#include <IOVDbFolder.h>

Inheritance diagram for IOVDbFolder:

Collaboration diagram for IOVDbFolder:

Public Member Functions
	IOVDbFolder (IOVDbConn conn, const IOVDbParser &folderprop, MsgStream &msg, IClassIDSvc clidsvc, IIOVDbMetaDataTool *metadatatool, const bool checklock, const bool outputToFile=false, const std::string &source="COOL_DATABASE", const bool crestToFile=false, const std::string &crestServer="", const std::string &crestTag="", const bool crestCoolToFile=false)

	~IOVDbFolder ()

const std::string &	folderName () const

const std::string &	key () const

IOVDbConn *	conn ()

bool	multiVersion () const

bool	timeStamp () const

bool	tagOverride () const

bool	retrieved () const

bool	noOverride () const

IOVDbNamespace::FolderType	folderType () const

bool	readMeta () const

bool	writeMeta () const

bool	fromMetaDataOnly () const

bool	extensible () const

bool	dropped () const

bool	iovOverridden () const

const std::string &	joTag () const

const std::string &	resolvedTag () const

const std::string &	eventStore () const

CLID	clid () const

unsigned long long	bytesRead () const

float	readTime () const

const IOVRange &	currentRange () const

void	useFileMetaData ()

void	setFolderDescription (const std::string &description)

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

void	setWriteMeta ()

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

void	setDropped (const bool dropped)

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

bool	cacheValid (const cool::ValidityKey reftime) const

bool	loadCache (const cool::ValidityKey vkey, const unsigned int cacheDiv, const std::string &globalTag, const bool ignoreMissChan)

void	resetCache ()

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

void	summary ()

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

void	printCache ()

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

bool	msgLvl (const MSG::Level lvl) const
	Test the output level. More...

MsgStream &	msg () const
	The standard message stream. More...

MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream. More...

void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Private Types
using	IOVHash = std::pair< IOVDbNamespace::IovStore::Iov_t, std::string >

using	IOV2Index = std::pair< cool::ValidityKey, size_t >

typedef std::pair< cool::ChannelId, cool::ChannelId >	ChanRange

Private Member Functions
void	clearCache ()

bool	resolveTag (const cool::IFolderPtr &fptr, const std::string &globalTag)

bool	magicTag (std::string &tag)

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

bool	addMetaAttrListColl (const CondAttrListCollection *coll)

void	setSharedSpec (const coral::AttributeList &atrlist)

void	addIOVtoCache (cool::ValidityKey since, cool::ValidityKey until)

bool	overrideOptionsFromParsedDescription (const IOVDbParser &parsedDescription)

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

void	setCacheLength (const bool timeIs_nsOfEpoch, const unsigned int cacheRun, const unsigned int cacheTime)

template<class T >
unsigned int	cacheUpdateImplementation (T &obj, const ServiceHandle< IIOVSvc > &iovSvc)

bool	objectIteratorIsValid (cool::IObjectIteratorPtr &objItr)

bool	objectIteratorIsValid (CoraCoolObjectIterPtr &objItr)

void	specialCacheUpdate (CoraCoolObject &obj, const ServiceHandle< IIOVSvc > &iovSvc)

void	specialCacheUpdate (const cool::IObject &obj, const ServiceHandle< IIOVSvc > &iovSvc)

std::vector< IOVHash >	fetchCrestIOVs (cool::ValidityKey since, cool::ValidityKey until)

std::vector< IOVDbNamespace::BasicFolder >	fetchCrestObjects (cool::ValidityKey since, cool::ValidityKey until, bool vectorPayloadFlag, cool::ValidityKey vkey, const std::string &nodeDesc)

void	dumpFile (const std::string &dumpName, const cool::ValidityKey &vkey, IOVDbNamespace::Cool2Json json, bool skipCoolIoV, IOVDbNamespace::BasicFolder basicFolder, const std::string &crestNodeDescr, const std::string &specString) const

void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Private Attributes
ITagInfoMgr *	p_tagInfoMgr {nullptr}

IClassIDSvc *	p_clidSvc {nullptr}

IIOVDbMetaDataTool *	p_metaDataTool {nullptr}

IOVDbConn *	m_conn {nullptr}

std::string	m_foldername

std::string	m_key

std::string	m_folderDescription

bool	m_multiversion {false}

bool	m_timestamp {false}

bool	m_tagoverride {false}

bool	m_notagoverride {false}

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}

bool	m_autocache {true}

bool	m_checklock {true}

cool::ValidityKey	m_iovoverride {0}

IOVDbNamespace::FolderType	m_foldertype

cool::ValidityKey	m_cachelength {0}

int	m_cachehint {0}

int	m_cacheinc {0}

cool::ChannelSelection	m_chansel

std::vector< ChanRange >	m_chanrange

std::string	m_jotag

std::string	m_tag

std::string	m_typename

std::string	m_eventstore

std::string	m_cachepar

std::string	m_addrheader

CLID	m_clid {0}

unsigned int	m_ndbread {0}

unsigned int	m_ncacheread {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

bool	m_retrieved {false}

IOVRange	m_currange

coral::AttributeListSpecification *	m_cachespec {nullptr}

std::vector< cool::ChannelId >	m_cachechan

std::vector< coral::AttributeList >	m_cacheattr

std::vector< unsigned int >	m_cacheccstart

std::vector< unsigned int >	m_cacheccend

IOVDbNamespace::IovStore	m_iovs

const bool	m_outputToFile {false}

const bool	m_crestToFile {false}

const bool	m_crestCoolToFile {false}

const std::string	m_source

const std::string	m_crestServer

const std::string	m_crestTag

std::string	m_crest_tag = ""

nlohmann::json	m_tag_info = nullptr

std::optional< IOVDbNamespace::CrestFunctions >	m_cfunctions

std::string	m_nm
	Message source name. More...

boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...

std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...

std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

Detailed Description

Definition at line 52 of file IOVDbFolder.h.

Member Typedef Documentation

◆ ChanRange

typedef std::pair<cool::ChannelId,cool::ChannelId> IOVDbFolder::ChanRange

private

Definition at line 291 of file IOVDbFolder.h.

◆ IOV2Index

using IOVDbFolder::IOV2Index = std::pair<cool::ValidityKey,size_t>

private

Definition at line 237 of file IOVDbFolder.h.

◆ IOVHash

using IOVDbFolder::IOVHash = std::pair<IOVDbNamespace::IovStore::Iov_t,std::string>

private

Definition at line 236 of file IOVDbFolder.h.

Constructor & Destructor Documentation

◆ IOVDbFolder()

IOVDbFolder::IOVDbFolder	(	IOVDbConn *	conn,
		const IOVDbParser &	folderprop,
		MsgStream &	msg,
		IClassIDSvc *	clidsvc,
		IIOVDbMetaDataTool *	metadatatool,
		const bool	checklock,
		const bool	outputToFile = `false`,
		const std::string &	source = `"COOL_DATABASE"`,
		const bool	crestToFile = `false`,
		const std::string &	crestServer = `""`,
		const std::string &	crestTag = `""`,
		const bool	crestCoolToFile = `false`
	)

Definition at line 73 of file IOVDbFolder.cxx.

                                         :
   AthMessaging("IOVDbFolder"),
   p_clidSvc(clidsvc),
   p_metaDataTool(metadatatool),
   m_conn(conn),
   m_checklock(checklock),
   m_foldertype(AttrList),
   m_chansel(cool::ChannelSelection::all()),
   m_outputToFile{outputToFile},
   m_crestToFile{crestToFile},
   m_crestCoolToFile{crestCoolToFile},
   m_source{source},
   m_crestServer{crestServer},
   m_crestTag{crestTag}
 {
   // set message same message level as our parent (IOVDbSvc)
   setLevel(msg.level());
   // extract settings from the properties
   // foldername from the 'unnamed' property
   m_foldername=folderprop.folderName();
   // SG key from 'key' property, otherwise same as foldername
   // m_jokey is true if the 'key' property was set - need to remember this
   // to avoid using folder description <key> if present later
   m_key=folderprop.key();
   m_jokey=folderprop.hasKey();
   // tag from 'tag' property
   m_jotag=folderprop.tag();
   // event store from 'eventStoreName' property, default 'StoreGateSvc'
   m_eventstore=folderprop.eventStoreName();
   // cachelength (seconds or LB)
   m_cachepar = folderprop.cache();
   // check for <noover> - disables using tag override read from input file
   m_notagoverride=folderprop.noTagOverride();
   if (m_source == "CREST")
     m_cfunctions.emplace(IOVDbNamespace::CrestFunctions(m_crestServer));      
   if (m_notagoverride) ATH_MSG_INFO( "Inputfile tag override disabled for " << m_foldername );
  
   // channel selection from 'channelSelection' property
   // syntax is A:B,C:D,E:F
   // :B implies zero lower limit, A: implies zero upper limit
   std::string chanspec;
   if (folderprop.getKey("channelSelection","",chanspec) && !chanspec.empty()) {
     m_chanrange=IOVDbNamespace::parseChannelSpec<cool::ChannelId>(chanspec);
     // explicit setting of channel selection
     // push to the channel selection
     try{
       bool first(true);
       for(const auto & i:m_chanrange){
         if (first){
           first = false;
           m_chansel = cool::ChannelSelection(i.first,i.second);
         } else {
           m_chansel.addRange(i.first,i.second);
         }
       }
     } catch (cool::Exception& e) {
         ATH_MSG_ERROR("defining channel range (must be given in ascending order)");
         throw;
     }
   }
   if (folderprop.overridesIov(msg)){
     m_iovoverridden=true;
     m_iovoverride=folderprop.iovOverrideValue(msg);
     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 );
     }
   }
  
   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 );
   }
   
 }

◆ ~IOVDbFolder()

IOVDbFolder::~IOVDbFolder ( )

Definition at line 162 of file IOVDbFolder.cxx.

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

Member Function Documentation

◆ addIOVtoCache()

void IOVDbFolder::addIOVtoCache	(	cool::ValidityKey	since,
		cool::ValidityKey	until
	)

private

Definition at line 1153 of file IOVDbFolder.cxx.

                                                                       {
   // add IOV to the cache
   ATH_MSG_DEBUG("Adding IOV to cache, from "<<since<<" to "<<until);
   m_iovs.addIov(since, until);
 }

◆ addMetaAttrList()

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

private

Definition at line 1113 of file IOVDbFolder.cxx.

                                                          {
   // make a temporary CondAttrListCollection with channel 0xFFFF
   // This channel number is used to flag on readback that an 
   // AthenaAttributeList and not a CondAttrListCollection must be created
   CondAttrListCollection tmpColl(!m_timestamp);
   tmpColl.add(0xFFFF,atrlist);
   tmpColl.add(0xFFFF,range);
   return addMetaAttrListColl(&tmpColl);
 }

