ATLAS Offline Software
Loading...
Searching...
No Matches
TileDCSCondAlg Class Reference

Condition algorithm to prepare TileDCSState object and put it into condition store. More...

#include <TileDCSCondAlg.h>

Inheritance diagram for TileDCSCondAlg:
Collaboration diagram for TileDCSCondAlg:

Public Member Functions

 TileDCSCondAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual ~TileDCSCondAlg ()=default
virtual StatusCode initialize () override
virtual StatusCode execute (const EventContext &ctx) const override
virtual StatusCode finalize () override
virtual bool isReEntrant () const override
 Avoid scheduling algorithm multiple times.
virtual StatusCode sysInitialize () override
 Override sysInitialize.
virtual bool isClonable () const override
 Specify if the algorithm is clonable.
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
virtual bool filterPassed (const EventContext &ctx) const
 Get filter decision:
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 Set filter decision:
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.

Private Types

enum  TileModuleType { LONG_BARREL = 0 , EXTENDED_BARREL = 1 , EXTENDED_BARREL_NO_D4 = 2 , EXTENDED_BARREL_SPECIAL_C10 = 3 }
enum  TileLimits { NUMBER_OF_CHANNELS = 48 , NUMBER_OF_HVSET_CHANNELS = 68 , NUMBER_OF_MODULE_TYPES = 2 , NUMBER_OF_SPECIAL_MODULE_TYPES = 4 }
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

int readConfig (const std::string &fileName, const std::string &subStr, std::vector< std::pair< int, int > > &rosDrawer)
 Read mapping of DB COOL channels into Tile ROS and drawer pairs.
int readBadHV (const std::string &fileName)
 Read special deltas for few unstable PMTs.
StatusCode fillReferenceHV (TileDCSState &dcsState, SG::WriteCondHandle< TileDCSState > &wh, const EventContext &ctx) const
 Store reference HV from Tile CES or Laser DB folder in TileDCSState.
unsigned int getChannelKey (unsigned int ros, unsigned int drawer, unsigned int channel) const
 @ brief Return Tile channel key used as index in internal caches @ ros Tile ROS in range [1..4] @ drawer Tile drawer number in range [0..63] @ channel Tile channel number
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

SG::ReadCondHandleKey< CondAttrListCollection > m_hvKey
 The Tile DCS HV COOL folder name.
SG::ReadCondHandleKey< CondAttrListCollection > m_hvSetKey
 The Tile DCS HVSET COOL folder name.
SG::ReadCondHandleKey< CondAttrListCollection > m_statesKey
 The Tile DCS STATES COOL folder name.
SG::WriteCondHandleKey< TileDCSState > m_dcsStateKey
 The name of TileDCSState object to produce and put into condition store.
SG::ReadCondHandleKey< TileEMScale > m_emScaleKey
 The name of TileEMScale object to get reference HV from Cesium or Laser folder.
Gaudi::Property< bool > m_readHV
 Flag to control reading Tile DCS HV folder from DB.
Gaudi::Property< bool > m_readHVSet
 Flag to control reading Tile DCS HVSET folder from DB.
Gaudi::Property< bool > m_readStates
 Flag to control reading Tile DCS STATES folder from DB.
Gaudi::Property< float > m_goodHVLimit
 Tile DCS Status is OK if difference between measured and requested HV is below this limit.
Gaudi::Property< float > m_warningHVLimit
 Mask channels with difference between measured and requested HV above this limit.
Gaudi::Property< int > m_goodDrawer
 Status is OK if Tile DCS drawer states is like this.
Gaudi::Property< std::vector< int > > m_warningDrawer
 Status is WARNING if Tile DCS drawer states is like this.
Gaudi::Property< std::string > m_dcsChHvInCool
 File name with mapping Tile DCS HV DB COOL channels to ROS and drawer.
Gaudi::Property< std::string > m_dcsChHvSetInCool
 File name with mapping Tile DCS HVSET DB COOL channels to ROS and drawer.
Gaudi::Property< std::string > m_dcsChStatesInCool
 File name with mapping Tile DCS STATES DB COOL channels to ROS and drawer.
ServiceHandle< TileCablingSvc > m_cablingSvc
 Name of Tile cabling service.
const TileCablingService * m_cabling {nullptr}
std::vector< std::pair< int, int > > m_rosDrawerHV
std::vector< std::pair< int, int > > m_rosDrawerHVSet
std::vector< std::pair< int, int > > m_rosDrawerStates
std::map< int, std::pair< float, float > > m_knownBadHV
int m_channel2pmt [2][NUMBER_OF_HVSET_CHANNELS] = {}
int m_pmt2channel [2][NUMBER_OF_HVSET_CHANNELS] = {}
bool m_isChannelUsed [4][NUMBER_OF_CHANNELS] = {}
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Condition algorithm to prepare TileDCSState object and put it into condition store.

This condition algorithm reads information from Tile DCS DB. Reference HV can be get from Tile calibration Cesium or Laser DB folder (by default) instead of from Tile DCS DB. In this case reference HV is used from Laser folder if it is not negative otherwise reference HV is used from Cesium folder. Using this information the algorithm prepares TileDCSState condition object and put it into condition store.

Definition at line 33 of file TileDCSCondAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 376 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ TileLimits

Enumerator
NUMBER_OF_CHANNELS 
NUMBER_OF_HVSET_CHANNELS 
NUMBER_OF_MODULE_TYPES 
NUMBER_OF_SPECIAL_MODULE_TYPES 

Definition at line 51 of file TileDCSCondAlg.h.

51 {
54 NUMBER_OF_MODULE_TYPES = 2, // LB, EB
55 NUMBER_OF_SPECIAL_MODULE_TYPES = 4 // // LB, EB, EB without D4, EB with special C10
56 };

◆ TileModuleType

