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

Class for TileCal monitoring at channel level. More...

#include <TileRawChannelMonTool.h>

Inheritance diagram for TileRawChannelMonTool:
Collaboration diagram for TileRawChannelMonTool:

Classes

struct  Data
 

Public Types

enum  TileFragStatus {
  ALL_OK =0, CRC_ERR =1, ALL_FF =0x10, ALL_00 =0x20,
  NO_FRAG =0x40, NO_ROB =0x80
}
 
enum  Interval_t {
  file = 0, eventsBlock, lumiBlock, lowStat,
  medStat, higStat, run, fill,
  all
}
 An enumeration describing how detailed a particular monitoring object is. More...
 
enum  MgmtAttr_t { ATTRIB_MANAGED = 0, ATTRIB_UNMANAGED = 1, ATTRIB_X_VS_LB = 2 }
 An enumeration describing how the class handles the histogram. More...
 

Public Member Functions

 TileRawChannelMonTool (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~TileRawChannelMonTool ()
 
virtual StatusCode initialize () override
 
virtual StatusCode bookHists () override
 Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers. More...
 
virtual StatusCode fillHists () override
 Calls fillHists( bool, bool, bool ); if an eventBlock,lumiBlock, or run has turned over, calls procHists( bool, bool, bool ) and bookHists( bool, bool, bool ). More...
 
virtual StatusCode finalHists () override
 Calls procHists( true, true, true ). More...
 
virtual StatusCode checkHists (bool fromFinalize) override
 This implementation does nothing; equivalent functionality may be provided by procHists(...) with appropriate arguments. More...
 
void bookHists (int ros, int drawer)
 
void drawHists (int ros, int drawer, const std::string &moduleName)
 
void ratioErrorBar (TH1S *hist, double &xmin, double &xmax, double mean)
 
void rangeErrorBar (double &xmin, double &max, double mean)
 
void bookDsp (int ros, int drawer)
 
StatusCode fillDsp (std::map< int, std::vector< double > > &efitMap, std::map< int, std::vector< double > > &tfitMap)
 
StatusCode finalDsp (int ros, int drawer)
 
void drawDsp (int ros, int drawer, const std::string &moduleName)
 
void drawOptFilt (int ros, int drawer, const std::string &moduleName)
 
TF1 * GetTimeFitFunc (TH2S *hist2d)
 Time Slope parameters for CIS runs. More...
 
void LaserFancyPlotting (int ros, int drawer, int maxgain, const std::string &moduleName)
 
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 parameters that describe the histogram. More...
 
virtual StatusCode regHist (TH1 *h, const MonGroup &group)
 Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram. More...
 
virtual StatusCode regHist (LWHist *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
 Support for lightweight histograms: More...
 
virtual StatusCode regHist (LWHist *h, const MonGroup &group)
 
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 graph. More...
 
virtual StatusCode regGraph (TGraph *g, const MonGroup &group)
 Registers a TGraph to be included in the output stream using logical parameters that describe the graph. More...
 
virtual StreamNameFcn * streamNameFunction ()
 Returns the function object that converts logical paramters into a physical stream name. More...
 
virtual StatusCode convertLWHists ()
 Deal with the LW histograms. More...
 
virtual StatusCode bookHistograms ()
 An inheriting class should either override this function or bookHists(). More...
 
virtual StatusCode bookHistogramsRecurrent ()
 An inheriting class should either override this function, bookHists() or bookHistograms(). More...
 
virtual StatusCode fillHistograms ()
 An inheriting class should either override this function or fillHists(). More...
 
virtual StatusCode procHistograms ()
 An inheriting class should either override this function or finalHists(). More...
 
virtual void setMonManager (AthenaMonManager *manager)
 Takes a pointer to a managing object to get information from it when needed. More...
 
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. More...
 
virtual StatusCode getHist (TH1 *&h, const std::string &hName, const MonGroup &group)
 Returns a TH1 via the pointer passed as the first argument. More...
 
virtual StatusCode getHist (TH2 *&h, const std::string &hName, const std::string &system, Interval_t interval)
 Returns a TH2 via the pointer passed as the first argument. More...
 
virtual StatusCode getHist (TH2 *&h, const std::string &hName, const MonGroup &group)
 Returns a TH2 via the pointer passed as the first argument. More...
 
virtual StatusCode getHist (LWHist *&h, const std::string &hName, const std::string &system, Interval_t interval)
 
virtual StatusCode getHist (LWHist *&h, const std::string &hName, const MonGroup &group)
 
virtual StatusCode regEfficiency (TEfficiency *e, const MonGroup &group)
 Registers a TEfficiency to be included in the output stream using logical parameters that describe the plot. More...
 
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. More...
 
virtual StatusCode regTree (TTree *t, const MonGroup &group)
 Registers a TTree to be included in the output stream using logical parameters that describe it. More...
 
virtual StatusCode deregHist (LWHist *h)
 
virtual StatusCode deregHist (TH1 *h)
 De-registers a TH1 from the THistSvc, but does NOT delete the object. More...
 
virtual StatusCode writeAndDelete (TH1 *h, const MonGroup &group)
 Write out histogram and delete it. More...
 
virtual StatusCode deregGraph (TGraph *g)
 De-registers a TGraph from the THistSvc, but does NOT delete the object. More...
 
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. More...
 
virtual StatusCode deregObject (const std::string &objName, const MonGroup &group)
 De-registers a TObject from the THistSvc, but does NOT delete the object. More...
 
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. More...
 
virtual StatusCode runStat ()
 This implementation does nothing; equivalent functionality may be provided by procHists( true, true, true ). More...
 
virtual bool preSelector ()
 
virtual float lbAverageInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average mu, i.e. More...
 
virtual float lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Instantaneous number of interactions, i.e. More...
 
virtual float lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1) More...
 
virtual float lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Instantaneous luminosity. More...
 
virtual double lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Luminosity block time (in seconds) More...
 
virtual float lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average luminosity livefraction. More...
 
virtual float livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Livefraction per bunch crossing ID. More...
 
virtual double lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average Integrated Luminosity Live Fraction. More...
 
 MMTB_DEPRECATED (newLowStatInterval)
 
 MMTB_DEPRECATED (newMedStatInterval)
 
 MMTB_DEPRECATED (newHigStatInterval)
 
 MMTB_DEPRECATED (newLowStat)
 
 MMTB_DEPRECATED (newLumiBlock)
 
 MMTB_DEPRECATED (newRun)
 
 MMTB_DEPRECATED (newEventsBlock)
 
 MMTB_DEPRECATED (endOfEventsBlock)
 
 MMTB_DEPRECATED (endOfLowStat)
 
 MMTB_DEPRECATED (endOfLumiBlock)
 
 MMTB_DEPRECATED (endOfRun)
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static std::string intervalEnumToString (Interval_t interval)
 Converts a LevelOfDetail_t to a string of the same name. More...
 
static Interval_t intervalStringToEnum (const std::string &str)
 Converts a string to the corresponding Interval_t. More...
 
static const InterfaceID & interfaceID ()
 

Protected Types

typedef std::map< std::string, OutputMetadata * > MDMap_t
 

Protected Member Functions

TH1D * book1D (const std::string &nam, const std::string &tit, int nx, double xmin, double xmax)
 Implicit version of book1D. More...
 
TH1D * book1D (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TH2D * book2D (const std::string &nam, const std::string &tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax)
 Implicit version of book2D. More...
 
TH2D * book2D (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TH1F * book1F (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TH1I * book1I (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TH1S * book1S (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TH1S * book1Sx (std::string dir, std::string nam, std::string tit, int nx, const Double_t *xlgbins, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TH1C * book1C (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TH2F * book2F (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TH2F * book2F (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, int ny, const double *ybins, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TH2I * book2I (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TH2S * book2S (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TH2C * book2C (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TProfile * bookProfile (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TProfile * bookProfile (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TProfile * bookProfile (std::string dir, std::string nam, std::string tit, int nx, const float *xbins, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TProfile2D * bookProfile2D (std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax, double zmin, double zmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TGraph * bookGraph (const std::string &dir, const std::string &nam, const std::string &tit, int N, float *X, float *Y)
 
TGraphErrors * bookGraphErrors (const std::string &dir, const std::string &nam, const std::string &tit, int N, float *X, float *Y, float *X_errors, float *Y_errors)
 
TGraphAsymmErrors * bookGraphAsymmErrors (const std::string &dir, const std::string &nam, const std::string &tit, int N, float *X, float *Y, float *X_errors1, float *X_errors2, float *Y_errors1, float *Y_errors2)
 
TMultiGraph * bookMultiGraph (const std::string &dir, const std::string &nam, const std::string &tit)
 
TH1I_LW * book1ILW (const std::string &dir, const std::string &nam, const std::string &tit, int nx, double xmin, double xmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TH2I_LW * book2ILW (const std::string &dir, const std::string &nam, const std::string &tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
TProfile_LW * bookProfileLW (const std::string &dir, const std::string &nam, const std::string &tit, int nx, double xmin, double xmax, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
 
StatusCode removeTObj (TObject *obj)
 
template<typename T >
void regHist (const std::string &subDir, T *hist, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, const std::string &trigChain="", const std::string &mergeAlgo="")
 
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 parameters that describe the histogram. More...
 
virtual StatusCode regHist (TH1 *h, const MonGroup &group)
 Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram. More...
 
virtual StatusCode regHist (LWHist *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
 Support for lightweight histograms: More...
 
virtual StatusCode regHist (LWHist *h, const MonGroup &group)
 
template<typename T >
void regGraph (const std::string &subDir, T *graph, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, const std::string &trigChain="", const std::string &mergeAlgo="")
 
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 graph. More...
 
virtual StatusCode regGraph (TGraph *g, const MonGroup &group)
 Registers a TGraph to be included in the output stream using logical parameters that describe the graph. More...
 
std::string getCellName (unsigned int ros, unsigned int channel)
 
std::string getTMDBCellName (unsigned int ros, unsigned int channel)
 
bool isDisconnected (int ros, int drawer, int ch)
 
StatusCode regManagedHistograms (std::vector< MgmtParams< TH1 > > &templateHistograms)
 
StatusCode regManagedGraphs (std::vector< MgmtParams< TGraph > > &templateGraphs)
 
StatusCode regManagedTrees (std::vector< MgmtParams< TTree > > &templateTrees)
 
StatusCode regManagedLWHistograms (std::vector< MgmtParams< LWHist > > &templateLWHistograms)
 
StatusCode regManagedEfficiencies (std::vector< MgmtParams< TEfficiency > > &templateEfficiencies)
 
StatusCode parseList (const std::string &, std::vector< std::string > &)
 
void updateTriggersForGroups (std::vector< std::string > &)
 
StatusCode registerMetadata (const std::string &streamName, const std::string &hName, const MonGroup &group)
 
StatusCode THistSvc_deReg_fixTGraph (TFile *file, TGraph *theGraph, std::string &directoryName)
 Fixes THistSvc->deReg(obj) when obj is TGraph instance. More...
 
unsigned int get_nEvents () const
 
long get_procNEventsProp () const
 
virtual bool trigChainsArePassed (std::vector< std::string > &)
 
virtual StreamNameFcn * getNewStreamNameFcn () const
 
bool newLowStatIntervalFlag () const
 Flag functions allowing clients to determine when to book new and process old histograms; values are updated by fillHists() based on counting lumiBlocks, and are correctly set when fillHistograms(), bookHistograms() and procHistograms() are called. More...
 
bool newMedStatIntervalFlag () const
 
bool newHigStatIntervalFlag () const
 
bool newLowStatFlag () const
 
bool newLumiBlockFlag () const
 
bool newRunFlag () const
 
bool newEventsBlockFlag () const
 
bool endOfEventsBlockFlag () const
 
bool endOfLowStatFlag () const
 
bool endOfLumiBlockFlag () const
 
bool endOfRunFlag () const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Protected Attributes

const TileID * m_tileID {}
 
const TileHWID * m_tileHWID {}
 
const TileTBID * m_tileTBID {}
 
const TileCablingService * m_cabling {}
 
bool m_savePng {}
 
bool m_savePs {}
 
bool m_saveSvg {}
 
std::vector< int > m_fragIDsToIgnoreDMUerrors
 
std::vector< int > m_fragIDsDemonstrators
 
std::string m_EBcellName [48]
 
std::string m_LBcellName [48]
 
std::string m_TMDB_LB_cell_names [8] = {"D0", "D1L", "D1R", "D2R", "D2L", "D3L", "D3R", ""}
 
std::string m_TMDB_EB_cell_names [4] = {"D5L", "D5R", "D6L", "D6R"}
 
int m_chMapLB [48]
 
int m_chMapEB [48]
 
int m_chMapEBsp [48]
 
std::map< Interval_t, std::vector< MgmtParams< TH1 > > > m_templateHistograms
 
std::map< Interval_t, std::vector< MgmtParams< TGraph > > > m_templateGraphs
 
std::map< Interval_t, std::vector< MgmtParams< TTree > > > m_templateTrees
 
std::map< Interval_t, std::vector< MgmtParams< LWHist > > > m_templateLWHistograms
 
std::map< Interval_t, std::vector< MgmtParams< TEfficiency > > > m_templateEfficiencies
 
std::vector< std::string > m_vTrigChainNames
 
std::vector< std::string > m_vTrigGroupNames
 
MDMap_t m_metadataMap
 
std::set< LWHist * > m_lwhists
 
AthenaMonManager * m_manager
 
std::string m_managerNameProp
 
std::string m_fileKey
 
std::string m_dataTypeStr
 
std::string m_environmentStr
 
unsigned int m_detailLevel
 
AthenaMonManager::DataType_t m_dataType
 
AthenaMonManager::Environment_t m_environment
 
StreamNameFcn * m_streamNameFcn
 
ServiceHandle< ITHistSvc > m_THistSvc
 
PublicToolHandle< Trig::ITrigDecisionTool > m_trigDecTool {this, "TrigDecisionTool",""}
 
PublicToolHandle< ITriggerTranslatorTool > m_trigTranslator {this,"TriggerTranslatorTool",""}
 
ToolHandleArray< IDQFilterTool > m_DQFilterTools {this,"FilterTools",{}}
 
long m_procNEventsProp
 
std::string m_path
 
long m_preScaleProp
 
std::string m_triggerChainProp
 
std::string m_triggerGroupProp
 
bool m_useTrigger
 
unsigned int m_lastLumiBlock
 
unsigned int m_lastRun
 
int m_lastLowStatInterval
 
int m_lastMedStatInterval
 
int m_lastHigStatInterval
 
unsigned int m_nEvents
 
unsigned int m_nEventsIgnoreTrigger
 
unsigned int m_nLumiBlocks
 
bool m_haveClearedLastEventBlock
 

Private Types

enum  RunType {
  Unknown = 0, PhysRun = 1, LasRun = 2, LedRun = 3,
  PedRun = 4, CisRun = 8, MonoRun = 9, CisRamp = 10
}
 
enum  DspPlot {
  Edsp = 0, Tdsp = 1, chi2dsp = 2, Edsp_fit = 3,
  Tdsp_fit = 4
}
 
enum  sumDspPlot { sumEdsp_fit = 0, sumTdsp_fit = 1, sumEdsp = 2, NsumDsp = 3 }
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void bookSummaryHistograms (int ros, int drawer)
 
StatusCode fillSummaryHistograms ()
 
void resetSummaryHistograms ()
 
bool checkDmuHeader (std::vector< uint32_t > *headerVec, int dmu)
 The following three functions are implemented to filter data corruption, copied from TileDigitsMonTool.h. More...
 
bool checkDmuHeaderFormat (uint32_t header)
 Function to check that the DMU header format is correct bit_31 of the DMU header must be 1 and bit_17 of the DMU header must be 0 Return true in the case of error. More...
 
bool checkDmuHeaderParity (uint32_t header)
 Function to check that the DMU header parity is correct Parity of the DMU header should be odd Return true in case of error. More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

bool m_bookAll {}
 
bool m_book2D {}
 
bool m_overlaphists {}
 
int m_runType {}
 
std::string m_contName
 
std::string m_contNameDSP
 
std::string m_contNameOF
 
double m_DownLimit {}
 
double m_UpLimit {}
 
double m_lo_IntegralLimit {}
 
double m_med_IntegralLimit {}
 
double m_hi_IntegralLimit {}
 
bool m_useratioerror {}
 
bool m_plotDsp {}
 
bool m_storeGraph {}
 
std::map< int, std::vector< double > > m_efitMap
 
std::map< int, std::vector< double > > m_tfitMap
 
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
 
double m_efitThresh {}
 
bool m_corrup [5][64][2][16] ={}
 
const uint32_t * m_cispar
 
bool m_bigain {}
 
int m_nEventsTileMon {}
 
std::unique_ptr< Data > m_data
 
TileRawChannelUnit::UNIT m_calibUnit {}
 
int m_summaryUpdateFrequency {}
 
bool m_resetAfterSummaryUpdate {}
 
bool m_doLaserSummaryVsPMT {}
 
bool m_drawHists {}
 
float m_minAmpForCorrectedTime {}
 
std::string m_infoName {}
 
const TileInfo * m_tileInfo {}
 
bool m_is12bit {}
 
SG::ReadHandleKey< TileDQstatus > m_DQstatusKey
 
int m_intCalibUnit {}
 
double m_dac2Charge [3] ={}
 
bool m_newLowStatInterval
 
bool m_newMedStatInterval
 
bool m_newHigStatInterval
 
bool m_newLowStat
 
bool m_newLumiBlock
 
bool m_newRun
 
bool m_newEventsBlock
 
bool m_endOfEventsBlock
 
bool m_endOfLowStat
 
bool m_endOfLumiBlock
 
bool m_endOfRun
 
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
 
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
 
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"}
 
bool m_bookHistogramsInitial
 
bool m_useLumi
 
float m_defaultLBDuration
 
std::set< Interval_t > m_supportedIntervalsForRebooking
 
Imp * m_d
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Class for TileCal monitoring at channel level.

Definition at line 34 of file TileRawChannelMonTool.h.

Member Typedef Documentation

◆ MDMap_t

typedef std::map<std::string,OutputMetadata*> ManagedMonitorToolBase::MDMap_t
protectedinherited

Definition at line 888 of file ManagedMonitorToolBase.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ DspPlot

enum TileRawChannelMonTool::DspPlot
private
Enumerator
Edsp 
Tdsp 
chi2dsp 
Edsp_fit 
Tdsp_fit 

Definition at line 133 of file TileRawChannelMonTool.h.

133  {
134  Edsp = 0, Tdsp = 1, chi2dsp = 2, Edsp_fit = 3, Tdsp_fit = 4
135  };

◆ Interval_t

enum ManagedMonitorToolBase::Interval_t
inherited

An enumeration describing how detailed a particular monitoring object is.

summary: used to summarize the state of the system

runstat: same as summary

shift: used to flag potential problems

expert: essential for diagnosing problems identified by shift-level objects

debug: useful for standalone debugging, but not for routine monitoring; not essential for diagnosing problems during normal running

transient: too detailed to ever be written; always summarized by the user by means of another object An enumeration describing the interval over which a particular monitoring object is filled (i.e., interval over which the method Fill(...) is called). This information may be stored with the monitoring object if an application is only able to partially fill the object (i.e., a job sees only part of a run or fill). This information may be ignored in some running Environments. The 'fill' interval corresponds to a fill of the LHC. The 'all' interval corresponds to all available data. The 'lumiBlock' and 'fill' intervals are only valid for the 'collisions' DataType_t.

Enumerator
file 
eventsBlock 
lumiBlock 
lowStat 
medStat 
higStat 
run 
fill 
all 

Definition at line 114 of file ManagedMonitorToolBase.h.

114  { file = 0, eventsBlock, lumiBlock,
115  lowStat, medStat, higStat,
116  run, fill, all };

◆ MgmtAttr_t

enum ManagedMonitorToolBase::MgmtAttr_t
inherited

An enumeration describing how the class handles the histogram.

attrib_unmanaged: histograms with this attribute will not be rebooked automatically and must be managed by the user code.

attrib_x_is_lb: indicates that the x-axis of the histogram is the luminosity block number and that the histogram should be rebooked as necessary if the current LB exceeds the range.

Enumerator
ATTRIB_MANAGED 
ATTRIB_UNMANAGED 
ATTRIB_X_VS_LB 

Definition at line 131 of file ManagedMonitorToolBase.h.

131 { ATTRIB_MANAGED = 0, ATTRIB_UNMANAGED = 1, ATTRIB_X_VS_LB = 2};

◆ RunType

enum TileRawChannelMonTool::RunType
private
Enumerator
Unknown 
PhysRun 
LasRun 
LedRun 
PedRun 
CisRun 
MonoRun 
CisRamp 

Definition at line 123 of file TileRawChannelMonTool.h.

123  {
124  Unknown = 0, PhysRun = 1, // expect monogain
125  LasRun = 2, // expect monogain
126  LedRun = 3, // expect monogain
127  PedRun = 4, // expect bigain
128  CisRun = 8, // expect bigain
129  MonoRun = 9, // expect monogain
130  CisRamp = 10 // expect monogain
131  };

◆ sumDspPlot

enum TileRawChannelMonTool::sumDspPlot
private
Enumerator
sumEdsp_fit 
sumTdsp_fit 
sumEdsp 
NsumDsp 

Definition at line 137 of file TileRawChannelMonTool.h.

137  {
138  sumEdsp_fit = 0, sumTdsp_fit = 1, sumEdsp = 2, NsumDsp = 3
139  };

◆ TileFragStatus

enum TilePaterMonTool::TileFragStatus
inherited
Enumerator
ALL_OK 
CRC_ERR 
ALL_FF 
ALL_00 
NO_FRAG 
NO_ROB 

Definition at line 65 of file TilePaterMonTool.h.

65 {ALL_OK=0, CRC_ERR=1, ALL_FF=0x10, ALL_00=0x20, NO_FRAG=0x40, NO_ROB=0x80};

Constructor & Destructor Documentation

◆ TileRawChannelMonTool()

TileRawChannelMonTool::TileRawChannelMonTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 43 of file TileRawChannelMonTool.cxx.

44  : TilePaterMonTool(type, name, parent)
45  , m_tileToolEmscale("TileCondToolEmscale")
46  , m_cispar(0)
47  , m_nEventsTileMon(0)
48  , m_calibUnit(TileRawChannelUnit::Invalid)
49  , m_drawHists(true)
50  , m_tileInfo(0)
51 
52 /*---------------------------------------------------------*/
53 {
54  declareInterface<IMonitorToolBase>(this);
55 
56  declareProperty("bookAllDrawers", m_bookAll = false);
57  declareProperty("overlaphists", m_overlaphists = false);
58  declareProperty("book2D", m_book2D = true);
59 
60  // run type 1 - phys, 2 - las, 4 - ped, 8 - cis
61  declareProperty("runType", m_runType = 0);
62  declareProperty("bigain", m_bigain = true);
63  declareProperty("TileRawChannelContainer", m_contName = "TileRawChannelOpt2"); //SG RC Container
64  declareProperty("TileRawChannelContainerDSP", m_contNameDSP = "TileRawChannelCnt"); //SG DSP RC Cell Container
65 
66  declareProperty("AmpQ_down_Limit", m_DownLimit = 0.7);
67  declareProperty("AmpQ_up_Limit", m_UpLimit = 1.3);
68  declareProperty("AmpQ_loIntegralLimit", m_lo_IntegralLimit = 0.005);
69  declareProperty("AmpQ_medIntegralLimit", m_med_IntegralLimit = 0.010);
70  declareProperty("AmpQ_hiIntegralLimit", m_hi_IntegralLimit = 0.015);
71  declareProperty("RatioErrorBar", m_useratioerror = true);
72  declareProperty("PlotDSP", m_plotDsp = false);
73  declareProperty("StoreGraph", m_storeGraph = true);
74  m_path = "/Tile/RawChannel"; //ROOT file directory
75  declareProperty("EfitThresh", m_efitThresh = 0.30); //threshold in pC for DSP check
76  declareProperty("TileCondToolEmscale", m_tileToolEmscale);
77  declareProperty("SummaryUpdateFrequency", m_summaryUpdateFrequency = 0);
78  declareProperty("ResetAfterSummaryUpdate", m_resetAfterSummaryUpdate = false);
79  declareProperty("DoLaserSummaryVsPMT", m_doLaserSummaryVsPMT = false);
80  declareProperty("MinAmpForCorrectedTime", m_minAmpForCorrectedTime = 0.5);
81  declareProperty("TileInfoName", m_infoName = "TileInfo");
82  declareProperty("TileDQstatus", m_DQstatusKey = "TileDQstatus");
83  declareProperty("CalibUnit", m_intCalibUnit = (int)TileRawChannelUnit::Invalid);
84 }

◆ ~TileRawChannelMonTool()

TileRawChannelMonTool::~TileRawChannelMonTool ( )
virtual

Definition at line 87 of file TileRawChannelMonTool.cxx.

89 {
90 }

Member Function Documentation

◆ book1C()

TH1C * TilePaterMonTool::book1C ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 186 of file TilePaterMonTool.cxx.

190 {
191 
192  TH1C* hist = new TH1C(TString(nam), TString(tit), nx, xmin, xmax);
193  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
194  return hist;
195 }

◆ book1D() [1/2]

TH1D* TilePaterMonTool::book1D ( const std::string &  nam,
const std::string &  tit,
int  nx,
double  xmin,
double  xmax 
)
inlineprotectedinherited

Implicit version of book1D.

Definition at line 69 of file TilePaterMonTool.h.

71  {
72  return book1D(m_path, nam, tit, nx, xmin, xmax);
73  }

◆ book1D() [2/2]

TH1D * TilePaterMonTool::book1D ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 164 of file TilePaterMonTool.cxx.

168 {
169 
170  TH1D* hist = new TH1D(TString(nam), TString(tit), nx, xmin, xmax);
171  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
172  return hist;
173 }

◆ book1F()

TH1F * TilePaterMonTool::book1F ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 175 of file TilePaterMonTool.cxx.

179 {
180 
181  TH1F* hist = new TH1F(TString(nam), TString(tit), nx, xmin, xmax);
182  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
183  return hist;
184 }

◆ book1I()

TH1I * TilePaterMonTool::book1I ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 219 of file TilePaterMonTool.cxx.

223 {
224 
225  TH1I* hist = new TH1I(TString(nam), TString(tit), nx, xmin, xmax);
226  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
227  return hist;
228 }

◆ book1ILW()

TH1I_LW * TilePaterMonTool::book1ILW ( const std::string &  dir,
const std::string &  nam,
const std::string &  tit,
int  nx,
double  xmin,
double  xmax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 346 of file TilePaterMonTool.cxx.

350 {
351  TH1I_LW* hist = TH1I_LW::create(TString(nam), TString(tit), nx, xmin, xmax);
352  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
353  return hist;
354 }

◆ book1S()

TH1S * TilePaterMonTool::book1S ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 197 of file TilePaterMonTool.cxx.

201 {
202 
203  TH1S* hist = new TH1S(TString(nam), TString(tit), nx, xmin, xmax);
204  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
205  return hist;
206 }

◆ book1Sx()

TH1S * TilePaterMonTool::book1Sx ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
const Double_t *  xlgbins,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 208 of file TilePaterMonTool.cxx.

212 {
213 
214  TH1S* hist = new TH1S(TString(nam), TString(tit), nx, xlgbins);
215  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
216  return hist;
217 }

◆ book2C()

TH2C * TilePaterMonTool::book2C ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
int  ny,
double  ymin,
double  ymax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 290 of file TilePaterMonTool.cxx.

295 {
296  TH2C* hist = new TH2C(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax);
297  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
298  return hist;
299 }

◆ book2D() [1/2]

TH2D* TilePaterMonTool::book2D ( const std::string &  nam,
const std::string &  tit,
int  nx,
double  xmin,
double  xmax,
int  ny,
double  ymin,
double  ymax 
)
inlineprotectedinherited

Implicit version of book2D.

Definition at line 76 of file TilePaterMonTool.h.

79  {
80  return book2D(m_path, nam, tit, nx, xmin, xmax, ny, ymin, ymax);
81  }

◆ book2D() [2/2]

TH2D * TilePaterMonTool::book2D ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
int  ny,
double  ymin,
double  ymax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 233 of file TilePaterMonTool.cxx.

238 {
239  TH2D* hist = new TH2D(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax);
240  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
241  return hist;
242 }

◆ book2F() [1/2]

TH2F * TilePaterMonTool::book2F ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
int  ny,
const double *  ybins,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 255 of file TilePaterMonTool.cxx.

260 {
261  TH2F* hist = new TH2F(TString(nam), TString(tit), nx, xmin, xmax, ny, ybins);
262  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
263  return hist;
264 }

◆ book2F() [2/2]

TH2F * TilePaterMonTool::book2F ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
int  ny,
double  ymin,
double  ymax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 244 of file TilePaterMonTool.cxx.

249 {
250  TH2F* hist = new TH2F(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax);
251  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
252  return hist;
253 }

◆ book2I()

TH2I * TilePaterMonTool::book2I ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
int  ny,
double  ymin,
double  ymax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 267 of file TilePaterMonTool.cxx.

272 {
273  TH2I* hist = new TH2I(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax);
274  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
275  return hist;
276 }

◆ book2ILW()

TH2I_LW * TilePaterMonTool::book2ILW ( const std::string &  dir,
const std::string &  nam,
const std::string &  tit,
int  nx,
double  xmin,
double  xmax,
int  ny,
double  ymin,
double  ymax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 356 of file TilePaterMonTool.cxx.

361 {
362  TH2I_LW* hist = TH2I_LW::create(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax);
363  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
364  return hist;
365 }

◆ book2S()

TH2S * TilePaterMonTool::book2S ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
int  ny,
double  ymin,
double  ymax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 279 of file TilePaterMonTool.cxx.

284 {
285  TH2S *hist = new TH2S(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax);
286  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
287  return hist;
288 }

◆ bookDsp()

void TileRawChannelMonTool::bookDsp ( int  ros,
int  drawer 
)

Definition at line 360 of file TileRawChannelMonTool.cxx.

362 {
363  const char *gain[6] = { "_lo", "_hi", "", " low gain", " high gain", "" };
364 
365 
366  std::ostringstream sStr;
367 
368  std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
369  std::string subDir = moduleName;
370  std::string histName, histTitle;
371 
372  ATH_MSG_DEBUG("in bookDSP() for module " << moduleName);
373 
374  // for bigain run book 2 histograms per channel
375  // for monogain run book just one histogram per channel
376  int mingain = (m_bigain) ? 0 : 2;
377  int maxgain = (m_bigain) ? 2 : 3;
378 
379  for (int gn = mingain; gn < maxgain; ++gn) {
380  std::string finalsubDir = "Summary";
381  sStr.str("");
382  sStr << moduleName << gain[gn] << "_summary_chi2_amp";
383  std::string finalhistName = sStr.str();
384 
385  sStr.str("");
386  sStr << moduleName << gain[3 + gn] << " Summary chi2 versus amp";
387  std::string finalhistTitle = sStr.str();
388 
389  switch (gn) {
390  case 0: // low gain
391  m_data->m_finalHistDsp2[ros][drawer][gn].push_back(book2F(finalsubDir, finalhistName, finalhistTitle, 200, -45.1, 855.1, 16, 0., 16.));
392  break;
393  case 1: // high gain
394  m_data->m_finalHistDsp2[ros][drawer][gn].push_back(book2F(finalsubDir, finalhistName, finalhistTitle, 150, -7.0, 12.0, 16, 0., 16.));
395  break;
396  default: // single gain mode
397  if (m_runType == PhysRun) {
398  m_data->m_finalHistDsp2[ros][drawer][gn & 1].push_back(book2F(subDir, finalhistName, finalhistTitle, 150, -7.005, 7.005, 16, 0., 16.));
399 
400  } else {
401  m_data->m_finalHistDsp2[ros][drawer][gn & 1].push_back(book2F(subDir, finalhistName, finalhistTitle, 200, -45.1, 855.1, 16, 0., 16.));
402  }
403  }
404 
405  }
406 
407  for (int ch = 0; ch < 48; ++ch) {
408 
409  // int pmt=m_cabling->channel2hole(ros,ch); // 1:48, negative for non-connected channels
410  // int pmt0 = ((pmt > 0)? pmt-1 : pmt+1); // 0:47, negaitve for non-connected channels
411  sStr.str("");
412  // sStr << std::setfill('0') << std::setw(2) << (abs(pmt)-1) << std::setfill(' ');
413  sStr << std::setfill('0') << std::setw(2) << ch << std::setfill(' ');
414  std::string sCh = sStr.str(); // 00:47, always positive
415 
416  for (int gn = mingain; gn < maxgain; ++gn) {
417 
418  sStr.str("");
419  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_dsp_amp";
420  histName = sStr.str();
421 
422  sStr.str("");
423  sStr << moduleName << " CH " << ch << gain[3 + gn] << " Dsp Amp";
424  histTitle = sStr.str();
425 
426  switch (gn) {
427  case 0: // low gain
428  m_data->m_histDsp1[ros][drawer][ch][gn].push_back(book1F(subDir, histName, histTitle, 491, -50.5, 1049.34));
429  break;
430  case 1: // high gain
431  m_data->m_histDsp1[ros][drawer][ch][gn].push_back(book1F(subDir, histName, histTitle, 413, -1.01, 15.51));
432  break;
433  default: // single gain mode
434  if (m_runType == PhysRun) {
435  m_data->m_histDsp1[ros][drawer][ch][gn & 1].push_back(book1F(subDir, histName, histTitle, 100, -0.55, 20.05));
436  } else {
437  m_data->m_histDsp1[ros][drawer][ch][gn & 1].push_back(book1F(subDir, histName, histTitle, 200, -0.5, 800.5));
438  }
439  }
440 
441  sStr.str("");
442  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_dsp_time";
443  histName = sStr.str();
444 
445  sStr.str("");
446  sStr << moduleName << " CH " << ch << gain[3 + gn] << " Dsp Time";
447  histTitle = sStr.str();
448 
449  m_data->m_histDsp1[ros][drawer][ch][gn & 1].push_back(book1F(subDir, histName, histTitle, 101, -100.5, 100.5));
450 
451  sStr.str("");
452  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_dsp_chi2";
453  histName = sStr.str();
454 
455  sStr.str("");
456  sStr << moduleName << " CH " << ch << gain[3 + gn] << " Dsp Chi2";
457  histTitle = sStr.str();
458 
459  m_data->m_histDsp1[ros][drawer][ch][gn & 1].push_back(book1F(subDir, histName, histTitle, 16, -0.5, 15.5));
460 
461  sStr.str("");
462  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_dsp-fit_amp_diff";
463  histName = sStr.str();
464 
465  sStr.str("");
466  sStr << moduleName << " CH " << ch << gain[3 + gn] << " Dsp-OF Amp difference";
467  histTitle = sStr.str();
468 
469  auto ix = (gn < 2) ? gn : (gn & 1);
470  m_data->m_histDsp1[ros][drawer][ch][ix].push_back(book1F(subDir, histName, histTitle, 404, -1.01, 1.01));
471 
472  sStr.str("");
473  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_dsp-fit_time_diff";
474  histName = sStr.str();
475 
476  sStr.str("");
477  sStr << moduleName << " CH " << ch << gain[3 + gn] << " Dsp-OF Time diff";
478  histTitle = sStr.str();
479 
480  m_data->m_histDsp1[ros][drawer][ch][gn & 1].push_back(book1F(subDir, histName, histTitle, 101, -2.02, 2.02));
481 
482  sStr.str("");
483  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_chi2_amp";
484  histName = sStr.str();
485 
486  sStr.str("");
487  sStr << moduleName << " CH " << ch << gain[3 + gn] << " Dsp Chi2 versus Amp";
488  histTitle = sStr.str();
489 
490  switch (gn) {
491  case 0: // low gain
492  m_data->m_histDsp2[ros][drawer][ch][gn].push_back(book2F(subDir, histName, histTitle, 200, -45.1, 855.1, 16, 0., 16.));
493  break;
494  case 1: // high gain
495  m_data->m_histDsp2[ros][drawer][ch][gn].push_back(book2F(subDir, histName, histTitle, 150, -7.0, 12.0, 16, 0., 16.));
496  break;
497  default: // single gain mode
498  if (m_runType == PhysRun) {
499  m_data->m_histDsp2[ros][drawer][ch][gn & 1].push_back(book2F(subDir, histName, histTitle, 150, -7.005, 7.005, 16, 0., 16.));
500  } else {
501  m_data->m_histDsp2[ros][drawer][ch][gn & 1].push_back(book2F(subDir, histName, histTitle, 200, -45.1, 855.1, 16, 0., 16.));
502  }
503  }
504 
505  } //end for over gains
506  } // end for over chans
507 }

◆ bookGraph()

TGraph * TilePaterMonTool::bookGraph ( const std::string &  dir,
const std::string &  nam,
const std::string &  tit,
int  N,
float *  X,
float *  Y 
)
protectedinherited

Definition at line 428 of file TilePaterMonTool.cxx.

428  {
429 
430  TGraph1 *hist = new TGraph1(N, X, Y);
431  hist->SetName(TString(nam));
432  hist->SetTitle(TString(tit));
433 
434  regGraph(subdir, hist);
435 
436  return (TGraph*) hist;
437 }

◆ bookGraphAsymmErrors()

TGraphAsymmErrors * TilePaterMonTool::bookGraphAsymmErrors ( const std::string &  dir,
const std::string &  nam,
const std::string &  tit,
int  N,
float *  X,
float *  Y,
float *  X_errors1,
float *  X_errors2,
float *  Y_errors1,
float *  Y_errors2 
)
protectedinherited

Definition at line 515 of file TilePaterMonTool.cxx.

518 {
519 
520  TGraphAsymmErrors *hist = new TGraphAsymmErrors(N, X, Y, X_errors1, X_errors2, Y_errors1, Y_errors2);
521  hist->SetName(TString(nam));
522  hist->SetTitle(TString(tit));
523 
524  regGraph(subdir, hist);
525  return (TGraphAsymmErrors*) hist;
526 }

◆ bookGraphErrors()

TGraphErrors * TilePaterMonTool::bookGraphErrors ( const std::string &  dir,
const std::string &  nam,
const std::string &  tit,
int  N,
float *  X,
float *  Y,
float *  X_errors,
float *  Y_errors 
)
protectedinherited

Definition at line 458 of file TilePaterMonTool.cxx.

458  {
459 
460  TGraphErrors *hist = new TGraphErrors(N, X, Y, X_errors, Y_errors);
461  hist->SetName(TString(nam));
462  hist->SetTitle(TString(tit));
463 
464  regGraph(subdir, hist);
465  return (TGraphErrors *) hist;
466 }

◆ bookHistograms()

StatusCode ManagedMonitorToolBase::bookHistograms ( )
virtualinherited

An inheriting class should either override this function or bookHists().

Reimplemented in SCTHitEffMonTool, SCTHitsNoiseMonTool, SCTErrMonTool, SCTTracksMonTool, SCTLorentzMonTool, photonMonTool, egammaMonToolBase, electronMonTool, MuonPhysValMonitoring::MuonPhysValMonitoringTool, LArCellMonTool, AFPHitsMonitorTool, MuonDQA::MuonEventInfoMonTool, DQTDataFlowMonTool, TileCalCellMonTool, ActsTrk::PhysValTool, PhysValSecVtx, LUCID_HitsMoniTool, ZeeTaPMonTool, forwardElectronMonTool, DQTNonCollBkg_ZDC, TRT_Electron_Monitoring_Tool, InDetGlobalTrackMonTool, CscCalibMonToolBase, JetTagMonitoring, InDetPhysValMonitoringTool, EgammaPhysValMonitoring::EgammaPhysValMonitoringTool, InDetGlobalSynchMonTool, MissingEtDQA::PhysValMET, CaloTowerVecMon, JetTagDQA::PhysValBTag, CscCalibMonToolSlope, METMonTool, DQTGlobalWZFinderTool, CSCSegmValAlg, PhysVal::PhysValExample, TopPhysVal::TopPhysValMonitoring, DataQualityFatherMonTool, CscCalibMonToolPed, ZeeValidation::ZeeValidationMonitoringTool, CaloClusterVecMon, CaloTransverseBalanceVecMon, DQTDetSynchMonTool, InDetTrackPerfMonTool, IDPerfMonWenu, IDPerfMonZee, TrackCaloClusterRecValidationTool, DQTMuonIDTrackTool, InDetGlobalPixelTool, JetMonitoringTool, TileCellNoiseMonTool, CscClusterValAlg, PhysValTau, PhysValFE, AFPTechnicalMonitorTool, ManagedMonitorToolTest, DiMuMon, InDetVertexMonitoring, CscPrdValAlg, CscRdoValAlg, HIMonitoringEventShapeTool, IDPerfMonKshort, HIMonitoringZdcTool, HIMonitoringElectronsTool, HIMonitoringPhotonsTool, PhysValCluster, and HIMonitoringMuonsTool.

Definition at line 1406 of file ManagedMonitorToolBase.cxx.

1408 {
1409 
1410  return StatusCode::SUCCESS;
1411 }

◆ bookHistogramsRecurrent()

StatusCode ManagedMonitorToolBase::bookHistogramsRecurrent ( )
virtualinherited

An inheriting class should either override this function, bookHists() or bookHistograms().

Reimplemented in SCTHitEffMonTool, SCTHitsNoiseMonTool, SCTErrMonTool, SCTTracksMonTool, SCTLorentzMonTool, AFPHitsMonitorTool, InDetGlobalBCMTool, DQTDataFlowMonTool, RpcLv1RawDataEfficiency, LVL1::CalorimeterL1CaloMon, LVL1::L1CaloCTPMon, LVL1::L1CaloLevel2Mon, LVL1::L1CaloPMTScoresMon, MdtRawDataValAlg, InDetGlobalTrackMonTool, InDetGlobalHitsMonTool, TRT_Monitoring_Tool, LVL1::L1CaloL1TopoMon, CaloTowerVecMon, DQTGlobalWZFinderTool, InDetGlobalTopBottomMonTool, DataQualityFatherMonTool, InDetGlobalNoiseOccupancyMonTool, RpcLv1RawDataValAlg, CaloClusterVecMon, RpcLv1RawDataSectorLogic, CaloTransverseBalanceVecMon, InDetGlobalBeamSpotMonTool, MdtVsTgcRawDataValAlg, MdtVsRpcRawDataValAlg, InDetGlobalErrorMonTool, ManagedMonitorToolTest, InDetGlobalPrimaryVertexMonTool, HIMonitoringEventShapeTool, AFPTechnicalMonitorTool, HIMonitoringZdcTool, HIMonitoringElectronsTool, HIMonitoringPhotonsTool, and HIMonitoringMuonsTool.

Definition at line 1394 of file ManagedMonitorToolBase.cxx.

1396 {
1397  if( m_newEventsBlock ) { }
1398  if( m_newLumiBlock ) { }
1399  if( m_newRun ) { }
1400 
1401  return StatusCode::SUCCESS;
1402 }

◆ bookHists() [1/2]

StatusCode TileRawChannelMonTool::bookHists ( )
overridevirtual

Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers.

Reimplemented from ManagedMonitorToolBase.

Definition at line 123 of file TileRawChannelMonTool.cxx.

125 {
126 
127  if (msgLvl(MSG::DEBUG)) {
128  msg(MSG::DEBUG) << "in bookHists()" << endmsg;
129  msg(MSG::DEBUG) << "Using base path " << m_path << endmsg;
130  }
131 
132  if (m_intCalibUnit>=0 && m_intCalibUnit<=3) {
133  m_calibUnit = (TileRawChannelUnit::UNIT)m_intCalibUnit;
134  }
135  if (m_calibUnit == TileRawChannelUnit::Invalid) {
136  if (m_runType == PhysRun) {
137  m_calibUnit = TileRawChannelUnit::CesiumPicoCoulombs;
138  } else {
139  m_calibUnit = TileRawChannelUnit::PicoCoulombs;
140  }
141  }
142 
143  if (m_bookAll) {
144  for (int ros = 1; ros < 5; ++ros) {
145  for (int drawer = 0; drawer < 64; ++drawer) {
146  bookHists(ros, drawer);
147 
148  if (m_plotDsp) bookDsp(ros, drawer);
149 
150  }
151  }
152  }
153 
154  /* float X_axis[48];
155  float X_errors[48];
156  for (int i = 0; i < 48; i++) {
157  X_axis[i] = i+0.5;
158  X_errors[i] = 0.;
159  }
160 
161  TGraph* test = new TGraph(48,X_axis,X_errors);
162  test->SetNameTitle("LFTESTLBC01","LFTESTLBC01");
163  m_rootsvc->regGraph("/HIST1/Tile/RawChannel/Summary/LFTESTBC01", test);
164 
165  TGraph* test2 = new TGraph(48,X_axis,X_errors);
166  test2->SetNameTitle("LFTESTLBC02","LFTESTLBC02");
167  m_rootsvc->regGraph("/HIST1/Tile/RawChannel/Summary/LFTESTBC02", test2);
168  */
169 
170  //SetBookStatus(true);
171 
172 
173  return StatusCode::SUCCESS;
174 }

◆ bookHists() [2/2]

void TileRawChannelMonTool::bookHists ( int  ros,
int  drawer 
)

Definition at line 178 of file TileRawChannelMonTool.cxx.

180 {
181  const char *gain[6] = { "_lo", "_hi", "", " low gain", " high gain", "" };
182 
183  std::ostringstream sStr;
184  std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
185  std::string subDir = moduleName;
186  std::string histName, histTitle;
187 
188  ATH_MSG_DEBUG("in bookHists() for module " << moduleName);
189 
190  // for bigain run book 2 histograms per channel
191  // for monogain run book just one histogram per channel
192  int mingain = (m_bigain) ? 0 : 2;
193  int maxgain = (m_bigain) ? 2 : 3;
194 
195  for (int ch = 0; ch < 48; ++ch) {
196 
197  // int pmt=m_cabling->channel2hole(ros,ch); // 1:48, negative for non-connected channels
198  // int pmt0 = ((pmt > 0)? pmt-1 : pmt+1); // 0:47, negaitve for non-connected channels
199  sStr.str("");
200  sStr << std::setfill('0') << std::setw(2) << ch << std::setfill(' ');
201  // sStr << std::setfill('0') << std::setw(2) << (abs(pmt)-1) << std::setfill(' ');
202  std::string sCh = sStr.str(); // 00:47, always positive
203 
204  for (int gn = mingain; gn < maxgain; ++gn) {
205 
206  if ((m_runType == CisRun) || (m_runType == CisRamp)) {
207 
208  std::string HistName[4] = { "_amp_ratio_100", "_amp_ratio_5", "_time_100", "_time_5" };
209  std::string HistTitle[4] = { " amp to charge ratio for 100 pF", " amp to charge ratio for 5 pF", " time for 100 pF", " time for 5 pF" };
210 
211  for (int type = 0; type < 4; type++) {
212  sStr.str("");
213  sStr << moduleName << "_ch_" << sCh << gain[gn] << HistName[type];
214  histName = sStr.str();
215 
216  sStr.str("");
217  sStr << moduleName << " CH " << ch << gain[3 + gn] << HistTitle[type];
218  histTitle = sStr.str();
219 
220  if (type < 2)
221  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 101, -0.01, 2.01));
222  else
223  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 101, -101.0, 101.0));
224  }
225 
226  if (m_book2D) {
227  std::string Hist2DName[4] = { "_amp_vs_q_100", "_amp_vs_q_5", "_time_vs_time_100", "_time_vs_time_5" };
228  std::string Hist2DTitle[4] = { " amp vs charge 100 pF", " amp vs charge 5 pF", " time vs time 100 pF", " time vs time 5 pF" };
229  float factor_charge = m_is12bit ? 2. : 1.;
230  float factor_adc = m_is12bit ? 4. : 1.;
231  // Below, static_cast<float> is used to avoid warnings from -Wnarrowing
232  float LowX_low2D[4] = { -4., -0.5, -0.25, -0.25 };
233  float HighX_low2D[4] = { 804., 50.5, 25.25, 25.25 };
234  float LowX_hi2D[4] = { static_cast<float>(-0.0625 * factor_charge), static_cast<float>(-0.0625 * factor_charge), -0.25, -0.25 };
235  float HighX_hi2D[4] = { static_cast<float>(12.5625 * factor_charge), static_cast<float>(12.5625 * factor_charge), 25.25, 25.25 };
236  float LowY_low2D[4] = { -25., -5.3125, -64.0, -64.0 };
237  float HighY_low2D[4] = { 1025., 60.3125, 32.0, 32.0 };
238  float LowY_hi2D[4] = { static_cast<float>(-25. * factor_adc), static_cast<float>(-25. * factor_adc), -64.0, -64.0 };
239  float HighY_hi2D[4] = { static_cast<float>(1025. * factor_adc), static_cast<float>(1025. * factor_adc), 32.0, 32.0 };
240  float LowY_hi2D_pC[4] = { static_cast<float>(-.391 * factor_adc), static_cast<float>(-.391 * factor_adc), -64.0, -64.0 };
241  float HighY_hi2D_pC[4] = { static_cast<float>(16.02 * factor_adc), static_cast<float>(16.02 * factor_adc), 32.0, 32.0 };
242 
243  for (int type = 0; type < 4; type++) {
244 
245  sStr.str("");
246  sStr << moduleName << "_ch_" << sCh << gain[gn] << Hist2DName[type];
247  histName = sStr.str();
248 
249  sStr.str("");
250  sStr << moduleName << " CH " << ch << gain[3 + gn] << Hist2DTitle[type];
251  histTitle = sStr.str();
252 
253  switch (gn) {
254  case 0: // low gain
255  m_data->m_hist2[ros][drawer][ch][gn & 1].push_back(
256  book2S(subDir, histName, histTitle, 51, LowX_low2D[type], HighX_low2D[type], 160, LowY_low2D[type], HighY_low2D[type]));
257  break;
258  case 1: // high gain
259  if (m_calibUnit == TileRawChannelUnit::CesiumPicoCoulombs || m_calibUnit == TileRawChannelUnit::PicoCoulombs)
260  m_data->m_hist2[ros][drawer][ch][gn & 1].push_back(
261  book2S(subDir, histName, histTitle, 51, LowX_hi2D[type], HighX_hi2D[type], 160, LowY_hi2D_pC[type], HighY_hi2D_pC[type]));
262  else
263  m_data->m_hist2[ros][drawer][ch][gn & 1].push_back(
264  book2S(subDir, histName, histTitle, 51, LowX_hi2D[type], HighX_hi2D[type], 160, LowY_hi2D[type], HighY_hi2D[type]));
265  break;
266  default: // single gain mode
267  if (m_calibUnit == TileRawChannelUnit::CesiumPicoCoulombs)
268  m_data->m_hist2[ros][drawer][ch][gn & 1].push_back(
269  book2S(subDir, histName, histTitle, 51, LowX_hi2D[type], HighX_hi2D[type], 160, LowY_hi2D_pC[type], HighY_hi2D_pC[type]));
270  else
271  m_data->m_hist2[ros][drawer][ch][gn & 1].push_back(
272  book2S(subDir, histName, histTitle, 51, LowX_hi2D[type], HighX_hi2D[type], 160, LowY_hi2D[type], HighY_hi2D[type]));
273  }
274  } //loop over type hist
275  } // if(book2D)
276 
277  } else { // not CIS run
278 
279  sStr.str("");
280  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_amp";
281  histName = sStr.str();
282 
283  sStr.str("");
284  sStr << moduleName << " CH " << ch << gain[3 + gn] << " amp";
285  histTitle = sStr.str();
286 
287  if (m_runType == PedRun) {
288  switch (gn) {
289  case 0: // low gain
290  m_data->m_hist1[ros][drawer][ch][gn].push_back(book1S(subDir, histName, histTitle, 101, -10.1, 10.1));
291  break;
292  case 1: // high gain
293  m_data->m_hist1[ros][drawer][ch][gn].push_back(book1S(subDir, histName, histTitle, 101, -0.404, 0.404));
294  break;
295  default: // single gain mode
296  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 101, -10.1, 10.1));
297  }
298  } else {
299  switch (gn) {
300  case 0: // low gain
301  if (m_overlaphists) {
302  const Int_t nlg1 = 49;
303  const Int_t nlg2 = 500;
304  const Int_t nlg3 = 1027;
305  Double_t xlgbin[nlg1 + nlg2 + nlg3 + 1];
306  for(Int_t i = 0; i <= nlg1; ++i)
307  xlgbin[i] = -50.5+1.0*i;
308  for(Int_t i = 1; i <= nlg2; ++i)
309  xlgbin[i + nlg1] = -1.5 + 0.05 * i;
310  for(Int_t i = 1; i <= nlg3; ++i)
311  xlgbin[i + nlg1 + nlg2] = 23.5 + 1.0 * i;
312  m_data->m_hist1[ros][drawer][ch][gn].push_back(book1Sx(subDir, histName, histTitle, nlg1 + nlg2 + nlg3, xlgbin));
313  } else {
314  m_data->m_hist1[ros][drawer][ch][gn].push_back(book1S(subDir, histName, histTitle, 1101, -50.5, 1050.5));
315  }
316  break;
317  case 1: // high gain
318  if (m_overlaphists)
319  m_data->m_hist1[ros][drawer][ch][gn].push_back(book1S(subDir, histName, histTitle, 500, -1.5, 23.5));
320  else
321  m_data->m_hist1[ros][drawer][ch][gn].push_back(book1S(subDir, histName, histTitle, 826, -1.01, 15.51));
322  break;
323  default: // single gain mode
324  if (m_runType == PhysRun) {
325  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 206, -0.55, 20.05));
326  } else {
327  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 801, -0.5, 800.5));
328  }
329  }
330  }
331 
332  sStr.str("");
333  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_time";
334  histName = sStr.str();
335 
336  sStr.str("");
337  sStr << moduleName << " CH " << ch << gain[3 + gn] << " time";
338  histTitle = sStr.str();
339 
340  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 201, -100.5, 100.5));
341  //Lukas
342  sStr.str("");
343  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_time_corr";
344  histName = sStr.str();
345 
346  sStr.str("");
347  sStr << moduleName << " CH " << ch << gain[3 + gn] << " time_corr";
348  histTitle = sStr.str();
349 
350  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 201, -100.5, 100.5));
351  //Lukas
352  }
353  }
354  }
355 
356  if (m_summaryUpdateFrequency > 0) bookSummaryHistograms(ros, drawer);
357 }

◆ bookMultiGraph()

TMultiGraph * TilePaterMonTool::bookMultiGraph ( const std::string &  dir,
const std::string &  nam,
const std::string &  tit 
)
protectedinherited

Definition at line 547 of file TilePaterMonTool.cxx.

547  {
548 
549  TMultiGraph1* hist = new TMultiGraph1();
550  hist->SetName(TString(nam));
551  hist->SetTitle(TString(tit));
552 
553  regGraph(subdir, (TGraph*) hist);
554  return (TMultiGraph*) hist;
555 }

◆ bookProfile() [1/3]

TProfile * TilePaterMonTool::bookProfile ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
const float *  xbins,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 322 of file TilePaterMonTool.cxx.

326 {
327  TProfile* hist = new TProfile(TString(nam), TString(tit), nx, xbins);
328  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
329  return hist;
330 }

◆ bookProfile() [2/3]

TProfile * TilePaterMonTool::bookProfile ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
double  ymin,
double  ymax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 311 of file TilePaterMonTool.cxx.

316 {
317  TProfile* hist = new TProfile(TString(nam), TString(tit), nx, xmin, xmax, ymin, ymax);
318  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
319  return hist;
320 }

◆ bookProfile() [3/3]

TProfile * TilePaterMonTool::bookProfile ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 301 of file TilePaterMonTool.cxx.

305 {
306  TProfile* hist = new TProfile(TString(nam), TString(tit), nx, xmin, xmax);
307  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
308  return hist;
309 }

◆ bookProfile2D()

TProfile2D * TilePaterMonTool::bookProfile2D ( std::string  dir,
std::string  nam,
std::string  tit,
int  nx,
double  xmin,
double  xmax,
int  ny,
double  ymin,
double  ymax,
double  zmin,
double  zmax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 332 of file TilePaterMonTool.cxx.

338 {
339 
340  TProfile2D* hist = new TProfile2D(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax, zmin, zmax);
341  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
342  return hist;
343 }

◆ bookProfileLW()

TProfile_LW * TilePaterMonTool::bookProfileLW ( const std::string &  dir,
const std::string &  nam,
const std::string &  tit,
int  nx,
double  xmin,
double  xmax,
double  ymin,
double  ymax,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
std::string  trigChain = "",
std::string  mergeAlgo = "" 
)
protectedinherited

Definition at line 368 of file TilePaterMonTool.cxx.

373 {
374  TProfile_LW* hist = TProfile_LW::create(TString(nam), TString(tit), nx, xmin, xmax, ymin, ymax);
375  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
376  return hist;
377 }

◆ bookSummaryHistograms()

void TileRawChannelMonTool::bookSummaryHistograms ( int  ros,
int  drawer 
)
private

Definition at line 901 of file TileRawChannelMonTool.cxx.

903 {
904 
905 
906  const char *gain[6] = { "_lo", "_hi", "", " low gain", " high gain", "" };
907 
908  // for bigain run book 2 histograms per channel
909  // for monogain run book just one histogram per channel
910  int mingain = (m_bigain) ? 0 : 2;
911  int maxgain = (m_bigain) ? 2 : 3;
912 
913  std::ostringstream sStr;
914 
915  if ((m_runType == CisRun) || (m_runType == CisRamp)) {
916 
917  const char *HistName[6] = { "_tslope", "_toffset", "_qratio", " Time slope", " Time offset", " Amp/Q ratio" };
918  const char *CapName[4] = { "_100", "_5", " 100 pF", " 5 pF" };
919 
920 
921  std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
922  std::string subDir = "Summary";
923  std::string histName, histTitle;
924 
925  for (int gn = mingain; gn < maxgain; ++gn) {
926  int adc = gn & 1;
927  for (int cap = 0; cap < 2; ++cap) {
928  for (int type = 0; type < 3; ++type) {
929 
930  sStr.str("");
931  sStr << moduleName << gain[gn] << HistName[type] << CapName[cap];
932  histName = sStr.str();
933  sStr.str("");
934  sStr << moduleName << gain[3 + gn] << HistName[3 + type] << CapName[2 + cap];
935  histTitle = sStr.str();
936  m_data->m_finalHist1[ros][drawer][adc][cap].push_back(book1F(subDir, histName, histTitle, 48, 0, 48));
937  }
938  } //end of loop over capacitors
939  } //end of loop over gn
940 
941  } else { // not CisRun
942  const char *HistName[10] = { "_amp", "_rms", "_sigma", "_time", "_time_corr", " Amplitude", " RMS of amplitude", " Sigma amp from Gaussian fit",
943  " Average time and RMS", " Average time corr. and RMS" };
944  //Lukas
945 
946  std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
947  std::string subDir = "Summary";
948  std::string histName, histTitle;
949 
950  for (int gn = mingain; gn < maxgain; ++gn) {
951 
952  int adc = gn & 1;
953 
954  //for (int type = 0; type < 4; ++type) {
955  for (int type = 0; type < 5; ++type) { //Lukas
956 
957  sStr.str("");
958  sStr << moduleName << gain[gn] << HistName[type];
959  histName = sStr.str();
960  sStr.str("");
961  //sStr << moduleName << gain[3+gn] << HistName[4+type];
962  sStr << moduleName << gain[3 + gn] << HistName[5 + type]; //Lukas
963  histTitle = sStr.str();
964  m_data->m_finalHist1[ros][drawer][adc][0].push_back(book1F(subDir, histName, histTitle, 48, 0.0, 48.0));
965 
966  std::string hTitle(histTitle);
967 
968  if (m_doLaserSummaryVsPMT && m_runType == LasRun) {
969 
970  hTitle += " (Even PMTs)";
971  m_data->m_summaryPmts[ros][drawer][adc][0].push_back(book1F(subDir + "/pmt", histName + "_pmt_even", hTitle, 49, -0.5, 48.5));
972  m_data->m_summaryPmts[ros][drawer][adc][0].back()->SetMarkerStyle(22);
973  m_data->m_summaryPmts[ros][drawer][adc][0].back()->SetMarkerColor(2);
974  m_data->m_summaryPmts[ros][drawer][adc][0].back()->SetMarkerSize(0.75);
975 
976  hTitle = histTitle;
977  hTitle += " (Odd PMTs)";
978  m_data->m_summaryPmts[ros][drawer][adc][1].push_back(book1F(subDir + "/pmt", histName + "_pmt_odd", hTitle, 49, -0.5, 48.5));
979  m_data->m_summaryPmts[ros][drawer][adc][1].back()->SetMarkerStyle(23);
980  m_data->m_summaryPmts[ros][drawer][adc][1].back()->SetMarkerColor(4);
981  m_data->m_summaryPmts[ros][drawer][adc][1].back()->SetMarkerSize(0.75);
982 
983  if (ros < 3 && m_data->m_summaryPmts[0][drawer][adc][0].size() < (unsigned int)(type + 1)) {
984 
985  histName.replace(histName.begin(), histName.begin() + 3, "LB");
986  histTitle.replace(histTitle.begin(), histTitle.begin() + 3, "LB");
987  hTitle = histTitle;
988 
989  hTitle += " (LBA even PMTs + LBC odd PMTs: negative)";
990  m_data->m_summaryPmts[0][drawer][adc][0].push_back(book1F(subDir + "/pmt", histName + "_pmt_LBA-even_LBC-odd", hTitle, 97, -48.5, 48.5));
991  m_data->m_summaryPmts[0][drawer][adc][0].back()->SetMarkerStyle(22);
992  m_data->m_summaryPmts[0][drawer][adc][0].back()->SetMarkerColor(2);
993  m_data->m_summaryPmts[0][drawer][adc][0].back()->SetMarkerSize(0.75);
994 
995  hTitle = histTitle;
996  hTitle += " (LBA odd PMTs + LBC even PMTs: negative)";
997  m_data->m_summaryPmts[0][drawer][adc][1].push_back(book1F(subDir + "/pmt", histName + "_pmt_LBA-odd_LBC-even", hTitle, 97, -48.5, 48.5));
998  m_data->m_summaryPmts[0][drawer][adc][1].back()->SetMarkerStyle(23);
999  m_data->m_summaryPmts[0][drawer][adc][1].back()->SetMarkerColor(4);
1000  m_data->m_summaryPmts[0][drawer][adc][1].back()->SetMarkerSize(0.75);
1001  }
1002  }
1003  }
1004 
1005  } //end of loop over gn
1006  }
1007 
1008 }

◆ checkDmuHeader()

bool TileRawChannelMonTool::checkDmuHeader ( std::vector< uint32_t > *  headerVec,
int  dmu 
)
private

The following three functions are implemented to filter data corruption, copied from TileDigitsMonTool.h.

Function to check for data corruption. Modified from TileDigitsMonTool implementation

Definition at line 1942 of file TileRawChannelMonTool.cxx.

1944 {
1945  bool err = false;
1946 
1947  if (checkDmuHeaderFormat((*headerVec)[dmu])) {
1948  err = true;
1949 
1950  }
1951  if (checkDmuHeaderParity((*headerVec)[dmu])) {
1952  err = true;
1953 
1954  }
1955  if (((*headerVec)[dmu] >> 25) & 0x1) {
1956  //Memory Parity Error
1957  err = true;
1958 
1959  }
1960  if (((*headerVec)[dmu] >> 24) & 0x1) {
1961  //Single Strobe Error
1962  err = true;
1963 
1964  }
1965  if (((*headerVec)[dmu] >> 23) & 0x1) {
1966  //Double Strobe Error
1967  err = true;
1968 
1969  }
1970 
1971  return err;
1972 }

◆ checkDmuHeaderFormat()

bool TileRawChannelMonTool::checkDmuHeaderFormat ( uint32_t  header)
inlineprivate

Function to check that the DMU header format is correct bit_31 of the DMU header must be 1 and bit_17 of the DMU header must be 0 Return true in the case of error.

Definition at line 103 of file TileRawChannelMonTool.h.

103  {
104  if (((header >> 31 & 0x1) == 1) && ((header >> 17 & 0x1) == 0))
105  return false; //no error
106  else
107  return true; //error
108  };

◆ checkDmuHeaderParity()

bool TileRawChannelMonTool::checkDmuHeaderParity ( uint32_t  header)
inlineprivate

Function to check that the DMU header parity is correct Parity of the DMU header should be odd Return true in case of error.

Definition at line 113 of file TileRawChannelMonTool.h.

113  {
114  uint32_t parity(0);
115  for (int i = 0; i < 32; ++i)
116  parity += ((header >> i) & 0x1);
117 
118  if ((parity % 2) == 1) return false; //no error
119  else return true; //error
120 
121  };

◆ checkHists()

StatusCode TileRawChannelMonTool::checkHists ( bool  calledFromFinalize)
overridevirtual

This implementation does nothing; equivalent functionality may be provided by procHists(...) with appropriate arguments.

Reimplemented from ManagedMonitorToolBase.

Definition at line 1419 of file TileRawChannelMonTool.cxx.

1421 {
1422 
1423  ATH_MSG_INFO("in checkHists()");
1424 
1425  return StatusCode::SUCCESS;
1426 }

◆ convertLWHists()

StatusCode ManagedMonitorToolBase::convertLWHists ( )
virtualinherited

Deal with the LW histograms.

Implements IMonitorToolBase.

Definition at line 1377 of file ManagedMonitorToolBase.cxx.

1379 {
1380  // note that managed histograms will be converted by regMonitoredLWHistograms
1381  // hence they are not in m_lwhists
1382  if (m_manager) {
1383  std::set<LWHist*>::iterator it(m_lwhists.begin()),itE(m_lwhists.end());
1384  for (;it!=itE;++it)
1385  m_manager->writeAndDeleteLWHist( *it );
1386  m_lwhists.clear();
1387  }
1388  return StatusCode::SUCCESS;
1389 
1390 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ deregGraph()

StatusCode ManagedMonitorToolBase::deregGraph ( TGraph *  g)
virtualinherited

De-registers a TGraph from the THistSvc, but does NOT delete the object.

Definition at line 1843 of file ManagedMonitorToolBase.cxx.

1845 {
1846  return m_THistSvc->deReg( g );
1847 }

◆ deregHist() [1/2]

StatusCode ManagedMonitorToolBase::deregHist ( LWHist *  h)
virtualinherited

Definition at line 1826 of file ManagedMonitorToolBase.cxx.

1827 {
1828  std::set<LWHist*>::iterator it = m_lwhists.find(h);
1829  if (it==m_lwhists.end())
1830  return StatusCode::FAILURE;
1831  LWHistAthMonWrapper:: removeCustomData(h);
1832  m_lwhists.erase(it);
1833  if (h->usingROOTBackend()) {
1834  h->setOwnsROOTHisto(true);
1835  return m_THistSvc->deReg( h->getROOTHistBase() );
1836  }
1837 
1838  return StatusCode::SUCCESS;
1839 }

◆ deregHist() [2/2]

StatusCode ManagedMonitorToolBase::deregHist ( TH1 *  h)
virtualinherited

De-registers a TH1 from the THistSvc, but does NOT delete the object.

Definition at line 1819 of file ManagedMonitorToolBase.cxx.

1821 {
1822  return m_THistSvc->deReg( h );
1823 }

◆ deregObject() [1/2]

StatusCode ManagedMonitorToolBase::deregObject ( const std::string &  objName,
const MonGroup &  group 
)
virtualinherited

De-registers a TObject from the THistSvc, but does NOT delete the object.

(NB: LightWeight histograms are not even registered until readout).

Definition at line 1861 of file ManagedMonitorToolBase.cxx.

1863 {
1864  std::string streamName = streamNameFunction()->getStreamName( this, group, objName );
1865  std::set<LWHist*>::iterator it(m_lwhists.begin()),itE(m_lwhists.end());
1866  for (;it!=itE;++it) {
1867  LWHist * hlw = *it;
1868  if (LWHistAthMonWrapper::key(hlw)==objName) {
1869  m_lwhists.erase(it);
1870  if (hlw->usingROOTBackend()) {
1871  hlw->setOwnsROOTHisto(true);
1872  return m_THistSvc->deReg( hlw->getROOTHistBase() );
1873  }
1874  return StatusCode::SUCCESS;
1875  }
1876  }
1877  return m_THistSvc->deReg( streamName );
1878 }

◆ deregObject() [2/2]

StatusCode ManagedMonitorToolBase::deregObject ( const std::string &  objName,
const std::string &  system,
Interval_t  interval 
)
virtualinherited

De-registers a TObject from the THistSvc, but does NOT delete the object.

(NB: LightWeight histograms are not even registered until readout).

Definition at line 1851 of file ManagedMonitorToolBase.cxx.

1854 {
1855  MonGroup group( this, system, interval );
1856  return deregObject( objName, group );
1857 }

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ drawDsp()

void TileRawChannelMonTool::drawDsp ( int  ros,
int  drawer,
const std::string &  moduleName 
)

Definition at line 1709 of file TileRawChannelMonTool.cxx.

1711 {
1712  MsgStream log(msgSvc(), name());
1713  int maxgain = (m_bigain) ? 2 : 1;
1714  double ms = (m_bigain) ? 0.75 : 1.0; // marker size
1715  bool do_plots = m_savePng || m_savePs || m_saveSvg;
1716 
1717  TCanvas * Can = NULL; // for -Wmaybe-uninitialized
1718  if (do_plots) {
1719  Can = new TCanvas("dsp_amp", "dsp_amp", 402 * maxgain, 588);
1720  Can->Divide(maxgain, 3);
1721  gStyle->SetOptStat(0);
1722  gStyle->SetTitleFontSize(0.1);
1723  }
1724 
1725  TLine line(0., 0., 48., 0.); //Draw a green line to guide the sight
1726  line.SetLineColor(3);
1727 
1728  double maxy[6] = { 0.05, 0.05, 0.5, 0.5, 10.0, 10.0 };
1729  double miny[6] = { -0.05, -0.05, -0.5, -0.5, -0.05, -0.05 };
1730  double norm[2] = { 1., 1 };
1731  for (int adc = 0; adc < maxgain; ++adc) {
1732 
1733  double maxEdsp = m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->GetMaximum();
1734  double minEdsp = m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->GetMinimum();
1735  double maxTdsp = m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->GetMaximum();
1736  double minTdsp = m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->GetMinimum();
1737  double maxchidsp = m_data->m_finalHistDsp2[ros][drawer][adc][0]->GetMaximum();
1738  double minchidsp = m_data->m_finalHistDsp2[ros][drawer][adc][0]->GetMinimum();
1739 
1740  TVirtualPad * pad;
1741  if (do_plots) {
1742  pad = Can->cd(adc + 1);
1743  pad->SetTopMargin(0.15);
1744  pad->SetGridx();
1745  }
1746 
1747  if (maxEdsp < 0.9 * maxy[adc]) m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetMaximum(maxy[adc]);
1748  if (minEdsp > miny[adc] + 0.1 * TMath::Abs(miny[adc])) m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetMinimum(miny[adc]);
1749 
1750  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetMarkerStyle(21);
1751  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetMarkerSize(ms);
1752  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetLabelSize(0.08, "X");
1753  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetLabelSize(0.08, "Y");
1754  if (do_plots) m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->Draw("");
1755 
1756  //Now we add the 1d histogram on the y-axis
1757  if (m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->GetMaximum() > 0.1) { //normalize the scale to get into the frame
1758  norm[sumEdsp_fit] = 47. / m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->GetMaximum();
1759  }
1760  m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->Scale(norm[sumEdsp_fit]);
1761  //hbardsp1[ros][drawer][adc][sumEdsp_fit]->SetFillStyle(3350);
1762  m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->SetFillColor(38);
1763  if (do_plots) {
1764  m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->Draw("hbar,same");
1765 
1766  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->Draw("E0,same");
1767 
1768  line.Draw();
1769 
1770  pad = Can->cd(maxgain + adc + 1);
1771  pad->SetTopMargin(0.15);
1772  pad->SetGridx();
1773  }
1774 
1775  if (maxTdsp < 0.9 * maxy[2 + adc]) m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetMaximum(maxy[2 + adc]);
1776  if (minTdsp > miny[2 + adc] + 0.1 * TMath::Abs(miny[2 + adc])) m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetMinimum(miny[2 + adc]);
1777 
1778  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetMarkerStyle(21);
1779  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetMarkerSize(ms);
1780  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetLabelSize(0.08, "X");
1781  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetLabelSize(0.08, "Y");
1782  if (do_plots) m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->Draw("");
1783 
1784  if (m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->GetMaximum() > 0.1) { //normalize the scale to get into the frame
1785  norm[sumTdsp_fit] = 47. / m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->GetMaximum();
1786  }
1787  m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->Scale(norm[sumTdsp_fit]);
1788  // hbardsp1[ros][drawer][adc][sumTdsp_fit]->SetFillStyle(3350);
1789  m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->SetFillColor(38);
1790  if (do_plots) {
1791  m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->Draw("hbar,same");
1792 
1793  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->Draw("E0,same");
1794 
1795  line.Draw();
1796 
1797  pad = Can->cd(2 * maxgain + adc + 1);
1798  pad->SetTopMargin(0.15);
1799  pad->SetGridx();
1800  pad->SetGridy();
1801  }
1802 
1803  if (maxchidsp < 0.9 * maxy[4 + adc]) m_data->m_finalHistDsp2[ros][drawer][adc][0]->SetMaximum(maxy[4 + adc]);
1804  if (minchidsp > miny[4 + adc] + 0.1 * TMath::Abs(miny[4 + adc])) m_data->m_finalHistDsp2[ros][drawer][adc][0]->SetMinimum(miny[4 + adc]);
1805 
1806  m_data->m_finalHistDsp2[ros][drawer][adc][0]->SetLabelSize(0.08, "X");
1807  m_data->m_finalHistDsp2[ros][drawer][adc][0]->SetLabelSize(0.08, "Y");
1808  if (do_plots) {
1809  gStyle->SetPalette(1);
1810  m_data->m_finalHistDsp2[ros][drawer][adc][0]->Draw("zcol");
1811  }
1812 
1813  } //end of loop over gain
1814 
1815  if (m_savePng) {
1816  Can->Print(TString(moduleName + "_dsp_amp.png"), "png");
1817  }
1818  if (m_savePs) {
1819  Can->Print(TString(moduleName + "_dsp_amp.ps"), "ps");
1820  }
1821  if (m_saveSvg) {
1822  Can->Print(TString(moduleName + "_dsp_amp.svg"), "svg");
1823  }
1824  if (do_plots) delete Can;
1825 
1826  for (int adc = 0; adc < maxgain; ++adc) {
1827  m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->Scale(1 / norm[sumEdsp_fit]); //back to normal
1828  m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->Scale(1 / norm[sumTdsp_fit]); //back to normal
1829  }
1830 }

◆ drawHists()

void TileRawChannelMonTool::drawHists ( int  ros,
int  drawer,
const std::string &  moduleName 
)

Definition at line 1429 of file TileRawChannelMonTool.cxx.

1431 {
1432 
1433  ATH_MSG_DEBUG("in drawHists()");
1434 
1435  int maxgain = (m_bigain) ? 2 : 1;
1436  double ms = (m_bigain) ? 0.75 : 1.0; // marker size
1437 
1438  bool do_plots = m_savePng || m_savePs || m_saveSvg;
1439 
1440  if ((m_runType == CisRun) || (m_runType == CisRamp)) {
1441 
1442  float X_axis[48];
1443  float X_errors[48];
1444  for (int i = 0; i < 48; i++) {
1445  X_axis[i] = i + 0.5;
1446  X_errors[i] = 0.;
1447  }
1448 
1449  const char *gain[6] = { "_lo", "_hi", "", " low gain", " high gain", "" };
1450  const char *CapName[4] = { "_100", "_5", " 100 pF", " 5 pF" };
1451  if (maxgain == 1) gain[0] = gain[1] = gain[2] = gain[3] = gain[4] = gain[5];
1452 
1453  /* TGraph* test = new TGraph(48,X_errors,X_errors);
1454  test->SetName(("/HIST1/Tile/RawChannel/Summary/LFTEST"+moduleName).c_str());
1455  m_rootsvc->regGraph("/HIST1/Tile/RawChannel/Summary/LFTEST"+moduleName, test);
1456  */
1457 
1458  TCanvas * Can = NULL;
1459  if (do_plots) {
1460  Can = new TCanvas("amp_ratio", "amp_ratio", 402 * maxgain, 588);
1461  Can->Divide(maxgain, 2);
1462  gStyle->SetOptStat(0);
1463  gStyle->SetTitleFontSize(0.1);
1464  }
1465 
1466  TLine line(0., 1., 48., 1.); //Draw a green line to guide the sight
1467  line.SetLineColor(3);
1468 
1469  std::string subDir = "Summary";
1470  std::vector<TGraphAsymmErrors*> grapherrVec;
1471 
1472  for (int adc = 0; adc < maxgain; ++adc) {
1473  for (int cap = 0; cap < 2; ++cap) {
1474 
1475  std::ostringstream sStr;
1476  sStr << moduleName << gain[adc] << "_tails" << CapName[cap];
1477  std::string graphName = sStr.str();
1478  sStr.str("");
1479  sStr << moduleName << gain[adc + 3] << " Mean Amp/Q ratio and up/down tails " << CapName[2 + cap];
1480  std::string graphTitle = sStr.str();
1481 
1482  TVirtualPad * pad;
1483  if (do_plots) {
1484  pad = Can->cd(cap * maxgain + adc + 1);
1485  pad->SetTopMargin(0.15);
1486  pad->SetGridx();
1487  }
1488 
1489  TGraphAsymmErrors * final_Egraph = bookGraphAsymmErrors(subDir, graphName, graphTitle, 48, X_axis, m_data->m_rangeQ[adc][cap][0], X_errors, X_errors,
1490  m_data->m_rangeQ[adc][cap][1], m_data->m_rangeQ[adc][cap][2]);
1491  grapherrVec.push_back(final_Egraph);
1492 
1493  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetStats(kFALSE);
1494  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetMarkerStyle(21);
1495  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetMarkerSize(ms);
1496  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetLabelSize(0.06, "X");
1497  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetLabelSize(0.06, "Y");
1498  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetMaximum(2.2);
1499  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetMinimum(-0.2);
1500  if (do_plots) m_data->m_finalHist1[ros][drawer][adc][cap][2]->Draw("P0");
1501 
1502  final_Egraph->SetMarkerStyle(21);
1503  final_Egraph->SetMarkerSize(ms);
1504  final_Egraph->SetMaximum(2.2);
1505  final_Egraph->SetMinimum(-0.2);
1506  final_Egraph->GetXaxis()->SetRangeUser(0, 48);
1507  if (do_plots) {
1508  final_Egraph->Draw("P0");
1509  line.Draw();
1510  }
1511 
1512  }
1513  }
1514 
1515  if (m_savePng) {
1516  Can->Print(TString(moduleName + "_amp_ratio.png"), "png");
1517  }
1518  if (m_savePs) {
1519  Can->Print(TString(moduleName + "_amp_ratio.ps"), "ps");
1520  }
1521  if (m_saveSvg) {
1522  Can->Print(TString(moduleName + "_amp_ratio.svg"), "svg");
1523  }
1524  if (do_plots) delete Can;
1525 
1526 // we have to remove TGraphAsymmErrors in 13.0.10, because THistSvc doesn't handle them well
1527  if (!m_storeGraph) {
1528  std::vector<TGraphAsymmErrors*>::const_iterator it = grapherrVec.begin();
1529  std::vector<TGraphAsymmErrors *>::const_iterator itend = grapherrVec.end();
1530  for (; it != itend; ++it) {
1531  if ((removeTObj(*it)).isFailure()) ATH_MSG_WARNING("Problems removing TObj");
1532  }
1533  }
1534 
1535  if (do_plots) {
1536  Can = new TCanvas("fit_time", "fit_time", 402 * maxgain, 588);
1537  Can->Divide(maxgain, 4);
1538  gStyle->SetOptStat(0);
1539  gStyle->SetTitleFontSize(0.1);
1540  }
1541 
1542  double maxy[2] = { 1.4, 15.0 };
1543  double miny[2] = { -0.1, -15.0 };
1544 
1545  for (int adc = 0; adc < maxgain; ++adc) {
1546  for (int cap = 0; cap < 2; ++cap) {
1547  for (int type = 0; type < 2; ++type) {
1548 
1549  TVirtualPad * pad;
1550  if (do_plots) {
1551  pad = Can->cd((type + cap * 2) * maxgain + adc + 1);
1552  pad->SetTopMargin(0.15);
1553  pad->SetGridx();
1554  }
1555 
1556  if (m_data->m_finalHist1[ros][drawer][adc][cap][type]->GetMaximum() < 0.9 * maxy[type])
1557  m_data->m_finalHist1[ros][drawer][adc][cap][type]->SetMaximum(maxy[type]);
1558  if (m_data->m_finalHist1[ros][drawer][adc][cap][type]->GetMinimum() > (miny[type] + 0.1 * TMath::Abs(miny[type])))
1559  m_data->m_finalHist1[ros][drawer][adc][cap][type]->SetMinimum(miny[type]);
1560 
1561  m_data->m_finalHist1[ros][drawer][adc][cap][type]->SetMarkerStyle(21);
1562  m_data->m_finalHist1[ros][drawer][adc][cap][type]->SetMarkerSize(ms);
1563  m_data->m_finalHist1[ros][drawer][adc][cap][type]->SetLabelSize(0.10, "X");
1564  m_data->m_finalHist1[ros][drawer][adc][cap][type]->SetLabelSize(0.10, "Y");
1565  if (do_plots) {
1566  m_data->m_finalHist1[ros][drawer][adc][cap][type]->Draw("P0");
1567 
1568  line.SetLineColor(3);
1569  line.Draw();
1570  }
1571  }
1572  }
1573  }
1574 
1575  if (m_savePng) {
1576  Can->Print(TString(moduleName + "_fit_time.png"), "png");
1577  }
1578  if (m_savePs) {
1579  Can->Print(TString(moduleName + "_fit_time.ps"), "ps");
1580  }
1581  if (m_saveSvg) {
1582  Can->Print(TString(moduleName + "_fit_time.svg"), "svg");
1583  }
1584  if (do_plots) delete Can;
1585 
1586  } else {
1587  if ((m_runType == LasRun) || (m_runType == LedRun)) { //same stuff but with Laser fancy colors
1588  LaserFancyPlotting(ros, drawer, maxgain, moduleName);
1589  } else {
1590 
1591  TCanvas * Can = NULL;
1592  if (do_plots) {
1593  Can = new TCanvas("fit_amp", "fit_amp", 402 * maxgain, 588);
1594  Can->Divide(maxgain, 3);
1595  gStyle->SetOptStat(0);
1596  gStyle->SetTitleFontSize(0.1);
1597  }
1598 
1599  double maxy[6] = { 1.0, 0.05, 1.0, 0.05, 25.0, 25.0 };
1600  double miny[6] = { -1.0, -0.05, 0.0, 0.0, -25.0, -25.0 };
1601 
1602  for (int adc = 0; adc < maxgain; ++adc) {
1603 
1604  double max0 = m_data->m_finalHist1[ros][drawer][adc][0][0]->GetMaximum();
1605  double max1 = m_data->m_finalHist1[ros][drawer][adc][0][1]->GetMaximum();
1606  double max2 = m_data->m_finalHist1[ros][drawer][adc][0][2]->GetMaximum();
1607  double max3 = m_data->m_finalHist1[ros][drawer][adc][0][3]->GetMaximum();
1608  double min0 = m_data->m_finalHist1[ros][drawer][adc][0][0]->GetMinimum();
1609  double min1 = m_data->m_finalHist1[ros][drawer][adc][0][1]->GetMinimum();
1610  double min2 = m_data->m_finalHist1[ros][drawer][adc][0][2]->GetMinimum();
1611  double min3 = m_data->m_finalHist1[ros][drawer][adc][0][3]->GetMinimum();
1612 
1613  TVirtualPad * pad;
1614  if (do_plots) {
1615  pad = Can->cd(adc + 1);
1616  pad->SetTopMargin(0.15);
1617  pad->SetGridx();
1618  }
1619 
1620  if (max0 < 0.9 * maxy[adc]) m_data->m_finalHist1[ros][drawer][adc][0][0]->SetMaximum(maxy[adc]);
1621  if (min0 > (miny[adc] + 0.1 * TMath::Abs(miny[adc]))) m_data->m_finalHist1[ros][drawer][adc][0][0]->SetMinimum(miny[adc]);
1622 
1623  m_data->m_finalHist1[ros][drawer][adc][0][0]->SetMarkerStyle(21);
1624  m_data->m_finalHist1[ros][drawer][adc][0][0]->SetMarkerSize(ms);
1625  m_data->m_finalHist1[ros][drawer][adc][0][0]->SetLabelSize(0.08, "X");
1626  m_data->m_finalHist1[ros][drawer][adc][0][0]->SetLabelSize(0.08, "Y");
1627  if (do_plots) {
1628  m_data->m_finalHist1[ros][drawer][adc][0][0]->Draw("E0");
1629  }
1630 
1631  if (do_plots) {
1632  pad = Can->cd(maxgain + adc + 1);
1633  pad->SetTopMargin(0.15);
1634  pad->SetGridx();
1635  }
1636 
1637  // if (max2 > 5 * max1) max2 = 2 * max1; // don't put crazy fit results on plot
1638  if (max1 < maxy[2 + adc]) {
1639  if (max2 < maxy[2 + adc])
1640  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMaximum(maxy[2 + adc]);
1641  else
1642  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMaximum(max2);
1643  } else {
1644  if (max1 < max2) m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMaximum(max2);
1645  }
1646 
1647  if (min1 > miny[2 + adc]) {
1648  if (min2 > miny[2 + adc])
1649  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMinimum(miny[2 + adc]);
1650  else
1651  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMinimum(min2);
1652  } else {
1653  if (min1 > min2) m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMinimum(min2);
1654  }
1655 
1656  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMarkerStyle(21);
1657  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMarkerSize(ms);
1658  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetLabelSize(0.08, "X");
1659  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetLabelSize(0.08, "Y");
1660  if (do_plots) {
1661  m_data->m_finalHist1[ros][drawer][adc][0][1]->Draw("P0");
1662  }
1663 
1664  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMaximum(m_data->m_finalHist1[ros][drawer][adc][0][1]->GetMaximum());
1665  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMinimum(m_data->m_finalHist1[ros][drawer][adc][0][1]->GetMinimum());
1666  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMarkerStyle(25);
1667  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMarkerSize(ms);
1668  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMarkerColor(4);
1669  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetLabelSize(0.08, "X");
1670  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetLabelSize(0.08, "Y");
1671  if (do_plots) {
1672  m_data->m_finalHist1[ros][drawer][adc][0][2]->Draw("sameP0");
1673  }
1674 
1675  if (do_plots) {
1676  pad = Can->cd(2 * maxgain + adc + 1);
1677  pad->SetTopMargin(0.15);
1678  pad->SetGridx();
1679  }
1680 
1681  if (max3 < 0.9 * maxy[4 + adc]) m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMaximum(maxy[4 + adc]);
1682  if (min3 > (miny[4 + adc] + 0.1 * TMath::Abs(miny[4 + adc]))) m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMinimum(miny[4 + adc]);
1683 
1684  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMarkerStyle(21);
1685  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMarkerSize(ms);
1686  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetLabelSize(0.08, "X");
1687  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetLabelSize(0.08, "Y");
1688  if (do_plots) {
1689  m_data->m_finalHist1[ros][drawer][adc][0][3]->Draw("E0");
1690  }
1691 
1692  } //end of loop over gain
1693 
1694  if (m_savePng) {
1695  Can->Print(TString(moduleName + "_fit_amp.png"), "png");
1696  }
1697  if (m_savePs) {
1698  Can->Print(TString(moduleName + "_fit_amp.ps"), "ps");
1699  }
1700  if (m_saveSvg) {
1701  Can->Print(TString(moduleName + "_fit_amp.svg"), "svg");
1702  }
1703  if (do_plots) delete Can;
1704  }
1705  }
1706 }

◆ drawOptFilt()

void TileRawChannelMonTool::drawOptFilt ( int  ros,
int  drawer,
const std::string &  moduleName 
)

◆ endOfEventsBlockFlag()

bool ManagedMonitorToolBase::endOfEventsBlockFlag ( ) const
inlineprotectedinherited

Definition at line 856 of file ManagedMonitorToolBase.h.

856 { return m_endOfEventsBlock; }

◆ endOfLowStatFlag()

bool ManagedMonitorToolBase::endOfLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 857 of file ManagedMonitorToolBase.h.

857 { return m_endOfLowStat; }

◆ endOfLumiBlockFlag()

bool ManagedMonitorToolBase::endOfLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 858 of file ManagedMonitorToolBase.h.

858 { return m_endOfLumiBlock; }

◆ endOfRunFlag()

bool ManagedMonitorToolBase::endOfRunFlag ( ) const
inlineprotectedinherited

Definition at line 859 of file ManagedMonitorToolBase.h.

859 { return m_endOfRun; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ fillDsp()

StatusCode TileRawChannelMonTool::fillDsp ( std::map< int, std::vector< double > > &  efitMap,
std::map< int, std::vector< double > > &  tfitMap 
)

Definition at line 797 of file TileRawChannelMonTool.cxx.

799 {
800 
801  ATH_MSG_DEBUG("in fillDsp()");
802 
803  const TileRawChannelContainer* RawChannelCnt;
804  CHECK(evtStore()->retrieve(RawChannelCnt, m_contNameDSP));
805 
806  TileRawChannelUnit::UNIT RChUnit = RawChannelCnt->get_unit();
807 
808  TileRawChannelContainer::const_iterator collItr = RawChannelCnt->begin();
809  TileRawChannelContainer::const_iterator lastColl = RawChannelCnt->end();
810 
811  for (; collItr != lastColl; ++collItr) {
812 
813  TileRawChannelCollection::const_iterator chItr = (*collItr)->begin();
814  TileRawChannelCollection::const_iterator lastCh = (*collItr)->end();
815 
816  if (chItr != lastCh) {
817 
818  HWIdentifier adc_id = (*chItr)->adc_HWID();
819  int ros = m_tileHWID->ros(adc_id);
820  int drawer = m_tileHWID->drawer(adc_id);
821 
822  if (m_data->m_histDsp1[ros][drawer][0][0].size() == 0) {
823  m_bigain = true;
824  bookDsp(ros, drawer);
825  }
826 
827  for (; chItr != lastCh; ++chItr) {
828 
829  const TileRawChannel * rch = (*chItr);
830 
831  adc_id = rch->adc_HWID();
832  unsigned int chan = m_tileHWID->channel(adc_id);
833  int adc = m_tileHWID->adc(adc_id);
834  int gain = (m_bigain) ? adc : 0; // ignore gain in monogain run
835  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
836 
837  if ((m_cispar[8] == 0) /* || ( m_cispar[8] == abs(m_cabling->channel2hole(ros,chan)) )*/
838  && !m_corrup[ros][drawer][gain][chan / 3]) { // channel is fired and not corrupted
839 
840  double amp = rch->amplitude();
841  if (RChUnit != m_calibUnit) {
842  if (m_calibUnit != TileRawChannelUnit::CesiumPicoCoulombs) { //We put everythin in the same unit
843  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, m_calibUnit);
844  } else { // it is =TileRawChannelUnit::CesiumPicoCoulombs, careful with MBTS channels
845  if (ros < 3) //if LB then it's ok CesiumPicoCoulomb
846  {
847  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::CesiumPicoCoulombs);
848  //conversion factor if of the order of 1000MeV=1.05pC
849  } else // check that they are not MBTS channel
850  {
851  int index, pmt;
852  /*Identifier cell_id =*/rch->cell_ID_index(index, pmt);
853  if (index < -1) // MBTS channel
854  {
855  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::PicoCoulombs);
856  } else //not MBTS channel
857  {
858  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::CesiumPicoCoulombs);
859  }
860  }
861  } // end if CesiumPicoCouloumb
862  }
863 
864  double time = rch->time();
865  double chi2 = rch->quality();
866 
867  m_data->m_histDsp1[ros][drawer][chan][gain][Edsp]->Fill(amp, 1.0);
868  m_data->m_histDsp1[ros][drawer][chan][gain][Tdsp]->Fill(time, 1.0);
869  m_data->m_histDsp1[ros][drawer][chan][gain][chi2dsp]->Fill(chi2, 1.0);
870  m_data->m_histDsp2[ros][drawer][chan][gain][0]->Fill(amp, chi2, 1.0);
871  m_data->m_finalHistDsp2[ros][drawer][gain][0]->Fill(amp, chi2, 1.0);
872 
873  std::map<int, std::vector<double> >::iterator it = efitMap.find(ros * 100 + drawer);
874  if (it != efitMap.end()) {
875  double efit = (*it).second.at(chan + gain * 48);
876  it = tfitMap.find(ros * 100 + drawer);
877  double tfit = (*it).second.at(chan + gain * 48);
878  //convert from pC to ADC counts
879  if (TMath::Abs(efit) > m_efitThresh) { // fill the histogram only if the efit is above threshold
880  m_data->m_histDsp1[ros][drawer][chan][gain][Edsp_fit]->Fill((amp - efit) / efit, 1.0);
881  }
882 
883  if (tfit != 0.) {
884  m_data->m_histDsp1[ros][drawer][chan][gain][Tdsp_fit]->Fill((time - tfit), 1.0);
885  }
886 
887  }
888  }
889 
890  } // loop over channels
891 
892  }
893  }
894  return StatusCode::SUCCESS;
895 }

◆ fillHistograms()

StatusCode ManagedMonitorToolBase::fillHistograms ( )
virtualinherited

An inheriting class should either override this function or fillHists().

Reimplemented in SCTHitEffMonTool, SCTHitsNoiseMonTool, SCTErrMonTool, SCTTracksMonTool, SCTLorentzMonTool, photonMonTool, egammaMonToolBase, electronMonTool, MuonPhysValMonitoring::MuonPhysValMonitoringTool, AFPHitsMonitorTool, LArCellMonTool, InDetGlobalBCMTool, MuonDQA::MuonEventInfoMonTool, DQTDataFlowMonTool, TileCalCellMonTool, ActsTrk::PhysValTool, PhysValSecVtx, LUCID_HitsMoniTool, ZeeTaPMonTool, forwardElectronMonTool, RpcLv1RawDataEfficiency, LVL1::CalorimeterL1CaloMon, LVL1::L1CaloCTPMon, LVL1::L1CaloLevel2Mon, LVL1::L1CaloPMTScoresMon, MdtRawDataValAlg, DQTNonCollBkg_ZDC, InDetGlobalTrackMonTool, TRT_Electron_Monitoring_Tool, CscCalibMonToolBase, InDetGlobalHitsMonTool, JetTagMonitoring, InDetPhysValMonitoringTool, EgammaPhysValMonitoring::EgammaPhysValMonitoringTool, TRT_Monitoring_Tool, InDetGlobalSynchMonTool, MissingEtDQA::PhysValMET, METMonTool, CaloTowerVecMon, LVL1::L1CaloL1TopoMon, JetTagDQA::PhysValBTag, DQTGlobalWZFinderTool, InDetGlobalTopBottomMonTool, CSCSegmValAlg, InDetGlobalNoiseOccupancyMonTool, PhysVal::PhysValExample, TopPhysVal::TopPhysValMonitoring, DataQualityFatherMonTool, ZeeValidation::ZeeValidationMonitoringTool, CaloClusterVecMon, RpcLv1RawDataValAlg, CaloTransverseBalanceVecMon, DQTDetSynchMonTool, RpcLv1RawDataSectorLogic, InDetTrackPerfMonTool, DQTMuonIDTrackTool, InDetGlobalBeamSpotMonTool, InDetGlobalPixelTool, IDPerfMonWenu, IDPerfMonZee, TrackCaloClusterRecValidationTool, MdtVsTgcRawDataValAlg, MdtVsRpcRawDataValAlg, CscClusterValAlg, JetMonitoringTool, TileCellNoiseMonTool, InDetGlobalErrorMonTool, PhysValTau, AFPTechnicalMonitorTool, PhysValFE, ManagedMonitorToolTest, DiMuMon, InDetGlobalPrimaryVertexMonTool, InDetVertexMonitoring, CscPrdValAlg, CscRdoValAlg, HIMonitoringEventShapeTool, IDPerfMonKshort, HIMonitoringZdcTool, HIMonitoringElectronsTool, HIMonitoringPhotonsTool, PhysValCluster, and HIMonitoringMuonsTool.

Definition at line 1414 of file ManagedMonitorToolBase.cxx.

1416 {
1417  return StatusCode::SUCCESS;
1418 }

◆ fillHists()

StatusCode TileRawChannelMonTool::fillHists ( )
overridevirtual

Calls fillHists( bool, bool, bool ); if an eventBlock,lumiBlock, or run has turned over, calls procHists( bool, bool, bool ) and bookHists( bool, bool, bool ).

Reimplemented from ManagedMonitorToolBase.

Definition at line 510 of file TileRawChannelMonTool.cxx.

512 {
513 
514  ATH_MSG_DEBUG("in fillHists()");
515 
516  if (m_nEventsTileMon % 1000 == 0) ATH_MSG_INFO(m_nEventsTileMon<<" events processed so far");
517  // array of 16 CIS parameters
518  const TileDQstatus* dqStatus = SG::makeHandle (m_DQstatusKey).get();
519  m_cispar = dqStatus->cispar();
520  ++m_nEventsTileMon;
521 
522  m_efitMap.clear();
523  m_tfitMap.clear();
524 
525  //ndulchin: start filter code
526  const TileDigitsContainer* DigitsCnt;
527  CHECK(evtStore()->retrieve(DigitsCnt, "TileDigitsCnt"));
528 
529  TileDigitsContainer::const_iterator collItr2 = DigitsCnt->begin();
530  TileDigitsContainer::const_iterator lastColl2 = DigitsCnt->end();
531 
532  for (; collItr2 != lastColl2; ++collItr2) {
533  TileDigitsCollection::const_iterator digitsItr = (*collItr2)->begin();
534  TileDigitsCollection::const_iterator lastDigits = (*collItr2)->end();
535 
536  if (digitsItr != lastDigits) {
537 
538  HWIdentifier adc_id = (*digitsItr)->adc_HWID();
539  int ros = m_tileHWID->ros(adc_id);
540  int drawer = m_tileHWID->drawer(adc_id);
541  std::vector<uint32_t> headerVec = (*collItr2)->getFragChipHeaderWords();
542  int headsize = headerVec.size();
543  if (headsize > 16) headsize = 16;
544 
545  int fragId = (*collItr2)->identify();
546  if (!std::binary_search(m_fragIDsToIgnoreDMUerrors.begin(), m_fragIDsToIgnoreDMUerrors.end(), fragId)) {
547 
548  for (int dmu = 0; dmu < headsize; dmu++) {
549  m_corrup[ros][drawer][0][dmu] = checkDmuHeader(&headerVec, dmu);
550  m_corrup[ros][drawer][1][dmu] = checkDmuHeader(&headerVec, dmu);
551  }
552 
553  } else {
554  for (int dmu = 0; dmu < headsize; dmu++) {
555  m_corrup[ros][drawer][0][dmu] = false;
556  m_corrup[ros][drawer][1][dmu] = false;
557  }
558  }
559 
560  for (int dmu = headsize; dmu < 16; dmu++) {
561  m_corrup[ros][drawer][0][dmu] = false;
562  m_corrup[ros][drawer][1][dmu] = false;
563  }
564 
565  }
566  }
567 
568  //if (!isErr)
569  //ndulchin: end Filter code
570 
571  const TileRawChannelContainer* RawChannelCnt;
572  CHECK(evtStore()->retrieve(RawChannelCnt, m_contName));
573 
574  TileRawChannelUnit::UNIT RChUnit = RawChannelCnt->get_unit();
575 
576  //Lukas
577  double avgTimePerPart[5], sumTimeCh[5];
578  int nCh[5];
579  for (int iros = 0; iros < 5; iros++) {
580  avgTimePerPart[iros] = 0;
581  sumTimeCh[iros] = 0;
582  nCh[iros] = 0;
583  } //for iros
584  //Lukas
585 
586  for (int k = 0; k < 2; k++) { //Lukas
587 
588  TileRawChannelContainer::const_iterator collItr = RawChannelCnt->begin();
589  TileRawChannelContainer::const_iterator lastColl = RawChannelCnt->end();
590 
591  for (; collItr != lastColl; ++collItr) {
592 
593  int cap = (m_cispar[7] > 10) ? 0 : 1; // 100 pF or 5 pF
594  int cap_index = cap;
595 
596  double hg_small_charge = 1.; // ignore charges below 1 pC in HG
597  double lg_small_charge = (cap) ? 10. : 15.; // ignore charges below 10 pC for small cap and below 15 pC for big cap in LG
598  double hg_charge_cut = 11.5; // ignore charges above 11.5 pC in HG (full range is 12.5 pC)
599  double lg_charge_cut = 750.; // ignore charges above 750. pC in LG (full range is 800. pC)
600 
601  int fragId = (*collItr)->identify();
602  bool demonstrator = (std::binary_search(m_fragIDsDemonstrators.begin(), m_fragIDsDemonstrators.end(), fragId));
603  if (demonstrator) {
604  hg_small_charge *= 2.;
605  hg_charge_cut *= 2;
606  cap_index *= 2;
607  }
608  double charge = (m_cispar[6] < 1024) ? m_cispar[6] * m_dac2Charge[cap_index] : 0;
609  double timeInj = m_cispar[5] * 0.104;
610 
611  TileRawChannelCollection::const_iterator chItr = (*collItr)->begin();
612  TileRawChannelCollection::const_iterator lastCh = (*collItr)->end();
613 
614  if (chItr != lastCh) {
615 
616  HWIdentifier adc_id = (*chItr)->adc_HWID();
617  int ros = m_tileHWID->ros(adc_id);
618  int drawer = m_tileHWID->drawer(adc_id);
619  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
620 
621  if (m_data->m_hist1[ros][drawer][0][0].size() == 0) {
622  // m_bigain = (dqStatus->calibMode() == 1); // true if bi-gain run
623  // we fill both high and low gain plots
624  m_bigain = true;
625  if (k == 0) bookHists(ros, drawer); //Lukas
626  }
627 
628  std::vector<double> efitVec(m_bigain ? 96 : 48, 0.), tfitVec(m_bigain ? 96 : 48, 0.); //I need these variables later for comparison with dsp
629 
630  for (; chItr != lastCh; ++chItr) {
631 
632  const TileRawChannel * rch = (*chItr);
633 
634  adc_id = rch->adc_HWID();
635  unsigned int chan = m_tileHWID->channel(adc_id);
636  int adc = m_tileHWID->adc(adc_id);
637  int gain = (m_bigain) ? adc : 0; // ignore gain in monogain run
638 
639  if ((m_cispar[8] == 0) /* || ( m_cispar[8] == abs(m_cabling->channel2hole(ros,chan)) )*/) { // channel is fired
640 
641  double amp = rch->amplitude();
642  if (RChUnit != m_calibUnit) {
643  //Put everything in PicoCoulomb by default for all run types
644  //For Laser and Physcs calibrate in CesiumPicoCoulomb for all channels,
645  // but the MBTS channels, for which we keep the calibration in PicoCoulombCesium pC for consistency
646  //(no Cs calibration is possible)
647  if (m_calibUnit == TileRawChannelUnit::CesiumPicoCoulombs) {
648  if (ros < 3) //if LB then it's ok CesiumPicoCoulomb
649  {
650  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::CesiumPicoCoulombs);
651  } else // check that they are not MBTS channel
652  {
653  int index, pmt;
654  /*Identifier cell_id =*/rch->cell_ID_index(index, pmt);
655  if (index < -1) // MBTS channel
656  {
657  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::PicoCoulombs);
658  } else //not MBTS channel
659  {
660  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::CesiumPicoCoulombs);
661  }
662  }
663  } //close if on CesiumPicoCoulomb units
664  else { //calibrate in PicoCoulomb
665  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, m_calibUnit);
666  }
667  } // no need to calibrate
668 
669  efitVec[chan + gain * 48] = amp;
670  double time = rch->time();
671  double timeCorr = 0; //Lukas
672  tfitVec[chan + gain * 48] = time;
673 
674  if (!m_corrup[ros][drawer][gain][chan / 3]) {
675  if ((m_runType == CisRun) || (m_runType == CisRamp)) {
676  if (k == 0) { //Lukas
677 
678  if (m_book2D) {
679  m_data->m_hist2[ros][drawer][chan][gain][cap]->Fill(charge, amp);
680  }
681 
682  // avoid small signals and overflows in both gains
683  if ( ( (adc == 1) && (charge < hg_charge_cut) && (charge > hg_small_charge) ) ||
684  ( (adc == 0) && (charge < lg_charge_cut) && (charge > lg_small_charge) ) ) {
685 
686  double ratio = amp / charge;
687 
688  m_data->m_hist1[ros][drawer][chan][gain][0 + cap]->Fill(ratio);
689  m_data->m_hist1[ros][drawer][chan][gain][2 + cap]->Fill(time);
690  if (m_book2D) {
691  m_data->m_hist2[ros][drawer][chan][gain][cap + 2]->Fill(timeInj, time);
692  }
693 
694  /*TimeCov[ros][drawer][chan][gain][cap][0] += timeInj;
695  TimeCov[ros][drawer][chan][gain][cap][1] += timeInj*timeInj;
696  TimeCov[ros][drawer][chan][gain][cap][2] += time;
697  TimeCov[ros][drawer][chan][gain][cap][3] += time*time;
698  TimeCov[ros][drawer][chan][gain][cap][4] += timeInj*time;*/
699  ++m_data->m_timeCov[ros][drawer][chan][gain][cap][5];
700  }
701  } //if k==0 //Lukas
702  } else { // not CisRun
703  if (k == 0) { //Lukas
704  m_data->m_hist1[ros][drawer][chan][gain][0]->Fill(amp, 1.0);
705  if (time != 0) { // we don't fill the time when it is exactly 0, which is a conventional value to say that it is not
706  // calculated when the difference between the max(samples)-min(samples)< threshold
707  m_data->m_hist1[ros][drawer][chan][gain][1]->Fill(time, 1.0);
708  }
709 
710  m_data->m_timeCov[ros][drawer][chan][gain][0][0] += amp;
711  m_data->m_timeCov[ros][drawer][chan][gain][0][1] += amp * amp;
712  m_data->m_timeCov[ros][drawer][chan][gain][0][2] += time;
713  m_data->m_timeCov[ros][drawer][chan][gain][0][3] += time * time;
714  //TimeCov[ros][drawer][chan][gain][0][4] += amp*time;
715  ++m_data->m_timeCov[ros][drawer][chan][gain][0][5];
716  /*
717  //Lukas
718  if((ros==3 && drawer==14 && (chan==12 || chan==13 || chan==18 || chan==19))||(ros==4 && drawer==17 && (chan==12 || chan==13 || chan==18 || chan==19))){
719  }else if((ros==3 || ros==4) && (chan==0 || chan==1 || chan==12 || chan==13)){
720  }else{
721  sumTimeCh[ros][gain]+=time;
722  nCh[ros][gain]+=1;
723  }
724  //Lukas
725  */
726  //Lukas
727  if (isDisconnected(ros, drawer, chan) || amp < m_minAmpForCorrectedTime) continue;
728  if ((ros == 3 || ros == 4)
729  && (chan == 0 || chan == 1 || chan == 2 || chan == 3 || chan == 4 || chan == 5 || chan == 12 || chan == 13 || chan == 18
730  || chan == 19)) {
731  } else {
732  sumTimeCh[ros] += time;
733  nCh[ros] += 1;
734  }
735  //Lukas
736 
737  } //if k==0 //Lukas
738  else if (k == 1) { //Lukas
739  if (isDisconnected(ros, drawer, chan) || amp < m_minAmpForCorrectedTime) continue;
740 
741  timeCorr = time - avgTimePerPart[ros]; //Lukas
742  m_data->m_hist1[ros][drawer][chan][gain][2]->Fill(timeCorr, 1.0); //Lukas
743 
744  m_data->m_timeCovCorr[ros][drawer][chan][gain][0][0] += timeCorr; //Lukas
745  m_data->m_timeCovCorr[ros][drawer][chan][gain][0][1] += timeCorr * timeCorr; //Lukas
746  ++m_data->m_timeCovCorr[ros][drawer][chan][gain][0][2]; //Lukas
747 
748  } //k==1 //Lukas
749  } // end of nonCisRun
750  }
751 
752  } else { // if channel is not fired
753  }
754 
755  } // loop over channels
756  if (k == 0) { //Lukas
757  if (m_plotDsp) {
758  m_efitMap.insert(make_pair(ros * 100 + drawer, efitVec)); // needed later for dspreco comparison
759  m_tfitMap.insert(make_pair(ros * 100 + drawer, tfitVec)); // needed later for dspreco comparison
760  }
761  } //if k==0 //Lukas
762  }
763  }
764  //Lukas
765  if (k == 0) {
766  for (int iros = 0; iros < 5; iros++) {
767  if (nCh[iros] != 0) {
768  avgTimePerPart[iros] = sumTimeCh[iros] / nCh[iros];
769  } else {
770  avgTimePerPart[iros] = 0;
771  }
772  sumTimeCh[iros] = 0;
773  nCh[iros] = 0;
774  } //for
775  } //if k==0
776  //Lukas
777  } // loop over k //Lukas
778 
779  if (m_plotDsp) {
780  if (fillDsp(m_efitMap, m_tfitMap).isFailure()) ATH_MSG_WARNING("Error filling DSP histograms");
781  }
782 
783 
784  if ((m_summaryUpdateFrequency > 0) && (m_nEventsTileMon % m_summaryUpdateFrequency == 0)) {
785  m_drawHists = false;
786  CHECK(fillSummaryHistograms());
787  if (m_resetAfterSummaryUpdate) resetSummaryHistograms();
788  }
789 
790 
791 
793  return StatusCode::SUCCESS;
794 }

◆ fillSummaryHistograms()

StatusCode TileRawChannelMonTool::fillSummaryHistograms ( )
private

Definition at line 1038 of file TileRawChannelMonTool.cxx.

1040 {
1041 
1042  ATH_MSG_INFO("in fillFfinalHiststograms()");
1043 
1044  memset(m_data->m_rangeQ, 0, sizeof(m_data->m_rangeQ));
1045 
1046  TF1 * fit_gaus = new TF1("g", "gaus");
1047 
1048  // for bigain run book 2 histograms per channel
1049  // for monogain run book just one histogram per channel
1050  int mingain = (m_bigain) ? 0 : 2;
1051  int maxgain = (m_bigain) ? 2 : 3;
1052 
1053  if ((m_runType == CisRun) || (m_runType == CisRamp)) {
1054  for (int ros = 1; ros < 5; ++ros) {
1055  for (int drawer = 0; drawer < 64; ++drawer) {
1056  if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
1057  for (int gn = mingain; gn < maxgain; ++gn) {
1058 
1059  int adc = gn & 1;
1060  for (int cap = 0; cap < 2; ++cap) {
1061  for (int ch = 0; ch < 48; ++ch) {
1062 
1063  // int pmt = abs(m_cabling->channel2hole(ros,ch)); // number in range [1,48]
1064 
1065  TF1* polyfunc = 0;
1066  if (m_book2D) polyfunc = GetTimeFitFunc(m_data->m_hist2[ros][drawer][ch][adc][cap + 2]);
1067  if (polyfunc) {
1068  m_data->m_finalHist1[ros][drawer][adc][cap][0]->SetBinContent(ch + 1, polyfunc->GetParameter(1));
1069  if (polyfunc->GetParError(1) > 5) {
1070  m_data->m_finalHist1[ros][drawer][adc][cap][0]->SetBinError(ch + 1, 5.);
1071  } else {
1072  m_data->m_finalHist1[ros][drawer][adc][cap][0]->SetBinError(ch + 1, polyfunc->GetParError(1));
1073  }
1074  m_data->m_finalHist1[ros][drawer][adc][cap][1]->SetBinContent(ch + 1, polyfunc->GetParameter(0));
1075  if (polyfunc->GetParError(0) > 5) {
1076  m_data->m_finalHist1[ros][drawer][adc][cap][1]->SetBinError(ch + 1, 5.);
1077  } else {
1078  m_data->m_finalHist1[ros][drawer][adc][cap][1]->SetBinError(ch + 1, polyfunc->GetParError(0));
1079  }
1080 
1081  delete polyfunc; //important!
1082  }
1083 
1084  else {
1085  m_data->m_finalHist1[ros][drawer][adc][cap][0]->SetBinContent(ch + 1, 0.);
1086  m_data->m_finalHist1[ros][drawer][adc][cap][0]->SetBinError(ch + 1, 0.);
1087  m_data->m_finalHist1[ros][drawer][adc][cap][1]->SetBinContent(ch + 1, 0.);
1088  m_data->m_finalHist1[ros][drawer][adc][cap][1]->SetBinError(ch + 1, 0.);
1089  }
1090 
1091  TH1S * hist = m_data->m_hist1[ros][drawer][ch][adc][cap];
1092  int nbins = hist->GetNbinsX();
1093  int minbin = 1;
1094  for (; minbin < nbins; ++minbin) {
1095  if (hist->GetBinContent(minbin) > 0.0) {
1096  break;
1097  }
1098  }
1099  int maxbin = nbins;
1100  for (; maxbin > 1; --maxbin) {
1101  if (hist->GetBinContent(maxbin) > 0.0) {
1102  break;
1103  }
1104  }
1105 
1106  double mean = hist->GetMean();
1107  double xmin = hist->GetBinCenter(minbin);
1108  double xmax = hist->GetBinCenter(maxbin);
1109 
1110  //rangeErrorBar(xmin,xmax,mean);
1111  if (m_useratioerror) { // /use ratioerror bar or rangeerror bar ?
1112  ratioErrorBar(hist, xmin, xmax, mean);
1113  } else {
1114  rangeErrorBar(xmin, xmax, mean);
1115  }
1116 
1117  //std::cout << hist->GetName() <<" mean-xmin= "<< mean-xmin <<"\n";
1118  m_data->m_rangeQ[adc][cap][0][ch] = mean;
1119  m_data->m_rangeQ[adc][cap][1][ch] = std::max(0.0, mean - xmin);
1120  m_data->m_rangeQ[adc][cap][2][ch] = std::max(0.0, xmax - mean);
1121 
1122  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetBinContent(ch + 1, mean);
1123  }
1124  } //end of loop over capacitors
1125  } //end of loop over gn
1126 
1127  if(m_drawHists) {
1128  std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
1129  drawHists(ros, drawer, moduleName);
1130  }
1131  }
1132  } //end of loop over drawer
1133  } //end of loop over ros
1134 
1135  } else { // not CisRun
1136 
1137  for (int ros = 1; ros < 5; ++ros) {
1138  for (int drawer = 0; drawer < 64; ++drawer) {
1139  if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
1140  for (int gn = mingain; gn < maxgain; ++gn) {
1141 
1142  int adc = gn & 1;
1143  for (int ch = 0; ch < 48; ++ch) {
1144 
1145  // int pmt = abs(m_cabling->channel2hole(ros,ch)); // number in range [1,48]
1146 
1147  double Amp = 0.0, ErrA = 0.0, RMS = 0.0, ErrR = 0.0;
1148  double Time = 0.0, RMST = 0.0, Sigma = 0.0, ErrS = 0.0;
1149  double NEvents = m_data->m_timeCov[ros][drawer][ch][adc][0][5];
1150 
1151  double TimeCorr = 0.0, RMSTCorr = 0.0; //Lukas
1152  double NEventsCorr = m_data->m_timeCovCorr[ros][drawer][ch][adc][0][2]; //Lukas
1153 
1154  if (NEvents > 0.0) {
1155 
1156  Amp = m_data->m_timeCov[ros][drawer][ch][adc][0][0] / NEvents;
1157  RMS = m_data->m_timeCov[ros][drawer][ch][adc][0][1] / NEvents - Amp * Amp;
1158  if (RMS > 0.0) {
1159  RMS = sqrt(RMS);
1160  ErrA = RMS / sqrt(NEvents);
1161  ErrR = RMS / sqrt(2 * NEvents);
1162  } else {
1163  RMS = 0.0;
1164  }
1165 
1166  Time = m_data->m_timeCov[ros][drawer][ch][adc][0][2] / NEvents;
1167  RMST = m_data->m_timeCov[ros][drawer][ch][adc][0][3] / NEvents - Time * Time;
1168  if (RMST > 0.0) {
1169  RMST = sqrt(RMST);
1170  } else {
1171  RMST = 0.0;
1172  }
1173  }
1174 
1175  //Lukas
1176  if (NEventsCorr > 0.0) {
1177  TimeCorr = m_data->m_timeCovCorr[ros][drawer][ch][adc][0][0] / NEventsCorr;
1178  RMSTCorr = m_data->m_timeCovCorr[ros][drawer][ch][adc][0][1] / NEventsCorr - TimeCorr * TimeCorr;
1179  if (RMSTCorr > 0.0) {
1180  RMSTCorr = sqrt(RMSTCorr);
1181  } else {
1182  RMSTCorr = 0.0;
1183  }
1184  }
1185  //Lukas
1186 
1187  if (m_data->m_hist1[ros][drawer][ch][adc][0]->GetEntries() > 0) {
1188  if (adc == 0 && m_overlaphists) { // We have for LB histograms with variable-width bins, not suitable for a fit
1189  TH1S *h4fit=new TH1S(*(m_data->m_hist1[ros][drawer][ch][adc][0]));
1190  h4fit->Scale(1,"width");
1191  h4fit->Fit("g", "NQ");
1192  delete(h4fit);
1193  } else {
1194  m_data->m_hist1[ros][drawer][ch][adc][0]->Fit("g", "NQ");
1195  }
1196  Sigma = fit_gaus->GetParameter(2);
1197  ErrS = fit_gaus->GetParError(2);
1198  }
1199 
1200  m_data->m_finalHist1[ros][drawer][adc][0][0]->SetBinContent(ch + 1, Amp);
1201  m_data->m_finalHist1[ros][drawer][adc][0][0]->SetBinError(ch + 1, ErrA);
1202  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetBinContent(ch + 1, RMS);
1203  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetBinError(ch + 1, ErrR);
1204  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetBinContent(ch + 1, Sigma);
1205  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetBinError(ch + 1, ErrS);
1206  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetBinContent(ch + 1, Time);
1207  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetBinError(ch + 1, RMST);
1208  m_data->m_finalHist1[ros][drawer][adc][0][4]->SetBinContent(ch + 1, TimeCorr); //Lukas
1209  m_data->m_finalHist1[ros][drawer][adc][0][4]->SetBinError(ch + 1, RMSTCorr); //Lukas
1210 
1211  if (m_doLaserSummaryVsPMT && m_runType == LasRun) {
1212 
1213  int pmt = m_cabling->channel2hole(ros, ch);
1214  if (pmt < 0) continue;
1215 
1216  int fiber = (pmt % 2);
1217 
1218  m_data->m_summaryPmts[ros][drawer][adc][fiber][0]->SetBinContent(pmt + 1, Amp);
1219  m_data->m_summaryPmts[ros][drawer][adc][fiber][0]->SetBinError(pmt + 1, ErrA);
1220  m_data->m_summaryPmts[ros][drawer][adc][fiber][1]->SetBinContent(pmt + 1, RMS);
1221  m_data->m_summaryPmts[ros][drawer][adc][fiber][1]->SetBinError(pmt + 1, ErrR);
1222  m_data->m_summaryPmts[ros][drawer][adc][fiber][2]->SetBinContent(pmt + 1, Sigma);
1223  m_data->m_summaryPmts[ros][drawer][adc][fiber][2]->SetBinError(pmt + 1, ErrS);
1224  m_data->m_summaryPmts[ros][drawer][adc][fiber][3]->SetBinContent(pmt + 1, Time);
1225  m_data->m_summaryPmts[ros][drawer][adc][fiber][3]->SetBinError(pmt + 1, RMST);
1226  m_data->m_summaryPmts[ros][drawer][adc][fiber][4]->SetBinContent(pmt + 1, TimeCorr); //Lukas
1227  m_data->m_summaryPmts[ros][drawer][adc][fiber][4]->SetBinError(pmt + 1, RMSTCorr); //Lukas
1228 
1229  if (ros == 1) {
1230 
1231  int bin = m_data->m_summaryPmts[0][drawer][adc][fiber][0]->FindBin(pmt);
1232 
1233  m_data->m_summaryPmts[0][drawer][adc][fiber][0]->SetBinContent(bin, Amp);
1234  m_data->m_summaryPmts[0][drawer][adc][fiber][0]->SetBinError(bin, ErrA);
1235  m_data->m_summaryPmts[0][drawer][adc][fiber][1]->SetBinContent(bin, RMS);
1236  m_data->m_summaryPmts[0][drawer][adc][fiber][1]->SetBinError(bin, ErrR);
1237  m_data->m_summaryPmts[0][drawer][adc][fiber][2]->SetBinContent(bin, Sigma);
1238  m_data->m_summaryPmts[0][drawer][adc][fiber][2]->SetBinError(bin, ErrS);
1239  m_data->m_summaryPmts[0][drawer][adc][fiber][3]->SetBinContent(bin, Time);
1240  m_data->m_summaryPmts[0][drawer][adc][fiber][3]->SetBinError(bin, RMST);
1241  m_data->m_summaryPmts[0][drawer][adc][fiber][4]->SetBinContent(bin, TimeCorr); //Lukas
1242  m_data->m_summaryPmts[0][drawer][adc][fiber][4]->SetBinError(bin, RMSTCorr); //Lukas
1243 
1244  }
1245 
1246  if (ros == 2) {
1247 
1248  int bin = m_data->m_summaryPmts[0][drawer][adc][1 - fiber][0]->FindBin(-pmt);
1249 
1250  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][0]->SetBinContent(bin, Amp);
1251  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][0]->SetBinError(bin, ErrA);
1252  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][1]->SetBinContent(bin, RMS);
1253  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][1]->SetBinError(bin, ErrR);
1254  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][2]->SetBinContent(bin, Sigma);
1255  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][2]->SetBinError(bin, ErrS);
1256  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][3]->SetBinContent(bin, Time);
1257  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][3]->SetBinError(bin, RMST);
1258  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][4]->SetBinContent(bin, TimeCorr); //Lukas
1259  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][4]->SetBinError(bin, RMSTCorr); //Lukas
1260 
1261  }
1262  }
1263 
1264  }
1265  } //end of loop over gn
1266 
1267  if(m_drawHists){
1268  std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
1269  drawHists(ros, drawer, moduleName);
1270  if (m_plotDsp) {
1271  if (finalDsp(ros, drawer).isFailure()) ATH_MSG_WARNING("Error finalizing DSP histograms");
1272  }
1273  }
1274 
1275  }
1276  } //loop over drawer
1277  } //loop over ros
1278  }
1279 
1280  delete fit_gaus;
1281 
1282  return StatusCode::SUCCESS;
1283 }

◆ finalDsp()

StatusCode TileRawChannelMonTool::finalDsp ( int  ros,
int  drawer 
)

get algorithm and number of iterations from bsflags

Definition at line 1312 of file TileRawChannelMonTool.cxx.

1314 {
1315 
1316  if (m_data->m_histDsp1[ros][drawer][0][0].size() != 0) {
1317 
1319  const TileRawChannelContainer* RawChannelCntDsp;
1320 
1321  unsigned int iteration = 0u;
1322  unsigned int algorithm = 0u;
1323  if (evtStore()->retrieve(RawChannelCntDsp, m_contNameDSP).isSuccess()) {
1324  uint32_t info = RawChannelCntDsp->get_bsflags() >> 24u;
1325  iteration = info & 3u;
1326  algorithm = (info >> 2u) & 1u;
1327 
1328  // iteration: "NI", "I1", "I2", "I3"
1329  // algorithm: "OF1", "OF2"
1330  }
1331 
1332  const char *alg_name[2] = { "OF1", "OF2" };
1333  const char * iter_name[4] = { "NI", "I1", "I2", "I3" };
1334 
1335  const char *part[5] = { "AUX", "LBA", "LBC", "EBA", "EBC" };
1336  const char *gain[4] = { "_lo", "_hi", " low gain", " high gain" };
1337 
1338  int mingain = 0;
1339  int maxgain = 2;
1340 
1341 // const char *HistName[9] = {"_dspfit_ampdiff","_dspfit_timediff","_dspamp",
1342 // " Average (DSP-"," Average DSP-", " Average DSP-",
1343 // " - OFF-OF2-I) divided by OFF-OF2-I Amplitudes and RMS"," - OFF-OF2-I Time and RMS", " Amplitudes and RMS"};
1344  const char *HistName[9] = { "_dspfit_ampdiff", "_dspfit_timediff", "_dspamp", " Avg. (DSP-", " Average DSP-", " Average DSP-",
1345  " - OFF-OF2-I) / OFF Amplitudes and RMS", " - OFF-OF2-I Time and RMS", " Amplitudes and RMS" };
1346 
1347  std::ostringstream sStr;
1348  sStr << part[ros] << std::setfill('0') << std::setw(2) << drawer + 1 << std::setfill(' ');
1349  std::string moduleName = sStr.str();
1350  std::string subDir = "Summary";
1351  std::string histName, histTitle;
1352 
1353  for (int gn = mingain; gn < maxgain; ++gn) {
1354 
1355  int adc = gn & 1;
1356 
1357  for (int type = sumEdsp_fit; type < NsumDsp; ++type) {
1358  sStr.str("");
1359  sStr << moduleName << gain[gn] << HistName[type];
1360  histName = sStr.str();
1361  sStr.str("");
1362  sStr << moduleName << gain[2 + gn] << HistName[3 + type] << alg_name[algorithm] << "-" << iter_name[iteration] << HistName[6 + type];
1363  histTitle = sStr.str();
1364  m_data->m_finalHistDsp1[ros][drawer][adc].push_back(book1F(subDir, histName, histTitle, 48, 0.0, 48.0));
1365  }
1366 
1367  //Create hbar histograms to be used in drawDsp
1368  sStr.str("");
1369  sStr << moduleName << gain[gn] << "_dspfit_amphbar";
1370  histName = sStr.str();
1371  sStr.str("");
1372  sStr << moduleName << gain[2 + gn] << " (DSP-" << alg_name[algorithm] << "-" << iter_name[iteration]
1373  << " - OFF-OF2-I) divided by OFF Amplitudes for all chans";
1374  histTitle = sStr.str();
1375  m_data->m_hBarDsp1[ros][drawer][adc].push_back(book1F(subDir, histName, histTitle, 404, -1.01, 1.01));
1376 
1377  sStr.str("");
1378  sStr << moduleName << gain[gn] << "_dspfit_timehbar";
1379  histName = sStr.str();
1380  sStr.str("");
1381  sStr << moduleName << gain[2 + gn] << " (DSP-" << alg_name[algorithm] << "-" << iter_name[iteration] << " - OFF-OF2-I) Time for all chans";
1382  histTitle = sStr.str();
1383  m_data->m_hBarDsp1[ros][drawer][adc].push_back(book1F(subDir, histName, histTitle, 101, -2.02, 2.02));
1384 
1385  for (int ch = 0; ch < 48; ++ch) {
1386  // int pmt = abs(m_cabling->channel2hole(ros,ch)); // number in range [1,48]
1387 
1388  if (m_data->m_histDsp1[ros][drawer][ch][adc][Edsp_fit]->GetEntries() > 0) {
1389  double dspmean = m_data->m_histDsp1[ros][drawer][ch][adc][Edsp]->GetMean();
1390  double dsprms = m_data->m_histDsp1[ros][drawer][ch][adc][Edsp]->GetRMS();
1391  double emean = m_data->m_histDsp1[ros][drawer][ch][adc][Edsp_fit]->GetMean();
1392  double erms = m_data->m_histDsp1[ros][drawer][ch][adc][Edsp_fit]->GetRMS();
1393  double tmean = m_data->m_histDsp1[ros][drawer][ch][adc][Tdsp_fit]->GetMean();
1394  double trms = m_data->m_histDsp1[ros][drawer][ch][adc][Tdsp_fit]->GetRMS();
1395 
1396  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp]->SetBinContent(ch + 1, dspmean);
1397  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp]->SetBinError(ch + 1, dsprms);
1398  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetBinContent(ch + 1, emean);
1399  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetBinError(ch + 1, erms);
1400  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetBinContent(ch + 1, tmean);
1401  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetBinError(ch + 1, trms);
1402 
1403  m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->Add(m_data->m_histDsp1[ros][drawer][ch][adc][Edsp_fit]);
1404  m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->Add(m_data->m_histDsp1[ros][drawer][ch][adc][Tdsp_fit]);
1405 
1406  }
1407  }
1408  } // close loops over chans, gain
1409 
1410  // log << MSG::WARNING << "LUCA Calling drawDsp" << endreq;
1411  drawDsp(ros, drawer, moduleName);
1412 
1413  } //close if there are histograms for this Module
1414 
1415  return StatusCode::SUCCESS;
1416 }

