Inheritance diagram for calo::GnocchiCalorimetry:

Classes
struct	Config

Public Types
using	Parameters = art::EDProducer::Table< Config >

using	ModuleType = EDProducer

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

Public Member Functions
	GnocchiCalorimetry (Parameters const &config)

void	produce (art::Event &evt) override

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 Member Functions
std::vector< std::vector< OrganizedHits > >	OrganizeHits (const std::vector< art::Ptr< recob::Hit >> &hits, const std::vector< const recob::TrackHitMeta * > &thms, const recob::Track &track, unsigned nplanes)

std::vector< std::vector< OrganizedHits > >	OrganizeHitsIndividual (const std::vector< art::Ptr< recob::Hit >> &hits, const std::vector< const recob::TrackHitMeta * > &thms, const recob::Track &track, unsigned nplanes)

std::vector< std::vector< OrganizedHits > >	OrganizeHitsSnippets (const std::vector< art::Ptr< recob::Hit >> &hits, const std::vector< const recob::TrackHitMeta * > &thms, const recob::Track &track, unsigned nplanes)

bool	HitIsValid (const recob::TrackHitMeta *thm, const recob::Track &track)

geo::Point_t	GetLocation (const recob::Track &track, const art::Ptr< recob::Hit > hit, const recob::TrackHitMeta *meta)

geo::Point_t	GetLocationAtWires (const recob::Track &track, const recob::Hit &hit, const recob::TrackHitMeta *meta)

geo::Point_t	WireToTrajectoryPosition (const geo::Point_t &loc, const geo::TPCID &tpc)

geo::Point_t	TrajectoryToWirePosition (const geo::Point_t &loc, const geo::TPCID &tpc)

double	GetPitch (const recob::Track &track, const recob::Hit &hit, const recob::TrackHitMeta *meta)

double	GetCharge (const recob::Hit &hit, const std::vector< recob::Hit const * > &sharedHits)

double	GetEfield (const detinfo::DetectorPropertiesData &dprop, const recob::Track &track, const art::Ptr< recob::Hit > hit, const recob::TrackHitMeta *meta)

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
Config	fConfig

CalorimetryAlg	fCaloAlg

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

Detailed Description

Definition at line 65 of file GnocchiCalorimetry_module.cc.

Member Typedef Documentation

using art::EDProducer::ModuleType = EDProducer

inherited

Definition at line 17 of file EDProducer.h.

using calo::GnocchiCalorimetry::Parameters = art::EDProducer::Table<Config>

Definition at line 134 of file GnocchiCalorimetry_module.cc.

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

calo::GnocchiCalorimetry::GnocchiCalorimetry ( Parameters const & config )

explicit

Definition at line 188 of file GnocchiCalorimetry_module.cc.

References calo::GnocchiCalorimetry::Config::CalorimetryAlgConfig, fCaloAlg, fConfig, fNormTools, fhicl::DelegatedParameter::get(), and calo::GnocchiCalorimetry::Config::NormTools.

   : EDProducer{param}, fConfig(param()), fCaloAlg(fConfig.CalorimetryAlgConfig())
 {
   produces<std::vector<anab::Calorimetry>>();
   produces<art::Assns<recob::Track, anab::Calorimetry>>();
   std::vector<fhicl::ParameterSet> norm_tool_configs =
     fConfig.NormTools.get<std::vector<fhicl::ParameterSet>>();
   for (const fhicl::ParameterSet& p : norm_tool_configs) {
     fNormTools.push_back(art::make_tool<INormalizeCharge>(p));
   }
 }

Member Function Documentation

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());
   }

double calo::GnocchiCalorimetry::GetCharge	(	const recob::Hit &	hit,
		const std::vector< recob::Hit const * > &	sharedHits
	)

private

Definition at line 636 of file GnocchiCalorimetry_module.cc.

References calo::GnocchiCalorimetry::Config::cmAmplitude, calo::GnocchiCalorimetry::Config::cmIntegral, calo::GnocchiCalorimetry::Config::cmSummedADC, calo::GnocchiCalorimetry::Config::cmSummedIntegral, fConfig, recob::Hit::Integral(), recob::Hit::PeakAmplitude(), recob::Hit::ROISummedADC(), and sum.

