TRestRawSignal.h

/*************************************************************************
 * This file is part of the REST software framework.                     *
 *                                                                       *
 * Copyright (C) 2016 GIFNA/TREX (University of Zaragoza)                *
 * For more information see http://gifna.unizar.es/trex                  *
 *                                                                       *
 * REST is free software: you can redistribute it and/or modify          *
 * it under the terms of the GNU General Public License as published by  *
 * the Free Software Foundation, either version 3 of the License, or     *
 * (at your option) any later version.                                   *
 *                                                                       *
 * REST is distributed in the hope that it will be useful,               *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the          *
 * GNU General Public License for more details.                          *
 *                                                                       *
 * You should have a copy of the GNU General Public License along with   *
 * REST in $REST_PATH/LICENSE.                                           *
 * If not, see http://www.gnu.org/licenses/.                             *
 * For the list of contributors see $REST_PATH/CREDITS.                  *
 *************************************************************************/
 
#ifndef RestCore_TRestRawSignal
#define RestCore_TRestRawSignal
 
#include <TGraph.h>
#include <TRandom.h>
#include <TString.h>
#include <TVector2.h>
 
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
 
class TRestRawSignal {
   private:
    void CalculateThresholdIntegral();
 
    void CalculateBaseLineSigmaSD(Int_t startBin, Int_t endBin);
 
    void CalculateBaseLineSigmaIQR(Int_t startBin, Int_t endBin);
 
    void CalculateBaseLineSigmaExcludeOutliers(Int_t startBin, Int_t endBin);
 
    std::vector<Float_t> GetSignalSmoothed_ExcludeOutliers(Int_t averagingPoints);
 
   protected:
    Int_t fSignalID;
 
    std::vector<Short_t> fSignalData;
 
    Bool_t fShowWarnings = true;
 
    UInt_t fSeed = gRandom->GetSeed();
 
   public:
    TGraph* fGraph;  
 
    std::vector<Int_t> fPointsOverThreshold;  
 
    Double_t fThresholdIntegral = -1;  
 
    Int_t fHeadPoints;  
 
    Int_t fTailPoints;  
 
    Double_t fBaseLine = 0;  
 
    Double_t fBaseLineSigma = 0;  
 
    TVector2 fRange = TVector2(0, 0);  
 
    inline Int_t GetSignalID() const { return fSignalID; }
 
    inline Int_t GetID() const { return fSignalID; }
 
    inline Int_t GetNumberOfPoints() const { return fSignalData.size(); }
 
    inline std::vector<Int_t> GetPointsOverThreshold() const { return fPointsOverThreshold; }
 
    inline Double_t GetMaxValue() { return GetMaxPeakValue(); }
 
    inline Double_t GetMinValue() { return GetMinPeakValue(); }
 
    inline Int_t GetHeadPoints() const { return fHeadPoints; }
 
    inline Int_t GetTailPoints() const { return fTailPoints; }
 
    inline Double_t GetBaseLine() const { return fBaseLine; }
 
    inline Double_t GetBaseLineSigma() const { return fBaseLineSigma; }
 
    inline TVector2 GetRange() const { return fRange; }
 
    inline Bool_t isBaseLineInitialized() const { return !(fBaseLineSigma == 0 && fBaseLine == 0); }
 
    Double_t GetData(Int_t n) const;
 
    Double_t GetRawData(Int_t n) const;
 
    Short_t operator[](Int_t n);
 
    inline void SetSignalID(Int_t sID) { fSignalID = sID; }
 
    inline void SetID(Int_t sID) { fSignalID = sID; }
 
    inline void SetHeadPoints(Int_t p) { fHeadPoints = p; }
 
    inline void SetTailPoints(Int_t p) { fTailPoints = p; }
 
    inline void SetRange(const TVector2& range) { fRange = range; }
 
    inline void SetRangeToMax() { fRange = TVector2(0, GetNumberOfPoints()); }
 
    inline void SetRange(Int_t from, Int_t to) { fRange = TVector2(from, to); }
 
    void Reset();
 
    void Initialize();
 
    void AddPoint(Short_t);
 
    void AddPoint(Double_t);
 
    void IncreaseBinBy(Int_t bin, Double_t data);
 
    void InitializePointsOverThreshold(const TVector2& thrPar, Int_t nPointsOver, Int_t nPointsFlat = 512);
 
    UInt_t GetSeed() const { return fSeed; }
 
    Double_t GetIntegral();
 
    Double_t GetIntegralInRange(Int_t startBin, Int_t endBin);
 
    Double_t GetThresholdIntegral();
 
    Double_t GetTripleMaxIntegral();
 
    Double_t GetSlopeIntegral();
 
    Double_t GetRiseSlope();
 
    Int_t GetRiseTime();
 
    Double_t GetAverageInRange(Int_t startBin, Int_t endBin);
 
    Int_t GetMaxPeakWidth();
 
    Double_t GetMaxPeakValue();
 
    Int_t GetMaxPeakBin();
 
    Double_t GetMinPeakValue();
 
    Int_t GetMinPeakBin();
 
    Bool_t IsADCSaturation(int Nflat = 3);
 
    void GetDifferentialSignal(TRestRawSignal* diffSignal, Int_t smearPoints);
 
    void GetSignalSmoothed(TRestRawSignal* smoothedSignal, Int_t averagingPoints);
 
    std::vector<Float_t> GetSignalSmoothed(Int_t averagingPoints, std::string option = "");
 
    void GetWhiteNoiseSignal(TRestRawSignal* noiseSignal, Double_t noiseLevel = 1.);
 
    void CalculateBaseLineMean(Int_t startBin, Int_t endBin);
 
    void CalculateBaseLineMedian(Int_t startBin, Int_t endBin);
 
    void CalculateBaseLineMedianExcludeOutliers(Int_t startBin, Int_t endBin);
 
    void CalculateBaseLine(Int_t startBin, Int_t endBin, const std::string& option = "");
 
    void GetBaseLineCorrected(TRestRawSignal* smoothedSignal, Int_t averagingPoints);
 
    void AddOffset(Short_t offset);
 
    void SignalAddition(const TRestRawSignal& signal);
 
    void Scale(Double_t value);
 
    void WriteSignalToTextFile(const TString& filename);
 
    void Print() const;
 
    void SetSeed(UInt_t seed) { fSeed = seed; }
 
    TGraph* GetGraph(Int_t color = 1);
 
    std::vector<std::tuple<double, UShort_t, double>> GetPeaks(double threshold, UShort_t distance = 5,
                                                               double signalBaseLine = 0.0) const;
    std::vector<std::tuple<double, UShort_t, double>> GetPeaksVeto(double threshold, UShort_t distance = 5,
                                                                   double signalBaseLine = 0.0) const;
 
    TRestRawSignal();
    TRestRawSignal(Int_t nBins);
    ~TRestRawSignal();
 
    ClassDef(TRestRawSignal, 3);
};
#endif