electronSuperClusterBuilder Class Reference

Create supercluster under electron hypothesis. More...

#include <electronSuperClusterBuilder.h>

Inheritance diagram for electronSuperClusterBuilder:

Collaboration diagram for electronSuperClusterBuilder:

Public Member Functions
	electronSuperClusterBuilder (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override final
	should be called by the derived class in the initialize phase
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
virtual StatusCode	execute (const EventContext &ctx) const override
	should be called by the derived class in the execute phase
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
virtual bool	egammaRecPassesSelection (const egammaRec *egRec) const override final
virtual xAOD::EgammaParameters::EgammaType	getEgammaRecType (const egammaRec *egRec) const override final
virtual StatusCode	redoMatching (const EventContext &ctx, SG::WriteHandle< EgammaRecContainer > &newEgammaRecs) const override final
virtual std::vector< std::size_t >	searchForSecondaryClusters (const size_t i, const EgammaRecContainer *, std::vector< bool > &isUsed) const override final
	Search for secondary clusters.
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
Gaudi::Property< int >	m_maxDelEtaCells
	Size of maximum search window in eta.
Gaudi::Property< int >	m_maxDelPhiCells
	Size of maximum search window in phi.
Gaudi::Property< std::size_t >	m_numberOfPixelHits
Gaudi::Property< std::size_t >	m_numberOfSiHits
ToolHandle< IEMTrackMatchBuilder >	m_trackMatchBuilder
	Tool to perform track matching.
Gaudi::Property< bool >	m_doTrackMatching
	private member flag to do the track matching
float	m_maxDelEta {}
float	m_maxDelPhi {}
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

Create supercluster under electron hypothesis.

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

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

Output containers:

• OutputEgammaRecContainerKey (default=ElectronSuperRecCollection): collection of EgammaRec objects with the cluster set to be the supercluster
• SuperClusterCollectionName (default=ElectronSuperClusters): 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
• having at least one track with minimum number of Pixel and Si hits ( NumberOfReqPixelHits, NumberOfReqSiHits)

Clusters to be merged in a supercluster are selected using the electronSuperClusterBuilder::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 doTrackMatching is true the track matching is redone on top of new superclusters, using the tool configured by the property TrackMatchBuilderTool, by default EMTrackMatchBuilder.

See also

photonSuperClusterBuilder

Definition at line 71 of file electronSuperClusterBuilder.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

electronSuperClusterBuilder()

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

Definition at line 38 of file electronSuperClusterBuilder.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 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

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

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 electronSuperClusterBuilder::egammaRecPassesSelection ( const egammaRec * egRec ) const

finaloverrideprivatevirtual

Reimplemented from egammaSuperClusterBuilderBase.

Definition at line 63 of file electronSuperClusterBuilder.cxx.

                                                                                       {
  // We need tracks
  if (egRec->getNumberOfTrackParticles() == 0) {
    return false;
  }
  const xAOD::TrackParticle *trackParticle = egRec->trackParticle(0);
  using xAOD::EgammaHelpers::summaryValueInt;
  // with possible pixel
  uint8_t nPixelHits = summaryValueInt(*trackParticle, xAOD::numberOfPixelDeadSensors, 0);
  nPixelHits += summaryValueInt(*trackParticle, xAOD::numberOfPixelHits, 0); 
  if (nPixelHits < m_numberOfPixelHits) {
    return false;
  }
  // and with silicon (add SCT to pixel)
  uint8_t nSiHits = nPixelHits;
  nSiHits += summaryValueInt(*trackParticle, xAOD::numberOfSCTHits, 0);
  return nSiHits >= m_numberOfSiHits;
};

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

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

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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

getEgammaRecType()

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

finaloverrideprivatevirtual

Implements egammaSuperClusterBuilderBase.

Definition at line 83 of file electronSuperClusterBuilder.cxx.

                                                                                           {
  return xAOD::EgammaParameters::electron;
}

initialize()

StatusCode electronSuperClusterBuilder::initialize ( )

finaloverridevirtual

should be called by the derived class in the initialize phase

Reimplemented from egammaSuperClusterBuilderBase.

Definition at line 46 of file electronSuperClusterBuilder.cxx.

{
  ATH_MSG_DEBUG(" Initializing electronSuperClusterBuilder");
 
  // Additional Window we search in
  m_maxDelPhi = m_maxDelPhiCells * s_cellPhiSize * 0.5;
  m_maxDelEta = m_maxDelEtaCells * s_cellEtaSize * 0.5;
 
  // retrieve track match builder
  if (m_doTrackMatching) {
    ATH_CHECK(m_trackMatchBuilder.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 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

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

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

finaloverrideprivatevirtual

Reimplemented from egammaSuperClusterBuilderBase.

Definition at line 88 of file electronSuperClusterBuilder.cxx.

        {
  if (m_doTrackMatching) {
    ATH_CHECK(m_trackMatchBuilder->executeRec(ctx, newEgammaRecs.ptr()));
  }
 
  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() [1/2]

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

protectedpure virtualinherited

Implemented in egammaSuperClusterBuilder, and photonSuperClusterBuilder.

searchForSecondaryClusters() [2/2]

std::vector< std::size_t > electronSuperClusterBuilder::searchForSecondaryClusters ( const size_t i, const EgammaRecContainer * , std::vector< bool > & isUsed ) const

finaloverrideprivatevirtual

Search for secondary clusters.

Parameters

i	index of the seed cluster
isUsed	booleand mask of already used cluster

Returns

vector of index of the satellites

Only clusters that have not already been used are considered. The satellite is added if:

• matches the seed in a narrow window OR
• is inside the window for additonal criteria AND matches the same track

The first condition is evaluated with egammaSuperClusterBuilderBase.matchesInWindow. The second condition is evaluated using MaxWindowDelEtaCells and MaxWindowDelPhiCells and electronSuperClusterBuilder.matchSameTrack

Definition at line 100 of file electronSuperClusterBuilder.cxx.

{
  // assume egammaRecs != 0, since the ReadHadler is valid
  // assume seed egammaRec has a valid cluster, since it has been already used
  std::vector<std::size_t> secondaryIndices;
 
  const auto* const seedEgammaRec = (*egammaRecs)[seedIndex];
  const xAOD::CaloCluster* const seedCaloClus = seedEgammaRec->caloCluster();
 
  const xAOD::TrackParticle* seedTrackParticle = seedEgammaRec->trackParticle();
 
  // 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();
    // Now perform a number of tests to see if the cluster should be added
 
    const auto seedSecdEta = std::abs(seedCaloClus->eta() - secClus->eta());
    const auto seedSecdPhi =
      std::abs(P4Helpers::deltaPhi(seedCaloClus->phi(), secClus->phi()));
 
    const bool addCluster =
      (matchesInWindow(seedCaloClus, secClus) ||
       ((seedSecdEta < m_maxDelEta && seedSecdPhi < m_maxDelPhi) &&
        (matchSameTrack(*seedTrackParticle, *secEgammaRec))));
    // 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");
  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 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

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.

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

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.

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

m_addCellsWindowEtaEndcap

float egammaSuperClusterBuilderBase::m_addCellsWindowEtaEndcap = 0.0F

privateinherited

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

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

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.

                                                   {
    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_doTrackMatching

Gaudi::Property<bool> electronSuperClusterBuilder::m_doTrackMatching

private

Initial value:

{
    this,
      "doTrackMatching",
      true,
      "Boolean to do track matching" }

private member flag to do the track matching

Definition at line 153 of file electronSuperClusterBuilder.h.

                                       {
    this,
      "doTrackMatching",
      true,
      "Boolean to do track matching" };

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.

                                                              {
    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

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.

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

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.

                                       {
    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

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.

                                            {
    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

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.

                                          {
    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

protectedinherited

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

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.

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

m_maxDelEta

float electronSuperClusterBuilder::m_maxDelEta {}

private

Definition at line 159 of file electronSuperClusterBuilder.h.

{};

m_maxDelEtaCells

Gaudi::Property<int> electronSuperClusterBuilder::m_maxDelEtaCells

private

Initial value:

{
    this,
    "MaxWindowDelEtaCells",
    5,
    "Size of maximum search window in eta"
  }

Size of maximum search window in eta.

Definition at line 116 of file electronSuperClusterBuilder.h.

                                     {
    this,
    "MaxWindowDelEtaCells",
    5,
    "Size of maximum search window in eta"
  };

m_maxDelPhi

float electronSuperClusterBuilder::m_maxDelPhi {}

private

Definition at line 160 of file electronSuperClusterBuilder.h.

{};

m_maxDelPhiCells

Gaudi::Property<int> electronSuperClusterBuilder::m_maxDelPhiCells

private

Initial value:

{
    this,
    "MaxWindowDelPhiCells",
    12,
    "Size of maximum search window in phi"
  }

Size of maximum search window in phi.

Definition at line 123 of file electronSuperClusterBuilder.h.

                                     {
    this,
    "MaxWindowDelPhiCells",
    12,
    "Size of maximum search window in phi"
  };

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.

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

m_numberOfPixelHits

Gaudi::Property<std::size_t> electronSuperClusterBuilder::m_numberOfPixelHits

private

Initial value:

{
    this,
    "NumberOfReqPixelHits",
    0,
    "Number of required pixel hits for electrons"
  }

Definition at line 130 of file electronSuperClusterBuilder.h.

                                              {
    this,
    "NumberOfReqPixelHits",
    0,
    "Number of required pixel hits for electrons"
  };

m_numberOfSiHits

Gaudi::Property<std::size_t> electronSuperClusterBuilder::m_numberOfSiHits

private

Initial value:

{
    this,
    "NumberOfReqSiHits",
    7,
    "Number of required silicon hits for electrons"
  }

Definition at line 137 of file electronSuperClusterBuilder.h.

                                           {
    this,
    "NumberOfReqSiHits",
    7,
    "Number of required silicon hits for electrons"
  };

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

m_searchWindowPhiEndcap

float egammaSuperClusterBuilderBase::m_searchWindowPhiEndcap = 0.0F

protectedinherited

Definition at line 198 of file egammaSuperClusterBuilderBase.h.

m_trackMatchBuilder

ToolHandle<IEMTrackMatchBuilder> electronSuperClusterBuilder::m_trackMatchBuilder

private

Initial value:

{
    this,
    "TrackMatchBuilderTool",
    "EMTrackMatchBuilder",
    "Tool that matches tracks to egammaRecs"
  }

Tool to perform track matching.

Definition at line 145 of file electronSuperClusterBuilder.h.

                                                      {
    this,
    "TrackMatchBuilderTool",
    "EMTrackMatchBuilder",
    "Tool that matches tracks to egammaRecs"
  };

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.

                                      {
    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

staticconstexprprotectedinherited

Definition at line 136 of file egammaSuperClusterBuilderBase.h.

s_cellPhiSize

float egammaSuperClusterBuilderBase::s_cellPhiSize = M_PI / 128.

staticconstexprprotectedinherited

Definition at line 137 of file egammaSuperClusterBuilderBase.h.

s_ClEtaMaxForTG3cell

float egammaSuperClusterBuilderBase::s_ClEtaMaxForTG3cell = s_TG3Run3E4cellEtaMax + 0.03

staticconstexprprotectedinherited

Definition at line 144 of file egammaSuperClusterBuilderBase.h.

s_ClEtaMinForTG3cell

float egammaSuperClusterBuilderBase::s_ClEtaMinForTG3cell = s_TG3Run2E4cellEtaMin - 0.03

staticconstexprprotectedinherited

Definition at line 143 of file egammaSuperClusterBuilderBase.h.

s_TG3Run2E4cellEtaMax

float egammaSuperClusterBuilderBase::s_TG3Run2E4cellEtaMax = 1.6

staticconstexprprotectedinherited

Definition at line 140 of file egammaSuperClusterBuilderBase.h.

s_TG3Run2E4cellEtaMin

float egammaSuperClusterBuilderBase::s_TG3Run2E4cellEtaMin = 1.4

staticconstexprprotectedinherited

Definition at line 141 of file egammaSuperClusterBuilderBase.h.

s_TG3Run3E3cellEtaMin

float egammaSuperClusterBuilderBase::s_TG3Run3E3cellEtaMin = 1.2

staticconstexprprotectedinherited

Definition at line 139 of file egammaSuperClusterBuilderBase.h.

s_TG3Run3E4cellEtaMax

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:

• electronSuperClusterBuilder.h
• electronSuperClusterBuilder.cxx