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, PoolMapElement >	PoolMap

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::IFileCatalog *	setupCatalog (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

ReplicaSorter *	m_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 81 of file AtlCoolCopy.cxx.

Member Typedef Documentation

◆ CoolTagMap

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

private

Definition at line 279 of file AtlCoolCopy.cxx.

◆ HiTagMap

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

private

Definition at line 273 of file AtlCoolCopy.cxx.

◆ PoolMap

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

private

Definition at line 269 of file AtlCoolCopy.cxx.

Constructor & Destructor Documentation

◆ AtlCoolCopy()

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

Definition at line 301 of file AtlCoolCopy.cxx.

                           :
   m_sourcedb(sourcedb),m_destdb(destdb),m_allowcreate(allowcreate),
   m_recreate(false),
   m_includehead(false),m_excludehead(false),
   m_usertags(true),m_userupdatehead(false),m_debug(false),m_alliov(false),
   m_verify(false),m_root(false),m_zeronull(false),m_analyse(false),
   m_checkrefs(false),m_listpfn(false),m_poolopen(false),m_poolall(false),
   m_nocopy(false),m_nodata(false),m_nochannel(false),m_chdesc(false),
   m_hitag(false),m_nohitag(false),m_forcesingle(false),m_forcemulti(false),
   m_forcerune(false),m_forcetime(false),m_forcepay(false),m_forcenopay(false),
   m_sourceread(true),m_truncate(false),m_skipout(false),m_skiprep(false),
   m_applock(false),m_applocksv(false),
   m_readoracle(false),m_gettime(false),m_getonline(false),m_onlinerun(false),
   m_getbulk(false),
   m_prunetags(false),m_lockedonly(false),m_copytaginfo(false),
   m_copytaglock(false),m_coracool(true),m_ignoremode(false),
   m_ignorespec(false),m_checkdesttag(false),m_noclobroot(false),
   m_runemin(cool::ValidityKeyMin),m_runemax(cool::ValidityKeyMax),
   m_timemin(cool::ValidityKeyMin),m_timemax(cool::ValidityKeyMax),
   m_newrunemin(cool::ValidityKeyMin),m_newrunemax(cool::ValidityKeyMax),
   m_newtimemin(cool::ValidityKeyMin),m_newtimemax(cool::ValidityKeyMax),
   m_srunemin(cool::ValidityKeyMin),m_srunemax(cool::ValidityKeyMax),
   m_channel1(""),m_channel2(""),m_bufsize(1000),m_sealmsg(5),
   m_anadelt(-1),m_outfolder(""),m_outtag(""),m_newdataset(""),
   m_checkoutputfile(""),m_timedb(""),m_taglabel(""),
   m_runinfohost("http://atlas-run-info-api.web.cern.ch/api"),
   m_coolapp(&m_coralsvc),
   m_dbSvc(&(m_coolapp.databaseService())),m_repsort(nullptr),
   m_open(false),m_chansel(cool::ChannelSelection::all()),p_rootfile(nullptr)
 {
   m_poolrefs.clear();
   m_poollast=m_poolrefs.end();
   // configure CORAL components
   coral::IConnectionServiceConfiguration& csconfig=m_coralsvc.configuration();
   csconfig.disablePoolAutomaticCleanUp();
   csconfig.setConnectionTimeOut(0);
 }

Member Function Documentation

◆ addExclude()

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

Definition at line 529 of file AtlCoolCopy.cxx.

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

◆ addFolder()

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

Definition at line 461 of file AtlCoolCopy.cxx.

                                                                        {
   std::cout << "Add folders in path:" << folder << " [ ";
   const std::vector<std::string> nodelist=m_sourceDbPtr->listAllNodes();
   // find all matching leaf folders
   for (std::vector<std::string>::const_iterator nodeitr=nodelist.begin();
        nodeitr!=nodelist.end();++nodeitr) {
     // match exact folder name or leading part of path
     // for leading part matches, next char in folder name must be '/'
     // so /CALO/SetA matches /CALO/SetA/X but not /CALO/SetAB
     if (*nodeitr==folder || folder=="/" ||
       (nodeitr->compare(0,folder.size(),folder)==0 && 
      nodeitr->size()>folder.size() && nodeitr->compare(folder.size(),1,"/")==0)) {
       // check if folder on exclude list
       bool exclude=false;
       for (std::vector<std::string>::const_iterator iexcl=m_folderexcl.begin();
        iexcl!=m_folderexcl.end();++iexcl) {
     if (iexcl->compare(0,1,"/")==0) {
       // exclude pattern starting / matches folder path (/SCT or /SCT/DCS)
           exclude=(exclude || nodeitr->compare(0,iexcl->size(),*iexcl)==0);
     } else {
       // exclude pattern without leading / matches anywhere in folder
       exclude=(exclude || (nodeitr->find(*iexcl)!=std::string::npos));
     }
       }
       // check folder exists (is a leaf folder), and not excluded
       if (m_sourceDbPtr->existsFolder(*nodeitr) && !exclude && !onlyTags) {
     // only add if folder not already on list
     if (find(m_folderlist.begin(),m_folderlist.end(),*nodeitr)==
         m_folderlist.end()) {
       std::cout << *nodeitr << " ";
       m_folderlist.push_back(*nodeitr);
     }
       }
       // if its a folderset, check for any hierarchical tags
       if (!m_nohitag && m_sourceDbPtr->existsFolderSet(*nodeitr) && !exclude) {
     if (!m_prunetags) {
           const std::vector<std::string> foldersettags=
         m_sourceDbPtr->getFolderSet(*nodeitr)->listTags();
       if (!foldersettags.empty()) {
         for (std::vector<std::string>::const_iterator 
               itr=foldersettags.begin();itr!=foldersettags.end();++itr) {
           m_hitagmap[*itr]=*nodeitr;
         }
       }
     } else {
       // only take tags in this folder which are referenced from one of
       // the input tags (assumed to be top-level tags)
       cool::IFolderSetPtr sfolder=m_sourceDbPtr->getFolderSet(*nodeitr);
       for (std::vector<std::string>::const_iterator toptag=m_tags.begin();
       toptag!=m_tags.end();++toptag) {
         try {
           std::string rtag=sfolder->resolveTag(*toptag);
           m_hitagmap[rtag]=*nodeitr;
         }
         // catch exceptions indicating tag defines nothing here
         // note std::exception rather than COOL exception to cover case
         // when trying to resolve a leaf tag in the '/' folder, which
         // throws a coral AttributeException
         catch (std::exception& e) {}
       }
     }
       }
     }
   }
   std::cout << "]" << std::endl;
   return true;
 }

◆ 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 1291 of file AtlCoolCopy.cxx.

                                        {
   // set newsince/until to since/until
   // but doing any required truncation/adjustment
   newsince=since;
   newuntil=until;
   if (m_alliov) {
     // make IOV cover specified range
     if (timestamp) {
       newsince=m_newtimemin;
       newuntil=m_newtimemax;
     } else {
       newsince=m_newrunemin;
       newuntil=m_newrunemax;
     }
   }
   // check for IOV truncation to range of query
   if (m_truncate) {
     if (newsince<qsince) newsince=qsince;
     if (newuntil>quntil) newuntil=quntil;
   }
   // check not requesting an IOV with negative length
   if (newuntil<newsince) throw cool::Exception(
     "Attempt to insert IOV with -ve length","AtlCoolCopy::adjustIOVs");
 }

◆ 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 1858 of file AtlCoolCopy.cxx.

                                        {
   // analyse the IOV and channel structure of this folder/tag, make ROOT histos
   std::cout << "Analyse tag " << sourcetag << " of folder " << folder << 
     std::endl;
   bool anatime=(m_anadelt>=0);
   if (anatime) {
     std::cout << "Analyse time structures with tolerance of " << 
       m_anadelt/1.E9 << " seconds " << std::endl;
   }
   // create COOLANA/folder structure and create leaf directory for histograms
   std::string dirname=rootDirs(folder,"COOLANA");
   if (gDirectory->FindObject(dirname.c_str())==nullptr) {
     std::cout << "Make directory " << dirname << std::endl;
     gDirectory->mkdir(dirname.c_str());
   }
   gDirectory->cd(dirname.c_str());
   // get channels
   std::vector<cool::ChannelId> channels=sourcefl->listChannels();
   unsigned int nchan=channels.size();
   // end of last IOV seen on this channel
   long long* lastiov=new long long[nchan];
   long long* iovtotlen=new long long[nchan];
   long long* iovtotgap=new long long[nchan];
   int* iovn=new int[nchan];
   for (unsigned int i=0;i<nchan;++i) {
     lastiov[i]=-1; // no IOV seen on this channel yet
     iovtotlen[i]=0;
     iovtotgap[i]=0;
     iovn[i]=0;
   }
   cool::ValidityKey globsince=cool::ValidityKeyMax;
   cool::ValidityKey globuntil=cool::ValidityKeyMin;
  
   // book histograms - only if the objects do not already exist (previous tag)
   TH1F* h_iovchan=bookOrFindTH1F("IOVSperChannel","IOVs per channel",
                  nchan,-0.5,nchan-0.5);
   TH1F* h_iovname=bookOrFindTH1F("IOVSperChannelName",
      "IOVs per channel-name (copy of IOVSperChannel)",
                      nchan,-0.5,nchan-0.5);
   TH1F* h_iovlength=bookOrFindTH1F("IOVLogLength","IOV log10 length",
                    100,0.,20.);
   TH1F* h_iovgap=bookOrFindTH1F("IOVLogGapLength","IOV log10 gap length",
                 100,0.,20.);
   // histograms for time analysis if needed
   TH1F* h_anadelt=nullptr;
   TH1F* h_chandelt=nullptr;
   if (anatime) {
     h_anadelt=bookOrFindTH1F("IOVAlignLogDelT","IOV alignment log deltaT",
                  100,0.,20.);
     // add factor 2 in number of channels, to catch those where a channel
     // changes many times within the m_anadelt window (i.e. noise/jitter)
     h_chandelt=bookOrFindTH1F("AlignedChanPerIOV","Aligned channels per IOV",
                   nchan*2,0.5,nchan*2-0.5);
   }
   std::cout << "Booked histograms for folder with " << nchan << " channels"
         << std::endl;
   // setup storage for IOV time analysis 
   using IOVTimeMap = std::map<cool::ValidityKey, int>;
   IOVTimeMap iov_time_map;
  
   // setup iterator to loop over objects
   int nobj=0;
   cool::FolderVersioning::Mode vermode=sourcefl->versioningMode();
   cool::IObjectIteratorPtr sourceitr;
   try {
     if (vermode==cool::FolderVersioning::SINGLE_VERSION) {
       sourceitr=sourcefl->browseObjects(since,until,m_chansel);
     } else {
       sourceitr=sourcefl->browseObjects(since,until,m_chansel,sourcetag);
     }
   }
   catch (cool::Exception& e) {
     std::cout << "Exception thrown from analysis copy iterator setup: " << 
       e.what() << std::endl;
     return 135;
   }
   // look up names of all the channels in one go
   std::map<cool::ChannelId,std::string> 
     chanmap=sourcefl->listChannelsWithNames();
   // now loop over all IOVs and write them
   try {
     while (sourceitr->goToNext()) {
       const cool::IObject& sobj=sourceitr->currentRef();
       // get channel and find its index
       cool::ChannelId ichanid=sobj.channelId();
       const std::string& cname=chanmap[ichanid];
       std::pair<std::vector<cool::ChannelId>::iterator,
     std::vector<cool::ChannelId>::iterator > chanitr=
       std::equal_range(channels.begin(),channels.end(),ichanid);
       if (chanitr.first!=chanitr.second) {
     cool::ChannelId ichan=std::distance(channels.begin(),chanitr.first);
     Int_t bin=h_iovchan->Fill(ichan);
     if (ichan && !h_iovname->GetBinContent(bin)) {
       h_iovname->GetXaxis()->SetBinLabel(bin,cname.c_str());    
     }
     h_iovname->Fill(ichan);
     // analyse IOV start/stop
     cool::ValidityKey since2=sobj.since();
     cool::ValidityKey until2=sobj.until();
     if (since2<globsince) globsince=since2;
     // dont count IOV is open-ended, so length statistics will make sense
         if (until2!=cool::ValidityKeyMax) {
       if (until2>globuntil) globuntil=until2;
       long long len=until2-since2;
       h_iovlength->Fill(log10(len));
       iovn[ichan]+=1;
       iovtotlen[ichan]+=len;
     }
     if (lastiov[ichan]<static_cast<long long>(since2) && 
         lastiov[ichan]>=0) {
       // have a gap in the IOV structure for this channel
       long long gap=since2-lastiov[ichan];
       iovtotgap[ichan]+=gap;
       h_iovgap->Fill(log10(gap));
       std::cout << "Gap of " << gap << std::endl;
     }
     if (until2!=cool::ValidityKeyMax) {
       lastiov[ichan]=until2;
     } else {
       lastiov[ichan]=since2;
     }
     // analyse IOV alignment
     if (anatime) {
       long long del1=-1;
       long long del2=-1;
       // find the nearest time to this one
       // this gives the first value exceeding since2
       IOVTimeMap::iterator hiitr=iov_time_map.lower_bound(since2);
       IOVTimeMap::iterator lowitr=hiitr;
       if (hiitr!=iov_time_map.end()) {
         // del1 is +ve time interval to next one
         del1=hiitr->first-since2;
       }
       if (lowitr!=iov_time_map.begin()) {
         // del2 is +ve time interval to previous one
         --lowitr;
         del2=since2-lowitr->first;
       }
       long long del=-1;
       IOVTimeMap::iterator moditr;
       bool domod=false;
       if (del1<=m_anadelt && del1>-1) {
         moditr=hiitr;
         del=del1;
         domod=true;
       }
       if (del2<=m_anadelt && del2>-1 && (del2<del || del==-1)) {
         moditr=lowitr;
         del=del2;
         domod=true;
       }
       if (domod) {
         ++(moditr->second);
         if (del>0) {
           h_anadelt->Fill(log10(del));
         } else {
           h_anadelt->Fill(0.);
         }
       } else {
         iov_time_map[since2]=0;
       }
     }
       } else {
     // channel ID not found 
         std::cout << "ERROR :Channel " << ichanid << 
         " not found in channel list - ignored" << std::endl;
       }
       ++nobj;
     }
     std::cout << "Finished analysis with " << nobj << " objects" << std::endl;
     if (timestamp) {
       std::cout << "IOV timestamp range: " << globsince << " " << 
     timeString(globsince) << "to " << globuntil << " " << 
     timeString(globuntil) << std::endl;
     } else {
       std::cout << "IOV run/LB range [" << (globsince >> 32) << "," <<
       (globsince & 0xFFFFFFFF) << "] to [" << (globuntil >> 32) << "," <<
       (globuntil & 0xFFFFFFFF) << "]" << std::endl;
     }
     // calculate statistics for each channel
     TH1F* h_iovoccchan=bookOrFindTH1F("ChannelOcc","Channel Occupancy",
                       nchan,-0.5,nchan-0.5);
     TH1F* h_iovlenchan=bookOrFindTH1F("IOVLenChan",
           "Mean IOV length per channel",nchan,-0.5,nchan-0.5);
     for (unsigned int i=0;i<nchan;++i) {
       float occ=0.;
       float avlen=0.;
       if (iovn[i]>0) {
         occ=1.-float(iovtotgap[i])/float(iovtotlen[i]+iovtotgap[i]);
     avlen=float(iovtotlen[i])/iovn[i];
       } 
       h_iovoccchan->Fill(i,occ);
       h_iovlenchan->Fill(i,avlen);
     }
     if (anatime) {
       std::cout << "Alignment analysis: " << iov_time_map.size()
         << " seperate IOV starts (tolerance " << m_anadelt/1.E9 << 
     " seconds)" << std::endl;
       // fill histogram of number of channels incremented per IOV
       for (IOVTimeMap::const_iterator itr=iov_time_map.begin();
        itr!=iov_time_map.end();++itr) {
     h_chandelt->Fill(itr->second);
       }
     }
   }
   catch (cool::Exception& e) {
     std::cout << "Exception thrown from folder analysis reading loop: " << 
       e.what() << std::endl;
     return 134;
   }
   sourceitr->close();
   delete [] lastiov;
   delete [] iovtotlen;
   delete [] iovtotgap;
   delete[] iovn; iovn=nullptr; 
   return 0;
 }

◆ 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 2079 of file AtlCoolCopy.cxx.

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

◆ channelID()

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

staticprivate

Definition at line 856 of file AtlCoolCopy.cxx.

                                                     {
   const char* cstr=chanstring.c_str();
   if (isNumeric(cstr)) {
     // channel is a number 
     return cool::ChannelId(strtoul(cstr,nullptr,10));
   } else {
     cool::ChannelId chan=0;
     try {
       chan=folder->channelId(chanstring);
       std::cout << "Channel name " << chanstring << " maps to channelID " 
         << chan << std::endl;
     }
     catch (cool::Exception& e) {
       std::cout << "ERROR: Channel name " << chanstring << 
     " not defined in folder " << std::endl;
     }
     return chan;
   }
 }

◆ checkChannels()

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

private

Definition at line 2922 of file AtlCoolCopy.cxx.

                                 {
   // Channel manipulation is slow due to lack of bulk API for creating them
   // this routine therefore does the minimum work, not checking destination
   // if folder is newly created, and not copying description unless requested
   // get map of all channels
   const std::map<cool::ChannelId,std::string> chanmap=
     sourcefl->listChannelsWithNames();
   if (m_debug) std::cout << "Checking channels table for folder " << folder 
     << " with " << chanmap.size() << " channels" << std::endl;
   int ncreate=0;
   int nmodify=0;
   // iterate over all channels
   for (std::map<cool::ChannelId,std::string>::const_iterator 
      itr=chanmap.begin();itr!=chanmap.end();++itr) {
     // assume now ALL channels are in channels table (COOL 2.4 and above)
     const cool::ChannelId chan=itr->first;
     // check if channel should be skipped
     if (!m_excludechans.empty()) {
       if (find(m_excludechans.begin(),m_excludechans.end(),
            chan)!=m_excludechans.end()) continue;
     }
     if (!m_chansel.inSelection(chan)) continue;
  
     const std::string& sourcename=itr->second;
     // only look up channel description if we are copying it
     std::string sourcedesc="";
     if (m_chdesc) sourcedesc=sourcefl->channelDescription(chan);
     // only check destination if folder alreay existed
     if (!newfolder && destfl->existsChannel(chan)) {
       const std::string & destname=destfl->channelName(chan);
       std::string destdesc="";
       if (m_chdesc) destdesc=destfl->channelDescription(chan);
       // if sourcename is not set, and destination is, dont worry
       if (sourcename!=destname && !sourcename.empty()) {
         // channel names differ - error if verifying, set if copying
         if (m_verify) {
           std::cout << "ERROR: Channel " << chan << " names differ: " << 
             sourcename << " " << destname << std::endl;
           return false;
         }
     destfl->setChannelName(chan,sourcename);
     std::cout << "Modify channel " << chan << " name from "
             << destname << " to " << sourcename << std::endl;
     ++nmodify;
       }
       if (sourcedesc!=destdesc && !sourcedesc.empty()) {
         // channel descriptions differ - error if verifying, set if copying
         if (m_verify) {
           std::cout << "ERROR: Channel " << chan << " descriptions differ: " 
                 << sourcedesc << " " << destdesc << std::endl;
       return false;
     }
         std::cout << "Modify channel " << chan << " description from "
             << sourcedesc << " to " << destdesc << std::endl;
     destfl->setChannelDescription(chan,sourcedesc);
     ++nmodify;
       }
     } else {
       // channel does not exist on destination - if verifying, this is error
       if (m_verify) return false;
       // otherwise create it
       if (m_debug) std::cout << "Create new channel " << chan << " name " 
             << sourcename << " description" << sourcedesc << std::endl;
       destfl->createChannel(chan,sourcename,sourcedesc);
       ++ncreate;
     }
   }
   if (ncreate>0) std::cout << "Created " << ncreate << " new channels for "
                << folder << std::endl;
   if (nmodify>0) std::cout << "Modified " << nmodify << " channel info for "
                << folder << std::endl;
   return true;
 }

◆ checkRef()

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

private

Definition at line 2999 of file AtlCoolCopy.cxx.

                                                            {
   const std::string name=payload[0].name();
   if (name=="PoolRef" || name=="fileGUID") {
     std::string poolref;
     std::string addr=payload[0].data<std::string>();
     if (name=="PoolRef") {
       std::string::size_type iofs1=addr.find("[DB=");
       std::string::size_type iofs2=addr.find(']',iofs1);
       if (iofs1!=std::string::npos && iofs2!=std::string::npos && iofs2>iofs1) {
         poolref=addr.substr(iofs1+4,iofs2-iofs1-4);
       } else {
       std::cout << "ERROR: Badly formed POOL object reference " <<
     addr << std::endl;
       }
     } else {
       // for fileGUID, POOL GUID is just the string
       poolref=addr;
     }
     std::string foldertag=folder+":"+tag;
     // insert into list, first check if same as before
     if (m_poollast!=m_poolrefs.end() && m_poollast->first==poolref) {
       m_poollast->second.inccount();
       m_poollast->second.addfoldertag(foldertag);
     } else {
       m_poollast=m_poolrefs.find(poolref);
       if (m_poollast!=m_poolrefs.end()) {
         m_poollast->second.inccount();
         m_poollast->second.addfoldertag(foldertag);
       } else {
         m_poolrefs[poolref]=PoolMapElement(1,foldertag);
         m_poollast=m_poolrefs.find(poolref);
       }
     }
   }
 }

◆ equalRecord()

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

staticprivate

Definition at line 2510 of file AtlCoolCopy.cxx.

                                           {
   // equality test for COOL IRecords, handling NULL string attributes correctly
   // tests values and types of Attributes, not names
   if (lhs.size()!=rhs.size()) return false;
   for (size_t i=0;i<lhs.size();++i) {
     // types must match - have to test explicitly first
     if (lhs[i].specification().storageType()!=
     rhs[i].specification().storageType())
       return false;
     // now use IField equality to for final test (spec again and data)
     if (lhs[i]!=rhs[i]) {
       // if not equal, check for special case of strings and compare directly
       // types are known to be equal so only test LHS
       const cool::StorageType& stype=lhs[i].specification().storageType();
       if (stype==cool::StorageType::String255 || 
       stype==cool::StorageType::String4k ||
       stype==cool::StorageType::String64k ||
       stype==cool::StorageType::String16M) {
     // check if string data payloads are really equal or not
     if (lhs[i].data<std::string>()!=rhs[i].data<std::string>()) 
       return false;
       } else {
     // if not string, trust the result of IField !=operator
     return false;
       }
     }
   }
   return true;
 }

◆ filePoolRefs()

void AtlCoolCopy::filePoolRefs ( )

private

Definition at line 3283 of file AtlCoolCopy.cxx.

                                {
   // list POOL refs and error codes, optionally to file
   if (!m_checkoutputfile.empty()) {
     std::cout << "Write POOL file checkoutput on " << m_checkoutputfile << 
       std::endl;
   } else {
     m_checkoutputfile="/dev/null";
   }
   std::ofstream chkostream(m_checkoutputfile.c_str());
   std::cout << "ErrCode GUID Count LFN PFN Folders ..." << std::endl;
   for (PoolMap::const_iterator ipool=m_poolrefs.begin();
        ipool!=m_poolrefs.end();++ipool) {
     if (m_poolall || ipool->second.errcode()>0) {
       std::ostringstream line;
       // write error code, GUID, usage count 
       line << ipool->second.errcode() << " " << ipool->first << " " << 
         ipool->second.count() << " ";
       if (!ipool->second.lfn().empty()) {
         line << ipool->second.lfn() << " ";
       } else {
         line << "noLFN ";
       }
       if (!ipool->second.pfn().empty()) {
     line << ipool->second.pfn() << " ";
       } else {
         line << "noPFN ";
       }
       for (std::vector<std::string>::const_iterator 
            itr=ipool->second.foldertag().begin();
          itr!=ipool->second.foldertag().end();++itr)
         line << *itr << " ";
       std::cout << line.str() << std::endl;
       chkostream << line.str()  << std::endl;
     }
   }
 }

◆ getBulkRun()

bool AtlCoolCopy::getBulkRun ( )

private

Definition at line 2782 of file AtlCoolCopy.cxx.

                              {
   // get minimum run-number/timestamp for bulk reco update
   if (m_getonline) {
     std::cout << "ERROR: -getonline and -getbulk cannot be used simultaneously"
               << std::endl;
     return false;
   }
   std::cout << "Call getbulk using URL" << std::endl;
   // Initialize libcurl
   curl_global_init(CURL_GLOBAL_ALL);
   using uniqueCurl_t = std::unique_ptr<CURL,decltype(&curl_easy_cleanup)>;
   uniqueCurl_t curl(curl_easy_init(), curl_easy_cleanup);
   //CURL *curl = curl_easy_init();
   CURLcode res = CURLE_OK;
   
   if (curl) {
       std::string url = m_runinfohost + "/runs/nemop/sync";
       // Set the URL
       res = curl_easy_setopt(curl.get(), CURLOPT_URL, url.c_str());
       if (res != CURLE_OK) {
           std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
           return false;
       }
       // Follow HTTP redirections
       res = curl_easy_setopt(curl.get(), CURLOPT_FOLLOWLOCATION, 1L);
       if (res != CURLE_OK) {
           std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
           return false;
       }
       // Response data buffer
       std::string response;
  
       // Set the callback function to receive response data
       res = curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, WriteCallback);
       if (res != CURLE_OK) {
           std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
           return false;
       }
       res = curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &response);
       if (res != CURLE_OK) {
           std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
           return false;
       }
       // Perform the request
       res = curl_easy_perform(curl.get());
       if (res != CURLE_OK) {
           std::cerr << "Failed to perform request: " << curl_easy_strerror(res) << ":" << url.c_str() << std::endl;
           return false;
       } else {
           // Print the received response
           std::cout << "Response: " << std::endl;
           std::cout << response << std::endl;
           try {
             // Split the response into two fields
             nlohmann::json jsonData = nlohmann::json::parse(response);
             // Extract the run and timestamp fields
             int nextrun = jsonData["run"];
             long long rtime = jsonData["timestamp"];
             std::cout << "Next run started will be " << nextrun << std::endl;
             std::cout << "Epoch time extracted " << rtime << std::endl;
             if (m_alliov) {
                 // if overwriting IOVs, set the new IOV lower limit
                 m_newrunemin=(static_cast<long long>(nextrun)) << 32;
                 m_newtimemin=rtime*static_cast<long long>(1E9);
             } else {
                 // set the query lower limit - for use with truncate option
                 m_runemin=(static_cast<long long>(nextrun)) << 32;
                 m_timemin=rtime*static_cast<long long>(1E9);
                 m_truncate=true;
             }
           } catch (nlohmann::json::parse_error& e) {
               std::cerr << "Failed to parse JSON response: " << e.what() << std::endl;
               return false;
           } catch (nlohmann::json::type_error& e) {
               std::cerr << "Failed to extract data from JSON response: " << e.what() << std::endl;
               return false;
           } catch (std::exception& e) {
               std::cerr << "Failed to extract run and timestamp from JSON response: " << e.what() << std::endl;
               return false;
           }      
       }
       // Clean up done by unique_ptr
   } else {
       std::cerr << "Failed to initialize libcurl." << std::endl;
       return false;
   }
   // Cleanup libcurl
   curl_global_cleanup();
  
   return true;
 }

