beamgate_debugger Class Reference
[Analysis, Analysis]

Analysis module to perform a simple analysis meant to be a data quality check for beamgate events. More...

#include <beamgate_debugger.hh>

Inheritance diagram for beamgate_debugger:


Public Member Functions
	beamgate_debugger ()
	Default constructor.
virtual	~beamgate_debugger ()
	Default destructor.
virtual bool	initialize ()
	Implementation of ana_base::initialize.
virtual bool	analyze (storage_manager *data)
	Implementation of ana_base::analyze.
virtual bool	finalize ()
	Implementation of ana_base::finalize.
void	set_max_adc (PMT::ch_adc_t val)
	Setter for maximum ADC count to be plotted.
void	set_beam_window_size (PMT::word_t n)
	Setter for beam window width.
void	set_pre_ped_nsample (UShort_t n)
	This is taken from the beginning of the waveform.
void	set_post_ped_nsample (UShort_t n)
	This is taken from the end of the waveform.
void	set_output_file (TFile *fout)
	A setter for analysis output file poitner.
void	set_verbosity (MSG::Level level)
	Setter for the verbosity level.
MSG::Level	get_verbosity () const
	Getter for the verbosity level.
const std::string	class_name () const
	Getter for the class name.
Protected Attributes
TFile *	_fout
	Analysis output file pointer.
char	_buf [200]
	char buffer for message manipulation
bool	_verbosity [MSG::MSG_TYPE_MAX]
	holder for enabled message levels
MSG::Level	_verbosity_level
	holder for specified verbosity level
std::string	_name
	class name holder
Private Member Functions
void	reset ()
	Initialize data members.
void	prepare_histo ()
	Prepare histograms.
void	get_ped_info (double &mean, double &rms, const std::vector< double > *sample) const
	A method to calculate pedestal mean and rms.
Private Attributes
TH2D *	_hSampleSize
TH2D *	_hPrePedMean
TH2D *	_hPostPedMean
TH2D *	_hPrePedRMS
TH2D *	_hPostPedRMS
TH2D *	_hMaxADC
TH2D *	_hMaxTime
PMT::ch_adc_t	_adc_max
PMT::ch_number_t	_ch_cnt
PMT::word_t	_beam_window_width
UShort_t	_pre_nsample
UShort_t	_post_nsample
std::vector< double >	_pre_sample
std::vector< double >	_post_sample

Detailed Description

Analysis module to perform a simple analysis meant to be a data quality check for beamgate events.

Definition at line 27 of file beamgate_debugger.hh.

Constructor & Destructor Documentation

beamgate_debugger::beamgate_debugger ( )

Default constructor.

Definition at line 6 of file beamgate_debugger.cc.

References _hMaxADC, _hMaxTime, _hPostPedMean, _hPostPedRMS, _hPrePedMean, _hPrePedRMS, _hSampleSize, decoder_base::_name, _post_nsample, and _pre_nsample.

00007   : ana_base(), _pre_sample(), _post_sample()
00008 {
00009 
00010   _name="beamgate_debugger";
00011   _hPrePedMean=0;
00012   _hPrePedRMS=0;
00013   
00014   _hPostPedMean=0;
00015   _hPostPedRMS=0;
00016 
00017   _hMaxADC=0;
00018   _hMaxTime=0;
00019 
00020   _hSampleSize=0;
00021 
00022   _pre_nsample=6;
00023   _post_nsample=6;
00024 
00025 }

virtual beamgate_debugger::~beamgate_debugger ( ) [inline, virtual]

Default destructor.

Definition at line 35 of file beamgate_debugger.hh.

00035 {};

Member Function Documentation

bool beamgate_debugger::analyze ( storage_manager * data ) [virtual]

Implementation of ana_base::analyze.

Implements ana_base.

Definition at line 135 of file beamgate_debugger.cc.

References _beam_window_width, _hMaxADC, _hMaxTime, _hPostPedMean, _hPostPedRMS, _hPrePedMean, _hPrePedRMS, _hSampleSize, _post_nsample, _post_sample, _pre_nsample, _pre_sample, PMT::BASE_DISC, PMT::BEAM_DISC, PMT::BEAM_WIN, PMT::COSMIC_DISC, PMT::DISC_MAX, storage_manager::get_data(), get_ped_info(), PMT::MICHEL_DISC, and DATA_STRUCT::PMT_WF_COLLECTION.

00135                                                     {
00136 
00137   bool beam_wf=false;
00138 
00139   double ped_mean=0;
00140   double ped_rms=0;
00141 
00142   PMT::ch_adc_t max_adc=0;
00143   UShort_t max_time=0;
00144   UShort_t index=0;
00145 
00146   pmt_wf_collection *ewf = (pmt_wf_collection*)(data->get_data(DATA_STRUCT::PMT_WF_COLLECTION));
00147 
00148   for(std::vector<pmt_waveform>::const_iterator wf_iter(ewf->begin());
00149       wf_iter!=ewf->end();
00150       ++wf_iter){
00151 
00152     beam_wf=false;
00153     switch((*wf_iter).disc_id()) {
00154     case PMT::BEAM_DISC:
00155     case PMT::BEAM_WIN:
00156       beam_wf=true;
00157       break;
00158     case PMT::BASE_DISC:
00159     case PMT::COSMIC_DISC:
00160     case PMT::MICHEL_DISC:
00161       beam_wf=( (*wf_iter).size()>_beam_window_width );
00162       break;
00163     case PMT::DISC_MAX:
00164       break;
00165     }
00166     if(!beam_wf) continue;
00167 
00168     _hSampleSize->Fill((*wf_iter).channel_number()+1,((*wf_iter).size()));
00169 
00170     ped_mean=0;
00171     ped_rms=0;
00172     max_adc=0;
00173     max_time=0;
00174     index=0;
00175 
00176     _pre_sample.clear();
00177     _post_sample.clear();
00178 
00179     for(pmt_waveform::const_iterator adc_iter((*wf_iter).begin());
00180     adc_iter!=(*wf_iter).end();
00181     ++adc_iter) {
00182       
00183       if( index < _pre_nsample )
00184 
00185     _pre_sample.push_back((double)((*adc_iter)));
00186 
00187       if( index >= ((*wf_iter).size() - _post_nsample) )
00188 
00189     _post_sample.push_back((double)((*adc_iter)));
00190 
00191       if( (*adc_iter) > max_adc ) {
00192     max_adc  = (*adc_iter);
00193     max_time = index;
00194       }
00195       
00196       index++;
00197     }
00198 
00199     get_ped_info(ped_mean,ped_rms,&_pre_sample);
00200     _hPrePedMean->Fill((*wf_iter).channel_number(), ped_mean);
00201     _hPrePedRMS->Fill((*wf_iter).channel_number(), ped_rms);
00202 
00203     get_ped_info(ped_mean,ped_rms,&_post_sample);
00204     _hPostPedMean->Fill((*wf_iter).channel_number(), ped_mean);
00205     _hPostPedRMS->Fill((*wf_iter).channel_number(), ped_rms);
00206 
00207     _hMaxADC->Fill((*wf_iter).channel_number(), max_adc);
00208     _hMaxTime->Fill((*wf_iter).channel_number(), max_time);
00209   }
00210 
00211 
00212   return true;
00213   
00214 }

const std::string decoder_base::class_name ( ) const [inline, inherited]

Getter for the class name.

Definition at line 46 of file decoder_base.hh.

References decoder_base::_name.

00046 {return _name;};

bool beamgate_debugger::finalize ( ) [virtual]

Implementation of ana_base::finalize.

Implements ana_base.

Definition at line 216 of file beamgate_debugger.cc.

References ana_base::_fout, _hMaxADC, _hMaxTime, _hPostPedMean, _hPostPedRMS, _hPrePedMean, _hPrePedRMS, decoder_base::_verbosity, MSG::DEBUG, and Message::send().

00216                                 {
00217 
00218   if(_verbosity[MSG::DEBUG])
00219     Message::send(MSG::DEBUG,__FUNCTION__,"called...");
00220 
00221   _fout->cd();
00222   _hPrePedMean->Write();
00223   _hPrePedRMS->Write();
00224   _hPostPedMean->Write();
00225   _hPostPedRMS->Write();
00226   _hMaxADC->Write();
00227   _hMaxTime->Write();
00228 
00229   if(_verbosity[MSG::DEBUG])
00230     Message::send(MSG::DEBUG,__FUNCTION__,"ends...");
00231 
00232   return true;
00233 
00234 }

void beamgate_debugger::get_ped_info	(	double &	mean,
		double &	rms,
		const std::vector< double > *	sample
	)			const `[inline, private]`

A method to calculate pedestal mean and rms.

Definition at line 73 of file beamgate_debugger.hh.

Referenced by analyze().

00073 {if(sample) {mean=0;rms=0;}};

MSG::Level decoder_base::get_verbosity ( ) const [inline, inherited]

Getter for the verbosity level.

Definition at line 43 of file decoder_base.hh.

References decoder_base::_verbosity_level.

00043 {return _verbosity_level;};

bool beamgate_debugger::initialize ( ) [virtual]

Implementation of ana_base::initialize.

Implements ana_base.

Definition at line 27 of file beamgate_debugger.cc.

References _adc_max, _beam_window_width, _ch_cnt, _post_nsample, _post_sample, _pre_nsample, _pre_sample, decoder_base::_verbosity, PMT::BEAMGATE_NSAMPLE, MSG::DEBUG, PMT::MAX_ADC, PMT::NUM_PMT_CHANNEL, prepare_histo(), reset(), and Message::send().

00027                                   {
00028   if(_verbosity[MSG::DEBUG])
00029     Message::send(MSG::DEBUG,__FUNCTION__,"called...");
00030 
00031   reset();
00032   prepare_histo();
00033   _pre_sample.reserve(_pre_nsample);
00034   _post_sample.reserve(_post_nsample);
00035 
00036   _ch_cnt=PMT::NUM_PMT_CHANNEL;
00037   _beam_window_width=PMT::BEAMGATE_NSAMPLE;
00038   _adc_max=PMT::MAX_ADC;  
00039 
00040   if(_verbosity[MSG::DEBUG])
00041     Message::send(MSG::DEBUG,__FUNCTION__,"ends...");
00042 
00043   return true;
00044 }

void beamgate_debugger::prepare_histo ( ) [private]

Prepare histograms.

Definition at line 73 of file beamgate_debugger.cc.

References _adc_max, _beam_window_width, _ch_cnt, _hMaxADC, _hMaxTime, _hPostPedMean, _hPostPedRMS, _hPrePedMean, _hPrePedRMS, _hSampleSize, _post_nsample, _pre_nsample, decoder_base::_verbosity, MSG::DEBUG, and Message::send().

Referenced by initialize().

00073                                      {
00074 
00075   if(_verbosity[MSG::DEBUG])
00076     Message::send(MSG::DEBUG,__FUNCTION__,"called...");
00077 
00078   if(!_hSampleSize)
00079     _hSampleSize = new TH2D("hSampleSize",
00080                 "Number of ADC words; Channel Number; Number of words",
00081                 _ch_cnt,  -0.5, _ch_cnt-0.5,
00082                 int(_beam_window_width*1.5), -0.5, (double)(int(_beam_window_width*1.5)-0.5));
00083   else _hSampleSize->Reset();
00084 
00085   if(!_hPrePedMean)
00086     _hPrePedMean = new TH2D("hPrePedMean",
00087                   Form("Pedestal mean from first %d samples; Channel Number; Ped. Mean",
00088                    _pre_nsample),
00089                   _ch_cnt, -0.5, _ch_cnt-0.5,
00090                   80,2030,2070);
00091   else _hPrePedMean->Reset();
00092 
00093   if(!_hPostPedMean)
00094     _hPostPedMean = new TH2D("hPostPedMean",
00095                   Form("Pedestal mean from last %d samples; Channel Number; Ped. Mean",
00096                    _post_nsample),
00097                   _ch_cnt, -0.5, _ch_cnt-0.5,
00098                   80,2030,2070);
00099   else _hPostPedMean->Reset();
00100 
00101   if(!_hPrePedRMS)
00102     _hPrePedRMS = new TH2D("hPrePedRMS",
00103                Form("Pedestal RMS from first %d samples; Channel Number; Ped. RMS",
00104                 _pre_nsample),
00105                _ch_cnt, -0.5, _ch_cnt-0.5,
00106                40,0,20);
00107   else _hPrePedRMS->Reset();
00108 
00109   if(!_hPostPedRMS)
00110     _hPostPedRMS = new TH2D("hPostPedRMS",
00111                Form("Pedestal RMS from first %d samples; Channel Number; Ped. RMS",
00112                 _post_nsample),
00113                _ch_cnt, -0.5, _ch_cnt-0.5,
00114                40,0,20);
00115   else _hPostPedRMS->Reset();
00116 
00117   if(!_hMaxADC)
00118     _hMaxADC = new TH2D("hMaxADC",
00119             "Maximum ADC Counts; Channel Number; Max ADC",
00120             _ch_cnt, -0.5, _ch_cnt-0.5,
00121             _adc_max,-0.5,_adc_max-0.5);
00122   else _hMaxADC->Reset();
00123 
00124   if(!_hMaxTime)
00125     _hMaxTime = new TH2D("hMaxTime",
00126             "Maximum Time Counts; Channel Number; Max Time",
00127             _ch_cnt, -0.5, _ch_cnt-0.5,
00128              100,0,_beam_window_width*1.5);
00129   else _hMaxTime->Reset();
00130 
00131   if(_verbosity[MSG::DEBUG])
00132     Message::send(MSG::DEBUG,__FUNCTION__,"ends...");
00133 }

void beamgate_debugger::reset ( ) [private]

Initialize data members.

Definition at line 46 of file beamgate_debugger.cc.

References _hMaxADC, _hMaxTime, _hPostPedMean, _hPostPedRMS, _hPrePedMean, _hPrePedRMS, _hSampleSize, _post_sample, _pre_sample, decoder_base::_verbosity, MSG::DEBUG, and Message::send().

Referenced by initialize().

00046                              {
00047   
00048   if(_verbosity[MSG::DEBUG])
00049     Message::send(MSG::DEBUG,__FUNCTION__,"called...");
00050   
00051   if(_hSampleSize)   delete  _hSampleSize;
00052   if(_hPrePedMean)   delete  _hPrePedMean;
00053   if(_hPrePedRMS)    delete  _hPrePedRMS;
00054   if(_hPostPedMean)  delete  _hPostPedMean;
00055   if(_hPostPedRMS)   delete  _hPostPedRMS;
00056   if(_hMaxADC)       delete  _hMaxADC;
00057   if(_hMaxTime)      delete  _hMaxTime;
00058 
00059   _hSampleSize=0;
00060   _hPrePedMean=0;
00061   _hPostPedMean=0;
00062   _hPrePedRMS=0;
00063   _hPostPedRMS=0;
00064   _hMaxADC=0;
00065   _hMaxTime=0;
00066   _pre_sample.clear();
00067   _post_sample.clear();
00068 
00069   if(_verbosity[MSG::DEBUG])
00070     Message::send(MSG::DEBUG,__FUNCTION__,"ends...");  
00071 }

void beamgate_debugger::set_beam_window_size ( PMT::word_t n ) [inline]

Setter for beam window width.

Definition at line 50 of file beamgate_debugger.hh.

References _beam_window_width.

00050 {_beam_window_width=n;};

void beamgate_debugger::set_max_adc ( PMT::ch_adc_t val ) [inline]

Setter for maximum ADC count to be plotted.

Definition at line 47 of file beamgate_debugger.hh.

References _adc_max.

00047 {_adc_max=val;};

void ana_base::set_output_file ( TFile * fout ) [inline, inherited]

A setter for analysis output file poitner.

Definition at line 46 of file ana_base.hh.

References ana_base::_fout.

00046 {_fout=fout;};

void beamgate_debugger::set_post_ped_nsample ( UShort_t n ) [inline]

This is taken from the end of the waveform.

Definition at line 62 of file beamgate_debugger.hh.

References _post_nsample.

00062 {_post_nsample=n;};

void beamgate_debugger::set_pre_ped_nsample ( UShort_t n ) [inline]

This is taken from the beginning of the waveform.

Definition at line 56 of file beamgate_debugger.hh.

References _pre_nsample.

00056 {_pre_nsample=n;};

void decoder_base::set_verbosity ( MSG::Level level ) [inherited]

Setter for the verbosity level.

Reimplemented in ana_processor.

Definition at line 11 of file decoder_base.cc.

References decoder_base::_verbosity, decoder_base::_verbosity_level, MSG::DEBUG, MSG::ERROR, MSG::INFO, MSG::MSG_TYPE_MAX, MSG::NORMAL, and MSG::WARNING.

Referenced by algo_slow_readout_decoder::algo_slow_readout_decoder(), compare_content(), decoder_base::decoder_base(), decoder_manager::decoder_manager(), decoder_manager::initialize(), main(), xmit_event_search::run(), bin_word_search::run(), and ana_processor::set_verbosity().

00011                                               {
00012 
00013   _verbosity_level=level;
00014 
00015   for(size_t i=(size_t)(MSG::DEBUG); i<(size_t)(MSG::MSG_TYPE_MAX); ++i)
00016     _verbosity[i]=false;
00017 
00018   switch(level){
00019   case MSG::DEBUG:
00020     _verbosity[MSG::DEBUG]=true;
00021   case MSG::INFO:
00022     _verbosity[MSG::INFO]=true;
00023   case MSG::NORMAL:
00024     _verbosity[MSG::NORMAL]=true;
00025   case MSG::WARNING:
00026     _verbosity[MSG::WARNING]=true;
00027   case MSG::ERROR:
00028     _verbosity[MSG::ERROR]=true;
00029   case MSG::MSG_TYPE_MAX:
00030     break;
00031   }
00032 
00033 }