#include <Phase1PixelBlade.h>

Inheritance diagram for Phase1PixelBlade:

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

	Phase1PixelBlade (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...

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

std::pair< float, float >	computeRadiusRanges (const std::vector< const GeomDet * > &)

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

int	findBin (float R, int layer) const

int	findBin2 (GlobalPoint thispoint, 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::pair< float, float >	back_radius_range_

std::pair< float, float >	front_radius_range_

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 Phase1PixelBlade

Definition at line 16 of file Phase1PixelBlade.h.

Constructor & Destructor Documentation

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

Definition at line 21 of file Phase1PixelBlade.cc.

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

     : GeometricSearchDet(true),
       theFrontDets(frontDets),
       theBackDets(backDets),
       front_radius_range_(std::make_pair(0, 0)),
       back_radius_range_(std::make_pair(0, 0)) {
   theDets.assign(theFrontDets.begin(), theFrontDets.end());
   theDets.insert(theDets.end(), theBackDets.begin(), theBackDets.end());
 
   theDiskSector = BladeShapeBuilderFromDet::build(theDets);
   theFrontDiskSector = BladeShapeBuilderFromDet::build(theFrontDets);
   theBackDiskSector = BladeShapeBuilderFromDet::build(theBackDets);
 
   //--------- DEBUG INFO --------------
   LogDebug("TkDetLayers") << "DEBUG INFO for Phase1PixelBlade";
   LogDebug("TkDetLayers") << "Blade z, perp, innerRadius, outerR[disk, front, back]: " << this->position().z() << " , "
                           << this->position().perp() << " , (" << theDiskSector->innerRadius() << " , "
                           << theDiskSector->outerRadius() << "), (" << theFrontDiskSector->innerRadius() << " , "
                           << theFrontDiskSector->outerRadius() << "), (" << theBackDiskSector->innerRadius() << " , "
                           << theBackDiskSector->outerRadius() << ")" << std::endl;
 
   for (vector<const GeomDet*>::const_iterator it = theFrontDets.begin(); it != theFrontDets.end(); it++) {
     LogDebug("TkDetLayers") << "frontDet phi,z,r: " << (*it)->position().phi() << " , " << (*it)->position().z()
                             << " , " << (*it)->position().perp() << " , "
                             << " rmin: " << (*it)->surface().rSpan().first
                             << " rmax: " << (*it)->surface().rSpan().second << std::endl;
   }
 
   for (vector<const GeomDet*>::const_iterator it = theBackDets.begin(); it != theBackDets.end(); it++) {
     LogDebug("TkDetLayers") << "backDet phi,z,r: " << (*it)->position().phi() << " , " << (*it)->position().z() << " , "
                             << (*it)->position().perp() << " , "
                             << " rmin: " << (*it)->surface().rSpan().first
                             << " rmax: " << (*it)->surface().rSpan().second << std::endl;
   }
 }

Phase1PixelBlade::~Phase1PixelBlade ( )

override

Definition at line 19 of file Phase1PixelBlade.cc.

19 {}

Member Function Documentation

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

private

Definition at line 162 of file Phase1PixelBlade.cc.

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

Referenced by groupedCompatibleDetsV().

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

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

inlineoverridevirtual

Implements GeometricSearchDet.

Definition at line 25 of file Phase1PixelBlade.h.

References theDets.

25 { return theDets; }

Phase1PixelBlade::theDets

std::vector< const GeomDet * > theDets

Definition: Phase1PixelBlade.h:81

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

                                                                                                      {
   edm::LogError("TkDetLayers") << "temporary dummy implementation of Phase1PixelBlade::compatible()!!";
   return pair<bool, TrajectoryStateOnSurface>();
 }

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

overridevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 57 of file Phase1PixelBlade.cc.

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

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

private

Definition at line 115 of file Phase1PixelBlade.cc.

References findBin2(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), mag(), rho, theBackDiskSector, theFrontDiskSector, and TrajectoryStateOnSurface::transverseCurvature().

Referenced by groupedCompatibleDetsV().

                                                                                          {
   HelixPlaneCrossing::PositionType startPos(startingState.globalPosition());
   HelixPlaneCrossing::DirectionType startDir(startingState.globalMomentum());
   double rho(startingState.transverseCurvature());
   HelixArbitraryPlaneCrossing crossing(startPos, startDir, rho, propDir);
 
   pair<bool, double> innerPath = crossing.pathLength(*theFrontDiskSector);
   if (!innerPath.first)
     return SubLayerCrossings();
 
   GlobalPoint gInnerPoint(crossing.position(innerPath.second));
   //Code for use of binfinder
   //int innerIndex = theInnerBinFinder.binIndex(gInnerPoint.perp());
   //float innerDist = std::abs( theInnerBinFinder.binPosition(innerIndex) - gInnerPoint.z());
 
   //  int innerIndex = findBin(gInnerPoint.perp(),0);
   int innerIndex = findBin2(gInnerPoint, 0);
 
   //fixme gc patched for SLHC - force order here to be in z
   //float innerDist = std::abs( findPosition(innerIndex,0).perp() - gInnerPoint.perp());
   float innerDist = (startingState.globalPosition() - gInnerPoint).mag();
   SubLayerCrossing innerSLC(0, innerIndex, gInnerPoint);
 
   pair<bool, double> outerPath = crossing.pathLength(*theBackDiskSector);
   if (!outerPath.first)
     return SubLayerCrossings();
 
   GlobalPoint gOuterPoint(crossing.position(outerPath.second));
   //Code for use of binfinder
   //int outerIndex = theOuterBinFinder.binIndex(gOuterPoint.perp());
   //float outerDist = std::abs( theOuterBinFinder.binPosition(outerIndex) - gOuterPoint.perp());
   //  int outerIndex  = findBin(gOuterPoint.perp(),1);
   int outerIndex = findBin2(gOuterPoint, 1);
 
   //fixme gc patched for SLHC - force order here to be in z
   //float outerDist = std::abs( findPosition(outerIndex,1).perp() - gOuterPoint.perp());
   float outerDist = (startingState.globalPosition() - gOuterPoint).mag();
   SubLayerCrossing outerSLC(1, outerIndex, gOuterPoint);
 
   if (innerDist < outerDist) {
     return SubLayerCrossings(innerSLC, outerSLC, 0);
   } else {
     return SubLayerCrossings(outerSLC, innerSLC, 1);
   }
 }

std::pair< float, float > Phase1PixelBlade::computeRadiusRanges ( const std::vector< const GeomDet * > & current_dets )

private

Definition at line 276 of file Phase1PixelBlade.cc.

References BoundingBox::corners(), Vector3DBase< T, FrameTag >::cross(), mps_fire::i, SiStripPI::max, min(), PV3DBase< T, PVType, FrameType >::perp(), GloballyPositioned< T >::position(), alignCSCRings::r, idealTransformation::rotation, Surface::toGlobal(), GloballyPositioned< T >::toLocal(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), PV3DBase< T, PVType, FrameType >::z(), and MetAnalyzer::zAxis.

                                                                                                          {
   typedef Surface::PositionType::BasicVectorType Vector;
   Vector posSum(0, 0, 0);
   for (auto i : current_dets)
     posSum += (*i).surface().position().basicVector();
 
   Surface::PositionType meanPos(0., 0., posSum.z() / float(current_dets.size()));
 
   // temporary plane - for the computation of bounds
   const Plane& tmpplane = current_dets.front()->surface();
 
   GlobalVector xAxis;
   GlobalVector yAxis;
   GlobalVector zAxis;
 
   GlobalVector planeXAxis = tmpplane.toGlobal(LocalVector(1, 0, 0));
   const GlobalPoint& planePosition = tmpplane.position();
 
   if (planePosition.x() * planeXAxis.x() + planePosition.y() * planeXAxis.y() > 0.) {
     yAxis = planeXAxis;
   } else {
     yAxis = -planeXAxis;
   }
 
   GlobalVector planeZAxis = tmpplane.toGlobal(LocalVector(0, 0, 1));
   if (planeZAxis.z() * planePosition.z() > 0.) {
     zAxis = planeZAxis;
   } else {
     zAxis = -planeZAxis;
   }
 
   xAxis = yAxis.cross(zAxis);
 
   Surface::RotationType rotation = Surface::RotationType(xAxis, yAxis);
   Plane plane(meanPos, rotation);
 
   Surface::PositionType tmpPos = current_dets.front()->surface().position();
 
   float rmin(plane.toLocal(tmpPos).perp());
   float rmax(plane.toLocal(tmpPos).perp());
 
   for (auto it : current_dets) {
     vector<GlobalPoint> corners = BoundingBox().corners(it->specificSurface());
     for (const auto& i : corners) {
       float r = plane.toLocal(i).perp();
       rmin = min(rmin, r);
       rmax = max(rmax, r);
     }
   }
 
   return std::make_pair(rmin, rmax);
 }

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

private

Definition at line 172 of file Phase1PixelBlade.cc.

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

Referenced by groupedCompatibleDetsV().

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

int Phase1PixelBlade::findBin	(	float	R,
		int	layer
	)		const

private

Definition at line 240 of file Phase1PixelBlade.cc.

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

                                                                 {
   vector<const GeomDet*> localDets = diskSectorIndex == 0 ? theFrontDets : theBackDets;
 
   int theBin = 0;
   float rDiff = std::abs(R - localDets.front()->surface().position().perp());
   for (vector<const GeomDet*>::const_iterator i = localDets.begin(); i != localDets.end(); i++) {
     float testDiff = std::abs(R - (**i).surface().position().perp());
     if (testDiff < rDiff) {
       rDiff = testDiff;
       theBin = i - localDets.begin();
     }
   }
   return theBin;
 }

int Phase1PixelBlade::findBin2	(	GlobalPoint	thispoint,
		int	layer
	)		const

private

Definition at line 255 of file Phase1PixelBlade.cc.

References mps_fire::i, mag(), theBackDets, and theFrontDets.

Referenced by computeCrossings().

                                                                                {
   const vector<const GeomDet*>& localDets = diskSectorIndex == 0 ? theFrontDets : theBackDets;
 
   int theBin = 0;
   float sDiff = (thispoint - localDets.front()->surface().position()).mag();
 
   for (vector<const GeomDet*>::const_iterator i = localDets.begin(); i != localDets.end(); i++) {
     float testDiff = (thispoint - (**i).surface().position()).mag();
     if (testDiff < sDiff) {
       sDiff = testDiff;
       theBin = i - localDets.begin();
     }
   }
   return theBin;
 }

GlobalPoint Phase1PixelBlade::findPosition	(	int	index,
		int	diskSectorIndex
	)		const

private

Definition at line 271 of file Phase1PixelBlade.cc.

References theBackDets, and theFrontDets.

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

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

overridevirtual

Reimplemented from GeometricSearchDet.

Definition at line 68 of file Phase1PixelBlade.cc.

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

                                                                                  {
   SubLayerCrossings crossings;
 
   crossings = computeCrossings(tsos, prop.propagationDirection());
   if (!crossings.isValid())
     return;
 
   vector<DetGroup> closestResult;
   addClosest(tsos, prop, est, crossings.closest(), closestResult);
 
   if (closestResult.empty()) {
     vector<DetGroup> nextResult;
     addClosest(tsos, prop, est, crossings.other(), nextResult);
     if (nextResult.empty())
       return;
 
     //DetGroupElement nextGel( nextResult.front().front());
     //int crossingSide = LayerCrossingSide().endcapSide( nextGel.trajectoryState(), prop);
 
     DetGroupMerger::orderAndMergeTwoLevels(std::move(closestResult),
                                            std::move(nextResult),
                                            result,
                                            0,
                                            0);  //fixme gc patched for SLHC - already correctly sorted for SLHC
     //crossings.closestIndex(), crossingSide);
   } else {
     DetGroupElement closestGel(closestResult.front().front());
     float window = computeWindowSize(closestGel.det(), closestGel.trajectoryState(), est);
 
     searchNeighbors(tsos, prop, est, crossings.closest(), window, closestResult, false);
 
     vector<DetGroup> nextResult;
     searchNeighbors(tsos, prop, est, crossings.other(), window, nextResult, true);
 
     //int crossingSide = LayerCrossingSide().endcapSide( closestGel.trajectoryState(), prop);
     DetGroupMerger::orderAndMergeTwoLevels(std::move(closestResult),
                                            std::move(nextResult),
                                            result,
                                            0,
                                            0);  //fixme gc patched for SLHC - already correctly sorted for SLHC
     //crossings.closestIndex(), crossingSide);
   }
 }

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

private

Definition at line 215 of file Phase1PixelBlade.cc.

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

Referenced by searchNeighbors().

                                                                                                     {
   // check if the z window around TSOS overlaps with the detector theDet (with a 1% margin added)
 
   //   const float tolerance = 0.1;
   const float relativeMargin = 1.01;
 
   LocalPoint localCrossPoint(det.surface().toLocal(crossPoint));
   //   if (std::abs(localCrossPoint.z()) > tolerance) {
   //     edm::LogInfo(TkDetLayers) << "Phase1PixelBlade::overlap calculation assumes point on surface, but it is off by "
   //     << localCrossPoint.z() ;
   //   }
 
   float localX = localCrossPoint.x();
   float detHalfLength = det.surface().bounds().length() / 2.;
 
   //   edm::LogInfo(TkDetLayers) << "Phase1PixelBlade::overlap: Det at " << det.position() << " hit at " << localY
   //        << " Window " << window << " halflength "  << detHalfLength ;
 
   if ((std::abs(localX) - window) < relativeMargin * detHalfLength) {  // FIXME: margin hard-wired!
     return true;
   } else {
     return false;
   }
 }

void Phase1PixelBlade::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 178 of file Phase1PixelBlade.cc.

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

Referenced by groupedCompatibleDetsV().

                                                                 {
   const GlobalPoint& gCrossingPos = crossing.position();
   const vector<const GeomDet*>& sBlade(subBlade(crossing.subLayerIndex()));
 
   int closestIndex = crossing.closestDetIndex();
   int negStartIndex = closestIndex - 1;
   int posStartIndex = closestIndex + 1;
 
   if (checkClosest) {  // must decide if the closest is on the neg or pos side
     if (gCrossingPos.perp() < sBlade[closestIndex]->surface().position().perp()) {
       posStartIndex = closestIndex;
     } else {
       negStartIndex = closestIndex;
     }
   }
 
   typedef CompatibleDetToGroupAdder Adder;
   for (int idet = negStartIndex; idet >= 0; idet--) {
     if (!overlap(gCrossingPos, *sBlade[idet], window))
       break;
     if (!Adder::add(*sBlade[idet], tsos, prop, est, result))
       break;
   }
   for (int idet = posStartIndex; idet < static_cast<int>(sBlade.size()); idet++) {
     if (!overlap(gCrossingPos, *sBlade[idet], window))
       break;
     if (!Adder::add(*sBlade[idet], tsos, prop, est, result))
       break;
   }
 }