ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
GetLCSinglePionsPerf Class Reference

Top algorithm to get local hadronic calibration performance plots for single pions. More...

#include <GetLCSinglePionsPerf.h>

Inheritance diagram for GetLCSinglePionsPerf:
Collaboration diagram for GetLCSinglePionsPerf:

Public Member Functions

 GetLCSinglePionsPerf (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~GetLCSinglePionsPerf ()
 
virtual StatusCode initialize ()
 
virtual StatusCode execute ()
 
virtual StatusCode finalize ()
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static double angle_mollier_factor (double x)
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
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. More...
 

Private Types

enum  keys_topo { kTOPO_EM, kTOPO_W, kTOPO_OOC, kTOPO }
 
enum  keys_tagged { kTAGEM, kTAGHAD, kTAGUNK, kTAG }
 
enum  keys_momsums {
  kMOM_CLS0, kMOM_CLS1, kMOM_CLS2, kMOM_SUMCLS,
  kMOM_MISS, kMOM_MCENER
}
 
enum  keys_norm_level { kLEVEL_PARTICLE, kLEVEL_CALIBHIT, kLEVEL_CALIBHIT_IDEAL }
 
typedef std::pair< std::string, xAOD::CaloCluster::MomentType > moment_name_pair
 
typedef std::vector< moment_name_pair > moment_name_vector
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

int fill_reco (const xAOD::CaloClusterContainer &clusColl, const EventContext &ctx)
 
int fill_moments (const xAOD::CaloClusterContainer &clusColl, const EventContext &ctx)
 
int fill_calibhits (const xAOD::CaloClusterContainer &clusColl, const EventContext &ctx)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

const AtlasDetectorID * m_id_helper
 
const CaloCell_ID * m_calo_id
 
const CaloDmDescrManager * m_caloDmDescrManager
 
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_clusterBasicCollName
 
SG::ReadHandleKeyArray< xAOD::CaloClusterContainer > m_clusterCollNames
 
std::string m_outputFileName
 
TFile * m_outputFile
 
SG::ReadHandleKeyArray< CaloCalibrationHitContainer > m_CalibrationHitContainerNames
 
SG::ReadHandleKeyArray< CaloCalibrationHitContainer > m_DMCalibrationHitContainerNames
 
moment_name_vector m_validMoments
 
double m_distance_cut
 
int m_netabin
 
float m_etamin
 
float m_etamax
 
float m_deta
 
int m_nphibin
 
float m_phimin
 
float m_phimax
 
float m_dphi
 
int m_nlogenerbin
 
float m_logenermin
 
float m_logenermax
 
int m_nlogenerbin2
 
float m_dlogener
 
int m_nnormtype
 
int m_ncluscoll
 
int m_ntagcases
 
int m_nmoments
 
int m_nmomsums
 
float m_truthPiEngFraction
 
bool m_doEngRecOverTruth
 
bool m_doEngTag
 
bool m_doEngRecSpect
 
bool m_doEngNoiseClus
 
bool m_doClusMoments
 
bool m_doRecoEfficiency
 
bool m_useRecoEfficiency
 
bool m_useGoodClus
 
bool m_doCalibHitsValidation
 
bool m_usePionClusters
 
std::vector< std::vector< std::vector< TProfile * > > > m_engRecOverTruth_vs_eta
 
std::vector< std::vector< std::vector< TProfile * > > > m_engRecOverTruth_vs_ebeam
 
std::vector< std::vector< TProfile * > > m_engTag_vs_eta
 
std::vector< std::vector< TProfile * > > m_engTag_vs_ebeam
 
std::vector< std::vector< std::vector< TH1F * > > > m_engRecSpect
 
std::vector< std::vector< TH1F * > > m_engPionSpect
 
std::vector< std::vector< TH1F * > > m_engNoiseClusSpect
 
std::vector< TProfile * > m_engNoiseClus_vs_eta
 
std::vector< std::vector< std::vector< TProfile * > > > m_clusMoment_vs_eta
 
std::vector< std::vector< std::vector< TProfile * > > > m_clusMoment_vs_ebeam
 
std::vector< TH1F * > m_RecoEfficiency_vs_eta [2]
 
std::vector< TH1F * > m_RecoEfficiency_vs_ebeam [2]
 
std::vector< TProfile * > m_SumCalibHitOverEbeam_vs_eta
 
std::vector< TProfile * > m_DefaultCalculatorOverEbeam_vs_eta
 
std::vector< TProfile * > m_SumCalibHitAssignedOverEbeam_vs_eta
 
std::vector< TProfile2D * > m_SumCalibHitAssignedOverEbeam_vs_etaphi
 
double m_mc_ener
 
double m_mc_eta
 
double m_mc_phi
 
int m_mc_etabin
 
int m_mc_enerbin
 
int m_mc_phibin
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Top algorithm to get local hadronic calibration performance plots for single pions.

Version
$Id: GetLCSinglePionsPerf.h,v 1.1 2009-07-01 14:36:01 pospelov Exp $
Author
Gennady Pospelov guenn.nosp@m.adi..nosp@m.pospe.nosp@m.lov@.nosp@m.cern..nosp@m.ch
Date
1-July-2009

Definition at line 37 of file GetLCSinglePionsPerf.h.

Member Typedef Documentation

◆ moment_name_pair

typedef std::pair<std::string,xAOD::CaloCluster::MomentType> GetLCSinglePionsPerf::moment_name_pair
private

Definition at line 50 of file GetLCSinglePionsPerf.h.

◆ moment_name_vector

typedef std::vector<moment_name_pair> GetLCSinglePionsPerf::moment_name_vector
private

Definition at line 51 of file GetLCSinglePionsPerf.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ keys_momsums

enum GetLCSinglePionsPerf::keys_momsums
private
Enumerator
kMOM_CLS0 
kMOM_CLS1 
kMOM_CLS2 
kMOM_SUMCLS 
kMOM_MISS 
kMOM_MCENER 

Definition at line 55 of file GetLCSinglePionsPerf.h.

55 {kMOM_CLS0, kMOM_CLS1, kMOM_CLS2, kMOM_SUMCLS, kMOM_MISS, kMOM_MCENER};

◆ keys_norm_level

enum GetLCSinglePionsPerf::keys_norm_level
private
Enumerator
kLEVEL_PARTICLE 
kLEVEL_CALIBHIT 
kLEVEL_CALIBHIT_IDEAL 

Definition at line 56 of file GetLCSinglePionsPerf.h.

56 {kLEVEL_PARTICLE, kLEVEL_CALIBHIT, kLEVEL_CALIBHIT_IDEAL };

◆ keys_tagged

enum GetLCSinglePionsPerf::keys_tagged
private
Enumerator
kTAGEM 
kTAGHAD 
kTAGUNK 
kTAG 

Definition at line 54 of file GetLCSinglePionsPerf.h.

54 {kTAGEM, kTAGHAD, kTAGUNK, kTAG};

◆ keys_topo

enum GetLCSinglePionsPerf::keys_topo
private
Enumerator
kTOPO_EM 
kTOPO_W 
kTOPO_OOC 
kTOPO 

Definition at line 53 of file GetLCSinglePionsPerf.h.

53 {kTOPO_EM, kTOPO_W, kTOPO_OOC, kTOPO};

Constructor & Destructor Documentation

◆ GetLCSinglePionsPerf()

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

Definition at line 59 of file GetLCSinglePionsPerf.cxx.

60  : AthAlgorithm(name, pSvcLocator),
61  m_id_helper(nullptr),
62  m_calo_id(nullptr),
63  m_caloDmDescrManager(nullptr),
64  m_outputFileName("CheckSinglePionsReco.root"),
65  m_outputFile(nullptr),
66  m_distance_cut(1.5),
67  m_netabin(25), m_etamin(0.0), m_etamax(5.0),
68  m_deta(0),
69  m_nphibin(1), m_phimin(-M_PI), m_phimax(M_PI),
70  m_dphi(0),
71  m_nlogenerbin(22), m_logenermin(2.0), m_logenermax(6.4),
72  m_nlogenerbin2(3),
73  m_dlogener(0),
74  m_nnormtype(3),
75  m_ncluscoll(4),
76  m_ntagcases(3),
77  m_nmoments(0),
78  m_nmomsums(6),
79  m_truthPiEngFraction(0.1),
80  m_doEngRecOverTruth(true),
81  m_doEngTag(true),
82  m_doEngRecSpect(true),
83  m_doEngNoiseClus(true),
84  m_doClusMoments(true),
85  m_doRecoEfficiency(true),
86  m_useRecoEfficiency(false),
87  m_useGoodClus(false),
88  m_doCalibHitsValidation(true),
89  m_mc_ener(0),
90  m_mc_eta(0),
91  m_mc_phi(0),
92  m_mc_etabin(0),
93  m_mc_enerbin(0),
94  m_mc_phibin(0)
95 {
96  // collection name where cluster always have moments
97  declareProperty("ClusterBasicCollName",m_clusterBasicCollName);
98 
99  // collections names after different correction steps
100  declareProperty("ClusterCollectionNames",m_clusterCollNames);
101 
102  // distance cut for clusters to calcuate engReco
103  declareProperty("DistanceCut",m_distance_cut);
104 
105  // Name of output file to save histograms in
106  declareProperty("OutputFileName",m_outputFileName);
107 
108  // Names of CalibrationHitContainers to use
109  declareProperty("CalibrationHitContainerNames",m_CalibrationHitContainerNames);
110  declareProperty("DMCalibrationHitContainerNames",m_DMCalibrationHitContainerNames);
111 
112  // to create different types of validation histograms
113  declareProperty("doEngRecOverTruth",m_doEngRecOverTruth);
114  declareProperty("doEngTag",m_doEngTag);
115  declareProperty("doEngRecSpect",m_doEngRecSpect);
116  declareProperty("doEngNoiseClus",m_doEngNoiseClus);
117  declareProperty("doClusMoments",m_doClusMoments);
118  declareProperty("doRecoEfficiency",m_doRecoEfficiency);
119  declareProperty("useRecoEfficiency",m_useRecoEfficiency);
120  declareProperty("useGoodClus",m_useGoodClus);
121 
122  declareProperty("etamin",m_etamin);
123  declareProperty("etamax",m_etamax);
124  declareProperty("netabin",m_netabin);
125 
126  declareProperty("phimin",m_phimin);
127  declareProperty("phimax",m_phimax);
128  declareProperty("nphibin",m_nphibin);
129 
130  declareProperty("logenermin",m_logenermin);
131  declareProperty("logenermax",m_logenermax);
132  declareProperty("nlogenerbin",m_nlogenerbin);
133 
134  declareProperty("doCalibHitsValidation",m_doCalibHitsValidation);
135 // Only use clusters that contain at least m_truthPiEngFraction % of the true pion energy
136  declareProperty("usePionClustersOnly",m_usePionClusters);
137 
138  // dead material identifier description manager
139  m_caloDmDescrManager = CaloDmDescrManager::instance();
140 
141  m_validMoments.resize(0);
142  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_TOT"),xAOD::CaloCluster::ENG_CALIB_TOT));
143  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_OUT_L"),xAOD::CaloCluster::ENG_CALIB_OUT_L));
144  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TOT"),xAOD::CaloCluster::ENG_CALIB_DEAD_TOT));
145  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_EMB0"),xAOD::CaloCluster::ENG_CALIB_DEAD_EMB0));
146  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TILE0"),xAOD::CaloCluster::ENG_CALIB_DEAD_TILE0));
147  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TILEG3"),xAOD::CaloCluster::ENG_CALIB_DEAD_TILEG3));
148  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_EME0"),xAOD::CaloCluster::ENG_CALIB_DEAD_EME0));
149  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_HEC0"),xAOD::CaloCluster::ENG_CALIB_DEAD_HEC0));
150  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_FCAL"),xAOD::CaloCluster::ENG_CALIB_DEAD_FCAL));
151  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_LEAKAGE"),xAOD::CaloCluster::ENG_CALIB_DEAD_LEAKAGE));
152  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_UNCLASS"),xAOD::CaloCluster::ENG_CALIB_DEAD_UNCLASS));
153 
154  m_nmoments = m_validMoments.size();
155 
156 }

◆ ~GetLCSinglePionsPerf()

GetLCSinglePionsPerf::~GetLCSinglePionsPerf ( )
virtual

Definition at line 163 of file GetLCSinglePionsPerf.cxx.

164 {
165 
166 }

Member Function Documentation

◆ angle_mollier_factor()

double GetLCSinglePionsPerf::angle_mollier_factor ( double  x)
static

Definition at line 1288 of file GetLCSinglePionsPerf.cxx.

1289 {
1290  double eta = fabs(x);
1291  double ff;
1292  if(eta<1.6){
1293  ff = atan(5.0*1.7/(200.0*cosh(eta)));
1294  }else if(eta<3.2){
1295  ff = atan(5.0*1.6/(420./tanh(eta)));
1296  }else{
1297  ff = atan(5.0*0.95/(505./tanh(eta)));
1298  }
1299  return ff*(1./atan(5.0*1.7/200.0));
1300 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode GetLCSinglePionsPerf::execute ( )
virtual

Definition at line 654 of file GetLCSinglePionsPerf.cxx.

655 {
656  const EventContext& ctx = getContext();
657 
658  /* ********************************************
659  reading particles
660  ******************************************** */
661  const McEventCollection* truthEvent=nullptr;
662  ATH_CHECK( evtStore()->retrieve(truthEvent, "TruthEvent") );
663 
664  if( truthEvent->at(0)->particles_empty() ){
665  ATH_MSG_ERROR( "No particles in McEventCollection" );
666  return StatusCode::FAILURE;
667  }
668 #ifdef HEPMC3
669  const HepMC::ConstGenParticlePtr& gen=truthEvent->at(0)->particles().front();
670 #else
671  HepMC::GenEvent::particle_const_iterator pit = truthEvent->at(0)->particles_begin();
672  const HepMC::GenParticle *gen = (*pit);
673 #endif
674  m_mc_eta = gen->momentum().pseudoRapidity();
675  m_mc_phi = gen->momentum().phi();
676  m_mc_ener = gen->momentum().e();
677 
678  // energy and eta bins for particle
679  m_mc_enerbin = int( (log10(m_mc_ener) - m_logenermin)/m_dlogener);
680  m_mc_etabin = int((fabs(m_mc_eta)-m_etamin)/m_deta);
681  m_mc_phibin = int((m_mc_phi-m_phimin)/m_dphi);
682 
683  if(m_mc_etabin <0 || m_mc_etabin >= m_netabin || m_mc_enerbin <0 || m_mc_enerbin >= m_nlogenerbin || m_mc_phibin !=0) return StatusCode::SUCCESS;
684 
685  SG::ReadHandle<xAOD::CaloClusterContainer> clusColl (m_clusterBasicCollName, ctx);
686  if(clusColl->empty()) {
687  ATH_MSG_WARNING( "Empty ClusterContainer " << m_clusterBasicCollName );
688  return StatusCode::SUCCESS;
689  }
690 
691  // check that we have at least one meaningfull cluster
692  if(m_doRecoEfficiency) {
693  bool PionWasReconstructed = false;
694  float engClusCalibThs = 1.0*MeV;
695  HepLorentzVector hlv_pion(1,0,0,1);
696  hlv_pion.setREtaPhi(1./cosh(m_mc_eta),m_mc_eta,m_mc_phi);
697  for (const xAOD::CaloCluster* theCluster : *clusColl) {
698  double mx_calib_tot;
699  if( !theCluster->retrieveMoment( xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot) ) {
700  ATH_MSG_ERROR( "Moment ENG_CALIB_TOT is absent" );
701  }
702  double mx_dens, mx_center_lambda;
703  if (!theCluster->retrieveMoment(xAOD::CaloCluster::CENTER_LAMBDA, mx_center_lambda))
704  mx_center_lambda = 0;
705  if (!theCluster->retrieveMoment(xAOD::CaloCluster::FIRST_ENG_DENS, mx_dens))
706  mx_dens = 0;
707 
708  HepLorentzVector hlv_cls(1,0,0,1);
709  hlv_cls.setREtaPhi(1./cosh(theCluster->eta()), theCluster->eta(), theCluster->phi());
710  double r = hlv_pion.angle(hlv_cls.vect());
711  if(r < m_distance_cut*angle_mollier_factor(m_mc_eta)
712  && mx_calib_tot > engClusCalibThs
713  && theCluster->size() > 1
714  && mx_dens > 0
715  && mx_center_lambda != 0.0 ) {
716  PionWasReconstructed = true;
717  break;
718  }
719  }
720  if(PionWasReconstructed){
721  m_RecoEfficiency_vs_ebeam[0][m_mc_etabin]->Fill(m_mc_ener);
722  m_RecoEfficiency_vs_eta[0][m_mc_enerbin]->Fill(m_mc_eta);
723  }
724  m_RecoEfficiency_vs_ebeam[1][m_mc_etabin]->Fill(m_mc_ener);
725  m_RecoEfficiency_vs_eta[1][m_mc_enerbin]->Fill(m_mc_eta);
726  if(m_useRecoEfficiency && !PionWasReconstructed) return StatusCode::SUCCESS;
727  }
728 
729  if(m_doEngRecSpect) {
730  m_engPionSpect[m_mc_enerbin][m_mc_etabin]->Fill(m_mc_ener);
731  }
732 
733  if(m_doEngRecOverTruth || m_doEngTag || m_doEngRecSpect || m_doEngNoiseClus){
734  fill_reco (*clusColl, ctx);
735  }
736 
737  if(m_doClusMoments) {
738  fill_moments (*clusColl, ctx);
739  }
740 
741  if(m_doCalibHitsValidation) {
742  fill_calibhits (*clusColl, ctx);
743  }
744 
745  return StatusCode::SUCCESS;
746 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< 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 & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ fill_calibhits()

int GetLCSinglePionsPerf::fill_calibhits ( const xAOD::CaloClusterContainer &  clusColl,
const EventContext &  ctx 
)
private

Definition at line 1167 of file GetLCSinglePionsPerf.cxx.

1169 {
1170  /* ********************************************
1171  reading calibration containers
1172  ******************************************** */
1173  std::vector<const CaloCalibrationHitContainer *> v_cchc;
1174  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& k : m_CalibrationHitContainerNames) {
1175  SG::ReadHandle<CaloCalibrationHitContainer> cchc (k, ctx);
1176  v_cchc.push_back(cchc.cptr());
1177  }
1178 
1179  std::vector<const CaloCalibrationHitContainer *> v_dmcchc;
1180  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& k : m_DMCalibrationHitContainerNames) {
1181  SG::ReadHandle<CaloCalibrationHitContainer> cchc (k, ctx);
1182  v_dmcchc.push_back(cchc.cptr());
1183  }
1184 
1185  // calculate total calibration energy int active+inactive hits
1186  double engCalibTot = 0.0;
1187  for (const CaloCalibrationHitContainer* cchc : v_cchc) {
1188  //loop over cells in calibration container
1189  for (const CaloCalibrationHit* hit : *cchc) {
1190  Identifier myId = hit->cellID();
1191  if(!myId.is_valid()) {
1192  ATH_MSG_ERROR("Error! Bad identifier " << myId << " in container '" << cchc->Name() << "',"
1193  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
1194  continue;
1195  }
1196  if(!m_id_helper->is_lar(myId) && !m_id_helper->is_tile(myId)) {
1197  ATH_MSG_ERROR("Error! Bad identifier (nor lar or tile) " << myId << " in container '" << cchc->Name() << "',"
1198  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
1199  continue;
1200  }
1201  engCalibTot += hit->energyTotal();
1202  }
1203  }
1204 
1205  // calibration energy in dead material
1206  double engCalibDeadTot = 0.0;
1207  double engDefaultCalculator = 0.0;
1208  for (const CaloCalibrationHitContainer* dmcchc : v_dmcchc) {
1209  //loop over cells in calibration container
1210  for (const CaloCalibrationHit* hit : *dmcchc) {
1211  Identifier myId = hit->cellID();
1212  if(!myId.is_valid()) {
1213  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Bad dead material identifier " << myId << " in container '" << dmcchc->Name() << "',"
1214  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
1215  continue;
1216  }
1217  if(!m_id_helper->is_lar_dm(myId) && !m_id_helper->is_tile_dm(myId)) {
1218  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Bad dead material identifier (nor lar_dm or tile_dm) " << myId << " in container '" << dmcchc->Name() << "',"
1219  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
1220  continue;
1221  }
1222  engCalibDeadTot += hit->energyTotal();
1223  //
1224  CaloDmDescrElement* myCDDE(nullptr);
1225  myCDDE = m_caloDmDescrManager->get_element(myId);
1226  if( !myCDDE ) {
1227  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Absent DM description element!");
1228  continue;
1229  }
1230  int nDmArea = m_caloDmDescrManager->get_dm_area(myId);
1231  if(nDmArea == CaloDmDescrArea::DMA_DEFCALC) engDefaultCalculator += hit->energyTotal();
1232  }
1233  }
1234 
1235  // calibration energy assigned to one or another cluster
1236  // retrieving cluster moments
1237  double engCalibAssigned = 0.0;
1238  double engClusSumCalibPresOnly = 0.0;
1239  for (const xAOD::CaloCluster* theCluster : clusColl) {
1240  double mx_calib_tot, mx_calib_ooc, mx_calib_dm;
1241 // if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot)
1242 // || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_OUT_L, mx_calib_ooc)
1243 // || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_DEAD_TOT mx_calib_dm)){
1244 // ATH_MSG_ERROR("One of the moment ENG_CALIB_TOT, ENG_CALIB_OUT_L, ENG_CALIB_DEAD_TOT is absent");
1245 // }
1246  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot) ){
1247  ATH_MSG_WARNING("Moment ENG_CALIB_TOT is absent");
1248  }
1249  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_OUT_L, mx_calib_ooc) ){
1250  ATH_MSG_WARNING("Moment ENG_CALIB_OUT_L is absent" );
1251  }
1252  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_DEAD_TOT, mx_calib_dm) ){
1253  ATH_MSG_WARNING("Moment ENG_CALIB_DEAD_TOT is absent");
1254  }
1255  engCalibAssigned += (mx_calib_tot + mx_calib_ooc + mx_calib_dm);
1256 
1257  double mx_calib_emb0, mx_calib_eme0, mx_calib_tileg3;
1258  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EMB0, mx_calib_emb0)
1259  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EME0, mx_calib_eme0)
1260  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TILEG3, mx_calib_tileg3)){
1261  ATH_MSG_WARNING("One of the moment ENG_CALIB_EMB0, ENG_CALIB_EME0, ENG_CALIB_TILEG3 is absent");
1262  }else{
1263  engClusSumCalibPresOnly += (mx_calib_emb0+mx_calib_eme0+mx_calib_tileg3);
1264  }
1265 
1266  } // iClus
1267  // energy in presamplers is included already in the dead material
1268  engCalibAssigned -= engClusSumCalibPresOnly;
1269 
1270  int n_enerbin = int( (log10(m_mc_ener) - m_logenermin)/ ((m_logenermax - m_logenermin)/m_nlogenerbin2));
1271  // sum of moments assigned to clusters wrt total sum of moment
1272  m_SumCalibHitOverEbeam_vs_eta[n_enerbin]->Fill(m_mc_eta, (engCalibTot+engCalibDeadTot)/m_mc_ener);
1273 // m_SumCalibHitOverEbeam_vs_ebeam[m_mc_etabin]->Fill(m_mc_ener, (engCalibTot+engCalibDeadTot)/m_mc_ener);
1274  m_SumCalibHitAssignedOverEbeam_vs_eta[n_enerbin]->Fill(m_mc_eta, engCalibAssigned/m_mc_ener);
1275  m_SumCalibHitAssignedOverEbeam_vs_etaphi[n_enerbin]->Fill(m_mc_eta, m_mc_phi, engCalibAssigned/m_mc_ener);
1276 
1277  m_DefaultCalculatorOverEbeam_vs_eta[n_enerbin]->Fill(m_mc_eta, engDefaultCalculator/m_mc_ener);
1278 // m_DefaultCalculatorOverEbeam_vs_ebeam[m_mc_etabin]->Fill(m_mc_ener, engDefaultCalculator/m_mc_ener);
1279 
1280  return 0;
1281 }

