BackEndSiPM.h

Go to the documentation of this file.

#ifndef _mdet_BackEndSiPM_h
#define _mdet_BackEndSiPM_h

#include <mdet/MComponentGroup.h>
#include <mdet/MDetectorComponent.h>
//
#include <utl/Validated.h>
//
#include <complex>
#include <memory>

namespace det {
  struct ParentCreator;
  struct ComponentUpdater;
}

namespace mdet {

  class Module;
  class BackEndSiPM :
    public MDetectorComponent<BackEndSiPM>::Type {
  public:

    static const char* const kComponentName;

    static const char* const kComponentId;
    const Module& GetModule() const {
      return fModule;
    }

    enum TransferStep {
      eFirstAdder,
      eSecondAdder,
      eLowGainAmplifier,
          eHighGainAmplifier,
          eADC,
          eSimplifiedLG,
          eSimplifiedHG
    };

    std::complex<double> ComputeTransfer(double freq, TransferStep step) const;

    double ApplySaturation (double value, TransferStep step) const;

    short GetNumberOfChannelsToGroup() const;

    double GetLowGainAmplifierOffset() const;

    double GetHighGainAmplifierOffset() const;

  private:


    std::complex<double> ComputeTransferLowGainAmplifier(double freq) const;

    std::complex<double> ComputeTransferHighGainAmplifier(double freq) const;

    std::complex<double> ComputeTransferFirstAdder(double freq) const;

    std::complex<double> ComputeTransferSecondAdder(double freq) const;

    std::complex<double> ComputeTransferADC(double freq) const;

    std::complex<double> ComputeTransferSimplifiedLG(double freq) const;

    std::complex<double> ComputeTransferSimplifiedHG(double freq) const;

    double ApplySaturationLowGainAmplifier(double v) const;

    double ApplySaturationHighGainAmplifier(double v) const;

    double ApplySaturationFirstAdder(double v) const;

    double ApplySaturationSecondAdder(double v) const;

    double ApplySaturationADC(double v) const;


    const char* Get1stAdderFunctionReal() const{
        return "(x*TMath::TwoPi()*10^6*[0]*pow(10,27)*([3]*pow(10,27)*x*TMath::TwoPi()*10^6-[1]*pow(10,10)*(x*TMath::TwoPi()*10^6)^3))/"
                        "(((x*TMath::TwoPi()*10^6)^4-[2]*pow(10,19)*(x*TMath::TwoPi()*10^6)^2+[4]*pow(10,32))^2+"
                        "([3]*pow(10,27)*x*TMath::TwoPi()*10^6-[1]*pow(10,10)*(x*TMath::TwoPi()*10^6)^3)^2)";
    }

    const char* Get1stAdderFunctionIm() const{
        return "(x*TMath::TwoPi()*10^6*[0]*pow(10,27)*((x*TMath::TwoPi()*10^6)^4-[2]*pow(10,19)*(x*TMath::TwoPi()*10^6)^2+[4]*pow(10,32)))/"
                        "(((x*TMath::TwoPi()*10^6)^4-[2]*pow(10,19)*(x*TMath::TwoPi()*10^6)^2+[4]*pow(10,32))^2+"
                        "([3]*pow(10,27)*x*TMath::TwoPi()*10^6-[1]*pow(10,10)*(x*TMath::TwoPi()*10^6)^3)^2)";
    }

    double GetFirstAdderPar1() const;
    double GetFirstAdderPar2() const;
    double GetFirstAdderPar3() const;
    double GetFirstAdderPar4() const;
    double GetFirstAdderPar5() const;

    double GetFirstAdderSaturationUp() const;
    double GetFirstAdderSaturationDown() const;
    double GetFirstAdderOffset() const;

    const char* Get2ndAdderFunctionReal() const{
        return "(x*TMath::TwoPi()*10^6*[0]*pow(10,27)*([3]*pow(10,27)*x*TMath::TwoPi()*10^6-[1]*pow(10,9)*(x*TMath::TwoPi()*10^6)^3))/"
                        "(((x*TMath::TwoPi()*10^6)^4-[2]*pow(10,19)*(x*TMath::TwoPi()*10^6)^2+[4]*pow(10,31))^2+"
                        "([3]*pow(10,27)*x*TMath::TwoPi()*10^6-[1]*pow(10,9)*(x*TMath::TwoPi()*10^6)^3)^2)";
    }

    const char* Get2ndAdderFunctionIm() const{
        return "(x*TMath::TwoPi()*10^6*[0]*pow(10,27)*((x*TMath::TwoPi()*10^6)^4-[2]*pow(10,19)*(x*TMath::TwoPi()*10^6)^2+[4]*pow(10,31)))/"
                        "(((x*TMath::TwoPi()*10^6)^4-[2]*pow(10,19)*(x*TMath::TwoPi()*10^6)^2+[4]*pow(10,31))^2+"
                        "([3]*pow(10,27)*x*TMath::TwoPi()*10^6-[1]*pow(10,9)*(x*TMath::TwoPi()*10^6)^3)^2)";
    }

    double GetSecondAdderPar1() const;
    double GetSecondAdderPar2() const;
    double GetSecondAdderPar3() const;
    double GetSecondAdderPar4() const;
    double GetSecondAdderPar5() const;

    double GetSecondAdderSaturationUp() const;
    double GetSecondAdderSaturationDown() const;
    double GetSecondAdderOffset() const;

    const char* GetAmplifierLGFunctionReal() const{
        return "-1*[9]*(-(x*TMath::TwoPi()*10^6)^2*[0]*pow(10,54)*(-[2]*pow(10,10)*(x*TMath::TwoPi()*10^6)^6+[4]*pow(10,36)*"
                        "(x*TMath::TwoPi()*10^6)^4-[6]*pow(10,54)*(x*TMath::TwoPi()*10^6)^2+[8]*pow(10,64))+(x*TMath::TwoPi()*10^6)*[1]*pow(10,59)*"
                        "([3]*pow(10,25)*(x*TMath::TwoPi()*10^6)^5-[5]*pow(10,45)*(x*TMath::TwoPi()*10^6)^3+(x*TMath::TwoPi()*10^6)*"
                        "[7]*pow(10,59)))/((-[2]*pow(10,10)*(x*TMath::TwoPi()*10^6)^6+[4]*pow(10,36)*(x*TMath::TwoPi()*10^6)^4-[6]*pow(10,54)*"
                        "(x*TMath::TwoPi()*10^6)^2+[8])^2+([3]*pow(10,25)*(x*TMath::TwoPi()*10^6)^5-[5]*pow(10,45)*(x*TMath::TwoPi()*10^6)^3+"
                        "(x*TMath::TwoPi()*10^6)*[7]*pow(10,59))^2)";

    }

    const char* GetAmplifierLGFunctionIm() const{
        return "-1*[9]*((x*TMath::TwoPi()*10^6)*[1]*pow(10,59)*(-[2]*pow(10,10)*(x*TMath::TwoPi()*10^6)^6+[4]*"
                        "pow(10,36)*(x*TMath::TwoPi()*10^6)^4-[6]*pow(10,54)*(x*TMath::TwoPi()*10^6)^2+[8]*pow(10,64))+"
                        "(x*TMath::TwoPi()*10^6)^2*[0]*pow(10,54)*([3]*pow(10,25)*(x*TMath::TwoPi()*10^6)^5-[5]*pow(10,45)*"
                        "(x*TMath::TwoPi()*10^6)^3+(x*TMath::TwoPi()*10^6)*[7]*pow(10,59)))/((-[2]*pow(10,10)*(x*TMath::TwoPi()*10^6)^6+"
                        "[4]*pow(10,36)*(x*TMath::TwoPi()*10^6)^4-[6]*pow(10,54)*(x*TMath::TwoPi()*10^6)^2+[8])^2+([3]*pow(10,25)*"
                        "(x*TMath::TwoPi()*10^6)^5-[5]*pow(10,45)*(x*TMath::TwoPi()*10^6)^3+(x*TMath::TwoPi()*10^6)*[7]*pow(10,59))^2)";

    }

    double GetLowGainAmplifierAdjustFactor() const; //2.263
    double GetLowGainAmplifierPar1() const;
    double GetLowGainAmplifierPar2() const;
    double GetLowGainAmplifierPar3() const;
    double GetLowGainAmplifierPar4() const;
    double GetLowGainAmplifierPar5() const;
    double GetLowGainAmplifierPar6() const;
    double GetLowGainAmplifierPar7() const;
    double GetLowGainAmplifierPar8() const;
    double GetLowGainAmplifierPar9() const;

    double GetLowGainAmplifierSaturationUp() const;
    double GetLowGainAmplifierSaturationDown() const;
    double GetLowGainAmplifierAdjustmentFactor() const;

    const char* GetAmplifierHGFunctionReal() const{
        return "-1*[9]*(-(x*TMath::TwoPi()*10^6)^2*[0]*pow(10,53)*(-[2]*pow(10,10)*(x*TMath::TwoPi()*10^6)^6+"
                        "(x*TMath::TwoPi()*10^6)^4*[4]*pow(10,35)-[6]*pow(10,53)*(x*TMath::TwoPi()*10^6)^2+[8]*pow(10,63))+"
                        "(x*TMath::TwoPi()*10^6)*[1]*pow(10,59)*([3]*pow(10,24)*(x*TMath::TwoPi()*10^6)^5-[5]*pow(10,44)*"
                        "(x*TMath::TwoPi()*10^6)^3+(x*TMath::TwoPi()*10^6)*[7]*pow(10,58)))/((-[2]*pow(10,10)*(x*TMath::TwoPi()*10^6)^6+"
                        "(x*TMath::TwoPi()*10^6)^4*[4]*pow(10,35)-[6]*pow(10,53)*(x*TMath::TwoPi()*10^6)^2+[8]*pow(10,63))^2+([3]*pow(10,24)*"
                        "(x*TMath::TwoPi()*10^6)^5-[5]*pow(10,44)*(x*TMath::TwoPi()*10^6)^3+(x*TMath::TwoPi()*10^6)*[7]*pow(10,58))^2)";

    }

    const char* GetAmplifierHGFunctionIm() const{
        return "-1*[9]*(((x*TMath::TwoPi()*10^6)*[1]*pow(10,59)*(-[2]*pow(10,10)*(x*TMath::TwoPi()*10^6)^6+"
                        "(x*TMath::TwoPi()*10^6)^4*[4]*pow(10,35)-[6]*pow(10,53)*(x*TMath::TwoPi()*10^6)^2+[8]*pow(10,63))+"
                        "(x*TMath::TwoPi()*10^6)^2*[0]*pow(10,53)*([3]*pow(10,24)*(x*TMath::TwoPi()*10^6)^5-[5]*pow(10,44)*"
                        "(x*TMath::TwoPi()*10^6)^3+(x*TMath::TwoPi()*10^6)*[7]*pow(10,58)))/((-[2]*pow(10,10)*(x*TMath::TwoPi()*10^6)^6+"
                        "(x*TMath::TwoPi()*10^6)^4*[4]*pow(10,35)-[6]*pow(10,53)*(x*TMath::TwoPi()*10^6)^2+[8]*pow(10,63))^2+([3]*pow(10,24)*"
                        "(x*TMath::TwoPi()*10^6)^5-[5]*pow(10,44)*(x*TMath::TwoPi()*10^6)^3+(x*TMath::TwoPi()*10^6)*[7]*pow(10,58))^2))";

    }

    double GetHighGainAmplifierAdjustFactor() const; //1.9*2.263
    double GetHighGainAmplifierPar1() const;
    double GetHighGainAmplifierPar2() const;
    double GetHighGainAmplifierPar3() const;
    double GetHighGainAmplifierPar4() const;
    double GetHighGainAmplifierPar5() const;
    double GetHighGainAmplifierPar6() const;
    double GetHighGainAmplifierPar7() const;
    double GetHighGainAmplifierPar8() const;
    double GetHighGainAmplifierPar9() const;

    double GetHighGainAmplifierSaturationUp() const;
    double GetHighGainAmplifierSaturationDown() const;
    double GetHighGainAmplifierAdjustmentFactor() const;



    const char* GetADCFunctionReal() const{
        return "(-[0]*(x*TMath::TwoPi()*10^6)^2*([5]-[3]*(x*TMath::TwoPi()*10^6)^2)+[1]*(x*TMath::TwoPi()*10^6)*"
                        "((x*TMath::TwoPi()*10^6)*[4]-[2]*(x*TMath::TwoPi()*10^6)^3))/(([5]-[3]*(x*TMath::TwoPi()*10^6)^2)^2+"
                        "((x*TMath::TwoPi()*10^6)*[4]-[2]*(x*TMath::TwoPi()*10^6)^3)^2)";
    }

    const char* GetADCFunctionIm() const{
        return "([0]*(x*TMath::TwoPi()*10^6)^2*((x*TMath::TwoPi()*10^6)*[4]-[2]*(x*TMath::TwoPi()*10^6)^3)+"
                        "[1]*(x*TMath::TwoPi()*10^6)*([5]-[3]*(x*TMath::TwoPi()*10^6)^2))/(([5]-[3]*(x*TMath::TwoPi()*10^6)^2)^2+"
                        "((x*TMath::TwoPi()*10^6)*[4]-[2]*(x*TMath::TwoPi()*10^6)^3)^2)";
    }

    double GetADCPar1() const;
    double GetADCPar2() const;
    double GetADCPar3() const;
    double GetADCPar4() const;
    double GetADCPar5() const;
    double GetADCPar6() const;

    double GetADCSaturationUp() const;
    double GetADCSaturationDown() const;
    double GetADCOffset() const;

    double GetSimplifiedGainLG() const;
    double GetSimplifiedGainHG() const;
    double GetSimplifiedTime() const;

    friend class Module;

    friend class utl::ShadowPtr<BackEndSiPM>;
    template<class A1, class A2, class A3, class A4>
    friend class det::ComponentGroup;

    BackEndSiPM(int cId, const det::VManager::IndexMap& parentMap, const Module& parent);
    ~BackEndSiPM() { }
    friend struct det::ParentCreator;
    template<class T>
    friend void boost::checked_delete(T*) BOOST_NOEXCEPT;
    friend struct det::ComponentUpdater;

    //16
    mutable utl::Validated<double> fFirstAdderPar1;
    mutable utl::Validated<double> fFirstAdderPar2;
    mutable utl::Validated<double> fFirstAdderPar3;
    mutable utl::Validated<double> fFirstAdderPar4;
    mutable utl::Validated<double> fFirstAdderPar5;
    mutable utl::Validated<double> fFirstAdderSaturationUp;
    mutable utl::Validated<double> fFirstAdderSaturationDown;
    mutable utl::Validated<double> fFirstAdderOffset;

    mutable utl::Validated<double> fSecondAdderPar1;
    mutable utl::Validated<double> fSecondAdderPar2;
    mutable utl::Validated<double> fSecondAdderPar3;
    mutable utl::Validated<double> fSecondAdderPar4;
    mutable utl::Validated<double> fSecondAdderPar5;
    mutable utl::Validated<double> fSecondAdderSaturationUp;
    mutable utl::Validated<double> fSecondAdderSaturationDown;
    mutable utl::Validated<double> fSecondAdderOffset;

    //26
    mutable utl::Validated<double> fLowGainAmplifierPar1;
    mutable utl::Validated<double> fLowGainAmplifierPar2;
    mutable utl::Validated<double> fLowGainAmplifierPar3;
    mutable utl::Validated<double> fLowGainAmplifierPar4;
    mutable utl::Validated<double> fLowGainAmplifierPar5;
    mutable utl::Validated<double> fLowGainAmplifierPar6;
    mutable utl::Validated<double> fLowGainAmplifierPar7;
    mutable utl::Validated<double> fLowGainAmplifierPar8;
    mutable utl::Validated<double> fLowGainAmplifierPar9;

    mutable utl::Validated<double> fLowGainAmplifierAdjustmentFactor;
    mutable utl::Validated<double> fLowGainAmplifierSaturationUp;
    mutable utl::Validated<double> fLowGainAmplifierSaturationDown;
    mutable utl::Validated<double> fLowGainAmplifierOffset;

    mutable utl::Validated<double> fHighGainAmplifierPar1;
    mutable utl::Validated<double> fHighGainAmplifierPar2;
    mutable utl::Validated<double> fHighGainAmplifierPar3;
    mutable utl::Validated<double> fHighGainAmplifierPar4;
    mutable utl::Validated<double> fHighGainAmplifierPar5;
    mutable utl::Validated<double> fHighGainAmplifierPar6;
    mutable utl::Validated<double> fHighGainAmplifierPar7;
    mutable utl::Validated<double> fHighGainAmplifierPar8;
    mutable utl::Validated<double> fHighGainAmplifierPar9;
    mutable utl::Validated<double> fHighGainAmplifierAdjustmentFactor;
    mutable utl::Validated<double> fHighGainAmplifierSaturationUp;
    mutable utl::Validated<double> fHighGainAmplifierSaturationDown;
    mutable utl::Validated<double> fHighGainAmplifierOffset;

    //9
    mutable utl::Validated<double> fADCPar1;
    mutable utl::Validated<double> fADCPar2;
    mutable utl::Validated<double> fADCPar3;
    mutable utl::Validated<double> fADCPar4;
    mutable utl::Validated<double> fADCPar5;
    mutable utl::Validated<double> fADCPar6;
    mutable utl::Validated<double> fADCSaturationUp;
    mutable utl::Validated<double> fADCSaturationDown;
    mutable utl::Validated<double> fADCOffset;

    mutable utl::Validated<double> fNumberOfChannelsToGroup;

    mutable utl::Validated<double> fSimplifiedGainLG;
    mutable utl::Validated<double> fSimplifiedGainHG;
    mutable utl::Validated<double> fSimplifiedTime;

    const Module& fModule;

  };

}

#endif // _mdet_BackEndSiPM_h