BackEndSiPM.cc

Go to the documentation of this file.

#include <mdet/BackEndSiPM.h>

#include <mdet/MHierarchyInfo.h>
//
#include <utl/AugerUnits.h>
#include <utl/MathConstants.h>
//
#include <fwk/RandomEngineRegistry.h>
#include <CLHEP/Random/RandGauss.h>

#include <algorithm>
#include <vector>
#include <sstream>
#include <iostream>
#include <string>
#include <TFormula.h>
#include <complex>

//

namespace mdet {

  const char* const
  BackEndSiPM::kComponentName = MHierarchyInfo::kComponentsNames[12];

  const char* const
  BackEndSiPM::kComponentId   = MHierarchyInfo::kComponentsIds[12];

  BackEndSiPM::BackEndSiPM
    (int cId, const det::VManager::IndexMap& parentMap, const Module& parent) :
      MDetectorComponent<BackEndSiPM>::Type(cId, parentMap),
      fModule(parent)
  {
            Register(fFirstAdderPar1);
            Register(fFirstAdderPar2);
            Register(fFirstAdderPar3);
            Register(fFirstAdderPar4);
            Register(fFirstAdderPar5);
            Register(fFirstAdderSaturationUp);
            Register(fFirstAdderSaturationDown);
            Register(fFirstAdderOffset);
            Register(fSecondAdderPar1);
            Register(fSecondAdderPar2);
            Register(fSecondAdderPar3);
            Register(fSecondAdderPar4);
            Register(fSecondAdderPar5);
            Register(fSecondAdderSaturationUp);
            Register(fSecondAdderSaturationDown);
            Register(fSecondAdderOffset);
            Register(fLowGainAmplifierPar1);
            Register(fLowGainAmplifierPar2);
            Register(fLowGainAmplifierPar3);
            Register(fLowGainAmplifierPar4);
            Register(fLowGainAmplifierPar5);
            Register(fLowGainAmplifierPar6);
            Register(fLowGainAmplifierPar7);
            Register(fLowGainAmplifierPar8);
            Register(fLowGainAmplifierPar9);
            Register(fLowGainAmplifierAdjustmentFactor);
            Register(fLowGainAmplifierSaturationUp);
            Register(fLowGainAmplifierSaturationDown);
            Register(fLowGainAmplifierOffset);
            Register(fHighGainAmplifierPar1);
            Register(fHighGainAmplifierPar2);
            Register(fHighGainAmplifierPar3);
            Register(fHighGainAmplifierPar4);
            Register(fHighGainAmplifierPar5);
            Register(fHighGainAmplifierPar6);
            Register(fHighGainAmplifierPar7);
            Register(fHighGainAmplifierPar8);
            Register(fHighGainAmplifierPar9);
            Register(fHighGainAmplifierAdjustmentFactor);
            Register(fHighGainAmplifierSaturationUp);
            Register(fHighGainAmplifierSaturationDown);
            Register(fHighGainAmplifierOffset);
            Register(fADCPar1);
            Register(fADCPar2);
            Register(fADCPar3);
            Register(fADCPar4);
            Register(fADCPar5);
            Register(fADCPar6);
            Register(fADCSaturationUp);
            Register(fADCSaturationDown);
            Register(fADCOffset);
            Register(fSimplifiedGainLG);
            Register(fSimplifiedGainHG);
            Register(fSimplifiedTime);
            Register(fNumberOfChannelsToGroup);
  }


  /******************************
   *    First Adder Getters             *
   ******************************/

  double
  BackEndSiPM::GetFirstAdderPar1()
    const
  {
    return GetData(fFirstAdderPar1, "firstAdderPar1");
  }
  double
  BackEndSiPM::GetFirstAdderPar2()
    const
  {
        return GetData(fFirstAdderPar2, "firstAdderPar2");
  }
  double
  BackEndSiPM::GetFirstAdderPar3()
    const
  {
        return GetData(fFirstAdderPar3, "firstAdderPar3");
  }
  double
  BackEndSiPM::GetFirstAdderPar4()
    const
  {
        return GetData(fFirstAdderPar4, "firstAdderPar4");
  }
  double
  BackEndSiPM::GetFirstAdderPar5()
    const
  {
        return GetData(fFirstAdderPar5, "firstAdderPar5");
  }
  double
  BackEndSiPM::GetFirstAdderSaturationUp()
    const
  {
    return GetData(fFirstAdderSaturationUp, "firstAdderSaturationUp");
  }
  double
  BackEndSiPM::GetFirstAdderSaturationDown()
    const
  {
    return GetData(fFirstAdderSaturationDown, "firstAdderSaturationDown");
  }
  double
  BackEndSiPM::GetFirstAdderOffset()
    const
  {
    return GetData(fFirstAdderOffset, "firstAdderOffset");
  }

