MDetector/Pixel.h

Go to the documentation of this file.

#ifndef _mdet_Pixel_h
#define _mdet_Pixel_h

#include <mdet/MDetectorComponent.h>
#include <mdet/PMT_helper.h>
//
#include <utl/ShadowPtr.h>
#include <utl/Validated.h>
#include <utl/Math.h>
#include <utl/MathConstants.h>
#include <utl/ConsecutiveEnumFactory.h>
//
#include <complex>
#include <cmath>


namespace det {
  struct ParentCreator;
  struct ComponentUpdater; // Actually not needed because PMT.h -> MComponentGroup.h -> ComponentGroup.h
}


namespace mdet {

  typedef std::vector<int> IdsContainer;


  class PMT;


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

  public:
    static const char* const kComponentName;

    static const char* const kComponentId;

    const PMT& GetPMT() const { return fPMT; }

    class SPE {
    public:
      double
      TimeSpaceEvaluate(double t)
        const
      {
        /*
         * Note that the standard function should not receive
         * Auger-units dependant magnitudes: by dividing
         * with sigma we independized x from Auger-units.
         */
        const double x = (t - fMu) / fSigma;
        return kOverallSign * fAmplitude * std::exp(-0.5 * utl::Sqr(x));
      }

      std::complex<double>
      FrequencySpaceEvaluate(const double f)
        const
      {
        double rp = -1 * utl::Sqr(fMu) / (2 * utl::Sqr(fSigma));
        rp += utl::Sqr(fSigma) / 2 * ( utl::Sqr(fMu) / (utl::Sqr(fSigma) * utl::Sqr(fSigma)) - utl::Sqr(f) );
        const double ip = -1 * fMu * f;
        const std::complex<double> e(rp, ip);
        return kOverallSign * fAmplitude * std::sqrt(2 * utl::kPi) * fSigma * std::exp(e);
      }

      double UpperLimit() const { return fMu + fPixel.GetPulseRelevantWidth() * fSigma; }

      double LowerLimit() const { return fMu - fPixel.GetPulseRelevantWidth() * fSigma; }

      double GetAmplitude() const { return fAmplitude; }

      double GetMu() const { return fMu; }

      double GetSigma() const { return fSigma; }

    private:
      static const int kOverallSign = -1;

      SPE(const Pixel& p, const double a, const double m, const double s)
        : fPixel(p), fAmplitude(a), fMu(m), fSigma(s) { }

      const Pixel& fPixel;
      double fAmplitude = 0;
      double fMu = 0;
      double fSigma = 0;

      // Allow construction.
      friend class Pixel;
    };

    SPE MakeSPEAt(const double t) const;

  private:
    void Update(const bool invalidateData, const bool invalidateComponents);

    enum PulseParametrization {
      eAmplitudeAndCharge,            
      eAmplitudeAndStandardDeviation, 
      eChargeAndStandardDeviation     
    };

    static const char * const PulseParametrizationTags[];

    // See the following friendship: repeats class name.
    typedef
      utl::ConsecutiveEnumFactory<
        PulseParametrization,
        eChargeAndStandardDeviation,
        PulseParametrizationTags
      > PulseParametrizationCreator;

    /*
     * It isn't possible to define friendship through a typedef: so we need a little verbosity here.
     * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf
     */
    // See the previous typedef: repeats class name.
    friend class utl::ConsecutiveEnumFactory<PulseParametrization, eChargeAndStandardDeviation, PulseParametrizationTags>;

    PulseParametrization GetPulseParametrization() const;

    double GetPulseAmplitudeMean() const;

    double GetPulseAmplitudeStdDev() const;

    double GetPulseStdDevMean() const;

    double GetPulseStdDevStdDev() const;

    double GetPulseChargeMean() const;

    double GetPulseChargeStdDev() const;

    double GetPulseParametersCorrelation() const;

    double GetPulseRelevantWidth() const;

    Pixel(const int pId, const det::VManager::IndexMap& parentMap, const PMT& parent);

    ~Pixel() { }

    const CrossTalkContainer& GetNeighborsCrossTalkInside() const;

    const CrossTalkContainer& GetNeighborsCrossTalkSide() const;

    const CrossTalkContainer& GetNeighborsCrossTalkCorner() const;

    const IdsContainer& GetChannelScintillatorFiberIds() const;

    friend struct det::ParentCreator;

    template<class T>
    friend void boost::checked_delete(T*) BOOST_NOEXCEPT;

    friend class PMT;

    friend class Module;

    friend struct det::ComponentUpdater;

    NeighborsContainer fNeighbors;

    mutable utl::ShadowPtr<CrossTalkContainer> fNeighborsCrossTalk;

    mutable utl::Validated<double> fCrossTalkNormalizationFactor;

    typedef std::string PulseParametrizationForConfig;

    mutable utl::Validated<PulseParametrizationForConfig> fPulseParametrization;

    mutable utl::ShadowPtr<IdsContainer> fChannelScintillatorFiberIds;

    mutable utl::Validated<double> fPulseAmplitudeMean;

    mutable utl::Validated<double> fPulseAmplitudeStdDev;

    mutable utl::Validated<double> fPulseStdDevMean;

    mutable utl::Validated<double> fPulseStdDevStdDev;

    mutable utl::Validated<double> fPulseChargeMean;

    mutable utl::Validated<double> fPulseChargeStdDev;

    mutable utl::Validated<double> fPulseParametersCorrelation;

    mutable utl::Validated<double> fPulseRelevantWidth;

    const PMT& fPMT;

  };

}


#endif