egammaSuperClusterBuilderBase Class Reference

Base class for electronSuperClusterBuilder photonSuperClusterBuilder egammaSuperClusterBuilder This class cannot be instantiated by itself since the execute method is not implemented. More...

#include <egammaSuperClusterBuilderBase.h>

Inheritance diagram for egammaSuperClusterBuilderBase:

Collaboration diagram for egammaSuperClusterBuilderBase:

Public Member Functions
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
	egammaSuperClusterBuilderBase (const std::string &name, ISvcLocator *pSvcLocator)
	Protected constructor since this class should not be instantiated by itself.
virtual StatusCode	initialize () override
	should be called by the derived class in the initialize phase
virtual StatusCode	execute (const EventContext &ctx) const override
	should be called by the derived class in the execute phase
virtual xAOD::EgammaParameters::EgammaType	getEgammaRecType (const egammaRec *egRec) const =0
virtual bool	egammaRecPassesSelection (const egammaRec *egRec) const
virtual StatusCode	redoMatching (const EventContext &ctx, SG::WriteHandle< EgammaRecContainer > &newEgammaRecs) const
virtual std::vector< std::size_t >	searchForSecondaryClusters (std::size_t egammaInd, const EgammaRecContainer *egammaRecs, std::vector< bool > &isUsed) const =0
bool	matchesInWindow (const xAOD::CaloCluster *ref, const xAOD::CaloCluster *clus) const
	Is clus in window center around ref?
std::unique_ptr< xAOD::CaloCluster >	createNewCluster (const EventContext &ctx, const std::vector< const xAOD::CaloCluster * > &clusters, const DataLink< CaloCellContainer > &cellCont, const CaloDetDescrManager &mgr, xAOD::EgammaParameters::EgammaType egType, xAOD::CaloClusterContainer *precorrClusters) const
	Add new supercluster ,created out of the input clusters, to the newClusters collections.
bool	seedClusterSelection (const xAOD::CaloCluster *clus) const
	check if we pass the basic criteria for a seed cluster
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
Gaudi::Property< float >	m_EtThresholdCut
	Seed selection requirements.
SG::ReadHandleKey< EgammaRecContainer >	m_inputEgammaRecContainerKey
	Key for input egammaRec container.
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloDetDescrMgrKey
SG::WriteHandleKey< EgammaRecContainer >	m_outputEgammaRecContainerKey
	Key for output egammaRec container.
SG::WriteHandleKey< xAOD::CaloClusterContainer >	m_outputSuperClusterCollectionName
	Key for output clusters.
SG::WriteHandleKey< xAOD::CaloClusterContainer >	m_precorrClustersKey
	Optional key for pre-correction clusters.
float	m_searchWindowEtaBarrel = 0.0F
float	m_searchWindowPhiBarrel = 0.0F
float	m_searchWindowEtaEndcap = 0.0F
float	m_searchWindowPhiEndcap = 0.0F

Static Protected Attributes
static constexpr float	s_cellEtaSize = 0.025
static constexpr float	s_cellPhiSize = M_PI / 128.
static constexpr float	s_TG3Run3E4cellEtaMax = 1.72
static constexpr float	s_TG3Run3E3cellEtaMin = 1.2
static constexpr float	s_TG3Run2E4cellEtaMax = 1.6
static constexpr float	s_TG3Run2E4cellEtaMin = 1.4
static constexpr float	s_ClEtaMinForTG3cell = s_TG3Run2E4cellEtaMin - 0.03
static constexpr float	s_ClEtaMaxForTG3cell = s_TG3Run3E4cellEtaMax + 0.03

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	fillClusterConstrained (xAOD::CaloCluster &tofill, const std::vector< const xAOD::CaloCluster * > &clusters, const CookieCutterHelpers::CentralPosition &cp0) const
	Fill super cluster constraining its size in eta,phi around the overall hottest cell and the its L2 size.
StatusCode	addTileGap3CellsinWindow (xAOD::CaloCluster &tofill, const CaloDetDescrManager &mgr) const
	add all tile Gap 3 cells in a window.
StatusCode	calibrateCluster (const EventContext &ctx, xAOD::CaloCluster *newCluster, const CaloDetDescrManager &mgr, const xAOD::EgammaParameters::EgammaType egType, xAOD::CaloClusterContainer *precorrClusters) const
	function to calibrate the new clusters energy
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
float	m_addCellsWindowEtaBarrel = 0.0F
float	m_addCellsWindowEtaEndcap = 0.0F
float	m_extraL0L1PhiSize = 0.0F
float	m_extraL3EtaSize = 0.0F
Gaudi::Property< bool >	m_linkToConstituents
	Decorate the supercluster with links to the component topoclusters.
Gaudi::Property< bool >	m_useExtendedTG3
	Use extended TG3 definition (only after Run 2)
Gaudi::Property< int >	m_searchWindowEtaCellsBarrel
	Size of topocluster search window in eta for the barrel.
Gaudi::Property< int >	m_searchWindowPhiCellsBarrel
	Size of topocluster search window in phi for the barrel.
Gaudi::Property< int >	m_searchWindowEtaCellsEndcap
	Size of topocluster search window in eta for the end-cap.
Gaudi::Property< int >	m_searchWindowPhiCellsEndcap
	Size of topocluster search window in phi for the end-cap.
Gaudi::Property< int >	m_addCellsWindowEtaCellsBarrel
	Size of windows et eta in which cells of topoclusters are added for the barrel (units of 2nd layer cells)
Gaudi::Property< int >	m_addCellsWindowEtaCellsEndcap
	Size of windows et eta in which cells of topoclusters are edded for the endcap (units of 2nd layer cells)
Gaudi::Property< int >	m_extraL0L1PhiSizeCells
	"When adding L0 (PS) and L1 cells, how much wider than the L2 size of the cluster is the acceptance in phi (units of 2nd layer cells)
Gaudi::Property< int >	m_extraL3EtaSizeCells
	"When adding L3 cells, how much wider in eta than the L2
ServiceHandle< IegammaMVASvc >	m_MVACalibSvc
	Handle to the MVA calibration service.
ToolHandle< IegammaSwTool >	m_clusterCorrectionTool
	Tool to handle cluster corrections.
ToolHandle< IegammaCheckEnergyDepositTool >	m_egammaCheckEnergyDepositTool
	Pointer to the egammaCheckEnergyDepositTool.
ToolHandle< IegammaCellRecoveryTool >	m_egammaCellRecoveryTool
	Pointer to the egammaCellRecoveryTool.
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

Base class for electronSuperClusterBuilder photonSuperClusterBuilder egammaSuperClusterBuilder This class cannot be instantiated by itself since the execute method is not implemented.

This class provides functions which are used to build supercluster and are independet from the nature of the particles, for example a function to decide if two clusters are compatible to be added in a supercluster (egammaSuperClusterBuilderBase::matchesInWindow) and a function (egammaSuperClusterBuilderBase::createNewCluster) to create a new supercluster from a collection of clusters.

