Inheritance diagram for cosmic::CosmicPFParticleTagger:

Public Types
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

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

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

virtual	~CosmicPFParticleTagger ()

void	produce (art::Event &e) override

void	beginJob () override

void	reconfigure (fhicl::ParameterSet const &p)

void	endJob () override

template<typename PROD , BranchType B = InEvent>
ProductID	getProductID (std::string const &instanceName={}) const

template<typename PROD , BranchType B>
ProductID	getProductID (ModuleDescription const &moduleDescription, std::string const &instanceName) const

bool	modifiesEvent () const

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

template<typename T , art::BranchType BT>
art::ProductToken< T >	consumes (InputTag const &it)

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

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

template<typename T , art::BranchType BT>
art::ViewToken< T >	consumesView (InputTag const &it)

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

template<typename T , art::BranchType BT>
art::ProductToken< T >	mayConsume (InputTag const &it)

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

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

template<typename T , art::BranchType BT>
art::ViewToken< T >	mayConsumeView (InputTag const &it)

base_engine_t &	createEngine (seed_t seed)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make)

base_engine_t &	createEngine (seed_t seed, std::string const &kind_of_engine_to_make, label_t const &engine_label)

seed_t	get_seed_value (fhicl::ParameterSet const &pset, char const key[]="seed", seed_t const implicit_seed=-1)

Static Public Member Functions
static cet::exempt_ptr< Consumer >	non_module_context ()

Protected Member Functions
CurrentProcessingContext const *	currentContext () const

void	validateConsumedProduct (BranchType const bt, ProductInfo const &pi)

void	prepareForJob (fhicl::ParameterSet const &pset)

void	showMissingConsumes () const

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 57 of file CosmicPFParticleTagger_module.cc.

Member Typedef Documentation

using art::EDProducer::ModuleType = EDProducer

inherited

Definition at line 34 of file EDProducer.h.

template<typename UserConfig , typename KeysToIgnore = void>

using art::EDProducer::Table = ProducerBase::Table<UserConfig, KeysToIgnore>

inherited

Definition at line 43 of file EDProducer.h.

using art::EDProducer::WorkerType = WorkerT<EDProducer>

inherited

Definition at line 35 of file EDProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 81 of file CosmicPFParticleTagger_module.cc.

References reconfigure().

 {
     this->reconfigure(p);
 
     // Call appropriate Produces<>() functions here.
     produces< std::vector<anab::CosmicTag>>();
     produces< art::Assns<anab::CosmicTag,   recob::Track>>();
     produces< art::Assns<recob::PFParticle, anab::CosmicTag>>();
 }

cosmic::CosmicPFParticleTagger::~CosmicPFParticleTagger ( )

virtual

Definition at line 93 of file CosmicPFParticleTagger_module.cc.

 {
     // Clean up dynamic memory and other resources here.
 }

Member Function Documentation

void cosmic::CosmicPFParticleTagger::beginJob ( )

overridevirtual

Reimplemented from art::EDProducer.

Definition at line 348 of file CosmicPFParticleTagger_module.cc.

349 {

350 }

template<typename T , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::consumes ( InputTag const & it )

inherited

Definition at line 147 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ProductToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::Product,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ProductToken<T>{it};
 }

template<typename T , art::BranchType BT>

void art::Consumer::consumesMany ( )

inherited

Definition at line 162 of file Consumer.h.

 {
   if (!moduleContext_)
     return;
 
   consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
 }

template<typename Element , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::consumesView ( InputTag const & it )

inherited

Definition at line 172 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ViewToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ViewToken<T>{it};
 }

EngineCreator::base_engine_t & EngineCreator::createEngine ( seed_t seed )

inherited

Definition at line 26 of file EngineCreator.cc.

References art::EngineCreator::rng().

Referenced by evgen::CosmicsGen::CosmicsGen(), rndm::NuRandomService::createEngine(), cluster::fuzzyCluster::fuzzyCluster(), cluster::HoughLineFinder::HoughLineFinder(), art::MixFilter< T >::initEngine_(), larg4::LArG4::LArG4(), evgen::LightSource::LightSource(), evgen::NeutronOsc::NeutronOsc(), evgen::NucleonDecay::NucleonDecay(), opdet::OpMCDigi::OpMCDigi(), opdet::OptDetDigitizer::OptDetDigitizer(), phot::PhotonLibraryPropagation::PhotonLibraryPropagation(), detsim::SimDriftElectrons::SimDriftElectrons(), evgen::SingleGen::SingleGen(), evgen::SNNueAr40CCGen::SNNueAr40CCGen(), ToyOneShowerGen::ToyOneShowerGen(), and trkf::Track3DKalman::Track3DKalman().

 {
   return rng()->createEngine(placeholder_schedule_id(), seed);
 }

EngineCreator::base_engine_t & EngineCreator::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make
	)

inherited

Definition at line 32 of file EngineCreator.cc.

References art::EngineCreator::rng().

 {
   return rng()->createEngine(
     placeholder_schedule_id(), seed, kind_of_engine_to_make);
 }

EngineCreator::base_engine_t & EngineCreator::createEngine	(	seed_t	seed,
		std::string const &	kind_of_engine_to_make,
		label_t const &	engine_label
	)

inherited

Definition at line 40 of file EngineCreator.cc.

References art::EngineCreator::rng().

 {
   return rng()->createEngine(
     placeholder_schedule_id(), seed, kind_of_engine_to_make, engine_label);
 }

CurrentProcessingContext const * art::EDProducer::currentContext ( ) const

protectedinherited

Definition at line 120 of file EDProducer.cc.

References art::EDProducer::current_context_.

   {
     return current_context_.get();
   }

void cosmic::CosmicPFParticleTagger::endJob ( )

overridevirtual

Reimplemented from art::EDProducer.

Definition at line 384 of file CosmicPFParticleTagger_module.cc.

References DEFINE_ART_MODULE.

                                           {
   // Implementation of optional member function here.
 }

EngineCreator::seed_t EngineCreator::get_seed_value	(	fhicl::ParameterSet const &	pset,
		char const	key[] = `"seed"`,
		seed_t const	implicit_seed = `-1`
	)

inherited

Definition at line 49 of file EngineCreator.cc.

References fhicl::ParameterSet::get().

Referenced by art::MixFilter< T >::initEngine_().

 {
   auto const& explicit_seeds = pset.get<std::vector<int>>(key, {});
   return explicit_seeds.empty() ? implicit_seed : explicit_seeds.front();
 }

template<typename PROD , BranchType B>

ProductID art::EDProducer::getProductID ( std::string const & instanceName = {} ) const

inlineinherited

Definition at line 123 of file EDProducer.h.

References art::EDProducer::moduleDescription_.

   {
     return ProducerBase::getProductID<PROD, B>(moduleDescription_,
                                                instanceName);
   }

template<typename PROD , BranchType B>

ProductID art::ProducerBase::getProductID	(	ModuleDescription const &	moduleDescription,
		std::string const &	instanceName
	)		const

inherited

Definition at line 56 of file ProducerBase.h.

References B, and art::ModuleDescription::moduleLabel().

Referenced by art::ProducerBase::modifiesEvent().

   {
     auto const& pd =
       get_ProductDescription<PROD>(B, md.moduleLabel(), instanceName);
     return pd.productID();
   }

template<typename T , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ProductToken<T> art::Consumer::mayConsume ( InputTag const & it )

inherited

Definition at line 190 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ProductToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::Product,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ProductToken<T>{it};
 }

template<typename T , art::BranchType BT>

void art::Consumer::mayConsumeMany ( )

inherited

Definition at line 205 of file Consumer.h.

 {
   if (!moduleContext_)
     return;
 
   consumables_[BT].emplace_back(ConsumableType::Many, TypeID{typeid(T)});
 }

template<typename Element , BranchType = InEvent>

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

inherited

template<typename T , art::BranchType BT>

art::ViewToken<T> art::Consumer::mayConsumeView ( InputTag const & it )

inherited

Definition at line 215 of file Consumer.h.

References art::InputTag::instance(), art::InputTag::label(), and art::InputTag::process().

 {
   if (!moduleContext_)
     return ViewToken<T>::invalid();
 
   consumables_[BT].emplace_back(ConsumableType::ViewElement,
                                 TypeID{typeid(T)},
                                 it.label(),
                                 it.instance(),
                                 it.process());
   return ViewToken<T>{it};
 }

bool art::ProducerBase::modifiesEvent ( ) const

inlineinherited

Definition at line 40 of file ProducerBase.h.

References art::ProducerBase::getProductID().

     {
       return true;
     }

cet::exempt_ptr< art::Consumer > art::Consumer::non_module_context ( )

staticinherited

Definition at line 76 of file Consumer.cc.

 {
   static Consumer invalid{InvalidTag{}};
   return &invalid;
 }

void art::Consumer::prepareForJob ( fhicl::ParameterSet const & pset )

protectedinherited

Definition at line 89 of file Consumer.cc.

References fhicl::ParameterSet::get_if_present().

Referenced by art::EDProducer::doBeginJob(), art::EDFilter::doBeginJob(), and art::EDAnalyzer::doBeginJob().

 {
   if (!moduleContext_)
     return;
 
   pset.get_if_present("errorOnMissingConsumes", requireConsumes_);
   for (auto& consumablesPerBranch : consumables_) {
     cet::sort_all(consumablesPerBranch);
   }
 }

void cosmic::CosmicPFParticleTagger::produce ( art::Event & e )

overridevirtual

Implements art::EDProducer.

Definition at line 98 of file CosmicPFParticleTagger_module.cc.

References evd::details::begin(), util::CreateAssn(), recob::Track::End(), evd::details::end(), fDetHalfHeight, fDetLength, fDetWidth, fMaxOutOfTime, fMaxTickDrift, fPFParticleModuleLabel, fTPCXBoundary, fTPCYBoundary, fTPCZBoundary, fTrackModuleLabel, art::DataViewImpl::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(), and x1.

 {
     // 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(*this, 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
         TVector3 vertexPosition  = track1->Vertex();
         TVector3 vertexDirection = track1->VertexDirection();
         TVector3 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]);
                 
                 TVector3 trackStart = track->Vertex();
                 TVector3 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 [0];
         float trackEndPt1_Y = vertexPosition [1];
         float trackEndPt1_Z = vertexPosition [2];
         float trackEndPt2_X = endPosition[0];
         float trackEndPt2_Y = endPosition[1];
         float trackEndPt2_Z = endPosition[2];
         
         // 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( hitVec[p]->PeakTimeMinusRMS() < fMinTickDrift || hitVec[p]->PeakTimePlusRMS() > fMaxTickDrift)
             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(*this, evt, *cosmicTagTrackVector, trackVec, *assnOutCosmicTagTrack );
         
         // Don't forget the association to the PFParticle
         util::CreateAssn(*this, evt, *cosmicTagTrackVector, pfParticle, *assnOutCosmicTagPFParticle);
     }
     
     evt.put( std::move(cosmicTagTrackVector)      );
     evt.put( std::move(assnOutCosmicTagTrack)     );
     evt.put( std::move(assnOutCosmicTagPFParticle));
     
     return;
 
 } // end of produce

void cosmic::CosmicPFParticleTagger::reconfigure ( fhicl::ParameterSet const & p )

Definition at line 352 of file CosmicPFParticleTagger_module.cc.

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

Referenced by CosmicPFParticleTagger().

 {
     // Implementation of optional member function here.
   
     auto const* detp = lar::providerFrom<detinfo::DetectorPropertiesService>();
     auto const* geo = lar::providerFrom<geo::Geometry>();
     auto const* ts = lar::providerFrom<detinfo::DetectorClocksService>();
 
     fDetHalfHeight = geo->DetHalfHeight();
     fDetWidth      = 2.*geo->DetHalfWidth();
     fDetLength     = geo->DetLength();
 
     float fSamplingRate = detp->SamplingRate();
 
     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
 
     //std::cerr << "Drift velocity is " << driftVelocity << " cm/us.  Sampling rate is: "<< fSamplingRate << " detector width: " <<  2*geo->DetHalfWidth() << std::endl;
     fDetectorWidthTicks = 2*geo->DetHalfWidth()/(driftVelocity*fSamplingRate/1000); // ~3200 for uB
     fMinTickDrift = ts->TPCTDC2Tick(0.);
     fMaxTickDrift = fMinTickDrift + fDetectorWidthTicks + fEndTickPadding;
 }

void art::Consumer::showMissingConsumes ( ) const

protectedinherited

Definition at line 125 of file Consumer.cc.

Referenced by art::EDProducer::doEndJob(), art::EDFilter::doEndJob(), art::EDAnalyzer::doEndJob(), and art::RootOutput::endJob().

 {
   if (!moduleContext_)
     return;
 
   // If none of the branches have missing consumes statements, exit early.
   if (std::all_of(cbegin(missingConsumes_),
                   cend(missingConsumes_),
                   [](auto const& perBranch) { return perBranch.empty(); }))
     return;
 
   constexpr cet::HorizontalRule rule{60};
   mf::LogPrint log{"MTdiagnostics"};
   log << '\n'
       << rule('=') << '\n'
       << "The following consumes (or mayConsume) statements are missing from\n"
       << module_context(moduleDescription_) << '\n'
       << rule('-') << '\n';
 
   cet::for_all_with_index(
     missingConsumes_, [&log](std::size_t const i, auto const& perBranch) {
       for (auto const& pi : perBranch) {
         log << "  "
             << assemble_consumes_statement(static_cast<BranchType>(i), pi)
             << '\n';
       }
     });
   log << rule('=');
 }

void art::Consumer::validateConsumedProduct	(	BranchType const	bt,
		ProductInfo const &	pi
	)

protectedinherited

Definition at line 101 of file Consumer.cc.

References art::errors::ProductRegistrationFailure.

 {
   // Early exits if consumes tracking has been disabled or if the
   // consumed product is an allowed consumable.
   if (!moduleContext_)
     return;
 
   if (cet::binary_search_all(consumables_[bt], pi))
     return;
 
   if (requireConsumes_) {
     throw Exception(errors::ProductRegistrationFailure,
                     "Consumer: an error occurred during validation of a "
                     "retrieved product\n\n")
       << "The following consumes (or mayConsume) statement is missing from\n"
       << module_context(moduleDescription_) << ":\n\n"
       << "  " << assemble_consumes_statement(bt, pi) << "\n\n";
   }
 
   missingConsumes_[bt].insert(pi);
 }