ATLAS Offline Software
Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
IOVDbFolder Class Reference

#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 std::string &crestServer="", const std::string &crestTag="", const bool crestCoolToFile=false)
 
 ~IOVDbFolder ()
 
const std::string & folderName () const
 
const std::string & key () const
 
IOVDbConnconn ()
 
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 IOVRangecurrentRange () 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::TransientAddresspreLoadFolder (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::TransientAddresscreateTransientAddress (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< IOVHashfetchCrestIOVs (cool::ValidityKey since, cool::ValidityKey until)
 
std::vector< IOVHashfetchCrestObjects (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. More...
 

Private Attributes

ITagInfoMgrp_tagInfoMgr {nullptr}
 
IClassIDSvc * p_clidSvc {nullptr}
 
IIOVDbMetaDataToolp_metaDataTool {nullptr}
 
IOVDbConnm_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< ChanRangem_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< CoralCrestManagerm_crest_mng
 
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 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.

78  :
79  AthMessaging("IOVDbFolder"),
80  p_clidSvc(clidsvc),
81  p_metaDataTool(metadatatool),
82  m_conn(conn),
83  m_checklock(checklock),
86  m_outputToFile{outputToFile},
87  m_crestCoolToFile{crestCoolToFile},
90  m_crestTag{crestTag}
91 {
92  // set message same message level as our parent (IOVDbSvc)
93  setLevel(msg.level());
94  // extract settings from the properties
95  // foldername from the 'unnamed' property
96  m_foldername=folderprop.folderName();
97  // SG key from 'key' property, otherwise same as foldername
98  // m_jokey is true if the 'key' property was set - need to remember this
99  // to avoid using folder description <key> if present later
100  m_key=folderprop.key();
101  m_jokey=folderprop.hasKey();
102  // tag from 'tag' property
103  m_jotag=folderprop.tag();
104  // event store from 'eventStoreName' property, default 'StoreGateSvc'
105  m_eventstore=folderprop.eventStoreName();
106  // cachelength (seconds or LB)
107  m_cachepar = folderprop.cache();
108  // check for <noover> - disables using tag override read from input file
109  m_notagoverride=folderprop.noTagOverride();
110  if (m_source == "CREST"){
112  }
113  if (m_notagoverride) ATH_MSG_INFO( "Inputfile tag override disabled for " << m_foldername );
114 
115  // channel selection from 'channelSelection' property
116  // syntax is A:B,C:D,E:F
117  // :B implies zero lower limit, A: implies zero upper limit
118  std::string chanspec;
119  if (folderprop.getKey("channelSelection","",chanspec) && !chanspec.empty()) {
120  m_chanrange=IOVDbNamespace::parseChannelSpec<cool::ChannelId>(chanspec);
121  // explicit setting of channel selection
122  // push to the channel selection
123  try{
124  bool first(true);
125  for(const auto & i:m_chanrange){
126  if (first){
127  first = false;
128  m_chansel = cool::ChannelSelection(i.first,i.second);
129  } else {
130  m_chansel.addRange(i.first,i.second);
131  }
132  }
133  } catch (cool::Exception& e) {
134  ATH_MSG_ERROR("defining channel range (must be given in ascending order)");
135  throw;
136  }
137  }
138  if (folderprop.overridesIov(msg)){
139  m_iovoverridden=true;
140  m_iovoverride=folderprop.iovOverrideValue(msg);
141  if (m_timestamp){
142  ATH_MSG_INFO( "Override timestamp to " << m_iovoverride << " for folder " << m_foldername );
143  } else {
145  ATH_MSG_INFO( "Override run/LB number to [" << run << ":" << lumi << "] for folder " << m_foldername );
146  }
147  }
148 
150  if (m_fromMetaDataOnly) {
151  ATH_MSG_INFO( "Read from meta data only for folder " << m_foldername );
152  }
153 
154  m_extensible=folderprop.extensible();
155  if (m_extensible) {
156  ATH_MSG_INFO( "Extensible folder " << m_foldername );
157  }
158 
159 }

◆ ~IOVDbFolder()

IOVDbFolder::~IOVDbFolder ( )

Definition at line 161 of file IOVDbFolder.cxx.

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

Member Function Documentation

◆ addIOVtoCache()

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

Definition at line 1091 of file IOVDbFolder.cxx.

1091  {
1092  // add IOV to the cache
1093  ATH_MSG_DEBUG("Adding IOV to cache, from "<<since<<" to "<<until);
1095 }

◆ addMetaAttrList()

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

Definition at line 1051 of file IOVDbFolder.cxx.

1052  {
1053  // make a temporary CondAttrListCollection with channel 0xFFFF
1054  // This channel number is used to flag on readback that an
1055  // AthenaAttributeList and not a CondAttrListCollection must be created
1057  tmpColl.add(0xFFFF,atrlist);
1058  tmpColl.add(0xFFFF,range);
1059  return addMetaAttrListColl(&tmpColl);
1060 }

◆ addMetaAttrListColl()

bool IOVDbFolder::addMetaAttrListColl ( const CondAttrListCollection coll)
private

Definition at line 1063 of file IOVDbFolder.cxx.

1063  {
1064  // send given payload to folder metadata
1065  // make a new CondAttrListCollection for the payload
1066  CondAttrListCollection* flmdColl=new CondAttrListCollection(*coll);
1067  if (StatusCode::SUCCESS!=p_metaDataTool->addPayload(m_foldername,flmdColl)) {
1068  ATH_MSG_ERROR( "addMetaAttrList: Failed to write metadata for folder " << m_foldername);
1069  return false;
1070  } else {
1071  ATH_MSG_DEBUG( "addMetaAttrList: write metadata for folder " << m_foldername );
1072  return true;
1073  }
1074 }

◆ bytesRead()

unsigned long long IOVDbFolder::bytesRead ( ) const
inline

Definition at line 369 of file IOVDbFolder.h.

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

175  {
176  const auto & objSince = obj.since();
177  const auto & objUntil = obj.until();
178  const auto & objChannel = obj.channelId();
179  ATH_MSG_DEBUG("from DB \t chID: "<<objChannel<<"\tobjstart:\t"<<objSince<<"\t objstop: \t"
180  << objUntil );
181  // The covered flag is used to check whether the
182  // requested IOV time is inside the range covered
183  // by the current cache. If not, a cache reset
184  // will be done.
185  unsigned int counter{};
186  bool covered{false};
187  //find the iterator distance into the channel array which gives the sought ChannelId
188  const auto pCacheChannel = std::find(m_cachechan.begin(), m_cachechan.end(), objChannel);
189  if (pCacheChannel != m_cachechan.end()){
190  //find corresponding iov, which we shall modify
191  const auto iovIdx = std::distance(m_cachechan.begin(), pCacheChannel);
192  const auto & iov = m_iovs.at(iovIdx);
193  if ((iov.first < objSince) and (objSince < iov.second)){
194  // obj time is larger than cache start (and less than cache stop)
195  // ==> update cache
196  ++counter;
197  ATH_MSG_DEBUG("special reload needed on THIS ONE !!!!!!!!!!!");
198  // just change existing IOVRange
199  ATH_MSG_DEBUG("changing "<<iov.second<<" to "<<objSince-1);
200  m_iovs.extendIov(iovIdx, objSince-1);
201  specialCacheUpdate(obj, iovSvc); // reset proxy, add to cache, addIOV
202  covered = true;
203  }
204  if ( (objSince>=iov.first and objSince<iov.second) or (objUntil>iov.first and objUntil<=iov.second) ) covered=true;
205  }
206  if (!covered) {
207  // cache range has not been covered, so update the cache
208  ++counter;
209  specialCacheUpdate(obj, iovSvc);
210  }
211  return counter;
212  }

◆ cacheValid()

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

Definition at line 377 of file IOVDbFolder.h.

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

◆ clearCache()

void IOVDbFolder::clearCache ( )
private

Definition at line 976 of file IOVDbFolder.cxx.

976  {
977  // clear all the cache vectors of information
978  m_iovs.clear();
979  m_cachechan.clear();
980  m_cacheattr.clear();
981  m_cacheccstart.clear();
982  m_cacheccend.clear();
983 }

◆ clid()

CLID IOVDbFolder::clid ( ) const
inline

Definition at line 367 of file IOVDbFolder.h.

367 { return m_clid; }

◆ conn()

IOVDbConn * IOVDbFolder::conn ( )
inline

Definition at line 330 of file IOVDbFolder.h.

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

865  {
866  auto tad = std::make_unique<SG::TransientAddress>(m_clid,m_key);
867  //
868  for (const auto & linkname:symlinks){
869  if (not linkname.empty()) {
870  CLID sclid;
871  if (StatusCode::SUCCESS==p_clidSvc->getIDOfTypeName(linkname,sclid)) {
872  tad->setTransientID(sclid);
873  ATH_MSG_DEBUG( "Setup symlink " << linkname << " CLID " <<sclid << " for folder " << m_foldername );
874  } else {
875  ATH_MSG_ERROR( "Could not get clid for symlink: "<< linkname );
876  return nullptr;
877  }
878  }
879  }
880  return tad;
881 }

◆ currentRange()

const IOVRange & IOVDbFolder::currentRange ( ) const
inline

Definition at line 375 of file IOVDbFolder.h.

375 { return m_currange; }

◆ dropped()

bool IOVDbFolder::dropped ( ) const
inline

Definition at line 356 of file IOVDbFolder.h.

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

1143 {
1144  std::ofstream myFile;
1145  std::string fMain(dumpName);
1146  const std::string sanitisedFolder=fMain+"/"+sanitiseFilename(m_foldername);
1147  const std::string fabricatedName=sanitisedFolder+delimiter+std::to_string(vkey)+fileSuffix;
1148  std::filesystem::create_directory(fMain);
1149  myFile.open(fabricatedName,std::ios::out);
1150  if (not myFile.is_open()) {
1151  std::string errorMessage{"File creation for "+fabricatedName+" failed."};
1152  ATH_MSG_FATAL(errorMessage);
1153  throw std::runtime_error(errorMessage);
1154  }
1155  else {
1156  ATH_MSG_INFO("File "<<fabricatedName<<" created.");
1157  }
1158 
1159  myFile<<s_openJson;
1160  if(json) {
1161  // Dump COOL data
1162  myFile<<json->description()<<s_delimiterJson<<std::endl;
1163  myFile<<json->payloadSpec()<<s_delimiterJson<<std::endl;
1164  if(!skipCoolIoV) {
1165  myFile<<json->iov()<<s_delimiterJson<<std::endl;
1166  }
1167  myFile<<json->payload()<<std::endl;
1168  }
1169  else {
1170  // Dump CREST data
1171  myFile<<"\"node_description\" : \""<<m_folderDescription<< '\"'<<s_delimiterJson<<std::endl;
1172  myFile<<"\"folder_payloadspec\": \""<<mng->getPayloadSpec()<< '\"'<<s_delimiterJson<<std::endl;
1173  myFile<<"\"data_array\" : "<<mng->dumpPayload(crestVkey)<<std::endl;
1174  }
1175  myFile<<s_closeJson;
1176 }

◆ eventStore()

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

Definition at line 364 of file IOVDbFolder.h.

365 { return m_eventstore; }

◆ extensible()

bool IOVDbFolder::extensible ( ) const
inline

Definition at line 354 of file IOVDbFolder.h.

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

1113 {
1114  std::vector<IOVHash> result;
1115 
1116  // Get a vector of pairs retrieved from crest
1117  std::vector<std::pair<cool::ValidityKey,std::string>> crestIOVs = m_crest_mng.value().getIovsForTag(since,until);
1118  size_t nIOVs = crestIOVs.size();
1119  if(crestIOVs.empty()){
1120  ATH_MSG_WARNING("Load cache failed for " << m_foldername << ". No IOVs retrieved from the DB");
1121  return result;
1122  }
1123 
1124  if(nIOVs>0) {
1125  if(nIOVs>1) {
1126  for(size_t ind=0; ind<nIOVs-1; ++ind) {
1127  result.emplace_back(IovStore::Iov_t(crestIOVs[ind].first, crestIOVs[ind+1].first),crestIOVs[ind].second);
1128  }
1129  }
1130  result.emplace_back(IovStore::Iov_t(crestIOVs[nIOVs-1].first, cool::ValidityKeyMax),crestIOVs[nIOVs-1].second);
1131  }
1132 
1133  return result;
1134 }

◆ fetchCrestObjects()

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

Definition at line 1178 of file IOVDbFolder.cxx.

1179 {
1180  std::vector<IOVDbFolder::IOVHash> iovHashVect = fetchCrestIOVs(since,until);
1181  if(iovHashVect.empty() || until<=iovHashVect[0].first.first) {
1182  if(iovHashVect.empty()) {
1183  ATH_MSG_INFO("NO IOVs retrieved for the folder "+ m_foldername);
1184  }
1185  else {
1186  ATH_MSG_INFO("Cache boundaries outside available IOVs for the folder "+ m_foldername);
1187  }
1188  return iovHashVect;
1189  }
1190  unsigned indIOVStart = 0;
1191  for(const auto& iovhash : iovHashVect) {
1192  if(vkey>=iovhash.first.first && vkey<iovhash.first.second)
1193  break;
1194  indIOVStart++;
1195  }
1196  unsigned indIOVEnd = indIOVStart;
1197  while(indIOVEnd < iovHashVect.size()) {
1198  if(iovHashVect[indIOVEnd].first.first < until
1199  && iovHashVect[indIOVEnd].first.second >= until) {
1200  break;
1201  }
1202  ++indIOVEnd;
1203  }
1204  std::vector<IOVDbFolder::IOVHash> resIovHashVect;
1205  for(unsigned ind = indIOVStart; ind <= indIOVEnd; ++ind) {
1206  std::vector<uint64_t> resIovs=m_crest_mng.value().loadPayloadForHash(iovHashVect[ind].first.first,iovHashVect[ind].second);
1207  if(resIovs.size()>1){
1208  uint64_t sTmp=iovHashVect[ind].first.first;
1209  uint64_t uTmp=0;
1210  for(unsigned int i=1;i<resIovs.size();i++){
1211  uTmp=resIovs[i];
1212  resIovHashVect.emplace_back(IovStore::Iov_t(sTmp, uTmp),iovHashVect[ind].second);
1213  sTmp=uTmp;
1214  }
1215  if(sTmp!=iovHashVect[ind].first.second){
1216  resIovHashVect.emplace_back(IovStore::Iov_t(sTmp, iovHashVect[ind].first.second),iovHashVect[ind].second);
1217  }
1218  }
1219  else if(resIovs.size()==1){
1220  resIovHashVect.emplace_back(IovStore::Iov_t(resIovs[0],iovHashVect[ind].first.second),iovHashVect[ind].second);
1221  }
1222  if(m_crestCoolToFile)
1223  break;
1224  }
1225  indIOVStart = 0;
1226  for(const auto& iovhash : resIovHashVect) {
1227  if(vkey>=iovhash.first.first && vkey<iovhash.first.second)
1228  break;
1229  if(indIOVStart+1<resIovHashVect.size())
1230  indIOVStart++;
1231  }
1232  if(m_crestCoolToFile) {
1233  dumpFile("crest_dump",vkey,nullptr,false,&m_crest_mng.value(),resIovHashVect[indIOVStart].first.first);
1234  }
1235  return resIovHashVect;
1236 }

◆ folderName()

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

Definition at line 327 of file IOVDbFolder.h.

327 {return m_foldername;}

◆ folderType()

IOVDbNamespace::FolderType IOVDbFolder::folderType ( ) const
inline

Definition at line 342 of file IOVDbFolder.h.

343 {return m_foldertype;}

◆ fromMetaDataOnly()

bool IOVDbFolder::fromMetaDataOnly ( ) const
inline

Definition at line 352 of file IOVDbFolder.h.

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

629  {
630 
631  ++m_ncacheread;
632  // will produce strAddress and one pointer type depending on folder data
633  std::string strAddress;
634  AthenaAttributeList* attrList=nullptr;
635  CondAttrListCollection* attrListColl=nullptr;
636  CondAttrListVec* attrListVec=nullptr;
637  cool::ValidityKey naystart=0;
638  cool::ValidityKey naystop=cool::ValidityKeyMax;
639  if( m_useFileMetaData ) {
641  readFromMetaData(m_foldername, p_metaDataTool, reftime, m_timestamp);
642  if (not readFromMetaData.isValid()){
643  ATH_MSG_ERROR( "read:Could not find IOVPayloadContainer for folder "<< m_foldername );
644  return false;
645  }
646  // read from file metadata
647  m_foldertype=readFromMetaData.folderType();
648  m_nobjread+=readFromMetaData.numberOfObjects();
649  poolPayloadReq=readFromMetaData.poolPayloadRequested();
650  strAddress = readFromMetaData.stringAddress();
651  range = readFromMetaData.range();
652  attrList = readFromMetaData.attributeList();
653  attrListColl = readFromMetaData.attrListCollection();
654  ATH_MSG_DEBUG( "Read file metadata for folder " << m_foldername << " foldertype is " << m_foldertype );
655  } else {
656  // COOL/CoraCool data to be read from cache
657  // for AttrListColl or PoolRefColl, need a CondAttrListCollection ready
658  // to receive the data
660  attrListColl=new CondAttrListCollection(!m_timestamp);
661  } else if (m_foldertype==CoraCool || m_foldertype==CoolVector) {
662  // for CoraCool/CoolVector, assume we will get everything in the cache
663  attrListVec=new CondAttrListVec(!m_timestamp, m_cacheattr.size());
664  }
665  // loop over cached data
666  unsigned int nobj=0;
667  // keep track of closest neighbouring IOVs
668  std::tie(naystart, naystop) = m_iovs.getCacheBounds();
669 
670  for (unsigned int ic=0; ic!=m_iovs.size();++ic) {
671  const auto & thisIov = m_iovs.at(ic);
672  if (thisIov.first<=reftime && reftime<thisIov.second) {
673  ++nobj;
675  // retrieve of AthenaAttributeList or single PoolRef
676  if (m_foldertype==AttrList) {
677  attrList=new AthenaAttributeList(m_cacheattr[ic]);
678  strAddress="POOLContainer_AthenaAttributeList][CLID=x";
679  } else {
680  strAddress=(m_cacheattr[ic])["PoolRef"].data<std::string>();
681  }
682  range=IOVDbNamespace::makeRange(thisIov.first,thisIov.second, m_timestamp);
683  // write meta-data if required
684  if (m_writemeta)
685  if (!addMetaAttrList(m_cacheattr[ic],range)) return false;
687  // retrieve of CondAttrListCollection
688  attrListColl->addShared(m_cachechan[ic],m_cacheattr[ic]);
689  attrListColl->add(m_cachechan[ic],IOVDbNamespace::makeRange(thisIov.first,thisIov.second, m_timestamp));
690  } else if (m_foldertype==CoraCool || m_foldertype==CoolVector) {
691  // retrieval of CoraCool data
692  attrListVec->addSlice(IOVDbNamespace::makeRange(thisIov.first,thisIov.second, m_timestamp),
695  if (m_writemeta) {
696  ATH_MSG_ERROR( "Writing of CoraCool folders to file metadata not implemented");
697  return false;
698  }
699  } else {
700  ATH_MSG_ERROR( "Unhandled folder type " << m_foldertype);
701  return false;
702  }
703  } else if (thisIov.second<=reftime && thisIov.second>naystart) {
704  naystart=thisIov.second;
705  } else if (thisIov.first>reftime && thisIov.first<naystop) {
706  naystop=thisIov.first;
707  }
708  }
709  // post-loop actions
711  // set up channel names if required
712  if (m_named) {
713  std::vector<std::string>::const_iterator nitr=m_channames.begin();
714  for (std::vector<cool::ChannelId>::const_iterator chitr=m_channums.begin();
715  chitr!=m_channums.end(); ++chitr,++nitr) {
716  attrListColl->add(*chitr,*nitr);
717  }
718  }
719  // set range
720  range=attrListColl->minRange();
721  strAddress="POOLContainer_CondAttrListCollection][CLID=x";
722  } else if (m_foldertype==CoraCool || m_foldertype==CoolVector) {
723  range=attrListVec->minRange();
724  strAddress="POOLContainer_CondAttrListVec][CLID=x";
725  } else if (m_foldertype==AttrList || m_foldertype==PoolRef) {
726  // single object retrieve - should have exactly one object
727  if (nobj==0) {
728  ATH_MSG_ERROR("COOL object not found in single-channel retrieve, folder "
729  << m_foldername << " currentTime " << reftime );
730  return false;
731  } else if (nobj>1) {
732  ATH_MSG_ERROR( nobj <<
733  " valid objects found for single-channel retrieve, folder " <<
734  m_foldername << " currentTime " << reftime );
735  return false;
736  }
737  }
738  ATH_MSG_DEBUG( "Retrieved object: folder " << m_foldername
739  << " at IOV " << reftime << " channels " << nobj << " has range "
740  << range );
741  // shrink range so it does not extend into 'gap' channels or outside cache
742  IOVTime tnaystart=makeEpochOrRunLumi(naystart, m_timestamp);
743  IOVTime tnaystop=makeEpochOrRunLumi(naystop, m_timestamp);
744  IOVTime rstart=range.start();
745  IOVTime rstop=range.stop();
746  if (tnaystart > rstart || rstop > tnaystop) {
747  ATH_MSG_DEBUG( "Shrink IOV range for " << m_foldername
748  << " from [" << rstart << ":" << rstop << "] to ["
749  << tnaystart << ":" << tnaystop << "]" );
750  if (tnaystart > rstart) rstart=tnaystart;
751  if (tnaystop < rstop) rstop=tnaystop;
752  range=IOVRange(rstart,rstop);
754  attrListColl->addNewStart(rstart);
755  attrListColl->addNewStop(rstop);
756  }
757  }
758  }
759  // save the range for possible later lookup in IOVDbSvc::getKeyInfo
761  m_retrieved=true;
762  // write metadata for attrListColl if required (after range shrinking)
763  if (m_writemeta &&
765  if (!addMetaAttrListColl(attrListColl)) return false;
766  }
767 
768  // turn the data into an IOpaqueAddress
769  strAddress=m_addrheader+strAddress;
770  IOpaqueAddress* addrp = nullptr;
771  if (StatusCode::SUCCESS!=persSvc->createAddress(0,0,strAddress,addrp)) {
772  ATH_MSG_ERROR( "Could not get IOpaqueAddress from string address "<< strAddress );
773  return false;
774  }
775  address = std::unique_ptr<IOpaqueAddress>(addrp);
776  GenericAddress* gAddr=dynamic_cast<GenericAddress*>(address.get());
777  if (!gAddr) {
778  ATH_MSG_ERROR( "Could not cast IOpaqueAddress to GenericAddress");
779  return false;
780  }
781  // create a new GenericAddress to set pool context
782  if (m_foldertype==AttrListColl) {
783  auto addr = std::make_unique<CondAttrListCollAddress>(*gAddr);
784  addr->setAttrListColl(attrListColl);
785  address = std::move(addr);
786  } else if (m_foldertype==PoolRefColl || m_foldertype==PoolRef) {
787  auto addr = std::make_unique<CondAttrListCollAddress>(gAddr->svcType(),
788  gAddr->clID(),gAddr->par()[0],gAddr->par()[1],
789  poolSvcContext,gAddr->ipar()[1]);
790  if (m_foldertype==PoolRefColl) {
791  addr->setAttrListColl(attrListColl);
792  }
793  address = std::move(addr);
794  poolPayloadReq=true;
795  } else if (m_foldertype==AttrList) {
796  auto addr = std::make_unique<AthenaAttrListAddress>(*gAddr);
797  addr->setAttrList(attrList);
798  address = std::move(addr);
799  } else if (m_foldertype==CoraCool || m_foldertype==CoolVector) {
800  auto addr = std::make_unique<CondAttrListVecAddress>(*gAddr);
801  addr->setAttrListVec(attrListVec);
802  address = std::move(addr);
803  }
804  return true;
805 }

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

40 {
42  m_lvl = m_imsg ?
43  static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
44  MSG::INFO;
45 }

◆ iovOverridden()

bool IOVDbFolder::iovOverridden ( ) const
inline

Definition at line 358 of file IOVDbFolder.h.

358 { return m_iovoverridden; }

◆ iovTime()

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

Definition at line 216 of file IOVDbFolder.cxx.

216  {
217  if (m_iovoverridden) {
218  return m_iovoverride;
219  } else {
220  return (m_timestamp ? reftime.timestamp() : reftime.re_time());
221  }
222 }

◆ joTag()

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

Definition at line 360 of file IOVDbFolder.h.

360 { return m_jotag; }

◆ key()

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

Definition at line 328 of file IOVDbFolder.h.

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

228  {
229  // load the cache for the given IOVTime, making a range around this time
230  // according to the caching policy
231  // if cacheDiv > 0, specifies number of slices of cache for query alignment
232  // if ignoreMissChan set, don't worry about missing channels outside the cache range
233  // return false if any problem
234  // timer to track amount of time in loadCache
235  TStopwatch cachetimer;
236  const auto & [cachestart, cachestop] = m_iovs.getCacheBounds();
237 
238  bool vectorPayload{};
239  if (m_source == "CREST"){
240  ATH_MSG_INFO("Download tag would be: "<<m_crestTag);
241  m_crest_mng.value().loadTagInfo();
242  vectorPayload = m_crest_mng.value().isVectorPayload();
243  }
244  else {
245  vectorPayload = (m_foldertype ==CoraCool) or (m_foldertype == CoolVector);
246  }
247 
248  ATH_MSG_DEBUG( "Load cache for folder " << m_foldername << " validitykey " << vkey);
249  // if not first time through, and limit not reached,and cache was not reset,
250  // and we are going forwards in time, double cachesize
251  if (m_ndbread>0 && m_cacheinc<3 && (cachestop!=cachestart) && vkey>cachestart && m_autocache) {
252  m_cachelength*=2;
253  ++m_cacheinc;
254  ATH_MSG_INFO( "Increase cache length (step " << m_cacheinc << ") for folder " << m_foldername << " to " << m_cachelength << " at validityKey " << vkey );
255  }
256  ++m_ndbread;
257  auto [changedCacheLo, changedCacheHi] = m_iovs.getCacheBounds();
258  if (cacheDiv>0) {
259  // quantise queries on boundaries that are sub-multiples of cache length
260  unsigned long long cacheq=m_cachelength/cacheDiv;
261  if (cacheq>0) changedCacheLo=vkey - vkey % cacheq;
262  changedCacheHi=changedCacheLo+m_cachelength;
263  } else {
264  // for run/LB indexed folders and cache of at least one run
265  // align the query to the run start
267  changedCacheLo=vkey & (0x7FFFFFFFLL << 32);
268  } else {
269  changedCacheLo=vkey;
270  }
271  changedCacheHi=vkey+m_cachelength;
272  }
273  if (changedCacheHi>cool::ValidityKeyMax) changedCacheHi=cool::ValidityKeyMax;
274  //
275  //
276  m_iovs.setCacheBounds(IovStore::Iov_t(changedCacheLo, changedCacheHi));
277  //
278  const auto & [since, until] = m_iovs.getCacheBounds();
279  ATH_MSG_DEBUG( "IOVDbFolder:loadCache limits set to [" << since << "," << until << "]" );
280 
281  if (m_cachespec==nullptr) {
282  // on first init, guess size based on channel count
283  unsigned int estsize=m_nchan;
284  if (m_cachehint > 0) {
285  estsize=estsize*m_cachehint;
286  } else if (m_timestamp) {
287  // for timestamp indexed folder (likely to be DCS), increase this
288  estsize=estsize*3;
289  }
290  // note this is only reserved size of the cache vectors
291  // actual datastorage is mainly allocated by pointer elsewhere
292  m_cachechan.reserve(estsize);
293  m_cacheattr.reserve(estsize);
294  if (vectorPayload) {
295  m_cacheccstart.reserve(estsize);
296  m_cacheccend.reserve(estsize);
297  }
298  } else {
299  // reset cache if it already contained data
300  // TBIO - could keep the attributelists and only change the data on reload
301  // avoiding some attributelist construction/destruction
302  clearCache();
303  }
304  bool retrievedone=false;
305  unsigned int nChannelsExpected = (m_chanrange.empty())? (m_nchan) : (IOVDbNamespace::countSelectedChannels(m_channums, m_chansel));
306  if (m_source == "COOL_DATABASE"){
307  // query to fill cache - request for database activates connection
308  if (not m_conn->open()) {
309  ATH_MSG_FATAL( "Conditions database connection " <<m_conn->name() << " cannot be opened - STOP" );
310  return false;
311  }
312  // access COOL inside try/catch in case of using stale connection
313  unsigned int attempts=0;
314 
315  ATH_MSG_DEBUG( "loadCache: Expecting to see " << nChannelsExpected << " channels" );
316  //
317  while (attempts<2 && !retrievedone) {
318  ++attempts;
319  try {
320  unsigned int iadd=0;
321  m_iovs.setIovSpan(IovStore::Iov_t(0,cool::ValidityKeyMax));
322  // check pointer is still valid - can go stale in AthenaMT environment
323  // according to CORAL server tests done by Andrea Valassi (23/6/09)
324  if (not m_conn->valid()) throw std::runtime_error("COOL database pointer invalidated");
325  // access COOL folder in case needed to resolve tag (even for CoraCool)
326  cool::IFolderPtr folder=m_conn->getFolderPtr(m_foldername);
327 
328  // resolve the tag for MV folders if not already done so
329  if (m_multiversion && m_tag.empty()) {
330  if (!resolveTag(folder,globalTag)) return false;
331 
332  }
333  if (m_foldertype==CoraCool) {
334  // CoraCool retrieve
336  CoraCoolFolderPtr ccfolder=ccDbPtr->getFolder(m_foldername);
337 
338  auto [since,until] = m_iovs.getCacheBounds();
339  CoraCoolObjectIterPtr itr=ccfolder->browseObjects(since, until,m_chansel,m_tag);
340  while (itr->hasNext()) {
341  CoraCoolObjectPtr obj=itr->next();
342  //should be skipping non-selected channels here?
343  addIOVtoCache(obj->since(),obj->until());
344  m_cachechan.push_back(obj->channelId());
345  // store all the attributeLists in the buffer
346  // save pointer to start
347  const unsigned int istart=m_cacheattr.size();
348  for (CoraCoolObject::const_iterator pitr=obj->begin();pitr!=obj->end(); ++pitr) {
349  // setup shared specification on first store
350  if (m_cachespec==nullptr) setSharedSpec(*pitr);
351  // use the shared specification in storing the payload
352  m_cacheattr.emplace_back(*m_cachespec,true);
353  m_cacheattr.back().fastCopyData(*pitr);
355  }
356  // save pointers to start and end
357  m_cacheccstart.push_back(istart);
358  m_cacheccend.push_back(m_cacheattr.size());
359  ++iadd;
360  }
361  itr->close();
362  retrievedone=true;
363  } else {
364  auto [since,until] = m_iovs.getCacheBounds();
365  cool::IObjectIteratorPtr itr=folder->browseObjects(since,until,m_chansel,m_tag);
366  if (m_outputToFile) {
368  dumpFile("cool_dump",vkey,&json,m_crestCoolToFile);
369  }
370  else if(m_crestCoolToFile){
371  Cool2Json json(folder, vkey, vkey, m_chansel, m_tag);
372  dumpFile("cool_dump",vkey,&json,m_crestCoolToFile);
373  }
374  while (itr->goToNext()) {
375  const cool::IObject& ref=itr->currentRef();
376  addIOVtoCache(ref.since(),ref.until());
377  m_cachechan.push_back(ref.channelId());
378  if (m_foldertype==CoolVector) {
379  // store all the attributeLists in the buffer
380  // save pointer to start
381  const unsigned int istart=m_cacheattr.size();
382  // get payload iterator and vector of payload records
383  cool::IRecordIterator& pitr=ref.payloadIterator();
384  const cool::IRecordVectorPtr& pvec=pitr.fetchAllAsVector();
385  for (cool::IRecordVector::const_iterator vitr=pvec->begin();vitr!=pvec->end();++vitr) {
386  const coral::AttributeList& atrlist=(*vitr)->attributeList();
387  // setup shared specification on first store
388  if (m_cachespec==nullptr) setSharedSpec(atrlist);
389  // use the shared specification in storing the payload
390  m_cacheattr.emplace_back(*m_cachespec,true);
391  m_cacheattr.back().fastCopyData(atrlist);
393  }
394  // save pointers to start and end
395  m_cacheccstart.push_back(istart);
396  m_cacheccend.push_back(m_cacheattr.size());
397  ++iadd;
398  pitr.close();
399  } else {
400  // standard COOL retrieve
401  const coral::AttributeList& atrlist=ref.payload().attributeList();
402  // setup shared specification on first store
403  if (m_cachespec==nullptr) setSharedSpec(atrlist);
404  // use the shared specification in storing the payload
405  m_cacheattr.emplace_back(*m_cachespec,true);
406  m_cacheattr[iadd].fastCopyData(atrlist);
407  ++iadd;
409  }
410  }
411  itr->close();
412  retrievedone=true;
413  }
414  ATH_MSG_DEBUG( "Retrieved " << iadd << " objects for "<< m_nchan << " channels into cache" );
415  m_nobjread+=iadd;
416  } catch (std::exception& e) {
417  ATH_MSG_WARNING( "COOL retrieve attempt " << attempts << " failed: " << e.what() );
418  // disconnect and reconnect
419  if (not m_conn->dropAndReconnect()) ATH_MSG_ERROR("Tried to reconnect in 'loadCache' but failed");
420  }
421  }
422  } // End of COOL reading section
423  else {
424  // CREST reading section
425  unsigned int iadd = 0;
426  auto [since,until] = m_iovs.getCacheBounds();
427  std::vector<IOVHash> iovs = fetchCrestObjects(since,until,vkey);
428  if (m_cachespec==nullptr)
429  m_cachespec=m_crest_mng.value().getAttributeListSpec();
430  for(const auto & [iov, hash] : iovs) {
431  m_crest_mng.value().selectIov(iov.first);
432  const auto & channelNumbers=m_crest_mng.value().channelIds(iov.first);
433  for (auto const & chan: channelNumbers){
434  addIOVtoCache(iov.first, iov.second);
435  std::string token;
436  std::istringstream tokenStream(chan);
437  std::getline(tokenStream, token, ':');
438  m_cachechan.push_back(std::stol(token));
439  if(m_crest_mng.value().isVectorPayload()){
440  const auto & vPayload = m_crest_mng.value().getVectorPayload(m_cachespec,chan);
441  const unsigned int istart=m_cacheattr.size();
442  for (const auto & attList:vPayload){
443  m_cacheattr.emplace_back(*m_cachespec,true);// maybe needs to be cleared before
444  m_cacheattr.back().fastCopyData(attList);
446  }
447  m_cacheccstart.push_back(istart);
448  m_cacheccend.push_back(m_cacheattr.size());
449  ++iadd;
450  }
451  else{
452  auto const & attList = m_crest_mng.value().getPayload(m_cachespec,chan);
453  const coral::AttributeList c(*m_cachespec,true);
454  m_cacheattr.push_back(attList);// maybe needs to be cleared before
455  m_cacheattr.back().fastCopyData(attList);
457  ++iadd;
458  }
459  }
460  }
461 
462  retrievedone=true;
463  ATH_MSG_DEBUG( "Retrieved " << iadd << " objects for "<< m_nchan << " channels into cache" );
464  m_nobjread+=iadd;
465  } // End of reading from CREST
466 
467  if (!retrievedone) {
468  const auto & [since,until] = m_iovs.getCacheBounds();
469  ATH_MSG_ERROR( "Could not retrieve Cond data for folder " <<
470  m_foldername << " tag " << m_tag << " validityKeys [" << since <<
471  "," << until << "]" );
472  return false;
473  }
474  // check if cache can be stretched according to extent of IOVs crossing
475  // boundaries - this requires all channels to have been seen
476  const auto & [nChannelsLo, nChannelsHi] = m_iovs.numberOfIovsOnBoundaries();
477  const auto missing=std::pair<unsigned int, unsigned int>(nChannelsExpected-nChannelsLo, nChannelsExpected-nChannelsHi);
478  ATH_MSG_DEBUG( "Cache retrieve missing " << missing.first << " lower and " << missing.second << " upper channels" );
479  //
480  const auto & span = m_iovs.getMinimumStraddlingSpan();
481  const auto & [cacheStart, cacheStop] =m_iovs.getCacheBounds();
482  //new code
483  if ((missing.first==0 or ignoreMissChan) and m_iovs.extendCacheLo()){
484  ATH_MSG_DEBUG( "Lower cache limit extended from " << cacheStart << " to " << span.first );
485  }
486 
487  if ((missing.second==0 or ignoreMissChan) and m_iovs.extendCacheHi()){
488  ATH_MSG_DEBUG( "Upper cache limit extended from " << cacheStop << " tp " << span.second );
489  }
490  //
491  // keep track of time spent
492  const float timeinc=cachetimer.RealTime();
493  m_readtime+=timeinc;
494  ATH_MSG_DEBUG( "Cache retrieve done for " << m_foldername << " with " <<
495  m_iovs.size() << " objects stored in" << std::fixed <<
496  std::setw(8) << std::setprecision(2) << timeinc << " s" );
497  return true;
498 }

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

503  {
504  ATH_MSG_DEBUG( "IOVDbFolder::recheck with DB for folder " << m_foldername<< " validitykey: " << vkey );
505  if (m_iovs.empty()) {
506  ATH_MSG_DEBUG( "Cache empty ! returning ..." );
507  return true;
508  }
509  ++m_ndbread;
510  // access COOL inside try/catch in case of using stale connection
511  unsigned int attempts = 0;
512  bool retrievedone = false;
513  //
514  unsigned int nChannelsExpected = (m_chanrange.empty())? (m_nchan) : (IOVDbNamespace::countSelectedChannels(m_channums, m_chansel));
515  ATH_MSG_DEBUG( "loadCacheIfDbChanged: Expecting to see " << nChannelsExpected << " channels" );
516  //
517  while (attempts<2 && !retrievedone) {
518  ++attempts;
519  try {
520  m_iovs.setIovSpan(IovStore::Iov_t(0,cool::ValidityKeyMax));
521  // access COOL folder in case needed to resolve tag (even for CoraCool)
522  cool::IFolderPtr folder=m_conn->getFolderPtr(m_foldername);
523  // resolve the tag for MV folders if not already done so
524  if (m_multiversion && m_tag.empty()) { // NEEDED OR NOT?
525  if (!resolveTag(folder,globalTag)) return false;
526  }
527  int counter=0;
528  const auto & [since,until] = m_iovs.getCacheBounds();
529  ATH_MSG_DEBUG(IOVDbNamespace::folderTypeName(m_foldertype)<<" type. cachestart:\t"<<since<<" \t cachestop:"<< until);
530  ATH_MSG_DEBUG("checking range: "<<vkey+1<<" - "<<vkey+2);
531  if (m_foldertype==CoraCool) {
532  // CoraCool retrieve initialise CoraCool connection
534  // this returns all the objects whose IOVRanges crosses this range .
535  CoraCoolObjectIterPtr itr = ccfolder->browseObjects(vkey+1, vkey+2,m_chansel,m_tag);
536  while (objectIteratorIsValid(itr)) {
537  CoraCoolObjectPtr obj = itr->next();
538  //code delegated to templated member, allowing for difference between CoraCoolObjectPtr and IObject
540  }
541  itr->close();
542  } else {
543  // this returns all the objects whose IOVRanges crosses this range .
544  cool::IObjectIteratorPtr itr=folder->browseObjects(vkey+1, vkey+2, m_chansel,m_tag);
545  while (objectIteratorIsValid(itr)) {
546  const cool::IObject& ref=itr->currentRef();
547  //code delegated to templated member, allowing for difference between CoraCoolObjectPtr and IObject
549  }
550  itr->close();
551  }
552  retrievedone=true;
553  ATH_MSG_DEBUG( "Need a special update for " << counter << " objects " );
555  }catch (std::exception& e) {
556  ATH_MSG_WARNING( "COOL retrieve attempt " << attempts << " failed: " << e.what() );
557  if (not m_conn->dropAndReconnect()) ATH_MSG_ERROR("Tried reconnecting in loadCacheIfDbChanged but failed");
558  }
559  }
560  return true;
561 }

