StereoHitContained.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/trackingUtilities/eventdata/segments/CDCSegment2D.h>
#include <tracking/trackingUtilities/eventdata/hits/CDCRLWireHit.h>
#include <tracking/trackingUtilities/eventdata/hits/CDCWireHit.h>
 
#include <cdc/topology/CDCWire.h>
 
#include <tracking/trackingUtilities/numerics/ESign.h>
#include <tracking/trackingUtilities/numerics/Weight.h>
 
#include <Math/Vector2D.h>
 
#include <numeric>
 
namespace Belle2 {
  namespace TrackFindingCDC {

    template<class AInBox>
    class StereoHitContained : public AInBox {
 
    public:
      using AInBox::AInBox;

      using HoughBox = typename AInBox::HoughBox;
 

      TrackingUtilities::Weight operator()(const TrackingUtilities::CDCSegment2D* segment2D,
                                           const HoughBox* houghBox)
      {
        size_t nHits = segment2D->size();
        auto weightOfHit = [this, &houghBox](const TrackingUtilities::Weight & totalWeight,
        const TrackingUtilities::CDCRecoHit2D & recoHit2D) -> TrackingUtilities::Weight {
          TrackingUtilities::Weight hitWeight = this->operator()(&recoHit2D, houghBox);
          return std::isnan(hitWeight) ? totalWeight : totalWeight + hitWeight;
        };
 
        TrackingUtilities::Weight totalWeight = std::accumulate(segment2D->begin(),
                                                                segment2D->end(),
                                                                static_cast<TrackingUtilities::Weight>(0.0),
                                                                weightOfHit);
 
        // Require a efficiency of 66%
        constexpr const TrackingUtilities::Weight minEfficiency = 2.0 / 3;
        if (totalWeight > nHits * minEfficiency) {
          return totalWeight;
        } else {
          return NAN;
        }
      }

      TrackingUtilities::Weight operator()(const TrackingUtilities::CDCRecoHit2D* recoHit2D,
                                           const HoughBox* houghBox)
      {
        const CDC::CDCWire& wire = recoHit2D->getWire();
        const double signedDriftLength = recoHit2D->getSignedRefDriftLength();
        bool isIn = contains(*houghBox, wire, signedDriftLength);
        TrackingUtilities::ERightLeft rlInfo = recoHit2D->getRLInfo();
        return isIn ? 1.0 + isValid(rlInfo) * m_rlWeightGain : NAN;
      }
 

      TrackingUtilities::Weight operator()(const TrackingUtilities::CDCWireHit* wireHit,
                                           const HoughBox* houghBox)
      {
        const CDC::CDCWire& wire = wireHit->getWire();
        const double driftLength = wireHit->getRefDriftLength();
 
        TrackingUtilities::ERightLeft rlInfo = containsRightOrLeft(*houghBox, wire, driftLength);
        return isValid(rlInfo) ? 1.0 + std::abs(rlInfo) * m_rlWeightGain : NAN;
      }

      TrackingUtilities::Weight operator()(TrackingUtilities::CDCRLWireHit& rlTaggedWireHit,
                                           const HoughBox* houghBox)
      {
        const CDC::CDCWire& wire = rlTaggedWireHit.getWire();
        const TrackingUtilities::ERightLeft rlInfo = rlTaggedWireHit.getRLInfo();
        const double driftLength = rlTaggedWireHit.getRefDriftLength();
 
        TrackingUtilities::ERightLeft newRLInfo =
          containsRightOrLeft(*houghBox, wire, driftLength, rlInfo);
 
        rlTaggedWireHit.setRLInfo(newRLInfo);
        return isValid(newRLInfo) ? 1.0 + std::abs(newRLInfo) * m_rlWeightGain : NAN;
      }

      TrackingUtilities::ERightLeft containsRightOrLeft(const HoughBox& houghBox,
                                                        const CDC::CDCWire& wire,
                                                        double driftLength,
                                                        TrackingUtilities::ERightLeft rlInfo = TrackingUtilities::ERightLeft::c_Unknown)
      {
        bool isRightIn = rlInfo != TrackingUtilities::ERightLeft::c_Left and contains(houghBox, wire, driftLength);
        bool isLeftIn = rlInfo != TrackingUtilities::ERightLeft::c_Right and contains(houghBox, wire, -driftLength);
 
        if (isRightIn and isLeftIn) {
          return TrackingUtilities::ERightLeft::c_Unknown;
        } else if (isRightIn) {
          return TrackingUtilities::ERightLeft::c_Right;
        } else if (isLeftIn) {
          return TrackingUtilities::ERightLeft::c_Left;
        } else {
          return TrackingUtilities::ERightLeft::c_Invalid;
        }
      }

      bool contains(const HoughBox& houghBox, const CDC::CDCWire& wire, double signedDriftLength)
      {
        const ROOT::Math::XYVector& pos2D = wire.getRefPos2D();
        //const ROOT::Math::XYVector& pos2D = wire.getWirePos2DAtZ(0);
        const ROOT::Math::XYVector& movePerZ = wire.getMovePerZ();
        CDC::ILayer iCLayer(wire.getICLayer());
        //B2INFO("movePerZ = " << movePerZ);
        const TrackingUtilities::ESign distSign = this->getDistanceSign(houghBox,
                                                  pos2D.x(),  pos2D.y(),
                                                  signedDriftLength,
                                                  movePerZ.x(), movePerZ.y(),
                                                  iCLayer);
        const bool isIn = distSign == TrackingUtilities::ESign::c_Zero;
        return isIn;
      }
 
    public:
      void setRLWeightGain(float rlWeightGain)
      { m_rlWeightGain = rlWeightGain;}

      float setRLWeightGain() const
      { return m_rlWeightGain; }
 
    private:
      float m_rlWeightGain = 0;
    };
 
  }
}