#include <CompositeTECPetal.h>

Inheritance diagram for CompositeTECPetal:

Classes
struct	WedgePar

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

	CompositeTECPetal (std::vector< const TECWedge * > &innerWedges, std::vector< const TECWedge * > &outerWedges) __attribute__((cold))

void	groupedCompatibleDetsV (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetGroup > &result) const override __attribute__((hot))

virtual const BoundDiskSector &	specificSurface () const final

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

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

int	findBin (float R, int layer) const

WedgePar const &	findPar (int index, int diskSectorType) 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 TECWedge * > &	subLayer (int ind) const

Static Private Member Functions
static float	computeWindowSize (const GeomDet *det, const TrajectoryStateOnSurface &tsos, const MeasurementEstimator &est) __attribute__((hot))

Private Attributes
std::vector< float >	theBackBoundaries

std::vector< const TECWedge * >	theBackComps

std::vector< WedgePar >	theBackPars

ReferenceCountingPointer< BoundDiskSector >	theBackSector

std::vector< const GeomDet * >	theBasicComps

std::vector< const GeometricSearchDet * >	theComps

ReferenceCountingPointer< BoundDiskSector >	theDiskSector

std::vector< float >	theFrontBoundaries

std::vector< const TECWedge * >	theFrontComps

std::vector< WedgePar >	theFrontPars

ReferenceCountingPointer< BoundDiskSector >	theFrontSector

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 TEC petals

Definition at line 20 of file CompositeTECPetal.h.

Constructor & Destructor Documentation

CompositeTECPetal::CompositeTECPetal	(	std::vector< const TECWedge * > &	innerWedges,
		std::vector< const TECWedge * > &	outerWedges
	)

Definition at line 94 of file CompositeTECPetal.cc.

References LogDebug, theBackBoundaries, theBackComps, theBackPars, theBackSector, theBasicComps, theComps, theDiskSector, theFrontBoundaries, theFrontComps, theFrontPars, and theFrontSector.

                                                            : 
   GeometricSearchDet(true),
   theFrontComps(innerWedges), 
   theBackComps(outerWedges)
 {
   theComps.assign(theFrontComps.begin(),theFrontComps.end());
   theComps.insert(theComps.end(),theBackComps.begin(),theBackComps.end());
 
   details::fillBoundaries( theFrontComps, theFrontBoundaries);
   details::fillBoundaries( theBackComps, theBackBoundaries);
   details::fillPars(theFrontComps, theFrontPars);
   details::fillPars(theBackComps, theBackPars);
 
   for(vector<const GeometricSearchDet*>::const_iterator it=theComps.begin();
       it!=theComps.end();it++){  
     theBasicComps.insert(theBasicComps.end(),   
              (**it).basicComponents().begin(),
              (**it).basicComponents().end());
   }
 
 
   //the Wedge are already R ordered
   //sort( theWedges.begin(), theWedges.end(), DetLessR());
   //sort( theFrontWedges.begin(), theFrontWedges.end(), DetLessR() );
   //sort( theBackWedges.begin(), theBackWedges.end(), DetLessR() );
   vector<const TECWedge*> allWedges;
   allWedges.assign(innerWedges.begin(),innerWedges.end());
   allWedges.insert(allWedges.end(),outerWedges.begin(),outerWedges.end());
 
   theDiskSector  = ForwardDiskSectorBuilderFromWedges()( allWedges );
   theFrontSector = ForwardDiskSectorBuilderFromWedges()( innerWedges);
   theBackSector  = ForwardDiskSectorBuilderFromWedges()( outerWedges);
 
   //--------- DEBUG INFO --------------
   LogDebug("TkDetLayers") << "DEBUG INFO for CompositeTECPetal" ;
 
   for(auto it=theFrontComps.begin(); 
       it!=theFrontComps.end(); it++){
     LogDebug("TkDetLayers") << "frontWedge phi,z,r: " 
                 << (*it)->surface().position().phi() << " , "
                 << (*it)->surface().position().z() <<   " , "
                 << (*it)->surface().position().perp() ;
   }
 
   for(auto it=theBackComps.begin(); 
       it!=theBackComps.end(); it++){
     LogDebug("TkDetLayers") << "backWedge phi,z,r: " 
                 << (*it)->surface().position().phi() << " , "
                 << (*it)->surface().position().z() <<   " , "
                 << (*it)->surface().position().perp() ;
   }
   //----------------------------------- 
 
 
 }

CompositeTECPetal::~CompositeTECPetal ( )

override

Definition at line 152 of file CompositeTECPetal.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

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

private

Definition at line 266 of file CompositeTECPetal.cc.

References CompatibleDetToGroupAdder::add(), SubLayerCrossing::closestDetIndex(), LogDebug, subLayer(), and SubLayerCrossing::subLayerIndex().

Referenced by groupedCompatibleDetsV().

 {
 
   auto det = subLayer( crossing.subLayerIndex())[crossing.closestDetIndex()];
 
   LogDebug("TkDetLayers") 
     << "in TECPetal, adding Wedge at r,z,phi: (" 
     << det->position().perp() << "," 
     << det->position().z() << "," 
     << det->position().phi() << ")" ;
   LogDebug("TkDetLayers") 
     << "wedge comps size: " 
     << det->basicComponents().size();
 
   return CompatibleDetToGroupAdder::add( *det, tsos, prop, est, result);
 }

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

inlineoverridevirtual

Implements GeometricSearchDet.

Definition at line 37 of file CompositeTECPetal.h.

References theBasicComps.

37 {return theBasicComps;}

CompositeTECPetal::theBasicComps

std::vector< const GeomDet * > theBasicComps

Definition: CompositeTECPetal.h:95

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

Referenced by components().

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

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

inlineoverridevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 39 of file CompositeTECPetal.h.

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

39 {return theComps;}

CompositeTECPetal::theComps

std::vector< const GeometricSearchDet * > theComps

Definition: CompositeTECPetal.h:96

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

private

Definition at line 211 of file CompositeTECPetal.cc.

References funct::abs(), findBin(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), LogDebug, HelixForwardPlaneCrossing::pathLength(), HelixForwardPlaneCrossing::position(), rho, theBackPars, theBackSector, theFrontPars, theFrontSector, and TrajectoryStateOnSurface::transverseCurvature().

Referenced by groupedCompatibleDetsV().

 {
   
   HelixPlaneCrossing::PositionType startPos( startingState.globalPosition() );
   HelixPlaneCrossing::DirectionType startDir( startingState.globalMomentum() );
 
   auto rho = startingState.transverseCurvature();
 
   HelixForwardPlaneCrossing crossing(startPos,startDir,rho,propDir);
 
   pair<bool,double> frontPath = crossing.pathLength( *theFrontSector);
   if (!frontPath.first) return SubLayerCrossings();
 
   pair<bool,double> backPath = crossing.pathLength(*theBackSector);
   if (!backPath.first) return SubLayerCrossings();
 
   GlobalPoint gFrontPoint(crossing.position(frontPath.second));
   GlobalPoint gBackPoint( crossing.position(backPath.second));
 
 
   LogDebug("TkDetLayers") 
     << "in TECPetal,front crossing : r,z,phi: (" 
     << gFrontPoint.perp() << ","
     << gFrontPoint.z() << "," 
     << gFrontPoint.phi() << ")";
   
   LogDebug("TkDetLayers") 
     << "in TECPetal,back crossing r,z,phi: (" 
     << gBackPoint.perp() << ","
     << gBackPoint.z() << "," 
     << gBackPoint.phi() << ")" ;
 
 
 
   int frontIndex = findBin(gFrontPoint.perp(),0);
   SubLayerCrossing frontSLC( 0, frontIndex, gFrontPoint);
 
   int backIndex = findBin(gBackPoint.perp(),1);
   SubLayerCrossing backSLC( 1, backIndex, gBackPoint);
   
   auto frontDist = std::abs( theFrontPars[frontIndex].theR - gFrontPoint.perp());
   auto backDist = std::abs( theBackPars[backIndex].theR - gBackPoint.perp());
   
   
   
   // 0ss: frontDisk has index=0, backDisk has index=1
   if (frontDist < backDist) {
     return SubLayerCrossings( frontSLC, backSLC, 0);
   }
   else {
     return SubLayerCrossings( backSLC, frontSLC, 1);
   } 
 }

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

staticprivate

Definition at line 345 of file CompositeTECPetal.cc.

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

Referenced by groupedCompatibleDetsV().

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

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

private

Definition at line 353 of file CompositeTECPetal.cc.

References theBackBoundaries, and theFrontBoundaries.

Referenced by computeCrossings().

 {
   return details::findBin(diskSectorType==0 ? theFrontBoundaries : theBackBoundaries,R);
 }

WedgePar const& CompositeTECPetal::findPar	(	int	index,
		int	diskSectorType
	)		const

inlineprivate

Definition at line 85 of file CompositeTECPetal.h.

References theBackPars, and theFrontPars.

Referenced by searchNeighbors().

                                                                               {
     return (diskSectorType == 0) ? theFrontPars[index] : theBackPars[index];
   }

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

overridevirtual

Reimplemented from GeometricSearchDet.

Definition at line 169 of file CompositeTECPetal.cc.

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

Referenced by components().

                                                            {
 
   vector<DetGroup> closestResult;
   SubLayerCrossings  crossings; 
   crossings = computeCrossings( tsos, prop.propagationDirection());
   if(! crossings.isValid()) return;
 
   addClosest( tsos, prop, est, crossings.closest(), closestResult); 
   LogDebug("TkDetLayers") << "in TECPetal, closestResult.size(): "<< closestResult.size();
 
   if (closestResult.empty()){
     vector<DetGroup> nextResult;
     addClosest( tsos, prop, est, crossings.other(), nextResult); 
     LogDebug("TkDetLayers") << "in TECPetal, nextResult.size(): "<< nextResult.size() ;
     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, 
                         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, 
                         crossings.closestIndex(), crossingSide);
   }
 }

void CompositeTECPetal::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 290 of file CompositeTECPetal.cc.

References PVValHelper::add(), SubLayerCrossing::closestDetIndex(), findPar(), muon::overlap(), PV3DBase< T, PVType, FrameType >::perp2(), SubLayerCrossing::position(), subLayer(), SubLayerCrossing::subLayerIndex(), theBackComps, and theFrontComps.

Referenced by groupedCompatibleDetsV().

 {
   const GlobalPoint& gCrossingPos = crossing.position();
 
   
   int closestIndex = crossing.closestDetIndex(); 
   int negStartIndex = closestIndex-1;
   int posStartIndex = closestIndex+1;
 
   float detR = findPar(closestIndex,crossing.subLayerIndex()).theR;
 
   if (checkClosest) { // must decide if the closest is on the neg or pos side
     if ( gCrossingPos.perp2() < detR*detR ) {
       posStartIndex = closestIndex;
     }
     else {
       negStartIndex = closestIndex;
     }
   }
 
   const std::vector<const TECWedge*>& sLayer = subLayer(crossing.subLayerIndex() );
 
   //const BinFinderType& binFinder = (crossing.subLayerIndex()==0 ? theFrontBinFinder : theBackBinFinder);
   int theSize = crossing.subLayerIndex()==0 ? theFrontComps.size() : theBackComps.size();
   
   typedef CompatibleDetToGroupAdder Adder;
   for (int idet=negStartIndex; idet >= 0; idet--) {
     //if(idet<0 || idet>= theSize) {edm::LogInfo(TkDetLayers) << "===== error! gone out vector bounds.idet: " << idet ;exit;}
     const GeometricSearchDet & neighborWedge = *sLayer[idet];
     WedgePar const & wpar = findPar(idet, crossing.subLayerIndex());
     if (!details::overlap( gCrossingPos, wpar, window)) break;  // --- to check
     if (!Adder::add( neighborWedge, tsos, prop, est, result)) break;
     // maybe also add shallow crossing angle test here???
   }
   for (int idet=posStartIndex; idet <theSize; idet++) {
     //if(idet<0 || idet>= theSize) {edm::LogInfo(TkDetLayers) << "===== error! gone out vector bounds.idet: " << idet ;exit;}
     const GeometricSearchDet & neighborWedge = *sLayer[idet];
     WedgePar const & wpar = findPar(idet, crossing.subLayerIndex());
     if (!details::overlap( gCrossingPos, wpar, window)) break;  // ---- to check
     if (!Adder::add( neighborWedge, tsos, prop, est, result)) break;
     // maybe also add shallow crossing angle test here???
   }
 }

