DalitzHistoSet Class Reference

#include <DalitzHistoSet.h>

Inheritance diagram for DalitzHistoSet:

Public Member Functions
	DalitzHistoSet ()
	DalitzHistoSet (const DalitzHistoSet &other)
virtual	~DalitzHistoSet ()
void	add (const DalitzHistogram &histo, double weight=1)
void	add (const DalitzHistoSet &hL, double weight=1)
void	multiply (const DalitzHistogram &hL)
void	multiply (const DalitzHistoSet &hL)
void	divide (const DalitzHistogram &hL)
void	divide (const DalitzHistoSet &hL)
void	addEvent (const IDalitzEvent &evt, double weight=1)
void	scale (double sf)
void	setNormFactor (double sf=1)
void	clearAllHistos ()
const std::string &	name () const
const std::string &	dirName () const
std::string	fullDirListFname (const std::string &asSubdirOf=".") const
bool	saveAsDir (const std::string &asSubdirOf=".") const
bool	retrieveFromDir (const std::string &asSubDirOf=".")
bool	save (const std::string &filename="DalitzHistos.root") const
bool	draw (const std::string &baseName="", const std::string &drawOpt="", const std::string &format="eps") const
bool	drawWithFit (const DalitzHistoSet &fit, const std::string &baseName="", const std::string &format="eps", const std::string &fitDrawOpt="HIST C SAME") const
bool	drawWithFitAndEachAmps (DalitzHistoSet &data, DalitzHistoSet &fit, std::vector< DalitzHistoSet > &amps, const std::string &baseName="", const std::string &format="eps", const std::string &fitDrawOpt="HIST C SAME") const
bool	drawWithFitAndEachAmpsAndInterference (DalitzHistoSet &data, DalitzHistoSet &fit, DalitzHistoSet &interference, std::vector< DalitzHistoSet > &amps, const std::string &baseName="", const std::string &format="eps", const std::string &fitDrawOpt="HIST C SAME") const
bool	drawWithFitNorm (const DalitzHistoSet &fit, const std::string &baseName="", const std::string &format="eps", const std::string &fitDrawOpt="HIST C SAME") const
void	setTitle (const std::string &title)
void	setFillColour (Color_t fcolor)
void	setLineColour (Color_t fcolor)
double	integral () const
DalitzHistoSet &	operator *= (double sf)
DalitzHistoSet	operator * (double sf) const
DalitzHistoSet &	operator/= (double sf)
DalitzHistoSet	operator/ (double sf) const
DalitzHistoSet &	operator+= (const DalitzHistoSet &rhs)
DalitzHistoSet	operator+ (const DalitzHistoSet &rhs) const
DalitzHistoSet &	operator-= (const DalitzHistoSet &rhs)
DalitzHistoSet	operator- (const DalitzHistoSet &rhs) const
DalitzHistoSet &	operator *= (const DalitzHistoSet &rhs)
DalitzHistoSet	operator * (const DalitzHistoSet &rhs) const
DalitzHistoSet &	operator/= (const DalitzHistoSet &rhs)
DalitzHistoSet	operator/ (const DalitzHistoSet &rhs) const
Public Member Functions inherited from MINT::PolymorphMap< DalitzCoordSet, DalitzHistogram >
	PolymorphMap ()
	PolymorphMap (const PolymorphMap &other)
	PolymorphMap (const typename std::map< DalitzCoordSet, DalitzHistogram > &other)
virtual	~PolymorphMap ()
std::map< DalitzCoordSet, DalitzHistogram > &	theMap ()
const std::map< DalitzCoordSet, DalitzHistogram > &	theMap () const
DalitzHistogram &	operator[] (const DalitzCoordSet &k)
const DalitzHistogram &	operator[] (const DalitzCoordSet &k) const
std::map< DalitzCoordSet, DalitzHistogram >::iterator	begin ()
std::map< DalitzCoordSet, DalitzHistogram >::const_iterator	begin () const
std::map< DalitzCoordSet, DalitzHistogram >::iterator	end ()
std::map< DalitzCoordSet, DalitzHistogram >::const_iterator	end () const
std::map< DalitzCoordSet, DalitzHistogram >::iterator	find (const DalitzCoordSet &c)
std::map< DalitzCoordSet, DalitzHistogram >::const_iterator	find (const DalitzCoordSet &c) const
void	insert (typename std::map< DalitzCoordSet, DalitzHistogram >::const_iterator first, typename std::map< DalitzCoordSet, DalitzHistogram >::const_iterator last)
unsigned int	size () const
bool	empty () const
PolymorphMap< DalitzCoordSet, DalitzHistogram > &	operator= (const PolymorphMap &other)
void	clear ()
void	resize (unsigned int N)
void	resize (unsigned int N, const DalitzHistogram &c)
	operator const typename std::map< DalitzCoordSet, DalitzHistogram > & () const
	operator typename std::map< DalitzCoordSet, DalitzHistogram > & ()
