Inheritance diagram for reco3d::SpacePointSolver:

Public Types
using	ModuleType = EDProducer

template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Member Functions
	SpacePointSolver (const fhicl::ParameterSet &pset)

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

void	fillProductDescriptions ()

void	registerProducts (ProductDescriptions &productsToRegister)

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

std::unique_ptr< Worker >	makeWorker (WorkerParams const &wp)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Protected Member Functions
ConsumesCollector &	consumesCollector ()

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Private Types
typedef std::map< const WireHit , const recob::Hit >	HitMap_t

Private Member Functions
void	produce (art::Event &evt) override

void	beginJob () override

void	AddNeighbours (const std::vector< SpaceCharge * > &spaceCharges) const

void	BuildSystem (const std::vector< HitTriplet > &triplets, std::vector< CollectionWireHit * > &cwires, std::vector< InductionWireHit * > &iwires, std::vector< SpaceCharge * > &orphanSCs, bool incNei, HitMap_t &hitmap) const

void	Minimize (const std::vector< CollectionWireHit * > &cwires, const std::vector< SpaceCharge * > &orphanSCs, double alpha, int maxiterations)

bool	AddSpacePoint (const SpaceCharge &sc, int id, recob::ChargedSpacePointCollectionCreator &points) const
	return whether the point was inserted (only happens when it has charge) More...

void	FillSystemToSpacePoints (const std::vector< CollectionWireHit * > &cwires, const std::vector< SpaceCharge * > &orphanSCs, recob::ChargedSpacePointCollectionCreator &pts) const

void	FillSystemToSpacePointsAndAssns (const std::vector< art::Ptr< recob::Hit >> &hitlist, const std::vector< CollectionWireHit * > &cwires, const std::vector< SpaceCharge * > &orphanSCs, const HitMap_t &hitmap, recob::ChargedSpacePointCollectionCreator &points, art::Assns< recob::SpacePoint, recob::Hit > &assn) const

Private Attributes
std::string	fHitLabel

bool	fFit

bool	fAllowBadInductionHit

bool	fAllowBadCollectionHit

double	fAlpha

double	fDistThresh

double	fDistThreshDrift

int	fMaxIterationsNoReg

int	fMaxIterationsReg

double	fXHitOffset

const geo::GeometryCore *	geom

std::unique_ptr< reco3d::IHitReader >	fHitReader
	Expt specific tool for reading hits. More...

unsigned int	fMinNHits

unsigned int	fMaxNTriplets

Detailed Description

Definition at line 49 of file SpacePointSolver_module.cc.

Member Typedef Documentation

typedef std::map<const WireHit*, const recob::Hit*> reco3d::SpacePointSolver::HitMap_t

private

Definition at line 59 of file SpacePointSolver_module.cc.

using art::EDProducer::ModuleType = EDProducer

inherited

Definition at line 17 of file EDProducer.h.

template<typename UserConfig , typename KeysToIgnore = void>

using art::detail::Producer::Table = Modifier::Table<UserConfig, KeysToIgnore>

inherited

Definition at line 26 of file Producer.h.

Constructor & Destructor Documentation

reco3d::SpacePointSolver::SpacePointSolver ( const fhicl::ParameterSet & pset )

explicit

Definition at line 114 of file SpacePointSolver_module.cc.

References recob::ChargedSpacePointCollectionCreator::produces().

     : EDProducer{pset}
     , fHitLabel(pset.get<std::string>("HitLabel"))
     , fFit(pset.get<bool>("Fit"))
     , fAllowBadInductionHit(pset.get<bool>("AllowBadInductionHit"))
     , fAllowBadCollectionHit(pset.get<bool>("AllowBadCollectionHit"))
     , fAlpha(pset.get<double>("Alpha"))
     , fDistThresh(pset.get<double>("WireIntersectThreshold"))
     , fDistThreshDrift(pset.get<double>("WireIntersectThresholdDriftDir"))
     , fMaxIterationsNoReg(pset.get<int>("MaxIterationsNoReg"))
     , fMaxIterationsReg(pset.get<int>("MaxIterationsReg"))
     , fXHitOffset(pset.get<double>("XHitOffset"))
     , fMinNHits(pset.get<unsigned int>("MinNHits"))
     , fMaxNTriplets(pset.get<unsigned int>("MaxNTriplets"))
   {
     recob::ChargedSpacePointCollectionCreator::produces(producesCollector(), "pre");
     if (fFit) {
       recob::ChargedSpacePointCollectionCreator::produces(producesCollector());
       produces<art::Assns<recob::SpacePoint, recob::Hit>>();
       recob::ChargedSpacePointCollectionCreator::produces(producesCollector(), "noreg");
     }
 
     fHitReader = art::make_tool<reco3d::IHitReader>(pset.get<fhicl::ParameterSet>("HitReaderTool"));
   }

Member Function Documentation

void reco3d::SpacePointSolver::AddNeighbours ( const std::vector< SpaceCharge * > & spaceCharges ) const

private

Definition at line 146 of file SpacePointSolver_module.cc.

References Neighbour::fCoupling, SpaceCharge::fPred, Neighbour::fSC, SpaceCharge::fX, SpaceCharge::fY, SpaceCharge::fZ, reco3d::InductionWireWithXPos::operator<(), sc, x, y, and z.

   {
     static const double kCritDist = 5;
 
     // Could use a QuadTree or VPTree etc, but seems like overkill
     class IntCoord {
     public:
       IntCoord(const SpaceCharge& sc)
         : fX(sc.fX / kCritDist), fY(sc.fY / kCritDist), fZ(sc.fZ / kCritDist)
       {}
 
       bool operator<(const IntCoord& i) const
       {
         return std::make_tuple(fX, fY, fZ) < std::make_tuple(i.fX, i.fY, i.fZ);
       }
 
       std::vector<IntCoord> Neighbours() const
       {
         std::vector<IntCoord> ret;
         for (int dx = -1; dx <= +1; ++dx) {
           for (int dy = -1; dy <= +1; ++dy) {
             for (int dz = -1; dz <= +1; ++dz) {
               ret.push_back(IntCoord(fX + dx, fY + dy, fZ + dz));
             }
           }
         }
         return ret;
       }
 
     protected:
       IntCoord(int x, int y, int z) : fX(x), fY(y), fZ(z) {}
 
       int fX, fY, fZ;
     };
 
     std::map<IntCoord, std::vector<SpaceCharge*>> scMap;
     for (SpaceCharge* sc : spaceCharges) {
       scMap[IntCoord(*sc)].push_back(sc);
     }
 
     std::cout << "Neighbour search..." << std::endl;
 
     // Now that we know all the space charges, can go through and assign neighbours
 
     int Ntests = 0;
     int Nnei = 0;
     for (SpaceCharge* sc1 : spaceCharges) {
       IntCoord ic(*sc1);
       for (IntCoord icn : ic.Neighbours()) {
         for (SpaceCharge* sc2 : scMap[icn]) {
 
           ++Ntests;
 
           if (sc1 == sc2) continue;
           double dist2 =
             cet::sum_of_squares(sc1->fX - sc2->fX, sc1->fY - sc2->fY, sc1->fZ - sc2->fZ);
 
           if (dist2 > cet::square(kCritDist)) continue;
 
           if (dist2 == 0) {
             std::cout << "ZERO DISTANCE SOMEHOW?" << std::endl;
             std::cout << sc1->fCWire << " " << sc1->fWire1 << " " << sc1->fWire2 << std::endl;
             std::cout << sc2->fCWire << " " << sc2->fWire1 << " " << sc2->fWire2 << std::endl;
             std::cout << dist2 << " " << sc1->fX << " " << sc2->fX << " " << sc1->fY << " "
                       << sc2->fY << " " << sc1->fZ << " " << sc2->fZ << std::endl;
             continue;
             dist2 = cet::square(kCritDist);
           }
 
           ++Nnei;
 
           // This is a pretty random guess
           const double coupling = exp(-sqrt(dist2) / 2);
           sc1->fNeighbours.emplace_back(sc2, coupling);
 
           if (std::isnan(1 / sqrt(dist2)) || std::isinf(1 / sqrt(dist2))) {
             std::cout << dist2 << " " << sc1->fX << " " << sc2->fX << " " << sc1->fY << " "
                       << sc2->fY << " " << sc1->fZ << " " << sc2->fZ << std::endl;
             abort();
           }
         } // end for sc2
       }   // end for icn
 
       // The neighbours lists use the most memory, so be careful to trim
       sc1->fNeighbours.shrink_to_fit();
     } // end for sc1
 
     for (SpaceCharge* sc : spaceCharges) {
       for (Neighbour& nei : sc->fNeighbours) {
         sc->fNeiPotential += nei.fCoupling * nei.fSC->fPred;
       }
     }
 
     std::cout << Ntests << " tests to find " << Nnei << " neighbours" << std::endl;
   }

bool reco3d::SpacePointSolver::AddSpacePoint	(	const SpaceCharge &	sc,
		int	id,
		recob::ChargedSpacePointCollectionCreator &	points
	)		const

private

return whether the point was inserted (only happens when it has charge)

Definition at line 333 of file SpacePointSolver_module.cc.

References recob::ChargedSpacePointCollectionCreator::add(), SpaceCharge::fPred, SpaceCharge::fX, SpaceCharge::fY, and SpaceCharge::fZ.

   {
     static const double err[6] = {
       0,
     };
 
     const float charge = sc.fPred;
     if (charge == 0) return false;
 
     const double xyz[3] = {sc.fX, sc.fY, sc.fZ};
     points.add({xyz, err, 0.0, id}, charge);
 
     return true;
   }

void reco3d::SpacePointSolver::beginJob ( )

overrideprivatevirtual

Reimplemented from art::EDProducer.

Definition at line 140 of file SpacePointSolver_module.cc.

   {
     geom = art::ServiceHandle<geo::Geometry const>()->provider();
   }

void reco3d::SpacePointSolver::BuildSystem	(	const std::vector< HitTriplet > &	triplets,
		std::vector< CollectionWireHit * > &	cwires,
		std::vector< InductionWireHit * > &	iwires,
		std::vector< SpaceCharge * > &	orphanSCs,
		bool	incNei,
		HitMap_t &	hitmap
	)		const

private

Definition at line 243 of file SpacePointSolver_module.cc.

References reco3d::InductionWireWithXPos::iwire, and sc.

   {
     std::set<const recob::Hit*> ihits;
     std::set<const recob::Hit*> chits;
     for (const HitTriplet& trip : triplets) {
       if (trip.x) chits.insert(trip.x);
       if (trip.u) ihits.insert(trip.u);
       if (trip.v) ihits.insert(trip.v);
     }
 
     std::map<const recob::Hit*, InductionWireHit*> inductionMap;
     for (const recob::Hit* hit : ihits) {
       InductionWireHit* iwire = new InductionWireHit(hit->Channel(), hit->Integral());
       inductionMap[hit] = iwire;
       iwires.emplace_back(iwire);
       hitmap[iwire] = hit;
     }
 
     std::map<const recob::Hit*, std::vector<SpaceCharge*>> collectionMap;
     std::map<const recob::Hit*, std::vector<SpaceCharge*>> collectionMapBad;
 
     std::set<InductionWireHit*> satisfiedInduction;
 
     for (const HitTriplet& trip : triplets) {
       // Don't have a cwire object yet, set it later
       SpaceCharge* sc = new SpaceCharge(
         trip.pt.x, trip.pt.y, trip.pt.z, 0, inductionMap[trip.u], inductionMap[trip.v]);
 
       if (trip.u && trip.v) {
         collectionMap[trip.x].push_back(sc);
         if (trip.x) {
           satisfiedInduction.insert(inductionMap[trip.u]);
           satisfiedInduction.insert(inductionMap[trip.v]);
         }
       }
       else {
         collectionMapBad[trip.x].push_back(sc);
       }
     }
 
     std::vector<SpaceCharge*> spaceCharges;
 
     for (const recob::Hit* hit : chits) {
       // Find the space charges associated with this hit
       std::vector<SpaceCharge*>& scs = collectionMap[hit];
       if (scs.empty()) {
         // If there are no full triplets try the triplets with one bad channel
         scs = collectionMapBad[hit];
       }
       else {
         // If there were good triplets, delete the bad hit ones
         for (SpaceCharge* sc : collectionMapBad[hit])
           delete sc;
       }
       // Still no space points, don't bother making a wire
       if (scs.empty()) continue;
 
       CollectionWireHit* cwire = new CollectionWireHit(hit->Channel(), hit->Integral(), scs);
       hitmap[cwire] = hit;
       cwires.push_back(cwire);
       spaceCharges.insert(spaceCharges.end(), scs.begin(), scs.end());
       for (SpaceCharge* sc : scs)
         sc->fCWire = cwire;
     } // end for hit
 
     // Space charges whose collection wire is bad, which we have no other way of
     // addressing.
     for (SpaceCharge* sc : collectionMap[0]) {
       // Only count orphans where an induction wire has no other explanation
       if (satisfiedInduction.count(sc->fWire1) == 0 || satisfiedInduction.count(sc->fWire2) == 0) {
         orphanSCs.push_back(sc);
       }
       else {
         delete sc;
       }
     }
     spaceCharges.insert(spaceCharges.end(), orphanSCs.begin(), orphanSCs.end());
 
     std::cout << cwires.size() << " collection wire objects" << std::endl;
     std::cout << spaceCharges.size() << " potential space points" << std::endl;
 
     if (incNei) AddNeighbours(spaceCharges);
   }

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::consumes ( InputTag const & tag )

