#include <PixelForwardLayerPhase1.h>

Inheritance diagram for PixelForwardLayerPhase1:

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

	PixelForwardLayerPhase1 (std::vector< const Phase1PixelBlade * > &blades)

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

	~PixelForwardLayerPhase1 () 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, bool innerDisk) const __attribute__((hot))

void	searchNeighbors (const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est, const SubTurbineCrossings &crossings, float window, std::vector< DetGroup > &result, bool innerDisk) 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
unsigned int	_num_innerpanels

unsigned int	_num_outerpanels

std::vector< const GeomDet * >	theBasicComps

std::vector< float >	theBinFinder_byR

std::vector< unsigned int >	theBinFinder_byR_index

std::vector< unsigned int >	theBinFinder_byR_nextindex

BinFinderType	theBinFinder_inner

BinFinderType	theBinFinder_outer

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 ForwardPhase1PixelBlade

Definition at line 14 of file PixelForwardLayerPhase1.h.

Member Typedef Documentation

typedef PeriodicBinFinderInPhi<float> PixelForwardLayerPhase1::BinFinderType

private

Definition at line 64 of file PixelForwardLayerPhase1.h.

Constructor & Destructor Documentation

PixelForwardLayerPhase1::PixelForwardLayerPhase1 ( std::vector< const Phase1PixelBlade * > & blades )

Definition at line 26 of file PixelForwardLayerPhase1.cc.

References _num_innerpanels, _num_outerpanels, ForwardDetLayer::computeSurface(), LogDebug, SiStripPI::max, min(), PV3DBase< T, PVType, FrameType >::perp(), phi, PV3DBase< T, PVType, FrameType >::phi(), GeometricSearchDet::position(), GloballyPositioned< T >::position(), ForwardDetLayer::setSurface(), ForwardDetLayer::specificSurface(), ForwardDetLayer::surface(), theBasicComps, theBinFinder_inner, theBinFinder_outer, theComps, and PV3DBase< T, PVType, FrameType >::z().

     : ForwardDetLayer(true), theComps(blades.begin(), blades.end()) {
   // Assumes blades are ordered inner first then outer; and within each by phi
   // where we go 0 -> pi, and then -pi -> 0
   // we also need the number of inner blades for the offset in theComps vector
   //
   // this->specificSurface() not yet available so need to calculate average R
   // we need some way to flag if FPIX is made of an inner and outer disk
   // or probably need to change the way this is done, e.g. a smarter binFinder
   float theRmin = (*(theComps.begin()))->surface().position().perp();
   float theRmax = theRmin;
   for (vector<const GeometricSearchDet*>::const_iterator it = theComps.begin(); it != theComps.end(); it++) {
     theRmin = std::min(theRmin, (*it)->surface().position().perp());
     theRmax = std::max(theRmax, (*it)->surface().position().perp());
   }
   //float split_inner_outer_radius = 0.5 * (theRmin + theRmax);
   // force the splitting rdius to be 10 cm to cope also with the FPIX disks with only the outer ring
   float split_inner_outer_radius = 10.;
   _num_innerpanels = 0;
   for (vector<const GeometricSearchDet*>::const_iterator it = theComps.begin(); it != theComps.end(); it++) {
     if ((**it).surface().position().perp() <= split_inner_outer_radius)
       ++_num_innerpanels;
   }
   _num_outerpanels = theComps.size() - _num_innerpanels;
   edm::LogInfo("TkDetLayers") << " Rmin, Rmax, R_average = " << theRmin << ", " << theRmax << ", "
                               << split_inner_outer_radius << std::endl
                               << " num inner, outer disks = " << _num_innerpanels << ", " << _num_outerpanels
                               << std::endl;
 
   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());
 
   theBinFinder_inner = BinFinderType(theComps.front()->surface().position().phi(), _num_innerpanels);
   theBinFinder_outer = BinFinderType(theComps[_num_innerpanels]->surface().position().phi(), _num_outerpanels);
 
   //--------- DEBUG INFO --------------
   LogDebug("TkDetLayers") << "DEBUG INFO for PixelForwardLayerPhase1"
                           << "\n"
                           << "Num of inner and outer panels = " << _num_innerpanels << ", " << _num_outerpanels << "\n"
                           << "Based on phi separation for inner: " << theComps.front()->surface().position().phi()
                           << " and on phi separation for outer: "
                           << theComps[_num_innerpanels]->surface().position().phi()
                           << "PixelForwardLayerPhase1.surfcace.phi(): " << std::endl
                           << this->surface().position().phi() << "\n"
                           << "PixelForwardLayerPhase1.surfcace.z(): " << this->surface().position().z() << "\n"
                           << "PixelForwardLayerPhase1.surfcace.innerR(): " << this->specificSurface().innerRadius()
                           << "\n"
                           << "PixelForwardLayerPhase1.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();
     //for(vector<const GeomDet*>::const_iterator iu=(**it).basicComponents().begin();
     //    iu!=(**it).basicComponents().end();iu++){
     //  std::cout << "   basic component rawId = " << hex << (**iu).geographicalId().rawId() << dec <<std::endl;
     //}
   }
   //-----------------------------------
 }

PixelForwardLayerPhase1::~PixelForwardLayerPhase1 ( )

override

Definition at line 91 of file PixelForwardLayerPhase1.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*>& PixelForwardLayerPhase1::basicComponents ( ) const

inlineoverridevirtual

Implements GeometricSearchDet.

Definition at line 21 of file PixelForwardLayerPhase1.h.

References theBasicComps.

21 { return theBasicComps; }

PixelForwardLayerPhase1::theBasicComps

std::vector< const GeomDet * > theBasicComps

Definition: PixelForwardLayerPhase1.h:77

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

inlineoverridevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 23 of file PixelForwardLayerPhase1.h.

References theComps.

23 { return theComps; }

PixelForwardLayerPhase1::theComps

std::vector< const GeometricSearchDet * > theComps

Definition: PixelForwardLayerPhase1.h:76

PixelForwardLayerPhase1::SubTurbineCrossings PixelForwardLayerPhase1::computeCrossings	(	const TrajectoryStateOnSurface &	startingState,
		PropagationDirection	propDir,
		bool	innerDisk
	)		const

private

Definition at line 299 of file PixelForwardLayerPhase1.cc.

References _num_innerpanels, funct::abs(), PeriodicBinFinderInPhi< T >::binIndex(), HelixArbitraryPlaneCrossing::direction(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), HelixArbitraryPlaneCrossing::pathLength(), HelixArbitraryPlaneCrossing2Order::pathLength(), Geom::phiLess(), HelixArbitraryPlaneCrossing::position(), HelixArbitraryPlaneCrossing2Order::position(), rho, ForwardDetLayer::specificSurface(), ForwardDetLayer::surface(), theBinFinder_inner, theBinFinder_outer, theComps, 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) {
     return SubTurbineCrossings();
   }
 
   HelixPlaneCrossing::PositionType turbinePoint(turbineCrossing.position(thePath.second));
   HelixPlaneCrossing::DirectionType turbineDir(turbineCrossing.direction(thePath.second));
   int closestIndex = 0;
   int nextIndex = 0;
   if (innerDisk)
     closestIndex = theBinFinder_inner.binIndex(turbinePoint.barePhi());
   else
     closestIndex = theBinFinder_outer.binIndex(turbinePoint.barePhi());
 
   HelixArbitraryPlaneCrossing2Order theBladeCrossing(turbinePoint, turbineDir, rho);
 
   float closestDist = 0;
   if (innerDisk) {
     const BoundPlane& closestPlane(static_cast<const BoundPlane&>(theComps[closestIndex]->surface()));
 
     pair<bool, double> theClosestBladePath = theBladeCrossing.pathLength(closestPlane);
     LocalPoint closestPos = closestPlane.toLocal(GlobalPoint(theBladeCrossing.position(theClosestBladePath.second)));
     closestDist = closestPos.x();
     // use fact that local X perp to global Y
     nextIndex = Geom::phiLess(closestPlane.phi(), turbinePoint.barePhi()) ? closestIndex + 1 : closestIndex - 1;
   } else {
     const BoundPlane& closestPlane(
         static_cast<const BoundPlane&>(theComps[closestIndex + _num_innerpanels]->surface()));
 
     pair<bool, double> theClosestBladePath = theBladeCrossing.pathLength(closestPlane);
     LocalPoint closestPos = closestPlane.toLocal(GlobalPoint(theBladeCrossing.position(theClosestBladePath.second)));
     closestDist = closestPos.x();
     // use fact that local X perp to global Y
     nextIndex = Geom::phiLess(closestPlane.phi(), turbinePoint.barePhi()) ? closestIndex + 1 : closestIndex - 1;
   }
 
   float nextDist = 0;
   if (innerDisk) {
     const BoundPlane& nextPlane(
         static_cast<const BoundPlane&>(theComps[theBinFinder_inner.binIndex(nextIndex)]->surface()));
     pair<bool, double> theNextBladePath = theBladeCrossing.pathLength(nextPlane);
     LocalPoint nextPos = nextPlane.toLocal(GlobalPoint(theBladeCrossing.position(theNextBladePath.second)));
     nextDist = nextPos.x();
   } else {
     const BoundPlane& nextPlane(
         static_cast<const BoundPlane&>(theComps[theBinFinder_outer.binIndex(nextIndex) + _num_innerpanels]->surface()));
     pair<bool, double> theNextBladePath = theBladeCrossing.pathLength(nextPlane);
     LocalPoint nextPos = nextPlane.toLocal(GlobalPoint(theBladeCrossing.position(theNextBladePath.second)));
     nextDist = nextPos.x();
   }
   if (std::abs(closestDist) < std::abs(nextDist)) {
     return SubTurbineCrossings(closestIndex, nextIndex, nextDist);
   } else {
     return SubTurbineCrossings(nextIndex, closestIndex, closestDist);
   }
 }

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

staticprivate

Definition at line 294 of file PixelForwardLayerPhase1.cc.

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

Referenced by groupedCompatibleDetsV(), and searchNeighbors().

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

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

staticprivate

Definition at line 367 of file PixelForwardLayerPhase1.cc.

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

Referenced by groupedCompatibleDetsV().

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

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

overridevirtual

Reimplemented from GeometricSearchDet.

Definition at line 98 of file PixelForwardLayerPhase1.cc.

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

                                                                                         {
   std::vector<DetGroup> closestResult_inner;
   std::vector<DetGroup> closestResult_outer;
   std::vector<DetGroup> nextResult_inner;
   std::vector<DetGroup> nextResult_outer;
   std::vector<DetGroup> result_inner;
   std::vector<DetGroup> result_outer;
   int frontindex_inner = 0;
   int frontindex_outer = 0;
   SubTurbineCrossings crossings_inner;
   SubTurbineCrossings crossings_outer;
 
   if (_num_innerpanels > 0)
     crossings_inner = computeCrossings(tsos, prop.propagationDirection(), true);
   crossings_outer = computeCrossings(tsos, prop.propagationDirection(), false);
   //  if (!crossings_inner.isValid){
   //    edm::LogInfo("TkDetLayers") << "inner computeCrossings returns invalid in PixelForwardLayerPhase1::groupedCompatibleDets:";
   //    return;
   //  }
   if (!crossings_outer.isValid) {
     edm::LogInfo("TkDetLayers")
         << "outer computeCrossings returns invalid in PixelForwardLayerPhase1::groupedCompatibleDets:";
     return;
   }
 
   typedef CompatibleDetToGroupAdder Adder;
   if (crossings_inner.isValid) {
     Adder::add(
         *theComps[theBinFinder_inner.binIndex(crossings_inner.closestIndex)], tsos, prop, est, closestResult_inner);
 
     if (closestResult_inner.empty()) {
       Adder::add(*theComps[theBinFinder_inner.binIndex(crossings_inner.nextIndex)], tsos, prop, est, result_inner);
       frontindex_inner = crossings_inner.nextIndex;
     } else {
       if (Adder::add(
               *theComps[theBinFinder_inner.binIndex(crossings_inner.nextIndex)], tsos, prop, est, nextResult_inner)) {
         int crossingSide = LayerCrossingSide().endcapSide(tsos, prop);
         int theHelicity = computeHelicity(theComps[theBinFinder_inner.binIndex(crossings_inner.closestIndex)],
                                           theComps[theBinFinder_inner.binIndex(crossings_inner.nextIndex)]);
         std::vector<DetGroup> tmp99 = closestResult_inner;
         DetGroupMerger::orderAndMergeTwoLevels(
             std::move(tmp99), std::move(nextResult_inner), result_inner, theHelicity, crossingSide);
         if (theHelicity == crossingSide)
           frontindex_inner = crossings_inner.closestIndex;
         else
           frontindex_inner = crossings_inner.nextIndex;
       } else {
         result_inner.swap(closestResult_inner);
         frontindex_inner = crossings_inner.closestIndex;
       }
     }
   }
   if (!closestResult_inner.empty()) {
     DetGroupElement closestGel(closestResult_inner.front().front());
     float window = computeWindowSize(closestGel.det(), closestGel.trajectoryState(), est);
     searchNeighbors(tsos, prop, est, crossings_inner, window, result_inner, true);
   }
 
   //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) {
 
   Adder::add(*theComps[(theBinFinder_outer.binIndex(crossings_outer.closestIndex)) + _num_innerpanels],
              tsos,
              prop,
              est,
              closestResult_outer);
 
   if (closestResult_outer.empty()) {
     Adder::add(*theComps[theBinFinder_outer.binIndex(crossings_outer.nextIndex) + _num_innerpanels],
                tsos,
                prop,
                est,
                result_outer);
     frontindex_outer = crossings_outer.nextIndex;
   } else {
     if (Adder::add(*theComps[theBinFinder_outer.binIndex(crossings_outer.nextIndex) + _num_innerpanels],
                    tsos,
                    prop,
                    est,
                    nextResult_outer)) {
       int crossingSide = LayerCrossingSide().endcapSide(tsos, prop);
       int theHelicity =
           computeHelicity(theComps[theBinFinder_outer.binIndex(crossings_outer.closestIndex) + _num_innerpanels],
                           theComps[theBinFinder_outer.binIndex(crossings_outer.nextIndex) + _num_innerpanels]);
       std::vector<DetGroup> tmp99 = closestResult_outer;
       DetGroupMerger::orderAndMergeTwoLevels(
           std::move(tmp99), std::move(nextResult_outer), result_outer, theHelicity, crossingSide);
       if (theHelicity == crossingSide)
         frontindex_outer = crossings_outer.closestIndex;
       else
         frontindex_outer = crossings_outer.nextIndex;
     } else {
       result_outer.swap(closestResult_outer);
       frontindex_outer = crossings_outer.closestIndex;
     }
   }
   if (!closestResult_outer.empty()) {
     DetGroupElement closestGel(closestResult_outer.front().front());
     float window = computeWindowSize(closestGel.det(), closestGel.trajectoryState(), est);
     searchNeighbors(tsos, prop, est, crossings_outer, window, result_outer, false);
   }
 
   if (result_inner.empty() && result_outer.empty())
     return;
   if (result_inner.empty())
     result.swap(result_outer);
   else if (result_outer.empty())
     result.swap(result_inner);
   else {
     int crossingSide = LayerCrossingSide().endcapSide(tsos, prop);
     int theHelicity = computeHelicity(theComps[theBinFinder_inner.binIndex(frontindex_inner)],
                                       theComps[theBinFinder_outer.binIndex(frontindex_outer) + _num_innerpanels]);
     DetGroupMerger::orderAndMergeTwoLevels(
         std::move(result_inner), std::move(result_outer), result, theHelicity, crossingSide);
   }
 }

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

private

Definition at line 220 of file PixelForwardLayerPhase1.cc.

References _num_innerpanels, _num_outerpanels, PVValHelper::add(), PeriodicBinFinderInPhi< T >::binIndex(), PixelForwardLayerPhase1::SubTurbineCrossings::closestIndex, computeHelicity(), LayerCrossingSide::endcapSide(), SiStripPI::max, HLT_FULL_cff::Merger, min(), eostools::move(), PixelForwardLayerPhase1::SubTurbineCrossings::nextIndex, theBinFinder_inner, theBinFinder_outer, 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 = (innerDisk ? _num_innerpanels / 4 : _num_outerpanels / 4);
 
   for (int idet = negStart; idet >= negStart - quarter + 1; idet--) {
     std::vector<DetGroup> tmp1;
     std::vector<DetGroup> newResult;
     if (innerDisk) {
       const GeometricSearchDet* neighbor = theComps[theBinFinder_inner.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_inner.binIndex(idet)], theComps[theBinFinder_inner.binIndex(idet + 1)]);
       std::vector<DetGroup> tmp2;
       tmp2.swap(result);
       Merger::orderAndMergeTwoLevels(std::move(tmp1), std::move(tmp2), newResult, theHelicity, crossingSide);
     } else {
       const GeometricSearchDet* neighbor = theComps[(theBinFinder_outer.binIndex(idet)) + _num_innerpanels];
       // 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_outer.binIndex(idet)) + _num_innerpanels],
                                         theComps[(theBinFinder_outer.binIndex(idet + 1)) + _num_innerpanels]);
       std::vector<DetGroup> tmp2;
       tmp2.swap(result);
       Merger::orderAndMergeTwoLevels(std::move(tmp1), std::move(tmp2), newResult, theHelicity, crossingSide);
     }
     result.swap(newResult);
   }
   for (int idet = posStart; idet < posStart + quarter - 1; idet++) {
     std::vector<DetGroup> tmp1;
     std::vector<DetGroup> newResult;
     if (innerDisk) {
       const GeometricSearchDet* neighbor = theComps[theBinFinder_inner.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_inner.binIndex(idet - 1)], theComps[theBinFinder_inner.binIndex(idet)]);
       std::vector<DetGroup> tmp2;
       tmp2.swap(result);
       Merger::orderAndMergeTwoLevels(std::move(tmp2), std::move(tmp1), newResult, theHelicity, crossingSide);
     } else {
       const GeometricSearchDet* neighbor = theComps[(theBinFinder_outer.binIndex(idet)) + _num_innerpanels];
       // 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_outer.binIndex(idet - 1)) + _num_innerpanels],
                                         theComps[(theBinFinder_outer.binIndex(idet)) + _num_innerpanels]);
       std::vector<DetGroup> tmp2;
       tmp2.swap(result);
       Merger::orderAndMergeTwoLevels(std::move(tmp2), std::move(tmp1), newResult, theHelicity, crossingSide);
     }
     result.swap(newResult);
   }
 }