![Logo](../../ATLAS-Logo-Square-Blue-RGB.png) |
ATLAS Offline Software
|
|
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 () |
|
Definition at line 81 of file AtlCoolCopy.cxx.
◆ CoolTagMap
◆ HiTagMap
◆ PoolMap
◆ AtlCoolCopy()
AtlCoolCopy::AtlCoolCopy |
( |
const std::string & |
sourcedb, |
|
|
const std::string & |
destdb, |
|
|
bool |
allowcreate = false |
|
) |
| |
Definition at line 301 of file AtlCoolCopy.cxx.
335 coral::IConnectionServiceConfiguration& csconfig=
m_coralsvc.configuration();
336 csconfig.disablePoolAutomaticCleanUp();
337 csconfig.setConnectionTimeOut(0);
◆ addExclude()
bool AtlCoolCopy::addExclude |
( |
const std::string & |
folder | ) |
|
Definition at line 529 of file AtlCoolCopy.cxx.
530 std::cout <<
"Adding folder to exclude list: " <<
folder << std::endl;
◆ addFolder()
bool AtlCoolCopy::addFolder |
( |
const std::string & |
folder, |
|
|
const bool |
onlyTags |
|
) |
| |
Definition at line 461 of file AtlCoolCopy.cxx.
462 std::cout <<
"Add folders in path:" <<
folder <<
" [ ";
463 const std::vector<std::string> nodelist=
m_sourceDbPtr->listAllNodes();
465 for (std::vector<std::string>::const_iterator nodeitr=nodelist.begin();
466 nodeitr!=nodelist.end();++nodeitr) {
472 nodeitr->size()>
folder.size() && nodeitr->compare(
folder.size(),1,
"/")==0)) {
475 for (std::vector<std::string>::const_iterator iexcl=
m_folderexcl.begin();
477 if (iexcl->compare(0,1,
"/")==0) {
490 std::cout << *nodeitr <<
" ";
497 const std::vector<std::string> foldersettags=
499 if (!foldersettags.empty()) {
500 for (std::vector<std::string>::const_iterator
501 itr=foldersettags.begin();itr!=foldersettags.end();++itr) {
508 cool::IFolderSetPtr sfolder=
m_sourceDbPtr->getFolderSet(*nodeitr);
509 for (std::vector<std::string>::const_iterator toptag=
m_tags.begin();
510 toptag!=
m_tags.end();++toptag) {
512 std::string rtag=sfolder->resolveTag(*toptag);
525 std::cout <<
"]" << std::endl;
◆ 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.
1314 if (newsince<qsince) newsince=qsince;
1315 if (newuntil>quntil) newuntil=quntil;
1318 if (newuntil<newsince)
throw cool::Exception(
1319 "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 1847 of file AtlCoolCopy.cxx.
1852 std::cout <<
"Analyse tag " << sourcetag <<
" of folder " <<
folder <<
1856 std::cout <<
"Analyse time structures with tolerance of " <<
1857 m_anadelt/1.E9 <<
" seconds " << std::endl;
1862 std::cout <<
"Make directory " <<
dirname << std::endl;
1867 std::vector<cool::ChannelId>
channels=sourcefl->listChannels();
1870 long long* lastiov=
new long long[
nchan];
1871 long long* iovtotlen=
new long long[
nchan];
1872 long long* iovtotgap=
new long long[
nchan];
1873 int* iovn=
new int[
nchan];
1874 for (
unsigned int i=0;
i<
nchan;++
i) {
1880 cool::ValidityKey globsince=cool::ValidityKeyMax;
1881 cool::ValidityKey globuntil=cool::ValidityKeyMin;
1887 "IOVs per channel-name (copy of IOVSperChannel)",
1894 TH1F* h_anadelt=
nullptr;
1895 TH1F* h_chandelt=
nullptr;
1897 h_anadelt=
bookOrFindTH1F(
"IOVAlignLogDelT",
"IOV alignment log deltaT",
1901 h_chandelt=
bookOrFindTH1F(
"AlignedChanPerIOV",
"Aligned channels per IOV",
1904 std::cout <<
"Booked histograms for folder with " <<
nchan <<
" channels"
1907 using IOVTimeMap = std::map<cool::ValidityKey, int>;
1908 IOVTimeMap iov_time_map;
1913 cool::IObjectIteratorPtr sourceitr;
1915 if (vermode==cool::FolderVersioning::SINGLE_VERSION) {
1921 catch (cool::Exception&
e) {
1922 std::cout <<
"Exception thrown from analysis copy iterator setup: " <<
1923 e.what() << std::endl;
1927 std::map<cool::ChannelId,std::string>
1928 chanmap=sourcefl->listChannelsWithNames();
1931 while (sourceitr->goToNext()) {
1932 const cool::IObject& sobj=sourceitr->currentRef();
1934 cool::ChannelId ichanid=sobj.channelId();
1935 const std::string& cname=chanmap[ichanid];
1939 if (chanitr.first!=chanitr.second) {
1943 h_iovname->GetXaxis()->SetBinLabel(
bin,cname.c_str());
1945 h_iovname->Fill(
ichan);
1947 cool::ValidityKey since2=sobj.since();
1948 cool::ValidityKey until2=sobj.until();
1949 if (since2<globsince) globsince=since2;
1951 if (until2!=cool::ValidityKeyMax) {
1952 if (until2>globuntil) globuntil=until2;
1953 long long len=until2-since2;
1954 h_iovlength->Fill(log10(len));
1956 iovtotlen[
ichan]+=len;
1958 if (lastiov[
ichan]<
static_cast<long long>(since2) &&
1959 lastiov[
ichan]>=0) {
1961 long long gap=since2-lastiov[
ichan];
1963 h_iovgap->Fill(log10(
gap));
1964 std::cout <<
"Gap of " <<
gap << std::endl;
1966 if (until2!=cool::ValidityKeyMax) {
1967 lastiov[
ichan]=until2;
1969 lastiov[
ichan]=since2;
1979 if (hiitr!=iov_time_map.end()) {
1981 del1=hiitr->first-since2;
1983 if (lowitr!=iov_time_map.begin()) {
1986 del2=since2-lowitr->first;
1991 if (del1<=m_anadelt && del1>-1) {
1996 if (del2<=m_anadelt && del2>-1 && (del2<del || del==-1)) {
2004 h_anadelt->Fill(log10(del));
2006 h_anadelt->Fill(0.);
2009 iov_time_map[since2]=0;
2014 std::cout <<
"ERROR :Channel " << ichanid <<
2015 " not found in channel list - ignored" << std::endl;
2019 std::cout <<
"Finished analysis with " << nobj <<
" objects" << std::endl;
2021 std::cout <<
"IOV timestamp range: " << globsince <<
" " <<
2022 timeString(globsince) <<
"to " << globuntil <<
" " <<
2025 std::cout <<
"IOV run/LB range [" << (globsince >> 32) <<
"," <<
2026 (globsince & 0
xFFFFFFFF) <<
"] to [" << (globuntil >> 32) <<
"," <<
2027 (globuntil & 0
xFFFFFFFF) <<
"]" << std::endl;
2033 "Mean IOV length per channel",
nchan,-0.5,
nchan-0.5);
2034 for (
unsigned int i=0;
i<
nchan;++
i) {
2038 occ=1.-
float(iovtotgap[
i])/
float(iovtotlen[
i]+iovtotgap[
i]);
2039 avlen=
float(iovtotlen[
i])/iovn[
i];
2041 h_iovoccchan->Fill(
i,occ);
2042 h_iovlenchan->Fill(
i,avlen);
2045 std::cout <<
"Alignment analysis: " << iov_time_map.size()
2046 <<
" seperate IOV starts (tolerance " <<
m_anadelt/1.E9 <<
2047 " seconds)" << std::endl;
2049 for (IOVTimeMap::const_iterator itr=iov_time_map.begin();
2050 itr!=iov_time_map.end();++itr) {
2051 h_chandelt->Fill(itr->second);
2055 catch (cool::Exception&
e) {
2056 std::cout <<
"Exception thrown from folder analysis reading loop: " <<
2057 e.what() << std::endl;
2062 delete [] iovtotlen;
2063 delete [] iovtotgap;
2064 delete[] iovn; iovn=
nullptr;
◆ 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()
◆ channelID()
cool::ChannelId AtlCoolCopy::channelID |
( |
const cool::IFolderPtr & |
folder, |
|
|
const std::string & |
chanstring |
|
) |
| |
|
staticprivate |
Definition at line 856 of file AtlCoolCopy.cxx.
858 const char* cstr=chanstring.c_str();
861 return cool::ChannelId(strtoul(cstr,
nullptr,10));
863 cool::ChannelId
chan=0;
866 std::cout <<
"Channel name " << chanstring <<
" maps to channelID "
867 <<
chan << std::endl;
869 catch (cool::Exception&
e) {
870 std::cout <<
"ERROR: Channel name " << chanstring <<
871 " not defined in folder " << std::endl;
◆ checkChannels()
bool AtlCoolCopy::checkChannels |
( |
const std::string & |
folder, |
|
|
const cool::IFolderPtr & |
sourcefl, |
|
|
const cool::IFolderPtr & |
destfl, |
|
|
bool |
newfolder |
|
) |
| |
|
private |
Definition at line 2911 of file AtlCoolCopy.cxx.
2918 const std::map<cool::ChannelId,std::string> chanmap=
2919 sourcefl->listChannelsWithNames();
2920 if (
m_debug) std::cout <<
"Checking channels table for folder " <<
folder
2921 <<
" with " << chanmap.size() <<
" channels" << std::endl;
2925 for (std::map<cool::ChannelId,std::string>::const_iterator
2926 itr=chanmap.begin();itr!=chanmap.end();++itr) {
2928 const cool::ChannelId
chan=itr->first;
2936 const std::string& sourcename=itr->second;
2938 std::string sourcedesc=
"";
2939 if (
m_chdesc) sourcedesc=sourcefl->channelDescription(
chan);
2942 const std::string & destname=destfl->channelName(
chan);
2943 std::string destdesc=
"";
2944 if (
m_chdesc) destdesc=destfl->channelDescription(
chan);
2946 if (sourcename!=destname && !sourcename.empty()) {
2949 std::cout <<
"ERROR: Channel " <<
chan <<
" names differ: " <<
2950 sourcename <<
" " << destname << std::endl;
2953 destfl->setChannelName(
chan,sourcename);
2954 std::cout <<
"Modify channel " <<
chan <<
" name from "
2955 << destname <<
" to " << sourcename << std::endl;
2958 if (sourcedesc!=destdesc && !sourcedesc.empty()) {
2961 std::cout <<
"ERROR: Channel " <<
chan <<
" descriptions differ: "
2962 << sourcedesc <<
" " << destdesc << std::endl;
2965 std::cout <<
"Modify channel " <<
chan <<
" description from "
2966 << sourcedesc <<
" to " << destdesc << std::endl;
2967 destfl->setChannelDescription(
chan,sourcedesc);
2974 if (
m_debug) std::cout <<
"Create new channel " <<
chan <<
" name "
2975 << sourcename <<
" description" << sourcedesc << std::endl;
2976 destfl->createChannel(
chan,sourcename,sourcedesc);
2980 if (ncreate>0) std::cout <<
"Created " << ncreate <<
" new channels for "
2982 if (nmodify>0) std::cout <<
"Modified " << nmodify <<
" channel info for "
◆ checkRef()
void AtlCoolCopy::checkRef |
( |
const cool::IRecord & |
payload, |
|
|
const std::string & |
folder, |
|
|
const std::string & |
tag |
|
) |
| |
|
private |
Definition at line 2988 of file AtlCoolCopy.cxx.
2991 if (
name==
"PoolRef" ||
name==
"fileGUID") {
2992 std::string poolref;
2993 std::string addr=
payload[0].data<std::string>();
2994 if (
name==
"PoolRef") {
2995 std::string::size_type iofs1=addr.find(
"[DB=");
2996 std::string::size_type iofs2=addr.find(
']',iofs1);
2997 if (iofs1!=std::string::npos && iofs2!=std::string::npos && iofs2>iofs1) {
2998 poolref=addr.substr(iofs1+4,iofs2-iofs1-4);
3000 std::cout <<
"ERROR: Badly formed POOL object reference " <<
◆ equalRecord()
bool AtlCoolCopy::equalRecord |
( |
const cool::IRecord & |
lhs, |
|
|
const cool::IRecord & |
rhs |
|
) |
| |
|
staticprivate |
Definition at line 2499 of file AtlCoolCopy.cxx.
2503 if (lhs.size()!=rhs.size())
return false;
2504 for (
size_t i=0;
i<lhs.size();++
i) {
2506 if (lhs[
i].specification().storageType()!=
2507 rhs[
i].specification().storageType())
2510 if (lhs[
i]!=rhs[
i]) {
2513 const cool::StorageType& stype=lhs[
i].specification().storageType();
2514 if (stype==cool::StorageType::String255 ||
2515 stype==cool::StorageType::String4k ||
2516 stype==cool::StorageType::String64k ||
2517 stype==cool::StorageType::String16M) {
2519 if (lhs[
i].data<std::string>()!=rhs[
i].data<std::string>())
◆ filePoolRefs()
void AtlCoolCopy::filePoolRefs |
( |
| ) |
|
|
private |
Definition at line 3272 of file AtlCoolCopy.cxx.
3281 std::cout <<
"ErrCode GUID Count LFN PFN Folders ..." << std::endl;
3282 for (PoolMap::const_iterator ipool=
m_poolrefs.begin();
3284 if (
m_poolall || ipool->second.errcode()>0) {
3285 std::ostringstream
line;
3287 line << ipool->second.errcode() <<
" " << ipool->first <<
" " <<
3288 ipool->second.count() <<
" ";
3289 if (!ipool->second.lfn().empty()) {
3290 line << ipool->second.lfn() <<
" ";
3294 if (!ipool->second.pfn().empty()) {
3295 line << ipool->second.pfn() <<
" ";
3299 for (std::vector<std::string>::const_iterator
3300 itr=ipool->second.foldertag().begin();
3301 itr!=ipool->second.foldertag().end();++itr)
3302 line << *itr <<
" ";
3303 std::cout <<
line.str() << std::endl;
3304 chkostream <<
line.str() << std::endl;
◆ getBulkRun()
bool AtlCoolCopy::getBulkRun |
( |
| ) |
|
|
private |
Definition at line 2771 of file AtlCoolCopy.cxx.
2774 std::cout <<
"ERROR: -getonline and -getbulk cannot be used simultaneously"
2778 std::cout <<
"Call getbulk using URL" << std::endl;
2780 curl_global_init(CURL_GLOBAL_ALL);
2781 using uniqueCurl_t = std::unique_ptr<CURL,decltype(&curl_easy_cleanup)>;
2782 uniqueCurl_t curl(curl_easy_init(), curl_easy_cleanup);
2784 CURLcode
res = CURLE_OK;
2789 res = curl_easy_setopt(curl.get(), CURLOPT_URL,
url.c_str());
2790 if (
res != CURLE_OK) {
2791 std::cerr <<
"Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2795 res = curl_easy_setopt(curl.get(), CURLOPT_FOLLOWLOCATION, 1L);
2796 if (
res != CURLE_OK) {
2797 std::cerr <<
"Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2805 if (
res != CURLE_OK) {
2806 std::cerr <<
"Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2809 res = curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &
response);
2810 if (
res != CURLE_OK) {
2811 std::cerr <<
"Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2815 res = curl_easy_perform(curl.get());
2816 if (
res != CURLE_OK) {
2817 std::cerr <<
"Failed to perform request: " << curl_easy_strerror(
res) <<
":" <<
url.c_str() << std::endl;
2821 std::cout <<
"Response: " << std::endl;
2822 std::cout <<
response << std::endl;
2827 int nextrun = jsonData[
"run"];
2828 long long rtime = jsonData[
"timestamp"];
2829 std::cout <<
"Next run started will be " << nextrun << std::endl;
2830 std::cout <<
"Epoch time extracted " <<
rtime << std::endl;
2837 m_runemin=(
static_cast<long long>(nextrun)) << 32;
2841 }
catch (nlohmann::json::parse_error&
e) {
2842 std::cerr <<
"Failed to parse JSON response: " <<
e.what() << std::endl;
2844 }
catch (nlohmann::json::type_error&
e) {
2845 std::cerr <<
"Failed to extract data from JSON response: " <<
e.what() << std::endl;
2848 std::cerr <<
"Failed to extract run and timestamp from JSON response: " <<
e.what() << std::endl;
2854 std::cerr <<
"Failed to initialize libcurl." << std::endl;
2858 curl_global_cleanup();
◆ getCoolHistGUID()
std::string AtlCoolCopy::getCoolHistGUID |
( |
const std::string & |
file | ) |
|
|
staticprivate |
Definition at line 3256 of file AtlCoolCopy.cxx.
3258 std::string hguid=
"";
3259 TFile* myfile=TFile::Open(
file.c_str(),
"READ");
3260 if (myfile!=
nullptr) {
3262 myfile->GetObject(
"fileGUID",oguid);
3263 if (oguid!=
nullptr) {
3264 hguid=oguid->GetString();
3265 std::cout <<
"CoolHist GUID found to be " << hguid << std::endl;
◆ getLockedTags()
bool AtlCoolCopy::getLockedTags |
( |
| ) |
|
|
private |
Definition at line 430 of file AtlCoolCopy.cxx.
433 cool::IFolderSetPtr topfolder=
m_sourceDbPtr->getFolderSet(
"/");
434 const std::vector<std::string>& toptaglist=topfolder->listTags();
435 for (std::vector<std::string>::const_iterator toptag=toptaglist.begin();
436 toptag!=toptaglist.end();++toptag) {
438 if (tstat==cool::HvsTagLock::LOCKED ||
439 tstat==cool::HvsTagLock::PARTIALLYLOCKED) {
440 std::cout <<
"Top-level tag " << *toptag <<
" will be copied" <<
442 m_tags.push_back(*toptag);
445 std::cout <<
"Total of " <<
m_tags.size() <<
" top-level tags to be copied"
◆ getOnlineRun()
bool AtlCoolCopy::getOnlineRun |
( |
| ) |
|
|
private |
Definition at line 2683 of file AtlCoolCopy.cxx.
2687 std::cout <<
"Extracting current run-number from ATLAS_RUN_NUMBER @ ATONR_ADG ... " <<
2689 curl_global_init(CURL_GLOBAL_ALL);
2690 using uniqueCurl_t = std::unique_ptr<CURL,decltype(&curl_easy_cleanup)>;
2691 uniqueCurl_t curl(curl_easy_init(), curl_easy_cleanup);
2692 CURLcode
res = CURLE_OK;
2696 res = curl_easy_setopt(curl.get(), CURLOPT_URL,
url.c_str());
2697 if (
res != CURLE_OK) {
2698 std::cerr <<
"Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2702 res = curl_easy_setopt(curl.get(), CURLOPT_FOLLOWLOCATION, 1L);
2703 if (
res != CURLE_OK) {
2704 std::cerr <<
"Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2712 if (
res != CURLE_OK) {
2713 std::cerr <<
"Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2716 res = curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &
response);
2717 if (
res != CURLE_OK) {
2718 std::cerr <<
"Failed to perform request: curl_easy_setopt, line "<<__LINE__<<std::endl;
2723 res = curl_easy_perform(curl.get());
2724 if (
res != CURLE_OK) {
2725 std::cerr <<
"Failed to perform request: " << curl_easy_strerror(
res) <<
":" <<
url.c_str() << std::endl;
2729 std::cout <<
"Response: " << std::endl;
2730 std::cout <<
response << std::endl;
2736 int runNumber = jsonData[
"resources"][0][
"runnumber"];
2738 std::cout <<
"Next run started will be " << nextrun << std::endl;
2740 std::cout <<
"Epoch time extracted " <<
rtime << std::endl;
2747 m_runemin=(
static_cast<long long>(nextrun)) << 32;
2751 }
catch (nlohmann::json::parse_error&
e) {
2752 std::cerr <<
"Failed to parse JSON response: " <<
e.what() << std::endl;
2754 }
catch (nlohmann::json::type_error&
e) {
2755 std::cerr <<
"Failed to extract data from JSON response: " <<
e.what() << std::endl;
2758 std::cerr <<
"Failed to extract run and timestamp from JSON response: " <<
e.what() << std::endl;
2764 std::cerr <<
"Failed to initialize libcurl." << std::endl;
2768 curl_global_cleanup();
◆ getRunList()
bool AtlCoolCopy::getRunList |
( |
| ) |
|
|
private |
Definition at line 2863 of file AtlCoolCopy.cxx.
2865 for (std::vector<std::string>::const_iterator itr=
m_runfile.begin();
2867 std::cout <<
"Reading allowed run numbers from file " << *itr << std::endl;
2868 FILE* p_inp=fopen(itr->c_str(),
"r");
2869 if (p_inp==
nullptr) {
2870 std::cout <<
"File not found" << std::endl;
2873 char* p_buf=
new char[999];
2874 while (!feof(p_inp)) {
2875 char* p_line=fgets(p_buf,999,p_inp);
2876 if (p_line!=
nullptr) {
2877 unsigned int run=
atoi(p_line);
2885 std::cout <<
"Read list of " <<
m_runlist.size() <<
" runs from " <<
2886 m_runfile.size() <<
" input runlist files" << std::endl;
2887 for (std::vector<unsigned int>::const_iterator itr=
m_runlist.begin();
2888 itr!=
m_runlist.end();++itr) std::cout <<
2889 "Update allowed for run " << *itr << std::endl;
◆ getTimeFromRun()
bool AtlCoolCopy::getTimeFromRun |
( |
| ) |
|
|
private |
Definition at line 2594 of file AtlCoolCopy.cxx.
2607 std::string sorfolder=
"/TDAQ/RunCtrl/SOR_Params";
2608 std::string eorfolder=
"/TDAQ/RunCtrl/EOR_Params";
2609 if (
m_timedb.find (
"CONDBR2")!=std::string::npos) {
2610 sorfolder=
"/TDAQ/RunCtrl/SOR";
2611 eorfolder=
"/TDAQ/RunCtrl/EOR";
2613 std::cout <<
"Extracting times for run range [" << (
m_runemin >> 32) <<
2615 " folder " << sorfolder << std::endl;
2617 std::cout <<
"ERROR: Run range not correctly specified" << std::endl;
2621 cool::IDatabasePtr tdaqdb;
2624 std::cout <<
"Opened database connection" << std::endl;
2627 std::cout <<
"COOL exception caught: " <<
e.what() << std::endl;
2632 cool::IFolderPtr
folder=tdaqdb->getFolder(sorfolder);
2637 while (itr->goToNext()) {
2638 const cool::IRecord&
payload=itr->currentRef().payload();
2644 std::cout <<
"ERROR: Found " << nobj <<
" SOR records" << std::endl;
2649 std::cout <<
"Exception accessing SOR information: " <<
e.what() <<
2655 cool::IFolderPtr
folder=tdaqdb->getFolder(eorfolder);
2660 while (itr->goToNext()) {
2661 const cool::IRecord&
payload=itr->currentRef().payload();
2667 std::cout <<
"ERROR: Found " << nobj <<
" EOR records" << std::endl;
2672 std::cout <<
"Exception accessing SOR information: " <<
e.what() <<
2676 tdaqdb->closeDatabase();
2677 std::cout <<
"Timestamp range set to " <<
m_timemin <<
" " <<
◆ getUpdateMode()
int AtlCoolCopy::getUpdateMode |
( |
std::string_view |
desc, |
|
|
std::string_view |
tag |
|
) |
| |
|
staticprivate |
Definition at line 2893 of file AtlCoolCopy.cxx.
2897 std::string_view modestr=
"";
2899 std::string::size_type iofs1=
desc.find(
"<updateMode>");
2900 std::string::size_type iofs2=
desc.find(
"</updateMode>");
2901 if (iofs1!=std::string::npos && iofs2!=std::string::npos && iofs2>iofs1)
2902 modestr=
desc.substr(iofs1+12,iofs2-iofs1-12);
2903 if (modestr==
"UPD1" ||
tag.find(
"UPD1")!=std::string::npos)
mode=1;
2904 if (modestr==
"UPD2" ||
tag.find(
"UPD2")!=std::string::npos)
mode=2;
2905 if (modestr==
"UPD3" ||
tag.find(
"UPD3")!=std::string::npos)
mode=3;
2906 if (modestr==
"UPD4" ||
tag.find(
"UPD4")!=std::string::npos)
mode=4;
◆ isNumeric()
bool AtlCoolCopy::isNumeric |
( |
const char * |
input | ) |
|
|
staticprivate |
Definition at line 2488 of file AtlCoolCopy.cxx.
2491 const char* cptr=
input;
2492 while (*cptr!=
'\0') {
2493 if (!isdigit(*cptr)) { isnum=
false;
break;}
◆ isOpen()
bool AtlCoolCopy::isOpen |
( |
| ) |
const |
|
inline |
◆ listPoolRefs()
int AtlCoolCopy::listPoolRefs |
( |
| ) |
|
|
private |
Definition at line 3098 of file AtlCoolCopy.cxx.
3099 std::cout <<
"Total of " <<
m_poolrefs.size() <<
" POOL files referenced"
3101 for (PoolMap::const_iterator ipool=
m_poolrefs.begin();
3103 std::cout <<
"Ref " << ipool->first <<
" (" << ipool->second.count()
3104 <<
")" << std::endl;
◆ 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.
1327 std::cout <<
"Reading tag " << sourcetag <<
" of folder " <<
folder <<
1328 " (no copy)" << std::endl;
1331 cool::IObjectIteratorPtr sourceitr;
1332 if (vermode==cool::FolderVersioning::SINGLE_VERSION) {
1338 while (sourceitr->goToNext()) {
1339 const cool::IObject&
obj=sourceitr->currentRef();
1343 std::cout <<
"Folder scanned with " << nobj <<
" objects" << std::endl;
1346 catch (cool::Exception&
e) {
1347 std::cout <<
"Exception thrown from read loop: " <<
e.what() <<
◆ openConnections()
bool AtlCoolCopy::openConnections |
( |
const std::string & |
sourcedb, |
|
|
const std::string & |
destdb, |
|
|
bool |
allowcreate |
|
) |
| |
|
private |
Definition at line 340 of file AtlCoolCopy.cxx.
347 coral::IConnectionServiceConfiguration& csconfig=
m_coralsvc.configuration();
348 csconfig.setReplicaSortingAlgorithm(*
m_repsort);
352 std::cout <<
"Open source database: " << sourcedb << std::endl;
353 if (!
m_sourceread) std::cout <<
"... in UPDATE mode" << std::endl;
358 std::cout <<
"Cool exception caught: " <<
e.what() << std::endl;
366 std::cout <<
"Open destination ROOT file: " << destdb << std::endl;
367 p_rootfile=
new TFile(destdb.c_str(),
"RECREATE");
368 if (
p_rootfile==
nullptr) std::cout <<
"ERROR: Could not open ROOT file" <<
374 std::cout <<
"Open destination database: " << tdestdb << std::endl;
381 "Forcing recreation of destination database - deleting existing data!"
384 m_dbSvc->dropDatabase(tdestdb);
386 throw cool::DatabaseDoesNotExist(
"old database deleted");
390 std::cout <<
"COOL exception caught: " <<
e.what() << std::endl;
393 std::cout <<
"Try to create new conditions DB" << std::endl;
396 std::cout <<
"Creation succeeded" << std::endl;
398 catch (cool::Exception&
e) {
399 std::cout <<
"Creation failed" << std::endl;
◆ openCoraCool()
bool AtlCoolCopy::openCoraCool |
( |
| ) |
|
|
private |
Definition at line 410 of file AtlCoolCopy.cxx.
412 std::cout <<
"Attempt to open source CoraCool DB " <<
m_sourcedb <<
416 std::cout <<
"Opened CoraCool source DB" << std::endl;
421 std::cout <<
"Attempt to open destination CoraCool DB " <<
m_destdb <<
425 std::cout <<
"Opened CoraCool dest DB" << std::endl;
◆ procOptVector()
bool AtlCoolCopy::procOptVector |
( |
const int |
argc, |
|
|
const char * |
argv[], |
|
|
std::vector< std::string > & |
folders |
|
) |
| |
|
private |
Definition at line 2121 of file AtlCoolCopy.cxx.
2128 std::string_view par0=
argv[
ic];
2130 if (par0.compare(0,2,
"--")==0) par0=par0.substr(1);
2131 if ((par0==
"-f" || par0==
"-folder") &&
ir>1) {
2134 }
else if ((par0==
"-e" || par0==
"-exclude") &&
ir>1) {
2137 }
else if ((par0==
"-t" || par0==
"-tag") &&
ir>1) {
2140 }
else if ((par0==
"-mt" || par0==
"-magic") &&
ir>1) {
2143 }
else if ((par0==
"-of" || par0==
"-outfolder") &&
ir>1) {
2146 }
else if ((par0==
"-ot" || par0==
"-outtag") &&
ir>1) {
2149 }
else if ((par0==
"-bs" || par0==
"-buffersize") &&
ir>1) {
2152 }
else if ((par0==
"-sl" || par0==
"-seal") &&
ir>1) {
2155 }
else if ((par0==
"-rls" || par0==
"-runlumisince") &&
ir>2) {
2158 }
else if ((par0==
"-rlu" || par0==
"-runlumiuntil") &&
ir>2) {
2161 }
else if ((par0==
"-nrls" || par0==
"-newrunlumisince") &&
ir>2) {
2164 }
else if ((par0==
"-nrlu" || par0==
"-newrunlumiuntil") &&
ir>2) {
2167 }
else if ((par0==
"-srls" || par0==
"-skiprunlumisince") &&
ir>2) {
2171 }
else if ((par0==
"-srlu" || par0==
"-skiprunlumiuntil") &&
ir>2) {
2175 }
else if (par0==
"-ro" || par0==
"-root") {
2177 }
else if (par0==
"-zn" || par0==
"-zeronull") {
2179 }
else if (par0==
"-ana" || par0==
"-analyse") {
2182 m_anadelt=
static_cast<long long>(ttime);
2184 }
else if ((par0==
"-rs" || par0==
"-runsince") &&
ir>1) {
2187 }
else if ((par0==
"-ru" || par0==
"-rununtil") &&
ir>1) {
2190 }
else if ((par0==
"-r" || par0==
"-run") &&
ir>1) {
2194 }
else if ((par0==
"-ts" || par0==
"-timesince") &&
ir>1) {
2197 }
else if ((par0==
"-tu" || par0==
"-timeuntil") &&
ir>1) {
2200 }
else if ((par0==
"-nts" || par0==
"-newtimesince") &&
ir>1) {
2203 }
else if ((par0==
"-ntu" || par0==
"-newtimeuntil") &&
ir>1) {
2206 }
else if (par0==
"-c" || par0==
"-create") {
2208 }
else if ((par0==
"-ch" || par0==
"-channel") &&
ir>1) {
2211 }
else if ((par0==
"-ch1" || par0==
"-channel1") &&
ir>1) {
2214 }
else if ((par0==
"-ch2" || par0==
"-channel2") &&
ir>1) {
2217 }
else if (par0==
"-chd" || par0==
"-channeldesc") {
2220 }
else if (par0==
"-forcerecreate") {
2222 }
else if (par0==
"-d" || par0==
"-debug") {
2224 }
else if (par0==
"-a" || par0==
"-alliov") {
2226 }
else if (par0==
"-ih" || par0==
"-includehead") {
2228 }
else if (par0==
"-eh" || par0==
"-excludehead") {
2230 }
else if (par0==
"-ht" || par0==
"-headtag") {
2232 }
else if (par0==
"-uht" || par0==
"-userheadtag") {
2234 }
else if (par0==
"-v" || par0==
"-verify") {
2236 }
else if (par0==
"-nc" || par0==
"-nocopy") {
2238 }
else if (par0==
"-noc" || par0==
"-nocoracool") {
2240 }
else if (par0==
"-nch" || par0==
"-nochannel") {
2242 }
else if (par0==
"-ncr" || par0==
"-noclobroot") {
2244 }
else if (par0==
"-nd" || par0==
"-nodata") {
2246 }
else if (par0==
"-nh" || par0==
"-nohitag") {
2248 }
else if (par0==
"-hi" || par0==
"-hitag") {
2250 }
else if ((par0==
"-ec" || par0==
"-excludechannel") &&
ir>1) {
2253 }
else if (par0==
"-fs" || par0==
"-forcesingle") {
2255 }
else if (par0==
"-fm" || par0==
"-forcemulti") {
2257 }
else if (par0==
"-frl" || par0==
"-forcerunlumi") {
2259 }
else if (par0==
"-ftm" || par0==
"-forcetime") {
2261 }
else if (par0==
"-fp" || par0==
"-forcepayload") {
2263 }
else if (par0==
"-fnp" || par0==
"-forcenopayload") {
2265 }
else if (par0==
"-cr" || par0==
"-checkrefs") {
2267 }
else if (par0==
"-lp" || par0==
"-listpfn") {
2270 }
else if (par0==
"-cf" || par0==
"-checkfiles") {
2273 }
else if (par0==
"-pa" || par0==
"-poolall") {
2275 }
else if ((par0==
"-co" || par0==
"-checkoutput") &&
ir>1) {
2278 }
else if ((par0==
"-pc" || par0==
"-poolcat") &&
ir>1) {
2281 }
else if ((par0==
"-mc" || par0==
"-mergecat") &&
ir>1) {
2284 }
else if ((par0==
"-ds" || par0==
"-dataset") &&
ir>1) {
2287 }
else if (par0==
"-us" || par0==
"-updatesource") {
2289 }
else if (par0==
"-cd" || par0==
"-checkdest") {
2291 }
else if (par0==
"-tr" || par0==
"-truncate") {
2293 }
else if (par0==
"-al" || par0==
"-appendlocked") {
2295 }
else if (par0==
"-alsv" || par0==
"-appendlockedsv") {
2298 }
else if (par0==
"-rdo" || par0==
"-readoracle") {
2300 }
else if (par0==
"-skiprep" || par0==
"-sr") {
2302 }
else if (par0==
"-go" || par0==
"-getonline") {
2304 }
else if (par0==
"-onr" || par0==
"-onlinerun") {
2306 }
else if (par0==
"-gb" || par0==
"-getbulk") {
2308 }
else if (par0==
"-gt" || par0==
"-gettime") {
2310 }
else if ((par0==
"-tdb" || par0==
"-timedb") &&
ir>1) {
2313 }
else if (par0==
"-ignoremode" &&
ir>1) {
2314 std::cout <<
"Ignoremode password is " <<
argv[
ic+1] <<
":end" << std::endl;
2315 if (strcmp(
argv[
ic+1],
"BackDoor")==0) {
2318 std::cout <<
"ERROR: Incorrect password for -ignoremode" << std::endl;
2322 }
else if (par0==
"-is" || par0==
"-ignorespec") {
2324 }
else if (par0==
"-pt" || par0==
"-prunetags") {
2327 }
else if (par0==
"-lo" || par0==
"-lockedonly") {
2331 }
else if (par0==
"-cti" || par0==
"-copytaginfo") {
2333 }
else if (par0==
"-ctl" || par0==
"-copytaglock") {
2336 }
else if ((par0==
"-tl" || par0==
"-taglabel") &&
ir>1) {
2340 }
else if ((par0==
"-ag" || par0==
"-addguid") &&
ir>1) {
2343 }
else if ((par0==
"-alf" || par0==
"-addlfn") &&
ir>1) {
2346 }
else if ((par0==
"-pf" || par0==
"-parfile") &&
ir>1) {
2349 }
else if ((par0==
"-rf" || par0==
"-runfile") &&
ir>1) {
2352 }
else if ((par0==
"-ws" || par0==
"-runinfohost") &&
ir>1) {
2355 }
else if (par0==
"-h" || par0==
"-help") {
2359 std::cout <<
"Parameter error for argument: " << par0 << std::endl;
◆ rootAllocate()
bool AtlCoolCopy::rootAllocate |
( |
const cool::IFieldSpecification & |
spec, |
|
|
void *& |
sptr, |
|
|
char & |
rootID |
|
) |
| const |
|
private |
Definition at line 1716 of file AtlCoolCopy.cxx.
1718 const cool::StorageType& stype=
spec.storageType();
1721 if (stype==cool::StorageType::Bool) {
1723 sptr=
static_cast<void*
>(
new unsigned int(0));
1725 }
else if (stype==cool::StorageType::UChar) {
1726 sptr=
static_cast<void*
>(
new unsigned char(
' '));
1728 }
else if (stype==cool::StorageType::Int16) {
1729 sptr=
static_cast<void*
>(
new short(0));
1731 }
else if (stype==cool::StorageType::UInt16) {
1732 sptr=
static_cast<void*
>(
new unsigned short(0));
1734 }
else if (stype==cool::StorageType::Int32) {
1735 sptr=
static_cast<void*
>(
new int(0));
1737 }
else if (stype==cool::StorageType::UInt32) {
1738 sptr=
static_cast<void*
>(
new unsigned int(0));
1740 }
else if (stype==cool::StorageType::Int64) {
1741 sptr=
static_cast<void*
>(
new long long int(0));
1743 }
else if (stype==cool::StorageType::UInt63) {
1744 sptr=
static_cast<void*
>(
new unsigned long long int(0));
1746 }
else if (stype==cool::StorageType::Float) {
1747 sptr=
static_cast<void*
>(
new float(0.));
1749 }
else if (stype==cool::StorageType::Double) {
1750 sptr=
static_cast<void*
>(
new double(0.));
1752 }
else if (stype==cool::StorageType::String4k ||
1753 stype==cool::StorageType::String255) {
1754 sptr=
static_cast<void*
>(
new char[4100]);
1756 }
else if (stype==cool::StorageType::String64k && !
m_noclobroot) {
1757 sptr=
static_cast<void*
>(
new char[65536]);
1759 }
else if (stype==cool::StorageType::String16M && !
m_noclobroot) {
1760 sptr=
static_cast<void*
>(
new char[67108864]);
1763 std::cout <<
"rootAllocate: Unsupported storage type for attribute: " <<
1764 spec.name() << std::endl;
1766 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.
1688 if (
p_rootfile->FindObject(toproot.c_str())==
nullptr) {
1690 std::cout <<
"Made top directory " << toproot << std::endl;
1695 std::string::size_type iofs1=1;
1696 std::string::size_type iofs2=1;
1698 while (iofs2!=std::string::npos) {
1699 iofs2=
folder.find(
'/',iofs1);
1700 if (iofs2==std::string::npos) {
1707 std::cout <<
"Make directory " <<
dirname << std::endl;
◆ 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.
1556 std::cout <<
"Write tag " << sourcetag <<
" of folder " <<
folder <<
1557 " to ROOT file" << std::endl;
1560 bool timestamp2=timestamp;
1567 if (
tree==
nullptr) {
1568 std::cout <<
"Book TTree " <<
treename << std::endl;
1580 if (vermode==cool::FolderVersioning::MULTI_VERSION)
1583 const cool::IRecordSpecification&
spec=
1584 (sourcefl->folderSpecification()).payloadSpecification();
1585 unsigned int ncolumns=
spec.size();
1592 const cool::IFieldSpecification& fieldspec=
spec[
icol];
1596 tree->Branch(fieldspec.name().c_str(),ptr,
1597 (fieldspec.name()+
"/"+rootID).c_str());
1599 <<
" of type " <<
spec[
icol].storageType().name() << std::endl;
1601 std::cout <<
"Attribute " <<
spec[
icol].name() <<
" of type " <<
1602 spec[
icol].storageType().name() <<
" will be skipped" << std::endl;
1607 std::cout <<
"TTree " <<
treename <<
" already exists" << std::endl;
1610 (sourcefl->folderSpecification()).payloadSpecification().size();
1612 std::cout <<
"ERROR in tree buffer definition: expect " <<
treename <<
1621 cool::IObjectIteratorPtr sourceitr;
1623 if (vermode==cool::FolderVersioning::SINGLE_VERSION) {
1629 catch (cool::Exception&
e) {
1630 std::cout <<
"Exception thrown from ROOT copy iterator setup: " <<
1631 e.what() << std::endl;
1636 while (sourceitr->goToNext()) {
1637 const cool::IObject& sobj=sourceitr->currentRef();
1648 if (vermode==cool::FolderVersioning::MULTI_VERSION) {
1651 std::string sourcetag2=sourcetag.substr(0,255);
1657 const cool::IRecord& record=sobj.payload();
1664 catch (cool::Exception&
e) {
1671 std::cout <<
"Written " << nobj <<
" objects to ROOT TTree with " << nex
1672 <<
" nulls/exceptions" << std::endl;
1674 catch (cool::Exception&
e) {
1675 std::cout <<
"Exception thrown from ROOT file writing loop: " <<
1676 e.what() << std::endl;
◆ rootWrite()
void AtlCoolCopy::rootWrite |
( |
void * |
sptr, |
|
|
const cool::IField & |
field |
|
) |
| const |
|
private |
Definition at line 1769 of file AtlCoolCopy.cxx.
1772 const cool::StorageType& stype=
field.storageType();
1773 if (stype==cool::StorageType::Bool) {
1775 *(
static_cast<int*
>(sptr))=0;
1777 *(
static_cast<int*
>(sptr))=(
field.data<
bool>() ? 1 : 0);
1779 }
else if (stype==cool::StorageType::UChar) {
1781 *(
static_cast<unsigned char*
>(sptr))=0;
1783 *(
static_cast<unsigned char*
>(sptr))=
field.data<
unsigned char>();
1785 }
else if (stype==cool::StorageType::Int16) {
1787 *(
static_cast<short*
>(sptr))=0;
1789 *(
static_cast<short*
>(sptr))=
field.data<
short>();
1791 }
else if (stype==cool::StorageType::UInt16) {
1793 *(
static_cast<unsigned short*
>(sptr))=0;
1795 *(
static_cast<unsigned short*
>(sptr))=
field.data<
unsigned short>();
1797 }
else if (stype==cool::StorageType::Int32) {
1799 *(
static_cast<int*
>(sptr))=0;
1801 *(
static_cast<int*
>(sptr))=
field.data<
int>();
1803 }
else if (stype==cool::StorageType::UInt32) {
1805 *(
static_cast<unsigned int*
>(sptr))=0;
1807 *(
static_cast<unsigned int*
>(sptr))=
field.data<
unsigned int>();
1809 }
else if (stype==cool::StorageType::Int64) {
1811 *(
static_cast<long long*
>(sptr))=0;
1813 *(
static_cast<long long*
>(sptr))=
field.data<
long long>();
1815 }
else if (stype==cool::StorageType::UInt63) {
1817 *(
static_cast<unsigned long long*
>(sptr))=0;
1819 *(
static_cast<unsigned long long*
>(sptr))=
field.data<
unsigned long long>();
1821 }
else if (stype==cool::StorageType::Float) {
1823 *(
static_cast<float*
>(sptr))=0.;
1825 *(
static_cast<float*
>(sptr))=
field.data<
float>();
1827 }
else if (stype==cool::StorageType::Double) {
1829 *(
static_cast<double*
>(sptr))=0.;
1831 *(
static_cast<double*
>(sptr))=
field.data<
double>();
1833 }
else if (stype==cool::StorageType::String255 ||
1834 stype==cool::StorageType::String4k ||
1835 stype==cool::StorageType::String64k ||
1836 stype==cool::StorageType::String16M) {
1838 strcpy(
static_cast<char*
>(sptr),
"NULL");
1840 strcpy(
static_cast<char*
>(sptr),
field.data<std::string>().c_str());
1843 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 2575 of file AtlCoolCopy.cxx.
2578 cool::ValidityKey
val;
2580 val=((1LL << 31)-1) << 32;
2582 val=
static_cast<long long>(atol(
input1)) << 32;
2584 if (input2[0]==
'M' || input2[0]==
'm') {
2589 if (
val>cool::ValidityKeyMax)
val=cool::ValidityKeyMax;
◆ setChannelRange()
void AtlCoolCopy::setChannelRange |
( |
const cool::IFolderPtr & |
sourcefl | ) |
|
|
private |
Definition at line 821 of file AtlCoolCopy.cxx.
829 for (
size_t i=0;
i<nChanRange;
i++) {
834 " to channel selection" << std::endl;
845 std::cout <<
"Adding channel range " <<
c1 <<
" to " <<
c2 <<
846 " to channel selection" << std::endl;
◆ setOpts()
int AtlCoolCopy::setOpts |
( |
int |
argc, |
|
|
const char * |
argv[] |
|
) |
| |
Definition at line 2368 of file AtlCoolCopy.cxx.
2370 std::vector<std::string>
folders;
2375 for (std::vector<std::string>::const_iterator
ifile=
m_parfile.begin();
2377 std::cout <<
"Reading parameters from file " << *
ifile << std::endl;
2378 FILE* p_inp=fopen(
ifile->c_str(),
"r");
2379 if (p_inp==
nullptr) {
2380 std::cout <<
"File not found" << std::endl;
2383 char* p_buf=
new char[999];
2384 while (!feof(p_inp)) {
2385 char* p_line=fgets(p_buf,999,p_inp);
2386 if (p_line!=
nullptr) {
2388 const char* fargv[99];
2390 char* p_start=
nullptr;
2391 while (*p_line!=
'\0') {
2392 if (*p_line==
' ' || *p_line==
'\n') {
2394 if (p_start!=
nullptr) {
2397 fargv[fargc]=p_start;
2403 if (p_start==
nullptr) p_start=p_line;
2415 std::cout <<
"Close file" << std::endl;
2422 std::cout <<
"Problem opening connections" << std::endl;
2436 for (std::vector<std::string>::const_iterator ifold=
folders.begin();
2456 std::cout <<
"Source run/LB range [" << (
m_runemin >> 32) <<
"," <<
2460 std::cout <<
"Source timestamp range " <<
m_timemin <<
" " <<
2464 std::cout <<
"Change o/p run/LB range [" << (
m_newrunemin >> 32) <<
"," <<
2468 std::cout <<
"Change o/p timestamp range " <<
m_newtimemin <<
" " <<
2472 std::cout <<
"Skip IOVs extending outside run/LB range [" <<
2478 for (std::vector<cool::ChannelId>::const_iterator itr=
2480 std::cout <<
"Channel " << *itr <<
" will be excluded" << std::endl;
2482 if (
m_hitag) std::cout <<
"All hierachical tags connecting to referenced tags will be copied" << std::endl;
2483 if (
m_nohitag) std::cout <<
"Hierarchical tag relations will not be copied"
◆ setupCatalog()
Definition at line 3309 of file AtlCoolCopy.cxx.
3314 for (std::vector<std::string>::const_iterator icat=catvec.begin();
3315 icat!=catvec.end();++icat) {
3316 std::cout <<
"Add catalogue: " << *icat << std::endl;
3318 if (icat->find(
':')==std::string::npos) {
3329 std::cout <<
"Could not setup POOL catalogues, exception:" <<
e.what()
◆ tagParents()
int AtlCoolCopy::tagParents |
( |
| ) |
|
|
private |
Definition at line 3025 of file AtlCoolCopy.cxx.
3026 std::cout <<
"Copying additional hierarchical tags of parent folders"
3034 cool::IFolderSetPtr sourcefl=
m_sourceDbPtr->getFolderSet(folderset);
3035 cool::IFolderSetPtr destfl=
m_destDbPtr->getFolderSet(folderset);
3036 std::cout <<
"Processing folderset " << folderset << std::endl;
3037 for (HiTagMap::const_iterator imap=
m_hitagmap.begin();
3041 std::string sourcetag=sourcefl->findTagRelation(imap->first);
3042 std::cout <<
"Create hierarchical tag between " << sourcetag <<
3043 " and " << imap->first <<
" in folder " << imap->second <<
3047 std::string etag=destfl->resolveTag(imap->first);
3048 if (etag==sourcetag) {
3049 std::cout <<
"This relation has already been created" << std::endl;
3051 std::cout <<
"ERROR: Tag in parent already related to " <<
3056 catch (cool::Exception&
e ) {
3059 destfl->createTagRelation(imap->first,sourcetag);
3065 m_cooltagmap.insert(CoolTagMap::value_type(imap->first,
3067 imap->first,imap->first)));
3069 catch (cool::Exception&
e) {
3070 std::cout <<
"Cool exception " <<
e.what() <<
3071 "thrown in hierarchical tag creation" << std::endl;
3077 catch (cool::Exception&
e) { }
3080 std::cout <<
"ERROR Folderset " << folderset <<
" not found" <<
◆ timeString()
std::string AtlCoolCopy::timeString |
( |
const cool::ValidityKey |
iovtime | ) |
|
|
staticprivate |
Definition at line 2562 of file AtlCoolCopy.cxx.
2563 if (iovtime==cool::ValidityKeyMin) {
2564 return "ValidityKeyMin ";
2565 }
else if (iovtime==cool::ValidityKeyMax) {
2566 return "ValidityKeyMax ";
2568 time_t
time=
static_cast<time_t
>(iovtime/1E9);
2571 return "UTC "+std::string(asctime_r(gmtime_r(&
time, &
result), buf));
◆ timeVal()
cool::ValidityKey AtlCoolCopy::timeVal |
( |
const char * |
input | ) |
|
|
staticprivate |
Definition at line 2531 of file AtlCoolCopy.cxx.
2537 return static_cast<long long>(atol(
input))*
2538 static_cast<long long>(1.E9);
2540 struct tm mytm{},mytm2{};
2548 cool::ValidityKey itime=
static_cast<cool::ValidityKey
>(mktime(&mytm));
2549 strptime(
"1970-01-02:00:00:00",
"%Y-%m-%d:%T",&mytm2);
2550 cool::ValidityKey caltime=
static_cast<cool::ValidityKey
>(mktime(&mytm2));
2551 itime+=24*60*60-caltime;
2552 return itime*
static_cast<cool::ValidityKey
>(1.E9);
2555 "ERROR in format of time value, use e.g. 2007-05-25:14:01:00" <<
◆ transConn()
std::string AtlCoolCopy::transConn |
( |
const std::string & |
inconn | ) |
|
|
staticprivate |
Definition at line 450 of file AtlCoolCopy.cxx.
453 if (inconn.find(
'/')==std::string::npos) {
454 return "sqlite://X;schema=mycool.db;dbname="+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.
1364 std::cout <<
"Verifying tag " << sourcetag <<
" of folder " <<
folder <<
1366 destfl->setPrefetchAll(
false);
1369 cool::IObjectIteratorPtr sourceitr,destitr;
1371 std::string
tag=sourcetag;
1372 if (vermode==cool::FolderVersioning::SINGLE_VERSION || sourcetag==
"HEAD")
1376 sourceflc->setPrefetchAll(
false);
1385 std::cout <<
"Exception thrown from verify iterator setup: " <<
e.what() <<
1394 const std::string& cfkey=sourceflc->coralFKey();
1395 const std::string& cpkey=sourceflc->coralPKey();
1396 while (csourceitr->hasNext()) {
1405 if (cdestitr->hasNext()) {
1410 if (sobj->since()!=dobj->since() || sobj->until()!=dobj->until())
1413 if (sobj->channelId()!=dobj->channelId())
1416 if (sobj->size()!=dobj->size()) {
1417 std::cout <<
"ERROR CoraCool object " << nobj <<
1418 " sizes do not match: " << sobj->size() <<
" " << dobj->size()
1425 sitr!=sobj->end();++sitr,++ditr) {
1427 for (coral::AttributeList::const_iterator aitr=sitr->begin();
1428 aitr!=sitr->end();++aitr) {
1429 const std::string&
aname=aitr->specification().name();
1432 if (*aitr!=(*ditr)[
aname]) {
1433 std::cout <<
"ERROR Values of attriute " <<
aname <<
1434 " differ" << std::endl;
1438 catch (coral::AttributeListException&
e) {
1439 std::cout <<
"ERROR: CoraCool attribute " <<
aname <<
1440 " not found in destination!" << std::endl;
1447 std::cout <<
"ERROR database entries do not match: since: " <<
1448 sobj->since() <<
"," << dobj->since() <<
" until: " <<
1449 sobj->until() <<
"," << dobj->until() <<
" channel: " <<
1450 sobj->channelId() <<
"," << dobj->channelId() << std::endl;
1455 "ERROR destination folder no matching CoraCool iterator for object "
1456 << nobj << std::endl;
1462 while (sourceitr->goToNext()) {
1463 const cool::IObject& sobj=sourceitr->currentRef();
1472 if (destitr->goToNext()) {
1473 const cool::IObject& dobj=destitr->currentRef();
1477 if (sobj.since()!=dobj.since() || sobj.until()!=dobj.until())
1480 if (sobj.channelId()!=dobj.channelId())
1485 if (paymode==cool::PayloadMode::VECTORPAYLOAD) {
1486 cool::IRecordIterator& spitr=sobj.payloadIterator();
1487 const cool::IRecordVectorPtr svptr=spitr.fetchAllAsVector();
1488 cool::IRecordIterator& dpitr=dobj.payloadIterator();
1489 const cool::IRecordVectorPtr dvptr=dpitr.fetchAllAsVector();
1490 if (svptr->size()!=dvptr->size()) {
1495 cool::IRecordVector::const_iterator svitr=svptr->begin();
1496 cool::IRecordVector::const_iterator svend=svptr->end();
1497 cool::IRecordVector::const_iterator dvitr=dvptr->begin();
1498 for (;svitr!=svend;++svitr,++dvitr) {
1503 std::cout <<
"ERROR vector payloads do not match (size " << svptr->size() <<
"," << dvptr->size() <<
")" << std::endl;
1508 if (!
equalRecord(sobj.payload(),dobj.payload())) iret=102;
1512 std::cout <<
"ERROR database entries do not match: since: " <<
1513 sobj.since() <<
"," << dobj.since() <<
" until: " <<
1514 sobj.until() <<
"," << dobj.until() <<
" channel: " <<
1515 sobj.channelId() <<
"," << dobj.channelId() << std::endl;
1516 std::cout <<
"Source payload:" << std::endl;
1517 sobj.payload().attributeList().toOutputStream(std::cout);
1518 std::cout << std::endl <<
"Destination payload:" << std::endl;
1519 dobj.payload().attributeList().toOutputStream(std::cout);
1520 std::cout << std::endl;
1525 "ERROR destination folder no matching iterator for object "
1526 << nobj << std::endl;
1533 catch (cool::Exception&
e) {
1534 std::cout <<
"Exception thrown from verify loop: " <<
e.what() <<
1544 std::cout <<
"Verification of folder " <<
folder <<
" tag " <<
1545 sourcetag <<
" OK (" << nobj <<
" objects)" << std::endl;
◆ writeTagInfo()
int AtlCoolCopy::writeTagInfo |
( |
| ) |
|
|
private |
Definition at line 3087 of file AtlCoolCopy.cxx.
3088 std::cout <<
"Write tag description ";
3090 std::cout <<
"for " <<
m_cooltagmap.size() <<
" tags" << std::endl;
3091 for (CoolTagMap::const_iterator itr=
m_cooltagmap.begin();
◆ m_addguid
std::vector<std::string> AtlCoolCopy::m_addguid |
|
private |
◆ m_addlfn
std::vector<std::string> AtlCoolCopy::m_addlfn |
|
private |
◆ m_alliov
bool AtlCoolCopy::m_alliov |
|
private |
◆ m_allowcreate
bool AtlCoolCopy::m_allowcreate |
|
private |
◆ m_anadelt
long long AtlCoolCopy::m_anadelt |
|
private |
◆ m_analyse
bool AtlCoolCopy::m_analyse |
|
private |
◆ m_applock
bool AtlCoolCopy::m_applock |
|
private |
◆ m_applocksv
bool AtlCoolCopy::m_applocksv |
|
private |
◆ m_bufsize
int AtlCoolCopy::m_bufsize |
|
private |
◆ m_channel1
std::string AtlCoolCopy::m_channel1 |
|
private |
◆ m_channel2
std::string AtlCoolCopy::m_channel2 |
|
private |
◆ m_channelRange
std::vector<std::string> AtlCoolCopy::m_channelRange |
|
private |
◆ m_chansel
cool::ChannelSelection AtlCoolCopy::m_chansel |
|
private |
◆ m_chdesc
bool AtlCoolCopy::m_chdesc |
|
private |
◆ m_checkdesttag
bool AtlCoolCopy::m_checkdesttag |
|
private |
◆ m_checkoutputfile
std::string AtlCoolCopy::m_checkoutputfile |
|
private |
◆ m_checkrefs
bool AtlCoolCopy::m_checkrefs |
|
private |
◆ m_coolapp
cool::Application AtlCoolCopy::m_coolapp |
|
private |
◆ m_cooltagmap
◆ m_copytaginfo
bool AtlCoolCopy::m_copytaginfo |
|
private |
◆ m_copytaglock
bool AtlCoolCopy::m_copytaglock |
|
private |
◆ m_coracool
bool AtlCoolCopy::m_coracool |
|
private |
◆ m_coralsvc
coral::ConnectionService AtlCoolCopy::m_coralsvc |
|
private |
◆ m_dbSvc
cool::IDatabaseSvc* AtlCoolCopy::m_dbSvc |
|
private |
◆ m_debug
bool AtlCoolCopy::m_debug |
|
private |
◆ m_destCoraPtr
◆ m_destdb
std::string AtlCoolCopy::m_destdb |
|
private |
◆ m_destDbPtr
cool::IDatabasePtr AtlCoolCopy::m_destDbPtr |
|
private |
◆ m_excludechans
std::vector<cool::ChannelId> AtlCoolCopy::m_excludechans |
|
private |
◆ m_excludehead
bool AtlCoolCopy::m_excludehead |
|
private |
◆ m_folderexcl
std::vector<std::string> AtlCoolCopy::m_folderexcl |
|
private |
◆ m_folderlist
std::vector<std::string> AtlCoolCopy::m_folderlist |
|
private |
◆ m_forcemulti
bool AtlCoolCopy::m_forcemulti |
|
private |
◆ m_forcenopay
bool AtlCoolCopy::m_forcenopay |
|
private |
◆ m_forcepay
bool AtlCoolCopy::m_forcepay |
|
private |
◆ m_forcerune
bool AtlCoolCopy::m_forcerune |
|
private |
◆ m_forcesingle
bool AtlCoolCopy::m_forcesingle |
|
private |
◆ m_forcetime
bool AtlCoolCopy::m_forcetime |
|
private |
◆ m_getbulk
bool AtlCoolCopy::m_getbulk |
|
private |
◆ m_getonline
bool AtlCoolCopy::m_getonline |
|
private |
◆ m_gettime
bool AtlCoolCopy::m_gettime |
|
private |
◆ m_hiparent
std::vector<std::string> AtlCoolCopy::m_hiparent |
|
private |
◆ m_hitag
bool AtlCoolCopy::m_hitag |
|
private |
◆ m_hitagmap
◆ m_ignoremode
bool AtlCoolCopy::m_ignoremode |
|
private |
◆ m_ignorespec
bool AtlCoolCopy::m_ignorespec |
|
private |
◆ m_includehead
bool AtlCoolCopy::m_includehead |
|
private |
◆ m_listpfn
bool AtlCoolCopy::m_listpfn |
|
private |
◆ m_lockedonly
bool AtlCoolCopy::m_lockedonly |
|
private |
◆ m_magic
std::vector<std::string> AtlCoolCopy::m_magic |
|
private |
◆ m_mergecat
std::vector<std::string> AtlCoolCopy::m_mergecat |
|
private |
◆ m_newdataset
std::string AtlCoolCopy::m_newdataset |
|
private |
◆ m_newrunemax
cool::ValidityKey AtlCoolCopy::m_newrunemax |
|
private |
◆ m_newrunemin
cool::ValidityKey AtlCoolCopy::m_newrunemin |
|
private |
◆ m_newtimemax
cool::ValidityKey AtlCoolCopy::m_newtimemax |
|
private |
◆ m_newtimemin
cool::ValidityKey AtlCoolCopy::m_newtimemin |
|
private |
◆ m_nochannel
bool AtlCoolCopy::m_nochannel |
|
private |
◆ m_noclobroot
bool AtlCoolCopy::m_noclobroot |
|
private |
◆ m_nocopy
bool AtlCoolCopy::m_nocopy |
|
private |
◆ m_nodata
bool AtlCoolCopy::m_nodata |
|
private |
◆ m_nohitag
bool AtlCoolCopy::m_nohitag |
|
private |
◆ m_nt_bufferptr
std::vector<void*> AtlCoolCopy::m_nt_bufferptr |
|
private |
◆ m_nt_channel
UInt_t AtlCoolCopy::m_nt_channel = 0 |
|
private |
◆ m_nt_lbsince
UInt_t AtlCoolCopy::m_nt_lbsince = 0 |
|
private |
◆ m_nt_lbuntil
UInt_t AtlCoolCopy::m_nt_lbuntil = 0 |
|
private |
◆ m_nt_runsince
UInt_t AtlCoolCopy::m_nt_runsince = 0 |
|
private |
◆ m_nt_rununtil
UInt_t AtlCoolCopy::m_nt_rununtil = 0 |
|
private |
◆ m_nt_since
ULong64_t AtlCoolCopy::m_nt_since = 0 |
|
private |
◆ m_nt_tagid
char AtlCoolCopy::m_nt_tagid[256] = {0} |
|
private |
◆ m_nt_treename
std::string AtlCoolCopy::m_nt_treename |
|
private |
◆ m_nt_until
ULong64_t AtlCoolCopy::m_nt_until = 0 |
|
private |
◆ m_onlinerun
bool AtlCoolCopy::m_onlinerun |
|
private |
◆ m_open
◆ m_outfolder
std::string AtlCoolCopy::m_outfolder |
|
private |
◆ m_outtag
std::string AtlCoolCopy::m_outtag |
|
private |
◆ m_parfile
std::vector<std::string> AtlCoolCopy::m_parfile |
|
private |
◆ m_poolall
bool AtlCoolCopy::m_poolall |
|
private |
◆ m_poolcat
std::vector<std::string> AtlCoolCopy::m_poolcat |
|
private |
◆ m_poollast
PoolMap::iterator AtlCoolCopy::m_poollast |
|
private |
◆ m_poolopen
bool AtlCoolCopy::m_poolopen |
|
private |
◆ m_poolrefs
◆ m_prunetags
bool AtlCoolCopy::m_prunetags |
|
private |
◆ m_readoracle
bool AtlCoolCopy::m_readoracle |
|
private |
◆ m_recreate
bool AtlCoolCopy::m_recreate |
|
private |
◆ m_repsort
◆ m_root
◆ m_runemax
cool::ValidityKey AtlCoolCopy::m_runemax |
|
private |
◆ m_runemin
cool::ValidityKey AtlCoolCopy::m_runemin |
|
private |
◆ m_runfile
std::vector<std::string> AtlCoolCopy::m_runfile |
|
private |
◆ m_runinfohost
std::string AtlCoolCopy::m_runinfohost |
|
private |
◆ m_runlist
std::vector<unsigned int> AtlCoolCopy::m_runlist |
|
private |
◆ m_sealmsg
int AtlCoolCopy::m_sealmsg |
|
private |
◆ m_skipout
bool AtlCoolCopy::m_skipout |
|
private |
◆ m_skiprep
bool AtlCoolCopy::m_skiprep |
|
private |
◆ m_sourceCoraPtr
◆ m_sourcedb
std::string AtlCoolCopy::m_sourcedb |
|
private |
◆ m_sourceDbPtr
cool::IDatabasePtr AtlCoolCopy::m_sourceDbPtr |
|
private |
◆ m_sourceread
bool AtlCoolCopy::m_sourceread |
|
private |
◆ m_srunemax
cool::ValidityKey AtlCoolCopy::m_srunemax |
|
private |
◆ m_srunemin
cool::ValidityKey AtlCoolCopy::m_srunemin |
|
private |
◆ m_taglabel
std::string AtlCoolCopy::m_taglabel |
|
private |
◆ m_tags
std::vector<std::string> AtlCoolCopy::m_tags |
|
private |
◆ m_timedb
std::string AtlCoolCopy::m_timedb |
|
private |
◆ m_timemax
cool::ValidityKey AtlCoolCopy::m_timemax |
|
private |
◆ m_timemin
cool::ValidityKey AtlCoolCopy::m_timemin |
|
private |
◆ m_truncate
bool AtlCoolCopy::m_truncate |
|
private |
◆ m_usertags
bool AtlCoolCopy::m_usertags |
|
private |
◆ m_userupdatehead
bool AtlCoolCopy::m_userupdatehead |
|
private |
◆ m_verify
bool AtlCoolCopy::m_verify |
|
private |
◆ m_zeronull
bool AtlCoolCopy::m_zeronull |
|
private |
◆ p_rootfile
TFile* AtlCoolCopy::p_rootfile |
|
private |
The documentation for this class was generated from the following file:
JetConstituentVector::iterator iterator
static cool::ValidityKey runLBVal(const char *input1, const char *input2)
static cool::ChannelId channelID(const cool::IFolderPtr &folder, const std::string &chanstring)
void rootWrite(void *sptr, const cool::IField &field) const
std::vector< std::string > m_magic
double GetBinContent(int) const
def rtime(fn, *args, **kw)
cool::ValidityKey m_srunemax
std::string find(const std::string &s)
return a remapped string
coral::ConnectionService m_coralsvc
ReplicaSorter * m_repsort
std::string m_checkoutputfile
std::string dirname(std::string name)
std::string rootDirs(const std::string &folder, const std::string &toproot)
cool::ValidityKey m_timemax
cool::ChannelSelection m_chansel
bool openConnections(const std::string &sourcedb, const std::string &destdb, bool allowcreate)
std::vector< std::string > m_parfile
cool::IDatabaseSvc * m_dbSvc
std::set< std::string > exclude
list of directories to be excluded
cool::ValidityKey m_newrunemin
cool::ValidityKey m_srunemin
def gap(flags, cells_name, *args, **kw)
static bool equalRecord(const cool::IRecord &lhs, const cool::IRecord &rhs)
cool::ValidityKey m_newtimemax
static cool::ValidityKey timeVal(const char *input)
void checkRef(const cool::IRecord &payload, const std::string &folder, const std::string &tag)
cool::ValidityKey m_newrunemax
AttrListVec::const_iterator const_iterator
std::vector< std::string > m_channelRange
std::vector< std::string > m_poolcat
void start()
redirect to init() for Gaudi FC
std::pair< std::vector< unsigned int >, bool > res
std::vector< cool::ChannelId > m_excludechans
void setWriteCatalog(const std::string &connect)
Access to the (first) writable file catalog.
cool::Application m_coolapp
bool procOptVector(const int argc, const char *argv[], std::vector< std::string > &folders)
cool::IDatabasePtr m_sourceDbPtr
cool::ValidityKey m_runemax
std::vector< std::string > m_folderlist
std::vector< unsigned int > m_runlist
double atof(std::string_view str)
Converts a string into a double / float.
boost::shared_ptr< CoraCoolDatabase > CoraCoolDatabasePtr
CoraCoolDatabasePtr m_sourceCoraPtr
cool::ValidityKey m_timemin
cool::IDatabasePtr m_destDbPtr
std::vector< void * > m_nt_bufferptr
cool::ValidityKey m_runemin
PoolMap::iterator m_poollast
std::vector< std::string > m_tags
std::vector< std::string > m_mergecat
int ir
counter of the current depth
std::string m_runinfohost
static TH1F * bookOrFindTH1F(const std::string &hID, const std::string &htitle, const int chan, const float xlow, const float xhigh)
std::vector< std::string > m_runfile
Status
Athena specific StatusCode values.
boost::shared_ptr< CoraCoolObjectIter > CoraCoolObjectIterPtr
def time(flags, cells_name, *args, **kw)
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
bool addFolder(const std::string &folder, const bool onlyTags)
static std::string transConn(const std::string &inconn)
boost::shared_ptr< CoraCoolObject > CoraCoolObjectPtr
std::string m_nt_treename
bool rootAllocate(const cool::IFieldSpecification &spec, void *&sptr, char &rootID) const
CoraCoolDatabasePtr m_destCoraPtr
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
size_t WriteCallback(void *contents, size_t size, size_t nmemb, std::string *s)
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
std::vector< std::string > m_addlfn
bool addExclude(const std::string &folder)
std::vector< std::string > m_hiparent
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
static std::string timeString(const cool::ValidityKey iovtime)
void addReadCatalog(const std::string &connect)
Add new catalog identified by name to the existing ones.
std::vector< std::string > m_folderexcl
static bool isNumeric(const char *input)
std::vector< std::string > m_addguid
cool::ValidityKey m_newtimemin