IDTPM2::Tier0 Class Reference

#include <Tier0.h>

Inheritance diagram for IDTPM2::Tier0:

Collaboration diagram for IDTPM2::Tier0:

Public Member Functions
	Tier0 (const std::string &name, ToolHandle< GenericMonitoringTool > *m=0)
virtual	~Tier0 ()
virtual void	initialize ()
	Book the histograms.
virtual void	execute (const TrackAnalysisStore &collections) const
	this can be over ridden if need be
virtual void	finalize ()
	Finalize resolution and bias histograms should be called from the calling montools stop() method.
const std::string &	name () const
ToolHandle< GenericMonitoringTool > *	monTool ()
	mon tool
const ToolHandle< GenericMonitoringTool > *	monTool () const
void	set_monTool (ToolHandle< GenericMonitoringTool > *m)
	do we need / should we have this specific setter ??
std::string	realPath (const std::string &tag="")
	This is a horrific function, has to get ALL the histograms, just to be able to work out how to get the actual path to the histograms for this tool - there simply MUST be a better way ...
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Static Public Member Functions
template<typename Derived>
static std::unique_ptr< IPlotBase >	create (const std::string &name, ToolHandle< GenericMonitoringTool > *m)
	factory creation mathod

Protected Member Functions
void	copyHist (TH1 *hsrc, TH1 *hdest, bool copyoverflow=true) const
	resolution porocessing stuff these don't really even need to be class functions, they could be simply utility functions
void	getHist (const std::string &hname, TH1 *hsrc)
void	getHist (ServiceHandle< ITHistSvc > &histsvc, const std::string &hname, TH1 *hsrc) const
void	processResolution (const std::string &path, bool writeflag=false)
void	processResolution (ServiceHandle< ITHistSvc > &histsvc, const std::string &path, bool writeflag=false) const
virtual ServiceHandle< ITHistSvc > &	histSvc ()
	we may well need these at some point ...

Protected Attributes
ToolHandle< GenericMonitoringTool > *	m_monTool

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::string	m_name
TIDA::Histogram< float >	m_htotal_efficiency
	Monitorwd::AScalar Histogram wrapper class.
TIDA::Histogram< float >	m_hpTeff
TIDA::Histogram< float >	m_hetaeff
TIDA::Histogram< float >	m_hphieff
TIDA::Histogram< float >	m_hd0eff
TIDA::Histogram< float >	m_hz0eff
TIDA::Histogram< float >	m_hnVtxeff
TIDA::Histogram< float >	m_hlbeff
TIDA::Histogram< float >	m_hpTres
TIDA::Histogram< float >	m_hipTres
TIDA::Histogram< float >	m_hetares
TIDA::Histogram< float >	m_hphires
TIDA::Histogram< float >	m_hd0res
TIDA::Histogram< float >	m_hz0res
TIDA::Histogram< float >	m_htrkvtx_x_lb
TIDA::Histogram< float >	m_htrkvtx_y_lb
TIDA::Histogram< float >	m_htrkvtx_z_lb
TIDA::Histogram< float >	m_hnpixvseta
TIDA::Histogram< float >	m_hnpixvsphi
TIDA::Histogram< float >	m_hnpixvsd0
TIDA::Histogram< float >	m_hnpixvspT
TIDA::Histogram< float >	m_hnsctvseta
TIDA::Histogram< float >	m_hnsctvsphi
TIDA::Histogram< float >	m_hnsctvsd0
TIDA::Histogram< float >	m_hnsctvspT
TIDA::Histogram< float >	m_hntrtvseta
TIDA::Histogram< float >	m_hntrtvsphi
TIDA::Histogram< float >	m_hnsihits_lb
TIDA::Histogram< float >	m_hnpixvseta_rec
TIDA::Histogram< float >	m_hnpixvsphi_rec
TIDA::Histogram< float >	m_hnpixvsd0_rec
TIDA::Histogram< float >	m_hnpixvspT_rec
TIDA::Histogram< float >	m_hnsctvseta_rec
TIDA::Histogram< float >	m_hnsctvsphi_rec
TIDA::Histogram< float >	m_hnsctvsd0_rec
TIDA::Histogram< float >	m_hnsctvspT_rec
TIDA::Histogram< float >	m_hntrtvseta_rec
TIDA::Histogram< float >	m_hntrtvsphi_rec
TIDA::Histogram< float >	m_hnsihits_lb_rec
TIDA::Histogram< float >	m_hd0vsphi
TIDA::Histogram< float >	m_hd0vsphi_rec
TIDA::Histogram< float >	m_hchain
TIDA::Histogram< float >	m_hroieta
TIDA::Histogram< float >	m_hntrk
TIDA::Histogram< float >	m_htrkpT
TIDA::Histogram< float >	m_htrketa
TIDA::Histogram< float >	m_htrkphi
TIDA::Histogram< float >	m_htrkd0
TIDA::Histogram< float >	m_htrkz0
TIDA::Histogram< float >	m_htrkdd0
TIDA::Histogram< float >	m_htrkdz0
TIDA::Histogram< float >	m_htrkd0sig
TIDA::Histogram< float >	m_hnpix
TIDA::Histogram< float >	m_hnsct
TIDA::Histogram< float >	m_hnsihits
TIDA::Histogram< float >	m_hntrt
TIDA::Histogram< float >	m_hntrk_rec
TIDA::Histogram< float >	m_chi2dof
TIDA::Histogram< float >	m_chi2dof_rec
TIDA::Histogram< float >	m_hmu
TIDA::Histogram< float >	m_hlayer
TIDA::Histogram< float >	m_htrkpT_rec
TIDA::Histogram< float >	m_htrketa_rec
TIDA::Histogram< float >	m_htrkphi_rec
TIDA::Histogram< float >	m_htrkd0_rec
TIDA::Histogram< float >	m_htrkz0_rec
TIDA::Histogram< float >	m_htrkdd0_rec
TIDA::Histogram< float >	m_htrkdz0_rec
TIDA::Histogram< float >	m_htrkd0sig_rec
TIDA::Histogram< float >	m_hnpix_rec
TIDA::Histogram< float >	m_hnsct_rec
TIDA::Histogram< float >	m_hnsihits_rec
TIDA::Histogram< float >	m_hntrt_rec
TIDA::Histogram< float >	m_hlayer_rec
TIDA::Histogram< float >	m_htrkpT_residual
TIDA::Histogram< float >	m_htrkipT_residual
TIDA::Histogram< float >	m_htrketa_residual
TIDA::Histogram< float >	m_htrkphi_residual
TIDA::Histogram< float >	m_htrkd0_residual
TIDA::Histogram< float >	m_htrkz0_residual
TIDA::Histogram< float >	m_htrkdd0_residual
TIDA::Histogram< float >	m_htrkdz0_residual
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

