TrackMaker.h

Go to the documentation of this file.

#ifndef TRACKMAKER_H
#define TRACKMAKER_H

#include "art/Framework/Principal/Event.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "lardataobj/RecoBase/Track.h"
#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/TrackFitHitInfo.h"
#include "lardataobj/RecoBase/SpacePoint.h"
#include "lardataobj/RecoBase/TrackingTypes.h"
#include "canvas/Persistency/Common/Assns.h"

namespace trkmkr {

  struct OptionalPointElement {
  public:
    void setTrackFitHitInfo(recob::TrackFitHitInfo&& aTrackFitHitInfo) { trackFitHitInfo = std::make_unique< recob::TrackFitHitInfo >(aTrackFitHitInfo); }
    void setTrackFitHitInfo(const recob::TrackFitHitInfo& aTrackFitHitInfo) { trackFitHitInfo = std::make_unique< recob::TrackFitHitInfo >(aTrackFitHitInfo); }
    bool isTrackFitInfoSet() { return bool(trackFitHitInfo); }
    recob::TrackFitHitInfo getTrackFitHitInfo() { auto tmp = *trackFitHitInfo; trackFitHitInfo.reset(); return tmp; }
    //
    void setSpacePoint(recob::SpacePoint&& aSpacePoint) { spacePoint = std::make_unique< recob::SpacePoint >(aSpacePoint); }
    void setSpacePoint(const recob::SpacePoint& aSpacePoint) { spacePoint = std::make_unique< recob::SpacePoint >(aSpacePoint); }
    bool isSpacePointSet() { return bool(spacePoint); }
    recob::SpacePoint getSpacePoint() { auto tmp = *spacePoint; spacePoint.reset(); return tmp; }
  private:
    std::unique_ptr< recob::TrackFitHitInfo > trackFitHitInfo;
    std::unique_ptr<recob::SpacePoint> spacePoint;
  };

  struct OptionalOutputs {
  public:
    typedef std::pair<recob::SpacePoint, art::Ptr<recob::Hit> > SpHitPair;

    void addPoint(OptionalPointElement& ope) {
      if (isTrackFitInfosInit() && ope.isTrackFitInfoSet()) {
        outTrackFitHitInfos->push_back( ope.getTrackFitHitInfo() );
      }
    }
    void addPoint(OptionalPointElement& ope, art::Ptr<recob::Hit> hptr) {
      if (isSpacePointsInit() && ope.isSpacePointSet()) {
        outSpacePointHitPairs->emplace_back(ope.getSpacePoint(), hptr);
      }
      addPoint(ope);
    }
    void reset() {
      if (isTrackFitInfosInit()) {
        outTrackFitHitInfos.reset();
        initTrackFitInfos();
      }
      if (isSpacePointsInit()) {
        outSpacePointHitPairs.reset();
        initSpacePoints();
      }
    }
    void initTrackFitInfos() {
      outTrackFitHitInfos = std::make_unique< std::vector<recob::TrackFitHitInfo> >();
    }
    void initSpacePoints() {
      outSpacePointHitPairs = std::make_unique< std::vector<SpHitPair> >();
    }
    bool isTrackFitInfosInit() { return bool(outTrackFitHitInfos); }
    bool isSpacePointsInit() { return bool(outSpacePointHitPairs); }
    std::vector<recob::TrackFitHitInfo> trackFitHitInfos() {
      if (!isTrackFitInfosInit()) throw std::logic_error("outTrackFitHitInfos is not available (any more?).");
      auto tmp = *outTrackFitHitInfos; outTrackFitHitInfos.reset(); return tmp;
    }
    std::vector<SpHitPair> spacePointHitPairs() {
      if (!isSpacePointsInit()) throw std::logic_error("outSpacePointHitPairs is not available (any more?).");
      auto tmp = *outSpacePointHitPairs; outSpacePointHitPairs.reset(); return tmp;
    }
  private:
    std::unique_ptr< std::vector<recob::TrackFitHitInfo> > outTrackFitHitInfos;
    std::unique_ptr< std::vector<SpHitPair> > outSpacePointHitPairs;
  };

  class TrackMaker {
  public:
    virtual ~TrackMaker() noexcept = default;

    virtual void initEvent(const art::Event& e) { return; }

    virtual bool makeTrack(const recob::Trajectory& traj, const std::vector<recob::TrajectoryPointFlags>& flags,
                           const int tkID, const std::vector<art::Ptr<recob::Hit> >& inHits,
                           recob::Track& outTrack, std::vector<art::Ptr<recob::Hit> >& outHits, OptionalOutputs& optionals) const
    {
      return makeTrack(recob::TrackTrajectory(traj,recob::TrackTrajectory::Flags_t(traj.NPoints())), tkID, inHits, outTrack, outHits, optionals);
    }
    virtual bool makeTrack(const art::Ptr<recob::Trajectory> traj, const std::vector<recob::TrajectoryPointFlags>& flags,
                           const std::vector<art::Ptr<recob::Hit> >& inHits,
                           recob::Track& outTrack, std::vector<art::Ptr<recob::Hit> >& outHits, OptionalOutputs& optionals) const
    {
      return makeTrack(recob::TrackTrajectory(*traj,recob::TrackTrajectory::Flags_t(traj->NPoints())), traj.key(), inHits, outTrack, outHits, optionals);
    }

    virtual bool makeTrack(const art::Ptr<recob::TrackTrajectory> ttraj, const std::vector<art::Ptr<recob::Hit> >& inHits,
                           recob::Track& outTrack, std::vector<art::Ptr<recob::Hit> >& outHits, OptionalOutputs& optionals) const
    {
      return makeTrack(*ttraj, ttraj.key(), inHits, outTrack, outHits, optionals);
    }

    virtual bool makeTrack(const recob::TrackTrajectory& ttraj, const int tkID, const std::vector<art::Ptr<recob::Hit> >& inHits,
                           recob::Track& outTrack, std::vector<art::Ptr<recob::Hit> >& outHits, OptionalOutputs& optionals) const = 0;

    virtual bool makeTrack(const art::Ptr<recob::Track> track, const std::vector<art::Ptr<recob::Hit> >& inHits,
                           recob::Track& outTrack, std::vector<art::Ptr<recob::Hit> >& outHits, OptionalOutputs& optionals) const
    {
      return makeTrack(track->Trajectory(), track.key(), inHits, outTrack, outHits, optionals);
    }

    virtual bool makeTrack(const recob::Track& track, const std::vector<art::Ptr<recob::Hit> >& inHits,
                           recob::Track& outTrack, std::vector<art::Ptr<recob::Hit> >& outHits, OptionalOutputs& optionals) const
    {
      return makeTrack(track.Trajectory(), track.ID(), inHits, outTrack, outHits, optionals);
    }
  };
}

#endif