ATLAS Offline Software
Public Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
AtlCoolCopy Class Reference
Collaboration diagram for AtlCoolCopy:

Public Member Functions

 AtlCoolCopy (const std::string &sourcedb, const std::string &destdb, bool allowcreate=false)
 
bool isOpen () const
 
bool addFolder (const std::string &folder, const bool onlyTags)
 
bool addExclude (const std::string &folder)
 
int copyFolder ATLAS_NOT_THREAD_SAFE (const std::string &folder, const std::vector< std::string > &taglist)
 
int doCopy ATLAS_NOT_THREAD_SAFE ()
 
int setOpts (int argc, const char *argv[])
 

Private Types

typedef std::map< std::string, PoolMapElementPoolMap
 
using HiTagMap = std::map< std::string, std::string >
 
using CoolTagMap = std::map< std::string, CoolTagInfo >
 

Private Member Functions

bool openConnections (const std::string &sourcedb, const std::string &destdb, bool allowcreate)
 
bool openCoraCool ()
 
bool getLockedTags ()
 
bool procOptVector (const int argc, const char *argv[], std::vector< std::string > &folders)
 
void setChannelRange (const cool::IFolderPtr &sourcefl)
 
int copyIOVs ATLAS_NOT_THREAD_SAFE (const std::string &folder, const std::string &destfolder, const cool::IFolderPtr &sourcefl, const CoraCoolFolderPtr &sourceflc, const cool::IFolderPtr &destfl, const CoraCoolFolderPtr &destflc, const std::string &sourcetag, const std::string &desttag, const cool::ValidityKey since, const cool::ValidityKey until, bool timestamp, bool checkrefs, bool iscora, const cool::PayloadMode::Mode paymode, bool created)
 
void adjustIOVs (const cool::ValidityKey &since, const cool::ValidityKey &until, const cool::ValidityKey &qsince, const cool::ValidityKey &quntil, cool::ValidityKey &newsince, cool::ValidityKey &newuntil, const bool timestamp) const
 
int nocopyIOVs (const std::string &folder, const cool::IFolderPtr &sourcefl, const std::string &sourcetag, const cool::ValidityKey since, const cool::ValidityKey until, bool checkrefs)
 
int verifyIOVs (const std::string &folder, const cool::IFolderPtr &sourcefl, const CoraCoolFolderPtr &sourceflc, const cool::IFolderPtr &destfl, const CoraCoolFolderPtr &destflc, const std::string &sourcetag, const cool::ValidityKey since, const cool::ValidityKey until, const bool checkrefs, const bool iscora, const cool::PayloadMode::Mode paymode)
 
int rootIOVs (const std::string &folder, const cool::IFolderPtr &sourcefl, const std::string &sourcetag, const cool::ValidityKey since, const cool::ValidityKey until, const bool timestamp)
 
std::string rootDirs (const std::string &folder, const std::string &toproot)
 
bool rootAllocate (const cool::IFieldSpecification &spec, void *&sptr, char &rootID) const
 
void rootWrite (void *sptr, const cool::IField &field) const
 
int analyseIOVs (const std::string &folder, const cool::IFolderPtr &sourcefl, const std::string &sourcetag, const cool::ValidityKey since, const cool::ValidityKey until, const bool timestamp)
 
bool getTimeFromRun ()
 
bool getOnlineRun ()
 
bool getBulkRun ()
 
bool getRunList ()
 
bool checkChannels (const std::string &folder, const cool::IFolderPtr &sourcefl, const cool::IFolderPtr &destfl, bool newfolder)
 
void checkRef (const cool::IRecord &payload, const std::string &folder, const std::string &tag)
 
int tagParents ()
 
int writeTagInfo ()
 
int listPoolRefs ()
 
int resolvePoolRefs ATLAS_NOT_THREAD_SAFE ()
 
void filePoolRefs ()
 

Static Private Member Functions

static std::string transConn (const std::string &inconn)
 
static cool::ChannelId channelID (const cool::IFolderPtr &folder, const std::string &chanstring)
 
static bool isNumeric (const char *input)
 
static bool equalRecord (const cool::IRecord &lhs, const cool::IRecord &rhs)
 
static TH1F * bookOrFindTH1F (const std::string &hID, const std::string &htitle, const int chan, const float xlow, const float xhigh)
 
static cool::ValidityKey timeVal (const char *input)
 
static std::string timeString (const cool::ValidityKey iovtime)
 
static cool::ValidityKey runLBVal (const char *input1, const char *input2)
 
static int getUpdateMode (std::string_view desc, std::string_view tag)
 
static std::string getCoolHistGUID (const std::string &file)
 
static pool::IFileCatalogsetupCatalog (const std::vector< std::string > &catvec)
 

Private Attributes

std::string m_sourcedb
 
std::string m_destdb
 
bool m_allowcreate
 
bool m_recreate
 
bool m_includehead
 
bool m_excludehead
 
bool m_usertags
 
bool m_userupdatehead
 
bool m_debug
 
bool m_alliov
 
bool m_verify
 
bool m_root
 
bool m_zeronull
 
bool m_analyse
 
bool m_checkrefs
 
bool m_listpfn
 
bool m_poolopen
 
bool m_poolall
 
bool m_nocopy
 
bool m_nodata
 
bool m_nochannel
 
bool m_chdesc
 
bool m_hitag
 
bool m_nohitag
 
bool m_forcesingle
 
bool m_forcemulti
 
bool m_forcerune
 
bool m_forcetime
 
bool m_forcepay
 
bool m_forcenopay
 
bool m_sourceread
 
bool m_truncate
 
bool m_skipout
 
bool m_skiprep
 
bool m_applock
 
bool m_applocksv
 
bool m_readoracle
 
bool m_gettime
 
bool m_getonline
 
bool m_onlinerun
 
bool m_getbulk
 
bool m_prunetags
 
bool m_lockedonly
 
bool m_copytaginfo
 
bool m_copytaglock
 
bool m_coracool
 
bool m_ignoremode
 
bool m_ignorespec
 
bool m_checkdesttag
 
bool m_noclobroot
 
cool::ValidityKey m_runemin
 
cool::ValidityKey m_runemax
 
cool::ValidityKey m_timemin
 
cool::ValidityKey m_timemax
 
cool::ValidityKey m_newrunemin
 
cool::ValidityKey m_newrunemax
 
cool::ValidityKey m_newtimemin
 
cool::ValidityKey m_newtimemax
 
cool::ValidityKey m_srunemin
 
cool::ValidityKey m_srunemax
 
std::vector< std::string > m_channelRange
 
std::string m_channel1
 
std::string m_channel2
 
int m_bufsize
 
int m_sealmsg
 
long long m_anadelt
 
std::string m_outfolder
 
std::string m_outtag
 
std::string m_newdataset
 
std::string m_checkoutputfile
 
std::string m_timedb
 
std::string m_taglabel
 
std::string m_runinfohost
 
std::vector< std::string > m_addguid
 
std::vector< std::string > m_addlfn
 
std::vector< std::string > m_parfile
 
std::vector< cool::ChannelId > m_excludechans
 
std::vector< std::string > m_runfile
 
std::vector< unsigned int > m_runlist
 
coral::ConnectionService m_coralsvc
 
cool::Application m_coolapp
 
cool::IDatabaseSvc * m_dbSvc
 
ReplicaSorterm_repsort
 
cool::IDatabasePtr m_sourceDbPtr
 
cool::IDatabasePtr m_destDbPtr
 
CoraCoolDatabasePtr m_sourceCoraPtr
 
CoraCoolDatabasePtr m_destCoraPtr
 
std::vector< std::string > m_folderlist
 
std::vector< std::string > m_folderexcl
 
std::vector< std::string > m_tags
 
std::vector< std::string > m_magic
 
std::vector< std::string > m_poolcat
 
std::vector< std::string > m_mergecat
 
bool m_open
 
cool::ChannelSelection m_chansel
 
PoolMap::iterator m_poollast
 
PoolMap m_poolrefs
 
HiTagMap m_hitagmap
 
std::vector< std::string > m_hiparent
 
CoolTagMap m_cooltagmap
 
TFile * p_rootfile
 
ULong64_t m_nt_since = 0
 
ULong64_t m_nt_until = 0
 
UInt_t m_nt_runsince = 0
 
UInt_t m_nt_rununtil = 0
 
UInt_t m_nt_lbsince = 0
 
UInt_t m_nt_lbuntil = 0
 
UInt_t m_nt_channel = 0
 
char m_nt_tagid [256] = {0}
 
std::string m_nt_treename
 
std::vector< void * > m_nt_bufferptr
 

Detailed Description

Definition at line 80 of file AtlCoolCopy.cxx.

Member Typedef Documentation

◆ CoolTagMap

using AtlCoolCopy::CoolTagMap = std::map<std::string, CoolTagInfo>
private

Definition at line 278 of file AtlCoolCopy.cxx.

◆ HiTagMap

using AtlCoolCopy::HiTagMap = std::map<std::string, std::string>
private

Definition at line 272 of file AtlCoolCopy.cxx.

◆ PoolMap

typedef std::map<std::string,PoolMapElement> AtlCoolCopy::PoolMap
private

Definition at line 268 of file AtlCoolCopy.cxx.

Constructor & Destructor Documentation

◆ AtlCoolCopy()

AtlCoolCopy::AtlCoolCopy ( const std::string &  sourcedb,
const std::string &  destdb,
bool  allowcreate = false 
)

Definition at line 300 of file AtlCoolCopy.cxx.

301  :
302  m_sourcedb(sourcedb),m_destdb(destdb),m_allowcreate(allowcreate),
303  m_recreate(false),
304  m_includehead(false),m_excludehead(false),
305  m_usertags(true),m_userupdatehead(false),m_debug(false),m_alliov(false),
306  m_verify(false),m_root(false),m_zeronull(false),m_analyse(false),
307  m_checkrefs(false),m_listpfn(false),m_poolopen(false),m_poolall(false),
308  m_nocopy(false),m_nodata(false),m_nochannel(false),m_chdesc(false),
309  m_hitag(false),m_nohitag(false),m_forcesingle(false),m_forcemulti(false),
310  m_forcerune(false),m_forcetime(false),m_forcepay(false),m_forcenopay(false),
311  m_sourceread(true),m_truncate(false),m_skipout(false),m_skiprep(false),
312  m_applock(false),m_applocksv(false),
313  m_readoracle(false),m_gettime(false),m_getonline(false),m_onlinerun(false),
314  m_getbulk(false),
315  m_prunetags(false),m_lockedonly(false),m_copytaginfo(false),
316  m_copytaglock(false),m_coracool(true),m_ignoremode(false),
317  m_ignorespec(false),m_checkdesttag(false),m_noclobroot(false),
318  m_runemin(cool::ValidityKeyMin),m_runemax(cool::ValidityKeyMax),
319  m_timemin(cool::ValidityKeyMin),m_timemax(cool::ValidityKeyMax),
320  m_newrunemin(cool::ValidityKeyMin),m_newrunemax(cool::ValidityKeyMax),
321  m_newtimemin(cool::ValidityKeyMin),m_newtimemax(cool::ValidityKeyMax),
322  m_srunemin(cool::ValidityKeyMin),m_srunemax(cool::ValidityKeyMax),
323  m_channel1(""),m_channel2(""),m_bufsize(1000),m_sealmsg(5),
324  m_anadelt(-1),m_outfolder(""),m_outtag(""),m_newdataset(""),
326  m_runinfohost("http://atlas-run-info-api.web.cern.ch/api"),
328  m_dbSvc(&(m_coolapp.databaseService())),m_repsort(nullptr),
330 {
331  m_poolrefs.clear();
332  m_poollast=m_poolrefs.end();
333  // configure CORAL components
334  coral::IConnectionServiceConfiguration& csconfig=m_coralsvc.configuration();
335  csconfig.disablePoolAutomaticCleanUp();
336  csconfig.setConnectionTimeOut(0);
337 }

Member Function Documentation

◆ addExclude()

bool AtlCoolCopy::addExclude ( const std::string &  folder)

Definition at line 528 of file AtlCoolCopy.cxx.

528  {
529  std::cout << "Adding folder to exclude list: " << folder << std::endl;
530  m_folderexcl.push_back(folder);
531  return true;
532 }

◆ addFolder()

bool AtlCoolCopy::addFolder ( const std::string &  folder,
const bool  onlyTags 
)

Definition at line 460 of file AtlCoolCopy.cxx.

460  {
461  std::cout << "Add folders in path:" << folder << " [ ";
462  const std::vector<std::string> nodelist=m_sourceDbPtr->listAllNodes();
463  // find all matching leaf folders
464  for (std::vector<std::string>::const_iterator nodeitr=nodelist.begin();
465  nodeitr!=nodelist.end();++nodeitr) {
466  // match exact folder name or leading part of path
467  // for leading part matches, next char in folder name must be '/'
468  // so /CALO/SetA matches /CALO/SetA/X but not /CALO/SetAB
469  if (*nodeitr==folder || folder=="/" ||
470  (nodeitr->compare(0,folder.size(),folder)==0 &&
471  nodeitr->size()>folder.size() && nodeitr->compare(folder.size(),1,"/")==0)) {
472  // check if folder on exclude list
473  bool exclude=false;
474  for (std::vector<std::string>::const_iterator iexcl=m_folderexcl.begin();
475  iexcl!=m_folderexcl.end();++iexcl) {
476  if (iexcl->compare(0,1,"/")==0) {
477  // exclude pattern starting / matches folder path (/SCT or /SCT/DCS)
478  exclude=(exclude || nodeitr->compare(0,iexcl->size(),*iexcl)==0);
479  } else {
480  // exclude pattern without leading / matches anywhere in folder
481  exclude=(exclude || (nodeitr->find(*iexcl)!=std::string::npos));
482  }
483  }
484  // check folder exists (is a leaf folder), and not excluded
485  if (m_sourceDbPtr->existsFolder(*nodeitr) && !exclude && !onlyTags) {
486  // only add if folder not already on list
487  if (find(m_folderlist.begin(),m_folderlist.end(),*nodeitr)==
488  m_folderlist.end()) {
489  std::cout << *nodeitr << " ";
490  m_folderlist.push_back(*nodeitr);
491  }
492  }
493  // if its a folderset, check for any hierarchical tags
494  if (!m_nohitag && m_sourceDbPtr->existsFolderSet(*nodeitr) && !exclude) {
495  if (!m_prunetags) {
496  const std::vector<std::string> foldersettags=
497  m_sourceDbPtr->getFolderSet(*nodeitr)->listTags();
498  if (!foldersettags.empty()) {
499  for (std::vector<std::string>::const_iterator
500  itr=foldersettags.begin();itr!=foldersettags.end();++itr) {
501  m_hitagmap[*itr]=*nodeitr;
502  }
503  }
504  } else {
505  // only take tags in this folder which are referenced from one of
506  // the input tags (assumed to be top-level tags)
507  cool::IFolderSetPtr sfolder=m_sourceDbPtr->getFolderSet(*nodeitr);
508  for (std::vector<std::string>::const_iterator toptag=m_tags.begin();
509  toptag!=m_tags.end();++toptag) {
510  try {
511  std::string rtag=sfolder->resolveTag(*toptag);
512  m_hitagmap[rtag]=*nodeitr;
513  }
514  // catch exceptions indicating tag defines nothing here
515  // note std::exception rather than COOL exception to cover case
516  // when trying to resolve a leaf tag in the '/' folder, which
517  // throws a coral AttributeException
518  catch (std::exception& e) {}
519  }
520  }
521  }
522  }
523  }
524  std::cout << "]" << std::endl;
525  return true;
526 }

◆ adjustIOVs()

void AtlCoolCopy::adjustIOVs ( const cool::ValidityKey &  since,
const cool::ValidityKey &  until,
const cool::ValidityKey &  qsince,
const cool::ValidityKey &  quntil,
cool::ValidityKey &  newsince,
cool::ValidityKey &  newuntil,
const bool  timestamp 
) const
private

Definition at line 1290 of file AtlCoolCopy.cxx.

1296  {
1297  // set newsince/until to since/until
1298  // but doing any required truncation/adjustment
1299  newsince=since;
1300  newuntil=until;
1301  if (m_alliov) {
1302  // make IOV cover specified range
1303  if (timestamp) {
1304  newsince=m_newtimemin;
1305  newuntil=m_newtimemax;
1306  } else {
1307  newsince=m_newrunemin;
1308  newuntil=m_newrunemax;
1309  }
1310  }
1311  // check for IOV truncation to range of query
1312  if (m_truncate) {
1313  if (newsince<qsince) newsince=qsince;
1314  if (newuntil>quntil) newuntil=quntil;
1315  }
1316  // check not requesting an IOV with negative length
1317  if (newuntil<newsince) throw cool::Exception(
1318  "Attempt to insert IOV with -ve length","AtlCoolCopy::adjustIOVs");
1319 }

◆ analyseIOVs()

int AtlCoolCopy::analyseIOVs ( const std::string &  folder,
const cool::IFolderPtr &  sourcefl,
const std::string &  sourcetag,
const cool::ValidityKey  since,
const cool::ValidityKey  until,
const bool  timestamp 
)
private

Definition at line 1857 of file AtlCoolCopy.cxx.

