CaloClusterMaker.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
//-----------------------------------------------------------------------
// File and Version Information:
//
// Description: see CaloClusterMaker.h
// 
// Environment:
//      Software developed for the ATLAS Detector at CERN LHC
//
// Author List:
//      Sven Menke
//
// Modified: Feb 09, 2005 (DLelas)
//          - CaloClusterMaker applies correction type tool on a whole 
//            cluster collection now. Needed for Sliding Window
//            cell weights calculation.
//
// Modified Feb 2014 (W Lampl)
//          - Migrate to xAOD::CaloCluster(Container)
//          - Move to AthAlgorithm, some simplifications
//-----------------------------------------------------------------------
 
//-----------------------
// This Class's Header --
//-----------------------
#include "CaloClusterMaker.h"
 
//---------------
// C++ Headers --
//---------------
#include "xAODCaloEvent/CaloClusterContainer.h"
#include "xAODCaloEvent/CaloClusterAuxContainer.h"
#include "CaloEvent/CaloClusterCellLinkContainer.h"
 
#include "CaloUtils/CaloClusterSignalState.h"
#include "CaloUtils/CaloClusterStoreHelper.h"
#include "AthenaKernel/errorcheck.h"
 
#include "GaudiKernel/IChronoStatSvc.h"
 
#include "StoreGate/WriteDecorHandle.h"
#include "xAODTrigCalo/CaloClusterTrigAuxContainer.h"
 
//###############################################################################
CaloClusterMaker::CaloClusterMaker(const std::string& name, 
                   ISvcLocator* pSvcLocator) 
  : AthReentrantAlgorithm(name, pSvcLocator)
  , m_clusterOutput("")
  , m_clusterCellLinkOutput("")
  , m_clusterMakerTools(this)
  , m_clusterCorrectionTools(this)
  , m_chrono("ChronoStatSvc", name)
  , m_saveSignalState(true)
  , m_chronoTools(false)
{
 
  // Name of Cluster Container to be registered in TDS
  declareProperty("ClustersOutputName",m_clusterOutput);  
  declareProperty("ClusterCellLinkOutputName",m_clusterCellLinkOutput);  
  
  // Name(s) of Cluster Maker Tools
  declareProperty("ClusterMakerTools",m_clusterMakerTools);
 
  // Name(s) of Cluster Correction Tools
  declareProperty("ClusterCorrectionTools",m_clusterCorrectionTools);
 
  // Name(s) of Cluster Correction Tools (even field) to trigger the
  // recording of the current cluster container in StoreGate before
  // its execution and the corresponding container name(s) (odd
  // fields). This property and KeepEachCorrection are mutually
  // exclusive
  //declareProperty("KeepCorrectionToolAndContainerNames",  m_keepCorrectionToolAndContainerNames);
 
  // save uncalibrated cluster signal state 
  declareProperty("SaveUncalibratedSignalState",m_saveSignalState);
 
  //Make Chrono Auditors for Cluster maker and correction tools
  declareProperty("ChronoTools", m_chronoTools);
}
 
//###############################################################################
 
CaloClusterMaker::~CaloClusterMaker()
= default;
 
//###############################################################################
 
StatusCode CaloClusterMaker::initialize()
{
 
 
  if (m_clusterMakerTools.retrieve().isFailure()) {
    ATH_MSG_ERROR("Failed to retrieve maker ToolHandleArray "
                  << m_clusterMakerTools);
  } else {
    ATH_MSG_DEBUG("Successfully retrieved maker ToolHandleArray "
                  << m_clusterMakerTools);
  }
  
  if (m_clusterCorrectionTools.retrieve().isFailure()) {
    ATH_MSG_ERROR("Failed to retrieve correction ToolHandleArray "
                  << m_clusterCorrectionTools);
  } else {
    ATH_MSG_DEBUG("Successfully retrieved correction ToolHandleArray "
                  << m_clusterCorrectionTools);
  }
 
  if (m_chronoTools) {
    msg(MSG::INFO) << "Will use ChronoStatSvc to monitor ClusterMaker and ClusterCorrection tools" << endmsg;
    ATH_CHECK( m_chrono.retrieve() );
  }
 
  ATH_CHECK( m_clusterOutput.initialize() );
 
  if (m_clusterCellLinkOutput.key().empty()) {
    m_clusterCellLinkOutput = m_clusterOutput.key() + "_links";
  }
  ATH_CHECK( m_clusterCellLinkOutput.initialize() );
 
  if (m_writeTriggerSpecificInfo) {
    m_mDecor_ncells = m_clusterOutput.key() + "." + m_mDecor_ncells.key();
  }
  ATH_CHECK(m_mDecor_ncells.initialize(m_writeTriggerSpecificInfo));
  
  return StatusCode::SUCCESS;
}
 