◆ magicTag()

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

Definition at line 1043 of file IOVDbFolder.cxx.

1043  { //alters the argument
1045  return (not tag.empty());
1046 }

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

165 {
166  MsgStream* ms = m_msg_tls.get();
167  if (!ms) {
168  if (!m_initialized.test_and_set()) initMessaging();
169  ms = new MsgStream(m_imsg,m_nm);
170  m_msg_tls.reset( ms );
171  }
172 
173  ms->setLevel (m_lvl);
174  return *ms;
175 }

◆ 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
lvlThe message level to test against
Returns
boolean Indicating if messages at given level will be printed
Return values
trueMessages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

152 {
153  if (!m_initialized.test_and_set()) initMessaging();
154  if (m_lvl <= lvl) {
155  msg() << lvl;
156  return true;
157  } else {
158  return false;
159  }
160 }

◆ multiVersion()

bool IOVDbFolder::multiVersion ( ) const
inline

Definition at line 332 of file IOVDbFolder.h.

332 { return m_multiversion; }

◆ noOverride()

bool IOVDbFolder::noOverride ( ) const
inline

Definition at line 338 of file IOVDbFolder.h.

338 { return m_notagoverride; }

◆ objectIteratorIsValid() [1/2]

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

Definition at line 216 of file IOVDbFolder.h.

216  {
217  return objItr->goToNext();
218  }

◆ objectIteratorIsValid() [2/2]

bool IOVDbFolder::objectIteratorIsValid ( CoraCoolObjectIterPtr objItr)
inlineprivate

Definition at line 221 of file IOVDbFolder.h.

221  {
222  return objItr->hasNext();
223  }

◆ overrideOptionsFromParsedDescription()

bool IOVDbFolder::overrideOptionsFromParsedDescription ( const IOVDbParser parsedDescription)
private

Definition at line 823 of file IOVDbFolder.cxx.

823  {
824  bool success{true};
825  // check for timeStamp indicating folder is timestamp indexed
826  m_timestamp=parsedDescription.timebaseIs_nsOfEpoch();
827  // check for key, giving a different key to the foldername
828  if (auto newkey=parsedDescription.key(); not newkey.empty() and not m_jokey) {
829  ATH_MSG_DEBUG( "Key for folder " << m_foldername << " set to "<< newkey << " from description string" );
830  m_key=newkey;
831  }
832  // check for 'cache' but only if not already found in joboptions
833  if (m_cachepar.empty()) m_cachepar=parsedDescription.cache();
834  // check for cachehint
835  if (int newCachehint=parsedDescription.cachehint();newCachehint!=0) m_cachehint=newCachehint;
836  // check for <named/>
837  m_named=parsedDescription.named();
838  // get addressHeader
839  if (auto newAddrHeader = parsedDescription.addressHeader();not newAddrHeader.empty()){
841  m_addrheader=newAddrHeader;
842  }
843  //get clid, if it exists (set to zero otherwise)
844  m_clid=parsedDescription.classId(msg());
845  // decode the typeName
846  if (!parsedDescription.getKey("typeName","",m_typename)) {
847  ATH_MSG_ERROR( "Primary type name is empty" );
848  return false;
849  }
850  bool gotCLID=(m_clid!=0);
851 
852  ATH_MSG_DEBUG( "Got folder typename " << m_typename );
853  if (!gotCLID)
854  if (StatusCode::SUCCESS==p_clidSvc->getIDOfTypeName(m_typename,m_clid))
855  gotCLID=true;
856  if (!gotCLID) {
857  ATH_MSG_ERROR("Could not get clid for typeName: " << m_typename);
858  return false;
859  }
860  ATH_MSG_DEBUG( "Got folder typename " << m_typename << " with CLID " << m_clid );
861  return success;
862 }

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

