SigAnalysis Class Reference

#include <SigAnalysis.h>

Inheritance diagram for SigAnalysis:

Collaboration diagram for SigAnalysis:

Public Member Functions
	SigAnalysis (const std::string &name)
	~SigAnalysis ()
virtual void	initialise ()
	standard operation interface
virtual void	execute (const std::vector< TIDA::Track * > &reftracks, const std::vector< TIDA::Track * > &testtracks, TrackAssociator *matcher)
virtual void	finalise ()
void	setprint (bool p)
virtual void	execute (const std::vector< TIDA::Track * > &tracks1, const std::vector< TIDA::Track * > &tracks2, TrackAssociator *matcher, TrigObjectMatcher *)
virtual void	execute (const std::vector< TIDA::Track * > &, const std::vector< TIDA::Track * > &, TrackAssociator *, const TIDA::Event *)
virtual void	execute (const std::vector< TIDA::Track * > &tracks1, const std::vector< TIDA::Track * > &tracks2, TrackAssociator *matcher, const TIDA::Event *event, double *)
virtual void	execute (const std::vector< TIDA::Track * > &, const std::vector< TIDA::Track * > &, TrackAssociator *, const TIDA::Event *, double *, TIDARoiDescriptor *)
const std::string &	name () const
	return identifier
virtual void	execute_vtx (const std::vector< TIDA::Vertex * > &, const std::vector< TIDA::Vertex * > &, const TIDA::Event *=0)
void	addHistogram (TH1 *h)
const std::map< std::string, TH1 * > &	getHistograms () const
	access the histograms
std::map< std::string, TH1 * >::const_iterator	begin () const
std::map< std::string, TH1 * >::const_iterator	end () const
void	setBeamRef (double x, double y, double z=0)
	set the beamline positions
void	setBeamRef (const std::vector< double > &v)
void	setBeamTest (double x, double y, double z=0)
void	setBeamTest (const std::vector< double > &v)
double	beamRefx () const
double	beamRefy () const
double	beamRefz () const
double	beamTestx () const
double	beamTesty () const
double	beamTestz () const
TIDA::FeatureStore &	store ()
const TIDA::Event *	event () const
void	setevent (TIDA::Event *e)
const TIDARoiDescriptor *	roi () const
void	setroi (TIDARoiDescriptor *r)

Protected Attributes
std::string	m_name
	identifier of the of the analysis - also used for the root directory into which the histograms are put
double	m_xBeamReference
	beamline positions reference sample
double	m_yBeamReference
double	m_zBeamReference
double	m_xBeamTest
	test sample
double	m_yBeamTest
double	m_zBeamTest
TIDA::FeatureStore	m_store
TIDA::Event *	m_event
TIDARoiDescriptor *	m_roi

Private Member Functions
void	addHistogram (TH1F *h)
TH1F *	find (const std::string &n)

Private Attributes
std::map< std::string, TH1F * >	m_histos
Efficiency1D *	m_eff_pt = nullptr
Efficiency1D *	m_eff_ptp = nullptr
Efficiency1D *	m_eff_ptm = nullptr
Efficiency1D *	m_eff_eta = nullptr
Efficiency1D *	m_eff_phi = nullptr
Efficiency1D *	m_eff_z0 = nullptr
Efficiency1D *	m_eff_d0 = nullptr
Efficiency1D *	m_eff_a0 = nullptr
Efficiency1D *	m_purity_pt = nullptr
Efficiency1D *	m_purity_eta = nullptr
Efficiency1D *	m_purity_phi = nullptr
Efficiency1D *	m_purity_z0 = nullptr
Efficiency1D *	m_purity_d0 = nullptr
Efficiency1D *	m_purity_a0 = nullptr
TH2F *	m_h2 = nullptr
TH2F *	m_h2m = nullptr
TH2F *	m_h2r = nullptr
int	m_Nreco
	number of reconstructed tracks
bool	m_print
	flag to print out the matched tracks etc
int	m_icount
	Event counter.
TIDDirectory *	m_dir

Detailed Description

Definition at line 28 of file SigAnalysis.h.

Constructor & Destructor Documentation

SigAnalysis()

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

inline

Definition at line 36 of file SigAnalysis.h.

                                       : TrackAnalysis( name ), m_Nreco(0), m_print(true), m_icount(0), m_dir(0) {
    std::cout << "SigAnalysis::SigAnalysis() " << TrackAnalysis::name() << std::endl;
  }  

~SigAnalysis()

SigAnalysis::~SigAnalysis ( )

inline

Definition at line 40 of file SigAnalysis.h.

                 {
    std::cout << "SigAnalysis::~SigAnalysis() " << name() << std::endl;
    std::map<std::string, TH1F*>::iterator hitr=m_histos.begin();
    std::map<std::string, TH1F*>::iterator hend=m_histos.end();
    for ( ; hitr!=hend ; ++hitr ) delete hitr->second;
 
    Efficiency1D* heff[4]    = {    m_eff_pt,    m_eff_eta,    m_eff_phi,    m_eff_z0 };
    Efficiency1D* hpurity[4] = { m_purity_pt, m_purity_eta, m_purity_phi, m_purity_z0 };
 
    for ( int i=4 ; i-- ; ) { delete heff[i]; delete hpurity[i]; } 
 
    delete m_eff_ptp;
    delete m_eff_ptm;
 
  }  

Member Function Documentation

addHistogram() [1/2]

void SigAnalysis::addHistogram ( TH1F * h )

inlineprivate

Definition at line 70 of file SigAnalysis.h.

                               { 
      std::string name = h->GetName();
      m_histos.insert( std::map<std::string, TH1F*>::value_type( name, h) );
  }

addHistogram() [2/2]

void TrackAnalysis::addHistogram ( TH1 * h )

inlineinherited

Definition at line 97 of file TrackAnalysis.h.

                              { 
    std::string name = h->GetName();
    m_histos.insert( std::map<std::string, TH1*>::value_type( name, h) );
  }

beamRefx()

double TrackAnalysis::beamRefx ( ) const

inlineinherited

Definition at line 124 of file TrackAnalysis.h.

{ return m_xBeamReference; }

beamRefy()

double TrackAnalysis::beamRefy ( ) const

inlineinherited

Definition at line 125 of file TrackAnalysis.h.

{ return m_yBeamReference; }

beamRefz()

double TrackAnalysis::beamRefz ( ) const

inlineinherited

Definition at line 126 of file TrackAnalysis.h.

{ return m_zBeamReference; }

beamTestx()

double TrackAnalysis::beamTestx ( ) const

inlineinherited

Definition at line 128 of file TrackAnalysis.h.

{ return  m_xBeamTest; }

beamTesty()

double TrackAnalysis::beamTesty ( ) const

inlineinherited

Definition at line 129 of file TrackAnalysis.h.

{ return  m_yBeamTest; }

beamTestz()

double TrackAnalysis::beamTestz ( ) const

inlineinherited

Definition at line 130 of file TrackAnalysis.h.

{ return  m_zBeamTest; }

begin()

std::map< std::string, TH1 * >::const_iterator TrackAnalysis::begin ( ) const

inlineinherited

Definition at line 105 of file TrackAnalysis.h.

{ return m_histos.begin(); }

end()

std::map< std::string, TH1 * >::const_iterator TrackAnalysis::end ( ) const

inlineinherited

Definition at line 106 of file TrackAnalysis.h.

{ return m_histos.end(); }

event()

const TIDA::Event * TrackAnalysis::event ( ) const

inlineinherited

Definition at line 135 of file TrackAnalysis.h.

{ return m_event; }

execute() [1/5]

virtual void TrackAnalysis::execute ( const std::vector< TIDA::Track * > & , const std::vector< TIDA::Track * > & , TrackAssociator * , const TIDA::Event *  )

inlinevirtual

Reimplemented from TrackAnalysis.

Definition at line 68 of file TrackAnalysis.h.

                               { }

execute() [2/5]

virtual void TrackAnalysis::execute ( const std::vector< TIDA::Track * > & , const std::vector< TIDA::Track * > & , TrackAssociator * , const TIDA::Event * , double * , TIDARoiDescriptor *  )

inlinevirtual

Reimplemented from TrackAnalysis.

Definition at line 81 of file TrackAnalysis.h.

                                 { }

execute() [3/5]

void SigAnalysis::execute ( const std::vector< TIDA::Track * > & reftracks, const std::vector< TIDA::Track * > & testtracks, TrackAssociator * matcher )

virtual

Implements TrackAnalysis.

Definition at line 205 of file SigAnalysis.cxx.

