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.                  *
 **************************************************************************/
 
#ifndef SVD_SENSORINFO_H
#define SVD_SENSORINFO_H
 
#include <vxd/geometry/SensorInfoBase.h>
#include <Math/Vector3D.h>
 
namespace Belle2 {
  namespace SVD {
    class SensorInfo: public VXD::SensorInfoBase {
    public:
      const double c_fanoFactorSi = 0.08;
 
      enum Coordinate {
        u = 1,
        v = 0
      };
      enum CarrierType {
        electron = -1, 
        hole = +1      
      };
 
      SensorInfo(VxdID id = 0, float width = 0, float length = 0, float thickness = 0,
                 int uCells = 0, int vCells = 0, float width2 = 0):
        VXD::SensorInfoBase(SensorInfo::SVD, id, width, length, thickness, uCells, vCells, width2, -1, 0),
        m_temperature(300), m_stripEdgeU(0), m_stripEdgeV(0),
        m_depletionVoltage(0), m_biasVoltage(0),
        m_backplaneCapacitanceU(0), m_interstripCapacitanceU(0),
        m_couplingCapacitanceU(0), m_backplaneCapacitanceV(0),
        m_interstripCapacitanceV(0), m_couplingCapacitanceV(0),
        m_aduEquivalentU(375), m_aduEquivalentV(375),
        m_electronicNoiseU(0), m_electronicNoiseV(0),
        m_aduEquivalentSbwU(375), m_aduEquivalentSbwV(375),
        m_electronicNoiseSbwU(0), m_electronicNoiseSbwV(0),
        m_isBackward(false)
      {
        setIsBackward(id);
      }
 
      void setIsBackward(VxdID id)
      {
        static const unsigned short layerSensors[] = {0, 0, 0, 2, 3, 4, 5};
        m_isBackward =
          (id.getLayerNumber() > 3)
          && (id.getSensorNumber() == layerSensors[id.getLayerNumber()]);
      }
 
      void setID(VxdID id)
      {
        m_id = id;
        setIsBackward(id);
      }
 
      void setSensorParams(double stripEdgeU, double stripEdgeV,
                           double depletionVoltage, double biasVoltage,
                           double backplaneCapacitanceU,
                           double interstripCapacitanceU,
                           double couplingCapacitanceU,
                           double backplaneCapacitanceV,
                           double interstripCapacitanceV,
                           double couplingCapacitanceV,
                           double AduEquivalentU,
                           double AduEquivalentV,
                           double electronicNoiseU,
                           double electronicNoiseV,
                           double AduEquivalentSbwU,
                           double AduEquivalentSbwV,
                           double electronicNoiseSbwU,
                           double electronicNoiseSbwV)
      {
        m_stripEdgeU = stripEdgeU,
        m_stripEdgeV = stripEdgeV,
        m_depletionVoltage = depletionVoltage;
        m_biasVoltage = biasVoltage;
        m_backplaneCapacitanceU = backplaneCapacitanceU;
        m_interstripCapacitanceU = interstripCapacitanceU;
        m_couplingCapacitanceU = couplingCapacitanceU;
        m_backplaneCapacitanceV = backplaneCapacitanceV;
        m_interstripCapacitanceV = interstripCapacitanceV;
        m_couplingCapacitanceV = couplingCapacitanceV;
        m_aduEquivalentU = AduEquivalentU;
        m_aduEquivalentV = AduEquivalentV;
        m_electronicNoiseU = electronicNoiseU;
        m_electronicNoiseV = electronicNoiseV;
        m_aduEquivalentSbwU = AduEquivalentSbwU;
        m_aduEquivalentSbwV = AduEquivalentSbwV;
        m_electronicNoiseSbwU = electronicNoiseSbwU;
        m_electronicNoiseSbwV = electronicNoiseSbwV;
      }
 
      double getTemperature() const {return m_temperature; }
      double getStripLengthU(int uID = 0) const;
      double getStripLengthV(int vID = 0) const;
      double getDepletionVoltage() const { return m_depletionVoltage; }
      double getBiasVoltage() const { return m_biasVoltage; }
      double getBackplaneCapacitanceU(int uID = 0) const;
      double getInterstripCapacitanceU(int uID = 0) const;
      double getCouplingCapacitanceU(int uID = 0) const;
      double getBackplaneCapacitanceV(int vID = 0) const;
      double getInterstripCapacitanceV(int vID = 0) const;
      double getCouplingCapacitanceV(int vID = 0) const;
      double getAduEquivalentU() const;
      double getAduEquivalentV() const;
      double getElectronicNoiseU() const;
      double getElectronicNoiseV() const;
      double getElectronMobility(double E) const;
      double getHoleMobility(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;
 
      double getHallFactor(CarrierType carrier) const
      {
        if (carrier == electron)
          return (1.13 + 0.0008 * (m_temperature - 273));
        else
          return (0.72 - 0.0005 * (m_temperature - 273));
      }
 
      const ROOT::Math::XYZVector getVelocity(CarrierType carrier, const ROOT::Math::XYZVector& point) const;
 
      const ROOT::Math::XYZVector& getLorentzShift(double uCoord, double vCoord) const;
 
      double getLorentzShift(bool isUCoordinate, double position) const;
 
    protected:
      double m_temperature;
      double m_stripEdgeU;
      double m_stripEdgeV;
      double m_depletionVoltage;
      double m_biasVoltage;
      double m_backplaneCapacitanceU;
      double m_interstripCapacitanceU;
      double m_couplingCapacitanceU;
      double m_backplaneCapacitanceV;
      double m_interstripCapacitanceV;
      double m_couplingCapacitanceV;
      double m_aduEquivalentU;
      double m_aduEquivalentV;
      double m_electronicNoiseU;
      double m_electronicNoiseV;
      double m_aduEquivalentSbwU;
      double m_aduEquivalentSbwV;
      double m_electronicNoiseSbwU;
      double m_electronicNoiseSbwV;
      bool m_isBackward;
    }; // Class SVD::SensorInfo
 
    inline double SensorInfo::getStripLengthU(int uID) const
    {
      // if this is a rectangular sensor, just return the default
      if (m_deltaWidth == 0.0)
        return (m_length - 2.0 * m_stripEdgeU);
      else {
        // calculate for a wedge sensor
        double dw = (1.0 * uID / m_uCells - 0.5) * m_deltaWidth;
        return (sqrt(dw * dw + m_length * m_length) - 2.0 * m_stripEdgeU);
      }
    }
 
    inline double SensorInfo::getStripLengthV(int vID) const
    {
      return (getWidth(getVCellPosition(vID)) - 2.0 * m_stripEdgeV);
    }
 
    inline double SensorInfo::getBackplaneCapacitanceU(int uID) const
    {
      return (m_backplaneCapacitanceU * getStripLengthU(uID));
    }
 
    inline double SensorInfo::getInterstripCapacitanceU(int uID) const
    {
      return (m_interstripCapacitanceU * getStripLengthU(uID));
    }
 
    inline double SensorInfo::getCouplingCapacitanceU(int uID) const
    {
      return (m_couplingCapacitanceU * getStripLengthU(uID));
    }
 
    inline double SensorInfo::getBackplaneCapacitanceV(int vID) const
    {
      return (m_backplaneCapacitanceV * getStripLengthV(vID));
    }
 
    inline double SensorInfo::getInterstripCapacitanceV(int vID) const
    {
      return (m_interstripCapacitanceV * getStripLengthV(vID));
    }
 
    inline double SensorInfo::getCouplingCapacitanceV(int vID) const
    {
      return (m_couplingCapacitanceV * getStripLengthV(vID));
    }
 
    inline double SensorInfo::getAduEquivalentU() const
    {
      if (m_isBackward)
        return m_aduEquivalentSbwU;
      else
        return m_aduEquivalentU;
    }
 
    inline double SensorInfo::getAduEquivalentV() const
    {
      if (m_isBackward)
        return m_aduEquivalentSbwU;
      else
        return m_aduEquivalentV;
    }
 
    inline double SensorInfo::getElectronicNoiseU() const
    {
      if (m_isBackward)
        return m_electronicNoiseSbwU;
      else
        return m_electronicNoiseU;
    }
 
    inline double SensorInfo::getElectronicNoiseV() const
    {
      if (m_isBackward)
        return m_electronicNoiseSbwV;
      else
        return m_electronicNoiseV;
    }
 
 
  } // SVD namespace
} //Belle2 namespace
#endif