#include <TIDLayer.h>

Inheritance diagram for TIDLayer:

Classes
struct	RingPar

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

const std::vector< const GeometricSearchDet * > &	components () const override __attribute__((cold))

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

TIDLayer &	operator= (const TIDLayer &)=delete

SubDetector	subDetector () const override

	TIDLayer (std::vector< const TIDRing *> &rings) __attribute__((cold))

	TIDLayer (const TIDLayer &)=delete

	~TIDLayer () override __attribute__((cold))

Private Member Functions
BoundDisk *	computeDisk (const std::vector< const TIDRing *> &rings) const __attribute__((cold))

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

void	fillRingPars (int i) __attribute__((cold))

int	findClosest (const GlobalPoint[3]) const __attribute__((hot))

int	findNextIndex (const GlobalPoint[3], int) const __attribute__((hot))

bool	overlapInR (const TrajectoryStateOnSurface &tsos, int i, double ymax) const __attribute__((hot))

std::array< int, 3 >	ringIndicesByCrossingProximity (const TrajectoryStateOnSurface &startingState, const Propagator &prop) const

Private Attributes
RingPar	ringPars [3]

std::vector< GeomDet const * >	theBasicComps

std::atomic< std::vector< const GeometricSearchDet * > * >	theComponents

const TIDRing *	theComps [3]

Detailed Description

A concrete implementation for TID layer built out of TIDRings

Definition at line 14 of file TIDLayer.h.

Constructor & Destructor Documentation

◆ TIDLayer() [1/2]

TIDLayer::TIDLayer ( std::vector< const TIDRing *> & rings )

Definition at line 104 of file TIDLayer.cc.

                                                 : RingedForwardLayer(true), theComponents{nullptr} {
   //They should be already R-ordered. TO BE CHECKED!!
   //sort( theRings.begin(), theRings.end(), DetLessR());
 
   if (rings.size() != 3)
     throw DetLayerException("Number of rings in TID layer is not equal to 3 !!");
   setSurface(computeDisk(rings));
 
   for (int i = 0; i != 3; ++i) {
     theComps[i] = rings[i];
     fillRingPars(i);
     theBasicComps.insert(
         theBasicComps.end(), (*rings[i]).basicComponents().begin(), (*rings[i]).basicComponents().end());
   }
 
   LogDebug("TkDetLayers") << "==== DEBUG TIDLayer =====";
   LogDebug("TkDetLayers") << "r,zed pos  , thickness, innerR, outerR: " << this->position().perp() << " , "
                           << this->position().z() << " , " << this->specificSurface().bounds().thickness() << " , "
                           << this->specificSurface().innerRadius() << " , " << this->specificSurface().outerRadius();
 }

◆ ~TIDLayer()

TIDLayer::~TIDLayer ( )

override

Definition at line 149 of file TIDLayer.cc.

References c, theComponents, and theComps.

                     {
   for (auto c : theComps)
     delete c;
 
   delete theComponents.load();
 }

◆ TIDLayer() [2/2]

TIDLayer::TIDLayer ( const TIDLayer & )

delete

Member Function Documentation

◆ basicComponents()

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

inlineoverride

Definition at line 25 of file TIDLayer.h.

References theBasicComps.

25 { return theBasicComps; }

TIDLayer::theBasicComps

std::vector< GeomDet const * > theBasicComps

Definition: TIDLayer.h:60

◆ components()

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

override

Definition at line 79 of file TIDLayer.cc.

References c, and groupFilesInBlocks::temp.

                                                                        {
   if (not theComponents) {
     auto temp = std::make_unique<std::vector<const GeometricSearchDet*>>();
     temp->reserve(3);
     for (auto c : theComps)
       temp->push_back(c);
     std::vector<const GeometricSearchDet*>* expected = nullptr;
     if (theComponents.compare_exchange_strong(expected, temp.get())) {
       //this thread set the value
       temp.release();
     }
   }
 
   return *theComponents;
 }

◆ computeDisk()

BoundDisk * TIDLayer::computeDisk ( const std::vector< const TIDRing *> & rings ) const

private

Definition at line 125 of file TIDLayer.cc.

References mps_fire::i, SiStripPI::max, SiStripPI::min, makeMuonMisalignmentScenario::rot, SiStripMonitorCluster_cfi::zmax, and SiStripMonitorCluster_cfi::zmin.

                                                                           {
   float theRmin = rings.front()->specificSurface().innerRadius();
   float theRmax = rings.front()->specificSurface().outerRadius();
   float theZmin = rings.front()->position().z() - rings.front()->surface().bounds().thickness() / 2;
   float theZmax = rings.front()->position().z() + rings.front()->surface().bounds().thickness() / 2;
 
   for (vector<const TIDRing*>::const_iterator i = rings.begin(); i != rings.end(); i++) {
     float rmin = (**i).specificSurface().innerRadius();
     float rmax = (**i).specificSurface().outerRadius();
     float zmin = (**i).position().z() - (**i).surface().bounds().thickness() / 2.;
     float zmax = (**i).position().z() + (**i).surface().bounds().thickness() / 2.;
     theRmin = min(theRmin, rmin);
     theRmax = max(theRmax, rmax);
     theZmin = min(theZmin, zmin);
     theZmax = max(theZmax, zmax);
   }
 
   float zPos = (theZmax + theZmin) / 2.;
   PositionType pos(0., 0., zPos);
   RotationType rot;
 
   return new BoundDisk(pos, rot, new SimpleDiskBounds(theRmin, theRmax, theZmin - zPos, theZmax - zPos));
 }