{
  if ( m_print ) std::cout << "SigAnalysis::execute() \t " << name() 
               << "\tref "  <<  reftracks.size() 
               << "\ttest " << testtracks.size() << std::endl;
 
  //  std::cout << "\tx " << m_xBeamReference << "\ty " << m_yBeamReference 
  //            << "\tx " << m_xBeamTest      << "\ty " << m_yBeamTest << std::endl;
        
  
  //  std::cout << "SigAnalysis (resolutions really) filling " << std::endl;
 
  // should have these as a class variable   
  static const std::string  varName[10] = { "pT", "eta", "phi", "z0", "d0", "a0", "nsct", "npix", "ntrt", "nstraw" };
 
  //  std::cout << "SigAnalysis ref size " << reftracks.size() << "\ttest size " << testtracks.size() << std::endl; 
  
  std::map<std::string, TH1F*>::iterator hmitr = m_histos.find("ntracks");
  if ( hmitr!=m_histos.end() )   hmitr->second->Fill( reftracks.size() );
  
  hmitr = m_histos.find("ntracks_rec");
  if ( hmitr!=m_histos.end() )   hmitr->second->Fill( testtracks.size() );
 
  bool dump = false;
  
  for ( int i=reftracks.size() ; i-- ; ) { 
     
    double pTt  = reftracks[i]->pT(); 
    double z0t  = reftracks[i]->z0(); 
    double etat = reftracks[i]->eta(); 
    double phit = reftracks[i]->phi(); 
    double d0t  = reftracks[i]->a0(); 
    // this will be changed when we know the beam spot position
    //   double a0t  =  reftracks[i]->a0() + sin(phit)*m_xBeam - cos(phit)*m_yBeam; 
    double a0t  =  reftracks[i]->a0() + sin(phit)*m_xBeamReference - cos(phit)*m_yBeamReference; 
 
    double nsctt = reftracks[i]->sctHits(); 
    double npixt = reftracks[i]->pixelHits(); 
 
    double ntrtt   = reftracks[i]->trHits(); 
    double nstrawt = reftracks[i]->strawHits(); 
 
    //    std::cout << "Fill h2 " << " " << m_h2m << " " << *reftracks[i] << std::endl;
 
    m_h2->Fill( phit, d0t );
 
    const TIDA::Track* matchedreco = matcher->matched(reftracks[i]); 
    
    //    std::cout << "\t\tSigAnalysis " << name() << "\t" << i << " " << *reftracks[i] << " -> ";        
 
    // raw reference track distributions 
    double vpart[10] = { std::fabs(pTt), etat, phit, z0t, d0t, a0t, nsctt, npixt, ntrtt, nstrawt };
    for ( int it=0 ; it<10 ; it++ ) { 
      // std::string hname = varName[it];
      // std::map<std::string, TH1F*>::iterator hmitr = m_histos.find(hname);
      //  if ( hmitr!=m_histos.end() )   hmitr->second->Fill( vpart[it] );
      
      if ( TH1F* hptr = find( varName[it] ) ) hptr->Fill( vpart[it] ); 
      else std::cerr << "hmmm histo " << varName[it] << " not found" << std::endl;
       
    }  
    
    
    if ( matchedreco )  {
       
       // efficiency histos
       m_eff_pt->Fill(std::fabs(pTt));
       m_eff_z0->Fill(z0t);
       m_eff_eta->Fill(etat);
       m_eff_phi->Fill(phit);
       m_eff_d0->Fill(d0t);
       m_eff_a0->Fill(a0t);
       
       // signed pT
       if ( pTt<0 ) m_eff_ptm->Fill(std::fabs(pTt));
       else         m_eff_ptp->Fill(std::fabs(pTt));
       
       // residual histos
       double pTr  = matchedreco->pT();  
       double z0r  = matchedreco->z0(); 
       double etar = matchedreco->eta();
       double phir = matchedreco->phi();
       double d0r  = matchedreco->a0(); 
       double a0r  = matchedreco->a0() + sin(phir)*m_xBeamTest - cos(phir)*m_yBeamTest; // this will be changed when we know the beam spot position
 
       if ( m_h2m ) m_h2m->Fill( phit, d0t );
      
       //       if ( m_print ) std::cout << "SigAnalysis::execute() \t " << name() << "\t" << i << " " 
       if ( m_print ) std::cout << "SigAnalysis::execute() \t\t" << i << " " 
                << *reftracks[i] << " -> " << *matchedreco << "\t" 
                << pTr << " " << pTt << " " << d0r << " " << d0t << std::endl;
    
       double vres[6] = { 1/pTt-1/pTr, etat-etar, phit-phir, z0t-z0r, d0t-d0r, a0t-a0r };
       for ( int it=0 ; it<6 ; it++ ) { 
     if ( TH1F* hptr = find(varName[it]+"_res") ) hptr->Fill( vres[it] ); 
     else std::cerr << "hmmm histo " << varName[it]+"_res" << " not found" << std::endl;
      }  
 
       // in this loop over the reference tracks, could fill efficiency 
       // histograms
 
     }
     else { 
       // fill efficiencies with unmatched histos
       //       std::cout << "NULL" << std::endl;
       m_eff_pt->FillDenom(std::fabs(pTt));
       m_eff_z0->FillDenom(z0t);
       m_eff_eta->FillDenom(etat);
       m_eff_phi->FillDenom(phit);
       m_eff_d0->FillDenom(d0t);
       m_eff_a0->FillDenom(a0t);
 
       // signed pT
       if ( pTt<0 ) m_eff_ptm->FillDenom(std::fabs(pTt));
       else         m_eff_ptp->FillDenom(std::fabs(pTt));
 
       if ( std::fabs(pTt)>4000 ) dump = true; 
     }
     
  }
 
 
  // for fake/purity histograms, loop over the test tracks
  // and get the corresponding matched reference tracks from the 
  // reverse map in the TrackAscociator class  - revmatched() 
 
  if ( m_print ) std::cout << "SigAnalysis::execute() \t " << name() << "\t " << m_icount << " events\t " << testtracks.size() << " tracks (" << m_Nreco << ")" << "\n---------------" << std::endl;
 
  m_icount++;
  
  m_Nreco += testtracks.size();
 
  for ( int i=testtracks.size() ; i-- ; ) { 
     
    //    std::cout << "\t\tSigAnalysis purity " << name() << "\t" << i << " " << *testtracks[i] << " -> ";
 
    //    double pTr  = std::fabs(testtracks[i]->pT()); 
    double pTr  = testtracks[i]->pT(); 
    double etar = testtracks[i]->eta(); 
    double phir = testtracks[i]->phi(); 
    double z0r  = testtracks[i]->z0(); 
    double d0r  = testtracks[i]->a0(); 
    double a0r  = testtracks[i]->a0() + sin(phir)*m_xBeamTest - cos(phir)*m_yBeamTest; // this will be changed when we know the beam spot position
    //    double a0rp = testtracks[i]->a0() - sin(phir)*m_xBeam - cos(phir)*m_yBeam; // this will be changed when we know the beam spot position
 
    //    std::cout << "d0 " << d0r << "\tphi " << phir << "\tx " << m_xBeamTest << "\ty " << m_yBeamTest << std::endl;
 
    double nsctr = testtracks[i]->sctHits(); 
    double npixr = testtracks[i]->pixelHits(); 
 
    double ntrtr   = testtracks[i]->trHits(); 
    double nstrawr = testtracks[i]->strawHits(); 
 
    if ( m_h2r ) m_h2r->Fill( phir, d0r );
 
    const TIDA::Track* matchedref = matcher->revmatched(testtracks[i]); 
 
    //    if ( matchedref )  std::cout << *matchedref << std::endl;
    //    else               std::cout << "NULL" << std::endl;     
        
    // raw test track distributions 
    double vpart[10] = { std::fabs(pTr), etar, phir, z0r, d0r, a0r, nsctr, npixr, ntrtr, nstrawr };
    for ( int it=0 ; it<10 ; it++ ) { 
      // std::string hname = name()+"_"+varName[it]+"_rec";
      //      std::string hname = varName[it]+"_rec";
      //      std::map<std::string, TH1F*>::iterator hmitr = m_histos.find(hname);
      //      if ( hmitr!=m_histos.end() )   hmitr->second->Fill( vpar[it] );
      //      else std::cerr << "hmmm histo " << hname << " not found" << std::endl;
      if ( TH1F* hptr = find(varName[it]+"_rec") ) hptr->Fill( vpart[it] ); 
      else std::cerr << "hmmm histo " << varName[it]+"_rec" << " not found" << std::endl;
    }  
    
    // purities
    if ( matchedref )  {
 
      //       std::cout << *matchedref << std::endl;
       
       m_purity_pt->Fill(std::fabs(pTr));
       m_purity_z0->Fill(z0r);
       m_purity_eta->Fill(etar);
       m_purity_phi->Fill(phir);
       m_purity_d0->Fill(d0r);
       m_purity_a0->Fill(a0r);
       
    }
    else { 
      //       std::cout << "NULL" << std::endl;
       m_purity_pt->FillDenom(std::fabs(pTr));
       m_purity_z0->FillDenom(z0r);
       m_purity_eta->FillDenom(etar);
       m_purity_phi->FillDenom(phir);
       m_purity_d0->FillDenom(d0r);
       m_purity_a0->FillDenom(a0r);
     }
 
  }
 
  if ( dump && m_print ) { 
    
     std::cout << "SigAnalysis::execute() missed a high pT track - dumping tracks" << std::endl;
      
    for ( int i=reftracks.size() ; i-- ; ) {
 
      if ( std::fabs( reftracks[i]->pT() ) > 1000 ) { 
    std::cout << "\t dump " << *reftracks[i];
    const TIDA::Track* matchedreco = matcher->matched(reftracks[i]); 
    if ( matchedreco ) std::cout << " <--> " << *matchedreco << std::endl;
    else               std::cout << std::endl;
      }
 
    }
 
    for ( int i=testtracks.size() ; i-- ; ) {     
      const TIDA::Track* matchedref = matcher->revmatched(testtracks[i]); 
      if ( matchedref==0 ) std::cout << "\t\t\t\t\t " << *testtracks[i] << std::endl;      
    }
 
  }
 
  //  std::cout << "SigAnalysis::execute() exiting" << std::endl;
    
}

execute() [4/5]

virtual void TrackAnalysis::execute ( const std::vector< TIDA::Track * > & tracks1, const std::vector< TIDA::Track * > & tracks2, TrackAssociator * matcher, const TIDA::Event * event, double *  )

inlinevirtual

Reimplemented from TrackAnalysis.

Definition at line 73 of file TrackAnalysis.h.

                      { 
    execute( tracks1, tracks2, matcher, event );
  }

execute() [5/5]

virtual void TrackAnalysis::execute ( const std::vector< TIDA::Track * > & tracks1, const std::vector< TIDA::Track * > & tracks2, TrackAssociator * matcher, TrigObjectMatcher *  )

inlinevirtual

Reimplemented from TrackAnalysis.

Definition at line 61 of file TrackAnalysis.h.

                                   {
    execute( tracks1, tracks2, matcher );
  }

execute_vtx()

virtual void TrackAnalysis::execute_vtx ( const std::vector< TIDA::Vertex * > & , const std::vector< TIDA::Vertex * > & , const TIDA::Event * = 0 )

inlinevirtualinherited

Reimplemented in Analysis_Tier0, and AnalysisR3_Tier0.

Definition at line 89 of file TrackAnalysis.h.

                                      { }  

finalise()

void SigAnalysis::finalise ( )

virtual

Implements TrackAnalysis.

Definition at line 177 of file SigAnalysis.cxx.

                           { 
  std::cout << "SigAnalysis::finalise() " << name() << "\tNreco " << m_Nreco << " tracks" << std::endl;
 
  //  if ( m_Nreco==0 ) return;
 
  m_dir->push();
 
  std::cout << "SigAnalysis::finalise() " << gDirectory->GetName() << std::endl;
 
  //  std::map<std::string, TH1F*>::iterator hitr=m_histos.begin();
  //  std::map<std::string, TH1F*>::iterator hend=m_histos.end();
  //  for ( ; hitr!=hend ; hitr++ ) hitr->second->Write();     
 
  //  std::cout << "DBG >" << m_eff_pt->Hist()->GetName() << "< DBG" << std::endl;
 
  Efficiency1D* heff[8] = { m_eff_pt, m_eff_eta, m_eff_phi, m_eff_z0, m_eff_d0, m_eff_a0, m_eff_ptm, m_eff_ptp };
  for ( int i=8 ; i-- ; ) { heff[i]->finalise();  } // heff[i]->Hist()->Write(); } 
 
  //  std::cout << "DBG >" << m_purity_pt->Hist()->GetName() << "< DBG" << std::endl;
 
  Efficiency1D* hpurity[6] = { m_purity_pt, m_purity_eta, m_purity_phi, m_purity_z0, m_purity_d0, m_purity_a0 };
  for ( int i=6 ; i-- ; ) { hpurity[i]->finalise();  } //  hpurity[i]->Hist()->Write(); } 
 
  m_dir->pop();
 
}

find()

TH1F * SigAnalysis::find ( const std::string & n )

inlineprivate

Definition at line 75 of file SigAnalysis.h.

                                   { 
      std::map<std::string, TH1F*>::iterator hmitr = m_histos.find(n);
      if ( hmitr!=m_histos.end() ) return hmitr->second;
      else                         return 0; 
  }

getHistograms()

const std::map< std::string, TH1 * > & TrackAnalysis::getHistograms ( ) const

inlineinherited

access the histograms

Definition at line 103 of file TrackAnalysis.h.

{ return m_histos; }

initialise()

void SigAnalysis::initialise ( )

virtual

standard operation interface

Implements TrackAnalysis.

Definition at line 13 of file SigAnalysis.cxx.

                             { 
 
  std::cout << "SigAnalysis::initialise() " << name() << std::endl;
  
  //+++ pT ranges
  //  double tmp_maxPt    = 50000.;
  double tmp_absResPt = 0.0005;
 
  const int pTResBins = 100;
 
  //+++ Eta ranges
  double tmp_maxEta    = 3.;
  double tmp_absResEta = 0.04; // 0.0005;
 
  //+++ Phi ranges
  double tmp_maxPhi    = 3.142;
  double tmp_absResPhi = 0.02; // 0.0001;
 
 
  const int etaBins    = 60;
  const int etaResBins = 300;
 
  const int phiBins    = 36;
  const int phiResBins = 100;
 
  const int    zBins = 50;      
  const double zMax  = 400;
 
  const int    zresBins = 100;      
  const double zresMax  = 10;
 
  const int    d0Bins = 100;
  const double d0Max  = 10;
 
  const int    d0resBins = 100;      
  const double d0resMax  = 10;
 
  // beamspot corrected position
 
  const int    a0Bins = 100;
  const double a0Max  = 10;
 
  const int    a0resBins = 100;      
  const double a0resMax  = 5;
 
  //+++ Book histograms
 
  // calculate a logarithmic binning in pt
  
  const int  ptnbins = 20;  
  // const int  ptnbins = 30;  
  double     ptbinlims[ptnbins+1];
  for ( int i=0 ; i<=ptnbins ; i++ ) {     ptbinlims[i] = std::pow(10, 2.0*i/ptnbins+2); }
  // for ( int i=0 ; i<=ptnbins ; i++ ) {     ptbinlims[i] = std::pow(10, 2.3*i/ptnbins+2); }
 
 
 
  TDirectory* dir = gDirectory;
 
  std::cout << "SigAnalysis::initialize() Directory " << gDirectory->GetName() << " " << name() << std::endl;
 
  m_dir = new TIDDirectory(name());
  m_dir->push();
 
  std::cout << "SigAnalysis::initialize() Directory " << gDirectory->GetName() << " package directory, " << name() << std::endl;
 
  Efficiency1D* heff[8];  
  Efficiency1D* hpurity[6]; 
 
  // "reference" quantities
  addHistogram(  new TH1F(  "pT",   "pT",   ptnbins,   ptbinlims ) );
  addHistogram(  new TH1F( "eta",  "eta",   etaBins,  -tmp_maxEta, tmp_maxEta ) );
  addHistogram(  new TH1F( "phi",  "phi",   phiBins,  -tmp_maxPhi, tmp_maxPhi ) );
  addHistogram(  new TH1F(  "z0",   "z0",     zBins,        -zMax,       zMax ) );
  addHistogram(  new TH1F(  "d0",   "d0",    d0Bins,       -d0Max,      d0Max ) );
  addHistogram(  new TH1F(  "a0",   "a0",    a0Bins,       -a0Max,      a0Max ) );
  
  // efficienies and purities
  heff[0]    = new Efficiency1D( find("pT"),  "pT_eff"  );
  heff[1]    = new Efficiency1D( find("eta"), "eta_eff" );
  heff[2]    = new Efficiency1D( find("phi"), "phi_eff" );
  heff[3]    = new Efficiency1D( find("z0"),  "z0_eff"  );
  heff[4]    = new Efficiency1D( find("d0"),  "d0_eff"  );
  heff[5]    = new Efficiency1D( find("a0"),  "a0_eff"  );
  
  heff[6]    = new Efficiency1D( find("pT"), "pTm_eff" );
  heff[7]    = new Efficiency1D( find("pT"), "pTp_eff" );
 
  m_eff_pt  = heff[0];
  m_eff_eta = heff[1];
  m_eff_phi = heff[2];
  m_eff_z0  = heff[3];
  m_eff_d0  = heff[4];
  m_eff_a0  = heff[5];
 
  m_eff_ptm = heff[6];
  m_eff_ptp = heff[7];
  
  hpurity[0] = new Efficiency1D( find("pT"),  "pT_pur"  );
  hpurity[1] = new Efficiency1D( find("eta"), "eta_pur" );
  hpurity[2] = new Efficiency1D( find("phi"), "phi_pur" );
  hpurity[3] = new Efficiency1D( find("z0"),  "z0_pur"  );
  hpurity[4] = new Efficiency1D( find("d0"),  "d0_pur"  );
  hpurity[5] = new Efficiency1D( find("a0"),  "a0_pur"  );
 
  m_purity_pt  = hpurity[0];
  m_purity_eta = hpurity[1];
  m_purity_phi = hpurity[2];
  m_purity_z0  = hpurity[3];
  m_purity_d0  = hpurity[4];
  m_purity_a0  = hpurity[5];
 
  // "test" quantities
  addHistogram(    new TH1F(  "pT_rec",   "pT_rec",   ptnbins,    ptbinlims ) );
  addHistogram(    new TH1F( "eta_rec",  "eta_rec",   etaBins,  -tmp_maxEta, tmp_maxEta ) );
  addHistogram(    new TH1F( "phi_rec",  "phi_rec",   phiBins,  -tmp_maxPhi, tmp_maxPhi ) );
  addHistogram(    new TH1F(  "z0_rec",   "z0_rec",     zBins,        -zMax,       zMax ) );
  addHistogram(    new TH1F(  "d0_rec",   "d0_rec",    d0Bins,       -d0Max,      d0Max ) );
  addHistogram(    new TH1F(  "a0_rec",   "a0_rec",    a0Bins,       -a0Max,      a0Max ) );
    
  // resolutions
  addHistogram(    new TH1F(  "pT_res",   "pT_res",    pTResBins,   -tmp_absResPt,  tmp_absResPt ) );
  addHistogram(    new TH1F( "eta_res",  "eta_res",   etaResBins,  -tmp_absResEta, tmp_absResEta ) );
  addHistogram(    new TH1F( "phi_res",  "phi_res",   phiResBins,  -tmp_absResPhi, tmp_absResPhi ) );
  addHistogram(    new TH1F(  "z0_res",   "z0_res",     zresBins,        -zresMax,       zresMax ) );
  addHistogram(    new TH1F(  "d0_res",   "d0_res",    d0resBins,       -0.5*d0resMax,      0.5*d0resMax ) );
  addHistogram(    new TH1F(  "a0_res",   "a0_res",    a0resBins,       -0.5*a0resMax,      0.5*a0resMax ) );
  
  // hit occupancies
                   
  int   NHits = 40;
  int Ntracks = 50;
 
  addHistogram( new TH1F( "nsct",     "nsct",     NHits, -0.5, float(NHits-0.5) ) );
  addHistogram( new TH1F( "nsct_rec", "nsct_rec", NHits, -0.5, float(NHits-0.5) ) );
 
  addHistogram( new TH1F( "npix",     "npix",     NHits, -0.5, float(NHits-0.5) ) );
  addHistogram( new TH1F( "npix_rec", "npix_rec", NHits, -0.5, float(NHits-0.5) ) );
 
  addHistogram( new TH1F( "ntrt",     "ntrt",     NHits, -0.5, float(NHits-0.5) ) );
  addHistogram( new TH1F( "ntrt_rec", "ntrt_rec", NHits, -0.5, float(NHits-0.5) ) );
 
  addHistogram( new TH1F( "nstraw",     "nstraw",     NHits*4, -0.5, float(4*NHits-0.5) ) );
  addHistogram( new TH1F( "nstraw_rec", "nstraw_rec", NHits*4, -0.5, float(4*NHits-0.5) ) );
 
  addHistogram( new TH1F( "ntracks",     "ntracks",     Ntracks, -0.5, float(Ntracks+0.5) ) );
  addHistogram( new TH1F( "ntracks_rec", "ntracks_rec", Ntracks, -0.5, float(Ntracks+0.5) ) );
  
 
  // beam offset fitting histos
  m_h2  = new TH2F( "d0vphi",       "d0vphi",        phiBins, -3.142, 3.142, d0Bins, -d0Max, d0Max );
  m_h2r = new TH2F( "d0vphi_rec",   "d0vphi_rec",    phiBins, -3.142, 3.142, d0Bins, -d0Max, d0Max );
  m_h2m = new TH2F( "d0vphi_match", "d0vphi_match",  phiBins, -3.142, 3.142, d0Bins, -d0Max, d0Max );
 
  m_dir->pop();
 
  dir->cd();
 
  //  std::cout << "initialize() Directory " << gDirectory->GetName() << " on leaving" << std::endl;
  
}

name()

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

inlineinherited

return identifier

Definition at line 52 of file TrackAnalysis.h.

{ return m_name; }

roi()

const TIDARoiDescriptor * TrackAnalysis::roi ( ) const

inlineinherited

Definition at line 138 of file TrackAnalysis.h.

{ return m_roi; }

setBeamRef() [1/2]

void TrackAnalysis::setBeamRef ( const std::vector< double > & v )

inlineinherited

Definition at line 112 of file TrackAnalysis.h.

                                                 {  
    if ( v.size()>0 ) m_xBeamReference = v[0]; 
    if ( v.size()>1 ) m_yBeamReference = v[1]; 
    if ( v.size()>2 ) m_zBeamReference = v[2]; 
  }

setBeamRef() [2/2]

void TrackAnalysis::setBeamRef ( double x, double y, double z = 0 )

inlineinherited

set the beamline positions

Definition at line 109 of file TrackAnalysis.h.

{  m_xBeamReference = x;  m_yBeamReference = y; m_zBeamReference = z; } 

setBeamTest() [1/2]

void TrackAnalysis::setBeamTest ( const std::vector< double > & v )

inlineinherited

Definition at line 118 of file TrackAnalysis.h.

                                                  { 
    if ( v.size()>0 ) m_xBeamTest = v[0]; 
    if ( v.size()>1 ) m_yBeamTest = v[1]; 
    if ( v.size()>2 ) m_zBeamTest = v[2]; 
  }

setBeamTest() [2/2]

void TrackAnalysis::setBeamTest ( double x, double y, double z = 0 )

inlineinherited

Definition at line 110 of file TrackAnalysis.h.

{  m_xBeamTest      = x;       m_yBeamTest = y;      m_zBeamTest = z; }

setevent()

void TrackAnalysis::setevent ( TIDA::Event * e )

inlineinherited

Definition at line 136 of file TrackAnalysis.h.

{ m_event=e; }

setprint()

void SigAnalysis::setprint ( bool p )

inline

Definition at line 66 of file SigAnalysis.h.

{ m_print=p; }

setroi()

void TrackAnalysis::setroi ( TIDARoiDescriptor * r )

inlineinherited

Definition at line 139 of file TrackAnalysis.h.

{ m_roi=r; }

store()

TIDA::FeatureStore & TrackAnalysis::store ( )

inlineinherited

Definition at line 133 of file TrackAnalysis.h.