protectedinherited

Definition at line 61 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumes().

   {
     return collector_.consumes<T, BT>(tag);
   }

ConsumesCollector & art::ModuleBase::consumesCollector ( )

protectedinherited

Definition at line 57 of file ModuleBase.cc.

References art::ModuleBase::collector_.

   {
     return collector_;
   }

template<typename T , BranchType BT>

void art::ModuleBase::consumesMany ( )

protectedinherited

Definition at line 75 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesMany().

   {
     collector_.consumesMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::consumesView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::consumesView ( InputTag const & tag )

inherited

Definition at line 68 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesView().

   {
     return collector_.consumesView<T, BT>(tag);
   }

void art::detail::Producer::doBeginJob ( SharedResources const & resources )

inherited

Definition at line 22 of file Producer.cc.

References art::detail::Producer::beginJobWithFrame(), and art::detail::Producer::setupQueues().

   {
     setupQueues(resources);
     ProcessingFrame const frame{ScheduleID{}};
     beginJobWithFrame(frame);
   }

bool art::detail::Producer::doBeginRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 65 of file Producer.cc.

References art::detail::Producer::beginRunWithFrame(), art::RangeSet::forRun(), art::RunPrincipal::makeRun(), r, art::RunPrincipal::runID(), and art::ModuleContext::scheduleID().

   {
     auto r = rp.makeRun(mc, RangeSet::forRun(rp.runID()));
     ProcessingFrame const frame{mc.scheduleID()};
     beginRunWithFrame(r, frame);
     r.commitProducts();
     return true;
   }

bool art::detail::Producer::doBeginSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 85 of file Producer.cc.

References art::detail::Producer::beginSubRunWithFrame(), art::RangeSet::forSubRun(), art::SubRunPrincipal::makeSubRun(), art::ModuleContext::scheduleID(), and art::SubRunPrincipal::subRunID().

   {
     auto sr = srp.makeSubRun(mc, RangeSet::forSubRun(srp.subRunID()));
     ProcessingFrame const frame{mc.scheduleID()};
     beginSubRunWithFrame(sr, frame);
     sr.commitProducts();
     return true;
   }

void art::detail::Producer::doEndJob ( )

inherited

Definition at line 30 of file Producer.cc.

References art::detail::Producer::endJobWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     endJobWithFrame(frame);
   }

bool art::detail::Producer::doEndRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 75 of file Producer.cc.

References art::detail::Producer::endRunWithFrame(), art::RunPrincipal::makeRun(), r, art::ModuleContext::scheduleID(), and art::Principal::seenRanges().

   {
     auto r = rp.makeRun(mc, rp.seenRanges());
     ProcessingFrame const frame{mc.scheduleID()};
     endRunWithFrame(r, frame);
     r.commitProducts();
     return true;
   }

