NeutrinoEnergyRecoAlg class. More...

#include <NeutrinoEnergyRecoAlg.h>

Classes
struct	EnergyRecoInputHolder
	EnergyRecoInputHolder struct. More...

Public Member Functions
	NeutrinoEnergyRecoAlg (const fhicl::ParameterSet &pset, const std::string &trackLabel, const std::string &showerLabel, const std::string &hitLabel, const std::string wireLabel, const std::string &trackToHitLabel, const std::string &showerToHitLabel, const std::string &hitToSpacePointLabel)
	Constructor. More...

dune::EnergyRecoOutput	CalculateNeutrinoEnergy (const art::Ptr< recob::Track > &pMuonTrack, const art::Event &event)
	Calculates neutrino energy using a muon track (the muon track may be ignored if it isn't of a suitable quality) More...

dune::EnergyRecoOutput	CalculateNeutrinoEnergy (const art::Ptr< recob::Shower > &pElectronShower, const art::Event &event)
	Calculates neutrino energy using an electron shower(the electron may be ignored if it isn't of a suitable quality) More...

dune::EnergyRecoOutput	CalculateNeutrinoEnergy (const art::Event &event)
	Calculates neutrino energy by summing wire charges. More...

dune::EnergyRecoOutput	CalculateNeutrinoEnergyViaMuonRanging (const art::Ptr< recob::Track > &pMuonTrack, const art::Event &event)
	Calculates neutrino energy explicitly using muon momentum by range. More...

dune::EnergyRecoOutput	CalculateNeutrinoEnergyViaMuonMCS (const art::Ptr< recob::Track > &pMuonTrack, const art::Event &event)
	Calculates neutrino energy explicitly using muon multiple scattering. More...

Private Types
enum	EnergyRecoMethod { kRecoMethodNotSet = -1, kMuonAndHadronic = 1, kElectronAndHadronic, kAllCharges }
	The energy reconstruction method. More...

enum	MuonTrackMethod { kTrackMethodNotSet = -1, kMCS, kContained }
	The muon momentum reconstruction method. More...

enum	MuonContainmentStatus { kContainmentNotSet = -1, kIsExiting, kIsContained }
	The muon containment status. More...

typedef Position4_t	Momentum4_t

Private Member Functions
double	CalculateMuonMomentumByRange (const art::Ptr< recob::Track > pMuonTrack)
	Calculates muon momentum by range. More...

double	CalculateMuonMomentumByMCS (const art::Ptr< recob::Track > pMuonTrack)
	Calculates muon momentum by multiple coulomb scattering. More...

double	CalculateElectronEnergy (const art::Ptr< recob::Shower > &pElectronShower, const art::Event &event)
	Calculates an electron shower's deposited energy by converting its deposited charge. More...

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

bool	IsContained (const std::vector< art::Ptr< recob::Hit > > &hits, const art::Event &event)
	Checks if a set of track hits are contained within a central volume of the detector. More...

Momentum4_t	CalculateParticle4Momentum (const double mass, const double momentum, const double directionX, const double directionY, const double directionZ)
	Calculates a particle's four-momentum vector. More...

double	CalculateLinearlyCorrectedValue (const double value, const double correctionGradient, const double correctionIntercept)
	Linearly corrects a value. More...

double	CalculateUncorrectedMuonMomentumByMCS (const art::Ptr< recob::Track > &pMuonTrack)
	Calculates the raw muon momentum by multiple coulomb scattering. More...

dune::EnergyRecoOutput	CalculateNeutrinoEnergy (const std::vector< art::Ptr< recob::Hit > > &leptonHits, const art::Event &event, const EnergyRecoInputHolder &energyRecoInputHolder)
	Calculates neutrino energy by summing hadronic deposited energy and lepton energy. More...

bool	IsPointContained (const double x, const double y, const double z)
	Check's if a point is contained within a central detector volume. More...

Private Attributes
double	kMuonMass = 0.1056583745
	the muon mass (hardcoded unfortunately) More...

double	kElectronMass = 0.0005109989461
	the electron mass (hardcoded unfortunately); More...

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

double	fGradTrkMomRange
	the correction gradient for muon momentum by range More...

double	fIntTrkMomRange
	the correction intercept for muon momentum by range More...

double	fGradTrkMomMCS
	the correction gradient for muom momentum by MCS More...

double	fIntTrkMomMCS
	the correction intercept for muon momentum by MCS More...

double	fGradNuMuHadEnCont
	the hqdronic energy correction gradient for numu+contained muon More...

double	fIntNuMuHadEnCont
	the hadronic energy correction intercept for numu+contained muon More...

double	fGradNuMuHadEnExit
	the hadronic energy correction gradient for numu+exiting muon More...

double	fIntNuMuHadEnExit
	the hadronic energy correction intercept for numu+exiting muon More...

double	fGradShwEnergy
	the electron shower energy correction gradient More...

double	fIntShwEnergy
	the electron shower energy correction intercept More...

double	fGradNuEHadEn
	the hadronic energy correction gradient for nue More...

double	fIntNuEHadEn
	the hadronic energy correction intercept for nue More...

double	fDistanceToWallThreshold
	the min distance from a detector wall to be considered contained More...

double	fMuonRangeToMCSThreshold
	the ratio threshold at which MCS is used for contained muons More...

double	fRecombFactor
	the average reccombination factor More...

std::string	fTrackLabel
	the track label More...

std::string	fShowerLabel
	the shower label More...

std::string	fHitLabel
	the hit label More...

std::string	fWireLabel
	the wire label More...

std::string	fTrackToHitLabel
	the associated track-to-hit label More...

std::string	fShowerToHitLabel
	the associated shower-to-hit label More...

std::string	fHitToSpacePointLabel
	the associated hit-to-space point label More...

Detailed Description

NeutrinoEnergyRecoAlg class.

Definition at line 31 of file NeutrinoEnergyRecoAlg.h.

Member Typedef Documentation

typedef Position4_t dune::NeutrinoEnergyRecoAlg::Momentum4_t

private

Definition at line 101 of file NeutrinoEnergyRecoAlg.h.

Member Enumeration Documentation

enum dune::NeutrinoEnergyRecoAlg::EnergyRecoMethod

private

The energy reconstruction method.

Enumerator
kRecoMethodNotSet	method not set
kMuonAndHadronic	muon momentum and hadronic deposited energy method
kElectronAndHadronic	electron deposited energy and hadronic deposited energy method
kAllCharges	summed wire charges

Definition at line 107 of file NeutrinoEnergyRecoAlg.h.

         {
             kRecoMethodNotSet = -1,                               ///< method not set
             kMuonAndHadronic = 1,                                 ///< muon momentum and hadronic deposited energy method
             kElectronAndHadronic,                                 ///< electron deposited energy and hadronic deposited energy method
             kAllCharges                                           ///< summed wire charges
         };

enum dune::NeutrinoEnergyRecoAlg::MuonContainmentStatus

private

The muon containment status.

Enumerator
kContainmentNotSet	Containment not set.
kIsExiting	Muon exits.
kIsContained	Muon is contained.

Definition at line 122 of file NeutrinoEnergyRecoAlg.h.

         {
             kContainmentNotSet = -1,                              ///< Containment not set
             kIsExiting,                                           ///< Muon exits
             kIsContained                                          ///< Muon is contained
         };

enum dune::NeutrinoEnergyRecoAlg::MuonTrackMethod

private

The muon momentum reconstruction method.

Enumerator
kTrackMethodNotSet	method not set
kMCS	muon momentum by multiple scattering
kContained	muon momentum by range

Definition at line 115 of file NeutrinoEnergyRecoAlg.h.

         {
             kTrackMethodNotSet = -1,                              ///< method not set
             kMCS,                                                 ///< muon momentum by multiple scattering
             kContained                                            ///< muon momentum by range
         };

Constructor & Destructor Documentation

dune::NeutrinoEnergyRecoAlg::NeutrinoEnergyRecoAlg	(	const fhicl::ParameterSet &	pset,
		const std::string &	trackLabel,
		const std::string &	showerLabel,
		const std::string &	hitLabel,
		const std::string	wireLabel,
		const std::string &	trackToHitLabel,
		const std::string &	showerToHitLabel,
		const std::string &	hitToSpacePointLabel
	)

Constructor.

Parameters

pset	the FCL parameter set
trackLabel	the track label
showerLabel	the shower label
hitLabel	the hit label
wireLabel	the wire label
trackToHitLabel	the associated track-to-hit label
showerToHitLabel	the associated shower-to-hit label
hitToSpacePointLabel	the associated hit-to-space point label

Definition at line 33 of file NeutrinoEnergyRecoAlg.cc.

                                                                                                                 :
     fCalorimetryAlg(pset.get<fhicl::ParameterSet>("CalorimetryAlg")),
     fGradTrkMomRange(pset.get<double>("GradTrkMomRange")),
     fIntTrkMomRange(pset.get<double>("IntTrkMomRange")),
     fGradTrkMomMCS(pset.get<double>("GradTrkMomMCS")),
     fIntTrkMomMCS(pset.get<double>("IntTrkMomMCS")),
     fGradNuMuHadEnCont(pset.get<double>("GradNuMuHadEnCont")),
     fIntNuMuHadEnCont(pset.get<double>("IntNuMuHadEnCont")),
     fGradNuMuHadEnExit(pset.get<double>("GradNuMuHadEnExit")),
     fIntNuMuHadEnExit(pset.get<double>("IntNuMuHadEnExit")),
     fGradShwEnergy(pset.get<double>("GradShwEnergy")),
     fIntShwEnergy(pset.get<double>("IntShwEnergy")),
     fGradNuEHadEn(pset.get<double>("GradNuEHadEn")),
     fIntNuEHadEn(pset.get<double>("IntNuEHadEn")),
     fDistanceToWallThreshold(pset.get<double>("DistanceToWallThreshold")),
     fMuonRangeToMCSThreshold(pset.get<double>("MuonRangeToMCSThreshold")),
     fRecombFactor(pset.get<double>("RecombFactor")),
     fTrackLabel(trackLabel),
     fShowerLabel(showerLabel),
     fHitLabel(hitLabel),
     fWireLabel(wireLabel),
     fTrackToHitLabel(trackToHitLabel),
     fShowerToHitLabel(showerToHitLabel),
     fHitToSpacePointLabel(hitToSpacePointLabel)
 {
 }

Member Function Documentation

double dune::NeutrinoEnergyRecoAlg::CalculateElectronEnergy	(	const art::Ptr< recob::Shower > &	pElectronShower,
		const art::Event &	event
	)

private

Calculates an electron shower's deposited energy by converting its deposited charge.

Parameters

pElectronShower	the electron shower
event	the art event

Returns: the reconstructed electron energy

Definition at line 251 of file NeutrinoEnergyRecoAlg.cc.

 {
     const std::vector<art::Ptr<recob::Hit> > electronHits(dune_ana::DUNEAnaHitUtils::GetHitsOnPlane(dune_ana::DUNEAnaShowerUtils::GetHits(pElectronShower, event, fShowerToHitLabel),2));
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(event);
     auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(event, clockData);
     const double electronObservedCharge(dune_ana::DUNEAnaHitUtils::LifetimeCorrectedTotalHitCharge(clockData, detProp, electronHits));
     const double uncorrectedElectronEnergy(this->CalculateEnergyFromCharge(electronObservedCharge));
 
     return this->CalculateLinearlyCorrectedValue(uncorrectedElectronEnergy, fGradShwEnergy, fIntShwEnergy);
 }

double dune::NeutrinoEnergyRecoAlg::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 264 of file NeutrinoEnergyRecoAlg.cc.

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

double dune::NeutrinoEnergyRecoAlg::CalculateLinearlyCorrectedValue	(	const double	value,
		const double	correctionGradient,
		const double	correctionIntercept
	)

private

Linearly corrects a value.

Parameters

value	the raw value
correctionGradient	the linear correction gradient
correctionIntercept	the linear correction intercept

Returns: the linearly corrected value

Definition at line 289 of file NeutrinoEnergyRecoAlg.cc.

 {
     return (value - correctionIntercept) / correctionGradient;
 }

double dune::NeutrinoEnergyRecoAlg::CalculateMuonMomentumByMCS ( const art::Ptr< recob::Track > pMuonTrack )

private

Calculates muon momentum by multiple coulomb scattering.

Parameters

pMuonTrack the muon track

Returns: the reconstructed muon momentum

Definition at line 243 of file NeutrinoEnergyRecoAlg.cc.

 {
     const double uncorrectedMomentum(this->CalculateUncorrectedMuonMomentumByMCS(pMuonTrack));
     return this->CalculateLinearlyCorrectedValue(uncorrectedMomentum, fGradTrkMomMCS, fIntTrkMomMCS);
 }

double dune::NeutrinoEnergyRecoAlg::CalculateMuonMomentumByRange ( const art::Ptr< recob::Track > pMuonTrack )

private

Calculates muon momentum by range.

Parameters

pMuonTrack the muon track

Returns: the reconstructed muon momentum

Definition at line 236 of file NeutrinoEnergyRecoAlg.cc.

 {
     return this->CalculateLinearlyCorrectedValue(pMuonTrack->Length(), fGradTrkMomRange, fIntTrkMomRange);
 }

dune::EnergyRecoOutput dune::NeutrinoEnergyRecoAlg::CalculateNeutrinoEnergy	(	const art::Ptr< recob::Track > &	pMuonTrack,
		const art::Event &	event
	)

Calculates neutrino energy using a muon track (the muon track may be ignored if it isn't of a suitable quality)

Parameters

pMuonTrack	the muon track
event	the art event

Returns: the neutrino energy summary object

Definition at line 64 of file NeutrinoEnergyRecoAlg.cc.

 {
     if (!pMuonTrack.isAvailable() || pMuonTrack.isNull())
     {
         mf::LogWarning("NeutrinoEnergyRecoAlg") << " Cannot access the muon track which is needed for this energy reconstructio method.\n"
         << "Swapping to energy reconstruction method " << kAllCharges << " for this calculation." << std::endl;
         return this->CalculateNeutrinoEnergy(event);
     }
 
     Point_t vertex(pMuonTrack->Start().X(), pMuonTrack->Start().Y(), pMuonTrack->Start().Z());
 
     const std::vector<art::Ptr<recob::Hit> > muonHits(dune_ana::DUNEAnaHitUtils::GetHitsOnPlane(dune_ana::DUNEAnaTrackUtils::GetHits(pMuonTrack, event, fTrackToHitLabel),2));
     bool isContained(this->IsContained(muonHits, event));
     const double uncorrectedMuonMomentumMCS(this->CalculateUncorrectedMuonMomentumByMCS(pMuonTrack));
     const double muonMomentumMCS(this->CalculateLinearlyCorrectedValue(uncorrectedMuonMomentumMCS, fGradTrkMomMCS, fIntTrkMomMCS));
     if (!isContained)
     {
         if (uncorrectedMuonMomentumMCS > std::numeric_limits<double>::epsilon())
         {
             EnergyRecoInputHolder energyRecoInputHolder(vertex, 
                 this->CalculateParticle4Momentum(kMuonMass, muonMomentumMCS, pMuonTrack->VertexDirection().X(), pMuonTrack->VertexDirection().Y(), pMuonTrack->VertexDirection().Z()), 
                 kMuonAndHadronic, kMCS, kIsExiting, fGradNuMuHadEnExit, fIntNuMuHadEnExit);
             return this->CalculateNeutrinoEnergy(muonHits, event, energyRecoInputHolder);
         }
         else
         {
             return this->CalculateNeutrinoEnergy(event);
         }
     }
     else
     {
         const double muonMomentumRange(CalculateMuonMomentumByRange(pMuonTrack));
         if (uncorrectedMuonMomentumMCS > std::numeric_limits<double>::epsilon() 
             && muonMomentumRange/muonMomentumMCS - fMuonRangeToMCSThreshold < -1.*std::numeric_limits<double>::epsilon())
         {
             EnergyRecoInputHolder energyRecoInputHolder(vertex, 
                 this->CalculateParticle4Momentum(kMuonMass, muonMomentumMCS, pMuonTrack->VertexDirection().X(), pMuonTrack->VertexDirection().Y(), pMuonTrack->VertexDirection().Z()), 
                 kMuonAndHadronic, kMCS, kIsContained, fGradNuMuHadEnExit, fIntNuMuHadEnExit);
 
             return this->CalculateNeutrinoEnergy(muonHits, event, energyRecoInputHolder);
         }
         else
         {
             EnergyRecoInputHolder energyRecoInputHolder(vertex, 
                 this->CalculateParticle4Momentum(kMuonMass, muonMomentumRange, pMuonTrack->VertexDirection().X(), pMuonTrack->VertexDirection().Y(), pMuonTrack->VertexDirection().Z()), 
                 kMuonAndHadronic, kContained, kIsContained, fGradNuMuHadEnCont, fIntNuMuHadEnCont);
 
             return this->CalculateNeutrinoEnergy(muonHits, event, energyRecoInputHolder);
         }
     }
 
     throw art::Exception(art::errors::LogicError) << "Unable to determine how to calculate neutrino energy using muon track! \n";
 }

dune::EnergyRecoOutput dune::NeutrinoEnergyRecoAlg::CalculateNeutrinoEnergy	(	const art::Ptr< recob::Shower > &	pElectronShower,
		const art::Event &	event
	)

Calculates neutrino energy using an electron shower(the electron may be ignored if it isn't of a suitable quality)

Parameters

pElectronShower	the electron shower
event	the art event

Returns: the neutrino energy summary object

Definition at line 120 of file NeutrinoEnergyRecoAlg.cc.

 {
     if (!pElectronShower.isAvailable() || pElectronShower.isNull())
     {
         mf::LogWarning("NeutrinoEnergyRecoAlg") 
         << " Cannot access the electron shower which is needed for this energy reconstructio method.\n"
         << "Swapping to energy reconstruction method " << kAllCharges << " for this calculation." << std::endl;
         return this->CalculateNeutrinoEnergy(event);
     }
 
 
     Point_t vertex(pElectronShower->ShowerStart().X(), pElectronShower->ShowerStart().Y(), pElectronShower->ShowerStart().Z());
 
     const std::vector<art::Ptr<recob::Hit> > electronHits(dune_ana::DUNEAnaHitUtils::GetHitsOnPlane(dune_ana::DUNEAnaShowerUtils::GetHits(pElectronShower, event, fShowerToHitLabel),2));
     const double electronEnergy(this->CalculateElectronEnergy(pElectronShower, event));
     //ATTN yep this line is bugged.  It's deliberately bugged to maintain how the original code functioned
     //Because of the small electron mass vs total energy deposition, this bug will have a very very small effect on the 4vector
     const Momentum4_t electron4Momentum(this->CalculateParticle4Momentum(kElectronMass, electronEnergy, 
         pElectronShower->Direction().X(), pElectronShower->Direction().Y(), pElectronShower->Direction().Z()));
 
     EnergyRecoInputHolder energyRecoInputHolder(vertex, electron4Momentum, 
     kElectronAndHadronic, kTrackMethodNotSet, kContainmentNotSet, fGradNuEHadEn, fIntNuEHadEn);
 
     return this->CalculateNeutrinoEnergy(electronHits, event, energyRecoInputHolder);
 }

dune::EnergyRecoOutput dune::NeutrinoEnergyRecoAlg::CalculateNeutrinoEnergy ( const art::Event & event )

Calculates neutrino energy by summing wire charges.

Parameters

event the art event

Returns: the neutrino energy summary object

Definition at line 149 of file NeutrinoEnergyRecoAlg.cc.

 {
     art::ServiceHandle<geo::Geometry> fGeometry;
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(event);
     auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(event, clockData);
     const double triggerTme(clockData.TriggerTime());
 
     const std::vector<art::Ptr<recob::Wire> > wires(dune_ana::DUNEAnaEventUtils::GetWires(event, fWireLabel));
     double wireCharge(0);
 
     for (unsigned int iWire = 0; iWire < wires.size(); ++iWire)
     {
         if (fGeometry->SignalType(wires[iWire]->Channel()) != geo::kCollection)
             continue;
 
         const recob::Wire::RegionsOfInterest_t& signalROI(wires[iWire]->SignalROI());
         for (const lar::sparse_vector<float>::datarange_t& range : signalROI.get_ranges())
         {
             const std::vector<float>& signal(range.data());
             const raw::TDCtick_t binFirstTickROI(range.begin_index());
             for (unsigned int iSignal = 0; iSignal < signal.size(); ++iSignal)
                 wireCharge += signal[iSignal]*dune_ana::DUNEAnaHitUtils::LifetimeCorrection(clockData, detProp, iSignal+binFirstTickROI, triggerTme);
         }
     }
     const double totalEnergy(this->CalculateEnergyFromCharge(wireCharge));
 
     dune::EnergyRecoOutput output;
     output.recoMethodUsed = static_cast<int>(kAllCharges);
     output.fRecoVertex.SetXYZ(0.,0.,0.);
     output.fNuLorentzVector.SetXYZT(0.,0.,0.,totalEnergy);
     output.fLepLorentzVector.SetXYZT(0.,0.,0.,0.);
     output.fHadLorentzVector.SetXYZT(0.,0.,0.,0.);
     output.longestTrackContained = static_cast<int>(kContainmentNotSet);
     output.trackMomMethod = static_cast<int>(kTrackMethodNotSet);
     return output;
 }

dune::EnergyRecoOutput dune::NeutrinoEnergyRecoAlg::CalculateNeutrinoEnergy	(	const std::vector< art::Ptr< recob::Hit > > &	leptonHits,
		const art::Event &	event,
		const EnergyRecoInputHolder &	energyRecoInputHolder
	)

private

Calculates neutrino energy by summing hadronic deposited energy and lepton energy.

Parameters

leptonHits	the lepton hits
event	the art event
energyRecoInputHolder	the holder object holding pre-calculated or pre-existing information

Returns: the neutrino energy summary object

Definition at line 305 of file NeutrinoEnergyRecoAlg.cc.

 {
     auto const clockData = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(event);
     auto const detProp = art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(event, clockData);
     const double leptonObservedCharge(dune_ana::DUNEAnaHitUtils::LifetimeCorrectedTotalHitCharge(clockData, detProp, leptonHits));
 
     const std::vector<art::Ptr<recob::Hit> > eventHits(dune_ana::DUNEAnaHitUtils::GetHitsOnPlane(dune_ana::DUNEAnaEventUtils::GetHits(event, fHitLabel),2));
     const double eventObservedCharge(dune_ana::DUNEAnaHitUtils::LifetimeCorrectedTotalHitCharge(clockData, detProp, eventHits));
 
     const double hadronicObservedCharge(eventObservedCharge-leptonObservedCharge);
     const double uncorrectedHadronicEnergy(this->CalculateEnergyFromCharge(hadronicObservedCharge));
     const double correctedHadronicEnergy(
         this->CalculateLinearlyCorrectedValue(uncorrectedHadronicEnergy,energyRecoInputHolder.fHadronicCorrectionGradient,
         energyRecoInputHolder.fHadronicCorrectionIntercept));
 
     const double neutrinoEnergy(energyRecoInputHolder.fLeptonMomentum.E()+correctedHadronicEnergy);
 
     dune::EnergyRecoOutput output;
     output.recoMethodUsed = static_cast<int>(energyRecoInputHolder.fEnergyRecoMethod);
     output.fRecoVertex = energyRecoInputHolder.fVertex;
     output.fNuLorentzVector.SetE(neutrinoEnergy);
     output.fLepLorentzVector = energyRecoInputHolder.fLeptonMomentum;
     output.fHadLorentzVector.SetE(correctedHadronicEnergy);
     output.longestTrackContained = static_cast<int>(energyRecoInputHolder.fMuonContainmentStatus);
     output.trackMomMethod = static_cast<int>(energyRecoInputHolder.fMuonTrackMethod);
     return output;
 }

dune::EnergyRecoOutput dune::NeutrinoEnergyRecoAlg::CalculateNeutrinoEnergyViaMuonMCS	(	const art::Ptr< recob::Track > &	pMuonTrack,
		const art::Event &	event
	)

Calculates neutrino energy explicitly using muon multiple scattering.

Parameters

pMuonTrack	the muon track
event	the art event

Returns: the neutrino energy summary object

Definition at line 206 of file NeutrinoEnergyRecoAlg.cc.

 {
     Point_t vertex(pMuonTrack->Start().X(), pMuonTrack->Start().Y(), pMuonTrack->Start().Z());
 
     const std::vector<art::Ptr<recob::Hit> > muonHits(dune_ana::DUNEAnaHitUtils::GetHitsOnPlane(dune_ana::DUNEAnaTrackUtils::GetHits(pMuonTrack, event, fTrackToHitLabel),2));
     bool isContained(this->IsContained(muonHits, event));
     const double muonMomentumMCS(this->CalculateMuonMomentumByMCS(pMuonTrack));
 
     EnergyRecoInputHolder energyRecoInputHolder(vertex, 
         this->CalculateParticle4Momentum(kMuonMass, muonMomentumMCS, pMuonTrack->VertexDirection().X(), pMuonTrack->VertexDirection().Y(), pMuonTrack->VertexDirection().Z()), 
         kMuonAndHadronic, kMCS, static_cast<MuonContainmentStatus>(isContained), fGradNuMuHadEnExit, fIntNuMuHadEnExit);
 
     return this->CalculateNeutrinoEnergy(muonHits, event, energyRecoInputHolder);
 }

dune::EnergyRecoOutput dune::NeutrinoEnergyRecoAlg::CalculateNeutrinoEnergyViaMuonRanging	(	const art::Ptr< recob::Track > &	pMuonTrack,
		const art::Event &	event
	)

Calculates neutrino energy explicitly using muon momentum by range.

Parameters

pMuonTrack	the muon track
event	the art event

Returns: the neutrino energy summary object

Definition at line 188 of file NeutrinoEnergyRecoAlg.cc.

 {
     Point_t vertex(pMuonTrack->Start().X(), pMuonTrack->Start().Y(), pMuonTrack->Start().Z());
 
     const std::vector<art::Ptr<recob::Hit> > muonHits(dune_ana::DUNEAnaHitUtils::GetHitsOnPlane(dune_ana::DUNEAnaTrackUtils::GetHits(pMuonTrack, event, fTrackToHitLabel),2));
     bool isContained(this->IsContained(muonHits, event));
     const double muonMomentumRange(this->CalculateMuonMomentumByRange(pMuonTrack));
 
     EnergyRecoInputHolder energyRecoInputHolder(vertex, 
         this->CalculateParticle4Momentum(kMuonMass, muonMomentumRange, pMuonTrack->VertexDirection().X(), pMuonTrack->VertexDirection().Y(), pMuonTrack->VertexDirection().Z()), 
         kMuonAndHadronic, kContained, static_cast<MuonContainmentStatus>(isContained), fGradNuMuHadEnCont, fIntNuMuHadEnCont);
 
     return this->CalculateNeutrinoEnergy(muonHits, event, energyRecoInputHolder);
 }

NeutrinoEnergyRecoAlg::Momentum4_t dune::NeutrinoEnergyRecoAlg::CalculateParticle4Momentum	(	const double	mass,
		const double	momentum,
		const double	directionX,
		const double	directionY,
		const double	directionZ
	)

private

Calculates a particle's four-momentum vector.

Parameters

mass	the particle mass
momentum	the particle momentum
directionX	direction X component
directionY	direction X component
directionZ	direction X component

Returns: the particle's four-momenutm vector

Definition at line 224 of file NeutrinoEnergyRecoAlg.cc.

 {
     const double E(std::sqrt(momentum*momentum + mass*mass));
     const double pX(directionX * momentum);
     const double pY(directionY * momentum);
     const double pZ(directionZ * momentum);
     return Momentum4_t(pX, pY, pZ, E);
 }

double dune::NeutrinoEnergyRecoAlg::CalculateUncorrectedMuonMomentumByMCS ( const art::Ptr< recob::Track > & pMuonTrack )

private

Calculates the raw muon momentum by multiple coulomb scattering.

Parameters

pMuonTrack the muon track

Returns: the uncorrected reconstructed muon momentum

Definition at line 297 of file NeutrinoEnergyRecoAlg.cc.

 {
     trkf::TrackMomentumCalculator TrackMomCalc;
     return (TrackMomCalc.GetMomentumMultiScatterChi2(pMuonTrack));
 }

bool dune::NeutrinoEnergyRecoAlg::IsContained	(	const std::vector< art::Ptr< recob::Hit > > &	hits,
		const art::Event &	event
	)

private

Checks if a set of track hits are contained within a central volume of the detector.

Parameters

hits	the track hits

Returns: an is contained bool

Definition at line 271 of file NeutrinoEnergyRecoAlg.cc.

 {
     for (unsigned int iHit = 0; iHit < hits.size(); ++iHit)
     {
         const std::vector<art::Ptr<recob::SpacePoint> > spacePoints(dune_ana::DUNEAnaHitUtils::GetSpacePoints(hits[iHit], 
             event, fHitLabel, fHitToSpacePointLabel));
         for (unsigned int iSpacePoint = 0; iSpacePoint < spacePoints.size(); ++iSpacePoint)
         {
             const art::Ptr<recob::SpacePoint> spacePoint(spacePoints[iSpacePoint]);
             if (!(this->IsPointContained(spacePoint->XYZ()[0],spacePoint->XYZ()[1],spacePoint->XYZ()[2])))
                 return false;
         }
     }
     return true;
 }

bool dune::NeutrinoEnergyRecoAlg::IsPointContained	(	const double	x,
		const double	y,
		const double	z
	)

private

Check's if a point is contained within a central detector volume.

Parameters

x	the x component of the position
y	the y component of the position
z	the z component of the position

Returns: an is contained bool

Definition at line 336 of file NeutrinoEnergyRecoAlg.cc.

 {
     double position[3] = {x,y,z};
     art::ServiceHandle<geo::Geometry> fGeometry;
 
     geo::TPCID tpcID(fGeometry->FindTPCAtPosition(position));
     if (!(fGeometry->HasTPC(tpcID)))
         return false;
 
     double minX(std::numeric_limits<double>::max());
     double maxX(std::numeric_limits<double>::lowest());
     double minY(std::numeric_limits<double>::max());
     double maxY(std::numeric_limits<double>::lowest());
     double minZ(std::numeric_limits<double>::max());
     double maxZ(std::numeric_limits<double>::lowest());
     for (unsigned int iCryostat = 0; iCryostat < fGeometry->Ncryostats(); ++iCryostat)
     {
         const geo::CryostatGeo& cryostat(fGeometry->Cryostat(iCryostat));
         for (unsigned int iTPC = 0; iTPC < cryostat.NTPC(); ++iTPC)
         {
             const geo::TPCGeo& tpc(cryostat.TPC(iTPC));
             minX = std::min(minX,tpc.MinX());
             maxX = std::max(maxX,tpc.MaxX());
             minY = std::min(minY,tpc.MinY());
             maxY = std::max(maxY,tpc.MaxY());
             minZ = std::min(minZ,tpc.MinZ());
             maxZ = std::max(maxZ,tpc.MaxZ());
         }
     }
 
     minX += fDistanceToWallThreshold;
     maxX -= fDistanceToWallThreshold;
     minY += fDistanceToWallThreshold;
     maxY -= fDistanceToWallThreshold;
     minZ += fDistanceToWallThreshold;
     maxZ -= fDistanceToWallThreshold;
 
     if (x - minX < -1.*std::numeric_limits<double>::epsilon() ||
         x - maxX > std::numeric_limits<double>::epsilon())
         return false;
     if (y - minY < -1.*std::numeric_limits<double>::epsilon() ||
         y - maxY > std::numeric_limits<double>::epsilon())
         return false;
     if (z - minZ < -1.*std::numeric_limits<double>::epsilon() ||
         z - maxZ > std::numeric_limits<double>::epsilon())
         return false;
 
     return true;
 }

Member Data Documentation

calo::CalorimetryAlg dune::NeutrinoEnergyRecoAlg::fCalorimetryAlg

private

the calorimetry algorithm

Definition at line 271 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fDistanceToWallThreshold

private

the min distance from a detector wall to be considered contained

Definition at line 285 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fGradNuEHadEn

private

the hadronic energy correction gradient for nue

Definition at line 283 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fGradNuMuHadEnCont

private

the hqdronic energy correction gradient for numu+contained muon

Definition at line 277 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fGradNuMuHadEnExit

private

the hadronic energy correction gradient for numu+exiting muon

Definition at line 279 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fGradShwEnergy

private

the electron shower energy correction gradient

Definition at line 281 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fGradTrkMomMCS

private

the correction gradient for muom momentum by MCS

Definition at line 275 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fGradTrkMomRange

private

the correction gradient for muon momentum by range

Definition at line 273 of file NeutrinoEnergyRecoAlg.h.

std::string dune::NeutrinoEnergyRecoAlg::fHitLabel

private

the hit label

Definition at line 291 of file NeutrinoEnergyRecoAlg.h.

std::string dune::NeutrinoEnergyRecoAlg::fHitToSpacePointLabel

private

the associated hit-to-space point label

Definition at line 295 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fIntNuEHadEn

private

the hadronic energy correction intercept for nue

Definition at line 284 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fIntNuMuHadEnCont

private

the hadronic energy correction intercept for numu+contained muon

Definition at line 278 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fIntNuMuHadEnExit

private

the hadronic energy correction intercept for numu+exiting muon

Definition at line 280 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fIntShwEnergy

private

the electron shower energy correction intercept

Definition at line 282 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fIntTrkMomMCS

private

the correction intercept for muon momentum by MCS

Definition at line 276 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fIntTrkMomRange

private

the correction intercept for muon momentum by range

Definition at line 274 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fMuonRangeToMCSThreshold

private

the ratio threshold at which MCS is used for contained muons

Definition at line 286 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::fRecombFactor

private

the average reccombination factor

Definition at line 287 of file NeutrinoEnergyRecoAlg.h.

std::string dune::NeutrinoEnergyRecoAlg::fShowerLabel

private

the shower label

Definition at line 290 of file NeutrinoEnergyRecoAlg.h.

std::string dune::NeutrinoEnergyRecoAlg::fShowerToHitLabel

private

the associated shower-to-hit label

Definition at line 294 of file NeutrinoEnergyRecoAlg.h.

std::string dune::NeutrinoEnergyRecoAlg::fTrackLabel

private

the track label

Definition at line 289 of file NeutrinoEnergyRecoAlg.h.

std::string dune::NeutrinoEnergyRecoAlg::fTrackToHitLabel

private

the associated track-to-hit label

Definition at line 293 of file NeutrinoEnergyRecoAlg.h.

std::string dune::NeutrinoEnergyRecoAlg::fWireLabel

private

the wire label

Definition at line 292 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::kElectronMass = 0.0005109989461

private

the electron mass (hardcoded unfortunately);

Definition at line 104 of file NeutrinoEnergyRecoAlg.h.

double dune::NeutrinoEnergyRecoAlg::kMuonMass = 0.1056583745

private

the muon mass (hardcoded unfortunately)

Definition at line 103 of file NeutrinoEnergyRecoAlg.h.

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

dunereco/dunereco/FDSensOpt/NeutrinoEnergyRecoAlg/NeutrinoEnergyRecoAlg.h
dunereco/dunereco/FDSensOpt/NeutrinoEnergyRecoAlg/NeutrinoEnergyRecoAlg.cc

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation