Creates some dummy PFParticles and associations to clusters. More...

Inheritance diagram for lar::test::AssnsChainPFParticleMaker:

Classes
struct	Config

Public Types
using	Parameters = art::EDProducer::Table< Config >

Public Member Functions
	AssnsChainPFParticleMaker (Parameters const &config)

virtual void	produce (art::Event &event) override

Private Member Functions
std::vector< art::Ptr < recob::Cluster > >	collectClusters (art::Event const &event) const
	Returns a list of clusters to be combined. More...

Private Attributes
std::vector< art::InputTag >	clusterTags
	List of cluster tags. More...

unsigned int	nClustersPerPFO
	Maximum number of clusters per PFO. More...

Detailed Description

Creates some dummy PFParticles and associations to clusters.

Configuration parameters

clusters (list of input tags): collections of the clusters to be used if PFParticles
clustersPerPFO (unsigned integer, default: 3): number of clusters combined into each PFParticle

Definition at line 50 of file AssnsChainPFParticleMaker_module.cc.

Member Typedef Documentation

using lar::test::AssnsChainPFParticleMaker::Parameters = art::EDProducer::Table<Config>

Definition at line 70 of file AssnsChainPFParticleMaker_module.cc.

Constructor & Destructor Documentation

lar::test::AssnsChainPFParticleMaker::AssnsChainPFParticleMaker ( Parameters const & config )

inlineexplicit

Definition at line 72 of file AssnsChainPFParticleMaker_module.cc.

         : EDProducer{config}
         , clusterTags(config().clusters())
         , nClustersPerPFO(config().clustersPerPFO())
         {
           produces<std::vector<recob::PFParticle>>();
           produces<art::Assns<recob::Cluster, recob::PFParticle>>();
         }

Member Function Documentation

std::vector< art::Ptr< recob::Cluster > > lar::test::AssnsChainPFParticleMaker::collectClusters ( art::Event const & event ) const

private

Returns a list of clusters to be combined.

Definition at line 198 of file AssnsChainPFParticleMaker_module.cc.

 {
 
   std::vector<art::Ptr<recob::Cluster>> allClusters;
 
   for (auto const& tag: clusterTags) {
     auto clusters = event.getValidHandle<std::vector<recob::Cluster>>(tag);
 
     std::size_t const nClusters = clusters->size();
     for (std::size_t i = 0; i < nClusters; ++i)
       allClusters.emplace_back(clusters, i);
 
   } // for
 
   return allClusters;
 } // lar::test::AssnsChainPFParticleMaker::collectClusters()

void lar::test::AssnsChainPFParticleMaker::produce ( art::Event & event )

overridevirtual

Definition at line 101 of file AssnsChainPFParticleMaker_module.cc.

                                                               {
 
   //
   // prepare input: merge all hits in a single collection
   //
   std::vector<art::Ptr<recob::Cluster>> clusters = collectClusters(event);
 
   //
   // prepare output
   //
   auto PFOs = std::make_unique<std::vector<recob::PFParticle>>();
   auto clusterPFOassns
     = std::make_unique<art::Assns<recob::Cluster, recob::PFParticle>>();
 
   //
   // create the PFParticles
   //
   unsigned int nPFOs = clusters.size() / nClustersPerPFO;
   if (nPFOs * nClustersPerPFO < clusters.size()) ++nPFOs;
 
   art::PtrMaker<recob::PFParticle> ptrMaker(event);
 
   unsigned int nDaughtersPerParticle = 2;
   unsigned int nParticlesInTier = 1;
   std::size_t firstPFOinThisTier = 0;
   std::size_t firstPFOinNextTier = firstPFOinThisTier + nParticlesInTier;
   std::size_t nextDaughter = firstPFOinNextTier;
   std::vector<std::size_t> parents
     (nPFOs, std::size_t(recob::PFParticle::kPFParticlePrimary));
   for (unsigned int i = 0; i < nPFOs; ++i) {
 
     // prepare for the next tier, if needed
     if (i >= firstPFOinNextTier) {
       firstPFOinThisTier = firstPFOinNextTier;
 
       nParticlesInTier *= nDaughtersPerParticle;
       nDaughtersPerParticle += 1;
       firstPFOinNextTier += nParticlesInTier;
     } // if
 
     //
     // assign clusters to PFO
     //
     std::vector<art::Ptr<recob::Cluster>> PFOclusters;
     std::size_t iCluster = i;
     while (iCluster < clusters.size()) {
       PFOclusters.push_back(clusters[iCluster]);
       iCluster += nPFOs;
     } // while
 
     //
     // generate the PFParticle
     //
     std::size_t const endDaughter
       = std::min(nextDaughter + nDaughtersPerParticle, (std::size_t) nPFOs);
     std::vector<std::size_t> daughters;
     daughters.reserve(endDaughter - nextDaughter);
     while (nextDaughter < endDaughter) {
       parents[nextDaughter] = i;
       daughters.push_back(nextDaughter);
       ++nextDaughter;
     } // while
 
     PFOs->emplace_back(
       11,                  // pdgCode (11 = shower-like)
       i,                   // self
       parents[i],          // parent
       std::move(daughters)
       );
 
     //
     // generate associations
     //
     auto const PFOptr = ptrMaker(i); // art pointer to the new PFParticle
     for (art::Ptr<recob::Cluster> const& cluster: PFOclusters) {
       mf::LogVerbatim("AssnsChainPFParticleMaker")
         << "Associating cluster " << cluster << " with PFO " << PFOptr;
       clusterPFOassns->addSingle(cluster, PFOptr);
     }
 
   } // for
 
   mf::LogInfo("AssnsChainPFParticleMaker")
     << "Created " << PFOs->size() << " particle flow objects with about "
     << nClustersPerPFO << " clusters each from " << clusters.size()
     << " clusters and " << clusterPFOassns->size() << " associations from "
     << clusterTags.size() << " collections";
 
   event.put(std::move(PFOs));
   event.put(std::move(clusterPFOassns));
 
 } // lar::test::AssnsChainClusterMaker::produce()