◆ addMetaAttrListColl()

bool IOVDbFolder::addMetaAttrListColl ( const CondAttrListCollection * coll )

private

Definition at line 1125 of file IOVDbFolder.cxx.

                                                                    {
   // send given payload to folder metadata
   // make a new CondAttrListCollection for the payload
   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;
   } else {
     ATH_MSG_DEBUG( "addMetaAttrList: write metadata for folder " << m_foldername );
     return true;
   }
 }

◆ bytesRead()

unsigned long long IOVDbFolder::bytesRead ( ) const

inline

Definition at line 379 of file IOVDbFolder.h.

380 { return m_nbytesread; }

◆ cacheUpdateImplementation()

template<class T >

unsigned int IOVDbFolder::cacheUpdateImplementation	(	T &	obj,
		const ServiceHandle< IIOVSvc > &	iovSvc
	)

inlineprivate

Definition at line 177 of file IOVDbFolder.h.

                                                                           {
     const auto & objSince = obj.since();
     const auto & objUntil = obj.until();
     const auto & objChannel = obj.channelId();
     ATH_MSG_DEBUG("from DB \t chID: "<<objChannel<<"\tobjstart:\t"<<objSince<<"\t objstop: \t"
                    << objUntil );
     // The covered flag is used to check whether the
     // requested IOV time is inside the range covered
     // by the current cache. If not, a cache reset
     // will be done.
     unsigned int counter{};
     bool covered{false};
     //find the iterator distance into the channel array which gives the sought ChannelId
     const auto pCacheChannel = std::find(m_cachechan.begin(), m_cachechan.end(), objChannel);
     if (pCacheChannel != m_cachechan.end()){
       //find corresponding iov, which we shall modify
       const auto iovIdx = std::distance(m_cachechan.begin(), pCacheChannel);
       const auto & iov = m_iovs.at(iovIdx);
       if ((iov.first < objSince) and (objSince < iov.second)){ 
         // obj time is larger than cache start (and less than cache stop)
         //   ==> update cache
         ++counter;
         ATH_MSG_DEBUG("special reload needed on THIS ONE !!!!!!!!!!!");
         // just change existing IOVRange
         ATH_MSG_DEBUG("changing "<<iov.second<<"  to "<<objSince-1);
         m_iovs.extendIov(iovIdx, objSince-1);
         specialCacheUpdate(obj, iovSvc); //  reset proxy, add to cache, addIOV 
         covered = true;
       }
       if ( (objSince>=iov.first and objSince<iov.second) or (objUntil>iov.first and objUntil<=iov.second) ) covered=true;
     }
     if (!covered) {
       // cache range has not been covered, so update the cache
       ++counter;
       specialCacheUpdate(obj, iovSvc);
     }
     return counter;    
   }

◆ cacheValid()

bool IOVDbFolder::cacheValid ( const cool::ValidityKey reftime ) const

inline

Definition at line 387 of file IOVDbFolder.h.

                                                                        {
   const auto & [cacheStart, cacheStop]=m_iovs.getCacheBounds();
   return ((reftime>cacheStart) and (reftime<cacheStop));
 }

◆ clearCache()

void IOVDbFolder::clearCache ( )

private

Definition at line 1038 of file IOVDbFolder.cxx.

                         {
   // clear all the cache vectors of information
   m_iovs.clear();
   m_cachechan.clear();
   m_cacheattr.clear();
   m_cacheccstart.clear();
   m_cacheccend.clear();
 }

◆ clid()

CLID IOVDbFolder::clid ( ) const

inline

Definition at line 377 of file IOVDbFolder.h.

377 { return m_clid; }

◆ conn()

IOVDbConn * IOVDbFolder::conn ( )

inline

Definition at line 340 of file IOVDbFolder.h.

340 { return m_conn;}

◆ createTransientAddress()

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

private

