CscCalibMonToolSlope Class Reference

Class for monitoring CSC relative gain calibration results. More...

#include <CscCalibMonToolSlope.h>

Inheritance diagram for CscCalibMonToolSlope:

Collaboration diagram for CscCalibMonToolSlope:

Public Types
enum	Interval_t {   file = 0 , eventsBlock , lumiBlock , lowStat ,   medStat , higStat , run , fill ,   all }
	An enumeration describing the interval over which a particular monitoring object is filled (i.e., interval over which the method Fill(...) is called). 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
	CscCalibMonToolSlope (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
	~CscCalibMonToolSlope ()
	Destructor.
StatusCode	initialize ()
	Initialize slope sepcific values.
StatusCode	finalize ()
	Delete slope sepcific values.
StatusCode	bookHistograms ()
	Books all histograms not retrieved driectly from CscCalcSlope.
virtual StatusCode	fillHistograms (const EventContext &ctx)
	Standard function for a ManagedMonitorToolBase.
virtual StatusCode	procHistograms ()
	At end of run this processes the calibration results and fills the histograms.
virtual StatusCode	checkHists (bool fromFinalise)
	Standard function for a ManagedMonitorToolBase.
virtual StreamNameFcn *	streamNameFunction ()
	Returns the function object that converts logical paramters into a physical stream name.
virtual StatusCode	bookHists ()
	Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers.
virtual StatusCode	fillHists (const EventContext &ctx)
	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 ()
	Calls procHists( true, true, true ).
virtual StatusCode	bookHistogramsRecurrent ()
	An inheriting class should either override this function, bookHists() or bookHistograms().
virtual void	setMonManager (AthenaMonManager *manager)
	Takes a pointer to a managing object to get information from it when needed.
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.
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	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.
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) const
	Average mu, i.e.
virtual float	lbInteractionsPerCrossing (const EventContext &ctx) const
	Instantaneous number of interactions, i.e.
virtual float	lbAverageLuminosity (const EventContext &ctx) const
	Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1).
virtual float	lbLuminosityPerBCID (const EventContext &ctx) const
	Instantaneous luminosity.
virtual double	lbDuration (const EventContext &ctx) const
	Luminosity block time (in seconds).
virtual float	lbAverageLivefraction (const EventContext &ctx) const
	Average luminosity livefraction.
virtual float	livefractionPerBCID (const EventContext &ctx) const
	Livefraction per bunch crossing ID.
virtual double	lbLumiWeight (const EventContext &ctx) const
	Average Integrated Luminosity Live Fraction.
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 Interval_t to a string of the same name.
static Interval_t	intervalStringToEnum (const std::string &str)
	Converts a string to the corresponding Interval_t.
static const InterfaceID &	interfaceID ()

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

Protected Member Functions
virtual StatusCode	bookHistCollection (HistCollection *histCollection, const std::string &dataTypeName, const std::string &dataTypeTitle, const std::string &categoryName, const std::string &categoryTitle, const std::string &axisLabel, int numBins, float lowBound, float highBound, const std::string &parDir="", uint16_t toSkip=0)
	Initializes the histograms in a histCollection and books them.
virtual StatusCode	bookLayHists (const std::string &histTypeDir, const std::string &parTypeDir, std::vector< TH1F * > &vector, const std::string &namePrefix, const std::string &titlePrefix, const std::string &xaxis, const std::string &yaxis, bool chanView=true, bool ignoreY=false, unsigned int numBins=100, float lowBound=0, float highbound=100)
	Books a vector of histograms where each one corresponds to a layer of the CSC secbers.
virtual StatusCode	bookChamHists (const std::string &histTypeDir, const std::string &parTypeDir, std::vector< TH1F * > &histVector, const std::string &namePrefix, const std::string &titlePrefix, const std::string &xaxis="", const std::string &yaxis="", bool chanView=true, bool ignoreY=false, unsigned int numBins=100, float lowBound=0, float highbound=100)
	Books a vector of histograms where each one corresponds to a secber of the CSC secbers.
virtual StatusCode	procParameter (const CscCalibResultCollection *parVals, ProcSetupInfo *simpleSet)
	Processors a parameter type.
virtual StatusCode	copyDataToHists (HistCollection *histCollection)
	Fills the histograms in the histCollection based on the data in the std::vector in the HistCollection.
virtual int	getLayIndex (int measuresPhi, int stationEta, int sector, int layer)
	produces a unique number for every layer in the detector
virtual int	getChamIndex (int measuresPhi, int stationEta, int sector)
	Produces a unique number for every secber in the detector.
virtual int	getSector (int stationPhi, int stationSize)
	Produces a sector number from the phi and size of a station.
std::string	getEndCap (int eta)
	Gets the letter endcap (A or C) for a given eta index (1,-1).
std::string	getGeoPath (int eta=-9999, int sector=-9999, int wireLayer=-9999, int measuresPhi=-9999, int channel=-9999)
	getGeoPath creates a directory structure for a histogram based upon where it is in the CSC geometry.
std::string	getFullPath (const std::string &geoPath, const std::string &histTypeDir, const std::string &parTypeDir)
	Geo path creates a directory structure for a histogram based upon its geoPath, the hist type dir (spectrum of values, per-channel values, etc), and the parTypeDir (pedestal, etc).
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
unsigned int	m_maxHashId {}
unsigned int	m_maxChamId {}
unsigned int	m_numBad {}
unsigned int	m_expectedChamberLayer {}
bool	m_makeHashHists {}
	Data output options.
bool	m_makeAllChan1dHists {}
bool	m_makeAllChan2dHists {}
bool	m_makeLayHists {}
bool	m_makeLaySummHists {}
bool	m_makeChamProfs {}
bool	m_makeChamSummHists {}
bool	m_makeChamHists {}
bool	m_doAllDetailed {}
bool	m_doBadDetailed {}
int	m_maxDetailedChannels {}
	To keep track of channels that should have more data printed to root file.
bool *	m_detailedHashIds {}
bool	m_onlyExpectPrecisionHashIds {}
	Hash Ids one would expect to be in calibration data.
std::set< int >	m_expectedHashIdsAll
std::set< int >	m_expectedHashIdsPrec
std::string	m_hashName
	Naming info.
std::string	m_hashTitle
std::string	m_allChan1dName
std::string	m_allChan1dTitle
std::string	m_allChan2dName
std::string	m_allChan2dTitle
std::string	m_chamProfName
std::string	m_chamProfTitle
std::string	m_layHistName
std::string	m_layHistTitle
std::string	m_chamSummHistName
std::string	m_chamSummHistTitle
std::string	m_chamHistName
std::string	m_chamHistTitle
std::string	m_laySummHistName
std::string	m_laySummHistTitle
int	m_histCol {}
	Hist colors.
int	m_histColAlert {}
std::string	m_generic_path_csccalibmonitoring
	Path of histograms.
std::string	m_hashPath
std::string	m_allChan2dPath
std::string	m_chamProfPath
std::string	m_layHistPath
std::string	m_chamSummHistPath
std::string	m_laySummHistPath
DataVector< MonGroup > *	m_monGroupVec {}
	Keeps track of MonGroups.
std::map< std::string, MonGroup * >	m_monGroupMap
std::string	m_calibResultKey
	Calibration result storegate key.
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::ReadCondHandleKey< CscCondDbData >	m_readKey {this, "ReadKey", "CscCondDbData", "Key of CscCondDbData"}
	Access to COOL database.
bool	m_doStatDb {}
HistCollection *	m_statDbColl {}
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
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
virtual StatusCode	handleParameter (const CscCalibResultCollection *parVals)
	handleParameter sets things up for the base class procParameter.
virtual StatusCode	postProc ()
	postProc retrieves the plots fit to produce the gain
StatusCode	makeFracGraphs (const CscCalibReportSlope &slopeReport)
	Make fractional deviation plots between the gain plot points and the fit.
StatusCode	findDeadChannels (const CscCalibReportSlope &slopeReport)
	Look for dead channels.
std::vector< float > &	setArray (std::vector< float > &array, const float &value, const int &numEntries)
void	genNeighborRatios (const std::vector< float > &source, std::vector< float > &ratios) const
	Generated next neighbor channel ratios of the slopes.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
bool	m_doNeighborRatios {}
	Do neighbor ratios.
bool	m_histAttenLevels {}
	Histogram all values for all histograms.
float	m_slopeMaxDiff {}
	Maximum deviation from expected values allowed before m_h_numBad is incremented.
float	m_interceptMax {}
float	m_chi2Max {}
float	m_fracDevMax {}
float	m_peaktMaxDiff {}
int	m_slopeBadBin {1}
	Bin corresponding to each category in m_h_numbad.
int	m_interceptBadBin {2}
int	m_chi2BadBin {3}
int	m_peaktBadBin {4}
int	m_fracBadBin {5}
int	m_deadBadBin {6}
int	m_missingBadBin {7}
int	m_totalLiveBin {1}
int	m_totalDeadBin {2}
int	m_newLiveBin {3}
int	m_newDeadBin {4}
TH1I *	m_h_numBad {}
	Stores number of channels that are bad in several categories.
TH1F *	m_h_slopeCompareOverview {}
	Histograms that simply histogram all entries for a value.
TH1F *	m_h_interceptOverview {}
TH1F *	m_h_chi2Overview {}
TH1F *	m_h_slopeMissingChans {}
TH1F *	m_h_deadOverview {}
	Overview of dead channels and changes.
std::vector< TProfile * >	m_fracProfs
	Holds fractional deviation TProfiles.
HistCollection *	m_slopeNewColl {}
	HistCollections.
HistCollection *	m_slopeOldColl {}
HistCollection *	m_slopeDiffColl {}
HistCollection *	m_peaktNewColl {}
HistCollection *	m_peaktOldColl {}
HistCollection *	m_peaktDiffColl {}
HistCollection *	m_interceptColl {}
HistCollection *	m_chi2Coll {}
HistCollection *	m_deadNewColl {}
HistCollection *	m_deadDiffColl {}
HistCollection *	m_slopeRatioColl {}
HistCollection *	m_fitResColl {}
DataVector< HistCollection >	m_ampColls
std::string	m_histKey
	Storegate key for pedestal amplitude histograms.
std::string	m_subDir
	Name of subdirectory under EXPERT or SHIFT that the histograms will be stored.
int	m_deadPulserLevelCutoff
	Dead channel finding user defined parameters.
int	m_deadADCCutoff
bool	m_newLowStatInterval
bool	m_newMedStatInterval
bool	m_newHigStatInterval
bool	m_newLowStat
bool	m_newLumiBlock
bool	m_newRun
bool	m_newEventsBlock
bool	m_endOfEventsBlock
bool	m_endOfLowStat
bool	m_endOfLumiBlock
bool	m_endOfRun
SG::ReadCondHandleKey< LuminosityCondData >	m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
SG::ReadCondHandleKey< LBDurationCondData >	m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
SG::ReadCondHandleKey< TrigLiveFractionCondData >	m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"}
bool	m_bookHistogramsInitial
bool	m_useLumi
float	m_defaultLBDuration
std::set< Interval_t >	m_supportedIntervalsForRebooking
Imp *	m_d
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Class for monitoring CSC relative gain calibration results.

This class monitors the slope determined to be the relative gain between CSC chanels, as produced by CscCalcSlope.cxx in the CscCalibAlgs package. It produces numerous histograms to illustrate the results. It runs during the finalize stage of the job. The info it looks at includes: -The slope and intercept and chi^2 of the fit -COOL slope. -Difference between slope and COOL slope

CscCalibMonToolBase provides the basis for much of the operation of this class. Generally, the program flow osciallates between base class functions and CscCalibMonToolSlope functions.

Definition at line 37 of file CscCalibMonToolSlope.h.

Member Typedef Documentation

MDMap_t

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

protectedinherited

Definition at line 733 of file ManagedMonitorToolBase.h.

StoreGateSvc_t

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

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Member Enumeration Documentation

Interval_t

enum ManagedMonitorToolBase::Interval_t

inherited

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 61 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 75 of file ManagedMonitorToolBase.h.

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

Constructor & Destructor Documentation

CscCalibMonToolSlope()

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

Constructor.

Definition at line 24 of file CscCalibMonToolSlope.cxx.

                              : 
  CscCalibMonToolBase(type, name, parent){
  declareProperty("MaxSlopeDiff",m_slopeMaxDiff=0.5);
  declareProperty("MaxIntercept",m_interceptMax = 5.0);
  declareProperty("MaxChi2_NDF",m_chi2Max = 100);
  declareProperty("MaxFracDev",m_fracDevMax = .5);
  declareProperty("MaxPeaktDiff",m_peaktMaxDiff= 10);
  m_calibResultKey = "CscCalibResultSlope";
  declareProperty("calGraphKey", m_histKey = "cscSlopeCalibReport");
  declareProperty("subDir", m_subDir ="");
  declareProperty("DeadPulserLevelCutoff", m_deadPulserLevelCutoff = 50);   
  declareProperty("DeadADCCutoff", m_deadADCCutoff =100); //Cutoff after ped subtraction
  declareProperty("DoNeighborRatio", m_doNeighborRatios = true);
  declareProperty("HistAttenLevels", m_histAttenLevels = false , "Make histograms for all attenuation levels. Potentially requires a LOT of RAM.");
 
 
  /*##From CscCalibMonToolBase.cxx, for reference. Do not uncomment!
    declareProperty("MakeHashValueHist",m_makeHashHist=true);
    declareProperty("MakeLayerValueHists",m_makeLayerHists=false);
    declareProperty("DetailedResultHashIds",m_detailedHashIds);
   */
 
}

~CscCalibMonToolSlope()

CscCalibMonToolSlope::~CscCalibMonToolSlope ( )

inline

Destructor.

Definition at line 47 of file CscCalibMonToolSlope.h.

{};

Member Function Documentation

bookChamHists()

StatusCode CscCalibMonToolBase::bookChamHists ( const std::string & histTypeDir, const std::string & parTypeDir, std::vector< TH1F * > & histVector, const std::string & namePrefix, const std::string & titlePrefix, const std::string & xaxis = "", const std::string & yaxis = "", bool chanView = true, bool ignoreY = false, unsigned int numBins = 100, float lowBound = 0, float highbound = 100 )

protectedvirtualinherited

Books a vector of histograms where each one corresponds to a secber of the CSC secbers.

Parameters

histTypeDir	The subdirectory where the histogram type should be stored (e.g "layerOverview")
parTypeDir	The subdirectory where the parameter type (e.g ped, noise,etc)
namePrefix	Something to put in front of the name. Rest is based on secber.
titlePrefix	String to append to the front of the title. Rest is based on secber.
xaxis	Title for x-axis.
yaxis	Title for y-axis.
chanView	If true, x-axis num-bins will be number of channels of a given layer. numbins, highBound, and lowBound will be ignored.
ignoreY	Do not initialize histograms from the transverse direction.
numBins	number of bins for each histoto
lowBound	lower bound for histogram x-axis
highBound	higher bound for histogram x-axis

Definition at line 547 of file CscCalibMonToolBase.cxx.

{
  //When doing channel view (i.e. one value per channel, also refered to as SectorView)
  //we use pre-defined nbins, lower bound, and upper bound for histograms for obvious reasons
  static const int chanViewNBinsX = 800;
  static const double chanViewLowBoundX = .5;
  static const double chanViewHighBoundX = 800.5;
 
  static const int chanViewNBinsY = 200;
  static const double chanViewLowBoundY = .5;
  static const double chanViewHighBoundY = 200.5;
 
 
  //Book a set of channel view histograms.
  //unsigned int numStrips;
  int stationSize, stationPhi, stationEta, sector;
  std::string stationName;
  std::string orientationName = "prec";
  std::string orientationTitle = "Precision Direction";
 
  int numHists = (ignoreY) ? 32 : 64; //32 chambers, 2 orientations
  histVector.resize(numHists,nullptr);
 
  const std::vector<Identifier> & ids = m_idHelperSvc->cscIdHelper().idVector();
 
  for(const auto & thisChamberId:ids)
  {
    IdentifierHash chamHash;
    m_idHelperSvc->cscIdHelper().get_module_hash(thisChamberId,chamHash);
    ATH_MSG_DEBUG( "Booking histograms for chamber with hash " << (int)chamHash  );
 
    stationSize = m_idHelperSvc->cscIdHelper().stationName(thisChamberId); //50
    stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(thisChamberId);
    stationEta = m_idHelperSvc->cscIdHelper().stationEta(thisChamberId); 
    sector = getSector(stationPhi,stationSize);
 
    for(unsigned int orientationItr = 0; orientationItr < 2; orientationItr++)
    {
      if(orientationItr ==1)
      {
        if(ignoreY)
          continue; //skip non precision strips.
        orientationName = "trans";
        orientationTitle = "Transverse Direction";
        if(chanView){
          numBins = chanViewNBinsY;
          lowBound = chanViewLowBoundY;
          highBound = chanViewHighBoundY;
        }
      }
      else
      {
        orientationName = "prec";
        orientationTitle = "Precision Direction";
        if(chanView){
          numBins = chanViewNBinsX;
          lowBound = chanViewLowBoundX;
          highBound = chanViewHighBoundX;
        }
      }
 
      std::stringstream nameStream;
      nameStream.setf(std::ios::right, std::ios::adjustfield);
      nameStream << namePrefix << "_" << orientationName <<  "_eta_" 
        << ((stationEta == 1) ? "1" : "0") << "_sector_" 
        << std::setw(2) << std::setfill('0')
        << sector ; 
 
      std::stringstream titleStream;
 
      titleStream << titlePrefix << ", " << orientationTitle 
        << ", Eta " << stationEta
        << ", Sector " << sector; 
 
      TH1F* hist = new TH1F(nameStream.str().c_str(), titleStream.str().c_str()
          ,numBins, lowBound, highBound);
      hist->GetXaxis()->SetTitle(xaxis.c_str());
      hist->GetYaxis()->SetTitle(yaxis.c_str());
      hist->SetFillColor(m_histCol);
 
      int chamIndex = getChamIndex(orientationItr,stationEta,sector);
 
      ATH_MSG_DEBUG( "Registering histogram with name " 
                     << hist->GetName() << " and chamIndex " << chamIndex  );
 
      histVector[chamIndex] = hist;
 
      std::string path = getFullPath(getGeoPath(stationEta,sector), histTypeDir, parTypeDir);
 
      MonGroup monGroup( this, path ,run, ATTRIB_MANAGED);
      if (!monGroup.regHist(hist).isSuccess())
      {
        ATH_MSG_WARNING("monGroup.regHist(hist) failed for "<< path  );
      }
    }//End orientation loop        
  }//End chamber loop
  ATH_MSG_DEBUG( "Exiting bookChamHists"  );
  return StatusCode::SUCCESS;
}//end bookChamHists

bookHistCollection()

StatusCode CscCalibMonToolBase::bookHistCollection ( HistCollection * histCollection, const std::string & dataTypeName, const std::string & dataTypeTitle, const std::string & categoryName, const std::string & categoryTitle, const std::string & axisLabel, int numBins, float lowBound, float highBound, const std::string & parDir = "", uint16_t toSkip = 0 )

protectedvirtualinherited

Initializes the histograms in a histCollection and books them.

This and the other booking function are used to enforce a central naming convention to the histograms. The Name parameters are strings that will be input into the names of the historams, and the Title parameters into the titles.

Parameters

dataTypeName	indicates the dataType, like pedestal, noise, etc.
dataTypeTitle	indicates the dataType, like pedestal,noise, etc.
categoryName	indicates a category. Useful to specify new or COOL data.
categoryTitle	indicates a category. Useful to specify new or COOL data.
axisLabel	What the axis corresponding to the data type should be named. The other axis is determined depending on histogram type.
numBins	For those histograms whose x-axis is the datatype, and not channels or similar.
lowBound	For those histograms whose x-axis is the datatype, and not channels or similar.
highBound	For those histograms whose x-axis is the datatype, and not channels or similar.
parDir	is a parDirectory to store the resulting histograms in.
toSkip	is a bit word that specifies when to allow certain histograms

Definition at line 138 of file CscCalibMonToolBase.cxx.

{        
  //toSkip bitmask:
  //00000000 do all
  //00000001 skip all channels hash view 
  //00000010 skip chamberAverage
  //00000100 skip layer overview
  //00001000 skip sector summary 
  //00010000 skip layer summary
  //00100000 skip AllChannels 1d view
  //00100000 skip AllChannels 2d view
  //01000000 skip csc spectra
  //10000000 skip sector overview
 
  //Make sure last character isn't a "/"
  std::string endDir = "";
  if(parDir != "")
    endDir = "/" + parDir;
 
  //Some universal directories
  std::string allChambersDirectory = "/GeneralCscHists";
 
  //Set directory structure used by CscCalibMonToolBase
  /*
     m_hashPath          = m_generic_path_csccalibmonitoring + allChambersDirectory + "/AllChanHash" + endDir;
     m_allChan2dPath    = m_generic_path_csccalibmonitoring + allChambersDirectory + "/AllChan2d" + endDir;
     m_chamProfPath       = m_generic_path_csccalibmonitoring + allChambersDirectory + "/SectorProfiles" + endDir;
     m_layHistPath       = m_generic_path_csccalibmonitoring + "/EXPERT/" + parDir + "Layers";
     m_chamSummHistPath  = m_generic_path_csccalibmonitoring +  "/EXPERT/" + parDir + "ChamberValueSpectrum";
     m_laySummHistPath   = m_generic_path_csccalibmonitoring +  "/EXPERT/" + parDir + "LayerValueSpectrum";
   */
  bool allGood = true;
 
 
  std::string nameStart =  dataTypeName;
  if(categoryName != "" )
    nameStart += "_" + categoryName;
 
  std::string titleStart = categoryTitle + " " + dataTypeTitle;
  std::string yaxis= "", xaxis = "";
 
  ATH_MSG_DEBUG( "In bookHistCollection for " << nameStart << " series."  );
 
  if(!((toSkip>>6) &0x1)){
    histCollection->cscSpec.resize(2,nullptr);
    for(int measuresPhi =0; measuresPhi <=1; measuresPhi++) {
      std::string name = "h_" + nameStart+ "_" + (measuresPhi ? "phi" : "eta") + "_spectrum" ;
      std::string title = titleStart +" " + (measuresPhi ? "Phi Strips" : "Eta Strips") + " spectrum";
      TH1F * specHist = new TH1F(name.c_str(), title.c_str(), numBins, lowBound, highBound);
      specHist->GetYaxis()->SetTitle("Counts");
      specHist->GetXaxis()->SetTitle(axisLabel.c_str());
      std::string specPath = getFullPath( getGeoPath(), "OverviewSpectra", parDir);
      MonGroup monGroup( this, specPath, run, ATTRIB_MANAGED);
      StatusCode sc = monGroup.regHist(specHist);
 
      specHist->SetFillColor(m_histCol);
 
      if(!sc.isSuccess())
      {
        ATH_MSG_ERROR( "failed to register " << name  );
        allGood = false;
      }       
      else
        histCollection->cscSpec[measuresPhi] = specHist; 
    }
 
 
  }
 
  if(m_makeHashHists && !(toSkip & 0x1))
  {
    std::string name = "h_" + nameStart + "_" + m_hashName;
    std::string title = categoryTitle + " " + dataTypeTitle + " "  + m_hashTitle;
    yaxis = axisLabel;
    xaxis = "Channel Hash ID";
    TH1F * hashHist = new TH1F(name.c_str(), title.c_str(), m_maxHashId+1,0,m_maxHashId+1);
    hashHist->GetXaxis()->SetTitle(xaxis.c_str());
    hashHist->GetYaxis()->SetTitle(yaxis.c_str());
    hashHist->SetFillColor(m_histCol);
 
    std::string hashPath = getFullPath( getGeoPath(), "FullViewHash", parDir);
    MonGroup monGroup( this, hashPath, run, ATTRIB_MANAGED);
    ATH_MSG_DEBUG( "Registering " << name  );
    if (!monGroup.regHist(hashHist).isSuccess())
    {
      ATH_MSG_ERROR( "failed to register " << name  );
      allGood = false;
    }       
    else
      histCollection->hashHist = hashHist;
 
  }
  //All channels 1d view
  if(m_makeAllChan1dHists && !((toSkip>>6) & 0x1))
  {
 
    std::string name = "h_" + nameStart + "_" + m_allChan1dName;
    std::string title = categoryTitle + " " + dataTypeTitle + " "  + m_allChan1dTitle;
    yaxis = axisLabel;
    xaxis = "Chamber";
    int nxbins  = 26146;// 4 layers, 192 channels each, with 32 chambers + 2 "extra" chambers" 
    float nxmin = -16; // -1  (for EC)
    float nxmax = 16; // 1 (for EA)
 
    TH1F * allChan1dHistX = new TH1F((name+"X").c_str(), (title+ " - Precision strips").c_str(),
        nxbins,nxmin,nxmax);
    allChan1dHistX->GetXaxis()->SetTitle(xaxis.c_str());
    allChan1dHistX->GetYaxis()->SetTitle(yaxis.c_str());
 
    std::string allChan1dPath = getFullPath( getGeoPath(), "FullView1d", parDir);
    MonGroup monGroup( this, allChan1dPath, run, ATTRIB_MANAGED );
    ATH_MSG_DEBUG( "Registering " << name  );
    if (!monGroup.regHist(allChan1dHistX).isSuccess())
    {
      ATH_MSG_ERROR( "failed to register " << name  );
      allGood = false;
    }       
    else
      histCollection->allChan1dHistX = allChan1dHistX;
 
    nxbins = 6562;
 
    TH1F * allChan1dHistY = new TH1F((name+"Y").c_str(), (title + " - Transverse strips").c_str(),
        nxbins,nxmin,nxmax);
    allChan1dHistY->GetXaxis()->SetTitle(xaxis.c_str());
    allChan1dHistY->GetYaxis()->SetTitle(yaxis.c_str());
 
    ATH_MSG_DEBUG( "Registering " << name  );
    if (!monGroup.regHist(allChan1dHistY).isSuccess())
    {
      ATH_MSG_ERROR( "failed to register " << name  );
      allGood = false;
    }       
    else
      histCollection->allChan1dHistY = allChan1dHistY;
 
 
  }
 
  //All channels 2d view
  if(m_makeAllChan2dHists && !((toSkip>>6) & 0x1))
  {
 
    std::string name = "h_" + nameStart + "_" + m_allChan2dName;
    std::string title = categoryTitle + " " + dataTypeTitle + " " + m_allChan2dTitle;
    //yaxis = "sector  + 0.2 * (layer - 1) + 0.1";     
    yaxis = "Sector/Layer";
    xaxis = "Strip Number (Negative for Transverse Strips)";
 
    int nxbins ;
    float nxmin;
    float nxmax;
    int nybins ;
    float nymin;
    float nymax;
    if(histCollection->ignoreY){
      nxbins  = 193;  // 192 bins for precision + 1 extra
      nxmin = 0.; // -1 -> -48 (for transverse)
      nxmax = 193.; // 1 -> 192 (for precision)
      nybins  = 175;  // 32 chambers (16 per side x 5 layers per chamber) + 5 extra
      nymin = -17.; //
      nymax = 18.;  //
    }
    else{
      nxbins  = 242;  // 192 bins for precision, 48 for transverse strips + 2 extra
      nxmin = -49.; // -1 -> -48 (for transverse)
      nxmax = 193.; // 1 -> 192 (for precision)
      nybins  = 175;  // 32 chambers (16 per side x 5 layers per chamber) + 5 extra
      nymin = -17.; //
      nymax = 18.;  //
    }
 
    TH2F * allChan2dHist = new TH2F(name.c_str(), title.c_str(),
        nxbins,nxmin,nxmax,nybins,nymin,nymax);
    allChan2dHist->GetXaxis()->SetTitle(xaxis.c_str());
    allChan2dHist->GetYaxis()->SetTitle(yaxis.c_str());
 
    std::string allChan2dPath = getFullPath( getGeoPath(), "FullView2d", parDir);
    MonGroup monGroup( this, allChan2dPath, run, ATTRIB_MANAGED);
    ATH_MSG_DEBUG( "Registering " << name  );
    if (!monGroup.regHist(allChan2dHist).isSuccess())
    {
      ATH_MSG_ERROR( "failed to register " << name  );
      allGood = false;
    }       
    else
      histCollection->allChan2dHist = allChan2dHist;
 
  }
 
  if(m_makeChamProfs && !((toSkip >> 1) & 0x1) )
  {
    std::string name = "h_" + nameStart + "_" + m_chamProfName;
    std::string title = titleStart + " " + m_chamProfTitle;
    yaxis = "Average " + axisLabel;
    xaxis = "Sector * eta";
    int numSectors = 16;
    TProfile * chamProf= new TProfile(name.c_str(), title.c_str(), 
        numSectors + 1, -16, 17); //hard coding these because its annoying otherwise
    chamProf->GetXaxis()->SetTitle(xaxis.c_str());
    chamProf->GetYaxis()->SetTitle(yaxis.c_str());
 
    ATH_MSG_DEBUG( "Registering " << name  );
    std::string path = getFullPath( getGeoPath(), "Profiles", parDir);
    MonGroup monGroup( this, path, run, ATTRIB_MANAGED);
    if (!monGroup.regHist(chamProf).isSuccess())
    {
      ATH_MSG_ERROR( "failed to register " << name  );
      allGood = false;
    }
    else 
      histCollection->chamProf = chamProf;
  }
  if(m_makeLayHists && !((toSkip >> 2) & 0x1) )
  {
    std::string namePrefix = nameStart + "_" + m_layHistName;
    std::string titlePrefix = titleStart + " " + m_layHistTitle;
    yaxis = axisLabel;
    xaxis = "Channel";
 
    ATH_MSG_DEBUG( "Registering set with prefix"  << namePrefix  );
    histCollection->layHistVect.clear();
    if (!bookLayHists("LayerView", parDir, histCollection->layHistVect,namePrefix, titlePrefix, "Channel", xaxis
                      ,true, histCollection->ignoreY).isSuccess())
    {
      ATH_MSG_ERROR( "failed to register " << namePrefix << " (layer histograms) " );
      allGood = false;
    }
  }
 
  if(m_makeChamSummHists && !((toSkip >> 3) & 0x1) )
  {
    std::string namePrefix = nameStart + "_" + m_chamSummHistName;
    std::string titlePrefix = titleStart + " " + m_chamSummHistTitle;
    yaxis = "";
    xaxis = axisLabel;
 
    ATH_MSG_DEBUG( "Registering set with prefix"  << namePrefix  );
    histCollection->chamSummVect.clear();
    if (!bookChamHists("SecSpectrum", parDir,histCollection->chamSummVect,namePrefix, titlePrefix, xaxis,yaxis,
                       false,histCollection->ignoreY,numBins,lowBound,highBound).isSuccess())
    {
      ATH_MSG_ERROR( "failed to register " << namePrefix 
                     << " (chamber summary histograms) "  );
      allGood = false;
    }
  }
 
  if(m_makeChamHists && !((toSkip >> 7) & 0x1) )
  {
    std::string namePrefix = nameStart + "_" + m_chamHistName;
    std::string titlePrefix = titleStart + " " + m_chamHistTitle;
    yaxis = "";
    xaxis = axisLabel;
 
    ATH_MSG_DEBUG( "Registering set with prefix"  << namePrefix  );
    histCollection->chamHistVect.clear();
    if (!bookChamHists("SectorView", parDir,histCollection->chamHistVect,namePrefix, titlePrefix, xaxis,yaxis,
                       true,histCollection->ignoreY).isSuccess())
    {
      ATH_MSG_ERROR( "failed to register " << namePrefix 
                     << " (chamber summary histograms) "  );
      allGood = false;
    }
  }
 
  if(m_makeLaySummHists && !((toSkip >> 4) & 0x1) )
  {
    std::string namePrefix = nameStart + "_" + m_laySummHistName;
    std::string titlePrefix = titleStart + " " + m_laySummHistTitle;
    yaxis = "";
    xaxis = axisLabel;
 
    ATH_MSG_DEBUG( "Registering set with prefix" << namePrefix  );
    histCollection->laySummVect.clear();
    if (!bookLayHists("LaySpectrum", parDir, histCollection->laySummVect,
                      namePrefix, titlePrefix, xaxis,yaxis,
                      false,histCollection->ignoreY,numBins,lowBound,highBound).isSuccess())
    {
      ATH_MSG_ERROR( " Failed to register " << namePrefix << " (Layer summary hists) " );
      allGood = false;
    }
  }
  if(allGood)
    return StatusCode::SUCCESS;
  else 
    return StatusCode::FAILURE;
}//end bookHistCollection

bookHistograms()

StatusCode CscCalibMonToolSlope::bookHistograms ( )

virtual

Books all histograms not retrieved driectly from CscCalcSlope.

Reimplemented from CscCalibMonToolBase.

Definition at line 83 of file CscCalibMonToolSlope.cxx.

