Inheritance diagram for filt::LArG4ParticleFilter:

Public Types
using	ModuleType = EDFilter

using	WorkerType = WorkerT< EDFilter >

template<typename UserConfig >
using	Table = ProducerBase::Table< UserConfig >

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

virtual	~LArG4ParticleFilter ()

virtual bool	filter (art::Event &e)

void	reconfigure (fhicl::ParameterSet const &pset)

void	beginJob ()

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

Static Public Attributes
static constexpr bool	Pass {true}

static constexpr bool	Fail {false}

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 Member Functions
bool	IsInterestingParticle (const art::Ptr< simb::MCParticle > particle, int index)

bool	PDGCheck (const art::Ptr< simb::MCParticle > particle, int index)

bool	MinMomentumCheck (const art::Ptr< simb::MCParticle > particle, int index)

bool	MaxMomentumCheck (const art::Ptr< simb::MCParticle > particle, int index)

bool	StartInTPCCheck (const art::Ptr< simb::MCParticle > particle, int index)

bool	StopInTPCCheck (const art::Ptr< simb::MCParticle > particle, int index)

bool	TPCTrajLengthCheck (const art::Ptr< simb::MCParticle > particle, int index)

double	CalculateLength (const std::vector< TVector3 > &position_segment)

Private Attributes
art::ServiceHandle< geo::Geometry >	fGeom

std::vector< int >	fInterestingPDGs

std::vector< double >	fParticleMinMomentum

std::vector< double >	fParticleMaxMomentum

std::vector< int >	fStartInTPC

std::vector< int >	fStopInTPC

std::vector< double >	fParticleMinTPCLength

bool	fRequireAllInterestingParticles

std::vector< bool >	fFoundInterestingParticles

Detailed Description

Definition at line 25 of file LArG4ParticleFilter_module.cc.

Member Typedef Documentation

using art::EDFilter::ModuleType = EDFilter

inherited

Definition at line 37 of file EDFilter.h.

template<typename UserConfig >

using art::EDFilter::Table = ProducerBase::Table<UserConfig>

inherited

Definition at line 46 of file EDFilter.h.

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

inherited

Definition at line 38 of file EDFilter.h.

Constructor & Destructor Documentation

filt::LArG4ParticleFilter::LArG4ParticleFilter ( fhicl::ParameterSet const & pset )

explicit

virtual filt::LArG4ParticleFilter::~LArG4ParticleFilter ( )

inlinevirtual

Definition at line 28 of file LArG4ParticleFilter_module.cc.

References beginJob(), CalculateLength(), e, filter(), IsInterestingParticle(), MaxMomentumCheck(), MinMomentumCheck(), PDGCheck(), reconfigure(), StartInTPCCheck(), StopInTPCCheck(), and TPCTrajLengthCheck().

28 {};

Member Function Documentation

void filt::LArG4ParticleFilter::beginJob ( )

virtual

Reimplemented from art::EDFilter.

Definition at line 117 of file LArG4ParticleFilter_module.cc.

Referenced by ~LArG4ParticleFilter().

double filt::LArG4ParticleFilter::CalculateLength ( const std::vector< TVector3 > & position_segment )

private

Definition at line 264 of file LArG4ParticleFilter_module.cc.

References DEFINE_ART_MODULE.

Referenced by TPCTrajLengthCheck(), and ~LArG4ParticleFilter().

                                                                                         {
     double length = 0;
     //Check how many points we have in the segment.  If it is one or less, there is nothing to calculate so return 0
     if (position_segment.size() <= 1) return length;
 
     //Now we need to compare every adjacent pair of positions to work out the length of this segment
     for (unsigned int i = 1; i < position_segment.size(); i++){
       length += (position_segment[i] - position_segment[i-1]).Mag();
     }
 
     return length;
   }

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::EDFilter::currentContext ( ) const

protectedinherited

Definition at line 120 of file EDFilter.cc.

References art::EDFilter::current_context_.

   {
     return current_context_.get();
   }

bool filt::LArG4ParticleFilter::filter ( art::Event & e )

virtual

Implements art::EDFilter.

Definition at line 78 of file LArG4ParticleFilter_module.cc.

References fFoundInterestingParticles, fInterestingPDGs, fRequireAllInterestingParticles, art::DataViewImpl::getByLabel(), and IsInterestingParticle().

Referenced by ~LArG4ParticleFilter().

                                               {
 
     //art::ServiceHandle<geo::Geometry> geom;
 
     //Reset the found vector
     for (unsigned int i = 0; i < fFoundInterestingParticles.size(); i++){
       fFoundInterestingParticles[i] = false;
     }
 
     //Get the vector of particles
     art::Handle<std::vector<simb::MCParticle> > particles;
     e.getByLabel("largeant",particles);
     //Loop through the particles
     for (unsigned int part_i = 0; part_i < particles->size(); part_i++){
       //Get the particle
       const art::Ptr<simb::MCParticle> particle(particles,part_i);
       //Loop over the list of particles we want and compare it with the particle we are looking it
       for (unsigned int interest_i = 0; interest_i < fInterestingPDGs.size(); interest_i++){
         if (IsInterestingParticle(particle,interest_i)) {
           if (!fRequireAllInterestingParticles) return true; //If we only require at least one of the particles be found then we have already done our job
           fFoundInterestingParticles[interest_i] = true;
           bool foundThemAll = true;
           for (unsigned int found_i = 0; found_i < fFoundInterestingParticles.size(); found_i++){
             if (fFoundInterestingParticles[found_i] == false){
               foundThemAll = false;
               break;
             }
           }
           if (foundThemAll){
             return true;
           }
         }
       }
     }
 
     //Assume that the event is not worth saving
     return false;
   }

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::EDFilter::getProductID ( std::string const & instanceName = {} ) const

inlineinherited

Definition at line 131 of file EDFilter.h.

References art::EDFilter::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();
   }

bool filt::LArG4ParticleFilter::IsInterestingParticle	(	const art::Ptr< simb::MCParticle >	particle,
		int	index
	)

private

Definition at line 122 of file LArG4ParticleFilter_module.cc.

References MaxMomentumCheck(), MinMomentumCheck(), PDGCheck(), StopInTPCCheck(), and TPCTrajLengthCheck().

Referenced by filter(), and ~LArG4ParticleFilter().

                                                                                                  {
     //Run the checks
     if (!PDGCheck(particle,index)) return false;
     if (!MinMomentumCheck(particle,index)) return false;
     if (!MaxMomentumCheck(particle,index)) return false;
     if (!StopInTPCCheck(particle,index)) return false;
     if (!TPCTrajLengthCheck(particle,index)) return false;
 
     return true;
   }

bool filt::LArG4ParticleFilter::MaxMomentumCheck	(	const art::Ptr< simb::MCParticle >	particle,
		int	index
	)

private

Definition at line 145 of file LArG4ParticleFilter_module.cc.

References fParticleMaxMomentum, and simb::MCParticle::Momentum().

Referenced by IsInterestingParticle(), and ~LArG4ParticleFilter().

                                                                                             {
     if (fParticleMaxMomentum[index] > 0 && particle->Momentum(0).Vect().Mag() > fParticleMaxMomentum[index]) return false;
     return true;
   }

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 filt::LArG4ParticleFilter::MinMomentumCheck	(	const art::Ptr< simb::MCParticle >	particle,
		int	index
	)

private

Definition at line 140 of file LArG4ParticleFilter_module.cc.

References fParticleMinMomentum, and simb::MCParticle::Momentum().

Referenced by IsInterestingParticle(), and ~LArG4ParticleFilter().

                                                                                             {
     if (fParticleMinMomentum[index] > 0 && particle->Momentum(0).Vect().Mag() < fParticleMinMomentum[index]) return false;
     return true;
   }

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