bool	operator== (const MINT::PolymorphMap< DalitzCoordSet, DalitzHistogram > &v2) const
bool	operator!= (const MINT::PolymorphMap< DalitzCoordSet, DalitzHistogram > &v2) const
bool	operator< (const MINT::PolymorphMap< DalitzCoordSet, DalitzHistogram > &v2) const
bool	operator> (const MINT::PolymorphMap< DalitzCoordSet, DalitzHistogram > &v2) const

Private Member Functions
void	makeHistograms (const DalitzEventPattern &pat)
bool	makeDirectory (const std::string &asSubdirOf) const
const std::string &	makeName ()

Private Attributes
std::string	_name
std::map< DalitzCoordSet, DalitzHistogram >	_theMap

Additional Inherited Members
Protected Attributes inherited from MINT::PolymorphMap< DalitzCoordSet, DalitzHistogram >
std::map< DalitzCoordSet, DalitzHistogram >	_map

Detailed Description

Definition at line 20 of file DalitzHistoSet.h.

Constructor & Destructor Documentation

DalitzHistoSet() [1/2]

DalitzHistoSet::DalitzHistoSet

(

)

Definition at line 21 of file DalitzHistoSet.cpp.

{
  //TH1::AddDirectory(kFALSE);
  makeName();
}

DalitzHistoSet() [2/2]

DalitzHistoSet::DalitzHistoSet

(

const DalitzHistoSet &

other

)

Definition at line 27 of file DalitzHistoSet.cpp.

  : PolymorphMap( other )
{
  //TH1::AddDirectory(kFALSE);
  makeName();
}

~DalitzHistoSet()

DalitzHistoSet::~DalitzHistoSet ( )

virtual

Definition at line 34 of file DalitzHistoSet.cpp.

                               {
  
}

Member Function Documentation

add() [1/2]

void DalitzHistoSet::add	(	const DalitzHistogram &	histo,
		double	weight = 1
	)

Definition at line 52 of file DalitzHistoSet.cpp.

                                                                   {
  (*this)[histo.coord()].add(histo, weight);
  return;
}

add() [2/2]

void DalitzHistoSet::add	(	const DalitzHistoSet &	hL,
		double	weight = 1
	)

Definition at line 56 of file DalitzHistoSet.cpp.

                                                               {
  for(std::map< DalitzCoordSet, DalitzHistogram>::const_iterator it = hL.begin();
      it != hL.end();
      it++){
    this->add(it->second, weight);
  }
  return;
}

addEvent()

void DalitzHistoSet::addEvent	(	const IDalitzEvent &	evt,
		double	weight = 1
	)

Definition at line 89 of file DalitzHistoSet.cpp.

                                                                   {
  int ndgtr(evt.eventPattern().numDaughters());
  if(this->empty() && ndgtr > 2) makeHistograms(evt.eventPattern());

  for(map< DalitzCoordSet, DalitzHistogram>::iterator 
    it = this->begin();
      it != this->end();
      it++){
    it->second.addEvent(evt, weight);
  }
  return;
}

clearAllHistos()

void DalitzHistoSet::clearAllHistos

(

)

Definition at line 158 of file DalitzHistoSet.cpp.

                                   {
  if(this->empty()) return;
  for(map< DalitzCoordSet, DalitzHistogram>::iterator 
    it = this->begin();
      it != this->end();
      it++){
    it->second.clearHisto();
  }
  return;
}

dirName()

const std::string & DalitzHistoSet::dirName

(

)

const

Definition at line 178 of file DalitzHistoSet.cpp.

                                              {
  return _name;
}

