caf Namespace Reference

This module creates Common Analysis Files. More...

Classes
class	ArrayVectorProxyBase
class	CAFMaker
	Module to create Common Analysis Files from ART files. More...
struct	CAFMakerParams
struct	CVNFinalState
class	Proxy
class	Proxy< caf::SRBeam >
	Proxy for caf::SRBeam. More...
class	Proxy< caf::SRBpf >
	Proxy for caf::SRBpf. More...
class	Proxy< caf::SRBPFEnergy >
	Proxy for caf::SRBPFEnergy. More...
class	Proxy< caf::SRBpfId >
	Proxy for caf::SRBpfId. More...
class	Proxy< caf::SRBpfTrack >
	Proxy for caf::SRBpfTrack. More...
class	Proxy< caf::SRContain >
	Proxy for caf::SRContain. More...
class	Proxy< caf::SRCosmic >
	Proxy for caf::SRCosmic. More...
class	Proxy< caf::SRCosmicCVN >
	Proxy for caf::SRCosmicCVN. More...
class	Proxy< caf::SRCosRej >
	Proxy for caf::SRCosRej. More...
class	Proxy< caf::SRCVNFeatures >
	Proxy for caf::SRCVNFeatures. More...
class	Proxy< caf::SRCVNNeutronDaughterResult >
	Proxy for caf::SRCVNNeutronDaughterResult. More...
class	Proxy< caf::SRCVNParticleResult >
	Proxy for caf::SRCVNParticleResult. More...
class	Proxy< caf::SRCVNResult >
	Proxy for caf::SRCVNResult. More...
class	Proxy< caf::SRElastic >
	Proxy for caf::SRElastic. More...
class	Proxy< caf::SRELid >
	Proxy for caf::SRELid. More...
class	Proxy< caf::SREnergyBranch >
	Proxy for caf::SREnergyBranch. More...
class	Proxy< caf::SRFluxWeights >
	Proxy for caf::SRFluxWeights. More...
class	Proxy< caf::SRFuzzyK >
	Proxy for caf::SRFuzzyK. More...
class	Proxy< caf::SRFuzzyKProng >
	Proxy for caf::SRFuzzyKProng. More...
class	Proxy< caf::SRGeant4Weights >
	Proxy for caf::SRGeant4Weights. More...
class	Proxy< caf::SRGenieWeights >
	Proxy for caf::SRGenieWeights. More...
class	Proxy< caf::SRGlobalTruth >
	Proxy for caf::SRGlobalTruth. More...
class	Proxy< caf::SRHadClust >
	Proxy for caf::SRHadClust. More...
class	Proxy< caf::SRHeader >
	Proxy for caf::SRHeader. More...
class	Proxy< caf::SRHoughVertex >
	Proxy for caf::SRHoughVertex. More...
class	Proxy< caf::SRIDBranch >
	Proxy for caf::SRIDBranch. More...
class	Proxy< caf::SRKalman >
	Proxy for caf::SRKalman. More...
class	Proxy< caf::SRKalmanTrack >
	Proxy for caf::SRKalmanTrack. More...
class	Proxy< caf::SRLem >
	Proxy for caf::SRLem. More...
class	Proxy< caf::SRLorentzVector >
	Proxy for caf::SRLorentzVector. More...
class	Proxy< caf::SRMCReweight >
	Proxy for caf::SRMCReweight. More...
class	Proxy< caf::SRMichelE >
	Proxy for caf::SRMichelE. More...
class	Proxy< caf::SRMRCCParent >
	Proxy for caf::SRMRCCParent. More...
class	Proxy< caf::SRMRProperties >
	Proxy for caf::SRMRProperties. More...
class	Proxy< caf::SRMuonID >
	Proxy for caf::SRMuonID. More...
class	Proxy< caf::SRNCCosRej >
	Proxy for caf::SRNCCosRej. More...
class	Proxy< caf::SRNCPi0BkgRej >
	Proxy for caf::SRNCPi0BkgRej. More...
class	Proxy< caf::SRNeutrino >
	Proxy for caf::SRNeutrino. More...
class	Proxy< caf::SRNueCosRej >
	Proxy for caf::SRNueCosRej. More...
class	Proxy< caf::SRNueEnergy >
	Proxy for caf::SRNueEnergy. More...
class	Proxy< caf::SRNuGenParticle >
	Proxy for caf::SRNuGenParticle. More...
class	Proxy< caf::SRNumuEnergy >
	Proxy for caf::SRNumuEnergy. More...
class	Proxy< caf::SRNuonEResult >
	Proxy for caf::SRNuonEResult. More...
class	Proxy< caf::SRParentBranch >
	Proxy for caf::SRParentBranch. More...
class	Proxy< caf::SRParticleTruth >
	Proxy for caf::SRParticleTruth. More...
class	Proxy< caf::SRPixelMap >
	Proxy for caf::SRPixelMap. More...
class	Proxy< caf::SRPixelObjMap >
	Proxy for caf::SRPixelObjMap. More...
class	Proxy< caf::SRPresel >
	Proxy for caf::SRPresel. More...
class	Proxy< caf::SRProng >
	Proxy for caf::SRProng. More...
class	Proxy< caf::SRProngTrainingData >
	Proxy for caf::SRProngTrainingData. More...
class	Proxy< caf::SRRegCVNResult >
	Proxy for caf::SRRegCVNResult. More...
class	Proxy< caf::SRRemid >
	Proxy for caf::SRRemid. More...
class	Proxy< caf::SRRvp >
	Proxy for caf::SRRvp. More...
class	Proxy< caf::SRShower >
	Proxy for caf::SRShower. More...
class	Proxy< caf::SRShowerLID >
	Proxy for caf::SRShowerLID. More...
class	Proxy< caf::SRSlcME >
	Proxy for caf::SRSlcME. More...
class	Proxy< caf::SRSlice >
	Proxy for caf::SRSlice. More...
class	Proxy< caf::SRSliceLID >
	Proxy for caf::SRSliceLID. More...
class	Proxy< caf::SRSliceMap >
	Proxy for caf::SRSliceMap. More...
class	Proxy< caf::SRSLid >
	Proxy for caf::SRSLid. More...
class	Proxy< caf::SRSLidEnergy >
	Proxy for caf::SRSLidEnergy. More...
class	Proxy< caf::SRSpill >
	Proxy for caf::SRSpill. More...
class	Proxy< caf::SRTrack >
	Proxy for caf::SRTrack. More...
class	Proxy< caf::SRTrackBase >
	Proxy for caf::SRTrackBase. More...
class	Proxy< caf::SRTrackBranch >
	Proxy for caf::SRTrackBranch. More...
class	Proxy< caf::SRTrainingBranch >
	Proxy for caf::SRTrainingBranch. More...
class	Proxy< caf::SRTrainingData >
	Proxy for caf::SRTrainingData. More...
class	Proxy< caf::SRTrkME >
	Proxy for caf::SRTrkME. More...
class	Proxy< caf::SRTrueMichelE >
	Proxy for caf::SRTrueMichelE. More...
class	Proxy< caf::SRTrueNumuEnergy >
	Proxy for caf::SRTrueNumuEnergy. More...
class	Proxy< caf::SRTrueParticle >
	Proxy for caf::SRTrueParticle. More...
class	Proxy< caf::SRTruthBranch >
	Proxy for caf::SRTruthBranch. More...
class	Proxy< caf::SRVector3D >
	Proxy for caf::SRVector3D. More...
class	Proxy< caf::SRVertexBranch >
	Proxy for caf::SRVertexBranch. More...
class	Proxy< caf::SRVertexDT >
	Proxy for caf::SRVertexDT. More...
class	Proxy< caf::SRVeto >
	Proxy for caf::SRVeto. More...
class	Proxy< caf::SRXnue >
	Proxy for caf::SRXnue. More...
class	Proxy< caf::StandardRecord >
	Proxy for caf::StandardRecord. More...
class	Proxy< std::vector< T > >
class	Proxy< T[N]>
class	Restorer
class	RestorerT
class	SRBeam
	Information about the neutrino production. Docs from http://www.hep.utexas.edu/~zarko/wwwgnumi/v19/v19/output_gnumi.html. More...
class	SRBpf
class	SRBPFEnergy
	BPF energy estimator output. More...
class	SRBpfId
	Breakpoint ID (BpfId) output. More...
class	SRBpfTrack
class	SRBranchRegistry
class	SRContain
	Containment variables. More...
class	SRCosmic
	Truth information for cosmic rays. More...
class	SRCosmicCVN
class	SRCosRej
	Output from Cosmic Rejection (CosRej) module. More...
class	SRCVNFeatures
	CVN features. More...
class	SRCVNNeutronDaughterResult
	CVN PID output for a single particle. More...
class	SRCVNParticleResult
	CVN PID output for a single particle. More...
class	SRCVNResult
	CVN PID output. More...
class	SRElastic
	A potential interaction point from the ElasticArms algorithm. More...
class	SRELid
	Output of the LIDBuilder module (slid::lid objects). More...
class	SREnergy
class	SREnergyBranch
	An SREnergyBranch contains vectors of energy objects. More...
class	SRFluxWeights
	Reweight information for flux systematic. More...
class	SRFuzzyK
class	SRFuzzyKProng
class	SRGeant4Weights
	Reweight information for geant4 systematic. More...
class	SRGenieWeights
	Reweight information for a single GENIE systematic. More...
class	SRGlobalTruth
class	SRHadClust
	Overarching information for a numu hadronic cluster. More...
class	SRHeader
	Header representing overview information for the current event/slice. More...
class	SRHoughVertex
	A potential interaction point found by the HoughVertex algorithm. More...
class	SRIDBranch
	Event ID and selection variables. More...
class	SRJMEid
	Output of the jmshower::NueSel module. More...
class	SRJMEnergy
	DO NOT USE. ONLY HERE FOR BACKWARDS COMPATIBILITY. More...
class	SRJMShower
	A reconstructed shower from the JMShower module. More...
class	SRKalman
class	SRKalmanTrack
class	SRLem
	This class contains the LEM PID output. More...
class	SRLid
	DO NOT USE. ONLY HERE FOR BACKWARDS COMPATIBILITY. More...
class	SRLorentzVector
	4-vector with more efficient storage than TLorentzVector More...
class	SRMCReweight
	Various weights for systematic reweights of MC. More...
class	SRMichelE
class	SRMRCCParent
	An SRMRCCParent holds information about the slice that was parent to the current slice. It is currently being used by Muon Removed Charged Current Analysis. More...
class	SRMRProperties
	A reconstructed shower from the MRProperties module. More...
class	SRMuId
	This class contains the LLH muon PID output. More...
class	SRMuonID
	Contains the reco muon PID (ReMId) output. More...
class	SRNCCosRej
	Output from Cosmic Rejection (Nuecosrej) module. More...
class	SRNCPi0BkgRej
class	SRNDSandbox
class	SRNeutrino
	The SRNeutrino is a representation of neutrino interaction information. More...
class	SRNueCosRej
	Output from Cosmic Rejection (Nuecosrej) module. More...
class	SRNueEnergy
	Nue energy estimator output in the standard record. More...
class	SRNuePresel
	Nue preselection information. More...
class	SRNueSandbox
class	SRNuGenParticle
	SRNuGenParticle represents a particle within the simulation of a neutrino interaction. More...
class	SRNumuEnergy
	Numu energy estimator output. More...
class	SRNumuSandbox
class	SRNuonEResult
	NuonE output. More...
class	SRNusSandbox
class	SRParentBranch
class	SRParticleTruth
	The truth information of reco objects within a slice. More...
class	SRPixelMap
	Variables describing Michel E's found around the end of a track. More...
class	SRPixelObjMap
	Variables describing Michel E's found around the end of a track. More...
class	SRPresel
	preselection information More...
class	SRProng
class	SRProngTrainingData
class	SRProngXSec
class	SRProxySystController
class	SRQepid
	Contains the quasielastic muon PID (QePId) output. More...
class	SRRegCVNResult
	Regression CVN output. More...
class	SRRemid
	Contains the reco muon PID (ReMId) output. More...
class	SRRvp
	Contains the RVP PID output. More...
class	SRSandbox
class	SRShower
class	SRShowerBranch
class	SRShowerLID
class	SRShowerPID
	DO NOT USE. ONLY HERE FOR BACKWARDS COMPATIBILITY. More...
class	SRSlcME
	Represents output from SlcMEFilter. More...
class	SRSlice
	An SRSlice contains overarching information for a slice. More...
class	SRSliceLID
class	SRSliceMap
	Variables describing Michel E's found around the end of a track. More...
class	SRSLid
	This class contains the LID pid information for a shower (slid::ShowerLID objects). More...
class	SRSLidEnergy
	This is a class for the NueSel energy estimate. More...
class	SRSPid
	Contains the SPID pid information for a shower (slid::ShowerLID objects). More...
class	SRSpill
class	SRSpillTruthBranch
	Truth info for all neutrinos in the spill. More...
class	SRTrack
class	SRTrackBase
class	SRTrackBranch
	Reconstructed tracks found by various algorithms. More...
class	SRTrainingBranch
	Event ID training variables. More...
class	SRTrainingData
class	SRTrkME
	Variables describing Michel E's found around the end of a track. More...
class	SRTrueMichelE
	Truth information for a Michel electron. More...
class	SRTrueNumuEnergy
	Truth information for numu energy fitting. More...
class	SRTrueParticle
class	SRTruth
	Represents a true neutrino. More...
class	SRTruthBranch
	Contains truth information for the slice for the parent neutrino/cosmic. More...
class	SRVector3D
	A 3-vector with more efficient storage than TVector3. More...
class	SRVertex
	Time and position of a reconstructed vertex. More...
class	SRVertexBranch
	Vectors of reconstructed vertices found by various algorithms. More...
class	SRVertexDT
	A vertex found by the VertexDT algorithm. More...
class	SRVeto
	Details of processing cuts made by the veto modules. More...
class	SRXnue
	Store BDT variables for the short-baseline oscillation study. More...
class	StandardRecord
	The StandardRecord is the primary top-level object in the Common Analysis File trees. More...
class	VectorProxyBase

Typedefs
using	FlatSRSLidEnergy = flat::Flat< caf::SRSLidEnergy >
using	FlatSRNueEnergy = flat::Flat< caf::SRNueEnergy >
using	FlatSRBPFEnergy = flat::Flat< caf::SRBPFEnergy >
using	FlatSRVector3D = flat::Flat< caf::SRVector3D >
using	FlatSRHadClust = flat::Flat< caf::SRHadClust >
using	FlatSRTrueNumuEnergy = flat::Flat< caf::SRTrueNumuEnergy >
using	FlatSRNumuEnergy = flat::Flat< caf::SRNumuEnergy >
using	FlatSREnergyBranch = flat::Flat< caf::SREnergyBranch >
using	FlatSRHeader = flat::Flat< caf::SRHeader >
using	FlatSRLorentzVector = flat::Flat< caf::SRLorentzVector >
using	FlatSRTrueMichelE = flat::Flat< caf::SRTrueMichelE >
using	FlatSRCosmic = flat::Flat< caf::SRCosmic >
using	FlatSRBeam = flat::Flat< caf::SRBeam >
using	FlatSRNuGenParticle = flat::Flat< caf::SRNuGenParticle >
using	FlatSRTrueParticle = flat::Flat< caf::SRTrueParticle >
using	FlatSRGeant4Weights = flat::Flat< caf::SRGeant4Weights >
using	FlatSRGenieWeights = flat::Flat< caf::SRGenieWeights >
using	FlatSRFluxWeights = flat::Flat< caf::SRFluxWeights >
using	FlatSRMCReweight = flat::Flat< caf::SRMCReweight >
using	FlatSRNeutrino = flat::Flat< caf::SRNeutrino >
using	FlatSRGlobalTruth = flat::Flat< caf::SRGlobalTruth >
using	FlatSRTruthBranch = flat::Flat< caf::SRTruthBranch >
using	FlatSRParticleTruth = flat::Flat< caf::SRParticleTruth >
using	FlatSRSlcME = flat::Flat< caf::SRSlcME >
using	FlatSRTrkME = flat::Flat< caf::SRTrkME >
using	FlatSRMichelE = flat::Flat< caf::SRMichelE >
using	FlatSRMRCCParent = flat::Flat< caf::SRMRCCParent >
using	FlatSRParentBranch = flat::Flat< caf::SRParentBranch >
using	FlatSRBpfId = flat::Flat< caf::SRBpfId >
using	FlatSRContain = flat::Flat< caf::SRContain >
using	FlatSRCosRej = flat::Flat< caf::SRCosRej >
using	FlatSRCVNResult = flat::Flat< caf::SRCVNResult >
using	FlatSRLem = flat::Flat< caf::SRLem >
using	FlatSRELid = flat::Flat< caf::SRELid >
using	FlatSRMuonID = flat::Flat< caf::SRMuonID >
using	FlatSRNCCosRej = flat::Flat< caf::SRNCCosRej >
using	FlatSRNCPi0BkgRej = flat::Flat< caf::SRNCPi0BkgRej >
using	FlatSRNueCosRej = flat::Flat< caf::SRNueCosRej >
using	FlatSRPresel = flat::Flat< caf::SRPresel >
using	FlatSRNuonEResult = flat::Flat< caf::SRNuonEResult >
using	FlatSRRemid = flat::Flat< caf::SRRemid >
using	FlatSRRvp = flat::Flat< caf::SRRvp >
using	FlatSRSliceLID = flat::Flat< caf::SRSliceLID >
using	FlatSRVeto = flat::Flat< caf::SRVeto >
using	FlatSRXnue = flat::Flat< caf::SRXnue >
using	FlatSRIDBranch = flat::Flat< caf::SRIDBranch >
using	FlatSRSlice = flat::Flat< caf::SRSlice >
using	FlatSRCosmicCVN = flat::Flat< caf::SRCosmicCVN >
using	FlatSRSpill = flat::Flat< caf::SRSpill >
using	FlatSRCVNFeatures = flat::Flat< caf::SRCVNFeatures >
using	FlatSRPixelObjMap = flat::Flat< caf::SRPixelObjMap >
using	FlatSRSliceMap = flat::Flat< caf::SRSliceMap >
using	FlatSRTrainingData = flat::Flat< caf::SRTrainingData >
using	FlatSRTrainingBranch = flat::Flat< caf::SRTrainingBranch >
using	FlatSRShower = flat::Flat< caf::SRShower >
using	FlatSRSLid = flat::Flat< caf::SRSLid >
using	FlatSRShowerLID = flat::Flat< caf::SRShowerLID >
using	FlatSRMRProperties = flat::Flat< caf::SRMRProperties >
using	FlatSRTrack = flat::Flat< caf::SRTrack >
using	FlatSRTrackBase = flat::Flat< caf::SRTrackBase >
using	FlatSRKalmanTrack = flat::Flat< caf::SRKalmanTrack >
using	FlatSRKalman = flat::Flat< caf::SRKalman >
using	FlatSRTrackBranch = flat::Flat< caf::SRTrackBranch >
using	FlatSRPixelMap = flat::Flat< caf::SRPixelMap >
using	FlatSRCVNNeutronDaughterResult = flat::Flat< caf::SRCVNNeutronDaughterResult >
using	FlatSRCVNParticleResult = flat::Flat< caf::SRCVNParticleResult >
using	FlatSRProngTrainingData = flat::Flat< caf::SRProngTrainingData >
using	FlatSRProng = flat::Flat< caf::SRProng >
using	FlatSRBpfTrack = flat::Flat< caf::SRBpfTrack >
using	FlatSRBpf = flat::Flat< caf::SRBpf >
using	FlatSRRegCVNResult = flat::Flat< caf::SRRegCVNResult >
using	FlatSRFuzzyKProng = flat::Flat< caf::SRFuzzyKProng >
using	FlatSRFuzzyK = flat::Flat< caf::SRFuzzyK >
using	FlatSRElastic = flat::Flat< caf::SRElastic >
using	FlatSRHoughVertex = flat::Flat< caf::SRHoughVertex >
using	FlatSRVertexDT = flat::Flat< caf::SRVertexDT >
using	FlatSRVertexBranch = flat::Flat< caf::SRVertexBranch >
using	FlatStandardRecord = flat::Flat< caf::StandardRecord >
using	SRProxy = caf::Proxy< caf::StandardRecord >
using	SRSLidEnergyProxy = caf::Proxy< caf::SRSLidEnergy >
using	SRNueEnergyProxy = caf::Proxy< caf::SRNueEnergy >
using	SRBPFEnergyProxy = caf::Proxy< caf::SRBPFEnergy >
using	SRVector3DProxy = caf::Proxy< caf::SRVector3D >
using	SRHadClustProxy = caf::Proxy< caf::SRHadClust >
using	SRTrueNumuEnergyProxy = caf::Proxy< caf::SRTrueNumuEnergy >
using	SRNumuEnergyProxy = caf::Proxy< caf::SRNumuEnergy >
using	SREnergyBranchProxy = caf::Proxy< caf::SREnergyBranch >
using	SRHeaderProxy = caf::Proxy< caf::SRHeader >
using	SRLorentzVectorProxy = caf::Proxy< caf::SRLorentzVector >
using	SRTrueMichelEProxy = caf::Proxy< caf::SRTrueMichelE >
using	SRCosmicProxy = caf::Proxy< caf::SRCosmic >
using	SRBeamProxy = caf::Proxy< caf::SRBeam >
using	SRNuGenParticleProxy = caf::Proxy< caf::SRNuGenParticle >
using	SRTrueParticleProxy = caf::Proxy< caf::SRTrueParticle >
using	SRGeant4WeightsProxy = caf::Proxy< caf::SRGeant4Weights >
using	SRGenieWeightsProxy = caf::Proxy< caf::SRGenieWeights >
using	SRFluxWeightsProxy = caf::Proxy< caf::SRFluxWeights >
using	SRMCReweightProxy = caf::Proxy< caf::SRMCReweight >
using	SRNeutrinoProxy = caf::Proxy< caf::SRNeutrino >
using	SRGlobalTruthProxy = caf::Proxy< caf::SRGlobalTruth >
using	SRTruthBranchProxy = caf::Proxy< caf::SRTruthBranch >
using	SRParticleTruthProxy = caf::Proxy< caf::SRParticleTruth >
using	SRSlcMEProxy = caf::Proxy< caf::SRSlcME >
using	SRTrkMEProxy = caf::Proxy< caf::SRTrkME >
using	SRMichelEProxy = caf::Proxy< caf::SRMichelE >
using	SRMRCCParentProxy = caf::Proxy< caf::SRMRCCParent >
using	SRParentBranchProxy = caf::Proxy< caf::SRParentBranch >
using	SRBpfIdProxy = caf::Proxy< caf::SRBpfId >
using	SRContainProxy = caf::Proxy< caf::SRContain >
using	SRCosRejProxy = caf::Proxy< caf::SRCosRej >
using	SRCVNResultProxy = caf::Proxy< caf::SRCVNResult >
using	SRLemProxy = caf::Proxy< caf::SRLem >
using	SRELidProxy = caf::Proxy< caf::SRELid >
using	SRMuonIDProxy = caf::Proxy< caf::SRMuonID >
using	SRNCCosRejProxy = caf::Proxy< caf::SRNCCosRej >
using	SRNCPi0BkgRejProxy = caf::Proxy< caf::SRNCPi0BkgRej >
using	SRNueCosRejProxy = caf::Proxy< caf::SRNueCosRej >
using	SRPreselProxy = caf::Proxy< caf::SRPresel >
using	SRNuonEResultProxy = caf::Proxy< caf::SRNuonEResult >
using	SRRemidProxy = caf::Proxy< caf::SRRemid >
using	SRRvpProxy = caf::Proxy< caf::SRRvp >
using	SRSliceLIDProxy = caf::Proxy< caf::SRSliceLID >
using	SRVetoProxy = caf::Proxy< caf::SRVeto >
using	SRXnueProxy = caf::Proxy< caf::SRXnue >
using	SRIDBranchProxy = caf::Proxy< caf::SRIDBranch >
using	SRSliceProxy = caf::Proxy< caf::SRSlice >
using	SRCosmicCVNProxy = caf::Proxy< caf::SRCosmicCVN >
using	SRSpillProxy = caf::Proxy< caf::SRSpill >
using	SRCVNFeaturesProxy = caf::Proxy< caf::SRCVNFeatures >
using	SRPixelObjMapProxy = caf::Proxy< caf::SRPixelObjMap >
using	SRSliceMapProxy = caf::Proxy< caf::SRSliceMap >
using	SRTrainingDataProxy = caf::Proxy< caf::SRTrainingData >
using	SRTrainingBranchProxy = caf::Proxy< caf::SRTrainingBranch >
using	SRShowerProxy = caf::Proxy< caf::SRShower >
using	SRSLidProxy = caf::Proxy< caf::SRSLid >
using	SRShowerLIDProxy = caf::Proxy< caf::SRShowerLID >
using	SRMRPropertiesProxy = caf::Proxy< caf::SRMRProperties >
using	SRTrackProxy = caf::Proxy< caf::SRTrack >
using	SRTrackBaseProxy = caf::Proxy< caf::SRTrackBase >
using	SRKalmanTrackProxy = caf::Proxy< caf::SRKalmanTrack >
using	SRKalmanProxy = caf::Proxy< caf::SRKalman >
using	SRTrackBranchProxy = caf::Proxy< caf::SRTrackBranch >
using	SRPixelMapProxy = caf::Proxy< caf::SRPixelMap >
using	SRCVNNeutronDaughterResultProxy = caf::Proxy< caf::SRCVNNeutronDaughterResult >
using	SRCVNParticleResultProxy = caf::Proxy< caf::SRCVNParticleResult >
using	SRProngTrainingDataProxy = caf::Proxy< caf::SRProngTrainingData >
using	SRProngProxy = caf::Proxy< caf::SRProng >
using	SRBpfTrackProxy = caf::Proxy< caf::SRBpfTrack >
using	SRBpfProxy = caf::Proxy< caf::SRBpf >
using	SRRegCVNResultProxy = caf::Proxy< caf::SRRegCVNResult >
using	SRFuzzyKProngProxy = caf::Proxy< caf::SRFuzzyKProng >
using	SRFuzzyKProxy = caf::Proxy< caf::SRFuzzyK >
using	SRElasticProxy = caf::Proxy< caf::SRElastic >
using	SRHoughVertexProxy = caf::Proxy< caf::SRHoughVertex >
using	SRVertexDTProxy = caf::Proxy< caf::SRVertexDT >
using	SRVertexBranchProxy = caf::Proxy< caf::SRVertexBranch >
using	StandardRecordProxy = caf::Proxy< caf::StandardRecord >
template<class T >
using	VectorProxy = Proxy< std::vector< T >>
template<class T , unsigned int N>
using	ArrayProxy = Proxy< T[N]>

Enumerations
enum	Det_t {   kUNKNOWN, kNEARDET, kFARDET, kNDOS,   kNDSBTEST, kTESTBEAM, kNDetector, kFCCDAQ }
	Which NOvA detector? More...
enum	View_t { kX, kY, kXorY }
	Detector view, following GeometryObjects/PlaneGeo.h. More...
enum	generator_ { kUnknownGenerator = 0, kGENIE = 1, kGIBUU = 2 }
	Known generators of neutrino interactions (extend as other generators are used) More...
enum	gen_process_t {   kModeUnknown = -1, kPrimary = 0, kHadElastic = 1, kDecay = 2,   kPionInelastic = 3, kProtonInelastic = 4, kNeutronInelastic = 5, kOther = 6 }
	Interaction type responsible for particle production. More...
enum	mode_type_ {   kUnknownMode = -1, kQE = 0, kRes = 1, kDIS = 2,   kCoh = 3, kCohElastic = 4, kElectronScattering = 5, kIMDAnnihilation = 6,   kInverseBetaDecay = 7, kGlashowResonance = 8, kAMNuGamma = 9, kMEC = 10,   kDiffractive = 11, kEM = 12, kWeakMix = 13 }
	Neutrino interaction categories. More...
enum	int_type_ {   kUnknownInteraction = -1, kNuanceOffset = 1000, kCCQE = kNuanceOffset + 1, kNCQE = kNuanceOffset + 2,   kResCCNuProtonPiPlus = kNuanceOffset + 3, kResCCNuNeutronPi0 = kNuanceOffset + 4, kResCCNuNeutronPiPlus = kNuanceOffset + 5, kResNCNuProtonPi0 = kNuanceOffset + 6,   kResNCNuProtonPiPlus = kNuanceOffset + 7, kResNCNuNeutronPi0 = kNuanceOffset + 8, kResNCNuNeutronPiMinus = kNuanceOffset + 9, kResCCNuBarNeutronPiMinus = kNuanceOffset + 10,   kResCCNuBarProtonPi0 = kNuanceOffset + 11, kResCCNuBarProtonPiMinus = kNuanceOffset + 12, kResNCNuBarProtonPi0 = kNuanceOffset + 13, kResNCNuBarProtonPiPlus = kNuanceOffset + 14,   kResNCNuBarNeutronPi0 = kNuanceOffset + 15, kResNCNuBarNeutronPiMinus = kNuanceOffset + 16, kResCCNuDeltaPlusPiPlus = kNuanceOffset + 17, kResCCNuDelta2PlusPiMinus = kNuanceOffset + 21,   kResCCNuBarDelta0PiMinus = kNuanceOffset + 28, kResCCNuBarDeltaMinusPiPlus = kNuanceOffset + 32, kResCCNuProtonRhoPlus = kNuanceOffset + 39, kResCCNuNeutronRhoPlus = kNuanceOffset + 41,   kResCCNuBarNeutronRhoMinus = kNuanceOffset + 46, kResCCNuBarNeutronRho0 = kNuanceOffset + 48, kResCCNuSigmaPlusKaonPlus = kNuanceOffset + 53, kResCCNuSigmaPlusKaon0 = kNuanceOffset + 55,   kResCCNuBarSigmaMinusKaon0 = kNuanceOffset + 60, kResCCNuBarSigma0Kaon0 = kNuanceOffset + 62, kResCCNuProtonEta = kNuanceOffset + 67, kResCCNuBarNeutronEta = kNuanceOffset + 70,   kResCCNuKaonPlusLambda0 = kNuanceOffset + 73, kResCCNuBarKaon0Lambda0 = kNuanceOffset + 76, kResCCNuProtonPiPlusPiMinus = kNuanceOffset + 79, kResCCNuProtonPi0Pi0 = kNuanceOffset + 80,   kResCCNuBarNeutronPiPlusPiMinus = kNuanceOffset + 85, kResCCNuBarNeutronPi0Pi0 = kNuanceOffset + 86, kResCCNuBarProtonPi0Pi0 = kNuanceOffset + 90, kCCDIS = kNuanceOffset + 91,   kNCDIS = kNuanceOffset + 92, kUnUsed1 = kNuanceOffset + 93, kUnUsed2 = kNuanceOffset + 94, kCCQEHyperon = kNuanceOffset + 95,   kNCCOH = kNuanceOffset + 96, kCCCOH = kNuanceOffset + 97, kNuElectronElastic = kNuanceOffset + 98, kInverseMuDecay = kNuanceOffset + 99 }
	Neutrino interaction type. More...
enum	CAFType { kNested, kFlatMultiTree, kFlatSingleTree, kCopiedRecord }

Functions
void	BlindThisSlice (SRSlice &slc)
void	BlindThisTrack (SRTrack &trk)
void	BlindThisJMShower (SRJMShower &jm)
void	BlindThisElasticVtx (SRElastic &vtx)
void	BlindThisCosRej (SRCosRej &cosrej)
void	BlindThisRecord (StandardRecord *rec)
void	FillNumuEnergyVars (const numue::NumuE &e, caf::SRNumuEnergy &sre)
void	FillNumuLSTMEnergyVars (const LSTME::LSTMEnergy &artE, float &lstmmuon, float &lstmnu)
void	FillNueEnergyVars (const rb::Cluster &slice, const SRVertexBranch &srVertexBranch, caf::SRNueEnergy &sre)
void	FillHadClustVars (const rb::Cluster &hadclust, caf::SRHadClust &srhadclust)
void	FillMRCCParentInfo (const murem::MRCCParent &parent, caf::SRMRCCParent &srparent, const art::Event &evt)
void	FillNumuInfo (const art::Ptr< cvn::Result > &cvn, const std::vector< art::Ptr< rb::Track >> &trks, const art::Ptr< numue::NumuE > &numuE, const art::Ptr< cosrej::CosRejObj > &cosrejobj, const art::Event &evt, SRMRCCParent &parent, const art::Ptr< rb::Cluster > &slice)
void	FillSliceInfo (const art::Ptr< rb::Cluster > &slice, SRMRCCParent &parent)
void	FillMuIdVars (const remid::ReMId &remid, SRKalmanTrack &srTrk)
void	FillMuonIDVars (const muonid::MuonID &muid, SRKalmanTrack &srTrk)
void	FillJMEIDVars (const jmshower::EID &eid, caf::SRJMEid &sreid)
void	FillCVNNeutronDaughterResultVars (const std::vector< art::Ptr< rb::PID > > &cvnneutrons, caf::SRCVNNeutronDaughterResult &cvnneutron)
void	FillCVNParticleResultVars (const std::vector< art::Ptr< rb::PID > > &cvnparts, caf::SRCVNParticleResult &cvnpart)
void	FillShowerVars (const rb::Shower &shw, caf::SRFuzzyKProng &srshw, const std::vector< rb::Cluster > &sliceList, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, const int &sliceIdx)
void	FillSlidVars (const slid::ShowerLID &slid, SRShowerLID &shwlid)
void	FillSpidVars (const slid::ShowerPID &spid, caf::SRSPid &srspid)
void	FillLIDEnergyVars (const slid::ShowerLID &slid, caf::SRFuzzyKProng &png)
void	FillLEMVars (const lem::PIDDetails &lem, caf::SRLem &srlem)
void	FillRVPVars (const rvp::RVP &rvp, caf::SRRvp &srrvp)
void	FillXnueVars (const xnue::Xnue &xnue, caf::SRXnue &srxnue)
void	FillCosRejVars (const cosrej::CosRejObj &cosrej, caf::SRCosRej &srcosrej, caf::SRContain &srcontain)
void	FillNueCosRejVars (const cosrej::NueCosRej &nuecosrej, caf::SRNueCosRej &srnuecosrej)
void	FillNCCosRejVars (const ncid::NCCosRej &nccosrej, caf::SRNCCosRej &srnccosrej)
void	FillNCPi0BkgRejVars (const ncpi0::NCPi0BkgRej &ncpi0bkgrej, caf::SRNCPi0BkgRej &srncpi0bkgrej)
void	FillNuePreselVars (const presel::PreselObj &nuepre, caf::SRPresel &srnuepre)
void	FillRockPreselVars (const presel::PreselObj &rockpre, caf::SRPresel &srrockpre)
void	FillVetoVars (const presel::Veto &veto, const presel::Veto &nueveto, caf::SRVeto &srveto)
void	FillNuonEResultVars (const cvn::Result &result, caf::SRNuonEResult &srnuone)
void	FillCVNResultVars (const cvn::Result &result, caf::SRCVNResult &srcvn, bool NoCosmics)
void	FillCVNPixelMaps (const cvn::PixelMap &map, caf::SRPixelObjMap &srcvnmap, bool useGeV)
void	FillCVNPixelMaps (const cvn::PixelMap &map, caf::SRPixelMap &srcvnmap, bool useGeV)
void	FillCVNTrainingData (const cvn::TrainingData &cvntdata, caf::SRTrainingData &srtdata)
void	FillCVNProngTrainingData (const cvn::ProngTrainingData &cvnpdata, caf::SRProngTrainingData &srpdata)
void	FillCVNFeaturesVars (const cvn::Features &features, caf::SRCVNFeatures &srcvnfeatures, int maxcomponents)
void	CopyRemidVars (const SRKalmanTrack &srTrk, caf::SRRemid &remid)
void	CopyMuonIDVars (const SRKalmanTrack &srTrk, caf::SRMuonID &muid)
void	FillSliceLID (const SliceLID::Prediction &artSliceLID, caf::SRSliceLID &cafSliceLID)
void	AddTrkMEToVec (const me::TrkME &michel, std::vector< SRTrkME > *vec, SRTrack &srTrk, const std::vector< rb::Cluster > &sliceList, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, int sliceIdx)
bool	IsTrueDiF (const rb::Cluster &slice)
	Helper for FillDiFVars and FillDiFShowerVars. More...
void	FillDiFVars (const rb::Cluster &slice, const std::vector< rb::Cluster > &sliceList, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, int sliceIdx, SRMRProperties &srMR)
void	AddSlcMEToVec (const me::SlcME &michel, std::vector< SRSlcME > *vec, const std::vector< rb::Cluster > &sliceList, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, int sliceIdx)
template<class T >
void	FillProngVars (const rb::Prong &prng, T &srPrng, const std::vector< rb::Cluster > &sliceList, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, int sliceIdx)
template void	FillProngVars< SRProng > (const rb::Prong &, SRProng &, const std::vector< rb::Cluster > &, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, int)
template void	FillProngVars< SRFuzzyKProng > (const rb::Prong &, SRFuzzyKProng &, const std::vector< rb::Cluster > &, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, int)
template void	FillProngVars< SRTrack > (const rb::Prong &, SRTrack &, const std::vector< rb::Cluster > &, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, int)
void	FillTrackVars (const rb::Track &trk, SRTrack &srTrk, const std::vector< rb::Cluster > &sliceList, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, int sliceIdx)
void	FillTrackVarsWithOverlapE (const rb::Track &trk, const rb::Energy &energy, SRTrack &srTrk, const std::vector< rb::Cluster > &sliceList, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, int sliceIdx)
	Function to fill SRTrack branch if overlapping energy object is present. More...
void	FillTrackVarsBpfFitSum (const rb::FitSum &fitsum, SRBpfTrack &srBpfTrk)
void	FillTrackVarsBpfPid (const bpfit::BPFPId &bpfpid, SRBpfTrack &srBpfTrk)
void	FillSliceVars (const rb::Cluster &slice, caf::SRSlice &srslice, bool allowEmpty)
void	FillShowerVars (const rb::Shower &shw, caf::SRFuzzyKProng &srshw, const std::vector< rb::Cluster > &sliceList, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, int sliceIdx)
void	FillDiFShowerVars (const rb::Shower &shw, const std::vector< rb::Cluster > &sliceList, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, int sliceIdx, SRMRProperties &srMR)
void	FillTrackContainmentVars (const cosrej::TrkCntObj &, SRTrack &)
	Function to fill SRTrack containment information. More...
void	FillNDRecoTrkVars (const ndreco::NDRecoTrkObj &, SRKalmanTrack &)
	Functions to fill SRKalmanTrack pion energy reconstruction information. More...
void	FillNDRecoBPFVars (const ndreco::NDRecoBpfObj &pionreco, SRBpfTrack &srTrk)
void	FillNDRecoPngVars (const ndreco::NDRecoPngObj &pionreco, SRFuzzyKProng &srPng)
void	FillTrackInfoVars (const trackinfo::TrackInfoObj &, SRTrack &)
	Function to fill additional SRTrack information. More...
void	FillNueSandVars (const nuesand::NueSandObj &sand, caf::SRNueSandbox &srsand)
void	FillNumuSandVars (const numusand::NumuSandObj &sand, caf::SRNumuSandbox &srsand, caf::SRContain &srcontain)
void	FillNusSandVars (const nussand::NusSandObj &sand, caf::SRNusSandbox &srsand)
SRParticleTruth	FillParticleTruth (const std::vector< rb::Cluster > &sliceList, const art::PtrVector< rb::CellHit > &hits, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, int sliceIdx)
	Function to fill the particle truth for a set of hits. More...
void	AddParticleToVec (const sim::Particle &part, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, std::vector< SRTrueParticle > *vec, const std::vector< sim::TrueEnergy > &TrueEnergies)
float	FindDaughterVisE (const sim::Particle &part, std::vector< cheat::TrackIDE > &tracks)
float	FindDaughterVisENonRecur (const sim::Particle &part, std::vector< cheat::TrackIDE > &tracks)
void	AddCosmicTruthToVec (const cheat::NeutrinoEffPur *effPur, std::vector< cheat::TrackIDE > &allTracks, std::vector< cheat::TrackIDE > &sliceTracks, std::vector< cheat::TrackIDE > &allTracksBirks, std::vector< cheat::TrackIDE > &sliceTracksBirks, std::vector< SRCosmic > *vec)
void	FindAndAddMichels (std::vector< const sim::Particle * > particles, std::vector< cheat::TrackIDE > &allTracks, std::vector< SRTrueMichelE > *michelVec)
void	AddTrueMichelEToVec (const sim::Particle &michel, const sim::Particle &motherMuon, std::vector< cheat::TrackIDE > &allTracks, std::vector< SRTrueMichelE > *vec)
void	AddPreFSI (const art::Ptr< simb::MCTruth > &truth, SRNeutrino &nu)
double	TrueNeutrinoDistance (novadaq::cnv::DetId det, const SRNeutrino &nu)
std::vector< SRGenieWeights >	GenieReweightTable (const rwgt::GENIEReweightTable &table)
SRFluxWeights	FluxReweights (const fxwgt::FluxWeights &flxwgts)
SRGeant4Weights	Geant4Reweights (const g4rwgt::G4WeightTable &g4wgts)
caf::generator_	CAFGeneratorEnum (simb::Generator_t simbGeneratorEnum)
std::vector< unsigned int >	DecodeGeneratorVersion (const std::string &versionString)
template<class T >
std::vector< T >	PtrVecToVec (const art::PtrVector< T > &xs)
CAFType	GetCAFType (const TDirectory *dir, TTree *tr)
std::string	StripSubscripts (const std::string &s)
int	NSubscripts (const std::string &name)
	Count the subscripts in the name. More...
const long &	AdjustBase (const long &base, CAFType type, const std::string &name)
template<class T >
void	GetTypedValueWrapper (TLeaf *leaf, T &x, int subidx)
void	GetTypedValueWrapper (TLeaf *leaf, std::string &x, int subidx)
template<class T >
void	EvalInstanceWrapper (TTreeFormula *ttf, T &x)
void	EvalInstanceWrapper (TTreeFormula *ttf, std::string &x)
template<class T >
bool	operator< (const Proxy< std::vector< T >> &a, const std::vector< T > &b)
	Used in comparison of GENIE version numbers. More...

Variables
static const int	blind_val = -5
static const unsigned int	blind_val_unsigned = 0
const std::string	whattracker = "bpf"
const std::string	slicelabel = "slicer"
const std::string	trklabelkalman = "kalmantrackmerge"
const std::string	trklabelbpf = "breakpoint"
const std::string	numuelabel = "numue"
const std::string	cosrejlabel = "cosrej"
const std::string	remidlabel = "remid"
const std::string	cvnlabel = "cvnevaloldpresel"
const std::string	vtxlabel = "elasticarmshs"
const std::string	pronglabel = "fuzzykvertex:Prongs3D"
const std::string	cvnpronglabel = "cvnprongeval"
const int	kNumCVNFinalStates = 387
const CVNFinalState	cvnStates [kNumCVNFinalStates]
const int	kCVN_nM_Other = kNumCVNFinalStates
const int	kCVN_nE_Other = kNumCVNFinalStates+1
const int	kCVN_nT_Other = kNumCVNFinalStates+2
const int	kCVN_Cosmic_PT = kNumCVNFinalStates+3
const int	kCVN_Other_PT = kNumCVNFinalStates+4
const long	kZero = 0
const long	kDummyBase = -1

Detailed Description

This module creates Common Analysis Files.

Common Analysis Files.

Class to make all of the CAFCuts for the RecoValidation modules.

Author

rocco.nosp@m.@phy.nosp@m.sics..nosp@m.umn..nosp@m.edu

Date

July 2012

Authors

mbair.nosp@m.d42@.nosp@m.india.nosp@m.na.e.nosp@m.du

Date

2017/02/14

Typedef Documentation

template<class T , unsigned int N>

using caf::ArrayProxy = typedef Proxy<T[N]>

Definition at line 301 of file BasicTypesProxy.h.

using caf::FlatSRBeam = typedef flat::Flat<caf::SRBeam>

Definition at line 86 of file FwdDeclare.h.

using caf::FlatSRBpf = typedef flat::Flat<caf::SRBpf>

Definition at line 428 of file FwdDeclare.h.

using caf::FlatSRBPFEnergy = typedef flat::Flat<caf::SRBPFEnergy>

Definition at line 26 of file FwdDeclare.h.

using caf::FlatSRBpfId = typedef flat::Flat<caf::SRBpfId>

Definition at line 182 of file FwdDeclare.h.

using caf::FlatSRBpfTrack = typedef flat::Flat<caf::SRBpfTrack>

Definition at line 422 of file FwdDeclare.h.

using caf::FlatSRContain = typedef flat::Flat<caf::SRContain>

Definition at line 188 of file FwdDeclare.h.

using caf::FlatSRCosmic = typedef flat::Flat<caf::SRCosmic>

Definition at line 80 of file FwdDeclare.h.

using caf::FlatSRCosmicCVN = typedef flat::Flat<caf::SRCosmicCVN>

Definition at line 296 of file FwdDeclare.h.

using caf::FlatSRCosRej = typedef flat::Flat<caf::SRCosRej>

Definition at line 194 of file FwdDeclare.h.

using caf::FlatSRCVNFeatures = typedef flat::Flat<caf::SRCVNFeatures>

Definition at line 308 of file FwdDeclare.h.

using caf::FlatSRCVNNeutronDaughterResult = typedef flat::Flat<caf::SRCVNNeutronDaughterResult>

Definition at line 398 of file FwdDeclare.h.

using caf::FlatSRCVNParticleResult = typedef flat::Flat<caf::SRCVNParticleResult>

Definition at line 404 of file FwdDeclare.h.

using caf::FlatSRCVNResult = typedef flat::Flat<caf::SRCVNResult>

Definition at line 200 of file FwdDeclare.h.

using caf::FlatSRElastic = typedef flat::Flat<caf::SRElastic>

Definition at line 452 of file FwdDeclare.h.

using caf::FlatSRELid = typedef flat::Flat<caf::SRELid>

Definition at line 212 of file FwdDeclare.h.

using caf::FlatSREnergyBranch = typedef flat::Flat<caf::SREnergyBranch>

Definition at line 56 of file FwdDeclare.h.

using caf::FlatSRFluxWeights = typedef flat::Flat<caf::SRFluxWeights>

Definition at line 116 of file FwdDeclare.h.

using caf::FlatSRFuzzyK = typedef flat::Flat<caf::SRFuzzyK>

Definition at line 446 of file FwdDeclare.h.

using caf::FlatSRFuzzyKProng = typedef flat::Flat<caf::SRFuzzyKProng>

Definition at line 440 of file FwdDeclare.h.

using caf::FlatSRGeant4Weights = typedef flat::Flat<caf::SRGeant4Weights>

Definition at line 104 of file FwdDeclare.h.

using caf::FlatSRGenieWeights = typedef flat::Flat<caf::SRGenieWeights>

Definition at line 110 of file FwdDeclare.h.

using caf::FlatSRGlobalTruth = typedef flat::Flat<caf::SRGlobalTruth>

Definition at line 134 of file FwdDeclare.h.

using caf::FlatSRHadClust = typedef flat::Flat<caf::SRHadClust>

Definition at line 38 of file FwdDeclare.h.

using caf::FlatSRHeader = typedef flat::Flat<caf::SRHeader>

Definition at line 62 of file FwdDeclare.h.

using caf::FlatSRHoughVertex = typedef flat::Flat<caf::SRHoughVertex>

Definition at line 458 of file FwdDeclare.h.

using caf::FlatSRIDBranch = typedef flat::Flat<caf::SRIDBranch>

Definition at line 284 of file FwdDeclare.h.

using caf::FlatSRKalman = typedef flat::Flat<caf::SRKalman>

Definition at line 380 of file FwdDeclare.h.

using caf::FlatSRKalmanTrack = typedef flat::Flat<caf::SRKalmanTrack>

Definition at line 374 of file FwdDeclare.h.

using caf::FlatSRLem = typedef flat::Flat<caf::SRLem>

Definition at line 206 of file FwdDeclare.h.

using caf::FlatSRLorentzVector = typedef flat::Flat<caf::SRLorentzVector>

Definition at line 68 of file FwdDeclare.h.

using caf::FlatSRMCReweight = typedef flat::Flat<caf::SRMCReweight>

Definition at line 122 of file FwdDeclare.h.

using caf::FlatSRMichelE = typedef flat::Flat<caf::SRMichelE>

Definition at line 164 of file FwdDeclare.h.

using caf::FlatSRMRCCParent = typedef flat::Flat<caf::SRMRCCParent>

Definition at line 170 of file FwdDeclare.h.

using caf::FlatSRMRProperties = typedef flat::Flat<caf::SRMRProperties>

Definition at line 356 of file FwdDeclare.h.

using caf::FlatSRMuonID = typedef flat::Flat<caf::SRMuonID>

Definition at line 218 of file FwdDeclare.h.

using caf::FlatSRNCCosRej = typedef flat::Flat<caf::SRNCCosRej>

Definition at line 224 of file FwdDeclare.h.

using caf::FlatSRNCPi0BkgRej = typedef flat::Flat<caf::SRNCPi0BkgRej>

Definition at line 230 of file FwdDeclare.h.

using caf::FlatSRNeutrino = typedef flat::Flat<caf::SRNeutrino>

Definition at line 128 of file FwdDeclare.h.

using caf::FlatSRNueCosRej = typedef flat::Flat<caf::SRNueCosRej>

Definition at line 236 of file FwdDeclare.h.

using caf::FlatSRNueEnergy = typedef flat::Flat<caf::SRNueEnergy>

Definition at line 20 of file FwdDeclare.h.

using caf::FlatSRNuGenParticle = typedef flat::Flat<caf::SRNuGenParticle>

Definition at line 92 of file FwdDeclare.h.

using caf::FlatSRNumuEnergy = typedef flat::Flat<caf::SRNumuEnergy>

Definition at line 50 of file FwdDeclare.h.

using caf::FlatSRNuonEResult = typedef flat::Flat<caf::SRNuonEResult>

Definition at line 248 of file FwdDeclare.h.

using caf::FlatSRParentBranch = typedef flat::Flat<caf::SRParentBranch>

Definition at line 176 of file FwdDeclare.h.

using caf::FlatSRParticleTruth = typedef flat::Flat<caf::SRParticleTruth>

Definition at line 146 of file FwdDeclare.h.

using caf::FlatSRPixelMap = typedef flat::Flat<caf::SRPixelMap>

Definition at line 392 of file FwdDeclare.h.

using caf::FlatSRPixelObjMap = typedef flat::Flat<caf::SRPixelObjMap>

Definition at line 314 of file FwdDeclare.h.

using caf::FlatSRPresel = typedef flat::Flat<caf::SRPresel>

Definition at line 242 of file FwdDeclare.h.

using caf::FlatSRProng = typedef flat::Flat<caf::SRProng>

Definition at line 416 of file FwdDeclare.h.

using caf::FlatSRProngTrainingData = typedef flat::Flat<caf::SRProngTrainingData>

Definition at line 410 of file FwdDeclare.h.

using caf::FlatSRRegCVNResult = typedef flat::Flat<caf::SRRegCVNResult>

Definition at line 434 of file FwdDeclare.h.

using caf::FlatSRRemid = typedef flat::Flat<caf::SRRemid>

Definition at line 254 of file FwdDeclare.h.

using caf::FlatSRRvp = typedef flat::Flat<caf::SRRvp>

Definition at line 260 of file FwdDeclare.h.

using caf::FlatSRShower = typedef flat::Flat<caf::SRShower>

Definition at line 338 of file FwdDeclare.h.

using caf::FlatSRShowerLID = typedef flat::Flat<caf::SRShowerLID>

Definition at line 350 of file FwdDeclare.h.

using caf::FlatSRSlcME = typedef flat::Flat<caf::SRSlcME>

Definition at line 152 of file FwdDeclare.h.

using caf::FlatSRSlice = typedef flat::Flat<caf::SRSlice>

Definition at line 290 of file FwdDeclare.h.

using caf::FlatSRSliceLID = typedef flat::Flat<caf::SRSliceLID>

Definition at line 266 of file FwdDeclare.h.

using caf::FlatSRSliceMap = typedef flat::Flat<caf::SRSliceMap>

Definition at line 320 of file FwdDeclare.h.

using caf::FlatSRSLid = typedef flat::Flat<caf::SRSLid>

Definition at line 344 of file FwdDeclare.h.

using caf::FlatSRSLidEnergy = typedef flat::Flat<caf::SRSLidEnergy>

Definition at line 14 of file FwdDeclare.h.

using caf::FlatSRSpill = typedef flat::Flat<caf::SRSpill>

Definition at line 302 of file FwdDeclare.h.

using caf::FlatSRTrack = typedef flat::Flat<caf::SRTrack>

Definition at line 362 of file FwdDeclare.h.

using caf::FlatSRTrackBase = typedef flat::Flat<caf::SRTrackBase>

Definition at line 368 of file FwdDeclare.h.

using caf::FlatSRTrackBranch = typedef flat::Flat<caf::SRTrackBranch>

Definition at line 386 of file FwdDeclare.h.

using caf::FlatSRTrainingBranch = typedef flat::Flat<caf::SRTrainingBranch>

Definition at line 332 of file FwdDeclare.h.

using caf::FlatSRTrainingData = typedef flat::Flat<caf::SRTrainingData>

Definition at line 326 of file FwdDeclare.h.

using caf::FlatSRTrkME = typedef flat::Flat<caf::SRTrkME>

Definition at line 158 of file FwdDeclare.h.

using caf::FlatSRTrueMichelE = typedef flat::Flat<caf::SRTrueMichelE>

Definition at line 74 of file FwdDeclare.h.

using caf::FlatSRTrueNumuEnergy = typedef flat::Flat<caf::SRTrueNumuEnergy>

Definition at line 44 of file FwdDeclare.h.

using caf::FlatSRTrueParticle = typedef flat::Flat<caf::SRTrueParticle>

Definition at line 98 of file FwdDeclare.h.

using caf::FlatSRTruthBranch = typedef flat::Flat<caf::SRTruthBranch>

Definition at line 140 of file FwdDeclare.h.

using caf::FlatSRVector3D = typedef flat::Flat<caf::SRVector3D>

Definition at line 32 of file FwdDeclare.h.

using caf::FlatSRVertexBranch = typedef flat::Flat<caf::SRVertexBranch>

Definition at line 470 of file FwdDeclare.h.

using caf::FlatSRVertexDT = typedef flat::Flat<caf::SRVertexDT>

Definition at line 464 of file FwdDeclare.h.

using caf::FlatSRVeto = typedef flat::Flat<caf::SRVeto>

Definition at line 272 of file FwdDeclare.h.

using caf::FlatSRXnue = typedef flat::Flat<caf::SRXnue>

Definition at line 278 of file FwdDeclare.h.

using caf::FlatStandardRecord = typedef flat::Flat<caf::StandardRecord>

Definition at line 476 of file FwdDeclare.h.

using caf::SRBeamProxy = typedef caf::Proxy<caf::SRBeam>

Definition at line 86 of file FwdDeclare.h.

using caf::SRBPFEnergyProxy = typedef caf::Proxy<caf::SRBPFEnergy>

Definition at line 26 of file FwdDeclare.h.

using caf::SRBpfIdProxy = typedef caf::Proxy<caf::SRBpfId>

Definition at line 182 of file FwdDeclare.h.

using caf::SRBpfProxy = typedef caf::Proxy<caf::SRBpf>

Definition at line 428 of file FwdDeclare.h.

using caf::SRBpfTrackProxy = typedef caf::Proxy<caf::SRBpfTrack>

Definition at line 422 of file FwdDeclare.h.

using caf::SRContainProxy = typedef caf::Proxy<caf::SRContain>

Definition at line 188 of file FwdDeclare.h.

using caf::SRCosmicCVNProxy = typedef caf::Proxy<caf::SRCosmicCVN>

Definition at line 296 of file FwdDeclare.h.

using caf::SRCosmicProxy = typedef caf::Proxy<caf::SRCosmic>

Definition at line 80 of file FwdDeclare.h.

using caf::SRCosRejProxy = typedef caf::Proxy<caf::SRCosRej>

Definition at line 194 of file FwdDeclare.h.

using caf::SRCVNFeaturesProxy = typedef caf::Proxy<caf::SRCVNFeatures>

Definition at line 308 of file FwdDeclare.h.

using caf::SRCVNNeutronDaughterResultProxy = typedef caf::Proxy<caf::SRCVNNeutronDaughterResult>

Definition at line 398 of file FwdDeclare.h.

using caf::SRCVNParticleResultProxy = typedef caf::Proxy<caf::SRCVNParticleResult>

Definition at line 404 of file FwdDeclare.h.

using caf::SRCVNResultProxy = typedef caf::Proxy<caf::SRCVNResult>

Definition at line 200 of file FwdDeclare.h.

using caf::SRElasticProxy = typedef caf::Proxy<caf::SRElastic>

Definition at line 452 of file FwdDeclare.h.

using caf::SRELidProxy = typedef caf::Proxy<caf::SRELid>

Definition at line 212 of file FwdDeclare.h.

using caf::SREnergyBranchProxy = typedef caf::Proxy<caf::SREnergyBranch>

Definition at line 56 of file FwdDeclare.h.

using caf::SRFluxWeightsProxy = typedef caf::Proxy<caf::SRFluxWeights>

Definition at line 116 of file FwdDeclare.h.

using caf::SRFuzzyKProngProxy = typedef caf::Proxy<caf::SRFuzzyKProng>

Definition at line 440 of file FwdDeclare.h.

using caf::SRFuzzyKProxy = typedef caf::Proxy<caf::SRFuzzyK>

Definition at line 446 of file FwdDeclare.h.

using caf::SRGeant4WeightsProxy = typedef caf::Proxy<caf::SRGeant4Weights>

Definition at line 104 of file FwdDeclare.h.

using caf::SRGenieWeightsProxy = typedef caf::Proxy<caf::SRGenieWeights>

Definition at line 110 of file FwdDeclare.h.

using caf::SRGlobalTruthProxy = typedef caf::Proxy<caf::SRGlobalTruth>

Definition at line 134 of file FwdDeclare.h.

using caf::SRHadClustProxy = typedef caf::Proxy<caf::SRHadClust>

Definition at line 38 of file FwdDeclare.h.

using caf::SRHeaderProxy = typedef caf::Proxy<caf::SRHeader>

Definition at line 62 of file FwdDeclare.h.

using caf::SRHoughVertexProxy = typedef caf::Proxy<caf::SRHoughVertex>

Definition at line 458 of file FwdDeclare.h.

using caf::SRIDBranchProxy = typedef caf::Proxy<caf::SRIDBranch>

Definition at line 284 of file FwdDeclare.h.

using caf::SRKalmanProxy = typedef caf::Proxy<caf::SRKalman>

Definition at line 380 of file FwdDeclare.h.

using caf::SRKalmanTrackProxy = typedef caf::Proxy<caf::SRKalmanTrack>

Definition at line 374 of file FwdDeclare.h.

using caf::SRLemProxy = typedef caf::Proxy<caf::SRLem>

Definition at line 206 of file FwdDeclare.h.

using caf::SRLorentzVectorProxy = typedef caf::Proxy<caf::SRLorentzVector>

Definition at line 68 of file FwdDeclare.h.

using caf::SRMCReweightProxy = typedef caf::Proxy<caf::SRMCReweight>

Definition at line 122 of file FwdDeclare.h.

using caf::SRMichelEProxy = typedef caf::Proxy<caf::SRMichelE>

Definition at line 164 of file FwdDeclare.h.

using caf::SRMRCCParentProxy = typedef caf::Proxy<caf::SRMRCCParent>

Definition at line 170 of file FwdDeclare.h.

using caf::SRMRPropertiesProxy = typedef caf::Proxy<caf::SRMRProperties>

Definition at line 356 of file FwdDeclare.h.

using caf::SRMuonIDProxy = typedef caf::Proxy<caf::SRMuonID>

Definition at line 218 of file FwdDeclare.h.

using caf::SRNCCosRejProxy = typedef caf::Proxy<caf::SRNCCosRej>

Definition at line 224 of file FwdDeclare.h.

using caf::SRNCPi0BkgRejProxy = typedef caf::Proxy<caf::SRNCPi0BkgRej>

Definition at line 230 of file FwdDeclare.h.

typedef Proxy< SRNeutrino > caf::SRNeutrinoProxy

Definition at line 128 of file FwdDeclare.h.

using caf::SRNueCosRejProxy = typedef caf::Proxy<caf::SRNueCosRej>

Definition at line 236 of file FwdDeclare.h.

using caf::SRNueEnergyProxy = typedef caf::Proxy<caf::SRNueEnergy>

Definition at line 20 of file FwdDeclare.h.

using caf::SRNuGenParticleProxy = typedef caf::Proxy<caf::SRNuGenParticle>

Definition at line 92 of file FwdDeclare.h.

using caf::SRNumuEnergyProxy = typedef caf::Proxy<caf::SRNumuEnergy>

Definition at line 50 of file FwdDeclare.h.

using caf::SRNuonEResultProxy = typedef caf::Proxy<caf::SRNuonEResult>

Definition at line 248 of file FwdDeclare.h.

using caf::SRParentBranchProxy = typedef caf::Proxy<caf::SRParentBranch>

Definition at line 176 of file FwdDeclare.h.

using caf::SRParticleTruthProxy = typedef caf::Proxy<caf::SRParticleTruth>

Definition at line 146 of file FwdDeclare.h.

using caf::SRPixelMapProxy = typedef caf::Proxy<caf::SRPixelMap>

Definition at line 392 of file FwdDeclare.h.

using caf::SRPixelObjMapProxy = typedef caf::Proxy<caf::SRPixelObjMap>

Definition at line 314 of file FwdDeclare.h.

using caf::SRPreselProxy = typedef caf::Proxy<caf::SRPresel>

Definition at line 242 of file FwdDeclare.h.

using caf::SRProngProxy = typedef caf::Proxy<caf::SRProng>

Definition at line 416 of file FwdDeclare.h.

using caf::SRProngTrainingDataProxy = typedef caf::Proxy<caf::SRProngTrainingData>

Definition at line 410 of file FwdDeclare.h.

typedef Proxy< StandardRecord > caf::SRProxy

Definition at line 2 of file EpilogFwd.h.

using caf::SRRegCVNResultProxy = typedef caf::Proxy<caf::SRRegCVNResult>

Definition at line 434 of file FwdDeclare.h.

using caf::SRRemidProxy = typedef caf::Proxy<caf::SRRemid>

Definition at line 254 of file FwdDeclare.h.

using caf::SRRvpProxy = typedef caf::Proxy<caf::SRRvp>

Definition at line 260 of file FwdDeclare.h.

using caf::SRShowerLIDProxy = typedef caf::Proxy<caf::SRShowerLID>

Definition at line 350 of file FwdDeclare.h.

using caf::SRShowerProxy = typedef caf::Proxy<caf::SRShower>

Definition at line 338 of file FwdDeclare.h.

using caf::SRSlcMEProxy = typedef caf::Proxy<caf::SRSlcME>

Definition at line 152 of file FwdDeclare.h.

using caf::SRSliceLIDProxy = typedef caf::Proxy<caf::SRSliceLID>

Definition at line 266 of file FwdDeclare.h.

using caf::SRSliceMapProxy = typedef caf::Proxy<caf::SRSliceMap>

Definition at line 320 of file FwdDeclare.h.

using caf::SRSliceProxy = typedef caf::Proxy<caf::SRSlice>

Definition at line 290 of file FwdDeclare.h.

using caf::SRSLidEnergyProxy = typedef caf::Proxy<caf::SRSLidEnergy>

Definition at line 14 of file FwdDeclare.h.

using caf::SRSLidProxy = typedef caf::Proxy<caf::SRSLid>

Definition at line 344 of file FwdDeclare.h.

typedef Proxy< SRSpill > caf::SRSpillProxy

Definition at line 302 of file FwdDeclare.h.

using caf::SRTrackBaseProxy = typedef caf::Proxy<caf::SRTrackBase>

Definition at line 368 of file FwdDeclare.h.

using caf::SRTrackBranchProxy = typedef caf::Proxy<caf::SRTrackBranch>

Definition at line 386 of file FwdDeclare.h.

using caf::SRTrackProxy = typedef caf::Proxy<caf::SRTrack>

Definition at line 362 of file FwdDeclare.h.

using caf::SRTrainingBranchProxy = typedef caf::Proxy<caf::SRTrainingBranch>

Definition at line 332 of file FwdDeclare.h.

using caf::SRTrainingDataProxy = typedef caf::Proxy<caf::SRTrainingData>

Definition at line 326 of file FwdDeclare.h.

using caf::SRTrkMEProxy = typedef caf::Proxy<caf::SRTrkME>

Definition at line 158 of file FwdDeclare.h.

using caf::SRTrueMichelEProxy = typedef caf::Proxy<caf::SRTrueMichelE>

Definition at line 74 of file FwdDeclare.h.

using caf::SRTrueNumuEnergyProxy = typedef caf::Proxy<caf::SRTrueNumuEnergy>

Definition at line 44 of file FwdDeclare.h.

using caf::SRTrueParticleProxy = typedef caf::Proxy<caf::SRTrueParticle>

Definition at line 98 of file FwdDeclare.h.

using caf::SRTruthBranchProxy = typedef caf::Proxy<caf::SRTruthBranch>

Definition at line 140 of file FwdDeclare.h.

using caf::SRVector3DProxy = typedef caf::Proxy<caf::SRVector3D>

Definition at line 32 of file FwdDeclare.h.

using caf::SRVertexBranchProxy = typedef caf::Proxy<caf::SRVertexBranch>

Definition at line 470 of file FwdDeclare.h.

using caf::SRVertexDTProxy = typedef caf::Proxy<caf::SRVertexDT>

Definition at line 464 of file FwdDeclare.h.

using caf::SRVetoProxy = typedef caf::Proxy<caf::SRVeto>

Definition at line 272 of file FwdDeclare.h.

using caf::SRXnueProxy = typedef caf::Proxy<caf::SRXnue>

Definition at line 278 of file FwdDeclare.h.

using caf::StandardRecordProxy = typedef caf::Proxy<caf::StandardRecord>

Definition at line 476 of file FwdDeclare.h.

template<class T >

using caf::VectorProxy = typedef Proxy<std::vector<T>>

Definition at line 235 of file BasicTypesProxy.h.

Enumeration Type Documentation

enum caf::CAFType

Enumerator
kNested
kFlatMultiTree
kFlatSingleTree
kCopiedRecord

Definition at line 31 of file BasicTypesProxy.h.

  {
    kNested,
    kFlatMultiTree,
    kFlatSingleTree,
    kCopiedRecord // Assigned into, not associated with a file
  };

enum caf::Det_t

Which NOvA detector?

Enumerator
kUNKNOWN	Unknown detector.
kNEARDET	Near Detector underground.
kFARDET	Far Detector at Ash River.
kNDOS	Prototype Near Detector on the Surface.
kNDSBTEST
kTESTBEAM
kNDetector
kFCCDAQ

Definition at line 7 of file SREnums.h.

  {
    kUNKNOWN,     ///< Unknown detector
    kNEARDET,     ///< Near Detector underground
    kFARDET,      ///< Far Detector at Ash River
    kNDOS,        ///< Prototype Near Detector on the Surface
    kNDSBTEST,
    kTESTBEAM,
    kNDetector,
    kFCCDAQ
  };

enum caf::gen_process_t

Interaction type responsible for particle production.

Enumerator
kModeUnknown
kPrimary
kHadElastic
kDecay
kPionInelastic
kProtonInelastic
kNeutronInelastic
kOther

Definition at line 35 of file SREnums.h.

                    {
    kModeUnknown      = -1,
    kPrimary          = 0,
    kHadElastic       = 1,
    kDecay            = 2,
    kPionInelastic    = 3,
    kProtonInelastic  = 4,
    kNeutronInelastic = 5,
    kOther            = 6
  };

enum caf::generator_

Known generators of neutrino interactions (extend as other generators are used)

Enumerator
kUnknownGenerator
kGENIE
kGIBUU

Definition at line 28 of file SREnums.h.

                 {
    kUnknownGenerator = 0,
    kGENIE            = 1,
    kGIBUU            = 2
  };

enum caf::int_type_

Neutrino interaction type.

Enumerator
kUnknownInteraction
kNuanceOffset	offset to account for adding in Nuance codes to this enum
kCCQE	charged current quasi-elastic
kNCQE	neutral current quasi-elastic
kResCCNuProtonPiPlus	resonant charged current,
kResCCNuNeutronPi0	resonant charged current,
kResCCNuNeutronPiPlus	resonant charged current,
kResNCNuProtonPi0	resonant neutral current,
kResNCNuProtonPiPlus	resonant neutral current,
kResNCNuNeutronPi0	resonant neutral current,
kResNCNuNeutronPiMinus	resonant neutral current,
kResCCNuBarNeutronPiMinus	resonant charged current,
kResCCNuBarProtonPi0	resonant charged current,
kResCCNuBarProtonPiMinus	resonant charged current,
kResNCNuBarProtonPi0	resonant charged current,
kResNCNuBarProtonPiPlus	resonant charged current,
kResNCNuBarNeutronPi0	resonant charged current,
kResNCNuBarNeutronPiMinus	resonant charged current,
kResCCNuDeltaPlusPiPlus
kResCCNuDelta2PlusPiMinus
kResCCNuBarDelta0PiMinus
kResCCNuBarDeltaMinusPiPlus
kResCCNuProtonRhoPlus
kResCCNuNeutronRhoPlus
kResCCNuBarNeutronRhoMinus
kResCCNuBarNeutronRho0
kResCCNuSigmaPlusKaonPlus
kResCCNuSigmaPlusKaon0
kResCCNuBarSigmaMinusKaon0
kResCCNuBarSigma0Kaon0
kResCCNuProtonEta
kResCCNuBarNeutronEta
kResCCNuKaonPlusLambda0
kResCCNuBarKaon0Lambda0
kResCCNuProtonPiPlusPiMinus
kResCCNuProtonPi0Pi0
kResCCNuBarNeutronPiPlusPiMinus
kResCCNuBarNeutronPi0Pi0
kResCCNuBarProtonPi0Pi0
kCCDIS	charged current deep inelastic scatter
kNCDIS	charged current deep inelastic scatter
kUnUsed1
kUnUsed2
kCCQEHyperon
kNCCOH
kCCCOH	charged current coherent pion
kNuElectronElastic	neutrino electron elastic scatter
kInverseMuDecay	inverse muon decay

Definition at line 66 of file SREnums.h.

                {
    kUnknownInteraction        = -1,
    kNuanceOffset              = 1000,                ///< offset to account for adding in Nuance codes to this enum
    kCCQE                      = kNuanceOffset + 1,   ///< charged current quasi-elastic
    kNCQE                      = kNuanceOffset + 2,   ///< neutral current quasi-elastic
    kResCCNuProtonPiPlus       = kNuanceOffset + 3,   ///< resonant charged current, \f$\nu p \to l^- p \pi^+\f$
    kResCCNuNeutronPi0         = kNuanceOffset + 4,   ///< resonant charged current, \f$\nu n \to l^- p \pi^0\f$
    kResCCNuNeutronPiPlus      = kNuanceOffset + 5,   ///< resonant charged current, \f$\nu n \to l^- n \pi^+\f$
    kResNCNuProtonPi0          = kNuanceOffset + 6,   ///< resonant neutral current, \f$\nu p \to \nu p \pi^0\f$
    kResNCNuProtonPiPlus       = kNuanceOffset + 7,   ///< resonant neutral current, \f$\nu p \to \nu p \pi^+\f$
    kResNCNuNeutronPi0         = kNuanceOffset + 8,   ///< resonant neutral current, \f$\nu n \to \nu n \pi^0\f$
    kResNCNuNeutronPiMinus     = kNuanceOffset + 9,   ///< resonant neutral current, \f$\nu n \to \nu p \pi^-\f$
    kResCCNuBarNeutronPiMinus  = kNuanceOffset + 10,  ///< resonant charged current, \f$\bar\nu n \to l^+ n \pi^-\f$
    kResCCNuBarProtonPi0       = kNuanceOffset + 11,  ///< resonant charged current, \f$\bar\nu p \to l^+ n \pi^0\f$
    kResCCNuBarProtonPiMinus   = kNuanceOffset + 12,  ///< resonant charged current, \f$\bar\nu p \to l^+ p \pi^-\f$
    kResNCNuBarProtonPi0       = kNuanceOffset + 13,  ///< resonant charged current, \f$\bar\nu p \to \bar\nu p \pi^0\f$
    kResNCNuBarProtonPiPlus    = kNuanceOffset + 14,  ///< resonant charged current, \f$\bar\nu p \to \bar\nu n \pi^+\f$
    kResNCNuBarNeutronPi0      = kNuanceOffset + 15,  ///< resonant charged current, \f$\bar\nu n \to \bar\nu n \pi^0\f$
    kResNCNuBarNeutronPiMinus  = kNuanceOffset + 16,  ///< resonant charged current, \f$\bar\nu n \to \bar\nu p \pi^-\f$
    kResCCNuDeltaPlusPiPlus    = kNuanceOffset + 17,
    kResCCNuDelta2PlusPiMinus  = kNuanceOffset + 21,
    kResCCNuBarDelta0PiMinus   = kNuanceOffset + 28,
    kResCCNuBarDeltaMinusPiPlus= kNuanceOffset + 32,
    kResCCNuProtonRhoPlus      = kNuanceOffset + 39,
    kResCCNuNeutronRhoPlus     = kNuanceOffset + 41,
    kResCCNuBarNeutronRhoMinus = kNuanceOffset + 46,
    kResCCNuBarNeutronRho0     = kNuanceOffset + 48,
    kResCCNuSigmaPlusKaonPlus  = kNuanceOffset + 53,
    kResCCNuSigmaPlusKaon0     = kNuanceOffset + 55,
    kResCCNuBarSigmaMinusKaon0 = kNuanceOffset + 60,
    kResCCNuBarSigma0Kaon0     = kNuanceOffset + 62,
    kResCCNuProtonEta          = kNuanceOffset + 67,
    kResCCNuBarNeutronEta      = kNuanceOffset + 70,
    kResCCNuKaonPlusLambda0    = kNuanceOffset + 73,
    kResCCNuBarKaon0Lambda0    = kNuanceOffset + 76,
    kResCCNuProtonPiPlusPiMinus= kNuanceOffset + 79,
    kResCCNuProtonPi0Pi0       = kNuanceOffset + 80,
    kResCCNuBarNeutronPiPlusPiMinus = kNuanceOffset + 85,
    kResCCNuBarNeutronPi0Pi0   = kNuanceOffset + 86,
    kResCCNuBarProtonPi0Pi0    = kNuanceOffset + 90,
    kCCDIS                     = kNuanceOffset + 91,  ///< charged current deep inelastic scatter
    kNCDIS                     = kNuanceOffset + 92,  ///< charged current deep inelastic scatter
    kUnUsed1                   = kNuanceOffset + 93,
    kUnUsed2                   = kNuanceOffset + 94,
    kCCQEHyperon               = kNuanceOffset + 95,
    kNCCOH                     = kNuanceOffset + 96,
    kCCCOH                     = kNuanceOffset + 97,  ///< charged current coherent pion
    kNuElectronElastic         = kNuanceOffset + 98,  ///< neutrino electron elastic scatter
    kInverseMuDecay            = kNuanceOffset + 99   ///< inverse muon decay
  };

enum caf::mode_type_

Neutrino interaction categories.

Enumerator
kUnknownMode
kQE
kRes
kDIS
kCoh
kCohElastic
kElectronScattering
kIMDAnnihilation
kInverseBetaDecay
kGlashowResonance
kAMNuGamma
kMEC
kDiffractive
kEM
kWeakMix

Definition at line 47 of file SREnums.h.

                 {
    kUnknownMode               = -1,
    kQE                        = 0,
    kRes                       = 1,
    kDIS                       = 2,
    kCoh                       = 3,
    kCohElastic                = 4,
    kElectronScattering        = 5,
    kIMDAnnihilation           = 6,
    kInverseBetaDecay          = 7,
    kGlashowResonance          = 8,
    kAMNuGamma                 = 9,
    kMEC                       = 10,
    kDiffractive               = 11,
    kEM                        = 12,
    kWeakMix                   = 13
  };

enum caf::View_t

Detector view, following GeometryObjects/PlaneGeo.h.

Enumerator
kX	Vertical planes which measure X.
kY	Horizontal planes which measure Y.
kXorY	X or Y views.

Definition at line 20 of file SREnums.h.

  {
    kX,   ///< Vertical planes which measure X
    kY,   ///< Horizontal planes which measure Y
    kXorY ///< X or Y views
  };

Function Documentation

void caf::AddCosmicTruthToVec	(	const cheat::NeutrinoEffPur *	effPur,
		std::vector< cheat::TrackIDE > &	allTracks,
		std::vector< cheat::TrackIDE > &	sliceTracks,
		std::vector< cheat::TrackIDE > &	allTracksBirks,
		std::vector< cheat::TrackIDE > &	sliceTracksBirks,
		std::vector< SRCosmic > *	vec
	)

Definition at line 535 of file FillTruth.cxx.

References std::atan2(), caf::SRCosmic::azimuth, geo::GeometryBase::DetHalfHeight(), geo::GeometryBase::DetHalfWidth(), geo::GeometryBase::DetLength(), dir, caf::SRCosmic::E, caf::SRCosmic::eff, cheat::NeutrinoEffPur::efficiency, cheat::NeutrinoEffPur::energySlice, cheat::NeutrinoEffPur::energyTotal, caf::SRCosmic::enter, caf::SRCosmic::exit, stan::math::fabs(), FindAndAddMichels(), geom(), simb::MCTruth::GetParticle(), cheat::BackTracker::MCTruthToParticles(), caf::SRCosmic::michel, simb::MCTrajectory::Momentum(), simb::MCParticle::Momentum(), cheat::NeutrinoEffPur::neutrinoInt, caf::SRCosmic::nhitslc, caf::SRCosmic::nhittot, cheat::NeutrinoEffPur::nSliceHits, cheat::NeutrinoEffPur::nTotalHits, caf::SRCosmic::p, caf::SRCosmic::pdg, simb::MCParticle::PdgCode(), caf::SRCosmic::penter, simb::MCTrajectory::Position(), simb::MCParticle::Position(), geo::ProjectToBoxEdge(), gen_hdf5record::pt, caf::SRCosmic::pur, cheat::NeutrinoEffPur::purity, caf::SRVector3D::SetXYZ(), simb::MCTrajectory::size(), caf::SRCosmic::stop, caf::SRCosmic::time, Unit(), Vect(), caf::SRCosmic::visE, caf::SRCosmic::visEinslc, caf::SRCosmic::vtx, and caf::SRCosmic::zenith.