Definition at line 30 of file Tier0.h.

Constructor & Destructor Documentation

Tier0()

IDTPM2::Tier0::Tier0	(	const std::string &	name,
		ToolHandle< GenericMonitoringTool > *	m = 0 )

Definition at line 24 of file Tier0.cxx.

  : IPlotBase( name, m ), m_name(name)
{ }

~Tier0()

virtual IDTPM2::Tier0::~Tier0 ( )

inlinevirtual

Definition at line 38 of file Tier0.h.

{ }

Member Function Documentation

copyHist()

void IDTPM2::IPlotBase::copyHist ( TH1 * hsrc, TH1 * hdest, bool copyoverflow = true ) const

protectedinherited

resolution porocessing stuff these don't really even need to be class functions, they could be simply utility functions

Definition at line 20 of file IPlotBase.cxx.

                                                                               {
  
  if ( hsrc->GetNbinsX()!=hdest->GetNbinsX() ) return; // do we want to give an error message ?? throw and exception ??
 
  int imin = 0;
  int imax = hsrc->GetNbinsX()+1; 
 
  if ( !copyoverflow ) {
    imin = 1;
    imax = hsrc->GetNbinsX(); 
  }
  
  for  ( int i=imin ; i<=imax ; i++ ) {
    hdest->SetBinContent( i, hsrc->GetBinContent(i) );
    hdest->SetBinError( i, hsrc->GetBinError(i) );
  }
 
  hdest->SetEntries( hsrc->GetEntries() );
}

create()

template<typename Derived>

std::unique_ptr< IPlotBase > IDTPM2::IPlotBase::create ( const std::string & name, ToolHandle< GenericMonitoringTool > * m )

inlinestaticinherited

factory creation mathod

Definition at line 50 of file IPlotBase.h.

                                                               {
    return std::make_unique<Derived>( name, m );
  } 

execute()

void IDTPM2::Tier0::execute ( const TrackAnalysisStore & collections ) const

virtual

this can be over ridden if need be

if ( !m_initialised ) return;

not used yet, but it will be ...

these two variables aren't used yet but they will be soon

these two variables aren't used yet but will be soon ...

fil the number of offline tracks

no matcher found ...

shouldn;t ever happen

fil the number of offline tracks

m_hnVtxeff->Fill( m_nVtx, eff_weight ); /// don't use the class variable as this is not thread safe

we should create a hit pattern here ...

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

<<<<<<<<<<<<<< need proper delta phi

test track distributions for test tracks with a reference track match

1d residual distributions

Implements IDTPM2::IPlotBase.

Definition at line 202 of file Tier0.cxx.

                                                                       { 


  //  const TIDA::Associator<const VertexView>* vertex_matcher = collections.vertex_matcher();
 
  m_hchain->Fill( 0.5, 1 );
 
  if ( collections.roiIndex()==0 ) m_hchain->Fill( 1.5, 1 ); // only if this is the first Roi for a chain
 
  // --- Fill reference track distributions ---                                                                         
  const std::vector<const TrackView*>& refTracks  = collections.reference_tracks();
  const std::vector<const TrackView*>& testTracks = collections.test_tracks();
  
  const xAOD::EventInfo* eventinfo = collections.eventInfo();

  //   long    runnumber = 0;
  //   long    eventid   = 0;
  
  long    lumiblock = 0;
  double  mu        = 0;
 
  if (eventinfo) {  
    //    runnumber = collections.eventInfo()->runNumber(); 
    //    eventid   = collections.eventInfo()->eventNumber(); 
    lumiblock = collections.eventInfo()->lumiBlock(); 
    mu        = collections.eventInfo()->averageInteractionsPerCrossing();
  }
 
  m_hmu->Fill( mu );
  
  m_hntrk->Fill( refTracks.size() );
  
  m_hntrk_rec->Fill( testTracks.size() );
  
  m_hchain->Fill( 4.5, testTracks.size() );
  
 
  
  const TIDA::Associator<const TrackView>* matcher = collections.matcher();

  if ( matcher==0 ) {
    std::cerr << "Tier0::execute() no matcher available - should never happen" << std::endl;
    return;
  }
 
  int itrack = 0;
 
  for ( const TrackView* reference : refTracks) {
    
    if ( !reference ) continue; 
 
    itrack++;
    
    m_hchain->Fill( 2.5, 1 );
    
    // Get reference parameters
    double referencePT  = reference->pt()*0.001;
    double referenceEta = reference->eta();
    double referencePhi = reference->phi();
    double referenceZ0  = reference->z0();
    double referenceD0  = reference->d0();
 
    double referenceDZ0  = reference->dz0();
    double referenceDD0  = reference->dd0();
 
    //    std::cout << itrack << "\tpt: " << referencePT << "\t" << referenceEta << " " << referenceZ0 << std::endl;
 
    // Find matched tracks
    const TrackView*  test = matcher->matched(reference);
 
    //    std::cout << "SUTT matched pointers: " << reference << "\t" << test << std::endl;
    
    float     eff_weight = 0;
    if (test) eff_weight = 1;
 
    //    std::cout << "\t efficiency calculation: " << test << "\tweight: " << eff_weight << std::endl;
    
    m_htotal_efficiency->Fill(0.5, eff_weight );
 
    m_hpTeff->Fill( std::fabs(referencePT), eff_weight );
    m_hz0eff->Fill( referenceZ0, eff_weight );
    m_hd0eff->Fill( referenceD0, eff_weight );
    m_hetaeff->Fill( referenceEta, eff_weight );
    m_hphieff->Fill( referencePhi, eff_weight );
    //    if (beamline) m_hnVtxeff->Fill( beamline[3], eff_weight ); /// this is a hack to make it thread safe
 
    m_hlbeff->Fill( lumiblock, eff_weight );
 
    //    m_hmueff->Fill( mu, eff_weight );
 
    
    m_htrkpT->Fill( std::fabs(referencePT) );
    m_htrketa->Fill( referenceEta );
    m_htrkphi->Fill( referencePhi );
    m_htrkd0->Fill( referenceD0 );
    m_htrkz0->Fill( referenceZ0 );
 
    m_htrkdd0->Fill( referenceDD0 );
    m_htrkdz0->Fill( referenceDZ0 );
 
    // if ( referenceDD0!=0 )
 
    if ( referenceDD0 ) m_htrkd0sig->Fill( referenceD0/referenceDD0 );
 
    m_hnpixvseta->Fill( referenceEta,  reference->nPixels() ); 
    m_hnsctvseta->Fill( referenceEta,  reference->nSCT() ); 
    m_hntrtvseta->Fill( referenceEta,  reference->nTRT() ); 
 
    
    if ( reference->ndof()!=0 ) m_chi2dof->Fill( reference->chi2()/reference->ndof() ); 
        
    //    m_hnpixvsphi->Fill( referencePhi,  int(reference->nPixels()+0.5)*0.5) ); 
    //    m_hnpixvsphi->Fill( referencePhi,  reference->nPixels() ); 
    //    m_hnsctvsphi->Fill( referencePhi,  reference->nSCT() ); 
    //    m_hntrtvsphi->Fill( referencePhi,  reference->strawHits() );
 
    m_hnpix->Fill( reference->nPixels() ); 
    m_hnpixvsphi->Fill( referencePhi,  reference->nPixels() ); 
 
    m_hnsctvsphi->Fill( referencePhi,  reference->nSCT() ); 
    m_hntrtvsphi->Fill( referencePhi,  reference->nTRT() ); 
 
    m_hnpixvsd0->Fill( referenceD0,  reference->nPixels() );
    m_hnsctvsd0->Fill( referenceD0,  reference->nSCT() ); 
 
    //    m_hnpixvspT->Fill( std::fabs(referencePT),  int((reference->nPixels()+0.5)*0.5) ); 
    //    m_hnsctvspT->Fill( std::fabs(referencePT),  reference->nSCT() ); 
 
    m_hnpixvspT->Fill( std::fabs(referencePT),  reference->nPixels() ); 
    m_hnsctvspT->Fill( std::fabs(referencePT),  reference->nSCT() ); 
 
 
    m_hnsct->Fill(  reference->nSCT() ); 
    m_hnsihits->Fill(  reference->nSi() ); 
    m_hntrt->Fill(  reference->nTRT() ); 
   
    m_hnsihits_lb->Fill( lumiblock, reference->nSi() );

    //    for ( size_t ilayer=0 ; ilayer<32 ; ilayer++ ) { 
    //       if ( reference->hitPattern()&(1U<<ilayer) ) m_hlayer->Fill( ilayer );
    //    } 
 
    m_hd0vsphi->Fill(referencePhi, referenceD0 );
 
    if (test) { 
    
      m_hchain->Fill( 3.5, 1 );


      // m_hpTres->Fill( referencePT, (test->pT() - referencePT)*0.001;
      // m_hipTres->Fill( 1000/referencePT, (1000/test->pT() - 1000/referencePT) );
      // m_hetares->Fill( referenceEta, test->eta() - referenceEta );
      // m_hphires->Fill( referencePhi, phi(test->phi() - referencePhi) );
      // m_hd0res->Fill( referenceD0, test->d0() - referenceD0 );
      // m_hz0res->Fill( referenceZ0, test->z0() - referenceZ0  );

      m_hpTres->Fill( referenceEta, (test->pt()*0.001 - referencePT) );
      m_hipTres->Fill( referenceEta, (1000/test->pt() - 1/referencePT) );
      m_hetares->Fill( referenceEta, test->eta() - referenceEta );
      //    m_hphires->Fill( referenceEta, phi(test->phi() - referencePhi) );
      m_hphires->Fill( referenceEta, test->phi() - referencePhi ); 
      m_hd0res->Fill( referenceEta, test->d0() - referenceD0 );
      m_hz0res->Fill( referenceEta, test->z0() - referenceZ0  );
 
      //      m_htrkvtx_x_lb->Fill( lumiblock(), beamTestx() );
      //      m_htrkvtx_y_lb->Fill( lumiblock(), beamTesty() );
      //      m_htrkvtx_z_lb->Fill( lumiblock(), beamTestz() );
 
#if 0
      if (tevt && beamline) {
        m_htrkvtx_x_lb->Fill( tevt->lumi_block(), beamline[0] );
        m_htrkvtx_y_lb->Fill( tevt->lumi_block(), beamline[1] );
        m_htrkvtx_z_lb->Fill( tevt->lumi_block(), beamline[2] );
      }
      
      for ( size_t ilayer=0 ; ilayer<32 ; ilayer++ ) { 
    if ( test->hitPattern()&(1U<<ilayer) ) m_hlayer_rec->Fill( ilayer );
      } 
#endif
 
      //      std::cout << "SUTT beam x " << beamTestx() << " " << "\tx " << beamTesty() << " " <<  "\ty " << beamTestz() << std::endl;
 
#if 0
      m_htrkpT_rec->Fill( referencePT );
      m_htrketa_rec->Fill( referenceEta );
      m_htrkphi_rec->Fill( referencePhi );
      m_htrkd0_rec->Fill( referenceD0 );
      m_htrkz0_rec->Fill( referenceZ0 );
     
#endif

      m_htrkpT_rec->Fill( std::fabs(test->pt())*0.001 );
      m_htrketa_rec->Fill( test->eta() );
      m_htrkphi_rec->Fill( test->phi() );
      m_htrkd0_rec->Fill( test->d0() );
      m_htrkz0_rec->Fill( test->z0() );
 
      m_htrkdd0_rec->Fill( test->dd0() );
      m_htrkdz0_rec->Fill( test->dz0() );
 
      if ( test->dd0() ) m_htrkd0sig_rec->Fill( test->d0()/test->dd0() );
 

      m_htrkpT_residual->Fill( (test->pt()*0.001 - referencePT) );
      m_htrkipT_residual->Fill( (1000/test->pt() - 1/referencePT) );
      m_htrketa_residual->Fill( test->eta() - referenceEta );
      m_htrkphi_residual->Fill( test->phi() - referencePhi ); 
 
      m_htrkd0_residual->Fill( test->d0() - referenceD0 );
      m_htrkz0_residual->Fill( test->z0() - referenceZ0  );
 
      m_htrkdd0_residual->Fill( test->dd0() - referenceDD0 );
      m_htrkdz0_residual->Fill( test->dz0() - referenceDZ0  );
 
      m_hnpixvseta_rec->Fill( referenceEta, test->nPixels() ); 
      m_hnsctvseta_rec->Fill( referenceEta, test->nSCT() ); 
 
      m_hnpixvsphi_rec->Fill( referencePhi, test->nPixels() ); 
      m_hnsctvsphi_rec->Fill( referencePhi, test->nSCT() ); 
 
      m_hnpixvsd0_rec->Fill( referenceD0, test->nPixels() ); 
      m_hnsctvsd0_rec->Fill( referenceD0, test->nSCT() ); 
 
      m_hnpixvspT_rec->Fill( std::fabs(referencePT),  test->nPixels() ); 
      m_hnsctvspT_rec->Fill( std::fabs(referencePT),  test->nSCT() ); 
 
      m_hnpix_rec->Fill(  test->nPixels() ); 
      m_hnsct_rec->Fill(  test->nSCT() ); 
      m_hnsihits_rec->Fill(  test->nSi() ); 
 
#if 0
      if (tevt) m_hnsihits_lb_rec->Fill( tevt->lumi_block(), test->nSi() );
#endif
 
      m_hntrt_rec->Fill(  test->nTRT() ); 
 
      m_hntrtvseta_rec->Fill( referenceEta, test->nTRT() ); 
      m_hntrtvsphi_rec->Fill( referencePhi, test->nTRT() ); 
 
      m_hd0vsphi_rec->Fill( test->phi(), test->d0() );
 
      if ( test->ndof()!=0 ) m_chi2dof_rec->Fill( test->chi2()/test->ndof() ); 
 
    }
 
  }
 
}

finalize()

void IDTPM2::Tier0::finalize ( )

virtual

Finalize resolution and bias histograms should be called from the calling montools stop() method.

Implements IDTPM2::IPlotBase.

Definition at line 471 of file Tier0.cxx.

{ } 

getHist() [1/2]

void IDTPM2::IPlotBase::getHist ( const std::string & hname, TH1 * hsrc )

inlineprotectedinherited

Definition at line 88 of file IPlotBase.h.

{ return getHist( histSvc(), hname, hsrc ); }

getHist() [2/2]

void IDTPM2::IPlotBase::getHist ( ServiceHandle< ITHistSvc > & histsvc, const std::string & hname, TH1 * hsrc ) const

protectedinherited

Definition at line 42 of file IPlotBase.cxx.

                                                                                                          {
  TH1* h = 0;
  if ( histsvc->getHist( hname, h ).isFailure() ) MY_MSG_WARNING << "Could not retieve histogram: " << hname << endmsg;
  else copyHist( hsrc, h );
}

histSvc()

virtual ServiceHandle< ITHistSvc > & IDTPM2::IPlotBase::histSvc ( )

inlineprotectedvirtualinherited

we may well need these at some point ...

this method is dangerous - should not be used anywhere except finalise or stop

Definition at line 105 of file IPlotBase.h.

                                              {
    if ( monTool()==0 ) throw std::runtime_error("IPlotBase: monTool not set");
    return (*monTool())->histogramService();
  }

initialize()

void IDTPM2::Tier0::initialize ( )

virtual

Book the histograms.

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

do we want to track the offline vertex ??? leave this in in preparation ...

han config too stufid to deal with spaces in histogram names

trigger tracking differential resolutions

residuals

Implements IDTPM2::IPlotBase.

Definition at line 31 of file Tier0.cxx.

                             {
 
  if ( !monTool() ) throw std::runtime_error( "Tier0::initialize() monTool not found" );
 
  m_hchain = TIDA::Histogram<float>( monTool(),  "Chain" );
 
  m_hroieta = TIDA::Histogram<float>( monTool(),  "roi_eta" );

 
  m_hntrk = TIDA::Histogram<float>( monTool(),  "reftrk_N" );

 
  m_htrkpT  = TIDA::Histogram<float>( monTool(), "reftrk_pT" );
  m_htrkphi = TIDA::Histogram<float>( monTool(), "reftrk_phi" );
  m_htrketa = TIDA::Histogram<float>( monTool(), "reftrk_eta" );
  m_htrkd0  = TIDA::Histogram<float>( monTool(), "reftrk_d0" );
      
  m_htrkz0  = TIDA::Histogram<float>( monTool(), "reftrk_z0" );

  m_htrkdd0  = TIDA::Histogram<float>( monTool(), "reftrk_dd0" );
  m_htrkdz0  = TIDA::Histogram<float>( monTool(), "reftrk_dz0" );
 
  m_htrkd0sig = TIDA::Histogram<float>( monTool(), "reftrk_d0sig" );
 


  //  m_hntrk_rec = TIDA::Histogram<float>( monTool(),  "testtrk_N", "Test tracks", 100, vnbins );
  m_hntrk_rec = TIDA::Histogram<float>( monTool(),  "testtrk_N" );
 
 
  //  m_htrkpT_rec  = TIDA::Histogram<float>( monTool(), "testtrk_pT" , "Test track pT",  25,    0.,   100.);
  m_htrkpT_rec  = TIDA::Histogram<float>( monTool(), "testtrk_pT" );
  m_htrkphi_rec = TIDA::Histogram<float>( monTool(), "testtrk_phi" );
  m_htrketa_rec = TIDA::Histogram<float>( monTool(), "testtrk_eta" );
  m_htrkd0_rec  = TIDA::Histogram<float>( monTool(), "testtrk_d0" );
   
  m_htrkz0_rec  = TIDA::Histogram<float>( monTool(), "testtrk_z0" );
 
  m_htrkdd0_rec  = TIDA::Histogram<float>( monTool(), "testtrk_dd0" );
  m_htrkdz0_rec  = TIDA::Histogram<float>( monTool(), "testtrk_dz0" );
 
  m_htrkd0sig_rec = TIDA::Histogram<float>( monTool(), "testtrk_d0sig" );
 
 

 
 
  m_htotal_efficiency = TIDA::Histogram<float>( monTool(), "Eff_overall" );
 
  m_hpTeff    = TIDA::Histogram<float>( monTool(),  "Eff_pT" );
  m_hetaeff   = TIDA::Histogram<float>( monTool(),  "Eff_Eta" );
  m_hphieff   = TIDA::Histogram<float>( monTool(),  "Eff_Phi" );
  m_hd0eff    = TIDA::Histogram<float>( monTool(),  "Eff_d0" );
  
  m_hz0eff    = TIDA::Histogram<float>( monTool(),  "Eff_z0" );
  m_hnVtxeff  = TIDA::Histogram<float>( monTool(),  "Eff_nVtx" );
 
  m_hd0vsphi     = TIDA::Histogram<float>( monTool(), "d0_vs_phi_prof" );
  m_hd0vsphi_rec = TIDA::Histogram<float>( monTool(), "d0_vs_phi_rec_prof" );
 
  m_hlbeff = TIDA::Histogram<float>( monTool(),  "Eff_lb" );
  // m_hmueff = TIDA::Histogram<float>( monTool(),  "Eff_mu" );
 
 
  m_htrkvtx_x_lb = TIDA::Histogram<float>( monTool(),  "trkvtx_x_vs_lb" );
  m_htrkvtx_y_lb = TIDA::Histogram<float>( monTool(),  "trkvtx_y_vs_lb" );
  m_htrkvtx_z_lb = TIDA::Histogram<float>( monTool(),  "trkvtx_z_vs_lb" );

  //  m_hotrkvtx_x_lb = TIDA::Histogram<float>( monTool(),  "otrkvtx_x_vs_lb" );
  //  m_hotrkvtx_y_lb = TIDA::Histogram<float>( monTool(),  "otrkvtx_y_vs_lb" );
  //  m_hotrkvtx_z_lb = TIDA::Histogram<float>( monTool(),  "otrkvtx_z_vs_lb" );
 

  m_hnpixvseta     = TIDA::Histogram<float>( monTool(), "npix_vs_eta" );
  m_hnpixvseta_rec = TIDA::Histogram<float>( monTool(), "npix_vs_eta_rec" );
 
  m_hnsctvseta     = TIDA::Histogram<float>( monTool(), "nsct_vs_eta" );
  m_hnsctvseta_rec = TIDA::Histogram<float>( monTool(), "nsct_vs_eta_rec" );
 
  m_hntrtvseta     = TIDA::Histogram<float>( monTool(), "ntrt_vs_eta" );
  m_hntrtvseta_rec = TIDA::Histogram<float>( monTool(), "ntrt_vs_eta_rec" );
 
  m_hnpixvsphi     = TIDA::Histogram<float>( monTool(), "npix_vs_phi" );
  m_hnpixvsphi_rec = TIDA::Histogram<float>( monTool(), "npix_vs_phi_rec" );
 
  m_hnsctvsphi     = TIDA::Histogram<float>( monTool(), "nsct_vs_phi" );
  m_hnsctvsphi_rec = TIDA::Histogram<float>( monTool(), "nsct_vs_phi_rec" );
 
  m_hntrtvsphi     = TIDA::Histogram<float>( monTool(), "ntrt_vs_phi" );
  m_hntrtvsphi_rec = TIDA::Histogram<float>( monTool(), "ntrt_vs_phi_rec" );
  
  m_hnpixvsd0     = TIDA::Histogram<float>( monTool(), "npix_vs_d0" );
  m_hnpixvsd0_rec = TIDA::Histogram<float>( monTool(), "npix_vs_d0_rec" );
  
  m_hnsctvsd0     = TIDA::Histogram<float>( monTool(), "nsct_vs_d0" );
  m_hnsctvsd0_rec = TIDA::Histogram<float>( monTool(), "nsct_vs_d0_rec" );
  
  
  m_hnpixvspT     = TIDA::Histogram<float>( monTool(), "npix_vs_pT" );
  m_hnpixvspT_rec = TIDA::Histogram<float>( monTool(), "npix_vs_pT_rec" );
 
  m_hnsctvspT     = TIDA::Histogram<float>( monTool(), "nsct_vs_pT" );
  m_hnsctvspT_rec = TIDA::Histogram<float>( monTool(), "nsct_vs_pT_rec" );
  
  
  m_hnsihits_lb     = TIDA::Histogram<float>( monTool(),  "nsihits_lb" );
  m_hnsihits_lb_rec = TIDA::Histogram<float>( monTool(),  "nsihits_lb_rec" );
  
  
  m_hlayer_rec  = TIDA::Histogram<float>( monTool(), "layer_rec" );
  m_hlayer      = TIDA::Histogram<float>( monTool(), "layer" );

 
 
  m_hpTres  = TIDA::Histogram<float>( monTool(), "Res_pT" );
  m_hipTres = TIDA::Histogram<float>( monTool(), "Res_ipT" );
  m_hetares = TIDA::Histogram<float>( monTool(), "Res_eta" );
  m_hphires = TIDA::Histogram<float>( monTool(), "Res_phi" );
  m_hd0res  = TIDA::Histogram<float>( monTool(), "Res_d0" );
  m_hz0res  = TIDA::Histogram<float>( monTool(), "Res_z0" );
 

 
  m_htrkpT_residual  = TIDA::Histogram<float>( monTool(), "residual_pT" );
  m_htrkipT_residual = TIDA::Histogram<float>( monTool(), "residual_ipT" );
  m_htrkphi_residual = TIDA::Histogram<float>( monTool(), "residual_phi" );
  m_htrketa_residual = TIDA::Histogram<float>( monTool(), "residual_eta" );
  m_htrkd0_residual  = TIDA::Histogram<float>( monTool(), "residual_d0" );
  m_htrkz0_residual  = TIDA::Histogram<float>( monTool(), "residual_z0" );
 
  m_htrkdd0_residual  = TIDA::Histogram<float>( monTool(), "residual_dd0" );
  m_htrkdz0_residual  = TIDA::Histogram<float>( monTool(), "residual_dz0" );
 
 
 
  m_hnpix     = TIDA::Histogram<float>( monTool(), "npix" );
  m_hnpix_rec = TIDA::Histogram<float>( monTool(), "npix_rec" );
 
  m_hnsct     = TIDA::Histogram<float>( monTool(), "nsct" );
  m_hnsct_rec = TIDA::Histogram<float>( monTool(), "nsct_rec" );
 
  m_hnsihits     = TIDA::Histogram<float>( monTool(), "nsiHits" );
  m_hnsihits_rec = TIDA::Histogram<float>( monTool(), "nsiHits_rec" );
 
  m_hntrt     = TIDA::Histogram<float>( monTool(), "ntrt" );
  m_hntrt_rec = TIDA::Histogram<float>( monTool(), "ntrt_rec" );
 
  m_chi2dof     = TIDA::Histogram<float>( monTool(), "chi2dof" );
  m_chi2dof_rec = TIDA::Histogram<float>( monTool(), "chi2dof_rec" );
  
  m_hmu = TIDA::Histogram<float>( monTool(),  "mu" );
  
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

monTool() [1/2]

ToolHandle< GenericMonitoringTool > * IDTPM2::IPlotBase::monTool ( )

inlineinherited

mon tool

Definition at line 71 of file IPlotBase.h.

{ return m_monTool; }

monTool() [2/2]

const ToolHandle< GenericMonitoringTool > * IDTPM2::IPlotBase::monTool ( ) const

inlineinherited

Definition at line 73 of file IPlotBase.h.

{ return m_monTool; }

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

name()

const std::string & IDTPM2::Tier0::name ( ) const

inline

Definition at line 46 of file Tier0.h.

{ return m_name; }

processResolution() [1/2]

void IDTPM2::IPlotBase::processResolution ( const std::string & path, bool writeflag = false )

inlineprotectedinherited

Definition at line 89 of file IPlotBase.h.

{ return processResolution( histSvc(), path, writeflag ); }

processResolution() [2/2]

void IDTPM2::IPlotBase::processResolution ( ServiceHandle< ITHistSvc > & histsvc, const std::string & path, bool writeflag = false ) const

protectedinherited

process the histogramss NB: might be better if instead of adding the 2D histogram and then copying the 1D hjistograms back, we passed in the 1D histogram pointers and filled them directly in the Resplot

use the provides 1D, maan, sigme histograms etc would like to do this ...

use the provides 1D, maan, sigme histograms etc

Definition at line 49 of file IPlotBase.cxx.

                                                                                                                        {
 
  TH2* hist2d = 0;
  
  if ( histsvc->getHist( path+"2D", hist2d ).isFailure() ) MY_MSG_WARNING << "Could not retieve 2D: " << (path+"2D") << endmsg;
  else {
    
    
    Resplot::Resplot rp( path, hist2d );
 
    rp.Finalise( Resplot::FitNull95 );
 
    if ( !writeflag ) {
      //  if ( histsvc->regHist( path+"1D",    rp.H1D()   ).isFailure() ) MY_MSG_WARNING << "Unable to register histogram: 1D:    " << name() << endmsg; 
      //  if ( histsvc->regHist( path+"mean",  rp.Mean()  ).isFailure() ) MY_MSG_WARNING << "Unable to register histogram: mean:  " << name() << endmsg; 
      //  if ( histsvc->regHist( path+"sigma", rp.Sigma() ).isFailure() ) MY_MSG_WARNING << "Unable to register histogram: sigma: " << name() << endmsg; 
      //  }
      //  else {
      getHist( histsvc, path+"1D",    rp.H1D()   );
      getHist( histsvc, path+"mean",  rp.Mean()  );
      getHist( histsvc, path+"sigma", rp.Sigma() );
    }
  }
 
}

realPath()

std::string IDTPM2::IPlotBase::realPath ( const std::string & tag = "" )

inherited

This is a horrific function, has to get ALL the histograms, just to be able to work out how to get the actual path to the histograms for this tool - there simply MUST be a better way ...

can add on our "fixed" histogram "Vertex" domain

Definition at line 86 of file IPlotBase.cxx.

                                                          {
 
  std::string dir  = (*monTool())->getPath();

  std::string stub = dir.substr( dir.find('/', 1) + 1 ) + tag; 
  
  const std::vector<std::string>& allhists = histSvc()->getHists();
 
  std::string basestr = "";
  
  for ( size_t i=0 ; i<allhists.size() ; i++ ) {
    if ( allhists[i].find(stub)!=std::string::npos ) {
      std::string s = allhists[i];
      basestr = s.substr(0,s.find("/"+stub)+1);
      break;
    }
  }
 
  return basestr + stub;
  
}

set_monTool()

void IDTPM2::IPlotBase::set_monTool ( ToolHandle< GenericMonitoringTool > * m )

inlineinherited

do we need / should we have this specific setter ??

Definition at line 76 of file IPlotBase.h.

{ m_monTool=m; }

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_chi2dof

TIDA::Histogram<float> IDTPM2::Tier0::m_chi2dof

private

Definition at line 131 of file Tier0.h.

m_chi2dof_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_chi2dof_rec

private

Definition at line 132 of file Tier0.h.

m_hchain

TIDA::Histogram<float> IDTPM2::Tier0::m_hchain

private

Definition at line 108 of file Tier0.h.

m_hd0eff

TIDA::Histogram<float> IDTPM2::Tier0::m_hd0eff

private

Definition at line 58 of file Tier0.h.

m_hd0res

TIDA::Histogram<float> IDTPM2::Tier0::m_hd0res

private

Definition at line 67 of file Tier0.h.

m_hd0vsphi

TIDA::Histogram<float> IDTPM2::Tier0::m_hd0vsphi

private

Definition at line 105 of file Tier0.h.

m_hd0vsphi_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hd0vsphi_rec

private

Definition at line 106 of file Tier0.h.

m_hetaeff

TIDA::Histogram<float> IDTPM2::Tier0::m_hetaeff

private

Definition at line 56 of file Tier0.h.

m_hetares

TIDA::Histogram<float> IDTPM2::Tier0::m_hetares

private

Definition at line 65 of file Tier0.h.

m_hipTres

TIDA::Histogram<float> IDTPM2::Tier0::m_hipTres

private

Definition at line 64 of file Tier0.h.

m_hlayer

TIDA::Histogram<float> IDTPM2::Tier0::m_hlayer

private

Definition at line 138 of file Tier0.h.

m_hlayer_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hlayer_rec

private

Definition at line 158 of file Tier0.h.

m_hlbeff

TIDA::Histogram<float> IDTPM2::Tier0::m_hlbeff

private

Definition at line 61 of file Tier0.h.

m_hmu

TIDA::Histogram<float> IDTPM2::Tier0::m_hmu

private

Definition at line 135 of file Tier0.h.

m_hnpix

TIDA::Histogram<float> IDTPM2::Tier0::m_hnpix

private

Definition at line 124 of file Tier0.h.

m_hnpix_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hnpix_rec

private

Definition at line 152 of file Tier0.h.

m_hnpixvsd0

TIDA::Histogram<float> IDTPM2::Tier0::m_hnpixvsd0

private

Definition at line 77 of file Tier0.h.

m_hnpixvsd0_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hnpixvsd0_rec

private

Definition at line 92 of file Tier0.h.

m_hnpixvseta

TIDA::Histogram<float> IDTPM2::Tier0::m_hnpixvseta

private

Definition at line 75 of file Tier0.h.

m_hnpixvseta_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hnpixvseta_rec

private

Definition at line 90 of file Tier0.h.

m_hnpixvsphi

TIDA::Histogram<float> IDTPM2::Tier0::m_hnpixvsphi

private

Definition at line 76 of file Tier0.h.

m_hnpixvsphi_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hnpixvsphi_rec

private

Definition at line 91 of file Tier0.h.

m_hnpixvspT

TIDA::Histogram<float> IDTPM2::Tier0::m_hnpixvspT

private

Definition at line 78 of file Tier0.h.

m_hnpixvspT_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hnpixvspT_rec

private

Definition at line 93 of file Tier0.h.

m_hnsct

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsct

private

Definition at line 125 of file Tier0.h.

m_hnsct_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsct_rec

private

Definition at line 153 of file Tier0.h.

m_hnsctvsd0

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsctvsd0

private

Definition at line 82 of file Tier0.h.

m_hnsctvsd0_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsctvsd0_rec

private

Definition at line 97 of file Tier0.h.

m_hnsctvseta

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsctvseta

private

Definition at line 80 of file Tier0.h.

m_hnsctvseta_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsctvseta_rec

private

Definition at line 95 of file Tier0.h.

m_hnsctvsphi

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsctvsphi

private

Definition at line 81 of file Tier0.h.

m_hnsctvsphi_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsctvsphi_rec

private

Definition at line 96 of file Tier0.h.

m_hnsctvspT

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsctvspT

private

Definition at line 83 of file Tier0.h.

m_hnsctvspT_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsctvspT_rec

private

Definition at line 98 of file Tier0.h.

m_hnsihits

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsihits

private

Definition at line 126 of file Tier0.h.

m_hnsihits_lb

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsihits_lb

private

Definition at line 88 of file Tier0.h.

m_hnsihits_lb_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsihits_lb_rec

private

Definition at line 103 of file Tier0.h.

m_hnsihits_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hnsihits_rec

private

Definition at line 154 of file Tier0.h.

m_hntrk

TIDA::Histogram<float> IDTPM2::Tier0::m_hntrk

private

Definition at line 110 of file Tier0.h.

m_hntrk_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hntrk_rec

private

Definition at line 129 of file Tier0.h.

m_hntrt

TIDA::Histogram<float> IDTPM2::Tier0::m_hntrt

private

Definition at line 127 of file Tier0.h.

m_hntrt_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hntrt_rec

private

Definition at line 155 of file Tier0.h.

m_hntrtvseta

TIDA::Histogram<float> IDTPM2::Tier0::m_hntrtvseta

private

Definition at line 85 of file Tier0.h.

m_hntrtvseta_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hntrtvseta_rec

private

Definition at line 100 of file Tier0.h.

m_hntrtvsphi

TIDA::Histogram<float> IDTPM2::Tier0::m_hntrtvsphi

private

Definition at line 86 of file Tier0.h.

m_hntrtvsphi_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_hntrtvsphi_rec

private

Definition at line 101 of file Tier0.h.

m_hnVtxeff

TIDA::Histogram<float> IDTPM2::Tier0::m_hnVtxeff

private

Definition at line 60 of file Tier0.h.

m_hphieff

TIDA::Histogram<float> IDTPM2::Tier0::m_hphieff

private

Definition at line 57 of file Tier0.h.

m_hphires

TIDA::Histogram<float> IDTPM2::Tier0::m_hphires

private

Definition at line 66 of file Tier0.h.

m_hpTeff

TIDA::Histogram<float> IDTPM2::Tier0::m_hpTeff

private

Definition at line 55 of file Tier0.h.

m_hpTres

TIDA::Histogram<float> IDTPM2::Tier0::m_hpTres

private

Definition at line 63 of file Tier0.h.

m_hroieta

TIDA::Histogram<float> IDTPM2::Tier0::m_hroieta

private

Definition at line 109 of file Tier0.h.

m_htotal_efficiency

TIDA::Histogram<float> IDTPM2::Tier0::m_htotal_efficiency

private

Monitorwd::AScalar Histogram wrapper class.

Definition at line 54 of file Tier0.h.

m_htrkd0

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkd0

private

Definition at line 115 of file Tier0.h.

m_htrkd0_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkd0_rec

private

Definition at line 144 of file Tier0.h.

m_htrkd0_residual

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkd0_residual

private

Definition at line 165 of file Tier0.h.

m_htrkd0sig

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkd0sig

private

Definition at line 122 of file Tier0.h.

m_htrkd0sig_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkd0sig_rec

private

Definition at line 150 of file Tier0.h.

m_htrkdd0

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkdd0

private

Definition at line 119 of file Tier0.h.

m_htrkdd0_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkdd0_rec

private

Definition at line 147 of file Tier0.h.

m_htrkdd0_residual

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkdd0_residual

private

Definition at line 168 of file Tier0.h.

m_htrkdz0

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkdz0

private

Definition at line 120 of file Tier0.h.

m_htrkdz0_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkdz0_rec

private

Definition at line 148 of file Tier0.h.

m_htrkdz0_residual

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkdz0_residual

private

Definition at line 169 of file Tier0.h.

m_htrketa

TIDA::Histogram<float> IDTPM2::Tier0::m_htrketa

private

Definition at line 113 of file Tier0.h.

m_htrketa_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_htrketa_rec

private

Definition at line 142 of file Tier0.h.

m_htrketa_residual

TIDA::Histogram<float> IDTPM2::Tier0::m_htrketa_residual

private

Definition at line 163 of file Tier0.h.

m_htrkipT_residual

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkipT_residual

private

Definition at line 162 of file Tier0.h.

m_htrkphi

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkphi

private

Definition at line 114 of file Tier0.h.

m_htrkphi_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkphi_rec

private

Definition at line 143 of file Tier0.h.

m_htrkphi_residual

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkphi_residual

private

Definition at line 164 of file Tier0.h.

m_htrkpT

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkpT

private

Definition at line 111 of file Tier0.h.

m_htrkpT_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkpT_rec

private

Definition at line 141 of file Tier0.h.

m_htrkpT_residual

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkpT_residual

private

Definition at line 161 of file Tier0.h.

m_htrkvtx_x_lb

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkvtx_x_lb

private

Definition at line 70 of file Tier0.h.

m_htrkvtx_y_lb

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkvtx_y_lb

private

Definition at line 71 of file Tier0.h.

m_htrkvtx_z_lb

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkvtx_z_lb

private

Definition at line 72 of file Tier0.h.

m_htrkz0

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkz0

private

Definition at line 116 of file Tier0.h.

m_htrkz0_rec

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkz0_rec

private

Definition at line 145 of file Tier0.h.

m_htrkz0_residual

TIDA::Histogram<float> IDTPM2::Tier0::m_htrkz0_residual

private

Definition at line 166 of file Tier0.h.

m_hz0eff

TIDA::Histogram<float> IDTPM2::Tier0::m_hz0eff

private

Definition at line 59 of file Tier0.h.

m_hz0res

TIDA::Histogram<float> IDTPM2::Tier0::m_hz0res

private

Definition at line 68 of file Tier0.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_monTool

ToolHandle<GenericMonitoringTool>* IDTPM2::IPlotBase::m_monTool

protectedinherited

Definition at line 116 of file IPlotBase.h.

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_name

std::string IDTPM2::Tier0::m_name

private

Definition at line 50 of file Tier0.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

---

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

• Tier0.h
• Tier0.cxx