#include <DalitzBWBoxSet.h>

Inheritance diagram for DalitzBWBoxSet:

Public Member Functions
	DalitzBWBoxSet (MINT::IReturnRealForEvent< IDalitzEvent > amps=0, TRandom r=gRandom)

	DalitzBWBoxSet (TRandom *r)

	DalitzBWBoxSet (const DalitzBWBoxSet &other)

virtual	~DalitzBWBoxSet ()

void	add (DalitzBWBox &box)

void	add (DalitzBWBoxSet &boxes)

void	setPhaseSpaceFrac (double ps)

double	phaseSpaceFrac () const

void	setUnWeightPs (bool doSo=true)

virtual MINT::counted_ptr< DalitzEvent >	makeEventForOwner ()

virtual MINT::counted_ptr< DalitzEvent >	makeEventForOwner (int &nTries)

virtual MINT::counted_ptr< DalitzEvent >	makeWeightedEventForOwner ()

virtual MINT::counted_ptr< DalitzEvent >	makeWeightedEventForOwner (int &nTries)

virtual MINT::counted_ptr< DalitzEvent >	tryEventForOwner ()

virtual MINT::counted_ptr< DalitzEvent >	phaseSpaceEvent ()

virtual MINT::counted_ptr< IDalitzEvent >	newEvent ()

virtual MINT::counted_ptr< IDalitzEvent >	newUnweightedEvent ()

virtual bool	exhausted () const

double	phaseSpaceIntegral () const

double	fullPdf (DalitzEvent &evt)

double	genValueNoPs (const DalitzEvent &evt) const

double	genValuePs (const DalitzEvent &evt) const

double	genValueWithLoop (DalitzEvent &evt) const

double	genValue (const DalitzEvent &evt) const

void	print (std::ostream &os) const

bool	ensureFreshEvents ()

bool	setRnd (TRandom *rnd=gRandom)

bool	am_I_generating_what_I_think_I_am_generating (int Nevents=1000000)

bool	compareGenerationMethodsForFullPDF (int Nevents=1000000)

Public Member Functions inherited from MINT::PolymorphVector< DalitzBWBox >
	PolymorphVector ()

	PolymorphVector (unsigned int N)

	PolymorphVector (unsigned int N, const DalitzBWBox &c)

	PolymorphVector (const PolymorphVector &other)

	PolymorphVector (const typename std::vector< DalitzBWBox > &other)

virtual	~PolymorphVector ()

std::vector< DalitzBWBox > &	theVector ()

const std::vector< DalitzBWBox > &	theVector () const

DalitzBWBox &	operator[] (unsigned int i)

const DalitzBWBox &	operator[] (unsigned int i) const

DalitzBWBox &	at (unsigned int i)

const DalitzBWBox &	at (unsigned int i) const

std::vector< DalitzBWBox >::iterator	begin ()

std::vector< DalitzBWBox >::const_iterator	begin () const

std::vector< DalitzBWBox >::iterator	end ()

std::vector< DalitzBWBox >::const_iterator	end () const

std::vector< DalitzBWBox >::iterator	find (const DalitzBWBox &c)

std::vector< DalitzBWBox >::const_iterator	find (const DalitzBWBox &c) const

DalitzBWBox &	front ()

const DalitzBWBox &	front () const

DalitzBWBox &	back ()

const DalitzBWBox &	back () const

unsigned int	size () const

bool	empty () const

void	push_back (const DalitzBWBox &c)

void	pop_back ()

void	erase (typename std::vector< DalitzBWBox >::iterator pos)

void	erase (typename std::vector< DalitzBWBox >::iterator first, typename std::vector< DalitzBWBox >::iterator last)

PolymorphVector< DalitzBWBox > &	operator= (const PolymorphVector< DalitzBWBox > &other)

void	clear ()

void	resize (unsigned int N)

void	resize (unsigned int N, const DalitzBWBox &c)

	operator const typename std::vector< DalitzBWBox > & () const

	operator typename std::vector< DalitzBWBox > & ()

bool	operator== (const MINT::PolymorphVector< DalitzBWBox > &v2) const

bool	operator!= (const MINT::PolymorphVector< DalitzBWBox > &v2) const

bool	operator< (const MINT::PolymorphVector< DalitzBWBox > &v2) const

bool	operator> (const MINT::PolymorphVector< DalitzBWBox > &v2) const

Public Member Functions inherited from MINT::IUnweightedEventGenerator< IDalitzEvent >
virtual	~IUnweightedEventGenerator ()

Public Member Functions inherited from MINT::IEventGenerator< IDalitzEvent >
virtual	~IEventGenerator ()

Protected Member Functions
void	getReady ()

void	findMax ()

int	justThrowAwayData (double maxValue, MINT::IReturnRealForEvent< IDalitzEvent > *amps)

MINT::counted_ptr< DalitzEvent >	popEventFromList ()

void	set_psbox_height_and_weight ()

void	setup_psbox ()

double	VolumeSum () const

double	heightSum () const

void	makeVolumeProbIntervals ()

int	pickRandomVolume ()

double	calc_pick_ps_prob () const

double	pick_ps_prob ()

bool	checkIntegration () const

bool	ready () const

double	findMaxInList (double &sampleMax)

virtual MINT::counted_ptr< DalitzEvent >	makeWeightedApproxEventForOwner ()

virtual MINT::counted_ptr< DalitzEvent >	makeWeightedApproxEventForOwner (int &nTries)

Protected Attributes
DalitzEventPtrList	_eventPtrList

double	_maxWeightEstimate

double	_maxWeightInSample

MINT::IReturnRealForEvent< IDalitzEvent > *	_ampSum

bool	_ready

std::vector< double >	_volumeProbs

TRandom *	_rnd

double	_phaseSpaceFrac

double	_phaseSpaceIntegral

DalitzPhaseSpaceBox	_psbox

double	_pick_ps_prob

Protected Attributes inherited from MINT::PolymorphVector< DalitzBWBox >
std::vector< DalitzBWBox >	_vec

Static Protected Attributes
static double	__phaseSpaceFracDefaultValue =0.25

Detailed Description

Definition at line 23 of file DalitzBWBoxSet.h.

Constructor & Destructor Documentation

◆ DalitzBWBoxSet() [1/3]

DalitzBWBoxSet::DalitzBWBoxSet	(	MINT::IReturnRealForEvent< IDalitzEvent > *	amps = `0`,
		TRandom *	r = `gRandom`
	)

