EGamma_ElectronTrackingValidation/analysis/TrackingNtupleObjs.hpp

/** TrackingNtupleObjs.hpp created on 2017-12-10 17:34:34.450820 by generate_class.py
 * AVOID EDITING THIS FILE BY HAND!! Instead edit TrackingNtupleObjs.yaml and re-run
 * generate_class.py
 */
#include "filval/filval.hpp"
#include "filval/root/filval.hpp"

#include<cmath>

#include "TrackingNtuple.h"

using namespace std;
using namespace fv;
using namespace fv::root;

typedef TreeDataSet<TrackingNtuple> TrackingDataSet;
struct PixRecHit;

class PixRecHitCollection {
  public:
    class iter {
      public:
        iter(const PixRecHitCollection* collection, size_t idx)
          :collection(collection), idx(idx) { }
        iter operator++() { ++idx; return *this; }
        bool operator!=(const iter & other) { return idx != other.idx; }
        const PixRecHit operator*() const;
      private:
        const PixRecHitCollection* collection;
        size_t idx;
    };

    Value<vector<unsigned short>>* val_subdet;
    Value<vector<unsigned short>>* val_layer;
    Value<vector<unsigned short>>* val_ladder;
    Value<vector<unsigned int>>* val_detId;
    Value<vector<unsigned short>>* val_simType;
    Value<vector<float>>* val_x;
    Value<vector<float>>* val_y;
    Value<vector<float>>* val_z;
    Value<vector<float>>* val_xx;
    Value<vector<float>>* val_xy;
    Value<vector<float>>* val_yy;
    Value<vector<float>>* val_yz;
    Value<vector<float>>* val_zz;
    Value<vector<float>>* val_zx;
    Value<vector<float>>* val_radL;
    Value<vector<float>>* val_bbxi;
    Value<vector<vector<int>>>* val_trkIdx;
    Value<vector<vector<int>>>* val_seeIdx;
    Value<vector<vector<int>>>* val_simHitIdx;
    Value<vector<vector<float>>>* val_chargeFraction;

    PixRecHitCollection() { }

    void init(TrackingDataSet& tds){
        val_subdet = tds.track_branch_obj<vector<unsigned short>>("pix_subdet");
        val_layer = tds.track_branch_obj<vector<unsigned short>>("pix_layer");
        val_ladder = tds.track_branch_obj<vector<unsigned short>>("pix_ladder");
        val_detId = tds.track_branch_obj<vector<unsigned int>>("pix_detId");
        val_simType = tds.track_branch_obj<vector<unsigned short>>("pix_simType");
        val_x = tds.track_branch_obj<vector<float>>("pix_x");
        val_y = tds.track_branch_obj<vector<float>>("pix_y");
        val_z = tds.track_branch_obj<vector<float>>("pix_z");
        val_xx = tds.track_branch_obj<vector<float>>("pix_xx");
        val_xy = tds.track_branch_obj<vector<float>>("pix_xy");
        val_yy = tds.track_branch_obj<vector<float>>("pix_yy");
        val_yz = tds.track_branch_obj<vector<float>>("pix_yz");
        val_zz = tds.track_branch_obj<vector<float>>("pix_zz");
        val_zx = tds.track_branch_obj<vector<float>>("pix_zx");
        val_radL = tds.track_branch_obj<vector<float>>("pix_radL");
        val_bbxi = tds.track_branch_obj<vector<float>>("pix_bbxi");
        val_trkIdx = tds.track_branch_obj<vector<vector<int>>>("pix_trkIdx");
        val_seeIdx = tds.track_branch_obj<vector<vector<int>>>("pix_seeIdx");
        val_simHitIdx = tds.track_branch_obj<vector<vector<int>>>("pix_simHitIdx");
        val_chargeFraction = tds.track_branch_obj<vector<vector<float>>>("pix_chargeFraction");
    }

    size_t size() const { return val_subdet->get_value().size();}

    const PixRecHit operator[](size_t) const;
    iter begin() const { return iter(this, 0); }
    iter end() const { return iter(this, size()); }
};

struct PixRecHit {
    const PixRecHitCollection* collection;
    const size_t idx;
    PixRecHit(const PixRecHitCollection* collection, const size_t idx)
      :collection(collection), idx(idx) { }

    const unsigned short& subdet() const {return collection->val_subdet->get_value().at(idx);}
    const unsigned short& layer() const {return collection->val_layer->get_value().at(idx);}
    const unsigned short& ladder() const {return collection->val_ladder->get_value().at(idx);}
    const unsigned int& detId() const {return collection->val_detId->get_value().at(idx);}
    const unsigned short& simType() const {return collection->val_simType->get_value().at(idx);}
    const float& x() const {return collection->val_x->get_value().at(idx);}
    const float& y() const {return collection->val_y->get_value().at(idx);}
    const float& z() const {return collection->val_z->get_value().at(idx);}
    const float& xx() const {return collection->val_xx->get_value().at(idx);}
    const float& xy() const {return collection->val_xy->get_value().at(idx);}
    const float& yy() const {return collection->val_yy->get_value().at(idx);}
    const float& yz() const {return collection->val_yz->get_value().at(idx);}
    const float& zz() const {return collection->val_zz->get_value().at(idx);}
    const float& zx() const {return collection->val_zx->get_value().at(idx);}
    const float& radL() const {return collection->val_radL->get_value().at(idx);}
    const float& bbxi() const {return collection->val_bbxi->get_value().at(idx);}
    const vector<int>& trkIdx() const {return collection->val_trkIdx->get_value().at(idx);}
    const vector<int>& seeIdx() const {return collection->val_seeIdx->get_value().at(idx);}
    const vector<int>& simHitIdx() const {return collection->val_simHitIdx->get_value().at(idx);}
    const vector<float>& chargeFraction() const {return collection->val_chargeFraction->get_value().at(idx);}
};

const PixRecHit PixRecHitCollection::iter::operator*() const {
    return {collection, idx};
}
const PixRecHit PixRecHitCollection::operator[](size_t idx) const {
    return {this, idx};
}
struct SimHit;

class SimHitCollection {
  public:
    class iter {
      public:
        iter(const SimHitCollection* collection, size_t idx)
          :collection(collection), idx(idx) { }
        iter operator++() { ++idx; return *this; }
        bool operator!=(const iter & other) { return idx != other.idx; }
        const SimHit operator*() const;
      private:
        const SimHitCollection* collection;
        size_t idx;
    };

    Value<vector<unsigned short>>* val_subdet;
    Value<vector<unsigned short>>* val_layer;
    Value<vector<unsigned int>>* val_detId;
    Value<vector<float>>* val_x;
    Value<vector<float>>* val_y;
    Value<vector<float>>* val_z;
    Value<vector<int>>* val_particle;
    Value<vector<short>>* val_process;
    Value<vector<float>>* val_eloss;
    Value<vector<float>>* val_tof;
    Value<vector<int>>* val_simTrkIdx;
    Value<vector<vector<int>>>* val_hitIdx;
    Value<vector<vector<int>>>* val_hitType;

    SimHitCollection() { }

    void init(TrackingDataSet& tds){
        val_subdet = tds.track_branch_obj<vector<unsigned short>>("simhit_subdet");
        val_layer = tds.track_branch_obj<vector<unsigned short>>("simhit_layer");
        val_detId = tds.track_branch_obj<vector<unsigned int>>("simhit_detId");
        val_x = tds.track_branch_obj<vector<float>>("simhit_x");
        val_y = tds.track_branch_obj<vector<float>>("simhit_y");
        val_z = tds.track_branch_obj<vector<float>>("simhit_z");
        val_particle = tds.track_branch_obj<vector<int>>("simhit_particle");
        val_process = tds.track_branch_obj<vector<short>>("simhit_process");
        val_eloss = tds.track_branch_obj<vector<float>>("simhit_eloss");
        val_tof = tds.track_branch_obj<vector<float>>("simhit_tof");
        val_simTrkIdx = tds.track_branch_obj<vector<int>>("simhit_simTrkIdx");
        val_hitIdx = tds.track_branch_obj<vector<vector<int>>>("simhit_hitIdx");
        val_hitType = tds.track_branch_obj<vector<vector<int>>>("simhit_hitType");
    }

    size_t size() const { return val_subdet->get_value().size();}

    const SimHit operator[](size_t) const;
    iter begin() const { return iter(this, 0); }
    iter end() const { return iter(this, size()); }
};

struct SimHit {
    const SimHitCollection* collection;
    const size_t idx;
    SimHit(const SimHitCollection* collection, const size_t idx)
      :collection(collection), idx(idx) { }

    const unsigned short& subdet() const {return collection->val_subdet->get_value().at(idx);}
    const unsigned short& layer() const {return collection->val_layer->get_value().at(idx);}
    const unsigned int& detId() const {return collection->val_detId->get_value().at(idx);}
    const float& x() const {return collection->val_x->get_value().at(idx);}
    const float& y() const {return collection->val_y->get_value().at(idx);}
    const float& z() const {return collection->val_z->get_value().at(idx);}
    const int& particle() const {return collection->val_particle->get_value().at(idx);}
    const short& process() const {return collection->val_process->get_value().at(idx);}
    const float& eloss() const {return collection->val_eloss->get_value().at(idx);}
    const float& tof() const {return collection->val_tof->get_value().at(idx);}
    const int& simTrkIdx() const {return collection->val_simTrkIdx->get_value().at(idx);}
    const vector<int>& hitIdx() const {return collection->val_hitIdx->get_value().at(idx);}
    const vector<int>& hitType() const {return collection->val_hitType->get_value().at(idx);}
};

const SimHit SimHitCollection::iter::operator*() const {
    return {collection, idx};
}
const SimHit SimHitCollection::operator[](size_t idx) const {
    return {this, idx};
}
struct Seed;

class SeedCollection {
  public:
    class iter {
      public:
        iter(const SeedCollection* collection, size_t idx)
          :collection(collection), idx(idx) { }
        iter operator++() { ++idx; return *this; }
        bool operator!=(const iter & other) { return idx != other.idx; }
        const Seed operator*() const;
      private:
        const SeedCollection* collection;
        size_t idx;
    };

    Value<vector<short>>* val_fitok;
    Value<vector<float>>* val_px;
    Value<vector<float>>* val_py;
    Value<vector<float>>* val_pz;
    Value<vector<float>>* val_pt;
    Value<vector<float>>* val_eta;
    Value<vector<float>>* val_phi;
    Value<vector<float>>* val_dxy;
    Value<vector<float>>* val_dz;
    Value<vector<float>>* val_ptErr;
    Value<vector<float>>* val_etaErr;
    Value<vector<float>>* val_phiErr;
    Value<vector<float>>* val_dxyErr;
    Value<vector<float>>* val_dzErr;
    Value<vector<float>>* val_chi2;
    Value<vector<int>>* val_q;
    Value<vector<unsigned int>>* val_nValid;
    Value<vector<unsigned int>>* val_nPixel;
    Value<vector<unsigned int>>* val_nGlued;
    Value<vector<unsigned int>>* val_nStrip;
    Value<vector<unsigned int>>* val_algo;
    Value<vector<unsigned int>>* val_algoOriginal;
    Value<vector<int>>* val_trkIdx;
    Value<vector<vector<float>>>* val_shareFrac;
    Value<vector<vector<int>>>* val_simTrkIdx;
    Value<vector<vector<int>>>* val_hitIdx;
    Value<vector<vector<int>>>* val_hitType;
    Value<vector<unsigned int>>* val_offset;
    Value<vector<unsigned char>>* val_hitsMask;
    Value<vector<int>>* val_subDet2;
    Value<vector<float>>* val_dRz2;
    Value<vector<float>>* val_dPhi2;
    Value<vector<float>>* val_dRz2Pos;
    Value<vector<float>>* val_dPhi2Pos;
    Value<vector<int>>* val_subDet1;
    Value<vector<float>>* val_dRz1;
    Value<vector<float>>* val_dPhi1;
    Value<vector<float>>* val_dRz1Pos;
    Value<vector<float>>* val_dPhi1Pos;
    Value<vector<float>>* val_superClusterEnergy;
    Value<vector<float>>* val_superClusterEta;
    Value<vector<float>>* val_superClusterPhi;
    Value<vector<float>>* val_superClusterEt;
    Value<vector<int>>* val_superClusterIdx;
    Value<vector<unsigned int>>* val_ecalDriven;
    Value<vector<unsigned int>>* val_trkDriven;