◆ getCoolHistGUID()

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

staticprivate

Definition at line 3267 of file AtlCoolCopy.cxx.

                                                             {
   // attempt to extract COOL Hist GUID from file
   std::string hguid="";
   TFile* myfile=TFile::Open(file.c_str(),"READ");
   if (myfile!=nullptr) {
     TObjString* oguid;
     myfile->GetObject("fileGUID",oguid);
     if (oguid!=nullptr) {
       hguid=oguid->GetString();
       std::cout << "CoolHist GUID found to be " << hguid << std::endl;
     }
     myfile->Close();
   }
   return hguid;
 }

◆ getLockedTags()

bool AtlCoolCopy::getLockedTags ( )

private

Definition at line 430 of file AtlCoolCopy.cxx.

                                 {
   // set m_tags to list of top level tags which are locked
   m_tags.clear();
   cool::IFolderSetPtr topfolder=m_sourceDbPtr->getFolderSet("/");
   const std::vector<std::string>& toptaglist=topfolder->listTags();
   for (std::vector<std::string>::const_iterator toptag=toptaglist.begin();
        toptag!=toptaglist.end();++toptag) {
     cool::HvsTagLock::Status tstat=topfolder->tagLockStatus(*toptag);
     if (tstat==cool::HvsTagLock::LOCKED || 
     tstat==cool::HvsTagLock::PARTIALLYLOCKED) {
       std::cout << "Top-level tag " << *toptag << " will be copied" <<
     std::endl;
       m_tags.push_back(*toptag);
     }
   }
   std::cout << "Total of " << m_tags.size() << " top-level tags to be copied"
         << std::endl;
   return (!m_tags.empty());
 }

