IsolationBuilder Class Reference

#include <IsolationBuilder.h>

Inheritance diagram for IsolationBuilder:

Collaboration diagram for IsolationBuilder:

Classes
struct	CaloIsoHelpHandles
struct	CaloIsoHelpKey
struct	TrackIsoHelpHandles
struct	TrackIsoHelpKey

Public Member Functions
	IsolationBuilder (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters:
virtual	~IsolationBuilder ()
	Destructor:
virtual StatusCode	initialize () override final
virtual StatusCode	execute (const EventContext &ctx) const override final
virtual StatusCode	finalize () override final
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
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	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

Protected Member Functions
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
	IsolationBuilder ()
	Default constructor:
StatusCode	initializeIso (std::set< xAOD::Iso::IsolationFlavour > &runIsoType, std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > > *caloIsoMap, std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey > > *trackIsoMap, const std::string &containerName, const std::vector< std::vector< int > > &isoInts, const std::vector< std::vector< int > > &corInts, const std::vector< std::vector< int > > &corIntsExtra, const std::string &customConfig)
	called by algorithm initialize per object (electron, photon, forward electron, muon)
StatusCode	addCaloIsoCorrections (size_t flavor, xAOD::Iso::IsolationFlavour isoFlav, CaloIsoHelpKey &cisoH, const std::vector< std::vector< int > > &corInts, bool corrsAreExtra, const std::string &prefix, const std::string &customConfig)
	called by initializeIso
StatusCode	addTrackIsoCorrections (size_t flavor, xAOD::Iso::IsolationFlavour isoFlav, TrackIsoHelpKey &tisoH, const std::vector< std::vector< int > > &corInts, bool corrsAreExtra, const std::string &prefix, const std::string &customConfig)
	called by initializeIso
StatusCode	executeCaloIso (const std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > > &caloIsoMap, const CaloCellContainer *cellColl) const
StatusCode	executeTrackIso (const std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey > > &trackIsoMap) const
void	declareIso (std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > > &caloIso)
void	declareIso (std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey > > &trackIso)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static bool	isCoreCor (xAOD::Iso::IsolationCaloCorrection corr)

Private Attributes
Gaudi::Property< std::string >	m_ElectronContainerName
	Containers (Is it best to make them as strings? Used by multiple handles)
Gaudi::Property< std::string >	m_FwdElectronContainerName
Gaudi::Property< std::string >	m_PhotonContainerName
Gaudi::Property< std::string >	m_MuonContainerName
ToolHandle< xAOD::ICaloCellIsolationTool >	m_cellIsolationTool
	Tool for cell isolation calculation.
SG::ReadHandleKey< CaloCellContainer >	m_cellsKey
	Cell container.
ToolHandle< xAOD::ICaloTopoClusterIsolationTool >	m_topoIsolationTool
	Tool for topo isolation calculation.
ToolHandle< xAOD::INeutralEFlowIsolationTool >	m_pflowIsolationTool
	Tool for neutral pflow isolation calculation.
ToolHandle< xAOD::ITrackIsolationTool >	m_trackIsolationTool
	Tool for neutral pflow isolation calculation.
Gaudi::Property< bool >	m_isTrigger { this, "IsTrigger", false }
	is the alg run at trigger level
Gaudi::Property< bool >	m_useBremAssoc
Gaudi::Property< bool >	m_allTrackRemoval { this, "AllTrackRemoval", true }
Gaudi::Property< bool >	m_storepileupCorrection { this, "storepileupCorrection", false }
Gaudi::Property< std::vector< std::vector< int > > >	m_elisoInts
	Isolation types.
Gaudi::Property< std::vector< std::vector< int > > >	m_elcorInts
Gaudi::Property< std::vector< std::vector< int > > >	m_elcorIntsExtra
Gaudi::Property< std::vector< std::vector< int > > >	m_phisoInts
	Isolation types (for the alg.
Gaudi::Property< std::vector< std::vector< int > > >	m_phcorInts
Gaudi::Property< std::vector< std::vector< int > > >	m_phcorIntsExtra
Gaudi::Property< std::vector< std::vector< int > > >	m_muisoInts
Gaudi::Property< std::vector< std::vector< int > > >	m_mucorInts
Gaudi::Property< std::vector< std::vector< int > > >	m_mucorIntsExtra
Gaudi::Property< std::vector< std::vector< int > > >	m_feisoInts
Gaudi::Property< std::vector< std::vector< int > > >	m_fecorInts
Gaudi::Property< std::vector< std::vector< int > > >	m_fecorIntsExtra
std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > >	m_elCaloIso
std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > >	m_phCaloIso
std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > >	m_feCaloIso
std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > >	m_muCaloIso
std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey > >	m_elTrackIso
std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey > >	m_phTrackIso
std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey > >	m_muTrackIso
Gaudi::Property< std::string >	m_customConfigEl
Gaudi::Property< std::string >	m_customConfigPh
Gaudi::Property< std::string >	m_customConfigFwd
Gaudi::Property< std::string >	m_customConfigMu
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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 44 of file IsolationBuilder.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

IsolationBuilder() [1/2]

IsolationBuilder::IsolationBuilder	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Constructor with parameters:

Definition at line 18 of file IsolationBuilder.cxx.

  : ::AthReentrantAlgorithm(name, pSvcLocator)
{}

~IsolationBuilder()

IsolationBuilder::~IsolationBuilder ( )

virtualdefault

Destructor:

IsolationBuilder() [2/2]

IsolationBuilder::IsolationBuilder ( )

private

Default constructor:

Member Function Documentation

addCaloIsoCorrections()

StatusCode IsolationBuilder::addCaloIsoCorrections ( size_t flavor, xAOD::Iso::IsolationFlavour isoFlav, CaloIsoHelpKey & cisoH, const std::vector< std::vector< int > > & corInts, bool corrsAreExtra, const std::string & prefix, const std::string & customConfig )

private

called by initializeIso

Definition at line 401 of file IsolationBuilder.cxx.

{
 
  if (!corrsAreExtra) {
    std::string bitsetName =
      prefix + xAOD::Iso::toString(isoFlav) + "CorrBitset";
    if (!customConfig.empty()) {
      bitsetName += "_" + customConfig;
    }
 
    cisoH.corrBitsetDeco = bitsetName;
    ATH_MSG_DEBUG("Initializing non extra corr : " << cisoH.corrBitsetDeco.key());
    ATH_CHECK(cisoH.corrBitsetDeco.initialize());
  }
 
  for (size_t corrType = 0; corrType < corInts[flavor].size(); corrType++) {
    // iterate over the calo isolation corrections
    const auto cor = static_cast<unsigned int>(corInts[flavor][corrType]);
    if (!corrsAreExtra)
      cisoH.CorrList.calobitset.set(cor);
    const xAOD::Iso::IsolationCaloCorrection isoCor =
      static_cast<xAOD::Iso::IsolationCaloCorrection>(cor);
 
    if (isCoreCor(isoCor)) {
      std::string isoCorName = prefix;
      if (isoCor != xAOD::Iso::core57cells) {
        isoCorName += xAOD::Iso::toString(isoFlav); // since this doesn't depend on the flavor, just have one
      }
 
      // a core correction; only store core energy, not the core area
      isoCorName += xAOD::Iso::toString(isoCor) +
                    xAOD::Iso::toString(xAOD::Iso::coreEnergy) + "Correction";
      if (!customConfig.empty()) {
        isoCorName += "_" + customConfig;
      }
      cisoH.coreCorDeco.emplace(isoCor, isoCorName);
      cisoH.coreCorDeco[isoCor].setOwner(this);
      ATH_MSG_DEBUG("initializing " << cisoH.coreCorDeco[isoCor].key());
      ATH_CHECK(cisoH.coreCorDeco[isoCor].initialize());
    } else {
      // noncore correction
      if (isoCor == xAOD::Iso::pileupCorrection && !m_storepileupCorrection)
    continue;
      cisoH.noncoreCorDeco.emplace(
        isoCor, SG::WriteDecorHandleKeyArray<xAOD::IParticleContainer>());
      auto& vec = cisoH.noncoreCorDeco[isoCor];
      vec.setOwner(this);
      for (auto type : cisoH.isoTypes) {
        std::string corName = prefix + xAOD::Iso::toString(type) +
                              xAOD::Iso::toString(isoCor) + "Correction";
        if (!customConfig.empty()) {
          corName += "_" + customConfig;
        }
        vec.emplace_back(corName);
      }
      ATH_MSG_DEBUG("Initializing " << xAOD::Iso::toString(isoCor)
                                    << " Corrections");
      ATH_CHECK(vec.initialize());
    }
  }
  return StatusCode::SUCCESS;
}

addTrackIsoCorrections()

StatusCode IsolationBuilder::addTrackIsoCorrections ( size_t flavor, xAOD::Iso::IsolationFlavour isoFlav, TrackIsoHelpKey & tisoH, const std::vector< std::vector< int > > & corInts, bool corrsAreExtra, const std::string & prefix, const std::string & customConfig )

private

called by initializeIso

Definition at line 472 of file IsolationBuilder.cxx.

{
 
  if (!corrsAreExtra) {
    std::string bitsetName =
      prefix + xAOD::Iso::toString(isoFlav) + "CorrBitset";
    if (!customConfig.empty()) {
      bitsetName += "_" + customConfig;
    }
 
    tisoH.corrBitsetDeco = bitsetName;
    ATH_MSG_DEBUG("Initializing " << tisoH.corrBitsetDeco.key());
    ATH_CHECK(tisoH.corrBitsetDeco.initialize());
  }
 
  for (size_t corrType = 0; corrType < corInts[flavor].size(); corrType++) {
    const auto cor = static_cast<unsigned int>(corInts[flavor][corrType]);
    if (!corrsAreExtra)
      tisoH.CorrList.trackbitset.set(cor);
    const xAOD::Iso::IsolationTrackCorrection isoCor =
      static_cast<xAOD::Iso::IsolationTrackCorrection>(cor);
 
    // all pt corrections are core type
    std::string isoCorName = prefix + xAOD::Iso::toString(isoFlav) +
                             xAOD::Iso::toString(isoCor) + "Correction";
 
    if (!customConfig.empty()) {
      isoCorName += "_" + customConfig;
    }
    tisoH.coreCorDeco.emplace(isoCor, isoCorName);
    tisoH.coreCorDeco[isoCor].setOwner(this);
    ATH_MSG_DEBUG("initializing " << tisoH.coreCorDeco[isoCor].key());
    ATH_CHECK(tisoH.coreCorDeco[isoCor].initialize());
  }
  return StatusCode::SUCCESS;
}

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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());
 
  }

declareIso() [1/2]

void IsolationBuilder::declareIso ( std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > > & caloIso )

private

Definition at line 756 of file IsolationBuilder.cxx.

{
  for (auto& iso : caloIso) {
    iso.second.declare(this);
  }
}

declareIso() [2/2]

void IsolationBuilder::declareIso ( std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey > > & trackIso )

private

Definition at line 765 of file IsolationBuilder.cxx.

{
  for (auto& iso : trackIso) {
    iso.second.declare(this);
  }
}

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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 IsolationBuilder::execute ( const EventContext & ctx ) const

finaloverridevirtual

Definition at line 132 of file IsolationBuilder.cxx.

{
  ATH_MSG_DEBUG("Executing " << name() << "...");
 
  // For etcone, needs the cells
 
  const CaloCellContainer* cellColl = nullptr;
  if (!m_cellIsolationTool.empty()) {
    SG::ReadHandle<CaloCellContainer> cellcoll(m_cellsKey, ctx);
    // check is only used for serial running; remove when MT scheduler used
    if (!cellcoll.isValid()) {
      ATH_MSG_FATAL("Failed to retrieve cell container: " << m_cellsKey.key());
      return StatusCode::FAILURE;
    }
    cellColl = cellcoll.cptr();
  }
  // Compute isolations
 
  if (m_elCaloIso.size()) {
    ATH_MSG_DEBUG("About to execute Electron calo iso");
    ATH_CHECK(executeCaloIso(m_elCaloIso, cellColl));
  }
  if (m_phCaloIso.size()) {
    ATH_MSG_DEBUG("About to execute Photon calo iso");
    ATH_CHECK(executeCaloIso(m_phCaloIso, cellColl));
  }
  if (m_feCaloIso.size()) {
    ATH_MSG_DEBUG("About to execute Forward Electron calo iso");
    ATH_CHECK(executeCaloIso(m_feCaloIso, cellColl));
  }
  if (m_muCaloIso.size()) {
    ATH_MSG_DEBUG("About to execute muon calo iso");
    ATH_CHECK(executeCaloIso(m_muCaloIso, cellColl));
  }
 
  if (m_elTrackIso.size()) {
    ATH_MSG_DEBUG("About to execute Electron track iso");
    ATH_CHECK(executeTrackIso(m_elTrackIso));
  }
  if (m_phTrackIso.size()) {
    ATH_MSG_DEBUG("About to execute Photon track iso");
    ATH_CHECK(executeTrackIso(m_phTrackIso));
  }
  if (m_muTrackIso.size()) {
    ATH_MSG_DEBUG("About to execute Muon track iso");
    ATH_CHECK(executeTrackIso(m_muTrackIso));
  }
 
  return StatusCode::SUCCESS;
}

executeCaloIso()

StatusCode IsolationBuilder::executeCaloIso ( const std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > > & caloIsoMap, const CaloCellContainer * cellColl ) const

private

Definition at line 517 of file IsolationBuilder.cxx.

{
  for (const auto& pr : caloIsoMap) {
 
    const xAOD::Iso::IsolationFlavour flav = pr.first;
    const auto& keys = pr.second;
    CaloIsoHelpHandles handles(keys);
 
    ATH_MSG_DEBUG("Executing calo iso flavor: " << xAOD::Iso::toString(flav));
 
    if (handles.isoDeco.empty()) {
      ATH_MSG_FATAL("Have a CaloIsoHelpHandles with no actual isolations; "
                    "something wrong happened");
      return StatusCode::FAILURE;
    }
    auto& readHandle =
      handles.isoDeco[0]; // can treat the writeDecorHandle as a read handle;
    
    if (readHandle.isAvailable()){ // This must be before readHandle.isValid() or else the isValid call
                                   // will crash if the deocration already exists
      ATH_MSG_DEBUG("read (actually a write) handle for " << keys.isoDeco[0].key() << " already exists.  "
                    << "Will not recompute." );
      return StatusCode::SUCCESS;
    }
 
    if (!readHandle.isValid()) {
      ATH_MSG_FATAL("Could not retrieve read handle for "
                    << keys.isoDeco[0].key());
      return StatusCode::FAILURE;
    }
 
    for (const auto *part : *readHandle) {
      xAOD::CaloIsolation CaloIsoResult;
      bool successfulCalc = false;
      if (flav == xAOD::Iso::IsolationFlavour::etcone && cellColl) {
        successfulCalc = m_cellIsolationTool->caloCellIsolation(
          CaloIsoResult, *part, keys.isoTypes, keys.CorrList, cellColl);
      } else if (flav == xAOD::Iso::IsolationFlavour::topoetcone) {
        successfulCalc = m_topoIsolationTool->caloTopoClusterIsolation(
          CaloIsoResult, *part, keys.isoTypes, keys.CorrList);
      } else if (flav == xAOD::Iso::IsolationFlavour::neflowisol) {
        successfulCalc = m_pflowIsolationTool->neutralEflowIsolation(
          CaloIsoResult, *part, keys.isoTypes, keys.CorrList);
      }
 
      if (successfulCalc) {
        for (unsigned int i = 0; i < keys.isoTypes.size(); i++) {
          float iso = CaloIsoResult.etcones[i];
          ATH_MSG_DEBUG("custom Iso " << xAOD::Iso::toCString(keys.isoTypes[i])
                                      << " = " << iso / 1e3);
          (handles.isoDeco[i])(*part) = iso;
        }
        // corrections
        (handles.corrBitsetDeco)(*part) = keys.CorrList.calobitset.to_ulong();
 
        // let's do the core corrections
 
        // iterate over the values we want to store
        for (auto& coreCorDecoPr : handles.coreCorDeco) {
          // find the matching result
          auto corIter =
            CaloIsoResult.coreCorrections.find(coreCorDecoPr.first);
          if (corIter == CaloIsoResult.coreCorrections.end()) {
            ATH_MSG_FATAL("Could not find core correction of required type: "
                          << xAOD::Iso::toCString(coreCorDecoPr.first));
            ATH_MSG_FATAL("Check configuration");
            return StatusCode::FAILURE;
          }
          // now that we have the match, let's find the energy
          std::map<xAOD::Iso::IsolationCorrectionParameter,
                   float>::const_iterator it =
            corIter->second.find(xAOD::Iso::coreEnergy);
          if (it == corIter->second.end()) {
            ATH_MSG_FATAL("Could not find coreEnergy correction for: "
                          << xAOD::Iso::toCString(coreCorDecoPr.first));
            ATH_MSG_FATAL("Check configuration");
            return StatusCode::FAILURE;
          }
          ATH_MSG_DEBUG("About to write core correction: "
                        << xAOD::Iso::toCString(coreCorDecoPr.first));
          (coreCorDecoPr.second)(*part) = it->second;
        }
 
        // let's do the noncore corrections
        for (auto& noncoreCorDecoPr : handles.noncoreCorDeco) {
          // find the matching result
          auto corIter =
            CaloIsoResult.noncoreCorrections.find(noncoreCorDecoPr.first);
          if (corIter == CaloIsoResult.noncoreCorrections.end()) {
            ATH_MSG_FATAL("Could not find noncore correction of required type: "
                          << xAOD::Iso::toCString(noncoreCorDecoPr.first));
            ATH_MSG_FATAL("Check configuration");
            return StatusCode::FAILURE;
          }
 
          ATH_MSG_DEBUG("About to write noncore correction: "
                        << xAOD::Iso::toCString(noncoreCorDecoPr.first));
          auto& vecHandles = noncoreCorDecoPr.second;
          for (size_t i = 0; i < vecHandles.size(); i++) {
            (vecHandles[i])(*part) = corIter->second[i];
          }
        }
      } else {
        ATH_MSG_FATAL("Call to CaloIsolationTool failed for flavor "
                      << xAOD::Iso::toCString(flav));
        return StatusCode::FAILURE;
      }
    }
  }
  return StatusCode::SUCCESS;
}

