PixelForwardLayer Class Reference

#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 13 of file PixelForwardLayer.h.

Member Typedef Documentation

typedef PeriodicBinFinderInPhi<float> PixelForwardLayer::BinFinderType

private

Definition at line 61 of file PixelForwardLayer.h.

Constructor & Destructor Documentation

PixelForwardLayer::PixelForwardLayer

(

std::vector< const PixelBlade * > &

blades

)

Definition at line 22 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 50 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 20 of file PixelForwardLayer.h.

References theBasicComps.

{ return theBasicComps; }

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

inlineoverridevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 22 of file PixelForwardLayer.h.

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

{ return theComps; }

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

private

Definition at line 157 of file PixelForwardLayer.cc.

References funct::abs(), PeriodicBinFinderInPhi< T >::binIndex(), HelixArbitraryPlaneCrossing::direction(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), HelixArbitraryPlaneCrossing::pathLength(), HelixArbitraryPlaneCrossing2Order::pathLength(), GloballyPositioned< T >::phi(), Geom::phiLess(), 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 = Geom::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 153 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 207 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 57 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 108 of file PixelForwardLayer.cc.

References PVValHelper::add(), PeriodicBinFinderInPhi< T >::binIndex(), PixelForwardLayer::SubTurbineCrossings::closestIndex, computeHelicity(), LayerCrossingSide::endcapSide(), SiStripPI::max, HLT_2018_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);
  }
}

SubDetector PixelForwardLayer::subDetector ( ) const

inlineoverridevirtual

The type of detector (PixelBarrel, PixelEndcap, TIB, TOB, TID, TEC, CSC, DT, RPCBarrel, RPCEndcap)

Implements DetLayer.

Definition at line 30 of file PixelForwardLayer.h.

References computeHelicity(), GeomDetEnumerators::PixelEndcap, and GeomDetEnumerators::subDetGeom.

{ return GeomDetEnumerators::subDetGeom[GeomDetEnumerators::PixelEndcap]; }

Member Data Documentation

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

private

Definition at line 65 of file PixelForwardLayer.h.

Referenced by basicComponents(), and PixelForwardLayer().

BinFinderType PixelForwardLayer::theBinFinder

private

Definition at line 62 of file PixelForwardLayer.h.

Referenced by computeCrossings(), groupedCompatibleDetsV(), PixelForwardLayer(), and searchNeighbors().

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

private

Definition at line 64 of file PixelForwardLayer.h.

Referenced by components(), computeCrossings(), groupedCompatibleDetsV(), PixelForwardLayer(), searchNeighbors(), and ~PixelForwardLayer().