cosmic::TrackPFParticleMatch Class Reference

Inheritance diagram for cosmic::TrackPFParticleMatch:

Public Member Functions
	TrackPFParticleMatch (fhicl::ParameterSet const &p)
void	produce (art::Event &e) override
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 Attributes
std::string	fPFParticleModuleLabel
std::string	fTrackModuleLabel

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 30 of file TrackPFParticleMatch_module.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 43 of file TrackPFParticleMatch_module.cc.

  : EDProducer{p}
{
    fPFParticleModuleLabel = p.get< std::string >("PFParticleModuleLabel");
    fTrackModuleLabel      = p.get< std::string >("TrackModuleLabel", "track");

    // Call appropriate Produces<>() functions here.
    produces< art::Assns<recob::Track, recob::PFParticle>>();
}

Member Function Documentation

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

overridevirtual

Implements art::EDProducer.

Definition at line 53 of file TrackPFParticleMatch_module.cc.

{
    // Instatiate the output
    std::unique_ptr< art::Assns<recob::Track, recob::PFParticle > > trackPFParticleAssns( new art::Assns<recob::Track, recob::PFParticle>);

    // Recover handle for PFParticles
    art::Handle<std::vector<recob::PFParticle> > pfParticleHandle;
    evt.getByLabel( fPFParticleModuleLabel, pfParticleHandle);

    // 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(fPFParticleModuleLabel, clusterHandle);

    if (!(pfParticleHandle.isValid() && clusterHandle.isValid()))
    {
        evt.put( std::move(trackPFParticleAssns) );
        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(trackPFParticleAssns) );
        return;
    }

    // The strategy will be to build sets of maps which will enable us to go from hit to either Track or PFParticle
    using HitToTrackMap = std::map<int, std::vector<art::Ptr<recob::Track>>>;   // Allows for hit sharing

    // Build out the track/hit map first
    // Recover the track/hit associations
    art::FindManyP<recob::Hit>  trackHitAssns(trackHandle, evt, fTrackModuleLabel);

    // Get an empty map
    HitToTrackMap hitToTrackMap;

    // Fill it
    for(size_t idx = 0; idx < trackHandle->size(); idx++)
    {
        art::Ptr<recob::Track> track(trackHandle, idx);

        std::vector<art::Ptr<recob::Hit>> trackHitVec = trackHitAssns.at(track.key());

        for (const auto& hitPtr : trackHitVec)
        {
            hitToTrackMap[hitPtr.key()].push_back(track);
        }
    }

    // Now we walk up the remaining list of associations needed to go from CR tags to hits
    // We'll need to go from tracks to PFParticles
    // From PFParticles we go to 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);

    // We'll store this info in a rather complicated data structure...
    using TrackToPFParticleHitMap = std::map<art::Ptr<recob::Track>, std::map<art::Ptr<recob::PFParticle>,std::vector<art::Ptr<recob::Hit>>>>;

    TrackToPFParticleHitMap trackToPFParticleHitMap;

    // Now we go through the PFParticles and match hits to tracks
    for(size_t idx = 0; idx < pfParticleHandle->size(); idx++)
    {
        art::Ptr<recob::PFParticle> pfParticle(pfParticleHandle, idx);

        // Recover associated clusters
        std::vector<art::Ptr<recob::Cluster>> clusterVec = clusterAssns.at(pfParticle.key());

        // Loop through the clusters
        for(const auto& cluster : clusterVec)
        {
            // Recover associated hits
            std::vector<art::Ptr<recob::Hit>> hitVec = clusterHitAssns.at(cluster.key());

            // Loop through hits and look for associated track
            for(const auto& hit : hitVec)
            {
                HitToTrackMap::iterator hitToTrackItr = hitToTrackMap.find(hit.key());

                if (hitToTrackItr != hitToTrackMap.end())
                {
                    for(auto& track : hitToTrackItr->second)
                        trackToPFParticleHitMap[track][pfParticle].push_back(hit);
                }
            }
        }
    }

    // Ok, now we can create the associations
    for (auto& trackMapItr : trackToPFParticleHitMap)
    {
        std::vector<art::Ptr<recob::PFParticle>> pfParticleVec;

        for(auto& pfParticleMapItr : trackMapItr.second)
        {
            // We need to make sure we don't associate the case where the hits are from crossing tracks
            // which would be an illegal association.
            // Two things to check: that more than one view is matched in the hits
            // That some fraction of the matched hits are from the track
            int nHitsPerView[] = {0,0,0};

            for(const auto& hit : pfParticleMapItr.second)
            {
                nHitsPerView[hit->View()]++;
            }

            int nViewsWithHits(0);

            for(auto& nHits : nHitsPerView) if (nHits > 0) nViewsWithHits++;

            if (nViewsWithHits < 2) continue;

            // Get the hits associated to the track again
            std::vector<art::Ptr<recob::Hit>> trackHitVec = trackHitAssns.at(trackMapItr.first.key());

            // Fraction of hits from track shared with PFParticle
            float sharedHitFrac = float(pfParticleMapItr.second.size()) / float(trackHitVec.size());

            if (sharedHitFrac < 0.3) continue;

            // Ok, this is an association to make
            pfParticleVec.push_back(pfParticleMapItr.first);
        }

        util::CreateAssn(*this, evt, trackMapItr.first, pfParticleVec, *trackPFParticleAssns);
    }

    evt.put( std::move(trackPFParticleAssns));

    return;

} // end of produce

Member Data Documentation

std::string cosmic::TrackPFParticleMatch::fPFParticleModuleLabel

private

Definition at line 38 of file TrackPFParticleMatch_module.cc.

std::string cosmic::TrackPFParticleMatch::fTrackModuleLabel

private

Definition at line 39 of file TrackPFParticleMatch_module.cc.

---

The documentation for this class was generated from the following file:

• larana/larana/CosmicRemoval/TrackPFParticleMatch_module.cc