Analysis_Tier0 Class Reference

#include <Analysis_Tier0.h>

Inheritance diagram for Analysis_Tier0:

Collaboration diagram for Analysis_Tier0:

Public Member Functions
	Analysis_Tier0 (const std::string &name, double pTCut, double etaCut, double d0Cut, double z0Cut)
virtual void	initialise ()
	standard operation interface
virtual void	execute (const std::vector< TIDA::Track * > &referenceTracks, const std::vector< TIDA::Track * > &testTracks, TrackAssociator *associator)
virtual void	execute_vtx (const std::vector< TIDA::Vertex * > &vtx0, const std::vector< TIDA::Vertex * > &vtx1, const TIDA::Event *tevt=0)
virtual void	finalise ()
void	setvertices (int numvtx)
std::map< std::string, TH1 * >::const_iterator	THbegin () const
std::map< std::string, TH1 * >::const_iterator	THend () const
std::map< std::string, TProfile * >::const_iterator	TEffbegin () const
std::map< std::string, TProfile * >::const_iterator	TEffend () const
void	set_monTool (ToolHandle< GenericMonitoringTool > *m)
ToolHandle< GenericMonitoringTool > *	monTool ()
bool	debug () const
void	addHistogram (TH1 *h)
void	addHistogram (TProfile *h)
double	phi (double 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
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 Attributes
std::map< std::string, TH1 * >	m_histos
std::map< std::string, TProfile * >	m_effhistos
TProfile *	m_h_total_efficiency
TProfile *	m_h_pTeff
TProfile *	m_h_etaeff
TProfile *	m_h_phieff
TProfile *	m_h_d0eff
TProfile *	m_h_z0eff
TProfile *	m_h_nVtxeff
TProfile *	m_h_lbeff
TProfile *	m_h_pTres
TProfile *	m_h_ipTres
TProfile *	m_h_etares
TProfile *	m_h_phires
TProfile *	m_h_d0res
TProfile *	m_h_z0res
TProfile *	m_h_trkvtx_x_lb
TProfile *	m_h_trkvtx_y_lb
TProfile *	m_h_trkvtx_z_lb
TProfile *	m_h_npixvseta
TProfile *	m_h_npixvsphi
TProfile *	m_h_npixvsd0
TProfile *	m_h_npixvspT
TProfile *	m_h_nsctvseta
TProfile *	m_h_nsctvsphi
TProfile *	m_h_nsctvsd0
TProfile *	m_h_nsctvspT
TProfile *	m_h_ntrtvseta
TProfile *	m_h_ntrtvsphi
TProfile *	m_h_nsihits_lb
TProfile *	m_h_npixvseta_rec
TProfile *	m_h_npixvsphi_rec
TProfile *	m_h_npixvsd0_rec
TProfile *	m_h_npixvspT_rec
TProfile *	m_h_nsctvseta_rec
TProfile *	m_h_nsctvsphi_rec
TProfile *	m_h_nsctvsd0_rec
TProfile *	m_h_nsctvspT_rec
TProfile *	m_h_ntrtvseta_rec
TProfile *	m_h_ntrtvsphi_rec
TProfile *	m_h_nsihits_lb_rec
TProfile *	m_h_d0vsphi
TProfile *	m_h_d0vsphi_rec
TH1F *	m_h_chain
TH1F *	m_h_ntrk
TH1F *	m_h_trkpT
TH1F *	m_h_trketa
TH1F *	m_h_trkphi
TH1F *	m_h_trkd0
TH1F *	m_h_trkz0
TH1F *	m_h_trkdd0
TH1F *	m_h_trkdz0
TH1F *	m_h_trkd0sig
TH1F *	m_h_npix
TH1F *	m_h_nsct
TH1F *	m_h_nsihits
TH1F *	m_h_ntrt
TH1F *	m_h_ntrk_rec
TH1F *	m_h_layer
TH1F *	m_h_trkpT_rec
TH1F *	m_h_trketa_rec
TH1F *	m_h_trkphi_rec
TH1F *	m_h_trkd0_rec
TH1F *	m_h_trkz0_rec
TH1F *	m_h_trkdd0_rec
TH1F *	m_h_trkdz0_rec
TH1F *	m_h_trkd0sig_rec
TH1F *	m_h_npix_rec
TH1F *	m_h_nsct_rec
TH1F *	m_h_nsihits_rec
TH1F *	m_h_ntrt_rec
TH1F *	m_h_layer_rec
TH1F *	m_h_trkpT_residual
TH1F *	m_h_trkipT_residual
TH1F *	m_h_trketa_residual
TH1F *	m_h_trkphi_residual
TH1F *	m_h_trkd0_residual
TH1F *	m_h_trkz0_residual
TH1F *	m_h_trkdd0_residual
TH1F *	m_h_trkdz0_residual
int	m_nVtx
bool	m_debug
unsigned long long	m_eventid
VtxAnalysis *	m_vtxanal
ToolHandle< GenericMonitoringTool > *	m_monTool

Detailed Description

Definition at line 30 of file Analysis_Tier0.h.

Constructor & Destructor Documentation

Analysis_Tier0()

Analysis_Tier0::Analysis_Tier0	(	const std::string &	name,
		double	pTCut,
		double	etaCut,
		double	d0Cut,
		double	z0Cut )

Definition at line 18 of file Analysis_Tier0.cxx.

  : TrackAnalysis(name),
    // m_pTCut(pTCut), /// left in commented for development purposes
    // m_etaCut(etaCut),
    // m_d0Cut(d0Cut),
    // m_z0Cut(z0Cut),
    m_h_total_efficiency{nullptr},
    m_h_pTeff{nullptr},
    m_h_etaeff{nullptr},
    m_h_phieff{nullptr},
    m_h_d0eff{nullptr},
    m_h_z0eff{nullptr},
    m_h_nVtxeff{nullptr},
    m_h_lbeff{nullptr},
    m_h_pTres{nullptr},
    m_h_ipTres{nullptr},
    m_h_etares{nullptr},
    m_h_phires{nullptr},
    m_h_d0res{nullptr},
    m_h_z0res{nullptr},
    m_h_trkvtx_x_lb{nullptr},
    m_h_trkvtx_y_lb{nullptr},
    m_h_trkvtx_z_lb{nullptr},
    m_h_npixvseta{nullptr},
    m_h_npixvsphi{nullptr},
    m_h_npixvsd0{nullptr},
    m_h_npixvspT{nullptr},
    m_h_nsctvseta{nullptr},
    m_h_nsctvsphi{nullptr},
    m_h_nsctvsd0{nullptr},
    m_h_nsctvspT{nullptr},
    m_h_ntrtvseta{nullptr},
    m_h_ntrtvsphi{nullptr},
    m_h_nsihits_lb{nullptr},
    m_h_npixvseta_rec{nullptr},
    m_h_npixvsphi_rec{nullptr},
    m_h_npixvsd0_rec{nullptr},
    m_h_npixvspT_rec{nullptr},
    m_h_nsctvseta_rec{nullptr},
    m_h_nsctvsphi_rec{nullptr},
    m_h_nsctvsd0_rec{nullptr},
    m_h_nsctvspT_rec{nullptr},
    m_h_ntrtvseta_rec{nullptr},
    m_h_ntrtvsphi_rec{nullptr},
    m_h_nsihits_lb_rec{nullptr},
    m_h_d0vsphi{nullptr},
    m_h_d0vsphi_rec{nullptr},
    m_h_chain{nullptr},
    m_h_ntrk{nullptr},
    m_h_trkpT{nullptr},
    m_h_trketa{nullptr},
    m_h_trkphi{nullptr},
    m_h_trkd0{nullptr},
    m_h_trkz0{nullptr},
    m_h_trkdd0{nullptr},
    m_h_trkdz0{nullptr},
    m_h_trkd0sig{nullptr},
    m_h_npix{nullptr},
    m_h_nsct{nullptr},
    m_h_nsihits{nullptr},
    m_h_ntrt{nullptr},
    m_h_ntrk_rec{nullptr},
    m_h_layer{nullptr},
    m_h_trkpT_rec{nullptr},
    m_h_trketa_rec{nullptr},
    m_h_trkphi_rec{nullptr},
    m_h_trkd0_rec{nullptr},
    m_h_trkz0_rec{nullptr},
    m_h_trkdd0_rec{nullptr},
    m_h_trkdz0_rec{nullptr},
    m_h_trkd0sig_rec{nullptr},
    m_h_npix_rec{nullptr},
    m_h_nsct_rec{nullptr},
    m_h_nsihits_rec{nullptr},
    m_h_ntrt_rec{nullptr},
    m_h_layer_rec{nullptr},
    m_h_trkpT_residual{nullptr},
    m_h_trkipT_residual{nullptr},
    m_h_trketa_residual{nullptr},
    m_h_trkphi_residual{nullptr},
    m_h_trkd0_residual{nullptr},
    m_h_trkz0_residual{nullptr},
    m_h_trkdd0_residual{nullptr},
    m_h_trkdz0_residual{nullptr},
    m_nVtx(0),
    m_debug(false),
    m_eventid(0),
    m_vtxanal(nullptr),
    m_monTool(nullptr)
{}

Member Function Documentation

addHistogram() [1/2]

void Analysis_Tier0::addHistogram ( TH1 * h )

inline

Definition at line 70 of file Analysis_Tier0.h.

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

addHistogram() [2/2]

void Analysis_Tier0::addHistogram ( TProfile * h )

inline

Definition at line 75 of file Analysis_Tier0.h.

                                   {
    std::string name = h->GetName();
    m_effhistos.insert( std::map<std::string, TProfile*>::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(); }

debug()

bool Analysis_Tier0::debug ( ) const

inline

Definition at line 66 of file Analysis_Tier0.h.

{ return m_debug; }

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 Analysis_Tier0::execute ( const std::vector< TIDA::Track * > & referenceTracks, const std::vector< TIDA::Track * > & testTracks, TrackAssociator * associator )

virtual

Loop over reference tracks

fill number of times this analysis was called - presumably the number of passed RoIs for this chain

if the event number has changed, this is a new event so update the event counts

fil the number of offline tracks

fil the number of offline tracks

NB: do we want to fill the actual trigger quantities, or the offline quantities for the matched tracks?

residual profiles vs the reference variable

residual profiles vs eta - the more easy to understand

test track distributions for test tracks with a reference track match

1d residual distributions

Implements TrackAnalysis.

Definition at line 553 of file Analysis_Tier0.cxx.

                                               { 
  
  std::vector<TIDA::Track*>::const_iterator  reference    = referenceTracks.begin();
  std::vector<TIDA::Track*>::const_iterator  referenceEnd = referenceTracks.end();

  m_h_chain->Fill( 0.5 );
 
  if ( m_eventid != event()->event_number() ) { 
    m_eventid = event()->event_number(); 
    m_h_chain->Fill( 1.5 );
  }
 
  m_h_ntrk->Fill( referenceTracks.size() );
  m_h_ntrk_rec->Fill( testTracks.size() );

  m_h_chain->Fill(4.5, testTracks.size() );
 
 
  for( ; reference!=referenceEnd ; ++reference ) {
    
    // Get reference parameters
    double referenceEta = (*reference)->eta();
    double referencePhi = phi((*reference)->phi());
    double referenceZ0  = (*reference)->z0();
    double referenceD0  = (*reference)->a0();
    double referencePT  = (*reference)->pT();
 
    double referenceDZ0  = (*reference)->dz0();
    double referenceDD0  = (*reference)->da0();
    
    // Find matched tracks
    const TIDA::Track* test = associator->matched(*reference);
 
    double    eff_weight = 0;
    if (test) eff_weight = 1;
 
    m_h_total_efficiency->Fill(0.5, eff_weight );
 
    m_h_pTeff->Fill( std::fabs(referencePT)*0.001, eff_weight );
    m_h_z0eff->Fill( referenceZ0, eff_weight );
    m_h_d0eff->Fill( referenceD0, eff_weight );
    m_h_etaeff->Fill( referenceEta, eff_weight );
    m_h_phieff->Fill( referencePhi, eff_weight );
    m_h_nVtxeff->Fill( m_nVtx, eff_weight );
 
    m_h_lbeff->Fill( event()->lumi_block(), eff_weight );
 
    m_h_trkpT->Fill( std::fabs(referencePT)*0.001 );
    m_h_trketa->Fill( referenceEta );
    m_h_trkphi->Fill( referencePhi );
    m_h_trkd0->Fill( referenceD0 );
    m_h_trkz0->Fill( referenceZ0 );
 
    m_h_trkdd0->Fill( referenceDD0 );
    m_h_trkdz0->Fill( referenceDZ0 );
 
    if ( referenceDD0!=0 )  m_h_trkd0sig->Fill( referenceD0/referenceDD0 );
 
    m_h_npixvseta->Fill( referenceEta,  int(((*reference)->pixelHits()+0.5)*0.5) );
    m_h_nsctvseta->Fill( referenceEta,  (*reference)->sctHits() );
    m_h_ntrtvseta->Fill( referenceEta,  (*reference)->strawHits() );
 
 
    m_h_npixvsphi->Fill( referencePhi,  int(((*reference)->pixelHits()+0.5)*0.5) );
    m_h_nsctvsphi->Fill( referencePhi,  (*reference)->sctHits() );
    m_h_ntrtvsphi->Fill( referencePhi,  (*reference)->strawHits() );
 
    m_h_npixvsd0->Fill( referenceD0,  int(((*reference)->pixelHits()+0.5)*0.5) );
    m_h_nsctvsd0->Fill( referenceD0,  (*reference)->sctHits() );
 
    m_h_npixvspT->Fill( std::fabs(referencePT)*0.001,  int(((*reference)->pixelHits()+0.5)*0.5) );
    m_h_nsctvspT->Fill( std::fabs(referencePT)*0.001,  (*reference)->sctHits() );
 
 
    m_h_npix->Fill(  int(((*reference)->pixelHits()+0.5)*0.5) );
    m_h_nsct->Fill(  (*reference)->sctHits() );
    m_h_nsihits->Fill(  (*reference)->siHits() );
    m_h_ntrt->Fill(  (*reference)->strawHits() );
   
 
    m_h_nsihits_lb->Fill( event()->lumi_block(), (*reference)->siHits() );
 
    m_h_d0vsphi->Fill(referencePhi, referenceD0 );
 
    m_h_chain->Fill(2.5);
 
 
    for ( size_t ilayer=0 ; ilayer<32 ; ilayer++ ) { 
      if ( (*reference)->hitPattern()&(1U<<ilayer) ) m_h_layer->Fill( ilayer );
    } 
    
    if (test) {
 
      m_h_chain->Fill(3.5);


      // m_h_pTres->Fill( referencePT*0.001, (test->pT() - referencePT)*0.001 );
      // m_h_ipTres->Fill( 1000/referencePT, (1000/test->pT() - 1000/referencePT) );
      // m_h_etares->Fill( referenceEta, test->eta() - referenceEta );
      // m_h_phires->Fill( referencePhi, phi(test->phi() - referencePhi) );
      // m_h_d0res->Fill( referenceD0, test->a0() - referenceD0 );
      // m_h_z0res->Fill( referenceZ0, test->z0() - referenceZ0  );

      m_h_pTres->Fill( referenceEta, (test->pT() - referencePT)*0.001 );
      m_h_ipTres->Fill( referenceEta, (1000/test->pT() - 1000/referencePT) );
      m_h_etares->Fill( referenceEta, test->eta() - referenceEta );
      m_h_phires->Fill( referenceEta, phi(test->phi() - referencePhi) );
      m_h_d0res->Fill( referenceEta, test->a0() - referenceD0 );
      m_h_z0res->Fill( referenceEta, test->z0() - referenceZ0  );
 
      m_h_trkvtx_x_lb->Fill( event()->lumi_block(), beamTestx() );
      m_h_trkvtx_y_lb->Fill( event()->lumi_block(), beamTesty() );
      m_h_trkvtx_z_lb->Fill( event()->lumi_block(), beamTestz() );
 
      for ( size_t ilayer=0 ; ilayer<32 ; ilayer++ ) { 
    if ( test->hitPattern()&(1U<<ilayer) ) m_h_layer_rec->Fill( ilayer );
      } 
 
      //      std::cout << "SUTT beam x " << beamTestx() << " " << "\tx " << beamTesty() << " " <<  "\ty " << beamTestz() << std::endl;
 
#if 0
      m_h_trkpT_rec->Fill( referencePT*0.001 );
      m_h_trketa_rec->Fill( referenceEta );
      m_h_trkphi_rec->Fill( referencePhi );
      m_h_trkd0_rec->Fill( referenceD0 );
      m_h_trkz0_rec->Fill( referenceZ0 );
     
#endif

      m_h_trkpT_rec->Fill( std::fabs(test->pT())*0.001 );
      m_h_trketa_rec->Fill( test->eta() );
      m_h_trkphi_rec->Fill( test->phi() );
      m_h_trkd0_rec->Fill( test->a0() );
      m_h_trkz0_rec->Fill( test->z0() );
 
      m_h_trkdd0_rec->Fill( test->da0() );
      m_h_trkdz0_rec->Fill( test->dz0() );
 
      if ( test->da0()!=0 )  m_h_trkd0sig_rec->Fill( test->a0()/test->da0() );
 

      m_h_trkpT_residual->Fill( (test->pT() - referencePT)*0.001 );
      m_h_trkipT_residual->Fill( (1000/test->pT() - 1000/referencePT) );
      m_h_trketa_residual->Fill( test->eta() - referenceEta );
      m_h_trkphi_residual->Fill( phi(test->phi() - referencePhi) );
 
      m_h_trkd0_residual->Fill(  test->a0() - referenceD0 );
      m_h_trkz0_residual->Fill( test->z0() - referenceZ0  );
 
      m_h_trkdd0_residual->Fill( test->da0() - referenceDD0 );
      m_h_trkdz0_residual->Fill( test->dz0() - referenceDZ0  );
 
      m_h_npixvseta_rec->Fill( referenceEta, int((test->pixelHits()+0.5)*0.5) );
      m_h_nsctvseta_rec->Fill( referenceEta, test->sctHits() );
 
      m_h_npixvsphi_rec->Fill( referencePhi, int((test->pixelHits()+0.5)*0.5) );
      m_h_nsctvsphi_rec->Fill( referencePhi, test->sctHits() );
 
      m_h_npixvsd0_rec->Fill( referenceD0, int((test->pixelHits()+0.5)*0.5) );
      m_h_nsctvsd0_rec->Fill( referenceD0, test->sctHits() );
 
      m_h_npixvspT_rec->Fill( std::fabs(referencePT)*0.001,  int((test->pixelHits()+0.5)*0.5) );
      m_h_nsctvspT_rec->Fill( std::fabs(referencePT)*0.001,  test->sctHits() );
 
      m_h_npix_rec->Fill(  int((test->pixelHits()+0.5)*0.5) );
      m_h_nsct_rec->Fill(  test->sctHits() );
      m_h_nsihits_rec->Fill(  test->siHits() );
 
      m_h_nsihits_lb_rec->Fill( event()->lumi_block(), test->siHits() );
    
 
      m_h_ntrt_rec->Fill(  test->strawHits() );
 
      m_h_ntrtvseta_rec->Fill( referenceEta, test->strawHits() );
      m_h_ntrtvsphi_rec->Fill( referencePhi, test->strawHits() );
 
      m_h_d0vsphi_rec->Fill( test->phi(), test->a0() );
 
    }
    
  }
}

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()

void Analysis_Tier0::execute_vtx ( const std::vector< TIDA::Vertex * > & vtx0, const std::vector< TIDA::Vertex * > & vtx1, const TIDA::Event * tevt = 0 )

virtual

Reimplemented from TrackAnalysis.

Definition at line 755 of file Analysis_Tier0.cxx.

                                         { 
  if ( m_vtxanal ) m_vtxanal->execute( vtx0, vtx1, tevt );
}

finalise()

void Analysis_Tier0::finalise ( )

virtual

Implements TrackAnalysis.

Definition at line 762 of file Analysis_Tier0.cxx.

                              {
  if ( m_vtxanal ) m_vtxanal->finalise();
} 

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 Analysis_Tier0::initialise ( )

virtual

standard operation interface

archive the chain name

variable width bins for track occupancy

Limit the bins - to only the first 77 bins - so a range up to ~ 1000 leave the previous selection commented for the time being

reference track distributions

the error estimates are always positive ...

test track distributions

Limit the bins - to only the first 77 bins - so a range up to ~ 1000 leave the previous selection commented for the time being

trigger tracking efficiencies

han config too stufid to deal with spaces in histogram names

trigger tracking differential resolutions

change all these residiuals to be vs eta, rather than vs themselves

residuals

miscelaneous histograms

if ( cnams.extra().find("probe")!=std::string::npos ) { m_h_invmass = new TH1F( "invmass", "invariant mass;mass [GeV]", 320, 0, 200 ); addHistogram( m_h_invmass ); }

vertex analyses if required ...

is this needed ?

initialise the vtx analysis

store the historams

Implements TrackAnalysis.

Definition at line 113 of file Analysis_Tier0.cxx.

                                {
 
  ChainString cname = name();
 
  //  std::cout << "Analysis_Tier0::initialise() name " << name() << std::endl; 
 
#if 0
  std::cout << "\nAnalysis_Tier0:: chain specification: " << cname << "\t" << cname.raw() << std::endl;
  std::cout << "\tchain: " << cname.head()    << std::endl;
  std::cout << "\tkey:   " << cname.tail()    << std::endl;
  std::cout << "\troi:   " << cname.roi()     << std::endl;
  std::cout << "\tvtx:   " << cname.vtx()     << std::endl;
  std::cout << "\tte:    " << cname.element() << std::endl;
#endif
 
  m_debug = false;
 
  m_h_chain = new TH1F( "Chain", cname.c_str(), 5, 0, 5 );
  m_h_chain->GetXaxis()->SetBinLabel(1, "Nrois" );
  m_h_chain->GetXaxis()->SetBinLabel(2, "Nevents" );
  m_h_chain->GetXaxis()->SetBinLabel(3, "N ref tracks" );
  m_h_chain->GetXaxis()->SetBinLabel(4, "N matched tracks" );
  m_h_chain->GetXaxis()->SetBinLabel(5, "N total test tracks" );
 
 
 
  addHistogram(m_h_chain);

 
#if 0
  
  double vnbins[81] = {
   -0.5,
    0.5,    1.5,    2.5,    3.5,    4.5,    5.5,    6.5,    7.5,    8.5,    9.5,
    10.5,   11.5,   12.5,   13.5,   14.5,   15.5,   16.5,   17.5,   18.5,   19.5,
    20.5,   21.5,   22.5,   23.5,   24.5,   25.5,   26.5,   27.5,   28.5,   29.5,
    31.5,   32.5,   33.5,   34.5,   36.5,   37.5,   39.5,
    40.5,   42.5,   43.5,   45.5,   47.5,   49.5,
    50.5,   52.5,   54.5,   57.5,   59.5,
    61.5,   63.5,   66.5,   69.5,
    71.5,   74.5,   77.5,
    80.5,   83.5,   86.5,
    90.5,   93.5,   97.5,
    100.5,  104.5,  108.5,
    113.5,  117.5,
    122.5,  126.5,
    131.5,  136.5,
    142.5,  147.5,
    153.5,  159.5,
    165.5,
    171.5,  178.5,
    185.5,
    192.5,
    200.5 };
#endif
 
  double vnbins[101] = { 
    -0.5,
    0.5,   1.5,   2.5,   3.5,   4.5,   5.5,   6.5,   7.5,   8.5,   9.5,   10.5,   11.5,   12.5,   13.5,   14.5,   15.5,   17.5,   18.5,   19.5,   21.5,
    23.5,   24.5,   26.5,   28.5,   30.5,   32.5,   35.5,   37.5,   40.5,   43.5,   46.5,   50.5,   53.5,   57.5,   61.5,   66.5,   71.5,   76.5,   81.5,   87.5,
    93.5,   100.5,   107.5,   114.5,   123.5,   131.5,   141.5,   150.5,   161.5,   172.5,   185.5,   198.5,   211.5,   226.5,   242.5,   259.5,   277.5,   297.5,   317.5,   340.5,
    363.5,   389.5,   416.5,   445.5,   476.5,   509.5,
    544.5,   582.5,   623.5,   666.5,   713.5,   762.5,   815.5,   872.5,   933.5,   998.5,   1067.5,
    1141.5,   1221.5,   1305.5,   1396.5,   1493.5,   1597.5,
    1708.5,   1827.5,   1953.5,   2089.5,
    2234.5,   2389.5,   2555.5,
    2733.5,   2923.5,   3125.5,
    3342.5,   3574.5,
    3823.5,   4088.5,
    4372.5,   4675.5,
     5000.5
  };
 

  // m_h_ntrk = new TH1F( "reftrk_N", "Reference tracks", 100, vnbins );
  m_h_ntrk = new TH1F( "reftrk_N", "Reference tracks", 77, vnbins );
 
  addHistogram(m_h_ntrk);

 
  //  double pt_bins[25] = { 0, 1, 2, 3, 4, 8, 10, 12, 14, 16, 18, 20, 25, 30, 35, 40, 45, 50, 60, 70, 80, 90, 100 }; 
 
  std::vector<double> ptbins;
 
  for ( int i=0 ; i<=25 ; i++ ) {
 
    double y = std::log10(1) + i*( std::log10(100)-std::log10(1) )/25;
    
    double x = std::pow(10, y);
    ptbins.push_back(x);
 
  }
 
  //  m_h_trkpT  = new TH1F("reftrk_pT" , "Reference track pT",  50,    0.,    100.);
  m_h_trkpT  = new TH1F("reftrk_pT" , "Reference track pT",  25,   &ptbins[0]   );
  m_h_trkphi = new TH1F("reftrk_phi", "Reference track Phi", 25,   -M_PI,   M_PI);
  m_h_trketa = new TH1F("reftrk_eta", "Reference track Eta", 25,   -2.5,     2.5) ;
  if (name().find("LRT")!=std::string::npos || name().find("lrt")!=std::string::npos) { 
    m_h_trkd0  = new TH1F("reftrk_d0" , "Reference track d0", 201, -100.0,  100.0 );
  } else { 
    m_h_trkd0  = new TH1F("reftrk_d0" , "Reference track d0", 101,   -5.0,    5.0 );
  }      
  m_h_trkz0  = new TH1F("reftrk_z0" , "Reference track z0",  50,   -225.,    225.);

  m_h_trkdd0  = new TH1F("reftrk_dd0" , "Reference track sigma(d0)", 50,  0,     0.5);
  m_h_trkdz0  = new TH1F("reftrk_dz0" , "Reference track sigma(z0)", 50,  0,     2.5);
 
  m_h_trkd0sig = new TH1F("reftrk_d0sig" , "Reference track d0 significance", 101,   -5.,     5.);
 
  addHistogram(m_h_trkpT);
  addHistogram(m_h_trkphi);
  addHistogram(m_h_trketa);
  addHistogram(m_h_trkd0);
  addHistogram(m_h_trkz0);
 
 
  addHistogram(m_h_trkdd0);
  addHistogram(m_h_trkdz0);
 
  addHistogram(m_h_trkd0sig);


  //  m_h_ntrk_rec = new TH1F( "testtrk_N", "Test tracks", 100, vnbins );
  m_h_ntrk_rec = new TH1F( "testtrk_N", "Test tracks", 77, vnbins );
 
  addHistogram(m_h_ntrk_rec);
 
  //  m_h_trkpT_rec  = new TH1F("testtrk_pT" , "Test track pT",  25,    0.,   100.);
  m_h_trkpT_rec  = new TH1F("testtrk_pT" , "Test track pT",  25,   &ptbins[0]   );
  m_h_trkphi_rec = new TH1F("testtrk_phi", "Test track Phi", 25,   -M_PI,  M_PI);
  m_h_trketa_rec = new TH1F("testtrk_eta", "Test track Eta", 25,   -2.5,    2.5) ;
  if (name().find("LRT")!=std::string::npos || name().find("lrt")!=std::string::npos) { 
    m_h_trkd0_rec  = new TH1F("testtrk_d0" , "Test track d0", 201,   -100.0,    100.0 );
  } else { 
    m_h_trkd0_rec  = new TH1F("testtrk_d0" , "Test track d0", 101,   -5.0,    5.0 );
  }  
  m_h_trkz0_rec  = new TH1F("testtrk_z0" , "Test track z0",  50,   -225.,   225.);
 
  m_h_trkdd0_rec  = new TH1F("testtrk_dd0" , "Test track sigma(d0)", 50,   0,     0.5);
  m_h_trkdz0_rec  = new TH1F("testtrk_dz0" , "Test track sigma(z0)", 50,   0,     2.5);
 
  m_h_trkd0sig_rec = new TH1F("testtrk_d0sig" , "Test track d0 significance", 101,   -5.0,     5.0);
 
 
  addHistogram(m_h_trkpT_rec);
  addHistogram(m_h_trkphi_rec);
  addHistogram(m_h_trketa_rec);
  addHistogram(m_h_trkd0_rec);
  addHistogram(m_h_trkz0_rec);
 
  addHistogram(m_h_trkdd0_rec);
  addHistogram(m_h_trkdz0_rec);
  
  addHistogram(m_h_trkd0sig_rec);

 
  double d0bins_LRT[124] = { -100.5, 
                 -97.5, -93.5, -90.5, 
                 -86.5, -83.5, -80.5, 
                 -77.5, -74.5, -71.5,  
                 -69.5, -66.5, -63.5, -61.5, 
                 -59.5, -57.5, -54.5, -52.5, -50.5, 
                 -49.5, -47.5, -45.5, -43.5, -42.5, -40.5, 
                 -39.5, -37.5, -36.5, -34.5, -33.5, -32.5, -31.5, 
                 -29.5, -28.5, -27.5, -26.5, -25.5, -24.5, -23.5, -22.5, -21.5, -20.5, 
                 -19.5, -18.5, -17.5, -16.5, -15.5, -14.5, -13.5, -12.5, -11.5, -10.5, 
                 -9.5, -8.5, -7.5, -6.5, -5.5, -4.5, -3.5, -2.5, -1.5, -0.5,
                 0.5,  1.5,  2.5,  3.5,  4.5,  5.5,  6.5,  7.5,  8.5,  9.5,  
                 10.5,  11.5,  12.5,  13.5,  14.5,  15.5,  16.5,  17.5,  18.5,  19.5, 
                 20.5,  21.5,  22.5,  23.5,  24.5,  25.5,  26.5,  27.5,  28.5,  29.5, 
                 31.5,  32.5,  33.5,  34.5,  36.5,  37.5,  39.5, 
                 40.5,  42.5,  43.5,  45.5,  47.5,  49.5, 
                 50.5,  52.5,  54.5,  57.5,  59.5, 
                 61.5,  63.5,  66.5,  69.5, 
                 71.5,  74.5,  77.5,    
                 80.5,  83.5,  86.5,   
                 90.5,  93.5,  97.5,    
                 100.5 };
 
  double d0bins[40] = { -5.0,  -4.0,  -3.0,  -2.5,   
            -2.0,  -1.8,  -1.6,  -1.4,  -1.2,  
            -1.05, -0.95, -0.85, -0.75, -0.65, -0.55, -0.45, -0.35, -0.25, -0.15, -0.05, 
             0.05,  0.15,  0.25,  0.35,  0.45,  0.55,  0.65,  0.75,  0.85,  0.95,  1.05,  
             1.2,   1.4,   1.6,   1.8,   2.0,  
             2.5,   3.0,   4.0,   5.0 };
 
 
 
  m_h_total_efficiency = new TProfile ("Eff_overall",  "total efficiency",  1, 0., 1.);
 
  // m_h_pTeff = new TProfile( "Eff_pT",     "pT efficiency",     25,    0.,  100.   );
  m_h_pTeff    = new TProfile( "Eff_pT",     "pT efficiency",     25,   &ptbins[0]   );
  m_h_etaeff   = new TProfile( "Eff_Eta",    "eta efficiency",    25,   -2.5,   2.5  );
  m_h_phieff   = new TProfile( "Eff_Phi",    "phi  efficiency",   25,   -M_PI, M_PI  );
  if (name().find("LRT")!=std::string::npos || name().find("lrt")!=std::string::npos) { 
    m_h_d0eff    = new TProfile( "Eff_d0",     "d0 efficiency",     123,  d0bins_LRT );
  } else { 
    m_h_d0eff    = new TProfile( "Eff_d0",     "d0 efficiency",     39,  d0bins      );
  } 
  m_h_z0eff    = new TProfile( "Eff_z0",     "z0 efficiency",     50, -225.,  225.   );
  m_h_nVtxeff  = new TProfile( "Eff_nVtx",   "nVtx efficiency",   101,   -0.5,  100.5  );
 
 
  m_h_lbeff = new TProfile( "Eff_lb", "efficinecy vs lumiblock", 301, -0.5, 3009.5 );
 
  addHistogram( m_h_lbeff );
 
  m_h_trkvtx_x_lb = new TProfile( "trkvtx_x_vs_lb", "track vertex x vs lumiblock", 301, -0.5, 3009.5 );
  m_h_trkvtx_y_lb = new TProfile( "trkvtx_y_vs_lb", "track vertex y vs lumiblock", 301, -0.5, 3009.5 );
  m_h_trkvtx_z_lb = new TProfile( "trkvtx_z_vs_lb", "track vertex z vs lumiblock", 301, -0.5, 3009.5 );
 
  addHistogram( m_h_trkvtx_x_lb );
  addHistogram( m_h_trkvtx_y_lb );
  addHistogram( m_h_trkvtx_z_lb );

  m_h_npixvseta     = new TProfile("npix_vs_eta",      "offline npix vs eta;offline #eta;# mean number of offline pixel hits", 30,   -2.5,  2.5);
  m_h_npixvseta_rec = new TProfile("npix_vs_eta_rec",  "trigger npix vs eta;offline #eta;# mean number of trigger pixel hits", 30,   -2.5,  2.5);
 
  m_h_nsctvseta     = new TProfile("nsct_vs_eta",      "offline nsct vs eta;offline #eta;# mean number of offline sct hits", 30,   -2.5,  2.5);
  m_h_nsctvseta_rec = new TProfile("nsct_vs_eta_rec",  "trigger nsct vs eta;offline #eta;# mean number of trigger sct hits", 30,   -2.5,  2.5);
 
  m_h_ntrtvseta     = new TProfile("ntrt_vs_eta",      "offline ntrt vs eta;offline #eta;# mean number of offline trt hits", 30,   -2.5, 2.5 );
  m_h_ntrtvseta_rec = new TProfile("ntrt_vs_eta_rec",  "trigger ntrt vs eta;offline #eta;# mean number of trigger trt hits", 30,   -2.5, 2.5 );
 
  m_h_npixvsphi     = new TProfile("npix_vs_phi",      "offline npix vs phi;offline #phi;# mean number of offline pixel hits", 30,   -M_PI,  M_PI);
  m_h_npixvsphi_rec = new TProfile("npix_vs_phi_rec",  "trigger npix vs phi;offline #phi;# mean number of trigger pixel hits", 30,   -M_PI,  M_PI);
 
  m_h_nsctvsphi     = new TProfile("nsct_vs_phi",      "offline nsct vs phi;offline #phi;# mean number of offline sct hits", 30,   -M_PI,  M_PI);
  m_h_nsctvsphi_rec = new TProfile("nsct_vs_phi_rec",  "trigger nsct vs phi;offline #phi;# mean number of trigger sct hits", 30,   -M_PI,  M_PI);
 
  m_h_ntrtvsphi     = new TProfile("ntrt_vs_phi",      "offline ntrt vs phi;offline #phi;# mean number of offline trt hits", 30,   -M_PI, M_PI );
  m_h_ntrtvsphi_rec = new TProfile("ntrt_vs_phi_rec",  "trigger ntrt vs phi;offline #phi;# mean number of trigger trt hits", 30,   -M_PI, M_PI );
 
  if (name().find("LRT")!=std::string::npos || name().find("lrt")!=std::string::npos) {
    m_h_npixvsd0     = new TProfile("npix_vs_d0",      "offline npix vs d0;offline #d0;# mean number of offline pixel hits", 123,  d0bins_LRT );
    m_h_npixvsd0_rec = new TProfile("npix_vs_d0_rec",  "trigger npix vs d0;offline #d0;# mean number of trigger pixel hits", 123,  d0bins_LRT );
 
    m_h_nsctvsd0     = new TProfile("nsct_vs_d0",      "offline nsct vs d0;offline #d0;# mean number of offline sct hits", 123,   d0bins_LRT );
    m_h_nsctvsd0_rec = new TProfile("nsct_vs_d0_rec",  "trigger nsct vs d0;offline #d0;# mean number of trigger sct hits", 123,   d0bins_LRT );
  } else {
    m_h_npixvsd0     = new TProfile("npix_vs_d0",      "offline npix vs d0;offline #d0;# mean number of offline pixel hits", 39,  d0bins );
    m_h_npixvsd0_rec = new TProfile("npix_vs_d0_rec",  "trigger npix vs d0;offline #d0;# mean number of trigger pixel hits", 39,  d0bins );
 
    m_h_nsctvsd0     = new TProfile("nsct_vs_d0",      "offline nsct vs d0;offline #d0;# mean number of offline sct hits", 39,   d0bins );
    m_h_nsctvsd0_rec = new TProfile("nsct_vs_d0_rec",  "trigger nsct vs d0;offline #d0;# mean number of trigger sct hits", 39,   d0bins );
  }  
 
  m_h_npixvspT     = new TProfile("npix_vs_pT",      "offline npix vs pT;offline #p_{T};# mean number of offline pixel hits", 25, &ptbins[0] );
  m_h_npixvspT_rec = new TProfile("npix_vs_pT_rec",  "trigger npix vs pT;offline #p_{T};# mean number of trigger pixel hits", 25, &ptbins[0] );
 
  m_h_nsctvspT     = new TProfile("nsct_vs_pT",      "offline nsct vs pT;offline #p_{T} [GeV];# mean number of offline pixel hits", 25, &ptbins[0] );
  m_h_nsctvspT_rec = new TProfile("nsct_vs_pT_rec",  "trigger nsct vs pT;offline #p_{T} [GeV];# mean number of trigger pixel hits", 25, &ptbins[0] );
 
 
  m_h_nsihits_lb     = new TProfile( "nsihits_lb",     "offline n sihits vs lumiblock", 301, -0.5, 3009.5 );
  m_h_nsihits_lb_rec = new TProfile( "nsihits_lb_rec", "trigger n sihits vs lumiblock", 301, -0.5, 3009.5 );
 
  addHistogram( m_h_nsihits_lb );
  addHistogram( m_h_nsihits_lb_rec );
 
  m_h_layer_rec  = new TH1F("layer_rec" , "hit layers", 32,   -0.5,  31.5  );
  m_h_layer      = new TH1F("layer",      "hit layers", 32,   -0.5,  31.5  );
 
  addHistogram(m_h_layer);
  addHistogram(m_h_layer_rec);
 
 
 
  addHistogram(m_h_total_efficiency);
  addHistogram(m_h_pTeff);
  addHistogram(m_h_etaeff);
  addHistogram(m_h_phieff);
  addHistogram(m_h_z0eff);
  addHistogram(m_h_d0eff);
  addHistogram(m_h_nVtxeff);
 
  addHistogram( m_h_npixvseta );
  addHistogram( m_h_npixvseta_rec );
 
  addHistogram( m_h_nsctvseta );
  addHistogram( m_h_nsctvseta_rec );
 
  addHistogram( m_h_ntrtvseta );
  addHistogram( m_h_ntrtvseta_rec );
 
  addHistogram( m_h_npixvsphi );
  addHistogram( m_h_npixvsphi_rec );
 
  addHistogram( m_h_nsctvsphi );
  addHistogram( m_h_nsctvsphi_rec );
 
  addHistogram( m_h_ntrtvsphi );
  addHistogram( m_h_ntrtvsphi_rec );
 
  addHistogram( m_h_npixvsd0 );
  addHistogram( m_h_npixvsd0_rec );
 
  addHistogram( m_h_nsctvsd0 );
  addHistogram( m_h_nsctvsd0_rec );
 
  addHistogram( m_h_npixvspT );
  addHistogram( m_h_npixvspT_rec );
 
  addHistogram( m_h_nsctvspT );
  addHistogram( m_h_nsctvspT_rec );


 
  //  m_h_pTres  = new TProfile("Res_pT", "pT residual;pT [Gev];pT_{trig}-pT_{ref} [GeV]",   25,    0.,   100.);
  // m_h_pTres  = new TProfile("Res_pT", "pT residual;pT [Gev];pT_{trig}-pT_{ref} [GeV]",      25,   &ptbins[0]   );
  // m_h_ipTres = new TProfile("Res_ipT", "ipT residual;pT^{-1} [Gev^{-1}];1/pT_{trig}-1/pT_{ref} [GeV^{-1}]", 55, -5, 5   );
  // m_h_etares = new TProfile("Res_eta", "Eta residual;#eta;#eta_{trig}-#eta_{ref}", 25,   -2.5,    2.5);
  // m_h_phires = new TProfile("Res_phi", "Phi residual;#phi;#phi_{trig}-#phi_{ref}", 25,   -M_PI, M_PI);
  // m_h_d0res  = new TProfile("Res_d0", "d0 residual;d0 [mm];d0_{trig}-d0_{ref} [mm]",   50,  -10.,    10.);
  // m_h_z0res  = new TProfile("Res_z0", "z0 residual;z0 [mm];z0_{trig}-z0_{ref} [mm]",   50, -225.,   225.);
 
  m_h_pTres  = new TProfile("Res_pT",  "pT residual;#eta_{ref};#Delta pT [Gev]",  25,   -2.5,  2.5   );
  m_h_ipTres = new TProfile("Res_ipT", "ipT residual;#eta_{ref};#Delta pT^{-1} [Gev^{-1}]", 25, -2.5, 2.5);
  m_h_etares = new TProfile("Res_eta", "Eta residual;#eta_{ref};#Delta #eta",     25,   -2.5,  2.5);
  m_h_phires = new TProfile("Res_phi", "Phi residual;#eta_{ref};#Delta #phi",     25,   -2.5,  2.5);
  m_h_d0res  = new TProfile("Res_d0",  "d0 residual;#eta_{ref};#Delta d0 [mm]",   25,   -2.5,  2.5);
  m_h_z0res  = new TProfile("Res_z0",  "z0 residual;#eta_{ref};#Delta z0 [mm]",   25,   -2.5,  2.5);
 
  addHistogram(m_h_pTres);
  addHistogram(m_h_ipTres);
  addHistogram(m_h_etares);
  addHistogram(m_h_phires);
  addHistogram(m_h_d0res);
  addHistogram(m_h_z0res);

 
  m_h_trkpT_residual  = new TH1F("residual_pT" , "track pT residual",  201, -100.0,    100.0  );
  m_h_trkipT_residual = new TH1F("residual_ipT", "track ipT residual",  55,   -5.5,      5.5  );
  m_h_trkphi_residual = new TH1F("residual_phi", "track Phi residual",  50,   -0.02,     0.02 );
  m_h_trketa_residual = new TH1F("residual_eta", "track Eta residual",  50,   -0.02,     0.02 );
  m_h_trkd0_residual  = new TH1F("residual_d0" , "track d0 residual ", 251,   -2.5,      2.5  );
  m_h_trkz0_residual  = new TH1F("residual_z0" , "track z0 residual",  401,  -20.0,     20.0  );
 
  m_h_trkdd0_residual  = new TH1F("residual_dd0" , "track sigma d0 residual ", 251,   -0.5,     0.5  );
  m_h_trkdz0_residual  = new TH1F("residual_dz0" , "track sigma z0 residual",  401,   -1.0,     1.0  );
 
  addHistogram(m_h_trkpT_residual);
  addHistogram(m_h_trkipT_residual);
  addHistogram(m_h_trkphi_residual);
  addHistogram(m_h_trketa_residual);
  addHistogram(m_h_trkd0_residual);
  addHistogram(m_h_trkz0_residual);
 
  addHistogram(m_h_trkdd0_residual);
  addHistogram(m_h_trkdz0_residual);
 
  m_h_npix     = new TH1F("npix",     "npix",     26,  -0.5,     25.5  );
  m_h_npix_rec = new TH1F("npix_rec", "npix_rec", 26,  -0.5,     25.5  );
 
  m_h_nsct     = new TH1F("nsct",     "nsct",     31,  -0.5,     30.5  );
  m_h_nsct_rec = new TH1F("nsct_rec", "nsct_rec", 31,  -0.5,     30.5  );
 
  m_h_nsihits     = new TH1F("nsiHits",     "nsiHits",     41,  -0.5,     40.5  );
  m_h_nsihits_rec = new TH1F("nsiHits_rec", "nsiHits_rec", 41,  -0.5,     40.5  );
 
  m_h_ntrt     = new TH1F("ntrt",     "ntrt",      91,  -0.5,     91.5  );
  m_h_ntrt_rec = new TH1F("ntrt_rec", "ntrt_rec",  91,  -0.5,     91.5  );
 
  addHistogram( m_h_npix );
  addHistogram( m_h_nsct );
  addHistogram( m_h_nsihits );
  addHistogram( m_h_ntrt );
 
  addHistogram( m_h_npix_rec );
  addHistogram( m_h_nsct_rec );
  addHistogram( m_h_nsihits_rec );
  addHistogram( m_h_ntrt_rec );

 
  m_h_d0vsphi       = new TProfile( "d0_vs_phi_prof", "d0 vs phi_prof",  25, -M_PI, M_PI );
  m_h_d0vsphi_rec   = new TProfile( "d0_vs_phi_rec_prof", "d0 vs phi_rec_prof",  25, -M_PI, M_PI );
 
  addHistogram( m_h_d0vsphi );
  addHistogram( m_h_d0vsphi_rec );
 
 
  //  h2d_d0vsphi     = 0; // new     TH2D( "d0_vs_phi",      "d0 vs phi",       25, -M_PI, M_PI, 50, -2.6, 2.6 );
  //  h2d_d0vsphi_rec = 0; // new     TH2D( "d0_vs_phi_rec",  "d0 vs phi rec",   25, -M_PI, M_PI, 50, -2.6, 2.6 );
 
  //  addHistogram( h2d_d0vsphi ); 
  //  addHistogram( h2d_d0vsphi_rec ); 
 
  m_vtxanal = 0;
 
#if 1
 
  //  std::cout << "Analysis_Tier0 vertex info: " << name() << std::endl;  

  if ( name().find("vtx")!=std::string::npos || name().find("Vtx")!=std::string::npos ||
       name().find("vx")!=std::string::npos || name().find("Vx")!=std::string::npos ) { 
 
    // std::cout << "Analysis_Tier0 vertex info: " << name() << std::endl;  
 
    m_vtxanal = new VtxAnalysis("VTX");

    store().insert( m_vtxanal, "VTX" );

    m_vtxanal->initialise();
 
    //    std::cout << "vtxanal obj  size() " << m_vtxanal->objects().size() << std::endl;
    //    std::cout << "vtxanal prof size() " << m_vtxanal->profs().size() << std::endl;

    for ( unsigned i=0 ; i<m_vtxanal->objects().size() ; i++ ) addHistogram( m_vtxanal->objects()[i] );
    for ( unsigned i=0 ; i<m_vtxanal->profs().size() ; i++ )   addHistogram( m_vtxanal->profs()[i] );
  }
#endif
 
}

monTool()

ToolHandle< GenericMonitoringTool > * Analysis_Tier0::monTool ( )

inline

Definition at line 63 of file Analysis_Tier0.h.

{ return m_monTool; }

name()

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

inlineinherited

return identifier

Definition at line 52 of file TrackAnalysis.h.

{ return m_name; }

phi()

double Analysis_Tier0::phi

(

double

p

)

Definition at line 768 of file Analysis_Tier0.cxx.

                                   {
  if(p < -M_PI) p += 2*M_PI;
  if(p >  M_PI) p -= 2*M_PI;
  return p;
}

roi()

const TIDARoiDescriptor * TrackAnalysis::roi ( ) const

inlineinherited

Definition at line 138 of file TrackAnalysis.h.

{ return m_roi; }

set_monTool()

void Analysis_Tier0::set_monTool ( ToolHandle< GenericMonitoringTool > * m )

inline

Definition at line 61 of file Analysis_Tier0.h.

{ m_monTool=m; }

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; }

setroi()

void TrackAnalysis::setroi ( TIDARoiDescriptor * r )

inlineinherited

Definition at line 139 of file TrackAnalysis.h.

{ m_roi=r; }

setvertices()

void Analysis_Tier0::setvertices ( int numvtx )

inline

Definition at line 52 of file Analysis_Tier0.h.

{m_nVtx = numvtx;}

store()

TIDA::FeatureStore & TrackAnalysis::store ( )

inlineinherited

Definition at line 133 of file TrackAnalysis.h.

{ return m_store; }

TEffbegin()

std::map< std::string, TProfile * >::const_iterator Analysis_Tier0::TEffbegin ( ) const

inline

Definition at line 57 of file Analysis_Tier0.h.

{ return m_effhistos.begin(); }

TEffend()

std::map< std::string, TProfile * >::const_iterator Analysis_Tier0::TEffend ( ) const

inline

Definition at line 58 of file Analysis_Tier0.h.

{ return m_effhistos.end(); }

THbegin()

std::map< std::string, TH1 * >::const_iterator Analysis_Tier0::THbegin ( ) const

inline

Definition at line 54 of file Analysis_Tier0.h.

{ return m_histos.begin(); }

THend()

std::map< std::string, TH1 * >::const_iterator Analysis_Tier0::THend ( ) const

inline

Definition at line 55 of file Analysis_Tier0.h.

{ return m_histos.end(); }

Member Data Documentation

m_debug

bool Analysis_Tier0::m_debug

private

Definition at line 218 of file Analysis_Tier0.h.

m_effhistos

std::map<std::string, TProfile*> Analysis_Tier0::m_effhistos

private

Definition at line 85 of file Analysis_Tier0.h.

m_event

TIDA::Event* TrackAnalysis::m_event

protectedinherited

Definition at line 164 of file TrackAnalysis.h.

m_eventid

unsigned long long Analysis_Tier0::m_eventid

private

Definition at line 220 of file Analysis_Tier0.h.

m_h_chain

TH1F* Analysis_Tier0::m_h_chain

private

Definition at line 147 of file Analysis_Tier0.h.

m_h_d0eff

TProfile* Analysis_Tier0::m_h_d0eff

private

Definition at line 91 of file Analysis_Tier0.h.

m_h_d0res

TProfile* Analysis_Tier0::m_h_d0res

private

Definition at line 100 of file Analysis_Tier0.h.

m_h_d0vsphi

TProfile* Analysis_Tier0::m_h_d0vsphi

private

Definition at line 138 of file Analysis_Tier0.h.

m_h_d0vsphi_rec

TProfile* Analysis_Tier0::m_h_d0vsphi_rec

private

Definition at line 139 of file Analysis_Tier0.h.

m_h_etaeff

TProfile* Analysis_Tier0::m_h_etaeff

private

Definition at line 89 of file Analysis_Tier0.h.

m_h_etares

TProfile* Analysis_Tier0::m_h_etares

private

Definition at line 98 of file Analysis_Tier0.h.

m_h_ipTres

TProfile* Analysis_Tier0::m_h_ipTres

private

Definition at line 97 of file Analysis_Tier0.h.

m_h_layer

TH1F* Analysis_Tier0::m_h_layer

private

Definition at line 174 of file Analysis_Tier0.h.

m_h_layer_rec

TH1F* Analysis_Tier0::m_h_layer_rec

private

Definition at line 194 of file Analysis_Tier0.h.

m_h_lbeff

TProfile* Analysis_Tier0::m_h_lbeff

private

Definition at line 94 of file Analysis_Tier0.h.

m_h_npix

TH1F* Analysis_Tier0::m_h_npix

private

Definition at line 167 of file Analysis_Tier0.h.

m_h_npix_rec

TH1F* Analysis_Tier0::m_h_npix_rec

private

Definition at line 188 of file Analysis_Tier0.h.

m_h_npixvsd0

TProfile* Analysis_Tier0::m_h_npixvsd0

private

Definition at line 110 of file Analysis_Tier0.h.

m_h_npixvsd0_rec

TProfile* Analysis_Tier0::m_h_npixvsd0_rec

private

Definition at line 125 of file Analysis_Tier0.h.

m_h_npixvseta

TProfile* Analysis_Tier0::m_h_npixvseta

private

Definition at line 108 of file Analysis_Tier0.h.

m_h_npixvseta_rec

TProfile* Analysis_Tier0::m_h_npixvseta_rec

private

Definition at line 123 of file Analysis_Tier0.h.

m_h_npixvsphi

TProfile* Analysis_Tier0::m_h_npixvsphi

private

Definition at line 109 of file Analysis_Tier0.h.

m_h_npixvsphi_rec

TProfile* Analysis_Tier0::m_h_npixvsphi_rec

private

Definition at line 124 of file Analysis_Tier0.h.

m_h_npixvspT

TProfile* Analysis_Tier0::m_h_npixvspT

private

Definition at line 111 of file Analysis_Tier0.h.

m_h_npixvspT_rec

TProfile* Analysis_Tier0::m_h_npixvspT_rec

private

Definition at line 126 of file Analysis_Tier0.h.

m_h_nsct

TH1F* Analysis_Tier0::m_h_nsct

private

Definition at line 168 of file Analysis_Tier0.h.

m_h_nsct_rec

TH1F* Analysis_Tier0::m_h_nsct_rec

private

Definition at line 189 of file Analysis_Tier0.h.

m_h_nsctvsd0

TProfile* Analysis_Tier0::m_h_nsctvsd0

private

Definition at line 115 of file Analysis_Tier0.h.

m_h_nsctvsd0_rec

TProfile* Analysis_Tier0::m_h_nsctvsd0_rec

private

Definition at line 130 of file Analysis_Tier0.h.

m_h_nsctvseta

TProfile* Analysis_Tier0::m_h_nsctvseta

private

Definition at line 113 of file Analysis_Tier0.h.

m_h_nsctvseta_rec

TProfile* Analysis_Tier0::m_h_nsctvseta_rec

private

Definition at line 128 of file Analysis_Tier0.h.

m_h_nsctvsphi

TProfile* Analysis_Tier0::m_h_nsctvsphi

private

Definition at line 114 of file Analysis_Tier0.h.

m_h_nsctvsphi_rec

TProfile* Analysis_Tier0::m_h_nsctvsphi_rec

private

Definition at line 129 of file Analysis_Tier0.h.

m_h_nsctvspT

TProfile* Analysis_Tier0::m_h_nsctvspT

private

Definition at line 116 of file Analysis_Tier0.h.

m_h_nsctvspT_rec

TProfile* Analysis_Tier0::m_h_nsctvspT_rec

private

Definition at line 131 of file Analysis_Tier0.h.

m_h_nsihits

TH1F* Analysis_Tier0::m_h_nsihits

private

Definition at line 169 of file Analysis_Tier0.h.

m_h_nsihits_lb

TProfile* Analysis_Tier0::m_h_nsihits_lb

private

Definition at line 121 of file Analysis_Tier0.h.

m_h_nsihits_lb_rec

TProfile* Analysis_Tier0::m_h_nsihits_lb_rec

private

Definition at line 136 of file Analysis_Tier0.h.

m_h_nsihits_rec

TH1F* Analysis_Tier0::m_h_nsihits_rec

private

Definition at line 190 of file Analysis_Tier0.h.

m_h_ntrk

TH1F* Analysis_Tier0::m_h_ntrk

private

Definition at line 149 of file Analysis_Tier0.h.

m_h_ntrk_rec

TH1F* Analysis_Tier0::m_h_ntrk_rec

private

Definition at line 172 of file Analysis_Tier0.h.

m_h_ntrt

TH1F* Analysis_Tier0::m_h_ntrt

private

Definition at line 170 of file Analysis_Tier0.h.

m_h_ntrt_rec

TH1F* Analysis_Tier0::m_h_ntrt_rec

private

Definition at line 191 of file Analysis_Tier0.h.

m_h_ntrtvseta

TProfile* Analysis_Tier0::m_h_ntrtvseta

private

Definition at line 118 of file Analysis_Tier0.h.

m_h_ntrtvseta_rec

TProfile* Analysis_Tier0::m_h_ntrtvseta_rec

private

Definition at line 133 of file Analysis_Tier0.h.

m_h_ntrtvsphi

TProfile* Analysis_Tier0::m_h_ntrtvsphi

private

Definition at line 119 of file Analysis_Tier0.h.

m_h_ntrtvsphi_rec

TProfile* Analysis_Tier0::m_h_ntrtvsphi_rec

private

Definition at line 134 of file Analysis_Tier0.h.

m_h_nVtxeff

TProfile* Analysis_Tier0::m_h_nVtxeff

private

Definition at line 93 of file Analysis_Tier0.h.

m_h_phieff

TProfile* Analysis_Tier0::m_h_phieff

private

Definition at line 90 of file Analysis_Tier0.h.

m_h_phires

TProfile* Analysis_Tier0::m_h_phires

private

Definition at line 99 of file Analysis_Tier0.h.

m_h_pTeff

TProfile* Analysis_Tier0::m_h_pTeff

private

Definition at line 88 of file Analysis_Tier0.h.

m_h_pTres

TProfile* Analysis_Tier0::m_h_pTres

private

Definition at line 96 of file Analysis_Tier0.h.

m_h_total_efficiency

TProfile* Analysis_Tier0::m_h_total_efficiency

private

Definition at line 87 of file Analysis_Tier0.h.

m_h_trkd0

TH1F* Analysis_Tier0::m_h_trkd0

private

Definition at line 154 of file Analysis_Tier0.h.

m_h_trkd0_rec

TH1F* Analysis_Tier0::m_h_trkd0_rec

private

Definition at line 180 of file Analysis_Tier0.h.

m_h_trkd0_residual

TH1F* Analysis_Tier0::m_h_trkd0_residual

private

Definition at line 201 of file Analysis_Tier0.h.

m_h_trkd0sig

TH1F* Analysis_Tier0::m_h_trkd0sig

private

Definition at line 165 of file Analysis_Tier0.h.

m_h_trkd0sig_rec

TH1F* Analysis_Tier0::m_h_trkd0sig_rec

private

Definition at line 186 of file Analysis_Tier0.h.

m_h_trkdd0

TH1F* Analysis_Tier0::m_h_trkdd0

private

Definition at line 162 of file Analysis_Tier0.h.

m_h_trkdd0_rec

TH1F* Analysis_Tier0::m_h_trkdd0_rec

private

Definition at line 183 of file Analysis_Tier0.h.

m_h_trkdd0_residual

TH1F* Analysis_Tier0::m_h_trkdd0_residual

private

Definition at line 204 of file Analysis_Tier0.h.

m_h_trkdz0

TH1F* Analysis_Tier0::m_h_trkdz0

private

Definition at line 163 of file Analysis_Tier0.h.

m_h_trkdz0_rec

TH1F* Analysis_Tier0::m_h_trkdz0_rec

private

Definition at line 184 of file Analysis_Tier0.h.

m_h_trkdz0_residual

TH1F* Analysis_Tier0::m_h_trkdz0_residual

private

Definition at line 205 of file Analysis_Tier0.h.

m_h_trketa

TH1F* Analysis_Tier0::m_h_trketa

private

Definition at line 152 of file Analysis_Tier0.h.

m_h_trketa_rec

TH1F* Analysis_Tier0::m_h_trketa_rec

private

Definition at line 178 of file Analysis_Tier0.h.

m_h_trketa_residual

TH1F* Analysis_Tier0::m_h_trketa_residual

private

Definition at line 199 of file Analysis_Tier0.h.

m_h_trkipT_residual

TH1F* Analysis_Tier0::m_h_trkipT_residual

private

Definition at line 198 of file Analysis_Tier0.h.

m_h_trkphi

TH1F* Analysis_Tier0::m_h_trkphi

private

Definition at line 153 of file Analysis_Tier0.h.

m_h_trkphi_rec

TH1F* Analysis_Tier0::m_h_trkphi_rec

private

Definition at line 179 of file Analysis_Tier0.h.

m_h_trkphi_residual

TH1F* Analysis_Tier0::m_h_trkphi_residual

private

Definition at line 200 of file Analysis_Tier0.h.

m_h_trkpT

TH1F* Analysis_Tier0::m_h_trkpT

private

Definition at line 151 of file Analysis_Tier0.h.

m_h_trkpT_rec

TH1F* Analysis_Tier0::m_h_trkpT_rec

private

Definition at line 177 of file Analysis_Tier0.h.

m_h_trkpT_residual

TH1F* Analysis_Tier0::m_h_trkpT_residual

private

Definition at line 197 of file Analysis_Tier0.h.

m_h_trkvtx_x_lb

TProfile* Analysis_Tier0::m_h_trkvtx_x_lb

private

Definition at line 103 of file Analysis_Tier0.h.

m_h_trkvtx_y_lb

TProfile* Analysis_Tier0::m_h_trkvtx_y_lb

private

Definition at line 104 of file Analysis_Tier0.h.

m_h_trkvtx_z_lb

TProfile* Analysis_Tier0::m_h_trkvtx_z_lb

private

Definition at line 105 of file Analysis_Tier0.h.

m_h_trkz0

TH1F* Analysis_Tier0::m_h_trkz0

private

Definition at line 155 of file Analysis_Tier0.h.

m_h_trkz0_rec

TH1F* Analysis_Tier0::m_h_trkz0_rec

private

Definition at line 181 of file Analysis_Tier0.h.

m_h_trkz0_residual

TH1F* Analysis_Tier0::m_h_trkz0_residual

private

Definition at line 202 of file Analysis_Tier0.h.

m_h_z0eff

TProfile* Analysis_Tier0::m_h_z0eff

private

Definition at line 92 of file Analysis_Tier0.h.

m_h_z0res

TProfile* Analysis_Tier0::m_h_z0res

private

Definition at line 101 of file Analysis_Tier0.h.

m_histos

std::map<std::string, TH1*> Analysis_Tier0::m_histos

private

Definition at line 84 of file Analysis_Tier0.h.

m_monTool

ToolHandle<GenericMonitoringTool>* Analysis_Tier0::m_monTool

private

Definition at line 224 of file Analysis_Tier0.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_nVtx

int Analysis_Tier0::m_nVtx

private

Definition at line 216 of file Analysis_Tier0.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_vtxanal

VtxAnalysis* Analysis_Tier0::m_vtxanal

private

Definition at line 222 of file Analysis_Tier0.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:

• Analysis_Tier0.h
• Analysis_Tier0.cxx