Inheritance diagram for myana::RegCNNAna:

Public Member Functions
	RegCNNAna (fhicl::ParameterSet const &pset)

virtual	~RegCNNAna ()

void	beginJob () override

void	endJob () override

void	beginSubRun (const art::SubRun &sr) override

void	endSubRun (const art::SubRun &sr) override

void	analyze (art::Event const &evt) override

void	reconfigure (fhicl::ParameterSet const &p)

void	reset ()

Public Member Functions inherited from art::EDAnalyzer
	EDAnalyzer (fhicl::ParameterSet const &pset)

template<typename Config >
	EDAnalyzer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Analyzer
virtual	~Analyzer () noexcept

	Analyzer (fhicl::ParameterSet const &pset)

template<typename Config >
	Analyzer (Table< Config > const &config)

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

Public Member Functions inherited from art::Observer
	~Observer () noexcept

	Observer (Observer const &)=delete

	Observer (Observer &&)=delete

Observer &	operator= (Observer const &)=delete

Observer &	operator= (Observer &&)=delete

void	registerProducts (ProductDescriptions &, ModuleDescription const &)

void	fillDescriptions (ModuleDescription const &)

fhicl::ParameterSetID	selectorConfig () const

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Member Functions
art::Ptr< recob::Track >	GetLongestTrack (const art::Event &event)

art::Ptr< recob::Shower >	GetHighestChargeShower (detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, const art::Event &event)

double	CalculateEnergyFromCharge (const double charge)
	Converts deposited charge into energy by converting to number of electrons and correcting for average recombination. More...

std::vector< std::pair< const simb::MCParticle *, double > >	get_sortedMCParticle (std::unordered_map< const simb::MCParticle *, double > mcEMap)

Private Attributes
TTree *	fTree

int	ievt

float	regcnn_energy

float	regcnn_prong_energy

float	regcnn_vertex [3]

float	regcnn_dir [3]

float	regcnn_dir_diff

float	regcnn_nue_dir_diff

int	InDet

int	FidCut

int	mutrk_contain

int	nhits

int	nu_truth_N

int	nupdg_truth [kMax]

int	numode_truth [kMax]

int	nuccnc_truth [kMax]

double	nueng_truth [kMax]

double	nuvtxx_truth [kMax]

double	nuvtxy_truth [kMax]

double	nuvtxz_truth [kMax]

int	lepPDG_truth [kMax]

double	lepEng_truth [kMax]

int	nPizero [kMax]

int	nPion [kMax]

int	nNeutron [kMax]

int	nProton [kMax]

double	ErecoNu

double	RecoLepEnNu

double	RecoHadEnNu

int	RecoMethodNu

int	RecoTrackMomMethod

int	n_track_pad

int	track_id [kMax]

int	all_track_true_pdg [kMax]

int	all_track_true_pdg_mom [kMax]

double	all_track_px [kMax]

double	all_track_py [kMax]

double	all_track_pz [kMax]

double	all_track_true_px [kMax]

double	all_track_true_py [kMax]

double	all_track_true_pz [kMax]

int	n_showers

int	shower_id [kMax]

int	all_shower_true_pdg [kMax]

int	all_shower_true_pdg_mom [kMax]

double	all_shower_px [kMax]

double	all_shower_py [kMax]

double	all_shower_pz [kMax]

double	all_shower_true_px [kMax]

double	all_shower_true_py [kMax]

double	all_shower_true_pz [kMax]

double	fUncorrectedHadEn

double	RecoMuTrackLength

double	fUncorrectedMuMomMCS

double	fUncorrectedElectronEnergy

double	fUncorrectedHadEnFromShw

calo::CalorimetryAlg	fCalorimetryAlg
	the calorimetry algorithm More...

std::string	fMCGenModuleLabel

std::string	fRegCNNModuleLabel

std::string	fRegCNNResultLabel

std::string	fRegCNNProngModuleLabel

std::string	fRegCNNProngResultLabel

std::string	fRegCNNDirModuleLabel

std::string	fRegCNNDirResultLabel

std::string	fHitsModuleLabel

std::string	fEnergyRecoNuLabel

std::string	fTrackToHitLabel

std::string	fShowerToHitLabel

std::string	fParticleLabel

std::string	fTrackLabel

std::string	fTrackLabelDir

std::string	fShowerLabel

std::string	fShowerLabelDir

double	fRecombFactor
	the average reccombination factor More...

art::ServiceHandle< cheat::BackTrackerService >	backtracker

art::ServiceHandle< cheat::ParticleInventoryService >	particleinventory

Additional Inherited Members
Public Types inherited from art::EDAnalyzer
using	WorkerType = WorkerT< EDAnalyzer >

using	ModuleType = EDAnalyzer

Protected Member Functions inherited from art::Observer
std::string const &	processName () const

bool	wantAllEvents () const noexcept

bool	wantEvent (ScheduleID id, Event const &e) const

Handle< TriggerResults >	getTriggerResults (Event const &e) const

	Observer (fhicl::ParameterSet const &config)

	Observer (std::vector< std::string > const &select_paths, std::vector< std::string > const &reject_paths, fhicl::ParameterSet const &config)

Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Definition at line 59 of file RegCNNAna_module.cc.

Constructor & Destructor Documentation

myana::RegCNNAna::RegCNNAna ( fhicl::ParameterSet const & pset )

explicit

Definition at line 182 of file RegCNNAna_module.cc.

                                                        : 
   EDAnalyzer      (pset),
   fCalorimetryAlg (pset.get<fhicl::ParameterSet>("CalorimetryAlg"))
 {
   this->reconfigure(pset);
 }

myana::RegCNNAna::~RegCNNAna ( )

virtual

Definition at line 189 of file RegCNNAna_module.cc.

190 {

191 }

Member Function Documentation

void myana::RegCNNAna::analyze ( art::Event const & evt )

overridevirtual

Implements art::EDAnalyzer.

