SimChannel.h

Go to the documentation of this file.

#ifndef LARDATAOBJ_SIMULATION_SIMCHANNEL_H
#define LARDATAOBJ_SIMULATION_SIMCHANNEL_H

// LArSoftObj libraries
#include "larcoreobj/SimpleTypesAndConstants/PhysicalConstants.h" // util::kBogusI
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h"          // raw::ChannelID_t

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

namespace sim {

  struct TrackIDE {
    int trackID;        
    float energyFrac;   
    float energy;       
    float numElectrons; 
    int
      origTrackID; 

    TrackIDE() {}

    TrackIDE(int id, float ef, float e, float ne, int gid = util::kBogusI)
      : trackID(id), energyFrac(ef), energy(e), numElectrons(ne), origTrackID(gid)
    {}
  };

  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_t gid = util::kBogusI)
      : trackID(tid), numElectrons(nel), energy(e), x(xpos), y(ypos), z(zpos), origTrackID(gid)
    {}

    TrackID_t trackID;  
    float numElectrons; 
    float energy;       
    float x;            
    float y;            
    float z;            
    TrackID_t
      origTrackID; 
  };               // 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,
                                TrackID_t origTrackID = util::kBogusI);

    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