Inheritance diagram for CRHitRemovalByPCA:

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

virtual void	produce (art::Event &e)

virtual void	endJob ()
	End job method. More...

Public Member Functions inherited from art::EDProducer
	EDProducer (fhicl::ParameterSet const &pset)

template<typename Config >
	EDProducer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Producer
virtual	~Producer () noexcept

	Producer (fhicl::ParameterSet const &)

	Producer (Producer const &)=delete

	Producer (Producer &&)=delete

Producer &	operator= (Producer const &)=delete

Producer &	operator= (Producer &&)=delete

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)

Public Member Functions inherited from art::Modifier
	~Modifier () noexcept

	Modifier ()

	Modifier (Modifier const &)=delete

	Modifier (Modifier &&)=delete

Modifier &	operator= (Modifier const &)=delete

Modifier &	operator= (Modifier &&)=delete

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

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)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Member Functions
void	removeTaggedHits (const recob::PFParticle pfParticle, const art::Handle< std::vector< recob::PFParticle > > &pfParticleHandle, const art::FindManyP< recob::Cluster > &partToClusAssns, const art::FindManyP< recob::Hit > &clusToHitAssns, std::set< const recob::PFParticle > &taggedParticles, art::PtrVector< recob::Hit > &hitVec)

Private Attributes
std::string	fCosmicProducerLabel
	Module that produced the PCA based cosmic tags. More...

std::string	fHitProducerLabel
	The full collection of hits. More...

std::string	fPFParticleProducerLabel
	PFParticle producer. More...

double	fCosmicTagThreshold
	Thresholds for tagging. More...

int	fNumEvent
	Number of events seen. More...

int	fNumCRRejects
	Number of tracks produced. More...

Additional Inherited Members
Public Types inherited from art::EDProducer
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >

Static Public Member Functions inherited from art::EDProducer
static void	commitEvent (EventPrincipal &ep, Event &e)

Protected Member Functions inherited from art::ModuleBase
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 ()

Detailed Description

Definition at line 70 of file CRHitRemovalByPCA_module.cc.

Constructor & Destructor Documentation

CRHitRemovalByPCA::CRHitRemovalByPCA ( fhicl::ParameterSet const & pset )

explicit

Constructor.

Arguments:

pset - Fcl parameters.

Definition at line 111 of file CRHitRemovalByPCA_module.cc.

                                                                    :
   EDProducer{pset},
   fNumEvent(0),
   fNumCRRejects(0)
 {
     fCosmicProducerLabel     = pset.get<std::string>("CosmicProducerLabel");
     fHitProducerLabel        = pset.get<std::string>("HitProducerLabel");
     fPFParticleProducerLabel = pset.get<std::string>("PFParticleProducerLabel");
     fCosmicTagThreshold      = pset.get<double>     ("CosmicTagThreshold");
 
     produces<std::vector<recob::Hit> >();
 
     // Report.
     mf::LogInfo("CRHitRemovalByPCA") << "CRHitRemovalByPCA configured\n";
 }

Member Function Documentation

void CRHitRemovalByPCA::endJob ( )

virtual

End job method.

Reimplemented from art::EDProducer.

Definition at line 346 of file CRHitRemovalByPCA_module.cc.

 {
     double aveCRPerEvent = fNumEvent > 0 ? double(fNumCRRejects) / double(fNumEvent) : 0.;
 
     mf::LogInfo("CRHitRemovalByPCA")
         << "CRHitRemovalByPCA statistics:\n"
         << "  Number of events = " << fNumEvent << "\n"
         << "  Number of Cosmic Rays found = " << fNumCRRejects
         << ", " << aveCRPerEvent << " average/event";
 }

void CRHitRemovalByPCA::produce ( art::Event & evt )

virtual

Produce method.

Arguments:

evt - Art event.

This is the primary method. The goal is to produce a list of recob::Hit objects which are a "clean" subset of all hits and which are believed to be due to a neutrino interaction. It does this by considering input CosmicTag objects, relating them to PFParticles/Tracks and removing the hits associated to those objects which are believed to be Cosmic Rays.

