d8/d86/FillTrue_8cxx_source.html

 #include "FillTrue.h"


 #include "larcorealg/GeoAlgo/GeoAlgo.h"

 #include "RecoUtils/RecoUtils.h"


 #include <functional>

 #include <algorithm>


 // helper function declarations


 caf::SRTrackTruth MatchTrack2Truth(const detinfo::DetectorClocksData &clockData, const std::vector<caf::SRTrueParticle> &particles, const std::vector<art::Ptr<recob::Hit>> &hits,

                                    const std::map<int, caf::HitsEnergy> &all_hits_map);


 caf::SRTruthMatch MatchSlice2Truth(const std::vector<art::Ptr<recob::Hit>> &hits,

                                    const std::vector<art::Ptr<simb::MCTruth>> &neutrinos,

                                    const caf::SRTruthBranch &srtruth,

                                    const cheat::ParticleInventoryService &inventory_service,

                                    const detinfo::DetectorClocksData &clockData);


 float ContainedLength(const TVector3 &v0, const TVector3 &v1,

                       const std::vector<geoalgo::AABox> &boxes);


 bool FRFillNumuCC(const simb::MCTruth &mctruth,

                   const std::vector<art::Ptr<sim::MCTrack>> &mctracks,

                   const std::vector<geo::BoxBoundedGeo> &volumes,

                   TRandom &rand,

                   caf::SRFakeReco &fakereco);

 bool FRFillNueCC(const simb::MCTruth &mctruth,

                   const std::vector<caf::SRTrueParticle> &srparticle,

                   const std::vector<geo::BoxBoundedGeo> &volumes,

                   TRandom &rand,

                   caf::SRFakeReco &fakereco);


 // helper function definitions


 bool isFromNuVertex(const simb::MCTruth& mc, const sim::MCTrack& track,

                     float distance=5.0) {

   TVector3 nuVtx = mc.GetNeutrino().Nu().Trajectory().Position(0).Vect();

   TVector3 trkStart = track.Start().Position().Vect();

   return (trkStart - nuVtx).Mag() < distance;

 }


 // returns particle mass in MeV

 double PDGMass(int pdg) {

   const TDatabasePDG *PDGTable = TDatabasePDG::Instance();

   // regular particle

   if (pdg < 1000000000) {

     TParticlePDG* ple = PDGTable->GetParticle(pdg);

     if (ple == NULL) return -1;

     return ple->Mass() * 1000.0;

   }

   // ion

   else {

     int p = (pdg % 10000000) / 10000;

     int n = (pdg % 10000) / 10 - p;

     return (PDGTable->GetParticle(2212)->Mass() * p +

             PDGTable->GetParticle(2112)->Mass() * n) * 1000.0;

   }

 }


 double SmearLepton(const caf::SRTrueParticle &lepton, TRandom& rand) {

   const double smearing = 0.15;

   // Oscillation tech note says smear ionization deposition, but

   // code in old samples seems to use true energy.

   const double true_E = lepton.plane[0][2].visE + lepton.plane[1][2].visE;

   const double smeared_E = rand.Gaus(true_E, smearing * true_E / std::sqrt(true_E));

   return std::max(smeared_E, 0.0);

 }


 double SmearHadron(const caf::SRTrueParticle &hadron, TRandom& rand) {

   const double smearing = 0.05;

   const double true_E = hadron.startE - PDGMass(hadron.pdg) / 1000;

   const double smeared_E = rand.Gaus(true_E, smearing * true_E);

   return std::max(smeared_E, 0.0);

 }


 //......................................................................

 void CopyTMatrixDToVector(const TMatrixD& m, std::vector<float>& v)

 {

   const double& start = m(0, 0);

   v.insert(v.end(), &start, &start + m.GetNoElements());

 }


 namespace caf {


   //------------------------------------------------


   void FillSRGlobal(const sbn::evwgh::EventWeightParameterSet& pset,

                     caf::SRGlobal& srglobal,

                     std::map<std::string, unsigned int>& weightPSetIndex)

   {

     SRWeightPSet& cafpset = srglobal.wgts.emplace_back();


     cafpset.name = pset.fName;

     cafpset.type = caf::ReweightType_t(pset.fRWType);

     cafpset.nuniv = pset.fNuniverses;

     if(pset.fCovarianceMatrix) CopyTMatrixDToVector(*pset.fCovarianceMatrix, cafpset.covmx);


     weightPSetIndex[cafpset.name] = srglobal.wgts.size()-1;


     for(const auto& it: pset.fParameterMap){

       const sbn::evwgh::EventWeightParameter& param = it.first;

       const std::vector<float>& vals = it.second;


       SRWeightParam cafparam;

       cafparam.name = param.fName;

       cafparam.mean = param.fMean;

       cafparam.width = param.fWidth;

       cafparam.covidx = param.fCovIndex;


       cafpset.map.emplace_back(cafparam, vals);

     } // end for it

   }


   //------------------------------------------------


   void FillTrackTruth(const std::vector<art::Ptr<recob::Hit>> &hits,

                       const std::map<int, caf::HitsEnergy> &id_hits_map,

                       const std::vector<caf::SRTrueParticle> &particles,

                       const detinfo::DetectorClocksData &clockData,

                       caf::SRTrack& srtrack,

                       bool allowEmpty)

   {

     // Truth matching

     srtrack.truth = MatchTrack2Truth(clockData, particles, hits, id_hits_map);


   }//FillTrackTruth


   //------------------------------------------------


   // TODO: write trith matching for shower. Currently uses track truth matching

   // N.B. this will only work if showers are rolled up

   void FillShowerTruth(const std::vector<art::Ptr<recob::Hit>> &hits,

                        const std::map<int, caf::HitsEnergy> &id_hits_map,

                        const std::vector<caf::SRTrueParticle> &particles,

                        const detinfo::DetectorClocksData &clockData,

                        caf::SRShower& srshower,

                        bool allowEmpty)

   {

     // Truth matching

     srshower.truth = MatchTrack2Truth(clockData, particles, hits, id_hits_map);


   }//FillShowerTruth


   void FillStubTruth(const std::vector<art::Ptr<recob::Hit>> &hits,

                      const std::map<int, caf::HitsEnergy> &id_hits_map,

                      const std::vector<caf::SRTrueParticle> &particles,

                      const detinfo::DetectorClocksData &clockData,

                      caf::SRStub& srstub,

                      bool allowEmpty)

   {

     srstub.truth = MatchTrack2Truth(clockData, particles, hits, id_hits_map);

   }


   //------------------------------------------------


   void FillSliceTruth(const std::vector<art::Ptr<recob::Hit>> &hits,

                       const std::vector<art::Ptr<simb::MCTruth>> &neutrinos,

                       const caf::SRTruthBranch &srmc,

                       const cheat::ParticleInventoryService &inventory_service,

                       const detinfo::DetectorClocksData &clockData,

                       caf::SRSlice &srslice,

                       bool allowEmpty)

   {


     caf::SRTruthMatch tmatch = MatchSlice2Truth(hits, neutrinos, srmc, inventory_service, clockData);


     if (tmatch.index >= 0) {

       srslice.truth = srmc.nu[tmatch.index];

       srslice.tmatch = tmatch;

     }


     std::cout << "Slice matched to index: " << tmatch.index

         << " with match frac: " << tmatch.pur << std::endl;


   }//FillSliceTruth


  void FillMeVPrtlTruth(const evgen::ldm::MeVPrtlTruth &truth,

                        const std::vector<geo::BoxBoundedGeo> &active_volumes,

                        caf::SRMeVPrtl &srtruth) {

    // Fill stuff!!

    srtruth.position.x = truth.decay_pos.X();

    srtruth.position.y = truth.decay_pos.Y();

    srtruth.position.z = truth.decay_pos.Z();

    srtruth.time = truth.decay_pos.T();


    srtruth.momentum.x = truth.mevprtl_mom.X();

    srtruth.momentum.y = truth.mevprtl_mom.Y();

    srtruth.momentum.z = truth.mevprtl_mom.Z();

    srtruth.E     = truth.mevprtl_mom.E();


     // Set the cryostat of the position

     for (int icryo = 0; icryo < (int)active_volumes.size(); icryo++) {

       if (active_volumes[icryo].ContainsPosition(truth.decay_pos.Vect())) {

         srtruth.cryostat = icryo;

         break;

       }

     }


    srtruth.M = truth.mass;

    srtruth.flux_weight = truth.flux_weight;

    srtruth.ray_weight = truth.ray_weight;

    srtruth.decay_weight = truth.decay_weight;

    srtruth.decay_length = truth.mean_distance;


    srtruth.enter.x = truth.mevprtl_enter.X();

    srtruth.enter.y = truth.mevprtl_enter.Y();

    srtruth.enter.z = truth.mevprtl_enter.Z();

    srtruth.exit.x = truth.mevprtl_exit.X();

    srtruth.exit.y = truth.mevprtl_exit.Y();

    srtruth.exit.z = truth.mevprtl_exit.Z();

    srtruth.start.x = truth.mevprtl_start.X();

    srtruth.start.y = truth.mevprtl_start.Y();

    srtruth.start.z = truth.mevprtl_start.Z();


    srtruth.C1 = truth.C1;

    srtruth.C2 = truth.C2;

    srtruth.C3 = truth.C3;

    srtruth.C4 = truth.C4;

    srtruth.C5 = truth.C5;


    switch(truth.gen) {

      case evgen::ldm::kDissonantHiggs:

        srtruth.gen = caf::kMeVPrtlHiggs;

        break;

      case evgen::ldm::kHNL:

        srtruth.gen = caf::kMeVPrtlHNL;

        break;

      default:

        break;

    }

  }


  void FillSliceFakeReco(const std::vector<art::Ptr<recob::Hit>> &hits,

                          const std::vector<art::Ptr<simb::MCTruth>> &neutrinos,

                          const caf::SRTruthBranch &srmc,

                          const cheat::ParticleInventoryService &inventory_service,

                          const detinfo::DetectorClocksData &clockData,

                          caf::SRSlice &srslice,

                          const std::vector<caf::SRTrueParticle> &srparticles,

                          const std::vector<art::Ptr<sim::MCTrack>> &mctracks,

                          const std::vector<geo::BoxBoundedGeo> &volumes, TRandom &rand)

   {

     caf::SRTruthMatch tmatch = MatchSlice2Truth(hits, neutrinos, srmc, inventory_service, clockData);

     if(tmatch.index >= 0) {

       FRFillNumuCC(*neutrinos[tmatch.index], mctracks, volumes, rand, srslice.fake_reco);

       if(!srslice.fake_reco.filled)

         FRFillNueCC(*neutrinos[tmatch.index], srparticles, volumes, rand, srslice.fake_reco);

     }

   }//FillSliceFakeReco


   //------------------------------------------------

   void FillTrueNeutrino(const art::Ptr<simb::MCTruth> mctruth,

       const simb::MCFlux &mcflux,

       const simb::GTruth& gtruth,

       const std::vector<caf::SRTrueParticle> &srparticles,

       const std::map<int, std::vector<art::Ptr<recob::Hit>>> &id_to_truehit_map,

       caf::SRTrueInteraction &srneutrino, size_t i,

       const std::vector<geo::BoxBoundedGeo> &active_volumes) {


     srneutrino.index = i;


     for (int c = 0; c < 2; c++) {

       SRTrueInteractionPlaneInfo init;

       init.visE = 0.;

       init.nhit = 0;

       init.nhitprim = 0;


       for (int p = 0; p < 3; p++) {

         srneutrino.plane[c][p] = init;

       }

     }


     for(const caf::SRTrueParticle& part: srparticles){

       // save the G4 particles that came from this interaction

       if(part.interaction_id == (int)i) {

         if(part.start_process == caf::kG4primary) srneutrino.prim.push_back(part);


         // total up the deposited energy

         for(int p = 0; p < 3; ++p) {

           for (int i_cryo = 0; i_cryo < 2; i_cryo++) {

             srneutrino.plane[i_cryo][p].visE += part.plane[i_cryo][p].visE;

           }

         }

       }

     }

     srneutrino.nprim = srneutrino.prim.size();


     // Set of hits per-plane: primary particles

     {

       std::vector<std::array<std::set<unsigned>, 3>> planehitIDs(2);

       for (unsigned i_part = 0; i_part < srparticles.size(); i_part++) {

         if (srparticles[i_part].start_process == caf::kG4primary && srparticles[i_part].interaction_id == (int)i) {

           int track_id = srparticles[i_part].G4ID;

           // Look for hits

           if (!id_to_truehit_map.count(track_id)) continue;

           for (const art::Ptr<recob::Hit> &h: id_to_truehit_map.at(track_id)) {

             if (!h->WireID()) continue;

             planehitIDs[h->WireID().Cryostat][h->WireID().Plane].insert(h.key());

           }

         }

       }


       for(int p = 0; p < 3; ++p) {

         for (int i_cryo = 0; i_cryo < 2; i_cryo++) {

           srneutrino.plane[i_cryo][p].nhitprim = planehitIDs[i_cryo][p].size();

         }

       }

     }


     // Set of hits per-plane: all particles

     {

       std::vector<std::array<std::set<unsigned>, 3>> planehitIDs(2);

       for (unsigned i_part = 0; i_part < srparticles.size(); i_part++) {

         if (srparticles[i_part].interaction_id == (int)i) {

           int track_id = srparticles[i_part].G4ID;

           // Look for hits

           if (!id_to_truehit_map.count(track_id)) continue;

           for (const art::Ptr<recob::Hit> &h: id_to_truehit_map.at(track_id)) {

             if (!h->WireID()) continue;

             planehitIDs[h->WireID().Cryostat][h->WireID().Plane].insert(h.key());

           }

         }

       }


       for(int p = 0; p < 3; ++p) {

         for (int i_cryo = 0; i_cryo < 2; i_cryo++) {

           srneutrino.plane[i_cryo][p].nhit = planehitIDs[i_cryo][p].size();

         }

       }

     }


     // Set the GTruth stuff

     srneutrino.npiplus = gtruth.fNumPiPlus;

     srneutrino.npiminus = gtruth.fNumPiMinus;

     srneutrino.npizero = gtruth.fNumPi0;

     srneutrino.nproton = gtruth.fNumProton;

     srneutrino.nneutron = gtruth.fNumNeutron;

     srneutrino.ischarm = gtruth.fIsCharm;

     srneutrino.isseaquark = gtruth.fIsSeaQuark;

     srneutrino.resnum = gtruth.fResNum;

     srneutrino.xsec = gtruth.fXsec;


     // Set the MCFlux stuff

     srneutrino.initpdg = mcflux.fntype;

     srneutrino.baseline = mcflux.fdk2gen + mcflux.fgen2vtx;

     srneutrino.parent_pdg = mcflux.fptype;

     srneutrino.parent_dcy_mode = mcflux.fndecay;

     srneutrino.prod_vtx.x = mcflux.fvx;

     srneutrino.prod_vtx.y = mcflux.fvy;

     srneutrino.prod_vtx.z = mcflux.fvz;

     srneutrino.parent_dcy_mom.x = mcflux.fpdpx;

     srneutrino.parent_dcy_mom.y = mcflux.fpdpy;

     srneutrino.parent_dcy_mom.z = mcflux.fpdpz;

     float Pmass = PDGMass(mcflux.fptype) / 1000.; // MeV -> GeV

     srneutrino.parent_dcy_E = sqrt(mcflux.fpdpx*mcflux.fpdpx + mcflux.fpdpy*mcflux.fpdpy + mcflux.fpdpz*mcflux.fpdpz + Pmass*Pmass);

     srneutrino.imp_weight = mcflux.fnimpwt;


     if (mctruth->NeutrinoSet()) {

       // Neutrino

       const simb::MCNeutrino& nu = mctruth->GetNeutrino();

       srneutrino.isnc =   nu.CCNC()  && (nu.Mode() != simb::kWeakMix);

       srneutrino.iscc = (!nu.CCNC()) && (nu.Mode() != simb::kWeakMix);

       srneutrino.pdg = nu.Nu().PdgCode();

       srneutrino.targetPDG = nu.Target();

       srneutrino.hitnuc = nu.HitNuc();

       srneutrino.genie_mode = (caf::genie_interaction_mode_)nu.Mode();

       srneutrino.genie_inttype = (caf::genie_interaction_type_)nu.InteractionType();

       srneutrino.bjorkenX = nu.X();

       srneutrino.inelasticityY = nu.Y();

       srneutrino.Q2 = nu.QSqr();

       srneutrino.w = nu.W();

       srneutrino.E = nu.Nu().EndMomentum().Energy();

       srneutrino.momentum = nu.Nu().EndMomentum().Vect();

       srneutrino.position = nu.Nu().Position().Vect();

       srneutrino.time = nu.Nu().Position().T() / 1000. /* ns -> us */;

       srneutrino.genweight = nu.Nu().Weight();


       const simb::MCParticle& lepton = nu.Lepton();

       TLorentzVector q_labframe;

       q_labframe = nu.Nu().EndMomentum() - lepton.Momentum(0);

       srneutrino.q0_lab = q_labframe.E();

       srneutrino.modq_lab = q_labframe.P();


       // make sure the lepton comes first in the list of prim

       for (unsigned i_part = 0; i_part < srneutrino.prim.size(); i_part++) {

         if (srneutrino.prim[i_part].pdg == lepton.PdgCode()) {

           // swap them

           caf::SRTrueParticle temp = srneutrino.prim[0];

           srneutrino.prim[0] = srneutrino.prim[i_part];

           srneutrino.prim[i_part] = temp;

           break;

         }

       }


       // Set the cryostat of the position

       for (int icryo = 0; icryo < 2; icryo++) {

         if (active_volumes[icryo].ContainsPosition(nu.Nu().Position().Vect())) {

           srneutrino.cryostat = icryo;

           break;

         }

       }

     }


   }


   //------------------------------------------------


   void FillEventWeight(const sbn::evwgh::EventWeightMap& wgtmap,

                        caf::SRTrueInteraction& srint,

                        const std::map<std::string, unsigned int>& weightPSetIndex)

   {

     for(auto& it: wgtmap){

       if(weightPSetIndex.count(it.first) == 0){

         std::cout << "CAFMaker: Unknown EventWeightMap name '" << it.first << "'" << std::endl;

         std::cout << "Known names from EventWeightParameterSet:" << std::endl;

         for(auto k: weightPSetIndex) std::cout << "  " << k.first << std::endl;

         abort();

       }


       const unsigned int idx = weightPSetIndex.at(it.first);

       if(idx >= srint.wgt.size()) srint.wgt.resize(idx+1);

       srint.wgt[idx].univ = it.second;

     }

   }


   //------------------------------------------------


   void FillTrueG4Particle(const simb::MCParticle &particle,

         const std::vector<geo::BoxBoundedGeo> &active_volumes,

         const std::vector<std::vector<geo::BoxBoundedGeo>> &tpc_volumes,

         const std::map<int, std::vector<std::pair<geo::WireID, const sim::IDE *>>> &id_to_ide_map,

         const std::map<int, std::vector<art::Ptr<recob::Hit>>> &id_to_truehit_map,

         const cheat::BackTrackerService &backtracker,

         const cheat::ParticleInventoryService &inventory_service,

         const std::vector<art::Ptr<simb::MCTruth>> &neutrinos,

                           caf::SRTrueParticle &srparticle) {


     std::vector<std::pair<geo::WireID, const sim::IDE *>> empty;

     const std::vector<std::pair<geo::WireID, const sim::IDE *>> &particle_ides = id_to_ide_map.count(particle.TrackId()) ? id_to_ide_map.at(particle.TrackId()) : empty;


     std::vector<art::Ptr<recob::Hit>> emptyHits;

     const std::vector<art::Ptr<recob::Hit>> &particle_hits = id_to_truehit_map.count(particle.TrackId()) ? id_to_truehit_map.at(particle.TrackId()) : emptyHits;


     srparticle.length = 0.;

     srparticle.crosses_tpc = false;

     srparticle.wallin = caf::kWallNone;

     srparticle.wallout = caf::kWallNone;


     for (unsigned c = 0; c < 2; c++) {

       SRTrueParticlePlaneInfo init;

       init.visE = 0.;

       init.nhit = 0;


       for (int p = 0; p < 3; p++) {

         srparticle.plane[c][p] = init;

       }

     }


     for (auto const &ide_pair: particle_ides) {

       const geo::WireID &w = ide_pair.first;

       const sim::IDE *ide = ide_pair.second;


       if(w.Plane >= 0 && w.Plane < 3 && w.Cryostat < 2){

         srparticle.plane[w.Cryostat][w.Plane].visE += ide->energy / 1000. /* MeV -> GeV*/;

       }

     }


     for (const art::Ptr<recob::Hit> h: particle_hits) {

       const geo::WireID &w = h->WireID();


       if(w.Plane >= 0 && w.Plane < 3 && w.Cryostat < 2) {

         srparticle.plane[w.Cryostat][w.Plane].nhit ++;

       }

     }


     // if no trajectory points, then assume outside AV

     srparticle.cont_tpc = particle.NumberTrajectoryPoints() > 0;

     srparticle.contained = particle.NumberTrajectoryPoints() > 0;


     // Get the entry and exit points

     int entry_point = -1;


     int cryostat_index = -1;

     int tpc_index = -1;


     for (unsigned j = 0; j < particle.NumberTrajectoryPoints(); j++) {

       for (unsigned i = 0; i < active_volumes.size(); i++) {

         if (active_volumes.at(i).ContainsPosition(particle.Position(j).Vect())) {

           entry_point = j;

           cryostat_index = i;

           break;

         }

       }

       if (entry_point != -1) break;

     }

     // get the wall

     if (entry_point > 0) {

       srparticle.wallin = GetWallCross(active_volumes.at(cryostat_index), particle.Position(entry_point).Vect(), particle.Position(entry_point-1).Vect());

     }


     int exit_point = -1;


     // now setup the cryostat the particle is in

     std::vector<geo::BoxBoundedGeo> volumes;

     if (entry_point >= 0) {

       volumes = tpc_volumes.at(cryostat_index);

       for (unsigned i = 0; i < volumes.size(); i++) {

         if (volumes[i].ContainsPosition(particle.Position(entry_point).Vect())) {

           tpc_index = i;

           srparticle.cont_tpc = entry_point == 0;

           break;

         }

       }

       srparticle.contained = entry_point == 0;

     }

     // if we couldn't find the initial point, set not contained

     else {

       srparticle.contained = false;

     }

     if (tpc_index < 0) {

       srparticle.cont_tpc = false;

     }


     // setup aa volumes too for length calc

     // Define the volume used for length calculation to be the cryostat volume in question

     std::vector<geoalgo::AABox> aa_volumes;

     if (entry_point >= 0) {

       const geo::BoxBoundedGeo &v = active_volumes.at(cryostat_index);

       aa_volumes.emplace_back(v.MinX(), v.MinY(), v.MinZ(), v.MaxX(), v.MaxY(), v.MaxZ());

     }


     // Get the length and determine if any point leaves the active volume

     //

     // Use every trajectory point if possible

     if (entry_point >= 0) {

       // particle trajectory

       const simb::MCTrajectory &trajectory = particle.Trajectory();

       TVector3 pos = trajectory.Position(entry_point).Vect();

       for (unsigned i = entry_point+1; i < particle.NumberTrajectoryPoints(); i++) {

         TVector3 this_point = trajectory.Position(i).Vect();

         // get the exit point

         // update if particle is contained

         // check if particle has crossed TPC

         if (!srparticle.crosses_tpc) {

           for (unsigned j = 0; j < volumes.size(); j++) {

             if (volumes[j].ContainsPosition(this_point) && tpc_index >= 0 && j != ((unsigned)tpc_index)) {

               srparticle.crosses_tpc = true;

               break;

             }

           }

         }

         // check if particle has left tpc

         if (srparticle.cont_tpc) {

           srparticle.cont_tpc = volumes[tpc_index].ContainsPosition(this_point);

         }


         if (srparticle.contained) {

           srparticle.contained = active_volumes.at(cryostat_index).ContainsPosition(this_point);

         }


         // update length

         srparticle.length += ContainedLength(this_point, pos, aa_volumes);


         if (!active_volumes.at(cryostat_index).ContainsPosition(this_point) && active_volumes.at(cryostat_index).ContainsPosition(pos)) {

           exit_point = i-1;

         }


         pos = trajectory.Position(i).Vect();

       }

     }

     if (exit_point < 0 && entry_point >= 0) {

       exit_point = particle.NumberTrajectoryPoints() - 1;

     }

     if (exit_point >= 0 && ((unsigned)exit_point) < particle.NumberTrajectoryPoints() - 1) {

       srparticle.wallout = GetWallCross(active_volumes.at(cryostat_index), particle.Position(exit_point).Vect(), particle.Position(exit_point+1).Vect());

     }


     // other truth information

     srparticle.pdg = particle.PdgCode();


     srparticle.gen = particle.NumberTrajectoryPoints() ? particle.Position().Vect() : TVector3(-9999, -9999, -9999);

     srparticle.genT = particle.NumberTrajectoryPoints() ? particle.Position().T() / 1000. /* ns -> us*/: -9999;

     srparticle.genp = particle.NumberTrajectoryPoints() ? particle.Momentum().Vect(): TVector3(-9999, -9999, -9999);

     srparticle.genE = particle.NumberTrajectoryPoints() ? particle.Momentum().E(): -9999;


     srparticle.start = (entry_point >= 0) ? particle.Position(entry_point).Vect(): TVector3(-9999, -9999, -9999);

     srparticle.startT = (entry_point >= 0) ? particle.Position(entry_point).T() / 1000. /* ns-> us*/: -9999;

     srparticle.end = (exit_point >= 0) ? particle.Position(exit_point).Vect(): TVector3(-9999, -9999, -9999);

     srparticle.endT = (exit_point >= 0) ? particle.Position(exit_point).T() / 1000. /* ns -> us */ : -9999;


     srparticle.startp = (entry_point >= 0) ? particle.Momentum(entry_point).Vect() : TVector3(-9999, -9999, -9999);

     srparticle.startE = (entry_point >= 0) ? particle.Momentum(entry_point).E() : -9999.;

     srparticle.endp = (exit_point >= 0) ? particle.Momentum(exit_point).Vect() : TVector3(-9999, -9999, -9999);

     srparticle.endE = (exit_point >= 0) ? particle.Momentum(exit_point).E() : -9999.;


     srparticle.start_process = GetG4ProcessID(particle.Process());

     srparticle.end_process = GetG4ProcessID(particle.EndProcess());


     srparticle.G4ID = particle.TrackId();

     srparticle.parent = particle.Mother();


     // Set the initial cryostat

     srparticle.cryostat = -1;

     if (entry_point >= 0) {

       for (unsigned c = 0; c < active_volumes.size(); c++) {

         if (active_volumes[c].ContainsPosition(particle.Position(entry_point).Vect())) {

           srparticle.cryostat = c;

           break;

         }

       }

     }


     // Save the daughter particles

     for (int i_d = 0; i_d < particle.NumberDaughters(); i_d++) {

       srparticle.daughters.push_back(particle.Daughter(i_d));

     }


     // See if this MCParticle matches a genie truth

     srparticle.interaction_id = -1;


     art::Ptr<simb::MCTruth> truth = inventory_service.TrackIdToMCTruth_P(particle.TrackId());

     for (unsigned i = 0; i < neutrinos.size(); i++) {

       if (truth.get() == neutrinos[i].get()) {

         srparticle.interaction_id = i;

         break;

       }

     }

   } //FillTrueG4Particle


   void FillFakeReco(const std::vector<art::Ptr<simb::MCTruth>> &mctruths,

                     const std::vector<caf::SRTrueParticle> &srparticles,

                     const std::vector<art::Ptr<sim::MCTrack>> &mctracks,

                     const std::vector<geo::BoxBoundedGeo> &volumes,

                     TRandom &rand,

                     std::vector<caf::SRFakeReco> &srfakereco) {

     // iterate and fill

     for (const art::Ptr<simb::MCTruth> mctruth: mctruths) {

       bool do_fill = false;

       caf::SRFakeReco this_fakereco;

       do_fill = FRFillNumuCC(*mctruth, mctracks, volumes, rand, this_fakereco);

       if(!do_fill) do_fill = FRFillNueCC(*mctruth, srparticles, volumes, rand, this_fakereco);


       // TODO: others?

       // if (!do_fill) ...


       if (do_fill) srfakereco.push_back(this_fakereco);


     }

   }


   std::map<int, caf::HitsEnergy> SetupIDHitEnergyMap(const std::vector<art::Ptr<recob::Hit>> &allHits,

                                                            const detinfo::DetectorClocksData &clockData,

                                                            const cheat::BackTrackerService &backtracker) {

     std::map<int, caf::HitsEnergy> ret;


     for (const art::Ptr<recob::Hit> h : allHits) {

       const int hit_trackID = CAFRecoUtils::GetShowerPrimary(TruthMatchUtils::TrueParticleID(clockData, h, true));

       ++ret[hit_trackID].nHits;


       for (const sim::TrackIDE ide : backtracker.HitToTrackIDEs(clockData, h)) {

         const int ide_trackID = CAFRecoUtils::GetShowerPrimary(ide.trackID);

         ret[ide_trackID].totE += ide.energy;

       }

     }

     return ret;

   }


   std::map<int, std::vector<art::Ptr<recob::Hit>>> PrepTrueHits(const std::vector<art::Ptr<recob::Hit>> &allHits,

     const detinfo::DetectorClocksData &clockData, const cheat::BackTrackerService &backtracker) {

     std::map<int, std::vector<art::Ptr<recob::Hit>>> ret;

     for (const art::Ptr<recob::Hit> h: allHits) {

       for (int ID: backtracker.HitToTrackIds(clockData, *h)) {

         ret[abs(ID)].push_back(h);

       }

     }

     return ret;

   }


   std::map<int, std::vector<std::pair<geo::WireID, const sim::IDE*>>> PrepSimChannels(const std::vector<art::Ptr<sim::SimChannel>> &simchannels, const geo::GeometryCore &geo) {

     std::map<int, std::vector<std::pair<geo::WireID, const sim::IDE*>>> ret;


     for (const art::Ptr<sim::SimChannel> sc : simchannels) {

       // Lookup the wire of this channel

       raw::ChannelID_t channel = sc->Channel();

       std::vector<geo::WireID> maybewire = geo.ChannelToWire(channel);

       geo::WireID thisWire; // Default constructor makes invalid wire

       if (maybewire.size()) thisWire = maybewire[0];


       for (const auto &item : sc->TDCIDEMap()) {

         for (const sim::IDE &ide: item.second) {

           // indexing initializes empty vector

           ret[abs(ide.trackID)].push_back({thisWire, &ide});

         }

       }

     }

     return ret;

   }


 } // end namespace


 //--------------------------------------------


 bool FRFillNumuCC(const simb::MCTruth &mctruth,

                   const std::vector<art::Ptr<sim::MCTrack>> &mctracks,

                   const std::vector<geo::BoxBoundedGeo> &volumes,

                   TRandom &rand,

                   caf::SRFakeReco &fakereco) {

   // Configuration -- TODO: make configurable?


   // Fiducial Volume

   float xmin = 10.;

   float xmax = 10.;

   float ymin = 10.;

   float ymax = 10.;

   float zmin = 10.;

   float zmax = 100.;


   // energy smearing

   float hadron_smearing = 0.05;

   float lepton_contained_smearing = 0.02;

   std::function<float (float)> lepton_exiting_smearing = [](float length) {

     float A = 0.102;

     float B = 0.000612;

     return -A * TMath::Log(B * length);

   };


   // visible energy threshold

   float hadronic_energy_threshold = 0.021; // GeV


   // length cut

   float contained_length_cut = 50.; // cm

   float exiting_length_cut = 100.; // cm


   fakereco.filled = false;


   // first check if neutrino exists

   if (!mctruth.NeutrinoSet()) return false;


   // then check if fiducial

   int cryo_index = -1;

   for (unsigned i = 0; i < volumes.size(); i++) {

     const geo::BoxBoundedGeo &vol = volumes[i];

     geo::BoxBoundedGeo FV(vol.MinX() + xmin, vol.MaxX() - xmax, vol.MinY() + ymin, vol.MaxY() - ymax, vol.MinZ() + zmin, vol.MaxZ() - zmax);

     if (FV.ContainsPosition(mctruth.GetNeutrino().Nu().Position().Vect())) {

       cryo_index = i;

       break;

     }

   }


   if (cryo_index == -1) return false;


   std::vector<geoalgo::AABox> aa_volumes;

   const geo::BoxBoundedGeo &v = volumes.at(cryo_index);

   aa_volumes.emplace_back(v.MinX(), v.MinY(), v.MinZ(), v.MaxX(), v.MaxY(), v.MaxZ());


   // look for CC lepton or a \pi^+/- which can "fake" a numu CC interaction


   int lepton_ind = -1;

   // CC lepton

   if (abs(mctruth.GetNeutrino().Nu().PdgCode()) == 14 && mctruth.GetNeutrino().CCNC() == 0) {

     for (int i = 0; i < (int)mctracks.size(); i++) {

       if (isFromNuVertex(mctruth, *mctracks[i]) && abs(mctracks[i]->PdgCode()) == 13 && mctracks[i]->Process() == "primary") {

         if (lepton_ind == -1 || mctracks[lepton_ind]->Start().E() < mctracks[i]->Start().E()) {

           lepton_ind = i;

         }

       }

     }

   }

   // NC pion

   else if (mctruth.GetNeutrino().CCNC() == 1) {

     for (int i = 0; i < (int)mctracks.size(); i++) {

       if (isFromNuVertex(mctruth, *mctracks[i]) && abs(mctracks[i]->PdgCode()) == 211 && mctracks[i]->Process() == "primary") {

         if (lepton_ind == -1 || mctracks[lepton_ind]->Start().E() < mctracks[i]->Start().E()) {

           lepton_ind = i;

         }

       }

     }

   }


   // no matching track -- no fake reco

   if (lepton_ind == -1) return false;


   // Now set the "lepton"

   caf::SRFakeRecoParticle fake_lepton;


   fake_lepton.pid = 13;

   fake_lepton.contained = false;

   for (const geo::BoxBoundedGeo &vol: volumes) {

     if (vol.ContainsPosition(mctracks[lepton_ind]->Start().Position().Vect()) && vol.ContainsPosition(mctracks[lepton_ind]->Start().Position().Vect())) {

       fake_lepton.contained = true;

     }

   }

   fake_lepton.len = ContainedLength(mctracks[lepton_ind]->Start().Position().Vect(), mctracks[lepton_ind]->End().Position().Vect(), aa_volumes);

   fake_lepton.costh = mctracks[lepton_ind]->Start().Position().Vect().CosTheta();


   // apply length cut

   if (fake_lepton.contained && fake_lepton.len < contained_length_cut) return false;

   if (!fake_lepton.contained && fake_lepton.len < exiting_length_cut) return false;


   // smear the lepton energy

   float smearing = fake_lepton.contained ? lepton_contained_smearing : lepton_exiting_smearing(fake_lepton.len);

   float ke = (mctracks[lepton_ind]->Start().E() - PDGMass(mctracks[lepton_ind]->PdgCode())) / 1000. /* MeV -> GeV*/;

   fake_lepton.ke = rand.Gaus(ke, smearing * ke);

   fake_lepton.ke = std::max(fake_lepton.ke, 0.f);


   // get the hadronic state

   std::vector<caf::SRFakeRecoParticle> hadrons;


   for (int i = 0; i < (int)mctracks.size(); i++) {

     if (isFromNuVertex(mctruth, *mctracks[i]) // from this interaction

      && (abs(mctracks[i]->PdgCode()) == 211 || abs(mctracks[i]->PdgCode()) == 321 || abs(mctracks[i]->PdgCode()) == 2212) // hadronic

      && mctracks[i]->Process() == "primary" // primary

      && i != lepton_ind // not the fake lepton

     ) {

       caf::SRFakeRecoParticle hadron;

       hadron.pid = abs(mctracks[i]->PdgCode());

       hadron.contained = false;

       for (const geo::BoxBoundedGeo &vol: volumes) {

         if (vol.ContainsPosition(mctracks[i]->Start().Position().Vect()) && vol.ContainsPosition(mctracks[i]->Start().Position().Vect())) {

           hadron.contained = true;

         }

       }

       hadron.len = ContainedLength(mctracks[i]->Start().Position().Vect(), mctracks[i]->Start().Position().Vect(), aa_volumes);

       hadron.costh = mctracks[i]->Start().Position().Vect().CosTheta();


       float ke = (mctracks[i]->Start().E() - PDGMass(mctracks[i]->PdgCode())) / 1000. /* MeV -> GeV*/;

       if (ke < hadronic_energy_threshold) continue;


       hadron.ke = rand.Gaus(ke, hadron_smearing * ke);

       hadron.ke = std::max(hadron.ke, 0.f);


       hadrons.push_back(hadron);

     }

   }


   // total up the energy to get the reco neutrino energy

   fakereco.nuE = fake_lepton.ke;

   for (const caf::SRFakeRecoParticle &had: hadrons) fakereco.nuE += had.ke;

   fakereco.nuE += PDGMass(13) / 1000.; // MeV -.> GeV


   // save the particles

   fakereco.lepton = fake_lepton;

   fakereco.hadrons = hadrons;


   // other info

   TVector3 vertex = mctruth.GetNeutrino().Nu().Position().Vect();

   fakereco.vtx.x = vertex.X();

   fakereco.vtx.y = vertex.Y();

   fakereco.vtx.z = vertex.Z();


   // signal

   if (abs(mctruth.GetNeutrino().Nu().PdgCode()) == 14 && mctruth.GetNeutrino().CCNC() == 0) {

     fakereco.wgt = 0.8;

   }

   // bkg

   else {

     fakereco.wgt = 1.;

   }

   fakereco.nhad = fakereco.hadrons.size();

   fakereco.filled = true;


   return true;

 }


 bool FRFillNueCC(const simb::MCTruth &mctruth,

                   const std::vector<caf::SRTrueParticle> &srparticles,

                   const std::vector<geo::BoxBoundedGeo> &volumes,

                   TRandom &rand,

                   caf::SRFakeReco &fakereco) {

   // Configuration -- TODO: make configurable?


   // Fiducial Volume

   float xmin = 10.;

   float xmax = 10.;

   float ymin = 10.;

   float ymax = 10.;

   float zmin = 10.;

   float zmax = 100.;


   // energy smearing

 /*  auto smear_lepton = [&rand](const caf::SRTrueParticle &lepton) -> float {

     const double smearing = 0.15;

     // Oscillation tech note says smear ionization deposition, but

     // code in old samples seems to use true energy.

     const double true_E = lepton.plane[0][2].visE + lepton.plane[1][2].visE;

     const double smeared_E = rand.Gaus(true_E, smearing * true_E / std::sqrt(true_E));

     return std::max(smeared_E, 0.0);

   };

   auto smear_hadron = [&rand](const caf::SRTrueParticle &hadron) -> float {

     const double smearing = 0.05;

     const double true_E = hadron.startE - PDGMass(hadron.pdg) / 1000;

     const double smeared_E = rand.Gaus(true_E, smearing * true_E);

     return std::max(smeared_E, 0.0);

   };

 */

   // visible energy threshold

   const float hadronic_energy_threshold = 0.021; // GeV


   fakereco.filled = false;


   // first check if neutrino exists

   if (!mctruth.NeutrinoSet()) return false;


   TVector3 nuVtx = mctruth.GetNeutrino().Nu().Position().Vect();


   // then check if fiducial

   int cryo_index = -1;

   for (unsigned i = 0; i < volumes.size(); i++) {

     const geo::BoxBoundedGeo &vol = volumes[i];

     geo::BoxBoundedGeo FV(vol.MinX() + xmin, vol.MaxX() - xmax, vol.MinY() + ymin, vol.MaxY() - ymax, vol.MinZ() + zmin, vol.MaxZ() - zmax);

     if (FV.ContainsPosition(nuVtx)) {

       cryo_index = i;

       break;

     }

   }


   if (cryo_index == -1) return false;


   std::vector<geoalgo::AABox> aa_volumes;

   const geo::BoxBoundedGeo &v = volumes.at(cryo_index);

   aa_volumes.emplace_back(v.MinX(), v.MinY(), v.MinZ(), v.MaxX(), v.MaxY(), v.MaxZ());


   //Showers arising from the vertex are identified and the reconstructed energy is found

   //from smearing the ionisation deposition. If more than one shower with energy above

   //100 MeV exists, the event is removed. This removes neutral pion events where the

   //pion decays into two photon showers.


   std::vector<const caf::SRTrueParticle*> lepton_candidates;

   for(const auto& particle: srparticles) {

     const int pdg = std::abs(particle.pdg);

     const float distance_from_vertex = std::hypot(nuVtx.X() - particle.start.x,

                                                   nuVtx.Y() - particle.start.y,

                                                   nuVtx.Z() - particle.start.z);

     if((pdg == 11 || pdg == 22) && distance_from_vertex < 5) {

       const auto parent = std::find_if(srparticles.begin(), srparticles.end(),

         [&particle](const caf::SRTrueParticle& parent_candidate) -> bool {

           return particle.parent == std::abs(parent_candidate.G4ID);

         });

       if((parent == srparticles.end()

            || !(std::abs((*parent).pdg) == 11 || std::abs((*parent).pdg) == 22))

          && SmearLepton(particle, rand) > 0.1) {

         lepton_candidates.push_back(&particle);

       }

     }

   }

   if(lepton_candidates.size() != 1) return false;


   const caf::SRTrueParticle* lepton = lepton_candidates[0];

   caf::SRFakeRecoParticle fake_lepton;

   fake_lepton.pid = 11;

   fake_lepton.ke = SmearLepton(*lepton, rand) - PDGMass(11) / 1000;

   // Should these be set for a shower?

   // fake_lepton.len = ???;

   // fake_lepton.costh = ???;

   // fake_lepton.contained = false;


   // Get hadrons


   std::vector<caf::SRFakeRecoParticle> fake_hadrons;

   float hadronic_E = 0.0;

   for(const auto& particle: srparticles) {

     const int pdg = std::abs(particle.pdg);

     const float ke = SmearHadron(particle, rand);

     const float distance_from_vertex = std::hypot(nuVtx.X() - particle.start.x,

                                                   nuVtx.Y() - particle.start.y,

                                                   nuVtx.Z() - particle.start.z);


     if((pdg == 2212 || pdg == 211 || pdg == 321) && distance_from_vertex < 5

        && particle.start_process == caf::kG4primary && ke > hadronic_energy_threshold) {

       caf::SRFakeRecoParticle fake_hadron;

       fake_hadron.pid = pdg;

       fake_hadron.len = ContainedLength(TVector3(particle.start), TVector3(particle.end), aa_volumes);

       fake_hadron.contained = false;

       for(const geo::BoxBoundedGeo &vol: volumes) {

         if(vol.ContainsPosition(TVector3(particle.start))

            && vol.ContainsPosition(TVector3(particle.end))) {

           fake_hadron.contained = true;

         }

       }

       fake_hadron.costh = TVector3(particle.start).CosTheta();

       fake_hadron.ke = ke;

       hadronic_E += ke;

       fake_hadrons.push_back(fake_hadron);

     }

   }


   // If there is only one photon candidate in the event, a conversion gap cut is applied.

   // If the vertex is deemed visible, due to the presence of at least 50 MeV of hadronic

   // kinetic energy, and the photon starts to shower further than 3 cm from the vertex the

   // event is removed.


   if(lepton->pdg == 22 && hadronic_E > 0.05 && (TVector3(lepton->end) - nuVtx).Mag() > 3)

     return false;


   // Remaining photons undergo a dE/dx cut resulting in a 94% background rejection.


   double weight = 1.0;

   if(lepton->pdg == 22) weight *= 0.06;


   // If a misidentified photon originates from a resonant numuCC interaction, the muon

   // lepton is identified. Events where a muon travels greater than 1 m are assumed to be

   // from numuCC interactions and the event is removed.


   if(std::abs(mctruth.GetNeutrino().Nu().PdgCode()) == 14 && mctruth.GetNeutrino().CCNC() == 0) {

     const caf::SRTrueParticle* muon = NULL;

     for(const auto& particle: srparticles) {

       const int pdg = std::abs(particle.pdg);

       const float distance_from_vertex = std::hypot(nuVtx.X() - particle.start.x,

                                                     nuVtx.Y() - particle.start.y,

                                                     nuVtx.Z() - particle.start.z);

       if(pdg == 13 && distance_from_vertex < 5 && particle.start_process == caf::kG4primary

          && (muon == NULL || muon->startE < particle.startE))

         muon = &particle;

     }

     if(muon != NULL && ContainedLength(TVector3(muon->start), TVector3(muon->end), aa_volumes) > 100)

       return false;

   }


   // Events where the shower has an energy less than 200 MeV are removed


   if((lepton->plane[0][2].visE + lepton->plane[1][2].visE) < 0.2) return false;


   // total up the energy to get the reco neutrino energy

   fakereco.nuE = fake_lepton.ke + PDGMass(11) / 1000 + hadronic_E;


   // save the particles

   fakereco.lepton = fake_lepton;

   fakereco.hadrons = fake_hadrons;


   // other info

   fakereco.vtx.x = nuVtx.X();

   fakereco.vtx.y = nuVtx.Y();

   fakereco.vtx.z = nuVtx.Z();


   fakereco.wgt = 0.8;

   fakereco.wgt *= weight;


   fakereco.nhad = fakereco.hadrons.size();

   fakereco.filled = true;


   return true;

 }


 caf::Wall_t caf::GetWallCross(const geo::BoxBoundedGeo &volume, const TVector3 p0, const TVector3 p1) {

   TVector3 direction = (p1 - p0) * ( 1. / (p1 - p0).Mag());

   std::vector<TVector3> intersections = volume.GetIntersections(p0, direction);


   assert(intersections.size() == 2);


   // get the intersection point closer to p0

   int intersection_i = ((intersections[0] - p0).Mag() < (intersections[1] - p0).Mag()) ? 0 : 1;


   double eps = 1e-3;

   if (abs(intersections[intersection_i].X() - volume.MinX()) < eps) {

     //std::cout << "Left\n";

     return caf::kWallLeft;

   }

   else if (abs(intersections[intersection_i].X() - volume.MaxX()) < eps) {

     //std::cout << "Right\n";

     return caf::kWallRight;

   }

   else if (abs(intersections[intersection_i].Y() - volume.MinY()) < eps) {

     //std::cout << "Bottom\n";

     return caf::kWallBottom;

   }

   else if (abs(intersections[intersection_i].Y() - volume.MaxY()) < eps) {

     //std::cout << "Top\n";

     return caf::kWallTop;

   }

   else if (abs(intersections[intersection_i].Z() - volume.MinZ()) < eps) {

     //std::cout << "Front\n";

     return caf::kWallFront;

   }

   else if (abs(intersections[intersection_i].Z() - volume.MaxZ()) < eps) {

     //std::cout << "Back\n";

     return caf::kWallBack;

   }

   else assert(false);

   //std::cout << "None\n";


   return caf::kWallNone;

 }//GetWallCross


 //------------------------------------------


 caf::g4_process_ caf::GetG4ProcessID(const std::string &process_name) {

 #define MATCH_PROCESS(name) if (process_name == #name) {return caf::kG4 ## name;}

 #define MATCH_PROCESS_NAMED(strname, id) if (process_name == #strname) {return caf::kG4 ## id;}

   MATCH_PROCESS(primary)

   MATCH_PROCESS(CoupledTransportation)

   MATCH_PROCESS(FastScintillation)

   MATCH_PROCESS(Decay)

   MATCH_PROCESS(anti_neutronInelastic)

   MATCH_PROCESS(neutronInelastic)

   MATCH_PROCESS(anti_protonInelastic)

   MATCH_PROCESS(protonInelastic)

   MATCH_PROCESS(hadInelastic)

   MATCH_PROCESS_NAMED(kaon+Inelastic, kaonpInelastic)

   MATCH_PROCESS_NAMED(kaon-Inelastic, kaonmInelastic)

   MATCH_PROCESS_NAMED(kaon+Inelastic, kaonpInelastic)

   MATCH_PROCESS_NAMED(kaon-Inelastic, kaonmInelastic)

   MATCH_PROCESS_NAMED(sigma+Inelastic, sigmapInelastic)

   MATCH_PROCESS_NAMED(sigma-Inelastic, sigmamInelastic)

   MATCH_PROCESS_NAMED(pi+Inelastic, pipInelastic)

   MATCH_PROCESS_NAMED(pi-Inelastic, pimInelastic)

   MATCH_PROCESS_NAMED(xi+Inelastic, xipInelastic)

   MATCH_PROCESS_NAMED(xi-Inelastic, ximInelastic)

   MATCH_PROCESS(kaon0LInelastic)

   MATCH_PROCESS(kaon0SInelastic)

   MATCH_PROCESS(lambdaInelastic)

   MATCH_PROCESS_NAMED(anti-lambdaInelastic, anti_lambdaInelastic)

   MATCH_PROCESS(He3Inelastic)

   MATCH_PROCESS(ionInelastic)

   MATCH_PROCESS(xi0Inelastic)

   MATCH_PROCESS(alphaInelastic)

   MATCH_PROCESS(tInelastic)

   MATCH_PROCESS(dInelastic)

   MATCH_PROCESS(anti_neutronElastic)

   MATCH_PROCESS(neutronElastic)

   MATCH_PROCESS(anti_protonElastic)

   MATCH_PROCESS(protonElastic)

   MATCH_PROCESS(hadElastic)

   MATCH_PROCESS_NAMED(kaon+Elastic, kaonpElastic)

   MATCH_PROCESS_NAMED(kaon-Elastic, kaonmElastic)

   MATCH_PROCESS_NAMED(pi+Elastic, pipElastic)

   MATCH_PROCESS_NAMED(pi-Elastic, pimElastic)

   MATCH_PROCESS(conv)

   MATCH_PROCESS(phot)

   MATCH_PROCESS(annihil)

   MATCH_PROCESS(nCapture)

   MATCH_PROCESS(nKiller)

   MATCH_PROCESS(muMinusCaptureAtRest)

   MATCH_PROCESS(muIoni)

   MATCH_PROCESS(eBrem)

   MATCH_PROCESS(CoulombScat)

   MATCH_PROCESS(hBertiniCaptureAtRest)

   MATCH_PROCESS(hFritiofCaptureAtRest)

   MATCH_PROCESS(photonNuclear)

   MATCH_PROCESS(muonNuclear)

   MATCH_PROCESS(electronNuclear)

   MATCH_PROCESS(positronNuclear)

   MATCH_PROCESS(compt)

   MATCH_PROCESS(eIoni)

   MATCH_PROCESS(muBrems)

   MATCH_PROCESS(hIoni)

   MATCH_PROCESS(ionIoni)

   MATCH_PROCESS(hBrems)

   MATCH_PROCESS(muPairProd)

   MATCH_PROCESS(hPairProd)

   MATCH_PROCESS(LArVoxelReadoutScoringProcess)

   MATCH_PROCESS(Transportation)

   MATCH_PROCESS(msc)

   MATCH_PROCESS(StepLimiter)

   std::cerr << "Error: Process name with no match (" << process_name << ")\n";

   assert(false);

   return caf::kG4UNKNOWN; // unreachable in debug mode

 #undef MATCH_PROCESS

 #undef MATCH_PROCESS_NAMED


 }//GetG4ProcessID

 //-------------------------------------------


 float ContainedLength(const TVector3 &v0, const TVector3 &v1,

                        const std::vector<geoalgo::AABox> &boxes) {

   static const geoalgo::GeoAlgo algo;


   // if points are the same, return 0

   if ((v0 - v1).Mag() < 1e-6) return 0;


   // construct individual points

   geoalgo::Point_t p0(v0);

   geoalgo::Point_t p1(v1);


   // construct line segment

   geoalgo::LineSegment line(p0, p1);


   double length = 0;


   // total contained length is sum of lengths in all boxes

   // assuming they are non-overlapping

   for (auto const &box: boxes) {

     int n_contained = box.Contain(p0) + box.Contain(p1);

     // both points contained -- length is total length (also can break out of loop)

     if (n_contained == 2) {

       length = (v1 - v0).Mag();

       break;

     }

     // one contained -- have to find intersection point (which must exist)

     if (n_contained == 1) {

       auto intersections = algo.Intersection(line, box);

       // Because of floating point errors, it can sometimes happen

       // that there is 1 contained point but no "Intersections"

       // if one of the points is right on the edge

       if (intersections.size() == 0) {

         // determine which point is on the edge

         double tol = 1e-5;

         bool p0_edge = algo.SqDist(p0, box) < tol;

         bool p1_edge = algo.SqDist(p1, box) < tol;

         assert(p0_edge || p1_edge);

         // contained one is on edge -- can treat both as not contained

         //

         // In this case, no length

         if ((p0_edge && box.Contain(p0)) || (box.Contain(p1) && p1_edge))

           continue;

         // un-contaned one is on edge -- treat both as contained

         else if ((p0_edge && box.Contain(p1)) || (box.Contain(p0) && p1_edge)) {

     length = (v1 - v0).Mag();

     break;

         }

         else {

           assert(false); // bad

         }

       }

       // floating point errors can also falsely cause 2 intersection points

       //

       // in this case, one of the intersections must be very close to the

       // "contained" point, so the total contained length will be about

       // the same as the distance between the two intersection points

       else if (intersections.size() == 2) {

         length += (intersections.at(0).ToTLorentzVector().Vect() - intersections.at(1).ToTLorentzVector().Vect()).Mag();

         continue;

       }

       // "Correct"/ideal case -- 1 intersection point

       else if (intersections.size() == 1) {

         // get TVector at intersection point

         TVector3 int_tv(intersections.at(0).ToTLorentzVector().Vect());

         length += ( box.Contain(p0) ? (v0 - int_tv).Mag() : (v1 - int_tv).Mag() );

       }

       else assert(false); // bad

     }

     // none contained -- either must have zero or two intersections

     if (n_contained == 0) {

       auto intersections = algo.Intersection(line, box);

       if (!(intersections.size() == 0 || intersections.size() == 2)) {

         // more floating point error fixes...

         //

         // figure out which points are near the edge

         double tol = 1e-5;

         bool p0_edge = algo.SqDist(p0, box) < tol;

         bool p1_edge = algo.SqDist(p1, box) < tol;

         // and which points are near the intersection

         TVector3 vint = intersections.at(0).ToTLorentzVector().Vect();


         bool p0_int = (v0 - vint).Mag() < tol;

         bool p1_int = (v1 - vint).Mag() < tol;

         // exactly one of them should produce the intersection

         assert((p0_int && p0_edge) != (p1_int && p1_edge));

         // void variables when assert-ions are turned off

         (void) p0_int; (void) p1_int;


         // both close to edge -- full length is contained

         if (p0_edge && p1_edge) {

           length += (v0 - v1).Mag();

         }

         // otherwise -- one of them is not on an edge, no length is contained

         else {}

       }

       // assert(intersections.size() == 0 || intersections.size() == 2);

       else if (intersections.size() == 2) {

         TVector3 start(intersections.at(0).ToTLorentzVector().Vect());

         TVector3 end(intersections.at(1).ToTLorentzVector().Vect());

         length += (start - end).Mag();

       }

     }

   }


   return length;

 }//ContainedLength


 //------------------------------------------------

 caf::SRTrackTruth MatchTrack2Truth(const detinfo::DetectorClocksData &clockData, const std::vector<caf::SRTrueParticle> &particles, const std::vector<art::Ptr<recob::Hit>> &hits,

                                    const std::map<int, caf::HitsEnergy> &all_hits_map) {


   art::ServiceHandle<cheat::BackTrackerService> bt_serv;


   // this id is the same as the mcparticle ID as long as we got it from geant4

   std::vector<std::pair<int, float>> matches = CAFRecoUtils::AllTrueParticleIDEnergyMatches(clockData, hits, true);

   float total_energy = CAFRecoUtils::TotalHitEnergy(clockData, hits);

   std::map<int, caf::HitsEnergy> track_hits_map = caf::SetupIDHitEnergyMap(hits, clockData, *bt_serv.get());


   caf::SRTrackTruth ret;


   ret.visEintrk = total_energy / 1000. /* MeV -> GeV */;


   // setup the matches

   for (auto const &pair: matches) {

     caf::SRParticleMatch match;

     match.G4ID = pair.first;

     match.energy = pair.second / 1000. /* MeV -> GeV */;


     caf::HitsEnergy track_matched_hits = track_hits_map.find(match.G4ID)->second;

     caf::HitsEnergy all_matched_hits = all_hits_map.find(match.G4ID)->second;


     match.hit_purity = (hits.size() != 0) ? track_matched_hits.nHits / (float) hits.size() : 0.;

     match.energy_purity = (ret.visEintrk > 0) ? match.energy / ret.visEintrk : 0.;

     match.hit_completeness = (all_matched_hits.nHits != 0) ? track_matched_hits.nHits / (float) all_matched_hits.nHits : 0.;

     match.energy_completeness = (all_matched_hits.totE > 0) ? pair.second / all_matched_hits.totE : 0.;


     ret.matches.push_back(match);

   }


   // sort highest energy match to lowest

   std::sort(ret.matches.begin(), ret.matches.end(),

       [](const caf::SRParticleMatch &a, const caf::SRParticleMatch &b) {

         return a.energy > b.energy;

       }

       );


   bool found_bestmatch = false;

   if (ret.matches.size()) {

     ret.bestmatch = ret.matches.at(0);

     for (unsigned i_part = 0; i_part < particles.size(); i_part++) {

       if (particles[i_part].G4ID == ret.bestmatch.G4ID) {

         ret.p = particles[i_part];

         found_bestmatch = true;

         break;

       }

     }

   }


   // Calculate efficiency / purity

   if (found_bestmatch) {

     double match_total_energy = 0.;

     for (int p = 0; p < 3; p++) {

       for (int c = 0; c < 2; c++) {

         match_total_energy += ret.p.plane[c][p].visE;

       }

     }


     ret.eff = ret.matches[0].energy / match_total_energy;

     ret.pur = ret.matches[0].energy / ret.visEintrk;


     int icryo = -1;

     if (!hits.empty()) {

       icryo = hits[0]->WireID().Cryostat;

     }


     assert(icryo < 2);

     if (icryo >= 0 && icryo < 2) {

       float match_cryo_energy = ret.p.plane[icryo][0].visE + ret.p.plane[icryo][1].visE + ret.p.plane[icryo][2].visE;

       ret.eff_cryo = ret.matches[0].energy / match_cryo_energy;

     }

     else {

       ret.eff_cryo = -1;

     }


   }

   else {

     ret.eff = -1.;

     ret.pur = -1.;

     ret.eff_cryo = -1.;

   }


   ret.nmatches = ret.matches.size();


   return ret;

 }//MatchTrack2Truth

 //------------------------------------------------

 caf::SRTruthMatch MatchSlice2Truth(const std::vector<art::Ptr<recob::Hit>> &hits,

                                    const std::vector<art::Ptr<simb::MCTruth>> &truths,

                                    const caf::SRTruthBranch &srmc,

                                    const cheat::ParticleInventoryService &inventory_service,

                                    const detinfo::DetectorClocksData &clockData) {

   caf::SRTruthMatch ret;

   float total_energy = CAFRecoUtils::TotalHitEnergy(clockData, hits);

   // speed optimization: if there are no truths, all the matching energy must be cosmic

   if (truths.empty()) {

     ret.visEinslc = total_energy / 1000. /* MeV -> GeV */;

     ret.visEcosmic = total_energy / 1000. /* MeV -> GeV */;

     ret.eff_cryo = -1.;

     ret.eff = -1;

     ret.pur = -1;

     ret.index = -1;

     return ret;

   }

   std::vector<std::pair<int, float>> matches = CAFRecoUtils::AllTrueParticleIDEnergyMatches(clockData, hits, true);

   std::vector<float> matching_energy(truths.size(), 0.);

   for (auto const &pair: matches) {

     art::Ptr<simb::MCTruth> truth;

     try {

       truth = inventory_service.TrackIdToMCTruth_P(pair.first);

     }

     // Ignore track ID's that cannot be looked up

     catch(...) {

       continue;

     }

     for (unsigned ind = 0; ind < truths.size(); ind++) {

       if (truth == truths[ind]) {

         matching_energy[ind] += pair.second;

         break;

       }

     }

   }


   float cosmic_energy = total_energy;

   for (float E: matching_energy) cosmic_energy -= E;


   float matching_frac = *std::max_element(matching_energy.begin(), matching_energy.end()) / total_energy;

   int index = (matching_frac > 0.5) ? std::distance(matching_energy.begin(), std::max_element(matching_energy.begin(), matching_energy.end())) : -1;


   ret.index = index;

   if (index >= 0) {

     ret.visEinslc = total_energy / 1000. /* MeV -> GeV */;

     ret.visEcosmic = cosmic_energy / 1000. /* MeV -> GeV */;

     ret.pur = matching_energy[index] / total_energy;


     double totVisE = 0.;

     for (int p = 0; p < 3; p++) {

       for (int c = 0; c < 2; c++) {

         totVisE += srmc.nu[index].plane[c][p].visE;

       }

     }


     ret.eff = (matching_energy[index] / 1000.) / totVisE;


     // Lookup the cryostat

     int icryo = -1;

     if (!hits.empty()) {

       icryo = hits[0]->WireID().Cryostat;

     }


     if (icryo >= 0) {

       ret.eff_cryo = (matching_energy[index] / 1000.) /

           (srmc.nu[index].plane[icryo][0].visE + srmc.nu[index].plane[icryo][1].visE + srmc.nu[index].plane[icryo][2].visE);

     }

     else {

       ret.eff_cryo = -1;

     }


   }

   else {

     ret.pur = -1;

     ret.eff = -1;

     ret.eff_cryo = -1;

   }

   return ret;

 }//Slc2Truth