{
  ATH_CHECK( CscCalibMonToolBase::bookHistograms() );
  ATH_MSG_DEBUG( "CscCalibMonToolSlope : in bookHistograms()"  );
 
  if (newRunFlag())
  {
    std::string name,title,xaxis,yaxis;
    int highbound,lowbound,nbins;
 
    std::string geoPath = getGeoPath();
    std::string path = getFullPath(geoPath, "Misc", "");
    MonGroup monGroup(this, path, run, ATTRIB_MANAGED );
 
    //num bad histograms
    name = "h_csc_calib_numSignificant";
    title = "Number of significant results.";
    xaxis = "Catagory";
    yaxis = "Num channels with bad value.";
    lowbound = 1;
    highbound = 8;
    m_h_numBad = new TH1I(name.c_str(),title.c_str(),highbound-lowbound,lowbound,highbound);
    m_h_numBad->GetYaxis()->SetTitle(yaxis.c_str());     
    m_h_numBad->GetXaxis()->SetTitle(xaxis.c_str());
    m_h_numBad->GetXaxis()->SetBinLabel(m_slopeBadBin,"slope diff");
    m_h_numBad->GetXaxis()->SetBinLabel(m_interceptBadBin,"intercept diff");
    m_h_numBad->GetXaxis()->SetBinLabel(m_chi2BadBin,"chi^2/ndf ");
    m_h_numBad->GetXaxis()->SetBinLabel(m_peaktBadBin,"Peaking Time Diff");
    m_h_numBad->GetXaxis()->SetBinLabel(m_fracBadBin,"Fractional Deviation");
    m_h_numBad->GetXaxis()->SetBinLabel(m_deadBadBin,"New (or fixed) Dead Channel");
    m_h_numBad->GetXaxis()->SetBinLabel(m_missingBadBin,"Num chans w/ no data");
    m_h_numBad->SetFillColor(m_histCol);
    monGroup.regHist(m_h_numBad).ignore();
 
    //--overview histograms-----------------------------------------------------------------
    /*
       name = "h_csc_calib_peaktCompareOverview";
 
 
       title = "Differences between measured peaking time and values stored in condtions database";
       xaxis = "Difference (ns)";
       yaxis = "";
       lowbound = -10;
       highbound = 10;
       nbins = 100;
       m_h_peaktCompareOverview = new TH1F(name.c_str(),title.c_str(),nbins,lowbound,highbound);
       m_h_peaktCompareOverview->GetXaxis()->SetTitle(xaxis.c_str());
       m_h_peaktCompareOverview->GetYaxis()->SetTitle(yaxis.c_str());     
       m_h_peaktCompareOverview->SetFillColor(m_histCol);
       sc = monGroup.regHist(m_h_peaktCompareOverview);
 
       name = "h_csc_calib_slopeCompareOverview";
       title = "Differences between measured slope  and values stored in condtions database";
       xaxis = "Difference (fC/ADC)";
       yaxis = "";
       lowbound = -10;
       highbound = 10;
       nbins = 100;
       m_h_slopeCompareOverview = new TH1F(name.c_str(),title.c_str(),nbins,lowbound,highbound);
       m_h_slopeCompareOverview->GetXaxis()->SetTitle(xaxis.c_str());
       m_h_slopeCompareOverview->GetYaxis()->SetTitle(yaxis.c_str());     
       m_h_slopeCompareOverview->SetFillColor(m_histCol);
       sc = monGroup.regHist(m_h_slopeCompareOverview);
 
       name = "h_csc_calib_interceptOverview";
       title = "Intercepts";
       xaxis = "Intercept (ADC count)";
       yaxis = "";
       lowbound = 0;
       highbound = 10;
       nbins = 100;
       m_h_interceptOverview = new TH1F(name.c_str(),title.c_str(),nbins,lowbound,highbound);
       m_h_interceptOverview->GetXaxis()->SetTitle(xaxis.c_str());
       m_h_interceptOverview->GetYaxis()->SetTitle(yaxis.c_str());     
       m_h_interceptOverview->SetFillColor(m_histCol);
       sc = monGroup.regHist(m_h_interceptOverview);
 
       name = "h_csc_calib_chi2Overview";
       title = "chi^2/ndf for slope fits";
       xaxis = "chi^2/ndf";
       yaxis = "";
       lowbound = 0;
       highbound = 10;
       nbins = 100;
       m_h_chi2Overview = new TH1F(name.c_str(),title.c_str(),nbins,lowbound,highbound);
       m_h_chi2Overview->GetXaxis()->SetTitle(xaxis.c_str());
       m_h_chi2Overview->GetYaxis()->SetTitle(yaxis.c_str());     
       m_h_chi2Overview->SetFillColor(m_histCol);
       sc = monGroup.regHist(m_h_chi2Overview);
     */
    name = "h_csc_calib_deadOverview";
    title = "Number of dead channels";
    lowbound = 1;
    highbound = 5;
    nbins = 4;
    m_h_deadOverview = new TH1F(name.c_str(),title.c_str(),nbins,lowbound,highbound);
    m_h_deadOverview->GetXaxis()->SetBinLabel(m_totalLiveBin,"Total Live channels");
    m_h_deadOverview->GetXaxis()->SetBinLabel(m_totalDeadBin,"Total Dead channels");
    m_h_deadOverview->GetXaxis()->SetBinLabel(m_newLiveBin,"New Live Channels");
    m_h_deadOverview->GetXaxis()->SetBinLabel(m_newDeadBin,"New Dead Channels");
    m_h_deadOverview->SetFillColor(m_histColAlert);
    monGroup.regHist(m_h_deadOverview).ignore();
 
    name = "h_csc_calib_slopeMissingChans";
    title = "Number of dead channels";
    xaxis = "Channel (Hash ID)";
    yaxis = "";
    lowbound = 0;
    highbound = m_maxHashId+1;
    nbins = m_maxHashId+1;
    m_h_slopeMissingChans = new TH1F(name.c_str(),title.c_str(),nbins,lowbound,highbound);
    m_h_slopeMissingChans->GetXaxis()->SetTitle(xaxis.c_str());
    m_h_slopeMissingChans->GetYaxis()->SetTitle(yaxis.c_str());     
    m_h_slopeMissingChans->SetFillColor(m_histColAlert);
    monGroup.regHist(m_h_slopeMissingChans).ignore();
 
 
    std::string peaktDataName        = "peakt";
    std::string peaktDataTitle       = "Peaking Time";
    std::string peaktSubDir          = "Peakt";
 
    std::string slopeDataName        = "slope";
    std::string slopeDataTitle       = "Pulser Gain Slope";
    std::string slopeSubDir          = "Slope";
    
    std::string slopeRatioDataName        = "slopeRatio";
    std::string slopeRatioDataTitle       = "Ratio of N : N+1 Channel Slopes";
    std::string slopeRatioSubDir          = "SlopeRatio";
 
    std::string interceptDataName    = "intercept";  
    std::string interceptDataTitle    = "Intercept";
    std::string interceptSubDir      = "Intercept";
 
    std::string chi2DataName         = "chi2";
    std::string chi2DataTitle        = "Chi^2/ndf for gain slope fit";
    std::string chi2SubDir           = "Chi2";
 
    std::string deadDataName         = "dead";
    std::string deadDataTitle        = "Dead";
    std::string deadSubDir           = "Dead";
 
    std::string fitResDataName         = "fitRes";
    std::string fitResDataTitle        = "Fit Return Value";
    std::string fitResSubDir           = "FitResult";
 
    //Set naming parameters for histogram category names
    std::string newCatName       = "new";
    std::string newCatTitle      = "New";
 
    std::string oldCatName       = "old";
    std::string oldCatTitle      = "COOL";
 
    std::string diffCatName      = "diff";
    std::string diffCatTitle     = "Difference Between New and COOL";
 
    //axis info
    std::string peaktAxisLabel = "Peaking Time (ns)";
    std::string peaktDiffAxisLabel = "Peaking Time Difference (ns)";
    int peaktNumBins = 100;
    float peaktLowBound = 0;
    float peaktHighBound = 100;
 
    std::string slopeAxisLabel = "Gain (fC/ADC)";
    std::string slopeDiffAxisLabel = "Gain Difference (fC/ADC)";
    int slopeNumBins =300;
    float slopeLowBound = 0;
    float slopeHighBound = 5;
    
    std::string slopeRatioAxisLabel = "Ratio of N/(N+1) channel";
    int slopeRatioNumBins = 500;
    float slopeRatioLowBound = 0;
    float slopeRatioHighBound = 5;
 
    std::string interceptAxisLabel = "Intercept (ADC counts)";
    int interceptNumBins = 200;
    float interceptLowBound = -100;
    float interceptHighBound = 100;
 
    std::string chi2AxisLabel = "Chi^2/ndf";
    int chi2NumBins = 1000;
    float chi2LowBound = 0;
    float chi2HighBound = 3000; 
 
    std::string deadAxisLabel = "Is Dead";
    int deadNumBins = 3;
    float deadLowBound = -1.5;
    float deadHighBound = 1.5;
 
    std::string fitResAxisLabel = "Fit Return Value";
    int fitResNumBins =10000;
    float fitResLowBound = 0;
    float fitResHighBound = 10000;
 
    //Initialize histogram collections
    m_peaktNewColl = new HistCollection(m_maxHashId +1, m_maxHashId +1);
    m_peaktNewColl->ignoreY = false;
    m_peaktOldColl = new HistCollection(m_maxHashId +1);
    m_peaktOldColl->ignoreY = false;
    m_peaktDiffColl = new HistCollection(m_maxHashId +1);
    m_peaktDiffColl->ignoreY = false;
 
 
    if(m_doNeighborRatios){
      m_slopeRatioColl = new HistCollection(m_maxHashId +1);
      m_slopeRatioColl->ignoreY = true;
    }
 
    m_slopeNewColl = new HistCollection(m_maxHashId +1, m_maxHashId +1);
    m_slopeNewColl->ignoreY = true;
    m_slopeOldColl = new HistCollection(m_maxHashId +1);
    m_slopeOldColl->ignoreY = true;
    m_slopeDiffColl = new HistCollection(m_maxHashId +1);
    m_slopeDiffColl->ignoreY = true;
 
    m_interceptColl = new HistCollection(m_maxHashId +1, m_maxHashId +1);
    m_interceptColl->ignoreY = true;
 
    m_chi2Coll = new HistCollection(m_maxHashId +1);
    m_chi2Coll->ignoreY = true;
 
 
    m_deadNewColl = new HistCollection(m_maxHashId +1, m_maxHashId +1);
    m_deadNewColl->ignoreY = false;
    m_deadDiffColl = new HistCollection(m_maxHashId +1,m_maxHashId +1);
    m_deadDiffColl->ignoreY = false;
 
    m_fitResColl = new HistCollection(m_maxHashId +1);
    m_fitResColl->ignoreY = true;
 
    //Set subdirectory in monitoring root file
 
    //initialize, name, and book histograms in histogram collections using the bookHistCollection()
    //function
 
    ATH_CHECK(  bookHistCollection(m_peaktNewColl, peaktDataName, peaktDataTitle, newCatName, 
                                   newCatTitle, peaktAxisLabel, peaktNumBins, peaktLowBound, peaktHighBound, peaktSubDir) );
 
    ATH_MSG_DEBUG( "Registering peaktOldColl"  );
    ATH_CHECK( bookHistCollection(m_peaktOldColl, peaktDataName, peaktDataTitle, oldCatName, oldCatTitle,
                                  peaktAxisLabel, peaktNumBins, peaktLowBound, peaktHighBound, peaktSubDir) );
 
    ATH_MSG_DEBUG( "Registering peaktDiffColl"  );
    ATH_CHECK( bookHistCollection(m_peaktDiffColl, peaktDataName, peaktDataTitle, diffCatName, diffCatTitle,
                                  peaktDiffAxisLabel, peaktNumBins, peaktLowBound, peaktHighBound, peaktSubDir) );
 
    ATH_MSG_DEBUG( "Registering slopeRatioColl"  );
    ATH_CHECK( bookHistCollection(m_slopeNewColl, slopeDataName, slopeDataTitle, newCatName, 
                                  newCatTitle, slopeAxisLabel, slopeNumBins, slopeLowBound, slopeHighBound, slopeSubDir) );
 
    ATH_MSG_DEBUG( "Registering slopeNewColl"  );
    ATH_CHECK( bookHistCollection(m_slopeRatioColl, slopeRatioDataName, slopeRatioDataTitle, "", 
                                  "", slopeRatioAxisLabel, slopeRatioNumBins, slopeRatioLowBound, slopeRatioHighBound, slopeRatioSubDir) );
 
    ATH_MSG_DEBUG( "Registering slopeOldColl"  );
    ATH_CHECK( bookHistCollection(m_slopeOldColl, slopeDataName, slopeDataTitle, oldCatName, oldCatTitle,
                                  slopeAxisLabel, slopeNumBins, slopeLowBound, slopeHighBound, slopeSubDir) );
 
    ATH_MSG_DEBUG( "Registering slopeDiffColl"  );
    ATH_CHECK( bookHistCollection(m_slopeDiffColl, slopeDataName, slopeDataTitle, diffCatName, diffCatTitle,
                                  slopeDiffAxisLabel, slopeNumBins, slopeLowBound, slopeHighBound, slopeSubDir) );
 
    ATH_MSG_DEBUG( "Registering " << interceptDataTitle  );
    ATH_CHECK( bookHistCollection(m_interceptColl, interceptDataName, interceptDataTitle, "",
                                  "", interceptAxisLabel, interceptNumBins, interceptLowBound, interceptHighBound, 
                                  interceptSubDir) );
 
    ATH_CHECK( bookHistCollection(m_chi2Coll, chi2DataName, chi2DataTitle, "", "",
                                  chi2AxisLabel, chi2NumBins, chi2LowBound, chi2HighBound, chi2SubDir) );
 
    ATH_CHECK(  bookHistCollection(m_deadNewColl, deadDataName, deadDataTitle, newCatName, newCatTitle,
                                   deadAxisLabel, deadNumBins, deadLowBound, deadHighBound, deadSubDir) );
    
    ATH_CHECK( bookHistCollection(m_fitResColl, fitResDataName, fitResDataTitle, "", "",
                                  fitResAxisLabel, fitResNumBins, fitResLowBound, fitResHighBound, fitResSubDir) );
 
  }
  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 1179 of file ManagedMonitorToolBase.cxx.

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

bookHists()

StatusCode ManagedMonitorToolBase::bookHists ( )

virtualinherited

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

Implements IMonitorToolBase.

Definition at line 646 of file ManagedMonitorToolBase.cxx.

{
   // The Run/LumiBlock numbers are not set when beginRun() is called.  Therefore,
   // book histograms on the first call to fillHists(), which is called from execute().
   return StatusCode::SUCCESS;
}

bookLayHists()

StatusCode CscCalibMonToolBase::bookLayHists ( const std::string & histTypeDir, const std::string & parTypeDir, std::vector< TH1F * > & vector, const std::string & namePrefix, const std::string & titlePrefix, const std::string & xaxis, const std::string & yaxis, bool chanView = true, bool ignoreY = false, unsigned int numBins = 100, float lowBound = 0, float highbound = 100 )

protectedvirtualinherited

Books a vector of histograms where each one corresponds to a layer of the CSC secbers.

Parameters

histTypeDir	The subdirectory where the histogram type should be stored (e.g "layerOverview")
parTypeDir	The subdirectory where the parameter type (e.g ped, noise,etc)
namePrefix	Something to put in front of the name. Rest is based on layer.
titlePrefix	String to append to the front of the title. Rest is based on layer.
xaxis	Title for x-axis.
yaxis	Title for y-axis.
chanView	If true, x-axis num-bins will be number of channels of a given layer. numbins, highBound, and lowBound will be ignored.
ignoreY	Do not initialize histograms from the transverse direction.
numBins	number of bins for each histoto
lowBound	lower bound for histogram x-axis
highBound	higher bound for histogram x-axis

Definition at line 431 of file CscCalibMonToolBase.cxx.

{
  //Book a set of histograms, one for each layer.
  //chanView = true ignores numBins and bounds and makes x-axis based on channel ids
  //ignore Y = true skips transverse direction strips 
 
  //unsigned int numStrips;
  int stationSize, stationPhi, stationEta, sector;
  std::string stationName;
  std::string orientationName = "prec";
  std::string orientationTitle = "Precision Direction";
 
  int numHists = 32 * ( (ignoreY) ? 4 : 8);
  histVector.resize(numHists,nullptr); 
 
  ATH_MSG_DEBUG( "Allocated space for " << numHists << " histograms" );
 
  const std::vector<Identifier> & ids = m_idHelperSvc->cscIdHelper().idVector();
  for(const auto & thisChamberId:ids)
  {
    IdentifierHash chamHash;
    m_idHelperSvc->cscIdHelper().get_module_hash(thisChamberId,chamHash);
    ATH_MSG_DEBUG( "Booking histograms for chamber with hash " << (int)chamHash  );
 
    stationSize = m_idHelperSvc->cscIdHelper().stationName(thisChamberId); 
    stationName = m_idHelperSvc->cscIdHelper().stationNameString(stationSize);
    stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(thisChamberId);
    stationEta = m_idHelperSvc->cscIdHelper().stationEta(thisChamberId); 
    sector = getSector(stationPhi,stationSize);
    for(unsigned int orientationItr = 0; orientationItr < 2; orientationItr++)
    {
      if(orientationItr ==1)
      {
        if(ignoreY)  //skip non precision strips
          continue; 
        if(chanView) //Base bin labels on orientation
        {
          numBins = 48;
          highBound = 49;
          lowBound = 1;
        }
        orientationName = "trans";
        orientationTitle = "Transverse Direction";
      }
      else
      {
        if(chanView)
        {
          numBins = 192;
          highBound = 193;
          lowBound = 1;
        }
        orientationName = "prec";
        orientationTitle = "Precision Direction";
      }
 
      for(unsigned int layItr = 1; layItr <= 4; layItr++)
      {
        ATH_MSG_VERBOSE( "Storing a hist on orientation " << orientationItr 
                         << " With highbound/lowbound/nbins "  
                         << highBound << "/" << lowBound << "/" << numBins  );
 
        std::stringstream nameStream;
        nameStream.setf(std::ios::right, std::ios::adjustfield);
        nameStream << namePrefix; 
        nameStream << "_" << orientationName <<  "_eta_";
        nameStream << ((stationEta == 1) ? "1" : "0");
        nameStream << "_sector_" << std::setw(2) << std::setfill('0') <<  sector;
        nameStream << "_layer_"  << layItr; 
 
        std::stringstream titleStream;
        titleStream << titlePrefix << ", " << orientationTitle; 
        titleStream << ", Sector " << sector;
        titleStream <<", Eta " << stationEta;
        titleStream << ", Layer " << layItr;
 
        ATH_MSG_VERBOSE( "Storing " << nameStream.str() << " with title "
                         << titleStream.str() << "On orientation " << orientationItr << " With highbound/lowbound/nbins "  << highBound << "/" << lowBound << "/" << numBins  );
 
        TH1F* hist = new TH1F(nameStream.str().c_str(), titleStream.str().c_str(), 
            numBins, lowBound, highBound);
        hist->GetXaxis()->SetTitle(xaxis.c_str());
        hist->GetYaxis()->SetTitle(yaxis.c_str());
        hist->SetFillColor(m_histCol);
 
        int layIndex = getLayIndex(orientationItr,stationEta,sector,layItr);
 
        //Lets 
        std::string geoPath = getGeoPath(stationEta, sector,  layItr, orientationItr);
        std::string path = getFullPath(geoPath, histTypeDir, parDir);
        MonGroup monGroup( this, path ,run, ATTRIB_MANAGED);
 
 
        if(!monGroup.regHist(hist).isSuccess())
        { 
          ATH_MSG_FATAL( "Failed to register " << nameStream.str() 
                         << " with layIndex" << layIndex  );
          return StatusCode::FAILURE;    
        }
        else
        {
          ATH_MSG_DEBUG( "Succesfully registered histogram with layIndex " 
                         << layIndex  <<" and name " << hist->GetName()  );
          histVector[layIndex] = hist;
        }
      }//end layer loop
    }//End orientation loop        
  }//End chamber loop
  return StatusCode::SUCCESS;
}//end bookLayHists

checkHists()

StatusCode CscCalibMonToolBase::checkHists ( bool fromFinalise )

virtualinherited

Standard function for a ManagedMonitorToolBase.

Not used. Just expected to be here

Reimplemented from ManagedMonitorToolBase.

Definition at line 745 of file CscCalibMonToolBase.cxx.

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

copyDataToHists()

StatusCode CscCalibMonToolBase::copyDataToHists ( HistCollection * histCollection )

protectedvirtualinherited

Fills the histograms in the histCollection based on the data in the std::vector in the HistCollection.

Definition at line 890 of file CscCalibMonToolBase.cxx.

{
 
  //Determine what histograms we'll make:
  bool doSpec         = true; //(histCollection->cscSpec != NULL);
  bool doHash         = (histCollection->hashHist != nullptr         && m_makeHashHists);
  bool doAllChan1d    = (histCollection->allChan1dHistX != nullptr  && histCollection->allChan1dHistY != nullptr   && m_makeAllChan1dHists);
  bool doAllChan2d    = (histCollection->allChan2dHist != nullptr    && m_makeAllChan2dHists);
  bool doLayChan      = (!histCollection->layHistVect.empty()        && m_makeLayHists);
  bool doLaySummary   = (!histCollection->laySummVect.empty()        && m_makeLaySummHists);
  bool doChamAvg      = (histCollection->chamProf != nullptr         && m_makeChamProfs);
  bool doChamChan     = (!histCollection->chamSummVect.empty()       && m_makeChamHists);
  bool doChamSummary  = (!histCollection->chamSummVect.empty()       && m_makeChamSummHists);
  bool doErrors       = (histCollection->errors.size() != 0);    //Changed to a vector, so this
  //                                                                is best way to check at moment
 
  ATH_MSG_DEBUG( "Copying data to hist collection, doing: All Channels (hash view):" 
                 << (int)doHash  
                 << "All Channels (1d view) " << (int)doHash  
                 << "All Channels (2d view) " << (int)doHash  
                 << " layer overview " << (int)doLayChan
                 << " layer spectrum " << (int)doLaySummary
                 << " sector prof " << (int)doChamAvg
                 << " chamber overview " << (int)doChamChan
                 << " chamber spectrum " << (int)doChamSummary
                 );
 
  //For shorter lines:
  std::vector<float> & data = histCollection->data; 
  std::vector<float> & errors = histCollection->errors;
 
  //Loop through all channels, and copy relevant data from channel to histogram.
  const std::vector<Identifier> & ids = m_idHelperSvc->cscIdHelper().idVector();
  for(const auto & thisChamberId:ids)
  {
    IdentifierHash chamHash;
    m_idHelperSvc->cscIdHelper().get_module_hash(thisChamberId,chamHash);
    ATH_MSG_DEBUG( "Copying data to histograms for chamber with hash" << (int)chamHash );
 
    unsigned int stationSize = m_idHelperSvc->cscIdHelper().stationName(thisChamberId); //51 = large, 50 = small
 
    unsigned int stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(thisChamberId);
    int stationEta = m_idHelperSvc->cscIdHelper().stationEta(thisChamberId); 
    unsigned int sector = getSector(stationPhi,stationSize);
    int sectorIndex = sector * stationEta; //Histogram will go from -16 to +16. Bin 0 ignored.
 
 
 
    std::vector<Identifier> stripVect;
    m_idHelperSvc->cscIdHelper().idChannels(thisChamberId,stripVect);
 
    for(const auto & thisStrip:stripVect)
    { 
      unsigned int chamberLayer = m_idHelperSvc->cscIdHelper().chamberLayer(thisStrip);
      if(chamberLayer != 2)
        continue;
      int measuresPhi = m_idHelperSvc->cscIdHelper().measuresPhi(thisStrip);
      if(histCollection->ignoreY && measuresPhi)
        continue;
 
      IdentifierHash stripHash;
      m_idHelperSvc->cscIdHelper().get_channel_hash(thisStrip,stripHash);
      unsigned int layer = m_idHelperSvc->cscIdHelper().wireLayer(thisStrip);    
      unsigned int strip = m_idHelperSvc->cscIdHelper().strip(thisStrip);
      float secLayer = (((float)stationEta*sector) + 0.2 * ((float)layer - 1) + 0.1);     
      float datum = data.at(stripHash);
 
      ATH_MSG_VERBOSE( "Filling all chan for sector: " << sector 
                       << "\tlayer: " << layer << "\tstationEta: " << stationEta
                       << "\tsecLayer: " << secLayer 
                       << "\tdata: " << datum  );
 
      if(doSpec) {
        histCollection->cscSpec[measuresPhi]->Fill(datum);
      }
      if(doHash)
      {
        //copy data array directly to hash histogram with all channels
        histCollection->hashHist->Fill(stripHash,datum);
      }
 
      if(doAllChan1d)
      {
        ATH_MSG_VERBOSE( "Filling 1d chan for sector: " << sector 
                         << "\tlayer: " << layer << "\tstationEta: " << stationEta
                         << "\tsecLayer: " << secLayer 
                         << "\tdata: " << datum  );
        if(measuresPhi){
 
          double modifiedStripNum = 
            (stationEta *sector)
            + (layer-1)*.25
            + ((strip-1) * .25 /(48))
            ;
 
          ATH_MSG_VERBOSE( "Modified strip num: "  << modifiedStripNum  );
          //copy data array directly to 1d histogram with all channels
          histCollection->allChan1dHistY->Fill(
              modifiedStripNum, datum);
        } else {
          double modifiedStripNum = 
            (stationEta *sector)
            + (layer-1)*.25
            + ((strip-1) * .25 /(192 ))
            ;
 
          //copy data array directly to 1d histogram with all channels
          histCollection->allChan1dHistX->Fill(
              modifiedStripNum, datum);
        }
      }
 
      if(doAllChan2d)
      {
        ATH_MSG_VERBOSE( "Filling 2d chan for sector: " << sector 
                         << "\tlayer: " << layer << "\tstationEta: " << stationEta
                         << "\tsecLayer: " << secLayer 
                         << "\tdata: " << datum  );
 
        //copy data array directly to 2d histogram with all channels
        int modifiedStripNum = static_cast<int>(strip) * (measuresPhi ? -1 : 1);
        histCollection->allChan2dHist->Fill(
            modifiedStripNum, secLayer, std::abs(datum));
      }
 
      int layIndex = getLayIndex(measuresPhi,stationEta,sector,layer);
      int chamIndex = getChamIndex(measuresPhi,stationEta,sector);
      if(doLayChan) 
      {
        //Copy values from data array for this layer to layer histogram
        histCollection->layHistVect[layIndex]->SetBinContent(strip,datum);
        if(doErrors)
          histCollection->layHistVect[layIndex]->SetBinError(strip,errors.at(stripHash));
      }
      if(doLaySummary)
      {
        //Histogram values for this layer
        histCollection->laySummVect[layIndex]->Fill(datum);
 
      } 
      if(doChamAvg)
      {  
        //Keeps track of average value for each chamber.
        histCollection->chamProf->Fill(sectorIndex,datum);
      }
      if(doChamSummary)
      {
        //histogram values for this chamber
        histCollection->chamSummVect[chamIndex]->Fill(datum);
      }
      if(doChamChan)
      {
        int shiftedStrip = strip + (layer-1)*( measuresPhi ? 50 : 200);
        //Copy values from data array for this chamber to chamber histogram
        histCollection->chamHistVect[chamIndex]->SetBinContent(shiftedStrip,datum);
        if(doErrors)
          histCollection->chamHistVect[chamIndex]->SetBinError(shiftedStrip,errors.at(stripHash));
      }
    }//end strip loop        
  }//end chamber loop
 
  //probably should put this in its own function at some point
 
  return StatusCode::SUCCESS;
}

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

deregGraph()

StatusCode ManagedMonitorToolBase::deregGraph ( TGraph * g )

virtualinherited

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

Definition at line 1515 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 1507 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 1533 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 1523 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; }

