KHitContainer.cxx

Go to the documentation of this file.

#include "lardata/RecoObjects/KHitContainer.h"

#include "cetlib_except/exception.h"

namespace trkf {

  KHitContainer::KHitContainer()
  {}

  KHitContainer::~KHitContainer()
  {}

 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)
  {
    if(!prop)
      throw cet::exception("KHitContainer") << __func__ << ": no propagator" << "\n";

    // 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;
      boost::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