SimChannel.h

Go to the documentation of this file.

#ifndef LARDATAOBJ_SIMULATION_SIMCHANNEL_H
#define LARDATAOBJ_SIMULATION_SIMCHANNEL_H

// LArSoftObj libraries
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h" // raw::ChannelID_t

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


namespace sim {
  
  struct TrackIDE{
    int trackID;      
    float energyFrac; 
    float energy;     
    float numElectrons; 

    TrackIDE() {}
    
    
    TrackIDE(int id, float ef, float e, float ne ) : trackID(id), energyFrac(ef), energy (e), numElectrons (ne) {}
    

  };
  
  
  struct IDE{
    
    typedef int TrackID_t;
    
    IDE();
    
    
    IDE(IDE const& ide, int offset);
    
    IDE(TrackID_t tid,
        float nel,
        float e,
        float xpos,
        float ypos,
        float zpos)
    : trackID     (tid)
    , numElectrons(nel)
    , energy      (e)
    , x           (xpos)
    , y           (ypos)
    , z           (zpos)
    {}
    
    
    TrackID_t trackID;  
    float numElectrons; 
    float energy;       
    float x;            
    float y;            
    float z;            
  }; // struct IDE
  
  
  typedef std::pair<unsigned short, std::vector<sim::IDE> > TDCIDE;
  
  class SimChannel
  {
  public:
    typedef TDCIDE::first_type StoredTDC_t;
  
    typedef std::vector<TDCIDE> TDCIDEs_t;
    
  private:
    raw::ChannelID_t fChannel; 
    TDCIDEs_t        fTDCIDEs; 
    
    
  public:

    // Default constructor
    SimChannel();
    
    typedef unsigned int TDC_t;
    
    typedef IDE::TrackID_t TrackID_t;
    
    
    explicit SimChannel(raw::ChannelID_t channel);

    void AddIonizationElectrons(TrackID_t trackID,
                                TDC_t tdc,
                                double numberElectrons,
                                double const* xyz,
                                double energy); 
    
    raw::ChannelID_t Channel() const;
    
    std::vector<sim::IDE> TrackIDsAndEnergies(TDC_t startTDC,
                                              TDC_t endTDC) const;
    
    TDCIDEs_t const& TDCIDEMap() const;
    
    
    double Charge(TDC_t tdc) const;
    
    double Energy(TDC_t tdc) const;

    std::vector<sim::TrackIDE> TrackIDEs(TDC_t startTDC,
                                         TDC_t endTDC) const;
    
    bool operator<  (const SimChannel& other)     const;
    
    bool operator== (const SimChannel& other)     const;
    
    std::pair<TrackID_t,TrackID_t> MergeSimChannel
      (const SimChannel& channel, 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 CompareByTDC;
    
    TDCIDEs_t::iterator findClosestTDCIDE(StoredTDC_t tdc);
    
    TDCIDEs_t::const_iterator findClosestTDCIDE
      (StoredTDC_t tdc) const;


  };

} // namespace sim


inline bool                           sim::SimChannel::operator<  (const sim::SimChannel& other) const { return fChannel < other.Channel(); }
inline bool                           sim::SimChannel::operator== (const sim::SimChannel& other) const { return fChannel == other.Channel(); }
inline sim::SimChannel::TDCIDEs_t const& sim::SimChannel::TDCIDEMap()                             const { return fTDCIDEs; }
inline raw::ChannelID_t                sim::SimChannel::Channel()                                 const { return fChannel; }


// -----------------------------------------------------------------------------
// ---  template implementation
// ---
template <class Stream>
void sim::SimChannel::Dump
  (Stream&& out, std::string indent, std::string first_indent) const
{
  out << first_indent << "channel #" << Channel() << " read " << fTDCIDEs.size()
    << " TDCs:\n";
  double channel_energy = 0., channel_charge = 0.;
  for (const auto& TDCinfo: fTDCIDEs) {
    auto const tdc = TDCinfo.first;
    out << indent << "  TDC #" << tdc
      << " with " << TDCinfo.second.size() << " IDEs\n";
    double tdc_energy = 0., tdc_charge = 0.;
    for (const sim::IDE& ide: TDCinfo.second) {
      out << indent
        << "    (" << ide.x << ", " << ide.y << ", " << ide.z << ") "
        << ide.numElectrons << " electrons, " << ide.energy << " MeV (trkID="
        << ide.trackID << ")\n";
      tdc_energy += ide.energy;
      tdc_charge += ide.numElectrons;
    } // for IDEs
    out << indent << "    => TDC #" << tdc << " CH #" << Channel()
      << " collected " << tdc_charge << " electrons and " << tdc_energy
      << " MeV\n";
    channel_energy += tdc_energy;
    channel_charge += tdc_charge;
  } // for TDCs
  out << indent << "  => channel #" << Channel() << " collected "
    << channel_charge << " electrons and " << channel_energy << " MeV\n";
} // sim::SimChannel::Dump<>()


#endif // LARDATAOBJ_SIMULATION_SIMCHANNEL_H