{

// Standard constructor and destructor for an ART module.

explicit TrackHitAna(fhicl::ParameterSet const& pset);

virtual ~TrackHitAna();

// This method is called once, at the start of the job. In this

// example, it will define the histograms and n-tuples we'll write.

void beginJob();

void endJob();

// This method is called once, at the start of each run. It's a

// good place to read databases or files that may have

// run-dependent information.

void beginRun(const art::Run& run);

// This method reads in any parameters from the .fcl files. This

// method is called 'reconfigure' because it might be called in the

// middle of a job; e.g., if the user changes parameter values in an

// interactive event display.

void reconfigure(fhicl::ParameterSet const& pset);

// The analysis routine, called once per event.

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

// Traverse PFParticle hierarchy

int traversePFParticleHierarchy(art::Handle<std::vector<recob::PFParticle>>&,

size_t,

const art::FindManyP<recob::Track>&,

const art::FindManyP<recob::Vertex>&,

int&,

int&) const;

// The following typedefs will, obviously, be useful

double length(const recob::Track* track);

double projectedLength(const recob::Track* track);

// The parameters we'll read from the .fcl file.

std::vector<art::InputTag> fHitProducerLabelVec;

std::vector<art::InputTag> fWireProducerLabelVec;

std::vector<art::InputTag> fPFParticleProducerLabelVec;

std::vector<art::InputTag> fTrackProducerLabelVec;

// The variables that will go into the n-tuple.

int fEvent;

int fRun;

int fSubRun;

int fNumEvents;

// Keep track of the hit histogramming tools here

std::vector<std::unique_ptr<IHitHistogramTool>> fHitHistogramToolVec;

std::vector<std::vector<double>> fChannelPedVec;

// Other variables that will be shared between different methods.

const geo::GeometryCore* fGeometry; // pointer to Geometry service

const lariov::DetPedestalProvider& fPedestalRetrievalAlg; ///< Keep track of an instance to the pedestal retrieval alg

: EDAnalyzer(parameterSet),

fPedestalRetrievalAlg(*lar::providerFrom<lariov::DetPedestalService>())

{

fGeometry = lar::providerFrom<geo::Geometry>();

// Read in the parameters from the .fcl file.

this->reconfigure(parameterSet);

{

// Get the detector length, to determine the maximum bin edge of one

// of the histograms.

//double detectorLength = fGeometry->DetLength();

// Access ART's TFileService, which will handle creating and writing

// histograms and n-tuples for us.

art::ServiceHandle<art::TFileService> tfs;

// The arguments to 'make<whatever>' are the same as those passed

// to the 'whatever' constructor, provided 'whatever' is a ROOT

// class that TFileService recognizes.

for (auto& hitHistTool : fHitHistogramToolVec) hitHistTool->initializeHists(tfs, "AllHits");

// zero out the event counter

fNumEvents = 0;

{

// How to convert from number of electrons to GeV. The ultimate

// source of this conversion factor is

// ${LARSIM_DIR}/include/SimpleTypesAndConstants/PhysicalConstants.h.

{

// Read parameters from the .fcl file. The names in the arguments

// to p.get<TYPE> must match names in the .fcl file.

fHitProducerLabelVec = p.get< std::vector<art::InputTag> >("HitModuleLabel", std::vector<art::InputTag>() = {"gauss"});

fPFParticleProducerLabelVec = p.get< std::vector<art::InputTag> >("PFParticleProducerLabel", std::vector<art::InputTag>() = {"cluster3d"});

fTrackProducerLabelVec = p.get< std::vector<art::InputTag> >("TrackProducerLabel", std::vector<art::InputTag>() = {"trackkalmanhit"});

fWireProducerLabelVec = p.get< std::vector<art::InputTag> >("WireProducerLabel", std::vector<art::InputTag>() = {"caldata"});

// Implement the tools for handling the responses

const std::vector<fhicl::ParameterSet>& hitHistogramToolVec = p.get<std::vector<fhicl::ParameterSet>>("HitHistogramToolList");

for(auto& hitHistogramTool : hitHistogramToolVec)

fHitHistogramToolVec.push_back(art::make_tool<IHitHistogramTool>(hitHistogramTool));

return;

{

// Start by fetching some basic event information for our n-tuple.

fEvent = event.id().event();

fRun = event.run();

fSubRun = event.subRun();

fNumEvents++;

for(const auto& hitLabel : fHitProducerLabelVec)

{

// Make a pass through all hits to make contrasting plots

art::Handle< std::vector<recob::Hit> > hitHandle;

event.getByLabel(hitLabel, hitHandle);

if (hitHandle.isValid())

{

IHitHistogramTool::HitPtrVec allHitVec;

art::fill_ptr_vector(allHitVec, hitHandle);

for(auto& hitHistTool : fHitHistogramToolVec) hitHistTool->fillHistograms(allHitVec);

}

}

return;

{

// Make a call to normalize histograms if so desired

for(auto& hitHistTool : fHitHistogramToolVec) hitHistTool->endJob(fNumEvents);

return;

{

double result(0.);

return result;

{

double result(0.);

return result;

size_t pfParticleIdx,

const art::FindManyP<recob::Track>& trackAssns,

const art::FindManyP<recob::Vertex>& vertexAssns,

int& nTracks,

int& nVertices) const

{

// So far no daughters...

int nDaughters(0);

return nDaughters;