TimeDigitizer.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
 
#include <top/dataobjects/TOPSimHit.h>
#include <top/dataobjects/TOPDigit.h>
#include <top/dataobjects/TOPRawDigit.h>
#include <top/dataobjects/TOPRawWaveform.h>
#include <framework/datastore/StoreArray.h>
#include <top/dbobjects/TOPSampleTimes.h>
#include <top/dbobjects/TOPSignalShape.h>
#include <top/dbobjects/TOPCalTimeWalk.h>
#include <framework/database/DBObjPtr.h>
 
#include <map>
#include <vector>
 
namespace Belle2 {
  namespace TOP {
    class TimeDigitizer {
 
    public:
 
      enum EType {
        c_Hit = 0,
        c_ChargeShare = 1,
        c_CrossTalk = 2,
        c_CalPulse = 3
      };
 
      struct Hit {
        double pulseHeight = 0; 
        EType type = c_Hit;     
        const TOPSimHit* simHit = 0;  
        const TOPSignalShape* shape = 0; 
      };
 
      TimeDigitizer(int moduleID, int pixelID, double timeOffset, double calErrorsSq,
                    int shift, double rmsNoise, const TOPSampleTimes& sampleTimes);
 
      static void setStorageDepth(unsigned storageDepth) {s_storageDepth = storageDepth;}
 
      static void setReadoutWindows(unsigned numWin) {s_readoutWindows = numWin;}
 
      static void setOffsetWindows(int offsetWin) {s_offsetWindows = offsetWin;}
 
      static void setFirstWindow(unsigned window) {s_window = window;}
 
      static void maskSamples(bool maskThem) {s_maskSamples = maskThem;}
 
      static void setTimeWalk(DBObjPtr<TOPCalTimeWalk>* timeWalk) {s_timeWalk = timeWalk;}
 
      void setSampleTimes(const TOPSampleTimes* sampleTimes)
      {
        if (sampleTimes) {
          m_sampleTimes = sampleTimes;
        } else {
          B2ERROR("TOP::TimeDigitizer::setSampleTimes: argument is NULL pointer");
        }
      }
 
      void setNoise(double rmsNoise) {m_rmsNoise = rmsNoise;}
 
      void addTimeOfHit(double t, double pulseHeight, EType type,
                        const TOPSimHit* simHit = 0);
 
      int getModuleID() const { return m_moduleID; }
 
      int getPixelID() const { return m_pixelID; }
 
      unsigned getUniqueID() const {return m_pixelID + (m_moduleID << 16);}
 
      unsigned getASICWindow() const {return s_window;}
 
      unsigned int getChannel() const { return m_channel; }
 
      unsigned getScrodID() const {return m_scrodID;}
 
      unsigned getCarrierNumber() const {return m_carrier;}
 
      unsigned getASICNumber() const {return m_asic;}
 
      unsigned getASICChannel() const {return m_chan;}
 
      bool isValid() const {return m_valid;}
 
      void digitize(StoreArray<TOPRawDigit>& rawDigits,
                    StoreArray<TOPDigit>& digits,
                    int threshold = 0,
                    int thresholdCount = 0,
                    double timeJitter = 0) const;
 
      void digitize(StoreArray<TOPRawWaveform>& waveforms,
                    StoreArray<TOPRawDigit>& rawDigits,
                    StoreArray<TOPDigit>& digits,
                    int threshold,
                    int hysteresis = 0,
                    int thresholdCount = 0) const;
 
    private:
 
      double gauss(double x, double mean, double sigma) const
      {
        double xx = (x - mean) / sigma;
        return exp(-0.5 * xx * xx);
      }
 
      std::vector<short> generateWaveform(int startSample,
                                          const std::vector<double>& baselines,
                                          const std::vector<double>& rmsNoises,
                                          const std::vector<double>& pedestals,
                                          int ADCRange) const;
 
      double generateTimeWalk(double hitTime, double peakTime) const;
 
      static unsigned s_storageDepth;  
      static unsigned s_readoutWindows;   
      static int s_offsetWindows;    
      static unsigned s_window;      
      static bool s_maskSamples;     
      static DBObjPtr<TOPCalTimeWalk>* s_timeWalk; 
      int m_moduleID = 0;     
      int m_pixelID = 0;      
      double m_timeOffset = 0; 
      double m_calErrorsSq = 0; 
      double m_rmsNoise = 0;  
      const TOPSampleTimes* m_sampleTimes = 0; 
      int m_windowShift = 0; 
      unsigned m_channel = 0; 
      unsigned m_scrodID = 0; 
      unsigned m_carrier = 0; 
      unsigned m_asic = 0;    
      unsigned m_chan = 0;    
      bool m_valid = false;   
      std::multimap<double, const Hit> m_times; 
    };
 
  } // TOP namespace
} // Belle2 namespace