Inheritance diagram for cosmic::CosmicPCAxisTagger:

Public Types
using	ModuleType = EDProducer

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

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

void	produce (art::Event &e) 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 Types
typedef std::vector< reco::ClusterHit2D >	Hit2DVector

Private Attributes
std::string	fPFParticleModuleLabel

std::string	fPCAxisModuleLabel

lar_cluster3d::PrincipalComponentsAlg	fPcaAlg
	Principal Components algorithm. More...

int	fDetectorWidthTicks

float	fTPCXBoundary

float	fTPCYBoundary

float	fTPCZBoundary

float	fDetHalfHeight

float	fDetWidth

float	fDetLength

Detailed Description

Definition at line 50 of file CosmicPCAxisTagger_module.cc.

Member Typedef Documentation

typedef std::vector<reco::ClusterHit2D> cosmic::CosmicPCAxisTagger::Hit2DVector

private

Definition at line 57 of file CosmicPCAxisTagger_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

cosmic::CosmicPCAxisTagger::CosmicPCAxisTagger ( fhicl::ParameterSet const & p )

explicit

Definition at line 69 of file CosmicPCAxisTagger_module.cc.

References geo::GeometryCore::DetHalfHeight(), geo::GeometryCore::DetHalfWidth(), geo::GeometryCore::DetLength(), fDetectorWidthTicks, fDetHalfHeight, fDetLength, fDetWidth, fPcaAlg, fPCAxisModuleLabel, fPFParticleModuleLabel, fTPCXBoundary, fTPCYBoundary, fTPCZBoundary, and detinfo::sampling_rate().

   : EDProducer{p}, fPcaAlg(p.get<fhicl::ParameterSet>("PrincipalComponentsAlg"))
 {
   art::ServiceHandle<geo::Geometry const> geo;
 
   fDetHalfHeight = geo->DetHalfHeight();
   fDetWidth = 2. * geo->DetHalfWidth();
   fDetLength = geo->DetLength();
 
   auto const clock_data = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
   float fSamplingRate = sampling_rate(clock_data);
 
   fPFParticleModuleLabel = p.get<std::string>("PFParticleModuleLabel");
   fPCAxisModuleLabel = p.get<std::string>("PCAxisModuleLabel");
 
   fTPCXBoundary = p.get<float>("TPCXBoundary", 5);
   fTPCYBoundary = p.get<float>("TPCYBoundary", 5);
   fTPCZBoundary = p.get<float>("TPCZBoundary", 5);
 
   auto const detector =
     art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob(clock_data);
   const double driftVelocity =
     detector.DriftVelocity(detector.Efield(), detector.Temperature()); // cm/us
 
   fDetectorWidthTicks =
     2 * geo->DetHalfWidth() / (driftVelocity * fSamplingRate / 1000); // ~3200 for uB
 
   produces<std::vector<anab::CosmicTag>>();
   produces<art::Assns<recob::PFParticle, anab::CosmicTag>>();
   produces<art::Assns<recob::PCAxis, anab::CosmicTag>>();
 }

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

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

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 cosmic::CosmicPCAxisTagger::produce ( art::Event & e )

overridevirtual

Implements art::EDProducer.

Definition at line 101 of file CosmicPCAxisTagger_module.cc.