Referenced by produce().

 {
   switch (fConfig.ChargeMethod()) {
   case calo::GnocchiCalorimetry::Config::cmIntegral: return hit.Integral();
   case calo::GnocchiCalorimetry::Config::cmAmplitude: return hit.PeakAmplitude();
   case calo::GnocchiCalorimetry::Config::cmSummedADC: return hit.ROISummedADC();
   case calo::GnocchiCalorimetry::Config::cmSummedIntegral:
     return std::accumulate(
       sharedHits.cbegin(),
       sharedHits.cend(),
       hit.Integral(),
       [](double sum, recob::Hit const* sharedHit) { return sum + sharedHit->Integral(); });
   default: return 0.;
   }
   return 0.;
 }

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();
   }

double calo::GnocchiCalorimetry::GetEfield	(	const detinfo::DetectorPropertiesData &	dprop,
		const recob::Track &	track,
		const art::Ptr< recob::Hit >	hit,
		const recob::TrackHitMeta *	meta
	)

private

Definition at line 669 of file GnocchiCalorimetry_module.cc.

References DEFINE_ART_MODULE, detinfo::DetectorPropertiesData::Efield(), fConfig, calo::GnocchiCalorimetry::Config::FieldDistortionEfield, and GetLocation().

Referenced by produce().

 {
   auto const* sce = lar::providerFrom<spacecharge::SpaceChargeService>();
 
   double EField = dprop.Efield();
   if (sce->EnableSimEfieldSCE() && fConfig.FieldDistortionEfield()) {
     // Gets relative E field Distortions
     geo::Vector_t EFieldOffsets = sce->GetEfieldOffsets(GetLocation(track, hit, meta));
     // Add 1 in X direction as this is the direction of the drift field
     EFieldOffsets = EFieldOffsets + geo::Vector_t{1, 0, 0};
     // Convert to Absolute E Field from relative
     EFieldOffsets = EField * EFieldOffsets;
     // We only care about the magnitude for recombination
     EField = EFieldOffsets.r();
   }
   return EField;
 }

geo::Point_t calo::GnocchiCalorimetry::GetLocation	(	const recob::Track &	track,
		const art::Ptr< recob::Hit >	hit,
		const recob::TrackHitMeta *	meta
	)

private

Definition at line 525 of file GnocchiCalorimetry_module.cc.

References fConfig, recob::TrackHitMeta::Index(), recob::Track::LocationAtPoint(), calo::GnocchiCalorimetry::Config::TrackIsFieldDistortionCorrected, recob::Hit::WireID(), and WireToTrajectoryPosition().

Referenced by GetEfield(), and produce().

 {
   geo::Point_t loc = track.LocationAtPoint(meta->Index());
   return !fConfig.TrackIsFieldDistortionCorrected() ? WireToTrajectoryPosition(loc, hit->WireID()) :
                                                       loc;
 }

geo::Point_t calo::GnocchiCalorimetry::GetLocationAtWires	(	const recob::Track &	track,
		const recob::Hit &	hit,
		const recob::TrackHitMeta *	meta
	)

private

Definition at line 552 of file GnocchiCalorimetry_module.cc.

References fConfig, recob::TrackHitMeta::Index(), recob::Track::LocationAtPoint(), calo::GnocchiCalorimetry::Config::TrackIsFieldDistortionCorrected, TrajectoryToWirePosition(), and recob::Hit::WireID().

Referenced by GetPitch().

 {
   geo::Point_t loc = track.LocationAtPoint(meta->Index());
   return fConfig.TrackIsFieldDistortionCorrected() ? TrajectoryToWirePosition(loc, hit.WireID()) :
                                                      loc;
 }

double calo::GnocchiCalorimetry::GetPitch	(	const recob::Track &	track,
		const recob::Hit &	hit,
		const recob::TrackHitMeta *	meta
	)

private

Definition at line 583 of file GnocchiCalorimetry_module.cc.

References util::abs(), geo::WireID::asPlaneID(), geo::CryostatID::Cryostat, dir, recob::Track::DirectionAtPoint(), fConfig, calo::GnocchiCalorimetry::Config::FieldDistortion, Get, GetLocationAtWires(), recob::TrackHitMeta::Index(), recob::Track::LocationAtPoint(), geo::PlaneID::Plane, geo::TPCID::TPC, calo::GnocchiCalorimetry::Config::TrackIsFieldDistortionCorrected, TrajectoryToWirePosition(), recob::Hit::View(), recob::Hit::WireID(), and WireToTrajectoryPosition().