  /******************************
   *    Second Adder Getters    *
   ******************************/

  double
  BackEndSiPM::GetSecondAdderPar1()
    const
  {
    return GetData(fSecondAdderPar1, "secondAdderPar1");
  }
  double
  BackEndSiPM::GetSecondAdderPar2()
    const
  {
        return GetData(fSecondAdderPar2, "secondAdderPar2");
  }
  double
  BackEndSiPM::GetSecondAdderPar3()
    const
  {
        return GetData(fSecondAdderPar3, "secondAdderPar3");
  }
  double
  BackEndSiPM::GetSecondAdderPar4()
    const
  {
        return GetData(fSecondAdderPar4, "secondAdderPar4");
  }
  double
  BackEndSiPM::GetSecondAdderPar5()
    const
  {
        return GetData(fSecondAdderPar5, "secondAdderPar5");
  }
  double
  BackEndSiPM::GetSecondAdderSaturationUp()
    const
  {
    return GetData(fSecondAdderSaturationUp, "secondAdderSaturationUp");
  }
  double
  BackEndSiPM::GetSecondAdderSaturationDown()
    const
  {
    return GetData(fSecondAdderSaturationDown, "secondAdderSaturationDown");
  }
  double
  BackEndSiPM::GetSecondAdderOffset()
    const
  {
    return GetData(fSecondAdderOffset, "secondAdderOffset");
  }

  /**********************************
   *   Low Gain Amplifier Getters       *
   *********************************/

  double
  BackEndSiPM::GetLowGainAmplifierPar1()
    const
  {
    return GetData(fLowGainAmplifierPar1, "lowGainAmplifierPar1");
  }
  double
  BackEndSiPM::GetLowGainAmplifierPar2()
    const
  {
        return GetData(fLowGainAmplifierPar2, "lowGainAmplifierPar2");
  }
  double
  BackEndSiPM::GetLowGainAmplifierPar3()
    const
  {
        return GetData(fLowGainAmplifierPar3, "lowGainAmplifierPar3");
  }
  double
  BackEndSiPM::GetLowGainAmplifierPar4()
    const
  {
        return GetData(fLowGainAmplifierPar4, "lowGainAmplifierPar4");
  }
  double
  BackEndSiPM::GetLowGainAmplifierPar5()
    const
  {
        return GetData(fLowGainAmplifierPar5, "lowGainAmplifierPar5");
  }
  double
  BackEndSiPM::GetLowGainAmplifierPar6()
   const
  {
   return GetData(fLowGainAmplifierPar6, "lowGainAmplifierPar6");
  }
  double
  BackEndSiPM::GetLowGainAmplifierPar7()
   const
  {
   return GetData(fLowGainAmplifierPar7, "lowGainAmplifierPar7");
  }
  double
  BackEndSiPM::GetLowGainAmplifierPar8()
   const
  {
   return GetData(fLowGainAmplifierPar8, "lowGainAmplifierPar8");
  }
  double
  BackEndSiPM::GetLowGainAmplifierPar9()
   const
  {
   return GetData(fLowGainAmplifierPar9, "lowGainAmplifierPar9");
  }
  double
  BackEndSiPM::GetLowGainAmplifierSaturationUp()
    const
  {
    return GetData(fLowGainAmplifierSaturationUp, "lowGainAmplifierSaturationUp");
  }
  double
  BackEndSiPM::GetLowGainAmplifierSaturationDown()
    const
  {
    return GetData(fLowGainAmplifierSaturationDown, "lowGainAmplifierSaturationDown");
  }
  double
  BackEndSiPM::GetLowGainAmplifierOffset()
    const
  {
    return GetData(fLowGainAmplifierOffset, "lowGainAmplifierOffset");
  }
  double
  BackEndSiPM::GetLowGainAmplifierAdjustmentFactor()
    const
  {
          return GetData(fLowGainAmplifierAdjustmentFactor, "lowGainAmplifierAdjustmentFactor");
  }

