Splitter Class Reference

Class that allows to split runs into the intervals of intended properties given by the lossFunction. More...

#include <Splitter.h>

Public Member Functions
template<typename Evt >
std::vector< std::vector< std::map< ExpRun, std::pair< double, double > > > >	getIntervals (const std::map< ExpRun, std::pair< double, double > > &runs, std::vector< Evt > evts, TString lossFunctionOuter, TString lossFunctionInner, double atomSize=3./60)
	Function to merge/divide runs into the calibration intervals of given characteristic length.

Static Public Member Functions
static std::pair< double, double >	getStartEnd (std::vector< std::map< ExpRun, std::pair< double, double > > > res)
	Get the start/end time of the calibration interval (vector of the calib.
static std::vector< double >	getBreaks (std::vector< std::map< ExpRun, std::pair< double, double > > > res)
	Get vector with breaks of the calib.
static std::map< ExpRun, std::pair< double, double > >	mergeIntervals (std::map< ExpRun, std::pair< double, double > > I1, std::map< ExpRun, std::pair< double, double > > I2)
	Merge two subintervals into one subinterval.

Private Member Functions
std::vector< int >	dynamicBreaks (const std::vector< Atom > &runs)
	Get optimal break points using algorithm based on dynamic programming.
double	getMinLoss (const std::vector< Atom > &vec, int e, std::vector< int > &breaks)
	Recursive function to evaluate minimal sum of the lossFuctions for the optimal clustering.
double	lossFunction (const std::vector< Atom > &vec, int s, int e) const
	lossFunction of the calibration interval consisting of several "atoms" stored in vector vec The atoms included in calibration interval have indices between s and e
template<typename Evt >
std::vector< Atom >	createAtoms (const std::vector< std::pair< double, double > > &atomsTimes, const std::vector< Evt > &evts)
	Get the vector with parameters of the calibration Atoms.
TF1 *	toTF1 (TString LossString)
	Convert lossFunction from string to TF1.

Static Private Member Functions
static std::vector< std::pair< double, double > >	splitToSmall (std::map< ExpRun, std::pair< double, double > > runs, double intSize=1./60)
	Split the runs into small calibration intervals (atoms) of a specified size.

Private Attributes
TF1 *	lossFun
	loss function used for clustering of Atoms
std::vector< std::pair< double, std::vector< int > > >	cache
	cache used by the clustering algorithm (has to be reset every time)

Detailed Description

Class that allows to split runs into the intervals of intended properties given by the lossFunction.

It typically avoids of having large time gaps within calibration intervals. The algorithm is based on minimizing the total loss function Notice, that the calibration interval is defined as a map, where for each run the included period is defined by the start and end time

Definition at line 108 of file Splitter.h.

Constructor & Destructor Documentation

Splitter()

Splitter ( )

inline

Definition at line 111 of file Splitter.h.

: lossFun(nullptr)  {}

Member Function Documentation

createAtoms()

std::vector< Atom > createAtoms ( const std::vector< std::pair< double, double > > &  atomsTimes, const std::vector< Evt > &  evts  )

inlineprivate

Get the vector with parameters of the calibration Atoms.

Parameters

atomsTimes	vector with start/end times of the atoms
evts	vector with events

Returns

A vector of atoms, each including start/end times and the number of events inside

Definition at line 260 of file Splitter.h.

    {
      std::vector<Atom> atoms(atomsTimes.size());
 
      // Store start/end times to atoms
      for (unsigned a = 0; a < atoms.size(); ++a) {
        atoms[a].t1 = atomsTimes[a].first;
        atoms[a].t2 = atomsTimes[a].second;
      }
 
 
      // count the number of events in each atom
      for (unsigned i = 0; i < evts.size(); ++i) {
        for (unsigned a = 0; a < atoms.size(); ++a)
          if (atoms[a].t1 <= evts[i].t  && evts[i].t < atoms[a].t2)
            ++atoms[a].nEv;
 
      }
 
 
 
      return atoms;
    }

getBreaks()

static std::vector< double > getBreaks ( std::vector< std::map< ExpRun, std::pair< double, double > > >  res )

inlinestatic

Get vector with breaks of the calib.

interval

Parameters

res	A single calibration interval

Returns

: Vector of times [hours] of the break points, i.e. the subintervals boundaries

Definition at line 131 of file Splitter.h.

    {
      std::vector<double> breaks;
      for (int k = 0; k < int(res.size()) - 1; ++k) {
        double e = res.at(k).rbegin()->second.second; //end of the previous interval
        double s = res.at(k + 1).begin()->second.first; //start of the next interval
        breaks.push_back((e + s) / 2.);  //the break time is in between
      }
      return breaks;
    }

getIntervals()

std::vector< std::vector< std::map< ExpRun, std::pair< double, double > > > > getIntervals ( const std::map< ExpRun, std::pair< double, double > > &  runs, std::vector< Evt >  evts, TString  lossFunctionOuter, TString  lossFunctionInner, double  atomSize = 3. / 60  )

inline

Function to merge/divide runs into the calibration intervals of given characteristic length.

Parameters

runs	A map with key containing expNum+runNum and value start+end time in hours of the run
evts	A vector with all events
lossFunctionOuter	A formula of the outer loss function (for calib. intervals)
lossFunctionInner	A formula of the inner loss function (for calib. subintervals)
atomSize	length of the small calibration interval - atom (in hours)

Returns

: Vector of the calib. intervals always containing vector of calib. subintervals. Each subinterval is defined as a map spanning in general over several runs

Definition at line 163 of file Splitter.h.

    {
      //sort events by time
      std::sort(evts.begin(), evts.end(), [](const Evt & e1, const Evt & e2) { return (e1.t > e2.t); });
 
      // Divide into small intervals
      std::vector<std::pair<double, double>> smallRuns = splitToSmall(runs, atomSize);
 
      std::vector<Atom> atoms = createAtoms(smallRuns, evts);
 
 
      // Calculate breaks for the calib. intervals
      lossFun = toTF1(lossFunctionOuter);
      std::vector<int> breaksSize = dynamicBreaks(atoms);
 
      std::vector<std::vector<std::map<ExpRun, std::pair<double, double>>>> splitsRun; //split intervals with runNumber info
 
 
      // Calculate breaks for the calib. subintervals
      lossFun = toTF1(lossFunctionInner);
      std::vector<int> breaksVtx;
      for (int i = 0; i < int(breaksSize.size()) + 1; ++i) { //loop over all calib. intervals
        int s, e;
        std::tie(s, e) = getStartEndIndexes(atoms.size(), breaksSize, i);
 
        // Store only atoms lying in the current calib. interval
        auto currVec = slice(atoms, s, e);
 
        // Get optimal breaks for particular calib. interval
        std::vector<int> breaksSmall = dynamicBreaks(currVec);
 
        // Incorporate the runNumber information
        auto splitSeg = breaks2intervalsSep(runs, currVec, breaksSmall);
 
        // Put the vector of subintervals (representing division of the interval)
        // into the vector
        splitsRun.push_back(splitSeg);
 
        if (s != 0) breaksVtx.push_back(s - 1);
        for (auto b : breaksSmall)
          breaksVtx.push_back(b + s);
        if (e != int(breaksSize.size())) breaksVtx.push_back(e);
      }
 
      return splitsRun;
    }

getStartEnd()

static std::pair< double, double > getStartEnd ( std::vector< std::map< ExpRun, std::pair< double, double > > >  res )

inlinestatic

Get the start/end time of the calibration interval (vector of the calib.

subintervals).

Parameters

res	A single calibration interval (for example from getIntervals function)

Returns

: A pair with start/end time of the whole calib. interval

Definition at line 120 of file Splitter.h.

    {
      return {res.front().begin()->second.first,
              res.back().rbegin()->second.second};
    }

toTF1()

TF1 * toTF1 ( TString  LossString )

inlineprivate

Convert lossFunction from string to TF1.

Definition at line 286 of file Splitter.h.

    {
      LossString.ReplaceAll("rawTime", "[0]");
      LossString.ReplaceAll("netTime", "[1]");
      LossString.ReplaceAll("maxGap",  "[2]");
      LossString.ReplaceAll("nEv",     "[3]");
 
      return (new TF1("lossFun", LossString));
    }

Member Data Documentation

cache

std::vector<std::pair<double, std::vector<int> > > cache

private

cache used by the clustering algorithm (has to be reset every time)

Definition at line 301 of file Splitter.h.

lossFun

TF1* lossFun

private

loss function used for clustering of Atoms

Definition at line 297 of file Splitter.h.

---

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

• reconstruction/calibration/BeamSpotBoostInvMass/include/Splitter.h
• reconstruction/calibration/BeamSpotBoostInvMass/src/Splitter.cc