Inheritance diagram for cosmic::CosmicPFParticleTagger:

Public Types
using	ModuleType = EDProducer

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

Public Member Functions
	CosmicPFParticleTagger (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 Attributes
std::string	fPFParticleModuleLabel

std::string	fTrackModuleLabel

int	fEndTickPadding

int	fDetectorWidthTicks

int	fMinTickDrift

int	fMaxTickDrift

int	fMaxOutOfTime
	Max hits that can be out of time before rejecting. More...

float	fTPCXBoundary

float	fTPCYBoundary

float	fTPCZBoundary

float	fDetHalfHeight

float	fDetWidth

float	fDetLength

Detailed Description

Definition at line 39 of file CosmicPFParticleTagger_module.cc.

Member Typedef Documentation

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::CosmicPFParticleTagger::CosmicPFParticleTagger ( fhicl::ParameterSet const & p )

explicit

Definition at line 56 of file CosmicPFParticleTagger_module.cc.

References fDetectorWidthTicks, fDetHalfHeight, fDetLength, fDetWidth, fEndTickPadding, fMaxOutOfTime, fMaxTickDrift, fMinTickDrift, fPFParticleModuleLabel, fTPCXBoundary, fTPCYBoundary, fTPCZBoundary, fTrackModuleLabel, and detinfo::sampling_rate().

                                                                                : EDProducer{p}
 {
   auto const& tpc = lar::providerFrom<geo::Geometry>()->TPC({0, 0});
   auto const clock_data = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
   auto const detp =
     art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob(clock_data);
 
   fDetHalfHeight = tpc.HalfHeight();
   fDetWidth = 2. * tpc.HalfWidth();
   fDetLength = tpc.Length();
 
   float fSamplingRate = sampling_rate(clock_data);
 
   fPFParticleModuleLabel = p.get<std::string>("PFParticleModuleLabel");
   fTrackModuleLabel = p.get<std::string>("TrackModuleLabel", "track");
   fEndTickPadding = p.get<int>("EndTickPadding", 50); // Fudge the TPC edge in ticks...
   fMaxOutOfTime = p.get<int>("MaxOutOfTime", 4);
 
   fTPCXBoundary = p.get<float>("TPCXBoundary", 5);
   fTPCYBoundary = p.get<float>("TPCYBoundary", 5);
   fTPCZBoundary = p.get<float>("TPCZBoundary", 5);
 
   const double driftVelocity = detp.DriftVelocity(detp.Efield(), detp.Temperature()); // cm/us
 
   fDetectorWidthTicks =
     2 * tpc.HalfWidth() / (driftVelocity * fSamplingRate / 1000); // ~3200 for uB
   fMinTickDrift = clock_data.Time2Tick(clock_data.TriggerTime());
   fMaxTickDrift = fMinTickDrift + fDetectorWidthTicks + fEndTickPadding;
 
   produces<std::vector<anab::CosmicTag>>();
   produces<art::Assns<anab::CosmicTag, recob::Track>>();
   produces<art::Assns<recob::PFParticle, 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::CosmicPFParticleTagger::produce ( art::Event & e )

overridevirtual

Implements art::EDProducer.

Definition at line 90 of file CosmicPFParticleTagger_module.cc.

References util::begin(), util::CreateAssn(), DEFINE_ART_MODULE, util::end(), recob::Track::End(), fDetHalfHeight, fDetLength, fDetWidth, fMaxOutOfTime, fMaxTickDrift, fPFParticleModuleLabel, fTPCXBoundary, fTPCYBoundary, fTPCZBoundary, fTrackModuleLabel, art::ProductRetriever::getByLabel(), 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, art::Event::put(), track, recob::Track::Vertex(), recob::Track::VertexDirection(), x1, and x3.

 {
   // Instatiate the output
   std::unique_ptr<std::vector<anab::CosmicTag>> cosmicTagTrackVector(
     new std::vector<anab::CosmicTag>);
   std::unique_ptr<art::Assns<anab::CosmicTag, recob::Track>> assnOutCosmicTagTrack(
     new art::Assns<anab::CosmicTag, recob::Track>);
   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(cosmicTagTrackVector));
     evt.put(std::move(assnOutCosmicTagTrack));
     return;
   }
 
   // Recover the handle for the tracks
   art::Handle<std::vector<recob::Track>> trackHandle;
   evt.getByLabel(fTrackModuleLabel, trackHandle);
 
   if (!trackHandle.isValid()) {
     evt.put(std::move(cosmicTagTrackVector));
     evt.put(std::move(assnOutCosmicTagTrack));
     return;
   }
 
   // Recover handle for track <--> PFParticle associations
   art::Handle<art::Assns<recob::PFParticle, recob::Track>> pfPartToTrackHandle;
   evt.getByLabel(fTrackModuleLabel, pfPartToTrackHandle);
 
   // Recover the list of associated tracks
   art::FindManyP<recob::Track> pfPartToTrackAssns(pfParticleHandle, evt, fTrackModuleLabel);
 
   // and the hits
   art::FindManyP<recob::Hit> hitsSpill(trackHandle, evt, fTrackModuleLabel);
 
   // 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 track vector
     std::vector<art::Ptr<recob::Track>> trackVec = pfPartToTrackAssns.at(pfPartIdx);
 
     // Is there a track associated to this PFParticle?
     if (trackVec.empty()) {
       // We need to make a null CosmicTag to store with this PFParticle to keep sequencing correct
       std::vector<float> tempPt1, tempPt2;
       tempPt1.push_back(-999);
       tempPt1.push_back(-999);
       tempPt1.push_back(-999);
       tempPt2.push_back(-999);
       tempPt2.push_back(-999);
       tempPt2.push_back(-999);
       cosmicTagTrackVector->emplace_back(tempPt1, tempPt2, 0., anab::CosmicTagID_t::kNotTagged);
       util::CreateAssn(evt, *cosmicTagTrackVector, pfParticle, *assnOutCosmicTagPFParticle);
       continue;
     }
 
     // Start the tagging process...
     int isCosmic = 0;
     anab::CosmicTagID_t tag_id = anab::CosmicTagID_t::kNotTagged;
     art::Ptr<recob::Track> track1 = trackVec.front();
 
     std::vector<art::Ptr<recob::Hit>> hitVec = hitsSpill.at(track1.key());
 
     // Recover track end points
     auto vertexPosition = track1->Vertex();
     auto vertexDirection = track1->VertexDirection();
     auto endPosition = track1->End();
 
     // In principle there is one track associated to a PFParticle... but with current
     // technology it can happen that a PFParticle is broken into multiple tracks. Our
     // aim here is to find the maximum extents of all the tracks which have been
     // associated to the single PFParticle
     if (trackVec.size() > 1) {
       for (size_t trackIdx = 1; trackIdx < trackVec.size(); trackIdx++) {
         art::Ptr<recob::Track> track(trackVec[trackIdx]);
 
         auto trackStart = track->Vertex();
         auto trackEnd = track->End();
 
         // Arc length possibilities for start of track
         double arcLStartToStart = (trackStart - vertexPosition).Dot(vertexDirection);
         double arcLStartToEnd = (trackEnd - vertexPosition).Dot(vertexDirection);
 
         if (arcLStartToStart < 0. || arcLStartToEnd < 0.) {
           if (arcLStartToStart < arcLStartToEnd)
             vertexPosition = trackStart;
           else
             vertexPosition = trackEnd;
         }
 
         // Arc length possibilities for end of track
         double arcLEndToStart = (trackStart - endPosition).Dot(vertexDirection);
         double arcLEndToEnd = (trackEnd - endPosition).Dot(vertexDirection);
 
         if (arcLEndToStart > 0. || arcLEndToEnd > 0.) {
           if (arcLEndToStart > arcLEndToEnd)
             endPosition = trackStart;
           else
             endPosition = trackEnd;
         }
 
         // add the hits from this track to the collection
         hitVec.insert(
           hitVec.end(), hitsSpill.at(track.key()).begin(), hitsSpill.at(track.key()).end());
       }
     }
 
     // "Track" end points in easily readable form
     float trackEndPt1_X = vertexPosition.X();
     float trackEndPt1_Y = vertexPosition.Y();
     float trackEndPt1_Z = vertexPosition.Z();
     float trackEndPt2_X = endPosition.X();
     float trackEndPt2_Y = endPosition.Y();
     float trackEndPt2_Z = endPosition.Z();
 
     // Check that all hits on particle are "in time"
     int nOutOfTime(0);
 
     for (unsigned int p = 0; p < hitVec.size(); p++) {
       int peakLessRms = hitVec[p]->PeakTimeMinusRMS();
       int peakPlusRms = hitVec[p]->PeakTimePlusRMS();
 
       if (peakLessRms < fMinTickDrift || peakPlusRms > fMaxTickDrift) {
         if (++nOutOfTime > fMaxOutOfTime) {
           isCosmic = 1;
           tag_id = anab::CosmicTagID_t::kOutsideDrift_Partial;
           break; // If one hit is out of time it must be a cosmic ray
         }
       }
     }
 
     // Now check the TPC boundaries:
     if (isCosmic == 0) {
       // 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.
       unsigned boundaryMask[] = {0, 0};
 
       // 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)
         boundaryMask[0] = 0x1;
       else if (trackEndPt1_X < fTPCXBoundary)
         boundaryMask[0] = 0x2;
 
       if (fDetWidth - trackEndPt2_X < fTPCXBoundary)
         boundaryMask[1] = 0x1;
       else if (trackEndPt2_X < fTPCXBoundary)
         boundaryMask[1] = 0x2;
 
       // 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)
         boundaryMask[0] = 0x10;
       else if (fDetHalfHeight + trackEndPt1_Y < fTPCYBoundary)
         boundaryMask[0] = 0x20;
 
       if (fDetHalfHeight - trackEndPt2_Y < fTPCYBoundary)
         boundaryMask[1] = 0x10;
       else if (fDetHalfHeight + trackEndPt2_Y < fTPCYBoundary)
         boundaryMask[1] = 0x20;
 
       // 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)
         boundaryMask[0] = 0x100;
       else if (trackEndPt1_Z < fTPCZBoundary)
         boundaryMask[0] = 0x200;
 
       if (fDetLength - trackEndPt2_Z < fTPCZBoundary)
         boundaryMask[1] = 0x100;
       else if (trackEndPt2_Z < fTPCZBoundary)
         boundaryMask[1] = 0x200;
 
       unsigned trackMask = boundaryMask[0] | boundaryMask[1];
       int nBitsSet(0);
 
       for (int idx = 0; idx < 12; idx++)
         if (trackMask & (0x1 << idx)) nBitsSet++;
 
       // 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 (nBitsSet > 1) {
         if ((trackMask & 0x300) != 0x300) {
           isCosmic = 2;
           if ((trackMask & 0x3) == 0x3)
             tag_id = anab::CosmicTagID_t::kGeometry_XX;
           else if ((trackMask & 0x30) == 0x30)
             tag_id = anab::CosmicTagID_t::kGeometry_YY;
           else if ((trackMask & 0x3) && (trackMask & 0x30))
             tag_id = anab::CosmicTagID_t::kGeometry_XY;
           else if ((trackMask & 0x3) && (trackMask & 0x300))
             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 {
           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 (nBitsSet > 0) {
         isCosmic = 4;
         if (trackMask & 0x3)
           tag_id = anab::CosmicTagID_t::kGeometry_X;
         else if (trackMask & 0x30)
           tag_id = anab::CosmicTagID_t::kGeometry_Y;
         else if (trackMask & 0x300)
           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
 
     // Loop through the tracks resulting from this PFParticle and mark them
     cosmicTagTrackVector->emplace_back(endPt1, endPt2, cosmicScore, tag_id);
 
     util::CreateAssn(evt, *cosmicTagTrackVector, trackVec, *assnOutCosmicTagTrack);
 
     // Don't forget the association to the PFParticle
     util::CreateAssn(evt, *cosmicTagTrackVector, pfParticle, *assnOutCosmicTagPFParticle);
   }
 
   evt.put(std::move(cosmicTagTrackVector));
   evt.put(std::move(assnOutCosmicTagTrack));
   evt.put(std::move(assnOutCosmicTagPFParticle));
 
 } // 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);
   }