KHitContainer.cxx

Go to the documentation of this file.

#include "lardata/RecoObjects/KHitContainer.h"

#include "cetlib_except/exception.h"

namespace trkf {

  void fill(const art::PtrVector<recob::Hit>& hits, int only_plane) {}

  void KHitContainer::clear()
  {
    fSorted.clear();
    fUnsorted.clear();
    fUnused.clear();
  }

  void KHitContainer::reset()
  {
    fUnsorted.splice(fUnsorted.end(), fSorted);
    fUnsorted.splice(fUnsorted.end(), fUnused);
  }

  void KHitContainer::sort(const KTrack& trk,
                           bool addUnsorted,
                           const Propagator& prop,
                           Propagator::PropDirection dir)
  {
    // Maybe transfer all objects in unsorted list to the sorted list.

    if (addUnsorted) fSorted.splice(fSorted.end(), fUnsorted);

    // Loop over objects in sorted list.

    for (std::list<KHitGroup>::iterator igr = fSorted.begin(); igr != fSorted.end();) {

      KHitGroup& gr = *igr;

      // Get destination surface.

      const std::shared_ptr<const Surface>& psurf = gr.getSurface();

      // Make a fresh copy of the track and propagate it to
      // the destination surface.

      KTrack trkp = trk;
      std::optional<double> dist = prop.vec_prop(trkp, psurf, dir, false, 0, 0);
      if (!dist) {

        // If propagation failed, reset the path flag for this surface
        // and move the KHitGroup to the unsorted list.  Be careful to
        // keep the list iterator valid.

        gr.setPath(false, 0.);
        std::list<KHitGroup>::iterator it = igr;
        ++igr;
        fUnsorted.splice(fUnsorted.end(), fSorted, it);
      }
      else {

        // Otherwise (if propagation succeeded), set the path distance
        // and advance the iterator to the next KHitGroup.

        gr.setPath(true, *dist);
        ++igr;
      }
    }

    // Finally, sort the sorted list in order of path distance.

    fSorted.sort();
  }

  unsigned int KHitContainer::getPreferredPlane() const
  {
    // Count hits in each plane.

    std::vector<unsigned int> planehits(3, 0);

    // Loop over KHitGroups in the unsorted list.

    for (std::list<KHitGroup>::const_iterator igr = fUnsorted.begin(); igr != fUnsorted.end();
         ++igr) {

      const KHitGroup& gr = *igr;

      // Get plane of this KHitGroup.

      int plane = gr.getPlane();
      ++planehits.at(plane);
    }

    // Figure out which plane has the most hits.

    unsigned int prefplane = 0;
    for (unsigned int i = 0; i < planehits.size(); ++i) {
      if (planehits[i] >= planehits[prefplane]) prefplane = i;
    }
    return prefplane;
  }

} // end namespace trkf