Definition at line 23 of file DalitzBWBoxSet.cpp.

   : MINT::PolymorphVector<DalitzBWBox>()
   , _maxWeightEstimate(-9999.0)
   , _maxWeightInSample(-9999.0)
   , _ampSum(amps)
   , _ready(false)
   , _volumeProbs()
   , _rnd(r)
   , _phaseSpaceFrac(DalitzBWBoxSet::__phaseSpaceFracDefaultValue)
   , _phaseSpaceIntegral(-9999)
   , _psbox()
   , _pick_ps_prob(-9999)
 {}

◆ DalitzBWBoxSet() [2/3]

DalitzBWBoxSet::DalitzBWBoxSet ( TRandom * r )

Definition at line 36 of file DalitzBWBoxSet.cpp.

   : MINT::PolymorphVector<DalitzBWBox>()
   , _maxWeightEstimate(-9999.0)
   , _maxWeightInSample(-9999.0)
   , _ampSum(0)
   , _ready(false)
   , _volumeProbs()
   , _rnd(r)
   , _phaseSpaceFrac(DalitzBWBoxSet::__phaseSpaceFracDefaultValue)
   , _phaseSpaceIntegral(-9999)
   , _psbox()
   , _pick_ps_prob(-9999)
 {}

◆ DalitzBWBoxSet() [3/3]

DalitzBWBoxSet::DalitzBWBoxSet ( const DalitzBWBoxSet & other )

Definition at line 50 of file DalitzBWBoxSet.cpp.

   : IEventGenerator<IDalitzEvent>()
   , IUnweightedEventGenerator<IDalitzEvent>()
   , MINT::PolymorphVector<DalitzBWBox>(other)
   , _eventPtrList(other._eventPtrList)
   , _maxWeightEstimate(other._maxWeightEstimate)
   , _maxWeightInSample(other._maxWeightInSample)
   , _ampSum(other._ampSum)
   , _ready(other._ready)
   , _volumeProbs(other._volumeProbs)
   , _rnd(other._rnd)
   , _phaseSpaceFrac(other._phaseSpaceFrac)
   , _phaseSpaceIntegral(other._phaseSpaceIntegral)
   , _psbox(other._psbox)
   , _pick_ps_prob(other._pick_ps_prob)
 {}

◆ ~DalitzBWBoxSet()

virtual DalitzBWBoxSet::~DalitzBWBoxSet ( )

inlinevirtual

Definition at line 79 of file DalitzBWBoxSet.h.

79 {}

Member Function Documentation

◆ add() [1/2]

void DalitzBWBoxSet::add ( DalitzBWBox & box )

Definition at line 77 of file DalitzBWBoxSet.cpp.

                                         {
   _ready = false;
   box.setRnd(_rnd);
   this->push_back(box);
 }

◆ add() [2/2]

void DalitzBWBoxSet::add ( DalitzBWBoxSet & boxes )

Definition at line 83 of file DalitzBWBoxSet.cpp.

                                              {
   _ready = false;
   for(unsigned int i=0; i<boxes.size(); i++){
     this->add(boxes[i]);
   }
 }

◆ am_I_generating_what_I_think_I_am_generating()

bool DalitzBWBoxSet::am_I_generating_what_I_think_I_am_generating ( int Nevents = 1000000 )

virtual

Reimplemented from MINT::IUnweightedEventGenerator< IDalitzEvent >.

Definition at line 119 of file DalitzBWBoxSet.cpp.

                                                                             {
   cout << "Hello from DalitzBWBoxSet::am_I_generating_what_I_think_I_am_generating"
        << " with " << Nevents << " events to generate for each case" << endl;
 
   DiskResidentEventList generated_approxPDF_events("generated_approxPDF_events.root"
                            , "RECREATE");
   DiskResidentEventList generatedFlat_weighted_approxPDF_events("generatedFlat_weighted_approxPDF_events.root"
                                 , "RECREATE");
 
   int printEvery = min(Nevents/10, 10000);
  
   for(int i=0; i < Nevents; i++){
     generated_approxPDF_events.Add(*makeWeightedApproxEventForOwner());
     if(0 == i%printEvery) cout << "done event " << i << endl;
   }
   cout << "generated approxPDF_events"<< endl;
 
   generated_approxPDF_events.save();
   DalitzHistoSet datGen= generated_approxPDF_events.weightedHistoSet();
   datGen.save("generated_approxPDF_histos.root");
   datGen.draw("generated_approxPDF_histos");
 
   int rwfactor=1;
   for(int i=0; i < Nevents*rwfactor; i++){
     counted_ptr<DalitzEvent> evtPtr(phaseSpaceEvent());
     evtPtr->setWeight(evtPtr->getWeight()*genValueNoPs(*evtPtr));
     generatedFlat_weighted_approxPDF_events.Add(*evtPtr);
     if(0 == i%(printEvery*rwfactor)) cout << "done event " << i << endl;
   }
   cout << "generated generatedFlat_weighted_approxPDF_events" << endl;
   generatedFlat_weighted_approxPDF_events.save();;
   DalitzHistoSet datWeight = generatedFlat_weighted_approxPDF_events.weightedHistoSet();
   datWeight.save("generatedFlat_weighted_approxPDF_histos.root");
   datWeight.draw("generatedFlat_weighted_approxPDF_histos");
   datGen.drawWithFitNorm(datWeight, "genDotsWeightLine_", "eps", "E1 SAME");
 
   DalitzHistoSet ratio(datGen);
   ratio /= datWeight;
   ratio.save("ratio_full_by_weight.root");
   ratio.draw("ratio_full_by_weight");
 
   
   cout << "DalitzBWBoxSet::am_I_generating_what_I_think_I_am_generating:"
        << " all done" << endl;
 
   return true;
 }

◆ calc_pick_ps_prob()

double DalitzBWBoxSet::calc_pick_ps_prob ( ) const

protected

Definition at line 237 of file DalitzBWBoxSet.cpp.

                                               {
   bool dbThis=false;
   if(_phaseSpaceFrac <= 0) return 0;
   double returnVal= _psbox.volume()/(_psbox.volume() + VolumeSum());
   if(dbThis){
     cout << "calc_pick_ps_prob() = "
      <<  _psbox.volume() << " / " << "(" 
      << _psbox.volume() << " + " <<  VolumeSum() << ")"
      << " = " << returnVal << endl;
   }
   return returnVal;
 }

◆ checkIntegration()

bool DalitzBWBoxSet::checkIntegration ( ) const

protected