endOfEventsBlockFlag()

bool ManagedMonitorToolBase::endOfEventsBlockFlag ( ) const

inlineprotectedinherited

Definition at line 721 of file ManagedMonitorToolBase.h.

{ return m_endOfEventsBlock; }

endOfLowStatFlag()

bool ManagedMonitorToolBase::endOfLowStatFlag ( ) const

inlineprotectedinherited

Definition at line 722 of file ManagedMonitorToolBase.h.

{ return m_endOfLowStat; }

endOfLumiBlockFlag()

bool ManagedMonitorToolBase::endOfLumiBlockFlag ( ) const

inlineprotectedinherited

Definition at line 723 of file ManagedMonitorToolBase.h.

{ return m_endOfLumiBlock; }

endOfRunFlag()

bool ManagedMonitorToolBase::endOfRunFlag ( ) const

inlineprotectedinherited

Definition at line 724 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 CscCalibMonToolBase::fillHistograms ( const EventContext & ctx )

virtualinherited

Standard function for a ManagedMonitorToolBase.

Not used. For most ManagedMonitorToolBase classes, this would do event-by-event filling of histograms. However we let algorithms in CscCalibAlgs do this for us.

Reimplemented from ManagedMonitorToolBase.

Definition at line 700 of file CscCalibMonToolBase.cxx.

{
 
  ATH_MSG_DEBUG( "CscCalibMonToolBase :: in fillHistograms()"  );
 
  return StatusCode::SUCCESS;
}//end fillHistograms

fillHists()

StatusCode ManagedMonitorToolBase::fillHists ( const EventContext & ctx )

virtualinherited

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

Implements IMonitorToolBase.

Definition at line 656 of file ManagedMonitorToolBase.cxx.

{
 
   if (m_d->m_warnAboutMissingInitialize) {
       m_d->m_warnAboutMissingInitialize = false;
       msg(MSG::WARNING) << "ManagedMonitorToolBase::initialize() never called from reimplementation!" << endmsg;
   }
 
 
   bool isNewEventsBlock = ( m_procNEventsProp > 0  && ((m_nEvents % m_procNEventsProp) == 1) && m_haveClearedLastEventBlock );
   if (isNewEventsBlock) m_haveClearedLastEventBlock = false;
 
   m_newLowStat = false;
   m_newLumiBlock = false;
   m_newRun = false;
 
   m_newLowStatInterval = false;
   m_newMedStatInterval = false;
   m_newHigStatInterval = false;
 
   m_useTrigger = ( (m_triggerChainProp != "" || m_triggerGroupProp != "")  && (!m_trigDecTool.empty()) );
 
   if( m_manager != 0 ) {
     m_newLumiBlock = ( (m_lastLumiBlock != m_manager->lumiBlockNumber()) || m_manager->forkedProcess());
      m_newRun = ( m_lastRun != m_manager->runNumber() );
 
      if(m_newRun) {
         m_newLumiBlock = true;
         isNewEventsBlock = true;
      }
 
      m_newEventsBlock = isNewEventsBlock;
 
      if( m_newLumiBlock ) {
         // check if a new LB interval has started
         // lowest lumiBlockNumber() is 1
         // m_lastLowStatInterval is -1 initially
         int currentLB = m_manager->lumiBlockNumber();
         int LBsLowStat = m_manager->getLBsLowStat();
         int LBsMedStat = m_manager->getLBsMedStat();
         int LBsHigStat = m_manager->getLBsHigStat();
 
         if( LBsLowStat*LBsMedStat*LBsHigStat == 0) {
            msg(MSG::WARNING) << "zero LBs requested for interval" << endmsg;
         }
         else {
            if( ((currentLB-1)/LBsLowStat) != m_lastLowStatInterval ) m_newLowStatInterval = true;
            if( ((currentLB-1)/LBsMedStat) != m_lastMedStatInterval ) m_newMedStatInterval = true;
            if( ((currentLB-1)/LBsHigStat) != m_lastHigStatInterval ) m_newHigStatInterval = true;
         }
      }
 
      // Allow inheriting classes the option of using the lastLumiBloc/lastRun values
      // before updating them
   }
 
 
   StatusCode sc0( StatusCode::SUCCESS );
   StatusCode sc1( StatusCode::SUCCESS );
   StatusCode sc2( StatusCode::SUCCESS );
   StatusCode sc3( StatusCode::SUCCESS );
 
   // Set end of LowStat, LumiBlock and Run variables
   // These are needed to be used in procHistograms().
   m_endOfEventsBlock = m_newEventsBlock;
   m_endOfLowStat = m_newLowStatInterval;
   m_endOfLumiBlock = m_newLumiBlock;
   m_endOfRun = m_newRun;
 
   // just duplicates m_newLowStatInterval
   m_newLowStat = m_newLowStatInterval; 
 
   if( m_newEventsBlock || m_newLumiBlock || m_newRun ) {
     ATH_MSG_DEBUG("Interval transition processing");
      // Process histograms from the previous lumiBlock/run
      if( m_nEvents != 1 ) {
         m_d->benchPreProcHistograms();
         sc0 = procHistograms();
         m_d->benchPostProcHistograms();
      }
      // Re-book new histograms
      m_d->benchPreBookHistograms();
 
      if (!m_bookHistogramsInitial) {
          sc1 = bookHistograms();
          m_bookHistogramsInitial = true;
      } else {
          std::vector<Interval_t> intervals_to_process;
          if (m_newEventsBlock) intervals_to_process.push_back(eventsBlock);
          if (m_newLumiBlock) intervals_to_process.push_back(lumiBlock);
          if (m_newLowStatInterval) intervals_to_process.push_back(lowStat);
          if (m_newRun) intervals_to_process.push_back(run);
          for (const auto interval: intervals_to_process) {
            sc1 = regManagedHistograms(m_templateHistograms[interval]);     
            sc1 = regManagedGraphs(m_templateGraphs[interval]);
            sc1 = regManagedTrees(m_templateTrees[interval]);
          }
      }
      for (const auto& interval: std::vector<Interval_t>{ eventsBlock, lumiBlock, lowStat, run }) {
    for (const auto& it: m_templateHistograms[interval]) {
      // is histogram too small in x axis for LB range?
      if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
        //ATH_MSG_WARNING("We are rebinning for " << it.m_templateHist->GetName());
        while ( it.m_templateHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
          it.m_templateHist->LabelsInflate("X");
        }
      }
    }
        for (auto& it: m_templateEfficiencies[interval]) {
      if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
        // get the underlying passed and total TH1's from the TEfficiency
        TH1* passedHist = it.m_templateHist->GetCopyPassedHisto();
        TH1* totalHist = it.m_templateHist->GetCopyTotalHisto();
        // inflate them until they exceed the lumi-block number
        while (passedHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
          passedHist->LabelsInflate("X");
          totalHist->LabelsInflate("X");
              }
        // Replace them in the TEfficiency. First one has force ("f") option, since the 
        // histograms will not be consistent. This is corrected in the next line, so we
        // do check for consistency then.
        it.m_templateHist->SetPassedHistogram(*passedHist, "f");
        it.m_templateHist->SetTotalHistogram(*totalHist, " ");
        delete passedHist; // not owned by THistSvc, so need to be deleted.
        delete totalHist;
      }
        }
      }
 
      if (auto streamname = dynamic_cast<OfflineStream*>(streamNameFunction())) {
    streamname->updateRunLB();
      }
      
      sc3 = bookHistogramsRecurrent( );
      
      m_d->benchPostBookHistograms();
 
   }//end if new RUN/LB/Block
 
   // check filters
   bool filterresult(true);
   if (! m_DQFilterTools.empty()) {
     ToolHandleArray<IDQFilterTool>::const_iterator ifilter(m_DQFilterTools.begin()), filterend(m_DQFilterTools.end());
     for (; filterresult && (ifilter != filterend);
      ++ifilter) {
       filterresult = (filterresult && (*ifilter)->accept(ctx));
     }
   }
   
 
   // ...and fill as normal
   if(filterresult &&
      (!m_useTrigger
       || (m_vTrigChainNames.size()>0 && trigChainsArePassed(m_vTrigChainNames))
       || (m_vTrigGroupNames.size()>0 && trigChainsArePassed(m_vTrigGroupNames))) ) {
     ATH_MSG_DEBUG("Passed trigger, presumably");
      m_d->benchPreFillHistograms();
      fillHistograms(ctx).ignore();
      m_haveClearedLastEventBlock = true;
      m_d->benchPostFillHistograms();
      ++m_nEvents;
   } else { ATH_MSG_DEBUG("Failed trigger, presumably"); }
 
   ++m_nEventsIgnoreTrigger;
   if( m_newLumiBlock && (m_nEventsIgnoreTrigger != 1) ) {
      ++m_nLumiBlocks;
   }
   if( m_manager != 0 ) {
      m_lastRun = m_manager->runNumber();
      if( m_newLumiBlock ) {
         m_lastLumiBlock = m_manager->lumiBlockNumber();
 
         int LBsLowStat = m_manager->getLBsLowStat();
         int LBsMedStat = m_manager->getLBsMedStat();
         int LBsHigStat = m_manager->getLBsHigStat();
         if( LBsLowStat*LBsMedStat*LBsHigStat > 0) {
            if( m_newLowStatInterval ) m_lastLowStatInterval = (m_lastLumiBlock-1)/LBsLowStat;
            if( m_newMedStatInterval ) m_lastMedStatInterval = (m_lastLumiBlock-1)/LBsMedStat;
            if( m_newHigStatInterval ) m_lastHigStatInterval = (m_lastLumiBlock-1)/LBsHigStat;
         }
      }
   }
 
   return StatusCode::SUCCESS;
}

finalHists()

StatusCode ManagedMonitorToolBase::finalHists ( )

virtualinherited

Calls procHists( true, true, true ).

Implements IMonitorToolBase.

Definition at line 1153 of file ManagedMonitorToolBase.cxx.

{
 
   // This assumes that the end of a file will naturally end a run, which is not always true.
   // A merging application run afterwards should be able to put parts of a run together.
   if( m_nEvents != 1 ) {
     m_d->benchPreProcHistograms();
 
     // Set end flags for the LowStat, LumiBlock and Run variables.
     // This is needed to be used in the procHistograms method below.
     m_endOfEventsBlock = true;
     m_endOfLowStat = true;
     m_endOfLumiBlock = true;
     m_endOfRun = true;
 
     StatusCode sc = procHistograms();
 
     m_d->benchPostProcHistograms();
     return sc;
   }
   return StatusCode::SUCCESS;
}

finalize()

StatusCode CscCalibMonToolSlope::finalize ( )

virtual

Delete slope sepcific values.

Also calls CscCalibMonToolBase::finalize

Reimplemented from CscCalibMonToolBase.

Definition at line 49 of file CscCalibMonToolSlope.cxx.

{
  ATH_MSG_DEBUG( "Slope Finalizing " );
  delete m_slopeNewColl;
  delete m_slopeOldColl;
  delete m_slopeDiffColl;
  delete m_interceptColl;
  delete m_chi2Coll;
  delete m_deadNewColl;
  delete m_deadDiffColl;
  delete m_peaktNewColl;
  delete m_peaktOldColl;
  delete m_peaktDiffColl;
 
  return CscCalibMonToolBase::finalize();
}

findDeadChannels()

StatusCode CscCalibMonToolSlope::findDeadChannels ( const CscCalibReportSlope & slopeReport )

private

Look for dead channels.

Definition at line 867 of file CscCalibMonToolSlope.cxx.

