PhotonBackTracker.h

Go to the documentation of this file.

//
// \file PhotonBackTracker.h
// \brief The functions needed for the PhotonBackTracker class needed by the PhotonBackTrackerService in order to connect truth information with reconstruction.
// \author jason.stock@mines.sdsmt.edu
//
// Based on the original BackTracker by brebel@fnal.gov
//
//
//TODO: Impliment alternate backtracking scheme developed by T. Usher
//
#ifndef CHEAT_PHOTONBACKTRACKER_H
#define CHEAT_PHOTONBACKTRACKER_H

//CPP
#include <map>
#include <unordered_set>
#include <vector>

//Framework
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Utilities/InputTag.h"
#include "fhiclcpp/types/Atom.h"
#include "fhiclcpp/types/Sequence.h"

//LArSoft
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include "lardataobj/RecoBase/OpFlash.h"
#include "lardataobj/RecoBase/OpHit.h"
#include "lardataobj/Simulation/OpDetBacktrackerRecord.h"

namespace cheat {
  class ParticleInventory;
}
namespace fhicl {
  class ParameterSet;
}
namespace geo {
  class GeometryCore;
}
namespace sim {
  struct SDP;
  struct TrackSDP;
}

namespace cheat {
  class PhotonBackTracker {
  public:
    struct fhiclConfig {
      fhicl::Atom<double> Delay{
        fhicl::Name("Delay"),
        fhicl::Comment("The delay time needed to correctly account for the optical simulation and "
                       "optical systems simulation. (The time between when a g4partcile was made, "
                       "and when the simulation write out says a signal was recorded)."),
        0};
      fhicl::Atom<art::InputTag> G4ModuleLabel{
        fhicl::Name("G4ModuleLabel"),
        fhicl::Comment(
          "The label of the LArG4 module used to produce the art file we will be using."),
        "largeant"};
      fhicl::Sequence<art::InputTag> G4ModuleLabels{
        fhicl::Name("G4ModuleLabels"),
        fhicl::Comment(
          "The labels of the LArG4 modules used to produce the art file we will be using."),
        fhicl::Sequence<art::InputTag>::default_type{}};
      fhicl::Atom<art::InputTag> OpHitLabel{
        fhicl::Name("OpHitLabel"),
        fhicl::Comment("The default label for the module to use when grabbing OpHits"),
        "ophit"}; //This should be removed and replaced with some way to access the OpHitLabel given by the user in their own analysis module to avoid differing definitions.
      fhicl::Atom<art::InputTag> OpFlashLabel{
        fhicl::Name("OpFlashLabel"),
        fhicl::Comment("The default label for the module to use when grabbing OpFlash"),
        "opflash"}; //This should be removed and replaced with some way to access the OpFlashLabel given by the user in their own analysis module to avoid differing definitions.
      fhicl::Atom<double> MinOpHitEnergyFraction{
        fhicl::Name("MinOpHitEnergyFraction"),
        fhicl::Comment("The minimum contribution an energy deposit must make to a Hit to be "
                       "considered part of that hit."),
        0.010};
    };

    //----------------------------------------------------------------
    PhotonBackTracker(fhiclConfig const& config,
                      const cheat::ParticleInventory* partInv,
                      const geo::GeometryCore* geom); //,
    //          const detinfo::DetectorClocks* detClock);

    //----------------------------------------------------------------
    PhotonBackTracker(fhicl::ParameterSet const& pSet,
                      const cheat::ParticleInventory* partInv,
                      const geo::GeometryCore* geom); //,
    //          const detinfo::DetectorClocks* detClock);

    //----------------------------------------------------------------
    PhotonBackTracker(PhotonBackTracker const&) = delete;

    //-----------------------------------------------------
    template <typename Evt>
    void PrepEvent(Evt const& evt);

    //-----------------------------------------------------
    template <typename Evt>
    const bool CanRun(Evt const& evt);

    //-----------------------------------------------------
    template <typename Evt>
    void PrepOpDetBTRs(Evt const& evt);

    //-----------------------------------------------------
    template <typename Evt>
    void PrepOpFlashToOpHits(Evt const& evt);

    //----------------------------------------------------- /*NEW*/
    const std::vector<art::Ptr<recob::OpHit>> OpFlashToOpHits_Ps(
      art::Ptr<recob::OpFlash>& flash_P) const;