bool filt::LArG4ParticleFilter::PDGCheck	(	const art::Ptr< simb::MCParticle >	particle,
		int	index
	)

private

Definition at line 133 of file LArG4ParticleFilter_module.cc.

References fInterestingPDGs, and simb::MCParticle::PdgCode().

Referenced by IsInterestingParticle(), and ~LArG4ParticleFilter().

                                                                                     {
     int pdg = fInterestingPDGs[index];
     if (pdg == 0) return true; //User does not care what the PDG is
     if (particle->PdgCode() != pdg) return false;
     return true;
   }

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 filt::LArG4ParticleFilter::reconfigure ( fhicl::ParameterSet const & pset )

Definition at line 68 of file LArG4ParticleFilter_module.cc.

References fInterestingPDGs, fParticleMaxMomentum, fParticleMinMomentum, fParticleMinTPCLength, fRequireAllInterestingParticles, fStopInTPC, and fhicl::ParameterSet::get().

Referenced by ~LArG4ParticleFilter().

                                                                     {
     fInterestingPDGs = pset.get<std::vector<int> >("InterestingPDGs");
     fParticleMinMomentum = pset.get<std::vector<double> >("ParticleMinMomentum");
     fParticleMaxMomentum = pset.get<std::vector<double> >("ParticleMaxMomentum");
     fStopInTPC = pset.get<std::vector<int> >("StopInTPC");
     fParticleMinTPCLength = pset.get<std::vector<double> >("ParticleMinTPCLength");
     fRequireAllInterestingParticles = pset.get<bool>("RequireAllInterestingParticles");
     return;
   }

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

bool filt::LArG4ParticleFilter::StartInTPCCheck	(	const art::Ptr< simb::MCParticle >	particle,
		int	index
	)

private

Definition at line 150 of file LArG4ParticleFilter_module.cc.

References fGeom, geo::GeometryCore::FindTPCAtPosition(), fStartInTPC, geo::CryostatID::isValid, and simb::MCParticle::Position().

Referenced by ~LArG4ParticleFilter().

                                                                                            {
     //Firstly check if we even care if the particle starts in the TPC or not
     int demand = fStartInTPC[index];
     if (demand == 0) return true; //We don't care if the particle starts in the TPC or not so pass the check
     //Get starting position of particle
     TLorentzVector starting_position_4vect = particle->Position(0);
     double starting_position[3];
     starting_position[0] = starting_position_4vect.X();
     starting_position[1] = starting_position_4vect.Y();
     starting_position[2] = starting_position_4vect.Z();
 
     geo::TPCID tpcid = fGeom->FindTPCAtPosition(starting_position);
     bool validtpc = tpcid.isValid;
     //Now we need to compare if we have a TPC that we started in with whether we wanted to start in a TPC at all
     if (validtpc){
       //The particle DID start in a TPC.  Now, did we WANT this to happen
       if (demand == 1) return true; //We DID want this to happen
       else return false;
     }
     else{
       //The particle did NOT start in a TPC.  Did we WANT this to happen?
       if (demand == 2) return true; //We DID want this to happen
       else return false;
     }
 
     //Assume true by default
     return true;
   }

bool filt::LArG4ParticleFilter::StopInTPCCheck	(	const art::Ptr< simb::MCParticle >	particle,
		int	index
	)

private

Definition at line 180 of file LArG4ParticleFilter_module.cc.

References fGeom, geo::GeometryCore::FindTPCAtPosition(), fStopInTPC, geo::CryostatID::isValid, simb::MCParticle::NumberTrajectoryPoints(), and simb::MCParticle::Position().

Referenced by IsInterestingParticle(), and ~LArG4ParticleFilter().

                                                                                           {
     //Firstly check if we even care if the particle stops in the TPC or not
     int demand = fStopInTPC[index];
     if (demand == 0) return true; //We don't care if the particle stops in the TPC or not so pass the check
     //Get final position of particle
     TLorentzVector final_position_4vect = particle->Position(particle->NumberTrajectoryPoints()-1);
     double final_position[3];
     final_position[0] = final_position_4vect.X();
     final_position[1] = final_position_4vect.Y();
     final_position[2] = final_position_4vect.Z();
 
     geo::TPCID tpcid = fGeom->FindTPCAtPosition(final_position);
     bool validtpc = tpcid.isValid;
     //Now we need to compare if we have a TPC that we stopped in with whether we wanted to stop in a TPC at all
     if (validtpc){
       //The particle DID stop in a TPC.  Now, did we WANT this to happen
       if (demand == 1) return true; //We DID want this to happen
       else return false;
     }
     else{
       //The particle did NOT stop in a TPC.  Did we WANT this to happen?
       if (demand == 2) return true; //We DID want this to happen
       else return false;
     }
 
     //Assume true by default
     return true;
   }

bool filt::LArG4ParticleFilter::TPCTrajLengthCheck	(	const art::Ptr< simb::MCParticle >	particle,
		int	index
	)

private

Definition at line 209 of file LArG4ParticleFilter_module.cc.

References CalculateLength(), fGeom, geo::GeometryCore::FindTPCAtPosition(), fParticleMinTPCLength, geo::CryostatID::isValid, simb::MCParticle::NumberTrajectoryPoints(), and simb::MCParticle::Position().

Referenced by IsInterestingParticle(), and ~LArG4ParticleFilter().

                                                                                               {
     double min_traj_length = fParticleMinTPCLength[index];
 
     //Firstly, if we don't care about the TPC trajectory length then pass the check
     if (min_traj_length < 0) return true;
 
     //Now the hard bit
     //To do this, we need to collect the sequential particle positions which are contained in the TPC into segments.  The reason for doing this is that the particle may enter a TPC, leave it and enter it again and if this isn't taken into account, the length might be grossly overestimated
     //It is easiest to store the positions in a vector of vectors
     bool OK = false;
     std::vector< std::vector<TVector3> > position_segments;
     //We are also going to need an empty vector to store in the above vector
     std::vector<TVector3> position_segment;
     //Loop through the trajectory points
     for (unsigned int i = 0; i < particle->NumberTrajectoryPoints(); i++){
       //Extract the current position of the particle
       double curr_pos[3];
       curr_pos[0] = particle->Position(i).X();
       curr_pos[1] = particle->Position(i).Y();
       curr_pos[2] = particle->Position(i).Z();
       geo::TPCID curr_tpcid = fGeom->FindTPCAtPosition(curr_pos);
       //There are a couple of things to check here.  If the particle is currently in the TPC, then we need to store that particular position.  If it is NOT in the TPC, then its either exited the TPC or has not yet entered.  If it has just exited, then the position_segment should have some positions stored in it, it which case we now need to store this segment.  If it has not yet entered the TPC, then we don't need to do anything
       //If it is currently in the TPC
       if (curr_tpcid.isValid) position_segment.push_back(particle->Position(i).Vect());
       //It has just exited the TPC
       else if (position_segment.size() > 0){
         //Store the segment
         position_segments.push_back(position_segment);
         //Now reset the segment
         position_segment.clear();
       }
       //There is nothing to do because the particle has remained outside of the TPC
     }
     //We need to check once more if the position_segment vector has been filled
     if (position_segment.size() > 0){
       position_segments.push_back(position_segment);
       position_segment.clear();
     }
     //Now lets check the length of each segment
     //Firstly, if we didn't store a segment then the particle fails the check
     if (position_segments.size() == 0) return false;
     //Now loop through the segments and check if they are above threshold
     for (unsigned int i = 0; i < position_segments.size(); i++){
       double segment_length = CalculateLength(position_segments[i]);
       if (segment_length > min_traj_length){
         //We found a track segment in the TPC which passes the length threshold so don't flag as bad
         OK = true;
         break;
       }
     }
     if (!OK) return false;
 
     return true;
   }

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