◆ fill_moments()

int GetLCSinglePionsPerf::fill_moments ( const xAOD::CaloClusterContainer &  clusColl,
const EventContext &  ctx 
)
private

Definition at line 944 of file GetLCSinglePionsPerf.cxx.

946 {
947  ATH_MSG_DEBUG("GetLCSinglePionsPerf::fill_moments got cont. size: "<<clusColl.size());
948  /* ********************************************
949  reading calibration containers
950  ******************************************** */
951  std::vector<const CaloCalibrationHitContainer *> v_cchc;
952  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& k : m_CalibrationHitContainerNames) {
953  SG::ReadHandle<CaloCalibrationHitContainer> cchc (k, ctx);
954  v_cchc.push_back(cchc.cptr());
955  }
956 
957  std::vector<const CaloCalibrationHitContainer *> v_dmcchc;
958  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& k : m_DMCalibrationHitContainerNames) {
959  SG::ReadHandle<CaloCalibrationHitContainer> cchc (k, ctx);
960  v_dmcchc.push_back(cchc.cptr());
961  }
962 
963  // calculate total calibration energy int active+inactive hits
964  double engCalibTot = 0.0;
965  std::vector<double > engCalibTotSmp;
966  engCalibTotSmp.resize(CaloSampling::Unknown, 0.0);
967  for (const CaloCalibrationHitContainer* cchc : v_cchc) {
968  //loop over cells in calibration container
969  for (const CaloCalibrationHit* hit : *cchc) {
970  Identifier myId = hit->cellID();
971  if(!myId.is_valid()) {
972  ATH_MSG_WARNING("Error! Bad identifier " << myId << " in container '" << cchc->Name() << "',"
973  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
974  continue;
975  }
976  if(!m_id_helper->is_lar(myId) && !m_id_helper->is_tile(myId)) {
977  ATH_MSG_WARNING("Error! Bad identifier (nor lar or tile) " << myId << " in container '" << cchc->Name() << "',"
978  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
979  continue;
980  }
981 
982  CaloSampling::CaloSample nsmp = CaloSampling::CaloSample(m_calo_id->calo_sample(myId));
983  engCalibTot += hit->energyTotal();
984  engCalibTotSmp[nsmp] += hit->energyTotal();
985  }
986  }
987 
988 
989  double engCalibDeadTot = 0.0;
990  std::vector<double > engCalibDeadTotInArea;
991  engCalibDeadTotInArea.resize(CaloDmDescrArea::DMA_MAX,0.0);
992  for (const CaloCalibrationHitContainer* dmcchc : v_dmcchc) {
993  //loop over cells in calibration container
994  for (const CaloCalibrationHit* hit : *dmcchc) {
995  Identifier myId = hit->cellID();
996  if(!myId.is_valid()) {
997  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Bad dead material identifier " << myId << " in container '" << dmcchc->Name() << "',"
998  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
999  continue;
1000  }
1001  if(!m_id_helper->is_lar_dm(myId) && !m_id_helper->is_tile_dm(myId)) {
1002  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Bad dead material identifier (nor lar_dm or tile_dm) " << myId << " in container '" << dmcchc->Name() << "',"
1003  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
1004  continue;
1005  }
1006  engCalibDeadTot += hit->energyTotal();
1007  //
1008  CaloDmDescrElement* myCDDE(nullptr);
1009  myCDDE = m_caloDmDescrManager->get_element(myId);
1010  if( !myCDDE ) {
1011  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Absent DM description element!");
1012  continue;
1013  }
1014  int nDmArea = m_caloDmDescrManager->get_dm_area(myId);
1015  engCalibDeadTotInArea[nDmArea] += hit->energyTotal();
1016  engCalibDeadTotInArea[CaloDmDescrArea::DMA_ALL] += hit->energyTotal();
1017  }
1018  }
1019 // double engCalibDeadTotWithPres = engCalibDeadTot + engCalibTotSmp[CaloSampling::PreSamplerB]
1020 // + engCalibTotSmp[CaloSampling::PreSamplerE]
1021 // + engCalibTotSmp[CaloSampling::TileGap3];
1022 
1023  /* ********************************************
1024  reading clusters moments
1025  ******************************************** */
1026  double engClusSumCalib(0);
1027  double engClusSumCalibPresOnly(0);
1028  std::vector<std::vector<double > > clsMoments; // [iClus][m_nmoments]
1029  clsMoments.resize(clusColl.size());
1030  std::vector<double > clsMomentsSum; // [m_nmoments]
1031  clsMomentsSum.resize(m_nmoments,0.0);
1032 
1033  // retrieving cluster moments
1034  unsigned int iClus = -1;
1035  for (const xAOD::CaloCluster* theCluster : clusColl) {
1036  ++iClus;
1037  clsMoments[iClus].resize(m_validMoments.size(),0.0);
1038  int iMoment=0;
1039  for(moment_name_vector::const_iterator im=m_validMoments.begin(); im!=m_validMoments.end(); ++im, ++iMoment){
1040  double mx;
1041  if( theCluster->retrieveMoment((*im).second, mx) ) {
1042  clsMoments[iClus][iMoment] = mx;
1043  }else{
1044  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Can't retrieve moment " << (*im).first << " " << (*im).second);
1045  }
1046  clsMomentsSum[iMoment] += clsMoments[iClus][iMoment];
1047  }
1048  double mx;
1049  if(theCluster->retrieveMoment( xAOD::CaloCluster::ENG_CALIB_TOT, mx ) ){
1050  engClusSumCalib += mx;
1051  }else{
1052  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Can't retrieve moment xAOD::CaloCluster::ENG_CALIB_TOT ");
1053  }
1054  double mx_calib_emb0, mx_calib_eme0, mx_calib_tileg3;
1055  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EMB0, mx_calib_emb0)
1056  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EME0, mx_calib_eme0)
1057  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TILEG3, mx_calib_tileg3)){
1058  ATH_MSG_WARNING("One of the moment ENG_CALIB_EMB0, ENG_CALIB_EME0, ENG_CALIB_TILEG3 is absent");
1059  }else{
1060  engClusSumCalibPresOnly += (mx_calib_emb0+mx_calib_eme0+mx_calib_tileg3);
1061  }
1062  } // iClus
1063 
1064  double engCalibDeadTotWithPres = engCalibDeadTot + engClusSumCalibPresOnly;
1065 
1066  // DM energy before barrel presampler, inside it, and between presampler and strips
1067  double eng_calib_dead_emb0 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_EMB0]
1068  + engCalibDeadTotInArea[CaloDmDescrArea::DMA_EMB1]
1069  + engCalibTotSmp[CaloSampling::PreSamplerB];
1070  // DM energy between barrel and tile
1071  double eng_calib_dead_tile0 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_EMB3_TILE0];
1072  // DM energy before scintillator and inside scintillator
1073  double eng_calib_dead_tileg3 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_SCN]
1074  + engCalibTotSmp[CaloSampling::TileGap3];
1075  // DM energy beforee endcap presampler, inside it and between presampler and strips
1076  double eng_calib_dead_eme0 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_EME0]
1077  + engCalibDeadTotInArea[CaloDmDescrArea::DMA_EME12]
1078  + engCalibTotSmp[CaloSampling::PreSamplerE];
1079  // DM energy between emec and hec
1080  double eng_calib_dead_hec0 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_EME3_HEC0];
1081  // DM energy before FCAL and between HEC and FCAL
1082  double eng_calib_dead_fcal = engCalibDeadTotInArea[CaloDmDescrArea::DMA_FCAL0]
1083  + engCalibDeadTotInArea[CaloDmDescrArea::DMA_HEC_FCAL];
1084  // DM leakage behind the calorimeter
1085  double eng_calib_dead_leakage = engCalibDeadTotInArea[CaloDmDescrArea::DMA_LEAK];
1086  // the rest of DM energy which remains unclassified
1087  double eng_calib_dead_unclass = engCalibDeadTotWithPres - eng_calib_dead_emb0 - eng_calib_dead_tile0
1088  - eng_calib_dead_tileg3 - eng_calib_dead_eme0 - eng_calib_dead_hec0 - eng_calib_dead_fcal
1089  - eng_calib_dead_leakage;
1090 
1091  // filling histograms
1092  int iMoment=0;
1093  for(moment_name_vector::const_iterator im=m_validMoments.begin(); im!=m_validMoments.end(); ++im, ++iMoment){
1094  double xnorm = 0.0;
1095  switch ( (*im).second ) {
1096  case xAOD::CaloCluster::ENG_CALIB_TOT:
1097  xnorm = clsMomentsSum[iMoment];
1098  break;
1099  case xAOD::CaloCluster::ENG_CALIB_OUT_T:
1100  xnorm = engCalibTot - engClusSumCalib;
1101  break;
1102  case xAOD::CaloCluster::ENG_CALIB_OUT_L:
1103  xnorm = engCalibTot - engClusSumCalib;
1104  break;
1105  case xAOD::CaloCluster::ENG_CALIB_OUT_M:
1106  xnorm = engCalibTot - engClusSumCalib;
1107  break;
1108  case xAOD::CaloCluster::ENG_CALIB_DEAD_TOT:
1109  xnorm = engCalibDeadTotWithPres;
1110  break;
1111  case xAOD::CaloCluster::ENG_CALIB_DEAD_EMB0:
1112  xnorm = eng_calib_dead_emb0;
1113  break;
1114  case xAOD::CaloCluster::ENG_CALIB_DEAD_TILE0:
1115  xnorm = eng_calib_dead_tile0;
1116  break;
1117  case xAOD::CaloCluster::ENG_CALIB_DEAD_TILEG3:
1118  xnorm = eng_calib_dead_tileg3;
1119  break;
1120  case xAOD::CaloCluster::ENG_CALIB_DEAD_EME0:
1121  xnorm = eng_calib_dead_eme0;
1122  break;
1123  case xAOD::CaloCluster::ENG_CALIB_DEAD_HEC0:
1124  xnorm = eng_calib_dead_hec0;
1125  break;
1126  case xAOD::CaloCluster::ENG_CALIB_DEAD_FCAL:
1127  xnorm = eng_calib_dead_fcal;
1128  break;
1129  case xAOD::CaloCluster::ENG_CALIB_DEAD_LEAKAGE:
1130  xnorm = eng_calib_dead_leakage;
1131  break;
1132  case xAOD::CaloCluster::ENG_CALIB_DEAD_UNCLASS:
1133  xnorm = eng_calib_dead_unclass;
1134  break;
1135  default:
1136  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Not implemented for " << (*im).first << " " << (*im).second);
1137  break;
1138  }
1139  if(m_doClusMoments && xnorm > m_mc_ener*0.0001) {
1140  // moments assigned to first 3 maximum clusters
1141  const double inv_xnorm = 1. / xnorm;
1142  for(unsigned int i_cls=0; i_cls<clusColl.size(); i_cls++){
1143  m_clusMoment_vs_eta[iMoment][i_cls][m_mc_enerbin]->Fill(m_mc_eta, clsMoments[i_cls][iMoment]*inv_xnorm);
1144  m_clusMoment_vs_ebeam[iMoment][i_cls][m_mc_etabin]->Fill(m_mc_ener, clsMoments[i_cls][iMoment]*inv_xnorm);
1145  if(i_cls>=2) break;
1146  }
1147  // sum of moments assigned to clusters wrt total sum of moment
1148  m_clusMoment_vs_eta[iMoment][kMOM_SUMCLS][m_mc_enerbin]->Fill(m_mc_eta, clsMomentsSum[iMoment]/xnorm);
1149  m_clusMoment_vs_ebeam[iMoment][kMOM_SUMCLS][m_mc_etabin]->Fill(m_mc_ener, clsMomentsSum[iMoment]/xnorm);
1150  // unassigned energy wrt pion energy
1151  m_clusMoment_vs_eta[iMoment][kMOM_MISS][m_mc_enerbin]->Fill(m_mc_eta, (xnorm-clsMomentsSum[iMoment])/m_mc_ener);
1152  m_clusMoment_vs_ebeam[iMoment][kMOM_MISS][m_mc_etabin]->Fill(m_mc_ener, (xnorm-clsMomentsSum[iMoment])/m_mc_ener);
1153  // unassigned energy wrt pion energy
1154  m_clusMoment_vs_eta[iMoment][kMOM_MCENER][m_mc_enerbin]->Fill(m_mc_eta, xnorm/m_mc_ener);
1155  m_clusMoment_vs_ebeam[iMoment][kMOM_MCENER][m_mc_etabin]->Fill(m_mc_ener, xnorm/m_mc_ener);
1156  }
1157  } // i_mom
1158 
1159  return 0;
1160 }

