CMS 3D CMS Logo
List of all members | Public Member Functions | Private Member Functions | Private Attributes
PixelBlade Class Referencefinal

#include <PixelBlade.h>

Inheritance diagram for PixelBlade:
GeometricSearchDet

Public Member Functions

const std::vector< const GeomDet * > & basicComponents () const override
 
std::pair< bool, TrajectoryStateOnSurface > compatible (const TrajectoryStateOnSurface &ts, const Propagator &, const MeasurementEstimator &) const override __attribute__((cold))
 
const std::vector< const GeometricSearchDet * > & components () const override __attribute__((cold))
 Returns basic components, if any. More...
 
void groupedCompatibleDetsV (const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetGroup > &result) const override __attribute__((hot))
 
 PixelBlade (std::vector< const GeomDet * > &frontDets, std::vector< const GeomDet * > &backDets) __attribute__((cold))
 
virtual const BoundDiskSector & specificSurface () const
 
const BoundSurface & surface () const override
 The surface of the GeometricSearchDet. More...
 
 ~PixelBlade () override __attribute__((cold))
 
- Public Member Functions inherited from GeometricSearchDet
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
 
 GeometricSearchDet (bool doHaveGroups)
 
virtual std::vector< DetGroup > groupedCompatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const
 
bool hasGroups () const
 
virtual const Surface::PositionType & position () const
 Returns position of the surface. More...
 
virtual ~GeometricSearchDet ()
 

Private Member Functions

bool addClosest (const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est, const SubLayerCrossing &crossing, std::vector< DetGroup > &result) const __attribute__((hot))
 
SubLayerCrossings computeCrossings (const TrajectoryStateOnSurface &tsos, PropagationDirection propDir) const __attribute__((hot))
 
float computeWindowSize (const GeomDet *det, const TrajectoryStateOnSurface &tsos, const MeasurementEstimator &est) const
 
int findBin (float R, int layer) const
 
GlobalPoint findPosition (int index, int diskSectorIndex) const
 
bool overlap (const GlobalPoint &gpos, const GeomDet &det, float phiWin) const
 
void searchNeighbors (const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est, const SubLayerCrossing &crossing, float window, std::vector< DetGroup > &result, bool checkClosest) const __attribute__((hot))
 
const std::vector< const GeomDet * > & subBlade (int ind) const
 

Private Attributes

std::vector< const GeomDet * > theBackDets
 
ReferenceCountingPointer< BoundDiskSector > theBackDiskSector
 
std::vector< const GeomDet * > theDets
 
ReferenceCountingPointer< BoundDiskSector > theDiskSector
 
std::vector< const GeomDet * > theFrontDets
 
ReferenceCountingPointer< BoundDiskSector > theFrontDiskSector
 

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 Attributes inherited from GeometricSearchDet
bool haveGroups
 
GeomDetCompatibilityChecker theCompatibilityChecker
 

Detailed Description

A concrete implementation for PixelBlade

Definition at line 14 of file PixelBlade.h.

Constructor & Destructor Documentation

◆ PixelBlade()

PixelBlade::PixelBlade ( std::vector< const GeomDet * > &  frontDets,
std::vector< const GeomDet * > &  backDets 
)

Definition at line 20 of file PixelBlade.cc.

21  : GeometricSearchDet(true), theFrontDets(frontDets), theBackDets(backDets) {
22  theDets.assign(theFrontDets.begin(), theFrontDets.end());
23  theDets.insert(theDets.end(), theBackDets.begin(), theBackDets.end());
24 
25  theDiskSector = BladeShapeBuilderFromDet::build(theDets);
26  theFrontDiskSector = BladeShapeBuilderFromDet::build(theFrontDets);
27  theBackDiskSector = BladeShapeBuilderFromDet::build(theBackDets);
28 
29  //--------- DEBUG INFO --------------
30  LogDebug("TkDetLayers") << "DEBUG INFO for PixelBlade";
31  LogDebug("TkDetLayers") << "Blade z, perp, innerRadius, outerR: " << this->position().z() << " , "
32  << this->position().perp() << " , " << theDiskSector->innerRadius() << " , "
33  << theDiskSector->outerRadius();
34 
35  for (vector<const GeomDet*>::const_iterator it = theFrontDets.begin(); it != theFrontDets.end(); it++) {
36  LogDebug("TkDetLayers") << "frontDet phi,z,r: " << (*it)->position().phi() << " , " << (*it)->position().z()
37  << " , " << (*it)->position().perp();
38  ;
39  }
40 
41  for (vector<const GeomDet*>::const_iterator it = theBackDets.begin(); it != theBackDets.end(); it++) {
42  LogDebug("TkDetLayers") << "backDet phi,z,r: " << (*it)->position().phi() << " , " << (*it)->position().z() << " , "
43  << (*it)->position().perp();
44  }
45  //-----------------------------------
46 }

References BladeShapeBuilderFromDet::build(), LogDebug, PV3DBase< T, PVType, FrameType >::perp(), GeometricSearchDet::position(), theBackDets, theBackDiskSector, theDets, theDiskSector, theFrontDets, theFrontDiskSector, and PV3DBase< T, PVType, FrameType >::z().

◆ ~PixelBlade()

PixelBlade::~PixelBlade ( )
override

Definition at line 18 of file PixelBlade.cc.

18 {}

Member Function Documentation

◆ addClosest()

bool PixelBlade::addClosest ( const TrajectoryStateOnSurface &  tsos,
const Propagator &  prop,
const MeasurementEstimator &  est,
const SubLayerCrossing &  crossing,
std::vector< DetGroup > &  result 
) const
private

Definition at line 136 of file PixelBlade.cc.

140  {
141  const vector<const GeomDet*>& sBlade(subBlade(crossing.subLayerIndex()));
142  return CompatibleDetToGroupAdder().add(*sBlade[crossing.closestDetIndex()], tsos, prop, est, result);
143 }

References CompatibleDetToGroupAdder::add(), SubLayerCrossing::closestDetIndex(), mps_fire::result, subBlade(), and SubLayerCrossing::subLayerIndex().

Referenced by groupedCompatibleDetsV().

◆ basicComponents()

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

Implements GeometricSearchDet.

Definition at line 23 of file PixelBlade.h.

23 { return theDets; }

References theDets.

◆ compatible()

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

54  {
55  edm::LogError("TkDetLayers") << "temporary dummy implementation of PixelBlade::compatible()!!";
56  return pair<bool, TrajectoryStateOnSurface>();
57 }

◆ components()

const vector< const GeometricSearchDet * > & PixelBlade::components ( ) const
overridevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 48 of file PixelBlade.cc.

48  {
49  throw DetLayerException("TOBRod doesn't have GeometricSearchDet components");
50 }

◆ computeCrossings()

SubLayerCrossings PixelBlade::computeCrossings ( const TrajectoryStateOnSurface &  tsos,
PropagationDirection  propDir 
) const
private

Definition at line 97 of file PixelBlade.cc.

98  {
99  HelixPlaneCrossing::PositionType startPos(startingState.globalPosition());
100  HelixPlaneCrossing::DirectionType startDir(startingState.globalMomentum());
101  double rho(startingState.transverseCurvature());
102 
103  HelixArbitraryPlaneCrossing crossing(startPos, startDir, rho, propDir);
104 
105  pair<bool, double> innerPath = crossing.pathLength(*theFrontDiskSector);
106  if (!innerPath.first)
107  return SubLayerCrossings();
108 
109  GlobalPoint gInnerPoint(crossing.position(innerPath.second));
110  //Code for use of binfinder
111  //int innerIndex = theInnerBinFinder.binIndex(gInnerPoint.perp());
112  //float innerDist = std::abs( theInnerBinFinder.binPosition(innerIndex) - gInnerPoint.z());
113  int innerIndex = findBin(gInnerPoint.perp(), 0);
114  float innerDist = std::abs(findPosition(innerIndex, 0).perp() - gInnerPoint.perp());
115  SubLayerCrossing innerSLC(0, innerIndex, gInnerPoint);
116 
117  pair<bool, double> outerPath = crossing.pathLength(*theBackDiskSector);
118  if (!outerPath.first)
119  return SubLayerCrossings();
120 
121  GlobalPoint gOuterPoint(crossing.position(outerPath.second));
122  //Code for use of binfinder
123  //int outerIndex = theOuterBinFinder.binIndex(gOuterPoint.perp());
124  //float outerDist = std::abs( theOuterBinFinder.binPosition(outerIndex) - gOuterPoint.perp());
125  int outerIndex = findBin(gOuterPoint.perp(), 1);
126  float outerDist = std::abs(findPosition(outerIndex, 1).perp() - gOuterPoint.perp());
127  SubLayerCrossing outerSLC(1, outerIndex, gOuterPoint);
128 
129  if (innerDist < outerDist) {
130  return SubLayerCrossings(innerSLC, outerSLC, 0);
131  } else {
132  return SubLayerCrossings(outerSLC, innerSLC, 1);
133  }
134 }