Definition at line 46 of file egammaSuperClusterBuilderBase.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

egammaSuperClusterBuilderBase()

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

protected

Protected constructor since this class should not be instantiated by itself.

Definition at line 35 of file egammaSuperClusterBuilderBase.cxx.

  : AthReentrantAlgorithm(name, pSvcLocator)
{
}

Member Function Documentation

addTileGap3CellsinWindow()

StatusCode egammaSuperClusterBuilderBase::addTileGap3CellsinWindow ( xAOD::CaloCluster & tofill, const CaloDetDescrManager & mgr ) const

private

add all tile Gap 3 cells in a window.

All the cells in the TileGap3 layer which are in a eta x phi window 0.2, ~0.15 centered around the raw position of the cluster param tofill with weight 1.

Definition at line 617 of file egammaSuperClusterBuilderBase.cxx.

{
 
  double searchWindowEta = m_useExtendedTG3 ? 0.35 : 0.2;
  constexpr double searchWindowPhi = 2 * M_PI / 64.0 + M_PI / 64; // ~ 0.15 rad
  std::vector<const CaloCell*> cells;
  cells.reserve(16);
  const CaloCellContainer* inputcells =
    tofill.getCellLinks()->getCellContainer();
 
  if (!inputcells) {
    ATH_MSG_ERROR("No cell container in addRemainingCellsToCluster?");
    return StatusCode::FAILURE;
  }
 
  CaloCellList myList(&mgr, inputcells);
 
  const std::vector<CaloSampling::CaloSample> samples = {
    CaloSampling::TileGap3
  };
 
  for (auto samp : samples) {
    // quite slow
    myList.select(
      tofill.eta0(), tofill.phi0(), searchWindowEta, searchWindowPhi, samp);
    cells.insert(cells.end(), myList.begin(), myList.end());
  }
 
  for (const auto* cell : cells) {
    if (!cell) {
      continue;
    }
    const CaloDetDescrElement* dde = cell->caloDDE();
    if (!dde) {
      continue;
    }
 
    float maxEta = s_TG3Run2E4cellEtaMax;
    float minEta = s_TG3Run2E4cellEtaMin;
    if (m_useExtendedTG3) {
      minEta = s_TG3Run3E3cellEtaMin;
      // if |eta2| < 1.56, keep only E3, else keep E3+E4.
      // |eta2| uses as the eta of the highest energy cell in layer 2 as proxy
      if (std::abs(tofill.eta0()) > 1.56) {
        maxEta = s_TG3Run3E4cellEtaMax;
      }
    }
    float cellaEtaRaw = std::abs(dde->eta_raw());
    if (cellaEtaRaw >= minEta && cellaEtaRaw <= maxEta) {
      int index = inputcells->findIndex(dde->calo_hash());
      tofill.addCell(index, 1.);
    }
  }
  return StatusCode::SUCCESS;
}

calibrateCluster()

StatusCode egammaSuperClusterBuilderBase::calibrateCluster ( const EventContext & ctx, xAOD::CaloCluster * newCluster, const CaloDetDescrManager & mgr, const xAOD::EgammaParameters::EgammaType egType, xAOD::CaloClusterContainer * precorrClusters ) const

private

function to calibrate the new clusters energy

Calibrate with

• egammaSuperClusterBuilderBase.refineEta1Position
• ClusterCorrectionTool (default=egammaSwTool)
• fillPositionsInCalo
• MVACalibSvc (default=egammaMVASvc).

Definition at line 676 of file egammaSuperClusterBuilderBase.cxx.

{
 
  egammaClusterHelpers::refineEta1Position(newCluster, mgr);
  // Save the state before the corrections
  newCluster->setAltE(newCluster->e());
  newCluster->setAltEta(newCluster->eta());
  newCluster->setAltPhi(newCluster->phi());
  // first do the corrections
  if (precorrClusters) {
    precorrClusters->push_back(std::make_unique<xAOD::CaloCluster>());
    *precorrClusters->back() = *newCluster;
  }
  ATH_CHECK(m_clusterCorrectionTool->execute(
    ctx, newCluster, egType, xAOD::EgammaHelpers::isBarrel(newCluster)));
  double aeta = std::abs(newCluster->eta());
  if (aeta > 10) {
    ATH_MSG_DEBUG("Too large eta after S-shape corrections. "
          "SuperCluster rejected");
    return StatusCode::FAILURE;
  }
  newCluster->setRawE(newCluster->e());
  newCluster->setRawEta(newCluster->eta());
  newCluster->setRawPhi(newCluster->phi());
  //
  egammaClusterHelpers::fillPositionsInCalo(newCluster, mgr);
  ATH_CHECK(m_MVACalibSvc->execute(*newCluster, egType));
 
  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;
}

createNewCluster()

std::unique_ptr< xAOD::CaloCluster > egammaSuperClusterBuilderBase::createNewCluster ( const EventContext & ctx, const std::vector< const xAOD::CaloCluster * > & clusters, const DataLink< CaloCellContainer > & cellCont, const CaloDetDescrManager & mgr, xAOD::EgammaParameters::EgammaType egType, xAOD::CaloClusterContainer * precorrClusters ) const

protected

Add new supercluster ,created out of the input clusters, to the newClusters collections.

It decides which cells of the seed and the satellite clusters to add (boxing / cookie cutter).

The reference point is computed with findCentralPosition which returns the hottest cells looping on the cells of all the considered topo-clusters. Two references are computed, one for the barrel, one for the endcap. Computations are done in the calo-frame. Once the reference is computed the decision is made by egammaSuperClusterBuilderBase::fillClusterConstrained which add the cells for the accordeon.

Cells from the tile gap are added using egammaSuperClusterBuilderBase::addTileGap3CellsinWindow.

Kinematic properties of the cluster are computed from the property of the cells.

If the supercluster has a cluster energy less then EtThresholdCut (also used as threshould for the seed) false returned, and the cluster is not added. The supercluster need to pass egammaCheckEnergyDepositTool::checkFractioninSamplingCluster if not false is returned and the cluster is not added.

Calibrations on eta1, energy are applied with egammaSuperClusterBuilderBase::calibrateCluster

Calculate the kinematics of the new cluster, after all cells are added

Definition at line 309 of file egammaSuperClusterBuilderBase.cxx.

{
  if (clusters.empty()) {
    ATH_MSG_ERROR("Missing the seed cluster! Should not happen.");
    return nullptr;
  }
 
  // create a new empty cluster
  // collection will own it if
  auto newCluster = CaloClusterStoreHelper::makeCluster(cellCont);
 
  if (!newCluster) {
    ATH_MSG_ERROR("CaloClusterStoreHelper::makeCluster failed.");
    return nullptr;
  }
  //
  newCluster->setClusterSize(xAOD::CaloCluster::SuperCluster);
  // Let's try to find the eta and phi of the hottest cell in L2.
  // This will be used as the center for restricting the cluster size.
  CookieCutterHelpers::CentralPosition cp0(clusters, mgr);
 
  // Set the eta0/phi0 based on the references, but in raw coordinates
  if (cp0.emaxB >= cp0.emaxEC) {
    newCluster->setEta0(cp0.etaB);
    newCluster->setPhi0(cp0.phiB);
  } else {
    newCluster->setEta0(cp0.etaEC);
    newCluster->setPhi0(cp0.phiEC);
  }
 
  // Actually fill the cluster here
  if (fillClusterConstrained(*newCluster, clusters, cp0).isFailure()) {
    return nullptr;
  }
  // Apply SW-style summation of TileGap3 cells (if necessary).
  float eta0 = std::abs(newCluster->eta0());
  // In Run2, we did not impose restriction to include TG3 cells at this level.
  // It should have been [1.37,1.63]. It has no impact on performance as TG3 was
  // only used in energy calibration BDT in [1.4,1.6].
  // In Run three we restrict to [1.37,1.75]
  if (!m_useExtendedTG3 ||
      (eta0 > s_ClEtaMinForTG3cell && eta0 < s_ClEtaMaxForTG3cell)) {
    if (addTileGap3CellsinWindow(*newCluster, mgr).isFailure()) {
      ATH_MSG_ERROR("Problem with the input cluster when running "
                    "AddTileGap3CellsinWindow?");
 
      return nullptr;
    }
  }
  CaloClusterKineHelper::calculateKine(newCluster.get(), true, true);
 
  // If adding all EM cells we are somehow below the seed threshold then remove
  if (newCluster->et() < m_EtThresholdCut) {
    return nullptr;
  }
 
  // Check to see if cluster pases basic requirements. If not, kill it.
  if (!m_egammaCheckEnergyDepositTool.empty() &&
      !m_egammaCheckEnergyDepositTool->checkFractioninSamplingCluster(
        newCluster.get())) {
    return nullptr;
  }
 
  // Apply correction calibration
  if (calibrateCluster(ctx, newCluster.get(), mgr, egType, precorrClusters)
        .isFailure()) {
    ATH_MSG_WARNING("There was problem calibrating the object");
    return nullptr;
  }
 
  // Avoid negative energy clusters
  if (newCluster->et() < 0) {
    return nullptr;
  }
 
  if (m_linkToConstituents) {
    // EDM vector to constituent clusters
    std::vector<ElementLink<xAOD::CaloClusterContainer>> constituentLinks;
    for (const xAOD::CaloCluster* cluster : clusters) {
      ElementLink<xAOD::CaloClusterContainer> sisterCluster = 
        cluster->getSisterClusterLink();
 
      // Set the element Link to the constitents
      if (sisterCluster) {
        constituentLinks.push_back(sisterCluster);
      } else {
        ATH_MSG_WARNING("No sister Link available");
      }
    }
    // Set the link from the super cluster to the constituents (accumulated)
    // clusters used.
    static const SG::AuxElement::Accessor<
      std::vector<ElementLink<xAOD::CaloClusterContainer>>>
      caloClusterLinks("constituentClusterLinks");
    caloClusterLinks(*newCluster) = constituentLinks;
  }
  // return the new cluster
  return newCluster;
}

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

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

egammaRecPassesSelection()

bool egammaSuperClusterBuilderBase::egammaRecPassesSelection ( const egammaRec * egRec ) const

protectedvirtual

Reimplemented in electronSuperClusterBuilder.

Definition at line 228 of file egammaSuperClusterBuilderBase.cxx.

                                                                                                     { 
  return true;
}

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 egammaSuperClusterBuilderBase::execute ( const EventContext & ctx ) const

overrideprotectedvirtual

should be called by the derived class in the execute phase

Definition at line 106 of file egammaSuperClusterBuilderBase.cxx.

{
  SG::ReadHandle<EgammaRecContainer> egammaRecs(m_inputEgammaRecContainerKey,
                                                ctx);
  // check is only used for serial running; remove when MT scheduler used
  ATH_CHECK(egammaRecs.isValid());
 
  // Have to register cluster container in order to properly get cluster
  // links.
  SG::WriteHandle<xAOD::CaloClusterContainer> outputClusterContainer(
    m_outputSuperClusterCollectionName, ctx);
 
  ATH_CHECK(CaloClusterStoreHelper::AddContainerWriteHandle(outputClusterContainer));
 
  // Create the new Electron Super Cluster based EgammaRecContainer
  SG::WriteHandle<EgammaRecContainer> newEgammaRecs(
    m_outputEgammaRecContainerKey, ctx);
  ATH_CHECK(newEgammaRecs.record(std::make_unique<EgammaRecContainer>()));
 
  size_t inputSize = egammaRecs->size();
  outputClusterContainer->reserve(inputSize);
  newEgammaRecs->reserve(inputSize);
 
  std::optional<SG::WriteHandle<xAOD::CaloClusterContainer>> precorrClustersH;
  if (!m_precorrClustersKey.empty()) {
    precorrClustersH.emplace(m_precorrClustersKey, ctx);
    ATH_CHECK(CaloClusterStoreHelper::AddContainerWriteHandle(*precorrClustersH));
    precorrClustersH->ptr()->reserve(inputSize);
  }
 
  // The calo Det Descr manager
  SG::ReadCondHandle<CaloDetDescrManager> caloDetDescrMgrHandle{
    m_caloDetDescrMgrKey, ctx
  };
  ATH_CHECK(caloDetDescrMgrHandle.isValid());
  const CaloDetDescrManager* calodetdescrmgr = *caloDetDescrMgrHandle;
 
  // If no input return
  if (egammaRecs->empty()) {
    return StatusCode::SUCCESS;
  }
 
  // Figure the cellCont we need to point to
  const DataLink<CaloCellContainer>& cellCont =
    (*egammaRecs)[0]->caloCluster()->getCellLinks()->getCellContainerLink();
 
  // Loop over input egammaRec objects, build superclusters.
  size_t numInput = egammaRecs->size();
  std::vector<bool> isUsed(numInput, false);
  std::vector<bool> isUsedRevert(numInput, false);
 
  for (std::size_t i = 0; i < egammaRecs->size(); ++i) {
    if (isUsed[i]) {
      continue;
    }
    const auto* egRec = (*egammaRecs)[i];
    // check for good seed cluster
    const xAOD::CaloCluster* clus = egRec->caloCluster();
    if (!seedClusterSelection(clus)) {
      continue;
    }
    
    if (!egammaRecPassesSelection(egRec)) {
      continue; 
    }
 
    // save status in case we fail to create supercluster
    isUsedRevert = isUsed;
    // Mark seed as used,
    isUsed[i] = true;
 
    // Start accumulating the clusters from the seed
    std::vector<const xAOD::CaloCluster*> accumulatedClusters;
    accumulatedClusters.push_back(clus);
 
    // Now we find all the secondary cluster for this seed
    // and we accumulate them
    const std::vector<std::size_t> secondaryIndices =
      searchForSecondaryClusters(i, egammaRecs.cptr(), isUsed);
    for (const auto& secClusIndex : secondaryIndices) {
      const auto* const secRec = (*egammaRecs)[secClusIndex];
      accumulatedClusters.push_back(secRec->caloCluster());
    }
    ATH_MSG_DEBUG("Total clusters " << accumulatedClusters.size());
 
    // Create the new cluster
    std::unique_ptr<xAOD::CaloCluster> newCluster = 
      createNewCluster(ctx,
                       accumulatedClusters,
                       cellCont,
                       *calodetdescrmgr,
                       getEgammaRecType(egRec),
                       precorrClustersH ? precorrClustersH->ptr() : nullptr);
 
    // If we failed to create a cluster revert isUsed for the cluster
    if (newCluster) {
      outputClusterContainer->push_back(std::move(newCluster));
    }
    else {
      isUsed.swap(isUsedRevert);
      continue;
    }
      
    // Add the cluster links to the super cluster
    ElementLink<xAOD::CaloClusterContainer> clusterLink(
      *outputClusterContainer, outputClusterContainer->size() - 1, ctx);
    std::vector<ElementLink<xAOD::CaloClusterContainer>> elClusters{
      clusterLink
    };
  
    // Make egammaRec object, and push it back into output container.
    auto newEgRec = std::make_unique<egammaRec>(*egRec);
    newEgRec->setCaloClusters(elClusters);
    newEgammaRecs->push_back(std::move(newEgRec));
  } // End loop on egammaRecs
 
  ATH_CHECK(redoMatching(ctx, newEgammaRecs));
 
  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();
}