    //----------------------------------------------------- /*NEW*/
    const std::vector<double> OpFlashToXYZ(art::Ptr<recob::OpFlash>& flash_P) const;

    //----------------------------------------------------- /*NEW*/
    const std::set<int> OpFlashToTrackIds(art::Ptr<recob::OpFlash>& flash_P) const;

    //-----------------------------------------------------
    const double GetDelay();

    //-----------------------------------------------------
    void ClearEvent();

    //-----------------------------------------------------
    const bool BTRsReady();

    //-----------------------------------------------------
    const bool OpFlashToOpHitsReady();

    //-----------------------------------------------------
    std::vector<art::Ptr<sim::OpDetBacktrackerRecord>> const& OpDetBTRs();

    //-----------------------------------------------------
    const std::vector<const sim::SDP*> TrackIdToSimSDPs_Ps(int const& id);

    //-----------------------------------------------------
    const std::vector<const sim::SDP*> TrackIdToSimSDPs_Ps(int const& id, geo::View_t const& view);

    //-----------------------------------------------------
    const art::Ptr<sim::OpDetBacktrackerRecord> FindOpDetBTR(int const& opDetNum) const;

    //-----------------------------------------------------

    //-----------------------------------------------------
    const std::vector<sim::TrackSDP> OpDetToTrackSDPs(int const& OpDetNum,
                                                      double const& opHit_start_time,
                                                      double const& opHit_end_time) const;

    //-----------------------------------------------------
    const std::vector<sim::TrackSDP> OpHitToTrackSDPs(art::Ptr<recob::OpHit> const& opHit_P) const;

    //-----------------------------------------------------
    const std::vector<sim::TrackSDP> OpHitToTrackSDPs(recob::OpHit const& opHit) const;

    //-----------------------------------------------------
    const std::vector<int> OpHitToTrackIds(recob::OpHit const& opHit) const;

    //-----------------------------------------------------
    const std::vector<int> OpHitToTrackIds(art::Ptr<recob::OpHit> const& opHit) const;

    //-----------------------------------------------------
    const std::vector<int> OpHitToEveTrackIds(recob::OpHit const& opHit);

    //-----------------------------------------------------
    const std::vector<int> OpHitToEveTrackIds(art::Ptr<recob::OpHit> const& opHit_P);

    //-----------------------------------------------------
    const std::vector<sim::TrackSDP> OpHitToEveTrackSDPs(
      art::Ptr<recob::OpHit> const& opHit_P) const;

    //-----------------------------------------------------
    const std::vector<sim::TrackSDP> OpHitToEveTrackSDPs(recob::OpHit const& opHit) const;

    //-----------------------------------------------------
    const std::vector<art::Ptr<recob::OpHit>> TrackIdToOpHits_Ps(
      int const& tkId,
      std::vector<art::Ptr<recob::OpHit>> const& hitsIn);

    //-----------------------------------------------------
    const std::vector<std::vector<art::Ptr<recob::OpHit>>> TrackIdsToOpHits_Ps(
      std::vector<int> const& tkIds,
      std::vector<art::Ptr<recob::OpHit>> const& hitsIn);

    //-----------------------------------------------------
    const std::vector<const sim::SDP*> OpHitToSimSDPs_Ps(recob::OpHit const& opHit) const;

    //-----------------------------------------------------
    const std::vector<const sim::SDP*> OpHitToSimSDPs_Ps(
      art::Ptr<recob::OpHit> const& opHit_P) const;
    //-----------------------------------------------------
    //
    //-----------------------------------------------------
    //      const std::vector< const sim::SDP* > OpHitsToSimSDPs_Ps( const std::vector< art::Ptr < recob::OpHit > >& opHits_Ps) ;
    const std::vector<const sim::SDP*> OpHitsToSimSDPs_Ps(
      std::vector<art::Ptr<recob::OpHit>> const& opHits_Ps) const;

    //-----------------------------------------------------
    const std::vector<double> SimSDPsToXYZ(std::vector<sim::SDP> const& sdps) const&;

    //-----------------------------------------------------
    const std::vector<double> SimSDPsToXYZ(std::vector<const sim::SDP*> const& sdps_Ps) const&;

    //-----------------------------------------------------
    const std::vector<double> OpHitToXYZ(art::Ptr<recob::OpHit> const& opHit);

    //-----------------------------------------------------
    const std::vector<double> OpHitToXYZ(recob::OpHit const& opHit);

    //-----------------------------------------------------
    const std::vector<double> OpHitsToXYZ(
      std::vector<art::Ptr<recob::OpHit>> const& opHits_Ps) const; /*NEW*/

    //----------------------------------------------------- /*NEW*/
    const std::unordered_set<const sim::SDP*> OpHitToEveSimSDPs_Ps(recob::OpHit const& opHit);

    //----------------------------------------------------- /*NEW*/
    const std::unordered_set<const sim::SDP*> OpHitToEveSimSDPs_Ps(art::Ptr<recob::OpHit>& opHit_P);

    //-----------------------------------------------------
    const std::set<int> GetSetOfEveIds() const;

    //-----------------------------------------------------
    const std::set<int> GetSetOfTrackIds() const;

    //-----------------------------------------------------
    const std::set<int> GetSetOfEveIds(std::vector<art::Ptr<recob::OpHit>> const& opHits) const;

    //----------------------------------------------------- /*NEW*/
    const std::set<int> GetSetOfEveIds(std::vector<recob::OpHit> const& opHits) const;

    //-----------------------------------------------------
    const std::set<int> GetSetOfTrackIds(std::vector<art::Ptr<recob::OpHit>> const& opHits) const;

    //----------------------------------------------------- /*NEW*/
    const std::set<int> GetSetOfTrackIds(std::vector<recob::OpHit> const& opHits) const;

    //-----------------------------------------------------
    const double OpHitCollectionPurity(std::set<int> const& tkIds,
                                       std::vector<art::Ptr<recob::OpHit>> const& opHits);

    //-----------------------------------------------------
    const double OpHitLightCollectionPurity(std::set<int> const& tkIds,
                                            std::vector<art::Ptr<recob::OpHit>> const& opHits);

    //-----------------------------------------------------
    const double OpHitCollectionEfficiency(std::set<int> const& tkIds,
                                           std::vector<art::Ptr<recob::OpHit>> const& opHits,
                                           std::vector<art::Ptr<recob::OpHit>> const& opHitsIn);

    //-----------------------------------------------------
    const double OpHitCollectionEfficiency(std::set<int> const& tkIds,
                                           std::vector<art::Ptr<recob::OpHit>> const& opHits,
                                           std::vector<art::Ptr<recob::OpHit>> const& opHitsIn,
                                           geo::View_t const& view);

    //-----------------------------------------------------
    const double OpHitLightCollectionEfficiency(
      std::set<int> const& tkIds,
      std::vector<art::Ptr<recob::OpHit>> const& opHits,
      std::vector<art::Ptr<recob::OpHit>> const& opHitsIn);

    //-----------------------------------------------------
    const double OpHitLightCollectionEfficiency(std::set<int> const& tkIds,
                                                std::vector<art::Ptr<recob::OpHit>> const& opHits,
                                                std::vector<art::Ptr<recob::OpHit>> const& opHitsIn,
                                                geo::View_t const& view);

    //----------------------------------------------------- /*NEW*/
    //std::vector<sim::TrackSDP> OpFlashToTrackSDPs(art::Ptr<recob::OpFlash> flash_P);
    //----------------------------------------------------- /*NEW*/
    //std::vector<sim::TrackSDP> OpFlashToEveTrackSDPs(recob::OpFlash flash);
    //----------------------------------------------------- /*NEW*/
    //std::vector<sim::TrackSDP> OpFlashToEveTrackSDPs(art::Ptr<recob::OpFlash> flash_P);
    //----------------------------------------------------- /*NEW*/
    //std::vector<sim::SDP*> OpFlashToSimSDPs_Ps(art::Ptr<recob::OpFlash> flash_P);

  private:
    const cheat::ParticleInventory* fPartInv; //The constructor needs to put something in here
    const geo::GeometryCore* fGeom;
    //      const detinfo::DetectorClocks* fDetClocks;
    const double fDelay;
    const art::InputTag fG4ModuleLabel;
    const std::vector<art::InputTag> fG4ModuleLabels;
    const art::InputTag fOpHitLabel;
    const art::InputTag fOpFlashLabel;
    const double fMinOpHitEnergyFraction;
    mutable std::vector<art::Ptr<sim::OpDetBacktrackerRecord>> priv_OpDetBTRs;
    std::map<art::Ptr<recob::OpFlash>, std::vector<art::Ptr<recob::OpHit>>> priv_OpFlashToOpHits;

  }; //Class
} //namespace

#include "PhotonBackTracker.tcc"

#endif