OutputConditionsAlg Class Reference

#include <OutputConditionsAlg.h>

Inheritance diagram for OutputConditionsAlg:

Collaboration diagram for OutputConditionsAlg:

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

Protected Member Functions
virtual bool	isReEntrant () const override final
	Legacy algorithms are not thread-safe.
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
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	buildDescription (const std::string &identifier, const std::string &value, std::string &description) const
StatusCode	splitAddress (const std::string &address, std::string &address_header, std::string &address_data) const
uint64_t	timeToNano (unsigned long int timesec) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< IClassIDSvc >	p_clidsvc {this,"ClassIDSvc","ClassIDSvc"}
ServiceHandle< IIOVRegistrationSvc >	p_regsvc {this, "IOVRegistrationSvc","IOVRegistrationSvc"}
ServiceHandle< IAddressCreator >	m_persSvc {this,"EventPersistencySvc","EventPersistencySvc"}
ToolHandle< IAthenaOutputStreamTool >	m_streamer {this,"StreamName","AthenaOutputStreamTool/ConditionsAlgStream"}
Gaudi::Property< std::vector< std::string > >	m_objectList {this,"ObjectList",{},"List of object to be written","OrderedSet<std::string>"}
Gaudi::Property< bool >	m_par_writeIOV {this,"WriteIOV",true}
Gaudi::Property< std::string >	m_par_crestDir {this,"CrestDir",""}
Gaudi::Property< unsigned int >	m_par_run1 {this,"Run1",IOVTime::MINRUN,"IOV start (run-number)"}
Gaudi::Property< unsigned int >	m_par_lumib1 {this,"LB1",IOVTime::MINEVENT,"IOV start (LB-number)"}
Gaudi::Property< unsigned int >	m_par_run2 {this,"Run2",IOVTime::MAXRUN,"IOV end (run-number),ignored in CREST mode"}
Gaudi::Property< unsigned int >	m_par_lumib2 {this,"LB2",IOVTime::MAXEVENT,"IOV end (LB-number), ignored in CREST mode"}
UnsignedLongProperty	m_par_time1 {this,"Time1",IOVTime::MINTIMESTAMP,"IOV start (timestamp)"}
UnsignedLongProperty	m_par_time2 {this,"Time2",IOVTime::MAXEVENT,"IOV end (timestamp), ignored in CREST mode"}
Gaudi::Property< bool >	m_par_timestamp {this,"UseTime",false,"IOV in second or Run/LB"}
Gaudi::Property< std::vector< std::string > >	m_par_iovtags {this,"IOVTagList",{},"List of Tags to be written","OrderedSet<std::string>"}
Gaudi::Property< std::vector< std::string > >	m_par_tagDescr {this,"TagDescriptionList",{},"Human-readable description for each tag (only for CREST)","OrderedSet<std::string>"}
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

Definition at line 25 of file OutputConditionsAlg.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

~OutputConditionsAlg()

OutputConditionsAlg::~OutputConditionsAlg

(

)

Definition at line 28 of file OutputConditionsAlg.cxx.

{}

Member Function Documentation

AthAlgorithm()

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

Constructor.

Definition at line 31 of file AthAlgorithm.cxx.

                                                       :
  AthCommonAlgorithm<Gaudi::Algorithm>( name, pSvcLocator )
{
  // default cardinality for non-reentrant algorithms
  setProperty( "Cardinality", 1 ).orThrow("Unable to set property 'Cardinality'", name);
}

buildDescription()

void OutputConditionsAlg::buildDescription ( const std::string & identifier, const std::string & value, std::string & description ) const

private

Definition at line 383 of file OutputConditionsAlg.cxx.

                                                                                                                            {
 
  std::string fragment="<"+identifier+">"+value+"<\\"+identifier+">";
  description.insert(0,fragment);
  return;  
}

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 OutputConditionsAlg::execute ( const EventContext & ctx )

virtual

Execute method.

Implements AthAlgorithm.