sim::IDE::trackID
TrackID_t trackID
Geant4 supplied track ID.
Definition: SimChannel.h:116

caf::SRTrueInteraction::imp_weight
float imp_weight
Importance weight from flux file.
Definition: SRTrueInteraction.h:88

SmearHadron
double SmearHadron(const caf::SRTrueParticle &hadron, TRandom &rand)
Definition: FillTrue.cxx:70

vertex
process_name vertex
Definition: cheaterreco.fcl:51

evgen::ldm::MeVPrtlTruth::decay_pos
TLorentzVector decay_pos
Definition: MeVPrtlTruth.h:30

caf::SRTrueInteraction::npiplus
unsigned int npiplus
Number of &#39;s after neutrino reaction, before FSI.
Definition: SRTrueInteraction.h:69

caf::kWallLeft
Definition: SREnums.h:27

caf::SRTrueInteraction::genweight
float genweight
Weight, if any, assigned by the generator.
Definition: SRTrueInteraction.h:81

caf::kWallBottom
Definition: SREnums.h:26

caf::PrepSimChannels
std::map< int, std::vector< std::pair< geo::WireID, const sim::IDE * > > > PrepSimChannels(const std::vector< art::Ptr< sim::SimChannel >> &simchannels, const geo::GeometryCore &geo)
Definition: FillTrue.cxx:685

