photonSuperClusterBuilder Class Reference

Create supercluster under photon hypothesis. More...

#include <photonSuperClusterBuilder.h>

Inheritance diagram for photonSuperClusterBuilder:

Collaboration diagram for photonSuperClusterBuilder:

Public Member Functions
	photonSuperClusterBuilder (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override final
	should be called by the derived class in the initialize phase More...
virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...
virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
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. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
virtual StatusCode	execute (const EventContext &ctx) const override
	should be called by the derived class in the execute phase More...
virtual bool	egammaRecPassesSelection (const egammaRec *egRec) const
bool	matchesInWindow (const xAOD::CaloCluster *ref, const xAOD::CaloCluster *clus) const
	Is clus in window center around ref? More...
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. More...
bool	seedClusterSelection (const xAOD::CaloCluster *clus) const
	check if we pass the basic criteria for a seed cluster More...
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...

Protected Attributes
Gaudi::Property< float >	m_EtThresholdCut
	Seed selection requirements. More...
SG::ReadHandleKey< EgammaRecContainer >	m_inputEgammaRecContainerKey
	Key for input egammaRec container. More...
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloDetDescrMgrKey
SG::WriteHandleKey< EgammaRecContainer >	m_outputEgammaRecContainerKey
	Key for output egammaRec container. More...
SG::WriteHandleKey< xAOD::CaloClusterContainer >	m_outputSuperClusterCollectionName
	Key for output clusters. More...
SG::WriteHandleKey< xAOD::CaloClusterContainer >	m_precorrClustersKey
	Optional key for pre-correction clusters. More...
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
virtual xAOD::EgammaParameters::EgammaType	getEgammaRecType (const egammaRec *egRec) const override final
virtual StatusCode	redoMatching (const EventContext &ctx, SG::WriteHandle< EgammaRecContainer > &newEgammaRecs) const final override
virtual std::vector< std::size_t >	searchForSecondaryClusters (std::size_t photonInd, const EgammaRecContainer *egammaRecs, std::vector< bool > &isUsed) const override final
	Return extra clusters that can be added to make supercluster. More...
bool	matchesVtx (const std::vector< const xAOD::Vertex * > &seedVertices, const std::vector< xAOD::EgammaParameters::ConversionType > &seedVertexType, const egammaRec *egRec) const
	Does the cluster share conversion vertex? More...
bool	matchesVtxTrack (const std::vector< const xAOD::TrackParticle * > &seedVertexTracks, const egammaRec *egRec) const
	Does the cluster match a conversion vertex track with the seed? More...
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. More...
StatusCode	addTileGap3CellsinWindow (xAOD::CaloCluster &tofill, const CaloDetDescrManager &mgr) const
	add all tile Gap 3 cells in a window. More...
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 More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
ToolHandle< IEMConversionBuilder >	m_conversionBuilder
	Tool to retrieve the conversions. More...
Gaudi::Property< bool >	m_addClustersInWindow
	add the topoclusters in window More...
Gaudi::Property< bool >	m_addClustersMatchingVtx
	add the topoclusters matching conversion vertex More...
Gaudi::Property< bool >	m_useOnlyLeadingVertex
	use only the leading vertex for matching More...
Gaudi::Property< bool >	m_useOnlySi
	use only vertices/tracks with silicon tracks More...
Gaudi::Property< bool >	m_addClustersMatchingVtxTracks
	add the topoclusters matching conversion vertex tracks More...
Gaudi::Property< bool >	m_useOnlyLeadingTrack
	use only the leading track for matching More...
Gaudi::Property< bool >	m_doConversions
	private member flag to do the conversion building and matching More...
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. More...
Gaudi::Property< bool >	m_useExtendedTG3
	Use extended TG3 definition (only after Run 2) More...
Gaudi::Property< int >	m_searchWindowEtaCellsBarrel
	Size of topocluster search window in eta for the barrel. More...
Gaudi::Property< int >	m_searchWindowPhiCellsBarrel
	Size of topocluster search window in phi for the barrel. More...
Gaudi::Property< int >	m_searchWindowEtaCellsEndcap
	Size of topocluster search window in eta for the end-cap. More...
Gaudi::Property< int >	m_searchWindowPhiCellsEndcap
	Size of topocluster search window in phi for the end-cap. More...
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) More...
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) More...
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) More...
Gaudi::Property< int >	m_extraL3EtaSizeCells
	"When adding L3 cells, how much wider in eta than the L2 More...
