ATLAS Offline Software
AthenaMonManager.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 
7 #include <cctype>
8 
9 #include "TDirectory.h"
10 #include "TH1.h"
11 #include "TObject.h"
12 #include "TROOT.h"
13 #include "AthMonBench.h"
14 
15 #include "Gaudi/Interfaces/IOptionsSvc.h"
16 #include "GaudiKernel/IMessageSvc.h"
17 #include "GaudiKernel/ISvcLocator.h"
18 #include "GaudiKernel/ITHistSvc.h"
19 #include "GaudiKernel/MsgStream.h"
20 #include "Gaudi/Property.h"
21 #include "GaudiKernel/ServiceHandle.h"
22 
23 #include "AthenaKernel/ISGAudSvc.h"
28 
30 
31 #include <limits.h>
32 #include <vector>
33 
34 
36 public:
37  Imp(AthenaMonManager*man,const std::string& name) : m_theManager(man),
38  m_sgAudSvc(0),
39  m_isPrimaryManager(false),
40  m_everyNevents(-1),
41  m_eventCounter(-1),
44  m_dataTypeProp("userDefined"),
45  m_environmentProp("user"),
46  m_LBsLowStatProp(10),
47  m_LBsMedStatProp(30),
48  m_LBsHigStatProp(90),
49  m_manualRunLBProp(false),
50  m_runProp(0),
51  m_lumiBlockProp(0),
53  m_forkedProcess(false),
54  m_lastPID(0),
55  m_rootBackend(false),
56  m_doResourceMon(false)
57  {}
58 
59  ~Imp()
60  {
62 
63  for (it=m_toolbenchmarks.begin(),itE=m_toolbenchmarks.end(); it!=itE; ++it) {
64  delete it->second;
65  }
66 
67  m_toolbenchmarks.clear();
68  }
69 
70  //These were protected before we moved to a private implementation:
71  typedef std::map<std::string,TObject*> ObjMap_t;
73 
75  SmartIF<ISGAudSvc> m_sgAudSvc;
76 
78 
81 
82  std::string m_fileKeyProp;
83 
85  std::string m_dataTypeProp;
86  std::string m_environmentProp;
88 
90 
91  unsigned int m_runProp;
92  unsigned int m_lumiBlockProp;
93 
95 
98 
100 
101  //Hist leak checker is looking for
102  //inappropriate usage of MonGroup copy constructors (temporary
103  //until we outlaw copy/assignment of MonGroups):
105  Imp * m_d;
107  public:
109  m_mgcopies_initval(ManagedMonitorToolBase::MonGroup::ncopies()) {}
112  }
113  };
114 
115  template<class T> void toolAudStart(const T&tool) {
116  if (m_sgAudSvc) m_sgAudSvc->setFakeCurrentAlg(m_theManager->name()+"_MT_"+tool->name());
117  }
118  void toolAudEnd() {
119  if (m_sgAudSvc) m_sgAudSvc->clearFakeCurrentAlg();
120  }
121 
123 
124  class ToolBench {
125  public:
129  AthMonBench m_bench_algexec_fillHists;//NB: includes call to preselector
132  //NB: So far we don't check the call to runStat()
137  a->msg(l)<<"Init ResourceSummary ["<<m_theTool->name()<<"] --> load/create/initialize : "<<m_bench_alginit_retrieve<<endmsg;
140  a->msg(l)<<"Exec ResourceSummary ["<<m_theTool->name()<<"] --> book : "<<m_bench_algexec_bookHists<<endmsg;
141  a->msg(l)<<"Exec ResourceSummary ["<<m_theTool->name()<<"] --> check : "<<m_bench_algexec_checkHists<<endmsg;
142  a->msg(l)<<"Exec ResourceSummary ["<<m_theTool->name()<<"] --> fill : "<<m_bench_algexec_fillHists<<endmsg;
143  a->msg(l)<<"Fin ResourceSummary ["<<m_theTool->name()<<"] --> finalHists : "<<m_bench_algfin_finalHists<<endmsg;
144  a->msg(l)<<"Fin ResourceSummary ["<<m_theTool->name()<<"] --> checkHists(fromFinalize==true) : "<<m_bench_algfin_checkHists<<endmsg;
145  }
146 
147  };
148  std::map<IMonitorToolBase*,ToolBench*> m_toolbenchmarks;
151  if (it==m_toolbenchmarks.end()) {
152  ToolBench*tb =new ToolBench(t);
153  m_toolbenchmarks[t] = tb;
154  return tb;
155  }
156  return it->second;
157  }
158 
159  // The data below should be truly global for a job, and inheriting classes should
160  // not have the option of modifying them.
161  // The data are set from the corresponding m_* properties of the first AthenaMonManager
162  // in the Athena algorithm chain (this manager sets s_staticDataAreInit to true).
163 
164  inline static std::atomic<ISvcLocator*> s_svcLocator{nullptr};
165 
166  inline static std::atomic<bool> s_staticDataAreInit{false};
167 
168  inline static std::string s_dataTypeStr ATLAS_THREAD_SAFE {"userDefined"};
169  inline static std::string s_environmentStr ATLAS_THREAD_SAFE {"user"};
170  inline static DataType_t s_dataType ATLAS_THREAD_SAFE {userDefined};
171  inline static Environment_t s_environment ATLAS_THREAD_SAFE {user};
172 
173  inline static bool s_runLBOverridden ATLAS_THREAD_SAFE {false};
174  inline static unsigned int s_lumiBlock ATLAS_THREAD_SAFE {0};
175  inline static unsigned int s_run ATLAS_THREAD_SAFE {0};
176  inline static unsigned int s_fill ATLAS_THREAD_SAFE {0};
177  inline static unsigned int s_LBsLowStat ATLAS_THREAD_SAFE {0};
178  inline static unsigned int s_LBsMedStat ATLAS_THREAD_SAFE {0};
179  inline static unsigned int s_LBsHigStat ATLAS_THREAD_SAFE {0};
180 };
181 
182 
183 namespace {
184 
185 std::string strToLower( const std::string& str );
186 
187 } // unnamed namespace
188 
189 // *********************************************************************
190 // Public Methods
191 // *********************************************************************
192 
194 AthenaMonManager( const std::string& name, ISvcLocator* pSvcLocator )
195  : AthAlgorithm( name, pSvcLocator )
196  , m_monTools( this )
197  , m_THistSvc("THistSvc", name)
198  , m_d(new Imp(this, name))
199 {
200  declareProperty( "AthenaMonTools", m_monTools );
201  declareProperty( "CheckEveryNoEvents", m_d->m_everyNevents );
202  declareProperty( "FileKey", m_d->m_fileKeyProp );
203  declareProperty( "ManualDataTypeSetup", m_d->m_manualDataTypeSetupProp );
204  declareProperty( "DataType", m_d->m_dataTypeProp );
205  declareProperty( "Environment", m_d->m_environmentProp );
206  declareProperty( "LBsInLowStatInterval", m_d->m_LBsLowStatProp );
207  declareProperty( "LBsInMediumStatInterval", m_d->m_LBsMedStatProp );
208  declareProperty( "LBsInHighStatInterval", m_d->m_LBsHigStatProp );
209  declareProperty( "ManualRunLBSetup", m_d->m_manualRunLBProp );
210  declareProperty( "Run", m_d->m_runProp );
211  declareProperty( "LumiBlock", m_d->m_lumiBlockProp );
212  declareProperty( "ROOTBackend", m_d->m_rootBackend );
213 
214  if( !Imp::s_svcLocator )
215  Imp::s_svcLocator = pSvcLocator;
216 }
217 
218 
221 {
222  delete m_d;
223 
224  // If it is known that ManagedMonitorToolBase objects are deleted _after_ this object,
225  // then one should call setMonManager(0) on each of them.
226 }
227 
228 
231 envStringToEnum( const std::string& str )
232 {
233  std::string lcstr( strToLower(str) );
234 
235  if( lcstr == "user" )
236  return user;
237  else if( lcstr == "nooutput" )
238  return noOutput;
239  else if( lcstr == "online" )
240  return online;
241  else if( lcstr == "tier0" )
242  return tier0;
243  else if( lcstr == "tier0raw" )
244  return tier0Raw;
245  else if( lcstr == "tier0esd" )
246  return tier0ESD;
247  else if( lcstr == "aod" )
248  return AOD;
249  else if( lcstr == "altprod" )
250  return altprod;
251 
252  if( Imp::s_svcLocator ) {
253  SmartIF<IMessageSvc> ms{Imp::s_svcLocator.load()->service( "MessageSvc" )};
254  if( ms.isValid() ) {
255  MsgStream log( ms, "AthenaMonManager::envStringToEnum()" );
256  log << MSG::WARNING << "Unknown AthenaMonManager::Environment_t \""
257  << str << "\", returning \"user\"" << endmsg;
258  }
259  }
260 
261  return user;
262 }
263 
264 
267 dataTypeStringToEnum( const std::string& str )
268 {
269  std::string lcstr( strToLower(str) );
270 
271  if( lcstr == "userdefined" )
272  return userDefined;
273  else if( lcstr == "montecarlo" )
274  return monteCarlo;
275  else if( lcstr == "collisions" )
276  return collisions;
277  else if( lcstr == "cosmics" )
278  return cosmics;
279  else if( lcstr == "heavyioncollisions" )
280  return heavyIonCollisions;
281 
282  if( Imp::s_svcLocator ) {
283  SmartIF<IMessageSvc> ms{Imp::s_svcLocator.load()->service( "MessageSvc" )};
284  if( ms.isValid() ) {
285  MsgStream log( ms, "AthenaMonManager::dataTypeStringToEnum()" );
286  log << MSG::WARNING << "Unknown AthenaMonManager::DataType_t \""
287  << str << "\", returning \"userDefined\"" << endmsg;
288  }
289  }
290 
291  return userDefined;
292 }
293 
294 
297 environment()
298 {
299  return Imp::s_environment;
300 }
301 
303  return Imp::s_LBsLowStat;
304 }
306  return Imp::s_LBsMedStat;
307 }
309  return Imp::s_LBsHigStat;
310 }
311 
314 dataType()
315 {
316  return Imp::s_dataType;
317 }
318 
319 bool
321 forkedProcess() {
322  return m_d->m_forkedProcess;
323 }
324 
325 
326 unsigned int
329 {
330  if (Imp::s_runLBOverridden) {
331  return Imp::s_lumiBlock;
332  } else {
333  return Gaudi::Hive::currentContext().eventID().lumi_block();
334  }
335 }
336 
337 
338 unsigned int
340 runNumber()
341 {
342  if (Imp::s_runLBOverridden) {
343  return Imp::s_run;
344  } else {
345  return Gaudi::Hive::currentContext().eventID().run_number();
346  }
347 }
348 
349 
350 unsigned int
352 fillNumber()
353 {
354  return Imp::s_fill;
355 }
356 
357 
360 initialize()
361 {
363 
364  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "AthenaMonManager::initialize():" << endmsg;
365 
366  m_d->m_sgAudSvc = Imp::s_svcLocator.load()->service("SGAudSvc", false/*do not create*/);
368 
369  ATH_CHECK( m_THistSvc.retrieve() );
370 
371  if( !Imp::s_staticDataAreInit ) {
372  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " --> Initializing static data" << endmsg;
373 
374  if (msgLvl(MSG::DEBUG)) {
375  msg(MSG::DEBUG) << " * \"ManualDataTypeSetup\" = " << m_d->m_manualDataTypeSetupProp << endmsg;
376  }
377 
378 #if 0 // The two branches of the conditional are identical.
380  Imp::s_dataTypeStr = m_d->m_dataTypeProp;
381  Imp::s_dataType = dataTypeStringToEnum( m_d->m_dataTypeProp );
382  }
383  else
384 #endif
385  {
386  Imp::s_dataTypeStr = m_d->m_dataTypeProp;
387  Imp::s_dataType = dataTypeStringToEnum( m_d->m_dataTypeProp );
388  }
389 
390  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " * \"DataType\" = " << Imp::s_dataType << endmsg;
391 
392  Imp::s_environmentStr = m_d->m_environmentProp;
393  Imp::s_environment = envStringToEnum( m_d->m_environmentProp );
394 
395  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " * \"Environment\" = " << Imp::s_environment << endmsg;
396 
397  Imp::s_LBsLowStat = m_d->m_LBsLowStatProp;
398  Imp::s_LBsMedStat = m_d->m_LBsMedStatProp;
399  Imp::s_LBsHigStat = m_d->m_LBsHigStatProp;
400  if (msgLvl(MSG::DEBUG)) {
401  msg(MSG::DEBUG) << " * \"LBsInLowStatInterval\" = " << Imp::s_LBsLowStat << endmsg;
402  msg(MSG::DEBUG) << " * \"LBsInMediumStatInterval\" = " << Imp::s_LBsMedStat << endmsg;
403  msg(MSG::DEBUG) << " * \"LBsInHighStatInterval\" = " << Imp::s_LBsHigStat << endmsg;
404  }
405 
406  m_d->m_isPrimaryManager = true;
408 
409  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " * \"ManualRunLBSetup\" = " << m_d->m_manualRunLBProp << endmsg;
410 
411  if( m_d->m_manualRunLBProp ) {
412  Imp::s_run = m_d->m_runProp;
413  Imp::s_lumiBlock = m_d->m_lumiBlockProp;
414  Imp::s_runLBOverridden = true;
415  if (msgLvl(MSG::DEBUG))
416  msg(MSG::DEBUG) << " --> using run = " << Imp::s_run << ", lumiBlock = " << Imp::s_lumiBlock << endmsg;
417  } else {
418  if (msgLvl(MSG::DEBUG))
419  msg(MSG::DEBUG) << " --> using run = " << Imp::s_run << ", lumiBlock = " << Imp::s_lumiBlock << endmsg;
420  }
421  }
422 
423  // Ensure consistency among all managers
424  m_d->m_dataTypeProp = Imp::s_dataTypeStr;
425  m_d->m_environmentProp = Imp::s_environmentStr;
426 
427  // Provide a virtual Algorithm with a subset of the properties
428  ServiceHandle<Gaudi::Interfaces::IOptionsSvc> joSvc("JobOptionsSvc", name());
429  ATH_CHECK( joSvc.retrieve() );
430  ATH_MSG_DEBUG(" --> Found service \"JobOptionsSvc\"");
431 
432  const std::string client = name() + std::string("Properties");
433  ATH_MSG_DEBUG(" --> Adding properties under name \"" << client << "\"");
434  joSvc->set( client + ".FileKey", m_d->m_fileKeyProp );
435  joSvc->set( client + ".DataType", m_d->m_dataTypeProp );
436  joSvc->set( client + ".Environment", m_d->m_environmentProp );
437 
438  if( m_monTools.size() > 0 ) {
439  ATH_CHECK( m_monTools.retrieve() );
440  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " --> Retrieved AthenaMonTools" << endmsg;
441  }
442 
444 
446  for( ToolHandleArray<IMonitorToolBase>::iterator i = m_monTools.begin(); i != monToolsEnd; ++i ) {
447  ToolHandle<IMonitorToolBase>& tool = *i;
448  AthMonBench bench_tmp;
449  IMonitorToolBase* mon = tool.operator->();
450  ManagedMonitorToolBase* managed = dynamic_cast<ManagedMonitorToolBase*>( mon );
451  if( managed != 0 ) {
452  managed->setMonManager( this );
453  }
454  if (m_d->m_doResourceMon) {
456  tb->m_bench_alginit_retrieve = bench_tmp;
457  }
458 
459  }
460  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " --> Exiting successfully" << endmsg;
461 
462  return StatusCode::SUCCESS;
463 }
464 
465 
468 execute()
469 {
470  m_d->m_forkedProcess=false;
471  pid_t currPID=getpid();
472  //m_lastPID 0 means the execute method was not called yet.
473  if (m_d->m_lastPID!=0 && m_d->m_lastPID!=currPID) {
474  m_d->m_forkedProcess=true;
475  ATH_MSG_INFO("Forked event discovered!");
476  }
477  m_d->m_lastPID=currPID;
478 
480  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "AthenaMonManager::execute():" << endmsg;
481 
482  // This is legacy R2 monitoring.
483  // We only permit serial access (over all slots) to both HLT monitoring AND navigation thinning, as both use the same underlying thread un-safe navigation tool
484  // All of these elements are deprecated for R3 and are in the process of being replaced.
485  std::unique_lock<std::mutex> hltLock(TrigNavigationThinningSvcMutex::s_mutex, std::defer_lock);
486  if (name() == "HLTMonManager") {
487  ATH_MSG_DEBUG("HLTMonManager is obtaining the TrigNavigationThinningSvc lock in slot "
488  << Gaudi::Hive::currentContext().slot() << " for event " << Gaudi::Hive::currentContext().eventID().event_number() );
489  hltLock.lock();
490  }
491 
492  StatusCode sc;
493 
495  for( ToolHandleArray<IMonitorToolBase>::iterator i = m_monTools.begin(); i != monToolsEnd; ++i ) {
496  ToolHandle<IMonitorToolBase>& tool = *i;
498  AthMonBench bench_tmp;
499  if (m_d->m_doResourceMon)
500  bench_tmp.startMeasurement();
501  if( tool->preSelector() ) {
502 
503  sc = tool->fillHists();
504 
505  if( !sc.isSuccess() ) {
506  if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "IMonitorToolBase::fillHists() unsuccessful" << endmsg;
507  }
508  }
509 
510 
511  if (m_d->m_doResourceMon) {
512  bench_tmp.finishMeasurement();
513  Imp::ToolBench* tb = m_d->getToolBench(tool.operator->());
514  tb->m_bench_algexec_fillHists += bench_tmp;//fixme: count events and subdivide
515  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " --> m_doResourceMon is True" << endmsg;
516  }
517  m_d->toolAudEnd();
518  }
519  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " --> Done calling IMonitorToolBase::fillHists()" << endmsg;
520 
521  if( m_d->m_eventCounter > 0 ) {
522  m_d->m_eventCounter--;
523  }
524  else if( m_d->m_eventCounter == 0 ) {
525  for( ToolHandleArray<IMonitorToolBase>::iterator i = m_monTools.begin(); i != monToolsEnd; ++i ) {
526  ToolHandle<IMonitorToolBase>& tool = *i;
528  AthMonBench bench_tmp;
529 
530  if (m_d->m_doResourceMon)
531  bench_tmp.startMeasurement();
532  sc = tool->checkHists(false);
533  if (m_d->m_doResourceMon) {
534  bench_tmp.finishMeasurement();
535  Imp::ToolBench* tb = m_d->getToolBench(tool.operator->());
536  tb->m_bench_algexec_checkHists += bench_tmp;//fixme: count events and subdivide
537  }
538  if( !sc.isSuccess() ) {
539  if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "IMonitorToolBase::checkHists() unsuccessful" << endmsg;
540  }
541  m_d->toolAudEnd();
542  }
543  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " --> Done calling IMonitorToolBase::checkHists()" << endmsg;
544 
546  }
547  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " --> Exiting successfully" << endmsg;
548 
549  ATH_MSG_DEBUG(name() << " is releasing the TrigNavigationThinningSvc lock");
550  return StatusCode::SUCCESS;
551 }
552 
553 
556 finalize()
557 {
558  return StatusCode::SUCCESS;
559 }
560 
563 stop()
564 {
566  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "AthenaMonManager::finalize():" << endmsg;
567 
568  StatusCode sc;
569 
571  for( ToolHandleArray<IMonitorToolBase>::iterator i = m_monTools.begin(); i != monToolsEnd; ++i ) {
572  ToolHandle<IMonitorToolBase>& tool = *i;
574 
575  sc = tool->runStat();
576  if( !sc.isSuccess() ) {
577  if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "IMonitorToolBase::runStat() unsuccessful" << endmsg;
578  }
579 
580  Imp::ToolBench* tb = m_d->m_doResourceMon ? m_d->getToolBench(tool.operator->()) : 0;
581  if (tb)
582  tb->m_bench_algfin_finalHists.startMeasurement();
583  sc = tool->finalHists();
584  if (tb)
585  tb->m_bench_algfin_finalHists.finishMeasurement();
586  if( !sc.isSuccess() ) {
587  if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "IMonitorToolBase::finalHists() unsuccessful" << endmsg;
588  }
589  if (tb)
590  tb->m_bench_algfin_checkHists.startMeasurement();
591  sc = tool->checkHists(true);
592  if (tb)
593  tb->m_bench_algfin_checkHists.finishMeasurement();
594  if( !sc.isSuccess() ) {
595  if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "IMonitorToolBase::checkHists() unsuccessful" << endmsg;
596  }
597  if (tb)
598  tb->report(this);
599  m_d->toolAudEnd();
600  }
601  if (msgLvl(MSG::DEBUG)) {
602  msg(MSG::DEBUG) << " --> Done calling IMonitorToolBase::finalHists() and IMonitorToolBase::checkHists()" << endmsg;
603  msg(MSG::DEBUG) << " --> Exiting successfully" << endmsg;
604  }
605  return StatusCode::SUCCESS;
606 }
607 
608 
611 start()
612 {
614  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "AthenaMonManager::start():" << endmsg;
615 
616  StatusCode sc;
617 
619  for( ToolHandleArray<IMonitorToolBase>::iterator i = m_monTools.begin(); i != monToolsEnd; ++i ) {
620  ToolHandle<IMonitorToolBase>& tool = *i;
622  AthMonBench bench_tmp;
623  if (m_d->m_doResourceMon)
624  bench_tmp.startMeasurement();
625  sc = tool->bookHists();
626  if (m_d->m_doResourceMon) {
627  bench_tmp.finishMeasurement();
628  Imp::ToolBench* tb = m_d->getToolBench(tool.operator->());
629  tb->m_bench_algexec_bookHists += bench_tmp;
630  }
631  if( !sc.isSuccess() ) {
632  if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "IMonitorToolBase::bookHists() unsuccessful" << endmsg;
633  }
634  m_d->toolAudEnd();
635  }
636  if (msgLvl(MSG::DEBUG)) {
637  msg(MSG::DEBUG) << " --> Done calling IMonitorToolBase::bookHists()" << endmsg;
638  msg(MSG::DEBUG) << " --> Exiting successfully" << endmsg;
639  }
640 
641  return StatusCode::SUCCESS;
642 }
643 
644 
645 std::string
647 fileKey() const
648 {
649  return m_d->m_fileKeyProp;
650 }
651 
652 
653 void
655 passOwnership( TObject* h, const std::string& key )
656 {
657  Imp::ObjMap_t::value_type valToInsert( key, h );
658  m_d->m_objMap.insert( valToInsert );
659 }
660 
661 
662 void
664 writeAndDelete( const std::string& key )
665 {
666  // If is owned TObject, we deregister from THistSvc, write it in a
667  // root file, and delete it.
668 
670  if( i != m_d->m_objMap.end() ) {
671  TObject* o = i->second;
672  TH1* h = dynamic_cast<TH1*>( o );
673  if( h != 0 ) {
674  // By default, ROOT does its own bookkeeping of references to
675  // histograms, and this leads to a significant amount of time
676  // spent in the TObject d'tor when there are >= O(1000) TDirectories.
677  // So, turn this bookkeeping off when deleting these histograms.
678  bool doRecursiveReferenceDelete = gROOT->MustClean();
679  gROOT->SetMustClean(false);
680  TDirectory* dir = h->GetDirectory();
681  TDirectory* g = gDirectory;
682  if( dir )
683  dir->cd();
684  h->Write();
685  g->cd();
686 
687  StatusCode sc = m_THistSvc->deReg( h );
688  if( !sc.isSuccess() ) {
689  if (msgLvl(MSG::WARNING)) msg(MSG::WARNING) << "AthenaMonManager::WriteAndDeleteHist(): Failure to deReg( TObject* )" << endmsg;
690  }
691  delete o;
692  gROOT->SetMustClean(doRecursiveReferenceDelete);
693  m_d->m_objMap.erase( key );
694  }
695  }
696 }
697 
698 // *********************************************************************
699 // Protected Methods
700 // *********************************************************************
701 
702 
703 // *********************************************************************
704 // Private Methods
705 // *********************************************************************
706 namespace {
707 
708 std::string strToLower( const std::string& str )
709 {
710  std::string lstr(str);
711  std::string::const_iterator from = str.begin();
712  std::string::const_iterator strend = str.end();
713  std::string::iterator to = lstr.begin();
714  while( from != strend ) {
715  *to++ = tolower(*from++);
716  }
717  return lstr;
718 }
719 
720 } // unnamed namespace
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
AthenaMonManager::Imp::ATLAS_THREAD_SAFE
static std::string s_dataTypeStr ATLAS_THREAD_SAFE
Definition: AthenaMonManager.cxx:168
pid_t
int32_t pid_t
Definition: FPGATrackSimTypes.h:19
IMonitorToolBase.h
AthenaMonManager::Imp::~Imp
~Imp()
Definition: AthenaMonManager.cxx:59
AthenaMonManager::Imp::Imp
Imp(AthenaMonManager *man, const std::string &name)
Definition: AthenaMonManager.cxx:37
AthenaMonManager::Imp::ToolBench::m_bench_alginit_retrieve
AthMonBench m_bench_alginit_retrieve
Definition: AthenaMonManager.cxx:128
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:73
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
hist_file_dump.d
d
Definition: hist_file_dump.py:143
AthenaMonManager::Imp::m_toolbenchmarks
std::map< IMonitorToolBase *, ToolBench * > m_toolbenchmarks
Definition: AthenaMonManager.cxx:148
AthenaMonManager::Imp::m_eventCounter
long m_eventCounter
Definition: AthenaMonManager.cxx:80
AthenaMonManager::runNumber
static unsigned int runNumber()
Definition: AthenaMonManager.cxx:340
AthenaMonManager::fileKey
virtual std::string fileKey() const
Definition: AthenaMonManager.cxx:647
AthenaMonManager::cosmics
@ cosmics
Definition: AthenaMonManager.h:58
AthenaMonManager::Imp::ObjMap_t
std::map< std::string, TObject * > ObjMap_t
Definition: AthenaMonManager.cxx:71
AthenaMonManager::AOD
@ AOD
Definition: AthenaMonManager.h:49
AthenaMonManager::passOwnership
virtual void passOwnership(TObject *h, const std::string &key)
Pass ownership of a TObject to this manager so that it will be deleted appropriately.
Definition: AthenaMonManager.cxx:655
AthenaMonManager::finalize
virtual StatusCode finalize()
Definition: AthenaMonManager.cxx:556
AthenaMonManager::Imp::m_everyNevents
long m_everyNevents
Definition: AthenaMonManager.cxx:79
AthenaMonManager::envStringToEnum
static Environment_t envStringToEnum(const std::string &str)
Converts a string to an Environment_t of the same name.
Definition: AthenaMonManager.cxx:231
CSV_InDetExporter.new
new
Definition: CSV_InDetExporter.py:145
skel.it
it
Definition: skel.GENtoEVGEN.py:407
AthenaMonManager::Imp::m_objMap
ObjMap_t m_objMap
Definition: AthenaMonManager.cxx:72
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
AthenaMonManager::Imp::m_sgAudSvc
SmartIF< ISGAudSvc > m_sgAudSvc
Definition: AthenaMonManager.cxx:75
AthenaMonManager::heavyIonCollisions
@ heavyIonCollisions
Definition: AthenaMonManager.h:58
AthenaMonManager::Imp::ToolBench::m_bench_algexec_bookHists
AthMonBench m_bench_algexec_bookHists
Definition: AthenaMonManager.cxx:131
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
AthenaMonManager::Imp::s_staticDataAreInit
static std::atomic< bool > s_staticDataAreInit
Definition: AthenaMonManager.cxx:166
AthenaMonManager::Imp::ToolBench
Definition: AthenaMonManager.cxx:124
AthenaMonManager::Imp::HistLeakChecker::~HistLeakChecker
~HistLeakChecker()
Definition: AthenaMonManager.cxx:110
AthenaMonManager::DataType_t
DataType_t
An enumeration of the different types of data the monitoring application may be running over.
Definition: AthenaMonManager.h:58
AthenaMonManager::Imp::HistLeakChecker::HistLeakChecker
HistLeakChecker(Imp *d)
Definition: AthenaMonManager.cxx:108
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
AthenaMonManager::Imp::s_svcLocator
static std::atomic< ISvcLocator * > s_svcLocator
Definition: AthenaMonManager.cxx:164
python.LumiCalcHtml.lc
lc
Definition: LumiCalcHtml.py:579
AthenaMonManager::Imp::toolAudStart
void toolAudStart(const T &tool)
Definition: AthenaMonManager.cxx:115
AthenaAttributeList.h
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
AthenaMonManager::m_d
Imp * m_d
Definition: AthenaMonManager.h:122
AthenaMonManager::getLBsLowStat
static unsigned int getLBsLowStat()
Definition: AthenaMonManager.cxx:302
AthenaMonManager::Imp::ToolBench::report
void report(AthenaMonManager *a)
Definition: AthenaMonManager.cxx:135
TruthTest.itE
itE
Definition: TruthTest.py:25
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
AthenaMonManager::Imp::m_runProp
unsigned int m_runProp
Definition: AthenaMonManager.cxx:91
AthenaMonManager::Imp::m_isPrimaryManager
bool m_isPrimaryManager
Definition: AthenaMonManager.cxx:77
AthenaMonManager::Imp::ToolBench::m_bench_algexec_fillHists
AthMonBench m_bench_algexec_fillHists
Definition: AthenaMonManager.cxx:129
AthenaMonManager::environment
static Environment_t environment()
Returns the running environment of the monitoring application to help ManagedMonitorToolBase objects ...
Definition: AthenaMonManager.cxx:297
rerun_display.client
client
Definition: rerun_display.py:31
AthenaMonManager::Imp::HistLeakChecker::m_d
Imp * m_d
Definition: AthenaMonManager.cxx:105
AthenaMonManager::fillNumber
static unsigned int fillNumber()
Definition: AthenaMonManager.cxx:352
AthenaMonManager::Imp::m_environmentProp
std::string m_environmentProp
Definition: AthenaMonManager.cxx:86
AthenaMonManager::getLBsMedStat
static unsigned int getLBsMedStat()
Definition: AthenaMonManager.cxx:305
Execution.tb
tb
Definition: Execution.py:15
ManagedMonitorToolBase.h
AthMonBench::finishMeasurement
void finishMeasurement()
Definition: AthMonBench.h:83
AthenaMonManager::Imp::m_dataTypeProp
std::string m_dataTypeProp
Definition: AthenaMonManager.cxx:85
AthenaMonManager::tier0ESD
@ tier0ESD
Definition: AthenaMonManager.h:49
AthenaMonManager::Imp::m_LBsLowStatProp
unsigned int m_LBsLowStatProp
Definition: AthenaMonManager.cxx:87
AthenaMonManager::dataType
static DataType_t dataType()
Returns the data type that the monitoring application is running over to help ManagedMonitorToolBase ...
Definition: AthenaMonManager.cxx:314
AthenaMonManager::Imp::ToolBench::m_bench_algexec_checkHists
AthMonBench m_bench_algexec_checkHists
Definition: AthenaMonManager.cxx:130
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
AthenaMonManager::start
virtual StatusCode start()
Definition: AthenaMonManager.cxx:611
AthenaMonManager
An Algorithm that manages a set of modules, each inheriting from ManagedMonitorToolBase,...
Definition: AthenaMonManager.h:34
AthenaMonManager::Imp::ToolBench::m_bench_algfin_checkHists
AthMonBench m_bench_algfin_checkHists
Definition: AthenaMonManager.cxx:134
AthenaMonManager::dataTypeStringToEnum
static DataType_t dataTypeStringToEnum(const std::string &str)
Converts a string to a DataType_t of the same name.
Definition: AthenaMonManager.cxx:267
ManagedMonitorToolBase::setMonManager
virtual void setMonManager(AthenaMonManager *manager)
Takes a pointer to a managing object to get information from it when needed.
Definition: ManagedMonitorToolBase.cxx:1328
ParseInputs.gDirectory
gDirectory
Definition: Final2012/ParseInputs.py:133
lumiFormat.i
int i
Definition: lumiFormat.py:85
AthenaMonManager::collisions
@ collisions
Definition: AthenaMonManager.h:58
TrigNavigationThinningSvcMutex::s_mutex
static std::mutex s_mutex
Definition: TrigNavigationThinningSvcMutex.h:19
AthenaMonManager::tier0
@ tier0
Definition: AthenaMonManager.h:49
AthenaMonManager::Imp::m_nMonGroupCopies
unsigned m_nMonGroupCopies
Definition: AthenaMonManager.cxx:94
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
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
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthenaMonManager::online
@ online
Definition: AthenaMonManager.h:49
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:111
AthenaMonManager::writeAndDelete
virtual void writeAndDelete(const std::string &key)
If the TObject is owned by this manager, its Write() method is called and it is deleted.
Definition: AthenaMonManager.cxx:664
AthenaMonManager::Imp::m_manualDataTypeSetupProp
bool m_manualDataTypeSetupProp
Definition: AthenaMonManager.cxx:84
AthenaMonManager::tier0Raw
@ tier0Raw
Definition: AthenaMonManager.h:49
AthenaMonManager.h
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthenaMonManager::user
@ user
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::MonGroup::ncopies
static unsigned ncopies()
Definition: ManagedMonitorToolBase.cxx:184
AthenaMonManager::Imp::toolAudEnd
void toolAudEnd()
Definition: AthenaMonManager.cxx:118
AthenaMonManager::m_monTools
ToolHandleArray< IMonitorToolBase > m_monTools
Definition: AthenaMonManager.h:116
AthenaMonManager::Imp::ToolBench::ToolBench
ToolBench(IMonitorToolBase *t)
Definition: AthenaMonManager.cxx:126
AthenaMonManager::Imp::m_manualRunLBProp
bool m_manualRunLBProp
Definition: AthenaMonManager.cxx:89
AthAlgorithm
Definition: AthAlgorithm.h:47
beamspotman.dir
string dir
Definition: beamspotman.py:623
AthenaMonManager::Environment_t
Environment_t
An enumeration of the different types of running environment the monitoring application may be in.
Definition: AthenaMonManager.h:49
AthenaMonManager::Imp::m_LBsMedStatProp
unsigned int m_LBsMedStatProp
Definition: AthenaMonManager.cxx:87
IMonitorToolBase
Definition: IMonitorToolBase.h:25
AthMonBench::s_resourceMonThreshold
static const MSG::Level s_resourceMonThreshold
Definition: AthMonBench.h:28
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
AthMonBench.h
AthenaMonManager::getLBsHigStat
static unsigned int getLBsHigStat()
Definition: AthenaMonManager.cxx:308
AthMonBench::startMeasurement
void startMeasurement()
Definition: AthMonBench.h:76
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:453
AthenaMonManager::execute
virtual StatusCode execute()
Definition: AthenaMonManager.cxx:468
AthenaMonManager::Imp::m_fileKeyProp
std::string m_fileKeyProp
Definition: AthenaMonManager.cxx:82
AthenaMonManager::Imp::m_theManager
AthenaMonManager * m_theManager
Definition: AthenaMonManager.cxx:74
AthenaMonManager::Imp::HistLeakChecker
Definition: AthenaMonManager.cxx:104
AthenaMonManager::stop
virtual StatusCode stop()
Definition: AthenaMonManager.cxx:563
AthenaMonManager::Imp::getToolBench
ToolBench * getToolBench(IMonitorToolBase *t)
Definition: AthenaMonManager.cxx:149
CxxUtils::to
CONT to(RANGE &&r)
Definition: ranges.h:39
AthenaMonManager::Imp::m_doResourceMon
bool m_doResourceMon
Definition: AthenaMonManager.cxx:122
AthenaMonManager::Imp::m_forkedProcess
bool m_forkedProcess
Definition: AthenaMonManager.cxx:96
AthenaMonManager::Imp::m_rootBackend
bool m_rootBackend
Definition: AthenaMonManager.cxx:99
a
TList * a
Definition: liststreamerinfos.cxx:10
AthenaMonManager::AthenaMonManager
AthenaMonManager(const std::string &name, ISvcLocator *pSvcLocator)
Definition: AthenaMonManager.cxx:194
h
AthenaMonManager::forkedProcess
bool forkedProcess()
Definition: AthenaMonManager.cxx:321
AthenaMonManager::Imp::m_lumiBlockProp
unsigned int m_lumiBlockProp
Definition: AthenaMonManager.cxx:92
AthenaMonManager::altprod
@ altprod
Definition: AthenaMonManager.h:49
AthenaMonManager::Imp::m_lastPID
pid_t m_lastPID
Definition: AthenaMonManager.cxx:97
ISGAudSvc.h
AthenaMonManager::Imp::ToolBench::m_bench_algfin_finalHists
AthMonBench m_bench_algfin_finalHists
Definition: AthenaMonManager.cxx:133
DEBUG
#define DEBUG
Definition: page_access.h:11
plotBeamSpotMon.mon
mon
Definition: plotBeamSpotMon.py:67
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
AthenaMonManager::Imp::m_LBsHigStatProp
unsigned int m_LBsHigStatProp
Definition: AthenaMonManager.cxx:87
str
Definition: BTagTrackIpAccessor.cxx:11
AthenaMonManager::Imp
Definition: AthenaMonManager.cxx:35
AthenaMonManager::lumiBlockNumber
static unsigned int lumiBlockNumber()
Definition: AthenaMonManager.cxx:328
AthenaMonManager::userDefined
@ userDefined
Definition: AthenaMonManager.h:58
AthenaMonManager::Imp::HistLeakChecker::m_mgcopies_initval
unsigned m_mgcopies_initval
Definition: AthenaMonManager.cxx:106
checker_macros.h
Define macros for attributes used to control the static checker.
AthenaMonManager::~AthenaMonManager
virtual ~AthenaMonManager()
Definition: AthenaMonManager.cxx:220
AthMonBench::setUnitCount
void setUnitCount()
Definition: AthMonBench.h:111
AthMonBench
Definition: AthMonBench.h:25
AthenaMonManager::m_THistSvc
ServiceHandle< ITHistSvc > m_THistSvc
Definition: AthenaMonManager.h:118
AthenaMonManager::Imp::ToolBench::m_theTool
const IMonitorToolBase * m_theTool
Definition: AthenaMonManager.cxx:127
AthenaMonManager::noOutput
@ noOutput
Definition: AthenaMonManager.h:49
AthenaMonManager::monteCarlo
@ monteCarlo
Definition: AthenaMonManager.h:58
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
TrigNavigationThinningSvcMutex.h
AthenaMonManager::initialize
virtual StatusCode initialize()
Definition: AthenaMonManager.cxx:360
ServiceHandle< Gaudi::Interfaces::IOptionsSvc >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37