1860  {
1861  // analyse the IOV and channel structure of this folder/tag, make ROOT histos
1862  std::cout << "Analyse tag " << sourcetag << " of folder " << folder <<
1863  std::endl;
1864  bool anatime=(m_anadelt>=0);
1865  if (anatime) {
1866  std::cout << "Analyse time structures with tolerance of " <<
1867  m_anadelt/1.E9 << " seconds " << std::endl;
1868  }
1869  // create COOLANA/folder structure and create leaf directory for histograms
1870  std::string dirname=rootDirs(folder,"COOLANA");
1871  if (gDirectory->FindObject(dirname.c_str())==nullptr) {
1872  std::cout << "Make directory " << dirname << std::endl;
1873  gDirectory->mkdir(dirname.c_str());
1874  }
1875  gDirectory->cd(dirname.c_str());
1876  // get channels
1877  std::vector<cool::ChannelId> channels=sourcefl->listChannels();
1878  unsigned int nchan=channels.size();
1879  // end of last IOV seen on this channel
1880  long long* lastiov=new long long[nchan];
1881  long long* iovtotlen=new long long[nchan];
1882  long long* iovtotgap=new long long[nchan];
1883  int* iovn=new int[nchan];
1884  for (unsigned int i=0;i<nchan;++i) {
1885  lastiov[i]=-1; // no IOV seen on this channel yet
1886  iovtotlen[i]=0;
1887  iovtotgap[i]=0;
1888  iovn[i]=0;
1889  }
1890  cool::ValidityKey globsince=cool::ValidityKeyMax;
1891  cool::ValidityKey globuntil=cool::ValidityKeyMin;
1892 
1893  // book histograms - only if the objects do not already exist (previous tag)
1894  TH1F* h_iovchan=bookOrFindTH1F("IOVSperChannel","IOVs per channel",
1895  nchan,-0.5,nchan-0.5);
1896  TH1F* h_iovname=bookOrFindTH1F("IOVSperChannelName",
1897  "IOVs per channel-name (copy of IOVSperChannel)",
1898  nchan,-0.5,nchan-0.5);
1899  TH1F* h_iovlength=bookOrFindTH1F("IOVLogLength","IOV log10 length",
1900  100,0.,20.);
1901  TH1F* h_iovgap=bookOrFindTH1F("IOVLogGapLength","IOV log10 gap length",
1902  100,0.,20.);
1903  // histograms for time analysis if needed
1904  TH1F* h_anadelt=nullptr;
1905  TH1F* h_chandelt=nullptr;
1906  if (anatime) {
1907  h_anadelt=bookOrFindTH1F("IOVAlignLogDelT","IOV alignment log deltaT",
1908  100,0.,20.);
1909  // add factor 2 in number of channels, to catch those where a channel
1910  // changes many times within the m_anadelt window (i.e. noise/jitter)
1911  h_chandelt=bookOrFindTH1F("AlignedChanPerIOV","Aligned channels per IOV",
1912  nchan*2,0.5,nchan*2-0.5);
1913  }
1914  std::cout << "Booked histograms for folder with " << nchan << " channels"
1915  << std::endl;
1916  // setup storage for IOV time analysis
1917  using IOVTimeMap = std::map<cool::ValidityKey, int>;
1918  IOVTimeMap iov_time_map;
1919 
1920  // setup iterator to loop over objects
1921  int nobj=0;
1922  cool::FolderVersioning::Mode vermode=sourcefl->versioningMode();
1923  cool::IObjectIteratorPtr sourceitr;
1924  try {
1925  if (vermode==cool::FolderVersioning::SINGLE_VERSION) {
1926  sourceitr=sourcefl->browseObjects(since,until,m_chansel);
1927  } else {
1928  sourceitr=sourcefl->browseObjects(since,until,m_chansel,sourcetag);
1929  }
1930  }
1931  catch (cool::Exception& e) {
1932  std::cout << "Exception thrown from analysis copy iterator setup: " <<
1933  e.what() << std::endl;
1934  return 135;
1935  }
1936  // look up names of all the channels in one go
1937  std::map<cool::ChannelId,std::string>
1938  chanmap=sourcefl->listChannelsWithNames();
1939  // now loop over all IOVs and write them
1940  try {
1941  while (sourceitr->goToNext()) {
1942  const cool::IObject& sobj=sourceitr->currentRef();
1943  // get channel and find its index
1944  cool::ChannelId ichanid=sobj.channelId();
1945  const std::string& cname=chanmap[ichanid];
1948  std::equal_range(channels.begin(),channels.end(),ichanid);
1949  if (chanitr.first!=chanitr.second) {
1950  cool::ChannelId ichan=std::distance(channels.begin(),chanitr.first);
1951  Int_t bin=h_iovchan->Fill(ichan);
1952  if (ichan && !h_iovname->GetBinContent(bin)) {
1953  h_iovname->GetXaxis()->SetBinLabel(bin,cname.c_str());
1954  }
1955  h_iovname->Fill(ichan);
1956  // analyse IOV start/stop
1957  cool::ValidityKey since2=sobj.since();
1958  cool::ValidityKey until2=sobj.until();
1959  if (since2<globsince) globsince=since2;
1960  // dont count IOV is open-ended, so length statistics will make sense
1961  if (until2!=cool::ValidityKeyMax) {
1962  if (until2>globuntil) globuntil=until2;
1963  long long len=until2-since2;
1964  h_iovlength->Fill(log10(len));
1965  iovn[ichan]+=1;
1966  iovtotlen[ichan]+=len;
1967  }
1968  if (lastiov[ichan]<static_cast<long long>(since2) &&
1969  lastiov[ichan]>=0) {
1970  // have a gap in the IOV structure for this channel
1971  long long gap=since2-lastiov[ichan];
1972  iovtotgap[ichan]+=gap;
1973  h_iovgap->Fill(log10(gap));
1974  std::cout << "Gap of " << gap << std::endl;
1975  }
1976  if (until2!=cool::ValidityKeyMax) {
1977  lastiov[ichan]=until2;
1978  } else {
1979  lastiov[ichan]=since2;
1980  }
1981  // analyse IOV alignment
1982  if (anatime) {
1983  long long del1=-1;
1984  long long del2=-1;
1985  // find the nearest time to this one
1986  // this gives the first value exceeding since2
1987  IOVTimeMap::iterator hiitr=iov_time_map.lower_bound(since2);
1988  IOVTimeMap::iterator lowitr=hiitr;
1989  if (hiitr!=iov_time_map.end()) {
1990  // del1 is +ve time interval to next one
1991  del1=hiitr->first-since2;
1992  }
1993  if (lowitr!=iov_time_map.begin()) {
1994  // del2 is +ve time interval to previous one
1995  --lowitr;
1996  del2=since2-lowitr->first;
1997  }
1998  long long del=-1;
1999  IOVTimeMap::iterator moditr;
2000  bool domod=false;
2001  if (del1<=m_anadelt && del1>-1) {
2002  moditr=hiitr;
2003  del=del1;
2004  domod=true;
2005  }
2006  if (del2<=m_anadelt && del2>-1 && (del2<del || del==-1)) {
2007  moditr=lowitr;
2008  del=del2;
2009  domod=true;
2010  }
2011  if (domod) {
2012  ++(moditr->second);
2013  if (del>0) {
2014  h_anadelt->Fill(log10(del));
2015  } else {
2016  h_anadelt->Fill(0.);
2017  }
2018  } else {
2019  iov_time_map[since2]=0;
2020  }
2021  }
2022  } else {
2023  // channel ID not found
2024  std::cout << "ERROR :Channel " << ichanid <<
2025  " not found in channel list - ignored" << std::endl;
2026  }
2027  ++nobj;
2028  }
2029  std::cout << "Finished analysis with " << nobj << " objects" << std::endl;
2030  if (timestamp) {
2031  std::cout << "IOV timestamp range: " << globsince << " " <<
2032  timeString(globsince) << "to " << globuntil << " " <<
2033  timeString(globuntil) << std::endl;
2034  } else {
2035  std::cout << "IOV run/LB range [" << (globsince >> 32) << "," <<
2036  (globsince & 0xFFFFFFFF) << "] to [" << (globuntil >> 32) << "," <<
2037  (globuntil & 0xFFFFFFFF) << "]" << std::endl;
2038  }
2039  // calculate statistics for each channel
2040  TH1F* h_iovoccchan=bookOrFindTH1F("ChannelOcc","Channel Occupancy",
2041  nchan,-0.5,nchan-0.5);
2042  TH1F* h_iovlenchan=bookOrFindTH1F("IOVLenChan",
2043  "Mean IOV length per channel",nchan,-0.5,nchan-0.5);
2044  for (unsigned int i=0;i<nchan;++i) {
2045  float occ=0.;
2046  float avlen=0.;
2047  if (iovn[i]>0) {
2048  occ=1.-float(iovtotgap[i])/float(iovtotlen[i]+iovtotgap[i]);
2049  avlen=float(iovtotlen[i])/iovn[i];
2050  }
2051  h_iovoccchan->Fill(i,occ);
2052  h_iovlenchan->Fill(i,avlen);
2053  }
2054  if (anatime) {
2055  std::cout << "Alignment analysis: " << iov_time_map.size()
2056  << " seperate IOV starts (tolerance " << m_anadelt/1.E9 <<
2057  " seconds)" << std::endl;
2058  // fill histogram of number of channels incremented per IOV
2059  for (IOVTimeMap::const_iterator itr=iov_time_map.begin();
2060  itr!=iov_time_map.end();++itr) {
2061  h_chandelt->Fill(itr->second);
2062  }
2063  }
2064  }
2065  catch (cool::Exception& e) {
2066  std::cout << "Exception thrown from folder analysis reading loop: " <<
2067  e.what() << std::endl;
2068  return 134;
2069  }
2070  sourceitr->close();
2071  delete [] lastiov;
2072  delete [] iovtotlen;
2073  delete [] iovtotgap;
2074  delete[] iovn; iovn=nullptr;
2075  return 0;
2076 }

◆ ATLAS_NOT_THREAD_SAFE() [1/4]

int doCopy AtlCoolCopy::ATLAS_NOT_THREAD_SAFE ( )

◆ ATLAS_NOT_THREAD_SAFE() [2/4]

int resolvePoolRefs AtlCoolCopy::ATLAS_NOT_THREAD_SAFE ( )
private

◆ ATLAS_NOT_THREAD_SAFE() [3/4]

int copyIOVs AtlCoolCopy::ATLAS_NOT_THREAD_SAFE ( const std::string &  folder,
const std::string &  destfolder,
const cool::IFolderPtr &  sourcefl,
const CoraCoolFolderPtr sourceflc,
const cool::IFolderPtr &  destfl,
const CoraCoolFolderPtr destflc,
const std::string &  sourcetag,
const std::string &  desttag,
const cool::ValidityKey  since,
const cool::ValidityKey  until,
bool  timestamp,
bool  checkrefs,
bool  iscora,
const cool::PayloadMode::Mode  paymode,
bool  created 
)
private

◆ ATLAS_NOT_THREAD_SAFE() [4/4]

int copyFolder AtlCoolCopy::ATLAS_NOT_THREAD_SAFE ( const std::string &  folder,
const std::vector< std::string > &  taglist 
)

◆ bookOrFindTH1F()

TH1F * AtlCoolCopy::bookOrFindTH1F ( const std::string &  hID,
const std::string &  htitle,
const int  chan,
const float  xlow,
const float  xhigh 
)
staticprivate

Definition at line 2078 of file AtlCoolCopy.cxx.

2080  {
2081  // check histogram does not exist in current directory
2082  // if yes, return pointer to it, else book and return pointer
2083  TObject* obj=gDirectory->FindObject(hID.c_str());
2084  if (obj==nullptr) {
2085  return new TH1F(hID.c_str(),htitle.c_str(),nchan,xlow,xhigh);
2086  } else {
2087  return static_cast<TH1F*>(obj);
2088  }
2089 }

◆ channelID()

cool::ChannelId AtlCoolCopy::channelID ( const cool::IFolderPtr &  folder,
const std::string &  chanstring 
)
staticprivate

Definition at line 855 of file AtlCoolCopy.cxx.

856  {
857  const char* cstr=chanstring.c_str();
858  if (isNumeric(cstr)) {
859  // channel is a number
860  return cool::ChannelId(strtoul(cstr,nullptr,10));
861  } else {
862  cool::ChannelId chan=0;
863  try {
864  chan=folder->channelId(chanstring);
865  std::cout << "Channel name " << chanstring << " maps to channelID "
866  << chan << std::endl;
867  }
868  catch (cool::Exception& e) {
869  std::cout << "ERROR: Channel name " << chanstring <<
870  " not defined in folder " << std::endl;
871  }
872  return chan;
873  }
874 }

◆ checkChannels()

bool AtlCoolCopy::checkChannels ( const std::string &  folder,
const cool::IFolderPtr &  sourcefl,
const cool::IFolderPtr &  destfl,
bool  newfolder 
)
private

Definition at line 2921 of file AtlCoolCopy.cxx.

2923  {
2924  // Channel manipulation is slow due to lack of bulk API for creating them
2925  // this routine therefore does the minimum work, not checking destination
2926  // if folder is newly created, and not copying description unless requested
2927  // get map of all channels
2928  const std::map<cool::ChannelId,std::string> chanmap=
2929  sourcefl->listChannelsWithNames();
2930  if (m_debug) std::cout << "Checking channels table for folder " << folder
2931  << " with " << chanmap.size() << " channels" << std::endl;
2932  int ncreate=0;
2933  int nmodify=0;
2934  // iterate over all channels
2935  for (std::map<cool::ChannelId,std::string>::const_iterator
2936  itr=chanmap.begin();itr!=chanmap.end();++itr) {
2937  // assume now ALL channels are in channels table (COOL 2.4 and above)
2938  const cool::ChannelId chan=itr->first;
2939  // check if channel should be skipped
2940  if (!m_excludechans.empty()) {
2941  if (find(m_excludechans.begin(),m_excludechans.end(),
2942  chan)!=m_excludechans.end()) continue;
2943  }
2944  if (!m_chansel.inSelection(chan)) continue;
2945 
2946  const std::string& sourcename=itr->second;
2947  // only look up channel description if we are copying it
2948  std::string sourcedesc="";
2949  if (m_chdesc) sourcedesc=sourcefl->channelDescription(chan);
2950  // only check destination if folder alreay existed
2951  if (!newfolder && destfl->existsChannel(chan)) {
2952  const std::string & destname=destfl->channelName(chan);
2953  std::string destdesc="";
2954  if (m_chdesc) destdesc=destfl->channelDescription(chan);
2955  // if sourcename is not set, and destination is, dont worry
2956  if (sourcename!=destname && !sourcename.empty()) {
2957  // channel names differ - error if verifying, set if copying
2958  if (m_verify) {
2959  std::cout << "ERROR: Channel " << chan << " names differ: " <<
2960  sourcename << " " << destname << std::endl;
2961  return false;
2962  }
2963  destfl->setChannelName(chan,sourcename);
2964  std::cout << "Modify channel " << chan << " name from "
2965  << destname << " to " << sourcename << std::endl;
2966  ++nmodify;
2967  }
2968  if (sourcedesc!=destdesc && !sourcedesc.empty()) {
2969  // channel descriptions differ - error if verifying, set if copying
2970  if (m_verify) {
2971  std::cout << "ERROR: Channel " << chan << " descriptions differ: "
2972  << sourcedesc << " " << destdesc << std::endl;
2973  return false;
2974  }
2975  std::cout << "Modify channel " << chan << " description from "
2976  << sourcedesc << " to " << destdesc << std::endl;
2977  destfl->setChannelDescription(chan,sourcedesc);
2978  ++nmodify;
2979  }
2980  } else {
2981  // channel does not exist on destination - if verifying, this is error
2982  if (m_verify) return false;
2983  // otherwise create it
2984  if (m_debug) std::cout << "Create new channel " << chan << " name "
2985  << sourcename << " description" << sourcedesc << std::endl;
2986  destfl->createChannel(chan,sourcename,sourcedesc);
2987  ++ncreate;
2988  }
2989  }
2990  if (ncreate>0) std::cout << "Created " << ncreate << " new channels for "
2991  << folder << std::endl;
2992  if (nmodify>0) std::cout << "Modified " << nmodify << " channel info for "
2993  << folder << std::endl;
2994  return true;
2995 }

◆ checkRef()

void AtlCoolCopy::checkRef ( const cool::IRecord &  payload,
const std::string &  folder,
const std::string &  tag 
)
private

Definition at line 2998 of file AtlCoolCopy.cxx.

2999  {
3000  const std::string name=payload[0].name();
3001  if (name=="PoolRef" || name=="fileGUID") {
3002  std::string poolref;
3003  std::string addr=payload[0].data<std::string>();
3004  if (name=="PoolRef") {
3005  std::string::size_type iofs1=addr.find("[DB=");
3006  std::string::size_type iofs2=addr.find(']',iofs1);
3007  if (iofs1!=std::string::npos && iofs2!=std::string::npos && iofs2>iofs1) {
3008  poolref=addr.substr(iofs1+4,iofs2-iofs1-4);
3009  } else {
3010  std::cout << "ERROR: Badly formed POOL object reference " <<
3011  addr << std::endl;
3012  }
3013  } else {
3014  // for fileGUID, POOL GUID is just the string
3015  poolref=addr;
3016  }
3017  std::string foldertag=folder+":"+tag;
3018  // insert into list, first check if same as before
3019  if (m_poollast!=m_poolrefs.end() && m_poollast->first==poolref) {
3020  m_poollast->second.inccount();
3021  m_poollast->second.addfoldertag(foldertag);
3022  } else {
3023  m_poollast=m_poolrefs.find(poolref);
3024  if (m_poollast!=m_poolrefs.end()) {
3025  m_poollast->second.inccount();
3026  m_poollast->second.addfoldertag(foldertag);
3027  } else {
3028  m_poolrefs[poolref]=PoolMapElement(1,foldertag);
3029  m_poollast=m_poolrefs.find(poolref);
3030  }
3031  }
3032  }
3033 }

◆ equalRecord()

bool AtlCoolCopy::equalRecord ( const cool::IRecord &  lhs,
const cool::IRecord &  rhs 
)
staticprivate

Definition at line 2509 of file AtlCoolCopy.cxx.

2510  {
2511  // equality test for COOL IRecords, handling NULL string attributes correctly
2512  // tests values and types of Attributes, not names
2513  if (lhs.size()!=rhs.size()) return false;
2514  for (size_t i=0;i<lhs.size();++i) {
2515  // types must match - have to test explicitly first
2516  if (lhs[i].specification().storageType()!=
2517  rhs[i].specification().storageType())
2518  return false;
2519  // now use IField equality to for final test (spec again and data)
2520  if (lhs[i]!=rhs[i]) {
2521  // if not equal, check for special case of strings and compare directly
2522  // types are known to be equal so only test LHS
2523  const cool::StorageType& stype=lhs[i].specification().storageType();
2524  if (stype==cool::StorageType::String255 ||
2525  stype==cool::StorageType::String4k ||
2526  stype==cool::StorageType::String64k ||
2527  stype==cool::StorageType::String16M) {
2528  // check if string data payloads are really equal or not
2529  if (lhs[i].data<std::string>()!=rhs[i].data<std::string>())
2530  return false;
2531  } else {
2532  // if not string, trust the result of IField !=operator
2533  return false;
2534  }
2535  }
2536  }
2537  return true;
2538 }

◆ filePoolRefs()

void AtlCoolCopy::filePoolRefs ( )
private

Definition at line 3282 of file AtlCoolCopy.cxx.

3282  {
3283  // list POOL refs and error codes, optionally to file
3284  if (!m_checkoutputfile.empty()) {
3285  std::cout << "Write POOL file checkoutput on " << m_checkoutputfile <<
3286  std::endl;
3287  } else {
3288  m_checkoutputfile="/dev/null";
3289  }
3290  std::ofstream chkostream(m_checkoutputfile.c_str());
3291  std::cout << "ErrCode GUID Count LFN PFN Folders ..." << std::endl;
3292  for (PoolMap::const_iterator ipool=m_poolrefs.begin();
3293  ipool!=m_poolrefs.end();++ipool) {
3294  if (m_poolall || ipool->second.errcode()>0) {
3295  std::ostringstream line;
3296  // write error code, GUID, usage count
3297  line << ipool->second.errcode() << " " << ipool->first << " " <<
3298  ipool->second.count() << " ";
3299  if (!ipool->second.lfn().empty()) {
3300  line << ipool->second.lfn() << " ";
3301  } else {
3302  line << "noLFN ";
3303  }
3304  if (!ipool->second.pfn().empty()) {
3305  line << ipool->second.pfn() << " ";
3306  } else {
3307  line << "noPFN ";
3308  }
3309  for (std::vector<std::string>::const_iterator
3310  itr=ipool->second.foldertag().begin();
3311  itr!=ipool->second.foldertag().end();++itr)
3312  line << *itr << " ";
3313  std::cout << line.str() << std::endl;
3314  chkostream << line.str() << std::endl;
3315  }
3316  }
3317 }

◆ getBulkRun()

bool AtlCoolCopy::getBulkRun ( )
private

Definition at line 2781 of file AtlCoolCopy.cxx.

2781  {
2782  // get minimum run-number/timestamp for bulk reco update
2783  if (m_getonline) {
2784  std::cout << "ERROR: -getonline and -getbulk cannot be used simultaneously"
2785  << std::endl;
2786  return false;
2787  }
2788  std::cout << "Call getbulk using URL" << std::endl;
2789  // Initialize libcurl
2790  curl_global_init(CURL_GLOBAL_ALL);
2791  using uniqueCurl_t = std::unique_ptr<CURL,decltype(&curl_easy_cleanup)>;
2792  uniqueCurl_t curl(curl_easy_init(), curl_easy_cleanup);
2793  //CURL *curl = curl_easy_init();
2794  CURLcode res = CURLE_OK;
2795 
2796  if (curl) {
2797  std::string url = m_runinfohost + "/runs/nemop/sync";
2798  // Set the URL
2799  res = curl_easy_setopt(curl.get(), CURLOPT_URL, url.c_str());
2800  if (res != CURLE_OK) {
2801  std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2802  return false;
2803  }
2804  // Follow HTTP redirections
2805  res = curl_easy_setopt(curl.get(), CURLOPT_FOLLOWLOCATION, 1L);
2806  if (res != CURLE_OK) {
2807  std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2808  return false;
2809  }
2810  // Response data buffer
2811  std::string response;
2812 
2813  // Set the callback function to receive response data
2814  res = curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, WriteCallback);
2815  if (res != CURLE_OK) {
2816  std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2817  return false;
2818  }
2819  res = curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &response);
2820  if (res != CURLE_OK) {
2821  std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2822  return false;
2823  }
2824  // Perform the request
2825  res = curl_easy_perform(curl.get());
2826  if (res != CURLE_OK) {
2827  std::cerr << "Failed to perform request: " << curl_easy_strerror(res) << ":" << url.c_str() << std::endl;
2828  return false;
2829  } else {
2830  // Print the received response
2831  std::cout << "Response: " << std::endl;
2832  std::cout << response << std::endl;
2833  try {
2834  // Split the response into two fields
2836  // Extract the run and timestamp fields
2837  int nextrun = jsonData["run"];
2838  long long rtime = jsonData["timestamp"];
2839  std::cout << "Next run started will be " << nextrun << std::endl;
2840  std::cout << "Epoch time extracted " << rtime << std::endl;
2841  if (m_alliov) {
2842  // if overwriting IOVs, set the new IOV lower limit
2843  m_newrunemin=(static_cast<long long>(nextrun)) << 32;
2844  m_newtimemin=rtime*static_cast<long long>(1E9);
2845  } else {
2846  // set the query lower limit - for use with truncate option
2847  m_runemin=(static_cast<long long>(nextrun)) << 32;
2848  m_timemin=rtime*static_cast<long long>(1E9);
2849  m_truncate=true;
2850  }
2851  } catch (nlohmann::json::parse_error& e) {
2852  std::cerr << "Failed to parse JSON response: " << e.what() << std::endl;
2853  return false;
2854  } catch (nlohmann::json::type_error& e) {
2855  std::cerr << "Failed to extract data from JSON response: " << e.what() << std::endl;
2856  return false;
2857  } catch (std::exception& e) {
2858  std::cerr << "Failed to extract run and timestamp from JSON response: " << e.what() << std::endl;
2859  return false;
2860  }
2861  }
2862  // Clean up done by unique_ptr
2863  } else {
2864  std::cerr << "Failed to initialize libcurl." << std::endl;
2865  return false;
2866  }
2867  // Cleanup libcurl
2868  curl_global_cleanup();
2869 
2870  return true;
2871 }

◆ getCoolHistGUID()

std::string AtlCoolCopy::getCoolHistGUID ( const std::string &  file)
staticprivate

Definition at line 3266 of file AtlCoolCopy.cxx.

3266  {
3267  // attempt to extract COOL Hist GUID from file
3268  std::string hguid="";
3269  TFile* myfile=TFile::Open(file.c_str(),"READ");
3270  if (myfile!=nullptr) {
3271  TObjString* oguid;
3272  myfile->GetObject("fileGUID",oguid);
3273  if (oguid!=nullptr) {
3274  hguid=oguid->GetString();
3275  std::cout << "CoolHist GUID found to be " << hguid << std::endl;
3276  }
3277  myfile->Close();
3278  }
3279  return hguid;
3280 }

◆ getLockedTags()

bool AtlCoolCopy::getLockedTags ( )
private

Definition at line 429 of file AtlCoolCopy.cxx.

429  {
430  // set m_tags to list of top level tags which are locked
431  m_tags.clear();
432  cool::IFolderSetPtr topfolder=m_sourceDbPtr->getFolderSet("/");
433  const std::vector<std::string>& toptaglist=topfolder->listTags();
434  for (std::vector<std::string>::const_iterator toptag=toptaglist.begin();
435  toptag!=toptaglist.end();++toptag) {
436  cool::HvsTagLock::Status tstat=topfolder->tagLockStatus(*toptag);
437  if (tstat==cool::HvsTagLock::LOCKED ||
438  tstat==cool::HvsTagLock::PARTIALLYLOCKED) {
439  std::cout << "Top-level tag " << *toptag << " will be copied" <<
440  std::endl;
441  m_tags.push_back(*toptag);
442  }
443  }
444  std::cout << "Total of " << m_tags.size() << " top-level tags to be copied"
445  << std::endl;
446  return (!m_tags.empty());
447 }

◆ getOnlineRun()

bool AtlCoolCopy::getOnlineRun ( )
private

Definition at line 2693 of file AtlCoolCopy.cxx.

2693  {
2694  // open using the ATLAS_COOLONL_GLOBAL schema, since we have authentication
2695  // information for this one by default
2696  // get minimum run-number/timestamp for bulk reco update
2697  std::cout << "Extracting current run-number from ATLAS_RUN_NUMBER @ ATONR_ADG ... " <<
2698  // Initialize libcurl
2699  curl_global_init(CURL_GLOBAL_ALL);
2700  using uniqueCurl_t = std::unique_ptr<CURL,decltype(&curl_easy_cleanup)>;
2701  uniqueCurl_t curl(curl_easy_init(), curl_easy_cleanup);
2702  CURLcode res = CURLE_OK;
2703  if (curl) {
2704  std::string url = m_runinfohost + "/runs?sort=runnumber:DESC&size=1";
2705  // Set the URL
2706  res = curl_easy_setopt(curl.get(), CURLOPT_URL, url.c_str());
2707  if (res != CURLE_OK) {
2708  std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2709  return false;
2710  }
2711  // Follow HTTP redirections
2712  res = curl_easy_setopt(curl.get(), CURLOPT_FOLLOWLOCATION, 1L);
2713  if (res != CURLE_OK) {
2714  std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2715  return false;
2716  }
2717  // Response data buffer
2718  std::string response;
2719 
2720  // Set the callback function to receive response data
2721  res = curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, WriteCallback);
2722  if (res != CURLE_OK) {
2723  std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2724  return false;
2725  }
2726  res = curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &response);
2727  if (res != CURLE_OK) {
2728  std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2729  return false;
2730  }
2731 
2732  // Perform the request
2733  res = curl_easy_perform(curl.get());
2734  if (res != CURLE_OK) {
2735  std::cerr << "Failed to perform request: " << curl_easy_strerror(res) << ":" << url.c_str() << std::endl;
2736  return false;
2737  } else {
2738  // Print the received response
2739  std::cout << "Response: " << std::endl;
2740  std::cout << response << std::endl;
2741  // Parse the JSON string
2742  try {
2744 
2745  // Extract the runnumber field
2746  int runNumber = jsonData["resources"][0]["runnumber"];
2747  int nextrun=runNumber+1;
2748  std::cout << "Next run started will be " << nextrun << std::endl;
2749  const long long rtime=time(nullptr);
2750  std::cout << "Epoch time extracted " << rtime << std::endl;
2751  if (m_alliov) {
2752  // if overwriting IOVs, set the new IOV lower limit
2753  m_newrunemin=(static_cast<long long>(nextrun)) << 32;
2754  m_newtimemin=rtime*static_cast<long long>(1E9);
2755  } else {
2756  // set the query lower limit - for use with truncate option
2757  m_runemin=(static_cast<long long>(nextrun)) << 32;
2758  m_timemin=rtime*static_cast<long long>(1E9);
2759  m_truncate=true;
2760  }
2761  } catch (nlohmann::json::parse_error& e) {
2762  std::cerr << "Failed to parse JSON response: " << e.what() << std::endl;
2763  return false;
2764  } catch (nlohmann::json::type_error& e) {
2765  std::cerr << "Failed to extract data from JSON response: " << e.what() << std::endl;
2766  return false;
2767  } catch (std::exception& e) {
2768  std::cerr << "Failed to extract run and timestamp from JSON response: " << e.what() << std::endl;
2769  return false;
2770  }
2771  }
2772  // Clean up done by unique_ptr d'tor
2773  } else {
2774  std::cerr << "Failed to initialize libcurl." << std::endl;
2775  return false;
2776  }
2777  // Cleanup libcurl
2778  curl_global_cleanup();
2779  return true;
2780 }

◆ getRunList()

bool AtlCoolCopy::getRunList ( )
private

Definition at line 2873 of file AtlCoolCopy.cxx.

2873  {
2874  // loop over all given filenames
2875  for (std::vector<std::string>::const_iterator itr=m_runfile.begin();
2876  itr!=m_runfile.end();++itr) {
2877  std::cout << "Reading allowed run numbers from file " << *itr << std::endl;
2878  FILE* p_inp=fopen(itr->c_str(),"r");
2879  if (p_inp==nullptr) {
2880  std::cout << "File not found" << std::endl;
2881  return false;
2882  }
2883  char* p_buf=new char[999];
2884  while (!feof(p_inp)) {
2885  char* p_line=fgets(p_buf,999,p_inp);
2886  if (p_line!=nullptr) {
2887  unsigned int run=atoi(p_line);
2888  m_runlist.push_back(run);
2889  }
2890  }
2891  fclose(p_inp);
2892  delete[] p_buf;
2893  }
2894  std::sort(m_runlist.begin(),m_runlist.end());
2895  std::cout << "Read list of " << m_runlist.size() << " runs from " <<
2896  m_runfile.size() << " input runlist files" << std::endl;
2897  for (std::vector<unsigned int>::const_iterator itr=m_runlist.begin();
2898  itr!=m_runlist.end();++itr) std::cout <<
2899  "Update allowed for run " << *itr << std::endl;
2900  return true;
2901 }

◆ getTimeFromRun()

bool AtlCoolCopy::getTimeFromRun ( )
private

Definition at line 2604 of file AtlCoolCopy.cxx.

