#include <ForwardDetLayer.h>

Inheritance diagram for ForwardDetLayer:

Public Member Functions
std::pair< bool, TrajectoryStateOnSurface >	compatible (const TrajectoryStateOnSurface &, const Propagator &, const MeasurementEstimator &) const override

bool	contains (const Local3DPoint &p) const

	ForwardDetLayer (bool doHaveGroups)

Location	location () const final
	Which part of the detector (barrel, endcap) More...

virtual const BoundDisk &	specificSurface () const final

const BoundSurface &	surface () const final
	The surface of the GeometricSearchDet. More...

	~ForwardDetLayer () override

Public Member Functions inherited from DetLayer
	DetLayer (bool doHaveGroup, bool ibar)

bool	isBarrel () const

bool	isForward () const

int	seqNum () const

void	setSeqNum (int sq)

virtual SubDetector	subDetector () const =0
	The type of detector (PixelBarrel, PixelEndcap, TIB, TOB, TID, TEC, CSC, DT, RPCBarrel, RPCEndcap) More...

	~DetLayer () override

Public Member Functions inherited from GeometricSearchDet
virtual const std::vector< const GeomDet * > &	basicComponents () const =0

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

virtual void	compatibleDetsV (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetWithState > &result) const

virtual const std::vector< const GeometricSearchDet * > &	components () const =0
	Returns basic components, if any. More...

	GeometricSearchDet (bool doHaveGroups)

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

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 ()

Protected Member Functions
SimpleDiskBounds const &	bounds () const

virtual BoundDisk *	computeSurface ()

virtual void	initialize ()

float	rmax () const

float	rmin () const

void	setSurface (BoundDisk *cp)

float	zmax () const

float	zmin () const

Private Attributes
ReferenceCountingPointer< BoundDisk >	theDisk

Additional Inherited Members
Public Types inherited from DetLayer
typedef GeomDetEnumerators::Location	Location

typedef GeomDetEnumerators::SubDetector	SubDetector

Public Types inherited from GeometricSearchDet
typedef std::pair< const GeomDet *, TrajectoryStateOnSurface >	DetWithState

typedef BoundSurface::PositionType	PositionType

typedef BoundSurface::RotationType	RotationType

typedef TrajectoryStateOnSurface	TrajectoryState

Protected Attributes inherited from GeometricSearchDet
bool	haveGroups

GeomDetCompatibilityChecker	theCompatibilityChecker

Detailed Description

A specialization of the DetLayer interface for forward layers. Forward layers are disks with their axes parallel to the global Z axis. The methods that have a common implementation for all ForwardDetLayers are implemented in this class, but some methods are left abstract.

Definition at line 22 of file ForwardDetLayer.h.

Constructor & Destructor Documentation

◆ ForwardDetLayer()

ForwardDetLayer::ForwardDetLayer ( bool doHaveGroups )

inline

Definition at line 24 of file ForwardDetLayer.h.

24 : DetLayer(doHaveGroups, false) {}

◆ ~ForwardDetLayer()

ForwardDetLayer::~ForwardDetLayer ( )

override

Definition at line 10 of file ForwardDetLayer.cc.

10 {}

Member Function Documentation

◆ bounds()

SimpleDiskBounds const& ForwardDetLayer::bounds ( ) const

inlineprotected

Definition at line 54 of file ForwardDetLayer.h.

54 { return static_cast<SimpleDiskBounds const&>(theDisk->bounds()); }

References theDisk.

Referenced by zmax(), and zmin().

◆ compatible()

pair< bool, TrajectoryStateOnSurface > ForwardDetLayer::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 84 of file ForwardDetLayer.cc.

                                                                                                     {
   if
     UNLIKELY(theDisk == nullptr)
   edm::LogError("DetLayers") << "ERROR: BarrelDetLayer::compatible() is used before the layer surface is initialized";
   // throw an exception? which one?
  
   TrajectoryStateOnSurface myState = prop.propagate(ts, specificSurface());
   if
     UNLIKELY(!myState.isValid()) return make_pair(false, myState);
  
   // check z;  (are we sure?????)
   // auto z = myState.localPosition().z();
   // if ( z<bounds().minZ | z>bounds().maxZ) return make_pair( false, myState);
  
   // check r
   auto r2 = myState.localPosition().perp2();
   if ((r2 > rmin() * rmin()) & (r2 < rmax() * rmax()))
     return make_pair(true, myState);
  
   // take into account the thickness of the layer
   float deltaR = 0.5f * bounds().thickness() * myState.localDirection().perp() / std::abs(myState.localDirection().z());
  
   // and take into account the error on the predicted state
   const float nSigma = 3.;
   if (myState.hasError()) {
     LocalError err = myState.localError().positionError();
     // ignore correlation for the moment...
     deltaR += nSigma * sqrt(err.xx() + err.yy());
   }
  
   // check r again;
   auto ri2 = std::max(rmin() - deltaR, 0.f);
   ri2 *= ri2;
   auto ro2 = rmax() + deltaR;
   ro2 *= ro2;
   return make_pair((r2 > ri2) & (r2 < ro2), myState);
 }

