KVSignal.h

 
 
#ifndef __KVSIGNAL_H
#define __KVSIGNAL_H
 
#include "TGraph.h"
#include "TArrayF.h"
#include "TH1F.h"
 
class KVDetector;
class KVDBParameterList;
 
class KVSignal : public TGraph {
public:
   enum SignalType {
      kQH1,
      kI1,
      kQL1,
      kQ2,
      kI2,
      kQ3,
      kADC,
      kUNKDT
   };
 
protected:
    Int_t fIndex;
    Int_t fChannel;
 
    TString fDetName;
    TString fType;
 
    Int_t fFPGAOutputNumbers;
 
    TArrayF fAdc;
    Double_t fAmplitude;
    Double_t fRiseTime;
    Double_t fIMax;
    Double_t fTMax;
    Double_t fYmin, fYmax;
    Double_t fBaseLine;
    Double_t fSigmaBase;
    Double_t fEndLine;
    Double_t fSigmaEnd;
 
    Double_t fChannelWidth;
    Double_t fInterpolatedChannelWidth;
    Int_t fFirstBL, fLastBL;
    Double_t fTauRC;
    Double_t fTrapRiseTime;
    Double_t fTrapFlatTop;
    Double_t fSemiGaussSigma;
    Bool_t fWithPoleZeroCorrection;
    Bool_t fWithInterpolation;
    Double_t fMinimumValueForAmplitude;
 
    Bool_t fPSAIsDone;
    Double_t fChannelWidthInt;
   void ResetIndexes();
   virtual void BuildCubicSignal(); //Interpolazione mediante cubic
   virtual void BuildCubicSplineSignal(); //Interpolazione mediante cubic spline
   virtual void BuildSmoothingSplineSignal(); //Interpolazione mediante cubic spline
   void init();
   void TreateOldSignalName();
 
public:
   KVSignal();
   KVSignal(const char* name, const char* title);
   KVSignal(const TString& name, const TString& title);
   virtual ~KVSignal();
   void Copy(TObject& obj) const;
 
   Bool_t IsLongEnough() const;
 
   const Char_t* GetDetectorName()  const
   {
      return fDetName.Data();
   }
   void SetDetectorName(const Char_t* name)
   {
      fDetName = name;
   }
 
   void SetType(const Char_t* type)
   {
      fType = type;
   }
   const Char_t* GetType()          const
   {
      return fType.Data();
   }
   void DeduceFromName();
   Int_t GetIndex()           const
   {
      return fIndex;
   }
 
   virtual Bool_t IsCharge() const
   {
      return kFALSE;
   }
   virtual Bool_t IsCurrent() const
   {
      return kFALSE;
   }
 
   void Print(Option_t* chopt = "") const;
 
   void SetData(Int_t nn, Double_t* xx, Double_t* yy);
   virtual void Set(Int_t n);
   void SetADCData();
   TArrayF* GetArray()
   {
      return &fAdc;
   }
 
   Int_t GetNFPGAValues() const
   {
      return fFPGAOutputNumbers;
   }
 
   Bool_t HasFPGA() const
   {
      return (GetNFPGAValues() > 0);
   }
 
   Double_t GetPSAParameter(const Char_t* parname);
   virtual void LoadPSAParameters();
   virtual void SetDefaultValues();
   virtual void UpdatePSAParameter(KVDBParameterList* par);
   KVSignal* ConvertTo(const Char_t* type);
 
   virtual bool IsOK();
 
   virtual void TreateSignal();
#define KVSIGNAL_GETPSARESULT_KVDETECTOR 1
   virtual void GetPSAResult(KVDetector*) const
   {
   }
   Bool_t PSAHasBeenComputed() const
   {
      return fPSAIsDone;
   }
 
   void SetChannelWidth(double width)
   {
      fChannelWidth = width;
      fChannelWidthInt = width;
   }
   Double_t GetChannelWidth() const
   {
      return fChannelWidth;
   }
   Bool_t TestWidth() const;
   void ChangeChannelWidth(Double_t newwidth);
   void SetMaxT(double t)
   {
      fAdc.Set((int)(t / fChannelWidth));
   }
   void SetNSamples(int nn)
   {
      fAdc.Set(nn);
   }
   Int_t GetNSamples() const
   {
      return fAdc.GetSize();
   }
 
   void SetBaseLineLength(Int_t length, Int_t first = 0)
   {
      fFirstBL = first;
      fLastBL = length - first;
   }
   Double_t GetBLFirst() const
   {
      return fFirstBL;
   }
   Double_t GetBLLength() const
   {
      return fLastBL - fFirstBL;
   }
 
   virtual Double_t ComputeBaseLine();
   virtual Double_t ComputeDuration(Double_t th = 0.2);
   virtual Double_t ComputeEndLine();
   virtual void RemoveBaseLine();
 
   void BuildReverseTimeSignal();
 
   Bool_t IsFired();
 
   Double_t GetBaseLine() const
   {
      return fBaseLine;
   }
   Double_t GetSigmaBaseLine()const
   {
      return fSigmaBase;
   }
 
   Double_t GetEndLine() const
   {
      return fEndLine;
   }
   Double_t GetSigmaEndLine()const
   {
      return fSigmaEnd;
   }
 
   Double_t ComputeRiseTime();
   Double_t GetRiseTime() const
   {
      return fRiseTime;
   }
 