Implements art::EDProducer.

Definition at line 140 of file CRHitRemovalByPCA_module.cc.

 {
     ++fNumEvent;
 
     // Start by looking up the original hits
     art::Handle< std::vector<recob::Hit> > hitHandle;
     evt.getByLabel(fHitProducerLabel, hitHandle);
 
     // If there are no hits then there should be no output
     if (!hitHandle.isValid()) return;
 
     // If there are hits then we are going to output something so get a new
     // output hit vector
     std::unique_ptr<std::vector<recob::Hit> > outputHits(new std::vector<recob::Hit>);
 
     // And fill it with the complete original list of hits
     *outputHits = *hitHandle;
 
     // Recover the PFParticles that are responsible for making the tracks
     art::Handle<std::vector<recob::PFParticle> > pfParticleHandle;
     evt.getByLabel(fPFParticleProducerLabel, pfParticleHandle);
 
     // Without a valid collection of PFParticles we can't do the hit removal
     if (!pfParticleHandle.isValid())
     {
         evt.put(std::move(outputHits));
         return;
     }
 
     // Recover the clusters so we can do associations to the hits
     // In theory the clusters come from the same producer as the PFParticles
     art::Handle<std::vector<recob::Cluster> > clusterHandle;
     evt.getByLabel(fPFParticleProducerLabel, clusterHandle);
 
     // If there are no clusters then something is really wrong
     if (!clusterHandle.isValid())
     {
         evt.put(std::move(outputHits));
         return;
     }
 
     // Recover the list of cosmic tags
     art::Handle< std::vector<anab::CosmicTag> > cosmicTagHandle;
     evt.getByLabel(fCosmicProducerLabel, cosmicTagHandle);
 
     // No cosmic tags then nothing to do here
     if (!cosmicTagHandle.isValid() || cosmicTagHandle->empty())
     {
         evt.put(std::move(outputHits));
         return;
     }
 
     // Start recovering the necessary associations
     // Start by finding the associations going from cosmic tags to PFParticles
     art::FindManyP<recob::PFParticle> cosmicTagToPFPartAssns(cosmicTagHandle, evt, fCosmicProducerLabel);
 
     // From PFParticles we go to clusters
     art::FindManyP<recob::Cluster> clusterAssns(pfParticleHandle, evt, fPFParticleProducerLabel);
 
     // Likewise, recover the collection of associations to hits
     art::FindManyP<recob::Hit> clusterHitAssns(clusterHandle, evt, fPFParticleProducerLabel);
 
     // Container to contain the "bad" hits...
     art::PtrVector<recob::Hit> taggedHits;
 
     // No point double counting hits
     std::set<const recob::PFParticle*> taggedSet;
 
     // Start the identification of hits to remove. The outer loop is over the various producers of
     // the CosmicTag objects we're examininig
     for(size_t crIdx = 0; crIdx != cosmicTagHandle->size(); crIdx++)
     {
         art::Ptr<anab::CosmicTag> cosmicTag(cosmicTagHandle, crIdx);
 
             // If this was tagged as a CR muon then we have work to do!
         if (cosmicTag->CosmicScore() > fCosmicTagThreshold)
         {
             // Recover the associated PFParticle
             std::vector<art::Ptr<recob::PFParticle> > pfPartVec = cosmicTagToPFPartAssns.at(crIdx);
 
             if (pfPartVec.empty()) continue;
 
             art::Ptr<recob::PFParticle> pfParticle = pfPartVec.front();
 
             // Again, most likely needless
             if (!pfParticle) continue;
 
             // A cosmic ray must be a primary (by fiat)
             if (!pfParticle->IsPrimary()) continue;
 
             // Avoid double counting if more than one tagger running
             if (taggedSet.find(pfParticle.get()) != taggedSet.end()) continue;
 
             // Remove all hits associated to this particle and its daughters
             removeTaggedHits(pfParticle.get(), pfParticleHandle, clusterAssns, clusterHitAssns, taggedSet, taggedHits);
         }
     }
 
     // Are there any tagged hits?
     if (!taggedHits.empty())
     {
         // First order of business is to attempt to restore any hits which are shared between a tagged
         // CR PFParticle and an untagged one. We can do this by going through the PFParticles and
         // "removing" hits which are in the not tagged set.
         art::PtrVector<recob::Hit> untaggedHits;
 
         for(const auto& pfParticle : *pfParticleHandle)
         {
             if (taggedSet.find(&pfParticle) != taggedSet.end()) continue;
 
             // Recover the clusters associated to the input PFParticle
             std::vector<art::Ptr<recob::Cluster> > clusterVec = clusterAssns.at(pfParticle.Self());
 
             // Loop over the clusters and grab the associated hits
             for(const auto& cluster : clusterVec)
             {
                 std::vector<art::Ptr<recob::Hit> > clusHitVec = clusterHitAssns.at(cluster->ID());
                 untaggedHits.insert(untaggedHits.end(), clusHitVec.begin(), clusHitVec.end());
             }
         }
 
         // Filter out the hits we want to save
         FilterHits(taggedHits, untaggedHits);
 
         // The below is rather ugly but there is an interplay between art::Ptr's and the
         // actual pointers to objects that I might be missing and this is what I see how to do
         // First move all the original art::Ptr hits into a local art::PtrVector
         art::PtrVector<recob::Hit> originalHits;
 
         // Fill this one hit at a time...
         for(size_t hitIdx = 0; hitIdx != hitHandle->size(); hitIdx++)
         {
             art::Ptr<recob::Hit> hit(hitHandle, hitIdx);
 
             originalHits.push_back(hit);
         }
 
         // Remove the cosmic ray tagged hits
         FilterHits(originalHits, taggedHits);
 
         // Clear the current outputHits vector since we're going to refill...
         outputHits->clear();
 
         // Now make the new list of output hits
         for (const auto& hit : originalHits)
         {
             // Kludge to remove out of time hits
             if (hit->StartTick() > 6400 || hit->EndTick() < 3200) continue;
 
             outputHits->emplace_back(*hit);
         }
     }
 
     // Add tracks and associations to event.
     evt.put(std::move(outputHits));
 }

void CRHitRemovalByPCA::removeTaggedHits	(	const recob::PFParticle *	pfParticle,
		const art::Handle< std::vector< recob::PFParticle > > &	pfParticleHandle,
		const art::FindManyP< recob::Cluster > &	partToClusAssns,
		const art::FindManyP< recob::Hit > &	clusToHitAssns,
		std::set< const recob::PFParticle * > &	taggedParticles,
		art::PtrVector< recob::Hit > &	hitVec
	)

private

Hit removal method

Arguments:

pfParticle - the top level PFParticle to have hits removed pfParticleHandle - handle to the PFParticle objects partToClusAssns - list of PFParticle to Cluster associations clusToHitAssns - list of Cluster to Hit associations hitVec - the current list of hits

This recursively called method will remove all hits associated to an input PFParticle and, in addition, will call itself for all daughters of the input PFParticle

Definition at line 312 of file CRHitRemovalByPCA_module.cc.

 {
     // Recover the clusters associated to the input PFParticle
     std::vector<art::Ptr<recob::Cluster> > clusterVec = partToClusAssns.at(pfParticle->Self());
 
     // Record this PFParticle as tagged
     taggedParticles.insert(pfParticle);
 
     // Loop over the clusters and grab the associated hits
     for(const auto& cluster : clusterVec)
     {
         std::vector<art::Ptr<recob::Hit> > clusHitVec = clusToHitAssns.at(cluster->ID());
         hitVec.insert(hitVec.end(), clusHitVec.begin(), clusHitVec.end());
     }
 
     // Loop over the daughters of this particle and remove their hits as well
     for(const auto& daughterId : pfParticle->Daughters())
     {
         art::Ptr<recob::PFParticle> daughter(pfParticleHandle, daughterId);
 
         removeTaggedHits(daughter.get(), pfParticleHandle, partToClusAssns, clusToHitAssns, taggedParticles, hitVec);
     }
 
     return;
 }