#include <StubBuilder.h>

Public Member Functions
void	Setup (const art::Event &e, const art::InputTag &pfplabel, const art::InputTag &trklabel)

sbn::Stub	FromVertexHit (const art::Ptr< recob::Slice > &slice, const sbn::VertexHit &vhit, const recob::Hit &vhit_hit, const geo::GeometryCore geo, const spacecharge::SpaceCharge sce, const detinfo::DetectorClocksData &dclock, const detinfo::DetectorPropertiesData &dprop, const art::Event &e, std::vector< art::Ptr< recob::Hit >> &stub_hits, art::Ptr< recob::PFParticle > &stub_pfp)

	StubBuilder (fhicl::ParameterSet const &p, bool PositionsAreSCECorrected)

Private Member Functions
double	Normalize (double dQdx, const art::Event &e, const recob::Hit &h, const geo::Point_t &location, const geo::Vector_t &direction, double t0)

Private Attributes
calo::CalorimetryAlg	fCaloAlg

bool	fPositionsAreSCECorrected

std::vector< fhicl::ParameterSet >	fNormToolConfig

std::vector< std::unique_ptr < INormalizeCharge > >	fNormTools

std::map< unsigned, std::vector< art::Ptr < recob::Hit > > >	fSliceHits

std::map< unsigned, std::vector< art::Ptr < recob::PFParticle > > >	fSlicePFPs

std::map< unsigned, std::vector< art::Ptr < recob::Track > > >	fSliceTrks

std::map< unsigned, std::vector< std::vector < art::Ptr< recob::Hit > > > >	fSlicePFPHits

std::map< unsigned, std::vector< std::vector < art::Ptr< recob::Hit > > > >	fSliceTrkHits

std::map< unsigned, std::vector< std::vector < const recob::TrackHitMeta * > > >	fSliceTrkTHMs

Detailed Description

Helper class which takes in data product information from the event and makes stub objects from hits near the vertex.

Definition at line 36 of file StubBuilder.h.

Constructor & Destructor Documentation

sbn::StubBuilder::StubBuilder	(	fhicl::ParameterSet const &	p,
		bool	PositionsAreSCECorrected
	)

inline

Definition at line 51 of file StubBuilder.h.

                                                                         : 
     fCaloAlg(p),
     fPositionsAreSCECorrected(PositionsAreSCECorrected),
     fNormToolConfig(p.get<std::vector<fhicl::ParameterSet>>("NormTools", {}))
   {
     for (const fhicl::ParameterSet &p: fNormToolConfig) {
       fNormTools.push_back(art::make_tool<INormalizeCharge>(p));
     }
   }

Member Function Documentation

sbn::Stub sbn::StubBuilder::FromVertexHit	(	const art::Ptr< recob::Slice > &	slice,
		const sbn::VertexHit &	vhit,
		const recob::Hit &	vhit_hit,
		const geo::GeometryCore *	geo,
		const spacecharge::SpaceCharge *	sce,
		const detinfo::DetectorClocksData &	dclock,
		const detinfo::DetectorPropertiesData &	dprop,
		const art::Event &	e,
		std::vector< art::Ptr< recob::Hit >> &	stub_hits,
		art::Ptr< recob::PFParticle > &	stub_pfp
	)

Definition at line 215 of file StubBuilder.cxx.

                                                                      {
     // look up stuff
     const std::vector<art::Ptr<recob::Hit>> &hits = fSliceHits.at(slice.key());
     const std::vector<art::Ptr<recob::PFParticle>> &pfps = fSlicePFPs.at(slice.key());
     const std::vector<art::Ptr<recob::Track>> &trks = fSliceTrks.at(slice.key());
     const std::vector<std::vector<art::Ptr<recob::Hit>>> &pfp_hits = fSlicePFPHits.at(slice.key());
     const std::vector<std::vector<art::Ptr<recob::Hit>>> &trk_hits = fSliceTrkHits.at(slice.key());
     const std::vector<std::vector<const recob::TrackHitMeta *>> &trk_thms = fSliceTrkTHMs.at(slice.key());
     
     stub_hits = CollectHits(hits, vhit, vhit_hit, geo, dprop);
 
     // Sort hits along the vtx -> end direction
     float vertex_w = vhit.vtxw;
     int stubdir = vertex_w <= vhit_hit.WireID().Wire ? 1 : -1;
     std::sort(stub_hits.begin(), stub_hits.end(), 
       [stubdir](auto const &lhs, auto const &rhs) {
         return lhs->WireID().Wire * stubdir < rhs->WireID().Wire * stubdir;});
 
     // Find which pfparticle to group this VertexStub with 
     int pfp_ind = FindPFPInd(stub_hits, pfps, pfp_hits);
     art::Ptr<recob::PFParticle> null; // nullptr
     stub_pfp = (pfp_ind >= 0) ? pfps[pfp_ind] : null;
 
     sbn::Stub stub;
 
     // Save all the charges
     stub.hits.emplace_back();
     for (unsigned i_hit = 0; i_hit < stub_hits.size(); i_hit++) {
       const recob::Hit &hit = *stub_hits[i_hit];
 
       sbn::StubHit stubhit; 
 
       stubhit.charge = fCaloAlg.ElectronsFromADCArea(Normalize(hit.Integral(), e, hit, 
                                                               vhit.vtxXYZ /* close enuff to hit */, 
                                                               geo::Vector_t() /* no direction available */,
                                                               0. /* TODO: add T0*/),  
                                    hit.WireID().Plane);
       stubhit.ontrack = (pfp_ind >= 0) ? HitOnTrack(stub_hits[i_hit], trks[pfp_ind], trk_hits[pfp_ind], trk_thms[pfp_ind]) : false;
       stubhit.wire = hit.WireID().Wire;
 
       stub.hits.back().push_back(stubhit);
     }
 
     // See if we can compute a track pitch
     if (pfp_ind >= 0 && trks[pfp_ind]) {
       stub.trkpitch.push_back(sbn::GetPitch(geo, sce, trks[pfp_ind]->Start(), trks[pfp_ind]->StartDirection(), geo->View(vhit_hit.WireID()), vhit_hit.WireID(), true, fPositionsAreSCECorrected));
     }
     else {
       stub.trkpitch.push_back(-1.);
     }
 
     stub.vtx = vhit.vtxXYZ;
     stub.end = vhit.spXYZ;
     stub.pitch.push_back(vhit.charge / vhit.dqdx);
     stub.plane.push_back(vhit.wire);
     stub.hit_w.push_back(vhit.wire.Wire);
     stub.vtx_w.push_back(vertex_w);
 
     // Save the EField at the start and end point
     stub.efield_vtx = sbn::GetEfield(dprop, sce, vhit.vtxXYZ, vhit_hit.WireID(), false);
     stub.efield_end = sbn::GetEfield(dprop, sce, vhit.spXYZ, vhit_hit.WireID(), false);
 
     return stub;
 }

double sbn::StubBuilder::Normalize	(	double	dQdx,
		const art::Event &	e,
		const recob::Hit &	h,
		const geo::Point_t &	location,
		const geo::Vector_t &	direction,
		double	t0
	)

private

Definition at line 193 of file StubBuilder.cxx.

                                                                                                                                                        {
     
   double ret = dQdx;
 
   // Normtools configured -- use those
   if (fNormTools.size()) {
     for (auto const &nt: fNormTools) {
       ret = nt->Normalize(ret, e, h, location, direction, t0);
     }
   }
   // Otherwise, fix using configured electron lifetime
   else {
     auto const clock_data = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(e);
     auto const dprop =
       art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(e, clock_data);
 
     ret = ret * fCaloAlg.LifetimeCorrection(clock_data, dprop, h.PeakTime(), 0.);
   }
 
   return ret;
 }

void sbn::StubBuilder::Setup	(	const art::Event &	e,
		const art::InputTag &	pfplabel,
		const art::InputTag &	trklabel
	)