bool art::detail::Producer::doEndSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 95 of file Producer.cc.

References art::detail::Producer::endSubRunWithFrame(), art::SubRunPrincipal::makeSubRun(), art::ModuleContext::scheduleID(), and art::Principal::seenRanges().

   {
     auto sr = srp.makeSubRun(mc, srp.seenRanges());
     ProcessingFrame const frame{mc.scheduleID()};
     endSubRunWithFrame(sr, frame);
     sr.commitProducts();
     return true;
   }

bool art::detail::Producer::doEvent	(	EventPrincipal &	ep,
		ModuleContext const &	mc,
		std::atomic< std::size_t > &	counts_run,
		std::atomic< std::size_t > &	counts_passed,
		std::atomic< std::size_t > &	counts_failed
	)

inherited

Definition at line 105 of file Producer.cc.

References art::detail::Producer::checkPutProducts_, e, art::EventPrincipal::makeEvent(), art::detail::Producer::produceWithFrame(), and art::ModuleContext::scheduleID().

   {
     auto e = ep.makeEvent(mc);
     ++counts_run;
     ProcessingFrame const frame{mc.scheduleID()};
     produceWithFrame(e, frame);
     e.commitProducts(checkPutProducts_, &expectedProducts<InEvent>());
     ++counts_passed;
     return true;
   }

void art::detail::Producer::doRespondToCloseInputFile ( FileBlock const & fb )

inherited

Definition at line 44 of file Producer.cc.

References art::detail::Producer::respondToCloseInputFileWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseInputFileWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToCloseOutputFiles ( FileBlock const & fb )

inherited

Definition at line 58 of file Producer.cc.

References art::detail::Producer::respondToCloseOutputFilesWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseOutputFilesWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToOpenInputFile ( FileBlock const & fb )

inherited

Definition at line 37 of file Producer.cc.

References art::detail::Producer::respondToOpenInputFileWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenInputFileWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToOpenOutputFiles ( FileBlock const & fb )

inherited

Definition at line 51 of file Producer.cc.

References art::detail::Producer::respondToOpenOutputFilesWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenOutputFilesWithFrame(fb, frame);
   }

void art::Modifier::fillProductDescriptions ( )

inherited

Definition at line 10 of file Modifier.cc.

References art::ProductRegistryHelper::fillDescriptions(), and art::ModuleBase::moduleDescription().

   {
     ProductRegistryHelper::fillDescriptions(moduleDescription());
   }

void reco3d::SpacePointSolver::FillSystemToSpacePoints	(	const std::vector< CollectionWireHit * > &	cwires,
		const std::vector< SpaceCharge * > &	orphanSCs,
		recob::ChargedSpacePointCollectionCreator &	pts
	)		const

private

Definition at line 351 of file SpacePointSolver_module.cc.

References sc.

   {
     int iPoint = 0;
     for (const CollectionWireHit* cwire : cwires) {
       for (const SpaceCharge* sc : cwire->fCrossings) {
         AddSpacePoint(*sc, iPoint++, points);
       } // for sc
     }   // for cwire
 
     for (const SpaceCharge* sc : orphanSCs)
       AddSpacePoint(*sc, iPoint++, points);
   }

void reco3d::SpacePointSolver::FillSystemToSpacePointsAndAssns	(	const std::vector< art::Ptr< recob::Hit >> &	hitlist,
		const std::vector< CollectionWireHit * > &	cwires,
		const std::vector< SpaceCharge * > &	orphanSCs,
		const HitMap_t &	hitmap,
		recob::ChargedSpacePointCollectionCreator &	points,
		art::Assns< recob::SpacePoint, recob::Hit > &	assn
	)		const

private

Definition at line 368 of file SpacePointSolver_module.cc.

