#include <Phase2OTECRingedLayer.h>

Inheritance diagram for Phase2OTECRingedLayer:

Classes
struct	RingPar

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

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

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

Phase2OTECRingedLayer &	operator= (const Phase2OTECRingedLayer &)=delete

	Phase2OTECRingedLayer (std::vector< const Phase2OTECRing * > &rings) __attribute__((cold))

	Phase2OTECRingedLayer (const Phase2OTECRingedLayer &)=delete

virtual SubDetector	subDetector () const

	~Phase2OTECRingedLayer () __attribute__((cold))

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

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

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

std::array< int, 3 >	findThreeClosest (const GlobalPoint[15]) 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 [15]

std::vector< GeomDet const * >	theBasicComps

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

const Phase2OTECRing *	theComps [15]

Detailed Description

A concrete implementation for Phase 2 OT EC layer built out of Phase2OTECRings

Definition at line 16 of file Phase2OTECRingedLayer.h.

Constructor & Destructor Documentation

Phase2OTECRingedLayer::Phase2OTECRingedLayer ( std::vector< const Phase2OTECRing * > & rings )

Definition at line 50 of file Phase2OTECRingedLayer.cc.

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

Phase2OTECRingedLayer::~Phase2OTECRingedLayer ( )

Definition at line 110 of file Phase2OTECRingedLayer.cc.

References EnergyCorrector::c, theComponents, and theComps.

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

Phase2OTECRingedLayer::Phase2OTECRingedLayer ( const Phase2OTECRingedLayer & )

delete

Member Function Documentation

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

inlinevirtual

Definition at line 27 of file Phase2OTECRingedLayer.h.

References theBasicComps.

27 {return theBasicComps;}

Phase2OTECRingedLayer::theBasicComps

std::vector< GeomDet const * > theBasicComps

Definition: Phase2OTECRingedLayer.h:62

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

virtual

Definition at line 22 of file Phase2OTECRingedLayer.cc.

References EnergyCorrector::c, NOTECRINGS, and groupFilesInBlocks::temp.

                                                                                    {
   if (not theComponents) {
     std::unique_ptr<std::vector<const GeometricSearchDet*>> temp( new std::vector<const GeometricSearchDet*>() );
     temp->reserve(NOTECRINGS);
     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;
  }

BoundDisk * Phase2OTECRingedLayer::computeDisk ( const std::vector< const Phase2OTECRing * > & rings ) const

private

Definition at line 80 of file Phase2OTECRingedLayer.cc.

References i, bookConverter::max, min(), makeMuonMisalignmentScenario::rot, SiStripMonitorClusterAlca_cfi::zmax, and SiStripMonitorClusterAlca_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 Phase2OTECRing*>::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));
 
 }

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

private

Definition at line 275 of file Phase2OTECRingedLayer.cc.

References MeasurementEstimator::maximalLocalDisplacement(), GeomDet::surface(), and PV2DBase< T, PVType, FrameType >::y().

Referenced by groupedCompatibleDetsV().

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

void Phase2OTECRingedLayer::fillRingPars ( int i )

private

Definition at line 38 of file Phase2OTECRingedLayer.cc.

References funct::abs(), and 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.;
 
 }

std::array< int, 3 > Phase2OTECRingedLayer::findThreeClosest ( const GlobalPoint ringCrossing[15] ) const

private

Definition at line 286 of file Phase2OTECRingedLayer.cc.

References funct::abs(), i, NOTECRINGS, perp(), ringPars, and Phase2OTECRingedLayer::RingPar::theRingR.

Referenced by ringIndicesByCrossingProximity().

 {
   std::array<int,3> theBins={{-1,-1,-1}};
   theBins[0] = 0;
   float initialR =  ringPars[0].theRingR;
   float rDiff0 = std::abs( ringCrossing[0].perp() - initialR);
   float rDiff1 = -1.;
   float rDiff2 = -1.;
   for (int i = 1; i < NOTECRINGS ; i++){
     float ringR =  ringPars[i].theRingR;
     float testDiff = std::abs( ringCrossing[i].perp() - ringR);
     if ( testDiff<rDiff0 ) {
       rDiff2 = rDiff1;
       rDiff1 = rDiff0;
       rDiff0 = testDiff;
       theBins[2] = theBins[1];
       theBins[1] = theBins[0];
       theBins[0] = i;
     } 
     else 
     if ( rDiff1 < 0 || testDiff<rDiff1 ) {
       rDiff2 = rDiff1;
       rDiff1 = testDiff;
       theBins[2] = theBins[1];
       theBins[1] = i;
     } 
     else 
     if ( rDiff2 < 0 || testDiff<rDiff2 ) {
       rDiff2 = testDiff;
       theBins[2] = i;
     } 
   }
 
   return theBins;
 }

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

Definition at line 119 of file Phase2OTECRingedLayer.cc.

References DetGroupMerger::addSameLevel(), alongMomentum, computeWindowSize(), constexpr, TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), Phase2OTECRing::groupedCompatibleDetsV(), i, cmsHarvester::index, NOTECRINGS, DetGroupMerger::orderAndMergeTwoLevels(), overlapInR(), Propagator::propagationDirection(), ringIndicesByCrossingProximity(), theComps, and PV3DBase< T, PVType, FrameType >::z().

 {
   std::array<int,3> const & ringIndices = ringIndicesByCrossingProximity(startingState,prop);
   if ( ringIndices[0]==-1 || ringIndices[1] ==-1 || ringIndices[2] == -1 ) {
     edm::LogError("TkDetLayers") << "TkRingedForwardLayer::groupedCompatibleDets : error in CrossingProximity";
     return;
   }
 
   //order is odd rings in front of even rings
   constexpr int ringOrder[NOTECRINGS]{0,1,0,1,0,1,0,1,0,1,0,1,0,1,0};
   auto index = [&ringIndices,& ringOrder](int i) { return ringOrder[ringIndices[i]];};
 
   std::vector<DetGroup> closestResult;
   theComps[ringIndices[0]]->groupedCompatibleDetsV( startingState, prop, est, closestResult);       
   // if the closest is empty, use the next one and exit: inherited from TID !
   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); 
 
   // check if next ring and next next ring are found and if there is overlap
 
   bool ring1ok = ringIndices[1] != -1 && overlapInR(closestGel.trajectoryState(),ringIndices[1],rWindow);
   bool ring2ok = ringIndices[2] != -1 && overlapInR(closestGel.trajectoryState(),ringIndices[2],rWindow);
 
   // look for the two rings in the same plane (are they only two?)
 
   // determine if we are propagating from in to out (0) or from out to in (1)
 
   int direction = 0;
   if(startingState.globalPosition().z()*startingState.globalMomentum().z()>0) {
     if(prop.propagationDirection() == alongMomentum) direction=0;
     else direction=1;
   }
   else{
     if(prop.propagationDirection() == alongMomentum) direction=1;
     else direction=0;
   }
 
   if((index(0) == index(1)) && (index(0) == index(2))) {
     edm::LogInfo("AllRingsInOnePlane") << " All rings: " 
                        << ringIndices[0] << " " 
                        << ringIndices[1] << " " 
                        << ringIndices[2] << " in one plane. Only the first two will be considered";
     ring2ok=false;
   }
 
   if(index(0) == index(1)) {
     if(ring1ok) {
       std::vector<DetGroup> ring1res;
       theComps[ringIndices[1]]->groupedCompatibleDetsV( startingState, prop, est, ring1res);
       DetGroupMerger::addSameLevel(std::move(ring1res),closestResult);
     }
     if(ring2ok) {
       std::vector<DetGroup> ring2res;
       theComps[ringIndices[2]]->groupedCompatibleDetsV( startingState, prop, est, ring2res);
       DetGroupMerger::orderAndMergeTwoLevels(std::move(closestResult),std::move(ring2res),result,index(0),direction);
       return;
     }
     else {
       result.swap(closestResult);
       return;
     }
   }
   else if(index(0) == index(2)) {
     if(ring2ok) {
       std::vector<DetGroup> ring2res;
       theComps[ringIndices[2]]->groupedCompatibleDetsV( startingState, prop, est, ring2res);
       DetGroupMerger::addSameLevel(std::move(ring2res),closestResult);
     }
     if(ring1ok) {
       std::vector<DetGroup> ring1res;
       theComps[ringIndices[1]]->groupedCompatibleDetsV( startingState, prop, est, ring1res);
       DetGroupMerger::orderAndMergeTwoLevels(std::move(closestResult),std::move(ring1res),result,index(0),direction);
       return;
     }
     else {
       result.swap(closestResult);
       return;
     }
   }
   else {
     std::vector<DetGroup> ring12res;
     if(ring1ok) {
       std::vector<DetGroup> ring1res;
       theComps[ringIndices[1]]->groupedCompatibleDetsV( startingState, prop, est, ring1res);
       ring12res.swap(ring1res);
     } 
     if(ring2ok) {
       std::vector<DetGroup> ring2res;
       theComps[ringIndices[2]]->groupedCompatibleDetsV( startingState, prop, est, ring2res);
       DetGroupMerger::addSameLevel(std::move(ring2res),ring12res);
     }
     if(!ring12res.empty()) {
       DetGroupMerger::orderAndMergeTwoLevels(std::move(closestResult),std::move(ring12res),result,index(0),direction);
       return;
     }
     else {
       result.swap(closestResult);
       return;
     }
   }
 }

Phase2OTECRingedLayer& Phase2OTECRingedLayer::operator= ( const Phase2OTECRingedLayer & )

delete

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

private

Definition at line 323 of file Phase2OTECRingedLayer.cc.

References funct::abs(), f, TrajectoryStateOnSurface::globalPosition(), cmsHarvester::index, bookConverter::max, PV3DBase< T, PVType, FrameType >::perp(), ringPars, Phase2OTECRingedLayer::RingPar::thetaRingMax, Phase2OTECRingedLayer::RingPar::thetaRingMin, SiStripMonitorClusterAlca_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);
 }

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

private

Definition at line 231 of file Phase2OTECRingedLayer.cc.

References findThreeClosest(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), i, NOTECRINGS, Propagator::propagationDirection(), rho, Phase2OTECRing::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[NOTECRINGS];
   // vector<GlobalVector>  ringXDirections;
 
   for (int i = 0; i < NOTECRINGS ; 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.));
     }
   }
 
   //find three closest rings to the crossing
 
   std::array<int,3> closests = findThreeClosest(ringCrossings);
 
   return closests;
 }