Definition at line 129 of file StubBuilder.cxx.

                                                                                                       {
   // Clear out old data
   fSlicePFPHits.clear();
   fSlicePFPs.clear();
   fSliceHits.clear();
   fSliceTrkHits.clear();
   fSliceTrkTHMs.clear();
   fSliceTrks.clear();
 
   // Build the map of the slice key to the hits
   art::Handle<std::vector<recob::Slice>> slice_handle;
   e.getByLabel(pfplabel, slice_handle);
 
   std::vector<art::Ptr<recob::Slice>> slices;
   art::fill_ptr_vector(slices, slice_handle);
 
   art::FindManyP<recob::PFParticle> slicePFPs(slices, e, pfplabel);
   art::FindManyP<recob::Hit> sliceHits(slices, e, pfplabel);
 
   for (unsigned i_slc = 0; i_slc < slices.size(); i_slc++) {
     const std::vector<art::Ptr<recob::PFParticle>> thisSlicePFPs = slicePFPs.at(i_slc);
     art::FindManyP<recob::Cluster> pfparticleClusters(thisSlicePFPs, e, pfplabel);
 
     std::vector<art::Ptr<recob::Track>> thisSliceTracks;
     std::vector<std::vector<art::Ptr<recob::Hit>>> thisSlicePFPHits;
     std::vector<std::vector<art::Ptr<recob::Hit>>> thisSliceTrkHits;
     std::vector<std::vector<const recob::TrackHitMeta *>> thisSliceTrkTHMs;
 
     art::FindManyP<recob::Track> pfparticleTracks(thisSlicePFPs, e, trklabel);
     for (unsigned i_slc_pfp = 0; i_slc_pfp < thisSlicePFPs.size(); i_slc_pfp++) {
       thisSlicePFPHits.emplace_back();
       const std::vector<art::Ptr<recob::Cluster>> &thisPFPClusters = pfparticleClusters.at(i_slc_pfp);
       art::FindManyP<recob::Hit> clusterHits(thisPFPClusters, e, pfplabel);
       for (unsigned i_clus = 0; i_clus < thisPFPClusters.size(); i_clus++) {
         thisSlicePFPHits.back().insert(thisSlicePFPHits.back().end(), clusterHits.at(i_clus).begin(), clusterHits.at(i_clus).end());
       }
 
       art::FindManyP<recob::Hit, recob::TrackHitMeta> FMthisTrackHits(pfparticleTracks.at(i_slc_pfp), e, trklabel);
       if (pfparticleTracks.at(i_slc_pfp).size()) {
         const std::vector<art::Ptr<recob::Hit>> &thisTrackHits = FMthisTrackHits.at(0);
         const std::vector<const recob::TrackHitMeta *> &thisTrackTHMs = FMthisTrackHits.data(0);
         thisSliceTrkHits.push_back(thisTrackHits);
         thisSliceTrkTHMs.push_back(thisTrackTHMs);
         thisSliceTracks.push_back(pfparticleTracks.at(i_slc_pfp).at(0));
       }
       else {
         thisSliceTrkHits.emplace_back();
         thisSliceTrkTHMs.emplace_back();
         thisSliceTracks.emplace_back(); // nullptr
       }
 
     }
 
     std::size_t const sliceKey = slices[i_slc].key();
 
     fSlicePFPHits[sliceKey] = thisSlicePFPHits;
     fSliceTrkHits[sliceKey] = thisSliceTrkHits;
     fSliceTrkTHMs[sliceKey] = thisSliceTrkTHMs;
     fSliceTrks[sliceKey] = thisSliceTracks;
     fSlicePFPs[sliceKey] = thisSlicePFPs;
     fSliceHits[sliceKey] = sliceHits.at(i_slc);
   }
 }

Member Data Documentation

calo::CalorimetryAlg sbn::StubBuilder::fCaloAlg

private

Definition at line 63 of file StubBuilder.h.

std::vector<fhicl::ParameterSet> sbn::StubBuilder::fNormToolConfig

private

Definition at line 65 of file StubBuilder.h.

std::vector<std::unique_ptr<INormalizeCharge> > sbn::StubBuilder::fNormTools

private

Definition at line 66 of file StubBuilder.h.

bool sbn::StubBuilder::fPositionsAreSCECorrected

private

Definition at line 64 of file StubBuilder.h.

std::map<unsigned, std::vector<art::Ptr<recob::Hit> > > sbn::StubBuilder::fSliceHits

private

Definition at line 69 of file StubBuilder.h.

std::map<unsigned, std::vector<std::vector<art::Ptr<recob::Hit> > > > sbn::StubBuilder::fSlicePFPHits

private

Definition at line 72 of file StubBuilder.h.

std::map<unsigned, std::vector<art::Ptr<recob::PFParticle> > > sbn::StubBuilder::fSlicePFPs

private

Definition at line 70 of file StubBuilder.h.

std::map<unsigned, std::vector<std::vector<art::Ptr<recob::Hit> > > > sbn::StubBuilder::fSliceTrkHits

private

Definition at line 73 of file StubBuilder.h.

std::map<unsigned, std::vector<art::Ptr<recob::Track> > > sbn::StubBuilder::fSliceTrks

private

Definition at line 71 of file StubBuilder.h.

std::map<unsigned, std::vector<std::vector<const recob::TrackHitMeta *> > > sbn::StubBuilder::fSliceTrkTHMs

private

Definition at line 74 of file StubBuilder.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation