IDTPM2::VertexPlots Class Reference

#include <VertexPlots.h>

Inheritance diagram for IDTPM2::VertexPlots:

Collaboration diagram for IDTPM2::VertexPlots:

Classes
struct	ParHistograms

Public Member Functions
	VertexPlots (const std::string &name, ToolHandle< GenericMonitoringTool > *m=0)
	Constructor.
virtual	~VertexPlots ()=default
	Destructor.
void	initialize ()
	Book the histograms.
void	execute (const TrackAnalysisStore &collections) const
	this can be over ridden if need be
void	finalize ()
	Print out final stats on histograms.
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 Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
ParHistograms	m_test
	why mess about with separate tools for the distributions, the efficiencies and resolutions
ParHistograms	m_reference
TIDA::Histogram2D< float >	m_vtx_ntest_vs_nref
	ParHisrograms matched;.
TIDA::Histogram< float >	m_vtx_res_x
	residuals ...
TIDA::Histogram< float >	m_vtx_res_y
TIDA::Histogram< float >	m_vtx_res_z
TIDA::Histogram2D< float >	m_vtx_res_z_vs_z
	diferential residuals ...
TIDA::Histogram2D< float >	m_vtx_res_z_vs_ntracks
TIDA::Histogram2D< float >	m_vtx_res_z_vs_nvtx
TIDA::Histogram2D< float >	m_vtx_res_z_vs_mu
TIDA::Histogram2D< float >	m_vtx_eff_vs_z
	efficiencies ...
TIDA::Histogram2D< float >	m_vtx_eff_vs_mu
TIDA::Histogram2D< float >	m_vtx_eff_vs_nvtx
TIDA::Histogram2D< float >	m_vtx_eff_vs_ntracks
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 38 of file VertexPlots.h.

Constructor & Destructor Documentation

VertexPlots()

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

Constructor.

---

--— Constructor --—

Definition at line 20 of file VertexPlots.cxx.

  : IPlotBase( name, m ) { 
}

~VertexPlots()

virtual IDTPM2::VertexPlots::~VertexPlots ( )

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

virtual

this can be over ridden if need be

don't need run and event number ??

multiplicity histograms ...

fill parameter histograms ...

could loop over these independently, but we have the matcheing information, so might as well do it here ...

in the original IDTPM code information on the associated tracks and weights was passed in separately. Really, if need them, they should be added to the vertex itself - so they would be added as methods on the VertexView. Will come back to this ...

Implements IDTPM2::IPlotBase.