Enumerator
LONG_BARREL 
EXTENDED_BARREL 
EXTENDED_BARREL_NO_D4 
EXTENDED_BARREL_SPECIAL_C10 

Definition at line 45 of file TileDCSCondAlg.h.

45 {LONG_BARREL = 0, // LB
46 EXTENDED_BARREL = 1, // EB
47 EXTENDED_BARREL_NO_D4 = 2, // EB without D4: EBA15, EBC18
48 EXTENDED_BARREL_SPECIAL_C10 = 3 // EB with special C10
49 };

Constructor & Destructor Documentation

◆ TileDCSCondAlg()

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

Definition at line 22 of file TileDCSCondAlg.cxx.

22 :
23 AthCondAlgorithm(name, pSvcLocator)
24{
25}

◆ ~TileDCSCondAlg()

virtual TileDCSCondAlg::~TileDCSCondAlg ( )
virtualdefault

Member Function Documentation

◆ declareGaudiProperty()

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

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

Definition at line 156 of file AthCommonDataStore.h.

158 {
160 hndl.value(),
161 hndl.documentation());
162
163 }
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
148 }
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

◆ evtStore()

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

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

Definition at line 85 of file AthCommonDataStore.h.

◆ execute()

StatusCode TileDCSCondAlg::execute ( const EventContext & ctx) const
overridevirtual

Definition at line 109 of file TileDCSCondAlg.cxx.

109 {
110
111 SG::WriteCondHandle<TileDCSState> dcsState{m_dcsStateKey, ctx};
112
113 if (dcsState.isValid()) {
114 ATH_MSG_DEBUG("Found valid TileDCSState: " << dcsState.key());
115 return StatusCode::SUCCESS;
116 }
117
118 std::unique_ptr<TileDCSState> dcsStateData = std::make_unique<TileDCSState>();
119 dcsStateData->setGoodDrawer(m_goodDrawer.value());
120 dcsStateData->setWarningDrawer(m_warningDrawer.value());
121
122 if (m_readHV) {
123
124 SG::ReadCondHandle<CondAttrListCollection> hv(m_hvKey, ctx);
125 dcsState.addDependency(hv);
126 for (const CondAttrListCollection::ChanAttrListPair& chanAttrListPair : **hv) {
127
128 const CondAttrListCollection::ChanNum coolChannel = chanAttrListPair.first;
129
130 const std::pair<int, int> rosDrawerPair = m_rosDrawerHV.at(coolChannel);
131 unsigned int ros = rosDrawerPair.first;
132 unsigned int drawer = rosDrawerPair.second;
133
134 ATH_MSG_VERBOSE( "ros: " << ros
135 << ", drawer: " << drawer
136 << ", COOL channel: " << coolChannel
137 << ", payload: " << chanAttrListPair.second);
138
139 int moduleType = (ros > 2) ? EXTENDED_BARREL : LONG_BARREL;
140 int pmt0 = 0; // runs over paylod parameters
141 for (const coral::Attribute& attribute : chanAttrListPair.second) {
142 int channel = m_pmt2channel[moduleType][pmt0];
143 dcsStateData->setChannelHV(ros, drawer, channel, attribute.data<float>());
144 ATH_MSG_VERBOSE( "HV[" << pmt0 << "] = " << attribute.data<float>() );
145 ++pmt0;
146 }
147
148 }
149 }
150
151
152 if (m_readHVSet) {
153
154 SG::ReadCondHandle<CondAttrListCollection> hvSet(m_hvSetKey, ctx);
155 dcsState.addDependency(hvSet);
156 for (const CondAttrListCollection::ChanAttrListPair& chanAttrListPair : **hvSet) {
157
158 const CondAttrListCollection::ChanNum coolChannel = chanAttrListPair.first;
159
160 const std::pair<int, int> rosDrawerPair = m_rosDrawerHVSet.at(coolChannel);
161 unsigned int ros = rosDrawerPair.first;
162 unsigned int drawer = rosDrawerPair.second;
163
164 ATH_MSG_VERBOSE( "ros: " << ros
165 << ", drawer: " << drawer
166 << ", COOL channel: " << coolChannel
167 << ", payload: " << chanAttrListPair.second);
168
169 int moduleType = (ros > 2) ? EXTENDED_BARREL : LONG_BARREL;
170 int pmt0 = 0; // runs over paylod parameters
171 for (const coral::Attribute& attribute : chanAttrListPair.second) {
172 int channel = m_pmt2channel[moduleType][pmt0];
173 dcsStateData->setChannelHVSet(ros, drawer, channel, attribute.data<float>());
174 ATH_MSG_VERBOSE( "HVSET[" << pmt0 << "] = " << attribute.data<float>() );
175 ++pmt0;
176 }
177
178 }
179 } else {
180 ATH_CHECK( fillReferenceHV(*dcsStateData, dcsState, ctx) );
181
182 }
183
184
185 if (m_readStates) {
186
187 SG::ReadCondHandle<CondAttrListCollection> states(m_statesKey, ctx);
188 dcsState.addDependency(states);
189 for (const CondAttrListCollection::ChanAttrListPair& chanAttrListPair : **states) {
190
191 CondAttrListCollection::ChanNum coolChannel = chanAttrListPair.first;
192
193 std::pair<int, int> rosDrawerPair = m_rosDrawerStates.at(coolChannel);
194 unsigned int ros = rosDrawerPair.first;
195 unsigned int drawer = rosDrawerPair.second;
196
197 ATH_MSG_VERBOSE( "ros: " << ros
198 << ", drawer: " << drawer
199 << ", COOL channel: " << coolChannel
200 << ", payload: " << chanAttrListPair.second);
201
202 for (const coral::Attribute& attribute : chanAttrListPair.second) {
203 dcsStateData->setDrawerStates(ros, drawer, attribute.data<int>());
204 ATH_MSG_VERBOSE( "STATES = " << attribute.data<int>() );
205 }
206
207 }
208 }
209
210
211 for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
212 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
213
214 TileDCSState::TileDCSStatus drawerStatus = dcsStateData->getDCSStatus(ros, drawer);
215
216 int moduleType = (ros > 2) ? EXTENDED_BARREL : LONG_BARREL;
217 int specialModuleType(moduleType);
218 if (moduleType == EXTENDED_BARREL) {
219 if ((ros == 3 && drawer == 14) || (ros == 4 && drawer == 17)) {
220 specialModuleType = EXTENDED_BARREL_NO_D4; // EBA15 EBC18
221 } else if (!m_cabling->C10_connected(drawer)) {
222 specialModuleType = EXTENDED_BARREL_SPECIAL_C10; // EB modules with special C10
223 }
224 }
225
226 for (unsigned int channel = 0; channel < TileCalibUtils::MAX_CHAN; ++channel) {
227 if (m_isChannelUsed[specialModuleType][channel]) {
228
230
231 float hvSet(dcsStateData->getChannelHVSet(ros, drawer, channel));
232 float hv(dcsStateData->getChannelHV(ros, drawer, channel));
233
234 // ignore zero "set" and negative "measured" HV, set status to unknown
235 if (hvSet >= 1.0 && hv >= 0.0 // HV can't be negative
236 && hvSet < 999.9 && hv < 999.9) { // HV can't be greater 930V
237
238 std::map<int, std::pair<float, float>>::const_iterator itr =
239 m_knownBadHV.find(getChannelKey(ros, drawer, channel));
240
241 if (itr != m_knownBadHV.end()) { // known unstable PMTs
242
243 float hvGap = (m_readHVSet) ? // take into account offset if HVSET is used
244 std::fabs(hvSet + itr->second.second - hv) : std::fabs(hvSet - hv);
245
246 if (hvGap <= m_goodHVLimit) channelHVStatus = TileDCSState::OK_KNOWNBADPMT;
247 else if (hvGap <= m_warningHVLimit) channelHVStatus = TileDCSState::WARNING_KNOWNBADPMT;
248 else channelHVStatus = TileDCSState::ALERT_KNOWNBADPMT;
249 } else {
250 float hvGap = std::fabs(hvSet - hv);
251 if (hvGap <= m_goodHVLimit) channelHVStatus = TileDCSState::OK;
252 else if (hvGap <= m_warningHVLimit) channelHVStatus = TileDCSState::WARNING;
253 else channelHVStatus = TileDCSState::ALERT;
254 }
255
256 }
257
258 dcsStateData->setDCSHVStatus(ros, drawer, channel, channelHVStatus);
259
260 if (drawerStatus > TileDCSState::OK && !m_readHVSet) {
261 dcsStateData->setDCSStatus(ros, drawer, channel, drawerStatus);
262 } else {
263 dcsStateData->setDCSStatus(ros, drawer, channel, std::max(drawerStatus, channelHVStatus));
264 }
265
266 } else {
267 dcsStateData->setDCSHVStatus(ros, drawer, channel, TileDCSState::NON_EXISTING);
268 dcsStateData->setDCSStatus(ros, drawer, channel, TileDCSState::NON_EXISTING);
269 }
270 }
271
272
273 if (msgLvl(MSG::VERBOSE)) {
274 msg(MSG::VERBOSE) << "Module = " << TileCalibUtils::getDrawerString(ros, drawer)
275 << " Status = " << drawerStatus << endmsg;
276
277 std::string ignored = ((drawerStatus > TileDCSState::OK && !m_readHVSet) ? " ignored" : "");
278
279 for (unsigned int channel = 0; channel < TileCalibUtils::MAX_CHAN; ++channel) {
280 int pmt0 = m_channel2pmt[moduleType][channel];
281 TileDCSState::TileDCSStatus status = dcsStateData->getDCSHVStatus(ros, drawer, channel);
282 msg(MSG::VERBOSE) << "Module = " << TileCalibUtils::getDrawerString(ros, drawer)
283 << " channel = " << channel
284 << " pmt = " << pmt0 + 1
285 << " HV = " << dcsStateData->getChannelHV(ros, drawer, channel)
286 << " HVSET = " << dcsStateData->getChannelHVSet(ros, drawer, channel)
287 << " Status = " << status
288 << ignored << endmsg;
289 }
290 }
291
292 }
293 }
294
295 // Define validity of the output cond object
296 if(dcsState.record(std::move(dcsStateData)).isFailure()) {
297
298 ATH_MSG_ERROR("Could not record TileDCSState object with "
299 << dcsState.key()
300 << " with EventRange " << dcsState.getRange()
301 << " into Conditions Store");
302
303 return StatusCode::FAILURE;
304 } else {
305
306 ATH_MSG_VERBOSE("Recorded TileDCSState object with "
307 << dcsState.key()
308 << " with EventRange " << dcsState.getRange()
309 << " into Conditions Store");
310 }
311
312 return StatusCode::SUCCESS;
313
314}
#define endmsg
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_DEBUG(x,...)
#define ATH_MSG_ERROR(x,...)
#define ATH_MSG_VERBOSE(x,...)
bool msgLvl(const MSG::Level lvl) const
ChanAttrListMap::value_type ChanAttrListPair
const std::string & key() const
void addDependency(const EventIDRange &range)
const EventIDRange & getRange() const
StatusCode record(const EventIDRange &range, T *t)
record handle, with explicit range DEPRECATED
static const unsigned int MAX_ROS
Number of ROSs.
static std::string getDrawerString(unsigned int ros, unsigned int drawer)
Return the drawer name, e.g.
static const unsigned int MAX_DRAWER
Number of drawers in ROS 1-4.
static const unsigned int MAX_CHAN
Number of channels in drawer.
unsigned int getChannelKey(unsigned int ros, unsigned int drawer, unsigned int channel) const
@ brief Return Tile channel key used as index in internal caches @ ros Tile ROS in range [1....
bool m_isChannelUsed[4][NUMBER_OF_CHANNELS]
std::map< int, std::pair< float, float > > m_knownBadHV
SG::WriteCondHandleKey< TileDCSState > m_dcsStateKey
The name of TileDCSState object to produce and put into condition store.
std::vector< std::pair< int, int > > m_rosDrawerHV
int m_pmt2channel[2][NUMBER_OF_HVSET_CHANNELS]
Gaudi::Property< float > m_goodHVLimit
Tile DCS Status is OK if difference between measured and requested HV is below this limit.
Gaudi::Property< bool > m_readHVSet
Flag to control reading Tile DCS HVSET folder from DB.
std::vector< std::pair< int, int > > m_rosDrawerStates
Gaudi::Property< float > m_warningHVLimit
Mask channels with difference between measured and requested HV above this limit.
SG::ReadCondHandleKey< CondAttrListCollection > m_hvSetKey
The Tile DCS HVSET COOL folder name.
Gaudi::Property< std::vector< int > > m_warningDrawer
Status is WARNING if Tile DCS drawer states is like this.
Gaudi::Property< int > m_goodDrawer
Status is OK if Tile DCS drawer states is like this.
SG::ReadCondHandleKey< CondAttrListCollection > m_hvKey
The Tile DCS HV COOL folder name.
const TileCablingService * m_cabling
int m_channel2pmt[2][NUMBER_OF_HVSET_CHANNELS]
Gaudi::Property< bool > m_readHV
Flag to control reading Tile DCS HV folder from DB.
SG::ReadCondHandleKey< CondAttrListCollection > m_statesKey
The Tile DCS STATES COOL folder name.
std::vector< std::pair< int, int > > m_rosDrawerHVSet
Gaudi::Property< bool > m_readStates
Flag to control reading Tile DCS STATES folder from DB.
StatusCode fillReferenceHV(TileDCSState &dcsState, SG::WriteCondHandle< TileDCSState > &wh, const EventContext &ctx) const
Store reference HV from Tile CES or Laser DB folder in TileDCSState.
TileDCSStatus
Describes Tile DCS status.
status
Definition merge.py:16

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.cxx.

54{
55 // If we didn't find any symlinks to add, just return the collection
56 // from the base class. Otherwise, return the extended collection.
57 if (!m_extendedExtraObjects.empty()) {
59 }
61}
Common base class for algorithms.

◆ fillReferenceHV()

StatusCode TileDCSCondAlg::fillReferenceHV ( TileDCSState & dcsState,
SG::WriteCondHandle< TileDCSState > & wh,
const EventContext & ctx ) const
private

Store reference HV from Tile CES or Laser DB folder in TileDCSState.

Parameters
[out]dcsStateTileDCSState to store reference HV
[out]eventRangeEvent range within which reference HV is valid

Definition at line 479 of file TileDCSCondAlg.cxx.

481 {
482
483 SG::ReadCondHandle<TileEMScale> emScale(m_emScaleKey, ctx);
484 wh.addDependency(emScale);
485
486 float laserReferenceHV = -5.;
487 float cesReferenceHV = -5.;
488
489 for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
490 int moduleType = (ros > 2) ? EXTENDED_BARREL : LONG_BARREL;
491
492 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
493 unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
494
495 for (unsigned int channel = 0; channel < TileCalibUtils::MAX_CHAN; ++channel) {
496 int pmt0 = m_channel2pmt[moduleType][channel];
497
498 cesReferenceHV = emScale->getCesiumReferenceHV(drawerIdx, channel);
499 laserReferenceHV = emScale->getLaserReferenceHV(drawerIdx, channel);
500
501 if (laserReferenceHV >= 0.) {
502 dcsState.setChannelHVSet(ros, drawer, channel, laserReferenceHV);
503 } else {
504 dcsState.setChannelHVSet(ros, drawer, channel, cesReferenceHV);
505 }
506
507 if (msgLvl(MSG::VERBOSE)) {
508 msg(MSG::VERBOSE) << "Module = " << TileCalibUtils::getDrawerString(ros, drawer)
509 << " channel = " << channel
510 << " pmt = " << pmt0 + 1
511 << " HVref = " << dcsState.getChannelHVSet(ros, drawer, channel);
512
513 if (laserReferenceHV >= 0.) {
514 msg(MSG::VERBOSE) << " Taken from Laser run (replace "
515 << cesReferenceHV << " cesium value)" << endmsg;
516 } else {
517 msg(MSG::VERBOSE) << endmsg;
518 }
519 }
520 }
521 }
522 }
523
524 return StatusCode::SUCCESS;
525}
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
SG::ReadCondHandleKey< TileEMScale > m_emScaleKey
The name of TileEMScale object to get reference HV from Cesium or Laser folder.
float getChannelHVSet(unsigned int ros, unsigned int drawer, unsigned int channel) const
Return requested HV reported by DCS for given Tile channel.
void setChannelHVSet(unsigned int ros, unsigned int drawer, unsigned int channel, float hvSet)
Store requested HV reported by DCS for given Tile channel.
str wh
Definition parseDir.py:45

◆ filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx) const
inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

93 {
94 return execState( ctx ).filterPassed();
95 }
virtual bool filterPassed(const EventContext &ctx) const
Get filter decision:

◆ finalize()

StatusCode TileDCSCondAlg::finalize ( )
overridevirtual

Definition at line 528 of file TileDCSCondAlg.cxx.

528 {
529 return StatusCode::SUCCESS;
530}

◆ getChannelKey()

unsigned int TileDCSCondAlg::getChannelKey ( unsigned int ros,
unsigned int drawer,
unsigned int channel ) const
inlineprivate

@ brief Return Tile channel key used as index in internal caches @ ros Tile ROS in range [1..4] @ drawer Tile drawer number in range [0..63] @ channel Tile channel number

Definition at line 214 of file TileDCSCondAlg.h.

214 {
215 return ( ((((ros - 1) << 6) | drawer) << 6) | channel );
216}

◆ initialize()

StatusCode TileDCSCondAlg::initialize ( )
overridevirtual

Definition at line 28 of file TileDCSCondAlg.cxx.

28 {
29
30 ATH_MSG_DEBUG( "In initialize()" );
31
32 ATH_CHECK( m_hvKey.initialize(m_readHV) );
33
34 ATH_CHECK( m_hvSetKey.initialize(m_readHVSet) );
35 ATH_CHECK( m_emScaleKey.initialize(!m_readHVSet) );
36
37 ATH_CHECK( m_statesKey.initialize(m_readStates) );
38
39
40 ATH_MSG_INFO( "Will read the following folders: "
41 << ((m_readHV) ? m_hvKey.key() : "") << " "
42 << ((m_readHVSet) ? m_hvSetKey.key() : "") << " "
43 << ((m_readStates) ? m_statesKey.key() : ""));
44
45 //=== get TileCablingSvc
46 ATH_CHECK( m_cablingSvc.retrieve() );
47
48 //=== cache pointers to cabling helpers
49 m_cabling = m_cablingSvc->cablingService();
50
51 if (!m_cabling) {
52 ATH_MSG_ERROR( "Pointer to TileCablingService is zero: " << m_cabling);
53 return StatusCode::FAILURE;
54 }
55
56 std::map<TileModuleType, unsigned int> roses{{LONG_BARREL, 2}, {EXTENDED_BARREL, 3}};
57
58 for (TileModuleType moduleType : {LONG_BARREL, EXTENDED_BARREL}) {
59
60 unsigned int ros = roses[moduleType];
61 unsigned int channel = 0;
62
64 int pmt = m_cabling->channel2hole(ros, channel);
65 m_isChannelUsed[moduleType][channel] = (pmt > 0); // positive pmt - means channel is connected
66
67 if (moduleType == EXTENDED_BARREL) {
70 }
71
72 pmt = std::abs(pmt);
73 m_channel2pmt[moduleType][channel] = pmt - 1;
74 m_pmt2channel[moduleType][pmt - 1] = channel; // note - pmt-1 is used as index
75 }
76
77 for (; channel < 68; ++channel) {
78 m_channel2pmt[moduleType][channel] = channel;
79 m_pmt2channel[moduleType][channel] = channel;
80 }
81
82 }
83
84 // description of EBA15 and EBC18 channel 0-3 do not exist, channel 18,19 used
91 // description of EB with special C10 - channel 4 (pmt 5) is not used
93
94 if (m_readHVSet) {
95 // read special deltas for few unstable PMTs
96 readBadHV("BadHVChannels.dat");
97 if (readConfig(m_dcsChHvSetInCool, "Drawer", m_rosDrawerHVSet)) return StatusCode::FAILURE;
98 }
99
100 if (readConfig(m_dcsChStatesInCool, "_LVPS_", m_rosDrawerStates)) return StatusCode::FAILURE;
101 if (readConfig(m_dcsChHvInCool, "Drawer", m_rosDrawerHV)) return StatusCode::FAILURE;
102
103 ATH_CHECK( m_dcsStateKey.initialize() );
104
105 return StatusCode::SUCCESS;
106}
#define ATH_MSG_INFO(x,...)
Gaudi::Property< std::string > m_dcsChHvInCool
File name with mapping Tile DCS HV DB COOL channels to ROS and drawer.
Gaudi::Property< std::string > m_dcsChHvSetInCool
File name with mapping Tile DCS HVSET DB COOL channels to ROS and drawer.
int readBadHV(const std::string &fileName)
Read special deltas for few unstable PMTs.
Gaudi::Property< std::string > m_dcsChStatesInCool
File name with mapping Tile DCS STATES DB COOL channels to ROS and drawer.
ServiceHandle< TileCablingSvc > m_cablingSvc
Name of Tile cabling service.
int readConfig(const std::string &fileName, const std::string &subStr, std::vector< std::pair< int, int > > &rosDrawer)
Read mapping of DB COOL channels into Tile ROS and drawer pairs.

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const
inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