References art::Assns< L, R, D >::addSingle(), SpaceCharge::fCWire, SpaceCharge::fWire1, SpaceCharge::fWire2, recob::ChargedSpacePointCollectionCreator::lastSpacePointPtr(), and sc.

   {
     std::map<const recob::Hit*, art::Ptr<recob::Hit>> ptrmap;
     for (art::Ptr<recob::Hit> hit : hitlist)
       ptrmap[hit.get()] = hit;
 
     std::vector<const SpaceCharge*> scs;
     for (const SpaceCharge* sc : orphanSCs)
       scs.push_back(sc);
     for (const CollectionWireHit* cwire : cwires)
       for (const SpaceCharge* sc : cwire->fCrossings)
         scs.push_back(sc);
 
     int iPoint = 0;
 
     for (const SpaceCharge* sc : scs) {
       if (!AddSpacePoint(*sc, iPoint++, points)) continue;
       const auto& spsPtr = points.lastSpacePointPtr();
 
       if (sc->fCWire) { assn.addSingle(spsPtr, ptrmap[hitmap.at(sc->fCWire)]); }
       if (sc->fWire1) { assn.addSingle(spsPtr, ptrmap[hitmap.at(sc->fWire1)]); }
       if (sc->fWire2) { assn.addSingle(spsPtr, ptrmap[hitmap.at(sc->fWire2)]); }
     }
   }

std::array< std::vector< ProductInfo >, NumBranchTypes > const & art::ModuleBase::getConsumables ( ) const

inherited

Definition at line 43 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::getConsumables().

   {
     return collector_.getConsumables();
   }

std::unique_ptr< Worker > art::ModuleBase::makeWorker ( WorkerParams const & wp )

inherited

Definition at line 37 of file ModuleBase.cc.

References art::ModuleBase::doMakeWorker(), and art::NumBranchTypes.

   {
     return doMakeWorker(wp);
   }

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::mayConsume ( InputTag const & tag )

protectedinherited

Definition at line 82 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsume().

   {
     return collector_.mayConsume<T, BT>(tag);
   }

template<typename T , BranchType BT>

void art::ModuleBase::mayConsumeMany ( )

protectedinherited

