ChannelData.hh

Go to the documentation of this file.

#ifndef CHANNELDATA_h
#define CHANNELDATA_h

#include "Rtypes.h" //has the classdef macro
#include <string>
#include <vector>
#include <utility>
#include <stdint.h>

//subclasses
#include "Pulse.hh"
#include "Baseline.hh"
#include "Spe.hh"
#include "Unspikes.hh"
#include "Roi.hh"
#include "TOF.hh"

class TGraph;
//notice: members with comment starting with ! are not saved
class ChannelData{
  //interface
public:
  ChannelData() { Clear(); }
  virtual ~ChannelData(){}
  void Clear(); 

  TGraph* GetTGraph(bool baseline_subtracted = false, int downsample=1) const; 
  void Draw(bool baseline_subtracted = false, int downsample=1,
            bool autoscalex=true, bool autoscaley=true, double xmin=0,
            double xmax=0, double ymin=0, double ymax=0); 
  void Print (int verbosity);  
  int TimeToSample(double time, bool checkrange=false);
  double SampleToTime(int sample){ return (sample - trigger_index)/sample_rate;}
  const double* GetWaveform() const { return &(waveform[0]); }
  double* GetWaveform() { return &(waveform[0]); }
  const double* GetBaselineSubtractedWaveform() const 
  { return &(subtracted_waveform[0]); }
  double* GetBaselineSubtractedWaveform()
  { return &(subtracted_waveform[0]); }
  const double* GetIntegralWaveform() const 
  { return &(integral[0]); }
  double* GetIntegralWaveform()
  { return &(integral[0]); }
  
  double GetVerticalRange() const { return ((uint64_t)1<<sample_bits) - 1; } 
public:
  enum ID_TYPES { CH_INVALID=-1, CH_SUM=-2 };
public:
  //data members
  //raw-ish information
  int board_id;  
  int board_num; 
  int channel_num; 
  int channel_id; 
  std::string label; 
  uint64_t timestamp; 
  int sample_bits; 
  double sample_rate; 
  int trigger_index; 
  int nsamps; 
  double smoothed_min; 
  double smoothed_max; 
  std::vector<double> generic; 
  bool saturated; 
  double maximum; 
  double minimum; 
  double max_time; 
  double min_time; 
  const char* channel_start; 
  const char* channel_end;   
  double spe_mean;     
  double spe_sigma;
  //vector waveforms
  std::vector<double> waveform; 
  std::vector<std::pair<int,int> > unsuppressed_regions; 
  
  //processed information
  
  //baseline finding
  Baseline baseline;  
  std::vector<double> subtracted_waveform; 
  //individual pulses
  int npulses; 
  std::vector<Pulse> pulses; 
  std::vector<Roi> regions; 
  TOF tof; 

  //differentiator
  std::vector<double> derivative; 
  //smoothed data
  std::vector<double> smoothed_data; 
  std::vector<Spe> single_pe; 
  std::vector<Unspikes> unspikes; 

  //integrator
  std::vector<double> integral; 
  double integral_max;      
  double integral_min;      
  int integral_max_index;   
  int integral_min_index;   
  double integral_max_time; 
  double integral_min_time; 
  
  //energy variables
  double s1_full;    
  double s2_full;    
  double s1_fixed;   
  double s2_fixed;   
  ClassDef(ChannelData,14)
};

inline void ChannelData::Clear()
{
  board_id = -1;
  board_num = -1;
  channel_num = -1;
  channel_id = -1;
  label = "";
  timestamp = 0;
  sample_bits = -1;
  sample_rate = -1;
  trigger_index = -1;
  nsamps = -1;
  saturated = false;
  maximum=-1;
  minimum=-1;
  generic.clear();
  channel_start = NULL;
  channel_end = NULL;
  spe_mean = 1.;
  spe_sigma = 0.;

  baseline.Clear();
  tof.Clear();
  subtracted_waveform.clear();
  npulses=0;
  pulses.clear();
  single_pe.clear();
  derivative.clear();
  smoothed_data.clear();
  smoothed_min = -1; 
  smoothed_max = -1;
  integral.clear();
  integral_max = -1;
  integral_min = -1;
  integral_max_index = -1;
  integral_min_index = -1;
  integral_max_time = -1;
  integral_min_time = -1;
  s1_full = 0;
  s2_full = 0;
  s1_fixed = 0;
  s2_fixed = 0;
}

inline int ChannelData::TimeToSample(double time, bool checkrange)
{ 
  int samp = (int)(time*sample_rate + trigger_index);
  if(checkrange){
    if(samp < 0) samp = 0;
    if(samp > nsamps-1) samp = nsamps-1;
  }
  return samp;
}

#endif