TrackMaker.h

Go to the documentation of this file.

#ifndef TRACKMAKER_H
#define TRACKMAKER_H

#include "art/Framework/Principal/fwd.h"
#include "canvas/Persistency/Common/Ptr.h"

#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/SpacePoint.h"
#include "lardataobj/RecoBase/Track.h"
#include "lardataobj/RecoBase/TrackFitHitInfo.h"
#include "lardataobj/RecoBase/TrackTrajectory.h"
#include "lardataobj/RecoBase/TrackingTypes.h"
#include "lardataobj/RecoBase/Trajectory.h"
#include "lardataobj/RecoBase/TrajectoryPointFlags.h"

#include <memory>
#include <stdexcept>
#include <utility>
#include <vector>

namespace detinfo {
  class DetectorPropertiesData;
}

namespace trkmkr {

  struct OptionalPointElement {
  public:
    void setTrackFitHitInfo(recob::TrackFitHitInfo&& aTrackFitHitInfo)
    {
      trackFitHitInfo = std::make_unique<recob::TrackFitHitInfo>(std::move(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&) {}

    bool makeTrack(const detinfo::DetectorPropertiesData& detProp,
                   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(detProp, *ttraj, ttraj.key(), inHits, outTrack, outHits, optionals);
    }

    virtual bool makeTrack(const detinfo::DetectorPropertiesData& detProp,
                           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;

    bool makeTrack(const detinfo::DetectorPropertiesData& detProp,
                   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(
        detProp, track->Trajectory(), track.key(), inHits, outTrack, outHits, optionals);
    }
  };
}

#endif