IDTPM2::Resolutions Class Reference

#include <Resolutions.h>

Inheritance diagram for IDTPM2::Resolutions:

Collaboration diagram for IDTPM2::Resolutions:

Public Member Functions
	Resolutions (const std::string &name, ToolHandle< GenericMonitoringTool > *m=0)
	Constructor this method should be an enum of "allowed" methods.
virtual	~Resolutions ()=default
	Destructor.
void	initialize ()
	Book the histograms.
void	finalize ()
	Finalize resolution and bias histograms should be called from the calling montools stop() method.
void	execute (const TrackAnalysisStore &collections) const
	this can be over ridden if need be
void	method (unsigned m=0)
unsigned	method () const
const std::string &	name () const
	generic utilities, just in case
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
const std::string &	m_name
ToolHandle< GenericMonitoringTool > *	m_monTool

Private Types
enum	Param {   INCLUSIVE , PT , ETA , D0 ,   Z0 , QOVERP , QOVERPT , THETA ,   PHI , Z0SIN , NPARAMS , NPARAMSOUT = 3 }

Private Member Functions
void	getTrackParameters (const TrackView &p, std::array< float, NPARAMS > &params, std::array< float, NPARAMS > &errors) const
	get the track parameters
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::string	m_paramName [NPARAMS]
unsigned int	m_method
	probably will eventually no longer need these
TIDA::Histogram< float >	m_pull [NPARAMS]
TIDA::Histogram< float >	m_res [NPARAMS]
TIDA::Histogram< float >	m_sigma [NPARAMS]
TIDA::Histogram< float >	m_significance [NPARAMS]
TIDA::Histogram2D< float >	m_corr [NPARAMS]
TIDA::Histogram< float >	m_resHelper [NPARAMS][NPARAMSOUT]
TIDA::Histogram< float >	m_reswidth [NPARAMS][NPARAMSOUT]
TIDA::Histogram< float >	m_resmean [NPARAMS][NPARAMSOUT]
TIDA::Histogram< float >	m_pullHelper [NPARAMS][NPARAMSOUT]
TIDA::Histogram< float >	m_pullwidth [NPARAMS][NPARAMSOUT]
TIDA::Histogram< float >	m_pullmean [NPARAMS][NPARAMSOUT]
TIDA::Histogram2D< float >	m_resolution_vs_pt [NPARAMS]
	like the res{Helper,width,mean} plots above but actually make some sense
TIDA::Histogram2D< float >	m_resolution_vs_eta [NPARAMS]
TIDA::Histogram2D< float >	m_resolution_vs_z0 [NPARAMS]
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 32 of file Resolutions.h.

Member Enumeration Documentation

Param

enum IDTPM2::Resolutions::Param

private

Enumerator
INCLUSIVE
PT
ETA
D0
Z0
QOVERP
QOVERPT
THETA
PHI
Z0SIN
NPARAMS
NPARAMSOUT

Definition at line 61 of file Resolutions.h.

             { 
      INCLUSIVE,
      PT,
      ETA,
      D0,
      Z0,
      QOVERP,
      QOVERPT,
      THETA,
      PHI,
      Z0SIN,
      NPARAMS,
      NPARAMSOUT = 3 // Plot only vs pt and eta inclusive ????
  };

Constructor & Destructor Documentation

Resolutions()

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

Constructor this method should be an enum of "allowed" methods.

NB: no point making this an actual athena configurable class - better to make it an internal class of some global histogram class - although independent, then class HistogramDriver { ... } can containe any number of IHistogramFiller* and call them itself.

then the python for the HistogramDriver can have separate functions to book the relevant histograms, so we can do function HistogramDriver_build: ... histogramFiller.filler = { filler1, filler2 }

and so on, and these become functions that create histograms and for the c++ code it can loop over the fillers, and call their histogram bookers itself. The only issue, is in the use of histogram creating functions from the GenericMonTool: maybe we pass in the HistogramDriver so that they can used the histogram creators from there, or else they would need to begime GenericMonTools themselves. That would actually be more complicted, since to add a new tool, you would need to implement an entire new generic MonTool, but to add a helper class for the HistogramDriver, all you would need to do would be to add a basic python class which creates the histograms with a provided function, so less boiler plate, with simpler, and more flexible code. local include(s)

---

--— Constructor --—

Definition at line 56 of file Resolutions.cxx.

  : IPlotBase( name, m ), m_method(0) 
{ }

~Resolutions()

virtual IDTPM2::Resolutions::~Resolutions ( )

virtualdefault

Destructor.

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::Resolutions::execute ( const TrackAnalysisStore & collections ) const

virtual

this can be over ridden if need be

all the IDTPM fillers take a "weight". Where does this "weight" come from ? do we even need it ? double weight = 1;

— reference and test tracks —
don't actually need these here, as we are explicitly iterating over the matched pairs to avoid all the lookups

track matcher just loop over the matched tracks from here ...

we can get all the matches pairs directly ...

then can just iterate over the match pairs rather than look anything up ...

this "fill a vector, then for the tools from the vector" approach is quite nasty would it be better to define the array once outside the loop and over write ? More denagerous, but faster, better still to just use a vector<float> anyway then we can clear() for each track

this is why I don't like this NPARAMS enum appraoch - now you have to start indexing from 1, rather than 0, so you need to know about the enum stucture, really the loop should be for ( unsigned i=PT ; i<NPARAMS ; i++ )

nope, should test is testError!=0 and only fill the pulls etc if the error is set to a non-zero value, than can also be used for truth particles, jets, clusers etc

do we really want the significance for eg phi ? ie phi/dphi ? clealy we only want the significance for valiables that might have a resolution comparable to the actual values

this isn't the residual, we really need 1/testP[i] - 1/refP[i]; but is testP[i] = 1/qpt, then just testP[i]-refP[i] is what we should be using, this

why do we only have the residuals and pulls vs "inclusive", "eta" and "pt" ?? surely we ALSO want these vs, z0, d0 and (for confirmation) vs phi but then we would ALSO want them versus the number of tracks, number of vertices, and also versus <mu>

Implements IDTPM2::IPlotBase.

Definition at line 118 of file Resolutions.cxx.

                                                                             {
  
  
  
  
  //  const std::vector<const TrackView*>& refTracks  = collections.reference_tracks();
  //  const std::vector<const TrackView*>& testTracks = collections.test_tracks();
  
  const TIDA::Associator<const TrackView>* matcher = collections.matcher();
  
  std::array<float,NPARAMS>       refP = {};
  std::array<float,NPARAMS>  refErrorP = {};
  
  std::array<float,NPARAMS>      testP = {};
  std::array<float,NPARAMS> testErrorP = {};
  
  
  
  const TIDA::Associator<const TrackView>::map_type&  matches = matcher->matched();
  
  
  TIDA::Associator<const TrackView>::map_type::const_iterator itr = matches.begin();
 
  for ( ; itr!=matches.end() ; itr++ ) {  //cppcheck-suppress postfixOperator
    
    const TrackView* ref  = itr->first;
    const TrackView* test = itr->second;
    
    //  for ( size_t i=0 ; i<refTracks.size() ; i++ ) { 
    
    
    getTrackParameters(  *ref,  refP,  refErrorP );
    getTrackParameters( *test, testP, testErrorP );

    
    for( unsigned i=1 ; i<NPARAMS ; i++ ) {
      
      float residual = testP[i] - refP[i];
 
      if( i==PHI ) residual = deltaPhi( testP[i] - refP[i] ); // angular difference
      
 
      if ( testErrorP[i]!=0 )  { 
    
    float pull = residual/testErrorP[i];
    
    float sigma_test        = testErrorP[i];
 
    float significance_test = testP[i]/testErrorP[i];
    
    m_pull[i].Fill( pull ); // , weight );

    m_significance[i].Fill( significance_test ); // , weight );
 
    if ( i==QOVERPT ) {
      residual    = testP[i]/refP[i] - 1;    // Relative q/pt resolution
      sigma_test *= 1/std::fabs( testP[i] ); // relative q/pt error
    }
 
    m_sigma[i].Fill( sigma_test ); //, weight );
 
      }
        
      //    m_corr[i].Fill( refP[i], testP[i], weight ); /// !!! 2D histograms not implemented yet - next thing to do
 
      m_res[i].Fill( residual ); //, weight );
 
      m_corr[i].Fill( refP[i], testP[i] );
 
      m_resolution_vs_pt[i].Fill(  ref->pt()*0.001, residual );
      m_resolution_vs_eta[i].Fill( ref->eta(),      residual );
      m_resolution_vs_z0[i].Fill(  ref->z0(),       residual );
      
      // for( unsigned int j=0; j<NPARAMSOUT; j++ ) {
      //      m_resHelper[i][j],Fill(  refP[j], residual ); //, weight ); 
      //      m_pullHelper[i][j].Fill( refP[j], pull );     //, weight ); 
      // }
    }
  }
}

finalize()

void IDTPM2::Resolutions::finalize ( )

virtual

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

finalize NB: actually this CAN'T be called from finalize, since if we create and histograms in the finalize() and register them with the HistSvc for some reason athena crashes in the clean up, even if we setDirectory(0) on the histograms, so all the finalisation processing much take place in the stop() method so this has to be called indirectly by the algoritm stop()

Implements IDTPM2::IPlotBase.

Definition at line 244 of file Resolutions.cxx.

                                 {
 
  MY_MSG_DEBUG <<  "Finalising resolution plots: " << name() << endmsg;
 
  std::string realpath = realPath( "/Resolutions/" ); 
  
  std::string names[3] = { "pt", "eta", "z0" };
    
  for( unsigned i=1 ; i<NPARAMS ; i++ ) {
    for ( int j=0 ; j<3 ; j++ ) {
      processResolution( realpath+"resolution_"+m_paramName[i]+"_vs_"+names[j]+"/" );
    }
  }
  
#if 0
  IDPVM::ResolutionHelper resolutionHelper;
  IDPVM::ResolutionHelper::methods method = IDPVM::ResolutionHelper::methods( m_method );

  for( unsigned int i=1; i<NPARAMS; i++ ) {
    for( unsigned int j=0; j<NPARAMSOUT; j++ ) {
      
      std::cout << "\t"  <<  m_resHelper[i][j].name() << std::endl;
      std::cout << "\t"  <<  m_reswidth[i][j].name()  << std::endl;
      std::cout << "\t"  <<  m_resmean[i][j].name()   << std::endl;
      
      std::cout << "\t"  <<  m_pullHelper[i][j].name() << std::endl;
      std::cout << "\t"  <<  m_pullwidth[i][j].name()  << std::endl;
      std::cout << "\t"  <<  m_pullmean[i][j].name()   << std::endl;    
      
      //      resolutionHelper.makeResolutions(  m_resHelper[i][j], m_reswidth[i][j], m_resmean[i][j],  method );
      //      resolutionHelper.makeResolutions( m_pullHelper[i][j], m_pullwidth[i][j, m_pullmean[i][j], method );
    }
  }
#endif
  
}

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

getTrackParameters()

void IDTPM2::Resolutions::getTrackParameters ( const TrackView & p, std::array< float, NPARAMS > & params, std::array< float, NPARAMS > & errors ) const

private

get the track parameters

---

— getTrackParameters —

parameters

do we really want to store such a value ? in the wrapper, we will likely calculate it inside the function so it is no less helpfull to calculate it explicitly

no point testing for all these if it is not a track particle uncertainties

for the time being ...

Definition at line 288 of file Resolutions.cxx.

{
 
  params.fill(0);
  
  params[ D0 ]      = p.d0();
  params[ Z0 ]      = p.z0();
  params[ QOVERP ]  = p.qOverP() * Gaudi::Units::GeV;
  params[ QOVERPT ] = p.qOverP()*std::sin(p.theta()) * Gaudi::Units::GeV;
  params[ THETA ]   = p.theta();
  params[ PHI ]     = p.phi();
  params[ PT ]      = p.pt() / Gaudi::Units::GeV;
  params[ Z0SIN ]     = p.z0()*std::sin(p.theta()); 
  params[ ETA ]       = p.eta();
  params[ INCLUSIVE ] = 1;
 
  errors.fill(0);
  
  if ( p.is<xAOD::TrackParticle>() ) { 
    errors[ D0 ]        =  p.dd0();      //error( p, Trk::d0 );
    errors[ Z0 ]        =  p.dz0();      //, Trk::z0 );
    errors[ QOVERP ]    =  p.dqOverP();   // p, Trk::qOverP ) * Gaudi::Units::GeV;
    
    // errors[ QOVERPT ]   = qOverPTError( p ) * Gaudi::Units::GeV;
    errors[ QOVERPT ]   =  0;   // for the time being
    
    errors[ THETA ]     =  p.dtheta();   // error( p, Trk::theta );
    errors[ PHI ]       =  p.dphi();     // error( p, Trk::phi );
    errors[ PT ]        =  p.dpt();      // pTError( p ) / Gaudi::Units::GeV;
    //   errors[ Z0SIN ]     = z0SinThetaError( p ); ///
    errors[ Z0SIN ]     =  0; 
    errors[ ETA ]       =  p.deta();     // etaError( p );
    errors[ INCLUSIVE ] =  0;
  }
}

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::Resolutions::initialize ( )

virtual

Book the histograms.

---

— Book the histograms —

!!!! ARGH !! NO WAY !!!

corr ? correlation ???

loop all vs variables

not even sure what these histograms are for ... resolutions

pulls

pull helper ???

Implements IDTPM2::IPlotBase.

Definition at line 65 of file Resolutions.cxx.

{
  MY_MSG_DEBUG <<  "Booking resolutions: " << name()  << endmsg; 
  
  for( unsigned int i=1; i<NPARAMS; i++ ) {
    
    m_pull[i]         = TIDA::Histogram<float>(   monTool(), "pull_"+m_paramName[i] );
    
    m_pull[i]         = TIDA::Histogram<float>(   monTool(), "pull_"+m_paramName[i] );
    m_res[i]          = TIDA::Histogram<float>(   monTool(), "res_"+m_paramName[i] );
    m_sigma[i]        = TIDA::Histogram<float>(   monTool(), "sigma_"+m_paramName[i] );
    m_significance[i] = TIDA::Histogram<float>(   monTool(), "significance_"+m_paramName[i] );
    m_corr[i]         = TIDA::Histogram2D<float>( monTool(), "corr_test_vs_ref_"+m_paramName[i] ); 
 
    m_resolution_vs_pt[i]  = TIDA::Histogram2D<float>( monTool(), "2D", "resolution_"+m_paramName[i]+"_vs_pt" );
    m_resolution_vs_eta[i] = TIDA::Histogram2D<float>( monTool(), "2D", "resolution_"+m_paramName[i]+"_vs_eta" );
    m_resolution_vs_z0[i]  = TIDA::Histogram2D<float>( monTool(), "@D", "resolution_"+m_paramName[i]+"_vs_z0" );
    
    for( unsigned int j=0; j<NPARAMSOUT; j++ ) {

      m_resHelper[i][j] = TIDA::Histogram<float>( monTool(), "resHelper_"+m_paramName[i]+"_vs_"+m_paramName[j] );
      m_reswidth[i][j]  = TIDA::Histogram<float>( monTool(), "resolution_"+m_paramName[i]+"_vs_"+m_paramName[j] );
      m_resmean[i][j]   = TIDA::Histogram<float>( monTool(), "resmean_"+m_paramName[i]+"_vs_"+m_paramName[j] );
      
      m_pullHelper[i][j] = TIDA::Histogram<float>( monTool(), "pullHelper_"+m_paramName[i]+"_vs_"+m_paramName[j] ); 
      m_pullmean[i][j]   = TIDA::Histogram<float>( monTool(), "pullmean_"+m_paramName[i]+"_vs_"+m_paramName[j] );
      m_pullwidth[i][j]  = TIDA::Histogram<float>( monTool(), "pullwidth_"+m_paramName[i]+"_vs_"+m_paramName[j] );
      
    } // close NPARAMSOUT loop
  } // close NPARAMS loop
 
}

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

method() [1/2]

unsigned IDTPM2::Resolutions::method ( ) const

inline

Definition at line 56 of file Resolutions.h.

{ return m_method; }

method() [2/2]

void IDTPM2::Resolutions::method ( unsigned m = 0 )

inline

Definition at line 54 of file Resolutions.h.

{ m_method = m; }

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::IPlotBase::name ( ) const

inlineinherited

generic utilities, just in case

Definition at line 68 of file IPlotBase.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_corr

TIDA::Histogram2D<float> IDTPM2::Resolutions::m_corr[NPARAMS]

private

Definition at line 101 of file Resolutions.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_method

unsigned int IDTPM2::Resolutions::m_method

private

probably will eventually no longer need these

Definition at line 93 of file Resolutions.h.

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

const std::string& IDTPM2::IPlotBase::m_name

protectedinherited

Definition at line 114 of file IPlotBase.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_paramName

std::string IDTPM2::Resolutions::m_paramName[NPARAMS]

private

Initial value:

                        = {
  "inclusive", "pt", "eta", "d0", "z0", "qoverp", "ptqopt", "theta", "phi", "z0sin"
}

Definition at line 82 of file Resolutions.h.

                                 {
    "inclusive", "pt", "eta", "d0", "z0", "qoverp", "ptqopt", "theta", "phi", "z0sin"
  };

m_pull

TIDA::Histogram<float> IDTPM2::Resolutions::m_pull[NPARAMS]

private

Definition at line 97 of file Resolutions.h.

m_pullHelper

TIDA::Histogram<float> IDTPM2::Resolutions::m_pullHelper[NPARAMS][NPARAMSOUT]

private

Definition at line 107 of file Resolutions.h.

m_pullmean

TIDA::Histogram<float> IDTPM2::Resolutions::m_pullmean[NPARAMS][NPARAMSOUT]

private

Definition at line 109 of file Resolutions.h.

m_pullwidth

TIDA::Histogram<float> IDTPM2::Resolutions::m_pullwidth[NPARAMS][NPARAMSOUT]

private

Definition at line 108 of file Resolutions.h.

m_res

TIDA::Histogram<float> IDTPM2::Resolutions::m_res[NPARAMS]

private

Definition at line 98 of file Resolutions.h.

m_resHelper

TIDA::Histogram<float> IDTPM2::Resolutions::m_resHelper[NPARAMS][NPARAMSOUT]

private

Definition at line 103 of file Resolutions.h.

m_resmean

TIDA::Histogram<float> IDTPM2::Resolutions::m_resmean[NPARAMS][NPARAMSOUT]

private

Definition at line 105 of file Resolutions.h.

m_resolution_vs_eta

TIDA::Histogram2D<float> IDTPM2::Resolutions::m_resolution_vs_eta[NPARAMS]

private

Definition at line 114 of file Resolutions.h.

m_resolution_vs_pt

TIDA::Histogram2D<float> IDTPM2::Resolutions::m_resolution_vs_pt[NPARAMS]

private

like the res{Helper,width,mean} plots above but actually make some sense

Definition at line 113 of file Resolutions.h.

m_resolution_vs_z0

TIDA::Histogram2D<float> IDTPM2::Resolutions::m_resolution_vs_z0[NPARAMS]

private

Definition at line 115 of file Resolutions.h.

m_reswidth

TIDA::Histogram<float> IDTPM2::Resolutions::m_reswidth[NPARAMS][NPARAMSOUT]

private

Definition at line 104 of file Resolutions.h.

m_sigma

TIDA::Histogram<float> IDTPM2::Resolutions::m_sigma[NPARAMS]

private

Definition at line 99 of file Resolutions.h.

m_significance

TIDA::Histogram<float> IDTPM2::Resolutions::m_significance[NPARAMS]

private

Definition at line 100 of file Resolutions.h.

---

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

• Resolutions.h
• Resolutions.cxx