ScintillatorSimulator.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
/* KLM headers. */
#include <klm/dataobjects/KLMElementNumberDefinitions.h>
#include <klm/dataobjects/KLMSimHit.h>
#include <klm/dbobjects/KLMScintillatorDigitizationParameters.h>
#include <klm/dbobjects/KLMScintillatorFEEData.h>
#include <klm/simulation/ScintillatorFirmware.h>
#include <klm/time/KLMTime.h>
 
namespace Belle2 {
  namespace KLM {
 
    class ScintillatorSimulator {
 
    public:
 
      struct Photoelectron {
        int bin;          
        double expTime;   
        bool isReflected; 
      };
 
      ScintillatorSimulator(const KLMScintillatorDigitizationParameters* digPar,
                            ScintillatorFirmware* fitter,
                            double digitizationInitialTime,
                            bool debug);
 
      ScintillatorSimulator(const ScintillatorSimulator&) = delete;
 
      ScintillatorSimulator& operator=(const ScintillatorSimulator&) = delete;
 
      ~ScintillatorSimulator();
 
      void simulate(
        const std::multimap<KLMChannelNumber, const KLMSimHit*>::iterator& firstHit,
        const std::multimap<KLMChannelNumber, const KLMSimHit*>::iterator& end);
 
      KLMScintillatorFirmwareFitResult* getFPGAFit();
 
      enum ScintillatorFirmwareFitStatus getFitStatus() const;
 
      double getNPhotoelectrons();
 
      int getNGeneratedPhotoelectrons();
 
      double getEnergy();
 
      void setFEEData(const KLMScintillatorFEEData* FEEData);
 
      void generatePhotoelectrons(double stripLen, double distSiPM,
                                  int nPhotons, double timeShift,
                                  bool isReflected);
 
      void fillSiPMOutput(float* hist, bool useDirect, bool useReflected);
 
      float getMCTime() const
      {
        return m_MCTime;
      }
 
      float getSiPMMCTime() const
      {
        return m_SiPMMCTime;
      }
 
    private:
 
      void reallocPhotoElectronBuffers(int size);
 
      void prepareSimulation();
 
      void performSimulation();
 
      int* sortPhotoelectrons(int nPhotoelectrons);
 
      void addRandomSiPMNoise();
 
      void simulateADC();
 
      void debugOutput();
 
      const KLMTime* m_Time;
 
      const KLMScintillatorDigitizationParameters* m_DigPar;
 
      ScintillatorFirmware* m_fitter;
 
      double m_DigitizationInitialTime;
 
      bool m_Debug;
 
      double m_histRange;
 
      float* m_amplitudeDirect;
 
      float* m_amplitudeReflected;
 
      float* m_amplitude;
 
      int* m_ADCAmplitude;
 
      double* m_SignalTimeDependence;
 
      double* m_SignalTimeDependenceDiff;
 
      struct Photoelectron* m_Photoelectrons;
 
      int* m_PhotoelectronIndex;
 
      int* m_PhotoelectronIndex2;
 
      int m_PhotoelectronBufferSize;
 
      enum ScintillatorFirmwareFitStatus m_FPGAStat;
 
      KLMScintillatorFirmwareFitResult m_FPGAFit;
 
      int m_npe;
 
      double m_Energy;
 
      std::string m_stripName;
 
      double m_Pedestal;
 
      double m_PhotoelectronAmplitude;
 
      int m_Threshold;
 
      float m_MCTime;
 
      float m_SiPMMCTime;
 
    };
 
  }
 
}