GenAodValidationTool Class Reference

#include <GenAodValidationTool.h>

Inheritance diagram for GenAodValidationTool:

Collaboration diagram for GenAodValidationTool:

Public Member Functions
	GenAodValidationTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters:
virtual	~GenAodValidationTool ()
	Destructor:
StatusCode	initialize ()
	Athena Algorithm's Hooks.
StatusCode	execute ()
StatusCode	finalize ()
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Inline methods:

Protected Types
typedef ToolHandle< IIOHepMcTool >	HepMcTool_t
	shorthand for lazy people (good coders are lazy people, aren't they ?)

Protected Member Functions
	GenAodValidationTool ()
	Default constructor:
virtual StatusCode	initializeTool ()
	Non-const methods:
virtual StatusCode	finalizeTool ()
virtual StatusCode	executeTool ()
	Main method to perform the validation.
virtual StatusCode	executeTool (const McEventCollection *refMcEvents, const McEventCollection *checkMcEvents)
	Main method to perform the validation:
virtual StatusCode	executeTool (const HepMC::GenEvent *refMcEvents, const HepMC::GenEvent *checkMcEvents)
	Main method to perform the validation (directly onto the GenEvents):
bool	compareVtx (const HepMC::ConstGenVertexPtr &vtx1, const HepMC::ConstGenVertexPtr &vtx2) const
	Check that 2 given vertices are the same:
bool	compareParts (const HepMC::ConstGenParticlePtr &p1, const HepMC::ConstGenParticlePtr &p2) const
	Check that 2 given particles are the same:
StatusCode	setupHepMcWriterTools ()
	Request pointers to the HepMcWriterTools to be able to write out HepMC::GenEvent for further comparison (off-framework)
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
StringProperty	m_refMcEventsName
	Location of the reference McEventCollection.
StringProperty	m_checkMcEventsName
	Location of the 'to-be-validated' McEventCollection.
StringProperty	m_hardVtxOutFileName
	Name of the output text file which will contain the hard-scattering vertices.
std::ofstream *	m_outFile
	Pointer to the output text file containing hard-scattering vertices.
HepMcTool_t	m_refMcEventWriter
	Tool to write the reference HepMC::GenEvent into a dedicated file.
HepMcTool_t	m_checkMcEventWriter
	Tool to write the 'to-be-checked' HepMC::GenEvent into a dedicated file.
unsigned int	m_nAnalysedEvents
	Counter of analysed events.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 31 of file GenAodValidationTool.h.

Member Typedef Documentation

HepMcTool_t

typedef ToolHandle<IIOHepMcTool> GenAodValidationTool::HepMcTool_t

protected

shorthand for lazy people (good coders are lazy people, aren't they ?)

Definition at line 135 of file GenAodValidationTool.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

GenAodValidationTool() [1/2]

GenAodValidationTool::GenAodValidationTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Constructor with parameters:

Public methods:

Constructors

Definition at line 41 of file GenAodValidationTool.cxx.

                                                   : 
  TruthParticleValidationBaseTool( type, name, parent ),
  m_outFile( nullptr )
{
  //
  // Property declaration
  // 
  
  declareProperty( "RefMcEvents",   
           m_refMcEventsName = "TruthEvent",
           "StoreGate location of the reference McEventCollection" );
 
  declareProperty( "CheckMcEvents", 
           m_checkMcEventsName = "GEN_AOD",
           "Location of the 'to-be-validated' McEventCollection" );
 
  declareProperty( "HardScatteringVtxOutputFile",
           m_hardVtxOutFileName = "hepmc.hard.vtx.txt",
           "Name of the output text file which will contain the " 
           "hard-scattering vertices" );
 
  declareProperty( "RefHepMcWriterTool",
           m_refMcEventWriter = HepMcTool_t( "HepMcWriterTool", 
                             this ),
           "Tool to write the reference HepMC::GenEvent into a dedicated file" );
 
  declareProperty( "CheckHepMcWriterTool",
           m_checkMcEventWriter = HepMcTool_t( "HepMcWriterTool", 
                               this ),
           "Tool to write the \"to-be-checked\" HepMC::GenEvent "
           "into a dedicated file" );
 
}

~GenAodValidationTool()

GenAodValidationTool::~GenAodValidationTool ( )

virtual

Destructor:

Destructor.

Definition at line 79 of file GenAodValidationTool.cxx.

{ 
  ATH_MSG_DEBUG("Calling destructor");
 
  if ( m_outFile ) {
    m_outFile->close();
    delete m_outFile;
    m_outFile = nullptr;
  }
 
}

GenAodValidationTool() [2/2]

GenAodValidationTool::GenAodValidationTool ( )

protected

Default constructor:

Member Function Documentation

compareParts()

bool GenAodValidationTool::compareParts ( const HepMC::ConstGenParticlePtr & p1, const HepMC::ConstGenParticlePtr & p2 ) const

protected

Check that 2 given particles are the same:

• 4-mom
• id
• status
• flow
• polarization

Definition at line 406 of file GenAodValidationTool.cxx.

{
  if ( !p1 || !p2 ) {
    ATH_MSG_ERROR("One of particles is a NULL pointer !!" << endmsg
          << " p1: " << p1 << endmsg
          << " p2: " << p2);
    return false;
  }
 
  if ( HepMC::barcode(p1) != HepMC::barcode(p2) ) {
    return false;
  }
 
  const HepMC::FourVector hlv1   = p1->momentum();
  const int id1                  = p1->pdg_id();
  const int status1              = p1->status();
  auto flow1                     = HepMC::flow(p1);
  auto pol1                      = HepMC::polarization(p1);
 
  const HepMC::FourVector hlv2   = p2->momentum();
  const int id2                  = p2->pdg_id();
  const int status2              = p2->status();
  auto flow2                     = HepMC::flow(p2);
  auto pol2                      = HepMC::polarization(p2);
 
  const bool isOK = ( hlv1    == hlv2    &&
              id1     == id2     && 
              status1 == status2 &&
              flow1   == flow2   &&
              pol1    == pol2    );
 
 
  if ( !isOK ) {
    ATH_MSG_WARNING 
      ("=============================" << endmsg
       << "\thlv:    " << std::boolalpha << (hlv1    == hlv2   ) << endmsg
       << "\tid:     " << std::boolalpha << (id1     == id2    ) << endmsg
       << "\tstatus: " << std::boolalpha << (status1 == status2) << endmsg
       << "\tflow:   " << std::boolalpha << (flow1   == flow2  ) << endmsg
       << "\tpolar:  " << std::boolalpha << (pol1    == pol2   ) << endmsg
       << "=============================");
  }
 
  return isOK;
}

compareVtx()

bool GenAodValidationTool::compareVtx ( const HepMC::ConstGenVertexPtr & vtx1, const HepMC::ConstGenVertexPtr & vtx2 ) const

protected

Check that 2 given vertices are the same:

• check same number of branches
• check same particles (4-mom + id + status)

Definition at line 310 of file GenAodValidationTool.cxx.

{
  if ( !vtx1 || !vtx2 ) {
    ATH_MSG_ERROR("One of vertices is a NULL pointer !!" << endmsg
          << " vtx1: " << vtx1 << endmsg
          << " vtx2: " << vtx2);
    return false;
  }
 
#ifdef HEPMC3 
  auto inVtx1 = vtx1->particles_in();
  auto inVtx2 = vtx2->particles_in();
  if (inVtx1.size() !=  inVtx2.size()) {
    ATH_MSG_ERROR("Not the same number of branches !!" << endmsg  << " in:  " << inVtx1.size()  << "\t" << inVtx2.size());
    return false;
  }
  std::sort(inVtx1.begin(), inVtx1.end(), [](auto& a, auto& b) -> bool{return a->momentum().pz() > b->momentum().pz(); });
  std::sort(inVtx2.begin(), inVtx2.end(), [](auto& a, auto& b) -> bool{return a->momentum().pz() > b->momentum().pz(); });
  for (size_t i=0; i<inVtx1.size(); ++i){
     if ( compareParts( inVtx1.at(i), inVtx2.at(i) ) ) continue;
     ATH_MSG_ERROR("In-going particles are NOT matching !!");
     return false;
  }
  auto outVtx1 = vtx1->particles_out();
  auto outVtx2 = vtx2->particles_out();
  if (outVtx1.size() !=  outVtx2.size()) {
    ATH_MSG_ERROR("Not the same number of branches !!" << endmsg  << " out:  " << outVtx1.size()  << "\t" << outVtx2.size());
    return false;
  }
  std::sort(outVtx1.begin(), outVtx1.end(), [](auto& a, auto& b) -> bool{return a->momentum().pz() > b->momentum().pz(); });
  std::sort(outVtx2.begin(), outVtx2.end(), [](auto& a, auto& b) -> bool{return a->momentum().pz() > b->momentum().pz(); });
  for (size_t i=0; i<outVtx1.size(); ++i){
     if ( compareParts( outVtx1.at(i), outVtx2.at(i) ) ) continue;
     ATH_MSG_ERROR("Out-going particles are NOT matchiutg !!");
     return false;
  }
#else
  const int inVtx1 = vtx1->particles_in_size();
  const int inVtx2 = vtx2->particles_in_size();
 
  const int outVtx1 = vtx1->particles_out_size();
  const int outVtx2 = vtx2->particles_out_size();
  
  if (  inVtx1 !=  inVtx2 || outVtx1 != outVtx2 ) {
    ATH_MSG_ERROR("Not the same number of branches !!" << endmsg
          << " in:  " << inVtx1  << "\t" << inVtx2  << endmsg
          << " out: " << outVtx1 << "\t" << outVtx2);
    return false;
  }
 
  for ( HepMC::GenVertex::particles_in_const_iterator inPart1 = vtx1->particles_in_const_begin();
    inPart1 != vtx1->particles_in_const_end();
    ++inPart1 ) {
    bool inParticleOK = false;
    for ( HepMC::GenVertex::particles_in_const_iterator inPart2 = vtx2->particles_in_const_begin();
    inPart2 != vtx2->particles_in_const_end();
    ++inPart2 ) {
      if ( compareParts( *inPart1, *inPart2 ) ) {
    inParticleOK = true;
    break;
      }
    } //> end loop over in-part2
 
    if ( !inParticleOK ) {
      ATH_MSG_ERROR("In-going particles are NOT matching !!");
      return false;
    }
 
  }//> end loop over in-part1
 
 
  for ( HepMC::GenVertex::particles_out_const_iterator outPart1 = vtx1->particles_out_const_begin();
    outPart1 != vtx1->particles_out_const_end();
    ++outPart1 ) {
    bool outParticleOK = false;
    for ( HepMC::GenVertex::particles_out_const_iterator outPart2 = vtx2->particles_out_const_begin();
    outPart2 != vtx2->particles_out_const_end();
    ++outPart2 ) {
      if ( compareParts( *outPart1, *outPart2 ) ) {
    outParticleOK = true;
    break;
      }
    } //> end loop over out-part2
 
    if ( !outParticleOK ) {
      ATH_MSG_ERROR("Out-going particles are NOT matching !!");
      return false;
    }
 
  }//> end loop over out-part1
#endif
 
  return true;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode TruthParticleValidationBaseTool::execute ( )

virtualinherited

Implements ITruthParticleValidationTool.

Definition at line 78 of file TruthParticleValidationBaseTool.cxx.

{
  ++m_nAnalysedEvents;
  return executeTool();
}

executeTool() [1/3]

StatusCode GenAodValidationTool::executeTool ( )

protectedvirtual

Main method to perform the validation.

Just a wrapper around the more API-detailed method.

Implements TruthParticleValidationBaseTool.

Definition at line 132 of file GenAodValidationTool.cxx.

{
  // retrieve reference McEventCollection
  const McEventCollection * refMcEvents = nullptr;
  if ( evtStore()->retrieve( refMcEvents, m_refMcEventsName ).isFailure() ||
       nullptr == refMcEvents ) {
    ATH_MSG_ERROR("Could not retrieve reference McEventCollection at ["
          << m_refMcEventsName << "] !!");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_VERBOSE("Successfully retrieved reference McEventCollection at ["
            << m_refMcEventsName << "]");
 
    if ( !m_refMcEventWriter || 
     m_refMcEventWriter->execute().isFailure() ) {
      ATH_MSG_WARNING("Failed to write the reference GenEvent !!");
    }
  }
 
  // retrieve checking McEventCollection
  const McEventCollection * checkMcEvents = nullptr;
  if ( evtStore()->retrieve(checkMcEvents, m_checkMcEventsName).isFailure() ||
       nullptr == checkMcEvents ) {
    ATH_MSG_ERROR("Could not retrieve 'to-be-validated' McEventCollection at ["
          << m_checkMcEventsName << "] !!");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_VERBOSE
      ("Successfully retrieved 'to-be-validated' McEventCollection at ["
       << m_checkMcEventsName << "]");
 
    if ( !m_checkMcEventWriter ||
     m_checkMcEventWriter->execute().isFailure() ) {
      ATH_MSG_WARNING("Failed to write the reference GenEvent !!");
    }
  }
 
  return executeTool( refMcEvents, checkMcEvents );
}

executeTool() [2/3]

StatusCode GenAodValidationTool::executeTool ( const HepMC::GenEvent * refMcEvents, const HepMC::GenEvent * checkMcEvents )

protectedvirtual

Main method to perform the validation (directly onto the GenEvents):

• check that each vertex is identical to the original one
• check that missing particles are not there for a good reason

Definition at line 209 of file GenAodValidationTool.cxx.

{
  if ( nullptr == refMcEvts ) {
    ATH_MSG_ERROR("NULL pointer to reference HepMC::GenEvent !!");
    return StatusCode::FAILURE;
  }
 
  if ( nullptr == checkMcEvts ) {
    ATH_MSG_ERROR("NULL pointer to the 'to-be-validated' HepMC::GenEvent !!");
    return StatusCode::FAILURE;
  }
 
  const unsigned int evtNbr = refMcEvts->event_number();
  (*m_outFile) << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
           << std::endl
           << "Event: " << evtNbr
           << std::endl;
 
#ifdef HEPMC3   
  std::map<int,int> ref_bc_to_id;
  const auto& refvertices = refMcEvts->vertices();
  for ( const auto&  vtx: refvertices) {
    // AV: this algorthm is not very correct
    int partonsin = 0;
    int showerout = 0;
    for (auto& p: vtx->particles_in()) if (MC::isQuark(p) || MC::isGluon(p)) partonsin++;
    for (auto& p: vtx->particles_out()) if (p->pdg_id() == 91||p->pdg_id() == 92||p->pdg_id() == 94)  showerout++;
    if ( partonsin >= 2 &&  showerout == 0 ) {
      ref_bc_to_id[HepMC::barcode(vtx)] = vtx->id();
   }
  }
  std::map<int,int> che_bc_to_id;
  const auto& chevertices = checkMcEvts->vertices();
  for (const auto& checkVtx: chevertices) {
    che_bc_to_id[HepMC::barcode(checkVtx)] = checkVtx->id();
  }
  std::set<int> allbarcodes;
  for (const auto &[bc,id]: ref_bc_to_id) allbarcodes.insert(bc);
  for (const auto &[bc,id]: che_bc_to_id) allbarcodes.insert(bc);
  for (const auto &bc: allbarcodes){
   auto ref_it = ref_bc_to_id.find(bc);
   auto che_it = che_bc_to_id.find(bc);
   if (ref_it == ref_bc_to_id.end()) {ATH_MSG_WARNING("In Event [" << evtNbr << "]: got null ref-vertex (barcode: " << bc << ")");  continue; }
   if (che_it == che_bc_to_id.end()) {ATH_MSG_WARNING("Output GenEvent is missing the selected HardScattering Vtx !!"<< " (" << bc << ")"); continue; }
   if (-ref_it->second > int(refvertices.size()) ) { continue; } 
   if (-che_it->second > int(chevertices.size()) ) { continue; } 
   const auto& refvtx = refvertices[-ref_it->second-1];
   const auto& chevtx = chevertices[-che_it->second-1];
   (*m_outFile) << refvtx << std::endl;
   (*m_outFile) << chevtx << std::endl;
   (*m_outFile) << "---------" << std::endl;
   if ( !compareVtx( refvtx, chevtx ) ) {
        ATH_MSG_WARNING("Selected HardScattering vertices are NOT the same !!"<< " at Event [" << evtNbr << "]"<< " refVtx = " << refvtx<<" chevtx = " << chevtx);
   }
  }
  (*m_outFile) << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" << std::endl;  
#else
  std::set<int> ref_bc;
  for ( auto vtxIt = refMcEvts->vertices_begin(); vtxIt != refMcEvts->vertices_end(); ++vtxIt ) {
    auto vtx =*vtxIt;
    int partonsin = 0;
    int showerout = 0;
#ifdef HEPMC3
    for (auto p = vtx->particles_in_begin();p!=vtx->particles_in_end();++p ) if (MC::isQuark(*p) || MC::isGluon(*p)) partonsin++;
#else
    for (auto p = vtx->particles_in_const_begin();p!=vtx->particles_in_const_end();++p ) if (MC::isQuark(*p) || MC::isGluon(*p)) partonsin++;
#endif
    for (auto& p : *vtx) if (p->pdg_id() == 91||p->pdg_id() == 92||p->pdg_id() == 94)  showerout++;
    if ( partonsin >= 2 &&  showerout == 0 ) {
      ref_bc.insert(vtx->barcode());
   }
  }
  std::set<int> che_bc;
  for ( auto vtxIt = checkMcEvts->vertices_begin(); vtxIt != checkMcEvts->vertices_end(); ++vtxIt ) {
    auto vtx =*vtxIt;
    che_bc.insert(vtx->barcode());
  }
  std::set<int> allbarcodes;
  for (const auto &bc: ref_bc) allbarcodes.insert(bc);
  for (const auto &bc: che_bc) allbarcodes.insert(bc);
  for (const auto &bc: allbarcodes){
   auto ref_it = ref_bc.find(bc);
   auto che_it = che_bc.find(bc);
   if (ref_it == ref_bc.end()) {ATH_MSG_WARNING("In Event [" << evtNbr << "]: got null ref-vertex (barcode: " << bc << ")"); continue; }
   if (che_it == che_bc.end()) {ATH_MSG_WARNING("Output GenEvent is missing the selected HardScattering Vtx !!"<< " (" << bc << ")"); continue; }
   const auto refvtx = refMcEvts->barcode_to_vertex(bc);
   const auto chevtx = checkMcEvts->barcode_to_vertex(bc);
   (*m_outFile) << refvtx << std::endl;
   (*m_outFile) << chevtx << std::endl;
   (*m_outFile) << "---------" << std::endl;
   if ( !compareVtx( refvtx, chevtx ) ) {
     ATH_MSG_WARNING("Selected HardScattering vertices are NOT the same !!"<< " at Event [" << evtNbr << "]"<< " refVtx = " << refvtx<<" chevtx = " << chevtx);
   }
  }
  (*m_outFile) << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" << std::endl;
#endif
 
  return StatusCode::SUCCESS;
}

executeTool() [3/3]

StatusCode GenAodValidationTool::executeTool ( const McEventCollection * refMcEvents, const McEventCollection * checkMcEvents )

protectedvirtual

Main method to perform the validation:

• check that each vertex is identical to the original one
• check that missing particles are not there for a good reason

Definition at line 173 of file GenAodValidationTool.cxx.

{
  if ( nullptr == refMcEvents ) {
    ATH_MSG_ERROR("NULL pointer to reference McEventCollection !!");
    return StatusCode::FAILURE;
  }
 
  if ( nullptr == checkMcEvents ) {
    ATH_MSG_ERROR("NULL pointer to the 'to-be-validated' McEventCollection !!");
    return StatusCode::FAILURE;
  }
 
  if ( refMcEvents->size() != checkMcEvents->size() ) {
    ATH_MSG_ERROR("McEventCollections to be compared don't have the same size !"
          << endmsg
          << "Ref:     " << refMcEvents->size() << endmsg
          << "Current: " << checkMcEvents->size());
  }
 
  const unsigned int nMaxEvts = std::min( refMcEvents->size(),
                      checkMcEvents->size() );
  for ( unsigned int iEvt = 0; iEvt != nMaxEvts; ++iEvt ) {
 
    if ( executeTool( (*refMcEvents)[iEvt], 
              (*checkMcEvents)[iEvt] ).isFailure() ) {
      ATH_MSG_WARNING("Could not VALIDATE this event ["
              << (*refMcEvents)[iEvt]->event_number()
              << "] !!");
    }
  }
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode TruthParticleValidationBaseTool::finalize ( )

virtualinherited

Implements ITruthParticleValidationTool.

Definition at line 64 of file TruthParticleValidationBaseTool.cxx.

{
  ATH_MSG_INFO("Finalizing " << name() << "...");
  ATH_MSG_INFO("Analysed [" << m_nAnalysedEvents << "] events.");
 
  // Give the concrete (derived) tool a chance to finalize itself
  if ( finalizeTool().isFailure() ) {
    ATH_MSG_ERROR("Could not finalize concrete tool !");
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

finalizeTool()

StatusCode GenAodValidationTool::finalizeTool ( )

protectedvirtual

Reimplemented from TruthParticleValidationBaseTool.

Definition at line 125 of file GenAodValidationTool.cxx.

{
  ATH_MSG_INFO("Finalizing " << name() << "...");
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode TruthParticleValidationBaseTool::initialize ( )

virtualinherited

Athena Algorithm's Hooks.

Implements ITruthParticleValidationTool.

Definition at line 49 of file TruthParticleValidationBaseTool.cxx.

{
  ATH_MSG_INFO("Initializing " << name() << "...");
 
  // Give the concrete (derived) tool a chance to initialize itself
  if ( initializeTool().isFailure() ) {
    ATH_MSG_ERROR("Could not initialize concrete tool !");
    return StatusCode::FAILURE;
  }
 
  // initializing the event counter
  m_nAnalysedEvents = 0;
  return StatusCode::SUCCESS;
}

initializeTool()

StatusCode GenAodValidationTool::initializeTool ( )

protectedvirtual

Non-const methods:

Reimplemented from TruthParticleValidationBaseTool.

Definition at line 96 of file GenAodValidationTool.cxx.

{
  ATH_MSG_INFO("Initializing " << name() << "...");
 
  if ( m_outFile ) {
    delete m_outFile;
    m_outFile = nullptr;
  }
  m_outFile = new std::ofstream( m_hardVtxOutFileName.value().c_str(),
                 std::ios::trunc );
  if ( !m_outFile || !m_outFile->is_open() || m_outFile->bad() ) {
    ATH_MSG_ERROR("Could not open output Hard-Scattering vertices file at : " 
          << m_hardVtxOutFileName.value());
    if ( m_outFile ) {
      delete m_outFile;
      m_outFile = nullptr;
    }
    return StatusCode::FAILURE;
  }
 
  // retrieve and configure HepMC writer tools
  if ( setupHepMcWriterTools().isFailure() ) {
    ATH_MSG_ERROR("Could not configure the HepMC::GenEvent writer tools !!");
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & ITruthParticleValidationTool::interfaceID ( )

inlinestaticinherited

Inline methods:

Definition at line 65 of file ITruthParticleValidationTool.h.

{ 
   return IID_ITruthParticleValidationTool; 
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setupHepMcWriterTools()

StatusCode GenAodValidationTool::setupHepMcWriterTools ( )

protected

Request pointers to the HepMcWriterTools to be able to write out HepMC::GenEvent for further comparison (off-framework)

Definition at line 452 of file GenAodValidationTool.cxx.

{
  ATH_CHECK( m_refMcEventWriter.retrieve() );
  ATH_CHECK( m_checkMcEventWriter.retrieve() );
 
  // now we configure the tools
  SmartIF<IProperty> prop{m_refMcEventWriter.get()};
  ATH_CHECK( prop.isValid() );
  ATH_CHECK( prop->setProperty("McEvents", m_refMcEventsName.value()) );
 
  prop = m_checkMcEventWriter.get();
  ATH_CHECK( prop.isValid() );
  ATH_CHECK( prop->setProperty("McEvents", m_checkMcEventsName.value()) );
 
  return StatusCode::SUCCESS;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_checkMcEventsName

StringProperty GenAodValidationTool::m_checkMcEventsName

protected

Location of the 'to-be-validated' McEventCollection.

Definition at line 122 of file GenAodValidationTool.h.

m_checkMcEventWriter

HepMcTool_t GenAodValidationTool::m_checkMcEventWriter

protected

Tool to write the 'to-be-checked' HepMC::GenEvent into a dedicated file.

Definition at line 143 of file GenAodValidationTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_hardVtxOutFileName

StringProperty GenAodValidationTool::m_hardVtxOutFileName

protected

Name of the output text file which will contain the hard-scattering vertices.

Default = "hepmc.hard.vtx.txt"

Definition at line 127 of file GenAodValidationTool.h.

m_nAnalysedEvents

unsigned int TruthParticleValidationBaseTool::m_nAnalysedEvents

protectedinherited

Counter of analysed events.

Definition at line 75 of file TruthParticleValidationBaseTool.h.

m_outFile

std::ofstream* GenAodValidationTool::m_outFile

protected

Pointer to the output text file containing hard-scattering vertices.

Definition at line 131 of file GenAodValidationTool.h.

m_refMcEventsName

StringProperty GenAodValidationTool::m_refMcEventsName

protected

Location of the reference McEventCollection.

Definition at line 118 of file GenAodValidationTool.h.

m_refMcEventWriter

HepMcTool_t GenAodValidationTool::m_refMcEventWriter

protected

Tool to write the reference HepMC::GenEvent into a dedicated file.

Definition at line 139 of file GenAodValidationTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• GenAodValidationTool.h
• GenAodValidationTool.cxx