old.PhotonBackTracker.h

Go to the documentation of this file.

//  \adapted from BackTracker.h by brebel@fnal.gov
#ifndef CHEAT_PHOTONBACKTRACKERER_H
#define CHEAT_PHOTONBACKTRACKERER_H
#ifdef __GNUC__
#define DEPRECATED __attribute__((deprecated))
#else
#define DEPRECATED
#endif

#include <vector>

#include "art/Framework/Principal/Run.h"
#include "art/Framework/Services/Registry/ActivityRegistry.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "fhiclcpp/ParameterSet.h"

#include "larcore/Geometry/Geometry.h"
#include "larcorealg/Geometry/GeometryCore.h"
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h" // int
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include "lardataobj/Simulation/OpDetBacktrackerRecord.h"
#include "larsim/Simulation/LArVoxelList.h"
#include "nug4/ParticleNavigation/EveIdCalculator.h"
#include "nug4/ParticleNavigation/ParticleList.h"
#include "nusimdata/SimulationBase/MCParticle.h"
#include "nusimdata/SimulationBase/MCTruth.h"

#include "lardataobj/RecoBase/OpHit.h"

/*namespace recob{
  class SpacePoint;
}*/

namespace cheat {

  class PhotonBackTracker {

  public:
    PhotonBackTracker(fhicl::ParameterSet const& pset, art::ActivityRegistry& reg);
    ~PhotonBackTracker();

    void reconfigure(fhicl::ParameterSet const& pset);

    // The Rebuild function rebuilds the various maps we need to answer backtracking queries.
    // It is called automatically before each event is processed. For jobs involving
    // Monte Carlo generation, this is too soon. So, we'll call rebuild after those data
    // products are put into the event in LArG4.  This is the least bad way of ensuring the
    // PhotonBackTracker works in jobs that combine MC production and reconstruction analysis based
    // on MC truth.  Don't copy this design pattern without talking to brebel@fnal.gov first
    void Rebuild(const art::Event& evt);

    // Get a reference to the ParticleList
    const sim::ParticleList& ParticleList() const { return fParticleList; }

    // Set the EveIdCalculator for the owned ParticleList
    void SetEveIdCalculator(sim::EveIdCalculator* ec) { fParticleList.AdoptEveIdCalculator(ec); }

    // Return a pointer to the simb::MCParticle object corresponding to
    // the given TrackID
    const simb::MCParticle* TrackIDToParticle(int const& id) const;
    const simb::MCParticle* TrackIDToMotherParticle(int const& id) const;

    std::vector<sim::SDP> TrackIDToSimSDP(int const& id) const;

    // Get art::Ptr<> to simb::MCTruth and related information
    const art::Ptr<simb::MCTruth>& TrackIDToMCTruth(int const& id) const;
    const art::Ptr<simb::MCTruth>& ParticleToMCTruth(const simb::MCParticle* p) const;
    std::vector<const simb::MCParticle*> MCTruthToParticles(
      art::Ptr<simb::MCTruth> const& mct) const;
    const std::vector<art::Ptr<simb::MCTruth>>& MCTruthVector() const { return fMCTruthList; }

    // this method will return the Geant4 track IDs of
    // the particles contributing ionization electrons to the identified hit
    DEPRECATED std::vector<sim::TrackSDP> OpHitToTrackID(art::Ptr<recob::OpHit> const& hit)
    {
      return OpHitToTrackSDPs(hit);
    }
    std::vector<sim::TrackSDP> OpHitToTrackSDPs(art::Ptr<recob::OpHit> const& hit);

    // method to return a subset of allhits that are matched to a list of TrackIDs
    const std::vector<std::vector<art::Ptr<recob::OpHit>>> TrackIDsToOpHits(
      std::vector<art::Ptr<recob::OpHit>> const& allhits,
      std::vector<int> const& tkIDs);

    // method to return the EveIDs of particles contributing ionization
    // electrons to the identified hit
    std::vector<sim::TrackSDP> OpHitToEveSDPs(art::Ptr<recob::OpHit> const& hit);
    std::vector<sim::TrackSDP> OpHitToEveID(art::Ptr<recob::OpHit> const& hit);

    // method to return sim::SDP objects associated with a given hit
    void OpHitToSDPs(recob::OpHit const& hit, std::vector<sim::SDP>& sdps) const;
    DEPRECATED void OpHitToSimSDPs(recob::OpHit const& hit, std::vector<sim::SDP>& sdps) const
    {
      OpHitToSDPs(hit, sdps);
    }
    void OpHitToSDPs(art::Ptr<recob::OpHit> const& hit, std::vector<sim::SDP>& sdps) const
    {
      OpHitToSDPs(*hit, sdps);
    }
    DEPRECATED void OpHitToSimSDPs(art::Ptr<recob::OpHit> const& hit,
                                   std::vector<sim::SDP>& sdps) const
    {
      OpHitToSDPs(*hit, sdps);
    }

    // method to return the XYZ position of the weighted average energy deposition for a given hit
    std::vector<double> SimSDPsToXYZ(std::vector<sim::SDP> const& sdps);

    // method to return the XYZ position of the weighted average energy deposition for a given hit
    std::vector<double> OpHitToXYZ(art::Ptr<recob::OpHit> const& hit);

    // method to return the XYZ position of a space point (unweighted average XYZ of component hits).
    /*    std::vector<double> SpacePointToXYZ(art::Ptr<recob::SpacePoint> const& spt,
          art::Event                  const& evt,
          std::string                 const& label);*/

    // method to return the XYZ position of a space point (unweighted average XYZ of component hits).
    /*    std::vector<double> SpacePointHitsToXYZ(art::PtrVector<recob::Hit> const& hits);*/

    // method to return the fraction of hits in a collection that come from the specified Geant4 track ids
    double OpHitCollectionPurity(std::set<int> trackIDs,
                                 std::vector<art::Ptr<recob::OpHit>> const& hits);

    // method to return the fraction of all hits in an event from a specific set of Geant4 track IDs that are
    // represented in a collection of hits
    double OpHitCollectionEfficiency(std::set<int> trackIDs,
                                     std::vector<art::Ptr<recob::OpHit>> const& hits,
                                     std::vector<art::Ptr<recob::OpHit>> const& allhits);
    double OpHitCollectionEfficiency(std::set<int> trackIDs,
                                     std::vector<art::Ptr<recob::OpHit>> const& hits,
                                     std::vector<art::Ptr<recob::OpHit>> const& allhits,
                                     geo::View_t const& view);

    // method to return the fraction of charge in a collection that come from the specified Geant4 track ids
    double OpHitChargeCollectionPurity(std::set<int> trackIDs,
                                       std::vector<art::Ptr<recob::OpHit>> const& hits);

    // method to return the fraction of all charge in an event from a specific set of Geant4 track IDs that are
    // represented in a collection of hits
    double OpHitChargeCollectionEfficiency(std::set<int> trackIDs,
                                           std::vector<art::Ptr<recob::OpHit>> const& hits,
                                           std::vector<art::Ptr<recob::OpHit>> const& allhits);
    double OpHitChargeCollectionEfficiency(std::set<int> trackIDs,
                                           std::vector<art::Ptr<recob::OpHit>> const& hits,
                                           std::vector<art::Ptr<recob::OpHit>> const& allhits,
                                           geo::View_t const& view);

    // method to return all EveIDs corresponding to the current sim::ParticleList
    std::set<int> GetSetOfEveIDs();

    // method to return all TrackIDs corresponding to the current sim::ParticleList
    std::set<int> GetSetOfTrackIDs();

    // method to return all EveIDs corresponding to the given list of hits
    std::set<int> GetSetOfEveIDs(std::vector<art::Ptr<recob::OpHit>> const& hits);

    // method to return all TrackIDs corresponding to the given list of hits
    std::set<int> GetSetOfTrackIDs(std::vector<art::Ptr<recob::OpHit>> const& hits);

    const std::vector<art::Ptr<sim::OpDetBacktrackerRecord>>& OpDetBacktrackerRecords() const
    {
      return cOpDetBacktrackerRecords;
    }

    void ChannelToTrackSDPs(std::vector<sim::TrackSDP>& trackSDPs,
                            int channel,
                            const double hit_start_time,
                            const double hit_end_time);

  private:
    geo::GeometryCore const* geom = lar::providerFrom<geo::Geometry>();

    const art::Ptr<sim::OpDetBacktrackerRecord> FindOpDetBacktrackerRecord(int channel) const;

    const void shouldThisFail() const;

    bool have_complained;

    sim::ParticleList fParticleList; 
    sim::LArVoxelList fVoxelList;    
    std::vector<art::Ptr<simb::MCTruth>> fMCTruthList; 
    std::vector<art::Ptr<sim::OpDetBacktrackerRecord>>
      cOpDetBacktrackerRecords;                
    std::map<int, int> fTrackIDToMCTruthIndex; 
    std::string fG4ModuleLabel;                
    double fMinOpHitEnergyFraction;            
    double fDelay;                             //Shift in time
  };
} // namespace

DECLARE_ART_SERVICE(cheat::PhotonBackTracker, LEGACY)
#endif // CHEAT_PHOTONBACKTRACKER_H