trkf::SpacePointFinder Class Reference

Inheritance diagram for trkf::SpacePointFinder:

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

Private Member Functions
void	produce (art::Event &evt) override
void	endJob () override

Private Attributes
SpacePointAlg	fSptalg
std::string	fClusterModuleLabel
unsigned int	fMinHits
bool	fClusterAssns
int	fNumEvent
int	fNumSpt2
int	fNumSpt3

Detailed Description

Definition at line 36 of file SpacePointFinder_module.cc.

Constructor & Destructor Documentation

trkf::SpacePointFinder::SpacePointFinder ( fhicl::ParameterSet const &  pset )

explicit

Definition at line 61 of file SpacePointFinder_module.cc.

    : EDProducer{pset}
    , fSptalg(pset.get<fhicl::ParameterSet>("SpacePointAlg"))
    , fMinHits(0)
    , fClusterAssns(false)
    , fNumEvent(0)
    , fNumSpt2(0)
    , fNumSpt3(0)
  {
    fClusterModuleLabel = pset.get<std::string>("ClusterModuleLabel");
    fMinHits = pset.get<unsigned int>("MinHits");
    fClusterAssns = pset.get<bool>("ClusterAssns");

    produces<std::vector<art::PtrVector<recob::SpacePoint>>>();
    produces<std::vector<recob::SpacePoint>>();
    produces<art::Assns<recob::SpacePoint, recob::Hit>>();
    if (fClusterAssns) produces<art::Assns<recob::SpacePoint, recob::Cluster>>();

    // Report.

    mf::LogInfo("SpacePointFinder")
      << "SpacePointFinder configured with the following parameters:\n"
      << "  ClusterModuleLabel = " << fClusterModuleLabel << "\n"
      << "  Minimum Hits per Cluster = " << fMinHits << "\n"
      << "  Cluster associations = " << fClusterAssns;
  }

Member Function Documentation

void trkf::SpacePointFinder::endJob ( )

overrideprivate

Definition at line 320 of file SpacePointFinder_module.cc.

  {
    mf::LogInfo("SpacePointFinder")
      << "SpacePointFinder statistics:\n"
      << "  Number of events = " << fNumEvent << "\n"
      << "  Number of 2-view space points created = " << fNumSpt2 << "\n"
      << "  Number of 3-view space points created = " << fNumSpt3;
  }

void trkf::SpacePointFinder::produce ( art::Event &  evt )

overrideprivate