◆ getOnlineRun()

bool AtlCoolCopy::getOnlineRun ( )

private

Definition at line 2694 of file AtlCoolCopy.cxx.

                                {
   // open using the ATLAS_COOLONL_GLOBAL schema, since we have authentication
   // information for this one by default
   // get minimum run-number/timestamp for bulk reco update
   std::cout << "Extracting current run-number from ATLAS_RUN_NUMBER @ ATONR_ADG ... " << 
   // Initialize libcurl
   curl_global_init(CURL_GLOBAL_ALL);
    using uniqueCurl_t = std::unique_ptr<CURL,decltype(&curl_easy_cleanup)>;
   uniqueCurl_t curl(curl_easy_init(), curl_easy_cleanup);
   CURLcode res = CURLE_OK;
   if (curl) {
       std::string url = m_runinfohost + "/runs?sort=runnumber:DESC&size=1";
       // Set the URL
       res = curl_easy_setopt(curl.get(), CURLOPT_URL, url.c_str());
       if (res != CURLE_OK) {
           std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
           return false;
       }
       // Follow HTTP redirections
       res = curl_easy_setopt(curl.get(), CURLOPT_FOLLOWLOCATION, 1L);
       if (res != CURLE_OK) {
           std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
           return false;
       }
       // Response data buffer
       std::string response;
  
       // Set the callback function to receive response data
       res = curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, WriteCallback);
       if (res != CURLE_OK) {
           std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
           return false;
       }
       res = curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &response);
       if (res != CURLE_OK) {
           std::cerr << "Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
           return false;
       }
  
       // Perform the request
       res = curl_easy_perform(curl.get());
       if (res != CURLE_OK) {
           std::cerr << "Failed to perform request: " << curl_easy_strerror(res) << ":" << url.c_str() << std::endl;
           return false;
       } else {
           // Print the received response
           std::cout << "Response: " << std::endl;
           std::cout << response << std::endl;
           // Parse the JSON string
           try {
             nlohmann::json jsonData = nlohmann::json::parse(response);
  
             // Extract the runnumber field
             int runNumber = jsonData["resources"][0]["runnumber"];
             int nextrun=runNumber+1;
             std::cout << "Next run started will be " << nextrun << std::endl;
             const long long rtime=time(nullptr);
             std::cout << "Epoch time extracted " << rtime << std::endl;
             if (m_alliov) {
                 // if overwriting IOVs, set the new IOV lower limit
                 m_newrunemin=(static_cast<long long>(nextrun)) << 32;
                 m_newtimemin=rtime*static_cast<long long>(1E9);
             } else {
                 // set the query lower limit - for use with truncate option
                 m_runemin=(static_cast<long long>(nextrun)) << 32;
                 m_timemin=rtime*static_cast<long long>(1E9);
                 m_truncate=true;
             }
           } catch (nlohmann::json::parse_error& e) {
               std::cerr << "Failed to parse JSON response: " << e.what() << std::endl;
               return false;
           } catch (nlohmann::json::type_error& e) {
               std::cerr << "Failed to extract data from JSON response: " << e.what() << std::endl;
               return false;
           } catch (std::exception& e) {
               std::cerr << "Failed to extract run and timestamp from JSON response: " << e.what() << std::endl;
               return false;
           }
       }
       // Clean up done by unique_ptr d'tor
   } else {
       std::cerr << "Failed to initialize libcurl." << std::endl;
       return false;
   }
   // Cleanup libcurl
   curl_global_cleanup();
   return true;
 }

◆ getRunList()

bool AtlCoolCopy::getRunList ( )

private

Definition at line 2874 of file AtlCoolCopy.cxx.

                              {
   // loop over all given filenames
   for (std::vector<std::string>::const_iterator itr=m_runfile.begin();
        itr!=m_runfile.end();++itr) {
     std::cout << "Reading allowed run numbers from file " << *itr << std::endl;
     FILE* p_inp=fopen(itr->c_str(),"r");
     if (p_inp==nullptr) {
       std::cout << "File not found" << std::endl;
       return false;
     }
     char* p_buf=new char[999];
     while (!feof(p_inp)) {
       char* p_line=fgets(p_buf,999,p_inp);
       if (p_line!=nullptr) {
     unsigned int run=atoi(p_line);
     m_runlist.push_back(run);
       }
     }
     fclose(p_inp);
     delete[] p_buf;
   }
   std::sort(m_runlist.begin(),m_runlist.end());
   std::cout << "Read list of " << m_runlist.size() << " runs from " <<
     m_runfile.size() << " input runlist files" << std::endl;
   for (std::vector<unsigned int>::const_iterator itr=m_runlist.begin();
        itr!=m_runlist.end();++itr) std::cout << 
      "Update allowed for run " << *itr << std::endl;
   return true;
 }

◆ getTimeFromRun()

bool AtlCoolCopy::getTimeFromRun ( )

private

Definition at line 2605 of file AtlCoolCopy.cxx.

                                  {
   // extract time limits for a run range using the expected information
   // in the /TDAQ/RunCtrl/SOR_Params and EOR_Params on the given DB connection
  
   // choose database instance based on run number switchover if none is given
   if (m_timedb.empty()) {
     if ((m_runemin >> 32)>=236107) {
       m_timedb="COOLONL_TDAQ/CONDBR2";
     } else {
       m_timedb="COOLONL_TDAQ/COMP200";
     }
   }
   // select foldername based on database instance
   std::string sorfolder="/TDAQ/RunCtrl/SOR_Params";
   std::string eorfolder="/TDAQ/RunCtrl/EOR_Params";
   if (m_timedb.find ("CONDBR2")!=std::string::npos) {
     sorfolder="/TDAQ/RunCtrl/SOR";
     eorfolder="/TDAQ/RunCtrl/EOR";
   }
   std::cout << "Extracting times for run range [" << (m_runemin >> 32) <<
     "," << (m_runemax >> 32) << "] from database " << m_timedb << 
     " folder " << sorfolder << std::endl;
   if (m_runemin==cool::ValidityKeyMin || m_runemax==cool::ValidityKeyMax) {
     std::cout << "ERROR: Run range not correctly specified" << std::endl;
     return false;
   }
   // open database connection
   cool::IDatabasePtr tdaqdb;
   try {
     tdaqdb=m_dbSvc->openDatabase(transConn(m_timedb),m_sourceread);
     std::cout << "Opened database connection" << std::endl;
   }
   catch (std::exception& e) {
     std::cout << "COOL exception caught: " << e.what() << std::endl;
     return false;
   }
   // start of run information
   try {
     cool::IFolderPtr folder=tdaqdb->getFolder(sorfolder);
     // channel number is arbitrary - have to loop
     cool::IObjectIteratorPtr itr=folder->browseObjects(m_runemin,m_runemin,
             cool::ChannelSelection::all());
     int nobj=0;
     while (itr->goToNext()) {
       const cool::IRecord& payload=itr->currentRef().payload();
       m_timemin=payload["SORTime"].data<unsigned long long>();
       ++nobj;
     }
     itr->close();
     if (nobj!=1) {
       std::cout << "ERROR: Found " << nobj << " SOR records" << std::endl;
       return false;
     }
   }
   catch (std::exception& e) {
     std::cout << "Exception accessing SOR information: " << e.what() << 
       std::endl;
     return false;
   }
   // end of run information
   try {
     cool::IFolderPtr folder=tdaqdb->getFolder(eorfolder);
     // channel number is arbitrary - have to loop
     cool::IObjectIteratorPtr itr=folder->browseObjects(((m_runemax >> 32) << 32),((m_runemax >> 32) << 32),
             cool::ChannelSelection::all());
     int nobj=0;
     while (itr->goToNext()) {
       const cool::IRecord& payload=itr->currentRef().payload();
       m_timemax=payload["EORTime"].data<unsigned long long>();
       ++nobj;
     }
     itr->close();
     if (nobj!=1) {
       std::cout << "ERROR: Found " << nobj << " EOR records" << std::endl;
       return false;
     }
   }
   catch (std::exception& e) {
     std::cout << "Exception accessing SOR information: " << e.what() << 
       std::endl;
     return false;
   }
   tdaqdb->closeDatabase();
   std::cout << "Timestamp range set to " << m_timemin << " " <<
       timeString(m_timemin) << "to " << m_timemax << " " << 
       timeString(m_timemax) << std::endl;
   return true;
 }

◆ getUpdateMode()

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

staticprivate

Definition at line 2904 of file AtlCoolCopy.cxx.

                                        {
   // analyse the folder description and tag name for updateMode flags
   // return 1 for online mode, 0 otherwise
   std::string_view modestr="";
   int mode=0;
   std::string::size_type iofs1=desc.find("<updateMode>");
   std::string::size_type iofs2=desc.find("</updateMode>");
   if (iofs1!=std::string::npos && iofs2!=std::string::npos && iofs2>iofs1)
     modestr=desc.substr(iofs1+12,iofs2-iofs1-12);
   if (modestr=="UPD1" || tag.find("UPD1")!=std::string::npos) mode=1;
   if (modestr=="UPD2" || tag.find("UPD2")!=std::string::npos) mode=2;
   if (modestr=="UPD3" || tag.find("UPD3")!=std::string::npos) mode=3;
   if (modestr=="UPD4" || tag.find("UPD4")!=std::string::npos) mode=4;
   return mode;
 }

◆ isNumeric()

bool AtlCoolCopy::isNumeric ( const char * input )

staticprivate

Definition at line 2499 of file AtlCoolCopy.cxx.

                                              {
   // determine if input string is numeric or string
   bool isnum=true;
   const char* cptr=input;
   while (*cptr!='\0') {
     if (!isdigit(*cptr)) { isnum=false; break;}
     ++cptr;
   }
   return isnum;
 }

◆ isOpen()

bool AtlCoolCopy::isOpen ( ) const

inline

Definition at line 297 of file AtlCoolCopy.cxx.

297 { return m_open; }

◆ listPoolRefs()

int AtlCoolCopy::listPoolRefs ( )

private

Definition at line 3109 of file AtlCoolCopy.cxx.

                               {
   std::cout << "Total of " << m_poolrefs.size() << " POOL files referenced"
         << std::endl;
   for (PoolMap::const_iterator ipool=m_poolrefs.begin();
        ipool!=m_poolrefs.end();++ipool) {
     std::cout << "Ref " << ipool->first << " (" << ipool->second.count() 
           << ")" << std::endl;
   }
   return 0;
 }

