TileDigitsMonTool Class Reference

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

#include <TileDigitsMonTool.h>

Inheritance diagram for TileDigitsMonTool:

Collaboration diagram for TileDigitsMonTool:

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
	TileDigitsMonTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~TileDigitsMonTool ()
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)
virtual const uint8_t *	stuckBitProb (int ros, int module, int channel, int gain) const override
virtual void	saveStuckBitsProbabilities (TTree *tree) override
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 ()
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 }
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
int	stuckBits (TH1S *hist, int adc)
	Method to find stuckbits in Read-Out ADC channel.
int	stuckBits_Amp (TH1S *hist, int adc)
	A crude method to check Read-Out ADC channel stuckbits.
int	stuckBits_Amp2 (TH1S *hist, TH1C *modhist, int adc, TH2C *outhist=NULL, int ch=0, uint8_t *stuck_probs=NULL)
void	CRCcheck (const TileDQstatus *dqStatus, uint32_t crc32, uint32_t crcMask, int headsize, int ros, int drawer)
	Method to check global CRC and DMU CRC.
bool	DMUheaderCheck (std::vector< uint32_t > *headerVec, int ros, int drawer, int gain, int dmu)
	DMU header format as defined in http://www.sysf.physto.se/~klere/tile-dmu/header.html Bits: 1pllllesdrvvvv0mmgggbbbbbbbbbbbb.
void	shiftHisto (TH1S *hist, int ros, int drawer, int ch, int gain)
void	statTestHistos (int ros, int drawer, int gain)
int	define_palette (int ncolors, int *colors=NULL)
StatusCode	RODCRCcalc (const TileDQstatus *dqStatus)
bool	DMUheaderFormatCheck (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 case of error.
bool	DMUheaderParityCheck (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 {}
int	m_runType {}
std::string	m_contNameDSP
ToolHandle< TileCondToolNoiseSample >	m_tileToolNoiseSample
	tool which provided noise values
const uint32_t *	m_cispar {}
bool	m_bigain {}
int	m_nEventsTileMon {}
int	m_nSamples {}
std::unique_ptr< Data >	m_data
bool	m_allHistsFilled {}
bool	m_fillPedestalDifference {}
std::string	m_digitsContainerName
std::string	m_infoName
const TileInfo *	m_tileInfo {}
int	m_i_ADCmax {}
float	m_f_ADCmax {}
float	m_ADCmaxMinusEps {}
bool	m_is12bit {}
int	m_shiftnbins {}
int	m_zeroLimitHG {}
int	m_saturationLimitHG {}
SG::ReadHandleKey< TileDQstatus >	m_DQstatusKey
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

Static Private Attributes
static const int	m_NCont = 10

Detailed Description

Class for TileCal monitoring at digits level.

Definition at line 30 of file TileDigitsMonTool.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

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.

                      { file = 0, eventsBlock, lumiBlock,
         lowStat, medStat, higStat,
         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.

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

RunType

enum TileDigitsMonTool::RunType

private

Enumerator
Unknown
PhysRun
LasRun
LedRun
PedRun
CisRun
MonoRun
CisRamp

Definition at line 109 of file TileDigitsMonTool.h.

                 {
      Unknown = 0, // expect monogain
      PhysRun = 1, // expect monogain
      LasRun = 2, // expect monogain
      LedRun = 3, // expect monogain
      PedRun = 4, // expect bigain
      CisRun = 8, // expect bigain
      MonoRun = 9, // expect monogain
      CisRamp = 10 // expect monogain
    };

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.

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

Constructor & Destructor Documentation

TileDigitsMonTool()

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

Definition at line 51 of file TileDigitsMonTool.cxx.

  : TilePaterMonTool(type, name, parent)
  , m_tileToolNoiseSample("TileCondToolNoiseSample")
  , m_cispar(0)
  , m_nEventsTileMon(0)
  , m_allHistsFilled(false)
  //, hp(-1)
  //, hb(-1)
  , m_tileInfo(0)
  , m_is12bit(false)
  , m_shiftnbins(0)
/*---------------------------------------------------------*/
{
  declareInterface<IMonitorToolBase>(this);
  declareInterface<ITileStuckBitsProbsTool>(this);
 
  declareProperty("bookAllDrawers", m_bookAll = false);
  declareProperty("book2D", m_book2D = false);
 
  // run type 1 - phys, 2 - las, 4 - ped, 8 - cis, 9- mono
  declareProperty("runType", m_runType = 8);
  declareProperty("bigain", m_bigain = true);
  declareProperty("NSamples", m_nSamples = 7);
  declareProperty("TileRawChannelContainerDSP", m_contNameDSP = "TileRawChannelCnt");
  declareProperty("TileDigitsContainer", m_digitsContainerName = "TileDigitsCnt");
  declareProperty("FillPedestalDifference", m_fillPedestalDifference = true);
  declareProperty("TileInfoName", m_infoName = "TileInfo");
  declareProperty("TileDQstatus", m_DQstatusKey = "TileDQstatus");
  declareProperty("ZeroLimitHG", m_zeroLimitHG = 0);
  declareProperty("SaturationLimitHG", m_saturationLimitHG = 1023);
 
  m_path = "/Tile/Digits"; //ROOT file directory
}

~TileDigitsMonTool()

TileDigitsMonTool::~TileDigitsMonTool ( )

virtual

Definition at line 86 of file TileDigitsMonTool.cxx.

{
}

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

{
 
  TH1S* hist = new TH1S(TString(nam), TString(tit), nx, xlgbins);
  regHist(subdir, hist, interval, attribute, trigChain, mergeAlgo);
  return hist;
}

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

                                                                                                                                    {
 
  TGraph1 *hist = new TGraph1(N, X, Y);
  hist->SetName(TString(nam));
  hist->SetTitle(TString(tit));
 
  regGraph(subdir, hist);
 
  return hist;
}

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.

{
 
  TGraphAsymmErrors *hist = new TGraphAsymmErrors(N, X, Y, X_errors1, X_errors2, Y_errors1, Y_errors2);
  hist->SetName(TString(nam));
  hist->SetTitle(TString(tit));
 
  regGraph(subdir, hist);
  return hist;
}

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.

                                                                                                                                                                                     {
 
  TGraphErrors *hist = new TGraphErrors(N, X, Y, X_errors, Y_errors);
  hist->SetName(TString(nam));
  hist->SetTitle(TString(tit));
 
  regGraph(subdir, hist);
  return hist;
}

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.

{
 
   return StatusCode::SUCCESS;
}

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.

{
   if( m_newEventsBlock ) { }
   if( m_newLumiBlock ) { }
   if( m_newRun ) { }
 
   return StatusCode::SUCCESS;
}

bookHists() [1/2]

StatusCode TileDigitsMonTool::bookHists ( )

overridevirtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 134 of file TileDigitsMonTool.cxx.

{
 
  if (msgLvl(MSG::DEBUG)) {
    msg(MSG::DEBUG) << "in bookHists()" << endmsg;
    msg(MSG::DEBUG) << "Using base path " << m_path << endmsg;
  }
 
  if (m_bookAll) {
    for (int ros = 1; ros < 5; ++ros) {
      for (int drawer = 0; drawer < 64; ++drawer) {
        bookHists(ros, drawer);
      }
    }
  }
 
  m_data->m_outInHighGain.push_back(book1D("Summary", "OverFlowInHighGain", "Injected charge with overflow in high gain", 10010, -0.5, 1000.5));
 
  //SetBookStatus(true);
 
  return StatusCode::SUCCESS;
}

bookHists() [2/2]

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

index of hists per one channel per gain 0 - digit[0] (first sample only) 1 - mean RMS over 7(9) samples in event 2 - all samples

index of hists per TileDMU (16 DMUs, first 16 channels used) 3 - BCID 4 - BCID errors 5 - CRC errors (only gain=0 used, so should be the last histogram in a vector)

for bigain run book 2 histograms per channel for monogain run book just one histogram per channel

Definition at line 159 of file TileDigitsMonTool.cxx.

{
  const char *part[5] = { "AUX", "LBA", "LBC", "EBA", "EBC" };
  const char *gain[6] = { "_lo", "_hi", "", " low gain", " high gain", "" };

 
  MsgStream log(msgSvc(), name());
 
  std::ostringstream sStr;
  sStr << part[ros] << std::setfill('0') << std::setw(2) << drawer + 1 << std::setfill(' ');
  std::string moduleName = sStr.str();
  std::string subDir = moduleName;
  std::string histName, histTitle;
 
  ATH_MSG_DEBUG("in bookHists() for module " << moduleName);

  int mingain = (m_bigain) ? 0 : 2;
  int maxgain = (m_bigain) ? 2 : 3;
 
  for (int gn = mingain; gn < maxgain; ++gn) {
    //Book DMU header errors histograms
    int adc = gn & 1;
 
    sStr.str("");
    sStr << moduleName << "_DMU_head_" << gain[gn] << "_err";
    histName = sStr.str();
 
    sStr.str("");
    sStr << moduleName << " DMU Header " << gain[3 + gn] << " errors";
    histTitle = sStr.str();
 
    m_data->m_hist2[ros][drawer][adc].push_back(book2F(subDir, histName, histTitle, 16, 0., 16., 8, -0.5, 7.5));
  }
 
  for (int ch = 0; ch < 48; ++ch) {
 
    //    int pmt=m_cabling->channel2hole(ros,ch); // 1:48, negative for non-connected channels
    //    int pmt0 = ((pmt > 0)? pmt-1 : pmt+1); // 0:47, negaitve for non-connected channels
    sStr.str("");
    sStr << std::setfill('0') << std::setw(2) << ch << std::setfill(' ');
    std::string sCh = sStr.str(); // 00:47, always positive
 
    for (int gn = mingain; gn < maxgain; ++gn) {
 
      int adc = gn & 1;
 
      // first sample
      sStr.str("");
      sStr << moduleName << "_ch_" << sCh << gain[gn] << "_sample0";
      histName = sStr.str();
 
      sStr.str("");
      sStr << moduleName << " CH " << ch << gain[3 + gn] << " sample[0]";
      histTitle = sStr.str();
 
      m_data->m_hist1[ros][drawer][ch][adc].push_back(book1S(subDir, histName, histTitle, 151, -0.5, 150.5));
 
      // RMS over samples in event
      sStr.str("");
      sStr << moduleName << "_ch_" << sCh << gain[gn] << "_meanRMS";
      histName = sStr.str();
 
      sStr.str("");
      sStr << moduleName << " CH " << ch << gain[3 + gn] << " mean RMS in event";
      histTitle = sStr.str();
 
      m_data->m_hist1[ros][drawer][ch][adc].push_back(book1S(subDir, histName, histTitle, 101, -0.05, 10.05));
 
      //all samples to find stuck bits
      sStr.str("");
      sStr << moduleName << "_ch_" << sCh << gain[gn] << "_samples";
      histName = sStr.str();
 
      sStr.str("");
      sStr << moduleName << " CH " << ch << gain[3 + gn] << " all samples";
      histTitle = sStr.str();
 
      m_data->m_hist1[ros][drawer][ch][adc].push_back(book1S(subDir, histName, histTitle, m_i_ADCmax + 1, -0.5, m_i_ADCmax + 0.5));
 
      //eventnumber % 32 for n/32 gain switch failure
      sStr.str("");
      sStr << moduleName << "_ch_" << sCh << gain[gn] << "_evtn_mod32";
      histName = sStr.str();
 
      sStr.str("");
      sStr << moduleName << " CH " << ch << gain[3 + gn] << " event number % 32";
      histTitle = sStr.str();
 
      m_data->m_histC[ros][drawer][ch][adc].push_back(book1C(subDir, histName, histTitle, 32, -0.5, 31.5));
 
      // average profile for a given channel/gain
      sStr.str("");
      sStr << moduleName << "_ch_" << sCh << gain[gn] << "_prof";
      histName = sStr.str();
 
      sStr.str("");
      sStr << moduleName << " CH " << ch << gain[3 + gn] << " average profile";
      histTitle = sStr.str();
 
      m_data->m_histP[ros][drawer][ch][adc].push_back(bookProfile(subDir, histName, histTitle, m_nSamples, 0.0, m_nSamples * 1.0, -0.5, m_i_ADCmax + 0.5));
 
      // shifted samples histograms
 
      double shiftxmin = 0.;
      double shiftxmax = m_shiftnbins;
      int shiftnbins = m_shiftnbins;
 
      sStr.str("");
      sStr << moduleName << "_ch_" << sCh << gain[gn] << "_samples_shifted";
      histName = sStr.str();
 
      sStr.str("");
      sStr << moduleName << " CH " << ch << gain[3 + gn] << " all samples shifted";
      histTitle = sStr.str();
 
      m_data->m_shifted_hist[ros][drawer][ch][adc] = book1S(subDir, histName, histTitle, shiftnbins, shiftxmin, shiftxmax);
 
      if (ch < 16) { // use first 16 channels to store BCID/CRC errors (one per TileDMU)
 
        sStr.str("");
        sStr << std::setfill('0') << std::setw(2) << ch << std::setfill(' ');
        std::string sDmu = sStr.str();
 
        sStr.str("");
        sStr << moduleName << "_dmu_" << sDmu << gain[gn] << "_BCID";
        histName = sStr.str();
 
        sStr.str("");
        sStr << moduleName << " DMU0 " << ch << gain[3 + gn] << " BCID";
        histTitle = sStr.str();
 
        m_data->m_hist1[ros][drawer][ch][adc].push_back(book1S(subDir, histName, histTitle, 100, 2050.5, 2150.5));
 
        sStr.str("");
        sStr << moduleName << "_dmu_" << sDmu << gain[gn] << "_BCID_err";
        histName = sStr.str();
 
        sStr.str("");
        sStr << moduleName << " DMU0 " << ch << gain[3 + gn] << " BCID errors";
        histTitle = sStr.str();
 
        m_data->m_hist_DMUerr[ros][drawer][ch][adc].push_back(book1I(subDir, histName, histTitle, 3, -0.5, 2.5));
 
        if (adc) continue; // don't book CRC for high gain
 
        sStr.str("");
        sStr << moduleName << "_dmu_" << sDmu << "_CRC_err";
        histName = sStr.str();
 
        sStr.str("");
        sStr << moduleName << " DMU0 " << ch << " CRC errors";
        histTitle = sStr.str();
 
        m_data->m_hist_DMUerr[ros][drawer][ch][0].push_back(book1I(subDir, histName, histTitle, 5, -0.5, 4.5));
      }
    }
  }
 
// and now global histograms for all channels in a drawer
 
  // global CRC
  sStr.str("");
  sStr << moduleName << "_CRC_global";
  histName = sStr.str();
 
  sStr.str("");
  sStr << moduleName << " global CRC errors";
  histTitle = sStr.str();
 
  m_data->m_hist0[ros][drawer].push_back(book1S("Summary", histName, histTitle, 3, -0.5, 2.5));
 
}

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.

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

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.

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

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.

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

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.

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

checkHists()

StatusCode TileDigitsMonTool::checkHists ( bool calledFromFinalize )

overridevirtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 938 of file TileDigitsMonTool.cxx.

{
 
  ATH_MSG_INFO("in checkHists()");
 
  return StatusCode::SUCCESS;
}

CRCcheck()

void TileDigitsMonTool::CRCcheck ( const TileDQstatus * dqStatus, uint32_t crc32, uint32_t crcMask, int headsize, int ros, int drawer )

private

Method to check global CRC and DMU CRC.

Author: Luca. F. November 06 This method provides CRC checks for Global and TileDMU chips. Global CRC is taken from the trailer and it is correct if the first 16 bits and the last 16 bits of the word match. TileDMU CRC is taken from the DMU mask filled in the FPGA. At the moment it makes sense only for monogain runs (Physics, LED, MonoCIS). The least significant 16 bits are the result of the CRC check in the FE (0xFFFF means all OK). The most significant 16 bits are the result of the CRC check in the ROD (0xFFFF means all OK).

bigain: dummy information

monogain: meaningful information. Fill 0 if crc32 if 0 Fill 1 if both FE and ROD crc is 1 Fill 2 if DMU FE crc is 0 Fill 3 if DMU ROD crc is 0 Fill 4 is FE and ROD crc is 0

Definition at line 1612 of file TileDigitsMonTool.cxx.

                                                                                                      {
 
  // protection against non-exisitng histograms
  if (m_data->m_hist0[ros][drawer].size() == 0) return;
 
  //LF CRC check
  //std::string ros_name[2] = {"LBA","LBC"};
  //std::cout << "Module= " << ros_name[ros-1] << drawer+1 << " CRCmask= 0x" <<  std::setfill('0') << std::setw(8) << std::hex <<  crcMask  << std::setfill(' ') << std::dec <<"\n";
 
  //END CRC check
  // array to adjust order of DMU's of EB* FE CRC status in DMU chip mask word
  // this is needed because FE and ROD fill DMU mask word in different order
  int chFE_ext[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 12, 13, 8, 9, 10, 11, 14, 15 };
  int chFE_sp[16] = { 11, 0, 1, 2, 3, 4, 5, 6, 12, 13, 7, 8, 9, 10, 14, 15 };
  // global CRC
  //  uint32_t crc32 = (*collItr)->getFragCRC();
  uint32_t crc0 = crc32 & 0xFFFF;
  uint32_t crc1 = crc32 >> 16;
  if (crc32 == 0)
    m_data->m_hist0[ros][drawer][0]->Fill(0.0, 1.0);
  else if (crc0 == crc1) // two half-words should match
    m_data->m_hist0[ros][drawer][0]->Fill(1.0, 1.0);
  else
    m_data->m_hist0[ros][drawer][0]->Fill(2.0, 1.0);
 
  // CRC per TileDMU.For mono gain we have it from ROD and FE. 
  // In bi gain, it is just a placeholder with global CRC information.
 
  if (headsize < 16) {  // How to handle EB? All bits are filled anyway or not?
  }
 
  if (dqStatus->calibMode() == 1) { 
    for (int ch = 0; ch < headsize; ++ch) {
      if (crc32 == 0)
        m_data->m_hist_DMUerr[ros][drawer][ch][0][1]->Fill(0.0, 1.0);
      else if (crc0 == crc1)
        m_data->m_hist_DMUerr[ros][drawer][ch][0][1]->Fill(1.0, 1.0);
      else
        m_data->m_hist_DMUerr[ros][drawer][ch][0][1]->Fill(2.0, 1.0);
 
    }
  } else { 
    if (crc32 == 0) {  //std::cout << "Global crc is zero\n";
      for (int ch = 0; ch < headsize; ++ch) {
        m_data->m_hist_DMUerr[ros][drawer][ch][0][1]->Fill(0.0, 1.0);
      }
    } else if (crcMask == 0xFFFFFFFF) {
      for (int ch = 0; ch < headsize; ++ch) {
        m_data->m_hist_DMUerr[ros][drawer][ch][0][1]->Fill(1.0, 1.0);
      }
    } else {
      uint32_t fe_crc = crcMask & 0xFFFF;
      uint32_t rod_crc = crcMask >> 16;
      for (int ch = 0; ch < headsize; ++ch) {
        int flag = 0;
        if (ros == 1 || ros == 2) // LB* use simple FECRC map
            {
          if ((fe_crc >> ch & 0x1) == 0x0) flag++;
        } else if (ros == 3 || ros == 4)  // EB* use different FECRC map
            {
          if ((ros == 3 && drawer == 14) || (ros == 4 && drawer == 17))  // Special Check for EBA15,EBC18
              {
            if ((fe_crc >> chFE_sp[ch] & 0x1) == 0x0) flag++;
          } else {
            if ((fe_crc >> chFE_ext[ch] & 0x1) == 0x0) flag++;
          }
        }
        if ((rod_crc >> ch & 0x1) == 0x0) flag += 2;
 
        //std::cout << "flag for chan "<< ch <<  "=" << flag <<  "\n";
 
        switch (flag) {
          case 0: //TileDMU is fine
            m_data->m_hist_DMUerr[ros][drawer][ch][0][1]->Fill(1.0, 1.0);
            break;
          case 1: //fe error only
            m_data->m_hist_DMUerr[ros][drawer][ch][0][1]->Fill(2.0, 1.0);
            break;
          case 2: // rod errors
            m_data->m_hist_DMUerr[ros][drawer][ch][0][1]->Fill(3.0, 1.0);
            break;
          default: // fe+rod errors
            m_data->m_hist_DMUerr[ros][drawer][ch][0][1]->Fill(4.0, 1.0);
        } // end switch case
 
      } // end loop on chips
 
    } // end if on crcMask
 
  } // end if on runtype
}

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.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

define_palette()

int TileDigitsMonTool::define_palette ( int ncolors, int * colors = NULL )

private

Definition at line 948 of file TileDigitsMonTool.cxx.

                                                              {
  /*---------------------------------------------------------*/
  Float_t alpha = 1.; // 0- transparent, 1- opaque
  Int_t ind;
  // set Deep Sea Blue palette (dark to light)
  if (ncolors == 51 && colors == 0) {
    TColor::InitializeColors();
    const int nRGBs = 5;
    Double_t stops[nRGBs] = { 0.00, 0.34, 0.61, 0.84, 1.00 };
    Double_t red[nRGBs] = { 0.00, 0.09, 0.18, 0.09, 0.00 };
    Double_t green[nRGBs] = { 0.01, 0.02, 0.39, 0.68, 0.97 };
    Double_t blue[nRGBs] = { 0.17, 0.39, 0.62, 0.79, 0.97 };
    ind = TColor::CreateGradientColorTable(nRGBs, stops, red, green, blue, m_NCont, alpha);
  }
 
  // set Grey Scale palette (light to dark)
  else if (ncolors == 52 && colors == 0) {
    TColor::InitializeColors();
    const int nRGBs = 3;
    Double_t stops[nRGBs] = { 0.00, 0.50, 1.00 };
    Double_t red[nRGBs] = { 0.90, 0.50, 0.10 };
    Double_t green[nRGBs] = { 0.90, 0.50, 0.10 };
    Double_t blue[nRGBs] = { 0.90, 0.50, 0.10 };
    ind = TColor::CreateGradientColorTable(nRGBs, stops, red, green, blue, m_NCont, alpha);
  } else
    return -1;
  return ind;
}

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.

{
   return m_THistSvc->deReg( g );
}

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.

{
   return m_THistSvc->deReg( h );
}

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.

{
   std::string streamName = streamNameFunction()->getStreamName( this, group, objName );
   return m_THistSvc->deReg( streamName );
}

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.

{
   MonGroup group( this, system, interval );
   return deregObject( objName, group );
}

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.

{ return m_detStore; }

DMUheaderCheck()

bool TileDigitsMonTool::DMUheaderCheck ( std::vector< uint32_t > * headerVec, int ros, int drawer, int gain, int dmu )

private

DMU header format as defined in http://www.sysf.physto.se/~klere/tile-dmu/header.html Bits: 1pllllesdrvvvv0mmgggbbbbbbbbbbbb.

The header starts with bit 31 set to indicate a header. The other bits as follows: p - Parity (odd) l - Derandomizer length (number of samples). e - Parity error. A parity error was detected from the memory in the last readout. s - SEstr Single Error Strobe recieved from the ttc. d - DEstr Double Error Strobe recieved from the ttc. r - Register parity. Parity from the registers in the chip. v - Variable parity. Parity from the variables in the chip. 0 - Not used. (Set to 0) m - Mode. 00 - Normal mode 01 - Calibration mode 10 - Test mode 11 - Not used g - High/low gain. Indicates high(1) or low(0) amplification from the 3-in-1 cards. b - Bunch Crossing.

Definition at line 1741 of file TileDigitsMonTool.cxx.

{
  bool err = false;
 
  if (DMUheaderFormatCheck((*headerVec)[dmu])) {
    m_data->m_hist2[ros][drawer][gain][0]->Fill(dmu + 0.5, 1., 1.);
    err = true;
    return err;
  }
  if (DMUheaderParityCheck((*headerVec)[dmu])) {
    m_data->m_hist2[ros][drawer][gain][0]->Fill(dmu + 0.5, 2., 1.);
    err = true;
    return err;
  }
  if (((*headerVec)[dmu] >> 25) & 0x1) {
    //Memory Parity Error
    m_data->m_hist2[ros][drawer][gain][0]->Fill(dmu + 0.5, 3., 1.);
    err = true;
  }
  if (((*headerVec)[dmu] >> 24) & 0x1) {
    //Single Strobe Error
    m_data->m_hist2[ros][drawer][gain][0]->Fill(dmu + 0.5, 4., 1.);
    err = true;
  }
  if (((*headerVec)[dmu] >> 23) & 0x1) {
    //Double Strobe Error
    m_data->m_hist2[ros][drawer][gain][0]->Fill(dmu + 0.5, 5., 1.);
    err = true;
  }
 
  if (!err) m_data->m_hist2[ros][drawer][gain][0]->Fill(dmu + 0.5, 0., 1.);
 
  int fragId = m_tileHWID->frag(ros, drawer);
  if (std::binary_search(m_fragIDsToIgnoreDMUerrors.begin(), m_fragIDsToIgnoreDMUerrors.end(), fragId)) {
    err = false;
  }
 
  return err;
}

DMUheaderFormatCheck()

bool TileDigitsMonTool::DMUheaderFormatCheck ( 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 case of error.

Definition at line 85 of file TileDigitsMonTool.h.

                                                      {
      if (((header >> 31 & 0x1) == 1) && ((header >> 17 & 0x1) == 0))
        return false; // no error
      else
        return true; //error
    };

DMUheaderParityCheck()

bool TileDigitsMonTool::DMUheaderParityCheck ( 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 95 of file TileDigitsMonTool.h.

                                                      {
      uint32_t parity(0);
      for (int i = 0; i < 32; ++i)
        parity += ((header >> i) & 0x1);
 
      if ((parity % 2) == 1) return false; //no error
      else return true; //error
    };

drawHists()

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

Definition at line 978 of file TileDigitsMonTool.cxx.

{
 
  ATH_MSG_VERBOSE("in drawHists()");
 
  int maxgain = (m_bigain) ? 2 : 1;
  double ms = (m_bigain) ? 0.75 : 1.0; // marker size
 
  static bool palette_init_done = false;
  static int pal51[m_NCont];
  static int pal52[m_NCont];
  static TExec *ex_pal51;
  static TExec *ex_pal52;
  bool do_plots = m_savePng || m_savePs || m_saveSvg;
 
  if (palette_init_done == false) {
    palette_init_done = true;
    int i;
    int ind = define_palette(51);
    if (ind < 0) ind = 0; // fall-back colours
    for (i = 0; i < m_NCont; i++)
      pal51[i] = ind + i;
    ind = define_palette(52);
    if (ind < 0) ind = 0; // fall-back colours
    for (i = 0; i < m_NCont; i++)
      pal52[i] = ind + i;
    TString s;
    s.Form("gStyle->SetPalette(%d,(int*)%ld);", m_NCont, (long) pal51);
    ex_pal51 = new TExec("ex_pal51", s.Data());
    s.Form("gStyle->SetPalette(%d,(int*)%ld);", m_NCont, (long) pal52);
    ex_pal52 = new TExec("ex_pal52", s.Data());
  }
 
  TLine * maxline[4];
  double line[8] = { 1.2, 2.5, 1.0, 1.0, 48.0, 48.0, 48.0, 16.0 };
  double miny[12] = { 20.0, 20.0, 0.0, 0.0, 0.0, 0.0, -0.1, -0.1, -0.1, -0.1, -0.1, -0.1 };
  double maxy[12] = { 80.0, 80.0, 1.5, 3.0, 1.5, 3.0, 2.2, 2.2, 2.2, 2.2, 3.2, 2.2 };
  //                   ?  ,  ?  , ?  , ?  , ?  , ?  ,  ?  ,  ? , BC hi,BC lo, CRC ,  ?
  if (m_fillPedestalDifference) {
    miny[0] = miny[1] = -5.0;
    maxy[0] = maxy[1] = 5.0;
  }
 
  TText *t = new TText();
  t->SetTextAlign(32);
  t->SetTextSize(0.06);
  t->SetTextFont(72);
 
  if (maxgain == 1) {
    line[0] = line[1];
    for (int ind = 0; ind < 12; ind += 2) {
      miny[ind] = miny[ind + 1] = std::min(miny[ind], miny[ind + 1]);
      maxy[ind] = maxy[ind + 1] = std::max(maxy[ind], maxy[ind + 1]);
    }
  }
 
  for (int type = 0; type < 4; ++type) {
    maxline[type] = new TLine(0.0, line[type], line[4 + type], line[type]);
    maxline[type]->SetLineColor(2 + type / 2);
  }
 
  TCanvas * Can = NULL;
  if (do_plots) {
    Can = new TCanvas("dig_noise", "dig_noise", 402 * maxgain, 588);
    Can->Divide(maxgain, 3);
    gStyle->SetOptStat(0);
    gStyle->SetTitleFontSize(0.1);
  }
 
  for (int gain = 0; gain < maxgain; ++gain) {
    for (int type = 0; type < 3; ++type) {
 
      if (do_plots) {
        TVirtualPad * pad = Can->cd(type * maxgain + gain + 1);
        pad->SetTopMargin(0.15);
        pad->SetGridx();
      }
      int ind = type * 2 + gain;
 
      if (m_data->m_final_hist1[ros][drawer][gain][type]->GetMaximum() < 0.9 * maxy[ind]) //if maximum is below reasonable limit use a default scale
      m_data->m_final_hist1[ros][drawer][gain][type]->SetMaximum(maxy[ind]);
      if (m_data->m_final_hist1[ros][drawer][gain][type]->GetMinimum() > (miny[ind] + 0.1 * TMath::Abs(miny[ind]))) // if minimum is above reasonable limit
        m_data->m_final_hist1[ros][drawer][gain][type]->SetMinimum(miny[ind]);                     // use a default scale
 
      m_data->m_final_hist1[ros][drawer][gain][type]->SetMarkerStyle(21);
      m_data->m_final_hist1[ros][drawer][gain][type]->SetMarkerSize(ms);
      m_data->m_final_hist1[ros][drawer][gain][type]->SetLabelSize(0.08, "X");
      m_data->m_final_hist1[ros][drawer][gain][type]->SetLabelSize(0.08, "Y");
      if (do_plots) {
        m_data->m_final_hist1[ros][drawer][gain][type]->Draw("P0");
        if (type > 0) maxline[gain]->Draw();
      }
    }
  }
 
  if (m_savePng) {
    Can->Print(TString(moduleName + "_dig_noise.png"), "png");
  }
  if (m_savePs) {
    Can->Print(TString(moduleName + "_dig_noise.ps"), "ps");
  }
  if (m_saveSvg) {
    Can->Print(TString(moduleName + "_dig_noise.svg"), "svg");
  }
  if (do_plots) {
    delete Can;
 
    Can = new TCanvas("dig_errors", "dig_errors", 402 * maxgain, 588);
    Can->Divide(maxgain, 4);
    gStyle->SetOptStat(1);
    gStyle->SetTitleFontSize(0.1);
  }
 
  for (int gain = 0; gain < maxgain; ++gain) {
    for (int type = 3; type < 6; ++type) {
 
      TVirtualPad * pad = NULL;
      if (do_plots) {
        pad = Can->cd((type - 3) * maxgain + gain + 1);
        pad->SetTopMargin(0.15);
      }
      int ind = type * 2 + gain;
 
      if (type == 5 && gain == 1) {
        if (do_plots) pad->SetLogy();
 
        m_data->m_hist0[ros][drawer][0]->SetStats(kFALSE);
        gStyle->SetStatFontSize(0.1);
        m_data->m_hist0[ros][drawer][0]->SetStats(kTRUE);
        m_data->m_hist0[ros][drawer][0]->SetLabelSize(0.08, "X");
        m_data->m_hist0[ros][drawer][0]->SetLabelSize(0.08, "Y");
        if (do_plots) m_data->m_hist0[ros][drawer][0]->Draw(); // global CRC in bottom right corner
 
      } else {
        if (do_plots) pad->SetGridx();
 
        if (m_data->m_final_hist1[ros][drawer][gain][type]->GetMaximum() < 0.9 * maxy[ind]) //if maximum is below reasonable limit use a default scale
        m_data->m_final_hist1[ros][drawer][gain][type]->SetMaximum(maxy[ind]);
        if (m_data->m_final_hist1[ros][drawer][gain][type]->GetMinimum() > (miny[ind] + 0.1 * TMath::Abs(miny[ind]))) // if minimum is above reasonable limit
          m_data->m_final_hist1[ros][drawer][gain][type]->SetMinimum(miny[ind]);                           // use a default scale
 
        m_data->m_final_hist1[ros][drawer][gain][type]->SetMarkerStyle(21);
        m_data->m_final_hist1[ros][drawer][gain][type]->SetMarkerSize(ms);
        m_data->m_final_hist1[ros][drawer][gain][type]->SetStats(kFALSE);
        m_data->m_final_hist1[ros][drawer][gain][type]->SetLabelSize(0.08, "X");
        m_data->m_final_hist1[ros][drawer][gain][type]->SetLabelSize(0.08, "Y");
        if (type != 3) {
          if (do_plots) m_data->m_final_hist1[ros][drawer][gain][type]->Draw("P0");
        } else {
          m_data->m_final_hist_stucks[ros][drawer][gain]->SetStats(kFALSE);
          m_data->m_final_hist_stucks[ros][drawer][gain]->SetMarkerSize(3.);
          m_data->m_final_hist_stucks[ros][drawer][gain]->SetMarkerColor(4);
          m_data->m_final_hist_stucks[ros][drawer][gain]->SetLabelSize(0.08, "X");
          m_data->m_final_hist_stucks[ros][drawer][gain]->SetLabelSize(0.1, "Y");
          gStyle->SetNumberContours(m_NCont);
          if (do_plots) {
            m_data->m_final_hist_stucks[ros][drawer][gain]->Draw("textzcol");
            ex_pal52->Draw();
            m_data->m_final_hist_stucks[ros][drawer][gain]->Draw("textcolzsame");
            pad->Update();
            TPaletteAxis *palette = (TPaletteAxis*) m_data->m_final_hist_stucks[ros][drawer][gain]->GetListOfFunctions()->FindObject("palette");
            if (palette != NULL) palette->SetLabelSize(0.07);
            pad->Modified();
          }
        }
        if (type == 4 || (type == 5 && gain == 0)) {
          m_data->m_final_hist1[ros][drawer][gain][type]->GetYaxis()->SetLabelOffset(-0.85); // do not draw default lables
          if (do_plots) {
            t->DrawText(-0.2, 1., "all OK");
            t->DrawText(-0.2, .0, "wrong");
            if (type == 4)
              t->DrawText(-0.2, 2., "mismatch");
            else {
              t->DrawText(-0.2, 2., "FE fail");
              t->DrawText(-0.2, 2.5, "FE+ROD fail");
              t->DrawText(-0.2, 3., "ROD fail");
            }
          }
        }
        /* if (type == 3)
         maxline[2]->Draw();
         else */
        if (type != 3) if (do_plots) maxline[3]->Draw();
      }
    }
    //LF Now plot DMU Header Errors histograms
    TVirtualPad * pad = NULL;
    if (do_plots) {
      pad = Can->cd(6 + gain + 1);
      pad->SetTopMargin(0.15);
      pad->SetGridx();
    }
    m_data->m_hist2[ros][drawer][gain][0]->SetMarkerSize(3.);
    m_data->m_hist2[ros][drawer][gain][0]->SetMarkerColor(2);
    m_data->m_hist2[ros][drawer][gain][0]->SetLabelSize(0.11, "Y");
    m_data->m_hist2[ros][drawer][gain][0]->SetLabelSize(0.08, "X");
    m_data->m_hist2[ros][drawer][gain][0]->SetStats(kFALSE);
    m_data->m_hist2[ros][drawer][gain][0]->GetYaxis()->SetBinLabel(1, "OK ");
    m_data->m_hist2[ros][drawer][gain][0]->GetYaxis()->SetBinLabel(2, "Format");
    m_data->m_hist2[ros][drawer][gain][0]->GetYaxis()->SetBinLabel(3, "Parity");
    m_data->m_hist2[ros][drawer][gain][0]->GetYaxis()->SetBinLabel(4, "Memory");
    m_data->m_hist2[ros][drawer][gain][0]->GetYaxis()->SetBinLabel(5, "SingleStr");
    m_data->m_hist2[ros][drawer][gain][0]->GetYaxis()->SetBinLabel(6, "DbleStr");
    m_data->m_hist2[ros][drawer][gain][0]->GetYaxis()->SetBinLabel(7, "DummyFrag");
    m_data->m_hist2[ros][drawer][gain][0]->GetYaxis()->SetBinLabel(8, "NoDataFrag");
    m_data->m_hist2[ros][drawer][gain][0]->GetYaxis()->SetTickLength(0.01);
    m_data->m_hist2[ros][drawer][gain][0]->GetYaxis()->SetLabelOffset(0.001);
    if (do_plots) {
      gStyle->SetNumberContours(m_NCont);
      m_data->m_hist2[ros][drawer][gain][0]->Draw("textzcol");
      ex_pal51->Draw();
      m_data->m_hist2[ros][drawer][gain][0]->Draw("textzcolsame");
      pad->Update();
      TPaletteAxis *palette = (TPaletteAxis*) m_data->m_hist2[ros][drawer][gain][0]->GetListOfFunctions()->FindObject("palette");
      if (palette != NULL) palette->SetLabelSize(0.07);
      pad->Modified();
    }
 
  }
 
  if (m_savePng) {
    Can->Print(TString(moduleName + "_dig_errors.png"), "png");
  }
  if (m_savePs) {
    Can->Print(TString(moduleName + "_dig_errors.ps"), "ps");
  }
  if (m_saveSvg) {
    Can->Print(TString(moduleName + "_dig_errors.svg"), "svg");
  }
  if (do_plots) delete Can;
 
  for (int type = 0; type < 4; ++type) {
    delete maxline[type];
  }
 
  delete t;
 
  if (m_runType == PedRun) {
 
    if (do_plots) {
      Can = new TCanvas("correlation", "correlation", 402 * maxgain, 588);
      Can->Divide(maxgain, 2);
      gStyle->SetOptStat(0);
      gStyle->SetPalette(1);
      gStyle->SetTitleFontSize(0.1);
    }
 
    TPaveLabel covar_label[2];
    covar_label[0] = TPaveLabel(37., 49., 54., 56., "");
    covar_label[1] = TPaveLabel(37., 49., 54., 56., "");
 
    for (int gain = 0; gain < maxgain; ++gain) {
      for (int type = 0; type < 2; ++type) {
        if (do_plots) {
          TVirtualPad * pad = Can->cd(type * maxgain + gain + 1);
          pad->SetTopMargin(0.15);
        }
        m_data->m_final_hist2[ros][drawer][gain][type]->SetLabelSize(0.06, "X");
        m_data->m_final_hist2[ros][drawer][gain][type]->SetLabelSize(0.06, "Y");
        if (do_plots) {
          m_data->m_final_hist2[ros][drawer][gain][type]->Draw("COLZ");
          if (type == 0) {
            std::ostringstream label_text;
            label_text << "<C_ij>/<C_ii>= " << std::setprecision(4) << m_data->m_cov_ratio[ros][drawer][gain] << std::setprecision(4);
            covar_label[gain].SetLabel(label_text.str().c_str());
            covar_label[gain].SetTextSize(0.4);
            covar_label[gain].Draw();
          }
        }
      }
    }
 
    if (m_savePng) {
      Can->Print(TString(moduleName + "_correlation.png"), "png");
    }
    if (m_savePs) {
      Can->Print(TString(moduleName + "_correlation.ps"), "ps");
    }
    if (do_plots) delete Can;
  }
 
  gStyle->SetOptStat(1111);
}

endOfEventsBlockFlag()

bool ManagedMonitorToolBase::endOfEventsBlockFlag ( ) const

inlineprotectedinherited

Definition at line 794 of file ManagedMonitorToolBase.h.

{ return m_endOfEventsBlock; }

endOfLowStatFlag()

bool ManagedMonitorToolBase::endOfLowStatFlag ( ) const

inlineprotectedinherited

Definition at line 795 of file ManagedMonitorToolBase.h.

{ return m_endOfLowStat; }

endOfLumiBlockFlag()

bool ManagedMonitorToolBase::endOfLumiBlockFlag ( ) const

inlineprotectedinherited

Definition at line 796 of file ManagedMonitorToolBase.h.

{ return m_endOfLumiBlock; }

endOfRunFlag()

bool ManagedMonitorToolBase::endOfRunFlag ( ) const

inlineprotectedinherited

Definition at line 797 of file ManagedMonitorToolBase.h.

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

{ 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

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.

{
   return StatusCode::SUCCESS;
}

fillHists()

StatusCode TileDigitsMonTool::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 345 of file TileDigitsMonTool.cxx.

{
//  static counter = 0;
//  bool extra = ((counter%m_updateCounter) == 0);
//  ++counter;
 
  ATH_MSG_DEBUG("in fillHists()");
 
  const TileDQstatus* dqStatus = SG::makeHandle (m_DQstatusKey).get();
 
  // array of 16 CIS parameters
  m_cispar = dqStatus->cispar();
  ++m_nEventsTileMon;
 
  //  std::cout << "Calib Mode=" << dqStatus->calibMode() << "\n";
 
  const TileDigitsContainer* digitsContainer;
  CHECK(evtStore()->retrieve(digitsContainer, m_digitsContainerName));
 
  for (const TileDigitsCollection* digitsCollection : *digitsContainer) {
 
    if (digitsCollection->empty()) continue;
 
    HWIdentifier adc_id = digitsCollection->front()->adc_HWID();
    int ros = m_tileHWID->ros(adc_id);
    int drawer = m_tileHWID->drawer(adc_id);
 
    if (m_data->m_hist1[ros][drawer][0][0].size() == 0) {
      m_bigain = true;
      m_nSamples = digitsCollection->front()->NtimeSamples();
      if (!m_bookAll) bookHists(ros, drawer);
    }
    
    uint32_t status = digitsCollection->getFragStatus();
    if (status != TileFragStatus::ALL_OK) {
      float bin = 99.;
      if (status & (TileFragStatus::ALL_FF | TileFragStatus::ALL_00)) {
        bin = 6.;
      } else if (status & (TileFragStatus::NO_FRAG | TileFragStatus::NO_ROB)) {
        bin = 7.;
      }
      for (int dmu = 0; dmu < 16; dmu++) {
        m_data->m_corrup[ros][drawer][0][dmu] = true;
        m_data->m_corrup[ros][drawer][1][dmu] = true;
        m_data->m_hist2[ros][drawer][0][0]->Fill(dmu + 0.5, bin, 1.);
        m_data->m_hist2[ros][drawer][1][0]->Fill(dmu + 0.5, bin, 1.);
      }
      continue;
    }
 
    std::vector<uint32_t> headerVec = digitsCollection->getFragChipHeaderWords();
 
    int headsize = headerVec.size();
    if (headsize > 16) {
      ATH_MSG_ERROR("length of BCID vector " << headsize << " - greater than 16 !");
      headsize = 16;
    }
    
    for (int dmu = 0; dmu < headsize; dmu++) {
      m_data->m_corrup[ros][drawer][0][dmu] = DMUheaderCheck(&headerVec, ros, drawer, 0, dmu); //tests and fills
      m_data->m_corrup[ros][drawer][1][dmu] = DMUheaderCheck(&headerVec, ros, drawer, 1, dmu);
    }
  
    for (int dmu = headsize; dmu < 16; dmu++) {
      m_data->m_corrup[ros][drawer][0][dmu] = false;
      m_data->m_corrup[ros][drawer][1][dmu] = false;
    }
  }
 
  for (const TileDigitsCollection* digitsCollection : *digitsContainer) {
 
    if (digitsCollection->empty()) continue;
 
    HWIdentifier adc_id = digitsCollection->front()->adc_HWID();
    int ros = m_tileHWID->ros(adc_id);
    int drawer = m_tileHWID->drawer(adc_id);
 
    if (m_data->m_hist1[ros][drawer][0][0].size() == 0) {
      //m_bigain = (dqStatus->calibMode() == 1); // true if bi-gain run
      // For the time being, we fill both high and low gain plots, as it was requiered by Tomas
      m_bigain = true;
      m_nSamples = digitsCollection->front()->NtimeSamples(); // number of samples
      //        bookHists(ros,drawer);
    }
    
    std::vector<uint32_t> headerVec = digitsCollection->getFragChipHeaderWords();
    
    int headsize = headerVec.size();
    //if (headsize > 16 ) {
    //   log << MSG::ERROR << "legth of BCID vector " << headsize << " - greater than 16 !" << endreq;
    //   headsize = 16;
    //}
 
    //coverity[STACK_USE]
    double mean_tmp[48][2][16];
    memset(mean_tmp, 0, sizeof(mean_tmp));
    
    // Below, the charge conversion for 12 bit is just an approximation;
    //   4095. can be changed later to gain precision if needed.
    double charge = 0;
    if (m_is12bit){ // if 12 bit ADCs
      charge = m_cispar[6] * m_cispar[7] * (2. * 4.096 / 4095.);
    }
    else{
      charge = m_cispar[6] * m_cispar[7] * (2. * 4.096 / 1023.);
    }
    
    for (const TileDigits* tileDigits : *digitsCollection) {
 
      adc_id = tileDigits->adc_HWID();
      int chan = m_tileHWID->channel(adc_id);
      int gain = (m_bigain) ? m_tileHWID->adc(adc_id) : 0; // ignore gain in monogain run
 
      m_data->m_histC[ros][drawer][chan][gain][0]->Fill(m_nEventsTileMon % 32, 1.0);
      
      std::vector<float> vdigits = tileDigits->samples();
      
      double meansamp = 0.0;
      double rmssamp = 0.0;
      unsigned int dsize = vdigits.size();
      if (dsize > 16) {
        ATH_MSG_ERROR("length of digits vector " << dsize << " - greater than 16 !");
        dsize = 16;
      }
      //std::cout << "m_runType= "<< m_runType << "\n";
      for (unsigned int i = 0; i < dsize; ++i) {
        double dig = vdigits[i];
        meansamp += dig;
        rmssamp += dig * dig;
        mean_tmp[chan][gain][i] = dig;
        
        if (!m_data->m_corrup[ros][drawer][gain][chan / 3]) {
          if (m_runType != CisRun) {
            m_data->m_histP[ros][drawer][chan][gain][0]->Fill(i + 0.1, dig, 1.0);
            m_data->m_hist1[ros][drawer][chan][gain][2]->Fill(dig, 1.0);
          } else if (m_cispar[6] > 0. && (dig > 0 || gain < 1 || charge < 12.)) { //LF If CIS run, Protection to avoid zero amplitudes due to 0 injected charge
            m_data->m_histP[ros][drawer][chan][gain][0]->Fill(i + 0.1, dig, 1.0);
            m_data->m_hist1[ros][drawer][chan][gain][2]->Fill(dig, 1.0);
          }
          
          if (gain == 1 && dig > m_ADCmaxMinusEps) // overflow in high gain, find charge is it
            m_data->m_outInHighGain[0]->Fill(charge);
        }
      }
 
      if (dsize > 0 && !m_data->m_corrup[ros][drawer][gain][chan / 3]) {
        double ped = vdigits[0];
        m_data->m_hist1[ros][drawer][chan][gain][0]->Fill(ped, 1.0);
        m_data->m_sumPed1[ros][drawer][chan][gain] += ped;
        m_data->m_sumPed2[ros][drawer][chan][gain] += ped * ped;
        //if ( (chan==23)&&(ros==1)&&(drawer==18)&&(gain==0)) {
        //std::cout << "ped=" << ped << "\tm_sumPed1=" << m_data->m_sumPed1[ros][drawer][chan][gain] << "\n";
        //std::cout << "ped^2=" << ped*ped << "\tm_sumPed2=" << m_data->m_sumPed2[ros][drawer][chan][gain] << "\n";
        //}
        if (dsize > 1) {
          meansamp /= dsize;
          rmssamp = rmssamp / dsize - meansamp * meansamp;
          rmssamp = (rmssamp > 0.0) ? sqrt(rmssamp * dsize / (dsize - 1)) : 0.0;
          m_data->m_hist1[ros][drawer][chan][gain][1]->Fill(rmssamp, 1.0);
          m_data->m_sumRms1[ros][drawer][chan][gain] += rmssamp;
          m_data->m_sumRms2[ros][drawer][chan][gain] += rmssamp * rmssamp;
        }
      }
    } // digits
    
      //For cor&cov
    for (int sample = 0; sample < m_nSamples; ++sample) {
      for (int gain = 0; gain < 2; ++gain) {
        for (int ch_i = 0; ch_i < 48; ++ch_i)
      if (!m_data->m_corrup[ros][drawer][gain][ch_i / 3]) {
        m_data->m_nEvents_i[ros][drawer][gain][ch_i]++;
        m_data->m_meanAmp[ros][drawer][gain][ch_i] += mean_tmp[ch_i][gain][sample];
        for (int ch_j = 0; ch_j < 48; ++ch_j)
          if (!m_data->m_corrup[ros][drawer][gain][ch_j / 3]) {
        m_data->m_nEvents_ij[ros][drawer][gain][ch_i][ch_j]++;
        m_data->m_meanAmp_ij[ros][drawer][gain][ch_i][ch_j] += mean_tmp[ch_i][gain][sample] * mean_tmp[ch_j][gain][sample];
          }
      }
      }
    }
    
    // BCID
    uint32_t bcid = digitsCollection->getRODBCID();
    
    for (int ch = 0; ch < headsize; ++ch) {
      uint32_t bcid_ch = (headerVec[ch] & 0xFFF);
      m_data->m_hist1[ros][drawer][ch][0][3]->Fill(bcid_ch, 1.0);
      if ((bcid_ch == bcid) || (bcid_ch == bcid - 1))   // Conservative condition to be consistent with both run before Feb07 and
        m_data->m_hist_DMUerr[ros][drawer][ch][0][0]->Fill(1.0, 1.0);      // runs after Feb07. Introducing a RunNum variable it could be more strict.
      else if ((bcid == 0) && ((bcid_ch == 3563) || (bcid_ch == 3564))) // if bcid==0 then bcid_ch should be 3563 (0xDEB)
        m_data->m_hist_DMUerr[ros][drawer][ch][0][0]->Fill(1.0, 1.0);          // but sometimes 3564 (0xDEC) is observed.
      //        if (bcid_ch == bcid)                // Now allow only exact bcid: ROD BCID = DMU BCID+1
      //          m_data->m_hist_DMUerr[ros][drawer][ch][0][0]->Fill(1.0,1.0);      //  Apr 2013
      //        else if (bcid_ch == 0)
      //          m_data->m_hist_DMUerr[ros][drawer][ch][0][0]->Fill(0.0,1.0);
      //        else 
      //          m_data->m_hist_DMUerr[ros][drawer][ch][0][0]->Fill(2.0,1.0);
    }
    
    //DMUheaderCheck(&headerVec,headsize,ros,drawer,0); 
    
    if ((m_bigain) && ((digitsCollection->getFragChipHeaderWordsHigh()).size() > 0)) {// LF we need to avoid that headsize is set to zero in monogain runs
      
      headerVec = digitsCollection->getFragChipHeaderWordsHigh();
      headsize = headerVec.size();
      if (headsize > 16) {
        ATH_MSG_ERROR("length of BCIDhigh vector " << headsize << " - greater than 16 !");
        headsize = 16;
      }
    }
    // if monogain run with m_bigain==1, we fill the BCID plots we the same info
    for (int ch = 0; ch < headsize; ++ch) {
      uint32_t bcid_ch = (headerVec[ch] & 0xFFF);
      m_data->m_hist1[ros][drawer][ch][1][3]->Fill(bcid_ch, 1.0);
      if ((bcid_ch == bcid) || (bcid_ch == bcid - 1))       // BCID from TileDMU should match BCID from ROD header or
        m_data->m_hist_DMUerr[ros][drawer][ch][1][0]->Fill(1.0, 1.0);              // bcid-1 for runs after Feb07.
      else if ((bcid == 0) && ((bcid_ch == 3563) || (bcid_ch == 3564))) // if bcid==0 then bcid_ch should be 3563 (0xDEB)
        m_data->m_hist_DMUerr[ros][drawer][ch][1][0]->Fill(1.0, 1.0);          // but sometimes 3564 (0xDEC) is observed.
      //        if (bcid_ch == bcid)                // Now allow only exact bcid
      //          m_data->m_hist_DMUerr[ros][drawer][ch][0][0]->Fill(1.0,1.0);      //  Apr 2013
      //      else if (bcid_ch == 0)
      //        m_data->m_hist_DMUerr[ros][drawer][ch][1][0]->Fill(0.0,1.0);
      //      else
      //        m_data->m_hist_DMUerr[ros][drawer][ch][1][0]->Fill(2.0,1.0);
    }
    
    //DMUheaderCheck(&headerVec,headsize,ros,drawer,1);
    
    if (dqStatus->calibMode() == 1) {
      // global and DMU CRC check
      uint32_t crc32 = digitsCollection->getFragCRC();
      uint32_t CRCmask = digitsCollection->getFragDMUMask();
      
      CRCcheck(dqStatus, crc32, CRCmask, headsize, ros, drawer);
    }
  } //loop over drawers
  // 
 
  if (dqStatus->calibMode() == 0) {
    if (RODCRCcalc(dqStatus).isFailure()) ATH_MSG_WARNING("Not possible to check CRC from ROD");
  }
  
  return StatusCode::SUCCESS;
}

finalHists()

StatusCode TileDigitsMonTool::finalHists ( )

overridevirtual

Calls procHists( true, true, true ).

LF: when we have a monogain run, like Laser, it might happen that occasionally some entries have not the expected gain. In this case we cannot use m_nEventsTileMon to calculate average and RMS. The most simple minded solution would be to use the a counter for each single chan (5x64x48x2 counters!). I prefered the following 'escamotage': the pedestal histograms already have the correct number of entries and, unless there are some overflow, even the correct mean and RMS. So, if m_nEntries doesn't match the entries in the histo, I use the latter for calculation porpouse. I could even use the histogram mean and RMS, but it is not necessary and I avoid problems in case of overflows.

Reimplemented from ManagedMonitorToolBase.

Definition at line 592 of file TileDigitsMonTool.cxx.

{
 
  ATH_MSG_INFO("in finalHists()");
  if (m_allHistsFilled) return StatusCode::SUCCESS;
  m_allHistsFilled = true;
 
  const EventContext &ctx = Gaudi::Hive::currentContext();
 
  const char *part[5] = { "AUX", "LBA", "LBC", "EBA", "EBC" };
  const char *gain[6] = { "_lo", "_hi", "", " low gain", " high gain", "" };
 
  std::string pedestalTitile(" Pedestal[0]");
  if (m_fillPedestalDifference) pedestalTitile += " - pedestal from DB";
 
  const char *HistName[8] = { "_ped", "_rms_lfr", "_rms_hfr", "_bits"
                              , pedestalTitile.c_str(), " RMS noise low frequency", " RMS noise high frequency", " Stuck bits and zero amp" };
 
  const char *ErrName[4] = { "_bcid", "_crc", " BCID errors", " CRC errors" };
  const char *HistName2[4] = { "_covar", "_corr", " covariance", " correlation" };
 
  // for bigain run book 2 histograms per channel
  // for monogain run book just one histogram per channel
  int mingain = (m_bigain) ? 0 : 2;
  int maxgain = (m_bigain) ? 2 : 3;
 
  for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
    for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER ; ++drawer) {
      if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
        unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
 
        std::ostringstream sStr;
        std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
        std::string subDir = "Summary";
        std::string histName, histTitle;
 
        for (int gn = mingain; gn < maxgain; ++gn) {
 
          int adc = gn & 1;
 
          for (int type = 0; type < 4; ++type) {
            sStr.str("");
            sStr << moduleName << gain[gn] << HistName[type];
            histName = sStr.str();
            sStr.str("");
            sStr << moduleName << gain[3 + gn] << HistName[4 + type];
            histTitle = sStr.str();
             m_data->m_final_hist1[ros][drawer][adc].push_back(book1F(subDir, histName, histTitle, 48, 0.0, 48.0));
          }
 
          // stuck bits and saturations / 0s
          sStr.str("");
          sStr << moduleName << gain[gn] << "_stucks";
          histName = sStr.str();
          sStr.str("");
          sStr << moduleName << gain[3 + gn] << " Stuck bits and saturation";
          histTitle = sStr.str();
          m_data->m_final_hist_stucks[ros][drawer][adc] = book2C(subDir, histName, histTitle, 48, 0.0, 48.0, 7, 0., 7.);
          m_data->m_final_hist_stucks[ros][drawer][adc]->GetYaxis()->SetBinLabel(1, "SB 0");
          m_data->m_final_hist_stucks[ros][drawer][adc]->GetYaxis()->SetBinLabel(2, "SB 1,2");
          m_data->m_final_hist_stucks[ros][drawer][adc]->GetYaxis()->SetBinLabel(3, "SB 3,4");
          m_data->m_final_hist_stucks[ros][drawer][adc]->GetYaxis()->SetBinLabel(4, "SB 5-9");
          m_data->m_final_hist_stucks[ros][drawer][adc]->GetYaxis()->SetBinLabel(5, "zeros");
          m_data->m_final_hist_stucks[ros][drawer][adc]->GetYaxis()->SetBinLabel(6, "saturation");
          m_data->m_final_hist_stucks[ros][drawer][adc]->GetYaxis()->SetBinLabel(7, "n % 32");
 
          for (unsigned int channel = 0; channel < TileCalibUtils::MAX_CHAN; ++channel) {
 
            //            int pmt = abs(m_cabling->channel2hole(ros,channel));
 
            double Ped = 0.0, PedRMS = 0.0, RMSHi = 0.0;
 
            int nevents = int(m_data->m_hist1[ros][drawer][channel][adc][0]->GetEntries()); //ROOT GetEntries return a Double_t.
            bool fillPedAndRms = (nevents > 0);
 
            if ((nevents != 0) && (nevents != m_nEventsTileMon)) {
              ATH_MSG_VERBOSE( "Number of entries in histo " << m_data->m_hist1[ros][drawer][channel][adc][0]->GetTitle()
                              << " doesnt match n. of events! Using the first one in mean and RMS calculation" );
 
              ATH_MSG_VERBOSE( "Number of entries in histo =" << nevents << "\tNumber of events= " << m_nEventsTileMon );
 
            } else {          //all ok
              nevents = m_nEventsTileMon;
            }
 
            if (fillPedAndRms) {
 
              if (nevents > 0) {
                Ped = m_data->m_sumPed1[ros][drawer][channel][adc] / nevents;
                RMSHi = m_data->m_sumRms1[ros][drawer][channel][adc] / nevents;
                
                if (nevents > 1) {
                  PedRMS = m_data->m_sumPed2[ros][drawer][channel][adc] / nevents - Ped * Ped;
                  PedRMS = (PedRMS > 0.0) ? sqrt(PedRMS * nevents / (nevents - 1)) : 0.0;
                }
              }
              
              //        if ( (pmt==24)&&(ros==1)&&(drawer==18)&&(adc==0)) {
              //std::cout << "Evt = " << m_nEventsTileMon << "\t channel=" << channel << "  pmt=" << pmt << "\n";
              //std::cout << "Ped = " << Ped << "\n";
              //std::cout << "E(x^2) = " << m_data->m_sumPed2[ros][drawer][channel][adc] << "\n";
              //std::cout << "PedRMS = " << PedRMS << "\n";
              
              //}
              
              if (m_fillPedestalDifference) {
 
                if (!isDisconnected(ros, drawer, channel)) {
                  m_data->m_final_hist1[ros][drawer][adc][0]->SetBinContent(channel + 1, Ped - m_tileToolNoiseSample->getPed(drawerIdx, channel, adc, TileRawChannelUnit::ADCcounts, ctx));
                  m_data->m_final_hist1[ros][drawer][adc][0]->SetBinError(channel + 1, PedRMS);
                }
 
              } else {
                m_data->m_final_hist1[ros][drawer][adc][0]->SetBinContent(channel + 1, Ped);
                m_data->m_final_hist1[ros][drawer][adc][0]->SetBinError(channel + 1, PedRMS);
              }
              
              m_data->m_final_hist1[ros][drawer][adc][1]->SetBinContent(channel + 1, PedRMS);
              m_data->m_final_hist1[ros][drawer][adc][2]->SetBinContent(channel + 1, RMSHi);
              
            }
 
            // For tests
            //stuckBits_maker(m_data->m_hist1[ros][drawer][channel][adc][2]);
 
            TH1S * hist = m_data->m_hist1[ros][drawer][channel][adc][2];
            double weight = 0.0;
            for (int i = 2; i < m_i_ADCmax + 2; ++i) { // first bin is excluded
              weight += hist->GetBinContent(i);
            }
            // if we have weight=0 after the loop, then there is no non-zero amplitudes
            if (weight > 0.0) {
              if (hist->GetBinContent(1) > 0) {
                weight = 0.5; // sometimes zeros
              } else {
                weight = 1.0; // assume that all OK
              }
 
              int stuck_bit = stuckBits(hist, adc);
              if (stuck_bit > 0) {
                weight += 1.0; // some stuck bits
              }
            }
            m_data->m_final_hist1[ros][drawer][adc][3]->SetBinContent(channel + 1, weight);
            stuckBits_Amp2(hist, m_data->m_histC[ros][drawer][channel][adc][0], adc,
                           m_data->m_final_hist_stucks[ros][drawer][adc], channel,
                           m_data->m_stuck_probs[ros][drawer][channel][adc]);
          } // end of loop over channels
 
          // BCID
          sStr.str("");
          sStr << moduleName << gain[gn] << ErrName[0];
          histName = sStr.str();
          sStr.str("");
          sStr << moduleName << gain[3 + gn] << ErrName[2];
          histTitle = sStr.str();
          m_data->m_final_hist1[ros][drawer][adc].push_back(book1F(subDir, histName, histTitle, 16, 0.0, 16.0));
 
          // CRC only for one gain
          if (adc == 0) {
            sStr.str("");
            sStr << moduleName << ErrName[1];
            histName = sStr.str();
            sStr.str("");
            sStr << moduleName << ErrName[3];
            histTitle = sStr.str();
            m_data->m_final_hist1[ros][drawer][adc].push_back(book1F(subDir, histName, histTitle, 16, 0.0, 16.0));
          }
 
          for (int ch = 0; ch < 16; ++ch) {
 
            int dmu = ch + 1;
 
            // BCID and CRC errors
            for (int id = 0; id < 2; ++id) {
              int bin0 = lround(m_data->m_hist_DMUerr[ros][drawer][ch][adc][id]->GetBinContent(0));
              int bin1 = lround(m_data->m_hist_DMUerr[ros][drawer][ch][adc][id]->GetBinContent(1));
              int bin2 = lround(m_data->m_hist_DMUerr[ros][drawer][ch][adc][id]->GetBinContent(2));
              int bin3 = lround(m_data->m_hist_DMUerr[ros][drawer][ch][adc][id]->GetBinContent(3));
              int bin4 = lround(m_data->m_hist_DMUerr[ros][drawer][ch][adc][id]->GetBinContent(4));
              int bin5 = lround(m_data->m_hist_DMUerr[ros][drawer][ch][adc][id]->GetBinContent(5));
              double weight = -1.0;
 
              if (bin0 + bin3 + bin4 + bin5 > 0) {
                if ((bin4 == 0) && (bin5 == 0)) {
                  weight = 2.0; // BCID: all other errors; CRC: FE only errors
                } else if ((bin3 == 0) && (bin5 == 0)) {
                  weight = 3.0; // CRC only: ROD only errors
                } else { // if there are ROD and FE errors (not necessary at the same time),
                         //weight is 2.5
                  weight = 2.5; // CRC only: ROD and FE errors
                }
              } else {
                if (bin2 == 0) {
                  weight = 0.0; // all zeros
                } else if (bin1 == 0) {
                  weight = 1.0; // all OK
                } else {
                  weight = 1.0 - (double) bin1 / m_nEventsTileMon; // percentage of good events
                  if (weight > 0.8) weight = 0.8; // to see clearly even one event with zeros
                }
              }
              m_data->m_final_hist1[ros][drawer][adc][id + 4]->SetBinContent(dmu, weight);
 
              if (adc) break; // no CRC histogram in high gain
            }
          } // end of loop over 16 DMU
 
          //Correlation and Covariance
          if (m_runType == PedRun) {
 
            for (int type = 0; type < 2; ++type) {
              sStr.str("");
              sStr << moduleName << gain[gn] << HistName2[type];
              histName = sStr.str();
              sStr.str("");
              sStr << moduleName << gain[3 + gn] << HistName2[2 + type];
              histTitle = sStr.str();
              m_data->m_final_hist2[ros][drawer][adc].push_back(book2F(subDir, histName, histTitle, 48, 0.0, 48.0, 48, 0.0, 48.0));
            }
 
            if (m_nEventsTileMon * m_nSamples > 0) {
 
              for (int ch_i = 0; ch_i < 48; ++ch_i) {
        if (m_data->m_nEvents_i[ros][drawer][adc][ch_i] > 0)
          m_data->m_meanAmp[ros][drawer][adc][ch_i] /= m_data->m_nEvents_i[ros][drawer][adc][ch_i];
                for (int ch_j = 0; ch_j < 48; ++ch_j)
          if (m_data->m_nEvents_ij[ros][drawer][adc][ch_i][ch_j] > 0)
            m_data->m_meanAmp_ij[ros][drawer][adc][ch_i][ch_j] /= m_data->m_nEvents_ij[ros][drawer][adc][ch_i][ch_j];
              }
 
              //coverity[STACK_USE]
              double covar[48][48];
              //coverity[STACK_USE]
              double corr[48][48];
              double mean_rms[48];
              double mean_cov_ii = 0.; // mean values of covar in diag terms
              double mean_cov_ij = 0.;  // mean values of covar in off diag terms
 
              for (int ch_i = 0; ch_i < 48; ++ch_i) {
                //                int pmt_i = abs(m_cabling->channel2hole(ros,ch_i))-1;
                for (int ch_j = 0; ch_j < 48; ++ch_j) {
                  //                  int pmt_j = abs(m_cabling->channel2hole(ros,ch_j))-1;
                  covar[ch_i][ch_j] = m_data->m_meanAmp_ij[ros][drawer][adc][ch_i][ch_j] - m_data->m_meanAmp[ros][drawer][adc][ch_i] * m_data->m_meanAmp[ros][drawer][adc][ch_j];
 
                  if (ch_j < ch_i) {
                    mean_cov_ij += covar[ch_i][ch_j]; //LF: we take C_ij with its sign
                  }
                }
 
                mean_cov_ii += covar[ch_i][ch_i];
 
                if (covar[ch_i][ch_i] != 0.0)
                  mean_rms[ch_i] = covar[ch_i][ch_i] / sqrt(TMath::Abs(covar[ch_i][ch_i]));
                else
                  mean_rms[ch_i] = 0.;
              }
 
              if (mean_cov_ii != 0.) {
                m_data->m_cov_ratio[ros][drawer][adc] = (2. * mean_cov_ij) / (mean_cov_ii * 47.); //(2*cov_ij/(48*47))/(cov_ii/48)
              } else {
                m_data->m_cov_ratio[ros][drawer][adc] = 0.;
              }
              //          std::cout << "m_cov_ratio["<<adc<<"]= " <<  m_data->m_cov_ratio[ros][drawer][adc] << "\n";
 
              for (int i = 0; i < 48; ++i) {
                for (int j = 0; j < 48; ++j) {
                  if ((mean_rms[i] == 0.) || (mean_rms[j] == 0.)) {
                    corr[i][j] = 0.;
                  } else {
                    corr[i][j] = covar[i][j] / mean_rms[i] / mean_rms[j];
                  }
                  m_data->m_final_hist2[ros][drawer][adc][0]->SetBinContent(i + 1, j + 1, covar[i][j]);
                  m_data->m_final_hist2[ros][drawer][adc][1]->SetBinContent(i + 1, j + 1, corr[i][j]);
                }
              }
            } // end if m_nEventsTileMon > 0
 
          } // end if PedRun
        } // end of loop over gn
 
        drawHists(ros, drawer, moduleName);
 
        //if RunType is Cis, the Kolmogorov test of the sample distribution is performed
        if (m_runType == CisRun) {
 
          for (int gn = mingain; gn < maxgain; ++gn) {
            for (int i = 0; i < 48; ++i) {
              TH1S *h = (TH1S*) m_data->m_hist1[ros][drawer][i][gn][2]->Clone("temphist");
              h->SetDirectory(0);
              shiftHisto(h, ros, drawer, i, gn);
              delete h;
            }
            double shiftxmin = 0.;
            double shiftxmax = m_shiftnbins;
            int shiftnbins = m_shiftnbins;
 
            std::ostringstream s;
            s << part[ros] << std::setfill('0') << std::setw(2) << drawer + 1 << std::setfill(' ');
            std::string moduleName = s.str();
            std::string subDir = moduleName;
 
            s.str("");
            s << moduleName << gain[gn] << "_samples_ref";
            std::string histName = s.str();
 
            s.str("");
            s << moduleName << gain[3 + gn] << " all samples reference";
            std::string histTitle = s.str();
 
            m_data->m_shifted_hist[ros][drawer][48][gn] = book1S(subDir, histName, histTitle, shiftnbins, shiftxmin, shiftxmax);
 
            statTestHistos(ros, drawer, gn);
          } // if runTYpe==CisRun
        }
      }
 
    } //loop over drawer
  } //loop over ros
 
 
  return StatusCode::SUCCESS;
}

get_nEvents()

unsigned int ManagedMonitorToolBase::get_nEvents ( ) const

inlineprotectedinherited

Definition at line 692 of file ManagedMonitorToolBase.h.

                                              {
          return m_nEvents; 
      }

get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const

inlineprotectedinherited

Definition at line 696 of file ManagedMonitorToolBase.h.

                                              {
          return m_procNEventsProp;
      }

getCellName()

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

inlineprotectedinherited

Definition at line 221 of file TilePaterMonTool.h.

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

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.

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

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.

{
   MonGroup group( this, system, interval );
   return getHist( h, hName, group );
}

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.

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

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.

{
   MonGroup group( this, system, interval );
   return getHist( h, hName, group );
}

getNewStreamNameFcn()

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

protectedvirtualinherited

Definition at line 2155 of file ManagedMonitorToolBase.cxx.

{
   StreamNameFcn* fcn(0);
 
   switch( m_environment ) {
      case AthenaMonManager::noOutput:
         fcn = new NoOutputStream();
         break;
      case AthenaMonManager::online:
         fcn = new OnlineStream();
         break;
      case AthenaMonManager::user:
         fcn = new DefaultStream( m_fileKey );
         break;
      case AthenaMonManager::tier0:
      case AthenaMonManager::tier0Raw:
      case AthenaMonManager::tier0ESD:
      case AthenaMonManager::AOD:
      case AthenaMonManager::altprod:
      default:
         fcn = new OfflineStream( m_fileKey, m_dataType, m_environment );
   }
 
   return fcn;
}

getTMDBCellName()

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

inlineprotectedinherited

Definition at line 230 of file TilePaterMonTool.h.

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

initialize()

StatusCode TileDigitsMonTool::initialize ( )

overridevirtual

Reimplemented from TilePaterMonTool.

Definition at line 92 of file TileDigitsMonTool.cxx.

{
  ATH_MSG_INFO("in initialize()");
 
  if (m_fillPedestalDifference) CHECK(m_tileToolNoiseSample.retrieve());
 
  m_nEventsTileMon = 0;
  m_allHistsFilled = false;
  m_data = std::make_unique<Data>();
  memset(m_data->m_sumPed1, 0, sizeof(m_data->m_sumPed1));
  memset(m_data->m_sumPed2, 0, sizeof(m_data->m_sumPed2));
  memset(m_data->m_sumRms1, 0, sizeof(m_data->m_sumRms1));
  memset(m_data->m_sumRms2, 0, sizeof(m_data->m_sumRms2));
  memset(m_data->m_meanAmp, 0, sizeof(m_data->m_meanAmp));
  memset(m_data->m_meanAmp_ij, 0, sizeof(m_data->m_meanAmp_ij));
  memset(m_data->m_nEvents_i, 0, sizeof(m_data->m_nEvents_i));
  memset(m_data->m_nEvents_ij, 0, sizeof(m_data->m_nEvents_ij));
  memset(m_data->m_stuck_probs, 0, sizeof(m_data->m_stuck_probs));
 
  //For test stuck_bits_maker
  //hp = 1;
  //hb = -1;
 
  // TileInfo
  CHECK( detStore()->retrieve(m_tileInfo, m_infoName) );
  m_i_ADCmax = m_tileInfo->ADCmax();
  m_f_ADCmax = m_i_ADCmax;
  m_ADCmaxMinusEps = m_i_ADCmax - 0.01;
 
  m_shiftnbins = 796;
  if (m_i_ADCmax == 4095){
    m_is12bit = true;
    m_shiftnbins = m_shiftnbins * 4;
  }
 
  CHECK( m_DQstatusKey.initialize() );
 
  return TilePaterMonTool::initialize();
}

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() [1/2]

const InterfaceID & IMonitorToolBase::interfaceID ( )

inlinestaticinherited

Definition at line 29 of file IMonitorToolBase.h.

{ return IID_IMonitorToolBase; }

interfaceID() [2/2]

const InterfaceID & ITileStuckBitsProbsTool::interfaceID ( )

inlinestaticinherited

Definition at line 18 of file ITileStuckBitsProbsTool.h.

                                          {
    static const InterfaceID IID_ITileStuckBitsProbsTool("ITileStuckBitsProbsTool", 1, 0);
    return IID_ITileStuckBitsProbsTool;
  }

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.

{
   std::string str("file");
 
   switch( interval ) {
      case all:
         str = "all";
         break;
      case fill:
         str = "fill";
         break;
      case run:
         str = "run";
         break;
      case lowStat:
         str = "lowStat";
         break;
      case medStat:
         str = "medStat";
         break;
      case higStat:
         str = "higStat";
         break;
      case lumiBlock:
         str = "lumiBlock";
         break;
      case eventsBlock:
         str = "eventsBlock";
         break;
      case file:
     str = "file";
     break;
      default:
         str = "unknown";
   }
 
   return str;
}

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.

{
   std::string lcstr( strToLower(str) );
 
   if( lcstr == "all" )
      return all;
   else if( lcstr == "fill" )
      return fill;
   else if( lcstr == "run" )
      return run;
   else if( lcstr == "lowStat" )
      return lowStat;
   else if( lcstr == "medStat" )
      return medStat;
   else if( lcstr == "higStat" )
      return higStat;
   else if( lcstr == "lumiBlock" )
      return lumiBlock;
   else if( lcstr == "eventsBlock" )
      return eventsBlock;
   else if( lcstr == "file" )
      return file;
 
   if( Imp::s_svcLocator ) {
      SmartIF<IMessageSvc> ms{Imp::s_svcLocator.load()->service( "MessageSvc" )};
      if( ms.isValid() ) {
         MsgStream log( ms, "ManagedMonitorToolBase::intervalStringToEnum()" );
         log << MSG::WARNING << "Unknown ManagedMonitorToolBase::Interval_t \""
            << str << "\", returning \"file\"" << endmsg;
      }
   }
 
   return file;
}

isDisconnected()

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

inlineprotectedinherited

Definition at line 256 of file TilePaterMonTool.h.

                                                          {
 
    if (ros < 3) { //LB, all standard. Channels 30,31,43 are disconnected
      return m_chMapLB[ch];
    } else {
      if (((ros == 3) && (drawer == 14)) || ((ros == 4) && (drawer == 17))) {//EB, EBA15 and EBC18 are special
        return m_chMapEBsp[ch];
      } else  {//EB standard module
        return m_chMapEB[ch];
      }
    } //end if LB else EB
 
  }

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.

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

lbAverageLivefraction()

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

virtualinherited

Average luminosity livefraction.

Definition at line 1760 of file ManagedMonitorToolBase.cxx.

{
    if (m_environment == AthenaMonManager::online)
        return 1.0;
 
    if (!m_trigLiveFractionDataKey.empty()) {
        SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
        return live->lbAverageLiveFraction();
    } else {
        //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLivefraction() can't work properly! ");
        ATH_MSG_DEBUG("Warning: lbAverageLivefraction() - luminosity not availble (i.e. EnableLumi = False)");
        return -1.0;
    }
    // not reached
}

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.

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

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.

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

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.

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

lbLuminosityPerBCID()

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

virtualinherited

Instantaneous luminosity.

Definition at line 1743 of file ManagedMonitorToolBase.cxx.

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

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.

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

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.

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

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.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

newEventsBlockFlag()

bool ManagedMonitorToolBase::newEventsBlockFlag ( ) const

inlineprotectedinherited

Definition at line 793 of file ManagedMonitorToolBase.h.

{ return m_newEventsBlock; }

newHigStatIntervalFlag()

bool ManagedMonitorToolBase::newHigStatIntervalFlag ( ) const

inlineprotectedinherited

Definition at line 789 of file ManagedMonitorToolBase.h.

{ return m_newHigStatInterval; }

newLowStatFlag()

bool ManagedMonitorToolBase::newLowStatFlag ( ) const

inlineprotectedinherited

Definition at line 790 of file ManagedMonitorToolBase.h.

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

{ return m_newLowStatInterval; }

newLumiBlockFlag()

bool ManagedMonitorToolBase::newLumiBlockFlag ( ) const

inlineprotectedinherited

Definition at line 791 of file ManagedMonitorToolBase.h.

{ return m_newLumiBlock; }

newMedStatIntervalFlag()

bool ManagedMonitorToolBase::newMedStatIntervalFlag ( ) const

inlineprotectedinherited

Definition at line 788 of file ManagedMonitorToolBase.h.

{ return m_newMedStatInterval; }

newRunFlag()

bool ManagedMonitorToolBase::newRunFlag ( ) const

inlineprotectedinherited

Definition at line 792 of file ManagedMonitorToolBase.h.

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

                                                               {
   std::string item;
   std::stringstream ss(line);
 
   if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "ManagedMonitorToolBase::parseList:";
 
   while ( std::getline(ss, item, ',') ) {
      std::stringstream iss(item); // remove 
      iss >> item;                 // whitespace 
      if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " " << item;
      result.push_back(item);
   }
 
   msg(MSG::DEBUG) << endmsg;
   return StatusCode::SUCCESS;
}

preSelector()

bool ManagedMonitorToolBase::preSelector ( )

virtualinherited

Implements IMonitorToolBase.

Definition at line 1679 of file ManagedMonitorToolBase.cxx.

{
   if( m_preScaleProp > 1 ) {
      return ( (m_nEvents % m_preScaleProp) == 1 );
   }
   return true;
}

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.

{
   if( m_endOfEventsBlock ) { }
   if( m_endOfLowStat ) { }
   if( m_endOfLumiBlock ) { }
   if( m_endOfRun) { }
 
   return StatusCode::SUCCESS;
}

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.

                                                                                        {
    if (!e)
        return StatusCode::FAILURE;
 
    TGraph* g = reinterpret_cast<TGraph*>(e);
    std::string name = e->GetName();
 
    // MANAGED
    if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
        // warn about not using merge algorithms
        if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
            ATH_MSG_WARNING("HEY! Attempting to register "<<name<<" as a per-LB histogram, but not setting the merge algorithm! Use \"merge\", at least.");
        }
        // add the efficiency to rebooking vector
        if (m_supportedIntervalsForRebooking.count(group.interval())) {
            m_templateEfficiencies[group.interval()].push_back( MgmtParams<TEfficiency>(e, group) );
        } else {
            ATH_MSG_ERROR("Attempt to book managed graph " << name << " with invalid interval type " << intervalEnumToString(group.interval()));
            return StatusCode::FAILURE;
        }
 
        MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
        std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
        registerMetadata(streamName, name, group).ignore();
        return m_THistSvc->regGraph( streamName, g );
    } else {
    // UNMANAGED
        if( m_manager != 0 ) {
            std::string genericName = NoOutputStream().getStreamName( this, group, name );
            m_manager->writeAndDelete( genericName );
            m_manager->passOwnership( e, genericName );
        }
 
        std::string streamName = streamNameFunction()->getStreamName( this, group, name, false );
        StatusCode smd = registerMetadata(streamName, name, group);
        if (smd != StatusCode::SUCCESS) 
            return StatusCode::FAILURE;
 
        return m_THistSvc->regGraph( streamName, g );
    }
}

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.

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

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.

{
   if (!g)
      return StatusCode::FAILURE;
 
   // This part of the code deals with MANAGED type
   if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
       // Create an unmanaged group based on the original MonGroup instance passed
       // This is needed because managed graph is presented as a number of unmanaged
       // graphs (one per each interval)
       MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
 
       if (m_supportedIntervalsForRebooking.count(group.interval())) {
           m_templateGraphs[group.interval()].push_back( MgmtParams<TGraph>(g, group_unmanaged) );
       } else {
           ATH_MSG_ERROR("Attempt to book managed graph " << g->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
           return StatusCode::FAILURE;
       }
 
       std::string name = g->GetName();
       std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
       registerMetadata(streamName, name, group).ignore();
       return m_THistSvc->regGraph( streamName, g );
       //return m_THistSvc->regGraph( streamName );
   } 
 
   // This part of the code deals with UNMANAGED type
   std::string gName = g->GetName();
 
   if( m_manager != 0 ) {
      std::string genericName = NoOutputStream().getStreamName( this, group, gName );
      m_manager->writeAndDelete( genericName );
      m_manager->passOwnership( g, genericName );
   }
 
   std::string streamName = streamNameFunction()->getStreamName( this, group, gName, false );
 
   StatusCode smd = registerMetadata(streamName, gName, group);
   if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
 
   return m_THistSvc->regGraph( streamName, g );
}

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.

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

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.

{
 
  std::string path(m_path);
  if (!subDir.empty()) path += ("/" + subDir);
 
  if(ManagedMonitorToolBase::regHist(hist, path, interval, attribute, trigChain, mergeAlgo).isFailure()) {
    ATH_MSG_WARNING( "Could not register histogram : "  << path + "/" + hist->GetName() );
  }
 
}

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.

{
//   ManagedMonitorToolBase_addHistStatistics(this,h);
 
  if (!h)
    return StatusCode::FAILURE;
  
  // This part of the code deals with MANAGED type
  if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
    /* 
       Create an unmanaged group based on the original MonGroup instance passed
       It is needed because managed histogram is presented as a number of unmanaged
       histograms (one per each interval)
       Update (PUEO) - I don't think it actually matters, and need to keep 
       track of "proper" attribute for X_VS_LB
    */
    
    if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
      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.");
    }
    
    if (m_supportedIntervalsForRebooking.count(group.interval())) {
      m_templateHistograms[group.interval()].push_back( MgmtParams<TH1>(h, group) );
    } else {
      ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
           return StatusCode::FAILURE;
    }
    
    std::string hName = h->GetName();
    MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
    std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, hName, false );
    registerMetadata(streamName, hName, group).ignore();
    return m_THistSvc->regHist( streamName, h );
  }
  
  // This part of the code deals with UNMANAGED type
  std::string hName = h->GetName();
  
  if( m_manager != 0 ) {
    std::string genericName = NoOutputStream().getStreamName( this, group, hName );
    m_manager->writeAndDelete( genericName );
    m_manager->passOwnership( h, genericName );
  }
  
  std::string streamName = streamNameFunction()->getStreamName( this, group, hName, false );
  
  StatusCode smd = registerMetadata(streamName, hName, group);
  if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
  
  return m_THistSvc->regHist( streamName, h );
}

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.

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

registerMetadata()

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

protectedinherited

Definition at line 945 of file ManagedMonitorToolBase.cxx.

                                {
  if( m_environment != AthenaMonManager::online ) {
    TTree* metadata(0);
    std::string mdStreamName( streamName );
    size_t found=mdStreamName.rfind('/');
    
    if ( found != std::string::npos )
      mdStreamName.replace( found, mdStreamName.length(), "/metadata" );
    
    MDMap_t::iterator i = m_metadataMap.find( mdStreamName );
    if( i == m_metadataMap.end() ) {
      metadata = new TTree( "metadata", "Monitoring Metadata" );
      if (! metadata) return StatusCode::FAILURE;
      StatusCode scmd = m_THistSvc->regTree( mdStreamName, metadata );
      if (scmd == StatusCode::FAILURE) return StatusCode::FAILURE;
      i = m_metadataMap.emplace( mdStreamName, new OutputMetadata(metadata) ).first;
    }
    
    i->second->fill( hName,  group.interval(), group.chain(), group.merge() );
  }
  return StatusCode::SUCCESS;
}

regManagedEfficiencies()

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

protectedinherited

Definition at line 1139 of file ManagedMonitorToolBase.cxx.

                                                                                                                    {
    bool allIsOk = true;
    for( auto& it : templateEfficiencies ) {
        // get components of MgmtParams and copy efficiency
        MonGroup group = it.m_group;
        TEfficiency* theEfficiency = it.m_templateHist;
        TEfficiency* e = static_cast<TEfficiency*>(theEfficiency->Clone());
        int nbins = theEfficiency->GetTotalHistogram()->GetNbinsX();
        int xlow = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmin();
        int xhigh = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmax();
        e->SetBins(nbins,xlow,xhigh); // reset histogram
        std::string name = e->GetName();
 
        // make TGraph casts of TEfficiencies
        TGraph* theGraph = reinterpret_cast<TGraph*>(theEfficiency);
        TGraph* g = reinterpret_cast<TGraph*>(e);
 
        // Get the streamName for the previous interval
        std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
 
        // RE-REGISTER 
        // 1) De-register the original graph with the THistSvc
        StatusCode sc1 = m_THistSvc->deReg( theGraph );
        if (sc1 == StatusCode::FAILURE) allIsOk = false;
        // 2) Fix THistSvc->deReg for TGraphs
        bool doneCleaning = false;
        std::string directoryName = streamNameFunction()->getDirectoryName( this, group, name, true );
        TSeqCollection *filelist=gROOT->GetListOfFiles();
        for (int i=0; i<filelist->GetEntries(); i++) {
            ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
            TFile* file = static_cast<TFile*>(filelist->At(i));
            StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
            if (sc2 == StatusCode::SUCCESS) doneCleaning = true;
        }
        // 3) Check if TGraph fix has been applied successfully
        if (!doneCleaning) { 
            ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
            allIsOk = false;
        }
        // 4) Register cloned histogram under previous interval streamName
        StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
        if (sc3 == StatusCode::FAILURE) 
            allIsOk = false;
 
        // get streamname for interval
        streamName = streamNameFunction()->getStreamName( this, group, name, false );
        // store metadata
        StatusCode smd = registerMetadata(streamName, name, group);
        if (smd != StatusCode::SUCCESS) allIsOk = false;
        // Re-register the original graph
        StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
        if (sc4 == StatusCode::FAILURE) allIsOk = false;
    }
 
    if (!allIsOk) return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
}

regManagedGraphs()

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

protectedinherited

Definition at line 1068 of file ManagedMonitorToolBase.cxx.

{
      // See the description for the regManagedHistograms method
      bool allIsOk = true;  
   
      for( std::vector< MgmtParams<TGraph> >::iterator it = templateGraphs.begin(); it != templateGraphs.end(); ++it ) {
          MonGroup group = (*it).m_group;
 
          // Get a handle to the graph
          TGraph* theGraph = (*it).m_templateHist;
 
          // Clone the graph
          TGraph* g = static_cast<TGraph*>(theGraph->Clone());
          theGraph->Set(0); // equivalent to Reset() for TH1
 
          // Get name
          std::string gName = g->GetName();
 
          // Get the streamName for the previous interval
          std::string streamName = streamNameFunction()->getStreamName( this, group, gName, true );
 
          // De-register the original graph with the THistSvc
          StatusCode sc1 = m_THistSvc->deReg( theGraph );
          if (sc1 == StatusCode::FAILURE)
              allIsOk = false;
 
          // *** begin ***
          // Fix THistSvc->deReg for TGraphs
          bool doneCleaning = false;
          std::string directoryName = streamNameFunction()->getDirectoryName( this, group, gName, true );
          TSeqCollection *filelist=gROOT->GetListOfFiles();
          for (int i=0; i<filelist->GetEntries(); i++) {
              ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
              TFile* file = static_cast<TFile*>(filelist->At(i));
              StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
              if (sc2 == StatusCode::SUCCESS)
                  doneCleaning = true;
          }
         
          // Check if TGraph fix has been applied successfully 
          if (!doneCleaning) { 
              ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
              allIsOk = false;
          }
          // *** end ***
 
          // Register clonned histogram under previous interval streamName
          StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
          if (sc3 == StatusCode::FAILURE) 
              allIsOk = false;
 
          // Get streamName for the current interval
          streamName = streamNameFunction()->getStreamName( this, group, gName, false );
          // Register metadata information with the current interval streamname
          StatusCode smd = registerMetadata(streamName, gName, group);
          if (smd != StatusCode::SUCCESS) 
              allIsOk = false;
 
          // Re-register the original graph with the current interval streamName
          StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
          if (sc4 == StatusCode::FAILURE) 
              allIsOk = false;
 
      }
 
      if (!allIsOk) return StatusCode::FAILURE;
      
      return StatusCode::SUCCESS;
}

regManagedHistograms()

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

protectedinherited

Definition at line 971 of file ManagedMonitorToolBase.cxx.

{
      // The method registers histograms with the THistSvc and saves them to file.
 
      // The funky business with registering and deregistering the histogram is needed
      // to get the correct directory when saving histograms. THistSvc deals with ROOT 
      // to set up proper TDirectory, so we rely on it.
      // E.g. 
      //     m_THistSvc->regHist( streamName, h ): sets the correct TDirectory with streamName
      //     m_THistSvc->deReg( h ) - deregister from THistSvc otherwise THistSvc will try to save it
      //                          at the end of execution
      //  use passownership of the histogram and save it to file 
      //     m_manager->passOwnership( h, genericName );
      //     m_manager->writeAndDelete( genericName );
      bool allIsOk = true;  
   
      for( std::vector< MgmtParams<TH1> >::iterator it = templateHistograms.begin(); it != templateHistograms.end(); ++it ) {
          MonGroup& group = (*it).m_group;
 
          // Get a handle to the histogram
          TH1* theHist = (*it).m_templateHist;
 
          // Clone the histogram
          TH1* h = static_cast<TH1*>(theHist->Clone());
          theHist->Reset();
 
          // Get name
          std::string hName = h->GetName();
 
          // Get the streamName for the previous interval
          std::string streamName = streamNameFunction()->getStreamName( this, group, hName, true );
 
          // Register the histogram with the THistSvc
          StatusCode sc1 = m_THistSvc->deReg( theHist );
          if (sc1 == StatusCode::FAILURE) allIsOk = false;
 
          // Register clonned histogram under previous interval streamName
          StatusCode sc2 = m_THistSvc->regHist( streamName, h );
          if (sc2 == StatusCode::FAILURE) allIsOk = false;
 
          if( m_manager != 0 ) {
             std::string genericName = NoOutputStream().getStreamName( this, group, hName );
             m_manager->passOwnership( h, genericName );
             m_manager->writeAndDelete( genericName );
          }
        
          // Get streamName for the current interval 
          streamName = streamNameFunction()->getStreamName( this, group, hName, false );
          // Register metadata information with the current interval streamname
          StatusCode smd = registerMetadata(streamName, hName, group);
          if (smd != StatusCode::SUCCESS) allIsOk = false;
 
          // Re-register the original histogram with the current interval streamName
          StatusCode sc3 = m_THistSvc->regHist( streamName, theHist );
          if (sc3 == StatusCode::FAILURE) allIsOk = false;
 
      }
 
      if (!allIsOk) return StatusCode::FAILURE;
      
      return StatusCode::SUCCESS;
}

regManagedTrees()

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

protectedinherited

Definition at line 1199 of file ManagedMonitorToolBase.cxx.

{
      // See the description for the regManagedHistograms method
      bool allIsOk = true;  
   
      for( std::vector< MgmtParams<TTree> >::iterator it = templateTrees.begin(); it != templateTrees.end(); ++it ) {
          MonGroup group = (*it).m_group;
 
          // Get a handle to the original tree
          TTree* theTree = (*it).m_templateHist;
 
          // Clone the tree
          TTree* t = static_cast<TTree*>(theTree->Clone());
          theTree->Reset();
 
          // Dumping the tree
          std::string name = t->GetName();
 
          // Get the streamName for the previous interval
          std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
 
          // De-register original tree with the THistSvc
          StatusCode sc1 = m_THistSvc->deReg( theTree );
          if (sc1 == StatusCode::FAILURE) allIsOk = false;
 
          // Register clonned tree under previous interval streamName
          StatusCode sc2 = m_THistSvc->regTree( streamName, t );
          if (sc2 == StatusCode::FAILURE) allIsOk = false;
 
          if( m_manager != 0 ) {
             std::string genericName = NoOutputStream().getStreamName( this, group, name );
             m_manager->passOwnership( t, genericName );
             m_manager->writeAndDelete( genericName );
          }
 
          // Get streamName for the current interval
          streamName = streamNameFunction()->getStreamName( this, group, name, false );
          // Register metadata information with the current interval streamname
          StatusCode smd = registerMetadata(streamName, name, group);
          if (smd != StatusCode::SUCCESS) allIsOk = false;
 
          // Re-register the original graph with the current interval streamName
          StatusCode sc3 = m_THistSvc->regTree( streamName, theTree );
          if (sc3 == StatusCode::FAILURE) allIsOk = false;
 
      }
 
      if (!allIsOk) return StatusCode::FAILURE;
      
      return StatusCode::SUCCESS;
}

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.

{
 
   // This part of the code deals with MANAGED type
   if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
       // Create an unmanaged group based on the original MonGroup instance passed
       // This is needed because managed tree is presented as a number of unmanaged
       // trees (one per each interval)
       MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
 
       if (m_supportedIntervalsForRebooking.count(group.interval())) {
           m_templateTrees[group.interval()].push_back( MgmtParams<TTree>(t, group_unmanaged) );
       } else {
           ATH_MSG_ERROR("Attempt to book managed tree " << t->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
           return StatusCode::FAILURE;
       }
 
       std::string name = t->GetName();
       std::string genericName = NoOutputStream().getStreamName( this, group_unmanaged, name );
       std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
       registerMetadata(streamName, name, group).ignore();
       return m_THistSvc->regTree( streamName, t );
   }
 
 
   // This part of the code deals with UNMANAGED type
   std::string tName = t->GetName();
 
   if( m_manager != 0 ) {
      std::string genericName = NoOutputStream().getStreamName( this, group, tName );
      m_manager->writeAndDelete( genericName );
      m_manager->passOwnership( t, genericName );
   }
 
   std::string streamName = streamNameFunction()->getStreamName( this, group, tName, false );
 
   StatusCode smd = registerMetadata(streamName, tName, group);
   if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
 
   return m_THistSvc->regTree( streamName, t );
}

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.

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

removeTObj()

StatusCode TilePaterMonTool::removeTObj ( TObject * obj )

protectedinherited

Definition at line 416 of file TilePaterMonTool.cxx.

                                                    {
  if (obj != 0) {
    if (obj->IsA()->InheritsFrom("TH1")) {
      if (deregHist(static_cast<TH1*> (obj)).isFailure()) {
        ATH_MSG_WARNING( "Could not dereg Histogram : " << obj->GetName() );
        return StatusCode::FAILURE;
      } else {
        delete obj;
      }
    } else if (obj->IsA()->InheritsFrom("TGraph")) {
      if (deregGraph(static_cast<TGraph*> (obj)) != StatusCode::SUCCESS) {
        ATH_MSG_WARNING( "Could not dereg Graph : " << obj->GetName() );
        return StatusCode::FAILURE;
      } else {
        delete obj;
      }
    } else {
      ATH_MSG_WARNING( "Asked to remove object " << obj->GetName() << "of unsupported type " << obj->IsA() );
      return StatusCode::FAILURE;
    }
  } else {
    ATH_MSG_WARNING( "Asked to remove NULL pointer" );
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

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.

  {
    h.renounce();
    PBASE::renounce (h);
  }

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.

                                                          {
    handlesArray.renounce();
  }

RODCRCcalc()

StatusCode TileDigitsMonTool::RODCRCcalc ( const TileDQstatus * dqStatus )

private

Author: Luca. F. Mar 08 This method provides CRC checks for Global and TileDMU chips. They are taken from the the ROD RawChannel Container TileDMU CRC is taken from the DMU mask filled in the FPGA. It makes sense only for monogain runs (Physics, LED, MonoCIS). The least significant 16 bits are the result of the CRC check in the FE (0xFFFF means all OK). The most significant 16 bits are the result of the CRC check in the ROD (0xFFFF means all OK). Global CRC is taken also from the DQ Fragment. '0' means OK, '1' means mismatch.

Definition at line 1782 of file TileDigitsMonTool.cxx.

                                                                     {
 
  const TileRawChannelContainer* rawChannelContainer;
  CHECK(evtStore()->retrieve(rawChannelContainer, m_contNameDSP));
 
  for (const TileRawChannelCollection* rawChannelCollection : *rawChannelContainer) {
 
    if (rawChannelCollection->empty()) continue;
 
    HWIdentifier hwid = rawChannelCollection->front()->adc_HWID(); //take the first channel in the drawer
    int ros = m_tileHWID->ros(hwid);  //take the ros and drawer from the first channel
    int drawer = m_tileHWID->drawer(hwid);
    
    uint32_t crc32 = rawChannelCollection->getFragGlobalCRC() & 1;
    
    if (crc32 == 0) {
      crc32 = 0xFFFFFFFF;
    } else { // means OK CRC match
      crc32 = 0xFFFF;
    } //means NOT OK, CRC mismatch
 
    uint32_t CRCmask = rawChannelCollection->getFragRODChipMask();
    CRCmask = CRCmask << 16; // ROD mask is stored in the 16 most significant bits ce
    CRCmask += rawChannelCollection->getFragFEChipMask();
    
    CRCcheck(dqStatus, crc32, CRCmask, 16, ros, drawer); //reuse the same funcion used for digits
    
  }
 
  return StatusCode::SUCCESS;
}

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.

{
   return StatusCode::SUCCESS;
}

saveStuckBitsProbabilities()

void TileDigitsMonTool::saveStuckBitsProbabilities ( TTree * tree )

overridevirtual

Implements ITileStuckBitsProbsTool.

Definition at line 1907 of file TileDigitsMonTool.cxx.

                                                              {
 
  tree->Branch("StuckBitsProb", m_data->m_stuck_probs, "StuckBitsProb[5][64][48][2][10]/b");
}

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.

{
  ATH_MSG_DEBUG( "ManagedMonitorToolBase::setMonManager():");
  m_manager = manager;
  if( m_manager != 0 ) {
      ATH_MSG_DEBUG( "  --> Setting manager");
      m_managerNameProp = m_manager->name();
      m_fileKey = m_manager->fileKey();
      m_dataType = m_manager->dataType();
      m_environment = m_manager->environment();
      delete m_streamNameFcn;
      m_streamNameFcn = getNewStreamNameFcn();
   }
    ATH_MSG_DEBUG( "  --> Exiting successfully");
}

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.

{
   // All instances should write to the stream(s) defined by the
   // AthenaMonManager.
 
   return StatusCode::SUCCESS;
}

shiftHisto()

void TileDigitsMonTool::shiftHisto ( TH1S * hist, int ros, int drawer, int ch, int gain )

private

Definition at line 1825 of file TileDigitsMonTool.cxx.

{
 
  hist->GetXaxis()->SetRange(5, 100);
 
  TSpectrum s(8, 1.);
 
  s.Search(hist, 2, "goff");
  int shift = int(s.GetPositionX()[0]);
  if (shift > 0) {
    int factor = m_is12bit ? 4 : 1;
    int xmax = std::max(1025 * factor, 846 * factor + shift);
    int xmin = std::max(1, shift + 50 * factor);
    for (int bin = xmin; bin < xmax; ++bin) {
      double c = hist->GetBinContent(bin);
      if (c > 0) m_data->m_shifted_hist[ros][drawer][ch][gain]->SetBinContent(bin - shift - 50 * factor, c);
    }
  }
}

statTestHistos()

void TileDigitsMonTool::statTestHistos ( int ros, int drawer, int gain )

private

Definition at line 1847 of file TileDigitsMonTool.cxx.

{
  std::vector<TH1S*> refbld;
  std::vector<TH1S*> newrefbld;
  TH1F *ref = new TH1F("ref", "ref", m_shiftnbins, 0., m_shiftnbins);
  ref->SetDirectory(0);
  TH1F *ref1 = new TH1F("ref1", "ref1", m_shiftnbins, 0., m_shiftnbins);
  ref1->SetDirectory(0);
 
  for (int i = 0; i < 48; i++) {
 
    TH1S *h = m_data->m_shifted_hist[ros][drawer][i][gain];
    float integ = h->Integral(200, 600);
    if (integ > 0) {
      refbld.push_back(h);
    }
 
  }
 
  int entr = refbld.size();
  const double inv_entr = (entr > 0 ? 1. / static_cast<double>(entr) : 1);
  for (int i = 0; i < entr; i++) {
    TH1S *h = refbld.at(i);
    ref->Add(h, inv_entr);
  }
 
  //      refbld.push_back(ref);
  TH1S *obj = 0;
 
  for (int i = 0; i < entr; i++) {
    obj = refbld.at(i);
    float kol = obj->KolmogorovTest(ref);
    //std::cout<<"The value of the Kolmogorov test for "<< ros << drawer << gain << " pmt:" << i << " is "<< kol << std::endl;
    if (kol > 0.5) {
      newrefbld.push_back(obj);
    }
  }
 
  int ent = newrefbld.size();
  const double inv_ent = (ent > 0 ? 1. / static_cast<double>(ent) : 1);
  for (int i = 0; i < ent; i++) {
    obj = newrefbld.at(i);
    ref1->Add(obj, inv_ent);
  }
 
  //  newrefbld->Add(ref1);      
 
  if (ent > 6)
    m_data->m_shifted_hist[ros][drawer][48][gain]->Add(ref1, 1.);
  else
    m_data->m_shifted_hist[ros][drawer][48][gain]->Add(ref, 1.);
 
  delete ref;
  delete ref1;
 
}

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.

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

stuckBitProb()

const uint8_t * TileDigitsMonTool::stuckBitProb ( int ros, int module, int channel, int gain ) const

overridevirtual

Implements ITileStuckBitsProbsTool.

Definition at line 930 of file TileDigitsMonTool.cxx.

{
  return m_data->m_stuck_probs[ros][module][channel][gain];
}

stuckBits()

int TileDigitsMonTool::stuckBits ( TH1S * hist, int adc )

private

Method to find stuckbits in Read-Out ADC channel.

Definition at line 1263 of file TileDigitsMonTool.cxx.

                                                     {
  // function returns number of stuck bits
  int NSB = 0;
 
  // If all bins at given hypothetical stuck_position (0,1) and stuck_bit (0,...,9)
  // are empty then this bin is stuck in this position. Do this procedure only for
  // bins between the first and the last non-zeroth one.
 
  // Find first/last non-zero bin in the histogram
  int MinBin = 1;
  for (; MinBin < m_i_ADCmax + 2; ++MinBin) {
    if (hist->GetBinContent(MinBin) > 0) {
      break;
    }
  }
  if (MinBin == m_i_ADCmax + 2) return 0; // empty histogram, nothing to do
 
  int MaxBin = m_i_ADCmax + 1;
  for (; MaxBin > 0; --MaxBin) {
    if (hist->GetBinContent(MaxBin) > 0) {
      break;
    }
  }
 
  // bins in hist are counted from 1 to m_i_ADCmax + 1, but actual X value for those bins are 0-m_i_ADCmax
 
  // if there is nothing in first half of histogram
  // or there is nothing in second half and there is a sharp edge at 512
  // it can be that upper most bit is stuck in 0 or 1
  if (MinBin == (m_i_ADCmax + 1) / 2 + 1 || (MaxBin == (m_i_ADCmax + 1) / 2 && hist->GetBinContent(MaxBin) > 3)) {
    ++NSB;
    // std::cout << "Bit 9 is stuck" << std::endl;
  }
 
  --MinBin; // shift to zero bin
  ++MaxBin; // shift to zero bin
 
  for (int hyp_pos = 0; hyp_pos < 2; ++hyp_pos) { // bit stuck at value 0 or 1
    for (int hyp_bit = 0; hyp_bit < 10; ++hyp_bit) { // which bit is stuck
      double sum = 0;
      int bin_counter = 0;
 
      int win_length = (1 << hyp_bit); // length of one interval with all zeros if bit is stuck
      int BeginBin = (1 - hyp_pos) * win_length; // beginning of first interval to check
 
      while (BeginBin + 1 < MaxBin) {
        int EndBin = BeginBin + win_length; // end of interval to check
 
        if (EndBin > MinBin) {
          for (int bin = BeginBin; bin < EndBin; ++bin) {
            //bin is from 0 to m_i_ADCmax here - must be changed in GetBinConent to (bin+1)
            if (MinBin < (bin + 1) && (bin + 1) < MaxBin) {
              sum += hist->GetBinContent(bin + 1);
              ++bin_counter;
            }
          }
        }
        BeginBin = EndBin + win_length; // beginning of next interval
      }
      if (sum == 0 && bin_counter > 0) {
        // std::cout << "Bit "<<hyp_bit<<" is stuck at "<< hyp_pos << std::endl;
        ++NSB;
      }
    }
  }
 
  if ((NSB == 0) && ((m_runType == CisRun) || (m_runType == CisRamp))) {
 
    NSB = stuckBits_Amp(hist, adc); // if no stuck bits found, lets try another crude procedure
  }
 
  return NSB;
}

stuckBits_Amp()

int TileDigitsMonTool::stuckBits_Amp ( TH1S * hist, int adc )

private

A crude method to check Read-Out ADC channel stuckbits.

Definition at line 1372 of file TileDigitsMonTool.cxx.

                                                       {
  int i, b, c, cc = 2;
  int bc[10], bv[10];
  double bs[10];
  int f; // flip-flop of non-zero contents of previous bin
  int cm, cp; // previous and next bin contents
  double prob; // probability
  for (b = 0; b < 10; b++) {
    bc[b] = 0;
    bs[b] = 0.;
    bv[b] = 1 << b;
  }
  cp = hist->GetBinContent(1);
  f = !!cp;
  for (i = 1; i < m_i_ADCmax + 1; i++) {
    cm = cc;
    c = cc = cp;
    cp = (i < m_i_ADCmax) ? hist->GetBinContent(i + 2) : 0;
    prob = 1.;
    if (c > 0 && c < 0.125 * (cp + cm - std::sqrt((double) cp) - std::sqrt((double) cm))) {
      prob = 1. - (double) c / (0.125 * (cp + cm - std::sqrt((double) cp) - std::sqrt((double) cm)));
      c = 0;
    }
    if (c || f) // count bit flips (bc[b]) in bins with non-zero contents and adjacent bins
      for (b = 0; b < 10; b++) {
        if ((i & bv[b]) != ((i - 1) & bv[b]))
          bc[b]++;
        else
          break; // higher bit can flip only of the previous one does
      }
    if (f > 0 && c > 0) continue;
    if (f == 0 && c == 0) continue;
    if (c || f) // bin content flips (zero - non-zero)
      for (b = 0; b < 10; b++) { // count bits flipped at this position
        if ((i & bv[b]) != ((i - 1) & bv[b]))
          bs[b] += (i & bv[b]) ? (c ? prob : -prob) : (c ? -prob : prob);
        else
          break;
      }
    f = !f;
  }
 
  int NSB = 0;
  for (b = 0; b < 10; b++)
    // if (bc[b] > 2 && abs(bs[b]) * 2 > bc[b])
    if (((bc[b] > 2) && (std::abs(bs[b]) == bc[b])) || ((std::abs(bs[b]) > 7) && (std::abs(bs[b]) * 3 > bc[b]))) {
      NSB++;
    }
 
  return NSB;
 
}

stuckBits_Amp2()

int TileDigitsMonTool::stuckBits_Amp2 ( TH1S * hist, TH1C * modhist, int adc, TH2C * outhist = NULL, int ch = 0, uint8_t * stuck_probs = NULL )

private

Definition at line 1426 of file TileDigitsMonTool.cxx.

                                                                                                                       {
 
  if (hist->GetEntries() < 1000)  return 0; /* too few events (1000 / N_samples) in histogram, ignore */
 
  int i, b, c, cc = 0; /* bin counter, but position, bin content */
  double cont;
  int last_non0, first_non0 = -1;
  int bc[10] = { 0 }, bv[10] = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 }; // bit flips at signal regions, bit values
  double bs[10] = { 0. }; // bit flips at signal edges
  int bac[10] = { 0 }, ba0[10] = { 0 }, ba1[10] = { 0 }, bas[10] = { 0 }; // for stuck bits between first_non0, last_non0 using old technique
  int f; // flip-flop of non-zero contents of previous bin
  int cm, cp; // previous and next bin contents
  double prob; // probability
  int zero_limit, saturation_limit;
  zero_limit = gain ? m_zeroLimitHG : 0;
  saturation_limit = gain ? m_saturationLimitHG : m_i_ADCmax;
  cp = hist->GetBinContent(1);
  f = !!cp;
  if (f) first_non0 = 0;
  for (last_non0 = m_i_ADCmax; last_non0 >= 0; last_non0--)
    if (hist->GetBinContent(last_non0 + 1) > 0) break;
  if (last_non0 < 0) // empty histogram
    return 0;
  for (i = 1; i <= last_non0; i++) {
    cm = cc;
    c = cc = cp;
    cp = (i < m_i_ADCmax) ? hist->GetBinContent(i + 2) : 0;
    if (first_non0 < 0) {
      if (cc > 0)
        first_non0 = i;
      else
        continue;
    }
    for (b = 0; b < 10; b++) { // count bits flipped at this position
      if ((i & bv[b]) != ((i - 1) & bv[b])) {
        bac[b]++;
        if (bas[b] > 0) {
          if ((i - 1) & bv[b])
            ba1[b]++;
          else
            ba0[b]++;
          bas[b] = 0;
        }
      }
      if (cc > 0) bas[b]++;
    }
    prob = 1.;
    cont = sqrt((double) (c + cm));
    if ((c == 0 || cm == 0) && (c > 0 || cm > 0)) {
      prob = erf((cont - sqrt(cont)) / sqrt(2 * cont));
    }
    /* bin content is lower than usual */
    if (c > 0 && c < 0.25 * (cp + cm - std::sqrt((double) cp) - std::sqrt((double) cm))) {
      prob = 1. - (double) c / (0.25 * (cp + cm - std::sqrt((double) cp) - std::sqrt((double) cm)));
      c = 0;
    }
    if (c || f) // count bit flips (bc[b]) in bins with non-zero contents or adjacent bins
      for (b = 0; b < 10; b++) {
        if ((i & bv[b]) != ((i - 1) & bv[b]))
          bc[b]++;
        else
          break; // a higher bit can flip only of the lower one does
      }
    if (f > 0 && c > 0) continue;
    if (f == 0 && c == 0) continue;
    if (c || f) // bin content flips (zero - non-zero)
      for (b = 0; b < 10; b++) { // count bits flipped at this position
        if ((i & bv[b]) != ((i - 1) & bv[b]))
          bs[b] += (i & bv[b]) ? (c ? prob : -prob) : (c ? -prob : prob);
        else
          break;
      }
    f = !f;
  }
 
  for (b = 0; b < 10; b++)  // count bits flipped at this position
    if ((i & bv[b]) != ((i - 1) & bv[b])) {
      bac[b]++;
      if (bas[b] > 0) {
        if ((i - 1) & bv[b])
          ba1[b]++;
        else
          ba0[b]++;
      }
    }
 
  int is_stack = 0;
  double sb_prob[4] = {0., 0., 0., 0.};
  static const int sb_map[10] = {0, 1, 1, 2, 2, 3, 3, 3, 3, 3}; // mapping of SB to histogram rows
  for (b = 0; b < 10; b++) {
    if ((ba0[b] == 0 || ba1[b] == 0) && bac[b] > 2 && (ba0[b] + ba1[b] >= bac[b] / 2 || ba0[b] + ba1[b] > 2)) {
      is_stack = 1;
      if (outhist != NULL) {
        sb_prob[sb_map[b]] = 1.;
      }
      if (stuck_probs != NULL)
        stuck_probs[b] = ba0[b] == 0 ? 100u : 200u;
      continue;
    }
    double bs1 = std::fabs(bs[b]) - sqrt(std::fabs(bs[b]));
    if (bs1 < 0.) bs1 = 0.;
    if ((bs1 > 0.5 * bc[b]) || (bc[b] > 7 && bs1 * 3 > bc[b])) is_stack = 1;
    if (outhist != NULL && bc[b] > 0) {
      // if (sb_prob[sb_map[b]] < 100. * bs1 / bc[b]) sb_prob[sb_map[b]] = 100. * bs1 / bc[b];
      sb_prob[sb_map[b]] = 1. - (1. - sb_prob[sb_map[b]]) * (1. - 1. * bs1 / bc[b]); // prod of probs. of not-stuck
    }
    if (stuck_probs != NULL)
    {
      stuck_probs[b] = (uint8_t) (100. * bs1 / bc[b]);
      if (bs[b] > 0)
      {
        stuck_probs[b] += 100u;
        if (stuck_probs[b] == 100u)
          stuck_probs[b] = 0u;
      }
    }
  }
  if ((first_non0 >= (m_i_ADCmax + 1) / 2 && first_non0 < m_i_ADCmax)
      || (last_non0 == (m_i_ADCmax + 1) / 2 - 1 && hist->GetBinContent(last_non0) > 3)) {
    is_stack = 1;
 
    sb_prob[3] = 1.;
    if (stuck_probs != NULL)
      stuck_probs[9] = first_non0 >= 512 ? 200u : 100u;
  }
  if (outhist != NULL) {
    outhist->Fill((double) ch, 0., 100. * sb_prob[0]);
    outhist->Fill((double) ch, 1., 100. * sb_prob[1]);
    outhist->Fill((double) ch, 2., 100. * sb_prob[2]);
    outhist->Fill((double) ch, 3., 100. * sb_prob[3]);
 
    if (first_non0 >= saturation_limit)
      outhist->Fill((double) ch, 5., 100.);
    else if (last_non0 >= saturation_limit) {
      double frac;
      int saturation_entries = 0;
      int maxADC = m_i_ADCmax + 1;
      for  (i = saturation_limit + 1; i <= maxADC; ++i)
        saturation_entries += hist->GetBinContent(i);
      frac = 100. * (double) saturation_entries / hist->GetEntries();
      if (frac > 0. && frac < 1.) frac = 1.;
      if (frac > 99. && frac < 100.) frac = 99.;
      outhist->Fill((double) ch, 5., frac);
    }
    if (last_non0 <= zero_limit)
      outhist->Fill((double) ch, 4., 100.);
    else if (first_non0 <= zero_limit) {
      double frac;
      int zero_entries = 0;
      for  (i = 1; i <= zero_limit + 1; ++i)
        zero_entries += hist->GetBinContent(i);
      frac = 100. * (double) zero_entries / hist->GetEntries();
      if (frac > 0. && frac < 1.) frac = 1.;
      if (frac > 99. && frac < 100.) frac = 99.;
      outhist->Fill((double) ch, 4., frac);
    }
    double entries, empty_cut, full_cut;
    int mod32empty = 0;
    int mod32full = 0;
    bool enough = false;
    entries = modhist -> GetEntries();
    empty_cut = entries < 4096. ? entries / (32 * 4) : 32.;
    full_cut = entries / 32.;
    if (full_cut > 126.)
      full_cut = 126.;
    if (full_cut - empty_cut < 1.)
      full_cut = empty_cut + 1.;
 
    for (i = 1; i <= 32; ++i) {
      if (modhist->GetBinContent(i) <= empty_cut)
        ++mod32empty;
      else if (modhist->GetBinContent(i) > full_cut)
        ++mod32full;
      if (modhist->GetBinContent(i) > 64)
       enough = true;
    }
    if (mod32empty + mod32full == 32 || enough) //skip in the case of small number of events
      if (mod32empty != 0 && mod32full != 0) //some but not all n%32 positions have events
        outhist->Fill((double) ch, 6., mod32empty);
 
    outhist->SetMaximum(100.);
  }
  return is_stack;
}

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.

{
    // THistSvc employs TDirectory Append method when registering TGraph.
    // When deReg is used to de-register TGraph object, THistSvc only removes the object
    // from its internal management but forgets to delete from TDirectory.
    // The current method fixes this problem by removing the TGraph object manually
    // after THistSvc->deReg(TGraph* obj) is called.
 
    // Saves and restores gFile and gDirectory
    GlobalDirectoryRestore restore;
 
    // This check is true when TGraph object is removed successfully
    bool graphRemoved = false;
 
    file->cd("/");
    TDirectory* dir = file->GetDirectory(directoryName.c_str());
    if (dir != 0) {
        dir->cd();
        TObject* obj = dir->Remove(theGraph);
        if (obj != 0) 
            graphRemoved = true;
    } 
 
    if (!graphRemoved) {
        return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
}

trigChainsArePassed()

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

protectedvirtualinherited

Definition at line 2092 of file ManagedMonitorToolBase.cxx.

{
  ATH_MSG_DEBUG( "ManagedMonitorToolBase::trigChainsArePassed:");
 
   for(unsigned int i=0; i<vTrigNames.size(); i++) {
      if( m_trigDecTool->isPassed(vTrigNames[i]) ) {
    ATH_MSG_DEBUG( "  + \"" << vTrigNames[i] << "\" passed, returning \'true\'");
    return true;
      }
      else {
    ATH_MSG_DEBUG( "  - \"" << vTrigNames[i] << "\" did not pass");
      }
   }
 
   return false;
}

updateTriggersForGroups()

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

protectedinherited

Definition at line 2130 of file ManagedMonitorToolBase.cxx.

                                                               {
  for (size_t i = 0; i < vTrigChainNames.size(); ++i) {
    std::string& thisName = vTrigChainNames[i];
    if (thisName.compare(0, 9, "CATEGORY_") ==0) {
      ATH_MSG_DEBUG("Found a trigger category: " << thisName << ". We will unpack it.");
      std::vector<std::string> triggers = m_trigTranslator->translate(thisName.substr(9,std::string::npos));
      std::ostringstream oss;
      oss << "(";
      for (size_t itrig = 0; itrig < triggers.size(); ++itrig) {
    if (itrig != 0) { 
      oss << "|";
    }
    oss << triggers[itrig];
      }
      oss << ")";
      // replace with new value
      std::string newval = oss.str();
      ATH_MSG_DEBUG("Replaced with " << newval);
      vTrigChainNames[i] = std::move(newval);
    }
  }
}

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

writeAndDelete()

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

virtualinherited

Write out histogram and delete it.

Definition at line 1599 of file ManagedMonitorToolBase.cxx.

                                                {
  if (!h)
    return StatusCode::FAILURE;
  
  std::string hName = h->GetName();
  
  if( m_manager != 0 ) {
    std::string genericName = NoOutputStream().getStreamName( this, group, hName );
    m_manager->writeAndDelete( genericName );
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_ADCmaxMinusEps

float TileDigitsMonTool::m_ADCmaxMinusEps {}

private

Definition at line 174 of file TileDigitsMonTool.h.

{};

m_allHistsFilled

bool TileDigitsMonTool::m_allHistsFilled {}

private

Definition at line 161 of file TileDigitsMonTool.h.

{};

m_bigain

bool TileDigitsMonTool::m_bigain {}

private

Definition at line 124 of file TileDigitsMonTool.h.

{};

m_book2D

bool TileDigitsMonTool::m_book2D {}

private

Definition at line 105 of file TileDigitsMonTool.h.

{};

m_bookAll

bool TileDigitsMonTool::m_bookAll {}

private

Definition at line 104 of file TileDigitsMonTool.h.

{};

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.

{};

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.

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

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.

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

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.

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

m_cispar

const uint32_t* TileDigitsMonTool::m_cispar {}

private

Definition at line 122 of file TileDigitsMonTool.h.

{};

m_contNameDSP

std::string TileDigitsMonTool::m_contNameDSP

private

Definition at line 107 of file TileDigitsMonTool.h.

m_d

Imp* ManagedMonitorToolBase::m_d

privateinherited

Definition at line 900 of file ManagedMonitorToolBase.h.

m_data

std::unique_ptr<Data> TileDigitsMonTool::m_data

private

Definition at line 160 of file TileDigitsMonTool.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_digitsContainerName

std::string TileDigitsMonTool::m_digitsContainerName

private

Definition at line 167 of file TileDigitsMonTool.h.

m_DQFilterTools

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

protectedinherited

Definition at line 849 of file ManagedMonitorToolBase.h.

{this,"FilterTools",{}};

m_DQstatusKey

SG::ReadHandleKey<TileDQstatus> TileDigitsMonTool::m_DQstatusKey

private

Definition at line 182 of file TileDigitsMonTool.h.

m_EBcellName

std::string TilePaterMonTool::m_EBcellName[48]

protectedinherited

Initial value:

= { "E3", "E4", "D4", "D4", "C10", "C10", "A12", "A12", "B11", "B11", "A13", "A13"
                                 , "E1", "E2", "B12", "B12", "D5", "D5", "E3*", "E4*", "A14", "A14", "B13", "B13"
                                 ,   "",   "",    "",    "",   "",   "", "B14", "A15", "A15",    "",    "", "B14"
                                 , "B15", "D6", "D6", "B15", "A16", "A16",  "",    "",    "",    "",    "", "" }

Definition at line 210 of file TilePaterMonTool.h.

                               { "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",  "",    "",    "",    "",    "", "" };

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_f_ADCmax

float TileDigitsMonTool::m_f_ADCmax {}

private

Definition at line 173 of file TileDigitsMonTool.h.

{};

m_fileKey

std::string ManagedMonitorToolBase::m_fileKey

protectedinherited

Definition at line 833 of file ManagedMonitorToolBase.h.

m_fillPedestalDifference

bool TileDigitsMonTool::m_fillPedestalDifference {}

private

Definition at line 166 of file TileDigitsMonTool.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_i_ADCmax

int TileDigitsMonTool::m_i_ADCmax {}

private

Definition at line 172 of file TileDigitsMonTool.h.

{};

m_infoName

std::string TileDigitsMonTool::m_infoName

private

Definition at line 170 of file TileDigitsMonTool.h.

m_is12bit

bool TileDigitsMonTool::m_is12bit {}

private

Definition at line 176 of file TileDigitsMonTool.h.

{};

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.

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

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.

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

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.

{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_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap

protectedinherited

Definition at line 827 of file ManagedMonitorToolBase.h.

m_NCont

const int TileDigitsMonTool::m_NCont = 10

staticprivate

Definition at line 76 of file TileDigitsMonTool.h.

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 TileDigitsMonTool::m_nEventsTileMon {}

private

Definition at line 125 of file TileDigitsMonTool.h.

{};

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_nSamples

int TileDigitsMonTool::m_nSamples {}

private

Definition at line 126 of file TileDigitsMonTool.h.

{};

m_path

std::string ManagedMonitorToolBase::m_path

protectedinherited

Definition at line 852 of file ManagedMonitorToolBase.h.

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_runType

int TileDigitsMonTool::m_runType {}

private

Definition at line 106 of file TileDigitsMonTool.h.

{};

m_saturationLimitHG

int TileDigitsMonTool::m_saturationLimitHG {}

private

Definition at line 180 of file TileDigitsMonTool.h.

{};

m_savePng

bool TilePaterMonTool::m_savePng {}

protectedinherited

Definition at line 203 of file TilePaterMonTool.h.

{};

m_savePs

bool TilePaterMonTool::m_savePs {}

protectedinherited

Definition at line 204 of file TilePaterMonTool.h.

{};

m_saveSvg

bool TilePaterMonTool::m_saveSvg {}

protectedinherited

Definition at line 205 of file TilePaterMonTool.h.

{};

m_shiftnbins

int TileDigitsMonTool::m_shiftnbins {}

private

Definition at line 177 of file TileDigitsMonTool.h.

{};

m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn

protectedinherited

Definition at line 841 of file ManagedMonitorToolBase.h.

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

{};

m_tileID

const TileID* TilePaterMonTool::m_tileID {}

protectedinherited

Definition at line 198 of file TilePaterMonTool.h.

{};

m_tileInfo

const TileInfo* TileDigitsMonTool::m_tileInfo {}

private

Definition at line 171 of file TileDigitsMonTool.h.

{};

m_tileTBID

const TileTBID* TilePaterMonTool::m_tileTBID {}

protectedinherited

Definition at line 200 of file TilePaterMonTool.h.

{};

m_tileToolNoiseSample

ToolHandle<TileCondToolNoiseSample> TileDigitsMonTool::m_tileToolNoiseSample

private

tool which provided noise values

Definition at line 120 of file TileDigitsMonTool.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.

{"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.

{"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.

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

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

{this,"TriggerTranslatorTool",""};

m_useLumi

bool ManagedMonitorToolBase::m_useLumi

privateinherited

Definition at line 894 of file ManagedMonitorToolBase.h.

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.

m_zeroLimitHG

int TileDigitsMonTool::m_zeroLimitHG {}

private

Definition at line 179 of file TileDigitsMonTool.h.

{};

---

The documentation for this class was generated from the following files:

• TileDigitsMonTool.h
• TileDigitsMonTool.cxx