  /**********************************
   *   High Gain Amplifier Getters      *
   *********************************/

  double
  BackEndSiPM::GetHighGainAmplifierPar1()
    const
  {
    return GetData(fHighGainAmplifierPar1, "highGainAmplifierPar1");
  }
  double
  BackEndSiPM::GetHighGainAmplifierPar2()
    const
  {
        return GetData(fHighGainAmplifierPar2, "highGainAmplifierPar2");
  }
  double
  BackEndSiPM::GetHighGainAmplifierPar3()
    const
  {
        return GetData(fHighGainAmplifierPar3, "highGainAmplifierPar3");
  }
  double
  BackEndSiPM::GetHighGainAmplifierPar4()
    const
  {
        return GetData(fHighGainAmplifierPar4, "highGainAmplifierPar4");
  }
  double
  BackEndSiPM::GetHighGainAmplifierPar5()
    const
  {
        return GetData(fHighGainAmplifierPar5, "highGainAmplifierPar5");
  }
  double
  BackEndSiPM::GetHighGainAmplifierPar6()
   const
  {
   return GetData(fHighGainAmplifierPar6, "highGainAmplifierPar6");
  }
  double
  BackEndSiPM::GetHighGainAmplifierPar7()
   const
  {
   return GetData(fHighGainAmplifierPar7, "highGainAmplifierPar7");
  }
  double
  BackEndSiPM::GetHighGainAmplifierPar8()
   const
  {
   return GetData(fHighGainAmplifierPar8, "highGainAmplifierPar8");
  }
  double
  BackEndSiPM::GetHighGainAmplifierPar9()
   const
  {
   return GetData(fHighGainAmplifierPar9, "highGainAmplifierPar9");
  }
  double
  BackEndSiPM::GetHighGainAmplifierSaturationUp()
    const
  {
    return GetData(fHighGainAmplifierSaturationUp, "highGainAmplifierSaturationUp");
  }
  double
  BackEndSiPM::GetHighGainAmplifierSaturationDown()
    const
  {
    return GetData(fHighGainAmplifierSaturationDown, "highGainAmplifierSaturationDown");
  }
  double
  BackEndSiPM::GetHighGainAmplifierOffset()
    const
  {
    return GetData(fHighGainAmplifierOffset, "highGainAmplifierOffset");
  }
  double
  BackEndSiPM::GetHighGainAmplifierAdjustmentFactor()
    const
  {
    return GetData(fHighGainAmplifierAdjustmentFactor, "highGainAmplifierAdjustmentFactor");
  }

  /******************************
   *            ADC Getters                     *
   ******************************/

  double
  BackEndSiPM::GetADCPar1()
    const
  {
    return GetData(fADCPar1, "ADCPar1");
  }
  double
  BackEndSiPM::GetADCPar2()
    const
  {
        return GetData(fADCPar2, "ADCPar2");
  }
  double
  BackEndSiPM::GetADCPar3()
    const
  {
        return GetData(fADCPar3, "ADCPar3");
  }
  double
  BackEndSiPM::GetADCPar4()
    const
  {
        return GetData(fADCPar4, "ADCPar4");
  }
  double
  BackEndSiPM::GetADCPar5()
    const
  {
        return GetData(fADCPar5, "ADCPar5");
  }
  double
  BackEndSiPM::GetADCPar6()
   const
  {
   return GetData(fADCPar6, "ADCPar6");
  }
  double
  BackEndSiPM::GetADCSaturationUp()
    const
  {
    return GetData(fADCSaturationUp, "ADCSaturationUp");
  }
  double
  BackEndSiPM::GetADCSaturationDown()
    const
  {
    return GetData(fADCSaturationDown, "ADCSaturationDown");
  }
  double
  BackEndSiPM::GetADCOffset()
    const
  {
    return GetData(fADCOffset, "ADCOffset");
  }

  short BackEndSiPM::GetNumberOfChannelsToGroup() const{
          return GetData(fNumberOfChannelsToGroup, "numberOfChannelsToGroup");
  }

  /**********************************
   *   High Gain Amplifier Getters      *
   *********************************/

  double
  BackEndSiPM::GetSimplifiedGainLG()
    const
  {
    return GetData(fSimplifiedGainLG, "simplifiedGainLG");
  }
  double
  BackEndSiPM::GetSimplifiedGainHG()
    const
  {
    return GetData(fSimplifiedGainHG, "simplifiedGainHG");
  }
  double
  BackEndSiPM::GetSimplifiedTime()
    const
  {
        return GetData(fSimplifiedTime, "simplifiedTime");
  }

  /*********************************
   *    Get Transfer factors       *
   *********************************/

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

          std::complex<double> value;
          switch(step){
                  case eFirstAdder:
                          value = ComputeTransferFirstAdder(freq);
                          break;
                  case eSecondAdder:
                          value = ComputeTransferSecondAdder(freq);
                          break;
                  case eLowGainAmplifier:
                          value = ComputeTransferLowGainAmplifier(freq);
                          break;
                  case eHighGainAmplifier:
                          value = ComputeTransferHighGainAmplifier(freq);
                          break;
                  case eADC:
                          value = ComputeTransferADC(freq);
                          break;
                  case eSimplifiedLG:
                          value = ComputeTransferSimplifiedLG(freq);
                          break;
                  case eSimplifiedHG:
                          value = ComputeTransferSimplifiedHG(freq);
                          break;
          }
          return value;
  }

  double BackEndSiPM::ApplySaturation (double value, BackEndSiPM::TransferStep step) const {
         // return value;
          switch(step){
                  case eFirstAdder:
                          value = ApplySaturationFirstAdder(value);
                          break;
                  case eSecondAdder:
                          value = ApplySaturationSecondAdder(value);
                          break;
                  case eLowGainAmplifier:
                          value = ApplySaturationLowGainAmplifier(value);
                          break;
                  case eHighGainAmplifier:
                          value = ApplySaturationHighGainAmplifier(value);
                          break;
                  case eADC:
                          value = ApplySaturationADC(value);
                          break;
                  case eSimplifiedLG:
                          value = ApplySaturationLowGainAmplifier(value);
                          break;
                  case eSimplifiedHG:
                          value = ApplySaturationHighGainAmplifier(value);
                          break;
          }
          return value;
  }

  std::complex<double>
  BackEndSiPM::ComputeTransferFirstAdder(double freq)
    const
  {
      TFormula transferReFirstAdder("transferReFirstAdder",Get1stAdderFunctionReal()); //Transfer RE for Pre Amplifier in MHz
      transferReFirstAdder.SetParameter(0, GetFirstAdderPar1());
      transferReFirstAdder.SetParameter(1, GetFirstAdderPar2());
      transferReFirstAdder.SetParameter(2, GetFirstAdderPar3());
      transferReFirstAdder.SetParameter(3, GetFirstAdderPar4());
      transferReFirstAdder.SetParameter(4, GetFirstAdderPar5());

      TFormula transferImFirstAdder("transferImFirstAdder",Get1stAdderFunctionIm()); //Transfer RE for Fast Shaper in MHz
      transferImFirstAdder.SetParameter(0, GetFirstAdderPar1());
      transferImFirstAdder.SetParameter(1, GetFirstAdderPar2());
      transferImFirstAdder.SetParameter(2, GetFirstAdderPar3());
      transferImFirstAdder.SetParameter(3, GetFirstAdderPar4());
      transferImFirstAdder.SetParameter(4, GetFirstAdderPar5());

     /* cout << "transfer function first adder integrator: " << endl;
      cout << GetAdderFunctionReal() << endl;
      cout << GetFirstAdderPar1() << " " << GetFirstAdderPar2() << " " << GetFirstAdderPar3() << " " << GetFirstAdderPar4() << " " << GetFirstAdderPar5() << endl;*/

      const std::complex<double> totalTransfer(transferReFirstAdder.Eval(freq), transferImFirstAdder.Eval(freq));

      return totalTransfer;
  }

  std::complex<double>
  BackEndSiPM::ComputeTransferSecondAdder(double freq)
    const
  {
      TFormula transferReSecondAdder("transferReSecondAdder",Get2ndAdderFunctionReal()); //Transfer RE for Pre Amplifier in MHz
      transferReSecondAdder.SetParameter(0, GetSecondAdderPar1());
      transferReSecondAdder.SetParameter(1, GetSecondAdderPar2());
      transferReSecondAdder.SetParameter(2, GetSecondAdderPar3());
      transferReSecondAdder.SetParameter(3, GetSecondAdderPar4());
      transferReSecondAdder.SetParameter(4, GetSecondAdderPar5());

      TFormula transferImSecondAdder("transferImSecondAdder",Get2ndAdderFunctionIm()); //Transfer RE for Fast Shaper in MHz
      transferImSecondAdder.SetParameter(0, GetSecondAdderPar1());
      transferImSecondAdder.SetParameter(1, GetSecondAdderPar2());
      transferImSecondAdder.SetParameter(2, GetSecondAdderPar3());
      transferImSecondAdder.SetParameter(3, GetSecondAdderPar4());
      transferImSecondAdder.SetParameter(4, GetSecondAdderPar5());

      /*cout << "transfer function second adder integrator: " << endl;
      cout << GetAdderFunctionReal() << endl;
      cout << GetSecondAdderPar1() << " " << GetSecondAdderPar2() << " " << GetSecondAdderPar3() << " " << GetSecondAdderPar4() << " " << GetSecondAdderPar5() << endl;*/

      const std::complex<double> totalTransfer(transferReSecondAdder.Eval(freq), transferImSecondAdder.Eval(freq));

      return totalTransfer;
  }

  std::complex<double>
  BackEndSiPM::ComputeTransferLowGainAmplifier(double freq)
    const
  {
      TFormula transferReLowGainAmplifier("transferReLowGainAmplifier", GetAmplifierLGFunctionReal()); //Transfer RE for Pre Amplifier in MHz
      transferReLowGainAmplifier.SetParameter(0, GetLowGainAmplifierPar1());
      transferReLowGainAmplifier.SetParameter(1, GetLowGainAmplifierPar2());
      transferReLowGainAmplifier.SetParameter(2, GetLowGainAmplifierPar3());
      transferReLowGainAmplifier.SetParameter(3, GetLowGainAmplifierPar4());
      transferReLowGainAmplifier.SetParameter(4, GetLowGainAmplifierPar5());
      transferReLowGainAmplifier.SetParameter(5, GetLowGainAmplifierPar6());
      transferReLowGainAmplifier.SetParameter(6, GetLowGainAmplifierPar7());
      transferReLowGainAmplifier.SetParameter(7, GetLowGainAmplifierPar8());
      transferReLowGainAmplifier.SetParameter(8, GetLowGainAmplifierPar9());
      transferReLowGainAmplifier.SetParameter(9, GetLowGainAmplifierAdjustmentFactor());

      TFormula transferImLowGainAmplifier("transferImLowGainAmplifier", GetAmplifierLGFunctionIm()); //Transfer RE for Fast Shaper in MHz
      transferImLowGainAmplifier.SetParameter(0, GetLowGainAmplifierPar1());
      transferImLowGainAmplifier.SetParameter(1, GetLowGainAmplifierPar2());
      transferImLowGainAmplifier.SetParameter(2, GetLowGainAmplifierPar3());
      transferImLowGainAmplifier.SetParameter(3, GetLowGainAmplifierPar4());
      transferImLowGainAmplifier.SetParameter(4, GetLowGainAmplifierPar5());
      transferImLowGainAmplifier.SetParameter(5, GetLowGainAmplifierPar6());
      transferImLowGainAmplifier.SetParameter(6, GetLowGainAmplifierPar7());
      transferImLowGainAmplifier.SetParameter(7, GetLowGainAmplifierPar8());
      transferImLowGainAmplifier.SetParameter(8, GetLowGainAmplifierPar9());
      transferImLowGainAmplifier.SetParameter(9, GetLowGainAmplifierAdjustmentFactor());

/*      cout << "transfer function Low gain integrator: " << endl;
      cout << GetAmplifierFunctionReal() << endl;
      cout << GetLowGainAmplifierPar1() << " " << GetLowGainAmplifierPar2() << " " << GetLowGainAmplifierPar3() << " " << GetLowGainAmplifierPar4() << " " << GetLowGainAmplifierPar5();
      cout << " " << GetLowGainAmplifierPar6() << " " << GetLowGainAmplifierPar7() << " " << GetLowGainAmplifierPar8() << " " << GetLowGainAmplifierPar9() << endl;*/

      const std::complex<double> totalTransfer(transferReLowGainAmplifier.Eval(freq), transferImLowGainAmplifier.Eval(freq));

      return totalTransfer;
  }

  std::complex<double>
  BackEndSiPM::ComputeTransferHighGainAmplifier(double freq)
    const
  {
      TFormula transferReHighGainAmplifier("transferReHighGainAmplifier", GetAmplifierHGFunctionReal()); //Transfer RE for Pre Amplifier in MHz
      transferReHighGainAmplifier.SetParameter(0, GetHighGainAmplifierPar1());
      transferReHighGainAmplifier.SetParameter(1, GetHighGainAmplifierPar2());
      transferReHighGainAmplifier.SetParameter(2, GetHighGainAmplifierPar3());
      transferReHighGainAmplifier.SetParameter(3, GetHighGainAmplifierPar4());
      transferReHighGainAmplifier.SetParameter(4, GetHighGainAmplifierPar5());
      transferReHighGainAmplifier.SetParameter(5, GetHighGainAmplifierPar6());
      transferReHighGainAmplifier.SetParameter(6, GetHighGainAmplifierPar7());
      transferReHighGainAmplifier.SetParameter(7, GetHighGainAmplifierPar8());
      transferReHighGainAmplifier.SetParameter(8, GetHighGainAmplifierPar9());
      transferReHighGainAmplifier.SetParameter(9, GetHighGainAmplifierAdjustmentFactor());

      TFormula transferImHighGainAmplifier("transferImHighGainAmplifier", GetAmplifierHGFunctionIm()); //Transfer RE for Fast Shaper in MHz
      transferImHighGainAmplifier.SetParameter(0, GetHighGainAmplifierPar1());
      transferImHighGainAmplifier.SetParameter(1, GetHighGainAmplifierPar2());
      transferImHighGainAmplifier.SetParameter(2, GetHighGainAmplifierPar3());
      transferImHighGainAmplifier.SetParameter(3, GetHighGainAmplifierPar4());
      transferImHighGainAmplifier.SetParameter(4, GetHighGainAmplifierPar5());
      transferImHighGainAmplifier.SetParameter(5, GetHighGainAmplifierPar6());
      transferImHighGainAmplifier.SetParameter(6, GetHighGainAmplifierPar7());
      transferImHighGainAmplifier.SetParameter(7, GetHighGainAmplifierPar8());
      transferImHighGainAmplifier.SetParameter(8, GetHighGainAmplifierPar9());
      transferImHighGainAmplifier.SetParameter(9, GetHighGainAmplifierAdjustmentFactor());

      /*cout << "transfer function High gain integrator: " << endl;
      cout << GetAmplifierFunctionReal() << endl;
      cout << GetHighGainAmplifierPar1() << " " << GetHighGainAmplifierPar2() << " " << GetHighGainAmplifierPar3() << " " << GetHighGainAmplifierPar4() << " " << GetHighGainAmplifierPar5();
      cout << " " << GetHighGainAmplifierPar6() << " " << GetHighGainAmplifierPar7() << " " << GetHighGainAmplifierPar8() << " " << GetHighGainAmplifierPar9() << endl;*/

      const std::complex<double> totalTransfer(transferReHighGainAmplifier.Eval(freq), transferImHighGainAmplifier.Eval(freq));

      return totalTransfer;
  }

  std::complex<double>
  BackEndSiPM::ComputeTransferADC(double freq)
    const
  {
      TFormula transferReADC("transferReADC",GetADCFunctionReal()); //Transfer RE for Pre Amplifier in MHz
      transferReADC.SetParameter(0, GetADCPar1());
      transferReADC.SetParameter(1, GetADCPar2());
      transferReADC.SetParameter(2, GetADCPar3());
      transferReADC.SetParameter(3, GetADCPar4());
      transferReADC.SetParameter(4, GetADCPar5());
      transferReADC.SetParameter(5, GetADCPar6());

      TFormula transferImADC("transferImADC",GetADCFunctionIm()); //Transfer RE for Fast Shaper in MHz
      transferImADC.SetParameter(0, GetADCPar1());
      transferImADC.SetParameter(1, GetADCPar2());
      transferImADC.SetParameter(2, GetADCPar3());
      transferImADC.SetParameter(3, GetADCPar4());
      transferImADC.SetParameter(4, GetADCPar5());
      transferImADC.SetParameter(5, GetADCPar6());

     /* cout << "transfer function ADC integrator: " << endl;
      cout << GetAmplifierFunctionReal() << endl;
      cout << GetADCPar1() << " " << GetADCPar2() << " " << GetADCPar3() << " " << GetADCPar4() << " " << GetADCPar5();
      cout << " " << GetADCPar6() << endl;*/

      const std::complex<double> totalTransfer(transferReADC.Eval(freq), transferImADC.Eval(freq));

      return totalTransfer;
  }



  std::complex<double>
  BackEndSiPM::ComputeTransferSimplifiedLG(double freq)
    const
  {

      double totalGain = GetSimplifiedGainLG();
      double totalTime = GetSimplifiedTime();

      const std::complex<double> totalTransfer(-(totalGain/(1+pow(freq*utl::kTwoPi*totalTime,2))),
        (totalGain*(freq*utl::kTwoPi*totalTime)/(1+pow(freq*utl::kTwoPi*totalTime,2))));

      return totalTransfer;
  }

  std::complex<double>
  BackEndSiPM::ComputeTransferSimplifiedHG(double freq)
    const
  {

      double totalGain = GetSimplifiedGainHG();
      double totalTime = GetSimplifiedTime();

      const std::complex<double> totalTransfer(-(totalGain/(1+pow(freq*3.1416*2*totalTime,2))),
                  (totalGain*(freq*2*3.1416*totalTime)/(1+pow(freq*2*3.1416*totalTime,2))));

      return totalTransfer;
  }

  /*
   *********************************
   *****        Apply Saturation   *****
   *********************************
   */

  double
  BackEndSiPM::ApplySaturationFirstAdder(double v)
    const
  {

        v += GetFirstAdderOffset();
    if (v > GetFirstAdderSaturationUp())
      return GetFirstAdderSaturationUp();
    else if (v < GetFirstAdderSaturationDown())
      return  GetFirstAdderSaturationDown();
    else
      return v;
  }

  double
  BackEndSiPM::ApplySaturationSecondAdder(double v)
    const
  {

        v += GetSecondAdderOffset();
    if (v > GetSecondAdderSaturationUp())
      return GetSecondAdderSaturationUp();
    else if (v < GetSecondAdderSaturationDown())
      return  GetSecondAdderSaturationDown();
    else
      return v;
  }

  double
  BackEndSiPM::ApplySaturationLowGainAmplifier(double v)
    const
  {

        v += GetLowGainAmplifierOffset();
    if (v > GetLowGainAmplifierSaturationUp())
      return GetLowGainAmplifierSaturationUp();
    else if (v < GetLowGainAmplifierSaturationDown())
      return  GetLowGainAmplifierSaturationDown();
    else
      return v;
  }

  double
  BackEndSiPM::ApplySaturationHighGainAmplifier(double v)
    const
  {

        v += GetHighGainAmplifierOffset();
    if (v > GetHighGainAmplifierSaturationUp())
      return GetHighGainAmplifierSaturationUp();
    else if (v < GetHighGainAmplifierSaturationDown())
      return  GetHighGainAmplifierSaturationDown();
    else
      return v;
  }

  double
  BackEndSiPM::ApplySaturationADC(double v)
    const
  {

        v += GetADCOffset();
    if (v > GetADCSaturationUp())
      return GetADCSaturationUp();
    else if (v < GetADCSaturationDown())
      return  GetADCSaturationDown();
    else
      return v;
  }

}