◆ 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 1322 of file AtlCoolCopy.cxx.

                               {
  
   std::cout << "Reading tag " << sourcetag << " of folder " << folder << 
       " (no copy)" << std::endl;
   cool::FolderVersioning::Mode vermode=sourcefl->versioningMode();
   int nobj=0;
   cool::IObjectIteratorPtr sourceitr;
   if (vermode==cool::FolderVersioning::SINGLE_VERSION) {
     sourceitr=sourcefl->browseObjects(since,until,m_chansel);
   } else {
     sourceitr=sourcefl->browseObjects(since,until,m_chansel,sourcetag);
   }
   try {
     while (sourceitr->goToNext()) {
       const cool::IObject& obj=sourceitr->currentRef();
       if (checkrefs) checkRef(obj.payload(),folder,sourcetag);
       ++nobj;
     }
     std::cout << "Folder scanned with " << nobj << " objects" << std::endl;
   }
   // exceptions thrown from read loop
   catch (cool::Exception& e) {
     std::cout << "Exception thrown from read loop: " << e.what() <<
       std::endl;
     return 33;
   }
   // finished with the iterator
   sourceitr->close();
   return 0;
 }

◆ openConnections()

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

private

Definition at line 340 of file AtlCoolCopy.cxx.

                                                            {
   // check connections not already open
   if (m_open) return true;
   // initialise replica sorter if it was requested
   if (m_readoracle) {
     m_repsort=new ReplicaSorter();
     coral::IConnectionServiceConfiguration& csconfig=m_coralsvc.configuration();
     csconfig.setReplicaSortingAlgorithm(*m_repsort);
   }
   // cool::IDatabaseSvc& dbSvc=cool::DatabaseSvcFactory::databaseService();
   // open source database
   std::cout << "Open source database: " << sourcedb << std::endl;
   if (!m_sourceread) std::cout << "... in UPDATE mode" << std::endl;
   try {
     m_sourceDbPtr=m_dbSvc->openDatabase(transConn(sourcedb),m_sourceread);
   }
   catch (std::exception& e) {
     std::cout << "Cool exception caught: " << e.what() << std::endl;
     return false;
   }
   // open destination database
   if (m_nocopy) {
     m_open=true;
     return true;
   } else if (m_root || m_analyse) {
     std::cout << "Open destination ROOT file: " << destdb << std::endl;
     p_rootfile=new TFile(destdb.c_str(),"RECREATE");
     if (p_rootfile==nullptr) std::cout << "ERROR: Could not open ROOT file" << 
              std::endl;
     m_open=(p_rootfile!=nullptr);
     return m_open;
   }
   std::string tdestdb=transConn(destdb);
   std::cout << "Open destination database: " << tdestdb << std::endl;
   try {
     m_destDbPtr=m_dbSvc->openDatabase(tdestdb,m_verify);
     // if the open succeeds and we are using recreate mode, drop/delete 
     // the existing database first
     if (m_recreate) {
       std::cout << 
       "Forcing recreation of destination database - deleting existing data!" 
         << std::endl;
       m_destDbPtr.reset();
       m_dbSvc->dropDatabase(tdestdb);
       // go into catch to recrete database
       throw cool::DatabaseDoesNotExist("old database deleted");
     }
   }
   catch (std::exception& e) {
     std::cout << "COOL exception caught: " << e.what() << std::endl;
     // try to recover by creating new DB if possible and requested
     if (allowcreate || m_recreate) {
       std::cout << "Try to create new conditions DB" << std::endl;
       try {
         m_destDbPtr=m_dbSvc->createDatabase(tdestdb);
     std::cout << "Creation succeeded" << std::endl;
       }
       catch (cool::Exception& e) {
     std::cout << "Creation failed" << std::endl;
     return false;
       }
     } else {
       return false;
     }
   }
   m_open=true;
   return true;
 }

◆ openCoraCool()

bool AtlCoolCopy::openCoraCool ( )

private

Definition at line 410 of file AtlCoolCopy.cxx.

                                {
   if (m_sourceCoraPtr.get()==nullptr) {
     std::cout << "Attempt to open source CoraCool DB " << m_sourcedb << 
       std::endl;
     m_sourceCoraPtr=CoraCoolDatabasePtr(new CoraCoolDatabase(m_sourcedb,
        m_sourceDbPtr,m_coralsvc,m_sourceread));
     std::cout << "Opened CoraCool source DB" << std::endl;
   }
   // skip destination DB if not copying
   if (m_nocopy) return true;
   if (m_destCoraPtr.get()==nullptr) {
     std::cout << "Attempt to open destination CoraCool DB " << m_destdb << 
       std::endl;
     m_destCoraPtr=CoraCoolDatabasePtr(new CoraCoolDatabase(m_destdb,
        m_destDbPtr,m_coralsvc,m_verify));
     std::cout << "Opened CoraCool dest DB" << std::endl;
   }
   return true;
 }

◆ procOptVector()

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

private

Definition at line 2132 of file AtlCoolCopy.cxx.

                                                {
   // process an array of options, return True if OK, False if not
   int ic=0;
   bool error=false;
   while (ic<argc) {
     int ir=argc-ic;
     std::string_view par0=argv[ic];
     // strip double "--" to achieve compatability with python-style options
     if (par0.compare(0,2,"--")==0) par0=par0.substr(1);
     if ((par0=="-f" || par0=="-folder") && ir>1) {
       folders.emplace_back(argv[ic+1]);
       ++ic;
     } else if ((par0=="-e" || par0=="-exclude") && ir>1) {
       addExclude(argv[ic+1]);
       ++ic;
     } else if ((par0=="-t" || par0=="-tag") && ir>1) {
       m_tags.emplace_back(argv[ic+1]);
       ++ic;
     } else if ((par0=="-mt" || par0=="-magic") && ir>1) {
       m_magic.push_back("_"+std::string(argv[ic+1]));
       ++ic;
     } else if ((par0=="-of" || par0=="-outfolder") && ir>1) {
       m_outfolder=argv[ic+1];
       ++ic;
     } else if ((par0=="-ot" || par0=="-outtag") && ir>1) {
       m_outtag=argv[ic+1];
       ++ic;
     } else if ((par0=="-bs" || par0=="-buffersize") && ir>1) {
       m_bufsize=atoi(argv[ic+1]);
       ++ic;
     } else if ((par0=="-sl" || par0=="-seal") && ir>1) {
       m_sealmsg=atoi(argv[ic+1]);
       ++ic;
     } else if ((par0=="-rls" || par0=="-runlumisince") && ir>2) {
       m_runemin=runLBVal(argv[ic+1],argv[ic+2]);
       ic+=2;
     } else if ((par0=="-rlu" || par0=="-runlumiuntil") && ir>2) {
       m_runemax=runLBVal(argv[ic+1],argv[ic+2]);
       ic+=2;
     } else if ((par0=="-nrls" || par0=="-newrunlumisince") && ir>2) {
       m_newrunemin=runLBVal(argv[ic+1],argv[ic+2]);
       ic+=2;
     } else if ((par0=="-nrlu" || par0=="-newrunlumiuntil") && ir>2) {
       m_newrunemax=runLBVal(argv[ic+1],argv[ic+2]);
       ic+=2;
     } else if ((par0=="-srls" || par0=="-skiprunlumisince") && ir>2) {
       m_srunemin=runLBVal(argv[ic+1],argv[ic+2]);
       m_skipout=true;
       ic+=2;
     } else if ((par0=="-srlu" || par0=="-skiprunlumiuntil") && ir>2) {
       m_srunemax=runLBVal(argv[ic+1],argv[ic+2]);
       m_skipout=true;
       ic+=2;
     } else if (par0=="-ro" || par0=="-root") {
       m_root=true;
     } else if (par0=="-zn" || par0=="-zeronull") {
       m_zeronull=true;
     } else if (par0=="-ana" || par0=="-analyse") {
       m_analyse=true;
       float ttime=atof(argv[ic+1])*1.E9;
       m_anadelt=static_cast<long long>(ttime);
       ++ic;
     } else if ((par0=="-rs" || par0=="-runsince") && ir>1) {
       m_runemin=(static_cast<long long>(atol(argv[ic+1])) << 32);
       ++ic;
     } else if ((par0=="-ru" || par0=="-rununtil") && ir>1) {
       m_runemax=(static_cast<long long>(1+atol(argv[ic+1])) << 32)-1;
       ++ic;
     } else if ((par0=="-r" || par0=="-run") && ir>1) {
       m_runemin=(static_cast<long long>(atol(argv[ic+1])) << 32);
       m_runemax=(static_cast<long long>(1+atol(argv[ic+1])) << 32)-1;
       ++ic;
     } else if ((par0=="-ts" || par0=="-timesince") && ir>1) {
       m_timemin=timeVal(argv[ic+1]);
       ++ic;
     } else if ((par0=="-tu" || par0=="-timeuntil") && ir>1) {
       m_timemax=timeVal(argv[ic+1]);
       ++ic;
     } else if ((par0=="-nts" || par0=="-newtimesince") && ir>1) {
       m_newtimemin=timeVal(argv[ic+1]);
       ++ic;
     } else if ((par0=="-ntu" || par0=="-newtimeuntil") && ir>1) {
       m_newtimemax=timeVal(argv[ic+1]);
       ++ic;
     } else if (par0=="-c" || par0=="-create") {
       m_allowcreate=true;
     } else if ((par0=="-ch" || par0=="-channel") && ir>1) {
       m_channelRange.emplace_back(argv[ic+1]);
       ++ic;
     } else if ((par0=="-ch1" || par0=="-channel1") && ir>1) {
       m_channel1=argv[ic+1];
       ++ic;
     } else if ((par0=="-ch2" || par0=="-channel2") && ir>1) {
       m_channel2=argv[ic+1];
       ++ic;
     } else if (par0=="-chd" || par0=="-channeldesc") {
       m_chdesc=true;
       // no abbreviaton for this one - dangerous option
     } else if (par0=="-forcerecreate") {
       m_recreate=true;
     } else if (par0=="-d" || par0=="-debug") {
       m_debug=true;
     } else if (par0=="-a" || par0=="-alliov") {
       m_alliov=true;
     } else if (par0=="-ih" || par0=="-includehead") {
       m_includehead=true;
     } else if (par0=="-eh" || par0=="-excludehead") {
       m_excludehead=true;
     } else if (par0=="-ht" || par0=="-headtag") {
       m_usertags=false;
     } else if (par0=="-uht" || par0=="-userheadtag") {
       m_userupdatehead=true;
     } else if (par0=="-v" || par0=="-verify") {
       m_verify=true;
     } else if (par0=="-nc" || par0=="-nocopy") {
       m_nocopy=true;
     } else if (par0=="-noc" || par0=="-nocoracool") {
       m_coracool=false;
     } else if (par0=="-nch" || par0=="-nochannel") {
       m_nochannel=true;
     } else if (par0=="-ncr" || par0=="-noclobroot") {
       m_noclobroot=true;
     } else if (par0=="-nd" || par0=="-nodata") {
       m_nodata=true;
     } else if (par0=="-nh" || par0=="-nohitag") {
       m_nohitag=true;
     } else if (par0=="-hi" || par0=="-hitag") {
       m_hitag=true;
     } else if ((par0=="-ec" || par0=="-excludechannel") && ir>1) {
       m_excludechans.push_back(strtoul(argv[ic+1],nullptr,10));
       ++ic;
     } else if (par0=="-fs" || par0=="-forcesingle") {
       m_forcesingle=true;
     } else if (par0=="-fm" || par0=="-forcemulti") {
       m_forcemulti=true;
     } else if (par0=="-frl" || par0=="-forcerunlumi") {
       m_forcerune=true;
     } else if (par0=="-ftm" || par0=="-forcetime") {
       m_forcetime=true;
     } else if (par0=="-fp" || par0=="-forcepayload") {
       m_forcepay=true;
     } else if (par0=="-fnp" || par0=="-forcenopayload") {
       m_forcenopay=true;
     } else if (par0=="-cr" || par0=="-checkrefs") {
       m_checkrefs=true;
     } else if (par0=="-lp" || par0=="-listpfn") {
       m_listpfn=true;
       m_checkrefs=true;
     } else if (par0=="-cf" || par0=="-checkfiles") {
       m_poolopen=true;
       m_checkrefs=true;
     } else if (par0=="-pa" || par0=="-poolall") {
       m_poolall=true;
     } else if ((par0=="-co" || par0=="-checkoutput") && ir>1) {
       m_checkoutputfile=argv[ic+1];
       ++ic;
     } else if ((par0=="-pc" || par0=="-poolcat") && ir>1) {
       m_poolcat.emplace_back(argv[ic+1]);
       ++ic;
     } else if ((par0=="-mc" || par0=="-mergecat") && ir>1) {
       m_mergecat.emplace_back(argv[ic+1]);
       ++ic;
     } else if ((par0=="-ds" || par0=="-dataset") && ir>1) {
       m_newdataset=argv[ic+1];
       ++ic;
     } else if (par0=="-us" || par0=="-updatesource") {
       m_sourceread=false;
     } else if (par0=="-cd" || par0=="-checkdest") {
       m_checkdesttag=true;
     } else if (par0=="-tr" || par0=="-truncate") {
       m_truncate=true;
     } else if (par0=="-al" || par0=="-appendlocked") {
       m_applock=true;
     } else if (par0=="-alsv" || par0=="-appendlockedsv") {
       m_applock=true;
       m_applocksv=true;
     } else if (par0=="-rdo" || par0=="-readoracle") {
       m_readoracle=true;
     } else if (par0=="-skiprep" || par0=="-sr") {
       m_skiprep=true;
     } else if (par0=="-go" || par0=="-getonline") {
       m_getonline=true;
     } else if (par0=="-onr" || par0=="-onlinerun") {
       m_onlinerun=true;
     } else if (par0=="-gb" || par0=="-getbulk") {
       m_getbulk=true;
     } else if (par0=="-gt" || par0=="-gettime") {
       m_gettime=true;
     } else if ((par0=="-tdb" || par0=="-timedb") && ir>1) {
       m_timedb=argv[ic+1];
       ++ic;
     } else if (par0=="-ignoremode" && ir>1) {
       std::cout << "Ignoremode password is " << argv[ic+1] << ":end" << std::endl;
       if (strcmp(argv[ic+1],"BackDoor")==0) {
     m_ignoremode=true;
       } else {
     std::cout << "ERROR: Incorrect password for -ignoremode" << std::endl;
     error=true;
       }
       ++ic;
     } else if (par0=="-is" || par0=="-ignorespec") {
       m_ignorespec=true;
     } else if (par0=="-pt" || par0=="-prunetags") {
       m_prunetags=true;
       m_excludehead=true;
     } else if (par0=="-lo" || par0=="-lockedonly") {
       m_lockedonly=true;
       m_prunetags=true;
       m_excludehead=true;
     } else if (par0=="-cti" || par0=="-copytaginfo") {
       m_copytaginfo=true;
     } else if (par0=="-ctl" || par0=="-copytaglock") {
       m_copytaginfo=true;
       m_copytaglock=true;
     } else if ((par0=="-tl" || par0=="-taglabel") && ir>1) {
       m_taglabel=argv[ic+1];
       ++ic;
       m_copytaginfo=true;
     } else if ((par0=="-ag" || par0=="-addguid") && ir>1) {
       m_addguid.emplace_back(argv[ic+1]);
       ++ic;
     } else if ((par0=="-alf" || par0=="-addlfn") && ir>1) {
       m_addlfn.emplace_back(argv[ic+1]);
       ++ic;
     } else if ((par0=="-pf" || par0=="-parfile") && ir>1) {
       m_parfile.emplace_back(argv[ic+1]);
       ++ic;
     } else if ((par0=="-rf" || par0=="-runfile") && ir>1) {
       m_runfile.emplace_back(argv[ic+1]);
       ++ic;
     } else if ((par0=="-ws" || par0=="-runinfohost") && ir>1) {
       m_runinfohost=argv[ic+1];
       ++ic;
     } else if (par0=="-h" || par0=="-help") {
       // help printout triggered by -999 return code
       return 999;
     } else {
       std::cout << "Parameter error for argument: " << par0 << std::endl;
       error=true;
     }
     ++ic;
   }
   return !error;
 }

