MagField::AtlasFieldMapCondAlg Class Reference

#include <AtlasFieldMapCondAlg.h>

Inheritance diagram for MagField::AtlasFieldMapCondAlg:

Collaboration diagram for MagField::AtlasFieldMapCondAlg:

Classes
struct	Cache

Public Member Functions
	AtlasFieldMapCondAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~AtlasFieldMapCondAlg ()
StatusCode	start () override final
StatusCode	initialize () override final
StatusCode	execute (const EventContext &ctx) const override final
virtual bool	isReEntrant () const override final
virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...
virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
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. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	updateFieldMap (const EventContext &ctx, Cache &cache) const
StatusCode	checkCurrentFromConditions (const EventContext &ctx, double &soleCurrent, double &toroCurrent, EventIDRange &rangeDCS) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
Gaudi::Property< std::string >	m_fullMapFilename
	map file names - if not read from cool More...
Gaudi::Property< std::string >	m_soleMapFilename
Gaudi::Property< std::string >	m_toroMapFilename
Gaudi::Property< double >	m_mapSoleCurrent
	nominal current for the maps More...
Gaudi::Property< double >	m_mapToroCurrent
Gaudi::Property< double >	m_soleMinCurrent
Gaudi::Property< double >	m_toroMinCurrent
Gaudi::Property< bool >	m_loadMapOnStart
Gaudi::Property< bool >	m_useMapsFromCOOL
SG::ReadCondHandleKey< CondAttrListCollection >	m_mapsInputKey
SG::WriteCondHandleKey< AtlasFieldMapCondObj >	m_mapCondObjOutputKey
SG::ReadCondHandleKey< CondAttrListCollection >	m_currInputKey
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 22 of file AtlasFieldMapCondAlg.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

AtlasFieldMapCondAlg()

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

Definition at line 33 of file AtlasFieldMapCondAlg.cxx.

  : AthReentrantAlgorithm(name, pSvcLocator)
{}

~AtlasFieldMapCondAlg()

AtlasFieldMapCondAlg::~AtlasFieldMapCondAlg ( )

virtualdefault

Member Function Documentation

cardinality()

unsigned int AthReentrantAlgorithm::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.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

{
  return 0;
}

checkCurrentFromConditions()

StatusCode AtlasFieldMapCondAlg::checkCurrentFromConditions ( const EventContext &  ctx, double &  soleCurrent, double &  toroCurrent, EventIDRange &  rangeDCS  ) const

private

Definition at line 427 of file AtlasFieldMapCondAlg.cxx.

{
 
  // readin current value
  SG::ReadCondHandle<CondAttrListCollection> readHandle{ m_currInputKey, ctx };
  const CondAttrListCollection* attrListColl{ *readHandle };
  if (attrListColl == nullptr) {
    ATH_MSG_ERROR("checkCurrentFromConditions: Failed to retrieve "
                  "CondAttributeListCollection with key "
                  << m_currInputKey.key());
    return StatusCode::FAILURE;
  }
 
  // Get the validitiy range
  if (!readHandle.range(rangeDCS)) {
    ATH_MSG_FATAL(
      "checkCurrentFromConditions: Failed to retrieve validity range for "
      << readHandle.key());
    return StatusCode::FAILURE;
  }
  ATH_MSG_INFO("checkCurrentFromConditions: Range of input currents is "
               << rangeDCS);
 
  // get magnet currents from DCS
  double solcur{ 0. };
  double torcur{ 0. };
  bool gotsol{ false };
  bool gottor{ false };
 
  /*
   * due to inconsistencies between CONDBR2 and OFLP200/COMP200 (the former
   * includes channel names in the /EXT/DCS/MAGNETS/SENSORDATA folder, the
   * latter don't), we try to read currents in both ways
   */
  bool hasChanNames{ false };
  ATH_MSG_INFO("checkCurrentFromConditions: Attempt 1 at reading currents from "
               "DCS (using channel name)");
  for (CondAttrListCollection::const_iterator itr = attrListColl->begin();
       itr != attrListColl->end();
       ++itr) {
    const std::string& name = attrListColl->chanName(itr->first);
    ATH_MSG_INFO("checkCurrentFromConditions: Trying to read from DCS: "
                 "[channel name, index, value] "
                 << name << " , " << itr->first << " , "
                 << itr->second["value"].data<float>());
    if (name.compare("") != 0) {
      hasChanNames = true;
    }
    if (name.compare("CentralSol_Current") == 0) {
      // channel 1 is solenoid current
      solcur = itr->second["value"].data<float>();
      gotsol = true;
    } else if (name.compare("Toroids_Current") == 0) {
      // channel 3 is toroid current
      torcur = itr->second["value"].data<float>();
      gottor = true;
    }
  }
  if (!hasChanNames) {
    ATH_MSG_INFO("checkCurrentFromConditions: Attempt 2 at reading currents "
                 "from DCS (using channel index)");
    // in no channel is named, try again using channel index instead
    for (CondAttrListCollection::const_iterator itr = attrListColl->begin();
         itr != attrListColl->end();
         ++itr) {
 
      if (itr->first == 1) {
        // channel 1 is solenoid current
        solcur = itr->second["value"].data<float>();
        gotsol = true;
      } else if (itr->first == 3) {
        // channel 3 is toroid current
        torcur = itr->second["value"].data<float>();
        gottor = true;
      }
    }
  }
  if (!gotsol || !gottor) {
    if (!gotsol)
      ATH_MSG_ERROR("checkCurrentFromConditions: Missing solenoid current in "
                    "DCS information");
    if (!gottor)
      ATH_MSG_ERROR("checkCurrentFromConditions: Missing toroid current in DCS "
                    "information");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO("checkCurrentFromConditions: Currents read from DCS - solenoid "
               << solcur << " toroid " << torcur);
 
  // round to zero if close to zero
  if (solcur < m_soleMinCurrent) {
    solcur = 0.0;
    ATH_MSG_INFO("checkCurrentFromConditions: Solenoid is off");
  }
  if (torcur < m_toroMinCurrent) {
    torcur = 0.0;
    ATH_MSG_INFO("checkCurrentFromConditions: Toroids are off");
  }
 
  soleCurrent = solcur;
  toroCurrent = torcur;
 
  return StatusCode::SUCCESS;
}

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

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

inlineprivateinherited

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

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

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

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 333 of file AthCommonDataStore.h.

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

declareProperty() [5/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 352 of file AthCommonDataStore.h.

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

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > &  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() [1/2]

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; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

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

finaloverride

Definition at line 82 of file AtlasFieldMapCondAlg.cxx.

{
 
  ATH_MSG_DEBUG("execute: entering  " << ctx.eventID());
 
  // Check if output conditions object with field map object is still valid, if
  // not replace it with new map
  SG::WriteCondHandle<AtlasFieldMapCondObj> mapWriteHandle{
    m_mapCondObjOutputKey, ctx
  };
  if (mapWriteHandle.isValid()) {
    ATH_MSG_DEBUG("execute: CondHandle " << mapWriteHandle.fullKey()
                                         << " is still valid. ");
    return StatusCode::SUCCESS;
  }
 
  // This will need to be filled before we construct the condition object
  Cache cache{};
 
  ATH_CHECK(updateFieldMap(ctx, cache));
 
  if (cache.m_fieldMap) {
    ATH_MSG_INFO("execute: solenoid zone id  "
                 << cache.m_fieldMap->solenoidZoneId());
  } else {
    ATH_MSG_INFO("execute: no map read (currents == 0");
  }
 
  // Save newly created map in conditions object, and record it in the
  // conditions store, with its own range
  auto fieldMapCondObj = std::make_unique<AtlasFieldMapCondObj>();
  // move ownership of the field map to the fieldMapCondObj
  if (cache.m_fieldMap)
    fieldMapCondObj->setFieldMap(std::move(cache.m_fieldMap));
  if (mapWriteHandle
        .record(cache.m_mapCondObjOutputRange, std::move(fieldMapCondObj))
        .isFailure()) {
    ATH_MSG_ERROR("execute: Could not record AtlasFieldMapCondObj object with "
                  << mapWriteHandle.key() << " with EventRange "
                  << cache.m_mapCondObjOutputRange << " into Conditions Store");
    return StatusCode::FAILURE;
  }
  ATH_MSG_INFO("execute: recorded AtlasFieldMapCondObj with EventRange "
               << cache.m_mapCondObjOutputRange);
 
  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 & AthReentrantAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.cxx.

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

filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx ) const

inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

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

initialize()

StatusCode AtlasFieldMapCondAlg::initialize ( )

finaloverride

Definition at line 41 of file AtlasFieldMapCondAlg.cxx.

{
  // Read Handle for the map
  ATH_CHECK(m_mapsInputKey.initialize(m_useMapsFromCOOL));
 
  // Read Handle for the current
  ATH_CHECK(m_currInputKey.initialize(!m_loadMapOnStart && m_useMapsFromCOOL));
 
  // Output handle for the field map
  ATH_CHECK(m_mapCondObjOutputKey.initialize());
 
  ATH_MSG_DEBUG("Initialize: Key " << m_mapCondObjOutputKey.fullKey()
                << " has been succesfully registered ");
 
  ATH_MSG_INFO("Initialize: Will update the field map from " <<
               (m_useMapsFromCOOL ? "conditions" : "jobOpt file name") );
 
  // Load these dictionaries now, so we don't need to try to do so
  // while multiple threads are running.
  TClass::GetClass("TLeafI");
  TClass::GetClass("TLeafD");
  TClass::GetClass("TLeafO");
  TClass::GetClass("TLeafS");
 
  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 AthReentrantAlgorithm::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, InDet::SiSPGNNTrackMaker, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

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

isReEntrant()

virtual bool MagField::AtlasFieldMapCondAlg::isReEntrant ( ) const

inlinefinaloverridevirtual

Definition at line 31 of file AtlasFieldMapCondAlg.h.

{ return false; }

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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.

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 AthReentrantAlgorithm::setFilterPassed ( bool  state, const EventContext &  ctx  ) const

inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

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

start()

StatusCode AtlasFieldMapCondAlg::start ( )

finaloverride

Definition at line 69 of file AtlasFieldMapCondAlg.cxx.

{
  ATH_MSG_DEBUG("start: entering  ");
 
  // Load map on start, we assume that the current context is valid
  if (m_loadMapOnStart) {
    return (execute(Gaudi::Hive::currentContext()));
  }
 
  return StatusCode::SUCCESS;
}

sysExecute()

StatusCode AthReentrantAlgorithm::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 67 of file AthReentrantAlgorithm.cxx.

{
  return Gaudi::Algorithm::sysExecute (ctx);
}

sysInitialize()

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

Definition at line 96 of file AthReentrantAlgorithm.cxx.

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateFieldMap()

StatusCode AtlasFieldMapCondAlg::updateFieldMap ( const EventContext &  ctx, Cache &  cache  ) const

private

Definition at line 131 of file AtlasFieldMapCondAlg.cxx.

{
  // We get here only for the first creation of the field map, or if the
  // AtlasFieldMapCondObj object, where the map is stored, is no longer valid,
  // i.e. the IOV is out of range
 
  // Update the map either with the file names from cool or from alg properties,
  // according to m_useMapsFromCOOL
 
  // Get file names from COOL, or use local ones:
  std::string fullMapFilename;
  std::string soleMapFilename;
  std::string toroMapFilename;
 
  if (m_useMapsFromCOOL) {
 
    ATH_MSG_INFO("updateFieldMap: Update map from conditions");
 
    // readin map file name from cool
    SG::ReadCondHandle<CondAttrListCollection> readHandle{ m_mapsInputKey,
                                                           ctx };
    const CondAttrListCollection* attrListColl{ *readHandle };
    if (attrListColl == nullptr) {
      ATH_MSG_ERROR("updateFieldMap: Failed to retrieve "
                    "CondAttributeListCollection with key "
                    << readHandle.key());
      return StatusCode::FAILURE;
    }
 
    // // handle for COOL field map filenames
    // const DataHandle<CondAttrListCollection> mapHandle;
 
    // Get the validitiy range
    EventIDRange rangeW;
    if (!readHandle.range(rangeW)) {
      ATH_MSG_FATAL("updateFieldMap: Failed to retrieve validity range for "
                    << readHandle.key());
      return StatusCode::FAILURE;
    }
    cache.m_mapCondObjOutputRange = rangeW;
    ATH_MSG_INFO(
      "updateFieldMap: Update map from conditions: Range of input/output is "
      << cache.m_mapCondObjOutputRange);
 
    ATH_MSG_INFO(
      "updateFieldMap: reading magnetic field map filenames from COOL");
 
    for (CondAttrListCollection::const_iterator itr = attrListColl->begin();
         itr != attrListColl->end();
         ++itr) {
      const coral::AttributeList& attr = itr->second;
      const std::string& mapType = attr["FieldType"].data<std::string>();
      const std::string& mapFile = attr["MapFileName"].data<std::string>();
      const float soleCur = attr["SolenoidCurrent"].data<float>();
      const float toroCur = attr["ToroidCurrent"].data<float>();
 
      ATH_MSG_INFO("updateFieldMap: found map of type "
                   << mapType << " with soleCur=" << soleCur
                   << " toroCur=" << toroCur << " (path " << mapFile << ")");
 
      // first 5 letters are reserved (like "file:")
      const std::string mapFile_decoded = mapFile.substr(5);
      if (mapType == "GlobalMap") {
        fullMapFilename = mapFile_decoded;
        cache.m_mapSoleCurrent = soleCur;
        cache.m_mapToroCurrent = toroCur;
      } else if (mapType == "SolenoidMap") {
        soleMapFilename = mapFile_decoded;
      } else if (mapType == "ToroidMap") {
        toroMapFilename = mapFile_decoded;
      }
      // note: the idea is that the folder contains exactly three maps
      // (if it contains more than 3 maps, then this logic doesn't work
      // perfectly) nominal currents are read from the global map
    }
 
    if (m_loadMapOnStart) {
 
      // For loading map on start - online scenario - take the currents from job
      // options And set IOV range to current run number to run number + 1
 
      cache.m_mapSoleCurrent = m_mapSoleCurrent;
      cache.m_mapToroCurrent = m_mapToroCurrent;
 
      // Create a range for the current run
      EventIDBase start, stop;
      start.set_run_number(ctx.eventID().run_number());
      start.set_lumi_block(0);
      stop.set_run_number(ctx.eventID().run_number() + 1);
      stop.set_lumi_block(0);
      cache.m_mapCondObjOutputRange = EventIDRange(start, stop);
 
      ATH_MSG_INFO("updateFieldMap: loadMapOnStart is set, overriding currents "
                   "from job options - solCur "
                   << cache.m_mapSoleCurrent << ", torCur "
                   << cache.m_mapToroCurrent << " and setting IOV range: "
                   << cache.m_mapCondObjOutputRange);
    } else {
      // For normal athena jobs, check the currents in DCS to check if one of
      // the two magnets is OFF so that the correct map can be used. If a field
      // is off, set an IOV validity range to be the current run only. (Note DCS
      // currents have a timestamp-based IOV, so this is not used.)
 
      //  Note: for the nominal maps from COOL, three maps are available:
      //    - Global with both solenoid and toroid
      //    - Solenoid - just the currents for the solenoid
      //    - Toroid   - just the currents for the toroid
 
      double soleCurrent;
      double toroCurrent;
      EventIDRange rangeDCS;
      ATH_CHECK(
        checkCurrentFromConditions(ctx, soleCurrent, toroCurrent, rangeDCS));
 
      bool mustCreateIOVRange = false;
      if (soleCurrent < m_soleMinCurrent) {
        cache.m_mapSoleCurrent = 0;
        mustCreateIOVRange = true;
        ATH_MSG_INFO("updateFieldMap: set solenoid current to 0 from DCS");
      }
      if (toroCurrent < m_toroMinCurrent) {
        cache.m_mapToroCurrent = 0;
        mustCreateIOVRange = true;
        ATH_MSG_INFO("updateFieldMap: set toroid current to 0 from DCS");
      }
      if (mustCreateIOVRange) {
        // The currents from DCS are zero for either solenoid or toroid,
        // construct an IOV range for one run
        EventIDBase start, stop;
        // use ctx run number
        start.set_run_number(ctx.eventID().run_number());
        start.set_lumi_block(0);
        stop.set_run_number(ctx.eventID().run_number() + 1);
        stop.set_lumi_block(0);
        cache.m_mapCondObjOutputRange = EventIDRange(start, stop);
        ATH_MSG_INFO("updateFieldMap: map IOV  range "
                     << cache.m_mapCondObjOutputRange);
      } else {
        ATH_MSG_INFO("updateFieldMap: currents are OK, will use nominal maps");
      }
    }
  }
 
  else {
    // not m_useMapsFromCOOL - set values from job options
    fullMapFilename = m_fullMapFilename;
    soleMapFilename = m_soleMapFilename;
    toroMapFilename = m_toroMapFilename;
    if (m_mapSoleCurrent < m_soleMinCurrent) {
      cache.m_mapSoleCurrent = 0;
      ATH_MSG_INFO("updateFieldMap: requested solenoid current in JobOpt "
                   << m_mapSoleCurrent << " is below allowed minimum "
                   << m_soleMinCurrent << " setting to 0");
    } else {
      cache.m_mapSoleCurrent = m_mapSoleCurrent;
    }
    if (m_mapToroCurrent < m_toroMinCurrent) {
      cache.m_mapToroCurrent = 0;
      ATH_MSG_INFO("updateFieldMap: requested toroid current in JobOpt "
                   << m_mapToroCurrent << " is below allowed minimum "
                   << m_toroMinCurrent << " setting to 0");
    } else {
      cache.m_mapToroCurrent = m_mapToroCurrent;
    }
 
    // Create a range for the current run
    EventIDBase start, stop;
    start.set_run_number(ctx.eventID().run_number());
    start.set_lumi_block(0);
    stop.set_run_number(ctx.eventID().run_number() + 1);
    stop.set_lumi_block(0);
    cache.m_mapCondObjOutputRange = EventIDRange(start, stop);
 
    ATH_MSG_INFO(
      "updateFieldMap: useMapsFromCOOL == false, using default range "
      << cache.m_mapCondObjOutputRange);
  }
 
  // We allow to set currents via the TagInfoMgr which adds tags to the TagInfo
  // object - only allowed for offline
 
  if (m_useMapsFromCOOL) {
 
    // get currents via TagInfoMgr
    ServiceHandle<ITagInfoMgr> tagInfoMgr("TagInfoMgr", name());
    if (tagInfoMgr.retrieve().isSuccess()) {
      ATH_MSG_INFO("updateFieldMap: found TagInfoMgr ");
      bool resetCurrentsFromTagInfo = false;
      std::string mapSoleCurrent = tagInfoMgr->findTag("MapSoleCurrent");
      if (not mapSoleCurrent.empty()) {
        cache.m_mapSoleCurrent = std::stof(mapSoleCurrent);
        resetCurrentsFromTagInfo = true;
        ATH_MSG_INFO("updateFieldMap: found MapSoleCurrent in TagInfo, setting "
                     "the solenoid current "
                     << cache.m_mapSoleCurrent);
      }
      std::string mapToroCurrent = tagInfoMgr->findTag("MapToroCurrent");
      if (not mapToroCurrent.empty()) {
        cache.m_mapToroCurrent = std::stof(mapToroCurrent);
        resetCurrentsFromTagInfo = true;
        ATH_MSG_INFO("updateFieldMap: found MapToroCurrent in TagInfo, setting "
                     "the toroid current "
                     << cache.m_mapToroCurrent);
      }
      if (resetCurrentsFromTagInfo)
        ATH_MSG_INFO("updateFieldMap: reset currents from TagInfo");
      else
        ATH_MSG_INFO("updateFieldMap: DID NOT reset currents from TagInfo");
    } else {
      ATH_MSG_INFO("updateFieldMap: TagInfoMgr NOT found. ");
    }
  }
 
  // Select map file according to the value of the currents which indicate which
  // map is 'on'
 
  // determine the map to load
  std::string mapFile;
  if (cache.solenoidOn() && cache.toroidOn())
    mapFile = fullMapFilename;
  else if (cache.solenoidOn())
    mapFile = soleMapFilename;
  else if (cache.toroidOn())
    mapFile = toroMapFilename;
  else {
    // all magnets OFF. no need to read map
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_INFO(
    "updateFieldMap: Set map currents from FieldSvc: solenoid/toroid "
    << cache.m_mapSoleCurrent << "," << cache.m_mapToroCurrent);
  ATH_MSG_INFO("updateFieldMap: Use map file " << mapFile);
 
  // find the path to the map file
  std::string resolvedMapFile = PathResolver::find_file(mapFile, "CALIBPATH");
  if (resolvedMapFile.empty()) {
    ATH_MSG_ERROR("Field map file " << mapFile << " not found");
    return StatusCode::FAILURE;
  }
  // Do checks and extract root file to initialize the map
  if (resolvedMapFile.find(".root") == std::string::npos) {
    ATH_MSG_ERROR("updateFieldMap: input file name '"
                  << resolvedMapFile << "' does not end with .root");
    return StatusCode::FAILURE;
  }
  TFile* rootfile = new TFile(resolvedMapFile.c_str(), "OLD");
  if (!rootfile) {
    ATH_MSG_ERROR("updateFieldMap: failed to open " << resolvedMapFile);
    return StatusCode::FAILURE;
  }
  if (!rootfile->cd()) {
    // could not make it current directory
    ATH_MSG_ERROR(
      "updateFieldMap: unable to cd() into the ROOT field map TFile");
    rootfile->Close();
    delete rootfile;
    return StatusCode::FAILURE;
  }
  // open the tree
  TTree* tree = (TTree*)rootfile->Get("BFieldMap");
  if (tree == nullptr) {
    // no tree
    ATH_MSG_ERROR(
      "updateFieldMap: TTree 'BFieldMap' does not exist in ROOT field map");
    rootfile->Close();
    delete rootfile;
    return StatusCode::FAILURE;
  }
 
  // create map
  cache.m_fieldMap = std::make_unique<MagField::AtlasFieldMap>();
 
  // initialize map
  if (!cache.m_fieldMap->initializeMap(
        rootfile, cache.m_mapSoleCurrent, cache.m_mapToroCurrent)) {
    // failed to initialize the map
    ATH_MSG_ERROR(
      "updateFieldMap: unable to initialize the map for AtlasFieldMap for file "
      << resolvedMapFile);
    rootfile->Close();
    delete rootfile;
    return StatusCode::FAILURE;
  }
 
  rootfile->Close();
  delete rootfile;
 
  ATH_MSG_INFO("updateFieldMap: Initialized the field map from "
               << resolvedMapFile);
 
  return StatusCode::SUCCESS;
}

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_currInputKey

SG::ReadCondHandleKey<CondAttrListCollection> MagField::AtlasFieldMapCondAlg::m_currInputKey

private

Initial value:

{
    this,
    "COOLCurrentsFolderName",
    "/EXT/DCS/MAGNETS/SENSORDATA",
    "Name of the COOL folder containing magnet currents"
  }

Definition at line 152 of file AtlasFieldMapCondAlg.h.

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_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 AthReentrantAlgorithm::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

m_fullMapFilename

Gaudi::Property<std::string> MagField::AtlasFieldMapCondAlg::m_fullMapFilename

private

Initial value:

{
    this,
    "FullMapFile",
    "MagneticFieldMaps/bfieldmap_7730_20400_14m.root",
    "File storing the full magnetic field map"
  }

map file names - if not read from cool

Definition at line 73 of file AtlasFieldMapCondAlg.h.

m_loadMapOnStart

Gaudi::Property<bool> MagField::AtlasFieldMapCondAlg::m_loadMapOnStart

private

Initial value:

{
    this,
    "LoadMapOnStart",
    false,
    "Load the magnetic field map at start"
  }

Definition at line 116 of file AtlasFieldMapCondAlg.h.

m_mapCondObjOutputKey

SG::WriteCondHandleKey<AtlasFieldMapCondObj> MagField::AtlasFieldMapCondAlg::m_mapCondObjOutputKey

private

Initial value:

{
    this,
    "AtlasFieldMapCondObj",
    "fieldMapCondObj",
    "Name of key for the Magnetic Field conditions object with the map file "
    "names"
  }

Definition at line 142 of file AtlasFieldMapCondAlg.h.

m_mapsInputKey

SG::ReadCondHandleKey<CondAttrListCollection> MagField::AtlasFieldMapCondAlg::m_mapsInputKey

private

Initial value:

{
    this,
    "COOLMapsFolderName",
    "/GLOBAL/BField/Maps",
    "Name of the COOL folder containing field maps"
  }

Definition at line 133 of file AtlasFieldMapCondAlg.h.

m_mapSoleCurrent

Gaudi::Property<double> MagField::AtlasFieldMapCondAlg::m_mapSoleCurrent

private

Initial value:

{ this,
                                            "MapSoleCurrent",
                                            7730.,
                                            "Nominal solenoid current (A)" }

nominal current for the maps

Definition at line 92 of file AtlasFieldMapCondAlg.h.

m_mapToroCurrent

Gaudi::Property<double> MagField::AtlasFieldMapCondAlg::m_mapToroCurrent

private

Initial value:

{ this,
                                            "MapToroCurrent",
                                            20400.,
                                            "Nominal toroid current (A)" }

Definition at line 96 of file AtlasFieldMapCondAlg.h.

m_soleMapFilename

Gaudi::Property<std::string> MagField::AtlasFieldMapCondAlg::m_soleMapFilename

private

Initial value:

{
    this,
    "SoleMapFile",
    "MagneticFieldMaps/bfieldmap_7730_0_14m.root",
    "File storing the solenoid-only magnetic field map"
  }

Definition at line 79 of file AtlasFieldMapCondAlg.h.

m_soleMinCurrent

Gaudi::Property<double> MagField::AtlasFieldMapCondAlg::m_soleMinCurrent

private

Initial value:

{
    this,
    "SoleMinCurrent",
    1.0,
    "Minimum solenoid current (A) for which solenoid is considered ON"
  }

Definition at line 102 of file AtlasFieldMapCondAlg.h.

m_toroMapFilename

Gaudi::Property<std::string> MagField::AtlasFieldMapCondAlg::m_toroMapFilename

private

Initial value:

{
    this,
    "ToroMapFile",
    "MagneticFieldMaps/bfieldmap_0_20400_14m.root",
    "File storing the toroid-only magnetic field map"
  }

Definition at line 85 of file AtlasFieldMapCondAlg.h.

m_toroMinCurrent

Gaudi::Property<double> MagField::AtlasFieldMapCondAlg::m_toroMinCurrent

private

Initial value:

{
    this,
    "ToroMinCurrent",
    1.0,
    "Minimum toroid current (A) for which toroid is considered ON"
  }

Definition at line 108 of file AtlasFieldMapCondAlg.h.

m_useMapsFromCOOL

Gaudi::Property<bool> MagField::AtlasFieldMapCondAlg::m_useMapsFromCOOL

private

Initial value:

{
    this,
    "UseMapsFromCOOL",
    true,
    "Get magnetic field map filenames from COOL"
  }

Definition at line 124 of file AtlasFieldMapCondAlg.h.

m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• AtlasFieldMapCondAlg.h
• AtlasFieldMapCondAlg.cxx