fillClusterConstrained()

StatusCode egammaSuperClusterBuilderBase::fillClusterConstrained ( xAOD::CaloCluster & tofill, const std::vector< const xAOD::CaloCluster * > & clusters, const CookieCutterHelpers::CentralPosition & cp0 ) const

private

Fill super cluster constraining its size in eta,phi around the overall hottest cell and the its L2 size.

Parameters

tofill	empty cluster to be filled
clusters	seed and satellite clusters
cp0	this specify the eta/phi reference in the calo-frame. In egamma reconstruction the references are the hottest cells in L2, in barrel and endcap.

Cells are added if their raw coordinates are inside a window in eta and/or phi centered around the hottest cells specified by cp0. If there are two hottest cells (one in the barrel and one in the endcap) both are used in the tests and an OR of the two is considered.

First L2 and L3 LAR EM cells are considered (excluding inner wheel endcap cells). A cut in eta is used. The range of the eta-window depends if the seed cell is in barrel or endcap. For example for the barrel, cells in L2 are added if they are inside +/- (AddCellsWindowEtaCellsBarrel * s_cellEtaSize / 2) where s_cellEtaSize is the eta size of one cell in L2. For L3 the semi-window is increased by (ExtraL3EtaSizeCells * s_cellEtaSize / 2).

Then cells in PS and L1 are added if they match a window in eta and phi. The eta requiriment is the same as in L2. The window in phi is computed asymetrically using the cells in layer 2, using the function egammaSuperClusterBuilderBase::findPhiSize and increading the semi-window by (ExtraL0L1PhiSize * s_cellPhiSize) where s_cellPhiSize is the size in phi of cells in L2.

Definition at line 438 of file egammaSuperClusterBuilderBase.cxx.

{
  const float addCellsWindowEtaBarrel = m_addCellsWindowEtaBarrel;
  const float addCellsWindowEtaEndcap = m_addCellsWindowEtaEndcap;
  const float addCellsWindowL3EtaBarrel =
    m_addCellsWindowEtaBarrel + m_extraL3EtaSize;
  const float addCellsWindowL3EtaEndcap =
    m_addCellsWindowEtaEndcap + m_extraL3EtaSize;
 
  // Loop for L2/L3
  for (const xAOD::CaloCluster* tocheck : clusters) {
    xAOD::CaloCluster::const_cell_iterator cell_itr = tocheck->begin();
    xAOD::CaloCluster::const_cell_iterator cell_end = tocheck->end();
    // Loop over cells
    for (; cell_itr != cell_end; ++cell_itr) {
      // sanity check on the cell
      const CaloCell* cell = *cell_itr;
      if (!cell) {
        continue;
      }
      const CaloDetDescrElement* dde = cell->caloDDE();
      if (!dde) {
        continue;
      }
      // we want only LAREM
      if (!(dde->getSubCalo() == CaloCell_ID::LAREM)) {
        continue;
      }
      // we want L2 or L3 cells
      const auto sampling = dde->getSampling();
      const bool isL2Cell =
        (CaloCell_ID::EMB2 == sampling || CaloCell_ID::EME2 == sampling);
      const bool isL3Cell =
        (CaloCell_ID::EMB3 == sampling || CaloCell_ID::EME3 == sampling);
 
      if ((!isL2Cell) && (!isL3Cell)) {
        continue;
      }
      // Also exclude the inner wheel Endcap
      if (dde->is_lar_em_endcap_inner()) {
        continue;
      }
 
      bool inEtaRange = false;
      // Check if is inside the eta range wrt to the hottest
      // cell(s) for the cluster we construct
      if (cp0.emaxB > 0) { // barrel
        if (isL2Cell &&
            (std::abs(cp0.etaB - dde->eta_raw()) < addCellsWindowEtaBarrel)) {
          inEtaRange = true;
        }
        if (isL3Cell &&
            (std::abs(cp0.etaB - dde->eta_raw()) < addCellsWindowL3EtaBarrel)) {
          inEtaRange = true;
        }
      }
      if (cp0.emaxEC > 0) { // endcap
        if (isL2Cell &&
            (std::abs(cp0.etaEC - dde->eta_raw()) < addCellsWindowEtaEndcap)) {
          inEtaRange = true;
        }
        if (isL3Cell && (std::abs(cp0.etaEC - dde->eta_raw()) <
                         addCellsWindowL3EtaEndcap)) {
          inEtaRange = true;
        }
      }
      if (!inEtaRange) {
        continue;
      }
      tofill.addCell(cell_itr.index(), cell_itr.weight());
    } // Loop over cells for L2/L3
  }   // Loop over clusters for L2/L3
 
  // We should have a size here
  if (tofill.size() == 0) {
    return StatusCode::FAILURE;
  }
  // Now calculate the cluster size in 2nd layer
  // use that for constraining the L0/L1 cells we add
  const CookieCutterHelpers::PhiSize phiSize(cp0, tofill);
  const float phiPlusB = cp0.phiB + phiSize.plusB + m_extraL0L1PhiSize;
  const float phiMinusB = cp0.phiB - phiSize.minusB - m_extraL0L1PhiSize;
  const float phiPlusEC = cp0.phiEC + phiSize.plusEC + m_extraL0L1PhiSize;
  const float phiMinusEC = cp0.phiEC - phiSize.minusEC - m_extraL0L1PhiSize;
 
  // Loop for L0/L1
  for (const xAOD::CaloCluster* tocheck : clusters) {
    xAOD::CaloCluster::const_cell_iterator cell_itr = tocheck->begin();
    xAOD::CaloCluster::const_cell_iterator cell_end = tocheck->end();
    // Loop over cells
    for (; cell_itr != cell_end; ++cell_itr) {
      // sanity check on the cell
      const CaloCell* cell = *cell_itr;
      if (!cell) {
        continue;
      }
      const CaloDetDescrElement* dde = cell->caloDDE();
      if (!dde) {
        continue;
      }
 
      // only deal with L1 or PS
      const auto sampling = dde->getSampling();
      const bool isL0L1Cell =
        (CaloCell_ID::EMB1 == sampling || CaloCell_ID::EME1 == sampling ||
         CaloCell_ID::PreSamplerB == sampling ||
         CaloCell_ID::PreSamplerE == sampling);
      if (!isL0L1Cell) {
        continue;
      }
 
      bool inEtaRange = false;
      // Check if is inside the eta range wrt to the hottest
      // cell(s) for the cluster we construct
      if (cp0.emaxB > 0) { // barrel
        if (std::abs(cp0.etaB - dde->eta_raw()) < addCellsWindowEtaBarrel) {
          inEtaRange = true;
        }
      }
      if (cp0.emaxEC > 0) { // endcap
        if (std::abs(cp0.etaEC - dde->eta_raw()) < addCellsWindowEtaEndcap) {
          inEtaRange = true;
        }
      }
      if (!inEtaRange) {
        continue;
      }
 
      // Add L0/L1 when we are in the narrow range
      bool inPhiRange = false;
      if (cp0.emaxB > 0) { // barrel
        const double cell_phi = proxim(dde->phi_raw(), cp0.phiB);
        if (cell_phi > phiMinusB && cell_phi < phiPlusB) {
          inPhiRange = true;
        }
      }
      if (cp0.emaxEC > 0) { // endcap
        const double cell_phi = proxim(dde->phi_raw(), cp0.phiEC);
        if (cell_phi > phiMinusEC && cell_phi < phiPlusEC) {
          inPhiRange = true;
        }
      }
      if (!inPhiRange) {
        continue;
      }
 
      tofill.addCell(cell_itr.index(), cell_itr.weight());
    } // Cell Loop for L0/L1
  }   // Cluster loop for L0/L1
 
  if (!m_egammaCellRecoveryTool.empty()) {
    IegammaCellRecoveryTool::Info info;
    if (cp0.emaxB > cp0.emaxEC) {
      info.etamax = cp0.etaB;
      info.phimax = cp0.phiB;
    } else {
      info.etamax = cp0.etaEC;
      info.phimax = cp0.phiEC;
    }
    if (m_egammaCellRecoveryTool->execute(tofill,info).isFailure()) {
      ATH_MSG_WARNING("Issue trying to recover cells");
    }
 
    // And finally add the recovered cells
    const CaloCellContainer* inputcells =
      tofill.getCellLinks()->getCellContainer();
    for (const auto *c : info.addedCells) {
      int index = inputcells->findIndex(c->caloDDE()->calo_hash());
      tofill.addCell(index, 1.);
    }
  }
 
  return StatusCode::SUCCESS;
}

filterPassed()

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

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

getEgammaRecType()

virtual xAOD::EgammaParameters::EgammaType egammaSuperClusterBuilderBase::getEgammaRecType ( const egammaRec * egRec ) const

protectedpure virtual

Implemented in egammaSuperClusterBuilder, electronSuperClusterBuilder, and photonSuperClusterBuilder.

initialize()

StatusCode egammaSuperClusterBuilderBase::initialize ( )

overrideprotectedvirtual

should be called by the derived class in the initialize phase

Reimplemented in egammaSuperClusterBuilder, electronSuperClusterBuilder, and photonSuperClusterBuilder.

Definition at line 43 of file egammaSuperClusterBuilderBase.cxx.

{
  ATH_CHECK(m_inputEgammaRecContainerKey.initialize());
  ATH_CHECK(m_precorrClustersKey.initialize(SG::AllowEmpty));
  ATH_CHECK(m_caloDetDescrMgrKey.initialize());
  ATH_CHECK(m_outputEgammaRecContainerKey.initialize());
  ATH_CHECK(m_outputSuperClusterCollectionName.initialize());
 
  m_addCellsWindowEtaBarrel =
    m_addCellsWindowEtaCellsBarrel * s_cellEtaSize * 0.5;
  m_addCellsWindowEtaEndcap =
    m_addCellsWindowEtaCellsEndcap * s_cellEtaSize * 0.5;
  // The +- to account for the different L3 eta granularity
  m_extraL3EtaSize = m_extraL3EtaSizeCells * s_cellEtaSize * 0.5;
  // the + is to account for different L0/L1 phi granularity
  m_extraL0L1PhiSize = m_extraL0L1PhiSizeCells * s_cellPhiSize;
 
  m_searchWindowPhiBarrel = m_searchWindowPhiCellsBarrel * s_cellPhiSize * 0.5;
  m_searchWindowEtaBarrel = m_searchWindowEtaCellsBarrel * s_cellEtaSize * 0.5;
  m_searchWindowPhiEndcap = m_searchWindowPhiCellsEndcap * s_cellPhiSize * 0.5;
  m_searchWindowEtaEndcap = m_searchWindowEtaCellsEndcap * s_cellEtaSize * 0.5;
 
  if (m_addCellsWindowEtaCellsBarrel % 2 == 0 ||
      m_addCellsWindowEtaCellsEndcap % 2 == 0) {
    ATH_MSG_FATAL("For adding cells relative to the hottest cell to be "
                  "symmetric in eta, the AddCells "
                  "window size needs to be odd");
 
    return StatusCode::FAILURE;
  }
  ATH_CHECK(m_clusterCorrectionTool.retrieve());
  ATH_CHECK(m_MVACalibSvc.retrieve());
 
  if (!m_egammaCheckEnergyDepositTool.empty()) {
    ATH_CHECK(m_egammaCheckEnergyDepositTool.retrieve());
  } else {
    m_egammaCheckEnergyDepositTool.disable();
  }
  if (!m_egammaCellRecoveryTool.empty()) {
    ATH_CHECK(m_egammaCellRecoveryTool.retrieve());
  } else {
    m_egammaCellRecoveryTool.disable();
  }
 
  ATH_MSG_INFO("e/gamma super clusters"
               << '\n'
               << "--> Eta Window size for L0/L1/L2 cells : "
               << " Barrel +- " << m_addCellsWindowEtaBarrel << " ,EndCap +- "
               << m_addCellsWindowEtaEndcap << '\n'
               << "--> Eta Window size for L3 cells : "
               << " Barrel +- "
               << (m_addCellsWindowEtaBarrel + m_extraL3EtaSize)
               << " ,EndCap +- "
               << (m_addCellsWindowEtaEndcap + m_extraL3EtaSize) << '\n'
               << " -> Phi window is fully dynamic for L2/L3" << '\n'
               << " -> L0/L1 cells in phi will be collected in a Window : "
               << "(L2 neg extend - " << m_extraL0L1PhiSize << " , "
               << "L2 pos extend + " << m_extraL0L1PhiSize << ")");
 
  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;
}

