QPulseGenerator.hh

Go to the documentation of this file.

#ifndef _Q_PULSE_GENERATOR_HH_
#define _Q_PULSE_GENERATOR_HH_

#include "QVector.hh"
#include <list>
#include <vector>
#include <queue>
#include <gsl/gsl_rng.h>
#include "QNoiseGenerator.hh"
#include "QAmplitudeGenerator.hh"
#include <TF1.h>

namespace  Cuore {class QMathFunction;}
using namespace Cuore;

class  QPulseGenerator {
    public:
        QPulseGenerator() {}
        QPulseGenerator(const QVector& config, const gsl_rng* randGen);
        ~QPulseGenerator();

        int GetChannelId() const { return fChannelId; }
        double GetSamplingFrequency() const { return fSamplFreq; }
        bool NeedNoisePS() const { return fNeedNoisePS; }
        void SetNoisePS(const QVector& noisePS);
        bool NeedAmplitudeHisto() const { return fNeedAmplitudeHisto; }
        void SetAmplitudeHisto(const TH1D& histo);
        void GenerateFromEnergy(bool fromEnergy) { fGenerateFromEnergy = fromEnergy; }
        void SetCalibrationFunction(const TF1& calibFunc) { fCalibrationFunction = calibFunc; }
        
        void Generate();
        double GetTime() const { return fMainEventInfo.fTime; }

        void FillWindow(QVector& window) const;
        int GetMasterSampleIndex() const { return fMasterSampleIndex; }
        vector<int> GetSamplesIndex() const { return fSamplesIndex; }

        bool operator<(const QPulseGenerator& other) const { return GetTime() < other.GetTime(); }

        class EventInfo {
            public:
                bool operator<(const EventInfo& other) const { return fTime < other.fTime; }
                double fTime;
                double fDeltaT;
                double fEnergy;
                double fAmplitude;
                double fMax;
                double fMaxPos;
        };

        vector<EventInfo> GetEventInfo() const {return fWindowEventInfo;}
        EventInfo GetMainEventInfo() const { return fMainEventInfo;}

    private:

        const QVector& GenerateNoise(bool continued, size_t nsamples);
        double GenerateAmplitude();
        double GenerateDeltaT();
        EventInfo GenerateDeltaTAndAmplitude();
        const QVector& GeneratePulse(double delay, double amplitude, double& max, double& maxpos);
        void FillInfo();
        void Init(const QVector& config);

        bool fFirstCall;

        bool fGenerateFromEnergy;
        TF1 fCalibrationFunction;
        int fChannelId;
        int    fNumSamples;
        double fSamplFreq;
        double fBesselCutOff;
        double fWideDuration;
        double fPreTrigger;
        double fBaseline;
        QMathFunction* fPhysicsPulse;
        double fThermalMax;
        double fBesselGain;
        double* fParams;

        QNoiseGenerator* fNoiseGenerator;
        QAmplitudeGenerator* fAmplitudeGenerator;

        const gsl_rng* fRandomGen;

        double fTime;

        size_t fWideWindowSize;
        size_t fWideWindowRatio;
        QVector fWideWindow;
        QVector fPulseWindow;
        QVector fNoiseRemainder;
        QVector fNoiseWindow;

        list<EventInfo> fEventInfos;
        list<EventInfo>::iterator fMainEventIter;
        vector<EventInfo> fWindowEventInfo;
        EventInfo fMainEventInfo;

        int fMasterSampleIndex;
        vector<int> fSamplesIndex;

        QAmplitudeGenerator::Type fAmplDistrType;
        bool fNeedAmplitudeHisto;
        double fAmplDistrP1;
        double fAmplDistrP2;
        int fTimeDistrType;
        double fTimeDistrP1;
        double fTimeDistrP2;
        QNoiseGenerator::Type fNoiseDistrType ;
        bool fNeedNoisePS;
        double fNoiseDistrP1;
        double fNoiseDistrP2;

};
#endif

---