#include <PixelForwardLayer.h>

Inheritance diagram for PixelForwardLayer:

Classes
struct	SubTurbineCrossings

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

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

	PixelForwardLayer (std::vector< const PixelBlade * > &blades)

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

	~PixelForwardLayer () 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 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 Types
typedef PeriodicBinFinderInPhi< float >	BinFinderType

Private Member Functions
SubTurbineCrossings	computeCrossings (const TrajectoryStateOnSurface &startingState, PropagationDirection propDir) const __attribute__((hot))

void	searchNeighbors (const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est, const SubTurbineCrossings &crossings, float window, std::vector< DetGroup > &result) const __attribute__((hot))

Static Private Member Functions
static int	computeHelicity (const GeometricSearchDet firstBlade, const GeometricSearchDet secondBlade)

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

Private Attributes
std::vector< const GeomDet * >	theBasicComps

BinFinderType	theBinFinder

std::vector< const GeometricSearchDet * >	theComps

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

Protected Attributes inherited from GeometricSearchDet
bool	haveGroups

GeomDetCompatibilityChecker	theCompatibilityChecker

Detailed Description

A concrete implementation for PixelForward layer built out of ForwardPixelBlade

Definition at line 15 of file PixelForwardLayer.h.

Member Typedef Documentation

typedef PeriodicBinFinderInPhi<float> PixelForwardLayer::BinFinderType

private

Definition at line 66 of file PixelForwardLayer.h.

Constructor & Destructor Documentation

PixelForwardLayer::PixelForwardLayer ( std::vector< const PixelBlade * > & blades )

Definition at line 23 of file PixelForwardLayer.cc.

References ForwardDetLayer::computeSurface(), LogDebug, PV3DBase< T, PVType, FrameType >::phi(), GloballyPositioned< T >::position(), ForwardDetLayer::setSurface(), ForwardDetLayer::specificSurface(), ForwardDetLayer::surface(), theBasicComps, theBinFinder, theComps, and PV3DBase< T, PVType, FrameType >::z().

                                                                      :
   ForwardDetLayer(true),
   theComps(blades.begin(),blades.end())
 {
   for(vector<const GeometricSearchDet*>::const_iterator it=theComps.begin();
       it!=theComps.end();it++){  
     theBasicComps.insert(theBasicComps.end(),   
              (**it).basicComponents().begin(),
              (**it).basicComponents().end());
   }
 
   //They should be already phi-ordered. TO BE CHECKED!!
   //sort( theBlades.begin(), theBlades.end(), PhiLess());
   setSurface( computeSurface() );
   
   //Is a "periodic" binFinderInPhi enough?. TO BE CHECKED!!
   theBinFinder = BinFinderType( theComps.front()->surface().position().phi(),
                 theComps.size());
 
   //--------- DEBUG INFO --------------
   LogDebug("TkDetLayers") << "DEBUG INFO for PixelForwardLayer" << "\n"
               << "PixelForwardLayer.surfcace.phi(): " 
               << this->surface().position().phi() << "\n"
               << "PixelForwardLayer.surfcace.z(): " 
               << this->surface().position().z() << "\n"
               << "PixelForwardLayer.surfcace.innerR(): " 
               << this->specificSurface().innerRadius() << "\n"
               << "PixelForwardLayer.surfcace.outerR(): " 
               << this->specificSurface().outerRadius() ;
 
   for(vector<const GeometricSearchDet*>::const_iterator it=theComps.begin(); 
       it!=theComps.end(); it++){
     LogDebug("TkDetLayers") << "blades phi,z,r: " 
                 << (*it)->surface().position().phi() << " , "
                 << (*it)->surface().position().z() <<   " , "
                 << (*it)->surface().position().perp();
   }
   //-----------------------------------
 
     
 }

PixelForwardLayer::~PixelForwardLayer ( )

override

Definition at line 65 of file PixelForwardLayer.cc.

References mps_fire::i, and theComps.

                                      {
   vector<const GeometricSearchDet*>::const_iterator i;
   for (i=theComps.begin(); i!=theComps.end(); i++) {
     delete *i;
   }
 } 

Member Function Documentation

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

inlineoverridevirtual

Implements GeometricSearchDet.

Definition at line 22 of file PixelForwardLayer.h.

References theBasicComps.

22 {return theBasicComps;}

PixelForwardLayer::theBasicComps

std::vector< const GeomDet * > theBasicComps

Definition: PixelForwardLayer.h:70

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

inlineoverridevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 24 of file PixelForwardLayer.h.

References groupedCompatibleDetsV(), mps_fire::result, and theComps.

24 {return theComps;}

PixelForwardLayer::theComps

std::vector< const GeometricSearchDet * > theComps

Definition: PixelForwardLayer.h:69

PixelForwardLayer::SubTurbineCrossings PixelForwardLayer::computeCrossings	(	const TrajectoryStateOnSurface &	startingState,
		PropagationDirection	propDir
	)		const

private

Definition at line 182 of file PixelForwardLayer.cc.

References funct::abs(), PeriodicBinFinderInPhi< T >::binIndex(), HelixArbitraryPlaneCrossing::direction(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), HelixArbitraryPlaneCrossing::pathLength(), HelixArbitraryPlaneCrossing2Order::pathLength(), GloballyPositioned< T >::phi(), HelixArbitraryPlaneCrossing::position(), HelixArbitraryPlaneCrossing2Order::position(), rho, ForwardDetLayer::specificSurface(), ForwardDetLayer::surface(), theBinFinder, theComps, GloballyPositioned< T >::toLocal(), TrajectoryStateOnSurface::transverseCurvature(), and PV3DBase< T, PVType, FrameType >::x().

Referenced by groupedCompatibleDetsV().

 {  
   typedef MeasurementEstimator::Local2DVector Local2DVector;
 
   HelixPlaneCrossing::PositionType startPos( startingState.globalPosition());
   HelixPlaneCrossing::DirectionType startDir( startingState.globalMomentum());
   
   auto rho = startingState.transverseCurvature();
 
   HelixArbitraryPlaneCrossing turbineCrossing( startPos, startDir, rho,
                            propDir);
 
   pair<bool,double> thePath = turbineCrossing.pathLength( specificSurface() );
   
   if (!thePath.first) {
     //edm::LogInfo("TkDetLayers") << "ERROR in PixelForwardLayer: disk not crossed by track" ;
     return SubTurbineCrossings();
   }
 
   HelixPlaneCrossing::PositionType  turbinePoint( turbineCrossing.position(thePath.second));
   HelixPlaneCrossing::DirectionType turbineDir( turbineCrossing.direction(thePath.second));
 
   int closestIndex = theBinFinder.binIndex(turbinePoint.barePhi());
 
   const Plane& closestPlane( static_cast<const Plane&>(theComps[closestIndex]->surface()));
 
 
   HelixArbitraryPlaneCrossing2Order theBladeCrossing(turbinePoint, turbineDir, rho);
 
   pair<bool,double> theClosestBladePath = theBladeCrossing.pathLength( closestPlane );
   LocalPoint closestPos = closestPlane.toLocal(GlobalPoint(theBladeCrossing.position(theClosestBladePath.second)) );
     
   auto closestDist = closestPos.x(); // use fact that local X perp to global Y
 
   //int next = turbinePoint.phi() - closestPlane.position().phi() > 0 ? closest+1 : closest-1;
 
   int nextIndex = PhiLess()( closestPlane.phi(), turbinePoint.barePhi()) ? 
     closestIndex+1 : closestIndex-1;
 
   const Plane& nextPlane( static_cast<const Plane&>( 
     theComps[ theBinFinder.binIndex(nextIndex)]->surface()));
 
   pair<bool,double> theNextBladePath    = theBladeCrossing.pathLength( nextPlane );
   LocalPoint nextPos = nextPlane.toLocal(GlobalPoint(theBladeCrossing.position(theNextBladePath.second)) );
 
   auto nextDist = nextPos.x();
 
   if ( std::abs(closestDist) < std::abs(nextDist)) {
     return SubTurbineCrossings( closestIndex, nextIndex, nextDist);
   }
   else {
     return SubTurbineCrossings( nextIndex, closestIndex, closestDist);
   }
 }

int PixelForwardLayer::computeHelicity	(	const GeometricSearchDet *	firstBlade,
		const GeometricSearchDet *	secondBlade
	)

staticprivate

Definition at line 176 of file PixelForwardLayer.cc.

References funct::abs(), GeometricSearchDet::position(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by groupedCompatibleDetsV(), searchNeighbors(), and subDetector().

 {  
   return std::abs(firstBlade->position().z()) < std::abs(secondBlade->position().z()) ? 0 : 1;
 }

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

staticprivate

Definition at line 239 of file PixelForwardLayer.cc.

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

Referenced by groupedCompatibleDetsV().

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

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

overridevirtual

Reimplemented from GeometricSearchDet.

Definition at line 73 of file PixelForwardLayer.cc.

References PVValHelper::add(), PeriodicBinFinderInPhi< T >::binIndex(), PixelForwardLayer::SubTurbineCrossings::closestIndex, computeCrossings(), computeHelicity(), computeWindowSize(), LayerCrossingSide::endcapSide(), PixelForwardLayer::SubTurbineCrossings::isValid, eostools::move(), PixelForwardLayer::SubTurbineCrossings::nextIndex, DetGroupMerger::orderAndMergeTwoLevels(), Propagator::propagationDirection(), mps_fire::result, searchNeighbors(), theBinFinder, theComps, and svgfig::window().

Referenced by components().

                                                            {
   std::vector<DetGroup> closestResult;
   SubTurbineCrossings  crossings; 
 
   crossings = computeCrossings( tsos, prop.propagationDirection());
   if (!crossings.isValid){
     //edm::LogInfo("TkDetLayers") << "computeCrossings returns invalid in PixelForwardLayer::groupedCompatibleDets:";
     return;
   }
 
   typedef CompatibleDetToGroupAdder Adder;
   Adder::add( *theComps[theBinFinder.binIndex(crossings.closestIndex)], 
          tsos, prop, est, closestResult);
 
   if(closestResult.empty()){
     Adder::add( *theComps[theBinFinder.binIndex(crossings.nextIndex)], 
            tsos, prop, est, result);
     return;
   }      
 
   DetGroupElement closestGel( closestResult.front().front());
   float window = computeWindowSize( closestGel.det(), closestGel.trajectoryState(), est);
 
   //float detWidth = closestGel.det()->surface().bounds().width();
   //if (crossings.nextDistance < detWidth + window) {
   vector<DetGroup> nextResult;
   if (Adder::add( *theComps[theBinFinder.binIndex(crossings.nextIndex)], 
           tsos, prop, est, nextResult)) {
     int crossingSide = LayerCrossingSide().endcapSide( tsos, prop);
     int theHelicity = computeHelicity(theComps[theBinFinder.binIndex(crossings.closestIndex)],
                     theComps[theBinFinder.binIndex(crossings.nextIndex)] );
     DetGroupMerger::orderAndMergeTwoLevels( std::move(closestResult), std::move(nextResult), result, 
                         theHelicity, crossingSide);
   }
   else {
     result.swap(closestResult);
   }
   
   /*
   }
   else {
     result.swap(closestResult);
   }
   */
 
   // --- THIS lines may speed up the reconstruction. But it reduces slightly the efficiency.
   // only loop over neighbors (other than closest and next) if window is BIG  
   //if (window > 0.5*detWidth) {
   searchNeighbors( tsos, prop, est, crossings, window, result);
   //} 
 }

void PixelForwardLayer::searchNeighbors	(	const TrajectoryStateOnSurface &	tsos,
		const Propagator &	prop,
		const MeasurementEstimator &	est,
		const SubTurbineCrossings &	crossings,
		float	window,
		std::vector< DetGroup > &	result
	)		const

private

Definition at line 131 of file PixelForwardLayer.cc.

References PVValHelper::add(), PeriodicBinFinderInPhi< T >::binIndex(), PixelForwardLayer::SubTurbineCrossings::closestIndex, computeHelicity(), LayerCrossingSide::endcapSide(), SiStripPI::max, trackerDrivenElectronSeeds_cff::Merger, min(), eostools::move(), PixelForwardLayer::SubTurbineCrossings::nextIndex, theBinFinder, and theComps.

Referenced by groupedCompatibleDetsV().

 {
   typedef CompatibleDetToGroupAdder Adder;
   int crossingSide = LayerCrossingSide().endcapSide( tsos, prop);
   typedef DetGroupMerger Merger;
 
   int negStart = min( crossings.closestIndex, crossings.nextIndex) - 1;
   int posStart = max( crossings.closestIndex, crossings.nextIndex) + 1;
 
   int quarter = theComps.size()/4;
  
   for (int idet=negStart; idet >= negStart - quarter+1; idet--) {
     std::vector<DetGroup> tmp1;
     const GeometricSearchDet* neighbor = theComps[theBinFinder.binIndex(idet)];
     // if (!overlap( gCrossingPos, *neighbor, window)) break; // mybe not needed?
     // maybe also add shallow crossing angle test here???
     if (!Adder::add( *neighbor, tsos, prop, est, tmp1)) break;
     int theHelicity = computeHelicity(theComps[theBinFinder.binIndex(idet)],
                       theComps[theBinFinder.binIndex(idet+1)] );
     std::vector<DetGroup> tmp2; tmp2.swap(result);
     std::vector<DetGroup> newResult;
     Merger::orderAndMergeTwoLevels( std::move(tmp1), std::move(tmp2), newResult, theHelicity, crossingSide);
     result.swap(newResult);
   }
   for (int idet=posStart; idet < posStart + quarter-1; idet++) {
     vector<DetGroup> tmp1;
     const GeometricSearchDet* neighbor = theComps[theBinFinder.binIndex(idet)];
     // if (!overlap( gCrossingPos, *neighbor, window)) break; // mybe not needed?
     // maybe also add shallow crossing angle test here???
     if (!Adder::add( *neighbor, tsos, prop, est, tmp1)) break;
     int theHelicity = computeHelicity(theComps[theBinFinder.binIndex(idet-1)],
                       theComps[theBinFinder.binIndex(idet)] );
     std::vector<DetGroup> tmp2; tmp2.swap(result);
     std::vector<DetGroup> newResult;
     Merger::orderAndMergeTwoLevels(std::move(tmp2), std::move(tmp1), newResult, theHelicity, crossingSide);
     result.swap(newResult);
   }
 }