884  {
885  // preload Address from SG - does folder setup including COOL access
886  // also set detector store location - cannot be done in constructor
887  // as detector store does not exist yet in IOVDbSvc initialisation
888  // and sets up cache length, taking into account optional overrides
889  // returns null pointer in case of problem
890  p_tagInfoMgr = tagInfoMgr;
891  if( not m_useFileMetaData ) {
892  if(m_source=="CREST"){
893  m_folderDescription = m_crest_mng.value().getFolderDescription();
894  } else {
895  //folder desc from db
897  }
898  } else {
899  // folder description from meta-data set already earlier
900  }
901  ATH_MSG_DEBUG( "Folder description for " << m_foldername << ": " << m_folderDescription);
902  // register folder with meta-data tool if writing metadata
903  if (m_writemeta) {
904  if (StatusCode::SUCCESS!=p_metaDataTool->registerFolder(m_foldername,m_folderDescription)) {
905  ATH_MSG_ERROR( "Failed to register folder " << m_foldername<< " for meta-data write" );
906  return nullptr;
907  }
908  }
909  // parse the description string
910  IOVDbParser folderpar(m_folderDescription, msg());
911  //use the overrides in the folderdescription, return nullptr immediately if something went wrong
912  if (not overrideOptionsFromParsedDescription(folderpar)) return nullptr;
913  // setup channel list and folder type
914  if( not m_useFileMetaData ) {
915  if(m_source=="CREST"){
916  std::tie(m_channums, m_channames) = m_crest_mng.value().getChannelList();
917 
918  //determine foldertype from the description, the spec and the number of channels
919  m_foldertype = m_crest_mng.value().determineFolderType();
920  } else {
921  // data being read from COOL
922  auto fldPtr=m_conn->getFolderPtr<cool::IFolderPtr>(m_foldername);
923  // get the list of channels
925  // set folder type
927  }
928  }
929  m_nchan=m_channums.size();
930  ATH_MSG_DEBUG( "Folder identified as type " << m_foldertype );
931  // note that for folders read from metadata, folder type identification
932  // is deferred until getAddress when first data is read
933  // and channel number/name information is not read
934 
935  // change channel selection for single-object read
936  if (m_foldertype==AttrList || m_foldertype==PoolRef) m_chansel=cool::ChannelSelection(0);
937  const auto & linknameVector = folderpar.symLinks();
938  // now create TAD
939  auto tad{createTransientAddress(linknameVector)};
940  if (not tad) {
941  ATH_MSG_WARNING("Transient address is null in "<<__func__);
942  return nullptr;
943  }
944  setCacheLength(m_timestamp, cacheRun, cacheTime);
945  return tad;
946 }

◆ printCache()

void IOVDbFolder::printCache ( )

Definition at line 1098 of file IOVDbFolder.cxx.

1098  {
1099  const auto & [since,until] = m_iovs.getCacheBounds();
1100  ATH_MSG_DEBUG("folder cache printout -------------------");
1101  ATH_MSG_DEBUG(m_foldername << " length: "<<m_cachelength<<"\tstart: "<<since<<"\tstop: "<<until);
1102  ATH_MSG_DEBUG("current range: "<<m_currange);
1103  const auto & iovs = m_iovs.vectorStore();
1105  for (const auto & iov:iovs){
1106  ATH_MSG_DEBUG("channelID:\t"<<(*ci++)<<"\t since: "<<iov.first<<"\t until: "<<iov.second);
1107  }
1108  ATH_MSG_DEBUG("folder cache printout -------------------");
1109 
1110 }

◆ readMeta()

bool IOVDbFolder::readMeta ( ) const
inline

Definition at line 348 of file IOVDbFolder.h.

348 { return m_useFileMetaData; }

◆ readTime()

float IOVDbFolder::readTime ( ) const
inline

Definition at line 372 of file IOVDbFolder.h.

373 { return m_readtime; }

◆ resetCache()

void IOVDbFolder::resetCache ( )

Definition at line 617 of file IOVDbFolder.cxx.

617  {
618  // reset the cache to unfilled state, used if no more data will be required
619  // from this folder
621  clearCache();
622 }

◆ resolvedTag()

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

Definition at line 362 of file IOVDbFolder.h.

362 { return m_tag; }

◆ resolveTag()

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

Definition at line 986 of file IOVDbFolder.cxx.

986  {
987  // resolve the tag
988  // if specified in job options or already-processed override use that,
989  // else use global tag
990  // return false for failure
991  std::string tag=m_jotag;
992  if (tag=="HEAD") return true;
993  if (tag.empty()) tag=globalTag;
994  if (tag.empty()) {
995  ATH_MSG_ERROR( "No IOVDbSvc.GlobalTag specified on job options or input file" );
996  return false;
997  }
998  if(m_source=="CREST"){
999 
1000  m_tag = m_crestTag;
1001 
1002  ATH_MSG_DEBUG( "resolveTag returns " << m_tag );
1003  return true;
1004  }
1005  // check for magic tags
1006  if (IOVDbNamespace::looksLikeMagicTag(tag) and not magicTag(tag)) return false;
1007  // check tag exists - if not, lookup hierarchically
1008  const std::vector<std::string>& taglist=fptr->listTags();
1009  if (find(taglist.begin(),taglist.end(),tag)!=taglist.end()) {
1010  // tag exists directly in folder
1011  ATH_MSG_DEBUG( "Using tag "<< tag << " for folder " << m_foldername );
1012  } else {
1013  // tag maybe an HVS tag
1014  try {
1015  std::string restag=fptr->resolveTag(tag);
1016  ATH_MSG_INFO( "HVS tag " << tag << " resolved to "<< restag << " for folder " << m_foldername );
1017  // HVS tag may itself be magic
1018  if (IOVDbNamespace::looksLikeMagicTag(restag) and not magicTag(restag)) return false;
1019  tag=restag;
1020  }catch (cool::Exception& e) {
1021  ATH_MSG_ERROR( "Tag " << tag <<" cannot be resolved for folder " << m_foldername );
1022  return false;
1023  }
1024  }
1025  m_tag=tag;
1026  // optionally check if tag is locked
1027  if (m_checklock) {
1028  const auto tagLock=IOVDbNamespace::checkTagLock(fptr,tag);
1029  if (not tagLock.has_value()){
1030  ATH_MSG_ERROR( "Could not check tag lock status for " << tag );
1031  return false;
1032  }
1033  if (not tagLock.value()){
1034  ATH_MSG_ERROR("Tag " << tag <<" is not locked and IOVDbSvc.CheckLock is set" );
1035  return false;
1036  }
1037  }
1038  ATH_MSG_DEBUG( "resolveTag returns " << m_tag );
1039  return true;
1040 }

◆ retrieved()

bool IOVDbFolder::retrieved ( ) const
inline

Definition at line 340 of file IOVDbFolder.h.

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

948  {
949  if (timeIs_nsOfEpoch){
950  long long int clen=600; // default value of 10 minutes
951  if (cacheTime!=0) {
952  clen=cacheTime;
953  m_autocache=false;
954  } else {
955  // for timestamp, cache parameter (if set) sets length in seconds
956  if (not m_cachepar.empty()) clen=std::stoi(m_cachepar);
957  }
959  ATH_MSG_DEBUG( "Cache length set to " << clen << " seconds" );
960  } else {
961  // for run/event, cache parameter sets length in LB
962  // default value is 1 whole run
964  if (cacheRun!=0) {
966  m_autocache=false;
967  } else {
968  if (not m_cachepar.empty()) m_cachelength=std::stoi(m_cachepar);
969  }
971  ATH_MSG_DEBUG( "Cache length set to " << run <<" runs " << lumi << " lumiblocks" );
972  }
973 }

◆ setDropped()

void IOVDbFolder::setDropped ( const bool  dropped)
inline

Definition at line 382 of file IOVDbFolder.h.

382 { m_dropped=dropped; }

◆ setFolderDescription()

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

Definition at line 345 of file IOVDbFolder.h.

◆ setIOVOverride()

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

Definition at line 191 of file IOVDbFolder.cxx.

193  {
194  // set IOV override for this folder if run!=0 or time!=0
195  // folder-specific override takes precedence if set
196  if (m_iovoverridden) return;
197  if (m_timestamp) {
198  if (time!=0) {
200  ATH_MSG_INFO( "Override timestamp to " << m_iovoverride << " for folder "<< m_foldername );
201  m_iovoverridden=true;
202  }
203  } else {
204  if (run!=0 || lumiblock!=0) {
206  ATH_MSG_INFO( "Override run/LB number to [" << run << ":" << lumiblock <<
207  "] for folder " << m_foldername );
208  m_iovoverridden=true;
209  }
210  }
211 }

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

29 {
30  m_lvl = lvl;
31 }

◆ setSharedSpec()

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

Definition at line 1077 of file IOVDbFolder.cxx.

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

◆ setTagOverride()

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

Definition at line 176 of file IOVDbFolder.cxx.

176  {
177  if (m_tagoverride) {
178  ATH_MSG_WARNING( "Request to override tag for folder " <<
179  m_foldername << " to " << tag << " supercedes earlier override to " << m_jotag );
180  } else {
181  if (setFlag) m_tagoverride=true;
182  }
184 }

◆ setWriteMeta()

void IOVDbFolder::setWriteMeta ( )

Definition at line 186 of file IOVDbFolder.cxx.

186  {
187  m_writemeta=true;
188 }

◆ specialCacheUpdate() [1/2]

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

Definition at line 590 of file IOVDbFolder.cxx.

590  {
591 
592  // reset IOVRange in IOVSvc to trigger reset of object. Set to a
593  // time earlier than since.
594  IOVRange range = IOVDbNamespace::makeRange(ref.since()-2, ref.since()-1, m_timestamp);
595  if (StatusCode::SUCCESS != iovSvc->setRange(clid(), key(), range, eventStore())) {
596  ATH_MSG_ERROR( "IOVDbFolder::specialCacheUpdate - setRange failed for folder "
597  << folderName() );
598  return;
599  }
600  // add new object.
601  addIOVtoCache(ref.since(),ref.until());
602  m_cachechan.push_back(ref.channelId());
603  const coral::AttributeList& atrlist = ref.payload().attributeList();
604  // use the shared specification in storing the payload
605  const unsigned int istart=m_cacheattr.size();
606  m_cacheattr.emplace_back(*m_cachespec,true);// maybe needs to be cleared before
607  m_cacheattr.back().fastCopyData(atrlist);
609  if (m_foldertype==CoolVector) {
610  // save pointers to start and end
611  m_cacheccstart.push_back(istart);
612  m_cacheccend.push_back(m_cacheattr.size());
613  }
614 }

◆ specialCacheUpdate() [2/2]

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

Definition at line 564 of file IOVDbFolder.cxx.

564  {
565 
566  // reset IOVRange in IOVSvc to trigger reset of object. Set to a
567  // time earlier than since.
568  IOVRange range = IOVDbNamespace::makeRange(obj.since()-2, obj.since()-1, m_timestamp);
569  if (StatusCode::SUCCESS != iovSvc->setRange(clid(), key(), range, eventStore())) {
570  ATH_MSG_ERROR( "IOVDbFolder::specialCacheUpdate - setRange failed for folder "
571  << folderName() );
572  return;
573  }
574  addIOVtoCache(obj.since(),obj.until());
575  m_cachechan.push_back(obj.channelId());
576  // store all the attributeLists in the buffer save pointer to start
577  const unsigned int istart=m_cacheattr.size();
578  for (CoraCoolObject::const_iterator pitr=obj.begin(); pitr!=obj.end();++pitr) {
579  // use the shared specification in storing the payload
580  m_cacheattr.emplace_back(*m_cachespec,true);
581  m_cacheattr.back().fastCopyData(*pitr);
583  }
584  // save pointers to start and end
585  m_cacheccstart.push_back(istart);
586  m_cacheccend.push_back(m_cacheattr.size());
587 }

◆ summary()

void IOVDbFolder::summary ( )

Definition at line 808 of file IOVDbFolder.cxx.

808  {
810  // summarise the read statistics for this folder
811  ATH_MSG_INFO( "Folder " << m_foldername << " ("<<folderTypeName
812  << ") db-read " << m_ndbread << "/" <<
813  m_ncacheread << " objs/chan/bytes " << m_nobjread << "/" <<
814  m_nchan << "/" << m_nbytesread << " (( " << std::fixed << std::setw(8)
815  << std::setprecision(2) << m_readtime << " ))s" );
816  // print WARNING if data for this folder was never read from Storegate
817  if (m_ncacheread==0 && m_ndbread>0) {
818  ATH_MSG_WARNING( "Folder " << m_foldername << " is requested but no data retrieved" );
819  }
820 }

◆ tagOverride()

bool IOVDbFolder::tagOverride ( ) const
inline

Definition at line 336 of file IOVDbFolder.h.

336 { return m_tagoverride; }

◆ timeStamp()

bool IOVDbFolder::timeStamp ( ) const
inline

Definition at line 334 of file IOVDbFolder.h.

334 { return m_timestamp; }

◆ useFileMetaData()

void IOVDbFolder::useFileMetaData ( )

Definition at line 165 of file IOVDbFolder.cxx.

165  {
166  // enable folder from FLMD at given connection
167  m_useFileMetaData = true;
168  // if previously connected to a real DB connection, remove association
169  if (m_conn!=nullptr) {
170  m_conn->decUsage();
171  m_conn=nullptr;
172  }
173 }

◆ writeMeta()

bool IOVDbFolder::writeMeta ( ) const
inline

Definition at line 350 of file IOVDbFolder.h.

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

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

◆ m_cacheinc

int IOVDbFolder::m_cacheinc {0}
private

Definition at line 281 of file IOVDbFolder.h.

◆ m_cachelength

cool::ValidityKey IOVDbFolder::m_cachelength {0}
private

Definition at line 279 of file IOVDbFolder.h.

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

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

◆ m_clid

CLID IOVDbFolder::m_clid {0}
private

Definition at line 294 of file IOVDbFolder.h.

◆ m_conn

IOVDbConn* IOVDbFolder::m_conn {nullptr}
private

Definition at line 258 of file IOVDbFolder.h.

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

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

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

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

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

◆ m_iovoverride

cool::ValidityKey IOVDbFolder::m_iovoverride {0}
private

Definition at line 276 of file IOVDbFolder.h.

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

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

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

◆ m_named

bool IOVDbFolder::m_named {false}
private

Definition at line 270 of file IOVDbFolder.h.

◆ m_nbytesread

unsigned long long IOVDbFolder::m_nbytesread {0}
private

Definition at line 299 of file IOVDbFolder.h.

◆ m_ncacheread

unsigned int IOVDbFolder::m_ncacheread {0}
private

Definition at line 297 of file IOVDbFolder.h.

◆ m_nchan

unsigned int IOVDbFolder::m_nchan {0}
private

Definition at line 303 of file IOVDbFolder.h.

◆ m_ndbread

unsigned int IOVDbFolder::m_ndbread {0}
private

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

◆ m_notagoverride

bool IOVDbFolder::m_notagoverride {false}
private

Definition at line 265 of file IOVDbFolder.h.

◆ m_outputToFile

const bool IOVDbFolder::m_outputToFile {false}
private

Definition at line 318 of file IOVDbFolder.h.

◆ m_readtime

float IOVDbFolder::m_readtime {0}
private

Definition at line 300 of file IOVDbFolder.h.

◆ m_retrieved

bool IOVDbFolder::m_retrieved {false}
private

Definition at line 308 of file IOVDbFolder.h.

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

◆ m_timestamp

bool IOVDbFolder::m_timestamp {false}
private

Definition at line 263 of file IOVDbFolder.h.

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

◆ m_writemeta

bool IOVDbFolder::m_writemeta {false}
private

Definition at line 266 of file IOVDbFolder.h.

◆ p_clidSvc

IClassIDSvc* IOVDbFolder::p_clidSvc {nullptr}
private

Definition at line 256 of file IOVDbFolder.h.

◆ p_metaDataTool

IIOVDbMetaDataTool* IOVDbFolder::p_metaDataTool {nullptr}
private

Definition at line 257 of file IOVDbFolder.h.

◆ p_tagInfoMgr

ITagInfoMgr* IOVDbFolder::p_tagInfoMgr {nullptr}
private

Definition at line 255 of file IOVDbFolder.h.