executeTrackIso()

StatusCode IsolationBuilder::executeTrackIso ( const std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey > > & trackIsoMap ) const

private

Definition at line 633 of file IsolationBuilder.cxx.

{
  for (const auto& pr : trackIsoMap) {
    const xAOD::Iso::IsolationFlavour flav = pr.first;
    const auto& keys = pr.second;
    TrackIsoHelpHandles handles(keys);
 
    ATH_MSG_DEBUG("Executing track iso flavor: " << xAOD::Iso::toString(flav));
 
    if (handles.isoDeco.empty()) {
      ATH_MSG_FATAL("Have a TrackIsoHelpHandles with no actual isolations; "
                    "something wrong happened");
      return StatusCode::FAILURE;
    }
    auto& readHandle =
      handles.isoDeco[0]; // can treat the writeDecorHandle as a read handle;
 
    if (readHandle.isAvailable()){ // This must be before readHandle.isValid() or else the isValid call
                                   // will crash if the deocration already exists
      ATH_MSG_DEBUG("Decoration for for " << keys.isoDeco[0].key() << " already exists.  "
                    << "Will not recompute." );
      return StatusCode::SUCCESS;
    }
 
    if (!readHandle.isValid()) {
      ATH_MSG_FATAL("Could not retrieve read handle for "
                    << keys.isoDeco[0].key());
      return StatusCode::FAILURE;
    }
 
    for (const auto *part : *readHandle) {
      xAOD::TrackIsolation TrackIsoResult;
      bool successfulCalc = false;
      // check to see if we are dealing with an electron
      const auto * eg = dynamic_cast<const xAOD::Egamma*>(part);
      if (eg) {
        ATH_MSG_DEBUG("Doing track isolation on an egamma particle");
    std::unique_ptr<xAOD::Vertex> trigVtx = nullptr;
        std::set<const xAOD::TrackParticle*> tracksToExclude;
        if (xAOD::EgammaHelpers::isElectron(eg)) {
          tracksToExclude =
            xAOD::EgammaHelpers::getTrackParticles(eg, m_useBremAssoc);
      if (m_isTrigger) {
        const xAOD::Electron* el = static_cast<const xAOD::Electron*>(part);
        trigVtx = std::make_unique<xAOD::Vertex>();
        trigVtx->makePrivateStore();
        trigVtx->setZ(el->trackParticle()->z0() + el->trackParticle()->vz());
        ATH_MSG_DEBUG("will use a vertex at z = " << trigVtx->z() << " to compute electron track isolation");
      }
        } else {
          if (m_allTrackRemoval) { // New (from ??/??/16) : now this gives all
                                   // tracks
            tracksToExclude =
              xAOD::EgammaHelpers::getTrackParticles(eg, m_useBremAssoc);
          } else { // this is just to be able to have the 2015+2016 default case
                   // (only tracks from first vertex)
            const auto * gam = dynamic_cast<const xAOD::Photon*>(eg);
            if (gam && gam->nVertices() > 0) {
              const xAOD::Vertex* phvtx = gam->vertex(0);
              for (unsigned int itk = 0; itk < phvtx->nTrackParticles(); itk++)
                tracksToExclude.insert(
                  m_useBremAssoc
                    ? xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(
                        phvtx->trackParticle(itk))
                    : phvtx->trackParticle(itk));
            }
          }
        }
        successfulCalc = m_trackIsolationTool->trackIsolation(TrackIsoResult,
                                                              *part,
                                                              keys.isoTypes,
                                                              keys.CorrList,
                                                              trigVtx.get(),
                                                              &tracksToExclude);
      } else {
        ATH_MSG_DEBUG("Not doing track isolation on an egamma particle");
        successfulCalc = m_trackIsolationTool->trackIsolation(
          TrackIsoResult, *part, keys.isoTypes, keys.CorrList);
      }
 
      if (successfulCalc) {
        for (unsigned int i = 0; i < keys.isoTypes.size(); i++) {
          float iso = TrackIsoResult.ptcones[i];
          float isoV = TrackIsoResult.ptvarcones_10GeVDivPt[i];
          ATH_MSG_DEBUG("custom Iso " << xAOD::Iso::toCString(keys.isoTypes[i])
                                      << " = " << iso / 1e3
                                      << ", var cone = " << isoV / 1e3);
          (handles.isoDeco[i])(*part) = iso;
          (handles.isoDecoV[i])(*part) = isoV;
        }
 
        // corrections
        (handles.corrBitsetDeco)(*part) = keys.CorrList.trackbitset.to_ulong();
        // let's do the core corrections
        // iterate over the values we want to store
        for (auto& coreCorDecoPr : handles.coreCorDeco) {
          // find the matching result
          auto corIter =
            TrackIsoResult.coreCorrections.find(coreCorDecoPr.first);
          if (corIter == TrackIsoResult.coreCorrections.end()) {
            ATH_MSG_FATAL("Could not find core correction of required type: "
                          << xAOD::Iso::toCString(coreCorDecoPr.first));
            ATH_MSG_FATAL("Check configuration");
            return StatusCode::FAILURE;
          }
          ATH_MSG_DEBUG("About to write tracking core correction: "
                        << xAOD::Iso::toCString(coreCorDecoPr.first));
          (coreCorDecoPr.second)(*part) = corIter->second;
        }
 
      } else {
        ATH_MSG_FATAL("Call to TrackIsolationTool failed for flavor "
                      << xAOD::Iso::toCString(flav));
        return StatusCode::FAILURE;
      }
    }
  }
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode IsolationBuilder::finalize ( )

finaloverridevirtual

Definition at line 124 of file IsolationBuilder.cxx.

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

initialize()

StatusCode IsolationBuilder::initialize ( )

finaloverridevirtual

Definition at line 26 of file IsolationBuilder.cxx.

{
  ATH_MSG_INFO("Initializing " << name() << "...");
 
  std::set<xAOD::Iso::IsolationFlavour> runIsoType;
 
  if (m_elisoInts.size()) {
    ATH_MSG_DEBUG("Initializing central electrons");
    ATH_CHECK(initializeIso(runIsoType,
                &m_elCaloIso,
                &m_elTrackIso,
                m_ElectronContainerName,
                m_elisoInts,
                m_elcorInts,
                m_elcorIntsExtra,
                m_customConfigEl));
    declareIso(m_elCaloIso);
    declareIso(m_elTrackIso);
  }
 
  if (m_phisoInts.size()) {
    ATH_MSG_DEBUG("Initializing central photons");
    ATH_CHECK(initializeIso(runIsoType,
                &m_phCaloIso,
                &m_phTrackIso,
                m_PhotonContainerName,
                m_phisoInts,
                m_phcorInts,
                m_phcorIntsExtra,
                m_customConfigPh));
    declareIso(m_phCaloIso);
    declareIso(m_phTrackIso);
  }
 
  if (m_feisoInts.size()) {
    ATH_MSG_DEBUG("Initializing forward electrons");
    ATH_CHECK(initializeIso(runIsoType,
                &m_feCaloIso,
                nullptr,
                m_FwdElectronContainerName,
                m_feisoInts,
                m_fecorInts,
                m_fecorIntsExtra,
                m_customConfigFwd));
    declareIso(m_feCaloIso);
  }
 
  if (m_muisoInts.size()) {
    ATH_MSG_DEBUG("Initializing muons");
    ATH_CHECK(initializeIso(runIsoType,
                &m_muCaloIso,
                &m_muTrackIso,
                m_MuonContainerName,
                m_muisoInts,
                m_mucorInts,
                m_mucorIntsExtra,
                m_customConfigMu));
    declareIso(m_muCaloIso);
    declareIso(m_muTrackIso);
  }
 
  // Retrieve the tools (there three Calo ones are the same in fact)
  if (!m_cellIsolationTool.empty() &&
      runIsoType.find(xAOD::Iso::etcone) != runIsoType.end()) {
    ATH_CHECK(m_cellIsolationTool.retrieve());
  } else {
    m_cellIsolationTool.disable();
  }
 
  if (!m_topoIsolationTool.empty() &&
      runIsoType.find(xAOD::Iso::topoetcone) != runIsoType.end()) {
    ATH_CHECK(m_topoIsolationTool.retrieve());
  } else {
    m_topoIsolationTool.disable();
  }
 
  if (!m_pflowIsolationTool.empty() &&
      runIsoType.find(xAOD::Iso::neflowisol) != runIsoType.end()) {
    ATH_CHECK(m_pflowIsolationTool.retrieve());
  } else {
    m_pflowIsolationTool.disable();
  }
 
  if (!m_trackIsolationTool.empty() &&
      runIsoType.find(xAOD::Iso::IsolationFlavour::ptcone) !=
        runIsoType.end()) {
    ATH_CHECK(m_trackIsolationTool.retrieve());
  } else {
    m_trackIsolationTool.disable();
  }
 
  // initialise data handles
  ATH_CHECK(m_cellsKey.initialize(!m_cellIsolationTool.empty()));
 
  return StatusCode::SUCCESS;
}

initializeIso()

StatusCode IsolationBuilder::initializeIso ( std::set< xAOD::Iso::IsolationFlavour > & runIsoType, std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > > * caloIsoMap, std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey > > * trackIsoMap, const std::string & containerName, const std::vector< std::vector< int > > & isoInts, const std::vector< std::vector< int > > & corInts, const std::vector< std::vector< int > > & corIntsExtra, const std::string & customConfig )

private

called by algorithm initialize per object (electron, photon, forward electron, muon)

Definition at line 269 of file IsolationBuilder.cxx.

{
 
  std::string prefix = containerName + ".";
 
  for (size_t flavor = 0; flavor < isoInts.size(); flavor++) {
    // iterate over the flavor (cell, topo, eflow, track
    //   Note: it is a configuration error if different types
    //         are included in one inner vector
 
    CaloIsoHelpKey cisoH(this);
    TrackIsoHelpKey tisoH(this);
 
    // std::vector<SG::AuxElement::Decorator<float>*> Deco;
    xAOD::Iso::IsolationFlavour isoFlav = xAOD::Iso::numIsolationFlavours;
    xAOD::Iso::IsolationFlavour oldIsoFlav = xAOD::Iso::numIsolationFlavours;
 
    for (size_t type = 0; type < isoInts[flavor].size(); type++) {
      // iterate over the cone sizes for a given flavor.
      // (also check that the cone sizes really are of the same flavor;
      // otherwise an error)
 
      xAOD::Iso::IsolationType isoType =
        static_cast<xAOD::Iso::IsolationType>(isoInts[flavor][type]);
      isoFlav = xAOD::Iso::isolationFlavour(isoType);
      ATH_MSG_DEBUG("Saw isoType " << xAOD::Iso::toString(isoType) << " and isoFlav " << xAOD::Iso::toString(isoFlav));
      if (oldIsoFlav != xAOD::Iso::numIsolationFlavours &&
          oldIsoFlav != isoFlav) {
        ATH_MSG_FATAL("Configuration error:  can only have one type of "
                      "isolation in inner vector");
        return StatusCode::FAILURE;
      }
      oldIsoFlav = isoFlav;
      std::string isoName = prefix + xAOD::Iso::toString(isoType);
      if (!customConfig.empty()) {
        isoName += "_" + customConfig;
      }
      if (isoFlav == xAOD::Iso::etcone || isoFlav == xAOD::Iso::topoetcone ||
          isoFlav == xAOD::Iso::neflowisol) {
        cisoH.isoTypes.push_back(isoType);
        cisoH.isoDeco.emplace_back(isoName);
      } else if (isoFlav == xAOD::Iso::ptcone) {
        tisoH.isoTypes.push_back(isoType);
        tisoH.isoDeco.emplace_back(isoName);
        auto coneSize =
          static_cast<int>(round(100 * xAOD::Iso::coneSize(isoType)));
        std::string isoNameV = prefix + "ptvarcone" + std::to_string(coneSize);
        if (!customConfig.empty()) {
          isoNameV += "_" + customConfig;
        }
        tisoH.isoDecoV.emplace_back(isoNameV);
      } else {
        ATH_MSG_FATAL("Configuration error: Isolation flavor "
                      << isoFlav << " not supported.");
        return StatusCode::FAILURE;
      }
    }
 
    // check that there were isolations configured
    if (isoFlav == xAOD::Iso::numIsolationFlavours) {
      ATH_MSG_WARNING("The configuration was malformed: an empty inner vector "
                      "was added; ignoring");
      continue;
    }

    // Now that the isolations to calculate are determined,
    // initialize the isolation decorations
    // and then determine the corrections to apply,
    // and finally add it to the IsoMap.
 
    if (isoFlav == xAOD::Iso::etcone || isoFlav == xAOD::Iso::topoetcone ||
        isoFlav == xAOD::Iso::neflowisol) {
 
      // let's initialize the decos
      ATH_MSG_DEBUG("Initializing cisoH.isoDeco");
      ATH_CHECK(cisoH.isoDeco.initialize());
 
      ATH_CHECK(addCaloIsoCorrections(
        flavor, isoFlav, cisoH, corInts, false, prefix, customConfig));
      ATH_CHECK(addCaloIsoCorrections(
        flavor, isoFlav, cisoH, corIntsExtra, true, prefix, customConfig));
 
      if (caloIsoMap) {
        caloIsoMap->push_back(std::make_pair(isoFlav, cisoH));
      } else {
        ATH_MSG_FATAL(
          "caloIsoMap was nullptr but the configuration attempted to use it");
        return StatusCode::FAILURE;
      }
    } else if (isoFlav == xAOD::Iso::ptcone) {
 
      // let's initialize the decos
      ATH_MSG_DEBUG("Initializing tisoH.isoDeco");
      ATH_CHECK(tisoH.isoDeco.initialize());
      ATH_MSG_DEBUG("Initializing tisoH.isoDecoV");
      ATH_CHECK(tisoH.isoDecoV.initialize());
 
      ATH_CHECK(addTrackIsoCorrections(
        flavor, isoFlav, tisoH, corInts, false, prefix, customConfig));
      ATH_CHECK(addTrackIsoCorrections(
        flavor, isoFlav, tisoH, corIntsExtra, true, prefix, customConfig));
 
      if (trackIsoMap) {
        trackIsoMap->push_back(std::make_pair(isoFlav, tisoH));
      } else {
        ATH_MSG_FATAL(
          "trackIsoMap was nullptr but the configuration attempted to use it");
        return StatusCode::FAILURE;
      }
    } else {
      ATH_MSG_WARNING("Isolation flavour "
                      << xAOD::Iso::toCString(isoFlav)
                      << " does not exist ! Check your inputs");
    }
    runIsoType.insert(isoFlav);
  }
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

isCoreCor()

bool IsolationBuilder::isCoreCor ( xAOD::Iso::IsolationCaloCorrection corr )

staticprivate

Definition at line 262 of file IsolationBuilder.cxx.

{
  return (cor == xAOD::Iso::coreCone || cor == xAOD::Iso::coreConeSC ||
          cor == xAOD::Iso::coreMuon || cor == xAOD::Iso::core57cells);
}

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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_allTrackRemoval

Gaudi::Property<bool> IsolationBuilder::m_allTrackRemoval { this, "AllTrackRemoval", true }

private

Definition at line 145 of file IsolationBuilder.h.

{ this, "AllTrackRemoval", true };

m_cellIsolationTool

ToolHandle<xAOD::ICaloCellIsolationTool> IsolationBuilder::m_cellIsolationTool

private

Initial value:

{
    this,
    "CaloCellIsolationTool",
    "",
    "Handle of the calo cell IsolationTool"
  }

Tool for cell isolation calculation.

Definition at line 97 of file IsolationBuilder.h.

                                                            {
    this,
    "CaloCellIsolationTool",
    "",
    "Handle of the calo cell IsolationTool"
  };

m_cellsKey

SG::ReadHandleKey<CaloCellContainer> IsolationBuilder::m_cellsKey

private

Initial value:

{
    this,
    "CellCollectionName",
    "AllCalo",
    "Name of container which contain calo cells"
  }

Cell container.

Definition at line 105 of file IsolationBuilder.h.

                                               {
    this,
    "CellCollectionName",
    "AllCalo",
    "Name of container which contain calo cells"
  };

m_customConfigEl

Gaudi::Property<std::string> IsolationBuilder::m_customConfigEl

private

Initial value:

{
    this,
    "CustomConfigurationNameEl",
    "",
    "use a custom configuration for electron"
  }

Definition at line 349 of file IsolationBuilder.h.

                                           {
    this,
    "CustomConfigurationNameEl",
    "",
    "use a custom configuration for electron"
  };

m_customConfigFwd

Gaudi::Property<std::string> IsolationBuilder::m_customConfigFwd

private

Initial value:

{
    this,
    "CustomConfigurationNameFwd",
    "",
    "use a custom configuration for forward electron"
  }

Definition at line 363 of file IsolationBuilder.h.

                                            {
    this,
    "CustomConfigurationNameFwd",
    "",
    "use a custom configuration for forward electron"
  };

m_customConfigMu

Gaudi::Property<std::string> IsolationBuilder::m_customConfigMu

private

Initial value:

{
    this,
    "CustomConfigurationNameMu",
    "",
    "use a custom configuration for muon"
  }

Definition at line 370 of file IsolationBuilder.h.

                                           {
    this,
    "CustomConfigurationNameMu",
    "",
    "use a custom configuration for muon"
  };

m_customConfigPh

Gaudi::Property<std::string> IsolationBuilder::m_customConfigPh

private

Initial value:

{
    this,
    "CustomConfigurationNamePh",
    "",
    "use a custom configuration for photon"
  }

Definition at line 356 of file IsolationBuilder.h.

                                           {
    this,
    "CustomConfigurationNamePh",
    "",
    "use a custom configuration for photon"
  };

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_elCaloIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey> > IsolationBuilder::m_elCaloIso

private

Definition at line 277 of file IsolationBuilder.h.

m_elcorInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_elcorInts

private

Initial value:

{
    this,
    "ElCorTypes",
    {},
    "The correction types to do for electron iso: vector of vector of enum "
    "type Iso::IsolationCalo/TrackCorrection"
  }

Definition at line 158 of file IsolationBuilder.h.

                                                      {
    this,
    "ElCorTypes",
    {},
    "The correction types to do for electron iso: vector of vector of enum "
    "type Iso::IsolationCalo/TrackCorrection"
  };

m_elcorIntsExtra

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_elcorIntsExtra

private

Initial value:

{
    this,
    "ElCorTypesExtra",
    {},
    "The extra correction types to store but not apply for electrons"
  }

Definition at line 166 of file IsolationBuilder.h.

                                                           {
    this,
    "ElCorTypesExtra",
    {},
    "The extra correction types to store but not apply for electrons"
  };

m_ElectronContainerName

Gaudi::Property<std::string> IsolationBuilder::m_ElectronContainerName

private

Initial value:

{
    this,
    "ElectronCollectionContainerName",
    "Electrons"
  }

Containers (Is it best to make them as strings? Used by multiple handles)

Definition at line 72 of file IsolationBuilder.h.

                                                  {
    this,
    "ElectronCollectionContainerName",
    "Electrons"
  };

m_elisoInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_elisoInts

private

Initial value:

{
    this,
    "ElIsoTypes",
    {},
    "The isolation types to do for electrons: vector of vector of enum type "
    "Iso::IsolationType"
  }

Isolation types.

Definition at line 150 of file IsolationBuilder.h.

                                                      {
    this,
    "ElIsoTypes",
    {},
    "The isolation types to do for electrons: vector of vector of enum type "
    "Iso::IsolationType"
  };

m_elTrackIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey> > IsolationBuilder::m_elTrackIso

private

Definition at line 314 of file IsolationBuilder.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_feCaloIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey> > IsolationBuilder::m_feCaloIso

private

Definition at line 281 of file IsolationBuilder.h.

m_fecorInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_fecorInts

private

Initial value:

{
    this,
    "FeCorTypes",
    {},
    "The correction types to do for forward electron iso: vector of vector of "
    "enum type Iso::IsolationCalo/TrackCorrection"
  }

Definition at line 229 of file IsolationBuilder.h.

                                                      {
    this,
    "FeCorTypes",
    {},
    "The correction types to do for forward electron iso: vector of vector of "
    "enum type Iso::IsolationCalo/TrackCorrection"
  };

m_fecorIntsExtra

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_fecorIntsExtra

private

Initial value:

{
    this,
    "FeCorTypesExtra",
    {},
    "The extra correction types to store but not apply for forward electrons"
  }

Definition at line 237 of file IsolationBuilder.h.

                                                           {
    this,
    "FeCorTypesExtra",
    {},
    "The extra correction types to store but not apply for forward electrons"
  };

m_feisoInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_feisoInts

private

Initial value:

{
    this,
    "FeIsoTypes",
    {},
    "The isolation types to do for forward electron: vector of vector of enum "
    "type Iso::IsolationType"
  }

Definition at line 221 of file IsolationBuilder.h.

                                                      {
    this,
    "FeIsoTypes",
    {},
    "The isolation types to do for forward electron: vector of vector of enum "
    "type Iso::IsolationType"
  };

m_FwdElectronContainerName

Gaudi::Property<std::string> IsolationBuilder::m_FwdElectronContainerName

private

Initial value:

{
    this,
    "FwdElectronCollectionContainerName",
    "ForwardElectrons"
  }

Definition at line 78 of file IsolationBuilder.h.

                                                     {
    this,
    "FwdElectronCollectionContainerName",
    "ForwardElectrons"
  };

m_isTrigger

Gaudi::Property<bool> IsolationBuilder::m_isTrigger { this, "IsTrigger", false }

private

is the alg run at trigger level

Definition at line 137 of file IsolationBuilder.h.

{ this, "IsTrigger", false };

m_muCaloIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey> > IsolationBuilder::m_muCaloIso

private

Definition at line 283 of file IsolationBuilder.h.

m_mucorInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_mucorInts

private

Initial value:

{
    this,
    "MuCorTypes",
    {},
    "The correction types to do for Muon iso: vector of vector of enum type "
    "Iso::IsolationCalo/TrackCorrection"
  }

Definition at line 206 of file IsolationBuilder.h.

                                                      {
    this,
    "MuCorTypes",
    {},
    "The correction types to do for Muon iso: vector of vector of enum type "
    "Iso::IsolationCalo/TrackCorrection"
  };

m_mucorIntsExtra

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_mucorIntsExtra

private

Initial value:

{
    this,
    "MuCorTypesExtra",
    {},
    "The extra correction types to store but not apply for muons"
  }

Definition at line 214 of file IsolationBuilder.h.

                                                           {
    this,
    "MuCorTypesExtra",
    {},
    "The extra correction types to store but not apply for muons"
  };

m_muisoInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_muisoInts

private

Initial value:

{
    this,
    "MuIsoTypes",
    {},
    "The isolation types to do for Muons : vector of vector of enum type "
    "Iso::IsolationType"
  }

Definition at line 198 of file IsolationBuilder.h.

                                                      {
    this,
    "MuIsoTypes",
    {},
    "The isolation types to do for Muons : vector of vector of enum type "
    "Iso::IsolationType"
  };

m_MuonContainerName

Gaudi::Property<std::string> IsolationBuilder::m_MuonContainerName

private

Initial value:

{
    this,
    "MuonCollectionContainerName",
    "Muons"
  }

Definition at line 90 of file IsolationBuilder.h.

                                              {
    this,
    "MuonCollectionContainerName",
    "Muons"
  };

m_muTrackIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey> > IsolationBuilder::m_muTrackIso

private

Definition at line 318 of file IsolationBuilder.h.

m_pflowIsolationTool

ToolHandle<xAOD::INeutralEFlowIsolationTool> IsolationBuilder::m_pflowIsolationTool

private

Initial value:

{
    this,
    "PFlowIsolationTool",
    "",
    "Handle of the pflow IsolationTool"
  }

Tool for neutral pflow isolation calculation.

Definition at line 121 of file IsolationBuilder.h.

                                                                 {
    this,
    "PFlowIsolationTool",
    "",
    "Handle of the pflow IsolationTool"
  };

m_phCaloIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey> > IsolationBuilder::m_phCaloIso

private

Definition at line 279 of file IsolationBuilder.h.

m_phcorInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_phcorInts

private

Initial value:

{
    this,
    "PhCorTypes",
    {},
    "The correction types to do for photons iso: vector of vector of enum type "
    "Iso::IsolationCalo/TrackCorrection"
  }

Definition at line 183 of file IsolationBuilder.h.

                                                      {
    this,
    "PhCorTypes",
    {},
    "The correction types to do for photons iso: vector of vector of enum type "
    "Iso::IsolationCalo/TrackCorrection"
  };

m_phcorIntsExtra

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_phcorIntsExtra

private

Initial value:

{
    this,
    "PhCorTypesExtra",
    {},
    "The extra correction types to store but not apply for photons"
  }

Definition at line 191 of file IsolationBuilder.h.

                                                           {
    this,
    "PhCorTypesExtra",
    {},
    "The extra correction types to store but not apply for photons"
  };

m_phisoInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_phisoInts

private

Initial value:

{
    this,
    "PhIsoTypes",
    {},
    "The isolation types to do for photons: vector of vector of enum type "
    "Iso::IsolationType"
  }

Isolation types (for the alg.

properties, only vector<vector<double>> available

Definition at line 175 of file IsolationBuilder.h.

                                                      {
    this,
    "PhIsoTypes",
    {},
    "The isolation types to do for photons: vector of vector of enum type "
    "Iso::IsolationType"
  };

m_PhotonContainerName

Gaudi::Property<std::string> IsolationBuilder::m_PhotonContainerName

private

Initial value:

{
    this,
    "PhotonCollectionContainerName",
    "Photons"
  }

Definition at line 84 of file IsolationBuilder.h.

                                                {
    this,
    "PhotonCollectionContainerName",
    "Photons"
  };

m_phTrackIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey> > IsolationBuilder::m_phTrackIso

private

Definition at line 316 of file IsolationBuilder.h.

m_storepileupCorrection

Gaudi::Property<bool> IsolationBuilder::m_storepileupCorrection { this, "storepileupCorrection", false }

private

Definition at line 147 of file IsolationBuilder.h.

{ this, "storepileupCorrection", false };

m_topoIsolationTool

ToolHandle<xAOD::ICaloTopoClusterIsolationTool> IsolationBuilder::m_topoIsolationTool

private

Initial value:

{
    this,
    "CaloTopoIsolationTool",
    "",
    "Handle of the calo topo IsolationTool"
  }

Tool for topo isolation calculation.

Definition at line 113 of file IsolationBuilder.h.

                                                                   {
    this,
    "CaloTopoIsolationTool",
    "",
    "Handle of the calo topo IsolationTool"
  };

m_trackIsolationTool

ToolHandle<xAOD::ITrackIsolationTool> IsolationBuilder::m_trackIsolationTool

private

Initial value:

{
    this,
    "TrackIsolationTool",
    "",
    "Handle of the track IsolationTool"
  }

Tool for neutral pflow isolation calculation.

Definition at line 129 of file IsolationBuilder.h.

                                                          {
    this,
    "TrackIsolationTool",
    "",
    "Handle of the track IsolationTool"
  };

m_useBremAssoc

Gaudi::Property<bool> IsolationBuilder::m_useBremAssoc

private

Initial value:

{ this,
                                        "useBremAssoc",
                                        true,
                                        "use track to track assoc after brem" }

Definition at line 140 of file IsolationBuilder.h.

                                    { this,
                                        "useBremAssoc",
                                        true,
                                        "use track to track assoc after brem" };

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• IsolationBuilder.h
• IsolationBuilder.cxx