◆ rootAllocate()

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

private

Definition at line 1716 of file AtlCoolCopy.cxx.

                                                    {
   const cool::StorageType& stype=spec.storageType();
   rootID=' ';
   sptr=nullptr;
   if (stype==cool::StorageType::Bool) {
     // map bool to uint32 for now
     sptr=static_cast<void*>(new unsigned int(0));
     rootID='i';
   } else if (stype==cool::StorageType::UChar) {
     sptr=static_cast<void*>(new unsigned char(' '));
     rootID='C';
   } else if (stype==cool::StorageType::Int16) {
     sptr=static_cast<void*>(new short(0));
     rootID='S';
   } else if (stype==cool::StorageType::UInt16) {
     sptr=static_cast<void*>(new unsigned short(0));
     rootID='s';
   } else if (stype==cool::StorageType::Int32) {
     sptr=static_cast<void*>(new int(0));
     rootID='I';
   } else if (stype==cool::StorageType::UInt32) {
     sptr=static_cast<void*>(new unsigned int(0));
     rootID='i';
   } else if (stype==cool::StorageType::Int64) {
     sptr=static_cast<void*>(new long long int(0));
     rootID='L';
   } else if (stype==cool::StorageType::UInt63) {
     sptr=static_cast<void*>(new unsigned long long int(0));
     rootID='l';
   } else if (stype==cool::StorageType::Float) {
     sptr=static_cast<void*>(new float(0.));
     rootID='F';
   } else if (stype==cool::StorageType::Double) {
     sptr=static_cast<void*>(new double(0.));
     rootID='D';
   } else if (stype==cool::StorageType::String4k || 
          stype==cool::StorageType::String255) {
     sptr=static_cast<void*>(new char[4100]);
     rootID='C';
   } else if (stype==cool::StorageType::String64k && !m_noclobroot) {
     sptr=static_cast<void*>(new char[65536]);
     rootID='C';
   } else if (stype==cool::StorageType::String16M && !m_noclobroot) {
     sptr=static_cast<void*>(new char[67108864]);
     rootID='C';
   } else if (stype==cool::StorageType::Blob64k && !m_noclobroot) {
     sptr=static_cast<void*>(new char[65536]);
     rootID='C';
   } else {
     std::cout << "rootAllocate: Unsupported storage type for attribute: " <<
       spec.name() << std::endl;
   }
   return (sptr!=nullptr);
 }

◆ rootDirs()

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

private

Definition at line 1682 of file AtlCoolCopy.cxx.

                                             {
   // create a ROOT directory structure start with toproot (=COOL or COOLANA)
   // and cd to the directory where a tree should be created
   // return the tree name (=leaf of the COOL foldername)
   p_rootfile->cd();
   if (p_rootfile->FindObject(toproot.c_str())==nullptr) {
     p_rootfile->mkdir(toproot.c_str());
     std::cout << "Made top directory " << toproot << std::endl;
   }
   gDirectory->cd(toproot.c_str());
   // now parse the COOL folder name to create intermediate directories
   // assume folder names begin with '/', to be skipped
   std::string::size_type iofs1=1;
   std::string::size_type iofs2=1;
   std::string treename;
   while (iofs2!=std::string::npos) {
     iofs2=folder.find('/',iofs1);
     if (iofs2==std::string::npos) {
       // no more /, so current part of string is leaf tree name
       treename=folder.substr(iofs1);
     } else {
       std::string dirname=folder.substr(iofs1,iofs2-iofs1);
       iofs1=iofs2+1;
       if (gDirectory->FindObject(dirname.c_str())==nullptr) {
     std::cout << "Make directory " << dirname << std::endl;
         gDirectory->mkdir(dirname.c_str());
       }
       gDirectory->cd(dirname.c_str());
     }
   }
   return treename;
 }

◆ 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 1551 of file AtlCoolCopy.cxx.

                                     {
   // copy this selection to ROOT
   std::cout << "Write tag " << sourcetag << " of folder " << folder << 
     " to ROOT file" << std::endl;
   // create the directory structure - top directory COOL
   std::string treename=rootDirs(folder,"COOL");
   bool timestamp2=timestamp;
   if (m_forcetime) timestamp2=true;
   if (m_forcerune) timestamp2=false;
   cool::FolderVersioning::Mode vermode=sourcefl->versioningMode();
   // create TTree with appropriate structure - only if it does not exist
   // could have been created from a previous tag in the same folder
   TTree* tree=static_cast<TTree*>(gDirectory->FindObject(treename.c_str()));
   if (tree==nullptr) {
     std::cout << "Book TTree " << treename << std::endl;
     tree=new TTree(treename.c_str(),"COOL datadump");
     if (timestamp2) {
       tree->Branch("IOVSince",&m_nt_since,"IOVSince/l");
       tree->Branch("IOVUntil",&m_nt_until,"IOVUntil/l");
     } else {
       tree->Branch("RunSince",&m_nt_runsince,"RunSince/i");
       tree->Branch("RunUntil",&m_nt_rununtil,"RunUntil/i");
       tree->Branch("LBSince",&m_nt_lbsince,"LBSince/i");
       tree->Branch("LBUntil",&m_nt_lbuntil,"LBUntil/i");
     }
     tree->Branch("ChannelID",&m_nt_channel,"ChannelID/i");
     if (vermode==cool::FolderVersioning::MULTI_VERSION)
       tree->Branch("TagID",m_nt_tagid,"TagID/C");
     // now loop through specification, creating payload buffer and tree
     const cool::IRecordSpecification& spec=
     (sourcefl->folderSpecification()).payloadSpecification();
     unsigned int ncolumns=spec.size();
     // clear the buffer of pointers - note this leaks the memory of the
     // previous buffers, but to do this properly would have to remember
     // the type of each object and delete appropriately
     m_nt_treename=treename;
     m_nt_bufferptr.clear();
     for (unsigned int icol=0;icol<ncolumns;++icol) {
       const cool::IFieldSpecification& fieldspec=spec[icol];
       void* ptr=nullptr;
       char rootID;
       if (rootAllocate(fieldspec,ptr,rootID)) {
         tree->Branch(fieldspec.name().c_str(),ptr,
            (fieldspec.name()+"/"+rootID).c_str());
     if (m_debug) std::cout << "Defining column for " << spec[icol].name() 
         << " of type " << spec[icol].storageType().name() << std::endl;
       } else {
         std::cout << "Attribute " << spec[icol].name() << " of type " << 
       spec[icol].storageType().name() << " will be skipped" << std::endl;
       }
       m_nt_bufferptr.push_back(ptr);
     }
   } else {
     std::cout << "TTree " << treename << " already exists" << std::endl;
     // check we have seen and defined this tree
     unsigned int size=
       (sourcefl->folderSpecification()).payloadSpecification().size();
     if (treename!=m_nt_treename || size!=m_nt_bufferptr.size()) {
       std::cout << "ERROR in tree buffer definition: expect " << treename <<
     " size " << size << " but buffer has " << m_nt_treename << " size " 
         << m_nt_bufferptr.size() << std::endl;
       return 123;
     }
   }
  
   int nobj=0;
   int nex=0;
   cool::IObjectIteratorPtr sourceitr;
   try {
     if (vermode==cool::FolderVersioning::SINGLE_VERSION) {
       sourceitr=sourcefl->browseObjects(since,until,m_chansel);
     } else {
       sourceitr=sourcefl->browseObjects(since,until,m_chansel,sourcetag);
     }
   }
   catch (cool::Exception& e) {
     std::cout << "Exception thrown from ROOT copy iterator setup: " << 
       e.what() << std::endl;
     return 125;
   }
   // now loop over all IOVs to copy them 
   try {
     while (sourceitr->goToNext()) {
       const cool::IObject& sobj=sourceitr->currentRef();
       if (timestamp2) {
         m_nt_since=sobj.since();
         m_nt_until=sobj.until();
       } else {
         m_nt_runsince=(sobj.since() >> 32);
         m_nt_rununtil=(sobj.until() >> 32);
         m_nt_lbsince=(sobj.since() & 0xFFFFFFFF);
         m_nt_lbuntil=(sobj.until() & 0xFFFFFFFF);
       }
       m_nt_channel=sobj.channelId();
       if (vermode==cool::FolderVersioning::MULTI_VERSION) {
     // truncate the string first to avoid coverity complaining about
     // potential buffer overruns
     std::string sourcetag2=sourcetag.substr(0,255);
     strncpy(m_nt_tagid,sourcetag2.c_str(),sizeof(m_nt_tagid)-1);
       }
       // loop over the payload elements and fill the ones for which buffers
       // are defined
       try {
         const cool::IRecord& record=sobj.payload();
         for (unsigned int icol=0;icol<record.size();++icol) {
       if (m_nt_bufferptr[icol]!=nullptr) rootWrite(m_nt_bufferptr[icol],record[icol]);
         }
         tree->Fill();
         ++nobj;
       }
       catch (cool::Exception& e) {
     // can get exceptions due to NULL values
     // catch them and continue...
     ++nex;
       }
     }
     sourceitr->close();
     std::cout << "Written " << nobj << " objects to ROOT TTree with " << nex 
           << " nulls/exceptions"  << std::endl;
   }
   catch (cool::Exception& e) {
     std::cout << "Exception thrown from ROOT file writing loop: " << 
       e.what() << std::endl;
     return 124;
   }
   return 0;
 }

◆ rootWrite()

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

private