References funct::abs(), findBin(), findPosition(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), perp(), rho, theBackDiskSector, theFrontDiskSector, and TrajectoryStateOnSurface::transverseCurvature().

Referenced by groupedCompatibleDetsV().

◆ computeWindowSize()

float PixelBlade::computeWindowSize ( const GeomDet *  det,
const TrajectoryStateOnSurface &  tsos,
const MeasurementEstimator &  est 
) const
private

Definition at line 145 of file PixelBlade.cc.

147  {
148  return est.maximalLocalDisplacement(tsos, det->surface()).x();
149 }

References MeasurementEstimator::maximalLocalDisplacement(), GeomDet::surface(), and x.

Referenced by groupedCompatibleDetsV().

◆ findBin()

int PixelBlade::findBin ( float  R,
int  layer 
) const
private

Definition at line 214 of file PixelBlade.cc.

214  {
215  vector<const GeomDet*> localDets = diskSectorIndex == 0 ? theFrontDets : theBackDets;
216 
217  int theBin = 0;
218  float rDiff = std::abs(R - localDets.front()->surface().position().perp());
219  ;
220  for (vector<const GeomDet*>::const_iterator i = localDets.begin(); i != localDets.end(); i++) {
221  float testDiff = std::abs(R - (**i).surface().position().perp());
222  if (testDiff < rDiff) {
223  rDiff = testDiff;
224  theBin = i - localDets.begin();
225  }
226  }
227  return theBin;
228 }

References funct::abs(), mps_fire::i, dttmaxenums::R, theBackDets, and theFrontDets.

Referenced by computeCrossings().

◆ findPosition()

GlobalPoint PixelBlade::findPosition ( int  index,
int  diskSectorIndex 
) const
private

Definition at line 230 of file PixelBlade.cc.

230  {
231  vector<const GeomDet*> diskSector = diskSectorType == 0 ? theFrontDets : theBackDets;
232  return (diskSector[index])->surface().position();
233 }

References theBackDets, and theFrontDets.

Referenced by computeCrossings().

◆ groupedCompatibleDetsV()

void PixelBlade::groupedCompatibleDetsV ( const TrajectoryStateOnSurface &  tsos,
const Propagator &  prop,
const MeasurementEstimator &  est,
std::vector< DetGroup > &  result 
) const
overridevirtual

Reimplemented from GeometricSearchDet.

Definition at line 59 of file PixelBlade.cc.

62  {
63  SubLayerCrossings crossings;
64  crossings = computeCrossings(tsos, prop.propagationDirection());
65  if (!crossings.isValid())
66  return;
67 
68  vector<DetGroup> closestResult;
69  addClosest(tsos, prop, est, crossings.closest(), closestResult);
70 
71  if (closestResult.empty()) {
72  vector<DetGroup> nextResult;
73  addClosest(tsos, prop, est, crossings.other(), nextResult);
74  if (nextResult.empty())
75  return;
76 
77  DetGroupElement nextGel(nextResult.front().front());
78  int crossingSide = LayerCrossingSide().endcapSide(nextGel.trajectoryState(), prop);
79 
80  DetGroupMerger::orderAndMergeTwoLevels(
81  std::move(closestResult), std::move(nextResult), result, crossings.closestIndex(), crossingSide);
82  } else {
83  DetGroupElement closestGel(closestResult.front().front());
84  float window = computeWindowSize(closestGel.det(), closestGel.trajectoryState(), est);
85 
86  searchNeighbors(tsos, prop, est, crossings.closest(), window, closestResult, false);
87 
88  vector<DetGroup> nextResult;
89  searchNeighbors(tsos, prop, est, crossings.other(), window, nextResult, true);
90 
91  int crossingSide = LayerCrossingSide().endcapSide(closestGel.trajectoryState(), prop);
92  DetGroupMerger::orderAndMergeTwoLevels(
93  std::move(closestResult), std::move(nextResult), result, crossings.closestIndex(), crossingSide);
94  }
95 }