divide() [1/2]

void DalitzHistoSet::divide

(

const DalitzHistogram &

hL

)

Definition at line 76 of file DalitzHistoSet.cpp.

                                                       {
  (*this)[histo.coord()].divide(histo);
  return;
}

divide() [2/2]

void DalitzHistoSet::divide

(

const DalitzHistoSet &

hL

)

Definition at line 80 of file DalitzHistoSet.cpp.

                                                   {
  for(map< DalitzCoordSet, DalitzHistogram>::const_iterator it = hL.begin();
      it != hL.end();
      it++){
    this->divide(it->second);
  }
  return;
}

draw()

bool DalitzHistoSet::draw	(	const std::string &	baseName = "",
		const std::string &	drawOpt = "",
		const std::string &	format = "eps"
	)		const

Definition at line 310 of file DalitzHistoSet.cpp.

                     {
  bool sc=true;
  for(map< DalitzCoordSet, DalitzHistogram>::const_iterator 
    it = this->begin();
      it != this->end();
      it++){
    sc &= it->second.draw(baseName, drawOpt, format);
  }
  return sc;
}

drawWithFit()

bool DalitzHistoSet::drawWithFit	(	const DalitzHistoSet &	fit,
		const std::string &	baseName = "",
		const std::string &	format = "eps",
		const std::string &	fitDrawOpt = "HIST C SAME"
	)		const

Definition at line 324 of file DalitzHistoSet.cpp.

                        {
  bool sc=true;
  for(map< DalitzCoordSet, DalitzHistogram>::const_iterator 
    it = this->begin();
      it != this->end();
      it++){
    map< DalitzCoordSet, DalitzHistogram >::const_iterator jt 
      = fit.find(it->first);
    if(jt == fit.end()) continue;
    sc &= it->second.drawWithFit(jt->second, baseName, format, fitDrawOpt);
  } 
  return sc;
}

drawWithFitAndEachAmps()

bool DalitzHistoSet::drawWithFitAndEachAmps	(	DalitzHistoSet &	data,
		DalitzHistoSet &	fit,
		std::vector< DalitzHistoSet > &	amps,
		const std::string &	baseName = "",
		const std::string &	format = "eps",
		const std::string &	fitDrawOpt = "HIST C SAME"
	)		const

