#include <MTDSectorForwardDoubleLayer.h>

Inheritance diagram for MTDSectorForwardDoubleLayer:

Public Member Functions
const MTDSectorForwardLayer *	backLayer () const

const std::vector< const GeomDet * > &	basicComponents () const override

std::pair< bool, TrajectoryStateOnSurface >	compatible (const TrajectoryStateOnSurface &, const Propagator &, const MeasurementEstimator &) 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...

const MTDSectorForwardLayer *	frontLayer () const

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

bool	isCrack (const GlobalPoint &gp) const

bool	isInsideOut (const TrajectoryStateOnSurface &tsos) const

	MTDSectorForwardDoubleLayer (const std::vector< const MTDDetSector > &frontSectors, const std::vector< const MTDDetSector > &backSectors)
	Constructor, takes ownership of pointers. More...

virtual const std::vector< const MTDDetSector * > &	sectors () const
	Return the vector of sectors. More...

void	selfTest () const

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

	~MTDSectorForwardDoubleLayer () override

Public Member Functions inherited from ForwardDetLayer
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)

	~DetLayer () override

Public Member Functions inherited from GeometricSearchDet
virtual void	compatibleDetsV (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetWithState > &result) const

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

Protected Member Functions
BoundDisk *	computeSurface () override

Protected Member Functions inherited from ForwardDetLayer
SimpleDiskBounds const &	bounds () const

virtual void	initialize ()

float	rmax () const

float	rmin () const

void	setSurface (BoundDisk *cp)

float	zmax () const

float	zmin () const

Private Attributes
MTDSectorForwardLayer	theBackLayer

std::vector< const GeomDet * >	theBasicComponents

std::vector< const GeometricSearchDet * >	theComponents

MTDSectorForwardLayer	theFrontLayer

std::vector< const MTDDetSector * >	theSectors

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

Definition at line 11 of file MTDSectorForwardDoubleLayer.h.

Constructor & Destructor Documentation

◆ MTDSectorForwardDoubleLayer()

MTDSectorForwardDoubleLayer::MTDSectorForwardDoubleLayer	(	const std::vector< const MTDDetSector *> &	frontSectors,
		const std::vector< const MTDDetSector *> &	backSectors
	)

Constructor, takes ownership of pointers.

Definition at line 17 of file MTDSectorForwardDoubleLayer.cc.

References basicComponents(), computeSurface(), alignBH_cfg::fixed, LogTrace, selfTest(), ForwardDetLayer::setSurface(), ForwardDetLayer::specificSurface(), theBasicComponents, theComponents, and theSectors.

     : ForwardDetLayer(true),
       theFrontLayer(frontSectors),
       theBackLayer(backSectors),
       theSectors(frontSectors),  // add back later
       theComponents(),
       theBasicComponents() {
   theSectors.insert(theSectors.end(), backSectors.begin(), backSectors.end());
   theComponents = std::vector<const GeometricSearchDet*>(theSectors.begin(), theSectors.end());
 
   // Cache chamber pointers (the basic components_)
   // and find extension in R and Z
   for (const auto& isect : theSectors) {
     vector<const GeomDet*> tmp2 = isect->basicComponents();
     theBasicComponents.insert(theBasicComponents.end(), tmp2.begin(), tmp2.end());
   }
 
   setSurface(computeSurface());
 
   LogTrace("MTDDetLayers") << "Constructing MTDSectorForwardDoubleLayer: " << std::fixed << std::setw(14)
                            << basicComponents().size() << " Dets " << std::setw(14) << theSectors.size() << " Sectors "
                            << " Z: " << std::setw(14) << specificSurface().position().z() << " R1: " << std::setw(14)
                            << specificSurface().innerRadius() << " R2: " << std::setw(14)
                            << specificSurface().outerRadius();
 
   selfTest();
 }

◆ ~MTDSectorForwardDoubleLayer()

MTDSectorForwardDoubleLayer::~MTDSectorForwardDoubleLayer ( )

inlineoverride

Definition at line 17 of file MTDSectorForwardDoubleLayer.h.

17 {}

Member Function Documentation

◆ backLayer()

const MTDSectorForwardLayer* MTDSectorForwardDoubleLayer::backLayer ( ) const

inline

Definition at line 51 of file MTDSectorForwardDoubleLayer.h.

References theBackLayer.

51 { return &theBackLayer; }

MTDSectorForwardDoubleLayer::theBackLayer

MTDSectorForwardLayer theBackLayer

Definition: MTDSectorForwardDoubleLayer.h:60

◆ basicComponents()

const std::vector<const GeomDet*>& MTDSectorForwardDoubleLayer::basicComponents ( ) const

inlineoverridevirtual

Implements GeometricSearchDet.

Definition at line 21 of file MTDSectorForwardDoubleLayer.h.

References theBasicComponents.

Referenced by MTDSectorForwardDoubleLayer().

21 { return theBasicComponents; }

MTDSectorForwardDoubleLayer::theBasicComponents

std::vector< const GeomDet * > theBasicComponents

Definition: MTDSectorForwardDoubleLayer.h:63

◆ compatible()

std::pair< bool, TrajectoryStateOnSurface > MTDSectorForwardDoubleLayer::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 69 of file MTDSectorForwardDoubleLayer.cc.

References funct::abs(), Surface::bounds(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), eleIsoSequence_cff::deltaR, submitPVResolutionJobs::err, TrajectoryStateOnSurface::hasError(), insideOut, isInsideOut(), TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localDirection(), TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localPosition(), LogTrace, ecalPedestalPCLHarvester_cfi::nSigma, LocalTrajectoryError::positionError(), Propagator::propagate(), ForwardDetLayer::rmax(), ForwardDetLayer::rmin(), ForwardDetLayer::specificSurface(), mathSSE::sqrt(), ForwardDetLayer::surface(), funct::tan(), theBackLayer, theFrontLayer, PV3DBase< T, PVType, FrameType >::theta(), Bounds::thickness(), createJobs::tmp, ForwardDetLayer::zmax(), and ForwardDetLayer::zmin().

Referenced by compatibleDets().

                                                                                                                   {
   // mostly copied from ForwardDetLayer, except propagates to closest surface,
   // not to center
 
   bool insideOut = isInsideOut(startingState);
   const MTDSectorForwardLayer& closerLayer = (insideOut) ? theFrontLayer : theBackLayer;
   LogTrace("MTDDetLayers") << "MTDSectorForwardDoubleLayer::compatible is assuming inside-out direction: " << insideOut;
 
   TrajectoryStateOnSurface myState = prop.propagate(startingState, closerLayer.specificSurface());
   if (!myState.isValid())
     return make_pair(false, myState);
 
   // take into account the thickness of the layer
   float deltaR = surface().bounds().thickness() / 2. * std::abs(tan(myState.localDirection().theta()));
 
   // take into account the error on the predicted state
   constexpr float nSigma = 3.;
   if (myState.hasError()) {
     LocalError err = myState.localError().positionError();
     // ignore correlation for the moment...
     deltaR += nSigma * sqrt(err.xx() + err.yy());
   }
 
   float zPos = (zmax() + zmin()) / 2.;
   SimpleDiskBounds tmp(rmin() - deltaR, rmax() + deltaR, zmin() - zPos, zmax() - zPos);
 
   return make_pair(tmp.inside(myState.localPosition()), myState);
 }

◆ compatibleDets()

vector< GeometricSearchDet::DetWithState > MTDSectorForwardDoubleLayer::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 99 of file MTDSectorForwardDoubleLayer.cc.

References compatible(), groupedCompatibleDets(), LogTrace, and mps_fire::result.

                                                                                                                   {
   vector<DetWithState> result;
   pair<bool, TrajectoryStateOnSurface> compat = compatible(startingState, prop, est);
 
   if (!compat.first) {
     LogTrace("MTDDetLayers") << "     MTDSectorForwardDoubleLayer::compatibleDets: not compatible"
                              << " (should not have been selected!)";
     return result;
   }
 
   TrajectoryStateOnSurface& tsos = compat.second;
 
   // standard implementation of compatibleDets() for class which have
   // groupedCompatibleDets implemented.
   // This code should be moved in a common place intead of being
   // copied many times.
   vector<DetGroup> vectorGroups(groupedCompatibleDets(tsos, prop, est));
   for (const auto& thisDG : vectorGroups) {
     for (const auto& thisDGE : thisDG) {
       result.emplace_back(DetWithState(thisDGE.det(), thisDGE.trajectoryState()));
     }
   }
 
   return result;
 }

◆ components()

const std::vector<const GeometricSearchDet*>& MTDSectorForwardDoubleLayer::components ( ) const

inlineoverridevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 23 of file MTDSectorForwardDoubleLayer.h.

References theComponents.

23 { return theComponents; }

MTDSectorForwardDoubleLayer::theComponents

std::vector< const GeometricSearchDet * > theComponents

Definition: MTDSectorForwardDoubleLayer.h:62

◆ computeSurface()

BoundDisk * MTDSectorForwardDoubleLayer::computeSurface ( )

overrideprotectedvirtual

Reimplemented from ForwardDetLayer.

Definition at line 46 of file MTDSectorForwardDoubleLayer.cc.

References WZElectronSkims53X_cff::max, SiStripPI::min, ForwardDetLayer::rmax(), ForwardDetLayer::rmin(), makeMuonMisalignmentScenario::rot, ForwardDetLayer::specificSurface(), theBackLayer, theFrontLayer, ForwardDetLayer::zmax(), and ForwardDetLayer::zmin().

Referenced by MTDSectorForwardDoubleLayer().

                                                        {
   const BoundDisk& frontDisk = theFrontLayer.specificSurface();
   const BoundDisk& backDisk = theBackLayer.specificSurface();
 
   float rmin = min(frontDisk.innerRadius(), backDisk.innerRadius());
   float rmax = max(frontDisk.outerRadius(), backDisk.outerRadius());
   float zmin = frontDisk.position().z();
   float halfThickness = frontDisk.bounds().thickness() / 2.;
   zmin = (zmin > 0) ? zmin - halfThickness : zmin + halfThickness;
   float zmax = backDisk.position().z();
   halfThickness = backDisk.bounds().thickness() / 2.;
   zmax = (zmax > 0) ? zmax + halfThickness : zmax - halfThickness;
   float zPos = (zmax + zmin) / 2.;
   PositionType pos(0., 0., zPos);
   RotationType rot;
 
   return new BoundDisk(pos, rot, new SimpleDiskBounds(rmin, rmax, zmin - zPos, zmax - zPos));
 }

◆ frontLayer()

const MTDSectorForwardLayer* MTDSectorForwardDoubleLayer::frontLayer ( ) const

inline

Definition at line 50 of file MTDSectorForwardDoubleLayer.h.

References theFrontLayer.

50 { return &theFrontLayer; }

MTDSectorForwardDoubleLayer::theFrontLayer

MTDSectorForwardLayer theFrontLayer

Definition: MTDSectorForwardDoubleLayer.h:59

◆ groupedCompatibleDets()

vector< DetGroup > MTDSectorForwardDoubleLayer::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 126 of file MTDSectorForwardDoubleLayer.cc.

References MTDSectorForwardLayer::compatibleDets(), LogTrace, mps_fire::result, theBackLayer, and theFrontLayer.

Referenced by compatibleDets().

                                                                                                            {
   vector<GeometricSearchDet::DetWithState> detWithStates1, detWithStates2;
 
   LogTrace("MTDDetLayers") << "groupedCompatibleDets are currently given always in inside-out order";
   // this should be fixed either in RecoMTD/MeasurementDet/MTDDetLayerMeasurements or
   // RecoMTD/DetLayers/MTDSectorForwardDoubleLayer
 
   detWithStates1 = theFrontLayer.compatibleDets(startingState, prop, est);
   detWithStates2 = theBackLayer.compatibleDets(startingState, prop, est);
 
   vector<DetGroup> result;
   if (!detWithStates1.empty())
     result.push_back(DetGroup(detWithStates1));
   if (!detWithStates2.empty())
     result.push_back(DetGroup(detWithStates2));
   LogTrace("MTDDetLayers") << "DoubleLayer Compatible dets: " << result.size();
   return result;
 }

◆ isCrack()

bool MTDSectorForwardDoubleLayer::isCrack ( const GlobalPoint & gp ) const

Definition at line 147 of file MTDSectorForwardDoubleLayer.cc.

References LogTrace, and mps_fire::result.

                                                                      {
   bool result = false;
   LogTrace("MTDDetLayers")
       << "MTDSectorForwardDoubleLayer::isCrack kept only for backward compatibility, no real implementation";
   return result;
 }

◆ isInsideOut()

bool MTDSectorForwardDoubleLayer::isInsideOut ( const TrajectoryStateOnSurface & tsos ) const

Definition at line 65 of file MTDSectorForwardDoubleLayer.cc.

References PV3DBase< T, PVType, FrameType >::basicVector(), Basic3DVector< T >::dot(), TrajectoryStateOnSurface::globalMomentum(), and TrajectoryStateOnSurface::globalPosition().

Referenced by compatible().

                                                                                         {
   return tsos.globalPosition().basicVector().dot(tsos.globalMomentum().basicVector()) > 0;
 }

◆ sectors()

virtual const std::vector<const MTDDetSector*>& MTDSectorForwardDoubleLayer::sectors ( ) const

inlinevirtual

Return the vector of sectors.

Definition at line 46 of file MTDSectorForwardDoubleLayer.h.

References theSectors.

46 { return theSectors; }

MTDSectorForwardDoubleLayer::theSectors

std::vector< const MTDDetSector * > theSectors

Definition: MTDSectorForwardDoubleLayer.h:61

◆ selfTest()

void MTDSectorForwardDoubleLayer::selfTest ( ) const

Definition at line 154 of file MTDSectorForwardDoubleLayer.cc.

References funct::abs(), cms::cuda::assert(), MTDSectorForwardLayer::basicComponents(), theBackLayer, and theFrontLayer.

Referenced by MTDSectorForwardDoubleLayer().

                                                  {
   const std::vector<const GeomDet*>& frontDets = theFrontLayer.basicComponents();
   const std::vector<const GeomDet*>& backDets = theBackLayer.basicComponents();
 
   // test that each front z is less than each back z
   float frontz(0.);
   float backz(1e3f);
   for (const auto& thisFront : frontDets) {
     float tmpz(std::abs(thisFront->surface().position().z()));
     if (tmpz > frontz) {
       frontz = tmpz;
     }
   }
   for (const auto& thisBack : backDets) {
     float tmpz(std::abs(thisBack->surface().position().z()));
     if (tmpz < backz) {
       backz = tmpz;
     }
   }
   assert(frontz < backz);
 }