ServiceHandle< IegammaMVASvc >	m_MVACalibSvc
	Handle to the MVA calibration service. More...
ToolHandle< IegammaSwTool >	m_clusterCorrectionTool
	Tool to handle cluster corrections. More...
ToolHandle< IegammaCheckEnergyDepositTool >	m_egammaCheckEnergyDepositTool
	Pointer to the egammaCheckEnergyDepositTool. More...
ToolHandle< IegammaCellRecoveryTool >	m_egammaCellRecoveryTool
	Pointer to the egammaCellRecoveryTool. More...
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Create supercluster under photon hypothesis.

The algorithm creates superclusters for photons merging topoclusters. Input containers:

• InputEgammaRecContainerName (default=egammaRecCollection): collection of EgammaRec objects to be used

Output containers:

• OutputEgammaRecContainerKey (default=PhotonSuperRecCollection): collection of EgammaRec objects with the cluster set to be the supercluster
• SuperClusterCollectionName (default=PhotonSuperClusters): collection of clusters (the supercluster)

The loop is on the clusters of the EgammaRec objects from the input container. Fist, the first cluster is considered as a seed. The cluster seed must pass some selection:

• having a second sampling with |eta| not larger than 10
• pT (from the sum of the three accordion layer) not below EtThresholdCut

Clusters to be merged in a supercluster are selected using the photonSuperClusterBuilder::searchForSecondaryClusters function. Then the procedure is redone, testing new seeds, for all the other clusters that have not been used to make superclusters. The building of the supercluster is done with egammaSuperClusterBuilderBase::createNewCluster which selects the cells to be used.

Add the end, if the property doConversions is true, the conversion matching is redone on top of new superclusters, using the tool configured by the property ConversionBuilderTool, by default EMConversionBuilder.

See also

electronSuperClusterBuilder

Definition at line 64 of file photonSuperClusterBuilder.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

photonSuperClusterBuilder()

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

Definition at line 23 of file photonSuperClusterBuilder.cxx.

  : egammaSuperClusterBuilderBase(name, pSvcLocator)
{
}

Member Function Documentation

addTileGap3CellsinWindow()

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

privateinherited

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 785 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

privateinherited

function to calibrate the new clusters energy

Calibrate with

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

Definition at line 844 of file egammaSuperClusterBuilderBase.cxx.

{
 
  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());
  //
  fillPositionsInCalo(newCluster, mgr);
  ATH_CHECK(m_MVACalibSvc->execute(*newCluster, egType));
 
  return StatusCode::SUCCESS;
}

cardinality()

unsigned int AthReentrantAlgorithm::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.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.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

protectedinherited

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 477 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() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

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

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > &  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

protectedvirtualinherited

Reimplemented in electronSuperClusterBuilder.

Definition at line 396 of file egammaSuperClusterBuilderBase.cxx.

                                                                                                     { 
  return true;
}

evtStore() [1/2]

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

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( ) const

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode egammaSuperClusterBuilderBase::execute ( const EventContext &  ctx ) const

overrideprotectedvirtualinherited

should be called by the derived class in the execute phase

Definition at line 274 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 & AthReentrantAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.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 Algorithm::extraOutputDeps();
}

fillClusterConstrained()

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

privateinherited

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 606 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 AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx ) const

inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

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

getEgammaRecType()

xAOD::EgammaParameters::EgammaType photonSuperClusterBuilder::getEgammaRecType ( const egammaRec *  egRec ) const