Referenced by caf::CAFMaker::produce().

  {
    static art::ServiceHandle<cheat::BackTracker> bt;
    static art::ServiceHandle<geo::Geometry> geom;

    // Get information about true cosmic
    vec->push_back(SRCosmic());
    SRCosmic& srTruth = vec->back();

    const art::Ptr<simb::MCTruth> &tru = effPur->neutrinoInt;

    // BUT GetParticle(int i) requires looping over list of particles in
    // single MCTruth object. So we have made an MCTruth object for each
    // "cosmic" and GetParticle(0) corresponds to the only particle then
    srTruth.pdg          = tru->GetParticle(0).PdgCode();

    srTruth.E            = tru->GetParticle(0).Momentum().E();
    srTruth.visE         = effPur->energyTotal;
    srTruth.visEinslc    = effPur->energySlice;
    srTruth.eff          = effPur->efficiency;
    srTruth.pur          = effPur->purity;
    srTruth.nhitslc      = effPur->nSliceHits;
    srTruth.nhittot      = effPur->nTotalHits;

    srTruth.time         = tru->GetParticle(0).Position().T();
    srTruth.vtx          = tru->GetParticle(0).Position().Vect();
    srTruth.p            = tru->GetParticle(0).Momentum();


    srTruth.azimuth      = atan2(tru->GetParticle(0).Momentum().Pz(),
                                  tru->GetParticle(0).Momentum().Px());
    srTruth.zenith       = -(tru->GetParticle(0).Momentum().Py())/tru->GetParticle(0).Momentum().P();

    std::vector<const sim::Particle*> particles = bt->MCTruthToParticles(tru);


    const simb::MCTrajectory& traj = particles[0]->Trajectory();


    bool entered = 0;
    bool exited = 0;

    for(size_t pt = 0; pt < traj.size(); ++pt){
      TVector3 point = traj.Position(pt).Vect();

      // Check to see if trajectory point is in the detector
      bool inDet = fabs(point.X()) <= geom->DetHalfWidth()   // Check X inside detector
      && fabs(point.Y()) <= geom->DetHalfHeight()  // then check Y
      && point.Z() >= 0 && point.Z() <= geom->DetLength(); // then check Z

      if(inDet && !entered){
        // Then we just entered the detector
        entered = true;

        if(pt > 0){
          // Put xyz from last point into an array for geo function call
          TVector3 lastPoint = traj.Position(pt - 1).Vect();
          double pointArray[3] = {point.X(), point.Y(), point.Z()};

          // Put xyz from direction vector into an array.
          TVector3 dir = (lastPoint - point).Unit();
          double dirArray[3] = {dir.X(), dir.Y(), dir.Z()};

          double enterArray[3] = {0,0,0};

          geo::ProjectToBoxEdge(pointArray, dirArray,
                                - geom->DetHalfWidth()  , geom->DetHalfWidth(),
                                - geom->DetHalfHeight() , geom->DetHalfHeight(),
                                0  , geom->DetLength(),
                                enterArray);

          srTruth.enter.SetXYZ(enterArray[0], enterArray[1], enterArray[2]);
          // No good way to interpolate between momentum at pt-1 and pt.
          srTruth.penter = traj.Momentum(pt-1);
        }
        else{ // If this is the case, we started inside the detector.
          srTruth.enter = point;
          srTruth.penter = traj.Momentum(pt);
        }
      }

      if(!inDet && entered && !exited){
        // Then we just exited the detector
        exited= true;

        // Put xyz from last point into an array for geo function call
        TVector3 lastPoint = traj.Position(pt - 1).Vect();
        double lastPointArray[3] = {lastPoint.X(), lastPoint.Y(), lastPoint.Z()};

        // Put xyz from direction vector into an array.
        TVector3 dir = (point - lastPoint).Unit();
        double dirArray[3] = {dir.X(), dir.Y(), dir.Z()};

        double exitArray[3] = {0,0,0};

        geo::ProjectToBoxEdge(lastPointArray, dirArray,
                              - geom->DetHalfWidth()  , geom->DetHalfWidth(),
                              - geom->DetHalfHeight() , geom->DetHalfHeight(),
                              0  , geom->DetLength(),
                              exitArray);

        srTruth.exit.SetXYZ(exitArray[0], exitArray[1], exitArray[2]);
      }
    }
    srTruth.stop = traj.Position(traj.size() - 1).Vect();

    // Make sure the particle actually entered the detector
    if(!entered){
      // If the primary never entered the detector, set the
      // coordinates to -5*10^9

      srTruth.enter.SetXYZ(-5e9, -5e9, -5e9);
      srTruth.exit.SetXYZ(-5e9, -5e9, -5e9);
    }

    // If the particle entered and did not exit, set the exit position to stop
    if(entered && !exited){
      srTruth.exit = srTruth.stop;
    }
    // Find the Michel electrons
    FindAndAddMichels(particles, allTracks, &srTruth.michel);
  }

void caf::AddParticleToVec	(	const sim::Particle &	part,
		std::vector< cheat::TrackIDE > &	allTracks,
		std::vector< cheat::TrackIDE > &	sliceTracks,
		std::vector< cheat::TrackIDE > &	allTracksBirks,
		std::vector< cheat::TrackIDE > &	sliceTracksBirks,
		std::vector< SRTrueParticle > *	vec,
		const std::vector< sim::TrueEnergy > &	TrueEnergies
	)

Definition at line 258 of file FillTruth.cxx.

References simb::MCParticle::Daughter(), caf::SRTrueParticle::daughterEnergies, caf::SRTrueParticle::daughterlist, caf::SRTrueParticle::daughterVisE, caf::SRTrueParticle::daughterVisEBirks, caf::SRTrueParticle::daughterVisEinslc, caf::SRTrueParticle::daughterVisEinslcBirks, simb::MCParticle::E(), caf::SRTrueParticle::elasticProtonMaxVisE, caf::SRTrueParticle::elasticProtonMaxVisEinslc, caf::SRTrueParticle::elasticProtonSumVisE, caf::SRTrueParticle::elasticProtonSumVisEinslc, caf::SRTrueParticle::enteringE, FindDaughterVisE(), FindDaughterVisENonRecur(), MECModelEnuComparisons::i, caf::SRTrueParticle::inelasticPhotonMaxVisE, caf::SRTrueParticle::inelasticPhotonMaxVisEinslc, caf::SRTrueParticle::inelasticPhotonSumVisE, caf::SRTrueParticle::inelasticPhotonSumVisEinslc, caf::SRTrueParticle::inelasticProtonMaxVisE, caf::SRTrueParticle::inelasticProtonMaxVisEinslc, caf::SRTrueParticle::inelasticProtonSumVisE, caf::SRTrueParticle::inelasticProtonSumVisEinslc, it, caf::SRTrueParticle::maxElasticProtonTrueE, caf::SRTrueParticle::maxInelasticPhotonTrueE, caf::SRTrueParticle::maxInelasticProtonTrueE, simb::MCParticle::Momentum(), simb::MCParticle::NumberDaughters(), caf::SRTrueParticle::p, caf::SRTrueParticle::pdg, genie::utils::res::PdgCode(), simb::MCParticle::PdgCode(), simb::MCParticle::Process(), caf::SRTrueParticle::totEscE, simb::MCParticle::TrackId(), cheat::BackTracker::TrackIDToParticle(), caf::SRTrueParticle::trkID, caf::SRTrueParticle::visE, caf::SRTrueParticle::visEBirks, caf::SRTrueParticle::visEinslc, and caf::SRTrueParticle::visEinslcBirks.

Referenced by caf::CAFMaker::AddMCTruthToVec().

  {
    static art::ServiceHandle<cheat::BackTracker> bt;
    int trackId = part.TrackId();
    // Find visible energy
    double visE = 0;
    for (std::vector<cheat::TrackIDE>::iterator  it = allTracks.begin();
         it != allTracks.end(); ++it)
    {
      if(trackId == it->trackID)
      {
        visE += it->energy;
        break;
      }
      
    }
    // Find visible energy in slice
    double inSliceVisE = 0;
    for (std::vector<cheat::TrackIDE>::iterator  it = sliceTracks.begin();
         it != sliceTracks.end(); ++it)
    {
      if(trackId == it->trackID)
      {
        inSliceVisE += it->energy;
        break;
      }
    }
    //now calculate visible energies with birks suppression
    // Find visible energy
    double visEBirks = 0;
    for (std::vector<cheat::TrackIDE>::iterator  it = allTracksBirks.begin();
         it != allTracksBirks.end(); ++it)
    {
      if(trackId == it->trackID)
      {
        visEBirks += it->energy;
        break;
      }
      
    }
    // Find visible energy in slice
    double inSliceVisEBirks = 0;
    for (std::vector<cheat::TrackIDE>::iterator  it = sliceTracksBirks.begin();
         it != sliceTracksBirks.end(); ++it)
    {
      if(trackId == it->trackID)
      {
        inSliceVisEBirks += it->energy;
        break;
      }
    }


    double daughterVisE = 0;
    double daughterInSliceVisE = 0;
    double daughterVisEBirks = 0;
    double daughterInSliceVisEBirks = 0;
    
    

    for (int i=0; i<part.NumberDaughters();++i){
      const sim::Particle * p = bt->TrackIDToParticle(part.Daughter(i));
      
      daughterVisE += FindDaughterVisE(*p,allTracks);
      daughterInSliceVisE += FindDaughterVisE(*p,sliceTracks);
      daughterVisEBirks += FindDaughterVisE(*p,allTracksBirks);
      daughterInSliceVisEBirks += FindDaughterVisE(*p,sliceTracksBirks);
    }
    

    // Find the total escaping energy in slice.
    float TotEscE = -5;
    float EnterEn = -5;
    for(const sim::TrueEnergy& trueE: TrueEnergies){
      if ( trackId == trueE.TrackId() ) {
        EnterEn = trueE.EnteringEnergy();
        TotEscE = trueE.TotalEscEnergy();
        break;
      }
    }
    
    // Make a new SRTrueParticle and get an accessor
    vec->push_back(SRTrueParticle());
    SRTrueParticle& srPart = vec->back();
    // Set fields
    srPart.pdg = part.PdgCode();
    srPart.visE = visE;
    srPart.visEinslc = inSliceVisE;
    srPart.daughterVisE = daughterVisE;
    srPart.daughterVisEinslc = daughterInSliceVisE;
    srPart.visEBirks = visEBirks;
    srPart.visEinslcBirks = inSliceVisEBirks;
    srPart.daughterVisEBirks = daughterVisEBirks;
    srPart.daughterVisEinslcBirks = daughterInSliceVisEBirks;
    srPart.totEscE = TotEscE;
    srPart.enteringE = EnterEn;
    srPart.p = part.Momentum();
    srPart.trkID = trackId;
 
    float maxProInel = 0;
    float maxProInelS =0;
    float maxProElS =0;
    float maxProEl =0;
    float maxPhoInel = 0;
    float maxPhoInelS = 0;

    float maxProInelTrueE = 0;
    float maxProElTrueE = 0;
    float maxPhoInelTrueE =0;

    double inelasticProtonSum = 0;
    double inelasticPhotonSum = 0 ;
    double elasticProtonSum = 0;
    double inelasticProtonInslcSum = 0;
    double inelasticPhotonInslcSum = 0 ;
    double elasticProtonInslcSum = 0;


    double inelasticProtonMax = 0;
    double inelasticPhotonMax = 0 ;
    double elasticProtonMax = 0;
    double inelasticProtonInslcMax = 0;
    double inelasticPhotonInslcMax = 0 ;
    double elasticProtonInslcMax = 0;


    for (int i=0; i<part.NumberDaughters();++i){
      const sim::Particle * p = bt->TrackIDToParticle(part.Daughter(i));
      srPart.daughterlist.push_back(bt->TrackIDToParticle(part.Daughter(i))->PdgCode());
      srPart.daughterEnergies.push_back(p->E());

      
      if(p->Process() == "neutronInelastic"){
        if(p->PdgCode() ==2212){
          
          inelasticProtonSum += FindDaughterVisENonRecur(*p,allTracks);
          inelasticProtonInslcSum += FindDaughterVisENonRecur(*p,sliceTracks);

          if( FindDaughterVisENonRecur(*p,allTracks) > maxProInel){
            inelasticProtonMax = FindDaughterVisENonRecur(*p,allTracks);
            maxProInel = inelasticProtonMax;

          }
          if( FindDaughterVisENonRecur(*p,sliceTracks) > maxProInelS){
            inelasticProtonInslcMax = FindDaughterVisENonRecur(*p,sliceTracks);
            maxProInelS = inelasticProtonInslcMax;
            maxProInelTrueE = p->E();
          }


        }
        if(p->PdgCode() ==22){
          
          inelasticPhotonSum += FindDaughterVisENonRecur(*p,allTracks);
          inelasticPhotonInslcSum += FindDaughterVisENonRecur(*p,sliceTracks);

          if( FindDaughterVisENonRecur(*p,allTracks) > maxPhoInel){
            inelasticPhotonMax = FindDaughterVisENonRecur(*p,allTracks);
            maxPhoInel = inelasticPhotonMax;
          }
          if( FindDaughterVisENonRecur(*p,sliceTracks) > maxPhoInelS){
            inelasticPhotonInslcMax = FindDaughterVisENonRecur(*p,sliceTracks);
            maxPhoInelS = inelasticPhotonInslcMax;
            maxPhoInelTrueE = p->E();
          }
          

        }

      }
      if(p->Process() == "hadElastic"){
        
        if(p->PdgCode() == 2212){
          
          elasticProtonSum += FindDaughterVisENonRecur(*p,allTracks);
          elasticProtonInslcSum += FindDaughterVisENonRecur(*p,sliceTracks);

          if( FindDaughterVisENonRecur(*p,sliceTracks) > maxProElS){
            elasticProtonInslcMax = FindDaughterVisENonRecur(*p,sliceTracks);
            maxProElS = elasticProtonInslcMax;
            maxProElTrueE = p->E();
          }
          if( FindDaughterVisENonRecur(*p,allTracks) > maxProEl){
            elasticProtonMax = FindDaughterVisENonRecur(*p,allTracks);
            maxProEl = elasticProtonMax;
          } 
          
        }
      
      }    
    
    }
    
    srPart.inelasticProtonSumVisE = inelasticProtonSum;
    srPart.inelasticPhotonSumVisE = inelasticPhotonSum;
    srPart.elasticProtonSumVisE = elasticProtonSum;


    srPart.inelasticProtonSumVisEinslc = inelasticProtonInslcSum;
    srPart.inelasticPhotonSumVisEinslc = inelasticPhotonInslcSum;
    srPart.elasticProtonSumVisEinslc = elasticProtonInslcSum;
    
    
    srPart.inelasticProtonMaxVisE = inelasticProtonMax;
    srPart.inelasticPhotonMaxVisE = inelasticPhotonMax;
    srPart.elasticProtonMaxVisE = elasticProtonMax;


    srPart.inelasticProtonMaxVisEinslc = inelasticProtonInslcMax;
    srPart.inelasticPhotonMaxVisEinslc = inelasticPhotonInslcMax;
    srPart.elasticProtonMaxVisEinslc = elasticProtonInslcMax;


    srPart.maxElasticProtonTrueE = maxProElTrueE;
    srPart.maxInelasticProtonTrueE = maxProInelTrueE;
    srPart.maxInelasticPhotonTrueE = maxPhoInelTrueE;




  }

void caf::AddPreFSI	(	const art::Ptr< simb::MCTruth > &	truth,
		SRNeutrino &	nu
	)

Definition at line 726 of file FillTruth.cxx.

References om::cout, e, allTimeWatchdog::endl, stan::math::fabs(), simb::MCTruth::GetParticle(), makeTrainCVSamples::int, simb::MCParticle::Momentum(), simb::MCParticle::Mother(), genie::utils::fragmrec::NParticles(), simb::MCTruth::NParticles(), caf::SRNuGenParticle::p, caf::SRNuGenParticle::pdg, period_run_lists::pfd, caf::SRNeutrino::prefsi, caf::SRNeutrino::prim, caf::SRNuGenParticle::primList, caf::SRNuGenParticle::status, and simb::MCParticle::StatusCode().

Referenced by caf::CAFMaker::AddMCTruthToVec().

  {
    // Add information about "pre-FSI hadrons", which are recoil hadrons inside the nucleus after 
    // resonance decays and hadronization and before FSI.  This excludes hadrons from hadronization
    // and resonance decays occuring outside the nucleus, as well as hadrons from coherent scattering
    // and scattering on hydrogen.

    // Also included is the mapping between pre-FSI hadrons and their final state descendants.
    // Final state particle information in the CAFs comes from sim::Particle objects from the 
    // BackTracker service and is stored in SRTrueParticle objects in SRNeutrino.  Information of
    // final state descendants of pre-FSI hadrons is stored in simb::MCParticle objects from 
    // simb::MCTruth.  This situation requires matching the pre-FSI hadron final state descendant
    // simb::MCParticle objects to the corresponding sim::Particle or SRTrueParticle objects by
    // pdg code and 4-momentum.

    // First, retrieve the pre-FSI hadrons and their final state descendants

    std::map<const simb::MCParticle*,std::vector<const simb::MCParticle*>> prefsi_final_descendants;

    for ( int iprefsi = 0; iprefsi < truth->NParticles(); ++iprefsi )
    {
      const simb::MCParticle* prefsi_part = &truth->GetParticle( iprefsi );
      // Require hadron undergoing intranuclear transport (status code = 14)
      if ( prefsi_part->StatusCode() != 14 ) continue;
      // Require hadron not a product of FSI
      if ( truth->GetParticle( prefsi_part->Mother() ).StatusCode() == 14 ) continue;
      // Find final state descendants
      std::vector<const simb::MCParticle*> final_descendants;
      for ( int ifinal = 0; ifinal < truth->NParticles(); ++ifinal )
      {
        const simb::MCParticle* final_part = &truth->GetParticle( ifinal );
        // Require final state particle (particle (status code = 1)
        if ( final_part->StatusCode() != 1 ) continue;
        // Exclude at-rest final state particles produced by GENIE presumably for baryon accounting.
        // Iddentical paricles with zero momentum are not unique and cannot be matched as described above.        
        if ( final_part->Momentum().Vect().Mag() == 0 ) continue;
        int iancestor = final_part->Mother();
        int search_count = 0;
        while ( iancestor != iprefsi && iancestor > 0 && search_count < truth->NParticles() )
        {
          iancestor = truth->GetParticle( iancestor ).Mother();
          search_count++;
        }
        if ( iancestor == iprefsi ) final_descendants.push_back( final_part );
      }
      prefsi_final_descendants[ prefsi_part ] = final_descendants;
    }

    // Determine mapping between pre-FSI hadrons and their final state descendants in the nu.prim
    // vector and add the pre-FSI hadron information to the record.

    for ( auto pfd : prefsi_final_descendants )
    {
      SRNuGenParticle nugen_part;
      nugen_part.pdg    = pfd.first->PdgCode();
      nugen_part.status = pfd.first->StatusCode();
      nugen_part.p      = pfd.first->Momentum();

      const int prefsiID = (int)nu.prefsi.size();

      for ( unsigned int iprim = 0; iprim < nu.prim.size(); ++iprim )
      {
        for ( auto final_part : pfd.second )
        {
          double max_diff = 1e-4;
          if ( final_part->PdgCode() == nu.prim[ iprim ].pdg &&
               fabs( final_part->Px() - nu.prim[ iprim ].p.px ) < max_diff &&
               fabs( final_part->Py() - nu.prim[ iprim ].p.py ) < max_diff &&
               fabs( final_part->Pz() - nu.prim[ iprim ].p.pz ) < max_diff &&
               fabs( final_part->E()  - nu.prim[ iprim ].p.E  ) < max_diff )
          {
            nugen_part.primList.push_back( iprim );
            nu.prim[ iprim ].prefsiID = prefsiID;
          }
        }
      }

      nu.prefsi.push_back( nugen_part );

      int nfinal = pfd.second.size();
      int nprim  = nu.prefsi[ prefsiID ].primList.size();
      if ( nfinal != nprim )
      {
        std::cout << Form( "Mismatch: pre-FSI N final state descendants = %d, N primary matches = %d", nfinal, nprim ) << std::endl;
        //if ( nfinal != nprim ) LOG_WARNING( "FillTruth" ) << Form( "Mismatch: pre-FSI N final state descendants = %d, N primary matches = %d", nfinal, nprim );
      }
    }

  }

void caf::AddSlcMEToVec	(	const me::SlcME &	michel,
		std::vector< SRSlcME > *	vec,
		const std::vector< rb::Cluster > &	sliceList,
		std::vector< cheat::TrackIDE > &	allTracks,
		std::vector< cheat::TrackIDE > &	sliceTracks,
		std::vector< cheat::TrackIDE > &	allTracksBirks,
		std::vector< cheat::TrackIDE > &	sliceTracksBirks,
		int	sliceIdx
	)

Definition at line 148 of file FillReco.cxx.

References caf::SRSlcME::adc, rb::Cluster::AllCells(), caf::SRSlcME::calE, rb::Cluster::CalorimetricEnergy(), me::SlcME::DeltaT(), caf::SRSlcME::deltat, me::SlcME::DistToSlc(), caf::SRSlcME::disttoslc, FillParticleTruth(), caf::SRSlcME::meanpos, rb::Cluster::MeanX(), rb::Cluster::MeanY(), rb::Cluster::MeanZ(), me::SlcME::MID(), caf::SRSlcME::mid, caf::SRSlcME::nhitx, caf::SRSlcME::nhity, rb::Cluster::NXCell(), rb::Cluster::NYCell(), rb::Cluster::TotalADC(), and caf::SRSlcME::truth.

Referenced by caf::CAFMaker::produce().

  {
    vec->push_back(SRSlcME());
    SRSlcME& srME = vec->back();

    srME.mid       = michel.MID();
    srME.nhitx     = michel.NXCell();
    srME.nhity     = michel.NYCell();
    srME.adc       = michel.TotalADC();
    srME.calE      = michel.CalorimetricEnergy();
    srME.deltat    = michel.DeltaT();
    srME.disttoslc = michel.DistToSlc();
    srME.meanpos   = TVector3(michel.MeanX(),michel.MeanY(),michel.MeanZ());

    srME.truth     = FillParticleTruth(sliceList,
                                       michel.AllCells(),
                                       allTracks,
                                       sliceTracks,
                                       allTracksBirks,
                                       sliceTracksBirks,
                                       sliceIdx);
  }

void caf::AddTrkMEToVec	(	const me::TrkME &	michel,
		std::vector< SRTrkME > *	vec,
		SRTrack &	srTrk,
		const std::vector< rb::Cluster > &	sliceList,
		std::vector< cheat::TrackIDE > &	allTracks,
		std::vector< cheat::TrackIDE > &	sliceTracks,
		std::vector< cheat::TrackIDE > &	allTracksBirks,
		std::vector< cheat::TrackIDE > &	sliceTracksBirks,
		int	sliceIdx
	)

Definition at line 34 of file FillReco.cxx.

References caf::SRTrkME::adc, rb::Cluster::AllCells(), caf::SRTrkME::calE, rb::Cluster::CalorimetricEnergy(), me::SlcME::DeltaT(), caf::SRTrkME::deltat, caf::SRTrkME::disttotrack, me::TrkME::DistToTrk(), FillParticleTruth(), caf::SRTrack::me, caf::SRTrkME::meanpos, rb::Cluster::MeanX(), rb::Cluster::MeanY(), rb::Cluster::MeanZ(), me::SlcME::MID(), caf::SRTrkME::mid, caf::SRTrkME::nhitx, caf::SRTrkME::nhity, rb::Cluster::NXCell(), rb::Cluster::NYCell(), rb::Cluster::TotalADC(), and caf::SRTrkME::truth.

Referenced by caf::CAFMaker::produce().

  {
    vec->push_back(SRTrkME());
    SRTrkME& srME = vec->back();

    srME.nhitx        = michel.NXCell();
    srME.nhity        = michel.NYCell();
    srME.mid          = michel.MID();
    srME.calE         = michel.CalorimetricEnergy();
    srME.adc          = michel.TotalADC();
    srME.deltat       = michel.DeltaT();
    srME.disttotrack  = michel.DistToTrk();
    srME.meanpos      = TVector3(michel.MeanX(),michel.MeanY(),michel.MeanZ());
    srME.truth        = FillParticleTruth(sliceList,
                                          michel.AllCells(),
                                          allTracks,
                                          sliceTracks,
                                          allTracksBirks,
                                          sliceTracksBirks,
                                          sliceIdx);

    srTrk.me.push_back(srME); // Also copy this TrkME to parent track
  }

void caf::AddTrueMichelEToVec	(	const sim::Particle &	michel,
		const sim::Particle &	motherMuon,
		std::vector< cheat::TrackIDE > &	allTracks,
		std::vector< SRTrueMichelE > *	vec
	)

Definition at line 698 of file FillTruth.cxx.

References caf::SRTrueMichelE::E, simb::MCParticle::E(), simb::MCParticle::EndPosition(), it, simb::MCParticle::Momentum(), caf::SRTrueMichelE::mustop, caf::SRTrueMichelE::p, simb::MCParticle::T(), caf::SRTrueMichelE::time, simb::MCParticle::TrackId(), and caf::SRTrueMichelE::visE.

Referenced by FindAndAddMichels().

  {
    vec->push_back(SRTrueMichelE());
    SRTrueMichelE& srMichel = vec->back();

    // Find the visible energy from the FLS hits
    float visE = 0;
    for (std::vector<cheat::TrackIDE>::iterator  it = allTracks.begin();
         it != allTracks.end(); ++it)
    {
      if(michel.TrackId() == it->trackID)
      {
        visE = it->energy;
        break;
      }
    }

    srMichel.E       = michel.E();
    srMichel.visE    = visE;
    srMichel.time    = michel.T();
    srMichel.mustop  = motherMuon.EndPosition();
    srMichel.p       = michel.Momentum();
  }

const long& caf::AdjustBase	(	const long &	base,
		CAFType	type,
		const std::string &	name
	)

Definition at line 94 of file BasicTypesProxy.cxx.

References kFlatSingleTree, kZero, and NSubscripts().

  {
    if(type == kFlatSingleTree && NSubscripts(name) == 0) return kZero;
    return base;
  }

void caf::BlindThisCosRej

(

SRCosRej &

cosrej

)

Definition at line 156 of file Blinding.cxx.

References blind_val, caf::SRCosRej::eratio, and caf::SRCosRej::hadE.

Referenced by BlindThisRecord().

                                         {
    cosrej.eratio = blind_val;
    cosrej.hadE   = blind_val;
  }

void caf::BlindThisElasticVtx

(

SRElastic &

vtx

)

Definition at line 58 of file Blinding.cxx.

References blind_val, blind_val_unsigned, caf::SRElastic::fuzzyk, MECModelEnuComparisons::i, caf::SRFuzzyK::png, and caf::SRFuzzyK::png2d.

Referenced by BlindThisRecord().

                                           {
    for (unsigned int i=0; i<vtx.fuzzyk.png.size(); i++) {
      vtx.fuzzyk.png[i].nhit         = blind_val_unsigned;
      vtx.fuzzyk.png[i].nhitx        = blind_val_unsigned;
      vtx.fuzzyk.png[i].nhity        = blind_val_unsigned;
      vtx.fuzzyk.png[i].nplane       = blind_val_unsigned;
      vtx.fuzzyk.png[i].maxplanecont = blind_val_unsigned;
      vtx.fuzzyk.png[i].calE         = blind_val;
      vtx.fuzzyk.png[i].weightedCalE         = blind_val;
      vtx.fuzzyk.png[i].len          = blind_val;

      vtx.fuzzyk.png[i].shwlid.nhit         = blind_val_unsigned;
      vtx.fuzzyk.png[i].shwlid.nhitx        = blind_val_unsigned;
      vtx.fuzzyk.png[i].shwlid.nhity        = blind_val_unsigned;
      vtx.fuzzyk.png[i].shwlid.nplane       = blind_val_unsigned;
      vtx.fuzzyk.png[i].shwlid.maxplanecont = blind_val_unsigned;
      vtx.fuzzyk.png[i].shwlid.calE         = blind_val;
      vtx.fuzzyk.png[i].shwlid.len          = blind_val;
      vtx.fuzzyk.png[i].shwlid.stop.SetZ     (blind_val);
      vtx.fuzzyk.png[i].shwlid.lid.setDefault();
      vtx.fuzzyk.png[i].shwlid.lidE.setDefault();
      vtx.fuzzyk.png[i].cvnpart.setDefault();
      vtx.fuzzyk.png[i].regcvn.setDefault();

      vtx.fuzzyk.png[i].bpf.muon.nhit         = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.muon.nhitx        = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.muon.nhity        = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.muon.nplane       = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.muon.maxplanecont = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.muon.calE         = blind_val;
      vtx.fuzzyk.png[i].bpf.muon.len          = blind_val;
      vtx.fuzzyk.png[i].bpf.muon.lenE         = blind_val;
      vtx.fuzzyk.png[i].bpf.muon.stop.        SetZ( blind_val );
      vtx.fuzzyk.png[i].bpf.muon.pid          = blind_val;
      vtx.fuzzyk.png[i].bpf.muon.chi2T        = blind_val;
      vtx.fuzzyk.png[i].bpf.muon.dEdXLL       = blind_val;
      vtx.fuzzyk.png[i].bpf.muon.hitRatio     = blind_val;
      vtx.fuzzyk.png[i].bpf.muon.energy       = blind_val;
      vtx.fuzzyk.png[i].bpf.muon.lenE         = blind_val;
      vtx.fuzzyk.png[i].bpf.muon.overlapE     = blind_val;
      vtx.fuzzyk.png[i].bpf.muon.momentum.    SetX( blind_val );
      vtx.fuzzyk.png[i].bpf.muon.momentum.    SetY( blind_val );
      vtx.fuzzyk.png[i].bpf.muon.momentum.    SetZ( blind_val );

      vtx.fuzzyk.png[i].bpf.pion.nhit         = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.pion.nhitx        = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.pion.nhity        = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.pion.nplane       = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.pion.maxplanecont = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.pion.calE         = blind_val;
      vtx.fuzzyk.png[i].bpf.pion.len          = blind_val;
      vtx.fuzzyk.png[i].bpf.pion.lenE         = blind_val;
      vtx.fuzzyk.png[i].bpf.pion.stop.        SetZ( blind_val );
      vtx.fuzzyk.png[i].bpf.pion.pid          = blind_val;
      vtx.fuzzyk.png[i].bpf.pion.chi2T        = blind_val;
      vtx.fuzzyk.png[i].bpf.pion.dEdXLL       = blind_val;
      vtx.fuzzyk.png[i].bpf.pion.hitRatio     = blind_val;
      vtx.fuzzyk.png[i].bpf.pion.energy       = blind_val;
      vtx.fuzzyk.png[i].bpf.pion.lenE         = blind_val;
      vtx.fuzzyk.png[i].bpf.pion.overlapE     = blind_val;
      vtx.fuzzyk.png[i].bpf.pion.momentum.    SetX( blind_val );
      vtx.fuzzyk.png[i].bpf.pion.momentum.    SetY( blind_val );
      vtx.fuzzyk.png[i].bpf.pion.momentum.    SetZ( blind_val );

      vtx.fuzzyk.png[i].bpf.proton.nhit         = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.proton.nhitx        = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.proton.nhity        = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.proton.nplane       = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.proton.maxplanecont = blind_val_unsigned;
      vtx.fuzzyk.png[i].bpf.proton.calE         = blind_val;
      vtx.fuzzyk.png[i].bpf.proton.len          = blind_val;
      vtx.fuzzyk.png[i].bpf.proton.lenE         = blind_val;
      vtx.fuzzyk.png[i].bpf.proton.stop.        SetZ( blind_val );
      vtx.fuzzyk.png[i].bpf.proton.pid          = blind_val;
      vtx.fuzzyk.png[i].bpf.proton.chi2T        = blind_val;
      vtx.fuzzyk.png[i].bpf.proton.dEdXLL       = blind_val;
      vtx.fuzzyk.png[i].bpf.proton.hitRatio     = blind_val;
      vtx.fuzzyk.png[i].bpf.proton.energy       = blind_val;
      vtx.fuzzyk.png[i].bpf.proton.lenE         = blind_val;
      vtx.fuzzyk.png[i].bpf.proton.overlapE     = blind_val;
      vtx.fuzzyk.png[i].bpf.proton.momentum.    SetX( blind_val );
      vtx.fuzzyk.png[i].bpf.proton.momentum.    SetY( blind_val );
      vtx.fuzzyk.png[i].bpf.proton.momentum.    SetZ( blind_val );

    }
    for (unsigned int i=0; i<vtx.fuzzyk.png2d.size(); i++) {
      vtx.fuzzyk.png2d[i].nhit         = blind_val_unsigned;
      vtx.fuzzyk.png2d[i].nhitx        = blind_val_unsigned;
      vtx.fuzzyk.png2d[i].nhity        = blind_val_unsigned;
      vtx.fuzzyk.png2d[i].nplane       = blind_val_unsigned;
      vtx.fuzzyk.png2d[i].maxplanecont = blind_val_unsigned;
      vtx.fuzzyk.png2d[i].calE         = blind_val;
      vtx.fuzzyk.png2d[i].weightedCalE         = blind_val;
      vtx.fuzzyk.png2d[i].len          = blind_val;
    }
  }

void caf::BlindThisJMShower

(

SRJMShower &

jm

)

Definition at line 44 of file Blinding.cxx.

References blind_val, blind_val_unsigned, caf::SRJMShower::calE, caf::SRJMShower::len, caf::SRJMShower::maxplanecont, caf::SRJMShower::nhit, caf::SRJMShower::nhitx, caf::SRJMShower::nhity, caf::SRJMShower::nplane, caf::SRJMShower::shwE, caf::SRJMShower::stop, and caf::SRJMShower::vtxE.

                                         {
    jm.nhit          = blind_val_unsigned;
    jm.nhitx         = blind_val_unsigned;
    jm.nhity         = blind_val_unsigned;
    jm.nplane        = blind_val_unsigned;
    jm.maxplanecont  = blind_val_unsigned;
    jm.calE          = blind_val;
    jm.len           = blind_val;
    jm.shwE          = blind_val;
    jm.vtxE          = blind_val;
    jm.stop.     SetZ( blind_val );
  }

void caf::BlindThisRecord

(

StandardRecord *

rec

)

If required, scrub the record of any quantities that shouldn't be viewed

Definition at line 162 of file Blinding.cxx.

References caf::SRHeader::blind, blind_val, BlindThisCosRej(), BlindThisElasticVtx(), BlindThisSlice(), BlindThisTrack(), caf::SRIDBranch::bpfid, caf::SRSlice::calE, om::cerr, caf::SRTrackBranch::cosmic, caf::SRIDBranch::cosrej, caf::SRIDBranch::cvnloosepreselptp, caf::SRIDBranch::cvnnocosmics, caf::SRIDBranch::cvnoldpresel, caf::SRHeader::det, caf::SRTrackBranch::discrete, caf::SRVertexBranch::elastic, allTimeWatchdog::endl, caf::StandardRecord::energy, caf::StandardRecord::hdr, MECModelEnuComparisons::i, caf::SRHeader::ismc, caf::SRElastic::IsValid, caf::SRTrackBranch::kalman, kFARDET, caf::SRIDBranch::lem, caf::SRNueEnergy::lid, caf::SRIDBranch::lid, caf::SRSlice::meantime, caf::SREnergyBranch::nue, caf::SREnergyBranch::numu, caf::SRIDBranch::remid, caf::SRIDBranch::rvp, caf::StandardRecord::sel, caf::SRSLidEnergy::setDefault(), caf::SRNueEnergy::setDefault(), caf::SRCVNResult::setDefault(), caf::SRELid::setDefault(), caf::SRRemid::setDefault(), caf::SRRvp::setDefault(), caf::SRBpfId::setDefault(), caf::SRNumuEnergy::setDefault(), caf::SRLem::setDefault(), caf::StandardRecord::slc, caf::SRTrackBase::tracks, caf::SRKalman::tracks, caf::StandardRecord::trk, caf::StandardRecord::vtx, and caf::SRTrackBranch::window.

Referenced by caf::CAFMaker::produce().

                                            {
    /// If required, scrub the record of any quantities that shouldn't be viewed

    if(rec->hdr.det != kFARDET){
      std::cerr << "Should only apply blinding to the Far Detector, aborting."
                << std::endl;
      abort();
    }

    if(rec->hdr.ismc){
      std::cerr << "Shouldn't apply blinding to Monte Carlo, aborting."
                << std::endl;
      abort();
    }

    // Is this record in the box?

    // Blinding 0.8 to 3 GeV events within 30 microsecond window
    // around center of beam spill (t=222000 microseconds).
    if (rec->slc.calE > 0.8 &&
        rec->slc.calE < 3.0 &&
        rec->slc.meantime > 207000 && 
        rec->slc.meantime < 237000 ) {

      // Walk through each rec branch.

      // -- start of branches --

      // -- hdr
      // Tag the record as blind
      rec->hdr.blind = 1;
    
      // -- spill

      // -- slc
      BlindThisSlice(rec->slc);

      // -- trk
      for (unsigned int i=0; i<rec->trk.kalman.tracks.size(); i++) {
        BlindThisTrack(rec->trk.kalman.tracks[i]);
        rec->trk.kalman.tracks[i].remavededx = blind_val;
        rec->trk.kalman.tracks[i].rempid = blind_val;
        rec->trk.kalman.tracks[i].scatllh = blind_val;
        rec->trk.kalman.tracks[i].dedxllh = blind_val;
        rec->trk.kalman.tracks[i].measfrac = blind_val;
        rec->trk.kalman.tracks[i].remcont = blind_val;
        rec->trk.kalman.tracks[i].lenE = blind_val;
        rec->trk.kalman.tracks[i].overlapE = blind_val;
      }
      for (unsigned int i=0; i<rec->trk.discrete.tracks.size(); i++) {
        BlindThisTrack(rec->trk.discrete.tracks[i]);
      }
      for (unsigned int i=0; i<rec->trk.cosmic.tracks.size(); i++) {
        BlindThisTrack(rec->trk.cosmic.tracks[i]);
      }
      for (unsigned int i=0; i<rec->trk.window.tracks.size(); i++) {
        BlindThisTrack(rec->trk.window.tracks[i]);
      }

      // -- vtx
      if (rec->vtx.elastic.IsValid == 1) {
        BlindThisElasticVtx(rec->vtx.elastic);
      }
      
      // -- energy
      // for now, everything goes, so use setDefault() methods
      rec->energy.numu.setDefault();
      rec->energy.nue .setDefault();
      rec->energy.nue.lid.setDefault();

      // for (unsigned int i=0; i<rec->energy.nue.lid.size(); i++) {
      //   rec->energy.nue.lid[i].setDefault();
      // }

      // -- sel
      // for now, everything goes, so use setDefault() methods
      rec->sel.remid.setDefault();
      rec->sel.bpfid.setDefault();
      rec->sel.lid  .setDefault();
      // for (unsigned int i=0; i<rec->sel.lid.shwlid.size(); i++){
      //   rec->sel.lid.shwlid[i].setDefault();
      //}
      rec->sel.lem   .setDefault();
      rec->sel.rvp   .setDefault();
      rec->sel.cvnloosepreselptp.setDefault();
      rec->sel.cvnoldpresel     .setDefault();
      rec->sel.cvnnocosmics     .setDefault();

      // some stuff survives here:
      BlindThisCosRej   (rec->sel.cosrej);

      // -- mc

      // -- parent

      // -- end of branches --

    } // end if (rec needs blinding)

  } 