matchesInWindow()

bool egammaSuperClusterBuilderBase::matchesInWindow ( const xAOD::CaloCluster * ref, const xAOD::CaloCluster * clus ) const

protected

Is clus in window center around ref?

Parameters

ref	reference cluster
clus	cluster to be tested

The matching is done using delta-eta and delta-phi comparing them with the values of SearchWindowEtaCellsBarrel, SearchWindowPhiCellsBarrel, SearchWindowEtaCellsEndcap and SearchWindowPhiCellsEndcap, depending if the seed is barrel or endcap. If it is in the crack, an OR of the conditions (using both seeds) is used.

Definition at line 241 of file egammaSuperClusterBuilderBase.cxx.

{
  auto inRange = [](float eta1, float phi1, 
                    float eta2, float phi2,
                    float etaWindow, float phiWindow) {
 
    const float dEta = std::abs(eta1 - eta2);
    const float dPhi = std::abs(P4Helpers::deltaPhi(phi1, phi2));
 
    return dEta < etaWindow && dPhi < phiWindow;
  };
 
  // First the case where the seed is both endcap and barrel, i.e. in the crack
  // Check around both measurements of the seed
  if (ref->hasSampling(CaloSampling::EMB2) &&
      ref->hasSampling(CaloSampling::EME2)) {
    const bool inRangeBarrel = inRange(ref->eta(), 
                                       ref->phi(), 
                                       clus->eta(),
                                       clus->phi(),
                                       m_searchWindowEtaBarrel, 
                                       m_searchWindowPhiBarrel);
 
    const bool inRangeEndcap = inRange(ref->eta(), 
                                       ref->phi(), 
                                       clus->eta(), 
                                       clus->phi(),
                                       m_searchWindowEtaEndcap, 
                                       m_searchWindowPhiEndcap);
 
    const bool inRangeBarrelL2 = inRange(ref->etaSample(CaloSampling::EMB2), 
                                         ref->phiSample(CaloSampling::EMB2),
                                         clus->eta(), 
                                         clus->phi(),
                                         m_searchWindowEtaBarrel, 
                                         m_searchWindowPhiBarrel);
 
    const bool inRangeEndcapL2 = inRange(ref->etaSample(CaloSampling::EME2), 
                                         ref->phiSample(CaloSampling::EME2),
                                         clus->eta(), 
                                         clus->phi(),
                                         m_searchWindowEtaEndcap, 
                                         m_searchWindowPhiEndcap);
    
    // Matches any in case of split
    return inRangeBarrel || inRangeEndcap || inRangeBarrelL2 || inRangeEndcapL2;
  }
 
  if (xAOD::EgammaHelpers::isBarrel(clus)) {
    return inRange(ref->eta(), 
                   ref->phi(), 
                   clus->eta(), 
                   clus->phi(),
                   m_searchWindowEtaBarrel, 
                   m_searchWindowPhiBarrel);
  }
 
  return inRange(ref->eta(), 
                 ref->phi(), 
                 clus->eta(), 
                 clus->phi(),
                 m_searchWindowEtaEndcap, 
                 m_searchWindowPhiEndcap);
}

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.

redoMatching()

StatusCode egammaSuperClusterBuilderBase::redoMatching ( const EventContext & ctx, SG::WriteHandle< EgammaRecContainer > & newEgammaRecs ) const

protectedvirtual

Reimplemented in electronSuperClusterBuilder, and photonSuperClusterBuilder.

Definition at line 233 of file egammaSuperClusterBuilderBase.cxx.

        {
  return StatusCode::SUCCESS;
}

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

searchForSecondaryClusters()

virtual std::vector< std::size_t > egammaSuperClusterBuilderBase::searchForSecondaryClusters ( std::size_t egammaInd, const EgammaRecContainer * egammaRecs, std::vector< bool > & isUsed ) const

protectedpure virtual

Implemented in egammaSuperClusterBuilder, and photonSuperClusterBuilder.

seedClusterSelection()

bool egammaSuperClusterBuilderBase::seedClusterSelection ( const xAOD::CaloCluster * clus ) const

protected

check if we pass the basic criteria for a seed cluster

Definition at line 417 of file egammaSuperClusterBuilderBase.cxx.

{
  // The seed should have 2nd sampling
  if (!clus->hasSampling(CaloSampling::EMB2) &&
      !clus->hasSampling(CaloSampling::EME2)) {
    return false;
  }
  const double eta2 = std::abs(clus->etaBE(2));
  if (eta2 > 10) {
    return false;
  }
  // Accordeon Energy samplings 1 to 3
  const double EMAccEnergy =
    clus->energyBE(1) + clus->energyBE(2) + clus->energyBE(3);
  const double EMAccEt = EMAccEnergy / cosh(eta2);
  // Require minimum energy for supercluster seeding.
  return EMAccEt >= m_EtThresholdCut;
}

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_addCellsWindowEtaBarrel

float egammaSuperClusterBuilderBase::m_addCellsWindowEtaBarrel = 0.0F

private

Definition at line 271 of file egammaSuperClusterBuilderBase.h.

m_addCellsWindowEtaCellsBarrel

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_addCellsWindowEtaCellsBarrel

private

Initial value:

{
    this,
    "AddCellsWindowEtaCellsBarrel",
    3,
    "Number of cells in eta of window around topocluster center to add cells"
  }

Size of windows et eta in which cells of topoclusters are added for the barrel (units of 2nd layer cells)

Definition at line 329 of file egammaSuperClusterBuilderBase.h.

                                                   {
    this,
    "AddCellsWindowEtaCellsBarrel",
    3,
    "Number of cells in eta of window around topocluster center to add cells"
  };

m_addCellsWindowEtaCellsEndcap

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_addCellsWindowEtaCellsEndcap

private

Initial value:

{
    this,
    "AddCellsWindowEtaCellsEndcap",
    5,
    "Number of cells in eta of window around topocluster center to add cells"
  }

Size of windows et eta in which cells of topoclusters are edded for the endcap (units of 2nd layer cells)

Definition at line 338 of file egammaSuperClusterBuilderBase.h.

                                                   {
    this,
    "AddCellsWindowEtaCellsEndcap",
    5,
    "Number of cells in eta of window around topocluster center to add cells"
  };

m_addCellsWindowEtaEndcap

float egammaSuperClusterBuilderBase::m_addCellsWindowEtaEndcap = 0.0F

private

Definition at line 272 of file egammaSuperClusterBuilderBase.h.

m_caloDetDescrMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> egammaSuperClusterBuilderBase::m_caloDetDescrMgrKey

protected

Initial value:

{
    this,
    "CaloDetDescrManager",
    "CaloDetDescrManager",
    "SG Key for CaloDetDescrManager in the Condition Store"
  }

Definition at line 162 of file egammaSuperClusterBuilderBase.h.

                                                                {
    this,
    "CaloDetDescrManager",
    "CaloDetDescrManager",
    "SG Key for CaloDetDescrManager in the Condition Store"
  };

m_clusterCorrectionTool

ToolHandle<IegammaSwTool> egammaSuperClusterBuilderBase::m_clusterCorrectionTool

private

Initial value:

{
    this,
    "ClusterCorrectionTool",
    "egammaSwTool/egammaswtool",
    "tool that applies cluster corrections"
  }

Tool to handle cluster corrections.

Definition at line 375 of file egammaSuperClusterBuilderBase.h.

                                                   {
    this,
    "ClusterCorrectionTool",
    "egammaSwTool/egammaswtool",
    "tool that applies cluster corrections"
  };

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_egammaCellRecoveryTool

ToolHandle<IegammaCellRecoveryTool> egammaSuperClusterBuilderBase::m_egammaCellRecoveryTool

private

Initial value:

{
    this,
    "egammaCellRecoveryTool",
    "",
    "Optional tool that adds cells in L2 or L3 "
    "that could have been rejected by timing cut"
  }

Pointer to the egammaCellRecoveryTool.

Definition at line 391 of file egammaSuperClusterBuilderBase.h.

                                                              {
    this,
    "egammaCellRecoveryTool",
    "",
    "Optional tool that adds cells in L2 or L3 "
    "that could have been rejected by timing cut"
  };

m_egammaCheckEnergyDepositTool

ToolHandle<IegammaCheckEnergyDepositTool> egammaSuperClusterBuilderBase::m_egammaCheckEnergyDepositTool

private

Initial value:

{
    this,
    "egammaCheckEnergyDepositTool",
    "",
    "Optional tool that performs basic checks of viability of cluster"
  }

Pointer to the egammaCheckEnergyDepositTool.

Definition at line 383 of file egammaSuperClusterBuilderBase.h.

                                                                          {
    this,
    "egammaCheckEnergyDepositTool",
    "",
    "Optional tool that performs basic checks of viability of cluster"
  };

m_EtThresholdCut

Gaudi::Property<float> egammaSuperClusterBuilderBase::m_EtThresholdCut

protected

Initial value:

{
    this,
    "EtThresholdCut",
    1.5 * Gaudi::Units::GeV,
    "The minimum EM Et required of SEED clusters (not applied to secondaries)"
  }

Seed selection requirements.

Definition at line 147 of file egammaSuperClusterBuilderBase.h.

                                       {
    this,
    "EtThresholdCut",
    1.5 * Gaudi::Units::GeV,
    "The minimum EM Et required of SEED clusters (not applied to secondaries)"
  };

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_extraL0L1PhiSize

float egammaSuperClusterBuilderBase::m_extraL0L1PhiSize = 0.0F

private

Definition at line 274 of file egammaSuperClusterBuilderBase.h.

m_extraL0L1PhiSizeCells

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_extraL0L1PhiSizeCells

private

Initial value:

{
    this,
    "ExtraL0L1PhiSize",
    1,
    "When adding L0 (PS) and L1 cells in phi, "
    "how much wider (+/- of the value) than the L2 phi size of the "
    "cluster (in L2 cells units) is the acceptance"
  }

"When adding L0 (PS) and L1 cells, how much wider than the L2 size of the cluster is the acceptance in phi (units of 2nd layer cells)

Definition at line 348 of file egammaSuperClusterBuilderBase.h.

                                            {
    this,
    "ExtraL0L1PhiSize",
    1,
    "When adding L0 (PS) and L1 cells in phi, "
    "how much wider (+/- of the value) than the L2 phi size of the "
    "cluster (in L2 cells units) is the acceptance"
  };

m_extraL3EtaSize

float egammaSuperClusterBuilderBase::m_extraL3EtaSize = 0.0F

private

Definition at line 276 of file egammaSuperClusterBuilderBase.h.

m_extraL3EtaSizeCells

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_extraL3EtaSizeCells

private

Initial value:

{
    this,
    "ExtraL3EtaSizeCells",
    0,
    "When adding L3 cells how much wider (+/- 0.5 of the value) "
    "than L2 (in L2 cells "
    "units) is the acceptance in eta"
  }

"When adding L3 cells, how much wider in eta than the L2

Definition at line 359 of file egammaSuperClusterBuilderBase.h.

                                          {
    this,
    "ExtraL3EtaSizeCells",
    0,
    "When adding L3 cells how much wider (+/- 0.5 of the value) "
    "than L2 (in L2 cells "
    "units) is the acceptance in eta"
  };

m_inputEgammaRecContainerKey

SG::ReadHandleKey<EgammaRecContainer> egammaSuperClusterBuilderBase::m_inputEgammaRecContainerKey

protected

Initial value:

{
    this,
    "InputEgammaRecContainerName",
    "egammaRecCollection",
    "input egammaRec container"
  }

Key for input egammaRec container.

Definition at line 155 of file egammaSuperClusterBuilderBase.h.

                                                                  {
    this,
    "InputEgammaRecContainerName",
    "egammaRecCollection",
    "input egammaRec container"
  };

m_linkToConstituents

Gaudi::Property<bool> egammaSuperClusterBuilderBase::m_linkToConstituents

private

Initial value:

{
    this,
    "LinkToConstituents",
    true,
    "Link sister clusters to new cluster"
  }

Decorate the supercluster with links to the component topoclusters.

Definition at line 280 of file egammaSuperClusterBuilderBase.h.

                                          {
    this,
    "LinkToConstituents",
    true,
    "Link sister clusters to new cluster"
  };

m_MVACalibSvc

ServiceHandle<IegammaMVASvc> egammaSuperClusterBuilderBase::m_MVACalibSvc

private

Initial value:

{ this,
                                              "MVACalibSvc",
                                              "egammaMVASvc",
                                              "calibration service" }

Handle to the MVA calibration service.

Definition at line 369 of file egammaSuperClusterBuilderBase.h.

                                            { this,
                                              "MVACalibSvc",
                                              "egammaMVASvc",
                                              "calibration service" };

m_outputEgammaRecContainerKey

SG::WriteHandleKey<EgammaRecContainer> egammaSuperClusterBuilderBase::m_outputEgammaRecContainerKey

protected

Initial value:

{
    this,
    "OutputEgammaRecContainerKey",
    "egammaSuperRecContainer",
    "output egammaRec container"
  }