References funct::abs(), PbPb_ZMuSkimMuonDPG_cff::deltaR, runTheMatrix::err, f, TrajectoryStateOnSurface::hasError(), TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localDirection(), TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localPosition(), SiStripPI::max, HLTSiStripMonitoring_cff::nSigma, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::perp2(), LocalTrajectoryError::positionError(), Propagator::propagate(), diffTwoXMLs::r2, mathSSE::sqrt(), UNLIKELY, and PV3DBase< T, PVType, FrameType >::z().

◆ computeSurface()

BoundDisk * ForwardDetLayer::computeSurface ( )

protectedvirtual

Definition at line 19 of file ForwardDetLayer.cc.

                                            {
   LogDebug("DetLayers") << "ForwaLayer::computeSurface callded";
   vector<const GeomDet*> comps = basicComponents();
  
   vector<const GeomDet*>::const_iterator ifirst = comps.begin();
   vector<const GeomDet*>::const_iterator ilast = comps.end();
  
   // Find extension in R
   float theRmin = components().front()->position().perp();
   float theRmax = theRmin;
   float theZmin = components().back()->position().z();
   float theZmax = theZmin;
   for (vector<const GeomDet*>::const_iterator deti = ifirst; deti != ilast; deti++) {
     vector<GlobalPoint> corners = BoundingBox().corners(dynamic_cast<const Plane&>((**deti).surface()));
     for (vector<GlobalPoint>::const_iterator ic = corners.begin(); ic != corners.end(); ic++) {
       float r = ic->perp();
       LogDebug("DetLayers") << "corner.perp(): " << r;
       float z = ic->z();
       theRmin = min(theRmin, r);
       theRmax = max(theRmax, r);
       theZmin = min(theZmin, z);
       theZmax = max(theZmax, z);
     }
  
     // in addition to the corners we have to check the middle of the
     // det +/- length/2
     // , since the min (max) radius for typical fw dets is reached there
  
     float rdet = (**deti).position().perp();
     float len = (**deti).surface().bounds().length();
     float width = (**deti).surface().bounds().width();
  
     GlobalVector xAxis = (**deti).toGlobal(LocalVector(1, 0, 0));
     GlobalVector yAxis = (**deti).toGlobal(LocalVector(0, 1, 0));
     GlobalVector perpDir = GlobalVector((**deti).position() - GlobalPoint(0, 0, (**deti).position().z()));
  
     double xAxisCos = xAxis.unit().dot(perpDir.unit());
     double yAxisCos = yAxis.unit().dot(perpDir.unit());
  
     LogDebug("DetLayers") << "in ForwardDetLayer::computeSurface(),xAxisCos,yAxisCos: " << xAxisCos << " , "
                           << yAxisCos;
     LogDebug("DetLayers") << "det pos.perp,length,width: " << rdet << " , " << len << " , " << width;
  
     if (fabs(xAxisCos) > fabs(yAxisCos)) {
       theRmin = min(theRmin, rdet - width / 2.F);
       theRmax = max(theRmax, rdet + width / 2.F);
     } else {
       theRmin = min(theRmin, rdet - len / 2.F);
       theRmax = max(theRmax, rdet + len / 2.F);
     }
   }
  
   LogDebug("DetLayers") << "creating SimpleDiskBounds with r range" << theRmin << " " << theRmax << " and z range "
                         << theZmin << " " << theZmax;
  
   // By default the forward layers are positioned around the z axis of the
   // global frame, and the axes of their local frame coincide with
   // those of the global grame (z along the disk axis)
   float zPos = (theZmax + theZmin) / 2.;
   PositionType pos(0., 0., zPos);
   RotationType rot;
  
   return new BoundDisk(pos, rot, new SimpleDiskBounds(theRmin, theRmax, theZmin - zPos, theZmax - zPos));
 }