Referenced by produce().

 {
   auto const& wireReadoutGeom = art::ServiceHandle<geo::WireReadout>()->Get();
   auto const* sce = lar::providerFrom<spacecharge::SpaceChargeService>();
 
   double angleToVert = wireReadoutGeom.WireAngleToVertical(hit.View(), hit.WireID().asPlaneID()) -
                        0.5 * ::util::pi<>();
 
   geo::Vector_t dir;
   auto const& plane =
     wireReadoutGeom.Plane({hit.WireID().Cryostat, hit.WireID().TPC, hit.WireID().Plane});
 
   // "dir" should be the direction that the wires see. If the track already has the field
   // distortion corrections applied, then we need to de-apply them to get the direction as
   // seen by the wire planes
   if (sce->EnableCalSpatialSCE() && fConfig.FieldDistortion() &&
       fConfig.TrackIsFieldDistortionCorrected()) {
     geo::Point_t loc = track.LocationAtPoint(meta->Index());
 
     // compute the dir of the track trajectory
     geo::Vector_t track_dir = track.DirectionAtPoint(meta->Index());
     geo::Point_t loc_mdx = loc - track_dir * plane.WirePitch() / 2.;
     geo::Point_t loc_pdx = loc + track_dir * plane.WirePitch() / 2.;
 
     loc_mdx = TrajectoryToWirePosition(loc_mdx, hit.WireID());
     loc_pdx = TrajectoryToWirePosition(loc_pdx, hit.WireID());
 
     // Direction at wires
     dir = (loc_pdx - loc_mdx) / (loc_mdx - loc_pdx).r();
   }
   // If there is no space charge or the track is not yet corrected, then the dir
   // is the track is what we want
   else {
     dir = track.DirectionAtPoint(meta->Index());
   }
 
   double cosgamma = std::abs(std::sin(angleToVert) * dir.Y() + std::cos(angleToVert) * dir.Z());
   double pitch{0.};
   if (cosgamma) { pitch = plane.WirePitch() / cosgamma; }
 
   // now take the pitch computed on the wires and correct it back to the particle trajectory
   geo::Point_t loc_w = GetLocationAtWires(track, hit, meta);
 
   geo::Point_t locw_pdx_traj = WireToTrajectoryPosition(loc_w + pitch * dir, hit.WireID());
   geo::Point_t loc = WireToTrajectoryPosition(loc_w, hit.WireID());
 
   pitch = (locw_pdx_traj - loc).R();
 
   return pitch;
 }

bool calo::GnocchiCalorimetry::HitIsValid	(	const recob::TrackHitMeta *	thm,
		const recob::Track &	track
	)

private

Definition at line 519 of file GnocchiCalorimetry_module.cc.

References recob::Track::HasValidPoint(), and recob::TrackHitMeta::Index().

Referenced by OrganizeHitsIndividual(), and OrganizeHitsSnippets().

 {
   if (thm->Index() == int_max_as_unsigned_int) return false;
   return track.HasValidPoint(thm->Index());
 }

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

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

double calo::GnocchiCalorimetry::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 654 of file GnocchiCalorimetry_module.cc.

References fNormTools.

Referenced by produce().

 {
   double ret = dQdx;
   for (auto const& nt : fNormTools) {
     ret = nt->Normalize(ret, e, h, location, direction, t0);
   }
 
   return ret;
 }

std::vector< std::vector< OrganizedHits > > calo::GnocchiCalorimetry::OrganizeHits	(	const std::vector< art::Ptr< recob::Hit >> &	hits,
		const std::vector< const recob::TrackHitMeta * > &	thms,
		const recob::Track &	track,
		unsigned	nplanes
	)

private

Definition at line 421 of file GnocchiCalorimetry_module.cc.

References calo::GnocchiCalorimetry::Config::cmAmplitude, calo::GnocchiCalorimetry::Config::cmIntegral, fConfig, hits(), OrganizeHitsIndividual(), and OrganizeHitsSnippets().

Referenced by produce().

 {
   // charge is computed per hit -- we organize hits indivudally
   if (fConfig.ChargeMethod() == calo::GnocchiCalorimetry::Config::cmIntegral ||
       fConfig.ChargeMethod() == calo::GnocchiCalorimetry::Config::cmAmplitude) {
     return OrganizeHitsIndividual(hits, thms, track, nplanes);
   }
   // charge is computed per snippet -- we organize hits by snippet
   else {
     return OrganizeHitsSnippets(hits, thms, track, nplanes);
   }
 }

std::vector< std::vector< OrganizedHits > > calo::GnocchiCalorimetry::OrganizeHitsIndividual	(	const std::vector< art::Ptr< recob::Hit >> &	hits,
		const std::vector< const recob::TrackHitMeta * > &	thms,
		const recob::Track &	track,
		unsigned	nplanes
	)

private

Definition at line 438 of file GnocchiCalorimetry_module.cc.

References HitIsValid(), and hits().

Referenced by OrganizeHits().

 {
   std::vector<std::vector<OrganizedHits>> ret(nplanes);
   for (unsigned i = 0; i < hits.size(); i++) {
     if (HitIsValid(thms[i], track)) { ret[hits[i]->WireID().Plane].push_back({i, {}}); }
   }
 
   return ret;
 }

std::vector< std::vector< OrganizedHits > > calo::GnocchiCalorimetry::OrganizeHitsSnippets	(	const std::vector< art::Ptr< recob::Hit >> &	hits,
		const std::vector< const recob::TrackHitMeta * > &	thms,
		const recob::Track &	track,
		unsigned	nplanes
	)

private

Definition at line 452 of file GnocchiCalorimetry_module.cc.

References recob::Hit::EndTick(), HitIsValid(), hits(), recob::Hit::Integral(), util::details::operator==(), util::quantities::concepts::operator>(), recob::Hit::StartTick(), geo::WireID::Wire, and recob::Hit::WireID().

Referenced by OrganizeHits().

 {
   // In this case, we need to only accept one hit in each snippet
   // Snippets are counted by the Start, End, and Wire. If all these are the same for a hit, then they are on the same snippet.
   //
   // If there are multiple valid hits on the same snippet, we need a way to pick the best one.
   // (TODO: find a good way). The current method is to take the one with the highest charge integral.
   struct HitIdentifier {
     int startTick;
     int endTick;
     int wire;
     float integral;
 
     // construct
     explicit HitIdentifier(const recob::Hit& hit)
       : startTick(hit.StartTick())
       , endTick(hit.EndTick())
       , wire(hit.WireID().Wire)
       , integral(hit.Integral())
     {}
 
     // Defines whether two hits are on the same snippet
     inline bool operator==(const HitIdentifier& rhs) const
     {
       return startTick == rhs.startTick && endTick == rhs.endTick && wire == rhs.wire;
     }
 
     // Defines which hit to pick between two both on the same snippet
     inline bool operator>(const HitIdentifier& rhs) const { return integral > rhs.integral; }
   };
 
   std::vector<std::vector<OrganizedHits>> ret(nplanes);
   std::vector<std::vector<HitIdentifier>> hit_idents(nplanes);
   for (unsigned i = 0; i < hits.size(); i++) {
     if (HitIsValid(thms[i], track)) {
       HitIdentifier this_ident(*hits[i]);
 
       // check if we have found a hit on this snippet before
       bool found_snippet = false;
       auto const plane = hits[i]->WireID().Plane;
       for (unsigned j = 0; j < ret[plane].size(); j++) {
         if (this_ident == hit_idents[plane][j]) {
           found_snippet = true;
           if (this_ident > hit_idents[plane][j]) {
             ret[plane][j].second.push_back(ret[plane][j].first);
             ret[plane][j].first = i;
             hit_idents[plane][j] = this_ident;
           }
           else {
             ret[plane][j].second.push_back(i);
           }
           break;
         }
       }
       if (!found_snippet) {
         ret[plane].push_back({i, {}});
         hit_idents[plane].push_back(this_ident);
       }
     }
   }
   return ret;
 }

void calo::GnocchiCalorimetry::produce ( art::Event & evt )

overridevirtual

Implements art::EDProducer.

