PCAnglePlaneMaker_module.cc File Reference

#include "art/Framework/Core/EDProducer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Principal/Run.h"
#include "art/Framework/Principal/SubRun.h"
#include "canvas/Utilities/InputTag.h"
#include "fhiclcpp/ParameterSet.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "lardata/Utilities/AssociationUtil.h"
#include "lardataobj/RecoBase/PFParticle.h"
#include <memory>
#include "lardataobj/RecoBase/Wire.h"
#include "lardataobj/RecoBase/Vertex.h"
#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/Cluster.h"
#include "larcore/Geometry/Geometry.h"
#include "larcorealg/Geometry/GeometryCore.h"
#include "lardataalg/DetectorInfo/DetectorPropertiesStandard.h"
#include "lardata/DetectorInfoServices/DetectorPropertiesService.h"
#include "sbnobj/Common/Reco/PCAnglePlane.h"
#include "PCA.h"

Go to the source code of this file.

Classes
struct	sbn::PCAngleInfo
class	sbn::PCAnglePlaneMaker

Namespaces
	sbn
	This module creates Common Analysis Files.

Functions
void	SaveHits (std::map< unsigned, std::array< std::vector< unsigned >, 3 >> &pfpToHits, const std::vector< art::Ptr< recob::Hit >> &hits, unsigned plane, const art::Ptr< recob::PFParticle > &pfp)
std::array< std::vector < art::Ptr< recob::Hit > >, 3 >	SortHits (const std::array< std::vector< art::Ptr< recob::Hit >>, 3 > &hits, const recob::Vertex &start, const geo::GeometryCore *geo, const detinfo::DetectorPropertiesData &dprop)
bool	DoBranch (art::Ptr< recob::PFParticle > particle, const std::map< unsigned, art::Ptr< recob::PFParticle >> &pfpMap)
std::map< unsigned, std::vector< sbn::PCAngleInfo > >	RemoveDupes (std::vector< sbn::PCAngleInfo > &angles)

Function Documentation

bool DoBranch	(	art::Ptr< recob::PFParticle >	particle,
		const std::map< unsigned, art::Ptr< recob::PFParticle >> &	pfpMap
	)

Definition at line 127 of file PCAnglePlaneMaker_module.cc.

                                                                                                         {
  (void) particle;
  (void) pfpMap;

  return true;
}

std::map<unsigned, std::vector<sbn::PCAngleInfo> > RemoveDupes

(

std::vector< sbn::PCAngleInfo > &

angles

)

Definition at line 135 of file PCAnglePlaneMaker_module.cc.

                                                                                           {
  // We will eliminate duplicates by converting to a set and then back to a vector
  //
  // Define a struct to implement the comparator
  struct angle_compare {
    bool operator() (const sbn::PCAngleInfo &lhs, const sbn::PCAngleInfo &rhs) const {
      // unique ID is hitID, hitIDLo, hitIDHi
      if (lhs.angle.hitID != rhs.angle.hitID) return lhs.angle.hitID < rhs.angle.hitID;
      if (lhs.angle.hitIDLo != rhs.angle.hitIDLo) return lhs.angle.hitIDLo < rhs.angle.hitIDLo;
      if (lhs.angle.hitIDHi != rhs.angle.hitIDHi) return lhs.angle.hitIDHi < rhs.angle.hitIDHi;
      // equal
      return false;
    }
  };

  // Given the choice, we want to keep angles with a smaller generation. 
  //
  // So first sort the input by generation (lo -> hi). So smaller generations
  // get inserted into the set first
  std::sort(angles.begin(), angles.end(),
     [](auto const &lhs, auto const &rhs) {return lhs.generation < rhs.generation;});

  // make the set to unique-ify the input
  std::set<sbn::PCAngleInfo, angle_compare> unique(angles.begin(), angles.end());

  // organize into output
  std::map<unsigned, std::vector<sbn::PCAngleInfo>> ret;
  for (const sbn::PCAngleInfo &angle: unique) {
    ret[angle.branch].push_back(angle);
  }

  // sort each ret by the hit order
  for (auto &pair: ret) {
    std::sort(pair.second.begin(), pair.second.end(),
      [](auto const &lhs, auto const &rhs) {
        return lhs.hit_ind < rhs.hit_ind;
   });
  }

  return ret;
}

void SaveHits	(	std::map< unsigned, std::array< std::vector< unsigned >, 3 >> &	pfpToHits,
		const std::vector< art::Ptr< recob::Hit >> &	hits,
		unsigned	plane,
		const art::Ptr< recob::PFParticle > &	pfp
	)

Definition at line 78 of file PCAnglePlaneMaker_module.cc.

                                                                                                                                                                          {
  for (const art::Ptr<recob::Hit> &h: hits) {
    pfpToHits[pfp.key()][plane].push_back(h.key());
  }
}

std::array<std::vector<art::Ptr<recob::Hit> >, 3> SortHits	(	const std::array< std::vector< art::Ptr< recob::Hit >>, 3 > &	hits,
		const recob::Vertex &	start,
		const geo::GeometryCore *	geo,
		const detinfo::DetectorPropertiesData &	dprop
	)

Definition at line 84 of file PCAnglePlaneMaker_module.cc.

                                                                                                      {
  // convert data to linked-list
  std::array<std::list<art::Ptr<recob::Hit>>, 3> planar {};
  for (unsigned i_plane = 0; i_plane < 3; i_plane++) {
    planar[i_plane].insert(planar[i_plane].begin(), hits[i_plane].begin(), hits[i_plane].end());
  }

  // start from the zeroth hit and grow from the nearest hit
  std::array<std::vector<art::Ptr<recob::Hit>>, 3> ret {};
  for (unsigned i = 0; i < 3; i++) {
    if (planar[i].size()) {

      // find the zeroth hit
      std::list<art::Ptr<recob::Hit>>::iterator firstHit = std::min_element(planar[i].begin(), planar[i].end(),
          [start, geo, dprop](auto const &lhs, auto const &rhs) {
            return sbnpca::Vert2HitDistance(*lhs, start, geo, dprop) < sbnpca::Vert2HitDistance(*rhs, start, geo, dprop);
      });
      ret[i].push_back(*firstHit);
      planar[i].erase(firstHit);

      while (planar[i].size()) {
        const recob::Hit &lastHit = *ret[i].back();
        std::list<art::Ptr<recob::Hit>>::iterator closest = std::min_element(planar[i].begin(), planar[i].end(),
          [lastHit, geo, dprop](auto const &lhs, auto const &rhs) { 
            return sbnpca::HitDistance(*lhs, lastHit, geo, dprop) < sbnpca::HitDistance(*rhs, lastHit, geo, dprop);
          });

        ret[i].push_back(*closest);
        planar[i].erase(closest);
      }
    }
  }

  return ret;

}