Definition at line 191 of file VertexPlots.cxx.

                                                                             {
 
  //  long    lumiblock = 0;
  double  mu        = 0;
 
  const xAOD::EventInfo* eventinfo = collections.eventInfo();
 
  if (eventinfo) {
    //    runnumber = collections.eventInfo()->runNumber(); 
    //    eventid   = collections.eventInfo()->eventNumber(); 
    //    lumiblock = collections.eventInfo()->lumiBlock(); 
    mu  = collections.eventInfo()->averageInteractionsPerCrossing();
  }
 
  const std::vector<const VertexView*>& ref  = collections.refvertices();
  const std::vector<const VertexView*>& test = collections.testvertices();

  
  m_vtx_ntest_vs_nref.Fill( ref.size(), test.size() );
  
  m_reference.m_nVtx.Fill( ref.size() );
  m_reference.m_nVtx_vs_actualMu.Fill( mu, ref.size() );
  
  m_test.m_nVtx.Fill( test.size() );
  m_test.m_nVtx_vs_actualMu.Fill( mu, test.size() );

 
  for ( size_t i=0 ;  i<ref.size() ; i++ ) {  m_reference.fill(  ref[i] ); }
  for ( size_t i=0 ; i<test.size() ; i++ ) {       m_test.fill( test[i] ); }
 
  // std::cout << "ref: " << ref.size() << "\ttest: " << test.size() << std::endl; 
 
  // now residuals andc efficiencies ...
 
  const TIDA::Associator<const VertexView>* matcher = collections.vertex_matcher();
 
  for ( size_t i=0 ; i<ref.size() ; i++ ) {  
 
    const VertexView* vr = ref[i];
 
    const VertexView* vt = matcher->matched( ref[i] );
 
    bool matched = false;
    
    if ( vt ) matched = true;
 
    size_t nvTracks = vr->nTrackParticles();
 
    m_vtx_eff_vs_z.Fill(        vr->z(), matched );
    m_vtx_eff_vs_mu.Fill(            mu, matched );
    m_vtx_eff_vs_nvtx.Fill(  ref.size(), matched );
    m_vtx_eff_vs_ntracks.Fill( nvTracks, matched );
    
 
    if ( matched ) {
 
      float dx = vt->x() - vr->x();
      float dy = vt->y() - vr->y();
      float dz = vt->z() - vr->z();
      
      m_vtx_res_x.Fill( dx );
      m_vtx_res_y.Fill( dy );
      m_vtx_res_z.Fill( dz );
 
      m_vtx_res_z_vs_z.Fill(       vr->z(), dz );
      m_vtx_res_z_vs_ntracks.Fill( nvTracks, dz );
      m_vtx_res_z_vs_nvtx.Fill(    ref.size(), dz );
      m_vtx_res_z_vs_mu.Fill(      mu, dz );
 
    }
 
  }

  
  // if( m_doTrackPlots ) {
  //    size_t nvTracks = associatedTracks.size();
  //    if( nvTracks != associatedTrackWeights.size() ) {
  //      MY_MSG_ERROR <<  "Vertex-associated track number mismatch"  << endmsg;
  //      return StatusCode::FAILURE;
  //    }
  // 
  
  // if( m_doTruthMuPlots ) {
  //    m_nVtx_vs_truthMu_2D.fill(  truthMu,    nVertices,  weight );
  //    m_nVtx_vs_truthMu.fill(     truthMu,    nVertices,  weight );
  // }
 
}

finalize()

void IDTPM2::VertexPlots::finalize ( )

virtual

Print out final stats on histograms.

---

--— finalizePlots --—

Implements IDTPM2::IPlotBase.

Definition at line 293 of file VertexPlots.cxx.

                                 {
  
  MY_MSG_DEBUG <<  "Finalising vertex parameters plots"  << endmsg;
 
  std::string realpath = realPath( "/Vertex/" ); // basestr+stub;
 
  MY_MSG_DEBUG  << "realpath: " << realpath << endmsg;
   
  processResolution( realpath+"vtx_res_z_vs_z/" );
  processResolution( realpath+"vtx_res_z_vs_ntracks/" );
  processResolution( realpath+"vtx_res_z_vs_nvtx/" );
  processResolution( realpath+"vtx_res_z_vs_mu/" );
 
  //  std::cout << "resplot: " << name() << "\t" << m_vtx_res_z_vs_z.name()       << std::endl;
  //  std::cout << "resplot: " << name() << "\t" << m_vtx_res_z_vs_ntracks.name() << std::endl;
  //  std::cout << "resplot: " << name() << "\t" << m_vtx_res_z_vs_nvtx.name()    << std::endl;
  //  std::cout << "resplot: " << name() << "\t" << m_vtx_res_z_vs_mu.name()      << std::endl;
 
}

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

virtual

Book the histograms.

---

— Book the histograms —

parameter histograms ...

initialise resolutions and efficiencies here ...

residuals ...

diferential residuals ...

efficiencies ...

Implements IDTPM2::IPlotBase.