Definition at line 95 of file SpacePointFinder_module.cc.

  {
    ++fNumEvent;

    // Get Services.

    art::ServiceHandle<geo::Geometry const> geom;

    // Get clusters.

    art::Handle<std::vector<recob::Cluster>> clusterh;
    evt.getByLabel(fClusterModuleLabel, clusterh);

    // Make a double or triple loop over clusters in distinct views
    // (depending on minimum number of views configured in SpacePointAlg).

    if (clusterh.isValid()) {

      // Make a collection of space points that will be inserted into the event.

      std::unique_ptr<std::vector<art::PtrVector<recob::SpacePoint>>> sptvecs(
        new std::vector<art::PtrVector<recob::SpacePoint>>);
      std::unique_ptr<std::vector<recob::SpacePoint>> spts(new std::vector<recob::SpacePoint>);
      std::unique_ptr<art::Assns<recob::SpacePoint, recob::Hit>> sphitassn(
        new art::Assns<recob::SpacePoint, recob::Hit>);
      std::unique_ptr<art::Assns<recob::SpacePoint, recob::Cluster>> spclassn(
        new art::Assns<recob::SpacePoint, recob::Cluster>);

      // Make a hit vector which will be used to store hits to be passed
      // to SpacePointAlg.

      art::PtrVector<recob::Hit> hits;
      art::FindManyP<recob::Hit> fm(clusterh, evt, fClusterModuleLabel);

      auto const clockData =
        art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
      auto const detProp =
        art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt);

      // Loop over first cluster.

      int nclus = clusterh->size();
      for (int iclus = 0; iclus < nclus; ++iclus) {
        art::Ptr<recob::Cluster> piclus(clusterh, iclus);
        geo::View_t iview = piclus->View();

        std::vector<art::Ptr<recob::Hit>> ihits = fm.at(iclus);

        // Test first view.

        if (ihits.size() >= fMinHits &&
            ((iview == geo::kU && fSptalg.enableU()) || (iview == geo::kV && fSptalg.enableV()) ||
             (iview == geo::kZ && fSptalg.enableW()))) {

          // Store hits from first view into hit vector.

          unsigned int nihits = ihits.size();
          hits.clear();
          hits.reserve(nihits);
          for (std::vector<art::Ptr<recob::Hit>>::const_iterator i = ihits.begin();
               i != ihits.end();
               ++i)
            hits.push_back(*i);

          // Loop over second cluster.

          for (int jclus = 0; jclus < iclus; ++jclus) {
            art::Ptr<recob::Cluster> pjclus(clusterh, jclus);
            geo::View_t jview = pjclus->View();

            std::vector<art::Ptr<recob::Hit>> jhits = fm.at(jclus);

            // Test second view.

            if (jhits.size() >= fMinHits &&
                ((jview == geo::kU && fSptalg.enableU()) ||
                 (jview == geo::kV && fSptalg.enableV()) ||
                 (jview == geo::kZ && fSptalg.enableW())) &&
                jview != iview) {

              // Store hits from second view into hit vector.

              unsigned int njhits = jhits.size();
              assert(hits.size() >= nihits);
              //hits.resize(nihits);
              while (hits.size() > nihits)
                hits.pop_back();
              assert(hits.size() == nihits);
              hits.reserve(nihits + njhits);
              for (std::vector<art::Ptr<recob::Hit>>::const_iterator j = jhits.begin();
                   j != jhits.end();
                   ++j)
                hits.push_back(*j);

              // If two-view space points are allowed, make them here.

              if (fSptalg.minViews() <= 2) {
                std::vector<recob::SpacePoint> new_spts;
                fSptalg.makeSpacePoints(clockData, detProp, hits, new_spts);

                // If we found some space points, insert them into the event.

                if (new_spts.size() > 0) {
                  fNumSpt2 += new_spts.size();
                  art::PtrVector<recob::Cluster> clusters;
                  clusters.reserve(2);
                  clusters.push_back(piclus);
                  clusters.push_back(pjclus);

                  // Insert newly found space points into event collection.

                  int nspt = spts->size();
                  spts->insert(spts->end(), new_spts.begin(), new_spts.end());

                  // Associate space points with hits and clusters.

                  art::PtrVector<recob::SpacePoint> sptvec;
                  for (unsigned int ispt = nspt; ispt < spts->size(); ++ispt) {
                    const recob::SpacePoint& spt = (*spts)[ispt];
                    const art::PtrVector<recob::Hit>& hits = fSptalg.getAssociatedHits(spt);
                    util::CreateAssn(evt, *spts, hits, *sphitassn, ispt);
                    if (fClusterAssns) util::CreateAssn(evt, *spts, clusters, *spclassn, ispt);

                    // make the PtrVector for this collection of space points
                    // Do not reproduce the following lines
                    // Contact brebel@fnal.gov if you think you need to reproduce these lines.
                    art::ProductID spid = evt.getProductID<std::vector<recob::SpacePoint>>();
                    art::Ptr<recob::SpacePoint> spptr(spid, ispt, evt.productGetter(spid));
                    sptvec.push_back(spptr);
                  }
                  sptvecs->push_back(sptvec);
                }
              }

              // Loop over third cluster.

              for (int kclus = 0; kclus < jclus; ++kclus) {
                art::Ptr<recob::Cluster> pkclus(clusterh, kclus);
                geo::View_t kview = pkclus->View();

                std::vector<art::Ptr<recob::Hit>> khits = fm.at(kclus);

                // Test third view.

                if (khits.size() >= fMinHits &&
                    ((kview == geo::kU && fSptalg.enableU()) ||
                     (kview == geo::kV && fSptalg.enableV()) ||
                     (kview == geo::kZ && fSptalg.enableW())) &&
                    kview != iview && kview != jview) {

                  // Store hits from third view into hit vector.

                  unsigned int nkhits = khits.size();
                  assert(hits.size() >= nihits + njhits);
                  //hits.resize(nihits + njhits);
                  while (hits.size() > nihits + njhits)
                    hits.pop_back();
                  assert(hits.size() == nihits + njhits);
                  hits.reserve(nihits + njhits + nkhits);
                  for (std::vector<art::Ptr<recob::Hit>>::const_iterator k = khits.begin();
                       k != khits.end();
                       ++k)
                    hits.push_back(*k);

                  // Make three-view space points.

                  std::vector<recob::SpacePoint> new_spts;
                  fSptalg.makeSpacePoints(clockData, detProp, hits, new_spts);

                  // If we found some space points, insert them into the event.

                  if (new_spts.size() > 0) {
                    fNumSpt3 += new_spts.size();
                    art::PtrVector<recob::Cluster> clusters;
                    clusters.reserve(3);
                    clusters.push_back(piclus);
                    clusters.push_back(pjclus);
                    clusters.push_back(pkclus);

                    // Insert newly found space points into event collection.

                    int nspt = spts->size();
                    spts->insert(spts->end(), new_spts.begin(), new_spts.end());

                    // Associate space points with hits and clusters.

                    art::PtrVector<recob::SpacePoint> sptvec;
                    for (unsigned int ispt = nspt; ispt < spts->size(); ++ispt) {
                      const recob::SpacePoint& spt = (*spts)[ispt];
                      const art::PtrVector<recob::Hit>& hits = fSptalg.getAssociatedHits(spt);
                      util::CreateAssn(evt, *spts, hits, *sphitassn, ispt);
                      if (fClusterAssns) util::CreateAssn(evt, *spts, clusters, *spclassn, ispt);

                      // make the PtrVector for this collection of space points
                      // Do not reproduce the following lines
                      // Contact brebel@fnal.gov if you think you need to reproduce these lines.
                      art::ProductID spid = evt.getProductID<std::vector<recob::SpacePoint>>();
                      art::Ptr<recob::SpacePoint> spptr(spid, ispt, evt.productGetter(spid));
                      sptvec.push_back(spptr);
                    }
                    sptvecs->push_back(sptvec);
                  }
                }
              }
            }
          }
        }
      }

      // Add space points and associations to event.

      evt.put(std::move(spts));
      evt.put(std::move(sptvecs));
      evt.put(std::move(sphitassn));
      if (fClusterAssns) evt.put(std::move(spclassn));
    }
  }

Member Data Documentation

bool trkf::SpacePointFinder::fClusterAssns

private

Definition at line 49 of file SpacePointFinder_module.cc.

std::string trkf::SpacePointFinder::fClusterModuleLabel

private

Definition at line 47 of file SpacePointFinder_module.cc.

unsigned int trkf::SpacePointFinder::fMinHits

private

Definition at line 48 of file SpacePointFinder_module.cc.

int trkf::SpacePointFinder::fNumEvent

private

Definition at line 53 of file SpacePointFinder_module.cc.

int trkf::SpacePointFinder::fNumSpt2

private

Definition at line 54 of file SpacePointFinder_module.cc.

int trkf::SpacePointFinder::fNumSpt3

private

Definition at line 55 of file SpacePointFinder_module.cc.

SpacePointAlg trkf::SpacePointFinder::fSptalg

private

Definition at line 46 of file SpacePointFinder_module.cc.

---

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

• SpacePointFinder_module.cc