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

// LArSoftObj libraries
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"

// C/C++ standard libraries
#include <string>
#include <vector>
#include <utility> // std::pair


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 OpDetBacktrackerRecord
  {
  public:
    typedef timePDclockSDP_t::first_type storedTimePDclock_t;

    typedef std::vector<timePDclockSDP_t> 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);

    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;

    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