   Double_t ComputeAmplitude();
   Double_t GetAmplitude() const
   {
      return fAmplitude;
   }
 
   void SetTrapShaperParameters(Double_t rise, Double_t flat)
   {
      fTrapRiseTime = rise;
      fTrapFlatTop = flat;
   }
   void SetShaperRiseTime(Double_t rise)
   {
      fTrapRiseTime = rise;
   }
   void SetShaperFlatTop(Double_t flat)
   {
      fTrapFlatTop = flat;
   }
   Double_t GetShaperRiseTime()const
   {
      return fTrapRiseTime;
   }
   Double_t GetShaperFlatTop() const
   {
      return fTrapFlatTop;
   }
   Double_t ComputeCFDThreshold(Double_t threshold = 0.5);
 
   void SetSemiGaussSigma(Double_t sig)
   {
      fSemiGaussSigma = sig;
   }
   Double_t GetSemiGaussSigma() const
   {
      return fSemiGaussSigma;
   }
 
   void SetPoleZeroCorrection(Bool_t with = kTRUE)
   {
      fWithPoleZeroCorrection = with;
   }
   void SetTauRC(Int_t taurc)
   {
      fTauRC = taurc;
   }
   Double_t GetTauRC() const
   {
      return fTauRC;
   }
 
   void SetInterpolation(Bool_t with = kTRUE)
   {
      fWithInterpolation = with;
   }
   void SetInterpolatedChannelWidth(double width)
   {
      fInterpolatedChannelWidth = width;
   }
   Double_t GetInterpolatedChannelWidth() const
   {
      return fInterpolatedChannelWidth;
   }
 
   virtual void ComputeRawAmplitude(void);
   Double_t GetRawAmplitude() const
   {
      return fYmax - fYmin;
   }
   Double_t GetYmin() const
   {
      return fYmin;
   }
   Double_t GetYmax() const
   {
      return fYmax;
   }
 
   Double_t GetAmplitudeTriggerValue() const
   {
      return fMinimumValueForAmplitude;
   }
   void SetAmplitudeTriggerValue(Double_t val)
   {
      fMinimumValueForAmplitude = val;
   }
 
   Bool_t ComputeMeanAndSigma(Int_t start, Int_t stop, Double_t& mean, Double_t& sigma);
   Bool_t ComputeMeanAndSigma(Double_t start, Double_t stop, Double_t& mean, Double_t& sigma);
 
 
   void Multiply(Double_t fact);
   void Add(Double_t fact);
 
   Double_t ARC_CFD(Double_t threshold = 0.3, Double_t tdelay = 10);
   double FindTzeroLeadingEdgeCubic(double LEVEL, int Nrecurr);
   Double_t FindTzeroCFDCubic(double level, int Nrecurr);
   double FindTzeroCFDCubic_rev(double level, double tend, int Nrecurr);
   Double_t CubicInterpolation(float* data, int x2, double fmax, int Nrecurr);
 
   virtual void BuildCubicSignal(double taufinal); //Interpolazione mediante cubic
   virtual void BuildCubicSplineSignal(double taufinal);//Interpolazione mediante spline cubic
   virtual void BuildSmoothingSplineSignal(double taufinal, double l = 1, int nbits = -1); //Interpolazione mediante smoothing spline
 
   virtual double GetDataInter(double t);
   virtual double GetDataInterCubic(double t);
   virtual double GetDataCubicSpline(double t);
   virtual double GetDataSmoothingSplineLTI(double t);//metodo che serve a BuildSmoothingSpline
   virtual double EvalCubicSpline(double X);//metodo che serve a BuildSmoothingSpline
 
   void FIR_ApplyTrapezoidal(double trise, double tflat); // trise=sqrt(12)*tausha di CR-RC^4 se tflat=trise/2
   void FIR_ApplySemigaus(double tau_usec);
   void FIR_ApplyRCLowPass(double time_usec, int reverse = 0);
   void FIR_ApplyRCHighPass(double time_usec, int reverse = 0);
   void FIR_ApplyRecursiveFilter(double a0, int N, double* a, double* b, int reverse);
   void FIR_ApplyMovingAverage(int npoints);
   void PoleZeroSuppression(Double_t tauRC);
   int FIR_ApplySmoothingSpline(double l, int nbits = -1);
   double ApplyNewton(double l, double x0);//metodo che serve a FIR_ApplySmoothingSpline
 
   void ApplyWindowing(int window_type = 3); // 0: barlett, 1:hanning, 2:hamming, 3: blackman
   static int FFT(unsigned int p_nSamples, bool p_bInverseTransform, double* p_lpRealIn, double* p_lpImagIn, double* p_lpRealOut, double* p_lpImagOut); // nsamples: power of 2
   int FFT(bool p_bInverseTransform, double* p_lpRealOut, double* p_lpImagOut);
   TH1* FFT2Histo(int output, TH1* hh = 0); // 0 modulo, 1 modulo db (normalized), 2, re, 3 im
 
   void ApplyModifications(TGraph* newSignal = 0, Int_t nsa = -1);
 
 
   void ShiftLeft(double);//shift in ns
   void ShiftRight(double);//shift in ns
   void TestDraw();
 
   static KVSignal* MakeSignal(const char* sig_type);
 
   ClassDef(KVSignal, 4) //Base class for FAZIA signal processing
 
};
 
#endif