PXDDigitizerModule.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 <framework/core/Module.h>
#include <pxd/dataobjects/PXDSimHit.h>
#include <pxd/dataobjects/PXDInjectionBGTiming.h>
#include <pxd/geometry/SensorInfo.h>
#include <framework/dataobjects/RelationElement.h>
#include <framework/datastore/StoreObjPtr.h>
#include <string>
#include <vector>
 
namespace Belle2 {
  namespace PXD {
 
    class Digit {
    public:
      Digit(unsigned short u = 0, unsigned short v = 0): m_u(u), m_v(v) {}
      bool operator<(const Digit& b)  const { return v() < b.v() || (v() == b.v() && u() < b.u()); }
      bool operator==(const Digit& b) const { return v() == b.v() && u() == b.u(); }
      unsigned short u() const { return m_u; }
      unsigned short v() const { return m_v; }
    protected:
      unsigned short m_u;
      unsigned short m_v;
    };
 
    class DigitValue {
    public:
      typedef std::map<RelationElement::index_type, RelationElement::weight_type> relations_map;
      DigitValue(): m_charge(0) {}
      void add(double charge, int particle = -1, int truehit = -1)
      {
        if (particle >= 0) m_particles[particle] += charge;
        if (truehit >= 0) m_truehits[truehit] += charge;
        m_charge += charge;
      }
      double charge() const { return m_charge; }
      const relations_map& particles() const { return m_particles; }
      const relations_map& truehits() const { return m_truehits; }
    protected:
      double m_charge;
      relations_map m_particles;
      relations_map m_truehits;
    };
 
    typedef std::map<Digit, DigitValue> Sensor;
    typedef std::map<VxdID, Sensor> Sensors;
 
 
    class PXDDigitizerModule : public Module {
    public:
      PXDDigitizerModule();
 
      void processHit();
      void driftCharge(const ROOT::Math::XYZVector& position, double electrons);
      void addNoiseDigits();
      double addNoise(double charge);
      void saveDigits();
      bool checkIfGated(int gate);
 
 
      void initialize() override final;
      void beginRun() override final;
      void event() override final;
 
    protected:
      bool   m_applyNoise;
      double m_elNoise;
      double m_noiseFraction;
 
      std::string m_storeMCParticlesName;
      std::string m_storeDigitsName;
      std::string m_storeSimHitsName;
      std::string m_storeTrueHitsName;
      std::string m_relMCParticleSimHitName;
      std::string m_relDigitMCParticleName;
      std::string m_relTrueHitSimHitName;
      std::string m_relDigitTrueHitName;
 
 
      bool   m_applyPoisson;
      bool   m_applyWindow;
 
      bool m_gatingWithoutReadout;
      double m_gatingWithoutReadoutTime;
      double m_gatingTime;
      double m_hwdelay;
 
      double m_segmentLength;
      int    m_elGroupSize;
      double m_elStepTime;
      int    m_elMaxSteps;
      double m_eToADU;
      double m_gq;
      double m_ADCUnit;
      double m_chargeThreshold;
      double m_chargeThresholdElectrons;
      double m_pedestalMean;
      double m_pedestalRMS;
      Sensors m_sensors;
 
      const PXDSimHit*   m_currentHit;
      int                m_currentParticle;
      int                m_currentTrueHit;
      Sensor*            m_currentSensor;
      const SensorInfo*  m_currentSensorInfo;
      ROOT::Math::XYZVector m_currentBField;
 
      int m_nGates;
      double m_pxdIntegrationTime;
      double m_timePerGate;
      int m_triggerGate;
      bool m_gated;
      std::vector<float> m_gatingStartTimes;
      std::vector<std::pair<int, int> > m_gatedChannelIntervals;
 
    private:
      StoreObjPtr<PXDInjectionBGTiming> m_storePXDTiming;
 
    };//end class declaration
 
 
  } // end namespace PXD
} // end namespace Belle2