Definition at line 874 of file IOVDbFolder.cxx.

                                                                         {
   auto tad = std::make_unique<SG::TransientAddress>(m_clid,m_key);
   //
   for (const auto & linkname:symlinks){
     if (not linkname.empty()) {
       CLID sclid;
       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 & IOVDbFolder::currentRange ( ) const

inline

Definition at line 385 of file IOVDbFolder.h.

385 { return m_currange; }

◆ dropped()

bool IOVDbFolder::dropped ( ) const

inline

Definition at line 366 of file IOVDbFolder.h.

366 { return m_dropped; }

◆ dumpFile()

void IOVDbFolder::dumpFile	(	const std::string &	dumpName,
		const cool::ValidityKey &	vkey,
		IOVDbNamespace::Cool2Json *	json,
		bool	skipCoolIoV,
		IOVDbNamespace::BasicFolder *	basicFolder,
		const std::string &	crestNodeDescr,
		const std::string &	specString
	)		const

private

Definition at line 1209 of file IOVDbFolder.cxx.

 {
   std::ofstream myFile;
   std::string fMain(dumpName);
   const std::string sanitisedFolder=fMain+"/"+sanitiseFilename(m_foldername);
   const std::string fabricatedName=sanitisedFolder+delimiter+std::to_string(vkey)+fileSuffix;
   std::filesystem::create_directory(fMain);
   myFile.open(fabricatedName,std::ios::out);
   if (not myFile.is_open()) {
     std::string errorMessage{"File creation for "+fabricatedName+" failed."};
     ATH_MSG_FATAL(errorMessage);
     throw std::runtime_error(errorMessage);
   }
   else {
     ATH_MSG_INFO("File "<<fabricatedName<<" created.");
   }
  
   myFile<<s_openJson;
   if(json) {
     // Dump COOL data
     myFile<<json->description()<<s_delimiterJson<<std::endl;
     myFile<<json->payloadSpec()<<s_delimiterJson<<std::endl;
     if(!skipCoolIoV) {
       myFile<<json->iov()<<s_delimiterJson<<std::endl;
     }
     myFile<<json->payload()<<std::endl;
   }
   else {
     // Dump CREST data
     std::string newNodeDescription = std::regex_replace(crestNodeDescr, std::regex("\""), "\\\"");
     std::string newSpecString = std::regex_replace(specString, std::regex(":"), ": ");
     newSpecString = std::regex_replace(newSpecString, std::regex(","), s_delimiterJson);
     myFile<<"\"node_description\" : \""<<newNodeDescription<< '\"'<<s_delimiterJson<<std::endl;
     myFile<<"\"folder_payloadspec\": \""<<newSpecString<< '\"'<<s_delimiterJson<<std::endl;
     myFile<<basicFolder->jsonPayload(newNodeDescription,newSpecString)<<std::endl;
   }
   myFile<<s_closeJson;
 }

◆ eventStore()

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

inline

Definition at line 374 of file IOVDbFolder.h.

375 { return m_eventstore; }

◆ extensible()

bool IOVDbFolder::extensible ( ) const

inline

Definition at line 364 of file IOVDbFolder.h.

364 { return m_extensible; }

◆ fetchCrestIOVs()

std::vector< IOVDbFolder::IOVHash > IOVDbFolder::fetchCrestIOVs	(	cool::ValidityKey	since,
		cool::ValidityKey	until
	)

private

Definition at line 1174 of file IOVDbFolder.cxx.

 {
   std::vector<IOVHash> result;
  
   // Get a vector of pairs retrieved from crest
   auto crestIOVs = m_cfunctions.value().getIovsForTag(m_crestTag, since, until); 
   if(crestIOVs.empty()){
     ATH_MSG_WARNING("Load cache failed for " << m_foldername << ". No IOVs retrieved from the DB");
     return result; 
   }
   std::vector<IOV2Index> iov2IndexVect;                  // Temporary vector for sorting IOV_SINCE values
   iov2IndexVect.reserve(crestIOVs.size());
   size_t hashInd{0};
   for(const auto& crestIOV : crestIOVs) {
     iov2IndexVect.emplace_back(std::stoull(crestIOV.first),hashInd++);
   }
  
   size_t nIOVs = iov2IndexVect.size();
   result.reserve(nIOVs);
   if(nIOVs>0) {
     if(nIOVs>1) {
       for(size_t ind=0; ind<nIOVs-1; ++ind) {
     result.emplace_back(IovStore::Iov_t(iov2IndexVect[ind].first
                         , iov2IndexVect[ind+1].first)
                 , crestIOVs[iov2IndexVect[ind].second].second);
       }
     }
     result.emplace_back(IovStore::Iov_t(iov2IndexVect[nIOVs-1].first
                         , cool::ValidityKeyMax)
                 , crestIOVs[iov2IndexVect[nIOVs-1].second].second);
   }
   
   return result;
 }

◆ fetchCrestObjects()

std::vector< BasicFolder > IOVDbFolder::fetchCrestObjects	(	cool::ValidityKey	since,
		cool::ValidityKey	until,
		bool	vectorPayloadFlag,
		cool::ValidityKey	vkey,
		const std::string &	nodeDesc
	)

private

Definition at line 1254 of file IOVDbFolder.cxx.

 {
  
   std::string crestPayloadType="crest-json-single-iov";
   nlohmann::json tagProperties = m_cfunctions.value().getTagProperties(m_crestTag);
   if(tagProperties!=nullptr
      && tagProperties.contains("payloadSpec")) {
     crestPayloadType=tagProperties["payloadSpec"].get<std::string>();
   }
  
   if(crestPayloadType.compare("crest-json-multi-iov")==0) {
 /*
    try {
       nlohmann::json multiPayload = nlohmann::json::parse(reply);
       nlohmann::json jsIovs=multiPayload["obj"];
       std::vector<IOV2Index> iov2IndexVect;
       iov2IndexVect.reserve(jsIovs.size());
       size_t hashInd{0};
       for(const auto& jsIov : jsIovs.items()) {
     iov2IndexVect.emplace_back(std::stoull(jsIov.key()),hashInd++);
       }
       std::sort(iov2IndexVect.begin(),iov2IndexVect.end(),
         [](const IOV2Index& a, const IOV2Index& b)
         {
           return a.first < b.first;
         });
       if(vkey < iov2IndexVect[0].first) {
     std::string errorMessage{"Load cache failed for "+m_foldername+". No valid IOV retrieved from the payload"};
     ATH_MSG_FATAL(errorMessage);
     throw std::runtime_error{errorMessage};
       }
  
       uint64_t iov = 0;
       for(const auto& iovhash : iov2IndexVect) {
     if(vkey >= iovhash.first) {
           iov=iovhash.first;
       continue;
     }
     else {
       break;
     }
       }
       if (indIOV>=0){
         iovHashVect[indIOV].first.first=iov;
         nlohmann::json payload={};
         payload["data"]=jsIovs[std::to_string(iov)];
         reply=payload.dump();
       } else {
         ATH_MSG_FATAL("indIOV is negative in IOVDbFolder::dumpFile");
       }
     }
     catch (std::exception & e) {
       std::string errorMessage = "Failed of parse multi iovs struct of internal iovs from payload for DCS type: " + std::string{e.what()};
       ATH_MSG_FATAL(errorMessage);
       throw std::runtime_error{errorMessage};
     }
   }
   ATH_MSG_DEBUG("Found IOV for " << m_foldername << " and VKEY " << vkey
         << " " << iovHashVect[indIOV].first);
  
   if (m_crestToFile and (indIOV>=0)) { //indIOV must be >=0, it's used as a vector index in this block
     unsigned long long sinceT =  iovHashVect[indIOV].first.first;
  
     std::string crest_work_dir=std::filesystem::current_path();
     crest_work_dir += "/crest_data";
     bool crest_rewrite = true;
     Crest::CrestClient crestFSClient = Crest::CrestClient(crest_rewrite, crest_work_dir);
  
     nlohmann::json js =
     {
       {"name", m_crestTag}
     };
  
     try{
       crestFSClient.createTag(js);
       ATH_MSG_INFO("Tag " << m_crestTag << " saved to disk.");
       ATH_MSG_INFO("CREST Dump dir = " << crest_work_dir);
     }
     catch (const std::exception& e) {
       ATH_MSG_WARNING("Data saving for tag " << m_crestTag << " failed: " << e.what());
     }
  
     try{
       crestFSClient.storePayloadDump(m_crestTag, sinceT, reply);
       ATH_MSG_INFO("Data (payload and IOV) saved for tag " << m_crestTag << ".");
     }
     catch (const std::exception& e) {
       ATH_MSG_WARNING("Data (payload and IOV) saving for tag " << m_crestTag<<" failed; " << e.what());
     }
   }
  
   const std::string& specString = cfunctions.getTagInfoElement(m_tag_info,"payload_spec");
   if (specString.empty()) {
     std::string errorMessage = "Reading payload spec from "+m_foldername+" failed.";
 */
     // Support for this type of payload will be added later
     std::string errorMessage = m_foldername + ": has multi-iov payload. Folders with multi-iov payloads currently not supported!";
     ATH_MSG_FATAL(errorMessage);
     throw std::runtime_error{errorMessage};
   }
   const std::string specString = m_cfunctions.value().getTagInfoElement(m_tag_info,"payload_spec");
   if (specString.empty()) {
     std::string errorMessage = "Reading payload spec from " + m_foldername + " failed.";
     ATH_MSG_FATAL(errorMessage);
     throw std::runtime_error{errorMessage};
   }
  
   std::vector<BasicFolder> retVector;
  
   // Vector of non-overlapping IOVs + corresponding Hashes
   std::vector<IOVHash> iovHashVect = fetchCrestIOVs(since, until);
  
   if(iovHashVect.empty() || until<=iovHashVect[0].first.first) {
     if(iovHashVect.empty()) {
       ATH_MSG_INFO("NO IOVs retrieved for the folder "+ m_foldername);
     }
     else {
       ATH_MSG_INFO("Cache boundaries outside available IOVs for the folder "+ m_foldername);
     }
     BasicFolder basicFolder;
     basicFolder.setVectorPayloadFlag(vectorPayloadFlag);
     retVector.push_back(basicFolder);
     return retVector;
   }
  
   unsigned indIOVStart = 0;
   for(const auto& iovhash : iovHashVect) {
     if(since < iovhash.first.first) break; // 'since' is earlier that the first IOV segment. indIOVStart=0
     if(since < iovhash.first.second
        && since >= iovhash.first.first) {
       break;
     }
     ++indIOVStart;
   }
   unsigned indIOVEnd = indIOVStart;
   while(indIOVEnd < iovHashVect.size()) {
     if(iovHashVect[indIOVEnd].first.first < until
        && iovHashVect[indIOVEnd].first.second >= until) {
        break;
     }
     ++indIOVEnd;
   }
  
   for(unsigned ind = indIOVStart; ind <= indIOVEnd; ++ind) {
     std::string reply = m_cfunctions.value().getPayloadForHash(iovHashVect[ind].second); 
  
     if (m_crestToFile) { 
       unsigned long long sinceT =  iovHashVect[ind].first.first;
  
       std::string crest_work_dir=std::filesystem::current_path();
       crest_work_dir += "/crest_data";
       bool crest_rewrite = true;
       Crest::CrestApiFs crestFSClient = Crest::CrestApiFs(crest_rewrite, crest_work_dir);
  
       nlohmann::json js =
       {
           {"description", "none"},
           {"endOfValidity", 0},
           {"lastValidatedTime", 0},
           {"name", m_crestTag},
           {"payloadSpec", "none"},
           {"synchronization", "none"},
           {"timeType", "time"}};
  
       TagDto dto = TagDto();
       dto = dto.fromJson(js);
  
       try{
     crestFSClient.createTag(dto);
     
         ATH_MSG_INFO("Tag " << m_crestTag << " saved to disk.");
         ATH_MSG_INFO("CREST Dump dir = " << crest_work_dir);
       }
       catch (const std::exception& e) {
         ATH_MSG_WARNING("Data saving for tag " << m_crestTag << " failed: " << e.what());
       }
  
       uint64_t endtime = 0;
       nlohmann::json elem = 
         {
           {"since", sinceT},
           {"data", reply},
           {"streamerInfo", "none"}
         };
  
       nlohmann::json jResources = json::array();
       jResources.push_back(elem);
  
       nlohmann::json jsStoreSet= 
       {
         {"size", 1},
         {"datatype", "data"},
         {"format", "StoreSetDto"},
         {"resources", jResources}
       };
  
       StoreSetDto storeSetDto = StoreSetDto::fromJson(jsStoreSet);
       
       try{
         crestFSClient.storeData(m_crestTag, storeSetDto, "JSON", "test", "test", "1", endtime);
     
         ATH_MSG_INFO("Data (payload and IOV) saved for tag " << m_crestTag << ".");
       }
       catch (const std::exception& e) {
         ATH_MSG_WARNING("Data (payload and IOV) saving for tag " << m_crestTag<<" failed; " << e.what());
       }
     }
  
     //basic folder now contains the info
     BasicFolder basicFolder;
     basicFolder.setVectorPayloadFlag(vectorPayloadFlag);
     std::istringstream ss(reply);
     Json2Cool inputJson(ss, basicFolder, specString, &(iovHashVect[ind].first));
     if (basicFolder.empty()){
       std::string errorMessage = "Reading channel data from "+m_foldername+" failed.";
       ATH_MSG_FATAL(errorMessage);
       throw std::runtime_error{errorMessage};
     }
  
     if(m_crestCoolToFile) {
       dumpFile("crest_dump",vkey,nullptr,false,&basicFolder,nodeDesc,specString);
     }
  
     retVector.push_back(basicFolder);
   }
   return retVector;
 }

◆ folderName()

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

inline

Definition at line 337 of file IOVDbFolder.h.

337 {return m_foldername;}

◆ folderType()

IOVDbNamespace::FolderType IOVDbFolder::folderType ( ) const

inline

Definition at line 352 of file IOVDbFolder.h.

353 {return m_foldertype;}

◆ fromMetaDataOnly()

bool IOVDbFolder::fromMetaDataOnly ( ) const

inline

Definition at line 362 of file IOVDbFolder.h.

362 { return m_fromMetaDataOnly; }

◆ getAddress()

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

Definition at line 634 of file IOVDbFolder.cxx.

                                                                     {
  
   ++m_ncacheread;
   // will produce strAddress and one pointer type depending on folder data
   std::string strAddress;
   AthenaAttributeList* attrList=nullptr;
   CondAttrListCollection* attrListColl=nullptr;
   CondAttrListVec* attrListVec=nullptr;
   cool::ValidityKey naystart=0;
   cool::ValidityKey naystop=cool::ValidityKeyMax;
   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;
     }
     // read from file metadata
     m_foldertype=readFromMetaData.folderType();
     m_nobjread+=readFromMetaData.numberOfObjects();
     poolPayloadReq=readFromMetaData.poolPayloadRequested();
     strAddress = readFromMetaData.stringAddress();
     range = readFromMetaData.range();
     attrList = readFromMetaData.attributeList();
     attrListColl = readFromMetaData.attrListCollection();
     ATH_MSG_DEBUG( "Read file metadata for folder " << m_foldername << " foldertype is " << m_foldertype );
   } else {
     // COOL/CoraCool data to be read from cache
     // for AttrListColl or PoolRefColl, need a CondAttrListCollection ready
     // to receive the data
     if (m_foldertype==AttrListColl || m_foldertype==PoolRefColl) {
       attrListColl=new CondAttrListCollection(!m_timestamp);
     } else if (m_foldertype==CoraCool || m_foldertype==CoolVector) {
       // for CoraCool/CoolVector, assume we will get everything in the cache
       attrListVec=new CondAttrListVec(!m_timestamp, m_cacheattr.size());
     }
     // loop over cached data
     unsigned int nobj=0;
     // keep track of closest neighbouring IOVs
     std::tie(naystart, naystop) = m_iovs.getCacheBounds();
  
     for (unsigned int ic=0; ic!=m_iovs.size();++ic) {
       const auto & thisIov  = m_iovs.at(ic);
       if (thisIov.first<=reftime && reftime<thisIov.second) {
         ++nobj;
         if (m_foldertype==AttrList || m_foldertype==PoolRef) {
           // retrieve of AthenaAttributeList or single PoolRef
           if (m_foldertype==AttrList) {
             attrList=new AthenaAttributeList(m_cacheattr[ic]);
             strAddress="POOLContainer_AthenaAttributeList][CLID=x";
           } else {
             strAddress=(m_cacheattr[ic])["PoolRef"].data<std::string>();
           }
           range=IOVDbNamespace::makeRange(thisIov.first,thisIov.second, m_timestamp);
           // write meta-data if required
           if (m_writemeta) 
             if (!addMetaAttrList(m_cacheattr[ic],range)) return false;
         } else if (m_foldertype==AttrListColl || m_foldertype==PoolRefColl) {
           // retrieve of CondAttrListCollection
           attrListColl->addShared(m_cachechan[ic],m_cacheattr[ic]);
           attrListColl->add(m_cachechan[ic],IOVDbNamespace::makeRange(thisIov.first,thisIov.second, m_timestamp));
         } else if (m_foldertype==CoraCool || m_foldertype==CoolVector) {
           // retrieval of CoraCool data
           attrListVec->addSlice(IOVDbNamespace::makeRange(thisIov.first,thisIov.second, m_timestamp),
                                 m_cachechan[ic],m_cacheattr,
                                 m_cacheccstart[ic],m_cacheccend[ic]);
           if (m_writemeta) {
             ATH_MSG_ERROR( "Writing of CoraCool folders to file metadata not implemented");
             return false;
           }
         } else {
           ATH_MSG_ERROR( "Unhandled folder type " << m_foldertype);
           return false;
         }
       } else if (thisIov.second<=reftime && thisIov.second>naystart) {
         naystart=thisIov.second;
       } else if (thisIov.first>reftime && thisIov.first<naystop) {
         naystop=thisIov.first;
       }
     }
     // post-loop actions
     if (m_foldertype==AttrListColl || m_foldertype==PoolRefColl) {
       // set up channel names if required
       if (m_named) {
         std::vector<std::string>::const_iterator nitr=m_channames.begin();
         for (std::vector<cool::ChannelId>::const_iterator chitr=m_channums.begin();
              chitr!=m_channums.end(); ++chitr,++nitr) {
           attrListColl->add(*chitr,*nitr);
         }
       }
       // set range
       range=attrListColl->minRange();
       strAddress="POOLContainer_CondAttrListCollection][CLID=x";
     } else if (m_foldertype==CoraCool || m_foldertype==CoolVector) {
       range=attrListVec->minRange();
       strAddress="POOLContainer_CondAttrListVec][CLID=x";
     } else if (m_foldertype==AttrList || m_foldertype==PoolRef) {
       // single object retrieve - should have exactly one object
       if (nobj==0) {
         ATH_MSG_ERROR("COOL object not found in single-channel retrieve, folder " 
                << m_foldername << " currentTime " << reftime );
         return false;
       } else if (nobj>1) {
         ATH_MSG_ERROR( nobj << 
           " valid objects found for single-channel retrieve, folder " << 
           m_foldername << " currentTime " << reftime );
         return false;
       }
     }
     ATH_MSG_DEBUG( "Retrieved object: folder " << m_foldername 
            <<  " at IOV " << reftime << " channels " << nobj << " has range "
            << range );
     // shrink range so it does not extend into 'gap' channels or outside cache
     IOVTime tnaystart=makeEpochOrRunLumi(naystart, m_timestamp);
     IOVTime tnaystop=makeEpochOrRunLumi(naystop, m_timestamp);
     IOVTime rstart=range.start();
     IOVTime rstop=range.stop();
     if (tnaystart > rstart || rstop > tnaystop) {
       ATH_MSG_DEBUG( "Shrink IOV range for " << m_foldername
              << " from [" << rstart << ":" << rstop << "] to ["
              << tnaystart << ":" << tnaystop << "]" );
       if (tnaystart > rstart) rstart=tnaystart;
       if (tnaystop  < rstop)  rstop=tnaystop;
       range=IOVRange(rstart,rstop);
       if (m_foldertype==AttrListColl || m_foldertype==PoolRefColl) {
         attrListColl->addNewStart(rstart);
         attrListColl->addNewStop(rstop);
       }
     }
   }
   // save the range for possible later lookup in IOVDbSvc::getKeyInfo
   m_currange=range;
   m_retrieved=true;
   // write metadata for attrListColl if required (after range shrinking)
   if (m_writemeta && 
       (m_foldertype==AttrListColl || m_foldertype==PoolRefColl)) {
     if (!addMetaAttrListColl(attrListColl)) return false;
   }
  
   // turn the data into an IOpaqueAddress
   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;
   }
   // create a new GenericAddress to set pool context
   if (m_foldertype==AttrListColl) {
     auto addr = std::make_unique<CondAttrListCollAddress>(*gAddr);
     addr->setAttrListColl(attrListColl);
     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);
     }
     address = std::move(addr);
     poolPayloadReq=true;
   } else if (m_foldertype==AttrList) {
     auto addr = std::make_unique<AthenaAttrListAddress>(*gAddr);
     addr->setAttrList(attrList);
     address = std::move(addr);
   } else if (m_foldertype==CoraCool || m_foldertype==CoolVector) {
     auto addr = std::make_unique<CondAttrListVecAddress>(*gAddr);
     addr->setAttrListVec(attrListVec);
     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();
   m_lvl = m_imsg ?
     static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
     MSG::INFO;
 }

