IOVDbFolder Class Reference

#include <IOVDbFolder.h>

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

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< IOVHash >	fetchCrestObjects (cool::ValidityKey since, cool::ValidityKey until, cool::ValidityKey vkey)
void	dumpFile (const std::string &dumpName, const cool::ValidityKey &vkey, IOVDbNamespace::Cool2Json *json, bool skipCoolIoV, CoralCrestManager *mng=NULL, const cool::ValidityKey crestVkey=0) const
void	initMessaging () const
	Initialize our message level and MessageSvc.

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_crestCoolToFile {false}
const std::string	m_source
const std::string	m_crestServer
const std::string	m_crestTag
std::optional< CoralCrestManager >	m_crest_mng
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 50 of file IOVDbFolder.h.

Member Typedef Documentation

ChanRange

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

private

Definition at line 284 of file IOVDbFolder.h.

IOV2Index

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

private

Definition at line 235 of file IOVDbFolder.h.

IOVHash

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

private

Definition at line 234 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 std::string &	crestServer = "",
		const std::string &	crestTag = "",
		const bool	crestCoolToFile = false )

Definition at line 71 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_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_crest_mng.emplace(CoralCrestManager(crestServer,m_crestTag));
  }
  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 161 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 1091 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 1051 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 1063 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 369 of file IOVDbFolder.h.

{ return m_nbytesread; }

cacheUpdateImplementation()

template<class T>

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

inlineprivate

Definition at line 175 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 377 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 976 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 367 of file IOVDbFolder.h.

{ return m_clid; }

conn()

IOVDbConn * IOVDbFolder::conn ( )

inline

Definition at line 330 of file IOVDbFolder.h.

{ return m_conn;}

createTransientAddress()

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

private

Definition at line 865 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 375 of file IOVDbFolder.h.

{ return m_currange; }

dropped()

bool IOVDbFolder::dropped ( ) const

inline

Definition at line 356 of file IOVDbFolder.h.

{ return m_dropped; }

dumpFile()

void IOVDbFolder::dumpFile ( const std::string & dumpName, const cool::ValidityKey & vkey, IOVDbNamespace::Cool2Json * json, bool skipCoolIoV, CoralCrestManager * mng = NULL, const cool::ValidityKey crestVkey = 0 ) const

private

Definition at line 1136 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);
  //ignore return code; if the file does not exist, we don't care
  //coverity[CHECKED_RETURN]
  std::remove(fabricatedName.c_str());
  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
    myFile<<"\"node_description\" : \""<<m_folderDescription<< '\"'<<s_delimiterJson<<std::endl;
    myFile<<"\"folder_payloadspec\": \""<<mng->getPayloadSpec()<< '\"'<<s_delimiterJson<<std::endl;
    myFile<<"\"data_array\" : "<<mng->dumpPayload(crestVkey)<<std::endl;
  }
  myFile<<s_closeJson;
}

eventStore()

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

inline

Definition at line 364 of file IOVDbFolder.h.

{ return m_eventstore; }

extensible()

bool IOVDbFolder::extensible ( ) const

inline

Definition at line 354 of file IOVDbFolder.h.

{ return m_extensible; }

fetchCrestIOVs()

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

private

Definition at line 1112 of file IOVDbFolder.cxx.

{
  std::vector<IOVHash> result;
 
  // Get a vector of pairs retrieved from crest
  std::vector<std::pair<cool::ValidityKey,std::string>> crestIOVs = m_crest_mng.value().getIovsForTag(since,until);
  size_t nIOVs = crestIOVs.size();
  if(crestIOVs.empty()){
    ATH_MSG_WARNING("Load cache failed for " << m_foldername << ". No IOVs retrieved from the DB");
    return result; 
  }
 
  if(nIOVs>0) {
    if(nIOVs>1) {
      for(size_t ind=0; ind<nIOVs-1; ++ind) {
        result.emplace_back(IovStore::Iov_t(crestIOVs[ind].first, crestIOVs[ind+1].first),crestIOVs[ind].second);
      }
    }
    result.emplace_back(IovStore::Iov_t(crestIOVs[nIOVs-1].first, cool::ValidityKeyMax),crestIOVs[nIOVs-1].second);
  }
  
  return result;
}

fetchCrestObjects()

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

private

Definition at line 1181 of file IOVDbFolder.cxx.

{
  std::vector<IOVDbFolder::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);
    }
    if(m_crestCoolToFile)
      dumpFile("crest_dump",vkey,nullptr,false,&m_crest_mng.value(),vkey);
    return iovHashVect;
  }
  unsigned indIOVStart = 0;
  for(const auto& iovhash : iovHashVect) {
    if(vkey>=iovhash.first.first && vkey<iovhash.first.second)
      break;
    indIOVStart++;
  }
  unsigned indIOVEnd = indIOVStart;
  while(indIOVEnd < iovHashVect.size()) {
    if(iovHashVect[indIOVEnd].first.first < until
       && iovHashVect[indIOVEnd].first.second >= until) {
       break;
    }
    ++indIOVEnd;
  }
  std::vector<IOVDbFolder::IOVHash> resIovHashVect;
  for(unsigned ind = indIOVStart; ind <= indIOVEnd; ++ind) {
      std::vector<uint64_t> resIovs=m_crest_mng.value().loadPayloadForHash(iovHashVect[ind].first.first,iovHashVect[ind].second);
      if(resIovs.size()>1){
         uint64_t sTmp=iovHashVect[ind].first.first;
         uint64_t uTmp=0;
         for(unsigned int i=1;i<resIovs.size();i++){
           uTmp=resIovs[i];
           resIovHashVect.emplace_back(IovStore::Iov_t(sTmp, uTmp),iovHashVect[ind].second);
           sTmp=uTmp;
         }
         if(sTmp!=iovHashVect[ind].first.second){
           resIovHashVect.emplace_back(IovStore::Iov_t(sTmp, iovHashVect[ind].first.second),iovHashVect[ind].second);
         }
      }
      else if(resIovs.size()==1){
        resIovHashVect.emplace_back(IovStore::Iov_t(resIovs[0],iovHashVect[ind].first.second),iovHashVect[ind].second);
      }
      if(m_crestCoolToFile)
        break;
  }
  indIOVStart = 0;
  for(const auto& iovhash : resIovHashVect) {
    if(vkey>=iovhash.first.first && vkey<iovhash.first.second)
      break;
    if(indIOVStart+1<resIovHashVect.size())
      indIOVStart++;
  }
  if(m_crestCoolToFile) {
      dumpFile("crest_dump",vkey,nullptr,false,&m_crest_mng.value(),resIovHashVect[indIOVStart].first.first);
  }
  return resIovHashVect;
}

folderName()

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

inline

Definition at line 327 of file IOVDbFolder.h.

{return m_foldername;}

folderType()

IOVDbNamespace::FolderType IOVDbFolder::folderType ( ) const

inline

Definition at line 342 of file IOVDbFolder.h.

{return m_foldertype;}

fromMetaDataOnly()

bool IOVDbFolder::fromMetaDataOnly ( ) const

inline

Definition at line 352 of file IOVDbFolder.h.

{ 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 625 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();
  // 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 IOVDbFolder::iovOverridden ( ) const

inline

Definition at line 358 of file IOVDbFolder.h.

{ return m_iovoverridden; }

iovTime()

cool::ValidityKey IOVDbFolder::iovTime

(

const IOVTime &

reftime

)

const

Definition at line 216 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 360 of file IOVDbFolder.h.

{ return m_jotag; }

key()

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

inline

Definition at line 328 of file IOVDbFolder.h.

{ 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 225 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{};
  if (m_source == "CREST"){
    ATH_MSG_INFO("Download tag would be: "<<m_crestTag);
    m_crest_mng.value().loadTagInfo();
    vectorPayload = m_crest_mng.value().isVectorPayload();
  }
  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) {
            Cool2Json json(folder, since, until, m_chansel, m_tag);
        dumpFile("cool_dump",vkey,&json,m_crestCoolToFile);
          }
      else if(m_crestCoolToFile){
            Cool2Json json(folder, vkey, vkey, m_chansel, m_tag);
            dumpFile("cool_dump",vkey,&json,m_crestCoolToFile);
          }
          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
    unsigned int iadd = 0;
    auto [since,until] = m_iovs.getCacheBounds();
    std::vector<IOVHash> iovs = fetchCrestObjects(since,until,vkey);
    if (m_cachespec==nullptr)
      m_cachespec=m_crest_mng.value().getAttributeListSpec();
    for(const auto & [iov, hash] : iovs) {
       m_crest_mng.value().selectIov(iov.first);
       const auto & channelNumbers=m_crest_mng.value().channelIds(iov.first);
      for (auto const & chan: channelNumbers){
         addIOVtoCache(iov.first, iov.second);
         std::string token;
         std::istringstream tokenStream(chan);
         std::getline(tokenStream, token, ':');
         m_cachechan.push_back(std::stol(token));
         if(m_crest_mng.value().isVectorPayload()){
           const auto & vPayload = m_crest_mng.value().getVectorPayload(m_cachespec,chan);
          const unsigned int istart=m_cacheattr.size();
          for (const auto & attList:vPayload){
             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 = m_crest_mng.value().getPayload(m_cachespec,chan);
          const coral::AttributeList c(*m_cachespec,true);
          m_cacheattr.push_back(attList);// 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 500 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 1043 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 163 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 178 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 (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

multiVersion()

bool IOVDbFolder::multiVersion ( ) const

inline

Definition at line 332 of file IOVDbFolder.h.

{ return m_multiversion; }

noOverride()

bool IOVDbFolder::noOverride ( ) const

inline

Definition at line 338 of file IOVDbFolder.h.

{ return m_notagoverride; }

objectIteratorIsValid() [1/2]

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

inlineprivate

Definition at line 216 of file IOVDbFolder.h.

                                                         {
    return objItr->goToNext();
  }

objectIteratorIsValid() [2/2]

bool IOVDbFolder::objectIteratorIsValid ( CoraCoolObjectIterPtr & objItr )

inlineprivate

Definition at line 221 of file IOVDbFolder.h.

                                                       {
    return objItr->hasNext();
  }

overrideOptionsFromParsedDescription()

bool IOVDbFolder::overrideOptionsFromParsedDescription ( const IOVDbParser & parsedDescription )

private

Definition at line 823 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=std::move(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=std::move(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 884 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"){
      m_folderDescription = m_crest_mng.value().getFolderDescription();       
    } 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"){
    std::tie(m_channums, m_channames) = m_crest_mng.value().getChannelList();
    
        //determine foldertype from the description, the spec and the number of channels
        m_foldertype = m_crest_mng.value().determineFolderType(); 
    } 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 1098 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 348 of file IOVDbFolder.h.

{ return m_useFileMetaData; }

readTime()

float IOVDbFolder::readTime ( ) const

inline

Definition at line 372 of file IOVDbFolder.h.

{ return m_readtime; }

resetCache()

void IOVDbFolder::resetCache

(

)

Definition at line 617 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 362 of file IOVDbFolder.h.

{ return m_tag; }

resolveTag()

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

private

Definition at line 986 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=std::move(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 340 of file IOVDbFolder.h.

{ return m_retrieved; }

setCacheLength()

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

private

Definition at line 948 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 382 of file IOVDbFolder.h.

{ m_dropped=dropped; }

setFolderDescription()

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

inline

Definition at line 345 of file IOVDbFolder.h.

{ m_folderDescription = description; }

setIOVOverride()

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

Definition at line 191 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 1077 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 176 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 186 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 590 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 564 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 808 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 336 of file IOVDbFolder.h.

{ return m_tagoverride; }

timeStamp()

bool IOVDbFolder::timeStamp ( ) const

inline

Definition at line 334 of file IOVDbFolder.h.

{ return m_timestamp; }

useFileMetaData()

void IOVDbFolder::useFileMetaData

(

)

Definition at line 165 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 350 of file IOVDbFolder.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 IOVDbFolder::m_addrheader

private

Definition at line 293 of file IOVDbFolder.h.

m_autocache

bool IOVDbFolder::m_autocache {true}

private

Definition at line 274 of file IOVDbFolder.h.

{true};         // indicates if cache length was automatically set

m_cacheattr

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

private

Definition at line 314 of file IOVDbFolder.h.

m_cacheccend

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

private

Definition at line 316 of file IOVDbFolder.h.

m_cacheccstart

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

private

Definition at line 315 of file IOVDbFolder.h.

m_cachechan

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

private

Definition at line 313 of file IOVDbFolder.h.

m_cachehint

int IOVDbFolder::m_cachehint {0}

private

Definition at line 280 of file IOVDbFolder.h.

{0};                 // cachehint value (set initial size to Nxchan)

m_cacheinc

int IOVDbFolder::m_cacheinc {0}

private

Definition at line 281 of file IOVDbFolder.h.

{0};                  // number of cache increments performed

m_cachelength

cool::ValidityKey IOVDbFolder::m_cachelength {0}

private

Definition at line 279 of file IOVDbFolder.h.

{0}; // length of cache

m_cachepar

std::string IOVDbFolder::m_cachepar

private

Definition at line 292 of file IOVDbFolder.h.

m_cachespec

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

private

Definition at line 312 of file IOVDbFolder.h.

{nullptr};

m_channames

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

private

Definition at line 305 of file IOVDbFolder.h.

m_channums

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

private

Definition at line 304 of file IOVDbFolder.h.

m_chanrange

std::vector<ChanRange> IOVDbFolder::m_chanrange

private

Definition at line 285 of file IOVDbFolder.h.

m_chansel

cool::ChannelSelection IOVDbFolder::m_chansel

private

Definition at line 283 of file IOVDbFolder.h.

m_checklock

bool IOVDbFolder::m_checklock {true}

private

Definition at line 275 of file IOVDbFolder.h.

{true};         // indicates if global tags should be checked locked

m_clid

CLID IOVDbFolder::m_clid {0}

private

Definition at line 294 of file IOVDbFolder.h.

{0};           // CLID, read from folder description or ClassIDSvc

m_conn

IOVDbConn* IOVDbFolder::m_conn {nullptr}

private

Definition at line 258 of file IOVDbFolder.h.

{nullptr};         // pointer to corresponding IOVDbConn object (=0 FLMD)

m_crest_mng

std::optional<CoralCrestManager> IOVDbFolder::m_crest_mng

private

Definition at line 324 of file IOVDbFolder.h.

m_crestCoolToFile

const bool IOVDbFolder::m_crestCoolToFile {false}

private

Definition at line 319 of file IOVDbFolder.h.

{false};

m_crestServer

const std::string IOVDbFolder::m_crestServer

private

Definition at line 321 of file IOVDbFolder.h.

m_crestTag

const std::string IOVDbFolder::m_crestTag

private

Definition at line 322 of file IOVDbFolder.h.

m_currange

IOVRange IOVDbFolder::m_currange

private

Definition at line 309 of file IOVDbFolder.h.

m_dropped

bool IOVDbFolder::m_dropped {false}

private

Definition at line 273 of file IOVDbFolder.h.

{false};          // data object was dropped from SG

m_eventstore

std::string IOVDbFolder::m_eventstore

private

Definition at line 291 of file IOVDbFolder.h.

m_extensible

bool IOVDbFolder::m_extensible {false}

private

Definition at line 269 of file IOVDbFolder.h.

{false};       // is this an extensible folder?

m_folderDescription

std::string IOVDbFolder::m_folderDescription

private

Definition at line 261 of file IOVDbFolder.h.

m_foldername

std::string IOVDbFolder::m_foldername

private

Definition at line 259 of file IOVDbFolder.h.

m_foldertype

IOVDbNamespace::FolderType IOVDbFolder::m_foldertype

private

Definition at line 277 of file IOVDbFolder.h.

m_fromMetaDataOnly

bool IOVDbFolder::m_fromMetaDataOnly {false}

private

Definition at line 268 of file IOVDbFolder.h.

{false}; // to be read from metadata only

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_iovoverridden

bool IOVDbFolder::m_iovoverridden {false}

private

Definition at line 271 of file IOVDbFolder.h.

{false};    // folder has IOV override

m_iovoverride

cool::ValidityKey IOVDbFolder::m_iovoverride {0}

private

Definition at line 276 of file IOVDbFolder.h.

{0};             // validity key to use

m_iovs

IOVDbNamespace::IovStore IOVDbFolder::m_iovs

private

Definition at line 317 of file IOVDbFolder.h.

m_jokey

bool IOVDbFolder::m_jokey {false}

private

Definition at line 272 of file IOVDbFolder.h.

{false};            // folder has non-default key from joboptions

m_jotag

std::string IOVDbFolder::m_jotag

private

Definition at line 288 of file IOVDbFolder.h.

m_key

std::string IOVDbFolder::m_key

private

Definition at line 260 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.

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

bool IOVDbFolder::m_multiversion {false}

private

Definition at line 262 of file IOVDbFolder.h.

{false};     // is folder multiversion

m_named

bool IOVDbFolder::m_named {false}

private

Definition at line 270 of file IOVDbFolder.h.

{false};            // folder has named channels

m_nbytesread

unsigned long long IOVDbFolder::m_nbytesread {0}

private

Definition at line 299 of file IOVDbFolder.h.

{0}; // number of bytes read from DB

m_ncacheread

unsigned int IOVDbFolder::m_ncacheread {0}

private

Definition at line 297 of file IOVDbFolder.h.

{0};       // number of times data read from cache

m_nchan

unsigned int IOVDbFolder::m_nchan {0}

private

Definition at line 303 of file IOVDbFolder.h.

{0};

m_ndbread

unsigned int IOVDbFolder::m_ndbread {0}

private

Definition at line 296 of file IOVDbFolder.h.

{0};          // number of times data read from DB

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 298 of file IOVDbFolder.h.

{0};         // number of objects read from DB

m_notagoverride

bool IOVDbFolder::m_notagoverride {false}

private

Definition at line 265 of file IOVDbFolder.h.

{false};    // tag must not be overridden from input file

m_outputToFile

const bool IOVDbFolder::m_outputToFile {false}

private

Definition at line 318 of file IOVDbFolder.h.

{false};

m_readtime

float IOVDbFolder::m_readtime {0}

private

Definition at line 300 of file IOVDbFolder.h.

{0};                // time spent reading data from COOL (in loadcache)

m_retrieved

bool IOVDbFolder::m_retrieved {false}

private

Definition at line 308 of file IOVDbFolder.h.

{false};

m_source

const std::string IOVDbFolder::m_source

private

Definition at line 320 of file IOVDbFolder.h.

m_tag

std::string IOVDbFolder::m_tag

private

Definition at line 289 of file IOVDbFolder.h.

m_tagoverride

bool IOVDbFolder::m_tagoverride {false}

private

Definition at line 264 of file IOVDbFolder.h.

{false};      // is tag reset from override (needed for FLMD)

m_timestamp

bool IOVDbFolder::m_timestamp {false}

private

Definition at line 263 of file IOVDbFolder.h.

{false};        // is folder indexed by timestamp (else runLB)

m_typename

std::string IOVDbFolder::m_typename

private

Definition at line 290 of file IOVDbFolder.h.

m_useFileMetaData

bool IOVDbFolder::m_useFileMetaData {false}

private

Definition at line 267 of file IOVDbFolder.h.

{false};  // is using input File MetaData

m_writemeta

bool IOVDbFolder::m_writemeta {false}

private

Definition at line 266 of file IOVDbFolder.h.

{false};        // is writing to metadata

p_clidSvc

IClassIDSvc* IOVDbFolder::p_clidSvc {nullptr}

private

Definition at line 256 of file IOVDbFolder.h.

{nullptr};      // pointer to CLID service

p_metaDataTool

IIOVDbMetaDataTool* IOVDbFolder::p_metaDataTool {nullptr}

private

Definition at line 257 of file IOVDbFolder.h.

{nullptr}; // pointer to metadata tool (writing)

p_tagInfoMgr

ITagInfoMgr* IOVDbFolder::p_tagInfoMgr {nullptr}

private

Definition at line 255 of file IOVDbFolder.h.

{nullptr};   // pointer to TagInfoMgr

---

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

• IOVDbFolder.h
• IOVDbFolder.cxx