◆ fill_reco()

int GetLCSinglePionsPerf::fill_reco ( const xAOD::CaloClusterContainer &  clusColl,
const EventContext &  ctx 
)
private

Definition at line 755 of file GetLCSinglePionsPerf.cxx.

757 {
758  /* ********************************************
759  reading cluster collections for each calibration level
760  ******************************************** */
761  std::vector<const xAOD::CaloClusterContainer *> clusCollVector;
762  for (const SG::ReadHandleKey<xAOD::CaloClusterContainer> & k : m_clusterCollNames) {
763  SG::ReadHandle<xAOD::CaloClusterContainer> pColl (k, ctx);
764  clusCollVector.push_back(pColl.cptr());
765  }
766 
767  HepLorentzVector hlv_pion(1,0,0,1);
768  hlv_pion.setREtaPhi(1./cosh(m_mc_eta),m_mc_eta,m_mc_phi);
769 
770  std::vector<double > engClusSum; // for 4 collections
771  engClusSum.resize(m_ncluscoll, 0.0);
772  std::vector<double > engClusSumPresOnly; // for 4 collections
773  engClusSumPresOnly.resize(m_ncluscoll, 0.0);
774 
775  double engClusSumCalib(0);
776  double engClusSumCalibPresOnly(0);
777  double engClusSumTrueOOC(0);
778  double engClusSumTrueDM(0);
779  std::vector<double> engClusSumCalibTagged;
780  engClusSumCalibTagged.resize(m_ntagcases, 0.0);
781 
782  int nGoodClus = 0;
783  unsigned int iClus = -1;
784  for (const xAOD::CaloCluster* theCluster : clusColl) {
785  ++iClus;
786  double mx_calib_tot;
787  if( !theCluster->retrieveMoment( xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot) ) {
788  ATH_MSG_ERROR( "Moment ENG_CALIB_TOT is absent" );
789  }
790  double mx_calib_emb0 = 0;
791  double mx_calib_eme0 = 0;
792  double mx_calib_tileg3 = 0;
793  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EMB0, mx_calib_emb0)
794  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EME0, mx_calib_eme0)
795  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TILEG3, mx_calib_tileg3)){
796  ATH_MSG_ERROR( "One of the moment ENG_CALIB_EMB0, ENG_CALIB_EME0, ENG_CALIB_TILEG3 is absent" );
797  }
798  double mx_calib_out = 0;
799  double mx_calib_dead_tot = 0;
800  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_OUT_L, mx_calib_out)
801  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_DEAD_TOT, mx_calib_dead_tot) ){
802  ATH_MSG_ERROR( "One of the moment ENG_CALIB_OUT_L, ENG_CALIB_DEAD_TOT is absent" );
803  }
804 
805  double mx_dens, mx_center_lambda;
806  if (!theCluster->retrieveMoment(xAOD::CaloCluster::CENTER_LAMBDA, mx_center_lambda))
807  mx_center_lambda = 0;
808  if (!theCluster->retrieveMoment(xAOD::CaloCluster::FIRST_ENG_DENS, mx_dens))
809  mx_dens = 0;
810 
811  bool clusIsGood(true);//Fabian
812  if(m_useGoodClus){
813  if(theCluster->size() <= 1 || mx_dens <=0 || mx_center_lambda ==0 || ( m_usePionClusters && mx_calib_tot <= m_truthPiEngFraction * m_mc_ener )) {
814  clusIsGood = false;
815  }
816  }
817 
818  HepLorentzVector hlv_cls(1,0,0,1);
819  hlv_cls.setREtaPhi(1./cosh(theCluster->eta()), theCluster->eta(), theCluster->phi());
820  double r = hlv_pion.angle(hlv_cls.vect());
821 
822  if((!m_usePionClusters && r < m_distance_cut*angle_mollier_factor(m_mc_eta)) ||
823  ( ( m_usePionClusters && r < m_distance_cut*angle_mollier_factor(m_mc_eta)) && clusIsGood ) ) {
824 
825  theCluster = clusCollVector[kTOPO]->at(iClus); // this collection has RecoStatus
826  CaloRecoStatus recoStatus = theCluster->recoStatus();
827 
828  if(recoStatus.checkStatus(CaloRecoStatus::TAGGEDEM) ) {
829  engClusSumCalibTagged[kTAGEM] += mx_calib_tot;
830  }else if(recoStatus.checkStatus(CaloRecoStatus::TAGGEDHAD) ) {
831  engClusSumCalibTagged[kTAGHAD] += mx_calib_tot;
832  }else if(recoStatus.checkStatus(CaloRecoStatus::TAGGEDUNKNOWN) ) {
833  engClusSumCalibTagged[kTAGUNK] += mx_calib_tot;
834  }else{
835  ATH_MSG_ERROR("CheckSinglePionsReco::execute() -> Error! Unkown classification status " << recoStatus.getStatusWord());
836  }
837 
838  if(clusIsGood){
839  nGoodClus++;
840  engClusSumCalib += mx_calib_tot;
841  engClusSumCalibPresOnly += (mx_calib_emb0+mx_calib_eme0+mx_calib_tileg3);
842  engClusSumTrueOOC += mx_calib_out;
843  engClusSumTrueDM += mx_calib_dead_tot;
844  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
845  theCluster = clusCollVector[i_coll]->at(iClus);
846  engClusSum[i_coll] += theCluster->e();
847  engClusSumPresOnly[i_coll] += (theCluster->eSample(CaloSampling::PreSamplerB)+theCluster->eSample(CaloSampling::PreSamplerE)+theCluster->eSample(CaloSampling::TileGap3));
848  }
849  }
850 
851  }else{
852  if(m_doEngNoiseClus){
853  // to save noise clusters
854  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
855  theCluster = clusCollVector[i_coll]->at(iClus);
856  m_engNoiseClusSpect[i_coll][m_mc_etabin]->Fill(theCluster->e());
857  m_engNoiseClus_vs_eta[i_coll]->Fill(theCluster->eta(), theCluster->e());
858  }
859  } // m_doEngNoiseClus
860  } // r
861  // xxx
862  } // iclus
863 
864  if(nGoodClus == 0) return 0;
865 
866  /* ********************************************
867  filling histograms for ereco over truth after each step of calibration
868  ******************************************** */
869  if(m_doEngRecOverTruth){
870  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++) {
871  // with respect to the initial pion energy
872  int i_norm = 0;
873  double enom = engClusSum[i_coll];
874  if(i_coll != kTOPO) {
875  enom = enom - engClusSumPresOnly[i_coll];
876  }
877  if(m_mc_ener != 0.0) {
878  m_engRecOverTruth_vs_eta[i_coll][i_norm][m_mc_enerbin]->Fill(m_mc_eta, enom/m_mc_ener);
879  m_engRecOverTruth_vs_ebeam[i_coll][i_norm][m_mc_etabin]->Fill(m_mc_ener, enom/m_mc_ener);
880  }
881  // with respect to the calibration level
882  i_norm = 1;
883  double edenom = engClusSumCalib - engClusSumCalibPresOnly; // for em or had
884  if(i_coll == kTOPO_OOC){ // ooc
885  edenom += engClusSumTrueOOC;
886  }else if(i_coll == kTOPO){ // dm
887  edenom += (engClusSumTrueOOC + engClusSumTrueDM);
888  }
889  if(edenom != 0.0) {
890  m_engRecOverTruth_vs_eta[i_coll][i_norm][m_mc_enerbin]->Fill(m_mc_eta, enom/edenom);
891  m_engRecOverTruth_vs_ebeam[i_coll][i_norm][m_mc_etabin]->Fill(m_mc_ener, enom/edenom);
892  }
893  // with respect to the calibration level with "ideal" previous step
894  i_norm = 2;
895  enom = engClusSum[i_coll] - engClusSumPresOnly[i_coll];
896  if(i_coll == kTOPO_OOC){ // ooc
897  double engClusSumRecoOOC = engClusSum[kTOPO_OOC] - engClusSum[kTOPO_W];
898  enom = engClusSumCalib - engClusSumCalibPresOnly + engClusSumRecoOOC;
899  }else if(i_coll == kTOPO){ // dm
900  double engClusSumRecoDM = engClusSum[kTOPO] - (engClusSum[kTOPO_OOC]-engClusSumPresOnly[kTOPO_OOC]);
901  enom = (engClusSumCalib - engClusSumCalibPresOnly) + engClusSumTrueOOC + engClusSumRecoDM;
902  }
903  if(edenom != 0.0) {
904  m_engRecOverTruth_vs_eta[i_coll][i_norm][m_mc_enerbin]->Fill(m_mc_eta, enom/edenom);
905  m_engRecOverTruth_vs_ebeam[i_coll][i_norm][m_mc_etabin]->Fill(m_mc_ener, enom/edenom);
906  }
907  } // i_coll
908  } // m_doEngRecOverTruth
909 
910  /* ********************************************
911  filling histograms with classification results
912  ******************************************** */
913  if(m_doEngTag) {
914  if(engClusSumCalib!=0.0) {
915  const double inv_engClusSumCalib = 1. / engClusSumCalib;
916  for(int i_tag=0; i_tag<m_ntagcases; i_tag++) {
917  m_engTag_vs_eta[i_tag][m_mc_enerbin]->Fill(m_mc_eta, engClusSumCalibTagged[i_tag]*inv_engClusSumCalib);
918  m_engTag_vs_ebeam[i_tag][m_mc_etabin]->Fill(m_mc_ener, engClusSumCalibTagged[i_tag]*inv_engClusSumCalib);
919  }
920  }
921  } // m_doEngTag
922 
923  /* ********************************************
924  filling histograms for reco energy spectras
925  ******************************************** */
926  if(m_doEngRecSpect){
927  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
928  double enom = engClusSum[i_coll];
929  if(i_coll != kTOPO) {
930  enom = enom - engClusSumPresOnly[i_coll];
931  }
932  m_engRecSpect[i_coll][m_mc_enerbin][m_mc_etabin]->Fill(enom/m_mc_ener);
933  }
934  } // m_doEngRecSpect
935 
936  return 0;
937 }

