PXDUtilities.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/gearbox/Unit.h>
#include <framework/gearbox/Const.h>
#include <framework/utilities/MathHelpers.h>
#include <tracking/dataobjects/RecoTrack.h>
#include <genfit/MeasuredStateOnPlane.h>
//#include <limits>
#include <math.h>
 
namespace Belle2 {
 
  namespace PXD {

    const int Z_Si = 14; 
    const double A_Si = 28.085; 
    const double rho_Si = 2.3290 * Unit::g_cm3; 

    inline double xiBeta2_L(const int Z = Z_Si,
                            const double A = A_Si,
                            const double rho = rho_Si,
                            const int z = 1)
    {
      const double K = 0.307075 * Unit::MeV * square(Unit::cm);
      return K / 2 * Z / A * z * z * rho;
    }

    inline double hbarWp(const int Z = Z_Si,
                         const double A = A_Si,
                         const double rho = rho_Si)
    {
      return std::sqrt(rho * Z / A) * 28.816 * Unit::eV;
    }

    inline double getDeltaP(const double mom, const double length, const double mass = Const::electronMass)
    {
      double betaGamma = mom / mass;
      if (betaGamma <= 100) return 0.0; // requirement of the formula.
      double beta2 = 1. / (1. + 1. / betaGamma / betaGamma);
      double xi = xiBeta2_L() * length / beta2;
      return xi * log(2 * mass * xi / square(hbarWp()) + 0.2);
    }

    inline unsigned short getPXDModuleID(const VxdID& sensorID)
    {
      return sensorID.getLayerNumber() * 1000 +
             sensorID.getLadderNumber() * 10 +
             sensorID.getSensorNumber();
    }

    inline VxdID getVxdIDFromPXDModuleID(const unsigned short& id)
    {
      return VxdID(id / 1000, (id % 1000) / 10, id % 10);
    }

    typedef genfit::MeasuredStateOnPlane TrackState;

    std::shared_ptr<TrackState> getTrackStateOnModule(const VXD::SensorInfoBase& pxdSensorInfo,
                                                      RecoTrack& recoTrack, double lambda = 0.0);

    bool isCloseToBorder(int u, int v, int checkDistance);
    bool isDefectivePixelClose(int u, int v, int checkDistance, const VxdID& moduleID);

    inline bool isClusterAtUEdge(VxdID id, unsigned int umin, unsigned int umax)
    {
      unsigned int uedgemax = Belle2::VXD::GeoCache::getInstance().getSensorInfo(id).getUCells();
      return (umin == 0 || umax == (uedgemax - 1));
    }

    inline bool isClusterAtVEdge(VxdID id, unsigned int vmin, unsigned int vmax)
    {
      unsigned int vedgemax = Belle2::VXD::GeoCache::getInstance().getSensorInfo(id).getVCells();
      return ((id.getSensorNumber() == 1 && vmax == (vedgemax - 1))
              || (id.getSensorNumber() == 2 && vmin == 0));
    }

    inline bool isClusterAtLadderJoint(VxdID id, unsigned int vmin, unsigned int vmax)
    {
      unsigned int vedgemax = Belle2::VXD::GeoCache::getInstance().getSensorInfo(id).getVCells();
      return ((id.getSensorNumber() == 2 && vmax == (vedgemax - 1))
              || (id.getSensorNumber() == 1 && vmin == 0));
    }

    inline unsigned short getBinU(VxdID id, unsigned int uid, unsigned int vid, unsigned short nBinsU)
    {
      unsigned int drainsPerBin = 4 * Belle2::VXD::GeoCache::getInstance().getSensorInfo(id).getUCells() / nBinsU;
      return (uid * 4 + vid % 4) / drainsPerBin;
    }

    inline unsigned short getBinV(VxdID id, unsigned int vid, unsigned short nBinsV)
    {
      unsigned int rowsPerBin = Belle2::VXD::GeoCache::getInstance().getSensorInfo(id).getVCells() / nBinsV;
      return vid / rowsPerBin;
    }
 
  } // end namespace PXD
} // end namespace Belle2