caf::SRSlice::tmatch
SRTruthMatch tmatch
Matching information between truth and reco objects.
Definition: SRSlice.h:37

caf::SRMeVPrtl::C1
double C1
Definition: SRMeVPrtl.h:40

caf::SRTrueInteraction::initpdg
int initpdg
Initial PDG code of probe neutrino.
Definition: SRTrueInteraction.h:37

caf::SRTrueInteraction::nneutron
unsigned int nneutron
Number of neutrons after neutrino reaction, before FSI.
Definition: SRTrueInteraction.h:73

caf::SRStub::truth
SRTrackTruth truth
truth information
Definition: SRStub.h:52

caf::SRTrueInteraction::isseaquark
bool isseaquark
Did neutrino scatter off a sea quark.
Definition: SRTrueInteraction.h:77

PDGMass
double PDGMass(int pdg)
Definition: FillTrue.cxx:44

geoalgo::GeoAlgo
Algorithm to compute various geometrical relation among geometrical objects. In particular functions ...
Definition: larcorealg/larcorealg/GeoAlgo/GeoAlgo.h:43

sbn::evwgh::EventWeightMap
std::map< std::string, std::vector< float > > EventWeightMap
Container for event-level weights.
Definition: EventWeightMap.h:18

caf::SRTrueParticle::genE
float genE
Energy at generation pt [GeV].
Definition: SRTrueParticle.h:31

sbn::evwgh::EventWeightParameter::fMean
float fMean
Gaussian mean.
Definition: EventWeightParameterSet.h:46

util::ContainedLength
double ContainedLength(const TVector3 &v0, const TVector3 &v1, const std::vector< geo::BoxBoundedGeo > &boxes)
Definition: Interaction.cxx:28

caf::SRTrueInteraction::parent_dcy_mom
SRVector3D parent_dcy_mom
Neutrino parent momentum at decay [GeV; beam coordinates].
Definition: SRTrueInteraction.h:86

pdg
var pdg
Definition: selectors.fcl:14

caf::SRTrueParticle::parent
unsigned parent
ID&#39;s of parent particle from this particle.
Definition: SRTrueParticle.h:59

evgen::ldm::MeVPrtlTruth::flux_weight
double flux_weight
Definition: MeVPrtlTruth.h:40

caf::SRMeVPrtl::ray_weight
double ray_weight
Weight associated with the Portal hitting the detector.
Definition: SRMeVPrtl.h:31

caf::SRWeightPSet::type
ReweightType_t type
Definition: SRWeightPSet.h:17

caf::SRTrueInteraction::inelasticityY
float inelasticityY
Inelasticity y.
Definition: SRTrueInteraction.h:58

caf::kWallBack
Definition: SREnums.h:30

cheat::BackTrackerService::HitToTrackIDEs
std::vector< sim::TrackIDE > HitToTrackIDEs(detinfo::DetectorClocksData const &clockData, recob::Hit const &hit) const
Definition: BackTrackerService.cc:173

cerr
BEGIN_PROLOG could also be cerr
Definition: messageservice.fcl:10

caf::SRTrueParticle::start
SRVector3D start
Start position in the active TPC volume [cm].
Definition: SRTrueParticle.h:43

caf::FillTrueNeutrino
void FillTrueNeutrino(const art::Ptr< simb::MCTruth > mctruth, const simb::MCFlux &mcflux, const simb::GTruth &gtruth, const std::vector< caf::SRTrueParticle > &srparticles, const std::map< int, std::vector< art::Ptr< recob::Hit >>> &id_to_truehit_map, caf::SRTrueInteraction &srneutrino, size_t i, const std::vector< geo::BoxBoundedGeo > &active_volumes)
Definition: FillTrue.cxx:258

caf::SRWeightParam::name
std::string name
Definition: SRWeightParam.h:11

caf::SRTrueInteraction::hitnuc
int hitnuc
Definition: SRTrueInteraction.h:43

caf::FillStubTruth
void FillStubTruth(const std::vector< art::Ptr< recob::Hit >> &hits, const std::map< int, caf::HitsEnergy > &id_hits_map, const std::vector< caf::SRTrueParticle > &particles, const detinfo::DetectorClocksData &clockData, caf::SRStub &srstub, bool allowEmpty)
Definition: FillTrue.cxx:147

caf::SRFakeRecoParticle::contained
bool contained
Whether contained.
Definition: SRFakeRecoParticle.h:23

caf::SRTrueInteraction
The SRTrueInteraction is a representation of neutrino interaction information.
Definition: SRTrueInteraction.h:31

caf::SRTrueInteraction::position
SRVector3D position
Neutrino interaction position.
Definition: SRTrueInteraction.h:92

caf::SRTrueInteraction::xsec
float xsec
xsec for thrown interaction, in 1/GeV^2, as stored by the GENIE spline
Definition: SRTrueInteraction.h:79

caf::SRTrueInteraction::resnum
int resnum
Resonance number, straight from GENIE.
Definition: SRTrueInteraction.h:78

tol
auto const tol
Definition: SurfXYZTest.cc:16

caf::SRTrueInteraction::nprim
int nprim
Number of primary daughters.
Definition: SRTrueInteraction.h:100

caf::SRTrueInteraction::prod_vtx
SRVector3D prod_vtx
Neutrino production vertex [cm; beam coordinates].
Definition: SRTrueInteraction.h:85

geoalgo::GeoAlgo::SqDist
double SqDist(const Line_t &line, const Point_t &pt) const
Definition: larcorealg/larcorealg/GeoAlgo/GeoAlgo.h:87

caf::SRTrueInteraction::E
float E
True energy [GeV].
Definition: SRTrueInteraction.h:52

caf::SRWeightParam::mean
float mean
Definition: SRWeightParam.h:12

sbn::evwgh::EventWeightParameter::fWidth
float fWidth
Gaussian sigma.
Definition: EventWeightParameterSet.h:47

Decay
process_name Decay
Definition: g4_cosmics_purity_15ms.fcl:7

p
pdgs p
Definition: selectors.fcl:22

geo::BoxBoundedGeo::MinX
double MinX() const
Returns the world x coordinate of the start of the box.
Definition: BoxBoundedGeo.h:88

MatchSlice2Truth
caf::SRTruthMatch MatchSlice2Truth(const std::vector< art::Ptr< recob::Hit >> &hits, const std::vector< art::Ptr< simb::MCTruth >> &neutrinos, const caf::SRTruthBranch &srtruth, const cheat::ParticleInventoryService &inventory_service, const detinfo::DetectorClocksData &clockData)
Definition: FillTrue.cxx:1367

geoalgo::LineSegment
Representation of a simple 3D line segment Defines a finite 3D straight line by having the start and ...
Definition: larcorealg/larcorealg/GeoAlgo/GeoLineSegment.h:25

caf::Wall_t
Wall_t
Definition: SREnums.h:22

caf::SRTrueParticlePlaneInfo
Definition: SRTrueParticle.h:15

sbn::evwgh::EventWeightParameter::fName
std::string fName
Parameter name.
Definition: EventWeightParameterSet.h:45

caf::SRTruthMatch
An SRTruthMatch contains overarching information for a slice.
Definition: SRTruthMatch.h:15

caf::SRTrueParticle::endT
float endT
End time last point in the active [us – t=0 is spill time].
Definition: SRTrueParticle.h:36

caf::SRTrueInteraction::targetPDG
int targetPDG
Definition: SRTrueInteraction.h:40

caf::SRTrueParticle::cryostat
int cryostat
Cryostat that the particle enters first – -1 if it does not enter a Cryostat.
Definition: SRTrueParticle.h:56

TruthMatchUtils::TrueParticleID
G4ID TrueParticleID(detinfo::DetectorClocksData const &clockData, const art::Ptr< recob::Hit > &pHit, const bool rollupUnsavedIDs)
The G4 ID of the true particle which deposits the most energy in the recob::Hit.
Definition: TruthMatchUtils.cc:68

caf::SRTrueParticle::startp
SRVector3D startp
Momentum at first point in the active TPC volume [GeV/c].
Definition: SRTrueParticle.h:40

caf::SRFakeRecoParticle::ke
float ke
Fake-reco kinetic energy [GeV].
Definition: SRFakeRecoParticle.h:19

caf::kWallFront
Definition: SREnums.h:29

SmearLepton
double SmearLepton(const caf::SRTrueParticle &lepton, TRandom &rand)
Definition: FillTrue.cxx:61

caf::SRTruthMatch::eff
float eff
Slice efficiency for this interaction.
Definition: SRTruthMatch.h:22

geo::GeometryCore::ChannelToWire
std::vector< geo::WireID > ChannelToWire(raw::ChannelID_t const channel) const
Returns a list of wires connected to the specified TPC channel.
Definition: GeometryCore.cxx:1196

caf::SRTrueInteractionPlaneInfo
Definition: SRTrueInteraction.h:20

geo::CryostatID::Cryostat
CryostatID_t Cryostat
Index of cryostat.
Definition: geo_types.h:212

caf::SRSlice::truth
SRTrueInteraction truth
Truth information on the slice.
Definition: SRSlice.h:36

caf::SRMeVPrtl::time
double time
Decay time [us].
Definition: SRMeVPrtl.h:23

caf::SRTrueInteraction::genie_inttype
genie_interaction_type_ genie_inttype
Following LARSoft MCNeutrino::InteractionType()
Definition: SRTrueInteraction.h:45

caf::SRFakeRecoParticle::len
float len
Fake-reco particle length [cm].
Definition: SRFakeRecoParticle.h:21

geo::BoxBoundedGeo::MaxX
double MaxX() const
Returns the world x coordinate of the end of the box.
Definition: BoxBoundedGeo.h:91

caf::SRTrackTruth
Definition: SRTrackTruth.h:19

caf::SRTrueInteraction::nproton
unsigned int nproton
Number of protons after neutrino reaction, before FSI.
Definition: SRTrueInteraction.h:72

E
process_name E
Definition: rawtorootconvert.fcl:26

track
process_name use argoneut_mc_hitfinder track
Definition: standard_reco.fcl:36

caf::SRFakeRecoParticle
The SRFakeRecoParticle is a faked reconstruction using estimates from the SBN proposal.
Definition: SRFakeRecoParticle.h:13

caf::genie_interaction_mode_
genie_interaction_mode_
Definition: SREnums.h:62

geo::WireID
Definition: geo_types.h:560

X
then echo echo For and will not be changed by echo further linking echo echo B echo The symbol is in the uninitialized data multiple common symbols may appear with the echo same name If the symbol is defined the common echo symbols are treated as undefined references For more echo details on common see the discussion of warn common echo in *Note Linker see the discussion of warn common echo in *Note Linker such as a global int variable echo as opposed to a large global array echo echo I echo The symbol is an indirect reference to another symbol This echo is a GNU extension to the a out object file format which is echo rarely used echo echo N echo The symbol is a debugging symbol echo echo R echo The symbol is in a read only data section echo echo S echo The symbol is in an uninitialized data section for small echo objects echo echo T echo The symbol is in the the normal defined echo symbol is used with no error When a weak undefined symbol echo is linked and the symbol is not the value of the echo weak symbol becomes zero with no error echo echo W echo The symbol is a weak symbol that has not been specifically echo tagged as a weak object symbol When a weak defined symbol echo is linked with a normal defined the normal defined echo symbol is used with no error When a weak undefined symbol echo is linked and the symbol is not the value of the echo weak symbol becomes zero with no error echo echo echo The symbol is a stabs symbol in an a out object file In echo this the next values printed are the stabs other echo the stabs desc and the stab type Stabs symbols are echo used to hold debugging information For more echo see *Note or object file format specific echo echo For Mac OS X
Definition: find_global_symbol.sh:107

caf::SRMeVPrtl::flux_weight
double flux_weight
Weight associated with the production of the Portal.
Definition: SRMeVPrtl.h:30

evgen::ldm::kHNL
Definition: MeVPrtlTruth.h:15

caf::FillSliceTruth
void FillSliceTruth(const std::vector< art::Ptr< recob::Hit >> &hits, const std::vector< art::Ptr< simb::MCTruth >> &neutrinos, const caf::SRTruthBranch &srmc, const cheat::ParticleInventoryService &inventory_service, const detinfo::DetectorClocksData &clockData, caf::SRSlice &srslice, bool allowEmpty)
Definition: FillTrue.cxx:160

caf::SRTrackTruth::visEintrk
float visEintrk
True total deposited energy associated with this Track across all 3 planes [GeV]. NOTE: this energy i...
Definition: SRTrackTruth.h:22

caf::SRMeVPrtl::momentum
caf::SRVector3D momentum
Portal momentum [GeV].
Definition: SRMeVPrtl.h:24

caf::SRGlobal::wgts
std::vector< SRWeightPSet > wgts
Definition: SRGlobal.h:13

isFromNuVertex
bool isFromNuVertex(const simb::MCTruth &mc, const sim::MCTrack &track, float distance=5.0)
Definition: FillTrue.cxx:36

caf::SRMeVPrtl::decay_length
double decay_length
Mean decay length of particle.
Definition: SRMeVPrtl.h:34

caf::g4_process_
g4_process_
Which G4 process ?
Definition: SREnums.h:155

caf::SRTruthMatch::visEinslc
float visEinslc
True deposited energy in slice [GeV].
Definition: SRTruthMatch.h:25

gen_crt_frags.m
tuple m
now if test mode generate materials, CRT shell, world, gdml header else just generate CRT shell for u...
Definition: gen_crt_frags.py:1347

evgen::ldm::MeVPrtlTruth::mean_distance
double mean_distance
Definition: MeVPrtlTruth.h:53

caf::SRMeVPrtl::C5
double C5
Definition: SRMeVPrtl.h:44

caf::SRParticleMatch::hit_completeness
float hit_completeness
The fraction of the best true particle&#39;s hits contained by the reconstructed object.
Definition: SRParticleMatch.h:16

caf::SRTrueInteraction::parent_pdg
int parent_pdg
PDG Code of parent particle ID.
Definition: SRTrueInteraction.h:84

cheat::BackTrackerService::HitToTrackIds
std::vector< int > HitToTrackIds(detinfo::DetectorClocksData const &clockData, recob::Hit const &hit) const
Definition: BackTrackerService.cc:193

caf::SRWeightPSet
Definition: SRWeightPSet.h:13

caf::SRTruthMatch::eff_cryo
float eff_cryo
Slice efficiency for this interaction for energy in the slice&#39;s cryostat.
Definition: SRTruthMatch.h:23

caf::SRParticleMatch::energy
float energy
Total energy matching between reco track and true particle across all three planes [GeV]...
Definition: SRParticleMatch.h:14

caf::kMeVPrtlHiggs
Definition: SREnums.h:54

caf::SetupIDHitEnergyMap
std::map< int, caf::HitsEnergy > SetupIDHitEnergyMap(const std::vector< art::Ptr< recob::Hit >> &allHits, const detinfo::DetectorClocksData &clockData, const cheat::BackTrackerService &backtracker)
Definition: FillTrue.cxx:657

caf::SRTrueParticle::contained
bool contained
Whether the particle is contained in a single active volume.
Definition: SRTrueParticle.h:51

GeoAlgo.h

caf::SRMeVPrtl::gen
caf::mevprtlchannel_ gen
Generator physics channel for this event.
Definition: SRMeVPrtl.h:21

caf::SRTrueParticle::wallout
Wall_t wallout
Wall of cryostat particle exits (wNone if stopping in detector)
Definition: SRTrueParticle.h:47

a
process_name gaushit a
Definition: decode_signalprocess_icarus.fcl:37

xmin
process_name pandoraGausCryo1 vertexChargeCryo1 vertexStubCryo1 xmin
Definition: run_vertexcharge_icarus.fcl:109

caf::SRTrueInteraction::pdg
int pdg
PDG code of probe neutrino.
Definition: SRTrueInteraction.h:38

h
while getopts h
Definition: getStatistics.sh:13

CAFRecoUtils::AllTrueParticleIDEnergyMatches
std::vector< std::pair< int, float > > AllTrueParticleIDEnergyMatches(const detinfo::DetectorClocksData &clockData, const std::vector< art::Ptr< recob::Hit > > &hits, bool rollup_unsaved_ids=1)
Definition: sbncode/sbncode/CAFMaker/RecoUtils/RecoUtils.cc:3

lar::dump::vector
auto vector(Vector const &v)
Returns a manipulator which will print the specified array.
Definition: DumpUtils.h:265

caf::SRTrueInteraction::prim
std::vector< SRTrueParticle > prim
Primary daughters, lepton comes first in vector.
Definition: SRTrueInteraction.h:101

caf::SRMeVPrtl::position
caf::SRVector3D position
Decay location [cm].
Definition: SRMeVPrtl.h:22

abs
T abs(T value)
Definition: sparse_vector_test.cc:30

sbn::evwgh::EventWeightParameterSet::fCovarianceMatrix
TMatrixD * fCovarianceMatrix
Covariance matrix for correlated throws (optional)
Definition: EventWeightParameterSet.h:144

caf::SRFakeReco::filled
bool filled
Definition: SRFakeReco.h:27

caf::SRVector3D::z
float z
Definition: SRVector3D.h:55

caf::SRTruthBranch::nu
std::vector< SRTrueInteraction > nu
Vector of true nu or cosmic.
Definition: SRTruthBranch.h:21

sbn::evwgh::EventWeightParameterSet::fRWType
ReweightType fRWType
Type of throws (the same for all parameters in a set)
Definition: EventWeightParameterSet.h:146

caf::SRTrueInteractionPlaneInfo::nhitprim
unsigned int nhitprim
Number of hits from primary particles on plane.
Definition: SRTrueInteraction.h:26

sbn::evwgh::EventWeightParameter::fCovIndex
size_t fCovIndex
Index in the covariance matrix (if any)
Definition: EventWeightParameterSet.h:48

caf::SRTrueInteraction::ischarm
bool ischarm
Is a charmed quark in interaction.
Definition: SRTrueInteraction.h:76

evgen::ldm::MeVPrtlTruth::C3
double C3
Definition: MeVPrtlTruth.h:47

icarus::distance
double distance(geo::Point_t const &point, CathodeDesc_t const &cathode)
Returns the distance of a point from the cathode.
Definition: CathodeCrossingUtils.cxx:35

caf::FillShowerTruth
void FillShowerTruth(const std::vector< art::Ptr< recob::Hit >> &hits, const std::map< int, caf::HitsEnergy > &id_hits_map, const std::vector< caf::SRTrueParticle > &particles, const detinfo::DetectorClocksData &clockData, caf::SRShower &srshower, bool allowEmpty)
Definition: FillTrue.cxx:134

caf::SRTrueInteractionPlaneInfo::nhit
unsigned int nhit
Number of hits on plane.
Definition: SRTrueInteraction.h:27

caf::SRWeightParam::width
float width
Definition: SRWeightParam.h:13

evgen::ldm::MeVPrtlTruth::C2
double C2
Definition: MeVPrtlTruth.h:46

caf::SRTrueParticle::crosses_tpc
bool crosses_tpc
Whether the particle crosses a TPC boundary.
Definition: SRTrueParticle.h:50

caf::SRFakeRecoParticle::pid
int pid
Fake-reco particle ID.
Definition: SRFakeRecoParticle.h:22

sbn::evwgh::EventWeightParameter
A single parameter to be reweighted.
Definition: EventWeightParameterSet.h:18

caf::SRTrueParticle::genp
SRVector3D genp
Momentum at generation point [GeV/c].
Definition: SRTrueParticle.h:39

caf::GetG4ProcessID
caf::g4_process_ GetG4ProcessID(const std::string &name)
Definition: FillTrue.cxx:1094

caf::kWeakMix
Definition: SREnums.h:79

caf::ReweightType_t
ReweightType_t
Definition: SREnums.h:224

sim::IDE
Ionization at a point of the TPC sensitive volume.
Definition: SimChannel.h:86

evgen::ldm::MeVPrtlTruth::C1
double C1
Definition: MeVPrtlTruth.h:45

caf::SRMeVPrtl::C3
double C3
Definition: SRMeVPrtl.h:42

caf::SRGlobal
Definition: SRGlobal.h:10

caf::kG4primary
Definition: SREnums.h:157

cheat::ParticleInventoryService::TrackIdToMCTruth_P
const art::Ptr< simb::MCTruth > & TrackIdToMCTruth_P(int id) const
Definition: ParticleInventoryService.cc:140

caf::SRTrueParticle::end_process
g4_process_ end_process
End G4 process of the particle.
Definition: SRTrueParticle.h:64

caf::SRTrueParticle::length
float length
Trajectory length in active TPC volume the particle first enters [cm].
Definition: SRTrueParticle.h:37

caf::SRMeVPrtl::M
double M
Portal Mass [GeV].
Definition: SRMeVPrtl.h:26

caf::SRTrueInteraction::momentum
SRVector3D momentum
Neutrino three-momentum.
Definition: SRTrueInteraction.h:91

caf::SRWeightPSet::map
std::vector< SRWeightMapEntry > map
Definition: SRWeightPSet.h:21

sim::IDE::energy
float energy
energy deposited by ionization by this track ID and time [MeV]
Definition: SimChannel.h:118

FRFillNueCC
bool FRFillNueCC(const simb::MCTruth &mctruth, const std::vector< caf::SRTrueParticle > &srparticle, const std::vector< geo::BoxBoundedGeo > &volumes, TRandom &rand, caf::SRFakeReco &fakereco)
Definition: FillTrue.cxx:873

sbn::evwgh::EventWeightParameterSet
Container for a set of reweightable parameters.
Definition: EventWeightParameterSet.h:61

pi
pdgs pi
Definition: selectors.fcl:22

caf::SRFakeReco::nhad
int nhad
Number of hadrons.
Definition: SRFakeReco.h:25

icarus::ns::util::end
auto end(FixedBins< T, C > const &) noexcept
Definition: FixedBins.h:585

caf::SRFakeReco::nuE
float nuE
Fake-reco neutrino Energy [GeV].
Definition: SRFakeReco.h:21

geo::BoxBoundedGeo::MinZ
double MinZ() const
Returns the world z coordinate of the start of the box.
Definition: BoxBoundedGeo.h:118

FRFillNumuCC
bool FRFillNumuCC(const simb::MCTruth &mctruth, const std::vector< art::Ptr< sim::MCTrack >> &mctracks, const std::vector< geo::BoxBoundedGeo > &volumes, TRandom &rand, caf::SRFakeReco &fakereco)
Definition: FillTrue.cxx:710

caf::SRTrueInteraction::bjorkenX
float bjorkenX
Bjorken x = (k-k&#39;)^2/(2*p.q) [Dimensionless].
Definition: SRTrueInteraction.h:57

evgen::ldm::MeVPrtlTruth::ray_weight
double ray_weight
Definition: MeVPrtlTruth.h:41

caf::SRMeVPrtl::C4
double C4
Definition: SRMeVPrtl.h:43

sbn::evwgh::EventWeightParameterSet::fParameterMap
std::map< EventWeightParameter, std::vector< float > > fParameterMap
Mapping of definitions to the set of values.
Definition: EventWeightParameterSet.h:143

caf::SRTrueInteraction::npizero
unsigned int npizero
Number of &#39;s after neutrino reaction, before FSI.
Definition: SRTrueInteraction.h:71

caf::SRTrueInteraction::isnc
bool isnc
same as LArSoft &quot;ccnc&quot; - 0=CC, 1=NC
Definition: SRTrueInteraction.h:47

caf::SRShower
Definition: SRShower.h:28

caf::FillFakeReco
void FillFakeReco(const std::vector< art::Ptr< simb::MCTruth >> &mctruths, const std::vector< caf::SRTrueParticle > &srparticles, const std::vector< art::Ptr< sim::MCTrack >> &mctracks, const std::vector< geo::BoxBoundedGeo > &volumes, TRandom &rand, std::vector< caf::SRFakeReco > &srfakereco)
Definition: FillTrue.cxx:636

caf::SRTrueParticle::startT
float startT
Start time of first TPC point [us – t=0 is spill time].
Definition: SRTrueParticle.h:35

caf::genie_interaction_type_
genie_interaction_type_
Definition: SREnums.h:82

caf::SRMeVPrtl::enter
caf::SRVector3D enter
Entry position of particle into Active Volume.
Definition: SRMeVPrtl.h:35

caf::SRFakeRecoParticle::costh
float costh
Fake-reco cosine of angle w.r.t. beam direction.
Definition: SRFakeRecoParticle.h:20

caf::FillMeVPrtlTruth
void FillMeVPrtlTruth(const evgen::ldm::MeVPrtlTruth &truth, const std::vector< geo::BoxBoundedGeo > &active_volumes, caf::SRMeVPrtl &srtruth)
Definition: FillTrue.cxx:182

caf::SRTrueParticle::genT
float genT
Start time of gen point [us – t=0 is spill time].
Definition: SRTrueParticle.h:34

CAFRecoUtils::GetShowerPrimary
int GetShowerPrimary(const int g4ID)
Definition: sbncode/sbncode/CAFMaker/RecoUtils/RecoUtils.cc:91

caf::SRTrueParticle::endE
float endE
Energy at last pt in active TPC volume [GeV].
Definition: SRTrueParticle.h:33

caf::SRFakeReco::wgt
float wgt
Weight for this interaction.
Definition: SRFakeReco.h:26

caf::HitsEnergy::totE
float totE
Definition: FillTrue.h:42

geo::PlaneID::Plane
PlaneID_t Plane
Index of the plane within its TPC.
Definition: geo_types.h:493

caf::SRParticleMatch::energy_purity
float energy_purity
The fraction of the reconstructed object&#39;s energy that originates from the best true particle...
Definition: SRParticleMatch.h:19

nlohmann::detail::void
j template void())
Definition: json.hpp:3108

geo::GeometryCore
Description of geometry of one entire detector.
Definition: GeometryCore.h:1476

sbn::evwgh::EventWeightParameterSet::fNuniverses
size_t fNuniverses
Number of universes (i.e. random throws)
Definition: EventWeightParameterSet.h:147

caf::SRTrueInteraction::w
float w
Hadronic invariant mass W.
Definition: SRTrueInteraction.h:64

evgen::ldm::MeVPrtlTruth::gen
Generator gen
Definition: MeVPrtlTruth.h:55

caf::SRSlice
An SRSlice contains overarching information for a slice.
Definition: SRSlice.h:24

evgen::ldm::MeVPrtlTruth::decay_weight
double decay_weight
Definition: MeVPrtlTruth.h:42

caf::SRMeVPrtl::E
double E
Portal Energy [GeV].
Definition: SRMeVPrtl.h:25

caf::SRWeightPSet::name
std::string name
Definition: SRWeightPSet.h:16

caf::SRTrueInteraction::plane
SRTrueInteractionPlaneInfo plane[2][3]
Per-plane, per-cryostat deposition information.
Definition: SRTrueInteraction.h:54

gen_crt_frags.w
tuple w
Definition: gen_crt_frags.py:1416

caf::SRTruthMatch::pur
float pur
Slice purity for this interaction.
Definition: SRTruthMatch.h:24

caf::SRTruthMatch::index
int index
Index of the matched true neutrino interaction (-1 if not matched to neutrino)
Definition: SRTruthMatch.h:27

caf::SRTrack::truth
SRTrackTruth truth
truth information
Definition: SRTrack.h:54

MatchTrack2Truth
caf::SRTrackTruth MatchTrack2Truth(const detinfo::DetectorClocksData &clockData, const std::vector< caf::SRTrueParticle > &particles, const std::vector< art::Ptr< recob::Hit >> &hits, const std::map< int, caf::HitsEnergy > &all_hits_map)
Definition: FillTrue.cxx:1279

geo::BoxBoundedGeo::MaxY
double MaxY() const
Returns the world y coordinate of the end of the box.
Definition: BoxBoundedGeo.h:106

caf::SRTrueInteraction::q0_lab
float q0_lab
q0, lab frame
Definition: SRTrueInteraction.h:62

caf::FillTrueG4Particle
void FillTrueG4Particle(const simb::MCParticle &particle, const std::vector< geo::BoxBoundedGeo > &active_volumes, const std::vector< std::vector< geo::BoxBoundedGeo >> &tpc_volumes, const std::map< int, std::vector< std::pair< geo::WireID, const sim::IDE * >>> &id_to_ide_map, const std::map< int, std::vector< art::Ptr< recob::Hit >>> &id_to_truehit_map, const cheat::BackTrackerService &backtracker, const cheat::ParticleInventoryService &inventory_service, const std::vector< art::Ptr< simb::MCTruth >> &neutrinos, caf::SRTrueParticle &srparticle)
Definition: FillTrue.cxx:434

caf::SRParticleMatch::G4ID
int G4ID
ID of the particle match, taken from G4 */.
Definition: SRParticleMatch.h:13

caf::SRFakeReco::hadrons
std::vector< SRFakeRecoParticle > hadrons
Fake-reco information on hadronic state.
Definition: SRFakeReco.h:24

evgen::ldm::MeVPrtlTruth::mass
double mass
Definition: MeVPrtlTruth.h:44

sim::MCTrack
Definition: MCTrack.h:27

caf::SRTrueInteraction::iscc
bool iscc
CC (true) or NC/interference (false)
Definition: SRTrueInteraction.h:48

caf::kWallRight
Definition: SREnums.h:28

caf::SRTrueInteraction::parent_dcy_E
float parent_dcy_E
Neutrino parent energy at decay [GeV].
Definition: SRTrueInteraction.h:87

caf::SRVector3D::y
float y
Definition: SRVector3D.h:54

cheat::BackTrackerService
Definition: BackTrackerService.h:45

caf::kWallTop
Definition: SREnums.h:25

evgen::ldm::MeVPrtlTruth::C4
double C4
Definition: MeVPrtlTruth.h:48

caf::SRWeightParam
Definition: SRWeightParam.h:8