The documentation for this class was generated from the following files:
IOVDbFolder::m_dropped
bool m_dropped
Definition: IOVDbFolder.h:273
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
CondAttrListCollection::minRange
const IOVRange & minRange() const
Current minimal IOVRange.
Definition: CondAttrListCollection.h:438
IOVDbNamespace::IovStore::extendIov
void extendIov(const unsigned int idx, const cool::ValidityKey &newUntilTime)
Extend a specific iov at the index to a new 'until' time.
Definition: IovStore.cxx:77
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition: AthMessaging.h:138
IOVDbParser::noTagOverride
bool noTagOverride() const
Definition: IOVDbParser.cxx:217
IOVDbNamespace::spaceStrip
std::string spaceStrip(const std::string &input)
Trim leading and trailing spaces,return a new trimmed string.
Definition: IOVDbStringFunctions.cxx:11
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
IOVDbFolder::m_outputToFile
const bool m_outputToFile
Definition: IOVDbFolder.h:318
IOVDbFolder::dumpFile
void dumpFile(const std::string &dumpName, const cool::ValidityKey &vkey, IOVDbNamespace::Cool2Json *json, bool skipCoolIoV, CoralCrestManager *mng=NULL, const cool::ValidityKey crestVkey=0) const
Definition: IOVDbFolder.cxx:1136
CxxUtils::span
span(T *ptr, std::size_t sz) -> span< T >
A couple needed deduction guides.
IOVDbFolder::m_cacheccend
std::vector< unsigned int > m_cacheccend
Definition: IOVDbFolder.h:316
IOVDbNamespace::Cool2Json
Definition: Cool2Json.h:26
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
IOVDbFolder::m_crestCoolToFile
const bool m_crestCoolToFile
Definition: IOVDbFolder.h:319
IOVDbFolder::m_useFileMetaData
bool m_useFileMetaData
Definition: IOVDbFolder.h:267
IOVDbFolder::magicTag
bool magicTag(std::string &tag)
Definition: IOVDbFolder.cxx:1043
IOVDbFolder::dropped
bool dropped() const
Definition: IOVDbFolder.h:356
get_generator_info.result
result
Definition: get_generator_info.py:21
IOVDbFolder::m_checklock
bool m_checklock
Definition: IOVDbFolder.h:275
IOVDbFolder::p_metaDataTool
IIOVDbMetaDataTool * p_metaDataTool
Definition: IOVDbFolder.h:257
dqt_zlumi_alleff_HIST.iov
iov
Definition: dqt_zlumi_alleff_HIST.py:119
IOVDbFolder::m_foldername
std::string m_foldername
Definition: IOVDbFolder.h:259
IOVDbFolder::m_tagoverride
bool m_tagoverride
Definition: IOVDbFolder.h:264
IOVDbFolder::conn
IOVDbConn * conn()
Definition: IOVDbFolder.h:330
IOVDbFolder::m_retrieved
bool m_retrieved
Definition: IOVDbFolder.h:308
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
IOVDbFolder::m_ncacheread
unsigned int m_ncacheread
Definition: IOVDbFolder.h:297
python.MagFieldUtils.lumiblock
lumiblock
Definition: MagFieldUtils.py:187
IOVDbNamespace::IovStore::vectorStore
std::vector< Iov_t > & vectorStore()
Return the internal vector store.
Definition: IovStore.cxx:64
json
nlohmann::json json
Definition: HistogramDef.cxx:9
IOVDbParser::cachehint
int cachehint() const
Definition: IOVDbParser.cxx:168
IOVDbFolder::m_jokey
bool m_jokey
Definition: IOVDbFolder.h:272
find_tgc_unfilled_channelids.iovs
iovs
Definition: find_tgc_unfilled_channelids.py:12
IOVDbNamespace::IovStore::getMinimumStraddlingSpan
Iov_t getMinimumStraddlingSpan() const
Get the minimum straddling span (max 'since' to min 'until')
Definition: IovStore.cxx:45
CondAttrListCollection::addNewStop
void addNewStop(const IOVTime &stop)
Add new stop time to minRange - make sure that stop is <= to new stop
Definition: CondAttrListCollection.h:518
IOVDbConn::open
bool open()
Definition: IOVDbConn.cxx:74
python.LArRawChannelBuilderCrestConfig.crestServer
crestServer
Definition: LArRawChannelBuilderCrestConfig.py:118
IOVDbFolder::m_crestTag
const std::string m_crestTag
Definition: IOVDbFolder.h:322
IOVDbFolder::m_crestServer
const std::string m_crestServer
Definition: IOVDbFolder.h:321
IOVDbNamespace::ALL_LUMI_BLOCKS
constexpr unsigned long long ALL_LUMI_BLOCKS
All the lumi blocks in one run.
Definition: IOVDbCoolFunctions.h:36
IOVDbNamespace::IovStore::numberOfIovsOnBoundaries
std::pair< unsigned int, unsigned int > numberOfIovsOnBoundaries() const
Return the current count of added Iovs which straddled cache boundaries.
Definition: IovStore.cxx:51
IOVDbFolder::m_currange
IOVRange m_currange
Definition: IOVDbFolder.h:309
IOVDbConn::name
const std::string & name() const
Definition: IOVDbConn.h:70
IOVDbFolder::m_cacheinc
int m_cacheinc
Definition: IOVDbFolder.h:281
CoralCrestManager
Definition: CoralCrestManager.h:29
IOVDbNamespace::IovStore::clear
void clear()
clear the store
Definition: IovStore.cxx:56
IOVDbFolder::createTransientAddress
std::unique_ptr< SG::TransientAddress > createTransientAddress(const std::vector< std::string > &symlinks)
Definition: IOVDbFolder.cxx:865
IIOVDbMetaDataTool::registerFolder
virtual StatusCode registerFolder(const std::string &folderName, const std::string &folderDescription) const =0
Register folder in the IOV Db MetaData.
IOVDbNamespace::IovStore::size
unsigned int size() const
length of store
Definition: IovStore.h:45
python.SystemOfUnits.second
float second
Definition: SystemOfUnits.py:135
IOVDbFolder::specialCacheUpdate
void specialCacheUpdate(CoraCoolObject &obj, const ServiceHandle< IIOVSvc > &iovSvc)
Definition: IOVDbFolder.cxx:564
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
CoralCrestManager::dumpPayload
std::string dumpPayload(cool::ValidityKey since)
Definition: CoralCrestManager.cxx:287
IOVDbParser::onlyReadMetadata
bool onlyReadMetadata() const
Definition: IOVDbParser.cxx:179
run
int run(int argc, char *argv[])
Definition: ttree2hdf5.cxx:28
IOVDbFolder::m_cachelength
cool::ValidityKey m_cachelength
Definition: IOVDbFolder.h:279
CheckTagAssociation.taglist
taglist
Definition: CheckTagAssociation.py:103
IOVDbNamespace::PoolRefColl
@ PoolRefColl
Definition: FolderTypes.h:31
CondAttrListCollection::addNewStart
void addNewStart(const IOVTime &start)
Add new start time to minRange - make sure that start is >= to new start.
Definition: CondAttrListCollection.h:508
IOVDbNamespace::iovTimeFromSeconds
unsigned long long iovTimeFromSeconds(const unsigned long long seconds)
Create a long long time in ns from s.
Definition: IOVDbCoolFunctions.cxx:98
IOVDbFolder::m_tag
std::string m_tag
Definition: IOVDbFolder.h:289
IOVDbFolder::eventStore
const std::string & eventStore() const
Definition: IOVDbFolder.h:364
IOVDbFolder::m_chansel
cool::ChannelSelection m_chansel
Definition: IOVDbFolder.h:283
IOVDbFolder::fetchCrestIOVs
std::vector< IOVHash > fetchCrestIOVs(cool::ValidityKey since, cool::ValidityKey until)
Definition: IOVDbFolder.cxx:1112
IOVDbNamespace::PoolRef
@ PoolRef
Definition: FolderTypes.h:30
IOVDbParser::overridesIov
bool overridesIov(MsgStream &msg) const
return true if this description overrides the timestamp or runlumi
Definition: IOVDbParser.cxx:262
IOVDbConn::valid
bool valid() const
Definition: IOVDbConn.h:60
python.PyKernel.AttributeList
AttributeList
Definition: PyKernel.py:36
IOVDbFolder::p_tagInfoMgr
ITagInfoMgr * p_tagInfoMgr
Definition: IOVDbFolder.h:255
IOVDbFolder::m_fromMetaDataOnly
bool m_fromMetaDataOnly
Definition: IOVDbFolder.h:268
IOVDbNamespace::makeEpochOrRunLumi
IOVTime makeEpochOrRunLumi(const cool::ValidityKey key, const bool timeIsEpoch)
Create an IOVTime in ns of epoch or run-lumi (determined by the bool) from a ValidityKey.
Definition: IOVDbCoolFunctions.cxx:87
CondAttrListCollection
This class is a collection of AttributeLists where each one is associated with a channel number....
Definition: CondAttrListCollection.h:52
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
IOVDbNamespace::IovStore::Iov_t
std::pair< cool::ValidityKey, cool::ValidityKey > Iov_t
Definition: IovStore.h:22
IOVDbFolder::setSharedSpec
void setSharedSpec(const coral::AttributeList &atrlist)
Definition: IOVDbFolder.cxx:1077
makeDTCalibBlob_pickPhase.globalTag
globalTag
Definition: makeDTCalibBlob_pickPhase.py:398
IOVDbParser::named
bool named() const
Definition: IOVDbParser.cxx:174
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
IOVDbNamespace::replaceServiceType71
bool replaceServiceType71(std::string &addrHeader)
Definition: IOVDbStringFunctions.cxx:212
IOVDbFolder::folderName
const std::string & folderName() const
Definition: IOVDbFolder.h:327
IOVDbConn::getFolderPtr
T getFolderPtr(const std::string &folderName)
Definition: IOVDbConn.h:43
IOVDbFolder::m_foldertype
IOVDbNamespace::FolderType m_foldertype
Definition: IOVDbFolder.h:277
dq_defect_copy_defect_database.since
def since
Definition: dq_defect_copy_defect_database.py:54
dq_defect_copy_defect_database.until
def until
Definition: dq_defect_copy_defect_database.py:55
AthMessaging::setLevel
void setLevel(MSG::Level lvl)
Change the current logging level.
Definition: AthMessaging.cxx:28
IOVDbFolder::m_addrheader
std::string m_addrheader
Definition: IOVDbFolder.h:293
AthMessaging::AthMessaging
AthMessaging()
Default constructor:
CoraCoolObject::const_iterator
AttrListVec::const_iterator const_iterator
Definition: CoraCoolObject.h:23
IOVDbFolder::clid
CLID clid() const
Definition: IOVDbFolder.h:367
python.AthDsoLogger.delimiter
delimiter
Definition: AthDsoLogger.py:70
IOVDbFolder::m_readtime
float m_readtime
Definition: IOVDbFolder.h:300
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
IOVDbFolder::m_jotag
std::string m_jotag
Definition: IOVDbFolder.h:288
IOVDbFolder::m_iovoverride
cool::ValidityKey m_iovoverride
Definition: IOVDbFolder.h:276
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
IOVDbParser::extensible
bool extensible() const
Definition: IOVDbParser.cxx:184
IOVDbFolder::addMetaAttrListColl
bool addMetaAttrListColl(const CondAttrListCollection *coll)
Definition: IOVDbFolder.cxx:1063
python.AppMgr.iadd
def iadd(self, tool)
associator for public tools -------------------------------------------—
Definition: AppMgr.py:29
IOVDbFolder::p_clidSvc
IClassIDSvc * p_clidSvc
Definition: IOVDbFolder.h:256
CondAttrListVec
Definition: CondAttrListVec.h:31
IOVDbFolder::m_crest_mng
std::optional< CoralCrestManager > m_crest_mng
Definition: IOVDbFolder.h:324
lumiFormat.i
int i
Definition: lumiFormat.py:85
IOVDbNamespace::checkTagLock
std::optional< bool > checkTagLock(const cool::IFolderPtr &fptr, const std::string &tag)
Check whether a tag is locked on a folder, if possible.
Definition: TagFunctions.cxx:43
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
IOVDbFolder::m_cachehint
int m_cachehint
Definition: IOVDbFolder.h:280
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
IOVDbFolder::m_clid
CLID m_clid
Definition: IOVDbFolder.h:294
IOVDbFolder::m_cachepar
std::string m_cachepar
Definition: IOVDbFolder.h:292
IOVDbFolder::m_channames
std::vector< std::string > m_channames
Definition: IOVDbFolder.h:305
IOVDbParser::cache
std::string cache() const
Definition: IOVDbParser.cxx:163
calibdata.exception
exception
Definition: calibdata.py:495
IOVDbFolder::m_iovs
IOVDbNamespace::IovStore m_iovs
Definition: IOVDbFolder.h:317
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:194
IOVDbNamespace::IovStore::getCacheBounds
Iov_t getCacheBounds() const
Report the current cache bounds.
Definition: IovStore.cxx:31
IOVDbNamespace::CoolVector
@ CoolVector
Definition: FolderTypes.h:33
IOVDbFolder::m_iovoverridden
bool m_iovoverridden
Definition: IOVDbFolder.h:271
IOVDbNamespace::CoraCool
@ CoraCool
Definition: FolderTypes.h:32
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
AthenaAttributeList
An AttributeList represents a logical row of attributes in a metadata table. The name and type of eac...
Definition: PersistentDataModel/PersistentDataModel/AthenaAttributeList.h:45
IOVDbFolder::m_autocache
bool m_autocache
Definition: IOVDbFolder.h:274
run
Definition: run.py:1
IOVDbNamespace::channelList
std::pair< std::vector< cool::ChannelId >, std::vector< std::string > > channelList(IOVDbConn *pConnection, const std::string &folderName, const bool named)
Retrieve channel information.
Definition: IOVDbCoolFunctions.cxx:160
IOVDbNamespace::IovStore::setCacheBounds
void setCacheBounds(const Iov_t &cacheBounds)
Set the cache bound variables.
Definition: IovStore.cxx:36
fptr
std::vector< TFile * > fptr
Definition: hcg.cxx:48
HLT::setFlag
void setFlag(TrigPassFlags *flags, const T *obj, const CONTAINER *container, const std::vector< bool > &flag)
Set the flag at index position.
Definition: TrigPassFlags.h:121
IOVDbFolder::m_folderDescription
std::string m_folderDescription
Definition: IOVDbFolder.h:261
IOVDbNamespace::AttrListColl
@ AttrListColl
Definition: FolderTypes.h:29
IOVDbParser::iovOverrideValue
unsigned long long iovOverrideValue(MsgStream &msg) const
Definition: IOVDbParser.cxx:301
IOVDbFolder::m_source
const std::string m_source
Definition: IOVDbFolder.h:320
IIOVDbMetaDataTool::addPayload
virtual StatusCode addPayload(const std::string &folderName, CondAttrListCollection *payload) const =0
Add an IOV and Payload for a particular folder - replaces payloads if there is an IOV overlap.
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AthMessaging.h:164
IOVDbParser::key
std::string key() const
Definition: IOVDbParser.cxx:138
CoraCoolFolderPtr
boost::shared_ptr< CoraCoolFolder > CoraCoolFolderPtr
Definition: CoraCoolTypes.h:15
IOVDbFolder::addMetaAttrList
bool addMetaAttrList(const coral::AttributeList &atrlist, const IOVRange &range)
Definition: IOVDbFolder.cxx:1051
IOVDbFolder::m_writemeta
bool m_writemeta
Definition: IOVDbFolder.h:266
IOVDbFolder::addIOVtoCache
void addIOVtoCache(cool::ValidityKey since, cool::ValidityKey until)
Definition: IOVDbFolder.cxx:1091
grepfile.ic
int ic
Definition: grepfile.py:33
IOVDbParser::tag
std::string tag() const
Definition: IOVDbParser.cxx:148
CoraCoolDatabasePtr
boost::shared_ptr< CoraCoolDatabase > CoraCoolDatabasePtr
Definition: CoraCoolTypes.h:12
IOVDbNamespace::makeRange
IOVRange makeRange(const cool::ValidityKey since, const cool::ValidityKey until, const bool timeIsEpoch)
Make an IOVRange from two validity keys.
Definition: IOVDbCoolFunctions.cxx:113
IOVDbNamespace::IovStore::addIov
void addIov(const Iov_t &iov)
Add an iov to the store and update the span variables.
Definition: IovStore.cxx:16
IOVDbParser::getKey
bool getKey(const std::string &key, const std::string &devvalue, std::string &value) const
original 'getKey' method, now implemented using 'at'
Definition: IOVDbParser.cxx:108
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
IOVDbParser
Definition: IOVDbParser.h:19
IOVDbNamespace::sanitiseFilename
std::string sanitiseFilename(const std::string &fname)
Replace the '/' of a file path with '^'.
Definition: IOVDbStringFunctions.cxx:110
IOVDbFolder::m_chanrange
std::vector< ChanRange > m_chanrange
Definition: IOVDbFolder.h:285
IOVDbFolder::m_channums
std::vector< cool::ChannelId > m_channums
Definition: IOVDbFolder.h:304
IOVDbFolder::m_nobjread
unsigned int m_nobjread
Definition: IOVDbFolder.h:298
IOVDbFolder::key
const std::string & key() const
Definition: IOVDbFolder.h:328
RTTAlgmain.address
address
Definition: RTTAlgmain.py:55
IOVDbNamespace::typeSizeIsKnown
bool typeSizeIsKnown(const coral::Attribute &attribute)
Return a bool indicating whether the size of a given Attribute can be determined.
Definition: IOVDbCoolFunctions.cxx:67
IOVDbParser::timebaseIs_nsOfEpoch
bool timebaseIs_nsOfEpoch() const
Definition: IOVDbParser.cxx:158
IOVDbFolder::cacheUpdateImplementation
unsigned int cacheUpdateImplementation(T &obj, const ServiceHandle< IIOVSvc > &iovSvc)
Definition: IOVDbFolder.h:175
IOVDbNamespace::resolveUsingTagInfo
std::string resolveUsingTagInfo(const std::string &tag, const ITagInfoMgr *tagInfoMgr)
Definition: TagFunctions.cxx:54
IOVDbFolder::m_cachespec
coral::AttributeListSpecification * m_cachespec
Definition: IOVDbFolder.h:312
IOVDbFolder::m_nchan
unsigned int m_nchan
Definition: IOVDbFolder.h:303
IOVDbNamespace::runLumiFromIovTime
std::pair< unsigned long long, unsigned long long > runLumiFromIovTime(const unsigned long long iovTime)
Return a [run,lumi] pair from an IOV time.
Definition: IOVDbCoolFunctions.cxx:108
IOVDbFolder::m_named
bool m_named
Definition: IOVDbFolder.h:270
lumiFormat.lumi
lumi
Definition: lumiFormat.py:106
IOVDbFolder::clearCache
void clearCache()
Definition: IOVDbFolder.cxx:976
IOVDbParser::folderName
std::string folderName() const
give the folder name contained in the parsed description
Definition: IOVDbParser.cxx:133
CoraCoolObjectIterPtr
boost::shared_ptr< CoraCoolObjectIter > CoraCoolObjectIterPtr
Definition: CoraCoolTypes.h:21
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:108
IOVDbNamespace::attributeListSize
unsigned int attributeListSize(const coral::AttributeList &atrlist)
return the size (in bytes) of an AttributeList
Definition: IOVDbCoolFunctions.cxx:72
IOVDbFolder::resolveTag
bool resolveTag(const cool::IFolderPtr &fptr, const std::string &globalTag)
Definition: IOVDbFolder.cxx:986
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
IOVDbFolder::m_notagoverride
bool m_notagoverride
Definition: IOVDbFolder.h:265
IOVDbNamespace::folderMetadata
std::pair< bool, std::string > folderMetadata(IOVDbConn *pConnection, const std::string &folderName)
Retrieve (bool) multiversion flag and folder description
Definition: IOVDbCoolFunctions.cxx:136
IOVDbFolder::setCacheLength
void setCacheLength(const bool timeIs_nsOfEpoch, const unsigned int cacheRun, const unsigned int cacheTime)
Definition: IOVDbFolder.cxx:948
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
IOVDbParser::hasKey
bool hasKey() const
Definition: IOVDbParser.cxx:143
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
ref
const boost::regex ref(r_ef)
IOVDbConn::decUsage
void decUsage()
Definition: IOVDbConn.h:74
IOVDbNamespace::IovStore::extendCacheHi
bool extendCacheHi()
Extend upper cache bound to the minimum 'until' time; return whether this changes its value.
Definition: IovStore.cxx:96
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition: AthMessaging.h:129
DeMoScan.first
bool first
Definition: DeMoScan.py:534
CoraCoolObjectPtr
boost::shared_ptr< CoraCoolObject > CoraCoolObjectPtr
Definition: CoraCoolTypes.h:18
IOVDbNamespace::AttrList
@ AttrList
Definition: FolderTypes.h:28
IOVDbFolder::overrideOptionsFromParsedDescription
bool overrideOptionsFromParsedDescription(const IOVDbParser &parsedDescription)
Definition: IOVDbFolder.cxx:823
IOVDbNamespace::SafeReadFromFileMetaData
Definition: ReadFromFileMetaData.h:74
IOVDbFolder::m_cachechan
std::vector< cool::ChannelId > m_cachechan
Definition: IOVDbFolder.h:313
CaloCondBlobAlgs_fillNoiseFromASCII.folder
folder
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:55
IOVDbFolder::m_ndbread
unsigned int m_ndbread
Definition: IOVDbFolder.h:296
IOVDbNamespace::IovStore::at
Iov_t at(const unsigned int idx) const
'at' to read iov at specific index
Definition: IovStore.h:49
IOVDbNamespace::folderTypeName
std::string folderTypeName(const FolderType f)
Give a string name for the folder type.
Definition: FolderTypes.cxx:135
pvec
std::array< fp_t, 2 > pvec
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:9
copySelective.source
string source
Definition: copySelective.py:31
IOVDbParser::classId
CLID classId(MsgStream &msg) const
Definition: IOVDbParser.cxx:190
IOVDbNamespace::iovTimeFromRunLumi
unsigned long long iovTimeFromRunLumi(const unsigned long long run, const unsigned long long lumi)
Create a long long representing the IOV from run, lumi.
Definition: IOVDbCoolFunctions.cxx:103
IOVDbFolder::m_multiversion
bool m_multiversion
Definition: IOVDbFolder.h:262
IOVDbNamespace::determineFolderType
FolderType determineFolderType(const std::string &folderDescription, const std::string &spec, const std::vector< cool::ChannelId > &chans)
Determine folder type with optional check using clid service to check clid matches typename.
Definition: FolderTypes.cxx:17
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:23
IOVDbNamespace::IovStore::extendCacheLo
bool extendCacheLo()
Extend lower cache bound to the maximum 'since' time; return whether this changes its value.
Definition: IovStore.cxx:89
IOVDbFolder::m_nbytesread
unsigned long long m_nbytesread
Definition: IOVDbFolder.h:299
IOVDbNamespace::countSelectedChannels
int countSelectedChannels(const std::vector< cool::ChannelId > &channels, const cool::ChannelSelection &selected)
Count the number of selected channels in a vector of channels according to cool::Channel selection.
Definition: IOVDbCoolFunctions.cxx:81
AthMessaging::initMessaging
void initMessaging() const
Initialize our message level and MessageSvc.
Definition: AthMessaging.cxx:39
IOVDbFolder::m_key
std::string m_key
Definition: IOVDbFolder.h:260
IOVDbNamespace::looksLikeMagicTag
bool looksLikeMagicTag(const std::string &candidateTag)
Looks like it should be magic.
Definition: IOVDbStringFunctions.cxx:151
CondAttrListVec::addSlice
void addSlice(const IOVRange &range, const unsigned int chan, const std::vector< coral::AttributeList > &data, const unsigned int datastart, const unsigned int dataend)
Definition: CondAttrListVec.h:268
AthMessaging::m_msg_tls
boost::thread_specific_ptr< MsgStream > m_msg_tls
MsgStream instance (a std::cout like with print-out levels)
Definition: AthMessaging.h:132
IOVDbFolder::m_cacheccstart
std::vector< unsigned int > m_cacheccstart
Definition: IOVDbFolder.h:315
test_pyathena.counter
counter
Definition: test_pyathena.py:15
IOVDbConn::dropAndReconnect
bool dropAndReconnect()
Definition: IOVDbConn.cxx:85
python.PyAthena.obj
obj
Definition: PyAthena.py:132
IOVDbParser::addressHeader
std::string addressHeader() const
Definition: IOVDbParser.cxx:206
CondAttrListCollection::add
bool add(ChanNum chanNum, const AttributeList &attributeList)
Adding in chan/attrList pairs.
Definition: CondAttrListCollection.h:452
Cut::all
@ all
Definition: SUSYToolsAlg.cxx:67
IOVDbFolder::fetchCrestObjects
std::vector< IOVHash > fetchCrestObjects(cool::ValidityKey since, cool::ValidityKey until, cool::ValidityKey vkey)
Definition: IOVDbFolder.cxx:1178
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
python.compressB64.c
def c
Definition: compressB64.py:93
IOVDbFolder::m_conn
IOVDbConn * m_conn
Definition: IOVDbFolder.h:258
IOVDbNamespace::IovStore::empty
bool empty() const
is the store empty?
Definition: IovStore.h:43
IOVDbNamespace::IovStore::setIovSpan
void setIovSpan(const Iov_t &span)
Set span.
Definition: IovStore.cxx:82
IOVDbParser::eventStoreName
std::string eventStoreName() const
Definition: IOVDbParser.cxx:153
IOVDbConn::getCoraCoolDb
CoraCoolDatabasePtr getCoraCoolDb()
Definition: IOVDbConn.cxx:102
IOVDbFolder::m_typename
std::string m_typename
Definition: IOVDbFolder.h:290
IOVDbFolder::objectIteratorIsValid
bool objectIteratorIsValid(cool::IObjectIteratorPtr &objItr)
Definition: IOVDbFolder.h:216
IOVDbFolder::m_timestamp
bool m_timestamp
Definition: IOVDbFolder.h:263
CondAttrListVec::minRange
const IOVRange & minRange() const
Definition: CondAttrListVec.h:232
extractSporadic.myFile
myFile
Definition: extractSporadic.py:86
IOVDbFolder::m_cacheattr
std::vector< coral::AttributeList > m_cacheattr
Definition: IOVDbFolder.h:314
CoralCrestManager::getPayloadSpec
std::string getPayloadSpec()
Definition: CoralCrestManager.cxx:148
CondAttrListCollection::addShared
void addShared(ChanNum chanNum, const AttributeList &attributeList)
Adding in chan/attrList pairs with shared data.
Definition: CondAttrListCollection.h:469
description
std::string description
glabal timer - how long have I taken so far?
Definition: hcg.cxx:88
IOVDbFolder::m_eventstore
std::string m_eventstore
Definition: IOVDbFolder.h:291
python.SystemOfUnits.ms
float ms
Definition: SystemOfUnits.py:148
IOVDbFolder::m_extensible
bool m_extensible
Definition: IOVDbFolder.h:269