Definition at line 71 of file OutputConditionsAlg.cxx.

                                                             {
 
  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 & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.cxx.

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

filterPassed()

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

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

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

finalize()

StatusCode OutputConditionsAlg::finalize

(

)

Definition at line 76 of file OutputConditionsAlg.cxx.

                                         {
  ATH_MSG_INFO ("Finalize: preparing to write conditions objects ");
 
  StatusCode sc = m_streamer->connectOutput();
  if (sc.isFailure()) {
    ATH_MSG_ERROR ("Could not connect stream to output");
    return( StatusCode::FAILURE);
  }
  // create list of objects
  
  struct obj_t{
    std::string type;
    std::string key;
    std::string folder;
    std::string tag;
    std::string tagDescr;
    SG::DataProxy* proxy=nullptr;
  };
 
  std::vector<obj_t> objs;
  //Use old-style indexed-based loop because the string-vector properties m_objectList, m_par_iovtags and are index-parallel
  for (unsigned int iobj = 0; iobj < m_objectList.size(); ++iobj) {
    //add a new element and keep reference to it
    obj_t& objt=objs.emplace_back();
    const std::string& objStr = m_objectList[iobj];
    objt.tag = iobj < m_par_iovtags.size() ? m_par_iovtags[iobj] : "";
    objt.tagDescr = iobj < m_par_tagDescr.size() ? m_par_tagDescr[iobj] : "";
 
    //Object-string definition: typename#key#folder (where key and folder are optional)
    //split object-string by '#' 
    auto hashSplit = std::ranges::views::split(objStr,std::string_view("#"));
    for (const auto [iHash, ss] : std::views::enumerate(hashSplit)) {
      switch(iHash) {
        case 0:
          objt.type=std::string_view(ss);
          break;
        case 1: 
          objt.key=std::string_view(ss);
          break;
        case 2:
          objt.folder=std::string_view(ss);
          break;
        default:
          ATH_MSG_ERROR("Ill-formed object list " << objStr);
          ATH_MSG_ERROR("Expect format typename#key#folder (where key and folder are optional)");
          return StatusCode::FAILURE;
      }
    }
 
    CLID clid;
    ATH_CHECK(p_clidsvc->getIDOfTypeName(objt.type, clid));
    if (objt.key.empty()) {
      //Try to get Key from proxy:
      objt.proxy = detStore()->proxy(clid);
      if (!objt.proxy) {
        ATH_MSG_ERROR("Could not get default proxy for CLID {}, typename {}",clid,objt.type);
        return StatusCode::FAILURE;
      }
      objt.key = objt.proxy->name();
    }
    else {
      objt.proxy = detStore()->proxy(clid, objt.key);
      if (!objt.proxy) {
        ATH_MSG_ERROR("Could not get proxy for CLID {}, typename {}, key {}",clid,objt.type,objt.key);
        return StatusCode::FAILURE;
      }
 
    }
 
    if (objt.folder.empty()) {
      objt.folder=objt.key;
    }
 
  } //end loop over m_objectList
 
  // list out all typename/key pairs to be written and construct TypeKeyPairs for the streamer
  const size_t nObjects = objs.size();
  IAthenaOutputStreamTool::TypeKeyPairs typeKeys;
  ATH_MSG_INFO("Identified a total of " << nObjects << " objects to write out:");
  // leave now if nothing to write
  if (nObjects == 0)
    return StatusCode::SUCCESS;
 
  for (unsigned i=1;const obj_t& objt : objs) {
    typeKeys.emplace_back(std::make_pair(objt.type, objt.key));
    ATH_MSG_INFO("{}: {}#{}#{}",i++,objt.type,objt.key,objt.folder);
  }
   
 
  // stream output (write objects)
  sc = m_streamer->streamObjects(typeKeys);
  if (sc.isFailure()) {
    ATH_MSG_ERROR("Could not stream out objects");
    return StatusCode::FAILURE;
  }
  // commit output
  sc = m_streamer->commitOutput();
  if (sc.isFailure()) {
    ATH_MSG_ERROR("Could not commit output stream");
    return StatusCode::FAILURE;
  }
  ATH_MSG_INFO("Written {} objects to output stream",nObjects);
 
  if (m_par_writeIOV) {
    // ======== COOL writing part (legacy) ===========:
 
    if (m_par_crestDir.empty()) {
      msg() << MSG::INFO << "Register objects in IOV database, interval of validity ";
      if (m_par_timestamp) {
        msg() << std::format("[time] from [ {} ] to [ {} ]", m_par_time1.value(), m_par_time2.value()) << endmsg;
      } else {
        msg() << std::format("[run,LB] from [ {}, {} ] to [ {}, {} ]",m_par_run1.value(),m_par_lumib1.value(),m_par_run2.value(), m_par_lumib2.value()) << endmsg;
      }
      int nreg = 0;
      for (const obj_t& objt : objs) {
        ATH_MSG_INFO("Register object {}#{} in IOV database folder {} {}", objt.type, objt.key, objt.folder,
                                 objt.tag.size() ? "with tag " + objt.tag : "without tagging");
        if (m_par_timestamp) {
          sc = p_regsvc->registerIOV(objt.type, objt.key, objt.folder, objt.tag, timeToNano(m_par_time1), timeToNano(m_par_time2));
        } else {
          sc = p_regsvc->registerIOV(objt.type, objt.key, objt.folder, objt.tag, m_par_run1, m_par_run2, m_par_lumib1, m_par_lumib2);
        }
        if (sc == StatusCode::SUCCESS) {
          ++nreg;
        } else {
          ATH_MSG_ERROR("Registration failed!");
        }
      }
      ATH_MSG_INFO("Registered " << nreg << " objects in COOL IOV database");
    } else {
      // ======== CREST writing part ===========:
 
      ATH_MSG_INFO("Opening crest local directroy " << m_par_crestDir);
      chai::Database db = chai::Database("crest_fs:" + m_par_crestDir);
      // Create a global tag. Simplifes reading this local crest dir by athena
      const std::string globalTagName = "GlobalTestTag";
      chai::GlobalTagPtr gt;
      std::vector<std::string> existingGlobalTags;
      try {
        existingGlobalTags = db.findGlobalTags(globalTagName);
      }
      catch (std::exception& e) {
        //no global tag exists, not a problem
      } 
      if (existingGlobalTags.empty()) {
        gt = db.createGlobalTag("GlobalTestTag", "test", "test");    
        ATH_MSG_INFO("Created Global Tag for testing (" << globalTagName << ") in " << m_par_crestDir);
      } else {
        gt = db.getGlobalTag(globalTagName);
        ATH_MSG_INFO("Global Tag for testing (" << globalTagName << ") exists already in " << m_par_crestDir);
      }
 
      // Some of the code here is taken from RegistrationSvc. Once we deprecate COOL, we can also delete (I)RegistrationSvc
      std::string address_data;
      // Loop over objects  ....
      for (const obj_t& objt : objs) {
        chai::TagIovType iovType;
        uint64_t since;
        if (m_par_timestamp) {
          iovType = chai::Tag::IovType::Time;
          since = timeToNano(m_par_time1);
        } else {
          iovType = chai::Tag::IovType::RunNumberLumiBlock;
          since = (static_cast<std::uint64_t>(m_par_run1.value()) << 32 )+ m_par_lumib1;
        }
        const CLID clid = objt.proxy->clID();
 
        //ATH_MSG_INFO("Working on object clid " << clid << ", " << objt.folder << " " << objt.type << " " << objt.key);
        ATH_MSG_INFO("Working on object clid {}, type {}, folder {}",clid, objt.type, objt.folder);
        // First, deal with teh folder description:
        std::string description;
        if (clid == 40774348 || clid == 1238547719) {
          // AthenaAttibuteList or CondAttrListCollection. The description can be build by chai ...
          description = chai::Tag::buildNodeDescription(iovType, objt.type, clid);
        } else {
          // Pool referenced storage, need to build the node description by ourselves
          IOpaqueAddress* addr = objt.proxy->address();
          if (!addr) {
            ATH_MSG_ERROR("No IOpaqueAddress from Type/Key [{}/{}]",objt.type,objt.key);
            return StatusCode::FAILURE;
          }
          std::string saddr;
          ATH_CHECK(m_persSvc->convertAddress(addr, saddr));
          // Split the string address into header and data parts
          std::string address_header;
 
          if (splitAddress(saddr, address_header, address_data).isFailure()) {
            ATH_MSG_ERROR("Could not split address: {}\n  hdr:  {}\n  data: {}",saddr,address_header,address_data);
            return StatusCode::FAILURE;
          }
          ATH_MSG_DEBUG("split address: {}\n  hdr:  {}\n  data: {}",saddr,address_header,address_data);
          // We store extra information in the folder description.
          // This info is:
          //   typeName       - required information
          //   symlinks       - the extra StoreGate keys, if any
          //   key            - optional, only needed if key != folder name
          //   timeStamp      - either run-lumi (default) or time
          //   address_header - added by convention
          //
          //
          // The convention is that the address_header is stored
          // in the description, and the IOV interval data
          // payload is just the pool reference in string form.
          // The address_header and address_data can be obtained
          // from the string address returned from the
          // persistency service, using splitAddress
 
          // Add symlinks (actually base-class types):
          std::string symLinkTypes;
          for (const CLID& c : objt.proxy->transientID()) {
            if (c != clid) {
              std::string symType;
              ATH_CHECK(p_clidsvc->getTypeNameOfID(c, symType));
              if (!symLinkTypes.empty())
                symLinkTypes += ":";  // Separate type names by colons
              symLinkTypes.append(symType);
            }
          }  // end loop over transientIDs
          if (!symLinkTypes.empty()) {
            buildDescription("symLink", symLinkTypes, description);
          }
 
          // IOV type:
          if (iovType == chai::Tag::IovType::Time) {
            buildDescription("timeStamp", "time", description);
          } else {
            buildDescription("timeStamp", "run-lumi", description);
          }
 
          // Address header:
          buildDescription("addrHeader", address_header, description);
 
          // SG key if needed:
          if (objt.key != objt.folder) {
            buildDescription("key", objt.key, description);
          }
        }  // end if POOL referenced storage
        static const std::string crestObjTypeStr{"crest-json-single-iov"};
        chai::Tag::Metadata chaiMD{.iovType = iovType,
                                   .objectType = crestObjTypeStr,
                                   .synchronization = chai::Tag::Synchronization::All,
                                   .status = chai::Tag::Status::Unlocked,
                                   .nodeDescription = std::move(description)};
 
        
 
        // Description and metadat ready, now deal with the payload
        IOpaqueAddress* addr = objt.proxy->address();
 
        CondAttrListCollAddress* collAddr = dynamic_cast<CondAttrListCollAddress*>(addr);
        if (collAddr) {
 
          // Multi-channel inline storage or multi-channel POOL storage
          const CondAttrListCollection* attrListColl = collAddr->attrListColl();
          // convert to multi-channel chai::container and ....
          chai::Container chaiCont=ChaiCoralConverter::toContainer(*attrListColl);
          ATH_MSG_INFO("Created chai container with " << chaiCont.numChannels() << " channels.");
          const chai::PayloadSpec& chaiSpec=chaiCont.payloadSpec();
          auto chaiTag=db.createTag(objt.tag, objt.tagDescr, chaiSpec,chaiMD);
          chaiTag->addPayload(chaiCont,since);
 
 
        } else if (clid == 40774348) { 
          // Attribute list (single-channel inline).. retrieve from detStore
 
          const AthenaAttributeList* attrList;
          ATH_CHECK(detStore()->retrieve(attrList, objt.key));
          // convert to single-channel chai::container
          chai::Container chaiCont=ChaiCoralConverter::toContainer(*attrList);
          const chai::PayloadSpec& chaiSpec=chaiCont.payloadSpec();
          auto chaiTag=db.createTag(objt.tag, objt.tagDescr, chaiSpec,chaiMD);
          gt->addTag(objt.folder,objt.tag); 
          chaiTag->addPayload(chaiCont,since);
        } else {
 
          //Single channel pool storage case:
          chai::PayloadSpec spec(chai::FieldSpec({{"PoolRef", chai::Type::String}}), chai::ChannelSpec({{0, ""}}));
          auto tag = db.createTag(objt.tag, objt.tagDescr, spec,chaiMD);
          gt->addTag(objt.folder, objt.tag);
          chai::Container container = tag->buildContainer();
          container[0].push(address_data);
          //With chai 3.0.0 the line above becomes: 
          //container.set(0,"PoolRef",address_data);
          tag->addPayload(container, since);
 
        }  // end else single-channel pool storage
      }  // end loop over objects
      ATH_MSG_INFO("Registered " << objs.size() << " objects in CREST IOV database");
    }  // end if write crest
  }  // end doWriteIOV
  else {
    ATH_MSG_INFO("Objects NOT registered in IOV database");
  }
  return StatusCode::SUCCESS;
}

initialize()

StatusCode OutputConditionsAlg::initialize

(

)

Definition at line 32 of file OutputConditionsAlg.cxx.

                                           {
  ATH_MSG_DEBUG ("in initialize()");
 
  // get pointer to ClassIDSvc
  if (StatusCode::SUCCESS!= p_clidsvc.retrieve()) {
    ATH_MSG_FATAL ("ClassIDSvc not found");
    return StatusCode::FAILURE;
  }
  if (m_par_writeIOV && m_par_crestDir.empty()) {
    // get pointer to IOVRegistrationSvc
    if (StatusCode::SUCCESS!=p_regsvc.retrieve()) {
      ATH_MSG_FATAL ("IOVRegistrationSvc not found");
      return StatusCode::FAILURE;
    }
  }
 
  StatusCode sc = m_streamer.retrieve();
  if (sc.isFailure()) {
    ATH_MSG_ERROR ("Unable to retrieve AthenaOutputStreamTool " << m_streamer); 
    return StatusCode::FAILURE;
  }  
 
  if (!m_par_crestDir.empty()) {
     //CREST mode:
     ATH_CHECK(m_persSvc.retrieve()); 
    //Sanity check of properties, m_object list and m_par_iovtags need to be index parallel
    if (m_objectList.size() > m_par_iovtags.size()) {
      ATH_MSG_ERROR("CREST mode: Database tag required for each object");
      for (size_t i= m_objectList.size()-m_par_iovtags.size();i<m_objectList.size();++i) {
        ATH_MSG_ERROR ("  No database tag set for object " << m_objectList[i]);
      }
      return StatusCode::FAILURE;
    }
  }
 
  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()

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

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

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

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

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const

inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 47 of file AthAlgorithm.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.

renounce()

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

inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

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

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

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

inlinevirtualinherited

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

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

splitAddress()

StatusCode OutputConditionsAlg::splitAddress ( const std::string & address, std::string & address_header, std::string & address_data ) const

private

Definition at line 390 of file OutputConditionsAlg.cxx.

                                                                                                                               {
  // Deals with address of form
  // <address_header service_type="256" clid="1238547719" /> POOLContainer_CondAttrListCollection][CLID=x
  // return header as part up to and including />, trailer as rest
 
  std::string::size_type p1 = address.find(" />");
  if (p1 != std::string::npos) {
    address_header = address.substr(0, p1 + 3);
    address_data = address.substr(p1 + 4);
    return StatusCode::SUCCESS;
  } else {
    return StatusCode::FAILURE;
  }
}

sysExecute()

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

overridevirtualinherited

Execute an algorithm.

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

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

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

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

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

Definition at line 60 of file AthCommonAlgorithm.cxx.

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

timeToNano()

uint64_t OutputConditionsAlg::timeToNano ( unsigned long int timesec ) const

private

Definition at line 372 of file OutputConditionsAlg.cxx.

{
  // convert time specified in seconds to ns used by COOL
  // use the magic value MAXEVENT to signal full range
  if (timesec==IOVTime::MAXEVENT) {
    return IOVTime::MAXTIMESTAMP;
  } else {
    return static_cast<uint64_t>(timesec)*1000000000;
  }
}

updateVHKA()

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

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_detStore

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

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_evtStore

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

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_objectList

Gaudi::Property<std::vector<std::string> > OutputConditionsAlg::m_objectList {this,"ObjectList",{},"List of object to be written","OrderedSet<std::string>"}

private

Definition at line 45 of file OutputConditionsAlg.h.

{this,"ObjectList",{},"List of object to be written","OrderedSet<std::string>"};

m_par_crestDir

Gaudi::Property<std::string> OutputConditionsAlg::m_par_crestDir {this,"CrestDir",""}

private

Definition at line 47 of file OutputConditionsAlg.h.

{this,"CrestDir",""};

m_par_iovtags

Gaudi::Property<std::vector<std::string> > OutputConditionsAlg::m_par_iovtags {this,"IOVTagList",{},"List of Tags to be written","OrderedSet<std::string>"}

private

Definition at line 55 of file OutputConditionsAlg.h.

{this,"IOVTagList",{},"List of Tags to be written","OrderedSet<std::string>"};

m_par_lumib1

Gaudi::Property<unsigned int> OutputConditionsAlg::m_par_lumib1 {this,"LB1",IOVTime::MINEVENT,"IOV start (LB-number)"}

private

Definition at line 49 of file OutputConditionsAlg.h.

{this,"LB1",IOVTime::MINEVENT,"IOV start (LB-number)"};

m_par_lumib2

Gaudi::Property<unsigned int> OutputConditionsAlg::m_par_lumib2 {this,"LB2",IOVTime::MAXEVENT,"IOV end (LB-number), ignored in CREST mode"}

private

Definition at line 51 of file OutputConditionsAlg.h.

{this,"LB2",IOVTime::MAXEVENT,"IOV end (LB-number), ignored in CREST mode"};

m_par_run1

Gaudi::Property<unsigned int> OutputConditionsAlg::m_par_run1 {this,"Run1",IOVTime::MINRUN,"IOV start (run-number)"}

private

Definition at line 48 of file OutputConditionsAlg.h.

{this,"Run1",IOVTime::MINRUN,"IOV start (run-number)"};

m_par_run2

Gaudi::Property<unsigned int> OutputConditionsAlg::m_par_run2 {this,"Run2",IOVTime::MAXRUN,"IOV end (run-number),ignored in CREST mode"}

private

Definition at line 50 of file OutputConditionsAlg.h.

{this,"Run2",IOVTime::MAXRUN,"IOV end (run-number),ignored in CREST mode"};

m_par_tagDescr

Gaudi::Property<std::vector<std::string> > OutputConditionsAlg::m_par_tagDescr {this,"TagDescriptionList",{},"Human-readable description for each tag (only for CREST)","OrderedSet<std::string>"}

private

Definition at line 56 of file OutputConditionsAlg.h.

{this,"TagDescriptionList",{},"Human-readable description for each tag (only for CREST)","OrderedSet<std::string>"};

m_par_time1

UnsignedLongProperty OutputConditionsAlg::m_par_time1 {this,"Time1",IOVTime::MINTIMESTAMP,"IOV start (timestamp)"}

private

Definition at line 52 of file OutputConditionsAlg.h.

{this,"Time1",IOVTime::MINTIMESTAMP,"IOV start (timestamp)"};

m_par_time2

UnsignedLongProperty OutputConditionsAlg::m_par_time2 {this,"Time2",IOVTime::MAXEVENT,"IOV end (timestamp), ignored in CREST mode"}

private

Definition at line 53 of file OutputConditionsAlg.h.

{this,"Time2",IOVTime::MAXEVENT,"IOV end (timestamp), ignored in CREST mode"};

m_par_timestamp

Gaudi::Property<bool> OutputConditionsAlg::m_par_timestamp {this,"UseTime",false,"IOV in second or Run/LB"}

private

Definition at line 54 of file OutputConditionsAlg.h.

{this,"UseTime",false,"IOV in second or Run/LB"};

m_par_writeIOV

Gaudi::Property<bool> OutputConditionsAlg::m_par_writeIOV {this,"WriteIOV",true}

private

Definition at line 46 of file OutputConditionsAlg.h.

{this,"WriteIOV",true};

m_persSvc

ServiceHandle<IAddressCreator> OutputConditionsAlg::m_persSvc {this,"EventPersistencySvc","EventPersistencySvc"}

private

Definition at line 40 of file OutputConditionsAlg.h.

{this,"EventPersistencySvc","EventPersistencySvc"};

m_streamer

ToolHandle<IAthenaOutputStreamTool> OutputConditionsAlg::m_streamer {this,"StreamName","AthenaOutputStreamTool/ConditionsAlgStream"}

private

Definition at line 43 of file OutputConditionsAlg.h.

{this,"StreamName","AthenaOutputStreamTool/ConditionsAlgStream"};

m_varHandleArraysDeclared

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

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

p_clidsvc

ServiceHandle<IClassIDSvc> OutputConditionsAlg::p_clidsvc {this,"ClassIDSvc","ClassIDSvc"}

private

Definition at line 38 of file OutputConditionsAlg.h.

{this,"ClassIDSvc","ClassIDSvc"};

p_regsvc

ServiceHandle<IIOVRegistrationSvc> OutputConditionsAlg::p_regsvc {this, "IOVRegistrationSvc","IOVRegistrationSvc"}

private

Definition at line 39 of file OutputConditionsAlg.h.

{this, "IOVRegistrationSvc","IOVRegistrationSvc"};

---

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

• OutputConditionsAlg.h
• OutputConditionsAlg.cxx