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/trackFindingCDC/eventdata/segments/CDCSegment2D.h>
#include <tracking/trackFindingCDC/eventdata/hits/CDCRLWireHit.h>
#include <tracking/trackFindingCDC/eventdata/hits/CDCWireHit.h>
 
#include <tracking/trackFindingCDC/topology/CDCWire.h>
 
#include <tracking/trackFindingCDC/numerics/ESign.h>
#include <tracking/trackFindingCDC/numerics/Weight.h>
 
#include <numeric>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    template<class AInBox>
    class StereoHitContained : public AInBox {
 
    public:
      using AInBox::AInBox;
 
      using HoughBox = typename AInBox::HoughBox;
 
 
      Weight operator()(const CDCSegment2D* segment2D,
                        const HoughBox* houghBox)
      {
        size_t nHits = segment2D->size();
        auto weightOfHit = [this, &houghBox](const Weight & totalWeight,
        const CDCRecoHit2D & recoHit2D) -> Weight {
          Weight hitWeight = this->operator()(&recoHit2D, houghBox);
          return std::isnan(hitWeight) ? totalWeight : totalWeight + hitWeight;
        };
 
        Weight totalWeight = std::accumulate(segment2D->begin(),
                                             segment2D->end(),
                                             static_cast<Weight>(0.0),
                                             weightOfHit);
 
        // Require a efficiency of 66%
        constexpr const Weight minEfficiency = 2.0 / 3;
        if (totalWeight > nHits * minEfficiency) {
          return totalWeight;
        } else {
          return NAN;
        }
      }
 
      Weight operator()(const CDCRecoHit2D* recoHit2D,
                        const HoughBox* houghBox)
      {
        const CDCWire& wire = recoHit2D->getWire();
        const double signedDriftLength = recoHit2D->getSignedRefDriftLength();
        bool isIn = contains(*houghBox, wire, signedDriftLength);
        ERightLeft rlInfo = recoHit2D->getRLInfo();
        return isIn ? 1.0 + isValid(rlInfo) * m_rlWeightGain : NAN;
      }
 
 
      Weight operator()(const CDCWireHit* wireHit,
                        const HoughBox* houghBox)
      {
        const CDCWire& wire = wireHit->getWire();
        const double driftLength = wireHit->getRefDriftLength();
 
        ERightLeft rlInfo = containsRightOrLeft(*houghBox, wire, driftLength);
        return isValid(rlInfo) ? 1.0 + std::abs(rlInfo) * m_rlWeightGain : NAN;
      }
 
      Weight operator()(CDCRLWireHit& rlTaggedWireHit,
                        const HoughBox* houghBox)
      {
        const CDCWire& wire = rlTaggedWireHit.getWire();
        const ERightLeft rlInfo = rlTaggedWireHit.getRLInfo();
        const double driftLength = rlTaggedWireHit.getRefDriftLength();
 
        ERightLeft newRLInfo =
          containsRightOrLeft(*houghBox, wire, driftLength, rlInfo);
 
        rlTaggedWireHit.setRLInfo(newRLInfo);
        return isValid(newRLInfo) ? 1.0 + std::abs(newRLInfo) * m_rlWeightGain : NAN;
      }
 
      ERightLeft containsRightOrLeft(const HoughBox& houghBox,
                                     const CDCWire& wire,
                                     double driftLength,
                                     ERightLeft rlInfo = ERightLeft::c_Unknown)
      {
        bool isRightIn = rlInfo != ERightLeft::c_Left and contains(houghBox, wire, driftLength);
        bool isLeftIn = rlInfo != ERightLeft::c_Right and contains(houghBox, wire, -driftLength);
 
        if (isRightIn and isLeftIn) {
          return ERightLeft::c_Unknown;
        } else if (isRightIn) {
          return ERightLeft::c_Right;
        } else if (isLeftIn) {
          return ERightLeft::c_Left;
        } else {
          return ERightLeft::c_Invalid;
        }
      }
 
      bool contains(const HoughBox& houghBox, const CDCWire& wire, double signedDriftLength)
      {
        const Vector2D& pos2D = wire.getRefPos2D();
        //const Vector2D& pos2D = wire.getWirePos2DAtZ(0);
        const Vector2D& movePerZ = wire.getMovePerZ();
        ILayer iCLayer(wire.getICLayer());
        //B2INFO("movePerZ = " << movePerZ);
        const ESign distSign = this->getDistanceSign(houghBox,
                                                     pos2D.x(),  pos2D.y(),
                                                     signedDriftLength,
                                                     movePerZ.x(), movePerZ.y(),
                                                     iCLayer);
        const bool isIn = distSign == ESign::c_Zero;
        return isIn;
      }
 
    public:
      void setRLWeightGain(float rlWeightGain)
      { m_rlWeightGain = rlWeightGain;}
 
      float setRLWeightGain() const
      { return m_rlWeightGain; }
 
    private:
      float m_rlWeightGain = 0;
    };
 
  }
}