SensorInfo.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 <vxd/geometry/SensorInfoBase.h>
 
#include <Math/Vector3D.h>
 
namespace Belle2 {
  namespace PXD {
    class SensorInfo: public VXD::SensorInfoBase {
    public:
      SensorInfo(VxdID id = 0, float width = 0, float length = 0, float thickness = 0, int uCells = 0, int vCells = 0,
                 float splitLength = 0, int vCells2 = 0):
        VXD::SensorInfoBase(SensorInfo::PXD, id, width, length, thickness, uCells, vCells, 0, splitLength, vCells2), m_temperature(300),
        m_bulkDoping(0), m_backVoltage(0), m_topVoltage(0), m_sourceBorderSmallPitch(0), m_clearBorderSmallPitch(0),
        m_drainBorderSmallPitch(0), m_sourceBorderLargePitch(0), m_clearBorderLargePitch(0), m_drainBorderLargePitch(0),
        m_gateDepth(0), m_doublePixel(true), m_chargeThreshold(0), m_noiseFraction(0), m_integrationStart(0), m_integrationEnd(0)
      {
        m_hallFactor = (1.13 + 0.0008 * (m_temperature - 273));
        cook();
      }

      void setID(VxdID id) { m_id = id; }

      void flipVSegmentation()
      {
        if (m_splitLength <= 0) return;
        std::swap(m_vCells, m_vCells2);
        std::swap(m_sourceBorderSmallPitch, m_sourceBorderLargePitch);
        std::swap(m_clearBorderSmallPitch, m_clearBorderLargePitch);
        std::swap(m_drainBorderSmallPitch, m_drainBorderLargePitch);
        m_splitLength = (1 - m_splitLength);
        cook();
      }

      void setDEPFETParams(double bulkDoping, double backVoltage, double topVoltage,
                           double sourceBorderSmallPitch, double clearBorderSmallPitch, double drainBorderSmallPitch,
                           double sourceBorderLargePitch, double clearBorderLargePitch, double drainBorderLargePitch,
                           double gateDepth, bool doublePixel, double chargeThreshold, double noiseFraction)
      {
        m_bulkDoping = bulkDoping;
        m_backVoltage = backVoltage;
        m_topVoltage = topVoltage;
        m_sourceBorderSmallPitch = sourceBorderSmallPitch;
        m_clearBorderSmallPitch = clearBorderSmallPitch;
        m_drainBorderSmallPitch = drainBorderSmallPitch;
        m_sourceBorderLargePitch = sourceBorderLargePitch;
        m_clearBorderLargePitch = clearBorderLargePitch;
        m_drainBorderLargePitch = drainBorderLargePitch;
        m_gateDepth = gateDepth;
        m_doublePixel = doublePixel;
        m_chargeThreshold = chargeThreshold;
        m_noiseFraction = noiseFraction;
        cook();
      }

      void cook();

      int getTrappedID(double x, double y) const;

      void setIntegrationWindow(double start, double end)
      {
        m_integrationStart = start;
        m_integrationEnd = end;
      }

      double getTemperature() const {return m_temperature;}
      double getBulkDoping() const { return m_bulkDoping; }
      double getBackVoltage() const { return m_backVoltage; }
      double getTopVoltage() const { return m_topVoltage; }
      double getSourceBorder(double v) const
      {
        if (v / m_length + 0.5 >= m_splitLength) return m_sourceBorderSmallPitch;
        return m_sourceBorderLargePitch;
      }

      double getClearBorder(double v) const
      {
        if (v / m_length + 0.5 >= m_splitLength) return m_clearBorderSmallPitch;
        return m_clearBorderLargePitch;
      }

      double getDrainBorder(double v) const
      {
        if (v / m_length + 0.5 >= m_splitLength) return m_drainBorderSmallPitch;
        return m_drainBorderLargePitch;
      }

      double getGateDepth() const { return m_gateDepth; }
      bool   getDoublePixel() const { return m_doublePixel; }
      double getChargeThreshold() const { return m_chargeThreshold; }
      double getNoiseFraction() const { return m_noiseFraction; }
      double getIntegrationStart() const { return m_integrationStart; }
      double getIntegrationEnd() const { return m_integrationEnd; }
      double getHallFactor() const { return m_hallFactor; }
      double getElectronMobility(double E) const;
      const ROOT::Math::XYZVector getEField(const ROOT::Math::XYZVector& point) const;
      const ROOT::Math::XYZVector getBField(const ROOT::Math::XYZVector& point) const;
      const ROOT::Math::XYZVector getLorentzShift(double u, double v) const;
      const ROOT::Math::XYZVector getDriftVelocity(const ROOT::Math::XYZVector& E, const ROOT::Math::XYZVector& B) const;
      int getPixelKind(const VxdID sensorID, double v) const;
      int getPixelKindNew(const VxdID& sensorID, int vID) const;
 
    protected:
      void setLorentzFactor();

      double m_temperature;
      double m_hallFactor;
      double m_bulkDoping;
      double m_backVoltage;
      double m_topVoltage;
      double m_sourceBorderSmallPitch;
      double m_clearBorderSmallPitch;
      double m_drainBorderSmallPitch;
      double m_sourceBorderLargePitch;
      double m_clearBorderLargePitch;
      double m_drainBorderLargePitch;
      double m_gateDepth;
      bool   m_doublePixel;
      double m_chargeThreshold;
      double m_noiseFraction;

      double m_integrationStart;
      double m_integrationEnd;
 
      double m_up; 
      double m_iup; 
 
      double m_vsplit; 
 
      double m_vp; 
      double m_ivp; 
 
      double m_vp2; 
      double m_ivp2; 
 
      double m_hxIG; 
      double m_mIGL; 
      double m_sIGL; 
      double m_mIGS; 
      double m_sIGS; 
    };
 
  }
} //Belle2 namespace