PndEmcPSAFPGAPileupAnalyser Class Reference

#include <PndEmcPSAFPGAPileupAnalyser.h>

Inheritance diagram for PndEmcPSAFPGAPileupAnalyser:

Public Types
enum	pileup_t { kSingle =0, kPileup1 =1, kPileup2 =2, kInvalid =99 }
enum	status_t {   kBaseline, kInPulse, kPulseDetected, kPulseFinished,   kPileupFinished, kUndefined =99 }

Public Member Functions
	PndEmcPSAFPGAPileupAnalyser ()
virtual	~PndEmcPSAFPGAPileupAnalyser ()
virtual void	SetVerbose (Int_t verbose=0)
virtual void	initFromFile ()
virtual void	Init (const std::vector< Double_t > &params, TF1 *R_thres, TF1 *R_mean, float extBaselineValue=0)
virtual void	Init (const std::vector< Double_t > &params, TF1 *R_thres, TF1 *R_mean, unsigned int baselineStartSample, unsigned int baselineStopSample)
virtual void	GetHit (Int_t i, Double_t &Energy, Double_t &Time)
	Get energy and time of hit. More...
virtual void	GetHit (Int_t i, Double_t &Energy, Double_t &Time, pileup_t &PileupType)
void	GetEnergyMeasures (Int_t i, Double_t &Amplitude, Double_t &Integral)
virtual void	reset ()
virtual void	put (float valueToStore)
virtual float	baseline ()
virtual void	initFromFile (const std::string &fname)
int	nHits ()
float	sampleTime (int index)
float	sampleAmplitude (int index)
float	sampleIntegral (int index)
virtual Int_t	Process (const PndEmcWaveform *waveform)
	Find Hits in Waveform. More...
virtual void	Process (const PndEmcWaveform *waveform, Double_t &amplitude, Double_t &time)
	Deprecated. Do not use. More...
virtual void	Reset ()
	reset found hits More...
virtual void	Init (const std::vector< Double_t > &params)
status_t	GetStatus ()
	ClassDef (PndEmcAbsPSA, 1)

Protected Types
enum	{ kWindow, kExtern, kFollow }

Protected Member Functions
virtual void	setBaseline (float newBaseline)
virtual void	setBaselineWindow (unsigned int startSample, unsigned int stopSample)
virtual void	InitParameters (const std::vector< Double_t > &params)
virtual void	Init2 (const std::vector< Double_t > &params, TF1 *R_thres, TF1 *R_mean)
	ClassDef (PndEmcPSAFPGAPileupAnalyser, 2)
virtual void	init (SampleAnalyserParams &params)
	ClassDef (PndEmcPSAFPGASampleAnalyser, 2)

Protected Attributes
enum PndEmcPSAFPGAPileupAnalyser:: { ... }	baselineMode
Int_t	fVerbose
TF1 *	Int_thres
TF1 *	Int_mean
unsigned int	BaselineStartSample
unsigned int	BaselineStopSample
float	BaselineSum
PndEmcPSAFPGAFilterMWD *	MWD_filter1
PndEmcPSAFPGAFilterMWD *	MWD_filter2
PndEmcPSAFPGAFilterMWD *	MWD_filter3
PndEmcPSAFPGAFilterDelay *	CF_prev
bool	energy_finished
bool	timing_finished
bool	func_defined
unsigned int	cf_crossing
bool	in_cfRise
float	cfZero [MAX_NUMBER_OF_HITS]
float	cfRise [MAX_NUMBER_OF_HITS]
pileup_t	pileups [MAX_NUMBER_OF_HITS]
SampleAnalyserParams	analyserParams
float	baseline_value
unsigned int	local_time
bool	pulse_detected
int	rough_pulse_timing
int	cf_zero_crossing_points
PndEmcPSAFPGAFilterCF *	CF_filter
PndEmcPSAFPGAFilterMA *	MA_triggering
PndEmcPSAFPGAFilterDelay *	MA_delay
PndEmcPSAFPGAFilterDelay *	CF_delay
PndEmcPSAFPGAFilterDelay *	Signal_delay
PndEmcPSAFPGALinFitter *	CF_Fitter
int	Number_of_hits
float	time [MAX_NUMBER_OF_HITS]
float	integral [MAX_NUMBER_OF_HITS]
float	amplitude [MAX_NUMBER_OF_HITS]
status_t	status

Detailed Description

Definition at line 17 of file PndEmcPSAFPGAPileupAnalyser.h.

Member Enumeration Documentation

anonymous enum

protected

Enumerator
kWindow
kExtern
kFollow

Definition at line 41 of file PndEmcPSAFPGAPileupAnalyser.h.

{kWindow, kExtern, kFollow} baselineMode;

enum PndEmcPSAFPGAPileupAnalyser::pileup_t

Enumerator
kSingle
kPileup1
kPileup2
kInvalid

Definition at line 24 of file PndEmcPSAFPGAPileupAnalyser.h.

{kSingle=0, kPileup1=1, kPileup2=2, kInvalid=99};

enum PndEmcPSAFPGASampleAnalyser::status_t

inherited

Enumerator
kBaseline
kInPulse
kPulseDetected
kPulseFinished
kPileupFinished
kUndefined

Definition at line 57 of file PndEmcPSAFPGASampleAnalyser.h.

{kBaseline, kInPulse, kPulseDetected, kPulseFinished, kPileupFinished, kUndefined=99};

Constructor & Destructor Documentation

PndEmcPSAFPGAPileupAnalyser::PndEmcPSAFPGAPileupAnalyser

(

)

Definition at line 13 of file PndEmcPSAFPGAPileupAnalyser.cxx.

                                                         :
  PndEmcPSAFPGASampleAnalyser(), fVerbose(0), Int_thres(NULL), Int_mean(NULL), MWD_filter1(NULL), MWD_filter2(NULL), MWD_filter3(NULL), CF_prev(NULL), func_defined(false) {
}

PndEmcPSAFPGAPileupAnalyser::~PndEmcPSAFPGAPileupAnalyser ( )

virtual

Definition at line 17 of file PndEmcPSAFPGAPileupAnalyser.cxx.