References util::CreateAssn(), DEFINE_ART_MODULE, fDetectorWidthTicks, fDetHalfHeight, fDetLength, fDetWidth, fPCAxisModuleLabel, fPFParticleModuleLabel, fTPCXBoundary, fTPCYBoundary, fTPCZBoundary, recob::PCAxis::getAvePosition(), art::ProductRetriever::getByLabel(), recob::PCAxis::getEigenValues(), recob::PCAxis::getEigenVectors(), art::Handle< T >::isValid(), art::Ptr< T >::key(), anab::kGeometry_X, anab::kGeometry_XX, anab::kGeometry_XY, anab::kGeometry_XZ, anab::kGeometry_Y, anab::kGeometry_YY, anab::kGeometry_YZ, anab::kGeometry_Z, anab::kGeometry_ZZ, anab::kNotTagged, anab::kOutsideDrift_Partial, and art::Event::put().

 {
   // Instatiate the output
   std::unique_ptr<std::vector<anab::CosmicTag>> cosmicTagPFParticleVector(
     new std::vector<anab::CosmicTag>);
   std::unique_ptr<art::Assns<recob::PCAxis, anab::CosmicTag>> assnOutCosmicTagPCAxis(
     new art::Assns<recob::PCAxis, anab::CosmicTag>);
   std::unique_ptr<art::Assns<recob::PFParticle, anab::CosmicTag>> assnOutCosmicTagPFParticle(
     new art::Assns<recob::PFParticle, anab::CosmicTag>);
 
   // Recover handle for PFParticles
   art::Handle<std::vector<recob::PFParticle>> pfParticleHandle;
   evt.getByLabel(fPFParticleModuleLabel, pfParticleHandle);
 
   if (!pfParticleHandle.isValid()) {
     evt.put(std::move(cosmicTagPFParticleVector));
     evt.put(std::move(assnOutCosmicTagPFParticle));
     evt.put(std::move(assnOutCosmicTagPCAxis));
     return;
   }
 
   // We need a handle to the collection of clusters in the data store so we can
   // handle associations to hits.
   art::Handle<std::vector<recob::Cluster>> clusterHandle;
   evt.getByLabel(fPFParticleModuleLabel, clusterHandle);
 
   // Recover the handle for the PCAxes
   art::Handle<std::vector<recob::PCAxis>> pcaxisHandle;
   evt.getByLabel(fPCAxisModuleLabel, pcaxisHandle);
 
   if (!pcaxisHandle.isValid() || !clusterHandle.isValid()) {
     evt.put(std::move(cosmicTagPFParticleVector));
     evt.put(std::move(assnOutCosmicTagPFParticle));
     evt.put(std::move(assnOutCosmicTagPCAxis));
     return;
   }
 
   // Recover the list of associated PCA axes
   art::FindManyP<recob::PCAxis> pfPartToPCAxisAssns(pfParticleHandle, evt, fPCAxisModuleLabel);
 
   // Add the relations to recover associations cluster hits
   art::FindManyP<recob::SpacePoint> spacePointAssnVec(
     pfParticleHandle, evt, fPFParticleModuleLabel);
 
   // Recover the collection of associations between PFParticles and clusters, this will
   // be the mechanism by which we actually deal with clusters
   art::FindManyP<recob::Cluster> clusterAssns(pfParticleHandle, evt, fPFParticleModuleLabel);
 
   // Likewise, recover the collection of associations to hits
   art::FindManyP<recob::Hit> clusterHitAssns(clusterHandle, evt, fPFParticleModuleLabel);
 
   // The outer loop is going to be over PFParticles
   for (size_t pfPartIdx = 0; pfPartIdx != pfParticleHandle->size(); pfPartIdx++) {
     art::Ptr<recob::PFParticle> pfParticle(pfParticleHandle, pfPartIdx);
 
     // Recover the PCAxis vector
     std::vector<art::Ptr<recob::PCAxis>> pcAxisVec = pfPartToPCAxisAssns.at(pfPartIdx);
 
     // Is there an axis associated to this PFParticle?
     if (pcAxisVec.empty()) continue;
 
     // *****************************************************************************************
     // For what follows below we want the "best" PCAxis object only. However, it can be that
     // there are two PCAxes for a PFParticle (depending on source) where the "first" axis will
     // be the "better" one that we want (this statement by fiat, it is defined that way in the
     // axis producer module).
     if (pcAxisVec.size() > 1 && pcAxisVec.front()->getID() > pcAxisVec.back()->getID())
       std::reverse(pcAxisVec.begin(), pcAxisVec.end());
     // We need to confirm this!!
     // *****************************************************************************************
 
     // Recover the axis
     const art::Ptr<recob::PCAxis>& pcAxis = pcAxisVec.front();
 
     // Start the tagging process...
     int isCosmic = 0;
     anab::CosmicTagID_t tag_id = anab::CosmicTagID_t::kNotTagged;
 
     // There are two sections to the tagging, in the first we are going to check for hits that are
     // "out of time" and for this we only need the hit vector. If no hits are out of time then
     // we need to do a more thorough check of the positions of the hits.
     // If we find hits that are out of time we'll set the "end points" of our trajectory to
     // a scale factor past the principle eigen value
     double eigenVal0 = sqrt(pcAxis->getEigenValues()[0]);
     double maxArcLen = 3. * eigenVal0;
 
     // Recover PCA end points
     TVector3 vertexPosition(
       pcAxis->getAvePosition()[0], pcAxis->getAvePosition()[1], pcAxis->getAvePosition()[2]);
     TVector3 vertexDirection(pcAxis->getEigenVectors()[0][0],
                              pcAxis->getEigenVectors()[0][1],
                              pcAxis->getEigenVectors()[0][2]);
 
     TVector3 pcAxisStart = vertexPosition - maxArcLen * vertexDirection;
     TVector3 pcAxisEnd = vertexPosition + maxArcLen * vertexDirection;
 
     // "Track" end points in easily readable form
     float trackEndPt1_X = pcAxisStart[0];
     float trackEndPt1_Y = pcAxisStart[1];
     float trackEndPt1_Z = pcAxisStart[2];
     float trackEndPt2_X = pcAxisEnd[0];
     float trackEndPt2_Y = pcAxisEnd[1];
     float trackEndPt2_Z = pcAxisEnd[2];
 
     // Now we get the 2D clusters associated to this PFParticle
     std::vector<art::Ptr<recob::Cluster>> clusterVec = clusterAssns.at(pfParticle.key());
 
     bool dumpMe(false);
 
     // Once we have the clusters then we can loop over them to find the associated hits
     for (const auto& cluster : clusterVec) {
       // Recover the 2D hits associated to a given cluster
       std::vector<art::Ptr<recob::Hit>> hitVec = clusterHitAssns.at(cluster->ID());
 
       // Once we have the hits the first thing we should do is to check if any are "out of time"
       // If there are out of time hits then we are going to reject the cluster so no need to do
       // any further processing.
       // Check that all hits on particle are "in time"
       for (const auto& hit : hitVec) {
         if (dumpMe) {
           std::cout << "***>> Hit key: " << hit.key() << ", peak - RMS: " << hit->PeakTimeMinusRMS()
                     << ", peak + RMS: " << hit->PeakTimePlusRMS()
                     << ", det width: " << fDetectorWidthTicks << std::endl;
         }
         if (hit->PeakTimeMinusRMS() < fDetectorWidthTicks ||
             hit->PeakTimePlusRMS() > 2. * fDetectorWidthTicks) {
           isCosmic = 1;
           tag_id = anab::CosmicTagID_t::kOutsideDrift_Partial;
           break; // If one hit is out of time it must be a cosmic ray
         }
       }
     }
 
     // Recover the space points associated to this PFParticle.
     std::vector<art::Ptr<recob::SpacePoint>> spacePointVec = spacePointAssnVec.at(pfParticle.key());
 
     // Now check the TPC boundaries:
     if (isCosmic == 0 && !spacePointVec.empty()) {
       // Do a check on the transverse components of the PCA axes to make sure we are looking at long straight
       // tracks and not the kind of events we might want to keep
       double transRMS =
         sqrt(std::pow(pcAxis->getEigenValues()[1], 2) + std::pow(pcAxis->getEigenValues()[1], 2));
 
       if (eigenVal0 > 0. && transRMS > 0.) {
         // The idea is to find the maximum extents of this PFParticle using the PCA axis which we
         // can then use to determine proximity to a TPC boundary.
         // We implement this by recovering the 3D Space Points and then make a pass through them to
         // find the space points at the extremes of the distance along the principle axis.
         // We'll loop through the space points looking for those which have the largest arc lengths along
         // the principle axis. Set up to do that
         double arcLengthToFirstHit(9999.);
         double arcLengthToLastHit(-9999.);
 
         for (const auto spacePoint : spacePointVec) {
           TVector3 spacePointPos(spacePoint->XYZ()[0], spacePoint->XYZ()[1], spacePoint->XYZ()[2]);
           TVector3 deltaPos = spacePointPos - vertexPosition;
           double arcLenToHit = deltaPos.Dot(vertexDirection);
 
           if (arcLenToHit < arcLengthToFirstHit) {
             arcLengthToFirstHit = arcLenToHit;
             pcAxisStart = spacePointPos;
           }
 
           if (arcLenToHit > arcLengthToLastHit) {
             arcLengthToLastHit = arcLenToHit;
             pcAxisEnd = spacePointPos;
           }
         }
 
         // "Track" end points in easily readable form
         trackEndPt1_X = pcAxisStart[0];
         trackEndPt1_Y = pcAxisStart[1];
         trackEndPt1_Z = pcAxisStart[2];
         trackEndPt2_X = pcAxisEnd[0];
         trackEndPt2_Y = pcAxisEnd[1];
         trackEndPt2_Z = pcAxisEnd[2];
 
         // In below we check entry and exit points. Note that a special case of a particle entering
         // and exiting the same surface is considered to be running parallel to the surface and NOT
         // entering and exiting.
         // Also, in what follows we make no assumptions on which end point is the "start" or
         // "end" of the track being considered.
         bool nBdX[] = {false, false};
         bool nBdY[] = {false, false};
         bool nBdZ[] = {false, false};
 
         // Check x extents - note that uboone coordinaes system has x=0 at edge
         // Note this counts the case where the track enters and exits the same surface as a "1", not a "2"
         // Also note that, in theory, any cosmic ray entering or exiting the X surfaces will have presumably
         // been removed already by the checking of "out of time" hits... but this will at least label
         // neutrino interaction tracks which exit through the X surfaces of the TPC
         if (fDetWidth - trackEndPt1_X < fTPCXBoundary || trackEndPt1_X < fTPCXBoundary)
           nBdX[0] = true;
         if (fDetWidth - trackEndPt2_X < fTPCXBoundary || trackEndPt2_X < fTPCXBoundary)
           nBdX[1] = true;
 
         // Check y extents (note coordinate system change)
         // Note this counts the case where the track enters and exits the same surface as a "1", not a "2"
         if (fDetHalfHeight - trackEndPt1_Y < fTPCYBoundary ||
             fDetHalfHeight + trackEndPt1_Y < fTPCYBoundary)
           nBdY[0] = true; // one end of track exits out top
         if (fDetHalfHeight - trackEndPt2_Y < fTPCYBoundary ||
             fDetHalfHeight + trackEndPt2_Y < fTPCYBoundary)
           nBdY[1] = true; // one end of track exist out bottom
 
         // Check z extents
         // Note this counts the case where the track enters and exits the same surface as a "1", not a "2"
         if (fDetLength - trackEndPt1_Z < fTPCZBoundary || trackEndPt1_Z < fTPCZBoundary)
           nBdZ[0] = true;
         if (fDetLength - trackEndPt2_Z < fTPCZBoundary || trackEndPt2_Z < fTPCZBoundary)
           nBdZ[1] = true;
 
         // Endpoints exiting?
         bool exitEnd1 = nBdX[0] || nBdY[0]; // end point 1 enters/exits top/bottom or x sides
         bool exitEnd2 = nBdX[1] || nBdY[1]; // end point 2 enters/exits top/bottom or x sides
         bool exitEndZ1 =
           exitEnd1 && nBdZ[1]; // end point 1 enters/exits top/bottom and exits/enters z
         bool exitEndZ2 =
           exitEnd1 && nBdZ[0]; // end point 2 enters/exits top/bottom and exits/enters z
 
         // This should check for the case of a track which is both entering and exiting
         // but we consider entering and exiting the z boundaries to be a special case (should it be?)
         if ((exitEnd1 && exitEnd2) || exitEndZ1 || exitEndZ2) {
           isCosmic = 2;
           if (nBdX[0] && nBdX[1])
             tag_id = anab::CosmicTagID_t::kGeometry_XX;
           else if (nBdY[0] && nBdY[1])
             tag_id = anab::CosmicTagID_t::kGeometry_YY;
           else if ((nBdX[0] || nBdX[1]) && (nBdY[0] || nBdY[1]))
             tag_id = anab::CosmicTagID_t::kGeometry_XY;
           else if ((nBdX[0] || nBdX[1]) && (nBdZ[0] || nBdZ[1]))
             tag_id = anab::CosmicTagID_t::kGeometry_XZ;
           else
             tag_id = anab::CosmicTagID_t::kGeometry_YZ;
         }
         // This is the special case of track which appears to enter/exit z boundaries
         else if (nBdZ[0] && nBdZ[1]) {
           isCosmic = 3;
           tag_id = anab::CosmicTagID_t::kGeometry_ZZ;
         }
         // This looks for track which enters/exits a boundary but has other endpoint in TPC
         else if ((nBdX[0] || nBdY[0] || nBdZ[0]) != (nBdX[1] || nBdY[1] || nBdZ[1])) {
           isCosmic = 4;
           if (nBdX[0] || nBdX[1])
             tag_id = anab::CosmicTagID_t::kGeometry_X;
           else if (nBdY[0] || nBdY[1])
             tag_id = anab::CosmicTagID_t::kGeometry_Y;
           else if (nBdZ[0] || nBdZ[1])
             tag_id = anab::CosmicTagID_t::kGeometry_Z;
         }
       }
     }
 
     std::vector<float> endPt1;
     std::vector<float> endPt2;
     endPt1.push_back(trackEndPt1_X);
     endPt1.push_back(trackEndPt1_Y);
     endPt1.push_back(trackEndPt1_Z);
     endPt2.push_back(trackEndPt2_X);
     endPt2.push_back(trackEndPt2_Y);
     endPt2.push_back(trackEndPt2_Z);
 
     float cosmicScore = isCosmic > 0 ? 1. : 0.;
 
     // Handle special cases
     if (isCosmic == 3)
       cosmicScore = 0.4; // Enter/Exit at opposite Z boundaries
     else if (isCosmic == 4)
       cosmicScore = 0.5; // Enter or Exit but not both
 
     // Create the tag object for this PFParticle and make the corresponding association
     cosmicTagPFParticleVector->emplace_back(endPt1, endPt2, cosmicScore, tag_id);
 
     util::CreateAssn(evt, *cosmicTagPFParticleVector, pfParticle, *assnOutCosmicTagPFParticle);
 
     // Loop through the tracks resulting from this PFParticle and mark them
     for (const auto& axis : pcAxisVec) {
       util::CreateAssn(evt, *cosmicTagPFParticleVector, axis, *assnOutCosmicTagPCAxis);
     }
   }
 
   evt.put(std::move(cosmicTagPFParticleVector));
   evt.put(std::move(assnOutCosmicTagPFParticle));
   evt.put(std::move(assnOutCosmicTagPCAxis));
 } // end of produce

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