◆ computeWindowSize()

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

private

Definition at line 260 of file TIDLayer.cc.

References particleFlowClusterHGC_cfi::maxDistance, MeasurementEstimator::maximalLocalDisplacement(), and GeomDet::surface().

Referenced by groupedCompatibleDetsV().

                                                                          {
   const Plane& startPlane = det->surface();
   MeasurementEstimator::Local2DVector maxDistance = est.maximalLocalDisplacement(tsos, startPlane);
   return maxDistance.y();
 }

◆ fillRingPars()

void TIDLayer::fillRingPars ( int i )

private

Definition at line 95 of file TIDLayer.cc.

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

                                  {
   const BoundDisk& ringDisk = static_cast<const BoundDisk&>(theComps[i]->surface());
   float ringMinZ = std::abs(ringDisk.position().z()) - ringDisk.bounds().thickness() / 2.;
   float ringMaxZ = std::abs(ringDisk.position().z()) + ringDisk.bounds().thickness() / 2.;
   ringPars[i].thetaRingMin = ringDisk.innerRadius() / ringMaxZ;
   ringPars[i].thetaRingMax = ringDisk.outerRadius() / ringMinZ;
   ringPars[i].theRingR = (ringDisk.innerRadius() + ringDisk.outerRadius()) / 2.;
 }

◆ findClosest()

int TIDLayer::findClosest ( const GlobalPoint ringCrossing[3] ) const

private

Definition at line 268 of file TIDLayer.cc.

References funct::abs(), mps_fire::i, perp(), ringPars, and TIDLayer::RingPar::theRingR.

Referenced by ringIndicesByCrossingProximity().

                                                                  {
   int theBin = 0;
   float initialR = ringPars[0].theRingR;
   float rDiff = std::abs(ringCrossing[0].perp() - initialR);
   for (int i = 1; i < 3; i++) {
     float ringR = ringPars[i].theRingR;
     float testDiff = std::abs(ringCrossing[i].perp() - ringR);
     if (testDiff < rDiff) {
       rDiff = testDiff;
       theBin = i;
     }
   }
   return theBin;
 }

◆ findNextIndex()

int TIDLayer::findNextIndex	(	const GlobalPoint	ringCrossing[3],
		int	closest
	)		const

private

Definition at line 283 of file TIDLayer.cc.

References funct::abs(), pv::closest(), mps_fire::i, perp(), ringPars, and TIDLayer::RingPar::theRingR.

Referenced by ringIndicesByCrossingProximity().

                                                                                 {
   int firstIndexToCheck = (closest != 0) ? 0 : 1;
   float initialR = ringPars[firstIndexToCheck].theRingR;
   float rDiff = std::abs(ringCrossing[firstIndexToCheck].perp() - initialR);
   int theBin = firstIndexToCheck;
   for (int i = firstIndexToCheck + 1; i < 3; i++) {
     if (i != closest) {
       float ringR = ringPars[i].theRingR;
       float testDiff = std::abs(ringCrossing[i].perp() - ringR);
       if (testDiff < rDiff) {
         rDiff = testDiff;
         theBin = i;
       }
     }
   }
   return theBin;
 }

◆ groupedCompatibleDetsV()

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

override

Definition at line 156 of file TIDLayer.cc.

References computeWindowSize(), TIDRing::groupedCompatibleDetsV(), mps_fire::i, overlapInR(), mps_fire::result, ringIndicesByCrossingProximity(), and theComps.

                                                                          {
   std::array<int, 3> const& ringIndices = ringIndicesByCrossingProximity(startingState, prop);
   if (ringIndices[0] == -1) {
     edm::LogError("TkDetLayers") << "TkRingedForwardLayer::groupedCompatibleDets : error in CrossingProximity";
     return;
   }
 
   std::array<vector<DetGroup>, 3> groupsAtRingLevel;
   //order is ring3,ring1,ring2 i.e. 2 0 1
   //                                0 1 2
   static constexpr int ringOrder[3]{1, 2, 0};
   auto index = [&ringIndices](int i) { return ringOrder[ringIndices[i]]; };
 
   auto& closestResult = groupsAtRingLevel[index(0)];
   theComps[ringIndices[0]]->groupedCompatibleDetsV(startingState, prop, est, closestResult);
   if (closestResult.empty()) {
     theComps[ringIndices[1]]->groupedCompatibleDetsV(startingState, prop, est, result);
     return;
   }
 
   DetGroupElement closestGel(closestResult.front().front());
   float rWindow = computeWindowSize(closestGel.det(), closestGel.trajectoryState(), est);
 
   if (!overlapInR(closestGel.trajectoryState(), ringIndices[1], rWindow)) {
     result.swap(closestResult);
     return;
   }
 
   auto& nextResult = groupsAtRingLevel[index(1)];
   theComps[ringIndices[1]]->groupedCompatibleDetsV(startingState, prop, est, nextResult);
   if (nextResult.empty()) {
     result.swap(closestResult);
     return;
   }
 
   if (!overlapInR(closestGel.trajectoryState(), ringIndices[2], rWindow)) {
     //then merge 2 levels & return
     orderAndMergeLevels(closestGel.trajectoryState(), prop, groupsAtRingLevel, result);
     return;
   }
 
   auto& nextNextResult = groupsAtRingLevel[index(2)];
   theComps[ringIndices[2]]->groupedCompatibleDetsV(startingState, prop, est, nextNextResult);
   if (nextNextResult.empty()) {
     // then merge 2 levels and return
     orderAndMergeLevels(closestGel.trajectoryState(), prop, groupsAtRingLevel, result);  //
     return;
   }
 
   // merge 3 level and return merged
   orderAndMergeLevels(closestGel.trajectoryState(), prop, groupsAtRingLevel, result);
 }

◆ operator=()

TIDLayer& TIDLayer::operator= ( const TIDLayer & )

delete

◆ overlapInR()

bool TIDLayer::overlapInR	(	const TrajectoryStateOnSurface &	tsos,
		int	i,
		double	ymax
	)		const

private

Definition at line 301 of file TIDLayer.cc.

References funct::abs(), f, TrajectoryStateOnSurface::globalPosition(), SiStripPI::max, PV3DBase< T, PVType, FrameType >::perp(), ringPars, TIDLayer::RingPar::thetaRingMax, TIDLayer::RingPar::thetaRingMin, L1TOccupancyClient_cfi::ymax, and PV3DBase< T, PVType, FrameType >::z().

Referenced by groupedCompatibleDetsV().

                                                                                             {
   // assume "fixed theta window", i.e. margin in local y = r is changing linearly with z
   float tsRadius = tsos.globalPosition().perp();
   float thetamin = (max(0., tsRadius - ymax)) / (std::abs(tsos.globalPosition().z()) + 10.f);  // add 10 cm contingency
   float thetamax = (tsRadius + ymax) / (std::abs(tsos.globalPosition().z()) - 10.f);
 
   // do the theta regions overlap ?
 
   return !(thetamin > ringPars[index].thetaRingMax || ringPars[index].thetaRingMin > thetamax);
 }

◆ ringIndicesByCrossingProximity()

std::array< int, 3 > TIDLayer::ringIndicesByCrossingProximity	(	const TrajectoryStateOnSurface &	startingState,
		const Propagator &	prop
	)		const

private

Definition at line 212 of file TIDLayer.cc.

References findClosest(), findNextIndex(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), mps_fire::i, dqmdumpme::indices, Propagator::propagationDirection(), rho, TIDRing::surface(), theComps, and TrajectoryStateOnSurface::transverseCurvature().

Referenced by groupedCompatibleDetsV().

                                                                                           {
   typedef HelixForwardPlaneCrossing Crossing;
   typedef MeasurementEstimator::Local2DVector Local2DVector;
 
   HelixPlaneCrossing::PositionType startPos(startingState.globalPosition());
   HelixPlaneCrossing::DirectionType startDir(startingState.globalMomentum());
   PropagationDirection propDir(prop.propagationDirection());
   float rho(startingState.transverseCurvature());
 
   // calculate the crossings with the ring surfaces
   // rings are assumed to be sorted in R !
 
   Crossing myXing(startPos, startDir, rho, propDir);
 
   GlobalPoint ringCrossings[3];
   // vector<GlobalVector>  ringXDirections;
 
   for (int i = 0; i < 3; i++) {
     const BoundDisk& theRing = static_cast<const BoundDisk&>(theComps[i]->surface());
     pair<bool, double> pathlen = myXing.pathLength(theRing);
     if (pathlen.first) {
       ringCrossings[i] = GlobalPoint(myXing.position(pathlen.second));
       // ringXDirections.push_back( GlobalVector( myXing.direction(pathlen.second )));
     } else {
       // TO FIX.... perhaps there is something smarter to do
       //throw DetLayerException("trajectory doesn't cross TID rings");
       ringCrossings[i] = GlobalPoint(0., 0., 0.);
       //  ringXDirections.push_back( GlobalVector( 0.,0.,0.));
     }
   }
 
   int closestIndex = findClosest(ringCrossings);
   int nextIndex = findNextIndex(ringCrossings, closestIndex);
   if (closestIndex < 0 || nextIndex < 0)
     return std::array<int, 3>{{-1, -1, -1}};
   int nextNextIndex = -1;
   for (int i = 0; i < 3; i++) {
     if (i != closestIndex && i != nextIndex) {
       nextNextIndex = i;
       break;
     }
   }
 
   std::array<int, 3> indices{{closestIndex, nextIndex, nextNextIndex}};
   return indices;
 }