CaloRescaleNoise.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "CaloRescaleNoise.h"
#include "CaloConditions/CaloNoise.h"
#include "CaloIdentifier/CaloGain.h"
#include "CaloEvent/CaloCell.h"
#include "Identifier/Identifier.h"
#include "CaloIdentifier/CaloCell_Base_ID.h"
#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
 
#include "TTree.h"
#include <cstdio>
 
//Constructor
CaloRescaleNoise::CaloRescaleNoise(const std::string& name, ISvcLocator* pSvcLocator):
  AthAlgorithm(name,pSvcLocator)
{
}
 
//__________________________________________________________________________
//Destructor
CaloRescaleNoise::~CaloRescaleNoise() = default;
 
//__________________________________________________________________________
StatusCode CaloRescaleNoise::initialize()
{
  ATH_MSG_DEBUG ("CaloRescaleNoise initialize()" );
  ATH_CHECK(m_thistSvc.retrieve());
 
  const CaloIdManager* mgr = nullptr;
  ATH_CHECK( detStore()->retrieve( mgr ) );
  m_calo_id      = m_isSC ? static_cast<const CaloCell_Base_ID*>(mgr->getCaloCell_SuperCell_ID()) : static_cast<const CaloCell_Base_ID*>(mgr->getCaloCell_ID());
 
  ATH_CHECK( m_elecNoiseKey.initialize() );
  ATH_CHECK( m_pileupNoiseKey.initialize() );
 
  ATH_CHECK( m_scaleCorrKey.initialize(!m_absScaling) );
  ATH_CHECK( m_cablingKey.initialize());
  ATH_CHECK( m_onlineScaleCorrKey.initialize() );
  ATH_CHECK( m_caloMgrKey.initialize() );
  ATH_CHECK( m_caloSCMgrKey.initialize(m_isSC) );
 
  m_tree = new TTree("mytree","Calo Noise ntuple");
  m_tree->Branch("iCool",&m_iCool,"iCool/I");
  m_tree->Branch("iSubHash",&m_SubHash,"iSubHash/I");
  m_tree->Branch("iHash",&m_Hash,"iHash/I");
  m_tree->Branch("iOffId",&m_OffId,"iOffId/I");
  m_tree->Branch("eta",&m_eta,"eta/F");
  m_tree->Branch("phi",&m_phi,"phi/F");
  m_tree->Branch("layer",&m_layer,"layer/I");
  m_tree->Branch("iGain",&m_Gain,"iGain/I");
  m_tree->Branch("ElecNoise",&m_elecNoise,"ElecNoise/F");
  m_tree->Branch("PileupNoise",&m_pileupNoise,"PileupNoise/F");
  m_tree->Branch("ElecNoiseRescaled",&m_elecNoiseRescaled,"ElecNoiseRescaled/F");
 
  ATH_CHECK( m_thistSvc->regTree("/file1/calonoise/mytree",m_tree) );
  ATH_MSG_INFO ( " end of CaloRescaleNoise::initialize " );
  return StatusCode::SUCCESS; 
}
//__________________________________________________________________________
StatusCode CaloRescaleNoise::execute(const EventContext& /*ctx*/)
{
  ATH_MSG_DEBUG ("CaloRescaleNoise execute()" );
  return StatusCode::SUCCESS; 
}
 
//__________________________________________________________________________
StatusCode CaloRescaleNoise::stop()
{
  const EventContext& ctx = Gaudi::Hive::currentContext();
  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey,ctx};
  const LArOnOffIdMapping* cabling{*cablingHdl};
  if(!cabling) {
     ATH_MSG_ERROR( "Do not have cabling mapping from key " << m_cablingKey.key() );
     return StatusCode::FAILURE;
  }
 
  FILE* fp = std::fopen("calonoise.txt","w");
  if (!fp) {
    ATH_MSG_ERROR("Cannot open file calonoise.txt: " << strerror(errno));
    return StatusCode::FAILURE;
  }
 
  const ILArHVScaleCorr *scaleCorr = nullptr;
  if(!m_absScaling) {
     SG::ReadCondHandle<ILArHVScaleCorr> scaleCorrHdl (m_scaleCorrKey, ctx);
     scaleCorr = *scaleCorrHdl;
  }
  SG::ReadCondHandle<ILArHVScaleCorr> onlineScaleCorr (m_onlineScaleCorrKey, ctx);
  SG::ReadCondHandle<CaloNoise> elecNoise   (m_elecNoiseKey,   ctx);
  SG::ReadCondHandle<CaloNoise> pileupNoise (m_pileupNoiseKey, ctx);
 
  const CaloDetDescrManager_Base *calodetdescrmgr=nullptr;
  if(m_isSC){
     SG::ReadCondHandle<CaloSuperCellDetDescrManager> caloSCMgrHandle{m_caloSCMgrKey, ctx};
     if( not caloSCMgrHandle.isValid()){
       std::fclose(fp);
       ATH_MSG_ERROR("CaloRescaleNoise::stop: caloSCMgrHandle invalid.");
       return StatusCode::FAILURE;
     }
     calodetdescrmgr = static_cast<const CaloDetDescrManager_Base *>(*caloSCMgrHandle);
 
  } else {
     SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey, ctx};
     if( not caloMgrHandle.isValid()){
       std::fclose(fp);
       ATH_MSG_ERROR("CaloRescaleNoise::stop: caloMgrHandle invalid.");
       return StatusCode::FAILURE;
     }
     calodetdescrmgr = static_cast<const CaloDetDescrManager_Base *>(*caloMgrHandle);
  }
 
  int ncell=m_calo_id->calo_cell_hash_max();
  ATH_MSG_INFO ( " start loop over Calo cells " << ncell );
  for (int i=0;i<ncell;i++) {
       IdentifierHash idHash=i;
       Identifier id=m_calo_id->cell_id(idHash);
       HWIdentifier hwid=cabling->createSignalChannelID(id);
       const CaloDetDescrElement* calodde = calodetdescrmgr->get_element(id);
       int subCalo;
       IdentifierHash idSubHash = m_calo_id->subcalo_cell_hash (idHash, subCalo);
 
       int iCool=-1;
       if (m_calo_id->is_em(id)) {    // EM calo
         if (m_calo_id->is_em_barrel(id)) {
            if (m_calo_id->pos_neg(id) > 0 )
               iCool=2;
            else
               iCool=1;
         }
         if (m_calo_id->is_em_endcap(id)) {
            if (m_calo_id->pos_neg(id) > 0 )
               iCool=3;
            else
               iCool=0;
         }
   
       }
       if (m_calo_id->is_hec(id)) {   // HEC
        iCool=16;
       }
       if (m_calo_id->is_fcal(id)) {   // Fcal
        iCool=32;
       }
       if (m_calo_id->is_tile(id)) {   // Tile
        iCool=48;
       }
       int ii = (int) (idSubHash);
 
       m_iCool = iCool;
       m_SubHash = ii;
       m_Hash =  i;
       m_OffId = (int)(id.get_identifier32().get_compact());
 
       m_eta = calodde->eta_raw();
       m_phi = calodde->phi_raw();
       m_layer = m_calo_id->calo_sample(id);
 
       int ngain;
       if (m_isSC) ngain=1;
       else if (subCalo<3) ngain=3;    
       else ngain=4;
 
       float hvcorr=1.;
       float hvonline=1.;
 
       if (iCool<48) {
          if(!m_absScaling) hvcorr = scaleCorr->HVScaleCorr(hwid);
          hvonline = onlineScaleCorr->HVScaleCorr(hwid);
       }
 
       for (int igain=0;igain<ngain;igain++) {
 
          CaloGain::CaloGain gain=CaloGain::LARHIGHGAIN;
          if (subCalo<3) {
           if (igain==0) gain=CaloGain::LARHIGHGAIN;
           if (igain==1) gain=CaloGain::LARMEDIUMGAIN;
           if (igain==2) gain=CaloGain::LARLOWGAIN;
          } 
          else {
           if (igain==0) gain=CaloGain::TILELOWLOW;
           if (igain==1) gain=CaloGain::TILELOWHIGH;
           if (igain==2) gain=CaloGain::TILEHIGHLOW;
           if (igain==3) gain=CaloGain::TILEHIGHHIGH;
          }
          m_Gain = igain;
 
          m_elecNoise   = elecNoise->getNoise(id,gain);
          m_pileupNoise = pileupNoise->getNoise(id,gain);
 
          if (hvonline>0.) {
             if (m_absScaling) {
                m_elecNoiseRescaled = m_elecNoise*hvonline;
                if (iCool<48 && m_elecNoise>0. && hvonline > 1.) {
                    ATH_MSG_WARNING ( " Abs. scaled Noise cell " << m_Hash  <<
                                      " layer/ieta/iphi " << m_calo_id->sampling(id) << " " << m_calo_id->eta(id) << " " << m_calo_id->phi(id) << " OldNoise,NewNoise " <<
                                         m_elecNoise << " " << m_elecNoiseRescaled );
                }
             } else {
                m_elecNoiseRescaled = m_elecNoise*hvcorr;
                if (iCool<48 && m_elecNoise>0. && std::fabs(m_elecNoiseRescaled/m_elecNoise-1.)>0.05) {
                    ATH_MSG_WARNING ( " DifferentNoise  cell " << m_calo_id->show_to_string(id) <<
                                      " layer/eta/phi " << m_layer << " " << m_eta << " " << m_phi << " OldNoise,NewNoise " <<
                                         m_elecNoise << " " << m_elecNoiseRescaled );
                }
             }
          } else {
             m_elecNoiseRescaled = m_elecNoise ;
          }
 
          // for SC debugging
          if (iCool<48) fprintf(fp,"%10d %5d %5d %5d %8.3f %8.3f\n",id.get_identifier32().get_compact(),iCool,ii,gain,m_elecNoiseRescaled,m_pileupNoise);
 
          m_tree->Fill();
 
       }   // loop over gains
 
  }        // loop over cells
 
  std::fclose(fp);
  return StatusCode::SUCCESS;
 }