◆ iovOverridden()

bool IOVDbFolder::iovOverridden ( ) const

inline

Definition at line 368 of file IOVDbFolder.h.

368 { return m_iovoverridden; }

◆ iovTime()

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

Definition at line 217 of file IOVDbFolder.cxx.

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

◆ joTag()

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

inline

Definition at line 370 of file IOVDbFolder.h.

370 { return m_jotag; }

◆ key()

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

inline

Definition at line 338 of file IOVDbFolder.h.

338 { return m_key;}

◆ loadCache()

bool IOVDbFolder::loadCache	(	const cool::ValidityKey	vkey,
		const unsigned int	cacheDiv,
		const std::string &	globalTag,
		const bool	ignoreMissChan
	)

Definition at line 226 of file IOVDbFolder.cxx.

                                                        {
   // load the cache for the given IOVTime, making a range around this time
   // according to the caching policy
   // if cacheDiv > 0, specifies number of slices of cache for query alignment
   // if ignoreMissChan set, don't worry about missing channels outside the cache range
   // return false if any problem
   // timer to track amount of time in loadCache
   TStopwatch cachetimer;
   const auto & [cachestart, cachestop] = m_iovs.getCacheBounds();
  
   bool vectorPayload{};
   std::string strCrestNodeDesc;
   if (m_source == "CREST"){
     ATH_MSG_INFO("Download tag would be: "<<m_crestTag);
  
     if (m_crest_tag != m_crestTag){
       m_crest_tag = m_crestTag;
       m_tag_info = m_cfunctions.value().getTagInfo(m_crestTag); 
     }
     strCrestNodeDesc = m_cfunctions.value().folderDescriptionForTag(m_crestTag);
     vectorPayload = (strCrestNodeDesc.find("CondAttrListVec") != std::string::npos);
   }
   else {
     vectorPayload = (m_foldertype ==CoraCool) or (m_foldertype == CoolVector);
   }
  
   ATH_MSG_DEBUG( "Load cache for folder " << m_foldername << " validitykey " << vkey);
   // if not first time through, and limit not reached,and cache was not reset, 
   // and we are going forwards in time, double cachesize
   if (m_ndbread>0 && m_cacheinc<3 && (cachestop!=cachestart) && vkey>cachestart && m_autocache) {
     m_cachelength*=2;
     ++m_cacheinc;
     ATH_MSG_INFO( "Increase cache length (step " << m_cacheinc << ") for folder " << m_foldername << " to " << m_cachelength << " at validityKey " << vkey );
   }
   ++m_ndbread;
   auto [changedCacheLo, changedCacheHi] = m_iovs.getCacheBounds();
   if (cacheDiv>0) {
     // quantise queries on boundaries that are sub-multiples of cache length
     unsigned long long cacheq=m_cachelength/cacheDiv;
     if (cacheq>0) changedCacheLo=vkey - vkey % cacheq;
     changedCacheHi=changedCacheLo+m_cachelength;
   } else {
     // for run/LB indexed folders and cache of at least one run
     // align the query to the run start
     if (!m_timestamp && m_cachelength>=IOVDbNamespace::ALL_LUMI_BLOCKS) {
       changedCacheLo=vkey & (0x7FFFFFFFLL << 32);
     } else {
       changedCacheLo=vkey;
     }
     changedCacheHi=vkey+m_cachelength;
   }
   if (changedCacheHi>cool::ValidityKeyMax) changedCacheHi=cool::ValidityKeyMax;
   //
   //
   m_iovs.setCacheBounds(IovStore::Iov_t(changedCacheLo, changedCacheHi));
   //
   const auto & [since, until] = m_iovs.getCacheBounds();
   ATH_MSG_DEBUG( "IOVDbFolder:loadCache limits set to ["  << since << "," << until << "]" );
  
   if (m_cachespec==nullptr) {
     // on first init, guess size based on channel count
     unsigned int estsize=m_nchan;
     if (m_cachehint > 0) {
       estsize=estsize*m_cachehint;
     } else if (m_timestamp) {
       // for timestamp indexed folder (likely to be DCS), increase this
       estsize=estsize*3;
     }
     // note this is only reserved size of the cache vectors
     // actual datastorage is mainly allocated by pointer elsewhere
     m_cachechan.reserve(estsize);
     m_cacheattr.reserve(estsize);
     if (vectorPayload) {
       m_cacheccstart.reserve(estsize);
       m_cacheccend.reserve(estsize);
     }
   } else {
     // reset cache if it already contained data
     // TBIO - could keep the attributelists and only change the data on reload
     // avoiding some attributelist construction/destruction
     clearCache();
   }
   bool retrievedone=false;
   unsigned int nChannelsExpected = (m_chanrange.empty())? (m_nchan) : (IOVDbNamespace::countSelectedChannels(m_channums, m_chansel));
   if (m_source == "COOL_DATABASE"){
     // query to fill cache - request for database activates connection
     if (not m_conn->open()) {
       ATH_MSG_FATAL( "Conditions database connection " <<m_conn->name() << " cannot be opened - STOP" );
       return false;
     }
     // access COOL inside try/catch in case of using stale connection
     unsigned int attempts=0;
  
     ATH_MSG_DEBUG( "loadCache: Expecting to see " << nChannelsExpected << " channels" );
     //
     while (attempts<2 && !retrievedone) {
       ++attempts;
       try {
         unsigned int iadd=0;
         m_iovs.setIovSpan(IovStore::Iov_t(0,cool::ValidityKeyMax));
         // check pointer is still valid - can go stale in AthenaMT environment
         // according to CORAL server tests done by Andrea Valassi (23/6/09)
         if (not m_conn->valid()) throw std::runtime_error("COOL database pointer invalidated");
         // access COOL folder in case needed to resolve tag (even for CoraCool)
         cool::IFolderPtr folder=m_conn->getFolderPtr(m_foldername);
  
         // resolve the tag for MV folders if not already done so
         if (m_multiversion && m_tag.empty()) {
           if (!resolveTag(folder,globalTag)) return false;
         
         }
         if (m_foldertype==CoraCool) {
           // CoraCool retrieve
           CoraCoolDatabasePtr ccDbPtr=m_conn->getCoraCoolDb();
           CoraCoolFolderPtr ccfolder=ccDbPtr->getFolder(m_foldername);
  
           auto [since,until] = m_iovs.getCacheBounds();
           CoraCoolObjectIterPtr itr=ccfolder->browseObjects(since, until,m_chansel,m_tag);
           while (itr->hasNext()) {
             CoraCoolObjectPtr obj=itr->next();
             //should be skipping non-selected channels here?
             addIOVtoCache(obj->since(),obj->until());
             m_cachechan.push_back(obj->channelId());
             // store all the attributeLists in the buffer
             // save pointer to start
             const unsigned int istart=m_cacheattr.size();
             for (CoraCoolObject::const_iterator pitr=obj->begin();pitr!=obj->end(); ++pitr) {
               // setup shared specification on first store
               if (m_cachespec==nullptr) setSharedSpec(*pitr);
               // use the shared specification in storing the payload
               m_cacheattr.emplace_back(*m_cachespec,true);
               m_cacheattr.back().fastCopyData(*pitr);
               m_nbytesread+=IOVDbNamespace::attributeListSize(*pitr);
             }
             // save pointers to start and end
             m_cacheccstart.push_back(istart);
             m_cacheccend.push_back(m_cacheattr.size());
             ++iadd;
           }
           itr->close();
           retrievedone=true;
         } else {
           auto [since,until] = m_iovs.getCacheBounds();
           cool::IObjectIteratorPtr itr=folder->browseObjects(since,until,m_chansel,m_tag);
           if (m_outputToFile ||m_crestCoolToFile ) {
             Cool2Json json(folder, since, until, m_chansel, m_tag);
         dumpFile("cool_dump",vkey,&json,m_crestCoolToFile,nullptr,"","");
           }
           while (itr->goToNext()) {
             const cool::IObject& ref=itr->currentRef();
             addIOVtoCache(ref.since(),ref.until());
             m_cachechan.push_back(ref.channelId());
             if (m_foldertype==CoolVector) {
               // store all the attributeLists in the buffer
               // save pointer to start
               const unsigned int istart=m_cacheattr.size();
               // get payload iterator and vector of payload records
               cool::IRecordIterator& pitr=ref.payloadIterator();
               const cool::IRecordVectorPtr& pvec=pitr.fetchAllAsVector();
               for (cool::IRecordVector::const_iterator vitr=pvec->begin();vitr!=pvec->end();++vitr) {
                 const coral::AttributeList& atrlist=(*vitr)->attributeList();
                 // setup shared specification on first store
                 if (m_cachespec==nullptr) setSharedSpec(atrlist);
                 // use the shared specification in storing the payload
                 m_cacheattr.emplace_back(*m_cachespec,true);
                 m_cacheattr.back().fastCopyData(atrlist);
                 m_nbytesread+=IOVDbNamespace::attributeListSize(atrlist);
               }
               // save pointers to start and end
               m_cacheccstart.push_back(istart);
               m_cacheccend.push_back(m_cacheattr.size());
               ++iadd;
               pitr.close();
             } else {
               // standard COOL retrieve
               const coral::AttributeList& atrlist=ref.payload().attributeList();
               // setup shared specification on first store
               if (m_cachespec==nullptr) setSharedSpec(atrlist);
               // use the shared specification in storing the payload
               m_cacheattr.emplace_back(*m_cachespec,true);
               m_cacheattr[iadd].fastCopyData(atrlist);
               ++iadd;
               m_nbytesread+=IOVDbNamespace::attributeListSize(atrlist);
             }
           }
           itr->close();
           retrievedone=true;
         }
         ATH_MSG_DEBUG( "Retrieved " << iadd << " objects for "<< m_nchan << " channels into cache" );
         m_nobjread+=iadd;
       } catch (std::exception& e) {
         ATH_MSG_WARNING( "COOL retrieve attempt " << attempts << " failed: " << e.what() );
         // disconnect and reconnect
         if (not m_conn->dropAndReconnect()) ATH_MSG_ERROR("Tried to reconnect in 'loadCache' but failed");
       }
     }
   } // End of COOL reading section
   else {
     // CREST reading section
     auto [since,until] = m_iovs.getCacheBounds();
     std::vector<BasicFolder> crestObjs;
     try {
       crestObjs = fetchCrestObjects(since,until,vectorPayload,vkey,strCrestNodeDesc);
     }
     catch(std::exception&) {
       return false;
     }
  
     unsigned int iadd = 0;
  
     if (!resolveTag(nullptr,globalTag)) return false; 
     ATH_MSG_DEBUG( "loadCache: Expecting to see " << nChannelsExpected << " channels" );
  
     for(BasicFolder& basicFolder : crestObjs) {
       const auto & channelNumbers=basicFolder.channelIds();
       ATH_MSG_DEBUG( "ChannelIds is " << channelNumbers.size() << " long" );
       for (const auto & chan: channelNumbers){
         addIOVtoCache(basicFolder.iov().first, basicFolder.iov().second);
         m_cachechan.push_back(chan);
         if (basicFolder.isVectorPayload()) {
           const auto & vPayload = basicFolder.getVectorPayload(chan);
           const unsigned int istart=m_cacheattr.size();
           for (const auto & attList:vPayload){
             if (m_cachespec==nullptr) setSharedSpec(attList);
             m_cacheattr.emplace_back(*m_cachespec,true);// maybe needs to be cleared before
             m_cacheattr.back().fastCopyData(attList);
             m_nbytesread+=IOVDbNamespace::attributeListSize(attList);
           }
           m_cacheccstart.push_back(istart);
           m_cacheccend.push_back(m_cacheattr.size());
           ++iadd;
         } else {
           auto const & attList = basicFolder.getPayload(chan);
           if (m_cachespec==nullptr) setSharedSpec(attList);
           const coral::AttributeList c(*m_cachespec,true);
           m_cacheattr.push_back(c);// maybe needs to be cleared before
           m_cacheattr.back().fastCopyData(attList);
           m_nbytesread+=IOVDbNamespace::attributeListSize(attList);
           ++iadd;
         }
       }
     }
     retrievedone=true;
     ATH_MSG_DEBUG( "Retrieved " << iadd << " objects for "<< m_nchan << " channels into cache" );
     m_nobjread+=iadd;
   } // End of reading from CREST
  
   if (!retrievedone) {
     const auto & [since,until] = m_iovs.getCacheBounds();
     ATH_MSG_ERROR( "Could not retrieve Cond data for folder " <<
       m_foldername << " tag " << m_tag << " validityKeys [" << since <<
       "," << until << "]" );
     return false;
   }
   // check if cache can be stretched according to extent of IOVs crossing
   // boundaries - this requires all channels to have been seen
   const auto & [nChannelsLo, nChannelsHi] = m_iovs.numberOfIovsOnBoundaries();
   const auto  missing=std::pair<unsigned int, unsigned int>(nChannelsExpected-nChannelsLo, nChannelsExpected-nChannelsHi);
   ATH_MSG_DEBUG( "Cache retrieve missing " << missing.first  << " lower and " << missing.second << " upper channels" );
   //
   const auto & span = m_iovs.getMinimumStraddlingSpan();
   const auto & [cacheStart, cacheStop] =m_iovs.getCacheBounds();
   //new code
   if ((missing.first==0 or ignoreMissChan) and m_iovs.extendCacheLo()){
     ATH_MSG_DEBUG( "Lower cache limit extended from " << cacheStart << " to " << span.first );
   }
   
   if ((missing.second==0 or ignoreMissChan) and m_iovs.extendCacheHi()){
     ATH_MSG_DEBUG( "Upper cache limit extended from " << cacheStop << " tp " << span.second );
   }
   //
   // keep track of time spent
   const float timeinc=cachetimer.RealTime();
   m_readtime+=timeinc;
   ATH_MSG_DEBUG( "Cache retrieve done for " << m_foldername << " with " << 
       m_iovs.size() << " objects stored in" << std::fixed <<
       std::setw(8) << std::setprecision(2) << timeinc << " s" );
   return true;
 }