{//This function has grown a bit unwieldly, and duplicates info in sets and arrays. Can this be merged?
 
  SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
  const CscCondDbData* readCdo{*readHandle};
 
  //****Find Dead channels
  IdContext channelContext = m_idHelperSvc->cscIdHelper().channel_context(); 
 
  std::set <int> newDead, newUndead;
 
  const std::set <int>& pulsedChambers = slopeReport.getPulsedChambers();
  if(pulsedChambers.empty())
  {
    ATH_MSG_ERROR( "No pulsed chambers stored in slopeReport! Skipping dead channel collecting!"  );
    return StatusCode::RECOVERABLE;
  }
 
  const std::map <int,TProfile*>& ampProfs = slopeReport.getAmpProfs();
  if(ampProfs.empty())
  {
    ATH_MSG_ERROR( "There are no amplitude profiles in the slope report! Can't find dead chans." );
    return StatusCode::RECOVERABLE;
  }
 
  std::map <int,TProfile*>::const_iterator profItr = ampProfs.begin();
 
  int pulserLevel = profItr->first;
  ATH_MSG_INFO( "Looking for dead channels. Lowest attenuation level is " 
                << pulserLevel  );
  ATH_MSG_INFO( "Dead channel cutoff is: "<< m_deadADCCutoff   );
 
  if(pulserLevel < m_deadPulserLevelCutoff)
  {//Pulser level is low enough (pulse voltage is high enough) to test for dead channels
 
    const TProfile * ampProf = profItr->second;
    if(!ampProf)
    {
      ATH_MSG_ERROR( "There is no profile for this attenuation level! Skipping dead channel finding!" );
      return StatusCode::RECOVERABLE;
    }
 
    ATH_MSG_DEBUG( "There were " << pulsedChambers.size()
                   << " chambers pulsed."  );
 
    //Prepare dead channel content
    std::vector<float> & currentDeadVals = m_deadNewColl->data;
    std::vector<float> & diffDeadVals = m_deadDiffColl->data;
 
    setArray(currentDeadVals,0,m_maxHashId+1);
    setArray(diffDeadVals,0,m_maxHashId+1);
 
    //Loop through each channel in TProfile (bin = hash + 1), and check value to see
    //if its dead
    float adc, ped;
    bool wasDead, isDead;
    int statusWord;
    for(unsigned int hashItr = 0; hashItr <= m_maxHashId ; hashItr++)
    {
      Identifier id;
      m_idHelperSvc->cscIdHelper().get_id(hashItr,id, &channelContext);
      int chamberLayer = m_idHelperSvc->cscIdHelper().chamberLayer(id);
      IdentifierHash chamberHash;
      m_idHelperSvc->cscIdHelper().get_module_hash(id, chamberHash);
 
      if(chamberLayer == 2 && pulsedChambers.count((int)chamberHash))
      {//This is a good chamber layer and it is a pulsed chamber
 
        ATH_CHECK(readCdo->readChannelStatus(hashItr, statusWord));
        ATH_CHECK(readCdo->readChannelPed   (hashItr, ped       ));
        wasDead = statusWord & 0x1;
 
        adc = ampProf->GetBinContent( hashItr + 1 );
        isDead = ( (adc-ped) < m_deadADCCutoff);
 
        if(isDead && !wasDead)
        {
          ATH_MSG_INFO( "NEW DEAD CHANNEL! Hash: " << hashItr << " ped: " << ped << " adc " << adc << " diff: " << adc-ped  );
          newDead.insert(hashItr);
          m_h_deadOverview->Fill(m_newDeadBin);
          diffDeadVals[hashItr] = 1;
          m_detailedHashIds[hashItr] = true;
        }
        if(!isDead && wasDead)
        {
          ATH_MSG_INFO( "PREVIOUSLY DEAD CHANNEL NOW LIVE! Hash: " << hashItr  );
          newUndead.insert(hashItr);
          m_h_deadOverview->Fill(m_newLiveBin);
          diffDeadVals[hashItr] = -1;
          m_detailedHashIds[hashItr] = true;
        }
 
        if(isDead)
        {
          currentDeadVals[hashItr] = 1;
          m_h_deadOverview->Fill(m_totalDeadBin);
        }
        else
          m_h_deadOverview->Fill(m_totalLiveBin);
 
      }//end if chamberLayer
 
    }//End for(hashItr)
 
    //***Generate histograms
    ATH_MSG_INFO( "Generating dead histograms"  );
    ATH_CHECK( copyDataToHists(m_deadNewColl) );
 
    //ATH_CHECK( copyDataToHists(m_deadDiffColl) );
    ATH_MSG_INFO( "Finished generating dead histograms"  );
 
    //***Fill COOL input file if there are new dead channels******
    if(newDead.size() || newUndead.size())
    {
      ATH_MSG_INFO( "There are " << newDead.size() 
                    << " newly dead channels and " << newUndead.size() 
                    << " newly live channels" );
      std::ofstream  out("deadInfo.cal");
      out <<"00-00 " << newDead.size() + newUndead.size() << " dead_stat END_HEADER\n";
 
      for(const auto & thisDeadChannel:newDead)
      {
        Identifier id;
        m_idHelperSvc->cscIdHelper().get_id(thisDeadChannel,id, &channelContext);
        IdentifierHash chamHash;
        m_idHelperSvc->cscIdHelper().get_module_hash(id, chamHash);
        out << thisDeadChannel << " " << (int)chamHash << " " 
          << m_idHelperSvc->cscIdHelper().show_to_string(id, &channelContext) << " 1\n";
      }
 
      for(const auto undeadChannel : newUndead)
      {
        Identifier id;
        m_idHelperSvc->cscIdHelper().get_id(undeadChannel,id, &channelContext);
        IdentifierHash chamHash;
        m_idHelperSvc->cscIdHelper().get_module_hash(id, chamHash);
        out << undeadChannel << " " << (int)chamHash << " " 
          << m_idHelperSvc->cscIdHelper().show_to_string(id, &channelContext)
          << "0\n";
      } 
      out.close();
    }//end if newDead.size()
 
  }//end if(pulserLevel < cutoff)
  else 
  {
    ATH_MSG_ERROR( "Lowest pulser level isn't low enough to count as a dead channel test. Skipping." );
    return StatusCode::RECOVERABLE;
  }
 
 
  return StatusCode::SUCCESS;
}

genNeighborRatios()

void CscCalibMonToolSlope::genNeighborRatios ( const std::vector< float > & source, std::vector< float > & ratios ) const

private

Generated next neighbor channel ratios of the slopes.

Definition at line 1029 of file CscCalibMonToolSlope.cxx.

                                                                                                            {
  size_t nEntries = source.size();
  if(nEntries != ratios.size()){
    ATH_MSG_ERROR( " in genNeighborRatios, source (" << nEntries << ") and ratio (" << ratios.size() 
                   << ") vectors have different numbers of entries!"  );
    return;
  }
 
  //loop through every channel, taking the ratio between it and the next
  size_t nloops = nEntries -1; //Can't do this to the last channel
  for(size_t cnt=0; cnt < nloops; cnt++){
    ratios[cnt] = source[cnt]/source[cnt+1];
  }
}

get_nEvents()

unsigned int ManagedMonitorToolBase::get_nEvents ( ) const

inlineprotectedinherited

Definition at line 620 of file ManagedMonitorToolBase.h.

                                              {
          return m_nEvents; 
      }

get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const

inlineprotectedinherited

Definition at line 624 of file ManagedMonitorToolBase.h.

                                              {
          return m_procNEventsProp;
      }

getChamIndex()

int CscCalibMonToolBase::getChamIndex ( int measuresPhi, int stationEta, int sector )

protectedvirtualinherited

Produces a unique number for every secber in the detector.

Definition at line 1065 of file CscCalibMonToolBase.cxx.

{
  int chamIndex = measuresPhi*32
    + ((stationEta ==1) ? 16 : 0)
    + (sector-1); 
  return( chamIndex);
}

getEndCap()

std::string CscCalibMonToolBase::getEndCap ( int eta )

protectedinherited

Gets the letter endcap (A or C) for a given eta index (1,-1).

Definition at line 1085 of file CscCalibMonToolBase.cxx.

{
  if(eta ==1)
    return "A";
  if(eta == -1)
    return "C";   
  return "ERROR";
}

getFullPath()

std::string CscCalibMonToolBase::getFullPath ( const std::string & geoPath, const std::string & histTypeDir, const std::string & parTypeDir )

protectedinherited

Geo path creates a directory structure for a histogram based upon its geoPath, the hist type dir (spectrum of values, per-channel values, etc), and the parTypeDir (pedestal, etc).

This provides a centralized, consistent way of generating the paths

Definition at line 1185 of file CscCalibMonToolBase.cxx.

{
  std::stringstream ss; 
 
  ss << m_generic_path_csccalibmonitoring << geoPath;
 
  if(histTypeDir != "") 
    ss << "/" << histTypeDir;
 
  if(parTypeDir != "")
    ss <<  "/" << parTypeDir;
 
  return ss.str();
}

getGeoPath()

std::string CscCalibMonToolBase::getGeoPath ( int eta = -9999, int sector = -9999, int wireLayer = -9999, int measuresPhi = -9999, int channel = -9999 )

protectedinherited

getGeoPath creates a directory structure for a histogram based upon where it is in the CSC geometry.

The user fills the data down as far as they like. For example, just filling in eta and sector will provide a path for a sector-wide histogram. This provides a centralized location to change the layout of the root output file.

Definition at line 1098 of file CscCalibMonToolBase.cxx.

{
  std::stringstream ss;
 
  static const std::string histStr = "/_hists";
  static const std::string errorDir = "/ERROR";
 
  ss << std::setfill('0');//so we can have uniform numbers
 
 
  if( eta == -9999 ) //CSC Wide
  {
    ss << "/CscOverview";
    return ss.str(); 
  }
 
  std::string endCap = getEndCap(eta);
  if(endCap == "ERROR")
  {
    ATH_MSG_ERROR( "Eta " << eta << " is invalid. "  );
    return errorDir;
  }
 
  ss << "/EndCap" << endCap;
 
  if(sector == -9999) //Endcap Histogram
  {
    ss << histStr;
    return ss.str();
  }
 
  if(sector <1 || sector > 16)
  {
    ATH_MSG_ERROR( "Sector " << sector << " is invalid. "  );
    return errorDir;
  }
 
  ss << "/Sector" << std::setw(2) << sector;
 
  if(wireLayer == -9999)//Sector (chamber) wide histrogram
  {
    ss << histStr;
    return ss.str();
  }
 
  if(wireLayer < 1 || wireLayer > 4)
  {
    ATH_MSG_ERROR( "WireLayer " << wireLayer << " is invalid."  );
    return errorDir;
  }
 
  ss << "/Layer" << wireLayer;
 
  if(measuresPhi == -9999)//Layer wide histrogram
  {
    ss << histStr;
    return ss.str();
  }
 
  if(measuresPhi < 0 || measuresPhi > 1)
  {
    ATH_MSG_ERROR( "MeasuresPhi " << measuresPhi << " is invalid."  );
    return errorDir; 
  }
 
  ss << (measuresPhi ? "/Phi" : "/Eta");
  if(channel == -9999) //LayerDirection wide histogram
  {
    /* Channel histograms don't work (too much memory used by meta data tree), so layer is now our most detailed channel. No need for histStr.
       ss << histStr;*/
    return ss.str();
  }
 
  if( channel < 1 || (measuresPhi && channel > 48)  || (!measuresPhi && channel > 192)) 
  {
    ATH_MSG_ERROR( "Channel " << channel << " is invalid for a " << (measuresPhi ? "phi layers" : "eta layer")  );
    return errorDir;
  }
 
 
  ss << "/Channel" << std::setw( measuresPhi ? 2 : 3 ) << channel;
 
  return ss.str();
}//end getGeoPath 

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 1310 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 1300 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 1329 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 1319 of file ManagedMonitorToolBase.cxx.

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

getLayIndex()

int CscCalibMonToolBase::getLayIndex ( int measuresPhi, int stationEta, int sector, int layer )

protectedvirtualinherited

produces a unique number for every layer in the detector

Definition at line 1056 of file CscCalibMonToolBase.cxx.

{
  int layIndex = measuresPhi*32*4
    + ((stationEta ==1) ? 16*4 : 0)
    + (sector-1)*4 
    + layer -1;
  return layIndex;
}

getNewStreamNameFcn()

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

protectedvirtualinherited

Definition at line 2029 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;
}

getSector()

int CscCalibMonToolBase::getSector ( int stationPhi, int stationSize )

protectedvirtualinherited

Produces a sector number from the phi and size of a station.

Definition at line 1073 of file CscCalibMonToolBase.cxx.

{
  //stationSize : 50 = CSS, 51 = CSL
  //Sector 1 : large with athena's stationPhi = 1 (onlinePhi = 0)
  //Sector 2 : small with athenas stationPhi = 1 (onlinePhi = 0)
  //Sector 3 : large with athenas stationPhi = 2 (onlinePhi = 1)
  //etc...
  return(2*stationPhi + 50 - stationSize);
  //return(2*stationPhi + stationSize - 51);
}

handleParameter()

StatusCode CscCalibMonToolSlope::handleParameter ( const CscCalibResultCollection * parVals )

privatevirtual

handleParameter sets things up for the base class procParameter.

It makes decisions based on the parameter being passed in parVals on how to handle the data

Parameters

parVals

Values for a particular parameter

Reimplemented from CscCalibMonToolBase.

Definition at line 374 of file CscCalibMonToolSlope.cxx.

{
  ATH_MSG_DEBUG( "CscCalibMonToolSlope : in handleParameter()"  );
 
  //The whole point of this funciton is to pass the correct histograms and setup info 
  //to CsccalibMonToolBase::procParameter. To organize this, we store the setup info into
  //these structs: 
  ProcSetupInfo simpleSet;
 
  //--setup for this parameter
  std::string parName = parVals->parName();
  /*if(parName == "peakt")
    {
    m_log << MSG::INFO << "Evaluating peaking times" << endmsg;
    simpleSet.dbName = parVals->parName();
    simpleSet.badHist = m_h_numBad;
    simpleSet.badBin = m_peaktBadBin;
    simpleSet.maxDiff = m_peaktMaxDiff;
    simpleSet.overDiff = m_h_peaktCompareOverview;
    simpleSet.overChi2 = m_h_chi2Overview;
    simpleSet.chi2BadBin = m_chi2BadBin;
    simpleSet.doChi2 = false;
    simpleSet.vals = &m_peaktNewColl->data;
    simpleSet.errors = &m_peaktNewColl->errors;
    simpleSet.oldVals = &m_peaktOldColl->data;
    simpleSet.diffs = &m_peaktDiffColl->data;
    simpleSet.missingBadBin = m_missingBadBin;
    simpleSet.missingChans = m_h_slopeMissingChans;
    simpleSet.expectedChannels = m_expectedHashIdsPrec;
    }
   */
  if(parName == "pslope")
  {
    ATH_MSG_INFO( "Evaluating slopes"  );
    simpleSet.dbName = parVals->parName();
    simpleSet.badHist = m_h_numBad;
    simpleSet.badBin = m_slopeBadBin;
    simpleSet.maxDiff = m_slopeMaxDiff;
    simpleSet.overDiff = m_h_slopeCompareOverview;
    simpleSet.overChi2 = m_h_chi2Overview;
    simpleSet.chi2BadBin = m_chi2BadBin;
    simpleSet.chi2Max = m_chi2Max;
    simpleSet.doChi2 = true;
    simpleSet.vals = &m_slopeNewColl->data;
    simpleSet.errors = &m_slopeNewColl->errors;
    simpleSet.oldVals = &m_slopeOldColl->data;
    simpleSet.diffs = &m_slopeDiffColl->data;
    simpleSet.chi2s = &m_chi2Coll->data;
    simpleSet.missingBadBin = m_missingBadBin;
    simpleSet.missingChans = m_h_slopeMissingChans;
    simpleSet.expectedChannels = m_expectedHashIdsPrec;
  }
  else if (parName == "pinter")
  {
    ATH_MSG_INFO( "Evaluating intercepts"  );
    simpleSet.expectedVal = 0;
    simpleSet.badHist = m_h_numBad;
    simpleSet.badBin = m_interceptBadBin;
    simpleSet.maxDiff = m_interceptMax;
    simpleSet.overDiff = m_h_interceptOverview;
    simpleSet.overChi2 = m_h_chi2Overview;
    simpleSet.doChi2 = false;
    simpleSet.vals = &m_interceptColl->data;
    simpleSet.errors = &m_interceptColl->errors;
    simpleSet.oldVals = nullptr ;
    simpleSet.diffs = nullptr ;
    simpleSet.missingBadBin = m_missingBadBin;
    simpleSet.missingChans = m_h_slopeMissingChans;
    simpleSet.expectedChannels = m_expectedHashIdsPrec;
  }
  else
  {
    ATH_MSG_INFO( "CscCalibMonToolSlope : Did not recognize parameter name " 
                  << parName << ". This is usually ok."  );
    return StatusCode::FAILURE;
  }
 
  //Process parameter by filling histograms in simpleSet and allIdsSet structures
  ATH_CHECK( procParameter(parVals,&simpleSet) );
 
 
  if(parName == "peakt")
  {
    ATH_MSG_INFO( "Generating peaking time histograms"  );
 
    ATH_CHECK( copyDataToHists(m_peaktNewColl) &
               copyDataToHists(m_peaktOldColl) &
               copyDataToHists(m_peaktDiffColl) );
  }
  if(parName == "pslope") 
  {
 
    ATH_MSG_INFO( "Generating slope histograms"  );
    
    if(m_doNeighborRatios){
      genNeighborRatios(m_slopeNewColl->data, m_slopeRatioColl->data);
      ATH_CHECK( copyDataToHists(m_slopeRatioColl) );
    }
 
    ATH_CHECK( copyDataToHists(m_slopeNewColl) &
               copyDataToHists(m_slopeOldColl) &
               copyDataToHists(m_slopeDiffColl) &
               copyDataToHists(m_chi2Coll) );
  }
  if(parName == "pinter")
  {
    ATH_MSG_INFO( "Generating intercept histograms"  );
    ATH_CHECK( copyDataToHists(m_interceptColl) );
  }
  return StatusCode::SUCCESS;
}

initialize()

StatusCode CscCalibMonToolSlope::initialize ( )

virtual

Initialize slope sepcific values.

Also calls CscCalibMonToolBase::intialize

Reimplemented from CscCalibMonToolBase.

Definition at line 66 of file CscCalibMonToolSlope.cxx.

{
  m_onlyExpectPrecisionHashIds = true; 
  ATH_CHECK(CscCalibMonToolBase::initialize());
 
  ATH_MSG_DEBUG( "Expected chamber layer is " << m_expectedChamberLayer );
 
  for(unsigned int hash = 0 ; hash <= m_maxHashId; hash++)
  {
    m_fracProfs.push_back(nullptr);
  }
  m_generic_path_csccalibmonitoring = "MUON_CSC_PULSER";
 
  return StatusCode::SUCCESS;
}

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

interfaceID()

const InterfaceID & IMonitorToolBase::interfaceID ( )

inlinestaticinherited

Definition at line 30 of file IMonitorToolBase.h.

{ return IID_IMonitorToolBase; }

intervalEnumToString()

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

staticinherited

Converts a Interval_t to a string of the same name.

Definition at line 452 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 494 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;
}

lbAverageInteractionsPerCrossing()

float ManagedMonitorToolBase::lbAverageInteractionsPerCrossing ( const EventContext & ctx ) const

virtualinherited

Average mu, i.e.

<mu>

Definition at line 1583 of file ManagedMonitorToolBase.cxx.

{
    if (!m_lumiDataKey.empty()) {
        SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
        return lumi->lbAverageInteractionsPerCrossing();
    } else {
        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 ) const

virtualinherited

Average luminosity livefraction.

Definition at line 1648 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_DEBUG("Warning: lbAverageLivefraction() - luminosity not availble (i.e. EnableLumi = False)");
        return -1.0;
    }
    // not reached
}

lbAverageLuminosity()

float ManagedMonitorToolBase::lbAverageLuminosity ( const EventContext & ctx ) const

virtualinherited

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

Definition at line 1617 of file ManagedMonitorToolBase.cxx.

{
    if (!m_lumiDataKey.empty()) {
        SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
        return lumi->lbAverageLuminosity();
    } else {
        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 ) const

virtualinherited

Luminosity block time (in seconds).

Definition at line 1699 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_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 ) const

virtualinherited

Instantaneous number of interactions, i.e.

mu

Definition at line 1598 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_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 ) const

virtualinherited

Instantaneous luminosity.

Definition at line 1632 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_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 ) const

virtualinherited

Average Integrated Luminosity Live Fraction.

Definition at line 1684 of file ManagedMonitorToolBase.cxx.

{
    if (!m_lumiDataKey.empty()) {
        return (lbAverageLuminosity(ctx)*lbDuration(ctx))*lbAverageLivefraction(ctx);
    } else{
        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 ) const

virtualinherited

Livefraction per bunch crossing ID.

Definition at line 1666 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_DEBUG("Warning: livefractionPerBCID() - luminosity retrieved available (i.e. EnableLumi = False)");
        return -1.0;
    }
    // not reached
}

makeFracGraphs()

StatusCode CscCalibMonToolSlope::makeFracGraphs ( const CscCalibReportSlope & slopeReport )

private

Make fractional deviation plots between the gain plot points and the fit.

Definition at line 718 of file CscCalibMonToolSlope.cxx.

{
  ATH_MSG_DEBUG( "CscCalibMonToolSlope : in makeFracGraphs()"  );
  const std::vector<TGraphErrors*>& calGraphs = slopeReport.getCalGraphs();
  if(calGraphs.empty())
  {
    ATH_MSG_ERROR( "No calGraphs in slopeReport. Not going to make fractional deviation"
                   << " plots."  );
    return StatusCode::RECOVERABLE;
  }
 
  //Loop through all channels in geometry:
  const std::vector <Identifier> & ids = m_idHelperSvc->cscIdHelper().idVector();
  for(const auto & thisChamberId:ids)
  {
    ATH_MSG_VERBOSE( "in Chamber loop "  );
    unsigned int stationSize = m_idHelperSvc->cscIdHelper().stationName(thisChamberId); //51 = large, 50 = small
    unsigned int stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(thisChamberId);
    int stationEta = m_idHelperSvc->cscIdHelper().stationEta(thisChamberId);
    unsigned int sector = getSector(stationPhi,stationSize);
 
    std::vector <Identifier> stripVect;
    m_idHelperSvc->cscIdHelper().idChannels(thisChamberId,stripVect);
    for(const auto & thisStrip : stripVect)
    {
      ATH_MSG_VERBOSE( "in strip loop "  );
      IdentifierHash stripHash;
      m_idHelperSvc->cscIdHelper().get_channel_hash(thisStrip,stripHash);
      if(!m_expectedHashIdsPrec.count((int)stripHash)){
        ATH_MSG_VERBOSE( "Skipping hash"  << (int)stripHash  );
        continue;
      }
      ATH_MSG_VERBOSE( "strip hash " << stripHash  );
 
      const TGraphErrors * graph = calGraphs[stripHash];
      if(!graph)
      {
        ATH_MSG_VERBOSE( "SKipping graph"  );
        continue;
      }
      
      TF1 * func = graph->GetFunction("simpleFunc");
      if(!func){
        ATH_MSG_DEBUG( "Could not retrieve function, skipping this graph"  );
        continue;
      }
 
      ATH_MSG_VERBOSE( "Address is " << graph );
      ATH_MSG_VERBOSE( "name is "<< graph->GetName()  );
      ATH_MSG_VERBOSE( "Getting n "  );
 
      int nPoints = graph->GetN();
      ATH_MSG_VERBOSE( "Got n "  );
      //Get identification information
      //Note, we don't ask for measuresPhi because there should be no
      //TGraphs with Y anyways.
      ATH_MSG_VERBOSE( "getting id info " );
      unsigned int layer = m_idHelperSvc->cscIdHelper().wireLayer(thisStrip);
      unsigned int strip = m_idHelperSvc->cscIdHelper().strip(thisStrip);
      ATH_MSG_VERBOSE( "Got strip and layer"  );
      //initialize fractional deviation profile
      ATH_MSG_VERBOSE( "initializing profile "  );
 
      std::stringstream  nameStream;
      nameStream.setf(std::ios::right,std::ios::adjustfield);
      nameStream << "dev_" 
        << "X"   //orientation
        << "_eta_" << stationEta
        << "_sector_" << std::setw (2) << std::setfill ('0') << sector
        << "_layer_" << layer
        << "_strip_" << strip;
      std::stringstream  titleStream;
      titleStream << "Fractional Deviation of Measured ADC From Fit ADC for Precision Direction"
        << ", Sector " << sector
        << ", Eta "     << stationEta
        << ", Layer " << layer
        << ", Strip " << strip;
      TProfile * fracProf 
        = new TProfile(nameStream.str().c_str(), titleStream.str().c_str(), nPoints, 
            1, nPoints +1);
      fracProf->GetXaxis()->SetTitle("Pulser Attenuator Settings in dB (not auscaled axis) ");
      fracProf->GetYaxis()->SetTitle("ADC response"); 
 
      ATH_MSG_VERBOSE( "getting parameters "  );
      float intercept = func->GetParameter(0);
      float slope = func->GetParameter(1);
      ATH_MSG_VERBOSE( "got them "  );
 
      //Loop through points in graph, and compare the adc value and charge
      //to that expected from the fit parameters from the TF1 object
      double adc, db, calcAdc;
      bool isBad = false;
      for(int itr = 0; itr < nPoints; itr++)
      {
        ATH_MSG_VERBOSE( "in point loop on point " << itr );
 
        //Find Fractional Deviation
        graph->GetPoint(itr,db,adc);
        calcAdc = intercept + slope*std::pow(10,db/-20);
        double frac = (adc - calcAdc)/( calcAdc - intercept);
 
        //Test to see if this is a bad result
        ATH_MSG_VERBOSE( "bad result test "  );
        if(frac > m_fracDevMax)
        {
          m_h_numBad->Fill(m_fracBadBin);
          isBad = true;
        }
 
        //test for nan, and put into fracProf 
        if (frac==frac)
        {
          ATH_MSG_VERBOSE( "filling fracProf "  );
          fracProf->Fill(itr +1, frac);     
        }
 
        //Label bin with db amount
        ATH_MSG_VERBOSE( "labeling bin "  );
        std::stringstream  binLabel;
        binLabel << db;    
        fracProf->GetXaxis()->SetBinLabel(itr+1, binLabel.str().c_str());
      }
      ATH_MSG_VERBOSE( "storing fracProf "  );
      //Store fraction graph for later
      if(stripHash > m_maxHashId)
      {
        ATH_MSG_ERROR( "Tried to assign fracProf with stripHash " << stripHash
                       << " when max stripHash is " << m_maxHashId  );
        return StatusCode::RECOVERABLE;
      }
 
      m_fracProfs[stripHash] = fracProf; 
      //Record if this was a bad channel
      if(isBad && ((int)m_numBad <= m_maxDetailedChannels) )
      {
        if(!m_detailedHashIds[stripHash])
        {
          m_numBad++;
          m_detailedHashIds[stripHash] = true;
        }
      }
 
    }//end loop over strips
  }//end loop over chambers
  ATH_MSG_DEBUG( "Finished generating frac graphs"  );
 
  return StatusCode::SUCCESS;
}//end makeFracGraphs

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

{ return m_newEventsBlock; }

newHigStatIntervalFlag()

bool ManagedMonitorToolBase::newHigStatIntervalFlag ( ) const

inlineprotectedinherited

Definition at line 716 of file ManagedMonitorToolBase.h.

{ return m_newHigStatInterval; }

newLowStatFlag()

bool ManagedMonitorToolBase::newLowStatFlag ( ) const

inlineprotectedinherited

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

{ return m_newLowStatInterval; }

newLumiBlockFlag()

bool ManagedMonitorToolBase::newLumiBlockFlag ( ) const

inlineprotectedinherited

Definition at line 718 of file ManagedMonitorToolBase.h.

{ return m_newLumiBlock; }

newMedStatIntervalFlag()

bool ManagedMonitorToolBase::newMedStatIntervalFlag ( ) const

inlineprotectedinherited

Definition at line 715 of file ManagedMonitorToolBase.h.

{ return m_newMedStatInterval; }

newRunFlag()

bool ManagedMonitorToolBase::newRunFlag ( ) const

inlineprotectedinherited

Definition at line 719 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 1985 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;
}

postProc()

StatusCode CscCalibMonToolSlope::postProc ( )

privatevirtual

postProc retrieves the plots fit to produce the gain

Reimplemented from CscCalibMonToolBase.

Definition at line 488 of file CscCalibMonToolSlope.cxx.

{
  ATH_MSG_DEBUG( "CscCalibMonToolSlope : in retrieveHistos()"  );
 
  ATH_MSG_DEBUG( "Do all detailed is: " << m_doAllDetailed  );
 
 
 
  IdContext chanContext = m_idHelperSvc->cscIdHelper().channel_context();
 
  //Get the slopeReport, checking for pointer errors along the way
  const CscCalibReportContainer* repCont;
  if (!evtStore()->retrieve(repCont, m_histKey).isSuccess())
  {
    ATH_MSG_ERROR( " Cannot retrieve object from storegate with key "
                   << m_histKey <<  " aborting retrieving hists "  );
    return StatusCode::RECOVERABLE;
  }
  if(repCont->size() != 1)
  {
    ATH_MSG_ERROR( "Container with key " << m_histKey
                   << " does not have a size of one. Do not know how to proceed, so aborting"
                   << " retrieving calibration histograms."  );
    return StatusCode::RECOVERABLE;
  }
 
  const CscCalibReportSlope * slopeReport =
    dynamic_cast<const CscCalibReportSlope *>(repCont->front());
  if(!slopeReport)
  {
    ATH_MSG_ERROR( "No report stored in the container with key " << m_histKey
                   << ". Aborting retrieving histograms."  );
    return StatusCode::RECOVERABLE;
  }
  if(slopeReport->getLabel() != "calGraphs")
  {
    ATH_MSG_ERROR( "Incorect object retrieved from container with key " << m_histKey
                   << ". Aborting hist retrieval"  );
    return StatusCode::RECOVERABLE;
  }
  
 //ampProfs 
  const std::map <int,TProfile*>& ampProfs = slopeReport->getAmpProfs();
  if(ampProfs.empty())
  {
    ATH_MSG_ERROR( "There are no amplitude profiles in the slope report! Can't find dead chans." );
    return StatusCode::RECOVERABLE;
  }
 
  if(m_histAttenLevels){
    for(const auto & [attenuationVal, pProfile] : ampProfs){
 
      const float atten = attenuationVal * 0.5f;
      const std::string attenStr = std::to_string(atten);
 
      HistCollection * ampColl = new HistCollection(m_maxHashId +1, m_maxHashId +1);
      ampColl->ignoreY = true;
 
      //put into ampColls to make for easy deleting later
      m_ampColls.push_back(ampColl);
 
 
      std::string dataName = "amp_atten" + attenStr;
      std::string dataTitle = "ADC response at attenuation " + attenStr + " db" ; 
      std::string axisLabel = "ADC";
      unsigned int numBins = 300; 
      float lowBound = 0;
      float highBound = 3000;
      std::string subDir = "AmpAtten" + attenStr;
 
      bookHistCollection(ampColl, dataName, dataTitle, "", "", axisLabel, numBins, lowBound, highBound, subDir).ignore();
      for(unsigned int stripHash = 0; stripHash < m_maxHashId; stripHash++){
        ampColl->data[stripHash] =  pProfile->GetBinContent(stripHash +1);
      }
 
      ATH_CHECK( copyDataToHists(ampColl) );
    }
  }
 
 
  const std::vector<float>& fitResVec = slopeReport->getFitResults();
  m_fitResColl->data = fitResVec;
  ATH_CHECK( copyDataToHists(m_fitResColl) );
 
  //Generate fractional deviation histograms
  ATH_MSG_DEBUG( "About to generate fractional deviation graphs" );
  if(!makeFracGraphs(*slopeReport).isSuccess())
    ATH_MSG_WARNING( "Failed to generate fractional deviation graphs. Continuing anyway.." );
 
 
  ATH_MSG_DEBUG( "About to find dead channels"  );
  //Determine dead channels
  //sc = findDeadChannels(*slopeReport);
  //if(!sc.isSuccess())
  //  m_log << MSG::WARNING << "Failure while finding dead channels" << endmsg;
 
 
  //Put extra info for those channels indicated in m_detailedHashIds
  ATH_MSG_DEBUG( "Picking detailed graphs to output to root file" );
  if(m_numBad >0 || m_maxDetailedChannels < 0 || m_doAllDetailed)
  { 
    const std::vector<TGraphErrors*>& calGraphs
      = slopeReport->getCalGraphs();
    if(calGraphs.empty())
    {
      ATH_MSG_ERROR( "No calGraph stored inside object with key " << m_histKey
                     << ". Aborting hist retrieval."  );
      return StatusCode::RECOVERABLE;
    }
    else
      ATH_MSG_INFO( "Got calGraphs"  );
 
    const std::vector<TH1I*>& bitHists = slopeReport->getBitHists();
    if(bitHists.empty())
      ATH_MSG_INFO( "No bit histogram vector found from calibration. "
                    << " Won't be in monitoring output file. "  );
    else
      ATH_MSG_INFO( "Got bitHists"  );
 
 
    //These are the channels we will get detailed forr.
    for(unsigned int idItr = 0; idItr < m_maxHashId; idItr++)
    {
      ATH_MSG_ERROR("Calgraph Address: " <<  calGraphs[idItr]);
      if(m_expectedHashIdsPrec.count(idItr) && (m_detailedHashIds[idItr] || (m_doAllDetailed) ) )
      {
        ATH_MSG_ERROR("Doing detailed plots of hash " << idItr);
 
        Identifier chanId;
        m_idHelperSvc->cscIdHelper().get_id(IdentifierHash(idItr), chanId, &chanContext);
        int stationSize = m_idHelperSvc->cscIdHelper().stationName(chanId);
        int stationEta = m_idHelperSvc->cscIdHelper().stationEta(chanId);
        int stationPhi = m_idHelperSvc->cscIdHelper().stationPhi(chanId);
        int wireLayer = m_idHelperSvc->cscIdHelper().wireLayer(chanId);
        int measuresPhi = m_idHelperSvc->cscIdHelper().measuresPhi(chanId);
        int strip = m_idHelperSvc->cscIdHelper().strip(chanId);
        int sector = getSector(stationPhi, stationSize);
 
        std::string geoPath = getGeoPath(stationEta, sector, wireLayer, measuresPhi);
        std::string calGraphPath = getFullPath(geoPath, "CalGraphs","");
        std::string fracPath = getFullPath(geoPath,"FracProf","");
        std::string bitHistPath = getFullPath(geoPath, "BitHists", "");
 
        //Record calgraph
        TGraphErrors  * sourceGraph = 
          const_cast<TGraphErrors*>(calGraphs[idItr]);
        if(!sourceGraph)
        {
          ATH_MSG_ERROR( "The requested calgraph for hash "
                         << idItr << " doesn't exist in CscCalibReport object!"  );
        }
        else {
          std::stringstream  name;
          name << "calfit" 
            << "_EC" << getEndCap(stationEta)
            << "_sector_" << sector 
            << "_layer_" << wireLayer
            << "_" << (measuresPhi ? "trans" : "prec")
            << "_strip_" 
            << std::setfill ('0') <<  std::setw (measuresPhi ? 2 : 3) 
            << strip;
 
          sourceGraph->SetName(name.str().c_str());
          ATH_MSG_DEBUG( "CalGraph axis title: " << sourceGraph->GetXaxis()->GetTitle()  );
 
          ATH_CHECK( regGraph(sourceGraph, calGraphPath, run, ATTRIB_MANAGED) );
        }
 
        //record fracDev graph
        TProfile * sourceProf = m_fracProfs[idItr];
        if(!sourceProf)
        {
          ATH_MSG_ERROR( "There is no fractional profile available for hash " 
                         << idItr << ". Quitting retrieveHistos()."  );
        }
        else{
          std::stringstream  fracName;
          fracName << "frac_"
            << "_EC" << getEndCap(stationEta)
            << "_sector_" << sector 
            << "_layer_" << wireLayer
            << "_" << (measuresPhi ? "trans" : "prec")
            << "_strip_" 
            << std::setfill ('0') <<  std::setw (measuresPhi ? 2 : 3) 
            << strip;
 
          sourceProf->SetName(fracName.str().c_str());
 
          ATH_CHECK( regHist(sourceProf, fracPath, run, ATTRIB_MANAGED) );
        }
 
        //Bit map histograms
        //copy source histogram into new histogram, and store
        if(!bitHists.empty())
        {
          TH1I *  bitHist = const_cast<TH1I*>(bitHists[idItr]);
          if(!bitHist)
          {
            ATH_MSG_ERROR( "There is no bit histogram with hashId "
                           << idItr << " Quiting out of detailed histogram loop."  );
          }
          else {
 
            std::stringstream  name2;
            name2 << "h_bitMap"
              << "_EC" << getEndCap(stationEta)
              << "_sector_" << sector 
              << "_layer_" << wireLayer
              << "_" << (measuresPhi ? "trans" : "prec")
              << "_strip_" 
              << std::setfill ('0') <<  std::setw (measuresPhi ? 2 : 3) 
              << strip;
            // TH1I * newHist2 = (TH1I*)bitHist->Clone(name2.str().c_str());
            bitHist->SetName(name2.str().c_str());
            bitHist->SetFillColor((m_detailedHashIds[idItr] ? m_histColAlert : m_histCol));
 
            //ATH_CHECK( regHist(newHist2, chanPath, run, ATTRIB_MANAGED) );
            ATH_CHECK( regHist(bitHist, bitHistPath, run, ATTRIB_MANAGED) );
          }
        }//end if bithists*/
 
      }//end if (m_detailedHashIds)
      else
        ATH_MSG_ERROR("Skipping hash " << idItr << " " <<  m_expectedHashIdsPrec.count(idItr) << " " << m_doAllDetailed);
    }//end idItr loop
  }//if numBad > 0
  return StatusCode::SUCCESS;    
}// end retrieveHistos

preSelector()

bool ManagedMonitorToolBase::preSelector ( )

virtualinherited

Implements IMonitorToolBase.

Definition at line 1571 of file ManagedMonitorToolBase.cxx.

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

procHistograms()

StatusCode CscCalibMonToolBase::procHistograms ( )

virtualinherited

At end of run this processes the calibration results and fills the histograms.

fillHistograms() retrieves a CscCalibResultContainer from the TDS, and loops through CscCalibResultCollection objects, each holding info for a calibration parameter.

It calls handleParameter() for each CscCalibResultCollection, which is used in a derived class to determine what is to be done with each parameter.

Reimplemented from ManagedMonitorToolBase.

Definition at line 709 of file CscCalibMonToolBase.cxx.

{
 
  ATH_MSG_DEBUG( "CscCalibMonToolBase : in procHistograms()"  );
 
  if(endOfRunFlag())
  {
    const CscCalibResultContainer* calibContainer = nullptr;
    if (!evtStore()->retrieve(calibContainer, m_calibResultKey).isSuccess())
    {
      ATH_MSG_ERROR( " Cannot retrieve container with name " << m_calibResultKey  );
      return StatusCode::RECOVERABLE;
    }
 
    ATH_MSG_DEBUG( "There are " << calibContainer->size() << " parameters to monitor"  );
 
    for(const CscCalibResultCollection* thisParameter: *calibContainer) {
      ATH_CHECK( handleParameter(thisParameter) );
    }
    ATH_CHECK( postProc() );
  }
  return StatusCode::SUCCESS;
}//end procHistograms  

procParameter()

StatusCode CscCalibMonToolBase::procParameter ( const CscCalibResultCollection * parVals, ProcSetupInfo * simpleSet )

protectedvirtualinherited

Processors a parameter type.

Typically called by derived classes' handleParameter. It does several things

-Fills the histograms in simpleSet -Determines if a given channel deviates too much from an expected value (expected value is from COOL or specified in simpleSet). -Optionally tests the chi^2 value in parVals -Fills the std::vectors in simpleSet. These vectors contain info such as the per-channel values, difference from old COOL values, and the COOL values themselves. -Looks for any expected channels missing in parVals. If so, it mentions it.

Parameters

parVals	Collection of values for a given parameter
simpleSet	contains a set of histograms and vectors to be filled.

Definition at line 771 of file CscCalibMonToolBase.cxx.

{
  ATH_MSG_DEBUG( "Entering proc parameter for " << parVals->parName() << ". Max diff " << procParameterInput->maxDiff << "."  );
  if (procParameterInput->doChi2)
    ATH_MSG_DEBUG( " Will retrieve chi2 with expected max of " << procParameterInput->chi2Max  );
 
  //Start with expected channels, remove whenever one is found, leftover are
  //missing channels
  std::set<int> missingChannels = procParameterInput->expectedChannels;
 
  SG::ReadCondHandle<CscCondDbData> readHandle{m_readKey};
  const CscCondDbData* readCdo{*readHandle};
 
  //--Cycle through values and fill histograms
  int numFailures = 0, maxFailures = 10;
  for(const CscCalibResult* chan: *parVals)
  {
    const int hashId = chan->hashId();
    const float val = chan->value();
    const  float error = chan->error();
    float oldVal = 0;
 
    //This channel isn't missing
    missingChannels.erase(hashId);
 
    //--Compare measured value with an expected value---------------------
    if(procParameterInput->dbName != "")
    {
      //Get expected value from database
      if(!(readCdo->readChannelParam(hashId, oldVal, procParameterInput->dbName)).isSuccess())
      {
        numFailures++;
        ATH_MSG_WARNING( "CscCalibMonToolBase :  Failed to retrieve parameter"
                         << " for channel " << hashId  
                         << " from COOL database. Continuing with COOL value = 0" 
                         );
        if(numFailures==maxFailures)
        {
          ATH_MSG_FATAL( "CscCalibMonToolBase : "
                         << maxFailures << " failed retrievals. Quiting. "  );
          return StatusCode::FAILURE;
        }
      }
    }
    else
    {
      //No value in database, compare to provided expected value
      oldVal = procParameterInput->expectedVal;
    }
 
    float diff = val - oldVal;
 
    bool isBad = false;
    if( std::abs(diff) > procParameterInput->maxDiff)
    {
      ATH_MSG_INFO( "CscCalibMonToolBase : Possible problem! " << parVals->parName()
                    << " measurement of " << val << " varies by " << diff
                    << " from expected value of " << oldVal << " on channel with hash Id "
                    << hashId << ". Specified maximum variance is " << procParameterInput->maxDiff  );
      isBad = true;
      procParameterInput->badHist->Fill(procParameterInput->badBin); //Too high a difference
    }
 
    float chi2_ndf = 0;
    if(procParameterInput->doChi2)
    {
      chi2_ndf = chan->chi2()/chan->ndf();
      if(chi2_ndf > procParameterInput->chi2Max)
      {
        procParameterInput->badHist->Fill(procParameterInput->chi2BadBin);
        isBad = true;
      }
    }
 
    //If there is a bad channel, specify that we want details about it.
    if( isBad && ( (int)m_numBad  <= m_maxDetailedChannels || m_maxDetailedChannels < 0 ) ) 
    {
      if(!m_detailedHashIds[hashId])
      {    
        m_numBad++;
        m_detailedHashIds[hashId] = true; //Look closer at this hash id (used in derived class)
      }
    }
 
    (*procParameterInput->vals)[hashId] = val;
    if((procParameterInput->errors->size()))
      (*procParameterInput->errors)[hashId] = error;
    if(procParameterInput->oldVals)
      (*procParameterInput->oldVals)[hashId] = oldVal;
    if(procParameterInput->diffs)
      (*procParameterInput->diffs)[hashId] = diff;
    if(procParameterInput->doChi2)
      (*procParameterInput->chi2s)[hashId] = chi2_ndf;
    //--Print out values channel-by channel sorted by Hash Id-------------------
  }//End chanItr loop
 
  if(missingChannels.size() !=0)
  {
    for(const auto & thisChan: missingChannels)
    {
      if(procParameterInput->missingChans != nullptr)
      {
        //If we haven't already noticed that this channel is missing, 
        //increment missing bad bin in badHist.
        if(!procParameterInput->missingChans->GetBinContent(thisChan+1))
          procParameterInput->badHist->Fill(procParameterInput->missingBadBin);
        //Always fill missingChans histogram 
        procParameterInput->missingChans->Fill(thisChan);
 
      }
    }
  }
  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 1337 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/2]

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

virtualinherited

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

Definition at line 1391 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 );
   }
 
   // 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() [2/2]

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

virtualinherited

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

Definition at line 1381 of file ManagedMonitorToolBase.cxx.

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

regHist() [1/2]

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

virtualinherited

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

A histogram is passed via reference to a pointer.

Definition at line 1247 of file ManagedMonitorToolBase.cxx.

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

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

virtualinherited

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

Definition at line 1238 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 844 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 1038 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 967 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 870 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 1098 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 1446 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 1436 of file ManagedMonitorToolBase.cxx.

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

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 368 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 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

runStat()

StatusCode ManagedMonitorToolBase::runStat ( )

virtualinherited

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

Implements IMonitorToolBase.

Definition at line 1553 of file ManagedMonitorToolBase.cxx.

{
   return StatusCode::SUCCESS;
}

setArray()

std::vector< float > & CscCalibMonToolSlope::setArray ( std::vector< float > & array, const float & value, const int & numEntries )

private

Definition at line 1022 of file CscCalibMonToolSlope.cxx.

{
  for(int i = 0 ; i < numEntries; i++)
    array[i] = value;
  return array;
}

setMonManager()

void ManagedMonitorToolBase::setMonManager ( AthenaMonManager * manager )

virtualinherited

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

Definition at line 1220 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 1542 of file ManagedMonitorToolBase.cxx.

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

streamNameFunction()

ManagedMonitorToolBase::StreamNameFcn * ManagedMonitorToolBase::streamNameFunction ( )

virtualinherited

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

