Looper

Description

Facility to loop over a n-tuple, including parallelisation and printing.

#include <Looper.h>

Public Member Functions
template<typename TTreePtr >
	Looper (const TTreePtr &t, Slice s={1, 0})
	Looper (long long nEvents, Slice s={1, 0})
	~Looper ()
void	operator++ ()
bool	operator() ()
const long long	operator* () const

Static Public Attributes
static long long	division = 10

Private Member Functions
	Looper (TTree *t, long long nEvents, Slice s={1, 0})

Private Attributes
TTree *	tree
const Slice	slice
const long long	nEvTot
const long long	start
const long long	stop
const long long	nEvSlice
long long	iEvSlice
long long	percent
const std::chrono::time_point< std::chrono::system_clock >	start_t

Constructor & Destructor Documentation

Looper() [1/3]

Looper ( TTree *  t, long long  nEvents, Slice  s = {1,0}  )

inlineprivate

Parameters

t	n-tuple
nEvents	total number of events to generate (with all slices)
s	exactly like the output of `Options::slice()`

                      {1,0} 
            ) : tree(t), slice(s),
                nEvTot(nEvents),
                start(nEvTot*((s.second+0.)/s.first)),
                stop (nEvTot*((s.second+1.)/s.first)),
                nEvSlice(stop - start), iEvSlice(0), percent(-1),
                start_t(std::chrono::system_clock::now())
    {
        using namespace std;
 
        if (slice.first < slice.second)
            BOOST_THROW_EXCEPTION(invalid_argument("The number of slices " + to_string(slice.first)
                        + " must be larger than the index of the current slice " + to_string(slice.second)));
 
        if (nEvSlice <= 0)
            BOOST_THROW_EXCEPTION(invalid_argument("The number of events cannot be " + to_string(nEvSlice)));
 
        cerr << slice << '\t' << start << '-' << stop;
 
        time_t now = chrono::system_clock::to_time_t(start_t);
        cerr << '\t' << ctime(&now);
    }

Looper() [2/3]

Looper ( const TTreePtr &  t, Slice  s = {1,0}  )

inline

Constructor for existing tree with raw pointer.

Parameters

t	n-tuple
s	exactly like the output of `Options::slice()`

                      {1,0} 
            ) : Looper(&*t, t->GetEntries(), s)
    {
        using namespace std;
        namespace DE = Darwin::Exceptions;
        string root_log = DE::intercept_printf([this]() { printf("loading first entry"); tree->GetEntry(start); });
        tree->GetEntry(start);
        if (root_log.find("Error") != string::npos)
            BOOST_THROW_EXCEPTION(runtime_error("Error while loading a TTree entry:\n" + root_log));
    }

Looper() [3/3]

Looper ( long long  nEvents, Slice  s = {1,0}  )

inline

Constructor for simple counter.

Parameters

nEvents	total number of events to generate (with all slices)
s	exactly like the output of `Options::slice()`

                      {1,0} 
            ) : Looper(nullptr, nEvents, s)
    {
    }

~Looper()

~Looper ( )

inline

    {
        if (percent < 100ll)
            std::cerr << red << "Warning: the event loop has stopped at entry "
                      << iEvSlice << def << '\n';
    }

Member Function Documentation

operator()()

bool operator() ( )

inline

Check that the counter is still in the range and prints percentage.

    {
        using namespace std;
        long long test_percent = (100ll*iEvSlice)/nEvSlice;
 
        if (test_percent != percent && test_percent % division == 0) {
            percent = test_percent;
            cerr << slice.second << '/' << slice.first << '\t' << percent << '%';
            auto now_t = chrono::system_clock::now();
            auto elapsed_time {now_t - start_t};
            time_t now = chrono::system_clock::to_time_t(now_t);
            auto secs = chrono::duration_cast<chrono::seconds>(elapsed_time);
            cerr << '\t' << secs.count() << "s\t" << ctime(&now);
        }
 
        return iEvSlice < nEvSlice;
    }

operator*()

const long long operator* ( ) const

inline

Pointer-like operator to return the value of the entry.

    {
        return start + iEvSlice;
    }

operator++()

void operator++ ( )

inline

Increments the counter and load entry (if applicable)

    {
        ++iEvSlice;
        if (tree) tree->GetEntry(start + iEvSlice);
    }

Member Data Documentation

division

long long division = 10

static

steps at which progress is printed (100%/division)

iEvSlice

long long iEvSlice

private

nEvSlice

const long long nEvSlice

private

nEvTot

const long long nEvTot

private

{#processes, process index}

total number of entries in tree

percent

long long percent

private

slice

const Slice slice

private

start

const long long start

private

first entry (included)

start_t

const std::chrono::time_point<std::chrono::system_clock> start_t

private

starting time

stop

const long long stop

private

last entry (excluded)

tree

TTree* tree

private

tree

---

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

• /builds/Proto/Darwin/interface/Looper.h