DalitzHistogram Class Reference

#include <DalitzHistogram.h>

Public Member Functions
	DalitzHistogram ()
	DalitzHistogram (const DalitzCoordSet &c, const DalitzEventPattern &p, int bins=200, double units=GeV *GeV)
	DalitzHistogram (const DalitzHistogram &other)
virtual	~DalitzHistogram ()
const std::string &	name () const
void	smartTitle (const DalitzCoordSet &c_in, const DalitzEventPattern &pat_in)
const std::string	smartTitle () const
const std::string	hname () const
const std::string &	htitle () const
const std::string &	dirName () const
const DalitzEventPattern &	pattern () const
void	init (const DalitzCoordSet &c, const DalitzEventPattern &p, int bins=100, double units=GeV *GeV)
bool	saveAsDir (const std::string &asSubdirOf=".") const
bool	retrieveFromDir (const std::string &asSubdirOf=".", const char *theName=0)
void	add (const DalitzHistogram &addMeToYou, double weight=1)
void	multiply (const DalitzHistogram &multiplyWith)
void	divide (const DalitzHistogram &divideBy)
void	setNormFactor (double f=1)
void	addEvent (const IDalitzEvent &evt, double weight=1)
MINT::const_counted_ptr< TH1 >	histo () const
MINT::counted_ptr< TH1 >	histo ()
const DalitzCoordSet &	coord () const
DalitzCoordSet &	coord ()
void	scale (double sf)
void	setTitle (const std::string &title)
void	clearHisto ()
bool	draw (const std::string &baseName="", const std::string &drawOpt="", const std::string &format="eps") const
bool	drawWithFit (const DalitzHistogram &fit, const std::string &baseName="", const std::string &format="eps", const std::string &fitDrawOpt="HIST C SAME") const
bool	drawWithFit (TCanvas &can, const DalitzHistogram &fit, const std::string &baseName="", const std::string &format="eps", const std::string &fitDrawOpt="HIST C SAME") const
bool	drawEachAmp (TCanvas &can, const std::string &baseName="", const std::string &drawOpt="SAME", const std::string &format="eps") const
MINT::counted_ptr< TH1 >	getHisto ()
double	integral () const
DalitzHistogram &	operator= (const DalitzHistogram &other)

Private Member Functions
void	makeName ()
bool	makeDirectory (const std::string &asSubdirOf=".") const
std::string	valueFileName (const std::string &asSubdirOf=".", const char *theName=0) const
std::string	histoFileName (const std::string &asSubdirOf=".", const char *theName=0) const
bool	saveValues (const std::string &inDir=".") const
bool	retrieveValues (const std::string &fromDirectory, const char *theName=0)
bool	saveHisto (const std::string &inDir=".") const
bool	retrieveHisto (const std::string &fromDir, const char *theName=0)

Private Attributes
double	_units
int	_nbins
MINT::counted_ptr< TH1 >	_h
DalitzCoordSet	_c
DalitzEventPattern	_pat
std::string	_name
std::string	_smartTitle
TTree *	_tree
std::vector< int >	_patForTree

Detailed Description

Definition at line 24 of file DalitzHistogram.h.

Constructor & Destructor Documentation

DalitzHistogram() [1/3]

DalitzHistogram::DalitzHistogram

(

)

Definition at line 34 of file DalitzHistogram.cpp.

  : _units(GeV*GeV), _h(0), _c(), _pat()
  , _name("noName"), _tree(0), _patForTree()
{
}

DalitzHistogram() [2/3]

DalitzHistogram::DalitzHistogram	(	const DalitzCoordSet &	c,
		const DalitzEventPattern &	p,
		int	bins = 200,
		double	units = GeV*GeV
	)

Definition at line 40 of file DalitzHistogram.cpp.

  : _units(units), _nbins(bins), _h(0), _c(), _pat()
  , _name("noName"), _tree(0), _patForTree()
{
  init(c, pat);
}

DalitzHistogram() [3/3]

DalitzHistogram::DalitzHistogram

(

const DalitzHistogram &

other

)