Definition at line 437 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;
}

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 >, and AthCheckedComponent<::AthAlgTool >.

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 935 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 1966 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 2004 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 298 of file AthCommonDataStore.h.

                                               {
    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 1491 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_allChan1dName

std::string CscCalibMonToolBase::m_allChan1dName

protectedinherited

Definition at line 138 of file CscCalibMonToolBase.h.

m_allChan1dTitle

std::string CscCalibMonToolBase::m_allChan1dTitle

protectedinherited

Definition at line 139 of file CscCalibMonToolBase.h.

m_allChan2dName

std::string CscCalibMonToolBase::m_allChan2dName

protectedinherited

Definition at line 140 of file CscCalibMonToolBase.h.

m_allChan2dPath

std::string CscCalibMonToolBase::m_allChan2dPath

protectedinherited

Definition at line 158 of file CscCalibMonToolBase.h.

m_allChan2dTitle

std::string CscCalibMonToolBase::m_allChan2dTitle

protectedinherited

Definition at line 141 of file CscCalibMonToolBase.h.

m_ampColls

DataVector<HistCollection> CscCalibMonToolSlope::m_ampColls

private

Definition at line 122 of file CscCalibMonToolSlope.h.

m_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial

privateinherited

Definition at line 800 of file ManagedMonitorToolBase.h.

m_calibResultKey

std::string CscCalibMonToolBase::m_calibResultKey

protectedinherited

Calibration result storegate key.

Definition at line 166 of file CscCalibMonToolBase.h.

m_chamHistName

std::string CscCalibMonToolBase::m_chamHistName

protectedinherited

Definition at line 148 of file CscCalibMonToolBase.h.

m_chamHistTitle

std::string CscCalibMonToolBase::m_chamHistTitle

protectedinherited

Definition at line 149 of file CscCalibMonToolBase.h.

m_chamProfName

std::string CscCalibMonToolBase::m_chamProfName

protectedinherited

Definition at line 142 of file CscCalibMonToolBase.h.

m_chamProfPath

std::string CscCalibMonToolBase::m_chamProfPath

protectedinherited

Definition at line 158 of file CscCalibMonToolBase.h.

m_chamProfTitle

std::string CscCalibMonToolBase::m_chamProfTitle

protectedinherited

Definition at line 143 of file CscCalibMonToolBase.h.

m_chamSummHistName

std::string CscCalibMonToolBase::m_chamSummHistName

protectedinherited

Definition at line 146 of file CscCalibMonToolBase.h.

m_chamSummHistPath

std::string CscCalibMonToolBase::m_chamSummHistPath

protectedinherited

Definition at line 159 of file CscCalibMonToolBase.h.

m_chamSummHistTitle

std::string CscCalibMonToolBase::m_chamSummHistTitle

protectedinherited

Definition at line 147 of file CscCalibMonToolBase.h.

m_chi2BadBin

int CscCalibMonToolSlope::m_chi2BadBin {3}

private

Definition at line 93 of file CscCalibMonToolSlope.h.

{1}, m_interceptBadBin{2}, m_chi2BadBin{3}, m_peaktBadBin{4}, m_fracBadBin{5}, 

m_chi2Coll

HistCollection* CscCalibMonToolSlope::m_chi2Coll {}

private

Definition at line 115 of file CscCalibMonToolSlope.h.

{};       

m_chi2Max

float CscCalibMonToolSlope::m_chi2Max {}

private

Definition at line 90 of file CscCalibMonToolSlope.h.

{},m_interceptMax{},m_chi2Max{}, m_fracDevMax{}, m_peaktMaxDiff{};

m_d

Imp* ManagedMonitorToolBase::m_d

privateinherited

Definition at line 807 of file ManagedMonitorToolBase.h.

m_dataType

AthenaMonManager::DataType_t ManagedMonitorToolBase::m_dataType

protectedinherited

Definition at line 745 of file ManagedMonitorToolBase.h.

m_dataTypeStr

std::string ManagedMonitorToolBase::m_dataTypeStr

protectedinherited

Definition at line 741 of file ManagedMonitorToolBase.h.

m_deadADCCutoff

int CscCalibMonToolSlope::m_deadADCCutoff

private

Definition at line 131 of file CscCalibMonToolSlope.h.

m_deadBadBin

int CscCalibMonToolSlope::m_deadBadBin {6}

private

Definition at line 94 of file CscCalibMonToolSlope.h.

{6},m_missingBadBin{7};

m_deadDiffColl

HistCollection * CscCalibMonToolSlope::m_deadDiffColl {}

private

Definition at line 116 of file CscCalibMonToolSlope.h.

{}, *m_deadDiffColl{};

m_deadNewColl

HistCollection* CscCalibMonToolSlope::m_deadNewColl {}

private

Definition at line 116 of file CscCalibMonToolSlope.h.

{}, *m_deadDiffColl{};

m_deadPulserLevelCutoff

int CscCalibMonToolSlope::m_deadPulserLevelCutoff

private

Dead channel finding user defined parameters.

Definition at line 131 of file CscCalibMonToolSlope.h.

m_defaultLBDuration

float ManagedMonitorToolBase::m_defaultLBDuration

privateinherited

Definition at line 802 of file ManagedMonitorToolBase.h.

m_detailedHashIds

bool* CscCalibMonToolBase::m_detailedHashIds {}

protectedinherited

Definition at line 129 of file CscCalibMonToolBase.h.

{};

m_detailLevel

unsigned int ManagedMonitorToolBase::m_detailLevel

protectedinherited

Definition at line 743 of file ManagedMonitorToolBase.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_doAllDetailed

bool CscCalibMonToolBase::m_doAllDetailed {}

protectedinherited

Definition at line 123 of file CscCalibMonToolBase.h.

{}, m_doBadDetailed{};

m_doBadDetailed

bool CscCalibMonToolBase::m_doBadDetailed {}

protectedinherited

Definition at line 123 of file CscCalibMonToolBase.h.

{}, m_doBadDetailed{};

m_doNeighborRatios

bool CscCalibMonToolSlope::m_doNeighborRatios {}

private

Do neighbor ratios.

Definition at line 84 of file CscCalibMonToolSlope.h.

{};

m_doStatDb

bool CscCalibMonToolBase::m_doStatDb {}

protectedinherited

Definition at line 241 of file CscCalibMonToolBase.h.

{};

m_DQFilterTools

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

protectedinherited

Definition at line 756 of file ManagedMonitorToolBase.h.

{this,"FilterTools",{}};

m_endOfEventsBlock

bool ManagedMonitorToolBase::m_endOfEventsBlock

privateinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

m_endOfLowStat

bool ManagedMonitorToolBase::m_endOfLowStat

privateinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

m_endOfLumiBlock

bool ManagedMonitorToolBase::m_endOfLumiBlock

privateinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

m_endOfRun

bool ManagedMonitorToolBase::m_endOfRun

privateinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

m_environment

AthenaMonManager::Environment_t ManagedMonitorToolBase::m_environment

protectedinherited

Definition at line 746 of file ManagedMonitorToolBase.h.

m_environmentStr

std::string ManagedMonitorToolBase::m_environmentStr

protectedinherited

Definition at line 742 of file ManagedMonitorToolBase.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_expectedChamberLayer

unsigned int CscCalibMonToolBase::m_expectedChamberLayer {}

protectedinherited

Definition at line 116 of file CscCalibMonToolBase.h.

{};

m_expectedHashIdsAll

std::set<int> CscCalibMonToolBase::m_expectedHashIdsAll

protectedinherited

Definition at line 133 of file CscCalibMonToolBase.h.

m_expectedHashIdsPrec

std::set<int> CscCalibMonToolBase::m_expectedHashIdsPrec

protectedinherited

Definition at line 133 of file CscCalibMonToolBase.h.

m_fileKey

std::string ManagedMonitorToolBase::m_fileKey

protectedinherited

Definition at line 740 of file ManagedMonitorToolBase.h.

m_fitResColl

HistCollection* CscCalibMonToolSlope::m_fitResColl {}

private

Definition at line 120 of file CscCalibMonToolSlope.h.

{};

m_fracBadBin

int CscCalibMonToolSlope::m_fracBadBin {5}

private

Definition at line 93 of file CscCalibMonToolSlope.h.

{1}, m_interceptBadBin{2}, m_chi2BadBin{3}, m_peaktBadBin{4}, m_fracBadBin{5}, 

m_fracDevMax

float CscCalibMonToolSlope::m_fracDevMax {}

private

Definition at line 90 of file CscCalibMonToolSlope.h.

{},m_interceptMax{},m_chi2Max{}, m_fracDevMax{}, m_peaktMaxDiff{};

m_fracProfs

std::vector<TProfile*> CscCalibMonToolSlope::m_fracProfs

private

Holds fractional deviation TProfiles.

Definition at line 109 of file CscCalibMonToolSlope.h.

m_generic_path_csccalibmonitoring

std::string CscCalibMonToolBase::m_generic_path_csccalibmonitoring

protectedinherited

Path of histograms.

Definition at line 157 of file CscCalibMonToolBase.h.

m_h_chi2Overview

TH1F * CscCalibMonToolSlope::m_h_chi2Overview {}

private

Definition at line 101 of file CscCalibMonToolSlope.h.

{}, *m_h_interceptOverview{},*m_h_chi2Overview{}, 

m_h_deadOverview

TH1F* CscCalibMonToolSlope::m_h_deadOverview {}

private

Overview of dead channels and changes.

Definition at line 106 of file CscCalibMonToolSlope.h.

{};

m_h_interceptOverview

TH1F * CscCalibMonToolSlope::m_h_interceptOverview {}

private

Definition at line 101 of file CscCalibMonToolSlope.h.

{}, *m_h_interceptOverview{},*m_h_chi2Overview{}, 

m_h_numBad

TH1I* CscCalibMonToolSlope::m_h_numBad {}

private

Stores number of channels that are bad in several categories.

Definition at line 98 of file CscCalibMonToolSlope.h.

{};

m_h_slopeCompareOverview

TH1F* CscCalibMonToolSlope::m_h_slopeCompareOverview {}

private

Histograms that simply histogram all entries for a value.

Definition at line 101 of file CscCalibMonToolSlope.h.

{}, *m_h_interceptOverview{},*m_h_chi2Overview{}, 

m_h_slopeMissingChans

TH1F * CscCalibMonToolSlope::m_h_slopeMissingChans {}

private

Definition at line 102 of file CscCalibMonToolSlope.h.

{};

m_hashName

std::string CscCalibMonToolBase::m_hashName

protectedinherited

Naming info.

Definition at line 136 of file CscCalibMonToolBase.h.

m_hashPath

std::string CscCalibMonToolBase::m_hashPath

protectedinherited

Definition at line 158 of file CscCalibMonToolBase.h.

m_hashTitle

std::string CscCalibMonToolBase::m_hashTitle

protectedinherited

Definition at line 137 of file CscCalibMonToolBase.h.

m_haveClearedLastEventBlock

bool ManagedMonitorToolBase::m_haveClearedLastEventBlock

protectedinherited

Definition at line 773 of file ManagedMonitorToolBase.h.

m_histAttenLevels

bool CscCalibMonToolSlope::m_histAttenLevels {}

private

Histogram all values for all histograms.

Definition at line 87 of file CscCalibMonToolSlope.h.

{};

m_histCol

int CscCalibMonToolBase::m_histCol {}

protectedinherited

Hist colors.

Definition at line 154 of file CscCalibMonToolBase.h.

{}, m_histColAlert{};

m_histColAlert

int CscCalibMonToolBase::m_histColAlert {}

protectedinherited

Definition at line 154 of file CscCalibMonToolBase.h.

{}, m_histColAlert{};

m_histKey

std::string CscCalibMonToolSlope::m_histKey

private

Storegate key for pedestal amplitude histograms.

Definition at line 125 of file CscCalibMonToolSlope.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> CscCalibMonToolBase::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

protectedinherited

Definition at line 168 of file CscCalibMonToolBase.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_interceptBadBin

int CscCalibMonToolSlope::m_interceptBadBin {2}

private

Definition at line 93 of file CscCalibMonToolSlope.h.

{1}, m_interceptBadBin{2}, m_chi2BadBin{3}, m_peaktBadBin{4}, m_fracBadBin{5}, 

m_interceptColl

HistCollection* CscCalibMonToolSlope::m_interceptColl {}

private

Definition at line 114 of file CscCalibMonToolSlope.h.

{};

m_interceptMax

float CscCalibMonToolSlope::m_interceptMax {}

private

Definition at line 90 of file CscCalibMonToolSlope.h.

{},m_interceptMax{},m_chi2Max{}, m_fracDevMax{}, m_peaktMaxDiff{};

m_lastHigStatInterval

int ManagedMonitorToolBase::m_lastHigStatInterval

protectedinherited

Definition at line 768 of file ManagedMonitorToolBase.h.

m_lastLowStatInterval

int ManagedMonitorToolBase::m_lastLowStatInterval

protectedinherited

Definition at line 768 of file ManagedMonitorToolBase.h.

m_lastLumiBlock

unsigned int ManagedMonitorToolBase::m_lastLumiBlock

protectedinherited

Definition at line 766 of file ManagedMonitorToolBase.h.

m_lastMedStatInterval

int ManagedMonitorToolBase::m_lastMedStatInterval

protectedinherited

Definition at line 768 of file ManagedMonitorToolBase.h.

m_lastRun

unsigned int ManagedMonitorToolBase::m_lastRun

protectedinherited

Definition at line 767 of file ManagedMonitorToolBase.h.

m_layHistName

std::string CscCalibMonToolBase::m_layHistName

protectedinherited

Definition at line 144 of file CscCalibMonToolBase.h.

m_layHistPath

std::string CscCalibMonToolBase::m_layHistPath

protectedinherited

Definition at line 158 of file CscCalibMonToolBase.h.

m_layHistTitle

std::string CscCalibMonToolBase::m_layHistTitle

protectedinherited

Definition at line 145 of file CscCalibMonToolBase.h.

m_laySummHistName

std::string CscCalibMonToolBase::m_laySummHistName

protectedinherited

Definition at line 150 of file CscCalibMonToolBase.h.

m_laySummHistPath

std::string CscCalibMonToolBase::m_laySummHistPath

protectedinherited

Definition at line 159 of file CscCalibMonToolBase.h.

m_laySummHistTitle

std::string CscCalibMonToolBase::m_laySummHistTitle

protectedinherited

Definition at line 151 of file CscCalibMonToolBase.h.

m_lbDurationDataKey

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

privateinherited

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

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

m_makeAllChan1dHists

bool CscCalibMonToolBase::m_makeAllChan1dHists {}

protectedinherited

Definition at line 120 of file CscCalibMonToolBase.h.

{}, m_makeAllChan1dHists{}, m_makeAllChan2dHists{},  m_makeLayHists{}, 

m_makeAllChan2dHists

bool CscCalibMonToolBase::m_makeAllChan2dHists {}

protectedinherited

Definition at line 120 of file CscCalibMonToolBase.h.

{}, m_makeAllChan1dHists{}, m_makeAllChan2dHists{},  m_makeLayHists{}, 

m_makeChamHists

bool CscCalibMonToolBase::m_makeChamHists {}

protectedinherited

Definition at line 122 of file CscCalibMonToolBase.h.

{}, m_makeChamHists{},

m_makeChamProfs

bool CscCalibMonToolBase::m_makeChamProfs {}

protectedinherited

Definition at line 121 of file CscCalibMonToolBase.h.

{}, m_makeChamProfs{}, 

m_makeChamSummHists

bool CscCalibMonToolBase::m_makeChamSummHists {}

protectedinherited

Definition at line 122 of file CscCalibMonToolBase.h.

{}, m_makeChamHists{},

m_makeHashHists

bool CscCalibMonToolBase::m_makeHashHists {}

protectedinherited

Data output options.

Definition at line 120 of file CscCalibMonToolBase.h.

{}, m_makeAllChan1dHists{}, m_makeAllChan2dHists{},  m_makeLayHists{}, 

m_makeLayHists

bool CscCalibMonToolBase::m_makeLayHists {}

protectedinherited

Definition at line 120 of file CscCalibMonToolBase.h.

{}, m_makeAllChan1dHists{}, m_makeAllChan2dHists{},  m_makeLayHists{}, 

m_makeLaySummHists

bool CscCalibMonToolBase::m_makeLaySummHists {}

protectedinherited

Definition at line 121 of file CscCalibMonToolBase.h.

{}, m_makeChamProfs{}, 

m_manager

AthenaMonManager* ManagedMonitorToolBase::m_manager

protectedinherited

Definition at line 736 of file ManagedMonitorToolBase.h.

m_managerNameProp

std::string ManagedMonitorToolBase::m_managerNameProp

protectedinherited

Definition at line 738 of file ManagedMonitorToolBase.h.

m_maxChamId

unsigned int CscCalibMonToolBase::m_maxChamId {}

protectedinherited

Definition at line 114 of file CscCalibMonToolBase.h.

{};

m_maxDetailedChannels

int CscCalibMonToolBase::m_maxDetailedChannels {}

protectedinherited

To keep track of channels that should have more data printed to root file.

Definition at line 128 of file CscCalibMonToolBase.h.

{};

m_maxHashId

unsigned int CscCalibMonToolBase::m_maxHashId {}

protectedinherited

Definition at line 113 of file CscCalibMonToolBase.h.

{};

m_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap

protectedinherited

Definition at line 734 of file ManagedMonitorToolBase.h.

m_missingBadBin

int CscCalibMonToolSlope::m_missingBadBin {7}

private

Definition at line 94 of file CscCalibMonToolSlope.h.

{6},m_missingBadBin{7};

m_monGroupMap

std::map<std::string, MonGroup*> CscCalibMonToolBase::m_monGroupMap

protectedinherited

Definition at line 163 of file CscCalibMonToolBase.h.

m_monGroupVec

DataVector<MonGroup>* CscCalibMonToolBase::m_monGroupVec {}

protectedinherited

Keeps track of MonGroups.

Definition at line 162 of file CscCalibMonToolBase.h.

{};

m_nEvents

unsigned int ManagedMonitorToolBase::m_nEvents

protectedinherited

Definition at line 770 of file ManagedMonitorToolBase.h.

m_nEventsIgnoreTrigger

unsigned int ManagedMonitorToolBase::m_nEventsIgnoreTrigger

protectedinherited

Definition at line 771 of file ManagedMonitorToolBase.h.

m_newDeadBin

int CscCalibMonToolSlope::m_newDeadBin {4}

private

Definition at line 96 of file CscCalibMonToolSlope.h.

{1}, m_totalDeadBin{2}, m_newLiveBin{3}, m_newDeadBin{4};

m_newEventsBlock

bool ManagedMonitorToolBase::m_newEventsBlock

privateinherited

Definition at line 729 of file ManagedMonitorToolBase.h.

m_newHigStatInterval

bool ManagedMonitorToolBase::m_newHigStatInterval

privateinherited

Definition at line 727 of file ManagedMonitorToolBase.h.

m_newLiveBin

int CscCalibMonToolSlope::m_newLiveBin {3}

private

Definition at line 96 of file CscCalibMonToolSlope.h.

{1}, m_totalDeadBin{2}, m_newLiveBin{3}, m_newDeadBin{4};

m_newLowStat

bool ManagedMonitorToolBase::m_newLowStat

privateinherited

Definition at line 728 of file ManagedMonitorToolBase.h.

m_newLowStatInterval

bool ManagedMonitorToolBase::m_newLowStatInterval

privateinherited

Definition at line 727 of file ManagedMonitorToolBase.h.

m_newLumiBlock

bool ManagedMonitorToolBase::m_newLumiBlock

privateinherited

Definition at line 728 of file ManagedMonitorToolBase.h.

m_newMedStatInterval

bool ManagedMonitorToolBase::m_newMedStatInterval

privateinherited

Definition at line 727 of file ManagedMonitorToolBase.h.

m_newRun

bool ManagedMonitorToolBase::m_newRun

privateinherited

Definition at line 728 of file ManagedMonitorToolBase.h.

m_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks

protectedinherited

Definition at line 772 of file ManagedMonitorToolBase.h.

m_numBad

unsigned int CscCalibMonToolBase::m_numBad {}

protectedinherited

Definition at line 115 of file CscCalibMonToolBase.h.

{};

m_onlyExpectPrecisionHashIds

bool CscCalibMonToolBase::m_onlyExpectPrecisionHashIds {}

protectedinherited

Hash Ids one would expect to be in calibration data.

Definition at line 132 of file CscCalibMonToolBase.h.

{};

m_path

std::string ManagedMonitorToolBase::m_path

protectedinherited

Definition at line 759 of file ManagedMonitorToolBase.h.

m_peaktBadBin

int CscCalibMonToolSlope::m_peaktBadBin {4}

private

Definition at line 93 of file CscCalibMonToolSlope.h.

{1}, m_interceptBadBin{2}, m_chi2BadBin{3}, m_peaktBadBin{4}, m_fracBadBin{5}, 

m_peaktDiffColl

HistCollection * CscCalibMonToolSlope::m_peaktDiffColl {}

private

Definition at line 113 of file CscCalibMonToolSlope.h.

{}, *m_peaktOldColl{}, *m_peaktDiffColl{};

m_peaktMaxDiff

float CscCalibMonToolSlope::m_peaktMaxDiff {}

private

Definition at line 90 of file CscCalibMonToolSlope.h.

{},m_interceptMax{},m_chi2Max{}, m_fracDevMax{}, m_peaktMaxDiff{};

m_peaktNewColl

HistCollection* CscCalibMonToolSlope::m_peaktNewColl {}

private

Definition at line 113 of file CscCalibMonToolSlope.h.

{}, *m_peaktOldColl{}, *m_peaktDiffColl{};

m_peaktOldColl

HistCollection * CscCalibMonToolSlope::m_peaktOldColl {}

private

Definition at line 113 of file CscCalibMonToolSlope.h.

{}, *m_peaktOldColl{}, *m_peaktDiffColl{};

m_preScaleProp

long ManagedMonitorToolBase::m_preScaleProp

protectedinherited

Definition at line 760 of file ManagedMonitorToolBase.h.

m_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp

protectedinherited

Definition at line 758 of file ManagedMonitorToolBase.h.

m_readKey

SG::ReadCondHandleKey<CscCondDbData> CscCalibMonToolBase::m_readKey {this, "ReadKey", "CscCondDbData", "Key of CscCondDbData"}

protectedinherited

Access to COOL database.

Definition at line 171 of file CscCalibMonToolBase.h.

{this, "ReadKey", "CscCondDbData", "Key of CscCondDbData"};   

m_slopeBadBin

int CscCalibMonToolSlope::m_slopeBadBin {1}

private

Bin corresponding to each category in m_h_numbad.

Definition at line 93 of file CscCalibMonToolSlope.h.

{1}, m_interceptBadBin{2}, m_chi2BadBin{3}, m_peaktBadBin{4}, m_fracBadBin{5}, 

m_slopeDiffColl

HistCollection * CscCalibMonToolSlope::m_slopeDiffColl {}

private

Definition at line 112 of file CscCalibMonToolSlope.h.

{}, *m_slopeOldColl{}, *m_slopeDiffColl{};

m_slopeMaxDiff

float CscCalibMonToolSlope::m_slopeMaxDiff {}

private

Maximum deviation from expected values allowed before m_h_numBad is incremented.

Definition at line 90 of file CscCalibMonToolSlope.h.

{},m_interceptMax{},m_chi2Max{}, m_fracDevMax{}, m_peaktMaxDiff{};

m_slopeNewColl

HistCollection* CscCalibMonToolSlope::m_slopeNewColl {}

private

HistCollections.

See CscCalibMonToolBase for definition

Definition at line 112 of file CscCalibMonToolSlope.h.

{}, *m_slopeOldColl{}, *m_slopeDiffColl{};

m_slopeOldColl

HistCollection * CscCalibMonToolSlope::m_slopeOldColl {}

private

Definition at line 112 of file CscCalibMonToolSlope.h.

{}, *m_slopeOldColl{}, *m_slopeDiffColl{};

m_slopeRatioColl

HistCollection* CscCalibMonToolSlope::m_slopeRatioColl {}

private

Definition at line 117 of file CscCalibMonToolSlope.h.

{};

m_statDbColl

HistCollection* CscCalibMonToolBase::m_statDbColl {}

protectedinherited

Definition at line 242 of file CscCalibMonToolBase.h.

{};

m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn

protectedinherited

Definition at line 748 of file ManagedMonitorToolBase.h.

m_subDir

std::string CscCalibMonToolSlope::m_subDir

private

Name of subdirectory under EXPERT or SHIFT that the histograms will be stored.

Definition at line 128 of file CscCalibMonToolSlope.h.

m_supportedIntervalsForRebooking

std::set<Interval_t> ManagedMonitorToolBase::m_supportedIntervalsForRebooking

privateinherited

Definition at line 803 of file ManagedMonitorToolBase.h.

m_templateEfficiencies

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

protectedinherited

Definition at line 604 of file ManagedMonitorToolBase.h.

m_templateGraphs

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

protectedinherited

Definition at line 596 of file ManagedMonitorToolBase.h.

m_templateHistograms

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

protectedinherited

Definition at line 592 of file ManagedMonitorToolBase.h.

m_templateTrees

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

protectedinherited

Definition at line 600 of file ManagedMonitorToolBase.h.

m_THistSvc

ServiceHandle<ITHistSvc> ManagedMonitorToolBase::m_THistSvc

protectedinherited

Definition at line 750 of file ManagedMonitorToolBase.h.

m_totalDeadBin

int CscCalibMonToolSlope::m_totalDeadBin {2}

private

Definition at line 96 of file CscCalibMonToolSlope.h.

{1}, m_totalDeadBin{2}, m_newLiveBin{3}, m_newDeadBin{4};

m_totalLiveBin

int CscCalibMonToolSlope::m_totalLiveBin {1}

private

Definition at line 96 of file CscCalibMonToolSlope.h.

{1}, m_totalDeadBin{2}, m_newLiveBin{3}, m_newDeadBin{4};

m_trigDecTool

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

protectedinherited

Definition at line 752 of file ManagedMonitorToolBase.h.

{this, "TrigDecisionTool",""};

m_triggerChainProp

std::string ManagedMonitorToolBase::m_triggerChainProp

protectedinherited

Definition at line 761 of file ManagedMonitorToolBase.h.

m_triggerGroupProp

std::string ManagedMonitorToolBase::m_triggerGroupProp

protectedinherited

Definition at line 762 of file ManagedMonitorToolBase.h.

m_trigLiveFractionDataKey

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

privateinherited

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

{this,"TriggerTranslatorTool",""};

m_useLumi

bool ManagedMonitorToolBase::m_useLumi

privateinherited

Definition at line 801 of file ManagedMonitorToolBase.h.

m_useTrigger

bool ManagedMonitorToolBase::m_useTrigger

protectedinherited

Definition at line 764 of file ManagedMonitorToolBase.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

m_vTrigChainNames

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

protectedinherited

Definition at line 608 of file ManagedMonitorToolBase.h.

m_vTrigGroupNames

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

protectedinherited

Definition at line 608 of file ManagedMonitorToolBase.h.

---

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

• CscCalibMonToolSlope.h
• CscCalibMonToolSlope.cxx