OpFlash.h

Go to the documentation of this file.

//
// \brief Definition of OpFlash object for LArSoft
//
// \author bjpjones@mit.edu
//         cschiu@mit.edu
//
#ifndef OPFLASH_H
#define OPFLASH_H

#include <iosfwd> // std::ostream
#include <limits> // std::numeric_limits<>
#include <vector>

namespace recob {

  // subevents are groupings of OpDet pulse peaks. Each peak comes from an OpDet and
  // has a certain number of PE; each subevent has a time associated with it
  class OpFlash {
  public:
    static constexpr double NoCenter = std::numeric_limits<double>::max();

    OpFlash() = default;

  private:
    double fTime{0.0};   
    double fTimeWidth;   
    double fAbsTime;     
    unsigned int fFrame; 
    std::vector<double> fPEperOpDet;  
    std::vector<double> fWireCenters; 
    std::vector<double> fWireWidths;  
    double fXCenter{NoCenter};        
    double fXWidth{NoCenter};         
    double fYCenter;                  
    double fYWidth;                   
    double fZCenter;                  
    double fZWidth;                   
    double fFastToTotal;              
    bool fInBeamFrame;                
    int fOnBeamTime;                  

  public:
    OpFlash(double time,
            double timewidth,
            double abstime,
            unsigned int frame,
            std::vector<double> PEperOpDet,
            bool InBeamFrame,
            int OnBeamTime,
            double FastToTotal,
            double xCenter,
            double xWidth,
            double yCenter,
            double yWidth,
            double zCenter,
            double zWidth,
            std::vector<double> WireCenters = std::vector<double>(0),
            std::vector<double> WireWidths = std::vector<double>(0));

    OpFlash(double time,
            double timewidth,
            double abstime,
            unsigned int frame,
            std::vector<double> PEperOpDet,
            bool InBeamFrame = 0,
            int OnBeamTime = 0,
            double FastToTotal = 1,
            double yCenter = 0,
            double yWidth = 0,
            double zCenter = 0,
            double zWidth = 0,
            std::vector<double> WireCenters = std::vector<double>(0),
            std::vector<double> WireWidths = std::vector<double>(0));

    // Get Methods
    double Time() const;
    double TimeWidth() const;
    double AbsTime() const;
    unsigned int Frame() const;
    double PE(unsigned int i) const;

    std::vector<double> const& PEs() const;

    bool hasXCenter() const;

    double XCenter() const;
    double XWidth() const;
    double YCenter() const;
    double YWidth() const;
    double ZCenter() const;
    double ZWidth() const;

    bool InBeamFrame() const;
    int OnBeamTime() const;

    std::vector<double> const& WireCenters() const;
    std::vector<double> const& WireWidths() const;

    double TotalPE() const;
    double FastToTotal() const;
  };

  std::ostream& operator<<(std::ostream& out, OpFlash const& flash);

}

inline double recob::OpFlash::Time() const
{
  return fTime;
}
inline double recob::OpFlash::TimeWidth() const
{
  return fTimeWidth;
}
inline double recob::OpFlash::AbsTime() const
{
  return fAbsTime;
}
inline unsigned int recob::OpFlash::Frame() const
{
  return fFrame;
}
inline double recob::OpFlash::PE(unsigned int i) const
{
  return fPEperOpDet[i];
}
inline std::vector<double> const& recob::OpFlash::PEs() const
{
  return fPEperOpDet;
}
inline bool recob::OpFlash::hasXCenter() const
{
  return fXCenter != NoCenter;
}
inline double recob::OpFlash::XCenter() const
{
  return fXCenter;
}
inline double recob::OpFlash::XWidth() const
{
  return fXWidth;
}
inline double recob::OpFlash::YCenter() const
{
  return fYCenter;
}
inline double recob::OpFlash::YWidth() const
{
  return fYWidth;
}
inline double recob::OpFlash::ZCenter() const
{
  return fZCenter;
}
inline double recob::OpFlash::ZWidth() const
{
  return fZWidth;
}
inline double recob::OpFlash::FastToTotal() const
{
  return fFastToTotal;
}
inline std::vector<double> const& recob::OpFlash::WireCenters() const
{
  return fWireCenters;
}
inline std::vector<double> const& recob::OpFlash::WireWidths() const
{
  return fWireWidths;
}
inline bool recob::OpFlash::InBeamFrame() const
{
  return fInBeamFrame;
}
inline int recob::OpFlash::OnBeamTime() const
{
  return fOnBeamTime;
}

namespace recob {
  struct OpFlashSortByTime {
    bool operator()(recob::OpFlash const& i, recob::OpFlash const& j) const
    {
      return i.Time() < j.Time();
    }
  };
}

#endif