Darwin::Tools Namespace Reference

Classes
class	ChainSlice
class	Flow
class	Looper
class	MetaInfo
class	Options
class	SlicedFriendElement
class	UserInfo

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

Enumerations
enum	BranchMode { mandatory, facultative, mandatory, facultative }
enum	Mode {   none = 0b000000, config = 0b000001, split = 0b000010, fill = 0b000100,   Friend = 0b001000, syst = 0b010000, verbose = 0b100000, none = 0b000000,   config = 0b000001, split = 0b000010, fill = 0b000100, Friend = 0b001000,   syst = 0b010000, verbose = 0b100000 }
enum	BranchMode { mandatory, facultative, mandatory, facultative }
enum	Mode {   none = 0b000000, config = 0b000001, split = 0b000010, fill = 0b000100,   Friend = 0b001000, syst = 0b010000, verbose = 0b100000, none = 0b000000,   config = 0b000001, split = 0b000010, fill = 0b000100, Friend = 0b001000,   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, const int steering)
void	printDarwinSoftwareVersion ()
void	printEntries (vector< fs::path > inputs, const int steering)
void	CollectFriends (const TTree *tree, set< string > &printed, const int steering, string indent="")
void	CollectChainFriends (const TChain *chain, set< string > &printed, const int steering, string indent="")
void	printFriends (vector< fs::path > inputs, const int steering)
void	printHist (vector< fs::path > inputs, const pt::ptree &config, const int steering)
int	printMetaInfo (vector< fs::path > inputs, const pt::ptree &config)
void	StandardInit ()
std::vector< std::filesystem::path >	GetROOTfiles (std::vector< std::filesystem::path > inputs)
template<typename THX = TH1>
std::unique_ptr< THX >	GetHist (std::vector< std::filesystem::path > inputs, const std::string &name="h")
std::string	GetFirstTreeLocation (const std::filesystem::path &input)
std::shared_ptr< TFile >	GetOutputFile (const std::filesystem::path &, const std::source_location=std::source_location::current())
std::ostream &	operator<< (std::ostream &Stream, const Darwin::Tools::Slice &slice)
static std::ostream	dev_null (nullptr)
std::unique_ptr< TFile >	GetOutput (std::filesystem::path output, const std::string &name)
std::vector< const char * >	tokenize (const char *str)
static std::ostream	dev_null (nullptr)

Detailed Description

Classes and functions related to the framework.

Utilities enabling better support for friend chains in a TTree.

SPDX-License-Idendifier: GPL-3.0-or-later SPDX-FileCopyrightText: Louis Moureaux louis.nosp@m..mou.nosp@m.reaux.nosp@m.@cer.nosp@m.n.ch

Typedef Documentation

Slice

typedef std::pair< unsigned, unsigned > Slice

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

Enumeration Type Documentation

BranchMode [1/2]

enum BranchMode

Enumerator
mandatory	mounting branch is mandatory
facultative	mounting branch is facultative
mandatory	mounting branch is mandatory
facultative	mounting branch is facultative

                {
    mandatory  , 
    facultative  
}; 

BranchMode [2/2]

enum BranchMode

Enumerator
mandatory	mounting branch is mandatory
facultative	mounting branch is facultative
mandatory	mounting branch is mandatory
facultative	mounting branch is facultative

                {
    mandatory  , 
    facultative  
}; 

Mode [1/2]

enum Mode

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	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  = 0b001000, 
    syst    = 0b010000, 
    verbose = 0b100000  
}; 

Mode [2/2]

enum Mode

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	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  = 0b001000, 
    syst    = 0b010000, 
    verbose = 0b100000  
}; 

Function Documentation

CollectChainFriends()

void Darwin::Tools::CollectChainFriends	(	const TChain *	chain,
		set< string > &	printed,
		const int	steering,
		string	indent = ""
	)

Retrieve and prints the elements in the chain and their friends recursively.

Parameters

chain	chain to collect friends from
printed	files already printed
steering	bitfield from `Options::steering()`
indent	spaces to show the distance from the original tree

{
    for (const auto &obj : *chain->GetListOfFiles()) {
        auto element = dynamic_cast<TChainElement*>(obj);
 
        // TChain::Add format: filename.root?#tree
        auto full_name = element->GetTitle() + string("?#") + element->GetName();
 
        // [chain] filename.root?#tree
        cout << indent << "[chain] " << full_name;
 
        // try to open the file and fetch the tree to check for more friends
        // print extra info if the tree isn't available
        TTree *tree = nullptr;
        unique_ptr<TFile> file(TFile::Open(element->GetTitle()));
        if (file && !file->IsZombie()) {
            tree = file->Get<TTree>(element->GetName());
            if (!tree)
                BOOST_THROW_EXCEPTION(Exceptions::BadInput(
                    Form("Tree %s not found", element->GetName()), file));
        } else
            BOOST_THROW_EXCEPTION(Exceptions::BadInput("File not found", file));
        cout << endl;
 
        // recurse only if we haven't seen this file yet
        if (printed.count(full_name) == 0) {
            printed.insert(full_name);
            CollectFriends(tree, printed, steering, indent + " ");
        } else
            cout << indent << " [see above]" << endl;
    }
}

CollectFriends()

void CollectFriends	(	const TTree *	tree,
		set< string > &	printed,
		const int	steering,
		string	indent
	)

Retrieve and prints the name and the friends.

When called on a long chain of friends, the output can include a very large number of files. To avoid printing too many lines, each file is printed only once. The printed argument keeps track of files already printed.

Parameters

tree	tree (or chain) to collect friends from
printed	files already printed
steering	bitflied from `Options::steering()`
indent	spaces to show the distance from the original tree

{
    // If `tree` is actually a chain, we go through the files in the chain.
    // There are two reasons to this:
    // - A chain depends on each file in the chain, and we want to display this
    //   information
    // - Each tree in the chain can have its own set of friends independently
    //   from the chain's friends. We also want to print those.
    if (const auto chain = dynamic_cast<const TChain*>(tree); chain)
        CollectChainFriends(chain, printed, steering, indent);
 
    auto friends = tree->GetListOfFriends();
 
    // 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 << indent << "[friend] ";
        if (auto sliced = dynamic_cast<SlicedFriendElement*>(obj); sliced)
            // [friend] alias[50:100]
            cout << buddy->GetName()
                 << "[" << sliced->GetBegin() << ":" << sliced->GetEnd() << "]";
        else
            // [friend] filename.root alias
            cout << buddy->GetTitle() << " " << buddy->GetName();
 
        cout << endl;
 
        // recurse
        CollectFriends(buddy->GetTree(), printed, steering, indent + " ");
    }
}

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 {};
}

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

{
    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 std::string &  name = "h"  )

inline

Load a histogram from a list of files.

Todo:

what if the file had already been opened?? will it be closed prematurely?

Todo:

what if the file had already been opened?? will it be closed prematurely?

Todo:

what if the file had already been opened?? will it be closed prematurely?

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");
        unique_ptr<THX> h(fIn->Get<THX>(name.c_str()));
        if (!h) {
            namespace DE = Darwin::Exceptions;
            BOOST_THROW_EXCEPTION(DE::BadInput(Form("`%s` cannot be found in (one of) the "
                                                    " file(s).", name.c_str()), fIn));
        }
        if (sum)
            sum->Add(h.get());
        else {
            sum = std::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)

{
    inputs = GetROOTfiles(inputs);
 
    const size_t N = inputs.size();
    hash<UserInfo> Hash;
    vector<size_t> hashes(N,0);
 
    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> Darwin::Tools::GetOutput	(	std::filesystem::path	output,
		const std::string &	name
	)

{
    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;
}

GetOutputFile()

std::shared_ptr< TFile > GetOutputFile	(	const std::filesystem::path &	,
		const std::source_location	= std::source_location::current()
	)

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

upstream function

Parameters

output

file location

{
    string title = fs::path(location.file_name()).stem();
    auto output_rep = output.string() + "?reproducible="s + title;
    auto fOut = make_shared<TFile>(output_rep.c_str(), "RECREATE");
    if (!fOut->IsOpen() || fOut->IsZombie() || !fs::exists(output)) {
        fOut.reset();
        BOOST_THROW_EXCEPTION( fs::filesystem_error("Failed to open output file",
                                output, make_error_code(errc::io_error)) );
    }
    fOut->SetTitle(title.c_str());
    return fOut;
}

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

{
    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`
nIndent	level of indentation

{
    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;
}

operator<<()

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

inline

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,
		const int	steering
	)

Adapted from ROOT example

Parameters

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

{
    inputs = GetROOTfiles(inputs);
    size_t factor = inputs.size();
    string location = GetFirstTreeLocation(inputs.front());
    Flow flow(steering, inputs);
    auto tIn = flow.GetInputTree();
    TObjArray * branches = tIn->GetListOfBranches();
    size_t size = loopBranches(branches, factor);
    cout << right << setw(50) << GetHumanReadableSize(size * factor) << endl;
}

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,
		const int	steering
	)

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

Parameters

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

    {
    inputs = GetROOTfiles(inputs);
    string location = GetFirstTreeLocation(inputs.front());
    Flow flow(steering, inputs);
    auto tIn = flow.GetInputTree({1, 0}, location);
    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());
 
    Flow flow(steering, inputs);
    auto chain = flow.GetInputTree({1, 0}, location);
 
    set<string> printed;
    CollectChainFriends(chain, printed, steering);
}

printHist()

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

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`
steering	bitfield from `Options::steering()`

{
    Flow flow(steering, inputs);
    auto h = flow.GetInputHist(config.get<string>("hist"));
    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;
    }