Darwin::Tools Namespace Reference

Classes
class	Looper
class	MetaInfo
class	Options
class	UserInfo

Typedefs
typedef std::pair< unsigned, unsigned >	Slice

Enumerations
enum	{   none = 0b000000, config = 0b000001, split = 0b000010, fill = 0b000100,   Friend = 0b001100, syst = 0b010000, verbose = 0b100000 }
enum	{   none = 0b000000, config = 0b000001, split = 0b000010, fill = 0b000100,   Friend = 0b001100, syst = 0b010000, verbose = 0b100000 }

Functions
optional< bool >	getBool (string s)
template<typename ... Args>
void	FromPT2MetaInfo (const pt::ptree &elements, const MetaInfo &metainfo, ostream &cout, Args... args)
void	forceMetaInfo (const fs::path &input, const fs::path &output, const int steering)
int	getMetaInfo (vector< fs::path > inputs, const fs::path &output)
int	initMetaInfo (const pt::ptree &config)
template<int thousand = 1024>
const char *	GetHumanReadableSize (long double size)
Long64_t	GetSize (TBranch *br)
Long64_t	loopBranches (TObjArray *branches, size_t factor, int nIndent=0)
void	printBranches (vector< fs::path > inputs)
void	printDarwinSoftwareVersion ()
void	printEntries (vector< fs::path > inputs)
void	PrintCloseFriend (TList *friends, const int steering, string offset="")
void	printFriends (vector< fs::path > inputs, const int steering)
void	printHist (vector< fs::path > inputs, const pt::ptree &config)
int	printMetaInfo (vector< fs::path > inputs, const pt::ptree &config)
std::unique_ptr< TFile >	GetOutput (std::filesystem::path output, const char *name)
void	StandardInit ()
std::vector< std::filesystem::path >	GetROOTfiles (std::vector< std::filesystem::path > inputs)
std::unique_ptr< TChain >	GetChain (std::vector< std::filesystem::path > inputs, const char *name="events")
template<typename THX = TH1>
std::unique_ptr< THX >	GetHist (std::vector< std::filesystem::path > inputs, const char *name="h")
std::string	GetFirstTreeLocation (const std::filesystem::path &input)
std::unique_ptr< TTree >	NewTree (const std::unique_ptr< TChain > &chain, const bool makeFriend, const char *thisFunc)
std::ostream &	operator<< (std::ostream &Stream, const Darwin::Tools::Slice &slice)
static std::ostream	dev_null (nullptr)
std::vector< const char * >	tokenize (const char *str)
static std::ostream	dev_null (nullptr)

Detailed Description

Classes and functions related to the framework.

Typedef Documentation

Slice

typedef std::pair< unsigned, unsigned > Slice

current slice (>=0) / total number of slices (>0)

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
none	default (for simple executables)
config	activate -c option to provide config file
split	activate -k and -j to define slice
fill	activate -f to fill the tree
Friend	activate -F to only fill the new branches
syst	activate -s to systematic uncertainties
verbose	bit for debug mode (-v is always available)

     {
    none    = 0b000000, 
    config  = 0b000001, 
    split   = 0b000010, 
    fill    = 0b000100, 
    Friend  = 0b001100, 
    syst    = 0b010000, 
    verbose = 0b100000  
}; 

anonymous enum

anonymous enum

Enumerator
none	default (for simple executables)
config	activate -c option to provide config file
split	activate -k and -j to define slice
fill	activate -f to fill the tree
Friend	activate -F to only fill the new branches
syst	activate -s to systematic uncertainties
verbose	bit for debug mode (-v is always available)

     {
    none    = 0b000000, 
    config  = 0b000001, 
    split   = 0b000010, 
    fill    = 0b000100, 
    Friend  = 0b001100, 
    syst    = 0b010000, 
    verbose = 0b100000  
}; 

Function Documentation

dev_null() [1/2]

static std::ostream Darwin::Tools::dev_null ( nullptr  )

static

to redirect output stream to nowhere

dev_null() [2/2]

static std::ostream Darwin::Tools::dev_null ( nullptr  )

static

to redirect output stream to nowhere

forceMetaInfo()

void Darwin::Tools::forceMetaInfo	(	const fs::path &	input,
		const fs::path &	output,
		const int	steering
	)

Force content of all TTree::UserInfo() and TList found in the topmost directory of the root file. This method is to be used as a last resort, and certainly not in the context of reproducible results.

Parameters

input	input config file (INFO, JSON, XML)
output	ROOT file
steering	parameters obtained from explicit options

{
    pt::ptree config;
    if (input.extension() == ".json")
        pt::read_json(input, config);
    else if (input.extension() == ".xml")
        pt::read_xml(input, config);
    else
        pt::read_info(input, config);
 
    const string location = GetFirstTreeLocation(output);
    unique_ptr<TFile> fOut(TFile::Open(output.c_str(), "UPDATE"));
    auto t = unique_ptr<TTree>(fOut->Get<TTree>(location.c_str()));
    if (!t)
        BOOST_THROW_EXCEPTION(DE::BadInput("The tree can't be found in this file.", fOut));
 
    t->GetUserInfo()->Clear();
 
    static auto& cout = (steering & verbose) == verbose ? ::cout : dev_null;
    MetaInfo metainfo(t, false);
    FromPT2MetaInfo(config, metainfo, cout);
    metainfo.Set<bool>("git", "reproducible", false);
    if (metainfo.Find("history")) {
        TList * history = metainfo.List("history");
        metainfo.List()->Remove(history);
    }
    t->Write();
}

FromPT2MetaInfo()

void Darwin::Tools::FromPT2MetaInfo	(	const pt::ptree &	elements,
		const MetaInfo &	metainfo,
		ostream &	cout,
		Args...	args
	)

Sets whatever is in the input config file into the metainfo of a TTree.

Parameters

elements	from config file
metainfo	target metainfo (will be modified)
cout	overrides standard output
args	key chain

{
    if constexpr (sizeof...(Args) < 10) // max depth
    for (const auto& element: elements) {
        const char * key = element.first.c_str();
        const auto& value = element.second.get_value<string>();
 
        cout << bold;
        if constexpr (sizeof...(Args) > 0)
            (cout << ... << args) << ' ';
        cout << def << key << " \"" << value << '"' << endl;
 
        FromPT2MetaInfo(element.second, metainfo, cout, args..., key);
 
        auto match = [&value](const string& reg) {
            return regex_match( value, regex(reg) );
        };
        if (auto isBool = getBool(value); isBool)
            metainfo.Set<bool>(args..., key, *isBool);
        else if (match("-?[0-9]+")) // integer
            metainfo.Set<int>(args..., key, stoi(value));
        else if (match("-?[0-9]+([\\.][0-9]+)?")) // floating number
            metainfo.Set<float>(args..., key, stof(value));
        else if (element.second.size() == 0) { // string
            if (value.empty()) {
                if constexpr (sizeof...(Args) > 0)
                    metainfo.Set<string>(args..., string(key));
            }
            else
                metainfo.Set<string>(args..., key, value);
        }
    }
}

getBool()

optional<bool> Darwin::Tools::getBool

(

string

s

)

Translates a string into a boolean if possible.

{
    al::to_lower(s);
    al::trim(s);
    static const array<string,4> trueStr {"true", "on", "ktrue", "yes"},
                                 falseStr {"false", "off", "kfalse", "no"};
    if (auto it = find(trueStr.begin(), trueStr.end(), s);
            it != trueStr.end())
        return make_optional<bool>(true);
    if (auto it = find(falseStr.begin(), falseStr.end(), s);
            it != falseStr.end())
        return make_optional<bool>(false);
    return {};
}

GetChain()

std::unique_ptr< TChain > GetChain	(	std::vector< std::filesystem::path >	inputs,
		const char *	name = "events"
	)

Load chain from a list of files.

internal path to TTree

Parameters

inputs	ROOT files or directories
name	internal path to `TTree`

{
    using namespace std;
    namespace fs = filesystem;
 
    unique_ptr<TChain> chain = make_unique<TChain>(name);
    inputs = GetROOTfiles(inputs);
    for (auto const& input: inputs) {
        int code = chain->Add(input.c_str(), 0); // "If nentries<=0 and wildcarding is not used,
                                                 // returns 1 if the file exists and contains
                                                 // the correct tree and 0 otherwise"
        if (code == 1) continue; // i.e. the tree was found successfully
        auto fIn = make_unique<TFile>(input.c_str(), "READ");
        namespace DE = Darwin::Exceptions;
        BOOST_THROW_EXCEPTION(DE::BadInput("The tree cannot be "
                        "found in (one of) the input file(s).", fIn));
    }
    if (chain->GetEntries() == 0)
        BOOST_THROW_EXCEPTION(std::invalid_argument("Empty trees in input!"));
    return chain;
}

GetFirstTreeLocation()

std::string GetFirstTreeLocation

(

const std::filesystem::path &

input

)

one input ROOT file

Look for a tree in the input file (stop at the first found one).

NOTE: in principle, we take the risk of not looking at the same TTree as all other executables, but this is unlikely in practice

Parameters

input

one input ROOT file

{
    using namespace std;
    namespace fs = filesystem;
    namespace DE = Darwin::Exceptions;
 
    unique_ptr<TFile> fIn(TFile::Open(input.c_str(), "READ"));
    if (!fIn || !fIn->IsOpen() || fIn->IsZombie() || !fs::exists(input))
        BOOST_THROW_EXCEPTION( fs::filesystem_error("Failed to open input file",
                                input, make_error_code(std::errc::io_error)) );
 
    function<string(TDirectory *)> loop;
    loop = [&loop](TDirectory * d) -> string {
 
        // look for a `TTree` in the current `TDirectory`
        for (const auto&& obj: *(d->GetListOfKeys())) {
            auto const key = dynamic_cast<TKey*>(obj);
            if (dynamic_cast<TTree *>(key->ReadObj()) == nullptr) continue;
            return obj->GetName();
        }
 
        // if not found, check all sub`TDirectory`s
        for (const auto&& obj: *(d->GetListOfKeys())) {
            auto const key = dynamic_cast<TKey*>(obj);
            auto dd = dynamic_cast<TDirectory *>(key->ReadObj());
            if (dd == nullptr) continue;
            if (auto location = loop(dd); !location.empty())
                return Form("%s/%s", dd->GetName(), location.c_str());
        }
 
        // if nothing was found at this stage, return empty string
        return string();
    };
    string location = loop(fIn.get());
    if (location.empty())
        BOOST_THROW_EXCEPTION( DE::BadInput("No `TTree` could be found in the input file.", fIn) );
    return location;
}

GetHist()

std::unique_ptr< THX > GetHist ( std::vector< std::filesystem::path >  inputs, const char *  name = "h"  )

inline

Load a histogram from a list of files.

Parameters

inputs	ROOT files or directories
name	internal path to ROOT histogram

{
    using namespace std;
    namespace fs = filesystem;
 
    unique_ptr<THX> sum;
    inputs = GetROOTfiles(inputs);
    for (auto const& input: inputs) {
        auto fIn = make_unique<TFile>(input.c_str(), "READ");
        // TODO: what if the file had already been opened?? will it be closed prematurely?
        unique_ptr<THX> h(fIn->Get<THX>(name));
        if (!h) {
            namespace DE = Darwin::Exceptions;
            BOOST_THROW_EXCEPTION(DE::BadInput(Form("`%s` cannot be found in (one of) the "
                                                    " file(s).", name), fIn));
        }
        if (sum)
            sum->Add(h.get());
        else {
            sum = move(h);
            sum->SetDirectory(nullptr);
        }
    }
    return sum;
}

GetHumanReadableSize()

const char* Darwin::Tools::GetHumanReadableSize

(

long double

size

)

From an absolute number of bytes to human readable size in KB, MB, GB, etc.

< https://en.wikipedia.org/wiki/Byte

Parameters

size	size in bytes

{
    static const array levels = {'\0', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'};
    auto level = levels.begin();
    while (level != prev(levels.end()) 
            && size > static_cast<long double>(thousand)) {
        ++level;
        size /= thousand;
    }
    return Form("%.0Lf%c", size, *level);
}

getMetaInfo()

int Darwin::Tools::getMetaInfo	(	vector< fs::path >	inputs,
		const fs::path &	output
	)

Print content of the first TTree::UserInfo() found in the root file.

Parameters

inputs	input ROOT files
output	output config file (INFO, JSON, XML)

{
    const size_t N = inputs.size();
    hash<UserInfo> Hash;
    vector<size_t> hashes(N,0);
 
    inputs = GetROOTfiles(inputs);
    const string location = GetFirstTreeLocation(inputs.front());
 
    // looping over files
    for (size_t i = 0; i < N; ++i) {
 
        // opening file
        unique_ptr<TFile> fIn(TFile::Open(inputs[i].c_str(), "READ"));
        if (fIn->IsZombie())
            BOOST_THROW_EXCEPTION(DE::BadInput("Can't open the file.", fIn));
 
        // fetch tree
        auto t = unique_ptr<TTree>(dynamic_cast<TTree*>(fIn->Get<TTree>(location.c_str())));
        if (!t)
            BOOST_THROW_EXCEPTION(DE::BadInput("The tree can't be found in this file.", fIn));
 
        // open metainfo
        MetaInfo mi(t, false);
        hashes[i] = Hash(mi);
 
        // print (only the first time---the next rounds, we only check the hash)
        bool found = false;
        if (found) continue;
        mi.Write(output);
        found = true;
    }
 
    // check the hash
    bool identical = true;
    stringstream ss;
    for (size_t i = 0; i < N; ++i) {
        ss << inputs[i] << '\t' << hex << hashes[i] << '\n';
        if (i == 0) continue;
        identical &= hashes[i-1] == hashes[i];
    }
 
    if (identical) return EXIT_SUCCESS;
    cerr << red << ss.str() << def;
    return EXIT_FAILURE;
}

GetOutput()

std::unique_ptr< TFile > GetOutput	(	std::filesystem::path	output,
		const char *	name
	)

Shortcut to create a reproducible output file (see ROOT Doxygen for details)

{
    const auto fname = output;
    output += "?reproducible="; output += name;
    std::unique_ptr<TFile> f(TFile::Open(output.c_str(), "RECREATE"));
    if (!f || !f->IsOpen() || f->IsZombie() || !fs::exists(fname))
        BOOST_THROW_EXCEPTION( fs::filesystem_error("Failed to open output file",
                                output, make_error_code(std::errc::io_error)) );
    return f;
}

GetROOTfiles()

std::vector< std::filesystem::path > GetROOTfiles

(

std::vector< std::filesystem::path >

inputs

)

ROOT files or directories.

In case directories are given as inputs, instead of files, this function looks for all ROOT files in those directories (and subdirectories, iteratively).

Parameters

inputs

ROOT files or directories

{
    using namespace std;
    namespace fs = filesystem;
 
    if (inputs.size() == 0)
        BOOST_THROW_EXCEPTION(fs::filesystem_error("No input was found!",
                                make_error_code(errc::no_such_file_or_directory)));
 
    vector<fs::path> root_inputs;
    root_inputs.reserve(inputs.size());
 
    for (auto input: inputs) {
        input = fs::absolute(input);
        if (fs::is_directory(input)) {
            for (const auto &entry : fs::recursive_directory_iterator(
                    input, fs::directory_options::follow_directory_symlink)) {
                if (fs::is_regular_file(entry) && entry.path().extension() == ".root") {
                    root_inputs.push_back(entry);
                }
            }
        }
        else if (input.extension() == ".root")
            root_inputs.push_back(input);
    }
 
    sort(root_inputs.begin(), root_inputs.end(),
            [](const fs::path& a, const fs::path& b) {
                return strnatcmp(a.c_str(), b.c_str()) < 0;
            });
    return root_inputs;
}

GetSize()

Long64_t Darwin::Tools::GetSize

(

TBranch *

br

)

Adapted from ROOT example

{
    TMemFile f("buffer", "CREATE");
    auto fcurrent = br->GetTree()->GetCurrentFile();
    if (fcurrent) {
        auto settings = fcurrent->GetCompressionSettings();
        f.SetCompressionSettings(settings);
    }
    f.WriteObject(br, "thisbranch");
    TKey * key = f.GetKey("thisbranch");
    Long64_t size = key->GetNbytes();
 
    Long64_t basket = br->GetZipBytes();
    if (basket == 0) basket = br->GetTotBytes();
 
    return basket + size;
}

initMetaInfo()

int Darwin::Tools::initMetaInfo

(

const pt::ptree &

config

)

Writes a minimal MetaInfo to standard output.

Parameters

config

config, with `flags` and `corrections` at least

{
    auto formatStr = config.get<string>("format");
    MetaInfo::Format format;
    if (formatStr == "info")
        format = MetaInfo::INFO;
    else if (formatStr == "json")
        format = MetaInfo::JSON;
    else if (formatStr == "xml")
        format = MetaInfo::XML;
    else
        BOOST_THROW_EXCEPTION( std::invalid_argument(
            "Unknown MetaInfo format \"" + formatStr + "\"") );
 
    MetaInfo(MetaInfo::IKnowWhatIAmDoing{}).Write(cout, format);
 
    return EXIT_SUCCESS;
}

loopBranches()

Long64_t Darwin::Tools::loopBranches	(	TObjArray *	branches,
		size_t	factor,
		int	nIndent = 0
	)

Adapted from ROOT example

Parameters

branches	list of (sub)branches
factor	correction factor for #files in `TChain`

{
    size_t n = branches->GetEntries();
    Long64_t total = 0;
    for (size_t i = 0; i < n; ++i) {
        auto br = dynamic_cast<TBranch*>(branches->At(i));
        Long64_t size = GetSize(br);
 
        string branchname(nIndent, ' ');
        branchname += br->GetName();
        cout << left << setw(40) << branchname
             << right << setw(10) << GetHumanReadableSize(size * factor) << endl;
 
        TObjArray * subbranches = br->GetListOfBranches();
        size += loopBranches(subbranches, factor, nIndent + 1);
        total += size;
    }
    return total;
}

NewTree()

std::unique_ptr< TTree > NewTree	(	const std::unique_ptr< TChain > &	chain,
		const bool	makeFriend,
		const char *	thisFunc
	)

name of present exec

Either clone the input TChain or define the input TChain as a friend of the new TTree.

The title of the TTree is used to store (retrieve) the name of the present (previous) command. Different names are indeed necessary to distinguish the same branch in a TTree and its friend(s).

TODO: TTree::BuildIndex() to preserve the association despite skipped events?

Parameters

chain	input
makeFriend	steering containing the option
thisFunc	name of present exec

{
    using namespace std;
    namespace DT = Darwin::Tools;
    namespace DE = Darwin::Exceptions;
    unique_ptr<TTree> tOut;
    if (makeFriend) {
        tOut = make_unique<TTree>("events", thisFunc);
        chain->GetEntry(0); // necessary to load a(ny) TTree
 
        // find the name of the previous command
        TString lastFunc = chain->GetTree()->GetTitle(); // this is supposed to store the name of the last command
        if (lastFunc == "" || lastFunc == chain->GetTree()->GetName()) {
            cerr << orange << "Unable to identify the command used to obtain the input from the title.\n" << def;
            lastFunc = "previous";
        }
 
        // add friend
        tOut->AddFriend(chain.get(), lastFunc);
 
        // copy metainfo
        TList * userinfo = chain->GetTree()->GetUserInfo();
        tOut->GetUserInfo()->AddAll(userinfo);
        userinfo->Clear(); // necessary to prevent the TTree destructor from deleting
                           // all elements in the list (avoid double deletion)
    }
    else {
        tOut = unique_ptr<TTree>(chain->CloneTree(0));
        tOut->SetTitle(thisFunc);
    }
    return tOut;
}

operator<<()

std::ostream & operator<<	(	std::ostream &	Stream,
		const Darwin::Tools::Slice &	slice
	)

Prints the current slice and the total number of slices.

{
    Stream << slice.second << '/' << slice.first;
    return Stream;
}

printBranches()

void Darwin::Tools::printBranches

(

vector< fs::path >

inputs

)

Adapted from ROOT example

Parameters

inputs

input ROOT files

{
    inputs = GetROOTfiles(inputs);
    size_t factor = inputs.size();
    string location = GetFirstTreeLocation(inputs.front());
    unique_ptr<TChain> tIn = GetChain(inputs, location.c_str());
    TObjArray * branches = tIn->GetListOfBranches();
    size_t size = loopBranches(branches, factor);
    cout << right << setw(50) << GetHumanReadableSize(size * factor) << endl;
}

PrintCloseFriend()

void Darwin::Tools::PrintCloseFriend	(	TList *	friends,
		const int	steering,
		string	offset = ""
	)

Retrieve and prints the name and the friends.

Parameters

friends	obtained from `TTree::GetListOfFriends()`
steering	bitflied from `Options::steering()`
offset	spaces to show the distance from the original tree

{
    // if the tree had no friend, the list does not exist
    if (friends == nullptr) return;
 
    if (steering & verbose) friends->Print();
 
    // a priori we only expect one friend, but nothing speaks against more
    for (TObject * obj: *friends) {
        auto buddy = dynamic_cast<TFriendElement*>(obj);
        cout << offset << buddy->GetName()
                << ' ' << buddy->GetFile()->GetName()
                << ':' << buddy->GetTreeName() << endl;
 
        TList * comrades = buddy->GetTree()->GetListOfFriends();
        offset += " ";
        PrintCloseFriend(comrades, steering, offset);
    }
}

printDarwinSoftwareVersion()

void Darwin::Tools::printDarwinSoftwareVersion

(

)

Print the versions of the various pieces of software. Each software appears on a new line. Tought for exception handling in Python code and for Doxygen.

{
    // TODO: use accumulate
    for (auto const& v: MetaInfo::versions)
        cout << v.first << ' ' << v.second << '\n';
    cout << flush;
}

printEntries()

void Darwin::Tools::printEntries

(

vector< fs::path >

inputs

)

Get total number of entries in input ROOT file(s) or directory, and prints it directly to the terminal.

Parameters

inputs

input ROOT files

{
    try {
        inputs = GetROOTfiles(inputs);
        string location = GetFirstTreeLocation(inputs.front());
        unique_ptr<TChain> tIn = GetChain(inputs, location.c_str());
        cout << tIn->GetEntries() << endl;
    }
    catch (boost::wrapexcept<std::invalid_argument>& e) {
        cout << 0 << endl;
    }
}

printFriends()

void Darwin::Tools::printFriends	(	vector< fs::path >	inputs,
		const int	steering
	)

Prints the recursive list of friends to the input n-tuple.

Parameters

inputs	input ROOT files
steering	bitfield from `Options::steering()`

{
    inputs = GetROOTfiles(inputs);
    string location = GetFirstTreeLocation(inputs.front());
    unique_ptr<TChain> chain = GetChain(inputs, location.c_str());
    chain->GetEntry(0);
    TList * friends = chain->GetTree()->GetListOfFriends();
    PrintCloseFriend(friends, steering);
}

printHist()

void Darwin::Tools::printHist	(	vector< fs::path >	inputs,
		const pt::ptree &	config
	)

Print the content of a 1D histogram in columns.

Convention: index lowEdge upEdge content error

Parameters

inputs	input ROOT files
config	config handled with `Darwin::Tools::options`

{
    auto histname = config.get<string>("hist").c_str();
    auto h = GetHist<TH1>({inputs}, histname);
    if (h->GetDimension() > 1)
        BOOST_THROW_EXCEPTION( DE::BadInput("The desired histogram is not 1D",
                                            TFile(inputs.front().c_str()) ));
    int N = h->GetNbinsX();
    for (int i = 0; i <= N+1; ++i) {
        double low = h->GetBinLowEdge(i),
               up  = h->GetBinLowEdge(i+1),
               content = h->GetBinContent(i),
               error = h->GetBinError(i);
        if (error == 0 && content == 0) continue;
 
        // index
        cout << setw(10);
        if (i == 0) cout << "underflow";
        else if (i == N+1) cout << "overflow";
        else cout << i;
 
        // low edge
        cout << setw(15);
        if (i == 0) cout << "-inf";
        else cout << low;
        cout << setw(10);
 
        // upper edge
        if (i > N) cout << "+inf";
        else cout << up;
 
        // bin content and error
        cout << setw(15) << content
             << setw(15) << error
             << '\n';
    }
    cout << flush;
}

printMetaInfo()

int Darwin::Tools::printMetaInfo	(	vector< fs::path >	inputs,
		const pt::ptree &	config
	)

Print the value(s) corresponding to a given key in the first given input ROOT file.

If no value / subtree is found, the command fails and exits. If multiple entries are found, they are all printed. Only the first subtree is displayed.

The INFO format allows a key to have a value and a child. Since the JSON format does not allow that, we assume here that this case does not happen.

Parameters

inputs	input ROOT files
config	config, with `flags` and `corrections` at least

{
    inputs = GetROOTfiles(inputs);
    const string location = GetFirstTreeLocation(inputs.front());
 
    // opening first file
    unique_ptr<TFile> fIn(TFile::Open(inputs.front().c_str(), "READ"));
    if (fIn->IsZombie())
        BOOST_THROW_EXCEPTION(DE::BadInput("Can't open the file.", fIn));
 
    // fetch tree
    auto t = unique_ptr<TTree>(dynamic_cast<TTree*>(fIn->Get<TTree>(location.c_str())));
    if (!t)
        BOOST_THROW_EXCEPTION(DE::BadInput("The tree can't be found in this file.", fIn));
 
    // open metainfo
    MetaInfo metainfo(t, false);
    auto ptree = metainfo.MkPtree();
    auto key = config.get<string>("path");
 
    auto value = ptree.get<string>(key);
    if (!value.empty()) {
        cout << value << endl;
        return EXIT_SUCCESS;
    }
 
    auto child = ptree.get_child_optional(key);
    if (child) {
        for (auto& el: *child) {
            string key = el.first,
                   val = el.second.get_value<string>();
            if (!key.empty()) cout << key << ' ';
            if (!val.empty()) cout << val;
            cout << '\n';
        }
        cout << flush;
        return EXIT_SUCCESS;
    }
 
    return EXIT_FAILURE;
}

StandardInit()

void StandardInit

(

)

Standard initialisation for ROOT.

"Now you own all histogram objects and you will need to delete them, for in- stance through the use of std::unique_ptr. You can still set the directory of a histogram by calling SetDirectory() once it has been created."

{
    gROOT->SetBatch();
    TH1::SetDefaultSumw2();
    TH1::AddDirectory(kFALSE);
}

tokenize()

std::vector<const char *> Darwin::Tools::tokenize ( const char *  str )

inline

Tokenize a C-style string into a vector of C-style string with space as delimiter. It is especially useful in tests where the command is hard-coded.

    {
        std::cout << "\e[1m" << str << "\e[0m" << std::endl;
 
        // convert from `const char *` to `char *`
        char * cmd = new char[strlen(str)+1];
        strcpy(cmd, str);
 
        // tokenize
        std::vector<const char *> args;
        for (char * arg = strtok(cmd, " ");
                    arg != nullptr;
                    arg = strtok(NULL, " "))
            args.push_back(std::move(arg));
 
        //free(cmd); // do NOT free the memory
        return args;
    }