garana::Backtracker Class Reference

#include <Backtracker.h>

Public Member Functions
	Backtracker ()
	Backtracker (const TreeManager *tm)
void	FillMaps ()
const vector< UInt_t > *	GTruthToG4Particles (const UInt_t &itruth) const
const vector< UInt_t > *	GTruthToTracks (const UInt_t &itruth) const
UInt_t const	G4ParticleToGTruth (const UInt_t &ig4p) const
const vector< UInt_t > *	G4ParticleToTracks (const UInt_t &ig4p) const
UInt_t const	TrackToGTruth (const UInt_t &itrk) const
const vector< UInt_t > *	TrackToG4Particles (const UInt_t &itrk) const
const vector< pair< UInt_t, float > >	TrackToG4ParticlesDeposits (const UInt_t &itrk) const
UInt_t const	TrackToG4Particle (const UInt_t &itrk) const
const pair< UInt_t, float >	TrackToG4ParticleDeposit (const UInt_t &itrk) const
UInt_t const	VertexToGTruth (const UInt_t &ivtx) const
UInt_t const	GTruthToVertex (const UInt_t &ivtx) const
const vector< UInt_t > *	VertexToG4Particles (const UInt_t &ivtx) const
const vector< UInt_t > *	G4ParticleToVertices (const UInt_t &ig4p) const
UInt_t const	VeeToGTruth (const UInt_t &ivee) const
UInt_t const	GTruthToVee (const UInt_t &ivee) const
const vector< UInt_t > *	VeeToG4Particles (const UInt_t &ivee) const
UInt_t const	G4ParticleToVee (const UInt_t &ig4p) const
const vector< UInt_t > *	TrackToVertices (const UInt_t &itrk) const
const vector< UInt_t > *	VertexToTracks (const UInt_t &ivtx) const
const vector< UInt_t > *	TrackToVees (const UInt_t &itrk) const
const vector< UInt_t > *	VeeToTracks (const UInt_t &ivee) const
const vector< UInt_t > *	TrackToCalClusters (const UInt_t &itrk) const
const vector< UInt_t > *	CalClusterToTracks (const UInt_t &itrk) const
const vector< UInt_t > *	G4PToCalClusters (const UInt_t &itrk) const
const vector< UInt_t > *	CalClusterToG4Ps (const UInt_t &itrk) const

Public Attributes
float	ASSN_THRESHOLD = 0.5
	fraction of total associated energy contributed to reco object a particle must constitute to be considered associated More...

Private Member Functions
template<class T >
bool	CheckRange (const map< UInt_t, T > &m, const UInt_t &i) const
void	Clear ()

Private Attributes
const TreeManager *	fTM = nullptr
G4Tree *	g4 = nullptr
RecoTree *	rec = nullptr
map< UInt_t, vector< UInt_t > >	fGTruthToG4Particles
map< UInt_t, UInt_t >	fG4ParticleToGTruth
map< UInt_t, vector< UInt_t > >	fGTruthToTracks
map< UInt_t, UInt_t >	fTrackToGTruth
map< UInt_t, vector< UInt_t > >	fTrackToG4Particles
map< UInt_t, UInt_t >	fTrackToG4Particle
map< UInt_t, vector< UInt_t > >	fG4ParticleToTracks
map< UInt_t, vector< UInt_t > >	fG4ParticleToVertices
map< UInt_t, vector< UInt_t > >	fVertexToG4Particles
map< UInt_t, UInt_t >	fVertexToGTruth
map< UInt_t, UInt_t >	fGTruthToVertex
map< UInt_t, vector< UInt_t > >	fVeeToG4Particles
map< UInt_t, UInt_t >	fG4ParticleToVee
map< UInt_t, UInt_t >	fVeeToGTruth
map< UInt_t, UInt_t >	fGTruthToVee
map< UInt_t, vector< UInt_t > >	fTrackToVertices
map< UInt_t, vector< UInt_t > >	fVertexToTracks
map< UInt_t, vector< UInt_t > >	fVeeToTracks
map< UInt_t, vector< UInt_t > >	fTrackToVees
map< UInt_t, vector< UInt_t > >	fCaloClusterToTracks
map< UInt_t, vector< UInt_t > >	fTrackToCaloClusters
map< UInt_t, vector< UInt_t > >	fCaloClusterToG4Ps
map< UInt_t, vector< UInt_t > >	fG4PToCaloClusters

Detailed Description

Definition at line 30 of file Backtracker.h.

Constructor & Destructor Documentation

garana::Backtracker::Backtracker ( )

inline

Definition at line 33 of file Backtracker.h.

{}

garana::Backtracker::Backtracker ( const TreeManager *  tm )

inline

Definition at line 34 of file Backtracker.h.

: fTM(tm) {}

Member Function Documentation

const vector< UInt_t > * Backtracker::CalClusterToG4Ps

(

const UInt_t &

itrk

)

const

Definition at line 232 of file Backtracker.cxx.

                                                                                {
        if(CheckRange(fCaloClusterToG4Ps, icluster)) {
                return &fCaloClusterToG4Ps.at(icluster);
        }
        else {
                return new vector<UInt_t>();
        }
}//

const vector< UInt_t > * Backtracker::CalClusterToTracks

(

const UInt_t &

itrk

)

const

Definition at line 214 of file Backtracker.cxx.

                                                                                   {
        if(CheckRange(fCaloClusterToTracks, icluster)) {
                return &fCaloClusterToTracks.at(icluster);
        }
        else {
                return new vector<UInt_t>();
        }
}//

template<class T >

bool Backtracker::CheckRange ( const map< UInt_t, T > &  m, const UInt_t &  i  ) const

private

Definition at line 415 of file Backtracker.cxx.

                                                                          {

        try {
                if(m.find(i)==m.end())
                        throw(i);
                return true;
        }
        catch(UInt_t i){
                //cerr << "ERROR Backtracker: map index not found" << endl;
                return false;
        }
}

void Backtracker::Clear ( )

private

Definition at line 428 of file Backtracker.cxx.

                        {

    //gen = nullptr;
    g4  = nullptr;
    //det = nullptr;
    rec = nullptr;

    fGTruthToG4Particles.clear();
    fG4ParticleToGTruth.clear();
    fGTruthToTracks.clear();
    fTrackToGTruth.clear();
    fTrackToG4Particles.clear();
    fTrackToG4Particle.clear();
    fG4ParticleToTracks.clear();
    //fFSParticleToG4Particles.clear();
    //fG4ParticleToFSParticle.clear();
    fVertexToGTruth.clear();
    fGTruthToVertex.clear();
    fG4ParticleToVertices.clear();
    fVertexToG4Particles.clear();
    fVertexToGTruth.clear();
    fGTruthToVertex.clear();
    fVeeToG4Particles.clear();
    fG4ParticleToVee.clear();
    fVeeToGTruth.clear();
    fGTruthToVee.clear();
    fTrackToVertices.clear();
    fVertexToTracks.clear();
    fVeeToTracks.clear();
    fTrackToVees.clear();
    fCaloClusterToTracks.clear();
    fTrackToCaloClusters.clear();
    fCaloClusterToG4Ps.clear();
    fG4PToCaloClusters.clear();
}

void Backtracker::FillMaps

(

)

Definition at line 242 of file Backtracker.cxx.

                           {

    //cout << "In FillMaps..." << endl;
    Clear();
    //GenTree*  gen = nullptr;
    //g4  = nullptr;
    //DetTree*  det = nullptr;
    //rec = nullptr;

    //cout << "get trees" << endl;
    //if(fTM->IsActiveGenTree())  gen = fTM->GetGenTree();
    if(fTM->IsActiveG4Tree())   g4  = fTM->GetG4Tree();
    //if(fTM->IsActiveDetTree())  det = fTM->GetDetTree();
    if(fTM->IsActiveRecTree())  rec = fTM->GetRecoTree();

    //cout << "checking which are active..." << endl;
    if(fTM->IsActiveG4Tree()){
        //cout << "g4Tree is active" << endl;

        for(UInt_t ig4p=0; ig4p<g4->NSim(); ig4p++) {
                fG4ParticleToTracks[ig4p] = {};
        }

        if(fTM->IsActiveRecTree()){
            //cout << "recoTree is active" << endl;
            for(UInt_t itrk = 0; itrk<rec->NTrack(); itrk++ ) {

                //if(rec->TrackMaxDepositFrac(itrk)<ASSN_THRESHOLD) continue;

                //vector<UInt_t> tmpindices;
                //cout << "call GetTrackG4PIndices" << endl;
                rec->GetTrackG4PIndices(itrk, fTrackToG4Particles[itrk]);
                //cout << "get match ID" << endl;
                int matchid = rec->TrackTrkIdMaxDeposit(itrk);
                //cout << "track matched to " << fTrackToG4Particles[itrk].size() << " G4 particle(s)" << endl;

                //cout << "point i" << endl;
                if(rec->TrackMaxDepositFrac(itrk)<ASSN_THRESHOLD) {
                    //cout << "track deposit fraction too low (" << rec->TrackMaxDepositFrac(itrk)
                    //     << ")...skipping to next track" << endl;
                        continue;
                }//should this be considered an association?

                //cout << "point ii" << endl;
                for(UInt_t ig4p=0; ig4p<fTrackToG4Particles[itrk].size(); ig4p++){
                        //for(UInt_t ig4p=0; ig4p<tmpindices.size(); ig4p++){

                        if(fG4ParticleToTracks.find(fTrackToG4Particles[itrk][ig4p]) != fG4ParticleToTracks.end()) {

                                //fTrackToG4Particles[itrk][ig4p] = tmpindices[ig4p];
                                //if(fG4ParticleToTracks.find(tmpindices[ig4p]) != fG4ParticleToTracks.end() &&  //){
                                //if(g4->TrackID(tmpindices[ig4p]) == matchid ) {
                        if(g4->TrackID(fTrackToG4Particles[itrk][ig4p]) == matchid ) {
                                //cout << "found match id" << endl;
                                fTrackToG4Particle[itrk] = ig4p;
                                fG4ParticleToTracks[ig4p].push_back(itrk);
                                break;
                        } //if match id matches g4particle ID
                        }//if G4Particle index is in map
                }//for all matched particles to this track

                //cout << "point iii" << endl;
               // for(UInt_t ig4p=0; ig4p<g4->NSim(); ig4p++) {
               //     if(fG4ParticleToTracks[ig4p].size() == 0) continue;
               //     cout << "G4particle " << ig4p << " matched to " << fG4ParticleToTracks[ig4p].size()
               //          << " reco track(s)" << endl;
               // }//for all g4Particles
            }//for tracks
        }//if recoTree active
    }//if g4Tree active

    //cout << "point 1" << endl;

    if(fTM->IsActiveGenTree()){

     //   cout << "genTree is active" << endl;

        if(fTM->IsActiveG4Tree()){

            //G4 particles
            for(UInt_t ig4 = 0; ig4<g4->NSim(); ig4++ ) {
                fG4ParticleToGTruth[ig4] = g4->GetTruthIndex(ig4);
                fGTruthToG4Particles[ fG4ParticleToGTruth[ig4] ].push_back(ig4);
            
                //fG4ParticleToFSParticle[ig4]  //map< UInt_t, UInt_t >
                //fFSParticleToG4Particles //map< UInt_t, vector<UInt_t> >
            
            }//endfor g4 particles
        }//endif g4tree

       // cout << "point 2" << endl;

        if(fTM->IsActiveRecTree()){

            //tracks
            for(UInt_t itrk=0; itrk<rec->NTrack(); itrk++ ) {
         //       cout << "point 2i" << endl;
                //cout << "fTrackToG4Particles[itrk][0] = " << fTrackToG4Particles[itrk][0] << endl;
                //cout << "fG4ParticleToGTruth[ fTrackToG4Particles[itrk][0] ] = " << fG4ParticleToGTruth[ fTrackToG4Particles[itrk][0] ] << endl;
                if(fTrackToG4Particles[itrk].size()==0) continue;
                fTrackToGTruth[itrk] = fG4ParticleToGTruth[ fTrackToG4Particles[itrk][0] ]; //TODO select truth with most associated energy
           //     cout << "point 2ii" << endl;
                fGTruthToTracks[ fTrackToGTruth[itrk] ].push_back(itrk);
             //   cout << "point 2iii" << endl;
            }//endfor tracks

           // cout << "point 2a" << endl;

            //vertices
            for(UInt_t ivtx=0; ivtx<rec->NVertex(); ivtx++ ) {
                rec->GetVertexTrackIndices(ivtx,fVertexToTracks[ivtx]);
                for(UInt_t itrk=0; itrk<fVertexToTracks[ivtx].size(); itrk++) {
                    fTrackToVertices[ fVertexToTracks[ivtx][itrk] ].push_back(ivtx);

                    for(UInt_t ig4p=0; ig4p<fTrackToG4Particles[fVertexToTracks[ivtx][itrk]].size(); ig4p++) {
                        fVertexToG4Particles[ivtx].push_back( fTrackToG4Particles[ fVertexToTracks[ivtx][itrk] ][ig4p] );
                        fG4ParticleToVertices[ fVertexToG4Particles[ivtx].back() ].push_back(ivtx);
                    }// for g4Particles
                }// for tracks
             //       cout << "point 2b" << endl;
                fVertexToGTruth[ivtx] = fTrackToGTruth[ fVertexToTracks[ivtx][0] ];//TODO you sure all tracks associated with vertex associated with same GTruth?
                fGTruthToVertex[ fVertexToGTruth[ivtx] ] = ivtx;
            }//endfor vertices

           // cout << "point 3" << endl;

            //vees
            for(UInt_t ivee=0; ivee<rec->NVee(); ivee++){
            
                rec->GetVeeTrackIndices(ivee, fVeeToTracks[ivee]);
            
                for(UInt_t itrk=0; itrk<fVeeToTracks[ivee].size(); itrk++){
            
                    fTrackToVees[ fVeeToTracks[ivee][itrk] ].push_back(ivee);
            
                for(UInt_t ig4p=0; ig4p<fTrackToG4Particles[ fVeeToTracks[ivee][itrk] ].size(); ig4p++) {
                    fVeeToG4Particles[ivee].push_back(fTrackToG4Particles[ fVeeToTracks[ivee][itrk] ][ig4p]);
                    fG4ParticleToVee[fVeeToG4Particles[ivee].back()] = ivee;
                }
                }// for tracks
            
                fVeeToGTruth[ivee] = fTrackToGTruth[ fVeeToTracks[ivee][0] ];//TODO you sure all tracks associated with vee associated with same GTruth?
                fGTruthToVee[ fVeeToGTruth[ivee] ] = ivee;
            }//endfor vees

          // cout << "point 4" << endl;

            //ECal clusters
            for(UInt_t iclust=0; iclust<rec->NCalCluster(); iclust++){

                rec->GetCalClusterTrackIndices(iclust,fCaloClusterToTracks[iclust]);

                for(UInt_t itrk=0; itrk<fCaloClusterToTracks[iclust].size(); itrk++){
                    fTrackToCaloClusters[ fCaloClusterToTracks[iclust][itrk] ].push_back(iclust);
                }

                rec->GetCalClusterG4Indices(iclust,fCaloClusterToG4Ps[iclust]);

                for(UInt_t ig4p=0; ig4p<fCaloClusterToG4Ps[iclust].size(); ig4p++){
                    fG4PToCaloClusters[ fCaloClusterToG4Ps[iclust][ig4p] ].push_back(iclust);
                }
            }//for clusters

         //   cout << "point 5" << endl;

        }//endif recotree
    }//if gentree

    //cout << "at end of FillMaps()" << endl;

}//end FillMaps()

UInt_t const Backtracker::G4ParticleToGTruth

(

const UInt_t &

ig4p

)

const

Definition at line 32 of file Backtracker.cxx.

                                                                     {

        if(CheckRange(fG4ParticleToGTruth, ig4p)) {
                return fG4ParticleToGTruth.at(ig4p);
        }
        else {
                return UINT_MAX;
        }
}

const vector< UInt_t > * Backtracker::G4ParticleToTracks

(

const UInt_t &

ig4p

)

const

Definition at line 42 of file Backtracker.cxx.

                                                                              {

        if(CheckRange(fG4ParticleToTracks, ig4p)) {
                return &fG4ParticleToTracks.at(ig4p);
    }
        else {
                return new vector<UInt_t>();
        }
}

UInt_t const Backtracker::G4ParticleToVee

(

const UInt_t &

ig4p

)

const

Definition at line 168 of file Backtracker.cxx.

                                                                  {
        return fG4ParticleToVee.at(ig4p);
}

const vector< UInt_t > * Backtracker::G4ParticleToVertices

(

const UInt_t &

ig4p

)

const

Definition at line 145 of file Backtracker.cxx.

                                                                                 {
        if(CheckRange(fG4ParticleToVertices, ig4p)) {
                return &fG4ParticleToVertices.at(ig4p);
        }
        else {
                return new vector<UInt_t>();
        }
}

const vector< UInt_t > * Backtracker::G4PToCalClusters

(

const UInt_t &

itrk

)

const

Definition at line 223 of file Backtracker.cxx.

                                                                            {
        if(CheckRange(fG4PToCaloClusters, ig4p)) {
                return &fG4PToCaloClusters.at(ig4p);
        }
        else {
                return new vector<UInt_t>();
        }
}//

const vector< UInt_t > * Backtracker::GTruthToG4Particles

(

const UInt_t &

itruth

)

const

Definition at line 13 of file Backtracker.cxx.

                                                                                 {
        if(CheckRange(fGTruthToG4Particles, itruth)) {
                return &fGTruthToG4Particles.at(itruth);
        }
        else {
                return new vector<UInt_t>();
        }
}

const vector< UInt_t > * Backtracker::GTruthToTracks

(

const UInt_t &

itruth

)

const

Definition at line 21 of file Backtracker.cxx.

                                                                            {
        if(CheckRange(fGTruthToTracks, itruth)) {
                return &fGTruthToTracks.at(itruth);
        }
        else {
                return new vector<UInt_t>();
        }
}

UInt_t const Backtracker::GTruthToVee

(

const UInt_t &

ivee

)

const

Definition at line 157 of file Backtracker.cxx.

                                                                {
        return fGTruthToVee.at(itruth);
}

UInt_t const Backtracker::GTruthToVertex

(

const UInt_t &

ivtx

)

const

Definition at line 127 of file Backtracker.cxx.

                                                                   {
        if(CheckRange(fGTruthToVertex, itruth)) {
                return fGTruthToVertex.at(itruth);
        }
        else {
                return UINT_MAX;
        }
}

const vector< UInt_t > * Backtracker::TrackToCalClusters

(

const UInt_t &

itrk

)

const

Definition at line 205 of file Backtracker.cxx.

                                                                               {
        if(CheckRange(fTrackToCaloClusters, itrk)) {
                return &fTrackToCaloClusters.at(itrk);
        }
        else {
                return new vector<UInt_t>();
        }
}

UInt_t const Backtracker::TrackToG4Particle

(

const UInt_t &

itrk

)

const

Definition at line 94 of file Backtracker.cxx.

                                                                    {
        if(CheckRange(fTrackToG4Particle, itrk)) {
                return fTrackToG4Particle.at(itrk);
        }
        else {
                return UINT_MAX;
        }
}

const pair< UInt_t, float > Backtracker::TrackToG4ParticleDeposit

(

const UInt_t &

itrk

)

const

Definition at line 103 of file Backtracker.cxx.

                                                                                           {

        int trkidMax = rec->TrackTrkIdMaxDeposit(itrk);
        auto ig4ps =  TrackToG4Particles(itrk);
        map<int,UInt_t> trackIdToig4; // Geant4 trackID to G4Particle index

        for(auto const& ig4p : *ig4ps){
                trackIdToig4[g4->TrackID(ig4p)] = ig4p;
        }

        const pair<UInt_t,float> outpair(trackIdToig4[trkidMax],rec->TrackMaxDeposit(itrk));
        return outpair;

}

const vector< UInt_t > * Backtracker::TrackToG4Particles

(

const UInt_t &

itrk

)

const

Definition at line 65 of file Backtracker.cxx.

                                                                              {
        if(CheckRange(fTrackToG4Particles, itrk)) {
                return &fTrackToG4Particles.at(itrk);
        }
        else {
                return new vector<UInt_t>();
        }
}

const vector< pair< UInt_t, float > > Backtracker::TrackToG4ParticlesDeposits

(

const UInt_t &

itrk

)

const

Definition at line 74 of file Backtracker.cxx.

                                                                                                    {

        vector<pair<UInt_t,float>> outvec;
        auto ig4ps =  TrackToG4Particles(itrk);
        auto iddeps = rec->TrackTrueDeposits(itrk);

        map<int,UInt_t> trackIdToig4; // Geant4 trackID to G4Particle index
        for(auto const& ig4p : *ig4ps){
                trackIdToig4[g4->TrackID(ig4p)] = ig4p;
        }


        for( auto const& iddep : *iddeps) {
                outvec.push_back(make_pair(trackIdToig4[iddep.first],iddep.second));
        }

        return outvec;

}

UInt_t const Backtracker::TrackToGTruth

(

const UInt_t &

itrk

)

const

Definition at line 55 of file Backtracker.cxx.

                                                                {

        if(CheckRange(fTrackToGTruth, itrk)) {
                return fTrackToGTruth.at(itrk);
        }
        else {
                return UINT_MAX;
        }
}

const vector< UInt_t > * Backtracker::TrackToVees

(

const UInt_t &

itrk

)

const

Definition at line 188 of file Backtracker.cxx.

                                                                       {
        if(CheckRange(fTrackToVees, itrk)) {
                return &fTrackToVees.at(itrk);
        }
        else {
                return new vector<UInt_t>();
        }
}

const vector< UInt_t > * Backtracker::TrackToVertices

(

const UInt_t &

itrk

)

const

Definition at line 172 of file Backtracker.cxx.

                                                                           {
        if(CheckRange(fTrackToVertices, itrk)) {
                return &fTrackToVertices.at(itrk);
        }
        else {
                return new vector<UInt_t>();
        }
}

const vector< UInt_t > * Backtracker::VeeToG4Particles

(

const UInt_t &

ivee

)

const

Definition at line 160 of file Backtracker.cxx.

                                                                            {
        if(CheckRange(fVeeToG4Particles, ivee)) {
                return &fVeeToG4Particles.at(ivee);
        }
        else {
                return new vector<UInt_t>();
        }
}

UInt_t const Backtracker::VeeToGTruth

(

const UInt_t &

ivee

)

const

Definition at line 154 of file Backtracker.cxx.

                                                              {
        return fVeeToGTruth.at(ivee);
}

const vector< UInt_t > * Backtracker::VeeToTracks

(

const UInt_t &

ivee

)

const

Definition at line 196 of file Backtracker.cxx.

                                                                       {
        if(CheckRange(fVeeToTracks, ivee)) {
                return &fVeeToTracks.at(ivee);
        }
        else {
                return new vector<UInt_t>();
        }
}

const vector< UInt_t > * Backtracker::VertexToG4Particles

(

const UInt_t &

ivtx

)

const

Definition at line 136 of file Backtracker.cxx.

                                                                               {
        if(CheckRange(fVertexToG4Particles, ivtx)) {
                return &fVertexToG4Particles.at(ivtx);
        }
        else {
                return new vector<UInt_t>();
        }
}

UInt_t const Backtracker::VertexToGTruth

(

const UInt_t &

ivtx

)

const

Definition at line 118 of file Backtracker.cxx.

                                                                 {
        if(CheckRange(fVertexToGTruth, ivtx)) {
                return fVertexToGTruth.at(ivtx);
        }
        else {
                return UINT_MAX;
        }
}

const vector< UInt_t > * Backtracker::VertexToTracks

(

const UInt_t &

ivtx

)

const

Definition at line 180 of file Backtracker.cxx.

                                                                          {
        if(CheckRange(fVertexToTracks, ivtx)) {
                return &fVertexToTracks.at(ivtx);
        }
        else {
                return new vector<UInt_t>();
        }
}

Member Data Documentation

float garana::Backtracker::ASSN_THRESHOLD = 0.5

fraction of total associated energy contributed to reco object a particle must constitute to be considered associated

Definition at line 70 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fCaloClusterToG4Ps

private

Definition at line 108 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fCaloClusterToTracks

private

Definition at line 106 of file Backtracker.h.

map< UInt_t, UInt_t > garana::Backtracker::fG4ParticleToGTruth

private

Definition at line 84 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fG4ParticleToTracks

private

Definition at line 89 of file Backtracker.h.

map< UInt_t, UInt_t > garana::Backtracker::fG4ParticleToVee

private

Definition at line 98 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fG4ParticleToVertices

private

Definition at line 93 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fG4PToCaloClusters

private

Definition at line 109 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fGTruthToG4Particles

private

Definition at line 83 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fGTruthToTracks

private

Definition at line 85 of file Backtracker.h.

map< UInt_t, UInt_t > garana::Backtracker::fGTruthToVee

private

Definition at line 100 of file Backtracker.h.

map< UInt_t, UInt_t > garana::Backtracker::fGTruthToVertex

private

Definition at line 96 of file Backtracker.h.

const TreeManager* garana::Backtracker::fTM = nullptr

private

Definition at line 74 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fTrackToCaloClusters

private

Definition at line 107 of file Backtracker.h.

map< UInt_t, UInt_t > garana::Backtracker::fTrackToG4Particle

private

Definition at line 88 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fTrackToG4Particles

private

Definition at line 87 of file Backtracker.h.

map< UInt_t, UInt_t > garana::Backtracker::fTrackToGTruth

private

Definition at line 86 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fTrackToVees

private

Definition at line 105 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fTrackToVertices

private

Definition at line 102 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fVeeToG4Particles

private

Definition at line 97 of file Backtracker.h.

map< UInt_t, UInt_t> garana::Backtracker::fVeeToGTruth

private

Definition at line 99 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fVeeToTracks

private

Definition at line 104 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fVertexToG4Particles

private

Definition at line 94 of file Backtracker.h.

map< UInt_t, UInt_t > garana::Backtracker::fVertexToGTruth

private

Definition at line 95 of file Backtracker.h.

map< UInt_t, vector<UInt_t> > garana::Backtracker::fVertexToTracks

private

Definition at line 103 of file Backtracker.h.

G4Tree* garana::Backtracker::g4 = nullptr

private

Definition at line 76 of file Backtracker.h.

RecoTree* garana::Backtracker::rec = nullptr

private

Definition at line 78 of file Backtracker.h.

---

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

• garana/garana/Utility/Backtracker.h
• garana/garana/Utility/Backtracker.cxx