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

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

91{
92}

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

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

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

◆ bookHists() [2/2]

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

Definition at line 180 of file TileRawChannelMonTool.cxx.

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

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

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

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

1963{
1964 bool err = false;
1965
1966 if (checkDmuHeaderFormat((*headerVec)[dmu])) {
1967 err = true;
1968
1969 }
1970 if (checkDmuHeaderParity((*headerVec)[dmu])) {
1971 err = true;
1972
1973 }
1974 if (((*headerVec)[dmu] >> 25) & 0x1) {
1975 //Memory Parity Error
1976 err = true;
1977
1978 }
1979 if (((*headerVec)[dmu] >> 24) & 0x1) {
1980 //Single Strobe Error
1981 err = true;
1982
1983 }
1984 if (((*headerVec)[dmu] >> 23) & 0x1) {
1985 //Double Strobe Error
1986 err = true;
1987
1988 }
1989
1990 return err;
1991}
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 1438 of file TileRawChannelMonTool.cxx.

1440{
1441
1442 ATH_MSG_INFO("in checkHists()");
1443
1444 return StatusCode::SUCCESS;
1445}
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 1728 of file TileRawChannelMonTool.cxx.

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

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

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

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

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

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

◆ fillSummaryHistograms()

StatusCode TileRawChannelMonTool::fillSummaryHistograms ( )
private

Definition at line 1057 of file TileRawChannelMonTool.cxx.

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

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

1310{
1311 ATH_MSG_INFO("in finalHists()");
1312
1313 if (m_summaryUpdateFrequency == 0) {
1314 for (int ros = 1; ros < 5; ++ros) {
1315 for (int drawer = 0; drawer < 64; ++drawer) {
1316 if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
1317 bookSummaryHistograms(ros, drawer);
1318 }
1319 }
1320 }
1321 }
1322
1323 m_drawHists = true;
1324 CHECK(fillSummaryHistograms());
1325
1326
1327 return StatusCode::SUCCESS;
1328}

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

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

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

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

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

1852 {
1853 /*---------------------------------------------------------*/
1860 if (m_DownLimit < mean && mean < m_UpLimit) {
1861 if (xmin > m_DownLimit) xmin = mean;
1862 if (xmax < m_UpLimit) xmax = mean;
1863 }
1864
1865}

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

1868 {
1869 /*---------------------------------------------------------*/
1880 if (m_DownLimit < mean && mean < m_UpLimit) {
1881
1882 if (xmin > m_DownLimit) {
1883 xmin = mean;
1884 } else {
1885 int lo_thrbin = hist->FindBin(m_DownLimit); //
1886 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
1887 double ratio = integral / (hist->GetEntries());
1888 if (ratio > m_hi_IntegralLimit) {
1889 xmin = mean - 1.05;
1890 } //larger error bar
1891 else if (ratio > m_med_IntegralLimit) {
1892 xmin = mean - 0.7;
1893 } //intermediate error bar
1894 else if (ratio > m_lo_IntegralLimit) {
1895 xmin = mean - 0.35;
1896 } //small error bar
1897 else {
1898 xmin = mean;
1899 }
1900 }
1901
1902 if (xmax < m_UpLimit) {
1903 xmax = mean;
1904 } else {
1905 int hi_thrbin = hist->FindBin(m_UpLimit);
1906 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.
1907 double ratio = integral / (hist->GetEntries());
1908 if (ratio > m_hi_IntegralLimit) {
1909 xmax = mean + 1.05;
1910 } //larger error bar
1911 else if (ratio > m_med_IntegralLimit) {
1912 xmax = mean + 0.7;
1913 } //intermediate error bar
1914 else if (ratio > m_lo_IntegralLimit) {
1915 xmax = mean + 0.35;
1916 } //small error bar
1917 else {
1918 xmax = mean;
1919 }
1920 }
1921 }
1923}
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:126

◆ 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:8

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

1033{
1034
1035 memset(m_data->m_timeCov, 0, sizeof(m_data->m_timeCov));
1036 memset(m_data->m_timeCovCorr, 0, sizeof(m_data->m_timeCovCorr));
1037
1038 int mingain = (m_bigain) ? 0 : 2;
1039 int maxgain = (m_bigain) ? 2 : 3;
1040
1041 for (int ros = 1; ros < 5; ++ros) {
1042 for (int drawer = 0; drawer < 64; ++drawer) {
1043 if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
1044 for (int ch = 0; ch < 48; ++ch) {
1045 for (int gn = mingain; gn < maxgain; ++gn) {
1046 for (auto h : m_data->m_hist1[ros][drawer][ch][gn]) h->Reset();
1047 for (auto h : m_data->m_hist2[ros][drawer][ch][gn]) h->Reset();
1048 }
1049 }
1050 }
1051 }
1052 }
1053}

◆ 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