GeomDetCompatibilityChecker Class Reference

#include <GeomDetCompatibilityChecker.h>

Static Public Member Functions
static std::pair< bool, TrajectoryStateOnSurface >	isCompatible (const GeomDet *theDet, const TrajectoryStateOnSurface &ts, const Propagator &prop, const MeasurementEstimator &est)

Detailed Description

helper class which checks if a GeomDet is geometrically compatible with a TrajectoryState

Definition at line 12 of file GeomDetCompatibilityChecker.h.

Member Function Documentation

std::pair< bool, TrajectoryStateOnSurface > GeomDetCompatibilityChecker::isCompatible ( const GeomDet *  theDet, const TrajectoryStateOnSurface &  ts, const Propagator &  prop, const MeasurementEstimator &  est  )

static

tests the geometrical compatibility of the GeomDet with the predicted state. The TrajectoryState argument is propagated to the GeomDet surface using the Propagator argument. The resulting TrajectoryStateOnSurface is tested for compatibility with the surface bounds. If compatible, a std::pair< true, propagatedState> is returned. If the propagation fails, or if the state is not compatible, a std::pair< false, propagatedState> is returned.

Definition at line 57 of file GeomDetCompatibilityChecker.cc.

References funct::abs(), PV3DBase< T, PVType, FrameType >::basicVector(), MeasurementEstimator::estimate(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalParameters(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), LIKELY, LogDebug, SiStripPI::max, MeasurementEstimator::maxSagitta(), MeasurementEstimator::minTolerance2(), eostools::move(), castor_dqm_sourceclient_file_cfg::path, perp2(), Propagator::propagate(), Propagator::propagationDirection(), GeomDet::specificSurface(), GlobalTrajectoryParameters::transverseCurvature(), and UNLIKELY.

Referenced by ForwardDetRingOneZ::add(), CompatibleDetToGroupAdder::add(), DetRodOneR::add(), SimpleTECWedge::compatible(), PixelRod::compatibleDetsV(), and TrajectorySegmentBuilder::redoMeasurements().

                                                                                                                     {
  stat.ntot++;

  auto const sagCut = est.maxSagitta();
  auto const minTol2 = est.minTolerance2();

  // std::cout << "param " << sagCut << ' ' << std::sqrt(minTol2) << std::endl;

  /*
  auto err2 = tsos.curvilinearError().matrix()(3,3);
  auto largeErr = err2> 0.1*tolerance2;
  if (largeErr) stat.nle++; 
  */

  bool isIn = false;
  float sagitta = 99999999;
  bool close = false;
  if
    LIKELY(sagCut > 0) {
      // linear approximation
      auto const& plane = theDet->specificSurface();
      StraightLinePlaneCrossing crossing(
          tsos.globalPosition().basicVector(), tsos.globalMomentum().basicVector(), prop.propagationDirection());
      auto path = crossing.pathLength(plane);
      isIn = path.first;
      if
        UNLIKELY(!path.first) stat.ns1++;
      else {
        auto gpos = GlobalPoint(crossing.position(path.second));
        auto tpath2 = (gpos - tsos.globalPosition()).perp2();
        // sagitta = d^2*c/2
        sagitta = 0.5f * std::abs(tpath2 * tsos.globalParameters().transverseCurvature());
        close = sagitta < sagCut;
        LogDebug("TkDetLayer") << "GeomDetCompatibilityChecker: sagitta " << sagitta << std::endl;
        if (close) {
          stat.nth++;
          auto pos = plane.toLocal(GlobalPoint(crossing.position(path.second)));
          // auto toll = LocalError(tolerance2,0,tolerance2);
          auto tollL2 = std::max(sagitta * sagitta, minTol2);
          auto toll = LocalError(tollL2, 0, tollL2);
          isIn = plane.bounds().inside(pos, toll);
          if (!isIn) {
            stat.ns2++;
            LogDebug("TkDetLayer") << "GeomDetCompatibilityChecker: not in " << pos << std::endl;
            return std::make_pair(false, TrajectoryStateOnSurface());
          }
        }
      }
    }

  // precise propagation
  TrajectoryStateOnSurface&& propSt = prop.propagate(tsos, theDet->specificSurface());
  if
    UNLIKELY(!propSt.isValid()) {
      stat.nf1++;
      return std::make_pair(false, std::move(propSt));
    }

  auto es = est.estimate(propSt, theDet->specificSurface());
  if (!es)
    stat.nf2++;
  if (close && (!isIn) && (!es))
    stat.ns11++;
  if (close && es && (!isIn)) {
    stat.ns21++;
  }  // std::cout << sagitta << std::endl;}
  return std::make_pair(es, std::move(propSt));
}