◆ loadCacheIfDbChanged()

bool IOVDbFolder::loadCacheIfDbChanged	(	const cool::ValidityKey	vkey,
		const std::string &	globalTag,
		const cool::IDatabasePtr &	dbPtr,
		const ServiceHandle< IIOVSvc > &	iovSvc
	)

Definition at line 509 of file IOVDbFolder.cxx.

                                                                              {
   ATH_MSG_DEBUG( "IOVDbFolder::recheck with DB for folder " << m_foldername<< " validitykey: " << vkey );
   if (m_iovs.empty()) {
     ATH_MSG_DEBUG( "Cache empty ! returning ..." );
     return true;
   }
   ++m_ndbread;
   // access COOL inside try/catch in case of using stale connection
   unsigned int attempts     = 0;
   bool         retrievedone = false;
   //
   unsigned int nChannelsExpected = (m_chanrange.empty())? (m_nchan) : (IOVDbNamespace::countSelectedChannels(m_channums, m_chansel));
   ATH_MSG_DEBUG( "loadCacheIfDbChanged: Expecting to see " << nChannelsExpected << " channels" );
   //
   while (attempts<2 && !retrievedone) {
     ++attempts;
     try {
       m_iovs.setIovSpan(IovStore::Iov_t(0,cool::ValidityKeyMax));
       // access COOL folder in case needed to resolve tag (even for CoraCool)
       cool::IFolderPtr folder=m_conn->getFolderPtr(m_foldername);
       // resolve the tag for MV folders if not already done so
       if (m_multiversion && m_tag.empty()) { // NEEDED OR NOT?
         if (!resolveTag(folder,globalTag)) return false;
       }   
       int counter=0;
       const auto & [since,until] = m_iovs.getCacheBounds();
       ATH_MSG_DEBUG(IOVDbNamespace::folderTypeName(m_foldertype)<<" type. cachestart:\t"<<since<<" \t cachestop:"<< until);
       ATH_MSG_DEBUG("checking range:  "<<vkey+1<<" - "<<vkey+2);
       if (m_foldertype==CoraCool) {
         // CoraCool retrieve initialise CoraCool connection
         CoraCoolFolderPtr   ccfolder  = m_conn->getFolderPtr<CoraCoolFolderPtr>(m_foldername);
         // this returns all the objects whose IOVRanges crosses this range .
         CoraCoolObjectIterPtr itr = ccfolder->browseObjects(vkey+1, vkey+2,m_chansel,m_tag);
         while (objectIteratorIsValid(itr)) {
           CoraCoolObjectPtr obj = itr->next();
           //code delegated to templated member, allowing for difference between CoraCoolObjectPtr and IObject
           counter+=cacheUpdateImplementation(*obj,iovSvc);
         }
         itr->close();
       } else {
         // this returns all the objects whose IOVRanges crosses this range . 
         cool::IObjectIteratorPtr itr=folder->browseObjects(vkey+1, vkey+2, m_chansel,m_tag);
         while (objectIteratorIsValid(itr)) {
           const cool::IObject& ref=itr->currentRef();
           //code delegated to templated member, allowing for difference between CoraCoolObjectPtr and IObject
           counter+=cacheUpdateImplementation(ref,iovSvc);
         }
         itr->close();
       }
       retrievedone=true;
       ATH_MSG_DEBUG( "Need a special update for " << counter << " objects " );      
       m_nobjread+=counter;
     }catch (std::exception& e) {
       ATH_MSG_WARNING( "COOL retrieve attempt " << attempts <<  " failed: " << e.what() );
       if (not m_conn->dropAndReconnect()) ATH_MSG_ERROR("Tried reconnecting in loadCacheIfDbChanged but failed");
     }
   }
   return true;
 }