Definition at line 96 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeMany().

   {
     collector_.mayConsumeMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::mayConsumeView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::mayConsumeView ( InputTag const & tag )

inherited

Definition at line 89 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeView().

   {
     return collector_.mayConsumeView<T, BT>(tag);
   }

void reco3d::SpacePointSolver::Minimize	(	const std::vector< CollectionWireHit * > &	cwires,
		const std::vector< SpaceCharge * > &	orphanSCs,
		double	alpha,
		int	maxiterations
	)

private

Definition at line 400 of file SpacePointSolver_module.cc.

References e, Iterate(), and Metric().

   {
     double prevMetric = Metric(cwires, alpha);
     std::cout << "Begin: " << prevMetric << std::endl;
     for (int i = 0; i < maxiterations; ++i) {
       Iterate(cwires, orphanSCs, alpha);
       const double metric = Metric(cwires, alpha);
       std::cout << i << " " << metric << std::endl;
       if (metric > prevMetric) {
         std::cout << "Warning: metric increased" << std::endl;
         return;
       }
       if (fabs(metric - prevMetric) < 1e-3 * fabs(prevMetric)) return;
       prevMetric = metric;
     }
   }

ModuleDescription const & art::ModuleBase::moduleDescription ( ) const

inherited

Definition at line 13 of file ModuleBase.cc.

References art::errors::LogicError.

Referenced by art::OutputModule::doRespondToOpenInputFile(), art::OutputModule::doWriteEvent(), art::Modifier::fillProductDescriptions(), art::OutputModule::makePlugins_(), art::OutputWorker::OutputWorker(), reco::shower::LArPandoraModularShowerCreation::produce(), art::Modifier::registerProducts(), and art::OutputModule::registerProducts().

   {
     if (md_.has_value()) {
       return *md_;
     }
 
     throw Exception{errors::LogicError,
                     "There was an error while calling moduleDescription().\n"}
       << "The moduleDescription() base-class member function cannot be called\n"
          "during module construction.  To determine which module is "
          "responsible\n"
          "for calling it, find the '<module type>:<module "
          "label>@Construction'\n"
          "tag in the message prefix above.  Please contact artists@fnal.gov\n"
          "for guidance.\n";
   }

void reco3d::SpacePointSolver::produce ( art::Event & evt )

overrideprivatevirtual

Implements art::EDProducer.

Definition at line 421 of file SpacePointSolver_module.cc.

References art::fill_ptr_vector(), recob::ChargedSpacePointCollectionCreator::forPtrs(), art::ProductRetriever::getByLabel(), hits(), geo::kCollection, geo::kU, geo::kV, geo::kZ, art::Event::put(), geo::GeometryCore::SignalType(), reco3d::TripletFinder::Triplets(), and geo::GeometryCore::View().

   {
     art::Handle<std::vector<recob::Hit>> hits;
     std::vector<art::Ptr<recob::Hit>> hitlist;
     if (evt.getByLabel(fHitLabel, hits)) art::fill_ptr_vector(hitlist, hits);
 
     auto spcol_pre = recob::ChargedSpacePointCollectionCreator::forPtrs(evt, "pre");
     auto spcol_noreg = recob::ChargedSpacePointCollectionCreator::forPtrs(evt, "noreg");
     auto spcol = recob::ChargedSpacePointCollectionCreator::forPtrs(evt);
     auto assns = std::make_unique<art::Assns<recob::SpacePoint, recob::Hit>>();
 
     auto putemptycols = [&]() {
       spcol_pre.put();
       if (fFit) {
         spcol.put();
         evt.put(std::move(assns));
         spcol_noreg.put();
       }
     };
 
     // Skip very small events
     if (hits->size() < fMinNHits) {
       putemptycols();
       return;
     }
 
     art::ServiceHandle<geo::Geometry const> geom;
 
     std::vector<art::Ptr<recob::Hit>> xhits, uhits, vhits;
     bool is2view = fHitReader->readHits(hitlist, xhits, uhits, vhits);
 
     std::vector<raw::ChannelID_t> xbadchans, ubadchans, vbadchans;
     if (fAllowBadInductionHit || fAllowBadCollectionHit) {
       for (raw::ChannelID_t cid :
            art::ServiceHandle<lariov::ChannelStatusService const>()->GetProvider().BadChannels()) {
         if (geom->SignalType(cid) == geo::kCollection) {
           if (fAllowBadCollectionHit && geom->View(cid) == geo::kZ) { xbadchans.push_back(cid); }
         }
         else {
           if (fAllowBadInductionHit) {
             if (geom->View(cid) == geo::kU) ubadchans.push_back(cid);
             if (geom->View(cid) == geo::kV) vbadchans.push_back(cid);
           }
         }
       }
     }
     std::cout << xbadchans.size() << " X, " << ubadchans.size() << " U, " << vbadchans.size()
               << " V bad channels" << std::endl;
 
     std::vector<CollectionWireHit*> cwires;
     // So we can find them all to free the memory
     std::vector<InductionWireHit*> iwires;
     // Nodes with a bad collection wire that we otherwise can't address
     std::vector<SpaceCharge*> orphanSCs;
 
     auto const detProp =
       art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt);
 
     HitMap_t hitmap;
     if (is2view) {
       std::cout << "Finding 2-view coincidences..." << std::endl;
       TripletFinder tf(detProp,
                        xhits,
                        uhits,
                        {},
                        xbadchans,
                        ubadchans,
                        {},
                        fDistThresh,
                        fDistThreshDrift,
                        fXHitOffset);
       auto triplets = tf.TripletsTwoView();
       if (fMaxNTriplets > 0 && triplets.size() > fMaxNTriplets) {
         std::cout << "Huge Triplet Size, bailing out" << std::endl;
         putemptycols();
         return;
       }
       BuildSystem(triplets, cwires, iwires, orphanSCs, fAlpha != 0, hitmap);
     }
     else {
       std::cout << "Finding XUV coincidences..." << std::endl;
       TripletFinder tf(detProp,
                        xhits,
                        uhits,
                        vhits,
                        xbadchans,
                        ubadchans,
                        vbadchans,
                        fDistThresh,
                        fDistThreshDrift,
                        fXHitOffset);
       auto triplets = tf.Triplets();
       if (fMaxNTriplets > 0 && triplets.size() > fMaxNTriplets) {
         std::cout << "Huge Triplet Size, bailing out" << std::endl;
         putemptycols();
         return;
       }
       BuildSystem(triplets, cwires, iwires, orphanSCs, fAlpha != 0, hitmap);
     }
 
     FillSystemToSpacePoints(cwires, orphanSCs, spcol_pre);
     spcol_pre.put();
 
     if (fFit) {
       std::cout << "Iterating with no regularization..." << std::endl;
       Minimize(cwires, orphanSCs, 0, fMaxIterationsNoReg);
 
       FillSystemToSpacePoints(cwires, orphanSCs, spcol_noreg);
       spcol_noreg.put();
 
       std::cout << "Now with regularization..." << std::endl;
       Minimize(cwires, orphanSCs, fAlpha, fMaxIterationsReg);
 
       FillSystemToSpacePointsAndAssns(hitlist, cwires, orphanSCs, hitmap, spcol, *assns);
       spcol.put();
       evt.put(std::move(assns));
     } // end if fFit
 
     for (InductionWireHit* i : iwires)
       delete i;
     for (CollectionWireHit* c : cwires)
       delete c;
     for (SpaceCharge* s : orphanSCs)
       delete s;
   }

void art::Modifier::registerProducts ( ProductDescriptions & productsToRegister )

inherited

Definition at line 16 of file Modifier.cc.

References art::ModuleBase::moduleDescription(), and art::ProductRegistryHelper::registerProducts().

   {
     ProductRegistryHelper::registerProducts(productsToRegister,
                                             moduleDescription());
   }

void art::ModuleBase::setModuleDescription ( ModuleDescription const & md )

inherited

Definition at line 31 of file ModuleBase.cc.

References art::ModuleBase::md_.

   {
     md_ = md;
   }

void art::ModuleBase::sortConsumables ( std::string const & current_process_name )

inherited

Definition at line 49 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::sortConsumables().

   {
     // Now that we know we have seen all the consumes declarations,
     // sort the results for fast lookup later.
     collector_.sortConsumables(current_process_name);
   }

Member Data Documentation

bool reco3d::SpacePointSolver::fAllowBadCollectionHit

private

Definition at line 92 of file SpacePointSolver_module.cc.

bool reco3d::SpacePointSolver::fAllowBadInductionHit

private

Definition at line 92 of file SpacePointSolver_module.cc.

double reco3d::SpacePointSolver::fAlpha

private

Definition at line 94 of file SpacePointSolver_module.cc.

double reco3d::SpacePointSolver::fDistThresh

private

Definition at line 96 of file SpacePointSolver_module.cc.

double reco3d::SpacePointSolver::fDistThreshDrift

private

Definition at line 97 of file SpacePointSolver_module.cc.

bool reco3d::SpacePointSolver::fFit

private

Definition at line 91 of file SpacePointSolver_module.cc.

std::string reco3d::SpacePointSolver::fHitLabel

private

Definition at line 89 of file SpacePointSolver_module.cc.

std::unique_ptr<reco3d::IHitReader> reco3d::SpacePointSolver::fHitReader

private

Expt specific tool for reading hits.

Definition at line 105 of file SpacePointSolver_module.cc.

int reco3d::SpacePointSolver::fMaxIterationsNoReg

private

Definition at line 99 of file SpacePointSolver_module.cc.

int reco3d::SpacePointSolver::fMaxIterationsReg

private

Definition at line 100 of file SpacePointSolver_module.cc.

unsigned int reco3d::SpacePointSolver::fMaxNTriplets

private

Definition at line 108 of file SpacePointSolver_module.cc.

unsigned int reco3d::SpacePointSolver::fMinNHits

private

Definition at line 107 of file SpacePointSolver_module.cc.

double reco3d::SpacePointSolver::fXHitOffset

private

Definition at line 102 of file SpacePointSolver_module.cc.

const geo::GeometryCore* reco3d::SpacePointSolver::geom

private

Definition at line 104 of file SpacePointSolver_module.cc.

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

larreco/v09_26_01/source/larreco/SpacePointSolver/SpacePointSolver_module.cc

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation