lar_pandora::LArPandoraHelper Class Reference

LArPandoraHelper class. More...

#include <LArPandoraHelper.h>

Public Types
enum	DaughterMode { kIgnoreDaughters = 0, kUseDaughters = 1, kAddDaughters = 2 }
	DaughterMode enumeration. More...

Static Public Member Functions
static void	CollectWires (const art::Event &evt, const std::string &label, WireVector &wireVector)
	Collect the reconstructed wires from the ART event record. More...
static void	CollectHits (const art::Event &evt, const std::string &label, HitVector &hitVector)
	Collect the reconstructed Hits from the ART event record. More...
static void	CollectPFParticles (const art::Event &evt, const std::string &label, PFParticleVector &particleVector)
	Collect the reconstructed PFParticles from the ART event record. More...
static void	CollectSpacePoints (const art::Event &evt, const std::string &label, SpacePointVector &spacePointVector, SpacePointsToHits &spacePointsToHits)
	Collect the reconstructed SpacePoints and associated hits from the ART event record. More...
static void	CollectSpacePoints (const art::Event &evt, const std::string &label, SpacePointVector &spacePointVector, SpacePointsToHits &spacePointsToHits, HitsToSpacePoints &hitsToSpacePoints)
	Collect the reconstructed SpacePoints and associated hits from the ART event record. More...
static void	CollectClusters (const art::Event &evt, const std::string &label, ClusterVector &clusterVector, ClustersToHits &clustersToHits)
	Collect the reconstructed Clusters and associated hits from the ART event record. More...
static void	CollectPFParticles (const art::Event &evt, const std::string &label, PFParticleVector &particleVector, PFParticlesToSpacePoints &particlesToSpacePoints)
	Collect the reconstructed PFParticles and associated SpacePoints from the ART event record. More...
static void	CollectPFParticles (const art::Event &evt, const std::string &label, PFParticleVector &particleVector, PFParticlesToClusters &particlesToClusters)
	Collect the reconstructed PFParticles and associated Clusters from the ART event record. More...
static void	CollectPFParticleMetadata (const art::Event &evt, const std::string &label, PFParticleVector &particleVector, PFParticlesToMetadata &particlesToMetadata)
	Collect the reconstructed PFParticle Metadata from the ART event record. More...
static void	CollectShowers (const art::Event &evt, const std::string &label, ShowerVector &showerVector, PFParticlesToShowers &particlesToShowers)
	Collect the reconstructed PFParticles and associated Showers from the ART event record. More...
static void	CollectShowers (const art::Event &evt, const std::string &label, ShowerVector &showerVector, ShowersToHits &showersToHits)
	Collect the reconstructed Showers and associated Hits from the ART event record. More...
static void	CollectTracks (const art::Event &evt, const std::string &label, TrackVector &trackVector, PFParticlesToTracks &particlesToTracks)
	Collect the reconstructed PFParticles and associated Tracks from the ART event record. More...
static void	CollectTracks (const art::Event &evt, const std::string &label, TrackVector &trackVector, TracksToHits &tracksToHits)
	Collect the reconstructed Tracks and associated Hits from the ART event record. More...
static void	CollectSeeds (const art::Event &evt, const std::string &label, SeedVector &seedVector, PFParticlesToSeeds &particlesToSeeds)
	Collect the reconstructed PFParticles and associated Seeds from the ART event record. More...
static void	CollectSeeds (const art::Event &evt, const std::string &label, SeedVector &seedVector, SeedsToHits &seedsToHits)
	Collect the reconstructed Seeds and associated Hits from the ART event record. More...
static void	CollectVertices (const art::Event &evt, const std::string &label, VertexVector &vertexVector, PFParticlesToVertices &particlesToVertices)
	Collect the reconstructed PFParticles and associated Vertices from the ART event record. More...
static void	BuildPFParticleHitMaps (const PFParticleVector &particleVector, const PFParticlesToSpacePoints &particlesToSpacePoints, const SpacePointsToHits &spacePointsToHits, PFParticlesToHits &particlesToHits, HitsToPFParticles &hitsToParticles, const DaughterMode daughterMode=kUseDaughters)
	Build mapping between PFParticles and Hits using PFParticle/SpacePoint/Hit maps. More...
static void	BuildPFParticleHitMaps (const PFParticleVector &particleVector, const PFParticlesToClusters &particlesToClusters, const ClustersToHits &clustersToHits, PFParticlesToHits &particlesToHits, HitsToPFParticles &hitsToParticles, const DaughterMode daughterMode=kUseDaughters)
	Build mapping between PFParticles and Hits using PFParticle/Cluster/Hit maps. More...
static void	BuildPFParticleHitMaps (const art::Event &evt, const std::string &label_pfpart, const std::string &label_mid, PFParticlesToHits &particlesToHits, HitsToPFParticles &hitsToParticles, const DaughterMode daughterMode=kUseDaughters, const bool useClusters=true)
	Build mapping between PFParticles and Hits starting from ART event record. More...
static void	BuildPFParticleHitMaps (const art::Event &evt, const std::string &label, PFParticlesToHits &particlesToHits, HitsToPFParticles &hitsToParticles, const DaughterMode daughterMode=kUseDaughters, const bool useClusters=true)
	Build mapping between PFParticles and Hits starting from ART event record. More...
static void	CollectCosmicTags (const art::Event &evt, const std::string &label, CosmicTagVector &cosmicTagVector, TracksToCosmicTags &tracksToCosmicTags)
	Collect a vector of cosmic tags from the ART event record. More...
static void	CollectT0s (const art::Event &evt, const std::string &label, T0Vector &t0Vector, PFParticlesToT0s &particlesToT0s)
	Collect a vector of T0s from the ART event record. More...
static void	CollectSimChannels (const art::Event &evt, const std::string &label, SimChannelVector &simChannelVector, bool &areSimChannelsValid)
	Collect a vector of SimChannel objects from the ART event record. More...
static void	CollectMCParticles (const art::Event &evt, const std::string &label, MCParticleVector &particleVector)
	Collect a vector of MCParticle objects from the ART event record. More...
static void	CollectGeneratorMCParticles (const art::Event &evt, const std::string &label, RawMCParticleVector &particleVector)
	Collect a vector of MCParticle objects from the generator in the ART event record. ATTN: This function is needed as accessing generator (opposed to Geant4) level MCParticles requires use of MCTruth block. More...
static void	CollectMCParticles (const art::Event &evt, const std::string &label, MCTruthToMCParticles &truthToParticles, MCParticlesToMCTruth &particlesToTruth)
	Collect truth information from the ART event record. More...
static void	BuildMCParticleHitMaps (const art::Event &evt, const HitVector &hitVector, const SimChannelVector &simChannelVector, HitsToTrackIDEs &hitsToTrackIDEs)
	Collect the links from reconstructed hits to their true energy deposits. More...
static void	BuildMCParticleHitMaps (const HitsToTrackIDEs &hitsToTrackIDEs, const MCTruthToMCParticles &truthToParticles, MCParticlesToHits &particlesToHits, HitsToMCParticles &hitsToParticles, const DaughterMode daughterMode=kUseDaughters)
	Build mapping between Hits and MCParticles, starting from Hit/TrackIDE/MCParticle information. More...
static void	BuildMCParticleHitMaps (const art::Event &evt, const std::string &label, const HitVector &hitVector, MCParticlesToHits &particlesToHits, HitsToMCParticles &hitsToParticles, const DaughterMode daughterMode=kUseDaughters)
	Build mapping between Hits and MCParticles, starting from ART event record. More...
static void	BuildMCParticleHitMaps (const art::Event &evt, const std::string &hitLabel, const std::string &backtrackLabel, HitsToTrackIDEs &hitsToTrackIDEs)
	Get mapping between hits and true energy deposits using back-tracker information. More...
static void	BuildMCParticleHitMaps (const art::Event &evt, const std::string &truthLabel, const std::string &hitLabel, const std::string &backtrackLabel, MCParticlesToHits &particlesToHits, HitsToMCParticles &hitsToParticles, const DaughterMode daughterMode=kUseDaughters)
	Build mapping between Hits and MCParticles, starting from Hit/TrackIDE/MCParticle information. More...
template<typename T >
static void	GetAssociatedHits (const art::Event &evt, const std::string &label, const std::vector< art::Ptr< T >> &inputVector, HitVector &associatedHits, const pandora::IntVector *const indexVector=nullptr)
	Get all hits associated with input clusters. More...
static void	SelectNeutrinoPFParticles (const PFParticleVector &inputParticles, PFParticleVector &outputParticles)
	Select reconstructed neutrino particles from a list of all reconstructed particles. More...
static void	SelectFinalStatePFParticles (const PFParticleVector &inputParticles, PFParticleVector &outputParticles)
	Select final-state reconstructed particles from a list of all reconstructed particles. More...
static void	BuildMCParticleMap (const MCParticleVector &particleVector, MCParticleMap &particleMap)
	Build particle maps for true particles. More...
static void	BuildPFParticleMap (const PFParticleVector &particleVector, PFParticleMap &particleMap)
	Build particle maps for reconstructed particles. More...
