ATLAS Offline Software
Loading...
Searching...
No Matches
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.
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 ).
virtual StatusCode finalHists () override
 Calls procHists( true, true, true ).
virtual StatusCode checkHists (bool fromFinalize) override
 This implementation does nothing; equivalent functionality may be provided by procHists(...) with appropriate arguments.
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.
void LaserFancyPlotting (int ros, int drawer, int maxgain, const std::string &moduleName)
virtual StreamNameFcn * streamNameFunction ()
 Returns the function object that converts logical paramters into a physical stream name.
virtual StatusCode bookHistograms ()
 An inheriting class should either override this function or bookHists().
virtual StatusCode bookHistogramsRecurrent ()
 An inheriting class should either override this function, bookHists() or bookHistograms().
virtual StatusCode fillHistograms ()
 An inheriting class should either override this function or fillHists().
virtual StatusCode procHistograms ()
 An inheriting class should either override this function or finalHists().
virtual void setMonManager (AthenaMonManager *manager)
 Takes a pointer to a managing object to get information from it when needed.
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.
virtual StatusCode getHist (TH1 *&h, const std::string &hName, const MonGroup &group)
 Returns a TH1 via the pointer passed as the first argument.
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.
virtual StatusCode getHist (TH2 *&h, const std::string &hName, const MonGroup &group)
 Returns a TH2 via the pointer passed as the first argument.
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.
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.
virtual StatusCode regTree (TTree *t, const MonGroup &group)
 Registers a TTree to be included in the output stream using logical parameters that describe it.
virtual StatusCode writeAndDelete (TH1 *h, const MonGroup &group)
 Write out histogram and delete it.
virtual StatusCode deregHist (TH1 *h)
 De-registers a TH1 from the THistSvc, but does NOT delete the object.
virtual StatusCode deregGraph (TGraph *g)
 De-registers a TGraph from the THistSvc, but does NOT delete the object.
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.
virtual StatusCode deregObject (const std::string &objName, const MonGroup &group)
 De-registers a TObject from the THistSvc, but does NOT delete the object.
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.
virtual StatusCode runStat ()
 This implementation does nothing; equivalent functionality may be provided by procHists( true, true, true ).
virtual bool preSelector ()
virtual float lbAverageInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average mu, i.e.
virtual float lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Instantaneous number of interactions, i.e.
virtual float lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)
virtual float lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Instantaneous luminosity.
virtual double lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Luminosity block time (in seconds)
virtual float lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average luminosity livefraction.
virtual float livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Livefraction per bunch crossing ID.
virtual double lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average Integrated Luminosity Live Fraction.
 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.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () 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.
static Interval_t intervalStringToEnum (const std::string &str)
 Converts a string to the corresponding Interval_t.
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.
TH1D * book1D (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, const std::string &trigChain="", const 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.
TH2D * book2D (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, const std::string &trigChain="", const std::string &mergeAlgo="")
TH1F * book1F (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, const std::string &trigChain="", const std::string &mergeAlgo="")
TH1I * book1I (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, const std::string &trigChain="", const std::string &mergeAlgo="")
TH1S * book1S (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, const std::string &trigChain="", const std::string &mergeAlgo="")
TH1S * book1Sx (const std::string &dir, const std::string &nam, const std::string &tit, int nx, const Double_t *xlgbins, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, const std::string &trigChain="", const std::string &mergeAlgo="")
TH1C * book1C (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, const std::string &trigChain="", const std::string &mergeAlgo="")
TH2F * book2F (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, const std::string &trigChain="", const std::string &mergeAlgo="")
TH2F * book2F (const std::string &dir, const std::string &nam, const std::string &tit, int nx, double xmin, double xmax, int ny, const double *ybins, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, const std::string &trigChain="", const std::string &mergeAlgo="")
TH2I * book2I (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, const std::string &trigChain="", const std::string &mergeAlgo="")
TH2S * book2S (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, const std::string &trigChain="", const std::string &mergeAlgo="")
TH2C * book2C (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, const std::string &trigChain="", const std::string &mergeAlgo="")
TProfile * bookProfile (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, const std::string &trigChain="", const std::string &mergeAlgo="")
TProfile * bookProfile (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, const std::string &trigChain="", const std::string &mergeAlgo="")
TProfile * bookProfile (const std::string &dir, const std::string &nam, const std::string &tit, int nx, const float *xbins, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, const std::string &trigChain="", const std::string &mergeAlgo="")
TProfile2D * bookProfile2D (const std::string &dir, const std::string &nam, const 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, const std::string &trigChain="", const 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)
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.
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.
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.
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.
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 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.
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.
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
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.

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< TEfficiency > > > m_templateEfficiencies
std::vector< std::string > m_vTrigChainNames
std::vector< std::string > m_vTrigGroupNames
MDMap_t m_metadataMap
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.
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.
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.
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

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)
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default)
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 826 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 113 of file ManagedMonitorToolBase.h.

113 { file = 0, eventsBlock, lumiBlock,
114 lowStat, medStat, higStat,
115 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 130 of file ManagedMonitorToolBase.h.

130{ 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 62 of file TilePaterMonTool.h.

62{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 44 of file TileRawChannelMonTool.cxx.

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

◆ ~TileRawChannelMonTool()

TileRawChannelMonTool::~TileRawChannelMonTool ( )
virtual

Definition at line 88 of file TileRawChannelMonTool.cxx.

90{
91}

Member Function Documentation

◆ book1C()

TH1C * TilePaterMonTool::book1C ( 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 179 of file TilePaterMonTool.cxx.

183{
184
185 TH1C* hist = new TH1C(TString(nam), TString(tit), nx, xmin, xmax);
186 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
187 return hist;
188}
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:47
xmax
double xmax
Definition listroot.cxx:61
xmin
double xmin
Definition listroot.cxx:60

◆ book1D() [1/2]

TH1D * TilePaterMonTool::book1D ( 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 157 of file TilePaterMonTool.cxx.

161{
162
163 TH1D* hist = new TH1D(TString(nam), TString(tit), nx, xmin, xmax);
164 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
165 return hist;
166}

◆ book1D() [2/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 66 of file TilePaterMonTool.h.

68 {
69 return book1D(m_path, nam, tit, nx, xmin, xmax);
70 }
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:66

◆ book1F()

TH1F * TilePaterMonTool::book1F ( 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 168 of file TilePaterMonTool.cxx.

172{
173
174 TH1F* hist = new TH1F(TString(nam), TString(tit), nx, xmin, xmax);
175 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
176 return hist;
177}
python.TrigEgammaMonitorHelper.TH1F
TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition TrigEgammaMonitorHelper.py:24

◆ book1I()

TH1I * TilePaterMonTool::book1I ( 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 212 of file TilePaterMonTool.cxx.

216{
217
218 TH1I* hist = new TH1I(TString(nam), TString(tit), nx, xmin, xmax);
219 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
220 return hist;
221}

◆ book1S()

TH1S * TilePaterMonTool::book1S ( 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 190 of file TilePaterMonTool.cxx.

194{
195
196 TH1S* hist = new TH1S(TString(nam), TString(tit), nx, xmin, xmax);
197 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
198 return hist;
199}

◆ book1Sx()

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

Definition at line 201 of file TilePaterMonTool.cxx.

205{
206
207 TH1S* hist = new TH1S(TString(nam), TString(tit), nx, xlgbins);
208 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
209 return hist;
210}

◆ book2C()

TH2C * TilePaterMonTool::book2C ( 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 283 of file TilePaterMonTool.cxx.

288{
289 TH2C* hist = new TH2C(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax);
290 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
291 return hist;
292}
ymin
double ymin
Definition listroot.cxx:63
ymax
double ymax
Definition listroot.cxx:64

◆ book2D() [1/2]

TH2D * TilePaterMonTool::book2D ( 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 226 of file TilePaterMonTool.cxx.

231{
232 TH2D* hist = new TH2D(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax);
233 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
234 return hist;
235}

◆ book2D() [2/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 73 of file TilePaterMonTool.h.

76 {
77 return book2D(m_path, nam, tit, nx, xmin, xmax, ny, ymin, ymax);
78 }
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:73

◆ book2F() [1/2]

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

Definition at line 248 of file TilePaterMonTool.cxx.

253{
254 TH2F* hist = new TH2F(TString(nam), TString(tit), nx, xmin, xmax, ny, ybins);
255 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
256 return hist;
257}
python.TrigEgammaMonitorHelper.TH2F
TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition TrigEgammaMonitorHelper.py:45

◆ book2F() [2/2]

TH2F * TilePaterMonTool::book2F ( 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 237 of file TilePaterMonTool.cxx.

242{
243 TH2F* hist = new TH2F(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax);
244 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
245 return hist;
246}

◆ book2I()

TH2I * TilePaterMonTool::book2I ( 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 260 of file TilePaterMonTool.cxx.

265{
266 TH2I* hist = new TH2I(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax);
267 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
268 return hist;
269}

◆ book2S()

TH2S * TilePaterMonTool::book2S ( 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 272 of file TilePaterMonTool.cxx.

277{
278 TH2S *hist = new TH2S(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax);
279 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
280 return hist;
281}

◆ bookDsp()

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

Definition at line 365 of file TileRawChannelMonTool.cxx.

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

◆ 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 376 of file TilePaterMonTool.cxx.

376 {
377
378 TGraph1 *hist = new TGraph1(N, X, Y);
379 hist->SetName(TString(nam));
380 hist->SetTitle(TString(tit));
381
382 regGraph(subdir, hist);
383
384 return hist;
385}
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:60

◆ 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 463 of file TilePaterMonTool.cxx.

466{
467
468 TGraphAsymmErrors *hist = new TGraphAsymmErrors(N, X, Y, X_errors1, X_errors2, Y_errors1, Y_errors2);
469 hist->SetName(TString(nam));
470 hist->SetTitle(TString(tit));
471
472 regGraph(subdir, hist);
473 return hist;
474}

◆ 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 406 of file TilePaterMonTool.cxx.

406 {
407
408 TGraphErrors *hist = new TGraphErrors(N, X, Y, X_errors, Y_errors);
409 hist->SetName(TString(nam));
410 hist->SetTitle(TString(tit));
411
412 regGraph(subdir, hist);
413 return hist;
414}

◆ bookHistograms()

StatusCode ManagedMonitorToolBase::bookHistograms ( )
virtualinherited

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

Reimplemented in ActsTrk::PhysValTool, CscCalibMonToolBase, CscCalibMonToolPed, CscCalibMonToolSlope, DiMuMon, egammaMonToolBase, EgammaPhysValMonitoring::EgammaPhysValMonitoringTool, electronMonTool, forwardElectronMonTool, GeneratorPhysVal::GeneratorPhysValMonitoringTool, IDPerfMonKshort, IDPerfMonWenu, IDPerfMonZee, InDetPhysValMonitoringTool, InDetTrackPerfMonTool, JetMonitoringTool, JetTagDQA::PhysValBTag, ManagedMonitorToolTest, MissingEtDQA::PhysValMET, MuonPhysValMonitoring::MuonPhysValMonitoringTool, photonMonTool, PhysVal::PhysValExample, PhysValCluster, PhysValDiTau, PhysValFE, PhysValSecVtx, PhysValTau, TileCellNoiseMonTool, TrackCaloClusterRecValidationTool, ZeeTaPMonTool, and ZeeValidation::ZeeValidationMonitoringTool.

Definition at line 1296 of file ManagedMonitorToolBase.cxx.

1298{
1299
1300 return StatusCode::SUCCESS;
1301}

◆ bookHistogramsRecurrent()

StatusCode ManagedMonitorToolBase::bookHistogramsRecurrent ( )
virtualinherited

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

Reimplemented in ManagedMonitorToolTest, MdtVsRpcRawDataValAlg, and MdtVsTgcRawDataValAlg.

Definition at line 1284 of file ManagedMonitorToolBase.cxx.

1286{
1287 if( m_newEventsBlock ) { }
1288 if( m_newLumiBlock ) { }
1289 if( m_newRun ) { }
1290
1291 return StatusCode::SUCCESS;
1292}

◆ bookHists() [1/2]

StatusCode TileRawChannelMonTool::bookHists ( )
overridevirtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 124 of file TileRawChannelMonTool.cxx.

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

◆ bookHists() [2/2]

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

Definition at line 179 of file TileRawChannelMonTool.cxx.

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

◆ bookProfile() [1/3]

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

Definition at line 315 of file TilePaterMonTool.cxx.

319{
320 TProfile* hist = new TProfile(TString(nam), TString(tit), nx, xbins);
321 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
322 return hist;
323}

◆ bookProfile() [2/3]

TProfile * TilePaterMonTool::bookProfile ( 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 304 of file TilePaterMonTool.cxx.

309{
310 TProfile* hist = new TProfile(TString(nam), TString(tit), nx, xmin, xmax, ymin, ymax);
311 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
312 return hist;
313}

◆ bookProfile() [3/3]

TProfile * TilePaterMonTool::bookProfile ( 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 294 of file TilePaterMonTool.cxx.

298{
299 TProfile* hist = new TProfile(TString(nam), TString(tit), nx, xmin, xmax);
300 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
301 return hist;
302}

◆ bookProfile2D()

TProfile2D * TilePaterMonTool::bookProfile2D ( const std::string & dir,
const std::string & nam,
const 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,
const std::string & trigChain = "",
const std::string & mergeAlgo = "" )
protectedinherited

Definition at line 325 of file TilePaterMonTool.cxx.

331{
332
333 TProfile2D* hist = new TProfile2D(TString(nam), TString(tit), nx, xmin, xmax, ny, ymin, ymax, zmin, zmax);
334 regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
335 return hist;
336}

◆ bookSummaryHistograms()

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

Definition at line 910 of file TileRawChannelMonTool.cxx.

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

◆ 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 1952 of file TileRawChannelMonTool.cxx.

1954{
1955 bool err = false;
1956
1957 if (checkDmuHeaderFormat((*headerVec)[dmu])) {
1958 err = true;
1959
1960 }
1961 if (checkDmuHeaderParity((*headerVec)[dmu])) {
1962 err = true;
1963
1964 }
1965 if (((*headerVec)[dmu] >> 25) & 0x1) {
1966 //Memory Parity Error
1967 err = true;
1968
1969 }
1970 if (((*headerVec)[dmu] >> 24) & 0x1) {
1971 //Single Strobe Error
1972 err = true;
1973
1974 }
1975 if (((*headerVec)[dmu] >> 23) & 0x1) {
1976 //Double Strobe Error
1977 err = true;
1978
1979 }
1980
1981 return err;
1982}
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
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
dqt_zlumi_pandas.err
err
Definition dqt_zlumi_pandas.py:183

◆ 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 };
xAOD::uint32_t
setEventNumber uint32_t
Definition EventInfo_v1.cxx:127

◆ 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 1429 of file TileRawChannelMonTool.cxx.

1431{
1432
1433 ATH_MSG_INFO("in checkHists()");
1434
1435 return StatusCode::SUCCESS;
1436}
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & 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 }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & 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 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ deregGraph()

StatusCode ManagedMonitorToolBase::deregGraph ( TGraph * g)
virtualinherited

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

Definition at line 1623 of file ManagedMonitorToolBase.cxx.

1625{
1626 return m_THistSvc->deReg( g );
1627}
ManagedMonitorToolBase::m_THistSvc
ServiceHandle< ITHistSvc > m_THistSvc
Definition ManagedMonitorToolBase.h:843

◆ deregHist()

StatusCode ManagedMonitorToolBase::deregHist ( TH1 * h)
virtualinherited

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

Definition at line 1615 of file ManagedMonitorToolBase.cxx.

1617{
1618 return m_THistSvc->deReg( h );
1619}

◆ 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 1641 of file ManagedMonitorToolBase.cxx.

1643{
1644 std::string streamName = streamNameFunction()->getStreamName( this, group, objName );
1645 return m_THistSvc->deReg( streamName );
1646}
ManagedMonitorToolBase::StreamNameFcn::getStreamName
virtual std::string getStreamName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, bool usePreviousInterval=false)=0
A function that converts a MonGroup of logical parameters into a physical output stream name.
ManagedMonitorToolBase::streamNameFunction
virtual StreamNameFcn * streamNameFunction()
Returns the function object that converts logical paramters into a physical stream name.
Definition ManagedMonitorToolBase.cxx:451

◆ 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 1631 of file ManagedMonitorToolBase.cxx.

1634{
1635 MonGroup group( this, system, interval );
1636 return deregObject( objName, group );
1637}
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition ManagedMonitorToolBase.h:137
ManagedMonitorToolBase::deregObject
virtual StatusCode deregObject(const std::string &objName, const std::string &system, Interval_t interval)
De-registers a TObject from the THistSvc, but does NOT delete the object.
Definition ManagedMonitorToolBase.cxx:1632
CaloLCW_tf.group
group
Definition CaloLCW_tf.py:28

◆ 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 1719 of file TileRawChannelMonTool.cxx.

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

◆ drawHists()

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

Definition at line 1439 of file TileRawChannelMonTool.cxx.

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

◆ drawOptFilt()

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

◆ endOfEventsBlockFlag()

bool ManagedMonitorToolBase::endOfEventsBlockFlag ( ) const
inlineprotectedinherited

Definition at line 794 of file ManagedMonitorToolBase.h.

794{ return m_endOfEventsBlock; }

◆ endOfLowStatFlag()

bool ManagedMonitorToolBase::endOfLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 795 of file ManagedMonitorToolBase.h.

795{ return m_endOfLowStat; }

◆ endOfLumiBlockFlag()

bool ManagedMonitorToolBase::endOfLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 796 of file ManagedMonitorToolBase.h.

796{ return m_endOfLumiBlock; }

◆ endOfRunFlag()

bool ManagedMonitorToolBase::endOfRunFlag ( ) const
inlineprotectedinherited

Definition at line 797 of file ManagedMonitorToolBase.h.

797{ return m_endOfRun; }

◆ evtStore()

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; }

◆ 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 804 of file TileRawChannelMonTool.cxx.

806{
807
808 ATH_MSG_DEBUG("in fillDsp()");
809
810 const TileRawChannelContainer* RawChannelCnt;
811 CHECK(evtStore()->retrieve(RawChannelCnt, m_contNameDSP));
812
813 TileRawChannelUnit::UNIT RChUnit = RawChannelCnt->get_unit();
814
815 TileRawChannelContainer::const_iterator collItr = RawChannelCnt->begin();
816 TileRawChannelContainer::const_iterator lastColl = RawChannelCnt->end();
817
818 for (; collItr != lastColl; ++collItr) {
819
820 TileRawChannelCollection::const_iterator chItr = (*collItr)->begin();
821 TileRawChannelCollection::const_iterator lastCh = (*collItr)->end();
822
823 if (chItr != lastCh) {
824
825 HWIdentifier adc_id = (*chItr)->adc_HWID();
826 int ros = m_tileHWID->ros(adc_id);
827 int drawer = m_tileHWID->drawer(adc_id);
828
829 if (m_data->m_histDsp1[ros][drawer][0][0].size() == 0) {
830 m_bigain = true;
831 bookDsp(ros, drawer);
832 }
833
834 for (; chItr != lastCh; ++chItr) {
835
836 const TileRawChannel * rch = (*chItr);
837
838 adc_id = rch->adc_HWID();
839 unsigned int chan = m_tileHWID->channel(adc_id);
840 int adc = m_tileHWID->adc(adc_id);
841 int gain = (m_bigain) ? adc : 0; // ignore gain in monogain run
842 unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
843
844 if ((m_cispar[8] == 0) /* || ( m_cispar[8] == abs(m_cabling->channel2hole(ros,chan)) )*/
845 && !m_corrup[ros][drawer][gain][chan / 3]) { // channel is fired and not corrupted
846
847 double amp = rch->amplitude();
848 if (RChUnit != m_calibUnit) {
849 if (m_calibUnit != TileRawChannelUnit::CesiumPicoCoulombs) { //We put everythin in the same unit
850 amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, m_calibUnit);
851 } else { // it is =TileRawChannelUnit::CesiumPicoCoulombs, careful with MBTS channels
852 if (ros < 3) //if LB then it's ok CesiumPicoCoulomb
853 {
854 amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::CesiumPicoCoulombs);
855 //conversion factor if of the order of 1000MeV=1.05pC
856 } else // check that they are not MBTS channel
857 {
858 int index, pmt;
859 /*Identifier cell_id =*/rch->cell_ID_index(index, pmt);
860 if (index < -1) // MBTS channel
861 {
862 amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::PicoCoulombs);
863 } else //not MBTS channel
864 {
865 amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::CesiumPicoCoulombs);
866 }
867 }
868 } // end if CesiumPicoCouloumb
869 }
870
871 double time = rch->time();
872 double chi2 = rch->quality();
873
874 m_data->m_histDsp1[ros][drawer][chan][gain][Edsp]->Fill(amp, 1.0);
875 m_data->m_histDsp1[ros][drawer][chan][gain][Tdsp]->Fill(time, 1.0);
876 m_data->m_histDsp1[ros][drawer][chan][gain][chi2dsp]->Fill(chi2, 1.0);
877 m_data->m_histDsp2[ros][drawer][chan][gain][0]->Fill(amp, chi2, 1.0);
878 m_data->m_finalHistDsp2[ros][drawer][gain][0]->Fill(amp, chi2, 1.0);
879
880 std::map<int, std::vector<double> >::iterator it = efitMap.find(ros * 100 + drawer);
881 if (it != efitMap.end()) {
882 double efit = (*it).second.at(chan + gain * 48);
883 it = tfitMap.find(ros * 100 + drawer);
884 if (it != tfitMap.end()) {
885 double tfit = (*it).second.at(chan + gain * 48);
886 //convert from pC to ADC counts
887 if (TMath::Abs(efit) > m_efitThresh) { // fill the histogram only if the efit is above threshold
888 m_data->m_histDsp1[ros][drawer][chan][gain][Edsp_fit]->Fill((amp - efit) / efit, 1.0);
889 }
890
891 if (tfit != 0.) {
892 m_data->m_histDsp1[ros][drawer][chan][gain][Tdsp_fit]->Fill((time - tfit), 1.0);
893 }
894 }
895
896 }
897 }
898
899 } // loop over channels
900
901 }
902 }
903 return StatusCode::SUCCESS;
904}
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition Control/AthenaKernel/AthenaKernel/errorcheck.h:422
TileRawChannelContainer
Athena::TPCnvVers::Old Athena::TPCnvVers::Old Athena::TPCnvVers::Current Athena::TPCnvVers::Old Athena::TPCnvVers::Current TileRawChannelContainer
Definition TileTPCnv.cxx:127
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
Definition AthCommonDataStore.h:85
DataVector::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Standard const_iterator.
Definition DataVector.h:838
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition IdentifiableContainerMT.h:240
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition IdentifiableContainerMT.h:234
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition TileCalibUtils.cxx:60
TilePaterMonTool::m_tileHWID
const TileHWID * m_tileHWID
Definition TilePaterMonTool.h:199
TileRawChannelMonTool::m_corrup
bool m_corrup[5][64][2][16]
Definition TileRawChannelMonTool.h:97
TileRawChannel::time
float time(int ind=0) const
Definition TileRawChannel.h:103
TileRawChannel::quality
float quality(int ind=0) const
Definition TileRawChannel.h:105
TileRawChannel::amplitude
float amplitude(int ind=0) const
Definition TileRawChannel.h:101
TileRawData::cell_ID_index
Identifier cell_ID_index(int &index, int &pmt) const
Definition TileRawData.cxx:65
TileRawData::adc_HWID
HWIdentifier adc_HWID(void) const
Definition TileRawData.h:53
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition comparitor.cxx:525
CaloSwCorrections.time
time(flags, cells_name, *args, **kw)
Definition CaloSwCorrections.py:242
DeMoScan.index
str index
Definition DeMoScan.py:362
python.PyKernel.retrieve
retrieve(aClass, aKey=None)
Definition PyKernel.py:110

◆ fillHistograms()

StatusCode ManagedMonitorToolBase::fillHistograms ( )
virtualinherited

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

Reimplemented in ActsTrk::PhysValTool, CscCalibMonToolBase, DiMuMon, egammaMonToolBase, EgammaPhysValMonitoring::EgammaPhysValMonitoringTool, electronMonTool, forwardElectronMonTool, GeneratorPhysVal::GeneratorPhysValMonitoringTool, IDPerfMonKshort, IDPerfMonWenu, IDPerfMonZee, InDetPhysValMonitoringTool, InDetTrackPerfMonTool, JetMonitoringTool, JetTagDQA::PhysValBTag, ManagedMonitorToolTest, MdtVsRpcRawDataValAlg, MdtVsTgcRawDataValAlg, MissingEtDQA::PhysValMET, MuonPhysValMonitoring::MuonPhysValMonitoringTool, photonMonTool, PhysVal::PhysValExample, PhysValCluster, PhysValDiTau, PhysValFE, PhysValSecVtx, PhysValTau, TileCellNoiseMonTool, TrackCaloClusterRecValidationTool, ZeeTaPMonTool, and ZeeValidation::ZeeValidationMonitoringTool.

Definition at line 1304 of file ManagedMonitorToolBase.cxx.

1306{
1307 return StatusCode::SUCCESS;
1308}

◆ 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 517 of file TileRawChannelMonTool.cxx.

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

◆ fillSummaryHistograms()

StatusCode TileRawChannelMonTool::fillSummaryHistograms ( )
private

Definition at line 1048 of file TileRawChannelMonTool.cxx.

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

◆ finalDsp()

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

get algorithm and number of iterations from bsflags

Definition at line 1322 of file TileRawChannelMonTool.cxx.

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

◆ finalHists()

StatusCode TileRawChannelMonTool::finalHists ( )
overridevirtual

Calls procHists( true, true, true ).

Reimplemented from ManagedMonitorToolBase.

Definition at line 1299 of file TileRawChannelMonTool.cxx.

1301{
1302 ATH_MSG_INFO("in finalHists()");
1303
1304 if (m_summaryUpdateFrequency == 0) {
1305 for (int ros = 1; ros < 5; ++ros) {
1306 for (int drawer = 0; drawer < 64; ++drawer) {
1307 if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
1308 bookSummaryHistograms(ros, drawer);
1309 }
1310 }
1311 }
1312 }
1313
1314 m_drawHists = true;
1315 CHECK(fillSummaryHistograms());
1316
1317
1318 return StatusCode::SUCCESS;
1319}

◆ get_nEvents()

unsigned int ManagedMonitorToolBase::get_nEvents ( ) const
inlineprotectedinherited

Definition at line 692 of file ManagedMonitorToolBase.h.

692 {
693 return m_nEvents;
694 }

◆ get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const
inlineprotectedinherited

Definition at line 696 of file ManagedMonitorToolBase.h.

696 {
697 return m_procNEventsProp;
698 }

◆ getCellName()

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

Definition at line 221 of file TilePaterMonTool.h.

221 {
222 if (ros < 3) return m_LBcellName[channel];
223 else return m_EBcellName[channel];
224 };
TilePaterMonTool::m_EBcellName
std::string m_EBcellName[48]
Definition TilePaterMonTool.h:210
TilePaterMonTool::m_LBcellName
std::string m_LBcellName[48]
Definition TilePaterMonTool.h:215
plotting.yearwise_efficiency.channel
channel
Definition yearwise_efficiency.py:24

◆ getHist() [1/4]

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 1417 of file ManagedMonitorToolBase.cxx.

1419{
1420 std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1421 return m_THistSvc->getHist( streamName, h );
1422}

◆ getHist() [2/4]

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 1407 of file ManagedMonitorToolBase.cxx.

1410{
1411 MonGroup group( this, system, interval );
1412 return getHist( h, hName, group );
1413}
ManagedMonitorToolBase::getHist
virtual StatusCode getHist(TH1 *&h, const std::string &hName, const std::string &system, Interval_t interval)
Returns a TH1 via the pointer passed as the first argument.
Definition ManagedMonitorToolBase.cxx:1408

◆ getHist() [3/4]

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 1436 of file ManagedMonitorToolBase.cxx.

1438{
1439 std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1440 return m_THistSvc->getHist( streamName, h );
1441}

◆ getHist() [4/4]

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 1426 of file ManagedMonitorToolBase.cxx.

1429{
1430 MonGroup group( this, system, interval );
1431 return getHist( h, hName, group );
1432}

◆ getNewStreamNameFcn()

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

Definition at line 2155 of file ManagedMonitorToolBase.cxx.

2157{
2158 StreamNameFcn* fcn(0);
2159
2160 switch( m_environment ) {
2161 case AthenaMonManager::noOutput:
2162 fcn = new NoOutputStream();
2163 break;
2164 case AthenaMonManager::online:
2165 fcn = new OnlineStream();
2166 break;
2167 case AthenaMonManager::user:
2168 fcn = new DefaultStream( m_fileKey );
2169 break;
2170 case AthenaMonManager::tier0:
2171 case AthenaMonManager::tier0Raw:
2172 case AthenaMonManager::tier0ESD:
2173 case AthenaMonManager::AOD:
2174 case AthenaMonManager::altprod:
2175 default:
2176 fcn = new OfflineStream( m_fileKey, m_dataType, m_environment );
2177 }
2178
2179 return fcn;
2180}
ManagedMonitorToolBase::StreamNameFcn
A function-object base class allowing the specific implementation of getStreamName to be decided at r...
Definition ManagedMonitorToolBase.h:325
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition ManagedMonitorToolBase.h:839
ManagedMonitorToolBase::m_dataType
AthenaMonManager::DataType_t m_dataType
Definition ManagedMonitorToolBase.h:838

◆ 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 1919 of file TileRawChannelMonTool.cxx.

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

◆ getTMDBCellName()

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

Definition at line 230 of file TilePaterMonTool.h.

230 {
231 if (ros < 3) return m_TMDB_LB_cell_names[channel];
232 else return m_TMDB_EB_cell_names[channel];
233 };
TilePaterMonTool::m_TMDB_LB_cell_names
std::string m_TMDB_LB_cell_names[8]
Definition TilePaterMonTool.h:227
TilePaterMonTool::m_TMDB_EB_cell_names
std::string m_TMDB_EB_cell_names[4]
Definition TilePaterMonTool.h:228

◆ initialize()

StatusCode TileRawChannelMonTool::initialize ( )
overridevirtual

Reimplemented from TilePaterMonTool.

Definition at line 94 of file TileRawChannelMonTool.cxx.

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

◆ 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()

const InterfaceID & IMonitorToolBase::interfaceID ( )
inlinestaticinherited

Definition at line 29 of file IMonitorToolBase.h.

29{ return IID_IMonitorToolBase; }
IID_IMonitorToolBase
static const InterfaceID IID_IMonitorToolBase("IMonitorToolBase", 1, 0)

◆ 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 535 of file ManagedMonitorToolBase.cxx.

537{
538 std::string str("file");
539
540 switch( interval ) {
541 case all:
542 str = "all";
543 break;
544 case fill:
545 str = "fill";
546 break;
547 case run:
548 str = "run";
549 break;
550 case lowStat:
551 str = "lowStat";
552 break;
553 case medStat:
554 str = "medStat";
555 break;
556 case higStat:
557 str = "higStat";
558 break;
559 case lumiBlock:
560 str = "lumiBlock";
561 break;
562 case eventsBlock:
563 str = "eventsBlock";
564 break;
565 case file:
566 str = "file";
567 break;
568 default:
569 str = "unknown";
570 }
571
572 return str;
573}

◆ intervalStringToEnum()

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

Converts a string to the corresponding Interval_t.

Definition at line 577 of file ManagedMonitorToolBase.cxx.

579{
580 std::string lcstr( strToLower(str) );
581
582 if( lcstr == "all" )
583 return all;
584 else if( lcstr == "fill" )
585 return fill;
586 else if( lcstr == "run" )
587 return run;
588 else if( lcstr == "lowStat" )
589 return lowStat;
590 else if( lcstr == "medStat" )
591 return medStat;
592 else if( lcstr == "higStat" )
593 return higStat;
594 else if( lcstr == "lumiBlock" )
595 return lumiBlock;
596 else if( lcstr == "eventsBlock" )
597 return eventsBlock;
598 else if( lcstr == "file" )
599 return file;
600
601 if( Imp::s_svcLocator ) {
602 SmartIF<IMessageSvc> ms{Imp::s_svcLocator.load()->service( "MessageSvc" )};
603 if( ms.isValid() ) {
604 MsgStream log( ms, "ManagedMonitorToolBase::intervalStringToEnum()" );
605 log << MSG::WARNING << "Unknown ManagedMonitorToolBase::Interval_t \""
606 << str << "\", returning \"file\"" << endmsg;
607 }
608 }
609
610 return file;
611}
ManagedMonitorToolBase::Imp::s_svcLocator
static std::atomic< ISvcLocator * > s_svcLocator
Definition ManagedMonitorToolBase.cxx:38

◆ isDisconnected()

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

Definition at line 256 of file TilePaterMonTool.h.

256 {
257
258 if (ros < 3) { //LB, all standard. Channels 30,31,43 are disconnected
259 return m_chMapLB[ch];
260 } else {
261 if (((ros == 3) && (drawer == 14)) || ((ros == 4) && (drawer == 17))) {//EB, EBA15 and EBC18 are special
262 return m_chMapEBsp[ch];
263 } else {//EB standard module
264 return m_chMapEB[ch];
265 }
266 } //end if LB else EB
267
268 }

◆ LaserFancyPlotting()

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

Definition at line 1984 of file TileRawChannelMonTool.cxx.

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

◆ lbAverageInteractionsPerCrossing()

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

Average mu, i.e.

<mu>

Definition at line 1691 of file ManagedMonitorToolBase.cxx.

1693{
1694 if (!m_lumiDataKey.empty()) {
1695 SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1696 return lumi->lbAverageInteractionsPerCrossing();
1697 } else {
1698 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageInteractionsPerCrossing() can't work properly! ");
1699 ATH_MSG_DEBUG("Warning: lbAverageInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1700 return -1.0;
1701 }
1702 // not reached
1703}
ManagedMonitorToolBase::m_lumiDataKey
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey
Definition ManagedMonitorToolBase.h:887

◆ lbAverageLivefraction()

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

Average luminosity livefraction.

Definition at line 1760 of file ManagedMonitorToolBase.cxx.

1762{
1763 if (m_environment == AthenaMonManager::online)
1764 return 1.0;
1765
1766 if (!m_trigLiveFractionDataKey.empty()) {
1767 SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
1768 return live->lbAverageLiveFraction();
1769 } else {
1770 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLivefraction() can't work properly! ");
1771 ATH_MSG_DEBUG("Warning: lbAverageLivefraction() - luminosity not availble (i.e. EnableLumi = False)");
1772 return -1.0;
1773 }
1774 // not reached
1775}
ManagedMonitorToolBase::m_trigLiveFractionDataKey
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey
Definition ManagedMonitorToolBase.h:891

◆ 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 1727 of file ManagedMonitorToolBase.cxx.

1729{
1730 if (!m_lumiDataKey.empty()) {
1731 SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1732 return lumi->lbAverageLuminosity();
1733 } else {
1734 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLuminosity() can't work properly! ");
1735 ATH_MSG_DEBUG("Warning: lbAverageLuminosity() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1736 return -1.0;
1737 }
1738 // not reached
1739}

◆ lbDuration()

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

Luminosity block time (in seconds)

Definition at line 1814 of file ManagedMonitorToolBase.cxx.

1816{
1817 if ( m_environment == AthenaMonManager::online ) {
1818 return m_defaultLBDuration;
1819 }
1820 if (!m_lbDurationDataKey.empty()) {
1821 SG::ReadCondHandle<LBDurationCondData> dur (m_lbDurationDataKey, ctx);
1822 return dur->lbDuration();
1823 } else {
1824 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbDuration() can't work properly! ");
1825 ATH_MSG_DEBUG("Warning: lbDuration() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1826 return m_defaultLBDuration;
1827 }
1828 // not reached
1829}
ManagedMonitorToolBase::m_lbDurationDataKey
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey
Definition ManagedMonitorToolBase.h:889

◆ lbInteractionsPerCrossing()

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

Instantaneous number of interactions, i.e.

mu

Definition at line 1707 of file ManagedMonitorToolBase.cxx.

1709{
1710 if (!m_lumiDataKey.empty()) {
1711 SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1712 float muToLumi = lumi->muToLumi();
1713 if (muToLumi > 0) {
1714 return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id()) / muToLumi;
1715 }
1716 return 0;
1717 } else {
1718 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbInteractionsPerCrossing() can't work properly! ");
1719 ATH_MSG_DEBUG("Warning: lbInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1720 return -1.0;
1721 }
1722 // not reached
1723}

◆ lbLuminosityPerBCID()

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

Instantaneous luminosity.

Definition at line 1743 of file ManagedMonitorToolBase.cxx.

1745{
1746 if (!m_lumiDataKey.empty()) {
1747 SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1748 return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id());
1749 } else {
1750 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLuminosityPerBCID() can't work properly! ");
1751 ATH_MSG_DEBUG("Warning: lbLuminosityPerBCID() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1752 return -1.0;
1753 }
1754 // not reached
1755}

◆ lbLumiWeight()

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

Average Integrated Luminosity Live Fraction.

Definition at line 1798 of file ManagedMonitorToolBase.cxx.

1800{
1801 if (!m_lumiDataKey.empty()) {
1802 return (lbAverageLuminosity(ctx)*lbDuration(ctx))*lbAverageLivefraction(ctx);
1803 } else{
1804 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLumiWeight() can't work properly! ");
1805 ATH_MSG_DEBUG("Warning: lbLumiWeight() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1806 return -1.0;
1807 }
1808 // not reached
1809}
ManagedMonitorToolBase::lbAverageLivefraction
virtual float lbAverageLivefraction(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average luminosity livefraction.
Definition ManagedMonitorToolBase.cxx:1761
ManagedMonitorToolBase::lbAverageLuminosity
virtual float lbAverageLuminosity(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)
Definition ManagedMonitorToolBase.cxx:1728
ManagedMonitorToolBase::lbDuration
virtual double lbDuration(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Luminosity block time (in seconds)
Definition ManagedMonitorToolBase.cxx:1815

◆ livefractionPerBCID()

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

Livefraction per bunch crossing ID.

Definition at line 1779 of file ManagedMonitorToolBase.cxx.

1781{
1782 if (m_environment == AthenaMonManager::online)
1783 return 1.0;
1784
1785 if (!m_trigLiveFractionDataKey.empty()) {
1786 SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
1787 return live->l1LiveFractionVector().at (ctx.eventID().bunch_crossing_id());
1788 } else {
1789 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! livefractionPerBCID() can't work properly! ");
1790 ATH_MSG_DEBUG("Warning: livefractionPerBCID() - luminosity retrieved available (i.e. EnableLumi = False)");
1791 return -1.0;
1792 }
1793 // not reached
1794}

◆ 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()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ 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 793 of file ManagedMonitorToolBase.h.

793{ return m_newEventsBlock; }

◆ newHigStatIntervalFlag()

bool ManagedMonitorToolBase::newHigStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 789 of file ManagedMonitorToolBase.h.

789{ return m_newHigStatInterval; }

◆ newLowStatFlag()

bool ManagedMonitorToolBase::newLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 790 of file ManagedMonitorToolBase.h.

790{ 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 787 of file ManagedMonitorToolBase.h.

787{ return m_newLowStatInterval; }

◆ newLumiBlockFlag()

bool ManagedMonitorToolBase::newLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 791 of file ManagedMonitorToolBase.h.

791{ return m_newLumiBlock; }

◆ newMedStatIntervalFlag()

bool ManagedMonitorToolBase::newMedStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 788 of file ManagedMonitorToolBase.h.

788{ return m_newMedStatInterval; }

◆ newRunFlag()

bool ManagedMonitorToolBase::newRunFlag ( ) const
inlineprotectedinherited

Definition at line 792 of file ManagedMonitorToolBase.h.

792{ 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 2111 of file ManagedMonitorToolBase.cxx.

2112 {
2113 std::string item;
2114 std::stringstream ss(line);
2115
2116 if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "ManagedMonitorToolBase::parseList:";
2117
2118 while ( std::getline(ss, item, ',') ) {
2119 std::stringstream iss(item); // remove
2120 iss >> item; // whitespace
2121 if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " " << item;
2122 result.push_back(item);
2123 }
2124
2125 msg(MSG::DEBUG) << endmsg;
2126 return StatusCode::SUCCESS;
2127}
ss
static Double_t ss
Definition LArPhysWaveHECTool.cxx:37
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition AthCommonMsg.h:24
get_generator_info.result
result
Definition get_generator_info.py:21

◆ preSelector()

bool ManagedMonitorToolBase::preSelector ( )
virtualinherited

Implements IMonitorToolBase.

Definition at line 1679 of file ManagedMonitorToolBase.cxx.

1681{
1682 if( m_preScaleProp > 1 ) {
1683 return ( (m_nEvents % m_preScaleProp) == 1 );
1684 }
1685 return true;
1686}

◆ procHistograms()

StatusCode ManagedMonitorToolBase::procHistograms ( )
virtualinherited

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

Reimplemented in ActsTrk::PhysValTool, CscCalibMonToolBase, DiMuMon, egammaMonToolBase, EgammaPhysValMonitoring::EgammaPhysValMonitoringTool, GeneratorPhysVal::GeneratorPhysValMonitoringTool, IDPerfMonKshort, IDPerfMonWenu, IDPerfMonZee, InDetPhysValMonitoringTool, InDetTrackPerfMonTool, JetMonitoringTool, JetTagDQA::PhysValBTag, ManagedMonitorToolTest, MdtVsTgcRawDataValAlg, MissingEtDQA::PhysValMET, MuonPhysValMonitoring::MuonPhysValMonitoringTool, PhysVal::PhysValExample, PhysValDiTau, PhysValFE, PhysValSecVtx, PhysValTau, TileCellNoiseMonTool, TrackCaloClusterRecValidationTool, ZeeTaPMonTool, and ZeeValidation::ZeeValidationMonitoringTool.

Definition at line 1312 of file ManagedMonitorToolBase.cxx.

1314{
1315 if( m_endOfEventsBlock ) { }
1316 if( m_endOfLowStat ) { }
1317 if( m_endOfLumiBlock ) { }
1318 if( m_endOfRun) { }
1319
1320 return StatusCode::SUCCESS;
1321}

◆ 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 1843 of file TileRawChannelMonTool.cxx.

1843 {
1844 /*---------------------------------------------------------*/
1851 if (m_DownLimit < mean && mean < m_UpLimit) {
1852 if (xmin > m_DownLimit) xmin = mean;
1853 if (xmax < m_UpLimit) xmax = mean;
1854 }
1855
1856}

◆ 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 1859 of file TileRawChannelMonTool.cxx.

1859 {
1860 /*---------------------------------------------------------*/
1871 if (m_DownLimit < mean && mean < m_UpLimit) {
1872
1873 if (xmin > m_DownLimit) {
1874 xmin = mean;
1875 } else {
1876 int lo_thrbin = hist->FindBin(m_DownLimit); //
1877 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
1878 double ratio = integral / (hist->GetEntries());
1879 if (ratio > m_hi_IntegralLimit) {
1880 xmin = mean - 1.05;
1881 } //larger error bar
1882 else if (ratio > m_med_IntegralLimit) {
1883 xmin = mean - 0.7;
1884 } //intermediate error bar
1885 else if (ratio > m_lo_IntegralLimit) {
1886 xmin = mean - 0.35;
1887 } //small error bar
1888 else {
1889 xmin = mean;
1890 }
1891 }
1892
1893 if (xmax < m_UpLimit) {
1894 xmax = mean;
1895 } else {
1896 int hi_thrbin = hist->FindBin(m_UpLimit);
1897 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.
1898 double ratio = integral / (hist->GetEntries());
1899 if (ratio > m_hi_IntegralLimit) {
1900 xmax = mean + 1.05;
1901 } //larger error bar
1902 else if (ratio > m_med_IntegralLimit) {
1903 xmax = mean + 0.7;
1904 } //intermediate error bar
1905 else if (ratio > m_lo_IntegralLimit) {
1906 xmax = mean + 0.35;
1907 } //small error bar
1908 else {
1909 xmax = mean;
1910 }
1911 }
1912 }
1914}
integral
double integral(TH1 *h)
Definition computils.cxx:59

◆ 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 1444 of file ManagedMonitorToolBase.cxx.

1444 {
1445 if (!e)
1446 return StatusCode::FAILURE;
1447
1448 TGraph* g = reinterpret_cast<TGraph*>(e);
1449 std::string name = e->GetName();
1450
1451 // MANAGED
1452 if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1453 // warn about not using merge algorithms
1454 if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1455 ATH_MSG_WARNING("HEY! Attempting to register "<<name<<" as a per-LB histogram, but not setting the merge algorithm! Use \"merge\", at least.");
1456 }
1457 // add the efficiency to rebooking vector
1458 if (m_supportedIntervalsForRebooking.count(group.interval())) {
1459 m_templateEfficiencies[group.interval()].push_back( MgmtParams<TEfficiency>(e, group) );
1460 } else {
1461 ATH_MSG_ERROR("Attempt to book managed graph " << name << " with invalid interval type " << intervalEnumToString(group.interval()));
1462 return StatusCode::FAILURE;
1463 }
1464
1465 MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1466 std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1467 registerMetadata(streamName, name, group).ignore();
1468 return m_THistSvc->regGraph( streamName, g );
1469 } else {
1470 // UNMANAGED
1471 if( m_manager != 0 ) {
1472 std::string genericName = NoOutputStream().getStreamName( this, group, name );
1473 m_manager->writeAndDelete( genericName );
1474 m_manager->passOwnership( e, genericName );
1475 }
1476
1477 std::string streamName = streamNameFunction()->getStreamName( this, group, name, false );
1478 StatusCode smd = registerMetadata(streamName, name, group);
1479 if (smd != StatusCode::SUCCESS)
1480 return StatusCode::FAILURE;
1481
1482 return m_THistSvc->regGraph( streamName, g );
1483 }
1484}
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ManagedMonitorToolBase::NoOutputStream::getStreamName
virtual std::string getStreamName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, bool usePreviousInterval=false)
A function that converts a MonGroup of logical parameters into a physical output stream name.
Definition ManagedMonitorToolBase.cxx:1937
ManagedMonitorToolBase::m_supportedIntervalsForRebooking
std::set< Interval_t > m_supportedIntervalsForRebooking
Definition ManagedMonitorToolBase.h:896
ManagedMonitorToolBase::registerMetadata
StatusCode registerMetadata(const std::string &streamName, const std::string &hName, const MonGroup &group)
Definition ManagedMonitorToolBase.cxx:946
ManagedMonitorToolBase::intervalEnumToString
static std::string intervalEnumToString(Interval_t interval)
Converts a LevelOfDetail_t to a string of the same name.
Definition ManagedMonitorToolBase.cxx:536
ManagedMonitorToolBase::m_templateEfficiencies
std::map< Interval_t, std::vector< MgmtParams< TEfficiency > > > m_templateEfficiencies
Definition ManagedMonitorToolBase.h:676
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22

◆ regGraph() [1/3]

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 60 of file TilePaterMonTool.cxx.

61{
62
63 std::string path(m_path);
64 if (!subDir.empty()) path += ("/" + subDir);
65
66 if(ManagedMonitorToolBase::regGraph(graph, path, interval, attribute, trigChain, mergeAlgo).isFailure()) {
67 ATH_MSG_WARNING( "Could not register Graph : " << path + "/" + graph->GetName() );
68 }
69}
ManagedMonitorToolBase::regGraph
virtual StatusCode regGraph(TGraph *g, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TGraph to be included in the output stream using logical parameters that describe the gra...
Definition ManagedMonitorToolBase.cxx:1489
athena.path
path
python interpreter configuration --------------------------------------—
Definition athena.py:128

◆ regGraph() [2/3]

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

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 530 of file ManagedMonitorToolBase.cxx.

1500{
1501 if (!g)
1502 return StatusCode::FAILURE;
1503
1504 // This part of the code deals with MANAGED type
1505 if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1506 // Create an unmanaged group based on the original MonGroup instance passed
1507 // This is needed because managed graph is presented as a number of unmanaged
1508 // graphs (one per each interval)
1509 MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1510
1511 if (m_supportedIntervalsForRebooking.count(group.interval())) {
1512 m_templateGraphs[group.interval()].push_back( MgmtParams<TGraph>(g, group_unmanaged) );
1513 } else {
1514 ATH_MSG_ERROR("Attempt to book managed graph " << g->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1515 return StatusCode::FAILURE;
1516 }
1517
1518 std::string name = g->GetName();
1519 std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1520 registerMetadata(streamName, name, group).ignore();
1521 return m_THistSvc->regGraph( streamName, g );
1522 //return m_THistSvc->regGraph( streamName );
1523 }
1524
1525 // This part of the code deals with UNMANAGED type
1526 std::string gName = g->GetName();
1527
1528 if( m_manager != 0 ) {
1529 std::string genericName = NoOutputStream().getStreamName( this, group, gName );
1530 m_manager->writeAndDelete( genericName );
1531 m_manager->passOwnership( g, genericName );
1532 }
1533
1534 std::string streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1535
1536 StatusCode smd = registerMetadata(streamName, gName, group);
1537 if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1538
1539 return m_THistSvc->regGraph( streamName, g );
1540}
ManagedMonitorToolBase::m_templateGraphs
std::map< Interval_t, std::vector< MgmtParams< TGraph > > > m_templateGraphs
Definition ManagedMonitorToolBase.h:668

◆ regGraph() [3/3]

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 = "" )
protectedvirtualinherited

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 522 of file ManagedMonitorToolBase.cxx.

1491{
1492 MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1493 return regGraph( g, group );
1494}

◆ regHist() [1/3]

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 47 of file TilePaterMonTool.cxx.

48{
49
50 std::string path(m_path);
51 if (!subDir.empty()) path += ("/" + subDir);
52
53 if(ManagedMonitorToolBase::regHist(hist, path, interval, attribute, trigChain, mergeAlgo).isFailure()) {
54 ATH_MSG_WARNING( "Could not register histogram : " << path + "/" + hist->GetName() );
55 }
56
57}
ManagedMonitorToolBase::regHist
virtual StatusCode regHist(TH1 *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical ...
Definition ManagedMonitorToolBase.cxx:1344

◆ regHist() [2/3]

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

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.

Reimplemented from ManagedMonitorToolBase.

Definition at line 470 of file ManagedMonitorToolBase.cxx.

1354{
1355// ManagedMonitorToolBase_addHistStatistics(this,h);
1356
1357 if (!h)
1358 return StatusCode::FAILURE;
1359
1360 // This part of the code deals with MANAGED type
1361 if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1362 /*
1363 Create an unmanaged group based on the original MonGroup instance passed
1364 It is needed because managed histogram is presented as a number of unmanaged
1365 histograms (one per each interval)
1366 Update (PUEO) - I don't think it actually matters, and need to keep
1367 track of "proper" attribute for X_VS_LB
1368 */
1369
1370 if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1371 ATH_MSG_WARNING("HEY! You're attempting to register " << h->GetName() << " as a per-LB histogram, but you're not setting the merge algorithm! This is a SUPER-BAD idea! Use \"merge\", at least.");
1372 }
1373
1374 if (m_supportedIntervalsForRebooking.count(group.interval())) {
1375 m_templateHistograms[group.interval()].push_back( MgmtParams<TH1>(h, group) );
1376 } else {
1377 ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1378 return StatusCode::FAILURE;
1379 }
1380
1381 std::string hName = h->GetName();
1382 MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1383 std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, hName, false );
1384 registerMetadata(streamName, hName, group).ignore();
1385 return m_THistSvc->regHist( streamName, h );
1386 }
1387
1388 // This part of the code deals with UNMANAGED type
1389 std::string hName = h->GetName();
1390
1391 if( m_manager != 0 ) {
1392 std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1393 m_manager->writeAndDelete( genericName );
1394 m_manager->passOwnership( h, genericName );
1395 }
1396
1397 std::string streamName = streamNameFunction()->getStreamName( this, group, hName, false );
1398
1399 StatusCode smd = registerMetadata(streamName, hName, group);
1400 if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1401
1402 return m_THistSvc->regHist( streamName, h );
1403}
ManagedMonitorToolBase::m_templateHistograms
std::map< Interval_t, std::vector< MgmtParams< TH1 > > > m_templateHistograms
Definition ManagedMonitorToolBase.h:664

◆ regHist() [3/3]

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 = "" )
protectedvirtualinherited

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 462 of file ManagedMonitorToolBase.cxx.

1346{
1347 MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1348 return regHist( h, group );
1349}

◆ registerMetadata()

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

Definition at line 945 of file ManagedMonitorToolBase.cxx.

947 {
948 if( m_environment != AthenaMonManager::online ) {
949 TTree* metadata(0);
950 std::string mdStreamName( streamName );
951 size_t found=mdStreamName.rfind('/');
952
953 if ( found != std::string::npos )
954 mdStreamName.replace( found, mdStreamName.length(), "/metadata" );
955
956 MDMap_t::iterator i = m_metadataMap.find( mdStreamName );
957 if( i == m_metadataMap.end() ) {
958 metadata = new TTree( "metadata", "Monitoring Metadata" );
959 if (! metadata) return StatusCode::FAILURE;
960 StatusCode scmd = m_THistSvc->regTree( mdStreamName, metadata );
961 if (scmd == StatusCode::FAILURE) return StatusCode::FAILURE;
962 i = m_metadataMap.emplace( mdStreamName, new OutputMetadata(metadata) ).first;
963 }
964
965 i->second->fill( hName, group.interval(), group.chain(), group.merge() );
966 }
967 return StatusCode::SUCCESS;
968}

◆ regManagedEfficiencies()

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

Definition at line 1139 of file ManagedMonitorToolBase.cxx.

1139 {
1140 bool allIsOk = true;
1141 for( auto& it : templateEfficiencies ) {
1142 // get components of MgmtParams and copy efficiency
1143 MonGroup group = it.m_group;
1144 TEfficiency* theEfficiency = it.m_templateHist;
1145 TEfficiency* e = static_cast<TEfficiency*>(theEfficiency->Clone());
1146 int nbins = theEfficiency->GetTotalHistogram()->GetNbinsX();
1147 int xlow = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmin();
1148 int xhigh = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmax();
1149 e->SetBins(nbins,xlow,xhigh); // reset histogram
1150 std::string name = e->GetName();
1151
1152 // make TGraph casts of TEfficiencies
1153 TGraph* theGraph = reinterpret_cast<TGraph*>(theEfficiency);
1154 TGraph* g = reinterpret_cast<TGraph*>(e);
1155
1156 // Get the streamName for the previous interval
1157 std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
1158
1159 // RE-REGISTER
1160 // 1) De-register the original graph with the THistSvc
1161 StatusCode sc1 = m_THistSvc->deReg( theGraph );
1162 if (sc1 == StatusCode::FAILURE) allIsOk = false;
1163 // 2) Fix THistSvc->deReg for TGraphs
1164 bool doneCleaning = false;
1165 std::string directoryName = streamNameFunction()->getDirectoryName( this, group, name, true );
1166 TSeqCollection *filelist=gROOT->GetListOfFiles();
1167 for (int i=0; i<filelist->GetEntries(); i++) {
1168 ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
1169 TFile* file = static_cast<TFile*>(filelist->At(i));
1170 StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
1171 if (sc2 == StatusCode::SUCCESS) doneCleaning = true;
1172 }
1173 // 3) Check if TGraph fix has been applied successfully
1174 if (!doneCleaning) {
1175 ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
1176 allIsOk = false;
1177 }
1178 // 4) Register cloned histogram under previous interval streamName
1179 StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
1180 if (sc3 == StatusCode::FAILURE)
1181 allIsOk = false;
1182
1183 // get streamname for interval
1184 streamName = streamNameFunction()->getStreamName( this, group, name, false );
1185 // store metadata
1186 StatusCode smd = registerMetadata(streamName, name, group);
1187 if (smd != StatusCode::SUCCESS) allIsOk = false;
1188 // Re-register the original graph
1189 StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
1190 if (sc4 == StatusCode::FAILURE) allIsOk = false;
1191 }
1192
1193 if (!allIsOk) return StatusCode::FAILURE;
1194 return StatusCode::SUCCESS;
1195}
ManagedMonitorToolBase::StreamNameFcn::getDirectoryName
virtual std::string getDirectoryName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, const bool usePreviousInterval)=0
A function that returns TDirectory path in a file that corresponds to a given MonGroup and object nam...
ManagedMonitorToolBase::THistSvc_deReg_fixTGraph
StatusCode THistSvc_deReg_fixTGraph(TFile *file, TGraph *theGraph, std::string &directoryName)
Fixes THistSvc->deReg(obj) when obj is TGraph instance.
Definition ManagedMonitorToolBase.cxx:1037
python.envutil.filelist
filelist
print ("Checking files %s..." % fullfile)
Definition envutil.py:133

◆ regManagedGraphs()

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

Definition at line 1068 of file ManagedMonitorToolBase.cxx.

1070{
1071 // See the description for the regManagedHistograms method
1072 bool allIsOk = true;
1073
1074 for( std::vector< MgmtParams<TGraph> >::iterator it = templateGraphs.begin(); it != templateGraphs.end(); ++it ) {
1075 MonGroup group = (*it).m_group;
1076
1077 // Get a handle to the graph
1078 TGraph* theGraph = (*it).m_templateHist;
1079
1080 // Clone the graph
1081 TGraph* g = static_cast<TGraph*>(theGraph->Clone());
1082 theGraph->Set(0); // equivalent to Reset() for TH1
1083
1084 // Get name
1085 std::string gName = g->GetName();
1086
1087 // Get the streamName for the previous interval
1088 std::string streamName = streamNameFunction()->getStreamName( this, group, gName, true );
1089
1090 // De-register the original graph with the THistSvc
1091 StatusCode sc1 = m_THistSvc->deReg( theGraph );
1092 if (sc1 == StatusCode::FAILURE)
1093 allIsOk = false;
1094
1095 // *** begin ***
1096 // Fix THistSvc->deReg for TGraphs
1097 bool doneCleaning = false;
1098 std::string directoryName = streamNameFunction()->getDirectoryName( this, group, gName, true );
1099 TSeqCollection *filelist=gROOT->GetListOfFiles();
1100 for (int i=0; i<filelist->GetEntries(); i++) {
1101 ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
1102 TFile* file = static_cast<TFile*>(filelist->At(i));
1103 StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
1104 if (sc2 == StatusCode::SUCCESS)
1105 doneCleaning = true;
1106 }
1107
1108 // Check if TGraph fix has been applied successfully
1109 if (!doneCleaning) {
1110 ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
1111 allIsOk = false;
1112 }
1113 // *** end ***
1114
1115 // Register clonned histogram under previous interval streamName
1116 StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
1117 if (sc3 == StatusCode::FAILURE)
1118 allIsOk = false;
1119
1120 // Get streamName for the current interval
1121 streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1122 // Register metadata information with the current interval streamname
1123 StatusCode smd = registerMetadata(streamName, gName, group);
1124 if (smd != StatusCode::SUCCESS)
1125 allIsOk = false;
1126
1127 // Re-register the original graph with the current interval streamName
1128 StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
1129 if (sc4 == StatusCode::FAILURE)
1130 allIsOk = false;
1131
1132 }
1133
1134 if (!allIsOk) return StatusCode::FAILURE;
1135
1136 return StatusCode::SUCCESS;
1137}

◆ regManagedHistograms()

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

Definition at line 971 of file ManagedMonitorToolBase.cxx.

973{
974 // The method registers histograms with the THistSvc and saves them to file.
975
976 // The funky business with registering and deregistering the histogram is needed
977 // to get the correct directory when saving histograms. THistSvc deals with ROOT
978 // to set up proper TDirectory, so we rely on it.
979 // E.g.
980 // m_THistSvc->regHist( streamName, h ): sets the correct TDirectory with streamName
981 // m_THistSvc->deReg( h ) - deregister from THistSvc otherwise THistSvc will try to save it
982 // at the end of execution
983 // use passownership of the histogram and save it to file
984 // m_manager->passOwnership( h, genericName );
985 // m_manager->writeAndDelete( genericName );
986 bool allIsOk = true;
987
988 for( std::vector< MgmtParams<TH1> >::iterator it = templateHistograms.begin(); it != templateHistograms.end(); ++it ) {
989 MonGroup& group = (*it).m_group;
990
991 // Get a handle to the histogram
992 TH1* theHist = (*it).m_templateHist;
993
994 // Clone the histogram
995 TH1* h = static_cast<TH1*>(theHist->Clone());
996 theHist->Reset();
997
998 // Get name
999 std::string hName = h->GetName();
1000
1001 // Get the streamName for the previous interval
1002 std::string streamName = streamNameFunction()->getStreamName( this, group, hName, true );
1003
1004 // Register the histogram with the THistSvc
1005 StatusCode sc1 = m_THistSvc->deReg( theHist );
1006 if (sc1 == StatusCode::FAILURE) allIsOk = false;
1007
1008 // Register clonned histogram under previous interval streamName
1009 StatusCode sc2 = m_THistSvc->regHist( streamName, h );
1010 if (sc2 == StatusCode::FAILURE) allIsOk = false;
1011
1012 if( m_manager != 0 ) {
1013 std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1014 m_manager->passOwnership( h, genericName );
1015 m_manager->writeAndDelete( genericName );
1016 }
1017
1018 // Get streamName for the current interval
1019 streamName = streamNameFunction()->getStreamName( this, group, hName, false );
1020 // Register metadata information with the current interval streamname
1021 StatusCode smd = registerMetadata(streamName, hName, group);
1022 if (smd != StatusCode::SUCCESS) allIsOk = false;
1023
1024 // Re-register the original histogram with the current interval streamName
1025 StatusCode sc3 = m_THistSvc->regHist( streamName, theHist );
1026 if (sc3 == StatusCode::FAILURE) allIsOk = false;
1027
1028 }
1029
1030 if (!allIsOk) return StatusCode::FAILURE;
1031
1032 return StatusCode::SUCCESS;
1033}

◆ regManagedTrees()

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

Definition at line 1199 of file ManagedMonitorToolBase.cxx.

1201{
1202 // See the description for the regManagedHistograms method
1203 bool allIsOk = true;
1204
1205 for( std::vector< MgmtParams<TTree> >::iterator it = templateTrees.begin(); it != templateTrees.end(); ++it ) {
1206 MonGroup group = (*it).m_group;
1207
1208 // Get a handle to the original tree
1209 TTree* theTree = (*it).m_templateHist;
1210
1211 // Clone the tree
1212 TTree* t = static_cast<TTree*>(theTree->Clone());
1213 theTree->Reset();
1214
1215 // Dumping the tree
1216 std::string name = t->GetName();
1217
1218 // Get the streamName for the previous interval
1219 std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
1220
1221 // De-register original tree with the THistSvc
1222 StatusCode sc1 = m_THistSvc->deReg( theTree );
1223 if (sc1 == StatusCode::FAILURE) allIsOk = false;
1224
1225 // Register clonned tree under previous interval streamName
1226 StatusCode sc2 = m_THistSvc->regTree( streamName, t );
1227 if (sc2 == StatusCode::FAILURE) allIsOk = false;
1228
1229 if( m_manager != 0 ) {
1230 std::string genericName = NoOutputStream().getStreamName( this, group, name );
1231 m_manager->passOwnership( t, genericName );
1232 m_manager->writeAndDelete( genericName );
1233 }
1234
1235 // Get streamName for the current interval
1236 streamName = streamNameFunction()->getStreamName( this, group, name, false );
1237 // Register metadata information with the current interval streamname
1238 StatusCode smd = registerMetadata(streamName, name, group);
1239 if (smd != StatusCode::SUCCESS) allIsOk = false;
1240
1241 // Re-register the original graph with the current interval streamName
1242 StatusCode sc3 = m_THistSvc->regTree( streamName, theTree );
1243 if (sc3 == StatusCode::FAILURE) allIsOk = false;
1244
1245 }
1246
1247 if (!allIsOk) return StatusCode::FAILURE;
1248
1249 return StatusCode::SUCCESS;
1250}
read_hist_ntuple.t
t
Definition read_hist_ntuple.py:5

◆ 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 1554 of file ManagedMonitorToolBase.cxx.

1556{
1557
1558 // This part of the code deals with MANAGED type
1559 if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1560 // Create an unmanaged group based on the original MonGroup instance passed
1561 // This is needed because managed tree is presented as a number of unmanaged
1562 // trees (one per each interval)
1563 MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1564
1565 if (m_supportedIntervalsForRebooking.count(group.interval())) {
1566 m_templateTrees[group.interval()].push_back( MgmtParams<TTree>(t, group_unmanaged) );
1567 } else {
1568 ATH_MSG_ERROR("Attempt to book managed tree " << t->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1569 return StatusCode::FAILURE;
1570 }
1571
1572 std::string name = t->GetName();
1573 std::string genericName = NoOutputStream().getStreamName( this, group_unmanaged, name );
1574 std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1575 registerMetadata(streamName, name, group).ignore();
1576 return m_THistSvc->regTree( streamName, t );
1577 }
1578
1579
1580 // This part of the code deals with UNMANAGED type
1581 std::string tName = t->GetName();
1582
1583 if( m_manager != 0 ) {
1584 std::string genericName = NoOutputStream().getStreamName( this, group, tName );
1585 m_manager->writeAndDelete( genericName );
1586 m_manager->passOwnership( t, genericName );
1587 }
1588
1589 std::string streamName = streamNameFunction()->getStreamName( this, group, tName, false );
1590
1591 StatusCode smd = registerMetadata(streamName, tName, group);
1592 if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1593
1594 return m_THistSvc->regTree( streamName, t );
1595}
ManagedMonitorToolBase::m_templateTrees
std::map< Interval_t, std::vector< MgmtParams< TTree > > > m_templateTrees
Definition ManagedMonitorToolBase.h:672

◆ 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 1544 of file ManagedMonitorToolBase.cxx.

1547{
1548 MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1549 return regTree( t, group );
1550}
ManagedMonitorToolBase::regTree
virtual StatusCode regTree(TTree *t, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TTree to be included in the output stream using logical parameters that describe it.
Definition ManagedMonitorToolBase.cxx:1545

◆ removeTObj()

StatusCode TilePaterMonTool::removeTObj ( TObject * obj)
protectedinherited

Definition at line 416 of file TilePaterMonTool.cxx.

416 {
417 if (obj != 0) {
418 if (obj->IsA()->InheritsFrom("TH1")) {
419 if (deregHist(static_cast<TH1*> (obj)).isFailure()) {
420 ATH_MSG_WARNING( "Could not dereg Histogram : " << obj->GetName() );
421 return StatusCode::FAILURE;
422 } else {
423 delete obj;
424 }
425 } else if (obj->IsA()->InheritsFrom("TGraph")) {
426 if (deregGraph(static_cast<TGraph*> (obj)) != StatusCode::SUCCESS) {
427 ATH_MSG_WARNING( "Could not dereg Graph : " << obj->GetName() );
428 return StatusCode::FAILURE;
429 } else {
430 delete obj;
431 }
432 } else {
433 ATH_MSG_WARNING( "Asked to remove object " << obj->GetName() << "of unsupported type " << obj->IsA() );
434 return StatusCode::FAILURE;
435 }
436 } else {
437 ATH_MSG_WARNING( "Asked to remove NULL pointer" );
438 return StatusCode::FAILURE;
439 }
440 return StatusCode::SUCCESS;
441}
ManagedMonitorToolBase::deregHist
virtual StatusCode deregHist(TH1 *h)
De-registers a TH1 from the THistSvc, but does NOT delete the object.
Definition ManagedMonitorToolBase.cxx:1616
ManagedMonitorToolBase::deregGraph
virtual StatusCode deregGraph(TGraph *g)
De-registers a TGraph from the THistSvc, but does NOT delete the object.
Definition ManagedMonitorToolBase.cxx:1624

◆ 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 }
AthCommonDataStore::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 > renounce(T &h)
Definition AthCommonDataStore.h:380

◆ 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 1022 of file TileRawChannelMonTool.cxx.

1024{
1025
1026 memset(m_data->m_timeCov, 0, sizeof(m_data->m_timeCov));
1027 memset(m_data->m_timeCovCorr, 0, sizeof(m_data->m_timeCovCorr));
1028
1029 int mingain = (m_bigain) ? 0 : 2;
1030 int maxgain = (m_bigain) ? 2 : 3;
1031
1032 for (int ros = 1; ros < 5; ++ros) {
1033 for (int drawer = 0; drawer < 64; ++drawer) {
1034 if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
1035 for (int ch = 0; ch < 48; ++ch) {
1036 for (int gn = mingain; gn < maxgain; ++gn) {
1037 for (auto h : m_data->m_hist1[ros][drawer][ch][gn]) h->Reset();
1038 for (auto h : m_data->m_hist2[ros][drawer][ch][gn]) h->Reset();
1039 }
1040 }
1041 }
1042 }
1043 }
1044}

◆ runStat()

StatusCode ManagedMonitorToolBase::runStat ( )
virtualinherited

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

Implements IMonitorToolBase.

Definition at line 1661 of file ManagedMonitorToolBase.cxx.

1663{
1664 return StatusCode::SUCCESS;
1665}

◆ setMonManager()

void ManagedMonitorToolBase::setMonManager ( AthenaMonManager * manager)
virtualinherited

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

Definition at line 1325 of file ManagedMonitorToolBase.cxx.

1327{
1328 ATH_MSG_DEBUG( "ManagedMonitorToolBase::setMonManager():");
1329 m_manager = manager;
1330 if( m_manager != 0 ) {
1331 ATH_MSG_DEBUG( " --> Setting manager");
1332 m_managerNameProp = m_manager->name();
1333 m_fileKey = m_manager->fileKey();
1334 m_dataType = m_manager->dataType();
1335 m_environment = m_manager->environment();
1336 delete m_streamNameFcn;
1337 m_streamNameFcn = getNewStreamNameFcn();
1338 }
1339 ATH_MSG_DEBUG( " --> Exiting successfully");
1340}
ManagedMonitorToolBase::getNewStreamNameFcn
virtual StreamNameFcn * getNewStreamNameFcn() const
Definition ManagedMonitorToolBase.cxx:2156

◆ 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 1650 of file ManagedMonitorToolBase.cxx.

1652{
1653 // All instances should write to the stream(s) defined by the
1654 // AthenaMonManager.
1655
1656 return StatusCode::SUCCESS;
1657}

◆ streamNameFunction()

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

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

Definition at line 450 of file ManagedMonitorToolBase.cxx.

452{
453 if( m_streamNameFcn == 0 ) {
454 msg(MSG::ERROR) << "!! streamNameFunction() has not been initialized !!" << endmsg;
455 msg(MSG::ERROR) << " --> neither ManagedMonitorToolBase::initialize() nor" << endmsg;
456 msg(MSG::ERROR) << " --> ManagedMonitorToolBase::setMonManager() has been called." << endmsg;
457 msg(MSG::ERROR) << " --> Correct configuration cannot be guaranteed from this point." << endmsg;
458 m_streamNameFcn = getNewStreamNameFcn();
459 }
460 return m_streamNameFcn;
461}

◆ 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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

◆ 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 1036 of file ManagedMonitorToolBase.cxx.

1038{
1039 // THistSvc employs TDirectory Append method when registering TGraph.
1040 // When deReg is used to de-register TGraph object, THistSvc only removes the object
1041 // from its internal management but forgets to delete from TDirectory.
1042 // The current method fixes this problem by removing the TGraph object manually
1043 // after THistSvc->deReg(TGraph* obj) is called.
1044
1045 // Saves and restores gFile and gDirectory
1046 GlobalDirectoryRestore restore;
1047
1048 // This check is true when TGraph object is removed successfully
1049 bool graphRemoved = false;
1050
1051 file->cd("/");
1052 TDirectory* dir = file->GetDirectory(directoryName.c_str());
1053 if (dir != 0) {
1054 dir->cd();
1055 TObject* obj = dir->Remove(theGraph);
1056 if (obj != 0)
1057 graphRemoved = true;
1058 }
1059
1060 if (!graphRemoved) {
1061 return StatusCode::FAILURE;
1062 }
1063
1064 return StatusCode::SUCCESS;
1065}

◆ trigChainsArePassed()

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

Definition at line 2092 of file ManagedMonitorToolBase.cxx.

2094{
2095 ATH_MSG_DEBUG( "ManagedMonitorToolBase::trigChainsArePassed:");
2096
2097 for(unsigned int i=0; i<vTrigNames.size(); i++) {
2098 if( m_trigDecTool->isPassed(vTrigNames[i]) ) {
2099 ATH_MSG_DEBUG( " + \"" << vTrigNames[i] << "\" passed, returning \'true\'");
2100 return true;
2101 }
2102 else {
2103 ATH_MSG_DEBUG( " - \"" << vTrigNames[i] << "\" did not pass");
2104 }
2105 }
2106
2107 return false;
2108}
ManagedMonitorToolBase::m_trigDecTool
PublicToolHandle< Trig::ITrigDecisionTool > m_trigDecTool
Definition ManagedMonitorToolBase.h:845

◆ updateTriggersForGroups()

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

Definition at line 2130 of file ManagedMonitorToolBase.cxx.

2131 {
2132 for (size_t i = 0; i < vTrigChainNames.size(); ++i) {
2133 std::string& thisName = vTrigChainNames[i];
2134 if (thisName.compare(0, 9, "CATEGORY_") ==0) {
2135 ATH_MSG_DEBUG("Found a trigger category: " << thisName << ". We will unpack it.");
2136 std::vector<std::string> triggers = m_trigTranslator->translate(thisName.substr(9,std::string::npos));
2137 std::ostringstream oss;
2138 oss << "(";
2139 for (size_t itrig = 0; itrig < triggers.size(); ++itrig) {
2140 if (itrig != 0) {
2141 oss << "|";
2142 }
2143 oss << triggers[itrig];
2144 }
2145 oss << ")";
2146 // replace with new value
2147 std::string newval = oss.str();
2148 ATH_MSG_DEBUG("Replaced with " << newval);
2149 vTrigChainNames[i] = std::move(newval);
2150 }
2151 }
2152}
ManagedMonitorToolBase::m_trigTranslator
PublicToolHandle< ITriggerTranslatorTool > m_trigTranslator
Definition ManagedMonitorToolBase.h:847

◆ 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 }
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:398

◆ writeAndDelete()

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

Write out histogram and delete it.

Definition at line 1599 of file ManagedMonitorToolBase.cxx.

1600 {
1601 if (!h)
1602 return StatusCode::FAILURE;
1603
1604 std::string hName = h->GetName();
1605
1606 if( m_manager != 0 ) {
1607 std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1608 m_manager->writeAndDelete( genericName );
1609 }
1610 return StatusCode::SUCCESS;
1611}

Member Data Documentation

◆ m_bigain

bool TileRawChannelMonTool::m_bigain {}
private

Definition at line 143 of file TileRawChannelMonTool.h.

143{};

◆ m_book2D

bool TileRawChannelMonTool::m_book2D {}
private

Definition at line 70 of file TileRawChannelMonTool.h.

70{};

◆ m_bookAll

bool TileRawChannelMonTool::m_bookAll {}
private

Definition at line 69 of file TileRawChannelMonTool.h.

69{};

◆ m_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial
privateinherited

Definition at line 893 of file ManagedMonitorToolBase.h.

◆ m_cabling

const TileCablingService* TilePaterMonTool::m_cabling {}
protectedinherited

Definition at line 201 of file TilePaterMonTool.h.

201{};

◆ m_calibUnit

TileRawChannelUnit::UNIT TileRawChannelMonTool::m_calibUnit {}
private

Definition at line 166 of file TileRawChannelMonTool.h.

166{};

◆ 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 245 of file TilePaterMonTool.h.

245 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
246 , 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0
247 , 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0
248 , 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1 };

◆ 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 250 of file TilePaterMonTool.h.

250 { 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0
251 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
252 , 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0
253 , 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1 };

◆ 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 240 of file TilePaterMonTool.h.

240 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
241 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
242 , 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0
243 , 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 };

◆ 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.

97{}; //ros, drawer, gain, DMU

◆ m_d

Imp* ManagedMonitorToolBase::m_d
privateinherited

Definition at line 900 of file ManagedMonitorToolBase.h.

◆ m_dac2Charge

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

Definition at line 179 of file TileRawChannelMonTool.h.

179{};

◆ 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 838 of file ManagedMonitorToolBase.h.

◆ m_dataTypeStr

std::string ManagedMonitorToolBase::m_dataTypeStr
protectedinherited

Definition at line 834 of file ManagedMonitorToolBase.h.

◆ m_defaultLBDuration

float ManagedMonitorToolBase::m_defaultLBDuration
privateinherited

Definition at line 895 of file ManagedMonitorToolBase.h.

◆ m_detailLevel

unsigned int ManagedMonitorToolBase::m_detailLevel
protectedinherited

Definition at line 836 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.

170{};

◆ m_DownLimit

double TileRawChannelMonTool::m_DownLimit {}
private

Definition at line 76 of file TileRawChannelMonTool.h.

76{}; // Down Threshold for Amp/Q ratio plots

◆ m_DQFilterTools

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

Definition at line 849 of file ManagedMonitorToolBase.h.

849{this,"FilterTools",{}};

◆ 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.

171{};

◆ 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 210 of file TilePaterMonTool.h.

210 { "E3", "E4", "D4", "D4", "C10", "C10", "A12", "A12", "B11", "B11", "A13", "A13"
211 , "E1", "E2", "B12", "B12", "D5", "D5", "E3*", "E4*", "A14", "A14", "B13", "B13"
212 , "", "", "", "", "", "", "B14", "A15", "A15", "", "", "B14"
213 , "B15", "D6", "D6", "B15", "A16", "A16", "", "", "", "", "", "" };

◆ 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.

88{};

◆ m_endOfEventsBlock

bool ManagedMonitorToolBase::m_endOfEventsBlock
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_endOfLowStat

bool ManagedMonitorToolBase::m_endOfLowStat
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_endOfLumiBlock

bool ManagedMonitorToolBase::m_endOfLumiBlock
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_endOfRun

bool ManagedMonitorToolBase::m_endOfRun
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_environment

AthenaMonManager::Environment_t ManagedMonitorToolBase::m_environment
protectedinherited

Definition at line 839 of file ManagedMonitorToolBase.h.

◆ m_environmentStr

std::string ManagedMonitorToolBase::m_environmentStr
protectedinherited

Definition at line 835 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 833 of file ManagedMonitorToolBase.h.

◆ m_fragIDsDemonstrators

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

Definition at line 208 of file TilePaterMonTool.h.

◆ m_fragIDsToIgnoreDMUerrors

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

Definition at line 207 of file TilePaterMonTool.h.

◆ m_haveClearedLastEventBlock

bool ManagedMonitorToolBase::m_haveClearedLastEventBlock
protectedinherited

Definition at line 866 of file ManagedMonitorToolBase.h.

◆ m_hi_IntegralLimit

double TileRawChannelMonTool::m_hi_IntegralLimit {}
private

Definition at line 80 of file TileRawChannelMonTool.h.

80{}; // Warning error bar High limit for Amp/Q ratio plots

◆ m_infoName

std::string TileRawChannelMonTool::m_infoName {}
private

Definition at line 174 of file TileRawChannelMonTool.h.

174{};

◆ m_intCalibUnit

int TileRawChannelMonTool::m_intCalibUnit {}
private

Definition at line 178 of file TileRawChannelMonTool.h.

178{};

◆ m_is12bit

bool TileRawChannelMonTool::m_is12bit {}
private

Definition at line 176 of file TileRawChannelMonTool.h.

176{};

◆ m_lastHigStatInterval

int ManagedMonitorToolBase::m_lastHigStatInterval
protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lastLowStatInterval

int ManagedMonitorToolBase::m_lastLowStatInterval
protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lastLumiBlock

unsigned int ManagedMonitorToolBase::m_lastLumiBlock
protectedinherited

Definition at line 859 of file ManagedMonitorToolBase.h.

◆ m_lastMedStatInterval

int ManagedMonitorToolBase::m_lastMedStatInterval
protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lastRun

unsigned int ManagedMonitorToolBase::m_lastRun
protectedinherited

Definition at line 860 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 215 of file TilePaterMonTool.h.

215 { "D0", "A1", "B1", "B1", "A1", "A2", "B2", "B2", "A2", "A3", "A3", "B3"
216 , "B3", "D1", "D1", "A4", "B4", "B4", "A4", "A5", "A5", "B5", "B5", "A6"
217 , "D2", "D2", "A6", "B6", "B6", "A7", "", "", "A7", "B7", "B7", "A8"
218 , "A9", "A9", "A8", "B8", "B8", "D3", "B9", "", "D3", "A10", "A10", "B9" };

◆ m_lbDurationDataKey

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

Definition at line 888 of file ManagedMonitorToolBase.h.

889{this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"};

◆ m_lo_IntegralLimit

double TileRawChannelMonTool::m_lo_IntegralLimit {}
private

Definition at line 78 of file TileRawChannelMonTool.h.

78{}; // Warning error bar Low limit for Amp/Q ratio plots

◆ m_lumiDataKey

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

Definition at line 886 of file ManagedMonitorToolBase.h.

887{this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"};

◆ m_manager

AthenaMonManager* ManagedMonitorToolBase::m_manager
protectedinherited

Definition at line 829 of file ManagedMonitorToolBase.h.

◆ m_managerNameProp

std::string ManagedMonitorToolBase::m_managerNameProp
protectedinherited

Definition at line 831 of file ManagedMonitorToolBase.h.

◆ m_med_IntegralLimit

double TileRawChannelMonTool::m_med_IntegralLimit {}
private

Definition at line 79 of file TileRawChannelMonTool.h.

79{}; // Warning error bar Med limit for Amp/Q ratio plots

◆ m_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap
protectedinherited

Definition at line 827 of file ManagedMonitorToolBase.h.

◆ m_minAmpForCorrectedTime

float TileRawChannelMonTool::m_minAmpForCorrectedTime {}
private

Definition at line 172 of file TileRawChannelMonTool.h.

172{};

◆ m_nEvents

unsigned int ManagedMonitorToolBase::m_nEvents
protectedinherited

Definition at line 863 of file ManagedMonitorToolBase.h.

◆ m_nEventsIgnoreTrigger

unsigned int ManagedMonitorToolBase::m_nEventsIgnoreTrigger
protectedinherited

Definition at line 864 of file ManagedMonitorToolBase.h.

◆ m_nEventsTileMon

int TileRawChannelMonTool::m_nEventsTileMon {}
private

Definition at line 144 of file TileRawChannelMonTool.h.

144{};

◆ m_newEventsBlock

bool ManagedMonitorToolBase::m_newEventsBlock
privateinherited

Definition at line 822 of file ManagedMonitorToolBase.h.

◆ m_newHigStatInterval

bool ManagedMonitorToolBase::m_newHigStatInterval
privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

◆ m_newLowStat

bool ManagedMonitorToolBase::m_newLowStat
privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_newLowStatInterval

bool ManagedMonitorToolBase::m_newLowStatInterval
privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

◆ m_newLumiBlock

bool ManagedMonitorToolBase::m_newLumiBlock
privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_newMedStatInterval

bool ManagedMonitorToolBase::m_newMedStatInterval
privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

◆ m_newRun

bool ManagedMonitorToolBase::m_newRun
privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks
protectedinherited

Definition at line 865 of file ManagedMonitorToolBase.h.

◆ m_overlaphists

bool TileRawChannelMonTool::m_overlaphists {}
private

Definition at line 71 of file TileRawChannelMonTool.h.

71{};

◆ m_path

std::string ManagedMonitorToolBase::m_path
protectedinherited

Definition at line 852 of file ManagedMonitorToolBase.h.

◆ m_plotDsp

bool TileRawChannelMonTool::m_plotDsp {}
private

Definition at line 83 of file TileRawChannelMonTool.h.

83{}; //book Optimal Filter histograms?

◆ m_preScaleProp

long ManagedMonitorToolBase::m_preScaleProp
protectedinherited

Definition at line 853 of file ManagedMonitorToolBase.h.

◆ m_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp
protectedinherited

Definition at line 851 of file ManagedMonitorToolBase.h.

◆ m_resetAfterSummaryUpdate

bool TileRawChannelMonTool::m_resetAfterSummaryUpdate {}
private

Definition at line 169 of file TileRawChannelMonTool.h.

169{};

◆ m_runType

int TileRawChannelMonTool::m_runType {}
private

Definition at line 72 of file TileRawChannelMonTool.h.

72{};

◆ m_savePng

bool TilePaterMonTool::m_savePng {}
protectedinherited

Definition at line 203 of file TilePaterMonTool.h.

203{};

◆ m_savePs

bool TilePaterMonTool::m_savePs {}
protectedinherited

Definition at line 204 of file TilePaterMonTool.h.

204{};

◆ m_saveSvg

bool TilePaterMonTool::m_saveSvg {}
protectedinherited

Definition at line 205 of file TilePaterMonTool.h.

205{};

◆ m_storeGraph

bool TileRawChannelMonTool::m_storeGraph {}
private

Definition at line 84 of file TileRawChannelMonTool.h.

84{}; //Store TGraph to file: necessary due to THistSvc bug

◆ m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn
protectedinherited

Definition at line 841 of file ManagedMonitorToolBase.h.

◆ m_summaryUpdateFrequency

int TileRawChannelMonTool::m_summaryUpdateFrequency {}
private

Definition at line 168 of file TileRawChannelMonTool.h.

168{};

◆ m_supportedIntervalsForRebooking

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

Definition at line 896 of file ManagedMonitorToolBase.h.

◆ m_templateEfficiencies

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

Definition at line 676 of file ManagedMonitorToolBase.h.

◆ m_templateGraphs

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

Definition at line 668 of file ManagedMonitorToolBase.h.

◆ m_templateHistograms

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

Definition at line 664 of file ManagedMonitorToolBase.h.

◆ m_templateTrees

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

Definition at line 672 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 843 of file ManagedMonitorToolBase.h.

◆ m_tileHWID

const TileHWID* TilePaterMonTool::m_tileHWID {}
protectedinherited

Definition at line 199 of file TilePaterMonTool.h.

199{};

◆ m_tileID

const TileID* TilePaterMonTool::m_tileID {}
protectedinherited

Definition at line 198 of file TilePaterMonTool.h.

198{};

◆ m_tileInfo

const TileInfo* TileRawChannelMonTool::m_tileInfo {}
private

Definition at line 175 of file TileRawChannelMonTool.h.

175{};

◆ m_tileTBID

const TileTBID* TilePaterMonTool::m_tileTBID {}
protectedinherited

Definition at line 200 of file TilePaterMonTool.h.

200{};

◆ 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 228 of file TilePaterMonTool.h.

228{"D5L", "D5R", "D6L", "D6R"};

◆ 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 227 of file TilePaterMonTool.h.

227{"D0", "D1L", "D1R", "D2R", "D2L", "D3L", "D3R", ""}; // should be corrected at some time

◆ m_trigDecTool

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

Definition at line 845 of file ManagedMonitorToolBase.h.

845{this, "TrigDecisionTool",""};

◆ m_triggerChainProp

std::string ManagedMonitorToolBase::m_triggerChainProp
protectedinherited

Definition at line 854 of file ManagedMonitorToolBase.h.

◆ m_triggerGroupProp

std::string ManagedMonitorToolBase::m_triggerGroupProp
protectedinherited

Definition at line 855 of file ManagedMonitorToolBase.h.

◆ m_trigLiveFractionDataKey

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

Definition at line 890 of file ManagedMonitorToolBase.h.

891{this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"};

◆ m_trigTranslator

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

Definition at line 847 of file ManagedMonitorToolBase.h.

847{this,"TriggerTranslatorTool",""};

◆ m_UpLimit

double TileRawChannelMonTool::m_UpLimit {}
private

Definition at line 77 of file TileRawChannelMonTool.h.

77{}; // Up Threshold for Amp/Q ratio plots

◆ m_useLumi

bool ManagedMonitorToolBase::m_useLumi
privateinherited

Definition at line 894 of file ManagedMonitorToolBase.h.

◆ m_useratioerror

bool TileRawChannelMonTool::m_useratioerror {}
private

Definition at line 81 of file TileRawChannelMonTool.h.

81{}; //use ratioerror bar or rangeerror bar ?

◆ m_useTrigger

bool ManagedMonitorToolBase::m_useTrigger
protectedinherited

Definition at line 857 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 680 of file ManagedMonitorToolBase.h.

◆ m_vTrigGroupNames

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

Definition at line 680 of file ManagedMonitorToolBase.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0