pulse_viewer.hh

Go to the documentation of this file.

#ifndef PULSE_VIEWER_HH
#define PULSE_VIEWER_HH

#include <TH1D.h>
#include <TCanvas.h>
#include <TLine.h>
#include <TPad.h>
#include <TPaveText.h>
#include <TROOT.h>
#include <TStyle.h>
#include <TGaxis.h>
#include <TColor.h>

#include <set>
#include <algorithm>

#include "ana_base.hh"

class pulse_viewer : public ana_base{

public:

  pulse_viewer();

  virtual ~pulse_viewer(){};

  virtual bool initialize();

  virtual bool analyze(storage_manager* storage);

  virtual bool finalize();

  TH1D* next_pulse(PMT::ch_number_t ch);

  TH1D* previous_pulse(PMT::ch_number_t ch);


  const TCanvas* get_canvas() const {return _cWF;};

  const std::set<PMT::ch_number_t> get_hit_channels() const {return _channels;};

  PMT::ch_number_t next_channel();

  void display_cut_ranges();

  //
  // Setters
  //

  short get_npulse(PMT::ch_number_t ch);

  void set_range_pulse_start_time(double v1, double v2)   {_cut_tstart.first=v1;   _cut_tstart.second=v2;   };

  void set_range_pulse_start_time_reco(double v1, double v2)   {_cut_tstart_reco.first=v1;   _cut_tstart_reco.second=v2;   };

  void set_range_pulse_end_time(double v1, double v2)     {_cut_tend.first=v1;     _cut_tend.second=v2;     };

  void set_range_pulse_amp(double v1, double v2)          {_cut_amp.first=v1;      _cut_amp.second=v2;      };

  void set_range_pulse_charge(double v1,double v2)        {_cut_charge.first=v1;   _cut_charge.second=v2;   };

  void set_range_ped_mean(double v1, double v2)           {_cut_pedbase.first=v1;  _cut_pedbase.second=v2;  };

  void set_range_ped_rms(double v1, double v2)            {_cut_pedrms.first=v1;   _cut_pedrms.second=v2;   };

  void set_range_event_id(PMT::word_t v1, PMT::word_t v2) {_cut_event_id.first=v1; _cut_event_id.second=v2; };

  void set_range_channel(PMT::ch_number_t v1, PMT::ch_number_t v2) {_cut_channels.first=v1; _cut_channels.second=v2;};

  void set_range_sum_charge(double v1, double v2)         {_cut_sum_charge.first=v1; _cut_sum_charge.second=v2;};

  void set_range_sum_peak(double v1, double v2)           {_cut_sum_peak.first=v1; _cut_sum_peak.second=v2;};

  void set_range_npulse(double v1, double v2)             {_cut_npulse.first=v1; _cut_npulse.second=v2;};


  //
  // Getters
  //

  const std::pair<double,double> range_pulse_start_time() const   {return _cut_tstart;};

  const std::pair<double,double> range_pulse_start_time_reco() const   {return _cut_tstart_reco;};

  const std::pair<double,double> range_pulse_end_time() const     {return _cut_tend;};

  const std::pair<double,double> range_pulse_amp() const          {return _cut_amp;};

  const std::pair<double,double> range_pulse_charge() const       {return _cut_charge;};

  const std::pair<double,double> range_ped_mean() const           {return _cut_pedbase;};

  const std::pair<double,double> range_ped_rms() const            {return _cut_pedrms;};

  const std::pair<PMT::word_t,PMT::word_t> range_event_id() const {return _cut_event_id;};

  const std::pair<PMT::word_t,PMT::word_t> range_channel() const  {return _cut_channels;};

  const std::pair<double,double> range_sum_charge() const         {return _cut_sum_charge;};

  const std::pair<double,double> range_sum_peak() const           {return _cut_sum_peak;};

  const std::pair<UInt_t,UInt_t> range_npulse() const         {return _cut_npulse;};

protected:

  void set_style();
  
  void reset_cuts();

  void clear_map();
  
  void clear_viewer();
  
  TH1D* get_waveform(PMT::ch_number_t ch, size_t index);

  void add_channel_entry(PMT::ch_number_t ch);

  PMT::word_t _event_id;   
  double      _sum_charge; 
  double      _sum_peak;   
  UInt_t    _npulse;     
  std::set<PMT::ch_number_t>                           _channels;             
  std::set<PMT::ch_number_t>::iterator                 _ch_iter;              

  std::map<PMT::ch_number_t,std::pair<short,short> >   _pulse_count;          
  std::map<PMT::ch_number_t,std::vector<PMT::word_t> > _pulse_frame_id;       
  std::map<PMT::ch_number_t,std::vector<PMT::word_t> > _pulse_sample_number;  
  std::map<PMT::ch_number_t,std::vector<double> >      _pulse_tstart;         
  std::map<PMT::ch_number_t,std::vector<double> >      _pulse_tstart_reco;    
  std::map<PMT::ch_number_t,std::vector<double> >      _pulse_tend;           
  std::map<PMT::ch_number_t,std::vector<double> >      _pulse_amp;            
  std::map<PMT::ch_number_t,std::vector<double> >      _pulse_charge;         
  std::map<PMT::ch_number_t,std::vector<double> >      _pulse_pedbase;        
  std::map<PMT::ch_number_t,std::vector<double> >      _pulse_pedrms;         
  std::map<PMT::ch_number_t,std::map<PMT::word_t,std::map<PMT::word_t,std::vector<PMT::ch_adc_t> > > > _waveforms; 

  TCanvas* _cWF;
  
  // TPads to be drawn within the main canvas
  TPad *_pTitle; 
  TPad *_pData;  

  // TPads to be drawn within the _pData pad
  TPad *_pNote;  
  TPad *_pWF;    

  // Texts to on the pads
  TText     *_fTitle; 
  TPaveText *_fNote;  

  TH1D* _hWF;

  TLine *_lStart, *_lEnd, *_lBase, *_lRMSTop, *_lRMSBottom, *_lTop;

  std::pair<double,double> _cut_tstart, _cut_tstart_reco, _cut_tend, _cut_amp, _cut_charge, _cut_pedbase, _cut_pedrms;

  std::pair<double,double> _cut_sum_charge, _cut_sum_peak;

  std::pair<UInt_t,UInt_t> _cut_npulse;  

  std::pair<PMT::word_t,PMT::word_t> _cut_event_id;

  std::pair<PMT::ch_number_t,PMT::ch_number_t> _cut_channels;
};

#endif
 // end of doxygen group 

---