OpDetBacktrackerRecord.h

Go to the documentation of this file.

/*
 * @file   OpDetBacktrackerRecord.h
 * @brief  object containing MC truth information necessary for backtracking Photons.
 * Based on SimChannels by seligman@nevis.columbia.edu
 * @author jason.stock@mines.sdsmt.edu
 * @see    OpDetBacktrackerRecord.cxx
 *
 * This class uses only LArSoft libraries that are header only.
 */

#ifndef LARSIMOBJ_SIMULATION_OPDETBACKTRACKERRECORD_H
#define LARSIMOBJ_SIMULATION_OPDETBACKTRACKERRECORD_H

// C/C++ standard libraries
#include <map>
#include <string>
#include <utility> // std::pair
#include <vector>
namespace sim {

  struct TrackSDP {
    int trackID;      
    float energyFrac; 
    float energy;     

    TrackSDP() {}

    TrackSDP(int id, float phF, float ph) : trackID(id), energyFrac(phF), energy(ph) {}
  };

  struct SDP {

    typedef int TrackID_t;

    SDP();

    SDP(SDP const& sdp, int offset);

    SDP(TrackID_t tid, float nPh, float e, float xpos, float ypos, float zpos)
      : trackID(tid), numPhotons(nPh), energy(e), x(xpos), y(ypos), z(zpos)
    {}

    TrackID_t trackID; 
    float numPhotons;  
    float energy;      
    float x;           
    float y;           
    float z;           
  };                   // struct SDP

  typedef std::pair<double, std::vector<sim::SDP>> timePDclockSDP_t;

  class OBTRHelper {
    friend class OpDetBacktrackerRecord;

  public:
    typedef double timePDclock_t;
    typedef SDP::TrackID_t TrackID_t;

    OBTRHelper(TrackID_t trackID) : fTrackID(trackID) {}

    void AddScintillationPhotonsToMap(
      // std::map<timePDclock_t, std::vector<sim::SDP>> & timePDclockSDPs,
      TrackID_t trackID,
      timePDclock_t iTimePDclock,
      double numberPhotons,
      double const* xyz,
      double energy);

  private:
    std::map<timePDclock_t, std::vector<sim::SDP>> fTimePDclockSDPs;
    TrackID_t fTrackID;
  };

  class OpDetBacktrackerRecord {
  public:
    typedef timePDclockSDP_t::first_type storedTimePDclock_t;

    typedef std::vector<timePDclockSDP_t> timePDclockSDPs_t;
    // typedef std::map<storedTimePDclock_t, std::vector<sim::SDP>> timePDclockSDPs_t;

  private:
    int iOpDetNum;                     
    timePDclockSDPs_t timePDclockSDPs; 

  public:
    // Default constructor
    OpDetBacktrackerRecord();

    //typedef unsigned short timePDclock_t;
    typedef double timePDclock_t; //This is the G4Time from OpFastScintillation. (ns)

    typedef SDP::TrackID_t TrackID_t;

    explicit OpDetBacktrackerRecord(int detNum);

    explicit OpDetBacktrackerRecord(OBTRHelper& helper);

    void AddScintillationPhotons(TrackID_t trackID,
                                 timePDclock_t timePDclock,
                                 double numberPhotons,
                                 double const* xyz,
                                 double energy);

    int OpDetNum() const;

    std::vector<sim::SDP> TrackIDsAndEnergies(timePDclock_t startTimePDclock,
                                              timePDclock_t endTimePDclock) const;

    timePDclockSDPs_t const& timePDclockSDPsMap() const;

    double Photons(timePDclock_t iTimePDclock) const;

    double Energy(timePDclock_t iTimePDclock) const;

    // /// Sorts the timeClockSDPs by increasing timePDclock tick
    // void SortTimePDclockSDPs();

    std::vector<sim::TrackSDP> TrackSDPs(timePDclock_t startTimePDclock,
                                         timePDclock_t endTimePDclock) const;

    bool operator<(const OpDetBacktrackerRecord& other) const;

    bool operator==(const OpDetBacktrackerRecord& other) const;

    std::pair<TrackID_t, TrackID_t> MergeOpDetBacktrackerRecord(
      const OpDetBacktrackerRecord& opDetNum,
      int offset);

    template <typename Stream>
    void Dump(Stream&& out, std::string indent, std::string first_indent) const;

    template <typename Stream>
    void Dump(Stream&& out, std::string indent = "") const
    {
      Dump(std::forward<Stream>(out), indent, indent);
    }

  private:
    struct CompareByTimePDclock;

    timePDclockSDPs_t::iterator findClosestTimePDclockSDP(storedTimePDclock_t timePDclock);

    timePDclockSDPs_t::const_iterator findClosestTimePDclockSDP(
      storedTimePDclock_t timePDclock) const;
  };

} // namespace sim

inline bool sim::OpDetBacktrackerRecord::operator<(const sim::OpDetBacktrackerRecord& other) const
{
  return iOpDetNum < other.OpDetNum();
}
inline bool sim::OpDetBacktrackerRecord::operator==(const sim::OpDetBacktrackerRecord& other) const
{
  return iOpDetNum == other.OpDetNum();
}
inline sim::OpDetBacktrackerRecord::timePDclockSDPs_t const&
sim::OpDetBacktrackerRecord::timePDclockSDPsMap() const
{
  return timePDclockSDPs;
}
inline int sim::OpDetBacktrackerRecord::OpDetNum() const
{
  return iOpDetNum;
}

// -----------------------------------------------------------------------------
// ---  template implementation
// ---
template <class Stream>
void sim::OpDetBacktrackerRecord::Dump(Stream&& out,
                                       std::string indent,
                                       std::string first_indent) const
{
  out << first_indent << "OpDet #" << OpDetNum() << " read " << timePDclockSDPs.size()
      << " timePDclocks:\n";
  double opDet_energy = 0., opDet_photons = 0.;
  for (const auto& timePDclockinfo : timePDclockSDPs) {
    auto const iTimePDclock = timePDclockinfo.first;
    out << indent << "  timePDclock #" << iTimePDclock << " with " << timePDclockinfo.second.size()
        << " SDPs\n";
    double timePDclock_energy = 0., timePDclock_photons = 0.;
    for (const sim::SDP& sdp : timePDclockinfo.second) {
      out << indent << "    (" << sdp.x << ", " << sdp.y << ", " << sdp.z << ") " << sdp.numPhotons
          << " photons, " << sdp.energy << "MeV  (trkID=" << sdp.trackID << ")\n";
      timePDclock_energy += sdp.energy;
      timePDclock_photons += sdp.numPhotons;
    } // for SDPs
    out << indent << "    => timePDclock #" << iTimePDclock << " CH #" << OpDetNum()
        << " collected " << timePDclock_energy << " MeV and " << timePDclock_photons
        << " photons. \n";
    opDet_energy += timePDclock_energy;
    opDet_photons += timePDclock_photons;
  } // for timePDclocks
  out << indent << "  => channel #" << OpDetNum() << " collected " << opDet_photons
      << " photons and " << opDet_energy << " MeV.\n";
} // sim::OpDetBacktrackerRecord::Dump<>()

#endif // LARSIMOBJ_SIMULATION_OPDETBACKTRACKERRECORD_H