Definition at line 103 of file DalitzBWBoxSet.cpp.

                                           {
   bool s=true;
 
   double prevV=0;
   for(unsigned int i=0; i< this->size(); i++){
     if(prevV == _volumeProbs[i]) continue;
     prevV=_volumeProbs[i];
     cout << "checking integration for box "
      << (*this)[i].name() << endl;
     s &= (*this)[i].checkIntegration();
     cout << "============================="
      << endl;
   }
   return s;
 }

◆ compareGenerationMethodsForFullPDF()

bool DalitzBWBoxSet::compareGenerationMethodsForFullPDF ( int Nevents = 1000000 )

virtual

Reimplemented from MINT::IUnweightedEventGenerator< IDalitzEvent >.

Definition at line 166 of file DalitzBWBoxSet.cpp.

                                                                   {
   cout << "Hello from DalitzBWBoxSet::compareGenerationMethodsForFullPDF"
        << " (with " << this->size() << " boxes)"
        << " with " << Nevents << " events to generate for each case" << endl;
 
   DiskResidentEventList generated_fullPDF_efficient_weighted_events("generated_fullPDF_efficient_weighted_events.root"
                            , "RECREATE");
   DiskResidentEventList generatedFlat_fullPDF_flat_weighted_events("generated_fullPDF_flat_weighted_events.root"
                                 , "RECREATE");
 
   bool unweightFull = false;
 
   int printEvery = min(Nevents/10, 10000);
  
   for(int i=0; i < Nevents; i++){
     if(unweightFull) {
       generated_fullPDF_efficient_weighted_events.Add(*makeEventForOwner());
     }else{
       generated_fullPDF_efficient_weighted_events.Add(*makeWeightedEventForOwner());
     }
     if(0 == i%printEvery) cout << "done event " << i << endl;
   }
   cout << "generated approxPDF_events"<< endl;
 
   generated_fullPDF_efficient_weighted_events.save();
   DalitzHistoSet datGen= generated_fullPDF_efficient_weighted_events.weightedHistoSet();
   datGen.save("generated_fullPDF_efficient_weighted_histos.root");
   datGen.draw("generated_fullPDF_efficient_weighted");
 
   int rwfactor=1;
   for(int i=0; i < Nevents*rwfactor; i++){
     counted_ptr<DalitzEvent> evtPtr(phaseSpaceEvent());
     evtPtr->setWeight(evtPtr->getWeight()*fullPdf(*evtPtr));
     generatedFlat_fullPDF_flat_weighted_events.Add(*evtPtr);
     if(0 == i%(printEvery*rwfactor)) cout << "done event " << i << endl;
   }
   cout << "generated generatedFlat_fullPDF_flat_weighted_events" << endl;
   generatedFlat_fullPDF_flat_weighted_events.save();;
   DalitzHistoSet datWeight = generatedFlat_fullPDF_flat_weighted_events.weightedHistoSet();
   datWeight.save("generated_fullPDF_efficient_weighted_histos.root");
   datWeight.draw("generated_fullPDF_efficient_weighted_events");
   datGen.drawWithFitNorm(datWeight, "efficientBlue_FlatRed_", "eps", "E1 SAME");
   
   DalitzHistoSet ratio(datGen);
   ratio /= datWeight;
   ratio.save("ratio_full_by_weight.root");
   ratio.draw("ratio_full_by_weight");
 
   cout << "DalitzBWBoxSet::compareGenerationMethodsForFullPDF:"
        << " all done" << endl;
 
   return true;
 }

◆ ensureFreshEvents()

bool DalitzBWBoxSet::ensureFreshEvents ( )

virtual

Implements MINT::IUnweightedEventGenerator< IDalitzEvent >.

Definition at line 98 of file DalitzBWBoxSet.cpp.

                                       {
   setRnd(_rnd); // safety paranoia - all boxes should be using this already
   _rnd->SetSeed(time(0)*2);
   return true;
 }

◆ exhausted()

virtual bool DalitzBWBoxSet::exhausted ( ) const

inlinevirtual

Implements MINT::IEventGenerator< IDalitzEvent >.

Definition at line 100 of file DalitzBWBoxSet.h.

100 {return false;}

◆ findMax()

void DalitzBWBoxSet::findMax ( )

protected

Definition at line 291 of file DalitzBWBoxSet.cpp.

                             {
   bool dbThis=false;
 
   time_t startTime = time(0);
   // int maxEvents = 100000;
   int maxEvents = 60000; // memory
   int maxTries = 9;
 
   bool speedupabit=true;
   if(speedupabit){
     maxEvents=50000;
     maxTries = 3;
   }
   bool speedupalot=false;
   if(speedupalot){
     maxEvents=30000;
     maxTries = 2;
   }
   bool instant=false; // set true for very fast & very dirty testing jobs etc;
   if(instant){
     maxEvents=5000;
     maxTries = 1;
   }
   //int maxEvents = 100000;
   //  maxEvents = 10000;
 
   cout << "DalitzBWBoxSet::findMax making starter set with "
        << maxEvents << " events." << endl;
 
   int numTries=0;
   _maxWeightEstimate=-9999; // estimated max from pareto
 
   while(_maxWeightEstimate < 0 || 
     (_maxWeightEstimate > _maxWeightInSample*2 
     && numTries < maxTries 
     && _eventPtrList.size() < 1000000)
     ){
     numTries++;
     cout << " DalitzBWBoxSet::findMax(): iteration number " << numTries 
      << " for estimated max of parent " << _maxWeightEstimate
      << " and max of current sample: " << _maxWeightInSample
      << endl;
     for(int i=0; i < maxEvents; i++){
       counted_ptr<DalitzEvent> evt(makeWeightedEventForOwner());
 
       unsigned int printEvery = 100000;
       if(i <= 10) printEvery=10;
       else if(i <= 100) printEvery=100;
       else if(i <= 1000) printEvery=1000;
       else if(i <= 100000) printEvery=10000;
       else if(i <= 1000000) printEvery=500000;
       
       if(i < 1 || i%printEvery == 0){
     cout << "DalitzBWBoxSet::findMax() "
          << "made event number " << i 
          << "\t (" << difftime(time(0), startTime) << " sec)"
          << endl;
       }
       if(dbThis && (0 != evt)) {
     cout << "DalitzBWBoxSet::findMax(): made event with weight "
          << evt->getWeight() << endl;
       }
       if(0 != evt) _eventPtrList.Add(evt);
     }
 
     cout << "DalitzBWBoxSet::findMax() starter set took "
      << difftime(time(0), startTime) << " s." << endl;
 
     _maxWeightEstimate = findMaxInList(_maxWeightInSample);
     //    _maxWeightEstimate = 60; // debug only june 2011
     //    break;  // debug only june 2011
   }
 
   if(_maxWeightEstimate > _maxWeightInSample*4
      || _maxWeightEstimate < _maxWeightInSample){
     _maxWeightEstimate = _maxWeightInSample*4;
   }
   //  _maxWeightEstimate = 60; // debug only june 2011
 
   if(dbThis){
     cout << "DalitzBWBoxSet::findMax(): I have now "
      << _eventPtrList.size()
      << " events in the eventPtrList." << endl;
     if( _eventPtrList.size() > 0){
       cout << "The first one is: " << _eventPtrList.getEventRef(0) << endl;
     }
   }
 
   //if(dbThis)_eventPtrList.save("eventListBeforeUnweighting.root");
 
   ReturnWeight w;
   justThrowAwayData(_maxWeightEstimate, &w);
 
   if(dbThis){
     cout << "DalitzBWBoxSet::findMax(): AFTER unweighting I have "
      << _eventPtrList.size()
      << " events in the eventPtrList." << endl;
     if( _eventPtrList.size() > 0){
       cout << "The first unweighted event is: " << _eventPtrList.getEventRef(0) << endl;
     }
   }
 
 
 
   /*
   _eventPtrList.findMaxAndThrowAwayData(_maxWeightEstimate, &w);
   */
 
   // we've un-weighted them, need to set weight correctly...
   for(unsigned int i=0; i < _eventPtrList.size(); i++){
     _eventPtrList.getEventRef(i).setWeight(1);
   }
 
   cout << "DalitzBWBoxSet::findMax() after throw away I have "
        << _eventPtrList.size() << " events left. Maximum weight estimate is: "
        << _maxWeightEstimate << endl;
 
   cout << "DalitzBWBoxSet::findMax() done after "
        << difftime(time(0), startTime) << " s." << endl;
   return;
 }

