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 unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
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
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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 {}
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 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

TileLimits

enum TileDCSCondAlg::TileLimits

private

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.

                    {
      NUMBER_OF_CHANNELS = 48,
      NUMBER_OF_HVSET_CHANNELS = 68,
      NUMBER_OF_MODULE_TYPES = 2, // LB, EB
      NUMBER_OF_SPECIAL_MODULE_TYPES = 4 // // LB, EB, EB without D4, EB with special C10
    };

TileModuleType

enum TileDCSCondAlg::TileModuleType

private

Enumerator
LONG_BARREL
EXTENDED_BARREL
EXTENDED_BARREL_NO_D4
EXTENDED_BARREL_SPECIAL_C10

Definition at line 45 of file TileDCSCondAlg.h.

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

Constructor & Destructor Documentation

TileDCSCondAlg()

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

Definition at line 22 of file TileDCSCondAlg.cxx.

                                                                              :
  AthCondAlgorithm(name, pSvcLocator),
  m_cabling(nullptr)
{
 
}

~TileDCSCondAlg()

virtual TileDCSCondAlg::~TileDCSCondAlg ( )

virtualdefault

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

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

overridevirtual

Definition at line 111 of file TileDCSCondAlg.cxx.

                                                                {
 
  SG::WriteCondHandle<TileDCSState> dcsState{m_dcsStateKey, ctx};
 
  if (dcsState.isValid()) {
    ATH_MSG_DEBUG("Found valid TileDCSState: " << dcsState.key());
    return StatusCode::SUCCESS;
  }
 
  std::unique_ptr<TileDCSState> dcsStateData = std::make_unique<TileDCSState>();
  dcsStateData->setGoodDrawer(m_goodDrawer.value());
  dcsStateData->setWarningDrawer(m_warningDrawer.value());
 
  if (m_readHV) {
 
    SG::ReadCondHandle<CondAttrListCollection> hv(m_hvKey, ctx);
    dcsState.addDependency(hv);
    for (const CondAttrListCollection::ChanAttrListPair& chanAttrListPair : **hv) {
 
      const CondAttrListCollection::ChanNum coolChannel = chanAttrListPair.first;
 
      const std::pair<int, int> rosDrawerPair = m_rosDrawerHV.at(coolChannel);
      unsigned int ros = rosDrawerPair.first;
      unsigned int drawer = rosDrawerPair.second;
 
      ATH_MSG_VERBOSE( "ros: " << ros
                       << ", drawer: " << drawer
                       << ", COOL channel: " << coolChannel
                       << ", payload: " << chanAttrListPair.second);
 
      int moduleType = (ros > 2) ? EXTENDED_BARREL : LONG_BARREL;
      int pmt0 = 0; // runs over paylod parameters
      for (const coral::Attribute& attribute : chanAttrListPair.second) {
        int channel = m_pmt2channel[moduleType][pmt0];
        dcsStateData->setChannelHV(ros, drawer, channel, attribute.data<float>());
        ATH_MSG_VERBOSE( "HV[" << pmt0 << "] = " << attribute.data<float>() );
        ++pmt0;
      }
 
    }
  }
 
 
  if (m_readHVSet) {
 
    SG::ReadCondHandle<CondAttrListCollection> hvSet(m_hvSetKey, ctx);
    dcsState.addDependency(hvSet);
    for (const CondAttrListCollection::ChanAttrListPair& chanAttrListPair : **hvSet) {
 
      const CondAttrListCollection::ChanNum coolChannel = chanAttrListPair.first;
 
      const std::pair<int, int> rosDrawerPair = m_rosDrawerHVSet.at(coolChannel);
      unsigned int ros = rosDrawerPair.first;
      unsigned int drawer = rosDrawerPair.second;
 
      ATH_MSG_VERBOSE( "ros: " << ros
                       << ", drawer: " << drawer
                       << ", COOL channel: " << coolChannel
                       << ", payload: " << chanAttrListPair.second);
 
      int moduleType = (ros > 2) ? EXTENDED_BARREL : LONG_BARREL;
      int pmt0 = 0; // runs over paylod parameters
      for (const coral::Attribute& attribute : chanAttrListPair.second) {
        int channel = m_pmt2channel[moduleType][pmt0];
        dcsStateData->setChannelHVSet(ros, drawer, channel, attribute.data<float>());
        ATH_MSG_VERBOSE( "HVSET[" << pmt0 << "] = " << attribute.data<float>() );
        ++pmt0;
      }
 
    }
  } else {
    ATH_CHECK( fillReferenceHV(*dcsStateData, dcsState, ctx) );
 
  }
 
 
  if (m_readStates) {
 
    SG::ReadCondHandle<CondAttrListCollection> states(m_statesKey, ctx);
    dcsState.addDependency(states);
    for (const CondAttrListCollection::ChanAttrListPair& chanAttrListPair : **states) {
 
      CondAttrListCollection::ChanNum coolChannel = chanAttrListPair.first;
 
      std::pair<int, int> rosDrawerPair = m_rosDrawerStates.at(coolChannel);
      unsigned int ros = rosDrawerPair.first;
      unsigned int drawer = rosDrawerPair.second;
 
      ATH_MSG_VERBOSE( "ros: " << ros
                       << ", drawer: " << drawer
                       << ", COOL channel: " << coolChannel
                       << ", payload: " << chanAttrListPair.second);
 
      for (const coral::Attribute& attribute : chanAttrListPair.second) {
        dcsStateData->setDrawerStates(ros, drawer, attribute.data<int>());
        ATH_MSG_VERBOSE( "STATES = " << attribute.data<int>() );
      }
 
    }
  }
 
 
  for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
    for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
 
      TileDCSState::TileDCSStatus drawerStatus = dcsStateData->getDCSStatus(ros, drawer);
 
      int moduleType = (ros > 2) ? EXTENDED_BARREL : LONG_BARREL;
      int specialModuleType(moduleType);
      if (moduleType == EXTENDED_BARREL) {
        if ((ros == 3 && drawer == 14) || (ros == 4 && drawer == 17)) {
          specialModuleType = EXTENDED_BARREL_NO_D4; // EBA15 EBC18
        } else if (!m_cabling->C10_connected(drawer)) {
          specialModuleType = EXTENDED_BARREL_SPECIAL_C10; // EB modules with special C10
        }
      }
 
      for (unsigned int channel = 0; channel < TileCalibUtils::MAX_CHAN; ++channel) {
        if (m_isChannelUsed[specialModuleType][channel]) {
 
          TileDCSState::TileDCSStatus channelHVStatus(TileDCSState::UNKNOWN);
 
          float hvSet(dcsStateData->getChannelHVSet(ros, drawer, channel));
          float hv(dcsStateData->getChannelHV(ros, drawer, channel));
 
          // ignore zero "set" and negative "measured" HV, set status to unknown
          if (hvSet >= 1.0 && hv >= 0.0    // HV can't be negative
              && hvSet < 999.9 && hv < 999.9) { // HV can't be greater 930V
 
            std::map<int, std::pair<float, float>>::const_iterator itr =
              m_knownBadHV.find(getChannelKey(ros, drawer, channel));
 
            if (itr != m_knownBadHV.end()) { // known unstable PMTs
 
              float hvGap = (m_readHVSet) ? // take into account offset if HVSET is used
                std::fabs(hvSet + itr->second.second - hv) : std::fabs(hvSet - hv);
 
              if (hvGap <= m_goodHVLimit) channelHVStatus = TileDCSState::OK_KNOWNBADPMT;
              else if (hvGap <= m_warningHVLimit) channelHVStatus = TileDCSState::WARNING_KNOWNBADPMT;
              else channelHVStatus = TileDCSState::ALERT_KNOWNBADPMT;
            } else {
              float hvGap = std::fabs(hvSet - hv);
              if (hvGap <= m_goodHVLimit) channelHVStatus = TileDCSState::OK;
              else if (hvGap <= m_warningHVLimit) channelHVStatus = TileDCSState::WARNING;
              else channelHVStatus = TileDCSState::ALERT;
            }
 
          }
 
          dcsStateData->setDCSHVStatus(ros, drawer, channel, channelHVStatus);
 
          if (drawerStatus > TileDCSState::OK && !m_readHVSet) {
            dcsStateData->setDCSStatus(ros, drawer, channel, drawerStatus);
          } else {
            dcsStateData->setDCSStatus(ros, drawer, channel, std::max(drawerStatus, channelHVStatus));
          }
 
        } else {
          dcsStateData->setDCSHVStatus(ros, drawer, channel, TileDCSState::NON_EXISTING);
          dcsStateData->setDCSStatus(ros, drawer, channel, TileDCSState::NON_EXISTING);
        }
      }
 
 
      if (msgLvl(MSG::VERBOSE)) {
        msg(MSG::VERBOSE) << "Module = " << TileCalibUtils::getDrawerString(ros, drawer)
                          << " Status = " << drawerStatus << endmsg;
 
        std::string ignored = ((drawerStatus > TileDCSState::OK && !m_readHVSet) ? " ignored" : "");
 
        for (unsigned int channel = 0; channel < TileCalibUtils::MAX_CHAN; ++channel) {
          int pmt0 = m_channel2pmt[moduleType][channel];
          TileDCSState::TileDCSStatus status = dcsStateData->getDCSHVStatus(ros, drawer, channel);
          msg(MSG::VERBOSE) << "Module = " << TileCalibUtils::getDrawerString(ros, drawer)
                            << " channel = " << channel
                            << " pmt = " << pmt0 + 1
                            << " HV = " << dcsStateData->getChannelHV(ros, drawer, channel)
                            << " HVSET = " << dcsStateData->getChannelHVSet(ros, drawer, channel)
                            << " Status = " << status
                            << ignored << endmsg;
        }
      }
 
    }
  }
 
  // Define validity of the output cond object
  if(dcsState.record(std::move(dcsStateData)).isFailure()) {
 
    ATH_MSG_ERROR("Could not record TileDCSState object with "
                  << dcsState.key()
                  << " with EventRange " << dcsState.getRange()
                  << " into Conditions Store");
 
    return StatusCode::FAILURE;
  } else {
 
    ATH_MSG_VERBOSE("Recorded TileDCSState object with "
            << dcsState.key()
            << " with EventRange " << dcsState.getRange()
            << " into Conditions Store");
  }
 
  return StatusCode::SUCCESS;
 
}

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< 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 94 of file AthCommonReentrantAlgorithm.cxx.

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

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]	dcsState	TileDCSState to store reference HV
[out]	eventRange	Event range within which reference HV is valid

Definition at line 481 of file TileDCSCondAlg.cxx.

                                                                          {
 
  SG::ReadCondHandle<TileEMScale> emScale(m_emScaleKey, ctx);
  wh.addDependency(emScale);
 
  float laserReferenceHV = -5.;
  float cesReferenceHV = -5.;
 
  for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
    int moduleType = (ros > 2) ? EXTENDED_BARREL : LONG_BARREL;
 
    for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
      unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
 
      for (unsigned int channel = 0; channel < TileCalibUtils::MAX_CHAN; ++channel) {
        int pmt0 = m_channel2pmt[moduleType][channel];
 
        cesReferenceHV = emScale->getCesiumReferenceHV(drawerIdx, channel);
        laserReferenceHV = emScale->getLaserReferenceHV(drawerIdx, channel);
 
        if (laserReferenceHV >= 0.) {
          dcsState.setChannelHVSet(ros, drawer, channel, laserReferenceHV);
        } else {
          dcsState.setChannelHVSet(ros, drawer, channel, cesReferenceHV);
        }
 
        if (msgLvl(MSG::VERBOSE)) {
          msg(MSG::VERBOSE) << "Module = " << TileCalibUtils::getDrawerString(ros, drawer)
                            << " channel = " << channel
                            << " pmt = " << pmt0 + 1
                            << " HVref = " << dcsState.getChannelHVSet(ros, drawer, channel);
 
          if (laserReferenceHV >= 0.) {
            msg(MSG::VERBOSE) << " Taken from Laser run (replace "
                              << cesReferenceHV << " cesium value)" << endmsg;
          } else {
            msg(MSG::VERBOSE) << endmsg;
          }
        }
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

filterPassed()

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

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

finalize()

StatusCode TileDCSCondAlg::finalize ( )

overridevirtual

Definition at line 530 of file TileDCSCondAlg.cxx.

                                    {
  return StatusCode::SUCCESS;
}

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.

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

initialize()

StatusCode TileDCSCondAlg::initialize ( )

overridevirtual

Definition at line 30 of file TileDCSCondAlg.cxx.

                                      {
 
  ATH_MSG_DEBUG( "In initialize()" );
 
  ATH_CHECK( m_hvKey.initialize(m_readHV) );
 
  ATH_CHECK( m_hvSetKey.initialize(m_readHVSet) );
  ATH_CHECK( m_emScaleKey.initialize(!m_readHVSet) );
 
  ATH_CHECK( m_statesKey.initialize(m_readStates) );
 
 
  ATH_MSG_INFO( "Will read the following folders: "
                << ((m_readHV) ? m_hvKey.key() : "") << " "
                << ((m_readHVSet) ? m_hvSetKey.key() : "") << " "
                << ((m_readStates) ? m_statesKey.key() : ""));
 
  //=== get TileCablingSvc
  ATH_CHECK( m_cablingSvc.retrieve() );
 
  //=== cache pointers to cabling helpers
  m_cabling = m_cablingSvc->cablingService();
 
  if (!m_cabling) {
    ATH_MSG_ERROR( "Pointer to TileCablingService is zero: " << m_cabling);
    return StatusCode::FAILURE;
  }
 
  std::map<TileModuleType, unsigned int> roses{{LONG_BARREL, 2}, {EXTENDED_BARREL, 3}};
 
  for (TileModuleType moduleType : {LONG_BARREL, EXTENDED_BARREL}) {
 
    unsigned int ros = roses[moduleType];
    unsigned int channel = 0;
 
    for (; channel < TileCalibUtils::MAX_CHAN; ++channel) {
      int pmt = m_cabling->channel2hole(ros, channel);
      m_isChannelUsed[moduleType][channel] = (pmt > 0); // positive pmt - means channel is connected
 
      if (moduleType == EXTENDED_BARREL) {
        m_isChannelUsed[EXTENDED_BARREL_SPECIAL_C10][channel] =
          m_isChannelUsed[EXTENDED_BARREL_NO_D4][channel] = m_isChannelUsed[EXTENDED_BARREL][channel];
      }
 
      pmt = std::abs(pmt);
      m_channel2pmt[moduleType][channel] = pmt - 1;
      m_pmt2channel[moduleType][pmt - 1] = channel; // note - pmt-1 is used as index
    }
 
    for (; channel < 68; ++channel) {
      m_channel2pmt[moduleType][channel] = channel;
      m_pmt2channel[moduleType][channel] = channel;
    }
 
  }
 
  // description of EBA15 and EBC18 channel 0-3 do not exist, channel 18,19 used
  m_isChannelUsed[EXTENDED_BARREL_NO_D4][0] = false;
  m_isChannelUsed[EXTENDED_BARREL_NO_D4][1] = false;
  m_isChannelUsed[EXTENDED_BARREL_NO_D4][2] = false;
  m_isChannelUsed[EXTENDED_BARREL_NO_D4][3] = false;
  m_isChannelUsed[EXTENDED_BARREL_NO_D4][18] = true;
  m_isChannelUsed[EXTENDED_BARREL_NO_D4][19] = true;
  // description of EB with special C10 - channel 4 (pmt 5) is not used
  m_isChannelUsed[EXTENDED_BARREL_SPECIAL_C10][4] = false;
 
  if (m_readHVSet) {
    // read special deltas for few unstable PMTs
    readBadHV("BadHVChannels.dat");
    if (readConfig(m_dcsChHvSetInCool, "Drawer", m_rosDrawerHVSet)) return StatusCode::FAILURE;
  }
 
  if (readConfig(m_dcsChStatesInCool, "_LVPS_", m_rosDrawerStates)) return StatusCode::FAILURE;
  if (readConfig(m_dcsChHvInCool, "Drawer", m_rosDrawerHV)) return StatusCode::FAILURE;
 
  ATH_CHECK( m_dcsStateKey.initialize() );
 
  return StatusCode::SUCCESS;
}

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, 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, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

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.

{ return false; }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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

fileName

name of file with special deltas for few unstable PMTs

Returns

0 in the case of success

Definition at line 387 of file TileDCSCondAlg.cxx.

                                                       {
 
  std::string fullFileName = PathResolver::find_file(fileName, "DATAPATH");
  std::ifstream file(fullFileName.c_str());
  if (!file.is_open()) {
    ATH_MSG_WARNING( "Can't find " << fileName);
    return 1;
  } else {
    ATH_MSG_DEBUG("Reading file " << fullFileName);
  }
 
  std::string partName[5] = { "AUX", "LBA", "LBC", "EBA", "EBC" };
 
  unsigned int ros, module, pmt;
  float delta, offset;
  char ll[256];
  std::string line;
  size_t pos = 0;
 
  while (true) {
 
    file.getline(ll, sizeof(ll));
 
    if (file.eof() || file.fail()) break;
 
    line = std::string(ll);
 
    for (ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
      pos = line.find(partName[ros]);
      if (pos != std::string::npos) break;
    }
    if (ros == TileCalibUtils::MAX_ROS) {
      ATH_MSG_WARNING( "File " << fileName << " Partition name not found in " << line);
      continue;
    }
 
    module = atoi(&line[pos + 3]);
    if (module < 1 || module > TileCalibUtils::MAX_DRAWER) {
      ATH_MSG_WARNING( "File " << fileName << " Wrong module number in " << line);
      continue;
    }
 
    pos = line.find("PMT number");
    if (pos == std::string::npos) {
      ATH_MSG_WARNING( "File " << fileName << " Word 'PMT number' not found in " << line);
      continue;
    }
 
    pmt = atoi(&line[pos + 10]);
    if (pmt < 1 || pmt > TileCalibUtils::MAX_CHAN) {
      ATH_MSG_WARNING( "File " << fileName << " Wrong pmt number in " << line);
      continue;
    }
 
    pos = line.find("Step Value is");
    if (pos == std::string::npos) {
      ATH_MSG_WARNING( "File " << fileName << " Word 'Step Value is' not found in " << line);
      continue;
    }
 
    delta = atof(&line[pos + 13]);
    if (delta <= 0.0 || delta > 1000.0) {
      ATH_MSG_WARNING( "File " << fileName << " Wrong delta number in " << line);
      continue;
    }
 
    pos = line.find("Offset is:");
    if (pos == std::string::npos) {
      ATH_MSG_WARNING( "File " << fileName << " Word 'Offset is:' not found in " << line);
      continue;
    }
 
    offset = atof(&line[pos + 10]);
    if (offset < -1000.0 || offset > 1000.0) {
      ATH_MSG_WARNING( "File " << fileName << " Wrong offset number in " << line);
      continue;
    }
 
    ATH_MSG_WARNING( "Module = " << TileCalibUtils::getDrawerString(ros, module - 1)
                    << " pmt = " << pmt
                    << " delta = " << delta
                    << " offset = " << offset);
 
    int moduleType = (ros > 2) ? EXTENDED_BARREL : LONG_BARREL;
    int channel = m_pmt2channel[moduleType][pmt - 1];
    m_knownBadHV[getChannelKey(ros, module - 1, channel)] = std::make_pair(delta, offset);
 
  }
 
  file.close();
 
  return 0;
}

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

	fileName	name of file with mapping of COOL channels to Tile ROS and drawer pairs
	subStr	sub string to look for
[out]	rosDrawer	vector of Tile ROS and drawer pairs indexed by COOL channel

Returns

0 in the case of success

Definition at line 321 of file TileDCSCondAlg.cxx.

                                                                        {
 
  std::string fullFileName = PathResolver::find_file(fileName, "DATAPATH");
  std::ifstream file(fullFileName.c_str());
  if (!file.is_open()) {
    ATH_MSG_ERROR( "Can't find " << fileName);
    return 2;
  } else {
    ATH_MSG_DEBUG( "Reading file " << fullFileName);
  }
 
  rosDrawer.resize(257, std::make_pair<int, int>(0xFFFF, 0xFFFF));
 
  std::string compName[5] = { "XXX", "ATLTILLV01", "ATLTILLV02", "ATLTILLV00", "ATLTILLV03" };
 
  unsigned int ind, ros, module;
  std::string s, line;
  size_t pos;
 
  while (true) {
 
    file >> s >> ind >> line;
 
    if (file.eof() || file.fail()) break;
    if (ind > 1000000) break;
 
    for (ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
      pos = line.find(compName[ros]);
      if (pos != std::string::npos) break;
    }
 
    if (ros == TileCalibUtils::MAX_ROS) {
      msg(MSG::WARNING) << "File " << fileName << " Wrong computer name in " << line << endmsg;
      continue;
    }
 
    pos = line.find(subStr);
    if (pos == std::string::npos) {
      ATH_MSG_WARNING( "File " << fileName << " Word " << subStr << " not found in " << line);
      continue;
    }
 
    module = atoi(&line[pos + subStr.size()]);
    if (module < 1 || module > TileCalibUtils::MAX_DRAWER) {
      ATH_MSG_WARNING( "File " << fileName << " Wrong module number in " << line);
      continue;
    }
 
    ATH_MSG_VERBOSE("Module = " << TileCalibUtils::getDrawerString(ros, module - 1) << " ind = " << ind);
 
    if (rosDrawer.size() <= ind) {
      rosDrawer.resize(ind + 1, std::make_pair<int, int> (0xFFFF, 0xFFFF));
    }
 
    rosDrawer[ind] = std::make_pair<int, int>(ros, (module - 1));
 
  }
 
  file.close();
 
  return 0;
}

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

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

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

sysExecute()

StatusCode AthCommonReentrantAlgorithm< 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.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< 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 HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_cabling

const TileCablingService* TileDCSCondAlg::m_cabling {}

private

Definition at line 197 of file TileDCSCondAlg.h.

{};

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.

                                              { this,
        "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.

{};

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.

                                            {this,
        "DCSChHVInCOOL", "DCSChHVInCOOL.dat",
        "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.

                                               {this,
        "DCSChHVSETInCOOL", "DCSChHVSETInCOOL.dat",
        "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.

                                                {this,
        "DCSChStatesInCOOL", "DCSChStatesInCOOL.dat",
        "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.

                                                    {this,
        "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 393 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.

                                                 {this,
        "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 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.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.

                                   {this, "GoodDrawer", 212222,
        "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.

                                      {this, "GoodHVLimit", 2.0F,
        "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.

                                                       {this,
        "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.

                                                          {this,
        "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.

{}; // 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.

{};

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.

                                {this, "ReadHV", true,
        "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.

                                   {this, "ReadHVSET", false,
        "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.

                                    {this, "ReadSTATES", true,
        "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.

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

m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

                                                 {this, "WarningDrawer",
        {202221, // module in emergency mode
         202222, // 830V HV is on, no communication on HV can-bus, status is unknown (assume that it's good)
         2222,   // no communication on HV can-bus, status is unknown (assume that it's good)
         212020, // no communication on LV can-bus, status is unknown (assume that it's good)
         202020, // 830V HV is on, no communication on LV and HV can-bus, status is unknown (assume that it's good)
         2020},  // no communication on LV and HV can-bus, status is unknown (assume that it's good)
        "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.

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

---

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

• TileDCSCondAlg.h
• TileDCSCondAlg.cxx