Inheritance diagram for sbn::VertexChargeVacuum:

Public Member Functions
	VertexChargeVacuum (fhicl::ParameterSet const &p)

	VertexChargeVacuum (VertexChargeVacuum const &)=delete

	VertexChargeVacuum (VertexChargeVacuum &&)=delete

VertexChargeVacuum &	operator= (VertexChargeVacuum const &)=delete

VertexChargeVacuum &	operator= (VertexChargeVacuum &&)=delete

void	produce (art::Event &e) override

Private Member Functions
geo::Point_t	PositionAtWires (const geo::Point_t &p, const geo::GeometryCore geo, const spacecharge::SpaceCharge sce)

geo::Point_t	PositionAbsolute (const geo::Point_t &p, const geo::GeometryCore geo, const spacecharge::SpaceCharge sce)

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
art::InputTag	fPFParticleLabel

art::InputTag	fTrackLabel

float	fHitVacuumRadius

bool	fUseTrackSPRecovery

bool	fCorrectSCE

bool	fPositionsAreSCECorrected

bool	fSelectNeutrino

std::vector< fhicl::ParameterSet >	fNormToolConfig

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

calo::CalorimetryAlg	fCaloAlg

Detailed Description

Definition at line 54 of file VertexChargeVacuum_module.cc.

Constructor & Destructor Documentation

sbn::VertexChargeVacuum::VertexChargeVacuum ( fhicl::ParameterSet const & p )

explicit

Definition at line 92 of file VertexChargeVacuum_module.cc.

   : EDProducer{p},
     fPFParticleLabel(p.get<std::string>("PFParticleLabel", "pandora")),
     fTrackLabel(p.get<std::string>("TrackLabel", "pandoraTrack")),
     fHitVacuumRadius(p.get<float>("HitVacuumRadius")),
     fUseTrackSPRecovery(p.get<bool>("UseTrackSPRecovery")),
     fCorrectSCE(p.get<bool>("CorrectSCE")),
     fPositionsAreSCECorrected(p.get<bool>("PositionsAreSCECorrected")),
     fSelectNeutrino(p.get<bool>("SelectNeutrino")),
     fNormToolConfig(p.get<std::vector<fhicl::ParameterSet>>("NormTools", {})),

sbn::VertexChargeVacuum::VertexChargeVacuum ( VertexChargeVacuum const & )

delete

sbn::VertexChargeVacuum::VertexChargeVacuum ( VertexChargeVacuum && )

delete

Member Function Documentation

double sbn::VertexChargeVacuum::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 219 of file VertexChargeVacuum_module.cc.

                                                                                                                                                               {
     
   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;
 }

VertexChargeVacuum& sbn::VertexChargeVacuum::operator= ( VertexChargeVacuum const & )

delete

VertexChargeVacuum& sbn::VertexChargeVacuum::operator= ( VertexChargeVacuum && )

delete

geo::Point_t sbn::VertexChargeVacuum::PositionAbsolute	(	const geo::Point_t &	p,
		const geo::GeometryCore *	geo,
		const spacecharge::SpaceCharge *	sce
	)

private

Definition at line 212 of file VertexChargeVacuum_module.cc.

                                                                                                                                      {
   geo::TPCID tpc = geo->FindTPCAtPosition(p);
 
   if (tpc && !fPositionsAreSCECorrected) return sbn::GetLocation(sce, p, tpc);
   return p;
 }

geo::Point_t sbn::VertexChargeVacuum::PositionAtWires	(	const geo::Point_t &	p,
		const geo::GeometryCore *	geo,
		const spacecharge::SpaceCharge *	sce
	)

private

Definition at line 205 of file VertexChargeVacuum_module.cc.

                                                                                                                                     {
   geo::TPCID tpc = geo->FindTPCAtPosition(p);
 
   if (tpc && fPositionsAreSCECorrected) return sbn::GetLocationAtWires(sce, geo, p, tpc);
   return p; 
 }

void sbn::VertexChargeVacuum::produce ( art::Event & e )

override

Definition at line 241 of file VertexChargeVacuum_module.cc.

 {
   // output stuff
   std::unique_ptr<std::vector<sbn::VertexHit>> outVHit(new std::vector<sbn::VertexHit>);
   std::unique_ptr<art::Assns<recob::Slice, sbn::VertexHit>> assn(new art::Assns<recob::Slice, sbn::VertexHit>);
   std::unique_ptr<art::Assns<recob::Vertex, sbn::VertexHit>> vtxAssn(new art::Assns<recob::Vertex, sbn::VertexHit>);
   std::unique_ptr<art::Assns<recob::Hit, sbn::VertexHit>> hitAssn(new art::Assns<recob::Hit, sbn::VertexHit>);
 
   art::PtrMaker<sbn::VertexHit> vhitPtrMaker {evt};
 
   // collect services
   const geo::GeometryCore *geo = lar::providerFrom<geo::Geometry>();
   auto const clock_data = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
   auto const dprop =
     art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt, clock_data);
   auto const* sce = lar::providerFrom<spacecharge::SpaceChargeService>();
   // If we are not correcting for SCE, then blank out the service
   if (!fCorrectSCE) sce = nullptr;
 
   // get the PFParticle's and the associated data
   art::Handle<std::vector<recob::PFParticle>> pfparticle_handle;
   evt.getByLabel(fPFParticleLabel, pfparticle_handle);
 
   std::vector<art::Ptr<recob::PFParticle>> pfparticles;
   art::fill_ptr_vector(pfparticles, pfparticle_handle);
 
   art::FindManyP<recob::Vertex> pfparticleVertices(pfparticles, evt, fPFParticleLabel);
   art::FindManyP<recob::Cluster> pfparticleClusters(pfparticles, evt, fPFParticleLabel);
   art::FindManyP<recob::Slice> pfparticleSlices(pfparticles, evt, fPFParticleLabel);
   art::FindManyP<recob::Track> pfparticleTracks(pfparticles, evt, fTrackLabel);
 
   // organize the PFPlist into a map
   std::map<unsigned, art::Ptr<recob::PFParticle>> id_to_pfp;
   for (unsigned i = 0; i < pfparticles.size(); i++) {
     id_to_pfp[pfparticles[i]->Self()] = pfparticles[i];
   }
 
   // get all the hits
   // art::Handle<std::vector<recob::Hit>> hit_handle;
   // evt.getByLabel(fHitLabel, hit_handle);
 
   // std::vector<art::Ptr<recob::Hit>> hits;
   // art::fill_ptr_vector(hits, hit_handle);
 
   // map to space-points
   // art::FindManyP<recob::SpacePoint> hitSPs(hits, evt, fPFParticleLabel);
 
   // iterate over the "primary" PFParticles
   for (unsigned i_pfp = 0; i_pfp < pfparticles.size(); i_pfp++) {
     const recob::PFParticle &pfp = *pfparticles[i_pfp];
     if (!pfp.IsPrimary()) continue;
     // Ignore PFP's with no vertex
     if (!pfparticleVertices.at(i_pfp).size()) continue;
 
     // If configured, require this to be a PFP neutrino
     unsigned pfpPDGC = std::abs(pfp.PdgCode());
     if(fSelectNeutrino &&
         (pfpPDGC != 12) && (pfpPDGC != 14) && (pfpPDGC != 16) ) continue;
 
     // we found a primary PFP! Get its vertex.
     const art::Ptr<recob::Vertex> &vtx_ptr = pfparticleVertices.at(i_pfp).at(0); 
     const recob::Vertex &vert = *vtx_ptr;
 
     // The presence of space charge creates two different positions: the position as
     // "seen" by the wires (post-space charge) and the true position (pre-space charge)
     //
     // In some cases we want the wire-position and in other we want the true-position.
     // To be explicit, create two different vertexes for these two different cases
     recob::Vertex vert_absolute(PositionAbsolute(vert.position(), geo, sce),
             vert.covariance(), 
             vert.chi2(),
             vert.ndof(),
             vert.ID());
 
     recob::Vertex vert_atwires(PositionAtWires(vert.position(), geo, sce),
             vert.covariance(), 
             vert.chi2(),
             vert.ndof(),
             vert.ID());
 
     // also get all the daughter PFParticles
     const std::vector<size_t> &daughters = pfp.Daughters();
     std::vector<art::Ptr<recob::PFParticle>> daughterPFPs;
     for (size_t d: daughters) {
       daughterPFPs.push_back(id_to_pfp.at(d));
     }
 
     // look up the hits of each daughter
     std::array<std::vector<std::vector<art::Ptr<recob::Hit>>>, 3> daughterPlaneHits;
     for (const art::Ptr<recob::PFParticle> &d: daughterPFPs) {
       for (unsigned i_plane = 0; i_plane < 3; i_plane++) {
         daughterPlaneHits[i_plane].emplace_back();
       }
       const std::vector<art::Ptr<recob::Cluster>> &d_clusters = pfparticleClusters.at(d.key());
       art::FindManyP<recob::Hit> d_cluster_hits(d_clusters, evt, fPFParticleLabel);
       for (unsigned i = 0; i < d_clusters.size(); i++) {
         const std::vector<art::Ptr<recob::Hit>> &this_cluster_hits = d_cluster_hits.at(i);
         daughterPlaneHits[d_clusters[i]->Plane().Plane].back().insert(
           daughterPlaneHits[d_clusters[i]->Plane().Plane].back().end(),
           this_cluster_hits.begin(), this_cluster_hits.end());
       }
     }
 
     // Get the Slice associated with the primary PFP
     art::Ptr<recob::Slice> thisSlc = pfparticleSlices.at(i_pfp).at(0);
     // look up the hits
     art::FindManyP<recob::Hit> thisSlcHits({thisSlc}, evt, fPFParticleLabel);
     const std::vector<art::Ptr<recob::Hit>> &hits = thisSlcHits.at(0);
 
     // work on each plane
     for (unsigned i_plane = 0; i_plane < 3; i_plane++) {
       // vacuum up all the hits within the radius
       std::vector<art::Ptr<recob::Hit>> nearbyHits;
       for (unsigned i_hit = 0; i_hit < hits.size(); i_hit++) {
         const recob::Hit &hit = *hits[i_hit];
         if (hit.WireID().Plane == i_plane) {
           if (Vert2HitDistance(hit, vert_atwires, geo, dprop) < fHitVacuumRadius) {
             nearbyHits.push_back(hits[i_hit]);
           }
         }
       }
 
       // and find the hit SP's
       art::FindManyP<recob::SpacePoint> hitSPs(nearbyHits, evt, fPFParticleLabel);
 
       // Compute all needed information for each hit
       for (unsigned i_hit = 0; i_hit < nearbyHits.size(); i_hit++) {
         const recob::Hit &hit = *nearbyHits[i_hit];
 
         sbn::VertexHit vhit;
         vhit.wire = hit.WireID();
         vhit.proj_dist_to_vertex = Vert2HitDistance(hit, vert_atwires, geo, dprop);
         vhit.vtxw = geo->WireCoordinate(vert_atwires.position(), hit.WireID());
         vhit.vtxx = vert_atwires.position().x();
         vhit.vtxXYZ = vert_absolute.position();
 
         // Compute the charge, using everything we have
         vhit.charge = fCaloAlg.ElectronsFromADCArea(Normalize(hit.Integral(), evt, hit, 
                                                               vert_absolute.position() /* close enuff to hit */, 
                                                               geo::Vector_t() /* no direction available */,
                                                               0. /* TODO: add T0*/),  
                                    hit.WireID().Plane);
 
 
         // lookup the spacepoint location
         const std::vector<art::Ptr<recob::SpacePoint>> &hit_sp = hitSPs.at(i_hit);
 
         bool has_xyz = false;
         int spID = -1;
         geo::Point_t spXYZ;
         // Space-Point!
         if (hit_sp.size()) {
           const recob::SpacePoint sp = *hit_sp.at(0);
           spID = sp.ID();
           spXYZ = PositionAbsolute(sp.position(), geo, sce);
           has_xyz = true;
         }
         // No Space-Point. If configured, see if we can look up a point along the assigned track
         else if (fUseTrackSPRecovery) {
           unsigned plane = hit.WireID().Plane;
           art::Ptr<recob::PFParticle> matchingPFP;
           for (unsigned i_pfp_chk = 0; i_pfp_chk < daughterPlaneHits[plane].size(); i_pfp_chk++) {
             for (unsigned i_hit_chk = 0; i_hit_chk < daughterPlaneHits[plane][i_pfp_chk].size(); i_hit_chk++) {
               if (daughterPlaneHits[plane][i_pfp_chk][i_hit_chk] == nearbyHits[i_hit]) {
                 matchingPFP = daughterPFPs[i_pfp_chk];
                 break;
               }
             }
           }
           if (matchingPFP) {
             const std::vector<art::Ptr<recob::Track>> &pfptrack = pfparticleTracks.at(matchingPFP.key()); 
             if (pfptrack.size()) {
               const recob::Track &thisTrack = *pfptrack.at(0);
               spXYZ = PositionAbsolute(PlaceHitAlongTrack(thisTrack, vert_atwires, hit, geo, dprop), geo, sce); 
               has_xyz = true;
             }
           }
         }
 
         if (has_xyz) {
           vhit.spID = spID;
           vhit.spXYZ = spXYZ;
 
           geo::Vector_t dir = (spXYZ - vert_absolute.position()).Unit();
 
           // Compute the pitch. Since we have used the corrected vertex and Space-Point position, the
           // pt and dir here are space-charge corrected regardless of the input configuration
           vhit.pitch = sbn::GetPitch(geo, sce, spXYZ, dir, hit.View(), hit.WireID(), fCorrectSCE, true); 
 
           vhit.dqdx = vhit.charge / vhit.pitch;
 
           // Same here -- input position is already corrected
           float EField = sbn::GetEfield(dprop, sce, spXYZ, hit.WireID(), false);
 
           vhit.dedx = fCaloAlg.dEdx_AREA(clock_data, dprop, vhit.dqdx, hit.PeakTime(), hit.WireID().Plane, 0., EField);
         }
         else {
           vhit.spID = -1;
           vhit.pitch = -1;
           vhit.dqdx = -1;
           vhit.dedx = -1;
         }
 
         // Save!
         outVHit->push_back(vhit);
         art::Ptr<sbn::VertexHit> thisVHitPtr = vhitPtrMaker(outVHit->size()-1);
         assn->addSingle(thisSlc, thisVHitPtr);
         vtxAssn->addSingle(vtx_ptr, thisVHitPtr);
         hitAssn->addSingle(nearbyHits[i_hit], thisVHitPtr);
 
       } // end iterate over hits
     } // end iterate over planes
   } // end iterate over pfparticle's 
 
   evt.put(std::move(outVHit));
   evt.put(std::move(vtxAssn));
   evt.put(std::move(assn));
   evt.put(std::move(hitAssn));
 
 }