SRProxy.h

Go to the documentation of this file.

// This file was auto-generated by SRProxy's gen_srproxy.
// DO NOT EDIT IT DIRECTLY.

#pragma once

#include "TVector3.h"

#include "StandardRecord/SREnums.h"

#include "SRProxy/BasicTypesProxy.h"

#include "StandardRecord/Proxy/FwdDeclare.h"


/// Proxy for \ref caf::SRSLidEnergy
template<> class caf::Proxy<caf::SRSLidEnergy>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRSLidEnergy& x);

  void CheckEquals(const caf::SRSLidEnergy& sr) const;

  caf::Proxy<float> E;
  caf::Proxy<float> depE;
  caf::Proxy<float> hadE;
  caf::Proxy<float> shwE;
};

/// Proxy for \ref caf::SRNueEnergy
template<> class caf::Proxy<caf::SRNueEnergy>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRNueEnergy& x);

  void CheckEquals(const caf::SRNueEnergy& sr) const;

  caf::Proxy<caf::SRSLidEnergy> lid;
  caf::Proxy<float> rawgevhad;
  caf::Proxy<float> rawgevshw;
  caf::Proxy<float> rawgevslice;
  caf::Proxy<float> regcvnEvtE;
  caf::Proxy<float> regcvnEvtE_opphorn;
};

/// Proxy for \ref caf::SRBPFEnergy
template<> class caf::Proxy<caf::SRBPFEnergy>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRBPFEnergy& x);

  void CheckEquals(const caf::SRBPFEnergy& sr) const;

  caf::Proxy<float> DirZMuon;
  caf::Proxy<float> E1;
  caf::Proxy<float> E2;
  caf::Proxy<float> E3;
  caf::Proxy<float> EFuzzyK3D;
  caf::Proxy<float> ERemain;
  caf::Proxy<float> Eres1;
  caf::Proxy<float> Eres2;
  caf::Proxy<float> Eres3;
  caf::Proxy<float> EventID;
  caf::Proxy<float> N3DProngs;
  caf::Proxy<float> PMuon;
  caf::Proxy<float> SumPE;
};

/// Proxy for \ref caf::SRVector3D
template<> class caf::Proxy<caf::SRVector3D>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRVector3D& x);

  void CheckEquals(const caf::SRVector3D& sr) const;

  // Extra utility functions from SRVector3DAddons.h

  float X() const {return x;}
  float Y() const {return y;}
  float Z() const {return z;}

  operator TVector3() const {return TVector3(x, y, z);}

  float Mag2() const {return x*x+y*y+z*z;}
  float Mag() const {return sqrt(Mag2());}
  float Dot(const Proxy& v) const {return x*v.x + y*v.y + z*v.z;}
  float Dot(const TVector3& v) const {return x*v.X() + y*v.Y() + z*v.Z();}
  TVector3 Unit() const
  {
    const float m = Mag();
    return TVector3(x/m, y/m, z/m);
  }

  caf::Proxy<float> x;
  caf::Proxy<float> y;
  caf::Proxy<float> z;
};

/// Proxy for \ref caf::SRHadClust
template<> class caf::Proxy<caf::SRHadClust>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRHadClust& x);

  void CheckEquals(const caf::SRHadClust& sr) const;

  caf::Proxy<caf::SRVector3D> boxmax;
  caf::Proxy<caf::SRVector3D> boxmin;
  caf::Proxy<float> calE;
  caf::Proxy<unsigned int> firstcell;
  caf::Proxy<unsigned int> firstplane;
  caf::Proxy<unsigned int> lastcell;
  caf::Proxy<unsigned int> lastplane;
  caf::Proxy<caf::SRVector3D> meanpos;
  caf::Proxy<unsigned int> ncalhit;
  caf::Proxy<unsigned int> ncellsfromedge;
  caf::Proxy<unsigned int> ncontplanes;
  caf::Proxy<unsigned int> nhit;
  caf::Proxy<unsigned int> nmiphit;
};

/// Proxy for \ref caf::SRTrueNumuEnergy
template<> class caf::Proxy<caf::SRTrueNumuEnergy>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRTrueNumuEnergy& x);

  void CheckEquals(const caf::SRTrueNumuEnergy& sr) const;

  caf::Proxy<bool> truegoodmuon;
  caf::Proxy<float> truemuonE;
  caf::Proxy<float> truemuoncatcherE;
};

/// Proxy for \ref caf::SRNumuEnergy
template<> class caf::Proxy<caf::SRNumuEnergy>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRNumuEnergy& x);

  void CheckEquals(const caf::SRNumuEnergy& sr) const;

  caf::Proxy<float> E;
  caf::Proxy<float> angleE;
  caf::Proxy<float> angleerror;
  caf::Proxy<caf::SRBPFEnergy> bpfenergy;
  caf::Proxy<float> calccE;
  caf::Proxy<float> hadcalE;
  caf::Proxy<caf::SRHadClust> hadclust;
  caf::Proxy<float> hadtrkE;
  caf::Proxy<float> lstmmuon;
  caf::Proxy<float> lstmmuon_opphorn;
  caf::Proxy<float> lstmnu;
  caf::Proxy<float> lstmnu_opphorn;
  caf::Proxy<caf::SRTrueNumuEnergy> mc;
  caf::Proxy<float> ndhadcalactE;
  caf::Proxy<float> ndhadcalcatE;
  caf::Proxy<float> ndhadcaltranE;
  caf::Proxy<float> ndhadtrkactE;
  caf::Proxy<float> ndhadtrkcatE;
  caf::Proxy<float> ndhadtrktranE;
  caf::Proxy<float> ndtrkcalactE;
  caf::Proxy<float> ndtrkcalcatE;
  caf::Proxy<float> ndtrkcaltranE;
  caf::Proxy<float> ndtrklenact;
  caf::Proxy<float> ndtrklencat;
  caf::Proxy<float> ndtrktranx;
  caf::Proxy<float> ndtrktrany;
  caf::Proxy<float> recomuonE;
  caf::Proxy<float> recotrkcchadE;
  caf::Proxy<float> regcvnhadE;
  caf::Proxy<float> regcvnhadE_opphorn;
  caf::Proxy<float> shiftedtrkccE;
  caf::Proxy<float> trkccE;
  caf::Proxy<float> trknonqeE;
  caf::Proxy<float> trkqeE;
  caf::Proxy<float> ucrecomuonE;
  caf::Proxy<float> ucrecomuonE1trk;
};

/// Proxy for \ref caf::SREnergyBranch
template<> class caf::Proxy<caf::SREnergyBranch>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SREnergyBranch& x);

  void CheckEquals(const caf::SREnergyBranch& sr) const;

  caf::Proxy<caf::SRNueEnergy> nue;
  caf::Proxy<caf::SRNumuEnergy> numu;
};

/// Proxy for \ref caf::SRHeader
template<> class caf::Proxy<caf::SRHeader>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRHeader& x);

  void CheckEquals(const caf::SRHeader& sr) const;

  caf::Proxy<int> batch;
  caf::Proxy<bool> blind;
  caf::Proxy<int> cycle;
  caf::Proxy<short unsigned int> day;
  caf::Proxy<caf::Det_t> det;
  caf::Proxy<short unsigned int> dibfirst;
  caf::Proxy<short unsigned int> diblast;
  caf::Proxy<short unsigned int> dibmask;
  caf::Proxy<short unsigned int> doy;
  caf::Proxy<unsigned int> evt;
  caf::Proxy<bool> filt;
  caf::Proxy<bool> finetiming;
  caf::Proxy<short unsigned int> gain;
  caf::Proxy<short unsigned int> hour;
  caf::Proxy<bool> ismc;
  caf::Proxy<short unsigned int> maskstatus;
  caf::Proxy<short unsigned int> minute;
  caf::Proxy<short unsigned int> month;
  caf::Proxy<unsigned int> nbadchan;
  caf::Proxy<unsigned int> ntotchan;
  caf::Proxy<unsigned int> run;
  caf::Proxy<short unsigned int> second;
  caf::Proxy<short unsigned int> subevt;
  caf::Proxy<float> subevtendtime;
  caf::Proxy<float> subevtmeantime;
  caf::Proxy<float> subevtstarttime;
  caf::Proxy<unsigned int> subrun;
  caf::Proxy<float> unixtime;
  caf::Proxy<short unsigned int> year;
};

/// Proxy for \ref caf::SRLorentzVector
template<> class caf::Proxy<caf::SRLorentzVector>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRLorentzVector& x);

  void CheckEquals(const caf::SRLorentzVector& sr) const;

  // Extra utility functions from SRLorentzVectorAddons.h

  // For access as a position vector. For momentum use the member variables
  // directly.
  float T() const {return E;}
  float X() const {return px;}
  float Y() const {return py;}
  float Z() const {return pz;}
  float Mag() const {return sqrt(px*px + py*py + pz*pz);}
  float Beta() const {return Mag()/E;}
  float Gamma() const {return 1/sqrt(1-Beta()*Beta());}

  TVector3 Vect() const {return TVector3(px, py, pz);}

  caf::Proxy<float> E;
  caf::Proxy<float> px;
  caf::Proxy<float> py;
  caf::Proxy<float> pz;
};

/// Proxy for \ref caf::SRTrueMichelE
template<> class caf::Proxy<caf::SRTrueMichelE>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRTrueMichelE& x);

  void CheckEquals(const caf::SRTrueMichelE& sr) const;

  caf::Proxy<float> E;
  caf::Proxy<caf::SRLorentzVector> mustop;
  caf::Proxy<caf::SRLorentzVector> p;
  caf::Proxy<float> time;
  caf::Proxy<float> visE;
};

/// Proxy for \ref caf::SRCosmic
template<> class caf::Proxy<caf::SRCosmic>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRCosmic& x);

  void CheckEquals(const caf::SRCosmic& sr) const;

  caf::Proxy<float> E;
  caf::Proxy<float> azimuth;
  caf::Proxy<float> eff;
  caf::Proxy<caf::SRVector3D> enter;
  caf::Proxy<caf::SRVector3D> exit;
  caf::Proxy<std::vector<caf::SRTrueMichelE>> michel;
  caf::Proxy<unsigned int> nhitslc;
  caf::Proxy<unsigned int> nhittot;
  caf::Proxy<caf::SRLorentzVector> p;
  caf::Proxy<short int> pdg;
  caf::Proxy<caf::SRLorentzVector> penter;
  caf::Proxy<float> pur;
  caf::Proxy<caf::SRVector3D> stop;
  caf::Proxy<float> time;
  caf::Proxy<float> visE;
  caf::Proxy<float> visEinslc;
  caf::Proxy<caf::SRVector3D> vtx;
  caf::Proxy<float> zenith;
};

/// Proxy for \ref caf::SRBeam
template<> class caf::Proxy<caf::SRBeam>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRBeam& x);

  void CheckEquals(const caf::SRBeam& sr) const;

  caf::Proxy<float> dk2gen;
  caf::Proxy<float> dk2vtx;
  caf::Proxy<float> gen2vtx;
  caf::Proxy<float> mupare;
  caf::Proxy<caf::SRVector3D> muparp;
  caf::Proxy<int> ndecay;
  caf::Proxy<float> necm;
  caf::Proxy<float> nimpwt;
  caf::Proxy<caf::SRVector3D> pdp;
  caf::Proxy<int> potnum;
  caf::Proxy<float> ppdxdz;
  caf::Proxy<float> ppdydz;
  caf::Proxy<float> ppenergy;
  caf::Proxy<int> ppmedium;
  caf::Proxy<float> pppz;
  caf::Proxy<caf::SRVector3D> ppv;
  caf::Proxy<int> ptype;
  caf::Proxy<float> runjob;
  caf::Proxy<int> tgen;
  caf::Proxy<int> tgptype;
  caf::Proxy<caf::SRVector3D> tp;
  caf::Proxy<int> tptype;
  caf::Proxy<caf::SRVector3D> tv;
  caf::Proxy<caf::SRVector3D> v;
};

/// Proxy for \ref caf::SRNuGenParticle
template<> class caf::Proxy<caf::SRNuGenParticle>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRNuGenParticle& x);

  void CheckEquals(const caf::SRNuGenParticle& sr) const;

  caf::Proxy<caf::SRLorentzVector> p;
  caf::Proxy<short int> pdg;
  caf::Proxy<std::vector<unsigned int>> primList;
  caf::Proxy<int> status;
};

/// Proxy for \ref caf::SRTrueParticle
template<> class caf::Proxy<caf::SRTrueParticle>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRTrueParticle& x);

  void CheckEquals(const caf::SRTrueParticle& sr) const;

  caf::Proxy<std::vector<float>> daughterEnergies;
  caf::Proxy<float> daughterVisE;
  caf::Proxy<float> daughterVisEBirks;
  caf::Proxy<float> daughterVisEinslc;
  caf::Proxy<float> daughterVisEinslcBirks;
  caf::Proxy<std::vector<int>> daughterlist;
  caf::Proxy<float> elasticProtonMaxVisE;
  caf::Proxy<float> elasticProtonMaxVisEinslc;
  caf::Proxy<float> elasticProtonSumVisE;
  caf::Proxy<float> elasticProtonSumVisEinslc;
  caf::Proxy<float> enteringE;
  caf::Proxy<float> inelasticPhotonMaxVisE;
  caf::Proxy<float> inelasticPhotonMaxVisEinslc;
  caf::Proxy<float> inelasticPhotonSumVisE;
  caf::Proxy<float> inelasticPhotonSumVisEinslc;
  caf::Proxy<float> inelasticProtonMaxVisE;
  caf::Proxy<float> inelasticProtonMaxVisEinslc;
  caf::Proxy<float> inelasticProtonSumVisE;
  caf::Proxy<float> inelasticProtonSumVisEinslc;
  caf::Proxy<float> maxElasticProtonTrueE;
  caf::Proxy<float> maxInelasticPhotonTrueE;
  caf::Proxy<float> maxInelasticProtonTrueE;
  caf::Proxy<caf::SRLorentzVector> p;
  caf::Proxy<int> pdg;
  caf::Proxy<int> prefsiID;
  caf::Proxy<float> time;
  caf::Proxy<float> totEscE;
  caf::Proxy<int> trkID;
  caf::Proxy<float> visE;
  caf::Proxy<float> visEBirks;
  caf::Proxy<float> visEinslc;
  caf::Proxy<float> visEinslcBirks;
};

/// Proxy for \ref caf::SRGeant4Weights
template<> class caf::Proxy<caf::SRGeant4Weights>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRGeant4Weights& x);

  void CheckEquals(const caf::SRGeant4Weights& sr) const;

  caf::Proxy<unsigned int> npiminus_univ;
  caf::Proxy<unsigned int> npiplus_univ;
  caf::Proxy<unsigned int> nproton_univ;
  caf::Proxy<float> piminus_cv;
  caf::Proxy<std::vector<float>> piminus_univ;
  caf::Proxy<float> piplus_cv;
  caf::Proxy<std::vector<float>> piplus_univ;
  caf::Proxy<float> proton_cv;
  caf::Proxy<std::vector<float>> proton_univ;
};

/// Proxy for \ref caf::SRGenieWeights
template<> class caf::Proxy<caf::SRGenieWeights>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRGenieWeights& x);

  void CheckEquals(const caf::SRGenieWeights& sr) const;

  caf::Proxy<float> minus1sigma;
  caf::Proxy<float> minus2sigma;
  caf::Proxy<float> plus1sigma;
  caf::Proxy<float> plus2sigma;
};

/// Proxy for \ref caf::SRFluxWeights
template<> class caf::Proxy<caf::SRFluxWeights>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRFluxWeights& x);

  void CheckEquals(const caf::SRFluxWeights& sr) const;

  caf::Proxy<float> cv;
  caf::Proxy<unsigned int> nvuniv;
  caf::Proxy<std::vector<float>> vuniv;
};

/// Proxy for \ref caf::SRMCReweight
template<> class caf::Proxy<caf::SRMCReweight>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRMCReweight& x);

  void CheckEquals(const caf::SRMCReweight& sr) const;

  caf::Proxy<caf::SRGeant4Weights> geant4;
  caf::Proxy<std::vector<caf::SRGenieWeights>> genie;
  caf::Proxy<caf::SRFluxWeights> ppfx;
};

/// Proxy for \ref caf::SRNeutrino
template<> class caf::Proxy<caf::SRNeutrino>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRNeutrino& x);

  void CheckEquals(const caf::SRNeutrino& sr) const;

  caf::Proxy<float> E;
  caf::Proxy<float> L;
  caf::Proxy<float> W2;
  caf::Proxy<caf::SRBeam> beam;
  caf::Proxy<int> cycle;
  caf::Proxy<caf::Det_t> det;
  caf::Proxy<float> eff;
  caf::Proxy<unsigned int> evt;
  caf::Proxy<std::string> genConfigString;
  caf::Proxy<std::vector<unsigned int>> genVersion;
  caf::Proxy<caf::generator_> generator;
  caf::Proxy<float> genweight;
  caf::Proxy<int> hitnuc;
  caf::Proxy<caf::SRLorentzVector> hitnucp;
  caf::Proxy<int> inttype;
  caf::Proxy<bool> is0HC;
  caf::Proxy<bool> isFHC;
  caf::Proxy<bool> isRHC;
  caf::Proxy<bool> iscc;
  caf::Proxy<bool> ischarm;
  caf::Proxy<bool> isseaquark;
  caf::Proxy<bool> isvtxcont;
  caf::Proxy<std::vector<caf::SRTrueMichelE>> michel;
  caf::Proxy<int> mode;
  caf::Proxy<unsigned int> nhitslc;
  caf::Proxy<unsigned int> nhittot;
  caf::Proxy<unsigned int> nneutron;
  caf::Proxy<unsigned int> npiminus;
  caf::Proxy<unsigned int> npiplus;
  caf::Proxy<unsigned int> npizero;
  caf::Proxy<unsigned int> nproton;
  caf::Proxy<caf::SRLorentzVector> p;
  caf::Proxy<short int> pdg;
  caf::Proxy<short int> pdgorig;
  caf::Proxy<std::vector<caf::SRNuGenParticle>> prefsi;
  caf::Proxy<std::vector<caf::SRTrueParticle>> prim;
  caf::Proxy<float> pur;
  caf::Proxy<float> q2;
  caf::Proxy<int> resnum;
  caf::Proxy<unsigned int> run;
  caf::Proxy<caf::SRMCReweight> rwgt;
  caf::Proxy<unsigned int> subrun;
  caf::Proxy<int> tgtA;
  caf::Proxy<int> tgtZ;
  caf::Proxy<float> time;
  caf::Proxy<float> visE;
  caf::Proxy<float> visEBirks;
  caf::Proxy<float> visENeutron;
  caf::Proxy<float> visENeutronBirks;
  caf::Proxy<float> visEinslc;
  caf::Proxy<float> visEinslcBirks;
  caf::Proxy<float> visEinslcNeutron;
  caf::Proxy<float> visEinslcNeutronBirks;
  caf::Proxy<caf::SRVector3D> vtx;
  caf::Proxy<float> woscdumb;
  caf::Proxy<float> x;
  caf::Proxy<float> xsec;
  caf::Proxy<float> y;
};

/// Proxy for \ref caf::SRGlobalTruth
template<> class caf::Proxy<caf::SRGlobalTruth>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRGlobalTruth& x);

  void CheckEquals(const caf::SRGlobalTruth& sr) const;

  caf::Proxy<unsigned int> nnu;
};

/// Proxy for \ref caf::SRTruthBranch
template<> class caf::Proxy<caf::SRTruthBranch>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRTruthBranch& x);

  void CheckEquals(const caf::SRTruthBranch& sr) const;

  caf::Proxy<std::vector<caf::SRCosmic>> allcosmics;
  caf::Proxy<std::vector<caf::SRNeutrino>> allnus;
  caf::Proxy<std::vector<caf::SRCosmic>> cosmic;
  caf::Proxy<short int> faveidxeff;
  caf::Proxy<short int> faveidxeffpur;
  caf::Proxy<short int> faveidxeffthenpur;
  caf::Proxy<short int> faveidxenergy;
  caf::Proxy<short int> faveidxpur;
  caf::Proxy<caf::SRGlobalTruth> global;
  caf::Proxy<short int> nallcosmics;
  caf::Proxy<short int> nallnus;
  caf::Proxy<short int> ncosmic;
  caf::Proxy<short int> nnu;
  caf::Proxy<std::vector<caf::SRNeutrino>> nu;
};

/// Proxy for \ref caf::SRParticleTruth
template<> class caf::Proxy<caf::SRParticleTruth>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRParticleTruth& x);

  void CheckEquals(const caf::SRParticleTruth& sr) const;

  caf::Proxy<float> daughterVisE;
  caf::Proxy<float> daughterVisEBirks;
  caf::Proxy<float> daughterVisEinslc;
  caf::Proxy<float> daughterVisEinslcBirks;
  caf::Proxy<std::vector<float>> daughterVisEnergies;
  caf::Proxy<std::vector<int>> daughterlist;
  caf::Proxy<float> eff;
  caf::Proxy<std::vector<int>> motherlist;
  caf::Proxy<caf::SRLorentzVector> motherp;
  caf::Proxy<int> motherpdg;
  caf::Proxy<caf::SRLorentzVector> p;
  caf::Proxy<int> pdg;
  caf::Proxy<std::vector<float>> primNeutronE;
  caf::Proxy<std::vector<float>> primNeutronProcessE;
  caf::Proxy<caf::gen_process_t> processMax;
  caf::Proxy<float> processParticleE;
  caf::Proxy<float> pur;
  caf::Proxy<caf::SRVector3D> start;
  caf::Proxy<int> trkID;
  caf::Proxy<float> visE;
  caf::Proxy<float> visEBirks;
  caf::Proxy<float> visEinslc;
  caf::Proxy<float> visEinslcBirks;
};

/// Proxy for \ref caf::SRSlcME
template<> class caf::Proxy<caf::SRSlcME>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRSlcME& x);

  void CheckEquals(const caf::SRSlcME& sr) const;

  caf::Proxy<float> adc;
  caf::Proxy<float> calE;
  caf::Proxy<float> deltat;
  caf::Proxy<float> disttoslc;
  caf::Proxy<caf::SRVector3D> meanpos;
  caf::Proxy<float> mid;
  caf::Proxy<short unsigned int> nhitx;
  caf::Proxy<short unsigned int> nhity;
  caf::Proxy<caf::SRParticleTruth> truth;
};

/// Proxy for \ref caf::SRTrkME
template<> class caf::Proxy<caf::SRTrkME>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRTrkME& x);

  void CheckEquals(const caf::SRTrkME& sr) const;

  caf::Proxy<float> adc;
  caf::Proxy<float> calE;
  caf::Proxy<float> deltat;
  caf::Proxy<float> disttotrack;
  caf::Proxy<caf::SRVector3D> meanpos;
  caf::Proxy<float> mid;
  caf::Proxy<short unsigned int> nhitx;
  caf::Proxy<short unsigned int> nhity;
  caf::Proxy<caf::SRParticleTruth> truth;
};

/// Proxy for \ref caf::SRMichelE
template<> class caf::Proxy<caf::SRMichelE>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRMichelE& x);

  void CheckEquals(const caf::SRMichelE& sr) const;

  caf::Proxy<size_t> nbpf;
  caf::Proxy<size_t> ncosmic;
  caf::Proxy<size_t> ndiscrete;
  caf::Proxy<size_t> nkalman;
  caf::Proxy<size_t> nslc;
  caf::Proxy<std::vector<caf::SRSlcME>> slc;
  caf::Proxy<std::vector<caf::SRTrkME>> trkbpf;
  caf::Proxy<std::vector<caf::SRTrkME>> trkcosmic;
  caf::Proxy<std::vector<caf::SRTrkME>> trkdiscrete;
  caf::Proxy<std::vector<caf::SRTrkME>> trkkalman;
};

/// Proxy for \ref caf::SRMRCCParent
template<> class caf::Proxy<caf::SRMRCCParent>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRMRCCParent& x);

  void CheckEquals(const caf::SRMRCCParent& sr) const;

  caf::Proxy<int> contplanes;
  caf::Proxy<float> cvnm;
  caf::Proxy<float> eff;
  caf::Proxy<int> firstplane;
  caf::Proxy<float> hadEinmucat;
  caf::Proxy<int> lastplane;
  caf::Proxy<float> muE;
  caf::Proxy<int> muonbkcell;
  caf::Proxy<int> muonfwdcell;
  caf::Proxy<caf::SRVector3D> muonstart;
  caf::Proxy<caf::SRVector3D> muonstop;
  caf::Proxy<float> muonyattrans;
  caf::Proxy<int> ncellsfromedge;
  caf::Proxy<int> nhit;
  caf::Proxy<float> numuE;
  caf::Proxy<float> pur;
  caf::Proxy<float> remid;
  caf::Proxy<int> slcidx;
};

/// Proxy for \ref caf::SRParentBranch
template<> class caf::Proxy<caf::SRParentBranch>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRParentBranch& x);

  void CheckEquals(const caf::SRParentBranch& sr) const;

  caf::Proxy<caf::SRMRCCParent> mrccpar;
};

/// Proxy for \ref caf::SRBpfId
template<> class caf::Proxy<caf::SRBpfId>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRBpfId& x);

  void CheckEquals(const caf::SRBpfId& sr) const;

  caf::Proxy<int> bestBpfIdx;
  caf::Proxy<int> bestPngIdx;
  caf::Proxy<int> bestVtxIdx;
  caf::Proxy<float> chi2T;
  caf::Proxy<float> dEdXLL;
  caf::Proxy<float> energy;
  caf::Proxy<float> hitRatio;
  caf::Proxy<float> len;
  caf::Proxy<caf::SRVector3D> momentum;
  caf::Proxy<int> pdg;
  caf::Proxy<float> pid;
};

/// Proxy for \ref caf::SRContain
template<> class caf::Proxy<caf::SRContain>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRContain& x);

  void CheckEquals(const caf::SRContain& sr) const;

  caf::Proxy<float> cosbakair;
  caf::Proxy<int> cosbakcell;
  caf::Proxy<int> cosbakcellnd;
  caf::Proxy<float> cosbakdist;
  caf::Proxy<float> cosbaksteel;
  caf::Proxy<float> cosfwdair;
  caf::Proxy<int> cosfwdcell;
  caf::Proxy<int> cosfwdcellnd;
  caf::Proxy<float> cosfwddist;
  caf::Proxy<float> cosfwdsteel;
  caf::Proxy<float> cosyposattrans;
  caf::Proxy<float> enddist;
  caf::Proxy<float> kalbakair;
  caf::Proxy<int> kalbakcell;
  caf::Proxy<int> kalbakcellnd;
  caf::Proxy<float> kalbakdist;
  caf::Proxy<float> kalbaksteel;
  caf::Proxy<float> kalfwdair;
  caf::Proxy<int> kalfwdcell;
  caf::Proxy<int> kalfwdcellnd;
  caf::Proxy<float> kalfwddist;
  caf::Proxy<float> kalfwdsteel;
  caf::Proxy<float> kalyposattrans;
  caf::Proxy<float> missE;
  caf::Proxy<int> nplanestoback;
  caf::Proxy<int> nplanestofront;
  caf::Proxy<bool> numucontain;
  caf::Proxy<bool> numucontainSA;
  caf::Proxy<float> vtxdist;
  caf::Proxy<float> xmax2;
  caf::Proxy<float> xmaxt;
  caf::Proxy<float> xmin2;
  caf::Proxy<float> xmint;
  caf::Proxy<float> ymax2;
  caf::Proxy<float> ymaxt;
  caf::Proxy<float> ymin2;
  caf::Proxy<float> ymint;
  caf::Proxy<float> zmax2;
  caf::Proxy<float> zmaxt;
  caf::Proxy<float> zmin2;
  caf::Proxy<float> zmint;
};

/// Proxy for \ref caf::SRCosRej
template<> class caf::Proxy<caf::SRCosRej>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRCosRej& x);

  void CheckEquals(const caf::SRCosRej& sr) const;

  caf::Proxy<float> anglecos;
  caf::Proxy<float> anglekal;
  caf::Proxy<float> cdirscore;
  caf::Proxy<float> cfitspeed;
  caf::Proxy<float> coschidiff;
  caf::Proxy<float> coschisq;
  caf::Proxy<float> cosslope;
  caf::Proxy<float> costhetatrue;
  caf::Proxy<float> cscorediff;
  caf::Proxy<float> eratio;
  caf::Proxy<float> fscattext;
  caf::Proxy<float> fscattmax;
  caf::Proxy<float> fscattsig;
  caf::Proxy<float> fscattsum;
  caf::Proxy<float> hadE;
  caf::Proxy<float> kalchidiff;
  caf::Proxy<float> kalchisq;
  caf::Proxy<float> kalslope;
  caf::Proxy<float> kalthetatrue;
  caf::Proxy<float> kdirscore;
  caf::Proxy<float> kfitspeed;
  caf::Proxy<float> kscorediff;
  caf::Proxy<int> mincell;
  caf::Proxy<float> mindist;
  caf::Proxy<int> nkal3d;
  caf::Proxy<float> numucontpid2019;
  caf::Proxy<float> numucontpid2020;
  caf::Proxy<float> numuunconttunedpid;
  caf::Proxy<int> pdgbest;
  caf::Proxy<float> scatt;
};

/// Proxy for \ref caf::SRCVNResult
template<> class caf::Proxy<caf::SRCVNResult>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRCVNResult& x);

  void CheckEquals(const caf::SRCVNResult& sr) const;

  caf::Proxy<unsigned int> argmax;
  caf::Proxy<float> cosmicid;
  caf::Proxy<float> maxval;
  caf::Proxy<float> ncid;
  caf::Proxy<unsigned int> noutput;
  caf::Proxy<float> nueid;
  caf::Proxy<float> numuid;
  caf::Proxy<float> nutauid;
  caf::Proxy<std::vector<float>> output;
};

/// Proxy for \ref caf::SRLem
template<> class caf::Proxy<caf::SRLem>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRLem& x);

  void CheckEquals(const caf::SRLem& sr) const;

  caf::Proxy<float> avgexpE;
  caf::Proxy<float> avginvE;
  caf::Proxy<float> avgsigE;
  caf::Proxy<float> chibkg;
  caf::Proxy<float> chibkgexp;
  caf::Proxy<float> chisig;
  caf::Proxy<float> chisigexp;
  caf::Proxy<float> dectree;
  caf::Proxy<float> energydiff;
  caf::Proxy<float> energydiffexp;
  caf::Proxy<float> enrichfrac;
  caf::Proxy<float> enrichfracexp;
  caf::Proxy<float> fannid;
  caf::Proxy<float> fannidenrich;
  caf::Proxy<float> meanqfrac;
  caf::Proxy<float> meanqfracbkg;
  caf::Proxy<float> meanqfracbkgexp;
  caf::Proxy<float> meanqfracexp;
  caf::Proxy<float> meanqfracfit;
  caf::Proxy<float> meanqfracsig;
  caf::Proxy<float> meanqfracsigexp;
  caf::Proxy<float> meany;
  caf::Proxy<float> meanyexp;
  caf::Proxy<float> meanyfit;
  caf::Proxy<float> meanysig;
  caf::Proxy<float> meanysigexp;
  caf::Proxy<float> pid;
  caf::Proxy<float> pidexp;
  caf::Proxy<float> pidexpfit;
  caf::Proxy<float> pidfit;
  caf::Proxy<float> tmvabdt;
  caf::Proxy<float> tmvabdtd;
  caf::Proxy<float> tmvabdtg;
  caf::Proxy<float> tmvabdtmf;
  caf::Proxy<float> tmvamlp;
};

/// Proxy for \ref caf::SRELid
template<> class caf::Proxy<caf::SRELid>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRELid& x);

  void CheckEquals(const caf::SRELid& sr) const;

  caf::Proxy<float> ann;
  caf::Proxy<float> anne;
  caf::Proxy<float> annecos;
  caf::Proxy<float> annepi0;
  caf::Proxy<float> rnn;
};

/// Proxy for \ref caf::SRMuonID
template<> class caf::Proxy<caf::SRMuonID>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRMuonID& x);

  void CheckEquals(const caf::SRMuonID& sr) const;

  caf::Proxy<float> pid;
};

/// Proxy for \ref caf::SRNCCosRej
template<> class caf::Proxy<caf::SRNCCosRej>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRNCCosRej& x);

  void CheckEquals(const caf::SRNCCosRej& sr) const;

  caf::Proxy<float> cospidbdt;
  caf::Proxy<float> cospidbdtg;
  caf::Proxy<float> pngptp;
};

/// Proxy for \ref caf::SRNCPi0BkgRej
template<> class caf::Proxy<caf::SRNCPi0BkgRej>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRNCPi0BkgRej& x);

  void CheckEquals(const caf::SRNCPi0BkgRej& sr) const;

  caf::Proxy<double> ncpidbdtg;
  caf::Proxy<double> ncpidbdtglt;
};

/// Proxy for \ref caf::SRNueCosRej
template<> class caf::Proxy<caf::SRNueCosRej>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRNueCosRej& x);

  void CheckEquals(const caf::SRNueCosRej& sr) const;

  caf::Proxy<float> cosdang;
  caf::Proxy<float> cospidcontain;
  caf::Proxy<float> cospidcontainxy;
  caf::Proxy<float> cospidcorebdt;
  caf::Proxy<float> cospidlight;
  caf::Proxy<float> cospidperibdt;
  caf::Proxy<float> distallpngback;
  caf::Proxy<float> distallpngbottom;
  caf::Proxy<float> distallpngeast;
  caf::Proxy<float> distallpngfront;
  caf::Proxy<float> distallpngtop;
  caf::Proxy<float> distallpngwest;
  caf::Proxy<float> hitsperplane;
  caf::Proxy<float> hitsperplaneasymm;
  caf::Proxy<float> hitsperplaneasymmslice;
  caf::Proxy<float> muanglediffbydist;
  caf::Proxy<float> muanglediffbytime;
  caf::Proxy<float> muclosestapproachbydist;
  caf::Proxy<float> muclosestapproachbytime;
  caf::Proxy<int> musliceidxbydist;
  caf::Proxy<int> musliceidxbytime;
  caf::Proxy<float> mutimediffbydist;
  caf::Proxy<float> mutimediffbytime;
  caf::Proxy<float> partptp;
  caf::Proxy<float> photptp;
  caf::Proxy<float> photpxp;
  caf::Proxy<float> photpyp;
  caf::Proxy<float> pngptp;
  caf::Proxy<float> prongmaxx;
  caf::Proxy<float> prongmaxy;
  caf::Proxy<float> prongmaxz;
  caf::Proxy<float> prongminx;
  caf::Proxy<float> prongminy;
  caf::Proxy<float> prongminz;
  caf::Proxy<float> sparsenessasymm;
  caf::Proxy<float> sparsenessasymmslice;
  caf::Proxy<float> startback;
  caf::Proxy<float> startbottom;
  caf::Proxy<float> starteast;
  caf::Proxy<float> startfront;
  caf::Proxy<float> starttop;
  caf::Proxy<float> startwest;
  caf::Proxy<float> stopback;
  caf::Proxy<float> stopbottom;
  caf::Proxy<float> stopeast;
  caf::Proxy<float> stopfront;
  caf::Proxy<float> stoptop;
  caf::Proxy<float> stopwest;
  caf::Proxy<float> vtxdoca;
};

/// Proxy for \ref caf::SRPresel
template<> class caf::Proxy<caf::SRPresel>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRPresel& x);

  void CheckEquals(const caf::SRPresel& sr) const;

  caf::Proxy<bool> passpre;
};

/// Proxy for \ref caf::SRNuonEResult
template<> class caf::Proxy<caf::SRNuonEResult>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRNuonEResult& x);

  void CheckEquals(const caf::SRNuonEResult& sr) const;

  caf::Proxy<float> epi0nuoneid;
  caf::Proxy<float> epi0pi0id;
  caf::Proxy<unsigned int> noutput;
  caf::Proxy<float> nueccid;
  caf::Proxy<float> nuoneid;
  caf::Proxy<float> otherid;
  caf::Proxy<std::vector<float>> output;
  caf::Proxy<float> pi0id;
  caf::Proxy<float> rawgevslice;
};

/// Proxy for \ref caf::SRRemid
template<> class caf::Proxy<caf::SRRemid>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRRemid& x);

  void CheckEquals(const caf::SRRemid& sr) const;

  caf::Proxy<int> cont;
  caf::Proxy<float> dedxllh;
  caf::Proxy<float> len;
  caf::Proxy<float> measfrac;
  caf::Proxy<float> pid;
  caf::Proxy<float> scatllh;
};

/// Proxy for \ref caf::SRRvp
template<> class caf::Proxy<caf::SRRvp>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRRvp& x);

  void CheckEquals(const caf::SRRvp& sr) const;

  caf::Proxy<float> efrac2plwin;
  caf::Proxy<float> efrac2sigrd;
  caf::Proxy<float> efrac6plwin;
  caf::Proxy<float> eiso3sig;
  caf::Proxy<float> epl20frac;
  caf::Proxy<float> longtr;
  caf::Proxy<float> longtrfrac;
  caf::Proxy<float> mipfrac;
  caf::Proxy<float> miphits;
  caf::Proxy<int> ncell;
  caf::Proxy<float> pid;
  caf::Proxy<float> prongEbal2D;
  caf::Proxy<float> prongEbal3D;
  caf::Proxy<int> prongs2D;
  caf::Proxy<int> prongs3D;
  caf::Proxy<float> recoE;
  caf::Proxy<float> rvp12;
};

/// Proxy for \ref caf::SRSliceLID
template<> class caf::Proxy<caf::SRSliceLID>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRSliceLID& x);

  void CheckEquals(const caf::SRSliceLID& sr) const;

  caf::Proxy<float> cosmicid;
  caf::Proxy<float> ncid;
  caf::Proxy<float> nueid;
  caf::Proxy<float> numuid;
  caf::Proxy<float> nutauid;
};

/// Proxy for \ref caf::SRVeto
template<> class caf::Proxy<caf::SRVeto>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRVeto& x);

  void CheckEquals(const caf::SRVeto& sr) const;

  caf::Proxy<float> angle;
  caf::Proxy<float> anglevar;
  caf::Proxy<float> anglevarold;
  caf::Proxy<float> bakdist;
  caf::Proxy<float> diry;
  caf::Proxy<float> fwddist;
  caf::Proxy<bool> keep;
  caf::Proxy<bool> keepnue;
  caf::Proxy<int> ncell;
  caf::Proxy<bool> passangle;
  caf::Proxy<bool> passanglefirstana;
  caf::Proxy<bool> passnumicut;
  caf::Proxy<bool> passthru;
  caf::Proxy<bool> passthruold;
  caf::Proxy<float> ratio;
};

/// Proxy for \ref caf::SRXnue
template<> class caf::Proxy<caf::SRXnue>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRXnue& x);

  void CheckEquals(const caf::SRXnue& sr) const;

  caf::Proxy<double> bdt;
  caf::Proxy<float> efrac10p;
  caf::Proxy<float> efrac2sig;
  caf::Proxy<float> efracp2;
  caf::Proxy<float> efracp3;
  caf::Proxy<float> efracp4;
  caf::Proxy<float> emaxfrac6p;
  caf::Proxy<float> p1Fmip;
  caf::Proxy<float> p1energy;
  caf::Proxy<float> p2Fmip;
};

/// Proxy for \ref caf::SRIDBranch
template<> class caf::Proxy<caf::SRIDBranch>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRIDBranch& x);

  void CheckEquals(const caf::SRIDBranch& sr) const;

  caf::Proxy<caf::SRBpfId> bpfid;
  caf::Proxy<caf::SRContain> contain;
  caf::Proxy<caf::SRCosRej> cosrej;
  caf::Proxy<caf::SRCVNResult> cvn;
  caf::Proxy<caf::SRCVNResult> cvnloosepreselptp;
  caf::Proxy<caf::SRCVNResult> cvnloosepreselptp_opphorn;
  caf::Proxy<caf::SRCVNResult> cvnnocosmics;
  caf::Proxy<caf::SRCVNResult> cvnnocosmics_opphorn;
  caf::Proxy<caf::SRCVNResult> cvnoldpresel;
  caf::Proxy<caf::SRCVNResult> cvnoldpresel_opphorn;
  caf::Proxy<caf::SRLem> lem;
  caf::Proxy<caf::SRELid> lid;
  caf::Proxy<caf::SRMuonID> muonid;
  caf::Proxy<caf::SRNCCosRej> nccosrej;
  caf::Proxy<caf::SRNCPi0BkgRej> ncpi0bkgrej;
  caf::Proxy<caf::SRNueCosRej> nuecosrej;
  caf::Proxy<caf::SRPresel> nuepre;
  caf::Proxy<caf::SRNuonEResult> nuone;
  caf::Proxy<caf::SRNuonEResult> nuone_opphorn;
  caf::Proxy<caf::SRRemid> remid;
  caf::Proxy<caf::SRPresel> rockpre;
  caf::Proxy<caf::SRRvp> rvp;
  caf::Proxy<caf::SRSliceLID> slicelid;
  caf::Proxy<caf::SRSliceLID> slicelid_opphorn;
  caf::Proxy<caf::SRVeto> veto;
  caf::Proxy<double> wsid;
  caf::Proxy<caf::SRXnue> xnuepid;
};

/// Proxy for \ref caf::SRSlice
template<> class caf::Proxy<caf::SRSlice>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRSlice& x);

  void CheckEquals(const caf::SRSlice& sr) const;

  caf::Proxy<caf::SRVector3D> boxmax;
  caf::Proxy<caf::SRVector3D> boxmin;
  caf::Proxy<float> calE;
  caf::Proxy<float> closestslicecalE;
  caf::Proxy<float> closestslicemindist;
  caf::Proxy<float> closestsliceminfromback;
  caf::Proxy<float> closestsliceminfrombottom;
  caf::Proxy<float> closestsliceminfromeast;
  caf::Proxy<float> closestsliceminfromfront;
  caf::Proxy<float> closestsliceminfromtop;
  caf::Proxy<float> closestsliceminfromwest;
  caf::Proxy<unsigned int> closestslicenhit;
  caf::Proxy<float> closestslicetime;
  caf::Proxy<float> endtime;
  caf::Proxy<unsigned int> firstcell;
  caf::Proxy<unsigned int> firstplane;
  caf::Proxy<float> fracnoiseE;
  caf::Proxy<float> fracnoisePE;
  caf::Proxy<unsigned int> lastcell;
  caf::Proxy<unsigned int> lastplane;
  caf::Proxy<caf::SRVector3D> meanpos;
  caf::Proxy<float> meantime;
  caf::Proxy<unsigned int> ncalhit;
  caf::Proxy<unsigned int> ncellsfromedge;
  caf::Proxy<unsigned int> ncontplanes;
  caf::Proxy<unsigned int> nhit;
  caf::Proxy<unsigned int> nmiphit;
  caf::Proxy<unsigned int> nnoisehit;
  caf::Proxy<unsigned int> nnonnoise;
  caf::Proxy<float> starttime;
  caf::Proxy<float> tsd;
};

/// Proxy for \ref caf::SRCosmicCVN
template<> class caf::Proxy<caf::SRCosmicCVN>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRCosmicCVN& x);

  void CheckEquals(const caf::SRCosmicCVN& sr) const;

  caf::Proxy<float> cosmicVal;
  caf::Proxy<int> nHits;
  caf::Proxy<float> ncVal;
  caf::Proxy<float> nueVal;
  caf::Proxy<float> numuVal;
  caf::Proxy<float> nutauVal;
  caf::Proxy<bool> passSel;
  caf::Proxy<float> timeWinMax;
  caf::Proxy<float> timeWinMin;
};

/// Proxy for \ref caf::SRSpill
template<> class caf::Proxy<caf::SRSpill>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRSpill& x);

  void CheckEquals(const caf::SRSpill& sr) const;

  caf::Proxy<std::vector<float>> bposx;
  caf::Proxy<std::vector<float>> bposy;
  caf::Proxy<std::vector<caf::SRCosmicCVN>> cosmiccvn;
  caf::Proxy<float> dcmedgematchfrac;
  caf::Proxy<long long int> deltaspilltimensec;
  caf::Proxy<caf::Det_t> det;
  caf::Proxy<short unsigned int> dibfirst;
  caf::Proxy<short unsigned int> diblast;
  caf::Proxy<short unsigned int> dibmask;
  caf::Proxy<int> emptydatablock;
  caf::Proxy<bool> eventincomplete;
  caf::Proxy<unsigned int> evt;
  caf::Proxy<float> fracdcm3hits;
  caf::Proxy<long unsigned int> gpsspilltimensec;
  caf::Proxy<long unsigned int> gpsspilltimesec;
  caf::Proxy<float> hornI;
  caf::Proxy<std::vector<float>> intx;
  caf::Proxy<std::vector<float>> inty;
  caf::Proxy<bool> is0HC;
  caf::Proxy<bool> isFHC;
  caf::Proxy<bool> isRHC;
  caf::Proxy<bool> isgoodspill;
  caf::Proxy<bool> ismc;
  caf::Proxy<float> livetime;
  caf::Proxy<short unsigned int> maskstatus;
  caf::Proxy<int> nanosliceadcerror;
  caf::Proxy<int> nanoslicebufferempty;
  caf::Proxy<int> nanoslicebufferfull;
  caf::Proxy<int> nanoslicecommerror;
  caf::Proxy<int> nanoslicedatanotpresent;
  caf::Proxy<int> nanoslicenolinkstatus;
  caf::Proxy<int> nanosliceoverflowerror;
  caf::Proxy<int> nanoslicepacketerror;
  caf::Proxy<unsigned int> nbaddcmslg;
  caf::Proxy<short int> ncosmiccvn;
  caf::Proxy<int> ndatablockmissingdata;
  caf::Proxy<int> ndcms;
  caf::Proxy<int> ndiblocks;
  caf::Proxy<int> ndroppedmicroblocks;
  caf::Proxy<int> nemptymicroslice;
  caf::Proxy<int> nmicroblocks;
  caf::Proxy<int> nmicroslicedatanotpresent;
  caf::Proxy<unsigned int> nmicroslices;
  caf::Proxy<unsigned int> nmissingdcms;
  caf::Proxy<unsigned int> nmissingdcmslg;
  caf::Proxy<int> nnanoslices;
  caf::Proxy<unsigned int> nnoisyapds;
  caf::Proxy<unsigned int> nouttimehits;
  caf::Proxy<float> posx;
  caf::Proxy<float> posy;
  caf::Proxy<unsigned int> run;
  caf::Proxy<float> spillpot;
  caf::Proxy<long unsigned int> spilltimensec;
  caf::Proxy<long unsigned int> spilltimesec;
  caf::Proxy<unsigned int> subrun;
  caf::Proxy<unsigned char> trigger;
  caf::Proxy<float> widthx;
  caf::Proxy<float> widthy;
};

/// Proxy for \ref caf::SRCVNFeatures
template<> class caf::Proxy<caf::SRCVNFeatures>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRCVNFeatures& x);

  void CheckEquals(const caf::SRCVNFeatures& sr) const;

  caf::Proxy<std::vector<float>> components;
  caf::Proxy<unsigned int> ncomponents;
  caf::Proxy<unsigned int> noutput;
  caf::Proxy<std::vector<float>> output;
};

/// Proxy for \ref caf::SRPixelObjMap
template<> class caf::Proxy<caf::SRPixelObjMap>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRPixelObjMap& x);

  void CheckEquals(const caf::SRPixelObjMap& sr) const;

  caf::Proxy<unsigned char [16000]> cvnlabmap;
  caf::Proxy<unsigned char [16000]> cvnmap;
  caf::Proxy<unsigned char [16000]> cvnobjmap;
  caf::Proxy<unsigned int> firstcellx;
  caf::Proxy<unsigned int> firstcelly;
  caf::Proxy<unsigned int> firstplane;
  caf::Proxy<float> hitfracx;
  caf::Proxy<float> hitfracy;
  caf::Proxy<unsigned int> lastcellx;
  caf::Proxy<unsigned int> lastcelly;
  caf::Proxy<unsigned int> lastplane;
  caf::Proxy<unsigned int> ncells;
  caf::Proxy<unsigned int> nchan;
  caf::Proxy<unsigned int> nplanes;
};

/// Proxy for \ref caf::SRSliceMap
template<> class caf::Proxy<caf::SRSliceMap>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRSliceMap& x);

  void CheckEquals(const caf::SRSliceMap& sr) const;

  caf::Proxy<unsigned char [344064]> slicemap;
};

/// Proxy for \ref caf::SRTrainingData
template<> class caf::Proxy<caf::SRTrainingData>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRTrainingData& x);

  void CheckEquals(const caf::SRTrainingData& sr) const;

  caf::Proxy<unsigned int> finalstate;
  caf::Proxy<unsigned int> finalstateprong;
  caf::Proxy<unsigned int> interaction;
  caf::Proxy<float> lepenergy;
  caf::Proxy<float> nuenergy;
  caf::Proxy<unsigned int> parent;
  caf::Proxy<unsigned int> particles;
  caf::Proxy<double> vtxx;
  caf::Proxy<double> vtxy;
  caf::Proxy<double> vtxz;
};

/// Proxy for \ref caf::SRTrainingBranch
template<> class caf::Proxy<caf::SRTrainingBranch>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRTrainingBranch& x);

  void CheckEquals(const caf::SRTrainingBranch& sr) const;

  caf::Proxy<caf::SRCVNFeatures> cvnfeatures;
  caf::Proxy<std::vector<caf::SRPixelObjMap>> cvnmaps;
  caf::Proxy<bool> cvnmapsfilled;
  caf::Proxy<std::vector<caf::SRSliceMap>> slicemaps;
  caf::Proxy<std::vector<caf::SRTrainingData>> trainingdata;
};

/// Proxy for \ref caf::SRShower
template<> class caf::Proxy<caf::SRShower>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRShower& x);

  void CheckEquals(const caf::SRShower& sr) const;

  caf::Proxy<float> calE;
  caf::Proxy<caf::SRVector3D> dir;
  caf::Proxy<float> gap;
  caf::Proxy<float> len;
  caf::Proxy<short unsigned int> maxplanecont;
  caf::Proxy<short unsigned int> maxplanegap;
  caf::Proxy<short unsigned int> nhit;
  caf::Proxy<short unsigned int> nhitx;
  caf::Proxy<short unsigned int> nhity;
  caf::Proxy<short unsigned int> nplane;
  caf::Proxy<short unsigned int> nplanex;
  caf::Proxy<short unsigned int> nplaney;
  caf::Proxy<caf::SRVector3D> start;
  caf::Proxy<caf::SRVector3D> stop;
  caf::Proxy<caf::SRParticleTruth> truth;
  caf::Proxy<caf::SRParticleTruth> truthXView;
  caf::Proxy<caf::SRParticleTruth> truthYView;
  caf::Proxy<caf::View_t> view;
  caf::Proxy<float> width;
};

/// Proxy for \ref caf::SRSLid
template<> class caf::Proxy<caf::SRSLid>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRSLid& x);

  void CheckEquals(const caf::SRSLid& sr) const;

  caf::Proxy<float> ann;
  caf::Proxy<float> anne;
  caf::Proxy<float> annecos;
  caf::Proxy<float> annepi0;
  caf::Proxy<float> costheta;
  caf::Proxy<float> dedx0;
  caf::Proxy<float> dedx1;
  caf::Proxy<float> dedx2;
  caf::Proxy<float> dedx3;
  caf::Proxy<float> dedx4;
  caf::Proxy<float> dedx5;
  caf::Proxy<float> dedxp0c0;
  caf::Proxy<float> dedxp0c1;
  caf::Proxy<float> dedxp1c0;
  caf::Proxy<float> dedxp1c1;
  caf::Proxy<float> dedxp2c0;
  caf::Proxy<float> dedxp2c1;
  caf::Proxy<float> dedxp3c0;
  caf::Proxy<float> dedxp3c1;
  caf::Proxy<float> dedxp4c0;
  caf::Proxy<float> dedxp4c1;
  caf::Proxy<float> dedxp5c0;
  caf::Proxy<float> dedxp5c1;
  caf::Proxy<float> eglll;
  caf::Proxy<float> egllt;
  caf::Proxy<float> elll;
  caf::Proxy<float> ellt;
  caf::Proxy<float> emulll;
  caf::Proxy<float> emullt;
  caf::Proxy<float> enlll;
  caf::Proxy<float> enllt;
  caf::Proxy<float> epi0lll;
  caf::Proxy<float> epi0llt;
  caf::Proxy<float> epilll;
  caf::Proxy<float> epillt;
  caf::Proxy<float> eplll;
  caf::Proxy<float> epllt;
  caf::Proxy<float> gap;
  caf::Proxy<float> invglll;
  caf::Proxy<int> ismuon;
  caf::Proxy<float> mulll;
  caf::Proxy<float> mullt;
  caf::Proxy<float> pi0mass;
  caf::Proxy<float> shwEFrac;
  caf::Proxy<float> vtxgev;
};

/// Proxy for \ref caf::SRShowerLID
template<> class caf::Proxy<caf::SRShowerLID> : public caf::Proxy<caf::SRShower>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRShowerLID& x);

  void CheckEquals(const caf::SRShowerLID& sr) const;

  caf::Proxy<caf::SRSLid> lid;
  caf::Proxy<caf::SRSLidEnergy> lidE;
  caf::Proxy<float> shwE;
  caf::Proxy<float> vtxE;
};

/// Proxy for \ref caf::SRMRProperties
template<> class caf::Proxy<caf::SRMRProperties>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRMRProperties& x);

  void CheckEquals(const caf::SRMRProperties& sr) const;

  caf::Proxy<float> calE;
  caf::Proxy<caf::SRCVNResult> cvnloosepreselptp;
  caf::Proxy<caf::SRCVNResult> cvnnocosmics;
  caf::Proxy<caf::SRCVNResult> cvnoldpresel;
  caf::Proxy<float> gap;
  caf::Proxy<bool> isDiF;
  caf::Proxy<bool> isShwDiF;
  caf::Proxy<caf::SRShowerLID> lid;
  caf::Proxy<short unsigned int> maxplane;
  caf::Proxy<short unsigned int> maxplanecont;
  caf::Proxy<short unsigned int> maxplanegap;
  caf::Proxy<short unsigned int> minplane;
  caf::Proxy<short unsigned int> nhit;
  caf::Proxy<short unsigned int> nhitx;
  caf::Proxy<short unsigned int> nhity;
  caf::Proxy<short unsigned int> nplane;
  caf::Proxy<short unsigned int> nplanex;
  caf::Proxy<short unsigned int> nplaney;
  caf::Proxy<caf::SRParticleTruth> truth;
  caf::Proxy<caf::SRParticleTruth> truthXView;
  caf::Proxy<caf::SRParticleTruth> truthYView;
  caf::Proxy<caf::View_t> view;
};

/// Proxy for \ref caf::SRTrack
template<> class caf::Proxy<caf::SRTrack>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRTrack& x);

  void CheckEquals(const caf::SRTrack& sr) const;

  caf::Proxy<float> avedEdxlast10cm;
  caf::Proxy<float> avedEdxlast20cm;
  caf::Proxy<float> avedEdxlast30cm;
  caf::Proxy<float> avedEdxlast40cm;
  caf::Proxy<float> calE;
  caf::Proxy<caf::SRVector3D> dir;
  caf::Proxy<float> enddist;
  caf::Proxy<float> len;
  caf::Proxy<float> lenE;
  caf::Proxy<double> leninact;
  caf::Proxy<double> lenincat;
  caf::Proxy<short unsigned int> maxplanecont;
  caf::Proxy<short unsigned int> maxplanegap;
  caf::Proxy<float> maxtime;
  caf::Proxy<std::vector<caf::SRTrkME>> me;
  caf::Proxy<float> meantime;
  caf::Proxy<float> meantimeRes;
  caf::Proxy<float> mintime;
  caf::Proxy<std::vector<caf::SRMRProperties>> mrbrem;
  caf::Proxy<std::vector<caf::SRMRProperties>> mrdif;
  caf::Proxy<short unsigned int> nhit;
  caf::Proxy<short unsigned int> nhitx;
  caf::Proxy<short unsigned int> nhity;
  caf::Proxy<short unsigned int> nplane;
  caf::Proxy<short unsigned int> nplanegap;
  caf::Proxy<float> overlapE;
  caf::Proxy<float> pngmaxx;
  caf::Proxy<float> pngmaxy;
  caf::Proxy<float> pngminx;
  caf::Proxy<float> pngminy;
  caf::Proxy<caf::SRVector3D> start;
  caf::Proxy<caf::SRVector3D> stop;
  caf::Proxy<caf::SRVector3D> stopdir;
  caf::Proxy<float> trkbakair;
  caf::Proxy<int> trkbakcell;
  caf::Proxy<int> trkbakcellnd;
  caf::Proxy<float> trkbakdist;
  caf::Proxy<float> trkbaksteel;
  caf::Proxy<float> trkfwdair;
  caf::Proxy<int> trkfwdcell;
  caf::Proxy<int> trkfwdcellnd;
  caf::Proxy<float> trkfwddist;
  caf::Proxy<float> trkfwdsteel;
  caf::Proxy<float> trkyposattrans;
  caf::Proxy<caf::SRParticleTruth> truth;
  caf::Proxy<caf::SRParticleTruth> truthXView;
  caf::Proxy<caf::SRParticleTruth> truthYView;
  caf::Proxy<caf::View_t> view;
  caf::Proxy<float> vtxdist;
};

/// Proxy for \ref caf::SRTrackBase
template<> class caf::Proxy<caf::SRTrackBase>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRTrackBase& x);

  void CheckEquals(const caf::SRTrackBase& sr) const;

  caf::Proxy<size_t> ntracks;
  caf::Proxy<std::vector<caf::SRTrack>> tracks;
};

/// Proxy for \ref caf::SRKalmanTrack
template<> class caf::Proxy<caf::SRKalmanTrack> : public caf::Proxy<caf::SRTrack>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRKalmanTrack& x);

  void CheckEquals(const caf::SRKalmanTrack& sr) const;

  caf::Proxy<float> activity15;
  caf::Proxy<float> activity30;
  caf::Proxy<float> activity45;
  caf::Proxy<float> dedx15;
  caf::Proxy<float> dedx30;
  caf::Proxy<float> dedxllh;
  caf::Proxy<float> measfrac;
  caf::Proxy<float> muonid;
  caf::Proxy<float> mvapiE;
  caf::Proxy<float> prox15;
  caf::Proxy<float> prox30;
  caf::Proxy<float> remavededx;
  caf::Proxy<int> remcont;
  caf::Proxy<float> rempid;
  caf::Proxy<float> scatllh;
  caf::Proxy<float> scatt15;
  caf::Proxy<float> scatt30;
};

/// Proxy for \ref caf::SRKalman
template<> class caf::Proxy<caf::SRKalman>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRKalman& x);

  void CheckEquals(const caf::SRKalman& sr) const;

  caf::Proxy<unsigned int> idxlongest;
  caf::Proxy<unsigned int> idxmuonid;
  caf::Proxy<unsigned int> idxremid;
  caf::Proxy<size_t> ntracks;
  caf::Proxy<size_t> ntracks2d;
  caf::Proxy<std::vector<caf::SRKalmanTrack>> tracks;
  caf::Proxy<std::vector<caf::SRTrack>> tracks2d;
};

/// Proxy for \ref caf::SRTrackBranch
template<> class caf::Proxy<caf::SRTrackBranch>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRTrackBranch& x);

  void CheckEquals(const caf::SRTrackBranch& sr) const;

  caf::Proxy<caf::SRTrackBase> cosmic;
  caf::Proxy<caf::SRTrackBase> discrete;
  caf::Proxy<caf::SRKalman> kalman;
  caf::Proxy<caf::SRTrackBase> window;
};

/// Proxy for \ref caf::SRPixelMap
template<> class caf::Proxy<caf::SRPixelMap>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRPixelMap& x);

  void CheckEquals(const caf::SRPixelMap& sr) const;

  caf::Proxy<unsigned char [16000]> cvnmap;
  caf::Proxy<unsigned int> firstcellx;
  caf::Proxy<unsigned int> firstcelly;
  caf::Proxy<unsigned int> firstplane;
  caf::Proxy<float> hitfracx;
  caf::Proxy<float> hitfracy;
  caf::Proxy<unsigned int> lastcellx;
  caf::Proxy<unsigned int> lastcelly;
  caf::Proxy<unsigned int> lastplane;
  caf::Proxy<unsigned int> ncells;
  caf::Proxy<unsigned int> nchan;
  caf::Proxy<unsigned int> nplanes;
};

/// Proxy for \ref caf::SRCVNNeutronDaughterResult
template<> class caf::Proxy<caf::SRCVNNeutronDaughterResult>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRCVNNeutronDaughterResult& x);

  void CheckEquals(const caf::SRCVNNeutronDaughterResult& sr) const;

  caf::Proxy<float> otherid;
  caf::Proxy<float> photonid;
  caf::Proxy<float> protonid;
};

/// Proxy for \ref caf::SRCVNParticleResult
template<> class caf::Proxy<caf::SRCVNParticleResult>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRCVNParticleResult& x);

  void CheckEquals(const caf::SRCVNParticleResult& sr) const;

  caf::Proxy<float> electronid;
  caf::Proxy<float> emid;
  caf::Proxy<float> hadronid;
  caf::Proxy<float> maxval;
  caf::Proxy<float> muonid;
  caf::Proxy<float> neutronid;
  caf::Proxy<float> otherid;
  caf::Proxy<unsigned int> pdgmax;
  caf::Proxy<float> photonid;
  caf::Proxy<float> pionid;
  caf::Proxy<float> pizeroid;
  caf::Proxy<float> protonid;
};

/// Proxy for \ref caf::SRProngTrainingData
template<> class caf::Proxy<caf::SRProngTrainingData>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRProngTrainingData& x);

  void CheckEquals(const caf::SRProngTrainingData& sr) const;

  caf::Proxy<bool> isprimary;
  caf::Proxy<int> label3d;
  caf::Proxy<int> labelx;
  caf::Proxy<int> labely;
  caf::Proxy<unsigned int> ncellx;
  caf::Proxy<unsigned int> ncelly;
  caf::Proxy<double> pangle;
  caf::Proxy<double> pgap;
  caf::Proxy<double> plength;
  caf::Proxy<double> purity3d;
  caf::Proxy<double> purityx;
  caf::Proxy<double> purityy;
  caf::Proxy<double> rece;
  caf::Proxy<double> vertx;
  caf::Proxy<double> verty;
  caf::Proxy<double> vertz;
};

/// Proxy for \ref caf::SRProng
template<> class caf::Proxy<caf::SRProng>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRProng& x);

  void CheckEquals(const caf::SRProng& sr) const;

  caf::Proxy<float> calE;
  caf::Proxy<std::vector<caf::SRPixelMap>> cvnmaps;
  caf::Proxy<caf::SRCVNNeutronDaughterResult> cvnneutron;
  caf::Proxy<caf::SRCVNParticleResult> cvnpart;
  caf::Proxy<caf::SRCVNParticleResult> cvnpart_opphorn;
  caf::Proxy<caf::SRVector3D> dir;
  caf::Proxy<float> len;
  caf::Proxy<short unsigned int> maxplanecont;
  caf::Proxy<short unsigned int> maxplanegap;
  caf::Proxy<float> maxtime;
  caf::Proxy<float> meantime;
  caf::Proxy<float> meantimeRes;
  caf::Proxy<float> mintime;
  caf::Proxy<short unsigned int> nhit;
  caf::Proxy<short unsigned int> nhitx;
  caf::Proxy<short unsigned int> nhity;
  caf::Proxy<short unsigned int> nplane;
  caf::Proxy<float> pngmaxx;
  caf::Proxy<float> pngmaxy;
  caf::Proxy<float> pngminx;
  caf::Proxy<float> pngminy;
  caf::Proxy<std::vector<caf::SRProngTrainingData>> prongtrainingdata;
  caf::Proxy<caf::SRCVNParticleResult> spprongcvnpart5label;
  caf::Proxy<caf::SRCVNParticleResult> spprongcvnpartnumuccemid;
  caf::Proxy<caf::SRVector3D> start;
  caf::Proxy<caf::SRParticleTruth> truth;
  caf::Proxy<caf::SRParticleTruth> truthXView;
  caf::Proxy<caf::SRParticleTruth> truthYView;
  caf::Proxy<caf::View_t> view;
  caf::Proxy<float> weightedCalE;
};

/// Proxy for \ref caf::SRBpfTrack
template<> class caf::Proxy<caf::SRBpfTrack> : public caf::Proxy<caf::SRTrack>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRBpfTrack& x);

  void CheckEquals(const caf::SRBpfTrack& sr) const;

  caf::Proxy<bool> IsValid;
  caf::Proxy<float> activity15;
  caf::Proxy<float> activity30;
  caf::Proxy<float> activity45;
  caf::Proxy<float> chi2Hit;
  caf::Proxy<float> chi2Scat;
  caf::Proxy<float> chi2T;
  caf::Proxy<float> dEdXLL;
  caf::Proxy<float> dedx15;
  caf::Proxy<float> dedx30;
  caf::Proxy<float> energy;
  caf::Proxy<float> hitRatio;
  caf::Proxy<caf::SRVector3D> momentum;
  caf::Proxy<float> mvapiE;
  caf::Proxy<int> pdg;
  caf::Proxy<float> pid;
  caf::Proxy<float> prox15;
  caf::Proxy<float> prox30;
  caf::Proxy<float> scatt15;
  caf::Proxy<float> scatt30;
};

/// Proxy for \ref caf::SRBpf
template<> class caf::Proxy<caf::SRBpf>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRBpf& x);

  void CheckEquals(const caf::SRBpf& sr) const;

  caf::Proxy<caf::SRBpfTrack> muon;
  caf::Proxy<caf::SRBpfTrack> pion;
  caf::Proxy<caf::SRBpfTrack> proton;
};

/// Proxy for \ref caf::SRRegCVNResult
template<> class caf::Proxy<caf::SRRegCVNResult>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRRegCVNResult& x);

  void CheckEquals(const caf::SRRegCVNResult& sr) const;

  caf::Proxy<float> prongE;
};

/// Proxy for \ref caf::SRFuzzyKProng
template<> class caf::Proxy<caf::SRFuzzyKProng> : public caf::Proxy<caf::SRProng>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRFuzzyKProng& x);

  void CheckEquals(const caf::SRFuzzyKProng& sr) const;

  caf::Proxy<float> activity15;
  caf::Proxy<float> activity30;
  caf::Proxy<float> activity45;
  caf::Proxy<caf::SRBpf> bpf;
  caf::Proxy<float> dedx15;
  caf::Proxy<float> dedx30;
  caf::Proxy<float> mvapiE;
  caf::Proxy<float> prox15;
  caf::Proxy<float> prox30;
  caf::Proxy<caf::SRRegCVNResult> regcvn;
  caf::Proxy<caf::SRShowerLID> shwlid;
};

/// Proxy for \ref caf::SRFuzzyK
template<> class caf::Proxy<caf::SRFuzzyK>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRFuzzyK& x);

  void CheckEquals(const caf::SRFuzzyK& sr) const;

  caf::Proxy<unsigned int> longestidx;
  caf::Proxy<size_t> npng;
  caf::Proxy<size_t> npng2d;
  caf::Proxy<unsigned int> nshwlid;
  caf::Proxy<size_t> ntot;
  caf::Proxy<float> orphCalE;
  caf::Proxy<std::vector<caf::SRFuzzyKProng>> png;
  caf::Proxy<std::vector<caf::SRProng>> png2d;
};

/// Proxy for \ref caf::SRElastic
template<> class caf::Proxy<caf::SRElastic>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRElastic& x);

  void CheckEquals(const caf::SRElastic& sr) const;

  caf::Proxy<bool> IsValid;
  caf::Proxy<caf::SRFuzzyK> fuzzyk;
  caf::Proxy<float> prong2dvertexenergyvolume10;
  caf::Proxy<float> prong2dvertexenergyvolume20;
  caf::Proxy<float> prong2dvertexenergyvolume30;
  caf::Proxy<float> prong2dvertexenergyvolume40;
  caf::Proxy<float> prong3dvertexenergyvolume10;
  caf::Proxy<float> prong3dvertexenergyvolume20;
  caf::Proxy<float> prong3dvertexenergyvolume30;
  caf::Proxy<float> prong3dvertexenergyvolume40;
  caf::Proxy<float> slicevertexenergyvolume10;
  caf::Proxy<float> slicevertexenergyvolume20;
  caf::Proxy<float> slicevertexenergyvolume30;
  caf::Proxy<float> slicevertexenergyvolume40;
  caf::Proxy<float> time;
  caf::Proxy<caf::SRVector3D> vtx;
};

/// Proxy for \ref caf::SRHoughVertex
template<> class caf::Proxy<caf::SRHoughVertex>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRHoughVertex& x);

  void CheckEquals(const caf::SRHoughVertex& sr) const;

  caf::Proxy<caf::SRFuzzyK> fuzzyk;
  caf::Proxy<float> time;
  caf::Proxy<caf::SRVector3D> vtx;
};

/// Proxy for \ref caf::SRVertexDT
template<> class caf::Proxy<caf::SRVertexDT>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRVertexDT& x);

  void CheckEquals(const caf::SRVertexDT& sr) const;

  caf::Proxy<float> time;
  caf::Proxy<caf::SRVector3D> vtx;
};

/// Proxy for \ref caf::SRVertexBranch
template<> class caf::Proxy<caf::SRVertexBranch>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::SRVertexBranch& x);

  void CheckEquals(const caf::SRVertexBranch& sr) const;

  caf::Proxy<caf::SRElastic> elastic;
  caf::Proxy<std::vector<caf::SRHoughVertex>> hough;
  caf::Proxy<size_t> nhough;
  caf::Proxy<size_t> nvdt;
  caf::Proxy<std::vector<caf::SRVertexDT>> vdt;
};

/// Proxy for \ref caf::StandardRecord
template<> class caf::Proxy<caf::StandardRecord>
{
public:
  Proxy(TDirectory* d, TTree* tr, const std::string& name, const long& base, int offset);
  Proxy(const Proxy&) = delete;
  Proxy(const Proxy&&) = delete;
  Proxy& operator=(const caf::StandardRecord& x);

  void CheckEquals(const caf::StandardRecord& sr) const;

  caf::Proxy<caf::SREnergyBranch> energy;
  caf::Proxy<caf::SRHeader> hdr;
  caf::Proxy<caf::SRTruthBranch> mc;
  caf::Proxy<caf::SRMichelE> me;
  caf::Proxy<caf::SRParentBranch> parent;
  caf::Proxy<caf::SRIDBranch> sel;
  caf::Proxy<caf::SRSlice> slc;
  caf::Proxy<caf::SRSpill> spill;
  caf::Proxy<caf::SRTrainingBranch> training;
  caf::Proxy<caf::SRTrackBranch> trk;
  caf::Proxy<caf::SRVertexBranch> vtx;
};