Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
TrigEgammaMonitorAnalysisAlgorithm.cxx
Go to the documentation of this file.
1 
2 
3 #include "TrigEgammaMonitorAnalysisAlgorithm.h"
4 #include "AthContainers/Decorator.h"
5 
6 
7 
8 TrigEgammaMonitorAnalysisAlgorithm::TrigEgammaMonitorAnalysisAlgorithm( const std::string& name, ISvcLocator* pSvcLocator ):
9  TrigEgammaMonitorBaseAlgorithm( name, pSvcLocator )
10 
11 {}
12 
13 TrigEgammaMonitorAnalysisAlgorithm::~TrigEgammaMonitorAnalysisAlgorithm()
14 {}
15 
16 
17 StatusCode TrigEgammaMonitorAnalysisAlgorithm::initialize()
18 {
19 
20  ATH_CHECK(TrigEgammaMonitorBaseAlgorithm::initialize());
21 
22  return StatusCode::SUCCESS;
23 }
24 
25 
26 // *********************************************************************************
27 
28 
29 
30 void TrigEgammaMonitorAnalysisAlgorithm::fillLabel( const ToolHandle<GenericMonitoringTool>& groupHandle,
31  const std::string &histname,
32  const std::string &label ) const
33 {
34  auto mon = Monitored::Scalar<std::string>( histname, label );
35  fill( groupHandle, mon );
36 }
37 
38 
39 
40 // *********************************************************************************
41 
42 void TrigEgammaMonitorAnalysisAlgorithm::fillEfficiencies( const std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >>& pairObjs,
43  const TrigInfo& info, const bool onlyHLT ) const
44 {
45 
46  std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pair_vec;
47  std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pair_iso_vec;
48 
49  std::vector<asg::AcceptData> accept_vec;
50  std::vector<asg::AcceptData> accept_iso_vec;
51 
52  std::vector<asg::AcceptData> emu_accept_vec;
53  std::vector<asg::AcceptData> emu_accept_iso_vec;
54 
55 
56  for( auto pairObj : pairObjs ){
57 
58  if(pairObj.first->type()==xAOD::Type::Electron){
59 
60  auto passBits=tdt()->isPassedBits(info.trigger);
61  if(!((passBits & TrigDefs::L1_isPassedAfterVeto) && ((passBits & TrigDefs::EF_prescaled)==0))){
62  ATH_MSG_DEBUG("Prescaled trigger: " << info.trigger << " Skipping to normalize efficiencies");
63  continue;
64  }
65  const xAOD::Electron* el = static_cast<const xAOD::Electron *> (pairObj.first);
66  float et = getEt(el)/Gaudi::Units::GeV;
67  if(et < info.etthr-5.0) continue;
68 
69  }else if(pairObj.first->type()==xAOD::Type::Photon){
70  float et = getCluster_et(pairObj.first)/Gaudi::Units::GeV;
71  if(et < info.etthr-5.0) continue;
72 
73  // Applying FixedCutLoose isolation on the offline photon as recommended in the twiki:
74  // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/IsolationSelectionTool#Photons
75  bool pass_CaloIso = getIsolation_topoetcone20(pairObj.first)/getCluster_et(pairObj.first) < 0.065;
76  bool pass_trkIso = getIsolation_ptcone20(pairObj.first)/getCluster_et(pairObj.first) < 0.05;
77 
78  if (!pass_CaloIso || !pass_trkIso){
79  continue; // pass FixedCutLoose offline isolation
80  }
81  } // Offline photon
82 
83 
84  // Good pair to be measure
85  if(m_doEmulation){ // Emulation
86  bool valid=false;
87  auto acceptData = m_emulatorTool->emulate( pairObj.second, info.trigger , valid);
88  // skip this probe since the emulation is not possible. Avoid diff denominators between emulation and efficiecy
89  if(!valid) {
90  ATH_MSG_DEBUG("Emulation fail. Skip this probe...");
91  continue;
92  }
93  emu_accept_vec.push_back( acceptData );
94  static const SG::Decorator<bool> IsolatedDec("Isolated");
95  if( IsolatedDec(*pairObj.first) ){
96  emu_accept_iso_vec.push_back(acceptData);
97  }
98  }
99 
100  // Good pair to be measure
101  { // Efficiency
102  pair_vec.push_back(pairObj);
103  auto acceptData = setAccept( pairObj.second, info, onlyHLT );
104  accept_vec.push_back(acceptData);
105  static const SG::Decorator<bool> IsolatedDec("Isolated");
106  if( IsolatedDec(*pairObj.first) ){
107  pair_iso_vec.push_back(pairObj);
108  accept_iso_vec.push_back(acceptData);
109  }
110  }
111 
112 
113  }
114 
115  std::string dirname= "Efficiency";
116  std::string l2step = "FastElectron";
117  if( info.signature == "Electron" ){
118  l2step = "FastElectron";
119  }else if( info.signature == "Photon" ){
120  l2step = "FastPhoton";
121  }
122  fillEfficiency( "L1Calo" , "L1Calo" , info.pidname, info, pair_vec , accept_vec, dirname);
123  fillEfficiency( "FastCalo" , "L2Calo" , info.pidname, info, pair_vec , accept_vec, dirname);
124  fillEfficiency( l2step , "L2" , info.pidname, info, pair_vec , accept_vec, dirname);
125  fillEfficiency( "PrecisionCalo" , "EFCalo" , info.pidname, info, pair_vec , accept_vec, dirname);
126  fillEfficiency( "HLT" , "HLT" , info.pidname, info, pair_vec , accept_vec, dirname);
127 
128 
129  if( m_detailedHists ){
130  for( const auto& pid : m_isemname ){
131  fillEfficiency( "HLT_" + pid, "HLT", pid, info, pair_vec , accept_vec, dirname);
132  fillEfficiency( "HLT_" + pid + "Iso", "HLT", pid, info, pair_iso_vec, accept_iso_vec, dirname );
133  }
134  for( const auto& pid : m_lhname ){
135  fillEfficiency( "HLT_" + pid, "HLT", pid, info, pair_vec, accept_vec, dirname );
136  fillEfficiency( "HLT_" + pid + "Iso", "HLT", pid, info, pair_iso_vec, accept_iso_vec, dirname );
137  }
138  }
139 
140  // Fill emulator efficiency plots
141  if ( m_doEmulation ){
142  dirname= "Emulation";
143  fillEfficiency( "L1Calo" , "L1Calo" , info.pidname, info, pair_vec , emu_accept_vec, dirname);
144  fillEfficiency( "FastCalo" , "L2Calo" , info.pidname, info, pair_vec , emu_accept_vec, dirname);
145  fillEfficiency( l2step , "L2" , info.pidname, info, pair_vec , emu_accept_vec, dirname);
146  fillEfficiency( "PrecisionCalo" , "EFCalo" , info.pidname, info, pair_vec , emu_accept_vec, dirname);
147  fillEfficiency( "HLT" , "HLT" , info.pidname, info, pair_vec , emu_accept_vec, dirname);
148  }
149 
150  // Fill Inefficiencies
151  fillInefficiency( info.pidname, info, pair_vec , accept_vec);
152 
153 }
154 
155 
156 void TrigEgammaMonitorAnalysisAlgorithm::fillEfficiency( const std::string &subgroup,
157  const std::string &level,
158  const std::string &pidword,
159  const TrigInfo& info,
160  const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision* >>& pairObjs,
161  const std::vector< asg::AcceptData >& acceptObjs ,
162  const std::string& dirname ) const
163 {
164  const float etthr = info.etthr;
165  const std::string trigger = info.trigger;
166  auto monGroup = getGroup( trigger + "_"+dirname+"_" + subgroup );
167 
168  std::vector<float> et_vec, highet_vec, pt_vec, eta_vec, phi_vec, avgmu_vec, npvtx_vec,et_slice0_vec,et_slice1_vec,et_slice2_vec,et_slice3_vec, ptvarcone20rel_vec, ptvarcone30rel_vec, z0_vec, d0_vec;
169  std::vector<float> match_et_vec, match_highet_vec, match_pt_vec, match_eta_vec, match_phi_vec, match_avgmu_vec, match_npvtx_vec, match_ptvarcone20rel_vec, match_ptvarcone30rel_vec, match_z0_vec, match_d0_vec;
170  std::vector<bool> et_passed_vec, et_failed_vec, highet_passed_vec, highet_failed_vec, pt_passed_vec, eta_passed_vec, eta_failed_vec, phi_passed_vec, avgmu_passed_vec, npvtx_passed_vec;
171  std::vector<bool> ptvarcone20rel_passed_vec, ptvarcone30rel_passed_vec, z0_passed_vec, d0_passed_vec;
172  std::vector<bool> et_slice0_passed_vec,et_slice1_passed_vec,et_slice2_passed_vec,et_slice3_passed_vec;
173 
174  auto et_col = Monitored::Collection( "et" , et_vec );
175  auto highet_col = Monitored::Collection( "highet" , highet_vec );
176  auto pt_col = Monitored::Collection( "pt" , pt_vec );
177  auto eta_col = Monitored::Collection( "eta" , eta_vec );
178  auto phi_col = Monitored::Collection( "phi" , phi_vec );
179  auto avgmu_col = Monitored::Collection( "avgmu" , avgmu_vec );
180  auto npvtx_col = Monitored::Collection( "npvtx" , npvtx_vec );
181  auto ptvarcone20rel_col = Monitored::Collection( "ptvarcone20rel" , ptvarcone20rel_vec );
182  auto ptvarcone30rel_col = Monitored::Collection( "ptvarcone30rel" , ptvarcone30rel_vec );
183 
184  auto z0_col = Monitored::Collection( "z0" , z0_vec );
185  auto d0_col = Monitored::Collection( "d0" , d0_vec );
186 
187  auto match_et_col = Monitored::Collection( "match_et" , match_et_vec );
188  auto match_highet_col = Monitored::Collection( "match_ethigh" , match_highet_vec );
189  auto match_pt_col = Monitored::Collection( "match_pt" , match_pt_vec );
190  auto match_eta_col = Monitored::Collection( "match_eta" , match_eta_vec );
191  auto match_phi_col = Monitored::Collection( "match_phi" , match_phi_vec );
192  auto match_avgmu_col = Monitored::Collection( "match_avgmu" , match_avgmu_vec );
193  auto match_npvtx_col = Monitored::Collection( "match_npvtx" , match_npvtx_vec );
194  auto match_ptvarcone20rel_col = Monitored::Collection( "match_ptvarcone20rel" , match_ptvarcone20rel_vec );
195  auto match_ptvarcone30rel_col = Monitored::Collection( "match_ptvarcone30rel" , match_ptvarcone30rel_vec );
196 
197  auto match_z0_col = Monitored::Collection( "match_z0" , match_z0_vec );
198  auto match_d0_col = Monitored::Collection( "match_d0" , match_d0_vec );
199 
200  auto et_passed_col = Monitored::Collection( "et_passed" , et_passed_vec );
201  auto et_failed_col = Monitored::Collection( "et_failed" , et_failed_vec );
202  auto highet_passed_col = Monitored::Collection( "highet_passed" , highet_passed_vec );
203  auto highet_failed_col = Monitored::Collection( "highet_failed" , highet_failed_vec );
204  auto pt_passed_col = Monitored::Collection( "pt_passed" , pt_passed_vec );
205  auto eta_passed_col = Monitored::Collection( "eta_passed" , eta_passed_vec );
206  auto eta_failed_col = Monitored::Collection( "eta_failed" , eta_failed_vec );
207  auto phi_passed_col = Monitored::Collection( "phi_passed" , phi_passed_vec );
208  auto avgmu_passed_col = Monitored::Collection( "avgmu_passed" , avgmu_passed_vec );
209  auto npvtx_passed_col = Monitored::Collection( "npvtx_passed" , npvtx_passed_vec );
210  auto ptvarcone20rel_passed_col = Monitored::Collection( "ptvarcone20rel_passed" , ptvarcone20rel_passed_vec );
211  auto ptvarcone30rel_passed_col = Monitored::Collection( "ptvarcone30rel_passed" , ptvarcone30rel_passed_vec );
212 
213  auto z0_passed_col = Monitored::Collection( "z0_passed" , z0_passed_vec );
214  auto d0_passed_col = Monitored::Collection( "d0_passed" , d0_passed_vec );
215 
216  // For ET efficiency analysis in eta slices
217  auto et_slice0_col = Monitored::Collection( "et_slice0" , et_slice0_vec );
218  auto et_slice1_col = Monitored::Collection( "et_slice1" , et_slice1_vec );
219  auto et_slice2_col = Monitored::Collection( "et_slice2" , et_slice2_vec );
220  auto et_slice3_col = Monitored::Collection( "et_slice3" , et_slice3_vec );
221 
222  auto et_slice0_passed_col = Monitored::Collection( "et_slice0_passed" , et_slice0_passed_vec );
223  auto et_slice1_passed_col = Monitored::Collection( "et_slice1_passed" , et_slice1_passed_vec );
224  auto et_slice2_passed_col = Monitored::Collection( "et_slice2_passed" , et_slice2_passed_vec );
225  auto et_slice3_passed_col = Monitored::Collection( "et_slice3_passed" , et_slice3_passed_vec );
226 
227  unsigned iObj=0;
228 
229  SG::Decorator<bool> pidwordDec("is"+pidword);
230  for( auto pairObj : pairObjs ){
231 
232  bool pid=true;
233  bool isPassed = acceptObjs[iObj].getCutResult( level );
234  float et=0.;
235  float ptvarcone20rel = -99.0;
236  float ptvarcone30rel = -99.0;
237  float z0 = -99.0;
238  float d0 = -99.0;
239  const auto *eg = pairObj.first;
240  ATH_MSG_DEBUG("Default pid " << pid << " te " << isPassed);
241  if(xAOD::EgammaHelpers::isElectron(eg)){
242  ATH_MSG_DEBUG("Offline Electron with pidword " << pidword);
243  const xAOD::Electron* el =static_cast<const xAOD::Electron*> (eg);
244  pid=pidwordDec(*el);
245  ATH_MSG_DEBUG("Electron pid " << pid);
246  et = getEt(el)/Gaudi::Units::GeV;
247  if (el->pt() > 0) {
248  ptvarcone20rel = getIsolation_ptvarcone20(el)/el->pt();
249  ptvarcone30rel = getIsolation_ptvarcone30(el)/el->pt();
250  }
251  z0 = getTrack_z0(el);
252  d0 = getTrack_d0(el);
253  }
254  else et=eg->caloCluster()->et()/Gaudi::Units::GeV;
255 
256  float eta = eg->caloCluster()->etaBE(2);
257  float phi = eg->phi();
258  float pt = eg->pt()/Gaudi::Units::GeV;
259  float avgmu=lbAverageInteractionsPerCrossing( Gaudi::Hive::currentContext() );
260  float npvtx=0.0;
261 
262  ATH_MSG_DEBUG("PID decision efficiency " << pidwordDec(*eg));
263 
264  if(pid){
265  et_vec.push_back( et );
266  pt_vec.push_back( pt );
267  highet_vec.push_back( et );
268 
269  if(et > etthr+1.0){
270  eta_vec.push_back(eta);
271  phi_vec.push_back(phi);
272  avgmu_vec.push_back(avgmu);
273  npvtx_vec.push_back(npvtx);
274  ptvarcone20rel_vec.push_back(ptvarcone20rel);
275  ptvarcone30rel_vec.push_back(ptvarcone30rel);
276  z0_vec.push_back(z0);
277  d0_vec.push_back(d0);
278  }
279 
280  if(abs(eta)<=0.8){
281  et_slice0_vec.push_back(et);
282  }else if( abs(eta) > 0.80 && abs(eta) <= 1.37 ){
283  et_slice1_vec.push_back(et);
284  }else if( abs(eta) > 1.37 && abs(eta) <= 1.54 ){
285  et_slice2_vec.push_back(et);
286  }else if( abs(eta) > 1.54 && abs(eta) <= 2.50 ){
287  et_slice3_vec.push_back(et);
288  }
289 
290  if(isPassed) {
291  match_et_vec.push_back( et );
292  match_pt_vec.push_back( pt );
293  match_highet_vec.push_back( et );
294 
295  if(et > etthr+1.0){
296  match_eta_vec.push_back(eta);
297  match_phi_vec.push_back(phi);
298  match_avgmu_vec.push_back(avgmu);
299  match_npvtx_vec.push_back(npvtx);
300  match_ptvarcone20rel_vec.push_back(ptvarcone20rel);
301  match_ptvarcone30rel_vec.push_back(ptvarcone30rel);
302  match_z0_vec.push_back(z0);
303  match_d0_vec.push_back(d0);
304  }
305 
306  et_passed_vec.push_back( true );
307  et_failed_vec.push_back( false );
308  pt_passed_vec.push_back( true );
309  highet_passed_vec.push_back( true );
310  highet_failed_vec.push_back( false );
311 
312  if(abs(eta)<=0.8){
313  et_slice0_passed_vec.push_back(true);
314  }else if( abs(eta) > 0.80 && abs(eta) <= 1.37 ){
315  et_slice1_passed_vec.push_back(true);
316  }else if( abs(eta) > 1.37 && abs(eta) <= 1.54 ){
317  et_slice2_passed_vec.push_back(true);
318  }else if( abs(eta) > 1.54 && abs(eta) <= 2.50 ){
319  et_slice3_passed_vec.push_back(true);
320  }
321 
322  if(et > etthr+1.0){
323  eta_passed_vec.push_back( true );
324  eta_failed_vec.push_back( false );
325  phi_passed_vec.push_back( true );
326  avgmu_passed_vec.push_back( true );
327  npvtx_passed_vec.push_back( true );
328  ptvarcone20rel_passed_vec.push_back( true );
329  ptvarcone30rel_passed_vec.push_back( true );
330  z0_passed_vec.push_back( true );
331  d0_passed_vec.push_back( true );
332  }
333  } // Passes Trigger selection
334  else {
335 
336  et_passed_vec.push_back( false );
337  et_failed_vec.push_back( true );
338  pt_passed_vec.push_back( false );
339  highet_passed_vec.push_back( false );
340  highet_failed_vec.push_back( true );
341 
342  if(abs(eta)<=0.8){
343  et_slice0_passed_vec.push_back(false);
344  }else if( abs(eta) > 0.80 && abs(eta) <= 1.37 ){
345  et_slice1_passed_vec.push_back(false);
346  }else if( abs(eta) > 1.37 && abs(eta) <= 1.54 ){
347  et_slice2_passed_vec.push_back(false);
348  }else if( abs(eta) > 1.54 && abs(eta) <= 2.50 ){
349  et_slice3_passed_vec.push_back(false);
350  }
351 
352  if(et > etthr+1.0){
353  eta_passed_vec.push_back( false );
354  eta_failed_vec.push_back( true );
355  phi_passed_vec.push_back( false );
356  avgmu_passed_vec.push_back( false );
357  npvtx_passed_vec.push_back( false );
358  ptvarcone20rel_passed_vec.push_back( false );
359  ptvarcone30rel_passed_vec.push_back( false );
360  z0_passed_vec.push_back( false );
361  d0_passed_vec.push_back( false );
362  }
363  } // Fails Trigger selection
364 
365  } // Passes offline pid, fill histograms
366  iObj++;
367  }
368 
369  fill( monGroup, et_col, highet_col, pt_col, eta_col, phi_col, avgmu_col, npvtx_col, ptvarcone20rel_col, ptvarcone30rel_col, z0_col, d0_col,
370  match_et_col, match_highet_col, match_pt_col, match_eta_col, match_phi_col, match_avgmu_col, match_npvtx_col, match_ptvarcone20rel_col, match_ptvarcone30rel_col,match_z0_col,match_d0_col,
371  et_passed_col, et_failed_col, highet_passed_col, highet_failed_col, pt_passed_col, eta_passed_col, eta_failed_col, phi_passed_col, avgmu_passed_col, npvtx_passed_col, ptvarcone20rel_passed_col, ptvarcone30rel_passed_col, z0_passed_col, d0_passed_col,
372  et_slice0_col,et_slice1_col,et_slice2_col,et_slice3_col,et_slice0_passed_col,et_slice1_passed_col,et_slice2_passed_col,et_slice3_passed_col);
373 
374 }
375 // *********************************************************************************
376 
377 void TrigEgammaMonitorAnalysisAlgorithm::fillInefficiency( const std::string &pidword,
378  const TrigInfo& info,
379  const std::vector< std::pair< const xAOD::Egamma *,
380  const TrigCompositeUtils::Decision* >>& pairObjs,
381  const std::vector< asg::AcceptData >& acceptObjs ) const
382 {
383  auto monGroup = getGroup(info.trigger+"_Inefficiency");
384  unsigned iObj=0;
385  SG::Decorator<bool> pidwordDec("is"+pidword);
386  for( auto pairObj : pairObjs ){
387 
388  bool pid=true;
389  bool isPassedL1Calo = acceptObjs[iObj].getCutResult( "L1Calo");
390  bool isPassedL2Calo = acceptObjs[iObj].getCutResult( "L2Calo");
391  bool isPassedL2 = acceptObjs[iObj].getCutResult( "L2" );
392  bool isPassedEFCalo = acceptObjs[iObj].getCutResult( "EFCalo");
393  bool isPassedHLT = acceptObjs[iObj].getCutResult( "HLT" );
394 
395  const auto *eg = pairObj.first;
396  if(xAOD::EgammaHelpers::isElectron(eg)){
397  ATH_MSG_DEBUG("Offline Electron with pidword " << pidword);
398  const xAOD::Electron* el =static_cast<const xAOD::Electron*> (eg);
399  pid=pidwordDec(*el);
400  ATH_MSG_DEBUG("Electron pid " << pid);
401  }
402  if(pid){
403  if(!isPassedL1Calo){
404  fillLabel(monGroup, "InefficiencyCounts", "L1Calo" );
405  }if(!isPassedL2Calo){
406  fillLabel(monGroup, "InefficiencyCounts", "L2Calo" );
407  }if(!isPassedL2){
408  fillLabel(monGroup, "InefficiencyCounts", "L2" );
409  }if(!isPassedEFCalo){
410  fillLabel(monGroup, "InefficiencyCounts", "EFCalo" );
411  }if(!isPassedHLT){
412  fillLabel(monGroup, "InefficiencyCounts", "HLT" );
413  }
414  }
415  iObj++;
416  }
417 }
418 
419 
420 void TrigEgammaMonitorAnalysisAlgorithm::fillDistributions( const std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >>& pairObjs,
421  const TrigInfo& info ) const
422 {
423 
424  const std::string trigger = info.trigger;
425 
426  unsigned int condition=TrigDefs::Physics;
427 
428  // Offline
429  std::vector<const xAOD::Egamma*> eg_vec;
430  std::vector<const xAOD::Electron*> el_vec;
431  for( auto pairObj: pairObjs )
432  {
433  eg_vec.push_back(pairObj.first);
434  if( xAOD::EgammaHelpers::isElectron(pairObj.first)){
435  const xAOD::Electron* elOff = static_cast<const xAOD::Electron*> (pairObj.first);
436  el_vec.push_back(elOff);
437  }
438  }
439 
440  // Offline
441  fillShowerShapes( trigger, eg_vec, false );
442  fillTracking( trigger, el_vec, false );
443 
444  // L1Calo
445  {
446  // Fill L1 features
447  auto initRois = tdt()->features<TrigRoiDescriptorCollection>(trigger,condition,"",TrigDefs::allFeaturesOfType,"initialRoI");
448 
449  if (info.L1Legacy){
450  std::vector<const xAOD::EmTauRoI*> l1_vec;
451  for( auto &initRoi: initRois ){
452  if( !initRoi.link.isValid() ) continue;
453  const auto *feat = match()->getL1Feature( initRoi.source );
454  if(feat) l1_vec.push_back(feat);
455  }
456  fillL1Calo( trigger, l1_vec );
457  }else{
458  std::vector<const xAOD::eFexEMRoI*> l1_vec;
459  for( auto &initRoi: initRois ){
460  if( !initRoi.link.isValid() ) continue;
461  const auto *feat = match()->getL1eEMFeature( initRoi.source );
462  if(feat) l1_vec.push_back(feat);
463  }
464  fillL1eEM( trigger, l1_vec );
465  }
466 
467  }
468 
469 
470  // L2Calo
471  {
472  std::vector<const xAOD::TrigEMCluster*> emCluster_vec;
473  auto vec = tdt()->features<xAOD::TrigEMClusterContainer>(trigger,condition ,match()->key("FastCalo") );
474  for(auto &featLinkInfo : vec ){
475  if(! featLinkInfo.isValid() ) continue;
476  const auto *feat = *(featLinkInfo.link);
477  if(!feat) continue;
478  emCluster_vec.push_back(feat);
479  }
480  fillL2Calo( trigger, emCluster_vec );
481  }
482  // EFCalo
483  {
484  std::string key = match()->key("PrecisionCalo_Electron");
485  if(info.signature == "Photon") key = match()->key("PrecisionCalo_Photon");
486  if(info.lrt) key = match()->key("PrecisionCalo_LRT");
487  if(info.ion) key = match()->key("PrecisionCalo_HI");
488 
489  std::vector<const xAOD::CaloCluster* > clus_vec;
490  auto vec = tdt()->features<xAOD::CaloClusterContainer>(trigger,condition,key);
491  for(auto &featLinkInfo : vec ){
492  if(! featLinkInfo.isValid() ) continue;
493  const auto *feat = *(featLinkInfo.link);
494  if(!feat) continue;
495  clus_vec.push_back(feat);
496  }
497  fillEFCalo( trigger, clus_vec );
498  }
499 
500  if ( info.signature == "Electron" ){
501 
502  // L2 Electron
503  {
504  std::string key = match()->key("FastElectrons");
505  if(info.lrt) key = match()->key("FastElectrons_LRT");
506 
507  std::vector<const xAOD::TrigElectron*> el_vec;
508  // Get only passed objects
509  auto vec = tdt()->features<xAOD::TrigElectronContainer>(trigger,condition,key );
510  for( auto &featLinkInfo : vec ){
511  if(! featLinkInfo.isValid() ) continue;
512  const auto *feat = *(featLinkInfo.link);
513  if(!feat) continue;
514  el_vec.push_back(feat);
515  }
516  fillL2Electron( trigger, el_vec );
517  }
518  // HLT Electron
519  {
520  std::string key = match()->key("Electrons_GSF");
521  if(info.nogsf) key = match()->key("Electrons");
522  if(info.lrt) key = match()->key("Electrons_LRT");
523 
524  std::vector<const xAOD::Electron*> el_vec;
525  std::vector<const xAOD::Egamma*> eg_vec;
526  auto vec = tdt()->features<xAOD::ElectronContainer>(trigger, condition ,key );
527  for( auto &featLinkInfo : vec ){
528  if(! featLinkInfo.isValid() ) continue;
529  const auto *feat = *(featLinkInfo.link);
530  if(!feat) continue;
531  el_vec.push_back(feat);
532  eg_vec.push_back(feat);
533  }
534  fillShowerShapes( trigger, eg_vec, true );
535  fillTracking( trigger, el_vec, true );
536  }
537  }else if ( info.signature == "Photon"){
538  // Fast Photon
539  {
540  std::string key = match()->key("FastPhotons");
541  std::vector<const xAOD::TrigPhoton*> ph_vec;
542  // Get only passed objects
543  auto vec = tdt()->features<xAOD::TrigPhotonContainer>(trigger,condition,key );
544  for( auto &featLinkInfo : vec ){
545  if(! featLinkInfo.isValid() ) continue;
546  const auto *feat = *(featLinkInfo.link);
547  if(!feat) continue;
548  ph_vec.push_back(feat);
549  }
550  fillL2Photon( trigger, ph_vec );
551  }
552 
553  // HLT Photon
554  {
555  std::vector<const xAOD::Egamma*> ph_vec;
556  auto vec = tdt()->features<xAOD::PhotonContainer>(trigger,condition ,match()->key("Photons") );
557  for( auto &featLinkInfo : vec ){
558  if(! featLinkInfo.isValid() ) continue;
559  const auto *feat = *(featLinkInfo.link);
560  if(!feat) continue;
561  ph_vec.push_back(feat);
562  }
563  fillShowerShapes( trigger, ph_vec, true );
564  }
565  }else{
566  ATH_MSG_INFO( "Chain type not specified" );
567  }
568 
569 }
570 
571 
572 
573 
574 
575 void TrigEgammaMonitorAnalysisAlgorithm::fillL1Calo( const std::string &trigger, const std::vector< const xAOD::EmTauRoI* >& l1_vec ) const
576 {
577  auto monGroup = getGroup(trigger+"_Distributions_L1Calo");
578 
579  std::vector<float> eta_vec, phi_vec, energy_vec, roi_et_vec, emIso_vec, hadCore_vec;
580 
581  auto eta_col = Monitored::Collection( "eta" , eta_vec );
582  auto phi_col = Monitored::Collection( "phi" , phi_vec );
583  auto energy_col = Monitored::Collection( "energy" , energy_vec );
584  auto roi_et_col = Monitored::Collection( "roi_et" , roi_et_vec );
585  auto emIso_col = Monitored::Collection( "emIso" , emIso_vec );
586  auto hadCore_col = Monitored::Collection( "hadCore" , hadCore_vec );
587 
588  for( const auto *l1 : l1_vec )
589  {
590  if(!l1) continue;
591  eta_vec.push_back( l1->eta() );
592  phi_vec.push_back( l1->phi() );
593  energy_vec.push_back( l1->emClus()/Gaudi::Units::GeV );
594  roi_et_vec.push_back( l1->eT()/Gaudi::Units::GeV );
595  emIso_vec.push_back( l1->emIsol()/Gaudi::Units::GeV );
596  hadCore_vec.push_back( l1->hadCore()/Gaudi::Units::GeV );
597  }
598 
599  fill( monGroup, eta_col, phi_col, energy_col, roi_et_col, emIso_col, hadCore_col );
600 
601 }
602 
603 
604 void TrigEgammaMonitorAnalysisAlgorithm::fillL1eEM( const std::string &trigger, const std::vector< const xAOD::eFexEMRoI* >& l1_vec ) const
605 {
606  auto monGroup = getGroup(trigger+"_Distributions_L1Calo");
607 
608  std::vector<float> eta_vec, phi_vec, et_vec, wstot_vec, reta_vec, rhad_vec;
609 
610  auto et_col = Monitored::Collection( "et" , et_vec );
611  auto eta_col = Monitored::Collection( "eta" , eta_vec );
612  auto phi_col = Monitored::Collection( "phi" , phi_vec );
613  auto wstot_col = Monitored::Collection( "Wstot" , wstot_vec );
614  auto reta_col = Monitored::Collection( "Reta" , reta_vec );
615  auto rhad_col = Monitored::Collection( "Rhad" , rhad_vec );
616 
617 
618  for( const auto *l1 : l1_vec )
619  {
620  if(!l1) continue;
621  et_vec.push_back( l1->et()/Gaudi::Units::GeV );
622  eta_vec.push_back( l1->eta() );
623  phi_vec.push_back( l1->phi() );
624  wstot_vec.push_back( l1->Wstot() );
625  reta_vec.push_back( l1->Reta() );
626  rhad_vec.push_back( l1->Rhad() );
627  }
628 
629  fill( monGroup, eta_col, phi_col, et_col, wstot_col, reta_col, rhad_col );
630 
631 }
632 
633 
634 
635 void TrigEgammaMonitorAnalysisAlgorithm::fillL2Calo(const std::string &trigger, const std::vector< const xAOD::TrigEMCluster *>& emCluster_vec) const
636 {
637  auto monGroup = getGroup(trigger+"_Distributions_L2Calo");
638 
639  std::vector<float> et_vec,highet_vec, eta_vec, phi_vec;
640 
641  auto et_col = Monitored::Collection("et" , et_vec );
642  auto highet_col = Monitored::Collection("highet" , highet_vec );
643  auto eta_col = Monitored::Collection("eta", eta_vec );
644  auto phi_col = Monitored::Collection("phi", phi_vec );
645 
646  for ( const auto *emCluster : emCluster_vec )
647  {
648  if(!emCluster) continue;
649  et_vec.push_back( emCluster->et()/Gaudi::Units::GeV );
650  highet_vec.push_back( emCluster->et()/Gaudi::Units::GeV );
651  eta_vec.push_back( emCluster->eta() );
652  phi_vec.push_back( emCluster->phi() );
653  }
654 
655  fill( monGroup, et_col, eta_col, phi_col, highet_col );
656 
657 
658 }
659 
660 
661 
662 void TrigEgammaMonitorAnalysisAlgorithm::fillL2Electron(const std::string &trigger, const std::vector< const xAOD::TrigElectron* >& el_vec) const
663 {
664 
665  auto monGroup = getGroup(trigger+"_Distributions_L2Electron");
666 
667  std::vector<float> et_vec, eta_vec, phi_vec, highet_vec;
668 
669  auto et_col = Monitored::Collection("et" , et_vec );
670  auto highet_col = Monitored::Collection("highet" , highet_vec );
671  auto eta_col = Monitored::Collection("eta", eta_vec );
672  auto phi_col = Monitored::Collection("phi", phi_vec );
673 
674  for ( const auto *el : el_vec )
675  {
676  if(!el) continue;
677  et_vec.push_back( el->pt()/Gaudi::Units::GeV );
678  highet_vec.push_back( el->pt()/Gaudi::Units::GeV );
679  eta_vec.push_back( el->eta() );
680  phi_vec.push_back( el->phi() );
681  }
682 
683  fill( monGroup, et_col, eta_col, phi_col, highet_col );
684 }
685 
686 void TrigEgammaMonitorAnalysisAlgorithm::fillL2Photon(const std::string &trigger, const std::vector< const xAOD::TrigPhoton* >& ph_vec) const
687 {
688 
689  auto monGroup = getGroup(trigger+"_Distributions_L2Photon");
690 
691  std::vector<float> et_vec, eta_vec, phi_vec, highet_vec;
692 
693  auto et_col = Monitored::Collection("et" , et_vec );
694  auto highet_col = Monitored::Collection("highet" , highet_vec );
695  auto eta_col = Monitored::Collection("eta", eta_vec );
696  auto phi_col = Monitored::Collection("phi", phi_vec );
697 
698  for ( const auto *ph : ph_vec )
699  {
700  if(!ph) continue;
701  et_vec.push_back( ph->pt()/Gaudi::Units::GeV );
702  highet_vec.push_back( ph->pt()/Gaudi::Units::GeV );
703  eta_vec.push_back( ph->eta() );
704  phi_vec.push_back( ph->phi() );
705  }
706 
707  fill( monGroup, et_col, eta_col, phi_col, highet_col );
708 }
709 
710 
711 void TrigEgammaMonitorAnalysisAlgorithm::fillEFCalo(const std::string &trigger, const std::vector< const xAOD::CaloCluster*>& clus_vec) const
712 {
713 
714  auto monGroup = getGroup( trigger + "_Distributions_EFCalo" );
715 
716 
717  std::vector<float> energyBE0_vec, energyBE1_vec, energyBE2_vec, energyBE3_vec,
718  energy_vec, et_vec, eta_vec, phi_vec, eta_calo_vec, phi_calo_vec, highet_vec;
719 
720 
721 
722  auto energyBE0_col = Monitored::Collection("energyBE0", energyBE0_vec);
723  auto energyBE1_col = Monitored::Collection("energyBE1", energyBE1_vec);
724  auto energyBE2_col = Monitored::Collection("energyBE2", energyBE2_vec);
725  auto energyBE3_col = Monitored::Collection("energyBE3", energyBE3_vec);
726  auto energy_col = Monitored::Collection("energy" , energy_vec );
727  auto et_col = Monitored::Collection("et" , et_vec );
728  auto highet_col = Monitored::Collection("highet" , highet_vec );
729  auto eta_col = Monitored::Collection("eta" , eta_vec );
730  auto phi_col = Monitored::Collection("phi" , phi_vec );
731  auto eta_calo_col = Monitored::Collection("eta_calo" , eta_calo_vec );
732  auto phi_calo_col = Monitored::Collection("phi_calo" , phi_calo_vec );
733 
734  for ( const auto *clus : clus_vec )
735  {
736  double tmpeta = -999.;
737  if(!clus->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta))
738  tmpeta=-999.;
739  double tmpphi = -999.;
740  if(!clus->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi))
741  tmpphi=-999.;
742 
743  energyBE0_vec.push_back( clus->energyBE(0)/Gaudi::Units::GeV );
744  energyBE1_vec.push_back( clus->energyBE(1)/Gaudi::Units::GeV );
745  energyBE2_vec.push_back( clus->energyBE(2)/Gaudi::Units::GeV );
746  energyBE3_vec.push_back( clus->energyBE(3)/Gaudi::Units::GeV );
747  energy_vec.push_back( clus->e()/Gaudi::Units::GeV );
748  et_vec.push_back( clus->et()/Gaudi::Units::GeV );
749  highet_vec.push_back( clus->et()/Gaudi::Units::GeV );
750  eta_vec.push_back( clus->eta() );
751  phi_vec.push_back( clus->phi() );
752  eta_calo_vec.push_back( tmpeta );
753  phi_calo_vec.push_back( tmpphi );
754 
755  }
756 
757 
758  fill( monGroup, energyBE0_col, energyBE1_col, energyBE2_col, energyBE3_col,
759  energy_col, et_col, eta_col, phi_col, eta_calo_col, phi_calo_col, highet_col);
760 }
761 
762 
763 
764 
765 
766 void TrigEgammaMonitorAnalysisAlgorithm::fillShowerShapes(const std::string &trigger, const std::vector<const xAOD::Egamma*>& eg_vec , bool online) const
767 {
768 
769  ATH_MSG_DEBUG("Fill SS distributions: " << trigger);
770  auto monGroup = getGroup( trigger + ( online ? "_Distributions_HLT" : "_Distributions_Offline") );
771 
772  std::vector<float> Rhad_vec, Rhad1_vec, Reta_vec, Rphi_vec, weta1_vec, weta2_vec,
773  f1_vec, f3_vec, eratio_vec, et_vec, highet_vec , eta_vec, phi_vec, topoetcone20_vec, topoetcone40_shift_vec,
774  topoetcone20_rel_vec, topoetcone40_shift_rel_vec;
775 
776 
777  auto Rhad_col = Monitored::Collection("Rhad" , Rhad_vec );
778  auto Rhad1_col = Monitored::Collection("Rhad1" , Rhad1_vec );
779  auto Reta_col = Monitored::Collection("Reta" , Reta_vec );
780  auto Rphi_col = Monitored::Collection("Rphi" , Rphi_vec );
781  auto weta1_col = Monitored::Collection("weta1" , weta1_vec );
782  auto weta2_col = Monitored::Collection("weta2" , weta2_vec );
783  auto f1_col = Monitored::Collection("f1" , f1_vec );
784  auto f3_col = Monitored::Collection("f3" , f3_vec );
785  auto eratio_col = Monitored::Collection("eratio" , eratio_vec );
786  auto et_col = Monitored::Collection("et" , et_vec );
787  auto highet_col = Monitored::Collection("highet" , highet_vec );
788  auto eta_col = Monitored::Collection("eta" , eta_vec );
789  auto phi_col = Monitored::Collection("phi" , phi_vec );
790  auto topoetcone20_col = Monitored::Collection("topoetcone20", topoetcone20_vec);
791  auto topoetcone40_shift_col = Monitored::Collection("topoetcone40_shift", topoetcone40_shift_vec );
792  auto topoetcone20_rel_col = Monitored::Collection("topoetcone20_rel", topoetcone20_rel_vec);
793  auto topoetcone40_shift_rel_col = Monitored::Collection("topoetcone40_shift_rel", topoetcone40_shift_rel_vec );
794 
795  for ( const auto *eg : eg_vec ){
796 
797  if(!eg) continue;
798 
799  Rhad_vec.push_back( getShowerShape_Rhad(eg));
800  Rhad1_vec.push_back( getShowerShape_Rhad(eg));
801  Reta_vec.push_back( getShowerShape_Reta(eg));
802  Rphi_vec.push_back( getShowerShape_Rphi(eg));
803  weta1_vec.push_back( getShowerShape_weta1(eg));
804  weta2_vec.push_back( getShowerShape_weta2(eg));
805  f1_vec.push_back( getShowerShape_f1(eg));
806  f3_vec.push_back( getShowerShape_f3(eg));
807  eratio_vec.push_back( getShowerShape_Eratio(eg));
808  et_vec.push_back( eg->pt()/Gaudi::Units::GeV);
809  highet_vec.push_back( eg->pt()/Gaudi::Units::GeV);
810  eta_vec.push_back( eg->eta());
811  phi_vec.push_back( eg->phi());
812  topoetcone20_vec.push_back( getIsolation_topoetcone20(eg)/Gaudi::Units::GeV);
813  topoetcone40_shift_vec.push_back( (getIsolation_topoetcone40(eg)-2450)/Gaudi::Units::GeV );
814 
815  if (eg->pt() > 0) {
816  topoetcone20_rel_vec.push_back( getIsolation_topoetcone20(eg)/eg->pt());
817  topoetcone40_shift_rel_vec.push_back( (getIsolation_topoetcone40(eg)-2450)/eg->pt() );
818  }
819 
820  }// Loop over egamma objects
821 
822  fill( monGroup, Rhad_col, Rhad1_col, Reta_col, Rphi_col, weta1_col, weta2_col,
823  f1_col, f3_col, eratio_col, et_col, highet_col , eta_col, phi_col, topoetcone20_col, topoetcone40_shift_col,
824  topoetcone20_rel_col, topoetcone40_shift_rel_col );
825 
826 }
827 
828 
829 void TrigEgammaMonitorAnalysisAlgorithm::fillTracking(const std::string &trigger, const std::vector< const xAOD::Electron *>& eg_vec, bool online ) const
830 {
831 
832  ATH_MSG_DEBUG("Fill tracking");
833 
834  auto monGroup = getGroup( trigger + ( online ? "_Distributions_HLT" : "_Distributions_Offline") );
835 
836  std::vector<float> deta1_vec, deta1_EMECA_vec, deta1_EMECC_vec, deta1_EMEBA_vec, deta1_EMEBC_vec, deta2_vec, dphi2_vec,
837  dphiresc_vec, eprobht_vec, npixhits_vec, nscthits_vec, charge_vec, ptcone20_vec, ptvarcone20_vec, ptcone30_vec, ptvarcone30_vec, z0_vec, d0_vec, d0sig_vec,
838  pt_vec,pt_trk_vec, ptcone20_rel_vec, ptvarcone20_rel_vec, ptcone30_rel_vec, ptvarcone30_rel_vec, eta_vec, mu_vec;
839 
840  auto deta1_col = Monitored::Collection( "deta1" , deta1_vec );
841  auto deta1_EMECA_col = Monitored::Collection( "deta1_EMECA" , deta1_EMECA_vec );
842  auto deta1_EMECC_col = Monitored::Collection( "deta1_EMECC" , deta1_EMECC_vec );
843  auto deta1_EMEBA_col = Monitored::Collection( "deta1_EMEBA" , deta1_EMEBA_vec );
844  auto deta1_EMEBC_col = Monitored::Collection( "deta1_EMEBC" , deta1_EMEBC_vec );
845  auto deta2_col = Monitored::Collection( "deta2" , deta2_vec );
846  auto dphi2_col = Monitored::Collection( "dphi2" , dphi2_vec );
847  auto dphiresc_col = Monitored::Collection( "dphiresc" , dphiresc_vec );
848  auto eprobht_col = Monitored::Collection( "eprobht" , eprobht_vec );
849  auto npixhits_col = Monitored::Collection( "npixhits" , npixhits_vec );
850  auto nscthits_col = Monitored::Collection( "nscthits" , nscthits_vec );
851  auto charge_col = Monitored::Collection( "charge" , charge_vec );
852  auto ptcone20_col = Monitored::Collection( "ptcone20" , ptcone20_vec );
853  auto ptvarcone20_col = Monitored::Collection( "ptvarcone20" , ptvarcone20_vec );
854  auto ptcone30_col = Monitored::Collection( "ptcone30" , ptcone30_vec );
855  auto ptvarcone30_col = Monitored::Collection( "ptvarcone30" , ptvarcone30_vec );
856  auto z0_col = Monitored::Collection( "z0" , z0_vec );
857  auto d0_col = Monitored::Collection( "d0" , d0_vec );
858  auto d0sig_col = Monitored::Collection( "d0sig" , d0sig_vec );
859  auto pt_col = Monitored::Collection( "pt" , pt_vec );
860  auto pt_trk_col = Monitored::Collection( "pt_track" , pt_trk_vec );
861  auto ptcone20_rel_col = Monitored::Collection( "ptcone20_rel", ptcone20_rel_vec );
862  auto ptvarcone20_rel_col = Monitored::Collection( "ptvarcone20_rel" , ptvarcone20_rel_vec );
863  auto ptcone30_rel_col = Monitored::Collection( "ptcone30_rel", ptcone30_rel_vec );
864  auto ptvarcone30_rel_col = Monitored::Collection( "ptvarcone30_rel" , ptvarcone30_rel_vec );
865 
866  auto eta_col = Monitored::Collection( "eta" , eta_vec );
867  auto mu_col = Monitored::Collection( "mu" , mu_vec );
868 
869 
870  for ( const auto *eg : eg_vec ){
871 
872  if(!eg) continue;
873 
874  float cleta = 0.;
875  if(eg->caloCluster()) cleta=eg->caloCluster()->eta();
876  else cleta=eg->eta();
877 
878  deta1_vec.push_back( getCaloTrackMatch_deltaEta1(eg));
879 
880  if(cleta > 1.375 && cleta < 3.2)
881  deta1_EMECA_vec.push_back( getCaloTrackMatch_deltaEta1(eg));
882  if(cleta < -1.375 && cleta > -3.2)
883  deta1_EMECC_vec.push_back( getCaloTrackMatch_deltaEta1(eg));
884  if(cleta > 0 && cleta < 1.375)
885  deta1_EMEBA_vec.push_back( getCaloTrackMatch_deltaEta1(eg));
886  if(cleta < 0 && cleta > -1.375)
887  deta1_EMEBC_vec.push_back( getCaloTrackMatch_deltaEta1(eg));
888 
889  deta2_vec.push_back( getCaloTrackMatch_deltaEta2(eg));
890  dphi2_vec.push_back( getCaloTrackMatch_deltaPhi2(eg));
891  dphiresc_vec.push_back( getCaloTrackMatch_deltaPhiRescaled2(eg));
892  eprobht_vec.push_back( getTrackSummaryFloat_eProbabilityHT(eg));
893  npixhits_vec.push_back( getTrackSummary_numberOfPixelHits(eg));
894  nscthits_vec.push_back( getTrackSummary_numberOfSCTHits(eg));
895  charge_vec.push_back( eg->charge());
896  ptcone20_vec.push_back( getIsolation_ptcone20(eg)/Gaudi::Units::GeV);
897  ptvarcone20_vec.push_back( getIsolation_ptvarcone20(eg)/Gaudi::Units::GeV);
898  ptcone30_vec.push_back( getIsolation_ptcone30(eg)/Gaudi::Units::GeV);
899  ptvarcone30_vec.push_back( getIsolation_ptvarcone30(eg)/Gaudi::Units::GeV);
900 
901  // Quantities directly from tracks
902  ATH_MSG_DEBUG("Get track Quantities");
903  z0_vec.push_back( getTrack_z0(eg));
904  d0_vec.push_back( getTrack_d0(eg));
905  d0sig_vec.push_back(getD0sig(eg));
906  pt_vec.push_back( eg->pt()/Gaudi::Units::GeV);
907  pt_trk_vec.push_back( getTrack_pt(eg)/Gaudi::Units::GeV);
908  eta_vec.push_back(eg->eta());
909 
910  const float avgmu=lbAverageInteractionsPerCrossing( Gaudi::Hive::currentContext() );
911  mu_vec.push_back( avgmu );
912 
913  if (eg->pt() > 0) {
914  ptcone20_rel_vec.push_back( getIsolation_ptcone20(eg)/eg->pt());
915  ptvarcone20_rel_vec.push_back( getIsolation_ptvarcone20(eg)/eg->pt());
916  ptcone30_rel_vec.push_back( getIsolation_ptcone30(eg)/eg->pt());
917  ptvarcone30_rel_vec.push_back( getIsolation_ptvarcone30(eg)/eg->pt());
918  }
919 
920  }
921 
922 
923  fill( monGroup, deta1_col, deta1_EMECA_col, deta1_EMECC_col, deta1_EMEBA_col, deta1_EMEBC_col, deta2_col, dphi2_col,
924  dphiresc_col, eprobht_col, npixhits_col, nscthits_col, charge_col, ptcone20_col, ptvarcone20_col, ptcone30_col, ptvarcone30_col, z0_col, d0_col, d0sig_col,
925  pt_col, ptcone20_rel_col, ptvarcone20_rel_col, ptcone30_rel_col, ptvarcone30_rel_col, eta_col, mu_col,pt_trk_col);
926 }
927 
928 
929 
931 //
932 //
933 
934 
935 void TrigEgammaMonitorAnalysisAlgorithm::fillResolutions( const std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >>& pairObjs,
936  const TrigInfo& info ) const
937 {
938 
939  std::vector< std::pair< const xAOD::Egamma*, const xAOD::EmTauRoI * >> pair_l1_vec;
940  std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pair_eg_vec;
941  const std::string trigger = info.trigger;
942 
943  SG::Decorator<bool> pidnameDec("is"+info.pidname);
944  for( auto pairObj : pairObjs ){
945 
946  const xAOD::Egamma* eg = pairObj.first;
947  const auto *feat = pairObj.second;
948 
949  if (feat){
950 
951  //
952  // Get only off and l1 where the offline object passed by the offline pid selector
953  //
954  const auto *l1 = match()->getL1Feature( feat );
955  if(eg->type()==xAOD::Type::Electron){
956  const xAOD::Electron* el = static_cast<const xAOD::Electron*>(eg);
957  float et = getEt(el)/Gaudi::Units::GeV;
958  if( et < info.etthr-5.0) continue;
959  if(!pidnameDec(*eg)) continue;
960  pair_eg_vec.emplace_back(el,feat);
961  if(l1) pair_l1_vec.emplace_back(eg,l1 );
962  }
963  else if(eg->type()==xAOD::Type::Photon){
964  float et = getCluster_et(eg)/Gaudi::Units::GeV;
965  if( et < info.etthr-5.0) continue;
966  pair_eg_vec.emplace_back(eg,feat);
967  if(l1) pair_l1_vec.emplace_back(eg,l1 );
968  }
969  }
970 
971  }
972 
973  // Fill L1Calo for all level 1 objects found
974  fillL1CaloResolution( trigger, pair_l1_vec );
975  fillL1CaloAbsResolution( trigger, pair_l1_vec );
976  fillL2CaloResolution( trigger, pair_eg_vec );
977 
978  // Fill HLT electron for all onl objects found
979  if ( info.signature=="Electron"){
980  fillHLTElectronResolution( trigger, pair_eg_vec, info );
981  }
982  else if ( info.signature=="Photon"){
983  fillHLTPhotonResolution( trigger, pair_eg_vec, info );
984  }
985 
986 }
987 
988 
989 
990 
991 void TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloResolution(const std::string &trigger,
992  const std::vector< std::pair< const xAOD::Egamma*, const xAOD::EmTauRoI * >>& pairObjs ) const
993 {
994  auto monGroup = getGroup( trigger + "_Resolutions_L1Calo" );
995 
996  std::vector<float> eta_vec, res_et_vec;
997 
998  auto eta_col = Monitored::Collection( "eta" , eta_vec );
999  auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
1000 
1001 
1002  for (const auto & pairObj : pairObjs){
1003  const auto *off = pairObj.first;
1004  const auto *l1 = pairObj.second;
1005  ATH_MSG_DEBUG("Fill L1CaloResolution");
1006  if(off->type()==xAOD::Type::Electron){
1007  const xAOD::Electron* eloff =static_cast<const xAOD::Electron*> (off);
1008  eta_vec.push_back( l1->eta() );
1009  res_et_vec.push_back( (l1->emClus()-getEt(eloff))/getEt(eloff) ) ;
1010 
1011  }
1012  }
1013 
1014  fill( monGroup, eta_col, res_et_col );
1015 }
1016 
1017 
1018 
1019 
1020 
1021 void TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloAbsResolution(const std::string &trigger,
1022  const std::vector< std::pair< const xAOD::Egamma*, const xAOD::EmTauRoI * >>& pairObjs ) const
1023 {
1024  auto monGroup = getGroup( trigger + "_AbsResolutions_L1Calo" );
1025 
1026  std::vector<float> eta_vec, res_et_vec;
1027 
1028  auto eta_col = Monitored::Collection( "eta" , eta_vec );
1029  auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
1030 
1031 
1032  for (const auto & pairObj : pairObjs){
1033  const auto *off = pairObj.first;
1034  const auto *l1 = pairObj.second;
1035  ATH_MSG_DEBUG("Fill L1CaloAbsResolution");
1036  if(off->type()==xAOD::Type::Electron){
1037  const xAOD::Electron* eloff =static_cast<const xAOD::Electron*> (off);
1038  eta_vec.push_back( l1->eta() );
1039  res_et_vec.push_back( (l1->emClus()-getEt(eloff))/Gaudi::Units::GeV ) ;
1040  }
1041  }
1042 
1043  fill( monGroup, eta_col, res_et_col );
1044 }
1045 
1046 
1047 
1048 
1049 void TrigEgammaMonitorAnalysisAlgorithm::fillHLTElectronResolution(const std::string &trigger,
1050  const std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >>& pairObjs,
1051  const TrigInfo& info) const
1052 {
1053 
1054  auto monGroup = getGroup( trigger + "_Resolutions_HLT" );
1055 
1056  std::vector<float> res_pt_vec, res_et_vec, res_phi_vec, res_eta_vec, res_deta1_vec, res_deta2_vec, res_dphi2_vec, res_dphiresc_vec,
1057  res_z0_vec, res_d0_vec, res_d0sig_vec, res_eprobht_vec, res_npixhits_vec, res_nscthits_vec, res_Rhad_vec, res_Rhad1_vec, res_Reta_vec,
1058  res_Rphi_vec, res_weta1_vec, res_weta2_vec, res_wtots1_vec, res_f1_vec, res_f3_vec, res_eratio_vec, res_ethad_vec, res_ethad1_vec,
1059  et_vec, eta_vec, mu_vec;
1060  std::vector<float> res_ptcone20_vec, res_ptcone20_rel_vec, res_ptvarcone20_vec, res_ptvarcone20_rel_vec;
1061  std::vector<float> res_etInEta0_vec, res_etInEta1_vec, res_etInEta2_vec, res_etInEta3_vec;
1062 
1063 
1064  auto et_col = Monitored::Collection( "et" , et_vec );
1065  auto eta_col = Monitored::Collection( "eta" , eta_vec );
1066  auto mu_col = Monitored::Collection( "mu" , mu_vec );
1067 
1068  // For calo
1069  auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
1070  auto res_eta_col = Monitored::Collection( "res_eta" , res_eta_vec );
1071  auto res_phi_col = Monitored::Collection( "res_phi" , res_phi_vec );
1072  auto res_ethad_col = Monitored::Collection( "res_ethad" , res_ethad_vec );
1073  auto res_ethad1_col = Monitored::Collection( "res_ethad1" , res_ethad1_vec );
1074  auto res_Rhad_col = Monitored::Collection( "res_Rhad" , res_Rhad_vec );
1075  auto res_Rhad1_col = Monitored::Collection( "res_Rhad1" , res_Rhad1_vec );
1076  auto res_Reta_col = Monitored::Collection( "res_Reta" , res_Reta_vec );
1077  auto res_Rphi_col = Monitored::Collection( "res_Rphi" , res_Rphi_vec );
1078  auto res_weta1_col = Monitored::Collection( "res_weta1" , res_weta1_vec );
1079  auto res_weta2_col = Monitored::Collection( "res_weta2" , res_weta2_vec );
1080  auto res_wtots1_col = Monitored::Collection( "res_wtots1" , res_wtots1_vec );
1081  auto res_f1_col = Monitored::Collection( "res_f1" , res_f1_vec );
1082  auto res_f3_col = Monitored::Collection( "res_f3" , res_f3_vec );
1083  auto res_eratio_col = Monitored::Collection( "res_eratio" , res_eratio_vec );
1084 
1085  auto res_etInEta0_col = Monitored::Collection( "res_etInEta0" , res_etInEta0_vec );
1086  auto res_etInEta1_col = Monitored::Collection( "res_etInEta1" , res_etInEta1_vec );
1087  auto res_etInEta2_col = Monitored::Collection( "res_etInEta2" , res_etInEta2_vec );
1088  auto res_etInEta3_col = Monitored::Collection( "res_etInEta3" , res_etInEta3_vec );
1089 
1090  // For electron
1091  auto res_pt_col = Monitored::Collection( "res_pt" , res_pt_vec );
1092  auto res_deta1_col = Monitored::Collection( "res_deta1" , res_deta1_vec );
1093  auto res_deta2_col = Monitored::Collection( "res_deta2" , res_deta2_vec );
1094  auto res_dphi2_col = Monitored::Collection( "res_dphi2" , res_dphi2_vec );
1095  auto res_dphiresc_col = Monitored::Collection( "res_dphiresc" , res_dphiresc_vec );
1096  auto res_z0_col = Monitored::Collection( "res_z0" , res_z0_vec );
1097  auto res_d0_col = Monitored::Collection( "res_d0" , res_d0_vec );
1098  auto res_d0sig_col = Monitored::Collection( "res_d0sig" , res_d0sig_vec );
1099  auto res_eprobht_col = Monitored::Collection( "res_eprobht" , res_eprobht_vec );
1100  auto res_npixhits_col = Monitored::Collection( "res_npixhits" , res_npixhits_vec );
1101  auto res_nscthits_col = Monitored::Collection( "res_nscthits" , res_nscthits_vec );
1102  auto res_ptcone20_col = Monitored::Collection( "res_ptcone20" , res_ptcone20_vec );
1103  auto res_ptcone20_rel_col = Monitored::Collection( "res_ptcone20_rel" , res_ptcone20_rel_vec );
1104  auto res_ptvarcone20_col = Monitored::Collection( "res_ptvarcone20" , res_ptvarcone20_vec );
1105  auto res_ptvarcone20_rel_col = Monitored::Collection( "res_ptvarcone20_rel" , res_ptvarcone20_rel_vec );
1106 
1107 
1108 
1109 
1110  // Check for zero before filling
1111  ATH_MSG_DEBUG("Fill Resolution");
1112 
1113  std::string key = match()->key("Electrons_GSF");
1114  if(info.nogsf) key = match()->key("Electrons");
1115  if(info.lrt) key = match()->key("Electrons_LRT");
1116 
1117  for ( const auto & pairObj : pairObjs ){
1118 
1119  const xAOD::Electron *off = static_cast<const xAOD::Electron*>(pairObj.first);
1120  const xAOD::Electron *onl=nullptr;
1121 
1122 
1123  { // Get the closest electron object from the trigger starting with deltaR = 0.15
1124  float maxDeltaR=0.05;
1125  auto vec = tdt()->features<xAOD::ElectronContainer>(trigger,TrigDefs::Physics ,key );
1126  for(auto &featLinkInfo : vec ){
1127  if(! featLinkInfo.isValid() ) continue;
1128  const auto *feat = *(featLinkInfo.link);
1129  if(!feat) continue;
1130  float deltaR = dR( off->eta(), off->phi(), feat->eta(), feat->phi() );
1131  if( deltaR < maxDeltaR){
1132  maxDeltaR=deltaR;
1133  onl=feat;
1134  }
1135  }
1136  }
1137 
1138  if(!onl) continue;
1139 
1140  float val_off=0.;
1141  const float onl_eta=onl->eta();
1142  const float feta = abs(onl_eta);
1143  const float onl_et = getEt(onl)/Gaudi::Units::GeV;
1144  const float avgmu=lbAverageInteractionsPerCrossing( Gaudi::Hive::currentContext() );
1145  const float dummy=-999;
1146 
1147  eta_vec.push_back( onl_eta );
1148  et_vec.push_back( onl_et );
1149  mu_vec.push_back( avgmu );
1150 
1151  val_off=getTrack_pt(off);
1152  if(val_off!=0.){
1153  res_pt_vec.push_back( (getTrack_pt(off)-val_off)/val_off );
1154  }else{
1155  }
1156 
1157 
1158  val_off=getEt(off);
1159  if(val_off!=0.){
1160  res_et_vec.push_back( (getEt(onl)-val_off)/val_off );
1161  if( feta < 1.37 )
1162  res_etInEta0_vec.push_back((getEt(onl)-val_off)/val_off);
1163  else if( feta >=1.37 && feta <= 1.52 )
1164  res_etInEta1_vec.push_back((getEt(onl)-val_off)/val_off);
1165  else if( feta >= 1.55 && feta < 1.8 )
1166  res_etInEta2_vec.push_back((getEt(onl)-val_off)/val_off);
1167  else if( feta >= 1.8 && feta < 2.45 )
1168  res_etInEta3_vec.push_back((getEt(onl)-val_off)/val_off);
1169  }
1170 
1171  val_off=off->eta();
1172  if(val_off!=0.){
1173  res_eta_vec.push_back( (onl_eta-val_off)/val_off );
1174  }else{
1175  res_eta_vec.push_back( dummy );
1176  }
1177 
1178  val_off=off->phi();
1179  if(val_off!=0.){
1180  res_phi_vec.push_back( (onl->phi()-val_off)/val_off );
1181  }else{
1182  res_phi_vec.push_back(dummy );
1183  }
1184 
1185  val_off=getShowerShape_ethad(off);
1186  if(val_off!=0.) {
1187  res_ethad_vec.push_back((getShowerShape_ethad(onl)-val_off)/val_off);
1188  }else{
1189  res_ethad_vec.push_back( dummy );
1190  }
1191 
1192  val_off=getShowerShape_ethad1(off);
1193  if(val_off!=0){
1194  res_ethad1_vec.push_back((getShowerShape_ethad1(onl)-val_off)/val_off);
1195  }else{
1196  res_ethad1_vec.push_back( dummy);
1197  }
1198 
1199  val_off=getShowerShape_Rhad(off);
1200  if(val_off!=0.){
1201  res_Rhad_vec.push_back( (getShowerShape_Rhad(onl)-val_off)/val_off );
1202  }else{
1203  res_Rhad_vec.push_back( dummy );
1204  }
1205 
1206  val_off=getShowerShape_Rhad1(off);
1207  if(val_off!=0.){
1208  res_Rhad1_vec.push_back( (getShowerShape_Rhad1(onl)-val_off)/val_off );
1209  }else{
1210  res_Rhad1_vec.push_back( dummy );
1211  }
1212 
1213  val_off=getShowerShape_Reta(off);
1214  if(val_off!=0.){
1215  res_Reta_vec.push_back( (getShowerShape_Reta(onl)-val_off)/val_off );
1216  }else{
1217  res_Reta_vec.push_back( dummy );
1218  }
1219 
1220  val_off=getShowerShape_Rphi(off);
1221  if(val_off!=0.){
1222  res_Rphi_vec.push_back( (getShowerShape_Rphi(onl)-val_off)/val_off );
1223  }else{
1224  res_Rphi_vec.push_back( (getShowerShape_Rphi(onl)-val_off)/val_off );
1225  }
1226 
1227  val_off=getShowerShape_weta1(off);
1228  if(val_off!=0.){
1229  res_weta1_vec.push_back( (getShowerShape_weta1(onl)-val_off)/val_off );
1230  }else{
1231  res_weta1_vec.push_back( dummy );
1232  }
1233 
1234  val_off=getShowerShape_weta2(off);
1235  if(val_off!=0.){
1236  res_weta2_vec.push_back( (getShowerShape_weta2(onl)-val_off)/val_off );
1237  }else{
1238  res_weta2_vec.push_back( dummy );
1239  }
1240 
1241  val_off=getShowerShape_wtots1(off);
1242  if(val_off!=0.){
1243  res_wtots1_vec.push_back( (getShowerShape_wtots1(onl)-val_off)/val_off );
1244  }else{
1245  res_wtots1_vec.push_back( dummy );
1246  }
1247 
1248  val_off=getShowerShape_f1(off);
1249  if(val_off!=0.){
1250  res_f1_vec.push_back( (getShowerShape_f1(onl)-val_off)/val_off );
1251  }else{
1252  res_f1_vec.push_back(dummy );
1253  }
1254 
1255  val_off=getShowerShape_f3(off);
1256  if(val_off!=0.){
1257  res_f3_vec.push_back( (getShowerShape_f3(onl)-val_off)/val_off );
1258  }else{
1259  res_f3_vec.push_back( dummy );
1260  }
1261 
1262  val_off=getShowerShape_Eratio(off);
1263  if(val_off!=0.){
1264  res_eratio_vec.push_back( (getShowerShape_Eratio(onl)-val_off)/val_off );
1265  }else{
1266  res_eratio_vec.push_back( dummy );
1267  }
1268 
1269 
1270  //
1271  // Track variables
1272  //
1273 
1274  val_off=getTrack_pt(off);
1275  if(val_off!=0.){
1276  res_pt_vec.push_back( (getTrack_pt(onl)-val_off)/val_off );
1277  }else{
1278  res_pt_vec.push_back( dummy );
1279  }
1280 
1281  val_off=getEt(off);
1282  if(val_off!=0.) {
1283  res_et_vec.push_back( (getEt(onl)-val_off)/val_off );
1284  }else{
1285  res_et_vec.push_back( dummy );
1286  }
1287 
1288  val_off=getCaloTrackMatch_deltaEta1(off);
1289  if(val_off!=0.) {
1290  res_deta1_vec.push_back( (getCaloTrackMatch_deltaEta1(onl)-val_off)/val_off );
1291  }else{
1292  res_deta1_vec.push_back( dummy );
1293  }
1294 
1295  val_off=getCaloTrackMatch_deltaEta2(off);
1296  res_deta2_vec.push_back( (getCaloTrackMatch_deltaEta2(onl)-val_off)/val_off );
1297  val_off=getCaloTrackMatch_deltaPhi2(off);
1298  if(val_off!=0.) {
1299  res_dphi2_vec.push_back( (getCaloTrackMatch_deltaPhi2(onl)-val_off)/val_off );
1300  }else{
1301  res_dphi2_vec.push_back(dummy );
1302  }
1303 
1304  val_off=getCaloTrackMatch_deltaPhiRescaled2(off);
1305  res_dphiresc_vec.push_back( (getCaloTrackMatch_deltaPhiRescaled2(onl)-val_off)/val_off );
1306  // Resolution of Z0 of the track
1307  val_off=getTrack_z0(off);
1308  if(val_off!=0.) {
1309  res_z0_vec.push_back( getTrack_z0(onl)-val_off );
1310  }else{
1311  res_z0_vec.push_back( dummy );
1312  }
1313 
1314  // Absolute resolution for impact parameter
1315  val_off=getTrack_d0(off);
1316  if(val_off!=0.) {
1317  res_d0_vec.push_back( getTrack_d0(onl)-val_off );
1318  }else{
1319  res_d0_vec.push_back( dummy );
1320  }
1321 
1322  val_off=getD0sig(off);
1323  if(val_off!=0.) {
1324  res_d0sig_vec.push_back( getD0sig(onl)-val_off );
1325  }else{
1326  res_d0sig_vec.push_back( dummy );
1327  }
1328 
1329  // Absolute resolution on track summary ints/floats
1330  val_off=getTrackSummaryFloat_eProbabilityHT(off);
1331  res_eprobht_vec.push_back( (getTrackSummaryFloat_eProbabilityHT(onl)-val_off) );
1332  res_npixhits_vec.push_back( getTrackSummary_numberOfPixelHits(onl)-getTrackSummary_numberOfPixelHits(onl) );
1333  res_nscthits_vec.push_back( getTrackSummary_numberOfSCTHits(onl)-getTrackSummary_numberOfSCTHits(onl) );
1334 
1335 
1336 
1337 
1338  if(info.isolated){
1339 
1340  float val_off=getIsolation_ptcone20(off);
1341  if (val_off > 0.) {
1342  res_ptcone20_vec.push_back((getIsolation_ptcone20(onl)-val_off)/val_off);
1343  if (getEt(onl) > 0. && getEt(off) > 0.) {
1344  const float reliso_onl=getIsolation_ptcone20(onl)/getEt(onl);
1345  const float reliso_off=getIsolation_ptcone20(off)/getEt(off);
1346  res_ptcone20_rel_vec.push_back((reliso_onl-reliso_off)/reliso_off);
1347  }else{
1348  res_ptcone20_rel_vec.push_back(dummy);
1349  }
1350  }else{
1351  res_ptcone20_vec.push_back(dummy);
1352  res_ptcone20_rel_vec.push_back(dummy);
1353  }
1354 
1355  // ptvarcone20 isolation
1356  val_off=getIsolation_ptvarcone20(off);
1357  if (val_off > 0.) {
1358  if (getEt(onl) > 0. && getEt(off) > 0.) {
1359  res_ptvarcone20_vec.push_back((getIsolation_ptvarcone20(onl)-val_off)/val_off);
1360  const float reliso_onl=getIsolation_ptvarcone20(onl)/getEt(onl);
1361  const float reliso_off=getIsolation_ptvarcone20(off)/getEt(off);
1362  res_ptvarcone20_rel_vec.push_back((reliso_onl-reliso_off)/reliso_off);
1363  }else{
1364  res_ptvarcone20_rel_vec.push_back(dummy);
1365  }
1366  }else{
1367  res_ptvarcone20_vec.push_back(dummy);
1368  res_ptvarcone20_rel_vec.push_back(dummy);
1369  }
1370 
1371  }
1372 
1373 
1374 
1375 
1376 
1377  } // Loop over all offline objects
1378 
1379  // Fill everything
1380  fill( monGroup ,
1381  et_col ,
1382  eta_col ,
1383  mu_col ,
1384  res_pt_col ,
1385  res_et_col ,
1386  res_eta_col ,
1387  res_phi_col ,
1388  res_deta1_col ,
1389  res_deta2_col ,
1390  res_dphi2_col ,
1391  res_dphiresc_col,
1392  res_z0_col ,
1393  res_d0_col ,
1394  res_d0sig_col ,
1395  res_eprobht_col ,
1396  res_npixhits_col,
1397  res_nscthits_col,
1398  res_ethad_col ,
1399  res_ethad1_col ,
1400  res_Rhad_col ,
1401  res_Rhad1_col ,
1402  res_Reta_col ,
1403  res_Rphi_col ,
1404  res_weta1_col ,
1405  res_weta2_col ,
1406  res_wtots1_col ,
1407  res_f1_col ,
1408  res_f3_col ,
1409  res_eratio_col ,
1410  res_ptcone20_col ,
1411  res_ptcone20_rel_col ,
1412  res_ptvarcone20_col ,
1413  res_ptvarcone20_rel_col ,
1414  res_etInEta0_col,
1415  res_etInEta1_col,
1416  res_etInEta2_col,
1417  res_etInEta3_col );
1418 
1419 
1420 
1421 }
1422 
1423 
1424 
1425 
1426 
1427 void TrigEgammaMonitorAnalysisAlgorithm::fillHLTPhotonResolution(const std::string &trigger,
1428  const std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >>& pairObjs,
1429  const TrigInfo& info) const
1430 {
1431 
1432  auto monGroup = getGroup( trigger + "_Resolutions_HLT" );
1433 
1434  std::vector<float> res_phi_vec, res_eta_vec, res_Rhad_vec, res_Rhad1_vec, res_Reta_vec, res_ethad_vec, res_ethad1_vec,
1435  res_Rphi_vec, res_weta1_vec, res_weta2_vec, res_wtots1_vec, res_f1_vec, res_f3_vec, res_eratio_vec, et_vec, eta_vec, mu_vec;
1436 
1437  std::vector<float> res_et_vec, res_et_cnv_vec, res_et_uncnv_vec;
1438  std::vector<float> res_etInEta0_vec, res_etInEta1_vec, res_etInEta2_vec, res_etInEta3_vec;
1439  std::vector<float> res_cnv_etInEta0_vec, res_cnv_etInEta1_vec, res_cnv_etInEta2_vec, res_cnv_etInEta3_vec;
1440  std::vector<float> res_uncnv_etInEta0_vec, res_uncnv_etInEta1_vec, res_uncnv_etInEta2_vec, res_uncnv_etInEta3_vec;
1441 
1442 
1443 
1444  std::vector<float> res_topoetcone20_vec, res_topoetcone20_rel_vec;
1445 
1446  auto et_col = Monitored::Collection( "et" , et_vec );
1447  auto eta_col = Monitored::Collection( "eta" , eta_vec );
1448  auto mu_col = Monitored::Collection( "mu" , mu_vec );
1449 
1450  // For calo
1451  auto res_eta_col = Monitored::Collection( "res_eta" , res_eta_vec );
1452  auto res_phi_col = Monitored::Collection( "res_phi" , res_phi_vec );
1453  auto res_ethad_col = Monitored::Collection( "res_ethad" , res_ethad_vec );
1454  auto res_ethad1_col = Monitored::Collection( "res_ethad1" , res_ethad1_vec );
1455  auto res_Rhad_col = Monitored::Collection( "res_Rhad" , res_Rhad_vec );
1456  auto res_Rhad1_col = Monitored::Collection( "res_Rhad1" , res_Rhad1_vec );
1457  auto res_Reta_col = Monitored::Collection( "res_Reta" , res_Reta_vec );
1458  auto res_Rphi_col = Monitored::Collection( "res_Rphi" , res_Rphi_vec );
1459  auto res_weta1_col = Monitored::Collection( "res_weta1" , res_weta1_vec );
1460  auto res_weta2_col = Monitored::Collection( "res_weta2" , res_weta2_vec );
1461  auto res_wtots1_col = Monitored::Collection( "res_wtots1" , res_wtots1_vec );
1462  auto res_f1_col = Monitored::Collection( "res_f1" , res_f1_vec );
1463  auto res_f3_col = Monitored::Collection( "res_f3" , res_f3_vec );
1464  auto res_eratio_col = Monitored::Collection( "res_eratio" , res_eratio_vec );
1465 
1466 
1467  auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
1468  auto res_et_cnv_col = Monitored::Collection( "res_et_cnv" , res_et_cnv_vec );
1469  auto res_et_uncnv_col = Monitored::Collection( "res_et_uncnv" , res_et_uncnv_vec );
1470  auto res_etInEta0_col = Monitored::Collection( "res_etInEta0" , res_etInEta0_vec );
1471  auto res_etInEta1_col = Monitored::Collection( "res_etInEta1" , res_etInEta1_vec );
1472  auto res_etInEta2_col = Monitored::Collection( "res_etInEta2" , res_etInEta2_vec );
1473  auto res_etInEta3_col = Monitored::Collection( "res_etInEta3" , res_etInEta3_vec );
1474  auto res_cnv_etInEta0_col = Monitored::Collection( "res_cnv_etInEta0" , res_cnv_etInEta0_vec );
1475  auto res_cnv_etInEta1_col = Monitored::Collection( "res_cnv_etInEta1" , res_cnv_etInEta1_vec );
1476  auto res_cnv_etInEta2_col = Monitored::Collection( "res_cnv_etInEta2" , res_cnv_etInEta2_vec );
1477  auto res_cnv_etInEta3_col = Monitored::Collection( "res_cnv_etInEta3" , res_cnv_etInEta3_vec );
1478  auto res_uncnv_etInEta0_col = Monitored::Collection( "res_uncnv_etInEta0" , res_uncnv_etInEta0_vec);
1479  auto res_uncnv_etInEta1_col = Monitored::Collection( "res_uncnv_etInEta1" , res_uncnv_etInEta1_vec);
1480  auto res_uncnv_etInEta2_col = Monitored::Collection( "res_uncnv_etInEta2" , res_uncnv_etInEta2_vec);
1481  auto res_uncnv_etInEta3_col = Monitored::Collection( "res_uncnv_etInEta3" , res_uncnv_etInEta3_vec);
1482 
1483  // For photon
1484  auto res_topoetcone20_col = Monitored::Collection( "res_topoetcone20" , res_topoetcone20_vec );
1485  auto res_topoetcone20_rel_col = Monitored::Collection( "res_topoetcone20_rel" , res_topoetcone20_rel_vec );
1486 
1487 
1488 
1489 
1490  // Check for zero before filling
1491  ATH_MSG_DEBUG("Fill Resolution");
1492 
1493 
1494 
1495  for ( const auto & pairObj : pairObjs ){
1496 
1497  const xAOD::Photon *off = static_cast<const xAOD::Photon*>(pairObj.first);
1498  const xAOD::Photon *onl=nullptr;
1499 
1500 
1501  { // Get the closest electron object from the trigger starting with deltaR = 0.15
1502  float maxDeltaR=0.05;
1503  auto vec = tdt()->features<xAOD::PhotonContainer>(trigger,TrigDefs::Physics ,match()->key("Photons") );
1504  for(auto &featLinkInfo : vec ){
1505  if(! featLinkInfo.isValid() ) continue;
1506  const auto *feat = *(featLinkInfo.link);
1507  if(!feat) continue;
1508  float deltaR = dR( off->eta(), off->phi(), feat->eta(), feat->phi() );
1509  if( deltaR < maxDeltaR){
1510  maxDeltaR=deltaR;
1511  onl=feat;
1512  }
1513  }
1514  }
1515 
1516  // If not found, skip this off object!
1517  if(!onl) continue;
1518 
1519  float val_off=0.;
1520  const float onl_eta=onl->eta();
1521  const float feta = abs(onl_eta);
1522  const float onl_et = getCluster_et(onl)/Gaudi::Units::GeV;
1523  const float dummy=-999;
1524 
1525  const float avgmu=lbAverageInteractionsPerCrossing( Gaudi::Hive::currentContext() );
1526  et_vec.push_back( onl_et );
1527  eta_vec.push_back( onl_eta );
1528  mu_vec.push_back( avgmu );
1529 
1530 
1531  val_off=getCluster_et(off);
1532  if(val_off!=0.){
1533  res_et_vec.push_back( (getCluster_et(onl)-val_off)/val_off );
1534  if( feta < 1.37 )
1535  res_etInEta0_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1536  else if( feta >=1.37 && feta <= 1.52 )
1537  res_etInEta1_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1538  else if( feta >= 1.55 && feta < 1.8 )
1539  res_etInEta2_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1540  else if( feta >= 1.8 && feta < 2.45 )
1541  res_etInEta3_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1542 
1543  if(xAOD::EgammaHelpers::isConvertedPhoton(off)){
1544  res_et_cnv_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1545  if( feta < 1.37 )
1546  res_cnv_etInEta0_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1547  else if( feta >=1.37 && feta <= 1.52 )
1548  res_cnv_etInEta1_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1549  else if( feta >= 1.55 && feta < 1.8 )
1550  res_cnv_etInEta2_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1551  else if( feta >= 1.8 && feta < 2.45 )
1552  res_cnv_etInEta3_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1553  }else{
1554  res_et_uncnv_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1555  if( feta < 1.37 )
1556  res_uncnv_etInEta0_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1557  else if( feta >=1.37 && feta <= 1.52 )
1558  res_uncnv_etInEta1_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1559  else if( feta >= 1.55 && feta < 1.8 )
1560  res_uncnv_etInEta2_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1561  else if( feta >= 1.8 && feta < 2.45 )
1562  res_uncnv_etInEta3_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1563  }
1564  }
1565 
1566  val_off=off->eta();
1567  if(val_off!=0.){
1568  res_eta_vec.push_back( (onl_eta-val_off)/val_off ) ;
1569  }else{
1570  res_eta_vec.push_back( dummy ) ;
1571  }
1572 
1573  val_off=off->phi();
1574  if(val_off!=0.){
1575  res_phi_vec.push_back( (onl->phi()-val_off)/val_off );
1576  }else{
1577  res_phi_vec.push_back(dummy );
1578  }
1579 
1580  val_off=getShowerShape_ethad(off);
1581  if(val_off!=0.) {
1582  res_ethad_vec.push_back((getShowerShape_ethad(onl)-val_off)/val_off);
1583  }else{
1584  res_ethad_vec.push_back(dummy);
1585  }
1586 
1587  val_off=getShowerShape_ethad1(off);
1588  if(val_off!=0){
1589  res_ethad1_vec.push_back((getShowerShape_ethad1(onl)-val_off)/val_off);
1590  }else{
1591  res_ethad1_vec.push_back(dummy);
1592  }
1593 
1594  val_off=getShowerShape_Rhad(off);
1595  if(val_off!=0.){
1596  res_Rhad_vec.push_back( (getShowerShape_Rhad(onl)-val_off)/val_off );
1597  }else{
1598  res_Rhad_vec.push_back(dummy );
1599  }
1600 
1601  val_off=getShowerShape_Rhad1(off);
1602  if(val_off!=0.){
1603  res_Rhad1_vec.push_back( (getShowerShape_Rhad1(onl)-val_off)/val_off );
1604  }else{
1605  res_Rhad1_vec.push_back(dummy );
1606  }
1607 
1608  val_off=getShowerShape_Reta(off);
1609  if(val_off!=0.){
1610  res_Reta_vec.push_back( (getShowerShape_Reta(onl)-val_off)/val_off );
1611  }else{
1612  res_Reta_vec.push_back( dummy );
1613  }
1614 
1615  val_off=getShowerShape_Rphi(off);
1616  if(val_off!=0.){
1617  res_Rphi_vec.push_back( (getShowerShape_Rphi(onl)-val_off)/val_off );
1618  }else{
1619  res_Rphi_vec.push_back(dummy );
1620  }
1621 
1622  val_off=getShowerShape_weta1(off);
1623  if(val_off!=0.){
1624  res_weta1_vec.push_back( (getShowerShape_weta1(onl)-val_off)/val_off );
1625  }else{
1626  res_weta1_vec.push_back( dummy );
1627  }
1628 
1629  val_off=getShowerShape_weta2(off);
1630  if(val_off!=0.){
1631  res_weta2_vec.push_back( (getShowerShape_weta2(onl)-val_off)/val_off );
1632  }else{
1633  res_weta2_vec.push_back(dummy);
1634  }
1635 
1636  val_off=getShowerShape_wtots1(off);
1637  if(val_off!=0.){
1638  res_wtots1_vec.push_back( (getShowerShape_wtots1(onl)-val_off)/val_off );
1639  }else{
1640  res_wtots1_vec.push_back( dummy );
1641  }
1642 
1643  val_off=getShowerShape_f1(off);
1644  if(val_off!=0.){
1645  res_f1_vec.push_back( (getShowerShape_f1(onl)-val_off)/val_off );
1646  }else{
1647  res_f1_vec.push_back( dummy );
1648  }
1649 
1650  val_off=getShowerShape_f3(off);
1651  if(val_off!=0.){
1652  res_f3_vec.push_back( (getShowerShape_f3(onl)-val_off)/val_off );
1653  }else{
1654  res_f3_vec.push_back( dummy );
1655  }
1656 
1657  val_off=getShowerShape_Eratio(off);
1658  if(val_off!=0.){
1659  res_eratio_vec.push_back( (getShowerShape_Eratio(onl)-val_off)/val_off);
1660  }else{
1661  res_eratio_vec.push_back( dummy);
1662  }
1663 
1664 
1665  if( info.isolated ){
1666  // topoetcone20 isolation
1667  float val_off=getIsolation_topoetcone20(off);
1668  float etonl=onl->pt();
1669  float etoff=off->pt();
1670  if (val_off > 0.) {
1671  res_topoetcone20_vec.push_back((getIsolation_topoetcone20(onl)-val_off)/val_off);
1672  if (etonl > 0. && etoff > 0.) {
1673  const float reliso_onl=getIsolation_topoetcone20(onl)/etonl;
1674  const float reliso_off=getIsolation_topoetcone20(off)/etoff;
1675  res_topoetcone20_rel_vec.push_back((reliso_onl-reliso_off)/reliso_off);
1676  }else{
1677  res_topoetcone20_rel_vec.push_back(dummy);
1678  }
1679  }else{
1680  res_topoetcone20_vec.push_back(dummy);
1681  res_topoetcone20_rel_vec.push_back(dummy);
1682  }
1683  }
1684 
1685 
1686 
1687  } // Loop over all offline objects
1688 
1689  // Fill everything
1690  fill( monGroup ,
1691  et_col ,
1692  eta_col ,
1693  mu_col ,
1694  res_et_col ,
1695  res_eta_col ,
1696  res_phi_col ,
1697  res_ethad_col ,
1698  res_ethad1_col ,
1699  res_Rhad_col ,
1700  res_Rhad1_col ,
1701  res_Reta_col ,
1702  res_Rphi_col ,
1703  res_weta1_col ,
1704  res_weta2_col ,
1705  res_wtots1_col ,
1706  res_f1_col ,
1707  res_f3_col ,
1708  res_eratio_col ,
1709  res_topoetcone20_col ,
1710  res_topoetcone20_rel_col ,
1711  res_etInEta0_col,
1712  res_etInEta1_col,
1713  res_etInEta2_col,
1714  res_etInEta3_col,
1715  res_et_uncnv_col,
1716  res_cnv_etInEta0_col,
1717  res_cnv_etInEta1_col,
1718  res_cnv_etInEta2_col,
1719  res_cnv_etInEta3_col,
1720  res_et_cnv_col,
1721  res_uncnv_etInEta0_col,
1722  res_uncnv_etInEta1_col,
1723  res_uncnv_etInEta2_col,
1724  res_uncnv_etInEta3_col
1725  );
1726 
1727 
1728 
1729 }
1730 
1731 
1732 void TrigEgammaMonitorAnalysisAlgorithm::fillL2CaloResolution(const std::string &trigger,
1733  const std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >>& pairObjs ) const
1734 
1735 {
1736  ATH_MSG_DEBUG("Fill L2Calo Resolution");
1737 
1738  auto monGroup = getGroup( trigger + "_Resolutions_L2Calo" );
1739 
1740  std::vector<float> res_et_vec, res_phi_vec, res_eta_vec, res_Rhad_vec, res_Rhad1_vec, res_Reta_vec, res_ethad_vec, res_ethad1_vec,
1741  res_Rphi_vec, res_weta2_vec, res_f1_vec, res_f3_vec, res_eratio_vec, et_vec, eta_vec;
1742 
1743 
1744  auto et_col = Monitored::Collection( "et" , et_vec );
1745  auto eta_col = Monitored::Collection( "eta" , eta_vec );
1746  auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
1747  auto res_eta_col = Monitored::Collection( "res_eta" , res_eta_vec );
1748  auto res_phi_col = Monitored::Collection( "res_phi" , res_phi_vec );
1749  auto res_ethad_col = Monitored::Collection( "res_ethad" , res_ethad_vec );
1750  auto res_ethad1_col = Monitored::Collection( "res_ethad1" , res_ethad1_vec );
1751  auto res_Rhad_col = Monitored::Collection( "res_Rhad" , res_Rhad_vec );
1752  auto res_Rhad1_col = Monitored::Collection( "res_Rhad1" , res_Rhad1_vec );
1753  auto res_Reta_col = Monitored::Collection( "res_Reta" , res_Reta_vec );
1754  auto res_Rphi_col = Monitored::Collection( "res_Rphi" , res_Rphi_vec );
1755  auto res_weta2_col = Monitored::Collection( "res_weta2" , res_weta2_vec );
1756  auto res_f1_col = Monitored::Collection( "res_f1" , res_f1_vec );
1757  auto res_f3_col = Monitored::Collection( "res_f3" , res_f3_vec );
1758  auto res_eratio_col = Monitored::Collection( "res_eratio" , res_eratio_vec );
1759 
1760 
1761  for ( const auto & pairObj : pairObjs ){
1762 
1763 
1764  const xAOD::Egamma *off = pairObj.first;
1765  const xAOD::TrigEMCluster *onl=nullptr;
1766 
1767  { // Get the closest electron object from the trigger starting with deltaR = 0.15
1768  float maxDeltaR=0.05;
1769  auto vec = tdt()->features<xAOD::TrigEMClusterContainer>(trigger,TrigDefs::Physics ,match()->key("FastCalo") );
1770  for(auto &featLinkInfo : vec ){
1771  if(! featLinkInfo.isValid() ) continue;
1772  const auto *feat = *(featLinkInfo.link);
1773  if(!feat) continue;
1774  float deltaR = dR( off->eta(), off->phi(), feat->eta(), feat->phi() );
1775  if( deltaR < maxDeltaR){
1776  maxDeltaR=deltaR;
1777  onl=feat;
1778  }
1779  }
1780  }
1781 
1782  if(!onl) continue;
1783 
1784  et_vec.push_back(onl->et()*1e-3);
1785  eta_vec.push_back(onl->eta());
1786  const float dummy=-999;
1787 
1788  float val_off=0.;
1789 
1790  val_off=off->caloCluster()->et();
1791  if(val_off!=0.){
1792  res_et_vec.push_back(((onl->et())-val_off)/val_off);
1793  }else{
1794  res_et_vec.push_back(dummy);
1795  }
1796 
1797  val_off=off->caloCluster()->eta();
1798  if(val_off!=0.){
1799  res_eta_vec.push_back((onl->eta()-val_off)/val_off);
1800  }else{
1801  res_eta_vec.push_back(dummy);
1802  }
1803 
1804  val_off=off->caloCluster()->phi();
1805  if(val_off!=0.){
1806  res_phi_vec.push_back((onl->phi()-val_off)/val_off);
1807  }else{
1808  res_phi_vec.push_back((onl->phi()-val_off)/val_off);
1809  }
1810 
1811  float elonl_ethad = onl->energy( CaloSampling::HEC0 ); elonl_ethad += onl->energy( CaloSampling::HEC1 );
1812  elonl_ethad += onl->energy( CaloSampling::HEC2 ); elonl_ethad += onl->energy( CaloSampling::HEC3 );
1813  elonl_ethad += onl->energy( CaloSampling::TileBar0 ); elonl_ethad += onl->energy( CaloSampling::TileExt0 );
1814  elonl_ethad += onl->energy( CaloSampling::TileBar1 ); elonl_ethad += onl->energy( CaloSampling::TileExt1 );
1815  elonl_ethad += onl->energy( CaloSampling::TileBar2 ); elonl_ethad += onl->energy( CaloSampling::TileExt2 );
1816  elonl_ethad /= TMath::CosH(onl->eta() );
1817  val_off=getShowerShape_ethad(off);
1818  if(val_off!=0.){
1819  res_ethad_vec.push_back((elonl_ethad-val_off)/val_off);
1820  }else{
1821  res_ethad_vec.push_back(dummy);
1822  }
1823 
1824  val_off=getShowerShape_ethad1(off);
1825  if(val_off!=0.){
1826  res_ethad1_vec.push_back(( (onl->ehad1()/TMath::Abs(onl->eta()) )-val_off)/val_off);
1827  }else{
1828  res_ethad1_vec.push_back(dummy);
1829  }
1830 
1831  float elonl_Rhad = elonl_ethad / onl->energy() ;
1832  val_off=getShowerShape_Rhad(off);
1833  if(val_off!=0.){
1834  res_Rhad_vec.push_back(( elonl_Rhad-val_off)/val_off);
1835  }else{
1836  res_Rhad_vec.push_back(dummy);
1837  }
1838 
1839  float elonl_Rhad1 = onl->ehad1() / onl->energy() ;
1840  val_off=getShowerShape_Rhad1(off);
1841  if(val_off!=0.){
1842  res_Rhad1_vec.push_back(( elonl_Rhad1-val_off)/val_off);
1843  }else{
1844  res_Rhad1_vec.push_back(dummy);
1845  }
1846 
1847  float onl_reta= 999.0;
1848  if ( fabsf ( onl->e277() ) > 0.01 ) onl_reta = onl->e237() / onl->e277();
1849  val_off=getShowerShape_Reta(off);
1850  if(val_off!=0.){
1851  res_Reta_vec.push_back( (onl_reta -val_off)/val_off);
1852  }else{
1853  res_Reta_vec.push_back(dummy);
1854  }
1855 
1856  val_off=getShowerShape_weta2(off);
1857  if(val_off!=0.){
1858  res_weta2_vec.push_back(( (onl->weta2())-val_off)/val_off);
1859  }else{
1860  res_weta2_vec.push_back(dummy);
1861  }
1862 
1863  float onl_f1 = onl->energy(CaloSampling::EMB1)+onl->energy(CaloSampling::EME1);
1864  onl_f1 /= onl->energy();
1865  val_off=getShowerShape_f1(off);
1866  if(val_off!=0.){
1867  res_f1_vec.push_back(( (onl_f1)-val_off)/val_off);
1868  }else{
1869  res_f1_vec.push_back(dummy);
1870  }
1871 
1872  float onl_f3 = onl->energy(CaloSampling::EMB3)+onl->energy(CaloSampling::EME3);
1873  onl_f3 /= onl->energy();
1874  val_off=getShowerShape_f3(off);
1875  if(val_off!=0.){
1876  res_f3_vec.push_back(( (onl_f3)-val_off)/val_off);
1877  }else{
1878  res_f3_vec.push_back(dummy);
1879  }
1880 
1881  float onl_eratio = 999.0;
1882  if ( fabsf(onl->emaxs1() + onl->e2tsts1()) > 0.01 )
1883  onl_eratio = (onl->emaxs1() - onl->e2tsts1()) / (onl->emaxs1() + onl->e2tsts1());
1884  val_off=getShowerShape_Eratio(off);
1885  if(val_off!=0.){
1886  res_eratio_vec.push_back(( (onl_eratio)-val_off)/val_off);
1887  }else{
1888  res_eratio_vec.push_back(dummy);
1889  }
1890 
1891  }// Loop over all pair objects
1892 
1893 
1894  // Fill everything
1895  fill( monGroup ,
1896  et_col ,
1897  eta_col ,
1898  res_et_col ,
1899  res_eta_col ,
1900  res_phi_col ,
1901  res_ethad_col ,
1902  res_ethad1_col ,
1903  res_Rhad_col ,
1904  res_Rhad1_col ,
1905  res_Reta_col ,
1906  res_Rphi_col ,
1907  res_weta2_col ,
1908  res_f1_col ,
1909  res_f3_col ,
1910  res_eratio_col
1911  );
1912 
1913 }
1914 
grepfile.info
info
Definition: grepfile.py:38
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
python.TIDAMonTool.monGroup
def monGroup(analysis_chain)
Definition: TIDAMonTool.py:297
RunTrigEgammaMonitoring.onlyHLT
onlyHLT
Definition: RunTrigEgammaMonitoring.py:109
TrigEgammaMonitorBaseAlgorithm::dR
float dR(const float, const float, const float, const float) const
Get delta R.
Definition: TrigEgammaMonitorBaseAlgorithm.cxx:292
et
Extra patterns decribing particle interation process.
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
CaloCell_ID_FCS::TileExt2
@ TileExt2
Definition: FastCaloSim_CaloCell_ID.h:39
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17
constants.EMB1
int EMB1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:53
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ParticleTest.eg
eg
Definition: ParticleTest.py:29
_triginfo
Definition: TrigEgammaMonitorBaseAlgorithm.h:42
TrigEgammaMonitorBaseAlgorithm::getEt
float getEt(const xAOD::Electron *eg) const
Definition: TrigEgammaMonitorBaseAlgorithm.cxx:311
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
CaloCell_ID_FCS::TileExt0
@ TileExt0
Definition: FastCaloSim_CaloCell_ID.h:37
CaloCell_ID_FCS::TileBar1
@ TileBar1
Definition: FastCaloSim_CaloCell_ID.h:32
TrigEgammaMonitorBaseAlgorithm::setAccept
asg::AcceptData setAccept(const TrigCompositeUtils::Decision *, const TrigInfo &, const bool) const
Set the accept object for all trigger levels.
Definition: TrigEgammaMonitorBaseAlgorithm.cxx:177
TrigEgammaMonitorAnalysisAlgorithm::fillDistributions
void fillDistributions(const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &, const TrigInfo &) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:420
dirname
std::string dirname(std::string name)
Definition: utils.cxx:200
test_pyathena.pt
pt
Definition: test_pyathena.py:11
xAOD::passBits
passBits
Definition: TrigPassBits_v1.cxx:115
xAOD::CaloCluster_v1::et
double et() const
Definition: CaloCluster_v1.h:859
LArG4GenerateShowerLib.condition
condition
Definition: LArG4GenerateShowerLib.py:19
xAOD::Egamma_v1
Definition: Egamma_v1.h:56
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:9
CaloCell_ID_FCS::HEC2
@ HEC2
Definition: FastCaloSim_CaloCell_ID.h:29
TrigEgammaMonitorBaseAlgorithm::tdt
const ToolHandle< Trig::TrigDecisionTool > & tdt() const
Get the TDT
Definition: TrigEgammaMonitorBaseAlgorithm.h:133
TrigEgammaMonitorAnalysisAlgorithm.h
TrigEgammaMonitorAnalysisAlgorithm::~TrigEgammaMonitorAnalysisAlgorithm
virtual ~TrigEgammaMonitorAnalysisAlgorithm() override
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:13
TrigEgammaMonitorAnalysisAlgorithm::fillL1Calo
void fillL1Calo(const std::string &trigger, const std::vector< const xAOD::EmTauRoI * > &l1_vec) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:575
TrigEgammaMonitorAnalysisAlgorithm::fillShowerShapes
void fillShowerShapes(const std::string &trigger, const std::vector< const xAOD::Egamma * > &eg_vec, bool online) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:766
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
TrigEgammaMonitorAnalysisAlgorithm::fillResolutions
void fillResolutions(const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * >> &pairObjs, const TrigInfo &info) const
*****************************************************************************************************...
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:935
TrigEgammaMonitorAnalysisAlgorithm::fillL2Electron
void fillL2Electron(const std::string &trigger, const std::vector< const xAOD::TrigElectron * > &el_vec) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:662
calibdata.valid
list valid
Definition: calibdata.py:45
TileSynchronizeBch.online
online
Definition: TileSynchronizeBch.py:88
xAOD::EgammaHelpers::isConvertedPhoton
bool isConvertedPhoton(const xAOD::Egamma *eg, bool excludeTRT=false)
is the object a converted photon
Definition: EgammaxAODHelpers.cxx:25
CaloCell_ID_FCS::HEC1
@ HEC1
Definition: FastCaloSim_CaloCell_ID.h:28
PixelAthClusterMonAlgCfg.histname
histname
Definition: PixelAthClusterMonAlgCfg.py:106
TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloResolution
void fillL1CaloResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const xAOD::EmTauRoI * >> &pairObjs) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:991
SG::Decorator< bool >
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
TrigEgammaMonitorAnalysisAlgorithm::TrigEgammaMonitorAnalysisAlgorithm
TrigEgammaMonitorAnalysisAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:8
CaloCell_ID_FCS::TileBar0
@ TileBar0
Definition: FastCaloSim_CaloCell_ID.h:31
TrigEgammaMonitorAnalysisAlgorithm::fillEfficiencies
void fillEfficiencies(const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &, const TrigInfo &, const bool) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:42
TrigEgammaMonitorAnalysisAlgorithm::fillL2CaloResolution
void fillL2CaloResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * >> &pairObjs) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:1732
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::EgammaHelpers::isElectron
bool isElectron(const xAOD::Egamma *eg)
is the object an electron (not Fwd)
Definition: EgammaxAODHelpers.cxx:12
TrigEgammaMonitorAnalysisAlgorithm::fillHLTPhotonResolution
void fillHLTPhotonResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * >> &pairObjs, const TrigInfo &info) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:1427
TrigEgammaMonitorBaseAlgorithm::m_emulatorTool
ToolHandle< Trig::TrigEgammaEmulationToolMT > m_emulatorTool
Definition: TrigEgammaMonitorBaseAlgorithm.h:92
xAOD::Egamma_v1::caloCluster
const xAOD::CaloCluster * caloCluster(size_t index=0) const
Pointer to the xAOD::CaloCluster/s that define the electron candidate.
Definition: Egamma_v1.cxx:388
add-xsec-uncert-quadrature-N.label
label
Definition: add-xsec-uncert-quadrature-N.py:104
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
ParticleGun_EoverP_Config.pid
pid
Definition: ParticleGun_EoverP_Config.py:62
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
constants.EME1
int EME1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:55
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigEgammaMonitorBaseAlgorithm::m_doEmulation
Gaudi::Property< bool > m_doEmulation
Do emulation.
Definition: TrigEgammaMonitorBaseAlgorithm.h:104
xAOD::Egamma_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle.
Definition: Egamma_v1.cxx:75
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloAbsResolution
void fillL1CaloAbsResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const xAOD::EmTauRoI * >> &pairObjs) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:1021
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
TrigEgammaMonitorAnalysisAlgorithm::fillL2Calo
void fillL2Calo(const std::string &trigger, const std::vector< const xAOD::TrigEMCluster * > &emCluster_vec) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:635
TrigEgammaMonitorBaseAlgorithm::m_isemname
Gaudi::Property< std::vector< std::string > > m_isemname
isem names
Definition: TrigEgammaMonitorBaseAlgorithm.h:113
TrigEgammaMonitorAnalysisAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:17
TrigEgammaMonitorAnalysisAlgorithm::fillEFCalo
void fillEFCalo(const std::string &trigger, const std::vector< const xAOD::CaloCluster * > &clus_vec) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:711
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
TrigEgammaMonitorAnalysisAlgorithm::fillL1eEM
void fillL1eEM(const std::string &trigger, const std::vector< const xAOD::eFexEMRoI * > &l1_vec) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:604
CaloCell_ID_FCS::TileExt1
@ TileExt1
Definition: FastCaloSim_CaloCell_ID.h:38
CaloCell_ID_FCS::EME3
@ EME3
Definition: FastCaloSim_CaloCell_ID.h:26
xAOD::Electron_v1
Definition: Electron_v1.h:34
xAOD::CaloCluster_v1::PHICALOFRAME
@ PHICALOFRAME
Phi in the calo frame (for egamma)
Definition: CaloCluster_v1.h:191
AthMonitorAlgorithm::lbAverageInteractionsPerCrossing
virtual float lbAverageInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the average mu, i.e.
Definition: AthMonitorAlgorithm.cxx:227
TrigEgammaMonitorAnalysisAlgorithm::fillTracking
void fillTracking(const std::string &trigger, const std::vector< const xAOD::Electron * > &eg_vec, bool online) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:829
TrigEgammaMonitorBaseAlgorithm::match
const ToolHandle< TrigEgammaMatchingToolMT > & match() const
Get the e/g match tool.
Definition: TrigEgammaMonitorBaseAlgorithm.h:135
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
CaloCell_ID_FCS::HEC0
@ HEC0
Definition: FastCaloSim_CaloCell_ID.h:27
TrigEgammaMonitorAnalysisAlgorithm::fillLabel
void fillLabel(const ToolHandle< GenericMonitoringTool > &groupHandle, const std::string &histname, const std::string &label) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:30
TrigEgammaMonitorBaseAlgorithm::m_lhname
Gaudi::Property< std::vector< std::string > > m_lhname
lh names
Definition: TrigEgammaMonitorBaseAlgorithm.h:115
TrigEgammaMonitorBaseAlgorithm::getD0sig
float getD0sig(const xAOD::Electron *eg) const
Definition: TrigEgammaMonitorBaseAlgorithm.cxx:382
xAOD::Photon_v1
Definition: Photon_v1.h:37
TrigRoiDescriptorCollection
Definition: TrigRoiDescriptorCollection.h:21
plotBeamSpotMon.mon
mon
Definition: plotBeamSpotMon.py:67
TrigEgammaMonitorBaseAlgorithm::m_detailedHists
Gaudi::Property< bool > m_detailedHists
Include more detailed histograms.
Definition: TrigEgammaMonitorBaseAlgorithm.h:119
xAOD::Egamma_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: Egamma_v1.cxx:65
TrigEgammaMonitorBaseAlgorithm
Definition: TrigEgammaMonitorBaseAlgorithm.h:66
xAOD::Egamma_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: Egamma_v1.cxx:70
TrigEgammaMonitorAnalysisAlgorithm::fillInefficiency
void fillInefficiency(const std::string &pidword, const TrigInfo &info, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * >> &pairObjs, const std::vector< asg::AcceptData > &acceptObjs) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:377
skel.l1
l1
Definition: skel.GENtoEVGEN.py:409
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
xAOD::TrigEMCluster_v1
Description of a trigger EM cluster.
Definition: TrigEMCluster_v1.h:28
CaloCell_ID_FCS::HEC3
@ HEC3
Definition: FastCaloSim_CaloCell_ID.h:30
xAOD::CaloCluster_v1::ETACALOFRAME
@ ETACALOFRAME
Eta in the calo frame (for egamma)
Definition: CaloCluster_v1.h:190
TrigEgammaMonitorBaseAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: TrigEgammaMonitorBaseAlgorithm.cxx:24
CaloCell_ID_FCS::EMB3
@ EMB3
Definition: FastCaloSim_CaloCell_ID.h:22
makeComparison.deltaR
float deltaR
Definition: makeComparison.py:36
TrigEgammaMonitorAnalysisAlgorithm::fillL2Photon
void fillL2Photon(const std::string &trigger, const std::vector< const xAOD::TrigPhoton * > &eg_vec) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:686
CaloCell_ID_FCS::TileBar2
@ TileBar2
Definition: FastCaloSim_CaloCell_ID.h:33
Decorator.h
Helper class to provide type-safe access to aux data.
WriteBchToCool.onl
onl
Definition: WriteBchToCool.py:137
AthMonitorAlgorithm::getGroup
const ToolHandle< GenericMonitoringTool > & getGroup(const std::string &name) const
Get a specific monitoring tool from the tool handle array.
Definition: AthMonitorAlgorithm.cxx:164
TrigEgammaMonitorAnalysisAlgorithm::fillHLTElectronResolution
void fillHLTElectronResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * >> &pairObjs, const TrigInfo &info) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:1049
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
TrigEgammaMonitorAnalysisAlgorithm::fillEfficiency
void fillEfficiency(const std::string &subgroup, const std::string &level, const std::string &pidword, const TrigInfo &info, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * >> &pairObjs, const std::vector< asg::AcceptData > &acceptObjs, const std::string &dirname) const
Definition: TrigEgammaMonitorAnalysisAlgorithm.cxx:156
Generated on Wed May 14 2025 21:20:46 for ATLAS Offline Software by   doxygen 1.8.18