MakeReferenceFile.cxx File Reference

#include "CoolKernel/DatabaseId.h"
#include "CoolKernel/Exception.h"
#include "CoolKernel/IDatabaseSvc.h"
#include "CoolKernel/IDatabase.h"
#include "CoolApplication/Application.h"
#include "CoolKernel/IFolder.h"
#include "CoolKernel/FolderSpecification.h"
#include "CoolKernel/RecordSpecification.h"
#include "CoolKernel/Record.h"
#include "CoolKernel/FieldSpecification.h"
#include "CoolKernel/IObject.h"
#include "CoolKernel/IObjectIterator.h"
#include "CoolKernel/IRecordIterator.h"
#include "CoolKernel/StorageType.h"
#include "CoolKernel/ChannelSelection.h"
#include "RelationalAccess/ConnectionService.h"
#include <iostream>
#include <fstream>
#include <string>
#include <string_view>
#include <stdexcept>
#include <ctime>
#include <sstream>
#include <unordered_map>

Go to the source code of this file.

Classes
class	DbConnection
struct	FolderSpec
class	Folder

Typedefs
using	iovNamePair = std::pair< std::string, std::string >

Functions
std::string	timeRep (const cool::ValidityKey &t, bool isEnd=false, bool runLumi=true)
std::string	iovToString (const cool::IObject &obj, bool runLumi=true)
std::string	payloadToString (const cool::IObject &obj)
int	main (int argc, char *argv[])

Typedef Documentation

iovNamePair

using iovNamePair = std::pair<std::string, std::string >

Definition at line 39 of file MakeReferenceFile.cxx.

Function Documentation

iovToString()

std::string iovToString	(	const cool::IObject &	obj,
		bool	runLumi = true
	)

Definition at line 248 of file MakeReferenceFile.cxx.

{
    std::string sinceStr = timeRep(obj.since(), false, runLumi);
    std::string untilStr = timeRep(obj.until(), true, runLumi);
    return sinceStr + " - " + untilStr;
}

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 274 of file MakeReferenceFile.cxx.

{
 
    std::string tagName{"PixelChargeCalibration-DATA-RUN2-UPD4-27"};
    std::string folderName{"/PIXEL/ChargeCalibration"};
    std::string outputFileName{"test"};
    std::string dbName{"COOLOFL_PIXEL/CONDBR2"};
    std::string useIOV{"latest"};
    bool useLastIOV{true};
 
    for(int i=1; i<argc; i++){
        std::string aux(argv[i]);
        std::string variable(aux.substr(0,aux.find("=")));
        std::string value(aux.substr(aux.find("=")+1));
        if     (variable.compare("tagName")    == 0) {
            tagName = value;
        }
        else if(variable.compare("folder")     == 0) folderName = std::move(value);
        else if(variable.compare("outputFile") == 0) outputFileName = std::move(value);       
        else if(variable.compare("dbName")     == 0) dbName = std::move(value);
        else if(variable.compare("IOV")        == 0){
            // By selecting an IOV is understood you dont want to use the last one 
            // hence use the "IOV=runNumber_LB" (it should exist in the DB)
            // if you want to print all of them use "IOV=all"
            useIOV = std::move(value);
            useLastIOV = false;
        } 
        else{
            std::cout<< "ERROR - Option not found:"<< aux <<"\n";
            return 1;
        } 
        
    }
 
    if (outputFileName.compare("test") == 0){
        if(useLastIOV){
            outputFileName = tagName+".log";
        }
        else if (useIOV.compare("all") == 0){
            outputFileName = "XXXXXX_"+tagName+".log";
        }
        else{
            outputFileName = useIOV+"_"+tagName+".log";
        }
    }
 
    printf("%-11s: %s\n", "Tag Name"   ,tagName.c_str());
    printf("%-11s: %s\n", "Folder Name",folderName.c_str())  ;
    printf("%-11s: %s\n", "DB Name"    ,dbName.c_str()) ; 
    printf("%-11s: %s\n", "Output File",outputFileName.c_str()) ; 
    printf("%-11s: %s\n", "Last IOV"   ,useLastIOV ? "True" : "False");  
    printf("%-11s: %s\n", "IOV used"   ,useIOV.c_str()) ; 
    
    int returnCode = 0;
    DbConnection connection(dbName);
    FolderSpec fs(folderName, tagName);
    Folder f(connection, fs);
    
    cool::IObjectIteratorPtr objectsIterator = f.objectIterator(useLastIOV); // True to use the last IOV
    std::vector< iovNamePair > myIOVs;
    while (objectsIterator->goToNext())
    {
        const cool::IObject &thisObject = objectsIterator->currentRef();
        std::size_t posPar = iovToString(thisObject).find("]");
        std::size_t posCom = iovToString(thisObject).find(",");
        std::string name = iovToString(thisObject).substr(1,posPar-1).replace(posCom-1,1,"_");
        std::string display = iovToString(thisObject) + " (" + std::to_string(thisObject.channelId()) + ")\n";
        display += payloadToString(thisObject);
        myIOVs.push_back(std::make_pair(name,display));
    }
 
    if(!useLastIOV){
        bool found = false;
        // Saving all the IOVs in different files, just used for experts - Evolution monitoring
        for(const auto & [IOVname,iov]:myIOVs){
            if(IOVname.compare(useIOV)!=0 && useIOV.compare("all") != 0){
                continue;
            }
            found = true;
            std::cout<<IOVname<<"\n";
            const std::string filename= IOVname +"_"+tagName+".log";
            std::ofstream opFile(filename);
            opFile <<iov<<"\n";
            opFile.close();
        }
        if(!found){
            std::cout<< "IOV not found - Choose between one of the following:\n";
            for(const auto & [IOVname,iov]:myIOVs){
                std::cout<<IOVname<<"  ";
            }
            std::cout << "\n";
        }
 
    }
    else{    
        const std::string fileName = tagName + ".log";
        std::ofstream opFile(fileName);
        printf("%-11s: %s\n", "RunNumber"   ,(myIOVs.back().first).c_str()) ; 
        opFile << myIOVs.back().second << "\n";
        opFile.close();
    }
 
    return returnCode;
}

payloadToString()

std::string payloadToString

(

const cool::IObject &

obj

)

Definition at line 256 of file MakeReferenceFile.cxx.

{
    std::string result;
    const cool::IRecord &record = obj.payload();
    const auto &thisSpec = record.specification();
    for (cool::UInt32 i = 0; i != thisSpec.size(); ++i)
    {
        const std::string delimiter = (i == 0) ? ("") : (",");
        std::string typeName = thisSpec[i].storageType().name();
        result += "[\'" + thisSpec[i].name() + " (" + typeName + ")\' : ";
        std::ostringstream os;
        record[i].printValue(os);
        result += os.str();
    }
    result += "]";
    return result;
}

timeRep()

std::string timeRep	(	const cool::ValidityKey &	t,
		bool	isEnd = false,
		bool	runLumi = true
	)

Definition at line 217 of file MakeReferenceFile.cxx.

{
    std::string result;
    const std::string trail = isEnd ? (")") : ("]");
    if (not runLumi)
    { // ns of epoch
        if (t == cool::ValidityKeyMin)
        {
            result = "ValidityKeyMin";
        }
        else if (t == cool::ValidityKeyMax)
        {
            result = "ValidityKeyMax";
        }
        else
        {
            long int seconds = static_cast<long int>(t / 1000000000);
            std::string timeStr{std::asctime(std::gmtime(&seconds))};
            result = timeStr + " UTC";
        }
    }
    else
    { // runLumi
        auto run = t >> 32;
        auto lumiblock = t & 0xFFFFFFFF;
        result = "[" + std::to_string(run) + "," + std::to_string(lumiblock) + trail;
    }
    return result;
}