{ return m_store; }

Member Data Documentation

m_dir

TIDDirectory* SigAnalysis::m_dir

private

Definition at line 116 of file SigAnalysis.h.

m_eff_a0

Efficiency1D* SigAnalysis::m_eff_a0 = nullptr

private

Definition at line 93 of file SigAnalysis.h.

m_eff_d0

Efficiency1D* SigAnalysis::m_eff_d0 = nullptr

private

Definition at line 92 of file SigAnalysis.h.

m_eff_eta

Efficiency1D* SigAnalysis::m_eff_eta = nullptr

private

Definition at line 89 of file SigAnalysis.h.

m_eff_phi

Efficiency1D* SigAnalysis::m_eff_phi = nullptr

private

Definition at line 90 of file SigAnalysis.h.

m_eff_pt

Efficiency1D* SigAnalysis::m_eff_pt = nullptr

private

Definition at line 85 of file SigAnalysis.h.

m_eff_ptm

Efficiency1D* SigAnalysis::m_eff_ptm = nullptr

private

Definition at line 87 of file SigAnalysis.h.

m_eff_ptp

Efficiency1D* SigAnalysis::m_eff_ptp = nullptr

private

Definition at line 86 of file SigAnalysis.h.

m_eff_z0

Efficiency1D* SigAnalysis::m_eff_z0 = nullptr

private

Definition at line 91 of file SigAnalysis.h.

m_event

TIDA::Event* TrackAnalysis::m_event

protectedinherited

Definition at line 164 of file TrackAnalysis.h.

m_h2

TH2F* SigAnalysis::m_h2 = nullptr

private

Definition at line 103 of file SigAnalysis.h.

m_h2m

TH2F* SigAnalysis::m_h2m = nullptr

private

Definition at line 104 of file SigAnalysis.h.

m_h2r

TH2F* SigAnalysis::m_h2r = nullptr

private

Definition at line 105 of file SigAnalysis.h.

m_histos

std::map<std::string, TH1F*> SigAnalysis::m_histos

private

Definition at line 83 of file SigAnalysis.h.

m_icount

int SigAnalysis::m_icount

private

Event counter.

Definition at line 114 of file SigAnalysis.h.

m_name

std::string TrackAnalysis::m_name

protectedinherited

identifier of the of the analysis - also used for the root directory into which the histograms are put

Definition at line 145 of file TrackAnalysis.h.

m_Nreco

int SigAnalysis::m_Nreco

private

number of reconstructed tracks

Definition at line 108 of file SigAnalysis.h.

m_print

bool SigAnalysis::m_print

private

flag to print out the matched tracks etc

Definition at line 111 of file SigAnalysis.h.

m_purity_a0

Efficiency1D* SigAnalysis::m_purity_a0 = nullptr

private

Definition at line 100 of file SigAnalysis.h.

m_purity_d0

Efficiency1D* SigAnalysis::m_purity_d0 = nullptr

private

Definition at line 99 of file SigAnalysis.h.

m_purity_eta

Efficiency1D* SigAnalysis::m_purity_eta = nullptr

private

Definition at line 96 of file SigAnalysis.h.

m_purity_phi

Efficiency1D* SigAnalysis::m_purity_phi = nullptr

private

Definition at line 97 of file SigAnalysis.h.

m_purity_pt

Efficiency1D* SigAnalysis::m_purity_pt = nullptr

private

Definition at line 95 of file SigAnalysis.h.

m_purity_z0

Efficiency1D* SigAnalysis::m_purity_z0 = nullptr

private

Definition at line 98 of file SigAnalysis.h.

m_roi

TIDARoiDescriptor* TrackAnalysis::m_roi

protectedinherited

Definition at line 165 of file TrackAnalysis.h.

m_store

TIDA::FeatureStore TrackAnalysis::m_store

protectedinherited

Definition at line 162 of file TrackAnalysis.h.

m_xBeamReference

double TrackAnalysis::m_xBeamReference

protectedinherited

beamline positions reference sample

Definition at line 153 of file TrackAnalysis.h.

m_xBeamTest

double TrackAnalysis::m_xBeamTest

protectedinherited

test sample

Definition at line 158 of file TrackAnalysis.h.

m_yBeamReference

double TrackAnalysis::m_yBeamReference

protectedinherited

Definition at line 154 of file TrackAnalysis.h.

m_yBeamTest

double TrackAnalysis::m_yBeamTest

protectedinherited

Definition at line 159 of file TrackAnalysis.h.

m_zBeamReference

double TrackAnalysis::m_zBeamReference

protectedinherited

Definition at line 155 of file TrackAnalysis.h.

m_zBeamTest

double TrackAnalysis::m_zBeamTest

protectedinherited

Definition at line 160 of file TrackAnalysis.h.

---

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

• SigAnalysis.h
• SigAnalysis.cxx