ChannelSiPM.cc

Go to the documentation of this file.

#include <mdet/ChannelSiPM.h>

#include <mdet/MHierarchyInfo.h>
//
#include <utl/AugerUnits.h>
#include <utl/MathConstants.h>
//
#include <fwk/RandomEngineRegistry.h>
//
#include <algorithm>
#include <vector>
#include <sstream>
#include <iostream>
#include <string>

namespace mdet {

  const char* const ChannelSiPM::kComponentName = MHierarchyInfo::kComponentsNames[11];

  const char* const ChannelSiPM::kComponentId = MHierarchyInfo::kComponentsIds[11];

  ChannelSiPM::ChannelSiPM(int cId, const det::VManager::IndexMap& parentMap, const FrontEndSiPM& parent) :
    MDetectorComponent<ChannelSiPM>::Type(cId, parentMap),
    fFrontEnd(parent)
  {
    Register(fPreAmplifierTime);
    Register(fPreAmplifierGain);
    Register(fFastShaperTime);
    Register(fFastShaperGain);
    Register(fDiscriminatorGain);;
    Register(fThreshold);
    Register(fDiscriminatorLowLevel);
    Register(fDiscriminatorHiLevel);
  }


  double
  ChannelSiPM::GetPreAmplifierTime()
    const
  {
    return GetData(fPreAmplifierTime, "preAmplifierTime");
  }


  double
  ChannelSiPM::GetPreAmplifierGain()
    const
  {
    return GetData(fPreAmplifierGain, "preAmplifierGain");
  }


  double
  ChannelSiPM::GetFastShaperTime()
    const
  {
    return GetData(fFastShaperTime, "fastShaperTime");
  }


  double
  ChannelSiPM::GetFastShaperGain()
    const
  {
    return GetData(fFastShaperGain, "fastShaperGain");
  }


  double
  ChannelSiPM::GetDiscriminatorThreshold()
    const
  {
    return GetData(fThreshold, "threshold");
  }


  double
  ChannelSiPM::GetDiscriminatorGain()
    const
  {
    return GetData(fThreshold, "discriminatorGain");
  }


  double
  ChannelSiPM::GetDiscriminatorLowLevel()
    const
  {
    return GetData(fDiscriminatorLowLevel, "discriminatorLowLevel");
  }


  double
  ChannelSiPM::GetDiscriminatorHiLevel()
    const
  {
    return GetData(fDiscriminatorHiLevel, "discriminatorHiLevel");
  }


  double
  ChannelSiPM::GetDiscriminatorTransitionTime()
    const
  {
    return GetData(fDiscriminatorTransitionTime, "discriminatorTransitionTime");
  }


  /*
   *********************************
   ***** Amplification stage. ******
   *********************************
   */

  std::complex<double>
  ChannelSiPM::ComputeTransfer(double freq)
    const
  {
    const double preAmpGain = GetPreAmplifierGain();
    const double preAmpTime = GetPreAmplifierTime();

    const double fsGain = GetFastShaperGain();
    const double fsTime = GetFastShaperTime();

    const std::complex<double> preAmp(
      preAmpGain / (1 + pow(freq * utl::kTwoPi * preAmpTime, 2)),
      -preAmpGain*(freq * utl::kTwoPi * preAmpTime) / (1 + pow(freq * utl::kTwoPi * preAmpTime, 2))
    );

    const std::complex<double> fs(
      -fsGain * pow(freq * utl::kTwoPi * fsTime, 2) * 2 / (pow(1 + pow(freq * utl::kTwoPi*fsTime, 2), 2)),
      -fsGain * (freq * utl::kTwoPi * fsTime) * (1 - pow(freq * utl::kTwoPi * fsTime, 2)) /
        (pow(1 + pow(freq * utl::kTwoPi * fsTime, 2), 2))
    );

    return preAmp * fs;
    //return totalTransfer;
  }


  /*
   *********************************
   ***** Discrimination stage. *****
   *********************************
   */
  double
  ChannelSiPM::ApplySaturation(double v)
    const
  {
    if (v > GetDiscriminatorHiLevel())
      return GetDiscriminatorHiLevel();
    if (v < GetDiscriminatorLowLevel())
      return  GetDiscriminatorLowLevel();
    return v;
  }


  double
  ChannelSiPM::ComputeDiscriminator(double signal, double deltaTime)
    const
  {
    double signalDiscriminator = GetDiscriminatorLowLevel();
    if (signal >= GetDiscriminatorThreshold()) {
      if (fTimeOverThreshold >= GetDiscriminatorTransitionTime()) {
        signalDiscriminator = GetDiscriminatorHiLevel();
      } else {
        fTimeOverThreshold += deltaTime;
      }
    } else {
      fTimeOverThreshold = 0;
    }
    return signalDiscriminator;
    /*Double_t signalDiscriminator = GetDiscriminatorGain()*(signal-GetDiscriminatorThreshold()); //mV
    return ApplySaturation(signalDiscriminator);*/
  }

}