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 *, IOVTime, 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 2725 of file SCTCalib.cxx.

2725  {
2726  IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
2727  float noisyStripThr{m_noisyStripThrDef ? (m_noisyStripThrOffline):(m_noisyStripThrOnline)};
2728  for (int iStrip{0}; iStrip != nbins; ++iStrip) {
2729  Identifier stripId{m_pSCTHelper->strip_id(waferId, iStrip)};
2730  if (!isNoisy) { //--- Add all strips
2731  stripIdList.insert(stripId);
2732  } else {
2733  const float stripOccupancy{ (float) m_calibHitmapTool->getBinForHistogramIndex(iStrip + 1, waferHash.value()) / m_numberOfEvents};
2734  if (stripOccupancy > noisyStripThr) {
2735  if (!isNew) { //--- All noisy strips
2736  stripIdList.insert(stripId);
2737  } else { //--- New noisy strips : compared with configuration and calibration
2738  const bool isGoodInConfiguration{m_useConfiguration ? m_ConfigurationConditionsTool->isGood(stripId, InDetConditions::SCT_STRIP) : true};
2739  const bool isGoodInCalibration{m_useCalibration ? m_ReadCalibDataTool->isGood(stripId, InDetConditions::SCT_STRIP) : true};
2740  if (m_useConfiguration or m_useCalibration) {
2741  if (isGoodInConfiguration and isGoodInCalibration) {
2742  stripIdList.insert(stripId);
2743  }
2744  }
2745  }
2746  }
2747  }
2748  }
2749  return StatusCode::SUCCESS;
2750 }

◆ addToSummaryStr()

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

Definition at line 2595 of file SCTCalib.cxx.

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

◆ addToXML4DB()

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

Definition at line 2469 of file SCTCalib.cxx.

2469  {
2470  std::string tmp{DefectList};
2471  int length{static_cast<int>(tmp.length())};
2472  std::string Defect4DB{tmp.substr(1, length-2)}; // Removing first&end spaces in DefectList
2473 
2474  file << xmlOpenChannel(m_pSCTHelper->module_id(waferId).get_identifier32().get_compact(), m_iovStart.re_time(), m_iovStop.re_time()) << linefeed
2475  << xmlValue("SampleSize", "10000") << linefeed
2476  << xmlValue("BarrelEndcap", m_pSCTHelper->barrel_ec(waferId)) << linefeed
2477  << xmlValue("Layer", m_pSCTHelper->layer_disk(waferId)) << linefeed
2478  << xmlValue("Eta", m_pSCTHelper->eta_module(waferId)) << linefeed
2479  << xmlValue("Phi", m_pSCTHelper->phi_module(waferId)) << linefeed
2480  << xmlValue("DefectType", DefectType) << linefeed
2481  << xmlValue("Threshold", Threshold) << linefeed
2482  << xmlValue("DefectList", Defect4DB) << linefeed
2483  << xmlCloseChannel() << std::endl;
2484 
2485  return StatusCode::SUCCESS;
2486 }

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

2458  {
2459  file << "</channels>" << std::endl;
2460  if (file.is_open()) {
2461  file.close();
2462  return StatusCode::SUCCESS;
2463  } else {
2464  return StatusCode::FAILURE;
2465  }
2466 }

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

3230  {
3231  std::string strList;
3232  strList.erase();
3233  if (!LBList.empty()) {
3234  int firstLB{-1};
3235  int LBSize{-1};
3236 
3237  std::set<int>::const_iterator LBItrFirst{LBList.begin()};
3238  std::set<int>::const_iterator LBItrLast{--LBList.end()};
3239 
3240  std::set<int>::const_iterator LBItr{LBList.begin()};
3241  std::set<int>::const_iterator LBItrE{LBList.end()};
3242  for (; LBItr != LBItrE; ++LBItr) {
3243  int iLB{*LBItr};
3244  if (LBItr == LBItrFirst) {
3245  firstLB = iLB;
3246  LBSize = 1;
3247  } else {
3248  if (iLB == firstLB + LBSize) {
3249  ++LBSize;
3250  } else {
3251  int LBBegin{firstLB};
3252  int LBEnd{firstLB + LBSize -1};
3253  strList = m_pCalibWriteTool->addDefect(strList, LBBegin, LBEnd);
3254  firstLB = iLB;
3255  LBSize = 1;
3256  }
3257  }
3258  if (LBItr == LBItrLast) {
3259  int LBBegin{firstLB};
3260  int LBEnd{iLB};
3261  strList = m_pCalibWriteTool->addDefect(strList, LBBegin, LBEnd);
3262  }
3263  }
3264  }
3265  return strList;
3266 }

