ISF::GenericTruthStrategy Class Reference

A multi-purpose implementation of an ISF TruthStrategy. More...

#include <GenericTruthStrategy.h>

Inheritance diagram for ISF::GenericTruthStrategy:

Collaboration diagram for ISF::GenericTruthStrategy:

Public Member Functions
	GenericTruthStrategy (const std::string &t, const std::string &n, const IInterface *p)
	Constructor with parameters.
	~GenericTruthStrategy ()=default
	Destructor.
virtual StatusCode	initialize () override final
virtual bool	pass (ITruthIncident &incident) const override final
	true if the ITruthStrategy implementation applies to the given ITruthIncident
virtual bool	appliesToRegion (unsigned short geoID) const override final

Private Attributes
bool	m_useParentPt {true}
	parent kinetic energy / transverse momentum cuts (pT is stored as pT^2 which allows for faster comparisons)
double	m_parentPt2 {-1.}
Gaudi::Property< double >	m_parentPt {this, "ParentMinPt", -1.}
	parent particle
Gaudi::Property< double >	m_parentEkin {this, "ParentMinEkin", -1.}
	parent particle
bool	m_useChildPt {true}
	child particle kinetic energy / transverse momentum cuts (pT is stored as pT^2 which allows for faster comparisons)
double	m_childPt2 {-1.}
Gaudi::Property< double >	m_childPt {this, "ChildMinPt", -1.}
	pT momentum cut
Gaudi::Property< double >	m_childEkin {this, "ChildMinEkin", -1.}
	Ekin cut.
Gaudi::Property< bool >	m_allowChildrenOrParentPass {this, "AllowChildrenOrParentPassKineticCuts", false}
	pass cuts if parent did not
Gaudi::Property< VertexTypesVector >	m_vertexTypesVector {this, "VertexTypes", 0}
	vertex type (physics code) checks
VertexTypesSet	m_vertexTypes {}
	optimized for search
bool	m_doVertexRangeCheck {false}
Gaudi::Property< int >	m_vertexTypeRangeLow {this, "VertexTypeRangeLow", 0}
Gaudi::Property< int >	m_vertexTypeRangeHigh {this, "VertexTypeRangeHigh", 0}
unsigned	m_vertexTypeRangeLength {0}
Gaudi::Property< PDGCodesVector >	m_parentPdgCodesVector {this, "ParentPDGCodes", 0}
	PDG code checks.
PDGCodesSet	m_parentPdgCodes {}
	optimized for search
IntegerArrayProperty	m_regionListProperty {this, "Regions", {}}

Detailed Description

A multi-purpose implementation of an ISF TruthStrategy.

Author

Elmar.Ritsch -at- cern.ch

Definition at line 31 of file GenericTruthStrategy.h.

Constructor & Destructor Documentation

GenericTruthStrategy()

ISF::GenericTruthStrategy::GenericTruthStrategy	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Constructor with parameters.

Constructor.

Definition at line 13 of file GenericTruthStrategy.cxx.

                                                                                                         :
  base_class(t,n,p)
{
}

~GenericTruthStrategy()

ISF::GenericTruthStrategy::~GenericTruthStrategy ( )

default

Destructor.

Member Function Documentation

appliesToRegion()

bool ISF::GenericTruthStrategy::appliesToRegion ( unsigned short geoID ) const

finaloverridevirtual

Definition at line 165 of file GenericTruthStrategy.cxx.

{
  return std::find( m_regionListProperty.begin(),
                    m_regionListProperty.end(),
                    geoID ) != m_regionListProperty.end();
}

initialize()

StatusCode ISF::GenericTruthStrategy::initialize ( )

finaloverridevirtual

Definition at line 19 of file GenericTruthStrategy.cxx.

{
    ATH_MSG_VERBOSE("Initializing ...");
 
    // (*) setup parent particle cuts
    // -----
    //     (compute and store the squared cut parameters (faster comparisons))
    // check whether the user input makes sense (error case)
    if ( (m_parentPt>=0.) && (m_parentEkin>=0.) ) {
      ATH_MSG_ERROR("Both, pT and Ekin cuts are given for parent particles. Unclear which one to use! ABORT!");
      return StatusCode::FAILURE;
    }
    // neither pT nor Energy cuts were given (never being used so far)
    //   -> enable pT cut and set it to 0.
    else if ( (m_parentPt<0.) && (m_parentEkin<0.) ) {
      // we don't use a flag to disable energy/momentum checks, because
      // all relevant truth strategies up to now do use such cuts
      m_useParentPt = true;
      m_parentPt2 = 0.;
      m_parentEkin = 0.;  // would not be needed actually
    }
    // either pT or Ekin cut is given (standard case)
    else {
      // enable pT cut if value given (greater than 0.):
      m_useParentPt  = !(m_parentPt<0.);
      m_parentPt2 = m_parentPt * m_parentPt;
    }
 
    // (*) setup child particle cuts
    // -----
    //     (compute and store the squared cut parameters (faster comparisons))
    // check whether the user input makes sense (error case)
    if ( (m_childPt>=0.) && (m_childEkin>=0.) ) {
      ATH_MSG_ERROR("Both, pT and Ekin cuts are given for child particles. Unclear which one to use! ABORT!");
      return StatusCode::FAILURE;
    }
    // neither pT nor Energy cuts were given (never being used so far)
    //   -> enable pT cut and set it to 0.
    else if ( (m_childPt<0.) && (m_childEkin<0.) ) {
      // we don't use a flag to disable energy/momentum checks, because
      // all relevant truth strategies up to now do use such cuts
      m_useChildPt = true;
      m_childPt2 = 0.;
      m_childEkin = 0.;  // would not be needed actually
    }
    // either pT or Ekin cut is given (standard case)
    else {
      // enable pT cut if value given (greater than 0.):
      m_useChildPt = !(m_childPt<0.);
      m_childPt2 = m_childPt * m_childPt;
    }
 
    // VertexTypeRanges:
    //
    // check whether user input makes sense:
    if ( m_vertexTypeRangeHigh < m_vertexTypeRangeLow) {
      ATH_MSG_ERROR("The given parameter VertexTypeRangeLow is bigger than VertexTypeRangeHigh. ABORT");
      return StatusCode::FAILURE;
    }
    // the length of the given vertex type range
    m_vertexTypeRangeLength = unsigned(m_vertexTypeRangeHigh - m_vertexTypeRangeLow) + 1;
    // if neither lower now upper range limit given, disable range check
    m_doVertexRangeCheck    = m_vertexTypeRangeLow && m_vertexTypeRangeHigh;
 
 
    // fill PDG code std::set used for optimized search
    m_parentPdgCodes.insert( m_parentPdgCodesVector.begin(), m_parentPdgCodesVector.end());
 
    // fill vertex type std::set used for optimized search
    m_vertexTypes.insert( m_vertexTypesVector.begin(), m_vertexTypesVector.end());
 
    for(auto region : m_regionListProperty.value()) {
      if(region < AtlasDetDescr::fFirstAtlasRegion || region >= AtlasDetDescr::fNumAtlasRegions) {
        ATH_MSG_ERROR("Unknown Region (" << region << ") specified. Please check your configuration.");
        return StatusCode::FAILURE;
      }
    }
    return StatusCode::SUCCESS;
}

pass()

bool ISF::GenericTruthStrategy::pass ( ITruthIncident & incident ) const

finaloverridevirtual

true if the ITruthStrategy implementation applies to the given ITruthIncident

Definition at line 99 of file GenericTruthStrategy.cxx.

                                                            {
 
  // (1.) momentum/energy check
  // ----
  //
  {
    // check whether parent particle passes cut or not
    bool primFail = (m_useParentPt) ? (ti.parentPt2()<m_parentPt2)
      : (ti.parentEkin()<m_parentEkin) ;
 
 
    // if parent particle failed and strategy does not
    // allow for child-only pass -> failed
    if ( ( primFail && (!m_allowChildrenOrParentPass) ) ) {
      return false;
    }
 
    // check child particles
    bool secPass =  m_useChildPt ? ti.childrenPt2Pass(m_childPt2)
                                 : ti.childrenEkinPass(m_childEkin);
 
    // if child particles do not pass cuts
    if (!secPass) {
      if (!m_allowChildrenOrParentPass) {
        // child particles were required to pass cuts but did not
        return false;
      } else if (primFail) {
        // neither parent nor child particles passed cuts
        return false;
      }
    }
 
  }
 
 
  // (2.) parent particle PDG code check
  // ----
  // check whether parent PDG code matches with any of the given ones
  if (  m_parentPdgCodes.size() &&
       (m_parentPdgCodes.find(ti.parentPdgCode()) == m_parentPdgCodes.end()) ) {
 
    // parent particle PDG code not found
    return false;
  }
 
 
  // (3.) vertex type check
  // ----
  if ( m_doVertexRangeCheck || m_vertexTypes.size()) {
    int vxtype = ti.physicsProcessCode();
 
    // (3.1) vxtype in given range?: this is a small performance trick (only one comparison operator to check if within range)
    //  -> exactly equivalent to:  m_doVertexRangeCheck  && (m_vertexTypeLow<=vxtype) && (vxtype<=m_vertexTypeRangeHigh)
    bool vtxTypeRangePassed = m_doVertexRangeCheck && ( unsigned(vxtype-m_vertexTypeRangeLow) < m_vertexTypeRangeLength );
    // (3.2) if not in range or range check disabled, check whether vxtype
    //       std::set contains the given vertex type
    if ( (!vtxTypeRangePassed) && (m_vertexTypes.find(vxtype)==m_vertexTypes.end()) ) {
        // vxtype not registered -> not passed
        return false;
    }
  }
 
  // all cuts passed
  return true;
}

Member Data Documentation

m_allowChildrenOrParentPass

Gaudi::Property<bool> ISF::GenericTruthStrategy::m_allowChildrenOrParentPass {this, "AllowChildrenOrParentPassKineticCuts", false}

private

pass cuts if parent did not

Definition at line 65 of file GenericTruthStrategy.h.

{this, "AllowChildrenOrParentPassKineticCuts", false}; 

m_childEkin

Gaudi::Property<double> ISF::GenericTruthStrategy::m_childEkin {this, "ChildMinEkin", -1.}

private

Ekin cut.

Definition at line 64 of file GenericTruthStrategy.h.

{this, "ChildMinEkin", -1.};           

m_childPt

Gaudi::Property<double> ISF::GenericTruthStrategy::m_childPt {this, "ChildMinPt", -1.}

private

pT momentum cut

Definition at line 63 of file GenericTruthStrategy.h.

{this, "ChildMinPt", -1.};            

m_childPt2

double ISF::GenericTruthStrategy::m_childPt2 {-1.}

private

Definition at line 62 of file GenericTruthStrategy.h.

{-1.};

m_doVertexRangeCheck

bool ISF::GenericTruthStrategy::m_doVertexRangeCheck {false}

private

Definition at line 72 of file GenericTruthStrategy.h.

{false};

m_parentEkin

Gaudi::Property<double> ISF::GenericTruthStrategy::m_parentEkin {this, "ParentMinEkin", -1.}

private

parent particle

Definition at line 57 of file GenericTruthStrategy.h.

{this, "ParentMinEkin", -1.};          

m_parentPdgCodes

PDGCodesSet ISF::GenericTruthStrategy::m_parentPdgCodes {}

private

optimized for search

Definition at line 79 of file GenericTruthStrategy.h.

{};        

m_parentPdgCodesVector

Gaudi::Property<PDGCodesVector> ISF::GenericTruthStrategy::m_parentPdgCodesVector {this, "ParentPDGCodes", 0}

private

PDG code checks.

Python property

Definition at line 78 of file GenericTruthStrategy.h.

{this, "ParentPDGCodes", 0};  

m_parentPt

Gaudi::Property<double> ISF::GenericTruthStrategy::m_parentPt {this, "ParentMinPt", -1.}

private

parent particle

Definition at line 56 of file GenericTruthStrategy.h.

{this, "ParentMinPt", -1.};           

m_parentPt2

double ISF::GenericTruthStrategy::m_parentPt2 {-1.}

private

Definition at line 55 of file GenericTruthStrategy.h.

{-1.};

m_regionListProperty

IntegerArrayProperty ISF::GenericTruthStrategy::m_regionListProperty {this, "Regions", {}}

private

Definition at line 81 of file GenericTruthStrategy.h.

{this, "Regions", {}};

m_useChildPt

bool ISF::GenericTruthStrategy::m_useChildPt {true}

private

child particle kinetic energy / transverse momentum cuts (pT is stored as pT^2 which allows for faster comparisons)

use pT or Ekin cuts?

Definition at line 61 of file GenericTruthStrategy.h.

{true};          

m_useParentPt

bool ISF::GenericTruthStrategy::m_useParentPt {true}

private

parent kinetic energy / transverse momentum cuts (pT is stored as pT^2 which allows for faster comparisons)

use pT or Ekin cuts?

Definition at line 54 of file GenericTruthStrategy.h.

{true};         

m_vertexTypeRangeHigh

Gaudi::Property<int> ISF::GenericTruthStrategy::m_vertexTypeRangeHigh {this, "VertexTypeRangeHigh", 0}

private

Definition at line 74 of file GenericTruthStrategy.h.

{this, "VertexTypeRangeHigh", 0};

m_vertexTypeRangeLength

unsigned ISF::GenericTruthStrategy::m_vertexTypeRangeLength {0}

private

Definition at line 75 of file GenericTruthStrategy.h.

{0};

m_vertexTypeRangeLow

Gaudi::Property<int> ISF::GenericTruthStrategy::m_vertexTypeRangeLow {this, "VertexTypeRangeLow", 0}

private

Definition at line 73 of file GenericTruthStrategy.h.

{this, "VertexTypeRangeLow", 0};

m_vertexTypes

VertexTypesSet ISF::GenericTruthStrategy::m_vertexTypes {}

private

optimized for search

Definition at line 71 of file GenericTruthStrategy.h.

{};        

m_vertexTypesVector

Gaudi::Property<VertexTypesVector> ISF::GenericTruthStrategy::m_vertexTypesVector {this, "VertexTypes", 0}

private

vertex type (physics code) checks

Python property

Definition at line 70 of file GenericTruthStrategy.h.

{this, "VertexTypes", 0};  

---

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

• GenericTruthStrategy.h
• GenericTruthStrategy.cxx