calorimetry.hh

Go to the documentation of this file.

#ifndef CALORIMETRY_HH
#define CALORIMETRY_HH

#include "data_base.hh"

namespace larlight{
  class calorimetry : public data_base {
    
  public:
    
    calorimetry(DATA::DATA_TYPE type=DATA::Calorimetry);
    
    calorimetry(const calorimetry& original) : data_base(original),
                           fKineticEnergy(original.fKineticEnergy),
                           fdEdx(original.fdEdx),
                           fdQdx(original.fdQdx),
                           fResidualRange(original.fResidualRange),
                           fDeadWireResR(original.fDeadWireResR),
                           fRange(original.fRange),
                           fTrkPitch(original.fTrkPitch)
    {}
    
    virtual ~calorimetry(){}
    
    virtual void clear_data();
    
    // Set methods
    void set_dedx(const std::vector<double> &v)           { fdEdx = v;          }
    void set_dqdx(const std::vector<double> &v)           { fdQdx = v;          }
    void set_residual_range(const std::vector<double> &v) { fResidualRange = v; }
    void set_deadwire_range(const std::vector<double> &v) { fDeadWireResR  = v; }
    void set_kinetic_energy(const double v)               { fKineticEnergy = v; }
    void set_range(const double v)                        { fRange = v;         }
    void set_track_pitch(const std::vector<double> &v)    { fTrkPitch = v;      }

    // Get Methods 
    inline const std::vector<double>& dEdx()          const { return fdEdx; }
    inline const std::vector<double>& dQdx()          const { return fdQdx; }
    inline const std::vector<double>& ResidualRange() const { return fResidualRange; }
    inline const std::vector<double>& DeadWireResRC() const { return fDeadWireResR; }
    inline double                     KineticEnergy() const { return fKineticEnergy; }
    inline double                     Range()         const { return fRange; }
    inline const std::vector<double>& TrkPitchVec()   const { return fTrkPitch; }
    inline double                     TrkPitchC()     const
    {
      if (fTrkPitch.size())
    return fTrkPitch[0];
      else return 0;
    }

  protected:

    double              fKineticEnergy;   
    std::vector<double> fdEdx;            
    std::vector<double> fdQdx;            
    std::vector<double> fResidualRange;   
    std::vector<double> fDeadWireResR;    
    double              fRange;           
    std::vector<double> fTrkPitch;        
    
  private:
    
    ClassDef(calorimetry,1)
      
  };
  
  class event_calorimetry : public std::vector<larlight::calorimetry>,
                public event_base {
    
  public:
    
    event_calorimetry(DATA::DATA_TYPE type=DATA::Calorimetry);
    
    event_calorimetry(const event_calorimetry& original) : std::vector<larlight::calorimetry>(original),
                               event_base(original)
    {}
    
    ~event_calorimetry(){}
    
    virtual void clear_data(){event_base::clear_data(); clear();}

  protected:
    
    std::vector<larlight::calorimetry> fCalorimetry_v;
    
  private:
    
    ClassDef(event_calorimetry,2)
  };
}
#endif
 // end of doxygen group 

---