References addClosest(), SubLayerCrossings::closest(), SubLayerCrossings::closestIndex(), computeCrossings(), computeWindowSize(), LayerCrossingSide::endcapSide(), SubLayerCrossings::isValid(), eostools::move(), DetGroupMerger::orderAndMergeTwoLevels(), SubLayerCrossings::other(), Propagator::propagationDirection(), mps_fire::result, searchNeighbors(), and svgfig::window().

◆ overlap()

bool PixelBlade::overlap ( const GlobalPoint &  gpos,
const GeomDet &  det,
float  phiWin 
) const
private

Definition at line 189 of file PixelBlade.cc.

189  {
190  // check if the z window around TSOS overlaps with the detector theDet (with a 1% margin added)
191 
192  // const float tolerance = 0.1;
193  const float relativeMargin = 1.01;
194 
195  LocalPoint localCrossPoint(det.surface().toLocal(crossPoint));
196  // if (std::abs(localCrossPoint.z()) > tolerance) {
197  // edm::LogInfo(TkDetLayers) << "PixelBlade::overlap calculation assumes point on surface, but it is off by "
198  // << localCrossPoint.z() ;
199  // }
200 
201  float localX = localCrossPoint.x();
202  float detHalfLength = det.surface().bounds().length() / 2.;
203 
204  // edm::LogInfo(TkDetLayers) << "PixelBlade::overlap: Det at " << det.position() << " hit at " << localY
205  // << " Window " << window << " halflength " << detHalfLength ;
206 
207  if ((std::abs(localX) - window) < relativeMargin * detHalfLength) { // FIXME: margin hard-wired!
208  return true;
209  } else {
210  return false;
211  }
212 }

References funct::abs(), Surface::bounds(), Bounds::length(), phase1PixelTopology::localX(), GeomDet::surface(), GloballyPositioned< T >::toLocal(), and svgfig::window().

Referenced by searchNeighbors().

◆ searchNeighbors()

void PixelBlade::searchNeighbors ( const TrajectoryStateOnSurface &  tsos,
const Propagator &  prop,
const MeasurementEstimator &  est,
const SubLayerCrossing &  crossing,
float  window,
std::vector< DetGroup > &  result,
bool  checkClosest 
) const
private

Definition at line 151 of file PixelBlade.cc.

157  {
158  const GlobalPoint& gCrossingPos = crossing.position();
159 
160  const vector<const GeomDet*>& sBlade(subBlade(crossing.subLayerIndex()));
161 
162  int closestIndex = crossing.closestDetIndex();
163  int negStartIndex = closestIndex - 1;
164  int posStartIndex = closestIndex + 1;
165 
166  if (checkClosest) { // must decide if the closest is on the neg or pos side
167  if (gCrossingPos.perp() < sBlade[closestIndex]->surface().position().perp()) {
168  posStartIndex = closestIndex;
169  } else {
170  negStartIndex = closestIndex;
171  }
172  }
173 
174  typedef CompatibleDetToGroupAdder Adder;
175  for (int idet = negStartIndex; idet >= 0; idet--) {
176  if (!overlap(gCrossingPos, *sBlade[idet], window))
177  break;
178  if (!Adder::add(*sBlade[idet], tsos, prop, est, result))
179  break;
180  }
181  for (int idet = posStartIndex; idet < static_cast<int>(sBlade.size()); idet++) {
182  if (!overlap(gCrossingPos, *sBlade[idet], window))
183  break;
184  if (!Adder::add(*sBlade[idet], tsos, prop, est, result))
185  break;
186  }
187 }

References PVValHelper::add(), SubLayerCrossing::closestDetIndex(), overlap(), PV3DBase< T, PVType, FrameType >::perp(), SubLayerCrossing::position(), mps_fire::result, subBlade(), SubLayerCrossing::subLayerIndex(), and svgfig::window().

Referenced by groupedCompatibleDetsV().

◆ specificSurface()

virtual const BoundDiskSector& PixelBlade::specificSurface ( ) const
inlinevirtual

Definition at line 38 of file PixelBlade.h.

38 { return *theDiskSector; }

References theDiskSector.

◆ subBlade()

const std::vector<const GeomDet*>& PixelBlade::subBlade ( int  ind) const
inlineprivate

Definition at line 73 of file PixelBlade.h.

73 { return (ind == 0 ? theFrontDets : theBackDets); }

References theBackDets, and theFrontDets.

Referenced by addClosest(), and searchNeighbors().

◆ surface()

const BoundSurface& PixelBlade::surface ( ) const
inlineoverridevirtual

The surface of the GeometricSearchDet.

Implements GeometricSearchDet.

Definition at line 21 of file PixelBlade.h.

21 { return *theDiskSector; }

References theDiskSector.

Member Data Documentation

◆ theBackDets

std::vector<const GeomDet*> PixelBlade::theBackDets
private

Definition at line 78 of file PixelBlade.h.

Referenced by findBin(), findPosition(), PixelBlade(), and subBlade().

◆ theBackDiskSector

ReferenceCountingPointer<BoundDiskSector> PixelBlade::theBackDiskSector
private

Definition at line 82 of file PixelBlade.h.

Referenced by computeCrossings(), and PixelBlade().

◆ theDets

std::vector<const GeomDet*> PixelBlade::theDets
private

Definition at line 76 of file PixelBlade.h.

Referenced by basicComponents(), and PixelBlade().

◆ theDiskSector

ReferenceCountingPointer<BoundDiskSector> PixelBlade::theDiskSector
private

Definition at line 80 of file PixelBlade.h.

Referenced by PixelBlade(), specificSurface(), and surface().

◆ theFrontDets

std::vector<const GeomDet*> PixelBlade::theFrontDets
private

Definition at line 77 of file PixelBlade.h.

Referenced by findBin(), findPosition(), PixelBlade(), and subBlade().

◆ theFrontDiskSector

ReferenceCountingPointer<BoundDiskSector> PixelBlade::theFrontDiskSector
private

Definition at line 81 of file PixelBlade.h.

Referenced by computeCrossings(), and PixelBlade().

SubLayerCrossing::position
const GlobalPoint & position() const
Definition: SubLayerCrossings.h:14
PixelBlade::overlap
bool overlap(const GlobalPoint &gpos, const GeomDet &det, float phiWin) const
Definition: PixelBlade.cc:189
SubLayerCrossings::isValid
bool isValid()
Definition: SubLayerCrossings.h:28
mps_fire.i
i
Definition: mps_fire.py:428
GeometricSearchDet::GeometricSearchDet
GeometricSearchDet(bool doHaveGroups)
Definition: GeometricSearchDet.h:24
LayerCrossingSide
Definition: LayerCrossingSide.h:15
SubLayerCrossings::closestIndex
int closestIndex() const
Definition: SubLayerCrossings.h:31
svgfig.window
def window(xmin, xmax, ymin, ymax, x=0, y=0, width=100, height=100, xlogbase=None, ylogbase=None, minusInfinity=-1000, flipx=False, flipy=True)
Definition: svgfig.py:643
DDAxes::x
GeometricSearchDet::position
virtual const Surface::PositionType & position() const
Returns position of the surface.
Definition: GeometricSearchDet.h:31
perp
T perp() const
Magnitude of transverse component.
Definition: Basic3DVectorLD.h:133
Bounds::length
virtual float length() const =0
PV3DBase::z
T z() const
Definition: PV3DBase.h:61
PixelBlade::subBlade
const std::vector< const GeomDet * > & subBlade(int ind) const
Definition: PixelBlade.h:73
PixelBlade::theDets
std::vector< const GeomDet * > theDets
Definition: PixelBlade.h:76
GeomDet::surface
const Plane & surface() const
The nominal surface of the GeomDet.
Definition: GeomDet.h:37
LayerCrossingSide::endcapSide
static int endcapSide(const TrajectoryStateOnSurface &startingState, const Propagator &prop)
Definition: LayerCrossingSide.h:31
PixelBlade::theDiskSector
ReferenceCountingPointer< BoundDiskSector > theDiskSector
Definition: PixelBlade.h:80
PixelBlade::searchNeighbors
void searchNeighbors(const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est, const SubLayerCrossing &crossing, float window, std::vector< DetGroup > &result, bool checkClosest) const __attribute__((hot))
Definition: PixelBlade.cc:151
PixelBlade::computeWindowSize
float computeWindowSize(const GeomDet *det, const TrajectoryStateOnSurface &tsos, const MeasurementEstimator &est) const
Definition: PixelBlade.cc:145
Surface::bounds
const Bounds & bounds() const
Definition: Surface.h:87
Propagator::propagationDirection
virtual PropagationDirection propagationDirection() const final
Definition: Propagator.h:139
HelixArbitraryPlaneCrossing
Definition: HelixArbitraryPlaneCrossing.h:10
Point3DBase< float, GlobalTag >
DetGroupMerger::orderAndMergeTwoLevels
static void orderAndMergeTwoLevels(std::vector< DetGroup > &&one, std::vector< DetGroup > &&two, std::vector< DetGroup > &result, int firstIndex, int firstCrossed)
Definition: DetGroupMerger.cc:6
DDAxes::rho
PixelBlade::computeCrossings
SubLayerCrossings computeCrossings(const TrajectoryStateOnSurface &tsos, PropagationDirection propDir) const __attribute__((hot))
Definition: PixelBlade.cc:97
phase1PixelTopology::localX
constexpr uint16_t localX(uint16_t px)
Definition: phase1PixelTopology.h:142
PixelBlade::findBin
int findBin(float R, int layer) const
Definition: PixelBlade.cc:214
CompatibleDetToGroupAdder::add
static bool add(const GeometricSearchDet &det, const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetGroup > &result) __attribute__((hot))
Definition: CompatibleDetToGroupAdder.cc:7
SubLayerCrossings::closest
const SubLayerCrossing & closest() const
Definition: SubLayerCrossings.h:29
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233
BladeShapeBuilderFromDet::build
static BoundDiskSector * build(const std::vector< const GeomDet * > &dets) __attribute__((cold))
Definition: BladeShapeBuilderFromDet.cc:109
PixelBlade::theBackDiskSector
ReferenceCountingPointer< BoundDiskSector > theBackDiskSector
Definition: PixelBlade.h:82
PVValHelper::add
void add(std::map< std::string, TH1 * > &h, TH1 *hist)
Definition: PVValidationHelpers.cc:12
PixelBlade::theFrontDiskSector
ReferenceCountingPointer< BoundDiskSector > theFrontDiskSector
Definition: PixelBlade.h:81
SubLayerCrossing::closestDetIndex
int closestDetIndex() const
Definition: SubLayerCrossings.h:13
DetGroupElement
Definition: DetGroup.h:10
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
PixelBlade::addClosest
bool addClosest(const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est, const SubLayerCrossing &crossing, std::vector< DetGroup > &result) const __attribute__((hot))
Definition: PixelBlade.cc:136
DetLayerException
Common base class.
Definition: DetLayerException.h:15
PixelBlade::theFrontDets
std::vector< const GeomDet * > theFrontDets
Definition: PixelBlade.h:77
eostools.move
def move(src, dest)
Definition: eostools.py:511
PixelBlade::theBackDets
std::vector< const GeomDet * > theBackDets
Definition: PixelBlade.h:78
GloballyPositioned::toLocal
LocalPoint toLocal(const GlobalPoint &gp) const
Definition: GloballyPositioned.h:98
CompatibleDetToGroupAdder
Definition: CompatibleDetToGroupAdder.h:13
SubLayerCrossings::other
const SubLayerCrossing & other() const
Definition: SubLayerCrossings.h:30
AlignmentPI::index
index
Definition: AlignmentPayloadInspectorHelper.h:46
SubLayerCrossing
Definition: SubLayerCrossings.h:7
SubLayerCrossing::subLayerIndex
int subLayerIndex() const
Definition: SubLayerCrossings.h:12
mps_fire.result
result
Definition: mps_fire.py:311
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
PixelBlade::findPosition
GlobalPoint findPosition(int index, int diskSectorIndex) const
Definition: PixelBlade.cc:230
dttmaxenums::R
Definition: DTTMax.h:29
PV3DBase::perp
T perp() const
Definition: PV3DBase.h:69
Basic3DVector< float >
MeasurementEstimator::maximalLocalDisplacement
virtual Local2DVector maximalLocalDisplacement(const TrajectoryStateOnSurface &ts, const Plane &plane) const =0
SubLayerCrossings
Definition: SubLayerCrossings.h:22
Generated for CMSSW Reference Manual by doxygen 1.8.16