ATLAS Offline Software
ManagedMonitorToolBase.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #ifndef ManagedMonitorToolBase_CXX
6 #define ManagedMonitorToolBase_CXX
7 
9 
10 #include <cctype>
11 #include <ctime>
12 #include <sstream>
13 
14 #include "TGraph.h"
15 #include "TH1.h"
16 #include "TH2.h"
17 #include "TTree.h"
18 #include "TROOT.h"
19 #include "TFile.h"
20 #include "TEfficiency.h"
21 #include "AthMonBench.h"
23 
24 #include "Gaudi/Interfaces/IOptionsSvc.h"
25 #include "GaudiKernel/IHistogramSvc.h"
26 #include "GaudiKernel/IMessageSvc.h"
27 #include "GaudiKernel/ISvcLocator.h"
28 #include "GaudiKernel/MsgStream.h"
29 
32 #include "GaudiKernel/ITHistSvc.h"
33 
34 
35 //____________________________________________________________________
37 public:
38  inline static std::atomic<ISvcLocator*> s_svcLocator{nullptr};
41  m_doResourceMon(false),
43  ~Imp() {}
44 
45  //Data members:
47  //To warn against clients that reimplemented initialize without calling ManagedMonitorToolBase::initialze():
49 
50  //Internal methods and data members for detailed CPU/mem monitoring:
66  void benchFinalReport();
67  void benchReset();
68 };
69 
73 
74 //____________________________________________________________________
76 {
77  if (!m_doResourceMon)
78  return;
79  benchReset();
81 }
82 
83 //____________________________________________________________________
85 {
86  if (!m_doResourceMon)
87  return;
88  m_bench_book.finishMeasurement();
89  m_bench_total += m_bench_book;
90  m_benchNFillAfterbook = 0;
91 }
92 
93 //____________________________________________________________________
95 {
96  if (!m_doResourceMon)
97  return;
98  m_bench_tmp.reset();
99  m_bench_tmp.startMeasurement();
100 }
101 
102 //____________________________________________________________________
104 {
105  if (!m_doResourceMon)
106  return;
107  m_bench_tmp.finishMeasurement();
108  m_bench_total += m_bench_tmp;
109  ++m_benchNFillAfterbook;
110  if (m_benchNFillAfterbook==1) {
111  m_bench_fillfirst = m_bench_tmp;
112  } else {
113  m_bench_fillall += m_bench_tmp;
114  m_bench_filllast = m_bench_tmp;
115  }
116 }
117 
118 //____________________________________________________________________
120 {
121  if (!m_doResourceMon)
122  return;
123  m_bench_proc.startMeasurement();
124 }
125 
126 //____________________________________________________________________
128 {
129  if (!m_doResourceMon)
130  return;
131  m_bench_proc.finishMeasurement();
132  m_bench_total += m_bench_proc;
133  m_bench_fillall -= m_bench_filllast;
134  m_benchNFillAfterbook = 0;
135  benchFinalReport();
136  benchReset();
137 }
138 
139 //____________________________________________________________________
141 {
142  if (!m_doResourceMon)
143  return;
144  m_benchNFillAfterbook = 0;
145  m_bench_tmp.reset();
146  m_bench_book.reset();
147  m_bench_fillfirst.reset();
148  m_bench_fillall.reset();
149  m_bench_filllast.reset();
150  m_bench_proc.reset();
151  m_bench_total.reset();
152 
153 }
154 
155 //____________________________________________________________________
157 {
158  if (!m_doResourceMon)
159  return;
160  m_theclass->msg(AthMonBench::s_resourceMonThreshold) << "ResourceSummary --> Result of dedicated mon-tool resource monitoring:"<<endmsg;
161  m_theclass->msg(AthMonBench::s_resourceMonThreshold) << "ResourceSummary --> Book : "<<m_bench_book << endmsg;
162  m_theclass->msg(AthMonBench::s_resourceMonThreshold) << "ResourceSummary --> First Fill : "<<m_bench_fillfirst << endmsg;
163  m_theclass->msg(AthMonBench::s_resourceMonThreshold) << "ResourceSummary --> Last Fill : "<<m_bench_filllast << endmsg;
164  m_theclass->msg(AthMonBench::s_resourceMonThreshold) << "ResourceSummary --> Other Fills : "<<m_bench_fillall << endmsg;
165  m_theclass->msg(AthMonBench::s_resourceMonThreshold) << "ResourceSummary --> Proc : "<<m_bench_proc << endmsg;
166  m_bench_total.setUnitCount();//to avoid dividing by number of measurements
167  m_theclass->msg(AthMonBench::s_resourceMonThreshold) << "ResourceSummary --> Grand Total : "<<m_bench_total << endmsg;
168  //NB: Needs total also!
169 }
170 
171 
172 
176 
177 namespace {
178 
179  std::string strToLower( const std::string& str );
180 
181 } // unnamed namespace
182 
183 static std::atomic<unsigned> s_mmtb_mongroup_ncopies=0;
184 unsigned ManagedMonitorToolBase::MonGroup::ncopies() { return s_mmtb_mongroup_ncopies; }
185 void ManagedMonitorToolBase::MonGroup::badusage() { ++s_mmtb_mongroup_ncopies; }
186 
187 // *********************************************************************
188 // Public Methods
189 // *********************************************************************
192 regHist( TH1* h )
193 {
194  if( m_tool != 0 ) {
195  std::string hName( h->GetName() );
196  m_map.emplace( hName, h );
197  return m_tool->regHist( h, *this );
198  }
199 
200  return StatusCode::FAILURE;
201 }
202 
205 getHist( TH1*& h, const std::string& hName )
206 {
207  if( m_tool != 0 ) {
208  return m_tool->getHist( h, hName, *this );
209  }
210 
211  return StatusCode::FAILURE;
212 }
213 
214 
217 getHist( TH2*& h, const std::string& hName )
218 {
219  if( m_tool != 0 ) {
220  return m_tool->getHist( h, hName, *this );
221  }
222 
223  return StatusCode::FAILURE;
224 }
225 
226 
228  if( m_tool != 0 ) {
229  return m_tool->regEfficiency( e, *this );
230  }
231  return StatusCode::FAILURE;
232 }
233 
234 
237 regGraph( TGraph* g )
238 {
239  if( m_tool != 0 ) {
240  return m_tool->regGraph( g, *this );
241  }
242 
243  return StatusCode::FAILURE;
244 }
245 
246 
249 regTree( TTree* t )
250 {
251  if( m_tool != 0 ) {
252  return m_tool->regTree( t, *this );
253  }
254 
255  return StatusCode::FAILURE;
256 }
257 
258 
261 writeAndDelete( TH1* h )
262 {
263  if( m_tool != 0 ) {
264  std::string hName( h->GetName() );
265  m_map.erase( hName );
266  return m_tool->writeAndDelete( h, *this );
267  }
268 
269  return StatusCode::FAILURE;
270 }
271 
272 
275 deregHist( TH1* h )
276 {
277  if( m_tool != 0 ) {
278  std::string hName( h->GetName() );
279  m_map.erase( hName );
280  return m_tool->deregHist( h );
281  }
282 
283  return StatusCode::FAILURE;
284 }
285 
286 
289 deregGraph( TGraph* g )
290 {
291  if( m_tool != 0 ) {
292  return m_tool->deregGraph( g );
293  }
294 
295  return StatusCode::FAILURE;
296 }
297 
298 
301 deregObject( const std::string& objName )
302 {
303  if( m_tool != 0 ) {
304  return m_tool->deregObject( objName, *this );
305  }
306 
307  return StatusCode::FAILURE;
308 }
309 
310 
313 deregAll()
314 {
315  if( m_tool != 0 ) {
316  bool isSuccess(true);
317  StatusCode sc;
318 
319  typedef HistMap_t::const_iterator MapIter_t;
320  MapIter_t mapEnd = m_map.end();
321  for( MapIter_t i = m_map.begin(); i != mapEnd; ++i ) {
322  sc = m_tool->deregHist( i->second );
323  if( !sc.isSuccess() )
324  isSuccess = false;
325  }
326 
327  m_map.clear();
328 
329  if( isSuccess )
330  return StatusCode::SUCCESS;
331  }
332 
333  return StatusCode::FAILURE;
334 }
335 
336 
338 ManagedMonitorToolBase( const std::string & type, const std::string & name,
339  const IInterface* parent )
340  : AthAlgTool( type, name, parent )
341  , m_manager(0)
342  , m_managerNameProp("AthenaMonManager")
343  , m_fileKey("")
344  , m_dataTypeStr("userDefined")
345  , m_environmentStr("noOutput")
346  , m_detailLevel(1)
347  , m_dataType(AthenaMonManager::userDefined)
349  , m_streamNameFcn(0)
350  , m_THistSvc("THistSvc",name)
351  , m_procNEventsProp(0)
352  , m_path("")
353  , m_preScaleProp(0)
354  , m_triggerChainProp("")
355  , m_triggerGroupProp("")
356  , m_useTrigger(false)
357  , m_lastLumiBlock(0)
358  , m_lastRun(0)
362  , m_nEvents(1)
364  , m_nLumiBlocks(1)
366  , m_bookHistogramsInitial(false)
367  , m_useLumi(false)
368  , m_defaultLBDuration(60.)
369  , m_d(new Imp(this))
370 {
371 // ManagedMonitorToolBase_resetHistStatistics(this);
372  declareInterface<IMonitorToolBase>(this);
373  declareProperty( "ProcessNEvents", m_procNEventsProp );
374  declareProperty( "histoPathBase", m_path );
375  declareProperty( "PreScale", m_preScaleProp );
376  declareProperty( "TriggerChain", m_triggerChainProp );
377  declareProperty( "TriggerGroup", m_triggerGroupProp );
378 
379  // If a class would like to associate itself to a manager but cannot actually
380  // be referenced by it, the manager name can be set explicitly. Otherwise,
381  // it is set automatically.
382  declareProperty( "ManagerName", m_managerNameProp );
383 
384  // Enable luminosity tool?
385  declareProperty( "EnableLumi", m_useLumi );
386 
387  // How detailed should the monitoring be?
388  declareProperty( "DetailLevel", m_detailLevel );
389 
390  // If we don't know how long an LB is, here's the default
391  declareProperty( "DefaultLBDuration", m_defaultLBDuration );
392 
393  // Properties that are overridden in initialize()---settings via jobOptions are ignored!
394  declareProperty( "FileKey", m_fileKey );
395  declareProperty( "DataType", m_dataTypeStr );
396  declareProperty( "Environment", m_environmentStr );
397 
398  if( !Imp::s_svcLocator )
399  Imp::s_svcLocator = svcLoc();
400 
401  for (auto interval: { eventsBlock, lumiBlock, lowStat, run, all }) {
402  m_templateHistograms[interval] = std::vector< MgmtParams<TH1> >();
403  m_templateGraphs[interval] = std::vector< MgmtParams<TGraph> >();
404  m_templateTrees[interval] = std::vector< MgmtParams<TTree> >();
406  }
407 
408  newLowStatInterval = false;
409  newMedStatInterval = false;
410  newHigStatInterval = false;
411  newLowStat = false;
412  newLumiBlock = false;
413  newRun = false;
414  newEventsBlock = false;
415  endOfEventsBlock = false;
416  endOfLowStat = false;
417  endOfLumiBlock = false;
418  endOfRun = false;
419 
420  m_newLowStatInterval = false;
421  m_newMedStatInterval = false;
422  m_newHigStatInterval = false;
423  m_newLowStat = false;
424  m_newLumiBlock = false;
425  m_newRun = false;
426  m_newEventsBlock = false;
427  m_endOfEventsBlock = false;
428  m_endOfLowStat = false;
429  m_endOfLumiBlock = false;
430  m_endOfRun = false;
431 }
432 
433 
436 {
437 // ManagedMonitorToolBase_printHistStatistics(this);
438  delete m_streamNameFcn;
439 
442  i != mdend; ++i ) {
443  delete (i->second);
444  }
445  delete m_d;
446 }
447 
448 
452 {
453  if( m_streamNameFcn == 0 ) {
454  msg(MSG::ERROR) << "!! streamNameFunction() has not been initialized !!" << endmsg;
455  msg(MSG::ERROR) << " --> neither ManagedMonitorToolBase::initialize() nor" << endmsg;
456  msg(MSG::ERROR) << " --> ManagedMonitorToolBase::setMonManager() has been called." << endmsg;
457  msg(MSG::ERROR) << " --> Correct configuration cannot be guaranteed from this point." << endmsg;
459  }
460  return m_streamNameFcn;
461 }
462 
463 
464 /*
465 std::string
466 ManagedMonitorToolBase::
467 levelOfDetailEnumToString( LevelOfDetail_t level, bool useOnlineConventions )
468 {
469  std::string str("summary");
470 
471  switch( level ) {
472  case transient:
473  str = "transient";
474  break;
475  case debug:
476  str = "debug";
477  break;
478  case expert:
479  str = "expert";
480  break;
481  case shift:
482  str = "shift";
483  break;
484  case summary:
485  default:
486  if(useOnlineConventions)
487  str = "runstat";
488  else
489  str = "summary";
490  }
491 
492  if(useOnlineConventions)
493  str = strToUpper( str );
494 
495  return str;
496 }
497 */
498 
499 /*
500 ManagedMonitorToolBase::LevelOfDetail_t
501 ManagedMonitorToolBase::
502 levelOfDetailStringToEnum( const std::string& str )
503 {
504  std::string lcstr( strToLower(str) );
505 
506  if( lcstr == "summary" || lcstr == "runstat" )
507  return summary;
508  else if( lcstr == "shift" )
509  return shift;
510  else if( lcstr == "expert" )
511  return expert;
512  else if( lcstr == "debug" )
513  return debug;
514  else if( lcstr == "transient" )
515  return transient;
516 
517  // This is a static method (shared by all instances), so no "this" pointer
518  // is available (needed for msg). Have to use message service directly.
519  if( Imp::s_svcLocator!=0 ) {
520  IMessageSvc* ms(0);
521  StatusCode sc = Imp::s_svcLocator->service( "MessageSvc", ms, true );
522  if( sc.isSuccess() ) {
523  MsgStream log( ms, "ManagedMonitorToolBase::levelOfDetailStringToEnum()" );
524  log << MSG::WARNING << "Unknown ManagedMonitorToolBase::LevelOfDetail_t \""
525  << str << "\", returning \"transient\"" << endmsg;
526  }
527  }
528 
529  return transient;
530 }
531 */
532 
533 
534 std::string
537 {
538  std::string str("file");
539 
540  switch( interval ) {
541  case all:
542  str = "all";
543  break;
544  case fill:
545  str = "fill";
546  break;
547  case run:
548  str = "run";
549  break;
550  case lowStat:
551  str = "lowStat";
552  break;
553  case medStat:
554  str = "medStat";
555  break;
556  case higStat:
557  str = "higStat";
558  break;
559  case lumiBlock:
560  str = "lumiBlock";
561  break;
562  case eventsBlock:
563  str = "eventsBlock";
564  break;
565  case file:
566  str = "file";
567  break;
568  default:
569  str = "unknown";
570  }
571 
572  return str;
573 }
574 
575 
578 intervalStringToEnum( const std::string& str )
579 {
580  std::string lcstr( strToLower(str) );
581 
582  if( lcstr == "all" )
583  return all;
584  else if( lcstr == "fill" )
585  return fill;
586  else if( lcstr == "run" )
587  return run;
588  else if( lcstr == "lowStat" )
589  return lowStat;
590  else if( lcstr == "medStat" )
591  return medStat;
592  else if( lcstr == "higStat" )
593  return higStat;
594  else if( lcstr == "lumiBlock" )
595  return lumiBlock;
596  else if( lcstr == "eventsBlock" )
597  return eventsBlock;
598  else if( lcstr == "file" )
599  return file;
600 
601  if( Imp::s_svcLocator ) {
602  SmartIF<IMessageSvc> ms{Imp::s_svcLocator.load()->service( "MessageSvc" )};
603  if( ms.isValid() ) {
604  MsgStream log( ms, "ManagedMonitorToolBase::intervalStringToEnum()" );
605  log << MSG::WARNING << "Unknown ManagedMonitorToolBase::Interval_t \""
606  << str << "\", returning \"file\"" << endmsg;
607  }
608  }
609 
610  return file;
611 }
612 
613 
616 initialize()
617 {
619 
621  if( !sc.isSuccess() )
622  return StatusCode::FAILURE;
623 
624  ATH_MSG_DEBUG("ManagedMonitorToolBase::initialize():");
625 
627 
628  sc = m_THistSvc.retrieve();
629  if( !sc.isSuccess() ) {
630  msg(MSG::ERROR) << "!! Unable to locate the THistSvc service !!" << endmsg;
631  return sc;
632  }
633  ATH_MSG_DEBUG(" --> Found service \"THistSvc\"");
634 
635  if( !m_trigDecTool.empty() ) {
636  sc = m_trigDecTool.retrieve();
637  if( !sc.isSuccess() ) {
638  msg(MSG::ERROR) << "!! Unable to retrieve the TrigDecisionTool !!" << endmsg;
639  return sc;
640  }
641  ATH_MSG_DEBUG(" --> Found AlgTool \"TrigDecisionTool\"");
642 
643  if( !m_trigTranslator.empty() ) {
644  sc = m_trigTranslator.retrieve();
645  if ( !sc.isSuccess() ) {
646  ATH_MSG_ERROR(" Unable to retrieve the TrigTranslatorTool!" << endmsg);
647  return sc;
648  }
649  }
650 
651  if(m_triggerChainProp!="") {
652  ATH_MSG_DEBUG(" --> Found nonempty trigger chain list");
654  if(!sc.isSuccess()) {
655  msg(MSG::WARNING) << "Error parsing the trigger chain list, using empty list" << endmsg;
656  m_vTrigChainNames.clear();
657  }
658  if (!m_trigTranslator.empty()) {
660  }
661  }
662  else {
663  ATH_MSG_DEBUG(" --> trigger chain list empty");
664  }
665  if(m_triggerGroupProp!="") {
666  ATH_MSG_DEBUG(" --> Found nonempty trigger group list");
668  if(!sc.isSuccess()) {
669  msg(MSG::WARNING) << "Error parsing the trigger group names list, using empty list" << endmsg;
670  m_vTrigGroupNames.clear();
671  }
672  if (!m_trigTranslator.empty()) {
674  }
675  }
676  else {
677  ATH_MSG_DEBUG(" --> trigger group list empty");
678  }
679  }
680  else {
681  ATH_MSG_DEBUG(" --> no trigger decision tool specified");
682  }
683 
684  sc = m_DQFilterTools.retrieve();
685  if( !sc.isSuccess() ) {
686  ATH_MSG_ERROR("!! Unable to retrieve the Filter Tools !!");
687  return sc;
688  }
689 
690  ServiceHandle<Gaudi::Interfaces::IOptionsSvc> joSvc( "JobOptionsSvc", name() );
691  ATH_CHECK( joSvc.retrieve() );
692  ATH_MSG_DEBUG(" --> Found service \"JobOptionsSvc\"");
693 
694  const std::string client( m_managerNameProp + "Properties" );
695  ATH_MSG_DEBUG(" --> Asking for properties " << client);
696 
697  auto getProp = [this,&joSvc](std::string& var, const std::string& name) {
698  if (joSvc->has(name))
699  var = joSvc->get(name);
700  else
701  ATH_MSG_DEBUG("Cannot read " << name); // on purpose not an ERROR (will be set by setMonManager)
702  };
703  getProp( m_fileKey, client + ".FileKey");
704  getProp( m_dataTypeStr, client + ".DataType");
705  getProp( m_environmentStr, client + ".Environment");
706 
707  ATH_MSG_DEBUG(" * Properties set from " << client << " to the values:\n"
708  << " FileKey: " << m_fileKey << "\n"
709  << " DataType: " << m_dataTypeStr << "\n"
710  << " Environment: " << m_environmentStr);
711 
714 
718 
719  delete m_streamNameFcn;
721 
722  ATH_MSG_DEBUG(" --> Exiting successfully");
723 
724  return StatusCode::SUCCESS;
725 }
726 
727 
730 bookHists()
731 {
732  // The Run/LumiBlock numbers are not set when beginRun() is called. Therefore,
733  // book histograms on the first call to fillHists(), which is called from execute().
734  return StatusCode::SUCCESS;
735 }
736 
737 
740 fillHists()
741 {
742 
745  msg(MSG::WARNING) << "ManagedMonitorToolBase::initialize() never called from reimplementation!" << endmsg;
746  }
747 
748 
749  bool isNewEventsBlock = ( m_procNEventsProp > 0 && ((m_nEvents % m_procNEventsProp) == 1) && m_haveClearedLastEventBlock );
750  if (isNewEventsBlock) m_haveClearedLastEventBlock = false;
751 
752  m_newLowStat = false;
753  m_newLumiBlock = false;
754  m_newRun = false;
755  newLowStat = false;
756  newLumiBlock = false;
757  newRun = false;
758 
759  m_newLowStatInterval = false;
760  m_newMedStatInterval = false;
761  m_newHigStatInterval = false;
762  newLowStatInterval = false;
763  newMedStatInterval = false;
764  newHigStatInterval = false;
765 
766  m_useTrigger = ( (m_triggerChainProp != "" || m_triggerGroupProp != "") && (!m_trigDecTool.empty()) );
767 
768  if( m_manager != 0 ) {
771  newLumiBlock = m_newLumiBlock;
772  newRun = m_newRun;
773 
774  if(m_newRun) {
775  m_newLumiBlock = true;
776  newLumiBlock = m_newLumiBlock;
777  isNewEventsBlock = true;
778  }
779 
780  m_newEventsBlock = isNewEventsBlock;
781  newEventsBlock = m_newEventsBlock;
782 
783  if( m_newLumiBlock ) {
784  // check if a new LB interval has started
785  // lowest lumiBlockNumber() is 1
786  // m_lastLowStatInterval is -1 initially
787  int currentLB = m_manager->lumiBlockNumber();
788  int LBsLowStat = m_manager->getLBsLowStat();
789  int LBsMedStat = m_manager->getLBsMedStat();
790  int LBsHigStat = m_manager->getLBsHigStat();
791 
792  if( LBsLowStat*LBsMedStat*LBsHigStat == 0) {
793  msg(MSG::WARNING) << "zero LBs requested for interval" << endmsg;
794  }
795  else {
796  if( ((currentLB-1)/LBsLowStat) != m_lastLowStatInterval ) m_newLowStatInterval = true;
797  if( ((currentLB-1)/LBsMedStat) != m_lastMedStatInterval ) m_newMedStatInterval = true;
798  if( ((currentLB-1)/LBsHigStat) != m_lastHigStatInterval ) m_newHigStatInterval = true;
799  newLowStatInterval = m_newLowStatInterval;
800  newMedStatInterval = m_newHigStatInterval;
801  newHigStatInterval = m_newHigStatInterval;
802  }
803  }
804 
805  // Allow inheriting classes the option of using the lastLumiBloc/lastRun values
806  // before updating them
807  }
808 
809 
810  StatusCode sc0( StatusCode::SUCCESS );
811  StatusCode sc1( StatusCode::SUCCESS );
812  StatusCode sc2( StatusCode::SUCCESS );
813  StatusCode sc3( StatusCode::SUCCESS );
814 
815  // Set end of LowStat, LumiBlock and Run variables
816  // These are needed to be used in procHistograms().
821  endOfEventsBlock = m_newEventsBlock;
822  endOfLowStat = m_newLowStatInterval;
823  endOfLumiBlock = m_newLumiBlock;
824  endOfRun = m_newRun;
825 
826  // just duplicates m_newLowStatInterval
828  newLowStat = m_newLowStatInterval;
829 
831  ATH_MSG_DEBUG("Interval transition processing");
832  // Process histograms from the previous lumiBlock/run
833  if( m_nEvents != 1 ) {
835  sc0 = procHistograms();
837  }
838  // Re-book new histograms
840 
842  sc1 = bookHistograms();
844  } else {
845  std::vector<Interval_t> intervals_to_process;
846  if (m_newEventsBlock) intervals_to_process.push_back(eventsBlock);
847  if (m_newLumiBlock) intervals_to_process.push_back(lumiBlock);
848  if (m_newLowStatInterval) intervals_to_process.push_back(lowStat);
849  if (m_newRun) intervals_to_process.push_back(run);
850  for (const auto interval: intervals_to_process) {
854  }
855  }
856  for (const auto& interval: std::vector<Interval_t>{ eventsBlock, lumiBlock, lowStat, run }) {
857  for (const auto& it: m_templateHistograms[interval]) {
858  // is histogram too small in x axis for LB range?
859  if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
860  //ATH_MSG_WARNING("We are rebinning for " << it.m_templateHist->GetName());
861  while ( it.m_templateHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
862  it.m_templateHist->LabelsInflate("X");
863  }
864  }
865  }
866  for (auto& it: m_templateEfficiencies[interval]) {
867  if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
868  // get the underlying passed and total TH1's from the TEfficiency
869  TH1* passedHist = it.m_templateHist->GetCopyPassedHisto();
870  TH1* totalHist = it.m_templateHist->GetCopyTotalHisto();
871  // inflate them until they exceed the lumi-block number
872  while (passedHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
873  passedHist->LabelsInflate("X");
874  totalHist->LabelsInflate("X");
875  }
876  // Replace them in the TEfficiency. First one has force ("f") option, since the
877  // histograms will not be consistent. This is corrected in the next line, so we
878  // do check for consistency then.
879  it.m_templateHist->SetPassedHistogram(*passedHist, "f");
880  it.m_templateHist->SetTotalHistogram(*totalHist, " ");
881  delete passedHist; // not owned by THistSvc, so need to be deleted.
882  delete totalHist;
883  }
884  }
885  }
886 
887  if (auto streamname = dynamic_cast<OfflineStream*>(streamNameFunction())) {
888  streamname->updateRunLB();
889  }
890 
891  sc3 = bookHistogramsRecurrent( );
892 
894 
895  }//end if new RUN/LB/Block
896 
897  // check filters
898  bool filterresult(true);
899  if (! m_DQFilterTools.empty()) {
900  ToolHandleArray<IDQFilterTool>::const_iterator ifilter(m_DQFilterTools.begin()), filterend(m_DQFilterTools.end());
901  for (; filterresult && (ifilter != filterend);
902  ++ifilter) {
903  filterresult = (filterresult && (*ifilter)->accept());
904  }
905  }
906 
907 
908  // ...and fill as normal
909  if(filterresult &&
910  (!m_useTrigger
913  ATH_MSG_DEBUG("Passed trigger, presumably");
915  fillHistograms().ignore();
918  ++m_nEvents;
919  } else { ATH_MSG_DEBUG("Failed trigger, presumably"); }
920 
922  if( m_newLumiBlock && (m_nEventsIgnoreTrigger != 1) ) {
923  ++m_nLumiBlocks;
924  }
925  if( m_manager != 0 ) {
927  if( m_newLumiBlock ) {
929 
930  int LBsLowStat = m_manager->getLBsLowStat();
931  int LBsMedStat = m_manager->getLBsMedStat();
932  int LBsHigStat = m_manager->getLBsHigStat();
933  if( LBsLowStat*LBsMedStat*LBsHigStat > 0) {
937  }
938  }
939  }
940 
941  return StatusCode::SUCCESS;
942 }
943 
946 registerMetadata(const std::string& streamName, const std::string& hName,
947  const MonGroup& group) {
949  TTree* metadata(0);
950  std::string mdStreamName( streamName );
951  size_t found=mdStreamName.rfind('/');
952 
953  if ( found != std::string::npos )
954  mdStreamName.replace( found, mdStreamName.length(), "/metadata" );
955 
956  MDMap_t::iterator i = m_metadataMap.find( mdStreamName );
957  if( i == m_metadataMap.end() ) {
958  metadata = new TTree( "metadata", "Monitoring Metadata" );
959  if (! metadata) return StatusCode::FAILURE;
960  StatusCode scmd = m_THistSvc->regTree( mdStreamName, metadata );
961  if (scmd == StatusCode::FAILURE) return StatusCode::FAILURE;
962  i = m_metadataMap.emplace( mdStreamName, new OutputMetadata(metadata) ).first;
963  }
964 
965  i->second->fill( hName, group.interval(), group.chain(), group.merge() );
966  }
967  return StatusCode::SUCCESS;
968 }
969 
970 StatusCode
972 regManagedHistograms(std::vector< MgmtParams<TH1> >& templateHistograms)
973 {
974  // The method registers histograms with the THistSvc and saves them to file.
975 
976  // The funky business with registering and deregistering the histogram is needed
977  // to get the correct directory when saving histograms. THistSvc deals with ROOT
978  // to set up proper TDirectory, so we rely on it.
979  // E.g.
980  // m_THistSvc->regHist( streamName, h ): sets the correct TDirectory with streamName
981  // m_THistSvc->deReg( h ) - deregister from THistSvc otherwise THistSvc will try to save it
982  // at the end of execution
983  // use passownership of the histogram and save it to file
984  // m_manager->passOwnership( h, genericName );
985  // m_manager->writeAndDelete( genericName );
986  bool allIsOk = true;
987 
988  for( std::vector< MgmtParams<TH1> >::iterator it = templateHistograms.begin(); it != templateHistograms.end(); ++it ) {
989  MonGroup& group = (*it).m_group;
990 
991  // Get a handle to the histogram
992  TH1* theHist = (*it).m_templateHist;
993 
994  // Clone the histogram
995  TH1* h = static_cast<TH1*>(theHist->Clone());
996  theHist->Reset();
997 
998  // Get name
999  std::string hName = h->GetName();
1000 
1001  // Get the streamName for the previous interval
1002  std::string streamName = streamNameFunction()->getStreamName( this, group, hName, true );
1003 
1004  // Register the histogram with the THistSvc
1005  StatusCode sc1 = m_THistSvc->deReg( theHist );
1006  if (sc1 == StatusCode::FAILURE) allIsOk = false;
1007 
1008  // Register clonned histogram under previous interval streamName
1009  StatusCode sc2 = m_THistSvc->regHist( streamName, h );
1010  if (sc2 == StatusCode::FAILURE) allIsOk = false;
1011 
1012  if( m_manager != 0 ) {
1013  std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1014  m_manager->passOwnership( h, genericName );
1015  m_manager->writeAndDelete( genericName );
1016  }
1017 
1018  // Get streamName for the current interval
1019  streamName = streamNameFunction()->getStreamName( this, group, hName, false );
1020  // Register metadata information with the current interval streamname
1022  if (smd != StatusCode::SUCCESS) allIsOk = false;
1023 
1024  // Re-register the original histogram with the current interval streamName
1025  StatusCode sc3 = m_THistSvc->regHist( streamName, theHist );
1026  if (sc3 == StatusCode::FAILURE) allIsOk = false;
1027 
1028  }
1029 
1030  if (!allIsOk) return StatusCode::FAILURE;
1031 
1032  return StatusCode::SUCCESS;
1033 }
1034 
1035 StatusCode
1037 THistSvc_deReg_fixTGraph( TFile* file, TGraph* theGraph, std::string& directoryName)
1038 {
1039  // THistSvc employs TDirectory Append method when registering TGraph.
1040  // When deReg is used to de-register TGraph object, THistSvc only removes the object
1041  // from its internal management but forgets to delete from TDirectory.
1042  // The current method fixes this problem by removing the TGraph object manually
1043  // after THistSvc->deReg(TGraph* obj) is called.
1044 
1045  // Saves and restores gFile and gDirectory
1046  GlobalDirectoryRestore restore;
1047 
1048  // This check is true when TGraph object is removed successfully
1049  bool graphRemoved = false;
1050 
1051  file->cd("/");
1052  TDirectory* dir = file->GetDirectory(directoryName.c_str());
1053  if (dir != 0) {
1054  dir->cd();
1055  TObject* obj = dir->Remove(theGraph);
1056  if (obj != 0)
1057  graphRemoved = true;
1058  }
1059 
1060  if (!graphRemoved) {
1061  return StatusCode::FAILURE;
1062  }
1063 
1064  return StatusCode::SUCCESS;
1065 }
1066 
1067 StatusCode
1069 regManagedGraphs(std::vector< MgmtParams<TGraph> >& templateGraphs)
1070 {
1071  // See the description for the regManagedHistograms method
1072  bool allIsOk = true;
1073 
1074  for( std::vector< MgmtParams<TGraph> >::iterator it = templateGraphs.begin(); it != templateGraphs.end(); ++it ) {
1075  MonGroup group = (*it).m_group;
1076 
1077  // Get a handle to the graph
1078  TGraph* theGraph = (*it).m_templateHist;
1079 
1080  // Clone the graph
1081  TGraph* g = static_cast<TGraph*>(theGraph->Clone());
1082  theGraph->Set(0); // equivalent to Reset() for TH1
1083 
1084  // Get name
1085  std::string gName = g->GetName();
1086 
1087  // Get the streamName for the previous interval
1088  std::string streamName = streamNameFunction()->getStreamName( this, group, gName, true );
1089 
1090  // De-register the original graph with the THistSvc
1091  StatusCode sc1 = m_THistSvc->deReg( theGraph );
1092  if (sc1 == StatusCode::FAILURE)
1093  allIsOk = false;
1094 
1095  // *** begin ***
1096  // Fix THistSvc->deReg for TGraphs
1097  bool doneCleaning = false;
1098  std::string directoryName = streamNameFunction()->getDirectoryName( this, group, gName, true );
1099  TSeqCollection *filelist=gROOT->GetListOfFiles();
1100  for (int i=0; i<filelist->GetEntries(); i++) {
1101  ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
1102  TFile* file = static_cast<TFile*>(filelist->At(i));
1103  StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
1104  if (sc2 == StatusCode::SUCCESS)
1105  doneCleaning = true;
1106  }
1107 
1108  // Check if TGraph fix has been applied successfully
1109  if (!doneCleaning) {
1110  ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
1111  allIsOk = false;
1112  }
1113  // *** end ***
1114 
1115  // Register clonned histogram under previous interval streamName
1116  StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
1117  if (sc3 == StatusCode::FAILURE)
1118  allIsOk = false;
1119 
1120  // Get streamName for the current interval
1121  streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1122  // Register metadata information with the current interval streamname
1124  if (smd != StatusCode::SUCCESS)
1125  allIsOk = false;
1126 
1127  // Re-register the original graph with the current interval streamName
1128  StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
1129  if (sc4 == StatusCode::FAILURE)
1130  allIsOk = false;
1131 
1132  }
1133 
1134  if (!allIsOk) return StatusCode::FAILURE;
1135 
1136  return StatusCode::SUCCESS;
1137 }
1138 
1140  bool allIsOk = true;
1141  for( auto& it : templateEfficiencies ) {
1142  // get components of MgmtParams and copy efficiency
1143  MonGroup group = it.m_group;
1144  TEfficiency* theEfficiency = it.m_templateHist;
1145  TEfficiency* e = static_cast<TEfficiency*>(theEfficiency->Clone());
1146  int nbins = theEfficiency->GetTotalHistogram()->GetNbinsX();
1147  int xlow = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmin();
1148  int xhigh = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmax();
1149  e->SetBins(nbins,xlow,xhigh); // reset histogram
1150  std::string name = e->GetName();
1151 
1152  // make TGraph casts of TEfficiencies
1153  TGraph* theGraph = reinterpret_cast<TGraph*>(theEfficiency);
1154  TGraph* g = reinterpret_cast<TGraph*>(e);
1155 
1156  // Get the streamName for the previous interval
1157  std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
1158 
1159  // RE-REGISTER
1160  // 1) De-register the original graph with the THistSvc
1161  StatusCode sc1 = m_THistSvc->deReg( theGraph );
1162  if (sc1 == StatusCode::FAILURE) allIsOk = false;
1163  // 2) Fix THistSvc->deReg for TGraphs
1164  bool doneCleaning = false;
1165  std::string directoryName = streamNameFunction()->getDirectoryName( this, group, name, true );
1166  TSeqCollection *filelist=gROOT->GetListOfFiles();
1167  for (int i=0; i<filelist->GetEntries(); i++) {
1168  ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
1169  TFile* file = static_cast<TFile*>(filelist->At(i));
1170  StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
1171  if (sc2 == StatusCode::SUCCESS) doneCleaning = true;
1172  }
1173  // 3) Check if TGraph fix has been applied successfully
1174  if (!doneCleaning) {
1175  ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
1176  allIsOk = false;
1177  }
1178  // 4) Register cloned histogram under previous interval streamName
1179  StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
1180  if (sc3 == StatusCode::FAILURE)
1181  allIsOk = false;
1182 
1183  // get streamname for interval
1184  streamName = streamNameFunction()->getStreamName( this, group, name, false );
1185  // store metadata
1187  if (smd != StatusCode::SUCCESS) allIsOk = false;
1188  // Re-register the original graph
1189  StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
1190  if (sc4 == StatusCode::FAILURE) allIsOk = false;
1191  }
1192 
1193  if (!allIsOk) return StatusCode::FAILURE;
1194  return StatusCode::SUCCESS;
1195 }
1196 
1197 
1198 StatusCode
1200 regManagedTrees(std::vector< MgmtParams<TTree> >& templateTrees)
1201 {
1202  // See the description for the regManagedHistograms method
1203  bool allIsOk = true;
1204 
1205  for( std::vector< MgmtParams<TTree> >::iterator it = templateTrees.begin(); it != templateTrees.end(); ++it ) {
1206  MonGroup group = (*it).m_group;
1207 
1208  // Get a handle to the original tree
1209  TTree* theTree = (*it).m_templateHist;
1210 
1211  // Clone the tree
1212  TTree* t = static_cast<TTree*>(theTree->Clone());
1213  theTree->Reset();
1214 
1215  // Dumping the tree
1216  std::string name = t->GetName();
1217 
1218  // Get the streamName for the previous interval
1219  std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
1220 
1221  // De-register original tree with the THistSvc
1222  StatusCode sc1 = m_THistSvc->deReg( theTree );
1223  if (sc1 == StatusCode::FAILURE) allIsOk = false;
1224 
1225  // Register clonned tree under previous interval streamName
1226  StatusCode sc2 = m_THistSvc->regTree( streamName, t );
1227  if (sc2 == StatusCode::FAILURE) allIsOk = false;
1228 
1229  if( m_manager != 0 ) {
1230  std::string genericName = NoOutputStream().getStreamName( this, group, name );
1231  m_manager->passOwnership( t, genericName );
1232  m_manager->writeAndDelete( genericName );
1233  }
1234 
1235  // Get streamName for the current interval
1236  streamName = streamNameFunction()->getStreamName( this, group, name, false );
1237  // Register metadata information with the current interval streamname
1239  if (smd != StatusCode::SUCCESS) allIsOk = false;
1240 
1241  // Re-register the original graph with the current interval streamName
1242  StatusCode sc3 = m_THistSvc->regTree( streamName, theTree );
1243  if (sc3 == StatusCode::FAILURE) allIsOk = false;
1244 
1245  }
1246 
1247  if (!allIsOk) return StatusCode::FAILURE;
1248 
1249  return StatusCode::SUCCESS;
1250 }
1251 
1252 
1253 StatusCode
1255 finalHists()
1256 {
1257 
1258  // This assumes that the end of a file will naturally end a run, which is not always true.
1259  // A merging application run afterwards should be able to put parts of a run together.
1260  if( m_nEvents != 1 ) {
1262 
1263  // Set end flags for the LowStat, LumiBlock and Run variables.
1264  // This is needed to be used in the procHistograms method below.
1265  m_endOfEventsBlock = true;
1266  m_endOfLowStat = true;
1267  m_endOfLumiBlock = true;
1268  m_endOfRun = true;
1269  endOfEventsBlock = true;
1270  endOfLowStat = true;
1271  endOfLumiBlock = true;
1272  endOfRun = true;
1273 
1275 
1277  return sc;
1278  }
1279  return StatusCode::SUCCESS;
1280 }
1281 
1282 
1283 StatusCode
1286 {
1287  if( m_newEventsBlock ) { }
1288  if( m_newLumiBlock ) { }
1289  if( m_newRun ) { }
1290 
1291  return StatusCode::SUCCESS;
1292 }
1293 
1294 
1295 StatusCode
1297 bookHistograms( )
1298 {
1299 
1300  return StatusCode::SUCCESS;
1301 }
1302 
1303 StatusCode
1306 {
1307  return StatusCode::SUCCESS;
1308 }
1309 
1310 
1311 StatusCode
1313 procHistograms( )
1314 {
1315  if( m_endOfEventsBlock ) { }
1316  if( m_endOfLowStat ) { }
1317  if( m_endOfLumiBlock ) { }
1318  if( m_endOfRun) { }
1319 
1320  return StatusCode::SUCCESS;
1321 }
1322 
1323 
1324 void
1327 {
1328  ATH_MSG_DEBUG( "ManagedMonitorToolBase::setMonManager():");
1329  m_manager = manager;
1330  if( m_manager != 0 ) {
1331  ATH_MSG_DEBUG( " --> Setting manager");
1332  m_managerNameProp = m_manager->name();
1336  delete m_streamNameFcn;
1338  }
1339  ATH_MSG_DEBUG( " --> Exiting successfully");
1340 }
1341 
1342 StatusCode
1344 regHist( TH1* h, const std::string& system,
1345  Interval_t interval, MgmtAttr_t histo_mgmt, const std::string& chain, const std::string& merge )
1346 {
1347  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1348  return regHist( h, group );
1349 }
1350 
1351 StatusCode
1353 regHist( TH1* h, const MonGroup& group )
1354 {
1355 // ManagedMonitorToolBase_addHistStatistics(this,h);
1356 
1357  if (!h)
1358  return StatusCode::FAILURE;
1359 
1360  // This part of the code deals with MANAGED type
1361  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1362  /*
1363  Create an unmanaged group based on the original MonGroup instance passed
1364  It is needed because managed histogram is presented as a number of unmanaged
1365  histograms (one per each interval)
1366  Update (PUEO) - I don't think it actually matters, and need to keep
1367  track of "proper" attribute for X_VS_LB
1368  */
1369 
1370  if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1371  ATH_MSG_WARNING("HEY! You're attempting to register " << h->GetName() << " as a per-LB histogram, but you're not setting the merge algorithm! This is a SUPER-BAD idea! Use \"merge\", at least.");
1372  }
1373 
1374  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1375  m_templateHistograms[group.interval()].push_back( MgmtParams<TH1>(h, group) );
1376  } else {
1377  ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1378  return StatusCode::FAILURE;
1379  }
1380 
1381  std::string hName = h->GetName();
1382  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1383  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, hName, false );
1384  registerMetadata(streamName, hName, group).ignore();
1385  return m_THistSvc->regHist( streamName, h );
1386  }
1387 
1388  // This part of the code deals with UNMANAGED type
1389  std::string hName = h->GetName();
1390 
1391  if( m_manager != 0 ) {
1392  std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1393  m_manager->writeAndDelete( genericName );
1394  m_manager->passOwnership( h, genericName );
1395  }
1396 
1397  std::string streamName = streamNameFunction()->getStreamName( this, group, hName, false );
1398 
1400  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1401 
1402  return m_THistSvc->regHist( streamName, h );
1403 }
1404 
1405 
1406 StatusCode
1408 getHist( TH1*& h, const std::string& hName, const std::string& system,
1410 {
1411  MonGroup group( this, system, interval );
1412  return getHist( h, hName, group );
1413 }
1414 
1415 
1416 StatusCode
1418 getHist( TH1*& h, const std::string& hName, const MonGroup& group )
1419 {
1420  std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1421  return m_THistSvc->getHist( streamName, h );
1422 }
1423 
1424 
1425 StatusCode
1427 getHist( TH2*& h, const std::string& hName, const std::string& system,
1429 {
1430  MonGroup group( this, system, interval );
1431  return getHist( h, hName, group );
1432 }
1433 
1434 
1435 StatusCode
1437 getHist( TH2*& h, const std::string& hName, const MonGroup& group )
1438 {
1439  std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1440  return m_THistSvc->getHist( streamName, h );
1441 }
1442 
1443 
1445  if (!e)
1446  return StatusCode::FAILURE;
1447 
1448  TGraph* g = reinterpret_cast<TGraph*>(e);
1449  std::string name = e->GetName();
1450 
1451  // MANAGED
1452  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1453  // warn about not using merge algorithms
1454  if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1455  ATH_MSG_WARNING("HEY! Attempting to register "<<name<<" as a per-LB histogram, but not setting the merge algorithm! Use \"merge\", at least.");
1456  }
1457  // add the efficiency to rebooking vector
1458  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1459  m_templateEfficiencies[group.interval()].push_back( MgmtParams<TEfficiency>(e, group) );
1460  } else {
1461  ATH_MSG_ERROR("Attempt to book managed graph " << name << " with invalid interval type " << intervalEnumToString(group.interval()));
1462  return StatusCode::FAILURE;
1463  }
1464 
1465  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1466  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1467  registerMetadata(streamName, name, group).ignore();
1468  return m_THistSvc->regGraph( streamName, g );
1469  } else {
1470  // UNMANAGED
1471  if( m_manager != 0 ) {
1472  std::string genericName = NoOutputStream().getStreamName( this, group, name );
1473  m_manager->writeAndDelete( genericName );
1474  m_manager->passOwnership( e, genericName );
1475  }
1476 
1477  std::string streamName = streamNameFunction()->getStreamName( this, group, name, false );
1479  if (smd != StatusCode::SUCCESS)
1480  return StatusCode::FAILURE;
1481 
1482  return m_THistSvc->regGraph( streamName, g );
1483  }
1484 }
1485 
1486 
1487 StatusCode
1489 regGraph( TGraph* g, const std::string& system,
1490  Interval_t interval, MgmtAttr_t histo_mgmt, const std::string& chain, const std::string& merge )
1491 {
1492  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1493  return regGraph( g, group );
1494 }
1495 
1496 
1497 StatusCode
1499 regGraph( TGraph* g, const MonGroup& group )
1500 {
1501  if (!g)
1502  return StatusCode::FAILURE;
1503 
1504  // This part of the code deals with MANAGED type
1505  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1506  // Create an unmanaged group based on the original MonGroup instance passed
1507  // This is needed because managed graph is presented as a number of unmanaged
1508  // graphs (one per each interval)
1509  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1510 
1511  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1512  m_templateGraphs[group.interval()].push_back( MgmtParams<TGraph>(g, group_unmanaged) );
1513  } else {
1514  ATH_MSG_ERROR("Attempt to book managed graph " << g->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1515  return StatusCode::FAILURE;
1516  }
1517 
1518  std::string name = g->GetName();
1519  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1520  registerMetadata(streamName, name, group).ignore();
1521  return m_THistSvc->regGraph( streamName, g );
1522  //return m_THistSvc->regGraph( streamName );
1523  }
1524 
1525  // This part of the code deals with UNMANAGED type
1526  std::string gName = g->GetName();
1527 
1528  if( m_manager != 0 ) {
1529  std::string genericName = NoOutputStream().getStreamName( this, group, gName );
1530  m_manager->writeAndDelete( genericName );
1531  m_manager->passOwnership( g, genericName );
1532  }
1533 
1534  std::string streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1535 
1537  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1538 
1539  return m_THistSvc->regGraph( streamName, g );
1540 }
1541 
1542 
1543 StatusCode
1545 regTree( TTree* t, const std::string& system,
1546  Interval_t interval, MgmtAttr_t histo_mgmt, const std::string& chain, const std::string& merge )
1547 {
1548  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1549  return regTree( t, group );
1550 }
1551 
1552 
1553 StatusCode
1555 regTree( TTree* t, const MonGroup& group )
1556 {
1557 
1558  // This part of the code deals with MANAGED type
1559  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1560  // Create an unmanaged group based on the original MonGroup instance passed
1561  // This is needed because managed tree is presented as a number of unmanaged
1562  // trees (one per each interval)
1563  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1564 
1565  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1566  m_templateTrees[group.interval()].push_back( MgmtParams<TTree>(t, group_unmanaged) );
1567  } else {
1568  ATH_MSG_ERROR("Attempt to book managed tree " << t->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1569  return StatusCode::FAILURE;
1570  }
1571 
1572  std::string name = t->GetName();
1573  std::string genericName = NoOutputStream().getStreamName( this, group_unmanaged, name );
1574  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1575  registerMetadata(streamName, name, group).ignore();
1576  return m_THistSvc->regTree( streamName, t );
1577  }
1578 
1579 
1580  // This part of the code deals with UNMANAGED type
1581  std::string tName = t->GetName();
1582 
1583  if( m_manager != 0 ) {
1584  std::string genericName = NoOutputStream().getStreamName( this, group, tName );
1585  m_manager->writeAndDelete( genericName );
1586  m_manager->passOwnership( t, genericName );
1587  }
1588 
1589  std::string streamName = streamNameFunction()->getStreamName( this, group, tName, false );
1590 
1592  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1593 
1594  return m_THistSvc->regTree( streamName, t );
1595 }
1596 
1597 
1598 StatusCode
1600 writeAndDelete( TH1* h, const MonGroup& group ) {
1601  if (!h)
1602  return StatusCode::FAILURE;
1603 
1604  std::string hName = h->GetName();
1605 
1606  if( m_manager != 0 ) {
1607  std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1608  m_manager->writeAndDelete( genericName );
1609  }
1610  return StatusCode::SUCCESS;
1611 }
1612 
1613 
1614 StatusCode
1616 deregHist( TH1* h )
1617 {
1618  return m_THistSvc->deReg( h );
1619 }
1620 
1621 
1622 StatusCode
1624 deregGraph( TGraph* g )
1625 {
1626  return m_THistSvc->deReg( g );
1627 }
1628 
1629 
1630 StatusCode
1632 deregObject( const std::string& objName, const std::string& system,
1634 {
1635  MonGroup group( this, system, interval );
1636  return deregObject( objName, group );
1637 }
1638 
1639 
1640 StatusCode
1642 deregObject( const std::string& objName, const MonGroup& group )
1643 {
1644  std::string streamName = streamNameFunction()->getStreamName( this, group, objName );
1645  return m_THistSvc->deReg( streamName );
1646 }
1647 
1648 
1649 StatusCode
1651 setupOutputStreams( std::vector<std::string> )
1652 {
1653  // All instances should write to the stream(s) defined by the
1654  // AthenaMonManager.
1655 
1656  return StatusCode::SUCCESS;
1657 }
1658 
1659 
1660 StatusCode
1662 runStat()
1663 {
1664  return StatusCode::SUCCESS;
1665 }
1666 
1667 
1668 StatusCode
1670 checkHists( bool )
1671 {
1672  // Histograms will be checked using the data-quality monitoring framework (DQMF)
1673 
1674  return StatusCode::SUCCESS;
1675 }
1676 
1677 
1678 bool
1680 preSelector()
1681 {
1682  if( m_preScaleProp > 1 ) {
1683  return ( (m_nEvents % m_preScaleProp) == 1 );
1684  }
1685  return true;
1686 }
1687 
1688 
1689 // Average mu, i.e. <mu>
1690 float
1692 lbAverageInteractionsPerCrossing (const EventContext& ctx /*= Gaudi::Hive::currentContext()*/) const
1693 {
1694  if (!m_lumiDataKey.empty()) {
1696  return lumi->lbAverageInteractionsPerCrossing();
1697  } else {
1698  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageInteractionsPerCrossing() can't work properly! ");
1699  ATH_MSG_DEBUG("Warning: lbAverageInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1700  return -1.0;
1701  }
1702  // not reached
1703 }
1704 
1705 // Instantaneous number of interactions, i.e. mu
1706 float
1708 lbInteractionsPerCrossing (const EventContext& ctx /*= Gaudi::Hive::currentContext()*/) const
1709 {
1710  if (!m_lumiDataKey.empty()) {
1712  float muToLumi = lumi->muToLumi();
1713  if (muToLumi > 0) {
1714  return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id()) / muToLumi;
1715  }
1716  return 0;
1717  } else {
1718  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbInteractionsPerCrossing() can't work properly! ");
1719  ATH_MSG_DEBUG("Warning: lbInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1720  return -1.0;
1721  }
1722  // not reached
1723 }
1724 
1725 // Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)
1726 float
1728 lbAverageLuminosity (const EventContext& ctx /*= Gaudi::Hive::currentContext()*/) const
1729 {
1730  if (!m_lumiDataKey.empty()) {
1732  return lumi->lbAverageLuminosity();
1733  } else {
1734  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLuminosity() can't work properly! ");
1735  ATH_MSG_DEBUG("Warning: lbAverageLuminosity() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1736  return -1.0;
1737  }
1738  // not reached
1739 }
1740 
1741 // Instantaneous luminosity
1742 float
1744 lbLuminosityPerBCID (const EventContext& ctx /*= Gaudi::Hive::currentContext()*/) const
1745 {
1746  if (!m_lumiDataKey.empty()) {
1748  return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id());
1749  } else {
1750  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLuminosityPerBCID() can't work properly! ");
1751  ATH_MSG_DEBUG("Warning: lbLuminosityPerBCID() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1752  return -1.0;
1753  }
1754  // not reached
1755 }
1756 
1757 
1758 // Average luminosity livefraction
1759 float
1761 lbAverageLivefraction (const EventContext& ctx /*= Gaudi::Hive::currentContext()*/) const
1762 {
1764  return 1.0;
1765 
1768  return live->lbAverageLiveFraction();
1769  } else {
1770  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLivefraction() can't work properly! ");
1771  ATH_MSG_DEBUG("Warning: lbAverageLivefraction() - luminosity not availble (i.e. EnableLumi = False)");
1772  return -1.0;
1773  }
1774  // not reached
1775 }
1776 
1777 // Live Fraction per Bunch Crossing ID
1778 float
1780 livefractionPerBCID (const EventContext& ctx /*= Gaudi::Hive::currentContext()*/) const
1781 {
1783  return 1.0;
1784 
1787  return live->l1LiveFractionVector().at (ctx.eventID().bunch_crossing_id());
1788  } else {
1789  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! livefractionPerBCID() can't work properly! ");
1790  ATH_MSG_DEBUG("Warning: livefractionPerBCID() - luminosity retrieved available (i.e. EnableLumi = False)");
1791  return -1.0;
1792  }
1793  // not reached
1794 }
1795 
1796 // Average Integrated Luminosity Live Fraction
1797 double
1799 lbLumiWeight (const EventContext& ctx /*= Gaudi::Hive::currentContext()*/) const
1800 {
1801  if (!m_lumiDataKey.empty()) {
1802  return (lbAverageLuminosity(ctx)*lbDuration(ctx))*lbAverageLivefraction(ctx);
1803  } else{
1804  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLumiWeight() can't work properly! ");
1805  ATH_MSG_DEBUG("Warning: lbLumiWeight() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1806  return -1.0;
1807  }
1808  // not reached
1809 }
1810 
1811 
1812 // Luminosity block time (in seconds)
1813 double
1815 lbDuration (const EventContext& ctx /*= Gaudi::Hive::currentContext()*/) const
1816 {
1818  return m_defaultLBDuration;
1819  }
1820  if (!m_lbDurationDataKey.empty()) {
1822  return dur->lbDuration();
1823  } else {
1824  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbDuration() can't work properly! ");
1825  ATH_MSG_DEBUG("Warning: lbDuration() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1826  return m_defaultLBDuration;
1827  }
1828  // not reached
1829 }
1830 
1831 
1832 // *********************************************************************
1833 // Protected Methods
1834 // *********************************************************************
1835 
1837  OutputMetadata( TTree* metadata )
1838  : m_charArrSize(100)
1839  , m_metadata(metadata)
1840  , m_nameData(0)
1841  //, m_levelData(0)
1842  , m_intervalData(0)
1843  , m_triggerData(0)
1844  , m_mergeData(0)
1845 {
1846  m_nameData = new char[m_charArrSize];
1847  //m_levelData = new char[m_charArrSize];
1848  m_intervalData = new char[m_charArrSize];
1849  m_triggerData = new char[m_charArrSize];
1850  m_mergeData = new char[m_charArrSize];
1851  m_metadata->Branch( "Name", m_nameData, "Name/C" );
1852  //m_metadata->Branch( "LevelOfDetail", m_levelData, "LevelOfDetail/C" );
1853  m_metadata->Branch( "Interval", m_intervalData, "Interval/C" );
1854  m_metadata->Branch( "TriggerChain", m_triggerData, "TriggerChain/C" );
1855  m_metadata->Branch( "MergeMethod", m_mergeData, "MergeMethod/C" );
1856 }
1857 
1858 
1861 {
1862  delete [] m_mergeData;
1863  delete [] m_triggerData;
1864  delete [] m_intervalData;
1865  //delete [] m_levelData;
1866  delete [] m_nameData;
1867 }
1868 
1869 
1870 void
1872 fill( const std::string& name,
1873  //LevelOfDetail_t level,
1875  std::string trigger,
1876  std::string merge )
1877 {
1878  // ROOT does not properly write empty strings to output files in all cases. I haven't reported
1879  // this to the ROOT developers yet because I don't have time to develope a simple test case
1880  // for them (independent of Atlas software).
1881  // --M.G.Wilson, 7 July 2008
1882  if( trigger.empty() )
1883  trigger = "<none>";
1884  if( merge.empty() )
1885  merge = "<default>";
1886 
1887  copyString( m_nameData, name );
1888  //copyString( m_levelData, ManagedMonitorToolBase::levelOfDetailEnumToString( level ) );
1889  copyString( m_intervalData, ManagedMonitorToolBase::intervalEnumToString( interval ) );
1890  copyString( m_triggerData, trigger );
1891  copyString( m_mergeData, merge );
1892  m_metadata->Fill();
1893 }
1894 
1895 
1896 void
1898 copyString( char* to, const std::string& from )
1899 {
1900  int i = 0;
1901  const char* f = from.c_str();
1902  while( (++i < m_charArrSize) && ((*to++ = *f++) != 0) ) {};
1903  if( i == m_charArrSize ) {
1904  *to = 0;
1905  }
1906 }
1907 
1908 
1909 std::string
1911 getStreamName( const ManagedMonitorToolBase*, const MonGroup& group, const std::string& objName, bool )
1912 {
1913  std::ostringstream streamName;
1914 
1915  streamName << "/" << m_fileKey << "/";
1916 
1917  streamName << group.system() << "/" << objName;
1918  return streamName.str();
1919 }
1920 
1921 std::string
1923 getDirectoryName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, const bool usePreviousInterval )
1924 {
1925  std::string streamName = getStreamName(tool, group, objName, usePreviousInterval);
1926  std::string root, rem;
1927  parseString(streamName, root, rem);
1928  // Remove object name at the end
1929  // to obtain directory path
1930  rem.erase(rem.rfind('/'), rem.length());
1931  return rem;
1932 }
1933 
1934 
1935 std::string
1937 getStreamName( const ManagedMonitorToolBase*, const MonGroup& group, const std::string& objName, bool )
1938 {
1939  std::ostringstream streamName;
1940  streamName << group.system() << "/" << objName;
1941  return streamName.str();
1942 }
1943 
1944 
1945 std::string
1947 getDirectoryName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, const bool usePreviousInterval )
1948 {
1949  return getStreamName(tool, group, objName, usePreviousInterval);
1950 }
1951 
1952 std::string
1954 getStreamName( const ManagedMonitorToolBase*, const MonGroup& group, const std::string& objName, bool )
1955 {
1956  std::ostringstream streamName;
1957  //if( group.level() != ManagedMonitorToolBase::transient ) {
1958  // streamName << "/" << ManagedMonitorToolBase::levelOfDetailEnumToString( group.level(), true ) << "/";
1959  //}
1960  streamName << "/"; // slash is required for online environment;
1961  // otherwise the output histograms are placed in 'temp' subdirectory
1962 
1963  streamName << group.system() << "/" << objName;
1964  return streamName.str();
1965 }
1966 
1967 std::string
1969 getDirectoryName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, const bool usePreviousInterval )
1970 {
1971  return getStreamName(tool, group, objName, usePreviousInterval);
1972 }
1973 
1974 void
1976 getLBrange(int *start, int *end, int LB, int length) {
1977  if(start && end) {
1978  *start = ((LB-1)/length) * length + 1;
1979  *end = *start + length - 1;
1980  }
1981 }
1982 
1983 std::string
1985 getStreamName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, bool usePreviousInterval )
1986 {
1987  std::ostringstream streamName;
1988 
1989  //bool isTemp = ( group.level() == ManagedMonitorToolBase::transient );
1990  bool isTemp = false;
1991 
1992  bool useRunFolders = group.interval() != all;
1993 
1994  bool useLBFolders = ( useRunFolders )
1995  && ( group.interval() == ManagedMonitorToolBase::lumiBlock );
1996 
1997  bool useLowStatInterval = ( useRunFolders )
1998  && ( group.interval() == ManagedMonitorToolBase::lowStat );
1999 
2000  bool useMedStatInterval = ( useRunFolders )
2001  && ( group.interval() == ManagedMonitorToolBase::medStat );
2002 
2003  bool useHigStatInterval = ( useRunFolders )
2004  && ( group.interval() == ManagedMonitorToolBase::higStat );
2005 
2006  bool useEBFolders = ( group.interval() == ManagedMonitorToolBase::eventsBlock );
2007 
2008  if( !isTemp ) {
2009  streamName << "/" << m_fileKey << "/";
2010  }
2011 
2012  if( useRunFolders ) {
2013  if (usePreviousInterval && (group.interval() == ManagedMonitorToolBase::run) )
2014  streamName << "run_" << m_prev_run_number << "/";
2015  else
2016  streamName << "run_" << AthenaMonManager::runNumber() << "/";
2017  }
2018 
2019  int currentLB = AthenaMonManager::lumiBlockNumber();
2020  if( useLBFolders ) {
2021  if (usePreviousInterval && (group.interval() == ManagedMonitorToolBase::lumiBlock) )
2022  streamName << "lb_" << m_prev_lumi_block << "/";
2023  else
2024  streamName << "lb_" << currentLB << "/";
2025  }
2026  else if( useLowStatInterval ) {
2027  int start, end;
2028  if (usePreviousInterval && (group.interval() == ManagedMonitorToolBase::lowStat) )
2029  getLBrange(&start, &end, m_prev_lumi_block, AthenaMonManager::getLBsLowStat());
2030  else
2031  getLBrange(&start, &end, currentLB, AthenaMonManager::getLBsLowStat());
2032  streamName << "lowStat_LB" << start << "-" << end << "/";
2033  }
2034  else if( useMedStatInterval ) {
2035  int start, end;
2036  getLBrange(&start, &end, currentLB, AthenaMonManager::getLBsMedStat());
2037  streamName << "medStat_LB" << start << "-" << end << "/";
2038  }
2039  else if( useHigStatInterval ) {
2040  int start, end;
2041  getLBrange(&start, &end, currentLB, AthenaMonManager::getLBsHigStat());
2042  streamName << "higStat_LB" << start << "-" << end << "/";
2043  }
2044  else if( useEBFolders ) {
2045  // The number of events in an EventsBlock can vary for each ManagedMonitorToolBase object,
2046  // so there is no global way to determine when an EventsBlock has rolled over.
2047 
2048  // determine an eventsBlock number
2049  long eventsBlockNumber = 1; // assign some dafault value
2050  long procNEventsProp = tool->get_procNEventsProp();
2051  unsigned int nEvents = tool->get_nEvents();
2052  if (procNEventsProp > 0) {
2053  eventsBlockNumber = (long) nEvents / procNEventsProp;
2054  if ((nEvents % procNEventsProp) != 0)
2055  eventsBlockNumber++;
2056  }
2057 
2058  // lower eventsBlock number by 1 if usePreviousInterval is true;
2059  if (usePreviousInterval) {
2060  eventsBlockNumber--;
2061  }
2062 
2063  streamName << "eb_" << eventsBlockNumber << "/";
2064  }
2065 
2066  streamName << group.system() << "/" << objName;
2067 
2068  return streamName.str();
2069 }
2070 
2071 std::string
2073 getDirectoryName( const ManagedMonitorToolBase* tool, const MonGroup& group, const std::string& objName, const bool usePreviousInterval )
2074 {
2075  std::string streamName = getStreamName(tool, group, objName, usePreviousInterval);
2076  std::string root, rem;
2077  parseString(streamName, root, rem);
2078  // Remove object name at the end
2079  // to obtain directory path
2080  rem.erase(rem.rfind('/'), rem.length());
2081  return rem;
2082 }
2083 
2084 void
2086 updateRunLB() {
2087  m_prev_run_number = AthenaMonManager::runNumber();
2088  m_prev_lumi_block = AthenaMonManager::lumiBlockNumber();
2089 }
2090 
2091 bool
2093 trigChainsArePassed(std::vector<std::string>& vTrigNames)
2094 {
2095  ATH_MSG_DEBUG( "ManagedMonitorToolBase::trigChainsArePassed:");
2096 
2097  for(unsigned int i=0; i<vTrigNames.size(); i++) {
2098  if( m_trigDecTool->isPassed(vTrigNames[i]) ) {
2099  ATH_MSG_DEBUG( " + \"" << vTrigNames[i] << "\" passed, returning \'true\'");
2100  return true;
2101  }
2102  else {
2103  ATH_MSG_DEBUG( " - \"" << vTrigNames[i] << "\" did not pass");
2104  }
2105  }
2106 
2107  return false;
2108 }
2109 
2110 StatusCode
2112 parseList(const std::string& line, std::vector<std::string>& result) {
2113  std::string item;
2114  std::stringstream ss(line);
2115 
2116  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "ManagedMonitorToolBase::parseList:";
2117 
2118  while ( std::getline(ss, item, ',') ) {
2119  std::stringstream iss(item); // remove
2120  iss >> item; // whitespace
2121  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " " << item;
2122  result.push_back(item);
2123  }
2124 
2125  msg(MSG::DEBUG) << endmsg;
2126  return StatusCode::SUCCESS;
2127 }
2128 
2129 void
2131 updateTriggersForGroups(std::vector<std::string>& vTrigChainNames) {
2132  for (size_t i = 0; i < vTrigChainNames.size(); ++i) {
2133  std::string& thisName = vTrigChainNames[i];
2134  if (thisName.compare(0, 9, "CATEGORY_") ==0) {
2135  ATH_MSG_DEBUG("Found a trigger category: " << thisName << ". We will unpack it.");
2136  std::vector<std::string> triggers = m_trigTranslator->translate(thisName.substr(9,std::string::npos));
2137  std::ostringstream oss;
2138  oss << "(";
2139  for (size_t itrig = 0; itrig < triggers.size(); ++itrig) {
2140  if (itrig != 0) {
2141  oss << "|";
2142  }
2143  oss << triggers[itrig];
2144  }
2145  oss << ")";
2146  // replace with new value
2147  std::string newval = oss.str();
2148  ATH_MSG_DEBUG("Replaced with " << newval);
2149  vTrigChainNames[i] = std::move(newval);
2150  }
2151  }
2152 }
2153 
2156 getNewStreamNameFcn() const
2157 {
2158  StreamNameFcn* fcn(0);
2159 
2160  switch( m_environment ) {
2162  fcn = new NoOutputStream();
2163  break;
2165  fcn = new OnlineStream();
2166  break;
2168  fcn = new DefaultStream( m_fileKey );
2169  break;
2173  case AthenaMonManager::AOD:
2175  default:
2177  }
2178 
2179  return fcn;
2180 }
2181 
2182 void
2184 parseString(const std::string& streamName, std::string& root, std::string& rem) {
2185  std::string::size_type pos = streamName.find('/');
2186 
2187  if (pos == std::string::npos) {
2188  root = "";
2189  rem = streamName;
2190  return;
2191  }
2192 
2193  if (pos == 0) {
2194  parseString(streamName.substr(1,streamName.length()),root,rem);
2195  } else {
2196  root = streamName.substr(0,pos);
2197  rem = streamName.substr(pos+1,streamName.length());
2198  }
2199 
2200 }
2201 
2202 // *********************************************************************
2203 // Private Methods
2204 // *********************************************************************
2205 
2206 // GlobalDirectoryRestore ctor
2210  m_gd = gDirectory;
2211  m_gf = gFile;
2212 }
2213 
2214 // GlobalDirectoryRestore dtor
2218  gDirectory = m_gd;
2219  gFile = m_gf;
2220 }
2221 
2222 namespace {
2223 
2224  std::string strToLower( const std::string& str )
2225  {
2226  std::string lstr(str);
2227  std::string::const_iterator from = str.begin();
2228  std::string::const_iterator strend = str.end();
2229  std::string::iterator to = lstr.begin();
2230  while( from != strend ) {
2231  *to++ = tolower(*from++);
2232  }
2233  return lstr;
2234  }
2235 
2236 
2237 #if 0
2238  std::string strToUpper( const std::string& str )
2239  {
2240  std::string ustr(str);
2241  std::string::const_iterator from = str.begin();
2242  std::string::const_iterator strend = str.end();
2243  std::string::iterator to = ustr.begin();
2244  while( from != strend ) {
2245  *to++ = toupper(*from++);
2246  }
2247  return ustr;
2248  }
2249 #endif
2250 
2251 } // unnamed namespace
2252 
2253 #endif
ManagedMonitorToolBase::m_nEvents
unsigned int m_nEvents
Definition: ManagedMonitorToolBase.h:863
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
nEvents
const int nEvents
Definition: fbtTestBasics.cxx:78
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ManagedMonitorToolBase::THistSvc_deReg_fixTGraph
StatusCode THistSvc_deReg_fixTGraph(TFile *file, TGraph *theGraph, std::string &directoryName)
Fixes THistSvc->deReg(obj) when obj is TGraph instance.
Definition: ManagedMonitorToolBase.cxx:1037
ManagedMonitorToolBase::m_templateEfficiencies
std::map< Interval_t, std::vector< MgmtParams< TEfficiency > > > m_templateEfficiencies
Definition: ManagedMonitorToolBase.h:676
ManagedMonitorToolBase::streamNameFunction
virtual StreamNameFcn * streamNameFunction()
Returns the function object that converts logical paramters into a physical stream name.
Definition: ManagedMonitorToolBase.cxx:451
beamspotnt.var
var
Definition: bin/beamspotnt.py:1393
ManagedMonitorToolBase::Imp::m_bench_fillall
AthMonBench m_bench_fillall
Definition: ManagedMonitorToolBase.cxx:55
ManagedMonitorToolBase::m_newRun
bool m_newRun
Definition: ManagedMonitorToolBase.h:821
ManagedMonitorToolBase::MgmtParams< TH1 >
ManagedMonitorToolBase::StreamNameFcn
A function-object base class allowing the specific implementation of getStreamName to be decided at r...
Definition: ManagedMonitorToolBase.h:325
ManagedMonitorToolBase::m_supportedIntervalsForRebooking
std::set< Interval_t > m_supportedIntervalsForRebooking
Definition: ManagedMonitorToolBase.h:896
ManagedMonitorToolBase::preSelector
virtual bool preSelector()
Definition: ManagedMonitorToolBase.cxx:1680
ManagedMonitorToolBase::Interval_t
Interval_t
An enumeration describing how detailed a particular monitoring object is.
Definition: ManagedMonitorToolBase.h:113
ManagedMonitorToolBase::m_path
std::string m_path
Definition: ManagedMonitorToolBase.h:852
ManagedMonitorToolBase::m_dataTypeStr
std::string m_dataTypeStr
Definition: ManagedMonitorToolBase.h:834
ManagedMonitorToolBase::bookHistograms
virtual StatusCode bookHistograms()
An inheriting class should either override this function or bookHists().
Definition: ManagedMonitorToolBase.cxx:1297
ManagedMonitorToolBase::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Definition: ManagedMonitorToolBase.h:849
ManagedMonitorToolBase::getHist
virtual StatusCode getHist(TH1 *&h, const std::string &hName, const std::string &system, Interval_t interval)
Returns a TH1 via the pointer passed as the first argument.
Definition: ManagedMonitorToolBase.cxx:1408
ManagedMonitorToolBase::m_newEventsBlock
bool m_newEventsBlock
Definition: ManagedMonitorToolBase.h:822
ManagedMonitorToolBase::Imp::benchPreProcHistograms
void benchPreProcHistograms()
Definition: ManagedMonitorToolBase.cxx:119
get_generator_info.result
result
Definition: get_generator_info.py:21
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
ManagedMonitorToolBase::Imp::m_bench_tmp
AthMonBench m_bench_tmp
Definition: ManagedMonitorToolBase.cxx:52
ManagedMonitorToolBase::Imp
Definition: ManagedMonitorToolBase.cxx:36
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
ManagedMonitorToolBase::OutputMetadata::m_intervalData
char * m_intervalData
Definition: ManagedMonitorToolBase.h:719
CaloCellTimeCorrFiller.LB
LB
Definition: CaloCellTimeCorrFiller.py:36
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ManagedMonitorToolBase::MgmtAttr_t
MgmtAttr_t
An enumeration describing how the class handles the histogram.
Definition: ManagedMonitorToolBase.h:130
ManagedMonitorToolBase::higStat
@ higStat
Definition: ManagedMonitorToolBase.h:114
ManagedMonitorToolBase::fillHists
virtual StatusCode fillHists()
Calls fillHists( bool, bool, bool ); if an eventBlock,lumiBlock, or run has turned over,...
Definition: ManagedMonitorToolBase.cxx:740
ManagedMonitorToolBase::Imp::m_benchNFillAfterbook
unsigned m_benchNFillAfterbook
Definition: ManagedMonitorToolBase.cxx:59
ManagedMonitorToolBase::lumiBlock
@ lumiBlock
Definition: ManagedMonitorToolBase.h:113
ManagedMonitorToolBase::m_endOfLumiBlock
bool m_endOfLumiBlock
Definition: ManagedMonitorToolBase.h:823
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:73
ManagedMonitorToolBase::NoOutputStream
Definition: ManagedMonitorToolBase.h:738
ManagedMonitorToolBase::MonGroup::deregGraph
StatusCode deregGraph(TGraph *g)
De-registers a TGraph from the THistSvc, but does NOT delete the object.
Definition: ManagedMonitorToolBase.cxx:289
ManagedMonitorToolBase::m_THistSvc
ServiceHandle< ITHistSvc > m_THistSvc
Definition: ManagedMonitorToolBase.h:843
ManagedMonitorToolBase::m_procNEventsProp
long m_procNEventsProp
Definition: ManagedMonitorToolBase.h:851
ManagedMonitorToolBase::regTree
virtual StatusCode regTree(TTree *t, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TTree to be included in the output stream using logical parameters that describe it.
Definition: ManagedMonitorToolBase.cxx:1545
AthenaMonManager::runNumber
static unsigned int runNumber()
Definition: AthenaMonManager.cxx:340
initialize
void initialize()
Definition: run_EoverP.cxx:894
ManagedMonitorToolBase::setupOutputStreams
virtual StatusCode setupOutputStreams(std::vector< std::string > Mapping=std::vector< std::string >())
This implementation does nothing—streams in this class should be managed by the AthenaMonManager.
Definition: ManagedMonitorToolBase.cxx:1651
AthenaMonManager::fileKey
virtual std::string fileKey() const
Definition: AthenaMonManager.cxx:647
ManagedMonitorToolBase::NoOutputStream::getStreamName
virtual std::string getStreamName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, bool usePreviousInterval=false)
A function that converts a MonGroup of logical parameters into a physical output stream name.
Definition: ManagedMonitorToolBase.cxx:1937
ManagedMonitorToolBase::m_environmentStr
std::string m_environmentStr
Definition: ManagedMonitorToolBase.h:835
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:13
ManagedMonitorToolBase::Imp::benchPreFillHistograms
void benchPreFillHistograms()
Definition: ManagedMonitorToolBase.cxx:94
AthenaMonManager::AOD
@ AOD
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::regManagedGraphs
StatusCode regManagedGraphs(std::vector< MgmtParams< TGraph > > &templateGraphs)
Definition: ManagedMonitorToolBase.cxx:1069
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
ManagedMonitorToolBase::Imp::benchPostFillHistograms
void benchPostFillHistograms()
Definition: ManagedMonitorToolBase.cxx:103
ManagedMonitorToolBase::runStat
virtual StatusCode runStat()
This implementation does nothing; equivalent functionality may be provided by procHists( true,...
Definition: ManagedMonitorToolBase.cxx:1662
ManagedMonitorToolBase::writeAndDelete
virtual StatusCode writeAndDelete(TH1 *h, const MonGroup &group)
Write out histogram and delete it.
Definition: ManagedMonitorToolBase.cxx:1600
ManagedMonitorToolBase::livefractionPerBCID
virtual float livefractionPerBCID(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Livefraction per bunch crossing ID.
Definition: ManagedMonitorToolBase.cxx:1780
ManagedMonitorToolBase::regManagedHistograms
StatusCode regManagedHistograms(std::vector< MgmtParams< TH1 > > &templateHistograms)
Definition: ManagedMonitorToolBase.cxx:972
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
ManagedMonitorToolBase::Imp::m_bench_total
AthMonBench m_bench_total
Definition: ManagedMonitorToolBase.cxx:58
ManagedMonitorToolBase::lbDuration
virtual double lbDuration(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Luminosity block time (in seconds)
Definition: ManagedMonitorToolBase.cxx:1815
ManagedMonitorToolBase::m_trigDecTool
PublicToolHandle< Trig::ITrigDecisionTool > m_trigDecTool
Definition: ManagedMonitorToolBase.h:845
skel.it
it
Definition: skel.GENtoEVGEN.py:407
ManagedMonitorToolBase::Imp::~Imp
~Imp()
Definition: ManagedMonitorToolBase.cxx:43
ManagedMonitorToolBase::m_d
Imp * m_d
Definition: ManagedMonitorToolBase.h:899
ManagedMonitorToolBase::m_lastLowStatInterval
int m_lastLowStatInterval
Definition: ManagedMonitorToolBase.h:861
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
ManagedMonitorToolBase::OutputMetadata
Definition: ManagedMonitorToolBase.h:700
ManagedMonitorToolBase::m_triggerGroupProp
std::string m_triggerGroupProp
Definition: ManagedMonitorToolBase.h:855
ManagedMonitorToolBase::Imp::benchPostProcHistograms
void benchPostProcHistograms()
Definition: ManagedMonitorToolBase.cxx:127
ManagedMonitorToolBase::m_dataType
AthenaMonManager::DataType_t m_dataType
Definition: ManagedMonitorToolBase.h:838
ManagedMonitorToolBase::regGraph
virtual StatusCode regGraph(TGraph *g, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TGraph to be included in the output stream using logical parameters that describe the gra...
Definition: ManagedMonitorToolBase.cxx:1489
ManagedMonitorToolBase::m_useLumi
bool m_useLumi
Definition: ManagedMonitorToolBase.h:894
ManagedMonitorToolBase::m_newLowStatInterval
bool m_newLowStatInterval
Definition: ManagedMonitorToolBase.h:820
sendEI_SPB.root
root
Definition: sendEI_SPB.py:34
ManagedMonitorToolBase::fill
@ fill
Definition: ManagedMonitorToolBase.h:115
ManagedMonitorToolBase::parseList
StatusCode parseList(const std::string &, std::vector< std::string > &)
Definition: ManagedMonitorToolBase.cxx:2112
ManagedMonitorToolBase::regManagedEfficiencies
StatusCode regManagedEfficiencies(std::vector< MgmtParams< TEfficiency > > &templateEfficiencies)
Definition: ManagedMonitorToolBase.cxx:1139
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
python.TrigTLAMonitorAlgorithm.triggers
triggers
Definition: TrigTLAMonitorAlgorithm.py:196
ManagedMonitorToolBase::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition: ManagedMonitorToolBase.cxx:1313
ManagedMonitorToolBase::MonGroup::badusage
static void badusage()
Definition: ManagedMonitorToolBase.cxx:185
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
ManagedMonitorToolBase::DefaultStream::getDirectoryName
virtual std::string getDirectoryName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, const bool usePreviousInterval)
A function that returns TDirectory path in a file that corresponds to a given MonGroup and object nam...
Definition: ManagedMonitorToolBase.cxx:1923
ManagedMonitorToolBase::Imp::m_bench_book
AthMonBench m_bench_book
Definition: ManagedMonitorToolBase.cxx:53
ManagedMonitorToolBase::GlobalDirectoryRestore
Private helper class.
Definition: ManagedMonitorToolBase.h:874
dq_defect_bulk_create_defects.line
line
Definition: dq_defect_bulk_create_defects.py:27
ManagedMonitorToolBase::Imp::benchFinalReport
void benchFinalReport()
Definition: ManagedMonitorToolBase.cxx:156
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
ManagedMonitorToolBase::regManagedTrees
StatusCode regManagedTrees(std::vector< MgmtParams< TTree > > &templateTrees)
Definition: ManagedMonitorToolBase.cxx:1200
ManagedMonitorToolBase::OutputMetadata::m_charArrSize
const int m_charArrSize
Definition: ManagedMonitorToolBase.h:715
ManagedMonitorToolBase::registerMetadata
StatusCode registerMetadata(const std::string &streamName, const std::string &hName, const MonGroup &group)
Definition: ManagedMonitorToolBase.cxx:946
AthenaMonManager::getLBsLowStat
static unsigned int getLBsLowStat()
Definition: AthenaMonManager.cxx:302
ManagedMonitorToolBase::checkHists
virtual StatusCode checkHists(bool calledFromFinalize)
This implementation does nothing; equivalent functionality may be provided by procHists(....
Definition: ManagedMonitorToolBase.cxx:1670
ManagedMonitorToolBase::m_newHigStatInterval
bool m_newHigStatInterval
Definition: ManagedMonitorToolBase.h:820
ReadCondHandle.h
ManagedMonitorToolBase::m_newMedStatInterval
bool m_newMedStatInterval
Definition: ManagedMonitorToolBase.h:820
TrigLiveFractionCondData::lbAverageLiveFraction
float lbAverageLiveFraction(bool highPriority=true) const
Luminosity-averaged live fraction over all physics BCIDs.
Definition: TrigLiveFractionCondData.cxx:66
ManagedMonitorToolBase::OutputMetadata::m_metadata
TTree * m_metadata
Definition: ManagedMonitorToolBase.h:716
ManagedMonitorToolBase::deregHist
virtual StatusCode deregHist(TH1 *h)
De-registers a TH1 from the THistSvc, but does NOT delete the object.
Definition: ManagedMonitorToolBase.cxx:1616
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
ManagedMonitorToolBase::lbLuminosityPerBCID
virtual float lbLuminosityPerBCID(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Instantaneous luminosity.
Definition: ManagedMonitorToolBase.cxx:1744
ManagedMonitorToolBase::Imp::m_bench_proc
AthMonBench m_bench_proc
Definition: ManagedMonitorToolBase.cxx:57
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
ManagedMonitorToolBase::OfflineStream::getStreamName
virtual std::string getStreamName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, bool usePreviousInterval=false)
A function that converts a MonGroup of logical parameters into a physical output stream name.
Definition: ManagedMonitorToolBase.cxx:1985
python.checkMetadata.metadata
metadata
Definition: checkMetadata.py:175
ManagedMonitorToolBase::OutputMetadata::fill
virtual void fill(const std::string &name, Interval_t interval, std::string trigger, std::string merge)
Definition: ManagedMonitorToolBase.cxx:1872
AthenaMonManager::getLBsMedStat
static unsigned int getLBsMedStat()
Definition: AthenaMonManager.cxx:305
ManagedMonitorToolBase::m_bookHistogramsInitial
bool m_bookHistogramsInitial
Definition: ManagedMonitorToolBase.h:893
ManagedMonitorToolBase::Imp::m_warnAboutMissingInitialize
bool m_warnAboutMissingInitialize
Definition: ManagedMonitorToolBase.cxx:48
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
ManagedMonitorToolBase::getNewStreamNameFcn
virtual StreamNameFcn * getNewStreamNameFcn() const
Definition: ManagedMonitorToolBase.cxx:2156
ManagedMonitorToolBase::m_preScaleProp
long m_preScaleProp
Definition: ManagedMonitorToolBase.h:853
ManagedMonitorToolBase::lbInteractionsPerCrossing
virtual float lbInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Instantaneous number of interactions, i.e.
Definition: ManagedMonitorToolBase.cxx:1708
ManagedMonitorToolBase::trigChainsArePassed
virtual bool trigChainsArePassed(std::vector< std::string > &)
Definition: ManagedMonitorToolBase.cxx:2093
ManagedMonitorToolBase.h
ManagedMonitorToolBase::m_fileKey
std::string m_fileKey
Definition: ManagedMonitorToolBase.h:833
ManagedMonitorToolBase::m_lastLumiBlock
unsigned int m_lastLumiBlock
Definition: ManagedMonitorToolBase.h:859
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition: ManagedMonitorToolBase.h:137
ManagedMonitorToolBase::m_vTrigGroupNames
std::vector< std::string > m_vTrigGroupNames
Definition: ManagedMonitorToolBase.h:680
ManagedMonitorToolBase::GlobalDirectoryRestore::GlobalDirectoryRestore
GlobalDirectoryRestore()
Definition: ManagedMonitorToolBase.cxx:2209
ManagedMonitorToolBase::Imp::m_bench_fillfirst
AthMonBench m_bench_fillfirst
Definition: ManagedMonitorToolBase.cxx:54
AthenaMonManager::tier0ESD
@ tier0ESD
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::lbAverageLivefraction
virtual float lbAverageLivefraction(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average luminosity livefraction.
Definition: ManagedMonitorToolBase.cxx:1761
ManagedMonitorToolBase::m_templateGraphs
std::map< Interval_t, std::vector< MgmtParams< TGraph > > > m_templateGraphs
Definition: ManagedMonitorToolBase.h:668
AthenaMonManager::dataType
static DataType_t dataType()
Returns the data type that the monitoring application is running over to help ManagedMonitorToolBase ...
Definition: AthenaMonManager.cxx:314
ManagedMonitorToolBase::OutputMetadata::m_triggerData
char * m_triggerData
Definition: ManagedMonitorToolBase.h:720
AthenaMonManager
An Algorithm that manages a set of modules, each inheriting from ManagedMonitorToolBase,...
Definition: AthenaMonManager.h:34
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ManagedMonitorToolBase::m_manager
AthenaMonManager * m_manager
Definition: ManagedMonitorToolBase.h:829
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:616
ManagedMonitorToolBase::m_lumiDataKey
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey
Definition: ManagedMonitorToolBase.h:887
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::deregGraph
virtual StatusCode deregGraph(TGraph *g)
De-registers a TGraph from the THistSvc, but does NOT delete the object.
Definition: ManagedMonitorToolBase.cxx:1624
ManagedMonitorToolBase::m_streamNameFcn
StreamNameFcn * m_streamNameFcn
Definition: ManagedMonitorToolBase.h:841
defineDB.smd
smd
Definition: JetTagCalibration/share/defineDB.py:44
ManagedMonitorToolBase::OutputMetadata::m_nameData
char * m_nameData
Definition: ManagedMonitorToolBase.h:717
ManagedMonitorToolBase::setMonManager
virtual void setMonManager(AthenaMonManager *manager)
Takes a pointer to a managing object to get information from it when needed.
Definition: ManagedMonitorToolBase.cxx:1326
ParseInputs.gDirectory
gDirectory
Definition: Final2012/ParseInputs.py:133
ManagedMonitorToolBase::OutputMetadata::~OutputMetadata
virtual ~OutputMetadata()
Definition: ManagedMonitorToolBase.cxx:1860
lumiFormat.i
int i
Definition: lumiFormat.py:85
AthenaMonManager::tier0
@ tier0
Definition: AthenaMonManager.h:49
ITrigDecisionTool.h
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
ManagedMonitorToolBase::GlobalDirectoryRestore::~GlobalDirectoryRestore
~GlobalDirectoryRestore()
Definition: ManagedMonitorToolBase.cxx:2217
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
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
ManagedMonitorToolBase::file
@ file
Definition: ManagedMonitorToolBase.h:113
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:108
python.CaloAddPedShiftConfig.str
str
Definition: CaloAddPedShiftConfig.py:42
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:663
getLatestRuns.interval
interval
Definition: getLatestRuns.py:24
ManagedMonitorToolBase::DefaultStream
Definition: ManagedMonitorToolBase.h:725
ManagedMonitorToolBase::ATTRIB_UNMANAGED
@ ATTRIB_UNMANAGED
Definition: ManagedMonitorToolBase.h:130
file
TFile * file
Definition: tile_monitor.h:29
ManagedMonitorToolBase::Imp::benchPostBookHistograms
void benchPostBookHistograms()
Definition: ManagedMonitorToolBase.cxx:84
test_pyathena.parent
parent
Definition: test_pyathena.py:15
AthenaMonManager::tier0Raw
@ tier0Raw
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::m_triggerChainProp
std::string m_triggerChainProp
Definition: ManagedMonitorToolBase.h:854
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ManagedMonitorToolBase::OnlineStream
Definition: ManagedMonitorToolBase.h:745
AthenaMonManager::user
@ user
Definition: AthenaMonManager.h:49
hist_file_dump.f
f
Definition: hist_file_dump.py:140
ManagedMonitorToolBase::MonGroup::ncopies
static unsigned ncopies()
Definition: ManagedMonitorToolBase.cxx:184
run
Definition: run.py:1
ManagedMonitorToolBase::OfflineStream
Definition: ManagedMonitorToolBase.h:752
ManagedMonitorToolBase::StreamNameFcn::getStreamName
virtual std::string getStreamName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, bool usePreviousInterval=false)=0
A function that converts a MonGroup of logical parameters into a physical output stream name.
ManagedMonitorToolBase::Imp::m_doResourceMon
bool m_doResourceMon
Definition: ManagedMonitorToolBase.cxx:51
ManagedMonitorToolBase::~ManagedMonitorToolBase
virtual ~ManagedMonitorToolBase()
Definition: ManagedMonitorToolBase.cxx:435
ManagedMonitorToolBase::ManagedMonitorToolBase
ManagedMonitorToolBase(const std::string &type, const std::string &name, const IInterface *parent)
Definition: ManagedMonitorToolBase.cxx:338
ManagedMonitorToolBase::medStat
@ medStat
Definition: ManagedMonitorToolBase.h:114
ManagedMonitorToolBase::MonGroup::deregObject
StatusCode deregObject(const std::string &objName)
De-registers a TObject from the THistSvc, but does NOT delete the object.
Definition: ManagedMonitorToolBase.cxx:301
ManagedMonitorToolBase::m_templateTrees
std::map< Interval_t, std::vector< MgmtParams< TTree > > > m_templateTrees
Definition: ManagedMonitorToolBase.h:672
ManagedMonitorToolBase::m_metadataMap
MDMap_t m_metadataMap
Definition: ManagedMonitorToolBase.h:827
ManagedMonitorToolBase::bookHists
virtual StatusCode bookHists()
Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers.
Definition: ManagedMonitorToolBase.cxx:730
ManagedMonitorToolBase::Imp::benchReset
void benchReset()
Definition: ManagedMonitorToolBase.cxx:140
ManagedMonitorToolBase::m_endOfEventsBlock
bool m_endOfEventsBlock
Definition: ManagedMonitorToolBase.h:823
ManagedMonitorToolBase::m_trigLiveFractionDataKey
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey
Definition: ManagedMonitorToolBase.h:891
TrigLiveFractionCondData::l1LiveFractionVector
const std::vector< float > & l1LiveFractionVector(bool highPriority=true) const
Return vector with all BCIDs indexed by BCID number.
Definition: TrigLiveFractionCondData.cxx:42
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition: ManagedMonitorToolBase.h:839
ManagedMonitorToolBase::MonGroup::regHist
StatusCode regHist(TH1 *h)
Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical ...
Definition: ManagedMonitorToolBase.cxx:192
beamspotman.dir
string dir
Definition: beamspotman.py:621
ManagedMonitorToolBase::regEfficiency
virtual StatusCode regEfficiency(TEfficiency *e, const MonGroup &group)
Registers a TEfficiency to be included in the output stream using logical parameters that describe th...
Definition: ManagedMonitorToolBase.cxx:1444
LBDurationCondData::lbDuration
double lbDuration() const
Definition: LBDurationCondData.cxx:27
ManagedMonitorToolBase::OutputMetadata::OutputMetadata
OutputMetadata(TTree *metadata)
Definition: ManagedMonitorToolBase.cxx:1837
ManagedMonitorToolBase::m_lastRun
unsigned int m_lastRun
Definition: ManagedMonitorToolBase.h:860
ManagedMonitorToolBase::intervalStringToEnum
static Interval_t intervalStringToEnum(const std::string &str)
Converts a string to the corresponding Interval_t.
Definition: ManagedMonitorToolBase.cxx:578
ManagedMonitorToolBase::DefaultStream::getStreamName
virtual std::string getStreamName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, bool usePreviousInterval=false)
A function that converts a MonGroup of logical parameters into a physical output stream name.
Definition: ManagedMonitorToolBase.cxx:1911
ManagedMonitorToolBase::MonGroup::regEfficiency
StatusCode regEfficiency(TEfficiency *e)
Registers a TEfficiency to be included in the output stream.
Definition: ManagedMonitorToolBase.cxx:227
ManagedMonitorToolBase::m_newLumiBlock
bool m_newLumiBlock
Definition: ManagedMonitorToolBase.h:821
ManagedMonitorToolBase::m_endOfLowStat
bool m_endOfLowStat
Definition: ManagedMonitorToolBase.h:823
ManagedMonitorToolBase::m_lbDurationDataKey
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey
Definition: ManagedMonitorToolBase.h:889
WriteHiveWithMetaData.streamName
string streamName
Definition: WriteHiveWithMetaData.py:22
ManagedMonitorToolBase::OfflineStream::updateRunLB
void updateRunLB()
Definition: ManagedMonitorToolBase.cxx:2086
ManagedMonitorToolBase::bookHistogramsRecurrent
virtual StatusCode bookHistogramsRecurrent()
An inheriting class should either override this function, bookHists() or bookHistograms().
Definition: ManagedMonitorToolBase.cxx:1285
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:452
ManagedMonitorToolBase::OfflineStream::getLBrange
void getLBrange(int *, int *, int, int)
Definition: ManagedMonitorToolBase.cxx:1976
ManagedMonitorToolBase::Imp::Imp
Imp(ManagedMonitorToolBase *tc)
Definition: ManagedMonitorToolBase.cxx:39
ManagedMonitorToolBase::OnlineStream::getDirectoryName
virtual std::string getDirectoryName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, const bool usePreviousInterval)
A function that returns TDirectory path in a file that corresponds to a given MonGroup and object nam...
Definition: ManagedMonitorToolBase.cxx:1969
ExtractEBRunDetails.endOfRun
endOfRun
Definition: ExtractEBRunDetails.py:245
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
checkTriggerxAOD.found
found
Definition: checkTriggerxAOD.py:328
ManagedMonitorToolBase::OfflineStream::getDirectoryName
virtual std::string getDirectoryName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, const bool usePreviousInterval)
A function that returns TDirectory path in a file that corresponds to a given MonGroup and object nam...
Definition: ManagedMonitorToolBase.cxx:2073
item
Definition: ItemListSvc.h:43
DiTauRecTools::parseString
std::vector< TString > parseString(const TString &str, const TString &delim=",")
Definition: Reconstruction/DiTauRecTools/Root/HelperFunctions.cxx:19
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
ManagedMonitorToolBase::lowStat
@ lowStat
Definition: ManagedMonitorToolBase.h:114
ManagedMonitorToolBase::updateTriggersForGroups
void updateTriggersForGroups(std::vector< std::string > &)
Definition: ManagedMonitorToolBase.cxx:2131
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
CxxUtils::to
CONT to(RANGE &&r)
Definition: ranges.h:39
ManagedMonitorToolBase::OnlineStream::getStreamName
virtual std::string getStreamName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, bool usePreviousInterval=false)
A function that converts a MonGroup of logical parameters into a physical output stream name.
Definition: ManagedMonitorToolBase.cxx:1954
ManagedMonitorToolBase::m_managerNameProp
std::string m_managerNameProp
Definition: ManagedMonitorToolBase.h:831
ManagedMonitorToolBase::lbLumiWeight
virtual double lbLumiWeight(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average Integrated Luminosity Live Fraction.
Definition: ManagedMonitorToolBase.cxx:1799
ManagedMonitorToolBase::MonGroup::regGraph
StatusCode regGraph(TGraph *g)
Registers a TGraph to be included in the output stream using logical parameters that describe the his...
Definition: ManagedMonitorToolBase.cxx:237
ManagedMonitorToolBase::m_nEventsIgnoreTrigger
unsigned int m_nEventsIgnoreTrigger
Definition: ManagedMonitorToolBase.h:864
ManagedMonitorToolBase::run
@ run
Definition: ManagedMonitorToolBase.h:115
ManagedMonitorToolBase::m_endOfRun
bool m_endOfRun
Definition: ManagedMonitorToolBase.h:823
ManagedMonitorToolBase::m_newLowStat
bool m_newLowStat
Definition: ManagedMonitorToolBase.h:821
ManagedMonitorToolBase::MonGroup::writeAndDelete
StatusCode writeAndDelete(TH1 *h)
Write and delete a histogram.
Definition: ManagedMonitorToolBase.cxx:261
lumiFormat.lumi
lumi
Definition: lumiFormat.py:106
ManagedMonitorToolBase::StreamNameFcn::parseString
static void parseString(const std::string &streamName, std::string &root, std::string &rem)
A helper non-virtual function, parses id string.
Definition: ManagedMonitorToolBase.cxx:2184
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
ManagedMonitorToolBase::OutputMetadata::m_mergeData
char * m_mergeData
Definition: ManagedMonitorToolBase.h:721
AthenaMonManager::forkedProcess
bool forkedProcess()
Definition: AthenaMonManager.cxx:321
ManagedMonitorToolBase::m_lastHigStatInterval
int m_lastHigStatInterval
Definition: ManagedMonitorToolBase.h:861
ManagedMonitorToolBase::MonGroup::getHist
StatusCode getHist(TH1 *&h, const std::string &hName)
Returns a TH1 via the pointer passed as the first argument.
Definition: ManagedMonitorToolBase.cxx:205
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ManagedMonitorToolBase::Imp::benchPreBookHistograms
void benchPreBookHistograms()
Definition: ManagedMonitorToolBase.cxx:75
ManagedMonitorToolBase::m_nLumiBlocks
unsigned int m_nLumiBlocks
Definition: ManagedMonitorToolBase.h:865
AthenaMonManager::altprod
@ altprod
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::eventsBlock
@ eventsBlock
Definition: ManagedMonitorToolBase.h:113
ManagedMonitorToolBase::OutputMetadata::copyString
void copyString(char *to, const std::string &from)
Definition: ManagedMonitorToolBase.cxx:1898
python.envutil.filelist
filelist
print ("Checking files %s..." % fullfile)
Definition: envutil.py:133
ManagedMonitorToolBase::Imp::m_theclass
ManagedMonitorToolBase * m_theclass
Definition: ManagedMonitorToolBase.cxx:46
DEBUG
#define DEBUG
Definition: page_access.h:11
ManagedMonitorToolBase::finalHists
virtual StatusCode finalHists()
Calls procHists( true, true, true ).
Definition: ManagedMonitorToolBase.cxx:1255
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
ManagedMonitorToolBase::all
@ all
Definition: ManagedMonitorToolBase.h:115
ManagedMonitorToolBase::deregObject
virtual StatusCode deregObject(const std::string &objName, const std::string &system, Interval_t interval)
De-registers a TObject from the THistSvc, but does NOT delete the object.
Definition: ManagedMonitorToolBase.cxx:1632
ManagedMonitorToolBase::NoOutputStream::getDirectoryName
virtual std::string getDirectoryName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, const bool usePreviousInterval)
A function that returns TDirectory path in a file that corresponds to a given MonGroup and object nam...
Definition: ManagedMonitorToolBase.cxx:1947
ManagedMonitorToolBase::StreamNameFcn::getDirectoryName
virtual std::string getDirectoryName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, const bool usePreviousInterval)=0
A function that returns TDirectory path in a file that corresponds to a given MonGroup and object nam...
ManagedMonitorToolBase::MonGroup::deregHist
StatusCode deregHist(TH1 *h)
De-registers a TH1 from the THistSvc, but does NOT delete the object.
Definition: ManagedMonitorToolBase.cxx:275
ManagedMonitorToolBase::fillHistograms
virtual StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: ManagedMonitorToolBase.cxx:1305
ManagedMonitorToolBase::lbAverageLuminosity
virtual float lbAverageLuminosity(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)
Definition: ManagedMonitorToolBase.cxx:1728
str
Definition: BTagTrackIpAccessor.cxx:11
python.Logging.manager
manager
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/Logging.py:92
ManagedMonitorToolBase::m_useTrigger
bool m_useTrigger
Definition: ManagedMonitorToolBase.h:857
ManagedMonitorToolBase::m_detailLevel
unsigned int m_detailLevel
Definition: ManagedMonitorToolBase.h:836
ManagedMonitorToolBase::m_haveClearedLastEventBlock
bool m_haveClearedLastEventBlock
Definition: ManagedMonitorToolBase.h:866
AthenaMonManager::lumiBlockNumber
static unsigned int lumiBlockNumber()
Definition: AthenaMonManager.cxx:328
AthAlgTool
Definition: AthAlgTool.h:26
IDQFilterTool.h
ManagedMonitorToolBase::m_templateHistograms
std::map< Interval_t, std::vector< MgmtParams< TH1 > > > m_templateHistograms
Definition: ManagedMonitorToolBase.h:664
ManagedMonitorToolBase::Imp::m_bench_filllast
AthMonBench m_bench_filllast
Definition: ManagedMonitorToolBase.cxx:56
ManagedMonitorToolBase::ATTRIB_X_VS_LB
@ ATTRIB_X_VS_LB
Definition: ManagedMonitorToolBase.h:130
ManagedMonitorToolBase::Imp::s_svcLocator
static std::atomic< ISvcLocator * > s_svcLocator
Definition: ManagedMonitorToolBase.cxx:38
python.PyAthena.obj
obj
Definition: PyAthena.py:132
ManagedMonitorToolBase::m_trigTranslator
PublicToolHandle< ITriggerTranslatorTool > m_trigTranslator
Definition: ManagedMonitorToolBase.h:847
ManagedMonitorToolBase::m_lastMedStatInterval
int m_lastMedStatInterval
Definition: ManagedMonitorToolBase.h:861
ManagedMonitorToolBase::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Definition: ManagedMonitorToolBase.h:680
AthMonBench
Definition: AthMonBench.h:25
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
ManagedMonitorToolBase::MonGroup::deregAll
StatusCode deregAll()
De-registers all TH1 objects from the THistSvc, but does NOT delete the objects.
Definition: ManagedMonitorToolBase.cxx:313
ManagedMonitorToolBase::regHist
virtual StatusCode regHist(TH1 *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical ...
Definition: ManagedMonitorToolBase.cxx:1344
merge
Definition: merge.py:1
AthenaMonManager::noOutput
@ noOutput
Definition: AthenaMonManager.h:49
AthenaMonManager::monteCarlo
@ monteCarlo
Definition: AthenaMonManager.h:58
ManagedMonitorToolBase::intervalEnumToString
static std::string intervalEnumToString(Interval_t interval)
Converts a LevelOfDetail_t to a string of the same name.
Definition: ManagedMonitorToolBase.cxx:536
ManagedMonitorToolBase::MonGroup::regTree
StatusCode regTree(TTree *t)
Registers a TTree to be included in the output stream using logical parameters that describe the hist...
Definition: ManagedMonitorToolBase.cxx:249
ManagedMonitorToolBase::m_defaultLBDuration
float m_defaultLBDuration
Definition: ManagedMonitorToolBase.h:895
ServiceHandle< Gaudi::Interfaces::IOptionsSvc >
python.SystemOfUnits.ms
float ms
Definition: SystemOfUnits.py:148
ManagedMonitorToolBase::lbAverageInteractionsPerCrossing
virtual float lbAverageInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average mu, i.e.
Definition: ManagedMonitorToolBase.cxx:1692