InPhi0CurvBox.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 <tracking/trackFindingCDC/hough/perigee/Phi0Rep.h>
#include <tracking/trackFindingCDC/hough/perigee/CurvRep.h>
#include <tracking/trackFindingCDC/hough/boxes/Box.h>
#include <tracking/trackingUtilities/numerics/ESign.h>
#include <cdc/topology/ILayer.h>
 
#include <array>
#include <cmath>
 
namespace Belle2 {
  namespace TrackFindingCDC {

    class InPhi0CurvBox {
 
    public:
      explicit InPhi0CurvBox(float curlCurv = NAN) : m_curlCurv(curlCurv) {}
 
    public:
      using HoughBox = Box<DiscretePhi0, DiscreteCurv>;
 
    public:
      TrackingUtilities::ESign getDistanceSign(const HoughBox& houghBox,
                                               float x,
                                               float y,
                                               float l,
                                               float /*dxdz*/ = 0,
                                               float /*dydz*/ = 0,
                                               CDC::ILayer /*iCLayer*/ = -1) const
      {
        const std::array<DiscretePhi0, 2>& phi0Vec = houghBox.getBounds<DiscretePhi0>();
        const std::array<DiscreteCurv, 2>& curv = houghBox.getBounds<DiscreteCurv>();
 
        std::array<float, 2> xRot;
        xRot[0] = x * phi0Vec[0]->x() + y * phi0Vec[0]->y();
        xRot[1] = x * phi0Vec[1]->x() + y * phi0Vec[1]->y();
 
        const bool isNonCurler = static_cast<float>(curv[1]) <= m_curlCurv and static_cast<float>(curv[0]) >= -m_curlCurv;
        const bool onlyPositiveArm = isNonCurler;
        if (onlyPositiveArm) {
          // Reject hit if it is on the inward going branch but the curvature suggest it is no curler
          if (xRot[0] < 0 and xRot[1] < 0) return TrackingUtilities::ESign::c_Invalid;
        }
 
        std::array<float, 2> yRotPlusL;
        yRotPlusL[0] = -x * phi0Vec[0]->y() + y * phi0Vec[0]->x() + l;
        yRotPlusL[1] = -x * phi0Vec[1]->y() + y * phi0Vec[1]->x() + l;
 
        const float r2 =  x * x + y * y - l * l;
        std::array<float, 2> r2TimesHalfCurv;
        r2TimesHalfCurv[0] = r2 * (static_cast<float>(curv[0]) / 2.0);
        r2TimesHalfCurv[1] = r2 * (static_cast<float>(curv[1]) / 2.0);
 
        // Using binary notation encoding lower and upper box bounds to fill the flat array.
        std::array<float, 4> dist;
 
        dist[0b00] = r2TimesHalfCurv[0] - yRotPlusL[0];
        dist[0b10] = r2TimesHalfCurv[0] - yRotPlusL[1];
 
        dist[0b01] = r2TimesHalfCurv[1] - yRotPlusL[0];
        dist[0b11] = r2TimesHalfCurv[1] - yRotPlusL[1];
 
        return TrackingUtilities::ESignUtil::common(dist);
      }
 
    private:
      float m_curlCurv;
    };
  }
}