AtPSADeconv.h

Go to the documentation of this file.

#ifndef ATPSADECONV_H
#define ATPSADECONV_H
 
#include "AtPSA.h"
#include "AtPad.h"
#include "AtRawEvent.h"
 
#include <TVirtualFFT.h> // for TVirtualFFT
 
#include <cmath>
#include <functional>
#include <memory> // for unique_ptr, make_unique
#include <string> // for string
#include <utility>
#include <vector>
 
class AtPadFFT;
 
class AtPSADeconv : public virtual AtPSA {
 
protected:
   using ResponseFunc = std::function<double(int, double)>;
 
   AtRawEvent fEventResponse;
   ResponseFunc fResponse{nullptr};
 
   std::unique_ptr<TVirtualFFT> fFFT{nullptr};
   std::unique_ptr<TVirtualFFT> fFFTbackward{nullptr};
 
   int fFilterOrder{0};             //< Half the filter order
   int fCutoffFreq{-1};             //< Cutoff frequency squared
   bool fUseSimulatedCharge{false}; //< If true will attempt to use simulated charge instead of deconv.
 
public:
   AtPSADeconv();
   AtPSADeconv(AtPSADeconv &&obj) = default;
   AtPSADeconv &operator=(AtPSADeconv &&obj) = default;
   AtPSADeconv(const AtPSADeconv &obj);
   ~AtPSADeconv() = default;
 
   virtual std::unique_ptr<AtPSA> Clone() override { return std::make_unique<AtPSADeconv>(*this); }
   virtual HitVector AnalyzePad(AtPad *pad) override;
 
   void SetFilterOrder(int order);
   void SetCutoffFreq(int freq);
   void SetUseSimCharge(bool val) { fUseSimulatedCharge = val; }
 
   int GetFilterOrder() { return fFilterOrder * 2; }
   int GetCutoffFreq() { return sqrt(fCutoffFreq); }
 
   void SetResponse(AtRawEvent response) { fEventResponse = std::move(response); }
   void SetResponse(ResponseFunc response) { fResponse = response; }
 
   AtPad &GetResponse(int padNum);
   const AtPadFFT &GetResponseFFT(int padNum);
   const AtPadFFT &GetResponseFilter(int padNum);
 
protected:
   struct ZHitData {
      double z;
      double zVar;
      double q;
      double qVar;
   };
 
   using HitData = std::vector<ZHitData>;
 
   AtPad *createResponsePad(int padNum);
 
   virtual HitVector chargeToHits(AtPad &charge, std::string qName);
 
   virtual HitData getZandQ(const AtPad::trace &charge);
   virtual double getZhitVariance(double zLoc, double zLocVar) const override;
 
   void initFFTs();
   void initFilter();
   void updateFilter(const AtPadFFT &fft, AtPadFFT *filter);
   double getFilterKernel(int freq);
 
   HitVector AnalyzeFFTpad(AtPad &pad);
};
 
#endif //#ifndef ATPSADECONV_H