DATCONSVDSpacePoint.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Christian Wessel                                         *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#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 <svd/dataobjects/SVDCluster.h>
 
#include <vxd/dataobjects/VxdID.h>
 
#include <vector>
#include <string>
#include <utility> // std::pair
 
namespace Belle2 {
  class DATCONSVDSpacePoint: public RelationsObject {
 
  public:
    //--- C'tors and D'tors -------------------------------------------------------------------------------------------
    explicit DATCONSVDSpacePoint(std::vector<SVDCluster const*>& clusters,
                                 VXD::SensorInfoBase const* aSensorInfo = nullptr);
 
    DATCONSVDSpacePoint() :
      m_vxdID(0), m_sensorType(VXD::SensorInfoBase::SensorType::VXD) // type is set to generic VXD
    {}
 
    DATCONSVDSpacePoint(B2Vector3<double>& pos, const std::pair<double, double>& normalizedLocal,
                        std::pair<bool, bool> clustersAssigned, VxdID sensorID, Belle2::VXD::SensorInfoBase::SensorType detID) :
      m_position(pos),
      m_normalizedLocal(normalizedLocal),
      m_clustersAssigned(clustersAssigned),
      m_vxdID(sensorID), m_sensorType(detID)
    {}
 
    //-----------------------------------------------------------------------------------------------------------------
 
    friend std::ostream& operator<< (std::ostream& out, const DATCONSVDSpacePoint& aSP) { return out << aSP.getName();}
 
    bool operator == (const DATCONSVDSpacePoint& b) const
    {
      return getArrayIndex() == b.getArrayIndex();
    }
 
    bool operator != (const DATCONSVDSpacePoint& b) const
    {
      return !(*this == b);
    }
 
    //--- Global Coordinate Getters -----------------------------------------------------------------------------------
    double X() const { return m_position.X(); }
 
    double Y() const { return m_position.Y(); }
 
    double Z() const { return m_position.Z(); }
 
    const B2Vector3<double>& getPosition() const { return m_position; }
 
    //---- 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; }
 
 
    // 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;
    }
 
    std::vector<SVDCluster> getAssignedDATCONSVDClusters() { return m_assignedDATCONSVDClusters; }
 
    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("DATCONSVDSpacePoint::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("DATCONSVDSpacePoint::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:
    //--- Member variables --------------------------------------------------------------------------------------------
    B2Vector3<double> m_position;
 
    std::pair<double, double> m_normalizedLocal;
 
    std::pair<bool, bool> m_clustersAssigned {false, false};
 
    std::vector<SVDCluster> m_assignedDATCONSVDClusters;
 
    VxdID::baseType m_vxdID;
 
    VXD::SensorInfoBase::SensorType m_sensorType;
 
    mutable bool m_isAssigned {false};
 
 
    ClassDef(DATCONSVDSpacePoint, 1)
  }; // end class
} // end namespace Belle2