FlexiFastAmplitudeIntegrator Class Reference

#include <FlexiFastAmplitudeIntegrator.h>

Inheritance diagram for FlexiFastAmplitudeIntegrator:

Public Member Functions
	FlexiFastAmplitudeIntegrator (const std::string &fastFlexiEventFileName="fastFlexiEventFileName.root")
	FlexiFastAmplitudeIntegrator (const DalitzEventPattern &pattern, IFastAmplitudeIntegrable *amps=0, MINT::IEventGenerator< IDalitzEvent > *eventGenerator=0, TRandom *rnd=0, double precision=1.e-2, const std::string &fastFlexiEventFileName="fastFlexiEventFileName.root")
bool	initialise (const DalitzEventPattern &pattern, IFastAmplitudeIntegrable *amps=0, MINT::IEventGenerator< IDalitzEvent > *eventGenerator=0, TRandom *rnd=0, double precision=1.e-2)
virtual bool	add (const FlexiFastAmplitudeIntegrator &other)
bool	setValues (const DalitzEventPattern &pattern, IFastAmplitudeIntegrable *amps=0, MINT::IEventGenerator< IDalitzEvent > *eventGenerator=0, TRandom *rnd=0, double precision=1.e-2)
void	setPrecision (double prec)
bool	initialised () const
double	getVal ()
double	RealVal ()
double	integralForMatchingPatterns (bool match, int pattern_sign)
std::complex< double >	ComplexIntegralForTags (int tag1, int tag2)
std::complex< double >	ComplexSumForMatchingPatterns (bool match)
double	sumOfSqrtFitFractions ()
double	sumOfFitFractions ()
double	absSumOfSqrtInterferenceFractions ()
double	absSumOfInterferenceFractions ()
int	numberOfFitFractionsLargerThanThreshold (double threshold)
FitFractionList	getFractions () const
FitFractionList	getInterferenceTerms () const
bool	doFractions ()
double	variance () const
DalitzHistoSet	histoSet () const
void	saveEachAmpsHistograms (const std::string &prefix) const
std::vector< DalitzHistoSet >	GetEachAmpsHistograms ()
DalitzHistoSet	interferenceHistoSet () const
void	saveInterferenceHistograms (const std::string &prefix) const
std::vector< DalitzHistoSet >	GetInterferenceHistograms ()
virtual void	doFinalStats (MINT::Minimiser *mini=0)
void	doFinalStatsAndSave (MINT::Minimiser *min=0, const std::string &fname="FitAmpResults.txt", const std::string &fnameROOT="fitFractions.root")
double	getFractionChi2 () const
bool	ensureFreshEvents ()
Public Member Functions inherited from MINT::IReturnReal
virtual	~IReturnReal ()

Protected Member Functions
void	forcedReIntegrate ()
void	reIntegrate ()
double	weight (IDalitzEvent *evtPtr)
int	updateEventSet (long int Nevents)
double	evaluateSum ()
int	determineNumEvents ()
int	generateEnoughEvents ()
void	addEvent (IDalitzEvent &evt)
void	reAddEvent (DalitzEvent &evt)
int	addEvents (long int Nevents)
TRandom *	makeNewRnd (int seed=-9999)
Protected Member Functions inherited from MINT::IReturnReal
	IReturnReal ()

Protected Attributes
DalitzEventList	_fastFlexiEventList
DalitzEventPattern	_pat
IFastAmplitudeIntegrable *	_amps
MINT::counted_ptr< FitAmpPairList >	_integCalc
MINT::counted_ptr< FitAmpPairList >	_integCalc_copyForDebug
TRandom *	_rnd
MINT::counted_ptr< TRandom >	_localRnd
double	_precision
MINT::IEventGenerator< IDalitzEvent > *	_generator

Private Attributes
double	_mean
int	_numEvents
int	_Ncalls
int	_NReEvaluations
double	_sumT
double	_sumTRe
double	_sumTfast
bool	_initialised
bool	_db

Static Private Attributes
static const long int	_minEvents =100

Detailed Description

Definition at line 32 of file FlexiFastAmplitudeIntegrator.h.

Constructor & Destructor Documentation

FlexiFastAmplitudeIntegrator() [1/2]

FlexiFastAmplitudeIntegrator::FlexiFastAmplitudeIntegrator

(

const std::string &

fastFlexiEventFileName = "fastFlexiEventFileName.root"

)

Definition at line 36 of file FlexiFastAmplitudeIntegrator.cpp.

  : _sumT(0.0), _sumTRe(0.0), _sumTfast(0.0), _initialised(0), _db(false)//, _fastFlexiEventList(fastFlexiEventFileName, "RECREATE")

{
  (void)fastFlexiEventFileName;
}

FlexiFastAmplitudeIntegrator() [2/2]

FlexiFastAmplitudeIntegrator::FlexiFastAmplitudeIntegrator	(	const DalitzEventPattern &	pattern,
		IFastAmplitudeIntegrable *	amps = 0,
		MINT::IEventGenerator< IDalitzEvent > *	eventGenerator = 0,
		TRandom *	rnd = 0,
		double	precision = 1.e-2,
		const std::string &	fastFlexiEventFileName = "fastFlexiEventFileName.root"
	)

Definition at line 22 of file FlexiFastAmplitudeIntegrator.cpp.

  : _Ncalls(0), _NReEvaluations(0), _sumT(0.0), _sumTRe(0.0), _sumTfast(0.0), _db(false)
    //  , _fastFlexiEventList(fastFlexiEventFileName, "RECREATE")
{
  initialise(pattern, amps, generator, rnd, precision);
  (void)fastFlexiEventFileName;
}

Member Function Documentation

absSumOfInterferenceFractions()

double FlexiFastAmplitudeIntegrator::absSumOfInterferenceFractions ( )

inline

Definition at line 161 of file FlexiFastAmplitudeIntegrator.h.

                                         {
        return _integCalc->absSumOfInterferenceFractions();
  }   

absSumOfSqrtInterferenceFractions()

double FlexiFastAmplitudeIntegrator::absSumOfSqrtInterferenceFractions ( )

inline

Definition at line 157 of file FlexiFastAmplitudeIntegrator.h.

                                             {
        return _integCalc->absSumOfSqrtInterferenceFractions();
  }   

add()

bool FlexiFastAmplitudeIntegrator::add ( const FlexiFastAmplitudeIntegrator &  other )

virtual

Definition at line 58 of file FlexiFastAmplitudeIntegrator.cpp.

                                                                               {
  int totalEvents = _numEvents + other._numEvents;
  _fastFlexiEventList.Add(other._fastFlexiEventList);

  if(totalEvents > 0){
    _mean = (_numEvents * _mean + other._numEvents * other._mean)/totalEvents;
  }
  _numEvents = totalEvents;
  _Ncalls   += other._Ncalls;
  _NReEvaluations   += other._NReEvaluations;
  _sumT     += other._sumT;
  _sumTRe   += other._sumTRe;
  _sumTfast += other._sumTfast;
  if(0 != this->_integCalc){
    _integCalc->add(other._integCalc);
  }else{
    if(0 != other._integCalc){
      counted_ptr<IntegCalculator> nL(new IntegCalculator(*(other._integCalc)));
      _integCalc = nL;
    }
  }
  if(0 != this->_integCalc_copyForDebug){
    _integCalc_copyForDebug->add(other._integCalc_copyForDebug);
  }else{
    if(0 != other._integCalc_copyForDebug){
      counted_ptr<IntegCalculator> 
    nLc(new IntegCalculator(*(other._integCalc_copyForDebug)));
      _integCalc_copyForDebug = nLc;
    }
  }
  _initialised |= other._initialised;
  _db |= other._db;

  // other quantities we take over if they aren't defined, here:
  if(0 == _amps) _amps = other._amps;
  if(0 == _rnd) _rnd = other._rnd;
  if(0 == _localRnd) _localRnd = other._localRnd;
  if(_precision <= 0.0) _precision = other._precision;

  return true;
}

addEvent()

void FlexiFastAmplitudeIntegrator::addEvent ( IDalitzEvent &  evt )

protected

Definition at line 211 of file FlexiFastAmplitudeIntegrator.cpp.

                                                            {
  _fastFlexiEventList.Add(evt);
  DalitzEvent& listEvent( _fastFlexiEventList[_fastFlexiEventList.size()-1] );
  _integCalc->addEvent(listEvent, weight(&listEvent));
}

addEvents()

int FlexiFastAmplitudeIntegrator::addEvents ( long int  Nevents )

protected

Definition at line 220 of file FlexiFastAmplitudeIntegrator.cpp.

                                                           {
  bool dbThis=false;
  if(dbThis) cout << "FlexiFastAmplitudeIntegrator::addEvents "
          << " got called " << endl;
  if(Nevents <= 0) return _integCalc->numEvents();

  if(0 == _generator){
    cout << "FlexiFastAmplitudeIntegrator::addEvents "
     << " adding flat events. " << endl;
    for(int i=0; i < Nevents; i++){
      DalitzEvent evt(_pat, _rnd);
      addEvent(evt);
    }
  }else{
    int N_success = 0;
    unsigned long int maxTries = (unsigned long int) Nevents * 1000;
    // dealing with possible overflow:
    if(maxTries < (unsigned long int) Nevents) maxTries = Nevents * 100;
    if(maxTries < (unsigned long int) Nevents) maxTries = Nevents * 10;
    if(maxTries < (unsigned long int) Nevents) maxTries = Nevents;

    time_t startTime = time(0);
    for(unsigned long int i=0; i < maxTries && N_success < Nevents; i++){
      counted_ptr<IDalitzEvent> ptr(_generator->newEvent());
      if(dbThis) cout << "got event with ptr: " << ptr << endl;
      if(0 == ptr){
    if(_generator->exhausted()){
      cout << "ERROR in FlexiFastAmplitudeIntegrator::addEvents"
           << "\n\t Generator exhausted, cannot generate more events."
           << endl;
      break;
    }
      }else{
    addEvent(*ptr);
    N_success++;
    int                    printEvery =   1000;
    if(N_success >  1000)  printEvery =  50000;
    if(N_success > 100000) printEvery = 100000;
    bool printout = (N_success%printEvery == 0);
    if(dbThis) printout |= (N_success < 20);

    if(printout){
      cout << " FlexiFastAmplitudeIntegrator::addEvents: added " << N_success 
           << " th event";
      evaluateSum();
      double v= variance();
      double sigma = -9999;
      if(v > 0) sigma = sqrt(v);
      cout << "\t integ= " << _mean << " +/- " << sigma;
      cout << "\t("
           << MINT::stringtime(difftime(time(0), startTime))
           << ")";
      cout << endl;
    }
      }
    }
  }
  if(_integCalc->numEvents() <  Nevents){
    cout << "ERROR in FlexiFastAmplitudeIntegrator::addEvents"
     << "\n\t> I was supposed to add " << Nevents << " events,"
     << "\n\t> but now the total list size is only " 
     << _integCalc->numEvents()
     << endl;
  }else{
    cout << " added " << Nevents << " _integCalc->numEvents "
     << _integCalc->numEvents() << endl;

  }
  return _integCalc->numEvents();
}

ComplexIntegralForTags()

std::complex<double> FlexiFastAmplitudeIntegrator::ComplexIntegralForTags ( int  tag1, int  tag2  )

inline

Definition at line 141 of file FlexiFastAmplitudeIntegrator.h.

                                                               {
        return _integCalc->ComplexIntegralForTags(tag1,tag2);
  }

ComplexSumForMatchingPatterns()

std::complex<double> FlexiFastAmplitudeIntegrator::ComplexSumForMatchingPatterns ( bool  match )

inline

Definition at line 145 of file FlexiFastAmplitudeIntegrator.h.

                                                              {
        return _integCalc->ComplexSumForMatchingPatterns(match);
  }

determineNumEvents()

int FlexiFastAmplitudeIntegrator::determineNumEvents ( )

protected

Definition at line 335 of file FlexiFastAmplitudeIntegrator.cpp.

                                                    {
  updateEventSet(_minEvents);
  evaluateSum();
  double v = variance();
  double safetyFactor = 1.15;
  double maxVariance = _precision*_precision * _mean*_mean;
  _numEvents = _integCalc->numEvents() * 
    (v*safetyFactor/maxVariance);
  // round to the nearest 100:
  _numEvents = (_numEvents/100 + 1)*100;

  cout << " FlexiFastAmplitudeIntegrator::determineNumEvents():"
       << "\n\t> mean: " << _mean << ", rms " << sqrt(v)
       << "\n\t> currently, our relative precision is " 
       << sqrt(v)/_mean
       << "\n\t> to achieve the requested pecision of " << _precision << ","
       << "\n\t> (with a safety factor) I think we'll need " 
       << (v*safetyFactor/maxVariance)
       << " times that, i.e. " << _numEvents << " events" << endl;

  return _numEvents;
}

doFinalStats()

void FlexiFastAmplitudeIntegrator::doFinalStats ( MINT::Minimiser *  mini = 0 )

virtual

Implements IDalitzIntegrator.

Definition at line 429 of file FlexiFastAmplitudeIntegrator.cpp.

                                                              {
  bool dbThis=true;
  if(dbThis) cout << "FlexiFastAmplitudeIntegrator::doFinalStats() called" << endl;
  _integCalc->setSlow(); // means it makes histograms
  forcedReIntegrate();
  _integCalc->doFinalStats(mini);
}

doFinalStatsAndSave()

void FlexiFastAmplitudeIntegrator::doFinalStatsAndSave	(	MINT::Minimiser *	min = 0,
		const std::string &	fname = "FitAmpResults.txt",
		const std::string &	fnameROOT = "fitFractions.root"
	)

Definition at line 437 of file FlexiFastAmplitudeIntegrator.cpp.

                                                                                                                        {
    bool dbThis=true;
    if(dbThis) cout << "FlexiFastAmplitudeIntegrator::doFinalStats() called" << endl;
    _integCalc->setSlow(); // means it makes histograms
    forcedReIntegrate();
    _integCalc->doFinalStatsAndSave(mini,fname,fnameROOT);
}

doFractions()

bool FlexiFastAmplitudeIntegrator::doFractions ( )

inline

Definition at line 171 of file FlexiFastAmplitudeIntegrator.h.

{return _integCalc->doFractions();}

ensureFreshEvents()

bool FlexiFastAmplitudeIntegrator::ensureFreshEvents

(

)

Definition at line 100 of file FlexiFastAmplitudeIntegrator.cpp.

                                                    {
  _rnd = makeNewRnd(time(0));
  if(0 != _generator){
    _generator->ensureFreshEvents();
  }
  return true;
}

evaluateSum()

double FlexiFastAmplitudeIntegrator::evaluateSum ( )

protected

Definition at line 294 of file FlexiFastAmplitudeIntegrator.cpp.

                                                {
  time_t tstart = time(0);
  //  _Ncalls++;

  _mean    = _integCalc->integral();
  double v = variance();
  double sigma = -9999;
  if(v >= 0) sigma = sqrt(v);
  double actualPrecision = -9999;
  if(_mean != 0 && sigma > 0) actualPrecision = sigma/_mean;

  double delT = difftime(time(0), tstart);

  int                  printEvery =    100;
  if(_Ncalls >   1000) printEvery =   1000;
  if(_Ncalls >  10000) printEvery =  10000;
  if(_Ncalls > 100000) printEvery = 100000;
  bool printout = _Ncalls < 3 || (0 == _Ncalls%printEvery);
 
  if(printout || _db){
    cout << " FlexiFastAmplitudeIntegrator::evaluateSum() for "
     << _integCalc->numEvents() << " events, "
     << _Ncalls << " th call:";
    cout << "\n\t> getting: " << _mean << " +/- " << sigma
     << "\n\t> precision: requested: " << _precision*100
     << "%, actual: " << actualPrecision*100 << "%"
     << "\n\t> This took " << delT << " s."
     << endl;
    if(_db){
      cout << "checking save and read-back:" << endl;
      _integCalc->save("checkSaveAndReadBack");
      _integCalc_copyForDebug->retrieve("checkSaveAndReadBack");
      cout << " copy values:"
       << "\n\t     mean: " << _integCalc_copyForDebug->integral()
       << "\n\t variance: " << _integCalc_copyForDebug->variance()
       << endl;
    }
  }
  return _mean;
}

forcedReIntegrate()

void FlexiFastAmplitudeIntegrator::forcedReIntegrate ( )

protected

Definition at line 183 of file FlexiFastAmplitudeIntegrator.cpp.

                                                    {
  _integCalc->startForcedReIntegration();
  for(unsigned int i=0; i < _fastFlexiEventList.size(); i++){
     reAddEvent(_fastFlexiEventList[i]);
   }
  _integCalc->endIntegration();
}

generateEnoughEvents()

int FlexiFastAmplitudeIntegrator::generateEnoughEvents ( )

protected

Definition at line 358 of file FlexiFastAmplitudeIntegrator.cpp.

                                                      {
  updateEventSet(_minEvents);
  int counter(0);
  while(determineNumEvents() > _integCalc->numEvents() &&
    counter < 10 && _numEvents > 0){
    updateEventSet(_numEvents);
    counter++;
  }
  return _integCalc->numEvents();
}

GetEachAmpsHistograms()

std::vector< DalitzHistoSet > FlexiFastAmplitudeIntegrator::GetEachAmpsHistograms

(

)

Definition at line 415 of file FlexiFastAmplitudeIntegrator.cpp.

                                                                             {
  return _integCalc->GetEachAmpsHistograms();
}

getFractionChi2()

double FlexiFastAmplitudeIntegrator::getFractionChi2

(

)

const

Definition at line 445 of file FlexiFastAmplitudeIntegrator.cpp.

                                                         {
  return _integCalc->getFractionChi2();
}

getFractions()

FitFractionList FlexiFastAmplitudeIntegrator::getFractions ( ) const

inline

Definition at line 169 of file FlexiFastAmplitudeIntegrator.h.

{return _integCalc->getFractions();}

GetInterferenceHistograms()

std::vector< DalitzHistoSet > FlexiFastAmplitudeIntegrator::GetInterferenceHistograms

(

)

Definition at line 425 of file FlexiFastAmplitudeIntegrator.cpp.

                                                                                 {
    return _integCalc->GetInterferenceHistograms();
}

getInterferenceTerms()

FitFractionList FlexiFastAmplitudeIntegrator::getInterferenceTerms ( ) const

inline

Definition at line 170 of file FlexiFastAmplitudeIntegrator.h.

{return _integCalc->getInterferenceTerms();}

getVal()

double FlexiFastAmplitudeIntegrator::getVal

(

)

Definition at line 369 of file FlexiFastAmplitudeIntegrator.cpp.

                                           {
  _Ncalls++;
  time_t tstart = time(0);
  double delT_slow, delT_fast, delT_total;
  if( _integCalc->needToReIntegrate() ){
    _NReEvaluations++;
    reIntegrate();
    delT_slow = difftime(time(0), tstart);
    _sumTRe += delT_slow;
  }
  time_t tstart_2 = time(0);
  evaluateSum();
  delT_total = difftime(time(0), tstart);
  delT_fast = difftime(time(0), tstart_2);
  _sumTfast += delT_fast;
    
  int                  printEvery =     10;
  if(_Ncalls >    100) printEvery =    100;
  if(_Ncalls >   1000) printEvery =   1000;
  if(_Ncalls >  10000) printEvery =  10000;
  if(_Ncalls > 100000) printEvery = 100000;
  bool printout = _Ncalls < 10 || (0 == _Ncalls%printEvery);

  if(_Ncalls > 0 && printout){
    cout << "FlexiFastAmplitudeIntegrator::getVal, " << _Ncalls << "th call: Returning " << _mean
     << ",  re-evaluation fraction = " << ((double) _NReEvaluations)/((double) _Ncalls)
     << "\n\t this call took " << delT_total << " s,"
     << "\n\t average call " << _sumT / _Ncalls;
    if(_NReEvaluations > 0) cout << ", average re-integration " << _sumTRe / _NReEvaluations;
    int delN = _Ncalls - _NReEvaluations;
    if(delN > 0){
      cout << ", average call w/o re-integration " << _sumTfast / delN;
    }
    cout << " ."  << endl;
  }

  return _mean;
}

histoSet()

DalitzHistoSet FlexiFastAmplitudeIntegrator::histoSet

(

)

const

Definition at line 408 of file FlexiFastAmplitudeIntegrator.cpp.

                                                           {
  
  return _integCalc->histoSet();
}

initialise()

bool FlexiFastAmplitudeIntegrator::initialise	(	const DalitzEventPattern &	pattern,
		IFastAmplitudeIntegrable *	amps = 0,
		MINT::IEventGenerator< IDalitzEvent > *	eventGenerator = 0,
		TRandom *	rnd = 0,
		double	precision = 1.e-2
	)

Definition at line 45 of file FlexiFastAmplitudeIntegrator.cpp.

          {
  bool sc=true;
  sc &= setValues(pattern, amps, generator, rnd, precision);
  sc &= generateEnoughEvents();
  return sc;
}

initialised()

bool FlexiFastAmplitudeIntegrator::initialised ( ) const

inline

Definition at line 127 of file FlexiFastAmplitudeIntegrator.h.

                          {
    return _initialised;
  }

integralForMatchingPatterns()

double FlexiFastAmplitudeIntegrator::integralForMatchingPatterns ( bool  match, int  pattern_sign  )

inline

Definition at line 137 of file FlexiFastAmplitudeIntegrator.h.

                                                                 {
        return _integCalc->integralForMatchingPatterns(match, pattern_sign);
  }

interferenceHistoSet()

DalitzHistoSet FlexiFastAmplitudeIntegrator::interferenceHistoSet

(

)

const

Definition at line 419 of file FlexiFastAmplitudeIntegrator.cpp.

                                                                       {
    return _integCalc->interferenceHistoSet();
}

makeNewRnd()

TRandom * FlexiFastAmplitudeIntegrator::makeNewRnd ( int  seed = -9999 )

protected

Definition at line 108 of file FlexiFastAmplitudeIntegrator.cpp.

                                                         {
  if(seed < -9998) seed = time(0);
  cout << "FlexiFastAmplitudeIntegrator::makeNewRnd with seed " << seed << endl;
  counted_ptr<TRandom> lr(new TRandom3(seed));
  _localRnd = lr;
  _rnd = lr.get();
  return _rnd;
}

numberOfFitFractionsLargerThanThreshold()

int FlexiFastAmplitudeIntegrator::numberOfFitFractionsLargerThanThreshold ( double  threshold )

inline

Definition at line 165 of file FlexiFastAmplitudeIntegrator.h.

                                                               {
        return _integCalc->numberOfFitFractionsLargerThanThreshold(threshold);
  } 

reAddEvent()

void FlexiFastAmplitudeIntegrator::reAddEvent ( DalitzEvent &  evt )

protected

Definition at line 216 of file FlexiFastAmplitudeIntegrator.cpp.

                                                             {
  _integCalc->reAddEvent(evt, weight(&evt));
}

RealVal()

double FlexiFastAmplitudeIntegrator::RealVal ( )

inlinevirtual

Implements MINT::IReturnReal.

Definition at line 133 of file FlexiFastAmplitudeIntegrator.h.

                  {
    return getVal();
  }

reIntegrate()

void FlexiFastAmplitudeIntegrator::reIntegrate ( )

protected

Definition at line 190 of file FlexiFastAmplitudeIntegrator.cpp.

                                              {
  _integCalc->startReIntegration();
  for(unsigned int i=0; i < _fastFlexiEventList.size(); i++){
     reAddEvent(_fastFlexiEventList[i]);
   }
  _integCalc->endIntegration();
}

saveEachAmpsHistograms()

void FlexiFastAmplitudeIntegrator::saveEachAmpsHistograms

(

const std::string &

prefix

)

const

Definition at line 412 of file FlexiFastAmplitudeIntegrator.cpp.

                                                                                      {
  return _integCalc->saveEachAmpsHistograms(prefix);
}

saveInterferenceHistograms()

void FlexiFastAmplitudeIntegrator::saveInterferenceHistograms

(

const std::string &

prefix

)

const

Definition at line 422 of file FlexiFastAmplitudeIntegrator.cpp.

                                                                                          {
    return _integCalc->saveInterferenceHistograms(prefix);
}

setPrecision()

void FlexiFastAmplitudeIntegrator::setPrecision ( double  prec )

inline

Definition at line 117 of file FlexiFastAmplitudeIntegrator.h.

                                {
    _precision=prec;
    if(initialised()){
      generateEnoughEvents();
    }
  }

setValues()

bool FlexiFastAmplitudeIntegrator::setValues	(	const DalitzEventPattern &	pattern,
		IFastAmplitudeIntegrable *	amps = 0,
		MINT::IEventGenerator< IDalitzEvent > *	eventGenerator = 0,
		TRandom *	rnd = 0,
		double	precision = 1.e-2
	)

Definition at line 117 of file FlexiFastAmplitudeIntegrator.cpp.

         {
  _pat  = pattern;
  _amps = amps;
  //_weight = weight;
  if(0 != rnd){
    _rnd = rnd;
  }else{
    _rnd = makeNewRnd(time(0));
  }
  _precision = precision;
  
  _generator = generator;

  //  _integCalc = amps->makeIntegCalculator();
  _integCalc = amps->makeFitAmpPairList();
  _integCalc->setFast();

  if(_db) _integCalc_copyForDebug = amps->makeFitAmpPairList();

  if(0 == _integCalc){
    cout << "ERROR in FlexiFastAmplitudeIntegrator::initialise"
     << " amps->makeIntegCalculator()"
     << " return NULL pointer!" << endl;
    cout << "\t This will go wrong." << endl;
  }
  _Ncalls=0;
  _NReEvaluations=0;
  _sumT     = 0.0;
  _sumTRe   = 0.0;
  _sumTfast = 0.0;

  _initialised = true;
  return _initialised;
}

sumOfFitFractions()

double FlexiFastAmplitudeIntegrator::sumOfFitFractions ( )

inline

Definition at line 153 of file FlexiFastAmplitudeIntegrator.h.

                             {
        return _integCalc->sumOfFitFractions();
  }  

sumOfSqrtFitFractions()

double FlexiFastAmplitudeIntegrator::sumOfSqrtFitFractions ( )

inline

Definition at line 149 of file FlexiFastAmplitudeIntegrator.h.

                                 {
        return _integCalc->sumOfSqrtFitFractions();
  }

updateEventSet()

int FlexiFastAmplitudeIntegrator::updateEventSet ( long int  Nevents )

protected

Definition at line 158 of file FlexiFastAmplitudeIntegrator.cpp.

                                                                {
  if(! _initialised){
    cout << " FlexiFastAmplitudeIntegrator::updateEventSet "
     << " need to know pattern first." << endl;
    return 0;
  }

  _integCalc->startIntegration();
  int missingEvents = Nevents - _integCalc->numEvents();

  if(missingEvents > 0){
    cout << "missing events: " << missingEvents 
     << " = " << Nevents 
     << " - " << _integCalc->numEvents()
     << endl;
    addEvents(missingEvents);
  }else{
    cout << "want " << Nevents
     << ", have " << _integCalc->numEvents()
     << ", so no more events missing." << endl;
  }
  _integCalc->endIntegration();
  return _integCalc->numEvents();
}

variance()

double FlexiFastAmplitudeIntegrator::variance

(

)

const

Definition at line 291 of file FlexiFastAmplitudeIntegrator.cpp.

                                                   {
  return _integCalc->variance();
}

weight()

double FlexiFastAmplitudeIntegrator::weight ( IDalitzEvent *  evtPtr )

protected

Definition at line 198 of file FlexiFastAmplitudeIntegrator.cpp.

                                                         {
  return 1;
  // (not in use, but left as a hook should the need arise)
  /*
  if(0 == _weight) return 1;

  _weight->setEvent(evtPtr);
  double wght = _weight->RealVal();
  _weight->resetEventRecord();
  return wght;
  */
}

Member Data Documentation

_amps

IFastAmplitudeIntegrable* FlexiFastAmplitudeIntegrator::_amps

protected

Definition at line 49 of file FlexiFastAmplitudeIntegrator.h.

_db

bool FlexiFastAmplitudeIntegrator::_db

private

Definition at line 42 of file FlexiFastAmplitudeIntegrator.h.

_fastFlexiEventList

DalitzEventList FlexiFastAmplitudeIntegrator::_fastFlexiEventList

protected

Definition at line 46 of file FlexiFastAmplitudeIntegrator.h.

_generator

MINT::IEventGenerator<IDalitzEvent>* FlexiFastAmplitudeIntegrator::_generator

protected

Definition at line 80 of file FlexiFastAmplitudeIntegrator.h.

_initialised

bool FlexiFastAmplitudeIntegrator::_initialised

private

Definition at line 40 of file FlexiFastAmplitudeIntegrator.h.

_integCalc

MINT::counted_ptr<FitAmpPairList> FlexiFastAmplitudeIntegrator::_integCalc

protected

Definition at line 55 of file FlexiFastAmplitudeIntegrator.h.

_integCalc_copyForDebug

MINT::counted_ptr<FitAmpPairList> FlexiFastAmplitudeIntegrator::_integCalc_copyForDebug

protected

Definition at line 57 of file FlexiFastAmplitudeIntegrator.h.

_localRnd

MINT::counted_ptr<TRandom> FlexiFastAmplitudeIntegrator::_localRnd

protected

Definition at line 60 of file FlexiFastAmplitudeIntegrator.h.

_mean

double FlexiFastAmplitudeIntegrator::_mean

mutableprivate

Definition at line 33 of file FlexiFastAmplitudeIntegrator.h.

_minEvents

const long int FlexiFastAmplitudeIntegrator::_minEvents =100

staticprivate

Definition at line 34 of file FlexiFastAmplitudeIntegrator.h.

_Ncalls

int FlexiFastAmplitudeIntegrator::_Ncalls

private

Definition at line 36 of file FlexiFastAmplitudeIntegrator.h.

_NReEvaluations

int FlexiFastAmplitudeIntegrator::_NReEvaluations

private

Definition at line 37 of file FlexiFastAmplitudeIntegrator.h.

_numEvents

int FlexiFastAmplitudeIntegrator::_numEvents

private

Definition at line 35 of file FlexiFastAmplitudeIntegrator.h.

_pat

DalitzEventPattern FlexiFastAmplitudeIntegrator::_pat

protected

Definition at line 48 of file FlexiFastAmplitudeIntegrator.h.

_precision

double FlexiFastAmplitudeIntegrator::_precision

protected

Definition at line 61 of file FlexiFastAmplitudeIntegrator.h.

_rnd

TRandom* FlexiFastAmplitudeIntegrator::_rnd

protected

Definition at line 59 of file FlexiFastAmplitudeIntegrator.h.

_sumT

double FlexiFastAmplitudeIntegrator::_sumT

private

Definition at line 39 of file FlexiFastAmplitudeIntegrator.h.

_sumTfast

double FlexiFastAmplitudeIntegrator::_sumTfast

private

Definition at line 39 of file FlexiFastAmplitudeIntegrator.h.

_sumTRe

double FlexiFastAmplitudeIntegrator::_sumTRe

private

Definition at line 39 of file FlexiFastAmplitudeIntegrator.h.

---

The documentation for this class was generated from the following files:

• Mint/FlexiFastAmplitudeIntegrator.h
• src/Mojito/DalitzIntegrator/FlexiFastAmplitudeIntegrator.cpp