Inheritance diagram for lar_pandora::LArPandoraShowerCreation:

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

	LArPandoraShowerCreation (LArPandoraShowerCreation const &)=delete

	LArPandoraShowerCreation (LArPandoraShowerCreation &&)=delete

LArPandoraShowerCreation &	operator= (LArPandoraShowerCreation const &)=delete

LArPandoraShowerCreation &	operator= (LArPandoraShowerCreation &&)=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 Member Functions
recob::Shower	BuildShower (const int id, const lar_content::LArShowerPCA &larShowerPCA, const pandora::CartesianVector &vertexPosition) const
	Build a recob::Shower object. More...

recob::PCAxis	BuildPCAxis (const lar_content::LArShowerPCA &larShowerPCA) const
	Build a recob::PCAxis object. More...

Private Attributes
std::string	m_pfParticleLabel
	The pf particle label. More...

bool	m_useAllParticles
	Build a recob::Track for every recob::PFParticle. 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 24 of file LArPandoraShowerCreation_module.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 93 of file LArPandoraShowerCreation_module.cc.

     : EDProducer{pset}
     , m_pfParticleLabel(pset.get<std::string>("PFParticleLabel"))
     , m_useAllParticles(pset.get<bool>("UseAllParticles", false))
   {
     produces<std::vector<recob::Shower>>();
     produces<std::vector<recob::PCAxis>>();
     produces<art::Assns<recob::PFParticle, recob::Shower>>();
     produces<art::Assns<recob::PFParticle, recob::PCAxis>>();
     produces<art::Assns<recob::Shower, recob::Hit>>();
     produces<art::Assns<recob::Shower, recob::PCAxis>>();
   }

lar_pandora::LArPandoraShowerCreation::LArPandoraShowerCreation ( LArPandoraShowerCreation const & )

delete

lar_pandora::LArPandoraShowerCreation::LArPandoraShowerCreation ( LArPandoraShowerCreation && )

delete

Member Function Documentation

recob::PCAxis lar_pandora::LArPandoraShowerCreation::BuildPCAxis ( const lar_content::LArShowerPCA & larShowerPCA ) const

private

Build a recob::PCAxis object.

Parameters

larShowerPCA the lar shower pca parameters extracted from pandora

< SVD Decomposition was successful

< Eigen values from SVD decomposition

< Average position of hits fed to PCA

The three principle axes

< Number of hits in the decomposition, not yet ready

< Average doca of hits used in PCA, not ready yet

< Axis ID, not ready yet

Definition at line 294 of file LArPandoraShowerCreation_module.cc.

   {
     const pandora::CartesianVector& showerCentroid(larShowerPCA.GetCentroid());
     const pandora::CartesianVector& showerDirection(larShowerPCA.GetPrimaryAxis());
     const pandora::CartesianVector& showerSecondaryVector(larShowerPCA.GetSecondaryAxis());
     const pandora::CartesianVector& showerTertiaryVector(larShowerPCA.GetTertiaryAxis());
     const pandora::CartesianVector& showerEigenValues(larShowerPCA.GetEigenValues());
 
     const bool svdOK(true); ///< SVD Decomposition was successful
     const double eigenValues[3] = {
       showerEigenValues.GetX(),
       showerEigenValues.GetY(),
       showerEigenValues.GetZ()}; ///< Eigen values from SVD decomposition
     const double avePosition[3] = {showerCentroid.GetX(),
                                    showerCentroid.GetY(),
                                    showerCentroid.GetZ()}; ///< Average position of hits fed to PCA
 
     std::vector<std::vector<double>> eigenVecs = {
       /// The three principle axes
       {showerDirection.GetX(), showerDirection.GetY(), showerDirection.GetZ()},
       {showerSecondaryVector.GetX(), showerSecondaryVector.GetY(), showerSecondaryVector.GetZ()},
       {showerTertiaryVector.GetX(), showerTertiaryVector.GetY(), showerTertiaryVector.GetZ()}};
 
     // TODO
     const int numHitsUsed(100);     ///< Number of hits in the decomposition, not yet ready
     const double aveHitDoca(0.);    ///< Average doca of hits used in PCA, not ready yet
     const size_t iD(util::kBogusI); ///< Axis ID, not ready yet
 
     return recob::PCAxis(svdOK, numHitsUsed, eigenValues, eigenVecs, avePosition, aveHitDoca, iD);
   }

recob::Shower lar_pandora::LArPandoraShowerCreation::BuildShower	(	const int	id,
		const lar_content::LArShowerPCA &	larShowerPCA,
		const pandora::CartesianVector &	vertexPosition
	)		const

private

Build a recob::Shower object.

Parameters

id	the id code for the shower
larShowerPCA	the lar shower pca parameters extracted from pandora
vertexPosition	the shower vertex position

Definition at line 252 of file LArPandoraShowerCreation_module.cc.

   {
     const pandora::CartesianVector& showerLength(larShowerPCA.GetAxisLengths());
     const pandora::CartesianVector& showerDirection(larShowerPCA.GetPrimaryAxis());
 
     const float length(showerLength.GetX());
     const float openingAngle(
       larShowerPCA.GetPrimaryLength() > 0.f ?
         std::atan(larShowerPCA.GetSecondaryLength() / larShowerPCA.GetPrimaryLength()) :
         0.f);
     const TVector3 direction(
       showerDirection.GetX(), showerDirection.GetY(), showerDirection.GetZ());
     const TVector3 vertex(vertexPosition.GetX(), vertexPosition.GetY(), vertexPosition.GetZ());
 
     // TODO
     const TVector3 directionErr;
     const TVector3 vertexErr;
     const std::vector<double> totalEnergyErr;
     const std::vector<double> dEdx;
     const std::vector<double> dEdxErr;
     const std::vector<double> totalEnergy;
     const int bestplane(0);
 
     return recob::Shower(direction,
                          directionErr,
                          vertex,
                          vertexErr,
                          totalEnergy,
                          totalEnergyErr,
                          dEdx,
                          dEdxErr,
                          bestplane,
                          id,
                          length,
                          openingAngle);
   }

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

delete

LArPandoraShowerCreation& lar_pandora::LArPandoraShowerCreation::operator= ( LArPandoraShowerCreation && )

delete

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

overridevirtual

Implements art::EDProducer.

Definition at line 109 of file LArPandoraShowerCreation_module.cc.

   {
     std::unique_ptr<std::vector<recob::Shower>> outputShowers(new std::vector<recob::Shower>);
     std::unique_ptr<std::vector<recob::PCAxis>> outputPCAxes(new std::vector<recob::PCAxis>);
     std::unique_ptr<art::Assns<recob::PFParticle, recob::Shower>> outputParticlesToShowers(
       new art::Assns<recob::PFParticle, recob::Shower>);
     std::unique_ptr<art::Assns<recob::PFParticle, recob::PCAxis>> outputParticlesToPCAxes(
       new art::Assns<recob::PFParticle, recob::PCAxis>);
     std::unique_ptr<art::Assns<recob::Shower, recob::Hit>> outputShowersToHits(
       new art::Assns<recob::Shower, recob::Hit>);
     std::unique_ptr<art::Assns<recob::Shower, recob::PCAxis>> outputShowersToPCAxes(
       new art::Assns<recob::Shower, recob::PCAxis>);
 
     const art::PtrMaker<recob::Shower> makeShowerPtr(evt);
     const art::PtrMaker<recob::PCAxis> makePCAxisPtr(evt);
 
     int showerCounter(0);
 
     // Organise inputs
     PFParticleVector pfParticleVector, extraPfParticleVector;
     PFParticlesToSpacePoints pfParticlesToSpacePoints;
     PFParticlesToClusters pfParticlesToClusters;
     LArPandoraHelper::CollectPFParticles(
       evt, m_pfParticleLabel, pfParticleVector, pfParticlesToSpacePoints);
     LArPandoraHelper::CollectPFParticles(
       evt, m_pfParticleLabel, extraPfParticleVector, pfParticlesToClusters);
 
     VertexVector vertexVector;
     PFParticlesToVertices pfParticlesToVertices;
     LArPandoraHelper::CollectVertices(evt, m_pfParticleLabel, vertexVector, pfParticlesToVertices);
 
     for (const art::Ptr<recob::PFParticle> pPFParticle : pfParticleVector) {
       // Select shower-like pfparticles
       if (!m_useAllParticles && !LArPandoraHelper::IsShower(pPFParticle)) continue;
 
       // Obtain associated spacepoints
       PFParticlesToSpacePoints::const_iterator particleToSpacePointIter(
         pfParticlesToSpacePoints.find(pPFParticle));
 
       if (pfParticlesToSpacePoints.end() == particleToSpacePointIter) {
         mf::LogDebug("LArPandoraShowerCreation") << "No spacepoints associated to particle ";
         continue;
       }
 
       // Obtain associated clusters
       PFParticlesToClusters::const_iterator particleToClustersIter(
         pfParticlesToClusters.find(pPFParticle));
 
       if (pfParticlesToClusters.end() == particleToClustersIter) {
         mf::LogDebug("LArPandoraShowerCreation") << "No clusters associated to particle ";
         continue;
       }
 
       // Obtain associated vertex
       PFParticlesToVertices::const_iterator particleToVertexIter(
         pfParticlesToVertices.find(pPFParticle));
 
       if ((pfParticlesToVertices.end() == particleToVertexIter) ||
           (1 != particleToVertexIter->second.size())) {
         mf::LogDebug("LArPandoraShowerCreation") << "Unexpected number of vertices for particle ";
         continue;
       }
 
       // Copy information into expected pandora form
       pandora::CartesianPointVector cartesianPointVector;
       for (const art::Ptr<recob::SpacePoint> spacePoint : particleToSpacePointIter->second)
         cartesianPointVector.emplace_back(pandora::CartesianVector(
           spacePoint->XYZ()[0], spacePoint->XYZ()[1], spacePoint->XYZ()[2]));
 
       double vertexXYZ[3] = {0., 0., 0.};
       particleToVertexIter->second.front()->XYZ(vertexXYZ);
       const pandora::CartesianVector vertexPosition(vertexXYZ[0], vertexXYZ[1], vertexXYZ[2]);
 
       // Call pandora "fast" shower fitter
       try {
         // Access centroid of shower via this method
         const lar_content::LArShowerPCA initialLArShowerPCA(
           lar_content::LArPfoHelper::GetPrincipalComponents(cartesianPointVector, vertexPosition));
 
         // Ensure successful creation of all structures before placing results in output containers, remaking LArShowerPCA with updated vertex
         const pandora::CartesianVector& centroid(initialLArShowerPCA.GetCentroid());
         const pandora::CartesianVector& primaryAxis(initialLArShowerPCA.GetPrimaryAxis());
         const pandora::CartesianVector& secondaryAxis(initialLArShowerPCA.GetSecondaryAxis());
         const pandora::CartesianVector& tertiaryAxis(initialLArShowerPCA.GetTertiaryAxis());
         const pandora::CartesianVector& eigenvalues(initialLArShowerPCA.GetEigenValues());
 
         // Project the PFParticle vertex onto the PCA axis
         const pandora::CartesianVector projectedVertexPosition(
           centroid -
           primaryAxis.GetUnitVector() * (centroid - vertexPosition).GetDotProduct(primaryAxis));
 
         // By convention, principal axis should always point away from vertex
         const float testProjection(primaryAxis.GetDotProduct(projectedVertexPosition - centroid));
         const float directionScaleFactor(
           (testProjection > std::numeric_limits<float>::epsilon()) ? -1.f : 1.f);
 
         const lar_content::LArShowerPCA larShowerPCA(centroid,
                                                      primaryAxis * directionScaleFactor,
                                                      secondaryAxis * directionScaleFactor,
                                                      tertiaryAxis * directionScaleFactor,
                                                      eigenvalues);
         const recob::Shower shower(LArPandoraShowerCreation::BuildShower(
           showerCounter++, larShowerPCA, projectedVertexPosition));
         const recob::PCAxis pcAxis(LArPandoraShowerCreation::BuildPCAxis(larShowerPCA));
         outputShowers->emplace_back(shower);
         outputPCAxes->emplace_back(pcAxis);
       }
       catch (const pandora::StatusCodeException&) {
         mf::LogDebug("LArPandoraShowerCreation") << "Unable to extract shower pca";
         continue;
       }
 
       // Output objects
       art::Ptr<recob::Shower> pShower(makeShowerPtr(outputShowers->size() - 1));
       art::Ptr<recob::PCAxis> pPCAxis(makePCAxisPtr(outputPCAxes->size() - 1));
 
       HitVector hitsInParticle;
       LArPandoraHelper::GetAssociatedHits(
         evt, m_pfParticleLabel, particleToClustersIter->second, hitsInParticle);
 
       // Output associations, after output objects are in place
       util::CreateAssn(*this, evt, pShower, pPFParticle, *(outputParticlesToShowers.get()));
       util::CreateAssn(*this, evt, pPCAxis, pPFParticle, *(outputParticlesToPCAxes.get()));
       util::CreateAssn(
         *this, evt, *(outputShowers.get()), hitsInParticle, *(outputShowersToHits.get()));
       util::CreateAssn(*this, evt, pPCAxis, pShower, *(outputShowersToPCAxes.get()));
     }
 
     mf::LogDebug("LArPandora") << "   Number of new showers: " << outputShowers->size()
                                << std::endl;
     mf::LogDebug("LArPandora") << "   Number of new pcaxes:  " << outputPCAxes->size() << std::endl;
 
     evt.put(std::move(outputShowers));
     evt.put(std::move(outputPCAxes));
     evt.put(std::move(outputParticlesToShowers));
     evt.put(std::move(outputParticlesToPCAxes));
     evt.put(std::move(outputShowersToHits));
     evt.put(std::move(outputShowersToPCAxes));
   }