◆ finalize()

StatusCode GetLCSinglePionsPerf::finalize ( )
virtual

Definition at line 481 of file GetLCSinglePionsPerf.cxx.

482 {
483  ATH_MSG_INFO( "Writing out histograms" );
484 
485  // ereco over truth after each step of calibration
486  if(m_doEngRecOverTruth) {
487  m_outputFile->cd();
488  m_outputFile->mkdir("engRecOverTruth");
489  m_outputFile->cd("engRecOverTruth");
490  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
491  for(int i_norm=0; i_norm<m_nnormtype; i_norm++){
492  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
493  if(m_engRecOverTruth_vs_eta[i_coll][i_norm][i_ener]) m_engRecOverTruth_vs_eta[i_coll][i_norm][i_ener]->Write();
494  } // i_ener
495  } // i_norm
496  } // i_coll
497  //
498  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
499  for(int i_norm=0; i_norm<m_nnormtype; i_norm++){
500  for(int i_eta=0; i_eta<m_netabin; i_eta++) {
501  if(m_engRecOverTruth_vs_ebeam[i_coll][i_norm][i_eta]) m_engRecOverTruth_vs_ebeam[i_coll][i_norm][i_eta]->Write();
502  } // i_eta
503  } // i_norm
504  } // i_coll
505  } // m_doEngRecOverTruth
506 
507  // classification performance
508  if(m_doEngTag) {
509  m_outputFile->cd();
510  m_outputFile->mkdir("engTag");
511  m_outputFile->cd("engTag");
512  for(int i_tag=0; i_tag<m_ntagcases; i_tag++) {
513  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
514  if(m_engTag_vs_eta[i_tag][i_ener]) m_engTag_vs_eta[i_tag][i_ener]->Write();
515  } // i_ener
516  } // i_tag
517  // as a function of pion energy for several eta bins
518  for(int i_tag=0; i_tag<m_ntagcases; i_tag++){
519  for(int i_eta=0; i_eta<m_netabin; i_eta++) {
520  if(m_engTag_vs_ebeam[i_tag][i_eta]) m_engTag_vs_ebeam[i_tag][i_eta]->Write();
521  }
522  }
523  } // m_doEngTag
524 
525  // reco energy spactras
526  if(m_doEngRecSpect) {
527  m_outputFile->cd();
528  m_outputFile->mkdir("engRecSpect");
529  m_outputFile->cd("engRecSpect");
530  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
531  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
532  for(int i_eta=0; i_eta<m_netabin; i_eta++){
533  if(m_engRecSpect[i_coll][i_ener][i_eta]) m_engRecSpect[i_coll][i_ener][i_eta]->Write();
534  } // i_eta
535  } // i_ener
536  } // i_coll
537  // pione energy spectra
538  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
539  for(int i_eta=0; i_eta<m_netabin; i_eta++){
540  if(m_engPionSpect[i_ener][i_eta]) m_engPionSpect[i_ener][i_eta]->Write();
541  } // i_eta
542  } // i_ener
543  } // m_doEngRecSpect
544 
545  // noise clusters spectra
546  if(m_doEngNoiseClus) {
547  m_outputFile->cd();
548  m_outputFile->mkdir("engNoiseClus");
549  m_outputFile->cd("engNoiseClus");
550  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
551  for(int i_eta=0; i_eta<m_netabin; i_eta++){
552  if(m_engNoiseClusSpect[i_coll][i_eta]) m_engNoiseClusSpect[i_coll][i_eta]->Write();
553  } // i_eta
554  } // i_coll
555  // average noise
556  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
557  if(m_engNoiseClus_vs_eta[i_coll]) m_engNoiseClus_vs_eta[i_coll] -> Write();
558  }
559  } // m_doEngRecSpect
560 
561  if(m_doClusMoments) {
562  m_outputFile->cd();
563  m_outputFile->mkdir("clusMoment");
564  m_outputFile->cd("clusMoment");
565  for(int i_mom=0; i_mom<m_nmoments; i_mom++){
566  for(int i_sum=0; i_sum<m_nmomsums; i_sum++){
567  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
568  if(m_clusMoment_vs_eta[i_mom][i_sum][i_ener]) m_clusMoment_vs_eta[i_mom][i_sum][i_ener]->Write();
569  } // i_ener
570  } // i_sum
571  } // i_mom
572  for(int i_mom=0; i_mom<m_nmoments; i_mom++){
573  for(int i_sum=0; i_sum<m_nmomsums; i_sum++){
574  for(int i_eta=0; i_eta<m_netabin; i_eta++){
575  if(m_clusMoment_vs_ebeam[i_mom][i_sum][i_eta]) m_clusMoment_vs_ebeam[i_mom][i_sum][i_eta]->Write();
576  } // i_eta
577  } // i_sum
578  } // i_mom
579 
580  } // m_doClusMoments
581 
582  if(m_doRecoEfficiency) {
583  m_outputFile->cd();
584  m_outputFile->mkdir("RecoEff");
585  m_outputFile->cd("RecoEff");
586  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
587  if(m_RecoEfficiency_vs_eta[0][i_ener] && m_RecoEfficiency_vs_eta[1][i_ener]) {
588  m_RecoEfficiency_vs_eta[0][i_ener]->Write();
589  m_RecoEfficiency_vs_eta[1][i_ener]->Write();
590  }
591  } // i_eta
592  for(int i_eta=0; i_eta<m_netabin; i_eta++){
593  if(m_RecoEfficiency_vs_ebeam[0][i_eta] && m_RecoEfficiency_vs_ebeam[1][i_eta]) {
594  m_RecoEfficiency_vs_ebeam[0][i_eta]->Write();
595  m_RecoEfficiency_vs_ebeam[1][i_eta]->Write();
596  }
597  } // i_eta
598  } // m_doRecoEfficiency
599 
600  /* **************************************************************************
601  histograms to check calibration hits machinery
602  *************************************************************************** */
603  if(m_doCalibHitsValidation) {
604  m_outputFile->cd();
605  m_outputFile->mkdir("CalibHitsValidation");
606  m_outputFile->cd("CalibHitsValidation");
607  for(int i_ener=0; i_ener<m_nlogenerbin2; i_ener++){
608  if(m_SumCalibHitOverEbeam_vs_eta[i_ener]) m_SumCalibHitOverEbeam_vs_eta[i_ener]->Write();
609  if(m_DefaultCalculatorOverEbeam_vs_eta[i_ener]) m_DefaultCalculatorOverEbeam_vs_eta[i_ener]->Write();
610  if(m_SumCalibHitAssignedOverEbeam_vs_eta[i_ener]) m_SumCalibHitAssignedOverEbeam_vs_eta[i_ener]->Write();
611  if(m_SumCalibHitAssignedOverEbeam_vs_etaphi[i_ener]) m_SumCalibHitAssignedOverEbeam_vs_etaphi[i_ener]->Write();
612  } // i_ener
613 // for(int i_eta=0; i_eta<m_netabin; i_eta++){
614 // if(m_SumCalibHitOverEbeam_vs_ebeam[i_eta]) m_SumCalibHitOverEbeam_vs_ebeam[i_eta]->Write();
615 // // if(m_DefaultCalculatorOverEbeam_vs_ebeam[i_eta]) m_DefaultCalculatorOverEbeam_vs_ebeam[i_eta]->Write();
616 // } // i_eta
617 
618  } // m_doCalibHitsValidation
619 
620  /* ********************************************
621  writing tree with histogram parameters
622  ******************************************** */
623  m_outputFile->cd();
624  m_outputFile->mkdir("Parameters");
625  m_outputFile->cd("Parameters");
626  TTree *tree = new TTree("ParamTree","ParamTree");
627  tree->Branch("m_netabin",&m_netabin,"m_netabin/I");
628  tree->Branch("m_etamin",&m_etamin,"m_etamin/F");
629  tree->Branch("m_etamax",&m_etamax,"m_etamax/F");
630  tree->Branch("m_nphibin",&m_nphibin,"m_nphibin/I");
631  tree->Branch("m_phimin",&m_phimin,"m_phimin/F");
632  tree->Branch("m_phimax",&m_phimax,"m_phimax/F");
633  tree->Branch("m_nlogenerbin",&m_nlogenerbin,"m_nlogenerbin/I");
634  tree->Branch("m_logenermin",&m_logenermin,"m_logenermin/F");
635  tree->Branch("m_logenermax",&m_logenermax,"m_logenermax/F");
636  tree->Branch("m_nnormtype",&m_nnormtype,"m_nnormtype/I");
637  tree->Branch("m_ncluscoll",&m_ncluscoll,"m_ncluscoll/I");
638  tree->Branch("m_ntagcases",&m_ntagcases,"m_ntagcases/I");
639  tree->Branch("m_nmoments",&m_nmoments,"m_nmoments/I");
640  tree->Branch("m_nmomsums",&m_nmomsums,"m_nmomsums/I");
641  tree->Fill();
642  tree->Write();
643 
644  m_outputFile->Close();
645 
646  return StatusCode::SUCCESS;
647 }

◆ initialize()

StatusCode GetLCSinglePionsPerf::initialize ( )
virtual

Definition at line 173 of file GetLCSinglePionsPerf.cxx.

174 {
175  ATH_CHECK( detStore()->retrieve(m_calo_id,"CaloCell_ID") );
176  ATH_CHECK( detStore()->retrieve(m_id_helper) );
177 
178 
179  m_deta = (m_etamax - m_etamin)/m_netabin;
180  m_dphi = (m_phimax - m_phimin)/m_nphibin;
181  m_dlogener = (m_logenermax - m_logenermin)/m_nlogenerbin;
182 
183  m_outputFile = new TFile(m_outputFileName.c_str(),"RECREATE");
184  m_outputFile->cd();
185 
186  // defining histograms
187  char hname[256];
188  float h_eta_min = -5.0;
189  float h_eta_max=5.0;
190  int h_nch_eta = 50;
191  if(m_etamin != 0.0) {
192  h_eta_min = m_etamin;
193  h_eta_max = m_etamax;
194  }
195  const int n_logener_bins = m_nlogenerbin*2;
196  double *xbins = new double[n_logener_bins+1];
197  const double inv_n_logener_bins = 1. / static_cast<double> (n_logener_bins);
198  for(int i_bin=0; i_bin<=n_logener_bins; i_bin++) {
199  xbins[i_bin] = pow(10,m_logenermin+i_bin*(m_logenermax-m_logenermin)*inv_n_logener_bins);
200  }
201  m_ncluscoll = m_clusterCollNames.size();
202 
203  /* **************************************************************************
204  histograms to check classification performance
205  *************************************************************************** */
206  if(m_doEngTag) {
207  // as a function of pion eta for several energy bins
208  m_engTag_vs_eta.resize(m_ntagcases);
209  for(int i_tag=0; i_tag<m_ntagcases; i_tag++) {
210  m_engTag_vs_eta[i_tag].resize(m_nlogenerbin, nullptr);
211  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
212  sprintf(hname, "hp_engTag_vs_eta_tag%d_ener%d",i_tag, i_ener);
213  TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
214  hp->GetXaxis()->SetTitle("#eta");
215  hp->GetYaxis()->SetTitle("E_{class}/E_{tot}");
216  m_engTag_vs_eta[i_tag][i_ener] = hp;
217  } // i_ener
218  } // i_tag
219  // as a function of pion energy for several eta bins
220  m_engTag_vs_ebeam.resize(m_ntagcases);
221  for(int i_tag=0; i_tag<m_ntagcases; i_tag++){
222  m_engTag_vs_ebeam[i_tag].resize(m_netabin, nullptr);
223  for(int i_eta=0; i_eta<m_netabin; i_eta++) {
224  sprintf(hname, "hp_engTag_vs_ebeam_tag%d_eta%d",i_tag, i_eta);
225  TProfile *hp = new TProfile(hname, hname, n_logener_bins, xbins);
226  hp->GetXaxis()->SetTitle("E_{#pi}, MeV");
227  hp->GetYaxis()->SetTitle("E_{class}/E_{tot}");
228  m_engTag_vs_ebeam[i_tag][i_eta] = hp;
229  }
230  }
231  } // m_doEngTag
232 
233 
234  /* **************************************************************************
235  histograms to check reconstructed energy after each step of local hadronic
236  calibration, reco energy is defined as a sum of clusters energies within certain
237  angle around particle direction
238  *************************************************************************** */
239  if(m_doEngRecOverTruth) {
240  // as a function of pion eta for several energy bins
241  m_engRecOverTruth_vs_eta.resize(m_ncluscoll);
242  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
243  m_engRecOverTruth_vs_eta[i_coll].resize(m_nnormtype);
244  for(int i_norm=0; i_norm<m_nnormtype; i_norm++){
245  m_engRecOverTruth_vs_eta[i_coll][i_norm].resize(m_nlogenerbin, nullptr);
246  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
247  double ylow(0), yup(0);
248  if(i_norm != kLEVEL_PARTICLE) {
249  ylow = 0.0;
250  yup = 100.0;
251  }
252  sprintf(hname, "hp_engRecOverTruth_vs_eta_coll%d_norm%d_ener%d",i_coll, i_norm, i_ener);
253  TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max, ylow, yup);
254  hp->GetXaxis()->SetTitle("#eta");
255  if(i_norm==kLEVEL_PARTICLE) {
256  hp->GetYaxis()->SetTitle("E_{reco}/E_{#pi}");
257  }else{
258  hp->GetYaxis()->SetTitle("E_{reco}/E_{calib}");
259  }
260  m_engRecOverTruth_vs_eta[i_coll][i_norm][i_ener] = hp;
261  } // i_ener
262  } // i_norm
263  } // i_coll
264  // as a function of pion energy for several eta bins
265  m_engRecOverTruth_vs_ebeam.resize(m_ncluscoll);
266  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
267  m_engRecOverTruth_vs_ebeam[i_coll].resize(m_nnormtype);
268  for(int i_norm=0; i_norm<m_nnormtype; i_norm++){
269  m_engRecOverTruth_vs_ebeam[i_coll][i_norm].resize(m_netabin, nullptr);
270  for(int i_eta=0; i_eta<m_netabin; i_eta++) {
271  double ylow(0), yup(0);
272  if(i_norm != kLEVEL_PARTICLE) {
273  ylow = 0.0;
274  yup = 100.0;
275  }
276  sprintf(hname, "hp_m_engRecOverTruth_vs_ebeam_coll%d_norm%d_eta%d",i_coll, i_norm, i_eta);
277  TProfile *hp = new TProfile(hname, hname, n_logener_bins, xbins, ylow, yup);
278  hp->GetXaxis()->SetTitle("E_{#pi}, MeV");
279  if(i_norm==kLEVEL_PARTICLE) {
280  hp->GetYaxis()->SetTitle("E_{reco}/E_{#pi}");
281  }else{
282  hp->GetYaxis()->SetTitle("E_{reco}/E_{calib}");
283  }
284  m_engRecOverTruth_vs_ebeam[i_coll][i_norm][i_eta] = hp;
285  } // i_eta
286  } // i_norm
287  } // i_coll
288  } // m_doEngRecOverTruth
289 
290 
291  /* **************************************************************************
292  histograms to save reco and noise clusters energy spectras
293  *************************************************************************** */
294  if(m_doEngRecSpect) {
295  m_engRecSpect.resize(m_ncluscoll);
296  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
297  m_engRecSpect[i_coll].resize(m_nlogenerbin);
298  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
299  m_engRecSpect[i_coll][i_ener].resize(m_netabin, nullptr);
300  for(int i_eta=0; i_eta<m_netabin; i_eta++){
301  sprintf(hname, "hp_engRecSpect_coll%d_ener%d_eta%d",i_coll, i_ener, i_eta);
302  TH1F *h1 = new TH1F(hname, hname, 110, -0.2, 2.0);
303  h1->GetXaxis()->SetTitle("E_{reco}/E_{#pi}");
304  m_engRecSpect[i_coll][i_ener][i_eta] = h1;
305  } // i_eta
306  } // i_ener
307  } // i_coll
308  // energy spectra of incident pions
309  m_engPionSpect.resize(m_nlogenerbin);
310  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
311  m_engPionSpect[i_ener].resize(m_netabin, nullptr);
312  for(int i_eta=0; i_eta<m_netabin; i_eta++){
313  sprintf(hname, "hp_engPionSpect_ener%d_eta%d",i_ener, i_eta);
314  double x1 = pow(10,m_logenermin+i_ener*m_dlogener);
315  double x2 = pow(10,m_logenermin+(i_ener+1)*m_dlogener);
316  TH1F *h1 = new TH1F(hname, hname, 20, x1, x2);
317  h1->GetXaxis()->SetTitle("E_{#pi}, MeV");
318  m_engPionSpect[i_ener][i_eta] = h1;
319  } // i_eta
320  } // i_ener
321  } // m_doEngRecSpect
322 
323  /* **************************************************************************
324  histograms to save noise clusters spectras
325  *************************************************************************** */
326  if(m_doEngNoiseClus) {
327  // noise clusters spectras
328  m_engNoiseClusSpect.resize(m_ncluscoll);
329  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
330  m_engNoiseClusSpect[i_coll].resize(m_netabin, nullptr);
331  for(int i_eta=0; i_eta<m_netabin; i_eta++){
332  sprintf(hname, "hp_engNoiseClusSpect_coll%d_eta%d",i_coll, i_eta);
333  TH1F *h1 = new TH1F(hname, hname, 100, -2000., 2000.);
334  h1->GetXaxis()->SetTitle("E_{clus}, MeV");
335  m_engNoiseClusSpect[i_coll][i_eta] = h1;
336  } // i_eta
337  } // i_coll
338  // average
339  m_engNoiseClus_vs_eta.resize(m_ncluscoll, nullptr);
340  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
341  sprintf(hname, "hp_engNoiseClus_vs_eta_coll%d",i_coll);
342  TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
343  hp->GetXaxis()->SetTitle("#eta");
344  hp->GetYaxis()->SetTitle("E_{clus}, MeV");
345  m_engNoiseClus_vs_eta[i_coll] = hp;
346  //hp->SetErrorOption("s");
347  }
348  } // m_doEngNoiseClus
349 
350  /* **************************************************************************
351  histograms to save cluster moments
352  *************************************************************************** */
353  if(m_doClusMoments) {
354  m_clusMoment_vs_eta.resize(m_nmoments);
355  for(int i_mom=0; i_mom<m_nmoments; i_mom++){
356  m_clusMoment_vs_eta[i_mom].resize(m_nmomsums);
357  for(int i_sum=0; i_sum<m_nmomsums; i_sum++){
358  m_clusMoment_vs_eta[i_mom][i_sum].resize(m_nlogenerbin, nullptr);
359  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
360  sprintf(hname, "hp_clusMoment_vs_eta_mom%d_sum%d_ener%d",i_mom, i_sum, i_ener);
361  TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
362  hp->GetXaxis()->SetTitle("#eta");
363  hp->GetYaxis()->SetTitle("Mom_{cls}/Mom_{sum}");
364  hp->SetTitle(m_validMoments[i_mom].first.c_str());
365  m_clusMoment_vs_eta[i_mom][i_sum][i_ener] = hp;
366  } // i_ener
367  } // i_sum
368  } // i_mom
369 
370  m_clusMoment_vs_ebeam.resize(m_nmoments);
371  for(int i_mom=0; i_mom<m_nmoments; i_mom++){
372  m_clusMoment_vs_ebeam[i_mom].resize(m_nmomsums);
373  for(int i_sum=0; i_sum<m_nmomsums; i_sum++){
374  m_clusMoment_vs_ebeam[i_mom][i_sum].resize(m_netabin, nullptr);
375  for(int i_eta=0; i_eta<m_netabin; i_eta++){
376  sprintf(hname, "hp_clusMoment_vs_ebeam_mom%d_sum%d_eta%d",i_mom, i_sum, i_eta);
377  TProfile *hp = new TProfile(hname, hname, n_logener_bins, xbins);
378  hp->GetXaxis()->SetTitle("E_{#pi}");
379  hp->GetYaxis()->SetTitle("Mom_{cls}/Mom_{sum}");
380  hp->SetTitle(m_validMoments[i_mom].first.c_str());
381  m_clusMoment_vs_ebeam[i_mom][i_sum][i_eta] = hp;
382  } // i_eta
383  } // i_sum
384  } // i_mom
385 
386  } // m_doClusMoments
387 
388 
389  /* **************************************************************************
390  histograms to save reconstruction efficiency
391  *************************************************************************** */
392  if(m_doRecoEfficiency) {
393  // as a function of eta for several energy bins
394  for(int i_eff=0; i_eff<2; i_eff++){ // 0-reconstructed, 1-all events
395  m_RecoEfficiency_vs_eta[i_eff].resize(m_nlogenerbin, nullptr);
396  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
397  sprintf(hname, "hp_m_RecoEfficiency_eff%d_ener%d", i_eff, i_ener);
398  TH1F *h1 = new TH1F(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
399  h1->GetXaxis()->SetTitle("#eta");
400  h1->GetYaxis()->SetTitle("Efficiency");
401  m_RecoEfficiency_vs_eta[i_eff][i_ener] = h1;
402  } // i_eta
403  } // i_eff
404  // as a function of energy for several eta bins
405  for(int i_eff=0; i_eff<2; i_eff++){ // 0-reconstructed, 1-all events
406  m_RecoEfficiency_vs_ebeam[i_eff].resize(m_netabin, nullptr);
407  for(int i_eta=0; i_eta<m_netabin; i_eta++){
408  sprintf(hname, "hp_m_RecoEfficiency_eff%d_eta%d", i_eff, i_eta);
409  TH1F *h1 = new TH1F(hname, hname, n_logener_bins, xbins);
410  h1->GetXaxis()->SetTitle("E_{#pi}, MeV");
411  h1->GetYaxis()->SetTitle("Efficiency");
412  m_RecoEfficiency_vs_ebeam[i_eff][i_eta] = h1;
413  } // i_eta
414  } // i_eff
415  }
416 
417  /* **************************************************************************
418  histograms to check calibration hits machinery
419  *************************************************************************** */
420  if(m_doCalibHitsValidation) {
421  m_SumCalibHitOverEbeam_vs_eta.resize(m_nlogenerbin2, nullptr);
422  m_DefaultCalculatorOverEbeam_vs_eta.resize(m_nlogenerbin2, nullptr);
423  m_SumCalibHitAssignedOverEbeam_vs_eta.resize(m_nlogenerbin2, nullptr);
424  m_SumCalibHitAssignedOverEbeam_vs_etaphi.resize(m_nlogenerbin2, nullptr);
425  for(int i_ener=0; i_ener<m_nlogenerbin2; i_ener++){
426  sprintf(hname, "hp_SumCalibHitOverEbeam_vs_eta_ener%d", i_ener);
427  TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
428  hp->GetXaxis()->SetTitle("#eta");
429  hp->GetYaxis()->SetTitle("#sum E_{calib}/E_{#pi}");
430  m_SumCalibHitOverEbeam_vs_eta[i_ener] = hp;
431  sprintf(hname, "hp_DefaultCalculatorOverEbeam_vs_eta_ener%d", i_ener);
432  hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
433  hp->GetXaxis()->SetTitle("#eta");
434  hp->GetYaxis()->SetTitle("#sum E_{DefCalc}/E_{#pi}");
435  m_DefaultCalculatorOverEbeam_vs_eta[i_ener] = hp;
436  sprintf(hname, "hp_SumCalibHitAssignedOverEbeam_vs_eta_ener%d", i_ener);
437  hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
438  hp->GetXaxis()->SetTitle("#eta");
439  hp->GetYaxis()->SetTitle("#sum E_{assigned}/E_{#pi}");
440  m_SumCalibHitAssignedOverEbeam_vs_eta[i_ener] = hp;
441  sprintf(hname, "hp_SumCalibHitAssignedOverEbeam_vs_etaphi_ener%d", i_ener);
442  TProfile2D *hp2 = new TProfile2D(hname, hname, 25, h_eta_min, h_eta_max, 25, -M_PI, M_PI);
443  hp2->GetXaxis()->SetTitle("#eta");
444  hp2->GetYaxis()->SetTitle("#phi");
445  hp2->GetZaxis()->SetTitle("#sum E_{assigned}/E_{#pi}");
446  m_SumCalibHitAssignedOverEbeam_vs_etaphi[i_ener] = hp2;
447  } // i_ener
448 
449 // m_SumCalibHitOverEbeam_vs_ebeam.resize(m_netabin, 0);
450 // // m_DefaultCalculatorOverEbeam_vs_ebeam.resize(m_netabin, 0);
451 // for(int i_eta=0; i_eta<m_netabin; i_eta++){
452 // sprintf(hname, "hp_SumCalibHitOverEbeam_vs_ebeam_eta%d", i_eta);
453 // TProfile *hp = new TProfile(hname, hname, n_logener_bins, xbins);
454 // hp->GetXaxis()->SetTitle("#eta");
455 // hp->GetYaxis()->SetTitle("#sum E_{calib}/E_{#pi}");
456 // m_SumCalibHitOverEbeam_vs_ebeam[i_eta] = hp;
457 // // sprintf(hname, "hp_DefaultCalculatorOverEbeam_vs_ebeam_eta%d", i_eta);
458 // // hp = new TProfile(hname, hname, n_logener_bins, xbins);
459 // // hp->GetXaxis()->SetTitle("#eta");
460 // // hp->GetYaxis()->SetTitle("#sum E_{DefCalc}/E_{#pi}");
461 // // m_DefaultCalculatorOverEbeam_vs_ebeam[i_eta] = hp;
462 // } // i_eta
463  } // m_doCalibHitsValidation
464 
465 
466  delete [] xbins;
467 
468  ATH_CHECK( m_clusterBasicCollName.initialize() );
469  ATH_CHECK( m_clusterCollNames.initialize() );
470  ATH_CHECK( m_CalibrationHitContainerNames.initialize() );
471  ATH_CHECK( m_DMCalibrationHitContainerNames.initialize() );
472 
473  return StatusCode::SUCCESS;
474 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< 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.

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< 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.

