C++ Observable::GetValue方法代码示例

	vector<double> getDistances( DataPoint * x, DataPoint * y )
	{
		vector<double> distances;
		vector<string> xListOfNames = x->GetAllNames();
		vector<string> yListOfNames = y->GetAllNames();
		vector<string>::iterator xIter = xListOfNames.begin();
		vector<string>::iterator yIter = yListOfNames.begin();
		Observable * xVar = 0;
		Observable * yVar = 0;
		while ( (xVar = x->GetObservable( *xIter ) ) && (yVar = y->GetObservable( *yIter ) ) ) {
			if ( (*xIter == "time" ) || (*xIter == "mass" )) {
				//cout << fabs(xVar->GetValue() - yVar->GetValue() ) << endl;
				distances.push_back( fabs(xVar->GetValue() - yVar->GetValue() ) );
			}
			else if ( (*xIter == "cosTheta") ) {
				distances.push_back( fabs(xVar->GetValue() - yVar->GetValue()) );
			}
			/*
			   else if(  (*xIter == "cosPsi") ) {
			   distances.push_back( fabs( xVar->GetValue() - yVar->GetValue() ) );
			   }
			   else if ( (*xIter == "phi") ) {
			   double diff = diffmod2pi( xVar->GetValue() - yVar->GetValue() );
			   distances.push_back( diff );
			   }
			 */
			++xIter, ++yIter;
			if ( xIter == xListOfNames.end() || yIter == yListOfNames.end() ) break;
		}
		return distances;
	}