Key for output egammaRec container.

Definition at line 170 of file egammaSuperClusterBuilderBase.h.

                                                                     {
    this,
    "OutputEgammaRecContainerKey",
    "egammaSuperRecContainer",
    "output egammaRec container"
  };

m_outputSuperClusterCollectionName

SG::WriteHandleKey<xAOD::CaloClusterContainer> egammaSuperClusterBuilderBase::m_outputSuperClusterCollectionName

protected

Initial value:

{
    this,
    "SuperClusterCollectionName",
    "egammaSuperClusters",
    "output calo cluster container"
  }

Key for output clusters.

Definition at line 178 of file egammaSuperClusterBuilderBase.h.

                                                                                {
    this,
    "SuperClusterCollectionName",
    "egammaSuperClusters",
    "output calo cluster container"
  };

m_precorrClustersKey

SG::WriteHandleKey<xAOD::CaloClusterContainer> egammaSuperClusterBuilderBase::m_precorrClustersKey

protected

Initial value:

{ 
    this,
    "precorrClustersName",
    "",
    "optional pre-correction clusters"
  }

Optional key for pre-correction clusters.

Definition at line 186 of file egammaSuperClusterBuilderBase.h.

                                                                 { 
    this,
    "precorrClustersName",
    "",
    "optional pre-correction clusters"
  };

m_searchWindowEtaBarrel

float egammaSuperClusterBuilderBase::m_searchWindowEtaBarrel = 0.0F

protected

Definition at line 195 of file egammaSuperClusterBuilderBase.h.

m_searchWindowEtaCellsBarrel

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_searchWindowEtaCellsBarrel

private

Initial value:

{
    this,
    "SearchWindowEtaCellsBarrel",
    5,
    "Number of cells in eta of window in which to search for topoclusters"
  }

Size of topocluster search window in eta for the barrel.

Definition at line 296 of file egammaSuperClusterBuilderBase.h.

                                                 {
    this,
    "SearchWindowEtaCellsBarrel",
    5,
    "Number of cells in eta of window in which to search for topoclusters"
  };

m_searchWindowEtaCellsEndcap

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_searchWindowEtaCellsEndcap

private

Initial value:

{
    this,
    "SearchWindowEtaCellsEndcap",
    5,
    "Number of cells in eta of window in which to search for topoclusters"
  }

Size of topocluster search window in eta for the end-cap.

Definition at line 312 of file egammaSuperClusterBuilderBase.h.

                                                 {
    this,
    "SearchWindowEtaCellsEndcap",
    5,
    "Number of cells in eta of window in which to search for topoclusters"
  };

m_searchWindowEtaEndcap

float egammaSuperClusterBuilderBase::m_searchWindowEtaEndcap = 0.0F

protected

Definition at line 197 of file egammaSuperClusterBuilderBase.h.

m_searchWindowPhiBarrel

float egammaSuperClusterBuilderBase::m_searchWindowPhiBarrel = 0.0F

protected

Definition at line 196 of file egammaSuperClusterBuilderBase.h.

m_searchWindowPhiCellsBarrel

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_searchWindowPhiCellsBarrel

private

Initial value:

{
    this,
    "SearchWindowPhiCellsBarrel",
    5,
    "Number of cells in phi of window in which to search for topoclusters"
  }

Size of topocluster search window in phi for the barrel.

Definition at line 304 of file egammaSuperClusterBuilderBase.h.

                                                 {
    this,
    "SearchWindowPhiCellsBarrel",
    5,
    "Number of cells in phi of window in which to search for topoclusters"
  };

m_searchWindowPhiCellsEndcap

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_searchWindowPhiCellsEndcap

private

Initial value:

{
    this,
    "SearchWindowPhiCellsEndcap",
    5,
    "Number of cells in phi of window in which to search for topoclusters"
  }

Size of topocluster search window in phi for the end-cap.

Definition at line 320 of file egammaSuperClusterBuilderBase.h.

                                                 {
    this,
    "SearchWindowPhiCellsEndcap",
    5,
    "Number of cells in phi of window in which to search for topoclusters"
  };

m_searchWindowPhiEndcap

float egammaSuperClusterBuilderBase::m_searchWindowPhiEndcap = 0.0F

protected

Definition at line 198 of file egammaSuperClusterBuilderBase.h.

m_useExtendedTG3

Gaudi::Property<bool> egammaSuperClusterBuilderBase::m_useExtendedTG3

private

Initial value:

{
    this,
    "UseExtendedTG3",
    false,
    "Extend TG3 definition from |eta| = 1.2 to |eta| = 1.72"
  }

Use extended TG3 definition (only after Run 2)

Definition at line 288 of file egammaSuperClusterBuilderBase.h.

                                      {
    this,
    "UseExtendedTG3",
    false,
    "Extend TG3 definition from |eta| = 1.2 to |eta| = 1.72"
  };

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.

s_cellEtaSize

float egammaSuperClusterBuilderBase::s_cellEtaSize = 0.025

staticconstexprprotected

Definition at line 136 of file egammaSuperClusterBuilderBase.h.

s_cellPhiSize

float egammaSuperClusterBuilderBase::s_cellPhiSize = M_PI / 128.

staticconstexprprotected

Definition at line 137 of file egammaSuperClusterBuilderBase.h.

s_ClEtaMaxForTG3cell

float egammaSuperClusterBuilderBase::s_ClEtaMaxForTG3cell = s_TG3Run3E4cellEtaMax + 0.03

staticconstexprprotected

Definition at line 144 of file egammaSuperClusterBuilderBase.h.

s_ClEtaMinForTG3cell

float egammaSuperClusterBuilderBase::s_ClEtaMinForTG3cell = s_TG3Run2E4cellEtaMin - 0.03

staticconstexprprotected

Definition at line 143 of file egammaSuperClusterBuilderBase.h.

s_TG3Run2E4cellEtaMax

float egammaSuperClusterBuilderBase::s_TG3Run2E4cellEtaMax = 1.6

staticconstexprprotected

Definition at line 140 of file egammaSuperClusterBuilderBase.h.

s_TG3Run2E4cellEtaMin

float egammaSuperClusterBuilderBase::s_TG3Run2E4cellEtaMin = 1.4

staticconstexprprotected

Definition at line 141 of file egammaSuperClusterBuilderBase.h.

s_TG3Run3E3cellEtaMin

float egammaSuperClusterBuilderBase::s_TG3Run3E3cellEtaMin = 1.2

staticconstexprprotected

Definition at line 139 of file egammaSuperClusterBuilderBase.h.

s_TG3Run3E4cellEtaMax

float egammaSuperClusterBuilderBase::s_TG3Run3E4cellEtaMax = 1.72

staticconstexprprotected

Definition at line 138 of file egammaSuperClusterBuilderBase.h.

---

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

• egammaSuperClusterBuilderBase.h
• egammaSuperClusterBuilderBase.cxx