MTDDetRing Class Reference

#include <MTDDetRing.h>

Inheritance diagram for MTDDetRing:

Public Member Functions
std::pair< bool, TrajectoryStateOnSurface >	compatible (const TrajectoryStateOnSurface &ts, const Propagator &prop, const MeasurementEstimator &est) const override
std::vector< DetWithState >	compatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const override
const std::vector< const GeometricSearchDet * > &	components () const override
	Returns basic components, if any. More...
std::vector< DetGroup >	groupedCompatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const override
	MTDDetRing (std::vector< const GeomDet *>::const_iterator first, std::vector< const GeomDet *>::const_iterator last)
	Construct from iterators on GeomDet*. More...
	MTDDetRing (const std::vector< const GeomDet *> &dets)
	Construct from a vector of GeomDet*. More...
	~MTDDetRing () override
Public Member Functions inherited from ForwardDetRingOneZ
const std::vector< const GeomDet * > &	basicComponents () const override
	ForwardDetRingOneZ (std::vector< const GeomDet *>::const_iterator first, std::vector< const GeomDet *>::const_iterator last)
	Construct from iterators on Det*. More...
	ForwardDetRingOneZ (const std::vector< const GeomDet *> &dets)
	~ForwardDetRingOneZ () override
Public Member Functions inherited from ForwardDetRing
void	compatibleDetsV (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetWithState > &result) const override
	GeometricSearchDet (bool doHaveGroups)
const BoundDisk &	specificSurface () const
	Return the ring surface as a BoundDisk. More...
const BoundSurface &	surface () const final
	The surface of the GeometricSearchDet. More...
	~ForwardDetRing () override
Public Member Functions inherited from GeometricSearchDet
	GeometricSearchDet (bool doHaveGroups)
virtual void	groupedCompatibleDetsV (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetGroup > &result) const
bool	hasGroups () const
virtual const Surface::PositionType &	position () const
	Returns position of the surface. More...
virtual	~GeometricSearchDet ()

Private Types
typedef PeriodicBinFinderInPhi< float >	BinFinderType

Private Member Functions
void	init ()

Private Attributes
BinFinderType	theBinFinder

Additional Inherited Members
Public Types inherited from GeometricSearchDet
typedef std::pair< const GeomDet *, TrajectoryStateOnSurface >	DetWithState
typedef BoundSurface::PositionType	PositionType
typedef BoundSurface::RotationType	RotationType
typedef TrajectoryStateOnSurface	TrajectoryState
Protected Member Functions inherited from ForwardDetRingOneZ
bool	add (int idet, std::vector< DetWithState > &result, const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est) const
Protected Member Functions inherited from ForwardDetRing
void	setDisk (BoundDisk *disk)
	Set the rod's disk. More...
Protected Attributes inherited from GeometricSearchDet
bool	haveGroups
GeomDetCompatibilityChecker	theCompatibilityChecker

Detailed Description

A ring of periodic, possibly overlapping vertical detectors. Designed for the endcap timing layer.

Author

L. Gray - FNAL

Definition at line 16 of file MTDDetRing.h.

Member Typedef Documentation

BinFinderType

typedef PeriodicBinFinderInPhi<float> MTDDetRing::BinFinderType

private

Definition at line 43 of file MTDDetRing.h.

Constructor & Destructor Documentation

MTDDetRing() [1/2]

MTDDetRing::MTDDetRing	(	std::vector< const GeomDet *>::const_iterator	first,
		std::vector< const GeomDet *>::const_iterator	last
	)

Construct from iterators on GeomDet*.

Definition at line 19 of file MTDDetRing.cc.

References init().

    : ForwardDetRingOneZ(first, last) {
  init();
}

MTDDetRing() [2/2]

MTDDetRing::MTDDetRing

(

const std::vector< const GeomDet *> &

dets

)

Construct from a vector of GeomDet*.

Definition at line 24 of file MTDDetRing.cc.

References init().

: ForwardDetRingOneZ(vdets) { init(); }

~MTDDetRing()

MTDDetRing::~MTDDetRing ( )

override

Definition at line 30 of file MTDDetRing.cc.

{}

Member Function Documentation

compatible()

pair< bool, TrajectoryStateOnSurface > MTDDetRing::compatible ( const TrajectoryStateOnSurface &  ts, const Propagator &  , const MeasurementEstimator &    ) const

overridevirtual

tests the geometrical compatibility of the Det with the predicted state. The FreeTrajectoryState argument is propagated to the Det 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.

Implements GeometricSearchDet.

Definition at line 39 of file MTDDetRing.cc.

References MeasurementEstimator::estimate(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localPosition(), LogTrace, PV3DBase< T, PVType, FrameType >::perp(), Propagator::propagate(), ForwardDetRing::specificSurface(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by compatibleDets().

                                                                                                   {
  TrajectoryStateOnSurface ms = prop.propagate(ts, specificSurface());

#ifdef EDM_ML_DEBUG
  LogTrace("MTDDetLayers") << "MTDDetRing::compatible, Surface at Z: " << specificSurface().position().z()
                           << " R1: " << specificSurface().innerRadius() << " R2: " << specificSurface().outerRadius()
                           << " TS   at Z,R: " << ts.globalPosition().z() << "," << ts.globalPosition().perp();
  if (ms.isValid()) {
    LogTrace("MTDDetLayers") << " DEST at Z,R: " << ms.globalPosition().z() << "," << ms.globalPosition().perp()
                             << " local Z: " << ms.localPosition().z();
  } else {
    LogTrace("MTDDetLayers") << " DEST: not valid";
  }
#endif

  return make_pair(ms.isValid() and est.estimate(ms, specificSurface()) != 0, ms);
}

compatibleDets()

vector< GeometricSearchDet::DetWithState > MTDDetRing::compatibleDets ( const TrajectoryStateOnSurface &  startingState, const Propagator &  prop, const MeasurementEstimator &  est  ) const

overridevirtual

Returns all Dets compatible with a trajectory state according to the estimator est. The startingState should be propagated to the surface of each compatible Det using the Propagator passed as an argument. The default implementation should be overridden in dets with specific surface types to avoid propagation to a generic Surface

Reimplemented from GeometricSearchDet.

Definition at line 59 of file MTDDetRing.cc.

References ForwardDetRingOneZ::add(), ForwardDetRingOneZ::basicComponents(), PeriodicBinFinderInPhi< T >::binIndex(), compatible(), TrajectoryStateOnSurface::globalPosition(), createfilelist::int, LogTrace, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), GeometricSearchDet::position(), GloballyPositioned< T >::position(), mps_fire::result, ForwardDetRing::specificSurface(), mathSSE::sqrt(), ForwardDetRing::surface(), theBinFinder, and PV3DBase< T, PVType, FrameType >::z().

                                                                                                           {
  LogTrace("MTDDetLayers") << "MTDDetRing::compatibleDets, Surface at Z: " << surface().position().z()
                           << " R1: " << specificSurface().innerRadius() << " R2: " << specificSurface().outerRadius()
                           << " TS at Z,R: " << startingState.globalPosition().z() << ","
                           << startingState.globalPosition().perp() << "     DetRing pos." << position();

  vector<DetWithState> result;

  // Propagate and check that the result is within bounds
  pair<bool, TrajectoryStateOnSurface> compat = compatible(startingState, prop, est);
  if (!compat.first) {
    LogTrace("MTDDetLayers") << "    MTDDetRing::compatibleDets: not compatible"
                             << "    (should not have been selected!)";
    return result;
  }

  // Find the most probable destination component
  TrajectoryStateOnSurface& tsos = compat.second;
  GlobalPoint startPos = tsos.globalPosition();
  int closest = theBinFinder.binIndex(startPos.phi());
  const vector<const GeomDet*> dets = basicComponents();
  LogTrace("MTDDetLayers") << "     MTDDetRing::compatibleDets, closest det: " << closest
                           << " Phi: " << dets[closest]->surface().position().phi() << " impactPhi " << startPos.phi();

  // Add this detector, if it is compatible
  // NOTE: add performs a null propagation
  add(closest, result, tsos, prop, est);

#ifdef EDM_ML_DEBUG
  int nclosest = result.size();
  int nnextdet = 0;  // MDEBUG counters

  // Try the neighbors on each side until no more compatible.
  float dphi = 0;
  if (!result.empty()) {  // If closest is not compatible the next cannot be either
    float nSigmas = 3.;
    if (result.back().second.hasError()) {
      dphi = nSigmas * atan(sqrt(result.back().second.localError().positionError().xx()) /
                            result.back().second.globalPosition().perp());
    }
  } else {
    LogTrace("MTDDetLayers") << "     MTDDetRing::compatibleDets, closest not compatible!";
    //FIXME:  if closest is not compatible the next cannot be either
  }
#endif

  for (int idet = closest + 1; idet < closest + int(dets.size()) / 4 + 1; idet++) {
    // FIXME: should use dphi to decide if det must be queried.
    // Right now query until not compatible.
    int idetp = theBinFinder.binIndex(idet);
    {
#ifdef EDM_ML_DEBUG
      LogTrace("MTDDetLayers") << "     next det:" << idetp << " at Z: " << dets[idetp]->position().z()
                               << " phi: " << dets[idetp]->position().phi() << " FTS phi " << startPos.phi()
                               << " max dphi " << dphi;
      nnextdet++;
#endif
      if (!add(idetp, result, tsos, prop, est))
        break;
    }
  }

  for (int idet = closest - 1; idet > closest - int(dets.size()) / 4 - 1; idet--) {
    // FIXME: should use dphi to decide if det must be queried.
    // Right now query until not compatible.
    int idetp = theBinFinder.binIndex(idet);
    {
#ifdef EDM_ML_DEBUG
      LogTrace("MTDDetLayers") << "     previous det:" << idetp << " " << idet << " " << closest - dets.size() / 4 - 1
                               << " at Z: " << dets[idetp]->position().z() << " phi: " << dets[idetp]->position().phi()
                               << " FTS phi " << startPos.phi() << " max dphi" << dphi;
      nnextdet++;
#endif
      if (!add(idetp, result, tsos, prop, est))
        break;
    }
  }

#ifdef EDM_ML_DEBUG
  LogTrace("MTDDetLayers") << "     MTDDetRing::compatibleDets, size: " << result.size() << " on closest: " << nclosest
                           << " # checked dets: " << nnextdet + 1;

  if (result.empty()) {
    LogTrace("MTDDetLayers") << "   ***Ring not compatible,should have been discarded before!!!";
  }
#endif

  return result;
}

components()

const vector< const GeometricSearchDet * > & MTDDetRing::components ( ) const

overridevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 32 of file MTDDetRing.cc.

References mps_fire::result.

                                                                      {
  // FIXME dummy impl.
  edm::LogError("MTDDetLayers") << "temporary dummy implementation of MTDDetRing::components()!!";
  static const vector<const GeometricSearchDet*> result;
  return result;
}

groupedCompatibleDets()

vector< DetGroup > MTDDetRing::groupedCompatibleDets ( const TrajectoryStateOnSurface &  startingState, const Propagator &  prop, const MeasurementEstimator &  est  ) const

overridevirtual

Similar to compatibleDets(), but the compatible Dets are grouped in one or more groups. Dets are put in the same group if they are mutually exclusive for track crossing, i.e. a reconstructible track cannot cross more than one Det from a group. Pathological tracks (spirals etc.) can of course violate this rule.
The DetGroups are sorted in the sequence of crossing by a track. In order to define the direction of crossing the Propagator used in this method should have a defined direction() : either "alongMomentum" or "oppositeToMomentum" but not "anyDirection".
The three signatures of this method differ by the input trajectory state arguments: the starting state can be a TrajectoryStateOnSurface or a FreeTrajectoryState, and the state on this CompositeDet may be already known or not. The last two arguments are as for the method compatibleDets().
First signature: The first argument is a TrajectoryStateOnSurface, usually not on the surface of this CompositeDet.

Reimplemented from GeometricSearchDet.

Definition at line 151 of file MTDDetRing.cc.

References mps_fire::result.

                                                                                          {
  // FIXME should be implemented to allow returning  overlapping chambers
  // as separate groups!
  edm::LogError("MTDDetLayers") << "dummy implementation of MTDDetRing::groupedCompatibleDets()";
  vector<DetGroup> result;
  return result;
}

init()

void MTDDetRing::init ( void  )

private

Definition at line 26 of file MTDDetRing.cc.

References ForwardDetRingOneZ::basicComponents(), phi, GeometricSearchDet::position(), findQualityFiles::size, and theBinFinder.

Referenced by MTDDetRing().

                      {
  theBinFinder = BinFinderType(basicComponents().front()->position().phi(), basicComponents().size());
}

Member Data Documentation

theBinFinder

BinFinderType MTDDetRing::theBinFinder

private

Definition at line 44 of file MTDDetRing.h.

Referenced by compatibleDets(), and init().