void caf::BlindThisSlice

(

SRSlice &

slc

)

Definition at line 20 of file Blinding.cxx.

References blind_val, blind_val_unsigned, caf::SRSlice::boxmax, caf::SRSlice::calE, caf::SRSlice::lastplane, std::max(), caf::SRSlice::meanpos, caf::SRSlice::ncontplanes, caf::SRVector3D::SetZ(), and submit_hadd::u.

Referenced by BlindThisRecord().

                                    {
    // Small numbers of ncontplanes are useful for cosmic rejection, large
    // numbers can leak the event length (~ energy).
    slc.ncontplanes = std::max(10u, slc.ncontplanes);
    slc.lastplane   = blind_val_unsigned;
    slc.calE        = blind_val;
    slc.boxmax. SetZ( blind_val );
    slc.meanpos.SetZ( blind_val );
  }

void caf::BlindThisTrack

(

SRTrack &

trk

)

Definition at line 31 of file Blinding.cxx.

References blind_val, blind_val_unsigned, caf::SRTrack::calE, caf::SRTrack::len, caf::SRTrack::lenE, caf::SRTrack::maxplanecont, caf::SRTrack::nhit, caf::SRTrack::nhitx, caf::SRTrack::nhity, caf::SRTrack::nplane, and caf::SRTrack::stop.

Referenced by BlindThisRecord().

                                    {
    trk.nhit         = blind_val_unsigned;
    trk.nhitx        = blind_val_unsigned;
    trk.nhity        = blind_val_unsigned;
    trk.nplane       = blind_val_unsigned;
    trk.maxplanecont = blind_val_unsigned;
    trk.calE         = blind_val;
    trk.len          = blind_val;
    trk.lenE         = blind_val;
    trk.stop.    SetZ( blind_val );
  }

caf::generator_ caf::CAFGeneratorEnum

(

simb::Generator_t

simbGeneratorEnum

)

Definition at line 905 of file FillTruth.cxx.

References simb::kGENIE, kGENIE, simb::kGIBUU, kGIBUU, and kUnknownGenerator.

Referenced by caf::CAFMaker::AddMCTruthToVec().

  {
    switch (simbGeneratorEnum)
    {
      case simb::Generator_t::kGENIE:
        return kGENIE;

      case simb::Generator_t::kGIBUU:
        return kGIBUU;

      default:
        return kUnknownGenerator;

    }
  }

void caf::CopyMuonIDVars	(	const SRKalmanTrack &	srTrk,
		caf::SRMuonID &	muid
	)

Definition at line 723 of file FillPIDs.cxx.

References caf::SRKalmanTrack::muonid, and caf::SRMuonID::pid.

Referenced by caf::CAFMaker::produce().

  {
    muid.pid = srTrk.muonid;
  }

void caf::CopyRemidVars	(	const SRKalmanTrack &	srTrk,
		caf::SRRemid &	remid
	)

Definition at line 712 of file FillPIDs.cxx.

References caf::SRRemid::cont, caf::SRKalmanTrack::dedxllh, caf::SRRemid::dedxllh, caf::SRRemid::len, caf::SRTrack::len, caf::SRKalmanTrack::measfrac, caf::SRRemid::measfrac, caf::SRRemid::pid, caf::SRKalmanTrack::remcont, caf::SRKalmanTrack::rempid, caf::SRKalmanTrack::scatllh, and caf::SRRemid::scatllh.

Referenced by caf::CAFMaker::produce().

  {
    remid.pid      = srTrk.rempid;
    remid.scatllh  = srTrk.scatllh;
    remid.dedxllh  = srTrk.dedxllh;
    remid.len      = srTrk.len;
    remid.measfrac = srTrk.measfrac;
    remid.cont     = srTrk.remcont;
  }

std::vector< unsigned int > caf::DecodeGeneratorVersion

(

const std::string &

versionString

)

Definition at line 922 of file FillTruth.cxx.

References it, submit_syst::pattern, submit_cafana::regex, and runNovaSAM::ret.

Referenced by caf::CAFMaker::AddMCTruthToVec().

  {
    std::vector<unsigned int> ret;
    std::regex pattern("(\\d+)");
    auto vals_begin =  std::sregex_iterator(versionString.begin(), versionString.end(), pattern);
    auto vals_end = std::sregex_iterator();

    for (auto it = vals_begin; it != vals_end; it++)
      ret.push_back(std::stoi(it->str()));

    return ret;
  }

template<class T >

void caf::EvalInstanceWrapper	(	TTreeFormula *	ttf,
		T &	x
	)

Definition at line 236 of file BasicTypesProxy.cxx.

References T.

Referenced by caf::Proxy< T >::GetValueNested().

  {
    // TODO is this the safest way to cast?
    x = (T)ttf->EvalInstance(0);
  }

void caf::EvalInstanceWrapper	(	TTreeFormula *	ttf,
		std::string &	x
	)

Definition at line 242 of file BasicTypesProxy.cxx.

  {
    x = ttf->EvalStringInstance(0);
  }

void caf::FillCosRejVars	(	const cosrej::CosRejObj &	cosrej,
		caf::SRCosRej &	srcosrej,
		caf::SRContain &	srcontain
	)

Definition at line 394 of file FillPIDs.cxx.

References caf::SRCosRej::anglecos, cosrej::CosRejObj::AngleCos(), caf::SRCosRej::anglekal, cosrej::CosRejObj::AngleKal(), caf::SRCosRej::cdirscore, cosrej::CosRejObj::CDirScore(), caf::SRCosRej::cfitspeed, cosrej::CosRejObj::CFitSpeed(), cosrej::CosRejObj::ConCosPID(), caf::SRContain::cosbakair, cosrej::CosRejObj::CosBakAir(), caf::SRContain::cosbakcell, cosrej::CosRejObj::CosBakCell(), caf::SRContain::cosbakcellnd, cosrej::CosRejObj::CosBakCellND(), caf::SRContain::cosbakdist, cosrej::CosRejObj::CosBakDist(), caf::SRContain::cosbaksteel, cosrej::CosRejObj::CosBakSteel(), caf::SRCosRej::coschidiff, cosrej::CosRejObj::CosChiDiff(), caf::SRCosRej::coschisq, cosrej::CosRejObj::CosChisq(), caf::SRContain::cosfwdair, cosrej::CosRejObj::CosFwdAir(), caf::SRContain::cosfwdcell, cosrej::CosRejObj::CosFwdCell(), caf::SRContain::cosfwdcellnd, cosrej::CosRejObj::CosFwdCellND(), caf::SRContain::cosfwddist, cosrej::CosRejObj::CosFwdDist(), caf::SRContain::cosfwdsteel, cosrej::CosRejObj::CosFwdSteel(), caf::SRCosRej::cosslope, cosrej::CosRejObj::CosSlope(), caf::SRCosRej::costhetatrue, cosrej::CosRejObj::CosThetaTrue(), caf::SRContain::cosyposattrans, cosrej::CosRejObj::CosYPosAtTrans(), caf::SRCosRej::cscorediff, cosrej::CosRejObj::CScoreDiff(), caf::SRContain::enddist, cosrej::CosRejObj::EndDist(), caf::SRCosRej::eratio, cosrej::CosRejObj::ERatio(), caf::SRCosRej::fscattext, cosrej::CosRejObj::FScattExt(), caf::SRCosRej::fscattmax, cosrej::CosRejObj::FScattMax(), caf::SRCosRej::fscattsig, cosrej::CosRejObj::FScattSig(), caf::SRCosRej::fscattsum, cosrej::CosRejObj::FScattSum(), caf::SRCosRej::hadE, caf::SRContain::kalbakair, cosrej::CosRejObj::KalBakAir(), caf::SRContain::kalbakcell, cosrej::CosRejObj::KalBakCell(), caf::SRContain::kalbakcellnd, cosrej::CosRejObj::KalBakCellND(), caf::SRContain::kalbakdist, cosrej::CosRejObj::KalBakDist(), caf::SRContain::kalbaksteel, cosrej::CosRejObj::KalBakSteel(), caf::SRCosRej::kalchidiff, cosrej::CosRejObj::KalChiDiff(), caf::SRCosRej::kalchisq, cosrej::CosRejObj::KalChisq(), caf::SRContain::kalfwdair, cosrej::CosRejObj::KalFwdAir(), caf::SRContain::kalfwdcell, cosrej::CosRejObj::KalFwdCell(), caf::SRContain::kalfwdcellnd, cosrej::CosRejObj::KalFwdCellND(), caf::SRContain::kalfwddist, cosrej::CosRejObj::KalFwdDist(), caf::SRContain::kalfwdsteel, cosrej::CosRejObj::KalFwdSteel(), caf::SRCosRej::kalslope, cosrej::CosRejObj::KalSlope(), caf::SRCosRej::kalthetatrue, cosrej::CosRejObj::KalThetaTrue(), caf::SRContain::kalyposattrans, cosrej::CosRejObj::KalYPosAtTrans(), caf::SRCosRej::kdirscore, cosrej::CosRejObj::KDirScore(), caf::SRCosRej::kfitspeed, cosrej::CosRejObj::KFitSpeed(), caf::SRCosRej::kscorediff, cosrej::CosRejObj::KScoreDiff(), caf::SRCosRej::mincell, cosrej::CosRejObj::MinCell(), caf::SRCosRej::mindist, cosrej::CosRejObj::MinDist(), caf::SRCosRej::nkal3d, cosrej::CosRejObj::NTracks3D(), caf::SRCosRej::numucontpid2019, caf::SRCosRej::numucontpid2020, caf::SRCosRej::numuunconttunedpid, cosrej::CosRejObj::OldCosPID(), caf::SRCosRej::pdgbest, cosrej::CosRejObj::PDGBest(), caf::SRCosRej::scatt, cosrej::CosRejObj::Scatt(), cosrej::CosRejObj::StartAct(), cosrej::CosRejObj::UnconTunedCosPID(), caf::SRContain::vtxdist, and cosrej::CosRejObj::VtxDist().

Referenced by caf::CAFMaker::produce().

  {
    srcosrej.anglekal      = cosrej.AngleKal();
    srcosrej.anglecos      = cosrej.AngleCos();

    srcosrej.numucontpid2020    = cosrej.ConCosPID();
    srcosrej.numucontpid2019    = cosrej.OldCosPID();
    srcosrej.numuunconttunedpid = cosrej.UnconTunedCosPID();

    srcosrej.nkal3d        = cosrej.NTracks3D();
    srcosrej.mindist       = cosrej.MinDist();
    srcosrej.mincell       = cosrej.MinCell();
    srcosrej.eratio        = cosrej.ERatio();
    srcosrej.scatt         = cosrej.Scatt();
    srcosrej.hadE          = cosrej.StartAct();
    srcosrej.costhetatrue  = cosrej.CosThetaTrue();
    srcosrej.kalthetatrue  = cosrej.KalThetaTrue();
    srcosrej.pdgbest       = cosrej.PDGBest();
    srcosrej.fscattmax     = cosrej.FScattMax();
    srcosrej.fscattsum     = cosrej.FScattSum();
    srcosrej.fscattext     = cosrej.FScattExt();
    srcosrej.fscattsig     = cosrej.FScattSig();
    srcosrej.kfitspeed     = cosrej.KFitSpeed();
    srcosrej.cfitspeed     = cosrej.CFitSpeed();
    srcosrej.kdirscore     = cosrej.KDirScore();
    srcosrej.cdirscore     = cosrej.CDirScore();
    srcosrej.kscorediff    = cosrej.KScoreDiff();
    srcosrej.cscorediff    = cosrej.CScoreDiff();
    srcosrej.kalchisq      = cosrej.KalChisq();
    srcosrej.kalslope      = cosrej.KalSlope();
    srcosrej.kalchidiff    = cosrej.KalChiDiff();
    srcosrej.coschisq      = cosrej.CosChisq();
    srcosrej.cosslope      = cosrej.CosSlope();
    srcosrej.coschidiff    = cosrej.CosChiDiff();

    srcontain.vtxdist        = cosrej.VtxDist();
    srcontain.enddist        = cosrej.EndDist();
    srcontain.cosfwddist     = cosrej.CosFwdDist();
    srcontain.cosbakdist     = cosrej.CosBakDist();
    srcontain.cosfwdcell     = cosrej.CosFwdCell();
    srcontain.cosfwdcellnd   = cosrej.CosFwdCellND();
    srcontain.cosbakcell     = cosrej.CosBakCell();
    srcontain.cosbakcellnd   = cosrej.CosBakCellND();
    srcontain.cosfwdair      = cosrej.CosFwdAir();
    srcontain.cosfwdsteel    = cosrej.CosFwdSteel();
    srcontain.cosbakair      = cosrej.CosBakAir();
    srcontain.cosbaksteel    = cosrej.CosBakSteel();
    srcontain.kalfwdair      = cosrej.KalFwdAir();
    srcontain.kalfwdsteel    = cosrej.KalFwdSteel();
    srcontain.kalbakair      = cosrej.KalBakAir();
    srcontain.kalbaksteel    = cosrej.KalBakSteel();
    srcontain.kalfwddist     = cosrej.KalFwdDist();
    srcontain.kalbakdist     = cosrej.KalBakDist();
    srcontain.kalfwdcell     = cosrej.KalFwdCell();
    srcontain.kalfwdcellnd   = cosrej.KalFwdCellND();
    srcontain.kalbakcell     = cosrej.KalBakCell();
    srcontain.kalbakcellnd   = cosrej.KalBakCellND();
    srcontain.cosyposattrans = cosrej.CosYPosAtTrans();
    srcontain.kalyposattrans = cosrej.KalYPosAtTrans();
  }

void caf::FillCVNFeaturesVars	(	const cvn::Features &	features,
		caf::SRCVNFeatures &	srcvnfeatures,
		int	maxcomponents
	)

Definition at line 699 of file FillPIDs.cxx.

References caf::SRCVNFeatures::components, cvn::Features::fOutput, cvn::Features::fPrincipalComponents, caf::SRCVNFeatures::ncomponents, caf::SRCVNFeatures::noutput, and caf::SRCVNFeatures::output.

  {
    srcvnfeatures.output = features.fOutput;
    srcvnfeatures.noutput = features.fOutput.size();
    srcvnfeatures.components = features.fPrincipalComponents;
    if(int(srcvnfeatures.components.size()) > maxcomponents)
      srcvnfeatures.components.resize(maxcomponents);
    srcvnfeatures.ncomponents = srcvnfeatures.components.size();
  }

void caf::FillCVNNeutronDaughterResultVars	(	const std::vector< art::Ptr< rb::PID > > &	cvnneutrons,
		caf::SRCVNNeutronDaughterResult &	cvnneutron
	)

Definition at line 95 of file FillPIDs.cxx.

References MECModelEnuComparisons::i, caf::SRCVNNeutronDaughterResult::otherid, caf::SRCVNNeutronDaughterResult::photonid, caf::SRCVNNeutronDaughterResult::protonid, and febshutoff_auto::val.

Referenced by caf::CAFMaker::produce().

  {
    for (unsigned int i=0; i<cvnneutrons.size(); ++i){
      float val = cvnneutrons[i]->Value();
      int id = cvnneutrons[i]->Pdg();
      if(id==2212)
        cvnneutron.protonid = val;
      else if(id==22)
        cvnneutron.photonid = val;
      else
        cvnneutron.otherid = val;
    }

  }

void caf::FillCVNParticleResultVars	(	const std::vector< art::Ptr< rb::PID > > &	cvnparts,
		caf::SRCVNParticleResult &	cvnpart
	)

Definition at line 112 of file FillPIDs.cxx.

References caf::SRCVNParticleResult::electronid, caf::SRCVNParticleResult::emid, caf::SRCVNParticleResult::hadronid, MECModelEnuComparisons::i, caf::SRCVNParticleResult::maxval, caf::SRCVNParticleResult::muonid, caf::SRCVNParticleResult::neutronid, caf::SRCVNParticleResult::otherid, caf::SRCVNParticleResult::pdgmax, caf::SRCVNParticleResult::photonid, caf::SRCVNParticleResult::pionid, caf::SRCVNParticleResult::pizeroid, caf::SRCVNParticleResult::protonid, and febshutoff_auto::val.

Referenced by caf::CAFMaker::produce().

  {

    float largestv = 0;
    int largestid = 0;
    for (unsigned int i=0; i<cvnparts.size(); ++i){
      float val = cvnparts[i]->Value();
      int id = cvnparts[i]->Pdg();
      if (val > largestv){
        largestv = val;
        largestid = id;
      }
      switch (id) {
      case  11:
        cvnpart.electronid = val;
        break;
      case  13:
        cvnpart.muonid = val;
        break;
      case  2212:
        cvnpart.protonid = val;
        break;
      case  2112:
        cvnpart.neutronid = val;
        break;
      case  211:
        cvnpart.pionid = val;
        break;
      case 111:
        cvnpart.pizeroid = val;
        break;
      case  22:
        cvnpart.photonid = val;
        break;
      case 22 * 11:
        cvnpart.emid = val;     
        break;
      case 2212 * 211:
        cvnpart.hadronid = val;
        break;
      default:
        cvnpart.otherid = val;
        break;
      }
    }
    cvnpart.maxval = largestv;
    cvnpart.pdgmax = largestid;

    if(cvnpart.emid < 0) 
      cvnpart.emid = cvnpart.electronid + cvnpart.photonid;
    if(cvnpart.hadronid < 0)
      cvnpart.hadronid = cvnpart.pionid + cvnpart.protonid;

  }

void caf::FillCVNPixelMaps	(	const cvn::PixelMap &	map,
		caf::SRPixelObjMap &	srcvnmap,
		bool	useGeV
	)

Definition at line 617 of file FillPIDs.cxx.

References caf::SRPixelObjMap::cvnlabmap, caf::SRPixelObjMap::cvnmap, caf::SRPixelObjMap::cvnobjmap, cvn::PixelMap::fBound, cvn::PixelMap::fFracX, cvn::PixelMap::fFracY, cvn::Boundary::FirstCell(), caf::SRPixelObjMap::firstcellx, caf::SRPixelObjMap::firstcelly, caf::SRPixelObjMap::firstplane, cvn::Boundary::FirstPlane(), cvn::PixelMap::fNCell, cvn::PixelMap::fNPlane, caf::SRPixelObjMap::hitfracx, caf::SRPixelObjMap::hitfracy, cvn::Boundary::LastCell(), caf::SRPixelObjMap::lastcellx, caf::SRPixelObjMap::lastcelly, caf::SRPixelObjMap::lastplane, cvn::Boundary::LastPlane(), caf::SRPixelObjMap::ncells, caf::SRPixelObjMap::nchan, caf::SRPixelObjMap::nplanes, cvn::PixelMap::PixelMapToObjVector(), and cvn::PixelMap::PixelMapToVector().