virtual const BoundDiskSector& CompositeTECPetal::specificSurface ( ) const

inlinefinalvirtual

Definition at line 32 of file CompositeTECPetal.h.

References theDiskSector.

Referenced by TECLayer::addClosest().

32 {return *theDiskSector;}

CompositeTECPetal::theDiskSector

ReferenceCountingPointer< BoundDiskSector > theDiskSector

Definition: CompositeTECPetal.h:54

const std::vector<const TECWedge*>& CompositeTECPetal::subLayer ( int ind ) const

inlineprivate

Definition at line 89 of file CompositeTECPetal.h.

References theBackComps, and theFrontComps.

Referenced by addClosest(), and searchNeighbors().

                                                                            {
     return (ind==0 ? theFrontComps : theBackComps);
   }

const BoundSurface& CompositeTECPetal::surface ( ) const

inlinefinalvirtual

The surface of the GeometricSearchDet.

Implements GeometricSearchDet.

Definition at line 30 of file CompositeTECPetal.h.

References theDiskSector.

30 {return *theDiskSector;}

CompositeTECPetal::theDiskSector

ReferenceCountingPointer< BoundDiskSector > theDiskSector

Definition: CompositeTECPetal.h:54

Member Data Documentation

std::vector<float> CompositeTECPetal::theBackBoundaries

private

Definition at line 102 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), and findBin().

std::vector<const TECWedge*> CompositeTECPetal::theBackComps

private

Definition at line 99 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), searchNeighbors(), and subLayer().

std::vector<WedgePar> CompositeTECPetal::theBackPars

private

Definition at line 104 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), computeCrossings(), and findPar().

ReferenceCountingPointer<BoundDiskSector> CompositeTECPetal::theBackSector

private

Definition at line 107 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), and computeCrossings().

std::vector<const GeomDet*> CompositeTECPetal::theBasicComps

private

Definition at line 95 of file CompositeTECPetal.h.

Referenced by basicComponents(), and CompositeTECPetal().

std::vector<const GeometricSearchDet*> CompositeTECPetal::theComps

private

Definition at line 96 of file CompositeTECPetal.h.

Referenced by components(), CompositeTECPetal(), and ~CompositeTECPetal().

ReferenceCountingPointer<BoundDiskSector> CompositeTECPetal::theDiskSector

private

Definition at line 54 of file CompositeTECPetal.h.

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

std::vector<float> CompositeTECPetal::theFrontBoundaries

private

Definition at line 101 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), and findBin().

std::vector<const TECWedge*> CompositeTECPetal::theFrontComps

private

Definition at line 98 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), searchNeighbors(), and subLayer().

std::vector<WedgePar> CompositeTECPetal::theFrontPars

private

Definition at line 103 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), computeCrossings(), and findPar().

ReferenceCountingPointer<BoundDiskSector> CompositeTECPetal::theFrontSector

private

Definition at line 106 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), and computeCrossings().

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation