Inheritance diagram for cosmic::CosmicPCAxisTagger:

Public Types
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

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

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

virtual	~CosmicPCAxisTagger ()

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 Types
typedef std::vector< reco::ClusterHit2D >	Hit2DVector

Private Member Functions
void	RecobToClusterHits (const art::PtrVector< recob::Hit > &recobHitVec, Hit2DVector &clusterHitVec, reco::Hit2DListPtr &hit2DListPtr) const

Private Attributes
std::string	fPFParticleModuleLabel

std::string	fPCAxisModuleLabel

detinfo::DetectorProperties const *	fDetector
	Pointer to the detector properties. More...

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 60 of file CosmicPCAxisTagger_module.cc.

Member Typedef Documentation

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

private

Definition at line 73 of file CosmicPCAxisTagger_module.cc.

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

explicit

Definition at line 91 of file CosmicPCAxisTagger_module.cc.

References reconfigure().

                                                                         :
         fDetector(lar::providerFrom<detinfo::DetectorPropertiesService>()),
         fPcaAlg(p.get<fhicl::ParameterSet>("PrincipalComponentsAlg"))
 // :
 // Initialize member data here.
 {
     this->reconfigure(p);
 
     // Call appropriate Produces<>() functions here.
     produces< std::vector<anab::CosmicTag> >();
     produces< art::Assns<recob::PFParticle, anab::CosmicTag> >();
     produces< art::Assns<recob::PCAxis,     anab::CosmicTag> >();
 }

cosmic::CosmicPCAxisTagger::~CosmicPCAxisTagger ( )

virtual

Definition at line 105 of file CosmicPCAxisTagger_module.cc.

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

Member Function Documentation

void cosmic::CosmicPCAxisTagger::beginJob ( )

overridevirtual

Reimplemented from art::EDProducer.

Definition at line 394 of file CosmicPCAxisTagger_module.cc.

395 {

396 }

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::CosmicPCAxisTagger::endJob ( )

overridevirtual

Reimplemented from art::EDProducer.

Definition at line 427 of file CosmicPCAxisTagger_module.cc.

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

overridevirtual

Implements art::EDProducer.

Definition at line 110 of file CosmicPCAxisTagger_module.cc.

References util::CreateAssn(), fDetectorWidthTicks, fDetHalfHeight, fDetLength, fDetWidth, fPCAxisModuleLabel, fPFParticleModuleLabel, fTPCXBoundary, fTPCYBoundary, fTPCZBoundary, recob::PCAxis::getAvePosition(), art::DataViewImpl::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);
         
         // Require the PFParticle be a primary because attached hits will be daughter particles
         //if (!pfParticle->IsPrimary()) continue;
         // Oops! Don't do this unless traversing the heirarchy!
         
         // 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->StartTick() < fDetectorWidthTicks || hit->EndTick() > 2.*fDetectorWidthTicks)
                 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 > 10. && transRMS < 10. && transRMS / eigenVal0 < 0.1)
             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(*this, evt, *cosmicTagPFParticleVector, pfParticle, *assnOutCosmicTagPFParticle );
 
         // Loop through the tracks resulting from this PFParticle and mark them
         for(const auto& axis : pcAxisVec)
         {
             util::CreateAssn(*this, evt, *cosmicTagPFParticleVector, axis, *assnOutCosmicTagPCAxis );
         }
     }
     
     evt.put( std::move(cosmicTagPFParticleVector)  );
     evt.put( std::move(assnOutCosmicTagPFParticle) );
     evt.put( std::move(assnOutCosmicTagPCAxis)     );
     
     return;
 
 } // end of produce

void cosmic::CosmicPCAxisTagger::RecobToClusterHits	(	const art::PtrVector< recob::Hit > &	recobHitVec,
		Hit2DVector &	clusterHitVec,
		reco::Hit2DListPtr &	hit2DListPtr
	)		const

private

Takes the input vector of recob::Hits and returns a vector of Cluster2D hits

Definition at line 432 of file CosmicPCAxisTagger_module.cc.

References detinfo::DetectorProperties::ConvertTicksToX(), DEFINE_ART_MODULE, fDetector, detinfo::DetectorProperties::GetXTicksOffset(), geo::kU, geo::kV, geo::kW, art::PtrVector< T >::size(), and detinfo::DetectorProperties::TriggerOffset().

 {
     // We'll need the offsets for each plane
     std::map<geo::View_t, double> viewOffsetMap;
     
     viewOffsetMap[geo::kU] = fDetector->GetXTicksOffset(geo::kU, 0, 0)-fDetector->TriggerOffset();
     viewOffsetMap[geo::kV] = fDetector->GetXTicksOffset(geo::kV, 0, 0)-fDetector->TriggerOffset();
     viewOffsetMap[geo::kW] = fDetector->GetXTicksOffset(geo::kW, 0, 0)-fDetector->TriggerOffset();
     
     // Reserve memory for the hit vector - this is the container of the actual hits
     clusterHitVec.reserve(recobHitVec.size());
     
     // Reserve memory for the list of pointers to these hits - what we'll operate on
     
     // Cycle through the recob hits to build ClusterHit2D objects and insert
     // them into the map
     for(const auto& recobHit : recobHitVec)
     {
         const geo::WireID& hitWireID(recobHit->WireID());
         
         double hitPeakTime(recobHit->PeakTime() - viewOffsetMap[recobHit->View()]);
         double xPosition(fDetector->ConvertTicksToX(recobHit->PeakTime(), hitWireID.Plane, hitWireID.TPC, hitWireID.Cryostat));
         
         clusterHitVec.emplace_back(reco::ClusterHit2D(0, 0., 0., xPosition, hitPeakTime, *recobHit));
         hit2DListPtr.emplace_back(&clusterHitVec.back());
     }
     
     return;
 }

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

Definition at line 398 of file CosmicPCAxisTagger_module.cc.

References detinfo::DetectorProperties::DriftVelocity(), detinfo::DetectorProperties::Efield(), fDetector, fDetectorWidthTicks, fDetHalfHeight, fDetLength, fDetWidth, fPcaAlg, fPCAxisModuleLabel, fPFParticleModuleLabel, fTPCXBoundary, fTPCYBoundary, fTPCZBoundary, fhicl::ParameterSet::get(), lar_cluster3d::PrincipalComponentsAlg::reconfigure(), detinfo::DetectorProperties::SamplingRate(), and detinfo::DetectorProperties::Temperature().

Referenced by CosmicPCAxisTagger().

 {
     // Implementation of optional member function here.
   
     fDetector = lar::providerFrom<detinfo::DetectorPropertiesService>();
     art::ServiceHandle<geo::Geometry> geo;
     
     fDetHalfHeight = geo->DetHalfHeight();
     fDetWidth      = 2.*geo->DetHalfWidth();
     fDetLength     = geo->DetLength();
 
     float fSamplingRate = fDetector->SamplingRate();
 
     fPFParticleModuleLabel = p.get<std::string >("PFParticleModuleLabel");
     fPCAxisModuleLabel     = p.get< std::string >("PCAxisModuleLabel");
     
     fPcaAlg.reconfigure(p.get<fhicl::ParameterSet>("PrincipalComponentsAlg"));
 
     fTPCXBoundary = p.get< float >("TPCXBoundary", 5);
     fTPCYBoundary = p.get< float >("TPCYBoundary", 5);
     fTPCZBoundary = p.get< float >("TPCZBoundary", 5);
 
     const double driftVelocity = fDetector->DriftVelocity( fDetector->Efield(), fDetector->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
 }

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