Referenced by caf::CAFMaker::produce().

  {
    srcvnmap.nchan = 2;  //two views to pixel map
    srcvnmap.nplanes = map.fNPlane/2;
    srcvnmap.ncells = map.fNCell;
    srcvnmap.hitfracx = map.fFracX;
    srcvnmap.hitfracy = map.fFracY;
    srcvnmap.firstplane = map.fBound.FirstPlane();
    srcvnmap.lastplane = map.fBound.LastPlane();
    srcvnmap.firstcellx = map.fBound.FirstCell(0);
    srcvnmap.lastcellx = map.fBound.LastCell(0);
    srcvnmap.firstcelly = map.fBound.FirstCell(1);
    srcvnmap.lastcelly = map.fBound.LastCell(1);

    std::vector<unsigned char> tval = map.PixelMapToVector(useGeV);
    std::copy(tval.begin(), tval.end(), srcvnmap.cvnmap);
    std::vector<unsigned char> tlab = map.PixelMapToObjVector(true);
    std::copy(tlab.begin(), tlab.end(), srcvnmap.cvnlabmap);
    std::vector<unsigned char> tobj = map.PixelMapToObjVector(false);
    std::copy(tobj.begin(), tobj.end(), srcvnmap.cvnobjmap);
  }

void caf::FillCVNPixelMaps	(	const cvn::PixelMap &	map,
		caf::SRPixelMap &	srcvnmap,
		bool	useGeV
	)

Definition at line 641 of file FillPIDs.cxx.

References caf::SRPixelMap::cvnmap, cvn::PixelMap::fBound, cvn::PixelMap::fFracX, cvn::PixelMap::fFracY, cvn::Boundary::FirstCell(), caf::SRPixelMap::firstcellx, caf::SRPixelMap::firstcelly, caf::SRPixelMap::firstplane, cvn::Boundary::FirstPlane(), cvn::PixelMap::fNCell, cvn::PixelMap::fNPlane, caf::SRPixelMap::hitfracx, caf::SRPixelMap::hitfracy, cvn::Boundary::LastCell(), caf::SRPixelMap::lastcellx, caf::SRPixelMap::lastcelly, caf::SRPixelMap::lastplane, cvn::Boundary::LastPlane(), caf::SRPixelMap::ncells, caf::SRPixelMap::nchan, caf::SRPixelMap::nplanes, and cvn::PixelMap::PixelMapToVector().

  {
    srcvnmap.nchan = 2;  //two views to pixel map
    srcvnmap.nplanes = map.fNPlane/2;
    srcvnmap.ncells = map.fNCell;
    srcvnmap.hitfracx = map.fFracX;
    srcvnmap.hitfracy = map.fFracY;
    srcvnmap.firstplane = map.fBound.FirstPlane();
    srcvnmap.lastplane = map.fBound.LastPlane();
    srcvnmap.firstcellx = map.fBound.FirstCell(0);
    srcvnmap.lastcellx = map.fBound.LastCell(0);
    srcvnmap.firstcelly = map.fBound.FirstCell(1);
    srcvnmap.lastcelly = map.fBound.LastCell(1);

    std::vector<unsigned char> tval = map.PixelMapToVector(useGeV);
    std::copy(tval.begin(), tval.end(), srcvnmap.cvnmap);
  }

void caf::FillCVNProngTrainingData	(	const cvn::ProngTrainingData &	cvnpdata,
		caf::SRProngTrainingData &	srpdata
	)

Definition at line 677 of file FillPIDs.cxx.

References cvn::ProngTrainingData::fIsPrimary, cvn::ProngTrainingData::fLabel3D, cvn::ProngTrainingData::fLabelX, cvn::ProngTrainingData::fLabelY, cvn::ProngTrainingData::fNCellX, cvn::ProngTrainingData::fNCellY, cvn::ProngTrainingData::fPAngle, cvn::ProngTrainingData::fPGap, cvn::ProngTrainingData::fPLength, cvn::ProngTrainingData::fPurity3D, cvn::ProngTrainingData::fPurityX, cvn::ProngTrainingData::fPurityY, cvn::ProngTrainingData::fRecE, cvn::ProngTrainingData::fVertX, cvn::ProngTrainingData::fVertY, cvn::ProngTrainingData::fVertZ, caf::SRProngTrainingData::isprimary, caf::SRProngTrainingData::label3d, caf::SRProngTrainingData::labelx, caf::SRProngTrainingData::labely, caf::SRProngTrainingData::ncellx, caf::SRProngTrainingData::ncelly, caf::SRProngTrainingData::pangle, caf::SRProngTrainingData::pgap, caf::SRProngTrainingData::plength, caf::SRProngTrainingData::purity3d, caf::SRProngTrainingData::purityx, caf::SRProngTrainingData::purityy, caf::SRProngTrainingData::rece, caf::SRProngTrainingData::vertx, caf::SRProngTrainingData::verty, and caf::SRProngTrainingData::vertz.

Referenced by caf::CAFMaker::produce().

  {
    srpdata.label3d = cvnpdata.fLabel3D;
    srpdata.labelx = cvnpdata.fLabelX;
    srpdata.labely = cvnpdata.fLabelY;
    srpdata.isprimary = cvnpdata.fIsPrimary;
    srpdata.purity3d = cvnpdata.fPurity3D;
    srpdata.purityx = cvnpdata.fPurityX;
    srpdata.purityy = cvnpdata.fPurityY;
    srpdata.rece = cvnpdata.fRecE;
    srpdata.ncellx = cvnpdata.fNCellX;
    srpdata.ncelly = cvnpdata.fNCellY;
    srpdata.vertx = cvnpdata.fVertX;
    srpdata.verty = cvnpdata.fVertY;
    srpdata.vertz = cvnpdata.fVertZ;
    srpdata.plength = cvnpdata.fPLength;
    srpdata.pangle = cvnpdata.fPAngle;
    srpdata.pgap = cvnpdata.fPGap;
  }

void caf::FillCVNResultVars	(	const cvn::Result &	result,
		caf::SRCVNResult &	srcvn,
		bool	NoCosmics
	)

Definition at line 595 of file FillPIDs.cxx.

References caf::SRCVNResult::argmax, caf::SRCVNResult::cosmicid, distance(), cvn::Result::fOutput, caf::SRCVNResult::maxval, caf::SRCVNResult::ncid, caf::SRCVNResult::noutput, caf::SRCVNResult::nueid, caf::SRCVNResult::numuid, caf::SRCVNResult::nutauid, and caf::SRCVNResult::output.

Referenced by caf::CAFMaker::produce().

  {
    srcvn.output = result.fOutput;

    std::vector<float>::const_iterator maxIt =
      std::max_element(result.fOutput.cbegin(), result.fOutput.cend());

    srcvn.maxval = *maxIt;
    srcvn.argmax = std::distance(result.fOutput.cbegin(), maxIt);
    srcvn.noutput = result.fOutput.size();

    srcvn.numuid   = result.fOutput[0];
    srcvn.nueid    = result.fOutput[1];
    srcvn.nutauid  = -5;
    srcvn.ncid     = result.fOutput[2];
    srcvn.cosmicid = result.fOutput[3];
    if (NoCosmics) srcvn.cosmicid = -5;
  }

void caf::FillCVNTrainingData	(	const cvn::TrainingData &	cvntdata,
		caf::SRTrainingData &	srtdata
	)

Definition at line 661 of file FillPIDs.cxx.

References cvn::TrainingData::fFSlong, cvn::TrainingData::fFSp, cvn::TrainingData::fFSt, caf::SRTrainingData::finalstate, caf::SRTrainingData::finalstateprong, cvn::TrainingData::fInt, cvn::TrainingData::fLepEnergy, cvn::TrainingData::fNuEnergy, cvn::TrainingData::fPPt, cvn::TrainingData::fVtxX, cvn::TrainingData::fVtxY, cvn::TrainingData::fVtxZ, caf::SRTrainingData::interaction, caf::SRTrainingData::lepenergy, caf::SRTrainingData::nuenergy, caf::SRTrainingData::parent, caf::SRTrainingData::particles, caf::SRTrainingData::vtxx, caf::SRTrainingData::vtxy, and caf::SRTrainingData::vtxz.

Referenced by caf::CAFMaker::produce().

  {
    srtdata.parent = cvntdata.fPPt;
    srtdata.interaction = cvntdata.fInt;
    srtdata.finalstate = cvntdata.fFSt;
    srtdata.finalstateprong = cvntdata.fFSp;
    srtdata.particles = cvntdata.fFSlong;
    srtdata.nuenergy = cvntdata.fNuEnergy;
    srtdata.lepenergy = cvntdata.fLepEnergy;
    srtdata.vtxx = cvntdata.fVtxX;
    srtdata.vtxy = cvntdata.fVtxY;
    srtdata.vtxz = cvntdata.fVtxZ;
  }

void caf::FillDiFShowerVars	(	const rb::Shower &	shw,
		const std::vector< rb::Cluster > &	sliceList,
		std::vector< cheat::TrackIDE > &	allTracks,
		std::vector< cheat::TrackIDE > &	sliceTracks,
		std::vector< cheat::TrackIDE > &	allTracksBirks,
		std::vector< cheat::TrackIDE > &	sliceTracksBirks,
		int	sliceIdx,
		SRMRProperties &	srMR
	)

Definition at line 504 of file FillReco.cxx.

References rb::Cluster::AllCells(), caf::SRShower::calE, rb::Cluster::CalorimetricEnergy(), caf::SRShower::dir, rb::Prong::Dir(), rb::Cluster::ExtentPlane(), FillParticleTruth(), if(), caf::SRMRProperties::isShwDiF, IsTrueDiF(), kX, geo::kX, kXorY, geo::kXorY, kY, geo::kY, caf::SRShower::len, caf::SRMRProperties::lid, caf::SRShower::maxplanecont, caf::SRShower::maxplanegap, rb::Cluster::MostContiguousPlanes(), rb::Cluster::MostMissingPlanes(), rb::Cluster::NCell(), caf::SRShower::nhit, caf::SRShower::nhitx, caf::SRShower::nhity, caf::SRShower::nplane, caf::SRShower::nplanex, caf::SRShower::nplaney, rb::Cluster::NXCell(), rb::Cluster::NYCell(), caf::SRShower::start, rb::Prong::Start(), caf::SRShower::stop, rb::Shower::Stop(), rb::Shower::TotalLength(), caf::SRShower::truth, caf::SRShower::truthXView, caf::SRShower::truthYView, caf::SRShower::view, rb::Cluster::XCells(), and rb::Cluster::YCells().

Referenced by caf::CAFMaker::produce().

  {
    srMR.isShwDiF         = IsTrueDiF(shw);

    srMR.lid.nhit         = shw.NCell();
    srMR.lid.nhitx        = shw.NXCell();
    srMR.lid.nhity        = shw.NYCell();
    srMR.lid.nplane       = shw.ExtentPlane();
    srMR.lid.nplanex      = shw.ExtentPlane(geo::kX);
    srMR.lid.nplaney      = shw.ExtentPlane(geo::kY);
    srMR.lid.maxplanecont = shw.MostContiguousPlanes(geo::kXorY);
    srMR.lid.maxplanegap  = shw.MostMissingPlanes(geo::kXorY);
    srMR.lid.len          = shw.TotalLength();
    srMR.lid.calE         = shw.CalorimetricEnergy();
    srMR.lid.start        = shw.Start();
    srMR.lid.dir          = shw.Dir();
    srMR.lid.stop         = shw.Stop();

    srMR.lid.truth               = FillParticleTruth(sliceList,
                                                  shw.AllCells(),
                                                  allTracks,
                                                  sliceTracks,
                                                  allTracksBirks,
                                                  sliceTracksBirks,
                                                  sliceIdx);
    srMR.lid.truthXView               = FillParticleTruth(sliceList,
                                                       shw.XCells(),
                                                       allTracks,
                                                       sliceTracks,
                                                       allTracksBirks,
                                                       sliceTracksBirks,
                                                       sliceIdx);
    srMR.lid.truthYView               = FillParticleTruth(sliceList,
                                                       shw.YCells(),
                                                       allTracks,
                                                       sliceTracks,
                                                       allTracksBirks,
                                                       sliceTracksBirks,
                                                       sliceIdx);
    if      (shw.NXCell() == 0)  srMR.lid.view = kY;
    else if (shw.NYCell() == 0)  srMR.lid.view = kX;
    else                         srMR.lid.view = kXorY;
  }

void caf::FillDiFVars	(	const rb::Cluster &	slice,
		const std::vector< rb::Cluster > &	sliceList,
		std::vector< cheat::TrackIDE > &	allTracks,
		std::vector< cheat::TrackIDE > &	sliceTracks,
		std::vector< cheat::TrackIDE > &	allTracksBirks,
		std::vector< cheat::TrackIDE > &	sliceTracksBirks,
		int	sliceIdx,
		SRMRProperties &	srMR
	)

Definition at line 97 of file FillReco.cxx.

References rb::Cluster::AllCells(), caf::SRMRProperties::calE, rb::Cluster::CalorimetricEnergy(), rb::Cluster::ExtentPlane(), FillParticleTruth(), if(), caf::SRMRProperties::isDiF, IsTrueDiF(), kX, geo::kX, kXorY, geo::kXorY, kY, geo::kY, caf::SRMRProperties::maxplane, rb::Cluster::MaxPlane(), caf::SRMRProperties::maxplanecont, caf::SRMRProperties::maxplanegap, caf::SRMRProperties::minplane, rb::Cluster::MinPlane(), rb::Cluster::MostContiguousPlanes(), rb::Cluster::MostMissingPlanes(), rb::Cluster::NCell(), caf::SRMRProperties::nhit, caf::SRMRProperties::nhitx, caf::SRMRProperties::nhity, caf::SRMRProperties::nplane, caf::SRMRProperties::nplanex, caf::SRMRProperties::nplaney, rb::Cluster::NXCell(), rb::Cluster::NYCell(), caf::SRMRProperties::truth, caf::SRMRProperties::truthXView, caf::SRMRProperties::truthYView, caf::SRMRProperties::view, rb::Cluster::XCells(), and rb::Cluster::YCells().

Referenced by caf::CAFMaker::produce().

  {
    srMR.isDiF        = IsTrueDiF(slice);

    srMR.nhit         = slice.NCell();
    srMR.nhitx        = slice.NXCell();
    srMR.nhity        = slice.NYCell();
    srMR.nplane       = slice.ExtentPlane();
    srMR.nplanex      = slice.ExtentPlane(geo::kX);
    srMR.nplaney      = slice.ExtentPlane(geo::kY);
    srMR.maxplanecont = slice.MostContiguousPlanes(geo::kXorY);
    srMR.maxplanegap  = slice.MostMissingPlanes(geo::kXorY);
    srMR.minplane     = slice.MinPlane(geo::kXorY);
    srMR.maxplane     = slice.MaxPlane(geo::kXorY);
    srMR.calE         = slice.CalorimetricEnergy();

    srMR.truth               = FillParticleTruth(sliceList,
                                                  slice.AllCells(),
                                                  allTracks,
                                                  sliceTracks,
                                                  allTracksBirks,
                                                  sliceTracksBirks,
                                                  sliceIdx);
    srMR.truthXView               = FillParticleTruth(sliceList,
                                                       slice.XCells(),
                                                       allTracks,
                                                       sliceTracks,
                                                       allTracksBirks,
                                                       sliceTracksBirks,
                                                       sliceIdx);
    srMR.truthYView               = FillParticleTruth(sliceList,
                                                       slice.YCells(),
                                                       allTracks,
                                                       sliceTracks,
                                                       allTracksBirks,
                                                       sliceTracksBirks,
                                                       sliceIdx);
    if      (slice.NXCell() == 0)  srMR.view = kY;
    else if (slice.NYCell() == 0)  srMR.view = kX;
    else                         srMR.view = kXorY;
  }

void caf::FillHadClustVars	(	const rb::Cluster &	hadclust,
		caf::SRHadClust &	srhadclust
	)

Definition at line 101 of file FillEnergies.cxx.

References caf::SRHadClust::boxmax, caf::SRHadClust::boxmin, caf::SRHadClust::calE, rb::Cluster::CalorimetricEnergy(), rb::CellHit::Cell(), rb::Cluster::Cell(), caf::SRHadClust::firstcell, caf::SRHadClust::firstplane, geom(), art::Ptr< T >::get(), rb::RecoHit::IsCalibrated(), geo::kX, geo::kXorY, caf::SRHadClust::lastcell, caf::SRHadClust::lastplane, calib::Calibrator::MakeRecoHit(), rb::Cluster::MaxCell(), rb::Cluster::MaxPlane(), caf::SRHadClust::meanpos, std::min(), rb::Cluster::MinCell(), rb::Cluster::MinMaxMeanXYZ(), rb::Cluster::MinPlane(), rb::Cluster::MostContiguousPlanes(), caf::SRHadClust::ncalhit, rb::Cluster::NCell(), geo::PlaneGeo::Ncells(), caf::SRHadClust::ncellsfromedge, caf::SRHadClust::ncontplanes, caf::SRHadClust::nhit, caf::SRHadClust::nmiphit, rb::Cluster::NXCell(), rb::Cluster::NYCell(), rb::RecoHit::PECorr(), rb::CellHit::Plane(), geo::GeometryBase::Plane(), caf::SRVector3D::SetX(), caf::SRVector3D::SetY(), rb::CellHit::View(), rb::Cluster::W(), rb::Cluster::XCell(), and rb::Cluster::YCell().

Referenced by FillNumuEnergyVars().

  {
    static art::ServiceHandle<calib::Calibrator> cal;
    static art::ServiceHandle<geo::Geometry> geom;

    const double wx = (hadclust.NXCell() > 0) ? hadclust.W(hadclust.XCell(0).get()) : 0;
    const double wy = (hadclust.NYCell() > 0) ? hadclust.W(hadclust.YCell(0).get()) : 0;

    // Variables needed:
    // Holds contiguous planes info:
    unsigned int  cellsFromEdge = -1;

    // Hit counters:
    int nCalHit = 0;
    int nMipHit = 0;

    unsigned int minCellsFromEdge = 99999999;

    // Loop over hadclust in question here:
    for(unsigned int hitIdx = 0; hitIdx < hadclust.NCell(); ++hitIdx)
    {
      const art::Ptr<rb::CellHit>& chit = hadclust.Cell(hitIdx);
      // Get calbrated reco hit:
      const rb::RecoHit rhit(cal->MakeRecoHit(*chit,
                                              chit->View() == geo::kX ? wx : wy));

      const int planeNum = chit->Plane();
      cellsFromEdge = std::min((unsigned int)chit->Cell(), geom->Plane(planeNum)->Ncells() - 1 - chit->Cell());

      if(cellsFromEdge < minCellsFromEdge)
      {
        minCellsFromEdge = cellsFromEdge;
      }

      // Make sure things have been calibrated:
      if(!rhit.IsCalibrated())
      {
        //        LOG_DEBUG("CAFMaker") << "Not calibrated?! "
        //        << chit->Plane() << " " << chit->Cell();
        continue;
      }

      // Count up both the total calibrated hits
      // and the MIP hits from 100-245 PECorr
      // Count up total hits:
      nCalHit++;
      // Count up MIP hits:
      if ( (rhit.PECorr()>100.0) && (rhit.PECorr()<245.0) ) nMipHit++;
    } // end of hadclust loop

    srhadclust.nhit           = hadclust.NCell();
    srhadclust.ncalhit        = nCalHit;
    srhadclust.nmiphit        = nMipHit;
    srhadclust.ncontplanes    = hadclust.MostContiguousPlanes(geo::kXorY);
    if (!(hadclust.NCell()==0)){

      srhadclust.firstplane     = hadclust.MinPlane();
      srhadclust.lastplane      = hadclust.MaxPlane();
      srhadclust.firstcell      = hadclust.MinCell(geo::kXorY);
      srhadclust.lastcell       = hadclust.MaxCell(geo::kXorY);
      srhadclust.ncellsfromedge = minCellsFromEdge;

      srhadclust.calE           = hadclust.CalorimetricEnergy();

      TVector3 boxmin, boxmax, meanpos;
      hadclust.MinMaxMeanXYZ(boxmin, boxmax, meanpos);
      srhadclust.boxmin = boxmin;
      srhadclust.