◆ 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< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

StatusCode AthAlgorithm::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< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< 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< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_CalibrationHitContainerNames

SG::ReadHandleKeyArray<CaloCalibrationHitContainer> GetLCSinglePionsPerf::m_CalibrationHitContainerNames
private

Definition at line 66 of file GetLCSinglePionsPerf.h.

◆ m_calo_id

const CaloCell_ID* GetLCSinglePionsPerf::m_calo_id
private

Definition at line 59 of file GetLCSinglePionsPerf.h.

◆ m_caloDmDescrManager

const CaloDmDescrManager* GetLCSinglePionsPerf::m_caloDmDescrManager
private

Definition at line 60 of file GetLCSinglePionsPerf.h.

◆ m_clusMoment_vs_ebeam

std::vector<std::vector<std::vector<TProfile *> > > GetLCSinglePionsPerf::m_clusMoment_vs_ebeam
private

Definition at line 119 of file GetLCSinglePionsPerf.h.

◆ m_clusMoment_vs_eta

std::vector<std::vector<std::vector<TProfile *> > > GetLCSinglePionsPerf::m_clusMoment_vs_eta
private

Definition at line 118 of file GetLCSinglePionsPerf.h.

◆ m_clusterBasicCollName

SG::ReadHandleKey<xAOD::CaloClusterContainer> GetLCSinglePionsPerf::m_clusterBasicCollName
private

Definition at line 62 of file GetLCSinglePionsPerf.h.

◆ m_clusterCollNames

SG::ReadHandleKeyArray<xAOD::CaloClusterContainer> GetLCSinglePionsPerf::m_clusterCollNames
private

Definition at line 63 of file GetLCSinglePionsPerf.h.

◆ m_DefaultCalculatorOverEbeam_vs_eta

std::vector<TProfile *> GetLCSinglePionsPerf::m_DefaultCalculatorOverEbeam_vs_eta
private

Definition at line 126 of file GetLCSinglePionsPerf.h.

◆ m_deta

float GetLCSinglePionsPerf::m_deta
private

Definition at line 75 of file GetLCSinglePionsPerf.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_distance_cut

double GetLCSinglePionsPerf::m_distance_cut
private

Definition at line 70 of file GetLCSinglePionsPerf.h.

◆ m_dlogener

float GetLCSinglePionsPerf::m_dlogener
private

Definition at line 84 of file GetLCSinglePionsPerf.h.

◆ m_DMCalibrationHitContainerNames

SG::ReadHandleKeyArray<CaloCalibrationHitContainer> GetLCSinglePionsPerf::m_DMCalibrationHitContainerNames
private

Definition at line 67 of file GetLCSinglePionsPerf.h.

◆ m_doCalibHitsValidation

bool GetLCSinglePionsPerf::m_doCalibHitsValidation
private

Definition at line 101 of file GetLCSinglePionsPerf.h.

◆ m_doClusMoments

bool GetLCSinglePionsPerf::m_doClusMoments
private

Definition at line 97 of file GetLCSinglePionsPerf.h.

◆ m_doEngNoiseClus

bool GetLCSinglePionsPerf::m_doEngNoiseClus
private

Definition at line 96 of file GetLCSinglePionsPerf.h.

◆ m_doEngRecOverTruth

bool GetLCSinglePionsPerf::m_doEngRecOverTruth
private

Definition at line 93 of file GetLCSinglePionsPerf.h.

◆ m_doEngRecSpect

bool GetLCSinglePionsPerf::m_doEngRecSpect
private

Definition at line 95 of file GetLCSinglePionsPerf.h.

◆ m_doEngTag

bool GetLCSinglePionsPerf::m_doEngTag
private

Definition at line 94 of file GetLCSinglePionsPerf.h.

◆ m_doRecoEfficiency

bool GetLCSinglePionsPerf::m_doRecoEfficiency
private

Definition at line 98 of file GetLCSinglePionsPerf.h.

◆ m_dphi

float GetLCSinglePionsPerf::m_dphi
private

Definition at line 79 of file GetLCSinglePionsPerf.h.

◆ m_engNoiseClus_vs_eta

std::vector<TProfile *> GetLCSinglePionsPerf::m_engNoiseClus_vs_eta
private

Definition at line 116 of file GetLCSinglePionsPerf.h.

◆ m_engNoiseClusSpect

std::vector<std::vector<TH1F *> > GetLCSinglePionsPerf::m_engNoiseClusSpect
private

Definition at line 115 of file GetLCSinglePionsPerf.h.

◆ m_engPionSpect

std::vector<std::vector<TH1F *> > GetLCSinglePionsPerf::m_engPionSpect
private

Definition at line 113 of file GetLCSinglePionsPerf.h.

◆ m_engRecOverTruth_vs_ebeam

std::vector<std::vector<std::vector<TProfile *> > > GetLCSinglePionsPerf::m_engRecOverTruth_vs_ebeam
private

Definition at line 106 of file GetLCSinglePionsPerf.h.

◆ m_engRecOverTruth_vs_eta

std::vector<std::vector<std::vector<TProfile *> > > GetLCSinglePionsPerf::m_engRecOverTruth_vs_eta
private

Definition at line 105 of file GetLCSinglePionsPerf.h.

◆ m_engRecSpect

std::vector<std::vector<std::vector<TH1F *> > > GetLCSinglePionsPerf::m_engRecSpect
private

Definition at line 111 of file GetLCSinglePionsPerf.h.

◆ m_engTag_vs_ebeam

std::vector<std::vector<TProfile *> > GetLCSinglePionsPerf::m_engTag_vs_ebeam
private

Definition at line 109 of file GetLCSinglePionsPerf.h.

◆ m_engTag_vs_eta

std::vector<std::vector<TProfile *> > GetLCSinglePionsPerf::m_engTag_vs_eta
private

Definition at line 108 of file GetLCSinglePionsPerf.h.

◆ m_etamax

float GetLCSinglePionsPerf::m_etamax
private

Definition at line 74 of file GetLCSinglePionsPerf.h.

◆ m_etamin

float GetLCSinglePionsPerf::m_etamin
private

Definition at line 73 of file GetLCSinglePionsPerf.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_id_helper

const AtlasDetectorID* GetLCSinglePionsPerf::m_id_helper
private

Definition at line 58 of file GetLCSinglePionsPerf.h.

◆ m_logenermax

float GetLCSinglePionsPerf::m_logenermax
private

Definition at line 82 of file GetLCSinglePionsPerf.h.

◆ m_logenermin

float GetLCSinglePionsPerf::m_logenermin
private

Definition at line 81 of file GetLCSinglePionsPerf.h.

◆ m_mc_ener

double GetLCSinglePionsPerf::m_mc_ener
private

Definition at line 131 of file GetLCSinglePionsPerf.h.

◆ m_mc_enerbin

int GetLCSinglePionsPerf::m_mc_enerbin
private

Definition at line 135 of file GetLCSinglePionsPerf.h.

◆ m_mc_eta

double GetLCSinglePionsPerf::m_mc_eta
private

Definition at line 132 of file GetLCSinglePionsPerf.h.

◆ m_mc_etabin

int GetLCSinglePionsPerf::m_mc_etabin
private

Definition at line 134 of file GetLCSinglePionsPerf.h.

◆ m_mc_phi

double GetLCSinglePionsPerf::m_mc_phi
private

Definition at line 133 of file GetLCSinglePionsPerf.h.

◆ m_mc_phibin

int GetLCSinglePionsPerf::m_mc_phibin
private

Definition at line 136 of file GetLCSinglePionsPerf.h.

◆ m_ncluscoll

int GetLCSinglePionsPerf::m_ncluscoll
private

Definition at line 86 of file GetLCSinglePionsPerf.h.

◆ m_netabin

int GetLCSinglePionsPerf::m_netabin
private

Definition at line 72 of file GetLCSinglePionsPerf.h.

◆ m_nlogenerbin

int GetLCSinglePionsPerf::m_nlogenerbin
private

Definition at line 80 of file GetLCSinglePionsPerf.h.

◆ m_nlogenerbin2

int GetLCSinglePionsPerf::m_nlogenerbin2
private

Definition at line 83 of file GetLCSinglePionsPerf.h.

◆ m_nmoments

int GetLCSinglePionsPerf::m_nmoments
private

Definition at line 88 of file GetLCSinglePionsPerf.h.

◆ m_nmomsums

int GetLCSinglePionsPerf::m_nmomsums
private

Definition at line 89 of file GetLCSinglePionsPerf.h.

◆ m_nnormtype

int GetLCSinglePionsPerf::m_nnormtype
private

Definition at line 85 of file GetLCSinglePionsPerf.h.

◆ m_nphibin

int GetLCSinglePionsPerf::m_nphibin
private

Definition at line 76 of file GetLCSinglePionsPerf.h.

◆ m_ntagcases

int GetLCSinglePionsPerf::m_ntagcases
private

Definition at line 87 of file GetLCSinglePionsPerf.h.

◆ m_outputFile

TFile* GetLCSinglePionsPerf::m_outputFile
private

Definition at line 65 of file GetLCSinglePionsPerf.h.

◆ m_outputFileName

std::string GetLCSinglePionsPerf::m_outputFileName
private

Definition at line 64 of file GetLCSinglePionsPerf.h.

◆ m_phimax

float GetLCSinglePionsPerf::m_phimax
private

Definition at line 78 of file GetLCSinglePionsPerf.h.

◆ m_phimin

float GetLCSinglePionsPerf::m_phimin
private

Definition at line 77 of file GetLCSinglePionsPerf.h.

◆ m_RecoEfficiency_vs_ebeam

std::vector<TH1F *> GetLCSinglePionsPerf::m_RecoEfficiency_vs_ebeam[2]
private

Definition at line 122 of file GetLCSinglePionsPerf.h.

◆ m_RecoEfficiency_vs_eta

std::vector<TH1F *> GetLCSinglePionsPerf::m_RecoEfficiency_vs_eta[2]
private

Definition at line 121 of file GetLCSinglePionsPerf.h.

◆ m_SumCalibHitAssignedOverEbeam_vs_eta

std::vector<TProfile *> GetLCSinglePionsPerf::m_SumCalibHitAssignedOverEbeam_vs_eta
private

Definition at line 128 of file GetLCSinglePionsPerf.h.

◆ m_SumCalibHitAssignedOverEbeam_vs_etaphi

std::vector<TProfile2D *> GetLCSinglePionsPerf::m_SumCalibHitAssignedOverEbeam_vs_etaphi
private

Definition at line 129 of file GetLCSinglePionsPerf.h.

◆ m_SumCalibHitOverEbeam_vs_eta

std::vector<TProfile *> GetLCSinglePionsPerf::m_SumCalibHitOverEbeam_vs_eta
private

Definition at line 124 of file GetLCSinglePionsPerf.h.

◆ m_truthPiEngFraction

float GetLCSinglePionsPerf::m_truthPiEngFraction
private

Definition at line 92 of file GetLCSinglePionsPerf.h.

◆ m_useGoodClus

bool GetLCSinglePionsPerf::m_useGoodClus
private

Definition at line 100 of file GetLCSinglePionsPerf.h.

◆ m_usePionClusters

bool GetLCSinglePionsPerf::m_usePionClusters
private

Definition at line 102 of file GetLCSinglePionsPerf.h.

◆ m_useRecoEfficiency

bool GetLCSinglePionsPerf::m_useRecoEfficiency
private

Definition at line 99 of file GetLCSinglePionsPerf.h.

◆ m_validMoments

moment_name_vector GetLCSinglePionsPerf::m_validMoments
private

Definition at line 68 of file GetLCSinglePionsPerf.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
GetLCSinglePionsPerf::m_netabin
int m_netabin
Definition: GetLCSinglePionsPerf.h:72
GetLCSinglePionsPerf::m_dphi
float m_dphi
Definition: GetLCSinglePionsPerf.h:79
GetLCSinglePionsPerf::m_ncluscoll
int m_ncluscoll
Definition: GetLCSinglePionsPerf.h:86
CaloDmDescrArea::DMA_EMB3_TILE0
@ DMA_EMB3_TILE0
Definition: CaloDmDescrArea.h:28
beamspotman.r
def r
Definition: beamspotman.py:676
CaloCalibrationHitContainer
Definition: CaloCalibrationHitContainer.h:25
GetLCDefs::Unknown
@ Unknown
Definition: GetLCDefs.h:21
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
GetLCSinglePionsPerf::m_engTag_vs_eta
std::vector< std::vector< TProfile * > > m_engTag_vs_eta
Definition: GetLCSinglePionsPerf.h:108
GetLCSinglePionsPerf::m_clusMoment_vs_ebeam
std::vector< std::vector< std::vector< TProfile * > > > m_clusMoment_vs_ebeam
Definition: GetLCSinglePionsPerf.h:119
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_UNCLASS
@ ENG_CALIB_DEAD_UNCLASS
Attached Calibration Hit energy in dead material in unclassified areas of the detector.
Definition: CaloCluster_v1.h:246
GetLCSinglePionsPerf::fill_calibhits
int fill_calibhits(const xAOD::CaloClusterContainer &clusColl, const EventContext &ctx)
Definition: GetLCSinglePionsPerf.cxx:1167
GetLCSinglePionsPerf::m_outputFile
TFile * m_outputFile
Definition: GetLCSinglePionsPerf.h:65
GetLCSinglePionsPerf::m_nnormtype
int m_nnormtype
Definition: GetLCSinglePionsPerf.h:85
GetLCSinglePionsPerf::kTAG
@ kTAG
Definition: GetLCSinglePionsPerf.h:54
GetLCSinglePionsPerf::m_mc_phi
double m_mc_phi
Definition: GetLCSinglePionsPerf.h:133
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CaloRecoStatus::TAGGEDUNKNOWN
@ TAGGEDUNKNOWN
Definition: CaloRecoStatus.h:41
CaloDmDescrManager::get_element
CaloDmDescrElement * get_element(const Identifier &cellId) const
Definition: CaloDmDescrManager.cxx:107
GetLCSinglePionsPerf::m_clusMoment_vs_eta
std::vector< std::vector< std::vector< TProfile * > > > m_clusMoment_vs_eta
Definition: GetLCSinglePionsPerf.h:118
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
AtlasDetectorID::is_lar
bool is_lar(Identifier id) const
Definition: AtlasDetectorID.h:689
GetLCSinglePionsPerf::m_mc_eta
double m_mc_eta
Definition: GetLCSinglePionsPerf.h:132
GetLCSinglePionsPerf::m_SumCalibHitOverEbeam_vs_eta
std::vector< TProfile * > m_SumCalibHitOverEbeam_vs_eta
Definition: GetLCSinglePionsPerf.h:124
dqt_zlumi_pandas.hname
string hname
Definition: dqt_zlumi_pandas.py:279
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
GetLCSinglePionsPerf::m_logenermax
float m_logenermax
Definition: GetLCSinglePionsPerf.h:82
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
GetLCSinglePionsPerf::m_engNoiseClusSpect
std::vector< std::vector< TH1F * > > m_engNoiseClusSpect
Definition: GetLCSinglePionsPerf.h:115
CaloDmDescrArea::DMA_EMB1
@ DMA_EMB1
Definition: CaloDmDescrArea.h:26
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_LEAKAGE
@ ENG_CALIB_DEAD_LEAKAGE
Attached Calibration Hit energy in dead material behind calorimeters.
Definition: CaloCluster_v1.h:243
GetLCSinglePionsPerf::m_doEngNoiseClus
bool m_doEngNoiseClus
Definition: GetLCSinglePionsPerf.h:96
plotBeamSpotCompare.x2
x2
Definition: plotBeamSpotCompare.py:218
GetLCSinglePionsPerf::m_truthPiEngFraction
float m_truthPiEngFraction
Definition: GetLCSinglePionsPerf.h:92
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
CaloDmDescrArea::DMA_SCN
@ DMA_SCN
Definition: CaloDmDescrArea.h:29
tree
TChain * tree
Definition: tile_monitor.h:30
python.SystemOfUnits.MeV
int MeV
Definition: SystemOfUnits.py:154
GetLCSinglePionsPerf::moment_name_pair
std::pair< std::string, xAOD::CaloCluster::MomentType > moment_name_pair
Definition: GetLCSinglePionsPerf.h:50
GetLCSinglePionsPerf::kTAGUNK
@ kTAGUNK
Definition: GetLCSinglePionsPerf.h:54
GetLCSinglePionsPerf::m_doClusMoments
bool m_doClusMoments
Definition: GetLCSinglePionsPerf.h:97
M_PI
#define M_PI
Definition: ActiveFraction.h:11
xAOD::CaloCluster_v1::ENG_CALIB_TILEG3
@ ENG_CALIB_TILEG3
Calibration Hit energy inside the cluster scintillator.
Definition: CaloCluster_v1.h:222
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
python.atlas_oh.im
im
Definition: atlas_oh.py:167
xAOD::CaloCluster_v1::ENG_CALIB_OUT_M
@ ENG_CALIB_OUT_M
Attached Calibration Hit energy outside clusters but inside the calorimeter with medium matching (Ang...
Definition: CaloCluster_v1.h:200
xAOD::CaloCluster_v1::CENTER_LAMBDA
@ CENTER_LAMBDA
Shower depth at Cluster Centroid.
Definition: CaloCluster_v1.h:136
GetLCSinglePionsPerf::m_etamax
float m_etamax
Definition: GetLCSinglePionsPerf.h:74
GetLCSinglePionsPerf::m_nlogenerbin2
int m_nlogenerbin2
Definition: GetLCSinglePionsPerf.h:83
fitman.mx
mx
Definition: fitman.py:520
GetLCSinglePionsPerf::m_ntagcases
int m_ntagcases
Definition: GetLCSinglePionsPerf.h:87
GetLCSinglePionsPerf::m_dlogener
float m_dlogener
Definition: GetLCSinglePionsPerf.h:84
GetLCSinglePionsPerf::m_doCalibHitsValidation
bool m_doCalibHitsValidation
Definition: GetLCSinglePionsPerf.h:101
xAOD::CaloCluster_v1::ENG_CALIB_EMB0
@ ENG_CALIB_EMB0
Calibration Hit energy inside the cluster barrel presampler.
Definition: CaloCluster_v1.h:218
GetLCSinglePionsPerf::m_mc_etabin
int m_mc_etabin
Definition: GetLCSinglePionsPerf.h:134
GetLCSinglePionsPerf::m_engPionSpect
std::vector< std::vector< TH1F * > > m_engPionSpect
Definition: GetLCSinglePionsPerf.h:113
GetLCSinglePionsPerf::kLEVEL_CALIBHIT_IDEAL
@ kLEVEL_CALIBHIT_IDEAL
Definition: GetLCSinglePionsPerf.h:56
CaloCell_Base_ID::calo_sample
int calo_sample(const Identifier id) const
returns an int taken from Sampling enum and describing the subCalo to which the Id belongs.
Definition: CaloCell_Base_ID.cxx:141
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
CaloDmDescrArea::DMA_EME12
@ DMA_EME12
Definition: CaloDmDescrArea.h:33
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_TILE0
@ ENG_CALIB_DEAD_TILE0
Attached Calibration Hit energy in dead material between EMB3 and TILE0.
Definition: CaloCluster_v1.h:230
SG::ReadHandleKey< CaloCalibrationHitContainer >
read_hist_ntuple.h1
h1
Definition: read_hist_ntuple.py:21
GetLCSinglePionsPerf::m_doEngRecOverTruth
bool m_doEngRecOverTruth
Definition: GetLCSinglePionsPerf.h:93
x
#define x
GetLCSinglePionsPerf::angle_mollier_factor
static double angle_mollier_factor(double x)
Definition: GetLCSinglePionsPerf.cxx:1288
Identifier::is_valid
bool is_valid() const
Check if id is in a valid state.
GetLCSinglePionsPerf::m_engTag_vs_ebeam
std::vector< std::vector< TProfile * > > m_engTag_vs_ebeam
Definition: GetLCSinglePionsPerf.h:109
CaloCell_ID_FCS::TileGap3
@ TileGap3
Definition: FastCaloSim_CaloCell_ID.h:36
master.gen
gen
Definition: master.py:32
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
GetLCSinglePionsPerf::kTOPO_W
@ kTOPO_W
Definition: GetLCSinglePionsPerf.h:53
GetLCSinglePionsPerf::m_distance_cut
double m_distance_cut
Definition: GetLCSinglePionsPerf.h:70
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
CaloDmDescrManager::instance
static const CaloDmDescrManager * instance()
Definition: CaloDmDescrManager.cxx:67
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
GetLCSinglePionsPerf::kMOM_MISS
@ kMOM_MISS
Definition: GetLCSinglePionsPerf.h:55
CaloDmDescrArea::DMA_LEAK
@ DMA_LEAK
Definition: CaloDmDescrArea.h:44
GetLCSinglePionsPerf::kTAGEM
@ kTAGEM
Definition: GetLCSinglePionsPerf.h:54
GetLCSinglePionsPerf::kMOM_MCENER
@ kMOM_MCENER
Definition: GetLCSinglePionsPerf.h:55
CaloDmDescrArea::DMA_EMB0
@ DMA_EMB0
Definition: CaloDmDescrArea.h:25
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
GetLCSinglePionsPerf::m_logenermin
float m_logenermin
Definition: GetLCSinglePionsPerf.h:81
GetLCSinglePionsPerf::m_clusterCollNames
SG::ReadHandleKeyArray< xAOD::CaloClusterContainer > m_clusterCollNames
Definition: GetLCSinglePionsPerf.h:63
GetLCSinglePionsPerf::m_phimax
float m_phimax
Definition: GetLCSinglePionsPerf.h:78
GetLCSinglePionsPerf::m_SumCalibHitAssignedOverEbeam_vs_eta
std::vector< TProfile * > m_SumCalibHitAssignedOverEbeam_vs_eta
Definition: GetLCSinglePionsPerf.h:128
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
GetLCSinglePionsPerf::m_id_helper
const AtlasDetectorID * m_id_helper
Definition: GetLCSinglePionsPerf.h:58
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
GetLCSinglePionsPerf::m_useRecoEfficiency
bool m_useRecoEfficiency
Definition: GetLCSinglePionsPerf.h:99
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
GetLCSinglePionsPerf::kLEVEL_PARTICLE
@ kLEVEL_PARTICLE
Definition: GetLCSinglePionsPerf.h:56
GetLCSinglePionsPerf::m_deta
float m_deta
Definition: GetLCSinglePionsPerf.h:75
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
GetLCSinglePionsPerf::kMOM_CLS1
@ kMOM_CLS1
Definition: GetLCSinglePionsPerf.h:55
D3PDSizeSummary.ff
ff
Definition: D3PDSizeSummary.py:305
python.TrigEgammaMonitorHelper.TProfile
def TProfile(*args, **kwargs)
Definition: TrigEgammaMonitorHelper.py:81
GetLCSinglePionsPerf::fill_moments
int fill_moments(const xAOD::CaloClusterContainer &clusColl, const EventContext &ctx)
Definition: GetLCSinglePionsPerf.cxx:944
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::CaloCluster_v1::ENG_CALIB_TOT
@ ENG_CALIB_TOT
Calibration Hit energy inside the cluster.
Definition: CaloCluster_v1.h:195
GetLCSinglePionsPerf::kMOM_CLS2
@ kMOM_CLS2
Definition: GetLCSinglePionsPerf.h:55
GetLCSinglePionsPerf::m_validMoments
moment_name_vector m_validMoments
Definition: GetLCSinglePionsPerf.h:68
CaloDmDescrArea::DMA_DEFCALC
@ DMA_DEFCALC
Definition: CaloDmDescrArea.h:45
GetLCSinglePionsPerf::m_RecoEfficiency_vs_ebeam
std::vector< TH1F * > m_RecoEfficiency_vs_ebeam[2]
Definition: GetLCSinglePionsPerf.h:122
AtlasDetectorID::is_tile_dm
bool is_tile_dm(Identifier id) const
Definition: AtlasDetectorID.h:748
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_FCAL
@ ENG_CALIB_DEAD_FCAL
Attached Calibration Hit energy in dead material before FCAL, between FCAL and HEC.
Definition: CaloCluster_v1.h:241
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AtlasDetectorID::is_tile
bool is_tile(Identifier id) const
Definition: AtlasDetectorID.h:695
CaloDmDescrArea::DMA_FCAL0
@ DMA_FCAL0
Definition: CaloDmDescrArea.h:43
GetLCSinglePionsPerf::m_engNoiseClus_vs_eta
std::vector< TProfile * > m_engNoiseClus_vs_eta
Definition: GetLCSinglePionsPerf.h:116
GetLCSinglePionsPerf::kMOM_CLS0
@ kMOM_CLS0
Definition: GetLCSinglePionsPerf.h:55
GetLCSinglePionsPerf::m_phimin
float m_phimin
Definition: GetLCSinglePionsPerf.h:77
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
CaloDmDescrElement
Definition: CaloDmDescrManager.h:33
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
GetLCSinglePionsPerf::m_useGoodClus
bool m_useGoodClus
Definition: GetLCSinglePionsPerf.h:100
McEventCollection
This defines the McEventCollection, which is really just an ObjectVector of McEvent objects.
Definition: McEventCollection.h:33
xAOD::CaloCluster_v1::FIRST_ENG_DENS
@ FIRST_ENG_DENS
First Moment in E/V.
Definition: CaloCluster_v1.h:143
GetLCSinglePionsPerf::m_nlogenerbin
int m_nlogenerbin
Definition: GetLCSinglePionsPerf.h:80
GetLCSinglePionsPerf::m_outputFileName
std::string m_outputFileName
Definition: GetLCSinglePionsPerf.h:64
GetLCSinglePionsPerf::kLEVEL_CALIBHIT
@ kLEVEL_CALIBHIT
Definition: GetLCSinglePionsPerf.h:56
CaloDmDescrArea::DMA_HEC_FCAL
@ DMA_HEC_FCAL
Definition: CaloDmDescrArea.h:40
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
CaloRecoStatus::checkStatus
virtual bool checkStatus(const StatusIndicator &statusIndicator) const
Check status.
Definition: CaloRecoStatus.h:117
GetLCSinglePionsPerf::m_etamin
float m_etamin
Definition: GetLCSinglePionsPerf.h:73
CaloDmDescrArea::DMA_EME3_HEC0
@ DMA_EME3_HEC0
Definition: CaloDmDescrArea.h:37
HepMC::ConstGenParticlePtr
const GenParticle * ConstGenParticlePtr
Definition: GenParticle.h:38
CaloCalibrationHit
Class to store calorimeter calibration hit.
Definition: CaloCalibrationHit.h:23
xAOD::CaloCluster_v1::ENG_CALIB_EME0
@ ENG_CALIB_EME0
Calibration Hit energy inside the cluster endcap presampler.
Definition: CaloCluster_v1.h:220
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
CaloDmDescrArea::DMA_EME0
@ DMA_EME0
Definition: CaloDmDescrArea.h:31
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_HEC0
@ ENG_CALIB_DEAD_HEC0
Attached Calibration Hit energy in dead material between EME3 and HEC0.
Definition: CaloCluster_v1.h:238
GetLCSinglePionsPerf::m_nphibin
int m_nphibin
Definition: GetLCSinglePionsPerf.h:76
CaloDmDescrArea::DMA_MAX
@ DMA_MAX
Definition: CaloDmDescrArea.h:47
GetLCSinglePionsPerf::m_mc_ener
double m_mc_ener
Definition: GetLCSinglePionsPerf.h:131
GetLCSinglePionsPerf::m_usePionClusters
bool m_usePionClusters
Definition: GetLCSinglePionsPerf.h:102
CaloRecoStatus::TAGGEDEM
@ TAGGEDEM
Definition: CaloRecoStatus.h:38
GetLCSinglePionsPerf::m_engRecSpect
std::vector< std::vector< std::vector< TH1F * > > > m_engRecSpect
Definition: GetLCSinglePionsPerf.h:111
LArCellBinning.xbins
int xbins
Definition: LArCellBinning.py:163
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_TILEG3
@ ENG_CALIB_DEAD_TILEG3
Attached Calibration Hit energy in dead material before scintillator.
Definition: CaloCluster_v1.h:232
GetLCSinglePionsPerf::m_engRecOverTruth_vs_eta
std::vector< std::vector< std::vector< TProfile * > > > m_engRecOverTruth_vs_eta
Definition: GetLCSinglePionsPerf.h:105
GetLCSinglePionsPerf::m_DMCalibrationHitContainerNames
SG::ReadHandleKeyArray< CaloCalibrationHitContainer > m_DMCalibrationHitContainerNames
Definition: GetLCSinglePionsPerf.h:67
GetLCSinglePionsPerf::m_CalibrationHitContainerNames
SG::ReadHandleKeyArray< CaloCalibrationHitContainer > m_CalibrationHitContainerNames
Definition: GetLCSinglePionsPerf.h:66
GetLCSinglePionsPerf::m_calo_id
const CaloCell_ID * m_calo_id
Definition: GetLCSinglePionsPerf.h:59
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
GetLCSinglePionsPerf::kMOM_SUMCLS
@ kMOM_SUMCLS
Definition: GetLCSinglePionsPerf.h:55
a
TList * a
Definition: liststreamerinfos.cxx:10
GetLCSinglePionsPerf::kTAGHAD
@ kTAGHAD
Definition: GetLCSinglePionsPerf.h:54
GetLCSinglePionsPerf::m_DefaultCalculatorOverEbeam_vs_eta
std::vector< TProfile * > m_DefaultCalculatorOverEbeam_vs_eta
Definition: GetLCSinglePionsPerf.h:126
AtlasDetectorID::is_lar_dm
bool is_lar_dm(Identifier id) const
LAr/Tile dead material:
Definition: AtlasDetectorID.h:736
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_TOT
@ ENG_CALIB_DEAD_TOT
Attached Calibration Hit energy in dead material.
Definition: CaloCluster_v1.h:224
h
GetLCSinglePionsPerf::m_SumCalibHitAssignedOverEbeam_vs_etaphi
std::vector< TProfile2D * > m_SumCalibHitAssignedOverEbeam_vs_etaphi
Definition: GetLCSinglePionsPerf.h:129
GetLCSinglePionsPerf::kTOPO
@ kTOPO
Definition: GetLCSinglePionsPerf.h:53
AtlasDetectorID::show_to_string
std::string show_to_string(Identifier id, const IdContext *context=0, char sep='.') const
or provide the printout in string form
Definition: AtlasDetectorID.cxx:574
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CaloCell_ID_FCS::PreSamplerE
@ PreSamplerE
Definition: FastCaloSim_CaloCell_ID.h:23
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
DeMoScan.first
bool first
Definition: DeMoScan.py:536
GetLCSinglePionsPerf::m_doEngTag
bool m_doEngTag
Definition: GetLCSinglePionsPerf.h:94
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
CaloRecoStatus::getStatusWord
virtual const store_type & getStatusWord() const
retrieve the entire status word
Definition: CaloRecoStatus.h:112
GetLCSinglePionsPerf::m_nmoments
int m_nmoments
Definition: GetLCSinglePionsPerf.h:88
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
GetLCSinglePionsPerf::fill_reco
int fill_reco(const xAOD::CaloClusterContainer &clusColl, const EventContext &ctx)
Definition: GetLCSinglePionsPerf.cxx:755
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
CaloRecoStatus::TAGGEDHAD
@ TAGGEDHAD
Definition: CaloRecoStatus.h:39
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
xAOD::CaloCluster_v1::ENG_CALIB_OUT_L
@ ENG_CALIB_OUT_L
Attached Calibration Hit energy outside clusters but inside the calorimeter with loose matching (Angl...
Definition: CaloCluster_v1.h:196
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_EME0
@ ENG_CALIB_DEAD_EME0
Attached Calibration Hit energy in dead material before EME0, between EME0 and EME1.
Definition: CaloCluster_v1.h:235
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
xAOD::CaloCluster_v1::ENG_CALIB_OUT_T
@ ENG_CALIB_OUT_T
Attached Calibration Hit energy outside clusters but inside the calorimeter with tight matching (Angl...
Definition: CaloCluster_v1.h:204
GetLCSinglePionsPerf::m_RecoEfficiency_vs_eta
std::vector< TH1F * > m_RecoEfficiency_vs_eta[2]
Definition: GetLCSinglePionsPerf.h:121
GetLCSinglePionsPerf::m_nmomsums
int m_nmomsums
Definition: GetLCSinglePionsPerf.h:89
GetLCSinglePionsPerf::m_doEngRecSpect
bool m_doEngRecSpect
Definition: GetLCSinglePionsPerf.h:95
CaloDmDescrArea::DMA_ALL
@ DMA_ALL
Definition: CaloDmDescrArea.h:24
GetLCSinglePionsPerf::kTOPO_EM
@ kTOPO_EM
Definition: GetLCSinglePionsPerf.h:53
GetLCSinglePionsPerf::m_mc_phibin
int m_mc_phibin
Definition: GetLCSinglePionsPerf.h:136
GetLCSinglePionsPerf::m_engRecOverTruth_vs_ebeam
std::vector< std::vector< std::vector< TProfile * > > > m_engRecOverTruth_vs_ebeam
Definition: GetLCSinglePionsPerf.h:106
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
CaloRecoStatus
reconstruction status indicator
Definition: CaloRecoStatus.h:12
GetLCSinglePionsPerf::m_clusterBasicCollName
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_clusterBasicCollName
Definition: GetLCSinglePionsPerf.h:62
GetLCSinglePionsPerf::m_mc_enerbin
int m_mc_enerbin
Definition: GetLCSinglePionsPerf.h:135
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_EMB0
@ ENG_CALIB_DEAD_EMB0
Attached Calibration Hit energy in dead material before EMB0, between EMB0 and EMB1.
Definition: CaloCluster_v1.h:227
GetLCSinglePionsPerf::m_doRecoEfficiency
bool m_doRecoEfficiency
Definition: GetLCSinglePionsPerf.h:98
fitman.k
k
Definition: fitman.py:528
GenParticle
@ GenParticle
Definition: TruthClasses.h:30
CaloDmDescrManager::get_dm_area
int get_dm_area(const Identifier &cellId) const
Definition: CaloDmDescrManager.cxx:147
ServiceHandle< ICondSvc >
GetLCSinglePionsPerf::kTOPO_OOC
@ kTOPO_OOC
Definition: GetLCSinglePionsPerf.h:53
GetLCSinglePionsPerf::m_caloDmDescrManager
const CaloDmDescrManager * m_caloDmDescrManager
Definition: GetLCSinglePionsPerf.h:60
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Nov 7 2024 21:44:43 for ATLAS Offline Software by   doxygen 1.8.18