References CF_prev, Int_mean, Int_thres, MWD_filter1, MWD_filter2, and MWD_filter3.

                                                          {
        if(Int_thres!=NULL) delete Int_thres;
        if(Int_mean!=NULL) delete Int_mean;
        if(MWD_filter1!=NULL) delete MWD_filter1;
        if(MWD_filter2!=NULL) delete MWD_filter2;
        if(MWD_filter3!=NULL) delete MWD_filter3;
        if(CF_prev!=NULL) delete CF_prev;
}

Member Function Documentation

virtual float PndEmcPSAFPGAPileupAnalyser::baseline ( )

inlinevirtual

Implements PndEmcPSAFPGASampleAnalyser.

Definition at line 37 of file PndEmcPSAFPGAPileupAnalyser.h.

References PndEmcPSAFPGASampleAnalyser::baseline_value.

{return baseline_value;};

PndEmcAbsPSA::ClassDef ( PndEmcAbsPSA  , 1    )

inherited

PndEmcPSAFPGAPileupAnalyser::ClassDef ( PndEmcPSAFPGAPileupAnalyser  , 2    )

protected

PndEmcPSAFPGASampleAnalyser::ClassDef ( PndEmcPSAFPGASampleAnalyser  , 2    )

protectedinherited

void PndEmcPSAFPGAPileupAnalyser::GetEnergyMeasures	(	Int_t	i,
		Double_t &	Amplitude,
		Double_t &	Integral
	)

Definition at line 148 of file PndEmcPSAFPGAPileupAnalyser.cxx.

References PndEmcPSAFPGASampleAnalyser::sampleAmplitude(), and PndEmcPSAFPGASampleAnalyser::sampleIntegral().

                                                                                                    {
        Amplitude = sampleAmplitude(i);
        Integral = sampleIntegral(i);
}

void PndEmcPSAFPGAPileupAnalyser::GetHit ( Int_t  i, Double_t &  energy, Double_t &  time  )

virtual

Get energy and time of hit.

Parameters

Int_t	Index of Hit
Double_t	Energy of Hit
Double_t	Time of Hit

Returns

Reimplemented from PndEmcPSAFPGASampleAnalyser.

Definition at line 132 of file PndEmcPSAFPGAPileupAnalyser.cxx.

References PndEmcPSAFPGASampleAnalyser::sampleAmplitude(), and PndEmcPSAFPGASampleAnalyser::sampleTime().

Referenced by GetHit().

                                                                                  {
        Energy = sampleAmplitude(i);
        Time = sampleTime(i);
}

void PndEmcPSAFPGAPileupAnalyser::GetHit ( Int_t  i, Double_t &  Energy, Double_t &  Time, pileup_t &  PileupType  )

virtual

Definition at line 138 of file PndEmcPSAFPGAPileupAnalyser.cxx.

References GetHit(), i, kInvalid, PndEmcPSAFPGASampleAnalyser::nHits(), and pileups.

                                                                                                        {
        GetHit(i, Energy, Time);
        if(i < nHits() && i >=0) {
                PileupType = pileups[i];
        } else {
                PileupType = kInvalid;
        }
}

status_t PndEmcPSAFPGASampleAnalyser::GetStatus ( )

inlineinherited

Definition at line 58 of file PndEmcPSAFPGASampleAnalyser.h.

References PndEmcPSAFPGASampleAnalyser::status.

Referenced by PndEmcHighLowPSA::Process().

{ return status; }

void PndEmcPSAFPGAPileupAnalyser::Init ( const std::vector< Double_t > &  params, TF1 *  R_thres, TF1 *  R_mean, float  extBaselineValue = 0  )

virtual

Definition at line 70 of file PndEmcPSAFPGAPileupAnalyser.cxx.

References Init2(), and setBaseline().

Referenced by PndEmcFWEndcapDigi::Init().

                                                                                                                           {
        Init2(params, r_thres, r_mean);
        setBaseline(extBaselineValue);
}

void PndEmcPSAFPGAPileupAnalyser::Init ( const std::vector< Double_t > &  params, TF1 *  R_thres, TF1 *  R_mean, unsigned int  baselineStartSample, unsigned int  baselineStopSample  )

virtual

Definition at line 75 of file PndEmcPSAFPGAPileupAnalyser.cxx.

References Init2(), and setBaselineWindow().

                                                                                                                                                                      {
        Init2(params, r_thres, r_mean);
        setBaselineWindow(baselineStartSample, baselineStopSample);
}

void PndEmcPSAFPGASampleAnalyser::Init ( const std::vector< Double_t > &  params )

virtualinherited

Definition at line 132 of file PndEmcPSAFPGASampleAnalyser.cxx.

References PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_delay, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_fit_offset, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_fitter_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_ratio, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::clock_unit, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::hit_threshold, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::iafactor, PndEmcPSAFPGASampleAnalyser::init(), PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::ma_trig_M, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd_length, and PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd_tau.

                                                                       {
        SampleAnalyserParams newParams;
        newParams.ma_trig_M = (int) params.at(0);
        newParams.hit_threshold = params.at(1);
        newParams.cf_delay = (int) params.at(2);
        newParams.cf_ratio = params.at(3);
        newParams.cf_fitter_length = (int) params.at(4);
        newParams.cf_fit_offset = (int) params.at(5);
        newParams.mwd_length = (int) params.at(6);
        newParams.mwd_tau = params.at(7);
        newParams.clock_unit = params.at(8);
        newParams.iafactor = params.at(9);
        /*
        std::cout << newParams.ma_trig_M << std::endl;
        std::cout << newParams.hit_threshold << std::endl;
        std::cout << newParams.cf_delay << std::endl;
        std::cout << newParams.cf_ratio << std::endl;
        std::cout << newParams.cf_fitter_length << std::endl;
        std::cout << newParams.cf_fit_offset << std::endl;
        std::cout << newParams.mwd_length << std::endl;
        std::cout << newParams.mwd_tau << std::endl;
*/
  init(newParams);
  return;
}

void PndEmcPSAFPGASampleAnalyser::init ( PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams &  params )

protectedvirtualinherited

Reimplemented in PndEmcPSAFPGADigitalFilterAnalyser.

Definition at line 45 of file PndEmcPSAFPGASampleAnalyser.cxx.

References PndEmcPSAFPGASampleAnalyser::analyserParams, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_delay, PndEmcPSAFPGASampleAnalyser::CF_delay, PndEmcPSAFPGASampleAnalyser::CF_filter, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_fit_offset, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_fitter_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_ratio, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::clock_unit, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::hit_threshold, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::iafactor, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::ma_trig_M, PndEmcPSAFPGASampleAnalyser::MA_triggering, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd2_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd2_tau, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd3_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd3_tau, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd_tau, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::rough_timing_corr, PndEmcPSAFPGAFilterDelay::set(), PndEmcPSAFPGAFilterMA::set(), PndEmcPSAFPGAFilterCF::set(), PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::sig_delay, and PndEmcPSAFPGASampleAnalyser::Signal_delay.

Referenced by PndEmcPSAFPGADigitalFilterAnalyser::init(), PndEmcPSAFPGASampleAnalyser::Init(), PndEmcPSAFPGASampleAnalyser::initFromFile(), and InitParameters().

                                                                                              {
  analyserParams.hit_threshold = params.hit_threshold;
  analyserParams.ma_trig_M = params.ma_trig_M;
  analyserParams.cf_delay = params.cf_delay;
  analyserParams.cf_ratio = params.cf_ratio;
  analyserParams.cf_fitter_length = params.cf_fitter_length;
  analyserParams.cf_fit_offset = params.cf_fit_offset;
  analyserParams.mwd_length = params.mwd_length;
  analyserParams.mwd_tau = params.mwd_tau;
  analyserParams.mwd2_length = params.mwd2_length;
  analyserParams.mwd2_tau = params.mwd2_tau;
  analyserParams.mwd3_length = params.mwd3_length;
  analyserParams.mwd3_tau = params.mwd3_tau;
  analyserParams.sig_delay = params.sig_delay;
  analyserParams.rough_timing_corr = params.rough_timing_corr;
  analyserParams.clock_unit= params.clock_unit;
  analyserParams.iafactor= params.iafactor;

  CF_filter->set(analyserParams.cf_delay, analyserParams.cf_ratio);
  Signal_delay->set(analyserParams.cf_delay + analyserParams.cf_delay/2);
  MA_triggering->set(analyserParams.ma_trig_M);
  CF_delay->set(analyserParams.cf_fit_offset);

  return;
}

void PndEmcPSAFPGAPileupAnalyser::Init2 ( const std::vector< Double_t > &  params, TF1 *  R_thres, TF1 *  R_mean  )

protectedvirtual

Definition at line 81 of file PndEmcPSAFPGAPileupAnalyser.cxx.

References PndEmcPSAFPGASampleAnalyser::analyserParams, CF_prev, func_defined, InitParameters(), Int_mean, Int_thres, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd2_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd2_tau, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd3_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd3_tau, MWD_filter1, MWD_filter2, MWD_filter3, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd_tau, PndEmcPSAFPGAFilterDelay::set(), PndEmcPSAFPGAFilterMWD::set(), PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::sig_delay, and PndEmcPSAFPGASampleAnalyser::Signal_delay.

Referenced by Init().

                                                                                                    {

        InitParameters(params);
        Signal_delay->set(analyserParams.sig_delay);

        if(MWD_filter1!=NULL) delete MWD_filter1;
        MWD_filter1 = new PndEmcPSAFPGAFilterMWD();
        if(MWD_filter2!=NULL) delete MWD_filter2;
        MWD_filter2 = new PndEmcPSAFPGAFilterMWD();
        if(MWD_filter3!=NULL) delete MWD_filter3;
        MWD_filter3 = new PndEmcPSAFPGAFilterMWD();
        if(CF_prev!=NULL) delete CF_prev;
        CF_prev = new PndEmcPSAFPGAFilterDelay();

        MWD_filter1->set(analyserParams.mwd_tau, analyserParams.mwd_length);
        MWD_filter2->set(analyserParams.mwd2_tau, analyserParams.mwd2_length);
        MWD_filter3->set(analyserParams.mwd3_tau, analyserParams.mwd3_length);
        CF_prev->set(1);

        if(r_mean!=NULL && r_thres!=NULL) {
                func_defined = true;

                if(Int_thres!=NULL) delete Int_thres;
                Int_thres = new TF1("intThres", "(" +r_thres->GetExpFormula() + ")*x", r_thres->GetXmin(), r_thres->GetXmax());
                Int_thres->SetParameters(r_thres->GetParameters());
                Int_thres->SetNpx(1000);

                if(Int_mean!=NULL) delete Int_mean;
                Int_mean = new TF1("intMean", "(" +r_mean->GetExpFormula() + ")*x", r_mean->GetXmin(), r_mean->GetXmax());
                Int_mean->SetParameters(r_mean->GetParameters());
                Int_mean->SetNpx(1000);

        } else {
                std::cerr << "-W PndEmcPSAFPGAPileupAnalyser:Init2 no pileup separation function defined. All hits will be treated as single pulses" << std::endl;      
        }
}

void PndEmcPSAFPGASampleAnalyser::initFromFile ( const std::string &  fname )

virtualinherited

Definition at line 71 of file PndEmcPSAFPGASampleAnalyser.cxx.

References PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_delay, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_fit_offset, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_fitter_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_ratio, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::clock_unit, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::hit_threshold, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::iafactor, PndEmcPSAFPGASampleAnalyser::init(), PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::ma_trig_M, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd_length, and PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd_tau.

Referenced by PndEmcPSAFPGASampleAnalyser::PndEmcPSAFPGASampleAnalyser().

                                                                {// fname //[R.K.03/2017] unused variable(s)
  SampleAnalyserParams newParams;
  newParams.hit_threshold = 200;
  newParams.ma_trig_M = 30;
  newParams.cf_delay = 5;
  newParams.cf_ratio = 0.15;
  newParams.cf_fitter_length = 5; 
  newParams.cf_fit_offset = 2;
  newParams.mwd_length = 90;
  newParams.mwd_tau = 2500;
  newParams.clock_unit = 10;//ns
  newParams.iafactor= 1.;//ns

/*  std::ifstream ifile(fname.c_str());
  if(!ifile) {
    std::cerr << "Can not open input file: " << fname << "\n";
    exit(1);
  }

  std::set<std::string> options;
  options.insert("MWD_Tau");
  options.insert("MWD_Length");
  options.insert("TR_Thresh");
  options.insert("CFD_Ratio");
  options.insert("CFD_Delay");
  options.insert("Fit_ofset");
  options.insert("Fitter_L");
  options.insert("MA_trig");

  //parser
  for (pod::config_file_iterator i(ifile, options), e ; i != e; ++i) {
    if (i->string_key == "MWD_Tau") {
      newParams.mwd_tau = atof((i->value[0]).c_str());
    }
    if (i->string_key == "MWD_Length") {
      newParams.mwd_length = atoi((i->value[0]).c_str());
    }
    if (i->string_key == "TR_Thresh") {
      newParams.hit_threshold = atof((i->value[0]).c_str());
    }
    if (i->string_key == "CFD_Ratio") {
      newParams.cf_ratio = atof((i->value[0]).c_str());
    }
    if (i->string_key == "CFD_Delay") {
      newParams.cf_delay = atoi((i->value[0]).c_str());
    }
    if (i->string_key == "Fit_ofset") {
      newParams.cf_fit_offset = atoi((i->value[0]).c_str());
    }
    if (i->string_key == "Fitter_L") {
      newParams.cf_fitter_length = atoi((i->value[0]).c_str());
    }
    if (i->string_key == "MA_trig") {
      newParams.ma_trig_M = atoi((i->value[0]).c_str());
    }
  }
  
  ifile.close();*/
  init(newParams);
  return;
}

virtual void PndEmcPSAFPGAPileupAnalyser::initFromFile ( )

inlinevirtual

Definition at line 26 of file PndEmcPSAFPGAPileupAnalyser.h.

{};

void PndEmcPSAFPGAPileupAnalyser::InitParameters ( const std::vector< Double_t > &  params )

protectedvirtual

Definition at line 42 of file PndEmcPSAFPGAPileupAnalyser.cxx.

References PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_delay, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_fit_offset, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_fitter_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_ratio, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::hit_threshold, PndEmcPSAFPGASampleAnalyser::init(), PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::ma_trig_M, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd2_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd2_tau, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd3_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd3_tau, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd_length, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::mwd_tau, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::rough_timing_corr, and PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::sig_delay.

Referenced by Init2().

                                                                                  {

        //define parameter initialization, otherwise conflict with clock_unit and iafactor parameters, which have been added to PndEmcPSAFPGASampleAnalyser
        //
        const Int_t size = params.size();
        if(size!=14) {
                std::cerr << "-W PndEmcPSAFPGAPileupAnalyser::InitParameters Mismatch in number of parameters (" << size << "!=14). Filling missing parameter values up with zeros..." << std::endl;
        }

        SampleAnalyserParams newParams;
        newParams.ma_trig_M = (size>0) ? (int) params.at(0): 0;
        newParams.hit_threshold = (size>1) ? params.at(1): 0;
        newParams.cf_delay = (size>2) ? (int) params.at(2): 0;
        newParams.cf_ratio = (size>3) ? params.at(3): 0;
        newParams.cf_fitter_length = (size>4) ? (int) params.at(4): 0;
        newParams.cf_fit_offset = (size>5) ? (int) params.at(5): 0;
        newParams.mwd_length = (size>6) ? (int) params.at(6): 0;
        newParams.mwd_tau = (size>7) ? params.at(7): 0;
        newParams.mwd2_length = (size>8) ? (int) params.at(8): 0;
        newParams.mwd2_tau = (size>9) ? params.at(9): 0;
        newParams.mwd3_length = (size>10) ? (int) params.at(10): 0;
        newParams.mwd3_tau = (size>11) ?  params.at(11): 0;
        newParams.sig_delay = (size>12) ?  params.at(12): 0;
        newParams.rough_timing_corr = (size>13) ?  params.at(13): 0;
        
        PndEmcPSAFPGASampleAnalyser::init(newParams);   
}

int PndEmcPSAFPGASampleAnalyser::nHits ( )

inlineinherited

Definition at line 28 of file PndEmcPSAFPGASampleAnalyser.h.

References PndEmcPSAFPGASampleAnalyser::Number_of_hits.

Referenced by GetHit(), PndEmcPSAFPGADigitalFilterAnalyser::Process(), PndEmcPSAFPGASampleAnalyser::Process(), PndEmcPSAFPGASampleAnalyser::sampleAmplitude(), PndEmcPSAFPGASampleAnalyser::sampleIntegral(), and PndEmcPSAFPGASampleAnalyser::sampleTime().

{return Number_of_hits;};

Int_t PndEmcPSAFPGASampleAnalyser::Process ( const PndEmcWaveform *  waveform )

virtualinherited

Find Hits in Waveform.

Parameters

PndEmcWaveform

Returns

Return number of hits, negative if an error occurred

Implements PndEmcAbsPSA.

Reimplemented in PndEmcPSAFPGADigitalFilterAnalyser.

Definition at line 177 of file PndEmcPSAFPGASampleAnalyser.cxx.

References PndEmcWaveform::GetSignal(), PndEmcPSAFPGASampleAnalyser::nHits(), PndEmcPSAFPGASampleAnalyser::put(), and PndEmcPSAFPGASampleAnalyser::reset().

                                                                        {
        //std::cout<<"PndEmcPSAFPGASampleAnalyser::Process#"<<waveform->GetTimeStamp()
        //      <<", "<<waveform->GetActiveTime()<<std::endl;
        reset();
        std::vector<double> signal = waveform->GetSignal();
        std::vector<double>::iterator it;
        for(it = signal.begin(); it < signal.end();it++){
                this->put(*it);
        }
        return this->nHits();
}

void PndEmcAbsPSA::Process ( const PndEmcWaveform *  waveform, Double_t &  amplitude, Double_t &  time  )

virtualinherited

Deprecated. Do not use.

Parameters

PndEmcWaveform
Double_t
Double_t

Returns

Reimplemented in PndEmcPSAMatchedDigiFilter, PndEmcPSAParabolic, PndEmcPSAParabolicBaseline, and PndEmcPSATrapDigiFilter.

Definition at line 2 of file PndEmcAbsPSA.cxx.

References PndEmcAbsPSA::GetHit(), and PndEmcAbsPSA::Process().

                                                                                             {
                if(Process(waveform)>0){
                        GetHit(0,amplitude,time);
                }else{
                        amplitude = 0.;
                        time = 0.;
                }
        }; //deprecated do not use

void PndEmcPSAFPGAPileupAnalyser::put ( float  valueToStore )

virtual

Implements PndEmcPSAFPGASampleAnalyser.

Definition at line 153 of file PndEmcPSAFPGAPileupAnalyser.cxx.

References a, PndEmcPSAFPGASampleAnalyser::amplitude, PndEmcPSAFPGASampleAnalyser::analyserParams, PndEmcPSAFPGASampleAnalyser::baseline_value, baselineMode, BaselineStartSample, BaselineStopSample, BaselineSum, cf_crossing, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_delay, PndEmcPSAFPGASampleAnalyser::CF_delay, PndEmcPSAFPGASampleAnalyser::CF_filter, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::cf_fit_offset, PndEmcPSAFPGASampleAnalyser::CF_Fitter, CF_prev, cfRise, cfZero, energy_finished, PndEmcPSAFPGALinFitter::fit(), func_defined, fVerbose, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::hit_threshold, i, in_cfRise, Int_mean, Int_thres, PndEmcPSAFPGASampleAnalyser::integral, PndEmcPSAFPGASampleAnalyser::kBaseline, PndEmcPSAFPGASampleAnalyser::kInPulse, kPileup1, kPileup2, PndEmcPSAFPGASampleAnalyser::kPileupFinished, PndEmcPSAFPGASampleAnalyser::kPulseDetected, PndEmcPSAFPGASampleAnalyser::kPulseFinished, kSingle, PndEmcPSAFPGASampleAnalyser::kUndefined, kWindow, PndEmcPSAFPGASampleAnalyser::local_time, MWD_filter1, MWD_filter2, MWD_filter3, PndEmcPSAFPGASampleAnalyser::Number_of_hits, PndEmcPSAFPGALinFitter::offset(), pileups, PndEmcPSAFPGASampleAnalyser::pulse_detected, PndEmcPSAFPGAFilterDelay::put(), PndEmcPSAFPGAFilterMWD::put(), PndEmcPSAFPGAFilterCF::put(), PndEmcPSAFPGALinFitter::putPoint(), PndEmcPSAFPGALinFitter::reset(), PndEmcPSAFPGASampleAnalyser::rough_pulse_timing, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::rough_timing_corr, PndEmcPSAFPGASampleAnalyser::SampleAnalyserParams::sig_delay, PndEmcPSAFPGASampleAnalyser::Signal_delay, PndEmcPSAFPGALinFitter::slope(), PndEmcPSAFPGASampleAnalyser::status, PndEmcPSAFPGASampleAnalyser::time, and timing_finished.

                                                        {

        if(baselineMode==kWindow && local_time <= BaselineStopSample) {
                if(local_time >= BaselineStartSample) {
                        BaselineSum += valueToStore;
                } 
                if(local_time == BaselineStopSample) {
                        baseline_value = BaselineSum / (BaselineStopSample-BaselineStartSample+1);
                }
        } else {

                float signal = valueToStore - baseline_value;
                float signal_delayed = (analyserParams.sig_delay>0) ? Signal_delay->put(signal) : signal;

                float mwd_value = MWD_filter1->put(signal);
                float mwd2_value = MWD_filter2->put(mwd_value);
                float mwd3_value = MWD_filter3->put(mwd2_value);

                float cf_value = CF_filter->put(mwd3_value);
                float cf_value_delayed = (analyserParams.cf_fit_offset>0) ? CF_delay->put(cf_value) : cf_value;
                float cf_value_prev = CF_prev->put(cf_value_delayed);

                status = kUndefined;

                if (!pulse_detected) {
                        if(signal > analyserParams.hit_threshold) {     // new pulse detected..reset pulse specific quantities
                                status = kPulseDetected;
                                energy_finished = false;
                                timing_finished = false;
                                pulse_detected = true;
                                rough_pulse_timing = local_time;
                                cf_crossing = 0;
                                in_cfRise = false;
                                integral[Number_of_hits] = 0.0;
                                amplitude[Number_of_hits] = 0.0;

                                if(fVerbose>=5) std::cout << "first time over thres: " << local_time << std::endl;      
                        } else {
                                status = kBaseline;
                        }
                } 

                int dT = local_time - rough_pulse_timing;

                if(pulse_detected) {                                                                    // over thres

                        if(status!=kPulseDetected) status = kInPulse;

                        if( (!(dT<analyserParams.sig_delay)) && (!energy_finished) ) {                  // delayed over thres
                                if(fVerbose>=5) std::cout << local_time << " "; 
                                // Integral
                                integral[Number_of_hits] += signal_delayed;
                                // Amplitude
                                if(cf_crossing==0 && (signal_delayed > amplitude[Number_of_hits])) {
                                        amplitude[Number_of_hits] = signal_delayed;
                                }
                                if(signal_delayed < analyserParams.hit_threshold) {
                                        energy_finished = true;
                                        if(fVerbose>=5) std::cout << local_time << std::endl;;  
                                }
                        }


                        if( (!(dT<analyserParams.cf_delay)) && (!timing_finished) ) {     
                                if((cf_value_prev < 0.0) && (cf_value_delayed >= 0.0)) {                // new zero crossing
                                        CF_Fitter->reset();
                                        CF_Fitter->putPoint(local_time-1, cf_value_prev);
                                        CF_Fitter->putPoint(local_time, cf_value_delayed);
                                        CF_Fitter->fit();
                                        double a = CF_Fitter->offset();
                                        double k = CF_Fitter->slope();
                                        cfZero[cf_crossing++] = (k>0) ? -a/k : 0;
                                        in_cfRise = true;
                                }

                                if(cf_value_delayed< cf_value_prev) {
                                        if(in_cfRise) {
                                                cfRise[cf_crossing-1] = cf_value_prev - cfRise[cf_crossing-1];
                                                in_cfRise = false;
                                        } else {
                                                cfRise[cf_crossing] = cf_value_delayed;
                                        }
                                }
                                if(energy_finished) {
                                        timing_finished = true;
                                }
                        }

                        if(energy_finished && timing_finished) {

                                time[Number_of_hits] = (cf_crossing>0) ? cfZero[0] : rough_pulse_timing-analyserParams.rough_timing_corr;

                                if(fVerbose>=2) {
                                        std::cout << "Finaliyzing " << Number_of_hits << " hit" << std::endl;   
                                        std::cout << "  time: " <<  time[Number_of_hits] << std::endl;
                                        std::cout << "  ampitude: " << amplitude[Number_of_hits] << "\t";
                                        std::cout << "  integral: " << integral[Number_of_hits] << std::endl;
                                }

                                if(fVerbose >= 3) {
                                        std::cout << "all zeroCrossings t/rise" << std::endl;
                                        for(unsigned int i=0; i<cf_crossing; ++i) {
                                                std::cout << cfZero[i] << "/" << cfRise[i] << std::endl;
                                        }
                                }


                                if( (!func_defined) || (integral[Number_of_hits] < Int_thres->Eval(amplitude[Number_of_hits]))) {       //single pulse
                                        status = kPulseFinished;
                                        if(fVerbose>=2) std::cout << "single hit" << std::endl;
                                        pileups[Number_of_hits] = kSingle;
                                        Number_of_hits++;
                                } else {                                                                        //pileup pulse
                                        status = kPileupFinished;
                                        if(fVerbose>=2) std::cout << "pileup hit" << std::endl;
                                        //i2 = i_ges - i1
                                        integral[Number_of_hits+1] = integral[Number_of_hits] - Int_mean->Eval(amplitude[Number_of_hits]);      
                                        //i1 = i_ges - i2
                                        integral[Number_of_hits]-= integral[Number_of_hits+1];
                                        amplitude[Number_of_hits+1] = Int_mean->GetX(integral[Number_of_hits+1], 0, 0, 5.e-4, 100, kTRUE); 

                                        if(cf_crossing>1) {
                                                float max_rise = 0;
                                                for(unsigned int i=1; i<cf_crossing; ++i) {
                                                        if(cfRise[i] > max_rise) {
                                                                max_rise = cfRise[i];
                                                                time[Number_of_hits+1] = cfZero[i];
                                                        }
                                                }
                                        } else {
                                                time[Number_of_hits+1] = rough_pulse_timing-analyserParams.rough_timing_corr;
                                        }
                                        pileups[Number_of_hits] = kPileup1;
                                        pileups[Number_of_hits+1] = kPileup2;


                                        if(fVerbose>=2) {
                                                std::cout << "amp1: " << amplitude[Number_of_hits] << "\tint1: " << integral[Number_of_hits] << "\tamp2: " << amplitude[Number_of_hits+1] << "\tint2: " << integral[Number_of_hits+1] << std::endl;
                                        }

                                        Number_of_hits+=2;
                                }
                                pulse_detected = false;
                        }
                }

                if(fVerbose>=9) {
                        using namespace std;
                        cout << "#" << local_time <<" ";
                        cout << "mwd: " << mwd_value <<" ";
                        cout << "mwd 2: " << mwd2_value <<" ";
                        cout << "mwd 3: " << mwd3_value <<" ";
                        cout << "cf delay: " << cf_value_delayed <<" ";
                        if(pulse_detected) cout << "detec ";
                        if(!energy_finished) cout << "energy method running ";
                        if(!timing_finished) cout << "timing method running ";
                        cout << endl;
                }
        }       
        local_time++;
}

void PndEmcPSAFPGAPileupAnalyser::reset ( )

virtual

Implements PndEmcPSAFPGASampleAnalyser.

Definition at line 26 of file PndEmcPSAFPGAPileupAnalyser.cxx.

References BaselineSum, PndEmcPSAFPGASampleAnalyser::CF_delay, PndEmcPSAFPGASampleAnalyser::CF_filter, PndEmcPSAFPGASampleAnalyser::local_time, PndEmcPSAFPGASampleAnalyser::MA_triggering, MWD_filter1, MWD_filter2, MWD_filter3, PndEmcPSAFPGASampleAnalyser::Number_of_hits, PndEmcPSAFPGASampleAnalyser::pulse_detected, PndEmcPSAFPGAFilterDelay::resetToZero(), PndEmcPSAFPGAFilterMA::resetToZero(), PndEmcPSAFPGAFilterCF::resetToZero(), PndEmcPSAFPGAFilterMWD::resetToZero(), and PndEmcPSAFPGASampleAnalyser::rough_pulse_timing.

                                        {       //reset for every waveform to process
  local_time = 0;
  rough_pulse_timing = 0;
  Number_of_hits = 0;
  CF_filter->resetToZero();
  MA_triggering->resetToZero();
  MWD_filter1->resetToZero();
  MWD_filter2->resetToZero();
  MWD_filter3->resetToZero();
  CF_delay->resetToZero();
  pulse_detected = false;
  BaselineSum = 0;
  return;
}

virtual void PndEmcPSAFPGASampleAnalyser::Reset ( )

inlinevirtualinherited

reset found hits

Returns

Reimplemented from PndEmcAbsPSA.

Definition at line 34 of file PndEmcPSAFPGASampleAnalyser.h.

References PndEmcPSAFPGASampleAnalyser::reset().

Referenced by PndEmcHighLowPSA::Reset().

{this->reset();};

float PndEmcPSAFPGASampleAnalyser::sampleAmplitude ( int  index )

inherited

Definition at line 165 of file PndEmcPSAFPGASampleAnalyser.cxx.

References PndEmcPSAFPGASampleAnalyser::amplitude, and PndEmcPSAFPGASampleAnalyser::nHits().

Referenced by GetEnergyMeasures(), GetHit(), and PndEmcPSAFPGASampleAnalyser::GetHit().

                                                            {
  if(index < nHits() && index >= 0)
    return amplitude[index];
  return 0.0;
}

float PndEmcPSAFPGASampleAnalyser::sampleIntegral ( int  index )

inherited

Definition at line 171 of file PndEmcPSAFPGASampleAnalyser.cxx.

References PndEmcPSAFPGASampleAnalyser::integral, and PndEmcPSAFPGASampleAnalyser::nHits().

Referenced by GetEnergyMeasures().

                                                           {
  if (index < nHits() && index >= 0)
    return integral[index];
  return 0.0;
}

float PndEmcPSAFPGASampleAnalyser::sampleTime ( int  index )

inherited

Definition at line 159 of file PndEmcPSAFPGASampleAnalyser.cxx.

References PndEmcPSAFPGASampleAnalyser::nHits(), and PndEmcPSAFPGASampleAnalyser::time.

Referenced by GetHit(), and PndEmcPSAFPGASampleAnalyser::GetHit().

                                                       {
  if (index < nHits() && index >= 0)
    return time[index];
  return 0.0;
}

void PndEmcPSAFPGAPileupAnalyser::setBaseline ( float  newBaseline )

protectedvirtual

Reimplemented from PndEmcPSAFPGASampleAnalyser.

Definition at line 120 of file PndEmcPSAFPGAPileupAnalyser.cxx.

References baselineMode, kExtern, and PndEmcPSAFPGASampleAnalyser::setBaseline().

Referenced by Init().

                                                               {
        PndEmcPSAFPGASampleAnalyser::setBaseline(newBaseline);
        baselineMode = kExtern;
}

void PndEmcPSAFPGAPileupAnalyser::setBaselineWindow ( unsigned int  startSample, unsigned int  stopSample  )

protectedvirtual

Definition at line 125 of file PndEmcPSAFPGAPileupAnalyser.cxx.

References baselineMode, BaselineStartSample, BaselineStopSample, and kWindow.

Referenced by Init().

                                                                                                     {
        BaselineStartSample = startSample;
        BaselineStopSample = stopSample;
        baselineMode = kWindow;
}

virtual void PndEmcPSAFPGAPileupAnalyser::SetVerbose ( Int_t  verbose = 0 )

inlinevirtual

Definition at line 22 of file PndEmcPSAFPGAPileupAnalyser.h.

References fVerbose, and verbose.

Referenced by PndEmcFWEndcapDigi::Init().

{ fVerbose = verbose; }

Member Data Documentation

float PndEmcPSAFPGASampleAnalyser::amplitude[MAX_NUMBER_OF_HITS]

protectedinherited

Definition at line 82 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGADigitalFilterAnalyser::put(), PndEmcPSAFPGAIntegratingAnalyser::put(), put(), and PndEmcPSAFPGASampleAnalyser::sampleAmplitude().

SampleAnalyserParams PndEmcPSAFPGASampleAnalyser::analyserParams

protectedinherited

Definition at line 63 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGADigitalFilterAnalyser::init(), PndEmcPSAFPGASampleAnalyser::init(), Init2(), PndEmcPSAFPGADigitalFilterAnalyser::put(), PndEmcPSAFPGAIntegratingAnalyser::put(), and put().

float PndEmcPSAFPGASampleAnalyser::baseline_value

protectedinherited

Definition at line 65 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGAIntegratingAnalyser::baseline(), baseline(), PndEmcPSAFPGADigitalFilterAnalyser::PndEmcPSAFPGADigitalFilterAnalyser(), PndEmcPSAFPGASampleAnalyser::PndEmcPSAFPGASampleAnalyser(), PndEmcPSAFPGADigitalFilterAnalyser::Process(), PndEmcPSAFPGAIntegratingAnalyser::put(), PndEmcPSAFPGADigitalFilterAnalyser::put(), put(), and PndEmcPSAFPGASampleAnalyser::setBaseline().

enum { ... } PndEmcPSAFPGAPileupAnalyser::baselineMode

Referenced by put(), setBaseline(), and setBaselineWindow().

unsigned int PndEmcPSAFPGAPileupAnalyser::BaselineStartSample

protected

Definition at line 51 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by put(), and setBaselineWindow().

unsigned int PndEmcPSAFPGAPileupAnalyser::BaselineStopSample

protected

Definition at line 52 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by put(), and setBaselineWindow().

float PndEmcPSAFPGAPileupAnalyser::BaselineSum

protected

Definition at line 53 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by put(), and reset().

unsigned int PndEmcPSAFPGAPileupAnalyser::cf_crossing

protected

Definition at line 64 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by put().

PndEmcPSAFPGAFilterDelay* PndEmcPSAFPGASampleAnalyser::CF_delay

protectedinherited

Definition at line 74 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGASampleAnalyser::init(), PndEmcPSAFPGASampleAnalyser::PndEmcPSAFPGASampleAnalyser(), PndEmcPSAFPGAIntegratingAnalyser::put(), PndEmcPSAFPGADigitalFilterAnalyser::put(), put(), PndEmcPSAFPGADigitalFilterAnalyser::reset(), and reset().

PndEmcPSAFPGAFilterCF* PndEmcPSAFPGASampleAnalyser::CF_filter

protectedinherited

Definition at line 71 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGASampleAnalyser::init(), PndEmcPSAFPGASampleAnalyser::PndEmcPSAFPGASampleAnalyser(), PndEmcPSAFPGAIntegratingAnalyser::put(), PndEmcPSAFPGADigitalFilterAnalyser::put(), put(), PndEmcPSAFPGADigitalFilterAnalyser::reset(), PndEmcPSAFPGAIntegratingAnalyser::reset(), and reset().

PndEmcPSAFPGALinFitter* PndEmcPSAFPGASampleAnalyser::CF_Fitter

protectedinherited

Definition at line 76 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGASampleAnalyser::PndEmcPSAFPGASampleAnalyser(), PndEmcPSAFPGAIntegratingAnalyser::put(), PndEmcPSAFPGADigitalFilterAnalyser::put(), and put().

PndEmcPSAFPGAFilterDelay* PndEmcPSAFPGAPileupAnalyser::CF_prev

protected

Definition at line 58 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by Init2(), put(), and ~PndEmcPSAFPGAPileupAnalyser().

int PndEmcPSAFPGASampleAnalyser::cf_zero_crossing_points

protectedinherited

Definition at line 69 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGADigitalFilterAnalyser::put(), and PndEmcPSAFPGAIntegratingAnalyser::put().

float PndEmcPSAFPGAPileupAnalyser::cfRise[MAX_NUMBER_OF_HITS]

protected

Definition at line 67 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by put().

float PndEmcPSAFPGAPileupAnalyser::cfZero[MAX_NUMBER_OF_HITS]

protected

Definition at line 66 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by put().

bool PndEmcPSAFPGAPileupAnalyser::energy_finished

protected

Definition at line 60 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by put().

bool PndEmcPSAFPGAPileupAnalyser::func_defined

protected

Definition at line 62 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by Init2(), and put().

Int_t PndEmcPSAFPGAPileupAnalyser::fVerbose

protected

Definition at line 47 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by put(), and SetVerbose().

bool PndEmcPSAFPGAPileupAnalyser::in_cfRise

protected

Definition at line 65 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by put().

TF1* PndEmcPSAFPGAPileupAnalyser::Int_mean

protected

Definition at line 49 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by Init2(), put(), and ~PndEmcPSAFPGAPileupAnalyser().

TF1* PndEmcPSAFPGAPileupAnalyser::Int_thres

protected

Definition at line 48 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by Init2(), put(), and ~PndEmcPSAFPGAPileupAnalyser().

float PndEmcPSAFPGASampleAnalyser::integral[MAX_NUMBER_OF_HITS]

protectedinherited

Definition at line 81 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGADigitalFilterAnalyser::put(), PndEmcPSAFPGAIntegratingAnalyser::put(), put(), and PndEmcPSAFPGASampleAnalyser::sampleIntegral().

unsigned int PndEmcPSAFPGASampleAnalyser::local_time

protectedinherited

Definition at line 66 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGADigitalFilterAnalyser::put(), PndEmcPSAFPGAIntegratingAnalyser::put(), put(), PndEmcPSAFPGADigitalFilterAnalyser::reset(), PndEmcPSAFPGAIntegratingAnalyser::reset(), and reset().

PndEmcPSAFPGAFilterDelay* PndEmcPSAFPGASampleAnalyser::MA_delay

protectedinherited

Definition at line 73 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGASampleAnalyser::PndEmcPSAFPGASampleAnalyser().

PndEmcPSAFPGAFilterMA* PndEmcPSAFPGASampleAnalyser::MA_triggering

protectedinherited

Definition at line 72 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGASampleAnalyser::init(), PndEmcPSAFPGASampleAnalyser::PndEmcPSAFPGASampleAnalyser(), PndEmcPSAFPGAIntegratingAnalyser::put(), PndEmcPSAFPGADigitalFilterAnalyser::put(), PndEmcPSAFPGADigitalFilterAnalyser::reset(), PndEmcPSAFPGAIntegratingAnalyser::reset(), and reset().

PndEmcPSAFPGAFilterMWD* PndEmcPSAFPGAPileupAnalyser::MWD_filter1

protected

Definition at line 55 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by Init2(), put(), reset(), and ~PndEmcPSAFPGAPileupAnalyser().

PndEmcPSAFPGAFilterMWD* PndEmcPSAFPGAPileupAnalyser::MWD_filter2

protected

Definition at line 56 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by Init2(), put(), reset(), and ~PndEmcPSAFPGAPileupAnalyser().

PndEmcPSAFPGAFilterMWD* PndEmcPSAFPGAPileupAnalyser::MWD_filter3

protected

Definition at line 57 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by Init2(), put(), reset(), and ~PndEmcPSAFPGAPileupAnalyser().

int PndEmcPSAFPGASampleAnalyser::Number_of_hits

protectedinherited

Definition at line 79 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGASampleAnalyser::nHits(), PndEmcPSAFPGAIntegratingAnalyser::put(), PndEmcPSAFPGADigitalFilterAnalyser::put(), put(), PndEmcPSAFPGADigitalFilterAnalyser::reset(), PndEmcPSAFPGAIntegratingAnalyser::reset(), and reset().

pileup_t PndEmcPSAFPGAPileupAnalyser::pileups[MAX_NUMBER_OF_HITS]

protected

Definition at line 68 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by GetHit(), and put().

bool PndEmcPSAFPGASampleAnalyser::pulse_detected

protectedinherited

Definition at line 67 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGADigitalFilterAnalyser::put(), PndEmcPSAFPGAIntegratingAnalyser::put(), put(), PndEmcPSAFPGADigitalFilterAnalyser::reset(), PndEmcPSAFPGAIntegratingAnalyser::reset(), and reset().

int PndEmcPSAFPGASampleAnalyser::rough_pulse_timing

protectedinherited

Definition at line 68 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGADigitalFilterAnalyser::put(), PndEmcPSAFPGAIntegratingAnalyser::put(), put(), and reset().

PndEmcPSAFPGAFilterDelay* PndEmcPSAFPGASampleAnalyser::Signal_delay

protectedinherited

Definition at line 75 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGASampleAnalyser::init(), Init2(), PndEmcPSAFPGASampleAnalyser::PndEmcPSAFPGASampleAnalyser(), PndEmcPSAFPGADigitalFilterAnalyser::put(), PndEmcPSAFPGAIntegratingAnalyser::put(), put(), and PndEmcPSAFPGADigitalFilterAnalyser::reset().

status_t PndEmcPSAFPGASampleAnalyser::status

protectedinherited

Definition at line 84 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGASampleAnalyser::GetStatus(), and put().

float PndEmcPSAFPGASampleAnalyser::time[MAX_NUMBER_OF_HITS]

protectedinherited

Definition at line 80 of file PndEmcPSAFPGASampleAnalyser.h.

Referenced by PndEmcPSAFPGADigitalFilterAnalyser::put(), PndEmcPSAFPGAIntegratingAnalyser::put(), put(), and PndEmcPSAFPGASampleAnalyser::sampleTime().

bool PndEmcPSAFPGAPileupAnalyser::timing_finished

protected

Definition at line 61 of file PndEmcPSAFPGAPileupAnalyser.h.

Referenced by put().

---

The documentation for this class was generated from the following files:

• PndEmcPSAFPGAPileupAnalyser.h
• PndEmcPSAFPGAPileupAnalyser.cxx