◆ findMaxInList()

double DalitzBWBoxSet::findMaxInList ( double & sampleMax )

protected

Definition at line 413 of file DalitzBWBoxSet.cpp.

                                                      {
   bool dbThis=false;
 
 
   time_t startTime = time(0);
   if(0 == _eventPtrList.size()) return -9999;
 
   std::vector<double> vals;
   vals.resize(_eventPtrList.size());
   sampleMax=-9999;
   for(unsigned int i=0; i < _eventPtrList.size(); i++){
     DalitzEvent& evt(_eventPtrList.getEventRef(i));
 
     double w = evt.getWeight();
     double d=w;
 
     if(dbThis) cout << "w = " << w << endl;
 
     if(d > sampleMax || 0 == i) sampleMax=d;
     vals[i] = d;
 
     
     unsigned int printEvery = _eventPtrList.size()/10;
     if(printEvery <=0) printEvery = 5;
     if(i <= 2) printEvery=1;
     else if(i <= 200) printEvery=100;
     
     if(i < 5 || 0 == i%(printEvery)){
       std::cout << "DalitzBWBoxSet::findMaxInList() calculated "
         << "_ampSum for event " 
         << i 
         << ", its value is " << d
         << std::endl;
       double deltaT = difftime(time(0), startTime);
       std::cout << " DalitzBWBoxSet::findMaxInList()this took " 
         << deltaT << " s";
       if(deltaT > 0){
     std::cout << "; rate (before throwing away) = " 
           << i/deltaT
           << " evts/s";
       }
       std::cout << std::endl;
     }
   };
   
   
   double epsilon = 0.2;
   //    sampleMax = sampleMax + fabs(sampleMax * epsilon);
   
   double CL = 1.0 - 1./(_eventPtrList.size()*10000);
   std::cout << "sampleMax = " << sampleMax << std::endl;
 
   double maxValue = generalisedPareto_estimateMaximum(vals, CL);
   std::cout << " maxValue after " << maxValue << std::endl;
   maxValue *= 1.0 + epsilon;
   std::cout << "DalitzBWBoxSet::findMaxInList():: Now added " 
         << epsilon * 100 << "% for safety. Returning "
         << maxValue << std::endl;
  
   return maxValue;
 }

◆ fullPdf()

double DalitzBWBoxSet::fullPdf ( DalitzEvent & evt )

Definition at line 67 of file DalitzBWBoxSet.cpp.

                                               { // (but w/o phase space factor)
   bool dbThis=false;
   if(dbThis) cout << "DalitzBWBoxSet::fullPdf called" << endl;
   if(0 == _ampSum) return 0;
   double returnVal = _ampSum->RealVal(evt);
   if(dbThis) cout << "DalitzBWBoxSet::fullPdf result: " 
           << returnVal << endl;
   return returnVal;
 }

◆ genValue()

double DalitzBWBoxSet::genValue ( const DalitzEvent & evt ) const

Definition at line 900 of file DalitzBWBoxSet.cpp.

                                                           {
   bool dbThis=false;
   double sum=0;
   sum = genValueNoPs(evt) * (1.0 - phaseSpaceFrac());
 
   if(dbThis) cout <<  "DalitzBWBoxSet::genValue sum before phase space " 
           << sum << endl;
   double ps = phaseSpaceFrac()*genValuePs(evt);
   if(dbThis) cout <<  "DalitzBWBoxSet::genValue adding ps = " 
           << ps << endl;
   sum += ps;
   if(dbThis) cout <<  "DalitzBWBoxSet::genValue sum after phase space " 
           << sum << endl;
    return sum;
 }

◆ genValueNoPs()

double DalitzBWBoxSet::genValueNoPs ( const DalitzEvent & evt ) const

Definition at line 856 of file DalitzBWBoxSet.cpp.

                                                               {
   bool dbThis=false;
   double sum=0;
   if(dbThis){
     cout << "DalitzBWBoxSet::genValueNoPs called with " << evt
      <<  endl;
   }
   
   if(this->empty()) return 0;
 
   for(unsigned int i=0; i<this->size(); i++){
     double val = (*this)[i].genValue(evt);
     if(dbThis){
       cout << "DalitzBWBoxSet::genValueNoPs adding " << (*this)[i].name()
        << " with " << val << endl;
     }
     sum += val;
   }
   if(phaseSpaceFrac() > 0)sum += _psbox.genValue();
 
   if(dbThis){
     cout << "DalitzBWBoxSet::genValueNoPs returning " << sum << endl;
   }
   return sum;
 }

◆ genValuePs()