68 {
69 return true;
70 }

◆ isReEntrant()

virtual bool AthCondAlgorithm::isReEntrant ( ) const
inlineoverridevirtualinherited

Avoid scheduling algorithm multiple times.

With multiple concurrent events, conditions objects often expire simultaneously for all slots. To avoid that the scheduler runs the CondAlg in each slot, we declare it as "non-reentrant". This ensures that the conditions objects are only created once.

In case a particular CondAlg should behave differently, it can override this method again and return true.

See also
ATEAM-836

Definition at line 39 of file AthCondAlgorithm.h.

39{ return false; }

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

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

◆ readBadHV()

int TileDCSCondAlg::readBadHV ( const std::string & fileName)
private

Read special deltas for few unstable PMTs.

Parameters
fileNamename of file with special deltas for few unstable PMTs
Returns
0 in the case of success

Definition at line 385 of file TileDCSCondAlg.cxx.

385 {
386
387 std::string fullFileName = PathResolver::find_file(fileName, "DATAPATH");
388 std::ifstream file(fullFileName.c_str());
389 if (!file.is_open()) {
390 ATH_MSG_WARNING( "Can't find " << fileName);
391 return 1;
392 } else {
393 ATH_MSG_DEBUG("Reading file " << fullFileName);
394 }
395
396 std::string partName[5] = { "AUX", "LBA", "LBC", "EBA", "EBC" };
397
398 unsigned int ros, module, pmt;
399 float delta, offset;
400 char ll[256];
401 std::string line;
402 size_t pos = 0;
403
404 while (true) {
405
406 file.getline(ll, sizeof(ll));
407
408 if (file.eof() || file.fail()) break;
409
410 line = std::string(ll);
411
412 for (ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
413 pos = line.find(partName[ros]);
414 if (pos != std::string::npos) break;
415 }
416 if (ros == TileCalibUtils::MAX_ROS) {
417 ATH_MSG_WARNING( "File " << fileName << " Partition name not found in " << line);
418 continue;
419 }
420
421 module = atoi(&line[pos + 3]);
422 if (module < 1 || module > TileCalibUtils::MAX_DRAWER) {
423 ATH_MSG_WARNING( "File " << fileName << " Wrong module number in " << line);
424 continue;
425 }
426
427 pos = line.find("PMT number");
428 if (pos == std::string::npos) {
429 ATH_MSG_WARNING( "File " << fileName << " Word 'PMT number' not found in " << line);
430 continue;
431 }
432
433 pmt = atoi(&line[pos + 10]);
434 if (pmt < 1 || pmt > TileCalibUtils::MAX_CHAN) {
435 ATH_MSG_WARNING( "File " << fileName << " Wrong pmt number in " << line);
436 continue;
437 }
438
439 pos = line.find("Step Value is");
440 if (pos == std::string::npos) {
441 ATH_MSG_WARNING( "File " << fileName << " Word 'Step Value is' not found in " << line);
442 continue;
443 }
444
445 delta = atof(&line[pos + 13]);
446 if (delta <= 0.0 || delta > 1000.0) {
447 ATH_MSG_WARNING( "File " << fileName << " Wrong delta number in " << line);
448 continue;
449 }
450
451 pos = line.find("Offset is:");
452 if (pos == std::string::npos) {
453 ATH_MSG_WARNING( "File " << fileName << " Word 'Offset is:' not found in " << line);
454 continue;
455 }
456
457 offset = atof(&line[pos + 10]);
458 if (offset < -1000.0 || offset > 1000.0) {
459 ATH_MSG_WARNING( "File " << fileName << " Wrong offset number in " << line);
460 continue;
461 }
462
463 ATH_MSG_WARNING( "Module = " << TileCalibUtils::getDrawerString(ros, module - 1)
464 << " pmt = " << pmt
465 << " delta = " << delta
466 << " offset = " << offset);
467
468 int moduleType = (ros > 2) ? EXTENDED_BARREL : LONG_BARREL;
469 int channel = m_pmt2channel[moduleType][pmt - 1];
470 m_knownBadHV[getChannelKey(ros, module - 1, channel)] = std::make_pair(delta, offset);
471
472 }
473
474 file.close();
475
476 return 0;
477}
#define ATH_MSG_WARNING(x,...)
static std::string find_file(const std::string &logical_file_name, const std::string &search_path)
double atof(std::string_view str)
Converts a string into a double / float.
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
long long ll
TFile * file