Definition at line 200 of file GnocchiCalorimetry_module.cc.

References util::abs(), calo::GnocchiCalorimetry::Config::AssocHitModuleLabel, calo::GnocchiCalorimetry::Config::cmAmplitude, util::CreateAssn(), calo::GnocchiCalorimetry::Config::Cryostat, geo::CryostatID::Cryostat, art::FindManyP< ProdB, Data >::data(), tca::dEdx(), calo::CalorimetryAlg::dEdx_AMP(), calo::CalorimetryAlg::dEdx_AREA(), recob::Track::DirectionAtPoint(), recob::TrackTrajectory::End(), fCaloAlg, fConfig, art::fill_ptr_vector(), fNormTools, Get, art::ProductRetriever::getByLabel(), GetCharge(), GetEfield(), GetLocation(), GetPitch(), hits(), geo::CryostatID::isValid, util::kBogusD, recob::Track::LocationAtPoint(), Normalize(), OrganizeHits(), calo::GnocchiCalorimetry::Config::PFPModuleLabel, geo::PlaneID::Plane, art::Event::put(), r, recob::TrackTrajectory::Start(), calo::GnocchiCalorimetry::Config::T0ModuleLabel, geo::TPCID::TPC, track, calo::GnocchiCalorimetry::Config::TrackModuleLabel, and recob::Track::Trajectory().

 {
   // Get services
   auto const clock_data = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
   auto const det_prop =
     art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt, clock_data);
 
   auto const& wireReadoutGeom = art::ServiceHandle<geo::WireReadout>()->Get();
   size_t nplanes = wireReadoutGeom.Nplanes();
 
   // Define output collections
   std::unique_ptr<std::vector<anab::Calorimetry>> outputCalo(new std::vector<anab::Calorimetry>);
   std::unique_ptr<art::Assns<recob::Track, anab::Calorimetry>> outputCaloAssn(
     new art::Assns<recob::Track, anab::Calorimetry>);
 
   // collect input
   art::Handle<std::vector<recob::Track>> trackListHandle;
   std::vector<art::Ptr<recob::Track>> tracklist;
   if (evt.getByLabel(fConfig.TrackModuleLabel(), trackListHandle)) {
     art::fill_ptr_vector(tracklist, trackListHandle);
   }
 
   // get the label to collect this hits
   const std::string& hitLabel = (fConfig.AssocHitModuleLabel() == "") ?
                                   fConfig.TrackModuleLabel() :
                                   fConfig.AssocHitModuleLabel();
   art::FindManyP<recob::Hit, recob::TrackHitMeta> fmHits(trackListHandle, evt, hitLabel);
 
   // must be valid if the T0 module label is non-empty
   art::FindManyP<anab::T0> fmT0s(trackListHandle, evt, fConfig.T0ModuleLabel());
   art::FindManyP<recob::PFParticle> fmPFPs(trackListHandle, evt, fConfig.TrackModuleLabel());
   std::vector<art::Ptr<recob::PFParticle>> pfpList;
   if (fConfig.PFPModuleLabel().size()) {
     for (std::size_t itrk = 0, sz = fmPFPs.size(); itrk < sz; ++itrk) {
       // assuming every recob::Track has exactly one associated recob::PFParticle
       pfpList.push_back(fmPFPs.at(itrk).at(0));
     }
   }
   art::FindManyP<anab::T0> fmPFPT0s(pfpList, evt, fConfig.T0ModuleLabel());
 
   for (auto const& nt : fNormTools)
     nt->setup(evt);
 
   // iterate over all the tracks
   for (unsigned trk_i = 0; trk_i < tracklist.size(); trk_i++) {
     const recob::Track& track = *tracklist[trk_i];
 
     // collect input for this track
     const std::vector<art::Ptr<recob::Hit>>& hits = fmHits.at(trk_i);
     const std::vector<const recob::TrackHitMeta*>& thms = fmHits.data(trk_i);
 
     double T0 = 0;
     if (fConfig.T0ModuleLabel().size()) {
       if (fConfig.PFPModuleLabel().size()) {
         const std::vector<art::Ptr<anab::T0>>& this_t0s = fmPFPT0s.at(trk_i);
         if (this_t0s.size()) T0 = this_t0s.at(0)->Time();
       }
       else {
         const std::vector<art::Ptr<anab::T0>>& this_t0s = fmT0s.at(trk_i);
         if (this_t0s.size()) T0 = this_t0s.at(0)->Time();
       }
     }
 
     // organize the hits by plane
     std::vector<std::vector<OrganizedHits>> hit_indices = OrganizeHits(hits, thms, track, nplanes);
 
     for (unsigned plane_i = 0; plane_i < nplanes; plane_i++) {
 
       float kinetic_energy = 0.;
       std::vector<float> dEdxs;
       std::vector<float> dQdxs;
       std::vector<float> resranges;
       std::vector<float> deadwireresranges;
       float range = 0.;
       std::vector<float> pitches;
       std::vector<geo::Point_t> xyzs;
       std::vector<size_t> tp_indices;
       geo::PlaneID plane;
 
       // setup the plane ID
       plane.Plane = plane_i;
       plane.TPC = 0; // arbitrary -- tracks can cross TPC boundaries
       plane.Cryostat = fConfig.Cryostat();
       plane.isValid = true;
 
       std::vector<float> lengths;
       for (unsigned hit_i = 0; hit_i < hit_indices[plane_i].size(); hit_i++) {
         unsigned hit_index = hit_indices[plane_i][hit_i].first;
 
         std::vector<recob::Hit const*> sharedHits = {};
         sharedHits.reserve(hit_indices[plane_i][hit_i].second.size());
         for (const unsigned shared_hit_index : hit_indices[plane_i][hit_i].second)
           sharedHits.push_back(hits[shared_hit_index].get());
 
         // Get the location of this point
         geo::Point_t location = GetLocation(track, hits[hit_index], thms[hit_index]);
 
         // Get the pitch
         double pitch = GetPitch(track, *hits[hit_index], thms[hit_index]);
 
         // And the charge
         double charge = GetCharge(*hits[hit_index], sharedHits);
 
         // Get the EField
         double EField = GetEfield(det_prop, track, hits[hit_index], thms[hit_index]);
 
         // Angle to the drift electric field (in x direction), in units of degrees
         geo::Vector_t direction = track.DirectionAtPoint(thms[hit_index]->Index());
         double phi = acos(abs(direction.x())) * 180 / M_PI;
 
         double dQdx = charge / pitch;
 
         // Normalize out the detector response
         dQdx = Normalize(dQdx,
                          evt,
                          *hits[hit_index],
                          track.LocationAtPoint(thms[hit_index]->Index()),
                          track.DirectionAtPoint(thms[hit_index]->Index()),
                          T0);
 
         // turn into dEdx
         double dEdx = (fConfig.ChargeMethod() == calo::GnocchiCalorimetry::Config::cmAmplitude) ?
                         fCaloAlg.dEdx_AMP(clock_data,
                                           det_prop,
                                           dQdx,
                                           hits[hit_index]->PeakTime(),
                                           hits[hit_index]->WireID().Plane,
                                           T0,
                                           EField,
                                           phi) :
                         fCaloAlg.dEdx_AREA(clock_data,
                                            det_prop,
                                            dQdx,
                                            hits[hit_index]->PeakTime(),
                                            hits[hit_index]->WireID().Plane,
                                            T0,
                                            EField,
                                            phi);
 
         // save the length between each pair of hits
         if (xyzs.size() == 0) { lengths.push_back(0.); }
         else {
           lengths.push_back((location - xyzs.back()).r());
         }
 
         // save stuff
         dEdxs.push_back(dEdx);
         dQdxs.push_back(dQdx);
         pitches.push_back(pitch);
         xyzs.push_back(location);
         kinetic_energy += dEdx * pitch;
 
         // TODO: FIXME
         // It seems weird that the "trajectory-point-index" actually is the
         // index of the hit... is this a bug in the documentation
         // of anab::Calorimetry?
         //
         // i.e. -- I think this piece of code should actually be:
         // tp_indices.push_back(thms[hit_index]->Index());
         tp_indices.push_back(hits[hit_index].key());
 
       } // end iterate over hits
 
       // turn the lengths vector into a residual-range vector and total length
       if (lengths.size() > 1) {
         range = std::accumulate(lengths.begin(), lengths.end(), 0.);
 
         // check the direction that the hits are going in the track:
         // upstream (end-start) or downstream (start-end)
         bool is_downstream =
           (track.Trajectory().Start() - xyzs[0]).r() +
             (track.Trajectory().End() - xyzs.back()).r() <
           (track.Trajectory().End() - xyzs[0]).r() + (track.Trajectory().Start() - xyzs.back()).r();
 
         resranges.resize(lengths.size());
         if (is_downstream) {
           resranges[lengths.size() - 1] = lengths.back() / 2.;
           for (int i_len = lengths.size() - 2; i_len >= 0; i_len--) {
             resranges[i_len] = resranges[i_len + 1] + lengths[i_len + 1];
           }
         }
         else {
           resranges[0] = lengths[1] / 2.;
           for (unsigned i_len = 1; i_len < lengths.size(); i_len++) {
             resranges[i_len] = resranges[i_len - 1] + lengths[i_len];
           }
         }
       }
 
       // save the Calorimetry output
       //
       // Bogus if less than two hits on this plane
       if (lengths.size() > 1) {
         outputCalo->push_back(anab::Calorimetry(kinetic_energy,
                                                 dEdxs,
                                                 dQdxs,
                                                 resranges,
                                                 deadwireresranges,
                                                 range,
                                                 pitches,
                                                 xyzs,
                                                 tp_indices,
                                                 plane));
       }
       else {
         outputCalo->push_back(
           anab::Calorimetry(util::kBogusD, {}, {}, {}, {}, util::kBogusD, {}, {}, {}, plane));
       }
 
       util::CreateAssn(evt, *outputCalo, tracklist[trk_i], *outputCaloAssn);
 
     } // end iterate over planes
 
   } // end iterate over tracks
 
   evt.put(std::move(outputCalo));
   evt.put(std::move(outputCaloAssn));
 
   return;
 }

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

