IOVDbCrestTag Class Reference

#include <IOVDbCrestTag.h>

Inheritance diagram for IOVDbCrestTag:

Collaboration diagram for IOVDbCrestTag:

Classes
struct	Resident

Public Types
enum class	source_t { COOLDB =0 , CRESTDB }

Public Member Functions
	IOVDbCrestTag (IOVDbConn *conn, const IOVDbParser &folderprop, MsgStream &msg, IClassIDSvc *clidsvc, IIOVDbMetaDataTool *metadatatool, chai::Database &db, const std::string &crestTagName)
	~IOVDbCrestTag ()
const std::string &	key () const override
const source_t &	source () const override
IOVDbConn *	conn () override
bool	multiVersion () const override
bool	timeStamp () const override
bool	tagOverride () const override
bool	retrieved () const override
bool	noOverride () const override
IOVDbNamespace::FolderType	folderType () const override
bool	readMeta () const override
bool	writeMeta () const override
bool	fromMetaDataOnly () const override
bool	extensible () const override
bool	dropped () const override
bool	iovOverridden () const override
const std::string &	joTag () const override
const std::string &	resolvedTag () const override
const std::string &	eventStore () const override
CLID	clid () const override
unsigned long long	bytesRead () const override
float	readTime () const override
const IOVRange &	currentRange () const override
void	useFileMetaData () override
void	setFolderDescription (const std::string &description) override
void	setTagOverride (const std::string &tag, const bool setFlag) override
void	setWriteMeta () override
void	setIOVOverride (const unsigned int run, const unsigned int lumiblock, const unsigned int time) override
void	setDropped (const bool dropped) override
cool::ValidityKey	iovTime (const IOVTime &reftime) const override
bool	isResident (const cool::ValidityKey reftime) const override
bool	loadAt (const cool::ValidityKey vkey) override
void	reset () override
bool	getAddress (const cool::ValidityKey reftime, IAddressCreator *persSvc, const unsigned int poolSvcContext, std::unique_ptr< IOpaqueAddress > &address, IOVRange &range, bool &poolPayloadRequested) override
void	summary () override
std::unique_ptr< SG::TransientAddress >	preload (ITagInfoMgr *tagInfoMgr, const unsigned int cacheRun, const unsigned int cacheTime) override
std::string	dumpChannelsAsJson (cool::ValidityKey reftime) const
void	printState () override
bool	loadCacheIfDbChanged (const cool::ValidityKey vkey, const cool::IDatabasePtr &dbPtr, const ServiceHandle< IIOVSvc > &iovSvc) override
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.
const std::string &	folderName () const

Protected Attributes
std::string	m_foldername
	Folder name, as it appears in COOL or as a CREST tag label.
std::string	m_key
	SG key where data is loaded (unique).

Private Member Functions
IOVDbNamespace::FolderType	determineFolderType () const
std::unique_ptr< SG::TransientAddress >	createTransientAddress (const std::vector< std::string > &symlinks)
bool	addMetaAttrList (const coral::AttributeList &atrlist, const IOVRange &range)
bool	addMetaAttrListColl (const CondAttrListCollection *coll)
bool	channelInSelection (cool::ChannelId chan) const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
IClassIDSvc *	p_clidSvc {nullptr}
IIOVDbMetaDataTool *	p_metaDataTool {nullptr}
IOVDbConn *	m_conn {nullptr}
	Unused for CREST I/O; kept for per-connection usage counting.
chai::Database *	m_db {nullptr}
	Non-owning pointer to the shared chai::Database.
chai::TagPtr	m_tag
	Resolved in preload(). Stays null for a metadata-only folder.
std::string	m_folderDescription
bool	m_timestamp {false}
	Indexed by timestamp (else runLB), from tag->getIovType().
bool	m_tagoverride {false}
	Unused on the CREST path. Present to satisfy IOVDbConditionsSource.
bool	m_notagoverride {false}
	Unused on the CREST path. Present to satisfy IOVDbConditionsSource.
bool	m_writemeta {false}
bool	m_useFileMetaData {false}
bool	m_fromMetaDataOnly {false}
bool	m_extensible {false}
bool	m_named {false}
bool	m_iovoverridden {false}
bool	m_jokey {false}
bool	m_dropped {false}
cool::ValidityKey	m_iovoverride {0}
IOVDbNamespace::FolderType	m_foldertype {IOVDbNamespace::UNKNOWN}
std::string	m_jotag
	Explicit <tag>/<ctag> from job options. Used only for /TagInfo.
std::string	m_resolvedTagName
	The CREST tag name actually used for lookup.
std::string	m_eventstore
std::string	m_addrheader
std::string	m_typename
CLID	m_clid {0}
unsigned int	m_ncacheread {0}
unsigned int	m_ndbread {0}
unsigned int	m_nobjread {0}
unsigned long long	m_nbytesread {0}
float	m_readtime {0}
unsigned int	m_nchan {0}
std::vector< cool::ChannelId >	m_channums
std::vector< std::string >	m_channames
std::vector< std::pair< cool::ChannelId, cool::ChannelId > >	m_chanrange
bool	m_retrieved {false}
IOVRange	m_currange
coral::AttributeListSpecification *	m_cachespec {nullptr}
std::optional< Resident >	m_resident
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

Definition at line 51 of file IOVDbCrestTag.h.

Member Enumeration Documentation

source_t

enum class IOVDbConditionsSource::source_t

stronginherited

Enumerator
COOLDB
CRESTDB

Definition at line 36 of file IOVDbConditionsSource.h.

                      {
    COOLDB=0,
    CRESTDB,
  };

Constructor & Destructor Documentation

IOVDbCrestTag()

IOVDbCrestTag::IOVDbCrestTag	(	IOVDbConn *	conn,
		const IOVDbParser &	folderprop,
		MsgStream &	msg,
		IClassIDSvc *	clidsvc,
		IIOVDbMetaDataTool *	metadatatool,
		chai::Database &	db,
		const std::string &	crestTagName )

