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 std::vector<std::pair<int, double> > {
    public:
      MyCellInfo(int iClus, double w) { this->emplace_back(iClus, w); }
      void Add(const MyCellInfo& other) { this->insert(this->end(),other.begin(), other.end()); }
  };
 
  typedef std::map<Identifier, MyCellInfo> CellInfoSet_t;

  class MyClusInfo {
    public:
      class ClusCalibEnergy {
        public:
          double engTot = 0.0;
          std::array<double,CaloSampling::Unknown+1> engSmp;
          void Add(double eng, int nsmp)
          {
            engTot += eng;
            engSmp[nsmp] +=eng;
          }
      };
 
      void Add(double eng, int nsmp, int pid = 0)
      {
        engCalibIn.Add(eng, nsmp);
        engCalibParticle[pid].Add(eng, nsmp);
      }
 
      ClusCalibEnergy engCalibIn;
      double engCalibOut  = 0.0;
      double engCalibDead = 0.0;
      std::array<double,CaloDmDescrArea::DMA_MAX> 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) ;
};
 
#endif // CALOCALIBCLUSTERMOMENTSMAKER2_H