Looper.h

Go to the documentation of this file.

#ifndef DARWIN_LOOPER_H
#define DARWIN_LOOPER_H
 
#include <algorithm>
#include <memory>
#include <iostream>
#include <string>
 
#include <chrono>
#include <ctime>
 
#include <boost/exception/all.hpp>
 
#include <TChain.h>
#include <TTree.h>
 
#include "exceptions.h"
 
namespace Darwin::Tools {
 
typedef std::pair<unsigned, unsigned> Slice; 
 
std::ostream& operator<< (std::ostream& Stream, const Darwin::Tools::Slice& slice)
{
    Stream << slice.second << '/' << slice.first;
    return Stream;
}
 
class Looper {
    TTree * tree; 
    const Slice slice; 
 
    const long long nEvTot, 
                    start, 
                    stop, 
                    nEvSlice; // number of entries covered by the current process
    long long iEvSlice; // current entry
    long long percent; // percentage of progress for current entry
 
    const std::chrono::time_point<std::chrono::system_clock> start_t; 
 
    Looper (TTree * t, 
            long long nEvents, 
            Slice s = {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);
    }
 
public:
 
    static long long division; 
 
    template<typename TTreePtr>
    Looper (const TTreePtr& t, 
            Slice s = {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 (long long nEvents, 
            Slice s = {1,0} 
            ) : Looper(nullptr, nEvents, s)
    {
    }
 
    ~Looper ()
    {
        if (percent < 100ll)
            std::cerr << red << "Warning: the event loop has stopped at entry "
                      << iEvSlice << def << '\n';
    }
 
    void operator++ ()
    {
        ++iEvSlice;
        if (tree) tree->GetEntry(start + iEvSlice);
    }
 
    bool operator() ()
    {
        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;
    }
 
    inline const long long operator* () const
    {
        return start + iEvSlice;
    }
};
 
long long Looper::division = 10;
 
} // end of Darwin::Tools namespace
 
using Darwin::Tools::operator<<;
 
#endif