Definition at line 342 of file DalitzHistoSet.cpp.

                  {
  bool sc=true;
  std::vector<DalitzHistoSet>::iterator amps_it;

  for(map< DalitzCoordSet, DalitzHistogram>::iterator it = data.begin();it != data.end();it++){

    int counter = 0;
    TCanvas can;

    map< DalitzCoordSet, DalitzHistogram >::iterator jt= fit.find(it->first);
    if(jt == fit.end()) continue;
    MINT::counted_ptr<TH1> dataHisto = (it->second).getHisto();
    std::cout << it->first << endl;
    MINT::counted_ptr<TH1> FitHisto = jt->second.getHisto();

    TLegend* leg = new TLegend(0.5 //xmin
                ,0.5    //y-min
                    ,0.98   //x-max
                        ,0.935
                ,""); //y-max //coordinates are fractions

    leg->SetTextSize(0.03);
    if ((it->first).name() == "sij(2,3,4)" ||
        (it->first).name() == "sij(1,3,4)" ||
        (it->first).name() == "sij(1,2,4)" ||
        (it->first).name() == "sij(1,2,3)" )
    {
        leg->SetX1(0.1);
        leg->SetX2(0.4);
    }
    
    TLegend* leg2 = new TLegend(0.,0.,1.,1.,"");
    leg2->SetLineStyle(0);
    leg2->SetLineColor(0);

    (*dataHisto).Scale(1./(*dataHisto).Integral());
    (*dataHisto).SetMinimum(0.0001);
    double max = (*dataHisto).GetMaximum();
    if((*FitHisto).GetMaximum()>max)max= (*FitHisto).GetMaximum();
    (*dataHisto).SetMaximum(max*1.1);
    (*dataHisto).SetLineColor(kBlack);
    (*dataHisto).SetMarkerStyle(20);
    (*dataHisto).SetMarkerSize(0.6);
    (*dataHisto).Draw("E");
    
    (*FitHisto).SetLineColor(kBlack);
    (*FitHisto).Draw("HIST C SAME");
    //leg->AddEntry(&(*FitHisto),"Fit","l");  // "l" means line
    //leg->AddEntry(&(*dataHisto),"data","lep");  // "l" means line

    // suppress warning double NEntries = (*FitHisto).GetEntries();
    (*FitHisto).GetEntries();
    // suppress warning double NormFactor = (*FitHisto).GetNormFactor();
    (*FitHisto).GetNormFactor();

    MINT::counted_ptr<TH1> histo;

    for (amps_it = amps.begin(); amps_it < amps.end(); amps_it++)
    {
      map< DalitzCoordSet, DalitzHistogram >::iterator it2 = (*amps_it).find(it->first);

      counter++;
      histo = it2->second.getHisto();

      if (counter == 9) counter++; //Remove white colour
      (*histo).SetLineColor(1+counter);

          const char* title = (*histo).GetTitle();
          leg->AddEntry(&(*histo),title,"l");  // "l" means line
          leg2->AddEntry(&(*histo),title,"l");  // "l" means line

          (*histo).Draw("HIST C SAME");
      // suppress warning double NormFactorAmp = 
          (*histo).GetNormFactor();
    }

    std::string SaveName = it->first.name();
    TString SaveFull = baseName+SaveName+".eps";
    TString SaveFullLeg = baseName+SaveName+"_leg.eps";
    TString SaveFullLog = baseName+SaveName+"_log.eps";
    TString SaveLeg = baseName+"_leg.eps";

    SaveFull.ReplaceAll("(","");
    SaveFull.ReplaceAll(")","");
    SaveFull.ReplaceAll(",","_");
    SaveFullLeg.ReplaceAll("(","");
    SaveFullLeg.ReplaceAll(")","");
    SaveFullLeg.ReplaceAll(",","_");
    SaveFullLog.ReplaceAll("(","");
    SaveFullLog.ReplaceAll(")","");
    SaveFullLog.ReplaceAll(",","_");
    SaveLeg.ReplaceAll("(","");
    SaveLeg.ReplaceAll(")","");
    SaveLeg.ReplaceAll(",","_");

    can.Print(SaveFull);
    
    gPad->SetLogy(1);
    can.Print(SaveFullLog);
    gPad->SetLogy(0);

    leg->SetFillColor(4000);
    leg->SetShadowColor(4000);
    leg->Draw();
    can.Print(SaveFullLeg);

    TCanvas c;
    c.cd();
    leg2->SetFillColor(4000);
    leg2->SetShadowColor(4000);
    leg2->Draw();
    c.Print(SaveLeg);

  }
  return sc;
}

drawWithFitAndEachAmpsAndInterference()

bool DalitzHistoSet::drawWithFitAndEachAmpsAndInterference	(	DalitzHistoSet &	data,
		DalitzHistoSet &	fit,
		DalitzHistoSet &	interference,
		std::vector< DalitzHistoSet > &	amps,
		const std::string &	baseName = "",
		const std::string &	format = "eps",
		const std::string &	fitDrawOpt = "HIST C SAME"
	)		const

Definition at line 466 of file DalitzHistoSet.cpp.

                  {
  bool sc=true;
  std::vector<DalitzHistoSet>::iterator amps_it;

  for(map< DalitzCoordSet, DalitzHistogram>::iterator it = data.begin();it != data.end();it++){

    int counter = 0;
    TCanvas can;

    map< DalitzCoordSet, DalitzHistogram >::iterator jt= fit.find(it->first);
    if(jt == fit.end()) continue;
    MINT::counted_ptr<TH1> dataHisto = (it->second).getHisto();
    std::cout << it->first << endl;
    MINT::counted_ptr<TH1> FitHisto = jt->second.getHisto();

    map< DalitzCoordSet, DalitzHistogram >::iterator jt_interference = interference.find(it->first);
    if(jt_interference == interference.end()) continue;
    MINT::counted_ptr<TH1> interferenceHisto = (jt_interference->second).getHisto();


    TLegend* leg = new TLegend(0.5 //xmin
                ,0.5    //y-min
                    ,0.98   //x-max
                        ,0.935
                ,""); //y-max //coordinates are fractions

    leg->SetTextSize(0.01);
    if ((it->first).name() == "sij(2,3,4)" ||
        (it->first).name() == "sij(1,3,4)" ||
        (it->first).name() == "sij(1,2,4)" ||
        (it->first).name() == "sij(1,2,3)" )
    {
        leg->SetX1(0.1);
        leg->SetX2(0.4);
    }
    
    TLegend* leg2 = new TLegend(0.,0.,1.,1.,"");
    leg2->SetLineStyle(0);
    leg2->SetLineColor(0);

    (*dataHisto).Scale(1./(*dataHisto).Integral());
    double max = (*dataHisto).GetMaximum();
    if((*FitHisto).GetMaximum()>max)max= (*FitHisto).GetMaximum();
    (*dataHisto).SetMaximum(max*1.1);
    (*dataHisto).SetLineColor(kBlack);
    (*dataHisto).SetMarkerStyle(20);
    (*dataHisto).SetMarkerSize(0.6);
    (*dataHisto).Draw("E");
    
    (*FitHisto).SetLineColor(kBlack);
    (*FitHisto).Draw("HIST C SAME");
    //leg->AddEntry(&(*FitHisto),"Fit","l");  // "l" means line
    //leg->AddEntry(&(*dataHisto),"data","lep");  // "l" means line

    (*interferenceHisto).SetLineColor(kBlack);
    (*interferenceHisto).SetLineStyle(kDashed);
    (*interferenceHisto).Draw("HIST C SAME");
    leg->AddEntry(&(*interferenceHisto),"Interference","l"); 
    leg2->AddEntry(&(*interferenceHisto),"Interference","l"); 

    // suppress warning double NEntries = (*FitHisto).GetEntries();
    (*FitHisto).GetEntries();
    // suppress warning double NormFactor = (*FitHisto).GetNormFactor();
    (*FitHisto).GetNormFactor();

    MINT::counted_ptr<TH1> histo;

    for (amps_it = amps.begin(); amps_it < amps.end(); amps_it++)
    {
      map< DalitzCoordSet, DalitzHistogram >::iterator it2 = (*amps_it).find(it->first);

      counter++;
      histo = it2->second.getHisto();

      if (counter == 9) counter++; //Remove white colour
      (*histo).SetLineColor(1+counter);

          const char* title = (*histo).GetTitle();
          leg->AddEntry(&(*histo),title,"l");  // "l" means line
          leg2->AddEntry(&(*histo),title,"l");  // "l" means line

          (*histo).Draw("HIST C SAME");
      // suppress warning double NormFactorAmp = 
          (*histo).GetNormFactor();
    }

    std::string SaveName = it->first.name();
    TString SaveFull = baseName+SaveName+".eps";
    TString SaveFullLeg = baseName+SaveName+"_leg.eps";
    TString SaveLeg = baseName+"_leg.eps";

    SaveFull.ReplaceAll("(","");
    SaveFull.ReplaceAll(")","");
    SaveFull.ReplaceAll(",","_");
    SaveFullLeg.ReplaceAll("(","");
    SaveFullLeg.ReplaceAll(")","");
    SaveFullLeg.ReplaceAll(",","_");
    SaveLeg.ReplaceAll("(","");
    SaveLeg.ReplaceAll(")","");
    SaveLeg.ReplaceAll(",","_");

    can.Print(SaveFull);
    
    leg->SetFillColor(4000);
    leg->SetShadowColor(4000);
    leg->Draw();
    can.Print(SaveFullLeg);

    TCanvas c;
    c.cd();
    leg2->SetFillColor(4000);
    leg2->SetShadowColor(4000);
    leg2->Draw();
    c.Print(SaveLeg);

  }
  return sc;
}

drawWithFitNorm()

bool DalitzHistoSet::drawWithFitNorm	(	const DalitzHistoSet &	fit,
		const std::string &	baseName = "",
		const std::string &	format = "eps",
		const std::string &	fitDrawOpt = "HIST C SAME"
	)		const

Definition at line 592 of file DalitzHistoSet.cpp.

                            {
  DalitzHistoSet me(*this);
  DalitzHistoSet you(fit);
  if(0 != me.integral())  me  /= me.integral();
  if(0 != you.integral()) you /= you.integral();
  return me.drawWithFit(you, baseName, format, fitDrawOpt);
}

fullDirListFname()

std::string DalitzHistoSet::fullDirListFname

(

const std::string &

asSubdirOf = "."

)

const

Definition at line 231 of file DalitzHistoSet.cpp.

                                          {
  return asSubdirOf + "/" + dirName() + "/" + "directoryList.txt";
}

integral()

double DalitzHistoSet::integral

(

)

const

Definition at line 603 of file DalitzHistoSet.cpp.

                                     {
  if(this->empty()) return 0;
  return this->begin()->second.integral(); // should all be the same.
}

makeDirectory()

bool DalitzHistoSet::makeDirectory ( const std::string &  asSubdirOf ) const

private

Definition at line 196 of file DalitzHistoSet.cpp.

                                                                  {
  /*
    A mode is created from or'd permission bit masks defined
     in <sys/stat.h>:
           #define S_IRWXU 0000700     RWX mask for owner 
           #define S_IRUSR 0000400     R for owner 
           #define S_IWUSR 0000200     W for owner 
           #define S_IXUSR 0000100     X for owner 

           #define S_IRWXG 0000070     RWX mask for group 
           #define S_IRGRP 0000040     R for group 
           #define S_IWGRP 0000020     W for group 
           #define S_IXGRP 0000010     X for group 

           #define S_IRWXO 0000007     RWX mask for other 
           #define S_IROTH 0000004     R for other 
           #define S_IWOTH 0000002     W for other 
           #define S_IXOTH 0000001     X for other 

           #define S_ISUID 0004000     set user id on execution 
           #define S_ISGID 0002000     set group id on execution 
           #define S_ISVTX 0001000     save swapped text even after use
   */

  mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO 
              | S_ISUID | S_ISGID; 
  // see above for meaning. I want everybody to be allowed to read/write/exec.
  // Not sure about the last two bits.

  int zeroForSuccess = 0;
  zeroForSuccess |= mkdir( (asSubdirOf ).c_str(), mode );
  zeroForSuccess |= mkdir( (asSubdirOf + "/" + dirName() ).c_str(), mode );
  return (0 == zeroForSuccess);
}

makeHistograms()

void DalitzHistoSet::makeHistograms ( const DalitzEventPattern &  pat )

private

Definition at line 38 of file DalitzHistoSet.cpp.

                                                                {

  int nDaughters = pat.numDaughters();
  AllPossibleSij sijList(nDaughters);
  
  for(namedVMap::const_iterator it = sijList.begin();
      it != sijList.end(); it++){
    DalitzHistogram h(it->second, pat);
    (*this)[it->second] = h;
  }

  return;
}

makeName()

const std::string & DalitzHistoSet::makeName ( )

private

Definition at line 169 of file DalitzHistoSet.cpp.

                                         {
  _name = "DalitzHistoSet";
  return _name;
}

multiply() [1/2]

void DalitzHistoSet::multiply

(

const DalitzHistogram &

hL

)

Definition at line 64 of file DalitzHistoSet.cpp.

                                                         {
  (*this)[histo.coord()].multiply(histo);
  return;
}

multiply() [2/2]

void DalitzHistoSet::multiply

(

const DalitzHistoSet &

hL

)

Definition at line 68 of file DalitzHistoSet.cpp.

                                                     {
  for(map< DalitzCoordSet, DalitzHistogram>::const_iterator it = hL.begin();
      it != hL.end();
      it++){
    this->multiply(it->second);
  }
  return;
}

name()

const std::string & DalitzHistoSet::name

(

)

const

Definition at line 174 of file DalitzHistoSet.cpp.

                                           {
  return _name;
}

operator *() [1/2]

DalitzHistoSet DalitzHistoSet::operator *

(

double

sf

)

const

Definition at line 612 of file DalitzHistoSet.cpp.

                                                       {
  DalitzHistoSet newSet(*this);
  newSet *= sf;
  return newSet;
}

operator *() [2/2]

DalitzHistoSet DalitzHistoSet::operator *

(

const DalitzHistoSet &

rhs

)

const

Definition at line 656 of file DalitzHistoSet.cpp.

                                                                       {
  DalitzHistoSet newSet(*this);
  newSet *= rhs;
  return newSet;
}

operator *=() [1/2]

DalitzHistoSet & DalitzHistoSet::operator *=

(

double

sf

)

Definition at line 608 of file DalitzHistoSet.cpp.

                                                   {
  this->scale(sf);
  return *this;
}

operator *=() [2/2]

DalitzHistoSet & DalitzHistoSet::operator *=

(

const DalitzHistoSet &

rhs

)

Definition at line 652 of file DalitzHistoSet.cpp.

                                                                   {
  this->multiply(rhs);
  return *this;
}

operator+()

DalitzHistoSet DalitzHistoSet::operator+

(

const DalitzHistoSet &

rhs

)

const

Definition at line 637 of file DalitzHistoSet.cpp.

                                                                       {
  DalitzHistoSet newSet(*this);
  newSet += rhs;
  return newSet;
}

operator+=()

DalitzHistoSet & DalitzHistoSet::operator+=

(

const DalitzHistoSet &

rhs

)

Definition at line 633 of file DalitzHistoSet.cpp.

                                                                   {
  this->add(rhs);
  return *this;
}

operator-()

DalitzHistoSet DalitzHistoSet::operator-

(

const DalitzHistoSet &

rhs

)

const

Definition at line 646 of file DalitzHistoSet.cpp.

                                                                       {
  DalitzHistoSet newSet(*this);
  newSet -= rhs;
  return newSet;
}

operator-=()

DalitzHistoSet & DalitzHistoSet::operator-=

(

const DalitzHistoSet &

rhs

)

Definition at line 642 of file DalitzHistoSet.cpp.

                                                                   {
  this->add(rhs, -1.0);
  return *this;
}

operator/() [1/2]

DalitzHistoSet DalitzHistoSet::operator/

(

double

sf

)

const

Definition at line 627 of file DalitzHistoSet.cpp.

                                                       {
  DalitzHistoSet newSet(*this);
  newSet /= sf;
  return newSet;
}

operator/() [2/2]

DalitzHistoSet DalitzHistoSet::operator/

(

const DalitzHistoSet &

rhs

)

const

Definition at line 665 of file DalitzHistoSet.cpp.

                                                                       {
  DalitzHistoSet newSet(*this);
  newSet /= rhs;
  return newSet;
}

operator/=() [1/2]

DalitzHistoSet & DalitzHistoSet::operator/=

(

double

sf

)

Definition at line 623 of file DalitzHistoSet.cpp.

                                                   {
  this->scale(1./sf);
  return *this;
}

operator/=() [2/2]

DalitzHistoSet & DalitzHistoSet::operator/=

(

const DalitzHistoSet &

rhs

)

Definition at line 661 of file DalitzHistoSet.cpp.

                                                                   {
  this->divide(rhs);
  return *this;
}

retrieveFromDir()

bool DalitzHistoSet::retrieveFromDir

(

const std::string &

asSubDirOf = "."

)

Definition at line 282 of file DalitzHistoSet.cpp.

                                                               {
  bool dbThis=false;
  bool sc=true;

  makeDirectory(asSubdirOf);
  //path = asSubdirOf + "/" + dirName();
  NamedParameter<std::string> dirNames("DirectoryList"
                       , fullDirListFname(asSubdirOf).c_str()
                       );
  dirNames.reloadFile(fullDirListFname(asSubdirOf).c_str());
  std::string path=asSubdirOf + "/" + dirName();
  for(int i=0; i < dirNames.size(); i++){
    DalitzHistogram hs;    
    hs.retrieveFromDir( path, dirNames.getVal(i).c_str() );
    if(dbThis) cout << "hs.pattern()" << hs.pattern() << endl;
    this->add(hs);
  }
  if(dbThis){
    cout << "after adding:" << endl;
    for(std::map< DalitzCoordSet, DalitzHistogram>::const_iterator it =
      this->begin(); it != this->end(); it++){
      cout << "\n" << it->second.pattern() << endl;
    }

  }
  return sc;
}

save()

bool DalitzHistoSet::save

(

const std::string &

filename = "DalitzHistos.root"

)

const

Definition at line 182 of file DalitzHistoSet.cpp.

                                                        {
  TFile* f = TFile::Open(filename.c_str(), "RECREATE");
  f->cd();
  for(map< DalitzCoordSet, DalitzHistogram>::const_iterator 
    it = this->begin();
      it != this->end();
      it++){
    if(0 == it->second.histo()) continue;
    it->second.histo()->Write();
  }
  f->Close();
  return true;
}

saveAsDir()

bool DalitzHistoSet::saveAsDir

(

const std::string &

asSubdirOf = "."

)

const

Definition at line 235 of file DalitzHistoSet.cpp.

                                                               {
  bool dbThis=true;

  bool sc=true;

  if(dbThis) cout << "DalitzHistoSet::saveAsDir: called with "
          << "asSubdirOf = " << asSubdirOf << endl;

  makeDirectory(asSubdirOf);
  std::string dir = asSubdirOf + "/" + dirName();
  
  std::vector<std::string> directoryList;
  for(map< DalitzCoordSet, DalitzHistogram>::const_iterator 
    it = this->begin();
      it != this->end();
      it++){
    if(dbThis) cout << "DalitzHistoSet::saveAsDir: saving DalitzHistogram" << endl;
    sc &= it->second.saveAsDir(dir);
    directoryList.push_back(it->second.dirName());
  }
  
  NamedParameter<std::string> dirNames("DirectoryList"
                       , NamedParameterBase::QUIET);
  dirNames = directoryList;

  ofstream os( fullDirListFname(asSubdirOf).c_str() );
  if(os.bad()){
    cout << "ERROR in DalitzHistoSet::saveAsDir of \n\t" << name()
     << "\n\t unable to create file: "
     << "\n\t" << fullDirListFname() << endl;
    return false;
  }
  os << name()
     << '\n' << dirNames
     << endl;
  os.close();

  if(dbThis){
    cout << "I've just written this: "
     << name()
     << '\n' << dirNames
     << endl;
    cout << "to this file: " << fullDirListFname(asSubdirOf) << endl;
  }
  return sc;
}

scale()

void DalitzHistoSet::scale

(

double

sf

)

Definition at line 102 of file DalitzHistoSet.cpp.

                                   {
  if(this->empty()) return;
  for(map< DalitzCoordSet, DalitzHistogram>::iterator 
    it = this->begin();
      it != this->end();
      it++){
    it->second.scale(sf);
  }
  return;
}

setFillColour()

void DalitzHistoSet::setFillColour

(

Color_t

fcolor

)

Definition at line 134 of file DalitzHistoSet.cpp.

                                                {
  if(this->empty()) return;
  for(map< DalitzCoordSet, DalitzHistogram>::iterator 
    it = this->begin();
      it != this->end();
      it++){
    it->second.histo()->SetFillColor(fcolor);
  }
  return;
}

setLineColour()

void DalitzHistoSet::setLineColour

(

Color_t

fcolor

)

Definition at line 144 of file DalitzHistoSet.cpp.

                                                {
  if(this->empty()) return;
  for(map< DalitzCoordSet, DalitzHistogram>::iterator 
    it = this->begin();
      it != this->end();
      it++){
    it->second.histo()->SetLineColor(fcolor);
    it->second.histo()->SetLineWidth(2);
  }
  return;
}

setNormFactor()

void DalitzHistoSet::setNormFactor

(

double

sf = 1

)

Definition at line 113 of file DalitzHistoSet.cpp.

                                           {
  if(this->empty()) return;
  for(map< DalitzCoordSet, DalitzHistogram>::iterator 
    it = this->begin();
      it != this->end();
      it++){
    it->second.setNormFactor(sf);
  }
  return;
}

setTitle()

void DalitzHistoSet::setTitle

(

const std::string &

title

)

Definition at line 124 of file DalitzHistoSet.cpp.

                                                   {
  if(this->empty()) return;
  for(map< DalitzCoordSet, DalitzHistogram>::iterator 
    it = this->begin();
      it != this->end();
      it++){
    it->second.setTitle(title);
  }
  return;
}

Member Data Documentation

_name

std::string DalitzHistoSet::_name

private

Definition at line 22 of file DalitzHistoSet.h.

_theMap

std::map< DalitzCoordSet, DalitzHistogram> DalitzHistoSet::_theMap

private

Definition at line 27 of file DalitzHistoSet.h.

---

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

• Mint/DalitzHistoSet.h
• src/Mojito/BreitWignerMC/DalitzHistoSet.cpp