Definition at line 43 of file IOVDbCrestTag.cxx.

                                                                             :
  AthMessaging("IOVDbCrestTag"),
  p_clidSvc(clidsvc),
  p_metaDataTool(metadatatool),
  m_conn(conn),
  m_db(&db),
  m_resolvedTagName(crestTagName)
{
  setLevel(msg.level());
  m_foldername = folderprop.folderName();
  m_key = folderprop.key();
  m_jokey = folderprop.hasKey();
  m_eventstore = folderprop.eventStoreName();
  m_notagoverride = folderprop.noTagOverride();
  ATH_MSG_DEBUG("Created CREST folder " << m_foldername << " tag " << m_resolvedTagName);
  if (m_notagoverride) {
    ATH_MSG_INFO("Inputfile tag override disabled for " << m_foldername);
  }
 
  // <tag> is not used to resolve the CREST tag but is still recorded into
  // m_jotag for fillTagInfo(). <ctag> is the fallback when there is no <tag>.
  if (!folderprop.tag().empty()) {
    ATH_MSG_INFO("<tag> is ignored on the CREST path for folder " << m_foldername
                 << ". Use <ctag> to override the CREST tag name instead");
    m_jotag = IOVDbNamespace::spaceStrip(folderprop.tag());
  } else {
    std::string ctag;
    if (folderprop.getKey("ctag","",ctag) && !ctag.empty()) {
      m_jotag = IOVDbNamespace::spaceStrip(ctag);
    }
  }
 
  // No CHAI equivalent of COOL's server-side channelSelection. Parsed here
  // and applied client-side by channelInSelection().
  std::string chanspec;
  if (folderprop.getKey("channelSelection","",chanspec) && !chanspec.empty()) {
    m_chanrange = IOVDbNamespace::parseChannelSpec<cool::ChannelId>(chanspec);
  }
 
  if (folderprop.overridesIov(msg)) {
    m_iovoverridden = true;
    m_iovoverride = folderprop.iovOverrideValue(msg);
  }
 
  m_fromMetaDataOnly = folderprop.onlyReadMetadata();
  if (m_fromMetaDataOnly) {
    ATH_MSG_INFO("Read from meta data only for folder " << m_foldername);
  }
 
  m_extensible = folderprop.extensible();
  if (m_extensible) {
    ATH_MSG_INFO("Extensible folder " << m_foldername);
  }
}

~IOVDbCrestTag()

IOVDbCrestTag::~IOVDbCrestTag

(

)

Definition at line 100 of file IOVDbCrestTag.cxx.

                              {
  if (m_cachespec != nullptr) {
    m_cachespec->release();
  }
}

Member Function Documentation

addMetaAttrList()

bool IOVDbCrestTag::addMetaAttrList ( const coral::AttributeList & atrlist, const IOVRange & range )

private

Definition at line 451 of file IOVDbCrestTag.cxx.

                                                                                            {
  CondAttrListCollection tmpColl(!m_timestamp);
  tmpColl.add(0xFFFF, atrlist);
  tmpColl.add(0xFFFF, range);
  return addMetaAttrListColl(&tmpColl);
}

addMetaAttrListColl()

bool IOVDbCrestTag::addMetaAttrListColl ( const CondAttrListCollection * coll )

private

Definition at line 458 of file IOVDbCrestTag.cxx.

                                                                          {
  if (!coll) {
    return false;
  }
  CondAttrListCollection* flmdColl = new CondAttrListCollection(*coll);
  if (StatusCode::SUCCESS != p_metaDataTool->addPayload(m_foldername, flmdColl)) {
    ATH_MSG_ERROR("addMetaAttrList: Failed to write metadata for folder " << m_foldername);
    return false;
  }
  ATH_MSG_DEBUG("addMetaAttrList: write metadata for folder " << m_foldername);
  return true;
}

bytesRead()

unsigned long long IOVDbCrestTag::bytesRead ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 263 of file IOVDbCrestTag.h.

{ return m_nbytesread; }

channelInSelection()

bool IOVDbCrestTag::channelInSelection ( cool::ChannelId chan ) const

private

Definition at line 471 of file IOVDbCrestTag.cxx.

                                                               {
  if (m_chanrange.empty()) {
    return true;
  }
  for (const auto& range : m_chanrange) {
    if (chan >= range.first && chan <= range.second) {
      return true;
    }
  }
  return false;
}

clid()

CLID IOVDbCrestTag::clid ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 261 of file IOVDbCrestTag.h.

{ return m_clid; }

conn()

IOVDbConn * IOVDbCrestTag::conn ( )

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 225 of file IOVDbCrestTag.h.

{ return m_conn; }

createTransientAddress()

std::unique_ptr< SG::TransientAddress > IOVDbCrestTag::createTransientAddress ( const std::vector< std::string > & symlinks )

private

Definition at line 191 of file IOVDbCrestTag.cxx.

                                                                          {
  auto tad = std::make_unique<SG::TransientAddress>(m_clid, m_key);
  for (const auto& linkname : symlinks) {
    if (not linkname.empty()) {
      CLID sclid = 0;
      if (StatusCode::SUCCESS == p_clidSvc->getIDOfTypeName(linkname, sclid)) {
        tad->setTransientID(sclid);
        ATH_MSG_DEBUG("Setup symlink " << linkname << " CLID " << sclid << " for folder " << m_foldername);
      } else {
        ATH_MSG_ERROR("Could not get clid for symlink: " << linkname);
        return nullptr;
      }
    }
  }
  return tad;
}

currentRange()

const IOVRange & IOVDbCrestTag::currentRange ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 267 of file IOVDbCrestTag.h.

{ return m_currange; }

determineFolderType()

IOVDbNamespace::FolderType IOVDbCrestTag::determineFolderType ( ) const

private

Definition at line 157 of file IOVDbCrestTag.cxx.

                                                                  {
  // Check for CoraCool (not supported in CREST)
  if (m_folderDescription.find("<coracool>") != std::string::npos) {
    ATH_MSG_FATAL("Folder " << m_foldername << " is CoraCool and is not representable with CREST");
    return IOVDbNamespace::UNKNOWN;
  }
 
  const std::string typeName = IOVDbNamespace::parseTypename(m_folderDescription);
 
  // If the type is CondAttrListVec, and is not CoraCool, it must be a CoolVector
  if (typeName == "CondAttrListVec") {
    return IOVDbNamespace::CoolVector;
  }
 
  // A string type "PoolRef" column in field 0 indicates a POOL-compatible tag
  const auto& fields = m_tag->getFieldSpec();
  const bool poolCompatible = ((fields.size() > 0) && (fields[0].name == "PoolRef") &&
                               (fields[0].type == chai::String));
  if (poolCompatible) {
    const auto& channels = m_tag->getChannelSpec().channels();
    const bool onlyChannelZero = (channels.size() == 1 && channels[0].id == 0);
    return onlyChannelZero ? IOVDbNamespace::PoolRef : IOVDbNamespace::PoolRefColl;
  }
 
  // CondAttrListCollection -> AttrListColl
  if (typeName == "CondAttrListCollection") {
    return IOVDbNamespace::AttrListColl;
  }
 
  // Otherwise  AttrList
  return IOVDbNamespace::AttrList;
}

dropped()

bool IOVDbCrestTag::dropped ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 251 of file IOVDbCrestTag.h.

{ return m_dropped; }

dumpChannelsAsJson()

std::string IOVDbCrestTag::dumpChannelsAsJson

(

cool::ValidityKey

reftime

)

const

Definition at line 697 of file IOVDbCrestTag.cxx.

                                                                         {
  std::ostringstream os;
  os << "[";
  std::string sep;
  if (isResident(reftime) && !std::holds_alternative<std::monostate>(m_resident->payload)) {
    const cool::ValidityKey since = m_resident->since;
    const cool::ValidityKey until = m_resident->until;
    if (m_foldertype == CoolVector) {
      const auto& payloadResult = std::get<chai::PayloadResult<chai::VectorContainer>>(m_resident->payload);
      for (const auto channelId : payloadResult.payload.channelIds()) {
        const auto& rows = payloadResult.payload.rows(channelId);
        if (rows.empty()) {
          continue;
        }
        std::ostringstream payload;
        payload << "[";
        std::string rowSep;
        for (const auto& row : rows) {
          const coral::AttributeList al = ChaiCoralConverter::toAttributeList(*m_cachespec, *row);
          payload << rowSep << IOVDbNamespace::jsonAttributeList(al);
          rowSep = IOVDbNamespace::s_delimiterJson;
        }
        payload << "]";
        os << sep << IOVDbNamespace::s_openJson << "\"" << channelId << "\" : "
           << IOVDbNamespace::s_openJson
           << "\"since\" : " << since << IOVDbNamespace::s_delimiterJson
           << "\"until\" : " << until << IOVDbNamespace::s_delimiterJson
           << "\"payload\" : " << payload.str()
           << IOVDbNamespace::s_closeJson << IOVDbNamespace::s_closeJson;
        sep = IOVDbNamespace::s_delimiterJson;
      }
    } else {
      const auto& payloadResult = std::get<chai::PayloadResult<chai::Container>>(m_resident->payload);
      for (const auto channelId : payloadResult.payload.channelIds()) {
        const coral::AttributeList al =
          ChaiCoralConverter::toAttributeList(*m_cachespec, payloadResult.payload[channelId]);
        os << sep << IOVDbNamespace::s_openJson << "\"" << channelId << "\" : "
           << IOVDbNamespace::s_openJson
           << "\"since\" : " << since << IOVDbNamespace::s_delimiterJson
           << "\"until\" : " << until << IOVDbNamespace::s_delimiterJson
           << "\"payload\" : [" << IOVDbNamespace::jsonAttributeList(al) << "]"
           << IOVDbNamespace::s_closeJson << IOVDbNamespace::s_closeJson;
        sep = IOVDbNamespace::s_delimiterJson;
      }
    }
  }
  os << "]";
  return os.str();
}

eventStore()

const std::string & IOVDbCrestTag::eventStore ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 259 of file IOVDbCrestTag.h.

{ return m_eventstore; }

extensible()

bool IOVDbCrestTag::extensible ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 249 of file IOVDbCrestTag.h.

{ return m_extensible; }

folderName()

const std::string & IOVDbConditionsSource::folderName ( ) const

inlineinherited

Definition at line 62 of file IOVDbConditionsSource.h.

{return m_foldername;};

folderType()

IOVDbNamespace::FolderType IOVDbCrestTag::folderType ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 237 of file IOVDbCrestTag.h.

{ return m_foldertype; }

fromMetaDataOnly()

bool IOVDbCrestTag::fromMetaDataOnly ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 247 of file IOVDbCrestTag.h.

{ return m_fromMetaDataOnly; }

getAddress()

bool IOVDbCrestTag::getAddress ( const cool::ValidityKey reftime, IAddressCreator * persSvc, const unsigned int poolSvcContext, std::unique_ptr< IOpaqueAddress > & address, IOVRange & range, bool & poolPayloadRequested )

overridevirtual

Implements IOVDbConditionsSource.

Definition at line 483 of file IOVDbCrestTag.cxx.

                                                                      {
  ++m_ncacheread;
  std::string strAddress;
  // Owned here until released into the address object below, to avoid leaking in case of failure
  std::unique_ptr<AthenaAttributeList> attrList;
  std::unique_ptr<CondAttrListCollection> attrListColl;
  std::unique_ptr<CondAttrListVec> attrListVec;
 
  // Read from metadata if flag is set
  if (m_useFileMetaData) {
    IOVDbNamespace::SafeReadFromFileMetaData readFromMetaData(m_foldername, p_metaDataTool, reftime, m_timestamp);
    if (not readFromMetaData.isValid()) {
      ATH_MSG_ERROR("read:Could not find IOVPayloadContainer for folder " << m_foldername);
      return false;
    }
    m_foldertype = readFromMetaData.folderType();
    m_nobjread += readFromMetaData.numberOfObjects();
    poolPayloadReq = readFromMetaData.poolPayloadRequested();
    strAddress = readFromMetaData.stringAddress();
    range = readFromMetaData.range();
    attrList.reset(readFromMetaData.attributeList());
    attrListColl.reset(readFromMetaData.attrListCollection());
    ATH_MSG_DEBUG("Read file metadata for folder " << m_foldername << " foldertype is " << m_foldertype);
  }
 
  // Otherwise convert the resident CHAI payload directly
  else {
    if (!m_resident) {
      ATH_MSG_ERROR("No resident payload for folder " << m_foldername << " at IOV " << reftime);
      return false;
    }
    range = IOVDbNamespace::makeRange(m_resident->since, m_resident->until, m_timestamp);
 
    unsigned int nchan = 0;
    std::optional<coral::AttributeList> singleAl;
    try {
      switch (m_foldertype) {
        case AttrList:
        case PoolRef: {
          // A single-channel folder with no payload is an error
          if (std::holds_alternative<std::monostate>(m_resident->payload)) {
            ATH_MSG_ERROR("Empty resident for single-channel folder " << m_foldername);
            return false;
          }
          const auto& payloadResult = std::get<chai::PayloadResult<chai::Container>>(m_resident->payload);
          // Only channel 0 is read, as on the COOL path. Any other populated channel is ignored
          if (!payloadResult.payload.hasChannel(0)) {
            ATH_MSG_ERROR("No channel 0 for single-channel folder " << m_foldername << " currentTime "
                          << reftime << " (" << payloadResult.payload.channelIds().size()
                          << " channels populated)");
            return false;
          }
          nchan = 1;
          // Convert CHAI payload to attribute list
          singleAl.emplace(ChaiCoralConverter::toAttributeList(*m_cachespec, payloadResult.payload[0]));
          if (m_foldertype == AttrList) {
            attrList = std::make_unique<AthenaAttributeList>(*singleAl);
            strAddress = "POOLContainer_AthenaAttributeList][CLID=x";
          } else {
            strAddress = (*singleAl)["PoolRef"].data<std::string>();
          }
          break;
        }
        case AttrListColl:
        case PoolRefColl: {
          attrListColl = std::make_unique<CondAttrListCollection>(!m_timestamp);
          // Empty resident means zero channels. Just leave it empty, matching IOVDbFolder.
          if (!std::holds_alternative<std::monostate>(m_resident->payload)) {
            const auto& payloadResult = std::get<chai::PayloadResult<chai::Container>>(m_resident->payload);
            const auto channelIds = payloadResult.payload.channelIds();
            for (const auto channelId : channelIds) {
              const auto chan = static_cast<cool::ChannelId>(channelId);
              if (!channelInSelection(chan)) {
                continue;
              }
              // Convert each row to an attribute list and add to collection
              attrListColl->addShared(chan, ChaiCoralConverter::toAttributeList(*m_cachespec, payloadResult.payload[channelId]));
              attrListColl->add(chan, range);
              ++nchan;
            }
          }
          if (m_named) {
            auto nitr = m_channames.begin();
            for (auto chitr = m_channums.begin(); chitr != m_channums.end(); ++chitr, ++nitr) {
              attrListColl->add(*chitr, *nitr);
            }
          }
          strAddress = "POOLContainer_CondAttrListCollection][CLID=x";
          break;
        }
        case CoolVector: {
          attrListVec = std::make_unique<CondAttrListVec>(!m_timestamp);
          // Empty resident means zero channels. Just leave it empty, matching IOVDbFolder.
          if (!std::holds_alternative<std::monostate>(m_resident->payload)) {
            const auto& payloadResult = std::get<chai::PayloadResult<chai::VectorContainer>>(m_resident->payload);
            const auto channelIds = payloadResult.payload.channelIds();
            for (const auto channelId : channelIds) {
              const auto chan = static_cast<cool::ChannelId>(channelId);
              if (!channelInSelection(chan)) {
                continue;
              }
              // Convert each set of rows (per channel ID) to an attribute list vec
              const auto rows = ChaiCoralConverter::toAttributeListVec(*m_cachespec, payloadResult.payload.rows(channelId));
              attrListVec->addSlice(range, chan, rows, 0, rows.size());
              ++nchan;
            }
          }
          strAddress = "POOLContainer_CondAttrListVec][CLID=x";
          break;
        }
        default:
          ATH_MSG_ERROR("Unhandled folder type " << m_foldertype << " for folder " << m_foldername);
          return false;
      }
    } catch (const std::exception& e) {
      ATH_MSG_ERROR("Conversion failed for folder " << m_foldername << ": " << e.what());
      return false;
    }
 
    if (m_writemeta && (m_foldertype == AttrList || m_foldertype == PoolRef)) {
      if (!addMetaAttrList(*singleAl, range)) {
        return false;
      }
    }
 
    // CoolVector folders cannot be written to file metadata
    if (m_writemeta && m_foldertype == CoolVector) {
      ATH_MSG_ERROR("Writing of CoolVector folders to file metadata not implemented");
      return false;
    }
 
    // Don't change wording here, getProblemFoldersFromLogs.py relies on this.
    ATH_MSG_DEBUG("Retrieved object: folder " << m_foldername << " at IOV " << reftime
                  << " channels " << nchan << " has range " << range);
  }
 
  m_currange = range;
  m_retrieved = true;
 
  if (m_writemeta && (m_foldertype == AttrListColl || m_foldertype == PoolRefColl)) {
    if (!addMetaAttrListColl(attrListColl.get())) {
      return false;
    }
  }
 
  strAddress = m_addrheader + strAddress;
  IOpaqueAddress* addrp = nullptr;
  if (StatusCode::SUCCESS != persSvc->createAddress(0, 0, strAddress, addrp)) {
    ATH_MSG_ERROR("Could not get IOpaqueAddress from string address " << strAddress);
    return false;
  }
  address = std::unique_ptr<IOpaqueAddress>(addrp);
  GenericAddress* gAddr = dynamic_cast<GenericAddress*>(address.get());
  if (!gAddr) {
    ATH_MSG_ERROR("Could not cast IOpaqueAddress to GenericAddress");
    return false;
  }
  if (m_foldertype == AttrListColl) {
    auto addr = std::make_unique<CondAttrListCollAddress>(*gAddr);
    addr->setAttrListColl(attrListColl.release());
    address = std::move(addr);
  } else if (m_foldertype == PoolRefColl || m_foldertype == PoolRef) {
    auto addr = std::make_unique<CondAttrListCollAddress>(gAddr->svcType(),
                                                          gAddr->clID(), gAddr->par()[0],
                                                          gAddr->par()[1], poolSvcContext,
                                                          gAddr->ipar()[1]);
    if (m_foldertype == PoolRefColl) {
      addr->setAttrListColl(attrListColl.release());
    }
    address = std::move(addr);
    poolPayloadReq = true;
  } else if (m_foldertype == AttrList) {
    auto addr = std::make_unique<AthenaAttrListAddress>(*gAddr);
    addr->setAttrList(attrList.release());
    address = std::move(addr);
  } else if (m_foldertype == CoolVector) {
    auto addr = std::make_unique<CondAttrListVecAddress>(*gAddr);
    addr->setAttrListVec(attrListVec.release());
    address = std::move(addr);
  }
  return true;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

iovOverridden()

bool IOVDbCrestTag::iovOverridden ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 253 of file IOVDbCrestTag.h.

{ return m_iovoverridden; }

iovTime()

cool::ValidityKey IOVDbCrestTag::iovTime ( const IOVTime & reftime ) const

overridevirtual

Implements IOVDbConditionsSource.

Definition at line 146 of file IOVDbCrestTag.cxx.

                                                                   {
  if (m_iovoverridden) {
    return m_iovoverride;
  }
  return (m_timestamp ? reftime.timestamp() : reftime.re_time());
}

isResident()

bool IOVDbCrestTag::isResident ( const cool::ValidityKey reftime ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 269 of file IOVDbCrestTag.h.

                                                                         {
  // Unlike IOVDbFolder::isResident's strict ">", the bounds here are the IOV's
  // own [since, until), so reftime landing on since counts as resident.
  // Otherwise every such vkey forces a redundant CHAI refetch.
  return m_resident && reftime>=m_resident->since && reftime<m_resident->until;
}

joTag()

const std::string & IOVDbCrestTag::joTag ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 255 of file IOVDbCrestTag.h.

{ return m_jotag; }

key()

const std::string & IOVDbCrestTag::key ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 219 of file IOVDbCrestTag.h.

{ return m_key; }

loadAt()

bool IOVDbCrestTag::loadAt ( const cool::ValidityKey vkey )

overridevirtual

Implements IOVDbConditionsSource.

Definition at line 348 of file IOVDbCrestTag.cxx.

                                                              {
  TStopwatch cachetimer;
  // A bad EventInfo timestamp can produce vkey==0xFFFF... which a floor
  // lookup would resolve to the last IOV. Reset to 0 with a warning.
  cool::ValidityKey vkey = requestedVkey;
  if (vkey > cool::ValidityKeyMax) {
    ATH_MSG_WARNING("Requested validity key " << vkey << " is out of range, reset to 0");
    vkey = 0;
  }
  ATH_MSG_DEBUG("Load cache for folder " << m_foldername << " validitykey " << vkey);
 
  m_resident.reset();
 
  // An IOVTime above cool::ValidityKeyMax is invalid so clamp at the max
  const auto clampedKey = [this](uint64_t key, const char* which) {
    if (key > cool::ValidityKeyMax) {
      ATH_MSG_WARNING("CREST " << which << " " << key << " for folder " << m_foldername
                      << " exceeds cool::ValidityKeyMax; clamped");
      return cool::ValidityKeyMax;
    }
    return static_cast<cool::ValidityKey>(key);
  };
 
  unsigned int nchan = 0;
  try {
    // Caches the payload and returns the channel count
    auto storeResident = [this, &clampedKey](auto&& payloadResult) {
      if (m_cachespec == nullptr) {
        m_cachespec = ChaiCoralConverter::toCoralSpec(payloadResult.payload.fieldSpec());
      }
      const unsigned int channelCount = payloadResult.payload.channelIds().size();
      m_nbytesread += ChaiCoralConverter::payloadSize(payloadResult.payload);
      const cool::ValidityKey sinceKey = clampedKey(payloadResult.since, "since");
      const cool::ValidityKey untilKey = payloadResult.until.has_value()
        ? clampedKey(*payloadResult.until, "until") : cool::ValidityKeyMax;
      m_resident = Resident{sinceKey, untilKey, std::move(payloadResult)};
      return channelCount;
    };
 
    // CHAI needs to know if it's a vector or scalar payload to call the correct getXPayloadAt method.
    // This is what actually loads the payload at the desired time and caches it.
    nchan = m_tag->isVectorPayload() ? storeResident(m_tag->getVectorPayloadAt(vkey))
                                     : storeResident(m_tag->getPayloadAt(vkey));
  } catch (const chai::NotFoundError& e) {
    // IOVDbFolder returns an empty collection when a collection-type folder has
    // zero matching objects and when the query time precedes the first IOV.
    // Any other NotFoundError is a real error.
    const bool isCollectionType = (m_foldertype == AttrListColl || m_foldertype == PoolRefColl || m_foldertype == CoolVector);
 
    if (isCollectionType) {
      try {
        // getIovs() is lazy, so begin() fetches only the first page and returns the first element
        auto iovs = m_tag->getIovs(0);
        auto firstIt = iovs.begin();
        if (firstIt != iovs.end() && firstIt->getSince() > vkey) {
          const cool::ValidityKey firstSince = clampedKey(firstIt->getSince(), "first since");
          ATH_MSG_WARNING("No covering IOV for folder " << m_foldername << " validityKey " << vkey
                          << " (tag " << m_resolvedTagName << "'s first IOV starts at "
                          << firstSince << "); treating the folder as empty");
          m_resident = Resident{cool::ValidityKeyMin, firstSince, std::monostate{}};
          ++m_ndbread;
          const float timeinc = cachetimer.RealTime();
          m_readtime += timeinc;
          ATH_MSG_DEBUG("Cache retrieve done for " << m_foldername
                        << " with 0 channels (no coverage) " << "in " << std::fixed << std::setw(8)
                        << std::setprecision(2) << timeinc << " s");
          return true;
        }
      } catch (const std::exception& probeErr) {
        // A failure here is not the empty-collection case. Fall through to the real error below.
        ATH_MSG_DEBUG("Coverage probe for " << m_foldername << " failed: " << probeErr.what());
      }
    }
    ATH_MSG_ERROR("No covering IOV for folder " << m_foldername << " validityKey " << vkey << ": " << e.what());
    reset();
    return false;
  } catch (const chai::Error& e) {
    ATH_MSG_ERROR("CHAI error for folder " << m_foldername << ": " << e.what());
    reset();
    return false;
  } catch (const std::exception& e) {
    ATH_MSG_ERROR("Failed for folder " << m_foldername << ": " << e.what());
    reset();
    return false;
  }
 
  ++m_ndbread;
  m_nobjread += nchan;
  const float timeinc = cachetimer.RealTime();
  m_readtime += timeinc;
  ATH_MSG_DEBUG("Cache retrieve done for " << m_foldername << " with " << nchan
                << " channels stored in " << std::fixed << std::setw(8) << std::setprecision(2)
                << timeinc << " s");
  return true;
}

loadCacheIfDbChanged()

bool IOVDbCrestTag::loadCacheIfDbChanged ( const cool::ValidityKey vkey, const cool::IDatabasePtr & dbPtr, const ServiceHandle< IIOVSvc > & iovSvc )

overridevirtual

Implements IOVDbConditionsSource.

Definition at line 444 of file IOVDbCrestTag.cxx.

                                                                          {
  // COOL-specific online-reload path. No-op for CREST.
  return true;
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

multiVersion()

bool IOVDbCrestTag::multiVersion ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 227 of file IOVDbCrestTag.h.

{ return false; }

noOverride()

bool IOVDbCrestTag::noOverride ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 233 of file IOVDbCrestTag.h.

{ return m_notagoverride; }

preload()

std::unique_ptr< SG::TransientAddress > IOVDbCrestTag::preload ( ITagInfoMgr * tagInfoMgr, const unsigned int cacheRun, const unsigned int cacheTime )

overridevirtual

Implements IOVDbConditionsSource.

Definition at line 209 of file IOVDbCrestTag.cxx.

                                                                                 {
  if (not m_useFileMetaData) {
    if (m_resolvedTagName.empty()) {
      ATH_MSG_FATAL("Folder " << m_foldername << " has no CREST tag and is not read from file metadata");
      return nullptr;
    }
 
    // Attempt to resolve the tag and set the folder description
    try {
      m_tag = m_db->getTag(m_resolvedTagName);
    } catch (const std::exception& e) {
      ATH_MSG_FATAL("Failed to resolve CHAI tag '" << m_resolvedTagName
                    << "' for folder " << m_foldername << ": " << e.what());
      return nullptr;
    }
    m_folderDescription = m_tag->getNodeDescription();
 
    // The tag's IovType is the source of truth for the timebase. Fill in a missing
    // <timeStamp> in the node description, but refuse an existing one on another axis.
    switch (m_tag->getIovType()) {
      case chai::TagIovType::Time:
      case chai::TagIovType::RunNumberLumiBlock: {
        const std::string token = chai::iovTypeToNodeDescTimeStampToken(m_tag->getIovType());
        auto correction = IOVDbNamespace::correctTimeStampElement(m_folderDescription, token);
        // COOL's run-event means run-lumi: a same-axis token is kept as written
        if (correction.status == IOVDbNamespace::TimeStampCorrection::Corrected &&
            chai::timeStampTokenAxis(correction.foundToken) == chai::iovTypeAxis(m_tag->getIovType())) {
          correction.description = m_folderDescription;
          correction.status = IOVDbNamespace::TimeStampCorrection::Unchanged;
        }
        if (correction.status == IOVDbNamespace::TimeStampCorrection::Corrected) {
          ATH_MSG_FATAL("Folder " << m_foldername << "'s CREST description for tag "
                        << m_tag->getName() << " disagrees with the tag's IovType ('"
                        << chai::iovTypeToString(m_tag->getIovType()) << "'); description says '"
                        << m_folderDescription << "', tag's IovType wants '" << token
                        << "'. Fix the description on the CREST server");
          return nullptr;
        } else if (correction.status == IOVDbNamespace::TimeStampCorrection::Inserted) {
          ATH_MSG_INFO("Folder " << m_foldername << "'s CREST description for tag "
                       << m_tag->getName() << " has no <timeStamp> element; inserting '" << token
                       << "' from the tag's IovType");
        }
        m_folderDescription = std::move(correction.description);
        break;
      }
      default:
        ATH_MSG_FATAL("Tag " << m_tag->getName() << " for folder " << m_foldername
                      << " has unsupported IovType '" << chai::iovTypeToString(m_tag->getIovType())
                      << "' (expected 'time' or 'run-lumi')");
        return nullptr;
    }
  }
 
  // Otherwise the folder description was already set from file metadata
  ATH_MSG_DEBUG("Folder description for " << m_foldername << ": " << m_folderDescription);
 
  if (m_writemeta) {
    if (StatusCode::SUCCESS != p_metaDataTool->registerFolder(m_foldername, m_folderDescription)) {
      ATH_MSG_ERROR("Failed to register folder " << m_foldername << " for meta-data write");
      return nullptr;
    }
  }
 
  // Read timestamp-indexing straight from the description string so this
  // works even when no chai::Tag is resolved (a metadata-only folder).
  IOVDbParser folderpar(m_folderDescription, msg());
  m_timestamp = folderpar.timebaseIs_nsOfEpoch();
 
  // Reported here rather than in the constructor because the timebase
  // decides how the override key reads
  if (m_iovoverridden) {
    if (m_timestamp) {
      ATH_MSG_INFO("Override timestamp to " << m_iovoverride << " for folder " << m_foldername);
    } else {
      const auto [run,lumi] = IOVDbNamespace::runLumiFromIovTime(m_iovoverride);
      ATH_MSG_INFO("Override run/LB number to [" << run << ":" << lumi << "] for folder " << m_foldername);
    }
  }
 
  // File metadata carries no CREST tag to derive the timebase from.
  // A missing <timeStamp> defaults to run-lumi and logs a WARNING.
  if (m_useFileMetaData && !folderpar.at("timeStamp").second) {
    ATH_MSG_WARNING("Folder " << m_foldername
                    << "'s file metadata has no <timeStamp> element. Defaulting to run-lumi, "
                    << "which is wrong if the folder's CREST tag is time-indexed");
  }
 
  IOVDbNamespace::FolderAddressSpec resolved;
  if (!IOVDbNamespace::resolveFolderAddress(msg(), folderpar, m_foldername, m_jokey, m_key, p_clidSvc, resolved)) {
    return nullptr;
  }
 
  m_key = std::move(resolved.key);
  m_named = resolved.named;
  m_addrheader = std::move(resolved.addrheader);
  m_typename = std::move(resolved.typeName);
  m_clid = resolved.clid;
 
  if (not m_useFileMetaData) {
    // Get all channel IDs and names from the tag's channel spec
    const auto& channels = m_tag->getChannelSpec().channels();
    m_channums.clear();
    m_channames.clear();
    for (const auto& ch : channels) {
      m_channums.push_back(static_cast<cool::ChannelId>(ch.id));
      m_channames.push_back(ch.name);
    }
 
    m_foldertype = determineFolderType();
    if (m_foldertype == IOVDbNamespace::UNKNOWN) {
      return nullptr;
    }
 
    // The node description and the tag's isVectorPayload() flag must agree on vector vs scalar
    if ((m_foldertype == IOVDbNamespace::CoolVector) != m_tag->isVectorPayload()) {
      ATH_MSG_FATAL("Folder " << m_foldername << " (tag " << m_tag->getName()
                    << ") disagrees on vector-ness between its node description (typeName-derived "
                    << "folder type " << IOVDbNamespace::folderTypeName(m_foldertype)
                    << ") and its CHAI tag metadata (isVectorPayload()="
                    << (m_tag->isVectorPayload() ? "true" : "false") << ")");
      return nullptr;
    }
  }
 
  // For folders read from metadata, folder-type identification is
  // done in getAddress(). Channel number/name info is never read.
  m_nchan = m_channums.size();
  ATH_MSG_DEBUG("Folder identified as type " << m_foldertype);
 
  // Get the transient address while handling any symlinks
  const auto& linknameVector = folderpar.symLinks();
  auto tad{createTransientAddress(linknameVector)};
  if (not tad) {
    ATH_MSG_WARNING("Transient address is null in " << __func__);
    return nullptr;
  }
  return tad;
}

printState()

void IOVDbCrestTag::printState ( )

overridevirtual

Implements IOVDbConditionsSource.

Definition at line 679 of file IOVDbCrestTag.cxx.

                               {
  ATH_MSG_DEBUG("folder cache printout -------------------");
  if (m_resident) {
    unsigned int nchan = 0;
    if (!std::holds_alternative<std::monostate>(m_resident->payload)) {
      nchan = (m_foldertype == CoolVector)
        ? std::get<chai::PayloadResult<chai::VectorContainer>>(m_resident->payload).payload.channelIds().size()
        : std::get<chai::PayloadResult<chai::Container>>(m_resident->payload).payload.channelIds().size();
    }
    ATH_MSG_DEBUG(m_foldername << "\tsince: " << m_resident->since << "\tuntil: "
                  << m_resident->until << "\tchannels: " << nchan);
  } else {
    ATH_MSG_DEBUG(m_foldername << "\tno resident payload");
  }
  ATH_MSG_DEBUG("current range: " << m_currange);
  ATH_MSG_DEBUG("folder cache printout -------------------");
}

readMeta()

bool IOVDbCrestTag::readMeta ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 243 of file IOVDbCrestTag.h.

{ return m_useFileMetaData; }

readTime()

float IOVDbCrestTag::readTime ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 265 of file IOVDbCrestTag.h.

{ return m_readtime; }

reset()

void IOVDbCrestTag::reset ( )

overridevirtual

Implements IOVDbConditionsSource.

Definition at line 153 of file IOVDbCrestTag.cxx.

                          {
  m_resident.reset();
}

resolvedTag()

const std::string & IOVDbCrestTag::resolvedTag ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 257 of file IOVDbCrestTag.h.

{ return m_resolvedTagName; }

retrieved()

bool IOVDbCrestTag::retrieved ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 235 of file IOVDbCrestTag.h.

{ return m_retrieved; }

setDropped()

void IOVDbCrestTag::setDropped ( const bool dropped )

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 276 of file IOVDbCrestTag.h.

{ m_dropped=dropped; }

setFolderDescription()

void IOVDbCrestTag::setFolderDescription ( const std::string & description )

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 239 of file IOVDbCrestTag.h.

                                                                            {
  m_folderDescription = description;
}

setIOVOverride()

void IOVDbCrestTag::setIOVOverride ( const unsigned int run, const unsigned int lumiblock, const unsigned int time )

overridevirtual

Implements IOVDbConditionsSource.

Definition at line 127 of file IOVDbCrestTag.cxx.

                                                                                                                {
  if (m_iovoverridden) {
    return;
  }
  if (m_timestamp) {
    if (time != 0) {
      m_iovoverride = IOVDbNamespace::iovTimeFromSeconds(time);
      ATH_MSG_INFO("Override timestamp to " << m_iovoverride << " for folder " << m_foldername);
      m_iovoverridden = true;
    }
  } else {
    if (run != 0 || lumiblock != 0) {
      m_iovoverride = IOVDbNamespace::iovTimeFromRunLumi(run, lumiblock);
      ATH_MSG_INFO("Override run/LB number to [" << run << ":" << lumiblock << "] for folder " << m_foldername);
      m_iovoverridden = true;
    }
  }
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setTagOverride()

void IOVDbCrestTag::setTagOverride ( const std::string & tag, const bool setFlag )

overridevirtual

Implements IOVDbConditionsSource.

Definition at line 114 of file IOVDbCrestTag.cxx.

                                                                           {
  // Never reached for CREST tags (IOVDbSvc::processTagInfo skips them).
  // CREST tags come from the GlobalTag mapping or <ctag>, not TagInfo.
  if (setFlag) {
    m_tagoverride = true;
  }
  m_jotag = IOVDbNamespace::spaceStrip(tag);
}

setWriteMeta()

void IOVDbCrestTag::setWriteMeta ( )

overridevirtual

Implements IOVDbConditionsSource.

Definition at line 123 of file IOVDbCrestTag.cxx.

                                 {
  m_writemeta = true;
}

source()

const IOVDbCrestTag::source_t & IOVDbCrestTag::source ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 220 of file IOVDbCrestTag.h.

                                                                {
  static constexpr source_t s_source{source_t::CRESTDB};
  return s_source;
}

summary()

void IOVDbCrestTag::summary ( )

overridevirtual

Implements IOVDbConditionsSource.

Definition at line 669 of file IOVDbCrestTag.cxx.

                            {
  ATH_MSG_INFO("Folder " << m_foldername << " (" << IOVDbNamespace::folderTypeName(m_foldertype)
              << ") db-read " << m_ndbread << "/" << m_ncacheread << " objs/chan/bytes "
              << m_nobjread << "/" << m_nchan << "/" << m_nbytesread << " (( " << std::fixed
              << std::setw(8) << std::setprecision(2) << m_readtime << " ))s");
  if (m_ncacheread == 0 && m_ndbread > 0) {
    ATH_MSG_WARNING("Folder " << m_foldername << " is requested but no data retrieved");
  }
}

tagOverride()

bool IOVDbCrestTag::tagOverride ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 231 of file IOVDbCrestTag.h.

{ return m_tagoverride; }

timeStamp()

bool IOVDbCrestTag::timeStamp ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 229 of file IOVDbCrestTag.h.

{ return m_timestamp; }

useFileMetaData()

void IOVDbCrestTag::useFileMetaData ( )

overridevirtual

Implements IOVDbConditionsSource.

Definition at line 106 of file IOVDbCrestTag.cxx.

                                    {
  m_useFileMetaData = true;
  if (m_conn != nullptr) {
    m_conn->decUsage();
    m_conn = nullptr;
  }
}

writeMeta()

bool IOVDbCrestTag::writeMeta ( ) const

inlineoverridevirtual

Implements IOVDbConditionsSource.

Definition at line 245 of file IOVDbCrestTag.h.

{ return m_writemeta; }

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_addrheader

std::string IOVDbCrestTag::m_addrheader

private

Definition at line 191 of file IOVDbCrestTag.h.

m_cachespec

coral::AttributeListSpecification* IOVDbCrestTag::m_cachespec {nullptr}

private

Definition at line 214 of file IOVDbCrestTag.h.

{nullptr};

m_channames

std::vector<std::string> IOVDbCrestTag::m_channames

private

Definition at line 203 of file IOVDbCrestTag.h.

m_channums

std::vector<cool::ChannelId> IOVDbCrestTag::m_channums

private

Definition at line 202 of file IOVDbCrestTag.h.

m_chanrange

std::vector<std::pair<cool::ChannelId, cool::ChannelId> > IOVDbCrestTag::m_chanrange

private

Definition at line 207 of file IOVDbCrestTag.h.

m_clid

CLID IOVDbCrestTag::m_clid {0}

private

Definition at line 193 of file IOVDbCrestTag.h.

{0};

m_conn

IOVDbConn* IOVDbCrestTag::m_conn {nullptr}

private

Unused for CREST I/O; kept for per-connection usage counting.

Definition at line 167 of file IOVDbCrestTag.h.

{nullptr};           

m_currange

IOVRange IOVDbCrestTag::m_currange

private

Definition at line 210 of file IOVDbCrestTag.h.

m_db

chai::Database* IOVDbCrestTag::m_db {nullptr}

private

Non-owning pointer to the shared chai::Database.

Definition at line 168 of file IOVDbCrestTag.h.

{nullptr};             

m_dropped

bool IOVDbCrestTag::m_dropped {false}

private

Definition at line 184 of file IOVDbCrestTag.h.

{false};

m_eventstore

std::string IOVDbCrestTag::m_eventstore

private

Definition at line 190 of file IOVDbCrestTag.h.

m_extensible

bool IOVDbCrestTag::m_extensible {false}

private

Definition at line 180 of file IOVDbCrestTag.h.

{false};

m_folderDescription

std::string IOVDbCrestTag::m_folderDescription

private

Definition at line 171 of file IOVDbCrestTag.h.

m_foldername

std::string IOVDbConditionsSource::m_foldername

protectedinherited

Folder name, as it appears in COOL or as a CREST tag label.

Definition at line 123 of file IOVDbConditionsSource.h.

m_foldertype

IOVDbNamespace::FolderType IOVDbCrestTag::m_foldertype {IOVDbNamespace::UNKNOWN}

private

Definition at line 186 of file IOVDbCrestTag.h.

{IOVDbNamespace::UNKNOWN};

m_fromMetaDataOnly

bool IOVDbCrestTag::m_fromMetaDataOnly {false}

private

Definition at line 179 of file IOVDbCrestTag.h.

{false};

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_iovoverridden

bool IOVDbCrestTag::m_iovoverridden {false}

private

Definition at line 182 of file IOVDbCrestTag.h.

{false};

m_iovoverride

cool::ValidityKey IOVDbCrestTag::m_iovoverride {0}

private

Definition at line 185 of file IOVDbCrestTag.h.

{0};

m_jokey

bool IOVDbCrestTag::m_jokey {false}

private

Definition at line 183 of file IOVDbCrestTag.h.

{false};

m_jotag

std::string IOVDbCrestTag::m_jotag

private

Explicit <tag>/<ctag> from job options. Used only for /TagInfo.

Definition at line 188 of file IOVDbCrestTag.h.

m_key

std::string IOVDbConditionsSource::m_key

protectedinherited

SG key where data is loaded (unique).

Definition at line 124 of file IOVDbConditionsSource.h.

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_named

bool IOVDbCrestTag::m_named {false}

private

Definition at line 181 of file IOVDbCrestTag.h.

{false};

m_nbytesread

unsigned long long IOVDbCrestTag::m_nbytesread {0}

private

Definition at line 198 of file IOVDbCrestTag.h.

{0};

m_ncacheread

unsigned int IOVDbCrestTag::m_ncacheread {0}

private

Definition at line 195 of file IOVDbCrestTag.h.

{0};

m_nchan

unsigned int IOVDbCrestTag::m_nchan {0}

private

Definition at line 201 of file IOVDbCrestTag.h.

{0};

m_ndbread

unsigned int IOVDbCrestTag::m_ndbread {0}

private

Definition at line 196 of file IOVDbCrestTag.h.

{0};

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_nobjread

unsigned int IOVDbCrestTag::m_nobjread {0}

private

Definition at line 197 of file IOVDbCrestTag.h.

{0};

m_notagoverride

bool IOVDbCrestTag::m_notagoverride {false}

private

Unused on the CREST path. Present to satisfy IOVDbConditionsSource.

Definition at line 175 of file IOVDbCrestTag.h.

{false};  

m_readtime

float IOVDbCrestTag::m_readtime {0}

private

Definition at line 199 of file IOVDbCrestTag.h.

{0};

m_resident

std::optional<Resident> IOVDbCrestTag::m_resident

private

Definition at line 216 of file IOVDbCrestTag.h.

m_resolvedTagName

std::string IOVDbCrestTag::m_resolvedTagName

private

The CREST tag name actually used for lookup.

Definition at line 189 of file IOVDbCrestTag.h.

m_retrieved

bool IOVDbCrestTag::m_retrieved {false}

private

Definition at line 209 of file IOVDbCrestTag.h.

{false};

m_tag

chai::TagPtr IOVDbCrestTag::m_tag

private

Resolved in preload(). Stays null for a metadata-only folder.

Definition at line 169 of file IOVDbCrestTag.h.

m_tagoverride

bool IOVDbCrestTag::m_tagoverride {false}

private

Unused on the CREST path. Present to satisfy IOVDbConditionsSource.

Definition at line 174 of file IOVDbCrestTag.h.

{false};    

m_timestamp

bool IOVDbCrestTag::m_timestamp {false}

private

Indexed by timestamp (else runLB), from tag->getIovType().

Definition at line 172 of file IOVDbCrestTag.h.

{false};                        

m_typename

std::string IOVDbCrestTag::m_typename

private

Definition at line 192 of file IOVDbCrestTag.h.

m_useFileMetaData

bool IOVDbCrestTag::m_useFileMetaData {false}

private

Definition at line 178 of file IOVDbCrestTag.h.

{false};

m_writemeta

bool IOVDbCrestTag::m_writemeta {false}

private

Definition at line 177 of file IOVDbCrestTag.h.

{false};

p_clidSvc

IClassIDSvc* IOVDbCrestTag::p_clidSvc {nullptr}

private

Definition at line 165 of file IOVDbCrestTag.h.

{nullptr};

p_metaDataTool

IIOVDbMetaDataTool* IOVDbCrestTag::p_metaDataTool {nullptr}

private

Definition at line 166 of file IOVDbCrestTag.h.

{nullptr};

---

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

• IOVDbCrestTag.h
• IOVDbCrestTag.cxx