static art::Ptr< recob::PFParticle >	GetParentPFParticle (const PFParticleMap &particleMap, const art::Ptr< recob::PFParticle > daughterParticle)
	Return the top-level parent particle by navigating up the chain of parent/daughter associations. More...
static art::Ptr< recob::PFParticle >	GetFinalStatePFParticle (const PFParticleMap &particleMap, const art::Ptr< recob::PFParticle > daughterParticle)
	Return the final-state parent particle by navigating up the chain of parent/daughter associations. More...
static art::Ptr< simb::MCParticle >	GetParentMCParticle (const MCParticleMap &particleMap, const art::Ptr< simb::MCParticle > daughterParticle)
	Return the top-level parent particle by navigating up the chain of parent/daughter associations. More...
static art::Ptr< simb::MCParticle >	GetFinalStateMCParticle (const MCParticleMap &particleMap, const art::Ptr< simb::MCParticle > daughterParticle)
	Return the final-state parent particle by navigating up the chain of parent/daughter associations. More...
static art::Ptr< recob::Track >	GetPrimaryTrack (const PFParticlesToTracks &particlesToTracks, const art::Ptr< recob::PFParticle > particle)
	Return the primary track associated with a PFParticle. More...
static int	GetGeneration (const PFParticleMap &particleMap, const art::Ptr< recob::PFParticle > daughterParticle)
	Return the generation of this particle (first generation if primary) More...
static int	GetParentNeutrino (const PFParticleMap &particleMap, const art::Ptr< recob::PFParticle > daughterParticle)
	Return the parent neutrino PDG code (or zero for cosmics) for a given reconstructed particle. More...
static bool	IsFinalState (const PFParticleMap &particleMap, const art::Ptr< recob::PFParticle > daughterParticle)
	Determine whether a particle has been reconstructed as a final-state particle. More...
static bool	IsNeutrino (const art::Ptr< recob::PFParticle > particle)
	Determine whether a particle has been reconstructed as a neutrino. More...
static bool	IsTrack (const art::Ptr< recob::PFParticle > particle)
	Determine whether a particle has been reconstructed as track-like. More...
static bool	IsShower (const art::Ptr< recob::PFParticle > particle)
	Determine whether a particle has been reconstructed as shower-like. More...
static bool	IsVisible (const art::Ptr< simb::MCParticle > particle)
	Determine whether a particle is visible (i.e. long-lived charged particle) More...
static larpandoraobj::PFParticleMetadata	GetPFParticleMetadata (const pandora::ParticleFlowObject *const pPfo)
	Get metadata associated to a PFO. More...

Detailed Description

LArPandoraHelper class.

Definition at line 119 of file LArPandoraHelper.h.

Member Enumeration Documentation

enum lar_pandora::LArPandoraHelper::DaughterMode

DaughterMode enumeration.

Enumerator
kIgnoreDaughters
kUseDaughters
kAddDaughters

Definition at line 124 of file LArPandoraHelper.h.

                      {
      kIgnoreDaughters = 0, // Only use parent particles
      kUseDaughters = 1,    // Use both parent and daughter partcles
      kAddDaughters = 2     // Absorb daughter particles into parent particles
    };

Member Function Documentation

void lar_pandora::LArPandoraHelper::BuildMCParticleHitMaps ( const art::Event &  evt, const HitVector &  hitVector, const SimChannelVector &  simChannelVector, HitsToTrackIDEs &  hitsToTrackIDEs  )

static

Collect the links from reconstructed hits to their true energy deposits.

Parameters

evt	the art event containers
hitVector	the input vector of reconstructed hits
simChannelVector	the input vector of SimChannels
hitsToTrackIDEs	the out map from hits to true energy deposits

Definition at line 916 of file LArPandoraHelper.cxx.

  {
    auto const clock_data =
      art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);

    SimChannelMap simChannelMap;

    for (SimChannelVector::const_iterator iter = simChannelVector.begin(),
                                          iterEnd = simChannelVector.end();
         iter != iterEnd;
         ++iter) {
      const art::Ptr<sim::SimChannel> simChannel = *iter;
      simChannelMap.insert(SimChannelMap::value_type(simChannel->Channel(), simChannel));
    }

    for (HitVector::const_iterator iter = hitVector.begin(), iterEnd = hitVector.end();
         iter != iterEnd;
         ++iter) {
      const art::Ptr<recob::Hit> hit = *iter;

      SimChannelMap::const_iterator sIter = simChannelMap.find(hit->Channel());
      if (simChannelMap.end() == sIter) continue; // Hit has no truth information [continue]

      // ATTN: Need to convert TDCtick (integer) to TDC (unsigned integer) before passing to simChannel
      const raw::TDCtick_t start_tick(clock_data.TPCTick2TDC(hit->PeakTimeMinusRMS()));
      const raw::TDCtick_t end_tick(clock_data.TPCTick2TDC(hit->PeakTimePlusRMS()));
      const unsigned int start_tdc((start_tick < 0) ? 0 : start_tick);
      const unsigned int end_tdc(end_tick);

      if (start_tdc > end_tdc) continue; // Hit undershoots the readout window [continue]

      const art::Ptr<sim::SimChannel> simChannel = sIter->second;
      const TrackIDEVector trackCollection(simChannel->TrackIDEs(start_tdc, end_tdc));

      if (trackCollection.empty()) continue; // Hit has no truth information [continue]

      for (unsigned int iTrack = 0, iTrackEnd = trackCollection.size(); iTrack < iTrackEnd;
           ++iTrack) {
        const sim::TrackIDE trackIDE = trackCollection.at(iTrack);
        hitsToTrackIDEs[hit].push_back(trackIDE);
      }
    }
  }

void lar_pandora::LArPandoraHelper::BuildMCParticleHitMaps ( const HitsToTrackIDEs &  hitsToTrackIDEs, const MCTruthToMCParticles &  truthToParticles, MCParticlesToHits &  particlesToHits, HitsToMCParticles &  hitsToParticles, const DaughterMode  daughterMode = kUseDaughters  )

static

Build mapping between Hits and MCParticles, starting from Hit/TrackIDE/MCParticle information.

Parameters

hitsToTrackIDEs	the input map from hits to true energy deposits
truthToParticles	the input map of truth information
particlesToHits	the mapping between true particles and reconstructed hits
hitsToParticles	the mapping between reconstructed hits and true particles
daughterMode	treatment of daughter particles in construction of maps

Definition at line 966 of file LArPandoraHelper.cxx.

  {
    // Build mapping between particles and track IDs for parent/daughter navigation
    MCParticleMap particleMap;

    for (MCTruthToMCParticles::const_iterator iter1 = truthToParticles.begin(),
                                              iterEnd1 = truthToParticles.end();
         iter1 != iterEnd1;
         ++iter1) {
      const MCParticleVector& particleVector = iter1->second;
      for (MCParticleVector::const_iterator iter2 = particleVector.begin(),
                                            iterEnd2 = particleVector.end();
           iter2 != iterEnd2;
           ++iter2) {
        const art::Ptr<simb::MCParticle> particle = *iter2;
        particleMap[particle->TrackId()] = particle;
      }
    }

    // Loop over hits and build mapping between reconstructed hits and true particles
    for (HitsToTrackIDEs::const_iterator iter1 = hitsToTrackIDEs.begin(),
                                         iterEnd1 = hitsToTrackIDEs.end();
         iter1 != iterEnd1;
         ++iter1) {
      const art::Ptr<recob::Hit> hit = iter1->first;
      const TrackIDEVector& trackCollection = iter1->second;

      int bestTrackID(-1);
      float bestEnergyFrac(0.f);

      for (TrackIDEVector::const_iterator iter2 = trackCollection.begin(),
                                          iterEnd2 = trackCollection.end();
           iter2 != iterEnd2;
           ++iter2) {
        const sim::TrackIDE& trackIDE = *iter2;
        const int trackID(std::abs(trackIDE.trackID)); // TODO: Find out why std::abs is needed
        const float energyFrac(trackIDE.energyFrac);

        if (energyFrac > bestEnergyFrac) {
          bestEnergyFrac = energyFrac;
          bestTrackID = trackID;
        }
      }

      if (bestTrackID >= 0) {
        MCParticleMap::const_iterator iter3 = particleMap.find(bestTrackID);
        if (particleMap.end() == iter3)
          throw cet::exception("LArPandora") << " PandoraCollector::BuildMCParticleHitMaps --- "
                                                "Found a track ID without an MC Particle ";

        try {
          const art::Ptr<simb::MCParticle> thisParticle = iter3->second;
          const art::Ptr<simb::MCParticle> primaryParticle(
            LArPandoraHelper::GetFinalStateMCParticle(particleMap, thisParticle));
          const art::Ptr<simb::MCParticle> selectedParticle(
            (kAddDaughters == daughterMode) ? primaryParticle : thisParticle);

          if ((kIgnoreDaughters == daughterMode) && (selectedParticle != primaryParticle)) continue;

          if (!(LArPandoraHelper::IsVisible(selectedParticle))) continue;

          particlesToHits[selectedParticle].push_back(hit);
          hitsToParticles[hit] = selectedParticle;
        }
        catch (cet::exception& e) {
        }
      }
    }
  }

