ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
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 () override
 
virtual StatusCode stop ATLAS_NOT_THREAD_SAFE () override
 
virtual StatusCode finalize () override
 Finalize - delete any memory allocation from the heap. More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
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. More...
 

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 More...
 
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 (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 > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

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) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
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< 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.

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

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

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

Constructor & Destructor Documentation

◆ SCTCalib()

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

Definition at line 112 of file SCTCalib.cxx.

112  :
113  AthAlgorithm(name, pSvcLocator)
114 {
115  m_readHIST = m_doNoiseOccupancy or m_doRawOccupancy or m_doEfficiency or m_doBSErrorDB or m_doLorentzAngle;
116 }

◆ ~SCTCalib()

SCTCalib::~SCTCalib ( )
default

Member Function Documentation

◆ addStripsToList()

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

Definition at line 2738 of file SCTCalib.cxx.

2738  {
2739  IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
2740  float noisyStripThr{m_noisyStripThrDef ? (m_noisyStripThrOffline):(m_noisyStripThrOnline)};
2741  for (int iStrip{0}; iStrip != nbins; ++iStrip) {
2742  Identifier stripId{m_pSCTHelper->strip_id(waferId, iStrip)};
2743  if (!isNoisy) { //--- Add all strips
2744  stripIdList.insert(stripId);
2745  } else {
2746  const float stripOccupancy{ (float) m_calibHitmapTool->getBinForHistogramIndex(iStrip + 1, waferHash.value()) / m_numberOfEvents};
2747  if (stripOccupancy > noisyStripThr) {
2748  if (!isNew) { //--- All noisy strips
2749  stripIdList.insert(stripId);
2750  } else { //--- New noisy strips : compared with configuration and calibration
2751  const bool isGoodInConfiguration{m_useConfiguration ? m_ConfigurationConditionsTool->isGood(stripId, InDetConditions::SCT_STRIP) : true};
2752  const bool isGoodInCalibration{m_useCalibration ? m_ReadCalibDataTool->isGood(stripId, InDetConditions::SCT_STRIP) : true};
2753  if (m_useConfiguration or m_useCalibration) {
2754  if (isGoodInConfiguration and isGoodInCalibration) {
2755  stripIdList.insert(stripId);
2756  }
2757  }
2758  }
2759  }
2760  }
2761  }
2762  return StatusCode::SUCCESS;
2763 }

◆ addToSummaryStr()

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

Definition at line 2608 of file SCTCalib.cxx.

2608  {
2609  //--- Remove first&end spaces in DefectList
2610  const std::string tmpstrip{stripId};
2611  const std::string tmpchip{chipId};
2612  int len_strip{static_cast<int>(tmpstrip.length())};
2613  int len_chip{static_cast<int>(tmpchip.length())};
2614  std::string stripList{""};
2615  std::string chipList{""};
2616  if (len_strip > 0) {
2617  int stringLength = (len_strip-2 >0) ? len_strip-2 : len_strip;
2618  stripList = tmpstrip.substr(1, stringLength);
2619  }
2620  if (len_chip > 0) {
2621  int stringLength = (len_chip-2 >0) ? len_chip-2 : len_chip;
2622  chipList = tmpchip.substr(1, stringLength);
2623  }
2624  //--- Identifier/SN
2625  IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
2626  SCT_SerialNumber sn{m_CablingTool->getSerialNumberFromHash(waferHash)};
2627  //--- Preparing linkList
2628  std::string linkList{chipList2LinkList(stripList)};
2629  //--- Push to summary stream
2630  XmlStreamer m{"module", list};
2631  {
2632  XmlStreamer v{"value", "name", "SN", list};
2633  list << sn.str();
2634  }
2635  {
2636  XmlStreamer v{"value", "name", "BecLayerPhiEta", list};
2637  list << formatPosition(waferId, m_pSCTHelper, ".", false);
2638  }
2639  {
2640  XmlStreamer v{"value", "name", "LinkID", list};
2641  list << linkList;
2642  }
2643  {
2644  XmlStreamer v{"value", "name", "ChipID", list};
2645  list << stripList;
2646  }
2647  if (!strcmp(type, "DEAD")) {
2648  XmlStreamer v{"value", "name", "StripIDOnline", list};
2649  list << stripList;
2650  } else {
2651  ATH_MSG_ERROR("in addToSummaryStr : argument \"type\" needs to be \"DEAD\".");
2652  return StatusCode::FAILURE;
2653  }
2654 
2655  return StatusCode::SUCCESS;
2656 }

◆ addToXML4DB()

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

Definition at line 2482 of file SCTCalib.cxx.

2482  {
2483  std::string tmp{DefectList};
2484  int length{static_cast<int>(tmp.length())};
2485  std::string Defect4DB{tmp.substr(1, length-2)}; // Removing first&end spaces in DefectList
2486 
2487  file << xmlOpenChannel(m_pSCTHelper->module_id(waferId).get_identifier32().get_compact(), m_iovStart.re_time(), m_iovStop.re_time()) << linefeed
2488  << xmlValue("SampleSize", "10000") << linefeed
2489  << xmlValue("BarrelEndcap", m_pSCTHelper->barrel_ec(waferId)) << linefeed
2490  << xmlValue("Layer", m_pSCTHelper->layer_disk(waferId)) << linefeed
2491  << xmlValue("Eta", m_pSCTHelper->eta_module(waferId)) << linefeed
2492  << xmlValue("Phi", m_pSCTHelper->phi_module(waferId)) << linefeed
2493  << xmlValue("DefectType", DefectType) << linefeed
2494  << xmlValue("Threshold", Threshold) << linefeed
2495  << xmlValue("DefectList", Defect4DB) << linefeed
2496  << xmlCloseChannel() << std::endl;
2497 
2498  return StatusCode::SUCCESS;
2499 }

◆ ATLAS_NOT_THREAD_SAFE() [1/9]

StatusCode getNoisyStrip SCTCalib::ATLAS_NOT_THREAD_SAFE ( )
private

◆ ATLAS_NOT_THREAD_SAFE() [2/9]

StatusCode getDeadStrip SCTCalib::ATLAS_NOT_THREAD_SAFE ( )
private

◆ ATLAS_NOT_THREAD_SAFE() [3/9]

StatusCode getNoiseOccupancy 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 getEfficiency SCTCalib::ATLAS_NOT_THREAD_SAFE ( )
private

◆ ATLAS_NOT_THREAD_SAFE() [6/9]

StatusCode getBSErrors SCTCalib::ATLAS_NOT_THREAD_SAFE ( )
private

◆ ATLAS_NOT_THREAD_SAFE() [7/9]

StatusCode getLorentzAngle 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 2471 of file SCTCalib.cxx.

2471  {
2472  file << "</channels>" << std::endl;
2473  if (file.is_open()) {
2474  file.close();
2475  return StatusCode::SUCCESS;
2476  } else {
2477  return StatusCode::FAILURE;
2478  }
2479 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ 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 470 of file SCTCalib.cxx.

470  {
471  const IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
472  const SCT_SerialNumber sn{m_CablingTool->getSerialNumberFromHash(waferHash)};
473 
474  XmlStreamer mod{"module", m_gofile};
475  {
476  XmlStreamer v{"value", "name", "SN", m_gofile};
477  m_gofile << sn.str();
478  }
479  {
480  XmlStreamer v{"value", "name", "BecLayerPhiEta", m_gofile};
481  m_gofile << formatPosition(waferId, m_pSCTHelper, ".", false);
482  }
483  {
484  XmlStreamer v{"value", "name", "StartTime", m_gofile};
485  m_gofile << timeInterval.first;
486  }
487  {
488  XmlStreamer v{"value", "name", "EndTime", m_gofile};
489  m_gofile << timeInterval.second;
490  }
491  {
492  XmlStreamer v{"value", "name", "StartLBN", m_gofile};
493  m_gofile << lbRange.first;
494  }
495  {
496  XmlStreamer v{"value", "name", "EndLBN", m_gofile};
497  m_gofile << lbRange.second;
498  }
499 }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode SCTCalib::execute ( )
overridevirtual

Definition at line 294 of file SCTCalib.cxx.

294  {
295 
296  ATH_MSG_DEBUG("----- in execute() ----- ");
297 
298  const bool majorityIsGoodOrUnused{(m_useMajority and m_MajorityConditionsTool->isGood()) or !m_useMajority};
299  if (m_readBS) {
300  //--- TimeStamp/LB range analyzed
301  const EventContext& ctx = Gaudi::Hive::currentContext();
302  const int timeStamp{static_cast<int>(ctx.eventID().time_stamp())};
303  const int lumiBlock{static_cast<int>(ctx.eventID().lumi_block())};
304  int timeStampBeginOld;
305  int timeStampEndOld;
306  m_calibEvtInfoTool->getTimeStamps(timeStampBeginOld, timeStampEndOld);
307  m_calibEvtInfoTool->setTimeStamp(std::min(timeStamp, timeStampBeginOld), std::max(timeStamp, timeStampEndOld));
308  int lbBeginOld;
309  int lbEndOld;
310  m_calibEvtInfoTool->getLumiBlock(lbBeginOld, lbEndOld);
311  m_calibEvtInfoTool->setLumiBlock(std::min(lumiBlock, lbBeginOld), std::max(lumiBlock, lbEndOld));
312  m_calibEvtInfoTool->setLumiBlock(lumiBlock);
313  m_calibEvtInfoTool->setTimeStamp(timeStamp);
314  if (m_doHitMapsLB and majorityIsGoodOrUnused) {
315  m_calibLbTool->setLb(ctx.eventID().lumi_block());
316  }
317  }
318 
319  //--- Fill histograms for (1) Number of events and (2) Hitmaps
320  if (m_doHitMaps and majorityIsGoodOrUnused) m_calibHitmapTool->fill(m_readBS);
321 
322  //--- Fill histograms for (1) Number of events and (2) Hits as a function of LB
323  if (m_doHitMapsLB and majorityIsGoodOrUnused) {
324  m_calibLbTool->fill(m_readBS);
325  }
326 
327  //--- Fill histograms for (1) Number of events and (2) BSErrors
328  if (m_doHitMaps and m_doBSErrors) m_calibBsErrTool->fill(m_readBS);
329 
330  //--- Increment event counter : to be ready for the next event loop
331  m_calibEvtInfoTool->incrementCounter();
332 
333  ATH_MSG_DEBUG("----- end of execute() ----- ");
334 
335  return StatusCode::SUCCESS;
336 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< 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.

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

◆ finalize()

StatusCode SCTCalib::finalize ( )
overridevirtual

Finalize - delete any memory allocation from the heap.

Definition at line 452 of file SCTCalib.cxx.

452  {
453  ATH_MSG_INFO("----- in finalize() ----- ");
454 
455  if (m_writeToCool) {
456  if (!m_pCalibWriteTool.release().isSuccess()) {
457  ATH_MSG_ERROR("Failed to release m_pCalibWriteTool");
458  return StatusCode::FAILURE;
459  }
460  }
461 
462  return StatusCode::SUCCESS;
463 }

◆ getLBList()

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

Definition at line 3243 of file SCTCalib.cxx.

3243  {
3244  std::string strList;
3245  strList.erase();
3246  if (!LBList.empty()) {
3247  int firstLB{-1};
3248  int LBSize{-1};
3249 
3250  std::set<int>::const_iterator LBItrFirst{LBList.begin()};
3251  std::set<int>::const_iterator LBItrLast{--LBList.end()};
3252 
3253  std::set<int>::const_iterator LBItr{LBList.begin()};
3254  std::set<int>::const_iterator LBItrE{LBList.end()};
3255  for (; LBItr != LBItrE; ++LBItr) {
3256  int iLB{*LBItr};
3257  if (LBItr == LBItrFirst) {
3258  firstLB = iLB;
3259  LBSize = 1;
3260  } else {
3261  if (iLB == firstLB + LBSize) {
3262  ++LBSize;
3263  } else {
3264  int LBBegin{firstLB};
3265  int LBEnd{firstLB + LBSize -1};
3266  strList = m_pCalibWriteTool->addDefect(strList, LBBegin, LBEnd);
3267  firstLB = iLB;
3268  LBSize = 1;
3269  }
3270  }
3271  if (LBItr == LBItrLast) {
3272  int LBBegin{firstLB};
3273  int LBEnd{iLB};
3274  strList = m_pCalibWriteTool->addDefect(strList, LBBegin, LBEnd);
3275  }
3276  }
3277  }
3278  return strList;
3279 }

◆ getNoisyChips()

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

Definition at line 3157 of file SCTCalib.cxx.

3157  {
3158  std::set<int> chipIdList;
3159  chipIdList.clear();
3160 
3161  // Get SCT_DetectorElementCollection
3162  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> sctDetEle{m_SCTDetEleCollKey};
3163  const InDetDD::SiDetectorElementCollection* elements{sctDetEle.retrieve()};
3164  if (elements==nullptr) {
3165  ATH_MSG_FATAL(m_SCTDetEleCollKey.fullKey() << " could not be retrieved");
3166  return chipIdList;
3167  }
3168 
3169  //--- Minimum number of noisy strips for a noisy chip
3170  unsigned int noisyChipThr{static_cast<unsigned int>(m_noisyChipFraction*n_stripPerChip)};
3171  if (stripIdList.size() > noisyChipThr) {
3172  unsigned int numStripsPerChip[n_chipPerModule] = {0};
3173  //--- Loop over stripIdList
3174  std::set<Identifier>::const_iterator stripItr{stripIdList.begin()};
3175  std::set<Identifier>::const_iterator stripItrE{stripIdList.end()};
3176  for (; stripItr != stripItrE; ++stripItr) {
3177  Identifier stripId{*stripItr};
3178  int stripOffline{m_pSCTHelper->strip(stripId)};
3179  //--- Chip number : taken from SCT_ConfigurationConditionsTool::getChip
3180  IdentifierHash waferHash{m_pSCTHelper->wafer_hash(m_pSCTHelper->wafer_id(stripId))};
3181  const InDetDD::SiDetectorElement* pElement{elements->getDetectorElement(waferHash)};
3182  if (!pElement) {
3183  ATH_MSG_FATAL("Element pointer is nullptr");
3184  continue;
3185  }
3186  int stripOnline{(pElement->swapPhiReadoutDirection()) ? lastStrip - stripOffline : stripOffline};
3187  int chipId{m_pSCTHelper->side(stripId) == 0 ? stripOnline/n_stripPerChip : stripOnline/n_stripPerChip + n_chipPerSide};
3188  //--- Count number of noisy strips per chips
3189  ++numStripsPerChip[chipId];
3190  }
3191 
3192  //--- Insert noisy chips
3193  for (int iChip{0}; iChip != n_chipPerModule; ++iChip) {
3194  if (numStripsPerChip[iChip] > noisyChipThr) chipIdList.insert(iChip);
3195  }
3196  }
3197  return chipIdList;
3198 }

◆ getNoisyLB()

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

Definition at line 3202 of file SCTCalib.cxx.

3202  {
3203  std::string defectLB{""}; //return value if invalid
3204  float defectLBFrac{0.0}; //return value if invalid
3205  float noisyStripThr{m_noisyStripThrDef?(m_noisyStripThrOffline):(m_noisyStripThrOnline)};
3206 
3207  //--- Identifier
3208  Identifier waferId{m_pSCTHelper->wafer_id(m_pSCTHelper->barrel_ec(moduleId),
3209  m_pSCTHelper->layer_disk(moduleId),
3210  m_pSCTHelper->phi_module(moduleId),
3211  m_pSCTHelper->eta_module(moduleId),
3212  chipId < n_chipPerSide ? 0 : 1)};
3213  IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
3214  //--- Histogram for this chip
3215  int chipPositionInSide{m_pSCTHelper->side(waferId) == 0 ? chipId : chipId - n_chipPerSide};
3216  int histIndex{static_cast<int>((waferHash.value())*n_chipPerSide + chipPositionInSide)};
3217 
3218  //--- Find LBs where this chip was noisy
3219  double chipOccupancyThr{noisyStripThr*n_stripPerChip*m_noisyChipFraction};
3220  std::set<int> LBList;
3221  LBList.clear();
3222  if (!m_calibLbTool) {
3223  ATH_MSG_ERROR("nullptr m_calibLbTool line " <<__LINE__);
3224  return std::make_pair(defectLB, defectLBFrac);
3225  }
3226 
3227  for (int iLB{0}; iLB != m_LBRange; ++iLB) {
3228  double numEventsInLB{static_cast<double>(m_calibLbTool->getNumberOfEventsInBin(iLB + 1))};
3229  if (numEventsInLB == 0) continue;
3230  double chipOccupancy{(float) m_calibLbTool->getBinForHistogramIndex(iLB + 1, histIndex) / numEventsInLB};
3231  if (chipOccupancy > chipOccupancyThr) LBList.insert(iLB);
3232  }
3233  //--- Transform LBList to string and calculate a fraction of noisy LBs
3234  if (LBList.size() != 0) {
3235  defectLB = getLBList(LBList);
3236  defectLBFrac = static_cast<float>(LBList.size()) / m_numOfLBsProcessed;
3237  }
3238 
3239  return std::make_pair(defectLB, defectLBFrac);
3240 }

◆ getNumNoisyStrips()

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

Definition at line 2711 of file SCTCalib.cxx.

2711  {
2712  IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
2713  //--- Check if there are noisy strips in the wafer
2714  int numNoisyStripsInTheWafer{0};
2715  bool isNoisyWafer{false};
2716  float noisyStripThr{m_noisyStripThrDef ? (m_noisyStripThrOffline) : (m_noisyStripThrOnline)};
2717  for (int iStrip{0}; iStrip != nbins; ++iStrip) {
2718  if ( (float) m_calibHitmapTool->getBinForHistogramIndex(iStrip + 1, waferHash.value()) / m_numberOfEvents > noisyStripThr) ++numNoisyStripsInTheWafer;
2719  }
2720  //--- Define/counts noisy wafers using wafer occupancy and number of noisy strips
2721  double averageOccupancy{m_calibHitmapTool->size(waferHash.value())/static_cast<double>(nbins)/static_cast<double>(m_numberOfEvents)};
2722  const int subdetector{m_pSCTHelper->barrel_ec(waferId)};
2723  isNoisyWafer = (numNoisyStripsInTheWafer > m_noisyWaferFraction*nbins) and
2724  ((subdetector == ENDCAP_C and averageOccupancy > m_noisyWaferThrECC) or
2725  (subdetector == BARREL and averageOccupancy > m_noisyWaferThrBarrel) or
2726  (subdetector == ENDCAP_A and averageOccupancy > m_noisyWaferThrECA));
2727  if (isNoisyWafer) {
2728  ATH_MSG_INFO("Module: " << waferHash.value());
2729  ATH_MSG_INFO("Hits, Nevts, Occ: " << m_calibHitmapTool->size(waferHash.value()) << ", "
2730  << m_numberOfEvents << ", "
2731  << averageOccupancy);
2732  }
2733  return std::make_pair(numNoisyStripsInTheWafer, isNoisyWafer);
2734 }

◆ getOverlapStripList()

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

Definition at line 2825 of file SCTCalib.cxx.

2825  {
2826  std::set<Identifier> stripList;
2827  std::set<Identifier>::const_iterator stripAllItrLast = stripAllIdList.end();
2828  std::set<Identifier>::const_iterator stripRefItrLast = stripRefIdList.end();
2829 
2830  std::set<Identifier>::const_iterator stripAllItr = stripAllIdList.begin();
2831  for ( ; stripAllItr != stripAllItrLast; ++stripAllItr ) {
2832  std::set<Identifier>::const_iterator stripRefItr = stripRefIdList.begin();
2833  bool old = false;
2834  for ( ; stripRefItr != stripRefItrLast; ++stripRefItr ) {
2835  if (*stripAllItr == *stripRefItr) old = true;
2836  }
2837  if (!old) {
2838  stripList.insert(*stripAllItr);
2839  }
2840  }
2841  return stripList;
2842 }

◆ getStripList()

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

Definition at line 2846 of file SCTCalib.cxx.

2846  {
2847  std::string strList;
2848  if (!stripIdList.empty()) {
2849  int firstStrip{-1};
2850  int groupSize{-1};
2851 
2852  std::set<Identifier>::const_iterator stripItrFirst{stripIdList.begin()};
2853  std::set<Identifier>::const_iterator stripItrLast{--stripIdList.end()};
2854 
2855  std::set<Identifier>::const_iterator stripItr{stripIdList.begin()};
2856  std::set<Identifier>::const_iterator stripItrE{stripIdList.end()};
2857  for (; stripItr != stripItrE; ++stripItr) {
2858  Identifier stripId{*stripItr};
2859  int stripNum{m_pSCTHelper->side(stripId)*nbins + m_pSCTHelper->strip(stripId)};
2860  if (stripItr == stripItrFirst) {
2861  firstStrip = stripNum;
2862  groupSize = 1;
2863  } else {
2864  if (stripNum == firstStrip + groupSize) {
2865  ++groupSize;
2866  } else {
2867  int stripBegin{firstStrip};
2868  int stripEnd{firstStrip + groupSize -1};
2869  strList = m_pCalibWriteTool->addDefect(strList, stripBegin, stripEnd);
2870  firstStrip = stripNum;
2871  groupSize = 1;
2872  }
2873  }
2874  if (stripItr == stripItrLast) {
2875  int stripBegin{firstStrip};
2876  int stripEnd{stripNum};
2877  strList = m_pCalibWriteTool->addDefect(strList, stripBegin, stripEnd);
2878  }
2879  }
2880  }
2881  return strList;
2882 }

◆ initialize()

StatusCode SCTCalib::initialize ( )
overridevirtual

Definition at line 122 of file SCTCalib.cxx.

122  {
123 
124  ATH_MSG_INFO("----- in initialize() ----- ");
125  if (detStore()->retrieve(m_pSCTHelper, "SCT_ID").isFailure()) {
126  ATH_MSG_ERROR("Unable to retrieve SCTHelper");
127  return StatusCode::FAILURE;
128  }
129 
130  if (not retrievedService(m_pCalibWriteTool)) return StatusCode::FAILURE;
131  if (m_doHV) ATH_MSG_FATAL("Not yet properly implemented and tested!");
132 
133  ATH_CHECK(m_ConfigurationConditionsTool.retrieve(EnableTool {m_useConfiguration}));
134 
135  if (not m_useCalibration) {
136  ATH_MSG_DEBUG("ReadCalibDataTool was removed in initialization");
137  m_ReadCalibDataTool.disable();
138  } else {
139  if (m_ReadCalibDataTool.retrieve().isFailure()) return StatusCode::FAILURE;
140  }
141 
142  if (not m_useMajority) {
143  ATH_MSG_DEBUG("MajorityConditionsTool was removed in initialization");
144  } else {
145  if (m_MajorityConditionsTool.retrieve().isFailure()) return StatusCode::FAILURE;
146  }
147 
148  if (not retrievedService(m_calibHitmapTool)) return StatusCode::FAILURE;
149 
150  if (not retrievedService(m_calibModuleListTool)) return StatusCode::FAILURE;
151 
152  if (not retrievedService(m_calibEvtInfoTool)) return StatusCode::FAILURE;
153 
154  if (not m_useBSError) {
155  ATH_MSG_DEBUG("ByteStreamErrorsSvc was removed in initialization");
156  } else {
157  if (not retrievedService(m_calibBsErrTool)) return StatusCode::FAILURE;
158  }
159  if (not retrievedService(m_calibLbTool)) return StatusCode::FAILURE;
160 
161  ATH_CHECK(m_CablingTool.retrieve());
162  ATH_CHECK(m_SCTDetEleCollKey.initialize());
163 
164  //--- LB range
165  try {
166  m_LBRange = std::stoi(m_LBMax);
167  m_calibHitmapTool->setNumberOfLb(m_LBRange);
168  m_calibLbTool->setNumberOfLb(m_LBRange);
169  m_calibBsErrTool->setNumberOfLb(m_LBRange);
170  } catch (...) {
171  ATH_MSG_ERROR("Couldn't cast m_LBMax=\"" << m_LBMax << "\" to m_LBRange...");
172  m_LBRange = 0;
173  }
174 
175  m_calibHitmapTool->setLbToMerge(m_nLbsMerged);
176  m_calibLbTool->setLbToMerge(m_nLbsMerged);
177  m_calibBsErrTool->setLbToMerge(m_nLbsMerged);
178 
179  m_readHIST = m_doNoiseOccupancy or m_doRawOccupancy or m_doEfficiency or m_doBSErrorDB or m_doLorentzAngle;
180 
181  if (m_readBS and m_readHIST) {
182  ATH_MSG_ERROR("Both BS and HIST are set to be read. Choose either of BS or HIST.");
183  return StatusCode::FAILURE;
184  }
185 
186  //--- Open BS
187  if (m_readBS) {
188  ATH_MSG_INFO("------------> Reading from ByteStream <-------------");
189  m_calibEvtInfoTool->setSource("BS");
190  }
191 
192  //--- Open HIST
193  if (m_readHIST) {
194  ATH_MSG_INFO("------------> Reading from HIST <-------------");
195  m_calibEvtInfoTool->setSource("HIST");
196  //--- List of HIST
197  std::string hist{""};
198  std::vector<std::string> histCollection{m_input_hist.value()};
199  ATH_MSG_INFO("The input histogram name is : " << m_input_hist);
200  if (not histCollection.empty()) {
201  hist=histCollection.back();
202  if (histCollection.size() > 1) ATH_MSG_WARNING("The Histogram collection contains more than one histogram; using the last one.");
203  } else {
204  ATH_MSG_ERROR("The input histogram collection property is empty");
205  return StatusCode::FAILURE;
206  }
207 
208  //in case of DeadStrip or DeadChip, change open from EOS to
209  //copy and open locally. Delete the file after processing
210  m_inputHist = TFile::Open(hist.c_str());
211 
212  ATH_MSG_INFO("opening HIST file : " << hist.c_str());
213 
214  if (m_inputHist) {
215  //--- Check run number
216  const std::string os{std::to_string(m_runNumber.value())};
217  ATH_MSG_INFO("Getting HIST directory : " << m_runNumber.value());
218  if (not m_inputHist->GetDirectory("/run_"+TString{os})) {
219  ATH_MSG_ERROR("RunNumber in HIST is inconsistent with jobO : " << os);
220  return StatusCode::FAILURE ;
221  }
222  ATH_MSG_INFO("Getting Number of events: " << m_calibEvtInfoTool->counter());
223  //--- Read number of events : Previously from entry of "tier0ESD" in "/GLOBAL/DQTDataFlow/events_lb"
224  std::string osHist{std::string{"/run_"} + std::to_string(m_runNumber.value())+"/SCT/GENERAL/Conf/NumberOfEventsVsLB"};
225  TH1F* hist_events{dynamic_cast<TH1F*>(m_inputHist->Get(osHist.c_str()))};
226  m_numberOfEventsHist = hist_events->GetEntries();
227  } else {
228  ATH_MSG_WARNING("can not open HIST : " << hist.c_str());
229  }
230 
231 
232  ATH_MSG_INFO("Initialization of TimeStamp/LB, taken from runInfo.txt");
233  //--- Initialization of TimeStamp/LB, taken from runInfo.txt
234  m_calibEvtInfoTool->setSource("HIST");
235  m_calibEvtInfoTool->setTimeStamp(m_runStartTime, m_runEndTime);
236  m_calibEvtInfoTool->setRunNumber(m_runNumber);
237  m_calibEvtInfoTool->setEventNumber(m_eventNumber);
238  }
239 
240  //--- Booking histograms for hitmaps
241  if (m_doHitMaps) m_calibHitmapTool->book();
242  //--- Booking histograms for BSErrors
243  if (m_doHitMaps and m_doBSErrors) m_calibBsErrTool->book();
244 
245  //--- Reading histograms for hitmaps
246  if ((not m_doHitMaps and not m_doHitMapsLB) and m_readHitMaps) {
247  ATH_MSG_INFO("Set CalibEventInfo for m_readHitMaps == true");
248  m_calibEvtInfoTool->setSource("HIST");
249  m_calibHitmapTool->read("./SCTHitMaps.root");
250  m_numberOfEventsHist = m_calibHitmapTool->size();
251  m_calibEvtInfoTool->setTimeStamp(m_runStartTime, m_runEndTime);
252  m_calibEvtInfoTool->setRunNumber(m_runNumber);
253  m_calibEvtInfoTool->setEventNumber(m_eventNumber);
254  if (m_doNoisyStrip) {
255  m_calibLbTool->read("./SCTLB.root");
256  }
257  if (m_doBSErrors) {
258  m_calibBsErrTool->read("./SCTBSErrors.root");
259  }
260  }
261  //--- Hit-vs-LB for LBs in noisy links/chips
262  if (m_doHitMapsLB) m_calibLbTool->book();
263 
264  //--- Check statistics for NoiseOccupancy
265  if (m_doNoiseOccupancy and notEnoughStatistics(m_noiseOccupancyMinStat, m_numberOfEventsHist)) return StatusCode::FAILURE;
266  //--- Check statistics for RawOccupancy
267  if (m_doRawOccupancy and notEnoughStatistics(m_rawOccupancyMinStat, m_numberOfEventsHist)) return StatusCode::FAILURE;
268  //--- Check statistics for Efficiency
269  if (m_doEfficiency and notEnoughStatistics(m_efficiencyMinStat, m_numberOfEventsHist)) return StatusCode::FAILURE;
270  //--- Check statistics for BSError
271  if (m_doBSErrorDB and notEnoughStatistics(m_BSErrorDBMinStat, m_numberOfEventsHist)) return StatusCode::FAILURE;
272  //--- Check statistics for LorentzAngle
273  if (m_doLorentzAngle and notEnoughStatistics(m_LorentzAngleMinStat, m_numberOfEventsHist)) return StatusCode::FAILURE;
274  //
275 
276  ATH_MSG_INFO("----- end of initialize() ----- ");
277  return StatusCode::SUCCESS;
278 }

◆ inputHandles()

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

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ 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 2934 of file SCTCalib.cxx.

2936  {
2937 
2938  ATH_MSG_DEBUG("noisyStripsToSummaryXml: start");
2939 
2940  //--- Open
2941  const char* outputFileName{badStripsFile.c_str()};
2942  std::ofstream outFile{outputFileName, std::ios::out};
2943  if (!outFile.good()) {
2944  ATH_MSG_ERROR("Unable to open " << outputFileName);
2945  return(StatusCode::FAILURE);
2946  }
2947 
2948  //--- Initialization
2949  int numLinksAll{0}, numChipsAll{0};
2950  int numModulesAll{0}, numModulesRef{0};
2951  int numStripsAll{0}, numStripsNew{0}, numStripsRef{0};
2952  int numModulesDiff{0};
2953 
2954  std::string defectLinks, defectChips;
2955  std::string defectStripsAll, defectStripsNew, defectStripsRef;
2956  std::ostringstream osModuleList, osChipList;
2957 
2958  //--- Create module list
2959  SCT_ID::const_id_iterator waferItr{m_pSCTHelper->wafer_begin()};
2960  SCT_ID::const_id_iterator waferItrE{m_pSCTHelper->wafer_end()};
2961  ATH_MSG_DEBUG("noisyStripsToSummaryXml: before wafer loop");
2962  for (; waferItr != waferItrE; ++waferItr) {
2963  //--- Identifier
2964  Identifier waferId{*waferItr};
2965  Identifier moduleId{m_pSCTHelper->module_id(waferId)};
2966  IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
2967  SCT_SerialNumber sn{m_CablingTool->getSerialNumberFromHash(waferHash)};
2968 
2969  //--- Initialization for a module
2970  if (m_pSCTHelper->side(waferId) == 0) {
2971  defectLinks.erase();
2972  defectChips.erase();
2973  defectStripsAll.erase();
2974  defectStripsNew.erase();
2975  defectStripsRef.erase();
2976  }
2977 
2978  //--- Noisy links
2979  bool isNoisyWafer{getNumNoisyStrips(waferId).second}; // true if this wafer is noisy
2980  if (isNoisyWafer) {
2981  int link{m_pSCTHelper->side(waferId)};
2982  defectLinks = m_pCalibWriteTool->addDefect(defectLinks, link, link);
2983  ++numLinksAll;
2984  }
2985 
2986  //--- Execute once in this module
2987  if (m_pSCTHelper->side(waferId) == 1) {
2988  ATH_MSG_DEBUG("noisyStripsToSummaryXml: ALL");
2989  //--- Noisy strips : All
2990  std::map< Identifier, std::set<Identifier> >::const_iterator moduleAllItr{moduleListAll.find(moduleId)};
2991  if (moduleAllItr != moduleListAll.end()) {
2992  defectStripsAll = getStripList((*moduleAllItr).second);
2993  ++numModulesAll;
2994  numStripsAll += (*moduleAllItr).second.size();
2995  }
2996 
2997  ATH_MSG_DEBUG("noisyStripsToSummaryXml: REF");
2998  //--- Noisy strips : Ref
2999  std::map< Identifier, std::set<Identifier> >::const_iterator moduleRefItr{moduleListRef.find(moduleId)};
3000  if (moduleRefItr != moduleListRef.end()) {
3001  defectStripsRef = getStripList(moduleRefItr->second);
3002  ++numModulesRef;
3003  numStripsRef += moduleRefItr->second.size();
3004  }
3005 
3006  ATH_MSG_DEBUG("noisyStripsToSummaryXml: NEW");
3007  //--- Noisy strips : New
3008  if ( moduleAllItr != moduleListAll.end() ) {
3009  if ( moduleRefItr != moduleListRef.end() ) {
3010  std::set<Identifier> listNEW = getOverlapStripList( (*moduleAllItr).second, (*moduleRefItr).second );
3011  defectStripsNew = getStripList( listNEW );
3012  numStripsNew += listNEW.size();
3013  } else {
3014 
3015  defectStripsNew = getStripList( (*moduleAllItr).second );
3016  }
3017  }
3018 
3019  ATH_MSG_DEBUG("noisyStripsToSummaryXml: stripIdList -> chipIdList");
3020  //--- Noisy chips : stripIdList -> chipIdList
3021  if (moduleAllItr != moduleListAll.end()) {
3022  std::set<int> chipIdList{getNoisyChips(moduleAllItr->second)};
3023  if (!chipIdList.empty()) {
3024  ++numChipsAll;
3025  std::set<int>::iterator chipItr{chipIdList.begin()};
3026  std::set<int>::iterator chipItrE{chipIdList.end()};
3027  for (; chipItr != chipItrE; ++chipItr) {
3028  int chipId{*chipItr};
3029  //--- To be written into module list
3030  defectChips = m_pCalibWriteTool->addDefect(defectChips, chipId, chipId);
3031  //--- LBs where this chip was noisy
3032  std::pair< std::string, float > defectLB{getNoisyLB(moduleId, chipId)};
3033  //--- Chip list written to XML
3034  osChipList << " <chip>" << linefeed
3035  << " <value name=\"SN\">" << sn.str() << "</value>" << linefeed
3036  << " <value name=\"BecLayerPhiEta\">" << m_pSCTHelper->barrel_ec(waferId) << "."
3037  << m_pSCTHelper->layer_disk(waferId) << "."
3038  << m_pSCTHelper->phi_module(waferId) << "."
3039  << m_pSCTHelper->eta_module(waferId) << "</value>" << linefeed
3040  << " <value name=\"ChipID\">" << chipId << "</value>" << linefeed
3041  << " <value name=\"LB\">" << normalizeList(defectLB.first) << "</value>" << linefeed
3042  << " <value name=\"LBFraction\">" << defectLB.second << "</value>" << linefeed
3043  << " </chip>" << std::endl;
3044  }
3045  }
3046  }
3047  ATH_MSG_DEBUG("noisyStripsToSummaryXml: Difference between All & Ref");
3048  //--- Difference between All & Ref
3049  if (defectStripsAll != defectStripsRef) ++numModulesDiff;
3050  //--- Module list written to XML
3051  if (!defectStripsAll.empty() or (m_noisyUpdate and defectStripsAll != defectStripsRef)) {
3052  osModuleList << " <module>" << linefeed
3053  << " <value name=\"SN\">" << sn.str() << "</value>" << linefeed
3054  << " <value name=\"BecLayerPhiEta\">" << m_pSCTHelper->barrel_ec(waferId) << "."
3055  << m_pSCTHelper->layer_disk(waferId) << "."
3056  << m_pSCTHelper->phi_module(waferId) << "."
3057  << m_pSCTHelper->eta_module(waferId) << "</value>" << linefeed
3058  << " <value name=\"LinkID\">" << normalizeList(defectLinks) << "</value>" << linefeed
3059  << " <value name=\"ChipID\">" << normalizeList(defectChips) << "</value>" << linefeed
3060  << " <value name=\"StripOfflineAll\">" << normalizeList(defectStripsAll) << "</value>" << linefeed
3061  << " <value name=\"StripOfflineNew\">" << normalizeList(defectStripsNew) << "</value>" << linefeed
3062  << " <value name=\"StripOfflineRef\">" << normalizeList(defectStripsRef) << "</value>" << linefeed
3063  << " </module>" << std::endl;
3064  }
3065  ATH_MSG_DEBUG("noisyStripsToSummaryXml: After Difference between All & Ref");
3066  }
3067  }//--- end loop : waferItr
3068 
3069  ATH_MSG_DEBUG("noisyStripsToSummaryXml: after waferItr");
3070 
3071  //--- Upload flag
3072  std::string strUploadFlag{"U"};
3073 
3074  bool isRunsInCool{false};
3075  bool isNoisyMinStat{false}, isNoisyModuleList{false}, isNoisyModuleDiff{false}, isNoisyStripDiff{false};
3076  if (m_noisyUploadTest) {
3077  isRunsInCool = ((m_noisyModuleAverageInDB != -1.) and (m_noisyStripLastRunInDB != -999));
3078  if (isRunsInCool) {
3079  isNoisyMinStat = m_numberOfEvents > m_noisyMinStat;
3080  isNoisyModuleList = numModulesAll < m_noisyModuleList;
3081  isNoisyModuleDiff = ((static_cast<float>(numModulesAll) - m_noisyModuleAverageInDB)/m_noisyModuleAverageInDB) < m_noisyModuleDiff;
3082  isNoisyStripDiff = ((static_cast<float>(numStripsAll) - m_noisyStripAverageInDB)/m_noisyStripAverageInDB) < m_noisyStripDiff;
3083  if (!isNoisyMinStat or !isNoisyModuleList) {
3084  strUploadFlag = "R";
3085  } else {
3086  if (!isNoisyModuleDiff or !isNoisyStripDiff) {
3087  strUploadFlag = "Y";
3088  } else {
3089  strUploadFlag = "G";
3090  }
3091  }
3092  }
3093  }
3094 
3095  ATH_MSG_DEBUG("noisyStripsToSummaryXml: after FlagChecking");
3096 
3097  //--- Upload test result to XML
3098  std::ostringstream osNoisyMinStat, osNoisyModuleList, osNoisyModuleDiff, osNoisyStripDiff;
3099  osNoisyMinStat << "#events more than " << m_noisyMinStat.value();
3100  osNoisyModuleList << "#(modules w/ at least 1 noisy strip) less than " << m_noisyModuleList.value();
3101  osNoisyModuleDiff << "Increase of #(modules w/ at least 1 noisy strip) from average of recent runs less than " << m_noisyModuleDiff*100 << "%";
3102  osNoisyStripDiff << "Increase of #(noisy strips) from average of recent runs less than " << m_noisyStripDiff*100 << "%";
3103 
3104  std::ostringstream osFlagReason;
3105  if (!isNoisyMinStat) osFlagReason << "FAILED in " << osNoisyMinStat.str() << "; ";
3106  if (!isNoisyModuleList) osFlagReason << "FAILED in " << osNoisyModuleList.str() << "; ";
3107  if (!isNoisyModuleDiff) osFlagReason << "FAILED in " << osNoisyModuleDiff.str() << "; ";
3108  if (!isNoisyStripDiff) osFlagReason << "FAILED in " << osNoisyStripDiff.str();
3109 
3110  std::string strFlagEnable = m_noisyUploadTest ? "ENABLED" : "DISABLED";
3111  std::string strRunsInCool = isRunsInCool ? "AVAILABLE" : "UNAVAILABLE";
3112 
3113  std::ostringstream osCheckList;
3114  osCheckList << osNoisyMinStat.str() << "; "
3115  << osNoisyModuleList.str() << "; "
3116  << osNoisyModuleDiff.str() << "; "
3117  << osNoisyStripDiff.str();
3118 
3119  //--- Write out the contents to XML file
3120  outFile << xmlHeader << linefeed
3121  << associateStylesheet("BadStrips.xsl") << linefeed
3122  << "<run>" << linefeed
3123  << " <value name=\"RunNumber\">" << m_runNumber.value() << "</value>" << linefeed
3124  << " <value name=\"StartTime\">" << m_utcBegin << "</value>" << linefeed
3125  << " <value name=\"EndTime\">" << m_utcEnd << "</value>" << linefeed
3126  << " <value name=\"Duration\">" << m_calibEvtInfoTool->duration() << "</value>" << linefeed
3127  << " <value name=\"LB\">" << m_numOfLBsProcessed << "</value>" << linefeed
3128  << " <value name=\"Events\">" << m_numberOfEvents << "</value>" << linefeed
3129  << " <value name=\"Modules\">" << numModulesAll << "</value>" << linefeed
3130  << " <value name=\"Links\">" << numLinksAll << "</value>" << linefeed
3131  << " <value name=\"Chips\">" << numChipsAll << "</value>" << linefeed
3132  << " <value name=\"StripsOfflineAll\">" << numStripsAll << "</value>" << linefeed
3133  << " <value name=\"StripsOfflineNew\">" << numStripsNew << "</value>" << linefeed
3134  << " <value name=\"ModulesRef\">" << numModulesRef << "</value>" << linefeed
3135  << " <value name=\"StripsOfflineRef\">" << numStripsRef << "</value>" << linefeed
3136  << " <value name=\"ModulesDiff\">" << numModulesDiff << "</value>" << linefeed
3137  << " <value name=\"Flag\">" << strUploadFlag << "</value>" << linefeed
3138  << " <value name=\"FlagReason\">" << osFlagReason.str() << "</value>" << linefeed
3139  << " <value name=\"FlagEnable\">" << strFlagEnable << "</value>" << linefeed
3140  << " <value name=\"ReadCool\">" << strRunsInCool << "</value>" << linefeed
3141  << " <value name=\"CheckList\">" << osCheckList.str() << "</value>" << linefeed
3142  << " <chips>" << linefeed
3143  << osChipList.str()
3144  << " </chips>" << linefeed
3145  << " <modules>" << linefeed
3146  << osModuleList.str()
3147  << " </modules>" << linefeed
3148  << "</run>" << std::endl;
3149 
3150  ATH_MSG_DEBUG("noisyStripsToSummaryXml: before return");
3151 
3152  return StatusCode::SUCCESS;
3153 }

◆ noisyStripsToXml()

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

Definition at line 2886 of file SCTCalib.cxx.

2886  {
2887  //--- Open
2888  const char* outputFileName{badStripsFile.c_str()};
2889  std::ofstream outFile{outputFileName, std::ios::out};
2890  if (!outFile.good()) {
2891  ATH_MSG_ERROR("Unable to open " << outputFileName);
2892  return(StatusCode::FAILURE);
2893  }
2894  float noisyStripThr{m_noisyStripThrDef ? (m_noisyStripThrOffline) : (m_noisyStripThrOnline)};
2895  //--- Create module list
2896  std::ostringstream osModuleList;
2897  //--- Loop over wafers
2898  SCT_ID::const_id_iterator waferItr{m_pSCTHelper->wafer_begin()};
2899  SCT_ID::const_id_iterator waferItrE{m_pSCTHelper->wafer_end()};
2900  for (; waferItr != waferItrE; ++waferItr) {
2901  Identifier waferId{*waferItr};
2902  Identifier moduleId{m_pSCTHelper->module_id(waferId)};
2903  if (m_pSCTHelper->side(waferId) != 0) continue;
2904  std::map< Identifier, std::set<Identifier> >::const_iterator moduleItr{moduleList.find(moduleId)};
2905  if (moduleItr != moduleList.end()) {
2906  std::string defectStrips{getStripList((*moduleItr).second)};
2907  osModuleList << " <channel id=\"" << m_pSCTHelper->module_id(waferId).get_compact() << "\" "
2908  << "since=\"" << m_iovStart.re_time() << "\" "
2909  << "until=\"" << m_iovStop.re_time() << "\">" << linefeed
2910  << " <value name=\"SampleSize\">" << "10000" << "</value>" << linefeed
2911  << " <value name=\"BarrelEndcap\">" << m_pSCTHelper->barrel_ec(waferId) << "</value>" << linefeed
2912  << " <value name=\"Layer\">" << m_pSCTHelper->layer_disk(waferId) << "</value>" << linefeed
2913  << " <value name=\"Eta\">" << m_pSCTHelper->eta_module(waferId) << "</value>" << linefeed
2914  << " <value name=\"Phi\">" << m_pSCTHelper->phi_module(waferId) << "</value>" << linefeed
2915  << " <value name=\"DefectType\">" << "NOISY" << "</value>" << linefeed
2916  << " <value name=\"Threshold\">" << noisyStripThr << "</value>" << linefeed
2917  << " <value name=\"DefectList\">" << normalizeList(defectStrips) << "</value>" << linefeed
2918  << " </channel>" << std::endl;
2919  }
2920  }
2921  //--- Write out the contents
2922  outFile << "<channels server=\"ATLAS_COOLPROD\" schema=\"ATLAS_COOLOFL_SCT\" dbname=\"CONDBR2\" folder=\"SCT/Derived/Monitoring\" "
2923  << "since=\"" << m_iovStart.re_time() << "\" "
2924  << "until=\"" << m_iovStop.re_time() << "\" "
2925  << "tag=\"" << m_tagID4NoisyStrips << "\" "
2926  << "version=\"" << "multi\">" << std::endl
2927  << osModuleList.str()
2928  << "</channels>" << std::endl;
2929 
2930  return StatusCode::SUCCESS;
2931 }

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

282  {
283  if (obtained<required) {
284  ATH_MSG_ERROR("Number of events in " << histogramName << ": " << obtained << " is less than the required minimum number of events " << required);
285  return true;
286  }
287  return false;
288 }

◆ openXML4DB()

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

Definition at line 2450 of file SCTCalib.cxx.

2450  {
2451  if (!strcmp(type, "DeadStrip")) {
2452  file.open(m_deadStripsFile.value().c_str(), std::ios::out);
2453  if (!file.good()) return StatusCode::FAILURE;
2454  file << "<channels server=\"ATLAS_COOLPROD\" schema=\"ATLAS_COOLOFL_SCT\" dbname=\"MONP200\" folder=\"SCT/Derived/DeadStrips\" ";
2455  } else if (!strcmp(type, "DeadChip")) {
2456  file.open(m_deadChipsFile.value().c_str(), std::ios::out);
2457  if (!file.good()) return StatusCode::FAILURE;
2458  file << "<channels server=\"ATLAS_COOLPROD\" schema=\"ATLAS_COOLOFL_SCT\" dbname=\"MONP200\" folder=\"SCT/Derived/DeadChips\" ";
2459  } else {
2460  ATH_MSG_ERROR("in openXML4DB : argument \"type\" needs to be (DeadStrip, DeadChip).");
2461  return StatusCode::FAILURE;
2462  }
2463  file << "since=\"" << start.re_time() << "\" "
2464  << "until=\"" << end.re_time() << "\" "
2465  << "tag=\"" << tag << "\" "
2466  << "version=\"" << "multi\">" << linefeed;
2467  return StatusCode::SUCCESS;
2468 }

◆ 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 2505 of file SCTCalib.cxx.

2505  {
2506  if (!strcmp(type, "DEAD")) {
2507  file.open(m_deadSummaryFile.value().c_str(), std::ios::out);
2508  if (!file.good()) return StatusCode::FAILURE;
2509  file << xmlHeader << linefeed << associateStylesheet("DeadInfo.xsl") << linefeed
2510  << "<run>" << linefeed;
2511  } else {
2512  ATH_MSG_ERROR("in openXML4DeadSummary : argument \"type\" needs to be \"DEAD\".");
2513  return StatusCode::FAILURE;
2514  }
2515 
2516  //--- Upload flag
2517  std::string strUploadFlag{"U"};
2518  bool isNonZero{false};
2519 
2520  if ((m_doDeadChip and m_deadChipUploadTest) or (m_doDeadStrip and m_deadStripUploadTest)) {
2521  if (n_Chip > 0) {
2522  isNonZero = true;
2523  strUploadFlag = "G";
2524  } else {
2525  strUploadFlag = "R";
2526  }
2527  }
2528 
2529  //--- Upload test result
2530  std::ostringstream osNonZero;
2531  osNonZero << "#chips or #strips is non-zero";
2532  std::ostringstream osFlagReason;
2533  if (!isNonZero) osFlagReason << "FAILED in " << osNonZero.str();
2534  std::string strFlagEnable{(m_deadChipUploadTest or m_deadStripUploadTest) ? "ENABLED" : "DISABLED"};
2535  std::ostringstream osCheckList;
2536  osCheckList << osNonZero.str();
2537 
2538  file << xmlValue("RunNumber", m_runNumber.value()) << linefeed
2539  << xmlValue("StartTime", m_utcBegin) << linefeed
2540  << xmlValue("EndTime", m_utcEnd) << linefeed
2541  << xmlValue("Duration", m_calibEvtInfoTool->duration()) << linefeed
2542  << xmlValue("LB", m_calibEvtInfoTool->numLumiBlocks()) << linefeed
2543  << xmlValue("Events", m_numberOfEvents) << linefeed
2544  << xmlValue("Modules", n_Module) << linefeed
2545  << xmlValue("Links", n_Link) << linefeed
2546  << xmlValue("Chips", n_Chip) << linefeed
2547  << xmlValue("Strips", n_Strip) << linefeed
2548  << xmlValue("Flag", strUploadFlag) << linefeed
2549  << xmlValue("FlagReason", osFlagReason.str()) << linefeed
2550  << xmlValue("FlagEnable", strFlagEnable) << linefeed
2551  << xmlValue("CheckList", osCheckList.str()) << linefeed
2552  << " <modules>" << std::endl;
2553 
2554  return StatusCode::SUCCESS;
2555 }

◆ openXML4MonSummary()

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

Definition at line 2558 of file SCTCalib.cxx.

2558  {
2559  using TwoStrings = std::pair<std::string, std::string>;
2560  using Names = std::map<std::string, TwoStrings>;
2561  Names nameAssociation;
2562  nameAssociation["NoiseOccupancy"] = TwoStrings(m_noiseOccupancySummaryFile, "NoiseOccupancyInfo.xsl");
2563  nameAssociation["RawOccupancy"] = TwoStrings(m_rawOccupancySummaryFile, "RawOccupancyInfo.xsl");
2564  nameAssociation["Efficiency"] = TwoStrings(m_efficiencySummaryFile, "EfficiencyInfo.xsl");
2565  nameAssociation["BSErrors"] = TwoStrings(m_BSErrorSummaryFile, "BSErrorInfo.xsl");
2566  nameAssociation["BSErrorsModule"] = TwoStrings(m_BSErrorModuleFile, "BSErrorInfo.xsl");
2567  Names::iterator found{nameAssociation.find(type)};
2568  if (found!=nameAssociation.end()) {
2569  std::string filename{found->second.first};
2570  std::string xslName{found->second.second};
2571  //
2572  file.open(filename.c_str(), std::ios::out);
2573  if (!file.good()) return StatusCode::FAILURE;
2574  file << xmlHeader << linefeed << associateStylesheet(xslName) << linefeed << "<run>" << std::endl;
2575  } else {
2576  ATH_MSG_ERROR("in openXML4MonSummary : argument \"type\" needs to be (NoiseOccupancy, RawOccupancy, Efficiency, BSErrors).");
2577  return StatusCode::FAILURE;
2578  }
2579  file << xmlValue("RunNumber", m_runNumber.value()) << linefeed
2580  << xmlValue("StartTime", m_utcBegin) << linefeed
2581  << xmlValue("EndTime", m_utcEnd) << linefeed
2582  << xmlValue("Duration", m_calibEvtInfoTool->duration()) << linefeed
2583  << xmlValue("LB", m_LBRange) << linefeed
2584  << xmlValue("Events", m_numberOfEvents) << linefeed
2585  << " <data>" << std::endl;
2586  return StatusCode::SUCCESS;
2587 }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< 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< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ retrievedService()

template<class S >
bool SCTCalib::retrievedService ( S &  service) const
inlineprivate

Definition at line 284 of file SCTCalib.h.

284  {
285  if (service.retrieve().isFailure()) {
286  ATH_MSG_ERROR("Unable to retrieve "<<service.name());
287  return false;
288  }
289  return true;
290  }

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

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

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< 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< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

◆ wrapUpXML4Summary()

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

Definition at line 2590 of file SCTCalib.cxx.

2590  {
2591  file << list.str();
2592  if (!strcmp(type, "DEAD")) {
2593  file << " </modules>" << std::endl;
2594  } else if (!strcmp(type, "NoiseOccupancy") or !strcmp(type, "RawOccupancy") or !strcmp(type, "Efficiency") or !strcmp(type, "BSErrors") or !strcmp(type, "LorentzAngle")) {
2595  file << " </data>" << std::endl;
2596  }
2597  file << "</run>" << std::endl;
2598 
2599  if (file.is_open()) {
2600  file.close();
2601  return StatusCode::SUCCESS;
2602  } else {
2603  return StatusCode::FAILURE;
2604  }
2605 }

◆ xmlChannelEfficiencyDataString()

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

Definition at line 2676 of file SCTCalib.cxx.

2676  {
2677  std::ostringstream os;
2678  os << " <module>" << std::endl
2679  << " " << xmlValue("SN", serial.str()) << std::endl
2680  << " " << xmlValue("SampleSize", "10000") << std::endl
2681  << " " << xmlValue("barrel_endcap", m_pSCTHelper->barrel_ec(waferId)) << std::endl
2682  << " " << xmlValue("Layer", m_pSCTHelper->layer_disk(waferId)) << linefeed
2683  << " " << xmlValue("Eta", m_pSCTHelper->eta_module(waferId)) << std::endl
2684  << " " << xmlValue("Phi", m_pSCTHelper->phi_module(waferId)) << std::endl
2685  << " " << xmlValue("Efficiency", efficiency) << std::endl
2686  << " " << xmlValue("Side", side )<<std::endl
2687  << " </module>";
2688  return os.str();
2689 }

◆ 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 2693 of file SCTCalib.cxx.

2693  {
2694  std::ostringstream os;
2695  os << " <chip>" << std::endl
2696  << " " << xmlValue("SN", serial.str()) << std::endl
2697  << " " << xmlValue("SampleSize", "10000") << std::endl
2698  << " " << xmlValue("barrel_endcap", m_pSCTHelper->barrel_ec(waferId)) << std::endl
2699  << " " << xmlValue("Layer", m_pSCTHelper->layer_disk(waferId)) << linefeed
2700  << " " << xmlValue("Eta", m_pSCTHelper->eta_module(waferId)) << std::endl
2701  << " " << xmlValue("Phi", m_pSCTHelper->phi_module(waferId)) << std::endl
2702  << " " << xmlValue("Side", side )<<std::endl
2703  << " " << xmlValue("Chip", chip )<<std::endl
2704  << " " << xmlValue("Efficiency", efficiency) << std::endl
2705  << " " << xmlValue("Efficiency_bcid", efficiency_bcid) << std::endl
2706  << " </chip>";
2707  return os.str();
2708 }

◆ xmlChannelNoiseOccDataString()

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

Definition at line 2660 of file SCTCalib.cxx.

2660  {
2661  std::ostringstream os;
2662  os << xmlOpenChannel(waferId.get_identifier32().get_compact(), m_iovStart.re_time(), m_iovStop.re_time()) << std::endl
2663  << " " << xmlValue("SN", serial.str()) << std::endl
2664  << " " << xmlValue("SampleSize", "10000") << std::endl
2665  << " " << xmlValue("barrel_endcap", m_pSCTHelper->barrel_ec(waferId)) << std::endl
2666  << " " << xmlValue("Layer", m_pSCTHelper->layer_disk(waferId)) << linefeed
2667  << " " << xmlValue("Eta", m_pSCTHelper->eta_module(waferId)) << std::endl
2668  << " " << xmlValue("Phi", m_pSCTHelper->phi_module(waferId)) << std::endl
2669  << " " << xmlValue("NoiseOccupancy", occupancy) << std::endl
2670  << " " << xmlCloseChannel();
2671  return os.str();
2672 }

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.

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

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

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

◆ m_BSErrorDBMinStat

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

Definition at line 205 of file SCTCalib.h.

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

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

◆ m_busyThr4DeadFinding

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

Definition at line 192 of file SCTCalib.h.

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

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

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

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

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

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

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

◆ m_deadChipMinStat

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

Definition at line 189 of file SCTCalib.h.

◆ m_deadChipsFile

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

Definition at line 222 of file SCTCalib.h.

◆ m_deadChipSignificance

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

Definition at line 191 of file SCTCalib.h.

◆ m_deadChipUploadTest

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

Definition at line 194 of file SCTCalib.h.

◆ m_deadNotQuiet

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

Definition at line 196 of file SCTCalib.h.

◆ m_deadStripMinStat

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

Definition at line 187 of file SCTCalib.h.

◆ m_deadStripMinStatBusy

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

Definition at line 188 of file SCTCalib.h.

◆ m_deadStripsFile

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

Definition at line 221 of file SCTCalib.h.

◆ m_deadStripSignificance

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

Definition at line 190 of file SCTCalib.h.

◆ m_deadStripUploadTest

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

Definition at line 195 of file SCTCalib.h.

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

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< 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.

◆ m_doBSErrors

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

Definition at line 149 of file SCTCalib.h.

◆ m_doDeadChip

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

Definition at line 153 of file SCTCalib.h.

◆ m_doDeadStrip

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

Definition at line 152 of file SCTCalib.h.

◆ m_doEfficiency

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

Definition at line 156 of file SCTCalib.h.

◆ m_doHitMaps

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

Definition at line 145 of file SCTCalib.h.

◆ m_doHitMapsLB

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

Definition at line 146 of file SCTCalib.h.

◆ m_doHV

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

Definition at line 151 of file SCTCalib.h.

◆ m_doLorentzAngle

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

Definition at line 158 of file SCTCalib.h.

◆ m_doNoiseOccupancy

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

Definition at line 154 of file SCTCalib.h.

◆ m_doNoisyStrip

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

Definition at line 150 of file SCTCalib.h.

◆ m_doRawOccupancy

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

Definition at line 155 of file SCTCalib.h.

◆ m_efficiencyChipFile

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

Definition at line 230 of file SCTCalib.h.

◆ m_efficiencyDoChips

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

Definition at line 204 of file SCTCalib.h.

◆ m_efficiencyMinStat

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

Definition at line 203 of file SCTCalib.h.

◆ m_efficiencyModuleFile

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

Definition at line 229 of file SCTCalib.h.

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

◆ m_eventNumber

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

Definition at line 129 of file SCTCalib.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< 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 79 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.

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

◆ m_inputHist

TFile* SCTCalib::m_inputHist {nullptr}
private

Definition at line 247 of file SCTCalib.h.

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

◆ m_LBRange

int SCTCalib::m_LBRange {-999}
private

Definition at line 242 of file SCTCalib.h.

◆ m_LorentzAngleDebugMode

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

Definition at line 208 of file SCTCalib.h.

◆ m_LorentzAngleFile

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

Definition at line 233 of file SCTCalib.h.

◆ m_LorentzAngleMinStat

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

Definition at line 206 of file SCTCalib.h.

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

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

◆ m_maxtbins

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

Definition at line 185 of file SCTCalib.h.

◆ m_nLbsMerged

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

Definition at line 147 of file SCTCalib.h.

◆ m_noiseOccupancyFile

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

Definition at line 225 of file SCTCalib.h.

◆ m_noiseOccupancyMinStat

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

Definition at line 201 of file SCTCalib.h.

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

◆ m_noiseOccupancyTriggerAware

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

Definition at line 200 of file SCTCalib.h.

◆ m_noisyChipFraction

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

Definition at line 183 of file SCTCalib.h.

◆ m_noisyMinStat

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

Definition at line 171 of file SCTCalib.h.

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

◆ m_noisyModuleDiff

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

Definition at line 168 of file SCTCalib.h.

◆ m_noisyModuleList

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

Definition at line 167 of file SCTCalib.h.

◆ m_noisyStripAll

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

Definition at line 172 of file SCTCalib.h.

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

◆ m_noisyStripDiff

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

Definition at line 169 of file SCTCalib.h.

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

◆ m_noisyStripThrDef

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

Definition at line 173 of file SCTCalib.h.

◆ m_noisyStripThrOffline

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

Definition at line 174 of file SCTCalib.h.

◆ m_noisyStripThrOnline

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

Definition at line 175 of file SCTCalib.h.

◆ m_noisyThr4DeadFinding

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

Definition at line 193 of file SCTCalib.h.

◆ m_noisyUpdate

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

Definition at line 161 of file SCTCalib.h.

◆ m_noisyUploadTest

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

Definition at line 163 of file SCTCalib.h.

◆ m_noisyWaferAllStrips

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

Definition at line 178 of file SCTCalib.h.

◆ m_noisyWaferFinder

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

Definition at line 176 of file SCTCalib.h.

◆ m_noisyWaferFraction

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

Definition at line 182 of file SCTCalib.h.

◆ m_noisyWaferThrBarrel

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

Definition at line 179 of file SCTCalib.h.

◆ m_noisyWaferThrECA

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

Definition at line 180 of file SCTCalib.h.

◆ m_noisyWaferThrECC

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

Definition at line 181 of file SCTCalib.h.

◆ m_noisyWaferWrite

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

Definition at line 177 of file SCTCalib.h.

◆ m_noisyWriteAllModules

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

Definition at line 162 of file SCTCalib.h.

◆ m_numberOfEvents

unsigned long long SCTCalib::m_numberOfEvents {0}
private

Definition at line 238 of file SCTCalib.h.

◆ m_numberOfEventsHist

unsigned long long SCTCalib::m_numberOfEventsHist {0}
private

Definition at line 239 of file SCTCalib.h.

◆ m_numOfLBsProcessed

int SCTCalib::m_numOfLBsProcessed {0}
private

Definition at line 237 of file SCTCalib.h.

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

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

◆ m_quietThresholdChip

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

Definition at line 198 of file SCTCalib.h.

◆ m_quietThresholdStrip

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

Definition at line 197 of file SCTCalib.h.

◆ m_rawOccupancyMinStat

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

Definition at line 202 of file SCTCalib.h.

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

◆ m_readBS

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

Definition at line 142 of file SCTCalib.h.

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

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

◆ m_runEndTime

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

Definition at line 132 of file SCTCalib.h.

◆ m_runNumber

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

Definition at line 128 of file SCTCalib.h.

◆ m_runStartTime

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

Definition at line 131 of file SCTCalib.h.

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

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

◆ m_tagID4DeadStrips

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

Definition at line 211 of file SCTCalib.h.

◆ m_tagID4NoiseOccupancy

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

Definition at line 213 of file SCTCalib.h.

◆ m_tagID4NoisyStrips

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

Definition at line 210 of file SCTCalib.h.

◆ m_useBSError

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

Definition at line 138 of file SCTCalib.h.

◆ m_useCalibration

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

Definition at line 136 of file SCTCalib.h.

◆ m_useConfiguration

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

Definition at line 135 of file SCTCalib.h.

◆ m_useMajority

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

Definition at line 137 of file SCTCalib.h.

◆ 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< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< 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.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
SCTCalib::nbins
@ nbins
Definition: SCTCalib.h:77
histCollection
Definition: LArQuickHistMerge.cxx:56
SCT_CalibAlgs::chipList2LinkList
std::string chipList2LinkList(const std::string &chipList)
Definition: SCT_CalibUtilities.cxx:47
SCTCalib::n_BSErrorType
@ n_BSErrorType
Definition: SCTCalib.h:92
SCTCalib::last_barrel
@ last_barrel
Definition: SCTCalib.h:82
SCTCalib::n_chipPerModule
@ n_chipPerModule
Definition: SCTCalib.h:89
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
SCTCalib::m_efficiencyMinStat
UnsignedIntegerProperty m_efficiencyMinStat
Definition: SCTCalib.h:203
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
SCTCalib::m_iovStop
IOVTime m_iovStop
Definition: SCTCalib.h:244
SCTCalib::n_phiBinsB0
@ n_phiBinsB0
Definition: SCTCalib.h:90
SCTCalib::m_deadStripUploadTest
BooleanProperty m_deadStripUploadTest
Definition: SCTCalib.h:195
SCTCalib::m_doHitMapsLB
BooleanProperty m_doHitMapsLB
Definition: SCTCalib.h:146
SCTCalib::m_eventNumber
IntegerProperty m_eventNumber
Definition: SCTCalib.h:129
SCTCalib::n_etaBinsEC
@ n_etaBinsEC
Definition: SCTCalib.h:84
SCTCalib::m_readHitMaps
BooleanProperty m_readHitMaps
Definition: SCTCalib.h:148
SCTCalib::m_pSCTHelper
const SCT_ID * m_pSCTHelper
Definition: SCTCalib.h:95
InDetDD::SiDetectorElementCollection
Definition: SiDetectorElementCollection.h:30
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
SCTCalib::n_etaBins
@ n_etaBins
Definition: SCTCalib.h:80
SCTCalib::n_phiBinsEC
@ n_phiBinsEC
Definition: SCTCalib.h:85
SCTCalib::m_BSErrorDBMinStat
UnsignedIntegerProperty m_BSErrorDBMinStat
Definition: SCTCalib.h:205
SCTCalib::m_calibHitmapTool
ToolHandle< ISCT_CalibHistoTool > m_calibHitmapTool
Definition: SCTCalib.h:103
SCTCalib::m_LorentzAngleMinStat
UnsignedIntegerProperty m_LorentzAngleMinStat
Definition: SCTCalib.h:206
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
SCTCalib::m_runStartTime
StringProperty m_runStartTime
Definition: SCTCalib.h:131
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
SCTCalib::m_nLbsMerged
IntegerProperty m_nLbsMerged
Definition: SCTCalib.h:147
SCTCalib::first_hitBin
@ first_hitBin
Definition: SCTCalib.h:79
plotmaker.hist
hist
Definition: plotmaker.py:148
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
SCT_CalibAlgs::XmlStreamer
Definition: XmlStreamer.h:18
SCTCalib::m_useBSError
BooleanProperty m_useBSError
Definition: SCTCalib.h:138
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
SCTCalib::m_doEfficiency
BooleanProperty m_doEfficiency
Definition: SCTCalib.h:156
SCTCalib::m_runEndTime
StringProperty m_runEndTime
Definition: SCTCalib.h:132
SCT_ID::wafer_begin
const_id_iterator wafer_begin(void) const
Iterators over full set of ids. Wafer iterator is sorted.
Definition: SCT_ID.cxx:654
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
SCTCalib::notEnoughStatistics
bool notEnoughStatistics(const int required, const int obtained, const std::string &histogramName="HIST") const
Definition: SCTCalib.cxx:282
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
SCTCalib::m_noisyStripThrDef
BooleanProperty m_noisyStripThrDef
Definition: SCTCalib.h:173
SCTCalib::lastBSErrorType
@ lastBSErrorType
Definition: SCTCalib.h:92
SCTCalib::m_noisyWaferThrBarrel
FloatProperty m_noisyWaferThrBarrel
Definition: SCTCalib.h:179
SCTCalib::first_phiBinEC
@ first_phiBinEC
Definition: SCTCalib.h:85
SCT_ID::const_id_iterator
std::vector< Identifier >::const_iterator const_id_iterator
Definition: SCT_ID.h:73
SCTCalib::m_rawOccupancySummaryFile
StringProperty m_rawOccupancySummaryFile
Definition: SCTCalib.h:227
SCTCalib::m_BSErrorModuleFile
StringProperty m_BSErrorModuleFile
Definition: SCTCalib.h:232
SCTCalib::n_elements
@ n_elements
Definition: SCTCalib.h:91
SCTCalib::n_phiBinsECOuter
@ n_phiBinsECOuter
Definition: SCTCalib.h:91
SCTCalib::n_phiBinsECMiddle
@ n_phiBinsECMiddle
Definition: SCTCalib.h:91
SCTCalib::m_efficiencySummaryFile
StringProperty m_efficiencySummaryFile
Definition: SCTCalib.h:228
SCTCalib::m_noisyStripLastRunInDB
IntegerProperty m_noisyStripLastRunInDB
Definition: SCTCalib.h:165
SCT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: SCT_ID.h:728
SCT_ID::phi_module
int phi_module(const Identifier &id) const
Definition: SCT_ID.h:740
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
histCollection::size
size_t size()
Definition: LArQuickHistMerge.cxx:62
SCTCalib::m_calibBsErrTool
ToolHandle< ISCT_CalibHistoTool > m_calibBsErrTool
Definition: SCTCalib.h:105
SCTCalib::m_BSErrorSummaryFile
StringProperty m_BSErrorSummaryFile
Definition: SCTCalib.h:231
SCTCalib::m_noisyModuleAverageInDB
FloatProperty m_noisyModuleAverageInDB
Definition: SCTCalib.h:164
SCT_ID::module_id
Identifier module_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition: SCT_ID.h:416
SCTCalib::n_phiBinsB3
@ n_phiBinsB3
Definition: SCTCalib.h:90
SCTCalib::m_noisyModuleDiff
FloatProperty m_noisyModuleDiff
Definition: SCTCalib.h:168
SCTCalib::m_SCTDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection > m_SCTDetEleCollKey
Definition: SCTCalib.h:96
DeMoAtlasDataLoss.lbRange
string lbRange
Definition: DeMoAtlasDataLoss.py:67
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
SCTCalib::n_barrels
@ n_barrels
Definition: SCTCalib.h:82
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
SCTCalib::m_doHV
BooleanProperty m_doHV
Definition: SCTCalib.h:151
SCTCalib::m_input_hist
StringArrayProperty m_input_hist
Definition: SCTCalib.h:140
SCTCalib::n_phiBinsB2
@ n_phiBinsB2
Definition: SCTCalib.h:90
SCTCalib::n_stripPerChip
@ n_stripPerChip
Definition: SCTCalib.h:89
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TRT::Hit::side
@ side
Definition: HitInfo.h:83
SCTCalib::lastTimeBin
@ lastTimeBin
Definition: SCTCalib.h:78
SCTCalib::m_doRawOccupancy
BooleanProperty m_doRawOccupancy
Definition: SCTCalib.h:155
SCTCalib::m_numberOfEvents
unsigned long long m_numberOfEvents
Definition: SCTCalib.h:238
SCTCalib::m_LBRange
int m_LBRange
Definition: SCTCalib.h:242
SCT_ConditionsAlgorithms::xmlHeader
std::string xmlHeader(const std::string &version="1.0", const std::string &encoding="UTF-8")
Definition: SCT_SimpleHisto.h:64
SCTCalib::m_numberOfEventsHist
unsigned long long m_numberOfEventsHist
Definition: SCTCalib.h:239
SCTCalib::m_noisyStripAverageInDB
FloatProperty m_noisyStripAverageInDB
Definition: SCTCalib.h:166
SCTCalib::first_etaBin
@ first_etaBin
Definition: SCTCalib.h:80
SCTCalib::m_noisyModuleList
IntegerProperty m_noisyModuleList
Definition: SCTCalib.h:167
SCTCalib::last_hitBin
@ last_hitBin
Definition: SCTCalib.h:79
efficiency
void efficiency(std::vector< double > &bins, std::vector< double > &values, const std::vector< std::string > &files, const std::string &histname, const std::string &tplotname, const std::string &label="")
Definition: dependence.cxx:128
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
SCTCalib::m_useMajority
BooleanProperty m_useMajority
Definition: SCTCalib.h:137
SCT_SerialNumber::str
std::string str() const
Full serial number as a string
Definition: SCT_SerialNumber.cxx:56
SCTCalib::m_useConfiguration
BooleanProperty m_useConfiguration
Definition: SCTCalib.h:135
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
SCTCalib::m_deadSummaryFile
StringProperty m_deadSummaryFile
Definition: SCTCalib.h:223
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
SCTCalib::m_inputHist
TFile * m_inputHist
Definition: SCTCalib.h:247
SCTCalib::m_iovStart
IOVTime m_iovStart
Definition: SCTCalib.h:243
SCTCalib::firstStrip
@ firstStrip
Definition: SCTCalib.h:77
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
SCTCalib::last_phiBinEC
@ last_phiBinEC
Definition: SCTCalib.h:85
SCTCalib::m_useCalibration
BooleanProperty m_useCalibration
Definition: SCTCalib.h:136
SCTCalib::n_phiBinsECShort
@ n_phiBinsECShort
Definition: SCTCalib.h:91
SCT_CalibAlgs::xmlOpenChannel
std::string xmlOpenChannel(const long id, const T since, const T until)
Definition: SCT_CalibUtilities.h:36
SCTCalib::m_ConfigurationConditionsTool
ToolHandle< ISCT_ConfigurationConditionsTool > m_ConfigurationConditionsTool
Definition: SCTCalib.h:99
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
SCT_CalibAlgs::formatPosition
std::string formatPosition(const Identifier &waferId, const SCT_ID *helper, const std::string &delimiter, const bool includeSide)
Definition: SCT_CalibUtilities.cxx:36
SCT_CalibAlgs::xmlValue
std::string xmlValue(const std::string &name, const T value)
Definition: SCT_CalibUtilities.h:29
SCTCalib::m_readBS
BooleanProperty m_readBS
Definition: SCTCalib.h:142
SCTCalib::last_etaBin
@ last_etaBin
Definition: SCTCalib.h:80
SCTCalib::m_doBSErrorDB
BooleanProperty m_doBSErrorDB
Definition: SCTCalib.h:157
SCTCalib::m_utcEnd
std::string m_utcEnd
Definition: SCTCalib.h:241
SCTCalib::m_writeToCool
BooleanProperty m_writeToCool
Definition: SCTCalib.h:159
SCTCalib::m_doNoiseOccupancy
BooleanProperty m_doNoiseOccupancy
Definition: SCTCalib.h:154
file
TFile * file
Definition: tile_monitor.h:29
SCTCalib::m_runNumber
IntegerProperty m_runNumber
Definition: SCTCalib.h:128
SCTCalib::ntimeBins
@ ntimeBins
Definition: SCTCalib.h:78
SCTCalib::getLBList
std::string getLBList(const std::set< int > &LBList) const
Definition: SCTCalib.cxx:3243
SCTCalib::m_readHIST
bool m_readHIST
Definition: SCTCalib.h:248
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
SCT_ID::wafer_hash
IdentifierHash wafer_hash(const Identifier &wafer_id) const
wafer hash from id - optimized
Definition: SCT_ID.h:492
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SCTCalib::m_doDeadStrip
BooleanProperty m_doDeadStrip
Definition: SCTCalib.h:152
SCTCalib::n_etaInBarrel
@ n_etaInBarrel
Definition: SCTCalib.h:89
SCTCalib::m_calibModuleListTool
ToolHandle< ISCT_CalibModuleListTool > m_calibModuleListTool
Definition: SCTCalib.h:106
SCT_Monitoring::ENDCAP_A
@ ENDCAP_A
Definition: SCT_MonitoringNumbers.h:21
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
SCTCalib::lastStrip
@ lastStrip
Definition: SCTCalib.h:77
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
SCTCalib::last_disk
@ last_disk
Definition: SCTCalib.h:83
SCTCalib::m_ReadCalibDataTool
ToolHandle< ISCT_ReadCalibDataTool > m_ReadCalibDataTool
Definition: SCTCalib.h:100
SCTCalib::n_hitBins
@ n_hitBins
Definition: SCTCalib.h:79
SCTCalib::m_MajorityConditionsTool
ToolHandle< ISCT_DetectorLevelConditionsTool > m_MajorityConditionsTool
Definition: SCTCalib.h:101
perfmonmt-printer.required
required
Definition: perfmonmt-printer.py:184
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
DQPostProcessTest.outFile
outFile
Comment Out Those You do not wish to run.
Definition: DQPostProcessTest.py:37
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
SCTCalib::m_pCalibWriteTool
ToolHandle< SCTCalibWriteTool > m_pCalibWriteTool
Definition: SCTCalib.h:98
SCT_CalibAlgs::xmlCloseChannel
std::string xmlCloseChannel()
Definition: SCT_CalibUtilities.cxx:65
SCTCalib::m_calibLbTool
ToolHandle< ISCT_CalibHistoTool > m_calibLbTool
Definition: SCTCalib.h:104
SCTCalib::first_etaBinEC
@ first_etaBinEC
Definition: SCTCalib.h:84
SCTCalib::n_phiBinsB1
@ n_phiBinsB1
Definition: SCTCalib.h:90
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
SCTCalib::m_noisyWaferThrECA
FloatProperty m_noisyWaferThrECA
Definition: SCTCalib.h:180
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
SCTCalib::first_phiBin
@ first_phiBin
Definition: SCTCalib.h:81
SCTCalib::getStripList
std::string getStripList(const std::set< Identifier > &stripIdList) const
Definition: SCTCalib.cxx:2846
SCT_CalibAlgs::normalizeList
std::string normalizeList(std::string s)
Definition: SCT_CalibUtilities.cxx:21
SCTCalib::m_noiseOccupancySummaryFile
StringProperty m_noiseOccupancySummaryFile
Definition: SCTCalib.h:226
SCTCalib::getNoisyChips
std::set< int > getNoisyChips(const std::set< Identifier > &stripIdList) const
Definition: SCTCalib.cxx:3157
SCTCalib::m_doDeadChip
BooleanProperty m_doDeadChip
Definition: SCTCalib.h:153
SCT_ID::layer_disk
int layer_disk(const Identifier &id) const
Definition: SCT_ID.h:734
SCT_Monitoring::ENDCAP_C
@ ENDCAP_C
Definition: SCT_MonitoringNumbers.h:21
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
SCTCalib::m_doHitMaps
BooleanProperty m_doHitMaps
Definition: SCTCalib.h:145
SCTCalib::m_noisyChipFraction
FloatProperty m_noisyChipFraction
Definition: SCTCalib.h:183
SCT_SerialNumber
Definition: SCT_SerialNumber.h:22
SCTCalib::getNoisyLB
std::pair< std::string, float > getNoisyLB(const Identifier &moduleId, int &chipId) const
Definition: SCTCalib.cxx:3202
xAOD::timeStamp
setEventNumber timeStamp
Definition: EventInfo_v1.cxx:128
SCTCalib::getNumNoisyStrips
std::pair< int, bool > getNumNoisyStrips(const Identifier &waferId) const
Definition: SCTCalib.cxx:2711
SCTCalib::m_doBSErrors
BooleanProperty m_doBSErrors
Definition: SCTCalib.h:149
SCTCalib::n_disks
@ n_disks
Definition: SCTCalib.h:83
SCTCalib::n_chipPerSide
@ n_chipPerSide
Definition: SCTCalib.h:89
SCTCalib::m_utcBegin
std::string m_utcBegin
Definition: SCTCalib.h:240
python.PyAthena.v
v
Definition: PyAthena.py:154
SCTCalib::m_gofile
std::ofstream m_gofile
Definition: SCTCalib.h:114
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
a
TList * a
Definition: liststreamerinfos.cxx:10
Threshold
Threshold
Definition: TRIGGERidentity.h:18
SCTCalib::m_noiseOccupancyMinStat
UnsignedIntegerProperty m_noiseOccupancyMinStat
Definition: SCTCalib.h:201
h
SCTCalib::m_noisyStripDiff
FloatProperty m_noisyStripDiff
Definition: SCTCalib.h:169
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
CSV_InDetExporter.old
old
Definition: CSV_InDetExporter.py:145
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
SCT_ID::strip
int strip(const Identifier &id) const
Definition: SCT_ID.h:764
SCTCalib::m_noisyUpdate
BooleanProperty m_noisyUpdate
Definition: SCTCalib.h:161
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
SCT_ID::eta_module
int eta_module(const Identifier &id) const
Definition: SCT_ID.h:746
SCTCalib::m_rawOccupancyMinStat
UnsignedIntegerProperty m_rawOccupancyMinStat
Definition: SCTCalib.h:202
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:24
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
BARREL
@ BARREL
Definition: TRTRadiatorParameters.h:10
SCTCalib::m_deadChipsFile
StringProperty m_deadChipsFile
Definition: SCTCalib.h:222
SCTCalib::m_deadStripsFile
StringProperty m_deadStripsFile
Definition: SCTCalib.h:221
SCTCalib::retrievedService
bool retrievedService(S &service) const
Definition: SCTCalib.h:284
SCT_ID::side
int side(const Identifier &id) const
Definition: SCT_ID.h:752
SCT_ID::wafer_end
const_id_iterator wafer_end(void) const
Definition: SCT_ID.cxx:658
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
SCTCalib::m_noisyStripThrOnline
FloatProperty m_noisyStripThrOnline
Definition: SCTCalib.h:175
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
SCTCalib::n_phiBins
@ n_phiBins
Definition: SCTCalib.h:81
SCTCalib::firstTimeBin
@ firstTimeBin
Definition: SCTCalib.h:78
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:24
SCTCalib::m_noisyWaferFraction
FloatProperty m_noisyWaferFraction
Definition: SCTCalib.h:182
SCTCalib::m_tagID4NoisyStrips
StringProperty m_tagID4NoisyStrips
Definition: SCTCalib.h:210
SCT_ID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module, int side) const
For a single side of module.
Definition: SCT_ID.h:464
SCTCalib::m_numOfLBsProcessed
int m_numOfLBsProcessed
Definition: SCTCalib.h:237
SCTCalib::last_etaBinEC
@ last_etaBinEC
Definition: SCTCalib.h:84
InDetConditions::SCT_STRIP
@ SCT_STRIP
Definition: InDetHierarchy.h:14
SCTCalib::getOverlapStripList
std::set< Identifier > getOverlapStripList(const std::set< Identifier > &stripAllIdList, const std::set< Identifier > &stripRefIdList) const
Definition: SCTCalib.cxx:2825
xAOD::lumiBlock
setTeId lumiBlock
Definition: L2StandAloneMuon_v1.cxx:327
SCTCalib::m_deadChipUploadTest
BooleanProperty m_deadChipUploadTest
Definition: SCTCalib.h:194
SCTCalib::m_noisyStripThrOffline
FloatProperty m_noisyStripThrOffline
Definition: SCTCalib.h:174
AthenaPoolExample_Copy.outputFileName
string outputFileName
Definition: AthenaPoolExample_Copy.py:40
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
SCTCalib::m_CablingTool
ToolHandle< ISCT_CablingTool > m_CablingTool
Definition: SCTCalib.h:102
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
SCTCalib::m_noisyUploadTest
BooleanProperty m_noisyUploadTest
Definition: SCTCalib.h:163
SCTCalib::m_noisyMinStat
UnsignedIntegerProperty m_noisyMinStat
Definition: SCTCalib.h:171
SCTCalib::last_phiBin
@ last_phiBin
Definition: SCTCalib.h:81
readCCLHist.float
float
Definition: readCCLHist.py:83
SCTCalib::firstBSErrorType
@ firstBSErrorType
Definition: SCTCalib.h:92
SCTCalib::m_LBMax
StringProperty m_LBMax
Definition: SCTCalib.h:133
SCTCalib::m_doNoisyStrip
BooleanProperty m_doNoisyStrip
Definition: SCTCalib.h:150
SCTCalib::m_doLorentzAngle
BooleanProperty m_doLorentzAngle
Definition: SCTCalib.h:158
SCTCalib::first_disk
@ first_disk
Definition: SCTCalib.h:83
WriteBchToCool.moduleList
moduleList
Definition: WriteBchToCool.py:72
fitman.k
k
Definition: fitman.py:528
SCTCalib::m_calibEvtInfoTool
ToolHandle< ISCT_CalibEvtInfo > m_calibEvtInfoTool
Definition: SCTCalib.h:107
SCTCalib::first_barrel
@ first_barrel
Definition: SCTCalib.h:82
ServiceHandle< ICondSvc >
SCT_ID::strip_id
Identifier strip_id(int barrel_ec, int layer_disk, int phi_module, int eta_module, int side, int strip) const
For an individual strip.
Definition: SCT_ID.h:535
SCTCalib::m_noisyWaferThrECC
FloatProperty m_noisyWaferThrECC
Definition: SCTCalib.h:181
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sun Dec 22 2024 21:44:04 for ATLAS Offline Software by   doxygen 1.8.18