Definition at line 1772 of file AtlCoolCopy.cxx.

                                                                     {
   // check for NULL value
   bool recnull=(field.isNull() && m_zeronull);
   const cool::StorageType& stype=field.storageType();
   if (stype==cool::StorageType::Bool) {
     if (recnull) {
       *(static_cast<int*>(sptr))=0;
     } else {
       *(static_cast<int*>(sptr))=(field.data<bool>() ? 1 : 0);
     }
   } else if (stype==cool::StorageType::UChar) {
     if (recnull) {
       *(static_cast<unsigned char*>(sptr))=0;
     } else {
       *(static_cast<unsigned char*>(sptr))=field.data<unsigned char>();
     }
   } else if (stype==cool::StorageType::Int16) {
     if (recnull) {
       *(static_cast<short*>(sptr))=0;
     } else {
       *(static_cast<short*>(sptr))=field.data<short>();
     }
   } else if (stype==cool::StorageType::UInt16) {
     if (recnull) {
       *(static_cast<unsigned short*>(sptr))=0;
     } else {
       *(static_cast<unsigned short*>(sptr))=field.data<unsigned short>();
     }
   } else if (stype==cool::StorageType::Int32) {
     if (recnull) {
       *(static_cast<int*>(sptr))=0;
     } else {
       *(static_cast<int*>(sptr))=field.data<int>();
     }
   } else if (stype==cool::StorageType::UInt32) {
     if (recnull) {
       *(static_cast<unsigned int*>(sptr))=0;
     } else {
       *(static_cast<unsigned int*>(sptr))=field.data<unsigned int>();
     }
   } else if (stype==cool::StorageType::Int64) {
     if (recnull) {
       *(static_cast<long long*>(sptr))=0;
     } else {
       *(static_cast<long long*>(sptr))=field.data<long long>();
     }
   } else if (stype==cool::StorageType::UInt63) {
     if (recnull) {
       *(static_cast<unsigned long long*>(sptr))=0;
     } else {
       *(static_cast<unsigned long long*>(sptr))=field.data<unsigned long long>();
     }
   } else if (stype==cool::StorageType::Float) {
     if (recnull) {
       *(static_cast<float*>(sptr))=0.;
     } else {
       *(static_cast<float*>(sptr))=field.data<float>();
     }
   } else if (stype==cool::StorageType::Double) {
     if (recnull) {
       *(static_cast<double*>(sptr))=0.;
     } else {
       *(static_cast<double*>(sptr))=field.data<double>();
     }
   } else if (stype==cool::StorageType::String255 || 
          stype==cool::StorageType::String4k ||
          stype==cool::StorageType::String64k ||
          stype==cool::StorageType::String16M) {
     if (recnull) {
       strcpy(static_cast<char*>(sptr),"NULL");
     } else {
       strcpy(static_cast<char*>(sptr),field.data<std::string>().c_str());
     }
   } else if (stype==cool::StorageType::Blob64k && !m_noclobroot) {
     if (recnull) {
       strcpy(static_cast<char*>(sptr),"NULL");
     } else {
       auto blob = field.data<coral::Blob>();
       std::string blobStr((char*)blob.startingAddress(), blob.size());
       strcpy(static_cast<char*>(sptr), blobStr.c_str());
     }
   } else {
     std::cout << "ERROR: Unknown storage type in rootWrite!" << std::endl;
   }
 }

◆ runLBVal()

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

staticprivate

Definition at line 2586 of file AtlCoolCopy.cxx.

                                                                            {
   // parse the inputs as run/LB numbers to generate a validitykey
   // used in processing -rls-type options
   cool::ValidityKey val;
   if (input1[0]=='M' || input1[0]=='m') {
     val=((1LL << 31)-1) << 32;
   } else {
     val=static_cast<long long>(atol(input1)) << 32;
   }
   if (input2[0]=='M' || input2[0]=='m') {
     val+=(1LL << 32);
   } else {
     val+=atoll(input2);
   }
   if (val>cool::ValidityKeyMax) val=cool::ValidityKeyMax;
   return val;
 }

◆ setChannelRange()

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

private

Definition at line 821 of file AtlCoolCopy.cxx.

                                                                 {
   // add range specified via -ch1 -ch2 if given
   if (!m_channel1.empty() && !m_channel2.empty()) {
     m_channelRange.clear();
     m_channelRange.push_back(m_channel1+":"+m_channel2);
   }
   m_chansel=cool::ChannelSelection::all();
   const size_t nChanRange=m_channelRange.size();
   for (size_t i=0;i<nChanRange;i++) {
     size_t cpos=m_channelRange[i].find(':');
     if (cpos==std::string::npos || cpos > m_channelRange[i].size()-1) {
       // single channel
       std::cout << "Adding channel " << m_channelRange[i] << 
     " to channel selection" << std::endl;
       if (m_chansel.allChannels())
     m_chansel=cool::ChannelSelection(channelID(sourcefl,
                            m_channelRange[i]));
       else
     m_chansel.addChannel(channelID(sourcefl,m_channelRange[i]));
     }
     else { 
       // Channel Range
       std::string c1=m_channelRange[i].substr(0,cpos);
       std::string c2=m_channelRange[i].substr(1+cpos);
       std::cout << "Adding channel range " << c1 << " to " << c2 << 
     " to channel selection" << std::endl;
       if (m_chansel.allChannels())
     m_chansel=cool::ChannelSelection(channelID(sourcefl,c1),
                      channelID(sourcefl,c2));
       else
     m_chansel.addRange(channelID(sourcefl,c1),channelID(sourcefl,c2));
     }      
   }//end loop over channel ranges
 }

◆ setOpts()

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

Definition at line 2379 of file AtlCoolCopy.cxx.

                                                      {
   // accumulate raw folder list
   std::vector<std::string> folders;
   // process options given on command-line
   if (!procOptVector(argc,argv,folders)) return 2;
  
   // parse any parameters in files via parfile option
   for (std::vector<std::string>::const_iterator ifile=m_parfile.begin();
        ifile!=m_parfile.end();++ifile) {
     std::cout << "Reading parameters from file " << *ifile << std::endl;
     FILE* p_inp=fopen(ifile->c_str(),"r");
     if (p_inp==nullptr) {
       std::cout << "File not found" << std::endl;
       return 3;
     }
     char* p_buf=new char[999];
     while (!feof(p_inp)) {
       char* p_line=fgets(p_buf,999,p_inp);
       if (p_line!=nullptr) {
     int fargc=0;
     const char* fargv[99];
     // split this line into tokens
     char* p_start=nullptr;
     while (*p_line!='\0') {
       if (*p_line==' ' || *p_line=='\n') {
         // pointing at a space/newline, marking the end of a parameter
         if (p_start!=nullptr) {
           // if we have a parameter, mark the end and store it
           *p_line='\0';
           fargv[fargc]=p_start;
           fargc++;
           p_start=nullptr;
         }
       } else {
         // mark the start of a parameter
         if (p_start==nullptr) p_start=p_line;
       }
       ++p_line;
     }
     if (fargc>0) {
       if (!procOptVector(fargc,&fargv[0],folders)) {
         fclose(p_inp);
         return 3;
       }
     }
       }
     }
     std::cout << "Close file" << std::endl;
     fclose(p_inp);
     delete[] p_buf;
   }
  
   // now open the database so folder lookup will work
   if (!openConnections(m_sourcedb,m_destdb,m_allowcreate)) {
     std::cout << "Problem opening connections" << std::endl;
     return 10;
   } else {
     // having assembled the raw list of folders and exclude list, construct
     // real list of folders (allows exclude to be specified after folders on
     // command line), if none given, add '/'
     if (m_lockedonly) {
       if (getLockedTags()==0) return 11;
     }
     if (folders.empty()) {
       // no folders specified, take all with tags
       addFolder("/",false);
     } else {
       // explicit list of folders
       for (std::vector<std::string>::const_iterator ifold=folders.begin();
          ifold!=folders.end();++ifold) addFolder(*ifold,false);
       // need to process only tags in root folder, if inclusive hiearchicals
       if (m_hitag) addFolder("/",true);
     }
   }
   if (m_getonline) {
     if (!getOnlineRun()) return 6;
   }
   if (m_getbulk) {
     if (!getBulkRun()) return 6;
   }
   if (m_gettime) {
     if (!getTimeFromRun()) return 5;
   }
   if (!m_runfile.empty()) {
     if (!getRunList()) return 7;
   }
   // list out parameter changes
   if (m_runemin!=cool::ValidityKeyMin || m_runemax!=cool::ValidityKeyMax)
     std::cout << "Source run/LB range [" << (m_runemin >> 32) << "," <<
       (m_runemin & 0xFFFFFFFF) << "] to [" << (m_runemax >> 32) << "," <<
       (m_runemax & 0xFFFFFFFF) << "]" << std::endl;
   if (m_timemin!=cool::ValidityKeyMin || m_timemax!=cool::ValidityKeyMax)
     std::cout << "Source timestamp range " << m_timemin << " " <<
       timeString(m_timemin) << "to " << m_timemax << " " << 
       timeString(m_timemax) << std::endl;
   if (m_alliov)
     std::cout << "Change o/p run/LB range [" << (m_newrunemin >> 32) << "," <<
       (m_newrunemin & 0xFFFFFFFF) << "] to [" << (m_newrunemax >> 32) << "," <<
       (m_newrunemax & 0xFFFFFFFF) << "]" << std::endl;
   if (m_alliov) 
     std::cout << "Change o/p timestamp range " << m_newtimemin << " " <<
       timeString(m_newtimemin) << "to " << m_newtimemax << " " << 
       timeString(m_newtimemax) << std::endl;
   if (m_skipout) {
     std::cout << "Skip IOVs extending outside run/LB range [" << 
       (m_srunemin >> 32) << "," << (m_srunemin & 0xFFFFFFFF) << "] to [" <<
       (m_srunemax >> 32) << "," << (m_srunemax & 0xFFFFFFFF) << "]" << 
       std::endl;
   }
   if (!m_excludechans.empty()) {
     for (std::vector<cool::ChannelId>::const_iterator itr=
        m_excludechans.begin();itr!=m_excludechans.end();++itr) 
       std::cout << "Channel " << *itr << " will be excluded" << std::endl;
   }
   if (m_hitag) std::cout << "All hierachical tags connecting to referenced tags will be copied" << std::endl;
   if (m_nohitag) std::cout << "Hierarchical tag relations will not be copied"
                << std::endl;
   return 0;
 }

◆ setupCatalog()

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

staticprivate

Definition at line 3320 of file AtlCoolCopy.cxx.

                                                 {
   pool::IFileCatalog* catalog=new pool::IFileCatalog;
   try {
     catalog->setWriteCatalog("file:PoolFileCatalog.xml");
     for (std::vector<std::string>::const_iterator icat=catvec.begin();
      icat!=catvec.end();++icat) {
       std::cout << "Add catalogue: " << *icat << std::endl;
       // if catalogue contains no ":" specifier, assume plain file
       if (icat->find(':')==std::string::npos) {
         catalog->addReadCatalog("file:"+(*icat));
       } else {
         catalog->addReadCatalog(*icat);
       }
     }
     catalog->connect();
     catalog->start();
     return catalog;
   }
   catch (std::exception& e) {
     std::cout << "Could not setup POOL catalogues, exception:" << e.what() 
           << std::endl;
     return nullptr;
   }
 }

◆ tagParents()

int AtlCoolCopy::tagParents ( )

private

Definition at line 3036 of file AtlCoolCopy.cxx.

                             {
   std::cout << "Copying additional hierarchical tags of parent folders"
         << std::endl;
   while (!m_hiparent.empty()) {
     // take first element and erase it
     std::string folderset=*m_hiparent.begin();
     m_hiparent.erase(m_hiparent.begin());
     // process any tags defined for this folderset
     if (m_sourceDbPtr->existsFolderSet(folderset)) {
       cool::IFolderSetPtr sourcefl=m_sourceDbPtr->getFolderSet(folderset);
       cool::IFolderSetPtr destfl=m_destDbPtr->getFolderSet(folderset);
       std::cout << "Processing folderset " << folderset << std::endl;
       for (HiTagMap::const_iterator imap=m_hitagmap.begin();
        imap!=m_hitagmap.end();++imap) {
     try {
       // will throw exception if this tag is not pointing to the folder
       std::string sourcetag=sourcefl->findTagRelation(imap->first);
       std::cout << "Create hierarchical tag between " << sourcetag <<
         " and " << imap->first << " in folder " << imap->second <<
         std::endl;
       try {
         // first check this relation has not already been created
         std::string etag=destfl->resolveTag(imap->first);
         if (etag==sourcetag) {
           std::cout << "This relation has already been created" << std::endl;
         } else {
           std::cout << "ERROR: Tag in parent already related to " << 
           etag << std::endl;
           return 34;
         }
       }
       catch (cool::Exception& e ) {
             // only do creation if does not already exist - via exception
         try {
           destfl->createTagRelation(imap->first,sourcetag);
           // check if this implicates yet another parent folder to be checked
           if (find(m_hiparent.begin(),m_hiparent.end(),imap->second)==
               m_hiparent.end()) m_hiparent.push_back(imap->second);
           if (m_copytaginfo && 
         m_cooltagmap.find(imap->first)==m_cooltagmap.end())
           m_cooltagmap.insert(CoolTagMap::value_type(imap->first,
              CoolTagInfo(m_sourceDbPtr,imap->second,imap->second,
                      imap->first,imap->first)));
         }
         catch (cool::Exception& e) {
           std::cout << "Cool exception " << e.what() << 
             "thrown in hierarchical tag creation" << std::endl;
           return 34;
         }
       }
     }
     // exceptions from findTag - do nothing
     catch (cool::Exception& e) { }
       }
     } else {
       std::cout << "ERROR Folderset " << folderset << " not found" << 
     std::endl;
     }
   }
   return 0;
 }

◆ timeString()

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

staticprivate

Definition at line 2573 of file AtlCoolCopy.cxx.

                                                                {
   if (iovtime==cool::ValidityKeyMin) {
     return "ValidityKeyMin ";
   } else if (iovtime==cool::ValidityKeyMax) {
     return "ValidityKeyMax ";
   } else {
     time_t time=static_cast<time_t>(iovtime/1E9);
     struct tm result;
     char buf[32];
     return "UTC "+std::string(asctime_r(gmtime_r(&time, &result), buf));
   }
 }

◆ timeVal()

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

staticprivate

Definition at line 2542 of file AtlCoolCopy.cxx.

                                                       {
   // convert input char* string to 64bit COOL validityKey
   // input either represents a string in seconds, or a date in the form
   // yyyy/mm/dd:hh:mm:ss
   // first determine if input is a number
   if (isNumeric(input)) {
     return static_cast<long long>(atol(input))*
       static_cast<long long>(1.E9);
   } else {
     struct tm mytm{},mytm2{};
     char* result=strptime(input,"%Y-%m-%d:%T",&mytm);
     if (result!=nullptr) {
       // make the DST field zero, so the time is interpreted without daylight
       // savings time
       mytm.tm_isdst=0;
       // now have to correct for the local time zone - do this by also 
       // calculating the time since epoch for 2/1/1970 midnight (no DST)
       cool::ValidityKey itime=static_cast<cool::ValidityKey>(mktime(&mytm));
       strptime("1970-01-02:00:00:00","%Y-%m-%d:%T",&mytm2);
       cool::ValidityKey caltime=static_cast<cool::ValidityKey>(mktime(&mytm2));
       itime+=24*60*60-caltime;
       return itime*static_cast<cool::ValidityKey>(1.E9);
     } else {
       std::cout << 
     "ERROR in format of time value, use e.g. 2007-05-25:14:01:00" <<
     std::endl;
       return 0;
     }
   }
 }

◆ transConn()

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

staticprivate

Definition at line 450 of file AtlCoolCopy.cxx.

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

◆ 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 1356 of file AtlCoolCopy.cxx.

                                                    {
  
   std::cout << "Verifying tag " << sourcetag << " of folder " << folder << 
     std::endl;
   destfl->setPrefetchAll(false);
   cool::FolderVersioning::Mode vermode=sourcefl->versioningMode();
   int nobj=0;
   cool::IObjectIteratorPtr sourceitr,destitr;
   CoraCoolObjectIterPtr csourceitr,cdestitr;
   std::string tag=sourcetag;
   if (vermode==cool::FolderVersioning::SINGLE_VERSION || sourcetag=="HEAD") 
     tag="";
   try {
     if (iscora) {
       sourceflc->setPrefetchAll(false);
       csourceitr=sourceflc->browseObjects(since,until,m_chansel,tag);
       cdestitr=destflc->browseObjects(since,until,m_chansel,tag);
     } else {
       sourceitr=sourcefl->browseObjects(since,until,m_chansel,tag);
       destitr=destfl->browseObjects(since,until,m_chansel,tag);
     }
   }
   catch (std::exception& e) {
     std::cout << "Exception thrown from verify iterator setup: " << e.what() <<
       std::endl;
     return 105;
   }
   try {
     // the check algorithm assumes the two databases will give back the 
     // results of the query in the same order, which is currently the 
     // case in COOL 1.3. If this changes, the verification will be more complex
     if (iscora) {
       const std::string& cfkey=sourceflc->coralFKey();
       const std::string& cpkey=sourceflc->coralPKey();
       while (csourceitr->hasNext()) {
     CoraCoolObjectPtr sobj=csourceitr->next();
     // check object should not be skipped as excluded channel
     if (!m_excludechans.empty()) {
       if (find(m_excludechans.begin(),m_excludechans.end(),
            sobj->channelId())!=m_excludechans.end()) {
         continue;
       }
     }
     if (cdestitr->hasNext()) {
       CoraCoolObjectPtr dobj=cdestitr->next();
       // check objects are the same
       int iret=0;
       // check IOV equality
       if (sobj->since()!=dobj->since() || sobj->until()!=dobj->until())
         iret=100;
       // check channel equality
       if (sobj->channelId()!=dobj->channelId()) 
         iret=101;
       // check size of payloads
       if (sobj->size()!=dobj->size()) {
         std::cout << "ERROR CoraCool object " << nobj << 
           " sizes do not match: " << sobj->size() << " " << dobj->size() 
               << std::endl;
         iret=102;
       }
       // check payload equality (does not check attribute names)
       CoraCoolObject::const_iterator ditr=dobj->begin();
       for (CoraCoolObject::const_iterator sitr=sobj->begin();
            sitr!=sobj->end();++sitr,++ditr) {
         // loop over all the attributes, in order to skip PK and FK
         for (coral::AttributeList::const_iterator aitr=sitr->begin();
          aitr!=sitr->end();++aitr) {
           const std::string& aname=aitr->specification().name();
           if (aname!=cfkey && aname!=cpkey) {
         try {
           if (*aitr!=(*ditr)[aname]) {
             std::cout << "ERROR Values of attriute " << aname << 
               " differ" << std::endl;
             iret=102;
           }
         }
         catch (coral::AttributeListException& e) {
           std::cout << "ERROR: CoraCool attribute " << aname << 
             " not found in destination!" << std::endl;
           iret=102;
         }
           }
         }
       }
       if (iret!=0) {
         std::cout << "ERROR database entries do not match: since: " << 
           sobj->since() << "," << dobj->since() << " until: " <<
           sobj->until() << "," << dobj->until() << " channel: " <<
               sobj->channelId() << "," << dobj->channelId() << std::endl;
         return iret;
       }
     } else {
       std::cout << 
            "ERROR destination folder no matching CoraCool iterator for object "
           << nobj << std::endl;
       return 103;
     }
     ++ nobj;
       }
     } else {
       while (sourceitr->goToNext()) {
         const cool::IObject& sobj=sourceitr->currentRef();
     // check object should not be skipped as excluded channel
     if (!m_excludechans.empty()) {
       if (find(m_excludechans.begin(),m_excludechans.end(),
            sobj.channelId())!=m_excludechans.end()) {
         continue;
       }
     }
         if (checkrefs) checkRef(sobj.payload(),folder,sourcetag);
         if (destitr->goToNext()) {
       const cool::IObject& dobj=destitr->currentRef();
       // check objects are the same
       int iret=0;
       // check IOV equality
       if (sobj.since()!=dobj.since() || sobj.until()!=dobj.until())
         iret=100;
       // check channel equality
       if (sobj.channelId()!=dobj.channelId()) 
         iret=101;
       // check payload equality (does not check attribute names)
       // do not use cool::IRecord equality operator as does not correctly 
       // handle null values
       if (paymode==cool::PayloadMode::VECTORPAYLOAD) {
         cool::IRecordIterator& spitr=sobj.payloadIterator();
         const cool::IRecordVectorPtr svptr=spitr.fetchAllAsVector();
         cool::IRecordIterator& dpitr=dobj.payloadIterator();    
         const cool::IRecordVectorPtr dvptr=dpitr.fetchAllAsVector();
         if (svptr->size()!=dvptr->size()) {
           iret=102;
         } else {
           // loop through the payloads, checking equality - assumes
           // order is significant and same in source and destination DBs
           cool::IRecordVector::const_iterator svitr=svptr->begin();
           cool::IRecordVector::const_iterator svend=svptr->end();
           cool::IRecordVector::const_iterator dvitr=dvptr->begin();
           for (;svitr!=svend;++svitr,++dvitr) {
         if (!equalRecord(**svitr,**dvitr)) iret=102;
           }
         }
         if (iret!=0) {
           std::cout << "ERROR vector payloads do not match (size " << svptr->size() << "," << dvptr->size() << ")" << std::endl;
         }
         
       } else {
         // standard COOL folder - simple check of payloads
         if (!equalRecord(sobj.payload(),dobj.payload())) iret=102;
       }
  
       if (iret!=0) {
         std::cout << "ERROR database entries do not match: since: " << 
           sobj.since() << "," << dobj.since() << " until: " <<
           sobj.until() << "," << dobj.until() << " channel: " <<
               sobj.channelId() << "," << dobj.channelId() << std::endl;
         std::cout << "Source payload:" << std::endl;
         sobj.payload().attributeList().toOutputStream(std::cout);
         std::cout << std::endl << "Destination payload:" << std::endl;
         dobj.payload().attributeList().toOutputStream(std::cout);
         std::cout << std::endl;
         return iret;
       }
         } else {  
       std::cout << 
            "ERROR destination folder no matching iterator for object "
           << nobj << std::endl;
       return 103;
         }
         ++nobj;
       }
     }
   }
   catch (cool::Exception& e) {
     std::cout << "Exception thrown from verify loop: " << e.what() <<
       std::endl;
     return 104;
   }
   // finished with the iterators
   if (iscora) {
   } else {
     sourceitr->close();
     destitr->close();
   }
   std::cout << "Verification of folder " << folder << " tag " << 
     sourcetag << " OK (" << nobj << " objects)" << std::endl;
   return 0;
 }

◆ writeTagInfo()

int AtlCoolCopy::writeTagInfo ( )

private

Definition at line 3098 of file AtlCoolCopy.cxx.

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

Member Data Documentation

◆ m_addguid

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

private

Definition at line 245 of file AtlCoolCopy.cxx.

◆ m_addlfn

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

private

Definition at line 246 of file AtlCoolCopy.cxx.

◆ m_alliov

bool AtlCoolCopy::m_alliov

private

Definition at line 181 of file AtlCoolCopy.cxx.

◆ m_allowcreate

bool AtlCoolCopy::m_allowcreate

private

Definition at line 174 of file AtlCoolCopy.cxx.

◆ m_anadelt

long long AtlCoolCopy::m_anadelt

private

Definition at line 237 of file AtlCoolCopy.cxx.

◆ m_analyse

bool AtlCoolCopy::m_analyse

private

Definition at line 185 of file AtlCoolCopy.cxx.

◆ m_applock

bool AtlCoolCopy::m_applock

private

Definition at line 206 of file AtlCoolCopy.cxx.

◆ m_applocksv

bool AtlCoolCopy::m_applocksv

private

Definition at line 207 of file AtlCoolCopy.cxx.

◆ m_bufsize

int AtlCoolCopy::m_bufsize

private

Definition at line 235 of file AtlCoolCopy.cxx.

◆ m_channel1

std::string AtlCoolCopy::m_channel1

private

Definition at line 233 of file AtlCoolCopy.cxx.

◆ m_channel2

std::string AtlCoolCopy::m_channel2

private

Definition at line 234 of file AtlCoolCopy.cxx.

◆ m_channelRange

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

private

Definition at line 232 of file AtlCoolCopy.cxx.

◆ m_chansel

cool::ChannelSelection AtlCoolCopy::m_chansel

private

Definition at line 268 of file AtlCoolCopy.cxx.

◆ m_chdesc

bool AtlCoolCopy::m_chdesc

private

Definition at line 193 of file AtlCoolCopy.cxx.

◆ m_checkdesttag

bool AtlCoolCopy::m_checkdesttag

private

Definition at line 220 of file AtlCoolCopy.cxx.

◆ m_checkoutputfile

std::string AtlCoolCopy::m_checkoutputfile

private

Definition at line 241 of file AtlCoolCopy.cxx.

◆ m_checkrefs

bool AtlCoolCopy::m_checkrefs

private

Definition at line 186 of file AtlCoolCopy.cxx.

◆ m_coolapp

cool::Application AtlCoolCopy::m_coolapp

private

Definition at line 254 of file AtlCoolCopy.cxx.

◆ m_cooltagmap

CoolTagMap AtlCoolCopy::m_cooltagmap

private

Definition at line 280 of file AtlCoolCopy.cxx.

◆ m_copytaginfo

bool AtlCoolCopy::m_copytaginfo

private

Definition at line 215 of file AtlCoolCopy.cxx.

◆ m_copytaglock

bool AtlCoolCopy::m_copytaglock

private

Definition at line 216 of file AtlCoolCopy.cxx.

◆ m_coracool

bool AtlCoolCopy::m_coracool

private

Definition at line 217 of file AtlCoolCopy.cxx.

◆ m_coralsvc

coral::ConnectionService AtlCoolCopy::m_coralsvc

private

Definition at line 253 of file AtlCoolCopy.cxx.

◆ m_dbSvc

cool::IDatabaseSvc* AtlCoolCopy::m_dbSvc

private

Definition at line 255 of file AtlCoolCopy.cxx.

◆ m_debug

bool AtlCoolCopy::m_debug

private

Definition at line 180 of file AtlCoolCopy.cxx.

◆ m_destCoraPtr

CoraCoolDatabasePtr AtlCoolCopy::m_destCoraPtr

private

Definition at line 260 of file AtlCoolCopy.cxx.

◆ m_destdb

std::string AtlCoolCopy::m_destdb

private

Definition at line 173 of file AtlCoolCopy.cxx.

◆ m_destDbPtr

cool::IDatabasePtr AtlCoolCopy::m_destDbPtr

private

Definition at line 258 of file AtlCoolCopy.cxx.

◆ m_excludechans

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

private

Definition at line 248 of file AtlCoolCopy.cxx.

◆ m_excludehead

bool AtlCoolCopy::m_excludehead

private

Definition at line 177 of file AtlCoolCopy.cxx.

◆ m_folderexcl

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

private

Definition at line 262 of file AtlCoolCopy.cxx.

◆ m_folderlist

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

private

Definition at line 261 of file AtlCoolCopy.cxx.

◆ m_forcemulti

bool AtlCoolCopy::m_forcemulti

private

Definition at line 197 of file AtlCoolCopy.cxx.

◆ m_forcenopay

bool AtlCoolCopy::m_forcenopay

private

Definition at line 201 of file AtlCoolCopy.cxx.

◆ m_forcepay

bool AtlCoolCopy::m_forcepay

private

Definition at line 200 of file AtlCoolCopy.cxx.

◆ m_forcerune

bool AtlCoolCopy::m_forcerune

private

Definition at line 198 of file AtlCoolCopy.cxx.

◆ m_forcesingle

bool AtlCoolCopy::m_forcesingle

private

Definition at line 196 of file AtlCoolCopy.cxx.

◆ m_forcetime

bool AtlCoolCopy::m_forcetime

private

Definition at line 199 of file AtlCoolCopy.cxx.

◆ m_getbulk

bool AtlCoolCopy::m_getbulk

private

Definition at line 212 of file AtlCoolCopy.cxx.

◆ m_getonline

bool AtlCoolCopy::m_getonline

private

Definition at line 210 of file AtlCoolCopy.cxx.

◆ m_gettime

bool AtlCoolCopy::m_gettime

private

Definition at line 209 of file AtlCoolCopy.cxx.

◆ m_hiparent

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

private

Definition at line 276 of file AtlCoolCopy.cxx.

◆ m_hitag

bool AtlCoolCopy::m_hitag

private

Definition at line 194 of file AtlCoolCopy.cxx.

◆ m_hitagmap

HiTagMap AtlCoolCopy::m_hitagmap

private

Definition at line 274 of file AtlCoolCopy.cxx.

◆ m_ignoremode

bool AtlCoolCopy::m_ignoremode

private

Definition at line 218 of file AtlCoolCopy.cxx.

◆ m_ignorespec

bool AtlCoolCopy::m_ignorespec

private

Definition at line 219 of file AtlCoolCopy.cxx.

◆ m_includehead

bool AtlCoolCopy::m_includehead

private

Definition at line 176 of file AtlCoolCopy.cxx.

◆ m_listpfn

bool AtlCoolCopy::m_listpfn

private

Definition at line 187 of file AtlCoolCopy.cxx.

◆ m_lockedonly

bool AtlCoolCopy::m_lockedonly

private

Definition at line 214 of file AtlCoolCopy.cxx.

◆ m_magic

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

private

Definition at line 264 of file AtlCoolCopy.cxx.

◆ m_mergecat

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

private

Definition at line 266 of file AtlCoolCopy.cxx.

◆ m_newdataset

std::string AtlCoolCopy::m_newdataset

private

Definition at line 240 of file AtlCoolCopy.cxx.

◆ m_newrunemax

cool::ValidityKey AtlCoolCopy::m_newrunemax

private

Definition at line 227 of file AtlCoolCopy.cxx.

◆ m_newrunemin

cool::ValidityKey AtlCoolCopy::m_newrunemin

private

Definition at line 226 of file AtlCoolCopy.cxx.

◆ m_newtimemax

cool::ValidityKey AtlCoolCopy::m_newtimemax

private

Definition at line 229 of file AtlCoolCopy.cxx.

◆ m_newtimemin

cool::ValidityKey AtlCoolCopy::m_newtimemin

private

Definition at line 228 of file AtlCoolCopy.cxx.

◆ m_nochannel

bool AtlCoolCopy::m_nochannel

private

Definition at line 192 of file AtlCoolCopy.cxx.

◆ m_noclobroot

bool AtlCoolCopy::m_noclobroot

private

Definition at line 221 of file AtlCoolCopy.cxx.

◆ m_nocopy

bool AtlCoolCopy::m_nocopy

private

Definition at line 190 of file AtlCoolCopy.cxx.

◆ m_nodata

bool AtlCoolCopy::m_nodata

private

Definition at line 191 of file AtlCoolCopy.cxx.

◆ m_nohitag

bool AtlCoolCopy::m_nohitag

private

Definition at line 195 of file AtlCoolCopy.cxx.

◆ m_nt_bufferptr

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

private

Definition at line 294 of file AtlCoolCopy.cxx.

◆ m_nt_channel

UInt_t AtlCoolCopy::m_nt_channel = 0

private

Definition at line 291 of file AtlCoolCopy.cxx.

◆ m_nt_lbsince

UInt_t AtlCoolCopy::m_nt_lbsince = 0

private

Definition at line 289 of file AtlCoolCopy.cxx.

◆ m_nt_lbuntil

UInt_t AtlCoolCopy::m_nt_lbuntil = 0

private

Definition at line 290 of file AtlCoolCopy.cxx.

◆ m_nt_runsince

UInt_t AtlCoolCopy::m_nt_runsince = 0

private

Definition at line 287 of file AtlCoolCopy.cxx.

◆ m_nt_rununtil

UInt_t AtlCoolCopy::m_nt_rununtil = 0

private

Definition at line 288 of file AtlCoolCopy.cxx.

◆ m_nt_since

ULong64_t AtlCoolCopy::m_nt_since = 0

private

Definition at line 285 of file AtlCoolCopy.cxx.

◆ m_nt_tagid

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

private

Definition at line 292 of file AtlCoolCopy.cxx.

◆ m_nt_treename

std::string AtlCoolCopy::m_nt_treename

private

Definition at line 293 of file AtlCoolCopy.cxx.

◆ m_nt_until

ULong64_t AtlCoolCopy::m_nt_until = 0

private

Definition at line 286 of file AtlCoolCopy.cxx.

◆ m_onlinerun

bool AtlCoolCopy::m_onlinerun

private

Definition at line 211 of file AtlCoolCopy.cxx.

◆ m_open

bool AtlCoolCopy::m_open

private

Definition at line 267 of file AtlCoolCopy.cxx.

◆ m_outfolder

std::string AtlCoolCopy::m_outfolder

private

Definition at line 238 of file AtlCoolCopy.cxx.

◆ m_outtag

std::string AtlCoolCopy::m_outtag

private

Definition at line 239 of file AtlCoolCopy.cxx.

◆ m_parfile

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

private

Definition at line 247 of file AtlCoolCopy.cxx.

◆ m_poolall

bool AtlCoolCopy::m_poolall

private

Definition at line 189 of file AtlCoolCopy.cxx.

◆ m_poolcat

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

private

Definition at line 265 of file AtlCoolCopy.cxx.

◆ m_poollast

PoolMap::iterator AtlCoolCopy::m_poollast

private

Definition at line 270 of file AtlCoolCopy.cxx.

◆ m_poolopen

bool AtlCoolCopy::m_poolopen

private

Definition at line 188 of file AtlCoolCopy.cxx.

◆ m_poolrefs

PoolMap AtlCoolCopy::m_poolrefs

private

Definition at line 271 of file AtlCoolCopy.cxx.

◆ m_prunetags

bool AtlCoolCopy::m_prunetags

private

Definition at line 213 of file AtlCoolCopy.cxx.

◆ m_readoracle

bool AtlCoolCopy::m_readoracle

private

Definition at line 208 of file AtlCoolCopy.cxx.

◆ m_recreate

bool AtlCoolCopy::m_recreate

private

Definition at line 175 of file AtlCoolCopy.cxx.

◆ m_repsort

ReplicaSorter* AtlCoolCopy::m_repsort

private

Definition at line 256 of file AtlCoolCopy.cxx.

◆ m_root

bool AtlCoolCopy::m_root

private

Definition at line 183 of file AtlCoolCopy.cxx.

◆ m_runemax

cool::ValidityKey AtlCoolCopy::m_runemax

private

Definition at line 223 of file AtlCoolCopy.cxx.

◆ m_runemin

cool::ValidityKey AtlCoolCopy::m_runemin

private

Definition at line 222 of file AtlCoolCopy.cxx.

◆ m_runfile

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

private

Definition at line 249 of file AtlCoolCopy.cxx.

◆ m_runinfohost

std::string AtlCoolCopy::m_runinfohost

private

Definition at line 244 of file AtlCoolCopy.cxx.

◆ m_runlist

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

private

Definition at line 250 of file AtlCoolCopy.cxx.

◆ m_sealmsg

int AtlCoolCopy::m_sealmsg

private

Definition at line 236 of file AtlCoolCopy.cxx.

◆ m_skipout

bool AtlCoolCopy::m_skipout

private

Definition at line 204 of file AtlCoolCopy.cxx.

◆ m_skiprep

bool AtlCoolCopy::m_skiprep

private

Definition at line 205 of file AtlCoolCopy.cxx.

◆ m_sourceCoraPtr

CoraCoolDatabasePtr AtlCoolCopy::m_sourceCoraPtr

private

Definition at line 259 of file AtlCoolCopy.cxx.

◆ m_sourcedb

std::string AtlCoolCopy::m_sourcedb

private

Definition at line 172 of file AtlCoolCopy.cxx.

◆ m_sourceDbPtr

cool::IDatabasePtr AtlCoolCopy::m_sourceDbPtr

private

Definition at line 257 of file AtlCoolCopy.cxx.

◆ m_sourceread

bool AtlCoolCopy::m_sourceread

private

Definition at line 202 of file AtlCoolCopy.cxx.

◆ m_srunemax

cool::ValidityKey AtlCoolCopy::m_srunemax

private

Definition at line 231 of file AtlCoolCopy.cxx.

◆ m_srunemin

cool::ValidityKey AtlCoolCopy::m_srunemin

private

Definition at line 230 of file AtlCoolCopy.cxx.

◆ m_taglabel

std::string AtlCoolCopy::m_taglabel

private

Definition at line 243 of file AtlCoolCopy.cxx.

◆ m_tags

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

private

Definition at line 263 of file AtlCoolCopy.cxx.

◆ m_timedb

std::string AtlCoolCopy::m_timedb

private

Definition at line 242 of file AtlCoolCopy.cxx.

◆ m_timemax

cool::ValidityKey AtlCoolCopy::m_timemax

private

Definition at line 225 of file AtlCoolCopy.cxx.

◆ m_timemin

cool::ValidityKey AtlCoolCopy::m_timemin

private

Definition at line 224 of file AtlCoolCopy.cxx.

◆ m_truncate

bool AtlCoolCopy::m_truncate

private

Definition at line 203 of file AtlCoolCopy.cxx.

◆ m_usertags

bool AtlCoolCopy::m_usertags

private

Definition at line 178 of file AtlCoolCopy.cxx.

◆ m_userupdatehead

bool AtlCoolCopy::m_userupdatehead

private

Definition at line 179 of file AtlCoolCopy.cxx.

◆ m_verify

bool AtlCoolCopy::m_verify

private

Definition at line 182 of file AtlCoolCopy.cxx.

◆ m_zeronull

bool AtlCoolCopy::m_zeronull

private

Definition at line 184 of file AtlCoolCopy.cxx.

◆ p_rootfile

TFile* AtlCoolCopy::p_rootfile

private

Definition at line 282 of file AtlCoolCopy.cxx.

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

AtlCoolCopy.cxx

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ CoolTagMap

◆ HiTagMap

◆ PoolMap

Constructor & Destructor Documentation

◆ AtlCoolCopy()

Member Function Documentation

◆ addExclude()

◆ addFolder()

◆ adjustIOVs()

◆ analyseIOVs()

◆ ATLAS_NOT_THREAD_SAFE() [1/4]

◆ ATLAS_NOT_THREAD_SAFE() [2/4]

◆ ATLAS_NOT_THREAD_SAFE() [3/4]

◆ ATLAS_NOT_THREAD_SAFE() [4/4]

◆ bookOrFindTH1F()

◆ channelID()

◆ checkChannels()

◆ checkRef()

◆ equalRecord()

◆ filePoolRefs()

◆ getBulkRun()

◆ getCoolHistGUID()

◆ getLockedTags()

◆ getOnlineRun()

◆ getRunList()

◆ getTimeFromRun()

◆ getUpdateMode()

◆ isNumeric()

◆ isOpen()

◆ listPoolRefs()

◆ nocopyIOVs()

◆ openConnections()

◆ openCoraCool()

◆ procOptVector()

◆ rootAllocate()

◆ rootDirs()

◆ rootIOVs()

◆ rootWrite()

◆ runLBVal()

◆ setChannelRange()

◆ setOpts()

◆ setupCatalog()

◆ tagParents()

◆ timeString()

◆ timeVal()

◆ transConn()

◆ verifyIOVs()

◆ writeTagInfo()

Member Data Documentation

◆ m_addguid

◆ m_addlfn

◆ m_alliov

◆ m_allowcreate

◆ m_anadelt

◆ m_analyse

◆ m_applock

◆ m_applocksv

◆ m_bufsize

◆ m_channel1

◆ m_channel2

◆ m_channelRange

◆ m_chansel

◆ m_chdesc

◆ m_checkdesttag

◆ m_checkoutputfile

◆ m_checkrefs

◆ m_coolapp

◆ m_cooltagmap

◆ m_copytaginfo

◆ m_copytaglock

◆ m_coracool

◆ m_coralsvc

◆ m_dbSvc