◆ magicTag()

bool IOVDbFolder::magicTag ( std::string & tag )

private

Definition at line 1105 of file IOVDbFolder.cxx.

                                     { //alters the argument
   tag = IOVDbNamespace::resolveUsingTagInfo(tag, p_tagInfoMgr);
   return (not tag.empty());
 }

◆ 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 164 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 179 of file AthMessaging.h.

180 { 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 (!m_initialized.test_and_set()) initMessaging();
   if (m_lvl <= lvl) {
     msg() << lvl;
     return true;
   } else {
     return false;
   }
 }

◆ multiVersion()

bool IOVDbFolder::multiVersion ( ) const

inline

Definition at line 342 of file IOVDbFolder.h.

342 { return m_multiversion; }

◆ noOverride()

bool IOVDbFolder::noOverride ( ) const

inline

Definition at line 348 of file IOVDbFolder.h.

348 { return m_notagoverride; }

◆ objectIteratorIsValid() [1/2]

bool IOVDbFolder::objectIteratorIsValid ( cool::IObjectIteratorPtr & objItr )

inlineprivate

Definition at line 218 of file IOVDbFolder.h.

                                                          {
     return objItr->goToNext();
   }

◆ objectIteratorIsValid() [2/2]

bool IOVDbFolder::objectIteratorIsValid ( CoraCoolObjectIterPtr & objItr )

inlineprivate

Definition at line 223 of file IOVDbFolder.h.

                                                        {
     return objItr->hasNext();
   }

◆ overrideOptionsFromParsedDescription()

bool IOVDbFolder::overrideOptionsFromParsedDescription ( const IOVDbParser & parsedDescription )

private

Definition at line 832 of file IOVDbFolder.cxx.

                                                                                       {
   bool success{true};
   // check for timeStamp indicating folder is timestamp indexed
   m_timestamp=parsedDescription.timebaseIs_nsOfEpoch();
   // check for key, giving a different key to the foldername
   if (auto newkey=parsedDescription.key(); not newkey.empty() and not m_jokey) {
     ATH_MSG_DEBUG( "Key for folder " << m_foldername << " set to "<< newkey << " from description string" );
     m_key=newkey;
   }
   // check for 'cache' but only if not already found in joboptions
   if (m_cachepar.empty()) m_cachepar=parsedDescription.cache();
   // check for cachehint
   if (int newCachehint=parsedDescription.cachehint();newCachehint!=0) m_cachehint=newCachehint;
   // check for <named/>   
   m_named=parsedDescription.named();
    // get addressHeader
   if (auto newAddrHeader = parsedDescription.addressHeader();not newAddrHeader.empty()){
     IOVDbNamespace::replaceServiceType71(newAddrHeader);
     m_addrheader=newAddrHeader;
   }
   //get clid, if it exists (set to zero otherwise)
   m_clid=parsedDescription.classId(msg());
   // decode the typeName
   if (!parsedDescription.getKey("typeName","",m_typename)) {
     ATH_MSG_ERROR( "Primary type name is empty" );
     return false;
   }
   bool gotCLID=(m_clid!=0);
   
   ATH_MSG_DEBUG( "Got folder typename " << m_typename );
   if (!gotCLID)
     if (StatusCode::SUCCESS==p_clidSvc->getIDOfTypeName(m_typename,m_clid)) 
       gotCLID=true;
   if (!gotCLID) {
     ATH_MSG_ERROR("Could not get clid for typeName: " << m_typename);
     return false;
   }
   ATH_MSG_DEBUG( "Got folder typename " << m_typename <<  " with CLID " << m_clid );
   return success;
 }

◆ preLoadFolder()

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

Definition at line 893 of file IOVDbFolder.cxx.

                                                                                                               {
   // preload Address from SG - does folder setup including COOL access
   // also set detector store location - cannot be done in constructor
   // as detector store does not exist yet in IOVDbSvc initialisation
   // and sets up cache length, taking into account optional overrides
   // returns null pointer in case of problem
   p_tagInfoMgr = tagInfoMgr;
   if( not m_useFileMetaData ) {
     if(m_source=="CREST"){
       if (m_crest_tag != m_crestTag){
         m_crest_tag = m_crestTag;
         m_tag_info = m_cfunctions.value().getTagInfo(m_crestTag); 
       }
       m_folderDescription = m_cfunctions.value().folderDescriptionForTag(m_crestTag);
     } else {
       //folder desc from db
       std::tie(m_multiversion, m_folderDescription) = IOVDbNamespace::folderMetadata(m_conn, m_foldername);
     }
   } else {
     // folder description from meta-data set already earlier
   }
   ATH_MSG_DEBUG( "Folder description for " << m_foldername << ": " << m_folderDescription);
   // register folder with meta-data tool if writing metadata
   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;
     }
   }
   // parse the description string
   IOVDbParser folderpar(m_folderDescription, msg());
   //use the overrides in the folderdescription, return nullptr immediately if something went wrong
   if (not overrideOptionsFromParsedDescription(folderpar)) return nullptr;
   // setup channel list and folder type
   if( not m_useFileMetaData ) {
     if(m_source=="CREST"){
         const std::string & payloadSpec = m_cfunctions.value().getTagInfoElement(m_tag_info,"payload_spec");   
         std::string chanList = m_cfunctions.value().getTagInfoElement(m_tag_info,"channel_list"); 
         std::tie(m_channums, m_channames) = m_cfunctions.value().extractChannelListFromString(chanList); 
     
         //determine foldertype from the description, the spec and the number of channels
         m_foldertype = IOVDbNamespace::determineFolderType(m_folderDescription, payloadSpec, m_channums);
  
         if (m_crestToFile){
           int n_size = m_channums.size();
       nlohmann::json chan_list = nlohmann::json::array();
           for (int i = 0; i < n_size; i++) {
  
             nlohmann::json elem;
         std::string key = std::to_string(m_channums[i]);
             elem[key] = m_channames[i];
             chan_list.push_back(elem);
           }
  
           char ch = ':';
           int colsize = std::count(payloadSpec.begin(), payloadSpec.end(), ch);
  
       nlohmann::json tag_meta;
           tag_meta["tagName"] = m_crestTag;
           tag_meta["description"] = "";
           tag_meta["chansize"] = n_size;
           tag_meta["colsize"] = colsize;
  
       nlohmann::json tagInfo;
           tagInfo["channel_list"] = chan_list;
           tagInfo["node_description"] = m_folderDescription;
           tagInfo["payload_spec"] = payloadSpec;
  
           tag_meta["tagInfo"] = tagInfo.dump();
  
           std::string crest_work_dir=std::filesystem::current_path();
           crest_work_dir += "/crest_data";
           bool crest_rewrite = true;
  
       Crest::CrestApiFs crestFSClient = Crest::CrestApiFs(crest_rewrite, crest_work_dir);
  
           try{
         TagMetaDto dto = TagMetaDto();
         dto = dto.fromJson(tag_meta);
             crestFSClient.createTagMeta(dto);
         
             ATH_MSG_INFO("Tag meta info for " << m_crestTag << " saved to disk.");
             ATH_MSG_INFO("CREST Dump dir = " << crest_work_dir);
           }
           catch (const std::exception& e) {
             ATH_MSG_WARNING("Tag meta info saving for tag " << m_crestTag << " failed: " << e.what());
           }
     } // m_crestToFile
  
     } else {
       // data being read from COOL
       auto fldPtr=m_conn->getFolderPtr<cool::IFolderPtr>(m_foldername);
       // get the list of channels
       std::tie(m_channums, m_channames) = IOVDbNamespace::channelList(m_conn, m_foldername,m_named);
       // set folder type 
       m_foldertype = IOVDbNamespace::determineFolderType(fldPtr);
     }
   }
   m_nchan=m_channums.size();
   ATH_MSG_DEBUG( "Folder identified as type " << m_foldertype );
   // note that for folders read from metadata, folder type identification
   // is deferred until getAddress when first data is read
   // and channel number/name information is not read
  
   // change channel selection for single-object read
   if (m_foldertype==AttrList || m_foldertype==PoolRef) m_chansel=cool::ChannelSelection(0);
   const auto & linknameVector = folderpar.symLinks();
   // now create TAD
   auto tad{createTransientAddress(linknameVector)};
   if (not tad) {
     ATH_MSG_WARNING("Transient address is null in "<<__func__);
     return nullptr;
   }
   setCacheLength(m_timestamp, cacheRun, cacheTime);
   return tad;
 }

◆ printCache()

void IOVDbFolder::printCache ( )

Definition at line 1160 of file IOVDbFolder.cxx.

                        {
     const auto & [since,until] = m_iovs.getCacheBounds(); 
     ATH_MSG_DEBUG("folder cache printout -------------------");
     ATH_MSG_DEBUG(m_foldername << " length: "<<m_cachelength<<"\tstart: "<<since<<"\tstop: "<<until);
     ATH_MSG_DEBUG("current range: "<<m_currange);
     const auto & iovs = m_iovs.vectorStore();
     std::vector<cool::ChannelId>::iterator      ci= m_cachechan.begin();
     for (const auto & iov:iovs){
       ATH_MSG_DEBUG("channelID:\t"<<(*ci++)<<"\t since: "<<iov.first<<"\t until: "<<iov.second);
     }
     ATH_MSG_DEBUG("folder cache printout -------------------");
   
 }

◆ readMeta()

bool IOVDbFolder::readMeta ( ) const

inline

Definition at line 358 of file IOVDbFolder.h.

358 { return m_useFileMetaData; }

◆ readTime()

float IOVDbFolder::readTime ( ) const

inline

Definition at line 382 of file IOVDbFolder.h.