Definition at line 286 of file RegCNNAna_module.cc.

 {
   this->reset();
   ievt = evt.id().event();
   bool isMC = !evt.isRealData(); 
 
   auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService>()->DataFor(evt);
   auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService>()->DataFor(evt, clockData);
   // Get the highestChargeShower of current event and then the associated hits of that shower
   // Get lepton charge from shower hits and event charge from event hits
   // Get hadronic charge by the subtraction of lepton charge from event charge
   // Get hadronic energy from hadronic charge
   art::Ptr<recob::Shower> highestChargeShower(this->GetHighestChargeShower(clockData, detProp, evt));
   if (!highestChargeShower.isAvailable() || highestChargeShower.isNull()) {
     mf::LogWarning("RegCNNAna")<<" Cannot access the electron shower which is needed for this energy reconstruction method.\n"
       <<"Set default value"<<std::endl;
   } else {
     const std::vector<art::Ptr<recob::Hit> > electronHits(dune_ana::DUNEAnaHitUtils::GetHitsOnPlane(dune_ana::DUNEAnaShowerUtils::GetHits(highestChargeShower, evt, fShowerToHitLabel), 2));
     const double electronObservedCharge(dune_ana::DUNEAnaHitUtils::LifetimeCorrectedTotalHitCharge(clockData, detProp, electronHits));
     fUncorrectedElectronEnergy = this->CalculateEnergyFromCharge(electronObservedCharge);
     const std::vector<art::Ptr<recob::Hit> > eventHits(dune_ana::DUNEAnaHitUtils::GetHitsOnPlane(dune_ana::DUNEAnaEventUtils::GetHits(evt, fHitsModuleLabel), 2));
     const double eventObservedCharge(dune_ana::DUNEAnaHitUtils::LifetimeCorrectedTotalHitCharge(clockData, detProp, eventHits));
     const double hadronicObservedCharge(eventObservedCharge-electronObservedCharge);
     fUncorrectedHadEnFromShw = this->CalculateEnergyFromCharge(hadronicObservedCharge);
   }
 
   // Get the longest track of current event and then the associated hits of that track
   // Get lepton charge from track hits and event charge from event hits
   // Get hadronic charge by the subtraction of lepton charge from event charge
   // Get hadronic energy from hadronic charge
   // Compare hadronic energy to true energy, get calibrated parameters: grad and interception
   art::Ptr<recob::Track> longestTrack(this->GetLongestTrack(evt));
   if (!longestTrack.isAvailable() || longestTrack.isNull()) {
     mf::LogWarning("RegCNNAna")<<" Cannot access the muon track which is needed for this energy reconstruction method.\n"
       <<"Set default value"<<std::endl;
   } else {
     const std::vector<art::Ptr<recob::Hit> > muonHits(dune_ana::DUNEAnaHitUtils::GetHitsOnPlane(dune_ana::DUNEAnaTrackUtils::GetHits(longestTrack, evt, fTrackToHitLabel), 2));
     const double leptonObservedCharge(dune_ana::DUNEAnaHitUtils::LifetimeCorrectedTotalHitCharge(clockData, detProp, muonHits));
     const std::vector<art::Ptr<recob::Hit> > eventHits(dune_ana::DUNEAnaHitUtils::GetHitsOnPlane(dune_ana::DUNEAnaEventUtils::GetHits(evt, fHitsModuleLabel), 2));
     const double eventObservedCharge(dune_ana::DUNEAnaHitUtils::LifetimeCorrectedTotalHitCharge(clockData, detProp, eventHits));
     const double hadronicObservedCharge(eventObservedCharge-leptonObservedCharge);
     fUncorrectedHadEn = this->CalculateEnergyFromCharge(hadronicObservedCharge);
     RecoMuTrackLength = longestTrack->Length();
     trkf::TrackMomentumCalculator TrackMomCalc;
     fUncorrectedMuMomMCS = TrackMomCalc.GetMomentumMultiScatterChi2(longestTrack);
     std::cout<<"track length :"<<RecoMuTrackLength<<", uncorrectedMuMomMCS :"<<fUncorrectedMuMomMCS<<std::endl;
   }
 
   // * MC truth information 
   std::vector<art::Ptr<simb::MCTruth> > mclist;      
   if (isMC){    
     auto mctruthListHandle = evt.getHandle< std::vector<simb::MCTruth> >(fMCGenModuleLabel);
     if (mctruthListHandle) 
       art::fill_ptr_vector(mclist, mctruthListHandle);  
   }  
 
   // Get the hits out of the event record
   std::vector<art::Ptr<recob::Hit> > hits;
   auto hitHandle = evt.getHandle<std::vector<recob::Hit> >(fHitsModuleLabel);
   if (hitHandle)
     art::fill_ptr_vector(hits, hitHandle);
 
   const sim::ParticleList& trueParticles = particleinventory->ParticleList();
 
   // Get the pandoratrack out of the event record
   std::vector<art::Ptr<recob::Track> > trackDir;
   auto trackHandleDir = evt.getHandle<std::vector<recob::Track> >(fTrackLabelDir);
   if (trackHandleDir)
     art::fill_ptr_vector(trackDir, trackHandleDir);
   art::FindManyP<recob::Hit> fmtrkDir(trackHandleDir, evt, fTrackLabelDir);
 
   if (trackHandleDir.isValid()) {
     n_track_pad = trackDir.size();
     for (int itrack= 0; itrack< n_track_pad; ++itrack) {
       art::Ptr<recob::Track> ptrack = trackDir.at(itrack);
       track_id[itrack] = ptrack->ID();
       all_track_px[itrack] = ptrack->VertexDirection().X();
       all_track_py[itrack] = ptrack->VertexDirection().Y();
       all_track_pz[itrack] = ptrack->VertexDirection().Z();
 
       if (fmtrkDir.isValid()) {
         std::vector<art::Ptr<recob::Hit> > vhit = fmtrkDir.at(itrack);
         std::unordered_map<const simb::MCParticle*, double> mcEMap;
         for (size_t ihit= 0; ihit< vhit.size(); ++ihit) {
           std::vector<sim::TrackIDE> trackIDs = backtracker->HitToTrackIDEs(clockData, vhit[ihit]);
           for (size_t e= 0; e< trackIDs.size(); ++e) {
             mcEMap[particleinventory->TrackIdToParticle_P(trackIDs[e].trackID)] += trackIDs[e].energy;
           }
         }
         std::vector<std::pair<const simb::MCParticle*, double> > trkTrue = get_sortedMCParticle(mcEMap);
         if (trkTrue.size()> 0) {
           all_track_true_pdg[itrack] = trkTrue[0].first->PdgCode();
           all_track_true_pdg_mom[itrack] = trkTrue[0].first->Mother()==0 ? -1 : trueParticles[trkTrue[0].first->Mother()]->PdgCode();
           TVector3 v3_true(trkTrue[0].first->Momentum().Vect());
           all_track_true_px[itrack] = v3_true.X();
           all_track_true_py[itrack] = v3_true.Y();
           all_track_true_pz[itrack] = v3_true.Z();
         }
       } // end of fmtrkDir
     } // end of n_track_pad
   } // end of trackHandleDir
 
   // Get the emshower out of the event record
   std::vector<art::Ptr<recob::Shower> > showersDir;
   auto showerHandleDir = evt.getHandle<std::vector<recob::Shower> >(fShowerLabelDir);
   if (showerHandleDir)
     art::fill_ptr_vector(showersDir, showerHandleDir);
   art::FindManyP<recob::Hit> fmshDir(showerHandleDir, evt, fShowerLabelDir);
 
   if (showerHandleDir.isValid()) {
     n_showers = showersDir.size();
     for (int ishower= 0; ishower< n_showers; ++ishower) {
       art::Ptr<recob::Shower> emshower = showersDir.at(ishower);
       shower_id[ishower] = emshower->ID();
       all_shower_px[ishower] = emshower->Direction().X();
       all_shower_py[ishower] = emshower->Direction().Y();
       all_shower_pz[ishower] = emshower->Direction().Z();
 
       if (fmshDir.isValid()) {
         std::vector<art::Ptr<recob::Hit> > vhit = fmshDir.at(ishower);
         std::unordered_map<const simb::MCParticle*, double> mcEMap;
         for (size_t ihit= 0; ihit< vhit.size(); ++ihit) {
           std::vector<sim::TrackIDE> trackIDs = backtracker->HitToTrackIDEs(clockData, vhit[ihit]);
           for (size_t e= 0; e< trackIDs.size(); ++e) {
             mcEMap[particleinventory->TrackIdToParticle_P(trackIDs[e].trackID)] += trackIDs[e].energy;
           }
         }
         std::vector<std::pair<const simb::MCParticle*, double> > shwTrue = get_sortedMCParticle(mcEMap);
         if (shwTrue.size()> 0) {
           all_shower_true_pdg[ishower] = shwTrue[0].first->PdgCode();
           all_shower_true_pdg_mom[ishower] = shwTrue[0].first->Mother()==0 ? -1 : trueParticles[shwTrue[0].first->Mother()]->PdgCode();
           TVector3 v3_true(shwTrue[0].first->Momentum().Vect());
           all_shower_true_px[ishower] = v3_true.X();
           all_shower_true_py[ishower] = v3_true.Y();
           all_shower_true_pz[ishower] = v3_true.Z();
         }
       } // end of fmshDir
     } // end of n_showers
   } // end of showerHandleDir
 
 
   // Get DUNE energy Reco
   auto engrecoHandle = evt.getHandle<dune::EnergyRecoOutput>(fEnergyRecoNuLabel);
 
   // Get RegCNN Results
 
   // neutrino energy
   art::InputTag itag1(fRegCNNModuleLabel, fRegCNNResultLabel);
   auto cnnresultListHandle = evt.getHandle<std::vector<cnn::RegCNNResult>>(itag1);
 
   // lepton energy
   art::InputTag itag2(fRegCNNProngModuleLabel, fRegCNNProngResultLabel);
   auto RegCnnProngResultListHandle = evt.getHandle<std::vector<cnn::RegCNNResult>>(itag2);
 
   // lepton direction
   art::InputTag itag3(fRegCNNDirModuleLabel, fRegCNNDirResultLabel);
   auto RegCnnDirResultListHandle = evt.getHandle<std::vector<cnn::RegCNNResult> >(itag3);
 
   //std::vector<art::Ptr<cnn::Result> > cnnlist;
   // auto cnnresultListHandle2 = evt.getHandle<std::vector<cnn::RegCNNResult>>(fRegCNNModuleLabel);
   //if (cnnresultListHandle2)
   //  art::fill_ptr_vector(cnnlist, cnnresultListHandle2);
 
   // Get Truth information
   if (mclist.size()>0) {
     int neutrino_i = 0;   
     for(size_t iList = 0; (iList < mclist.size()) && (neutrino_i < kMax) ; ++iList) {
       if (mclist[iList]->NeutrinoSet()) {
         const simb::MCNeutrino &nu = mclist[iList]->GetNeutrino();
 
         nueng_truth[neutrino_i]  = nu.Nu().Momentum().E();
         nupdg_truth[neutrino_i]  = nu.Nu().PdgCode(); 
         nuccnc_truth[neutrino_i] = nu.CCNC(); 
         numode_truth[neutrino_i] = nu.Mode();
 
         lepEng_truth[neutrino_i] = nu.Lepton().E();
         lepPDG_truth[neutrino_i] = nu.Lepton().PdgCode();
 
         nuvtxx_truth[neutrino_i] = nu.Nu().Vx();
         nuvtxy_truth[neutrino_i] = nu.Nu().Vy();
         nuvtxz_truth[neutrino_i] = nu.Nu().Vz();
 
         // Now we want to do some final state particle counting
         // We need an instance of the backtracker to find the number of simulated hits for each track
         // Loop over all of the particles
         for (auto const thisPart : particleinventory->MCTruthToParticles_Ps(mclist[iList])) {
           const simb::MCParticle& part = *thisPart;
           int pdg = part.PdgCode();
           // Make sure this is a final state particle
           if (part.StatusCode() != 1) {
             continue;
           }
           // Make sure this particle is a daughter of the neutrino
           if (part.Mother() != 0) {
             continue;
           }
           // GENIE has some fake particles for energy conservation - eg nuclear binding energy. Ignore these
           if (pdg > 2000000000) {
             continue;
           }
           // Also don't care about nuclear recoils
           if (pdg > 1000000) {
             continue;
           }
           switch(abs(pdg)) {
             case 111 : ++nPizero[neutrino_i];   break;
             case 211 : ++nPion[neutrino_i];     break;
             case 2112 : ++nNeutron[neutrino_i]; break;
             case 2212 : ++nProton[neutrino_i];  break;
             default : break;
           }
         } // end of loop over all of the particles
 
         neutrino_i++; 
 
       } // end of existing valid neutrino    
     } // end of loop over neutrinos
 
     nu_truth_N = neutrino_i;  
 
   } // end of if mclist.size()>0
 
   // Get Hit information
   nhits = hits.size();
   InDet = 0;
   if (hits.size()>0)
   {
     bool fid_flag = false;
     for(size_t iHit = 0; iHit < hits.size(); ++iHit)
     {
       art::Ptr<recob::Hit> hit = hits.at(iHit);
       float peakT = hit->PeakTime();
       //unsigned int channel = hit->Channel();
       unsigned int plane = hit->WireID().Plane;
       unsigned int wire = hit->WireID().Wire;
       unsigned int tpc  = hit->WireID().TPC;
       // for dunefd 1x2x6
       if (peakT > 4482.) fid_flag = true; 
       if (plane == 2){
         if (tpc < 4 && wire < 5) fid_flag = true;
         if (tpc > 19 && wire > 474) fid_flag = true;
       }
       if (fid_flag) break; 
     }
     if (!fid_flag) InDet = 1; 
   }
 
   //cut with true vertex in fiducial volume
   FidCut = 0;
   if (nu_truth_N>0){
     if(fabs(nuvtxx_truth[0]) < 310. && fabs(nuvtxy_truth[0]) < 550. && nuvtxz_truth[0] > 50. && nuvtxz_truth[0] < 1250.) FidCut = 1;
     if (fabs(nupdg_truth[0])==14) {
       mutrk_contain = engrecoHandle->longestTrackContained; // 1 = contained, 0 = exiting, -1 = not set
     }
   }
 
   // Get RecoE from DUNE
   if (!engrecoHandle.failedToGet())
   {
     ErecoNu           = engrecoHandle->fNuLorentzVector.E();
     RecoLepEnNu       = engrecoHandle->fLepLorentzVector.E();
     RecoHadEnNu       = engrecoHandle->fHadLorentzVector.E();
     RecoMethodNu      = engrecoHandle->recoMethodUsed;  // 1 = longest reco track + hadronic, 2 = reco shower with highest charge + hadronic, 3 = all hit charges, -1 = not set
     RecoTrackMomMethod = engrecoHandle->trackMomMethod; // 1 = range, 0 = MCS, -1 = not set
     std::cout<< "EnergyReco: "<<ErecoNu << std::endl;
   }
 
   // Get RegCNN Results
   if (!cnnresultListHandle.failedToGet())
   {
     if (!cnnresultListHandle->empty())
     {
       const std::vector<float>& v = (*cnnresultListHandle)[0].fOutput;
       regcnn_energy = v[0];
       for (unsigned int ii = 0; ii < 3; ii++){
         regcnn_vertex[ii] = v[ii];
       }
     }
   }
 
   if (!RegCnnProngResultListHandle.failedToGet())
   {
     if (!RegCnnProngResultListHandle->empty())
     {
       const std::vector<float>& v = (*RegCnnProngResultListHandle)[0].fOutput;
       regcnn_prong_energy = v[0];
     }
   }
 
   if (!RegCnnDirResultListHandle.failedToGet()) {
     if (!RegCnnDirResultListHandle->empty()) {
       const std::vector<float>& v = (*RegCnnDirResultListHandle)[0].fOutput;
       for (unsigned int i= 0; i< v.size(); ++i) {
         regcnn_dir[i] = v[i];
       }
     }
   }
 
   if (regcnn_dir[0]!=-99999 && track_id[0]!=-99999) {
     for (int itrack= 0; itrack< n_track_pad; ++itrack) {
       if (track_id[itrack]==0) {
         double norm_regcnn_dir = TMath::Sqrt(regcnn_dir[0]*regcnn_dir[0]+
             regcnn_dir[1]*regcnn_dir[1]+
             regcnn_dir[2]*regcnn_dir[2]);
         double norm_true_dir = TMath::Sqrt(all_track_true_px[itrack]*all_track_true_px[itrack]+
             all_track_true_py[itrack]*all_track_true_py[itrack]+
             all_track_true_pz[itrack]*all_track_true_pz[itrack]);
         double dot = regcnn_dir[0]*all_track_true_px[itrack]+
           regcnn_dir[1]*all_track_true_py[itrack]+
           regcnn_dir[2]*all_track_true_pz[itrack];
         double cosTheta = dot/norm_regcnn_dir/norm_true_dir;
         regcnn_dir_diff = TMath::ACos(cosTheta)*180./TMath::Pi();
       }
     }
   }
 
   if (regcnn_dir[0]!=-99999 && shower_id[0]!=-99999) {
     for (int ishower= 0; ishower< n_showers; ++ishower) {
       if (shower_id[ishower]==0) {
         double norm_regcnn_dir = TMath::Sqrt(regcnn_dir[0]*regcnn_dir[0]+
             regcnn_dir[1]*regcnn_dir[1]+
             regcnn_dir[2]*regcnn_dir[2]);
         double norm_true_dir = TMath::Sqrt(all_shower_true_px[ishower]*all_shower_true_px[ishower]+
             all_shower_true_py[ishower]*all_shower_true_py[ishower]+
             all_shower_true_pz[ishower]*all_shower_true_pz[ishower]);
         double dot = regcnn_dir[0]*all_shower_true_px[ishower]+
           regcnn_dir[1]*all_shower_true_py[ishower]+
           regcnn_dir[2]*all_shower_true_pz[ishower];
         double cosTheta = dot/norm_regcnn_dir/norm_true_dir;
         regcnn_nue_dir_diff = TMath::ACos(cosTheta)*180./TMath::Pi();
       }
     }
   }
 
   // fill entry
   fTree->Fill();
   return;
 }

void myana::RegCNNAna::beginJob ( )

overridevirtual

Reimplemented from art::EDAnalyzer.

Definition at line 214 of file RegCNNAna_module.cc.

                               {
   art::ServiceHandle<art::TFileService> tfs;
 
   fTree = tfs->make<TTree>("anatree", "anatree");
   fTree->Branch("ievent",              &ievt,                 "ievent/I");
   fTree->Branch("InDet",               &InDet,                "InDet/I");
   fTree->Branch("FidCut",              &FidCut,               "FidCut/I");
   fTree->Branch("MuTrackCont",         &mutrk_contain,        "MuTrackCont/I");
   fTree->Branch("CNNEnergy",           &regcnn_energy,        "CNNEnergy/F");
   fTree->Branch("CNNLepEnergy",        &regcnn_prong_energy,  "CNNLepEnergy/F");
   fTree->Branch("CNNVertex",           regcnn_vertex,         "CNNVertex[3]/F");
   fTree->Branch("CNNDir",              regcnn_dir,            "CNNDir[3]/F");
   fTree->Branch("CNNDirDiff",          &regcnn_dir_diff,      "CNNDirDiff/F");
   fTree->Branch("CNNNueDirDiff",       &regcnn_nue_dir_diff,  "CNNNueDirDiff/F");
 
   // MC truth
   fTree->Branch("NuTruthN",            &nu_truth_N,     "NuTruthN/I");  
   fTree->Branch("NuEngTruth",          nueng_truth,     "NuEngTruth[NuTruthN]/D");   
   fTree->Branch("NuPDGTruth",          nupdg_truth,     "NuPDGTruth[NuTruthN]/I");   
   fTree->Branch("NuModeTruth",         numode_truth,    "NuModeTruth[NuTruthN]/I"); 
   fTree->Branch("NuCCNCTruth",         nuccnc_truth,    "NuCCNCTruth[NuTruthN]/I");   
   fTree->Branch("NuVtxXTruth",         nuvtxx_truth,    "NuVtxXTruth[NuTruthN]/D"); 
   fTree->Branch("NuVtxYTruth",         nuvtxy_truth,    "NuVtxYTruth[NuTruthN]/D"); 
   fTree->Branch("NuVtxZTruth",         nuvtxz_truth,    "NuVtxZTruth[NuTruthN]/D"); 
   // lepton truth
   fTree->Branch("LepPDGTruth",         lepPDG_truth,    "LepPDGTruth[NuTruthN]/I");
   fTree->Branch("LepEngTruth",         lepEng_truth,    "LepEngTruth[NuTruthN]/D");
   fTree->Branch("nProtonTruth",        nProton,         "nProtonTruth[NuTruthN]/I");
   fTree->Branch("nPionTruth",          nPion,           "nPionTruth[NuTruthN]/I");
   fTree->Branch("nPizeroTruth",        nPizero,         "nPizeroTruth[NuTruthN]/I");
   fTree->Branch("nNeutronTruth",       nNeutron,        "nNeutronTruth[NuTruthN]/I");
 
   // Reco. from DUNE, energy
   fTree->Branch("NHits",               &nhits,          "NHits/I");
   fTree->Branch("ErecoNu",             &ErecoNu,        "ErecoNu/D");
   fTree->Branch("RecoLepEnNu",         &RecoLepEnNu,    "RecoLepEnNu/D");
   fTree->Branch("RecoHadEnNu",         &RecoHadEnNu,    "RecoHadEnNu/D");
   fTree->Branch("RecoMethodNu",        &RecoMethodNu,   "RecoMethodNu/I");
   fTree->Branch("RecoTrackMomMethod",  &RecoTrackMomMethod, "RecoTrackMomMethod/I");
   fTree->Branch("RecoMuTrackLength",   &RecoMuTrackLength,  "RecoMuTrackLength/D");
   fTree->Branch("UncorrectedHadEn",    &fUncorrectedHadEn,    "UncorrectedHadEn/D");
   fTree->Branch("UncorrectedMuMomMCS", &fUncorrectedMuMomMCS, "UncorrectedMuMomMCS/D");
   fTree->Branch("UncorrectedElectronEnergy", &fUncorrectedElectronEnergy, "UncorrectedElectronEnergy/D");
   fTree->Branch("UncorrectedHadEnFromShw", &fUncorrectedHadEnFromShw, "UncorrectedHadEnFromShw/D");
 
   // direction
   fTree->Branch("n_track_pad", &n_track_pad, "n_track_pad/I");
   fTree->Branch("track_id", track_id, "track_id[n_track_pad]/I");
   fTree->Branch("all_track_true_pdg", all_track_true_pdg, "all_track_true_pdg[n_track_pad]/I");
   fTree->Branch("all_track_true_pdg_mom", all_track_true_pdg_mom, "all_track_true_pdg_mom[n_track_pad]/I");
   fTree->Branch("all_track_px", all_track_px, "all_track_px[n_track_pad]/D");
   fTree->Branch("all_track_py", all_track_py, "all_track_py[n_track_pad]/D");
   fTree->Branch("all_track_pz", all_track_pz, "all_track_pz[n_track_pad]/D");
   fTree->Branch("all_track_true_px", all_track_true_px, "all_track_true_px[n_track_pad]/D");
   fTree->Branch("all_track_true_py", all_track_true_py, "all_track_true_py[n_track_pad]/D");
   fTree->Branch("all_track_true_pz", all_track_true_pz, "all_track_true_pz[n_track_pad]/D");
 
   fTree->Branch("n_showers", &n_showers, "n_showers/I");
   fTree->Branch("shower_id", shower_id, "shower_id[n_showers]/I");
   fTree->Branch("all_shower_true_pdg", all_shower_true_pdg, "all_shower_true_pdg[n_showers]/I");
   fTree->Branch("all_shower_true_pdg_mom", all_shower_true_pdg_mom, "all_shower_true_pdg_mom[n_showers]/I");
   fTree->Branch("all_shower_px", all_shower_px, "all_shower_px[n_showers]/D");
   fTree->Branch("all_shower_py", all_shower_py, "all_shower_py[n_showers]/D");
   fTree->Branch("all_shower_pz", all_shower_pz, "all_shower_pz[n_showers]/D");
   fTree->Branch("all_shower_true_px", all_shower_true_px, "all_shower_true_px[n_showers]/D");
   fTree->Branch("all_shower_true_py", all_shower_true_py, "all_shower_true_py[n_showers]/D");
   fTree->Branch("all_shower_true_pz", all_shower_true_pz, "all_shower_true_pz[n_showers]/D");
 }

void myana::RegCNNAna::beginSubRun ( const art::SubRun & sr )

override

Definition at line 283 of file RegCNNAna_module.cc.

283 {

284 }

double myana::RegCNNAna::CalculateEnergyFromCharge ( const double charge )

private

Converts deposited charge into energy by converting to number of electrons and correcting for average recombination.

Parameters

charge the deposited charge

Returns: the reconstructed deposited energy

Definition at line 796 of file RegCNNAna_module.cc.

 {
   return fCalorimetryAlg.ElectronsFromADCArea(charge,2)*1./fRecombFactor/util::kGeVToElectrons;
 }

void myana::RegCNNAna::endJob ( )

overridevirtual

Reimplemented from art::EDAnalyzer.

Definition at line 625 of file RegCNNAna_module.cc.

625 {

626 }

void myana::RegCNNAna::endSubRun ( const art::SubRun & sr )

override

Definition at line 628 of file RegCNNAna_module.cc.

628 {

629 }

std::vector< std::pair< const simb::MCParticle *, double > > myana::RegCNNAna::get_sortedMCParticle ( std::unordered_map< const simb::MCParticle *, double > mcEMap )

private

Definition at line 802 of file RegCNNAna_module.cc.

                                                                                            {
   std::vector<std::pair<const simb::MCParticle*, double> > outVec;
   double total_E = 0;
   for (std::pair<const simb::MCParticle*, double> const& p: mcEMap) {
     outVec.push_back(p);
     total_E += p.second;
   }
   std::sort(outVec.begin(), outVec.end(), [](std::pair<const simb::MCParticle*, double> a, std::pair<const simb::MCParticle*, double> b){return a.second > b.second;});
   if (abs(total_E) < 1e-6) {total_E = 1;} // protect agains zero division
   for (std::pair<const simb::MCParticle*, double> & p: outVec) {
     p.second /= total_E;
   }
 
   return outVec;
 }

art::Ptr< recob::Shower > myana::RegCNNAna::GetHighestChargeShower	(	detinfo::DetectorClocksData const &	clockData,
		detinfo::DetectorPropertiesData const &	detProp,
		const art::Event &	event
	)

private

Definition at line 746 of file RegCNNAna_module.cc.

 {
   art::Ptr<recob::Shower> pShower(art::Ptr<recob::Shower>(art::ProductID("nullShower")));
   const std::vector<art::Ptr<recob::Shower> > showers(dune_ana::DUNEAnaEventUtils::GetShowers(event, fShowerLabel));
   if (0 == showers.size())
     return pShower;
 
   double maxCharge(std::numeric_limits<double>::lowest());
   for (unsigned int iShower = 0; iShower < showers.size(); ++iShower)
   {
     const std::vector<art::Ptr<recob::Hit> > showerHits(dune_ana::DUNEAnaHitUtils::GetHitsOnPlane(dune_ana::DUNEAnaShowerUtils::GetHits(showers[iShower],
             event,fShowerToHitLabel),2));
     const double showerCharge(dune_ana::DUNEAnaHitUtils::LifetimeCorrectedTotalHitCharge(clockData, detProp, showerHits));
     if (showerCharge-maxCharge > std::numeric_limits<double>::epsilon())
     {
       maxCharge = showerCharge;
       pShower = showers[iShower];
     }
   }
 
   /*************************
   // get all PFParticles first, and then get tracks by looping all the PFParticles
   art::Ptr<recob::Shower> pShower(art::Ptr<recob::Shower>(art::ProductID("nullShower")));
   // Get all PFParticles
   const std::vector<art::Ptr<recob::PFParticle>> particles = dune_ana::DUNEAnaEventUtils::GetPFParticles(event, fParticleLabel);
   if (0 == particles.size())
   return pShower;
 
   double maxCharge(std::numeric_limits<double>::lowest());
   for (const art::Ptr<recob::PFParticle> &particle : particles) {
 // Get the shower if this particle is shower-like
 if (dune_ana::DUNEAnaPFParticleUtils::IsShower(particle, event, fParticleLabel, fShowerLabel)) {
 const art::Ptr<recob::Shower> shower = dune_ana::DUNEAnaPFParticleUtils::GetShower(particle, event, fParticleLabel, fShowerLabel);
 const std::vector<art::Ptr<recob::Hit> > showerHits(dune_ana::DUNEAnaHitUtils::GetHitsOnPlane(dune_ana::DUNEAnaShowerUtils::GetHits(shower, event, fShowerToHitLabel), 2));
 const double showerCharge(dune_ana::DUNEAnaHitUtils::LifetimeCorrectedTotalHitCharge(showerHits));
 if (showerCharge-maxCharge > std::numeric_limits<double>::epsilon()) {
 maxCharge = showerCharge;
 pShower = shower;
 }
 }
 } // end of PFParticles
    ************************/
 
   return pShower;
 }

art::Ptr< recob::Track > myana::RegCNNAna::GetLongestTrack ( const art::Event & event )

private

Definition at line 701 of file RegCNNAna_module.cc.

 {
   art::Ptr<recob::Track> pTrack(art::Ptr<recob::Track>(art::ProductID("nullTrack")));
   const std::vector<art::Ptr<recob::Track> > tracks(dune_ana::DUNEAnaEventUtils::GetTracks(event, fTrackLabel));
   if (0 == tracks.size())
     return pTrack;
 
   double longestLength(std::numeric_limits<double>::lowest());
   for (unsigned int iTrack = 0; iTrack < tracks.size(); ++iTrack)
   {
     const double length(tracks[iTrack]->Length());
     if (length-longestLength > std::numeric_limits<double>::epsilon())
     {
       longestLength = length;
       pTrack = tracks[iTrack];
     }
   }
 
   /***********************
   // get all PFParticles first, and then get tracks by looping all the PFParticles
   art::Ptr<recob::Track> pTrack(art::Ptr<recob::Track>(art::ProductID("nullTrack")));
   // Get all PFParticles
   const std::vector<art::Ptr<recob::PFParticle>> particles = dune_ana::DUNEAnaEventUtils::GetPFParticles(event, fParticleLabel);
   if (0 == particles.size())
   return pTrack;
 
   double longestLength(std::numeric_limits<double>::lowest());
   for (const art::Ptr<recob::PFParticle> &particle : particles) {
 // Get the track if this particle is track-like
 if (dune_ana::DUNEAnaPFParticleUtils::IsTrack(particle, event, fParticleLabel, fTrackLabel)) {
 const art::Ptr<recob::Track> trk = dune_ana::DUNEAnaPFParticleUtils::GetTrack(particle, event, fParticleLabel, fTrackLabel);
 const double length(trk->Length());
 if (length-longestLength > std::numeric_limits<double>::epsilon()) {
 longestLength = length;
 pTrack = trk;
 }
 }
 } // end of PFParticles
    ************************/
 
   return pTrack;
 }

void myana::RegCNNAna::reconfigure ( fhicl::ParameterSet const & p )

Definition at line 193 of file RegCNNAna_module.cc.

 {
   fMCGenModuleLabel       = pset.get<std::string>("MCGenModuleLabel");
   fRegCNNModuleLabel      = pset.get<std::string>("RegCNNModuleLabel");
   fRegCNNResultLabel      = pset.get<std::string>("RegCNNResultLabel");
   fRegCNNProngModuleLabel = pset.get<std::string>("RegCNNProngModuleLabel");
   fRegCNNProngResultLabel = pset.get<std::string>("RegCNNProngResultLabel");
   fRegCNNDirModuleLabel   = pset.get<std::string>("RegCNNDirModuleLabel");
   fRegCNNDirResultLabel   = pset.get<std::string>("RegCNNDirResultLabel");
   fHitsModuleLabel        = pset.get<std::string>("HitsModuleLabel");
   fEnergyRecoNuLabel      = pset.get<std::string>("EnergyRecoNuLabel");
   fTrackToHitLabel        = pset.get<std::string>("TrackToHitLabel");
   fShowerToHitLabel       = pset.get<std::string>("ShowerToHitLabel");
   fParticleLabel          = pset.get<std::string>("ParticleLabel");
   fTrackLabel             = pset.get<std::string>("TrackLabel");
   fTrackLabelDir          = pset.get<std::string>("TrackLabelDir");
   fShowerLabel            = pset.get<std::string>("ShowerLabel");
   fShowerLabelDir         = pset.get<std::string>("ShowerLabelDir");
   fRecombFactor           = pset.get<double>("RecombFactor");
 }

void myana::RegCNNAna::reset ( )

Definition at line 631 of file RegCNNAna_module.cc.

 {
   // set default to nonsense value
   ievt               = -9999;
   mutrk_contain      = -999;
   regcnn_energy      = -99999;
   regcnn_prong_energy      = -99999;
   ErecoNu            = -99999;
   RecoLepEnNu        = -99999;
   RecoHadEnNu        = -99999;
   RecoMethodNu       = -99999;
   RecoTrackMomMethod = -99999;
 
   fUncorrectedHadEn    = -99999;
   RecoMuTrackLength    = -99999;
   fUncorrectedMuMomMCS = -99999;
   fUncorrectedElectronEnergy = -99999;
   fUncorrectedHadEnFromShw = -99999;
 
   for (int ii = 0; ii < 3; ii++){ 
     regcnn_vertex[ii] = -99999;
     regcnn_dir[ii] = -99999;
   }
   regcnn_dir_diff = -99999;
   regcnn_nue_dir_diff = -99999;
 
   nu_truth_N = 0;
   n_track_pad = 0;
   n_showers = 0;
   for (int ii = 0; ii < kMax; ++ii)
   {
     nupdg_truth[ii]  = -99999;
     numode_truth[ii] = -99999;
     nuccnc_truth[ii] = -99999;
     nueng_truth[ii]  = -99999;
     lepPDG_truth[ii] = -99999;
     lepEng_truth[ii] = -99999;
     nuvtxx_truth[ii] = -99999;
     nuvtxy_truth[ii] = -99999;
     nuvtxz_truth[ii] = -99999;
     nProton[ii]      = 0;
     nPion[ii]        = 0;
     nPizero[ii]      = 0;
     nNeutron[ii]     = 0;
 
     track_id[ii] = -99999;
     all_track_true_pdg[ii] = -99999;
     all_track_true_pdg_mom[ii] = -99999;
     all_track_px[ii] = -99999;
     all_track_py[ii] = -99999;
     all_track_pz[ii] = -99999;
     all_track_true_px[ii] = -99999;
     all_track_true_py[ii] = -99999;
     all_track_true_pz[ii] = -99999;
 
     shower_id[ii] = -99999;
     all_shower_true_pdg[ii] = -99999;
     all_shower_true_pdg_mom[ii] = -99999;
     all_shower_px[ii] = -99999;
     all_shower_py[ii] = -99999;
     all_shower_pz[ii] = -99999;
     all_shower_true_px[ii] = -99999;
     all_shower_true_py[ii] = -99999;
     all_shower_true_pz[ii] = -99999;
   }
 }

Member Data Documentation

double myana::RegCNNAna::all_shower_px[kMax]

private

Definition at line 143 of file RegCNNAna_module.cc.

double myana::RegCNNAna::all_shower_py[kMax]

private

Definition at line 144 of file RegCNNAna_module.cc.

double myana::RegCNNAna::all_shower_pz[kMax]

private

Definition at line 145 of file RegCNNAna_module.cc.

int myana::RegCNNAna::all_shower_true_pdg[kMax]

private

Definition at line 141 of file RegCNNAna_module.cc.

int myana::RegCNNAna::all_shower_true_pdg_mom[kMax]

private

Definition at line 142 of file RegCNNAna_module.cc.

double myana::RegCNNAna::all_shower_true_px[kMax]

private

Definition at line 146 of file RegCNNAna_module.cc.

double myana::RegCNNAna::all_shower_true_py[kMax]

private

Definition at line 147 of file RegCNNAna_module.cc.

double myana::RegCNNAna::all_shower_true_pz[kMax]

private

Definition at line 148 of file RegCNNAna_module.cc.

double myana::RegCNNAna::all_track_px[kMax]

private

Definition at line 132 of file RegCNNAna_module.cc.

double myana::RegCNNAna::all_track_py[kMax]

private

Definition at line 133 of file RegCNNAna_module.cc.

double myana::RegCNNAna::all_track_pz[kMax]

private

Definition at line 134 of file RegCNNAna_module.cc.

int myana::RegCNNAna::all_track_true_pdg[kMax]

private

Definition at line 130 of file RegCNNAna_module.cc.

int myana::RegCNNAna::all_track_true_pdg_mom[kMax]

private

Definition at line 131 of file RegCNNAna_module.cc.

double myana::RegCNNAna::all_track_true_px[kMax]

private

Definition at line 135 of file RegCNNAna_module.cc.

double myana::RegCNNAna::all_track_true_py[kMax]

private

Definition at line 136 of file RegCNNAna_module.cc.

double myana::RegCNNAna::all_track_true_pz[kMax]

private

Definition at line 137 of file RegCNNAna_module.cc.

art::ServiceHandle<cheat::BackTrackerService> myana::RegCNNAna::backtracker

private

Definition at line 177 of file RegCNNAna_module.cc.

double myana::RegCNNAna::ErecoNu