double DalitzBWBoxSet::genValuePs ( const DalitzEvent & evt ) const

Definition at line 881 of file DalitzBWBoxSet.cpp.

                                                             {
   //bool dbThis=false;
   return evt.phaseSpace()/phaseSpaceIntegral();
 }

◆ genValueWithLoop()

double DalitzBWBoxSet::genValueWithLoop ( DalitzEvent & evt ) const

Definition at line 887 of file DalitzBWBoxSet.cpp.

                                                             {
   // for debug only
   //bool dbThis=false;
   double sum=0;
   for(int i=0; i < evt.numPermutations(); i++){
     evt.setPermutationIndex(i);
     sum += genValue(evt);
   }
   evt.setPermutationIndex(0);
   sum /= ((double) evt.numPermutations());
   return sum;
 }

◆ getReady()

void DalitzBWBoxSet::getReady ( )

protected

Definition at line 271 of file DalitzBWBoxSet.cpp.

                              {
   //  checkIntegration();
   bool dbThis=false;
   if(this->empty()) return;
   setup_psbox();
 
   makeVolumeProbIntervals();
   _eventPtrList.clear();
 
   // checkIntegration(); // for debug only
 
   if(dbThis){
     cout << "DalitzBWBoxSet::getReady() - got ready, result is this: "
      << (*this) << "\n ======= OK, no? ====== " << endl;
   }
   _ready=true;
   //  am_I_generating_what_I_think_I_am_generating(1000000); // for debug only
 
 }

◆ heightSum()

double DalitzBWBoxSet::heightSum ( ) const

protected

Definition at line 538 of file DalitzBWBoxSet.cpp.

                                       {
   bool dbThis=false;
 
   double sum = 0;
   for(unsigned int i=0; i< this->size(); i++){
     if(dbThis)cout << " height number " << i << ") " 
            << (*this)[i].height()
            << endl;
     sum += (*this)[i].height();
   }
 
   if(dbThis)cout << " Volume sum: " << sum;
   return sum;
 }

◆ justThrowAwayData()

int DalitzBWBoxSet::justThrowAwayData	(	double	maxValue,
		MINT::IReturnRealForEvent< IDalitzEvent > *	amps
	)

protected

Definition at line 475 of file DalitzBWBoxSet.cpp.

                        {
   //  bool dbThis=true;
   std::cout << "EventPtrList::justThrowAwayData:"
         << " before throwing away data, my size is " 
         << _eventPtrList.size() << std::endl;
   
   time_t startTime = time(0);
   
   int rememberSize = _eventPtrList.size();
   unsigned int counter=0;
   
   DalitzEventPtrList newList;
   
   for(unsigned int i=0; i < _eventPtrList.size(); i++){
     double d=amps->RealVal(_eventPtrList.getEventRef(i));
     if(_rnd->Rndm()*maxValue < d){
       newList.Add( _eventPtrList.getEventRef(counter) );
     }
     
     unsigned int printEvery = 10000; //size()/10;
     //if(printEvery <=0) printEvery = 500;
     //    if(counter <= 2) printEvery=1;
     //else if(counter <= 200) printEvery=10000;
     
     if(counter < 1 || 0 == counter%(printEvery)){
       std::cout << " amps for event " 
         << counter 
         << ": " << d
         << ".  "  << newList.size() 
         << " events passed ";
       double deltaT = difftime(time(0), startTime);
       std::cout << ". Took " << deltaT << " s";
       
       if(deltaT > 0){
     std::cout << "; rate (before/after throwing away) = " 
           << counter/deltaT
           << " / " << newList.size()/deltaT
           << " evts/s";   
       }
       std::cout << std::endl;
     }
     counter++;
   };
   
   _eventPtrList = newList;
   std::cout << "now my size has changed to " << _eventPtrList.size()
         << std::endl;
   std::cout << " So the waste factor is ";
   if(size() > 0) std::cout << rememberSize/_eventPtrList.size();
   else std::cout << " infinity! - that's big!";
   std::cout << std::endl;
   
   
   double deltaTFinal = difftime(time(0), startTime);
   std::cout << " this took " << deltaTFinal/60.0 << " min" << std::endl;
   
   return _eventPtrList.size();
 }

◆ makeEventForOwner() [1/2]

counted_ptr< DalitzEvent > DalitzBWBoxSet::makeEventForOwner ( )

virtual

Definition at line 670 of file DalitzBWBoxSet.cpp.

                                                           {
   int NTries = 0;
   return makeEventForOwner(NTries);
 }

◆ makeEventForOwner() [2/2]

counted_ptr< DalitzEvent > DalitzBWBoxSet::makeEventForOwner ( int & nTries )

virtual

Definition at line 674 of file DalitzBWBoxSet.cpp.

                                                                      {
 //   bool dbThis=false;
   static unsigned int Ncalls=0;
   static unsigned int printEveryNthCall = 10000;
 
   Ncalls++;
   bool printThis = Ncalls < 3 || (0 == Ncalls%printEveryNthCall);
   
   NTries = 0;
   if(! _ready) getReady();
   if(_maxWeightEstimate < 0) findMax();
 //   if(dbThis) cout << "makeEventForOwner found max" << endl;
   if(_eventPtrList.size() > 0){
 //     if(dbThis) cout << "popping Event" << endl;
     return popEventFromList();
   }
 //   if(dbThis) cout << "making new event" << endl;
   counted_ptr<DalitzEvent> evtPtr(0);
   
   int counter=0;
   int maxCount = 1000000;
   int countProblems = 0;
   do{
     int tempTries=0;
     counter++;
     if(counter > maxCount){
       cout << "DalitzBWBoxSet::makeEventForOwner tried "
        << counter << " times unsuccessfully. Giving up"
        << endl;
       return evtPtr;
     }
     evtPtr = makeWeightedEventForOwner(tempTries);
     NTries += tempTries;
     double w = -9999.0;
     if(0 != evtPtr) w = evtPtr->getWeight();
     if(w > _maxWeightInSample) _maxWeightInSample=w;
     if(w > _maxWeightEstimate){
       countProblems++;
       cout << "DalitzBWBoxSet::makeEventForOwner ERROR!!! "
        << " for the " << countProblems << " th time. "
        << "\n\t This event's weight > max Weight: "
        << evtPtr->getWeight() << " > " << _maxWeightEstimate
        << endl;
       _maxWeightEstimate = evtPtr->getWeight()*1.3;
       cout << "\n\t...increased _maxWeightEstimate to: " 
        << _maxWeightEstimate
        << endl;
     }
   }while(0 == evtPtr || _rnd->Rndm()*_maxWeightEstimate > evtPtr->getWeight());
   
   if(printThis){
     cout << "DalitzBWBoxSet::makeEventForOwner INFO after "
      << Ncalls << " calls."
      << " Estimate of max weight " << _maxWeightEstimate
      << " max weight in sample so far " << _maxWeightInSample
      << "." << endl;
   }
 
   if(0 != evtPtr) evtPtr->setWeight(1);
   return evtPtr;
 }

◆ makeVolumeProbIntervals()

void DalitzBWBoxSet::makeVolumeProbIntervals ( )

protected

Definition at line 573 of file DalitzBWBoxSet.cpp.

                                             {
   bool dbThis=false;
 
   if(this->empty()) return;
   // intervals each with a length proportional
   // to the volume of the corresponding box.
   // All put together add up to one.
   // For random number generation.
 
   _volumeProbs.clear();
   _volumeProbs.resize(this->size());
 
   double totalVolume = VolumeSum();
   double sum=0;
   for(unsigned int i=0; i < this->size(); i++){
     //    (*this)[i].height() *= 1./totalVolume;
     sum += (*this)[i].volume()/totalVolume;
     if(dbThis){
       // cout << " with height " << (*this)[i].height();
       cout << " + " << (*this)[i].volume()/totalVolume;
       cout << " = \t volume probs [" << i <<"] = " << sum << endl;
     }
     _volumeProbs[i] = sum;
   }
 }

◆ makeWeightedApproxEventForOwner() [1/2]

counted_ptr< DalitzEvent > DalitzBWBoxSet::makeWeightedApproxEventForOwner ( )

protectedvirtual

Definition at line 785 of file DalitzBWBoxSet.cpp.

                                                                         {
   int NTries = 0;
   return makeWeightedApproxEventForOwner(NTries);
 }

◆ makeWeightedApproxEventForOwner() [2/2]

counted_ptr< DalitzEvent > DalitzBWBoxSet::makeWeightedApproxEventForOwner ( int & nTries )

protectedvirtual

Definition at line 789 of file DalitzBWBoxSet.cpp.

                                                                                    {
   //bool dbThis=false;
   counted_ptr<DalitzEvent> ptr(0);
   int maxTries = 10000000;
   NTries = 0;
   while((! ptr) && NTries < maxTries){
     ptr=tryEventForOwner();
     NTries++;
   }
   if(! ptr){ 
     cout << "ERROR in DalitzBWBoxSet::makeWeightedEventForOwner() "
      << " failed to make event after " << maxTries
      << " tries!"
      << endl;
     return ptr;
   }
   return ptr;
 }

◆ makeWeightedEventForOwner() [1/2]

counted_ptr< DalitzEvent > DalitzBWBoxSet::makeWeightedEventForOwner ( )

virtual

Definition at line 760 of file DalitzBWBoxSet.cpp.

                                                                   {
   int NTries = 0;
   return makeWeightedEventForOwner(NTries);
 }

◆ makeWeightedEventForOwner() [2/2]

counted_ptr< DalitzEvent > DalitzBWBoxSet::makeWeightedEventForOwner ( int & nTries )

virtual

Definition at line 764 of file DalitzBWBoxSet.cpp.

                                                                              {
 //   bool dbThis=false;
   counted_ptr<DalitzEvent> ptr(makeWeightedApproxEventForOwner(NTries));
   if(! ptr) return ptr;
   double w = ptr->getWeight();
 //   if(dbThis) cout << "phase space weight " << w << endl;
 
   double full = fullPdf(*ptr);
   double gen  = genValueNoPs(*ptr);
 //   if(dbThis) cout << ", full weight " << w 
 //        << " * " << full << " / " << gen << " = ";
 
   w *= full/gen;
 //   if(dbThis) cout << w << endl;
 
   ptr->setWeight(w);
   ptr->setGeneratorPdfRelativeToPhaseSpace(full);
 
   return ptr;
 }

◆ newEvent()

counted_ptr< IDalitzEvent > DalitzBWBoxSet::newEvent ( )

virtual

Implements MINT::IUnweightedEventGenerator< IDalitzEvent >.

Definition at line 736 of file DalitzBWBoxSet.cpp.

                                                   {
   bool dbThis=false;
   if(! dbThis){
     counted_ptr<IDalitzEvent> returnThis(makeWeightedEventForOwner());
     return returnThis;
   } else {
     counted_ptr<IDalitzEvent> returnThis(tryEventForOwner());
     return returnThis;
   }
 }

◆ newUnweightedEvent()

counted_ptr< IDalitzEvent > DalitzBWBoxSet::newUnweightedEvent ( )

virtual

Implements MINT::IUnweightedEventGenerator< IDalitzEvent >.

Definition at line 746 of file DalitzBWBoxSet.cpp.

                                                             {
   counted_ptr<IDalitzEvent> returnThis(makeEventForOwner());
   return returnThis;
 }

◆ phaseSpaceEvent()

counted_ptr< DalitzEvent > DalitzBWBoxSet::phaseSpaceEvent ( )

virtual

Definition at line 620 of file DalitzBWBoxSet.cpp.

                                                         {
   if(this->empty()) return counted_ptr<DalitzEvent>(0);
   if(! ready()) getReady();
   return _psbox.makeEventForOwner();
 }

◆ phaseSpaceFrac()

double DalitzBWBoxSet::phaseSpaceFrac ( ) const

inline

Definition at line 85 of file DalitzBWBoxSet.h.

85 {return _phaseSpaceFrac;}

DalitzBWBoxSet::_phaseSpaceFrac

double _phaseSpaceFrac

Definition: DalitzBWBoxSet.h:40

◆ phaseSpaceIntegral()

double DalitzBWBoxSet::phaseSpaceIntegral ( ) const

Definition at line 809 of file DalitzBWBoxSet.cpp.

                                               {
   // mainly for debug.
   bool dbThis=false;
 
   if(_phaseSpaceIntegral > 0) return _phaseSpaceIntegral;
   if(this->empty())return -9999;
 
   if(dbThis) cout << " calculating phaseSpaceIntegral " << endl;
   DalitzEventPattern pat = (*this)[0].pattern();
   DalitzBWBox box(pat);
 
   PhaseSpaceIntegral4body p4;
   cout << "compare to " << p4.getVal(pat) << endl;
 
   int maxEvents =  10000;
   int maxTries  =  10000 * maxEvents;
   int nTries=0;
   double sum=0, sumsq=0;
   for(int i=0; i < maxEvents && nTries < maxTries; i++){
     int triesForThisEvent=0;
     counted_ptr<DalitzEvent> ptr(box.makeEventForOwner(triesForThisEvent));
     nTries += triesForThisEvent;
     if(! ptr) continue;
     double val = ptr->phaseSpace();
     sum += val;
     sumsq += val*val;
     if(dbThis && (0 == i%1000 || i < 100)){
       cout << " i = " << i << ", nTries = " << nTries 
        << " val = " << val << " sum " << sum << endl;
     }
   }
   double mean = sum/((double)nTries);
   double meanOfSq = sumsq/((double)nTries);
   double variance = meanOfSq - mean*mean;
   double error = sqrt(variance)/sqrt((double)nTries);
 
   _phaseSpaceIntegral = sum/((double)nTries) * box.area().size();
   //  _phaseSpaceIntegral = sum/((double)maxEvents);// * box.volume();
   //  double psVolume = box.volume() * ((double)maxEvents)/((double)nTries);
   //double psVolume = box.volume();
   //_phaseSpaceIntegral = sum/((double)maxEvents);// * psVolume;
   cout << "phaseSpaceIntegral: returning " << _phaseSpaceIntegral
        << " relativeError: " << error/mean * 100 << "%" << endl;
 
   return _phaseSpaceIntegral;
 }

◆ pick_ps_prob()

double DalitzBWBoxSet::pick_ps_prob ( )

protected

Definition at line 249 of file DalitzBWBoxSet.cpp.

                                    {
   bool dbThis=false;
   if(_phaseSpaceFrac <= 0) return 0;
   if(_pick_ps_prob < 0){
     _pick_ps_prob = calc_pick_ps_prob();
     if(dbThis){
       cout << " DalitzBWBoxSet::pick_ps_prob() = " << _pick_ps_prob << endl;
     }
   }
   return _pick_ps_prob;  
 }

◆ pickRandomVolume()

int DalitzBWBoxSet::pickRandomVolume ( )

protected

Definition at line 599 of file DalitzBWBoxSet.cpp.

                                     {
   if(! ready()) getReady();
 
   if(_volumeProbs.size() != this->size()){
     makeVolumeProbIntervals();
   }
 
   double rndNumber = _rnd->Rndm();
   for(unsigned int i=0; i< _volumeProbs.size(); i++){
     if(_volumeProbs[i] > rndNumber) return i;
   }
   cout << "WARNING in DalitzBWBoxSet::pickRandomVolume():"
        << " How odd - should never have gotten here."
        << " rndNumber = " << rndNumber
        << ", _volumeProbs[this->size()-1] = "
        << _volumeProbs[this->size()-1]
        << endl;
   return this->size()-1;
 }

◆ popEventFromList()

counted_ptr< DalitzEvent > DalitzBWBoxSet::popEventFromList ( )

protected

Definition at line 751 of file DalitzBWBoxSet.cpp.

                                                          {
   if(_eventPtrList.empty()){
     return counted_ptr<DalitzEvent>(0);
   }
   //  counted_ptr<DalitzEvent> evt(new DalitzEvent(_eventPtrList.getEventRef(_eventPtrList.size()-1]));
   //_eventPtrList.resize(_eventPtrList.size()-1);
   return _eventPtrList.popLastEventPtr();
 }

◆ print()

void DalitzBWBoxSet::print ( std::ostream & os ) const

Definition at line 915 of file DalitzBWBoxSet.cpp.

                                            {
   for(unsigned int i=0; i < this->size(); i++){
     os << " box " << i << " )" << (*this)[i] << "\n";
   }
   return;
 }

◆ ready()

bool DalitzBWBoxSet::ready ( ) const

inlineprotected

Definition at line 66 of file DalitzBWBoxSet.h.

66 {return _ready;}

DalitzBWBoxSet::_ready

bool _ready

Definition: DalitzBWBoxSet.h:36

◆ set_psbox_height_and_weight()

void DalitzBWBoxSet::set_psbox_height_and_weight ( )

protected

Definition at line 220 of file DalitzBWBoxSet.cpp.

                                                 {
   bool dbThis=false;
   if(phaseSpaceFrac() <= 0) return;
   
   double rat = calc_pick_ps_prob()/phaseSpaceFrac();
   double w=1;
   if(rat > 0) w=rat;
   _psbox.weight() *= w;
   _psbox.height() /= w;
 
   if(dbThis){
     cout << "h " << _psbox.height() 
      << ", w " << _psbox.weight()
      << endl;
   }
 }

◆ setPhaseSpaceFrac()

void DalitzBWBoxSet::setPhaseSpaceFrac ( double ps )

inline

Definition at line 84 of file DalitzBWBoxSet.h.

84 {_phaseSpaceFrac = ps; getReady();}

DalitzBWBoxSet::_phaseSpaceFrac

double _phaseSpaceFrac

Definition: DalitzBWBoxSet.h:40

DalitzBWBoxSet::getReady

void getReady()

Definition: DalitzBWBoxSet.cpp:271

◆ setRnd()

bool DalitzBWBoxSet::setRnd ( TRandom * rnd = gRandom )

virtual

Implements MINT::IUnweightedEventGenerator< IDalitzEvent >.

Definition at line 89 of file DalitzBWBoxSet.cpp.

                                        {
   if(0 == rnd) _rnd = gRandom;
   else _rnd = rnd; // this *should* do it, but for safety:
   for(unsigned int i=0; i< this->size(); i++){
     (*this)[i].setRnd(_rnd);
   }
   return true;
 }

◆ setUnWeightPs()

void DalitzBWBoxSet::setUnWeightPs ( bool doSo = true )

Definition at line 567 of file DalitzBWBoxSet.cpp.

                                            {
   for(unsigned int i=0; i< this->size(); i++){
     (*this)[i].setUnWeightPs(doSo);
   }
 }

◆ setup_psbox()

void DalitzBWBoxSet::setup_psbox ( )

protected

Definition at line 261 of file DalitzBWBoxSet.cpp.

                                 {
   _psbox.setPattern(this->begin()->pattern());
 
   _psbox.height()=phaseSpaceFrac()*heightSum()/(1.0-phaseSpaceFrac());
   _psbox.weight()=1.0;
   for(int i=0; i < 100; i++){
     set_psbox_height_and_weight();
   }
 }

◆ tryEventForOwner()

counted_ptr< DalitzEvent > DalitzBWBoxSet::tryEventForOwner ( )

virtual

Definition at line 626 of file DalitzBWBoxSet.cpp.

                                                          {
 //   bool dbThis=false;
   if(this->empty()){
     cout << "DalitzBWBoxSet::tryEventForOwner ERROR: "
      << " you called me, but there are no boxes"
      << "\n\t returning 0-ptr" << endl;
     return counted_ptr<DalitzEvent>(0);
   }
   if(! ready()) getReady();
 
   counted_ptr<DalitzEvent> evtPtr(0);
   if(_rnd->Rndm() < pick_ps_prob()){
     evtPtr = phaseSpaceEvent();
 /*    if(dbThis){
       cout << "picked phaseSpace " << endl;
     }*/
   }else{
     int vol = pickRandomVolume();
     evtPtr = ((*this)[vol].tryEventForOwner());
 /*    if(dbThis){
       cout << "picked volume number: " << vol << endl;
     }*/
   }
 /*  if(dbThis && 0 != evtPtr){
     cout << "weight in DalitzBWBoxSet::tryEventForOwner() "
      << evtPtr->getWeight() << endl;
   }*/
   if(0 != evtPtr){
 /*    if(dbThis) {
       cout << "DalitzBWBoxSet::tryEventForOwner() calling:"
        << " setGeneratorPdfRelativeToPhaseSpace(genValueNoPs(*evtPtr))"
        << endl;
     }*/
     evtPtr->setGeneratorPdfRelativeToPhaseSpace(genValueNoPs(*evtPtr));
 //     if(dbThis) cout <<  " .. done that." << endl;
   }
 /*  if(dbThis){
     cout << " DalitzBWBoxSet::tryEventForOwner(): Returning " << evtPtr << endl;
     if(0 != evtPtr){
       cout << " ... with weight " << evtPtr->getWeight() << endl;
     }
   }*/
   return evtPtr;
 }

◆ VolumeSum()

double DalitzBWBoxSet::VolumeSum ( ) const

protected

Definition at line 552 of file DalitzBWBoxSet.cpp.

                                       {
   bool dbThis=false;
 
   double sum = 0;
   for(unsigned int i=0; i< this->size(); i++){
     if(dbThis)cout << " volume number " << i << ") " 
            << (*this)[i].volume()
            << endl;
     sum += (*this)[i].volume();
   }
 
   if(dbThis)cout << " Volume sum: " << sum;
   return sum;
 }

Member Data Documentation

◆ __phaseSpaceFracDefaultValue

double DalitzBWBoxSet::__phaseSpaceFracDefaultValue =0.25

staticprotected

Definition at line 26 of file DalitzBWBoxSet.h.

◆ _ampSum

MINT::IReturnRealForEvent<IDalitzEvent>* DalitzBWBoxSet::_ampSum

protected

Definition at line 34 of file DalitzBWBoxSet.h.

◆ _eventPtrList

DalitzEventPtrList DalitzBWBoxSet::_eventPtrList

protected

Definition at line 28 of file DalitzBWBoxSet.h.

◆ _maxWeightEstimate

double DalitzBWBoxSet::_maxWeightEstimate

protected

Definition at line 31 of file DalitzBWBoxSet.h.

◆ _maxWeightInSample

double DalitzBWBoxSet::_maxWeightInSample

protected

Definition at line 32 of file DalitzBWBoxSet.h.

◆ _phaseSpaceFrac

double DalitzBWBoxSet::_phaseSpaceFrac

protected

Definition at line 40 of file DalitzBWBoxSet.h.

◆ _phaseSpaceIntegral

double DalitzBWBoxSet::_phaseSpaceIntegral

mutableprotected

Definition at line 41 of file DalitzBWBoxSet.h.

◆ _pick_ps_prob

double DalitzBWBoxSet::_pick_ps_prob

protected

Definition at line 44 of file DalitzBWBoxSet.h.

◆ _psbox

DalitzPhaseSpaceBox DalitzBWBoxSet::_psbox

protected

Definition at line 43 of file DalitzBWBoxSet.h.

◆ _ready

bool DalitzBWBoxSet::_ready

protected

Definition at line 36 of file DalitzBWBoxSet.h.

◆ _rnd

TRandom* DalitzBWBoxSet::_rnd

protected

Definition at line 38 of file DalitzBWBoxSet.h.

◆ _volumeProbs

std::vector<double> DalitzBWBoxSet::_volumeProbs

protected

Definition at line 37 of file DalitzBWBoxSet.h.

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

Mint/DalitzBWBoxSet.h
src/Mojito/BreitWignerMC/DalitzBWBoxSet.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ DalitzBWBoxSet() [1/3]

◆ DalitzBWBoxSet() [2/3]

◆ DalitzBWBoxSet() [3/3]

◆ ~DalitzBWBoxSet()

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ am_I_generating_what_I_think_I_am_generating()

◆ calc_pick_ps_prob()

◆ checkIntegration()

◆ compareGenerationMethodsForFullPDF()

◆ ensureFreshEvents()

◆ exhausted()

◆ findMax()

◆ findMaxInList()

◆ fullPdf()

◆ genValue()

◆ genValueNoPs()

◆ genValuePs()

◆ genValueWithLoop()

◆ getReady()

◆ heightSum()

◆ justThrowAwayData()

◆ makeEventForOwner() [1/2]

◆ makeEventForOwner() [2/2]

◆ makeVolumeProbIntervals()

◆ makeWeightedApproxEventForOwner() [1/2]

◆ makeWeightedApproxEventForOwner() [2/2]

◆ makeWeightedEventForOwner() [1/2]

◆ makeWeightedEventForOwner() [2/2]

◆ newEvent()

◆ newUnweightedEvent()

◆ phaseSpaceEvent()

◆ phaseSpaceFrac()

◆ phaseSpaceIntegral()

◆ pick_ps_prob()

◆ pickRandomVolume()

◆ popEventFromList()

◆ print()

◆ ready()

◆ set_psbox_height_and_weight()

◆ setPhaseSpaceFrac()

◆ setRnd()

◆ setUnWeightPs()

◆ setup_psbox()

◆ tryEventForOwner()

◆ VolumeSum()

Member Data Documentation

◆ __phaseSpaceFracDefaultValue

◆ _ampSum

◆ _eventPtrList

◆ _maxWeightEstimate

◆ _maxWeightInSample

◆ _phaseSpaceFrac

◆ _phaseSpaceIntegral

◆ _pick_ps_prob

◆ _psbox

◆ _ready

◆ _rnd

◆ _volumeProbs