geo::Point_t calo::GnocchiCalorimetry::TrajectoryToWirePosition	(	const geo::Point_t &	loc,
		const geo::TPCID &	tpc
	)

private

Definition at line 561 of file GnocchiCalorimetry_module.cc.

References geo::TPCGeo::DriftDir(), fConfig, calo::GnocchiCalorimetry::Config::FieldDistortion, calo::GnocchiCalorimetry::Config::FieldDistortionCorrectionXSign, and geo::GeometryCore::TPC().

Referenced by GetLocationAtWires(), and GetPitch().

 {
   auto const* sce = lar::providerFrom<spacecharge::SpaceChargeService>();
   art::ServiceHandle<geo::Geometry> geom;
 
   geo::Point_t ret = loc;
 
   if (sce->EnableCalSpatialSCE() && fConfig.FieldDistortion()) {
     // Returned X is the drift -- multiply by the drift direction to undo this
     int corr = geom->TPC(tpc).DriftDir().X();
 
     geo::Vector_t offset = sce->GetPosOffsets(ret);
 
     ret.SetX(ret.X() + corr * fConfig.FieldDistortionCorrectionXSign() * offset.X());
     ret.SetY(ret.Y() + offset.Y());
     ret.SetZ(ret.Z() + offset.Z());
   }
 
   return ret;
 }

geo::Point_t calo::GnocchiCalorimetry::WireToTrajectoryPosition	(	const geo::Point_t &	loc,
		const geo::TPCID &	tpc
	)

private

Definition at line 534 of file GnocchiCalorimetry_module.cc.

References fConfig, calo::GnocchiCalorimetry::Config::FieldDistortion, calo::GnocchiCalorimetry::Config::FieldDistortionCorrectionXSign, and geo::TPCID::TPC.

Referenced by GetLocation(), and GetPitch().

 {
   auto const* sce = lar::providerFrom<spacecharge::SpaceChargeService>();
 
   geo::Point_t ret = loc;
 
   if (sce->EnableCalSpatialSCE() && fConfig.FieldDistortion()) {
     geo::Vector_t offset = sce->GetCalPosOffsets(ret, tpc.TPC);
 
     ret.SetX(ret.X() + fConfig.FieldDistortionCorrectionXSign() * offset.X());
     ret.SetY(ret.Y() + offset.Y());
     ret.SetZ(ret.Z() + offset.Z());
   }
 
   return ret;
 }