Definition at line 31 of file VertexPlots.cxx.

                                   {

  m_reference.initialize( this, "reference");
  m_test.initialize(      this, "test");

 
  m_vtx_ntest_vs_nref = TIDA::Histogram2D<float>( monTool(), "vtx_ntest_vs_nref" );
  
  m_vtx_res_x = TIDA::Histogram<float>( monTool(), "vtx_res_x" );     
  m_vtx_res_y = TIDA::Histogram<float>( monTool(), "vtx_res_y" );   
  m_vtx_res_z = TIDA::Histogram<float>( monTool(), "vtx_res_z" );
  
  m_vtx_res_z_vs_z       = TIDA::Histogram2D<float>   ( monTool(), "2D", "vtx_res_z_vs_z" );
  m_vtx_res_z_vs_ntracks = TIDA::Histogram2D<float>   ( monTool(), "2D", "vtx_res_z_vs_ntracks" );
  m_vtx_res_z_vs_nvtx    = TIDA::Histogram2D<float>   ( monTool(), "2D", "vtx_res_z_vs_nvtx" );
  m_vtx_res_z_vs_mu      = TIDA::Histogram2D<float>   ( monTool(), "2D", "vtx_res_z_vs_mu" );
  
  m_vtx_eff_vs_z       = TIDA::Histogram2D<float>   ( monTool(), "vtx_eff_vs_z"       );
  m_vtx_eff_vs_mu      = TIDA::Histogram2D<float>   ( monTool(), "vtx_eff_vs_mu"      );
  m_vtx_eff_vs_nvtx    = TIDA::Histogram2D<float>   ( monTool(), "vtx_eff_vs_nvtx"    );
  m_vtx_eff_vs_ntracks = TIDA::Histogram2D<float>   ( monTool(), "vtx_eff_vs_ntracks" );
  
}

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::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_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

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_reference

ParHistograms IDTPM2::VertexPlots::m_reference

private

Definition at line 110 of file VertexPlots.h.

m_test

ParHistograms IDTPM2::VertexPlots::m_test

private

why mess about with separate tools for the distributions, the efficiencies and resolutions

Definition at line 109 of file VertexPlots.h.

m_vtx_eff_vs_mu

TIDA::Histogram2D<float> IDTPM2::VertexPlots::m_vtx_eff_vs_mu

private

Definition at line 129 of file VertexPlots.h.

m_vtx_eff_vs_ntracks

TIDA::Histogram2D<float> IDTPM2::VertexPlots::m_vtx_eff_vs_ntracks

private

Definition at line 131 of file VertexPlots.h.

m_vtx_eff_vs_nvtx

TIDA::Histogram2D<float> IDTPM2::VertexPlots::m_vtx_eff_vs_nvtx

private

Definition at line 130 of file VertexPlots.h.

m_vtx_eff_vs_z

TIDA::Histogram2D<float> IDTPM2::VertexPlots::m_vtx_eff_vs_z

private

efficiencies ...

Definition at line 128 of file VertexPlots.h.

m_vtx_ntest_vs_nref

TIDA::Histogram2D<float> IDTPM2::VertexPlots::m_vtx_ntest_vs_nref

private

ParHisrograms matched;.

Definition at line 114 of file VertexPlots.h.

m_vtx_res_x

TIDA::Histogram<float> IDTPM2::VertexPlots::m_vtx_res_x

private

residuals ...

Definition at line 117 of file VertexPlots.h.

m_vtx_res_y

TIDA::Histogram<float> IDTPM2::VertexPlots::m_vtx_res_y

private

Definition at line 118 of file VertexPlots.h.

m_vtx_res_z

TIDA::Histogram<float> IDTPM2::VertexPlots::m_vtx_res_z

private

Definition at line 119 of file VertexPlots.h.

m_vtx_res_z_vs_mu

TIDA::Histogram2D<float> IDTPM2::VertexPlots::m_vtx_res_z_vs_mu

private

Definition at line 125 of file VertexPlots.h.

m_vtx_res_z_vs_ntracks

TIDA::Histogram2D<float> IDTPM2::VertexPlots::m_vtx_res_z_vs_ntracks

private

Definition at line 123 of file VertexPlots.h.

m_vtx_res_z_vs_nvtx

TIDA::Histogram2D<float> IDTPM2::VertexPlots::m_vtx_res_z_vs_nvtx

private

Definition at line 124 of file VertexPlots.h.

m_vtx_res_z_vs_z

TIDA::Histogram2D<float> IDTPM2::VertexPlots::m_vtx_res_z_vs_z

private

diferential residuals ...

Definition at line 122 of file VertexPlots.h.

---

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

• VertexPlots.h
• VertexPlots.cxx