private

Definition at line 122 of file RegCNNAna_module.cc.

calo::CalorimetryAlg myana::RegCNNAna::fCalorimetryAlg

private

the calorimetry algorithm

Definition at line 158 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fEnergyRecoNuLabel

private

Definition at line 167 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fHitsModuleLabel

private

Definition at line 166 of file RegCNNAna_module.cc.

int myana::RegCNNAna::FidCut

private

Definition at line 103 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fMCGenModuleLabel

private

Definition at line 159 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fParticleLabel

private

Definition at line 170 of file RegCNNAna_module.cc.

double myana::RegCNNAna::fRecombFactor

private

the average reccombination factor

Definition at line 175 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fRegCNNDirModuleLabel

private

Definition at line 164 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fRegCNNDirResultLabel

private

Definition at line 165 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fRegCNNModuleLabel

private

Definition at line 160 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fRegCNNProngModuleLabel

private

Definition at line 162 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fRegCNNProngResultLabel

private

Definition at line 163 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fRegCNNResultLabel

private

Definition at line 161 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fShowerLabel

private

Definition at line 173 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fShowerLabelDir

private

Definition at line 174 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fShowerToHitLabel

private

Definition at line 169 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fTrackLabel

private

Definition at line 171 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fTrackLabelDir

private

Definition at line 172 of file RegCNNAna_module.cc.

std::string myana::RegCNNAna::fTrackToHitLabel

private

Definition at line 168 of file RegCNNAna_module.cc.

TTree* myana::RegCNNAna::fTree

private

Definition at line 92 of file RegCNNAna_module.cc.

double myana::RegCNNAna::fUncorrectedElectronEnergy

private

Definition at line 155 of file RegCNNAna_module.cc.

double myana::RegCNNAna::fUncorrectedHadEn

private

Definition at line 151 of file RegCNNAna_module.cc.

double myana::RegCNNAna::fUncorrectedHadEnFromShw

private

Definition at line 156 of file RegCNNAna_module.cc.

double myana::RegCNNAna::fUncorrectedMuMomMCS

private

Definition at line 153 of file RegCNNAna_module.cc.

int myana::RegCNNAna::ievt

private

Definition at line 93 of file RegCNNAna_module.cc.

int myana::RegCNNAna::InDet

private

Definition at line 102 of file RegCNNAna_module.cc.

double myana::RegCNNAna::lepEng_truth[kMax]

private

Definition at line 115 of file RegCNNAna_module.cc.

int myana::RegCNNAna::lepPDG_truth[kMax]

private

Definition at line 114 of file RegCNNAna_module.cc.

int myana::RegCNNAna::mutrk_contain

private

Definition at line 104 of file RegCNNAna_module.cc.

int myana::RegCNNAna::n_showers

private

Definition at line 139 of file RegCNNAna_module.cc.

int myana::RegCNNAna::n_track_pad

private

Definition at line 128 of file RegCNNAna_module.cc.

int myana::RegCNNAna::nhits

private

Definition at line 105 of file RegCNNAna_module.cc.

int myana::RegCNNAna::nNeutron[kMax]

private

Definition at line 119 of file RegCNNAna_module.cc.

int myana::RegCNNAna::nPion[kMax]

private

Definition at line 118 of file RegCNNAna_module.cc.

int myana::RegCNNAna::nPizero[kMax]

private

Definition at line 117 of file RegCNNAna_module.cc.

int myana::RegCNNAna::nProton[kMax]

private

Definition at line 120 of file RegCNNAna_module.cc.

int myana::RegCNNAna::nu_truth_N

private

Definition at line 106 of file RegCNNAna_module.cc.

int myana::RegCNNAna::nuccnc_truth[kMax]

private

Definition at line 109 of file RegCNNAna_module.cc.

double myana::RegCNNAna::nueng_truth[kMax]

private

Definition at line 110 of file RegCNNAna_module.cc.

int myana::RegCNNAna::numode_truth[kMax]

private

Definition at line 108 of file RegCNNAna_module.cc.

int myana::RegCNNAna::nupdg_truth[kMax]

private

Definition at line 107 of file RegCNNAna_module.cc.

double myana::RegCNNAna::nuvtxx_truth[kMax]

private

Definition at line 111 of file RegCNNAna_module.cc.

double myana::RegCNNAna::nuvtxy_truth[kMax]

private

Definition at line 112 of file RegCNNAna_module.cc.

double myana::RegCNNAna::nuvtxz_truth[kMax]

private

Definition at line 113 of file RegCNNAna_module.cc.

art::ServiceHandle<cheat::ParticleInventoryService> myana::RegCNNAna::particleinventory

private

Definition at line 178 of file RegCNNAna_module.cc.

double myana::RegCNNAna::RecoHadEnNu

private

Definition at line 124 of file RegCNNAna_module.cc.

double myana::RegCNNAna::RecoLepEnNu

private

Definition at line 123 of file RegCNNAna_module.cc.

int myana::RegCNNAna::RecoMethodNu

private

Definition at line 125 of file RegCNNAna_module.cc.

double myana::RegCNNAna::RecoMuTrackLength

private

Definition at line 152 of file RegCNNAna_module.cc.

int myana::RegCNNAna::RecoTrackMomMethod

private

Definition at line 126 of file RegCNNAna_module.cc.

float myana::RegCNNAna::regcnn_dir[3]

private

Definition at line 97 of file RegCNNAna_module.cc.

float myana::RegCNNAna::regcnn_dir_diff

private

Definition at line 98 of file RegCNNAna_module.cc.

float myana::RegCNNAna::regcnn_energy

private

Definition at line 94 of file RegCNNAna_module.cc.

float myana::RegCNNAna::regcnn_nue_dir_diff

private

Definition at line 99 of file RegCNNAna_module.cc.

float myana::RegCNNAna::regcnn_prong_energy

private

Definition at line 95 of file RegCNNAna_module.cc.

float myana::RegCNNAna::regcnn_vertex[3]

private

Definition at line 96 of file RegCNNAna_module.cc.

int myana::RegCNNAna::shower_id[kMax]

private

Definition at line 140 of file RegCNNAna_module.cc.

int myana::RegCNNAna::track_id[kMax]

private

Definition at line 129 of file RegCNNAna_module.cc.

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

dunereco/dunereco/RegCNN/macro/RegCNNAna_module.cc

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation