Inheritance diagram for lar_pandora::LArPandoraExternalEventBuilding:

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

	LArPandoraExternalEventBuilding (LArPandoraExternalEventBuilding const &)=delete

	LArPandoraExternalEventBuilding (LArPandoraExternalEventBuilding &&)=delete

LArPandoraExternalEventBuilding &	operator= (LArPandoraExternalEventBuilding const &)=delete

LArPandoraExternalEventBuilding &	operator= (LArPandoraExternalEventBuilding &&)=delete

void	produce (art::Event &evt) 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 Types
typedef std::map< art::Ptr< recob::PFParticle >, art::Ptr< larpandoraobj::PFParticleMetadata > >	PFParticleToMetadata

Private Member Functions
void	CollectPFParticles (const art::Event &evt, PFParticleToMetadata &particlesToMetadata, PFParticleVector &particles) const
	Collect PFParticles from the ART event and their mapping to metadata objects. More...

void	BuildPFParticleMap (const PFParticleToMetadata &particlesToMetadata, PFParticleMap &particleMap) const
	Build mapping from ID to PFParticle for fast navigation through the hierarchy. More...

void	CollectClearCosmicRays (const PFParticleVector &allParticles, const PFParticleToMetadata &particlesToMetadata, const PFParticleMap &particleMap, PFParticleVector &clearCosmics) const
	Collect PFParticles that have been identified as clear cosmic ray muons by pandora. More...

void	CollectSlices (const PFParticleVector &allParticles, const PFParticleToMetadata &particlesToMetadata, const PFParticleMap &particleMap, SliceVector &slices) const
	Collect slices. More...

void	CollectConsolidatedParticles (const PFParticleVector &allParticles, const PFParticleVector &clearCosmics, const SliceVector &slices, PFParticleVector &consolidatedParticles) const
	Get the consolidated collection of particles based on the slice ids. More...

float	GetMetadataValue (const art::Ptr< larpandoraobj::PFParticleMetadata > &metadata, const std::string &key) const
	Query a metadata object for a given key and return the corresponding value. More...

bool	IsTarget (const art::Ptr< larpandoraobj::PFParticleMetadata > &metadata) const
	Query a metadata object to see if it is a target particle. More...

Private Attributes
std::string	m_inputProducerLabel
	Label for the Pandora instance that produced the collections we want to consolidated. More...

std::string	m_trackProducerLabel
	Label for the track producer using the Pandora instance that produced the collections we want to consolidate. More...

std::string	m_showerProducerLabel
	Label for the shower producer using the Pandora instance that produced the collections we want to consolidate. More...

std::string	m_hitProducerLabel
	Label for the hit producer that was used as input to the Pandora instance specified. More...

bool	m_shouldProduceT0s
	If we should produce T0s (relevant when stitching over multiple drift volumes) More...

art::InputTag	m_pandoraTag
	The input tag for the pandora producer. More...

std::unique_ptr< SliceIdBaseTool >	m_sliceIdTool
	The slice id tool. More...

bool	m_useTestBeamMode
	If we should expect a test-beam (instead of a neutrino) slice. More...

std::string	m_targetKey
	The metadata key for a PFParticle to determine if it is the target. More...

std::string	m_scoreKey
	The metadata key for the score of the target slice from Pandora. 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 32 of file LArPandoraExternalEventBuilding_module.cc.

Member Typedef Documentation

typedef std::map<art::Ptr<recob::PFParticle>, art::Ptr<larpandoraobj::PFParticleMetadata> > lar_pandora::LArPandoraExternalEventBuilding::PFParticleToMetadata

private

Definition at line 45 of file LArPandoraExternalEventBuilding_module.cc.

Constructor & Destructor Documentation

lar_pandora::LArPandoraExternalEventBuilding::LArPandoraExternalEventBuilding ( fhicl::ParameterSet const & pset )

explicit

Definition at line 137 of file LArPandoraExternalEventBuilding_module.cc.

                                                                                               :
     EDProducer{pset},
     m_inputProducerLabel(pset.get<std::string>("InputProducerLabel")),
     m_trackProducerLabel(pset.get<std::string>("TrackProducerLabel")),
     m_showerProducerLabel(pset.get<std::string>("ShowerProducerLabel")),
     m_hitProducerLabel(pset.get<std::string>("HitProducerLabel")),
     m_shouldProduceT0s(pset.get<bool>("ShouldProduceT0s")),
     m_pandoraTag(art::InputTag(m_inputProducerLabel)),
     m_sliceIdTool(art::make_tool<SliceIdBaseTool>(pset.get<fhicl::ParameterSet>("SliceIdTool"))),
     m_useTestBeamMode(pset.get<bool>("ShouldUseTestBeamMode", false)),
     m_targetKey(m_useTestBeamMode ? "IsTestBeam" : "IsNeutrino"),
     m_scoreKey(m_useTestBeamMode ? "TestBeamScore" : "NuScore")
 {
     produces< std::vector<recob::PFParticle> >();
     produces< std::vector<recob::SpacePoint> >();
     produces< std::vector<recob::Cluster> >();
     produces< std::vector<recob::Vertex> >();
     produces< std::vector<recob::Slice> >();
     produces< std::vector<recob::Track> >();
     produces< std::vector<recob::Shower> >();
     produces< std::vector<recob::PCAxis> >();
     produces< std::vector<larpandoraobj::PFParticleMetadata> >();
 
     produces< art::Assns<recob::PFParticle, recob::SpacePoint> >();
     produces< art::Assns<recob::PFParticle, recob::Cluster> >();
     produces< art::Assns<recob::PFParticle, recob::Vertex> >();
     produces< art::Assns<recob::PFParticle, recob::Slice> >();
     produces< art::Assns<recob::PFParticle, recob::Track> >();
     produces< art::Assns<recob::PFParticle, recob::Shower> >();
     produces< art::Assns<recob::PFParticle, recob::PCAxis> >();
     produces< art::Assns<recob::PFParticle, larpandoraobj::PFParticleMetadata> >();
     produces< art::Assns<recob::Track, recob::Hit, recob::TrackHitMeta> >();
     produces< art::Assns<recob::Shower, recob::Hit> >();
     produces< art::Assns<recob::Shower, recob::PCAxis> >();
     produces< art::Assns<recob::SpacePoint, recob::Hit> >();
     produces< art::Assns<recob::Cluster, recob::Hit> >();
     produces< art::Assns<recob::Slice, recob::Hit> >();
 
     if (m_shouldProduceT0s)
     {
         produces< std::vector<anab::T0> >();
         produces< art::Assns<recob::PFParticle, anab::T0> >();
     }
     }

lar_pandora::LArPandoraExternalEventBuilding::LArPandoraExternalEventBuilding ( LArPandoraExternalEventBuilding const & )

delete

lar_pandora::LArPandoraExternalEventBuilding::LArPandoraExternalEventBuilding ( LArPandoraExternalEventBuilding && )

delete

Member Function Documentation

void lar_pandora::LArPandoraExternalEventBuilding::BuildPFParticleMap	(	const PFParticleToMetadata &	particlesToMetadata,
		PFParticleMap &	particleMap
	)		const

private

Build mapping from ID to PFParticle for fast navigation through the hierarchy.

Parameters

particlesToMetadata	the input mapping from PFParticles to their metadata
particleMap	the output mapping from ID to PFParticle

Definition at line 236 of file LArPandoraExternalEventBuilding_module.cc.

 {
     for (const auto &entry : particlesToMetadata)
     {
         if (!particleMap.insert(PFParticleMap::value_type(entry.first->Self(), entry.first)).second)
             throw cet::exception("LArPandoraExternalEventBuilding") << "Repeated PFParticles" << std::endl;
     }
 }

void lar_pandora::LArPandoraExternalEventBuilding::CollectClearCosmicRays	(	const PFParticleVector &	allParticles,
		const PFParticleToMetadata &	particlesToMetadata,
		const PFParticleMap &	particleMap,
		PFParticleVector &	clearCosmics
	)		const

private

Collect PFParticles that have been identified as clear cosmic ray muons by pandora.

Parameters

allParticles	input vector of all particles
particlesToMetadata	the input mapping from PFParticles to their metadata
particleMap	the input mapping from ID to PFParticle
clearCosmics	the output vector of clear cosmic rays

Definition at line 247 of file LArPandoraExternalEventBuilding_module.cc.

 {
     for (const auto &part : allParticles)
     {
         // Get the parent of the particle
         const auto parentIt(particlesToMetadata.find(LArPandoraHelper::GetParentPFParticle(particleMap, part)));
         if (parentIt == particlesToMetadata.end())
             throw cet::exception("LArPandoraExternalEventBuilding") << "Found PFParticle without metadata" << std::endl;
 
         // ATTN particles without the "IsClearCosmic" parameter are not clear cosmics
         try
         {
             if (static_cast<bool>(std::round(this->GetMetadataValue(parentIt->second, "IsClearCosmic"))))
                 clearCosmics.push_back(part);
         }
         catch (const cet::exception &)
         {
         }
     }
 }

void lar_pandora::LArPandoraExternalEventBuilding::CollectConsolidatedParticles	(	const PFParticleVector &	allParticles,
		const PFParticleVector &	clearCosmics,
		const SliceVector &	slices,
		PFParticleVector &	consolidatedParticles
	)		const

private

Get the consolidated collection of particles based on the slice ids.

Parameters

allParticles	input vector of all particles
clearCosmics	the input vector of clear cosmic ray muons
slices	the input vector of slices
consolidatedParticles	the output vector of particles to include in the consolidated output

Definition at line 360 of file LArPandoraExternalEventBuilding_module.cc.

 {
     PFParticleVector collectedParticles;
     collectedParticles.insert(collectedParticles.end(), clearCosmics.begin(), clearCosmics.end());
 
     for (const auto &slice : slices)
     {
         const PFParticleVector &particles(slice.IsTaggedAsTarget() ? slice.GetTargetHypothesis() : slice.GetCosmicRayHypothesis());
         collectedParticles.insert(collectedParticles.end(), particles.begin(), particles.end());
     }
 
     // ATTN the collected particles are the ones we want to output, but here we loop over all particles to ensure that the consolidated
     // particles have the same ordering.
     for (const auto &part : allParticles)
     {
         if (std::find(collectedParticles.begin(), collectedParticles.end(), part) != collectedParticles.end())
             consolidatedParticles.push_back(part);
     }
 }

void lar_pandora::LArPandoraExternalEventBuilding::CollectPFParticles	(	const art::Event &	evt,
		PFParticleToMetadata &	particlesToMetadata,
		PFParticleVector &	particles
	)		const

private

Collect PFParticles from the ART event and their mapping to metadata objects.

Parameters

evt	the ART event
particlesToMetadata	the output mapping from PFParticles to their metadata
particles	the output vector of particles

Definition at line 212 of file LArPandoraExternalEventBuilding_module.cc.

 {
     art::Handle<std::vector<recob::PFParticle> > pfParticleHandle;
     evt.getByLabel(m_pandoraTag, pfParticleHandle);
 
     art::FindManyP<larpandoraobj::PFParticleMetadata> pfParticleMetadataAssoc(pfParticleHandle, evt, m_pandoraTag);
 
     for (unsigned int i = 0; i < pfParticleHandle->size(); ++i)
     {
         const art::Ptr<recob::PFParticle> part(pfParticleHandle, i);
         const auto &metadata(pfParticleMetadataAssoc.at(part.key()));
 
         particles.push_back(part);
 
         if (metadata.size() != 1)
             throw cet::exception("LArPandora") << " LArPandoraExternalEventBuilding::CollectPFParticles -- Found a PFParticle without exactly 1 metadata associated." << std::endl;
 
         if (!particlesToMetadata.insert(PFParticleToMetadata::value_type(part, metadata.front())).second)
             throw cet::exception("LArPandoraExternalEventBuilding") << "Repeated PFParticles" << std::endl;
     }
 }

void lar_pandora::LArPandoraExternalEventBuilding::CollectSlices	(	const PFParticleVector &	allParticles,
		const PFParticleToMetadata &	particlesToMetadata,
		const PFParticleMap &	particleMap,
		SliceVector &	slices
	)		const

private

Collect slices.

Parameters

allParticles	input vector of all particles
particlesToMetadata	the input mapping from PFParticles to their metadata
particleMap	the input mapping from ID to PFParticle
slices	the output vector of slices

Definition at line 270 of file LArPandoraExternalEventBuilding_module.cc.

 {
     std::map<unsigned int, float> targetScores;
     std::map<unsigned int, PFParticleVector> crHypotheses;
     std::map<unsigned int, PFParticleVector> targetHypotheses;
     std::vector<unsigned int> usedSliceIds;
 
     // Collect the slice information
     for (const auto &part : allParticles)
     {
         // Find the parent PFParticle
         const auto parentIt(particlesToMetadata.find(LArPandoraHelper::GetParentPFParticle(particleMap, part)));
         if (parentIt == particlesToMetadata.end())
             throw cet::exception("LArPandoraExternalEventBuilding") << "Found PFParticle without metadata" << std::endl;
 
         // Skip PFParticles that are clear cosmics
         try
         {
             if (static_cast<bool>(std::round(this->GetMetadataValue(parentIt->second, "IsClearCosmic"))))
                 continue;
         }
         catch (const cet::exception &)
         {
         }
 
         const unsigned int sliceId(static_cast<unsigned int>(std::round(this->GetMetadataValue(parentIt->second, "SliceIndex"))));
         const float targetScore(this->GetMetadataValue(parentIt->second, m_scoreKey));
 
         // Keep track of the slice IDs we have used, and their corresponding score
         if (std::find(usedSliceIds.begin(), usedSliceIds.end(), sliceId) == usedSliceIds.end())
         {
             usedSliceIds.push_back(sliceId);
 
         // ATTN all PFParticles in the same slice will have the same targetScore
         targetScores[sliceId] = targetScore;
         }
 
         if (this->IsTarget(parentIt->second))
         {
             targetHypotheses[sliceId].push_back(part);
         }
         else
         {
             crHypotheses[sliceId].push_back(part);
         }
     }
 
     // Sort the slice IDs to ensure reproducibility
     std::sort(usedSliceIds.begin(), usedSliceIds.end());
 
     // ATTN: we need to ensure that for each slice there is a cosmic and neutrino hypothesis, even if the pass created no PFOs
     // in such a case we add an empty vector of pfparticles
     const PFParticleVector emptyPFParticleVector;
 
     // Produce the slices
     for (const unsigned int sliceId : usedSliceIds)
     {
         // Get the target score
         const auto targetScoresIter(targetScores.find(sliceId));
         if (targetScoresIter == targetScores.end())
             throw cet::exception("LArPandoraExternalEventBuilding") << "Scrambled slice information - can't find target score with id = " << sliceId << std::endl;
 
         PFParticleVector targetPFParticleVector, crPFParticleVector;
 
         // Get the target hypothesis
         const auto targetHypothesisIter(targetHypotheses.find(sliceId));
         targetPFParticleVector = ((targetHypothesisIter == targetHypotheses.end()) ? emptyPFParticleVector : targetHypothesisIter->second);
 
         // Get the cosmic hypothesis
         const auto crHypothesisIter(crHypotheses.find(sliceId));
         crPFParticleVector = ((crHypothesisIter == crHypotheses.end()) ? emptyPFParticleVector : crHypothesisIter->second);
         slices.emplace_back(targetScoresIter->second, targetPFParticleVector, crPFParticleVector);
     }
 }

float lar_pandora::LArPandoraExternalEventBuilding::GetMetadataValue	(	const art::Ptr< larpandoraobj::PFParticleMetadata > &	metadata,
		const std::string &	key
	)		const

private

Query a metadata object for a given key and return the corresponding value.

Parameters

metadata	the metadata object to query
key	the key to search for

Returns: the value in the metadata corresponding to the input key

Definition at line 347 of file LArPandoraExternalEventBuilding_module.cc.

 {
     const auto &propertiesMap(metadata->GetPropertiesMap());
     const auto &it(propertiesMap.find(key));
 
     if (it == propertiesMap.end())
         throw cet::exception("LArPandoraExternalEventBuilding") << "No key \"" << key << "\" found in metadata properties map" << std::endl;
 
     return it->second;
 }

bool lar_pandora::LArPandoraExternalEventBuilding::IsTarget ( const art::Ptr< larpandoraobj::PFParticleMetadata > & metadata ) const

private

Query a metadata object to see if it is a target particle.

Parameters

metadata the metadata object to query

Returns: boolean - if the particle is a target

Definition at line 382 of file LArPandoraExternalEventBuilding_module.cc.

 {
     try
     {
         return static_cast<bool>(std::round(this->GetMetadataValue(metadata, m_targetKey)));
     }
     catch (const cet::exception &)
     {
         return false;
     }
 }

LArPandoraExternalEventBuilding& lar_pandora::LArPandoraExternalEventBuilding::operator= ( LArPandoraExternalEventBuilding const & )

delete

LArPandoraExternalEventBuilding& lar_pandora::LArPandoraExternalEventBuilding::operator= ( LArPandoraExternalEventBuilding && )

delete

void lar_pandora::LArPandoraExternalEventBuilding::produce ( art::Event & evt )

overridevirtual

Implements art::EDProducer.

Definition at line 184 of file LArPandoraExternalEventBuilding_module.cc.

 {
     PFParticleVector particles;
     PFParticleToMetadata particlesToMetadata;
     this->CollectPFParticles(evt, particlesToMetadata, particles);
 
     PFParticleMap particleMap;
     this->BuildPFParticleMap(particlesToMetadata, particleMap);
 
     PFParticleVector clearCosmics;
     this->CollectClearCosmicRays(particles, particlesToMetadata, particleMap, clearCosmics);
 
     SliceVector slices;
     this->CollectSlices(particles, particlesToMetadata, particleMap, slices);
 
     m_sliceIdTool->ClassifySlices(slices, evt);
 
     PFParticleVector consolidatedParticles;
     this->CollectConsolidatedParticles(particles, clearCosmics, slices, consolidatedParticles);
 
     const LArPandoraEvent::Labels labels(m_inputProducerLabel, m_trackProducerLabel, m_showerProducerLabel, m_hitProducerLabel);
     const LArPandoraEvent consolidatedEvent(LArPandoraEvent(this, &evt, labels, m_shouldProduceT0s), consolidatedParticles);
 
     consolidatedEvent.WriteToEvent();
 }