◆ getNoisyChips()

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

Definition at line 3144 of file SCTCalib.cxx.

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

◆ getNoisyLB()

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

Definition at line 3189 of file SCTCalib.cxx.

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

◆ getNumNoisyStrips()

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

Definition at line 2698 of file SCTCalib.cxx.

2698  {
2699  IdentifierHash waferHash{m_pSCTHelper->wafer_hash(waferId)};
2700  //--- Check if there are noisy strips in the wafer
2701  int numNoisyStripsInTheWafer{0};
2702  bool isNoisyWafer{false};
2703  float noisyStripThr{m_noisyStripThrDef ? (m_noisyStripThrOffline) : (m_noisyStripThrOnline)};
2704  for (int iStrip{0}; iStrip != nbins; ++iStrip) {
2705  if ( (float) m_calibHitmapTool->getBinForHistogramIndex(iStrip + 1, waferHash.value()) / m_numberOfEvents > noisyStripThr) ++numNoisyStripsInTheWafer;
2706  }
2707  //--- Define/counts noisy wafers using wafer occupancy and number of noisy strips
2708  double averageOccupancy{m_calibHitmapTool->size(waferHash.value())/static_cast<double>(nbins)/static_cast<double>(m_numberOfEvents)};
2709  const int subdetector{m_pSCTHelper->barrel_ec(waferId)};
2710  isNoisyWafer = (numNoisyStripsInTheWafer > m_noisyWaferFraction*nbins) and
2711  ((subdetector == ENDCAP_C and averageOccupancy > m_noisyWaferThrECC) or
2712  (subdetector == BARREL and averageOccupancy > m_noisyWaferThrBarrel) or
2713  (subdetector == ENDCAP_A and averageOccupancy > m_noisyWaferThrECA));
2714  if (isNoisyWafer) {
2715  ATH_MSG_INFO("Module: " << waferHash.value());
2716  ATH_MSG_INFO("Hits, Nevts, Occ: " << m_calibHitmapTool->size(waferHash.value()) << ", "
2717  << m_numberOfEvents << ", "
2718  << averageOccupancy);
2719  }
2720  return std::make_pair(numNoisyStripsInTheWafer, isNoisyWafer);
2721 }

◆ getOverlapStripList()

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

Definition at line 2812 of file SCTCalib.cxx.

2812  {
2813  std::set<Identifier> stripList;
2814  std::set<Identifier>::const_iterator stripAllItrLast = stripAllIdList.end();
2815  std::set<Identifier>::const_iterator stripRefItrLast = stripRefIdList.end();
2816 
2817  std::set<Identifier>::const_iterator stripAllItr = stripAllIdList.begin();
2818  for ( ; stripAllItr != stripAllItrLast; ++stripAllItr ) {
2819  std::set<Identifier>::const_iterator stripRefItr = stripRefIdList.begin();
2820  bool old = false;
2821  for ( ; stripRefItr != stripRefItrLast; ++stripRefItr ) {
2822  if (*stripAllItr == *stripRefItr) old = true;
2823  }
2824  if (!old) {
2825  stripList.insert(*stripAllItr);
2826  }
2827  }
2828  return stripList;
2829 }

◆ getStripList()

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

Definition at line 2833 of file SCTCalib.cxx.

2833  {
2834  std::string strList;
2835  if (!stripIdList.empty()) {
2836  int firstStrip{-1};
2837  int groupSize{-1};
2838 
2839  std::set<Identifier>::const_iterator stripItrFirst{stripIdList.begin()};
2840  std::set<Identifier>::const_iterator stripItrLast{--stripIdList.end()};
2841 
2842  std::set<Identifier>::const_iterator stripItr{stripIdList.begin()};
2843  std::set<Identifier>::const_iterator stripItrE{stripIdList.end()};
2844  for (; stripItr != stripItrE; ++stripItr) {
2845  Identifier stripId{*stripItr};
2846  int stripNum{m_pSCTHelper->side(stripId)*nbins + m_pSCTHelper->strip(stripId)};
2847  if (stripItr == stripItrFirst) {
2848  firstStrip = stripNum;
2849  groupSize = 1;
2850  } else {
2851  if (stripNum == firstStrip + groupSize) {
2852  ++groupSize;
2853  } else {
2854  int stripBegin{firstStrip};
2855  int stripEnd{firstStrip + groupSize -1};
2856  strList = m_pCalibWriteTool->addDefect(strList, stripBegin, stripEnd);
2857  firstStrip = stripNum;
2858  groupSize = 1;
2859  }
2860  }
2861  if (stripItr == stripItrLast) {
2862  int stripBegin{firstStrip};
2863  int stripEnd{stripNum};
2864  strList = m_pCalibWriteTool->addDefect(strList, stripBegin, stripEnd);
2865  }
2866  }
2867  }
2868  return strList;
2869 }

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

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

◆ noisyStripsToXml()

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

Definition at line 2873 of file SCTCalib.cxx.

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

◆ 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,
IOVTime  start,
IOVTime  end 
) const
private

Definition at line 2437 of file SCTCalib.cxx.

2437  {
2438  if (!strcmp(type, "DeadStrip")) {
2439  file.open(m_deadStripsFile.value().c_str(), std::ios::out);
2440  if (!file.good()) return StatusCode::FAILURE;
2441  file << "<channels server=\"ATLAS_COOLPROD\" schema=\"ATLAS_COOLOFL_SCT\" dbname=\"MONP200\" folder=\"SCT/Derived/DeadStrips\" ";
2442  } else if (!strcmp(type, "DeadChip")) {
2443  file.open(m_deadChipsFile.value().c_str(), std::ios::out);
2444  if (!file.good()) return StatusCode::FAILURE;
2445  file << "<channels server=\"ATLAS_COOLPROD\" schema=\"ATLAS_COOLOFL_SCT\" dbname=\"MONP200\" folder=\"SCT/Derived/DeadChips\" ";
2446  } else {
2447  ATH_MSG_ERROR("in openXML4DB : argument \"type\" needs to be (DeadStrip, DeadChip).");
2448  return StatusCode::FAILURE;
2449  }
2450  file << "since=\"" << start.re_time() << "\" "
2451  << "until=\"" << end.re_time() << "\" "
2452  << "tag=\"" << tag << "\" "
2453  << "version=\"" << "multi\">" << linefeed;
2454  return StatusCode::SUCCESS;
2455 }

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

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

◆ openXML4MonSummary()

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

Definition at line 2545 of file SCTCalib.cxx.

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

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

2577  {
2578  file << list.str();
2579  if (!strcmp(type, "DEAD")) {
2580  file << " </modules>" << std::endl;
2581  } else if (!strcmp(type, "NoiseOccupancy") or !strcmp(type, "RawOccupancy") or !strcmp(type, "Efficiency") or !strcmp(type, "BSErrors") or !strcmp(type, "LorentzAngle")) {
2582  file << " </data>" << std::endl;
2583  }
2584  file << "</run>" << std::endl;
2585 
2586  if (file.is_open()) {
2587  file.close();
2588  return StatusCode::SUCCESS;
2589  } else {
2590  return StatusCode::FAILURE;
2591  }
2592 }

◆ xmlChannelEfficiencyDataString()

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

Definition at line 2663 of file SCTCalib.cxx.

2663  {
2664  std::ostringstream os;
2665  os << " <module>" << std::endl
2666  << " " << xmlValue("SN", serial.str()) << std::endl
2667  << " " << xmlValue("SampleSize", "10000") << std::endl
2668  << " " << xmlValue("barrel_endcap", m_pSCTHelper->barrel_ec(waferId)) << std::endl
2669  << " " << xmlValue("Layer", m_pSCTHelper->layer_disk(waferId)) << linefeed
2670  << " " << xmlValue("Eta", m_pSCTHelper->eta_module(waferId)) << std::endl
2671  << " " << xmlValue("Phi", m_pSCTHelper->phi_module(waferId)) << std::endl
2672  << " " << xmlValue("Efficiency", efficiency) << std::endl
2673  << " " << xmlValue("Side", side )<<std::endl
2674  << " </module>";
2675  return os.str();
2676 }

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

2680  {
2681  std::ostringstream os;
2682  os << " <chip>" << std::endl
2683  << " " << xmlValue("SN", serial.str()) << std::endl
2684  << " " << xmlValue("SampleSize", "10000") << std::endl
2685  << " " << xmlValue("barrel_endcap", m_pSCTHelper->barrel_ec(waferId)) << std::endl
2686  << " " << xmlValue("Layer", m_pSCTHelper->layer_disk(waferId)) << linefeed
2687  << " " << xmlValue("Eta", m_pSCTHelper->eta_module(waferId)) << std::endl
2688  << " " << xmlValue("Phi", m_pSCTHelper->phi_module(waferId)) << std::endl
2689  << " " << xmlValue("Side", side )<<std::endl
2690  << " " << xmlValue("Chip", chip )<<std::endl
2691  << " " << xmlValue("Efficiency", efficiency) << std::endl
2692  << " " << xmlValue("Efficiency_bcid", efficiency_bcid) << std::endl
2693  << " </chip>";
2694  return os.str();
2695 }

◆ xmlChannelNoiseOccDataString()

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

Definition at line 2647 of file SCTCalib.cxx.

2647  {
2648  std::ostringstream os;
2649  os << xmlOpenChannel(waferId.get_identifier32().get_compact(), m_iovStart.re_time(), m_iovStop.re_time()) << std::endl
2650  << " " << xmlValue("SN", serial.str()) << std::endl
2651  << " " << xmlValue("SampleSize", "10000") << std::endl
2652  << " " << xmlValue("barrel_endcap", m_pSCTHelper->barrel_ec(waferId)) << std::endl
2653  << " " << xmlValue("Layer", m_pSCTHelper->layer_disk(waferId)) << linefeed
2654  << " " << xmlValue("Eta", m_pSCTHelper->eta_module(waferId)) << std::endl
2655  << " " << xmlValue("Phi", m_pSCTHelper->phi_module(waferId)) << std::endl
2656  << " " << xmlValue("NoiseOccupancy", occupancy) << std::endl
2657  << " " << xmlCloseChannel();
2658  return os.str();
2659 }

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
histCollection
Definition: LArQuickHistMerge.cxx:56
SCT_CalibAlgs::chipList2LinkList
std::string chipList2LinkList(const std::string &chipList)
Definition: SCT_CalibUtilities.cxx:47
SCTCalib::firstBSErrorType
@ firstBSErrorType
Definition: SCTCalib.h:92
SCTCalib::n_phiBinsEC
@ n_phiBinsEC
Definition: SCTCalib.h:85
SCTCalib::first_etaBin
@ first_etaBin
Definition: SCTCalib.h:80
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
SCTCalib::n_etaBins
@ n_etaBins
Definition: SCTCalib.h:80
SCTCalib::m_efficiencyMinStat
UnsignedIntegerProperty m_efficiencyMinStat
Definition: SCTCalib.h:203
SCTCalib::last_barrel
@ last_barrel
Definition: SCTCalib.h:82
SCTCalib::n_chipPerSide
@ n_chipPerSide
Definition: SCTCalib.h:89
SCTCalib::n_phiBinsECOuter
@ n_phiBinsECOuter
Definition: SCTCalib.h:91
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
SCTCalib::m_iovStop
IOVTime m_iovStop
Definition: SCTCalib.h:244
max
#define max(a, b)
Definition: cfImp.cxx:41
SCTCalib::m_deadStripUploadTest
BooleanProperty m_deadStripUploadTest
Definition: SCTCalib.h:195
SCTCalib::m_doHitMapsLB
BooleanProperty m_doHitMapsLB
Definition: SCTCalib.h:146
SCTCalib::n_elements
@ n_elements
Definition: SCTCalib.h:91
SCTCalib::m_eventNumber
IntegerProperty m_eventNumber
Definition: SCTCalib.h:129
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::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
SCTCalib::m_nLbsMerged
IntegerProperty m_nLbsMerged
Definition: SCTCalib.h:147
plotmaker.hist
hist
Definition: plotmaker.py:148
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:648
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::first_phiBin
@ first_phiBin
Definition: SCTCalib.h:81
SCTCalib::m_noisyWaferThrBarrel
FloatProperty m_noisyWaferThrBarrel
Definition: SCTCalib.h:179
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_hitBins
@ n_hitBins
Definition: SCTCalib.h:79
SCTCalib::n_chipPerModule
@ n_chipPerModule
Definition: SCTCalib.h:89
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::last_hitBin
@ last_hitBin
Definition: SCTCalib.h:79
SCTCalib::m_calibBsErrTool
ToolHandle< ISCT_CalibHistoTool > m_calibBsErrTool
Definition: SCTCalib.h:105
SCTCalib::lastBSErrorType
@ lastBSErrorType
Definition: SCTCalib.h:92
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_phiBinsECShort
@ n_phiBinsECShort
Definition: SCTCalib.h:91
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
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
TRT::Hit::side
@ side
Definition: HitInfo.h:83
SCTCalib::n_disks
@ n_disks
Definition: SCTCalib.h:83
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::last_disk
@ last_disk
Definition: SCTCalib.h:83
SCTCalib::m_numberOfEventsHist
unsigned long long m_numberOfEventsHist
Definition: SCTCalib.h:239
SCTCalib::m_noisyStripAverageInDB
FloatProperty m_noisyStripAverageInDB
Definition: SCTCalib.h:166
SCTCalib::m_noisyModuleList
IntegerProperty m_noisyModuleList
Definition: SCTCalib.h:167
SCTCalib::n_phiBinsB2
@ n_phiBinsB2
Definition: SCTCalib.h:90
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
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::ntimeBins
@ ntimeBins
Definition: SCTCalib.h:78
SCTCalib::m_deadSummaryFile
StringProperty m_deadSummaryFile
Definition: SCTCalib.h:223
SCTCalib::n_barrels
@ n_barrels
Definition: SCTCalib.h:82
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
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::first_etaBinEC
@ first_etaBinEC
Definition: SCTCalib.h:84
SCTCalib::m_useCalibration
BooleanProperty m_useCalibration
Definition: SCTCalib.h:136
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::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::getLBList
std::string getLBList(const std::set< int > &LBList) const
Definition: SCTCalib.cxx:3230
SCTCalib::m_readHIST
bool m_readHIST
Definition: SCTCalib.h:248
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
SCTCalib::first_hitBin
@ first_hitBin
Definition: SCTCalib.h:79
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
SCTCalib::n_etaInBarrel
@ n_etaInBarrel
Definition: SCTCalib.h:89
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::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
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
SCTCalib::m_ReadCalibDataTool
ToolHandle< ISCT_ReadCalibDataTool > m_ReadCalibDataTool
Definition: SCTCalib.h:100
SCTCalib::m_MajorityConditionsTool
ToolHandle< ISCT_DetectorLevelConditionsTool > m_MajorityConditionsTool
Definition: SCTCalib.h:101
perfmonmt-printer.required
required
Definition: perfmonmt-printer.py:184
SCTCalib::last_phiBin
@ last_phiBin
Definition: SCTCalib.h:81
min
#define min(a, b)
Definition: cfImp.cxx:40
SCTCalib::lastStrip
@ lastStrip
Definition: SCTCalib.h:77
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::firstStrip
@ firstStrip
Definition: SCTCalib.h:77
SCTCalib::m_pCalibWriteTool
ToolHandle< SCTCalibWriteTool > m_pCalibWriteTool
Definition: SCTCalib.h:98
SCT_CalibAlgs::xmlCloseChannel
std::string xmlCloseChannel()
Definition: SCT_CalibUtilities.cxx:65
SCTCalib::first_phiBinEC
@ first_phiBinEC
Definition: SCTCalib.h:85
SCTCalib::m_calibLbTool
ToolHandle< ISCT_CalibHistoTool > m_calibLbTool
Definition: SCTCalib.h:104
SCTCalib::n_phiBinsB0
@ n_phiBinsB0
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:195
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
SCTCalib::getStripList
std::string getStripList(const std::set< Identifier > &stripIdList) const
Definition: SCTCalib.cxx:2833
SCT_CalibAlgs::normalizeList
std::string normalizeList(std::string s)
Definition: SCT_CalibUtilities.cxx:21
SCTCalib::last_etaBinEC
@ last_etaBinEC
Definition: SCTCalib.h:84
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:3144
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
SCTCalib::n_phiBinsECMiddle
@ n_phiBinsECMiddle
Definition: SCTCalib.h:91
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
SCTCalib::m_doHitMaps
BooleanProperty m_doHitMaps
Definition: SCTCalib.h:145
SCTCalib::n_etaBinsEC
@ n_etaBinsEC
Definition: SCTCalib.h:84
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:3189
SCTCalib::n_phiBinsB3
@ n_phiBinsB3
Definition: SCTCalib.h:90
xAOD::timeStamp
setEventNumber timeStamp
Definition: EventInfo_v1.cxx:128
SCTCalib::getNumNoisyStrips
std::pair< int, bool > getNumNoisyStrips(const Identifier &waferId) const
Definition: SCTCalib.cxx:2698
SCTCalib::m_doBSErrors
BooleanProperty m_doBSErrors
Definition: SCTCalib.h:149
SCTCalib::n_phiBinsB1
@ n_phiBinsB1
Definition: SCTCalib.h:90
SCTCalib::m_utcBegin
std::string m_utcBegin
Definition: SCTCalib.h:240
SCTCalib::first_barrel
@ first_barrel
Definition: SCTCalib.h:82
python.PyAthena.v
v
Definition: PyAthena.py:157
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::firstTimeBin
@ firstTimeBin
Definition: SCTCalib.h:78
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
SCTCalib::lastTimeBin
@ lastTimeBin
Definition: SCTCalib.h:78
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
SCTCalib::last_etaBin
@ last_etaBin
Definition: SCTCalib.h:80
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:616
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
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
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:652
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:790
SCTCalib::n_stripPerChip
@ n_stripPerChip
Definition: SCTCalib.h:89
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
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
InDetConditions::SCT_STRIP
@ SCT_STRIP
Definition: InDetHierarchy.h:14
SCTCalib::first_disk
@ first_disk
Definition: SCTCalib.h:83
SCTCalib::getOverlapStripList
std::set< Identifier > getOverlapStripList(const std::set< Identifier > &stripAllIdList, const std::set< Identifier > &stripRefIdList) const
Definition: SCTCalib.cxx:2812
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
SCTCalib::n_phiBins
@ n_phiBins
Definition: SCTCalib.h:81
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
SCTCalib::m_CablingTool
ToolHandle< ISCT_CablingTool > m_CablingTool
Definition: SCTCalib.h:102
SCTCalib::n_BSErrorType
@ n_BSErrorType
Definition: SCTCalib.h:92
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
readCCLHist.float
float
Definition: readCCLHist.py:83
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
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
ServiceHandle< ICondSvc >
SCTCalib::nbins
@ nbins
Definition: SCTCalib.h:77
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
Generated on Thu Jul 4 2024 21:57:49 for ATLAS Offline Software by   doxygen 1.8.18