383 { return m_readtime; }

◆ resetCache()

void IOVDbFolder::resetCache ( )

Definition at line 626 of file IOVDbFolder.cxx.

                         {
   // reset the cache to unfilled state, used if no more data will be required
   // from this folder
   m_iovs.setCacheBounds(IovStore::Iov_t(0,0));
   clearCache();
 }

◆ resolvedTag()

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

inline

Definition at line 372 of file IOVDbFolder.h.

372 { return m_tag; }

◆ resolveTag()

bool IOVDbFolder::resolveTag	(	const cool::IFolderPtr &	fptr,
		const std::string &	globalTag
	)

private

Definition at line 1048 of file IOVDbFolder.cxx.

                                                                              {
   // resolve the tag 
   // if specified in job options or already-processed override use that,
   // else use global tag
   // return false for failure
   std::string tag=m_jotag;
   if (tag=="HEAD") return true;
   if (tag.empty()) tag=globalTag;
   if (tag.empty()) {
     ATH_MSG_ERROR( "No IOVDbSvc.GlobalTag specified on job options or input file" );
     return false;
   }
   if(m_source=="CREST"){
  
     m_tag = m_crestTag;
  
     ATH_MSG_DEBUG( "resolveTag returns " << m_tag );
     return true;
   }
   // check for magic tags
   if (IOVDbNamespace::looksLikeMagicTag(tag) and not magicTag(tag)) return false;
   // check tag exists - if not, lookup hierarchically
   const std::vector<std::string>& taglist=fptr->listTags();
   if (find(taglist.begin(),taglist.end(),tag)!=taglist.end()) {
     // tag exists directly in folder
     ATH_MSG_DEBUG( "Using tag "<< tag << " for folder " << m_foldername );
   } else {
     // tag maybe an HVS tag 
     try {
       std::string restag=fptr->resolveTag(tag);
       ATH_MSG_INFO( "HVS tag " << tag << " resolved to "<< restag << " for folder " << m_foldername );
       // HVS tag may itself be magic
       if (IOVDbNamespace::looksLikeMagicTag(restag) and not magicTag(restag)) return false;
       tag=restag;
     }catch (cool::Exception& e) {
       ATH_MSG_ERROR( "Tag " << tag <<" cannot be resolved for folder " << m_foldername );
       return false;
     }
   }
   m_tag=tag;
   // optionally check if tag is locked
   if (m_checklock) {
     const auto tagLock=IOVDbNamespace::checkTagLock(fptr,tag);
     if (not tagLock.has_value()){
       ATH_MSG_ERROR( "Could not check tag lock status for " << tag );
       return false;
     }
     if (not tagLock.value()){
       ATH_MSG_ERROR("Tag " << tag <<" is not locked and IOVDbSvc.CheckLock is set" );
       return false;
     }
   }
   ATH_MSG_DEBUG( "resolveTag returns " << m_tag );
   return true;
 }

◆ retrieved()

bool IOVDbFolder::retrieved ( ) const

inline

Definition at line 350 of file IOVDbFolder.h.

350 { return m_retrieved; }

◆ setCacheLength()

void IOVDbFolder::setCacheLength	(	const bool	timeIs_nsOfEpoch,
		const unsigned int	cacheRun,
		const unsigned int	cacheTime
	)

private

Definition at line 1010 of file IOVDbFolder.cxx.

                                                                                                                       {
   if (timeIs_nsOfEpoch){
     long long int clen=600; // default value of 10 minutes
     if (cacheTime!=0) {
       clen=cacheTime;
       m_autocache=false;
     } else {
       // for timestamp, cache parameter (if set) sets length in seconds
       if (not m_cachepar.empty()) clen=std::stoi(m_cachepar);
     }
     m_cachelength=IOVDbNamespace::iovTimeFromSeconds(clen);
     ATH_MSG_DEBUG( "Cache length set to " << clen << " seconds" );
   } else {
     // for run/event, cache parameter sets length in LB
     // default value is 1 whole run
     m_cachelength=IOVDbNamespace::ALL_LUMI_BLOCKS;
     if (cacheRun!=0) {
       m_cachelength=IOVDbNamespace::iovTimeFromRunLumi(cacheRun-1,IOVDbNamespace::ALL_LUMI_BLOCKS);
       m_autocache=false;
     } else {
       if (not m_cachepar.empty()) m_cachelength=std::stoi(m_cachepar);
     }
     const auto [run,lumi]=IOVDbNamespace::runLumiFromIovTime(m_cachelength);
     ATH_MSG_DEBUG( "Cache length set to " << run <<" runs " << lumi << " lumiblocks" );
   }
 }

◆ setDropped()

void IOVDbFolder::setDropped ( const bool dropped )

inline

Definition at line 392 of file IOVDbFolder.h.

392 { m_dropped=dropped; }

◆ setFolderDescription()

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

inline

Definition at line 355 of file IOVDbFolder.h.

356 { m_folderDescription = description; }

◆ setIOVOverride()

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

Definition at line 192 of file IOVDbFolder.cxx.

                                                           {
   // set IOV override for this folder if run!=0 or time!=0
   // folder-specific override takes precedence if set
   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;
 }

◆ setSharedSpec()

void IOVDbFolder::setSharedSpec ( const coral::AttributeList & atrlist )

private

Definition at line 1139 of file IOVDbFolder.cxx.

                                                             {
   m_cachespec=new coral::AttributeListSpecification;
   for (const auto & attribute:atrlist){
     const coral::AttributeSpecification& aspec=attribute.specification();
     m_cachespec->extend(aspec.name(),aspec.type());
     if (not typeSizeIsKnown(attribute)) {
       ATH_MSG_WARNING( "addType: unknown type " << aspec.typeName()<< 
       " in folder " << m_foldername <<  " will not be counted for bytes-read statistics" );
     }
   }
   ATH_MSG_DEBUG( "Setup shared AttributeListSpecification with " <<  m_cachespec->size() << " elements" );
 }

◆ setTagOverride()

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

Definition at line 177 of file IOVDbFolder.cxx.

                                                                    {
   if (m_tagoverride) {
     ATH_MSG_WARNING( "Request to override tag for folder " <<
       m_foldername << " to " << tag << " supercedes earlier override to "  << m_jotag );
   } else {
     if (setFlag) m_tagoverride=true;
   }
   m_jotag=IOVDbNamespace::spaceStrip(tag);
 }

◆ setWriteMeta()

void IOVDbFolder::setWriteMeta ( )

Definition at line 187 of file IOVDbFolder.cxx.

                                {
   m_writemeta=true;
 }

◆ specialCacheUpdate() [1/2]

void IOVDbFolder::specialCacheUpdate	(	const cool::IObject &	obj,
		const ServiceHandle< IIOVSvc > &	iovSvc
	)

private

Definition at line 599 of file IOVDbFolder.cxx.

                                                                                            {
  
   // reset IOVRange in IOVSvc to trigger reset of object. Set to a
   // time earlier than since.
   IOVRange range = IOVDbNamespace::makeRange(ref.since()-2, ref.since()-1, m_timestamp);
   if (StatusCode::SUCCESS != iovSvc->setRange(clid(), key(), range, eventStore())) {
     ATH_MSG_ERROR( "IOVDbFolder::specialCacheUpdate - setRange failed for folder " 
            << folderName() );
     return;
   }
   // add new object.
   addIOVtoCache(ref.since(),ref.until());
   m_cachechan.push_back(ref.channelId());
   const coral::AttributeList& atrlist = ref.payload().attributeList();
   // use the shared specification in storing the payload
   const unsigned int istart=m_cacheattr.size();
   m_cacheattr.emplace_back(*m_cachespec,true);// maybe needs to be cleared before
   m_cacheattr.back().fastCopyData(atrlist);
   m_nbytesread+=IOVDbNamespace::attributeListSize(atrlist);
   if (m_foldertype==CoolVector) {
     // save pointers to start and end
     m_cacheccstart.push_back(istart);
     m_cacheccend.push_back(m_cacheattr.size());
   }
 }

◆ specialCacheUpdate() [2/2]

void IOVDbFolder::specialCacheUpdate	(	CoraCoolObject &	obj,
		const ServiceHandle< IIOVSvc > &	iovSvc
	)

private

Definition at line 573 of file IOVDbFolder.cxx.

                                                                                           {
  
   // reset IOVRange in IOVSvc to trigger reset of object. Set to a
   // time earlier than since.
   IOVRange range = IOVDbNamespace::makeRange(obj.since()-2, obj.since()-1, m_timestamp);
   if (StatusCode::SUCCESS != iovSvc->setRange(clid(), key(), range, eventStore())) {
     ATH_MSG_ERROR( "IOVDbFolder::specialCacheUpdate - setRange failed for folder " 
            << folderName() );
     return;
   }
   addIOVtoCache(obj.since(),obj.until());
   m_cachechan.push_back(obj.channelId());
   // store all the attributeLists in the buffer save pointer to start
   const unsigned int istart=m_cacheattr.size();
   for (CoraCoolObject::const_iterator pitr=obj.begin(); pitr!=obj.end();++pitr) {
     // use the shared specification in storing the payload
     m_cacheattr.emplace_back(*m_cachespec,true);
     m_cacheattr.back().fastCopyData(*pitr);
     m_nbytesread+=IOVDbNamespace::attributeListSize(*pitr);
   }
   // save pointers to start and end
   m_cacheccstart.push_back(istart);
   m_cacheccend.push_back(m_cacheattr.size());
 }

◆ summary()

void IOVDbFolder::summary ( )

Definition at line 817 of file IOVDbFolder.cxx.

                           {
   const std::string & folderTypeName=IOVDbNamespace::folderTypeName(m_foldertype);
   // summarise the read statistics for this folder
   ATH_MSG_INFO(  "Folder " << m_foldername << " ("<<folderTypeName
         << ") 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" );
   // print WARNING if data for this folder was never read from Storegate
   if (m_ncacheread==0 && m_ndbread>0) {
     ATH_MSG_WARNING( "Folder " << m_foldername << " is requested but no data retrieved" );
   }
 }

◆ tagOverride()

bool IOVDbFolder::tagOverride ( ) const

inline

Definition at line 346 of file IOVDbFolder.h.

346 { return m_tagoverride; }

◆ timeStamp()

bool IOVDbFolder::timeStamp ( ) const

inline

Definition at line 344 of file IOVDbFolder.h.

344 { return m_timestamp; }

◆ useFileMetaData()

void IOVDbFolder::useFileMetaData ( )

