pulse.hh

Go to the documentation of this file.

#ifndef PULSE_HH
#define PULSE_HH

#include "data_base.hh"

namespace larlight {
  class pulse : public data_base {

  public:

    pulse(DATA::DATA_TYPE type=DATA::Pulse);

    pulse(const pulse& original) : data_base(original),
                         _channel_number(original._channel_number),
                         _ped_mean(original._ped_mean),
                         _ped_rms(original._ped_rms),
                         _pulse_peak(original._pulse_peak),
                         _charge(original._charge),
                         _start_time(original._start_time),
                         _end_time(original._end_time),
                         _max_time(original._max_time),
                         _readout_frame_number(original._readout_frame_number),
                         _readout_sample_number(original._readout_sample_number),
                                             _disc_id(original._disc_id)
    {};

    void set_channel_number   (UShort_t ch)   {_channel_number=ch;};

    void set_ped_mean (double v) {_ped_mean=v;};

    void set_ped_rms  (double v) {_ped_rms=v;};

    void set_pulse_peak (double v) {_pulse_peak=v;};

    void set_charge (double v) {_charge=v;};

    void set_start_time(double v) {_start_time=v;};

    void set_end_time(double v) {_end_time=v;};

    void set_max_time(double v) {_max_time=v;};

    void set_disc_id(FEM::DISCRIMINATOR id) { _disc_id=id; }

    void set_readout_frame_number(UInt_t id) { _readout_frame_number=id; }

    void set_readout_sample_number(UInt_t t) { _readout_sample_number=t; }

    FEM::DISCRIMINATOR disc_id() const { return _disc_id;}

    UInt_t readout_frame_number() const { return _readout_frame_number;}

    UInt_t readout_sample_number() const { return _readout_sample_number;}

    UShort_t channel_number() const {return _channel_number;};

    double ped_mean () const { return _ped_mean;};

    double ped_rms  () const { return _ped_rms;};

    double pulse_peak () const { return _pulse_peak;};

    double charge () const { return _charge;};

    double start_time () const { return _start_time;};

    double end_time () const { return _end_time;};

    double max_time () const { return _max_time;};

    virtual void clear_data();

    ~pulse(){};


  protected:

    void init_vars();

    UShort_t _channel_number; 
    double   _ped_mean;              
    double   _ped_rms;               
    double   _pulse_peak;            
    double   _charge;                
    double   _start_time;            
    double   _end_time;              
    double   _max_time;              
    UInt_t   _readout_frame_number;  
    UInt_t   _readout_sample_number; 
    FEM::DISCRIMINATOR _disc_id;     

    ClassDef(pulse,4)
  };

  class event_pulse : public std::vector<larlight::pulse>,
              public event_base {

  public:

    event_pulse(DATA::DATA_TYPE type=DATA::Pulse);

    event_pulse(const event_pulse& original)
      : std::vector<larlight::pulse>(original),
    event_base(original),
    _sum_charge(original._sum_charge),
    _sum_peak(original._sum_peak),
    _npulse(original._npulse)
    {}

    void calculate_sum();

    double sum_charge() const {return _sum_charge;}

    double sum_peak() const   {return _sum_peak;}

    double npulse() const     {return _npulse;}

    void set_sum_charge(double v) {_sum_charge=v;}

    void set_sum_peak(double v)   {_sum_peak=v;}

    void set_npulse(UInt_t v)   {_npulse=v;}

    virtual void clear_data();

    ~event_pulse(){}


  private:

    void init_vars();

    double _sum_charge;  
    double _sum_peak;    
    UInt_t _npulse;      

    ClassDef(event_pulse,2)
  };

 }

#endif
 // end of doxygen group 

---