PndEmcPSAFPGAIntegratingAnalyser.cxx

Go to the documentation of this file.

#include "PndEmcPSAFPGAIntegratingAnalyser.h"

#include "PndEmcPSAFPGAFilterCF.h"
#include "PndEmcPSAFPGAFilterMA.h"
#include "PndEmcPSAFPGAFilterDelay.h"
#include "PndEmcPSAFPGALinFitter.h"

#include <string>
#include <iostream>

PndEmcPSAFPGAIntegratingAnalyser::PndEmcPSAFPGAIntegratingAnalyser() :
  PndEmcPSAFPGASampleAnalyser() {
}

PndEmcPSAFPGAIntegratingAnalyser::PndEmcPSAFPGAIntegratingAnalyser(const std::string &fname) :
  PndEmcPSAFPGASampleAnalyser(fname) {
}

PndEmcPSAFPGAIntegratingAnalyser::~PndEmcPSAFPGAIntegratingAnalyser() {
}

void PndEmcPSAFPGAIntegratingAnalyser::reset() {
  local_time = 0;
  Number_of_hits = 0;
  CF_filter->resetToZero();
  MA_triggering->resetToZero();
  pulse_detected = false;
  return;
}

void PndEmcPSAFPGAIntegratingAnalyser::put(float valueToStore) {
        //    std::cout << valueToStore << " ";
        float signal = valueToStore - baseline_value;
        float signal_delayed = Signal_delay->put(signal);
        float cf_value = CF_filter->put(signal);
        float cf_value_delayed = CF_delay->put(cf_value);
        float ma_value = MA_triggering->put(signal);

        if(local_time < 30){ //first 30 samples are baseline
                baseline_value *=local_time;
                baseline_value += valueToStore;
                baseline_value /=local_time+1;
                local_time++;
                //        std::cout << baseline_value << " ";
                return;
        }

        int dT = local_time - rough_pulse_timing;
        if (!pulse_detected) {
                if((cf_value_delayed < 0.0) && (cf_value > 0.0) && (ma_value > analyserParams.hit_threshold)){
                        // hit detected
                        // CF
                        CF_Fitter->reset();
                        CF_Fitter->putPoint(local_time, cf_value_delayed);
                        cf_zero_crossing_points = 1;
                        pulse_detected = true;
                        rough_pulse_timing = local_time;
                        integral[Number_of_hits] = 0.0;
                        amplitude[Number_of_hits] = 0.0;
                }
        } else {
                // CF timing
                if(cf_zero_crossing_points < analyserParams.cf_fitter_length) {
                        CF_Fitter->putPoint(local_time, cf_value_delayed);
                        cf_zero_crossing_points++;
                }
                // Integral
                integral[Number_of_hits] += signal_delayed;
                // Amplitude
                if((dT < 2*analyserParams.cf_delay) && (signal_delayed > amplitude[Number_of_hits])) {
                        amplitude[Number_of_hits] = signal_delayed;
                }
                // Finalize pulse detection
                if ((dT > analyserParams.cf_delay) && (signal_delayed < analyserParams.hit_threshold/analyserParams.ma_trig_M)) {
                        pulse_detected = false;
                        CF_Fitter->fit();
                        double a = CF_Fitter->offset();
                        double k = CF_Fitter->slope();
                        time[Number_of_hits] = 0.0;
                        if(k > 0) 
                                time[Number_of_hits] = -a/k;
                        Number_of_hits++;
                }
        }

        local_time++;
}

ClassImp(PndEmcPSAFPGAIntegratingAnalyser);