void lar_pandora::LArPandoraHelper::BuildMCParticleHitMaps ( const art::Event &  evt, const std::string &  label, const HitVector &  hitVector, MCParticlesToHits &  particlesToHits, HitsToMCParticles &  hitsToParticles, const DaughterMode  daughterMode = kUseDaughters  )

static

Build mapping between Hits and MCParticles, starting from ART event record.

Parameters

evt	the ART event record
label	the label for the truth information in the event
hitVector	the input vector of reconstructed hits
particlesToHits	the output mapping between true particles and reconstructed hits
hitsToParticles	the output mapping between reconstructed hits and true particles
daughterMode	treatment of daughter particles in construction of maps

Definition at line 1043 of file LArPandoraHelper.cxx.

  {
    SimChannelVector simChannelVector;
    MCTruthToMCParticles truthToParticles;
    MCParticlesToMCTruth particlesToTruth;
    HitsToTrackIDEs hitsToTrackIDEs;

    bool areSimChannelsValid(false);
    LArPandoraHelper::CollectSimChannels(evt, label, simChannelVector, areSimChannelsValid);

    LArPandoraHelper::CollectMCParticles(evt, label, truthToParticles, particlesToTruth);
    LArPandoraHelper::BuildMCParticleHitMaps(evt, hitVector, simChannelVector, hitsToTrackIDEs);
    LArPandoraHelper::BuildMCParticleHitMaps(
      hitsToTrackIDEs, truthToParticles, particlesToHits, hitsToParticles, daughterMode);
  }

void lar_pandora::LArPandoraHelper::BuildMCParticleHitMaps ( const art::Event &  evt, const std::string &  hitLabel, const std::string &  backtrackLabel, HitsToTrackIDEs &  hitsToTrackIDEs  )

static

Get mapping between hits and true energy deposits using back-tracker information.

Parameters

evt	the event record
hitLabel	the label of the collection of hits
backtrackLabel	the label of the collection of back-tracker information
hitsToTrackIDEs	the output map between hits and true energy deposits

Definition at line 1067 of file LArPandoraHelper.cxx.

  {
    // Start by getting the collection of Hits
    art::Handle<std::vector<recob::Hit>> theHits;
    evt.getByLabel(hitLabel, theHits);

    if (!theHits.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find hits... " << std::endl;
      return;
    }

    HitVector hitVector;

    for (unsigned int i = 0; i < theHits->size(); ++i) {
      const art::Ptr<recob::Hit> hit(theHits, i);
      hitVector.push_back(hit);
    }

    // Now get the associations between Hits and MCParticles
    std::vector<anab::BackTrackerHitMatchingData const*> backtrackerVector;

    MCParticleVector particleVector;

    art::FindManyP<simb::MCParticle, anab::BackTrackerHitMatchingData> particles_per_hit(
      theHits, evt, backtrackLabel);

    if (!particles_per_hit.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find reco-truth matching... " << std::endl;
      return;
    }

    // Now loop over the hits and build a collection of IDEs
    for (HitVector::const_iterator iter = hitVector.begin(), iterEnd = hitVector.end();
         iter != iterEnd;
         ++iter) {
      const art::Ptr<recob::Hit> hit = *iter;

      particleVector.clear();
      backtrackerVector.clear();
      particles_per_hit.get(hit.key(), particleVector, backtrackerVector);

      for (unsigned int j = 0; j < particleVector.size(); ++j) {
        const art::Ptr<simb::MCParticle> particle = particleVector[j];

        sim::TrackIDE trackIDE;
        trackIDE.trackID = particle->TrackId();
        trackIDE.energy = backtrackerVector[j]->energy;
        trackIDE.energyFrac = backtrackerVector[j]->ideFraction;

        hitsToTrackIDEs[hit].push_back(trackIDE);
      }
    }
  }

void lar_pandora::LArPandoraHelper::BuildMCParticleHitMaps ( const art::Event &  evt, const std::string &  truthLabel, const std::string &  hitLabel, const std::string &  backtrackLabel, MCParticlesToHits &  particlesToHits, HitsToMCParticles &  hitsToParticles, const DaughterMode  daughterMode = kUseDaughters  )

static

Build mapping between Hits and MCParticles, starting from Hit/TrackIDE/MCParticle information.

Parameters

evt	the event record
truthLabel	the label describing the G4 truth information
hitLabel	the label describing the hit collection
backtrackLabel	the label describing the back-tracker information
particlesToHits	the mapping between true particles and reconstructed hits
hitsToParticles	the mapping between reconstructed hits and true particles
daughterMode	treatment of daughter particles in construction of maps

Definition at line 1127 of file LArPandoraHelper.cxx.

  {
    MCTruthToMCParticles truthToParticles;
    MCParticlesToMCTruth particlesToTruth;
    HitsToTrackIDEs hitsToTrackIDEs;

    LArPandoraHelper::CollectMCParticles(evt, truthLabel, truthToParticles, particlesToTruth);
    LArPandoraHelper::BuildMCParticleHitMaps(evt, hitLabel, backtrackLabel, hitsToTrackIDEs);
    LArPandoraHelper::BuildMCParticleHitMaps(
      hitsToTrackIDEs, truthToParticles, particlesToHits, hitsToParticles, daughterMode);
  }

void lar_pandora::LArPandoraHelper::BuildMCParticleMap ( const MCParticleVector &  particleVector, MCParticleMap &  particleMap  )

static

Build particle maps for true particles.

Parameters

particleVector	the input vector of true particles
particleMap	the output mapping between true particle and true track ID

Definition at line 1184 of file LArPandoraHelper.cxx.

  {
    for (MCParticleVector::const_iterator iter = particleVector.begin(),
                                          iterEnd = particleVector.end();
         iter != iterEnd;
         ++iter) {
      const art::Ptr<simb::MCParticle> particle = *iter;
      particleMap[particle->TrackId()] = particle;
      particleMap[particle->TrackId()] = particle;
    }
  }

void lar_pandora::LArPandoraHelper::BuildPFParticleHitMaps ( const PFParticleVector &  particleVector, const PFParticlesToSpacePoints &  particlesToSpacePoints, const SpacePointsToHits &  spacePointsToHits, PFParticlesToHits &  particlesToHits, HitsToPFParticles &  hitsToParticles, const DaughterMode  daughterMode = kUseDaughters  )

static

Build mapping between PFParticles and Hits using PFParticle/SpacePoint/Hit maps.

Parameters

particleVector	the input vector of PFParticle objects
particlesToSpacePoints	the input map from PFParticle to SpacePoint objects
spacePointsToHits	the input map from SpacePoint to Hit objects
particlesToHits	the output map from PFParticle to Hit objects
hitsToParticles	the output map from Hit to PFParticle objects
daughterMode	treatment of daughter particles in construction of maps

Definition at line 523 of file LArPandoraHelper.cxx.

  {
    // Build mapping from particle to particle ID for parent/daughter navigation
    PFParticleMap particleMap;

    for (PFParticleVector::const_iterator iter1 = particleVector.begin(),
                                          iterEnd1 = particleVector.end();
         iter1 != iterEnd1;
         ++iter1) {
      const art::Ptr<recob::PFParticle> particle = *iter1;
      particleMap[particle->Self()] = particle;
    }

    // Loop over hits and build mapping between reconstructed final-state particles and reconstructed hits
    for (PFParticlesToSpacePoints::const_iterator iter1 = particlesToSpacePoints.begin(),
                                                  iterEnd1 = particlesToSpacePoints.end();
         iter1 != iterEnd1;
         ++iter1) {
      const art::Ptr<recob::PFParticle> thisParticle = iter1->first;
      const art::Ptr<recob::PFParticle> particle(
        (kAddDaughters == daughterMode) ?
          LArPandoraHelper::GetFinalStatePFParticle(particleMap, thisParticle) :
          thisParticle);

      if ((kIgnoreDaughters == daughterMode) &&
          !LArPandoraHelper::IsFinalState(particleMap, particle))
        continue;

      const SpacePointVector& spacePointVector = iter1->second;

      for (SpacePointVector::const_iterator iter2 = spacePointVector.begin(),
                                            iterEnd2 = spacePointVector.end();
           iter2 != iterEnd2;
           ++iter2) {
        const art::Ptr<recob::SpacePoint> spacepoint = *iter2;

        SpacePointsToHits::const_iterator iter3 = spacePointsToHits.find(spacepoint);
        if (spacePointsToHits.end() == iter3)
          throw cet::exception("LArPandora") << " PandoraCollector::BuildPFParticleHitMaps --- "
                                                "Found a space point without an associated hit ";

        const art::Ptr<recob::Hit> hit = iter3->second;

        particlesToHits[particle].push_back(hit);
        hitsToParticles[hit] = particle;
      }
    }
  }

void lar_pandora::LArPandoraHelper::BuildPFParticleHitMaps ( const PFParticleVector &  particleVector, const PFParticlesToClusters &  particlesToClusters, const ClustersToHits &  clustersToHits, PFParticlesToHits &  particlesToHits, HitsToPFParticles &  hitsToParticles, const DaughterMode  daughterMode = kUseDaughters  )

static

Build mapping between PFParticles and Hits using PFParticle/Cluster/Hit maps.

Parameters

particleVector	the input vector of PFParticle objects
particlesToClusters	the input map from PFParticle to Cluster objects
clustersToHits	the input map from Cluster to Hit objects
particlesToHits	the output map from PFParticle to Hit objects
hitsToParticles	the output map from Hit to PFParticle objects
daughterMode	treatment of daughter particles in construction of maps

Definition at line 580 of file LArPandoraHelper.cxx.

  {
    // Build mapping from particle to particle ID for parent/daughter navigation
    PFParticleMap particleMap;

    for (PFParticleVector::const_iterator iter1 = particleVector.begin(),
                                          iterEnd1 = particleVector.end();
         iter1 != iterEnd1;
         ++iter1) {
      const art::Ptr<recob::PFParticle> particle = *iter1;
      particleMap[particle->Self()] = particle;
    }

    // Loop over hits and build mapping between reconstructed final-state particles and reconstructed hits
    for (PFParticlesToClusters::const_iterator iter1 = particlesToClusters.begin(),
                                               iterEnd1 = particlesToClusters.end();
         iter1 != iterEnd1;
         ++iter1) {
      const art::Ptr<recob::PFParticle> thisParticle = iter1->first;
      const art::Ptr<recob::PFParticle> particle(
        (kAddDaughters == daughterMode) ?
          LArPandoraHelper::GetFinalStatePFParticle(particleMap, thisParticle) :
          thisParticle);

      if ((kIgnoreDaughters == daughterMode) &&
          !LArPandoraHelper::IsFinalState(particleMap, particle))
        continue;

      const ClusterVector& clusterVector = iter1->second;
      for (ClusterVector::const_iterator iter2 = clusterVector.begin(),
                                         iterEnd2 = clusterVector.end();
           iter2 != iterEnd2;
           ++iter2) {
        const art::Ptr<recob::Cluster> cluster = *iter2;

        ClustersToHits::const_iterator iter3 = clustersToHits.find(cluster);
        if (clustersToHits.end() == iter3)
          throw cet::exception("LArPandora") << " PandoraCollector::BuildPFParticleHitMaps --- "
                                                "Found a space point without an associated hit ";

        const HitVector& hitVector = iter3->second;
        for (HitVector::const_iterator iter4 = hitVector.begin(), iterEnd4 = hitVector.end();
             iter4 != iterEnd4;
             ++iter4) {
          const art::Ptr<recob::Hit> hit = *iter4;

          particlesToHits[particle].push_back(hit);
          hitsToParticles[hit] = particle;
        }
      }
    }
  }

void lar_pandora::LArPandoraHelper::BuildPFParticleHitMaps ( const art::Event &  evt, const std::string &  label_pfpart, const std::string &  label_mid, PFParticlesToHits &  particlesToHits, HitsToPFParticles &  hitsToParticles, const DaughterMode  daughterMode = kUseDaughters, const bool  useClusters = true  )

static

Build mapping between PFParticles and Hits starting from ART event record.

Parameters

evt	the ART event record
label_pfpart	the label for the PFParticle list in the event
label_space	the label for the Intermediate list in the event
particlesToHits	output map from PFParticle to Hit objects
hitsToParticles	output map from Hit to PFParticle objects
daughterMode	treatment of daughter particles in construction of maps
useClusters	choice of intermediate object (true for Clusters, false for SpacePoints)

Definition at line 655 of file LArPandoraHelper.cxx.

  {
    // Use intermediate clusters
    if (useClusters) {
      PFParticleVector particleVector;
      PFParticlesToClusters particlesToClusters;

      ClusterVector clusterVector;
      ClustersToHits clustersToHits;

      LArPandoraHelper::CollectPFParticles(evt, label_pfpart, particleVector, particlesToClusters);
      LArPandoraHelper::CollectClusters(evt, label_middle, clusterVector, clustersToHits);

      LArPandoraHelper::BuildPFParticleHitMaps(particleVector,
                                               particlesToClusters,
                                               clustersToHits,
                                               particlesToHits,
                                               hitsToParticles,
                                               daughterMode);
    }

    // Use intermediate space points
    else {
      PFParticleVector particleVector;
      PFParticlesToSpacePoints particlesToSpacePoints;

      SpacePointVector spacePointVector;
      SpacePointsToHits spacePointsToHits;

      LArPandoraHelper::CollectPFParticles(
        evt, label_pfpart, particleVector, particlesToSpacePoints);
      LArPandoraHelper::CollectSpacePoints(evt, label_middle, spacePointVector, spacePointsToHits);

      LArPandoraHelper::BuildPFParticleHitMaps(particleVector,
                                               particlesToSpacePoints,
                                               spacePointsToHits,
                                               particlesToHits,
                                               hitsToParticles,
                                               daughterMode);
    }
  }

void lar_pandora::LArPandoraHelper::BuildPFParticleHitMaps ( const art::Event &  evt, const std::string &  label, PFParticlesToHits &  particlesToHits, HitsToPFParticles &  hitsToParticles, const DaughterMode  daughterMode = kUseDaughters, const bool  useClusters = true  )

static

Build mapping between PFParticles and Hits starting from ART event record.

Parameters

evt	the ART event record
label	the label for the PFParticle list in the event
particlesToHits	output map from PFParticle to Hit objects
hitsToParticles	output map from Hit to PFParticle objects
daughterMode	treatment of daughter particles in construction of maps
useClusters	choice of intermediate object (true for Clusters, false for SpacePoints)

Definition at line 641 of file LArPandoraHelper.cxx.

  {
    return LArPandoraHelper::BuildPFParticleHitMaps(
      evt, label, label, particlesToHits, hitsToParticles, daughterMode, useClusters);
  }

void lar_pandora::LArPandoraHelper::BuildPFParticleMap ( const PFParticleVector &  particleVector, PFParticleMap &  particleMap  )

static

Build particle maps for reconstructed particles.

Parameters

particleVector	the input vector of reconstructed particles
particleMap	the output mapping between reconstructed particles and particle ID

Definition at line 1200 of file LArPandoraHelper.cxx.

  {
    for (PFParticleVector::const_iterator iter = particleVector.begin(),
                                          iterEnd = particleVector.end();
         iter != iterEnd;
         ++iter) {
      const art::Ptr<recob::PFParticle> particle = *iter;
      particleMap[particle->Self()] = particle;
    }
  }

void lar_pandora::LArPandoraHelper::CollectClusters ( const art::Event &  evt, const std::string &  label, ClusterVector &  clusterVector, ClustersToHits &  clustersToHits  )

static

Collect the reconstructed Clusters and associated hits from the ART event record.

Parameters

evt	the ART event record
label	the label for the SpacePoint list in the event
clusterVector	the output vector of Cluster objects
clustersToHits	the output map from Cluster to Hit objects

Definition at line 164 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<recob::Cluster>> theClusters;
    evt.getByLabel(label, theClusters);

    if (!theClusters.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find clusters... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theClusters->size() << " Clusters " << std::endl;
    }

    art::FindManyP<recob::Hit> theHitAssns(theClusters, evt, label);
    for (unsigned int i = 0; i < theClusters->size(); ++i) {
      const art::Ptr<recob::Cluster> cluster(theClusters, i);
      clusterVector.push_back(cluster);

      const std::vector<art::Ptr<recob::Hit>> hits = theHitAssns.at(i);
      for (unsigned int j = 0; j < hits.size(); ++j) {
        const art::Ptr<recob::Hit> hit = hits.at(j);
        clustersToHits[cluster].push_back(hit);
      }
    }
  }

void lar_pandora::LArPandoraHelper::CollectCosmicTags ( const art::Event &  evt, const std::string &  label, CosmicTagVector &  cosmicTagVector, TracksToCosmicTags &  tracksToCosmicTags  )

static

Collect a vector of cosmic tags from the ART event record.

Parameters

evt	the ART event record
label	the label for the cosmic tag information in the event
cosmicTagVector	output vector of CosmicTag objects
tracksToCosmicTags	output map from tracks to cosmic tags

Definition at line 751 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<anab::CosmicTag>> theCosmicTags;
    evt.getByLabel(label, theCosmicTags);

    if (theCosmicTags.isValid()) {
      art::FindOneP<recob::Track> theCosmicAssns(
        theCosmicTags, evt, label); // We assume there is one tag per algorithm
      for (unsigned int i = 0; i < theCosmicTags->size(); ++i) {
        const art::Ptr<anab::CosmicTag> cosmicTag(theCosmicTags, i);
        const art::Ptr<recob::Track> track = theCosmicAssns.at(i);
        tracksToCosmicTags[track].push_back(
          cosmicTag); // We assume there could be multiple algorithms
        cosmicTagVector.push_back(cosmicTag);
      }
    }
  }

void lar_pandora::LArPandoraHelper::CollectGeneratorMCParticles ( const art::Event &  evt, const std::string &  label, RawMCParticleVector &  particleVector  )

static

Collect a vector of MCParticle objects from the generator in the ART event record. ATTN: This function is needed as accessing generator (opposed to Geant4) level MCParticles requires use of MCTruth block.

Parameters

