SpacePoint.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/geometry/B2Vector3.h>
#include <framework/datastore/RelationsObject.h>
#include <framework/logging/Logger.h>
 
#include <vxd/geometry/GeoCache.h>
#include <vxd/geometry/SensorInfoBase.h>
 
#include <pxd/dataobjects/PXDCluster.h>
 
#include <svd/dataobjects/SVDCluster.h>
 
#include <genfit/PlanarMeasurement.h>
 
#include <vector>
#include <string>
#include <utility> // std::pair
 
namespace Belle2 {
  class SpacePoint: public RelationsObject {
 
  public:
    //--- C'tors and D'tors -------------------------------------------------------------------------------------------
    explicit SpacePoint(const PXDCluster* pxdCluster,
                        const VXD::SensorInfoBase* aSensorInfo = nullptr);
 
    explicit SpacePoint(std::vector<SVDCluster const*>& clusters,
                        VXD::SensorInfoBase const* aSensorInfo = nullptr);
 
    SpacePoint() :
      m_positionError(1., 1., 1.), //TODO: Describe Design Decision for not using the default (0.,0.,0.)
      m_UClusterTime(0.), m_VClusterTime(0.),
      m_vxdID(0), m_sensorType(VXD::SensorInfoBase::SensorType::VXD) // type is set to generic VXD
    {}
 
    SpacePoint(const B2Vector3<double>& pos, const B2Vector3<double>& posError, std::pair<double, double> normalizedLocal,
               std::pair<bool, bool> clustersAssigned, VxdID sensorID, Belle2::VXD::SensorInfoBase::SensorType detID,
               double UClusterTime = 0., double VClusterTime = 0.) :
      m_position(pos), m_positionError(posError),
      m_normalizedLocal(normalizedLocal),
      m_UClusterTime(UClusterTime), m_VClusterTime(VClusterTime),
      m_clustersAssigned(clustersAssigned),
      m_vxdID(sensorID), m_sensorType(detID)
    {}
 
    virtual ~SpacePoint() {}
    //-----------------------------------------------------------------------------------------------------------------
 
    friend std::ostream& operator<< (std::ostream& out, const SpacePoint& aSP) { return out << aSP.getName();}
 
    bool operator == (const SpacePoint& b) const
    {
      return getArrayIndex() == b.getArrayIndex();
    }
 
    bool operator != (const SpacePoint& b) const
    {
      return !(*this == b);
    }
 
    std::string getName() const override
    {
      return "SpacePoint with index: " + std::to_string(getArrayIndex()) +
             "and VxdID: " + std::to_string(VxdID(m_vxdID));
    }
 
    //--- Global Coordinate Getters -----------------------------------------------------------------------------------
    double X() const { return m_position.X(); }
 
    double Y() const { return m_position.Y(); }
 
    double Z() const { return m_position.Z(); }
 
    double TimeU() const { return m_UClusterTime; }
 
    double TimeV() const { return m_VClusterTime; }
 
    const B2Vector3<double>& getPosition() const { return m_position; }
 
    const B2Vector3<double>& getPositionError() const { return m_positionError; }
 
    //---- Sensor Level Information Getters ---------------------------------------------------------------------------
    Belle2::VXD::SensorInfoBase::SensorType getType() const { return m_sensorType; }
 
    VxdID getVxdID() const { return m_vxdID; }
 
    double getNormalizedLocalU() const { return m_normalizedLocal.first; }
 
    double getNormalizedLocalV() const { return m_normalizedLocal.second; }
    //-----------------------------------------------------------------------------------------------------------------
 
    std::pair<bool, bool> getIfClustersAssigned() const { return m_clustersAssigned; }
 
    unsigned short getNClustersAssigned() const
    {
      if (m_sensorType == VXD::SensorInfoBase::SensorType::SVD &&
          m_clustersAssigned.first && m_clustersAssigned.second) {
        return 2;
      }
      return 1;
    }
 
    void setAssignmentState(bool isAssigned) const { m_isAssigned = isAssigned; }
 
    bool isUOnly() const { return m_clustersAssigned.first and not m_clustersAssigned.second; }
    bool isVOnly() const { return not m_clustersAssigned.first and m_clustersAssigned.second; }
    bool isUAndV() const { return m_clustersAssigned.first and m_clustersAssigned.second; }
 
    bool getAssignmentState() const { return m_isAssigned; }
 
    void setQualityEstimation(float qualityIndicator) {m_qualityIndicator = qualityIndicator; }
 
    float getQualityEstimation() const { return m_qualityIndicator; }
 
    void setQualityEstimationError(double qualityIndicatorError) {m_qualityIndicatorError = qualityIndicatorError;}
 
    float getQualityEstimationError() const {return m_qualityIndicatorError;}
 
 
//---------------------------------------------------------------------------------------------------------------------
//TODO: Some clarification, if the following conversions and especially the staticness of the functions below is needed
//in the version 2 of the VXDTF.
    virtual std::vector<genfit::PlanarMeasurement> getGenfitCompatible() const ;
 
 
// static converter functions:
 
    static B2Vector3<double> getGlobalCoordinates(const std::pair<double, double>& hitLocal, VxdID vxdID,
                                                  const VXD::SensorInfoBase* aSensorInfo = nullptr);
 
 
    static std::pair<double, double> convertLocalToNormalizedCoordinates(const std::pair<double, double>& hitLocal,
        VxdID vxdID, const VXD::SensorInfoBase* aSensorInfo = nullptr);
 
 
    static std::pair<double, double> convertNormalizedToLocalCoordinates(const std::pair<double, double>& hitNormalized,
        Belle2::VxdID vxdID, const Belle2::VXD::SensorInfoBase* aSensorInfo = nullptr);
 
 
    static double getUWedged(const std::pair<double, double>& hitLocalUnwedged, VxdID vxdID,
                             const VXD::SensorInfoBase* aSensorInfo = nullptr)
    {
      if (aSensorInfo == nullptr) { aSensorInfo = &VXD::GeoCache::getInstance().getSensorInfo(vxdID); }
      return (aSensorInfo->getWidth(hitLocalUnwedged.second) / aSensorInfo->getWidth()) * hitLocalUnwedged.first;
    }
 
 
 
    static double getUUnwedged(const std::pair<double, double>& hitLocalWedged, VxdID::baseType vxdID,
                               const VXD::SensorInfoBase* aSensorInfo = nullptr)
    {
      if (aSensorInfo == nullptr) { aSensorInfo = &VXD::GeoCache::getInstance().getSensorInfo(vxdID); }
      return (aSensorInfo->getWidth() / aSensorInfo->getWidth(hitLocalWedged.second)) * hitLocalWedged.first;
    }
 
 
 
    static void boundaryEnforce(double& value, const double& otherValue, double lower = 0, double higher = 1, unsigned int side = 0,
                                VxdID vxdID = VxdID())
    {
      // Times to times there are normalized coordinates that are out of the boundaries.
      // We do apply a smal sloppyness here
 
      double sloppyTerm = 1e-3;
      if (value < lower - sloppyTerm) {
        B2WARNING("SpacePoint::boundaryEnforce: value had to be moved (lowerCheck)! old: " << value << ", new: " << lower);
        B2WARNING("On sensor: " << vxdID << " side: " << (side == 0 ? " U " : " V") <<
                  " when the other coordinate is: " << otherValue);
 
        value = lower;
      }
      if (value > higher + sloppyTerm) {
        B2WARNING("SpacePoint::boundaryEnforce: value had to be moved (higherCheck)! old: " << value << ", new: " << higher);
        B2WARNING("On sensor: " << vxdID << " side: " << (side == 0 ? " U " : " V") <<
                  " when the other coordinate is: " << otherValue);
        value = higher;
      }
 
    }
//---------------------------------------------------------------------------------------------------------------------
 
  protected:
    void setPositionError(double uSigma, double vSigma, const VXD::SensorInfoBase* aSensorInfo)
    {
      //As only variances, but not the sigmas transform linearly, we need to use some acrobatics.
      m_positionError = aSensorInfo->vectorToGlobal(ROOT::Math::XYZVector(uSigma * uSigma, vSigma * vSigma, 0),
                                                    true // use alignment in transformation
                                                   );
      m_positionError.Sqrt();
    }
 
    //--- Member variables --------------------------------------------------------------------------------------------
    B2Vector3<double> m_position;
 
    B2Vector3<double> m_positionError;
 
 
    std::pair<double, double> m_normalizedLocal;
 
    double m_UClusterTime;
 
    double m_VClusterTime;
 
 
    std::pair<bool, bool> m_clustersAssigned {false, false};
 
    VxdID::baseType m_vxdID;
 
    VXD::SensorInfoBase::SensorType m_sensorType;
 
    float m_qualityIndicator {0.5};
 
 
    float m_qualityIndicatorError {0.5};
 
    mutable bool m_isAssigned {false};
 
    ClassDefOverride(SpacePoint, 13)
  };
}