#include <DalitzEventList.h>

Inheritance diagram for DalitzEventList:

Public Member Functions
	DalitzEventList ()

	DalitzEventList (const DalitzEventList &other)

	DalitzEventList (TNtupleD *)

virtual	~DalitzEventList ()

const std::string &	className () const

int	generatePhaseSpaceEvents (int NumEvents, const DalitzEventPattern &pat, TRandom *rnd=0)

int	generateEvents (unsigned int NumEvents, const DalitzEventPattern &pat, MINT::IReturnRealForEvent< IDalitzEvent > amps, TRandom rnd)

TH1D *	makePlot (const std::vector< int > sij, const std::string &name, MINT::IReturnRealForEvent< IDalitzEvent > weightFunction=0, int nbins=100, double units=GeV GeV, char opt='s')

TH2D *	makePlot2D (const std::vector< int > sijIndicesX, const std::vector< int > sijIndicesY, const std::string &name, MINT::IReturnRealForEvent< IDalitzEvent > weightFunction=0, int nbins=10, double units=GeV GeV, char opt='s')

TNtupleD *	makePlotNtp (const std::string &name_prefix="DalitzPlotNtp", MINT::IReturnRealForEvent< IDalitzEvent > weightFunction=0, double units=GeV GeV)

DalitzHistoSet	histoSet () const

DalitzHistoSet	weightedHistoSet () const

DalitzHistoSet	reWeightedHistoSet (MINT::IReturnRealForEvent< IDalitzEvent > *w)

DalitzHistoSet	weighedReWeightedHistoSet (MINT::IReturnRealForEvent< IDalitzEvent > *w)

bool	makePlots (const std::string &filename) const

PlotSet	makeAllPlots (const std::string &name_prefix, MINT::IReturnRealForEvent< IDalitzEvent > weightFunction=0, int nbins1D=100, int nbins2D=10, double units=GeV GeV)

bool	save (const std::string &fname="DalitzEvents.root") const

bool	fromFile (const std::string &fname="DalitzEvents.root")

TNtupleD *	makeNtuple () const

TNtupleD *	makeNtuple (const std::string &ntpName) const

bool	saveAsNtuple (const std::string &fname="DalitzEvents.root") const

bool	saveAsNtuple (const std::string &fname, const std::string &ntpName) const

bool	fromNtuple (TTree *ntp)

bool	fromNtuple (TTree *ntp, double num)

bool	fromNtupleFile (const std::string &fname="DalitzEvents.root")

Public Member Functions inherited from MINT::EventList< DalitzEvent >
	EventList ()

	EventList (const EventList< DalitzEvent > &other)

virtual	~EventList ()

EventList< DalitzEvent > &	operator= (const EventList< DalitzEvent > &other)

virtual DalitzEvent &	operator[] (unsigned int i)

virtual const DalitzEvent &	operator[] (unsigned int i) const

virtual DalitzEvent	getEvent (unsigned int i) const

virtual unsigned int	size () const

virtual bool	Add (const DalitzEvent &evt)

virtual bool	Add (const EventList< DalitzEvent > &addList)

Public Member Functions inherited from MINT::IEventList< DalitzEvent >
virtual	~IEventList ()

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

	PolymorphVector (unsigned int N)

	PolymorphVector (unsigned int N, const DalitzEvent &c)

	PolymorphVector (const PolymorphVector &other)

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

virtual	~PolymorphVector ()

std::vector< DalitzEvent > &	theVector ()

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

DalitzEvent &	operator[] (unsigned int i)

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

DalitzEvent &	at (unsigned int i)

const DalitzEvent &	at (unsigned int i) const

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

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

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

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

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

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

DalitzEvent &	front ()

const DalitzEvent &	front () const

DalitzEvent &	back ()

const DalitzEvent &	back () const

unsigned int	size () const

bool	empty () const

void	push_back (const DalitzEvent &c)

void	pop_back ()

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

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

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

void	clear ()

