ATLAS Offline Software
TrigEDMChecker.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
7 #include "GaudiKernel/IToolSvc.h"
8 
13 
19 
20 #include "AthContainers/debug.h"
22 #include "xAODJet/JetContainer.h"
56 #include "tauEvent/TauJet.h"
57 
58 #include "xAODMuon/MuonContainer.h"
59 
62 
69 
71 #include "xAODEgamma/Electron.h"
73 #include "xAODEgamma/Photon.h"
74 
75 
78 #include "xAODTau/TauDefs.h"
79 #include "xAODTau/TauJet.h"
80 
81 
82 #include "TrigEDMChecker.h"
83 
92 
96 
98 
99 
100 
101 #include "AthViews/ViewHelper.h"
102 #include "AthViews/View.h"
103 
104 
105 #include <iostream>
106 #include <fstream>
107 #include <queue>
108 
109 static const int maxRepWarnings = 5;
110 
111 
112 TrigEDMChecker::TrigEDMChecker(const std::string& name, ISvcLocator* pSvcLocator)
113  : AthAnalysisAlgorithm(name, pSvcLocator),
114  m_clidSvc( "ClassIDSvc", name )
115 {
118  declareProperty("doDumpAll", m_doDumpAll = true);
119  declareProperty("doDumpTrigPassBits", m_doDumpTrigPassBits = false);
120  declareProperty("doDumpLVL1_ROI", m_doDumpLVL1_ROI = false);
121  declareProperty("doDumpTrigMissingET", m_doDumpTrigMissingET = false);
122  declareProperty("doDumpxAODTrigMissingET", m_doDumpxAODTrigMissingET = false);
123  declareProperty("doDumpMuonFeature", m_doDumpMuonFeature = false);
124  declareProperty("doDumpCombinedMuonFeature", m_doDumpCombinedMuonFeature = false);
125  declareProperty("doDumpTileMuFeature", m_doDumpTileMuFeature = false);
126  declareProperty("doDumpTileTrackMuFeature", m_doDumpTileTrackMuFeature = false);
127  declareProperty("doDumpTrigPhotonContainer", m_doDumpTrigPhotonContainer = false);
128  declareProperty("doDumpTrigL2BphysContainer", m_doDumpTrigL2BphysContainer = false);
129  declareProperty("doDumpTrigEFBphysContainer", m_doDumpTrigEFBphysContainer = false);
130  declareProperty("doDumpTrigEFBjetContainer", m_doDumpTrigEFBjetContainer = false);
131  declareProperty("doDumpTrigL2BjetContainer", m_doDumpTrigL2BjetContainer = false);
132  declareProperty("doDumpxAODJetContainer", m_doDumpxAODJetContainer = false);
133  declareProperty("doDumpTrigMuonEFContainer", m_doDumpTrigMuonEFContainer = false);
134  declareProperty("doDumpTrigMuonEFInfoContainer", m_doDumpTrigMuonEFInfoContainer = false);
135  declareProperty("doDumpTrigMuonEFIsolationContainer", m_doDumpTrigMuonEFIsolationContainer = false);
136  declareProperty("doDumpxAODMuonContainer", m_doDumpxAODMuonContainer = false);
137  declareProperty("doDumpTrigElectronContainer", m_doDumpTrigElectronContainer = false);
138  declareProperty("doDumpxAODTrigElectronContainer", m_doDumpxAODTrigElectronContainer = false);
139  declareProperty("doDumpxAODTrigPhotonContainer", m_doDumpxAODTrigPhotonContainer = false);
140  declareProperty("doDumpxAODElectronContainer", m_doDumpxAODElectronContainer = false);
141  declareProperty("doDumpxAODPhotonContainer", m_doDumpxAODPhotonContainer = false);
142  declareProperty("doDumpHLTResult", m_doDumpHLTResult = false);
143  declareProperty("doDumpTrigTauContainer", m_doDumpTrigTauContainer = false);
144  declareProperty("doDumpTrigTauTracksInfo", m_doDumpTrigTauTracksInfo = false);
145  declareProperty("doDumpTrigInDetTrackCollection", m_doDumpTrigInDetTrackCollection = false);
146  declareProperty("doDumpTrigVertexCollection", m_doDumpTrigVertexCollection = false);
147  declareProperty("doDumpTrigEMCluster", m_doDumpTrigEMCluster = false);
148  declareProperty("doDumpTrigEMClusterContainer", m_doDumpTrigEMClusterContainer = false);
149  declareProperty("doDumpxAODTrigEMCluster", m_doDumpxAODTrigEMCluster = false);
150  declareProperty("doDumpxAODTrigEMClusterContainer", m_doDumpxAODTrigEMClusterContainer = false);
151  declareProperty("doDumpTrigTauClusterContainer", m_doDumpTrigTauClusterContainer = false);
152  declareProperty("doDumpTrackParticleContainer", m_doDumpTrackParticleContainer = false);
153  declareProperty("doDumpTauJetContainer", m_doDumpTauJetContainer = false);
154  declareProperty("doDumpxAODTrackParticle", m_doDumpxAODTrackParticle = false);
155  declareProperty("doDumpxAODVertex", m_doDumpxAODVertex = false);
156  declareProperty("doDumpxAODTauJetContainer", m_doDumpxAODTauJetContainer = false);
157  declareProperty("doDumpxAODTrigMinBias", m_doDumpxAODTrigMinBias = false);
158  declareProperty("doDumpStoreGate", m_doDumpStoreGate = false );
159  declareProperty("doDumpAllTrigComposite", m_doDumpAllTrigComposite = false );
160  declareProperty("dumpTrigCompositeContainers", m_dumpTrigCompositeContainers, "List of TC to dump" );
161  declareProperty("doDumpTrigCompsiteNavigation", m_doDumpTrigCompsiteNavigation = false );
162  declareProperty("doDumpNavigation", m_doDumpNavigation = false );
163  declareProperty("doTDTCheck", m_doTDTCheck = false );
164  declareProperty( "ClassIDSvc", m_clidSvc, "Service providing CLID info" );
165 }
166 
167 
168 
170 
172 
173  ATH_CHECK( m_navigationHandleKey.initialize() );
174  ATH_CHECK( m_decisionsKey.initialize() );
175  ATH_CHECK( m_navigationTool.retrieve() );
176 
177  ATH_MSG_DEBUG("Initializing TrigEDMChecker");
178 
179  ATH_MSG_INFO("REGTEST Initializing...");
180  ATH_MSG_INFO("REGTEST m_doDumpAll = " << m_doDumpAll );
181  ATH_MSG_INFO("REGTEST m_doDumpLVL1_ROI = " << m_doDumpLVL1_ROI);
182  ATH_MSG_INFO("REGTEST m_doDumpTrigMissingET = " << m_doDumpTrigMissingET );
183  ATH_MSG_INFO("REGTEST m_doDumpxAODTrigMissingET = " << m_doDumpxAODTrigMissingET );
184  ATH_MSG_INFO("REGTEST m_doDumpMuonFeature = " << m_doDumpMuonFeature );
185  ATH_MSG_INFO("REGTEST m_doDumpCombinedMuonFeature = " << m_doDumpCombinedMuonFeature );
186  ATH_MSG_INFO("REGTEST m_doDumpTileMuFeature = " << m_doDumpTileMuFeature);
187  ATH_MSG_INFO("REGTEST m_doDumpTileTrackMuFeature = " << m_doDumpTileTrackMuFeature);
188  ATH_MSG_INFO("REGTEST m_doDumpTrigPhotonContainer = " << m_doDumpTrigPhotonContainer );
189  ATH_MSG_INFO("REGTEST m_doDumpTrigL2BphysContainer = " << m_doDumpTrigL2BphysContainer );
190  ATH_MSG_INFO("REGTEST m_doDumpTrigEFBphysContainer = " << m_doDumpTrigEFBphysContainer );
191  ATH_MSG_INFO("REGTEST m_doDumpTrigEFBjetContainer = " << m_doDumpTrigEFBjetContainer );
192  ATH_MSG_INFO("REGTEST m_doDumpTrigL2BjetContainer = " << m_doDumpTrigL2BjetContainer );
193  ATH_MSG_INFO("REGTEST m_doDumpxAODJetContainer = " << m_doDumpxAODJetContainer );
194  ATH_MSG_INFO("REGTEST m_doDumpTrigMuonEFContainer = " << m_doDumpTrigMuonEFContainer );
195  ATH_MSG_INFO("REGTEST m_doDumpTrigMuonEFInfoContainer = " << m_doDumpTrigMuonEFInfoContainer );
196  ATH_MSG_INFO("REGTEST m_doDumpxAODMuonContainer = " << m_doDumpxAODMuonContainer );
197  ATH_MSG_INFO("REGTEST m_doDumpTrigElectronContainer = " << m_doDumpTrigElectronContainer );
198  ATH_MSG_INFO("REGTEST m_doDumpxAODTrigElectronContainer= " << m_doDumpxAODTrigElectronContainer );
199  ATH_MSG_INFO("REGTEST m_doDumpxAODTrigPhotonContainer = " << m_doDumpxAODTrigPhotonContainer );
200  ATH_MSG_INFO("REGTEST m_doDumpxAODElectronContainer = " << m_doDumpxAODElectronContainer );
201  ATH_MSG_INFO("REGTEST m_doDumpxAODPhotonContainer = " << m_doDumpxAODPhotonContainer );
202  ATH_MSG_INFO("REGTEST m_doDumpHLTResult = " << m_doDumpHLTResult );
203  ATH_MSG_INFO("REGTEST m_doDumpTrigTauContainer = " << m_doDumpTrigTauContainer );
204  ATH_MSG_INFO("REGTEST m_doDumpTrigTauTracksInfo = " << m_doDumpTrigTauTracksInfo );
205  ATH_MSG_INFO("REGTEST m_doDumpTrigInDetTrackCollection = " << m_doDumpTrigInDetTrackCollection );
206  ATH_MSG_INFO("REGTEST m_doDumpTrigVertexCollection = " << m_doDumpTrigVertexCollection );
207  ATH_MSG_INFO("REGTEST m_doDumpTrigEMCluster = " << m_doDumpTrigEMCluster );
208  ATH_MSG_INFO("REGTEST m_doDumpTrigEMClusterContainer = " << m_doDumpTrigEMClusterContainer );
209  ATH_MSG_INFO("REGTEST m_doDumpTrigTauClusterContainer = " << m_doDumpTrigTauClusterContainer );
210  ATH_MSG_INFO("REGTEST m_doDumpTrackParticleContainer = " << m_doDumpTrackParticleContainer );
211  ATH_MSG_INFO("REGTEST m_doDumpTauJetContainer = " << m_doDumpTauJetContainer );
212  ATH_MSG_INFO("REGTEST m_doDumpxAODTrackParticle = " << m_doDumpxAODTrackParticle );
213  ATH_MSG_INFO("REGTEST m_doDumpxAODVertex = " << m_doDumpxAODVertex );
214  ATH_MSG_INFO("REGTEST m_doDumpxAODTauJetContainer = " << m_doDumpxAODTauJetContainer );
215  ATH_MSG_INFO("REGTEST m_doDumpxAODTrigMinBias = " << m_doDumpxAODTrigMinBias );
216  ATH_MSG_INFO("REGTEST m_doDumpStoreGate = " << m_doDumpStoreGate );
217  ATH_MSG_INFO("REGTEST m_doDumpAllTrigComposite = " << m_doDumpAllTrigComposite );
218  ATH_MSG_INFO("REGTEST m_dumpTrigCompositeContainers = " << m_dumpTrigCompositeContainers );
219  ATH_MSG_INFO("REGTEST m_doDumpTrigCompsiteNavigation = " << m_doDumpTrigCompsiteNavigation );
220  ATH_MSG_INFO("REGTEST m_doTDTCheck = " << m_doTDTCheck );
221 
222  ATH_MSG_INFO("maxRepWarning = " << maxRepWarnings );
223 
225  ATH_CHECK( m_muonPrinter.retrieve() );
226  }
227  else m_muonPrinter.disable(); // to avoid auto-retrieval
228 
230  ATH_CHECK( m_clidSvc.retrieve() );
231  }
232 
234  ATH_CHECK( m_trigDec.retrieve() );
235  ATH_MSG_INFO("TDT Executing with navigation format: " << m_trigDec->getNavigationFormat());
236  }
238 
239  return StatusCode::SUCCESS;
240 }
241 
242 
244 
245  /* fwinkl, Mar 20222:
246  Some attempt was made to make the code pass the thread-checker. Methods that
247  are clearly not thread-safe (e.g. use of DataHandle) are marked as such. Calling
248  these methods from within execute would still trigger a thread-checker warning.
249  Since this algorithm is only ever used for validation and in single-threaded athena,
250  we suppress these warnings by the following assignment. This has the advantage
251  (as opposed to disabling the checking for the entire file) that new code is still
252  being checked and will hopefully be written in a thread-safe manner, i.e. using
253  ReadHandleKeys. If someone is very eager they could migrate all uses of DataHandles...
254  */
255  StatusCode sc ATLAS_THREAD_SAFE = do_execute();
256  return sc;
257 }
258 
259 StatusCode TrigEDMChecker::do_execute ATLAS_NOT_THREAD_SAFE() {
260 
261  ATH_MSG_INFO( " ==========START of event===========" );
262 
263  if(m_doDumpTrackParticleContainer){
264  StatusCode sc = dumpTrackParticleContainer();
265  if (sc.isFailure()) {
266  ATH_MSG_ERROR("The method dumpTrackParticleContainer() failed");
267  }
268  }
269 
270  if(m_doDumpAll || m_doDumpLVL1_ROI ){
271  StatusCode sc = dumpLVL1_ROI();
272  if (sc.isFailure()) {
273  ATH_MSG_ERROR("The method dumpLVL1_ROI() failed");
274  }
275  }
276 
277  /*
278  if(m_doDumpAll || m_doDumpTrigMissingET){
279  StatusCode sc = dumpTrigMissingET();
280  if (sc.isFailure()) {
281  mLog << MSG::ERROR << "The method dumpTrigMissingET() failed" << endmsg;
282 
283  }
284  }
285  */
286 
287  if(m_doDumpAll || m_doDumpxAODTrigMissingET){
288  StatusCode sc = dumpxAODTrigMissingET();
289  if (sc.isFailure()) {
290  ATH_MSG_ERROR("The method dumpxAODTrigMissingET() failed");
291  }
292  }
293 
294  if(m_doDumpAll || m_doDumpMuonFeature){
295  StatusCode sc = dumpMuonFeature();
296  if (sc.isFailure()) {
297  ATH_MSG_ERROR("The method dumpMuonFeature() failed");
298  }
299  }
300 
301  if(m_doDumpAll || m_doDumpCombinedMuonFeature){
302  StatusCode sc = dumpCombinedMuonFeature();
303  if (sc.isFailure()) {
304  ATH_MSG_ERROR("The method dumpCombinedMuonFeature() failed");
305  }
306  sc = dumpCombinedMuonFeatureContainer();
307  if (sc.isFailure()) {
308  ATH_MSG_ERROR("The method dumpCombinedMuonFeatureContainer() failed");
309  return StatusCode::SUCCESS;
310  }
311  }
312 
313  if(m_doDumpAll || m_doDumpTileMuFeature) {
314  StatusCode sc = dumpTileMuFeatureContainer();
315  if (sc.isFailure()) {
316  ATH_MSG_ERROR("The method dumpTileMuFeatureContainer() failed");
317  }
318  }
319 
320  if(m_doDumpAll || m_doDumpTileTrackMuFeature) {
321  StatusCode sc = dumpTileTrackMuFeatureContainer();
322  if (sc.isFailure()) {
323  ATH_MSG_ERROR("The method dumpTileTrackMuFeatureContainer() failed");
324  }
325  }
326 
327  if(m_doDumpAll || m_doDumpTrigEMCluster){
328  StatusCode sc = dumpTrigEMCluster();
329  if (sc.isFailure()) {
330  ATH_MSG_ERROR("The method dumpTrigEMCluster() failed");
331  }
332  }
333 
334  if(m_doDumpAll || m_doDumpTrigEMClusterContainer){
335  StatusCode sc = dumpTrigEMClusterContainer();
336  if (sc.isFailure()) {
337  ATH_MSG_ERROR("The method dumpTrigEMClusterContainer() failed");
338  }
339  }
340 
341  if(m_doDumpAll || m_doDumpxAODTrigEMCluster){
342  StatusCode sc = dumpxAODTrigEMCluster();
343  if (sc.isFailure()) {
344  ATH_MSG_ERROR("The method dumpxAODTrigEMCluster() failed");
345  }
346  }
347 
348  if(m_doDumpAll || m_doDumpxAODTrigEMClusterContainer){
349  StatusCode sc = dumpxAODTrigEMClusterContainer();
350  if (sc.isFailure()) {
351  ATH_MSG_ERROR("The method dumpxAODTrigEMClusterContainer() failed");
352  }
353  }
354 
355  if(m_doDumpTrigTauClusterContainer){
356  StatusCode sc = dumpTrigTauClusterContainer();
357  if (sc.isFailure()) {
358  ATH_MSG_ERROR("The method dumpTrigTauClusterContainer() failed");
359  }
360  }
361 
362  if(m_doDumpAll || m_doDumpTrigPhotonContainer){
363  StatusCode sc = dumpTrigPhotonContainer();
364  if (sc.isFailure()) {
365  ATH_MSG_ERROR("The method dumpTrigPhotonContainer() failed");
366  }
367  }
368 
369  if(m_doDumpAll || m_doDumpxAODJetContainer){
370  StatusCode sc = dumpxAODJetContainer();
371  if (sc.isFailure()) {
372  ATH_MSG_ERROR("The method dumpxAODJetContainer() failed");
373  }
374  }
375 
376  if(m_doDumpAll || m_doDumpTrigL2BphysContainer){
377  StatusCode sc = dumpTrigL2BphysContainer();
378  if (sc.isFailure()) {
379  ATH_MSG_ERROR("The method dumpTrigL2BphysContainer() failed");
380  }
381  }
382 
383  if(m_doDumpAll || m_doDumpTrigEFBphysContainer){
384  StatusCode sc = dumpTrigEFBphysContainer();
385  if (sc.isFailure()) {
386  ATH_MSG_ERROR("The method dumpTrigEFBphysContainer() failed");
387  }
388  }
389 
390  if(m_doDumpAll || m_doDumpTrigEFBjetContainer){
391  StatusCode sc = dumpTrigEFBjetContainer();
392  if (sc.isFailure()) {
393  ATH_MSG_ERROR("The method dumpTrigEFBjetContainer() failed");
394  }
395  }
396 
397  if(m_doDumpAll || m_doDumpTrigL2BjetContainer){
398  StatusCode sc = dumpTrigL2BjetContainer();
399  if (sc.isFailure()) {
400  ATH_MSG_ERROR("The method dumpTrigL2BjetContainer() failed");
401  }
402  }
403 
404  if(m_doDumpAll || m_doDumpTrigMuonEFContainer){
405  StatusCode sc = dumpTrigMuonEFContainer();
406  if (sc.isFailure()) {
407  ATH_MSG_ERROR("The method dumpTrigMuonEFContainer() failed");
408  }
409  }
410 
411  if(m_doDumpAll || m_doDumpTrigMuonEFInfoContainer){
412  StatusCode sc = dumpTrigMuonEFInfoContainer();
413  if (sc.isFailure()) {
414  ATH_MSG_ERROR("The method dumpTrigMuonEFInfoContainer() failed");
415  }
416  }
417 
418  if(m_doDumpAll || m_doDumpTrigMuonEFIsolationContainer) {
419  StatusCode sc = dumpTrigMuonEFIsolationContainer();
420  if(sc.isFailure()) {
421  ATH_MSG_ERROR("The method dumpTrigMuonEFIsolationContainer() failed");
422  }
423  }
424 
425  if(m_doDumpAll || m_doDumpxAODMuonContainer) {
426  StatusCode sc = dumpxAODMuonContainer();
427  if(sc.isFailure()) {
428  ATH_MSG_ERROR("The method dumpxAODMuonContainer() failed");
429  }
430  }
431 
432  if(m_doDumpAll || m_doDumpTrigElectronContainer){
433  StatusCode sc = dumpTrigElectronContainer();
434  if (sc.isFailure()) {
435  ATH_MSG_ERROR("The method dumpTrigElectronContainer() failed");
436  }
437  }
438 
439  if(m_doDumpAll || m_doDumpxAODTrigElectronContainer){
440  StatusCode sc = dumpxAODTrigElectronContainer();
441  if (sc.isFailure()) {
442  ATH_MSG_ERROR("The method dumpxAODTrigElectronContainer() failed");
443  }
444  }
445 
446  if(m_doDumpAll || m_doDumpxAODTrigPhotonContainer){
447  StatusCode sc = dumpxAODTrigPhotonContainer();
448  if (sc.isFailure()) {
449  ATH_MSG_ERROR("The method dumpxAODTrigElectronContainer() failed");
450  }
451  }
452 
453  if(m_doDumpAll || m_doDumpxAODElectronContainer){
454  StatusCode sc = dumpxAODElectronContainer();
455  if (sc.isFailure()) {
456  ATH_MSG_ERROR("The method dumpxAODTrigElectronContainer() failed");
457  }
458  }
459 
460  if(m_doDumpAll || m_doDumpxAODPhotonContainer){
461  StatusCode sc = dumpxAODPhotonContainer();
462  if (sc.isFailure()) {
463  ATH_MSG_ERROR("The method dumpxAODTrigElectronContainer() failed");
464  }
465  }
466 
467  if(m_doDumpTrigTauContainer){
468  StatusCode sc = dumpTrigTauContainer();
469  if (sc.isFailure()) {
470  ATH_MSG_ERROR("The method dumpTrigTauContainer() failed");
471  }
472  }
473 
474  if(m_doDumpTrigTauTracksInfo){
475  StatusCode sc = dumpTrigTauTracksInfo();
476  if (sc.isFailure()) {
477  ATH_MSG_ERROR("The method dumpTrigTauTracksInfo() failed");
478  }
479  }
480 
481  if(m_doDumpAll || m_doDumpHLTResult){
482  StatusCode sc = dumpHLTResult();
483  if (sc.isFailure()) {
484  ATH_MSG_ERROR("The method dumpHLTResult() failed");
485  }
486  }
487 
488  if(m_doDumpTrigInDetTrackCollection){
489  StatusCode sc = dumpTrigInDetTrackCollection();
490  if (sc.isFailure()) {
491  ATH_MSG_ERROR("The method dumpTrigInDetTrackCollection() failed");
492  }
493  }
494 
495  if(m_doDumpAll || m_doDumpTrigVertexCollection){
496  StatusCode sc = dumpTrigVertexCollection();
497  if (sc.isFailure()) {
498  ATH_MSG_ERROR("The method dumpTrigVertexCollection() failed");
499  }
500  }
501 
502  if(m_doDumpAll || m_doDumpxAODTauJetContainer){
503  StatusCode sc = dumpxAODTauJetContainer();
504  if (sc.isFailure()) {
505  ATH_MSG_ERROR("The method dumpxAODTauJetContainer() failed");
506  }
507  }
508 
509  if(m_doDumpTauJetContainer){
510  StatusCode sc = dumpTauJetContainer();
511  if (sc.isFailure()) {
512  ATH_MSG_ERROR("The method dumpTauJetContainer() failed");
513  }
514  }
515 
516  if(m_doDumpAll || m_doDumpxAODTrackParticle){
517  StatusCode sc = dumpxAODTrackParticle();
518  if (sc.isFailure()) {
519  ATH_MSG_ERROR("The method dumpxAODTrackParticle() failed");
520  }
521  }
522 
523  if(m_doDumpAll || m_doDumpxAODVertex){
524  StatusCode sc = dumpxAODVertex();
525  if (sc.isFailure()) {
526  ATH_MSG_ERROR("The method dumpxAODVertex() failed");
527  }
528  }
529 
530  if (m_doDumpAll || m_doDumpxAODTrigMinBias){
531  StatusCode sc = dumpxAODTrigMinBias();
532  if (sc.isFailure()) {
533  ATH_MSG_ERROR("The method dumpxAODTrigMinBias() failed");
534  }
535  }
536 
537  if (m_doDumpTrigPassBits){
538  StatusCode sc = dumpTrigPassBits();
539  if (sc.isFailure()) {
540  ATH_MSG_ERROR("The method dumpTrigPassBits() failed");
541  }
542  }
543 
544  if (m_doDumpAll || m_doDumpStoreGate) {
545  ATH_MSG_DEBUG(evtStore()->dump());
546  }
547 
548  if (m_doDumpAll || m_doDumpNavigation) {
549  StatusCode sc = dumpNavigation();
550  if ( sc.isFailure() ) {
551  ATH_MSG_ERROR("The method dumpNavigation() failed");
552  }
553  }
554 
555  if (m_doDumpAll || m_doTDTCheck) {
556  ATH_CHECK(dumpTDT());
557  }
558 
559  if (m_doDumpAll || m_doDumpAllTrigComposite || m_dumpTrigCompositeContainers.size() > 0) {
560  ATH_CHECK( dumpTrigComposite() );
561  }
562 
563  if (m_doDumpAll || m_doDumpTrigCompsiteNavigation) {
564  std::string trigCompositeSteering;
565  bool pass;
566  ATH_CHECK(TrigCompositeNavigationToDot(trigCompositeSteering, pass));
567  const EventContext& context = Gaudi::Hive::currentContext();
568  const std::string evtNumber = std::to_string(context.eventID().event_number());
569  const std::string passStr = (pass ? "Pass" : "Fail");
570  std::ofstream ofile(std::string("NavGraph_" + m_dumpNavForChain + "_Ev" + evtNumber + "_" + passStr + ".dot").c_str());
571  ofile << trigCompositeSteering;
572  }
573 
574 
575 
576  ATH_MSG_INFO( " ==========END of event===========" );
577  return StatusCode::SUCCESS;
578 
579 }
580 
583  const std::string name="HLT_xAOD__TrigPassBitsContainer_passbits";
584  const xAOD::TrigPassBitsContainer *xbitscont=nullptr;
585  StatusCode sc = evtStore()->retrieve(xbitscont,name);
586  if (sc.isFailure() ){
587  ATH_MSG_INFO("Cannot retrieve TrigPassBits");
588  }
589  else {
590  ATH_MSG_INFO("Size of PassBits container : " << xbitscont->size());
591  for(const auto bits:*xbitscont){
592  if(bits==nullptr){
593  ATH_MSG_INFO("TrigPassBits point nullptr ");
594  continue;
595  }
596  ATH_MSG_DEBUG("Analyzing bits for " << bits->containerClid() << " of size " << bits->size() << " with bit size " << bits->passBits().size());
597  }
598  xAOD::TrigPassBitsContainer::const_iterator itr = xbitscont->begin();
599  xAOD::TrigPassBitsContainer::const_iterator itrE = xbitscont->end();
600 
601  for (int j=0; itr != itrE; ++itr, ++j ) {
602  const xAOD::TrigPassBits * bits = (*itr);
603  if(bits==nullptr){
604  ATH_MSG_INFO("TrigPassBits point nullptr ");
605  continue;
606  }
607  ATH_MSG_DEBUG("Analyzing bits for " << bits->containerClid() << " of size " << bits->size() << " with bit size " << bits->passBits().size());
608  }
609  }
610  return StatusCode::SUCCESS;
611 }
612 
614 {
615  ATH_MSG_INFO("MinBias in dumpTrigSpacePointCounts()");
616 
617  std::string METTag="HLT_xAOD__TrigSpacePointCountsContainer_spacepoints";
618 
619  const xAOD::TrigSpacePointCountsContainer* SpacePointCountsCont=0;
620  StatusCode sc = evtStore()->retrieve(SpacePointCountsCont,METTag);
621 
622  if (sc.isFailure())
623  ATH_MSG_INFO("failed to retrieve " << METTag);
624  else {
625  ATH_MSG_INFO("Accessing " << METTag << " with " << SpacePointCountsCont->size() << " elements");
626 
627  std::string s; char buff[128];
628  std::vector<float> getVec;
629  float sum;
630 
631  // Loop over container content
632  for(uint i = 0; i < SpacePointCountsCont->size(); i++) {
633  getVec = SpacePointCountsCont->at(i)->contentsPixelClusEndcapC();
634  sum = 0.;
635  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
636  snprintf(buff, sizeof(buff), "REGTEST %s SUM of contentsPixelClusEndcapC() = %10.2f ", s.c_str(), sum );
638 
639  getVec = SpacePointCountsCont->at(i)->contentsPixelClusBarrel();
640  sum = 0.;
641  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
642  snprintf(buff, sizeof(buff), "REGTEST %s SUM of contentsPixelClusBarrel() = %10.2f ", s.c_str(), sum );
644 
645  getVec = SpacePointCountsCont->at(i)->contentsPixelClusEndcapA();
646  sum = 0.;
647  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
648  snprintf(buff, sizeof(buff), "REGTEST %s SUM of contentsPixelClusEndcapA() = %10.2f ", s.c_str(), sum );
650 
651  snprintf(buff, sizeof(buff), "REGTEST %s pixelClusTotBins() = %u ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusTotBins() );
653 
654  snprintf(buff, sizeof(buff), "REGTEST %s pixelClusTotMin() = %10.2f ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusTotMin() );
656 
657  snprintf(buff, sizeof(buff), "REGTEST %s pixelClusTotMax() = %10.2f ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusTotMax() );
659 
660  snprintf(buff, sizeof(buff), "REGTEST %s pixelClusSizeBins() = %u ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusSizeBins() );
662 
663  snprintf(buff, sizeof(buff), "REGTEST %s pixelClusSizeMin() = %10.2f ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusSizeMin() );
665 
666  snprintf(buff, sizeof(buff), "REGTEST %s pixelClusSizeMax() = %10.2f ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusSizeMax() );
668 
669  snprintf(buff, sizeof(buff), "REGTEST %s sctSpEndcapC() = %u ", s.c_str(), SpacePointCountsCont->at(i)->sctSpEndcapC() );
671 
672  snprintf(buff, sizeof(buff), "REGTEST %s sctSpBarrel() = %u ", s.c_str(), SpacePointCountsCont->at(i)->sctSpBarrel() );
674 
675  snprintf(buff, sizeof(buff), "REGTEST %s sctSpEndcapA() = %u ", s.c_str(), SpacePointCountsCont->at(i)->sctSpEndcapA() );
677  }
678  }
679 }
680 
682  ATH_MSG_INFO("MinBias in dumpTrigT2MBTSBits()");
683 
684  std::string METTag="HLT_xAOD__TrigT2MbtsBitsContainer_T2Mbts";
685 
686  const xAOD::TrigT2MbtsBitsContainer* T2MbtsBitsCont=0;
687  StatusCode sc = evtStore()->retrieve(T2MbtsBitsCont,METTag);
688 
689  if (sc.isFailure())
690  ATH_MSG_INFO("failed to retrieve " << METTag);
691  else {
692  ATH_MSG_INFO("Accessing " << METTag << " with " << T2MbtsBitsCont->size() << " elements");
693 
694  std::string s; char buff[380];
695  std::vector<float> getVec;
696  float sum;
697 
698  // Loop over container content
699  for(uint i = 0; i < T2MbtsBitsCont->size(); i++) {
700  getVec = T2MbtsBitsCont->at(i)->triggerEnergies();
701  sum = 0.;
702  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
703  snprintf(buff, sizeof(buff), "REGTEST %s SUM of triggerEnergies() = %10.2f ", s.c_str(), sum );
705 
706  getVec = T2MbtsBitsCont->at(i)->triggerTimes();
707  sum = 0.;
708  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
709  snprintf(buff, sizeof(buff), "REGTEST %s SUM of triggerTimes() = %10.2f ", s.c_str(), sum );
711  }
712  }
713 }
714 
716  ATH_MSG_INFO("MinBias in dumpTrigVertexCounts()");
717 
718  std::string METTag="HLT_xAOD__TrigVertexCountsContainer_vertexcounts";
719 
720  const xAOD::TrigVertexCountsContainer* T2VertexCountsCont=0;
721  StatusCode sc = evtStore()->retrieve(T2VertexCountsCont,METTag);
722 
723  if (sc.isFailure())
724  ATH_MSG_INFO("failed to retrieve " << METTag);
725  else {
726  ATH_MSG_INFO("Accessing " << METTag << " with " << T2VertexCountsCont->size() << " elements");
727 
728  std::string s; char buff[380];
729  std::vector<float> fgetVec;
730  float fsum(0.);
731  std::vector<unsigned int> ugetVec;
732  unsigned int usum(0);
733 
734  // Loop over container content
735  for(uint i = 0; i < T2VertexCountsCont->size(); i++) {
736  ugetVec = T2VertexCountsCont->at(i)->vtxNtrks();
737  for (uint j = 0; j < ugetVec.size(); ++j) usum += ugetVec[j];
738  snprintf(buff, sizeof(buff), "REGTEST %s SUM of vtxNtrks() = %u ", s.c_str(), usum );
740 
741  fgetVec = T2VertexCountsCont->at(i)->vtxTrkPtSqSum();
742  for (uint j = 0; j < fgetVec.size(); ++j) fsum += fgetVec[j];
743  snprintf(buff, sizeof(buff), "REGTEST %s SUM of vtxTrkPtSqSum() = %10.2f ", s.c_str(), fsum );
745  }
746  }
747 }
748 
750  ATH_MSG_INFO("MinBias in dumpTrigTrackCounts()");
751 
752  std::string METTag="HLT_xAOD__TrigTrackCountsContainer_trackcounts";
753 
754  const xAOD::TrigTrackCountsContainer* T2TrackCountsCont=0;
755  StatusCode sc = evtStore()->retrieve(T2TrackCountsCont,METTag);
756 
757  if (sc.isFailure())
758  ATH_MSG_INFO("failed to retrieve " << METTag);
759  else {
760  ATH_MSG_INFO("Accessing " << METTag << " with " << T2TrackCountsCont->size() << " elements");
761 
762  std::string s; char buff[380];
763  std::vector<float> getVec;
764  float sum;
765 
766  // Loop over container content
767  for(uint i = 0; i < T2TrackCountsCont->size(); i++) {
768  getVec = T2TrackCountsCont->at(i)->z0_pt();
769  sum = 0.;
770  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
771  snprintf(buff, sizeof(buff), "REGTEST %s SUM of z0_pt = %10.2f ", s.c_str(), sum );
773 
774  getVec = T2TrackCountsCont->at(i)->eta_phi();
775  sum = 0.;
776  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
777  snprintf(buff, sizeof(buff), "REGTEST %s SUM of eta_phi() = %10.2f ", s.c_str(), sum );
779 
780  snprintf(buff, sizeof(buff), "REGTEST %s z0Bins() = %u ", s.c_str(), T2TrackCountsCont->at(i)->z0Bins() );
782 
783  snprintf(buff, sizeof(buff), "REGTEST %s z0Min() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->z0Min() );
785 
786  snprintf(buff, sizeof(buff), "REGTEST %s z0Max() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->z0Max() );
788 
789  snprintf(buff, sizeof(buff), "REGTEST %s ptBins() = %u ", s.c_str(), T2TrackCountsCont->at(i)->ptBins() );
791 
792  snprintf(buff, sizeof(buff), "REGTEST %s ptMin() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->ptMin() );
794 
795  snprintf(buff, sizeof(buff), "REGTEST %s ptMax() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->ptMax() );
797 
798  snprintf(buff, sizeof(buff), "REGTEST %s etaBins() = %u ", s.c_str(), T2TrackCountsCont->at(i)->etaBins() );
800 
801  snprintf(buff, sizeof(buff), "REGTEST %s etaMin() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->etaMin() );
803 
804  snprintf(buff, sizeof(buff), "REGTEST %s etaMax() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->etaMax() );
806 
807  snprintf(buff, sizeof(buff), "REGTEST %s phiBins() = %u ", s.c_str(), T2TrackCountsCont->at(i)->phiBins() );
809 
810  snprintf(buff, sizeof(buff), "REGTEST %s phiMin() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->phiMin() );
812 
813  snprintf(buff, sizeof(buff), "REGTEST %s phiMax() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->phiMax() );
815  }
816  }
817 }
818 
820 
825 
826  return StatusCode::SUCCESS;
827 }
828 
830 
831 
832 
834 
835  ATH_MSG_INFO("dumpxAODTrigMissingET()");
836 
837  int ntag=4;
838  std::string METTags[]={"HLT_xAOD__TrigMissingETContainer_EFJetEtSum","HLT_xAOD__TrigMissingETContainer_TrigEFMissingET", "HLT_xAOD__TrigMissingETContainer_TrigL2MissingET_FEB","HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_topocl"};
839 
840  for(int itag=0; itag <ntag; itag++) {
841 
842  const xAOD::TrigMissingETContainer* MissingETCont=0;
843  StatusCode sc = evtStore()->retrieve(MissingETCont,METTags[itag]);
844  if (sc.isFailure())
845  ATH_MSG_INFO("failed to retrieve " << METTags[itag]);
846  else {
847  ATH_MSG_INFO("Accessing " << METTags[itag] << " with " << MissingETCont->size() << " elements");
848 
849  // Loop over container content
850  for(uint i = 0; i < MissingETCont->size(); i++) {
851 
852  std::string s; char buff[3000];
853 
854  snprintf(buff, sizeof(buff), "REGTEST %s Ex = %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->ex() );
856  snprintf(buff, sizeof(buff), "REGTEST %s Ey = %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->ey() );
858  snprintf(buff, sizeof(buff), "REGTEST %s Ez = %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->ez() );
860  snprintf(buff, sizeof(buff), "REGTEST %s SumET = %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->sumEt() );
862  snprintf(buff, sizeof(buff), "REGTEST %s SumE = %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->sumE() );
864  snprintf(buff, sizeof(buff), "REGTEST %s Flag = %d", s.c_str(), MissingETCont->at(i)->flag() );
866  snprintf(buff, sizeof(buff), "REGTEST %s Flag = %d", s.c_str(), MissingETCont->at(i)->roiWord() );
868 
869  unsigned int Nc = MissingETCont->at(i)->getNumberOfComponents();
870  if (Nc > 0) {
871  s="REGTEST __name____status_usedChannels__sumOfSigns__calib1_calib0";
872  s+="/MeV__ex/MeV_____ey/MeV_____ez/MeV___sumE/MeV__sumEt/CLHEP::MeV";
873  ATH_MSG_INFO(s);
874  }
875 
876  for(uint j = 0; j < Nc; j++) {
877 
878  std::string name = MissingETCont->at(i)->nameOfComponent(j);
879  const short status = MissingETCont->at(i)->statusComponent(j);
880  const unsigned short usedChan = MissingETCont->at(i)->usedChannelsComponent(j);
881  const short sumOfSigns = MissingETCont->at(i)->sumOfSignsComponent(j);
882  const float calib0 = MissingETCont->at(i)->calib0Component(j);
883  const float calib1 = MissingETCont->at(i)->calib1Component(j);
884  const float ex = MissingETCont->at(i)->exComponent(j);
885  const float ey = MissingETCont->at(i)->eyComponent(j);
886  const float ez = MissingETCont->at(i)->ezComponent(j);
887  const float sumE = MissingETCont->at(i)->sumEComponent(j);
888  const float sumEt = MissingETCont->at(i)->sumEtComponent(j);
889 
890  snprintf(buff, sizeof(buff),
891  "REGTEST %s %6d %12d %10d %6.2f %6.3f %10.2f %10.2f %10.2f %10.2f %10.2f",
892  name.c_str(), status, usedChan, sumOfSigns, calib1, calib0,
893  ex, ey, ez, sumE, sumEt);
894  ATH_MSG_INFO(buff);
895  }
896  }
897  }
898  }
899 
900  return StatusCode::SUCCESS;
901 }
902 
904 
905 
906 
907 StatusCode TrigEDMChecker::dumpTrigMissingET ATLAS_NOT_THREAD_SAFE() {
908 
909  ATH_MSG_DEBUG("in dumpTrigMissingET()");
910 
911  int ntag=3;
912  std::string METTags[]={"HLT_TrigMissingETContainer_TrigEFMissingET", "HLT_TrigMissingETContainer_TrigEFMissingET_FEB", "HLT_TrigMissingETContainer_TrigEFMissingET_topocl"};
913 
915  for (int itag=0; itag < ntag; itag++) { // loop over L2, EF
916  const TrigMissingETContainer* trigMETcont;
917  StatusCode sc=evtStore()->retrieve(trigMETcont , METTags[itag]);
918  if( sc.isFailure() ){
919  ATH_MSG_INFO("Failed to retrieve TrigMissingETContainer with key " << METTags[itag]);
920  continue;
921  }
922 
923  ATH_MSG_INFO("Got TrigMissingETContainer with key \"" << METTags[itag]<< "\"");
924 
925  TrigMissingETContainer::const_iterator trigMETfirst = trigMETcont->begin();
926  TrigMissingETContainer::const_iterator trigMETlast = trigMETcont->end();
927 
928  for (int j=0; trigMETfirst != trigMETlast; ++trigMETfirst++, ++j ) {
929 
930  ATH_MSG_INFO("REGTEST ==========START of TrigMissingET DUMP===========");
931 
932  std::string s;
933  char buff[128];
934 
935  snprintf(buff, sizeof(buff), "REGTEST %s Ex = %10.2f CLHEP::MeV", s.c_str(), (*trigMETfirst)->ex() );
937  snprintf(buff, sizeof(buff), "REGTEST %s Ey = %10.2f CLHEP::MeV", s.c_str(), (*trigMETfirst)->ey() );
939  snprintf(buff, sizeof(buff), "REGTEST %s Ez = %10.2f CLHEP::MeV", s.c_str(), (*trigMETfirst)->ez() );
941  snprintf(buff, sizeof(buff), "REGTEST %s Et = %10.2f CLHEP::MeV", s.c_str(), (*trigMETfirst)->et() );
943  snprintf(buff, sizeof(buff), "REGTEST %s SumEt = %10.2f CLHEP::MeV", s.c_str(), (*trigMETfirst)->sumEt() );
945  snprintf(buff, sizeof(buff), "REGTEST %s SumE = %10.2f CLHEP::MeV", s.c_str(), (*trigMETfirst)->sumE() );
947  snprintf(buff, sizeof(buff), "REGTEST %s E = %10.2f CLHEP::MeV", s.c_str(), (*trigMETfirst)->e() );
949  snprintf(buff, sizeof(buff), "REGTEST %s flag = %10d", s.c_str(), (*trigMETfirst)->getFlag() );
951  snprintf(buff, sizeof(buff), "REGTEST %s RoIword = %10ld", s.c_str(), (*trigMETfirst)->RoIword() );
953 
954  unsigned int Nc = (*trigMETfirst)->getNumOfComponents();
955  if (Nc > 0) {
956  s="REGTEST __name____status_usedChannels__sumOfSigns__calib1_calib0";
957  s+="/MeV__ex/MeV_____ey/MeV_____ez/MeV___sumE/MeV__sumEt/CLHEP::MeV";
958  ATH_MSG_INFO(s);
959 
960  for (unsigned int i=0; i<Nc; ++i) { // loop over components
961  std::string name = (*trigMETfirst)->getNameOfComponent(i);
962  const short status = (*trigMETfirst)->getStatus(i);
963  const unsigned short usedChan = (*trigMETfirst)->getUsedChannels(i);
964  const short sumOfSigns = (*trigMETfirst)->getSumOfSigns(i);
965  const float calib0 = (*trigMETfirst)->getComponentCalib0(i);
966  const float calib1 = (*trigMETfirst)->getComponentCalib1(i);
967  const float ex = (*trigMETfirst)->getExComponent(i);
968  const float ey = (*trigMETfirst)->getEyComponent(i);
969  const float ez = (*trigMETfirst)->getEzComponent(i);
970  const float sumE = (*trigMETfirst)->getSumEComponent(i);
971  const float sumEt = (*trigMETfirst)->getSumEtComponent(i);
972 
973  snprintf(buff, sizeof(buff),
974  "REGTEST %s %6d %12d %10d %6.2f %6.3f %10.2f %10.2f %10.2f %10.2f %10.2f",
975  name.c_str(), status, usedChan, sumOfSigns, calib1, calib0,
976  ex, ey, ez, sumE, sumEt);
978  } // loop over components
979  }
980  } // loop over TrigMissingET objects
981  } // loop over TrigMissingETContainers
982 
983  // if( sc.isSuccess() ) return sc; // Commented out by FB (12.07.14)
984 
986  ATH_MSG_INFO("Trying to fetch TrigMissingET objects from older releases");
987 
988  SG::ConstIterator<TrigMissingET> trigMETfirst ,trigMETlast;
989  StatusCode sc=evtStore()->retrieve(trigMETfirst ,trigMETlast);
990  if( sc.isFailure() ){
991  ATH_MSG_INFO("Failed to retrieve TrigMissingET (rel. <= 14.2.0)");
992  }
993 
994  for( ; trigMETfirst != trigMETlast ; ++trigMETfirst ){ // loop over TrigMissingET objects
995  const std::string& name(trigMETfirst.key());
996  ATH_MSG_INFO("Got TrigMissingET object with key \"" << name << "\"");
997 
998  std::string s;
999  char buff[3000];
1000 
1001  if( name.find("TrigEFMissingET") != std::string::npos ) {
1002  s="REGTEST EF: ";
1003  } else if( name.find("T2MissingET") != std::string::npos ){
1004  s="REGTEST L2: ";
1005  } else {
1006  ATH_MSG_WARNING(" This is UNKNOWN! " << name);
1007  s="REGTEST ??? ";
1008  }
1009 
1010  snprintf(buff, sizeof(buff), "%s Ex = %10.2f CLHEP::MeV", s.c_str(), trigMETfirst->ex() );
1011  ATH_MSG_INFO(buff);
1012  snprintf(buff, sizeof(buff), "%s Ey = %10.2f CLHEP::MeV", s.c_str(), trigMETfirst->ey() );
1013  ATH_MSG_INFO(buff);
1014  snprintf(buff, sizeof(buff), "%s Ez = %10.2f CLHEP::MeV", s.c_str(), trigMETfirst->ez() );
1015  ATH_MSG_INFO(buff);
1016  snprintf(buff, sizeof(buff), "%s Et = %10.2f CLHEP::MeV", s.c_str(), trigMETfirst->et() );
1017  ATH_MSG_INFO(buff);
1018  snprintf(buff, sizeof(buff), "%s SumE = %10.2f CLHEP::MeV", s.c_str(), trigMETfirst->sumE() );
1019  ATH_MSG_INFO(buff);
1020  snprintf(buff, sizeof(buff), "%s SumEt = %10.2f CLHEP::MeV", s.c_str(), trigMETfirst->sumEt() );
1021  ATH_MSG_INFO(buff);
1022  snprintf(buff, sizeof(buff), "%s E = %10.2f CLHEP::MeV", s.c_str(), trigMETfirst->e() );
1023  ATH_MSG_INFO(buff);
1024  snprintf(buff, sizeof(buff), "%s flag = %10d", s.c_str(), trigMETfirst->getFlag() );
1025  ATH_MSG_INFO(buff);
1026  snprintf(buff, sizeof(buff), "%s RoIword = %10ld", s.c_str(), trigMETfirst->RoIword() );
1027  ATH_MSG_INFO(buff);
1028 
1029  unsigned int Nc = trigMETfirst->getNumOfComponents();
1030  if (Nc > 0) {
1031  s="REGTEST __name____status_usedChannels__sumOfSigns__calib1_calib0";
1032  s+="/MeV__ex/MeV_____ey/MeV_____ez/MeV___sumE/MeV__sumEt/CLHEP::MeV";
1033  ATH_MSG_INFO(s);
1034 
1035  for (unsigned int i=0; i<Nc; ++i) { // loop over components
1036  std::string name = trigMETfirst->getNameOfComponent(i);
1037  const short status = trigMETfirst->getStatus(i);
1038  const unsigned short usedChan = trigMETfirst->getUsedChannels(i);
1039  const short sumOfSigns = trigMETfirst->getSumOfSigns(i);
1040  const float calib0 = trigMETfirst->getComponentCalib0(i);
1041  const float calib1 = trigMETfirst->getComponentCalib1(i);
1042  const float ex = trigMETfirst->getExComponent(i);
1043  const float ey = trigMETfirst->getEyComponent(i);
1044  const float ez = trigMETfirst->getEzComponent(i);
1045  const float sumE = trigMETfirst->getSumEComponent(i);
1046  const float sumEt = trigMETfirst->getSumEtComponent(i);
1047 
1048  snprintf(buff, sizeof(buff),
1049  "REGTEST %s %6d %12d %10d %6.2f %6.3f %10.2f %10.2f %10.2f %10.2f %10.2f",
1050  name.c_str(), status, usedChan, sumOfSigns, calib1, calib0,
1051  ex, ey, ez, sumE, sumEt);
1052  ATH_MSG_INFO(buff);
1053  } // loop over components
1054  }
1055  } // loop over TrigMissingET objects
1056 
1057  ATH_MSG_INFO("REGTEST ==========END of TrigMissingET DUMP===========");
1058 
1059  return StatusCode::SUCCESS;
1060 }
1061 
1063 
1065 
1066  ATH_MSG_DEBUG("in dumpTrackParticleContainer()");
1067 
1068  ATH_MSG_INFO("REGTEST ==========START of TrackParticleContainer DUMP===========");
1069 
1070  std::string trackPtags[]={"HLT_InDetTrigParticleCreation_Bjet_EFID",
1071  "HLT_InDetTrigParticleCreation_Bphysics_EFID",
1072  "HLT_InDetTrigParticleCreation_Electron_EFID",
1073  "HLT_InDetTrigParticleCreation_FullScan_EFID",
1074  "HLT_InDetTrigParticleCreation_Muon_EFID",
1075  "HLT_InDetTrigParticleCreation_Photon_EFID",
1076  "HLT_InDetTrigParticleCreation_Tau_EFID"};
1077 
1078  int ntag=7;
1079 
1080  StatusCode returnsc=StatusCode::SUCCESS;
1081 
1082  for (int itag=0; itag<ntag; itag++){
1083  const Rec::TrackParticleContainer* pTrackParticleC = nullptr;
1084  StatusCode sc = evtStore()->retrieve(pTrackParticleC, trackPtags[itag]);
1085  if (sc.isFailure()) {
1086  ATH_MSG_INFO("REGTEST No TrackParticleContainer found with tag " << trackPtags[itag]);
1087  continue;
1088  }
1089  ATH_MSG_INFO("TrackParticleContainer found with tag " << trackPtags[itag]
1090  << " and size " << pTrackParticleC->size());
1091 
1092  Rec::TrackParticleContainer::const_iterator trackItr = pTrackParticleC->begin();
1093  Rec::TrackParticleContainer::const_iterator trackItrE = pTrackParticleC->end();
1094  for (int ind=1; trackItr != trackItrE; ++trackItr, ind++) {
1095  const Rec::TrackParticle * trackParticle = (*trackItr);
1096  ATH_MSG_INFO(" TrackParticle " << ind << " charge "
1097  << trackParticle->charge() << " p "
1098  << trackParticle->p()<< " eta " << trackParticle->eta()
1099  << " phi " << trackParticle->phi());
1100 
1102  const Trk::Track * track = trackParticle->originalTrack();
1103  if ( track ) {
1104  ATH_MSG_INFO(" Got attached track");
1105  const Trk::TrackParameters* perigee = track->perigeeParameters();
1106  if (perigee) {
1107  const auto& parameterVector = perigee->parameters();
1108  ATH_MSG_INFO(" q/P " << parameterVector[Trk::qOverP] <<
1109  " theta " << parameterVector[Trk::theta] <<
1110  " phi " <<parameterVector[Trk::phi]);
1111  } else {
1112  ATH_MSG_INFO(" No perigee attached to track");
1113  }
1114 
1115  } else {
1116  if( m_trackWarningNum <= maxRepWarnings ) {
1117  ATH_MSG_DEBUG(" No attached track");
1118  if( m_trackWarningNum == maxRepWarnings) {
1119  ATH_MSG_WARNING(" Max attached track warning reached, no further warnings given");
1120  }
1122  }
1123  }
1124 
1126  const Trk::VxCandidate * vertex = trackParticle->reconstructedVertex();
1127  if ( vertex ) {
1128  const Trk::RecVertex& vtx = vertex->recVertex();
1129  const Amg::Vector3D& position = vtx.position();
1130  ATH_MSG_INFO(" vertex position (" << position[0] << ", " <<
1131  position[1] << ", " << position[2] << ") ");
1132  } else {
1133  if( m_vertexWarningNum <= maxRepWarnings ) {
1134  ATH_MSG_DEBUG(" No attached vertex");
1135  if( m_vertexWarningNum == maxRepWarnings) {
1136  ATH_MSG_WARNING(" Max attached vertex warning reached, no further warnings given");
1137  }
1139  }
1140  }
1141 
1142  const Trk::Perigee* perigee = trackParticle->measuredPerigee();
1143  if (perigee) {
1144  const auto& parameters = perigee->parameters();
1145  ATH_MSG_INFO("Trk::Perigee parameters:");
1146  ATH_MSG_INFO(" * d_0 : "<< parameters[Trk::d0] );
1147  ATH_MSG_INFO(" * z_0 : "<< parameters[Trk::z0] );
1148  ATH_MSG_INFO(" * phi : "<< parameters[Trk::phi] );
1149  ATH_MSG_INFO(" * Theta : "<< parameters[Trk::theta] );
1150  ATH_MSG_INFO(" * q/p : "<< parameters[Trk::qOverP] );
1151  } else {
1152  ATH_MSG_WARNING(" No attached perigee");
1153  }
1155  const Trk::TrackSummary* summary = trackParticle->trackSummary();
1156  if (summary) {
1157  ATH_MSG_DEBUG("Track summary information:");
1158  ATH_MSG_DEBUG(" * Number of B layer hits : "<<summary->get(Trk::numberOfBLayerHits));
1159  ATH_MSG_DEBUG(" * Number of pixel hits : "<<summary->get(Trk::numberOfPixelHits));
1160  ATH_MSG_DEBUG(" * Number of SCT hits : "<<summary->get(Trk::numberOfSCTHits));
1161  ATH_MSG_DEBUG(" * Number of TRT hits : "<<summary->get(Trk::numberOfTRTHits));
1162  }
1163  }
1164  }
1165  return returnsc;
1166 }
1167 
1168 
1170 
1172 
1173  ATH_MSG_DEBUG("in dumpLVL1_ROI()");
1174 
1175  ATH_MSG_INFO("REGTEST ==========START of LVL1_ROI DUMP===========");
1176 
1177  const LVL1_ROI * lvl1ROI;
1178  StatusCode sc = evtStore()->retrieve(lvl1ROI);
1179  if (sc.isFailure() ) {
1180  ATH_MSG_INFO("REGTEST No LVL1_ROI found");
1181  return StatusCode::SUCCESS;
1182  }
1183 
1184  ATH_MSG_INFO("REGTEST LVL1_ROI retrieved");
1185 
1186  LVL1_ROI::emtaus_type::const_iterator itEMTau =
1187  (lvl1ROI->getEmTauROIs()).begin();
1188  LVL1_ROI::emtaus_type::const_iterator itEMTau_e =
1189  (lvl1ROI->getEmTauROIs()).end();
1190  int j = 0;
1191  for( ; itEMTau != itEMTau_e; ++itEMTau, ++j) {
1192  ATH_MSG_INFO("REGTEST Looking at LVL1_ROI " << j);
1193  ATH_MSG_INFO("REGTEST LVL1 EmTauROI Eta is " << itEMTau->getEta());
1194  ATH_MSG_INFO("REGTEST LVL1 EmTauROI Phi is " << itEMTau->getPhi());
1195  ATH_MSG_INFO("REGTEST LVL1 EmTauROI EMClus is " << itEMTau->getEMClus());
1196  ATH_MSG_INFO("REGTEST LVL1 EmTauROI TauClus is " << itEMTau->getTauClus());
1197  ATH_MSG_INFO("REGTEST LVL1 EmTauROI EMIsol is " << itEMTau->getEMIsol());
1198  ATH_MSG_INFO("REGTEST LVL1 EmTauROI HadIsol is " << itEMTau->getHadIsol());
1199  ATH_MSG_INFO("REGTEST LVL1 EmTauROI Core is " << itEMTau->getCore());
1200  ATH_MSG_INFO("REGTEST LVL1 EmTauROI HadCore is " << itEMTau->getHadCore());
1201  ATH_MSG_INFO("REGTEST LVL1 EmTauROI roiWord is " << itEMTau->getROIWord());
1202  }
1203 
1204  ATH_MSG_INFO("REGTEST ==========END of LVL1_ROI DUMP===========");
1205  ATH_MSG_DEBUG("dumpLVL1_ROI() succeeded");
1206  return StatusCode::SUCCESS;
1207 }
1208 
1209 
1211 
1212 StatusCode TrigEDMChecker::dumpTrigPhotonContainer ATLAS_NOT_THREAD_SAFE() {
1213 
1214  ATH_MSG_DEBUG("in dumpTrigPhotonContainer()");
1215 
1216  ATH_MSG_INFO("REGTEST ==========START of TrigPhotonContainer DUMP===========");
1217 
1220 
1221  StatusCode sc = evtStore()->retrieve(trigPhoton,lastTrigPhoton);
1222  if (sc.isFailure()) {
1223  ATH_MSG_INFO("REGTEST No TrigPhotonContainer found");
1224  return StatusCode::SUCCESS;
1225  }
1226  ATH_MSG_INFO("REGTEST TrigPhotonContainers retrieved");
1227 
1228 
1229  for (int i=0; trigPhoton != lastTrigPhoton; ++trigPhoton, ++i) {
1230 
1231  ATH_MSG_INFO("REGTEST Looking at TrigPhotonContainer " << i);
1232 
1233  TrigPhotonContainer::const_iterator PhotonItr = trigPhoton->begin();
1234  TrigPhotonContainer::const_iterator PhotonItrE = trigPhoton->end();
1235 
1236  for (int j=0; PhotonItr != PhotonItrE; ++PhotonItr, ++j ) {
1237 
1238  ATH_MSG_INFO("REGTEST Looking at TrigPhoton " << j);
1239 
1240  ATH_MSG_INFO("REGTEST TrigPhoton->dPhi() returns " << (*PhotonItr)->dPhi());
1241  ATH_MSG_INFO("REGTEST TrigPhoton->dEta() returns " << (*PhotonItr)->dEta());
1242  ATH_MSG_INFO("REGTEST TrigPhoton->rCore() returns " << (*PhotonItr)->rCore());
1243  ATH_MSG_INFO("REGTEST TrigPhoton->isValid() returns " << (*PhotonItr)->isValid());
1244  ATH_MSG_INFO("REGTEST TrigPhoton->Et() returns " << (*PhotonItr)->Et());
1245 
1246  if ( (*PhotonItr)->cluster() != NULL ) {
1247  ATH_MSG_INFO("REGTEST Cluster info: ");
1248  ATH_MSG_INFO("REGTEST cluster->e() returns " << (*PhotonItr)->cluster()->e());
1249  ATH_MSG_INFO("REGTEST cluster->e237() returns " << (*PhotonItr)->cluster()->e237());
1250  ATH_MSG_INFO("REGTEST cluster->e277() returns " << (*PhotonItr)->cluster()->e277());
1251  ATH_MSG_INFO("REGTEST cluster->fracs1() returns " << (*PhotonItr)->cluster()->fracs1());
1252  ATH_MSG_INFO("REGTEST cluster->weta2() returns " << (*PhotonItr)->cluster()->weta2());
1253  ATH_MSG_INFO("REGTEST cluster->ehad() returns " << (*PhotonItr)->cluster()->ehad1());
1254  ATH_MSG_INFO("REGTEST cluster->emaxs1() returns " << (*PhotonItr)->cluster()->emaxs1());
1255 
1256  ATH_MSG_INFO("REGTEST Looking at P4PtEtaPhiM " << j);
1257 
1258  ATH_MSG_INFO("REGTEST P4PtEtaPhiM->Pt() returns " << (*PhotonItr)->pt());
1259  ATH_MSG_INFO("REGTEST P4PtEtaPhiM->Eta() returns " << (*PhotonItr)->eta());
1260  ATH_MSG_INFO("REGTEST P4PtEtaPhiM->Phi() returns " << (*PhotonItr)->phi());
1261  ATH_MSG_INFO("REGTEST P4PtEtaPhiM->m() returns " << (*PhotonItr)->m());
1262  }
1263 
1264  // printout variables using the new << operator
1265  ATH_MSG_INFO("TrigPhoton printout:");
1266  ATH_MSG_INFO("REGTEST " << (**PhotonItr));
1267 
1268  // do second loop to compare TrigPhotons using comparison operators
1269  TrigPhotonContainer::const_iterator PhotonItr2 = PhotonItr;
1270  TrigPhotonContainer::const_iterator PhotonItr2E = trigPhoton->end();
1271 
1272  for (int k=0; PhotonItr2 != PhotonItr2E; ++PhotonItr2, ++k ) {
1273  // find if TrigPhotons are the same (i.e. have same cluster and track
1274  if ( (**PhotonItr) == (**PhotonItr2) ) {
1275  ATH_MSG_INFO("REGTEST TrigPhoton nr. " << j << " is the same as TrigPhoton nr. " << k);
1276  } else {
1277  // TrigPhotons are different, print out differences
1278  std::map<std::string, double> v_diff;
1279  diff(*(*PhotonItr),*(*PhotonItr2), v_diff);
1281  ATH_MSG_INFO("TrigPhoton " << k << " different form TrigPhoton " << j << " :");
1282  for (int m=0;it !=v_diff.end();++it, ++m) {
1283  ATH_MSG_INFO("TrigPhoton Delta_" << (*it).first << " = " << (*it).second);
1284  }
1285  }
1286  }
1287  }
1288  }
1289 
1290  ATH_MSG_INFO("REGTEST ==========END of TrigPhotonContainer DUMP===========");
1291  ATH_MSG_DEBUG("dumpTrigPhotonContainer() succeeded");
1292 
1293  return StatusCode::SUCCESS;
1294 }
1295 
1296 
1298 
1299 StatusCode TrigEDMChecker::dumpTrigMuonEFContainer ATLAS_NOT_THREAD_SAFE() {
1300 
1301  ATH_MSG_DEBUG("in dumpTrigMuonEFContainer()");
1302 
1303  ATH_MSG_INFO("REGTEST ==========START of TrigMuonEFContainer DUMP===========");
1304 
1307 
1308  StatusCode sc = evtStore()->retrieve(trigMuon,lastTrigMuon);
1309  if (sc.isFailure()) {
1310  ATH_MSG_INFO("REGTEST No TrigMuonEFContainer found");
1311  return StatusCode::SUCCESS;
1312  }
1313  ATH_MSG_INFO("REGTEST TrigMuonEFContainers retrieved");
1314 
1315  for (int i=0; trigMuon != lastTrigMuon; ++trigMuon, ++i) {
1316 
1317  ATH_MSG_INFO("REGTEST Looking at TrigMuonEFContainer " << i);
1318 
1319  TrigMuonEFContainer::const_iterator MuonItr = trigMuon->begin();
1320  TrigMuonEFContainer::const_iterator MuonItrE = trigMuon->end();
1321 
1322  for (int j=0; MuonItr != MuonItrE; ++MuonItr, ++j ) {
1323 
1324  ATH_MSG_INFO("REGTEST Looking at TrigMuonEF " << j);
1325 
1326  ATH_MSG_INFO("REGTEST TrigMuonEF->muonCode() returns " << (*MuonItr)->MuonCode());
1327  ATH_MSG_INFO("REGTEST TrigMuonEF->roi() returns " << (*MuonItr)->RoINum());
1328  ATH_MSG_INFO("REGTEST TrigMuonEF->charge() returns " << (*MuonItr)->Charge());
1329 
1330  ATH_MSG_INFO("REGTEST Looking at P4IPtCotThPhiM " << j);
1331 
1332  ATH_MSG_INFO("REGTEST P4IPtCotThPhiM->iPt() returns " << (*MuonItr)->iPt());
1333  ATH_MSG_INFO("REGTEST P4IPtCotThPhiM->CotTh() returns " << (*MuonItr)->cotTh());
1334  ATH_MSG_INFO("REGTEST P4IPtCotThPhiM->Phi() returns " << (*MuonItr)->phi());
1335  ATH_MSG_INFO("REGTEST P4IPtCotThPhiM->m() returns " << (*MuonItr)->m());
1336  }
1337  }
1338 
1339  ATH_MSG_INFO("REGTEST ==========END of TrigMuonEFContainer DUMP===========");
1340  ATH_MSG_DEBUG("dumpTrigMuonEFContainer() succeeded");
1341 
1342  return StatusCode::SUCCESS;
1343 }
1344 
1346 
1347  ATH_MSG_DEBUG("In dumpxAODMuonContainer");
1348 
1349  ATH_MSG_INFO( "REGTEST ==========START of xAOD::MuonContainer DUMP===========" );
1350 
1351  const xAOD::MuonContainer* muonCont=0;
1352  StatusCode sc = evtStore()->retrieve(muonCont,"HLT_xAOD__MuonContainer_MuonEFInfo");
1353  if (sc.isFailure()) {
1354  ATH_MSG_INFO("REGTEST No muon container HLT_xAOD__MuonContainer_MuonEFInfo");
1355  return StatusCode::SUCCESS;
1356  }
1357 
1358  std::string output = m_muonPrinter->print( *muonCont );
1359  msg(MSG::INFO) << output << endmsg;
1360 
1361  ATH_MSG_INFO( "REGTEST ==========END of xAOD::MuonContainer DUMP===========" );
1362 
1363  return StatusCode::SUCCESS;
1364 
1365 }
1366 
1368 
1369 StatusCode TrigEDMChecker::dumpTrigMuonEFInfoContainer ATLAS_NOT_THREAD_SAFE() {
1370 
1371  ATH_MSG_DEBUG("in dumpTrigMuonEFInfoContainer()");
1372 
1373  ATH_MSG_INFO("REGTEST ==========START of TrigMuonEFInfoContainer DUMP===========");
1374 
1377 
1378  StatusCode sc = evtStore()->retrieve(trigMuon,lastTrigMuon);
1379  if (sc.isFailure()) {
1380  ATH_MSG_INFO("REGTEST No TrigMuonEFInfoContainer found");
1381  return StatusCode::SUCCESS;
1382  }
1383  ATH_MSG_INFO("REGTEST TrigMuonEFInfoContainers retrieved");
1384 
1385 
1386  for (int i=0; trigMuon != lastTrigMuon; ++trigMuon, ++i) {
1387 
1388  ATH_MSG_INFO("REGTEST -+-+-+-+ Looking at TrigMuonEFInfoContainer " << i);
1389 
1390  TrigMuonEFInfoContainer::const_iterator MuonItr = trigMuon->begin();
1391  TrigMuonEFInfoContainer::const_iterator MuonItrE = trigMuon->end();
1392 
1393  for (int j=0; MuonItr != MuonItrE; ++MuonItr, ++j ) {
1394 
1395  ATH_MSG_INFO("REGTEST Looking at TrigMuonEFInfo " << j);
1396 
1397  const TrigMuonEFInfo* muonInfo = (*MuonItr);
1398 
1399  ATH_MSG_INFO("REGTEST Test self equality ");
1400  if (*muonInfo == *muonInfo) {
1401  ATH_MSG_INFO("REGTEST passed ");
1402  }
1403  else {
1404  ATH_MSG_INFO("REGTEST failed ");
1405  }
1406 
1407 
1408  if (muonInfo->hasTrack()) {
1409  ATH_MSG_INFO("REGTEST Test new version ");
1410 
1411  ATH_MSG_INFO("REGTEST hasTracks()=true ");
1412  const TrigMuonEFInfoTrackContainer *tc = muonInfo->TrackContainer();
1413  ATH_MSG_INFO("REGTEST TrackContainer size: " << tc->size());
1414 
1415  for (TrigMuonEFInfoTrackContainer::const_iterator TrackItr = tc->begin() ; TrackItr!=tc->end(); ++TrackItr) {
1416 
1417  const TrigMuonEFInfoTrack* muonInfo = (*TrackItr);
1418  ATH_MSG_INFO("REGTEST MuonType(): ");
1419 
1420  const TrigMuonEFTrack* muonTrack = muonInfo->SpectrometerTrack();
1421  if (muonTrack) {
1422  printMuonTrk(muonTrack);
1423  } else {
1424  ATH_MSG_INFO("REGTEST no SpectrometerTrack track found");
1425  }
1426 
1427  ATH_MSG_INFO("REGTEST Looking at TrigMuonEFTrack ExtrapolatedTrack()");
1428  muonTrack = muonInfo->ExtrapolatedTrack();
1429  if (muonTrack) {
1430  printMuonTrk(muonTrack);
1431  } else {
1432  ATH_MSG_INFO("REGTEST no ExtrapolatedTrack track found");
1433  }
1434 
1435  ATH_MSG_INFO("REGTEST Looking at TrigMuonEFTrack CombinedTrack()");
1436  const TrigMuonEFCbTrack* muonCbTrack = muonInfo->CombinedTrack();
1437  if (muonCbTrack) {
1438  printMuonTrk(muonTrack);
1439  } else {
1440  ATH_MSG_INFO("REGTEST no CombinedTrack track found");
1441  }
1442  }
1443 
1444  }
1445 
1446  if (!muonInfo) {
1447  ATH_MSG_INFO("REGTEST no TrigMuonEFInfo found");
1448  return StatusCode::SUCCESS;
1449  }
1450  ATH_MSG_INFO("REGTEST TrigMuonEFInfo->RoINum() returns " << muonInfo->RoINum());
1451  }
1452  }
1453 
1454  ATH_MSG_INFO("REGTEST ==========END of TrigMuonEFInfoContainer DUMP===========");
1455  ATH_MSG_DEBUG("dumpTrigMuonEFInfoContainer() succeeded");
1456 
1457  return StatusCode::SUCCESS;
1458 }
1459 
1461 
1462 StatusCode TrigEDMChecker::dumpTrigMuonEFIsolationContainer ATLAS_NOT_THREAD_SAFE() {
1463 
1464  ATH_MSG_DEBUG("in dumpTrigMuonEFIsolationContainer()");
1465 
1466  ATH_MSG_INFO("REGTEST ==========START of TrigMuonEFIsolationContainer DUMP===========");
1467 
1470 
1471  StatusCode sc = evtStore()->retrieve(trigMuon,lastTrigMuon);
1472  if (sc.isFailure()) {
1473  ATH_MSG_INFO("REGTEST No TrigMuonEFIsolationContainer found");
1474  return StatusCode::SUCCESS;
1475  }
1476  ATH_MSG_INFO("REGTEST TrigMuonEFIsolationContainers retrieved");
1477 
1478 
1479  for (int i=0; trigMuon != lastTrigMuon; ++trigMuon, ++i) {
1480 
1481  ATH_MSG_INFO("REGTEST -+-+-+-+ Looking at TrigMuonEFIsolationContainer " << i);
1482 
1483  TrigMuonEFIsolationContainer::const_iterator MuonItr = trigMuon->begin();
1484  TrigMuonEFIsolationContainer::const_iterator MuonItrE = trigMuon->end();
1485 
1486  for (int j=0; MuonItr != MuonItrE; ++MuonItr, ++j ) {
1487 
1488  ATH_MSG_INFO("REGTEST Looking at TrigMuonEFIsolation " << j);
1489 
1490  const TrigMuonEFIsolation* muonIsolation = (*MuonItr);
1491 
1492  ATH_MSG_INFO("REGTEST Test self equality ");
1493  if (*muonIsolation == *muonIsolation) {
1494  ATH_MSG_INFO("REGTEST passed ");
1495  }
1496  else {
1497  ATH_MSG_INFO("REGTEST failed ");
1498  }
1499 
1500  ATH_MSG_INFO("REGTEST sumTrkPtCone02(): " << muonIsolation->sumTrkPtCone02());
1501  ATH_MSG_INFO("REGTEST sumTrkPtCone03(): " << muonIsolation->sumTrkPtCone03());
1502  ATH_MSG_INFO("REGTEST sumEtCone01() : " << muonIsolation->sumEtCone01());
1503  ATH_MSG_INFO("REGTEST sumEtCone02() : " << muonIsolation->sumEtCone02());
1504  ATH_MSG_INFO("REGTEST sumEtCone03() : " << muonIsolation->sumEtCone03());
1505  ATH_MSG_INFO("REGTEST sumEtCone04() : " << muonIsolation->sumEtCone04());
1506  ATH_MSG_INFO("REGTEST trackPosition() : " << muonIsolation->trackPosition() );
1507  // access MuonInfo* - only works for >=2012 data
1508  if(muonIsolation->getMuonInfo()) {
1509  ATH_MSG_INFO("REGTEST Link MuonEFInfo found: " << muonIsolation->getMuonInfo());
1510  if(!muonIsolation->getEFMuonInfoTrack()) {
1511  ATH_MSG_WARNING("REGTEST No InfoTrack attached to this EFIsolation object");
1512  }
1513  else {
1514  const TrigMuonEFInfoTrack* trk = muonIsolation->getEFMuonInfoTrack();
1515  ATH_MSG_INFO("REGTEST Linke EFInfoTrack has MuonType : " << trk->MuonType());
1516  if(trk->hasCombinedTrack()) ATH_MSG_INFO("REGTEST Linked EFInfoTrack combined pt : " << trk->CombinedTrack()->pt());
1517  if(trk->hasExtrapolatedTrack()) ATH_MSG_INFO("REGTEST Linked EFInfoTrack extrapolated pt : " << trk->ExtrapolatedTrack()->pt());
1518  if(trk->hasSpectrometerTrack()) ATH_MSG_INFO("REGTEST Linked EFInfoTrack MS pt : " << trk->SpectrometerTrack()->pt());
1519  if(trk->hasCombinedTrack()) {
1520  if(trk->CombinedTrack()->getIDTrackParticle())
1521  ATH_MSG_INFO("REGTEST Linked EFInfoTrack ID track pt : " << trk->CombinedTrack()->getIDTrackParticle()->pt());
1522  }
1523 
1524  }
1525  }else {
1526  ATH_MSG_INFO("REGTEST No Linked MuonEFInfo, expected for pre 2012 data");
1527  }
1528 
1529  }//TrigMuonEFIsolation loop
1530  }//TrigMuonEFIsolationContainer loop
1531 
1532  ATH_MSG_INFO("REGTEST ==========END of TrigMuonEFIsolationContainer DUMP===========");
1533  ATH_MSG_DEBUG("dumpTrigMuonEFIsolationContainer() succeeded");
1534 
1535  return StatusCode::SUCCESS;
1536 
1537 }//dumpTrigMuonEFIsolationContainer
1538 
1539 
1541  ATH_MSG_INFO("POINTER TrigMuonEFTrack: " << muonTrack);
1542  //if(muonTrack) mLog << MSG::INFO << "REGTEST TrigMuonEFTrack: " << *muonTrack << endmsg;
1543 
1544 // mLog <<MSG::INFO << "REGTEST TrigMuonEFTrack->charge() returns " << muonTrack->Charge() << endmsg;
1545 // mLog <<MSG::INFO << "REGTEST P4IPtCotThPhiM->iPt() returns " << muonTrack->iPt() << endmsg;
1546 // mLog <<MSG::INFO << "REGTEST P4IPtCotThPhiM->CotTh() returns " << muonTrack->cotTh() << endmsg;
1547 // mLog <<MSG::INFO << "REGTEST P4IPtCotThPhiM->Phi() returns " << muonTrack->phi() << endmsg;
1548 // mLog <<MSG::INFO << "REGTEST P4IPtCotThPhiM->m() returns " << muonTrack->m() << endmsg;
1549 // mLog <<MSG::INFO << "REGTEST chi2() returns " << muonTrack->chi2() << endmsg;
1550 // mLog <<MSG::INFO << "REGTEST chi2prob() returns " << muonTrack->chi2prob() << endmsg;
1551 // mLog <<MSG::INFO << "REGTEST posX() returns " << muonTrack->posX() << endmsg;
1552 // mLog <<MSG::INFO << "REGTEST posY() returns " << muonTrack->posY() << endmsg;
1553 // mLog <<MSG::INFO << "REGTEST posZ() returns " << muonTrack->posZ() << endmsg;
1554 // mLog <<MSG::INFO << "REGTEST NCscHitsEta() returns " << muonTrack->NCscHitsEta() << endmsg;
1555 // mLog <<MSG::INFO << "REGTEST NCscHitsPhi() returns " << muonTrack->NCscHitsPhi() << endmsg;
1556 // mLog <<MSG::INFO << "REGTEST NTgcHitsEta() returns " << muonTrack->NTgcHitsEta() << endmsg;
1557 // mLog <<MSG::INFO << "REGTEST NTgcHitsPhi() returns " << muonTrack->NTgcHitsPhi() << endmsg;
1558 // mLog <<MSG::INFO << "REGTEST NMdtHitsEta() returns " << muonTrack->NMdtHitsEta() << endmsg;
1559 // mLog <<MSG::INFO << "REGTEST NMdtHitsPhi() returns " << muonTrack->NMdtHitsPhi() << endmsg;
1560 // mLog <<MSG::INFO << "REGTEST NRpcHitsEta() returns " << muonTrack->NRpcHitsEta() << endmsg;
1561 // mLog <<MSG::INFO << "REGTEST NRpcHitsPhi() returns " << muonTrack->NRpcHitsPhi() << endmsg;
1562 // mLog <<MSG::INFO << "REGTEST d0() returns " << muonTrack->d0() << endmsg;
1563 // mLog <<MSG::INFO << "REGTEST z0() returns " << muonTrack->z0() << endmsg;
1564 }
1565 
1567  ATH_MSG_INFO(" POINTER TrigMuonEFCbTrack: " << muonTrack);
1568  //if(muonTrack) mLog << MSG::INFO << "REGTEST TrigMuonEFCbTrack: " << *muonTrack << endmsg;
1569 
1570 // printMuonTrk(mLog,(TrigMuonEFTrack*)muonTrack);
1571 // mLog <<MSG::INFO << "REGTEST TrigMuonEFCbTrack " << muonTrack << endmsg;
1572 // mLog <<MSG::INFO << "REGTEST NIdPixelHits() returns " << muonTrack->NIdPixelHits() << endmsg;
1573 // mLog <<MSG::INFO << "REGTEST NIdSctHits() returns " << muonTrack->NIdSctHits() << endmsg;
1574 // mLog <<MSG::INFO << "REGTEST NTrtHits() returns " << muonTrack->NTrtHits() << endmsg;
1575 // mLog <<MSG::INFO << "REGTEST matchChi2() returns " << muonTrack->matchChi2() << endmsg;
1576 }
1577 
1579 
1580 StatusCode TrigEDMChecker::dumpTrigElectronContainer ATLAS_NOT_THREAD_SAFE() {
1581 
1582  ATH_MSG_DEBUG("in dumpTrigElectronContainer()");
1583 
1584  ATH_MSG_INFO("REGTEST ==========START of TrigElectronContainer DUMP===========");
1585 
1588 
1589  StatusCode sc = evtStore()->retrieve(trigElec,lastTrigElec);
1590  if (sc.isFailure()) {
1591  ATH_MSG_INFO("REGTEST No TrigelectronContainer found");
1592  return StatusCode::SUCCESS;
1593  }
1594  ATH_MSG_INFO("REGTEST TrigElectronContainers retrieved");
1595 
1596  // declare pointer to the last trigElectron to test comparison operators
1598 
1599  for (int i=0; trigElec != lastTrigElec; ++trigElec, ++i) {
1600 
1601  ATH_MSG_INFO("REGTEST Looking at TrigElectronContainer " << i);
1602 
1603  TrigElectronContainer::const_iterator elecItr = trigElec->begin();
1604  TrigElectronContainer::const_iterator elecItrE = trigElec->end();
1605 
1606  for (int j=0; elecItr != elecItrE; ++elecItr, ++j ) {
1607 
1608  ATH_MSG_INFO("REGTEST Looking at TrigElectron " << j);
1609  // mLog <<MSG::INFO << "REGTEST TrigElectron->isValid() returns " << (*elecItr)->isValid() << endmsg;
1610  // mLog <<MSG::INFO << "REGTEST TrigElectron->pt() returns " << (*elecItr)->pt() << endmsg;
1611  // mLog <<MSG::INFO << "REGTEST TrigElectron->eta() returns " << (*elecItr)->eta() << endmsg;
1612  // mLog <<MSG::INFO << "REGTEST TrigElectron->phi() returns " << (*elecItr)->phi() << endmsg;
1613  // mLog <<MSG::INFO << "REGTEST TrigElectron->Zvtx() returns " << (*elecItr)->Zvtx() << endmsg;
1614 
1615  // mLog <<MSG::INFO << "REGTEST TrigElectron->charge() returns " << (*elecItr)->charge() << endmsg;
1616  // mLog <<MSG::INFO << "REGTEST TrigElectron->trackIndx() returns " << (*elecItr)->trackIndx() << endmsg;
1617  // mLog <<MSG::INFO << "REGTEST TrigElectron->trkClusDphi() returns " << (*elecItr)->trkClusDphi() << endmsg;
1618  // mLog <<MSG::INFO << "REGTEST TrigElectron->trkClusDeta() returns " << (*elecItr)->trkClusDeta() << endmsg;
1619  // mLog <<MSG::INFO << "REGTEST TrigElectron->Pt() (track) returns " << (*elecItr)->Pt() << endmsg;
1620  // mLog <<MSG::INFO << "REGTEST TrigElectron->err_Pt() returns " << (*elecItr)->err_Pt() << endmsg;
1621  // mLog <<MSG::INFO << "REGTEST TrigElectron->err_eta() returns " << (*elecItr)->err_eta() << endmsg;
1622  // mLog <<MSG::INFO << "REGTEST TrigElectron->err_phi() returns " << (*elecItr)->err_phi() << endmsg;
1623  // mLog <<MSG::INFO << "REGTEST TrigElectron->err_Zvtx() returns " << (*elecItr)->err_Zvtx() << endmsg;
1624 
1625  // mLog <<MSG::INFO << "REGTEST New methods: " << endmsg;
1626  // mLog <<MSG::INFO << "REGTEST TrigElectron->roiWord() returns " << (*elecItr)->roiWord() << endmsg;
1627  // mLog <<MSG::INFO << "REGTEST TrigElectron->trkEtaAtCalo() returns " << (*elecItr)->trkEtaAtCalo() << endmsg;
1628  // mLog <<MSG::INFO << "REGTEST TrigElectron->trkPhiAtCalo() returns " << (*elecItr)->trkPhiAtCalo() << endmsg;
1629  // mLog <<MSG::INFO << "REGTEST TrigElectron->caloEta() returns " << (*elecItr)->caloEta() << endmsg;
1630  // mLog <<MSG::INFO << "REGTEST TrigElectron->caloPhi() returns " << (*elecItr)->caloPhi() << endmsg;
1631  // mLog <<MSG::INFO << "REGTEST TrigElectron->Rcore() returns " << (*elecItr)->Rcore() << endmsg;
1632  // mLog <<MSG::INFO << "REGTEST TrigElectron->Eratio() returns " << (*elecItr)->Eratio() << endmsg;
1633  // mLog <<MSG::INFO << "REGTEST TrigElectron->EThad() returns " << (*elecItr)->EThad() << endmsg;
1634 
1635  // printout variables using the new << operator
1636  ATH_MSG_INFO("TrigElectron printout:");
1637  ATH_MSG_INFO("REGTEST " << (**elecItr));
1638 
1639  // do second loop to compare TrigElectrons using comparison operators
1640  TrigElectronContainer::const_iterator elecItr2 = elecItr; //trigElec->begin();
1641  TrigElectronContainer::const_iterator elecItr2E = trigElec->end();
1642 
1643  for (int k=0; elecItr2 != elecItr2E; ++elecItr2, ++k ) {
1644  // find if TrigElectrons are the same (i.e. have same cluster and track
1645  if ( (**elecItr) == (**elecItr2) ) {
1646  ATH_MSG_INFO("REGTEST TrigElectron nr. " << j << " is the same as TrigElectron nr. " << k);
1647  } else {
1648  // TrigElectrons are different, print out differences
1649  std::map<std::string, double> v_diff;
1650  diff(*(*elecItr),*(*elecItr2), v_diff);
1652  ATH_MSG_INFO("TrigElectron " << k << " different form TrigElectron " << j << " :");
1653  for (int m=0;it !=v_diff.end();++it, ++m) {
1654  ATH_MSG_INFO("TrigElectron Delta_" << (*it).first << " = " << (*it).second);
1655  }
1656  }
1657  }
1658  }
1659  }
1660 
1661  ATH_MSG_INFO("REGTEST ==========END of TrigElectronContainer DUMP===========");
1662  ATH_MSG_DEBUG("dumpTrigElectronContainer() succeeded");
1663 
1664  return StatusCode::SUCCESS;
1665 }
1666 
1669 
1670  ATH_MSG_DEBUG("In dumpxAODElectronContainer");
1671 
1672  ATH_MSG_INFO( "REGTEST ==========START of xAOD::TrigElectronContainer DUMP===========" );
1673 
1674  const xAOD::TrigElectronContainer* elCont=0;
1675  StatusCode sc = evtStore()->retrieve(elCont,"HLT_xAOD__TrigElectronContainer_L2ElectronFex");
1676  if (sc.isFailure()) {
1677  ATH_MSG_INFO("REGTEST No TrigElectron container HLT_xAOD__TrigElectronContainer_L2ElectronFex");
1678  return StatusCode::SUCCESS;
1679  }
1680 
1681  for (const auto eg : *elCont){
1682  ATH_MSG_INFO("REGTEST TrigElectron->Phi() returns " << eg->phi());
1683  ATH_MSG_INFO("REGTEST TrigElectron->Eta() returns " << eg->eta());
1684  ATH_MSG_INFO("REGTEST TrigElectron->rEta returns " << eg->rcore());
1685  ATH_MSG_INFO("REGTEST TrigElectron->eratio() returns " << eg->eratio());
1686  ATH_MSG_INFO("REGTEST TrigElectron->pt() returns " << eg->pt());
1687  ATH_MSG_INFO("REGTEST TrigElectron->etHad() returns " << eg->etHad());
1688  ATH_MSG_INFO("REGTEST TrigElectron->f1() returns " << eg->f1());
1689  ATH_MSG_INFO("REGTEST TrigElectron caloEta = " << eg->caloEta());
1690  ATH_MSG_INFO("REGTEST TrigElectron dPhiCalo" << eg->trkClusDphi());
1691  ATH_MSG_INFO("REGTEST TrigElectron dEtaCalo" << eg->trkClusDeta());
1692  ATH_MSG_INFO("REGTEST TrigElectron pTcalo" << eg->pt());
1693  ATH_MSG_INFO("REGTEST TrigElectron eTOverPt" << eg->etOverPt());
1694  ATH_MSG_INFO("REGTEST TrigElectron nTRTHits" << eg->nTRTHits());
1695  ATH_MSG_INFO("REGTEST TrigElectron nStrawHits" << eg->nTRTHiThresholdHits());
1696  ATH_MSG_INFO("REGTEST TrigElectron Check EMCluster");
1697  if(eg->emCluster()){
1698  ATH_MSG_INFO("REGTEST TrigElectron EMCluster retrieved");
1699  ATH_MSG_INFO("REGTEST TrigElectron emCluster->energy() returns " << eg->emCluster()->energy());
1700  ATH_MSG_INFO("REGTEST TrigElectron emCluster->phi() returns " << eg->emCluster()->phi());
1701  ATH_MSG_INFO("REGTEST TrigElectron emCluster->eta() returns " << eg->emCluster()->eta());
1702  ATH_MSG_INFO("REGTEST TrigElectron emCluster check Element Link");
1703  ATH_MSG_INFO("REGTEST TrigElectron emCluster energy = " << eg->emCluster()->energy());
1704  ATH_MSG_INFO("REGTEST TrigElectron ElementLink emCluster energy = " << (*eg->emClusterLink())->energy());
1705  }
1706  else ATH_MSG_INFO("REGTEST TrigElectron No EMCluster retrieved!");
1707  ATH_MSG_INFO("REGTEST TrigElectron Check TrackParticle");
1708  if(eg->trackParticle()){
1709  ATH_MSG_INFO("REGTEST TrigElectron TrackParticle retrieved");
1710  ATH_MSG_INFO("REGTEST TrigElectron trackParticle->pt() returns " << eg->trackParticle()->pt());
1711  ATH_MSG_INFO("REGTEST TrigElectron trackParticle->phi() returns " << eg->trackParticle()->phi());
1712  ATH_MSG_INFO("REGTEST TrigElectron trackParticle->eta() returns " << eg->trackParticle()->eta());
1713  ATH_MSG_INFO("REGTEST TrigElectron check TrackParticle Element Link");
1714  ATH_MSG_INFO("REGTEST TrigElectron TrackParticle pt = " << eg->trackParticle()->pt());
1715  ATH_MSG_INFO("REGTEST TrigElectron ElementLink TrackParticle pt = " << (*eg->trackParticleLink())->pt());
1716  }
1717  else ATH_MSG_INFO("REGTEST TrigElectron No TrackParticle retrieved!");
1718  }
1719  ATH_MSG_INFO( "REGTEST ==========END of xAOD::TrigElectronContainer DUMP===========" );
1720 
1721  return StatusCode::SUCCESS;
1722 
1723 }
1727 
1728  ATH_MSG_DEBUG("In dumpxAODTrigPhotonContainer");
1729 
1730  ATH_MSG_INFO( "REGTEST ==========START of xAOD::TrigPhotonContainer DUMP===========" );
1731 
1732  const xAOD::TrigPhotonContainer* phCont=0;
1733  StatusCode sc = evtStore()->retrieve(phCont,"HLT_xAOD__TrigPhotonContainer_L2PhotonFex");
1734  if (sc.isFailure()) {
1735  ATH_MSG_INFO("REGTEST No TrigPhoton container HLT_xAOD__TrigPhotonContainer_L2PhotonFex");
1736  return StatusCode::SUCCESS;
1737  }
1738 
1739  for (const auto eg : *phCont){
1740 
1741  ATH_MSG_INFO("REGTEST TrigPhoton->Phi() returns " << eg->phi());
1742  ATH_MSG_INFO("REGTEST TrigPhoton->Eta() returns " << eg->eta());
1743  ATH_MSG_INFO("REGTEST TrigPhoton->dPhi() returns " << eg->dPhi());
1744  ATH_MSG_INFO("REGTEST TrigPhoton->dEta() returns " << eg->dEta());
1745  ATH_MSG_INFO("REGTEST TrigPhoton->rEta returns " << eg->rcore());
1746  ATH_MSG_INFO("REGTEST TrigPhoton->eratio() returns " << eg->eratio());
1747  ATH_MSG_INFO("REGTEST TrigPhoton->pt() returns " << eg->pt());
1748  ATH_MSG_INFO("REGTEST TrigPhoton->etHad() returns " << eg->etHad());
1749  ATH_MSG_INFO("REGTEST TrigPhoton->f1() returns " << eg->f1());
1750  ATH_MSG_INFO("REGTEST TrigPhoton Check EMCluster");
1751  if(eg->emCluster()){
1752  ATH_MSG_INFO("REGTEST TrigPhoton EMCluster retrieved");
1753  ATH_MSG_INFO("REGTEST TrigPhoton emCluster->energy() returns " << eg->emCluster()->energy());
1754  ATH_MSG_INFO("REGTEST TrigPhoton emCluster->phi() returns " << eg->emCluster()->phi());
1755  ATH_MSG_INFO("REGTEST TrigPhoton emCluster->eta() returns " << eg->emCluster()->eta());
1756  ATH_MSG_INFO("REGTEST TrigPhoton emCluster check Element Link");
1757  ATH_MSG_INFO("REGTEST TrigPhoton emCluster energy = " << eg->emCluster()->energy());
1758  ATH_MSG_INFO("REGTEST TrigPhoton ElementLink emCluster energy = " << (*eg->emClusterLink())->energy());
1759  }
1760  else ATH_MSG_INFO("REGTEST TrigPhoton No EMCluster retrieved!");
1761  }
1762  ATH_MSG_INFO( "REGTEST ==========END of xAOD::TrigPhotonContainer DUMP===========" );
1763 
1764  return StatusCode::SUCCESS;
1765 
1766 }
1770 
1771  ATH_MSG_DEBUG("In dumpxAODElectronContainer");
1772 
1773  ATH_MSG_INFO( "REGTEST ==========START of xAOD::ElectronContainer DUMP===========" );
1774 
1775  const xAOD::ElectronContainer* elCont=0;
1776  StatusCode sc = evtStore()->retrieve(elCont,"HLT_xAOD__ElectronContainer_egamma_Electrons");
1777  if (sc.isFailure()) {
1778  ATH_MSG_INFO("REGTEST No Electron container HLT_xAOD__ElectronContainer_egamma_Electrons");
1779  return StatusCode::SUCCESS;
1780  }
1781  float val_float=-99;
1782  unsigned int isEMbit=0;
1783  bool pid=false;
1784  //DEBUG output for Egamma container
1785  ATH_MSG_INFO(" REGTEST: xAOD Reconstruction variables: ");
1786  // //Cluster and ShowerShape info
1787  //
1788  static const SG::AuxElement::Accessor< float > accLH("LHValue");
1789  static const SG::AuxElement::Accessor< float > accLHCalo("LHCaloValue");
1790  for (const auto eg : *elCont){
1791  //REGTEST printout
1792  if (eg) {
1793  ATH_MSG_INFO(" REGTEST: egamma energy: " << eg->e() );
1794  ATH_MSG_INFO(" REGTEST: egamma eta: " << eg->eta() );
1795  ATH_MSG_INFO(" REGTEST: egamma phi: " << eg->phi() );
1796  if(eg->selectionisEM(isEMbit,"isEMVLoose"))
1797  ATH_MSG_INFO(" REGTEST: isEMVLoose " << std::hex << isEMbit << std::dec);
1798  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1799  if(eg->selectionisEM(isEMbit,"isEMLoose"))
1800  ATH_MSG_INFO(" REGTEST: isEMLoose " << std::hex << isEMbit << std::dec);
1801  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1802  if(eg->selectionisEM(isEMbit,"isEMMedium"))
1803  ATH_MSG_INFO(" REGTEST: isEMMedium " << std::hex << isEMbit << std::dec);
1804  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1805  if(eg->selectionisEM(isEMbit,"isEMTight"))
1806  ATH_MSG_INFO(" REGTEST: isEMTight " << std::hex << isEMbit << std::dec);
1807  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1808  if(eg->selectionisEM(isEMbit,"isEMLHVLoose"))
1809  ATH_MSG_INFO(" REGTEST: isEMLHVLoose " << std::hex << isEMbit << std::dec);
1810  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1811  if(eg->selectionisEM(isEMbit,"isEMLHLoose"))
1812  ATH_MSG_INFO(" REGTEST: isEMLHLoose " << std::hex << isEMbit << std::dec);
1813  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1814  if(eg->selectionisEM(isEMbit,"isEMLHMedium"))
1815  ATH_MSG_INFO(" REGTEST: isEMLHMedium " << std::hex << isEMbit << std::dec);
1816  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1817  if(eg->selectionisEM(isEMbit,"isEMLHTight"))
1818  ATH_MSG_INFO(" REGTEST: isEMLHTight " << std::hex << isEMbit << std::dec);
1819  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1820  if(accLH.isAvailable(*eg))
1821  ATH_MSG_INFO(" REGTEST: LHValue " << accLH(*eg));
1822  else
1823  ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
1824  if(accLHCalo.isAvailable(*eg))
1825  ATH_MSG_INFO(" REGTEST: LHValue " << accLHCalo(*eg));
1826  else
1827  ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
1828  if(eg->passSelection(pid,"LHVLoose"))
1829  ATH_MSG_INFO(" REGTEST: LHVLoose " << pid);
1830  else
1831  ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
1832  if(eg->passSelection(pid,"LHLoose"))
1833  ATH_MSG_INFO(" REGTEST: LHLoose " << pid);
1834  else
1835  ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
1836  if(eg->passSelection(pid,"LHMedium"))
1837  ATH_MSG_INFO(" REGTEST: LHMedium " << pid);
1838  else
1839  ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
1840  if(eg->passSelection(pid,"LHTight"))
1841  ATH_MSG_INFO(" REGTEST: LHTight " << pid);
1842  else
1843  ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
1844  } else{
1845  ATH_MSG_INFO(" REGTEST: problems with egamma pointer" );
1846  return StatusCode::SUCCESS;
1847  }
1848  ATH_MSG_INFO(" REGTEST: caloCluster variables ");
1849  if (eg->caloCluster()) {
1850  ATH_MSG_INFO(" REGTEST: egamma cluster transverse energy: " << eg->caloCluster()->et() );
1851  ATH_MSG_INFO(" REGTEST: egamma cluster eta: " << eg->caloCluster()->eta() );
1852  ATH_MSG_INFO(" REGTEST: egamma cluster phi: " << eg->caloCluster()->phi() );
1853  double tmpeta = -999.;
1854  double tmpphi = -999.;
1855  eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta);
1856  eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi);
1857  ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. etaCalo = " << tmpeta);
1858  ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. phiCalo = " << tmpphi);
1859  } else{
1860  ATH_MSG_INFO(" REGTEST: problems with egamma cluster pointer" );
1861  }
1862  ATH_MSG_INFO("REGTEST: Check the original (uncalibrated)");
1863  static const SG::AuxElement::Accessor<ElementLink<xAOD::CaloClusterContainer> > orig ("originalCaloCluster");
1864  if (!orig.isAvailable(*eg->caloCluster()) || !orig(*eg->caloCluster()).isValid()){
1865  ATH_MSG_INFO("Problem with original cluster link");
1866  }
1867  else {
1868  const xAOD::CaloCluster *origClus = *orig(*eg->caloCluster());
1869  ATH_MSG_INFO("REGTEST:: Compare new and old clusters");
1870  ATH_MSG_INFO("REGTEST:: Original Cluster e,eta,phi" << origClus->e() << " " << origClus->eta() << " " << origClus->phi());
1871  ATH_MSG_INFO("REGTEST:: MVA Cluster e,eta,phi" << eg->caloCluster()->e() << " " << eg->caloCluster()->eta() << " " << eg->caloCluster()->phi());
1872  }
1873  ATH_MSG_INFO(" REGTEST: trackmatch variables ");
1874  if(eg->trackParticle()){
1875  ATH_MSG_INFO(" REGTEST: pt= " << eg->trackParticle()->pt());
1876  ATH_MSG_INFO(" REGTEST: charge= " << eg->trackParticle()->charge());
1877  ATH_MSG_INFO(" REGTEST: E/p= " << eg->caloCluster()->et() / eg->trackParticle()->pt() );
1878  eg->trackCaloMatchValue(val_float,xAOD::EgammaParameters::deltaEta1);
1879  ATH_MSG_INFO(" REGTEST: Delta eta 1st sampling= " << val_float);
1880  eg->trackCaloMatchValue(val_float,xAOD::EgammaParameters::deltaPhi2);
1881  ATH_MSG_INFO(" REGTEST: Delta phi 2nd sampling= " << val_float);
1882  } else{
1883  ATH_MSG_INFO(" REGTEST: no electron eg->trackParticle() pointer");
1884  }
1885 
1886  //msg() << MSG::VERBOSE << " REGTEST: cluster variables " << endmsg;
1887  //clus = eg->caloCluster();
1888  ATH_MSG_INFO(" REGTEST: EMShower variables ");
1889  eg->showerShapeValue(val_float,xAOD::EgammaParameters::ethad);
1890  ATH_MSG_INFO(" REGTEST: ethad = " << val_float);
1891  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e011);
1892  ATH_MSG_INFO(" REGTEST: e011 = " << val_float);
1893  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e132);
1894  ATH_MSG_INFO(" REGTEST: e132 = " << val_float);
1895  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e237);
1896  ATH_MSG_INFO(" REGTEST: e237 = " << val_float);
1897  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e335);
1898  ATH_MSG_INFO(" REGTEST: e335 = " << val_float);
1899  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e2ts1);
1900  ATH_MSG_INFO(" REGTEST: e2ts1 = " << val_float);
1901  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e2tsts1);
1902  ATH_MSG_INFO(" REGTEST: e2tsts1 = " << val_float);
1903  eg->isolationValue(val_float,xAOD::Iso::ptcone20);
1904  ATH_MSG_INFO(" REGTEST: ptcone20 = " << val_float);
1905  eg->isolationValue(val_float,xAOD::Iso::ptcone30);
1906  ATH_MSG_INFO(" REGTEST: ptcone30 = " << val_float);
1907  eg->isolationValue(val_float,xAOD::Iso::ptcone40);
1908  ATH_MSG_INFO(" REGTEST: ptcone40 = " << val_float);
1909  eg->isolationValue(val_float,xAOD::Iso::etcone20);
1910  ATH_MSG_INFO(" REGTEST: etcone20 = " << val_float);
1911  eg->isolationValue(val_float,xAOD::Iso::etcone30);
1912  ATH_MSG_INFO(" REGTEST: etcone30 = " << val_float);
1913  eg->isolationValue(val_float,xAOD::Iso::etcone40);
1914  ATH_MSG_INFO(" REGTEST: etcone40 = " << val_float);
1915  //DEBUG info for Electrons which by definition have a track match
1916 
1917  }
1918  ATH_MSG_INFO( "REGTEST ==========END of xAOD::ElectronContainer DUMP===========" );
1919 
1920  return StatusCode::SUCCESS;
1921 
1922 }
1926 
1927  ATH_MSG_DEBUG("In dumpxAODPhotonContainer");
1928 
1929  ATH_MSG_INFO( "REGTEST ==========START of xAOD::PhotonContainer DUMP===========" );
1930 
1931  const xAOD::PhotonContainer* phCont=0;
1932  StatusCode sc = evtStore()->retrieve(phCont,"HLT_xAOD__PhotonContainer_egamma_Photons");
1933  if (sc.isFailure()) {
1934  ATH_MSG_INFO("REGTEST No Photon container HLT_xAOD__PhotonContainer_egamma_Photons");
1935  return StatusCode::SUCCESS;
1936  }
1937 
1938  float val_float=-99;
1939  unsigned int isEMbit=0;
1940  //DEBUG output for xAOD::PhotonContainer
1941  ATH_MSG_INFO(" REGTEST: xAOD Reconstruction variables: ");
1942  // //Cluster and ShowerShape info
1943  for (const auto eg : *phCont){
1944  //REGTEST printout
1945  if (eg) {
1946  ATH_MSG_INFO(" REGTEST: egamma energy: " << eg->e() );
1947  ATH_MSG_INFO(" REGTEST: egamma eta: " << eg->eta() );
1948  ATH_MSG_INFO(" REGTEST: egamma phi: " << eg->phi() );
1949  ATH_MSG_INFO(" REGTEST: isEMLoose " << eg->selectionisEM(isEMbit,"isEMLoose"));
1950  ATH_MSG_INFO(" REGTEST: isEMLoose bit " << std::hex << isEMbit << std::dec);
1951  ATH_MSG_INFO(" REGTEST: isEMMedium " << eg->selectionisEM(isEMbit,"isEMMedium"));
1952  ATH_MSG_INFO(" REGTEST: isEMMedium bit " << std::hex << isEMbit << std::dec);
1953  ATH_MSG_INFO(" REGTEST: isEMTight " << eg->selectionisEM(isEMbit,"isEMTight"));
1954  ATH_MSG_INFO(" REGTEST: isEMTight bit " << std::hex << isEMbit << std::dec);
1955  } else{
1956  ATH_MSG_INFO(" REGTEST: problems with egamma pointer" );
1957  return StatusCode::SUCCESS;
1958  }
1959  ATH_MSG_INFO(" REGTEST: caloCluster variables ");
1960  if (eg->caloCluster()) {
1961  ATH_MSG_INFO(" REGTEST: egamma cluster transverse energy: " << eg->caloCluster()->et() );
1962  ATH_MSG_INFO(" REGTEST: egamma cluster eta: " << eg->caloCluster()->eta() );
1963  ATH_MSG_INFO(" REGTEST: egamma cluster phi: " << eg->caloCluster()->phi() );
1964  double tmpeta = -999.;
1965  double tmpphi = -999.;
1966  eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta);
1967  eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi);
1968  ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. etaCalo = " << tmpeta);
1969  ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. phiCalo = " << tmpphi);
1970  } else{
1971  ATH_MSG_INFO(" REGTEST: problems with egamma cluster pointer" );
1972  }
1973  ATH_MSG_INFO("REGTEST: Check the original (uncalibrated)");
1974  static const SG::AuxElement::Accessor<ElementLink<xAOD::CaloClusterContainer> > orig ("originalCaloCluster");
1975  if (!orig.isAvailable(*eg->caloCluster()) || !orig(*eg->caloCluster()).isValid()){
1976  ATH_MSG_INFO("Problem with original cluster link");
1977  }
1978  else {
1979  const xAOD::CaloCluster *origClus = *orig(*eg->caloCluster());
1980  ATH_MSG_INFO("REGTEST:: Compare new and old clusters");
1981  ATH_MSG_INFO("REGTEST:: Original Cluster e,eta,phi" << origClus->e() << " " << origClus->eta() << " " << origClus->phi());
1982  ATH_MSG_INFO("REGTEST:: MVA Cluster e,eta,phi" << eg->caloCluster()->e() << " " << eg->caloCluster()->eta() << " " << eg->caloCluster()->phi());
1983  }
1984  //msg() << MSG::VERBOSE << " REGTEST: cluster variables " << endmsg;
1985  //clus = eg->caloCluster();
1986  ATH_MSG_INFO(" REGTEST: EMShower variables ");
1987  eg->showerShapeValue(val_float,xAOD::EgammaParameters::ethad);
1988  ATH_MSG_INFO(" REGTEST: ethad = " << val_float);
1989  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e011);
1990  ATH_MSG_INFO(" REGTEST: e011 = " << val_float);
1991  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e132);
1992  ATH_MSG_INFO(" REGTEST: e132 = " << val_float);
1993  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e237);
1994  ATH_MSG_INFO(" REGTEST: e237 = " << val_float);
1995  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e335);
1996  ATH_MSG_INFO(" REGTEST: e335 = " << val_float);
1997  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e2ts1);
1998  ATH_MSG_INFO(" REGTEST: e2ts1 = " << val_float);
1999  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e2tsts1);
2000  ATH_MSG_INFO(" REGTEST: e2tsts1 = " << val_float);
2001  eg->isolationValue(val_float,xAOD::Iso::etcone20);
2002  ATH_MSG_INFO(" REGTEST: etcone20 = " << val_float);
2003  eg->isolationValue(val_float,xAOD::Iso::etcone30);
2004  ATH_MSG_INFO(" REGTEST: etcone30 = " << val_float);
2005  eg->isolationValue(val_float,xAOD::Iso::etcone40);
2006  ATH_MSG_INFO(" REGTEST: etcone40 = " << val_float);
2007  //DEBUG info for Electrons which by definition have a track match
2008 
2009  }
2010  ATH_MSG_INFO( "REGTEST ==========END of xAOD::PhotonContainer DUMP===========" );
2011 
2012  return StatusCode::SUCCESS;
2013 
2014 }
2016 
2017 StatusCode TrigEDMChecker::dumpTrigTauContainer ATLAS_NOT_THREAD_SAFE() {
2018 
2019  ATH_MSG_DEBUG("in dumpTrigTauContainer()");
2020  ATH_MSG_INFO("REGTEST ==========START of TrigTauContainer DUMP===========");
2021 
2024 
2025  StatusCode sc = evtStore()->retrieve(trigTau,lastTrigTau);
2026  if (sc.isFailure()) {
2027  ATH_MSG_INFO("REGTEST No TrigTauContainer found");
2028  return StatusCode::SUCCESS;
2029  }
2030  ATH_MSG_INFO("REGTEST TrigTauContainer retrieved");
2031 
2032  for (int i=0; trigTau != lastTrigTau; ++trigTau, ++i) {
2033 
2034  ATH_MSG_INFO("REGTEST Looking at TrigTauContainer " << i);
2035 
2036  TrigTauContainer::const_iterator TrigTauItr = trigTau->begin();
2037  TrigTauContainer::const_iterator TrigTauItrE = trigTau->end();
2038 
2039  for (int j=0; TrigTauItr != TrigTauItrE; ++TrigTauItr, ++j ) {
2040 
2041  ATH_MSG_INFO("REGTEST Looking at TrigTau " << j);
2042 
2043  ATH_MSG_INFO("REGTEST TrigTau->pt() returns " << (*TrigTauItr)->pt());
2044  ATH_MSG_INFO("REGTEST TrigTau->eta() returns " << (*TrigTauItr)->eta());
2045  ATH_MSG_INFO("REGTEST TrigTau->phi() returns " << (*TrigTauItr)->phi());
2046 
2047  ATH_MSG_INFO("REGTEST TrigTau->nMatchedTracks() returns " << (*TrigTauItr)->nMatchedTracks());
2048  ATH_MSG_INFO("REGTEST TrigTau->simpleEtFlow() returns " << (*TrigTauItr)->simpleEtFlow());
2049  ATH_MSG_INFO("REGTEST TrigTau->m() returns " << (*TrigTauItr)->m());
2050  }
2051  }
2052 
2053  ATH_MSG_INFO("REGTEST ==========END of TrigTau DUMP===========");
2054  ATH_MSG_DEBUG("dumpTrigTauContainer() succeeded");
2055 
2056  return StatusCode::SUCCESS;
2057 }
2058 
2060 StatusCode TrigEDMChecker::dumpTrigTauTracksInfo ATLAS_NOT_THREAD_SAFE() {
2061 
2062  ATH_MSG_DEBUG("in dumpTrigTauTracksInfo()");
2063  ATH_MSG_INFO("REGTEST ==========START of TrigTauTracksInfo DUMP===========");
2064 
2067 
2068  StatusCode sc = evtStore()->retrieve(trigTau,lastTrigTau);
2069  if (sc.isFailure()) {
2070  ATH_MSG_INFO("REGTEST No TrigTauTracksInfo found");
2071  return StatusCode::SUCCESS;
2072  }
2073  ATH_MSG_INFO("REGTEST TrigTauTracksInfos retrieved");
2074 
2075  for (int i=0; trigTau != lastTrigTau; ++trigTau, ++i) {
2076 
2077  const TrigTauTracksInfo* thisTrigTau = &(*trigTau);
2078 
2079  ATH_MSG_INFO("REGTEST Looking at TrigTauTracksInfo " << i);
2080 
2081  ATH_MSG_INFO("REGTEST TrigTauTracksInfo->pt() returns " << thisTrigTau->pt());
2082  ATH_MSG_INFO("REGTEST TrigTauTracksInfo->eta() returns " << thisTrigTau->eta());
2083  ATH_MSG_INFO("REGTEST TrigTauTracksInfo->phi() returns " << thisTrigTau->phi());
2084 
2085  ATH_MSG_INFO("REGTEST TrigTauTracksInfo->nCoreTracks() returns " << thisTrigTau->nCoreTracks());
2086  ATH_MSG_INFO("REGTEST TrigTauTracksInfo->nSlowTracks() returns " << thisTrigTau->nSlowTracks());
2087  ATH_MSG_INFO("REGTEST TrigTauTracksInfo->nIsoTracks() returns " << thisTrigTau->nIsoTracks());
2088 
2089  ATH_MSG_INFO("REGTEST TrigTauTracksInfo->charge() returns " << thisTrigTau->charge());
2090  ATH_MSG_INFO("REGTEST TrigTauTracksInfo->leadingTrackPt() returns " <<
2091  thisTrigTau->leadingTrackPt());
2092  ATH_MSG_INFO("REGTEST TrigTauTracksInfo->scalarPtSumCore() returns " <<
2093  thisTrigTau->scalarPtSumCore());
2094  ATH_MSG_INFO("REGTEST TrigTauTracksInfo->scalarPtSumIso() returns " <<
2095  thisTrigTau->scalarPtSumIso());
2096  ATH_MSG_INFO("REGTEST TrigTauTracksInfo->threeFastestTracks().pt() returns " <<
2097  thisTrigTau->threeFastestTracks().pt());
2098  }
2099 
2100  ATH_MSG_INFO("REGTEST ==========END of TrigTauTracksInfo DUMP===========");
2101  ATH_MSG_DEBUG("dumpTrigTauTracksInfo() succeeded");
2102 
2103  return StatusCode::SUCCESS;
2104 }
2105 
2107 
2109 
2110  ATH_MSG_DEBUG("in dumpHLTResult()");
2111 
2112  ATH_MSG_INFO("REGTEST ==========START of HLTResult DUMP===========");
2113 
2114  const HLT::HLTResult* hltResult = 0;
2115  StatusCode sc=evtStore()->retrieve( hltResult, "HLTResult_L2");
2116  if( sc.isFailure() || !hltResult ) {
2117  ATH_MSG_INFO("No HLTResult_L2 found in TDS");
2118  return StatusCode::SUCCESS;
2119  }
2120  ATH_MSG_INFO("REGTEST HLTResult_L2 Successfully Retrieved");
2121 
2122  ATH_MSG_INFO("REGTEST HLTResult_L2->isEmpty() returns " << hltResult->isEmpty());
2123  ATH_MSG_INFO("REGTEST HLTResult_L2->size() returns " << hltResult->size());
2124  ATH_MSG_INFO("REGTEST HLTResult_L2->isPassThrough() returns " << hltResult->isPassThrough());
2125  ATH_MSG_INFO("REGTEST HLTResult_L2->isAccepted() returns " << hltResult->isAccepted());
2126 
2127  ATH_MSG_INFO("REGTEST ==========END of HLTResult DUMP===========");
2128 
2129  ATH_MSG_DEBUG("dumpHLTResult() succeeded");
2130 
2131  return StatusCode::SUCCESS;
2132 }
2133 
2134 
2135 
2136 
2138 
2140 
2141  std::string TrigInDetTrackTags[]={ "HLT_TrigIDSCAN_Jet",
2142  "HLT_TrigIDSCAN_Tau",
2143  "HLT_TrigIDSCAN_eGamma",
2144  "HLT_TrigIDSCAN_Muon",
2145  "HLT_TrigIDSCAN_muonIso",
2146  "HLT_TrigIDSCAN_Bphysics",
2147  "HLT_TrigIDSCAN_FullScan",
2148  "HLT_TrigIDSCAN_Cosmics",
2149  "HLT_TrigIDSCAN_eGamma_Brem",
2150  "HLT_TrigIDSCAN_Tile",
2151  "HLT_TrigSiTrack_eGamma",
2152  "HLT_TrigSiTrack_Muon",
2153  "HLT_TrigSiTrack_muonIso",
2154  "HLT_TrigSiTrack_Tau",
2155  "HLT_TrigSiTrack_Jet",
2156  "HLT_TrigSiTrack_Bphysics",
2157  "HLT_TrigSiTrack_FullScan",
2158  "HLT_TrigSiTrack_Cosmics",
2159  "HLT_TRTSegmentFinder",
2160  "HLT_TRTxK"};
2161  int ntag=20;
2162 
2163  ATH_MSG_DEBUG("in dumpTrigInDetTrackCollection()");
2164 
2165  const TrigInDetTrackTruthMap* pTruthMap(nullptr);
2166  bool gotTruthMap = false;
2167 
2168  if (evtStore()->contains<TrigInDetTrackTruthMap>("TrigInDetTrackTruthMap")) {
2169  StatusCode sc=evtStore()->retrieve(pTruthMap,"TrigInDetTrackTruthMap");
2170  if (sc.isFailure())
2171  {
2172  ATH_MSG_WARNING(" could not retrieve TrackTruthMap with key TrigInDetTruthMap");
2173  } else {
2174  gotTruthMap=true;
2175  // pTruthMap->print();
2176  }
2177  }
2178  else ATH_MSG_DEBUG(" didn't find any TrackTruthMap objects with key TrigInDetTruthMap");
2179 
2180  ATH_MSG_INFO("REGTEST ==========START of TrigInDetTrackCollection DUMP===========");
2181 
2182  for (int iTag=0; iTag < ntag; iTag++) {
2183  const TrigInDetTrackCollection* trigInDetTrackCollection = nullptr;
2184  StatusCode sc = evtStore()->retrieve(trigInDetTrackCollection,TrigInDetTrackTags[iTag] );
2185  if (sc.isFailure()) {
2186  ATH_MSG_DEBUG("REGTEST No TrigInDetTrackCollection found with key " << TrigInDetTrackTags[iTag]);
2187  continue;
2188  }
2189  ATH_MSG_INFO("REGTEST TrigInDetTrackCollections retrieved with key "
2190  << TrigInDetTrackTags[iTag]);
2191 
2192  ATH_MSG_INFO("REGTEST TrigInDetTrackCollection->size() returns " << trigInDetTrackCollection->size());
2193 
2194  TrigInDetTrackCollection::const_iterator trkItr = trigInDetTrackCollection->begin();
2195  TrigInDetTrackCollection::const_iterator trkItrE = trigInDetTrackCollection->end();
2196 
2197  for (int j=0; trkItr != trkItrE; ++trkItr, ++j ) {
2198 
2199  ATH_MSG_INFO("REGTEST Looking at TrigInDetTrack " << j);
2200 
2201  ATH_MSG_INFO("REGTEST TrigInDetTrack->algorithmId() returns " << (*trkItr)->algorithmId());
2202  ATH_MSG_INFO("REGTEST TrigInDetTrack->chi2() returns " << (*trkItr)->chi2());
2203  ATH_MSG_INFO("REGTEST TrigInDetTrack->NStrawHits() returns " << (*trkItr)->NStrawHits());
2204 
2205  ATH_MSG_INFO("REGTEST TrigInDetTrack->NStraw() returns " << (*trkItr)->NStraw());
2206  ATH_MSG_INFO("REGTEST TrigInDetTrack->NStrawTime() returns " << (*trkItr)->NStrawTime());
2207  ATH_MSG_INFO("REGTEST TrigInDetTrack->NTRHits() returns " << (*trkItr)->NTRHits());
2208 
2209  ATH_MSG_INFO("REGTEST Looking at TrigInDetFitTrack->param()");
2210  const TrigInDetTrackFitPar* my_param = (*trkItr)->param();
2211 
2212  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->a0() returns " << my_param->a0());
2213  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->z0() returns " << my_param->z0());
2214  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->phi0() returns " << my_param->phi0());
2215  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->eta() returns " << my_param->eta());
2216  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->pT() returns " << my_param->pT());
2217  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->ea0() returns " << my_param->ea0());
2218  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->ez0() returns " << my_param->ez0());
2219  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->ephi0() returns " << my_param->ephi0());
2220  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->eeta() returns " << my_param->eeta());
2221  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->epT() returns " << my_param->epT());
2222  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->surfaceType() returns " << my_param->surfaceType());
2223  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->surfaceCoordinate() returns " << my_param->surfaceCoordinate());
2224  ATH_MSG_INFO("REGTEST Looking at covarience matrix: ");
2225 
2226  const std::vector<double>* const my_cov = my_param->cov();
2227  if (!my_cov) {
2228  ATH_MSG_INFO("REGTEST covarience matrix NULL (not stored)");
2229  } else {
2230  std::vector<double> tempcov = *my_cov;
2232  int k;
2233  for(iter = tempcov.begin(), k=0; iter != tempcov.end(); ++iter, ++k){
2234  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->cov() element " << k << " is " << (*iter));
2235  }
2236  }
2237  if (gotTruthMap) {
2238  if (!(pTruthMap->hasTruth((*trkItr)))) {
2239  ATH_MSG_DEBUG(" REGTEST Track has no truth info ");
2240  } else {
2241  ATH_MSG_DEBUG(" Track has truth info: ");
2242  const TrigInDetTrackTruth* pTRTtruth = pTruthMap->truth((*trkItr));
2243  int nMatches = pTRTtruth->nrMatches() ;
2244  if (nMatches==0) {
2245  ATH_MSG_INFO(" REGTEST Track has no truth matches");
2246  } else {
2247  ATH_MSG_INFO("REGTEST number of matched truth hits: Si: " << pTruthMap->bestMatchSiHits((*trkItr))
2248  << " TRT: " << pTruthMap->bestMatchTRTHits((*trkItr)));
2249  if (pTruthMap->bestMatchSiHits((*trkItr)) > 0) {
2250 
2251  const HepMcParticleLink* pSiTruth = pTruthMap->bestMatchSi((*trkItr));
2252 
2253  ATH_MSG_INFO("REGTEST Si match to kine ref " << pSiTruth->barcode());
2254  if (pSiTruth->cptr() != 0) {
2255  ATH_MSG_INFO("REGTEST Si PDG id " << pSiTruth->cptr()->pdg_id());
2256  }
2257  }
2258 
2259  if (pTruthMap->bestMatchTRTHits((*trkItr)) > 0) {
2260  const HepMcParticleLink* pTRTtruth = pTruthMap->bestMatchTRT((*trkItr));
2261 
2262  ATH_MSG_INFO("REGTEST TRT match to kine ref " << pTRTtruth->barcode());
2263  if (pTRTtruth->cptr() != 0) {
2264  ATH_MSG_INFO("REGTEST TRT PDG id " << pTRTtruth->cptr()->pdg_id());
2265  }
2266  }
2267  }
2268  }
2269  } // if (gotTruthMap)
2270  }
2271  }
2272 
2273  ATH_MSG_INFO("REGTEST ==========END of TrigInDetTrackCollection DUMP===========");
2274  ATH_MSG_DEBUG("dumpTrigInDetTrackCollection() succeeded");
2275 
2276  return StatusCode::SUCCESS;
2277 }
2278 
2279 
2281 
2282 StatusCode TrigEDMChecker::dumpTrigVertexCollection ATLAS_NOT_THREAD_SAFE() {
2283 
2284  ATH_MSG_DEBUG("in dumpTrigVertexCollection()");
2285  ATH_MSG_INFO("REGTEST ==========START of TrigVertexCollection DUMP===========");
2286 
2289 
2290  StatusCode sc = evtStore()->retrieve(trigVertex,lastTrigVertex);
2291  if (sc.isFailure()) {
2292  ATH_MSG_INFO("REGTEST No TrigVertexCollection found");
2293  return StatusCode::SUCCESS;
2294  }
2295  ATH_MSG_INFO("REGTEST TrigVertexCollection retrieved");
2296 
2297 
2298  for (int i=0; trigVertex != lastTrigVertex; ++trigVertex, ++i) {
2299 
2300  ATH_MSG_INFO("REGTEST Looking at TrigVertexCollection " << i);
2301 
2302  TrigVertexCollection::const_iterator VertexItr = trigVertex->begin();
2303  TrigVertexCollection::const_iterator VertexItrE = trigVertex->end();
2304 
2305  for (int j=0; VertexItr != VertexItrE; ++VertexItr, ++j ) {
2306 
2307  ATH_MSG_INFO("REGTEST Looking at TrigVertex " << j);
2308 
2309  ATH_MSG_INFO("REGTEST TrigVertex->x() returns " << (*VertexItr)->x());
2310  ATH_MSG_INFO("REGTEST TrigVertex->y() returns " << (*VertexItr)->y());
2311  ATH_MSG_INFO("REGTEST TrigVertex->z() returns " << (*VertexItr)->z());
2312  ATH_MSG_INFO("REGTEST TrigVertex->energyFraction() returns " << (*VertexItr)->energyFraction());
2313  ATH_MSG_INFO("REGTEST TrigVertex->ndof() returns " << (*VertexItr)->ndof());
2314 
2315  if(((*VertexItr)->tracks())!=NULL ){
2316  // mLog <<MSG::INFO << "REGTEST *** ((*VertexItr)->tracks())!=NULL *** " << endmsg;
2317  TrackInVertexList::const_iterator trkItr = (*VertexItr)->tracks()->begin();
2318  TrackInVertexList::const_iterator trkItrE = (*VertexItr)->tracks()->end();
2319 
2320  for (int p=0; trkItr != trkItrE; ++trkItr, ++p ) {
2321 
2322  ATH_MSG_INFO("REGTEST Looking at track " << p);
2323 
2324  ATH_MSG_INFO("REGTEST Tracks info: ");
2325  ATH_MSG_INFO("REGTEST tracks->NStrawHits() returns " << (*trkItr)->NStrawHits());
2326  ATH_MSG_INFO("REGTEST tracks->NStrawTime() returns " << (*trkItr)->NStrawTime());
2327  ATH_MSG_INFO("REGTEST tracks->NTRHits() returns " << (*trkItr)->NTRHits());
2328  }
2329  }
2330  }
2331  }
2332 
2333  ATH_MSG_INFO("REGTEST ==========END of TrigVertexCollection DUMP===========");
2334  ATH_MSG_DEBUG("dumpTrigVertexCollection() succeeded");
2335 
2336  return StatusCode::SUCCESS;
2337 }
2338 
2339 
2341 
2342 
2344 
2345  ATH_MSG_DEBUG("in dumpTrigEFBphysContainer()");
2346 
2347  ATH_MSG_INFO("REGTEST ==========START of TrigEFBphysContainer DUMP===========");
2348 
2349  std::string EFBphysTags[]={"HLT_xAOD__TrigBphysContainer_EFBMuMuFex",
2350  "HLT_xAOD__TrigBphysContainer_EFBMuMuXFex",
2351  "HLT_xAOD__TrigBphysContainer_EFDsPhiPiFex",
2352  "HLT_xAOD__TrigBphysContainer_EFMuPairs",
2353  "HLT_xAOD__TrigBphysContainer_EFMultiMuFex",
2354  "HLT_xAOD__TrigBphysContainer_EFTrackMass"
2355  };
2356 
2357  int ntag= (int) sizeof(EFBphysTags) / sizeof(EFBphysTags[0]);
2358 
2359 
2360  for (int itag=0; itag<ntag; itag++){
2361  const xAOD::TrigBphysContainer* trigEFBphys;
2362  StatusCode sc = evtStore()->retrieve(trigEFBphys, EFBphysTags[itag]);
2363  if (sc.isFailure()) {
2364  ATH_MSG_INFO("REGTEST No TrigEFBphysContainer found with tag " << EFBphysTags[itag]);
2365  continue;
2366  }
2367 
2368  ATH_MSG_INFO("REGTEST TrigEFBphysContainer found with tag " << EFBphysTags[itag]
2369  << " and size " << trigEFBphys->size());
2370 
2371  // for (int i=0; trigEFBphys != lastTrigEFBphys; ++trigEFBphys, ++i) {
2372 
2373  //mLog << MSG::INFO << "REGTEST Looking at TrigEFBphysContainer " << i << endmsg;
2374 
2375  xAOD::TrigBphysContainer::const_iterator EFBphysItr = trigEFBphys->begin();
2376  xAOD::TrigBphysContainer::const_iterator EFBphysItrE = trigEFBphys->end();
2377 
2378  for (int j=0; EFBphysItr != EFBphysItrE; ++EFBphysItr, ++j ) {
2379 
2380  ATH_MSG_INFO("REGTEST Looking at TrigEFBphys " << j);
2381 
2382  ATH_MSG_INFO("REGTEST TrigEFBphys->eta() returns " << (*EFBphysItr)->eta());
2383  ATH_MSG_INFO("REGTEST TrigEFBphys->phi() returns " << (*EFBphysItr)->phi());
2384  ATH_MSG_INFO("REGTEST TrigEFBphys->mass() returns " << (*EFBphysItr)->mass());
2385  ATH_MSG_INFO("REGTEST TrigEFBphys->fitmass() returns " << (*EFBphysItr)->fitmass());
2386  // ATH_MSG_INFO("REGTEST TrigEFBphys->isValid() returns " << (*EFBphysItr)->isValid());
2387  ATH_MSG_INFO("REGTEST TrigEFBphys->roiId() returns " << (*EFBphysItr)->roiId());
2388  ATH_MSG_INFO("REGTEST TrigEFBphys->particleType() returns " << (*EFBphysItr)->particleType());
2389 
2390  if( (*EFBphysItr)->secondaryDecay() != NULL){
2391  const xAOD::TrigBphys * psecond =(*EFBphysItr)->secondaryDecay();
2392  ATH_MSG_INFO("REGTEST Secondary decay info: ");
2393  ATH_MSG_INFO("REGTEST pSecondDecay->eta() returns " << psecond->eta());
2394  ATH_MSG_INFO("REGTEST pSecondDecay->phi() returns " << psecond->phi());
2395  ATH_MSG_INFO("REGTEST pSecondDecay->mass() returns " << psecond->mass());
2396  ATH_MSG_INFO("REGTEST pSecondDecay->fitmass() returns " << psecond->fitmass());
2397  // ATH_MSG_INFO("REGTEST pSecondDecay->isValid() returns " << (*EFBphysItr)->secondaryDecayLink()->isValid());
2398  ATH_MSG_INFO("REGTEST pSecondDecay->roiId() returns " << psecond->roiId());
2399  ATH_MSG_INFO("REGTEST pSecondDecay->particleType() returns " << psecond->particleType());
2400 
2401  } // end if secondary exists
2402 
2403 
2404 
2405  const std::vector<ElementLink<xAOD::TrackParticleContainer> > trackVector = (*EFBphysItr)->trackParticleLinks();
2406  if (trackVector.size() != 0) {
2407  ATH_MSG_INFO(" REGTEST got track vector size: " << trackVector.size());
2408  } else {
2409  ATH_MSG_INFO(" REGTEST no track vector!!! " );
2410  }
2411  std::vector<ElementLink<xAOD::TrackParticleContainer> >::const_iterator trkIt=trackVector.begin();
2412  for (int itrk=0 ; trkIt!= trackVector.end(); ++itrk, ++trkIt) {
2413  if (!(trkIt->isValid())) {
2414  ATH_MSG_WARNING("TrackParticleContainer::Invalid ElementLink to track ");
2415  continue;
2416  }
2417  //const Trk::Perigee* trackPerigee=(*(*trkIt))->measuredPerigee();
2418  const Trk::Perigee* trackPerigee=&((*(*trkIt))->perigeeParameters());
2419 
2420  // msg() << MSG::VERBOSE << "track, iterator, pointer " << itrk << " " << *trkIt << " " << *(*trkIt) << endmsg;
2421  double phi = trackPerigee->parameters()[Trk::phi];
2422  double theta = trackPerigee->parameters()[Trk::theta];
2423  double px = trackPerigee->momentum()[Trk::px];
2424  double py = trackPerigee->momentum()[Trk::py];
2425  double pt = sqrt(px*px + py*py);
2426  double eta = -std::log(tan(theta/2));
2427 
2428  ATH_MSG_INFO("track " << itrk << " pt phi eta " << pt << " " <<
2429  phi << " " << eta);
2430  }
2431 
2432  }
2433  }
2434  ATH_MSG_INFO("REGTEST ==========END of TrigEFBphysContainer DUMP===========");
2435  ATH_MSG_DEBUG("dumpTrigEFBphysContainer() succeeded");
2436 
2437  return StatusCode::SUCCESS;
2438 }
2439 
2442 
2443  ATH_MSG_DEBUG("in dumpTrigL2BphysContainer()");
2444  ATH_MSG_INFO("REGTEST ==========START of TrigL2BphysContainer DUMP===========");
2445 
2446  std::string L2BphysTags[]={"HLT_xAOD__TrigBphysContainer_L2BMuMuFex",
2447  "HLT_xAOD__TrigBphysContainer_L2BMuMuXFex",
2448  "HLT_xAOD__TrigBphysContainer_L2DsPhiPiFexDs",
2449  "HLT_xAOD__TrigBphysContainer_L2DsPhiPiFexPhi",
2450  "HLT_xAOD__TrigBphysContainer_L2JpsieeFex",
2451  "HLT_xAOD__TrigBphysContainer_L2MultiMuFex",
2452  "HLT_xAOD__TrigBphysContainer_L2TrackMass",
2453  };
2454  const int ntag = (int) sizeof(L2BphysTags) / sizeof(L2BphysTags[0]);
2455 
2456 
2457  for (int itag=0; itag<ntag; itag++){
2458  const xAOD::TrigBphysContainer* trigL2Bphys;
2459  StatusCode sc = evtStore()->retrieve(trigL2Bphys, L2BphysTags[itag]);
2460  if (sc.isFailure()) {
2461  ATH_MSG_INFO("REGTEST No TrigL2BphysContainer found with tag " << L2BphysTags[itag]);
2462  continue;
2463  }
2464 
2465  ATH_MSG_INFO("REGTEST TrigL2BphysContainer found with tag " << L2BphysTags[itag]
2466  << " and size " << trigL2Bphys->size());
2467 
2468  // for (int i=0; trigL2Bphys != lastTrigL2Bphys; ++trigL2Bphys, ++i) {
2469 
2470  // mLog << MSG::INFO << "REGTEST Looking at TrigL2BphysContainer " << i << endmsg;
2471 
2472  xAOD::TrigBphysContainer::const_iterator L2BphysItr = trigL2Bphys->begin();
2473  xAOD::TrigBphysContainer::const_iterator L2BphysItrE = trigL2Bphys->end();
2474 
2475  for (int j=0; L2BphysItr != L2BphysItrE; ++L2BphysItr, ++j ) {
2476 
2477  ATH_MSG_INFO("REGTEST Looking at TrigL2Bphys " << j);
2478 
2479  ATH_MSG_INFO("REGTEST TrigL2Bphys->eta() returns " << (*L2BphysItr)->eta());
2480  ATH_MSG_INFO("REGTEST TrigL2Bphys->phi() returns " << (*L2BphysItr)->phi());
2481  ATH_MSG_INFO("REGTEST TrigL2Bphys->mass() returns " << (*L2BphysItr)->mass());
2482  ATH_MSG_INFO("REGTEST TrigL2Bphys->fitmass() returns " << (*L2BphysItr)->fitmass());
2483  // ATH_MSG_INFO("REGTEST TrigL2Bphys->isValid() returns " << (*L2BphysItr)->isValid());
2484  ATH_MSG_INFO("REGTEST TrigL2Bphys->roiId() returns " << (*L2BphysItr)->roiId());
2485  ATH_MSG_INFO("REGTEST TrigL2Bphys->particleType() returns " << (*L2BphysItr)->particleType());
2486 
2487  if( (*L2BphysItr)->secondaryDecay() != NULL){
2488  const xAOD::TrigBphys * psecond =(*L2BphysItr)->secondaryDecay();
2489  ATH_MSG_INFO("REGTEST Secondary decay info: ");
2490  ATH_MSG_INFO("REGTEST pSecondDecay->eta() returns " << psecond->eta());
2491  ATH_MSG_INFO("REGTEST pSecondDecay->phi() returns " << psecond->phi());
2492  ATH_MSG_INFO("REGTEST pSecondDecay->mass() returns " << psecond->mass());
2493  ATH_MSG_INFO("REGTEST pSecondDecay->fitmass() returns " << psecond->fitmass());
2494  // ATH_MSG_INFO("REGTEST pSecondDecay->isValid() returns " << (*L2BphysItr)->secondaryDecayLink()->isValid());
2495  ATH_MSG_INFO("REGTEST pSecondDecay->roiId() returns " << psecond->roiId());
2496  ATH_MSG_INFO("REGTEST pSecondDecay->particleType() returns " << psecond->particleType());
2497  } // end if secondary exists
2498 
2499  const std::vector<ElementLink<xAOD::TrackParticleContainer> > trackVector = (*L2BphysItr)->trackParticleLinks();
2500  if (trackVector.size() != 0) {
2501  ATH_MSG_INFO(" REGTEST got track vector size: " << trackVector.size());
2502  } else {
2503  ATH_MSG_INFO(" REGTEST no track vector!!! " );
2504  }
2505  std::vector<ElementLink<xAOD::TrackParticleContainer> >::const_iterator trkIt=trackVector.begin();
2506  for (int itrk=0 ; trkIt!= trackVector.end(); ++itrk, ++trkIt) {
2507  if (!(trkIt->isValid())) {
2508  ATH_MSG_WARNING("TrackParticleContainer::Invalid ElementLink to track ");
2509  continue;
2510  }
2511  //const Trk::Perigee* trackPerigee=(*(*trkIt))->measuredPerigee();
2512  const Trk::Perigee* trackPerigee=&((*(*trkIt))->perigeeParameters());
2513 
2514  // msg() << MSG::VERBOSE << "track, iterator, pointer " << itrk << " " << *trkIt << " " << *(*trkIt) << endmsg;
2515  double phi = trackPerigee->parameters()[Trk::phi];
2516  double theta = trackPerigee->parameters()[Trk::theta];
2517  double px = trackPerigee->momentum()[Trk::px];
2518  double py = trackPerigee->momentum()[Trk::py];
2519  double pt = sqrt(px*px + py*py);
2520  double eta = -std::log(tan(theta/2));
2521 
2522  ATH_MSG_INFO("track " << itrk << " pt phi eta " << pt << " " <<
2523  phi << " " << eta);
2524  }
2525  }
2526  }
2527 
2528  ATH_MSG_INFO("REGTEST ==========END of TrigL2BphysContainer DUMP===========");
2529  ATH_MSG_DEBUG("dumpTrigL2BphysContainer() succeeded");
2530 
2531  return StatusCode::SUCCESS;
2532 }
2533 
2534 
2535 
2537 
2539 
2540  ATH_MSG_DEBUG("in dumpxAODJetContainer()");
2541 
2542  ATH_MSG_INFO("REGTEST ==========START of xAOD::JetContainer DUMP===========");
2543 
2544  std::string containerName[30] = {"HLT_xAOD__JetContainer_a4tcemjesFS",
2545  "HLT_xAOD__JetContainer_a4tcemsubFS",
2546  "HLT_xAOD__JetContainer_a4tcemsubjesFS",
2547  "HLT_xAOD__JetContainer_a4tcemnojcalibFS",
2548  "HLT_xAOD__JetContainer_a4tcemjesPS",
2549  "HLT_xAOD__JetContainer_a4tcemnojcalibPS",
2550  "HLT_xAOD__JetContainer_a4tclcwjesFS",
2551  "HLT_xAOD__JetContainer_a4tclcwsubFS",
2552  "HLT_xAOD__JetContainer_a4tclcwsubjesFS",
2553  "HLT_xAOD__JetContainer_a4tclcwnojcalibFS",
2554  "HLT_xAOD__JetContainer_a4tclcwjesPS",
2555  "HLT_xAOD__JetContainer_a4tclcwnojcalibPS",
2556  "HLT_xAOD__JetContainer_a4TTemnojcalibFS",
2557  "HLT_xAOD__JetContainer_a4TThadnojcalibFS",
2558  "HLT_xAOD__JetContainer_a10tcemjesFS",
2559  "HLT_xAOD__JetContainer_a10tcemsubFS",
2560  "HLT_xAOD__JetContainer_a10tcemsubjesFS",
2561  "HLT_xAOD__JetContainer_a10tcemnojcalibFS",
2562  "HLT_xAOD__JetContainer_a10tcemjesPS",
2563  "HLT_xAOD__JetContainer_a10tcemnojcalibPS",
2564  "HLT_xAOD__JetContainer_a10tclcwjesFS",
2565  "HLT_xAOD__JetContainer_a10tclcwsubFS",
2566  "HLT_xAOD__JetContainer_a10tclcwsubjesFS",
2567  "HLT_xAOD__JetContainer_a10tclcwnojcalibFS",
2568  "HLT_xAOD__JetContainer_a10tclcwjesPS",
2569  "HLT_xAOD__JetContainer_a10tclcwnojcalibPS",
2570  "HLT_xAOD__JetContainer_a10TTemnojcalibFS",
2571  "HLT_xAOD__JetContainer_a10TThadnojcalibFS",
2572  "HLT_xAOD__JetContainer_a10r_tcemsubjesFS",
2573  "HLT_xAOD__JetContainer_TrigHLTJetDSSelectorCollection"};
2574  float containerSizeParameter[30] = {0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4,
2575  1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.4};
2576  int containerInputType[30] = {1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 2, 2,
2577  1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 2, 2, 1, 1};
2578  int containerSignalState[30] = {0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1,
2579  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0};
2580  bool onefilled = false;
2581 
2582  for (int icont=0; icont<30; ++icont) {
2583  //retrieve jet collection
2584  const xAOD::JetContainer* jetCont = 0;
2585  StatusCode sc = evtStore()->retrieve(jetCont, containerName[icont]) ;
2586 
2587  if (sc.isFailure()) {
2588  ATH_MSG_WARNING("REGTEST Cannot retrieve jet container");
2589  continue;
2590  }
2591 
2592  int jetContsize = jetCont->size();
2593  ATH_MSG_INFO("REGTEST Got jet container " << containerName[icont] << ", size: " << jetContsize);
2594  if (jetContsize != 0) {
2595  onefilled = true;
2596  int i = 0;
2597  for(const auto thisjet : *jetCont) {
2598  ++i;
2599  ATH_MSG_INFO( "REGTEST Looking at jet " << i);
2600  if (thisjet) {
2601  //checks jet variables
2602  ATH_MSG_DEBUG("REGTEST Checking jet variables");
2603  ATH_MSG_INFO( "REGTEST pt: " << thisjet->pt() );
2604  ATH_MSG_INFO( "REGTEST eta: " << thisjet->eta() );
2605  ATH_MSG_INFO( "REGTEST phi: " << thisjet->phi() );
2606  ATH_MSG_INFO( "REGTEST m: " << thisjet->m() );
2607  ATH_MSG_INFO( "REGTEST e: " << thisjet->e() );
2608  ATH_MSG_INFO( "REGTEST rapidity: " << thisjet->rapidity() );
2609  ATH_MSG_INFO( "REGTEST px: " << thisjet->px() );
2610  ATH_MSG_INFO( "REGTEST py: " << thisjet->py() );
2611  ATH_MSG_INFO( "REGTEST pz: " << thisjet->pz() );
2612  ATH_MSG_INFO( "REGTEST type: " << thisjet->type() );
2613  ATH_MSG_INFO( "REGTEST algorithm (kt: 0, cam: 1, antikt: 2, ...): " << thisjet->getAlgorithmType() << "; should be 2");
2614  if(thisjet->getAlgorithmType() != 2) ATH_MSG_WARNING("Jet algorithm different from container");
2615  ATH_MSG_INFO( "REGTEST size parameter: " << thisjet->getSizeParameter() << "; should be " << containerSizeParameter[icont]);
2616  if(thisjet->getSizeParameter() != containerSizeParameter[icont]) ATH_MSG_WARNING("Jet size different from container");
2617  ATH_MSG_INFO( "REGTEST input (LCTopo: 0, EMTopo: 1, TopoTower: 2, ...): " << thisjet->getInputType() << "; should be " << containerInputType[icont]);
2618  if(thisjet->getInputType() != containerInputType[icont]) ATH_MSG_WARNING("Jet input different from container");
2619  ATH_MSG_INFO( "REGTEST constituents signal state (uncalibrated: 0, calibrated: 1): " << thisjet->getConstituentsSignalState() << "; should be " << containerSignalState[icont]);
2620  if(thisjet->getConstituentsSignalState() != containerSignalState[icont]) ATH_MSG_WARNING("Jet constituents' signal state different from container");
2621  ATH_MSG_INFO( "REGTEST number of constituents: " << thisjet->numConstituents() );
2622 
2623 
2624  //checks the constituents
2625  ATH_MSG_DEBUG("REGTEST Checking jet constituents");
2626 
2627  xAOD::JetConstituentVector constitCont = thisjet->getConstituents();
2628  unsigned int constitContsize = constitCont.size();
2629  ATH_MSG_INFO("REGTEST Got constituent vector, size: " << constitContsize << "; should be " << thisjet->numConstituents());
2630  if(constitContsize != thisjet->numConstituents()) ATH_MSG_WARNING("Constituents container size different from number of constituents");
2631 
2632  if (constitContsize != 0) {
2633 // int j = 0;
2634  // for (const auto thisconstit : constitCont) {
2635  // ++j;
2636  // ATH_MSG_INFO( "REGTEST Looking at constituent " << j);
2637  // if(thisconstit){
2638  // ATH_MSG_INFO( "REGTEST constituent pt: " << thisconstit->pt() );
2639  // ATH_MSG_INFO( "REGTEST constituent eta: " << thisconstit->eta() );
2640  // ATH_MSG_INFO( "REGTEST constituent phi: " << thisconstit->phi() );
2641  // ATH_MSG_INFO( "REGTEST constituent m: " << thisconstit->m() );
2642  // ATH_MSG_INFO( "REGTEST constituent e: " << thisconstit->e() );
2643  // ATH_MSG_INFO( "REGTEST constituent type (CaloCluster: 1, Jet: 2, ...): " << thisconstit->type() );
2644  // }
2645  // else{
2646  // ATH_MSG_WARNING("REGTEST Problem with constituent pointer");
2647  // return StatusCode::SUCCESS;
2648  // }
2649  // }
2650  // ATH_MSG_INFO("REGTEST size of constituent vector == number of displayed constituents: "<< (constitContsize == j) );
2651  // if (constitContsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2652  }
2653  // else ATH_MSG_WARNING("REGTEST This jet has 0 constituents!");
2654 
2655  //checks int attributes
2656  ATH_MSG_DEBUG("REGTEST Checking int attributes");
2657  int valueint;
2658  if( thisjet->getAttribute(xAOD::JetAttribute::GhostMuonSegmentCount, valueint)) ATH_MSG_INFO("REGTEST GhostMuonSegmentCount: " << valueint);
2659  if( thisjet->getAttribute(xAOD::JetAttribute::GhostTrackCount, valueint)) ATH_MSG_INFO("REGTEST GhostTrackCount: " << valueint);
2660  if( thisjet->getAttribute(xAOD::JetAttribute::GhostTruthParticleCount, valueint)) ATH_MSG_INFO("REGTEST GhostTruthParticleCount: " << valueint);
2661  if( thisjet->getAttribute(xAOD::JetAttribute::FracSamplingMaxIndex, valueint)) ATH_MSG_INFO( "REGTEST FracSamplingMaxIndex: " << valueint);
2662 
2663 
2664  //checks float attributes
2665  ATH_MSG_DEBUG("REGTEST Checking float attributes");
2666  float value;
2667  if( thisjet->getAttribute(xAOD::JetAttribute::ActiveArea, value)) ATH_MSG_INFO( "REGTEST ActiveArea: " << value );
2668  // Four-vector type if( thisjet->getAttribute(xAOD::JetAttribute::ActiveArea4vec, value)) ATH_MSG_INFO( "REGTEST ActiveArea4vec: " << value );
2669  if( thisjet->getAttribute(xAOD::JetAttribute::AverageLArQF, value)) ATH_MSG_INFO( "REGTEST AverageLArQF: " << value );
2670  if( thisjet->getAttribute(xAOD::JetAttribute::BchCorrCell, value)) ATH_MSG_INFO( "REGTEST BchCorrCell: " << value );
2671  if( thisjet->getAttribute(xAOD::JetAttribute::BchCorrDotx, value)) ATH_MSG_INFO( "REGTEST BchCorrDotx: " << value );
2672  if( thisjet->getAttribute(xAOD::JetAttribute::BchCorrJet, value)) ATH_MSG_INFO( "REGTEST BchCorrJet: " << value );
2673  if( thisjet->getAttribute(xAOD::JetAttribute::BchCorrJetForCell, value)) ATH_MSG_INFO( "REGTEST BchCorrJetForCell: " << value );
2674  if( thisjet->getAttribute(xAOD::JetAttribute::CentroidR, value)) ATH_MSG_INFO( "REGTEST CentroidR: " << value );
2675  if( thisjet->getAttribute(xAOD::JetAttribute::HECQuality, value)) ATH_MSG_INFO( "REGTEST HECQuality: " << value );
2676  if( thisjet->getAttribute(xAOD::JetAttribute::IsoKR20Par, value)) ATH_MSG_INFO( "REGTEST IsoKR20Par: " << value );
2677  if( thisjet->getAttribute(xAOD::JetAttribute::IsoKR20Perp, value)) ATH_MSG_INFO( "REGTEST IsoKR20Perp: " << value );
2678  // ElementLink<DataVector<xAOD::Vertex> > type if( thisjet->getAttribute(xAOD::JetAttribute::HighestJVFVtx, value)) ATH_MSG_INFO( "REGTEST HighestJVFVtx: " << value );
2679  // ??? type if( thisjet->getAttribute(xAOD::JetAttribute::JetLabel, value)) ATH_MSG_INFO( "REGTEST JetLabel: " << value );
2680  if( thisjet->getAttribute(xAOD::JetAttribute::KtDR, value)) ATH_MSG_INFO( "REGTEST KtDR: " << value );
2681  if( thisjet->getAttribute(xAOD::JetAttribute::LArBadHVEnergy, value)) ATH_MSG_INFO( "REGTEST LArBadHVEnergy: " << value );
2682  if( thisjet->getAttribute(xAOD::JetAttribute::LArBadHVRatio, value)) ATH_MSG_INFO( "REGTEST LArBadHVRatio: " << value );
2683  if( thisjet->getAttribute(xAOD::JetAttribute::LArQuality, value)) ATH_MSG_INFO( "REGTEST LArQuality: " << value );
2684  if( thisjet->getAttribute(xAOD::JetAttribute::NegativeE, value)) ATH_MSG_INFO( "REGTEST NegativeE: " << value );
2685  // no tools available yet if( thisjet->getAttribute(xAOD::JetAttribute::NumTowers, value)) ATH_MSG_INFO( "REGTEST NumTowers: " << value );
2686  if( thisjet->getAttribute(xAOD::JetAttribute::SamplingMax, value)) ATH_MSG_INFO( "REGTEST SamplingMax: " << value );
2687  if( thisjet->getAttribute(xAOD::JetAttribute::Timing, value)) ATH_MSG_INFO( "REGTEST Timing: " << value );
2688  if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiArea, value)) ATH_MSG_INFO( "REGTEST VoronoiArea: " << value );
2689  if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiAreaE, value)) ATH_MSG_INFO( "REGTEST VoronoiAreaE: " << value );
2690  if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiAreaPx, value)) ATH_MSG_INFO( "REGTEST VoronoiAreaPx: " << value );
2691  if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiAreaPy, value)) ATH_MSG_INFO( "REGTEST VoronoiAreaPy: " << value );
2692  if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiAreaPz, value)) ATH_MSG_INFO( "REGTEST VoronoiAreaPz: " << value );
2693  if( thisjet->getAttribute(xAOD::JetAttribute::Width, value)) ATH_MSG_INFO( "REGTEST WIDTH: " << value );
2694  if( thisjet->getAttribute(xAOD::JetAttribute::FracSamplingMax, value)) ATH_MSG_INFO( "REGTEST FracSamplingMax: " << value );
2695  if( thisjet->getAttribute(xAOD::JetAttribute::EMFrac, value)) ATH_MSG_INFO( "REGTEST EMFrac: " << value );
2696  if( thisjet->getAttribute(xAOD::JetAttribute::HECFrac, value)) ATH_MSG_INFO( "REGTEST HECFrac: " << value );
2697  if( thisjet->getAttribute(xAOD::JetAttribute::isBadLoose, value)) ATH_MSG_INFO( "REGTEST isBadLoose: " << value );
2698  if( thisjet->getAttribute(xAOD::JetAttribute::isBadMedium, value)) ATH_MSG_INFO( "REGTEST isBadMedium: " << value );
2699  if( thisjet->getAttribute(xAOD::JetAttribute::isBadTight, value)) ATH_MSG_INFO( "REGTEST isBadTight: " << value );
2700  // unknown attribute if( thisjet->getAttribute(xAOD::JetAttribute::isUgly, value)) ATH_MSG_INFO( "REGTEST isUgly: " << value );
2701  if( thisjet->getAttribute(xAOD::JetAttribute::N90Constituents, value)) ATH_MSG_INFO( "REGTEST N90Constituents: " << value );
2702  if( thisjet->getAttribute(xAOD::JetAttribute::N90Cells, value)) ATH_MSG_INFO( "REGTEST N90Cells: " << value );
2703  if( thisjet->getAttribute(xAOD::JetAttribute::OotFracClusters10, value)) ATH_MSG_INFO( "REGTEST OotFracClusters10: " << value );
2704  if( thisjet->getAttribute(xAOD::JetAttribute::OotFracClusters5, value)) ATH_MSG_INFO( "REGTEST OotFracClusters5: " << value );
2705  if( thisjet->getAttribute(xAOD::JetAttribute::OotFracCells5, value)) ATH_MSG_INFO( "REGTEST OotFracCells5: " << value );
2706  if( thisjet->getAttribute(xAOD::JetAttribute::OotFracCells10, value)) ATH_MSG_INFO( "REGTEST OotFracCells10: " << value );
2707  if( thisjet->getAttribute(xAOD::JetAttribute::PtTruth, value)) ATH_MSG_INFO( "REGTEST PtTruth: " << value );
2708  if( thisjet->getAttribute(xAOD::JetAttribute::Tau1, value)) ATH_MSG_INFO( "REGTEST Tau1: " << value );
2709  if( thisjet->getAttribute(xAOD::JetAttribute::Tau2, value)) ATH_MSG_INFO( "REGTEST Tau2: " << value );
2710  if( thisjet->getAttribute(xAOD::JetAttribute::Tau3, value)) ATH_MSG_INFO( "REGTEST Tau3: " << value );
2711  // unknown attribute if( thisjet->getAttribute(xAOD::JetAttribute::Split12, value)) ATH_MSG_INFO( "REGTEST Split12: " << value );
2712  // unknown attribute if( thisjet->getAttribute(xAOD::JetAttribute::Split23, value)) ATH_MSG_INFO( "REGTEST Split23: " << value );
2713  // unknown attribute if( thisjet->getAttribute(xAOD::JetAttribute::Split34, value)) ATH_MSG_INFO( "REGTEST Split34: " << value );
2714  if( thisjet->getAttribute(xAOD::JetAttribute::Dip12, value)) ATH_MSG_INFO( "REGTEST Dip12: " << value );
2715  if( thisjet->getAttribute(xAOD::JetAttribute::Dip13, value)) ATH_MSG_INFO( "REGTEST Dip13: " << value );
2716  if( thisjet->getAttribute(xAOD::JetAttribute::Dip23, value)) ATH_MSG_INFO( "REGTEST Dip23: " << value );
2717  if( thisjet->getAttribute(xAOD::JetAttribute::DipExcl12, value)) ATH_MSG_INFO( "REGTEST DipExcl12: " << value );
2718  if( thisjet->getAttribute(xAOD::JetAttribute::ThrustMin, value)) ATH_MSG_INFO( "REGTEST ThrustMin: " << value );
2719  if( thisjet->getAttribute(xAOD::JetAttribute::ThrustMaj, value)) ATH_MSG_INFO( "REGTEST ThrustMaj: " << value );
2720  if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram0, value)) ATH_MSG_INFO( "REGTEST FoxWolfram0: " << value );
2721  if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram1, value)) ATH_MSG_INFO( "REGTEST FoxWolfram1: " << value );
2722  if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram2, value)) ATH_MSG_INFO( "REGTEST FoxWolfram2: " << value );
2723  if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram3, value)) ATH_MSG_INFO( "REGTEST FoxWolfram3: " << value );
2724  if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram4, value)) ATH_MSG_INFO( "REGTEST FoxWolfram4: " << value );
2725  if( thisjet->getAttribute(xAOD::JetAttribute::Sphericity, value)) ATH_MSG_INFO( "REGTEST Sphericity: " << value );
2726  if( thisjet->getAttribute(xAOD::JetAttribute::Aplanarity, value)) ATH_MSG_INFO( "REGTEST Aplanarity: " << value );
2727 
2728  //checks vector<int> attributes
2729  ATH_MSG_DEBUG("REGTEST Checking vector<int> attributes");
2730  std::vector<int> vecvalueint;
2731  if (thisjet->getAttribute(xAOD::JetAttribute::NumTrkPt1000, vecvalueint)) {
2732  int vecsize = vecvalueint.size();
2733  ATH_MSG_INFO("REGTEST Got NumTrkPt1000 vector, size: " << vecsize);
2734  if (vecsize != 0) {
2735  int j = 0;
2736  for(const auto & thisvalue : vecvalueint){
2737  ++j;
2738  ATH_MSG_INFO("REGTEST NumTrkPt1000 #" << j << ": " << thisvalue);
2739  }
2740  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2741  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2742  }
2743  }
2744  if (thisjet->getAttribute(xAOD::JetAttribute::NumTrkPt500, vecvalueint)) {
2745  int vecsize = vecvalueint.size();
2746  ATH_MSG_INFO("REGTEST Got Got NumTrkPt500 vector, size: " << vecsize);
2747  if (vecsize != 0) {
2748  int j = 0;
2749  for(const auto & thisvalue : vecvalueint){
2750  ++j;
2751  ATH_MSG_INFO("REGTEST NumTrkPt500 #" << j << ": " << thisvalue);
2752  }
2753  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2754  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2755  }
2756  }
2757 
2758  //checks vector<float> attributes
2759  ATH_MSG_DEBUG("REGTEST Checking vector<float> attributes");
2760  std::vector<float> vecvalue;
2761  if (thisjet->getAttribute(xAOD::JetAttribute::JVF, vecvalue)) {
2762  int vecsize = vecvalue.size();
2763  ATH_MSG_INFO("REGTEST Got JVF vector, size: " << vecsize);
2764  if (vecsize != 0) {
2765  int j = 0;
2766  for(const auto & thisvalue : vecvalue){
2767  ++j;
2768  ATH_MSG_INFO("REGTEST JVF #" << j << ": " << thisvalue);
2769  }
2770  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2771  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2772  }
2773  }
2774  if (thisjet->getAttribute(xAOD::JetAttribute::SumPtTrkPt1000, vecvalue)) {
2775  int vecsize = vecvalue.size();
2776  ATH_MSG_INFO("REGTEST Got SumPtTrkPt1000 vector, size: " << vecsize);
2777  if (vecsize != 0) {
2778  int j = 0;
2779  for(const auto & thisvalue : vecvalue){
2780  ++j;
2781  ATH_MSG_INFO("REGTEST SumPtTrkPt1000 #" << j << ": " << thisvalue);
2782  }
2783  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2784  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2785  }
2786  }
2787  if (thisjet->getAttribute(xAOD::JetAttribute::SumPtTrkPt500, vecvalue)) {
2788  int vecsize = vecvalue.size();
2789  ATH_MSG_INFO("REGTEST Got SumPtTrkPt500 vector, size: " << vecsize);
2790  if (vecsize != 0) {
2791  int j = 0;
2792  for(const auto & thisvalue : vecvalue){
2793  ++j;
2794  ATH_MSG_INFO("REGTEST SumPtTrkPt500 #" << j << ": " << thisvalue);
2795  }
2796  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2797  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2798  }
2799  }
2800  if (thisjet->getAttribute(xAOD::JetAttribute::TrackWidthPt1000, vecvalue)) {
2801  int vecsize = vecvalue.size();
2802  ATH_MSG_INFO("REGTEST Got TrackWidthPt1000 vector, size: " << vecsize);
2803  if (vecsize != 0) {
2804  int j = 0;
2805  for(const auto & thisvalue : vecvalue){
2806  ++j;
2807  ATH_MSG_INFO("REGTEST TrackWidthPt1000 #" << j << ": " << thisvalue);
2808  }
2809  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2810  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2811  }
2812  }
2813  if (thisjet->getAttribute(xAOD::JetAttribute::TrackWidthPt500, vecvalue)) {
2814  int vecsize = vecvalue.size();
2815  ATH_MSG_INFO("REGTEST Got TrackWidthPt500 vector, size: " << vecsize);
2816  if (vecsize != 0) {
2817  int j = 0;
2818  for(const auto & thisvalue : vecvalue){
2819  ++j;
2820  ATH_MSG_INFO("REGTEST TrackWidthPt500 #" << j << ": " << thisvalue);
2821  }
2822  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2823  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2824  }
2825  }
2826  if (thisjet->getAttribute(xAOD::JetAttribute::EnergyPerSampling, vecvalue)) {
2827  int vecsize = vecvalue.size();
2828  ATH_MSG_INFO("REGTEST Got EnergyPerSampling vector, size: " << vecsize);
2829  if (vecsize != 0) {
2830  int j = 0;
2831  for(const auto & thisvalue : vecvalue){
2832  ++j;
2833  ATH_MSG_INFO("REGTEST EnergyPerSampling #" << j << ": " << thisvalue);
2834  }
2835  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2836  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2837  }
2838  }
2839 
2840 
2841  //checks associated objects
2842  // ATH_MSG_DEBUG("REGTEST Checking associated objects");
2843  // std::vector<const xAOD::TrackParticle*> track;
2844  // if( thisjet->getAssociatedObjects(xAOD::JetAttribute::GhostTrack, track) ){
2845  // int vecsize = track.size();
2846  // ATH_MSG_INFO("REGTEST Got GhostTrack vector, size: " << vecsize);
2847  // if (vecsize != 0) {
2848  // int j = 0;
2849  // for(const auto & thistrack : track){
2850  // ++j;
2851  // //checks only one associated variable, just making sure getting the object worked
2852  // if (thistrack) ATH_MSG_INFO("REGTEST z0 for GhostTrack #" << j << ": " << thistrack->z0());
2853  // else{
2854  // ATH_MSG_WARNING("REGTEST Problem with attribute pointer");
2855  // return StatusCode::SUCCESS;
2856  // }
2857  // }
2858  // ATH_MSG_INFO("REGTEST size of associated object vector == number of displayed attributes: " << (vecsize == j) );
2859  // if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this associated object");
2860  // }
2861  // }
2862  }
2863  else{
2864  ATH_MSG_WARNING("REGTEST Problem with jet pointer");
2865  return StatusCode::SUCCESS;
2866  }
2867  }
2868 
2869  if (jetContsize == i) ATH_MSG_INFO("REGTEST size of jet container == number of displayed jets: " << (jetContsize == i) );
2870  else ATH_MSG_WARNING("REGTEST Problem with displaying jets");
2871  }
2872  }
2873 
2874  if (!onefilled) ATH_MSG_DEBUG("There was no filled jet containers");
2875 
2876  ATH_MSG_INFO("REGTEST ==========END of xAOD::JetContainer DUMP===========");
2877 
2878  ATH_MSG_DEBUG("leaving dumpxAODJetContainer()");
2879 
2880  return StatusCode::SUCCESS;
2881 }
2882 
2883 
2885 
2886 StatusCode TrigEDMChecker::dumpTrigEFBjetContainer ATLAS_NOT_THREAD_SAFE() {
2887 
2888  ATH_MSG_DEBUG("in dumpTrigEFBjetContainer()");
2889  ATH_MSG_INFO("REGTEST ==========START of TrigEFBjetContainer DUMP===========");
2890 
2893 
2894  StatusCode sc = evtStore()->retrieve(trigEFBjet,lastTrigEFBjet);
2895  if (sc.isFailure()) {
2896  ATH_MSG_INFO("REGTEST No TrigEFBjetContainer found");
2897  return StatusCode::SUCCESS;
2898  }
2899  ATH_MSG_INFO("REGTEST TrigEFBjetContainers retrieved");
2900 
2901 
2902  for (int i=0; trigEFBjet != lastTrigEFBjet; ++trigEFBjet, ++i) {
2903 
2904  ATH_MSG_INFO("REGTEST Looking at TrigEFBjetContainer " << i);
2905 
2906  TrigEFBjetContainer::const_iterator EFBjetItr = trigEFBjet->begin();
2907  TrigEFBjetContainer::const_iterator EFBjetItrE = trigEFBjet->end();
2908 
2909  for (int j=0; EFBjetItr != EFBjetItrE; ++EFBjetItr, ++j ) {
2910 
2911  ATH_MSG_INFO("REGTEST Looking at TrigEFBjet " << j);
2912 
2913  ATH_MSG_INFO("REGTEST TrigEFBjet->prmVtx() returns " << (*EFBjetItr)->prmVtx());
2914  ATH_MSG_INFO("REGTEST TrigEFBjet->xComb() returns " << (*EFBjetItr)->xComb());
2915  // mLog <<MSG::INFO << "REGTEST TrigEFBjet->x2D() returns " << (*EFBjetItr)->x2D() << endmsg;
2916  ATH_MSG_INFO("REGTEST TrigEFBjet->xIP1D() returns " << (*EFBjetItr)->xIP1D());
2917  ATH_MSG_INFO("REGTEST TrigEFBjet->isValid() returns " << (*EFBjetItr)->isValid());
2918  ATH_MSG_INFO("REGTEST TrigEFBjet->roiId() returns " << (*EFBjetItr)->roiId());
2919  // mLog <<MSG::INFO << "REGTEST TrigEFBjet->xD0() returns " << (*EFBjetItr)->xD0() << endmsg;
2920  ATH_MSG_INFO("REGTEST TrigEFBjet->xIP2D() returns " << (*EFBjetItr)->xIP2D());
2921  // mLog <<MSG::INFO << "REGTEST TrigEFBjet->xZ0() returns " << (*EFBjetItr)->xZ0() << endmsg;
2922  ATH_MSG_INFO("REGTEST TrigEFBjet->xIP3D() returns " << (*EFBjetItr)->xIP3D());
2923  // new one:
2924  ATH_MSG_INFO("REGTEST TrigEFBjet->xCHI2() returns " << (*EFBjetItr)->xCHI2());
2925  // mLog <<MSG::INFO << "REGTEST TrigEFBjet->x3D() returns " << (*EFBjetItr)->x3D() << endmsg; // replaced by :
2926  ATH_MSG_INFO("REGTEST TrigEFBjet->xSV() returns " << (*EFBjetItr)->xSV());
2927  //
2928  ATH_MSG_INFO("REGTEST TrigEFBjet->xMVtx() returns " << (*EFBjetItr)->xMVtx());
2929  ATH_MSG_INFO("REGTEST TrigEFBjet->xEVtx() returns " << (*EFBjetItr)->xEVtx());
2930  ATH_MSG_INFO("REGTEST TrigEFBjet-> xNVtx() returns " << (*EFBjetItr)-> xNVtx());
2931  }
2932  }
2933  ATH_MSG_INFO("REGTEST ==========END of TrigEFBjetContainer DUMP===========");
2934  ATH_MSG_DEBUG("dumpTrigEFBjetContainer() succeeded");
2935 
2936  return StatusCode::SUCCESS;
2937 }
2938 
2939 
2941 
2942 StatusCode TrigEDMChecker::dumpTrigL2BjetContainer ATLAS_NOT_THREAD_SAFE() {
2943 
2944  ATH_MSG_DEBUG("in dumpTrigL2BjetContainer()");
2945  ATH_MSG_INFO("REGTEST ==========START of TrigL2BjetContainer DUMP===========");
2946 
2949 
2950  StatusCode sc = evtStore()->retrieve(trigL2Bjet,lastTrigL2Bjet);
2951  if (sc.isFailure()) {
2952  ATH_MSG_INFO("REGTEST No TrigL2BjetContainer found");
2953  return StatusCode::SUCCESS;
2954  }
2955  ATH_MSG_INFO("REGTEST TrigL2BjetContainers retrieved");
2956 
2957 
2958  for (int i=0; trigL2Bjet != lastTrigL2Bjet; ++trigL2Bjet, ++i) {
2959 
2960  ATH_MSG_INFO("REGTEST Looking at TrigL2BjetContainer " << i);
2961 
2962  TrigL2BjetContainer::const_iterator L2BjetItr = trigL2Bjet->begin();
2963  TrigL2BjetContainer::const_iterator L2BjetItrE = trigL2Bjet->end();
2964 
2965  for (int j=0; L2BjetItr != L2BjetItrE; ++L2BjetItr, ++j ) {
2966 
2967  ATH_MSG_INFO("REGTEST Looking at TrigL2Bjet " << j);
2968  ATH_MSG_INFO("REGTEST TrigL2Bjet->prmVtx() returns " << (*L2BjetItr)->prmVtx());
2969  ATH_MSG_INFO("REGTEST TrigL2Bjet->xComb() returns " << (*L2BjetItr)->xComb());
2970  // ATH_MSG_INFO("REGTEST TrigL2Bjet->x2D() returns " << (*L2BjetItr)->x2D());
2971  ATH_MSG_INFO("REGTEST TrigL2Bjet->xIP1D() returns " << (*L2BjetItr)->xIP1D());
2972  ATH_MSG_INFO("REGTEST TrigL2Bjet->isValid() returns " << (*L2BjetItr)->isValid());
2973  ATH_MSG_INFO("REGTEST TrigL2Bjet->roiId() returns " << (*L2BjetItr)->roiId());
2974  // ATH_MSG_INFO("REGTEST TrigL2Bjet->xD0() returns " << (*L2BjetItr)->xD0());
2975  ATH_MSG_INFO("REGTEST TrigL2Bjet->xIP2D() returns " << (*L2BjetItr)->xIP2D());
2976  // ATH_MSG_INFO("REGTEST TrigL2Bjet->xZ0() returns " << (*L2BjetItr)->xZ0());
2977  ATH_MSG_INFO("REGTEST TrigL2Bjet->xIP3D() returns " << (*L2BjetItr)->xIP3D());
2978  // new one:
2979  ATH_MSG_INFO("REGTEST TrigL2Bjet->xCHI2() returns " << (*L2BjetItr)->xCHI2());
2980  // ATH_MSG_INFO("REGTEST TrigL2Bjet->x3D() returns " << (*L2BjetItr)->x3D());
2981  ATH_MSG_INFO("REGTEST TrigL2Bjet->xSV() returns " << (*L2BjetItr)->xSV());
2982  ATH_MSG_INFO("REGTEST TrigL2Bjet->xMVtx() returns " << (*L2BjetItr)->xMVtx());
2983  ATH_MSG_INFO("REGTEST TrigL2Bjet->xEVtx() returns " << (*L2BjetItr)->xEVtx());
2984  ATH_MSG_INFO("REGTEST TrigL2Bjet-> xNVtx() returns " << (*L2BjetItr)-> xNVtx());
2985  }
2986  }
2987  ATH_MSG_INFO("REGTEST ==========END of TrigL2BjetContainer DUMP===========");
2988  ATH_MSG_DEBUG("dumpTrigL2BjetContainer() succeeded");
2989 
2990  return StatusCode::SUCCESS;
2991 }
2992 
2994 
2995 StatusCode TrigEDMChecker::dumpMuonFeature ATLAS_NOT_THREAD_SAFE() {
2996 
2997  ATH_MSG_DEBUG("in dumpMuonFeature()");
2998 
2999  ATH_MSG_INFO("REGTEST ==========START of MuonFeature DUMP===========");
3000 
3002  SG::ConstIterator< MuonFeature > lastMuFeature;
3003 
3004  StatusCode sc = evtStore()->retrieve(MuFeature,lastMuFeature);
3005  if (sc.isFailure()) {
3006  ATH_MSG_INFO("REGTEST No MuonFeature found");
3007  return StatusCode::SUCCESS;
3008  }
3009  ATH_MSG_INFO("REGTEST MuonFeature retrieved");
3010 
3011 
3012  for (int i=0; MuFeature != lastMuFeature; ++MuFeature, ++i) {
3013 
3014  const MuonFeature* thisMuFeature = &(*MuFeature);
3015 
3016  ATH_MSG_INFO("REGTEST Looking at MuonFeature " << i);
3017  ATH_MSG_INFO("REGTEST MuonFeature->roiId() returns " << thisMuFeature->roiId());
3018  ATH_MSG_INFO("REGTEST MuonFeature->eta() returns " << thisMuFeature->eta());
3019  ATH_MSG_INFO("REGTEST MuonFeature->phi() returns " << thisMuFeature->phi());
3020  ATH_MSG_INFO("REGTEST MuonFeature->saddress() returns " << thisMuFeature->saddress());
3021  ATH_MSG_INFO("REGTEST MuonFeature->pt() returns " << thisMuFeature->pt());
3022  ATH_MSG_INFO("REGTEST MuonFeature->radius() returns " << thisMuFeature->radius());
3023  ATH_MSG_INFO("REGTEST MuonFeature->dir_phi() returns " << thisMuFeature->dir_phi());
3024  ATH_MSG_INFO("REGTEST MuonFeature->zeta() returns " << thisMuFeature->zeta());
3025  ATH_MSG_INFO("REGTEST MuonFeature->dir_zeta() returns " << thisMuFeature->dir_zeta());
3026  ATH_MSG_INFO("REGTEST MuonFeature->beta() returns " << thisMuFeature->beta());
3027  }
3028 
3029  ATH_MSG_INFO("REGTEST ==========END of MuonFeature DUMP===========");
3030  ATH_MSG_DEBUG("dumpMuonFeature() succeeded");
3031 
3032  return StatusCode::SUCCESS;
3033 }
3034 
3036 
3037 StatusCode TrigEDMChecker::dumpCombinedMuonFeature ATLAS_NOT_THREAD_SAFE() {
3038 
3039  ATH_MSG_DEBUG("in dumpCombinedMuonFeature()");
3040 
3041  ATH_MSG_INFO("REGTEST ==========START of CombinedMuonFeature DUMP===========");
3042 
3045 
3046  StatusCode sc = evtStore()->retrieve(CombMuon,lastCombMuon);
3047  if (sc.isFailure()) {
3048  ATH_MSG_INFO("REGTEST No CombinedMuonFeature found");
3049  return StatusCode::SUCCESS;
3050  }
3051  ATH_MSG_INFO("REGTEST CombinedMuonFeatures retrieved");
3052 
3053  for (int i=0; CombMuon != lastCombMuon; ++CombMuon, ++i) {
3054 
3055  const CombinedMuonFeature* thisCombMuFeature = &(*CombMuon);
3056 
3057  ATH_MSG_INFO("REGTEST Looking at CombinedMuonFeature " << i);
3058  ATH_MSG_INFO("REGTEST TrigPhoton->pt() returns " << (thisCombMuFeature)->pt());
3059  ATH_MSG_INFO("REGTEST TrigPhoton->sigma_pt() returns " << (thisCombMuFeature)->sigma_pt());
3060  ATH_MSG_INFO("REGTEST MuonFeature info: ");
3061  // if ((thisCombMuFeature)->muFastTrack()) {
3062  if ((thisCombMuFeature)->muFastTrackLink().isValid() ) {
3063  ATH_MSG_INFO("REGTEST muFastTrack->eta() returns " << (thisCombMuFeature)->muFastTrack()->eta());
3064  ATH_MSG_INFO("REGTEST muFastTrack->phi() returns " << (thisCombMuFeature)->muFastTrack()->phi());
3065  ATH_MSG_INFO("REGTEST muFastTrack->radius() returns " << (thisCombMuFeature)->muFastTrack()->radius());
3066  ATH_MSG_INFO("REGTEST muFastTrack->zeta() returns " << (thisCombMuFeature)->muFastTrack()->zeta());
3067  } else {
3068  ATH_MSG_INFO("CombinedMuonFeature has no muFastTrack" );
3069  }
3070 
3071  ATH_MSG_INFO("REGTEST TrigInDetTrack info: ");
3072  // if ((thisCombMuFeature)->IDTrack()) {
3073  if ((thisCombMuFeature)->IDTrackLink().isValid() ) {
3074  ATH_MSG_INFO("REGTEST IDTrack->algorithmId() returns " <<(thisCombMuFeature)->IDTrack()->algorithmId());
3075  ATH_MSG_INFO("REGTEST IDTrack->chi2() returns " << (thisCombMuFeature)->IDTrack()->chi2());
3076  ATH_MSG_INFO("REGTEST IDTrack->NStrawHits() returns " <<(thisCombMuFeature)->IDTrack()->NStrawHits());
3077  ATH_MSG_INFO("REGTEST IDTrack->NStraw() returns " << (thisCombMuFeature)->IDTrack()->NStraw());
3078  ATH_MSG_INFO("REGTEST IDTrack->NStrawTime() returns " <<(thisCombMuFeature)->IDTrack()->NStrawTime());
3079  ATH_MSG_INFO("REGTEST IDTrack->NTRHits() returns " <<(thisCombMuFeature)->IDTrack()->NTRHits());
3080  } else {
3081  ATH_MSG_INFO("CombinedMuonFeature has no IDTrack" );
3082  }
3083 
3084  }
3085 
3086  ATH_MSG_INFO("REGTEST ==========END of CombinedMuonFeature DUMP===========");
3087  ATH_MSG_DEBUG("dumpCombinedMuonFeature() succeeded");
3088 
3089  return StatusCode::SUCCESS;
3090 }
3091 
3092 StatusCode TrigEDMChecker::dumpCombinedMuonFeatureContainer ATLAS_NOT_THREAD_SAFE() {
3093 
3094  ATH_MSG_DEBUG("in dumpCombinedMuonFeatureContainer()");
3095  ATH_MSG_INFO("REGTEST ==========START of CombinedMuonFeatureContainer DUMP===========");
3096 
3099 
3100  StatusCode sc = evtStore()->retrieve(CombMuon,lastCombMuon);
3101  if (sc.isFailure()) {
3102  ATH_MSG_INFO("REGTEST No CombinedMuonFeatureContainer found");
3103  return StatusCode::SUCCESS;
3104  }
3105  ATH_MSG_INFO("REGTEST CombinedMuonFeaturesContainer retrieved");
3106 
3107  for (int j=0; CombMuon != lastCombMuon; ++CombMuon, ++j) {
3108  ATH_MSG_INFO("REGTEST Looking at CombinedMuonFeatureContainer " << j);
3109 
3110  const CombinedMuonFeatureContainer* container = &(*CombMuon);
3112 
3113  int i = 0;
3114  for ( muon = container->begin() ; muon != container->end(); ++i, ++muon ) {
3115  const CombinedMuonFeature* thisCombMuFeature = *muon;
3116  ATH_MSG_INFO("REGTEST Looking at CombinedMuonFeature " << i);
3117 
3118  ATH_MSG_INFO("REGTEST CombinedMuonFeature->pt() returns " << (thisCombMuFeature)->pt());
3119  ATH_MSG_INFO("REGTEST CombinedMuonFeature->sigma_pt() returns " << (thisCombMuFeature)->sigma_pt());
3120 
3121  ATH_MSG_INFO("REGTEST MuonFeature info: ");
3122  if ( thisCombMuFeature->muFastTrackLink().isValid() ) {
3123  ATH_MSG_INFO("REGTEST muFastTrack->eta() returns " << (thisCombMuFeature)->muFastTrack()->eta());
3124  ATH_MSG_INFO("REGTEST muFastTrack->phi() returns " << (thisCombMuFeature)->muFastTrack()->phi());
3125  ATH_MSG_INFO("REGTEST muFastTrack->radius() returns " << (thisCombMuFeature)->muFastTrack()->radius());
3126  ATH_MSG_INFO("REGTEST muFastTrack->zeta() returns " << (thisCombMuFeature)->muFastTrack()->zeta());
3127  } else {
3128  ATH_MSG_WARNING("MuonFeature has no muFastTrack!" );
3129  }
3130 
3131  ATH_MSG_INFO("REGTEST TrigInDetTrack info: ");
3132  if ( thisCombMuFeature->IDTrackLink().isValid() ) {
3133  ATH_MSG_INFO("REGTEST IDTrack->algorithmId() returns " <<(thisCombMuFeature)->IDTrack()->algorithmId());
3134  ATH_MSG_INFO("REGTEST IDTrack->chi2() returns " << (thisCombMuFeature)->IDTrack()->chi2());
3135  ATH_MSG_INFO("REGTEST IDTrack->NStrawHits() returns " <<(thisCombMuFeature)->IDTrack()->NStrawHits());
3136 
3137  ATH_MSG_INFO("REGTEST IDTrack->NStraw() returns " << (thisCombMuFeature)->IDTrack()->NStraw());
3138  ATH_MSG_INFO("REGTEST IDTrack->NStrawTime() returns " <<(thisCombMuFeature)->IDTrack()->NStrawTime());
3139  ATH_MSG_INFO("REGTEST IDTrack->NTRHits() returns " <<(thisCombMuFeature)->IDTrack()->NTRHits());
3140  } else {
3141  ATH_MSG_WARNING("MuonFeature has no IDTrack!" );
3142  }
3143 
3144  }
3145  }
3146  return StatusCode::SUCCESS;
3147 }
3148 
3150 
3151 StatusCode TrigEDMChecker::dumpTrigEMCluster ATLAS_NOT_THREAD_SAFE() {
3152 
3153  ATH_MSG_DEBUG("in dumpTrigEMCluster()");
3154  ATH_MSG_INFO("REGTEST ==========START of TrigEMCluster DUMP===========");
3155 
3157  SG::ConstIterator< TrigEMCluster > lastEMCluster;
3158 
3159  StatusCode sc = evtStore()->retrieve(EMCluster,lastEMCluster);
3160  if (sc.isFailure()) {
3161  ATH_MSG_INFO("REGTEST No TrigEMCluster found");
3162  return StatusCode::SUCCESS;
3163  }
3164  ATH_MSG_INFO("REGTEST TrigEMCluster retrieved");
3165 
3166  for (int i=0; EMCluster != lastEMCluster; ++EMCluster, ++i) {
3167 
3168  const TrigEMCluster* thisEMCluster = &(*EMCluster);
3169 
3170  ATH_MSG_INFO("REGTEST Looking at TrigEMCluster " << i);
3171 
3172  ATH_MSG_INFO("REGTEST TrigEMCluster->energy() returns " << thisEMCluster->energy());
3173  ATH_MSG_INFO("REGTEST TrigEMCluster->e() returns " << thisEMCluster->e());
3174  ATH_MSG_INFO("REGTEST TrigEMCluster->phi() returns " << thisEMCluster->phi());
3175 
3176  ATH_MSG_INFO("REGTEST TrigEMCluster->eta() returns " << thisEMCluster->eta());
3177  ATH_MSG_INFO("REGTEST TrigEMCluster->e237() returns " << thisEMCluster->e237());
3178  ATH_MSG_INFO("REGTEST TrigEMCluster->e277() returns " << thisEMCluster->e277());
3179  ATH_MSG_INFO("REGTEST TrigEMCluster->fracs1() returns " << thisEMCluster->fracs1());
3180  ATH_MSG_INFO("REGTEST TrigEMCluster->weta2() returns " << thisEMCluster->weta2());
3181  ATH_MSG_INFO("REGTEST TrigEMCluster->ehad1() returns " << thisEMCluster->ehad1());
3182  ATH_MSG_INFO("REGTEST TrigEMCluster->Eta1() returns " << thisEMCluster->Eta1());
3183  }
3184 
3185  ATH_MSG_INFO("REGTEST ==========END of TrigEMCluster DUMP===========");
3186  ATH_MSG_DEBUG("dumpTrigEMCluster() succeeded");
3187 
3188  return StatusCode::SUCCESS;
3189 }
3190 
3191 StatusCode TrigEDMChecker::dumpxAODTrigEMCluster ATLAS_NOT_THREAD_SAFE() {
3192 
3193  ATH_MSG_DEBUG("in dumpxAODTrigEMCluster()");
3194 
3195  ATH_MSG_INFO("REGTEST ==========START of TrigEMCluster DUMP===========");
3196 
3199 
3200  StatusCode sc = evtStore()->retrieve(EMCluster,lastEMCluster);
3201  if (sc.isFailure()) {
3202  ATH_MSG_INFO("REGTEST No xAOD::TrigEMCluster found");
3203  return StatusCode::SUCCESS;
3204  }
3205  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster retrieved");
3206 
3207 
3208  for (int i=0; EMCluster != lastEMCluster; ++EMCluster, ++i) {
3209 
3210  const xAOD::TrigEMCluster* thisEMCluster = &(*EMCluster);
3211 
3212  ATH_MSG_INFO("REGTEST Looking at xAOD::TrigEMCluster " << i);
3213 
3214  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->energy() returns " << thisEMCluster->energy());
3215  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->e() returns " << thisEMCluster->energy());
3216  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->phi() returns " << thisEMCluster->phi());
3217 
3218  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->eta() returns " << thisEMCluster->eta());
3219  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->e237() returns " << thisEMCluster->e237());
3220  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->e277() returns " << thisEMCluster->e277());
3221  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->fracs1() returns " << thisEMCluster->fracs1());
3222  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->weta2() returns " << thisEMCluster->weta2());
3223  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->ehad1() returns " << thisEMCluster->ehad1());
3224  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->Eta1() returns " << thisEMCluster->eta1());
3225  }
3226 
3227  ATH_MSG_INFO("REGTEST ==========END of xAOD::TrigEMCluster DUMP===========");
3228  ATH_MSG_DEBUG("dumpxAODTrigEMCluster() succeeded");
3229 
3230  return StatusCode::SUCCESS;
3231 }
3232 
3234 
3235 StatusCode TrigEDMChecker::dumpTrigTauClusterContainer ATLAS_NOT_THREAD_SAFE() {
3236 
3237  ATH_MSG_DEBUG("in dumpTrigTauClusterContainer()");
3238 
3239  ATH_MSG_INFO("REGTEST ==========START of TrigTauClusterContainer/TrigTauClusterDetailsContainer DUMP===========");
3240 
3243 
3244  StatusCode sc = evtStore()->retrieve(TauCluster,lastTauCluster);
3245  if (sc.isFailure()) {
3246  ATH_MSG_INFO("REGTEST No TrigTauClusterContainer found");
3247  return StatusCode::SUCCESS;
3248  }
3249  ATH_MSG_INFO("REGTEST TrigTauClusterContainer retrieved");
3250 
3251 
3252  int nClusters = 0;
3253  for (int i=0; TauCluster != lastTauCluster; ++TauCluster, ++i) {
3254 
3255  ATH_MSG_INFO("REGTEST Looking at TrigTauClusterContainer " << i);
3256 
3257  TrigTauClusterContainer::const_iterator TauClusterItr = TauCluster->begin();
3258  TrigTauClusterContainer::const_iterator TauClusterItrE = TauCluster->end();
3259 
3260  for (int j=0; TauClusterItr != TauClusterItrE; ++TauClusterItr, ++j ) {
3261  nClusters++;
3262  ATH_MSG_INFO("REGTEST Looking at TrigTauCluster " << j);
3263 
3264  ATH_MSG_INFO("REGTEST TrigTauCluster->energy() returns " << (*TauClusterItr)->energy());
3265  ATH_MSG_INFO("REGTEST TrigTauCluster->et() returns " << (*TauClusterItr)->et());
3266  ATH_MSG_INFO("REGTEST TrigTauCluster->EMCalibEnergy() returns " << (*TauClusterItr)->EMCalibEnergy());
3267 
3268  ATH_MSG_INFO("REGTEST TrigTauCluster->EMenergy() returns " << (*TauClusterItr)->EMenergy());
3269  ATH_MSG_INFO("REGTEST TrigTauCluster->HADenergy() returns " << (*TauClusterItr)->HADenergy());
3270  ATH_MSG_INFO("REGTEST TrigTauCluster->eta() returns " << (*TauClusterItr)->eta());
3271  ATH_MSG_INFO("REGTEST TrigTauCluster->phi() returns " << (*TauClusterItr)->phi());
3272  ATH_MSG_INFO("REGTEST TrigTauCluster->IsoFrac() returns " << (*TauClusterItr)->IsoFrac());
3273  ATH_MSG_INFO("REGTEST TrigTauCluster->stripWidth() returns " << (*TauClusterItr)->stripWidth());
3274  ATH_MSG_INFO("REGTEST TrigTauCluster->numStripCells() returns " << (*TauClusterItr)->numStripCells());
3275  ATH_MSG_INFO("REGTEST TrigTauCluster->CaloRadius() returns " << (*TauClusterItr)->CaloRadius());
3276  ATH_MSG_INFO("REGTEST TrigTauCluster->numTotCells() returns " << (*TauClusterItr)->numTotCells());
3277 
3278 
3279  if( (*TauClusterItr)->clusterDetails() == 0 )
3280  ATH_MSG_WARNING("REGTEST TrigTauCluster-> Details link is MISSING ");
3281  else{
3282  ATH_MSG_INFO("REGTEST TrigTauCluster->Energy in Narrow cone : EM[0/1/2/3]="
3283  <<(*TauClusterItr)->EMenergyNarrow(0) << " " << (*TauClusterItr)->EMenergyNarrow(1) << " "
3284  <<(*TauClusterItr)->EMenergyNarrow(2) << " ");
3285  ATH_MSG_INFO("REGTEST TrigTauCluster->Energy in Narrow cone : HAD[0/1/2]="
3286  <<(*TauClusterItr)->HADenergyNarrow(0) << " " << (*TauClusterItr)->HADenergyNarrow(1) << " "
3287  <<(*TauClusterItr)->HADenergyNarrow(2));
3288  }
3289  }
3290  }
3291 
3292  int nDetails = 0;
3295  sc = evtStore()->retrieve(TauDetailsCluster,lastTauDetailsCluster);
3296  if (sc.isFailure()) {
3297  ATH_MSG_INFO("REGTEST No TrigTauDetailsClusterContainer found");
3298  return StatusCode::SUCCESS;
3299  }
3300  ATH_MSG_INFO("REGTEST TrigTauDetailsClusterContainer retrieved");
3301 
3302  for (int i=0; TauDetailsCluster != lastTauDetailsCluster; ++TauDetailsCluster, ++i) {
3303 
3304  ATH_MSG_INFO("REGTEST Looking at TrigTauClusterDetailsContainer " << i);
3305 
3306  TrigTauClusterDetailsContainer::const_iterator TauDetailsClusterItr = TauDetailsCluster->begin();
3307  TrigTauClusterDetailsContainer::const_iterator TauDetailsClusterItrE = TauDetailsCluster->end();
3308 
3309  for (int j=0; TauDetailsClusterItr != TauDetailsClusterItrE; ++TauDetailsClusterItr, ++j ) {
3310  nDetails++;
3311  ATH_MSG_INFO("REGTEST Looking at TrigTauClusterDetails " << j);
3312 
3313  for(unsigned int i = 0; i<4; ++i ) {
3314  ATH_MSG_INFO("REGTEST TrigTauClusterDetails-> EM["<<i <<"] Radius/EnergyNar/EnergyMid/EnergyWid returns "
3315  << (*TauDetailsClusterItr)->EMRadius(i) << " "
3316  << (*TauDetailsClusterItr)->EMenergyNarrow(i) << " "
3317  << (*TauDetailsClusterItr)->EMenergyMedium(i) << " "
3318  << (*TauDetailsClusterItr)->EMenergyWide(i));
3319  }
3320  for(unsigned int i = 0; i<3; ++i ) {
3321  ATH_MSG_INFO("REGTEST TrigTauClusterDetails-> HAD["<<i <<"] Radius/EnergyNar/EnergyMid/EnergyWid returns "
3322  << (*TauDetailsClusterItr)->HADRadius(i) << " "
3323  << (*TauDetailsClusterItr)->HADenergyNarrow(i) << " "
3324  << (*TauDetailsClusterItr)->HADenergyMedium(i) << " "
3325  << (*TauDetailsClusterItr)->HADenergyWide(i));
3326  }
3327  }
3328  }
3329 
3330  if( nDetails != nClusters)
3331  ATH_MSG_WARNING("REGTEST inconsistent number of TrigTauClusters ("<< nClusters<< ") and TrigTauClusterDetails ("
3332  << nDetails << ")");
3333 
3334  ATH_MSG_INFO("REGTEST ==========END of TrigTauClusterContainer/TrigTauClusterDetailsContainer DUMP===========");
3335 
3336  ATH_MSG_DEBUG("dumpTrigTauClusterContainer() succeeded");
3337 
3338  return StatusCode::SUCCESS;
3339 }
3340 
3342 
3343 StatusCode TrigEDMChecker::dumpTrigEMClusterContainer ATLAS_NOT_THREAD_SAFE() {
3344 
3345  ATH_MSG_DEBUG("in dumpTrigEMClusterContainer()");
3346 
3347  ATH_MSG_INFO("REGTEST ==========START of TrigEMClusterContainer DUMP===========");
3348 
3351 
3352  StatusCode sc = evtStore()->retrieve(EMCluster,lastEMCluster);
3353  if (sc.isFailure()) {
3354  ATH_MSG_INFO("REGTEST No TrigEMClusterContainer found");
3355  return StatusCode::SUCCESS;
3356  }
3357  ATH_MSG_INFO("REGTEST TrigEMClusterContainer retrieved");
3358 
3359 
3360  for (int i=0; EMCluster != lastEMCluster; ++EMCluster, ++i) {
3361 
3362  ATH_MSG_INFO("REGTEST Looking at TrigEMClusterContainer " << i);
3363 
3364  TrigEMClusterContainer::const_iterator EMClusterItr = EMCluster->begin();
3365  TrigEMClusterContainer::const_iterator EMClusterItrE = EMCluster->end();
3366 
3367  for (int j=0; EMClusterItr != EMClusterItrE; ++EMClusterItr, ++j ) {
3368 
3369  ATH_MSG_INFO("REGTEST Looking at TrigEMCluster " << j);
3370 
3371  ATH_MSG_INFO("REGTEST TrigEMCluster->energy() returns " << (*EMClusterItr)->energy());
3372  ATH_MSG_INFO("REGTEST TrigEMCluster->et() returns " << (*EMClusterItr)->et());
3373  ATH_MSG_INFO("REGTEST TrigEMCluster->eta() returns " << (*EMClusterItr)->eta());
3374  ATH_MSG_INFO("REGTEST TrigEMCluster->phi() returns " << (*EMClusterItr)->phi());
3375  ATH_MSG_INFO("REGTEST TrigEMCluster->print() gives");
3376  int level = msg().level();
3377  // little trick to print out stuff
3378  msg().setLevel(MSG::DEBUG);
3379  (*EMClusterItr)->print(msg());
3380  msg().setLevel(level);
3381  }
3382  }
3383 
3384  ATH_MSG_INFO("REGTEST ==========END of TrigEMClusterContainer DUMP===========");
3385  ATH_MSG_DEBUG("dumpTrigEMClusterContainer() succeeded");
3386 
3387  return StatusCode::SUCCESS;
3388 }
3389 
3390 StatusCode TrigEDMChecker::dumpxAODTrigEMClusterContainer ATLAS_NOT_THREAD_SAFE() {
3391 
3392  ATH_MSG_DEBUG("in dumpxAODTrigEMClusterContainer()");
3393 
3394  ATH_MSG_INFO("REGTEST ==========START of xAODTrigEMClusterContainer DUMP===========");
3395 
3398 
3399  StatusCode sc = evtStore()->retrieve(EMCluster,lastEMCluster);
3400  if (sc.isFailure()) {
3401  ATH_MSG_INFO("REGTEST No xAOD::TrigEMClusterContainer found");
3402  return StatusCode::SUCCESS;
3403  }
3404  ATH_MSG_INFO("REGTEST xAOD::TrigEMClusterContainer retrieved");
3405 
3406 
3407  for (int i=0; EMCluster != lastEMCluster; ++EMCluster, ++i) {
3408 
3409  ATH_MSG_INFO("REGTEST Looking at xAOD::TrigEMClusterContainer " << i);
3410 
3411  xAOD::TrigEMClusterContainer::const_iterator EMClusterItr = EMCluster->begin();
3412  xAOD::TrigEMClusterContainer::const_iterator EMClusterItrE = EMCluster->end();
3413 
3414  for (int j=0; EMClusterItr != EMClusterItrE; ++EMClusterItr, ++j ) {
3415 
3416  ATH_MSG_INFO("REGTEST Looking at xAOD::TrigEMCluster " << j);
3417  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->energy() returns " << (*EMClusterItr)->energy());
3418  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->et() returns " << (*EMClusterItr)->et());
3419  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->eta() returns " << (*EMClusterItr)->eta());
3420  ATH_MSG_INFO("REGTEST xAOD::TrigEMCluster->phi() returns " << (*EMClusterItr)->phi());
3421  //msg() <<MSG::INFO << "REGTEST xAOD::TrigEMCluster->print() gives" << endmsg;
3422  //int level = msg().level();
3423  // little trick to print out stuff
3424  //msg().setLevel(MSG::DEBUG);
3425  //(*EMClusterItr)->print(msg());
3426  //msg().setLevel(level);
3427  }
3428  }
3429 
3430  ATH_MSG_INFO("REGTEST ==========END of TrigEMClusterContainer DUMP===========");
3431  ATH_MSG_DEBUG("dumpTrigEMClusterContainer() succeeded");
3432 
3433  return StatusCode::SUCCESS;
3434 }
3435 
3437 
3438 StatusCode TrigEDMChecker::dumpTileMuFeatureContainer ATLAS_NOT_THREAD_SAFE() {
3439 
3440  ATH_MSG_DEBUG("in dumpTileMuFeatureContainer()");
3441  ATH_MSG_INFO("REGTEST ==========START of TileMuFeatureContainer DUMP===========");
3442 
3445 
3446  StatusCode sc = evtStore()->retrieve(TileMu, lastTileMu);
3447  if (sc.isFailure()) {
3448  ATH_MSG_INFO("REGTEST No TileMuFeatureContainer found");
3449  return StatusCode::SUCCESS;
3450  }
3451  ATH_MSG_INFO("REGTEST TileMuFeatureContainer retrieved");
3452 
3453  for (int i=0; TileMu != lastTileMu; ++TileMu, ++i) {
3454  ATH_MSG_INFO("REGTEST Looking at TileMuFeatureContainer " << i);
3455  TileMuFeatureContainer::const_iterator TileMuItr = TileMu->begin();
3456  TileMuFeatureContainer::const_iterator TileMuItrE = TileMu->end();
3457 
3458  for(int j=0; TileMuItr != TileMuItrE; ++TileMuItr, ++j) {
3459  ATH_MSG_INFO("REGTEST Looking at TileMuFeature " << j);
3460  ATH_MSG_INFO("REGTEST TileMuFeature->eta() returns " << (*TileMuItr)->eta());
3461  ATH_MSG_INFO("REGTEST TileMuFeature->phi() returns " << (*TileMuItr)->phi());
3462  ATH_MSG_INFO("REGTEST TileMuFeature->enedep().at(0) returns " << (*TileMuItr)->enedep().at(0));
3463  ATH_MSG_INFO("REGTEST TileMuFeature->enedep().at(1) returns " << (*TileMuItr)->enedep().at(1));
3464  ATH_MSG_INFO("REGTEST TileMuFeature->enedep().at(2) returns " << (*TileMuItr)->enedep().at(2));
3465  ATH_MSG_INFO("REGTEST TileMuFeature->enedep().at(3) returns " << (*TileMuItr)->enedep().at(3));
3466  ATH_MSG_INFO("REGTEST TileMuFeature->quality() returns " << (*TileMuItr)->quality());
3467 
3468  }
3469  }
3470 
3471  ATH_MSG_INFO("REGTEST ==========END of TileMuFeatureContainer DUMP===========");
3472  ATH_MSG_DEBUG("dumpTileMuFeatureContainer() succeeded");
3473 
3474  return StatusCode::SUCCESS;
3475 }
3476 
3478 
3479 StatusCode TrigEDMChecker::dumpTileTrackMuFeatureContainer ATLAS_NOT_THREAD_SAFE() {
3480 
3481  ATH_MSG_DEBUG("in dumpTileTrackMuFeatureContainer()");
3482  ATH_MSG_INFO("REGTEST ==========START of TileTrackMuFeatureContainer DUMP===========");
3483 
3486 
3487  StatusCode sc = evtStore()->retrieve(TileTrackMu, lastTileTrackMu);
3488  if (sc.isFailure()) {
3489  ATH_MSG_INFO("REGTEST No TileTrackMuFeatureContainer found");
3490  return StatusCode::SUCCESS;
3491  }
3492  ATH_MSG_INFO("REGTEST TileTrackMuFeatureContainer retrieved");
3493 
3494  for (int i=0; TileTrackMu!=lastTileTrackMu; ++TileTrackMu, ++i) {
3495  ATH_MSG_INFO("REGTEST Looking at TileTrackMuFeatureContainer " << i);
3496 
3497  TileTrackMuFeatureContainer::const_iterator TileTrackMuItr = TileTrackMu->begin();
3498  TileTrackMuFeatureContainer::const_iterator TileTrackMuItrE= TileTrackMu->end();
3499 
3500  for (int j=0; TileTrackMuItr != TileTrackMuItrE; ++TileTrackMuItr, ++j) {
3501  ATH_MSG_INFO("REGTEST Looking at TileTrackMuFeature " << j);
3502  ATH_MSG_INFO("REGTEST TileTrackMuFeature->PtTR_Trk() returns " << (*TileTrackMuItr)->PtTR_Trk());
3503  ATH_MSG_INFO("REGTEST TileTrackMuFeature->EtaTR_Trk() returns " << (*TileTrackMuItr)->EtaTR_Trk());
3504  ATH_MSG_INFO("REGTEST TileTrackMuFeature->PhiTR_Trk() returns " << (*TileTrackMuItr)->PhiTR_Trk());
3505  ATH_MSG_INFO("REGTEST TileTrackMuFeature->Typ_IDTrk() returns " << (*TileTrackMuItr)->Typ_IDTrk());
3506 
3507  ATH_MSG_INFO("REGTEST TileMuFeature info: ");
3508  ElementLink<TileMuFeatureContainer> TileMuEL = (*TileTrackMuItr)->TileMuLink();
3509  const TileMuFeature* TileMu;
3510  if ( !TileMuEL.isValid() ) {
3511  ATH_MSG_INFO("REGTEST No TileMuFeature (Something Wrong)");
3512  TileMu = 0;
3513  } else{
3514  TileMu = *TileMuEL;
3515  }
3516 
3517  if( TileMu != 0 ){
3518  ATH_MSG_INFO("REGTEST TileMuLink->eta() returns " << TileMu->eta());
3519  ATH_MSG_INFO("REGTEST TileMuLink->phi() returns " << TileMu->phi());
3520  ATH_MSG_INFO("REGTEST TileMuLink->enedep().at(0) returns " << TileMu->enedep().at(0));
3521  ATH_MSG_INFO("REGTEST TileMuLink->enedep().at(1) returns " << TileMu->enedep().at(1));
3522  ATH_MSG_INFO("REGTEST TileMuLink->enedep().at(2) returns " << TileMu->enedep().at(2));
3523  ATH_MSG_INFO("REGTEST TileMuLink->enedep().at(3) returns " << TileMu->enedep().at(3));
3524  ATH_MSG_INFO("REGTEST TileMuLink->quality() returns " << TileMu->quality());
3525  }
3526 
3527  ATH_MSG_INFO("REGTEST TrigInDetTrack info: ");
3528  ElementLink<TrigInDetTrackCollection> IDScanEL = (*TileTrackMuItr)->IDScanLink();
3529  const TrigInDetTrack* Track;
3530  if ( !IDScanEL.isValid() ) {
3531  ATH_MSG_INFO("REGTEST No valid IDtracks");
3532  Track = 0;
3533  } else{
3534  Track = *IDScanEL;
3535  }
3536 
3537  if (Track != 0) {
3538  ATH_MSG_INFO("REGTEST IDScanLink->algorithmId() returns " << Track->algorithmId());
3539  ATH_MSG_INFO("REGTEST IDScanLink->chi2() returns " << Track->chi2());
3540  ATH_MSG_INFO("REGTEST IDScanLink->NStrawHits() returns ");
3541  ATH_MSG_INFO("REGTEST IDScanLink->NStraw() returns " << Track->NStraw());
3542  ATH_MSG_INFO("REGTEST IDScanLink->NStrawTime() returns " << Track->NStrawTime());
3543  ATH_MSG_INFO("REGTEST IDScanLink->NTRHits() returns " << Track->NTRHits());
3544  ATH_MSG_INFO("REGTEST IDScanLink->param()->phi0() returns " << Track->param()->phi0());
3545  ATH_MSG_INFO("REGTEST IDScanLink->param()->eta() returns " << Track->param()->eta());
3546  ATH_MSG_INFO("REGTEST IDScanLink->param()->pT() returns " << Track->param()->pT());
3547  }
3548  }
3549  }
3550 
3551  ATH_MSG_INFO("REGTEST ==========END of TileTrackMuFeatureContainer DUMP===========");
3552  ATH_MSG_DEBUG("dumpTileTrackMuFeatureContainer() succeeded");
3553  return StatusCode::SUCCESS;
3554 }
3555 
3557 StatusCode TrigEDMChecker::dumpxAODTauJetContainer ATLAS_NOT_THREAD_SAFE() {
3558 
3559  ATH_MSG_DEBUG("In dumpxAODTauJetContainer");
3560  ATH_MSG_INFO( "REGTEST ==========START of xAOD::TauJetContainer DUMP===========" );
3561  const xAOD::TauJetContainer * TauJetcont = 0;
3562  StatusCode sc = evtStore() -> retrieve (TauJetcont, "HLT_xAOD__TauJetContainer_TrigTauRecMerged");
3563 
3564  if (sc.isFailure()) {
3565 
3566  ATH_MSG_INFO("REGTEST No Tau container HLT_xAOD__TauJetContainer_TrigTauRecMerged");
3567 
3568 
3569  return StatusCode::SUCCESS;
3570  }
3571 
3572 
3573  for(xAOD::TauJetContainer::const_iterator tauIt = TauJetcont->begin(); tauIt != TauJetcont->end();++tauIt){
3574 
3575  ATH_MSG_INFO( "REGTEST (*tauIt)->eta() returns " << (*tauIt)->eta() );
3576  ATH_MSG_INFO( "REGTEST (*tauIt)->phi() returns " << (*tauIt)->phi() );
3577  ATH_MSG_INFO( "REGTEST (*tauIt)->pt() returns " << (*tauIt)->pt() );
3578 
3579  // for numTracks()
3580  int EFnTracks = -1;
3581  #ifndef XAODTAU_VERSIONS_TAUJET_V3_H
3582  EFnTracks = (*tauIt)->nTracks();
3583  #else
3584  (*tauIt)->detail(xAOD::TauJetParameters::nChargedTracks, EFnTracks);
3585  #endif
3586 
3587  ATH_MSG_INFO( "REGTEST (*tauIt)->nTracks() returns " << EFnTracks );
3588 
3589  // for nTracksIsolation()
3590  int EFWidenTrack = -1;
3591  #ifndef XAODTAU_VERSIONS_TAUJET_V3_H
3592  EFWidenTrack = (*tauIt)->nWideTracks();
3593  #else
3594  (*tauIt)->detail(xAOD::TauJetParameters::nIsolatedTracks, EFWidenTrack);
3595  #endif
3596 
3597  ATH_MSG_INFO( "REGTEST (*tauIt)->nWideTracks() returns " << EFWidenTrack );
3598 
3599  //bool test = false;
3600  float trkAvgDist=0;
3601  float etOvPtLead=0;
3602  float emRadius=0;
3603  float hadRadius=0;
3604  float IsoFrac=0;
3605  float centFrac=0;
3606  float ipSigLeadTrk=0;
3607  float trFlightPathSig=0;
3608  float dRmax=0;
3609  float massTrkSys=0;
3610  float PSSFraction=0;
3611  float EMPOverTrkSysP=0;
3612  float ChPiEMEOverCaloEME=0;
3613  float EtEm=0;
3614  float EtHad=0;
3615 
3616  if ( (*tauIt)->detail(xAOD::TauJetParameters::trkAvgDist,trkAvgDist))
3617  ATH_MSG_INFO( "REGTEST TauDetails->trkAvgDist() returns " << trkAvgDist);
3618 
3619  if ( (*tauIt)->detail(xAOD::TauJetParameters::etOverPtLeadTrk,etOvPtLead))
3620  ATH_MSG_INFO( "REGTEST TauDetails->etOverPtLeadTrk() returns " << etOvPtLead);
3621 
3622  if ( (*tauIt)->detail(xAOD::TauJetParameters::EMRadius,emRadius))
3623  ATH_MSG_INFO( "REGTEST TauDetails->EMRadius() returns " << emRadius);
3624 
3625  if ( (*tauIt)->detail(xAOD::TauJetParameters::hadRadius,hadRadius))
3626  ATH_MSG_INFO( "REGTEST TauDetails->hadRadius() returns " << hadRadius);
3627 
3628  if ( (*tauIt)->detail(xAOD::TauJetParameters::isolFrac,IsoFrac))
3629  ATH_MSG_INFO( "REGTEST TauDetails->isolFrac() returns " << IsoFrac);
3630 
3631  if ( (*tauIt)->detail(xAOD::TauJetParameters::centFrac,centFrac))
3632  ATH_MSG_INFO( "REGTEST TauDetails->centFrac() returns " << centFrac);
3633 
3634  if ( (*tauIt)->detail(xAOD::TauJetParameters::ipSigLeadTrk,ipSigLeadTrk))
3635  ATH_MSG_INFO( "REGTEST TauDetails->ipSigLeadTrk() returns " << ipSigLeadTrk);
3636 
3638  ATH_MSG_INFO( "REGTEST TauDetails->trFlightPathSig() returns " << trFlightPathSig);
3639 
3640  if ( (*tauIt)->detail(xAOD::TauJetParameters::dRmax,dRmax))
3641  ATH_MSG_INFO( "REGTEST TauDetails->dRmax() returns " << dRmax);
3642 
3643  if ( (*tauIt)->detail(xAOD::TauJetParameters::massTrkSys,massTrkSys)){
3644  massTrkSys /=1000;
3645  ATH_MSG_INFO( "REGTEST TauDetails->massTrkSys() returns " << massTrkSys);}
3646 
3647  if ( (*tauIt)->detail(xAOD::TauJetParameters::PSSFraction,PSSFraction))
3648  ATH_MSG_INFO( "REGTEST TauDetails->PSSFraction() returns " << PSSFraction);
3649 
3651  ATH_MSG_INFO( "REGTEST TauDetails->EMPOverTrkSysP() returns " << EMPOverTrkSysP);
3652 
3654  ATH_MSG_INFO( "REGTEST TauDetails->ChPiEMEOverCaloEME() returns " << ChPiEMEOverCaloEME);
3655 
3656  if ( (*tauIt)->detail(xAOD::TauJetParameters::etEMAtEMScale,EtEm)){
3657  EtEm /=1000;
3658  ATH_MSG_INFO( "REGTEST TauDetails->etEMAtEMScale() returns " << EtEm);}
3659 
3660  if ( (*tauIt)->detail(xAOD::TauJetParameters::etHadAtEMScale,EtHad)){
3661  EtHad /=1000;
3662  ATH_MSG_INFO( "REGTEST TauDetails->etHadAtEMScale() returns " << EtHad);}
3663 
3664 
3665  if( !(*tauIt)->jetLink().isValid() ) {
3666  ATH_MSG_WARNING("tau does not have jet seed");
3667  return StatusCode::SUCCESS;
3668  }
3669 
3670  const xAOD::Jet* pJetSeed = *((*tauIt)->jetLink());
3671 
3674 
3675  for (int clusCount = 0; clusItr != clusItrE; ++clusItr, ++clusCount) {
3676 
3677  ATH_MSG_INFO( "REGTEST Tau Cluster " << clusCount << " pt = " << (*clusItr)->pt()
3678  << " eta = " << (*clusItr)->eta()
3679  << " phi = " << (*clusItr)->phi() );
3680 
3681  }
3682 
3683 
3684  for (unsigned int trackNum = 0; trackNum < (*tauIt)->nTracks(); ++trackNum) {
3685 
3686  const xAOD::TrackParticle *linkTrack = (*tauIt)->track(trackNum)->track();
3687  if (!linkTrack) {
3688  ATH_MSG_WARNING("can't get tau linked track");
3689  return StatusCode::SUCCESS;
3690  } else {
3691  ATH_MSG_DEBUG("Got the tau linked track");
3692  }
3693 
3694  ATH_MSG_INFO( "REGTEST Tau linked track " << trackNum << " pt = " << linkTrack->pt()
3695  << " eta = " << linkTrack->eta()
3696  << " phi = " << linkTrack->phi() );
3697 
3698  }
3699 
3700 
3701  }// end for
3702 
3703  return StatusCode::SUCCESS;
3704 
3705 }
3706 
3707 
3709 
3710 StatusCode TrigEDMChecker::dumpTauJetContainer ATLAS_NOT_THREAD_SAFE() {
3711 
3712  ATH_MSG_INFO("REGTEST ==========START of TauJetContainer DUMP===========");
3713 
3714  using namespace Analysis;
3715 
3716  StatusCode sCode=StatusCode::FAILURE;
3717  int ntag=1;
3718  std::string TauContainerTags[]={"HLT_TrigTauRecMerged"};
3719  for (int itag=0; itag < ntag; itag++) {
3720  const TauJetContainer* TauJetcont = nullptr;
3721  sCode=evtStore()->retrieve(TauJetcont , TauContainerTags[itag]);
3722  if( sCode.isFailure() ){
3723  ATH_MSG_INFO("Failed to retrieve TauJetContainer with key " << TauContainerTags[itag]);
3724  continue;
3725  }
3726 
3727  for(Analysis::TauJetContainer::const_iterator tauIt = TauJetcont->begin(); tauIt != TauJetcont->end(); ++tauIt){
3728 
3729  bool IsTaurec = false;
3730  bool Is1p3p = false;
3731  if ((*tauIt)->hasAuthor( TauJetParameters::tauRec)) {
3732  ATH_MSG_INFO("Is TauRec Seeded ");
3733  IsTaurec = true;
3734  }
3735 
3736  if ((*tauIt)->hasAuthor( TauJetParameters::tau1P3P)) {
3737  ATH_MSG_INFO("Is Tau1p3p Seeded ");
3738  Is1p3p = true;
3739  }
3740 
3741  if ((*tauIt)->hasAuthor( TauJetParameters::unknown)) {
3742  ATH_MSG_INFO("Is unknown seeded ");
3743  }
3744 
3745  const Analysis::TauCommonDetails* TauDetails = (*tauIt)->details<const Analysis::TauCommonDetails>();
3746  if (TauDetails == NULL) {
3747  ATH_MSG_INFO(" TauDetails == NULL ");
3748  continue;
3749  }
3750 
3751  ATH_MSG_INFO("REGTEST (*tauIt)->eta() returns " << (*tauIt)->eta());
3752  ATH_MSG_INFO("REGTEST (*tauIt)->phi() returns " << (*tauIt)->phi());
3753  ATH_MSG_INFO("REGTEST (*tauIt)->numTrack() returns " << (*tauIt)->numTrack());
3754  ATH_MSG_INFO("REGTEST TauDetails->nLooseTrk() returns " << TauDetails->nLooseTrk());
3755  ATH_MSG_INFO("REGTEST TauDetails->leadTrkPt() returns " << TauDetails->leadTrkPt());
3756  ATH_MSG_INFO("REGTEST TauDetails->leadLooseTrkPt() returns " << TauDetails->leadLooseTrkPt());
3757  ATH_MSG_INFO("REGTEST TauDetails->ipZ0SinThetaSigLeadTrk() returns " << TauDetails->ipZ0SinThetaSigLeadTrk());
3758  ATH_MSG_INFO("REGTEST TauDetails->ipSigLeadTrk() returns "<<TauDetails->ipSigLeadTrk());
3759  ATH_MSG_INFO("REGTEST TauDetails->ipSigLeadLooseTrk() returns "<<TauDetails->ipSigLeadLooseTrk());
3760  ATH_MSG_INFO("REGTEST TauDetails->trkWidth2() returns "<<TauDetails->trkWidth2());
3761  ATH_MSG_INFO("REGTEST TauDetails->trFlightPathSig() returns "<< TauDetails->trFlightPathSig());
3762 
3763  if(IsTaurec) {
3764  ATH_MSG_INFO("Calo seeded");
3765  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_etHadCalib() returns " << TauDetails->seedCalo_etHadCalib());
3766  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_etEMCalib() returns " << TauDetails->seedCalo_etEMCalib());
3767  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_EMRadius() returns " << TauDetails->seedCalo_EMRadius());
3768  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_isolFrac() returns " << TauDetails->seedCalo_isolFrac());
3769  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_centFrac() returns " << TauDetails->seedCalo_centFrac());
3770  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_stripWidth2() returns " << TauDetails->seedCalo_stripWidth2());
3771  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_nStrip() returns " << TauDetails->seedCalo_nStrip());
3772  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_etEMAtEMScale() returns " << TauDetails->seedCalo_etEMAtEMScale());
3773  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_etHADAtEMScale() returns " << TauDetails->seedCalo_etHadAtEMScale());
3774  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_hadRadius() returns " << TauDetails->seedCalo_hadRadius());
3775  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_nIsolLooseTrk() returns " << TauDetails->seedCalo_nIsolLooseTrk());
3776  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_trkAvgDist() returns " << TauDetails->seedCalo_trkAvgDist());
3777  ATH_MSG_INFO("REGTEST TauDetails->seedCalo_trkRmsDist() returns " << TauDetails->seedCalo_trkRmsDist());
3778  }
3779 
3780  if(Is1p3p) {
3781  ATH_MSG_INFO("Track seeded");
3782  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_EMRadius() returns " << TauDetails->seedTrk_EMRadius());
3783  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_isolFrac() returns " << TauDetails->seedTrk_isolFrac());
3784  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_etChrgHadOverSumTrkPt () returns " << TauDetails->seedTrk_etChrgHadOverSumTrkPt ());
3785  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_isolFracWide() returns " << TauDetails->seedTrk_isolFracWide());
3786  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_etHadAtEMScale() returns " << TauDetails->seedTrk_etHadAtEMScale());
3787  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_etEMAtEMScale() returns " << TauDetails->seedTrk_etEMAtEMScale());
3788  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_etEMCL() returns " << TauDetails->seedTrk_etEMCL());
3789  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_etChrgEM() returns " << TauDetails->seedTrk_etChrgEM());
3790  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_etNeuEM() returns " << TauDetails->seedTrk_etNeuEM());
3791  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_etResNeuEM() returns " << TauDetails->seedTrk_etResNeuEM());
3792  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_hadLeakEt() returns " << TauDetails->seedTrk_hadLeakEt());
3793  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_sumEMCellEtOverLeadTrkPt() returns " << TauDetails->seedTrk_sumEMCellEtOverLeadTrkPt());
3794  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_secMaxStripEt() returns " << TauDetails->seedTrk_secMaxStripEt());
3795  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_stripWidth2() returns " << TauDetails->seedTrk_stripWidth2());
3796  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_nStrip() returns " << TauDetails->seedTrk_nStrip());
3797  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_etChrgHad() returns " << TauDetails->seedTrk_etChrgHad());
3798  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_nOtherCoreTrk() returns " << TauDetails->seedTrk_nOtherCoreTrk());
3799  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_nIsolTrk() returns " << TauDetails->seedTrk_nIsolTrk());
3800  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_etIsolEM() returns " << TauDetails->seedTrk_etIsolEM());
3801  ATH_MSG_INFO("REGTEST TauDetails->seedTrk_etIsolHad() returns " << TauDetails->seedTrk_etIsolHad());
3802  }
3803 
3804  const Analysis::TauJet* tj = *tauIt;
3805  if ( tj->clusterLink().isValid() ) {
3806  ATH_MSG_INFO("REGTEST CaloCluster present");
3807  } else {
3808  ATH_MSG_INFO("REGTEST CaloCluster missing");
3809  }
3810 
3811  if( TauDetails->looseTrk().size() !=0 ) {
3812  ATH_MSG_INFO("REGTEST TauDetails->looseTrk() link present ");
3813  } else {
3814  ATH_MSG_INFO("REGTEST TauDetails->looseTrk() link missing ");
3815  }
3816 
3817  if ( tj->cellClusterLink().isValid() ) {
3818  ATH_MSG_INFO("REGTEST CellCaloCluster present");
3819  } else {
3820  ATH_MSG_INFO("REGTEST CellCaloCluster missing");
3821  }
3822 
3823  if ( tj->jetLink().isValid() ) {
3824  ATH_MSG_INFO("REGTEST Jet present");
3825  } else {
3826  ATH_MSG_INFO("REGTEST Jet missing");
3827  }
3828 
3829  if ( tj->jetLink().isValid() ) {
3830  ATH_MSG_INFO("REGTEST Jet present");
3831  } else {
3832  ATH_MSG_INFO("REGTEST Jet missing");
3833  }
3834 
3835  ATH_MSG_INFO("REGTEST numTrack returns " << tj->numTrack());
3836 
3837  if ( tj->trackLinkVector().size() != 0 ) {
3838  ATH_MSG_INFO("REGTEST TrackLinkVector present");
3839  } else {
3840  ATH_MSG_INFO("REGTEST TrackkLinkVector missing");
3841  }
3842 
3843  ATH_MSG_INFO("REGTEST author returns " << tj->author());
3844  ATH_MSG_INFO("REGTEST ROIWord returns " << tj->author());
3845  }
3846  }
3847 
3850  StatusCode sc = evtStore()->retrieve(TauJet, lastTauJet);
3851  if (sc.isFailure()) {
3852  ATH_MSG_INFO("REGTEST No TauJetContainer found");
3853  return StatusCode::FAILURE;
3854  }
3855  else ATH_MSG_DEBUG("Found TauJetContainer");
3856 
3857  ATH_MSG_INFO("REGTEST TauJetContainer retrieved");
3858 
3859  for ( ; TauJet != lastTauJet ; ++TauJet ) {
3860  ATH_MSG_INFO("REGTEST TauJetContainer key: " << TauJet.key());
3861  }
3862 
3863  return StatusCode::SUCCESS;
3864 }
3865 
3867 
3868  ATH_MSG_DEBUG("In dumpxAODTrackParticle()");
3869 
3870  ATH_MSG_INFO("REGTEST ==========START of xAOD::TrackParticle DUMP===========");
3871 
3872  std::vector<std::string> SGkeys;
3873  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_EFID");
3874  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bphysics_EFID");
3875  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Electron_EFID");
3876  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_FullScan_EFID");
3877  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_EFID");
3878  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Photon_EFID");
3879  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_EFID");
3880 
3881  StatusCode returnsc = StatusCode::SUCCESS;
3882 
3883  for (unsigned int SGkey = 0; SGkey < SGkeys.size(); ++SGkey) {
3884  const xAOD::TrackParticleContainer* trackParticleContainer=0;
3885  StatusCode sc = evtStore()->retrieve(trackParticleContainer,SGkeys.at(SGkey));
3886  if (sc.isFailure()) {
3887  ATH_MSG_INFO("REGTEST No track particle container found with key " << SGkeys.at(SGkey));
3888  continue;
3889  }
3890  ATH_MSG_INFO("REGTEST TrackParticleContainer retrieved with key " << SGkeys.at(SGkey)
3891  << " and size " << trackParticleContainer->size());
3892 
3893  xAOD::TrackParticleContainer::const_iterator trackParticleItr = trackParticleContainer->begin();
3894  xAOD::TrackParticleContainer::const_iterator trackParticleLast = trackParticleContainer->end();
3895 
3896  for (int index = 0; trackParticleItr != trackParticleLast; ++trackParticleItr, ++index) {
3897  ATH_MSG_INFO("REGTEST Looking at Track Particle " << index);
3898 
3899  ATH_MSG_INFO("REGTEST IParticle functions:");
3900  ATH_MSG_INFO("REGTEST pt: " << (*trackParticleItr)->pt()
3901  << "/eta: " << (*trackParticleItr)->eta()
3902  << "/phi: " << (*trackParticleItr)->phi()
3903  << "/m: " << (*trackParticleItr)->m()
3904  << "/e: " << (*trackParticleItr)->e()
3905  << "/rapidity: " << (*trackParticleItr)->rapidity());
3906 
3907  ATH_MSG_INFO("REGTEST Defining parameters functions:");
3908  ATH_MSG_INFO("REGTEST charge: " << (*trackParticleItr)->charge()
3909  << "/d0: " << (*trackParticleItr)->d0()
3910  << "/z0: " << (*trackParticleItr)->z0()
3911  << "/phi0: " << (*trackParticleItr)->phi0()
3912  << "/theta: " << (*trackParticleItr)->theta()
3913  << "/qOverP: " << (*trackParticleItr)->qOverP()
3914  << "/vx: " << (*trackParticleItr)->vx()
3915  << "/vy: " << (*trackParticleItr)->vy()
3916  << "/vz: " << (*trackParticleItr)->vz());
3917 
3918  // Curvilinear functions skipped
3919 
3920  ATH_MSG_INFO("REGTEST Fit quality functions:");
3921  ATH_MSG_INFO("REGTEST chiSquared: " << (*trackParticleItr)->chiSquared()
3922  << "/numberDoF: " << (*trackParticleItr)->numberDoF());
3923 
3924  // TrackInfo functions skipped
3925 
3926  ATH_MSG_INFO("REGTEST summaryValue variables:");
3927  msg() << MSG::INFO << "REGTEST ";
3929  if ( (*trackParticleItr)->summaryValue(numberOfBLayerHits, xAOD::numberOfBLayerHits) ) {
3930  msg() << "/numberOfBLayerHits: " << static_cast<int>(numberOfBLayerHits);
3931  } else {
3932  msg() << "/numberOfBLayerHits not found";
3933  }
3934 
3936  if ( (*trackParticleItr)->summaryValue(numberOfPixelHits, xAOD::numberOfPixelHits) ) {
3937  msg() << "/numberOfPixelHits: " << static_cast<int>(numberOfPixelHits);
3938  } else {
3939  msg() << "/numberOfPixelHits not found";
3940  }
3941 
3943  if ( (*trackParticleItr)->summaryValue(numberOfPixelHoles, xAOD::numberOfPixelHoles) ) {
3944  msg() << "/numberOfPixelHoles: " << static_cast<int>(numberOfPixelHoles);
3945  } else {
3946  msg() << "/numberOfPixelHoles not found";
3947  }
3948 
3950  if ( (*trackParticleItr)->summaryValue(numberOfSCTHits, xAOD::numberOfSCTHits) ) {
3951  msg() << "/numberOfSCTHits: " << static_cast<int>(numberOfSCTHits);
3952  } else {
3953  msg() << "/numberOfSCTHits not found";
3954  }
3955 
3957  if ( (*trackParticleItr)->summaryValue(numberOfSCTHoles, xAOD::numberOfSCTHoles) ) {
3958  msg() << "/numberOfSCTHoles: " << static_cast<int>(numberOfSCTHoles);
3959  } else {
3960  msg() << "/numberOfSCTHoles not found";
3961  }
3962 
3964  if ( (*trackParticleItr)->summaryValue(numberOfTRTHits, xAOD::numberOfTRTHits) ) {
3965  msg() << "/numberOfTRTHits: " << static_cast<int>(numberOfTRTHits);
3966  } else {
3967  msg() << "/numberOfTRTHits not found";
3968  }
3969 
3971  if ( (*trackParticleItr)->summaryValue(numberOfTRTHoles, xAOD::numberOfTRTHoles) ) {
3972  msg() << "/numberOfTRTHoles: " << static_cast<int>(numberOfTRTHoles);
3973  } else {
3974  msg() << "/numberOfTRTHoles not found";
3975  }
3976  msg() << endmsg;
3977  }
3978  }
3979 
3980  ATH_MSG_INFO("REGTEST ==========END of xAOD::TrackParticle DUMP===========");
3981  ATH_MSG_DEBUG("dumpxAODTrackParticles() succeeded");
3982 
3983  return returnsc;
3984 }
3985 
3987 
3988  ATH_MSG_DEBUG("In dumpxAODVertex()");
3989 
3990  ATH_MSG_INFO("REGTEST ==========START of xAOD::Vertex DUMP===========");
3991 
3992  const xAOD::VertexContainer* vertexContainer=0;
3993  StatusCode sc = evtStore()->retrieve(vertexContainer,"HLT_xAOD__VertexContainer_xPrimVx");
3994  if (sc.isFailure()) {
3995  ATH_MSG_INFO("REGTEST No vertex container");
3996  return StatusCode::FAILURE;
3997  }
3998  ATH_MSG_INFO("REGTEST VertexContainer retrieved");
3999 
4000  xAOD::VertexContainer::const_iterator vertexItr = vertexContainer->begin();
4001  xAOD::VertexContainer::const_iterator vertexLast = vertexContainer->end();
4002 
4003  for (int index = 0; vertexItr != vertexLast; ++vertexItr, ++index) {
4004  ATH_MSG_INFO("REGTEST Looking at Vertex " << index);
4005 
4006  ATH_MSG_INFO("REGTEST Public Member Functions:");
4007  ATH_MSG_INFO("REGTEST x: " << (*vertexItr)->x()
4008  << "/y: " << (*vertexItr)->y()
4009  << "/z: " << (*vertexItr)->z());
4010 
4011  ATH_MSG_INFO("REGTEST Public Member Functions:");
4012  ATH_MSG_INFO("REGTEST chiSquared: " << (*vertexItr)->chiSquared()
4013  << "/numberDoF: " << (*vertexItr)->numberDoF());
4014  }
4015 
4016  ATH_MSG_INFO("REGTEST ==========END of xAOD::Vertex DUMP===========");
4017  ATH_MSG_DEBUG("dumpxAODVertex() succeeded");
4018 
4019  return StatusCode::SUCCESS;
4020 }
4021 
4023  using namespace TrigCompositeUtils; // LinkInfo
4024  ATH_MSG_INFO( "REGTEST ==========START of TDT DUMP===========" );
4025  // Note: This minimal TDT dumper is for use during run-3 dev
4026  std::string chain = m_dumpNavForChain;
4027  if (chain.empty()) {
4028  chain = "HLT_.*";
4029  }
4030  std::vector<std::string> confChains = m_trigDec->getListOfTriggers(chain);
4031  for (const auto& item : confChains) {
4032  bool passed = m_trigDec->isPassed(item);
4033  ATH_MSG_INFO(" HLT Item " << item << " (numeric ID " << TrigConf::HLTUtils::string2hash(item, "Identifier") << ") passed raw? " << passed);
4034  if (m_trigDec->getNavigationFormat() == "TriggerElement") {
4035  ATH_MSG_DEBUG(" Skipping Run 2 features in this dumper");
4036  continue;
4037  }
4038  std::vector< LinkInfo<xAOD::IParticleContainer> > passFeatures = m_trigDec->features<xAOD::IParticleContainer>(item);
4039  if (passFeatures.size()) {
4040  ATH_MSG_INFO(" " << item << " Passed Final IParticle features size: " << passFeatures.size());
4041  for (const LinkInfo<xAOD::IParticleContainer>& li : passFeatures) {
4042  if (!li.isValid()) {
4043  ATH_MSG_WARNING(" Unable to access feature - link invalid.");
4044  } else {
4045  try {
4046  std::string state = "ACTIVE";
4047  if (li.state == ActiveState::INACTIVE) state = "INACTIVE";
4048  else if (li.state == ActiveState::UNSET) state = "UNSET";
4049  ATH_MSG_INFO(" IParticle Feature from " << li.link.dataID() << " index:" << li.link.index() << " pt:" << (*li.link)->pt() << " eta:" << (*li.link)->eta() << " phi:" << (*li.link)->phi() << " state:" << state);
4050  } catch (const std::exception& e) {
4051  ATH_MSG_WARNING(" Unable to dereference feature {" << e.what() << "}");
4052  }
4053  }
4054  }
4055  }
4056  std::vector< LinkInfo<xAOD::IParticleContainer> > passAndFailFeatures = m_trigDec->features<xAOD::IParticleContainer>(item, TrigDefs::includeFailedDecisions);
4057  if (passAndFailFeatures.size()) {
4058  ATH_MSG_INFO(" " << item << " Passed+Failed Final IParticle features size: " << passAndFailFeatures.size());
4059  for (const LinkInfo<xAOD::IParticleContainer>& li : passAndFailFeatures) {
4060  if (!li.isValid()) {
4061  ATH_MSG_WARNING(" Unable to access feature - link invalid.");
4062  } else {
4063  try {
4064  std::string state = "ACTIVE";
4065  if (li.state == ActiveState::INACTIVE) state = "INACTIVE";
4066  else if (li.state == ActiveState::UNSET) state = "UNSET";
4067  ATH_MSG_INFO(" IParticle Feature from " << li.link.dataID() << " index:" << li.link.index() << " pt:" << (*li.link)->pt() << " eta:" << (*li.link)->eta() << " phi:" << (*li.link)->phi() << " state:" << state);
4068  } catch (const std::exception& e) {
4069  ATH_MSG_WARNING(" Unable to dereference feature {" << e.what() << "}");
4070  }
4071  }
4072  }
4073  }
4074  std::vector< LinkInfo<xAOD::IParticleContainer> > allFeatures = m_trigDec->features<xAOD::IParticleContainer>(item, TrigDefs::includeFailedDecisions, "", TrigDefs::allFeaturesOfType);
4075  if (allFeatures.size()) {
4076  ATH_MSG_INFO(" " << item << " Passed+Failed ALL IParticle features size: " << allFeatures.size());
4077  for (const LinkInfo<xAOD::IParticleContainer>& li : allFeatures) {
4078  if (!li.isValid()) {
4079  ATH_MSG_WARNING(" Unable to access feature - link invalid.");
4080  } else {
4081  try {
4082  std::string state = "ACTIVE";
4083  if (li.state == ActiveState::INACTIVE) state = "INACTIVE";
4084  else if (li.state == ActiveState::UNSET) state = "UNSET";
4085  ATH_MSG_INFO(" IParticle Feature from " << li.link.dataID() << " index:" << li.link.index() << " pt:" << (*li.link)->pt() << " eta:" << (*li.link)->eta() << " phi:" << (*li.link)->phi() << " state:" << state);
4086  } catch (const std::exception& e) {
4087  ATH_MSG_WARNING(" Unable to dereference feature {" << e.what() << "}");
4088  }
4089  }
4090  }
4091  }
4092  }
4093 
4094  if (m_trigDec->getNavigationFormat() == "TrigComposite") {
4095  // Check associateToEventView helper function
4096  std::vector< LinkInfo<xAOD::IParticleContainer> > muons = m_trigDec->features<xAOD::IParticleContainer>("HLT_mu24_idperf_L1MU20", TrigDefs::Physics, "HLT_MuonL2CBInfo");
4097  SG::ReadHandle<xAOD::TrackParticleContainer> muonTracksReadHandle(m_muonTracksKey, Gaudi::Hive::currentContext());
4098  for (const LinkInfo<xAOD::IParticleContainer>& mu : muons) {
4099  // Note: auto here refers to type std::pair< xAOD::TrackParticleContainer::const_iterator, xAOD::TrackParticleContainer::const_iterator>
4100  const auto roiTrackItPair = m_trigDec->associateToEventView<xAOD::TrackParticleContainer>(muonTracksReadHandle, mu, "roi");
4101  const xAOD::TrackParticleContainer::const_iterator startIt = roiTrackItPair.first;
4102  const xAOD::TrackParticleContainer::const_iterator stopIt = roiTrackItPair.second;
4103  ATH_MSG_INFO("Muon pT: " << (*mu.link)->pt() << " is from the same ROI as tracks with index "
4104  << std::distance(muonTracksReadHandle->begin(), startIt) << "-" << std::distance(muonTracksReadHandle->begin(), stopIt)
4105  << ", which is " << std::distance(startIt, stopIt) << " tracks, out of " << muonTracksReadHandle->size() << " total tracks.");
4106  for (xAOD::TrackParticleContainer::const_iterator it = startIt; it != stopIt; ++it) {
4107  ATH_MSG_VERBOSE(" -- Track " << std::distance(startIt, it) << " in this ROI, pT: " << (*it)->pt() );
4108  }
4109  }
4110  }
4111 
4112  ATH_MSG_INFO( "REGTEST ==========END of TDT DUMP===========" );
4113  return StatusCode::SUCCESS;
4114 }
4115 
4117  ATH_MSG_INFO( "REGTEST ==========START of xAOD::TrigCompositeContainer DUMP===========" );
4118 
4121  const CLID TrigCompositeCLID = static_cast<CLID>( ClassID_traits< xAOD::TrigCompositeContainer >::ID() );
4122  evtStore()->keys(TrigCompositeCLID, m_dumpTrigCompositeContainers);
4123  std::string typeNameTC;
4124  ATH_CHECK(m_clidSvc->getTypeNameOfID(TrigCompositeCLID, typeNameTC));
4125  ATH_MSG_DEBUG("dumpTrigComposite got " << m_dumpTrigCompositeContainers.size() << " keys for " << typeNameTC);
4126  } else {
4127  ATH_MSG_DEBUG("Using supplied " << m_dumpTrigCompositeContainers.size() << " keys");
4128  }
4129 
4130  for ( const std::string & key: m_dumpTrigCompositeContainers ) {
4131  // get the collection
4132  if ( not evtStore()->contains<xAOD::TrigCompositeContainer>(key) ) {
4133  ATH_MSG_WARNING("Absent TrigCompositeContainer: " << key );
4134  continue;
4135  }
4136  ATH_MSG_DEBUG( "#################### Dumping container of : " << key );
4137  const xAOD::TrigCompositeContainer* cont= nullptr;
4138  ATH_CHECK( evtStore()->retrieve( cont, key ) );
4139 
4140  size_t count = 0;
4141  for ( auto tc: *cont ) {
4142  ATH_MSG_DEBUG("########## ELEMENT " << count++);
4143  ATH_MSG_DEBUG(*tc);
4144  // Get the objects we know of
4145  for (size_t i = 0; i < tc->linkColNames().size(); ++i) ATH_CHECK(checkTrigCompositeElementLink(tc, i));
4146  }
4147  }
4148  ATH_MSG_INFO( "REGTEST ==========END of xAOD::TrigCompositeContainer DUMP===========" );
4149  return StatusCode::SUCCESS;
4150 }
4151 
4152 
4153 
4155 
4156  const std::string name = tc->linkColNames().at(element);
4157  const CLID clid = static_cast<CLID>(tc->linkColClids().at(element));
4158 
4160 
4162  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to TrigRoiDescriptorCollection, link name:'" << name << "'");
4163  else ATH_MSG_DEBUG(" Dereferenced link '" << name << "'' to TrigRoiDescriptor:" << *elementLink);
4164 
4165  } else if (clid == ClassID_traits< DataVector< LVL1::RecEmTauRoI > >::ID()) { // There could be a few ROI types....
4166  // CLASS_DEF( DataVector< LVL1::RecEmTauRoI >, 6256, 1 )
4167 
4169  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to LVL1::RecEmTauRoI, link name:'" << name << "'");
4170  else ATH_MSG_DEBUG(" Dereferenced link '" << name << "' to LVL1::RecEmTauRoI:" << *elementLink);
4171 
4173 
4175  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to TrigComposite, link name:'" << name << "'");
4176  else ATH_MSG_DEBUG(" Dereferenced link '" << name << "' to TrigComposite, TC name:'" << (*elementLink)->name() << "'");
4177 
4178  } else if (clid == ClassID_traits< ViewContainer >::ID()) {
4179 
4180  const ElementLink<ViewContainer> elementLink = tc->objectLink<ViewContainer>(name);
4181  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to View, link name:'" << name << "'");
4182  else ATH_MSG_DEBUG(" Dereferenced link '" << name << "' to View:'" << *elementLink);
4183 
4184  } else if (name == "feature") {
4185 
4187 
4189  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to xAOD::TrigEMClusterContainer 'feature'");
4190  else ATH_MSG_DEBUG(" Dereferenced xAOD::TrigEMClusterContainer link 'feature', Energy:" << (*elementLink)->energy());
4191 
4193 
4195  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to xAOD::TrigMissingETContainer 'feature'");
4196  else ATH_MSG_DEBUG(" Dereferenced xAOD::TrigMissingETContainer link 'feature', ex:" << (*elementLink)->ex() << " ey:" << (*elementLink)->ey());
4197 
4198  } else {
4199 
4200  try {
4202  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to 'feature'");
4203  else ATH_MSG_DEBUG(" Dereferenced IParticle link 'feature', pt:" << (*elementLink)->pt() << " eta:" << (*elementLink)->eta() << " phi:" << (*elementLink)->phi());
4204  } catch(std::runtime_error& e) {
4205  ATH_MSG_WARNING(" Cannot dereference 'feature' as IParticle: '" << e.what() << "'");
4206  }
4207 
4208  }
4209 
4210  } else {
4211  ATH_MSG_DEBUG(" Ignoring link to '" << name << "' with link CLID " << clid);
4212  }
4213 
4214  return StatusCode::SUCCESS;
4215 
4216 }
4217 
4218 
4219 StatusCode TrigEDMChecker::TrigCompositeNavigationToDot(std::string& returnValue, bool& pass) {
4220 
4221  using namespace TrigCompositeUtils;
4222 
4223  // This constexpr is evaluated at compile time
4224  const CLID TrigCompositeCLID = static_cast<CLID>( ClassID_traits< xAOD::TrigCompositeContainer >::ID() );
4225  std::vector<std::string> keys;
4226  if ( m_dumpTrigCompositeContainers.size() == 0 ) {
4227  evtStore()->keys(TrigCompositeCLID, keys);
4228  }
4229  else {
4231  }
4232  std::string typeNameTC;
4233  ATH_CHECK(m_clidSvc->getTypeNameOfID(TrigCompositeCLID, typeNameTC));
4234  ATH_MSG_DEBUG("Got " << keys.size() << " keys for " << typeNameTC);
4235 
4237  DecisionIDContainer chainIDs;
4238  chainIDs.insert( chainID.numeric() );
4239 
4240  std::set<int> converted;
4241 
4242  const Trig::ChainGroup* cg = m_trigDec->getChainGroup(m_dumpNavForChain);
4243  pass = cg->isPassed(TrigDefs::requireDecision);
4244  std::vector<std::string> chains = cg->getListOfTriggers();
4245  for (const std::string& chain : chains) {
4246  const TrigConf::HLTChain* hltChain = m_trigDec->ExperimentalAndExpertMethods().getChainConfigurationDetails(chain);
4247  const HLT::Identifier chainID_tmp( hltChain->chain_name() );
4248  chainIDs.insert( chainID_tmp.numeric() );
4249  const std::vector<size_t> legMultiplicites = hltChain->leg_multiplicities();
4250  if (legMultiplicites.size() == 0) {
4251  ATH_MSG_ERROR("chain " << chainID_tmp << " has invalid configuration, no multiplicity data.");
4252  } else if (legMultiplicites.size() > 1) {
4253  // For multi-leg chains, the DecisionIDs are handled per leg.
4254  // We don't care here exactly how many objects are required per leg, just that there are two-or-more legs
4255  for (size_t legNumeral = 0; legNumeral < legMultiplicites.size(); ++legNumeral) {
4256  const HLT::Identifier legID = TrigCompositeUtils::createLegName(chainID_tmp, legNumeral);
4257  chainIDs.insert( legID.numeric() );
4258  }
4259  }
4260  }
4261 
4262  // First retrieve them all (this should not be needed in future)
4263  const DecisionContainer* container = nullptr;
4264  for (const std::string& key : keys) ATH_CHECK( evtStore()->retrieve( container, key ) );
4265 
4266  std::stringstream ss;
4267  ss << "digraph {" << std::endl;
4268  ss << " node [shape=rectangle]" << std::endl;
4269  ss << " rankdir = BT" << std::endl;
4270 
4271  // Now process them
4272  for (const std::string& key : keys) {
4273  if ( not m_doDumpAllTrigComposite ) {
4274  if ( not key.starts_with( "HLTNav_") ) { // Nav containers should always start with HLTNav_
4275  continue;
4276  }
4277  }
4278  ATH_CHECK( evtStore()->retrieve( container, key ) );
4279  ATH_MSG_DEBUG("Processing collection " << key << " to be added to the navigation graph");
4280  // ss << " rank=same" << std::endl; // dot cannot handle this is seems
4281  bool writtenHeader = false;
4282  for (const Decision* tc : *container ) {
4283  // Output my ID in the graph.
4284  const DecisionContainer* container = dynamic_cast<const DecisionContainer*>( tc->container() );
4285  const ElementLink<DecisionContainer> selfEL = ElementLink<DecisionContainer>(*container, tc->index());
4286  std::vector<ElementLink<DecisionContainer>> seedELs = tc->objectCollectionLinks<DecisionContainer>("seed");
4287  const bool isHypoAlgNode = tc->name() == "H";
4288  const bool isComboHypoAlgNode = tc->name() == "CH";
4289  const std::vector<DecisionID>& decisions = tc->decisions();
4290  const uint32_t selfKey = selfEL.key();
4291  const uint32_t selfIndex = selfEL.index();
4292  if (m_dumpNavForChain != "") {
4293  bool doDump = false;
4294  // Check me
4295  for (DecisionID id : decisions) {
4296  if (chainIDs.count(id) == 1) {
4297  doDump = true;
4298  break;
4299  }
4300  }
4301  // Check my seeds
4302  if (!doDump and (isHypoAlgNode or isComboHypoAlgNode) and not m_excludeFailedHypoNodes) {
4303  for (const ElementLink<DecisionContainer>& s : seedELs) {
4304  const std::vector<DecisionID>& seedDecisions = (*s)->decisions();
4305  for (DecisionID id : seedDecisions) {
4306  if (chainIDs.count(id) == 1) {
4307  doDump = true;
4308  break;
4309  }
4310  }
4311  }
4312  }
4313  if (!doDump) {
4314  continue;
4315  }
4316  }
4317  if (!writtenHeader) {
4318  writtenHeader = true;
4319  ss << " subgraph " << key << " {" << std::endl;
4320  ss << " label=\"" << key << "\"" << std::endl;
4321  }
4322  const std::string scheme = "rdpu9";
4323  std::string color = "1";
4324  if (tc->name() == "L1") { color = "1"; }
4325  else if (tc->name() == "F") { color = "2"; }
4326  else if (tc->name() == "IM") { color = "3"; }
4327  else if (tc->name() == "H") { color = "4"; }
4328  else if (tc->name() == "CH") { color = "5"; }
4329  else if (tc->name() == "SF") { color = "6"; }
4330  else if (tc->name() == "HLTPassRaw") { color = "7"; }
4331  ss << " \"" << selfKey << "_" << selfIndex << "\" [colorscheme="<<scheme<<",style=filled,fillcolor="<<color<<",label=<<B>Container</B>=" << typeNameTC;
4332  if (tc->name() != "") ss << " <B>Name</B>=" << tc->name();
4333  ss << "<BR/><B>Key</B>=" << key << "<BR/><B>Index</B>=" << selfIndex;
4334  const bool isRemapped = tc->isRemapped();
4335  if (isHypoAlgNode) ss << " <B>linksRemapped</B>=" << (isRemapped ? "Y" : "N");
4336  if (decisions.size() > 0) {
4337  ss << "<BR/><B>Pass</B>=";
4338  size_t c = 0;
4339  for (unsigned decisionID : decisions) {
4340  HLT::Identifier dID(decisionID);
4341  std::string highlight = (dID.numeric() == chainID.numeric() ? "<B>[CHAIN:" : "");
4342  if (highlight == "" and chainIDs.count(dID.numeric()) == 1 and TrigCompositeUtils::isLegId(dID)) {
4343  highlight = "<B>[LEG" + std::to_string(TrigCompositeUtils::getIndexFromLeg(dID)) + ":";
4344  }
4345  ss << std::hex << highlight << decisionID << (!highlight.empty() ? "]</B>" : "") << std::dec << ",";
4346  if (c++ == 5) {
4347  ss << "<BR/>";
4348  c = 0;
4349  }
4350  }
4351  }
4352  ss << ">]" << std::endl;
4353  // Output all the things I link to
4354  size_t seedCount = 0;
4355  for (size_t i = 0; i < tc->linkColNames().size(); ++i) {
4356  const std::string link = tc->linkColNames().at(i);
4357  if (link == "seed" || link == "seed__COLL") {
4358  ElementLink<DecisionContainer> seedEL = seedELs.at(seedCount++);
4359  const uint32_t seedKey = tc->linkColKeys().at(i);
4360  const uint32_t seedIndex = tc->linkColIndices().at(i);
4361  ATH_CHECK( seedKey == seedEL.key() );
4362  ATH_CHECK( seedIndex == seedEL.index() );
4363  if (m_dumpNavForChain != "") { // Only print "seed" link to nodes we include in our search
4364  const std::vector<DecisionID> seedDecisions = (*seedEL)->decisions();
4365  bool doSeedLink = false;
4366  for (DecisionID id : seedDecisions) {
4367  if (chainIDs.count(id) == 1) {
4368  doSeedLink = true;
4369  break;
4370  }
4371  }
4372  if (!doSeedLink) {
4373  continue;
4374  }
4375  }
4376  ss << " \"" << selfKey << "_" << selfIndex << "\" -> \"" << seedKey << "_" << seedIndex << "\" [colorscheme="<<scheme<<",color=9,fontcolor=8,label=\"seed\"]" << std::endl;
4377  } else {
4378  // Start with my class ID
4379  std::string linkColour = "12";
4380  std::string linkBackground = "11";
4381  const std::string extScheme = "paired12";
4382  if (link == "roi") { linkColour="2"; linkBackground="1"; }
4383  else if (link == "initialRoI") { linkColour="2"; linkBackground="1"; }
4384  else if (link == "initialRecRoI") { linkColour="8"; linkBackground="7"; }
4385  else if (link == "feature") { linkColour="4"; linkBackground="3"; }
4386  else if (link == "view") { linkColour="10"; linkBackground="9"; }
4387  const CLID linkCLID = static_cast<CLID>( tc->linkColClids().at(i) );
4388  // Use it to get my class name
4389  std::string tname;
4390  ATH_CHECK(m_clidSvc->getTypeNameOfID(linkCLID, tname));
4391  // Now get the sgkey I'm linking to & the index
4392  const SG::sgkey_t key = (isRemapped ? static_cast<SG::sgkey_t>( tc->linkColKeysRemap().at(i) ) : static_cast<SG::sgkey_t>( tc->linkColKeys().at(i) ));
4393  const unsigned index = (isRemapped ? tc->linkColIndicesRemap().at(i) : tc->linkColIndices().at(i));
4394  // Look it up
4395  CLID checkCLID;
4396  const std::string* keyStr = evtStore()->keyToString(key, checkCLID); // I don't own this str
4397  if (keyStr != nullptr && checkCLID != linkCLID) {
4398  std::string tnameOfCheck;
4399  m_clidSvc->getTypeNameOfID(checkCLID, tnameOfCheck).ignore(); // Might be invalid. But we don't care.
4400  ATH_MSG_ERROR("Inconsistent CLID " << checkCLID << " [" << tnameOfCheck << "] stored in storegate for key " << key
4401  << ". We were expecting " << linkCLID << " [" << tname << "]");
4402  }
4403 
4404  std::string tnameEscape;
4405  for (std::string::const_iterator i = tname.begin(); i != tname.end(); ++i) {
4406  unsigned char c = *i;
4407  if (c == '<') {
4408  tnameEscape += "&lt;";
4409  } else if (c == '>') {
4410  tnameEscape += "&gt;";
4411  } else {
4412  tnameEscape += c;
4413  }
4414  }
4415 
4416  // Print
4417  ss << " \"" << selfKey << "_" << selfIndex << "\" -> \"" << key << "_" << index << "\" ";
4418  ss << "[colorscheme="<<extScheme<<",color="<<linkColour<<",fontcolor="<<linkColour<<",arrowhead=empty,label=\"" << link << "\"]" << std::endl;
4419 
4420  // Check if we are linking to self (e.g. a dummy-feature), don't output a new box for this
4421  const bool linkToSelf = (selfKey == key and selfIndex == index);
4422 
4423  if (converted.count(key + index) == 0 and not linkToSelf) {
4424  ss << " \"" << key << "_" << index << "\" [colorscheme="<<extScheme<<",style=filled,fillcolor="<<linkBackground<<",label=<<B>Container</B>=" << tnameEscape << "<BR/><B>Key</B>=";
4425  if (keyStr != nullptr) ss << *keyStr;
4426  else ss << "[<I>KEY "<< key <<" NOT IN STORE</I>] ";
4427  ss << "<BR/><B>Index</B>=" << index << ">]";
4428  }
4429 
4430  converted.insert(key + index);
4431  }
4432  }
4433  }
4434  if (writtenHeader) {
4435  ss << " }" << std::endl;
4436  }
4437  }
4438 
4439  ss << "}" << std::endl;
4440 
4441  returnValue.assign( ss.str() );
4442  return StatusCode::SUCCESS;
4443 }
4444 
4446 {
4447  // Get object from store
4448  const xAOD::TrigNavigation * navigationHandle = nullptr;
4449  ATH_CHECK( evtStore()->retrieve( navigationHandle, m_navigationHandleKey.key() ) );
4450  // Proper version doesn't work - conversion issue?
4451  //SG::ReadHandle< xAOD::TrigNavigation > navigationHandle = SG::ReadHandle< xAOD::TrigNavigation >( m_navigationHandleKey );
4452  //if ( !navigationHandle.isValid() ) ATH_MSG_FATAL( "Could not retrieve navigation" );
4453 
4454  // Get serialised navigation info
4455  const std::vector< unsigned int > serialisedNavigation = navigationHandle->serialized();
4456  ATH_MSG_INFO( "Serialised navigation size: " << serialisedNavigation.size() );
4457 
4458  // Convert the input
4459  HLT::Navigation* testNav = m_navigationTool.get();
4460  testNav->deserialize( serialisedNavigation );
4461 
4462  // Make a map of TE name hashes
4463  const xAOD::TriggerMenuContainer * testMenu = nullptr;
4464  ATH_CHECK( inputMetaStore()->retrieve( testMenu, "TriggerMenu" ) );
4465  std::map< int, std::string > hash2string;
4466  for ( auto const& sequence : testMenu->front()->sequenceInputTEs() ) {
4467  for ( auto const& name : sequence ) {
4469  hash2string[ hash ] = name;
4470  }
4471  }
4472 
4473  // Map TE names to chain names
4474  unsigned int chainCounter = 0;
4475  std::map< int, std::string > hash2chain;
4476  for ( auto const& chain : testMenu->front()->chainSignatureOutputTEs() ) {
4477 
4478  // Find the chain name
4479  std::string chainName = testMenu->front()->chainNames()[ chainCounter ];
4480  ++chainCounter;
4481 
4482  // Find all associated TEs
4483  for ( auto const& signature : chain ) {
4484  for ( auto const& name : signature ) {
4486  hash2string[ hash ] = name; // for decoding
4487  hash2chain[ hash ] = chainName;
4488  }
4489  }
4490  }
4491 
4492  // Define a map of TE features, to the TEs that use them. Needs a custom sort lambda
4493  auto cmpLambda = []( const HLT::TriggerElement::FeatureAccessHelper &lhs, const HLT::TriggerElement::FeatureAccessHelper &rhs) {
4494 
4495  // Compare indices if CLID matches
4496  if ( lhs.getCLID() == rhs.getCLID() ) return ( lhs.getIndex() < rhs.getIndex() );
4497 
4498  // Compare CLIDs
4499  else return ( lhs.getCLID() < rhs.getCLID() );
4500  };
4501  std::map< HLT::TriggerElement::FeatureAccessHelper, std::vector< HLT::TriggerElement* >, decltype(cmpLambda) > feature2element(cmpLambda);
4502 
4503  // Retrieve all TE features and add them to the map
4504  std::vector< HLT::TriggerElement* > allTEs;
4505  testNav->getAll( allTEs, false );
4506  for ( auto element : allTEs ) {
4507 
4508  // Add TE features to the big map
4509  for ( auto helper : element->getFeatureAccessHelpers() ) {
4510  feature2element[ helper ].push_back( element );
4511  }
4512  }
4513 
4514  // Debug - output all TEs and their ancestors
4515  // No duplication - only print terminal nodes
4516  for ( auto element : allTEs ) {
4517  if ( testNav->isTerminalNode( element ) ) {
4518  ATH_MSG_INFO( "+++++++++++ " << hash2string[ element->getId() ] << " is terminal node" );
4519  ATH_MSG_INFO( "ptr: " << element );
4520  std::queue< HLT::TriggerElement* > allAncestors;
4521  allAncestors.push( element );
4522  while ( allAncestors.size() ) {
4523 
4524  HLT::TriggerElement * thisElement = allAncestors.front();
4525  allAncestors.pop();
4526  auto theseAncestors = thisElement->getRelated( HLT::TriggerElement::Relation::seededByRelation );
4527 
4528  // Dump TE
4529  ATH_MSG_INFO( "te: " << thisElement->getId() << " " << hash2string[ thisElement->getId() ] );
4530  ATH_MSG_INFO( " chain: " << hash2chain[ thisElement->getId() ] );
4531  for ( const auto& helper : thisElement->getFeatureAccessHelpers() ) {
4532  ATH_MSG_INFO( " feat: " << helper );
4533  }
4534  ATH_MSG_INFO( theseAncestors.size() << " ancestors" );
4535 
4536  // Examine ancestors
4537  for ( auto ancestor : theseAncestors ) {
4538  allAncestors.push( ancestor );
4539  }
4540  }
4541  }
4542  }
4543 
4544  // Make the decision container
4546  auto decisionOutput = outputNavigation.ptr();
4547 
4548  // Find unique chains associated with a feature
4549  std::map< HLT::TriggerElement const*, std::vector< int > > element2decisions;
4550  for ( const auto& pair : feature2element ) {
4551 
4552  // Get the feature info
4553  std::string featureName = testNav->label( pair.first.getCLID(), pair.first.getIndex().subTypeIndex() );
4554  auto sgKey = evtStore()->stringToKey( featureName, pair.first.getCLID() );
4555 
4556  // Store RoIs with appropriate label ?
4557  std::string storeFeatureName = "feature";
4558 /* if ( pair.first.getCLID() == ClassID_traits< TrigRoiDescriptor >::ID() ) {
4559  storeFeatureName = "roi";
4560  }*/
4561 
4562  // Make a decision object for the feature
4563  auto decision = TrigCompositeUtils::newDecisionIn( decisionOutput );
4564  decision->typelessSetObjectLink( storeFeatureName, sgKey, pair.first.getCLID(), pair.first.getIndex().objectsBegin(), pair.first.getIndex().objectsEnd() );
4565 
4566  // Examine associated TEs, look for chains
4567  std::set< std::string > passedChains;
4568  for ( HLT::TriggerElement const* element : pair.second ) {
4569 
4570  // TODO - find out what chains actually passed!
4571  passedChains.insert( hash2chain[ element->getId() ] );
4572 
4573  // Index the TE
4574  int decisionNumber = decisionOutput->size() - 1;
4575  element2decisions[ element ].push_back( decisionNumber );
4576  }
4577 
4578  // Store unique chains in the decision
4579  for ( auto& chain : passedChains ) {
4581  }
4582  }
4583 
4584  // Store decision ancestry (had to go through once before to ensure indices populated)
4585  unsigned int decisionCounter = 0;
4586  for ( const auto& pair : feature2element ) {
4587 
4588  // Get current decision
4589  auto decision = decisionOutput->at( decisionCounter );
4590  ++decisionCounter;
4591 
4592  // Find ancestor TEs
4593  for ( auto element : pair.second ) {
4594  auto theseAncestors = element->getRelated( HLT::TriggerElement::Relation::seededByRelation );
4595  for ( auto ancestor : theseAncestors ) {
4596  for ( int decisionIndex : element2decisions[ ancestor ] ) {
4597  TrigCompositeUtils::linkToPrevious( decision, m_decisionsKey.key(), decisionIndex );
4598  }
4599  }
4600  }
4601  }
4602 
4603  return StatusCode::SUCCESS;
4604 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
TrigEDMChecker::m_navigationHandleKey
SG::ReadHandleKey< xAOD::TrigNavigation > m_navigationHandleKey
Definition: TrigEDMChecker.h:219
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
Trk::numberOfPixelHits
@ numberOfPixelHits
number of pixel layers on track with absence of hits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:57
xAOD::JetAttribute::BchCorrCell
@ BchCorrCell
Definition: JetAttributes.h:94
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
TrigEDMChecker::m_excludeFailedHypoNodes
Gaudi::Property< bool > m_excludeFailedHypoNodes
Definition: TrigEDMChecker.h:186
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:261
get_hdefs.buff
buff
Definition: get_hdefs.py:61
TrigEDMChecker::dumpxAODTrigElectronContainer
StatusCode dumpxAODTrigElectronContainer()
Definition: TrigEDMChecker.cxx:1668
Trk::py
@ py
Definition: ParamDefs.h:60
xAOD::JetAttribute::GhostTruthParticleCount
@ GhostTruthParticleCount
Definition: JetAttributes.h:54
TrigElectronContainer.h
TileTrackMuFeatureContainer.h
TrigEDMChecker::m_doDumpTrigEMCluster
bool m_doDumpTrigEMCluster
Definition: TrigEDMChecker.h:82
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
TrigEDMChecker::m_doDumpxAODJetContainer
bool m_doDumpxAODJetContainer
Definition: TrigEDMChecker.h:64
RecEmTauRoI.h
TrigInDetTrackFitPar::ez0
double ez0() const
variance of longitudinal impact parameter
Definition: TrigInDetTrackFitPar.h:244
ConvertOldHistosToNewHistos.converted
converted
Definition: ConvertOldHistosToNewHistos.py:40
xAOD::TauJetParameters::nIsolatedTracks
@ nIsolatedTracks
Definition: TauDefs.h:323
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
xAOD::JetAttribute::Sphericity
@ Sphericity
Definition: JetAttributes.h:174
TrigEDMChecker::m_doDumpNavigation
bool m_doDumpNavigation
Definition: TrigEDMChecker.h:183
color
Definition: jFexInputByteStreamTool.cxx:25
AthAnalysisAlgorithm
Definition: AthAnalysisAlgorithm.h:34
TrigElectronContainer.h
TrigTauContainer.h
Trk::TrackParticleBase::charge
double charge() const
Return charge of the particle.
Definition: TrackParticleBase.h:200
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
xAOD::TrigEMCluster_v1::eta
float eta() const
get Eta (calibrated)
HLT::TrigNavStructure::getAll
void getAll(std::vector< TriggerElement * > &output, const bool activeOnly=true) const
The query returning a collection of all TriggerElements.
Definition: TrigNavStructure.cxx:363
test_pyathena.px
px
Definition: test_pyathena.py:18
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
xAOD::JetAttribute::LArQuality
@ LArQuality
Definition: JetAttributes.h:83
TrigEDMChecker::m_muonPrinter
ToolHandle< Rec::IMuonPrintingTool > m_muonPrinter
Definition: TrigEDMChecker.h:214
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
TrigMuonEFCbTrack::getIDTrackParticle
const Rec::TrackParticle * getIDTrackParticle() const
Get associated ID track.
Definition: TrigMuonEFCbTrack.cxx:91
xAOD::JetAttribute::Dip23
@ Dip23
Definition: JetAttributes.h:153
TrigEDMChecker::m_doDumpTrigInDetTrackCollection
bool m_doDumpTrigInDetTrackCollection
Definition: TrigEDMChecker.h:149
HLT::HLTResult::isPassThrough
bool isPassThrough() const
forced-accepted (FA) event configuration the FA request(s) are set per chain and hlt level by the tig...
Definition: HLTResult.h:152
TrigCompositeUtils::DecisionID
unsigned int DecisionID
Definition: TrigComposite_v1.h:27
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
xAOD::JetAttribute::FracSamplingMax
@ FracSamplingMax
Definition: JetAttributes.h:116
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:117
xAOD::TauJetParameters::trFlightPathSig
@ trFlightPathSig
Definition: TauDefs.h:163
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ID
std::vector< Identifier > ID
Definition: CalibHitIDCheck.h:24
TrigEDMChecker::m_doDumpxAODTrigMissingET
bool m_doDumpxAODTrigMissingET
Definition: TrigEDMChecker.h:61
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
TrigMuonEFIsolation::sumEtCone04
float sumEtCone04() const
Definition: TrigMuonEFIsolation.h:65
TrigEDMChecker::m_doTDTCheck
bool m_doTDTCheck
Definition: TrigEDMChecker.h:170
ParticleTest.eg
eg
Definition: ParticleTest.py:29
HLT::TrigNavStructure::label
std::string label(class_id_type clid, const index_or_label_type &sti_or_label) const
Definition: TrigNavStructure.cxx:775
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
TrigConf::HLTChain::chain_name
const std::string & chain_name() const
Definition: TrigConfHLTData/TrigConfHLTData/HLTChain.h:72
TrigEDMChecker::dumpxAODTrigPhotonContainer
StatusCode dumpxAODTrigPhotonContainer()
Definition: TrigEDMChecker.cxx:1726
xAOD::JetAttribute::DipExcl12
@ DipExcl12
Definition: JetAttributes.h:154
HLT::Identifier::numeric
TrigCompositeUtils::DecisionID numeric() const
numeric ID
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:47
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
xAOD::JetAttribute::BchCorrJetForCell
@ BchCorrJetForCell
Definition: JetAttributes.h:205
xAOD::EgammaParameters::e2ts1
@ e2ts1
2nd max in strips calc by summing 3 strips
Definition: EgammaEnums.h:105
EmTau_ROI.h
TauJetParameters::tau1P3P
@ tau1P3P
Definition: TauJetParameters.h:36
xAOD::JetAttribute::FoxWolfram2
@ FoxWolfram2
Definition: JetAttributes.h:171
TBReadH8ByteStream-Monitor_jobOptions.SGkey
SGkey
Definition: TBReadH8ByteStream-Monitor_jobOptions.py:53
MuonFeature::radius
float radius(void) const
Definition: MuonFeature.h:49
xAOD::JetAttribute::isBadMedium
@ isBadMedium
Definition: JetAttributes.h:191
TrigEDMChecker::dumpxAODTrigMinBias
StatusCode dumpxAODTrigMinBias()
Definition: TrigEDMChecker.cxx:819
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
TrigTauTracksInfo::threeFastestTracks
const P4PtEtaPhiM & threeFastestTracks() const
Definition: TrigTauTracksInfo.h:50
TrigEDMChecker::m_doDumpTrigMuonEFContainer
bool m_doDumpTrigMuonEFContainer
Definition: TrigEDMChecker.h:111
TrigEDMChecker::m_doDumpTrigElectronContainer
bool m_doDumpTrigElectronContainer
Definition: TrigEDMChecker.h:125
xAOD::TrigEMCluster_v1::weta2
float weta2() const
get cluster width (based on a 3x5 cluster - 2nd layer)
TrigElectron.h
TrigEDMChecker::m_doDumpTrigL2BphysContainer
bool m_doDumpTrigL2BphysContainer
Definition: TrigEDMChecker.h:67
TrigInDetTrackFitPar::surfaceCoordinate
void surfaceCoordinate(double c)
Setter: surface reference coordinate for non-perigee surfaces.
Definition: TrigInDetTrackFitPar.h:228
TrigMuonEFIsolationContainer.h
TrigInDetTrackCollection
Definition: TrigInDetTrackCollection.h:13
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
xAOD::TrigComposite_v1::objectLink
ElementLink< CONTAINER > objectLink(const std::string &name) const
Get the link with the requested name.
xAOD::JetAttribute::OotFracCells10
@ OotFracCells10
Definition: JetAttributes.h:89
TrigMuonEFTrack
Definition: TrigMuonEFTrack.h:27
TrigEDMChecker::TrigEDMChecker
TrigEDMChecker(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TrigEDMChecker.cxx:112
TrigCompositeUtils::newDecisionIn
Decision * newDecisionIn(DecisionContainer *dc, const std::string &name)
Helper method to create a Decision object, place it in the container and return a pointer to it.
Definition: TrigCompositeUtilsRoot.cxx:46
TrigEDMChecker::m_dumpNavForChain
Gaudi::Property< std::string > m_dumpNavForChain
Definition: TrigEDMChecker.h:185
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
TrigEDMChecker::dumpNavigation
StatusCode dumpNavigation()
Definition: TrigEDMChecker.cxx:4445
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
xAOD::JetAttribute::Dip13
@ Dip13
Definition: JetAttributes.h:152
index
Definition: index.py:1
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TileMu::phi
float phi() const
Phi (average value at the TileCal radius)
Definition: TileMu.h:46
TrigTauTracksInfo::nCoreTracks
int nCoreTracks() const
Definition: TrigTauTracksInfo.h:39
SG::detail::IteratorBase::key
const std::string & key() const
Get the key string with which the current object was stored.
Definition: SGIterator.cxx:155
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
xAOD::JetConstituentVector::end
iterator end() const
iterator after the last constituent
Definition: JetConstituentVector.cxx:104
xAOD::JetAttribute::BchCorrJet
@ BchCorrJet
Definition: JetAttributes.h:204
TrigMuonEFInfoContainer.h
TrigInDetTrackFitPar
Definition: TrigInDetTrackFitPar.h:68
TrigEMCluster::Eta1
float Eta1() const
get Eta sampling 1 (strip layer)
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigEMCluster.h:129
TrigCompositeUtils::addDecisionID
void addDecisionID(DecisionID id, Decision *d)
Appends the decision (given as ID) to the decision object.
Definition: TrigCompositeUtilsRoot.cxx:61
CombinedMuonFeatureContainer
Definition: CombinedMuonFeatureContainer.h:14
TrigEDMChecker::m_dumpTrigCompositeContainers
std::vector< std::string > m_dumpTrigCompositeContainers
Definition: TrigEDMChecker.h:181
TrigEMCluster.h
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
xAOD::JetAttribute::N90Cells
@ N90Cells
Definition: JetAttributes.h:92
MuonFeature::dir_phi
float dir_phi(void) const
Definition: MuonFeature.h:52
I4Momentum::p
virtual double p() const =0
momentum magnitude
HLT::NavigationCore::deserialize
bool deserialize(const std::vector< uint32_t > &input)
Definition: NavigationCore.cxx:151
TrigMuonEFInfoTrack::hasExtrapolatedTrack
bool hasExtrapolatedTrack() const
Definition: TrigMuonEFInfoTrack.cxx:121
xAOD::JetInput::Track
@ Track
Definition: JetContainerInfo.h:61
validation.ofile
ofile
Definition: validation.py:96
TrigEMClusterContainer.h
xAOD::TrigBphys_v1::particleType
pType particleType() const
accessor method: particle Type
TrigEDMChecker::m_trackWarningNum
int m_trackWarningNum
Definition: TrigEDMChecker.h:224
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
TrigSpacePointCountsContainer.h
TrigEMCluster::phi
float phi() const
get Phi (calibrated)
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigEMCluster.h:116
xAOD::JetAttribute::FoxWolfram4
@ FoxWolfram4
Definition: JetAttributes.h:173
Trk::TrackParticleBase::trackSummary
const TrackSummary * trackSummary() const
accessor function for TrackSummary.
Definition: TrackParticleBase.h:247
skel.it
it
Definition: skel.GENtoEVGEN.py:396
TrigMuonEFCbTrack.h
HLT::TriggerElement::getId
te_id_type getId() const
reset internals.
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:43
xAOD::Iso::ptcone30
@ ptcone30
Definition: IsolationType.h:41
HLT::TriggerElement::FeatureAccessHelper::getCLID
class_id_type getCLID() const
Class ID of object.
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:208
test_pyathena.pt
pt
Definition: test_pyathena.py:11
HLT::TrigNavStructure::isTerminalNode
static bool isTerminalNode(const TriggerElement *te)
queries if node is terminal (no more TriggerElement are seeded by it)
Definition: TrigNavStructure.cxx:517
TrigEDMChecker::dumpxAODPhotonContainer
StatusCode dumpxAODPhotonContainer()
Definition: TrigEDMChecker.cxx:1925
MuonFeature::eta
float eta(void) const
Definition: MuonFeature.h:50
xAOD::Iso::ptcone20
@ ptcone20
Track isolation.
Definition: IsolationType.h:40
TrigMissingETContainer
Definition: Trigger/TrigEvent/TrigMissingEtEvent/TrigMissingEtEvent/TrigMissingETContainer.h:12
mc.diff
diff
Definition: mc.SFGenPy8_MuMu_DD.py:14
xAOD::Iso::etcone40
@ etcone40
Definition: IsolationType.h:34
TrigTrackCountsContainer.h
TrigInDetTrackFitPar::eta
void eta(const double eta)
Setter: pseudorapidity.
Definition: TrigInDetTrackFitPar.h:220
Trk::z0
@ z0
Definition: ParamDefs.h:64
TrigPhotonContainer.h
xAOD::JetConstituentVector::size
size_t size() const
number of constituents
Definition: JetConstituentVector.cxx:102
TrigEDMChecker::m_doDumpxAODTauJetContainer
bool m_doDumpxAODTauJetContainer
Definition: TrigEDMChecker.h:155
TrigEDMChecker::m_doDumpMuonFeature
bool m_doDumpMuonFeature
Definition: TrigEDMChecker.h:99
athena.value
value
Definition: athena.py:124
TrigInDetTrackFitPar::epT
double epT() const
variance of transverse momentum
Definition: TrigInDetTrackFitPar.h:250
TrigInDetTrackFitPar::z0
void z0(const double z0)
Setter: longitudinal impact parameter.
Definition: TrigInDetTrackFitPar.h:216
TrigCompositeUtils::createAndStore
SG::WriteHandle< DecisionContainer > createAndStore(const SG::WriteHandleKey< DecisionContainer > &key, const EventContext &ctx)
Creates and right away records the DecisionContainer with the key.
Definition: TrigCompositeUtilsRoot.cxx:30
TrigInDetTrackCollection.h
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
Analysis::TauJetContainer
Definition: Reconstruction/tauEvent/tauEvent/TauJetContainer.h:31
xAOD::JetAttribute::VoronoiArea
@ VoronoiArea
Definition: JetAttributes.h:45
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:275
TrigMuonEFTrack.h
xAOD::TrigBphys_v1::mass
float mass() const
accessor method: mass
xAOD::Iso::etcone30
@ etcone30
Definition: IsolationType.h:33
TrigEMCluster
Class with calibrated variables for egamma clustering.
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigEMCluster.h:31
xAOD::JetAttribute::EnergyPerSampling
@ EnergyPerSampling
Definition: JetAttributes.h:115
AthAnalysisAlgorithm::inputMetaStore
const ServiceHandle< StoreGateSvc > & inputMetaStore() const
Const accessor for the input metadata store.
Definition: AthAnalysisAlgorithm.h:49
Analysis::TauJet::jetLink
const ElementLink< JetCollection > jetLink() const
ElementLink to seed Jet, might be invalid if not seeded from a Jet
TrigPassBits.h
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
isValid
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:620
TrigConf::HLTChain
HLT chain configuration information.
Definition: TrigConfHLTData/TrigConfHLTData/HLTChain.h:35
HLTResult.h
xAOD::Jet_v1::getConstituents
JetConstituentVector getConstituents() const
Return a vector of consituents. The object behaves like vector<const IParticle*>. See JetConstituentV...
Definition: Jet_v1.cxx:147
xAOD::TrigBphys_v1::secondaryDecay
const TrigBphys_v1 * secondaryDecay() const
accessor method: secondary decay particle
JetConstituentVector.h
This file defines helper classes to deal with jet constituents.
xAOD::JetAttribute::CentroidR
@ CentroidR
Definition: JetAttributes.h:131
ViewHelper.h
I4Momentum::pt
virtual double pt() const =0
transverse momentum
xAOD::JetAttribute::SamplingMax
@ SamplingMax
Definition: JetAttributes.h:119
TrigEDMChecker::m_doDumpTrackParticleContainer
bool m_doDumpTrackParticleContainer
Definition: TrigEDMChecker.h:55
TrigMuonEFInfoTrack.h
TrigEMCluster::e277
float e277() const
get Energy in a 7x7 cluster (no calibration) around hottest cell
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigEMCluster.h:120
xAOD::JetAttribute::OotFracClusters10
@ OotFracClusters10
Definition: JetAttributes.h:86
MuonFeature::phi
float phi(void) const
Definition: MuonFeature.h:51
TrigT2MbtsBits.h
TrigMuonEFInfoTrack::hasSpectrometerTrack
bool hasSpectrometerTrack() const
Definition: TrigMuonEFInfoTrack.cxx:101
xAOD::JetAttribute::BchCorrDotx
@ BchCorrDotx
Definition: JetAttributes.h:203
xAOD::TauJetParameters::hadRadius
@ hadRadius
Get hadron calorimeter radius.
Definition: TauDefs.h:192
xAOD::numberOfBLayerHits
@ numberOfBLayerHits
these are the hits in the first pixel layer, i.e.
Definition: TrackingPrimitives.h:231
TrigTauTracksInfo::leadingTrackPt
float leadingTrackPt() const
Definition: TrigTauTracksInfo.h:44
xAOD::TrigComposite_v1::linkColClids
const std::vector< uint32_t > & linkColClids() const
Raw access to the persistent link CLIDs.
xAOD::TrigNavigation_v1::serialized
const std::vector< unsigned int > & serialized() const
expose the navigation information (in serialized form)
TrigConf::HLTChain::leg_multiplicities
const std::vector< size_t > & leg_multiplicities() const
Definition: TrigConfHLTData/TrigConfHLTData/HLTChain.h:82
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
xAOD::TauJetParameters::ipSigLeadTrk
@ ipSigLeadTrk
Definition: TauDefs.h:160
TrigInDetTrack
Definition: TrigInDetTrack.h:34
MuonFeature.h
xAOD::JetAttribute::LArBadHVEnergy
@ LArBadHVEnergy
Definition: JetAttributes.h:81
Trk::RecVertex
Trk::RecVertex inherits from Trk::Vertex.
Definition: RecVertex.h:44
TauJetAuxContainer.h
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Analysis::TauDetails
Definition: TauDetails.h:26
TrigEMCluster::weta2
float weta2() const
get cluster width (based on a 3x5 cluster - 2nd layer)
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigEMCluster.h:125
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
Analysis::TauJet::author
TauJetParameters ::Author author() const
Author of this object (DO NOT USE! only for backward compatibility)
Trk::numberOfBLayerHits
@ numberOfBLayerHits
these are the hits in the 0th pixel layer?
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:51
xAOD::TrigEMCluster_v1::e237
float e237() const
get Energy in a 3x7 cluster (no calibration) around hottest cell
HLT::TriggerElement::getRelated
const std::vector< TriggerElement * > & getRelated(Relation rel) const
returns reference to the likns to other TriggerElements related by relation r
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:127
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
TrigInDetTrackTruthMap::bestMatchTRT
const HepMcParticleLink * bestMatchTRT(const TrigInDetTrack *p_trig_trk) const
Definition: TrigInDetTrackTruthMap.cxx:134
TrigEDMChecker::m_doDumpxAODTrigEMCluster
bool m_doDumpxAODTrigEMCluster
Definition: TrigEDMChecker.h:89
TrigEDMChecker::dumpxAODVertex
StatusCode dumpxAODVertex()
Definition: TrigEDMChecker.cxx:3986
CombinedMuonFeature::IDTrackLink
const ElementLink< TrigInDetTrackCollection > & IDTrackLink(void) const
Definition: CombinedMuonFeature.h:68
run_Egamma1_LArStrip_Fex.dump
dump
Definition: run_Egamma1_LArStrip_Fex.py:88
TrigMuonEFIsolation
Definition: TrigMuonEFIsolation.h:24
TrigEDMChecker::m_doDumpxAODVertex
bool m_doDumpxAODVertex
Definition: TrigEDMChecker.h:164
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:112
TrigEDMChecker::m_doDumpTrigMuonEFInfoContainer
bool m_doDumpTrigMuonEFInfoContainer
Definition: TrigEDMChecker.h:114
xAOD::TauJetParameters::centFrac
@ centFrac
Get centrality fraction.
Definition: TauDefs.h:200
xAOD::TauJetParameters::dRmax
@ dRmax
Get maximal dR of tracks associated to calo-seeded tau.
Definition: TauDefs.h:226
TrigEMCluster::e
float e() const
get Energy (calibrated)
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigEMCluster.h:104
TileMu::quality
float quality() const
Quality flag (0 or 1): set to 0 if the "energy deposition path" is MIP like in all three samples (tig...
Definition: TileMu.h:60
TrigMuonEFIsolation::sumEtCone03
float sumEtCone03() const
Definition: TrigMuonEFIsolation.h:63
TrigEDMChecker::m_doDumpxAODTrigEMClusterContainer
bool m_doDumpxAODTrigEMClusterContainer
Definition: TrigEDMChecker.h:92
TrigEDMChecker::m_doDumpxAODTrigElectronContainer
bool m_doDumpxAODTrigElectronContainer
Definition: TrigEDMChecker.h:128
TrigEDMChecker.h
TrigInDetTrackTruthMap::hasTruth
bool hasTruth(const TrigInDetTrack *p_trig_trk) const
methods to get truth-match objects
Definition: TrigInDetTrackTruthMap.cxx:58
TrigEMCluster::fracs1
float fracs1() const
get Energy in a 7 strips (around hottest strip) minus energy in 3 strips divided by energy in 3 strip...
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigEMCluster.h:123
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
TrigEDMChecker::m_doDumpTrigEMClusterContainer
bool m_doDumpTrigEMClusterContainer
Definition: TrigEDMChecker.h:85
CombinedMuonFeatureContainer.h
ClassID_traits::ID
static const CLID & ID()
the CLID of T
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:50
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
xAOD::JetAttribute::ThrustMin
@ ThrustMin
Definition: JetAttributes.h:167
Analysis::TauCommonDetails
Basic detail class containing information for track and calo seeded tau reconstruction algorithms.
Definition: TauCommonDetails.h:38
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
xAOD::EgammaParameters::ethad
@ ethad
ET leakage into hadronic calorimeter with exclusion of energy in CaloSampling::TileGap3.
Definition: EgammaEnums.h:45
TrigTauTracksInfo
Definition: TrigTauTracksInfo.h:28
xAOD::JetConstituentVector::begin
iterator begin() const
iterator on the first constituent
Definition: JetConstituentVector.cxx:103
TrigEDMChecker::dumpxAODTrackParticle
StatusCode dumpxAODTrackParticle()
Definition: TrigEDMChecker.cxx:3866
TauDefs.h
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
xAOD::JetAttribute::HECQuality
@ HECQuality
Definition: JetAttributes.h:80
TauJetParameters::tauRec
@ tauRec
Definition: TauJetParameters.h:35
xAOD::TauJetParameters::etHadAtEMScale
@ etHadAtEMScale
Get Hadronic energy at EM scale.
Definition: TauDefs.h:196
TrigEDMChecker::m_doDumpAllTrigComposite
bool m_doDumpAllTrigComposite
Definition: TrigEDMChecker.h:180
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
P4PtEtaPhiM::phi
virtual double phi() const
get phi data member
Definition: P4PtEtaPhiM.h:109
xAOD::TrigEMCluster_v1::phi
float phi() const
get Phi (calibrated)
TrigMuonEFInfo.h
TrigEDMChecker::m_doDumpHLTResult
bool m_doDumpHLTResult
Definition: TrigEDMChecker.h:146
MuonFeature::dir_zeta
float dir_zeta(void) const
Definition: MuonFeature.h:54
TrigPhoton.h
TrigEDMChecker::dumpTrigPassBits
StatusCode dumpTrigPassBits()
Definition: TrigEDMChecker.cxx:582
TrigEDMChecker::~TrigEDMChecker
virtual ~TrigEDMChecker()
Definition: TrigEDMChecker.cxx:169
TrigMuonEFIsolation::sumTrkPtCone02
float sumTrkPtCone02() const
Definition: TrigMuonEFIsolation.h:54
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
HLTUtils.h
convertTimingResiduals.sum
sum
Definition: convertTimingResiduals.py:55
TrigEMCluster::e237
float e237() const
get Energy in a 3x7 cluster (no calibration) around hottest cell
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigEMCluster.h:118
xAOD::TrigPassBits_v1::containerClid
uint32_t containerClid() const
CLID of the target container.
TrigEDMChecker::dumpTrigL2BphysContainer
StatusCode dumpTrigL2BphysContainer()
Definition: TrigEDMChecker.cxx:2441
TrigConf::HLTUtils::string2hash
static HLTHash string2hash(const std::string &, const std::string &category="TE")
hash function translating TE names into identifiers
MuonFeature::saddress
int saddress(void) const
Definition: MuonFeature.h:47
ElectronContainer.h
Analysis::TauJet::numTrack
unsigned int numTrack() const
number of Tracks associated to Tau candidate, CAUTION not to be confused with numberOfTracks()!
xAOD::JetAttribute::FoxWolfram3
@ FoxWolfram3
Definition: JetAttributes.h:172
TrigPassBitsContainer.h
TrigMuonEFInfoTrack::CombinedTrack
TrigMuonEFCbTrack * CombinedTrack()
Definition: TrigMuonEFInfoTrack.h:52
MuonFeature::roiId
int roiId(void) const
Definition: MuonFeature.h:46
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
lumiFormat.i
int i
Definition: lumiFormat.py:85
TrigEDMChecker::m_doDumpxAODElectronContainer
bool m_doDumpxAODElectronContainer
Definition: TrigEDMChecker.h:134
xAOD::JetAttribute::NumTrkPt1000
@ NumTrkPt1000
Definition: JetAttributes.h:105
TrigMuonEFInfoTrack::SpectrometerTrack
TrigMuonEFTrack * SpectrometerTrack()
Definition: TrigMuonEFInfoTrack.h:50
TrigEDMChecker::m_doDumpTrigCompsiteNavigation
bool m_doDumpTrigCompsiteNavigation
Definition: TrigEDMChecker.h:203
TrigEDMChecker::dumpTrigComposite
StatusCode dumpTrigComposite()
Dump information on TrigComposite collections.
Definition: TrigEDMChecker.cxx:4116
TrigEDMChecker::m_doDumpTrigPhotonContainer
bool m_doDumpTrigPhotonContainer
Definition: TrigEDMChecker.h:108
xAOD::JetAttribute::Tau2
@ Tau2
Definition: JetAttributes.h:136
xAOD::Iso::etcone20
@ etcone20
Calorimeter isolation.
Definition: IsolationType.h:32
Trk::theta
@ theta
Definition: ParamDefs.h:66
xAOD::JetAttribute::EMFrac
@ EMFrac
Definition: JetAttributes.h:112
Photon.h
TrigInDetTrackFitPar::surfaceType
void surfaceType(TrigSurfaceType s)
Setter: surface type PERIGEE=0, BARREL=1, ENDCAP=2.
Definition: TrigInDetTrackFitPar.h:226
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Trk::numberOfSCTHits
@ numberOfSCTHits
number of SCT holes
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:71
SG::WriteHandle::ptr
pointer_type ptr()
Dereference the pointer.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TrigEDMChecker::m_doDumpStoreGate
bool m_doDumpStoreGate
Definition: TrigEDMChecker.h:167
TrigBphys.h
xAOD::JetAttribute::GhostTrackCount
@ GhostTrackCount
Definition: JetAttributes.h:53
xAOD::TauJetParameters::trkAvgDist
@ trkAvgDist
Get calibrated EM transverse energy (DEPRECATED since r19)
Definition: TauDefs.h:214
HLT::TriggerElement
TriggerElement is the basic ingreedient of the interface between HLT algorithms and the navigation It...
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:27
xAOD::TrigPassBits_v1::size
uint32_t size() const
The size of the target container.
xAOD::TauJetParameters::nChargedTracks
@ nChargedTracks
Definition: TauDefs.h:322
xAOD::TrigPassBits_v1
Type describing which elements in a container passed a trigger chain.
Definition: TrigPassBits_v1.h:38
TriggerElement.h
TrigEDMChecker::initialize
virtual StatusCode initialize() override
Definition: TrigEDMChecker.cxx:171
LVL1_ROI.h
xAOD::JetAttribute::KtDR
@ KtDR
Definition: JetAttributes.h:134
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:40
Analysis::TauJet
Object for taus common for ESD and AOD.
Definition: Reconstruction/tauEvent/tauEvent/TauJet.h:61
xAOD::JetAttribute::SumPtTrkPt1000
@ SumPtTrkPt1000
Definition: JetAttributes.h:107
TrigVertexCountsContainer.h
calibdata.exception
exception
Definition: calibdata.py:496
TrigInDetTrackTruthMap
Definition: TrigInDetTrackTruthMap.h:38
xAOD::TrigBphys_v1::roiId
uint32_t roiId() const
accessor method: ID of L1 RoI
xAOD::EgammaParameters::e011
@ e011
uncalibrated energy (sum of cells) in presampler in a 1x1 window in cells in eta X phi
Definition: EgammaEnums.h:30
ATLAS_NOT_THREAD_SAFE
StatusCode TrigEDMChecker::do_execute ATLAS_NOT_THREAD_SAFE()
Install fatal handler with default options.
Definition: TrigEDMChecker.cxx:259
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:523
TrigEDMChecker::dumpHLTResult
StatusCode dumpHLTResult()
Definition: TrigEDMChecker.cxx:2108
xAOD::JetAttribute::FoxWolfram0
@ FoxWolfram0
Definition: JetAttributes.h:169
ParticleGun_EoverP_Config.pid
pid
Definition: ParticleGun_EoverP_Config.py:62
TrigPhotonContainer.h
Trk::px
@ px
Definition: ParamDefs.h:59
TrigEDMChecker::TrigCompositeNavigationToDot
StatusCode TrigCompositeNavigationToDot(std::string &returnValue, bool &pass)
Construct graph of HLT navigation in Run-3.
Definition: TrigEDMChecker.cxx:4219
xAOD::JetAttribute::Timing
@ Timing
Definition: JetAttributes.h:90
xAOD::JetAttribute::Tau1
@ Tau1
Definition: JetAttributes.h:135
TrigEDMChecker::dumpTrigT2MBTSBits
void dumpTrigT2MBTSBits()
Definition: TrigEDMChecker.cxx:681
TrigEDMChecker::m_doDumpTrigEFBphysContainer
bool m_doDumpTrigEFBphysContainer
Definition: TrigEDMChecker.h:70
TrigEDMChecker::dumpTrigTrackCounts
void dumpTrigTrackCounts()
Definition: TrigEDMChecker.cxx:749
JetTagCalibConfig.scheme
scheme
Definition: JetTagCalibConfig.py:16
TrigEDMChecker::m_doDumpxAODPhotonContainer
bool m_doDumpxAODPhotonContainer
Definition: TrigEDMChecker.h:137
TrigTrackCounts.h
I4Momentum::eta
virtual double eta() const =0
pseudo rapidity
TrigEDMChecker::dumpxAODElectronContainer
StatusCode dumpxAODElectronContainer()
Definition: TrigEDMChecker.cxx:1769
TrigInDetTrackFitPar::cov
void cov(const std::vector< double > *cov)
Setter: covariance matrix of track parameters.
Definition: TrigInDetTrackFitPar.h:224
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::TauJetParameters::etOverPtLeadTrk
@ etOverPtLeadTrk
Definition: TauDefs.h:158
TrigMissingETContainer.h
TauJetContainer.h
TrigMuonEFIsolation::sumEtCone01
float sumEtCone01() const
Definition: TrigMuonEFIsolation.h:59
TrigEMCluster.h
xAOD::JetAttribute::Tau3
@ Tau3
Definition: JetAttributes.h:137
xAOD::JetAttribute::JVF
@ JVF
Definition: JetAttributes.h:99
TrigMuonEFInfo::hasTrack
bool hasTrack() const
Definition: TrigMuonEFInfo.cxx:341
TrigEDMChecker::m_doDumpxAODMuonContainer
bool m_doDumpxAODMuonContainer
Definition: TrigEDMChecker.h:119
HLT::Navigation
The Navigation class, organizes TriggerElements into the tree structure.
Definition: Navigation.h:100
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
TrigEDMChecker::printMuonTrk
void printMuonTrk(const TrigMuonEFTrack *muonTrack)
Definition: TrigEDMChecker.cxx:1540
Trk::ParametersBase
Definition: ParametersBase.h:55
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
TrigEDMChecker::m_doDumpxAODTrackParticle
bool m_doDumpxAODTrackParticle
Definition: TrigEDMChecker.h:161
Trk::Vertex::position
const Amg::Vector3D & position() const
return position of vertex
Definition: Vertex.cxx:72
HLT::HLTResult
HLT::HLTResult is sumarising result of trigger decision evaluation (online/offline) It contains basic...
Definition: HLTResult.h:57
TrigMuonEFInfoTrackContainer
Definition: TrigMuonEFInfoTrackContainer.h:27
xAOD::JetAttribute::IsoKR20Par
@ IsoKR20Par
Definition: JetAttributes.h:196
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:270
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
Analysis::TauJet::clusterLink
const ElementLink< CaloClusterContainer > clusterLink() const
ElementLink to seed CaloCluster, DEPRECATED as of release 13
TrigEDMChecker::m_doDumpCombinedMuonFeature
bool m_doDumpCombinedMuonFeature
Definition: TrigEDMChecker.h:95
xAOD::TrigBphys_v1::fitmass
float fitmass() const
accessor method: mass from vertex fit
HLT::HLTResult::isAccepted
bool isAccepted() const
gets HLT decision
Definition: HLTResult.h:137
TauJetContainer.h
TrigTauTracksInfo::charge
float charge() const
Definition: TrigTauTracksInfo.h:43
TrigEDMChecker::m_doDumpTrigTauContainer
bool m_doDumpTrigTauContainer
Definition: TrigEDMChecker.h:140
TrigEDMChecker::dumpxAODJetContainer
StatusCode dumpxAODJetContainer()
Definition: TrigEDMChecker.cxx:2538
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
P4PtEtaPhiM::pt
virtual double pt() const
get pt data member
Definition: P4PtEtaPhiM.h:103
HLT::Identifier
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:20
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
xAOD::JetAttribute::N90Constituents
@ N90Constituents
Definition: JetAttributes.h:91
TileMuFeatureContainer.h
I4Momentum::phi
virtual double phi() const =0
phi in [-pi,pi[
CombinedMuonFeature
Definition: CombinedMuonFeature.h:30
xAOD::TauJetParameters::massTrkSys
@ massTrkSys
Definition: TauDefs.h:161
xAOD::decisions
decisions
Definition: TrigComposite_v1.cxx:101
TauJetParameters::emRadius
@ emRadius
Definition: TauJetParameters.h:149
TrigEMCluster::eta
float eta() const
get Eta (calibrated)
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigEMCluster.h:114
HLT::HLTResult::isEmpty
bool isEmpty() const
true if result is empty
Definition: HLTResult.cxx:626
TrigTauTracksInfo.h
TrigEFBjetContainer.h
LVL1_ROI
Top level AOD object storing LVL1 RoIs.
Definition: LVL1_ROI.h:43
TrigMuonEFInfoTrack::ExtrapolatedTrack
TrigMuonEFTrack * ExtrapolatedTrack()
Definition: TrigMuonEFInfoTrack.h:51
TrigEDMChecker::dumpTrigEFBphysContainer
StatusCode dumpTrigEFBphysContainer()
Definition: TrigEDMChecker.cxx:2343
TrigInDetTrackTruth
Definition: TrigInDetTrackTruth.h:36
TriggerMenuContainer.h
merge.output
output
Definition: merge.py:17
Trig::ChainGroup
Definition: ChainGroup.h:51
xAOD::TrigEMCluster_v1::fracs1
float fracs1() const
get Energy in a 7 strips (around hottest strip) minus energy in 3 strips divided by energy in 3 strip...
xAOD::JetAttribute::OotFracCells5
@ OotFracCells5
Definition: JetAttributes.h:88
TrigInDetTrackFitPar::eeta
double eeta() const
variance of pseudorapidity
Definition: TrigInDetTrackFitPar.h:248
TrigInDetTrackFitPar::ea0
double ea0() const
variance of transverse impact parameter
Definition: TrigInDetTrackFitPar.h:242
TrigEDMChecker::m_doDumpTrigEFBjetContainer
bool m_doDumpTrigEFBjetContainer
Definition: TrigEDMChecker.h:73
MuonFeature
Definition: MuonFeature.h:21
xAOD::JetAttribute::IsoKR20Perp
@ IsoKR20Perp
Definition: JetAttributes.h:197
TrigEDMChecker::m_doDumpTileTrackMuFeature
bool m_doDumpTileTrackMuFeature
Definition: TrigEDMChecker.h:105
Trig::ChainGroup::isPassed
bool isPassed(unsigned int condition=TrigDefs::Physics) const
tells if chain group passed
Definition: ChainGroup.cxx:208
TrigEDMChecker::m_clidSvc
ServiceHandle< ::IClassIDSvc > m_clidSvc
Definition: TrigEDMChecker.h:216
Trk::numberOfTRTHits
@ numberOfTRTHits
number of TRT outliers
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:79
Amg::py
@ py
Definition: GeoPrimitives.h:39
TrigMuonEFIsolation::getEFMuonInfoTrack
const TrigMuonEFInfoTrack * getEFMuonInfoTrack() const
Access the muon we calculated the isolation for.
Definition: TrigMuonEFIsolation.cxx:131
TrigEMCluster::ehad1
float ehad1() const
get hadronic Energy (first hadronic layer)
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigEMCluster.h:127
Analysis
The namespace of all packages in PhysicsAnalysis/JetTagging.
Definition: BTaggingCnvAlg.h:20
TrigEMCluster::energy
float energy() const
get Energy (calibrated)
Definition: Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigEMCluster.h:102
xAOD::JetAttribute::AverageLArQF
@ AverageLArQF
Definition: JetAttributes.h:85
TrigEDMChecker::dumpTrigVertexCounts
void dumpTrigVertexCounts()
Definition: TrigEDMChecker.cxx:715
Trk::TrackParticleBase::reconstructedVertex
const VxCandidate * reconstructedVertex() const
Get a pointer to the primary vertex.
Definition: TrackParticleBase.h:215
Trk::TrackSummary
A summary of the information contained by a track.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:287
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
TrigInDetTrackFitPar::ephi0
double ephi0() const
variance of azimuthal angle of the momentum
Definition: TrigInDetTrackFitPar.h:246
Trk::d0
@ d0
Definition: ParamDefs.h:63
TrigMuonEFInfoTrack::MuonType
unsigned short int MuonType() const
Definition: TrigMuonEFInfoTrack.h:58
TrigMuonEFCbTrack
Definition: TrigMuonEFCbTrack.h:28
TauJetParameters::unknown
@ unknown
Definition: TauJetParameters.h:34
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
TrigInDetTrackTruthMap.h
Trk::perigeeParameters
@ perigeeParameters
Definition: MeasurementType.h:19
xAOD::TrigPassBits_v1::passBits
const std::vector< uint32_t > & passBits() const
The internal bitmap created with the hypo decisions.
xAOD::JetAttribute::SumPtTrkPt500
@ SumPtTrkPt500
Definition: JetAttributes.h:108
P4PtEtaPhiM::eta
virtual double eta() const
get eta data member
Definition: P4PtEtaPhiM.h:106
TrigL2BjetContainer.h
TrigMuonEFIsolation::trackPosition
int trackPosition() const
Position of the muon in the TrigMuonEFInfoTrack container.
Definition: TrigMuonEFIsolation.h:68
TrigInDetTrackTruthMap::bestMatchSi
const HepMcParticleLink * bestMatchSi(const TrigInDetTrack *p_trig_trk) const
Definition: TrigInDetTrackTruthMap.cxx:114
TrigEDMChecker::m_muonTracksKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_muonTracksKey
Definition: TrigEDMChecker.h:218
TileMu::enedep
const std::vector< float > & enedep() const
Energy deposition by the muons in TileCal: 1st component: energy deposited in innermost layer (A cell...
Definition: TileMu.h:54
Rec::TrackParticleContainer
Definition: Reconstruction/Particle/Particle/TrackParticleContainer.h:33
xAOD::TrigEMCluster_v1::e277
float e277() const
get Energy in a 7x7 cluster (no calibration) around hottest cell
xAOD::JetAttribute::ThrustMaj
@ ThrustMaj
Definition: JetAttributes.h:168
xAOD::EgammaParameters::deltaPhi2
@ deltaPhi2
difference between the cluster phi (second sampling) and the phi of the track extrapolated to the sec...
Definition: EgammaEnums.h:204
AthHistogramming::hash
hash_t hash(const std::string &histName) const
Method to calculate a 32-bit hash from a string.
Definition: AthHistogramming.h:428
xAOD::JetAttribute::Aplanarity
@ Aplanarity
Definition: JetAttributes.h:175
xAOD::JetAttribute::TrackWidthPt1000
@ TrackWidthPt1000
Definition: JetAttributes.h:109
TrigMuonEFInfoTrack::hasCombinedTrack
bool hasCombinedTrack() const
Definition: TrigMuonEFInfoTrack.cxx:111
item
Definition: ItemListSvc.h:43
SG::sgkey_t
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
Definition: CxxUtils/CxxUtils/sgkey_t.h:32
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
xAOD::TrigBphys_v1::phi
float phi() const
accessor method: phi
TrigMuonEFIsolation::sumTrkPtCone03
float sumTrkPtCone03() const
Definition: TrigMuonEFIsolation.h:56
TrigEDMChecker::m_doDumpTrigMuonEFIsolationContainer
bool m_doDumpTrigMuonEFIsolationContainer
Definition: TrigEDMChecker.h:122
xAOD::TrigComposite_v1::linkColNames
const std::vector< std::string > & linkColNames() const
Raw access to the persistent link names.
xAOD::JetAttribute::FoxWolfram1
@ FoxWolfram1
Definition: JetAttributes.h:170
xAOD::CaloCluster_v1::PHICALOFRAME
@ PHICALOFRAME
Phi in the calo frame (for egamma)
Definition: CaloCluster_v1.h:188
ParticleGun_SamplingFraction.radius
radius
Definition: ParticleGun_SamplingFraction.py:96
TrigCompositeUtils::createLegName
HLT::Identifier createLegName(const HLT::Identifier &chainIdentifier, size_t counter)
Generate the HLT::Identifier which corresponds to a specific leg of a given chain.
Definition: TrigCompositeUtilsRoot.cxx:166
RoiDescriptorStore.h
MuonContainer.h
xAOD::JetAttribute::PtTruth
@ PtTruth
Definition: JetAttributes.h:194
Rec::TrackParticle
Definition: Reconstruction/Particle/Particle/TrackParticle.h:47
TrigTauClusterContainer.h
Rec::TrackParticle::measuredPerigee
const Trk::Perigee * measuredPerigee() const
Accessor method for Perigee.
Definition: Reconstruction/Particle/Particle/TrackParticle.h:180
python.copyTCTOutput.chains
chains
Definition: copyTCTOutput.py:81
TrigT2MbtsBitsContainer.h
xAOD::Iso::ptcone40
@ ptcone40
Definition: IsolationType.h:42
TauJet
@ TauJet
Definition: TruthClasses.h:47
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
TrigMuonEFInfoTrack
Definition: TrigMuonEFInfoTrack.h:22
xAOD::TrigEMCluster_v1::ehad1
float ehad1() const
get hadronic Energy (first hadronic layer)
TrigEMClusterContainer.h
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
TrigEDMChecker::dumpTrigSpacePointCounts
void dumpTrigSpacePointCounts()
Definition: TrigEDMChecker.cxx:613
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
TrigCompositeUtils::linkToPrevious
void linkToPrevious(Decision *d, const std::string &previousCollectionKey, size_t previousIndex)
Links to the previous object, location of previous 'seed' decision supplied by hand.
Definition: TrigCompositeUtilsRoot.cxx:139
TrigInDetTrackFitPar::a0
void a0(const double a0)
Setter: transverse impact parameter.
Definition: TrigInDetTrackFitPar.h:214
TrigEDMChecker::m_doDumpTrigVertexCollection
bool m_doDumpTrigVertexCollection
Definition: TrigEDMChecker.h:152
TrigCompositeUtils::isLegId
bool isLegId(const HLT::Identifier &legIdentifier)
Recognise whether the chain ID is a leg ID.
Definition: TrigCompositeUtilsRoot.cxx:204
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
DeMoScan.index
string index
Definition: DeMoScan.py:364
TrigEDMChecker::execute
virtual StatusCode execute() override
Definition: TrigEDMChecker.cxx:243
TrigCompositeUtils::LinkInfo< xAOD::IParticleContainer >
VertexContainer.h
TrigCompositeUtils::getIndexFromLeg
int32_t getIndexFromLeg(const HLT::Identifier &legIdentifier)
Extract the numeric index of a leg identifier.
Definition: TrigCompositeUtilsRoot.cxx:191
TrigCompositeUtils::DecisionIDContainer
std::set< DecisionID > DecisionIDContainer
Definition: TrigComposite_v1.h:28
xAOD::JetAttribute::LArBadHVRatio
@ LArBadHVRatio
Definition: JetAttributes.h:82
TrigEDMChecker::dumpxAODTrigMissingET
StatusCode dumpxAODTrigMissingET()
Definition: TrigEDMChecker.cxx:833
HLT::TriggerElement::FeatureAccessHelper::getIndex
const ObjectIndex & getIndex() const
index in the external ojects array
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:209
TrigEDMChecker::m_doDumpLVL1_ROI
bool m_doDumpLVL1_ROI
Definition: TrigEDMChecker.h:52
TrigEDMChecker::dumpTrackParticleContainer
StatusCode dumpTrackParticleContainer()
Definition: TrigEDMChecker.cxx:1064
JetContainer.h
TrigMuonEFInfoTrackContainer.h
HLT::TriggerElement::FeatureAccessHelper
the FeatureAccessHelper is a class used to keep track of features attached to this TE.
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:192
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
xAOD::TauJetParameters::ChPiEMEOverCaloEME
@ ChPiEMEOverCaloEME
Definition: TauDefs.h:278
TrigRoiDescriptorCollection
Definition: TrigRoiDescriptorCollection.h:21
xAOD::JetAttribute::VoronoiAreaPy
@ VoronoiAreaPy
Definition: JetAttributes.h:48
TrigInDetTrackTruthMap::bestMatchSiHits
int bestMatchSiHits(const TrigInDetTrack *p_trig_trk) const
Definition: TrigInDetTrackTruthMap.cxx:123
TrigEDMChecker::m_doDumpxAODTrigPhotonContainer
bool m_doDumpxAODTrigPhotonContainer
Definition: TrigEDMChecker.h:131
TrigMissingETContainer.h
Trk::VxCandidate
Definition: VxCandidate.h:27
Analysis::TauJet::trackLinkVector
const ElementLinkVector< Rec::TrackParticleContainer > & trackLinkVector() const
Get track link vector.
xAOD::TrigEMCluster_v1::eta1
float eta1() const
get Eta sampling 1 (strip layer)
xAOD::JetAttribute::GhostMuonSegmentCount
@ GhostMuonSegmentCount
Definition: JetAttributes.h:52
TrigTauTracksInfo::nIsoTracks
int nIsoTracks() const
Definition: TrigTauTracksInfo.h:41
TauJet.h
TileMu::eta
float eta() const
Eta (computed as the average of the eta values of the TileCal cells where the muon goes through)
Definition: TileMu.h:43
DEBUG
#define DEBUG
Definition: page_access.h:11
python.TriggerAPI.TriggerAPISession.chainName
chainName
Definition: TriggerAPISession.py:426
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
xAOD::JetAttribute::TrackWidthPt500
@ TrackWidthPt500
Definition: JetAttributes.h:110
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
ElementLinkVector::size
size_type size() const
Definition: AthLinks/ElementLinkVector.h:294
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
TrigEDMChecker::m_doDumpTrigTauClusterContainer
bool m_doDumpTrigTauClusterContainer
Definition: TrigEDMChecker.h:79
TrigMissingETAuxContainer.h
TrigEDMChecker::m_doDumpTauJetContainer
bool m_doDumpTauJetContainer
Definition: TrigEDMChecker.h:158
xAOD::JetAttribute::Width
@ Width
Definition: JetAttributes.h:122
RoiSerialise.h
xAOD::JetAttribute::OotFracClusters5
@ OotFracClusters5
Definition: JetAttributes.h:87
xAOD::TauJetParameters::isolFrac
@ isolFrac
Get isolation fraction.
Definition: TauDefs.h:198
TrigEDMChecker::dumpxAODMuonContainer
StatusCode dumpxAODMuonContainer()
Definition: TrigEDMChecker.cxx:1345
TrigEDMChecker::m_navigationTool
ToolHandle< HLT::Navigation > m_navigationTool
Definition: TrigEDMChecker.h:221
TrigEDMChecker::checkTrigCompositeElementLink
StatusCode checkTrigCompositeElementLink(const xAOD::TrigComposite *tc, size_t element)
Dump details on element links within TrigComposites.
Definition: TrigEDMChecker.cxx:4154
TrigCompositeUtils
Definition: Event/xAOD/xAODTrigger/xAODTrigger/TrigComposite.h:19
TrigTauTracksInfo::nSlowTracks
int nSlowTracks() const
Definition: TrigTauTracksInfo.h:40
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
TrigInDetTrackTruthMap::truth
const TrigInDetTrackTruth * truth(const TrigInDetTrack *p_trig_trk) const
Definition: TrigInDetTrackTruthMap.cxx:82
TrigMuonEFInfo::TrackContainer
const TrigMuonEFInfoTrackContainer * TrackContainer() const
Definition: TrigMuonEFInfo.h:94
HLT::HLTResult::size
unsigned int size() const
Definition: HLTResult.cxx:612
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
xAOD::TrigNavigation_v1
Interface to the raw trigger navigation information of the event.
Definition: TrigNavigation_v1.h:34
TrigEDMChecker::m_decisionsKey
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > m_decisionsKey
Definition: TrigEDMChecker.h:220
xAOD::JetAttribute::isBadLoose
@ isBadLoose
Definition: JetAttributes.h:190
SG::ConstAccessor< T, AuxAllocator_t< T > >::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
Track
Definition: TriggerChamberClusterOnTrackCreator.h:21
xAOD::JetAttribute::HECFrac
@ HECFrac
Definition: JetAttributes.h:113
HLT::TriggerElement::getFeatureAccessHelpers
const std::vector< FeatureAccessHelper > & getFeatureAccessHelpers() const
returns all features which ara attached to this TE
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:238
MuonFeature::pt
float pt(void) const
Definition: MuonFeature.h:48
xAOD::JetConstituentVector
A vector of jet constituents at the scale used during jet finding.
Definition: JetConstituentVector.h:117
Trk::phi
@ phi
Definition: ParamDefs.h:75
TrigRoiDescriptor.h
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
merge.status
status
Definition: merge.py:17
TrigMuonEFIsolation::getMuonInfo
const TrigMuonEFInfo * getMuonInfo() const
Access the muon info object we calculated the isolation for.
Definition: TrigMuonEFIsolation.cxx:122
Electron.h
xAOD::JetConstituentVector::iterator
Definition: JetConstituentVector.h:121
xAOD::EgammaParameters::e132
@ e132
uncalibrated energy (sum of cells) in strips in a 3x2 window in cells in eta X phi
Definition: EgammaEnums.h:36
xAOD::JetAttribute::ActiveArea
@ ActiveArea
Definition: JetAttributes.h:42
TrigTauTracksInfo::scalarPtSumCore
float scalarPtSumCore() const
Definition: TrigTauTracksInfo.h:46
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
xAOD::EgammaParameters::e237
@ e237
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 3x7
Definition: EgammaEnums.h:77
xAOD::TrackParticle_v1::track
const Trk::Track * track() const
Returns a pointer (which can be NULL) to the Trk::Track which was used to make this TrackParticle.
Definition: TrackParticle_v1.cxx:805
View.h
TrigInDetTrackTruth::nrMatches
unsigned int nrMatches() const
returns number of matching particles
Definition: TrigInDetTrackTruth.cxx:244
xAOD::JetAttribute::FracSamplingMaxIndex
@ FracSamplingMaxIndex
Definition: JetAttributes.h:117
TrigVertexCounts.h
LVL1_ROI::getEmTauROIs
const emtaus_type & getEmTauROIs() const
Get all the em/tau RoIs in the event.
Definition: LVL1_ROI.h:65
xAOD::EgammaParameters::deltaEta1
@ deltaEta1
difference between the cluster eta (first sampling) and the eta of the track extrapolated to the firs...
Definition: EgammaEnums.h:184
MuonFeature::beta
float beta(void) const
Definition: MuonFeature.h:55
Trig::ChainGroup::getListOfTriggers
std::vector< std::string > getListOfTriggers() const
Definition: ChainGroup.cxx:467
TrigMuonEFContainer.h
xAOD::TrigBphys_v1::eta
float eta() const
accessor method: eta
TrigEDMChecker::m_doDumpTrigMissingET
bool m_doDumpTrigMissingET
Definition: TrigEDMChecker.h:58
xAOD::TrigEMCluster_v1
Description of a trigger EM cluster.
Definition: TrigEMCluster_v1.h:28
TrigBphysContainer.h
TrigMuonEFIsolation::sumEtCone02
float sumEtCone02() const
Definition: TrigMuonEFIsolation.h:61
Analysis::TauJet::cellClusterLink
const ElementLink< CaloClusterContainer > cellClusterLink() const
ElementLink to cell CaloCluster, might be invalid the ID variables are calculated from this cluster i...
xAOD::EgammaParameters::e2tsts1
@ e2tsts1
energy of the cell corresponding to second energy maximum in the first sampling
Definition: EgammaEnums.h:108
xAOD::JetAttribute::isBadTight
@ isBadTight
Definition: JetAttributes.h:192
xAOD::CaloCluster_v1::ETACALOFRAME
@ ETACALOFRAME
Eta in the calo frame (for egamma)
Definition: CaloCluster_v1.h:187
xAOD::JetAttribute::VoronoiAreaPz
@ VoronoiAreaPz
Definition: JetAttributes.h:49
TrigInDetTrackFitPar::phi0
void phi0(const double phi0)
Setter: azimuthal angle of the momentum.
Definition: TrigInDetTrackFitPar.h:218
checker_macros.h
Define macros for attributes used to control the static checker.
CombinedMuonFeature::muFastTrackLink
const ElementLink< MuonFeatureContainer > & muFastTrackLink(void) const
Definition: CombinedMuonFeature.h:67
jet::ExtendedBool::UNSET
@ UNSET
Definition: UncertaintyEnum.h:232
xAOD::JetAttribute::NumTrkPt500
@ NumTrkPt500
Definition: JetAttributes.h:106
xAOD::TauJetParameters::PSSFraction
@ PSSFraction
Definition: TauDefs.h:277
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
TrigEDMChecker::m_trigDec
PublicToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: TrigEDMChecker.h:222
INACTIVE
@ INACTIVE
Definition: ZdcID.h:21
xAOD::numberOfTRTHoles
@ numberOfTRTHoles
number of TRT holes [unit8_t].
Definition: TrackingPrimitives.h:277
xAOD::EgammaParameters::e335
@ e335
uncalibrated energy (sum of cells) of the third sampling in a rectangle of size 3x5
Definition: EgammaEnums.h:86
TrigEDMChecker::m_doDumpxAODTrigMinBias
bool m_doDumpxAODTrigMinBias
Definition: TrigEDMChecker.h:173
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
xAOD::TauJetParameters::EMRadius
@ EMRadius
Get E_T radius.
Definition: TauDefs.h:190
EnergySum_ROI.h
Trk::TrackParticleBase::originalTrack
const Track * originalTrack() const
Return pointer to associated track.
Definition: TrackParticleBase.h:205
python.compressB64.c
def c
Definition: compressB64.py:93
TrigEDMChecker::m_doDumpTrigTauTracksInfo
bool m_doDumpTrigTauTracksInfo
Definition: TrigEDMChecker.h:143
TrigTauTracksInfo::scalarPtSumIso
float scalarPtSumIso() const
Definition: TrigTauTracksInfo.h:47
SG::ConstIterator
Definition: SGIterator.h:163
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
python.TriggerConfig.testMenu
def testMenu(flags)
Definition: TriggerConfig.py:837
PhotonContainer.h
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
TrigEDMChecker::m_doDumpTrigL2BjetContainer
bool m_doDumpTrigL2BjetContainer
Definition: TrigEDMChecker.h:76
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition: CaloCluster_v1.cxx:265
TrigEDMChecker::m_doDumpTileMuFeature
bool m_doDumpTileMuFeature
Definition: TrigEDMChecker.h:102
TrigMuonEFInfo
Definition: TrigMuonEFInfo.h:24
TauJet.h
TrigEDMChecker::dumpLVL1_ROI
StatusCode dumpLVL1_ROI()
Definition: TrigEDMChecker.cxx:1171
TileMu
Class to store TileMuId quantities.
Definition: TileMu.h:25
xAOD::TrigEMCluster_v1::energy
float energy() const
get Energy (calibrated)
TrigInDetTrackFitPar::pT
void pT(const double pT)
Setter: transverse momentum.
Definition: TrigInDetTrackFitPar.h:222
TrigEDMChecker::dumpTDT
StatusCode dumpTDT()
Definition: TrigEDMChecker.cxx:4022
xAOD::TrigBphys_v1
Class describing a Bphysics online composite object.
Definition: TrigBphys_v1.h:44
P4IPtCotThPhiMBase::pt
virtual double pt() const
transverse momentum
Definition: P4IPtCotThPhiMBase.cxx:12
TrigVertexCollection.h
TrackParticleContainer.h
Jet_ROI.h
xAOD::JetAttribute::VoronoiAreaE
@ VoronoiAreaE
Definition: JetAttributes.h:46
xAOD::JetAttribute::NegativeE
@ NegativeE
Definition: JetAttributes.h:84
xAOD::TauJetParameters::EMPOverTrkSysP
@ EMPOverTrkSysP
Definition: TauDefs.h:279
checkFileSG.ind
list ind
Definition: checkFileSG.py:118
xAOD::TauJetParameters::etEMAtEMScale
@ etEMAtEMScale
Get EM energy at EM scale.
Definition: TauDefs.h:194
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
debug.h
Helper functions intended to be called from the debugger.
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
fitman.k
k
Definition: fitman.py:528
TrigEDMChecker::dumpTrigInDetTrackCollection
StatusCode dumpTrigInDetTrackCollection()
Definition: TrigEDMChecker.cxx:2139
TrigInDetTrackTruthMap::bestMatchTRTHits
int bestMatchTRTHits(const TrigInDetTrack *p_trig_trk) const
Definition: TrigInDetTrackTruthMap.cxx:143
TrigSpacePointCounts.h
xAOD::JetAttribute::Dip12
@ Dip12
Definition: JetAttributes.h:151
TrigEDMChecker::m_doDumpAll
bool m_doDumpAll
a handle on Store Gate for access to the Event Store
Definition: TrigEDMChecker.h:48
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
MuonFeature::zeta
float zeta(void) const
Definition: MuonFeature.h:53
TrigEDMChecker::m_vertexWarningNum
int m_vertexWarningNum
Definition: TrigEDMChecker.h:225
TrackParticleContainer.h
TileMuFeature
Definition: TileMuFeature.h:33
xAOD::JetAttribute::VoronoiAreaPx
@ VoronoiAreaPx
Definition: JetAttributes.h:47
ViewContainer
Definition: View.h:158
TrigEDMChecker::m_doDumpTrigPassBits
bool m_doDumpTrigPassBits
Definition: TrigEDMChecker.h:50
SCT_Monitoring::summary
@ summary
Definition: SCT_MonitoringNumbers.h:65