finaloverrideprivatevirtual

Implements egammaSuperClusterBuilderBase.

Definition at line 44 of file photonSuperClusterBuilder.cxx.

                                                                        {
  if (egRec->getNumberOfVertices() > 0) {
    return xAOD::EgammaParameters::convertedPhoton;
  }
  else {
    return xAOD::EgammaParameters::unconvertedPhoton;
  }
}

initialize()

StatusCode photonSuperClusterBuilder::initialize ( )

finaloverridevirtual

should be called by the derived class in the initialize phase

Reimplemented from egammaSuperClusterBuilderBase.

Definition at line 30 of file photonSuperClusterBuilder.cxx.

{
  ATH_MSG_DEBUG(" Initializing photonSuperClusterBuilder");
 
  // retrieve conversion builder
  if (m_doConversions) {
    ATH_CHECK(m_conversionBuilder.retrieve());
  }
 
  return egammaSuperClusterBuilderBase::initialize();
}

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 AthReentrantAlgorithm::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

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

Definition at line 44 of file AthReentrantAlgorithm.cxx.

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

matchesInWindow()

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

protectedinherited

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

matchesVtx()

bool photonSuperClusterBuilder::matchesVtx ( const std::vector< const xAOD::Vertex * > &  seedVertices, const std::vector< xAOD::EgammaParameters::ConversionType > &  seedVertexType, const egammaRec *  egRec  ) const

private

Does the cluster share conversion vertex?

Definition at line 162 of file photonSuperClusterBuilder.cxx.

{
 
  auto numTestVertices = egRec->getNumberOfVertices();
  if (m_useOnlyLeadingVertex && numTestVertices > 0) {
    numTestVertices = 1;
  }
  for (size_t seedVx = 0; seedVx < seedVertices.size(); ++seedVx) {
    if (!m_useOnlySi ||
        seedVertexType[seedVx] == xAOD::EgammaParameters::singleSi ||
        seedVertexType[seedVx] == xAOD::EgammaParameters::doubleSi) {
 
      for (size_t testVx = 0; testVx < numTestVertices; ++testVx) {
        if (seedVertices[seedVx] == egRec->vertex(testVx)) {
          return true;
        }
      }
    }
  }
  return false;
}

matchesVtxTrack()

bool photonSuperClusterBuilder::matchesVtxTrack ( const std::vector< const xAOD::TrackParticle * > &  seedVertexTracks, const egammaRec *  egRec  ) const

private

Does the cluster match a conversion vertex track with the seed?

Definition at line 188 of file photonSuperClusterBuilder.cxx.

{
  auto numTestTracks = egRec->getNumberOfTrackParticles();
  if (m_useOnlyLeadingTrack && numTestTracks > 0) {
    numTestTracks = 1;
  }
  for (const auto* seedVertexTrack : seedVertexTracks) {
    // selected tracks alread are just Si if we are only looking at Si tracks
    for (size_t testTk = 0; testTk < numTestTracks; ++testTk) {
      if (seedVertexTrack == egRec->trackParticle(testTk)) {
        return true;
      }
    }
  }
  return false;
}

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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 photonSuperClusterBuilder::redoMatching ( const EventContext &  ctx, SG::WriteHandle< EgammaRecContainer > &  newEgammaRecs  ) const

finaloverrideprivatevirtual

Reimplemented from egammaSuperClusterBuilderBase.

Definition at line 54 of file photonSuperClusterBuilder.cxx.

        {
  if (m_doConversions) {
    for (auto egRec : *newEgammaRecs) {
      if (m_conversionBuilder->executeRec(ctx, egRec).isFailure()) {
        ATH_MSG_ERROR("Problem executing conversioBuilder on photonSuperRecs");
        return StatusCode::FAILURE;
      }
    }
  }
 
  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()

std::vector< std::size_t > photonSuperClusterBuilder::searchForSecondaryClusters ( std::size_t  photonInd, const EgammaRecContainer *  egammaRecs, std::vector< bool > &  isUsed  ) const

finaloverrideprivatevirtual

Return extra clusters that can be added to make supercluster.

Parameters

photonInd	index of the EgammaRec object in the input container corresponding to the seed
egammaRecs	input container of EgammaRec
isUsed	boolean mask to avoid to reuse clusters (1=already used, 0=not used). When calling this function the element corresponding to the seed is marked as used
nWindowClusters	how many clusters are added by the matchesInWindow
nExtraClusters	how many clusters are added by the other methods

The function returns a vector of index corresponding to secondary clusters to be merged with the seed.

If there is a conversion associated to the seed cluster the conversion tracks are considered only if the conversion is single or double Si or if the UseOnlySi property is false.

The secondary cluster is added if it pass one of the functions:

• egammaSuperClusterBuilderBase::matchesInWindow
• photonSuperClusterBuilder::matchesVtx: if satellite cluster and seed cluster share a common conversion vertex
• photonSuperClusterBuilder::matchesVtxTrack: if satellite cluster and seed cluster share a common track, considering the track from the conversion vertex of the seed and the ones associated to the satellite cluster each one can be disabled using the property AddClustersInWindow, AddClustersMatchingVtx and AddClustrsMatchingVtxTracks.

Implements egammaSuperClusterBuilderBase.

Definition at line 73 of file photonSuperClusterBuilder.cxx.

{
 
  std::vector<std::size_t> secondaryIndices;
 
  const auto* const seedEgammaRec = (*egammaRecs)[seedIndex];
  const xAOD::CaloCluster* const seedCaloClus = seedEgammaRec->caloCluster();
 
  // let's determine some things about the seed
  std::vector<const xAOD::Vertex*> seedVertices;
  std::vector<xAOD::EgammaParameters::ConversionType> seedVertexType;
  std::vector<const xAOD::TrackParticle*>
    seedVertexTracks; // tracks from conversion vertex
 
  auto numVertices = seedEgammaRec->getNumberOfVertices();
  if (m_useOnlyLeadingVertex && numVertices > 0) {
    numVertices = 1;
  }
 
  for (std::size_t vx = 0; vx < numVertices; ++vx) {
    const auto* const vertex = seedEgammaRec->vertex(vx);
    const auto convType = xAOD::EgammaHelpers::conversionType(vertex);
    seedVertices.push_back(vertex);
    seedVertexType.push_back(convType);
    const bool addTracks = !m_useOnlySi ||
                           convType == xAOD::EgammaParameters::singleSi ||
                           convType == xAOD::EgammaParameters::doubleSi;
    if (addTracks) {
      for (unsigned int tp = 0; tp < vertex->nTrackParticles(); ++tp) {
        seedVertexTracks.push_back(vertex->trackParticle(tp));
      }
    }
  }
 
  // for stats
  int nWindowClusters = 0;
  int nExtraClusters = 0;
 
  // Now loop over the potential secondary clusters
  for (std::size_t i = 0; i < egammaRecs->size(); ++i) {
 
    // if already used continue
    if (isUsed[i]) {
      continue;
    }
 
    const auto* const secEgammaRec = (*egammaRecs)[i];
    const xAOD::CaloCluster* const secClus = secEgammaRec->caloCluster();
    if (!secClus) {
      ATH_MSG_WARNING(
        "The potentially secondary egammaRec does not have a cluster");
      continue;
    }
 
    bool addCluster = false;
 
    if (matchesInWindow(seedCaloClus, secClus)) {
      ATH_MSG_DEBUG("Cluster with Et: " << secClus->et()
                                        << " matched in window");
      ++nWindowClusters;
      addCluster = true;
    } else if (m_addClustersMatchingVtx &&
               matchesVtx(seedVertices, seedVertexType, secEgammaRec)) {
      ATH_MSG_DEBUG("conversion vertices match");
      addCluster = true;
      ++nExtraClusters;
    } else if (m_addClustersMatchingVtxTracks &&
               matchesVtxTrack(seedVertexTracks, secEgammaRec)) {
      ATH_MSG_DEBUG("conversion track match");
      addCluster = true;
      ++nExtraClusters;
    }
    // Add it to the list of secondary clusters if it matches.
    if (addCluster) {
      secondaryIndices.push_back(i);
      isUsed[i] = true;
    }
  }
  ATH_MSG_DEBUG("Found: " << secondaryIndices.size() << " secondaries");
  ATH_MSG_DEBUG("window clusters: " << nWindowClusters);
  ATH_MSG_DEBUG("extra clusters: " << nExtraClusters);
 
  return secondaryIndices;
}

seedClusterSelection()

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

protectedinherited

check if we pass the basic criteria for a seed cluster

Definition at line 585 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 AthReentrantAlgorithm::setFilterPassed ( bool  state, const EventContext &  ctx  ) const

inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

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

sysExecute()

StatusCode AthReentrantAlgorithm::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 67 of file AthReentrantAlgorithm.cxx.

{
  return Gaudi::Algorithm::sysExecute (ctx);
}

sysInitialize()

StatusCode AthReentrantAlgorithm::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 InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

                                                {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::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

privateinherited

Definition at line 271 of file egammaSuperClusterBuilderBase.h.

m_addCellsWindowEtaCellsBarrel

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_addCellsWindowEtaCellsBarrel

privateinherited

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.

m_addCellsWindowEtaCellsEndcap

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_addCellsWindowEtaCellsEndcap

privateinherited

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.

m_addCellsWindowEtaEndcap

float egammaSuperClusterBuilderBase::m_addCellsWindowEtaEndcap = 0.0F

privateinherited

Definition at line 272 of file egammaSuperClusterBuilderBase.h.

m_addClustersInWindow

Gaudi::Property<bool> photonSuperClusterBuilder::m_addClustersInWindow

private

Initial value:

{
    this,
    "AddClustersInWindow",
    true,
    "add the topoclusters in window"
  }

add the topoclusters in window

Definition at line 137 of file photonSuperClusterBuilder.h.

m_addClustersMatchingVtx

Gaudi::Property<bool> photonSuperClusterBuilder::m_addClustersMatchingVtx

private

Initial value:

{
    this,
    "AddClustersMatchingVtx",
    true,
    "add the topoclusters matching conversion vertex"
  }

add the topoclusters matching conversion vertex

Definition at line 145 of file photonSuperClusterBuilder.h.

m_addClustersMatchingVtxTracks

Gaudi::Property<bool> photonSuperClusterBuilder::m_addClustersMatchingVtxTracks

private

Initial value:

{
    this,
    "AddClustrsMatchingVtxTracks",
    true,
    "add the topoclusters matching conversion vertex tracks"
  }

add the topoclusters matching conversion vertex tracks

Definition at line 170 of file photonSuperClusterBuilder.h.

m_caloDetDescrMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> egammaSuperClusterBuilderBase::m_caloDetDescrMgrKey

protectedinherited

Initial value:

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

Definition at line 162 of file egammaSuperClusterBuilderBase.h.

m_clusterCorrectionTool

ToolHandle<IegammaSwTool> egammaSuperClusterBuilderBase::m_clusterCorrectionTool

privateinherited

Initial value:

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

Tool to handle cluster corrections.

Definition at line 375 of file egammaSuperClusterBuilderBase.h.

m_conversionBuilder

ToolHandle<IEMConversionBuilder> photonSuperClusterBuilder::m_conversionBuilder

private

Initial value:

{
    this,
    "ConversionBuilderTool",
    "EMConversionBuilder",
    "Tool that matches conversion vertices to egammaRecs"
  }

Tool to retrieve the conversions.

Definition at line 128 of file photonSuperClusterBuilder.h.

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_doConversions

Gaudi::Property<bool> photonSuperClusterBuilder::m_doConversions

private

Initial value:

{ this,
                                         "doConversions",
                                         true,
                                         "Boolean to do conversion matching" }

private member flag to do the conversion building and matching

Definition at line 186 of file photonSuperClusterBuilder.h.

m_egammaCellRecoveryTool

ToolHandle<IegammaCellRecoveryTool> egammaSuperClusterBuilderBase::m_egammaCellRecoveryTool

privateinherited

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.

m_egammaCheckEnergyDepositTool

ToolHandle<IegammaCheckEnergyDepositTool> egammaSuperClusterBuilderBase::m_egammaCheckEnergyDepositTool

privateinherited

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.

m_EtThresholdCut

Gaudi::Property<float> egammaSuperClusterBuilderBase::m_EtThresholdCut

protectedinherited

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.

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 AthReentrantAlgorithm::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

m_extraL0L1PhiSize

float egammaSuperClusterBuilderBase::m_extraL0L1PhiSize = 0.0F

privateinherited

Definition at line 274 of file egammaSuperClusterBuilderBase.h.

m_extraL0L1PhiSizeCells

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_extraL0L1PhiSizeCells

privateinherited

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.

m_extraL3EtaSize

float egammaSuperClusterBuilderBase::m_extraL3EtaSize = 0.0F

privateinherited

Definition at line 276 of file egammaSuperClusterBuilderBase.h.

m_extraL3EtaSizeCells

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_extraL3EtaSizeCells

privateinherited

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.

m_inputEgammaRecContainerKey

SG::ReadHandleKey<EgammaRecContainer> egammaSuperClusterBuilderBase::m_inputEgammaRecContainerKey

protectedinherited

Initial value:

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

Key for input egammaRec container.

Definition at line 155 of file egammaSuperClusterBuilderBase.h.

m_linkToConstituents

Gaudi::Property<bool> egammaSuperClusterBuilderBase::m_linkToConstituents

privateinherited

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.

m_MVACalibSvc

ServiceHandle<IegammaMVASvc> egammaSuperClusterBuilderBase::m_MVACalibSvc

privateinherited

Initial value:

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

Handle to the MVA calibration service.

Definition at line 369 of file egammaSuperClusterBuilderBase.h.

m_outputEgammaRecContainerKey

SG::WriteHandleKey<EgammaRecContainer> egammaSuperClusterBuilderBase::m_outputEgammaRecContainerKey

protectedinherited

Initial value:

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

Key for output egammaRec container.

Definition at line 170 of file egammaSuperClusterBuilderBase.h.

m_outputSuperClusterCollectionName

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

protectedinherited

Initial value:

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

Key for output clusters.

Definition at line 178 of file egammaSuperClusterBuilderBase.h.

m_precorrClustersKey

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

protectedinherited

Initial value:

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

Optional key for pre-correction clusters.

Definition at line 186 of file egammaSuperClusterBuilderBase.h.

m_searchWindowEtaBarrel

float egammaSuperClusterBuilderBase::m_searchWindowEtaBarrel = 0.0F

protectedinherited

Definition at line 195 of file egammaSuperClusterBuilderBase.h.

m_searchWindowEtaCellsBarrel

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_searchWindowEtaCellsBarrel

privateinherited

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.

m_searchWindowEtaCellsEndcap

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_searchWindowEtaCellsEndcap

privateinherited

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.

m_searchWindowEtaEndcap

float egammaSuperClusterBuilderBase::m_searchWindowEtaEndcap = 0.0F

protectedinherited

Definition at line 197 of file egammaSuperClusterBuilderBase.h.

m_searchWindowPhiBarrel

float egammaSuperClusterBuilderBase::m_searchWindowPhiBarrel = 0.0F

protectedinherited

Definition at line 196 of file egammaSuperClusterBuilderBase.h.

m_searchWindowPhiCellsBarrel

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_searchWindowPhiCellsBarrel

privateinherited

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.

m_searchWindowPhiCellsEndcap

Gaudi::Property<int> egammaSuperClusterBuilderBase::m_searchWindowPhiCellsEndcap

privateinherited

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.

m_searchWindowPhiEndcap

float egammaSuperClusterBuilderBase::m_searchWindowPhiEndcap = 0.0F

protectedinherited

Definition at line 198 of file egammaSuperClusterBuilderBase.h.

m_useExtendedTG3

Gaudi::Property<bool> egammaSuperClusterBuilderBase::m_useExtendedTG3

privateinherited

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.

m_useOnlyLeadingTrack

Gaudi::Property<bool> photonSuperClusterBuilder::m_useOnlyLeadingTrack

private

Initial value:

{
    this,
    "UseOnlyLeadingTrack",
    true,
    "use only the leading track for matching"
  }

use only the leading track for matching

Definition at line 178 of file photonSuperClusterBuilder.h.

m_useOnlyLeadingVertex

Gaudi::Property<bool> photonSuperClusterBuilder::m_useOnlyLeadingVertex

private

Initial value:

{
    this,
    "UseOnlyLeadingVertex",
    true,
    "use only the leading vertex for matching"
  }

use only the leading vertex for matching

Definition at line 153 of file photonSuperClusterBuilder.h.

m_useOnlySi

Gaudi::Property<bool> photonSuperClusterBuilder::m_useOnlySi

private

Initial value:

{
    this,
    "UseOnlySi",
    true,
    "use only vertices/tracks with silicon tracks for adding sec. clusters "
    "(Mix not considered Si)"
  }

use only vertices/tracks with silicon tracks

Definition at line 161 of file photonSuperClusterBuilder.h.

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

constexpr float egammaSuperClusterBuilderBase::s_cellEtaSize = 0.025

staticconstexprprotectedinherited

Definition at line 136 of file egammaSuperClusterBuilderBase.h.

s_cellPhiSize

constexpr float egammaSuperClusterBuilderBase::s_cellPhiSize = M_PI / 128.

staticconstexprprotectedinherited

Definition at line 137 of file egammaSuperClusterBuilderBase.h.

s_ClEtaMaxForTG3cell

constexpr float egammaSuperClusterBuilderBase::s_ClEtaMaxForTG3cell = s_TG3Run3E4cellEtaMax + 0.03

staticconstexprprotectedinherited

Definition at line 144 of file egammaSuperClusterBuilderBase.h.

s_ClEtaMinForTG3cell

constexpr float egammaSuperClusterBuilderBase::s_ClEtaMinForTG3cell = s_TG3Run2E4cellEtaMin - 0.03

staticconstexprprotectedinherited

Definition at line 143 of file egammaSuperClusterBuilderBase.h.

s_TG3Run2E4cellEtaMax

constexpr float egammaSuperClusterBuilderBase::s_TG3Run2E4cellEtaMax = 1.6

staticconstexprprotectedinherited

Definition at line 140 of file egammaSuperClusterBuilderBase.h.

s_TG3Run2E4cellEtaMin

constexpr float egammaSuperClusterBuilderBase::s_TG3Run2E4cellEtaMin = 1.4

staticconstexprprotectedinherited

Definition at line 141 of file egammaSuperClusterBuilderBase.h.

s_TG3Run3E3cellEtaMin

constexpr float egammaSuperClusterBuilderBase::s_TG3Run3E3cellEtaMin = 1.2

staticconstexprprotectedinherited

Definition at line 139 of file egammaSuperClusterBuilderBase.h.

s_TG3Run3E4cellEtaMax

constexpr float egammaSuperClusterBuilderBase::s_TG3Run3E4cellEtaMax = 1.72

staticconstexprprotectedinherited

Definition at line 138 of file egammaSuperClusterBuilderBase.h.

---

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

• photonSuperClusterBuilder.h
• photonSuperClusterBuilder.cxx