CaloCalibClusterMomentsMaker2.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOCALIBHITREC_CALOCALIBCLUSTERMOMENTSMAKER2_H
#define CALOCALIBHITREC_CALOCALIBCLUSTERMOMENTSMAKER2_H
 
class CaloCell_ID;
class CaloDM_ID;
class CaloDmDescrManager;
class CaloDetDescrManager;
class McEventCollection;
class TruthParticleContainer;
 
#include "GaudiKernel/ToolHandle.h" 
 
#include "CaloUtils/CaloClusterCollectionProcessor.h"
#include "CaloGeoHelpers/CaloSampling.h"
#include "CaloIdentifier/CaloCell_ID.h"
#include "CaloDmDetDescr/CaloDmDescrManager.h"
#include "CaloSimEvent/CaloCalibrationHitContainer.h"
#include "StoreGate/ReadHandleKeyArray.h"
 
#include "xAODTruth/TruthParticleContainer.h"
 
#include <string>
#include <vector>
#include <set>
#include <map>
#include <atomic>
#include <array>
 
class CaloCalibClusterMomentsMaker2: public AthAlgTool, virtual public CaloClusterCollectionProcessor
{
 public:
 
  class CalibHitIPhiIEtaRange {
    public:
      char iPhi,iEtaMin,iEtaMax;
  };
 
  class MyCellInfo {
    public:
      MyCellInfo(int iClus, double w)
      {
        m_ClusWeights.emplace_back(iClus, w);
      }
      void Add(const MyCellInfo& other)
      {
        for (const std::pair<int, double>& p : other.m_ClusWeights) {
          m_ClusWeights.push_back( p );
        }
      }
      std::vector<std::pair<int, double> > m_ClusWeights;
  };
 
  typedef std::map<Identifier, MyCellInfo> CellInfoSet_t;
 
  class MyClusInfo {
    public:
      class ClusCalibEnergy {
        public:
          double engTot;
          std::vector<double > engSmp;
          ClusCalibEnergy() : engTot(0) { engSmp.resize(CaloSampling::Unknown+1, 0.0); }
          void Add(double eng, int nsmp)
          {
            engTot += eng;
            engSmp[nsmp] +=eng;
          }
      };
 
      MyClusInfo() : engCalibOut(0), engCalibDead(0) {
        engCalibDeadInArea.resize(CaloDmDescrArea::DMA_MAX,0.0);
        engCalibParticle.clear();
      }
 
      void Add(double eng, int nsmp, int pid = 0)
      {
        engCalibIn.Add(eng, nsmp);
        std::map<int, ClusCalibEnergy>::iterator pos = engCalibParticle.find(pid);
        if(pos != engCalibParticle.end()) {
          pos->second.Add(eng, nsmp);
        }else{
          ClusCalibEnergy tmp;
          tmp.Add(eng, nsmp);
          engCalibParticle[pid] = tmp;
        }
      }
 
      ClusCalibEnergy engCalibIn;
      double engCalibOut;
      double engCalibDead;
      std::vector<double > engCalibDeadInArea;
      std::map<int, ClusCalibEnergy > engCalibParticle;
  };
  typedef std::vector<MyClusInfo> ClusInfo_t;
 
 
  typedef std::pair<std::string,xAOD::CaloCluster::MomentType> 
  moment_name_pair;
 
  typedef std::vector<moment_name_pair> moment_name_vector;
 
  typedef std::set<moment_name_pair> moment_name_set;
 
  CaloCalibClusterMomentsMaker2(const std::string& type, const std::string& name,
                 const IInterface* parent);
 
 
  using CaloClusterCollectionProcessor::execute;
  virtual StatusCode execute(const EventContext& ctx,
                             xAOD::CaloClusterContainer* theClusColl) const override;
  virtual StatusCode initialize() override;
 
 private:
 
  std::vector<std::string>  m_momentsNames; 
 
  moment_name_vector m_validNames;
 
  moment_name_set m_validMoments;
 
  std::vector<std::string>  m_momentsNamesAOD; 
 
  std::set<xAOD::CaloCluster::MomentType>  m_momentsAOD; 
 
  SG::ReadHandleKeyArray<CaloCalibrationHitContainer> m_CalibrationHitContainerNames;
 
  SG::ReadHandleKeyArray<CaloCalibrationHitContainer> m_DMCalibrationHitContainerNames;
 
  SG::ReadHandleKey<xAOD::TruthParticleContainer> m_truthParticleContainerKey{this,"TruthParticles","TruthParticles","ReadHandleKey for truth particle container"};
  
  SG::ReadCondHandleKey<CaloDetDescrManager> m_caloDetDescrMgrKey{this,"CaloDetDescrManager", "CaloDetDescrManager"};
 
  const CaloCell_ID* m_calo_id;
 
  const CaloDM_ID*    m_caloDM_ID;
 
  const CaloDmDescrManager* m_caloDmDescrManager; 
 
  int m_n_phi_out;
  int m_n_eta_out;
  double m_out_phi_max;
  double m_out_eta_max;
 
  double m_rmaxOut[3];
 
  std::array<std::vector<std::vector<CalibHitIPhiIEtaRange>>,3>  m_i_phi_eta;
 
  mutable std::atomic<bool> m_foundAllContainers{};
 
  enum keys_dm_energy_sharing {kMatchDmOff, kMatchDmLoose, kMatchDmMedium, kMatchDmTight};
  enum keys_calib_frac_origin {kCalibFracEM, kCalibFracHAD, kCalibFracREST, kCalibFracMax};
 
  bool m_doDeadEnergySharing;
  bool m_doOutOfClusterL;
  bool m_doOutOfClusterM;
  bool m_doOutOfClusterT;
  bool m_doDeadL;
  bool m_doDeadM;
  bool m_doDeadT;
  bool m_useParticleID;
  bool m_doCalibFrac;
  float m_energyMin;
  float m_energyMinCalib;
  float m_apars_alpha;
  float m_apars_r0;
  int m_MatchDmType;
 
  static double angle_mollier_factor(double x) ;
  void get_calib_frac(const std::map<unsigned int,int>& truthBarcodeToPdgCodeMap,
                      const MyClusInfo& clusInfo, std::vector<double> &engFrac) const;
};
 
#endif // CALOCALIBCLUSTERMOMENTSMAKER2_H