Definition at line 93 of file DalitzHistogram.cpp.

  : _units(other._units)
  , _nbins(other._nbins)
  , _h(0)
  , _c(other._c)
  , _pat(other._pat)
  , _name(other._name)
  , _tree(0)
  , _patForTree(other._patForTree)
{
  bool dbThis=false;
  if(0 != other._h){
    _h = counted_ptr<TH1>((TH1*) other._h->Clone());
    if(0 == _h){
      cout << "Error in DalitzHistogram copy constructor"
       << endl;
      throw "oh man!";
    }
    _h->SetDirectory(0);
  }
  if(dbThis){
    cout << "DalitzHistogram copy ctor" << endl;
    cout << "pat before: " << other._pat
     << ", and after " << _pat << endl;
  }
}

~DalitzHistogram()

DalitzHistogram::~DalitzHistogram ( )

virtual

Definition at line 120 of file DalitzHistogram.cpp.

                                 {

}

Member Function Documentation

add()

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

Definition at line 247 of file DalitzHistogram.cpp.

                                                                         {
  bool dbThis=false;

  if(0 == addMeToYou.histo()){
    cout << "WARNING in DalitzHistogram::add(const DalitzHistogram&): "
     << " Trying to add a DalitzHistogram w/o histogram to me"
     << " I'll treat it as a zero (i.e. I'll do nothing)."
     << endl;
    return;
  }
  if(0 == histo()){
    if(dbThis){
      cout << "WARNING in DalitzHistogram::add(const DalitzHistogram&): "
       << " Trying to add a DalitzHistogram to me although I have"
       << " no histogram myself - treating myself as zero."
       << endl;
    }
    (*this) = addMeToYou;
    makeName();
    _h->SetNameTitle(hname().c_str(), htitle().c_str());
    // same as before, but repeated for robustness - in case
    // the other histogram had a funny name.
    return;
  }
  if(_c != addMeToYou._c){
    cout << "WARNING in DalitzHistogram::add(const DalitzHistogram&): "
     << " adding histograms for different co-ordinates!"
     << "\n\t" << _c << " != " << addMeToYou._c
     << "\n\t I'll go ahead with it, but it might not be what you want."
     << endl;
  }
  _h->Add((addMeToYou.histo().get()), weight);
  return;
}

addEvent()

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

Definition at line 361 of file DalitzHistogram.cpp.

                                                                    {
  if(0 == _h){
    cout << "Error in DalitzHistogram::addEvent: trying to fill empty histogram"
     << endl;
    return;
  }
  _h->Fill(evt.sij(_c.begin()->second)/_units, weight);
}

clearHisto()

void DalitzHistogram::clearHisto

(

)

Definition at line 377 of file DalitzHistogram.cpp.

                                {
  if(0 == _h) return;
    _h->Clear();
  //_h->Scale(0.0);
}

coord() [1/2]

const DalitzCoordSet& DalitzHistogram::coord ( ) const

inline

Definition at line 89 of file DalitzHistogram.h.

{return _c;}

coord() [2/2]

DalitzCoordSet& DalitzHistogram::coord ( )

inline

Definition at line 90 of file DalitzHistogram.h.

{return _c;}

dirName()

const std::string & DalitzHistogram::dirName

(

)

const

Definition at line 477 of file DalitzHistogram.cpp.

                                               {
  return name();
}

divide()

void DalitzHistogram::divide

(

const DalitzHistogram &

divideBy

)

Definition at line 321 of file DalitzHistogram.cpp.

                                                           {
  bool dbThis=false;

  if(0 == divideBy.histo()){
    cout << "WARNING in DalitzHistogram::divide(const DalitzHistogram&): "
     << " Trying to divide a DalitzHistogram w/o histogram to me"
     << " I guess I should crash, but I'll do nothing."
     << endl;
    //    this->clearHisto();
    return;
  }
  if(0 == histo()){
    if(dbThis){
      cout << "WARNING in DalitzHistogram::divide(const DalitzHistogram&): "
       << " Trying to divide a DalitzHistogram to me although I have"
       << " no histogram myself - treating myself as zero."
       << endl;
    }
    _h = counted_ptr<TH1>((TH1*) divideBy.histo()->Clone());
    if(0 == _h){
      cout << "Error in DalitzHistogram::divide: _h = " << _h << endl;
      throw "mistake";
    }
    _h->SetDirectory(0);
    _c = divideBy._c;
    makeName();
    _h->SetNameTitle(hname().c_str(), htitle().c_str());
    _h->Clear();
    return;
  }
  if(_c != divideBy._c){
    cout << "WARNING in DalitzHistogram::divide(const DalitzHistogram&): "
     << " divideing histograms for different co-ordinates!"
     << "\n\t" << _c << " != " << divideBy._c
     << "\n\t I'll go ahead with it, but it might not be what you want."
     << endl;
  }
  _h->Divide((divideBy.histo().get()));
  return;
}

draw()

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

Definition at line 383 of file DalitzHistogram.cpp.

                      {
  if(0 == _h) return false;
  string fname = baseName + _c.nameFileSave() + "." + format;
  TCanvas can;
  _h->Draw(drawOpt.c_str());
  can.Print(fname.c_str());
  return true;
}

drawEachAmp()

bool DalitzHistogram::drawEachAmp	(	TCanvas &	can,
		const std::string &	baseName = "",
		const std::string &	drawOpt = "SAME",
		const std::string &	format = "eps"
	)		const

Definition at line 763 of file DalitzHistogram.cpp.

                      {
  if(0 == _h) return false;
  string fname = baseName + _c.nameFileSave() + "." + format;
  _h->Draw(drawOpt.c_str());
//  can.Print(fname.c_str());
  return true;
}

drawWithFit() [1/2]

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

Definition at line 673 of file DalitzHistogram.cpp.

                         {
  if(0 == _h) return false;
  string fname = baseName + _c.nameFileSave() + "." + format;
  TCanvas can;

  counted_ptr<TH1> h_c( (TH1*) histo()->Clone());
  if(0 == h_c){
    cout << "Error in DalitzHistogram::drawWithFit, failed to clone histo h_c"
     << endl;
    throw "rubbish";
  }
  h_c->SetDirectory(0);
  counted_ptr<TH1> fit_c( (TH1*) fit.histo()->Clone());
  if(0 == fit_c){
    cout << "Error in DalitzHistogram::drawWithFit, failed to clone histo fit_c"
     << endl;
    throw "rubbish";
  }
  fit_c->SetDirectory(0);
  fit_c->Scale(h_c->Integral()/fit_c->Integral());

  double maxiThis = h_c->GetMaximum();//Stored();
  double maxiThat = fit_c->GetMaximum();//Stored();

  if(maxiThat > maxiThis) h_c->SetMaximum(maxiThat*1.05);
  //  else h_c->SetMaximum(maxiThis);

  h_c->Draw("E1");

  fit_c->SetLineWidth(3);
  fit_c->SetLineColor(2);
  fit_c->SetMarkerColor(2);

  fit_c->Draw(fitDrawOpt.c_str());
  can.Print(fname.c_str());
  return true;
}

drawWithFit() [2/2]

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

Definition at line 715 of file DalitzHistogram.cpp.

                         {
  if(0 == _h) return false;
  string fname = baseName + _c.nameFileSave() + "." + format;

  counted_ptr<TH1> h_c( (TH1*) histo()->Clone());
  if(0 == h_c){
    cout << "Error in DalitzHistogram::drawWithFit 2"
     << ", failed to clone histo h_c"
     << endl;
    throw "rubbish";
  }
  h_c->SetDirectory(0);

  counted_ptr<TH1> fit_c( (TH1*) fit.histo()->Clone());
  if(0 == fit_c){
    cout << "Error in DalitzHistogram::drawWithFit 2"
     << ", failed to clone histo fit_c"
     << endl;
    throw "rubbish";
  }
  fit_c->SetDirectory(0);
  fit_c->Scale(h_c->Integral()/fit_c->Integral());

  double maxiThis = h_c->GetMaximum();//Stored();
  double maxiThat = fit_c->GetMaximum();//Stored();

  if(maxiThat > maxiThis) h_c->SetMaximum(maxiThat*1.05);
  //  else h_c->SetMaximum(maxiThis);

  h_c->Draw("E1");

  fit_c->SetLineWidth(3);
  fit_c->SetLineColor(2);
  fit_c->SetMarkerColor(2);

  fit_c->Draw(fitDrawOpt.c_str());
  can.Print(fname.c_str());
  return true;
}

getHisto()

MINT::counted_ptr< TH1 > DalitzHistogram::getHisto

(

)

Definition at line 759 of file DalitzHistogram.cpp.

                                              {
    return _h;
}

histo() [1/2]

MINT::const_counted_ptr<TH1> DalitzHistogram::histo ( ) const

inline

Definition at line 87 of file DalitzHistogram.h.

{return _h;}

histo() [2/2]

MINT::counted_ptr<TH1> DalitzHistogram::histo ( )

inline

Definition at line 88 of file DalitzHistogram.h.

{return _h;}

histoFileName()

std::string DalitzHistogram::histoFileName ( const std::string &  asSubdirOf = ".", const char *  theName = 0  ) const

private

Definition at line 503 of file DalitzHistogram.cpp.

                                                  {
  std::string dir;
  if(0 == theName){
    dir=dirName();
  }else{
    dir=theName;
  }
  return asSubdirOf + "/" + dir + "/histo.root";
}

hname()

const std::string DalitzHistogram::hname

(

)

const

Definition at line 480 of file DalitzHistogram.cpp.

                                            {
  std::string s;
  for(std::string::const_iterator it = name().begin();
      it != name().end(); it++){
    if('(' == *it || ')'== *it) s += "_";
    else if(',' == *it) s += "_";
    else s+= *it;
  }
  return s;
}

htitle()

const std::string & DalitzHistogram::htitle

(

)

const

Definition at line 490 of file DalitzHistogram.cpp.

                                              {
  return name();
}

init()

void DalitzHistogram::init	(	const DalitzCoordSet &	c,
		const DalitzEventPattern &	p,
		int	bins = 100,
		double	units = GeV*GeV
	)

Definition at line 175 of file DalitzHistogram.cpp.

                {

  // this needs to change!
  _c   = c_in;
  _pat = pat_in;
  _nbins = bins;
  _units = units;
  _patForTree = _pat.getVectorOfInts();

  smartTitle(c_in,pat_in);


  double mi=0, ma=0;
  for(std::map<DalitzCoordKey, DalitzCoordinate>::iterator it = _c.begin();
      it != _c.end(); it++){
    double eps   = 0.1;
    
    mi = _pat.sijMin(it->second)/_units;
    ma = _pat.sijMax(it->second)/_units;
    
    mi -= (ma-mi)*eps;
    ma += (ma-mi)*eps;
    
    it->second.setMin(mi);
    it->second.setMax(ma);
  }

  makeName();

  counted_ptr<TH1D> local_h(new TH1D(name().c_str(), name().c_str()
                     , _nbins, mi, ma));
  if(0 == local_h){
    cout << "Error in DalitzHistogram::init: local_h = " << local_h << endl;
    throw "annoying";
  }
  local_h->SetDirectory(0);
  local_h->SetNameTitle(hname().c_str(), "");// smartTitle().c_str());
  local_h->Sumw2();
  local_h->SetLineWidth(2);

  std::string unitsName;
  if     (_units == TeV*TeV) unitsName = "TeV^{2}";
  else if(_units == GeV*GeV) unitsName = "GeV^{2}";
  else if(_units == MeV*MeV) unitsName = "MeV^{2}";
  else if(_units == keV*keV) unitsName = "keV^{2}";
  else if(_units ==  eV* eV) unitsName = "eV^{2}";
  else{
    unitsName = anythingToString((int) (_units/(GeV*GeV))) + " GeV^{2}";
  }

  std::string XLabel =  (string)smartTitle().c_str()+ " [" + (string)unitsName + "]";
  local_h->GetXaxis()->SetTitle(XLabel.c_str());
  local_h->GetXaxis()->SetTitleSize();

  double bw = (ma - mi)/((double)_nbins);
  char s[100]={'\0'};
  sprintf(s, "%f", bw);
  std::string st(s);
  std::string YLabel = "Yield / " + st + " " + unitsName;

  local_h->GetYaxis()->SetTitle(YLabel.c_str());

  _h = local_h;

  return;
}

integral()

double DalitzHistogram::integral

(

)

const

Definition at line 776 of file DalitzHistogram.cpp.

                                      {
  if(0 == _h) return 0;
  return _h->Integral();
}

makeDirectory()

bool DalitzHistogram::makeDirectory ( const std::string &  asSubdirOf = "." ) const

private

Definition at line 427 of file DalitzHistogram.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);
}

makeName()

void DalitzHistogram::makeName ( )

private

Definition at line 395 of file DalitzHistogram.cpp.

                              {
  _name = _c.name();
}

multiply()

void DalitzHistogram::multiply

(

const DalitzHistogram &

multiplyWith

)

Definition at line 281 of file DalitzHistogram.cpp.

                                                                 {
  bool dbThis=false;

  if(0 == multiplyWith.histo()){
    cout << "WARNING in DalitzHistogram::multiply(const DalitzHistogram&): "
     << " Trying to mulitply a DalitzHistogram w/o histogram to me"
     << " I'll treat it as a zero (i.e. I'll clear myself of entries)."
     << endl;
    this->clearHisto();
    return;
  }
  if(0 == histo()){
    if(dbThis){
      cout << "WARNING in DalitzHistogram::multiply(const DalitzHistogram&): "
       << " Trying to multiply a DalitzHistogram to me although I have"
       << " no histogram myself - treating myself as zero."
       << endl;
    }
    _h = counted_ptr<TH1>((TH1*) multiplyWith.histo()->Clone());
    if(0 == _h){
      cout << "Error DalitzHistogram::multiply: _h = " << _h << endl;
      throw "should not happen";
    }
    _h->SetDirectory(0);
    _c = multiplyWith._c;
    makeName();
    _h->SetNameTitle(hname().c_str(), htitle().c_str());
    _h->Clear();
    return;
  }
  if(_c != multiplyWith._c){
    cout << "WARNING in DalitzHistogram::multiply(const DalitzHistogram&): "
     << " multiplying histograms for different co-ordinates!"
     << "\n\t" << _c << " != " << multiplyWith._c
     << "\n\t I'll go ahead with it, but it might not be what you want."
     << endl;
  }
  _h->Multiply((multiplyWith.histo().get()));
  return;
}

name()

const std::string& DalitzHistogram::name ( ) const

inline

Definition at line 60 of file DalitzHistogram.h.

{return _name;}

operator=()

DalitzHistogram & DalitzHistogram::operator=

(

const DalitzHistogram &

other

)

Definition at line 123 of file DalitzHistogram.cpp.

                                                                       {
  if(0 != other.histo()){
    _h = counted_ptr<TH1>((TH1*) other.histo()->Clone());
    if(0 == _h){
      cout << "Error in DalitzHistogram = operator"
       << endl;
      throw "oh man!";
    }
    _h->SetDirectory(0);
  }else{
    _h = counted_ptr<TH1>(0);
  }
  _nbins = other._nbins;
  _c     = other._c;
  _pat   = other._pat;
  _name  = other._name;
  _tree  = 0;
  _patForTree = other._patForTree;
  return *this;
}

pattern()

const DalitzEventPattern& DalitzHistogram::pattern ( ) const

inline

Definition at line 67 of file DalitzHistogram.h.

{return _pat;}

retrieveFromDir()

bool DalitzHistogram::retrieveFromDir	(	const std::string &	asSubdirOf = ".",
		const char *	theName = 0
	)

Definition at line 468 of file DalitzHistogram.cpp.

                                            {
  bool success = true;
  if(0 != theName) _name = theName;
  success |= retrieveValues(asSubdirOf, theName);
  
  success |= retrieveHisto(asSubdirOf, theName);
  return success;
}

retrieveHisto()

bool DalitzHistogram::retrieveHisto ( const std::string &  fromDir, const char *  theName = 0  )

private

Definition at line 640 of file DalitzHistogram.cpp.

                                          {
  bool dbThis=false;
  std::string fn = histoFileName(fromDir, theName);
  //  _name = theName();
  TFile* f = TFile::Open(fn.c_str(), "READ");
  if(0 == f){
    cout << "ERROR in DalitzHistogram::retrieveHisto: cannot open file "
     << fn << endl;
    throw "bugger";
  }
  TH1* th = (TH1*) f->Get(hname().c_str());
  if(0 == th){
    cout << "ERROR in DalitzHistogram::retrieveHisto"
     << "\n\t can't find histogram " << hname()
     << "\n\t in file " << fn << endl;
    throw "errorRetrievingHisto";
  }
  th->SetDirectory(0);
  counted_ptr<TH1> cth((TH1*) th->Clone());
  cth->SetDirectory(0);
  _h = cth;
  f->Close();
  if(dbThis){
    cout << "DalitzHistogram::retrieveHisto"
     << "\n\t retrieved histogram " << hname()
     << "\n\t in file " << fn << endl;
    cout << "\t the ptr " << _h.get() << endl;
    cout << "\t the name " << _h->GetTitle() << endl;
  }
  return true;
}

retrieveValues()

bool DalitzHistogram::retrieveValues ( const std::string &  fromDirectory, const char *  theName = 0  )

private

Definition at line 553 of file DalitzHistogram.cpp.

                                           {
  bool dbThis=false;
  std::string fname = valueFileName(fromDirectory, theName);
  if(dbThis)cout << "trying fname = " << fname << endl;
  NamedParameter<double> n_units("units"
                 , fname.c_str()
                 //, NamedParameterBase::QUIET
                 );
  n_units.reloadFile(fname.c_str());
  NamedParameter<int> n_nbins("nbins"
                  ,fname.c_str()
                  //, NamedParameterBase::QUIET
                  );
  NamedParameter<int> n_c("c"
              , fname.c_str()
              //, NamedParameterBase::QUIET
              );
  NamedParameter<int> n_pat("pat"
                , fname.c_str()
                //, NamedParameterBase::QUIET
                );
  NamedParameter<std::string> n_name("name"
                     , fname.c_str()
                     //, NamedParameterBase::QUIET
                     );

  _units = n_units;
  _nbins = n_nbins;
  DalitzCoordinate co(n_c.getVector());
  _c = (DalitzCoordSet) co;
  DalitzEventPattern pa(n_pat.getVector());
  _pat = pa;
  //cout << "after reading in, the pattern is " << _pat << endl;
  _name = n_name;

  return true;
}

saveAsDir()

bool DalitzHistogram::saveAsDir

(

const std::string &

asSubdirOf = "."

)

const

Definition at line 462 of file DalitzHistogram.cpp.

                                                                {
  makeDirectory(asSubdirOf); // ignore error codes from mkdir, they could
  saveValues(asSubdirOf);
  saveHisto(asSubdirOf);
  return true;
}

saveHisto()

bool DalitzHistogram::saveHisto ( const std::string &  inDir = "." ) const

private

Definition at line 592 of file DalitzHistogram.cpp.

                                                           {
  bool dbThis=false;
  if(false && dbThis){
    cout << "DalitzHistogram::saveHisto( " << inDir << " ) got called"
     << endl;
  }

  std::string fn = histoFileName(inDir);

  if(0 == _h) return false;

  //_h->SaveAs(fn.c_str());
  //return true;

  if(dbThis){
    cout << "DalitzHistogram::saveHisto: tryring to save " << fn
     << endl;
  }
  TFile* f = TFile::Open(fn.c_str(), "RECREATE");
  if(0 == f){
    cout << "DalitzHistogram::saveHisto(const std::string& inDir)"
     << " failed to open file " << fn << endl;
    return false;
  }
  if(dbThis){
    cout << "file isOpen " << f->IsOpen() << endl;
    cout << "file isWritable " << f->IsWritable() << endl;
  }
  if(! f->IsWritable()){
    cout << "File " << fn << " not writeable" << endl;
    throw "damn";
  }
  f->cd();
  if(dbThis){
    cout << "cd'ed to file" << endl;
    cout << "number of entries in _h " << _h->GetEntries() << endl;
    cout << "now about to write " << endl;
  }
  _h->Write();
  if(dbThis) cout << "done writing. now closing" << endl;
  f->Close();
  //h->SetDirectory(0);
  if(dbThis) cout << "closed it. Now returning true" << endl;
  //delete f;
  return true;
 
}

saveValues()

bool DalitzHistogram::saveValues ( const std::string &  inDir = "." ) const

private

Definition at line 514 of file DalitzHistogram.cpp.

                                                            {

  NamedParameter<double> n_units("units"
                 , NamedParameterBase::QUIET);
  NamedParameter<int> n_nbins("nbins"
                 ,NamedParameterBase::QUIET);
  NamedParameter<int> n_c("c"
              , NamedParameterBase::QUIET);
  NamedParameter<int> n_pat("pat"
                , NamedParameterBase::QUIET);
  NamedParameter<std::string> n_name("name"
                     , NamedParameterBase::QUIET);
 
  n_units = _units;
  n_nbins  = _nbins;
  n_c     = (std::vector<int>) _c.begin()->first; // needs to change
  //  cout << "pat = " << _pat << endl;
  n_pat   = _pat.getVectorOfInts();
  // cout << "n_pat = " << n_pat << endl;
  n_name  = _name;

  std::string fname = valueFileName(inDir);
  ofstream os(fname.c_str());
  if(os.bad()){
    cout << "ERROR in DalitzHistogram::saveValues of \n\t" << name()
     << "\n\t unable to create file: "
     << "\n\t" << fname << endl;
    return false;
  }
  os << name() 
     << '\n' << n_units
     << '\n' << n_nbins
     << '\n' << n_c 
     << '\n' << n_pat
     << '\n' << n_name
     << endl;
  os.close();
  return true;
}

scale()

void DalitzHistogram::scale

(

double

sf

)

Definition at line 370 of file DalitzHistogram.cpp.

                                    {
  if(0 == _h) return;
  _h->Scale(sf);
}

setNormFactor()

void DalitzHistogram::setNormFactor ( double  f = 1 )

inline

Definition at line 83 of file DalitzHistogram.h.

{_h->SetNormFactor(f);}

setTitle()

void DalitzHistogram::setTitle

(

const std::string &

title

)

Definition at line 374 of file DalitzHistogram.cpp.

                                                    {
  if(0 != _h) _h->SetTitle(title.c_str());
}

smartTitle() [1/2]

void DalitzHistogram::smartTitle	(	const DalitzCoordSet &	c_in,
		const DalitzEventPattern &	pat_in
	)

Definition at line 149 of file DalitzHistogram.cpp.

{
//  pat_in
    TString c_out = c_in.name();
    for (unsigned int i = 1; i< pat_in.size(); i++)
    {
        std::string sij = convertInt(i);
        c_out.ReplaceAll(sij,pat_in[i].name());
    }
        c_out.ReplaceAll("sij","m^{2}");
        c_out.ReplaceAll("K+","K^{+}");
        c_out.ReplaceAll("pi+","#pi^{+}");
        c_out.ReplaceAll("pi-","#pi^{-}");
        c_out.ReplaceAll("Jpsi0","J/#psi");
        c_out.ReplaceAll("psi0","#psi");
        c_out.ReplaceAll("gamma0","#gamma");

        c_out.ReplaceAll(","," ");
    _smartTitle = c_out;
}

smartTitle() [2/2]

const std::string DalitzHistogram::smartTitle

(

)

const

Definition at line 171 of file DalitzHistogram.cpp.

{
    return _smartTitle;
}

valueFileName()

std::string DalitzHistogram::valueFileName ( const std::string &  asSubdirOf = ".", const char *  theName = 0  ) const

private

Definition at line 493 of file DalitzHistogram.cpp.

                                                  {
  std::string dir;
  if(0 == theName){
    dir=dirName();
  }else{
    dir=theName;
  }
  return asSubdirOf + "/" + dir + "/value.txt";
}

Member Data Documentation

_c

DalitzCoordSet DalitzHistogram::_c

private

Definition at line 29 of file DalitzHistogram.h.

_h

MINT::counted_ptr<TH1> DalitzHistogram::_h

private

Definition at line 28 of file DalitzHistogram.h.

_name

std::string DalitzHistogram::_name

private

Definition at line 31 of file DalitzHistogram.h.

_nbins

int DalitzHistogram::_nbins

private

Definition at line 27 of file DalitzHistogram.h.

_pat

DalitzEventPattern DalitzHistogram::_pat

private

Definition at line 30 of file DalitzHistogram.h.

_patForTree

std::vector<int> DalitzHistogram::_patForTree

private

Definition at line 34 of file DalitzHistogram.h.

_smartTitle

std::string DalitzHistogram::_smartTitle

private

Definition at line 32 of file DalitzHistogram.h.

_tree

TTree* DalitzHistogram::_tree

mutableprivate

Definition at line 33 of file DalitzHistogram.h.

_units

double DalitzHistogram::_units

private

Definition at line 26 of file DalitzHistogram.h.

---

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

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