SCTCalib Class Reference

#include <SCTCalib.h>

Inheritance diagram for SCTCalib:

Collaboration diagram for SCTCalib:

Public Member Functions
	SCTCalib (const std::string &name, ISvcLocator *pSvcLocator)
	~SCTCalib ()=default
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) override
	Execute method.
virtual StatusCode stop	ATLAS_NOT_THREAD_SAFE () override
virtual StatusCode	finalize () override
	Finalize - delete any memory allocation from the heap.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
bool	filterPassed (const EventContext &ctx) const
void	setFilterPassed (bool state, const EventContext &ctx) const
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	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
const EventContext &	getContext () const
	Deprecated methods (use the ones with EventContext).
bool	filterPassed () const
void	setFilterPassed (bool state) const

Protected Member Functions
virtual bool	isReEntrant () const override final
	Legacy algorithms are not thread-safe.
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.

Private Types
enum	{   nbins = 6*128 , firstStrip = 0 , lastStrip = nbins-1 , ntimeBins = 3 ,   firstTimeBin = 0 , lastTimeBin = 2 , n_hitBins = 50 , first_hitBin = 0 ,   last_hitBin = 50 , n_etaBins = 13 , first_etaBin = -6 , last_etaBin = 6 ,   n_phiBins = 56 , first_phiBin = 0 , last_phiBin = 55 , n_barrels = 4 ,   first_barrel = 0 , last_barrel = 3 , n_disks = 9 , first_disk = 0 ,   last_disk = 8 , n_etaBinsEC = 3 , first_etaBinEC = 0 , last_etaBinEC = 2 ,   n_phiBinsEC = 52 , first_phiBinEC = 0 , last_phiBinEC = 51 }
enum	{   n_chipPerSide = 6 , n_chipPerModule = 12 , n_stripPerChip = 128 , n_etaInBarrel = 12 ,   n_phiBinsB0 = 32 , n_phiBinsB1 = 40 , n_phiBinsB2 = 48 , n_phiBinsB3 = 56 ,   n_phiBinsECShort = 40 , n_phiBinsECMiddle = 40 , n_phiBinsECOuter = 52 , n_elements =8176 ,   n_BSErrorType = 15 , firstBSErrorType = 0 , lastBSErrorType = 14 }
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	prepareHV ()
void	doHVPrintXML (const std::pair< int, int > &timeInterval, const std::pair< int, int > &lbRange, Identifier)
	doHVPrintXML() Prints XML file for hv modules
bool	notEnoughStatistics (const int required, const int obtained, const std::string &histogramName="HIST") const
StatusCode getNoisyStrip	ATLAS_NOT_THREAD_SAFE ()
StatusCode getDeadStrip	ATLAS_NOT_THREAD_SAFE ()
StatusCode getNoiseOccupancy	ATLAS_NOT_THREAD_SAFE ()
StatusCode getRawOccupancy	ATLAS_NOT_THREAD_SAFE ()
StatusCode getEfficiency	ATLAS_NOT_THREAD_SAFE ()
StatusCode getBSErrors	ATLAS_NOT_THREAD_SAFE ()
StatusCode getLorentzAngle	ATLAS_NOT_THREAD_SAFE ()
StatusCode	openXML4DB (std::ofstream &, const char *, const char *, const IOVTime &, const IOVTime &) const
StatusCode	closeXML4DB (std::ofstream &) const
StatusCode	addToXML4DB (std::ofstream &, const Identifier &, const char *, float, const char *) const
StatusCode	openXML4MonSummary (std::ofstream &, const char *) const
StatusCode	openXML4DeadSummary (std::ofstream &file, const char *type, int n_Module=0, int n_Link=0, int n_Chip=0, int n_Strip=0) const
StatusCode	wrapUpXML4Summary (std::ofstream &, const char *, std::ostringstream &) const
StatusCode	addToSummaryStr (std::ostringstream &, const Identifier &, const char *, const char *, const char *) const
template<class S>
bool	retrievedService (S &service) const
std::string	xmlChannelNoiseOccDataString (const Identifier &waferId, const float occupancy, const SCT_SerialNumber &serial) const
std::string	xmlChannelEfficiencyDataString (const Identifier &waferId, const float efficiency, const SCT_SerialNumber &serial, const int side) const
std::string	xmlChannelEfficiencyDataStringChip (const Identifier &waferId, const float efficiency, const float efficiency_bcid, const SCT_SerialNumber &serial, const int side, const int chip) const
std::pair< int, bool >	getNumNoisyStrips (const Identifier &waferId) const
StatusCode	addStripsToList (const EventContext &ctx, Identifier &waferId, std::set< Identifier > &stripIdList, bool isNoisy, bool isNew) const
StatusCode writeModuleListToCool	ATLAS_NOT_THREAD_SAFE (const std::map< Identifier, std::set< Identifier > > &moduleListAll, const std::map< Identifier, std::set< Identifier > > &moduleListNew, const std::map< Identifier, std::set< Identifier > > &moduleListRef)
std::string	getStripList (const std::set< Identifier > &stripIdList) const
std::set< Identifier >	getOverlapStripList (const std::set< Identifier > &stripAllIdList, const std::set< Identifier > &stripRefIdList) const
StatusCode	noisyStripsToXml (const std::map< Identifier, std::set< Identifier > > &moduleList, const std::string &badStripsFile) const
StatusCode	noisyStripsToSummaryXml (const std::map< Identifier, std::set< Identifier > > &moduleListAll, const std::map< Identifier, std::set< Identifier > > &moduleListRef, const std::string &badStripsFile) const
std::set< int >	getNoisyChips (const std::set< Identifier > &stripIdList) const
std::pair< std::string, float >	getNoisyLB (const Identifier &moduleId, int &chipId) const
std::string	getLBList (const std::set< int > &LBList) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
const SCT_ID *	m_pSCTHelper {nullptr}
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
ToolHandle< SCTCalibWriteTool >	m_pCalibWriteTool {this, "SCTCalibWriteTool", "SCTCalibWriteTool", "Tool to write out data from calibration loop"}
ToolHandle< ISCT_ConfigurationConditionsTool >	m_ConfigurationConditionsTool {this, "SCT_ConfigurationConditionsTool", "SCT_ConfigurationConditionsTool/InDetSCT_ConfigurationConditionsTool", "Tool to retrieve SCT Configuration"}
ToolHandle< ISCT_ReadCalibDataTool >	m_ReadCalibDataTool {this, "SCT_ReadCalibDataTool", "SCT_ReadCalibDataTool/InDetSCT_ReadCalibDataTool", "Tool to retrieve SCT calibration data"}
ToolHandle< ISCT_DetectorLevelConditionsTool >	m_MajorityConditionsTool {this, "SCT_MajorityConditionsTool", "SCT_MajorityConditionsTool", "Tool to retrieve the majority conditions of SCT"}
ToolHandle< ISCT_CablingTool >	m_CablingTool {this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"}
ToolHandle< ISCT_CalibHistoTool >	m_calibHitmapTool {this, "SCT_CalibHitmapTool", "SCT_CalibHitmapTool", "Tool for reading and writing HitMap histograms"}
ToolHandle< ISCT_CalibHistoTool >	m_calibLbTool {this, "SCT_CalibLbTool", "SCT_CalibLbTool", "Tool for reading and writing Lb dependent HitMap histograms"}
ToolHandle< ISCT_CalibHistoTool >	m_calibBsErrTool {this, "SCT_CalibBsErrorTool", "SCT_CalibBsErrorTool", "Tool for reading and writing BS error histograms"}
ToolHandle< ISCT_CalibModuleListTool >	m_calibModuleListTool {this, "SCT_CalibModuleListTool", "SCT_CalibModuleListTool", "Tool for handling list of modules"}
ToolHandle< ISCT_CalibEvtInfo >	m_calibEvtInfoTool {this, "SCT_CalibEventInfo", "SCT_CalibEventInfo", "Tool for handling event info"}
std::vector< std::vector< std::pair< int, int > > >	m_summarytrips
std::vector< std::vector< std::pair< int, int > > >	m_summarytripslb
std::ofstream	m_gofile
std::ofstream	m_outDeadStrips
std::ofstream	m_outDeadChips
std::ofstream	m_outDeadSummary
std::ofstream	m_outNOSummary
std::ofstream	m_outROSummary
std::ofstream	m_outEffSummary
std::ofstream	m_outBSErrSummary
std::ofstream	m_outBSErrModule
std::ofstream	m_outLASummary
IntegerProperty	m_runNumber {this, "RunNumber", -1}
IntegerProperty	m_eventNumber {this, "EventNumber", -1}
StringProperty	m_runStartTime {this, "RunStartTime", "", "from runInfo.txt"}
StringProperty	m_runEndTime {this, "RunEndTime", "", "from runInfo.txt"}
StringProperty	m_LBMax {this, "LBMax", "1000", "from runInfo.txt"}
BooleanProperty	m_useConfiguration {this, "UseConfiguration", true}
BooleanProperty	m_useCalibration {this, "UseCalibration", true}
BooleanProperty	m_useMajority {this, "UseMajority", true}
BooleanProperty	m_useBSError {this, "UseBSError", false}
StringArrayProperty	m_input_hist {this, "InputHist", {}, "list of HIST (assuming 1 file)"}
BooleanProperty	m_readBS {this, "ReadBS", false, "True if BS is used"}
BooleanProperty	m_histBefore2010 {this, "HistBefore2010", false, "True if HIST is from 2009 or earlier"}
BooleanProperty	m_doHitMaps {this, "DoHitMaps", true}
BooleanProperty	m_doHitMapsLB {this, "DoHitMapsLB", true}
IntegerProperty	m_nLbsMerged {this, "LbsPerWindow", 30}
BooleanProperty	m_readHitMaps {this, "ReadHitMaps", false}
BooleanProperty	m_doBSErrors {this, "DoBSErrors", false}
BooleanProperty	m_doNoisyStrip {this, "DoNoisyStrip", true}
BooleanProperty	m_doHV {this, "DoHV", false}
BooleanProperty	m_doDeadStrip {this, "DoDeadStrip", false}
BooleanProperty	m_doDeadChip {this, "DoDeadChip", false}
BooleanProperty	m_doNoiseOccupancy {this, "DoNoiseOccupancy", false}
BooleanProperty	m_doRawOccupancy {this, "DoRawOccupancy", false}
BooleanProperty	m_doEfficiency {this, "DoEfficiency", false}
BooleanProperty	m_doBSErrorDB {this, "DoBSErrorDB", false}
BooleanProperty	m_doLorentzAngle {this, "DoLorentzAngle", false}
BooleanProperty	m_writeToCool {this, "WriteToCool", true}
BooleanProperty	m_noisyUpdate {this, "NoisyUpdate", true}
BooleanProperty	m_noisyWriteAllModules {this, "NoisyWriteAllModules", true}
BooleanProperty	m_noisyUploadTest {this, "NoisyUploadTest", true}
FloatProperty	m_noisyModuleAverageInDB {this, "NoisyModuleAverageInDB", -1., "Average number of modules with at least 1 noisy strip in COOL"}
IntegerProperty	m_noisyStripLastRunInDB {this, "NoisyStripLastRunInDB", -999, "Number of noisy strips of the last run uploaded to COOL"}
FloatProperty	m_noisyStripAverageInDB {this, "NoisyStripAverageInDB", -999., "Number of noisy strips of the last run uploaded to COOL"}
IntegerProperty	m_noisyModuleList {this, "NoisyModuleList", 200}
FloatProperty	m_noisyModuleDiff {this, "NoisyModuleDiff", 0.200}
FloatProperty	m_noisyStripDiff {this, "NoisyStripDiff", 128.}
UnsignedIntegerProperty	m_noisyMinStat {this, "NoisyMinStat", 50000}
BooleanProperty	m_noisyStripAll {this, "NoisyStripAll", true}
BooleanProperty	m_noisyStripThrDef {this, "NoisyStripThrDef", true}
FloatProperty	m_noisyStripThrOffline {this, "NoisyStripThrOffline", 1.500E-2}
FloatProperty	m_noisyStripThrOnline {this, "NoisyStripThrOnline", 1.500E-3}
BooleanProperty	m_noisyWaferFinder {this, "NoisyWaferFinder", true}
BooleanProperty	m_noisyWaferWrite {this, "NoisyWaferWrite", true}
BooleanProperty	m_noisyWaferAllStrips {this, "NoisyWaferAllStrips", true}
FloatProperty	m_noisyWaferThrBarrel {this, "NoisyWaferThrBarrel", 1.000E-4}
FloatProperty	m_noisyWaferThrECA {this, "NoisyWaferThrECA", 1.000E-4}
FloatProperty	m_noisyWaferThrECC {this, "NoisyWaferThrECC", 1.000E-4}
FloatProperty	m_noisyWaferFraction {this, "NoisyWaferFraction", 0.500}
FloatProperty	m_noisyChipFraction {this, "NoisyChipFraction", 0.500}
IntegerProperty	m_maxtbins {this, "HVBinWidth", 5}
UnsignedIntegerProperty	m_deadStripMinStat {this, "DeadStripMinStat", 200000}
UnsignedIntegerProperty	m_deadStripMinStatBusy {this, "DeadStripMinStatBusy", 1600000}
UnsignedIntegerProperty	m_deadChipMinStat {this, "DeadChipMinStat", 200000}
UnsignedIntegerProperty	m_deadStripSignificance {this, "DeadStripSignificance", 10}
UnsignedIntegerProperty	m_deadChipSignificance {this, "DeadChipSignificance", 10}
FloatProperty	m_busyThr4DeadFinding {this, "BusyThr4DeadFinding", 1E-4}
FloatProperty	m_noisyThr4DeadFinding {this, "NoisyThr4DeadFinding", 1.500E-3}
BooleanProperty	m_deadChipUploadTest {this, "DeadChipUploadTest", true}
BooleanProperty	m_deadStripUploadTest {this, "DeadStripUploadTest", true}
BooleanProperty	m_deadNotQuiet {this, "DeadNotQuiet", true}
FloatProperty	m_quietThresholdStrip {this, "QuietThresholdStrip", 0.5}
FloatProperty	m_quietThresholdChip {this, "QuietThresholdChip", 0.5}
BooleanProperty	m_noiseOccupancyTriggerAware {this, "NoiseOccupancyTriggerAware", true}
UnsignedIntegerProperty	m_noiseOccupancyMinStat {this, "NoiseOccupancyMinStat", 50000}
UnsignedIntegerProperty	m_rawOccupancyMinStat {this, "RawOccupancyMinStat", 50000}
UnsignedIntegerProperty	m_efficiencyMinStat {this, "EfficiencyMinStat", 50000}
BooleanProperty	m_efficiencyDoChips {this, "EfficiencyDoChips", true}
UnsignedIntegerProperty	m_BSErrorDBMinStat {this, "BSErrorDBMinStat", 50000}
UnsignedIntegerProperty	m_LorentzAngleMinStat {this, "LorentzAngleMinStat", 50000}
BooleanProperty	m_LorentzAngleDebugMode {this, "LorentzAngleDebugMode", true}
StringProperty	m_tagID4NoisyStrips {this, "TagID4NoisyStrips", "SctDerivedMonitoring-001-00"}
StringProperty	m_tagID4DeadStrips {this, "TagID4DeadStrips", "SctDerivedDeadStrips-001-00"}
StringProperty	m_tagID4DeadChips {this, "TagID4DeadChips", "SctDerivedDeadChips-001-00"}
StringProperty	m_tagID4NoiseOccupancy {this, "TagID4NoiseOccupancy", "SctDerivedNoiseOccupancy-001-00"}
StringProperty	m_badStripsAllFile {this, "BadStripsAllFile", "BadStripsAllFile.xml", "Output XML for all noisy strips"}
StringProperty	m_badStripsNewFile {this, "BadStripsNewFile", "BadStripsNewFile.xml", "Output XML for newly found noisy strips (i.e. not in config/calib data)"}
StringProperty	m_badStripsSummaryFile {this, "BadStripsSummaryFile", "BadStripsSummaryFile.xml", "Output XML for summary info from noisy strip search"}
StringProperty	m_badModulesFile {this, "BadModulesFile", "BadModulesFile.xml", "Output XML for HV trips"}
StringProperty	m_deadStripsFile {this, "DeadStripsFile", "DeadStripsFile.xml", "Output XML for dead strips"}
StringProperty	m_deadChipsFile {this, "DeadChipsFile", "DeadChipsFile.xml", "Output XML for dead chips"}
StringProperty	m_deadSummaryFile {this, "DeadSummaryFile", "DeadSummaryFile.xml", "Output XML for summary of Dead Finding"}
StringProperty	m_noiseOccupancyFile {this, "NoiseOccupancyFile", "NoiseOccupancyFile.xml", "Output XML for noise occupancy"}
StringProperty	m_noiseOccupancySummaryFile {this, "NoiseOccupancySummaryFile", "NoiseOccupancySummaryFile.xml", "Output XML for summary of noise occupancy"}
StringProperty	m_rawOccupancySummaryFile {this,"RawOccupancySummaryFile", "RawOccupancySummaryFile.xml", "Output XML for summary of raw occupancy"}
StringProperty	m_efficiencySummaryFile {this, "EfficiencySummaryFile", "EfficiencySummaryFile.xml", "Output XML for summary of efficiency"}
StringProperty	m_efficiencyModuleFile {this, "EfficiencyModuleFile", "EfficiencyModuleSummary.xml", "Output XML for efficiency"}
StringProperty	m_efficiencyChipFile {this, "EfficiencyChipFile", "EfficiencyChipSummary.xml", "Output XML for chip efficiency"}
StringProperty	m_BSErrorSummaryFile {this, "BSErrorSummaryFile", "BSErrorSummaryFile.xml", "Output XML for summary of BS Errors"}
StringProperty	m_BSErrorModuleFile {this, "BSErrorModuleFile", "BSErrorModuleSummary.xml", "Output XML for summary of BS Errors"}
StringProperty	m_LorentzAngleFile {this, "LorentzAngleFile", "LorentzAngleFile.xml", "Output XML for noise occupancy"}
StringProperty	m_LorentzAngleSummaryFile {this, "LorentzAngleSummaryFile", "LorentzAngleSummaryFile.xml", "Output XML for summary of lorentz angle"}
int	m_numOfLBsProcessed {0}
unsigned long long	m_numberOfEvents {0}
unsigned long long	m_numberOfEventsHist {0}
std::string	m_utcBegin
std::string	m_utcEnd
int	m_LBRange {-999}
IOVTime	m_iovStart
IOVTime	m_iovStop
TFile *	m_inputHist {nullptr}
bool	m_readHIST
std::vector< TProfile2D * >	m_pnoiseoccupancymapHistoVector
std::vector< TProfile2D * >	m_pnoiseoccupancymapHistoVectorECp
std::vector< TProfile2D * >	m_pnoiseoccupancymapHistoVectorECm
std::vector< TProfile * >	m_h_phiVsNstripsSideHistoVector
DataObjIDColl	m_extendedExtraObjects
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

Definition at line 65 of file SCTCalib.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
nbins
firstStrip
lastStrip
ntimeBins
firstTimeBin
lastTimeBin
n_hitBins
first_hitBin
last_hitBin
n_etaBins
first_etaBin
last_etaBin
n_phiBins
first_phiBin
last_phiBin
n_barrels
first_barrel
last_barrel
n_disks
first_disk
last_disk
n_etaBinsEC
first_etaBinEC
last_etaBinEC
n_phiBinsEC
first_phiBinEC
last_phiBinEC

Definition at line 77 of file SCTCalib.h.

           { nbins       = 6*128, firstStrip     =  0, lastStrip     = nbins-1,
             ntimeBins   =     3, firstTimeBin   =  0, lastTimeBin   =  2,
             n_hitBins   =    50, first_hitBin   =  0, last_hitBin   = 50,
             n_etaBins   =    13, first_etaBin   = -6, last_etaBin   =  6,
             n_phiBins   =    56, first_phiBin   =  0, last_phiBin   = 55,
             n_barrels   =     4, first_barrel   =  0, last_barrel   =  3,
             n_disks     =     9, first_disk     =  0, last_disk     =  8,
             n_etaBinsEC =     3, first_etaBinEC =  0, last_etaBinEC =  2,
             n_phiBinsEC =    52, first_phiBinEC =  0, last_phiBinEC = 51
           };

anonymous enum

anonymous enum

private

Enumerator
n_chipPerSide
n_chipPerModule
n_stripPerChip
n_etaInBarrel
n_phiBinsB0
n_phiBinsB1
n_phiBinsB2
n_phiBinsB3
n_phiBinsECShort
n_phiBinsECMiddle
n_phiBinsECOuter
n_elements
n_BSErrorType
firstBSErrorType
lastBSErrorType

Definition at line 89 of file SCTCalib.h.

           { n_chipPerSide = 6, n_chipPerModule = 12, n_stripPerChip = 128, n_etaInBarrel = 12,
             n_phiBinsB0 = 32, n_phiBinsB1 = 40, n_phiBinsB2 = 48, n_phiBinsB3 = 56,
             n_phiBinsECShort = 40, n_phiBinsECMiddle = 40, n_phiBinsECOuter = 52, n_elements=8176,
             n_BSErrorType = 15, firstBSErrorType = 0, lastBSErrorType = 14
           };

Constructor & Destructor Documentation

SCTCalib()

SCTCalib::SCTCalib	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 112 of file SCTCalib.cxx.

                                                                  :
   AthAlgorithm(name, pSvcLocator)
{
   m_readHIST = m_doNoiseOccupancy or m_doRawOccupancy or m_doEfficiency or m_doBSErrorDB or m_doLorentzAngle;
}

~SCTCalib()

SCTCalib::~SCTCalib ( )

default

Member Function Documentation

addStripsToList()

StatusCode SCTCalib::addStripsToList ( const EventContext & ctx, Identifier & waferId, std::set< Identifier > & stripIdList, bool isNoisy, bool isNew ) const

private

Definition at line 2741 of file SCTCalib.cxx.

                                                                                                                                       {
   IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
   float noisyStripThr{m_noisyStripThrDef ? (m_noisyStripThrOffline):(m_noisyStripThrOnline)};
   for (int iStrip{0}; iStrip != nbins; ++iStrip) {
      Identifier stripId{m_pSCTHelper->strip_id(waferId, iStrip)};
      if (!isNoisy) { //--- Add all strips
         stripIdList.insert(stripId);
      } else {
         const float stripOccupancy{ (float) m_calibHitmapTool->getBinForHistogramIndex(iStrip + 1, waferHash.value()) / m_numberOfEvents};
         if (stripOccupancy > noisyStripThr) {
            if (!isNew) { //--- All noisy strips
               stripIdList.insert(stripId);
            } else { //--- New noisy strips : compared with configuration and calibration
               const bool isGoodInConfiguration{m_useConfiguration ? m_ConfigurationConditionsTool->isGood(stripId, ctx, InDetConditions::SCT_STRIP) : true};
               const bool isGoodInCalibration{m_useCalibration ? m_ReadCalibDataTool->isGood(stripId, ctx, InDetConditions::SCT_STRIP) : true};
               if (m_useConfiguration or m_useCalibration) {
                  if (isGoodInConfiguration and isGoodInCalibration) {
                     stripIdList.insert(stripId);
                  }
               }
            }
         }
      }
   }
   return StatusCode::SUCCESS;
}

addToSummaryStr()

StatusCode SCTCalib::addToSummaryStr ( std::ostringstream & list, const Identifier & waferId, const char * type, const char * stripId, const char * chipId ) const

private

Definition at line 2611 of file SCTCalib.cxx.

                                                                                                                                                       {
   //--- Remove first&end spaces in DefectList
   const std::string tmpstrip{stripId};
   const std::string tmpchip{chipId};
   int len_strip{static_cast<int>(tmpstrip.length())};
   int len_chip{static_cast<int>(tmpchip.length())};
   std::string stripList{""};
   std::string chipList{""};
   if (len_strip > 0) {
     int stringLength = (len_strip-2 >0) ? len_strip-2 : len_strip;
     stripList = tmpstrip.substr(1, stringLength);
   }
   if (len_chip  > 0) {
    int stringLength = (len_chip-2 >0) ? len_chip-2 : len_chip;
     chipList  = tmpchip.substr(1, stringLength);
   }
   //--- Identifier/SN
   IdentifierHash   waferHash{m_pSCTHelper->wafer_hash(waferId)};
   SCT_SerialNumber sn{m_CablingTool->getSerialNumberFromHash(waferHash)};
   //--- Preparing linkList
   std::string linkList{chipList2LinkList(stripList)};
   //--- Push to summary stream
   XmlStreamer m{"module", list};
   {
      XmlStreamer v{"value", "name", "SN", list};
      list << sn.str();
   }
   {
      XmlStreamer v{"value", "name", "BecLayerPhiEta", list};
      list << formatPosition(waferId, m_pSCTHelper, ".", false);
   }
   {
      XmlStreamer v{"value", "name", "LinkID", list};
      list << linkList;
   }
   {
      XmlStreamer v{"value", "name", "ChipID", list};
      list << stripList;
   }
   if (!strcmp(type, "DEAD")) {
      XmlStreamer v{"value", "name", "StripIDOnline", list};
      list << stripList;
   } else {
      ATH_MSG_ERROR("in addToSummaryStr : argument \"type\" needs to be \"DEAD\".");
      return StatusCode::FAILURE;
   }
 
   return StatusCode::SUCCESS;
}

addToXML4DB()

StatusCode SCTCalib::addToXML4DB ( std::ofstream & file, const Identifier & waferId, const char * DefectType, float Threshold, const char * DefectList ) const

private

Definition at line 2485 of file SCTCalib.cxx.

                                                                                                                                                    {
   std::string tmp{DefectList};
   int length{static_cast<int>(tmp.length())};
   std::string Defect4DB{tmp.substr(1, length-2)}; // Removing first&end spaces in DefectList
 
   file << xmlOpenChannel(m_pSCTHelper->module_id(waferId).get_identifier32().get_compact(), m_iovStart.re_time(), m_iovStop.re_time()) << linefeed
        << xmlValue("SampleSize", "10000") << linefeed
        << xmlValue("BarrelEndcap", m_pSCTHelper->barrel_ec(waferId)) << linefeed
        << xmlValue("Layer", m_pSCTHelper->layer_disk(waferId)) << linefeed
        << xmlValue("Eta", m_pSCTHelper->eta_module(waferId)) << linefeed
        << xmlValue("Phi", m_pSCTHelper->phi_module(waferId)) << linefeed
        << xmlValue("DefectType", DefectType) << linefeed
        << xmlValue("Threshold", Threshold) << linefeed
        << xmlValue("DefectList", Defect4DB) << linefeed
        << xmlCloseChannel() << std::endl;
 
   return StatusCode::SUCCESS;
}

ATLAS_NOT_THREAD_SAFE() [1/9]

StatusCode getLorentzAngle SCTCalib::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [2/9]

StatusCode getBSErrors SCTCalib::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [3/9]

StatusCode getEfficiency SCTCalib::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [4/9]

StatusCode getRawOccupancy SCTCalib::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [5/9]

StatusCode getNoiseOccupancy SCTCalib::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [6/9]

StatusCode getDeadStrip SCTCalib::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [7/9]

StatusCode getNoisyStrip SCTCalib::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [8/9]

virtual StatusCode stop SCTCalib::ATLAS_NOT_THREAD_SAFE ( )

overridevirtual

ATLAS_NOT_THREAD_SAFE() [9/9]

StatusCode writeModuleListToCool SCTCalib::ATLAS_NOT_THREAD_SAFE ( const std::map< Identifier, std::set< Identifier > > & moduleListAll, const std::map< Identifier, std::set< Identifier > > & moduleListNew, const std::map< Identifier, std::set< Identifier > > & moduleListRef )

private

closeXML4DB()

StatusCode SCTCalib::closeXML4DB ( std::ofstream & file ) const

private

Definition at line 2474 of file SCTCalib.cxx.

                                                        {
   file << "</channels>" << std::endl;
   if (file.is_open()) {
      file.close();
      return StatusCode::SUCCESS;
   } else {
      return StatusCode::FAILURE;
   }
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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; }

doHVPrintXML()

void SCTCalib::doHVPrintXML ( const std::pair< int, int > & timeInterval, const std::pair< int, int > & lbRange, Identifier waferId )

private

doHVPrintXML() Prints XML file for hv modules

Definition at line 469 of file SCTCalib.cxx.

                                                                                                                       {
   const IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
   const SCT_SerialNumber sn{m_CablingTool->getSerialNumberFromHash(waferHash)};
 
   XmlStreamer mod{"module", m_gofile};
   {
      XmlStreamer v{"value", "name", "SN", m_gofile};
      m_gofile << sn.str();
   }
   {
      XmlStreamer v{"value", "name", "BecLayerPhiEta", m_gofile};
      m_gofile << formatPosition(waferId, m_pSCTHelper, ".", false);
   }
   {
      XmlStreamer v{"value", "name", "StartTime", m_gofile};
      m_gofile << timeInterval.first;
   }
   {
      XmlStreamer v{"value", "name", "EndTime", m_gofile};
      m_gofile << timeInterval.second;
   }
   {
      XmlStreamer v{"value", "name", "StartLBN", m_gofile};
      m_gofile << lbRange.first;
   }
   {
      XmlStreamer v{"value", "name", "EndLBN", m_gofile};
      m_gofile << lbRange.second;
   }
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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; }

execute()

StatusCode SCTCalib::execute ( const EventContext & ctx )

overridevirtual

Execute method.

Provides access to the EventContext if needed but is non-const as opposed to AthReentrantAlgorithm.

Implements AthAlgorithm.

Definition at line 294 of file SCTCalib.cxx.

                                                    {
 
   ATH_MSG_DEBUG("----- in execute() ----- ");
 
   const bool majorityIsGoodOrUnused{(m_useMajority and m_MajorityConditionsTool->isGood(ctx)) or !m_useMajority};
   if (m_readBS) {
      //--- TimeStamp/LB range analyzed
      const int timeStamp{static_cast<int>(ctx.eventID().time_stamp())};
      const int lumiBlock{static_cast<int>(ctx.eventID().lumi_block())};
      int timeStampBeginOld;
      int timeStampEndOld;
      m_calibEvtInfoTool->getTimeStamps(timeStampBeginOld, timeStampEndOld);
      m_calibEvtInfoTool->setTimeStamp(std::min(timeStamp, timeStampBeginOld), std::max(timeStamp, timeStampEndOld));
      int lbBeginOld;
      int lbEndOld;
      m_calibEvtInfoTool->getLumiBlock(lbBeginOld, lbEndOld);
      m_calibEvtInfoTool->setLumiBlock(std::min(lumiBlock, lbBeginOld), std::max(lumiBlock, lbEndOld));
      m_calibEvtInfoTool->setLumiBlock(lumiBlock);
      m_calibEvtInfoTool->setTimeStamp(timeStamp);
      if (m_doHitMapsLB and majorityIsGoodOrUnused) {
         m_calibLbTool->setLb(ctx.eventID().lumi_block());
      }
   }
 
   //--- Fill histograms for (1) Number of events and (2) Hitmaps
   if (m_doHitMaps and majorityIsGoodOrUnused) m_calibHitmapTool->fill(m_readBS);
 
   //--- Fill histograms for (1) Number of events and (2) Hits as a function of LB
   if (m_doHitMapsLB and majorityIsGoodOrUnused) {
      m_calibLbTool->fill(m_readBS);
   }
 
   //--- Fill histograms for (1) Number of events and (2) BSErrors
   if (m_doHitMaps and m_doBSErrors) m_calibBsErrTool->fill(m_readBS);
 
   //--- Increment event counter : to be ready for the next event loop
   m_calibEvtInfoTool->incrementCounter();
 
   ATH_MSG_DEBUG("----- end of execute() ----- ");
 
   return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

filterPassed() [1/2]

bool AthAlgorithm::filterPassed ( ) const

inherited

Definition at line 94 of file AthAlgorithm.cxx.

                                      {
  return filterPassed( Gaudi::Hive::currentContext() );
}

filterPassed() [2/2]

bool AthAlgorithm::filterPassed ( const EventContext & ctx ) const

inherited

Definition at line 98 of file AthAlgorithm.cxx.

                                                             {
  return execState( ctx ).filterPassed();
}

finalize()

StatusCode SCTCalib::finalize ( )

overridevirtual

Finalize - delete any memory allocation from the heap.

Definition at line 451 of file SCTCalib.cxx.

                              {
   ATH_MSG_INFO("----- in finalize() ----- ");
 
   if (m_writeToCool) {
      if (!m_pCalibWriteTool.release().isSuccess()) {
         ATH_MSG_ERROR("Failed to release m_pCalibWriteTool");
         return StatusCode::FAILURE;
      }
   }
 
   return StatusCode::SUCCESS;
}

getContext()

const EventContext & AthAlgorithm::getContext ( ) const

inherited

Deprecated methods (use the ones with EventContext).

Definition at line 90 of file AthAlgorithm.cxx.

                                                   {
  return Gaudi::Hive::currentContext();
}

getLBList()

std::string SCTCalib::getLBList ( const std::set< int > & LBList ) const

private

Definition at line 3246 of file SCTCalib.cxx.

                                                             {
   std::string strList;
   strList.erase();
   if (!LBList.empty()) {
      int firstLB{-1};
      int LBSize{-1};
 
      std::set<int>::const_iterator LBItrFirst{LBList.begin()};
      std::set<int>::const_iterator LBItrLast{--LBList.end()};
 
      std::set<int>::const_iterator LBItr{LBList.begin()};
      std::set<int>::const_iterator LBItrE{LBList.end()};
      for (; LBItr != LBItrE; ++LBItr) {
         int iLB{*LBItr};
         if (LBItr == LBItrFirst) {
            firstLB = iLB;
            LBSize  = 1;
         } else {
            if (iLB == firstLB + LBSize) {
               ++LBSize;
            } else {
               int LBBegin{firstLB};
               int LBEnd{firstLB + LBSize -1};
               strList = m_pCalibWriteTool->addDefect(strList, LBBegin, LBEnd);
               firstLB = iLB;
               LBSize  = 1;
            }
         }
         if (LBItr == LBItrLast) {
            int LBBegin{firstLB};
            int LBEnd{iLB};
            strList = m_pCalibWriteTool->addDefect(strList, LBBegin, LBEnd);
         }
      }
   }
   return strList;
}

getNoisyChips()

std::set< int > SCTCalib::getNoisyChips ( const std::set< Identifier > & stripIdList ) const

private

Definition at line 3160 of file SCTCalib.cxx.

                                                                   {
   std::set<int> chipIdList;
   chipIdList.clear();
 
   // Get SCT_DetectorElementCollection
   SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEle{m_SCTDetEleCollKey};
   const InDetDD::SiDetectorElementCollection* elements{sctDetEle.retrieve()};
   if (elements==nullptr) {
      ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " could not be retrieved");
      return chipIdList;
   }
 
   //--- Minimum number of noisy strips for a noisy chip
   unsigned int noisyChipThr{static_cast<unsigned int>(m_noisyChipFraction*n_stripPerChip)};
   if (stripIdList.size() > noisyChipThr) {
      unsigned int numStripsPerChip[n_chipPerModule] = {0};
      //--- Loop over stripIdList
      std::set<Identifier>::const_iterator stripItr{stripIdList.begin()};
      std::set<Identifier>::const_iterator stripItrE{stripIdList.end()};
      for (; stripItr != stripItrE; ++stripItr) {
         Identifier stripId{*stripItr};
         int stripOffline{m_pSCTHelper->strip(stripId)};
         //--- Chip number : taken from SCT_ConfigurationConditionsTool::getChip
         IdentifierHash waferHash{m_pSCTHelper->wafer_hash(m_pSCTHelper->wafer_id(stripId))};
         const InDetDD::SiDetectorElement* pElement{elements->getDetectorElement(waferHash)};
         if (!pElement) {
            ATH_MSG_FATAL("Element pointer is nullptr");
            continue;
         }
         int stripOnline{(pElement->swapPhiReadoutDirection()) ? lastStrip - stripOffline : stripOffline};
         int chipId{m_pSCTHelper->side(stripId) == 0 ? stripOnline/n_stripPerChip : stripOnline/n_stripPerChip + n_chipPerSide};
         //--- Count number of noisy strips per chips
         ++numStripsPerChip[chipId];
      }
 
      //--- Insert noisy chips
      for (int iChip{0}; iChip != n_chipPerModule; ++iChip) {
         if (numStripsPerChip[iChip] > noisyChipThr) chipIdList.insert(iChip);
      }
   }
   return chipIdList;
}

getNoisyLB()

std::pair< std::string, float > SCTCalib::getNoisyLB ( const Identifier & moduleId, int & chipId ) const

private

Definition at line 3205 of file SCTCalib.cxx.

                                                                  {
   std::string defectLB{""}; //return value if invalid
   float defectLBFrac{0.0}; //return value if invalid
   float noisyStripThr{m_noisyStripThrDef?(m_noisyStripThrOffline):(m_noisyStripThrOnline)};
 
   //--- Identifier
   Identifier waferId{m_pSCTHelper->wafer_id(m_pSCTHelper->barrel_ec(moduleId),
                      m_pSCTHelper->layer_disk(moduleId),
                      m_pSCTHelper->phi_module(moduleId),
                      m_pSCTHelper->eta_module(moduleId),
                      chipId < n_chipPerSide ? 0 : 1)};
   IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
   //--- Histogram for this chip
   int chipPositionInSide{m_pSCTHelper->side(waferId) == 0 ? chipId : chipId - n_chipPerSide};
   int histIndex{static_cast<int>((waferHash.value())*n_chipPerSide + chipPositionInSide)};
 
   //--- Find LBs where this chip was noisy
   double chipOccupancyThr{noisyStripThr*n_stripPerChip*m_noisyChipFraction};
   std::set<int> LBList;
   LBList.clear();
   if (!m_calibLbTool) {
      ATH_MSG_ERROR("nullptr m_calibLbTool line " <<__LINE__);
      return std::make_pair(defectLB, defectLBFrac);
   }
 
   for (int iLB{0}; iLB != m_LBRange; ++iLB) {
      double numEventsInLB{static_cast<double>(m_calibLbTool->getNumberOfEventsInBin(iLB + 1))};
      if (numEventsInLB == 0) continue;
      double chipOccupancy{(float) m_calibLbTool->getBinForHistogramIndex(iLB + 1, histIndex) / numEventsInLB};
      if (chipOccupancy > chipOccupancyThr) LBList.insert(iLB);
   }
   //--- Transform LBList to string and calculate a fraction of noisy LBs
   if (LBList.size() != 0) {
      defectLB = getLBList(LBList);
      defectLBFrac = static_cast<float>(LBList.size()) / m_numOfLBsProcessed;
   }
 
   return std::make_pair(defectLB, defectLBFrac);
}

getNumNoisyStrips()

std::pair< int, bool > SCTCalib::getNumNoisyStrips ( const Identifier & waferId ) const

private

Definition at line 2714 of file SCTCalib.cxx.

                                                           {
   IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
   //--- Check if there are noisy strips in the wafer
   int numNoisyStripsInTheWafer{0};
   bool isNoisyWafer{false};
   float noisyStripThr{m_noisyStripThrDef ? (m_noisyStripThrOffline) : (m_noisyStripThrOnline)};
   for (int iStrip{0}; iStrip != nbins; ++iStrip) {
      if ( (float) m_calibHitmapTool->getBinForHistogramIndex(iStrip + 1, waferHash.value()) / m_numberOfEvents > noisyStripThr) ++numNoisyStripsInTheWafer;
   }
   //--- Define/counts noisy wafers using wafer occupancy and number of noisy strips
   double averageOccupancy{m_calibHitmapTool->size(waferHash.value())/static_cast<double>(nbins)/static_cast<double>(m_numberOfEvents)};
   const int subdetector{m_pSCTHelper->barrel_ec(waferId)};
   isNoisyWafer = (numNoisyStripsInTheWafer > m_noisyWaferFraction*nbins) and
                  ((subdetector == ENDCAP_C and averageOccupancy > m_noisyWaferThrECC) or
                   (subdetector == BARREL   and averageOccupancy > m_noisyWaferThrBarrel) or
                   (subdetector == ENDCAP_A and averageOccupancy > m_noisyWaferThrECA));
   if (isNoisyWafer) {
      ATH_MSG_INFO("Module: " << waferHash.value());
      ATH_MSG_INFO("Hits, Nevts, Occ: " << m_calibHitmapTool->size(waferHash.value()) << ", "
                   << m_numberOfEvents << ", "
                   << averageOccupancy);
   }
   return std::make_pair(numNoisyStripsInTheWafer, isNoisyWafer);
}

getOverlapStripList()

std::set< Identifier > SCTCalib::getOverlapStripList ( const std::set< Identifier > & stripAllIdList, const std::set< Identifier > & stripRefIdList ) const

private

Definition at line 2828 of file SCTCalib.cxx.

                                                                                                                         {
   std::set<Identifier> stripList;
   std::set<Identifier>::const_iterator stripAllItrLast  = stripAllIdList.end();
   std::set<Identifier>::const_iterator stripRefItrLast  = stripRefIdList.end();
 
   std::set<Identifier>::const_iterator stripAllItr  = stripAllIdList.begin();
   for ( ; stripAllItr != stripAllItrLast; ++stripAllItr ) {
      std::set<Identifier>::const_iterator stripRefItr  = stripRefIdList.begin();
      bool old = false;
      for ( ; stripRefItr != stripRefItrLast; ++stripRefItr ) {
         if (*stripAllItr ==  *stripRefItr) old = true;
      }
      if (!old) {
         stripList.insert(*stripAllItr);
      }
   }
   return stripList;
}

getStripList()

std::string SCTCalib::getStripList ( const std::set< Identifier > & stripIdList ) const

private

Definition at line 2849 of file SCTCalib.cxx.

                                                                  {
   std::string strList;
   if (!stripIdList.empty()) {
      int firstStrip{-1};
      int groupSize{-1};
 
      std::set<Identifier>::const_iterator stripItrFirst{stripIdList.begin()};
      std::set<Identifier>::const_iterator stripItrLast{--stripIdList.end()};
 
      std::set<Identifier>::const_iterator stripItr{stripIdList.begin()};
      std::set<Identifier>::const_iterator stripItrE{stripIdList.end()};
      for (; stripItr != stripItrE; ++stripItr) {
         Identifier stripId{*stripItr};
         int stripNum{m_pSCTHelper->side(stripId)*nbins + m_pSCTHelper->strip(stripId)};
         if (stripItr == stripItrFirst) {
            firstStrip = stripNum;
            groupSize  = 1;
         } else {
            if (stripNum == firstStrip + groupSize) {
               ++groupSize;
            } else {
               int stripBegin{firstStrip};
               int stripEnd{firstStrip + groupSize -1};
               strList = m_pCalibWriteTool->addDefect(strList, stripBegin, stripEnd);
               firstStrip = stripNum;
               groupSize  = 1;
            }
         }
         if (stripItr == stripItrLast) {
            int stripBegin{firstStrip};
            int stripEnd{stripNum};
            strList = m_pCalibWriteTool->addDefect(strList, stripBegin, stripEnd);
         }
      }
   }
   return strList;
}

initialize()

StatusCode SCTCalib::initialize ( )

overridevirtual

Definition at line 122 of file SCTCalib.cxx.

                                {
 
   ATH_MSG_INFO("----- in initialize() ----- ");
   if (detStore()->retrieve(m_pSCTHelper, "SCT_ID").isFailure()) {
      ATH_MSG_ERROR("Unable to retrieve SCTHelper");
      return StatusCode::FAILURE;
   }
 
   if (not retrievedService(m_pCalibWriteTool)) return StatusCode::FAILURE;
   if (m_doHV) ATH_MSG_FATAL("Not yet properly implemented and tested!");
 
   ATH_CHECK(m_ConfigurationConditionsTool.retrieve(EnableTool {m_useConfiguration}));
 
   if (not m_useCalibration) {
      ATH_MSG_DEBUG("ReadCalibDataTool was removed in initialization");
      m_ReadCalibDataTool.disable();
   } else {
      if (m_ReadCalibDataTool.retrieve().isFailure()) return StatusCode::FAILURE;
   }
 
   if (not m_useMajority) {
      ATH_MSG_DEBUG("MajorityConditionsTool was removed in initialization");
   } else {
      if (m_MajorityConditionsTool.retrieve().isFailure()) return StatusCode::FAILURE;
   }
 
   if (not retrievedService(m_calibHitmapTool)) return StatusCode::FAILURE;
 
   if (not retrievedService(m_calibModuleListTool)) return StatusCode::FAILURE;
 
   if (not retrievedService(m_calibEvtInfoTool)) return StatusCode::FAILURE;
 
   if (not m_useBSError) {
      ATH_MSG_DEBUG("ByteStreamErrorsSvc was removed in initialization");
   } else {
      if (not retrievedService(m_calibBsErrTool)) return StatusCode::FAILURE;
   }
   if (not retrievedService(m_calibLbTool)) return StatusCode::FAILURE;
 
   ATH_CHECK(m_CablingTool.retrieve());
   ATH_CHECK(m_SCTDetEleCollKey.initialize());
 
   //--- LB range
   try {
      m_LBRange = std::stoi(m_LBMax);
      m_calibHitmapTool->setNumberOfLb(m_LBRange);
      m_calibLbTool->setNumberOfLb(m_LBRange);
      m_calibBsErrTool->setNumberOfLb(m_LBRange);
   } catch (...) {
      ATH_MSG_ERROR("Couldn't cast m_LBMax=\"" << m_LBMax << "\" to m_LBRange...");
      m_LBRange = 0;
   }
 
   m_calibHitmapTool->setLbToMerge(m_nLbsMerged);
   m_calibLbTool->setLbToMerge(m_nLbsMerged);
   m_calibBsErrTool->setLbToMerge(m_nLbsMerged);
 
   m_readHIST = m_doNoiseOccupancy or m_doRawOccupancy or m_doEfficiency or m_doBSErrorDB or m_doLorentzAngle;
 
   if (m_readBS and m_readHIST) {
      ATH_MSG_ERROR("Both BS and HIST are set to be read. Choose either of BS or HIST.");
      return StatusCode::FAILURE;
   }
 
   //--- Open BS
   if (m_readBS) {
      ATH_MSG_INFO("------------> Reading from ByteStream <-------------");
      m_calibEvtInfoTool->setSource("BS");
   }
 
   //--- Open HIST
   if (m_readHIST) {
      ATH_MSG_INFO("------------> Reading from HIST <-------------");
      m_calibEvtInfoTool->setSource("HIST");
      //--- List of HIST
      std::string hist{""};
      std::vector<std::string> histCollection{m_input_hist.value()};
      ATH_MSG_INFO("The input histogram name is : " << m_input_hist);
      if (not histCollection.empty()) {
         hist=histCollection.back();
         if (histCollection.size() > 1) ATH_MSG_WARNING("The Histogram collection contains more than one histogram; using the last one.");
      } else {
         ATH_MSG_ERROR("The input histogram collection property is empty");
         return StatusCode::FAILURE;
      }
 
      //in case of DeadStrip or DeadChip, change open from EOS to
      //copy and open locally. Delete the file after processing
      m_inputHist = TFile::Open(hist.c_str());
 
      ATH_MSG_INFO("opening HIST file : " << hist.c_str());
 
      if (m_inputHist) {
         //--- Check run number
         const std::string os{std::to_string(m_runNumber.value())};
         ATH_MSG_INFO("Getting HIST directory : " << m_runNumber.value());
         if (not m_inputHist->GetDirectory("/run_"+TString{os})) {
            ATH_MSG_ERROR("RunNumber in HIST is inconsistent with jobO : " << os);
            return StatusCode::FAILURE ;
         }
         ATH_MSG_INFO("Getting Number of events: " << m_calibEvtInfoTool->counter());
         //--- Read number of events : Previously from entry of "tier0ESD" in "/GLOBAL/DQTDataFlow/events_lb"
         std::string osHist{std::string{"/run_"} + std::to_string(m_runNumber.value())+"/SCT/GENERAL/Conf/NumberOfEventsVsLB"};
         TH1F* hist_events{dynamic_cast<TH1F*>(m_inputHist->Get(osHist.c_str()))};
         m_numberOfEventsHist = hist_events->GetEntries();
      } else {
         ATH_MSG_WARNING("can not open HIST : " << hist.c_str());
      }
 
 
      ATH_MSG_INFO("Initialization of TimeStamp/LB, taken from runInfo.txt");
      //--- Initialization of TimeStamp/LB, taken from runInfo.txt
      m_calibEvtInfoTool->setSource("HIST");
      m_calibEvtInfoTool->setTimeStamp(m_runStartTime, m_runEndTime);
      m_calibEvtInfoTool->setRunNumber(m_runNumber);
      m_calibEvtInfoTool->setEventNumber(m_eventNumber);
   }
 
   //--- Booking histograms for hitmaps
   if (m_doHitMaps) m_calibHitmapTool->book();
   //--- Booking histograms for BSErrors
   if (m_doHitMaps and m_doBSErrors) m_calibBsErrTool->book();
 
   //--- Reading histograms for hitmaps
   if ((not m_doHitMaps and not m_doHitMapsLB) and m_readHitMaps) {
      ATH_MSG_INFO("Set CalibEventInfo for m_readHitMaps == true");
      m_calibEvtInfoTool->setSource("HIST");
      m_calibHitmapTool->read("./SCTHitMaps.root");
      m_numberOfEventsHist = m_calibHitmapTool->size();
      m_calibEvtInfoTool->setTimeStamp(m_runStartTime, m_runEndTime);
      m_calibEvtInfoTool->setRunNumber(m_runNumber);
      m_calibEvtInfoTool->setEventNumber(m_eventNumber);
      if (m_doNoisyStrip) {
         m_calibLbTool->read("./SCTLB.root");
      }
      if (m_doBSErrors) {
         m_calibBsErrTool->read("./SCTBSErrors.root");
      }
   }
   //--- Hit-vs-LB for LBs in noisy links/chips
   if (m_doHitMapsLB) m_calibLbTool->book();
 
   //--- Check statistics for NoiseOccupancy
   if (m_doNoiseOccupancy and notEnoughStatistics(m_noiseOccupancyMinStat, m_numberOfEventsHist)) return StatusCode::FAILURE;
   //--- Check statistics for RawOccupancy
   if (m_doRawOccupancy and notEnoughStatistics(m_rawOccupancyMinStat, m_numberOfEventsHist)) return StatusCode::FAILURE;
   //--- Check statistics for Efficiency
   if (m_doEfficiency and notEnoughStatistics(m_efficiencyMinStat, m_numberOfEventsHist)) return StatusCode::FAILURE;
   //--- Check statistics for BSError
   if (m_doBSErrorDB and notEnoughStatistics(m_BSErrorDBMinStat, m_numberOfEventsHist)) return StatusCode::FAILURE;
   //--- Check statistics for LorentzAngle
   if (m_doLorentzAngle and notEnoughStatistics(m_LorentzAngleMinStat, m_numberOfEventsHist)) return StatusCode::FAILURE;
   //
 
   ATH_MSG_INFO("----- end of initialize() ----- ");
   return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const

inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 111 of file AthAlgorithm.h.

{ return false; }

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

noisyStripsToSummaryXml()

StatusCode SCTCalib::noisyStripsToSummaryXml ( const std::map< Identifier, std::set< Identifier > > & moduleListAll, const std::map< Identifier, std::set< Identifier > > & moduleListRef, const std::string & badStripsFile ) const

private

Definition at line 2937 of file SCTCalib.cxx.

                                            {
 
   ATH_MSG_DEBUG("noisyStripsToSummaryXml: start");
 
   //--- Open
   const char* outputFileName{badStripsFile.c_str()};
   std::ofstream outFile{outputFileName, std::ios::out};
   if (!outFile.good()) {
      ATH_MSG_ERROR("Unable to open " << outputFileName);
      return(StatusCode::FAILURE);
   }
 
   //--- Initialization
   int numLinksAll{0}, numChipsAll{0};
   int numModulesAll{0},  numModulesRef{0};
   int numStripsAll{0}, numStripsNew{0}, numStripsRef{0};
   int numModulesDiff{0};
 
   std::string defectLinks, defectChips;
   std::string defectStripsAll, defectStripsNew, defectStripsRef;
   std::ostringstream osModuleList, osChipList;
 
   //--- Create module list
   SCT_ID::const_id_iterator waferItr{m_pSCTHelper->wafer_begin()};
   SCT_ID::const_id_iterator waferItrE{m_pSCTHelper->wafer_end()};
   ATH_MSG_DEBUG("noisyStripsToSummaryXml: before wafer loop");
   for (; waferItr != waferItrE; ++waferItr) {
      //--- Identifier
      Identifier waferId{*waferItr};
      Identifier moduleId{m_pSCTHelper->module_id(waferId)};
      IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
      SCT_SerialNumber sn{m_CablingTool->getSerialNumberFromHash(waferHash)};
 
      //--- Initialization for a module
      if (m_pSCTHelper->side(waferId) == 0) {
         defectLinks.erase();
         defectChips.erase();
         defectStripsAll.erase();
         defectStripsNew.erase();
         defectStripsRef.erase();
      }
 
      //--- Noisy links
      bool isNoisyWafer{getNumNoisyStrips(waferId).second}; // true if this wafer is noisy
      if (isNoisyWafer) {
         int link{m_pSCTHelper->side(waferId)};
         defectLinks = m_pCalibWriteTool->addDefect(defectLinks, link, link);
         ++numLinksAll;
      }
 
      //--- Execute once in this module
      if (m_pSCTHelper->side(waferId) == 1) {
         ATH_MSG_DEBUG("noisyStripsToSummaryXml: ALL");
         //--- Noisy strips : All
         std::map< Identifier, std::set<Identifier> >::const_iterator moduleAllItr{moduleListAll.find(moduleId)};
         if (moduleAllItr != moduleListAll.end()) {
            defectStripsAll = getStripList((*moduleAllItr).second);
            ++numModulesAll;
            numStripsAll += (*moduleAllItr).second.size();
         }
 
         ATH_MSG_DEBUG("noisyStripsToSummaryXml: REF");
         //--- Noisy strips : Ref
         std::map< Identifier, std::set<Identifier> >::const_iterator moduleRefItr{moduleListRef.find(moduleId)};
         if (moduleRefItr != moduleListRef.end()) {
            defectStripsRef = getStripList(moduleRefItr->second);
            ++numModulesRef;
            numStripsRef += moduleRefItr->second.size();
         }
 
         ATH_MSG_DEBUG("noisyStripsToSummaryXml: NEW");
         //--- Noisy strips : New
         if ( moduleAllItr != moduleListAll.end() ) {
            if ( moduleRefItr != moduleListRef.end() ) {
               std::set<Identifier> listNEW = getOverlapStripList( (*moduleAllItr).second,  (*moduleRefItr).second );
               defectStripsNew = getStripList( listNEW );
               numStripsNew += listNEW.size();
            } else {
               
               defectStripsNew = getStripList( (*moduleAllItr).second );
            }
         }
 
         ATH_MSG_DEBUG("noisyStripsToSummaryXml: stripIdList -> chipIdList");
         //--- Noisy chips : stripIdList -> chipIdList
         if (moduleAllItr != moduleListAll.end()) {
            std::set<int> chipIdList{getNoisyChips(moduleAllItr->second)};
            if (!chipIdList.empty()) {
               ++numChipsAll;
               std::set<int>::iterator chipItr{chipIdList.begin()};
               std::set<int>::iterator chipItrE{chipIdList.end()};
               for (; chipItr != chipItrE; ++chipItr) {
                  int chipId{*chipItr};
                  //--- To be written into module list
                  defectChips = m_pCalibWriteTool->addDefect(defectChips, chipId, chipId);
                  //--- LBs where this chip was noisy
                  std::pair< std::string, float > defectLB{getNoisyLB(moduleId, chipId)};
                  //--- Chip list written to XML
                  osChipList << "    <chip>"                                                                              << linefeed
                             << "      <value name=\"SN\">"             << sn.str()                         << "</value>" << linefeed
                             << "      <value name=\"BecLayerPhiEta\">" << m_pSCTHelper->barrel_ec(waferId) << "."
                             <<                                          m_pSCTHelper->layer_disk(waferId)  << "."
                             <<                                          m_pSCTHelper->phi_module(waferId)  << "."
                             <<                                          m_pSCTHelper->eta_module(waferId)  << "</value>" << linefeed
                             << "      <value name=\"ChipID\">"         << chipId                           << "</value>" << linefeed
                             << "      <value name=\"LB\">"             << normalizeList(defectLB.first)    << "</value>" << linefeed
                             << "      <value name=\"LBFraction\">"     << defectLB.second                  << "</value>" << linefeed
                             << "    </chip>"                                                                             << std::endl;
               }
            }
         }
         ATH_MSG_DEBUG("noisyStripsToSummaryXml: Difference between All & Ref");
         //--- Difference between All & Ref
         if (defectStripsAll != defectStripsRef) ++numModulesDiff;
         //--- Module list written to XML
         if (!defectStripsAll.empty() or (m_noisyUpdate and defectStripsAll != defectStripsRef)) {
            osModuleList << "    <module>"                                                                              << linefeed
                         << "      <value name=\"SN\">"              << sn.str()                          << "</value>" << linefeed
                         << "      <value name=\"BecLayerPhiEta\">"  << m_pSCTHelper->barrel_ec(waferId)  << "."
                         <<                                             m_pSCTHelper->layer_disk(waferId) << "."
                         <<                                             m_pSCTHelper->phi_module(waferId) << "."
                         <<                                             m_pSCTHelper->eta_module(waferId) << "</value>" << linefeed
                         << "      <value name=\"LinkID\">"          << normalizeList(defectLinks)        << "</value>" << linefeed
                         << "      <value name=\"ChipID\">"          << normalizeList(defectChips)        << "</value>" << linefeed
                         << "      <value name=\"StripOfflineAll\">" << normalizeList(defectStripsAll)    << "</value>" << linefeed
                         << "      <value name=\"StripOfflineNew\">" << normalizeList(defectStripsNew)    << "</value>" << linefeed
                         << "      <value name=\"StripOfflineRef\">" << normalizeList(defectStripsRef)    << "</value>" << linefeed
                         << "    </module>"                                                                             << std::endl;
         }
         ATH_MSG_DEBUG("noisyStripsToSummaryXml: After Difference between All & Ref");
      }
   }//--- end loop : waferItr
 
   ATH_MSG_DEBUG("noisyStripsToSummaryXml: after waferItr");
 
   //--- Upload flag
   std::string strUploadFlag{"U"};
 
   bool isRunsInCool{false};
   bool isNoisyMinStat{false}, isNoisyModuleList{false}, isNoisyModuleDiff{false}, isNoisyStripDiff{false};
   if (m_noisyUploadTest) {
      isRunsInCool = ((m_noisyModuleAverageInDB != -1.) and (m_noisyStripLastRunInDB != -999));
      if (isRunsInCool) {
         isNoisyMinStat    = m_numberOfEvents > m_noisyMinStat;
         isNoisyModuleList = numModulesAll < m_noisyModuleList;
         isNoisyModuleDiff = ((static_cast<float>(numModulesAll) - m_noisyModuleAverageInDB)/m_noisyModuleAverageInDB) < m_noisyModuleDiff;
         isNoisyStripDiff = ((static_cast<float>(numStripsAll) - m_noisyStripAverageInDB)/m_noisyStripAverageInDB) < m_noisyStripDiff;
         if (!isNoisyMinStat or !isNoisyModuleList) {
            strUploadFlag = "R";
         } else {
            if (!isNoisyModuleDiff or !isNoisyStripDiff) {
               strUploadFlag = "Y";
            } else {
               strUploadFlag = "G";
            }
         }
      }
   }
 
   ATH_MSG_DEBUG("noisyStripsToSummaryXml: after FlagChecking");
 
   //--- Upload test result to XML
   std::ostringstream osNoisyMinStat, osNoisyModuleList, osNoisyModuleDiff, osNoisyStripDiff;
   osNoisyMinStat    << "#events more than "                                                                      << m_noisyMinStat.value();
   osNoisyModuleList << "#(modules w/ at least 1 noisy strip) less than "                                         << m_noisyModuleList.value();
   osNoisyModuleDiff << "Increase of #(modules w/ at least 1 noisy strip) from average of recent runs less than " << m_noisyModuleDiff*100 << "%";
   osNoisyStripDiff  << "Increase of #(noisy strips) from average of recent runs less than "                      << m_noisyStripDiff*100 << "%";
 
   std::ostringstream osFlagReason;
   if (!isNoisyMinStat)    osFlagReason << "FAILED in " << osNoisyMinStat.str()    << "; ";
   if (!isNoisyModuleList) osFlagReason << "FAILED in " << osNoisyModuleList.str() << "; ";
   if (!isNoisyModuleDiff) osFlagReason << "FAILED in " << osNoisyModuleDiff.str() << "; ";
   if (!isNoisyStripDiff)  osFlagReason << "FAILED in " << osNoisyStripDiff.str();
 
   std::string strFlagEnable = m_noisyUploadTest ? "ENABLED"   : "DISABLED";
   std::string strRunsInCool = isRunsInCool      ? "AVAILABLE" : "UNAVAILABLE";
 
   std::ostringstream osCheckList;
   osCheckList << osNoisyMinStat.str()    << "; "
               << osNoisyModuleList.str() << "; "
               << osNoisyModuleDiff.str() << "; "
               << osNoisyStripDiff.str();
 
   //--- Write out the contents to XML file
   outFile << xmlHeader                                                                                << linefeed
           << associateStylesheet("BadStrips.xsl")                                                     << linefeed
           << "<run>"                                                                                  << linefeed
           << "  <value name=\"RunNumber\">"        << m_runNumber.value()               << "</value>" << linefeed
           << "  <value name=\"StartTime\">"        << m_utcBegin                        << "</value>" << linefeed
           << "  <value name=\"EndTime\">"          << m_utcEnd                          << "</value>" << linefeed
           << "  <value name=\"Duration\">"         << m_calibEvtInfoTool->duration()    << "</value>" << linefeed
           << "  <value name=\"LB\">"               << m_numOfLBsProcessed               << "</value>" << linefeed
           << "  <value name=\"Events\">"           << m_numberOfEvents                  << "</value>" << linefeed
           << "  <value name=\"Modules\">"          << numModulesAll                     << "</value>" << linefeed
           << "  <value name=\"Links\">"            << numLinksAll                       << "</value>" << linefeed
           << "  <value name=\"Chips\">"            << numChipsAll                       << "</value>" << linefeed
           << "  <value name=\"StripsOfflineAll\">" << numStripsAll                      << "</value>" << linefeed
           << "  <value name=\"StripsOfflineNew\">" << numStripsNew                      << "</value>" << linefeed
           << "  <value name=\"ModulesRef\">"       << numModulesRef                     << "</value>" << linefeed
           << "  <value name=\"StripsOfflineRef\">" << numStripsRef                      << "</value>" << linefeed
           << "  <value name=\"ModulesDiff\">"      << numModulesDiff                    << "</value>" << linefeed
           << "  <value name=\"Flag\">"             << strUploadFlag                     << "</value>" << linefeed
           << "  <value name=\"FlagReason\">"       << osFlagReason.str()                << "</value>" << linefeed
           << "  <value name=\"FlagEnable\">"       << strFlagEnable                     << "</value>" << linefeed
           << "  <value name=\"ReadCool\">"         << strRunsInCool                     << "</value>" << linefeed
           << "  <value name=\"CheckList\">"        << osCheckList.str()                 << "</value>" << linefeed
           << "  <chips>"                                                                              << linefeed
           << osChipList.str()
           << "  </chips>"                                                                             << linefeed
           << "  <modules>"                                                                            << linefeed
           << osModuleList.str()
           << "  </modules>"                                                                           << linefeed
           << "</run>"                                                                                 << std::endl;
 
   ATH_MSG_DEBUG("noisyStripsToSummaryXml: before return");
 
   return StatusCode::SUCCESS;
}

noisyStripsToXml()

StatusCode SCTCalib::noisyStripsToXml ( const std::map< Identifier, std::set< Identifier > > & moduleList, const std::string & badStripsFile ) const

private

Definition at line 2889 of file SCTCalib.cxx.

                                                                                                                         {
   //--- Open
   const char* outputFileName{badStripsFile.c_str()};
   std::ofstream outFile{outputFileName, std::ios::out};
   if (!outFile.good()) {
      ATH_MSG_ERROR("Unable to open " << outputFileName);
      return(StatusCode::FAILURE);
   }
   float noisyStripThr{m_noisyStripThrDef ? (m_noisyStripThrOffline) : (m_noisyStripThrOnline)};
   //--- Create module list
   std::ostringstream osModuleList;
   //--- Loop over wafers
   SCT_ID::const_id_iterator waferItr{m_pSCTHelper->wafer_begin()};
   SCT_ID::const_id_iterator waferItrE{m_pSCTHelper->wafer_end()};
   for (; waferItr != waferItrE; ++waferItr) {
      Identifier waferId{*waferItr};
      Identifier moduleId{m_pSCTHelper->module_id(waferId)};
      if (m_pSCTHelper->side(waferId) != 0) continue;
      std::map< Identifier, std::set<Identifier> >::const_iterator moduleItr{moduleList.find(moduleId)};
      if (moduleItr != moduleList.end()) {
         std::string defectStrips{getStripList((*moduleItr).second)};
         osModuleList << "  <channel id=\""    << m_pSCTHelper->module_id(waferId).get_compact()  << "\" "
                      << "since=\"" << m_iovStart.re_time()                                       << "\" "
                      << "until=\"" << m_iovStop.re_time()                                        << "\">"      << linefeed
                      << "    <value name=\"SampleSize\">"   << "10000"                           << "</value>" << linefeed
                      << "    <value name=\"BarrelEndcap\">" << m_pSCTHelper->barrel_ec(waferId)  << "</value>" << linefeed
                      << "    <value name=\"Layer\">"        << m_pSCTHelper->layer_disk(waferId) << "</value>" << linefeed
                      << "    <value name=\"Eta\">"          << m_pSCTHelper->eta_module(waferId) << "</value>" << linefeed
                      << "    <value name=\"Phi\">"          << m_pSCTHelper->phi_module(waferId) << "</value>" << linefeed
                      << "    <value name=\"DefectType\">"   << "NOISY"                           << "</value>" << linefeed
                      << "    <value name=\"Threshold\">"    << noisyStripThr                     << "</value>" << linefeed
                      << "    <value name=\"DefectList\">"   << normalizeList(defectStrips)       << "</value>" << linefeed
                      << "  </channel>"                                                                         << std::endl;
      }
   }
   //--- Write out the contents
   outFile << "<channels server=\"ATLAS_COOLPROD\" schema=\"ATLAS_COOLOFL_SCT\" dbname=\"CONDBR2\" folder=\"SCT/Derived/Monitoring\" "
           << "since=\""   << m_iovStart.re_time() << "\" "
           << "until=\""   << m_iovStop.re_time()  << "\" "
           << "tag=\""     << m_tagID4NoisyStrips  << "\" "
           << "version=\"" << "multi\">"           << std::endl
           << osModuleList.str()
           << "</channels>" << std::endl;
 
   return StatusCode::SUCCESS;
}

notEnoughStatistics()

bool SCTCalib::notEnoughStatistics ( const int required, const int obtained, const std::string & histogramName = "HIST" ) const

private

Definition at line 282 of file SCTCalib.cxx.

                                                                                                          {
   if (obtained<required) {
      ATH_MSG_ERROR("Number of events in " << histogramName << ": " << obtained << " is less than the required minimum number of events " << required);
      return true;
   }
   return false;
}

openXML4DB()

StatusCode SCTCalib::openXML4DB ( std::ofstream & file, const char * type, const char * tag, const IOVTime & start, const IOVTime & end ) const

private

Definition at line 2453 of file SCTCalib.cxx.

                                                                                                                                    {
   if (!strcmp(type, "DeadStrip")) {
      file.open(m_deadStripsFile.value().c_str(), std::ios::out);
      if (!file.good()) return StatusCode::FAILURE;
      file << "<channels server=\"ATLAS_COOLPROD\" schema=\"ATLAS_COOLOFL_SCT\" dbname=\"MONP200\" folder=\"SCT/Derived/DeadStrips\" ";
   } else if (!strcmp(type, "DeadChip")) {
      file.open(m_deadChipsFile.value().c_str(), std::ios::out);
      if (!file.good()) return StatusCode::FAILURE;
      file << "<channels server=\"ATLAS_COOLPROD\" schema=\"ATLAS_COOLOFL_SCT\" dbname=\"MONP200\" folder=\"SCT/Derived/DeadChips\" ";
   } else {
      ATH_MSG_ERROR("in openXML4DB : argument \"type\" needs to be (DeadStrip, DeadChip).");
      return StatusCode::FAILURE;
   }
   file << "since=\""   << start.re_time() << "\" "
        << "until=\""   << end.re_time()   << "\" "
        << "tag=\""     << tag             << "\" "
        << "version=\"" << "multi\">"      << linefeed;
   return StatusCode::SUCCESS;
}

openXML4DeadSummary()

StatusCode SCTCalib::openXML4DeadSummary ( std::ofstream & file, const char * type, int n_Module = 0, int n_Link = 0, int n_Chip = 0, int n_Strip = 0 ) const

private

Definition at line 2508 of file SCTCalib.cxx.

                                                                                                                                     {
   if (!strcmp(type, "DEAD")) {
      file.open(m_deadSummaryFile.value().c_str(), std::ios::out);
      if (!file.good()) return StatusCode::FAILURE;
      file << xmlHeader << linefeed << associateStylesheet("DeadInfo.xsl") << linefeed
           << "<run>" << linefeed;
   } else {
      ATH_MSG_ERROR("in openXML4DeadSummary : argument \"type\" needs to be \"DEAD\".");
      return StatusCode::FAILURE;
   }
 
   //--- Upload flag
   std::string strUploadFlag{"U"};
   bool isNonZero{false};
 
   if ((m_doDeadChip and m_deadChipUploadTest) or (m_doDeadStrip and m_deadStripUploadTest)) {
      if (n_Chip > 0) {
         isNonZero = true;
         strUploadFlag = "G";
      } else {
         strUploadFlag = "R";
      }
   }
 
   //--- Upload test result
   std::ostringstream osNonZero;
   osNonZero << "#chips or #strips is non-zero";
   std::ostringstream osFlagReason;
   if (!isNonZero) osFlagReason << "FAILED in " << osNonZero.str();
   std::string strFlagEnable{(m_deadChipUploadTest or m_deadStripUploadTest) ? "ENABLED" : "DISABLED"};
   std::ostringstream osCheckList;
   osCheckList << osNonZero.str();
 
   file << xmlValue("RunNumber",  m_runNumber.value())                 << linefeed
        << xmlValue("StartTime",  m_utcBegin)                          << linefeed
        << xmlValue("EndTime",    m_utcEnd)                            << linefeed
        << xmlValue("Duration",   m_calibEvtInfoTool->duration())      << linefeed
        << xmlValue("LB",         m_calibEvtInfoTool->numLumiBlocks()) << linefeed
        << xmlValue("Events",     m_numberOfEvents)                    << linefeed
        << xmlValue("Modules",    n_Module)                            << linefeed
        << xmlValue("Links",      n_Link)                              << linefeed
        << xmlValue("Chips",      n_Chip)                              << linefeed
        << xmlValue("Strips",     n_Strip)                             << linefeed
        << xmlValue("Flag",       strUploadFlag)                       << linefeed
        << xmlValue("FlagReason", osFlagReason.str())                  << linefeed
        << xmlValue("FlagEnable", strFlagEnable)                       << linefeed
        << xmlValue("CheckList",  osCheckList.str())                   << linefeed
        << "  <modules>"                                               << std::endl;
 
   return StatusCode::SUCCESS;
}

openXML4MonSummary()

StatusCode SCTCalib::openXML4MonSummary ( std::ofstream & file, const char * type ) const

private

Definition at line 2561 of file SCTCalib.cxx.

                                                                                 {
   using TwoStrings = std::pair<std::string, std::string>;
   using Names = std::map<std::string, TwoStrings>;
   Names nameAssociation;
   nameAssociation["NoiseOccupancy"] = TwoStrings(m_noiseOccupancySummaryFile, "NoiseOccupancyInfo.xsl");
   nameAssociation["RawOccupancy"] = TwoStrings(m_rawOccupancySummaryFile, "RawOccupancyInfo.xsl");
   nameAssociation["Efficiency"] = TwoStrings(m_efficiencySummaryFile, "EfficiencyInfo.xsl");
   nameAssociation["BSErrors"] = TwoStrings(m_BSErrorSummaryFile, "BSErrorInfo.xsl");
   nameAssociation["BSErrorsModule"] = TwoStrings(m_BSErrorModuleFile, "BSErrorInfo.xsl");
   Names::iterator found{nameAssociation.find(type)};
   if (found!=nameAssociation.end()) {
      std::string filename{found->second.first};
      std::string xslName{found->second.second};
      //
      file.open(filename.c_str(), std::ios::out);
      if (!file.good()) return StatusCode::FAILURE;
      file << xmlHeader << linefeed << associateStylesheet(xslName) << linefeed << "<run>" << std::endl;
   } else {
      ATH_MSG_ERROR("in openXML4MonSummary : argument \"type\" needs to be (NoiseOccupancy, RawOccupancy, Efficiency, BSErrors).");
      return StatusCode::FAILURE;
   }
   file << xmlValue("RunNumber", m_runNumber.value()) << linefeed
        << xmlValue("StartTime", m_utcBegin) << linefeed
        << xmlValue("EndTime", m_utcEnd) << linefeed
        << xmlValue("Duration", m_calibEvtInfoTool->duration()) << linefeed
        << xmlValue("LB", m_LBRange) << linefeed
        << xmlValue("Events", m_numberOfEvents) << linefeed
        << "  <data>" << std::endl;
   return StatusCode::SUCCESS;
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

prepareHV()

StatusCode SCTCalib::prepareHV ( )

private

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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

retrievedService()

template<class S>

bool SCTCalib::retrievedService ( S & service ) const

inlineprivate

Definition at line 284 of file SCTCalib.h.

                                              {
         if (service.retrieve().isFailure()) {
            ATH_MSG_ERROR("Unable to retrieve "<<service.name());
            return false;
         }
         return true;
      }

setFilterPassed() [1/2]

void AthAlgorithm::setFilterPassed ( bool state ) const

inherited

Definition at line 102 of file AthAlgorithm.cxx.

                                                     {
  setFilterPassed( state, Gaudi::Hive::currentContext() );
}

setFilterPassed() [2/2]

void AthAlgorithm::setFilterPassed ( bool state, const EventContext & ctx ) const

inherited

Definition at line 106 of file AthAlgorithm.cxx.

                                                                              {
  execState( ctx ).setFilterPassed(state);
}

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc.

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

wrapUpXML4Summary()

StatusCode SCTCalib::wrapUpXML4Summary ( std::ofstream & file, const char * type, std::ostringstream & list ) const

private

Definition at line 2593 of file SCTCalib.cxx.

                                                                                                        {
   file << list.str();
   if (!strcmp(type, "DEAD")) {
      file << "  </modules>" << std::endl;
   } else if (!strcmp(type, "NoiseOccupancy") or !strcmp(type, "RawOccupancy") or !strcmp(type, "Efficiency") or !strcmp(type, "BSErrors") or !strcmp(type, "LorentzAngle")) {
      file << "  </data>" << std::endl;
   }
   file << "</run>" << std::endl;
 
   if (file.is_open()) {
      file.close();
      return StatusCode::SUCCESS;
   } else {
      return StatusCode::FAILURE;
   }
}

xmlChannelEfficiencyDataString()

std::string SCTCalib::xmlChannelEfficiencyDataString ( const Identifier & waferId, const float efficiency, const SCT_SerialNumber & serial, const int side ) const

private

Definition at line 2679 of file SCTCalib.cxx.

                                                                                                                                                {
   std::ostringstream os;
   os << "   <module>" << std::endl
      << "  " << xmlValue("SN", serial.str()) << std::endl
      << "  " << xmlValue("SampleSize", "10000") << std::endl
      << "  " << xmlValue("barrel_endcap", m_pSCTHelper->barrel_ec(waferId)) << std::endl
      << "  " << xmlValue("Layer", m_pSCTHelper->layer_disk(waferId)) << linefeed
      << "  " << xmlValue("Eta", m_pSCTHelper->eta_module(waferId)) << std::endl
      << "  " << xmlValue("Phi", m_pSCTHelper->phi_module(waferId)) << std::endl
      << "  " << xmlValue("Efficiency", efficiency) << std::endl
      << "  " << xmlValue("Side",  side )<<std::endl
      << "   </module>";
   return os.str();
}

xmlChannelEfficiencyDataStringChip()

std::string SCTCalib::xmlChannelEfficiencyDataStringChip ( const Identifier & waferId, const float efficiency, const float efficiency_bcid, const SCT_SerialNumber & serial, const int side, const int chip ) const

private

Definition at line 2696 of file SCTCalib.cxx.

                                                                                                                                                                                                 {
   std::ostringstream os;
   os << "   <chip>" << std::endl
      << "  " << xmlValue("SN", serial.str()) << std::endl
      << "  " << xmlValue("SampleSize", "10000") << std::endl
      << "  " << xmlValue("barrel_endcap", m_pSCTHelper->barrel_ec(waferId)) << std::endl
      << "  " << xmlValue("Layer", m_pSCTHelper->layer_disk(waferId)) << linefeed
      << "  " << xmlValue("Eta", m_pSCTHelper->eta_module(waferId)) << std::endl
      << "  " << xmlValue("Phi", m_pSCTHelper->phi_module(waferId)) << std::endl
      << "  " << xmlValue("Side",  side )<<std::endl
      << "  " << xmlValue("Chip",  chip )<<std::endl
      << "  " << xmlValue("Efficiency", efficiency) << std::endl
      << "  " << xmlValue("Efficiency_bcid", efficiency_bcid) << std::endl
      << "   </chip>";
   return os.str();
}

xmlChannelNoiseOccDataString()

std::string SCTCalib::xmlChannelNoiseOccDataString ( const Identifier & waferId, const float occupancy, const SCT_SerialNumber & serial ) const

private

Definition at line 2663 of file SCTCalib.cxx.

                                                                                                                             {
   std::ostringstream os;
   os << xmlOpenChannel(waferId.get_identifier32().get_compact(), m_iovStart.re_time(), m_iovStop.re_time()) << std::endl
      << "  " << xmlValue("SN", serial.str()) << std::endl
      << "  " << xmlValue("SampleSize", "10000") << std::endl
      << "  " << xmlValue("barrel_endcap", m_pSCTHelper->barrel_ec(waferId)) << std::endl
      << "  " << xmlValue("Layer", m_pSCTHelper->layer_disk(waferId)) << linefeed
      << "  " << xmlValue("Eta", m_pSCTHelper->eta_module(waferId)) << std::endl
      << "  " << xmlValue("Phi", m_pSCTHelper->phi_module(waferId)) << std::endl
      << "  " << xmlValue("NoiseOccupancy", occupancy) << std::endl
      << "  " << xmlCloseChannel();
   return os.str();
}

Member Data Documentation

m_badModulesFile

StringProperty SCTCalib::m_badModulesFile {this, "BadModulesFile", "BadModulesFile.xml", "Output XML for HV trips"}

private

Definition at line 219 of file SCTCalib.h.

{this, "BadModulesFile", "BadModulesFile.xml", "Output XML for HV trips"};

m_badStripsAllFile

StringProperty SCTCalib::m_badStripsAllFile {this, "BadStripsAllFile", "BadStripsAllFile.xml", "Output XML for all noisy strips"}

private

Definition at line 215 of file SCTCalib.h.

{this, "BadStripsAllFile", "BadStripsAllFile.xml", "Output XML for all noisy strips"};

m_badStripsNewFile

StringProperty SCTCalib::m_badStripsNewFile {this, "BadStripsNewFile", "BadStripsNewFile.xml", "Output XML for newly found noisy strips (i.e. not in config/calib data)"}

private

Definition at line 216 of file SCTCalib.h.

{this, "BadStripsNewFile", "BadStripsNewFile.xml", "Output XML for newly found noisy strips (i.e. not in config/calib data)"};

m_badStripsSummaryFile

StringProperty SCTCalib::m_badStripsSummaryFile {this, "BadStripsSummaryFile", "BadStripsSummaryFile.xml", "Output XML for summary info from noisy strip search"}

private

Definition at line 217 of file SCTCalib.h.

{this, "BadStripsSummaryFile", "BadStripsSummaryFile.xml", "Output XML for summary info from noisy strip search"};

m_BSErrorDBMinStat

UnsignedIntegerProperty SCTCalib::m_BSErrorDBMinStat {this, "BSErrorDBMinStat", 50000}

private

Definition at line 205 of file SCTCalib.h.

{this, "BSErrorDBMinStat", 50000};

m_BSErrorModuleFile

StringProperty SCTCalib::m_BSErrorModuleFile {this, "BSErrorModuleFile", "BSErrorModuleSummary.xml", "Output XML for summary of BS Errors"}

private

Definition at line 232 of file SCTCalib.h.

{this, "BSErrorModuleFile", "BSErrorModuleSummary.xml", "Output XML for summary of BS Errors"};

m_BSErrorSummaryFile

StringProperty SCTCalib::m_BSErrorSummaryFile {this, "BSErrorSummaryFile", "BSErrorSummaryFile.xml", "Output XML for summary of BS Errors"}

private

Definition at line 231 of file SCTCalib.h.

{this, "BSErrorSummaryFile", "BSErrorSummaryFile.xml", "Output XML for summary of BS Errors"};

m_busyThr4DeadFinding

FloatProperty SCTCalib::m_busyThr4DeadFinding {this, "BusyThr4DeadFinding", 1E-4}

private

Definition at line 192 of file SCTCalib.h.

{this, "BusyThr4DeadFinding", 1E-4};

m_CablingTool

ToolHandle<ISCT_CablingTool> SCTCalib::m_CablingTool {this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"}

private

Definition at line 102 of file SCTCalib.h.

{this, "SCT_CablingTool", "SCT_CablingTool", "Tool to retrieve SCT Cabling"};

m_calibBsErrTool

ToolHandle<ISCT_CalibHistoTool> SCTCalib::m_calibBsErrTool {this, "SCT_CalibBsErrorTool", "SCT_CalibBsErrorTool", "Tool for reading and writing BS error histograms"}

private

Definition at line 105 of file SCTCalib.h.

{this, "SCT_CalibBsErrorTool", "SCT_CalibBsErrorTool", "Tool for reading and writing BS error histograms"};

m_calibEvtInfoTool

ToolHandle<ISCT_CalibEvtInfo> SCTCalib::m_calibEvtInfoTool {this, "SCT_CalibEventInfo", "SCT_CalibEventInfo", "Tool for handling event info"}

private

Definition at line 107 of file SCTCalib.h.

{this, "SCT_CalibEventInfo", "SCT_CalibEventInfo", "Tool for handling event info"};

m_calibHitmapTool

ToolHandle<ISCT_CalibHistoTool> SCTCalib::m_calibHitmapTool {this, "SCT_CalibHitmapTool", "SCT_CalibHitmapTool", "Tool for reading and writing HitMap histograms"}

private

Definition at line 103 of file SCTCalib.h.

{this, "SCT_CalibHitmapTool", "SCT_CalibHitmapTool", "Tool for reading and writing HitMap histograms"};

m_calibLbTool

ToolHandle<ISCT_CalibHistoTool> SCTCalib::m_calibLbTool {this, "SCT_CalibLbTool", "SCT_CalibLbTool", "Tool for reading and writing Lb dependent HitMap histograms"}

private

Definition at line 104 of file SCTCalib.h.

{this, "SCT_CalibLbTool", "SCT_CalibLbTool", "Tool for reading and writing Lb dependent HitMap histograms"};

m_calibModuleListTool

ToolHandle<ISCT_CalibModuleListTool> SCTCalib::m_calibModuleListTool {this, "SCT_CalibModuleListTool", "SCT_CalibModuleListTool", "Tool for handling list of modules"}

private

Definition at line 106 of file SCTCalib.h.

{this, "SCT_CalibModuleListTool", "SCT_CalibModuleListTool", "Tool for handling list of modules"};

m_ConfigurationConditionsTool

ToolHandle<ISCT_ConfigurationConditionsTool> SCTCalib::m_ConfigurationConditionsTool {this, "SCT_ConfigurationConditionsTool", "SCT_ConfigurationConditionsTool/InDetSCT_ConfigurationConditionsTool", "Tool to retrieve SCT Configuration"}

private

Definition at line 99 of file SCTCalib.h.

{this, "SCT_ConfigurationConditionsTool", "SCT_ConfigurationConditionsTool/InDetSCT_ConfigurationConditionsTool", "Tool to retrieve SCT Configuration"};

m_deadChipMinStat

UnsignedIntegerProperty SCTCalib::m_deadChipMinStat {this, "DeadChipMinStat", 200000}

private

Definition at line 189 of file SCTCalib.h.

{this, "DeadChipMinStat", 200000};

m_deadChipsFile

StringProperty SCTCalib::m_deadChipsFile {this, "DeadChipsFile", "DeadChipsFile.xml", "Output XML for dead chips"}

private

Definition at line 222 of file SCTCalib.h.

{this, "DeadChipsFile", "DeadChipsFile.xml", "Output XML for dead chips"};

m_deadChipSignificance

UnsignedIntegerProperty SCTCalib::m_deadChipSignificance {this, "DeadChipSignificance", 10}

private

Definition at line 191 of file SCTCalib.h.

{this, "DeadChipSignificance", 10};

m_deadChipUploadTest

BooleanProperty SCTCalib::m_deadChipUploadTest {this, "DeadChipUploadTest", true}

private

Definition at line 194 of file SCTCalib.h.

{this, "DeadChipUploadTest", true};

m_deadNotQuiet

BooleanProperty SCTCalib::m_deadNotQuiet {this, "DeadNotQuiet", true}

private

Definition at line 196 of file SCTCalib.h.

{this, "DeadNotQuiet", true};

m_deadStripMinStat

UnsignedIntegerProperty SCTCalib::m_deadStripMinStat {this, "DeadStripMinStat", 200000}

private

Definition at line 187 of file SCTCalib.h.

{this, "DeadStripMinStat", 200000};

m_deadStripMinStatBusy

UnsignedIntegerProperty SCTCalib::m_deadStripMinStatBusy {this, "DeadStripMinStatBusy", 1600000}

private

Definition at line 188 of file SCTCalib.h.

{this, "DeadStripMinStatBusy", 1600000};

m_deadStripsFile

StringProperty SCTCalib::m_deadStripsFile {this, "DeadStripsFile", "DeadStripsFile.xml", "Output XML for dead strips"}

private

Definition at line 221 of file SCTCalib.h.

{this, "DeadStripsFile", "DeadStripsFile.xml", "Output XML for dead strips"};

m_deadStripSignificance

UnsignedIntegerProperty SCTCalib::m_deadStripSignificance {this, "DeadStripSignificance", 10}

private

Definition at line 190 of file SCTCalib.h.

{this, "DeadStripSignificance", 10};

m_deadStripUploadTest

BooleanProperty SCTCalib::m_deadStripUploadTest {this, "DeadStripUploadTest", true}

private

Definition at line 195 of file SCTCalib.h.

{this, "DeadStripUploadTest", true};

m_deadSummaryFile

StringProperty SCTCalib::m_deadSummaryFile {this, "DeadSummaryFile", "DeadSummaryFile.xml", "Output XML for summary of Dead Finding"}

private

Definition at line 223 of file SCTCalib.h.

{this, "DeadSummaryFile", "DeadSummaryFile.xml", "Output XML for summary of Dead Finding"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_doBSErrorDB

BooleanProperty SCTCalib::m_doBSErrorDB {this, "DoBSErrorDB", false}

private

Definition at line 157 of file SCTCalib.h.

{this, "DoBSErrorDB", false};

m_doBSErrors

BooleanProperty SCTCalib::m_doBSErrors {this, "DoBSErrors", false}

private

Definition at line 149 of file SCTCalib.h.

{this, "DoBSErrors", false};

m_doDeadChip

BooleanProperty SCTCalib::m_doDeadChip {this, "DoDeadChip", false}

private

Definition at line 153 of file SCTCalib.h.

{this, "DoDeadChip", false};

m_doDeadStrip

BooleanProperty SCTCalib::m_doDeadStrip {this, "DoDeadStrip", false}

private

Definition at line 152 of file SCTCalib.h.

{this, "DoDeadStrip", false};

m_doEfficiency

BooleanProperty SCTCalib::m_doEfficiency {this, "DoEfficiency", false}

private

Definition at line 156 of file SCTCalib.h.

{this, "DoEfficiency", false};

m_doHitMaps

BooleanProperty SCTCalib::m_doHitMaps {this, "DoHitMaps", true}

private

Definition at line 145 of file SCTCalib.h.

{this, "DoHitMaps", true};

m_doHitMapsLB

BooleanProperty SCTCalib::m_doHitMapsLB {this, "DoHitMapsLB", true}

private

Definition at line 146 of file SCTCalib.h.

{this, "DoHitMapsLB", true};

m_doHV

BooleanProperty SCTCalib::m_doHV {this, "DoHV", false}

private

Definition at line 151 of file SCTCalib.h.

{this, "DoHV", false};

m_doLorentzAngle

BooleanProperty SCTCalib::m_doLorentzAngle {this, "DoLorentzAngle", false}

private

Definition at line 158 of file SCTCalib.h.

{this, "DoLorentzAngle", false};

m_doNoiseOccupancy

BooleanProperty SCTCalib::m_doNoiseOccupancy {this, "DoNoiseOccupancy", false}

private

Definition at line 154 of file SCTCalib.h.

{this, "DoNoiseOccupancy", false};

m_doNoisyStrip

BooleanProperty SCTCalib::m_doNoisyStrip {this, "DoNoisyStrip", true}

private

Definition at line 150 of file SCTCalib.h.

{this, "DoNoisyStrip", true};

m_doRawOccupancy

BooleanProperty SCTCalib::m_doRawOccupancy {this, "DoRawOccupancy", false}

private

Definition at line 155 of file SCTCalib.h.

{this, "DoRawOccupancy", false};

m_efficiencyChipFile

StringProperty SCTCalib::m_efficiencyChipFile {this, "EfficiencyChipFile", "EfficiencyChipSummary.xml", "Output XML for chip efficiency"}

private

Definition at line 230 of file SCTCalib.h.

{this, "EfficiencyChipFile", "EfficiencyChipSummary.xml", "Output XML for chip efficiency"};

m_efficiencyDoChips

BooleanProperty SCTCalib::m_efficiencyDoChips {this, "EfficiencyDoChips", true}

private

Definition at line 204 of file SCTCalib.h.

{this, "EfficiencyDoChips", true};

m_efficiencyMinStat

UnsignedIntegerProperty SCTCalib::m_efficiencyMinStat {this, "EfficiencyMinStat", 50000}

private

Definition at line 203 of file SCTCalib.h.

{this, "EfficiencyMinStat", 50000};

m_efficiencyModuleFile

StringProperty SCTCalib::m_efficiencyModuleFile {this, "EfficiencyModuleFile", "EfficiencyModuleSummary.xml", "Output XML for efficiency"}

private

Definition at line 229 of file SCTCalib.h.

{this, "EfficiencyModuleFile", "EfficiencyModuleSummary.xml", "Output XML for efficiency"};

m_efficiencySummaryFile

StringProperty SCTCalib::m_efficiencySummaryFile {this, "EfficiencySummaryFile", "EfficiencySummaryFile.xml", "Output XML for summary of efficiency"}

private

Definition at line 228 of file SCTCalib.h.

{this, "EfficiencySummaryFile", "EfficiencySummaryFile.xml", "Output XML for summary of efficiency"};

m_eventNumber

IntegerProperty SCTCalib::m_eventNumber {this, "EventNumber", -1}

private

Definition at line 129 of file SCTCalib.h.

{this, "EventNumber", -1};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 114 of file AthAlgorithm.h.

m_gofile

std::ofstream SCTCalib::m_gofile

private

Definition at line 114 of file SCTCalib.h.

m_h_phiVsNstripsSideHistoVector

std::vector<TProfile*> SCTCalib::m_h_phiVsNstripsSideHistoVector

private

Definition at line 254 of file SCTCalib.h.

m_histBefore2010

BooleanProperty SCTCalib::m_histBefore2010 {this, "HistBefore2010", false, "True if HIST is from 2009 or earlier"}

private

Definition at line 143 of file SCTCalib.h.

{this, "HistBefore2010", false, "True if HIST is from 2009 or earlier"};

m_input_hist

StringArrayProperty SCTCalib::m_input_hist {this, "InputHist", {}, "list of HIST (assuming 1 file)"}

private

Definition at line 140 of file SCTCalib.h.

{this, "InputHist", {}, "list of HIST (assuming 1 file)"};

m_inputHist

TFile* SCTCalib::m_inputHist {nullptr}

private

Definition at line 247 of file SCTCalib.h.

{nullptr};    // Monitoring histograms

m_iovStart

IOVTime SCTCalib::m_iovStart

private

Definition at line 243 of file SCTCalib.h.

m_iovStop

IOVTime SCTCalib::m_iovStop

private

Definition at line 244 of file SCTCalib.h.

m_LBMax

StringProperty SCTCalib::m_LBMax {this, "LBMax", "1000", "from runInfo.txt"}

private

Definition at line 133 of file SCTCalib.h.

{this, "LBMax", "1000", "from runInfo.txt"};

m_LBRange

int SCTCalib::m_LBRange {-999}

private

Definition at line 242 of file SCTCalib.h.

{-999};

m_LorentzAngleDebugMode

BooleanProperty SCTCalib::m_LorentzAngleDebugMode {this, "LorentzAngleDebugMode", true}

private

Definition at line 208 of file SCTCalib.h.

{this, "LorentzAngleDebugMode", true};

m_LorentzAngleFile

StringProperty SCTCalib::m_LorentzAngleFile {this, "LorentzAngleFile", "LorentzAngleFile.xml", "Output XML for noise occupancy"}

private

Definition at line 233 of file SCTCalib.h.

{this, "LorentzAngleFile", "LorentzAngleFile.xml", "Output XML for noise occupancy"};

m_LorentzAngleMinStat

UnsignedIntegerProperty SCTCalib::m_LorentzAngleMinStat {this, "LorentzAngleMinStat", 50000}

private

Definition at line 206 of file SCTCalib.h.

{this, "LorentzAngleMinStat", 50000};

m_LorentzAngleSummaryFile

StringProperty SCTCalib::m_LorentzAngleSummaryFile {this, "LorentzAngleSummaryFile", "LorentzAngleSummaryFile.xml", "Output XML for summary of lorentz angle"}

private

Definition at line 234 of file SCTCalib.h.

{this, "LorentzAngleSummaryFile", "LorentzAngleSummaryFile.xml", "Output XML for summary of lorentz angle"};

m_MajorityConditionsTool

ToolHandle<ISCT_DetectorLevelConditionsTool> SCTCalib::m_MajorityConditionsTool {this, "SCT_MajorityConditionsTool", "SCT_MajorityConditionsTool", "Tool to retrieve the majority conditions of SCT"}

private

Definition at line 101 of file SCTCalib.h.

{this, "SCT_MajorityConditionsTool", "SCT_MajorityConditionsTool", "Tool to retrieve the majority conditions of SCT"};

m_maxtbins

IntegerProperty SCTCalib::m_maxtbins {this, "HVBinWidth", 5}

private

Definition at line 185 of file SCTCalib.h.

{this, "HVBinWidth", 5};

m_nLbsMerged

IntegerProperty SCTCalib::m_nLbsMerged {this, "LbsPerWindow", 30}

private

Definition at line 147 of file SCTCalib.h.

{this, "LbsPerWindow", 30};

m_noiseOccupancyFile

StringProperty SCTCalib::m_noiseOccupancyFile {this, "NoiseOccupancyFile", "NoiseOccupancyFile.xml", "Output XML for noise occupancy"}

private

Definition at line 225 of file SCTCalib.h.

{this, "NoiseOccupancyFile", "NoiseOccupancyFile.xml", "Output XML for noise occupancy"};

m_noiseOccupancyMinStat

UnsignedIntegerProperty SCTCalib::m_noiseOccupancyMinStat {this, "NoiseOccupancyMinStat", 50000}

private

Definition at line 201 of file SCTCalib.h.

{this, "NoiseOccupancyMinStat", 50000};

m_noiseOccupancySummaryFile

StringProperty SCTCalib::m_noiseOccupancySummaryFile {this, "NoiseOccupancySummaryFile", "NoiseOccupancySummaryFile.xml", "Output XML for summary of noise occupancy"}

private

Definition at line 226 of file SCTCalib.h.

{this, "NoiseOccupancySummaryFile", "NoiseOccupancySummaryFile.xml", "Output XML for summary of noise occupancy"};

m_noiseOccupancyTriggerAware

BooleanProperty SCTCalib::m_noiseOccupancyTriggerAware {this, "NoiseOccupancyTriggerAware", true}

private

Definition at line 200 of file SCTCalib.h.

{this, "NoiseOccupancyTriggerAware", true};

m_noisyChipFraction

FloatProperty SCTCalib::m_noisyChipFraction {this, "NoisyChipFraction", 0.500}

private

Definition at line 183 of file SCTCalib.h.

{this, "NoisyChipFraction", 0.500};

m_noisyMinStat

UnsignedIntegerProperty SCTCalib::m_noisyMinStat {this, "NoisyMinStat", 50000}

private

Definition at line 171 of file SCTCalib.h.

{this, "NoisyMinStat", 50000};

m_noisyModuleAverageInDB

FloatProperty SCTCalib::m_noisyModuleAverageInDB {this, "NoisyModuleAverageInDB", -1., "Average number of modules with at least 1 noisy strip in COOL"}

private

Definition at line 164 of file SCTCalib.h.

{this, "NoisyModuleAverageInDB", -1., "Average number of modules with at least 1 noisy strip in COOL"};

m_noisyModuleDiff

FloatProperty SCTCalib::m_noisyModuleDiff {this, "NoisyModuleDiff", 0.200}

private

Definition at line 168 of file SCTCalib.h.

{this, "NoisyModuleDiff", 0.200};

m_noisyModuleList

IntegerProperty SCTCalib::m_noisyModuleList {this, "NoisyModuleList", 200}

private

Definition at line 167 of file SCTCalib.h.

{this, "NoisyModuleList", 200};

m_noisyStripAll

BooleanProperty SCTCalib::m_noisyStripAll {this, "NoisyStripAll", true}

private

Definition at line 172 of file SCTCalib.h.

{this, "NoisyStripAll", true};

m_noisyStripAverageInDB

FloatProperty SCTCalib::m_noisyStripAverageInDB {this, "NoisyStripAverageInDB", -999., "Number of noisy strips of the last run uploaded to COOL"}

private

Definition at line 166 of file SCTCalib.h.

{this, "NoisyStripAverageInDB", -999., "Number of noisy strips of the last run uploaded to COOL"};

m_noisyStripDiff

FloatProperty SCTCalib::m_noisyStripDiff {this, "NoisyStripDiff", 128.}

private

Definition at line 169 of file SCTCalib.h.

{this, "NoisyStripDiff", 128.};

m_noisyStripLastRunInDB

IntegerProperty SCTCalib::m_noisyStripLastRunInDB {this, "NoisyStripLastRunInDB", -999, "Number of noisy strips of the last run uploaded to COOL"}

private

Definition at line 165 of file SCTCalib.h.

{this, "NoisyStripLastRunInDB", -999, "Number of noisy strips of the last run uploaded to COOL"};

m_noisyStripThrDef

BooleanProperty SCTCalib::m_noisyStripThrDef {this, "NoisyStripThrDef", true}

private

Definition at line 173 of file SCTCalib.h.

{this, "NoisyStripThrDef", true};

m_noisyStripThrOffline

FloatProperty SCTCalib::m_noisyStripThrOffline {this, "NoisyStripThrOffline", 1.500E-2}

private

Definition at line 174 of file SCTCalib.h.

{this, "NoisyStripThrOffline", 1.500E-2};

m_noisyStripThrOnline

FloatProperty SCTCalib::m_noisyStripThrOnline {this, "NoisyStripThrOnline", 1.500E-3}

private

Definition at line 175 of file SCTCalib.h.

{this, "NoisyStripThrOnline", 1.500E-3};

m_noisyThr4DeadFinding

FloatProperty SCTCalib::m_noisyThr4DeadFinding {this, "NoisyThr4DeadFinding", 1.500E-3}

private

Definition at line 193 of file SCTCalib.h.

{this, "NoisyThr4DeadFinding", 1.500E-3};

m_noisyUpdate

BooleanProperty SCTCalib::m_noisyUpdate {this, "NoisyUpdate", true}

private

Definition at line 161 of file SCTCalib.h.

{this, "NoisyUpdate", true};

m_noisyUploadTest

BooleanProperty SCTCalib::m_noisyUploadTest {this, "NoisyUploadTest", true}

private

Definition at line 163 of file SCTCalib.h.

{this, "NoisyUploadTest", true};

m_noisyWaferAllStrips

BooleanProperty SCTCalib::m_noisyWaferAllStrips {this, "NoisyWaferAllStrips", true}

private

Definition at line 178 of file SCTCalib.h.

{this, "NoisyWaferAllStrips", true};

m_noisyWaferFinder

BooleanProperty SCTCalib::m_noisyWaferFinder {this, "NoisyWaferFinder", true}

private

Definition at line 176 of file SCTCalib.h.

{this, "NoisyWaferFinder", true};

m_noisyWaferFraction

FloatProperty SCTCalib::m_noisyWaferFraction {this, "NoisyWaferFraction", 0.500}

private

Definition at line 182 of file SCTCalib.h.

{this, "NoisyWaferFraction", 0.500};

m_noisyWaferThrBarrel

FloatProperty SCTCalib::m_noisyWaferThrBarrel {this, "NoisyWaferThrBarrel", 1.000E-4}

private

Definition at line 179 of file SCTCalib.h.

{this, "NoisyWaferThrBarrel", 1.000E-4};

m_noisyWaferThrECA

FloatProperty SCTCalib::m_noisyWaferThrECA {this, "NoisyWaferThrECA", 1.000E-4}

private

Definition at line 180 of file SCTCalib.h.

{this, "NoisyWaferThrECA", 1.000E-4};

m_noisyWaferThrECC

FloatProperty SCTCalib::m_noisyWaferThrECC {this, "NoisyWaferThrECC", 1.000E-4}

private

Definition at line 181 of file SCTCalib.h.

{this, "NoisyWaferThrECC", 1.000E-4};

m_noisyWaferWrite

BooleanProperty SCTCalib::m_noisyWaferWrite {this, "NoisyWaferWrite", true}

private

Definition at line 177 of file SCTCalib.h.

{this, "NoisyWaferWrite", true};

m_noisyWriteAllModules

BooleanProperty SCTCalib::m_noisyWriteAllModules {this, "NoisyWriteAllModules", true}

private

Definition at line 162 of file SCTCalib.h.

{this, "NoisyWriteAllModules", true};

m_numberOfEvents

unsigned long long SCTCalib::m_numberOfEvents {0}

private

Definition at line 238 of file SCTCalib.h.

{0};

m_numberOfEventsHist

unsigned long long SCTCalib::m_numberOfEventsHist {0}

private

Definition at line 239 of file SCTCalib.h.

{0}; // For number of events from HIST

m_numOfLBsProcessed

int SCTCalib::m_numOfLBsProcessed {0}

private

Definition at line 237 of file SCTCalib.h.

{0};

m_outBSErrModule

std::ofstream SCTCalib::m_outBSErrModule

private

Definition at line 124 of file SCTCalib.h.

m_outBSErrSummary

std::ofstream SCTCalib::m_outBSErrSummary

private

Definition at line 123 of file SCTCalib.h.

m_outDeadChips

std::ofstream SCTCalib::m_outDeadChips

private

Definition at line 118 of file SCTCalib.h.

m_outDeadStrips

std::ofstream SCTCalib::m_outDeadStrips

private

Definition at line 117 of file SCTCalib.h.

m_outDeadSummary

std::ofstream SCTCalib::m_outDeadSummary

private

Definition at line 119 of file SCTCalib.h.

m_outEffSummary

std::ofstream SCTCalib::m_outEffSummary

private

Definition at line 122 of file SCTCalib.h.

m_outLASummary

std::ofstream SCTCalib::m_outLASummary

private

Definition at line 125 of file SCTCalib.h.

m_outNOSummary

std::ofstream SCTCalib::m_outNOSummary

private

Definition at line 120 of file SCTCalib.h.

m_outROSummary

std::ofstream SCTCalib::m_outROSummary

private

Definition at line 121 of file SCTCalib.h.

m_pCalibWriteTool

ToolHandle<SCTCalibWriteTool> SCTCalib::m_pCalibWriteTool {this, "SCTCalibWriteTool", "SCTCalibWriteTool", "Tool to write out data from calibration loop"}

private

Definition at line 98 of file SCTCalib.h.

{this, "SCTCalibWriteTool", "SCTCalibWriteTool", "Tool to write out data from calibration loop"};

m_pnoiseoccupancymapHistoVector

std::vector<TProfile2D*> SCTCalib::m_pnoiseoccupancymapHistoVector

private

Definition at line 251 of file SCTCalib.h.

m_pnoiseoccupancymapHistoVectorECm

std::vector<TProfile2D*> SCTCalib::m_pnoiseoccupancymapHistoVectorECm

private

Definition at line 253 of file SCTCalib.h.

m_pnoiseoccupancymapHistoVectorECp

std::vector<TProfile2D*> SCTCalib::m_pnoiseoccupancymapHistoVectorECp

private

Definition at line 252 of file SCTCalib.h.

m_pSCTHelper

const SCT_ID* SCTCalib::m_pSCTHelper {nullptr}

private

Definition at line 95 of file SCTCalib.h.

{nullptr};

m_quietThresholdChip

FloatProperty SCTCalib::m_quietThresholdChip {this, "QuietThresholdChip", 0.5}

private

Definition at line 198 of file SCTCalib.h.

{this, "QuietThresholdChip", 0.5};

m_quietThresholdStrip

FloatProperty SCTCalib::m_quietThresholdStrip {this, "QuietThresholdStrip", 0.5}

private

Definition at line 197 of file SCTCalib.h.

{this, "QuietThresholdStrip", 0.5};

m_rawOccupancyMinStat

UnsignedIntegerProperty SCTCalib::m_rawOccupancyMinStat {this, "RawOccupancyMinStat", 50000}

private

Definition at line 202 of file SCTCalib.h.

{this, "RawOccupancyMinStat", 50000};

m_rawOccupancySummaryFile

StringProperty SCTCalib::m_rawOccupancySummaryFile {this,"RawOccupancySummaryFile", "RawOccupancySummaryFile.xml", "Output XML for summary of raw occupancy"}

private

Definition at line 227 of file SCTCalib.h.

{this,"RawOccupancySummaryFile", "RawOccupancySummaryFile.xml", "Output XML for summary of raw occupancy"};

m_readBS

BooleanProperty SCTCalib::m_readBS {this, "ReadBS", false, "True if BS is used"}

private

Definition at line 142 of file SCTCalib.h.

{this, "ReadBS", false, "True if BS is used"};

m_ReadCalibDataTool

ToolHandle<ISCT_ReadCalibDataTool> SCTCalib::m_ReadCalibDataTool {this, "SCT_ReadCalibDataTool", "SCT_ReadCalibDataTool/InDetSCT_ReadCalibDataTool", "Tool to retrieve SCT calibration data"}

private

Definition at line 100 of file SCTCalib.h.

{this, "SCT_ReadCalibDataTool", "SCT_ReadCalibDataTool/InDetSCT_ReadCalibDataTool", "Tool to retrieve SCT calibration data"};

m_readHIST

bool SCTCalib::m_readHIST

private

Definition at line 248 of file SCTCalib.h.

m_readHitMaps

BooleanProperty SCTCalib::m_readHitMaps {this, "ReadHitMaps", false}

private

Definition at line 148 of file SCTCalib.h.

{this, "ReadHitMaps", false};

m_runEndTime

StringProperty SCTCalib::m_runEndTime {this, "RunEndTime", "", "from runInfo.txt"}

private

Definition at line 132 of file SCTCalib.h.

{this, "RunEndTime", "", "from runInfo.txt"};

m_runNumber

IntegerProperty SCTCalib::m_runNumber {this, "RunNumber", -1}

private

Definition at line 128 of file SCTCalib.h.

{this, "RunNumber", -1};

m_runStartTime

StringProperty SCTCalib::m_runStartTime {this, "RunStartTime", "", "from runInfo.txt"}

private

Definition at line 131 of file SCTCalib.h.

{this, "RunStartTime", "", "from runInfo.txt"};

m_SCTDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> SCTCalib::m_SCTDetEleCollKey {this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}

private

Definition at line 96 of file SCTCalib.h.

{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};

m_summarytrips

std::vector<std::vector<std::pair<int, int> > > SCTCalib::m_summarytrips

private

Definition at line 111 of file SCTCalib.h.

m_summarytripslb

std::vector<std::vector<std::pair<int, int> > > SCTCalib::m_summarytripslb

private

Definition at line 112 of file SCTCalib.h.

m_tagID4DeadChips

StringProperty SCTCalib::m_tagID4DeadChips {this, "TagID4DeadChips", "SctDerivedDeadChips-001-00"}

private

Definition at line 212 of file SCTCalib.h.

{this, "TagID4DeadChips", "SctDerivedDeadChips-001-00"};

m_tagID4DeadStrips

StringProperty SCTCalib::m_tagID4DeadStrips {this, "TagID4DeadStrips", "SctDerivedDeadStrips-001-00"}

private

Definition at line 211 of file SCTCalib.h.

{this, "TagID4DeadStrips", "SctDerivedDeadStrips-001-00"};

m_tagID4NoiseOccupancy

StringProperty SCTCalib::m_tagID4NoiseOccupancy {this, "TagID4NoiseOccupancy", "SctDerivedNoiseOccupancy-001-00"}

private

Definition at line 213 of file SCTCalib.h.

{this,  "TagID4NoiseOccupancy", "SctDerivedNoiseOccupancy-001-00"};

m_tagID4NoisyStrips

StringProperty SCTCalib::m_tagID4NoisyStrips {this, "TagID4NoisyStrips", "SctDerivedMonitoring-001-00"}

private

Definition at line 210 of file SCTCalib.h.

{this, "TagID4NoisyStrips", "SctDerivedMonitoring-001-00"};

m_useBSError

BooleanProperty SCTCalib::m_useBSError {this, "UseBSError", false}

private

Definition at line 138 of file SCTCalib.h.

{this, "UseBSError", false};

m_useCalibration

BooleanProperty SCTCalib::m_useCalibration {this, "UseCalibration", true}

private

Definition at line 136 of file SCTCalib.h.

{this, "UseCalibration", true};

m_useConfiguration

BooleanProperty SCTCalib::m_useConfiguration {this, "UseConfiguration", true}

private

Definition at line 135 of file SCTCalib.h.

{this, "UseConfiguration", true};

m_useMajority

BooleanProperty SCTCalib::m_useMajority {this, "UseMajority", true}

private

Definition at line 137 of file SCTCalib.h.

{this, "UseMajority", true};

m_utcBegin

std::string SCTCalib::m_utcBegin

private

Definition at line 240 of file SCTCalib.h.

m_utcEnd

std::string SCTCalib::m_utcEnd

private

Definition at line 241 of file SCTCalib.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_writeToCool

BooleanProperty SCTCalib::m_writeToCool {this, "WriteToCool", true}

private

Definition at line 159 of file SCTCalib.h.

{this, "WriteToCool", true};

---

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

• SCTCalib.h
• SCTCalib.cxx