    SeedCollection() { }

    void init(TrackingDataSet& tds){
        val_fitok = tds.track_branch_obj<vector<short>>("see_fitok");
        val_px = tds.track_branch_obj<vector<float>>("see_px");
        val_py = tds.track_branch_obj<vector<float>>("see_py");
        val_pz = tds.track_branch_obj<vector<float>>("see_pz");
        val_pt = tds.track_branch_obj<vector<float>>("see_pt");
        val_eta = tds.track_branch_obj<vector<float>>("see_eta");
        val_phi = tds.track_branch_obj<vector<float>>("see_phi");
        val_dxy = tds.track_branch_obj<vector<float>>("see_dxy");
        val_dz = tds.track_branch_obj<vector<float>>("see_dz");
        val_ptErr = tds.track_branch_obj<vector<float>>("see_ptErr");
        val_etaErr = tds.track_branch_obj<vector<float>>("see_etaErr");
        val_phiErr = tds.track_branch_obj<vector<float>>("see_phiErr");
        val_dxyErr = tds.track_branch_obj<vector<float>>("see_dxyErr");
        val_dzErr = tds.track_branch_obj<vector<float>>("see_dzErr");
        val_chi2 = tds.track_branch_obj<vector<float>>("see_chi2");
        val_q = tds.track_branch_obj<vector<int>>("see_q");
        val_nValid = tds.track_branch_obj<vector<unsigned int>>("see_nValid");
        val_nPixel = tds.track_branch_obj<vector<unsigned int>>("see_nPixel");
        val_nGlued = tds.track_branch_obj<vector<unsigned int>>("see_nGlued");
        val_nStrip = tds.track_branch_obj<vector<unsigned int>>("see_nStrip");
        val_algo = tds.track_branch_obj<vector<unsigned int>>("see_algo");
        val_algoOriginal = tds.track_branch_obj<vector<unsigned int>>("see_algoOriginal");
        val_trkIdx = tds.track_branch_obj<vector<int>>("see_trkIdx");
        val_shareFrac = tds.track_branch_obj<vector<vector<float>>>("see_shareFrac");
        val_simTrkIdx = tds.track_branch_obj<vector<vector<int>>>("see_simTrkIdx");
        val_hitIdx = tds.track_branch_obj<vector<vector<int>>>("see_hitIdx");
        val_hitType = tds.track_branch_obj<vector<vector<int>>>("see_hitType");
        val_offset = tds.track_branch_obj<vector<unsigned int>>("see_offset");
        val_hitsMask = tds.track_branch_obj<vector<unsigned char>>("see_hitsMask");
        val_subDet2 = tds.track_branch_obj<vector<int>>("see_subDet2");
        val_dRz2 = tds.track_branch_obj<vector<float>>("see_dRz2");
        val_dPhi2 = tds.track_branch_obj<vector<float>>("see_dPhi2");
        val_dRz2Pos = tds.track_branch_obj<vector<float>>("see_dRz2Pos");
        val_dPhi2Pos = tds.track_branch_obj<vector<float>>("see_dPhi2Pos");
        val_subDet1 = tds.track_branch_obj<vector<int>>("see_subDet1");
        val_dRz1 = tds.track_branch_obj<vector<float>>("see_dRz1");
        val_dPhi1 = tds.track_branch_obj<vector<float>>("see_dPhi1");
        val_dRz1Pos = tds.track_branch_obj<vector<float>>("see_dRz1Pos");
        val_dPhi1Pos = tds.track_branch_obj<vector<float>>("see_dPhi1Pos");
        val_superClusterEnergy = tds.track_branch_obj<vector<float>>("see_superClusterEnergy");
        val_superClusterEta = tds.track_branch_obj<vector<float>>("see_superClusterEta");
        val_superClusterPhi = tds.track_branch_obj<vector<float>>("see_superClusterPhi");
        val_superClusterEt = tds.track_branch_obj<vector<float>>("see_superClusterEt");
        val_superClusterIdx = tds.track_branch_obj<vector<int>>("see_superClusterIdx");
        val_ecalDriven = tds.track_branch_obj<vector<unsigned int>>("see_ecalDriven");
        val_trkDriven = tds.track_branch_obj<vector<unsigned int>>("see_trkDriven");
    }

    size_t size() const { return val_fitok->get_value().size();}

    const Seed operator[](size_t) const;
    iter begin() const { return iter(this, 0); }
    iter end() const { return iter(this, size()); }
};

struct Seed {
    const SeedCollection* collection;
    const size_t idx;
    Seed(const SeedCollection* collection, const size_t idx)
      :collection(collection), idx(idx) { }

    const short& fitok() const {return collection->val_fitok->get_value().at(idx);}
    const float& px() const {return collection->val_px->get_value().at(idx);}
    const float& py() const {return collection->val_py->get_value().at(idx);}
    const float& pz() const {return collection->val_pz->get_value().at(idx);}
    const float& pt() const {return collection->val_pt->get_value().at(idx);}
    const float& eta() const {return collection->val_eta->get_value().at(idx);}
    const float& phi() const {return collection->val_phi->get_value().at(idx);}
    const float& dxy() const {return collection->val_dxy->get_value().at(idx);}
    const float& dz() const {return collection->val_dz->get_value().at(idx);}
    const float& ptErr() const {return collection->val_ptErr->get_value().at(idx);}
    const float& etaErr() const {return collection->val_etaErr->get_value().at(idx);}
    const float& phiErr() const {return collection->val_phiErr->get_value().at(idx);}
    const float& dxyErr() const {return collection->val_dxyErr->get_value().at(idx);}
    const float& dzErr() const {return collection->val_dzErr->get_value().at(idx);}
    const float& chi2() const {return collection->val_chi2->get_value().at(idx);}
    const int& q() const {return collection->val_q->get_value().at(idx);}
    const unsigned int& nValid() const {return collection->val_nValid->get_value().at(idx);}
    const unsigned int& nPixel() const {return collection->val_nPixel->get_value().at(idx);}
    const unsigned int& nGlued() const {return collection->val_nGlued->get_value().at(idx);}
    const unsigned int& nStrip() const {return collection->val_nStrip->get_value().at(idx);}
    const unsigned int& algo() const {return collection->val_algo->get_value().at(idx);}
    const unsigned int& algoOriginal() const {return collection->val_algoOriginal->get_value().at(idx);}
    const int& trkIdx() const {return collection->val_trkIdx->get_value().at(idx);}
    const vector<float>& shareFrac() const {return collection->val_shareFrac->get_value().at(idx);}
    const vector<int>& simTrkIdx() const {return collection->val_simTrkIdx->get_value().at(idx);}
    const vector<int>& hitIdx() const {return collection->val_hitIdx->get_value().at(idx);}
    const vector<int>& hitType() const {return collection->val_hitType->get_value().at(idx);}
    const unsigned int& offset() const {return collection->val_offset->get_value().at(idx);}
    const unsigned char& hitsMask() const {return collection->val_hitsMask->get_value().at(idx);}
    const int& subDet2() const {return collection->val_subDet2->get_value().at(idx);}
    const float& dRz2() const {return collection->val_dRz2->get_value().at(idx);}
    const float& dPhi2() const {return collection->val_dPhi2->get_value().at(idx);}
    const float& dRz2Pos() const {return collection->val_dRz2Pos->get_value().at(idx);}
    const float& dPhi2Pos() const {return collection->val_dPhi2Pos->get_value().at(idx);}
    const int& subDet1() const {return collection->val_subDet1->get_value().at(idx);}
    const float& dRz1() const {return collection->val_dRz1->get_value().at(idx);}
    const float& dPhi1() const {return collection->val_dPhi1->get_value().at(idx);}
    const float& dRz1Pos() const {return collection->val_dRz1Pos->get_value().at(idx);}
    const float& dPhi1Pos() const {return collection->val_dPhi1Pos->get_value().at(idx);}
    const float& superClusterEnergy() const {return collection->val_superClusterEnergy->get_value().at(idx);}
    const float& superClusterEta() const {return collection->val_superClusterEta->get_value().at(idx);}
    const float& superClusterPhi() const {return collection->val_superClusterPhi->get_value().at(idx);}
    const float& superClusterEt() const {return collection->val_superClusterEt->get_value().at(idx);}
    const int& superClusterIdx() const {return collection->val_superClusterIdx->get_value().at(idx);}
    const unsigned int& ecalDriven() const {return collection->val_ecalDriven->get_value().at(idx);}
    const unsigned int& trkDriven() const {return collection->val_trkDriven->get_value().at(idx);}
};

const Seed SeedCollection::iter::operator*() const {
    return {collection, idx};
}
const Seed SeedCollection::operator[](size_t idx) const {
    return {this, idx};
}
struct Track;

class TrackCollection {
  public:
    class iter {
      public:
        iter(const TrackCollection* collection, size_t idx)
          :collection(collection), idx(idx) { }
        iter operator++() { ++idx; return *this; }
        bool operator!=(const iter & other) { return idx != other.idx; }
        const Track operator*() const;
      private:
        const TrackCollection* collection;
        size_t idx;
    };

    Value<vector<float>>* val_px;
    Value<vector<float>>* val_py;
    Value<vector<float>>* val_pz;
    Value<vector<float>>* val_pt;
    Value<vector<float>>* val_inner_px;
    Value<vector<float>>* val_inner_py;
    Value<vector<float>>* val_inner_pz;
    Value<vector<float>>* val_inner_pt;
    Value<vector<float>>* val_outer_px;
    Value<vector<float>>* val_outer_py;
    Value<vector<float>>* val_outer_pz;
    Value<vector<float>>* val_outer_pt;
    Value<vector<float>>* val_eta;
    Value<vector<float>>* val_lambda;
    Value<vector<float>>* val_cotTheta;
    Value<vector<float>>* val_phi;
    Value<vector<float>>* val_dxy;
    Value<vector<float>>* val_dz;
    Value<vector<float>>* val_ptErr;
    Value<vector<float>>* val_etaErr;
    Value<vector<float>>* val_lambdaErr;
    Value<vector<float>>* val_phiErr;
    Value<vector<float>>* val_dxyErr;
    Value<vector<float>>* val_dzErr;
    Value<vector<float>>* val_refpoint_x;
    Value<vector<float>>* val_refpoint_y;
    Value<vector<float>>* val_refpoint_z;
    Value<vector<float>>* val_nChi2;
    Value<vector<int>>* val_q;
    Value<vector<unsigned int>>* val_nValid;
    Value<vector<unsigned int>>* val_nInvalid;
    Value<vector<unsigned int>>* val_nPixel;
    Value<vector<unsigned int>>* val_nStrip;
    Value<vector<unsigned int>>* val_nPixelLay;
    Value<vector<unsigned int>>* val_nStripLay;
    Value<vector<unsigned int>>* val_n3DLay;
    Value<vector<unsigned int>>* val_nOuterLost;
    Value<vector<unsigned int>>* val_nInnerLost;
    Value<vector<unsigned int>>* val_algo;
    Value<vector<unsigned int>>* val_originalAlgo;
    Value<vector<ULong64_t>>* val_algoMask;
    Value<vector<unsigned int>>* val_stopReason;
    Value<vector<short>>* val_isHP;
    Value<vector<int>>* val_seedIdx;
    Value<vector<float>>* val_vtxx;
    Value<vector<float>>* val_vtxy;
    Value<vector<float>>* val_vtxz;
    Value<vector<vector<float>>>* val_shareFrac;
    Value<vector<vector<int>>>* val_simTrkIdx;
    Value<vector<vector<int>>>* val_hitIdx;
    Value<vector<vector<int>>>* val_hitType;
    Value<vector<int>>* val_genIdx;
    Value<vector<float>>* val_genDR;

    TrackCollection() { }

    void init(TrackingDataSet& tds){
        val_px = tds.track_branch_obj<vector<float>>("trk_px");
        val_py = tds.track_branch_obj<vector<float>>("trk_py");
        val_pz = tds.track_branch_obj<vector<float>>("trk_pz");
        val_pt = tds.track_branch_obj<vector<float>>("trk_pt");
        val_inner_px = tds.track_branch_obj<vector<float>>("trk_inner_px");
        val_inner_py = tds.track_branch_obj<vector<float>>("trk_inner_py");
        val_inner_pz = tds.track_branch_obj<vector<float>>("trk_inner_pz");
        val_inner_pt = tds.track_branch_obj<vector<float>>("trk_inner_pt");
        val_outer_px = tds.track_branch_obj<vector<float>>("trk_outer_px");
        val_outer_py = tds.track_branch_obj<vector<float>>("trk_outer_py");
        val_outer_pz = tds.track_branch_obj<vector<float>>("trk_outer_pz");
        val_outer_pt = tds.track_branch_obj<vector<float>>("trk_outer_pt");
        val_eta = tds.track_branch_obj<vector<float>>("trk_eta");
        val_lambda = tds.track_branch_obj<vector<float>>("trk_lambda");
        val_cotTheta = tds.track_branch_obj<vector<float>>("trk_cotTheta");
        val_phi = tds.track_branch_obj<vector<float>>("trk_phi");
        val_dxy = tds.track_branch_obj<vector<float>>("trk_dxy");
        val_dz = tds.track_branch_obj<vector<float>>("trk_dz");
        val_ptErr = tds.track_branch_obj<vector<float>>("trk_ptErr");
        val_etaErr = tds.track_branch_obj<vector<float>>("trk_etaErr");
        val_lambdaErr = tds.track_branch_obj<vector<float>>("trk_lambdaErr");
        val_phiErr = tds.track_branch_obj<vector<float>>("trk_phiErr");
        val_dxyErr = tds.track_branch_obj<vector<float>>("trk_dxyErr");
        val_dzErr = tds.track_branch_obj<vector<float>>("trk_dzErr");
        val_refpoint_x = tds.track_branch_obj<vector<float>>("trk_refpoint_x");
        val_refpoint_y = tds.track_branch_obj<vector<float>>("trk_refpoint_y");
        val_refpoint_z = tds.track_branch_obj<vector<float>>("trk_refpoint_z");
        val_nChi2 = tds.track_branch_obj<vector<float>>("trk_nChi2");
        val_q = tds.track_branch_obj<vector<int>>("trk_q");
        val_nValid = tds.track_branch_obj<vector<unsigned int>>("trk_nValid");
        val_nInvalid = tds.track_branch_obj<vector<unsigned int>>("trk_nInvalid");
        val_nPixel = tds.track_branch_obj<vector<unsigned int>>("trk_nPixel");
        val_nStrip = tds.track_branch_obj<vector<unsigned int>>("trk_nStrip");
        val_nPixelLay = tds.track_branch_obj<vector<unsigned int>>("trk_nPixelLay");
        val_nStripLay = tds.track_branch_obj<vector<unsigned int>>("trk_nStripLay");
        val_n3DLay = tds.track_branch_obj<vector<unsigned int>>("trk_n3DLay");
        val_nOuterLost = tds.track_branch_obj<vector<unsigned int>>("trk_nOuterLost");
        val_nInnerLost = tds.track_branch_obj<vector<unsigned int>>("trk_nInnerLost");
        val_algo = tds.track_branch_obj<vector<unsigned int>>("trk_algo");
        val_originalAlgo = tds.track_branch_obj<vector<unsigned int>>("trk_originalAlgo");
        val_algoMask = tds.track_branch_obj<vector<ULong64_t>>("trk_algoMask");
        val_stopReason = tds.track_branch_obj<vector<unsigned int>>("trk_stopReason");
        val_isHP = tds.track_branch_obj<vector<short>>("trk_isHP");
        val_seedIdx = tds.track_branch_obj<vector<int>>("trk_seedIdx");
        val_vtxx = tds.track_branch_obj<vector<float>>("trk_vtxx");
        val_vtxy = tds.track_branch_obj<vector<float>>("trk_vtxy");
        val_vtxz = tds.track_branch_obj<vector<float>>("trk_vtxz");
        val_shareFrac = tds.track_branch_obj<vector<vector<float>>>("trk_shareFrac");
        val_simTrkIdx = tds.track_branch_obj<vector<vector<int>>>("trk_simTrkIdx");
        val_hitIdx = tds.track_branch_obj<vector<vector<int>>>("trk_hitIdx");
        val_hitType = tds.track_branch_obj<vector<vector<int>>>("trk_hitType");
        val_genIdx = tds.track_branch_obj<vector<int>>("trk_genIdx");
        val_genDR = tds.track_branch_obj<vector<float>>("trk_genDR");
    }

    size_t size() const { return val_px->get_value().size();}

    const Track operator[](size_t) const;
    iter begin() const { return iter(this, 0); }
    iter end() const { return iter(this, size()); }
};

struct Track {
    const TrackCollection* collection;
    const size_t idx;
    Track(const TrackCollection* collection, const size_t idx)
      :collection(collection), idx(idx) { }

    const float& px() const {return collection->val_px->get_value().at(idx);}
    const float& py() const {return collection->val_py->get_value().at(idx);}
    const float& pz() const {return collection->val_pz->get_value().at(idx);}
    const float& pt() const {return collection->val_pt->get_value().at(idx);}
    const float& inner_px() const {return collection->val_inner_px->get_value().at(idx);}
    const float& inner_py() const {return collection->val_inner_py->get_value().at(idx);}
    const float& inner_pz() const {return collection->val_inner_pz->get_value().at(idx);}
    const float& inner_pt() const {return collection->val_inner_pt->get_value().at(idx);}
    const float& outer_px() const {return collection->val_outer_px->get_value().at(idx);}
    const float& outer_py() const {return collection->val_outer_py->get_value().at(idx);}
    const float& outer_pz() const {return collection->val_outer_pz->get_value().at(idx);}
    const float& outer_pt() const {return collection->val_outer_pt->get_value().at(idx);}
    const float& eta() const {return collection->val_eta->get_value().at(idx);}
    const float& lambda() const {return collection->val_lambda->get_value().at(idx);}
    const float& cotTheta() const {return collection->val_cotTheta->get_value().at(idx);}
    const float& phi() const {return collection->val_phi->get_value().at(idx);}
    const float& dxy() const {return collection->val_dxy->get_value().at(idx);}
    const float& dz() const {return collection->val_dz->get_value().at(idx);}
    const float& ptErr() const {return collection->val_ptErr->get_value().at(idx);}
    const float& etaErr() const {return collection->val_etaErr->get_value().at(idx);}
    const float& lambdaErr() const {return collection->val_lambdaErr->get_value().at(idx);}
    const float& phiErr() const {return collection->val_phiErr->get_value().at(idx);}
    const float& dxyErr() const {return collection->val_dxyErr->get_value().at(idx);}
    const float& dzErr() const {return collection->val_dzErr->get_value().at(idx);}
    const float& refpoint_x() const {return collection->val_refpoint_x->get_value().at(idx);}
    const float& refpoint_y() const {return collection->val_refpoint_y->get_value().at(idx);}
    const float& refpoint_z() const {return collection->val_refpoint_z->get_value().at(idx);}
    const float& nChi2() const {return collection->val_nChi2->get_value().at(idx);}
    const int& q() const {return collection->val_q->get_value().at(idx);}
    const unsigned int& nValid() const {return collection->val_nValid->get_value().at(idx);}
    const unsigned int& nInvalid() const {return collection->val_nInvalid->get_value().at(idx);}
    const unsigned int& nPixel() const {return collection->val_nPixel->get_value().at(idx);}
    const unsigned int& nStrip() const {return collection->val_nStrip->get_value().at(idx);}
    const unsigned int& nPixelLay() const {return collection->val_nPixelLay->get_value().at(idx);}
    const unsigned int& nStripLay() const {return collection->val_nStripLay->get_value().at(idx);}
    const unsigned int& n3DLay() const {return collection->val_n3DLay->get_value().at(idx);}
    const unsigned int& nOuterLost() const {return collection->val_nOuterLost->get_value().at(idx);}
    const unsigned int& nInnerLost() const {return collection->val_nInnerLost->get_value().at(idx);}
    const unsigned int& algo() const {return collection->val_algo->get_value().at(idx);}
    const unsigned int& originalAlgo() const {return collection->val_originalAlgo->get_value().at(idx);}
    const ULong64_t& algoMask() const {return collection->val_algoMask->get_value().at(idx);}
    const unsigned int& stopReason() const {return collection->val_stopReason->get_value().at(idx);}
    const short& isHP() const {return collection->val_isHP->get_value().at(idx);}
    const int& seedIdx() const {return collection->val_seedIdx->get_value().at(idx);}
    const float& vtxx() const {return collection->val_vtxx->get_value().at(idx);}
    const float& vtxy() const {return collection->val_vtxy->get_value().at(idx);}
    const float& vtxz() const {return collection->val_vtxz->get_value().at(idx);}
    const vector<float>& shareFrac() const {return collection->val_shareFrac->get_value().at(idx);}
    const vector<int>& simTrkIdx() const {return collection->val_simTrkIdx->get_value().at(idx);}
    const vector<int>& hitIdx() const {return collection->val_hitIdx->get_value().at(idx);}
    const vector<int>& hitType() const {return collection->val_hitType->get_value().at(idx);}
    const int& genIdx() const {return collection->val_genIdx->get_value().at(idx);}
    const float& genDR() const {return collection->val_genDR->get_value().at(idx);}
};

const Track TrackCollection::iter::operator*() const {
    return {collection, idx};
}
const Track TrackCollection::operator[](size_t idx) const {
    return {this, idx};
}
struct SimTrack;

class SimTrackCollection {
  public:
    class iter {
      public:
        iter(const SimTrackCollection* collection, size_t idx)
          :collection(collection), idx(idx) { }
        iter operator++() { ++idx; return *this; }
        bool operator!=(const iter & other) { return idx != other.idx; }
        const SimTrack operator*() const;
      private:
        const SimTrackCollection* collection;
        size_t idx;
    };

    Value<vector<int>>* val_event;
    Value<vector<int>>* val_bunchCrossing;
    Value<vector<int>>* val_pdgId;
    Value<vector<float>>* val_px;
    Value<vector<float>>* val_py;
    Value<vector<float>>* val_pz;
    Value<vector<float>>* val_pt;
    Value<vector<float>>* val_eta;
    Value<vector<float>>* val_phi;
    Value<vector<float>>* val_pca_pt;
    Value<vector<float>>* val_pca_eta;
    Value<vector<float>>* val_pca_lambda;
    Value<vector<float>>* val_pca_cotTheta;
    Value<vector<float>>* val_pca_phi;
    Value<vector<float>>* val_pca_dxy;
    Value<vector<float>>* val_pca_dz;
    Value<vector<int>>* val_q;
    Value<vector<unsigned int>>* val_nValid;
    Value<vector<unsigned int>>* val_nPixel;
    Value<vector<unsigned int>>* val_nStrip;
    Value<vector<unsigned int>>* val_nLay;
    Value<vector<unsigned int>>* val_nPixelLay;
    Value<vector<unsigned int>>* val_n3DLay;
    Value<vector<vector<int>>>* val_trkIdx;
    Value<vector<vector<float>>>* val_shareFrac;
    Value<vector<int>>* val_parentVtxIdx;
    Value<vector<vector<int>>>* val_decayVtxIdx;
    Value<vector<vector<int>>>* val_simHitIdx;
    Value<vector<vector<int>>>* val_seedIdx;

    SimTrackCollection() { }

    void init(TrackingDataSet& tds){
        val_event = tds.track_branch_obj<vector<int>>("sim_event");
        val_bunchCrossing = tds.track_branch_obj<vector<int>>("sim_bunchCrossing");
        val_pdgId = tds.track_branch_obj<vector<int>>("sim_pdgId");
        val_px = tds.track_branch_obj<vector<float>>("sim_px");
        val_py = tds.track_branch_obj<vector<float>>("sim_py");
        val_pz = tds.track_branch_obj<vector<float>>("sim_pz");
        val_pt = tds.track_branch_obj<vector<float>>("sim_pt");
        val_eta = tds.track_branch_obj<vector<float>>("sim_eta");
        val_phi = tds.track_branch_obj<vector<float>>("sim_phi");
        val_pca_pt = tds.track_branch_obj<vector<float>>("sim_pca_pt");
        val_pca_eta = tds.track_branch_obj<vector<float>>("sim_pca_eta");
        val_pca_lambda = tds.track_branch_obj<vector<float>>("sim_pca_lambda");
        val_pca_cotTheta = tds.track_branch_obj<vector<float>>("sim_pca_cotTheta");
        val_pca_phi = tds.track_branch_obj<vector<float>>("sim_pca_phi");
        val_pca_dxy = tds.track_branch_obj<vector<float>>("sim_pca_dxy");
        val_pca_dz = tds.track_branch_obj<vector<float>>("sim_pca_dz");
        val_q = tds.track_branch_obj<vector<int>>("sim_q");
        val_nValid = tds.track_branch_obj<vector<unsigned int>>("sim_nValid");
        val_nPixel = tds.track_branch_obj<vector<unsigned int>>("sim_nPixel");
        val_nStrip = tds.track_branch_obj<vector<unsigned int>>("sim_nStrip");
        val_nLay = tds.track_branch_obj<vector<unsigned int>>("sim_nLay");
        val_nPixelLay = tds.track_branch_obj<vector<unsigned int>>("sim_nPixelLay");
        val_n3DLay = tds.track_branch_obj<vector<unsigned int>>("sim_n3DLay");
        val_trkIdx = tds.track_branch_obj<vector<vector<int>>>("sim_trkIdx");
        val_shareFrac = tds.track_branch_obj<vector<vector<float>>>("sim_shareFrac");
        val_parentVtxIdx = tds.track_branch_obj<vector<int>>("sim_parentVtxIdx");
        val_decayVtxIdx = tds.track_branch_obj<vector<vector<int>>>("sim_decayVtxIdx");
        val_simHitIdx = tds.track_branch_obj<vector<vector<int>>>("sim_simHitIdx");
        val_seedIdx = tds.track_branch_obj<vector<vector<int>>>("sim_seedIdx");
    }

    size_t size() const { return val_event->get_value().size();}

    const SimTrack operator[](size_t) const;
    iter begin() const { return iter(this, 0); }
    iter end() const { return iter(this, size()); }
};

struct SimTrack {
    const SimTrackCollection* collection;
    const size_t idx;
    SimTrack(const SimTrackCollection* collection, const size_t idx)
      :collection(collection), idx(idx) { }

    const int& event() const {return collection->val_event->get_value().at(idx);}
    const int& bunchCrossing() const {return collection->val_bunchCrossing->get_value().at(idx);}
    const int& pdgId() const {return collection->val_pdgId->get_value().at(idx);}
    const float& px() const {return collection->val_px->get_value().at(idx);}
    const float& py() const {return collection->val_py->get_value().at(idx);}
    const float& pz() const {return collection->val_pz->get_value().at(idx);}
    const float& pt() const {return collection->val_pt->get_value().at(idx);}
    const float& eta() const {return collection->val_eta->get_value().at(idx);}
    const float& phi() const {return collection->val_phi->get_value().at(idx);}
    const float& pca_pt() const {return collection->val_pca_pt->get_value().at(idx);}
    const float& pca_eta() const {return collection->val_pca_eta->get_value().at(idx);}
    const float& pca_lambda() const {return collection->val_pca_lambda->get_value().at(idx);}
    const float& pca_cotTheta() const {return collection->val_pca_cotTheta->get_value().at(idx);}
    const float& pca_phi() const {return collection->val_pca_phi->get_value().at(idx);}
    const float& pca_dxy() const {return collection->val_pca_dxy->get_value().at(idx);}
    const float& pca_dz() const {return collection->val_pca_dz->get_value().at(idx);}
    const int& q() const {return collection->val_q->get_value().at(idx);}
    const unsigned int& nValid() const {return collection->val_nValid->get_value().at(idx);}
    const unsigned int& nPixel() const {return collection->val_nPixel->get_value().at(idx);}
    const unsigned int& nStrip() const {return collection->val_nStrip->get_value().at(idx);}
    const unsigned int& nLay() const {return collection->val_nLay->get_value().at(idx);}
    const unsigned int& nPixelLay() const {return collection->val_nPixelLay->get_value().at(idx);}
    const unsigned int& n3DLay() const {return collection->val_n3DLay->get_value().at(idx);}
    const vector<int>& trkIdx() const {return collection->val_trkIdx->get_value().at(idx);}
    const vector<float>& shareFrac() const {return collection->val_shareFrac->get_value().at(idx);}
    const int& parentVtxIdx() const {return collection->val_parentVtxIdx->get_value().at(idx);}
    const vector<int>& decayVtxIdx() const {return collection->val_decayVtxIdx->get_value().at(idx);}
    const vector<int>& simHitIdx() const {return collection->val_simHitIdx->get_value().at(idx);}
    const vector<int>& seedIdx() const {return collection->val_seedIdx->get_value().at(idx);}
};

const SimTrack SimTrackCollection::iter::operator*() const {
    return {collection, idx};
}
const SimTrack SimTrackCollection::operator[](size_t idx) const {
    return {this, idx};
}
struct SuperCluster;

class SuperClusterCollection {
  public:
    class iter {
      public:
        iter(const SuperClusterCollection* collection, size_t idx)
          :collection(collection), idx(idx) { }
        iter operator++() { ++idx; return *this; }
        bool operator!=(const iter & other) { return idx != other.idx; }
        const SuperCluster operator*() const;
      private:
        const SuperClusterCollection* collection;
        size_t idx;
    };

    Value<vector<float>>* val_e;
    Value<vector<float>>* val_px;
    Value<vector<float>>* val_py;
    Value<vector<float>>* val_pz;
    Value<vector<float>>* val_x;
    Value<vector<float>>* val_y;
    Value<vector<float>>* val_z;
    Value<vector<vector<int>>>* val_charge;
    Value<vector<vector<int>>>* val_subDet1;
    Value<vector<vector<int>>>* val_subDet2;
    Value<vector<vector<float>>>* val_dRz1;
    Value<vector<vector<float>>>* val_dPhi1;
    Value<vector<vector<float>>>* val_dRz2;
    Value<vector<vector<float>>>* val_dPhi2;
    Value<vector<vector<int>>>* val_seedType;
    Value<vector<vector<unsigned char>>>* val_hitsMask;

    SuperClusterCollection() { }

    void init(TrackingDataSet& tds){
        val_e = tds.track_branch_obj<vector<float>>("scl_e");
        val_px = tds.track_branch_obj<vector<float>>("scl_px");
        val_py = tds.track_branch_obj<vector<float>>("scl_py");
        val_pz = tds.track_branch_obj<vector<float>>("scl_pz");
        val_x = tds.track_branch_obj<vector<float>>("scl_x");
        val_y = tds.track_branch_obj<vector<float>>("scl_y");
        val_z = tds.track_branch_obj<vector<float>>("scl_z");
        val_charge = tds.track_branch_obj<vector<vector<int>>>("scl_charge");
        val_subDet1 = tds.track_branch_obj<vector<vector<int>>>("scl_subDet1");
        val_subDet2 = tds.track_branch_obj<vector<vector<int>>>("scl_subDet2");
        val_dRz1 = tds.track_branch_obj<vector<vector<float>>>("scl_dRz1");
        val_dPhi1 = tds.track_branch_obj<vector<vector<float>>>("scl_dPhi1");
        val_dRz2 = tds.track_branch_obj<vector<vector<float>>>("scl_dRz2");
        val_dPhi2 = tds.track_branch_obj<vector<vector<float>>>("scl_dPhi2");
        val_seedType = tds.track_branch_obj<vector<vector<int>>>("scl_seedType");
        val_hitsMask = tds.track_branch_obj<vector<vector<unsigned char>>>("scl_hitsMask");
    }

    size_t size() const { return val_e->get_value().size();}

    const SuperCluster operator[](size_t) const;
    iter begin() const { return iter(this, 0); }
    iter end() const { return iter(this, size()); }
};

struct SuperCluster {
    const SuperClusterCollection* collection;
    const size_t idx;
    SuperCluster(const SuperClusterCollection* collection, const size_t idx)
      :collection(collection), idx(idx) { }

    const float& e() const {return collection->val_e->get_value().at(idx);}
    const float& px() const {return collection->val_px->get_value().at(idx);}
    const float& py() const {return collection->val_py->get_value().at(idx);}
    const float& pz() const {return collection->val_pz->get_value().at(idx);}
    const float& x() const {return collection->val_x->get_value().at(idx);}
    const float& y() const {return collection->val_y->get_value().at(idx);}
    const float& z() const {return collection->val_z->get_value().at(idx);}
    const vector<int>& charge() const {return collection->val_charge->get_value().at(idx);}
    const vector<int>& subDet1() const {return collection->val_subDet1->get_value().at(idx);}
    const vector<int>& subDet2() const {return collection->val_subDet2->get_value().at(idx);}
    const vector<float>& dRz1() const {return collection->val_dRz1->get_value().at(idx);}
    const vector<float>& dPhi1() const {return collection->val_dPhi1->get_value().at(idx);}
    const vector<float>& dRz2() const {return collection->val_dRz2->get_value().at(idx);}
    const vector<float>& dPhi2() const {return collection->val_dPhi2->get_value().at(idx);}
    const vector<int>& seedType() const {return collection->val_seedType->get_value().at(idx);}
    const vector<unsigned char>& hitsMask() const {return collection->val_hitsMask->get_value().at(idx);}
};

const SuperCluster SuperClusterCollection::iter::operator*() const {
    return {collection, idx};
}
const SuperCluster SuperClusterCollection::operator[](size_t idx) const {
    return {this, idx};
}
struct SimVertex;

class SimVertexCollection {
  public:
    class iter {
      public:
        iter(const SimVertexCollection* collection, size_t idx)
          :collection(collection), idx(idx) { }
        iter operator++() { ++idx; return *this; }
        bool operator!=(const iter & other) { return idx != other.idx; }
        const SimVertex operator*() const;
      private:
        const SimVertexCollection* collection;
        size_t idx;
    };

    Value<vector<int>>* val_event;
    Value<vector<int>>* val_bunchCrossing;
    Value<vector<unsigned int>>* val_processType;
    Value<vector<float>>* val_x;
    Value<vector<float>>* val_y;
    Value<vector<float>>* val_z;
    Value<vector<vector<int>>>* val_sourceSimIdx;
    Value<vector<vector<int>>>* val_daughterSimIdx;

    SimVertexCollection() { }

    void init(TrackingDataSet& tds){
        val_event = tds.track_branch_obj<vector<int>>("simvtx_event");
        val_bunchCrossing = tds.track_branch_obj<vector<int>>("simvtx_bunchCrossing");
        val_processType = tds.track_branch_obj<vector<unsigned int>>("simvtx_processType");
        val_x = tds.track_branch_obj<vector<float>>("simvtx_x");
        val_y = tds.track_branch_obj<vector<float>>("simvtx_y");
        val_z = tds.track_branch_obj<vector<float>>("simvtx_z");
        val_sourceSimIdx = tds.track_branch_obj<vector<vector<int>>>("simvtx_sourceSimIdx");
        val_daughterSimIdx = tds.track_branch_obj<vector<vector<int>>>("simvtx_daughterSimIdx");
    }

    size_t size() const { return val_event->get_value().size();}

    const SimVertex operator[](size_t) const;
    iter begin() const { return iter(this, 0); }
    iter end() const { return iter(this, size()); }
};

struct SimVertex {
    const SimVertexCollection* collection;
    const size_t idx;
    SimVertex(const SimVertexCollection* collection, const size_t idx)
      :collection(collection), idx(idx) { }

    const int& event() const {return collection->val_event->get_value().at(idx);}
    const int& bunchCrossing() const {return collection->val_bunchCrossing->get_value().at(idx);}
    const unsigned int& processType() const {return collection->val_processType->get_value().at(idx);}
    const float& x() const {return collection->val_x->get_value().at(idx);}
    const float& y() const {return collection->val_y->get_value().at(idx);}
    const float& z() const {return collection->val_z->get_value().at(idx);}
    const vector<int>& sourceSimIdx() const {return collection->val_sourceSimIdx->get_value().at(idx);}
    const vector<int>& daughterSimIdx() const {return collection->val_daughterSimIdx->get_value().at(idx);}
};

const SimVertex SimVertexCollection::iter::operator*() const {
    return {collection, idx};
}
const SimVertex SimVertexCollection::operator[](size_t idx) const {
    return {this, idx};
}