evt	the ART event record
label	the label for the truth information in the generator
particleVector	the output vector of MCParticle objects

Definition at line 855 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<simb::MCTruth>> mcTruthBlocks;
    evt.getByLabel(label, mcTruthBlocks);

    if (!mcTruthBlocks.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find MC truth blocks from generator... "
                                 << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << mcTruthBlocks->size() << " MC truth blocks "
                                 << std::endl;
    }

    if (mcTruthBlocks->size() != 1)
      throw cet::exception("LArPandora") << " PandoraCollector::CollectGeneratorMCParticles --- "
                                            "Unexpected number of MC truth blocks ";

    const art::Ptr<simb::MCTruth> mcTruth(mcTruthBlocks, 0);

    for (int i = 0; i < mcTruth->NParticles(); ++i) {
      particleVector.push_back(mcTruth->GetParticle(i));
    }
  }

void lar_pandora::LArPandoraHelper::CollectHits ( const art::Event &  evt, const std::string &  label, HitVector &  hitVector  )

static

Collect the reconstructed Hits from the ART event record.

Parameters

evt	the ART event record
label	the label for the Hit list in the event
hitVector	the ouput vector of Hit objects

Definition at line 71 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<recob::Hit>> theHits;
    evt.getByLabel(label, theHits);

    if (!theHits.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find hits... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theHits->size() << " Hits " << std::endl;
    }

    for (unsigned int i = 0; i < theHits->size(); ++i) {
      const art::Ptr<recob::Hit> hit(theHits, i);
      hitVector.push_back(hit);
    }
  }

void lar_pandora::LArPandoraHelper::CollectMCParticles ( const art::Event &  evt, const std::string &  label, MCParticleVector &  particleVector  )

static

Collect a vector of MCParticle objects from the ART event record.

Parameters

evt	the ART event record
label	the label for the truth information in the event
particleVector	the output vector of MCParticle objects

Definition at line 830 of file LArPandoraHelper.cxx.

  {
    art::Handle<RawMCParticleVector> theParticles;
    evt.getByLabel(label, theParticles);

    if (!theParticles.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find MC particles... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theParticles->size() << " MC particles "
                                 << std::endl;
    }

    for (unsigned int i = 0; i < theParticles->size(); ++i) {
      const art::Ptr<simb::MCParticle> particle(theParticles, i);
      particleVector.push_back(particle);
    }
  }

void lar_pandora::LArPandoraHelper::CollectMCParticles ( const art::Event &  evt, const std::string &  label, MCTruthToMCParticles &  truthToParticles, MCParticlesToMCTruth &  particlesToTruth  )

static

Collect truth information from the ART event record.

Parameters

evt	the ART event record
label	the label for the truth information in the event
truthToParticles	output map from MCTruth to MCParticle objects
particlesToTruth	output map from MCParticle to MCTruth objects

Definition at line 886 of file LArPandoraHelper.cxx.

  {
    art::Handle<RawMCParticleVector> theParticles;
    evt.getByLabel(label, theParticles);

    if (!theParticles.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find MC particles... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theParticles->size() << " MC particles "
                                 << std::endl;
    }

    art::FindOneP<simb::MCTruth> theTruthAssns(theParticles, evt, label);

    for (unsigned int i = 0, iEnd = theParticles->size(); i < iEnd; ++i) {
      const art::Ptr<simb::MCParticle> particle(theParticles, i);
      const art::Ptr<simb::MCTruth> truth(theTruthAssns.at(i));
      truthToParticles[truth].push_back(particle);
      particlesToTruth[particle] = truth;
    }
  }

void lar_pandora::LArPandoraHelper::CollectPFParticleMetadata ( const art::Event &  evt, const std::string &  label, PFParticleVector &  particleVector, PFParticlesToMetadata &  particlesToMetadata  )

static

Collect the reconstructed PFParticle Metadata from the ART event record.

Parameters

evt	the ART event record
label	the label for the PFParticle list in the event
particleVector	the output vector of PFParticle objects
particlesToSpacePoints	the output map from PFParticle to PFParticleMetadata objects

Definition at line 262 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<recob::PFParticle>> theParticles;
    evt.getByLabel(label, theParticles);

    if (!theParticles.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find particles... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theParticles->size() << " PFParticles "
                                 << std::endl;
    }

    art::FindManyP<larpandoraobj::PFParticleMetadata> theMetadataAssns(theParticles, evt, label);
    for (unsigned int i = 0; i < theParticles->size(); ++i) {
      const art::Ptr<recob::PFParticle> particle(theParticles, i);
      particleVector.push_back(particle);

      const std::vector<art::Ptr<larpandoraobj::PFParticleMetadata>> pfParticleMetadataList =
        theMetadataAssns.at(i);
      for (unsigned int j = 0; j < pfParticleMetadataList.size(); ++j) {
        const art::Ptr<larpandoraobj::PFParticleMetadata> pfParticleMetadata =
          pfParticleMetadataList.at(j);
        particlesToMetadata[particle].push_back(pfParticleMetadata);
      }
    }
  }

void lar_pandora::LArPandoraHelper::CollectPFParticles ( const art::Event &  evt, const std::string &  label, PFParticleVector &  particleVector  )

static

Collect the reconstructed PFParticles from the ART event record.

Parameters

evt	the ART event record
label	the label for the PFParticle list in the event
particleVector	the output vector of PFParticle objects

Definition at line 95 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<recob::PFParticle>> theParticles;
    evt.getByLabel(label, theParticles);

    if (!theParticles.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find particles... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theParticles->size() << " PFParticles "
                                 << std::endl;
    }

    for (unsigned int i = 0; i < theParticles->size(); ++i) {
      const art::Ptr<recob::PFParticle> particle(theParticles, i);
      particleVector.push_back(particle);
    }
  }

void lar_pandora::LArPandoraHelper::CollectPFParticles ( const art::Event &  evt, const std::string &  label, PFParticleVector &  particleVector, PFParticlesToSpacePoints &  particlesToSpacePoints  )

static

Collect the reconstructed PFParticles and associated SpacePoints from the ART event record.

Parameters

evt	the ART event record
label	the label for the PFParticle list in the event
particleVector	the output vector of PFParticle objects
particlesToSpacePoints	the output map from PFParticle to SpacePoint objects

Definition at line 196 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<recob::PFParticle>> theParticles;
    evt.getByLabel(label, theParticles);

    if (!theParticles.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find particles... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theParticles->size() << " PFParticles "
                                 << std::endl;
    }

    art::FindManyP<recob::SpacePoint> theSpacePointAssns(theParticles, evt, label);
    for (unsigned int i = 0; i < theParticles->size(); ++i) {
      const art::Ptr<recob::PFParticle> particle(theParticles, i);
      particleVector.push_back(particle);

      const std::vector<art::Ptr<recob::SpacePoint>> spacepoints = theSpacePointAssns.at(i);
      for (unsigned int j = 0; j < spacepoints.size(); ++j) {
        const art::Ptr<recob::SpacePoint> spacepoint = spacepoints.at(j);
        particlesToSpacePoints[particle].push_back(spacepoint);
      }
    }
  }

static void lar_pandora::LArPandoraHelper::CollectPFParticles ( const art::Event &  evt, const std::string &  label, PFParticleVector &  particleVector, PFParticlesToClusters &  particlesToClusters  )

static

Collect the reconstructed PFParticles and associated Clusters from the ART event record.

Parameters

evt	the ART event record
label	the label for the PFParticle list in the event
particleVector	the output vector of PFParticle objects
particlesToClusters	the output map from PFParticle to Cluster objects

void lar_pandora::LArPandoraHelper::CollectSeeds ( const art::Event &  evt, const std::string &  label, SeedVector &  seedVector, PFParticlesToSeeds &  particlesToSeeds  )

static

Collect the reconstructed PFParticles and associated Seeds from the ART event record.

Parameters

evt	the ART event record
label	the label for the PFParticle list in the event
seedVector	the output vector of Seed objects
particlesToSeeds	the output map from PFParticle to Seed objects

Definition at line 425 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<recob::Seed>> theSeeds;
    evt.getByLabel(label, theSeeds);

    if (!theSeeds.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find seeds... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theSeeds->size() << " Seeds " << std::endl;
    }

    art::FindManyP<recob::PFParticle> theSeedAssns(theSeeds, evt, label);
    for (unsigned int i = 0; i < theSeeds->size(); ++i) {
      const art::Ptr<recob::Seed> seed(theSeeds, i);
      seedVector.push_back(seed);

      const std::vector<art::Ptr<recob::PFParticle>> particles = theSeedAssns.at(i);
      for (unsigned int j = 0; j < particles.size(); ++j) {
        const art::Ptr<recob::PFParticle> particle = particles.at(j);
        particlesToSeeds[particle].push_back(seed);
      }
    }
  }

static void lar_pandora::LArPandoraHelper::CollectSeeds ( const art::Event &  evt, const std::string &  label, SeedVector &  seedVector, SeedsToHits &  seedsToHits  )

static

Collect the reconstructed Seeds and associated Hits from the ART event record.

Parameters

evt	the ART event record
label	the label for the PFParticle list in the event
seedVector	the output vector of Seed objects
seedsToHits	the output map from Seed to Hit objects

void lar_pandora::LArPandoraHelper::CollectShowers ( const art::Event &  evt, const std::string &  label, ShowerVector &  showerVector, PFParticlesToShowers &  particlesToShowers  )

static

Collect the reconstructed PFParticles and associated Showers from the ART event record.

Parameters

evt	the ART event record
label	the label for the PFParticle list in the event
showerVector	the output vector of Shower objects
particlesToShowers	the output map from PFParticle to Shower objects

Definition at line 297 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<recob::Shower>> theShowers;
    evt.getByLabel(label, theShowers);

    if (!theShowers.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find showers... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theShowers->size() << " Showers " << std::endl;
    }

    art::FindManyP<recob::PFParticle> theShowerAssns(theShowers, evt, label);
    for (unsigned int i = 0; i < theShowers->size(); ++i) {
      const art::Ptr<recob::Shower> shower(theShowers, i);
      showerVector.push_back(shower);

      const std::vector<art::Ptr<recob::PFParticle>> particles = theShowerAssns.at(i);
      for (unsigned int j = 0; j < particles.size(); ++j) {
        const art::Ptr<recob::PFParticle> particle = particles.at(j);
        particlesToShowers[particle].push_back(shower);
      }
    }
  }

static void lar_pandora::LArPandoraHelper::CollectShowers ( const art::Event &  evt, const std::string &  label, ShowerVector &  showerVector, ShowersToHits &  showersToHits  )

static

Collect the reconstructed Showers and associated Hits from the ART event record.

Parameters

evt	the ART event record
label	the label for the PFParticle list in the event
showerVector	the output vector of Shower objects
showersToHits	the output map from Shower to Hit objects

void lar_pandora::LArPandoraHelper::CollectSimChannels ( const art::Event &  evt, const std::string &  label, SimChannelVector &  simChannelVector, bool &  areSimChannelsValid  )

static

Collect a vector of SimChannel objects from the ART event record.

Parameters

evt	the ART event record
label	the label for the truth information in the event
simChannelVector	output vector of SimChannel objects
areSimChannelsValid	boolean parameter indicating if the sim channel collection exists

Definition at line 802 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<sim::SimChannel>> theSimChannels;
    evt.getByLabel(label, theSimChannels);

    if (!theSimChannels.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find sim channels... " << std::endl;
      areSimChannelsValid = false;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theSimChannels->size() << " SimChannels "
                                 << std::endl;
      areSimChannelsValid = true;
    }

    for (unsigned int i = 0; i < theSimChannels->size(); ++i) {
      const art::Ptr<sim::SimChannel> channel(theSimChannels, i);
      simChannelVector.push_back(channel);
    }
  }

void lar_pandora::LArPandoraHelper::CollectSpacePoints ( const art::Event &  evt, const std::string &  label, SpacePointVector &  spacePointVector, SpacePointsToHits &  spacePointsToHits  )

static

Collect the reconstructed SpacePoints and associated hits from the ART event record.

Parameters

evt	the ART event record
label	the label for the SpacePoint list in the event
spacePointVector	the output vector of SpacePoint objects
spacePointsToHits	the output map from SpacePoint to Hit objects

Definition at line 120 of file LArPandoraHelper.cxx.

  {
    HitsToSpacePoints hitsToSpacePoints;
    return LArPandoraHelper::CollectSpacePoints(
      evt, label, spacePointVector, spacePointsToHits, hitsToSpacePoints);
  }

void lar_pandora::LArPandoraHelper::CollectSpacePoints ( const art::Event &  evt, const std::string &  label, SpacePointVector &  spacePointVector, SpacePointsToHits &  spacePointsToHits, HitsToSpacePoints &  hitsToSpacePoints  )

static

Collect the reconstructed SpacePoints and associated hits from the ART event record.

Parameters

evt	the ART event record
label	the label for the SpacePoint list in the event
spacePointVector	the output vector of SpacePoint objects
spacePointsToHits	the output map from SpacePoint to Hit objects
hitsToSpacePoints	the output map from Hit to SpacePoint objects

Definition at line 133 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<recob::SpacePoint>> theSpacePoints;
    evt.getByLabel(label, theSpacePoints);

    if (!theSpacePoints.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find spacepoints... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theSpacePoints->size() << " SpacePoints "
                                 << std::endl;
    }

    art::FindOneP<recob::Hit> theHitAssns(theSpacePoints, evt, label);
    for (unsigned int i = 0; i < theSpacePoints->size(); ++i) {
      const art::Ptr<recob::SpacePoint> spacepoint(theSpacePoints, i);
      spacePointVector.push_back(spacepoint);
      const art::Ptr<recob::Hit> hit = theHitAssns.at(i);
      spacePointsToHits[spacepoint] = hit;
      hitsToSpacePoints[hit] = spacepoint;
    }
  }

void lar_pandora::LArPandoraHelper::CollectT0s ( const art::Event &  evt, const std::string &  label, T0Vector &  t0Vector, PFParticlesToT0s &  particlesToT0s  )

static

Collect a vector of T0s from the ART event record.

Parameters

evt	the ART event record
label	the label for the T0 information in the event
t0Vector	output vector of T0 objects
particlesToT0s	output map from PParticles to T0s

Definition at line 775 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<anab::T0>> theT0s;
    evt.getByLabel(label, theT0s);

    if (theT0s.isValid()) {
      art::FindManyP<recob::PFParticle> theAssns(theT0s, evt, label);
      for (unsigned int i = 0; i < theT0s->size(); ++i) {
        const art::Ptr<anab::T0> theT0(theT0s, i);
        t0Vector.push_back(theT0);

        const std::vector<art::Ptr<recob::PFParticle>> particles = theAssns.at(i);
        for (unsigned int j = 0; j < particles.size(); ++j) {
          const art::Ptr<recob::PFParticle> theParticle = particles.at(j);
          particlesToT0s[theParticle].push_back(
            theT0); // We assume there could be multiple T0s per PFParticle
        }
      }
    }
  }

void lar_pandora::LArPandoraHelper::CollectTracks ( const art::Event &  evt, const std::string &  label, TrackVector &  trackVector, PFParticlesToTracks &  particlesToTracks  )

static

Collect the reconstructed PFParticles and associated Tracks from the ART event record.

Parameters

evt	the ART event record
label	the label for the PFParticle list in the event
trackVector	the output vector of Track objects
particlesToTracks	the output map from PFParticle to Track objects

Definition at line 329 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<recob::Track>> theTracks;
    evt.getByLabel(label, theTracks);

    if (!theTracks.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find tracks... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theTracks->size() << " Tracks " << std::endl;
    }

    art::FindManyP<recob::PFParticle> theTrackAssns(theTracks, evt, label);
    for (unsigned int i = 0; i < theTracks->size(); ++i) {
      const art::Ptr<recob::Track> track(theTracks, i);
      trackVector.push_back(track);

      const std::vector<art::Ptr<recob::PFParticle>> particles = theTrackAssns.at(i);
      for (unsigned int j = 0; j < particles.size(); ++j) {
        const art::Ptr<recob::PFParticle> particle = particles.at(j);
        particlesToTracks[particle].push_back(track);
      }
    }
  }

static void lar_pandora::LArPandoraHelper::CollectTracks ( const art::Event &  evt, const std::string &  label, TrackVector &  trackVector, TracksToHits &  tracksToHits  )

static

Collect the reconstructed Tracks and associated Hits from the ART event record.

Parameters

evt	the ART event record
label	the label for the PFParticle list in the event
trackVector	the output vector of Track objects
tracksToHits	the output map from Track to Hit objects

void lar_pandora::LArPandoraHelper::CollectVertices ( const art::Event &  evt, const std::string &  label, VertexVector &  vertexVector, PFParticlesToVertices &  particlesToVertices  )

static

Collect the reconstructed PFParticles and associated Vertices from the ART event record.

Parameters

evt	the ART event record
label	the label for the PFParticle list in the event
vertexVector	the output vector of Vertex objects
particlesToVertices	the output map from PFParticle to Vertex objects

Definition at line 491 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<recob::Vertex>> theVertices;
    evt.getByLabel(label, theVertices);

    if (!theVertices.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find vertices... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theVertices->size() << " Vertices " << std::endl;
    }

    art::FindManyP<recob::PFParticle> theVerticesAssns(theVertices, evt, label);
    for (unsigned int i = 0; i < theVertices->size(); ++i) {
      const art::Ptr<recob::Vertex> vertex(theVertices, i);
      vertexVector.push_back(vertex);

      const std::vector<art::Ptr<recob::PFParticle>> particles = theVerticesAssns.at(i);
      for (unsigned int j = 0; j < particles.size(); ++j) {
        const art::Ptr<recob::PFParticle> particle = particles.at(j);
        particlesToVertices[particle].push_back(vertex);
      }
    }
  }

void lar_pandora::LArPandoraHelper::CollectWires ( const art::Event &  evt, const std::string &  label, WireVector &  wireVector  )

static

Collect the reconstructed wires from the ART event record.

Parameters

evt	the ART event record
label	the label for the Wire list in the event
wireVector	the ouput vector of Wire objects

Definition at line 47 of file LArPandoraHelper.cxx.

  {
    art::Handle<std::vector<recob::Wire>> theWires;
    evt.getByLabel(label, theWires);

    if (!theWires.isValid()) {
      mf::LogDebug("LArPandora") << "  Failed to find wires... " << std::endl;
      return;
    }
    else {
      mf::LogDebug("LArPandora") << "  Found: " << theWires->size() << " Wires " << std::endl;
    }

    for (unsigned int i = 0; i < theWires->size(); ++i) {
      const art::Ptr<recob::Wire> wire(theWires, i);
      wireVector.push_back(wire);
    }
  }

template<typename T >

template void lar_pandora::LArPandoraHelper::GetAssociatedHits ( const art::Event &  evt, const std::string &  label, const std::vector< art::Ptr< T >> &  inputVector, HitVector &  associatedHits, const pandora::IntVector *const  indexVector = nullptr  )

static

Get all hits associated with input clusters.

Parameters

evt	the event containing the hits
label	the label of the collection producing PFParticles
input	vector input of T (clusters, spacepoints)
associatedHits	output hits associated with T
indexVector	vector of spacepoint indices reflecting trajectory points sorting order

Definition at line 1149 of file LArPandoraHelper.cxx.

  {

    art::Handle<std::vector<T>> handle;
    evt.getByLabel(label, handle);
    art::FindManyP<recob::Hit> hitAssoc(handle, evt, label);

    if (indexVector != nullptr) {
      if (inputVector.size() != indexVector->size())
        throw cet::exception("LArPandora") << " PandoraHelper::GetAssociatedHits --- trying to use "
                                              "an index vector not matching input vector";

      // If indexVector is filled, sort hits according to trajectory points order
      for (int index : (*indexVector)) {
        const art::Ptr<T>& element = inputVector.at(index);
        const HitVector& hits = hitAssoc.at(element.key());
        associatedHits.insert(associatedHits.end(), hits.begin(), hits.end());
      }
    }
    else {
      // If indexVector is empty just loop through inputSpacePoints
      for (const art::Ptr<T>& element : inputVector) {
        const HitVector& hits = hitAssoc.at(element.key());
        associatedHits.insert(associatedHits.end(), hits.begin(), hits.end());
      }
    }
  }

art::Ptr< simb::MCParticle > lar_pandora::LArPandoraHelper::GetFinalStateMCParticle ( const MCParticleMap &  particleMap, const art::Ptr< simb::MCParticle >  daughterParticle  )

static

Return the final-state parent particle by navigating up the chain of parent/daughter associations.

Parameters

particleMap	the mapping between true particle and true track ID
daughterParticle	the input MC particle

Returns

the final-state parent particle

Definition at line 1314 of file LArPandoraHelper.cxx.

  {
    // Navigate upward through MC daughter/parent links - collect this particle and all its parents
    MCParticleVector mcVector;

    int trackID(inputParticle->TrackId());

    while (1) {
      MCParticleMap::const_iterator pIter = particleMap.find(trackID);
      if (particleMap.end() == pIter) break; // Can't find MC Particle for this track ID [break]

      const art::Ptr<simb::MCParticle> particle = pIter->second;
      mcVector.push_back(particle);

      trackID = particle->Mother();
    }

    // Navigate downward through MC parent/daughter links - return the first long-lived charged particle
    for (MCParticleVector::const_reverse_iterator iter = mcVector.rbegin(),
                                                  iterEnd = mcVector.rend();
         iter != iterEnd;
         ++iter) {
      const art::Ptr<simb::MCParticle> nextParticle = *iter;

      if (LArPandoraHelper::IsVisible(nextParticle)) return nextParticle;
    }

    throw cet::exception("LArPandora"); // need to catch this exception
  }

art::Ptr< recob::PFParticle > lar_pandora::LArPandoraHelper::GetFinalStatePFParticle ( const PFParticleMap &  particleMap, const art::Ptr< recob::PFParticle >  daughterParticle  )

static

Return the final-state parent particle by navigating up the chain of parent/daughter associations.

Parameters

particleMap	the mapping between reconstructed particle and particle ID
daughterParticle	the input PF particle

Returns

the final-state parent particle

Definition at line 1247 of file LArPandoraHelper.cxx.

  {
    // Navigate upward through PFO daughter/parent links - return the top-level non-neutrino PF Particle
    int primaryTrackID(inputParticle->Self());

    if (!inputParticle->IsPrimary()) {
      int parentTrackID(inputParticle->Parent());

      while (1) {
        PFParticleMap::const_iterator pIter1 = particleMap.find(parentTrackID);
        if (particleMap.end() == pIter1)
          throw cet::exception("LArPandora") << " PandoraCollector::GetFinalStatePFParticle --- "
                                                "Found a PFParticle without a particle ID ";

        const art::Ptr<recob::PFParticle> parentParticle = pIter1->second;
        if (LArPandoraHelper::IsNeutrino(parentParticle)) break;

        primaryTrackID = parentTrackID;

        if (parentParticle->IsPrimary()) break;

        parentTrackID = parentParticle->Parent();
      }
    }

    PFParticleMap::const_iterator pIter2 = particleMap.find(primaryTrackID);
    if (particleMap.end() == pIter2)
      throw cet::exception("LArPandora") << " PandoraCollector::GetFinalStatePFParticle --- Found "
                                            "a PFParticle without a particle ID ";

    const art::Ptr<recob::PFParticle> outputParticle = pIter2->second;
    return outputParticle;
  }

int lar_pandora::LArPandoraHelper::GetGeneration ( const PFParticleMap &  particleMap, const art::Ptr< recob::PFParticle >  daughterParticle  )

static

Return the generation of this particle (first generation if primary)

Parameters

particleMap	the mapping between reconstructed particle and particle ID
daughterParticle	the input daughter particle

Returns

the nth generation in the particle hierarchy

Definition at line 1368 of file LArPandoraHelper.cxx.

  {
    // Navigate upward through PFO daughter/parent links - return the top-level PF Particle
    int nGenerations(0);
    int primaryTrackID(inputParticle->Self());

    while (1) {
      PFParticleMap::const_iterator pIter = particleMap.find(primaryTrackID);
      if (particleMap.end() == pIter)
        throw cet::exception("LArPandora")
          << " PandoraCollector::GetGeneration --- Found a PFParticle without a particle ID ";

      ++nGenerations;

      const art::Ptr<recob::PFParticle> primaryParticle = pIter->second;
      if (primaryParticle->IsPrimary()) break;

      primaryTrackID = primaryParticle->Parent();
    }

    return nGenerations;
  }

art::Ptr< simb::MCParticle > lar_pandora::LArPandoraHelper::GetParentMCParticle ( const MCParticleMap &  particleMap, const art::Ptr< simb::MCParticle >  daughterParticle  )

static

Return the top-level parent particle by navigating up the chain of parent/daughter associations.

Parameters

particleMap	the mapping between true particle and true track ID
daughterParticle	the input MC particle

Returns

the top-level parent particle

Definition at line 1285 of file LArPandoraHelper.cxx.

  {
    // Navigate upward through MC daughter/parent links - return the top-level MC particle
    int primaryTrackID(inputParticle->TrackId());
    int parentTrackID(inputParticle->Mother());

    while (1) {
      MCParticleMap::const_iterator pIter1 = particleMap.find(parentTrackID);
      if (particleMap.end() == pIter1) break; // Can't find MC Particle for this track ID [break]

      const art::Ptr<simb::MCParticle> particle = pIter1->second;

      primaryTrackID = parentTrackID;
      parentTrackID = particle->Mother();
    }

    MCParticleMap::const_iterator pIter2 = particleMap.find(primaryTrackID);
    if (particleMap.end() == pIter2)
      throw cet::exception("LArPandora")
        << " PandoraCollector::GetParentMCParticle --- Found a track ID without a MC particle ";

    const art::Ptr<simb::MCParticle> outputParticle = pIter2->second;
    return outputParticle;
  }

int lar_pandora::LArPandoraHelper::GetParentNeutrino ( const PFParticleMap &  particleMap, const art::Ptr< recob::PFParticle >  daughterParticle  )

static

Return the parent neutrino PDG code (or zero for cosmics) for a given reconstructed particle.

Parameters

particleMap	the mapping between reconstructed particle and particle ID
daughterParticle	the input daughter particle

Returns

the PDG code of the parent neutrinos (or zero for cosmics)

Definition at line 1395 of file LArPandoraHelper.cxx.

  {
    art::Ptr<recob::PFParticle> parentParticle =
      LArPandoraHelper::GetParentPFParticle(particleMap, daughterParticle);

    if (LArPandoraHelper::IsNeutrino(parentParticle)) return parentParticle->PdgCode();

    if (parentParticle->IsPrimary()) return 0;

    const int parentID(parentParticle->Parent());

    PFParticleMap::const_iterator pIter = particleMap.find(parentID);
    if (particleMap.end() == pIter)
      throw cet::exception("LArPandora")
        << " PandoraCollector::GetParentNeutrino --- Found a PFParticle without a particle ID ";

    const art::Ptr<recob::PFParticle> neutrinoParticle = pIter->second;
    return neutrinoParticle->PdgCode();
  }

art::Ptr< recob::PFParticle > lar_pandora::LArPandoraHelper::GetParentPFParticle ( const PFParticleMap &  particleMap, const art::Ptr< recob::PFParticle >  daughterParticle  )

static

Return the top-level parent particle by navigating up the chain of parent/daughter associations.

Parameters

particleMap	the mapping between reconstructed particle and particle ID
daughterParticle	the input PF particle

Returns

the top-level parent particle

Definition at line 1215 of file LArPandoraHelper.cxx.

  {
    // Navigate upward through PFO daughter/parent links - return the top-level PF Particle
    int primaryTrackID(inputParticle->Self());

    if (!inputParticle->IsPrimary()) {
      while (1) {
        PFParticleMap::const_iterator pIter1 = particleMap.find(primaryTrackID);
        if (particleMap.end() == pIter1)
          throw cet::exception("LArPandora") << " PandoraCollector::GetParentPFParticle --- Found "
                                                "a PFParticle without a particle ID ";

        const art::Ptr<recob::PFParticle> primaryParticle = pIter1->second;
        if (primaryParticle->IsPrimary()) break;

        primaryTrackID = primaryParticle->Parent();
      }
    }

    PFParticleMap::const_iterator pIter2 = particleMap.find(primaryTrackID);
    if (particleMap.end() == pIter2)
      throw cet::exception("LArPandora")
        << " PandoraCollector::GetParentPFParticle --- Found a PFParticle without a particle ID ";

    const art::Ptr<recob::PFParticle> outputParticle = pIter2->second;
    return outputParticle;
  }

larpandoraobj::PFParticleMetadata lar_pandora::LArPandoraHelper::GetPFParticleMetadata ( const pandora::ParticleFlowObject *const  pPfo )

static

Get metadata associated to a PFO.

Parameters

pPfo	input ParticleFlowObject

Returns

larpandoraobj::PFParticleMetadata

Definition at line 1498 of file LArPandoraHelper.cxx.

  {
    return larpandoraobj::PFParticleMetadata(pPfo->GetPropertiesMap());
  }

art::Ptr< recob::Track > lar_pandora::LArPandoraHelper::GetPrimaryTrack ( const PFParticlesToTracks &  particlesToTracks, const art::Ptr< recob::PFParticle >  particle  )

static

Return the primary track associated with a PFParticle.

Parameters

particlesToTracks	the mapping between particles and tracks
particle	the input particle

Definition at line 1348 of file LArPandoraHelper.cxx.

  {
    PFParticlesToTracks::const_iterator tIter = particlesToTracks.find(particle);

    if (particlesToTracks.end() == tIter || tIter->second.empty())
      throw cet::exception("LArPandora")
        << " PandoraCollector::GetPrimaryTrack --- Failed to find associated track ";

    if (tIter->second.size() != 1)
      throw cet::exception("LArPandora")
        << " PandoraCollector::GetPrimaryTrack --- Found more than one associated track ";

    const art::Ptr<recob::Track> primaryTrack = *(tIter->second.begin());
    return primaryTrack;
  }

bool lar_pandora::LArPandoraHelper::IsFinalState ( const PFParticleMap &  particleMap, const art::Ptr< recob::PFParticle >  daughterParticle  )

static

Determine whether a particle has been reconstructed as a final-state particle.

Parameters

particleMap	the mapping between reconstructed particle and particle ID
daughterParticle	the input daughter particle

Returns

true/false

Definition at line 1419 of file LArPandoraHelper.cxx.

  {
    if (LArPandoraHelper::IsNeutrino(daughterParticle)) return false;

    if (daughterParticle->IsPrimary()) return true;

    const int parentID(daughterParticle->Parent());

    PFParticleMap::const_iterator pIter = particleMap.find(parentID);
    if (particleMap.end() == pIter)
      throw cet::exception("LArPandora")
        << " PandoraCollector::IsFinalState --- Found a PFParticle without a particle ID ";

    const art::Ptr<recob::PFParticle> parentParticle = pIter->second;

    if (LArPandoraHelper::IsNeutrino(parentParticle)) return true;

    return false;
  }

bool lar_pandora::LArPandoraHelper::IsNeutrino ( const art::Ptr< recob::PFParticle >  particle )

static

Determine whether a particle has been reconstructed as a neutrino.

Parameters

particle

the input particle

Returns

true/false

Definition at line 1443 of file LArPandoraHelper.cxx.

  {
    const int pdg(particle->PdgCode());

    // electron, muon, tau (use Pandora PDG tables)
    return ((pandora::NU_E == std::abs(pdg)) || (pandora::NU_MU == std::abs(pdg)) ||
            (pandora::NU_TAU == std::abs(pdg)));
  }

bool lar_pandora::LArPandoraHelper::IsShower ( const art::Ptr< recob::PFParticle >  particle )

static

Determine whether a particle has been reconstructed as shower-like.

Parameters

particle

the input particle

Returns

true/false

Definition at line 1467 of file LArPandoraHelper.cxx.

  {
    const int pdg(particle->PdgCode());

    // electron, photon (use Pandora PDG tables)
    return ((pandora::E_MINUS == std::abs(pdg)) || (pandora::PHOTON == std::abs(pdg)));
  }

bool lar_pandora::LArPandoraHelper::IsTrack ( const art::Ptr< recob::PFParticle >  particle )

static

Determine whether a particle has been reconstructed as track-like.

Parameters

particle

the input particle

Returns

true/false

Definition at line 1455 of file LArPandoraHelper.cxx.

  {
    const int pdg(particle->PdgCode());

    // muon, pion, proton, kaon (use Pandora PDG tables)
    return ((pandora::MU_MINUS == std::abs(pdg)) || (pandora::PI_PLUS == std::abs(pdg)) ||
            (pandora::PROTON == std::abs(pdg)) || (pandora::K_PLUS == std::abs(pdg)));
  }

bool lar_pandora::LArPandoraHelper::IsVisible ( const art::Ptr< simb::MCParticle >  particle )

static

Determine whether a particle is visible (i.e. long-lived charged particle)

Parameters

particle

the input mc particle

Returns

true/false

Definition at line 1478 of file LArPandoraHelper.cxx.

  {
    // Include long-lived charged particles
    const int pdg(particle->PdgCode());

    if ((pandora::E_MINUS == std::abs(pdg)) || (pandora::MU_MINUS == std::abs(pdg)) ||
        (pandora::PROTON == std::abs(pdg)) || (pandora::PI_PLUS == std::abs(pdg)) ||
        (pandora::K_PLUS == std::abs(pdg)) || (pandora::SIGMA_MINUS == std::abs(pdg)) ||
        (pandora::SIGMA_PLUS == std::abs(pdg)) || (pandora::HYPERON_MINUS == std::abs(pdg)) ||
        (pandora::PHOTON == std::abs(pdg)) || (pandora::NEUTRON == std::abs(pdg)))
      return true;

    // TODO: What about ions, neutrons, photons? (Have included neutrons and photons for now)

    return false;
  }

void lar_pandora::LArPandoraHelper::SelectFinalStatePFParticles ( const PFParticleVector &  inputParticles, PFParticleVector &  outputParticles  )

static

Select final-state reconstructed particles from a list of all reconstructed particles.

Parameters

inputParticles	the input vector of all particles (it has to be all of them!)
outputParticles	the output vector of final-state particles

Definition at line 722 of file LArPandoraHelper.cxx.

  {
    // Build mapping from particle to particle ID for parent/daughter navigation
    PFParticleMap particleMap;

    for (PFParticleVector::const_iterator iter = inputParticles.begin(),
                                          iterEnd = inputParticles.end();
         iter != iterEnd;
         ++iter) {
      const art::Ptr<recob::PFParticle> particle = *iter;
      particleMap[particle->Self()] = particle;
    }

    // Select final-state particles
    for (PFParticleVector::const_iterator iter = inputParticles.begin(),
                                          iterEnd = inputParticles.end();
         iter != iterEnd;
         ++iter) {
      const art::Ptr<recob::PFParticle> particle = *iter;

      if (LArPandoraHelper::IsFinalState(particleMap, particle))
        outputParticles.push_back(particle);
    }
  }

void lar_pandora::LArPandoraHelper::SelectNeutrinoPFParticles ( const PFParticleVector &  inputParticles, PFParticleVector &  outputParticles  )

static

Select reconstructed neutrino particles from a list of all reconstructed particles.

Parameters

inputParticles	the input vector of all particles (it has to be all of them!)
outputParticles	the output vector of final-state particles

Definition at line 706 of file LArPandoraHelper.cxx.

  {
    for (PFParticleVector::const_iterator iter = inputParticles.begin(),
                                          iterEnd = inputParticles.end();
         iter != iterEnd;
         ++iter) {
      const art::Ptr<recob::PFParticle> particle = *iter;

      if (LArPandoraHelper::IsNeutrino(particle)) outputParticles.push_back(particle);
    }
  }

---

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

• larpandora/larpandora/LArPandoraInterface/LArPandoraHelper.h
• larpandora/larpandora/LArPandoraInterface/LArPandoraHelper.cxx