Definition at line 166 of file IOVDbFolder.cxx.

                                   {
   // enable folder from FLMD at given connection
   m_useFileMetaData = true;
   // if previously connected to a real DB connection, remove association
   if (m_conn!=nullptr) {
     m_conn->decUsage();
     m_conn=nullptr;
   }
 }

◆ writeMeta()

bool IOVDbFolder::writeMeta ( ) const

inline

Definition at line 360 of file IOVDbFolder.h.

360 { 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 IOVDbFolder::m_addrheader

private

Definition at line 300 of file IOVDbFolder.h.

◆ m_autocache

bool IOVDbFolder::m_autocache {true}

private

Definition at line 281 of file IOVDbFolder.h.

◆ m_cacheattr

std::vector<coral::AttributeList> IOVDbFolder::m_cacheattr

private

Definition at line 321 of file IOVDbFolder.h.

◆ m_cacheccend

std::vector<unsigned int> IOVDbFolder::m_cacheccend

private

Definition at line 323 of file IOVDbFolder.h.

◆ m_cacheccstart

std::vector<unsigned int> IOVDbFolder::m_cacheccstart

private

Definition at line 322 of file IOVDbFolder.h.

◆ m_cachechan

std::vector<cool::ChannelId> IOVDbFolder::m_cachechan

private

Definition at line 320 of file IOVDbFolder.h.

◆ m_cachehint

int IOVDbFolder::m_cachehint {0}

private

Definition at line 287 of file IOVDbFolder.h.

◆ m_cacheinc

int IOVDbFolder::m_cacheinc {0}

private

Definition at line 288 of file IOVDbFolder.h.

◆ m_cachelength

cool::ValidityKey IOVDbFolder::m_cachelength {0}

private

Definition at line 286 of file IOVDbFolder.h.

◆ m_cachepar

std::string IOVDbFolder::m_cachepar

private

Definition at line 299 of file IOVDbFolder.h.

◆ m_cachespec

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

private

Definition at line 319 of file IOVDbFolder.h.

◆ m_cfunctions

std::optional<IOVDbNamespace::CrestFunctions> IOVDbFolder::m_cfunctions

private

Definition at line 334 of file IOVDbFolder.h.

◆ m_channames

std::vector<std::string> IOVDbFolder::m_channames

private

Definition at line 312 of file IOVDbFolder.h.

◆ m_channums

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

private

Definition at line 311 of file IOVDbFolder.h.

◆ m_chanrange

std::vector<ChanRange> IOVDbFolder::m_chanrange

private

Definition at line 292 of file IOVDbFolder.h.

◆ m_chansel

cool::ChannelSelection IOVDbFolder::m_chansel

private

Definition at line 290 of file IOVDbFolder.h.

◆ m_checklock

bool IOVDbFolder::m_checklock {true}

private

Definition at line 282 of file IOVDbFolder.h.

◆ m_clid

CLID IOVDbFolder::m_clid {0}

private

Definition at line 301 of file IOVDbFolder.h.

◆ m_conn

IOVDbConn* IOVDbFolder::m_conn {nullptr}

private

Definition at line 265 of file IOVDbFolder.h.

◆ m_crest_tag

std::string IOVDbFolder::m_crest_tag = ""

private

Definition at line 331 of file IOVDbFolder.h.

◆ m_crestCoolToFile

const bool IOVDbFolder::m_crestCoolToFile {false}

private

Definition at line 327 of file IOVDbFolder.h.

◆ m_crestServer

const std::string IOVDbFolder::m_crestServer

private

Definition at line 329 of file IOVDbFolder.h.

◆ m_crestTag

const std::string IOVDbFolder::m_crestTag

private

Definition at line 330 of file IOVDbFolder.h.

◆ m_crestToFile

const bool IOVDbFolder::m_crestToFile {false}

private

Definition at line 326 of file IOVDbFolder.h.

◆ m_currange

IOVRange IOVDbFolder::m_currange

private

Definition at line 316 of file IOVDbFolder.h.

◆ m_dropped

bool IOVDbFolder::m_dropped {false}

private

Definition at line 280 of file IOVDbFolder.h.

◆ m_eventstore

std::string IOVDbFolder::m_eventstore

private

Definition at line 298 of file IOVDbFolder.h.

◆ m_extensible

bool IOVDbFolder::m_extensible {false}

private

Definition at line 276 of file IOVDbFolder.h.

◆ m_folderDescription

std::string IOVDbFolder::m_folderDescription

private

Definition at line 268 of file IOVDbFolder.h.

◆ m_foldername

std::string IOVDbFolder::m_foldername

private

Definition at line 266 of file IOVDbFolder.h.

◆ m_foldertype

IOVDbNamespace::FolderType IOVDbFolder::m_foldertype

private

Definition at line 284 of file IOVDbFolder.h.

◆ m_fromMetaDataOnly

bool IOVDbFolder::m_fromMetaDataOnly {false}

private

Definition at line 275 of file IOVDbFolder.h.

◆ m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_iovoverridden

bool IOVDbFolder::m_iovoverridden {false}

private

Definition at line 278 of file IOVDbFolder.h.

◆ m_iovoverride

cool::ValidityKey IOVDbFolder::m_iovoverride {0}

private

Definition at line 283 of file IOVDbFolder.h.

◆ m_iovs

IOVDbNamespace::IovStore IOVDbFolder::m_iovs

private

Definition at line 324 of file IOVDbFolder.h.

◆ m_jokey

bool IOVDbFolder::m_jokey {false}

private

Definition at line 279 of file IOVDbFolder.h.

◆ m_jotag

std::string IOVDbFolder::m_jotag

private

Definition at line 295 of file IOVDbFolder.h.

◆ m_key

std::string IOVDbFolder::m_key

private

Definition at line 267 of file IOVDbFolder.h.

◆ m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ 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_multiversion

bool IOVDbFolder::m_multiversion {false}

private

Definition at line 269 of file IOVDbFolder.h.

◆ m_named

bool IOVDbFolder::m_named {false}

private

Definition at line 277 of file IOVDbFolder.h.

◆ m_nbytesread

unsigned long long IOVDbFolder::m_nbytesread {0}

private

Definition at line 306 of file IOVDbFolder.h.

◆ m_ncacheread

unsigned int IOVDbFolder::m_ncacheread {0}

private

Definition at line 304 of file IOVDbFolder.h.

◆ m_nchan

unsigned int IOVDbFolder::m_nchan {0}

private

Definition at line 310 of file IOVDbFolder.h.

◆ m_ndbread

unsigned int IOVDbFolder::m_ndbread {0}

private

Definition at line 303 of file IOVDbFolder.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_nobjread

unsigned int IOVDbFolder::m_nobjread {0}

private

Definition at line 305 of file IOVDbFolder.h.

◆ m_notagoverride

bool IOVDbFolder::m_notagoverride {false}

private

Definition at line 272 of file IOVDbFolder.h.

◆ m_outputToFile

const bool IOVDbFolder::m_outputToFile {false}

private

Definition at line 325 of file IOVDbFolder.h.

◆ m_readtime

float IOVDbFolder::m_readtime {0}

private

Definition at line 307 of file IOVDbFolder.h.

◆ m_retrieved

bool IOVDbFolder::m_retrieved {false}

private

Definition at line 315 of file IOVDbFolder.h.

◆ m_source

const std::string IOVDbFolder::m_source

private

Definition at line 328 of file IOVDbFolder.h.

◆ m_tag

std::string IOVDbFolder::m_tag

private

Definition at line 296 of file IOVDbFolder.h.

◆ m_tag_info

nlohmann::json IOVDbFolder::m_tag_info = nullptr

private

Definition at line 332 of file IOVDbFolder.h.

◆ m_tagoverride

bool IOVDbFolder::m_tagoverride {false}

private

Definition at line 271 of file IOVDbFolder.h.

◆ m_timestamp

bool IOVDbFolder::m_timestamp {false}

private

Definition at line 270 of file IOVDbFolder.h.

◆ m_typename

std::string IOVDbFolder::m_typename

private

Definition at line 297 of file IOVDbFolder.h.

◆ m_useFileMetaData

bool IOVDbFolder::m_useFileMetaData {false}

private

Definition at line 274 of file IOVDbFolder.h.

◆ m_writemeta

bool IOVDbFolder::m_writemeta {false}

private

Definition at line 273 of file IOVDbFolder.h.

◆ p_clidSvc

IClassIDSvc* IOVDbFolder::p_clidSvc {nullptr}

private

Definition at line 263 of file IOVDbFolder.h.

◆ p_metaDataTool

IIOVDbMetaDataTool* IOVDbFolder::p_metaDataTool {nullptr}

private

Definition at line 264 of file IOVDbFolder.h.

◆ p_tagInfoMgr

ITagInfoMgr* IOVDbFolder::p_tagInfoMgr {nullptr}

private

Definition at line 262 of file IOVDbFolder.h.

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ChanRange

◆ IOV2Index

◆ IOVHash

Constructor & Destructor Documentation

◆ IOVDbFolder()

◆ ~IOVDbFolder()

Member Function Documentation

◆ addIOVtoCache()

◆ addMetaAttrList()

◆ addMetaAttrListColl()

◆ bytesRead()

◆ cacheUpdateImplementation()

◆ cacheValid()

◆ clearCache()

◆ clid()

◆ conn()

◆ createTransientAddress()

◆ currentRange()

◆ dropped()

◆ dumpFile()

◆ eventStore()

◆ extensible()

◆ fetchCrestIOVs()

◆ fetchCrestObjects()

◆ folderName()

◆ folderType()

◆ fromMetaDataOnly()

◆ getAddress()

◆ initMessaging()

◆ iovOverridden()

◆ iovTime()

◆ joTag()

◆ key()

◆ loadCache()

◆ loadCacheIfDbChanged()

◆ magicTag()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ multiVersion()

◆ noOverride()

◆ objectIteratorIsValid() [1/2]

◆ objectIteratorIsValid() [2/2]

◆ overrideOptionsFromParsedDescription()

◆ preLoadFolder()

◆ printCache()

◆ readMeta()

◆ readTime()

◆ resetCache()

◆ resolvedTag()

◆ resolveTag()

◆ retrieved()

◆ setCacheLength()

◆ setDropped()

◆ setFolderDescription()

◆ setIOVOverride()

◆ setLevel()

◆ setSharedSpec()

◆ setTagOverride()

◆ setWriteMeta()

◆ specialCacheUpdate() [1/2]

◆ specialCacheUpdate() [2/2]

◆ summary()

◆ tagOverride()

◆ timeStamp()

◆ useFileMetaData()

◆ writeMeta()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_addrheader

◆ m_autocache

◆ m_cacheattr

◆ m_cacheccend

◆ m_cacheccstart