◆ readConfig()

int TileDCSCondAlg::readConfig ( const std::string & fileName,
const std::string & subStr,
std::vector< std::pair< int, int > > & rosDrawer )
private

Read mapping of DB COOL channels into Tile ROS and drawer pairs.

Parameters
fileNamename of file with mapping of COOL channels to Tile ROS and drawer pairs
subStrsub string to look for
[out]rosDrawervector of Tile ROS and drawer pairs indexed by COOL channel
Returns
0 in the case of success

Definition at line 319 of file TileDCSCondAlg.cxx.

321 {
322
323 std::string fullFileName = PathResolver::find_file(fileName, "DATAPATH");
324 std::ifstream file(fullFileName.c_str());
325 if (!file.is_open()) {
326 ATH_MSG_ERROR( "Can't find " << fileName);
327 return 2;
328 } else {
329 ATH_MSG_DEBUG( "Reading file " << fullFileName);
330 }
331
332 rosDrawer.resize(257, std::make_pair<int, int>(0xFFFF, 0xFFFF));
333
334 std::string compName[5] = { "XXX", "ATLTILLV01", "ATLTILLV02", "ATLTILLV00", "ATLTILLV03" };
335
336 unsigned int ind, ros, module;
337 std::string s, line;
338 size_t pos;
339
340 while (true) {
341
342 file >> s >> ind >> line;
343
344 if (file.eof() || file.fail()) break;
345 if (ind > 1000000) break;
346
347 for (ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
348 pos = line.find(compName[ros]);
349 if (pos != std::string::npos) break;
350 }
351
352 if (ros == TileCalibUtils::MAX_ROS) {
353 msg(MSG::WARNING) << "File " << fileName << " Wrong computer name in " << line << endmsg;
354 continue;
355 }
356
357 pos = line.find(subStr);
358 if (pos == std::string::npos) {
359 ATH_MSG_WARNING( "File " << fileName << " Word " << subStr << " not found in " << line);
360 continue;
361 }
362
363 module = atoi(&line[pos + subStr.size()]);
364 if (module < 1 || module > TileCalibUtils::MAX_DRAWER) {
365 ATH_MSG_WARNING( "File " << fileName << " Wrong module number in " << line);
366 continue;
367 }
368
369 ATH_MSG_VERBOSE("Module = " << TileCalibUtils::getDrawerString(ros, module - 1) << " ind = " << ind);
370
371 if (rosDrawer.size() <= ind) {
372 rosDrawer.resize(ind + 1, std::make_pair<int, int> (0xFFFF, 0xFFFF));
373 }
374
375 rosDrawer[ind] = std::make_pair<int, int>(ros, (module - 1));
376
377 }
378
379 file.close();
380
381 return 0;
382}

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

369 {
370 h.renounce();
372 }
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)

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

352 {
354 }

◆ setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state,
const EventContext & ctx ) const
inlinevirtualinherited

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

99 {
101 }
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Set filter decision:

◆ sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

41{
42 return BaseAlg::sysExecute (ctx);
43}

◆ sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in AthAnalysisAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

71 {
73
74 if (sc.isFailure()) {
75 return sc;
76 }
77
78 ServiceHandle<ICondSvc> cs("CondSvc",name());
79 for (auto h : outputHandles()) {
80 if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
81 // do this inside the loop so we don't create the CondSvc until needed
82 if ( cs.retrieve().isFailure() ) {
83 ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
85 }
86 if (cs->regHandle(this,*h).isFailure()) {
88 ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
89 << " with CondSvc");
90 }
91 }
92 }
93 return sc;
94}
virtual StatusCode sysInitialize() override
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

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

Definition at line 298 of file AthCommonDataStore.h.

298 {
299 for (auto &a : m_vhka) {
301 for (auto k : keys) {
302 k->setOwner(this);
303 }
304 }
305 }

Member Data Documentation

◆ m_cabling

const TileCablingService* TileDCSCondAlg::m_cabling {nullptr}
private

Definition at line 197 of file TileDCSCondAlg.h.

197{nullptr};

◆ m_cablingSvc

ServiceHandle<TileCablingSvc> TileDCSCondAlg::m_cablingSvc
private
Initial value:
{ this,
"TileCablingSvc", "TileCablingSvc", "The Tile cabling service" }

Name of Tile cabling service.

Definition at line 194 of file TileDCSCondAlg.h.

194 { this,
195 "TileCablingSvc", "TileCablingSvc", "The Tile cabling service" };

◆ m_channel2pmt

int TileDCSCondAlg::m_channel2pmt[2][NUMBER_OF_HVSET_CHANNELS] = {}
private

Definition at line 205 of file TileDCSCondAlg.h.

205{};

◆ m_dcsChHvInCool

Gaudi::Property<std::string> TileDCSCondAlg::m_dcsChHvInCool
private
Initial value:
{this,
"DCSChHVInCOOL", "DCSChHVInCOOL.dat",
"File name with mapping Tile DCS HV DB COOL channels to ROS and drawer"}

File name with mapping Tile DCS HV DB COOL channels to ROS and drawer.

Definition at line 173 of file TileDCSCondAlg.h.

173 {this,
174 "DCSChHVInCOOL", "DCSChHVInCOOL.dat",
175 "File name with mapping Tile DCS HV DB COOL channels to ROS and drawer"};

◆ m_dcsChHvSetInCool

Gaudi::Property<std::string> TileDCSCondAlg::m_dcsChHvSetInCool
private
Initial value:
{this,
"DCSChHVSETInCOOL", "DCSChHVSETInCOOL.dat",
"File name with mapping Tile DCS HVSET DB COOL channels to ROS and drawer"}

File name with mapping Tile DCS HVSET DB COOL channels to ROS and drawer.

Definition at line 180 of file TileDCSCondAlg.h.

180 {this,
181 "DCSChHVSETInCOOL", "DCSChHVSETInCOOL.dat",
182 "File name with mapping Tile DCS HVSET DB COOL channels to ROS and drawer"};

◆ m_dcsChStatesInCool

Gaudi::Property<std::string> TileDCSCondAlg::m_dcsChStatesInCool
private
Initial value:
{this,
"DCSChStatesInCOOL", "DCSChStatesInCOOL.dat",
"File name with mapping Tile DCS STATES DB COOL channels to ROS and drawer"}

File name with mapping Tile DCS STATES DB COOL channels to ROS and drawer.

Definition at line 187 of file TileDCSCondAlg.h.

187 {this,
188 "DCSChStatesInCOOL", "DCSChStatesInCOOL.dat",
189 "File name with mapping Tile DCS STATES DB COOL channels to ROS and drawer"};

◆ m_dcsStateKey

SG::WriteCondHandleKey<TileDCSState> TileDCSCondAlg::m_dcsStateKey
private
Initial value:
{this,
"TileDCS", "TileDCS", "Output Tile DCS status"}

The name of TileDCSState object to produce and put into condition store.

Definition at line 111 of file TileDCSCondAlg.h.

111 {this,
112 "TileDCS", "TileDCS", "Output Tile DCS status"};

◆ m_detStore

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

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

◆ m_emScaleKey

SG::ReadCondHandleKey<TileEMScale> TileDCSCondAlg::m_emScaleKey
private
Initial value:
{this,
"TileEMScale", "TileEMScale", "Input Tile EMS conditions"}

The name of TileEMScale object to get reference HV from Cesium or Laser folder.

Definition at line 117 of file TileDCSCondAlg.h.

117 {this,
118 "TileEMScale", "TileEMScale", "Input Tile EMS conditions"};

◆ m_evtStore

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

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_goodDrawer

Gaudi::Property<int> TileDCSCondAlg::m_goodDrawer
private
Initial value:
{this, "GoodDrawer", 212222,
"Status is OK if Tile DCS drawer states is like this"}

Status is OK if Tile DCS drawer states is like this.

Definition at line 155 of file TileDCSCondAlg.h.

155 {this, "GoodDrawer", 212222,
156 "Status is OK if Tile DCS drawer states is like this"};

◆ m_goodHVLimit

Gaudi::Property<float> TileDCSCondAlg::m_goodHVLimit
private
Initial value:
{this, "GoodHVLimit", 2.0F,
"Status is OK if HV difference is below this limit"}

Tile DCS Status is OK if difference between measured and requested HV is below this limit.

Definition at line 142 of file TileDCSCondAlg.h.

142 {this, "GoodHVLimit", 2.0F,
143 "Status is OK if HV difference is below this limit"};

◆ m_hvKey

SG::ReadCondHandleKey<CondAttrListCollection> TileDCSCondAlg::m_hvKey
private
Initial value:
{this,
"HV", "/TILE/DCS/HV", "The Tile DCS HV COOL folder name"}

The Tile DCS HV COOL folder name.

Definition at line 93 of file TileDCSCondAlg.h.

93 {this,
94 "HV", "/TILE/DCS/HV", "The Tile DCS HV COOL folder name"};

◆ m_hvSetKey

SG::ReadCondHandleKey<CondAttrListCollection> TileDCSCondAlg::m_hvSetKey
private
Initial value:
{this,
"HVSET", "/TILE/DCS/HVSET", "The Tile DCS HVSET COOL folder name"}

The Tile DCS HVSET COOL folder name.

Definition at line 99 of file TileDCSCondAlg.h.

99 {this,
100 "HVSET", "/TILE/DCS/HVSET", "The Tile DCS HVSET COOL folder name"};

◆ m_isChannelUsed

bool TileDCSCondAlg::m_isChannelUsed[4][NUMBER_OF_CHANNELS] = {}
private

Definition at line 207 of file TileDCSCondAlg.h.

207{}; // 0=LB, 1=EB, 2=EB without D4, 3=EB with special C10

◆ m_knownBadHV

std::map<int, std::pair<float,float> > TileDCSCondAlg::m_knownBadHV
private

Definition at line 203 of file TileDCSCondAlg.h.

◆ m_pmt2channel

int TileDCSCondAlg::m_pmt2channel[2][NUMBER_OF_HVSET_CHANNELS] = {}
private

Definition at line 206 of file TileDCSCondAlg.h.

206{};

◆ m_readHV

Gaudi::Property<bool> TileDCSCondAlg::m_readHV
private
Initial value:
{this, "ReadHV", true,
"Flag to control reading Tile DCS HV folder from DB"}

Flag to control reading Tile DCS HV folder from DB.

Definition at line 123 of file TileDCSCondAlg.h.

123 {this, "ReadHV", true,
124 "Flag to control reading Tile DCS HV folder from DB"};

◆ m_readHVSet

Gaudi::Property<bool> TileDCSCondAlg::m_readHVSet
private
Initial value:
{this, "ReadHVSET", false,
"Flag to control reading Tile DCS HVSET folder from DB"}

Flag to control reading Tile DCS HVSET folder from DB.

Definition at line 129 of file TileDCSCondAlg.h.

129 {this, "ReadHVSET", false,
130 "Flag to control reading Tile DCS HVSET folder from DB"};

◆ m_readStates

Gaudi::Property<bool> TileDCSCondAlg::m_readStates
private
Initial value:
{this, "ReadSTATES", true,
"Flag to control reading Tile DCS STATES folder from DB"}

Flag to control reading Tile DCS STATES folder from DB.

Definition at line 135 of file TileDCSCondAlg.h.

135 {this, "ReadSTATES", true,
136 "Flag to control reading Tile DCS STATES folder from DB"};

◆ m_rosDrawerHV

std::vector<std::pair<int, int> > TileDCSCondAlg::m_rosDrawerHV
private

Definition at line 199 of file TileDCSCondAlg.h.

◆ m_rosDrawerHVSet

std::vector<std::pair<int, int> > TileDCSCondAlg::m_rosDrawerHVSet
private

Definition at line 200 of file TileDCSCondAlg.h.

◆ m_rosDrawerStates

std::vector<std::pair<int, int> > TileDCSCondAlg::m_rosDrawerStates
private

Definition at line 201 of file TileDCSCondAlg.h.

◆ m_statesKey

SG::ReadCondHandleKey<CondAttrListCollection> TileDCSCondAlg::m_statesKey
private
Initial value:
{this,
"STATES", "/TILE/DCS/STATES", "The Tile DCS STATES COOL folder name"}

The Tile DCS STATES COOL folder name.

Definition at line 105 of file TileDCSCondAlg.h.

105 {this,
106 "STATES", "/TILE/DCS/STATES", "The Tile DCS STATES COOL folder name"};

◆ m_varHandleArraysDeclared

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

Definition at line 387 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 386 of file AthCommonDataStore.h.

◆ m_warningDrawer

Gaudi::Property<std::vector<int> > TileDCSCondAlg::m_warningDrawer
private
Initial value:
{this, "WarningDrawer",
{202221,
202222,
2222,
212020,
202020,
2020},
"Status is WARNING if Tile DCS drawer states is like this"}

Status is WARNING if Tile DCS drawer states is like this.

Definition at line 161 of file TileDCSCondAlg.h.

161 {this, "WarningDrawer",
162 {202221, // module in emergency mode
163 202222, // 830V HV is on, no communication on HV can-bus, status is unknown (assume that it's good)
164 2222, // no communication on HV can-bus, status is unknown (assume that it's good)
165 212020, // no communication on LV can-bus, status is unknown (assume that it's good)
166 202020, // 830V HV is on, no communication on LV and HV can-bus, status is unknown (assume that it's good)
167 2020}, // no communication on LV and HV can-bus, status is unknown (assume that it's good)
168 "Status is WARNING if Tile DCS drawer states is like this"};

◆ m_warningHVLimit

Gaudi::Property<float> TileDCSCondAlg::m_warningHVLimit
private
Initial value:
{this, "WarningHVLimit", 10.0F,
"Mask channels with HV difference above this limit"}

Mask channels with difference between measured and requested HV above this limit.

Definition at line 149 of file TileDCSCondAlg.h.

149 {this, "WarningHVLimit", 10.0F,
150 "Mask channels with HV difference above this limit"};

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