//###############################################################################
 
StatusCode CaloClusterMaker::finalize() {
  return StatusCode::SUCCESS;
}
 
//###############################################################################
 
StatusCode CaloClusterMaker::execute (const EventContext& ctx) const
{
 
  // make a Cluster Container 
  SG::WriteHandle<xAOD::CaloClusterContainer> clusColl (m_clusterOutput, ctx);
 
  if (m_writeTriggerSpecificInfo) {
      ATH_CHECK( clusColl.record(std::make_unique<xAOD::CaloClusterContainer>(),
                 std::make_unique<xAOD::CaloClusterTrigAuxContainer>()) );
  }
  else {
    ATH_CHECK(CaloClusterStoreHelper::AddContainerWriteHandle(clusColl));
  }
    
  ToolHandleArray<CaloClusterCollectionProcessor>::const_iterator toolIt, toolIt_e; //Iterators over Tool handles
  toolIt=m_clusterMakerTools.begin();
  toolIt_e=m_clusterMakerTools.end();
  
  //Make Clusters: Execute each maker tool
  //for (CaloClusterCollectionProcessor& tool :  m_clusterMakerTools) {  //Doesn't work because CaloClusterCollectionProcessor is a base class
  for(;toolIt!=toolIt_e;++toolIt) {
    const std::string chronoName = this->name() + "_" +toolIt->name();
    if (m_chronoTools) m_chrono->chronoStart(chronoName);
    ATH_CHECK((*toolIt)->execute(ctx, clusColl.ptr()));
    if (m_chronoTools) m_chrono->chronoStop(chronoName);
  } //End loop over maker tools
 
  // PL set calibrated state
  if ( m_saveSignalState ) {
    //Fixme: Maybe this loop would auto-vectorize breaking into four separate loops for each quantity
    for (xAOD::CaloCluster* fClus : *clusColl) {
      ATH_MSG_DEBUG( "found cluster with state "<< fClus->signalState());
      fClus->setRawE(fClus->calE());
      fClus->setRawEta(fClus->calEta());
      fClus->setRawPhi(fClus->calPhi());
      fClus->setRawM(fClus->calM());    
    }//end loop over clusters
  }
 
 
  //Apply corrections: Exectue each correction tool
  //for (CaloClusterCollectionProcessor* tool :  m_clusterCorrectionTools) { //Doesn't work because CaloClusterCollectionProcessor is a base class
  toolIt=m_clusterCorrectionTools.begin();
  toolIt_e=m_clusterCorrectionTools.end();
  for(;toolIt!=toolIt_e;++toolIt) {
    const std::string& toolname=(*toolIt).name();
 
    ATH_MSG_DEBUG(" Applying correction = " << toolname);
    const std::string chronoName = this->name() + "_" + toolname;
    if (m_chronoTools) m_chrono->chronoStart(chronoName);
    ATH_CHECK((*toolIt)->execute(ctx, clusColl.ptr()));
    if (m_chronoTools) m_chrono->chronoStop(chronoName);
  }//End loop over correction tools
 
  if (m_writeTriggerSpecificInfo) {
    SG::WriteDecorHandle<xAOD::CaloClusterContainer, int> decor_handle(m_mDecor_ncells, ctx);
 
    for (const xAOD::CaloCluster * cl : *clusColl) {
      const CaloClusterCellLink * cell_links = cl->getCellLinks();
      if (!cell_links) {
        decor_handle(*cl) = 0;
      }
      else {
        decor_handle(*cl) = cell_links->size();
      }
    }
  }
 
  ATH_MSG_DEBUG("Created cluster container with " << clusColl->size() << " clusters");
  SG::WriteHandle<CaloClusterCellLinkContainer> cellLinks (m_clusterCellLinkOutput, ctx);
  ATH_CHECK( cellLinks.record (std::make_unique<CaloClusterCellLinkContainer>()) );
  CaloClusterStoreHelper::finalizeClusters (ctx, clusColl, cellLinks);
 
  return StatusCode::SUCCESS;
}
 
 
const std::string& CaloClusterMaker::getOutputContainerName() const {
  return m_clusterOutput.key();
}