Inheritance diagram for sbn::VertexStubTracker:

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

	VertexStubTracker (VertexStubTracker const &)=delete

	VertexStubTracker (VertexStubTracker &&)=delete

VertexStubTracker &	operator= (VertexStubTracker const &)=delete

VertexStubTracker &	operator= (VertexStubTracker &&)=delete

void	produce (art::Event &e) override

Private Attributes
art::InputTag	fPFPLabel

art::InputTag	fTrackLabel

art::InputTag	fVertexChargeLabel

float	fdQdxCut

float	fOneWiredQdxCut

bool	fCorrectSCE

bool	fPositionsAreSCECorrected

sbn::StubBuilder	fStubBuilder

std::vector< std::unique_ptr < sbn::IStubMerge > >	fStubMergeTools

Detailed Description

Definition at line 61 of file VertexStubTracker_module.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 90 of file VertexStubTracker_module.cc.

   : EDProducer{p},
     fPFPLabel(p.get<art::InputTag>("PFPLabel", "pandora")),
     fTrackLabel(p.get<art::InputTag>("TrackLabel", "pandoraTrack")),
     fVertexChargeLabel(p.get<art::InputTag>("VertexChargeLabel", "vhit")),
     fdQdxCut(p.get<float>("dQdxCut")),
     fOneWiredQdxCut(p.get<float>("OneWiredQdxCut")),
     fCorrectSCE(p.get<bool>("CorrectSCE")),
     fPositionsAreSCECorrected(p.get<bool>("PositionsAreSCECorrected")),
     fStubBuilder(p.get<fhicl::ParameterSet >("CaloAlg"), fPositionsAreSCECorrected)
 {
   // load the tools
   std::vector<fhicl::ParameterSet> merge_tool_configs(p.get<std::vector<fhicl::ParameterSet>>("MergeTools"));
   for (unsigned i = 0; i < merge_tool_configs.size(); i++) {
     fStubMergeTools.push_back(art::make_tool<IStubMerge>(merge_tool_configs[i]));
   }
 
   produces<std::vector<sbn::Stub>>();
   produces<art::Assns<sbn::VertexHit, sbn::Stub>>();
   produces<art::Assns<sbn::Stub, recob::Hit>>();
   produces<art::Assns<sbn::Stub, recob::Slice>>();
   produces<art::Assns<sbn::Stub, recob::PFParticle>>();
   
 }

sbn::VertexStubTracker::VertexStubTracker ( VertexStubTracker const & )

delete

sbn::VertexStubTracker::VertexStubTracker ( VertexStubTracker && )

delete

Member Function Documentation

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

delete

VertexStubTracker& sbn::VertexStubTracker::operator= ( VertexStubTracker && )

delete

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

override

Definition at line 115 of file VertexStubTracker_module.cc.

 {
   // collect services
   const geo::GeometryCore *geo = lar::providerFrom<geo::Geometry>();
   auto const clock_data = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(e);
   auto const dprop =
     art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(e, clock_data);
   const spacecharge::SpaceCharge *sce = lar::providerFrom<spacecharge::SpaceChargeService>();
   // If we are not correcting for SCE, then blank out the service
   if (!fCorrectSCE) sce = nullptr;
 
   // output data products
   std::unique_ptr<std::vector<sbn::Stub>> outStubs(new std::vector<sbn::Stub>);
   std::unique_ptr<art::Assns<sbn::VertexHit, sbn::Stub>> assn(new art::Assns<sbn::VertexHit, sbn::Stub>);
   std::unique_ptr<art::Assns<sbn::Stub, recob::Hit>> hitAssn(new art::Assns<sbn::Stub, recob::Hit>);
   std::unique_ptr<art::Assns<sbn::Stub, recob::Slice>> slcAssn(new art::Assns<sbn::Stub, recob::Slice>);
   std::unique_ptr<art::Assns<sbn::Stub, recob::PFParticle>> pfpAssn(new art::Assns<sbn::Stub, recob::PFParticle>);
 
   art::PtrMaker<sbn::Stub> StubPtrMaker {e};
 
   // input data
   art::Handle<std::vector<recob::Slice>> slice_handle;
   e.getByLabel(fPFPLabel, slice_handle);
 
   std::vector<art::Ptr<recob::Slice>> slices;
   art::fill_ptr_vector(slices, slice_handle);
 
   art::FindManyP<sbn::VertexHit> slcVHits(slices, e, fVertexChargeLabel);
 
   // Setup the stub builder
   fStubBuilder.Setup(e, fPFPLabel, fTrackLabel);
 
   for (unsigned i_slc = 0; i_slc < slices.size(); i_slc++) {
     const std::vector<art::Ptr<sbn::VertexHit>> &vhits = slcVHits.at(i_slc);
     
     // look up info per vertex hit
     art::FindManyP<recob::Vertex> vhitVtxs(vhits, e, fVertexChargeLabel);
     art::FindManyP<recob::Hit> vhitHits(vhits, e, fVertexChargeLabel);
 
     // stuff common to each vertex hit in a slice
     art::Ptr<recob::Slice> thisSlice = slices[i_slc];
   
     std::vector<sbn::StubInfo> stubs;
     for (unsigned i_vhit = 0; i_vhit < vhits.size(); i_vhit++) {
       // Collect data on this Vertex-Hit
       const sbn::VertexHit &thisVHit = *vhits[i_vhit];
       const recob::Hit &thisVHitHit = *vhitHits.at(i_vhit).at(0);
 
       bool passcut = (thisVHit.dqdx >= fdQdxCut) || ((abs(thisVHit.wire.Wire - thisVHit.vtxw) < 1.) && (thisVHit.dqdx >= fOneWiredQdxCut));
 
       if (!passcut) continue;
 
       sbn::StubInfo sinfo;
       sinfo.stub = fStubBuilder.FromVertexHit(thisSlice, thisVHit, thisVHitHit, geo, sce, clock_data, dprop, e, sinfo.hits, sinfo.pfp); 
       sinfo.vhit = vhits[i_vhit];
       sinfo.vhit_hit = vhitHits.at(i_vhit).at(0);
 
       stubs.push_back(sinfo);
 
     } // end iterate over vertex hits
 
     // Run all of the merging tools
     for (unsigned i_mrg = 0; i_mrg < fStubMergeTools.size(); i_mrg++) {
       stubs = fStubMergeTools[i_mrg]->Merge(stubs, geo, sce, clock_data, dprop);
     }
 
     // Save!
     for (unsigned i_stub = 0; i_stub < stubs.size(); i_stub++) {
       const sbn::StubInfo &sinfo = stubs[i_stub];
 
       outStubs->push_back(sinfo.stub);
       art::Ptr<sbn::Stub> outStub = StubPtrMaker(outStubs->size() - 1);
       assn->addSingle(sinfo.vhit, outStub);
       for (unsigned i_hit = 0; i_hit < sinfo.hits.size(); i_hit++) { 
         hitAssn->addSingle(outStub, sinfo.hits[i_hit]);
       }
       slcAssn->addSingle(outStub, thisSlice);
       if (sinfo.pfp) {
         pfpAssn->addSingle(outStub, sinfo.pfp);
       }
     } // end loop over stubs
 
   } // end loop over slices
   // Save into event
   e.put(std::move(outStubs));
   e.put(std::move(assn));
   e.put(std::move(hitAssn));
   e.put(std::move(slcAssn));
   e.put(std::move(pfpAssn));
 }