◆ finalHists()

StatusCode TileRawChannelMonTool::finalHists ( )
overridevirtual

Calls procHists( true, true, true ).

Reimplemented from ManagedMonitorToolBase.

Definition at line 1289 of file TileRawChannelMonTool.cxx.

1291 {
1292  ATH_MSG_INFO("in finalHists()");
1293 
1294  if (m_summaryUpdateFrequency == 0) {
1295  for (int ros = 1; ros < 5; ++ros) {
1296  for (int drawer = 0; drawer < 64; ++drawer) {
1297  if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
1298  bookSummaryHistograms(ros, drawer);
1299  }
1300  }
1301  }
1302  }
1303 
1304  m_drawHists = true;
1305  CHECK(fillSummaryHistograms());
1306 
1307 
1308  return StatusCode::SUCCESS;
1309 }

◆ get_nEvents()

unsigned int ManagedMonitorToolBase::get_nEvents ( ) const
inlineprotectedinherited

Definition at line 754 of file ManagedMonitorToolBase.h.

754  {
755  return m_nEvents;
756  }

◆ get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const
inlineprotectedinherited

Definition at line 758 of file ManagedMonitorToolBase.h.

758  {
759  return m_procNEventsProp;
760  }

◆ getCellName()

std::string TilePaterMonTool::getCellName ( unsigned int  ros,
unsigned int  channel 
)
inlineprotectedinherited

Definition at line 246 of file TilePaterMonTool.h.

246  {
247  if (ros < 3) return m_LBcellName[channel];
248  else return m_EBcellName[channel];
249  };

◆ getHist() [1/6]

StatusCode ManagedMonitorToolBase::getHist ( LWHist *&  h,
const std::string &  hName,
const MonGroup &  group 
)
virtualinherited

Definition at line 1614 of file ManagedMonitorToolBase.cxx.

1615 {
1616  h = 0;
1617  std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1618  std::set<LWHist*>::iterator it(m_lwhists.begin()),itE(m_lwhists.end());
1619  for (;it!=itE;++it) {
1620  if (LWHistAthMonWrapper::streamName(*it)==streamName) {
1621  h = *it;
1622  return StatusCode::SUCCESS;
1623  }
1624  }
1625  return StatusCode::FAILURE;
1626 }

◆ getHist() [2/6]

StatusCode ManagedMonitorToolBase::getHist ( LWHist *&  h,
const std::string &  hName,
const std::string &  system,
Interval_t  interval 
)
virtualinherited

Definition at line 1606 of file ManagedMonitorToolBase.cxx.

1608 {
1609  MonGroup group( this, system, interval );
1610  return getHist( h, hName, group );
1611 }

◆ getHist() [3/6]

StatusCode ManagedMonitorToolBase::getHist ( TH1 *&  h,
const std::string &  hName,
const MonGroup &  group 
)
virtualinherited

Returns a TH1 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1598 of file ManagedMonitorToolBase.cxx.

1600 {
1601  std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1602  return m_THistSvc->getHist( streamName, h );
1603 }

◆ getHist() [4/6]

StatusCode ManagedMonitorToolBase::getHist ( TH1 *&  h,
const std::string &  hName,
const std::string &  system,
Interval_t  interval 
)
virtualinherited

Returns a TH1 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1588 of file ManagedMonitorToolBase.cxx.

1591 {
1592  MonGroup group( this, system, interval );
1593  return getHist( h, hName, group );
1594 }

◆ getHist() [5/6]

StatusCode ManagedMonitorToolBase::getHist ( TH2 *&  h,
const std::string &  hName,
const MonGroup &  group 
)
virtualinherited

Returns a TH2 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1640 of file ManagedMonitorToolBase.cxx.

1642 {
1643  std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1644  return m_THistSvc->getHist( streamName, h );
1645 }

◆ getHist() [6/6]

StatusCode ManagedMonitorToolBase::getHist ( TH2 *&  h,
const std::string &  hName,
const std::string &  system,
Interval_t  interval 
)
virtualinherited

Returns a TH2 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1630 of file ManagedMonitorToolBase.cxx.

1633 {
1634  MonGroup group( this, system, interval );
1635  return getHist( h, hName, group );
1636 }

◆ getNewStreamNameFcn()

ManagedMonitorToolBase::StreamNameFcn * ManagedMonitorToolBase::getNewStreamNameFcn ( ) const
protectedvirtualinherited

Definition at line 2387 of file ManagedMonitorToolBase.cxx.

2389 {
2390  StreamNameFcn* fcn(0);
2391 
2392  switch( m_environment ) {
2393  case AthenaMonManager::noOutput:
2394  fcn = new NoOutputStream();
2395  break;
2396  case AthenaMonManager::online:
2397  fcn = new OnlineStream();
2398  break;
2399  case AthenaMonManager::user:
2400  fcn = new DefaultStream( m_fileKey );
2401  break;
2402  case AthenaMonManager::tier0:
2403  case AthenaMonManager::tier0Raw:
2404  case AthenaMonManager::tier0ESD:
2405  case AthenaMonManager::AOD:
2406  case AthenaMonManager::altprod:
2407  default:
2408  fcn = new OfflineStream( m_fileKey, m_dataType, m_environment );
2409  }
2410 
2411  return fcn;
2412 }

◆ GetTimeFitFunc()

TF1 * TileRawChannelMonTool::GetTimeFitFunc ( TH2S *  hist2d)

Time Slope parameters for CIS runs.

Was done once using correlation between X and Y, but this is not capable of coping with

Definition at line 1909 of file TileRawChannelMonTool.cxx.

1909  {
1910  /*---------------------------------------------------------*/
1911 //the TF1 pointer is created with new, please use a delete after the parameters have been extracted!
1912  if (hist2d) {
1913  TProfile* prof = hist2d->ProfileX();
1914 
1915  if (prof) {
1916  TH1S hist("hist", "TMP Histo", prof->GetNbinsX(), prof->GetBinLowEdge(1), prof->GetBinLowEdge(prof->GetNbinsX() + 1));
1917  float lastbin = -99.;
1918  float lasti = 0.;
1919  float shift = 0.;
1920  for (int i = 1; i < prof->GetNbinsX() + 1; i++) {
1921  if (prof->GetBinError(i) > 1e-7) {
1922  if ((shift < 1.) && ((prof->GetBinContent(i) - (lastbin + (i - lasti))) < -10.)) { //allow only 1 shift and only of negative sign
1923  shift = 25.;
1924  }
1925  lasti = i;
1926  lastbin = prof->GetBinContent(i);
1927  hist.SetBinContent(i, prof->GetBinContent(i) + shift);
1928  hist.SetBinError(i, prof->GetBinError(i));
1929  }
1930  } // end for loop on the histogram bins
1931  TF1* polfun = new TF1("polfun", "pol1", 0., 25.); //remember to delete!
1932  hist.Fit("polfun", "NQ");
1933 
1934  polfun->SetParameter(0, polfun->GetParameter(0) - 25.); // shift by -25 ns to be consistent with previous definition
1935  delete prof; //not needed, but these profiles appears in the root files, even if they are not booked
1936  return polfun; //rember to delete!
1937  }
1938  }
1939  return 0;
1940 }

◆ getTMDBCellName()

std::string TilePaterMonTool::getTMDBCellName ( unsigned int  ros,
unsigned int  channel 
)
inlineprotectedinherited

Definition at line 255 of file TilePaterMonTool.h.

255  {
256  if (ros < 3) return m_TMDB_LB_cell_names[channel];
257  else return m_TMDB_EB_cell_names[channel];
258  };

◆ initialize()

StatusCode TileRawChannelMonTool::initialize ( )
overridevirtual

Reimplemented from TilePaterMonTool.

Definition at line 93 of file TileRawChannelMonTool.cxx.

95 {
96 
97  ATH_MSG_INFO("in initialize()");
98 
99  m_data = std::make_unique<Data>();
100 
101  CHECK(m_tileToolEmscale.retrieve());
102 
103  m_nEventsTileMon = 0;
104 
105  memset(m_data->m_timeCov, 0, sizeof(m_data->m_timeCov));
106  memset(m_data->m_timeCovCorr, 0, sizeof(m_data->m_timeCovCorr));
107 
108  CHECK(TilePaterMonTool::initialize());
109 
110  CHECK( detStore()->retrieve(m_tileInfo, m_infoName) );
111  if (m_tileInfo->ADCmax() == 4095) m_is12bit = true;
112 
113  m_dac2Charge[0] = 100.* 2.0 * 4.096 / double(m_tileInfo->ADCmax()); // 100 pF * 2 for legacy or 200 pF for demonstrator
114  m_dac2Charge[1] = 5.2 * 2.0 * 4.096 / double(m_tileInfo->ADCmax()); // use the same number 5.2 pF as in TileCisDefaultCalibTool
115  m_dac2Charge[2] = 5.2 * 4.096 / double(m_tileInfo->ADCmax()); // effective value of small capacitor is twice smaller for demonstrator
116 
117  CHECK( m_DQstatusKey.initialize() );
118 
119  return StatusCode::SUCCESS;
120 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

static const InterfaceID& IMonitorToolBase::interfaceID ( )
inlinestaticinherited

Definition at line 29 of file IMonitorToolBase.h.

29 { return IID_IMonitorToolBase; }

◆ intervalEnumToString()

std::string ManagedMonitorToolBase::intervalEnumToString ( Interval_t  interval)
staticinherited

Converts a LevelOfDetail_t to a string of the same name.

Converts a string to the corresponding LevelOfDetail_t. Converts a Interval_t to a string of the same name.

Definition at line 587 of file ManagedMonitorToolBase.cxx.

589 {
590  std::string str("file");
591 
592  switch( interval ) {
593  case all:
594  str = "all";
595  break;
596  case fill:
597  str = "fill";
598  break;
599  case run:
600  str = "run";
601  break;
602  case lowStat:
603  str = "lowStat";
604  break;
605  case medStat:
606  str = "medStat";
607  break;
608  case higStat:
609  str = "higStat";
610  break;
611  case lumiBlock:
612  str = "lumiBlock";
613  break;
614  case eventsBlock:
615  str = "eventsBlock";
616  break;
617  case file:
618  str = "file";
619  break;
620  default:
621  str = "unknown";
622  }
623 
624  return str;
625 }

◆ intervalStringToEnum()

ManagedMonitorToolBase::Interval_t ManagedMonitorToolBase::intervalStringToEnum ( const std::string &  str)
staticinherited

Converts a string to the corresponding Interval_t.

Definition at line 629 of file ManagedMonitorToolBase.cxx.

631 {
632  std::string lcstr( strToLower(str) );
633 
634  if( lcstr == "all" )
635  return all;
636  else if( lcstr == "fill" )
637  return fill;
638  else if( lcstr == "run" )
639  return run;
640  else if( lcstr == "lowStat" )
641  return lowStat;
642  else if( lcstr == "medStat" )
643  return medStat;
644  else if( lcstr == "higStat" )
645  return higStat;
646  else if( lcstr == "lumiBlock" )
647  return lumiBlock;
648  else if( lcstr == "eventsBlock" )
649  return eventsBlock;
650  else if( lcstr == "file" )
651  return file;
652 
653  if( Imp::s_svcLocator ) {
654  IMessageSvc* ms(0);
655  StatusCode sc = Imp::s_svcLocator.load()->service( "MessageSvc", ms, true );
656  if( sc.isSuccess() ) {
657  MsgStream log( ms, "ManagedMonitorToolBase::intervalStringToEnum()" );
658  log << MSG::WARNING << "Unknown ManagedMonitorToolBase::Interval_t \""
659  << str << "\", returning \"file\"" << endmsg;
660  }
661  }
662 
663  return file;
664 }

◆ isDisconnected()

bool TilePaterMonTool::isDisconnected ( int  ros,
int  drawer,
int  ch 
)
inlineprotectedinherited

Definition at line 281 of file TilePaterMonTool.h.

281  {
282 
283  if (ros < 3) { //LB, all standard. Channels 30,31,43 are disconnected
284  return m_chMapLB[ch];
285  } else {
286  if (((ros == 3) && (drawer == 14)) || ((ros == 4) && (drawer == 17))) {//EB, EBA15 and EBC18 are special
287  return m_chMapEBsp[ch];
288  } else {//EB standard module
289  return m_chMapEB[ch];
290  }
291  } //end if LB else EB
292 
293  }

◆ LaserFancyPlotting()

void TileRawChannelMonTool::LaserFancyPlotting ( int  ros,
int  drawer,
int  maxgain,
const std::string &  moduleName 
)

Definition at line 1974 of file TileRawChannelMonTool.cxx.

1974  {
1975  /*---------------------------------------------------------*/
1976 
1977  ATH_MSG_DEBUG("in LaserFancyPlotting...");
1978 
1979  //TCanvas * Can = new TCanvas("fit_amp","fit_amp",402*maxgain,588);
1980  bool do_plots = m_savePng || m_savePs || m_saveSvg;
1981  TCanvas * Can = NULL;
1982  if (do_plots) {
1983  Can = new TCanvas("fit_amp", "fit_amp", 402 * maxgain, 735); //Lukas
1984  //Can->Divide(maxgain, 4);
1985  Can->Divide(maxgain, 5); //Lukas
1986  gStyle->SetOptStat(0);
1987  gStyle->SetTitleFontSize(0.1);
1988  }
1989  TLine *line = new TLine();
1990  line->SetLineWidth(2);
1991  line->SetLineStyle(7);
1992  line->SetLineColor(3);
1993 
1994  float ms = (m_bigain) ? 0.75 : 1.0; // marker size
1995 
1996  double maxy[6] = { 5.0, 0.5, 1.0, 0.05, 25.0, 25.0 };
1997  double miny[6] = { -5.0, -0.5, 0.0, 0.0, -25.0, -25.0 };
1998 
1999  // Mean value
2000  TH1F* final_empty[2]; //adc, type
2001  TH1F* final_odd[2]; //adc, type
2002  TH1F* final_even[2]; //adc, type
2003 
2004  // define TH1 that will contain the plots of variance/mean
2005  TH1F* pmtGain_empty[2];
2006  TH1F* pmtGain_odd[2];
2007  TH1F* pmtGain_even[2];
2008 
2009  for (int g = 0; g < 2; g++) {
2010 
2011  std::ostringstream hn;
2012  hn << "empty_" << g;
2013  final_empty[g] = new TH1F(hn.str().c_str(), m_data->m_finalHist1[ros][drawer][g][0][0]->GetTitle(), 48, 0, 48);
2014  hn.str("");
2015  hn << "odd_" << g;
2016  final_odd[g] = new TH1F(hn.str().c_str(), m_data->m_finalHist1[ros][drawer][g][0][0]->GetTitle(), 48, 0, 48);
2017  hn.str("");
2018  hn << "even_" << g;
2019  final_even[g] = new TH1F(hn.str().c_str(), m_data->m_finalHist1[ros][drawer][g][0][0]->GetTitle(), 48, 0, 48);
2020 
2021  //---- Histograms for the ratio Var/Mean
2022  // titles...
2023  std::string title;
2024  const char* gain[2] = { "low", "high" };
2025  const char* moduleNames[5] = { "AUX", "LBA", "LBC", "EBA", "EBC" };
2026  if (drawer < 10)
2027  title = Form("%s0%i %s gain, Variance/Mean", moduleNames[ros], drawer + 1, gain[g]);
2028  else
2029  title = Form("%s%i %s gain, Variance/Mean", moduleNames[ros], drawer + 1, gain[g]);
2030 
2031  std::ostringstream sStr;
2032  std::string subDir = "Summary";
2033  sStr.str("");
2034  sStr << moduleNames[ros] << std::setfill('0') << std::setw(2) << drawer + 1 << std::setfill(' ') << gain[g] << "_pmtGain_empty";
2035  std::string histName = sStr.str();
2036  pmtGain_empty[g] = book1F(subDir, histName, title, 48, 0.0, 48.0);
2037  // pmtGain_empty[g]= new TH1F(Form("pmtGain_empty_%i", g),title.c_str(), 48,0,48);
2038 
2039  sStr.str("");
2040  sStr << moduleNames[ros] << std::setfill('0') << std::setw(2) << drawer + 1 << std::setfill(' ') << gain[g] << "_pmtGain_odd";
2041  histName = sStr.str();
2042  pmtGain_odd[g] = book1F(subDir, histName, title, 48, 0.0, 48.0);
2043  // pmtGain_odd[g] = new TH1F(Form("pmtGain_odd_%i", g), title.c_str(), 48,0,48);
2044 
2045  sStr.str("");
2046  sStr << moduleNames[ros] << std::setfill('0') << std::setw(2) << drawer + 1 << std::setfill(' ') << gain[g] << "_pmtGain_even";
2047  histName = sStr.str();
2048  pmtGain_even[g] = book1F(subDir, histName, title, 48, 0.0, 48.0);
2049  //pmtGain_even[g] = new TH1F(Form("pmtGain_even_%i", g), title.c_str(), 48,0,48);
2050  }
2051 
2052  // loop over the 2 gains values
2053  for (int adc = 0; adc < maxgain; ++adc) {
2054 
2055  double max0 = m_data->m_finalHist1[ros][drawer][adc][0][0]->GetMaximum();
2056  //double max1 = final_hist1[ros][drawer][adc][0][1]->GetMaximum();
2057  //double max2 = final_hist1[ros][drawer][adc][0][2]->GetMaximum();
2058  double max3 = m_data->m_finalHist1[ros][drawer][adc][0][3]->GetMaximum();
2059  double max4 = m_data->m_finalHist1[ros][drawer][adc][0][4]->GetMaximum(); //Lukas
2060  double min0 = m_data->m_finalHist1[ros][drawer][adc][0][0]->GetMinimum();
2061  //double min1 = final_hist1[ros][drawer][adc][0][1]->GetMinimum();
2062  //double min2 = final_hist1[ros][drawer][adc][0][2]->GetMinimum();
2063  double min3 = m_data->m_finalHist1[ros][drawer][adc][0][3]->GetMinimum();
2064  double min4 = m_data->m_finalHist1[ros][drawer][adc][0][4]->GetMinimum(); //Lukas
2065 
2066  if (max0 > 0.) {
2067  final_empty[adc]->SetMaximum(1.05 * max0);
2068  } else {
2069  final_empty[adc]->SetMaximum(0.);
2070  }
2071 
2072  if ((max0 - min0) > 0) {
2073  final_empty[adc]->SetMinimum(max0 - 1.05 * (max0 - min0));
2074  }
2075 
2076  // Select pad 1 and 2
2077  TVirtualPad * pad;
2078  if (do_plots) {
2079  pad = Can->cd(adc + 1);
2080  pad->SetTopMargin(0.15);
2081  pad->SetGridx();
2082  }
2083 
2084  // bin=1 corresponds to the first pmt (#0)
2085  double Kapa = 1.30e-3;
2086  for (int ch = 0; ch < 48; ++ch) {
2087  if (isDisconnected(ros, drawer, ch)) {
2088  final_empty[adc]->SetBinContent(ch + 1, m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinContent(ch + 1) + 0.01);
2089  final_empty[adc]->SetBinError(ch + 1, m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinError(ch + 1) + 0.01);
2090  pmtGain_empty[adc]->SetBinContent(ch + 1, 0.01);
2091  pmtGain_empty[adc]->SetBinError(ch + 1, 0.01);
2092  }
2093  // connected channels
2094  else {
2095  double mean = m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinContent(ch + 1);
2096  double rms = m_data->m_finalHist1[ros][drawer][adc][0][1]->GetBinContent(ch + 1);
2097  double dmean = m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinError(ch + 1);
2098  double drms = m_data->m_finalHist1[ros][drawer][adc][0][1]->GetBinError(ch + 1);
2099  // even pmts
2100  int pmt = abs(m_cabling->channel2hole(ros, ch)); //extra safe: abs should not be necessary, because channels are connected.
2101  if (pmt % 2 == 0) {
2102  final_even[adc]->SetBinContent(ch + 1, m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinContent(ch + 1) + 0.001);
2103  final_even[adc]->SetBinError(ch + 1, m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinError(ch + 1) + 0.001);
2104 
2105  // if (bin!=0)
2106  // log<<MSG::DEBUG<<"["<<ros<<"]["<<drawer+1<<"]["<<adc<<"]["<< bin <<"] : mean="
2107  // << mean <<", var="<< rms*rms<<"\tVar/mean(corrected)="<< (rms*rms/mean) - Kapa*mean <<endreq;
2108  if (mean > 10e-3) {
2109  pmtGain_even[adc]->SetBinContent(ch + 1, (rms * rms / mean) - Kapa * mean);
2110  pmtGain_even[adc]->SetBinError(ch + 1, (rms * rms / mean) * sqrt((2 * drms / rms) * (2 * drms / rms) + (dmean / mean) * (dmean / mean)));
2111  } else {
2112  pmtGain_even[adc]->SetBinContent(ch + 1, -0.5);
2113  pmtGain_even[adc]->SetBinError(ch + 1, 0.001);
2114  }
2115  }
2116  // odd pmts
2117  else {
2118  final_odd[adc]->SetBinContent(ch + 1, m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinContent(ch + 1) + 0.001);
2119  final_odd[adc]->SetBinError(ch + 1, m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinError(ch + 1) + 0.001);
2120 
2121  // log<<MSG::DEBUG<<"["<<ros<<"]["<<drawer+1<<"]["<<adc<<"]["<< bin <<"] : mean="
2122  // << mean <<", var="<< rms*rms<<"\tVar/mean(corrected)="<< (rms*rms/mean) - Kapa*mean <<endreq;
2123  if (mean > 10e-3) {
2124  pmtGain_odd[adc]->SetBinContent(ch + 1, (rms * rms / mean) - Kapa * mean);
2125  pmtGain_odd[adc]->SetBinError(ch + 1, (rms * rms / mean) * sqrt((2 * drms / rms) * (2 * drms / rms) + (dmean / mean) * (dmean / mean)));
2126  } else {
2127  pmtGain_odd[adc]->SetBinContent(ch + 1, -0.5);
2128  pmtGain_odd[adc]->SetBinError(ch + 1, 0.001);
2129  }
2130  }
2131  }
2132  }
2133 
2134  // we are in pads 1 and 2
2135  // retrieve the max and min of the plots
2136  double max = pmtGain_odd[adc]->GetMaximum();
2137  if (pmtGain_even[adc]->GetMaximum() > max) max = 1.05 * pmtGain_even[adc]->GetMaximum();
2138  double min = pmtGain_odd[adc]->GetMinimum();
2139  if (pmtGain_even[adc]->GetMinimum() < min) min = pmtGain_even[adc]->GetMinimum() - 0.05 * fabs(pmtGain_even[adc]->GetMinimum());
2140  if (max < 0.20) max = 0.20;
2141  if (min > -0.10) min = -0.10;
2142  //log<<MSG::INFO<<"Min and Max : "<< min <<"; "<< max <<enreq;
2143  pmtGain_empty[adc]->SetMarkerStyle(21);
2144  pmtGain_even[adc]->SetMarkerStyle(22);
2145  pmtGain_odd[adc]->SetMarkerStyle(23);
2146  pmtGain_empty[adc]->SetMarkerSize(ms);
2147  pmtGain_even[adc]->SetMarkerSize(ms);
2148  pmtGain_odd[adc]->SetMarkerSize(ms);
2149  pmtGain_empty[adc]->SetLabelSize(0.08, "X");
2150  pmtGain_empty[adc]->SetLabelSize(0.08, "Y");
2151  pmtGain_even[adc]->SetMarkerColor(2);
2152  pmtGain_odd[adc]->SetMarkerColor(4);
2153  pmtGain_empty[adc]->GetYaxis()->SetRangeUser(min, max);
2154  if (do_plots) {
2155  pmtGain_empty[adc]->Draw("e");
2156  pmtGain_even[adc]->Draw("same,e");
2157  pmtGain_odd[adc]->Draw("same,e");
2158  line->DrawLine(0, -0.01, 48, -0.01);
2159  line->DrawLine(0, 0.15, 48, 0.15);
2160 
2161  // Select pads 3 and 4
2162  pad = Can->cd(maxgain + adc + 1);
2163  pad->SetTopMargin(0.15);
2164  pad->SetGridx();
2165  }
2166 
2167  // Plot the evolution of the mean vs #pmt number (with different colours for odd and even pmts)
2168  if (max0 < 0.9 * maxy[adc]) final_empty[adc]->SetMaximum(maxy[adc]);
2169  if (min0 > miny[adc] + 0.1 * TMath::Abs(miny[adc])) final_empty[adc]->SetMinimum(miny[adc]);
2170 
2171  final_empty[adc]->SetMarkerStyle(21);
2172  final_even[adc]->SetMarkerStyle(22);
2173  final_odd[adc]->SetMarkerStyle(23);
2174  final_empty[adc]->SetMarkerSize(ms);
2175  final_even[adc]->SetMarkerSize(ms);
2176  final_odd[adc]->SetMarkerSize(ms);
2177  final_empty[adc]->SetLabelSize(0.08, "X");
2178  final_empty[adc]->SetLabelSize(0.08, "Y");
2179  final_even[adc]->SetMarkerColor(2);
2180  final_odd[adc]->SetMarkerColor(4);
2181  if (do_plots) {
2182  final_empty[adc]->Draw("e");
2183  final_even[adc]->Draw("same,e");
2184  final_odd[adc]->Draw("same,e");
2185 
2186  // Select pads 5 and 6 and plot the RMS for each pmt
2187  pad = Can->cd(2 * maxgain + adc + 1);
2188  pad->SetTopMargin(0.15);
2189  pad->SetGridx();
2190  }
2191 
2192  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMarkerStyle(21);
2193  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMarkerSize(ms);
2194  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetLabelSize(0.08, "X");
2195  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetLabelSize(0.08, "Y");
2196  if (do_plots) m_data->m_finalHist1[ros][drawer][adc][0][1]->Draw("P0");
2197 
2198  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMaximum(m_data->m_finalHist1[ros][drawer][adc][0][1]->GetMaximum());
2199  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMinimum(m_data->m_finalHist1[ros][drawer][adc][0][1]->GetMinimum());
2200  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMarkerStyle(25);
2201  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMarkerSize(ms);
2202  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMarkerColor(4);
2203  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetLabelSize(0.08, "X");
2204  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetLabelSize(0.08, "Y");
2205  if (do_plots) m_data->m_finalHist1[ros][drawer][adc][0][2]->Draw("sameP0");
2206 
2207  // Select pads 7 and 8
2208  if (do_plots) {
2209  pad = Can->cd(3 * maxgain + adc + 1);
2210  pad->SetTopMargin(0.15);
2211  pad->SetGridx();
2212  }
2213 
2214  if (max3 < 0.9 * maxy[4 + adc]) m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMaximum(maxy[4 + adc]);
2215  if (min3 > miny[4 + adc] + 0.1 * TMath::Abs(miny[4 + adc])) m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMinimum(miny[4 + adc]);
2216 
2217  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMarkerStyle(21);
2218  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMarkerSize(ms);
2219  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetLabelSize(0.08, "X");
2220  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetLabelSize(0.08, "Y");
2221  m_data->m_finalHist1[ros][drawer][adc][0][3]->Draw("E0");
2222 
2223  //Lukas
2224  // Select pads 9 and 10
2225  if (do_plots) {
2226  pad = Can->cd(4 * maxgain + adc + 1);
2227  pad->SetTopMargin(0.15);
2228  pad->SetGridx();
2229  }
2230 
2231  if (max4 < 0.9 * maxy[4 + adc]) m_data->m_finalHist1[ros][drawer][adc][0][4]->SetMaximum(maxy[4 + adc]);
2232  if (min4 > miny[4 + adc] + 0.1 * TMath::Abs(miny[4 + adc])) m_data->m_finalHist1[ros][drawer][adc][0][4]->SetMinimum(miny[4 + adc]);
2233 
2234  m_data->m_finalHist1[ros][drawer][adc][0][4]->SetMarkerStyle(21);
2235  m_data->m_finalHist1[ros][drawer][adc][0][4]->SetMarkerSize(ms);
2236  m_data->m_finalHist1[ros][drawer][adc][0][4]->SetLabelSize(0.08, "X");
2237  m_data->m_finalHist1[ros][drawer][adc][0][4]->SetLabelSize(0.08, "Y");
2238  if (do_plots) m_data->m_finalHist1[ros][drawer][adc][0][4]->Draw("E0");
2239  //Lukas
2240 
2241  } //end of loop over gain
2242 
2243  if (m_savePng) {
2244  Can->Print(TString(moduleName + "_fit_amp.png"), "png");
2245  }
2246  if (m_savePs) {
2247  Can->Print(TString(moduleName + "_fit_amp.ps"), "ps");
2248  }
2249  if (m_saveSvg) {
2250  Can->Print(TString(moduleName + "_fit_amp.svg"), "svg");
2251  }
2252  //Can->Print(TString(moduleName+"_fit_amp.cxx"),"cxx");
2253  if (do_plots) delete Can;
2254  delete line;
2255  for (int g = 0; g < 2; g++) {
2256  delete final_empty[g];
2257  delete final_odd[g];
2258  delete final_even[g];
2259  //delete pmtGain_empty[g];
2260  //delete pmtGain_odd[g];
2261  //delete pmtGain_even[g];
2262  }
2263 }

◆ lbAverageInteractionsPerCrossing()

float ManagedMonitorToolBase::lbAverageInteractionsPerCrossing ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Average mu, i.e.

<mu>

Definition at line 1923 of file ManagedMonitorToolBase.cxx.

1925 {
1926  if (!m_lumiDataKey.empty()) {
1927  SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1928  return lumi->lbAverageInteractionsPerCrossing();
1929  } else {
1930  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageInteractionsPerCrossing() can't work properly! ");
1931  ATH_MSG_DEBUG("Warning: lbAverageInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1932  return -1.0;
1933  }
1934  // not reached
1935 }

◆ lbAverageLivefraction()

float ManagedMonitorToolBase::lbAverageLivefraction ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Average luminosity livefraction.

Definition at line 1992 of file ManagedMonitorToolBase.cxx.

1994 {
1995  if (m_environment == AthenaMonManager::online)
1996  return 1.0;
1997 
1998  if (!m_trigLiveFractionDataKey.empty()) {
1999  SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
2000  return live->lbAverageLiveFraction();
2001  } else {
2002  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLivefraction() can't work properly! ");
2003  ATH_MSG_DEBUG("Warning: lbAverageLivefraction() - luminosity not availble (i.e. EnableLumi = False)");
2004  return -1.0;
2005  }
2006  // not reached
2007 }

◆ lbAverageLuminosity()

float ManagedMonitorToolBase::lbAverageLuminosity ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)

Definition at line 1959 of file ManagedMonitorToolBase.cxx.

1961 {
1962  if (!m_lumiDataKey.empty()) {
1963  SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1964  return lumi->lbAverageLuminosity();
1965  } else {
1966  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLuminosity() can't work properly! ");
1967  ATH_MSG_DEBUG("Warning: lbAverageLuminosity() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1968  return -1.0;
1969  }
1970  // not reached
1971 }

◆ lbDuration()

double ManagedMonitorToolBase::lbDuration ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Luminosity block time (in seconds)

Definition at line 2046 of file ManagedMonitorToolBase.cxx.

2048 {
2049  if ( m_environment == AthenaMonManager::online ) {
2050  return m_defaultLBDuration;
2051  }
2052  if (!m_lbDurationDataKey.empty()) {
2053  SG::ReadCondHandle<LBDurationCondData> dur (m_lbDurationDataKey, ctx);
2054  return dur->lbDuration();
2055  } else {
2056  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbDuration() can't work properly! ");
2057  ATH_MSG_DEBUG("Warning: lbDuration() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
2058  return m_defaultLBDuration;
2059  }
2060  // not reached
2061 }

◆ lbInteractionsPerCrossing()

float ManagedMonitorToolBase::lbInteractionsPerCrossing ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Instantaneous number of interactions, i.e.

mu

Definition at line 1939 of file ManagedMonitorToolBase.cxx.

1941 {
1942  if (!m_lumiDataKey.empty()) {
1943  SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1944  float muToLumi = lumi->muToLumi();
1945  if (muToLumi > 0) {
1946  return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id()) / muToLumi;
1947  }
1948  return 0;
1949  } else {
1950  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbInteractionsPerCrossing() can't work properly! ");
1951  ATH_MSG_DEBUG("Warning: lbInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1952  return -1.0;
1953  }
1954  // not reached
1955 }

◆ lbLuminosityPerBCID()

float ManagedMonitorToolBase::lbLuminosityPerBCID ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Instantaneous luminosity.

Definition at line 1975 of file ManagedMonitorToolBase.cxx.

1977 {
1978  if (!m_lumiDataKey.empty()) {
1979  SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1980  return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id());
1981  } else {
1982  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLuminosityPerBCID() can't work properly! ");
1983  ATH_MSG_DEBUG("Warning: lbLuminosityPerBCID() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1984  return -1.0;
1985  }
1986  // not reached
1987 }

◆ lbLumiWeight()

double ManagedMonitorToolBase::lbLumiWeight ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Average Integrated Luminosity Live Fraction.

Definition at line 2030 of file ManagedMonitorToolBase.cxx.

2032 {
2033  if (!m_lumiDataKey.empty()) {
2034  return (lbAverageLuminosity(ctx)*lbDuration(ctx))*lbAverageLivefraction(ctx);
2035  } else{
2036  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLumiWeight() can't work properly! ");
2037  ATH_MSG_DEBUG("Warning: lbLumiWeight() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
2038  return -1.0;
2039  }
2040  // not reached
2041 }

◆ livefractionPerBCID()

float ManagedMonitorToolBase::livefractionPerBCID ( const EventContext &  ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Livefraction per bunch crossing ID.

Definition at line 2011 of file ManagedMonitorToolBase.cxx.

2013 {
2014  if (m_environment == AthenaMonManager::online)
2015  return 1.0;
2016 
2017  if (!m_trigLiveFractionDataKey.empty()) {
2018  SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
2019  return live->l1LiveFractionVector().at (ctx.eventID().bunch_crossing_id());
2020  } else {
2021  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! livefractionPerBCID() can't work properly! ");
2022  ATH_MSG_DEBUG("Warning: livefractionPerBCID() - luminosity retrieved available (i.e. EnableLumi = False)");
2023  return -1.0;
2024  }
2025  // not reached
2026 }

◆ MMTB_DEPRECATED() [1/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfEventsBlock  )
inherited

◆ MMTB_DEPRECATED() [2/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLowStat  )
inherited

◆ MMTB_DEPRECATED() [3/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLumiBlock  )
inherited

◆ MMTB_DEPRECATED() [4/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfRun  )
inherited

◆ MMTB_DEPRECATED() [5/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newEventsBlock  )
inherited

◆ MMTB_DEPRECATED() [6/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newHigStatInterval  )
inherited

◆ MMTB_DEPRECATED() [7/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStat  )
inherited

◆ MMTB_DEPRECATED() [8/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStatInterval  )
inherited

◆ MMTB_DEPRECATED() [9/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLumiBlock  )
inherited

◆ MMTB_DEPRECATED() [10/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newMedStatInterval  )
inherited

◆ MMTB_DEPRECATED() [11/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newRun  )
inherited

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ newEventsBlockFlag()

bool ManagedMonitorToolBase::newEventsBlockFlag ( ) const
inlineprotectedinherited

Definition at line 855 of file ManagedMonitorToolBase.h.

855 { return m_newEventsBlock; }

◆ newHigStatIntervalFlag()

bool ManagedMonitorToolBase::newHigStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 851 of file ManagedMonitorToolBase.h.

851 { return m_newHigStatInterval; }

◆ newLowStatFlag()

bool ManagedMonitorToolBase::newLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 852 of file ManagedMonitorToolBase.h.

852 { return m_newLowStat; }

◆ newLowStatIntervalFlag()

bool ManagedMonitorToolBase::newLowStatIntervalFlag ( ) const
inlineprotectedinherited

Flag functions allowing clients to determine when to book new and process old histograms; values are updated by fillHists() based on counting lumiBlocks, and are correctly set when fillHistograms(), bookHistograms() and procHistograms() are called.

Definition at line 849 of file ManagedMonitorToolBase.h.

849 { return m_newLowStatInterval; }

◆ newLumiBlockFlag()

bool ManagedMonitorToolBase::newLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 853 of file ManagedMonitorToolBase.h.

853 { return m_newLumiBlock; }

◆ newMedStatIntervalFlag()

bool ManagedMonitorToolBase::newMedStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 850 of file ManagedMonitorToolBase.h.

850 { return m_newMedStatInterval; }

◆ newRunFlag()

bool ManagedMonitorToolBase::newRunFlag ( ) const
inlineprotectedinherited

Definition at line 854 of file ManagedMonitorToolBase.h.

854 { return m_newRun; }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ parseList()

StatusCode ManagedMonitorToolBase::parseList ( const std::string &  line,
std::vector< std::string > &  result 
)
protectedinherited

Definition at line 2343 of file ManagedMonitorToolBase.cxx.

2344  {
2345  std::string item;
2346  std::stringstream ss(line);
2347 
2348  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "ManagedMonitorToolBase::parseList:";
2349 
2350  while ( std::getline(ss, item, ',') ) {
2351  std::stringstream iss(item); // remove
2352  iss >> item; // whitespace
2353  if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " " << item;
2354  result.push_back(item);
2355  }
2356 
2357  msg(MSG::DEBUG) << endmsg;
2358  return StatusCode::SUCCESS;
2359 }

◆ preSelector()

bool ManagedMonitorToolBase::preSelector ( )
virtualinherited

Implements IMonitorToolBase.

Definition at line 1911 of file ManagedMonitorToolBase.cxx.

1913 {
1914  if( m_preScaleProp > 1 ) {
1915  return ( (m_nEvents % m_preScaleProp) == 1 );
1916  }
1917  return true;
1918 }

◆ procHistograms()

StatusCode ManagedMonitorToolBase::procHistograms ( )
virtualinherited

An inheriting class should either override this function or finalHists().

Reimplemented in SCTHitEffMonTool, SCTHitsNoiseMonTool, SCTErrMonTool, SCTTracksMonTool, SCTLorentzMonTool, egammaMonToolBase, MuonPhysValMonitoring::MuonPhysValMonitoringTool, AFPHitsMonitorTool, LArCellMonTool, MuonDQA::MuonEventInfoMonTool, DQTDataFlowMonTool, TileCalCellMonTool, ActsTrk::PhysValTool, PhysValSecVtx, LUCID_HitsMoniTool, ZeeTaPMonTool, LVL1::CalorimeterL1CaloMon, LVL1::L1CaloCTPMon, LVL1::L1CaloLevel2Mon, LVL1::L1CaloPMTScoresMon, MdtRawDataValAlg, CscCalibMonToolBase, DQTNonCollBkg_ZDC, InDetGlobalTrackMonTool, TRT_Electron_Monitoring_Tool, InDetGlobalHitsMonTool, JetTagMonitoring, InDetPhysValMonitoringTool, EgammaPhysValMonitoring::EgammaPhysValMonitoringTool, TRT_Monitoring_Tool, METMonTool, MissingEtDQA::PhysValMET, LVL1::L1CaloL1TopoMon, JetTagDQA::PhysValBTag, CaloTowerVecMon, DQTGlobalWZFinderTool, CSCSegmValAlg, PhysVal::PhysValExample, TopPhysVal::TopPhysValMonitoring, DataQualityFatherMonTool, ZeeValidation::ZeeValidationMonitoringTool, CaloClusterVecMon, RpcLv1RawDataValAlg, CaloTransverseBalanceVecMon, DQTDetSynchMonTool, InDetTrackPerfMonTool, DQTMuonIDTrackTool, InDetGlobalBeamSpotMonTool, IDPerfMonWenu, IDPerfMonZee, TrackCaloClusterRecValidationTool, CscClusterValAlg, MdtVsTgcRawDataValAlg, InDetGlobalErrorMonTool, JetMonitoringTool, TileCellNoiseMonTool, AFPTechnicalMonitorTool, PhysValTau, PhysValFE, ManagedMonitorToolTest, DiMuMon, CscPrdValAlg, CscRdoValAlg, HIMonitoringEventShapeTool, IDPerfMonKshort, HIMonitoringZdcTool, HIMonitoringElectronsTool, HIMonitoringPhotonsTool, and HIMonitoringMuonsTool.

Definition at line 1422 of file ManagedMonitorToolBase.cxx.

1424 {
1425  if( m_endOfEventsBlock ) { }
1426  if( m_endOfLowStat ) { }
1427  if( m_endOfLumiBlock ) { }
1428  if( m_endOfRun) { }
1429 
1430  return StatusCode::SUCCESS;
1431 }

◆ rangeErrorBar()

void TileRawChannelMonTool::rangeErrorBar ( double &  xmin,
double &  max,
double  mean 
)

This method was bing used in 2006 for calculating the error bar length It is off by default, but it can be switched on by the usage of the property m_useratioerror=false This method set the error bar long as the interval from ean to the extreeme value of the sample distribution. If the extreeme value is below the threhold, then the error bar length is set to 0.

Definition at line 1833 of file TileRawChannelMonTool.cxx.

1833  {
1834  /*---------------------------------------------------------*/
1841  if (m_DownLimit < mean && mean < m_UpLimit) {
1842  if (xmin > m_DownLimit) xmin = mean;
1843  if (xmax < m_UpLimit) xmax = mean;
1844  }
1845 
1846 }

◆ ratioErrorBar()

void TileRawChannelMonTool::ratioErrorBar ( TH1S *  hist,
double &  xmin,
double &  xmax,
double  mean 
)

This method calculates the error bars of amp vs Q summary plots. The error bar depends on the percentage of events outside a certain limit. If the percentage of events outside a certain limit is below the threshold, then the error bar length is set to 0. There are 3 different thresholds and a lower and an upper limit. Threshold, limits and the error bar method usage are all settable by jo The are 3 different error bars lenghts for low, medium and high severity. IMPORTANT: In case the mean of the distribution is outside the limits, then the error bars are calculated as with rangeErrorBar method, as it won't have much sense calculating it in this way.

LF: If mean <0.7 or mean>1.3, we leave the range as error bar, as the ratio Error bar won't have any sense

Definition at line 1849 of file TileRawChannelMonTool.cxx.

1849  {
1850  /*---------------------------------------------------------*/
1861  if (m_DownLimit < mean && mean < m_UpLimit) {
1862 
1863  if (xmin > m_DownLimit) {
1864  xmin = mean;
1865  } else {
1866  int lo_thrbin = hist->FindBin(m_DownLimit); //
1867  double integral = hist->Integral(0, lo_thrbin); // we also want underflow, in case... Integral() is calculated including the contents of both limiting bins. As 0.7 falls in the middle of a bin, we are calculating the integral by excess
1868  double ratio = integral / (hist->GetEntries());
1869  if (ratio > m_hi_IntegralLimit) {
1870  xmin = mean - 1.05;
1871  } //larger error bar
1872  else if (ratio > m_med_IntegralLimit) {
1873  xmin = mean - 0.7;
1874  } //intermediate error bar
1875  else if (ratio > m_lo_IntegralLimit) {
1876  xmin = mean - 0.35;
1877  } //small error bar
1878  else {
1879  xmin = mean;
1880  }
1881  }
1882 
1883  if (xmax < m_UpLimit) {
1884  xmax = mean;
1885  } else {
1886  int hi_thrbin = hist->FindBin(m_UpLimit);
1887  double integral = hist->Integral(hi_thrbin, (hist->GetNbinsX() + 1)); //we also want overflow, in case... Integral() is calculated including the contents of both limiting bins. As 1.3 falls in the middle of a bin, we are calculating the integral by excess.
1888  double ratio = integral / (hist->GetEntries());
1889  if (ratio > m_hi_IntegralLimit) {
1890  xmax = mean + 1.05;
1891  } //larger error bar
1892  else if (ratio > m_med_IntegralLimit) {
1893  xmax = mean + 0.7;
1894  } //intermediate error bar
1895  else if (ratio > m_lo_IntegralLimit) {
1896  xmax = mean + 0.35;
1897  } //small error bar
1898  else {
1899  xmax = mean;
1900  }
1901  }
1902  }
1904 }

◆ regEfficiency()

StatusCode ManagedMonitorToolBase::regEfficiency ( TEfficiency *  e,
const MonGroup &  group 
)
virtualinherited

Registers a TEfficiency to be included in the output stream using logical parameters that describe the plot.

Definition at line 1648 of file ManagedMonitorToolBase.cxx.

1648  {
1649  if (!e)
1650  return StatusCode::FAILURE;
1651 
1652  TGraph* g = reinterpret_cast<TGraph*>(e);
1653  std::string name = e->GetName();
1654 
1655  // MANAGED
1656  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1657  // warn about not using merge algorithms
1658  if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1659  ATH_MSG_WARNING("HEY! Attempting to register "<<name<<" as a per-LB histogram, but not setting the merge algorithm! Use \"merge\", at least.");
1660  }
1661  // add the efficiency to rebooking vector
1662  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1663  m_templateEfficiencies[group.interval()].push_back( MgmtParams<TEfficiency>(e, group) );
1664  } else {
1665  ATH_MSG_ERROR("Attempt to book managed graph " << name << " with invalid interval type " << intervalEnumToString(group.interval()));
1666  return StatusCode::FAILURE;
1667  }
1668 
1669  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1670  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1671  registerMetadata(streamName, name, group).ignore();
1672  return m_THistSvc->regGraph( streamName, g );
1673  } else {
1674  // UNMANAGED
1675  if( m_manager != 0 ) {
1676  std::string genericName = NoOutputStream().getStreamName( this, group, name );
1677  m_manager->writeAndDelete( genericName );
1678  m_manager->passOwnership( e, genericName );
1679  }
1680 
1681  std::string streamName = streamNameFunction()->getStreamName( this, group, name, false );
1682  StatusCode smd = registerMetadata(streamName, name, group);
1683  if (smd != StatusCode::SUCCESS)
1684  return StatusCode::FAILURE;
1685 
1686  return m_THistSvc->regGraph( streamName, g );
1687  }
1688 }

◆ regGraph() [1/5]

template<typename T >
void TilePaterMonTool::regGraph ( const std::string &  subDir,
T *  graph,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
const std::string &  trigChain = "",
const std::string &  mergeAlgo = "" 
)
protectedinherited

Definition at line 65 of file TilePaterMonTool.cxx.

66 {
67 
68  std::string path(m_path);
69  if (!subDir.empty()) path += ("/" + subDir);
70 
71  if(ManagedMonitorToolBase::regGraph(graph, path, interval, attribute, trigChain, mergeAlgo).isFailure()) {
72  ATH_MSG_WARNING( "Could not register Graph : " << path + "/" + graph->GetName() );
73  }
74 }

◆ regGraph() [2/5]

StatusCode ManagedMonitorToolBase::regGraph
protectedinherited

Registers a TGraph to be included in the output stream using logical parameters that describe the graph.

Definition at line 567 of file ManagedMonitorToolBase.cxx.

1704 {
1705  if (!g)
1706  return StatusCode::FAILURE;
1707 
1708  // This part of the code deals with MANAGED type
1709  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1710  // Create an unmanaged group based on the original MonGroup instance passed
1711  // This is needed because managed graph is presented as a number of unmanaged
1712  // graphs (one per each interval)
1713  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1714 
1715  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1716  m_templateGraphs[group.interval()].push_back( MgmtParams<TGraph>(g, group_unmanaged) );
1717  } else {
1718  ATH_MSG_ERROR("Attempt to book managed graph " << g->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1719  return StatusCode::FAILURE;
1720  }
1721 
1722  std::string name = g->GetName();
1723  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1724  registerMetadata(streamName, name, group).ignore();
1725  return m_THistSvc->regGraph( streamName, g );
1726  //return m_THistSvc->regGraph( streamName );
1727  }
1728 
1729  // This part of the code deals with UNMANAGED type
1730  std::string gName = g->GetName();
1731 
1732  if( m_manager != 0 ) {
1733  std::string genericName = NoOutputStream().getStreamName( this, group, gName );
1734  m_manager->writeAndDelete( genericName );
1735  m_manager->passOwnership( g, genericName );
1736  }
1737 
1738  std::string streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1739 
1740  StatusCode smd = registerMetadata(streamName, gName, group);
1741  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1742 
1743  return m_THistSvc->regGraph( streamName, g );
1744 }

◆ regGraph() [3/5]

StatusCode ManagedMonitorToolBase::regGraph ( TGraph *  g,
const MonGroup &  group 
)
virtualinherited

Registers a TGraph to be included in the output stream using logical parameters that describe the graph.

Definition at line 1702 of file ManagedMonitorToolBase.cxx.

1704 {
1705  if (!g)
1706  return StatusCode::FAILURE;
1707 
1708  // This part of the code deals with MANAGED type
1709  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1710  // Create an unmanaged group based on the original MonGroup instance passed
1711  // This is needed because managed graph is presented as a number of unmanaged
1712  // graphs (one per each interval)
1713  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1714 
1715  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1716  m_templateGraphs[group.interval()].push_back( MgmtParams<TGraph>(g, group_unmanaged) );
1717  } else {
1718  ATH_MSG_ERROR("Attempt to book managed graph " << g->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1719  return StatusCode::FAILURE;
1720  }
1721 
1722  std::string name = g->GetName();
1723  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1724  registerMetadata(streamName, name, group).ignore();
1725  return m_THistSvc->regGraph( streamName, g );
1726  //return m_THistSvc->regGraph( streamName );
1727  }
1728 
1729  // This part of the code deals with UNMANAGED type
1730  std::string gName = g->GetName();
1731 
1732  if( m_manager != 0 ) {
1733  std::string genericName = NoOutputStream().getStreamName( this, group, gName );
1734  m_manager->writeAndDelete( genericName );
1735  m_manager->passOwnership( g, genericName );
1736  }
1737 
1738  std::string streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1739 
1740  StatusCode smd = registerMetadata(streamName, gName, group);
1741  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1742 
1743  return m_THistSvc->regGraph( streamName, g );
1744 }

◆ regGraph() [4/5]

StatusCode ManagedMonitorToolBase::regGraph
protectedinherited

Registers a TGraph to be included in the output stream using logical parameters that describe the graph.

Definition at line 559 of file ManagedMonitorToolBase.cxx.

1695 {
1696  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1697  return regGraph( g, group );
1698 }

◆ regGraph() [5/5]

StatusCode ManagedMonitorToolBase::regGraph ( TGraph *  g,
const std::string &  system,
Interval_t  interval,
MgmtAttr_t  histo_mgmt = ATTRIB_MANAGED,
const std::string &  chain = "",
const std::string &  merge = "" 
)
virtualinherited

Registers a TGraph to be included in the output stream using logical parameters that describe the graph.

Definition at line 1692 of file ManagedMonitorToolBase.cxx.

1695 {
1696  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1697  return regGraph( g, group );
1698 }

◆ regHist() [1/9]

template<typename T >
void TilePaterMonTool::regHist ( const std::string &  subDir,
T *  hist,
Interval_t  interval = run,
MgmtAttr_t  attribute = ATTRIB_MANAGED,
const std::string &  trigChain = "",
const std::string &  mergeAlgo = "" 
)
protectedinherited

Definition at line 52 of file TilePaterMonTool.cxx.

53 {
54 
55  std::string path(m_path);
56  if (!subDir.empty()) path += ("/" + subDir);
57 
58  if(ManagedMonitorToolBase::regHist(hist, path, interval, attribute, trigChain, mergeAlgo).isFailure()) {
59  ATH_MSG_WARNING( "Could not register histogram : " << path + "/" + hist->GetName() );
60  }
61 
62 }

◆ regHist() [2/9]

StatusCode ManagedMonitorToolBase::regHist
protectedinherited

Definition at line 592 of file ManagedMonitorToolBase.cxx.

1523 {
1524  // You may want to setROOTBackend to true in online environment
1525  //LWHistControls::setROOTBackend(true);
1526 
1527  if (!h)
1528  return StatusCode::FAILURE;
1529 
1530  if (!m_bookHistogramsInitial) {
1531  ATH_MSG_DEBUG("Yura: very first time");
1532  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1533 
1534  ATH_MSG_DEBUG("Yura: we have managed histograms");
1535  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1536  ATH_MSG_DEBUG(" Yura: adding histogram" << h->GetName());
1537  m_templateLWHistograms[group.interval()].push_back( MgmtParams<LWHist>(h, group) );
1538  } else {
1539  ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1540  return StatusCode::FAILURE;
1541  }
1542  //return StatusCode::SUCCESS;
1543  }
1544  }
1545 
1546  //FIXME: Code copied more or less verbatim from above. Collect most code (espc. for streamname) in common helpers!!
1547  std::string hName = h->GetName();
1548 
1549  if( m_manager )
1550  {
1551  std::string genericName = NoOutputStream().getStreamName(this, group, hName );
1552  LWHistAthMonWrapper::setKey(h,genericName);
1553  LWHist* prevLWHist = m_manager->ownedLWHistOfKey(genericName);
1554  if (prevLWHist)
1555  {
1556  std::set<LWHist*>::iterator it = m_lwhists.find(prevLWHist);
1557  if (it!=m_lwhists.end())
1558  {
1559  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1560  m_manager->writeAndResetLWHist( genericName, LWHistAthMonWrapper::streamName(prevLWHist) );
1561  } else {
1562  m_manager->writeAndDeleteLWHist( genericName, LWHistAthMonWrapper::streamName(prevLWHist) );
1563  }
1564  m_lwhists.erase(it);
1565  }
1566  }
1567  m_manager->passOwnership( h, genericName );
1568  }
1569  m_lwhists.insert(h);
1570 
1571  std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1572  LWHistAthMonWrapper::setStreamName(h,streamName);
1573  registerMetadata(streamName, hName, group).ignore();
1574 
1575  //Delay registration with THistSvc (unless root backend):
1576  //m_lwhistMap.insert(std::pair<LWHist*,std::string>(h,streamName));
1577  if (h->usingROOTBackend())
1578  {
1579  h->setOwnsROOTHisto(false);//Since might end up with thist svc
1580  return m_THistSvc->regHist( streamName, h->getROOTHistBase() );
1581  }
1582 
1583  return StatusCode::SUCCESS;
1584 
1585 }

◆ regHist() [3/9]

StatusCode ManagedMonitorToolBase::regHist ( LWHist *  h,
const MonGroup &  group 
)
virtualinherited

Definition at line 1522 of file ManagedMonitorToolBase.cxx.

1523 {
1524  // You may want to setROOTBackend to true in online environment
1525  //LWHistControls::setROOTBackend(true);
1526 
1527  if (!h)
1528  return StatusCode::FAILURE;
1529 
1530  if (!m_bookHistogramsInitial) {
1531  ATH_MSG_DEBUG("Yura: very first time");
1532  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1533 
1534  ATH_MSG_DEBUG("Yura: we have managed histograms");
1535  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1536  ATH_MSG_DEBUG(" Yura: adding histogram" << h->GetName());
1537  m_templateLWHistograms[group.interval()].push_back( MgmtParams<LWHist>(h, group) );
1538  } else {
1539  ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1540  return StatusCode::FAILURE;
1541  }
1542  //return StatusCode::SUCCESS;
1543  }
1544  }
1545 
1546  //FIXME: Code copied more or less verbatim from above. Collect most code (espc. for streamname) in common helpers!!
1547  std::string hName = h->GetName();
1548 
1549  if( m_manager )
1550  {
1551  std::string genericName = NoOutputStream().getStreamName(this, group, hName );
1552  LWHistAthMonWrapper::setKey(h,genericName);
1553  LWHist* prevLWHist = m_manager->ownedLWHistOfKey(genericName);
1554  if (prevLWHist)
1555  {
1556  std::set<LWHist*>::iterator it = m_lwhists.find(prevLWHist);
1557  if (it!=m_lwhists.end())
1558  {
1559  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1560  m_manager->writeAndResetLWHist( genericName, LWHistAthMonWrapper::streamName(prevLWHist) );
1561  } else {
1562  m_manager->writeAndDeleteLWHist( genericName, LWHistAthMonWrapper::streamName(prevLWHist) );
1563  }
1564  m_lwhists.erase(it);
1565  }
1566  }
1567  m_manager->passOwnership( h, genericName );
1568  }
1569  m_lwhists.insert(h);
1570 
1571  std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1572  LWHistAthMonWrapper::setStreamName(h,streamName);
1573  registerMetadata(streamName, hName, group).ignore();
1574 
1575  //Delay registration with THistSvc (unless root backend):
1576  //m_lwhistMap.insert(std::pair<LWHist*,std::string>(h,streamName));
1577  if (h->usingROOTBackend())
1578  {
1579  h->setOwnsROOTHisto(false);//Since might end up with thist svc
1580  return m_THistSvc->regHist( streamName, h->getROOTHistBase() );
1581  }
1582 
1583  return StatusCode::SUCCESS;
1584 
1585 }

◆ regHist() [4/9]

StatusCode ManagedMonitorToolBase::regHist
protectedinherited

Support for lightweight histograms:

Definition at line 590 of file ManagedMonitorToolBase.cxx.

1517 {
1518  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1519  return regHist( h, group );
1520 }

◆ regHist() [5/9]

StatusCode ManagedMonitorToolBase::regHist ( LWHist *  h,
const std::string &  system,
Interval_t  interval,
MgmtAttr_t  histo_mgmt = ATTRIB_MANAGED,
const std::string &  chain = "",
const std::string &  merge = "" 
)
virtualinherited

Support for lightweight histograms:

Definition at line 1515 of file ManagedMonitorToolBase.cxx.

1517 {
1518  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1519  return regHist( h, group );
1520 }

◆ regHist() [6/9]

StatusCode ManagedMonitorToolBase::regHist
protectedinherited

Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.

A histogram is passed via reference to a pointer.

Definition at line 507 of file ManagedMonitorToolBase.cxx.

1464 {
1465 // ManagedMonitorToolBase_addHistStatistics(this,h);
1466 
1467  if (!h)
1468  return StatusCode::FAILURE;
1469 
1470  // This part of the code deals with MANAGED type
1471  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1472  /*
1473  Create an unmanaged group based on the original MonGroup instance passed
1474  It is needed because managed histogram is presented as a number of unmanaged
1475  histograms (one per each interval)
1476  Update (PUEO) - I don't think it actually matters, and need to keep
1477  track of "proper" attribute for X_VS_LB
1478  */
1479 
1480  if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1481  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.");
1482  }
1483 
1484  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1485  m_templateHistograms[group.interval()].push_back( MgmtParams<TH1>(h, group) );
1486  } else {
1487  ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1488  return StatusCode::FAILURE;
1489  }
1490 
1491  std::string hName = h->GetName();
1492  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1493  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, hName, false );
1494  registerMetadata(streamName, hName, group).ignore();
1495  return m_THistSvc->regHist( streamName, h );
1496  }
1497 
1498  // This part of the code deals with UNMANAGED type
1499  std::string hName = h->GetName();
1500 
1501  if( m_manager != 0 ) {
1502  std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1503  m_manager->writeAndDelete( genericName );
1504  m_manager->passOwnership( h, genericName );
1505  }
1506 
1507  std::string streamName = streamNameFunction()->getStreamName( this, group, hName, false );
1508 
1509  StatusCode smd = registerMetadata(streamName, hName, group);
1510  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1511 
1512  return m_THistSvc->regHist( streamName, h );
1513 }

◆ regHist() [7/9]

StatusCode ManagedMonitorToolBase::regHist ( TH1 *  h,
const MonGroup &  group 
)
virtualinherited

Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.

A histogram is passed via reference to a pointer.

Definition at line 1462 of file ManagedMonitorToolBase.cxx.

1464 {
1465 // ManagedMonitorToolBase_addHistStatistics(this,h);
1466 
1467  if (!h)
1468  return StatusCode::FAILURE;
1469 
1470  // This part of the code deals with MANAGED type
1471  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1472  /*
1473  Create an unmanaged group based on the original MonGroup instance passed
1474  It is needed because managed histogram is presented as a number of unmanaged
1475  histograms (one per each interval)
1476  Update (PUEO) - I don't think it actually matters, and need to keep
1477  track of "proper" attribute for X_VS_LB
1478  */
1479 
1480  if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1481  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.");
1482  }
1483 
1484  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1485  m_templateHistograms[group.interval()].push_back( MgmtParams<TH1>(h, group) );
1486  } else {
1487  ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1488  return StatusCode::FAILURE;
1489  }
1490 
1491  std::string hName = h->GetName();
1492  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1493  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, hName, false );
1494  registerMetadata(streamName, hName, group).ignore();
1495  return m_THistSvc->regHist( streamName, h );
1496  }
1497 
1498  // This part of the code deals with UNMANAGED type
1499  std::string hName = h->GetName();
1500 
1501  if( m_manager != 0 ) {
1502  std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1503  m_manager->writeAndDelete( genericName );
1504  m_manager->passOwnership( h, genericName );
1505  }
1506 
1507  std::string streamName = streamNameFunction()->getStreamName( this, group, hName, false );
1508 
1509  StatusCode smd = registerMetadata(streamName, hName, group);
1510  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1511 
1512  return m_THistSvc->regHist( streamName, h );
1513 }

◆ regHist() [8/9]

StatusCode ManagedMonitorToolBase::regHist
protectedinherited

Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.

Definition at line 499 of file ManagedMonitorToolBase.cxx.

1456 {
1457  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1458  return regHist( h, group );
1459 }

◆ regHist() [9/9]

StatusCode ManagedMonitorToolBase::regHist ( TH1 *  h,
const std::string &  system,
Interval_t  interval,
MgmtAttr_t  histo_mgmt = ATTRIB_MANAGED,
const std::string &  chain = "",
const std::string &  merge = "" 
)
virtualinherited

Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.

Definition at line 1453 of file ManagedMonitorToolBase.cxx.

1456 {
1457  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1458  return regHist( h, group );
1459 }

◆ registerMetadata()

StatusCode ManagedMonitorToolBase::registerMetadata ( const std::string &  streamName,
const std::string &  hName,
const MonGroup &  group 
)
protectedinherited

Definition at line 1005 of file ManagedMonitorToolBase.cxx.

1007  {
1008  if( m_environment != AthenaMonManager::online ) {
1009  TTree* metadata(0);
1010  std::string mdStreamName( streamName );
1011  size_t found=mdStreamName.rfind('/');
1012 
1013  if ( found != std::string::npos )
1014  mdStreamName.replace( found, mdStreamName.length(), "/metadata" );
1015 
1016  MDMap_t::iterator i = m_metadataMap.find( mdStreamName );
1017  if( i == m_metadataMap.end() ) {
1018  metadata = new TTree( "metadata", "Monitoring Metadata" );
1019  if (! metadata) return StatusCode::FAILURE;
1020  StatusCode scmd = m_THistSvc->regTree( mdStreamName, metadata );
1021  if (scmd == StatusCode::FAILURE) return StatusCode::FAILURE;
1022  MDMap_t::value_type valToInsert( mdStreamName, new OutputMetadata(metadata) );
1023  i = m_metadataMap.insert( valToInsert ).first;
1024  }
1025 
1026  i->second->fill( hName, group.interval(), group.chain(), group.merge() );
1027  }
1028  return StatusCode::SUCCESS;
1029 }

◆ regManagedEfficiencies()

StatusCode ManagedMonitorToolBase::regManagedEfficiencies ( std::vector< MgmtParams< TEfficiency > > &  templateEfficiencies)
protectedinherited

Definition at line 1200 of file ManagedMonitorToolBase.cxx.

1200  {
1201  bool allIsOk = true;
1202  for( auto& it : templateEfficiencies ) {
1203  // get components of MgmtParams and copy efficiency
1204  MonGroup group = it.m_group;
1205  TEfficiency* theEfficiency = it.m_templateHist;
1206  TEfficiency* e = static_cast<TEfficiency*>(theEfficiency->Clone());
1207  int nbins = theEfficiency->GetTotalHistogram()->GetNbinsX();
1208  int xlow = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmin();
1209  int xhigh = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmax();
1210  e->SetBins(nbins,xlow,xhigh); // reset histogram
1211  std::string name = e->GetName();
1212 
1213  // make TGraph casts of TEfficiencies
1214  TGraph* theGraph = reinterpret_cast<TGraph*>(theEfficiency);
1215  TGraph* g = reinterpret_cast<TGraph*>(e);
1216 
1217  // Get the streamName for the previous interval
1218  std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
1219 
1220  // RE-REGISTER
1221  // 1) De-register the original graph with the THistSvc
1222  StatusCode sc1 = m_THistSvc->deReg( theGraph );
1223  if (sc1 == StatusCode::FAILURE) allIsOk = false;
1224  // 2) Fix THistSvc->deReg for TGraphs
1225  bool doneCleaning = false;
1226  std::string directoryName = streamNameFunction()->getDirectoryName( this, group, name, true );
1227  TSeqCollection *filelist=gROOT->GetListOfFiles();
1228  for (int i=0; i<filelist->GetEntries(); i++) {
1229  ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
1230  TFile* file = static_cast<TFile*>(filelist->At(i));
1231  StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
1232  if (sc2 == StatusCode::SUCCESS) doneCleaning = true;
1233  }
1234  // 3) Check if TGraph fix has been applied successfully
1235  if (!doneCleaning) {
1236  ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
1237  allIsOk = false;
1238  }
1239  // 4) Register cloned histogram under previous interval streamName
1240  StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
1241  if (sc3 == StatusCode::FAILURE)
1242  allIsOk = false;
1243 
1244  // get streamname for interval
1245  streamName = streamNameFunction()->getStreamName( this, group, name, false );
1246  // store metadata
1247  StatusCode smd = registerMetadata(streamName, name, group);
1248  if (smd != StatusCode::SUCCESS) allIsOk = false;
1249  // Re-register the original graph
1250  StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
1251  if (sc4 == StatusCode::FAILURE) allIsOk = false;
1252  }
1253 
1254  if (!allIsOk) return StatusCode::FAILURE;
1255  return StatusCode::SUCCESS;
1256 }

◆ regManagedGraphs()

StatusCode ManagedMonitorToolBase::regManagedGraphs ( std::vector< MgmtParams< TGraph > > &  templateGraphs)
protectedinherited

Definition at line 1129 of file ManagedMonitorToolBase.cxx.

1131 {
1132  // See the description for the regManagedHistograms method
1133  bool allIsOk = true;
1134 
1135  for( std::vector< MgmtParams<TGraph> >::iterator it = templateGraphs.begin(); it != templateGraphs.end(); ++it ) {
1136  MonGroup group = (*it).m_group;
1137 
1138  // Get a handle to the graph
1139  TGraph* theGraph = (*it).m_templateHist;
1140 
1141  // Clone the graph
1142  TGraph* g = static_cast<TGraph*>(theGraph->Clone());
1143  theGraph->Set(0); // equivalent to Reset() for TH1
1144 
1145  // Get name
1146  std::string gName = g->GetName();
1147 
1148  // Get the streamName for the previous interval
1149  std::string streamName = streamNameFunction()->getStreamName( this, group, gName, true );
1150 
1151  // De-register the original graph with the THistSvc
1152  StatusCode sc1 = m_THistSvc->deReg( theGraph );
1153  if (sc1 == StatusCode::FAILURE)
1154  allIsOk = false;
1155 
1156  // *** begin ***
1157  // Fix THistSvc->deReg for TGraphs
1158  bool doneCleaning = false;
1159  std::string directoryName = streamNameFunction()->getDirectoryName( this, group, gName, true );
1160  TSeqCollection *filelist=gROOT->GetListOfFiles();
1161  for (int i=0; i<filelist->GetEntries(); i++) {
1162  ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
1163  TFile* file = static_cast<TFile*>(filelist->At(i));
1164  StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
1165  if (sc2 == StatusCode::SUCCESS)
1166  doneCleaning = true;
1167  }
1168 
1169  // Check if TGraph fix has been applied successfully
1170  if (!doneCleaning) {
1171  ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
1172  allIsOk = false;
1173  }
1174  // *** end ***
1175 
1176  // Register clonned histogram under previous interval streamName
1177  StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
1178  if (sc3 == StatusCode::FAILURE)
1179  allIsOk = false;
1180 
1181  // Get streamName for the current interval
1182  streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1183  // Register metadata information with the current interval streamname
1184  StatusCode smd = registerMetadata(streamName, gName, group);
1185  if (smd != StatusCode::SUCCESS)
1186  allIsOk = false;
1187 
1188  // Re-register the original graph with the current interval streamName
1189  StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
1190  if (sc4 == StatusCode::FAILURE)
1191  allIsOk = false;
1192 
1193  }
1194 
1195  if (!allIsOk) return StatusCode::FAILURE;
1196 
1197  return StatusCode::SUCCESS;
1198 }

◆ regManagedHistograms()

StatusCode ManagedMonitorToolBase::regManagedHistograms ( std::vector< MgmtParams< TH1 > > &  templateHistograms)
protectedinherited

Definition at line 1032 of file ManagedMonitorToolBase.cxx.

1034 {
1035  // The method registers histograms with the THistSvc and saves them to file.
1036 
1037  // The funky business with registering and deregistering the histogram is needed
1038  // to get the correct directory when saving histograms. THistSvc deals with ROOT
1039  // to set up proper TDirectory, so we rely on it.
1040  // E.g.
1041  // m_THistSvc->regHist( streamName, h ): sets the correct TDirectory with streamName
1042  // m_THistSvc->deReg( h ) - deregister from THistSvc otherwise THistSvc will try to save it
1043  // at the end of execution
1044  // use passownership of the histogram and save it to file
1045  // m_manager->passOwnership( h, genericName );
1046  // m_manager->writeAndDelete( genericName );
1047  bool allIsOk = true;
1048 
1049  for( std::vector< MgmtParams<TH1> >::iterator it = templateHistograms.begin(); it != templateHistograms.end(); ++it ) {
1050  MonGroup& group = (*it).m_group;
1051 
1052  // Get a handle to the histogram
1053  TH1* theHist = (*it).m_templateHist;
1054 
1055  // Clone the histogram
1056  TH1* h = static_cast<TH1*>(theHist->Clone());
1057  theHist->Reset();
1058 
1059  // Get name
1060  std::string hName = h->GetName();
1061 
1062  // Get the streamName for the previous interval
1063  std::string streamName = streamNameFunction()->getStreamName( this, group, hName, true );
1064 
1065  // Register the histogram with the THistSvc
1066  StatusCode sc1 = m_THistSvc->deReg( theHist );
1067  if (sc1 == StatusCode::FAILURE) allIsOk = false;
1068 
1069  // Register clonned histogram under previous interval streamName
1070  StatusCode sc2 = m_THistSvc->regHist( streamName, h );
1071  if (sc2 == StatusCode::FAILURE) allIsOk = false;
1072 
1073  if( m_manager != 0 ) {
1074  std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1075  m_manager->passOwnership( h, genericName );
1076  m_manager->writeAndDelete( genericName );
1077  }
1078 
1079  // Get streamName for the current interval
1080  streamName = streamNameFunction()->getStreamName( this, group, hName, false );
1081  // Register metadata information with the current interval streamname
1082  StatusCode smd = registerMetadata(streamName, hName, group);
1083  if (smd != StatusCode::SUCCESS) allIsOk = false;
1084 
1085  // Re-register the original histogram with the current interval streamName
1086  StatusCode sc3 = m_THistSvc->regHist( streamName, theHist );
1087  if (sc3 == StatusCode::FAILURE) allIsOk = false;
1088 
1089  }
1090 
1091  if (!allIsOk) return StatusCode::FAILURE;
1092 
1093  return StatusCode::SUCCESS;
1094 }

◆ regManagedLWHistograms()

StatusCode ManagedMonitorToolBase::regManagedLWHistograms ( std::vector< MgmtParams< LWHist > > &  templateLWHistograms)
protectedinherited

Definition at line 1314 of file ManagedMonitorToolBase.cxx.

1316 {
1317  StatusCode sc1;
1318 
1319  for( std::vector< MgmtParams<LWHist> >::iterator it = templateLWHistograms.begin(); it != templateLWHistograms.end(); ++it ) {
1320  // Get histogram group
1321  MonGroup group = (*it).m_group;
1322 
1323  // Get handle to the histogram
1324  LWHist* h = (*it).m_templateHist;
1325 
1326  sc1 = regHist(h, group);
1327  }
1328 
1329  return sc1;
1330 }

◆ regManagedTrees()

StatusCode ManagedMonitorToolBase::regManagedTrees ( std::vector< MgmtParams< TTree > > &  templateTrees)
protectedinherited

Definition at line 1260 of file ManagedMonitorToolBase.cxx.

1262 {
1263  // See the description for the regManagedHistograms method
1264  bool allIsOk = true;
1265 
1266  for( std::vector< MgmtParams<TTree> >::iterator it = templateTrees.begin(); it != templateTrees.end(); ++it ) {
1267  MonGroup group = (*it).m_group;
1268 
1269  // Get a handle to the original tree
1270  TTree* theTree = (*it).m_templateHist;
1271 
1272  // Clone the tree
1273  TTree* t = static_cast<TTree*>(theTree->Clone());
1274  theTree->Reset();
1275 
1276  // Dumping the tree
1277  std::string name = t->GetName();
1278 
1279  // Get the streamName for the previous interval
1280  std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
1281 
1282  // De-register original tree with the THistSvc
1283  StatusCode sc1 = m_THistSvc->deReg( theTree );
1284  if (sc1 == StatusCode::FAILURE) allIsOk = false;
1285 
1286  // Register clonned tree under previous interval streamName
1287  StatusCode sc2 = m_THistSvc->regTree( streamName, t );
1288  if (sc2 == StatusCode::FAILURE) allIsOk = false;
1289 
1290  if( m_manager != 0 ) {
1291  std::string genericName = NoOutputStream().getStreamName( this, group, name );
1292  m_manager->passOwnership( t, genericName );
1293  m_manager->writeAndDelete( genericName );
1294  }
1295 
1296  // Get streamName for the current interval
1297  streamName = streamNameFunction()->getStreamName( this, group, name, false );
1298  // Register metadata information with the current interval streamname
1299  StatusCode smd = registerMetadata(streamName, name, group);
1300  if (smd != StatusCode::SUCCESS) allIsOk = false;
1301 
1302  // Re-register the original graph with the current interval streamName
1303  StatusCode sc3 = m_THistSvc->regTree( streamName, theTree );
1304  if (sc3 == StatusCode::FAILURE) allIsOk = false;
1305 
1306  }
1307 
1308  if (!allIsOk) return StatusCode::FAILURE;
1309 
1310  return StatusCode::SUCCESS;
1311 }

◆ regTree() [1/2]

StatusCode ManagedMonitorToolBase::regTree ( TTree *  t,
const MonGroup &  group 
)
virtualinherited

Registers a TTree to be included in the output stream using logical parameters that describe it.

Definition at line 1758 of file ManagedMonitorToolBase.cxx.

1760 {
1761 
1762  // This part of the code deals with MANAGED type
1763  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1764  // Create an unmanaged group based on the original MonGroup instance passed
1765  // This is needed because managed tree is presented as a number of unmanaged
1766  // trees (one per each interval)
1767  MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1768 
1769  if (m_supportedIntervalsForRebooking.count(group.interval())) {
1770  m_templateTrees[group.interval()].push_back( MgmtParams<TTree>(t, group_unmanaged) );
1771  } else {
1772  ATH_MSG_ERROR("Attempt to book managed tree " << t->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1773  return StatusCode::FAILURE;
1774  }
1775 
1776  std::string name = t->GetName();
1777  std::string genericName = NoOutputStream().getStreamName( this, group_unmanaged, name );
1778  std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1779  registerMetadata(streamName, name, group).ignore();
1780  return m_THistSvc->regTree( streamName, t );
1781  }
1782 
1783 
1784  // This part of the code deals with UNMANAGED type
1785  std::string tName = t->GetName();
1786 
1787  if( m_manager != 0 ) {
1788  std::string genericName = NoOutputStream().getStreamName( this, group, tName );
1789  m_manager->writeAndDelete( genericName );
1790  m_manager->passOwnership( t, genericName );
1791  }
1792 
1793  std::string streamName = streamNameFunction()->getStreamName( this, group, tName, false );
1794 
1795  StatusCode smd = registerMetadata(streamName, tName, group);
1796  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1797 
1798  return m_THistSvc->regTree( streamName, t );
1799 }

◆ regTree() [2/2]

StatusCode ManagedMonitorToolBase::regTree ( TTree *  t,
const std::string &  system,
Interval_t  interval,
MgmtAttr_t  histo_mgmt = ATTRIB_MANAGED,
const std::string &  chain = "",
const std::string &  merge = "" 
)
virtualinherited

Registers a TTree to be included in the output stream using logical parameters that describe it.

Definition at line 1748 of file ManagedMonitorToolBase.cxx.

1751 {
1752  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1753  return regTree( t, group );
1754 }

◆ removeTObj()

StatusCode TilePaterMonTool::removeTObj ( TObject *  obj)
protectedinherited

Definition at line 468 of file TilePaterMonTool.cxx.

468  {
469  if (obj != 0) {
470  if (obj->IsA()->InheritsFrom("TH1")) {
471  if (deregHist((TH1*) obj).isFailure()) {
472  ATH_MSG_WARNING( "Could not dereg Histogram : " << obj->GetName() );
473  return StatusCode::FAILURE;
474  } else {
475  delete obj;
476  }
477  } else if (obj->IsA()->InheritsFrom("TGraph")) {
478  if (deregGraph((TGraph*) obj) != StatusCode::SUCCESS) {
479  ATH_MSG_WARNING( "Could not dereg Graph : " << obj->GetName() );
480  return StatusCode::FAILURE;
481  } else {
482  delete obj;
483  }
484  } else {
485  ATH_MSG_WARNING( "Asked to remove object " << obj->GetName() << "of unsupported type " << obj->IsA() );
486  return StatusCode::FAILURE;
487  }
488  } else {
489  ATH_MSG_WARNING( "Asked to remove NULL pointer" );
490  return StatusCode::FAILURE;
491  }
492  return StatusCode::SUCCESS;
493 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ resetSummaryHistograms()

void TileRawChannelMonTool::resetSummaryHistograms ( )
private

Definition at line 1012 of file TileRawChannelMonTool.cxx.

1014 {
1015 
1016  memset(m_data->m_timeCov, 0, sizeof(m_data->m_timeCov));
1017  memset(m_data->m_timeCovCorr, 0, sizeof(m_data->m_timeCovCorr));
1018 
1019  int mingain = (m_bigain) ? 0 : 2;
1020  int maxgain = (m_bigain) ? 2 : 3;
1021 
1022  for (int ros = 1; ros < 5; ++ros) {
1023  for (int drawer = 0; drawer < 64; ++drawer) {
1024  if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
1025  for (int ch = 0; ch < 48; ++ch) {
1026  for (int gn = mingain; gn < maxgain; ++gn) {
1027  for (auto h : m_data->m_hist1[ros][drawer][ch][gn]) h->Reset();
1028  for (auto h : m_data->m_hist2[ros][drawer][ch][gn]) h->Reset();
1029  }
1030  }
1031  }
1032  }
1033  }
1034 }

◆ runStat()

StatusCode ManagedMonitorToolBase::runStat ( )
virtualinherited

This implementation does nothing; equivalent functionality may be provided by procHists( true, true, true ).

Implements IMonitorToolBase.

Definition at line 1893 of file ManagedMonitorToolBase.cxx.

1895 {
1896  return StatusCode::SUCCESS;
1897 }

◆ setMonManager()

void ManagedMonitorToolBase::setMonManager ( AthenaMonManager *  manager)
virtualinherited

Takes a pointer to a managing object to get information from it when needed.

Definition at line 1435 of file ManagedMonitorToolBase.cxx.

1437 {
1438  ATH_MSG_DEBUG( "ManagedMonitorToolBase::setMonManager():");
1439  m_manager = manager;
1440  if( m_manager != 0 ) {
1441  ATH_MSG_DEBUG( " --> Setting manager");
1442  m_managerNameProp = m_manager->name();
1443  m_fileKey = m_manager->fileKey();
1444  m_dataType = m_manager->dataType();
1445  m_environment = m_manager->environment();
1446  delete m_streamNameFcn;
1447  m_streamNameFcn = getNewStreamNameFcn();
1448  }
1449  ATH_MSG_DEBUG( " --> Exiting successfully");
1450 }

◆ setupOutputStreams()

StatusCode ManagedMonitorToolBase::setupOutputStreams ( std::vector< std::string >  Mapping = std::vector<std::string>())
virtualinherited

This implementation does nothing—streams in this class should be managed by the AthenaMonManager.

Consider using MonitorToolBase for user-managed streams.

Implements IMonitorToolBase.

Definition at line 1882 of file ManagedMonitorToolBase.cxx.

1884 {
1885  // All instances should write to the stream(s) defined by the
1886  // AthenaMonManager.
1887 
1888  return StatusCode::SUCCESS;
1889 }

◆ streamNameFunction()

ManagedMonitorToolBase::StreamNameFcn * ManagedMonitorToolBase::streamNameFunction ( )
virtualinherited

Returns the function object that converts logical paramters into a physical stream name.

Definition at line 502 of file ManagedMonitorToolBase.cxx.

504 {
505  if( m_streamNameFcn == 0 ) {
506  msg(MSG::ERROR) << "!! streamNameFunction() has not been initialized !!" << endmsg;
507  msg(MSG::ERROR) << " --> neither ManagedMonitorToolBase::initialize() nor" << endmsg;
508  msg(MSG::ERROR) << " --> ManagedMonitorToolBase::setMonManager() has been called." << endmsg;
509  msg(MSG::ERROR) << " --> Correct configuration cannot be guaranteed from this point." << endmsg;
510  m_streamNameFcn = getNewStreamNameFcn();
511  }
512  return m_streamNameFcn;
513 }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ THistSvc_deReg_fixTGraph()

StatusCode ManagedMonitorToolBase::THistSvc_deReg_fixTGraph ( TFile *  file,
TGraph *  theGraph,
std::string &  directoryName 
)
protectedinherited

Fixes THistSvc->deReg(obj) when obj is TGraph instance.

Read more in source file about this bug.

Definition at line 1097 of file ManagedMonitorToolBase.cxx.

1099 {
1100  // THistSvc employs TDirectory Append method when registering TGraph.
1101  // When deReg is used to de-register TGraph object, THistSvc only removes the object
1102  // from its internal management but forgets to delete from TDirectory.
1103  // The current method fixes this problem by removing the TGraph object manually
1104  // after THistSvc->deReg(TGraph* obj) is called.
1105 
1106  // Saves and restores gFile and gDirectory
1107  GlobalDirectoryRestore restore;
1108 
1109  // This check is true when TGraph object is removed successfully
1110  bool graphRemoved = false;
1111 
1112  file->cd("/");
1113  TDirectory* dir = file->GetDirectory(directoryName.c_str());
1114  if (dir != 0) {
1115  dir->cd();
1116  TObject* obj = dir->Remove(theGraph);
1117  if (obj != 0)
1118  graphRemoved = true;
1119  }
1120 
1121  if (!graphRemoved) {
1122  return StatusCode::FAILURE;
1123  }
1124 
1125  return StatusCode::SUCCESS;
1126 }

◆ trigChainsArePassed()

bool ManagedMonitorToolBase::trigChainsArePassed ( std::vector< std::string > &  vTrigNames)
protectedvirtualinherited

Definition at line 2324 of file ManagedMonitorToolBase.cxx.

2326 {
2327  ATH_MSG_DEBUG( "ManagedMonitorToolBase::trigChainsArePassed:");
2328 
2329  for(unsigned int i=0; i<vTrigNames.size(); i++) {
2330  if( m_trigDecTool->isPassed(vTrigNames[i]) ) {
2331  ATH_MSG_DEBUG( " + \"" << vTrigNames[i] << "\" passed, returning \'true\'");
2332  return true;
2333  }
2334  else {
2335  ATH_MSG_DEBUG( " - \"" << vTrigNames[i] << "\" did not pass");
2336  }
2337  }
2338 
2339  return false;
2340 }

◆ updateTriggersForGroups()

void ManagedMonitorToolBase::updateTriggersForGroups ( std::vector< std::string > &  vTrigChainNames)
protectedinherited

Definition at line 2362 of file ManagedMonitorToolBase.cxx.

2363  {
2364  for (size_t i = 0; i < vTrigChainNames.size(); ++i) {
2365  std::string& thisName = vTrigChainNames[i];
2366  if (thisName.compare(0, 9, "CATEGORY_") ==0) {
2367  ATH_MSG_DEBUG("Found a trigger category: " << thisName << ". We will unpack it.");
2368  std::vector<std::string> triggers = m_trigTranslator->translate(thisName.substr(9,std::string::npos));
2369  std::ostringstream oss;
2370  oss << "(";
2371  for (size_t itrig = 0; itrig < triggers.size(); ++itrig) {
2372  if (itrig != 0) {
2373  oss << "|";
2374  }
2375  oss << triggers[itrig];
2376  }
2377  oss << ")";
2378  // replace with new value
2379  std::string newval = oss.str();
2380  ATH_MSG_DEBUG("Replaced with " << newval);
2381  vTrigChainNames[i] = newval;
2382  }
2383  }
2384 }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

◆ writeAndDelete()

StatusCode ManagedMonitorToolBase::writeAndDelete ( TH1 *  h,
const MonGroup &  group 
)
virtualinherited

Write out histogram and delete it.

Definition at line 1803 of file ManagedMonitorToolBase.cxx.

1804  {
1805  if (!h)
1806  return StatusCode::FAILURE;
1807 
1808  std::string hName = h->GetName();
1809 
1810  if( m_manager != 0 ) {
1811  std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1812  m_manager->writeAndDelete( genericName );
1813  }
1814  return StatusCode::SUCCESS;
1815 }

Member Data Documentation

◆ m_bigain

bool TileRawChannelMonTool::m_bigain {}
private

Definition at line 143 of file TileRawChannelMonTool.h.

◆ m_book2D

bool TileRawChannelMonTool::m_book2D {}
private

Definition at line 70 of file TileRawChannelMonTool.h.

◆ m_bookAll

bool TileRawChannelMonTool::m_bookAll {}
private

Definition at line 69 of file TileRawChannelMonTool.h.

◆ m_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial
privateinherited

Definition at line 956 of file ManagedMonitorToolBase.h.

◆ m_cabling

const TileCablingService* TilePaterMonTool::m_cabling {}
protectedinherited

Definition at line 226 of file TilePaterMonTool.h.

◆ m_calibUnit

TileRawChannelUnit::UNIT TileRawChannelMonTool::m_calibUnit {}
private

Definition at line 166 of file TileRawChannelMonTool.h.

◆ m_chMapEB

int TilePaterMonTool::m_chMapEB[48]
protectedinherited
Initial value:
= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0
, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0
, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1 }

Definition at line 270 of file TilePaterMonTool.h.

◆ m_chMapEBsp

int TilePaterMonTool::m_chMapEBsp[48]
protectedinherited
Initial value:
= { 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0
, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1 }

Definition at line 275 of file TilePaterMonTool.h.

◆ m_chMapLB

int TilePaterMonTool::m_chMapLB[48]
protectedinherited
Initial value:
= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 }

Definition at line 265 of file TilePaterMonTool.h.

◆ m_cispar

const uint32_t* TileRawChannelMonTool::m_cispar
private

Definition at line 141 of file TileRawChannelMonTool.h.

◆ m_contName

std::string TileRawChannelMonTool::m_contName
private

Definition at line 73 of file TileRawChannelMonTool.h.

◆ m_contNameDSP

std::string TileRawChannelMonTool::m_contNameDSP
private

Definition at line 74 of file TileRawChannelMonTool.h.

◆ m_contNameOF

std::string TileRawChannelMonTool::m_contNameOF
private

Definition at line 75 of file TileRawChannelMonTool.h.

◆ m_corrup

bool TileRawChannelMonTool::m_corrup[5][64][2][16] ={}
private

Definition at line 97 of file TileRawChannelMonTool.h.

◆ m_d

Imp* ManagedMonitorToolBase::m_d
privateinherited

Definition at line 963 of file ManagedMonitorToolBase.h.

◆ m_dac2Charge

double TileRawChannelMonTool::m_dac2Charge[3] ={}
private

Definition at line 179 of file TileRawChannelMonTool.h.

◆ m_data

std::unique_ptr<Data> TileRawChannelMonTool::m_data
private

Definition at line 164 of file TileRawChannelMonTool.h.

◆ m_dataType

AthenaMonManager::DataType_t ManagedMonitorToolBase::m_dataType
protectedinherited

Definition at line 901 of file ManagedMonitorToolBase.h.

◆ m_dataTypeStr

std::string ManagedMonitorToolBase::m_dataTypeStr
protectedinherited

Definition at line 897 of file ManagedMonitorToolBase.h.

◆ m_defaultLBDuration

float ManagedMonitorToolBase::m_defaultLBDuration
privateinherited

Definition at line 958 of file ManagedMonitorToolBase.h.

◆ m_detailLevel

unsigned int ManagedMonitorToolBase::m_detailLevel
protectedinherited

Definition at line 899 of file ManagedMonitorToolBase.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doLaserSummaryVsPMT

bool TileRawChannelMonTool::m_doLaserSummaryVsPMT {}
private

Definition at line 170 of file TileRawChannelMonTool.h.

◆ m_DownLimit

double TileRawChannelMonTool::m_DownLimit {}
private

Definition at line 76 of file TileRawChannelMonTool.h.

◆ m_DQFilterTools

ToolHandleArray<IDQFilterTool> ManagedMonitorToolBase::m_DQFilterTools {this,"FilterTools",{}}
protectedinherited

Definition at line 912 of file ManagedMonitorToolBase.h.

◆ m_DQstatusKey

SG::ReadHandleKey<TileDQstatus> TileRawChannelMonTool::m_DQstatusKey
private

Definition at line 177 of file TileRawChannelMonTool.h.

◆ m_drawHists

bool TileRawChannelMonTool::m_drawHists {}
private

Definition at line 171 of file TileRawChannelMonTool.h.

◆ m_EBcellName

std::string TilePaterMonTool::m_EBcellName[48]
protectedinherited
Initial value:
= { "E3", "E4", "D4", "D4", "C10", "C10", "A12", "A12", "B11", "B11", "A13", "A13"
, "E1", "E2", "B12", "B12", "D5", "D5", "E3*", "E4*", "A14", "A14", "B13", "B13"
, "", "", "", "", "", "", "B14", "A15", "A15", "", "", "B14"
, "B15", "D6", "D6", "B15", "A16", "A16", "", "", "", "", "", "" }

Definition at line 235 of file TilePaterMonTool.h.

◆ m_efitMap

std::map<int, std::vector<double> > TileRawChannelMonTool::m_efitMap
private

Definition at line 85 of file TileRawChannelMonTool.h.

◆ m_efitThresh

double TileRawChannelMonTool::m_efitThresh {}
private

Definition at line 88 of file TileRawChannelMonTool.h.

◆ m_endOfEventsBlock

bool ManagedMonitorToolBase::m_endOfEventsBlock
privateinherited

Definition at line 885 of file ManagedMonitorToolBase.h.

◆ m_endOfLowStat

bool ManagedMonitorToolBase::m_endOfLowStat
privateinherited

Definition at line 885 of file ManagedMonitorToolBase.h.

◆ m_endOfLumiBlock

bool ManagedMonitorToolBase::m_endOfLumiBlock
privateinherited

Definition at line 885 of file ManagedMonitorToolBase.h.

◆ m_endOfRun

bool ManagedMonitorToolBase::m_endOfRun
privateinherited

Definition at line 885 of file ManagedMonitorToolBase.h.

◆ m_environment

AthenaMonManager::Environment_t ManagedMonitorToolBase::m_environment
protectedinherited

Definition at line 902 of file ManagedMonitorToolBase.h.

◆ m_environmentStr

std::string ManagedMonitorToolBase::m_environmentStr
protectedinherited

Definition at line 898 of file ManagedMonitorToolBase.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_fileKey

std::string ManagedMonitorToolBase::m_fileKey
protectedinherited

Definition at line 896 of file ManagedMonitorToolBase.h.

◆ m_fragIDsDemonstrators

std::vector<int> TilePaterMonTool::m_fragIDsDemonstrators
protectedinherited

Definition at line 233 of file TilePaterMonTool.h.

◆ m_fragIDsToIgnoreDMUerrors

std::vector<int> TilePaterMonTool::m_fragIDsToIgnoreDMUerrors
protectedinherited

Definition at line 232 of file TilePaterMonTool.h.

◆ m_haveClearedLastEventBlock

bool ManagedMonitorToolBase::m_haveClearedLastEventBlock
protectedinherited

Definition at line 929 of file ManagedMonitorToolBase.h.

◆ m_hi_IntegralLimit

double TileRawChannelMonTool::m_hi_IntegralLimit {}
private

Definition at line 80 of file TileRawChannelMonTool.h.

◆ m_infoName

std::string TileRawChannelMonTool::m_infoName {}
private

Definition at line 174 of file TileRawChannelMonTool.h.

◆ m_intCalibUnit

int TileRawChannelMonTool::m_intCalibUnit {}
private

Definition at line 178 of file TileRawChannelMonTool.h.

◆ m_is12bit

bool TileRawChannelMonTool::m_is12bit {}
private

Definition at line 176 of file TileRawChannelMonTool.h.

◆ m_lastHigStatInterval

int ManagedMonitorToolBase::m_lastHigStatInterval
protectedinherited

Definition at line 924 of file ManagedMonitorToolBase.h.

◆ m_lastLowStatInterval

int ManagedMonitorToolBase::m_lastLowStatInterval
protectedinherited

Definition at line 924 of file ManagedMonitorToolBase.h.

◆ m_lastLumiBlock

unsigned int ManagedMonitorToolBase::m_lastLumiBlock
protectedinherited

Definition at line 922 of file ManagedMonitorToolBase.h.

◆ m_lastMedStatInterval

int ManagedMonitorToolBase::m_lastMedStatInterval
protectedinherited

Definition at line 924 of file ManagedMonitorToolBase.h.

◆ m_lastRun

unsigned int ManagedMonitorToolBase::m_lastRun
protectedinherited

Definition at line 923 of file ManagedMonitorToolBase.h.

◆ m_LBcellName

std::string TilePaterMonTool::m_LBcellName[48]
protectedinherited
Initial value:
= { "D0", "A1", "B1", "B1", "A1", "A2", "B2", "B2", "A2", "A3", "A3", "B3"
, "B3", "D1", "D1", "A4", "B4", "B4", "A4", "A5", "A5", "B5", "B5", "A6"
, "D2", "D2", "A6", "B6", "B6", "A7", "", "", "A7", "B7", "B7", "A8"
, "A9", "A9", "A8", "B8", "B8", "D3", "B9", "", "D3", "A10", "A10", "B9" }

Definition at line 240 of file TilePaterMonTool.h.

◆ m_lbDurationDataKey

SG::ReadCondHandleKey<LBDurationCondData> ManagedMonitorToolBase::m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
privateinherited

Definition at line 951 of file ManagedMonitorToolBase.h.

◆ m_lo_IntegralLimit

double TileRawChannelMonTool::m_lo_IntegralLimit {}
private

Definition at line 78 of file TileRawChannelMonTool.h.

◆ m_lumiDataKey

SG::ReadCondHandleKey<LuminosityCondData> ManagedMonitorToolBase::m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
privateinherited

Definition at line 949 of file ManagedMonitorToolBase.h.

◆ m_lwhists

std::set<LWHist*> ManagedMonitorToolBase::m_lwhists
protectedinherited

Definition at line 891 of file ManagedMonitorToolBase.h.

◆ m_manager

AthenaMonManager* ManagedMonitorToolBase::m_manager
protectedinherited

Definition at line 892 of file ManagedMonitorToolBase.h.

◆ m_managerNameProp

std::string ManagedMonitorToolBase::m_managerNameProp
protectedinherited

Definition at line 894 of file ManagedMonitorToolBase.h.

◆ m_med_IntegralLimit

double TileRawChannelMonTool::m_med_IntegralLimit {}
private

Definition at line 79 of file TileRawChannelMonTool.h.

◆ m_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap
protectedinherited

Definition at line 889 of file ManagedMonitorToolBase.h.

◆ m_minAmpForCorrectedTime

float TileRawChannelMonTool::m_minAmpForCorrectedTime {}
private

Definition at line 172 of file TileRawChannelMonTool.h.

◆ m_nEvents

unsigned int ManagedMonitorToolBase::m_nEvents
protectedinherited

Definition at line 926 of file ManagedMonitorToolBase.h.

◆ m_nEventsIgnoreTrigger

unsigned int ManagedMonitorToolBase::m_nEventsIgnoreTrigger
protectedinherited

Definition at line 927 of file ManagedMonitorToolBase.h.

◆ m_nEventsTileMon

int TileRawChannelMonTool::m_nEventsTileMon {}
private

Definition at line 144 of file TileRawChannelMonTool.h.

◆ m_newEventsBlock

bool ManagedMonitorToolBase::m_newEventsBlock
privateinherited

Definition at line 884 of file ManagedMonitorToolBase.h.

◆ m_newHigStatInterval

bool ManagedMonitorToolBase::m_newHigStatInterval
privateinherited

Definition at line 882 of file ManagedMonitorToolBase.h.

◆ m_newLowStat

bool ManagedMonitorToolBase::m_newLowStat
privateinherited

Definition at line 883 of file ManagedMonitorToolBase.h.

◆ m_newLowStatInterval

bool ManagedMonitorToolBase::m_newLowStatInterval
privateinherited

Definition at line 882 of file ManagedMonitorToolBase.h.

◆ m_newLumiBlock

bool ManagedMonitorToolBase::m_newLumiBlock
privateinherited

Definition at line 883 of file ManagedMonitorToolBase.h.

◆ m_newMedStatInterval

bool ManagedMonitorToolBase::m_newMedStatInterval
privateinherited

Definition at line 882 of file ManagedMonitorToolBase.h.

◆ m_newRun

bool ManagedMonitorToolBase::m_newRun
privateinherited

Definition at line 883 of file ManagedMonitorToolBase.h.

◆ m_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks
protectedinherited

Definition at line 928 of file ManagedMonitorToolBase.h.

◆ m_overlaphists

bool TileRawChannelMonTool::m_overlaphists {}
private

Definition at line 71 of file TileRawChannelMonTool.h.

◆ m_path

std::string ManagedMonitorToolBase::m_path
protectedinherited

Definition at line 915 of file ManagedMonitorToolBase.h.

◆ m_plotDsp

bool TileRawChannelMonTool::m_plotDsp {}
private

Definition at line 83 of file TileRawChannelMonTool.h.

◆ m_preScaleProp

long ManagedMonitorToolBase::m_preScaleProp
protectedinherited

Definition at line 916 of file ManagedMonitorToolBase.h.

◆ m_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp
protectedinherited

Definition at line 914 of file ManagedMonitorToolBase.h.

◆ m_resetAfterSummaryUpdate

bool TileRawChannelMonTool::m_resetAfterSummaryUpdate {}
private

Definition at line 169 of file TileRawChannelMonTool.h.

◆ m_runType

int TileRawChannelMonTool::m_runType {}
private

Definition at line 72 of file TileRawChannelMonTool.h.

◆ m_savePng

bool TilePaterMonTool::m_savePng {}
protectedinherited

Definition at line 228 of file TilePaterMonTool.h.

◆ m_savePs

bool TilePaterMonTool::m_savePs {}
protectedinherited

Definition at line 229 of file TilePaterMonTool.h.

◆ m_saveSvg

bool TilePaterMonTool::m_saveSvg {}
protectedinherited

Definition at line 230 of file TilePaterMonTool.h.

◆ m_storeGraph

bool TileRawChannelMonTool::m_storeGraph {}
private

Definition at line 84 of file TileRawChannelMonTool.h.

◆ m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn
protectedinherited

Definition at line 904 of file ManagedMonitorToolBase.h.

◆ m_summaryUpdateFrequency

int TileRawChannelMonTool::m_summaryUpdateFrequency {}
private

Definition at line 168 of file TileRawChannelMonTool.h.

◆ m_supportedIntervalsForRebooking

std::set<Interval_t> ManagedMonitorToolBase::m_supportedIntervalsForRebooking
privateinherited

Definition at line 959 of file ManagedMonitorToolBase.h.

◆ m_templateEfficiencies

std::map< Interval_t, std::vector< MgmtParams<TEfficiency> > > ManagedMonitorToolBase::m_templateEfficiencies
protectedinherited

Definition at line 738 of file ManagedMonitorToolBase.h.

◆ m_templateGraphs

std::map< Interval_t, std::vector< MgmtParams<TGraph> > > ManagedMonitorToolBase::m_templateGraphs
protectedinherited

Definition at line 726 of file ManagedMonitorToolBase.h.

◆ m_templateHistograms

std::map< Interval_t, std::vector< MgmtParams<TH1> > > ManagedMonitorToolBase::m_templateHistograms
protectedinherited

Definition at line 722 of file ManagedMonitorToolBase.h.

◆ m_templateLWHistograms

std::map< Interval_t, std::vector< MgmtParams<LWHist> > > ManagedMonitorToolBase::m_templateLWHistograms
protectedinherited

Definition at line 734 of file ManagedMonitorToolBase.h.

◆ m_templateTrees

std::map< Interval_t, std::vector< MgmtParams<TTree> > > ManagedMonitorToolBase::m_templateTrees
protectedinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

◆ m_tfitMap

std::map<int, std::vector<double> > TileRawChannelMonTool::m_tfitMap
private

Definition at line 86 of file TileRawChannelMonTool.h.

◆ m_THistSvc

ServiceHandle<ITHistSvc> ManagedMonitorToolBase::m_THistSvc
protectedinherited

Definition at line 906 of file ManagedMonitorToolBase.h.

◆ m_tileHWID

const TileHWID* TilePaterMonTool::m_tileHWID {}
protectedinherited

Definition at line 224 of file TilePaterMonTool.h.

◆ m_tileID

const TileID* TilePaterMonTool::m_tileID {}
protectedinherited

Definition at line 223 of file TilePaterMonTool.h.

◆ m_tileInfo

const TileInfo* TileRawChannelMonTool::m_tileInfo {}
private

Definition at line 175 of file TileRawChannelMonTool.h.

◆ m_tileTBID

const TileTBID* TilePaterMonTool::m_tileTBID {}
protectedinherited

Definition at line 225 of file TilePaterMonTool.h.

◆ m_tileToolEmscale

ToolHandle<TileCondToolEmscale> TileRawChannelMonTool::m_tileToolEmscale
private

Definition at line 87 of file TileRawChannelMonTool.h.

◆ m_TMDB_EB_cell_names

std::string TilePaterMonTool::m_TMDB_EB_cell_names[4] = {"D5L", "D5R", "D6L", "D6R"}
protectedinherited

Definition at line 253 of file TilePaterMonTool.h.

◆ m_TMDB_LB_cell_names

std::string TilePaterMonTool::m_TMDB_LB_cell_names[8] = {"D0", "D1L", "D1R", "D2R", "D2L", "D3L", "D3R", ""}
protectedinherited

Definition at line 252 of file TilePaterMonTool.h.

◆ m_trigDecTool

PublicToolHandle<Trig::ITrigDecisionTool> ManagedMonitorToolBase::m_trigDecTool {this, "TrigDecisionTool",""}
protectedinherited

Definition at line 908 of file ManagedMonitorToolBase.h.

◆ m_triggerChainProp

std::string ManagedMonitorToolBase::m_triggerChainProp
protectedinherited

Definition at line 917 of file ManagedMonitorToolBase.h.

◆ m_triggerGroupProp

std::string ManagedMonitorToolBase::m_triggerGroupProp
protectedinherited

Definition at line 918 of file ManagedMonitorToolBase.h.

◆ m_trigLiveFractionDataKey

SG::ReadCondHandleKey<TrigLiveFractionCondData> ManagedMonitorToolBase::m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"}
privateinherited

Definition at line 953 of file ManagedMonitorToolBase.h.

◆ m_trigTranslator

PublicToolHandle<ITriggerTranslatorTool> ManagedMonitorToolBase::m_trigTranslator {this,"TriggerTranslatorTool",""}
protectedinherited

Definition at line 910 of file ManagedMonitorToolBase.h.

◆ m_UpLimit

double TileRawChannelMonTool::m_UpLimit {}
private

Definition at line 77 of file TileRawChannelMonTool.h.

◆ m_useLumi

bool ManagedMonitorToolBase::m_useLumi
privateinherited

Definition at line 957 of file ManagedMonitorToolBase.h.

◆ m_useratioerror

bool TileRawChannelMonTool::m_useratioerror {}
private

Definition at line 81 of file TileRawChannelMonTool.h.

◆ m_useTrigger

bool ManagedMonitorToolBase::m_useTrigger
protectedinherited

Definition at line 920 of file ManagedMonitorToolBase.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vTrigChainNames

std::vector<std::string> ManagedMonitorToolBase::m_vTrigChainNames
protectedinherited

Definition at line 742 of file ManagedMonitorToolBase.h.

◆ m_vTrigGroupNames

std::vector<std::string> ManagedMonitorToolBase::m_vTrigGroupNames
protectedinherited

Definition at line 742 of file ManagedMonitorToolBase.h.

The documentation for this class was generated from the following files:
AthenaMonManager::ownedLWHistOfKey
virtual LWHist * ownedLWHistOfKey(const std::string &key) const
Definition: AthenaMonManager.cxx:726
grepfile.info
info
Definition: grepfile.py:38
TileRawChannelMonTool::m_contNameDSP
std::string m_contNameDSP
Definition: TileRawChannelMonTool.h:74
ManagedMonitorToolBase::m_nEvents
unsigned int m_nEvents
Definition: ManagedMonitorToolBase.h:926
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
LWHist
Definition: LWHist.h:26
TileRawChannelContainer
Definition: TileRawChannelContainer.h:13
TileRawChannelMonTool::m_med_IntegralLimit
double m_med_IntegralLimit
Definition: TileRawChannelMonTool.h:79
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:1098
TilePaterMonTool::removeTObj
StatusCode removeTObj(TObject *obj)
Definition: TilePaterMonTool.cxx:468
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
ManagedMonitorToolBase::m_templateEfficiencies
std::map< Interval_t, std::vector< MgmtParams< TEfficiency > > > m_templateEfficiencies
Definition: ManagedMonitorToolBase.h:738
AthenaMonManager::writeAndDeleteLWHist
virtual LWHist * writeAndDeleteLWHist(const std::string &key, const std::string &streamName)
Definition: AthenaMonManager.cxx:743
ManagedMonitorToolBase::streamNameFunction
virtual StreamNameFcn * streamNameFunction()
Returns the function object that converts logical paramters into a physical stream name.
Definition: ManagedMonitorToolBase.cxx:503
TilePaterMonTool::book1F
TH1F * book1F(std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
Definition: TilePaterMonTool.cxx:175
TileRawChannelMonTool::m_tfitMap
std::map< int, std::vector< double > > m_tfitMap
Definition: TileRawChannelMonTool.h:86
TileRawChannelMonTool::checkDmuHeaderFormat
bool checkDmuHeaderFormat(uint32_t header)
Function to check that the DMU header format is correct bit_31 of the DMU header must be 1 and bit_17...
Definition: TileRawChannelMonTool.h:103
ManagedMonitorToolBase::m_newRun
bool m_newRun
Definition: ManagedMonitorToolBase.h:883
TileRawChannelMonTool::chi2dsp
@ chi2dsp
Definition: TileRawChannelMonTool.h:134
ManagedMonitorToolBase::m_supportedIntervalsForRebooking
std::set< Interval_t > m_supportedIntervalsForRebooking
Definition: ManagedMonitorToolBase.h:959
TileRawChannelMonTool::m_drawHists
bool m_drawHists
Definition: TileRawChannelMonTool.h:171
TileRawChannelMonTool::m_lo_IntegralLimit
double m_lo_IntegralLimit
Definition: TileRawChannelMonTool.h:78
defineDB.smd
string smd
Definition: JetTagCalibration/share/defineDB.py:44
TileRawChannelMonTool::checkDmuHeader
bool checkDmuHeader(std::vector< uint32_t > *headerVec, int dmu)
The following three functions are implemented to filter data corruption, copied from TileDigitsMonToo...
Definition: TileRawChannelMonTool.cxx:1942
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
ManagedMonitorToolBase::m_path
std::string m_path
Definition: ManagedMonitorToolBase.h:915
ymin
double ymin
Definition: listroot.cxx:63
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
checkFileSG.line
line
Definition: checkFileSG.py:75
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
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:1589
ManagedMonitorToolBase::m_newEventsBlock
bool m_newEventsBlock
Definition: ManagedMonitorToolBase.h:884
TilePaterMonTool::NO_ROB
@ NO_ROB
Definition: TilePaterMonTool.h:65
algorithm
std::string algorithm
Definition: hcg.cxx:82
mean
void mean(std::vector< double > &bins, std::vector< double > &values, const std::vector< std::string > &files, const std::string &histname, const std::string &tplotname, const std::string &label="")
Definition: dependence.cxx:254
get_generator_info.result
result
Definition: get_generator_info.py:21
header
Definition: hcg.cxx:526
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
TileDCSDataPlotter.max1
max1
Definition: TileDCSDataPlotter.py:884
athena.path
path
python interpreter configuration --------------------------------------—
Definition: athena.py:126
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
max
#define max(a, b)
Definition: cfImp.cxx:41
TileRawChannelMonTool::NsumDsp
@ NsumDsp
Definition: TileRawChannelMonTool.h:138
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
AddEmptyComponent.histName
string histName
Definition: AddEmptyComponent.py:64
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:28
ManagedMonitorToolBase::deregHist
virtual StatusCode deregHist(LWHist *h)
Definition: ManagedMonitorToolBase.cxx:1826
TilePaterMonTool::initialize
virtual StatusCode initialize() override
Definition: TilePaterMonTool.cxx:106
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TilePaterMonTool::TilePaterMonTool
TilePaterMonTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: TilePaterMonTool.cxx:78
TileRawChannelMonTool::m_bigain
bool m_bigain
Definition: TileRawChannelMonTool.h:143
TileRawChannelMonTool::m_data
std::unique_ptr< Data > m_data
Definition: TileRawChannelMonTool.h:164
integral
double integral(TH1 *h)
Definition: computils.cxx:57
TilePaterMonTool::ALL_00
@ ALL_00
Definition: TilePaterMonTool.h:65
ManagedMonitorToolBase::higStat
@ higStat
Definition: ManagedMonitorToolBase.h:115
TilePaterMonTool::bookGraphAsymmErrors
TGraphAsymmErrors * bookGraphAsymmErrors(const std::string &dir, const std::string &nam, const std::string &tit, int N, float *X, float *Y, float *X_errors1, float *X_errors2, float *Y_errors1, float *Y_errors2)
Definition: TilePaterMonTool.cxx:515
ManagedMonitorToolBase::lumiBlock
@ lumiBlock
Definition: ManagedMonitorToolBase.h:114
TileRawChannelMonTool::bookHists
virtual StatusCode bookHists() override
Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers.
Definition: TileRawChannelMonTool.cxx:123
ManagedMonitorToolBase::m_endOfLumiBlock
bool m_endOfLumiBlock
Definition: ManagedMonitorToolBase.h:885
TH1I
Definition: rootspy.cxx:332
TH2F
Definition: rootspy.cxx:420
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
TileRawChannelMonTool::m_runType
int m_runType
Definition: TileRawChannelMonTool.h:72
PixelAthClusterMonAlgCfg.zmin
zmin
Definition: PixelAthClusterMonAlgCfg.py:176
TilePaterMonTool::m_fragIDsDemonstrators
std::vector< int > m_fragIDsDemonstrators
Definition: TilePaterMonTool.h:233
index
Definition: index.py:1
ManagedMonitorToolBase::m_THistSvc
ServiceHandle< ITHistSvc > m_THistSvc
Definition: ManagedMonitorToolBase.h:906
ManagedMonitorToolBase::m_procNEventsProp
long m_procNEventsProp
Definition: ManagedMonitorToolBase.h:914
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
AthenaMonManager::writeAndResetLWHist
virtual LWHist * writeAndResetLWHist(const std::string &key, const std::string &streamName)
Definition: AthenaMonManager.cxx:802
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:1749
TilePaterMonTool::m_EBcellName
std::string m_EBcellName[48]
Definition: TilePaterMonTool.h:235
TilePaterMonTool::m_savePng
bool m_savePng
Definition: TilePaterMonTool.h:228
TileRawChannelMonTool::sumEdsp
@ sumEdsp
Definition: TileRawChannelMonTool.h:138
ReadBchFromCool.pmt
pmt
Definition: ReadBchFromCool.py:62
TilePaterMonTool::regHist
void regHist(const std::string &subDir, T *hist, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, const std::string &trigChain="", const std::string &mergeAlgo="")
Definition: TilePaterMonTool.cxx:52
plotmaker.hist
hist
Definition: plotmaker.py:148
run_gep.alg_name
alg_name
Definition: run_gep.py:298
TilePaterMonTool::m_savePs
bool m_savePs
Definition: TilePaterMonTool.h:229
AthenaMonManager::fileKey
virtual std::string fileKey() const
Definition: AthenaMonManager.cxx:699
TileRawChannelMonTool::fillSummaryHistograms
StatusCode fillSummaryHistograms()
Definition: TileRawChannelMonTool.cxx:1038
TileRawChannelUnit::CesiumPicoCoulombs
@ CesiumPicoCoulombs
Definition: TileRawChannelUnit.h:19
AthenaMonManager::AOD
@ AOD
Definition: AthenaMonManager.h:49
AthenaMonManager::passOwnership
virtual void passOwnership(TObject *h, const std::string &key)
Pass ownership of a TObject/LWHist to this manager so that it will be deleted appropriately.
Definition: AthenaMonManager.cxx:707
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
TilePaterMonTool::CRC_ERR
@ CRC_ERR
Definition: TilePaterMonTool.h:65
TilePaterMonTool::m_LBcellName
std::string m_LBcellName[48]
Definition: TilePaterMonTool.h:240
ManagedMonitorToolBase::lbDuration
virtual double lbDuration(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Luminosity block time (in seconds)
Definition: ManagedMonitorToolBase.cxx:2047
ManagedMonitorToolBase::m_trigDecTool
PublicToolHandle< Trig::ITrigDecisionTool > m_trigDecTool
Definition: ManagedMonitorToolBase.h:908
TilePaterMonTool::m_chMapEB
int m_chMapEB[48]
Definition: TilePaterMonTool.h:270
TH1I_LW
Definition: TH1I_LW.h:23
skel.it
it
Definition: skel.GENtoEVGEN.py:423
TProfile2D
Definition: rootspy.cxx:531
TH1D
Definition: rootspy.cxx:342
PixelAthClusterMonAlgCfg.ybins
ybins
Definition: PixelAthClusterMonAlgCfg.py:163
TH1I_LW::create
static TH1I_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xlow, const double &xup)
Definition: TH1I_LW.cxx:33
TileRawChannelMonTool::CisRun
@ CisRun
Definition: TileRawChannelMonTool.h:128
bin
Definition: BinsDiffFromStripMedian.h:43
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
TileRawChannelMonTool::m_bookAll
bool m_bookAll
Definition: TileRawChannelMonTool.h:69
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
LWHistAthMonWrapper::setStreamName
static void setStreamName(LWHist *, const std::string &streamName)
ManagedMonitorToolBase::m_dataType
AthenaMonManager::DataType_t m_dataType
Definition: ManagedMonitorToolBase.h:901
TileRawChannelMonTool::drawDsp
void drawDsp(int ros, int drawer, const std::string &moduleName)
Definition: TileRawChannelMonTool.cxx:1709
TilePaterMonTool::m_chMapLB
int m_chMapLB[48]
Definition: TilePaterMonTool.h:265
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:1693
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
ManagedMonitorToolBase::m_newLowStatInterval
bool m_newLowStatInterval
Definition: ManagedMonitorToolBase.h:882
TileRawChannelMonTool::ratioErrorBar
void ratioErrorBar(TH1S *hist, double &xmin, double &xmax, double mean)
Definition: TileRawChannelMonTool.cxx:1849
ManagedMonitorToolBase::fill
@ fill
Definition: ManagedMonitorToolBase.h:116
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
python.TrigTLAMonitorAlgorithm.triggers
triggers
Definition: TrigTLAMonitorAlgorithm.py:196
TileRawChannelMonTool::Unknown
@ Unknown
Definition: TileRawChannelMonTool.h:124
TileDigitsContainer
Definition: TileDigitsContainer.h:13
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
TileRawChannelMonTool::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
Definition: TileRawChannelMonTool.h:87
TileRawChannelMonTool::m_calibUnit
TileRawChannelUnit::UNIT m_calibUnit
Definition: TileRawChannelMonTool.h:166
TileRawChannelUnit::PicoCoulombs
@ PicoCoulombs
Definition: TileRawChannelUnit.h:18
TileRawData::adc_HWID
HWIdentifier adc_HWID(void) const
Definition: TileRawData.h:53
HWIdentifier
Definition: HWIdentifier.h:13
TProfile_LW
Definition: TProfile_LW.h:24
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
TileRawChannel::time
float time(int ind=0) const
Definition: TileRawChannel.h:103
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:83
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
ManagedMonitorToolBase::registerMetadata
StatusCode registerMetadata(const std::string &streamName, const std::string &hName, const MonGroup &group)
Definition: ManagedMonitorToolBase.cxx:1006
TilePaterMonTool::book2F
TH2F * book2F(std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
Definition: TilePaterMonTool.cxx:244
TileRawChannelMonTool::m_cispar
const uint32_t * m_cispar
Definition: TileRawChannelMonTool.h:141
TH2S
Definition: rootspy.cxx:400
ManagedMonitorToolBase::m_newHigStatInterval
bool m_newHigStatInterval
Definition: ManagedMonitorToolBase.h:882
ManagedMonitorToolBase::m_newMedStatInterval
bool m_newMedStatInterval
Definition: ManagedMonitorToolBase.h:882
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
TruthTest.itE
itE
Definition: TruthTest.py:25
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TileRawChannelMonTool::m_doLaserSummaryVsPMT
bool m_doLaserSummaryVsPMT
Definition: TileRawChannelMonTool.h:170
Monitored::X
@ X
Definition: HistogramFillerUtils.h:24
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TileRawChannelMonTool::bookSummaryHistograms
void bookSummaryHistograms(int ros, int drawer)
Definition: TileRawChannelMonTool.cxx:901
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
AthenaMonManager::environment
static Environment_t environment()
Returns the running environment of the monitoring application to help ManagedMonitorToolBase objects ...
Definition: AthenaMonManager.cxx:321
AthExHiveOpts.Time
Time
Definition: AthExHiveOpts.py:63
LWHistAthMonWrapper::streamName
static const std::string & streamName(LWHist *)
TilePaterMonTool::NO_FRAG
@ NO_FRAG
Definition: TilePaterMonTool.h:65
python.checkMetadata.metadata
metadata
Definition: checkMetadata.py:175
TilePaterMonTool::m_chMapEBsp
int m_chMapEBsp[48]
Definition: TilePaterMonTool.h:275
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:269
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
TileRawChannel::quality
float quality(int ind=0) const
Definition: TileRawChannel.h:105
ManagedMonitorToolBase::m_bookHistogramsInitial
bool m_bookHistogramsInitial
Definition: ManagedMonitorToolBase.h:956
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
LWHist::usingROOTBackend
bool usingROOTBackend() const
Definition: LWHist.h:73
TileRawChannelMonTool::m_storeGraph
bool m_storeGraph
Definition: TileRawChannelMonTool.h:84
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
ManagedMonitorToolBase::getNewStreamNameFcn
virtual StreamNameFcn * getNewStreamNameFcn() const
Definition: ManagedMonitorToolBase.cxx:2388
ManagedMonitorToolBase::m_preScaleProp
long m_preScaleProp
Definition: ManagedMonitorToolBase.h:916
TileRawChannelMonTool::m_minAmpForCorrectedTime
float m_minAmpForCorrectedTime
Definition: TileRawChannelMonTool.h:172
WriteCellNoiseToCool.gn
gn
Definition: WriteCellNoiseToCool.py:531
LWHistAthMonWrapper::removeCustomData
static void removeCustomData(LWHist *)
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ManagedMonitorToolBase::m_fileKey
std::string m_fileKey
Definition: ManagedMonitorToolBase.h:896
TileRawChannelMonTool::m_plotDsp
bool m_plotDsp
Definition: TileRawChannelMonTool.h:83
TilePaterMonTool::m_saveSvg
bool m_saveSvg
Definition: TilePaterMonTool.h:230
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition: TileDQstatus.h:49
TileRawChannelMonTool::checkDmuHeaderParity
bool checkDmuHeaderParity(uint32_t header)
Function to check that the DMU header parity is correct Parity of the DMU header should be odd Return...
Definition: TileRawChannelMonTool.h:113
TileDCSDataPlotter.tit
tit
Definition: TileDCSDataPlotter.py:890
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
TileRawChannelMonTool::GetTimeFitFunc
TF1 * GetTimeFitFunc(TH2S *hist2d)
Time Slope parameters for CIS runs.
Definition: TileRawChannelMonTool.cxx:1909
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:1993
ManagedMonitorToolBase::m_templateGraphs
std::map< Interval_t, std::vector< MgmtParams< TGraph > > > m_templateGraphs
Definition: ManagedMonitorToolBase.h:726
TH1C
Definition: rootspy.cxx:352
TileRawChannelMonTool::m_useratioerror
bool m_useratioerror
Definition: TileRawChannelMonTool.h:81
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthenaMonManager::dataType
static DataType_t dataType()
Returns the data type that the monitoring application is running over to help ManagedMonitorToolBase ...
Definition: AthenaMonManager.cxx:338
TileRawChannel::amplitude
float amplitude(int ind=0) const
Definition: TileRawChannel.h:101
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ManagedMonitorToolBase::m_manager
AthenaMonManager * m_manager
Definition: ManagedMonitorToolBase.h:892
TileRawChannelMonTool::m_intCalibUnit
int m_intCalibUnit
Definition: TileRawChannelMonTool.h:178
LWHistAthMonWrapper::key
static const std::string & key(LWHist *)
ManagedMonitorToolBase::m_lumiDataKey
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey
Definition: ManagedMonitorToolBase.h:950
ManagedMonitorToolBase::deregGraph
virtual StatusCode deregGraph(TGraph *g)
De-registers a TGraph from the THistSvc, but does NOT delete the object.
Definition: ManagedMonitorToolBase.cxx:1844
ManagedMonitorToolBase::m_streamNameFcn
StreamNameFcn * m_streamNameFcn
Definition: ManagedMonitorToolBase.h:904
TileRawChannelMonTool::PhysRun
@ PhysRun
Definition: TileRawChannelMonTool.h:124
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:193
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
TProfile_LW::create
static TProfile_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xlow, const double &xup, const char *option=" ")
Definition: TProfile_LW.cxx:32
lumiFormat.i
int i
Definition: lumiFormat.py:92
xmin
double xmin
Definition: listroot.cxx:60
python.TrigEgammaMonitorHelper.TProfile
def TProfile(*args, **kwargs)
Definition: TrigEgammaMonitorHelper.py:81
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
AthenaMonManager::tier0
@ tier0
Definition: AthenaMonManager.h:49
TH2I_LW::create
static TH2I_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xmin, const double &xmax, unsigned nbinsy, const double &ymin, const double &ymax)
Definition: TH2I_LW.cxx:33
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
TileRawChannelMonTool::m_contName
std::string m_contName
Definition: TileRawChannelMonTool.h:73
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
TH2I
Definition: rootspy.cxx:410
TileRawDataContainer::get_bsflags
uint32_t get_bsflags() const
Definition: TileRawDataContainer.h:64
TGraph1
Definition: TilePaterMonTool.cxx:409
TilePaterMonTool::book2S
TH2S * book2S(std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
Definition: TilePaterMonTool.cxx:279
ManagedMonitorToolBase::file
@ file
Definition: ManagedMonitorToolBase.h:114
TileRawChannelUnit::Invalid
@ Invalid
Definition: TileRawChannelUnit.h:26
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:870
TileRawChannelMonTool::m_dac2Charge
double m_dac2Charge[3]
Definition: TileRawChannelMonTool.h:179
covarianceTool.title
title
Definition: covarianceTool.py:542
getLatestRuns.interval
interval
Definition: getLatestRuns.py:24
TileRawChannelMonTool::m_tileInfo
const TileInfo * m_tileInfo
Definition: TileRawChannelMonTool.h:175
TileRawChannelMonTool::resetSummaryHistograms
void resetSummaryHistograms()
Definition: TileRawChannelMonTool.cxx:1012
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:522
ManagedMonitorToolBase::ATTRIB_UNMANAGED
@ ATTRIB_UNMANAGED
Definition: ManagedMonitorToolBase.h:131
TileRawChannel
Definition: TileRawChannel.h:35
PixelAthClusterMonAlgCfg.zmax
zmax
Definition: PixelAthClusterMonAlgCfg.py:176
test_pyathena.parent
parent
Definition: test_pyathena.py:15
AthenaMonManager::tier0Raw
@ tier0Raw
Definition: AthenaMonManager.h:49
TilePaterMonTool::m_TMDB_LB_cell_names
std::string m_TMDB_LB_cell_names[8]
Definition: TilePaterMonTool.h:252
TileRawChannelMonTool::m_UpLimit
double m_UpLimit
Definition: TileRawChannelMonTool.h:77
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:242
AthenaMonManager::user
@ user
Definition: AthenaMonManager.h:49
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
ManagedMonitorToolBase::ATTRIB_MANAGED
@ ATTRIB_MANAGED
Definition: ManagedMonitorToolBase.h:131
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.
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
TileRawChannelMonTool::finalDsp
StatusCode finalDsp(int ros, int drawer)
Definition: TileRawChannelMonTool.cxx:1312
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:236
TH1F::SetBinContent
void SetBinContent(int, double)
Definition: rootspy.cxx:327
TH2D
Definition: rootspy.cxx:430
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
ManagedMonitorToolBase::medStat
@ medStat
Definition: ManagedMonitorToolBase.h:115
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
TileRawChannelMonTool::m_DQstatusKey
SG::ReadHandleKey< TileDQstatus > m_DQstatusKey
Definition: TileRawChannelMonTool.h:177
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
ManagedMonitorToolBase::m_templateTrees
std::map< Interval_t, std::vector< MgmtParams< TTree > > > m_templateTrees
Definition: ManagedMonitorToolBase.h:730
ManagedMonitorToolBase::m_metadataMap
MDMap_t m_metadataMap
Definition: ManagedMonitorToolBase.h:889
TilePaterMonTool::ALL_OK
@ ALL_OK
Definition: TilePaterMonTool.h:65
ManagedMonitorToolBase::m_endOfEventsBlock
bool m_endOfEventsBlock
Definition: ManagedMonitorToolBase.h:885
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
TileRawChannelMonTool::m_is12bit
bool m_is12bit
Definition: TileRawChannelMonTool.h:176
fcn
void fcn(int &, double *, double &result, double par[], int)
this is where we write out chi2
Definition: Chi2LJets.cxx:183
ManagedMonitorToolBase::m_trigLiveFractionDataKey
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey
Definition: ManagedMonitorToolBase.h:954
TileRawChannelMonTool::drawHists
void drawHists(int ros, int drawer, const std::string &moduleName)
Definition: TileRawChannelMonTool.cxx:1429
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition: ManagedMonitorToolBase.h:902
TileRawChannelMonTool::Edsp
@ Edsp
Definition: TileRawChannelMonTool.h:134
beamspotman.dir
string dir
Definition: beamspotman.py:623
min
#define min(a, b)
Definition: cfImp.cxx:40
TileRawChannelMonTool::Tdsp
@ Tdsp
Definition: TileRawChannelMonTool.h:134
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
TilePaterMonTool::regGraph
void regGraph(const std::string &subDir, T *graph, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, const std::string &trigChain="", const std::string &mergeAlgo="")
Definition: TilePaterMonTool.cxx:65
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
TileRawChannelMonTool::LaserFancyPlotting
void LaserFancyPlotting(int ros, int drawer, int maxgain, const std::string &moduleName)
Definition: TileRawChannelMonTool.cxx:1974
Monitored::Y
@ Y
Definition: HistogramFillerUtils.h:24
ManagedMonitorToolBase::m_newLumiBlock
bool m_newLumiBlock
Definition: ManagedMonitorToolBase.h:883
ManagedMonitorToolBase::m_endOfLowStat
bool m_endOfLowStat
Definition: ManagedMonitorToolBase.h:885
TileRawChannelMonTool::bookDsp
void bookDsp(int ros, int drawer)
Definition: TileRawChannelMonTool.cxx:360
TileRawChannelMonTool::Edsp_fit
@ Edsp_fit
Definition: TileRawChannelMonTool.h:134
ManagedMonitorToolBase::m_lbDurationDataKey
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey
Definition: ManagedMonitorToolBase.h:952
TH2I_LW
Definition: TH2I_LW.h:23
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
TileRawChannelMonTool::m_summaryUpdateFrequency
int m_summaryUpdateFrequency
Definition: TileRawChannelMonTool.h:168
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
TileRawChannelMonTool::sumTdsp_fit
@ sumTdsp_fit
Definition: TileRawChannelMonTool.h:138
LWHistAthMonWrapper::setKey
static void setKey(LWHist *, const std::string &key)
charge
double charge(const T &p)
Definition: AtlasPID.h:494
TileRawChannelMonTool::m_book2D
bool m_book2D
Definition: TileRawChannelMonTool.h:70
TileRawChannelMonTool::Tdsp_fit
@ Tdsp_fit
Definition: TileRawChannelMonTool.h:134
TProfile
Definition: rootspy.cxx:515
TilePaterMonTool::m_fragIDsToIgnoreDMUerrors
std::vector< int > m_fragIDsToIgnoreDMUerrors
Definition: TilePaterMonTool.h:232
item
Definition: ItemListSvc.h:43
TilePaterMonTool::book1S
TH1S * book1S(std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
Definition: TilePaterMonTool.cxx:197
TileDQstatus::cispar
const uint32_t * cispar() const
CIS parameters.
Definition: TileDQstatus.h:152
ManagedMonitorToolBase::lowStat
@ lowStat
Definition: ManagedMonitorToolBase.h:115
LWHist::setOwnsROOTHisto
void setOwnsROOTHisto(bool b)
Definition: LWHist.h:75
ManagedMonitorToolBase::m_lwhists
std::set< LWHist * > m_lwhists
Definition: ManagedMonitorToolBase.h:891
TilePaterMonTool::book2D
TH2D * book2D(const std::string &nam, const std::string &tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax)
Implicit version of book2D.
Definition: TilePaterMonTool.h:76
TileRawChannelMonTool::m_efitThresh
double m_efitThresh
Definition: TileRawChannelMonTool.h:88
LArCellBinning.xbins
int xbins
Definition: LArCellBinning.py:163
ManagedMonitorToolBase::m_templateLWHistograms
std::map< Interval_t, std::vector< MgmtParams< LWHist > > > m_templateLWHistograms
Definition: ManagedMonitorToolBase.h:734
TilePaterMonTool::isDisconnected
bool isDisconnected(int ros, int drawer, int ch)
Definition: TilePaterMonTool.h:281
ManagedMonitorToolBase::m_managerNameProp
std::string m_managerNameProp
Definition: ManagedMonitorToolBase.h:894
ManagedMonitorToolBase::run
@ run
Definition: ManagedMonitorToolBase.h:116
ManagedMonitorToolBase::m_endOfRun
bool m_endOfRun
Definition: ManagedMonitorToolBase.h:885
TileRawChannelMonTool::fillDsp
StatusCode fillDsp(std::map< int, std::vector< double > > &efitMap, std::map< int, std::vector< double > > &tfitMap)
Definition: TileRawChannelMonTool.cxx:797
TileCalibUtils::getDrawerString
static std::string getDrawerString(unsigned int ros, unsigned int drawer)
Return the drawer name, e.g.
Definition: TileCalibUtils.cxx:145
TileRawChannelMonTool::m_DownLimit
double m_DownLimit
Definition: TileRawChannelMonTool.h:76
TileRawChannelMonTool::LasRun
@ LasRun
Definition: TileRawChannelMonTool.h:125
ManagedMonitorToolBase::m_newLowStat
bool m_newLowStat
Definition: ManagedMonitorToolBase.h:883
TileRawChannelMonTool::m_overlaphists
bool m_overlaphists
Definition: TileRawChannelMonTool.h:71
DeMoScan.index
string index
Definition: DeMoScan.py:362
AthenaPoolExample_Copy.streamName
string streamName
Definition: AthenaPoolExample_Copy.py:39
TilePaterMonTool::m_cabling
const TileCablingService * m_cabling
Definition: TilePaterMonTool.h:226
lumiFormat.lumi
lumi
Definition: lumiFormat.py:113
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
TileRawData::cell_ID_index
Identifier cell_ID_index(int &index, int &pmt) const
Definition: TileRawData.cxx:65
a
TList * a
Definition: liststreamerinfos.cxx:10
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
TileHWID::drawer
int drawer(const HWIdentifier &id) const
extract drawer field from HW identifier
Definition: TileHWID.h:171
python.compareTCTs.ratio
ratio
Definition: compareTCTs.py:295
TH1F
Definition: rootspy.cxx:320
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
python.CaloScaleNoiseConfig.str
str
Definition: CaloScaleNoiseConfig.py:78
TH2C
Definition: rootspy.cxx:390
TH1S
Definition: rootspy.cxx:362
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
TileRawDataContainer::get_unit
UNIT get_unit() const
Definition: TileRawDataContainer.h:60
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TileRawChannelMonTool::MonoRun
@ MonoRun
Definition: TileRawChannelMonTool.h:129
AthenaMonManager::altprod
@ altprod
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::eventsBlock
@ eventsBlock
Definition: ManagedMonitorToolBase.h:114
python.envutil.filelist
filelist
print ("Checking files %s..." % fullfile)
Definition: envutil.py:152
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TH1
Definition: rootspy.cxx:268
TileCablingService::channel2hole
static int channel2hole(int ros, int channel)
Definition: TileCablingService.cxx:1946
DEBUG
#define DEBUG
Definition: page_access.h:11
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
TileRawChannelMonTool::PedRun
@ PedRun
Definition: TileRawChannelMonTool.h:127
DiTauMassTools::HistInfoV2::RMS
@ RMS
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:31
TilePaterMonTool::book1D
TH1D * book1D(const std::string &nam, const std::string &tit, int nx, double xmin, double xmax)
Implicit version of book1D.
Definition: TilePaterMonTool.h:69
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
xmax
double xmax
Definition: listroot.cxx:61
ManagedMonitorToolBase::all
@ all
Definition: ManagedMonitorToolBase.h:116
beamspotnt.rms
rms
Definition: bin/beamspotnt.py:1266
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:1852
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
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...
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
TileRawChannelMonTool::m_nEventsTileMon
int m_nEventsTileMon
Definition: TileRawChannelMonTool.h:144
TileRawChannelMonTool::sumEdsp_fit
@ sumEdsp_fit
Definition: TileRawChannelMonTool.h:138
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:1960
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
python.Logging.manager
manager
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/Logging.py:92
TileRawChannelMonTool::m_infoName
std::string m_infoName
Definition: TileRawChannelMonTool.h:174
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition: TileCalibUtils.cxx:60
TileRawChannelMonTool::m_corrup
bool m_corrup[5][64][2][16]
Definition: TileRawChannelMonTool.h:97
TilePaterMonTool::ALL_FF
@ ALL_FF
Definition: TilePaterMonTool.h:65
python.LumiCalcRecover.subdir
subdir
Definition: LumiCalcRecover.py:25
ManagedMonitorToolBase::m_templateHistograms
std::map< Interval_t, std::vector< MgmtParams< TH1 > > > m_templateHistograms
Definition: ManagedMonitorToolBase.h:722
TilePaterMonTool::m_tileHWID
const TileHWID * m_tileHWID
Definition: TilePaterMonTool.h:224
ManagedMonitorToolBase::ATTRIB_X_VS_LB
@ ATTRIB_X_VS_LB
Definition: ManagedMonitorToolBase.h:131
TilePaterMonTool::m_TMDB_EB_cell_names
std::string m_TMDB_EB_cell_names[4]
Definition: TilePaterMonTool.h:253
ManagedMonitorToolBase::Imp::s_svcLocator
static std::atomic< ISvcLocator * > s_svcLocator
Definition: ManagedMonitorToolBase.cxx:41
TileRawChannelMonTool::rangeErrorBar
void rangeErrorBar(double &xmin, double &max, double mean)
Definition: TileRawChannelMonTool.cxx:1833
python.PyAthena.obj
obj
Definition: PyAthena.py:135
ManagedMonitorToolBase::m_trigTranslator
PublicToolHandle< ITriggerTranslatorTool > m_trigTranslator
Definition: ManagedMonitorToolBase.h:910
TilePaterMonTool::book1Sx
TH1S * book1Sx(std::string dir, std::string nam, std::string tit, int nx, const Double_t *xlgbins, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
Definition: TilePaterMonTool.cxx:208
LWHist::getROOTHistBase
virtual TH1 * getROOTHistBase()=0
TileRawChannelMonTool::m_efitMap
std::map< int, std::vector< double > > m_efitMap
Definition: TileRawChannelMonTool.h:85
TMultiGraph1
Definition: TilePaterMonTool.cxx:528
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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:1454
TileInfo::ADCmax
int ADCmax() const
Returns the maximum ADC output (10 bits --> 1023)
Definition: TileInfo.h:71
TileRawChannelMonTool::CisRamp
@ CisRamp
Definition: TileRawChannelMonTool.h:130
merge
Definition: merge.py:1
AthenaMonManager::noOutput
@ noOutput
Definition: AthenaMonManager.h:49
TileRawChannelMonTool::m_hi_IntegralLimit
double m_hi_IntegralLimit
Definition: TileRawChannelMonTool.h:80
ManagedMonitorToolBase::intervalEnumToString
static std::string intervalEnumToString(Interval_t interval)
Converts a LevelOfDetail_t to a string of the same name.
Definition: ManagedMonitorToolBase.cxx:588
fitman.k
k
Definition: fitman.py:528
ymax
double ymax
Definition: listroot.cxx:64
ManagedMonitorToolBase::m_defaultLBDuration
float m_defaultLBDuration
Definition: ManagedMonitorToolBase.h:958
TileRawChannelMonTool::m_resetAfterSummaryUpdate
bool m_resetAfterSummaryUpdate
Definition: TileRawChannelMonTool.h:169
TProfile::GetBinContent
double GetBinContent(int) const
Definition: rootspy.cxx:527
TileRawChannelMonTool::LedRun
@ LedRun
Definition: TileRawChannelMonTool.h:126
Generated on Sun Jun 30 2024 22:02:49 for ATLAS Offline Software by   doxygen 1.8.18