void	resize (unsigned int N)

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

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

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

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

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

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

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

Protected Attributes
TFile *	_file

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

Static Private Attributes
static const std::string	_className

Additional Inherited Members
Protected Member Functions inherited from MINT::IEventList< DalitzEvent >
	IEventList ()

Protected Member Functions inherited from MINT::IMinimalEventList< DalitzEvent >
	IMinimalEventList ()

Detailed Description

Definition at line 35 of file DalitzEventList.h.

Constructor & Destructor Documentation

◆ DalitzEventList() [1/3]

DalitzEventList::DalitzEventList ( )

Definition at line 27 of file MyDalitzEventList.h.

   : EventList<DalitzEvent>() 
 {
 }

◆ DalitzEventList() [2/3]

DalitzEventList::DalitzEventList ( const DalitzEventList & other )

Definition at line 32 of file MyDalitzEventList.h.

   : IEventList<DalitzEvent>()
   , EventList<DalitzEvent>(other) 
 {
 }

◆ DalitzEventList() [3/3]

DalitzEventList::DalitzEventList ( TNtupleD * ntp )

Definition at line 38 of file MyDalitzEventList.h.

   : EventList<DalitzEvent>() 
 {
   bool success = fromNtuple(ntp);
   if(! success){
     cout << "ERROR in DalitzEventList::DalitzEventList(TNtupleD* ntp)"
      << "\n   > problem creating myself from ntuple"
      << endl;
   }
 }

◆ ~DalitzEventList()

DalitzEventList::~DalitzEventList ( )

virtual

Definition at line 54 of file DalitzEventList.cpp.

                                  {
   //if(0 != _file) _file->Close();
 }

Member Function Documentation

◆ className()

const std::string& DalitzEventList::className ( ) const

inline

Definition at line 49 of file DalitzEventList.h.

49 {return _className;}

DalitzEventList::_className

static const std::string _className

Definition: DalitzEventList.h:38

◆ fromFile()

bool DalitzEventList::fromFile ( const std::string & fname = "DalitzEvents.root" )

Definition at line 320 of file MyDalitzEventList.h.

                                                     {
   return fromNtupleFile(fname);
 }

◆ fromNtuple() [1/2]

bool DalitzEventList::fromNtuple ( TTree * ntp )

Definition at line 352 of file MyDalitzEventList.h.

                                           {
   bool dbThis=false;
   if(dbThis) cout << "about to read ntuple with ptr " << ntp << endl;
   if(0==ntp) return false;
   if(ntp->GetEntries() <=0) return false;
   if(dbThis) cout << " number of entries: " << ntp->GetEntries() << endl;
   //if(dbThis) cout << " number of variables " << ntp->GetNvar() << endl;
   bool success=true;
   for(Long64_t i=0; i< ntp->GetEntries(); i++){
     if(dbThis){
       cout << "DalitzEventList::fromNtuple "
        << " getting " << i << " th entry" << endl;
     }
     ntp->GetEntry(i);
     if(dbThis) cout << " got it" << endl;
     DalitzEvent evt;
     //    success &= evt.fromNtuple(ntp);
     success &= evt.fromTree(ntp);
     if(dbThis) cout << " made event" << endl;
     if(! success){
       cout << "ERROR in DalitzEventList::fromNtuple"
        << ", call to DalitzEvent::fromNtuple returned false!"
        << endl;
       return false;
     }
     this->Add(evt);
     if(dbThis) cout << " added event" << endl;
   }
   if(dbThis) cout << "DalitzEventList::fromNtuple worked!" << endl;
   return success;
 }

◆ fromNtuple() [2/2]

bool DalitzEventList::fromNtuple	(	TTree *	ntp,
		double	num
	)

Definition at line 384 of file MyDalitzEventList.h.

                                                       {
   bool dbThis=false;
   if(dbThis) cout << "about to read ntuple with ptr " << ntp << endl;
   if(0==ntp) return false;
   if(ntp->GetEntries() <=0) return false;
   if(dbThis) cout << " number of entries: " << ntp->GetEntries() << endl;
   //if(dbThis) cout << " number of variables " << ntp->GetNvar() << endl;
   TRandom Rand(500);
   bool success=true;
   for(Long64_t i=0; i< ntp->GetEntries(); i++){
     if(dbThis){
       cout << "DalitzEventList::fromNtuple "
        << " getting " << i << " th entry" << endl;
     }
     double rand = Rand.Rndm();
     if (rand < num)
     {
         ntp->GetEntry(i);
         if(dbThis) cout << " got it" << endl;
         DalitzEvent evt;
         //    success &= evt.fromNtuple(ntp);
         success &= evt.fromTree(ntp);
         if(dbThis) cout << " made event" << endl;
         if(! success){
           cout << "ERROR in DalitzEventList::fromNtuple"
            << ", call to DalitzEvent::fromNtuple returned false!"
            << endl;
           return false;
         }
         this->Add(evt);
         if(dbThis) cout << " added event" << endl;
     }
   }
   if(dbThis) cout << "DalitzEventList::fromNtuple worked!" << endl;
   return success;
 }

◆ fromNtupleFile()

bool DalitzEventList::fromNtupleFile ( const std::string & fname = "DalitzEvents.root" )

Definition at line 421 of file MyDalitzEventList.h.

                                                           {
   TFile f(fname.c_str());
   f.cd();
   TTree* ntp = (TTree*) f.Get(className().c_str());
   if(0 == ntp){
     cout << "ERROR in DalitzEventList::fromNtupleFile"
      << "\n   > Can't get ntuple for filename = "
      << "\n   > " << fname << endl;
     return false;
   }
   return fromNtuple(ntp);
 }

◆ generateEvents()

int DalitzEventList::generateEvents	(	unsigned int	NumEvents,
		const DalitzEventPattern &	pat,
		MINT::IReturnRealForEvent< IDalitzEvent > *	amps,
		TRandom *	rnd
	)

◆ generatePhaseSpaceEvents()

int DalitzEventList::generatePhaseSpaceEvents	(	int	NumEvents,
		const DalitzEventPattern &	pat,
		TRandom *	rnd = `0`
	)

Definition at line 49 of file MyDalitzEventList.h.

                            {
 
   cout << "DalitzEventList::generatePhaseSpaceEvents "
        << " about to generate " << NumEvents 
        << " events to phase space" << endl;
   time_t tstart = time(0);
   int reportN = NumEvents/10; // 10 x at least;
   if(reportN > 10000) reportN = 10000; // at least once every 10k event
   for(int i=0; i< NumEvents; i++){
     if( i < 5 || (!(i%reportN))){
       cout << "DalitzEventList::generatePhaseSpaceEvents " 
        << " generating " << i+1 << "th event."
        << " with " << pat << " and " << rnd << endl;
     }
     Add(DalitzEvent(pat, rnd));
   }
   double delT = difftime(time(0), tstart);
   cout << " This took " << delT << " s";
   if(delT > 0){
     cout << " this is " << NumEvents/delT << " evts/s"
      << " or " << (NumEvents/delT) * 60<< " evts/min";
   }
   cout << endl;
 
   return this->size();
 }

◆ histoSet()

DalitzHistoSet DalitzEventList::histoSet ( ) const

Definition at line 434 of file MyDalitzEventList.h.

                                               {
   DalitzHistoSet hs;
   for(unsigned int i=0; i< this->size(); i++){
     hs.addEvent(((*this)[i]));
   }
   return hs;
 }

◆ makeAllPlots()

PlotSet DalitzEventList::makeAllPlots	(	const std::string &	name_prefix,
		MINT::IReturnRealForEvent< IDalitzEvent > *	weightFunction = `0`,
		int	nbins1D = `100`,
		int	nbins2D = `10`,
		double	units = `GeV*GeV`
	)

Definition at line 223 of file MyDalitzEventList.h.

                         {
   PlotSet ps;
   if(this->empty()) return ps;
 
   int nd = ((*this)[0]).eventPattern().size()-1;
   if(nd < 3) return ps;
 
   AllPossibleSij sijList(nd);
   
   for(namedVMap::const_iterator it = sijList.begin();
       it != sijList.end(); it++){    
     std::string name = name_prefix + "_s" + it->first;
       
     TH1D* newPlots = makePlot(it->second
                   , name
                   , weightFunction
                   , nbins1D
                   , units
                   , 's');
     if(0 != newPlots) ps.push_back(newPlots);
     
     name = name_prefix + "_m" + it->first;
     TH1D* newPlotm = makePlot(it->second
                   , name
                   , weightFunction
                   , nbins1D
                   , units
                   , 'm');
     if(0 != newPlotm) ps.push_back(newPlotm);
     namedVMap::const_iterator jt = it;
     jt++;
     for(; jt != sijList.end(); jt++){    
       std::string name2D = name_prefix + jt->first + "_vs_" + it->first;
 
       TH2D* newPlot2D = makePlot2D(it->second, jt->second, name2D
                    , weightFunction, nbins2D, units
                    , 's');
 
       if(0 != newPlot2D) ps.push_back(newPlot2D);
     }
   }
   TNtupleD* newPlotNtp = makePlotNtp(name_prefix, weightFunction, units);
   ps.push_back(newPlotNtp);
 
   return ps;  
 }

◆ makeNtuple() [1/2]

TNtupleD * DalitzEventList::makeNtuple ( ) const

Definition at line 276 of file MyDalitzEventList.h.

                                           {
   return makeNtuple(className());
 }

◆ makeNtuple() [2/2]

TNtupleD * DalitzEventList::makeNtuple ( const std::string & ntpName ) const

Definition at line 286 of file MyDalitzEventList.h.

                                                                     {
   
   if(this->empty()) return (TNtupleD*) 0;
   std::string varNameString= ((this->begin()))->makeNtupleVarnames();
   TNtupleD* ntp = new TNtupleD(className().c_str()
                    , ntpName.c_str()
                    , varNameString.c_str());
 
   ntp->SetDirectory(0);
 
   int arraySize = ((this->begin()))->ntupleVarArraySize();
   Double_t *array = new Double_t[arraySize];
 
 
   for(vector<DalitzEvent>::const_iterator it = this->begin();
       it != this->end(); it++){
 
     bool success = (it)->fillNtupleVarArray(array, arraySize);
     if(! success){
       cout << "ERROR in DalitzEventList::makeNtuple"
        << ", call to DalitzEvent::fillNtupleVarArray"
        << " returned failure"
        << endl;
     }else{
       ntp->Fill(array);
     }
   }
   delete[] array;
   return ntp;
 }

◆ makePlot()

TH1D * DalitzEventList::makePlot	(	const std::vector< int >	sij,
		const std::string &	name,
		MINT::IReturnRealForEvent< IDalitzEvent > *	weightFunction = `0`,
		int	nbins = `100`,
		double	units = `GeV*GeV`,
		char	opt = `'s'`
	)

Definition at line 79 of file MyDalitzEventList.h.

                  {
   if(this->empty()) return (TH1D*)0;
   
   double eps=0.1;
   double mi = ((*this)[0]).sijMin(sijIndices)/units;
   double ma = ((*this)[0]).sijMax(sijIndices)/units;
   if(opt=='m'){
     mi = sqrt(mi);
     ma = sqrt(ma);
   }
   mi -= (ma-mi)*eps;
   ma += (ma-mi)*eps;
 
   TH1D* histo = new TH1D(name.c_str(), name.c_str(), nbins, mi, ma);
 
   for(unsigned int i = 0; i < this->size(); i++){
     double w=1;
     DalitzEvent& evt((*this)[i]);
     if(0 != weightFunction) w = weightFunction->RealVal(evt);
     double x= evt.sij(sijIndices)/units;
     if(opt == 'm') x = sqrt(x);
     histo->Fill(x, w);
   }
   return histo;
 }

◆ makePlot2D()

TH2D * DalitzEventList::makePlot2D	(	const std::vector< int >	sijIndicesX,
		const std::vector< int >	sijIndicesY,
		const std::string &	name,
		MINT::IReturnRealForEvent< IDalitzEvent > *	weightFunction = `0`,
		int	nbins = `10`,
		double	units = `GeV*GeV`,
		char	opt = `'s'`
	)

Definition at line 111 of file MyDalitzEventList.h.

                    {
   if(this->empty()) return (TH2D*)0;
     
   
   double eps = 0.125;
   double miX = ((*this)[0]).sijMin(sijIndicesX)/units;
   double maX = ((*this)[0]).sijMax(sijIndicesX)/units;
   double miY = ((*this)[0]).sijMin(sijIndicesY)/units;
   double maY = ((*this)[0]).sijMax(sijIndicesY)/units;
   if(opt=='m'){
     miX = sqrt(miX);
     maX = sqrt(maX);
     miY = sqrt(miY);
     maY = sqrt(maY);
   }
   miX -= (maX - miX)*eps;
   maX += (maX - miX)*eps;
   miY -= (maY - miY)*eps;
   maY += (maY - miY)*eps;
 
   TH2D* histo = new TH2D(name.c_str()
              , name.c_str()
              , nbins, miX, maX
              , nbins, miY, maY);
   for(unsigned int i = 0; i < this->size(); i++){
     double w=1;
     DalitzEvent& evt((*this)[i]);
     if(0 != weightFunction) w = weightFunction->RealVal(evt);
     double x= evt.sij(sijIndicesX)/units;
     double y= evt.sij(sijIndicesY)/units;
     if(opt == 'm'){
       x = sqrt(x);
       y = sqrt(y);
     }
     histo->Fill(x, y, w);
   }
   return histo;
 }

◆ makePlotNtp()

TNtupleD * DalitzEventList::makePlotNtp	(	const std::string &	name_prefix = `"DalitzPlotNtp"`,
		MINT::IReturnRealForEvent< IDalitzEvent > *	weightFunction = `0`,
		double	units = `GeV*GeV`
	)

Definition at line 157 of file MyDalitzEventList.h.

                         {
   std::string ntp_str="";
   int nd = ((*this)[0]).eventPattern().size()-1;
   if(nd < 3) return (TNtupleD*)0;
   AllPossibleSij sijList(nd);
 
   int arraySize = 0;
   for(namedVMap::const_iterator it = sijList.begin();
       it != sijList.end(); it++){    
     std::string entry_name = "s" + it->first + ":";
     ntp_str += entry_name;
     arraySize++;
   }
   for(namedVMap::const_iterator it = sijList.begin();
       it != sijList.end(); it++){    
     std::string entry_name = "m" + it->first + ":";
     ntp_str += entry_name;
     arraySize++;
   }
   ntp_str += "weight:";
   arraySize++;
   ntp_str += "fcn"; // last one doesn't get a ":
 
   std::string ntp_id = className() + "_sij";
   std::string name   = name_prefix + "_sij";
   TNtupleD* ntp = new TNtupleD(ntp_id.c_str()
                    , name.c_str()
                    , ntp_str.c_str());
 
   Double_t* array = new Double_t[arraySize];
 
   for(unsigned int i = 0; i < this->size(); i++){
     int arrayIndex = 0;
     for(namedVMap::const_iterator it = sijList.begin();
     it != sijList.end(); it++){
       array[arrayIndex]=((*this)[i]).sij(it->second)/units;
       arrayIndex++;
     }
     for(namedVMap::const_iterator it = sijList.begin();
     it != sijList.end(); it++){    
       std::string entry_name = "m" + it->first;
       double sijtemp = ((*this)[i]).sij(it->second)/units;
       if(sijtemp >=0){
     array[arrayIndex]=sqrt(sijtemp);
       }else{
     array[arrayIndex] = -9999.;
       }
       arrayIndex++;
     }
     DalitzEvent& evt((*this)[i]);
     array[arrayIndex] = evt.getWeight();
     arrayIndex++;
     double fcn=1;
     if(0 != weightFunction) fcn = weightFunction->RealVal(evt);
     array[arrayIndex] = fcn;
     arrayIndex++;
 
     ntp->Fill(array);
   }
   delete[] array;
 
   return ntp;
 }

◆ makePlots()

bool DalitzEventList::makePlots ( const std::string & filename ) const

Definition at line 471 of file MyDalitzEventList.h.

                                                               {
   histoSet().save(filename);
   return true;
 }

◆ reWeightedHistoSet()

DalitzHistoSet DalitzEventList::reWeightedHistoSet ( MINT::IReturnRealForEvent< IDalitzEvent > * w )

Definition at line 450 of file MyDalitzEventList.h.

                                                                                       {
   // mainly for diagnostics
   DalitzHistoSet hs;
   if(0 == w) return hs;
   for(unsigned int i=0; i< this->size(); i++){
     DalitzEvent evt((*this)[i]);
     hs.addEvent(evt, w->RealVal(evt));
   }
   return hs;
 }

◆ save()

bool DalitzEventList::save ( const std::string & fname = "DalitzEvents.root" ) const

Definition at line 317 of file MyDalitzEventList.h.

                                                      {
   return saveAsNtuple(fname);
 }

◆ saveAsNtuple() [1/2]

bool DalitzEventList::saveAsNtuple ( const std::string & fname = "DalitzEvents.root" ) const

Definition at line 324 of file MyDalitzEventList.h.

                           {
   return saveAsNtuple(fname, className());
 }

◆ saveAsNtuple() [2/2]

bool DalitzEventList::saveAsNtuple	(	const std::string &	fname,
		const std::string &	ntpName
	)		const

Definition at line 329 of file MyDalitzEventList.h.

                           {
   if(this->empty()){
     cout << "WARNING in DalitzEventList::saveAsNtuple!"
      << "\n\tyou are trying to save me to the file: "
      << fname
      << "\n\tbut I have only " << this->size()
      << " events."
      << " I won't create the file."
      << endl;
     return false;
   }
   TFile f(fname.c_str(), "RECREATE");
   f.cd();
   TNtupleD* ntp = makeNtuple(ntpName);
   ntp->Write();
   f.Close();
   //ntp->Delete("all");
   //delete ntp;
   return true;
 }

◆ weighedReWeightedHistoSet()

DalitzHistoSet DalitzEventList::weighedReWeightedHistoSet ( MINT::IReturnRealForEvent< IDalitzEvent > * w )

Definition at line 461 of file MyDalitzEventList.h.

                                                                                              {
   DalitzHistoSet hs;
   if(0 == w) return hs;
   for(unsigned int i=0; i< this->size(); i++){
     DalitzEvent evt((*this)[i]);
     hs.addEvent(evt, w->RealVal(evt) * evt.getWeight());
   }
   return hs;
 }

◆ weightedHistoSet()

DalitzHistoSet DalitzEventList::weightedHistoSet ( ) const

Definition at line 441 of file MyDalitzEventList.h.

                                                       {
   // mainly for diagnostics
   DalitzHistoSet hs;
   for(unsigned int i=0; i< this->size(); i++){
     DalitzEvent evt((*this)[i]);
     hs.addEvent(evt, evt.getWeight());
   }
   return hs;
 }

Member Data Documentation

◆ _className

const std::string DalitzEventList::_className

staticprivate

Definition at line 38 of file DalitzEventList.h.

◆ _file

TFile* DalitzEventList::_file

protected

Definition at line 40 of file DalitzEventList.h.

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

Mint/DalitzEventList.h
Mint/MyDalitzEventList.h
src/Mojito/DalitzEvents/DalitzEventList.cpp

Public Member Functions

Protected Attributes

Static Private Attributes

Additional Inherited Members