2604  {
2605  // extract time limits for a run range using the expected information
2606  // in the /TDAQ/RunCtrl/SOR_Params and EOR_Params on the given DB connection
2607 
2608  // choose database instance based on run number switchover if none is given
2609  if (m_timedb.empty()) {
2610  if ((m_runemin >> 32)>=236107) {
2611  m_timedb="COOLONL_TDAQ/CONDBR2";
2612  } else {
2613  m_timedb="COOLONL_TDAQ/COMP200";
2614  }
2615  }
2616  // select foldername based on database instance
2617  std::string sorfolder="/TDAQ/RunCtrl/SOR_Params";
2618  std::string eorfolder="/TDAQ/RunCtrl/EOR_Params";
2619  if (m_timedb.find ("CONDBR2")!=std::string::npos) {
2620  sorfolder="/TDAQ/RunCtrl/SOR";
2621  eorfolder="/TDAQ/RunCtrl/EOR";
2622  }
2623  std::cout << "Extracting times for run range [" << (m_runemin >> 32) <<
2624  "," << (m_runemax >> 32) << "] from database " << m_timedb <<
2625  " folder " << sorfolder << std::endl;
2626  if (m_runemin==cool::ValidityKeyMin || m_runemax==cool::ValidityKeyMax) {
2627  std::cout << "ERROR: Run range not correctly specified" << std::endl;
2628  return false;
2629  }
2630  // open database connection
2631  cool::IDatabasePtr tdaqdb;
2632  try {
2633  tdaqdb=m_dbSvc->openDatabase(transConn(m_timedb),m_sourceread);
2634  std::cout << "Opened database connection" << std::endl;
2635  }
2636  catch (std::exception& e) {
2637  std::cout << "COOL exception caught: " << e.what() << std::endl;
2638  return false;
2639  }
2640  // start of run information
2641  try {
2642  cool::IFolderPtr folder=tdaqdb->getFolder(sorfolder);
2643  // channel number is arbitrary - have to loop
2644  cool::IObjectIteratorPtr itr=folder->browseObjects(m_runemin,m_runemin,
2646  int nobj=0;
2647  while (itr->goToNext()) {
2648  const cool::IRecord& payload=itr->currentRef().payload();
2649  m_timemin=payload["SORTime"].data<unsigned long long>();
2650  ++nobj;
2651  }
2652  itr->close();
2653  if (nobj!=1) {
2654  std::cout << "ERROR: Found " << nobj << " SOR records" << std::endl;
2655  return false;
2656  }
2657  }
2658  catch (std::exception& e) {
2659  std::cout << "Exception accessing SOR information: " << e.what() <<
2660  std::endl;
2661  return false;
2662  }
2663  // end of run information
2664  try {
2665  cool::IFolderPtr folder=tdaqdb->getFolder(eorfolder);
2666  // channel number is arbitrary - have to loop
2667  cool::IObjectIteratorPtr itr=folder->browseObjects(((m_runemax >> 32) << 32),((m_runemax >> 32) << 32),
2669  int nobj=0;
2670  while (itr->goToNext()) {
2671  const cool::IRecord& payload=itr->currentRef().payload();
2672  m_timemax=payload["EORTime"].data<unsigned long long>();
2673  ++nobj;
2674  }
2675  itr->close();
2676  if (nobj!=1) {
2677  std::cout << "ERROR: Found " << nobj << " EOR records" << std::endl;
2678  return false;
2679  }
2680  }
2681  catch (std::exception& e) {
2682  std::cout << "Exception accessing SOR information: " << e.what() <<
2683  std::endl;
2684  return false;
2685  }
2686  tdaqdb->closeDatabase();
2687  std::cout << "Timestamp range set to " << m_timemin << " " <<
2688  timeString(m_timemin) << "to " << m_timemax << " " <<
2689  timeString(m_timemax) << std::endl;
2690  return true;
2691 }

◆ getUpdateMode()

int AtlCoolCopy::getUpdateMode ( std::string_view  desc,
std::string_view  tag 
)
staticprivate

Definition at line 2903 of file AtlCoolCopy.cxx.

2904  {
2905  // analyse the folder description and tag name for updateMode flags
2906  // return 1 for online mode, 0 otherwise
2907  std::string_view modestr="";
2908  int mode=0;
2909  std::string::size_type iofs1=desc.find("<updateMode>");
2910  std::string::size_type iofs2=desc.find("</updateMode>");
2911  if (iofs1!=std::string::npos && iofs2!=std::string::npos && iofs2>iofs1)
2912  modestr=desc.substr(iofs1+12,iofs2-iofs1-12);
2913  if (modestr=="UPD1" || tag.find("UPD1")!=std::string::npos) mode=1;
2914  if (modestr=="UPD2" || tag.find("UPD2")!=std::string::npos) mode=2;
2915  if (modestr=="UPD3" || tag.find("UPD3")!=std::string::npos) mode=3;
2916  if (modestr=="UPD4" || tag.find("UPD4")!=std::string::npos) mode=4;
2917  return mode;
2918 }

◆ isNumeric()

bool AtlCoolCopy::isNumeric ( const char *  input)
staticprivate

Definition at line 2498 of file AtlCoolCopy.cxx.

2498  {
2499  // determine if input string is numeric or string
2500  bool isnum=true;
2501  const char* cptr=input;
2502  while (*cptr!='\0') {
2503  if (!isdigit(*cptr)) { isnum=false; break;}
2504  ++cptr;
2505  }
2506  return isnum;
2507 }

◆ isOpen()

bool AtlCoolCopy::isOpen ( ) const
inline

Definition at line 296 of file AtlCoolCopy.cxx.

296 { return m_open; }

◆ listPoolRefs()

int AtlCoolCopy::listPoolRefs ( )
private

Definition at line 3108 of file AtlCoolCopy.cxx.

3108  {
3109  std::cout << "Total of " << m_poolrefs.size() << " POOL files referenced"
3110  << std::endl;
3111  for (PoolMap::const_iterator ipool=m_poolrefs.begin();
3112  ipool!=m_poolrefs.end();++ipool) {
3113  std::cout << "Ref " << ipool->first << " (" << ipool->second.count()
3114  << ")" << std::endl;
3115  }
3116  return 0;
3117 }

◆ nocopyIOVs()

int AtlCoolCopy::nocopyIOVs ( const std::string &  folder,
const cool::IFolderPtr &  sourcefl,
const std::string &  sourcetag,
const cool::ValidityKey  since,
const cool::ValidityKey  until,
bool  checkrefs 
)
private

Definition at line 1321 of file AtlCoolCopy.cxx.

1324  {
1325 
1326  std::cout << "Reading tag " << sourcetag << " of folder " << folder <<
1327  " (no copy)" << std::endl;
1328  cool::FolderVersioning::Mode vermode=sourcefl->versioningMode();
1329  int nobj=0;
1330  cool::IObjectIteratorPtr sourceitr;
1331  if (vermode==cool::FolderVersioning::SINGLE_VERSION) {
1332  sourceitr=sourcefl->browseObjects(since,until,m_chansel);
1333  } else {
1334  sourceitr=sourcefl->browseObjects(since,until,m_chansel,sourcetag);
1335  }
1336  try {
1337  while (sourceitr->goToNext()) {
1338  const cool::IObject& obj=sourceitr->currentRef();
1339  if (checkrefs) checkRef(obj.payload(),folder,sourcetag);
1340  ++nobj;
1341  }
1342  std::cout << "Folder scanned with " << nobj << " objects" << std::endl;
1343  }
1344  // exceptions thrown from read loop
1345  catch (cool::Exception& e) {
1346  std::cout << "Exception thrown from read loop: " << e.what() <<
1347  std::endl;
1348  return 33;
1349  }
1350  // finished with the iterator
1351  sourceitr->close();
1352  return 0;
1353 }

◆ openConnections()

bool AtlCoolCopy::openConnections ( const std::string &  sourcedb,
const std::string &  destdb,
bool  allowcreate 
)
private

Definition at line 339 of file AtlCoolCopy.cxx.

340  {
341  // check connections not already open
342  if (m_open) return true;
343  // initialise replica sorter if it was requested
344  if (m_readoracle) {
345  m_repsort=new ReplicaSorter();
346  coral::IConnectionServiceConfiguration& csconfig=m_coralsvc.configuration();
347  csconfig.setReplicaSortingAlgorithm(*m_repsort);
348  }
349  // cool::IDatabaseSvc& dbSvc=cool::DatabaseSvcFactory::databaseService();
350  // open source database
351  std::cout << "Open source database: " << sourcedb << std::endl;
352  if (!m_sourceread) std::cout << "... in UPDATE mode" << std::endl;
353  try {
354  m_sourceDbPtr=m_dbSvc->openDatabase(transConn(sourcedb),m_sourceread);
355  }
356  catch (std::exception& e) {
357  std::cout << "Cool exception caught: " << e.what() << std::endl;
358  return false;
359  }
360  // open destination database
361  if (m_nocopy) {
362  m_open=true;
363  return true;
364  } else if (m_root || m_analyse) {
365  std::cout << "Open destination ROOT file: " << destdb << std::endl;
366  p_rootfile=new TFile(destdb.c_str(),"RECREATE");
367  if (p_rootfile==nullptr) std::cout << "ERROR: Could not open ROOT file" <<
368  std::endl;
369  m_open=(p_rootfile!=nullptr);
370  return m_open;
371  }
372  std::string tdestdb=transConn(destdb);
373  std::cout << "Open destination database: " << tdestdb << std::endl;
374  try {
375  m_destDbPtr=m_dbSvc->openDatabase(tdestdb,m_verify);
376  // if the open succeeds and we are using recreate mode, drop/delete
377  // the existing database first
378  if (m_recreate) {
379  std::cout <<
380  "Forcing recreation of destination database - deleting existing data!"
381  << std::endl;
382  m_destDbPtr.reset();
383  m_dbSvc->dropDatabase(tdestdb);
384  // go into catch to recrete database
385  throw cool::DatabaseDoesNotExist("old database deleted");
386  }
387  }
388  catch (std::exception& e) {
389  std::cout << "COOL exception caught: " << e.what() << std::endl;
390  // try to recover by creating new DB if possible and requested
391  if (allowcreate || m_recreate) {
392  std::cout << "Try to create new conditions DB" << std::endl;
393  try {
394  m_destDbPtr=m_dbSvc->createDatabase(tdestdb);
395  std::cout << "Creation succeeded" << std::endl;
396  }
397  catch (cool::Exception& e) {
398  std::cout << "Creation failed" << std::endl;
399  return false;
400  }
401  } else {
402  return false;
403  }
404  }
405  m_open=true;
406  return true;
407 }

◆ openCoraCool()

bool AtlCoolCopy::openCoraCool ( )
private

Definition at line 409 of file AtlCoolCopy.cxx.

409  {
410  if (m_sourceCoraPtr.get()==nullptr) {
411  std::cout << "Attempt to open source CoraCool DB " << m_sourcedb <<
412  std::endl;
415  std::cout << "Opened CoraCool source DB" << std::endl;
416  }
417  // skip destination DB if not copying
418  if (m_nocopy) return true;
419  if (m_destCoraPtr.get()==nullptr) {
420  std::cout << "Attempt to open destination CoraCool DB " << m_destdb <<
421  std::endl;
424  std::cout << "Opened CoraCool dest DB" << std::endl;
425  }
426  return true;
427 }

◆ procOptVector()

bool AtlCoolCopy::procOptVector ( const int  argc,
const char *  argv[],
std::vector< std::string > &  folders 
)
private

Definition at line 2131 of file AtlCoolCopy.cxx.

2132  {
2133  // process an array of options, return True if OK, False if not
2134  int ic=0;
2135  bool error=false;
2136  while (ic<argc) {
2137  int ir=argc-ic;
2138  std::string_view par0=argv[ic];
2139  // strip double "--" to achieve compatability with python-style options
2140  if (par0.compare(0,2,"--")==0) par0=par0.substr(1);
2141  if ((par0=="-f" || par0=="-folder") && ir>1) {
2142  folders.emplace_back(argv[ic+1]);
2143  ++ic;
2144  } else if ((par0=="-e" || par0=="-exclude") && ir>1) {
2145  addExclude(argv[ic+1]);
2146  ++ic;
2147  } else if ((par0=="-t" || par0=="-tag") && ir>1) {
2148  m_tags.emplace_back(argv[ic+1]);
2149  ++ic;
2150  } else if ((par0=="-mt" || par0=="-magic") && ir>1) {
2151  m_magic.push_back("_"+std::string(argv[ic+1]));
2152  ++ic;
2153  } else if ((par0=="-of" || par0=="-outfolder") && ir>1) {
2154  m_outfolder=argv[ic+1];
2155  ++ic;
2156  } else if ((par0=="-ot" || par0=="-outtag") && ir>1) {
2157  m_outtag=argv[ic+1];
2158  ++ic;
2159  } else if ((par0=="-bs" || par0=="-buffersize") && ir>1) {
2160  m_bufsize=atoi(argv[ic+1]);
2161  ++ic;
2162  } else if ((par0=="-sl" || par0=="-seal") && ir>1) {
2163  m_sealmsg=atoi(argv[ic+1]);
2164  ++ic;
2165  } else if ((par0=="-rls" || par0=="-runlumisince") && ir>2) {
2166  m_runemin=runLBVal(argv[ic+1],argv[ic+2]);
2167  ic+=2;
2168  } else if ((par0=="-rlu" || par0=="-runlumiuntil") && ir>2) {
2169  m_runemax=runLBVal(argv[ic+1],argv[ic+2]);
2170  ic+=2;
2171  } else if ((par0=="-nrls" || par0=="-newrunlumisince") && ir>2) {
2173  ic+=2;
2174  } else if ((par0=="-nrlu" || par0=="-newrunlumiuntil") && ir>2) {
2176  ic+=2;
2177  } else if ((par0=="-srls" || par0=="-skiprunlumisince") && ir>2) {
2178  m_srunemin=runLBVal(argv[ic+1],argv[ic+2]);
2179  m_skipout=true;
2180  ic+=2;
2181  } else if ((par0=="-srlu" || par0=="-skiprunlumiuntil") && ir>2) {
2182  m_srunemax=runLBVal(argv[ic+1],argv[ic+2]);
2183  m_skipout=true;
2184  ic+=2;
2185  } else if (par0=="-ro" || par0=="-root") {
2186  m_root=true;
2187  } else if (par0=="-zn" || par0=="-zeronull") {
2188  m_zeronull=true;
2189  } else if (par0=="-ana" || par0=="-analyse") {
2190  m_analyse=true;
2191  float ttime=atof(argv[ic+1])*1.E9;
2192  m_anadelt=static_cast<long long>(ttime);
2193  ++ic;
2194  } else if ((par0=="-rs" || par0=="-runsince") && ir>1) {
2195  m_runemin=(static_cast<long long>(atol(argv[ic+1])) << 32);
2196  ++ic;
2197  } else if ((par0=="-ru" || par0=="-rununtil") && ir>1) {
2198  m_runemax=(static_cast<long long>(1+atol(argv[ic+1])) << 32)-1;
2199  ++ic;
2200  } else if ((par0=="-r" || par0=="-run") && ir>1) {
2201  m_runemin=(static_cast<long long>(atol(argv[ic+1])) << 32);
2202  m_runemax=(static_cast<long long>(1+atol(argv[ic+1])) << 32)-1;
2203  ++ic;
2204  } else if ((par0=="-ts" || par0=="-timesince") && ir>1) {
2205  m_timemin=timeVal(argv[ic+1]);
2206  ++ic;
2207  } else if ((par0=="-tu" || par0=="-timeuntil") && ir>1) {
2208  m_timemax=timeVal(argv[ic+1]);
2209  ++ic;
2210  } else if ((par0=="-nts" || par0=="-newtimesince") && ir>1) {
2212  ++ic;
2213  } else if ((par0=="-ntu" || par0=="-newtimeuntil") && ir>1) {
2215  ++ic;
2216  } else if (par0=="-c" || par0=="-create") {
2217  m_allowcreate=true;
2218  } else if ((par0=="-ch" || par0=="-channel") && ir>1) {
2219  m_channelRange.emplace_back(argv[ic+1]);
2220  ++ic;
2221  } else if ((par0=="-ch1" || par0=="-channel1") && ir>1) {
2222  m_channel1=argv[ic+1];
2223  ++ic;
2224  } else if ((par0=="-ch2" || par0=="-channel2") && ir>1) {
2225  m_channel2=argv[ic+1];
2226  ++ic;
2227  } else if (par0=="-chd" || par0=="-channeldesc") {
2228  m_chdesc=true;
2229  // no abbreviaton for this one - dangerous option
2230  } else if (par0=="-forcerecreate") {
2231  m_recreate=true;
2232  } else if (par0=="-d" || par0=="-debug") {
2233  m_debug=true;
2234  } else if (par0=="-a" || par0=="-alliov") {
2235  m_alliov=true;
2236  } else if (par0=="-ih" || par0=="-includehead") {
2237  m_includehead=true;
2238  } else if (par0=="-eh" || par0=="-excludehead") {
2239  m_excludehead=true;
2240  } else if (par0=="-ht" || par0=="-headtag") {
2241  m_usertags=false;
2242  } else if (par0=="-uht" || par0=="-userheadtag") {
2243  m_userupdatehead=true;
2244  } else if (par0=="-v" || par0=="-verify") {
2245  m_verify=true;
2246  } else if (par0=="-nc" || par0=="-nocopy") {
2247  m_nocopy=true;
2248  } else if (par0=="-noc" || par0=="-nocoracool") {
2249  m_coracool=false;
2250  } else if (par0=="-nch" || par0=="-nochannel") {
2251  m_nochannel=true;
2252  } else if (par0=="-ncr" || par0=="-noclobroot") {
2253  m_noclobroot=true;
2254  } else if (par0=="-nd" || par0=="-nodata") {
2255  m_nodata=true;
2256  } else if (par0=="-nh" || par0=="-nohitag") {
2257  m_nohitag=true;
2258  } else if (par0=="-hi" || par0=="-hitag") {
2259  m_hitag=true;
2260  } else if ((par0=="-ec" || par0=="-excludechannel") && ir>1) {
2261  m_excludechans.push_back(strtoul(argv[ic+1],nullptr,10));
2262  ++ic;
2263  } else if (par0=="-fs" || par0=="-forcesingle") {
2264  m_forcesingle=true;
2265  } else if (par0=="-fm" || par0=="-forcemulti") {
2266  m_forcemulti=true;
2267  } else if (par0=="-frl" || par0=="-forcerunlumi") {
2268  m_forcerune=true;
2269  } else if (par0=="-ftm" || par0=="-forcetime") {
2270  m_forcetime=true;
2271  } else if (par0=="-fp" || par0=="-forcepayload") {
2272  m_forcepay=true;
2273  } else if (par0=="-fnp" || par0=="-forcenopayload") {
2274  m_forcenopay=true;
2275  } else if (par0=="-cr" || par0=="-checkrefs") {
2276  m_checkrefs=true;
2277  } else if (par0=="-lp" || par0=="-listpfn") {
2278  m_listpfn=true;
2279  m_checkrefs=true;
2280  } else if (par0=="-cf" || par0=="-checkfiles") {
2281  m_poolopen=true;
2282  m_checkrefs=true;
2283  } else if (par0=="-pa" || par0=="-poolall") {
2284  m_poolall=true;
2285  } else if ((par0=="-co" || par0=="-checkoutput") && ir>1) {
2287  ++ic;
2288  } else if ((par0=="-pc" || par0=="-poolcat") && ir>1) {
2289  m_poolcat.emplace_back(argv[ic+1]);
2290  ++ic;
2291  } else if ((par0=="-mc" || par0=="-mergecat") && ir>1) {
2292  m_mergecat.emplace_back(argv[ic+1]);
2293  ++ic;
2294  } else if ((par0=="-ds" || par0=="-dataset") && ir>1) {
2295  m_newdataset=argv[ic+1];
2296  ++ic;
2297  } else if (par0=="-us" || par0=="-updatesource") {
2298  m_sourceread=false;
2299  } else if (par0=="-cd" || par0=="-checkdest") {
2300  m_checkdesttag=true;
2301  } else if (par0=="-tr" || par0=="-truncate") {
2302  m_truncate=true;
2303  } else if (par0=="-al" || par0=="-appendlocked") {
2304  m_applock=true;
2305  } else if (par0=="-alsv" || par0=="-appendlockedsv") {
2306  m_applock=true;
2307  m_applocksv=true;
2308  } else if (par0=="-rdo" || par0=="-readoracle") {
2309  m_readoracle=true;
2310  } else if (par0=="-skiprep" || par0=="-sr") {
2311  m_skiprep=true;
2312  } else if (par0=="-go" || par0=="-getonline") {
2313  m_getonline=true;
2314  } else if (par0=="-onr" || par0=="-onlinerun") {
2315  m_onlinerun=true;
2316  } else if (par0=="-gb" || par0=="-getbulk") {
2317  m_getbulk=true;
2318  } else if (par0=="-gt" || par0=="-gettime") {
2319  m_gettime=true;
2320  } else if ((par0=="-tdb" || par0=="-timedb") && ir>1) {
2321  m_timedb=argv[ic+1];
2322  ++ic;
2323  } else if (par0=="-ignoremode" && ir>1) {
2324  std::cout << "Ignoremode password is " << argv[ic+1] << ":end" << std::endl;
2325  if (strcmp(argv[ic+1],"BackDoor")==0) {
2326  m_ignoremode=true;
2327  } else {
2328  std::cout << "ERROR: Incorrect password for -ignoremode" << std::endl;
2329  error=true;
2330  }
2331  ++ic;
2332  } else if (par0=="-is" || par0=="-ignorespec") {
2333  m_ignorespec=true;
2334  } else if (par0=="-pt" || par0=="-prunetags") {
2335  m_prunetags=true;
2336  m_excludehead=true;
2337  } else if (par0=="-lo" || par0=="-lockedonly") {
2338  m_lockedonly=true;
2339  m_prunetags=true;
2340  m_excludehead=true;
2341  } else if (par0=="-cti" || par0=="-copytaginfo") {
2342  m_copytaginfo=true;
2343  } else if (par0=="-ctl" || par0=="-copytaglock") {
2344  m_copytaginfo=true;
2345  m_copytaglock=true;
2346  } else if ((par0=="-tl" || par0=="-taglabel") && ir>1) {
2347  m_taglabel=argv[ic+1];
2348  ++ic;
2349  m_copytaginfo=true;
2350  } else if ((par0=="-ag" || par0=="-addguid") && ir>1) {
2351  m_addguid.emplace_back(argv[ic+1]);
2352  ++ic;
2353  } else if ((par0=="-alf" || par0=="-addlfn") && ir>1) {
2354  m_addlfn.emplace_back(argv[ic+1]);
2355  ++ic;
2356  } else if ((par0=="-pf" || par0=="-parfile") && ir>1) {
2357  m_parfile.emplace_back(argv[ic+1]);
2358  ++ic;
2359  } else if ((par0=="-rf" || par0=="-runfile") && ir>1) {
2360  m_runfile.emplace_back(argv[ic+1]);
2361  ++ic;
2362  } else if ((par0=="-ws" || par0=="-runinfohost") && ir>1) {
2363  m_runinfohost=argv[ic+1];
2364  ++ic;
2365  } else if (par0=="-h" || par0=="-help") {
2366  // help printout triggered by -999 return code
2367  return 999;
2368  } else {
2369  std::cout << "Parameter error for argument: " << par0 << std::endl;
2370  error=true;
2371  }
2372  ++ic;
2373  }
2374  return !error;
2375 }

◆ rootAllocate()

bool AtlCoolCopy::rootAllocate ( const cool::IFieldSpecification &  spec,
void *&  sptr,
char &  rootID 
) const
private

Definition at line 1715 of file AtlCoolCopy.cxx.

1716  {
1717  const cool::StorageType& stype=spec.storageType();
1718  rootID=' ';
1719  sptr=nullptr;
1720  if (stype==cool::StorageType::Bool) {
1721  // map bool to uint32 for now
1722  sptr=static_cast<void*>(new unsigned int(0));
1723  rootID='i';
1724  } else if (stype==cool::StorageType::UChar) {
1725  sptr=static_cast<void*>(new unsigned char(' '));
1726  rootID='C';
1727  } else if (stype==cool::StorageType::Int16) {
1728  sptr=static_cast<void*>(new short(0));
1729  rootID='S';
1730  } else if (stype==cool::StorageType::UInt16) {
1731  sptr=static_cast<void*>(new unsigned short(0));
1732  rootID='s';
1733  } else if (stype==cool::StorageType::Int32) {
1734  sptr=static_cast<void*>(new int(0));
1735  rootID='I';
1736  } else if (stype==cool::StorageType::UInt32) {
1737  sptr=static_cast<void*>(new unsigned int(0));
1738  rootID='i';
1739  } else if (stype==cool::StorageType::Int64) {
1740  sptr=static_cast<void*>(new long long int(0));
1741  rootID='L';
1742  } else if (stype==cool::StorageType::UInt63) {
1743  sptr=static_cast<void*>(new unsigned long long int(0));
1744  rootID='l';
1745  } else if (stype==cool::StorageType::Float) {
1746  sptr=static_cast<void*>(new float(0.));
1747  rootID='F';
1748  } else if (stype==cool::StorageType::Double) {
1749  sptr=static_cast<void*>(new double(0.));
1750  rootID='D';
1751  } else if (stype==cool::StorageType::String4k ||
1752  stype==cool::StorageType::String255) {
1753  sptr=static_cast<void*>(new char[4100]);
1754  rootID='C';
1755  } else if (stype==cool::StorageType::String64k && !m_noclobroot) {
1756  sptr=static_cast<void*>(new char[65536]);
1757  rootID='C';
1758  } else if (stype==cool::StorageType::String16M && !m_noclobroot) {
1759  sptr=static_cast<void*>(new char[67108864]);
1760  rootID='C';
1761  } else if (stype==cool::StorageType::Blob64k && !m_noclobroot) {
1762  sptr=static_cast<void*>(new char[65536]);
1763  rootID='C';
1764  } else {
1765  std::cout << "rootAllocate: Unsupported storage type for attribute: " <<
1766  spec.name() << std::endl;
1767  }
1768  return (sptr!=nullptr);
1769 }

◆ rootDirs()

std::string AtlCoolCopy::rootDirs ( const std::string &  folder,
const std::string &  toproot 
)
private

Definition at line 1681 of file AtlCoolCopy.cxx.

1682  {
1683  // create a ROOT directory structure start with toproot (=COOL or COOLANA)
1684  // and cd to the directory where a tree should be created
1685  // return the tree name (=leaf of the COOL foldername)
1686  p_rootfile->cd();
1687  if (p_rootfile->FindObject(toproot.c_str())==nullptr) {
1688  p_rootfile->mkdir(toproot.c_str());
1689  std::cout << "Made top directory " << toproot << std::endl;
1690  }
1691  gDirectory->cd(toproot.c_str());
1692  // now parse the COOL folder name to create intermediate directories
1693  // assume folder names begin with '/', to be skipped
1694  std::string::size_type iofs1=1;
1695  std::string::size_type iofs2=1;
1696  std::string treename;
1697  while (iofs2!=std::string::npos) {
1698  iofs2=folder.find('/',iofs1);
1699  if (iofs2==std::string::npos) {
1700  // no more /, so current part of string is leaf tree name
1701  treename=folder.substr(iofs1);
1702  } else {
1703  std::string dirname=folder.substr(iofs1,iofs2-iofs1);
1704  iofs1=iofs2+1;
1705  if (gDirectory->FindObject(dirname.c_str())==nullptr) {
1706  std::cout << "Make directory " << dirname << std::endl;
1707  gDirectory->mkdir(dirname.c_str());
1708  }
1709  gDirectory->cd(dirname.c_str());
1710  }
1711  }
1712  return treename;
1713 }

◆ rootIOVs()

int AtlCoolCopy::rootIOVs ( const std::string &  folder,
const cool::IFolderPtr &  sourcefl,
const std::string &  sourcetag,
const cool::ValidityKey  since,
const cool::ValidityKey  until,
const bool  timestamp 
)
private

Definition at line 1550 of file AtlCoolCopy.cxx.

1553  {
1554  // copy this selection to ROOT
1555  std::cout << "Write tag " << sourcetag << " of folder " << folder <<
1556  " to ROOT file" << std::endl;
1557  // create the directory structure - top directory COOL
1558  std::string treename=rootDirs(folder,"COOL");
1559  bool timestamp2=timestamp;
1560  if (m_forcetime) timestamp2=true;
1561  if (m_forcerune) timestamp2=false;
1562  cool::FolderVersioning::Mode vermode=sourcefl->versioningMode();
1563  // create TTree with appropriate structure - only if it does not exist
1564  // could have been created from a previous tag in the same folder
1565  TTree* tree=static_cast<TTree*>(gDirectory->FindObject(treename.c_str()));
1566  if (tree==nullptr) {
1567  std::cout << "Book TTree " << treename << std::endl;
1568  tree=new TTree(treename.c_str(),"COOL datadump");
1569  if (timestamp2) {
1570  tree->Branch("IOVSince",&m_nt_since,"IOVSince/l");
1571  tree->Branch("IOVUntil",&m_nt_until,"IOVUntil/l");
1572  } else {
1573  tree->Branch("RunSince",&m_nt_runsince,"RunSince/i");
1574  tree->Branch("RunUntil",&m_nt_rununtil,"RunUntil/i");
1575  tree->Branch("LBSince",&m_nt_lbsince,"LBSince/i");
1576  tree->Branch("LBUntil",&m_nt_lbuntil,"LBUntil/i");
1577  }
1578  tree->Branch("ChannelID",&m_nt_channel,"ChannelID/i");
1579  if (vermode==cool::FolderVersioning::MULTI_VERSION)
1580  tree->Branch("TagID",m_nt_tagid,"TagID/C");
1581  // now loop through specification, creating payload buffer and tree
1582  const cool::IRecordSpecification& spec=
1583  (sourcefl->folderSpecification()).payloadSpecification();
1584  unsigned int ncolumns=spec.size();
1585  // clear the buffer of pointers - note this leaks the memory of the
1586  // previous buffers, but to do this properly would have to remember
1587  // the type of each object and delete appropriately
1589  m_nt_bufferptr.clear();
1590  for (unsigned int icol=0;icol<ncolumns;++icol) {
1591  const cool::IFieldSpecification& fieldspec=spec[icol];
1592  void* ptr=nullptr;
1593  char rootID;
1594  if (rootAllocate(fieldspec,ptr,rootID)) {
1595  tree->Branch(fieldspec.name().c_str(),ptr,
1596  (fieldspec.name()+"/"+rootID).c_str());
1597  if (m_debug) std::cout << "Defining column for " << spec[icol].name()
1598  << " of type " << spec[icol].storageType().name() << std::endl;
1599  } else {
1600  std::cout << "Attribute " << spec[icol].name() << " of type " <<
1601  spec[icol].storageType().name() << " will be skipped" << std::endl;
1602  }
1603  m_nt_bufferptr.push_back(ptr);
1604  }
1605  } else {
1606  std::cout << "TTree " << treename << " already exists" << std::endl;
1607  // check we have seen and defined this tree
1608  unsigned int size=
1609  (sourcefl->folderSpecification()).payloadSpecification().size();
1610  if (treename!=m_nt_treename || size!=m_nt_bufferptr.size()) {
1611  std::cout << "ERROR in tree buffer definition: expect " << treename <<
1612  " size " << size << " but buffer has " << m_nt_treename << " size "
1613  << m_nt_bufferptr.size() << std::endl;
1614  return 123;
1615  }
1616  }
1617 
1618  int nobj=0;
1619  int nex=0;
1620  cool::IObjectIteratorPtr sourceitr;
1621  try {
1622  if (vermode==cool::FolderVersioning::SINGLE_VERSION) {
1623  sourceitr=sourcefl->browseObjects(since,until,m_chansel);
1624  } else {
1625  sourceitr=sourcefl->browseObjects(since,until,m_chansel,sourcetag);
1626  }
1627  }
1628  catch (cool::Exception& e) {
1629  std::cout << "Exception thrown from ROOT copy iterator setup: " <<
1630  e.what() << std::endl;
1631  return 125;
1632  }
1633  // now loop over all IOVs to copy them
1634  try {
1635  while (sourceitr->goToNext()) {
1636  const cool::IObject& sobj=sourceitr->currentRef();
1637  if (timestamp2) {
1638  m_nt_since=sobj.since();
1639  m_nt_until=sobj.until();
1640  } else {
1641  m_nt_runsince=(sobj.since() >> 32);
1642  m_nt_rununtil=(sobj.until() >> 32);
1643  m_nt_lbsince=(sobj.since() & 0xFFFFFFFF);
1644  m_nt_lbuntil=(sobj.until() & 0xFFFFFFFF);
1645  }
1646  m_nt_channel=sobj.channelId();
1647  if (vermode==cool::FolderVersioning::MULTI_VERSION) {
1648  // truncate the string first to avoid coverity complaining about
1649  // potential buffer overruns
1650  std::string sourcetag2=sourcetag.substr(0,255);
1651  strncpy(m_nt_tagid,sourcetag2.c_str(),sizeof(m_nt_tagid)-1);
1652  }
1653  // loop over the payload elements and fill the ones for which buffers
1654  // are defined
1655  try {
1656  const cool::IRecord& record=sobj.payload();
1657  for (unsigned int icol=0;icol<record.size();++icol) {
1658  if (m_nt_bufferptr[icol]!=nullptr) rootWrite(m_nt_bufferptr[icol],record[icol]);
1659  }
1660  tree->Fill();
1661  ++nobj;
1662  }
1663  catch (cool::Exception& e) {
1664  // can get exceptions due to NULL values
1665  // catch them and continue...
1666  ++nex;
1667  }
1668  }
1669  sourceitr->close();
1670  std::cout << "Written " << nobj << " objects to ROOT TTree with " << nex
1671  << " nulls/exceptions" << std::endl;
1672  }
1673  catch (cool::Exception& e) {
1674  std::cout << "Exception thrown from ROOT file writing loop: " <<
1675  e.what() << std::endl;
1676  return 124;
1677  }
1678  return 0;
1679 }

◆ rootWrite()

void AtlCoolCopy::rootWrite ( void *  sptr,
const cool::IField &  field 
) const
private

Definition at line 1771 of file AtlCoolCopy.cxx.

1771  {
1772  // check for NULL value
1773  bool recnull=(field.isNull() && m_zeronull);
1774  const cool::StorageType& stype=field.storageType();
1775  if (stype==cool::StorageType::Bool) {
1776  if (recnull) {
1777  *(static_cast<int*>(sptr))=0;
1778  } else {
1779  *(static_cast<int*>(sptr))=(field.data<bool>() ? 1 : 0);
1780  }
1781  } else if (stype==cool::StorageType::UChar) {
1782  if (recnull) {
1783  *(static_cast<unsigned char*>(sptr))=0;
1784  } else {
1785  *(static_cast<unsigned char*>(sptr))=field.data<unsigned char>();
1786  }
1787  } else if (stype==cool::StorageType::Int16) {
1788  if (recnull) {
1789  *(static_cast<short*>(sptr))=0;
1790  } else {
1791  *(static_cast<short*>(sptr))=field.data<short>();
1792  }
1793  } else if (stype==cool::StorageType::UInt16) {
1794  if (recnull) {
1795  *(static_cast<unsigned short*>(sptr))=0;
1796  } else {
1797  *(static_cast<unsigned short*>(sptr))=field.data<unsigned short>();
1798  }
1799  } else if (stype==cool::StorageType::Int32) {
1800  if (recnull) {
1801  *(static_cast<int*>(sptr))=0;
1802  } else {
1803  *(static_cast<int*>(sptr))=field.data<int>();
1804  }
1805  } else if (stype==cool::StorageType::UInt32) {
1806  if (recnull) {
1807  *(static_cast<unsigned int*>(sptr))=0;
1808  } else {
1809  *(static_cast<unsigned int*>(sptr))=field.data<unsigned int>();
1810  }
1811  } else if (stype==cool::StorageType::Int64) {
1812  if (recnull) {
1813  *(static_cast<long long*>(sptr))=0;
1814  } else {
1815  *(static_cast<long long*>(sptr))=field.data<long long>();
1816  }
1817  } else if (stype==cool::StorageType::UInt63) {
1818  if (recnull) {
1819  *(static_cast<unsigned long long*>(sptr))=0;
1820  } else {
1821  *(static_cast<unsigned long long*>(sptr))=field.data<unsigned long long>();
1822  }
1823  } else if (stype==cool::StorageType::Float) {
1824  if (recnull) {
1825  *(static_cast<float*>(sptr))=0.;
1826  } else {
1827  *(static_cast<float*>(sptr))=field.data<float>();
1828  }
1829  } else if (stype==cool::StorageType::Double) {
1830  if (recnull) {
1831  *(static_cast<double*>(sptr))=0.;
1832  } else {
1833  *(static_cast<double*>(sptr))=field.data<double>();
1834  }
1835  } else if (stype==cool::StorageType::String255 ||
1836  stype==cool::StorageType::String4k ||
1837  stype==cool::StorageType::String64k ||
1838  stype==cool::StorageType::String16M) {
1839  if (recnull) {
1840  strcpy(static_cast<char*>(sptr),"NULL");
1841  } else {
1842  strcpy(static_cast<char*>(sptr),field.data<std::string>().c_str());
1843  }
1844  } else if (stype==cool::StorageType::Blob64k && !m_noclobroot) {
1845  if (recnull) {
1846  strcpy(static_cast<char*>(sptr),"NULL");
1847  } else {
1848  auto blob = field.data<coral::Blob>();
1849  std::string blobStr((char*)blob.startingAddress(), blob.size());
1850  strcpy(static_cast<char*>(sptr), blobStr.c_str());
1851  }
1852  } else {
1853  std::cout << "ERROR: Unknown storage type in rootWrite!" << std::endl;
1854  }
1855 }

◆ runLBVal()

cool::ValidityKey AtlCoolCopy::runLBVal ( const char *  input1,
const char *  input2 
)
staticprivate

Definition at line 2585 of file AtlCoolCopy.cxx.

2585  {
2586  // parse the inputs as run/LB numbers to generate a validitykey
2587  // used in processing -rls-type options
2588  cool::ValidityKey val;
2589  if (input1[0]=='M' || input1[0]=='m') {
2590  val=((1LL << 31)-1) << 32;
2591  } else {
2592  val=static_cast<long long>(atol(input1)) << 32;
2593  }
2594  if (input2[0]=='M' || input2[0]=='m') {
2595  val+=(1LL << 32);
2596  } else {
2597  val+=atoll(input2);
2598  }
2599  if (val>cool::ValidityKeyMax) val=cool::ValidityKeyMax;
2600  return val;
2601 }

◆ setChannelRange()

void AtlCoolCopy::setChannelRange ( const cool::IFolderPtr &  sourcefl)
private

Definition at line 820 of file AtlCoolCopy.cxx.

820  {
821  // add range specified via -ch1 -ch2 if given
822  if (!m_channel1.empty() && !m_channel2.empty()) {
823  m_channelRange.clear();
824  m_channelRange.push_back(m_channel1+":"+m_channel2);
825  }
827  const size_t nChanRange=m_channelRange.size();
828  for (size_t i=0;i<nChanRange;i++) {
829  size_t cpos=m_channelRange[i].find(':');
830  if (cpos==std::string::npos || cpos > m_channelRange[i].size()-1) {
831  // single channel
832  std::cout << "Adding channel " << m_channelRange[i] <<
833  " to channel selection" << std::endl;
834  if (m_chansel.allChannels())
835  m_chansel=cool::ChannelSelection(channelID(sourcefl,
836  m_channelRange[i]));
837  else
838  m_chansel.addChannel(channelID(sourcefl,m_channelRange[i]));
839  }
840  else {
841  // Channel Range
842  std::string c1=m_channelRange[i].substr(0,cpos);
843  std::string c2=m_channelRange[i].substr(1+cpos);
844  std::cout << "Adding channel range " << c1 << " to " << c2 <<
845  " to channel selection" << std::endl;
846  if (m_chansel.allChannels())
847  m_chansel=cool::ChannelSelection(channelID(sourcefl,c1),
848  channelID(sourcefl,c2));
849  else
850  m_chansel.addRange(channelID(sourcefl,c1),channelID(sourcefl,c2));
851  }
852  }//end loop over channel ranges
853 }

◆ setOpts()

int AtlCoolCopy::setOpts ( int  argc,
const char *  argv[] 
)

Definition at line 2378 of file AtlCoolCopy.cxx.

2378  {
2379  // accumulate raw folder list
2380  std::vector<std::string> folders;
2381  // process options given on command-line
2382  if (!procOptVector(argc,argv,folders)) return 2;
2383 
2384  // parse any parameters in files via parfile option
2385  for (std::vector<std::string>::const_iterator ifile=m_parfile.begin();
2386  ifile!=m_parfile.end();++ifile) {
2387  std::cout << "Reading parameters from file " << *ifile << std::endl;
2388  FILE* p_inp=fopen(ifile->c_str(),"r");
2389  if (p_inp==nullptr) {
2390  std::cout << "File not found" << std::endl;
2391  return 3;
2392  }
2393  char* p_buf=new char[999];
2394  while (!feof(p_inp)) {
2395  char* p_line=fgets(p_buf,999,p_inp);
2396  if (p_line!=nullptr) {
2397  int fargc=0;
2398  const char* fargv[99];
2399  // split this line into tokens
2400  char* p_start=nullptr;
2401  while (*p_line!='\0') {
2402  if (*p_line==' ' || *p_line=='\n') {
2403  // pointing at a space/newline, marking the end of a parameter
2404  if (p_start!=nullptr) {
2405  // if we have a parameter, mark the end and store it
2406  *p_line='\0';
2407  fargv[fargc]=p_start;
2408  fargc++;
2409  p_start=nullptr;
2410  }
2411  } else {
2412  // mark the start of a parameter
2413  if (p_start==nullptr) p_start=p_line;
2414  }
2415  ++p_line;
2416  }
2417  if (fargc>0) {
2418  if (!procOptVector(fargc,&fargv[0],folders)) {
2419  fclose(p_inp);
2420  return 3;
2421  }
2422  }
2423  }
2424  }
2425  std::cout << "Close file" << std::endl;
2426  fclose(p_inp);
2427  delete[] p_buf;
2428  }
2429 
2430  // now open the database so folder lookup will work
2432  std::cout << "Problem opening connections" << std::endl;
2433  return 10;
2434  } else {
2435  // having assembled the raw list of folders and exclude list, construct
2436  // real list of folders (allows exclude to be specified after folders on
2437  // command line), if none given, add '/'
2438  if (m_lockedonly) {
2439  if (getLockedTags()==0) return 11;
2440  }
2441  if (folders.empty()) {
2442  // no folders specified, take all with tags
2443  addFolder("/",false);
2444  } else {
2445  // explicit list of folders
2446  for (std::vector<std::string>::const_iterator ifold=folders.begin();
2447  ifold!=folders.end();++ifold) addFolder(*ifold,false);
2448  // need to process only tags in root folder, if inclusive hiearchicals
2449  if (m_hitag) addFolder("/",true);
2450  }
2451  }
2452  if (m_getonline) {
2453  if (!getOnlineRun()) return 6;
2454  }
2455  if (m_getbulk) {
2456  if (!getBulkRun()) return 6;
2457  }
2458  if (m_gettime) {
2459  if (!getTimeFromRun()) return 5;
2460  }
2461  if (!m_runfile.empty()) {
2462  if (!getRunList()) return 7;
2463  }
2464  // list out parameter changes
2465  if (m_runemin!=cool::ValidityKeyMin || m_runemax!=cool::ValidityKeyMax)
2466  std::cout << "Source run/LB range [" << (m_runemin >> 32) << "," <<
2467  (m_runemin & 0xFFFFFFFF) << "] to [" << (m_runemax >> 32) << "," <<
2468  (m_runemax & 0xFFFFFFFF) << "]" << std::endl;
2469  if (m_timemin!=cool::ValidityKeyMin || m_timemax!=cool::ValidityKeyMax)
2470  std::cout << "Source timestamp range " << m_timemin << " " <<
2471  timeString(m_timemin) << "to " << m_timemax << " " <<
2472  timeString(m_timemax) << std::endl;
2473  if (m_alliov)
2474  std::cout << "Change o/p run/LB range [" << (m_newrunemin >> 32) << "," <<
2475  (m_newrunemin & 0xFFFFFFFF) << "] to [" << (m_newrunemax >> 32) << "," <<
2476  (m_newrunemax & 0xFFFFFFFF) << "]" << std::endl;
2477  if (m_alliov)
2478  std::cout << "Change o/p timestamp range " << m_newtimemin << " " <<
2479  timeString(m_newtimemin) << "to " << m_newtimemax << " " <<
2480  timeString(m_newtimemax) << std::endl;
2481  if (m_skipout) {
2482  std::cout << "Skip IOVs extending outside run/LB range [" <<
2483  (m_srunemin >> 32) << "," << (m_srunemin & 0xFFFFFFFF) << "] to [" <<
2484  (m_srunemax >> 32) << "," << (m_srunemax & 0xFFFFFFFF) << "]" <<
2485  std::endl;
2486  }
2487  if (!m_excludechans.empty()) {
2488  for (std::vector<cool::ChannelId>::const_iterator itr=
2489  m_excludechans.begin();itr!=m_excludechans.end();++itr)
2490  std::cout << "Channel " << *itr << " will be excluded" << std::endl;
2491  }
2492  if (m_hitag) std::cout << "All hierarchical tags connecting to referenced tags will be copied" << std::endl;
2493  if (m_nohitag) std::cout << "Hierarchical tag relations will not be copied"
2494  << std::endl;
2495  return 0;
2496 }

◆ setupCatalog()

pool::IFileCatalog * AtlCoolCopy::setupCatalog ( const std::vector< std::string > &  catvec)
staticprivate

Definition at line 3319 of file AtlCoolCopy.cxx.

3320  {
3322  try {
3323  catalog->setWriteCatalog("file:PoolFileCatalog.xml");
3324  for (std::vector<std::string>::const_iterator icat=catvec.begin();
3325  icat!=catvec.end();++icat) {
3326  std::cout << "Add catalogue: " << *icat << std::endl;
3327  // if catalogue contains no ":" specifier, assume plain file
3328  if (icat->find(':')==std::string::npos) {
3329  catalog->addReadCatalog("file:"+(*icat));
3330  } else {
3331  catalog->addReadCatalog(*icat);
3332  }
3333  }
3334  catalog->connect();
3335  catalog->start();
3336  return catalog;
3337  }
3338  catch (std::exception& e) {
3339  std::cout << "Could not setup POOL catalogues, exception:" << e.what()
3340  << std::endl;
3341  return nullptr;
3342  }
3343 }

◆ tagParents()

int AtlCoolCopy::tagParents ( )
private

Definition at line 3035 of file AtlCoolCopy.cxx.

3035  {
3036  std::cout << "Copying additional hierarchical tags of parent folders"
3037  << std::endl;
3038  while (!m_hiparent.empty()) {
3039  // take first element and erase it
3040  std::string folderset=*m_hiparent.begin();
3041  m_hiparent.erase(m_hiparent.begin());
3042  // process any tags defined for this folderset
3043  if (m_sourceDbPtr->existsFolderSet(folderset)) {
3044  cool::IFolderSetPtr sourcefl=m_sourceDbPtr->getFolderSet(folderset);
3045  cool::IFolderSetPtr destfl=m_destDbPtr->getFolderSet(folderset);
3046  std::cout << "Processing folderset " << folderset << std::endl;
3047  for (HiTagMap::const_iterator imap=m_hitagmap.begin();
3048  imap!=m_hitagmap.end();++imap) {
3049  try {
3050  // will throw exception if this tag is not pointing to the folder
3051  std::string sourcetag=sourcefl->findTagRelation(imap->first);
3052  std::cout << "Create hierarchical tag between " << sourcetag <<
3053  " and " << imap->first << " in folder " << imap->second <<
3054  std::endl;
3055  try {
3056  // first check this relation has not already been created
3057  std::string etag=destfl->resolveTag(imap->first);
3058  if (etag==sourcetag) {
3059  std::cout << "This relation has already been created" << std::endl;
3060  } else {
3061  std::cout << "ERROR: Tag in parent already related to " <<
3062  etag << std::endl;
3063  return 34;
3064  }
3065  }
3066  catch (cool::Exception& e ) {
3067  // only do creation if does not already exist - via exception
3068  try {
3069  destfl->createTagRelation(imap->first,sourcetag);
3070  // check if this implicates yet another parent folder to be checked
3071  if (find(m_hiparent.begin(),m_hiparent.end(),imap->second)==
3072  m_hiparent.end()) m_hiparent.push_back(imap->second);
3073  if (m_copytaginfo &&
3074  m_cooltagmap.find(imap->first)==m_cooltagmap.end())
3075  m_cooltagmap.insert(CoolTagMap::value_type(imap->first,
3076  CoolTagInfo(m_sourceDbPtr,imap->second,imap->second,
3077  imap->first,imap->first)));
3078  }
3079  catch (cool::Exception& e) {
3080  std::cout << "Cool exception " << e.what() <<
3081  "thrown in hierarchical tag creation" << std::endl;
3082  return 34;
3083  }
3084  }
3085  }
3086  // exceptions from findTag - do nothing
3087  catch (cool::Exception& e) { }
3088  }
3089  } else {
3090  std::cout << "ERROR Folderset " << folderset << " not found" <<
3091  std::endl;
3092  }
3093  }
3094  return 0;
3095 }

◆ timeString()

std::string AtlCoolCopy::timeString ( const cool::ValidityKey  iovtime)
staticprivate

Definition at line 2572 of file AtlCoolCopy.cxx.

2572  {
2573  if (iovtime==cool::ValidityKeyMin) {
2574  return "ValidityKeyMin ";
2575  } else if (iovtime==cool::ValidityKeyMax) {
2576  return "ValidityKeyMax ";
2577  } else {
2578  time_t time=static_cast<time_t>(iovtime/1E9);
2579  struct tm result;
2580  char buf[32];
2581  return "UTC "+std::string(asctime_r(gmtime_r(&time, &result), buf));
2582  }
2583 }

◆ timeVal()

cool::ValidityKey AtlCoolCopy::timeVal ( const char *  input)
staticprivate

Definition at line 2541 of file AtlCoolCopy.cxx.

2541  {
2542  // convert input char* string to 64bit COOL validityKey
2543  // input either represents a string in seconds, or a date in the form
2544  // yyyy/mm/dd:hh:mm:ss
2545  // first determine if input is a number
2546  if (isNumeric(input)) {
2547  return static_cast<long long>(atol(input))*
2548  static_cast<long long>(1.E9);
2549  } else {
2550  struct tm mytm{},mytm2{};
2551  char* result=strptime(input,"%Y-%m-%d:%T",&mytm);
2552  if (result!=nullptr) {
2553  // make the DST field zero, so the time is interpreted without daylight
2554  // savings time
2555  mytm.tm_isdst=0;
2556  // now have to correct for the local time zone - do this by also
2557  // calculating the time since epoch for 2/1/1970 midnight (no DST)
2558  cool::ValidityKey itime=static_cast<cool::ValidityKey>(mktime(&mytm));
2559  strptime("1970-01-02:00:00:00","%Y-%m-%d:%T",&mytm2);
2560  cool::ValidityKey caltime=static_cast<cool::ValidityKey>(mktime(&mytm2));
2561  itime+=24*60*60-caltime;
2562  return itime*static_cast<cool::ValidityKey>(1.E9);
2563  } else {
2564  std::cout <<
2565  "ERROR in format of time value, use e.g. 2007-05-25:14:01:00" <<
2566  std::endl;
2567  return 0;
2568  }
2569  }
2570 }

◆ transConn()

std::string AtlCoolCopy::transConn ( const std::string &  inconn)
staticprivate

Definition at line 449 of file AtlCoolCopy.cxx.

449  {
450  // translate simple connection string (no slash) to mycool.db with given
451  // instance name, all others are left alone
452  if (inconn.find('/')==std::string::npos) {
453  return "sqlite://X;schema=mycool.db;dbname="+inconn;
454  } else {
455  return inconn;
456  }
457 }

◆ verifyIOVs()

int AtlCoolCopy::verifyIOVs ( const std::string &  folder,
const cool::IFolderPtr &  sourcefl,
const CoraCoolFolderPtr sourceflc,
const cool::IFolderPtr &  destfl,
const CoraCoolFolderPtr destflc,
const std::string &  sourcetag,
const cool::ValidityKey  since,
const cool::ValidityKey  until,
const bool  checkrefs,
const bool  iscora,
const cool::PayloadMode::Mode  paymode 
)
private

Definition at line 1355 of file AtlCoolCopy.cxx.

1361  {
1362 
1363  std::cout << "Verifying tag " << sourcetag << " of folder " << folder <<
1364  std::endl;
1365  destfl->setPrefetchAll(false);
1366  cool::FolderVersioning::Mode vermode=sourcefl->versioningMode();
1367  int nobj=0;
1368  cool::IObjectIteratorPtr sourceitr,destitr;
1369  CoraCoolObjectIterPtr csourceitr,cdestitr;
1370  std::string tag=sourcetag;
1371  if (vermode==cool::FolderVersioning::SINGLE_VERSION || sourcetag=="HEAD")
1372  tag="";
1373  try {
1374  if (iscora) {
1375  sourceflc->setPrefetchAll(false);
1376  csourceitr=sourceflc->browseObjects(since,until,m_chansel,tag);
1377  cdestitr=destflc->browseObjects(since,until,m_chansel,tag);
1378  } else {
1379  sourceitr=sourcefl->browseObjects(since,until,m_chansel,tag);
1380  destitr=destfl->browseObjects(since,until,m_chansel,tag);
1381  }
1382  }
1383  catch (std::exception& e) {
1384  std::cout << "Exception thrown from verify iterator setup: " << e.what() <<
1385  std::endl;
1386  return 105;
1387  }
1388  try {
1389  // the check algorithm assumes the two databases will give back the
1390  // results of the query in the same order, which is currently the
1391  // case in COOL 1.3. If this changes, the verification will be more complex
1392  if (iscora) {
1393  const std::string& cfkey=sourceflc->coralFKey();
1394  const std::string& cpkey=sourceflc->coralPKey();
1395  while (csourceitr->hasNext()) {
1396  CoraCoolObjectPtr sobj=csourceitr->next();
1397  // check object should not be skipped as excluded channel
1398  if (!m_excludechans.empty()) {
1399  if (find(m_excludechans.begin(),m_excludechans.end(),
1400  sobj->channelId())!=m_excludechans.end()) {
1401  continue;
1402  }
1403  }
1404  if (cdestitr->hasNext()) {
1405  CoraCoolObjectPtr dobj=cdestitr->next();
1406  // check objects are the same
1407  int iret=0;
1408  // check IOV equality
1409  if (sobj->since()!=dobj->since() || sobj->until()!=dobj->until())
1410  iret=100;
1411  // check channel equality
1412  if (sobj->channelId()!=dobj->channelId())
1413  iret=101;
1414  // check size of payloads
1415  if (sobj->size()!=dobj->size()) {
1416  std::cout << "ERROR CoraCool object " << nobj <<
1417  " sizes do not match: " << sobj->size() << " " << dobj->size()
1418  << std::endl;
1419  iret=102;
1420  }
1421  // check payload equality (does not check attribute names)
1422  CoraCoolObject::const_iterator ditr=dobj->begin();
1423  for (CoraCoolObject::const_iterator sitr=sobj->begin();
1424  sitr!=sobj->end();++sitr,++ditr) {
1425  // loop over all the attributes, in order to skip PK and FK
1426  for (coral::AttributeList::const_iterator aitr=sitr->begin();
1427  aitr!=sitr->end();++aitr) {
1428  const std::string& aname=aitr->specification().name();
1429  if (aname!=cfkey && aname!=cpkey) {
1430  try {
1431  if (*aitr!=(*ditr)[aname]) {
1432  std::cout << "ERROR Values of attriute " << aname <<
1433  " differ" << std::endl;
1434  iret=102;
1435  }
1436  }
1437  catch (coral::AttributeListException& e) {
1438  std::cout << "ERROR: CoraCool attribute " << aname <<
1439  " not found in destination!" << std::endl;
1440  iret=102;
1441  }
1442  }
1443  }
1444  }
1445  if (iret!=0) {
1446  std::cout << "ERROR database entries do not match: since: " <<
1447  sobj->since() << "," << dobj->since() << " until: " <<
1448  sobj->until() << "," << dobj->until() << " channel: " <<
1449  sobj->channelId() << "," << dobj->channelId() << std::endl;
1450  return iret;
1451  }
1452  } else {
1453  std::cout <<
1454  "ERROR destination folder no matching CoraCool iterator for object "
1455  << nobj << std::endl;
1456  return 103;
1457  }
1458  ++ nobj;
1459  }
1460  } else {
1461  while (sourceitr->goToNext()) {
1462  const cool::IObject& sobj=sourceitr->currentRef();
1463  // check object should not be skipped as excluded channel
1464  if (!m_excludechans.empty()) {
1465  if (find(m_excludechans.begin(),m_excludechans.end(),
1466  sobj.channelId())!=m_excludechans.end()) {
1467  continue;
1468  }
1469  }
1470  if (checkrefs) checkRef(sobj.payload(),folder,sourcetag);
1471  if (destitr->goToNext()) {
1472  const cool::IObject& dobj=destitr->currentRef();
1473  // check objects are the same
1474  int iret=0;
1475  // check IOV equality
1476  if (sobj.since()!=dobj.since() || sobj.until()!=dobj.until())
1477  iret=100;
1478  // check channel equality
1479  if (sobj.channelId()!=dobj.channelId())
1480  iret=101;
1481  // check payload equality (does not check attribute names)
1482  // do not use cool::IRecord equality operator as does not correctly
1483  // handle null values
1484  if (paymode==cool::PayloadMode::VECTORPAYLOAD) {
1485  cool::IRecordIterator& spitr=sobj.payloadIterator();
1486  const cool::IRecordVectorPtr svptr=spitr.fetchAllAsVector();
1487  cool::IRecordIterator& dpitr=dobj.payloadIterator();
1488  const cool::IRecordVectorPtr dvptr=dpitr.fetchAllAsVector();
1489  if (svptr->size()!=dvptr->size()) {
1490  iret=102;
1491  } else {
1492  // loop through the payloads, checking equality - assumes
1493  // order is significant and same in source and destination DBs
1494  cool::IRecordVector::const_iterator svitr=svptr->begin();
1495  cool::IRecordVector::const_iterator svend=svptr->end();
1496  cool::IRecordVector::const_iterator dvitr=dvptr->begin();
1497  for (;svitr!=svend;++svitr,++dvitr) {
1498  if (!equalRecord(**svitr,**dvitr)) iret=102;
1499  }
1500  }
1501  if (iret!=0) {
1502  std::cout << "ERROR vector payloads do not match (size " << svptr->size() << "," << dvptr->size() << ")" << std::endl;
1503  }
1504 
1505  } else {
1506  // standard COOL folder - simple check of payloads
1507  if (!equalRecord(sobj.payload(),dobj.payload())) iret=102;
1508  }
1509 
1510  if (iret!=0) {
1511  std::cout << "ERROR database entries do not match: since: " <<
1512  sobj.since() << "," << dobj.since() << " until: " <<
1513  sobj.until() << "," << dobj.until() << " channel: " <<
1514  sobj.channelId() << "," << dobj.channelId() << std::endl;
1515  std::cout << "Source payload:" << std::endl;
1516  sobj.payload().attributeList().toOutputStream(std::cout);
1517  std::cout << std::endl << "Destination payload:" << std::endl;
1518  dobj.payload().attributeList().toOutputStream(std::cout);
1519  std::cout << std::endl;
1520  return iret;
1521  }
1522  } else {
1523  std::cout <<
1524  "ERROR destination folder no matching iterator for object "
1525  << nobj << std::endl;
1526  return 103;
1527  }
1528  ++nobj;
1529  }
1530  }
1531  }
1532  catch (cool::Exception& e) {
1533  std::cout << "Exception thrown from verify loop: " << e.what() <<
1534  std::endl;
1535  return 104;
1536  }
1537  // finished with the iterators
1538  if (iscora) {
1539  } else {
1540  sourceitr->close();
1541  destitr->close();
1542  }
1543  std::cout << "Verification of folder " << folder << " tag " <<
1544  sourcetag << " OK (" << nobj << " objects)" << std::endl;
1545  return 0;
1546 }

◆ writeTagInfo()

int AtlCoolCopy::writeTagInfo ( )
private

Definition at line 3097 of file AtlCoolCopy.cxx.

3097  {
3098  std::cout << "Write tag description ";
3099  if (m_copytaglock) std::cout << "and lock info ";
3100  std::cout << "for " << m_cooltagmap.size() << " tags" << std::endl;
3101  for (CoolTagMap::const_iterator itr=m_cooltagmap.begin();
3102  itr!=m_cooltagmap.end();++itr) {
3103  itr->second.write(m_destDbPtr,m_copytaglock);
3104  }
3105  return 0;
3106 }

Member Data Documentation

◆ m_addguid

std::vector<std::string> AtlCoolCopy::m_addguid
private

Definition at line 244 of file AtlCoolCopy.cxx.

◆ m_addlfn

std::vector<std::string> AtlCoolCopy::m_addlfn
private

Definition at line 245 of file AtlCoolCopy.cxx.

◆ m_alliov

bool AtlCoolCopy::m_alliov
private

Definition at line 180 of file AtlCoolCopy.cxx.

◆ m_allowcreate

bool AtlCoolCopy::m_allowcreate
private

Definition at line 173 of file AtlCoolCopy.cxx.

◆ m_anadelt

long long AtlCoolCopy::m_anadelt
private

Definition at line 236 of file AtlCoolCopy.cxx.

◆ m_analyse

bool AtlCoolCopy::m_analyse
private

Definition at line 184 of file AtlCoolCopy.cxx.

◆ m_applock

bool AtlCoolCopy::m_applock
private

Definition at line 205 of file AtlCoolCopy.cxx.

◆ m_applocksv

bool AtlCoolCopy::m_applocksv
private

Definition at line 206 of file AtlCoolCopy.cxx.

◆ m_bufsize

int AtlCoolCopy::m_bufsize
private

Definition at line 234 of file AtlCoolCopy.cxx.

◆ m_channel1

std::string AtlCoolCopy::m_channel1
private

Definition at line 232 of file AtlCoolCopy.cxx.

◆ m_channel2

std::string AtlCoolCopy::m_channel2
private

Definition at line 233 of file AtlCoolCopy.cxx.

◆ m_channelRange

std::vector<std::string> AtlCoolCopy::m_channelRange
private

Definition at line 231 of file AtlCoolCopy.cxx.

◆ m_chansel

cool::ChannelSelection AtlCoolCopy::m_chansel
private

Definition at line 267 of file AtlCoolCopy.cxx.

◆ m_chdesc

bool AtlCoolCopy::m_chdesc
private

Definition at line 192 of file AtlCoolCopy.cxx.

◆ m_checkdesttag

bool AtlCoolCopy::m_checkdesttag
private

Definition at line 219 of file AtlCoolCopy.cxx.

◆ m_checkoutputfile

std::string AtlCoolCopy::m_checkoutputfile
private

Definition at line 240 of file AtlCoolCopy.cxx.

◆ m_checkrefs

bool AtlCoolCopy::m_checkrefs
private

Definition at line 185 of file AtlCoolCopy.cxx.

◆ m_coolapp

cool::Application AtlCoolCopy::m_coolapp
private

Definition at line 253 of file AtlCoolCopy.cxx.

◆ m_cooltagmap

CoolTagMap AtlCoolCopy::m_cooltagmap
private

Definition at line 279 of file AtlCoolCopy.cxx.

◆ m_copytaginfo

bool AtlCoolCopy::m_copytaginfo
private

Definition at line 214 of file AtlCoolCopy.cxx.

◆ m_copytaglock

bool AtlCoolCopy::m_copytaglock
private

Definition at line 215 of file AtlCoolCopy.cxx.

◆ m_coracool

bool AtlCoolCopy::m_coracool
private

Definition at line 216 of file AtlCoolCopy.cxx.

◆ m_coralsvc

coral::ConnectionService AtlCoolCopy::m_coralsvc
private

Definition at line 252 of file AtlCoolCopy.cxx.

◆ m_dbSvc

cool::IDatabaseSvc* AtlCoolCopy::m_dbSvc
private

Definition at line 254 of file AtlCoolCopy.cxx.

◆ m_debug

bool AtlCoolCopy::m_debug
private

Definition at line 179 of file AtlCoolCopy.cxx.

◆ m_destCoraPtr

CoraCoolDatabasePtr AtlCoolCopy::m_destCoraPtr
private

Definition at line 259 of file AtlCoolCopy.cxx.

◆ m_destdb

std::string AtlCoolCopy::m_destdb
private

Definition at line 172 of file AtlCoolCopy.cxx.

◆ m_destDbPtr

cool::IDatabasePtr AtlCoolCopy::m_destDbPtr
private

Definition at line 257 of file AtlCoolCopy.cxx.

◆ m_excludechans

std::vector<cool::ChannelId> AtlCoolCopy::m_excludechans
private

Definition at line 247 of file AtlCoolCopy.cxx.

◆ m_excludehead

bool AtlCoolCopy::m_excludehead
private

Definition at line 176 of file AtlCoolCopy.cxx.

◆ m_folderexcl

std::vector<std::string> AtlCoolCopy::m_folderexcl
private

Definition at line 261 of file AtlCoolCopy.cxx.

◆ m_folderlist

std::vector<std::string> AtlCoolCopy::m_folderlist
private

Definition at line 260 of file AtlCoolCopy.cxx.

◆ m_forcemulti

bool AtlCoolCopy::m_forcemulti
private

Definition at line 196 of file AtlCoolCopy.cxx.

◆ m_forcenopay

bool AtlCoolCopy::m_forcenopay
private

Definition at line 200 of file AtlCoolCopy.cxx.

◆ m_forcepay

bool AtlCoolCopy::m_forcepay
private

Definition at line 199 of file AtlCoolCopy.cxx.

◆ m_forcerune

bool AtlCoolCopy::m_forcerune
private

Definition at line 197 of file AtlCoolCopy.cxx.

◆ m_forcesingle

bool AtlCoolCopy::m_forcesingle
private

Definition at line 195 of file AtlCoolCopy.cxx.

◆ m_forcetime

bool AtlCoolCopy::m_forcetime
private

Definition at line 198 of file AtlCoolCopy.cxx.

◆ m_getbulk

bool AtlCoolCopy::m_getbulk
private

Definition at line 211 of file AtlCoolCopy.cxx.

◆ m_getonline

bool AtlCoolCopy::m_getonline
private

Definition at line 209 of file AtlCoolCopy.cxx.

◆ m_gettime

bool AtlCoolCopy::m_gettime
private

Definition at line 208 of file AtlCoolCopy.cxx.

◆ m_hiparent

std::vector<std::string> AtlCoolCopy::m_hiparent
private

Definition at line 275 of file AtlCoolCopy.cxx.

◆ m_hitag

bool AtlCoolCopy::m_hitag
private

Definition at line 193 of file AtlCoolCopy.cxx.

◆ m_hitagmap

HiTagMap AtlCoolCopy::m_hitagmap
private

Definition at line 273 of file AtlCoolCopy.cxx.

◆ m_ignoremode

bool AtlCoolCopy::m_ignoremode
private

Definition at line 217 of file AtlCoolCopy.cxx.

◆ m_ignorespec

bool AtlCoolCopy::m_ignorespec
private

Definition at line 218 of file AtlCoolCopy.cxx.

◆ m_includehead

bool AtlCoolCopy::m_includehead
private

Definition at line 175 of file AtlCoolCopy.cxx.

◆ m_listpfn

bool AtlCoolCopy::m_listpfn
private

Definition at line 186 of file AtlCoolCopy.cxx.

◆ m_lockedonly

bool AtlCoolCopy::m_lockedonly
private

Definition at line 213 of file AtlCoolCopy.cxx.

◆ m_magic

std::vector<std::string> AtlCoolCopy::m_magic
private

Definition at line 263 of file AtlCoolCopy.cxx.

◆ m_mergecat

std::vector<std::string> AtlCoolCopy::m_mergecat
private

Definition at line 265 of file AtlCoolCopy.cxx.

◆ m_newdataset

std::string AtlCoolCopy::m_newdataset
private

Definition at line 239 of file AtlCoolCopy.cxx.

◆ m_newrunemax

cool::ValidityKey AtlCoolCopy::m_newrunemax
private

Definition at line 226 of file AtlCoolCopy.cxx.

◆ m_newrunemin

cool::ValidityKey AtlCoolCopy::m_newrunemin
private

Definition at line 225 of file AtlCoolCopy.cxx.

◆ m_newtimemax

cool::ValidityKey AtlCoolCopy::m_newtimemax
private

Definition at line 228 of file AtlCoolCopy.cxx.

◆ m_newtimemin

cool::ValidityKey AtlCoolCopy::m_newtimemin
private

Definition at line 227 of file AtlCoolCopy.cxx.

◆ m_nochannel

bool AtlCoolCopy::m_nochannel
private

Definition at line 191 of file AtlCoolCopy.cxx.

◆ m_noclobroot

bool AtlCoolCopy::m_noclobroot
private

Definition at line 220 of file AtlCoolCopy.cxx.

◆ m_nocopy

bool AtlCoolCopy::m_nocopy
private

Definition at line 189 of file AtlCoolCopy.cxx.

◆ m_nodata

bool AtlCoolCopy::m_nodata
private

Definition at line 190 of file AtlCoolCopy.cxx.

◆ m_nohitag

bool AtlCoolCopy::m_nohitag
private

Definition at line 194 of file AtlCoolCopy.cxx.

◆ m_nt_bufferptr

std::vector<void*> AtlCoolCopy::m_nt_bufferptr
private

Definition at line 293 of file AtlCoolCopy.cxx.

◆ m_nt_channel

UInt_t AtlCoolCopy::m_nt_channel = 0
private

Definition at line 290 of file AtlCoolCopy.cxx.

◆ m_nt_lbsince

UInt_t AtlCoolCopy::m_nt_lbsince = 0
private

Definition at line 288 of file AtlCoolCopy.cxx.

◆ m_nt_lbuntil

UInt_t AtlCoolCopy::m_nt_lbuntil = 0
private

Definition at line 289 of file AtlCoolCopy.cxx.

◆ m_nt_runsince

UInt_t AtlCoolCopy::m_nt_runsince = 0
private

Definition at line 286 of file AtlCoolCopy.cxx.

◆ m_nt_rununtil

UInt_t AtlCoolCopy::m_nt_rununtil = 0
private

Definition at line 287 of file AtlCoolCopy.cxx.

◆ m_nt_since

ULong64_t AtlCoolCopy::m_nt_since = 0
private

Definition at line 284 of file AtlCoolCopy.cxx.

◆ m_nt_tagid

char AtlCoolCopy::m_nt_tagid[256] = {0}
private

Definition at line 291 of file AtlCoolCopy.cxx.

◆ m_nt_treename

std::string AtlCoolCopy::m_nt_treename
private

Definition at line 292 of file AtlCoolCopy.cxx.

◆ m_nt_until

ULong64_t AtlCoolCopy::m_nt_until = 0
private

Definition at line 285 of file AtlCoolCopy.cxx.

◆ m_onlinerun

bool AtlCoolCopy::m_onlinerun
private

Definition at line 210 of file AtlCoolCopy.cxx.

◆ m_open

bool AtlCoolCopy::m_open
private

Definition at line 266 of file AtlCoolCopy.cxx.

◆ m_outfolder

std::string AtlCoolCopy::m_outfolder
private

Definition at line 237 of file AtlCoolCopy.cxx.

◆ m_outtag

std::string AtlCoolCopy::m_outtag
private

Definition at line 238 of file AtlCoolCopy.cxx.

◆ m_parfile

std::vector<std::string> AtlCoolCopy::m_parfile
private

Definition at line 246 of file AtlCoolCopy.cxx.

◆ m_poolall

bool AtlCoolCopy::m_poolall
private

Definition at line 188 of file AtlCoolCopy.cxx.

◆ m_poolcat

std::vector<std::string> AtlCoolCopy::m_poolcat
private

Definition at line 264 of file AtlCoolCopy.cxx.

◆ m_poollast

PoolMap::iterator AtlCoolCopy::m_poollast
private

Definition at line 269 of file AtlCoolCopy.cxx.

◆ m_poolopen

bool AtlCoolCopy::m_poolopen
private

Definition at line 187 of file AtlCoolCopy.cxx.

◆ m_poolrefs

PoolMap AtlCoolCopy::m_poolrefs
private

Definition at line 270 of file AtlCoolCopy.cxx.

◆ m_prunetags

bool AtlCoolCopy::m_prunetags
private

Definition at line 212 of file AtlCoolCopy.cxx.

◆ m_readoracle

bool AtlCoolCopy::m_readoracle
private

Definition at line 207 of file AtlCoolCopy.cxx.

◆ m_recreate

bool AtlCoolCopy::m_recreate
private

Definition at line 174 of file AtlCoolCopy.cxx.

◆ m_repsort

ReplicaSorter* AtlCoolCopy::m_repsort
private

Definition at line 255 of file AtlCoolCopy.cxx.

◆ m_root

bool AtlCoolCopy::m_root
private

Definition at line 182 of file AtlCoolCopy.cxx.

◆ m_runemax

cool::ValidityKey AtlCoolCopy::m_runemax
private

Definition at line 222 of file AtlCoolCopy.cxx.

◆ m_runemin

cool::ValidityKey AtlCoolCopy::m_runemin
private

Definition at line 221 of file AtlCoolCopy.cxx.

◆ m_runfile

std::vector<std::string> AtlCoolCopy::m_runfile
private

Definition at line 248 of file AtlCoolCopy.cxx.

◆ m_runinfohost

std::string AtlCoolCopy::m_runinfohost
private

Definition at line 243 of file AtlCoolCopy.cxx.

◆ m_runlist

std::vector<unsigned int> AtlCoolCopy::m_runlist
private

Definition at line 249 of file AtlCoolCopy.cxx.

◆ m_sealmsg

int AtlCoolCopy::m_sealmsg
private

Definition at line 235 of file AtlCoolCopy.cxx.

◆ m_skipout

bool AtlCoolCopy::m_skipout
private

Definition at line 203 of file AtlCoolCopy.cxx.

◆ m_skiprep

bool AtlCoolCopy::m_skiprep
private

Definition at line 204 of file AtlCoolCopy.cxx.

◆ m_sourceCoraPtr

CoraCoolDatabasePtr AtlCoolCopy::m_sourceCoraPtr
private

Definition at line 258 of file AtlCoolCopy.cxx.

◆ m_sourcedb

std::string AtlCoolCopy::m_sourcedb
private

Definition at line 171 of file AtlCoolCopy.cxx.

◆ m_sourceDbPtr

cool::IDatabasePtr AtlCoolCopy::m_sourceDbPtr
private

Definition at line 256 of file AtlCoolCopy.cxx.

◆ m_sourceread

bool AtlCoolCopy::m_sourceread
private

Definition at line 201 of file AtlCoolCopy.cxx.

◆ m_srunemax

cool::ValidityKey AtlCoolCopy::m_srunemax
private

Definition at line 230 of file AtlCoolCopy.cxx.

◆ m_srunemin

cool::ValidityKey AtlCoolCopy::m_srunemin
private

Definition at line 229 of file AtlCoolCopy.cxx.

◆ m_taglabel

std::string AtlCoolCopy::m_taglabel
private

Definition at line 242 of file AtlCoolCopy.cxx.

◆ m_tags

std::vector<std::string> AtlCoolCopy::m_tags
private

Definition at line 262 of file AtlCoolCopy.cxx.

◆ m_timedb

std::string AtlCoolCopy::m_timedb
private

Definition at line 241 of file AtlCoolCopy.cxx.

◆ m_timemax

cool::ValidityKey AtlCoolCopy::m_timemax
private

Definition at line 224 of file AtlCoolCopy.cxx.

◆ m_timemin

cool::ValidityKey AtlCoolCopy::m_timemin
private

Definition at line 223 of file AtlCoolCopy.cxx.

◆ m_truncate

bool AtlCoolCopy::m_truncate
private

Definition at line 202 of file AtlCoolCopy.cxx.

◆ m_usertags

bool AtlCoolCopy::m_usertags
private

Definition at line 177 of file AtlCoolCopy.cxx.

◆ m_userupdatehead

bool AtlCoolCopy::m_userupdatehead
private

Definition at line 178 of file AtlCoolCopy.cxx.

◆ m_verify

bool AtlCoolCopy::m_verify
private

Definition at line 181 of file AtlCoolCopy.cxx.

◆ m_zeronull

bool AtlCoolCopy::m_zeronull
private

Definition at line 183 of file AtlCoolCopy.cxx.

◆ p_rootfile

TFile* AtlCoolCopy::p_rootfile
private

Definition at line 281 of file AtlCoolCopy.cxx.


The documentation for this class was generated from the following file:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
AtlCoolCopy::runLBVal
static cool::ValidityKey runLBVal(const char *input1, const char *input2)
Definition: AtlCoolCopy.cxx:2585
AtlCoolCopy::channelID
static cool::ChannelId channelID(const cool::IFolderPtr &folder, const std::string &chanstring)
Definition: AtlCoolCopy.cxx:855
AtlCoolCopy::m_skipout
bool m_skipout
Definition: AtlCoolCopy.cxx:203
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
AtlCoolCopy::rootWrite
void rootWrite(void *sptr, const cool::IField &field) const
Definition: AtlCoolCopy.cxx:1771
AtlCoolCopy::m_magic
std::vector< std::string > m_magic
Definition: AtlCoolCopy.cxx:263
AtlCoolCopy::m_getbulk
bool m_getbulk
Definition: AtlCoolCopy.cxx:211
AtlCoolCopy::m_nt_rununtil
UInt_t m_nt_rununtil
Definition: AtlCoolCopy.cxx:287
AtlCoolCopy::m_outtag
std::string m_outtag
Definition: AtlCoolCopy.cxx:238
get_generator_info.result
result
Definition: get_generator_info.py:21
AtlCoolCopy::m_channel1
std::string m_channel1
Definition: AtlCoolCopy.cxx:232
python.rtime.rtime
def rtime(fn, *args, **kw)
Definition: rtime.py:15
AtlCoolCopy::m_verify
bool m_verify
Definition: AtlCoolCopy.cxx:181
AtlCoolCopy::m_nt_lbuntil
UInt_t m_nt_lbuntil
Definition: AtlCoolCopy.cxx:289
AtlCoolCopy::m_srunemax
cool::ValidityKey m_srunemax
Definition: AtlCoolCopy.cxx:230
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
CoraCoolDatabase
Definition: CoraCoolDatabase.h:24
AtlCoolCopy::m_coralsvc
coral::ConnectionService m_coralsvc
Definition: AtlCoolCopy.cxx:252
json
nlohmann::json json
Definition: HistogramDef.cxx:9
AtlCoolCopy::m_copytaglock
bool m_copytaglock
Definition: AtlCoolCopy.cxx:215
AtlCoolCopy::getTimeFromRun
bool getTimeFromRun()
Definition: AtlCoolCopy.cxx:2604
response
MDT_Response response
Definition: MDT_ResponseTest.cxx:28
CaloCondBlobAlgs_fillNoiseFromASCII.spec
spec
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:46
AtlCoolCopy::m_readoracle
bool m_readoracle
Definition: AtlCoolCopy.cxx:207
xAOD::short
short
Definition: Vertex_v1.cxx:165
AtlCoolCopy::m_destdb
std::string m_destdb
Definition: AtlCoolCopy.cxx:172
AtlCoolCopy::m_repsort
ReplicaSorter * m_repsort
Definition: AtlCoolCopy.cxx:255
AtlCoolCopy::m_getonline
bool m_getonline
Definition: AtlCoolCopy.cxx:209
mergePhysValFiles.newfolder
newfolder
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:82
AtlCoolCopy::m_checkoutputfile
std::string m_checkoutputfile
Definition: AtlCoolCopy.cxx:240
defineDB.ichan
ichan
Definition: JetTagCalibration/share/defineDB.py:28
xAOD::char
char
Definition: TrigDecision_v1.cxx:38
parse
std::map< std::string, std::string > parse(const std::string &list)
Definition: egammaLayerRecalibTool.cxx:1113
extractSporadic.c1
c1
Definition: extractSporadic.py:133
tree
TChain * tree
Definition: tile_monitor.h:30
AtlCoolCopy::m_excludehead
bool m_excludehead
Definition: AtlCoolCopy.cxx:176
dirname
std::string dirname(std::string name)
Definition: utils.cxx:200
AtlCoolCopy::rootDirs
std::string rootDirs(const std::string &folder, const std::string &toproot)
Definition: AtlCoolCopy.cxx:1681
AtlCoolCopy::m_truncate
bool m_truncate
Definition: AtlCoolCopy.cxx:202
AtlCoolCopy::m_timemax
cool::ValidityKey m_timemax
Definition: AtlCoolCopy.cxx:224
bin
Definition: BinsDiffFromStripMedian.h:43
AtlCoolCopy::m_hitag
bool m_hitag
Definition: AtlCoolCopy.cxx:193
AtlCoolCopy::m_chansel
cool::ChannelSelection m_chansel
Definition: AtlCoolCopy.cxx:267
PlotCalibFromCool.nchan
nchan
Definition: PlotCalibFromCool.py:564
AtlCoolCopy::openConnections
bool openConnections(const std::string &sourcedb, const std::string &destdb, bool allowcreate)
Definition: AtlCoolCopy.cxx:339
AtlCoolCopy::m_userupdatehead
bool m_userupdatehead
Definition: AtlCoolCopy.cxx:178
python.subdetectors.tile.Blob
Blob
Definition: tile.py:17
AtlCoolCopy::m_parfile
std::vector< std::string > m_parfile
Definition: AtlCoolCopy.cxx:246
AtlCoolCopy::m_hitagmap
HiTagMap m_hitagmap
Definition: AtlCoolCopy.cxx:273
AtlCoolCopy::m_dbSvc
cool::IDatabaseSvc * m_dbSvc
Definition: AtlCoolCopy.cxx:254
exclude
std::set< std::string > exclude
list of directories to be excluded
Definition: hcg.cxx:95
ReadOfcFromCool.field
field
Definition: ReadOfcFromCool.py:48
AtlCoolCopy::m_newrunemin
cool::ValidityKey m_newrunemin
Definition: AtlCoolCopy.cxx:225
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
AtlCoolCopy::m_usertags
bool m_usertags
Definition: AtlCoolCopy.cxx:177
AtlCoolCopy::m_srunemin
cool::ValidityKey m_srunemin
Definition: AtlCoolCopy.cxx:229
AtlCoolCopy::m_sourcedb
std::string m_sourcedb
Definition: AtlCoolCopy.cxx:171
CaloSwCorrections.gap
def gap(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:212
AtlCoolCopy::m_forcemulti
bool m_forcemulti
Definition: AtlCoolCopy.cxx:196
physics_parameters.url
string url
Definition: physics_parameters.py:27
AtlCoolCopy::equalRecord
static bool equalRecord(const cool::IRecord &lhs, const cool::IRecord &rhs)
Definition: AtlCoolCopy.cxx:2509
dq_defect_bulk_create_defects.line
line
Definition: dq_defect_bulk_create_defects.py:27
AtlCoolCopy::m_ignoremode
bool m_ignoremode
Definition: AtlCoolCopy.cxx:217
atlasStyleMacro.icol
int icol
Definition: atlasStyleMacro.py:13
AtlCoolCopy::m_newtimemax
cool::ValidityKey m_newtimemax
Definition: AtlCoolCopy.cxx:228
dq_defect_copy_defect_database.channels
def channels
Definition: dq_defect_copy_defect_database.py:56
AtlCoolCopy::timeVal
static cool::ValidityKey timeVal(const char *input)
Definition: AtlCoolCopy.cxx:2541
AtlCoolCopy::m_coracool
bool m_coracool
Definition: AtlCoolCopy.cxx:216
AtlCoolCopy::m_applocksv
bool m_applocksv
Definition: AtlCoolCopy.cxx:206
python.Dumpers.aname
string aname
Definition: Dumpers.py:5543
dq_defect_copy_defect_database.since
def since
Definition: dq_defect_copy_defect_database.py:54
AtlCoolCopy::m_forcesingle
bool m_forcesingle
Definition: AtlCoolCopy.cxx:195
AtlCoolCopy::m_gettime
bool m_gettime
Definition: AtlCoolCopy.cxx:208
AtlCoolCopy::checkRef
void checkRef(const cool::IRecord &payload, const std::string &folder, const std::string &tag)
Definition: AtlCoolCopy.cxx:2998
dq_defect_copy_defect_database.until
def until
Definition: dq_defect_copy_defect_database.py:55
AtlCoolCopy::m_checkrefs
bool m_checkrefs
Definition: AtlCoolCopy.cxx:185
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
AtlCoolCopy::m_poolrefs
PoolMap m_poolrefs
Definition: AtlCoolCopy.cxx:270
skel.input1
tuple input1
Definition: skel.GENtoEVGEN.py:775
AtlCoolCopy::m_nt_lbsince
UInt_t m_nt_lbsince
Definition: AtlCoolCopy.cxx:288
AtlCoolCopy::m_newrunemax
cool::ValidityKey m_newrunemax
Definition: AtlCoolCopy.cxx:226
CoraCoolObject::const_iterator
AttrListVec::const_iterator const_iterator
Definition: CoraCoolObject.h:23
AtlCoolCopy::m_nt_since
ULong64_t m_nt_since
Definition: AtlCoolCopy.cxx:284
AtlCoolCopy::m_nohitag
bool m_nohitag
Definition: AtlCoolCopy.cxx:194
pool::IFileCatalog
Definition: IFileCatalog.h:23
AtlCoolCopy::m_open
bool m_open
Definition: AtlCoolCopy.cxx:266
CaloCondBlobAlgs_fillNoiseFromASCII.desc
desc
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:53
AtlCoolCopy::m_poolall
bool m_poolall
Definition: AtlCoolCopy.cxx:188
AtlCoolCopy::m_nt_runsince
UInt_t m_nt_runsince
Definition: AtlCoolCopy.cxx:286
ParseInputs.gDirectory
gDirectory
Definition: Final2012/ParseInputs.py:133
AtlCoolCopy::m_skiprep
bool m_skiprep
Definition: AtlCoolCopy.cxx:204
lumiFormat.i
int i
Definition: lumiFormat.py:85
python.DecayParser.buf
buf
print ("=> [%s]"cmd)
Definition: DecayParser.py:27
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
LArCellNtuple.argv
argv
Definition: LArCellNtuple.py:152
python.LArBadChannelDBAlg.xFFFFFFFF
xFFFFFFFF
Definition: LArBadChannelDBAlg.py:73
AtlCoolCopy::m_alliov
bool m_alliov
Definition: AtlCoolCopy.cxx:180
AtlCoolCopy::m_nt_until
ULong64_t m_nt_until
Definition: AtlCoolCopy.cxx:285
AtlCoolCopy::m_channelRange
std::vector< std::string > m_channelRange
Definition: AtlCoolCopy.cxx:231
AtlCoolCopy::m_channel2
std::string m_channel2
Definition: AtlCoolCopy.cxx:233
AtlCoolCopy::m_ignorespec
bool m_ignorespec
Definition: AtlCoolCopy.cxx:218
AtlCoolCopy::m_checkdesttag
bool m_checkdesttag
Definition: AtlCoolCopy.cxx:219
AtlCoolCopy::m_poolcat
std::vector< std::string > m_poolcat
Definition: AtlCoolCopy.cxx:264
pool::IFileCatalog::start
void start()
redirect to init() for Gaudi FC
Definition: IFileCatalog.h:45
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
calibdata.exception
exception
Definition: calibdata.py:495
res
std::pair< std::vector< unsigned int >, bool > res
Definition: JetGroupProductTest.cxx:11
AtlCoolCopy::m_sourceread
bool m_sourceread
Definition: AtlCoolCopy.cxx:201
AtlCoolCopy::m_debug
bool m_debug
Definition: AtlCoolCopy.cxx:179
file
TFile * file
Definition: tile_monitor.h:29
AtlCoolCopy::m_excludechans
std::vector< cool::ChannelId > m_excludechans
Definition: AtlCoolCopy.cxx:247
AtlCoolCopy::m_outfolder
std::string m_outfolder
Definition: AtlCoolCopy.cxx:237
Preparation.mode
mode
Definition: Preparation.py:107
pool::IFileCatalog::setWriteCatalog
void setWriteCatalog(const std::string &connect)
Access to the (first) writable file catalog.
run
Definition: run.py:1
AtlCoolCopy::m_lockedonly
bool m_lockedonly
Definition: AtlCoolCopy.cxx:213
DQHistogramMergeRegExp.argc
argc
Definition: DQHistogramMergeRegExp.py:19
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
AtlCoolCopy::m_coolapp
cool::Application m_coolapp
Definition: AtlCoolCopy.cxx:253
AtlCoolCopy::m_listpfn
bool m_listpfn
Definition: AtlCoolCopy.cxx:186
AtlCoolCopy::procOptVector
bool procOptVector(const int argc, const char *argv[], std::vector< std::string > &folders)
Definition: AtlCoolCopy.cxx:2131
AtlCoolCopy::m_forcerune
bool m_forcerune
Definition: AtlCoolCopy.cxx:197
AtlCoolCopy::m_sourceDbPtr
cool::IDatabasePtr m_sourceDbPtr
Definition: AtlCoolCopy.cxx:256
pool::IFileCatalog::connect
void connect()
Definition: IFileCatalog.h:39
AtlCoolCopy::m_runemax
cool::ValidityKey m_runemax
Definition: AtlCoolCopy.cxx:222
AtlCoolCopy::m_folderlist
std::vector< std::string > m_folderlist
Definition: AtlCoolCopy.cxx:260
AtlCoolCopy::m_poolopen
bool m_poolopen
Definition: AtlCoolCopy.cxx:187
AtlCoolCopy::m_runlist
std::vector< unsigned int > m_runlist
Definition: AtlCoolCopy.cxx:249
CxxUtils::atof
double atof(std::string_view str)
Converts a string into a double / float.
Definition: Control/CxxUtils/Root/StringUtils.cxx:91
grepfile.ic
int ic
Definition: grepfile.py:33
AtlCoolCopy::m_onlinerun
bool m_onlinerun
Definition: AtlCoolCopy.cxx:210
CoraCoolDatabasePtr
boost::shared_ptr< CoraCoolDatabase > CoraCoolDatabasePtr
Definition: CoraCoolTypes.h:12
AtlCoolCopy::m_sealmsg
int m_sealmsg
Definition: AtlCoolCopy.cxx:235
AtlCoolCopy::m_sourceCoraPtr
CoraCoolDatabasePtr m_sourceCoraPtr
Definition: AtlCoolCopy.cxx:258
AtlCoolCopy::m_applock
bool m_applock
Definition: AtlCoolCopy.cxx:205
AtlCoolCopy::m_taglabel
std::string m_taglabel
Definition: AtlCoolCopy.cxx:242
AtlCoolCopy::m_timemin
cool::ValidityKey m_timemin
Definition: AtlCoolCopy.cxx:223
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
AtlCoolCopy::m_destDbPtr
cool::IDatabasePtr m_destDbPtr
Definition: AtlCoolCopy.cxx:257
AtlCoolCopy::m_nt_bufferptr
std::vector< void * > m_nt_bufferptr
Definition: AtlCoolCopy.cxx:293
AtlCoolCopy::getBulkRun
bool getBulkRun()
Definition: AtlCoolCopy.cxx:2781
EventContainers::Mode
Mode
Definition: IdentifiableContainerBase.h:13
AtlCoolCopy::m_runemin
cool::ValidityKey m_runemin
Definition: AtlCoolCopy.cxx:221
AtlCoolCopy::m_prunetags
bool m_prunetags
Definition: AtlCoolCopy.cxx:212
AtlCoolCopy::p_rootfile
TFile * p_rootfile
Definition: AtlCoolCopy.cxx:281
AtlCoolCopy::m_bufsize
int m_bufsize
Definition: AtlCoolCopy.cxx:234
AtlCoolCopy::m_timedb
std::string m_timedb
Definition: AtlCoolCopy.cxx:241
AtlCoolCopy::m_analyse
bool m_analyse
Definition: AtlCoolCopy.cxx:184
AtlCoolCopy::m_poollast
PoolMap::iterator m_poollast
Definition: AtlCoolCopy.cxx:269
PixelModuleFeMask_create_db.payload
string payload
Definition: PixelModuleFeMask_create_db.py:69
AtlCoolCopy::m_tags
std::vector< std::string > m_tags
Definition: AtlCoolCopy.cxx:262
AtlCoolCopy::m_nochannel
bool m_nochannel
Definition: AtlCoolCopy.cxx:191
AtlCoolCopy::m_mergecat
std::vector< std::string > m_mergecat
Definition: AtlCoolCopy.cxx:265
ir
int ir
counter of the current depth
Definition: fastadd.cxx:49
AtlCoolCopy::m_runinfohost
std::string m_runinfohost
Definition: AtlCoolCopy.cxx:243
CoolTagInfo
Definition: CoolTagInfo.h:16
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
AtlCoolCopy::m_nt_tagid
char m_nt_tagid[256]
Definition: AtlCoolCopy.cxx:291
AtlCoolCopy::m_forcepay
bool m_forcepay
Definition: AtlCoolCopy.cxx:199
python.DataFormatRates.c2
c2
Definition: DataFormatRates.py:123
AtlCoolCopy::m_nodata
bool m_nodata
Definition: AtlCoolCopy.cxx:190
AtlCoolCopy::bookOrFindTH1F
static TH1F * bookOrFindTH1F(const std::string &hID, const std::string &htitle, const int chan, const float xlow, const float xhigh)
Definition: AtlCoolCopy.cxx:2078
AtlCoolCopy::m_runfile
std::vector< std::string > m_runfile
Definition: AtlCoolCopy.cxx:248
Athena::Status
Status
Athena specific StatusCode values.
Definition: AthStatusCode.h:22
CoraCoolObjectIterPtr
boost::shared_ptr< CoraCoolObjectIter > CoraCoolObjectIterPtr
Definition: CoraCoolTypes.h:21
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
CaloCellTimeCorrFiller.foldertag
string foldertag
Definition: CaloCellTimeCorrFiller.py:20
makeDTCalibBlob_pickPhase.folders
folders
Definition: makeDTCalibBlob_pickPhase.py:346
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
AtlCoolCopy::addFolder
bool addFolder(const std::string &folder, const bool onlyTags)
Definition: AtlCoolCopy.cxx:460
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
AtlCoolCopy::m_cooltagmap
CoolTagMap m_cooltagmap
Definition: AtlCoolCopy.cxx:279
AtlCoolCopy::m_copytaginfo
bool m_copytaginfo
Definition: AtlCoolCopy.cxx:214
AtlCoolCopy::transConn
static std::string transConn(const std::string &inconn)
Definition: AtlCoolCopy.cxx:449
AtlCoolCopy::m_includehead
bool m_includehead
Definition: AtlCoolCopy.cxx:175
AtlCoolCopy::getRunList
bool getRunList()
Definition: AtlCoolCopy.cxx:2873
CoraCoolObjectPtr
boost::shared_ptr< CoraCoolObject > CoraCoolObjectPtr
Definition: CoraCoolTypes.h:18
AtlCoolCopy::m_newdataset
std::string m_newdataset
Definition: AtlCoolCopy.cxx:239
AtlCoolCopy::m_nt_treename
std::string m_nt_treename
Definition: AtlCoolCopy.cxx:292
AtlCoolCopy::m_root
bool m_root
Definition: AtlCoolCopy.cxx:182
CaloCondBlobAlgs_fillNoiseFromASCII.folder
folder
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:55
AtlCoolCopy::m_recreate
bool m_recreate
Definition: AtlCoolCopy.cxx:174
AtlCoolCopy::rootAllocate
bool rootAllocate(const cool::IFieldSpecification &spec, void *&sptr, char &rootID) const
Definition: AtlCoolCopy.cxx:1715
AtlCoolCopy::m_destCoraPtr
CoraCoolDatabasePtr m_destCoraPtr
Definition: AtlCoolCopy.cxx:259
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
WriteCallback
size_t WriteCallback(void *contents, size_t size, size_t nmemb, std::string *s)
Definition: AtlCoolCopy.cxx:64
AtlCoolCopy::m_nocopy
bool m_nocopy
Definition: AtlCoolCopy.cxx:189
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
LArCellNtuple.ifile
string ifile
Definition: LArCellNtuple.py:133
AtlCoolCopy::getLockedTags
bool getLockedTags()
Definition: AtlCoolCopy.cxx:429
AtlCoolCopy::m_nt_channel
UInt_t m_nt_channel
Definition: AtlCoolCopy.cxx:290
AtlCoolCopy::m_zeronull
bool m_zeronull
Definition: AtlCoolCopy.cxx:183
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:23
AtlCoolCopy::m_noclobroot
bool m_noclobroot
Definition: AtlCoolCopy.cxx:220
AtlCoolCopy::m_addlfn
std::vector< std::string > m_addlfn
Definition: AtlCoolCopy.cxx:245
get_generator_info.error
error
Definition: get_generator_info.py:40
AtlCoolCopy::addExclude
bool addExclude(const std::string &folder)
Definition: AtlCoolCopy.cxx:528
AtlCoolCopy::m_anadelt
long long m_anadelt
Definition: AtlCoolCopy.cxx:236
python.PyAthena.obj
obj
Definition: PyAthena.py:132
python.diffTAGTree.treename
treename
Definition: diffTAGTree.py:140
Cut::all
@ all
Definition: SUSYToolsAlg.cxx:67
error
Definition: IImpactPoint3dEstimator.h:70
AtlCoolCopy::m_hiparent
std::vector< std::string > m_hiparent
Definition: AtlCoolCopy.cxx:275
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
AtlCoolCopy::m_chdesc
bool m_chdesc
Definition: AtlCoolCopy.cxx:192
AtlCoolCopy::timeString
static std::string timeString(const cool::ValidityKey iovtime)
Definition: AtlCoolCopy.cxx:2572
pool::IFileCatalog::addReadCatalog
void addReadCatalog(const std::string &connect)
Add new catalog identified by name to the existing ones.
Definition: IFileCatalog.h:116
ReplicaSorter
Definition: Database/CoolConvUtilities/src/ReplicaSorter.h:12
AtlCoolCopy::m_folderexcl
std::vector< std::string > m_folderexcl
Definition: AtlCoolCopy.cxx:261
AtlCoolCopy::m_allowcreate
bool m_allowcreate
Definition: AtlCoolCopy.cxx:173
AtlCoolCopy::m_forcetime
bool m_forcetime
Definition: AtlCoolCopy.cxx:198
CaloCondBlobAlgs_fillNoiseFromASCII.blob
blob
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:95
AtlCoolCopy::getOnlineRun
bool getOnlineRun()
Definition: AtlCoolCopy.cxx:2693
python.SystemOfUnits.L
float L
Definition: SystemOfUnits.py:92
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
AtlCoolCopy::m_forcenopay
bool m_forcenopay
Definition: AtlCoolCopy.cxx:200
AtlCoolCopy::isNumeric
static bool isNumeric(const char *input)
Definition: AtlCoolCopy.cxx:2498
AtlCoolCopy::m_addguid
std::vector< std::string > m_addguid
Definition: AtlCoolCopy.cxx:244
AtlCoolCopy::m_newtimemin
cool::ValidityKey m_newtimemin
Definition: AtlCoolCopy.cxx:227
PoolMapElement
Definition: PoolMapElement.h:14