caf::SRSlice::fake_reco
SRFakeReco fake_reco
Definition: SRSlice.h:43

caf::SRTrueParticle::interaction_id
int interaction_id
Neutrino interaction ID of the source of this particle (-1 if cosmic)
Definition: SRTrueParticle.h:55

caf::SRTrueParticle::end
SRVector3D end
End position in the active TPC volume [cm].
Definition: SRTrueParticle.h:44

caf::SRTrueParticle::startE
float startE
Energy at first pt in active TPC volume [GeV].
Definition: SRTrueParticle.h:32

caf::SRTrueParticle::start_process
g4_process_ start_process
Start G4 process of the particle.
Definition: SRTrueParticle.h:63

caf::SRTrueInteraction::baseline
float baseline
Distance from decay to interaction [m].
Definition: SRTrueInteraction.h:67

evgen::ldm::MeVPrtlTruth::C5
double C5
Definition: MeVPrtlTruth.h:49

caf::HitsEnergy::nHits
int nHits
Definition: FillTrue.h:41

caf::SRMeVPrtl::cryostat
int cryostat
Cryostat that the decay occurs in.
Definition: SRMeVPrtl.h:28

CopyTMatrixDToVector
void CopyTMatrixDToVector(const TMatrixD &m, std::vector< float > &v)
Definition: FillTrue.cxx:79

muon
process_name can override from command line with o or output muon
Definition: runPID.fcl:28

geo::BoxBoundedGeo
A base class aware of world box coordinatesAn object describing a simple shape can inherit from this ...
Definition: BoxBoundedGeo.h:33

caf::SRVector3D::x
float x
Definition: SRVector3D.h:53

caf::SRTrueInteraction::Q2
float Q2
Q squared.
Definition: SRTrueInteraction.h:59

ana::SBNOsc::PDGTable
static const TDatabasePDG * PDGTable(new TDatabasePDG)

caf::SRTrueParticle::endp
SRVector3D endp
Momentum at last point in the active TPC volume [GeV/c].
Definition: SRTrueParticle.h:41

caf::FillTrackTruth
void FillTrackTruth(const std::vector< art::Ptr< recob::Hit >> &hits, const std::map< int, caf::HitsEnergy > &id_hits_map, const std::vector< caf::SRTrueParticle > &particles, const detinfo::DetectorClocksData &clockData, caf::SRTrack &srtrack, bool allowEmpty)
Definition: FillTrue.cxx:118

detinfo::DetectorClocksData
Contains all timing reference information for the detector.
Definition: DetectorClocksData.h:283

caf::FillSliceFakeReco
void FillSliceFakeReco(const std::vector< art::Ptr< recob::Hit >> &hits, const std::vector< art::Ptr< simb::MCTruth >> &neutrinos, const caf::SRTruthBranch &srmc, const cheat::ParticleInventoryService &inventory_service, const detinfo::DetectorClocksData &clockData, caf::SRSlice &srslice, const std::vector< caf::SRTrueParticle > &srparticles, const std::vector< art::Ptr< sim::MCTrack >> &mctracks, const std::vector< geo::BoxBoundedGeo > &volumes, TRandom &rand)
Definition: FillTrue.cxx:238

cheat::ParticleInventoryService
Definition: ParticleInventoryService.h:42

caf::SRTrueParticle::wallin
Wall_t wallin
Wall of cryostat particle enters (wNone if starting in detector)
Definition: SRTrueParticle.h:46

caf::PrepTrueHits
std::map< int, std::vector< art::Ptr< recob::Hit > > > PrepTrueHits(const std::vector< art::Ptr< recob::Hit >> &allHits, const detinfo::DetectorClocksData &clockData, const cheat::BackTrackerService &backtracker)
Definition: FillTrue.cxx:674

caf::SRMeVPrtl::exit
caf::SRVector3D exit
Exit position of particle into Active Volume.
Definition: SRMeVPrtl.h:36

caf::SRTrueInteraction::time
float time
Time.
Definition: SRTrueInteraction.h:56

caf::SRParticleMatch::hit_purity
float hit_purity
The fraction of the reconstructed object&#39;s hits that originate from the best true particle...
Definition: SRParticleMatch.h:17

geo::BoxBoundedGeo::MaxZ
double MaxZ() const
Returns the world z coordinate of the end of the box.
Definition: BoxBoundedGeo.h:121

MATCH_PROCESS
#define MATCH_PROCESS(name)

caf::SRTrueParticle::G4ID
int G4ID
ID of the particle (taken from G4 – -1 if this particle is not propogated by G4)
Definition: SRTrueParticle.h:54

caf::SRWeightPSet::covmx
std::vector< float > covmx
Definition: SRWeightPSet.h:19

caf::SRTruthBranch
Vectors of reconstructed vertices found by various algorithms.
Definition: SRTruthBranch.h:15

evgen::ldm::MeVPrtlTruth::mevprtl_start
TLorentzVector mevprtl_start
Definition: MeVPrtlTruth.h:26

e
do i e
Definition: updateVersionList.sh:68

geo::BoxBoundedGeo::GetIntersections
std::vector< TVector3 > GetIntersections(TVector3 const &TrajectoryStart, TVector3 const &TrajectoryDirect) const
Calculates the entry and exit points of a trajectory on the box surface.
Definition: BoxBoundedGeo.cxx:126

sbn::evwgh::EventWeightParameterSet::fName
std::string fName
Name of the parameter set.
Definition: EventWeightParameterSet.h:145

caf::SRTrueInteraction::npiminus
unsigned int npiminus
Number of &#39;s after neutrino reaction, before FSI.
Definition: SRTrueInteraction.h:70

caf::SRTrueParticle
Representation of a simb::MCParticle, knows energy, direction,.
Definition: SRTrueParticle.h:26

caf::SRTrack
Definition: SRTrack.h:28

caf::SRTrueInteraction::index
int index
Index of the matched true neutrino interaction (-1 if not matched to neutrino)
Definition: SRTrueInteraction.h:39

caf::kMeVPrtlHNL
Definition: SREnums.h:55

sim::MCTrack::Start
const MCStep & Start() const
Definition: MCTrack.h:44

caf::SRMeVPrtl
Definition: SRMeVPrtl.h:15

caf::SRMeVPrtl::start
caf::SRVector3D start
Start position of Portal in detector coordinates [cm].
Definition: SRMeVPrtl.h:37

CAFRecoUtils::TotalHitEnergy
float TotalHitEnergy(const detinfo::DetectorClocksData &clockData, const std::vector< art::Ptr< recob::Hit > > &hits)
Definition: sbncode/sbncode/CAFMaker/RecoUtils/RecoUtils.cc:47

caf::SRTrueInteraction::parent_dcy_mode
int parent_dcy_mode
Parent hadron/muon decay mode.
Definition: SRTrueInteraction.h:83

FillTrue.h

caf::SRParticleMatch::energy_completeness
float energy_completeness
The fraction of the best true particle&#39;s energy contained by the reconstructed object.
Definition: SRParticleMatch.h:18

caf::SRTrueParticle::gen
SRVector3D gen
Generation position [cm].
Definition: SRTrueParticle.h:42

caf::kWallNone
Definition: SREnums.h:24

caf::SRTrueInteraction::genie_mode
genie_interaction_mode_ genie_mode
Interaction mode (as for LArSoft MCNeutrino::Mode() )
Definition: SRTrueInteraction.h:44

k
pdgs k
Definition: selectors.fcl:22

caf::SRStub
Definition: SRStub.h:39

caf::SRTruthMatch::visEcosmic
float visEcosmic
True slice deposited energy from cosmics.
Definition: SRTruthMatch.h:26

raw::ChannelID_t
unsigned int ChannelID_t
Type representing the ID of a readout channel.
Definition: RawTypes.h:28

caf::SRFakeReco::vtx
SRVector3D vtx
Interaction vertex in detector coordinates [cm].
Definition: SRFakeReco.h:22

evgen::ldm::kDissonantHiggs
Definition: MeVPrtlTruth.h:14

sim::MCStep::Position
const TLorentzVector & Position() const
Definition: MCStep.h:40

evgen::ldm::MeVPrtlTruth
Definition: MeVPrtlTruth.h:18

caf::SRParticleMatch
Match from a reconstructed track to a true particle */.
Definition: SRParticleMatch.h:10

lib.dedx.A
float A
Definition: dedx.py:137

caf::SRTrueInteraction::wgt
std::vector< SRMultiverse > wgt
Systematic weights.
Definition: SRTrueInteraction.h:108

caf::SRTrueParticle::cont_tpc
bool cont_tpc
Whether the particle is contained in a single TPC.
Definition: SRTrueParticle.h:49

TruthMatchUtils::G4ID
int G4ID
Definition: TruthMatchUtils.h:29

geoalgo::GeoAlgo::Intersection
std::vector< Point_t > Intersection(const AABox_t &box, const HalfLine_t &line, bool back=false) const
Intersection between a HalfLine and an AABox.
Definition: larcorealg/larcorealg/GeoAlgo/GeoAlgo.cxx:11

evgen::ldm::MeVPrtlTruth::mevprtl_enter
TVector3 mevprtl_enter
Definition: MeVPrtlTruth.h:28

caf::SRTrueParticle::daughters
std::vector< unsigned > daughters
ID&#39;s of daughter particles from this particle.
Definition: SRTrueParticle.h:58

caf::SRFakeReco::lepton
SRFakeRecoParticle lepton
Fake-reco lepton information.
Definition: SRFakeReco.h:23

caf::FillEventWeight
void FillEventWeight(const sbn::evwgh::EventWeightMap &wgtmap, caf::SRTrueInteraction &srint, const std::map< std::string, unsigned int > &weightPSetIndex)
Definition: FillTrue.cxx:414

caf::SRTrueParticle::pdg
int pdg
Particle ID code.
Definition: SRTrueParticle.h:53

caf::SRWeightPSet::nuniv
int nuniv
Definition: SRWeightPSet.h:18

geo::BoxBoundedGeo::MinY
double MinY() const
Returns the world y coordinate of the start of the box.
Definition: BoxBoundedGeo.h:103

icarus::ns::util::empty
bool empty(FixedBins< T, C > const &) noexcept
Definition: FixedBins.h:555

caf::kG4UNKNOWN
Definition: SREnums.h:220

caf::SRFakeReco
The SRFakeReco is a faked reconstruction using estimates from the SBN proposal.
Definition: SRFakeReco.h:15

sim::TrackIDE
Ionization energy from a Geant4 track.
Definition: SimChannel.h:26

nu
BEGIN_PROLOG SN nu
Definition: clustermodules.fcl:121

caf::FillSRGlobal
void FillSRGlobal(const sbn::evwgh::EventWeightParameterSet &pset, caf::SRGlobal &srglobal, std::map< std::string, unsigned int > &weightPSetIndex)
Definition: FillTrue.cxx:89

caf::SRTrueInteraction::cryostat
int cryostat
Cryostat the the Interaction originates in. -1 if it originates outside a cryostat.
Definition: SRTrueInteraction.h:94

caf::SRTrueInteractionPlaneInfo::visE
float visE
Sum of energy deposited on plane [GeV].
Definition: SRTrueInteraction.h:25

caf::SRMeVPrtl::C2
double C2
Definition: SRMeVPrtl.h:41

caf::SRTrueInteraction::modq_lab
float modq_lab
|q|, lab frame
Definition: SRTrueInteraction.h:63

channelDBConverter.n
int n
Definition: channelDBConverter.py:249

geoalgo::Vector
Definition: larcorealg/larcorealg/GeoAlgo/GeoVector.h:33

caf::SRTrueParticle::plane
SRTrueParticlePlaneInfo plane[2][3]
Per-plane, per-cryostat deposition information.
Definition: SRTrueParticle.h:29

evgen::ldm::MeVPrtlTruth::mevprtl_mom
TLorentzVector mevprtl_mom
Definition: MeVPrtlTruth.h:25

evgen::ldm::MeVPrtlTruth::mevprtl_exit
TVector3 mevprtl_exit
Definition: MeVPrtlTruth.h:29

p1
physics associatedGroupsWithLeft p1
Definition: test_associatedgroupswithleft_full.fcl:24

cout
BEGIN_PROLOG could also be cout
Definition: messageservice.fcl:10

caf::SRWeightParam::covidx
int covidx
Definition: SRWeightParam.h:14

MATCH_PROCESS_NAMED
#define MATCH_PROCESS_NAMED(strname, id)

caf::SRMeVPrtl::decay_weight
double decay_weight
Weight associated with the Portal decaying.
Definition: SRMeVPrtl.h:32

caf::SRTrueParticlePlaneInfo::visE
float visE
Sum of energy deposited on plane [GeV].
Definition: SRTrueParticle.h:20

caf::SRShower::truth
SRTrackTruth truth
truth information TODO: make seperate showe info class
Definition: SRShower.h:50

caf::SRTrueParticlePlaneInfo::nhit
unsigned int nhit
Number of hits on plane.
Definition: SRTrueParticle.h:21

caf::HitsEnergy
Definition: FillTrue.h:40

caf::GetWallCross
caf::Wall_t GetWallCross(const geo::BoxBoundedGeo &volume, const TVector3 p0, const TVector3 p1)
Definition: FillTrue.cxx:1052

process_name
BEGIN_PROLOG sequence::SlidingWindowTriggerPatternsOppositeWindows END_PROLOG process_name
Definition: triggersim_eastmodule_icarus.fcl:134