ChannelSiPM.h

Go to the documentation of this file.

#ifndef _mdet_ChannelSiPM_h
#define _mdet_ChannelSiPM_h

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

namespace det {
  struct ParentCreator;
  struct ComponentUpdater;
}

namespace mdet {

  class FrontEndSiPM;

  class ChannelSiPM : public MDetectorComponent<ChannelSiPM>::Type {
  public:

    static const char* const kComponentName;

    static const char* const kComponentId;
    const FrontEndSiPM& GetFrontEnd() const {
      return fFrontEnd;
    }
    double GetThreshold() const;
    std::complex<double> ComputeTransfer(double freq) const;

    double ComputeDiscriminator(double signal, double deltaTime) const;

  private:
    /*
     * Properties that characterise the amplification
     * stage (with its frequency response). The
     * idea is that client code doesn't access
     * to this properties.
     * Instead the client code would provide a signal
     * and in this class (through this, or any other
     * mean) would give the output-response to that
     * given signal by the ChannelSiPM.
     */  
    double GetPreAmplifierTime() const;
    double GetPreAmplifierGain() const;
    const char* GetPreAmplifierFunctionReal() const;

    const char* GetPreAmplifierFunctionIm() const;
    double GetFastShaperTime() const;
    double GetFastShaperGain() const;
    const char* GetFastShaperFunctionReal() const;

    const char* GetFastShaperFunctionIm() const;
    /*
     * Propeties that characterize the discrimination stage.
     * The output signal of the discriminator is ideally a 
     * two valued continuous wave. This two values are set
     * according to the comparisson with the threshold, 
     * the hi value level meaning that the signal was
     * greater than the threshold and viceversa.
     * In reality, the signal has a finite transition time
     * between states, and finite stabilization times.
     */
    double GetDiscriminatorLowLevel() const;
    double GetDiscriminatorHiLevel() const;
    double GetDiscriminatorTransitionTime() const;
    double GetDiscriminatorGain() const;
    double GetDiscriminatorThreshold() const;
    double ApplySaturation(double v) const;


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

    mutable utl::Validated<double> fPreAmplifierTime;

    mutable utl::Validated<double> fPreAmplifierGain;

    mutable utl::Validated<double> fFastShaperTime;

    mutable utl::Validated<double> fFastShaperGain;

    mutable utl::Validated<double> fDiscriminatorGain;

   // mutable utl::Validated<double> fDiscriminatorDACThresholdStep;


    mutable utl::Validated<double> fThreshold;

    mutable utl::Validated<double> fDiscriminatorLowLevel;

    mutable utl::Validated<double> fDiscriminatorHiLevel;

    mutable utl::Validated<double> fDiscriminatorTransitionTime;

    mutable double fTimeOverThreshold;

    const FrontEndSiPM& fFrontEnd;

  };

}

#endif // _mdet_ChannelSiPM_h