//Use accept/reject method to create data
int Foam::GenerateData( int DataAmount )
{
	//if( newDataSet->GetDataNumber() < DataAmount ) newDataSet->ReserveDataSpace( DataAmount );
	for( int dataIndex = 0; dataIndex < DataAmount; ++dataIndex )
	{
		//Generate the discrete observables, and select the correct Foam generator to use
		int combinationIndex = 0;
		int incrementValue = 1;
		DataPoint * temporaryDataPoint = new DataPoint(allNames);
		for( int discreteIndex = int(discreteNames.size() - 1); discreteIndex >= 0; --discreteIndex )
		{
			//Create the discrete observable
			Observable * temporaryObservable = generationBoundary->GetConstraint( *discreteNames_ref[unsigned(discreteIndex)] )->CreateObservable(rootRandom);
			double currentValue = temporaryObservable->GetValue();
			temporaryDataPoint->SetObservable( *discreteNames_ref2[unsigned(discreteIndex)], temporaryObservable );
			delete temporaryObservable;

			//Calculate the index
			for (unsigned int valueIndex = 0; valueIndex < discreteValues[unsigned(discreteIndex)].size(); ++valueIndex )
			{
				if ( fabs( discreteValues[unsigned(discreteIndex)][valueIndex] - currentValue ) < DOUBLE_TOLERANCE )
				{
					combinationIndex += ( incrementValue * int(valueIndex) );
					incrementValue *= int(discreteValues[unsigned(discreteIndex)].size());
					break;
				}
			}
		}

		//Use the index calculated to select a Foam generator and generate an event with it
		Double_t* generatedEvent = new Double_t[ continuousNames.size() ];
		foamGenerators[unsigned(combinationIndex)]->MakeEvent();
		foamGenerators[unsigned(combinationIndex)]->GetMCvect(generatedEvent);

		//Store the continuous observables
		for (unsigned int continuousIndex = 0; continuousIndex < continuousNames.size(); ++continuousIndex )
		{
			string unit = generationBoundary->GetConstraint( *continuousNames_ref[continuousIndex] )->GetUnit();
			double newValue = minima[continuousIndex] + ( ranges[continuousIndex] * generatedEvent[continuousIndex] );
			temporaryDataPoint->SetObservable( *continuousNames_ref2[continuousIndex], newValue, unit );
			//cout << continuousNames[continuousIndex] << "\t" << newValue << "\t" << 0.0 << "\t" << unit << endl;
		}

		delete[] generatedEvent;
		//	Store the event
		temporaryDataPoint->SetDiscreteIndex(dataIndex);
		newDataSet->AddDataPoint(temporaryDataPoint);
	}

	//cout << "Destroying Generator(s)" << endl;
	//this->RemoveGenerator();
	return DataAmount;
}

		double getDistance(DataPoint * x, DataPoint * y)
		{
			double distance = 0.;
			double diff = 0.;	(void) diff;	//	Unused
			vector<string> xListOfNames = x->GetAllNames();
			vector<string> yListOfNames = y->GetAllNames();
			vector<string>::iterator xIter = xListOfNames.begin();
			vector<string>::iterator yIter = yListOfNames.begin();
			Observable * xVar = 0;
			Observable * yVar = 0;
			double xVal = 0.;
			double yVal = 0.;
			char buffer[100];	(void) buffer;	//	Unused
			while ( (xVar = x->GetObservable( *xIter ) ) && (yVar = y->GetObservable( *yIter ) ) ) {
				//cout << *xIter << endl;
				//if ( (*xIter == "time") ) {
				//	xVal = ( xVar->GetValue() - 1.6 )/1.2;
			    //	yVal = ( yVar->GetValue() - 1.6 )/1.2;
				//}
				if ( (*xIter == "mass") ) {
					xVal = ( xVar->GetValue() - 5200. )/350.;
					yVal = ( yVar->GetValue() - 5200. )/350.;
				}
				else if ( (*xIter == "cosTheta1") ) {
					xVal = ( xVar->GetValue() );
					yVal = ( yVar->GetValue() );
				}
				else if(  (*xIter == "cosTheta2") ) {
					xVal = ( xVar->GetValue() );
					yVal = ( yVar->GetValue() );
				}
				else if ( (*xIter == "phi") ) {
					xVal = ( xVar->GetValue() )/3.14159;
					yVal = ( yVar->GetValue() )/3.14159;
				}
				else {
					xVal = 0.;
					yVal = 0.;
				}
				distance += ( (xVal - yVal)*(xVal - yVal) );
				//sprintf(buffer, " %f %f %f", xVar->GetValue(), yVar->GetValue(), sqrt(distance));
				//cout << (*xIter) << buffer << endl;
				++xIter, ++yIter;
				if ( xIter == xListOfNames.end() || yIter == yListOfNames.end() ) break;
			}
			return sqrt(distance);
		}

        double getWeight( DataPoint * x )
        {
       		vector<string> xListOfNames = x->GetAllNames();
			vector<string>::iterator xIter = xListOfNames.begin();
			Observable * xVar = 0;
			double xVal = 1.;
			while ( ( xVar = x->GetObservable( *xIter ) ) ) {
                if ( (*xIter == "fsig_sw") ) {
					xVal = xVar->GetValue();
				}
				++xIter;
				if ( xIter == xListOfNames.end() ) break;
            }
            return xVal;
        }

	void updatePhaseSpaceBoundary( DataPoint * x, PhaseSpaceBoundary * newPhase, PhaseSpaceBoundary * oldPhase, vector<double> distances )
	{
		vector<string> xListOfNames = x->GetAllNames();
		vector<string>::iterator xIter = xListOfNames.begin();
		Observable * xVar = 0;
		double min = 0., max = 0.;
		int i = 0;
		char buffer[100];	(void) buffer;//	Unused

		while ( ( xVar = x->GetObservable( *xIter ) ) ) {
			if ( *xIter == "time" || *xIter == "cosTheta" || *xIter == "mass"){//|| *xIter == "cosPsi" || *xIter == "phi") {
				min = xVar->GetValue() - distances[ (unsigned)i ];
				max = xVar->GetValue() + distances[ (unsigned)i ];
				if ( min > oldPhase->GetConstraint( *xIter )->GetMinimum() ) ((ObservableContinuousConstraint *)newPhase->GetConstraint( *xIter ))->SetMinimum( min );
				if ( max < oldPhase->GetConstraint( *xIter )->GetMaximum() ) ((ObservableContinuousConstraint *)newPhase->GetConstraint( *xIter ))->SetMaximum( max );
				//cout << *xIter << " " << buffer << endl;
			}
			++xIter;
			if ( xIter == xListOfNames.end() ) break;
			i++;
			}
		}

//Returns whether a point is within the boundary
bool PhaseSpaceBoundary::IsPointInBoundary( DataPoint * TestDataPoint, bool silence )
{
	for (unsigned int nameIndex = 0; nameIndex < allNames.size(); ++nameIndex )
	{
		//Check if test Observable exists in the DataPoint
		Observable * testObservable = TestDataPoint->GetObservable( allNames[nameIndex], silence );
		if ( testObservable->GetUnit() == "NameNotFoundError" )
		{
			cerr << "Observable \"" << allNames[nameIndex] << "\" expected but not found" << endl;
			return false;
		}
		else
		{
			//Check if the Observable fits
			if ( !allConstraints[nameIndex]->CheckObservable(testObservable) )
			{
				return false;
			}
			else if( allConstraints[nameIndex]->IsDiscrete() )
			{
				vector<double> temp_vec = allConstraints[nameIndex]->GetValues();
				for( unsigned int i=0; i< temp_vec.size(); ++i )
				{
					if( fabs( testObservable->GetValue() - temp_vec[i] ) < DOUBLE_TOLERANCE_PHASE )
					{
						Observable* temp = new Observable( testObservable->GetName(), temp_vec[i], testObservable->GetUnit() );
						TestDataPoint->SetObservable( testObservable->GetName(), temp );
						delete temp;
					}
				}
			}
		}
	}

	//Point is within the boundary
	return true;
}