TIDLayer Class Reference

#include <TIDLayer.h>

Inheritance diagram for TIDLayer:

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))
TIDLayer &	operator= (const TIDLayer &)=delete
virtual SubDetector	subDetector () const
	TIDLayer (std::vector< const TIDRing * > &rings) __attribute__((cold))
	TIDLayer (const TIDLayer &)=delete
	~TIDLayer () __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 15 of file TIDLayer.h.

Constructor & Destructor Documentation

TIDLayer::TIDLayer

(

std::vector< const TIDRing * > &

rings

)

Definition at line 123 of file TIDLayer.cc.

References basicComponents(), computeDisk(), fillRingPars(), mps_fire::i, LogDebug, position, theBasicComps, and theComps.

                                                :
  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

(

)

Definition at line 183 of file TIDLayer.cc.

References EnergyCorrector::c, theComponents, and theComps.

                   {
  for (auto c : theComps) delete c;

  delete theComponents.load();
} 

TIDLayer::TIDLayer ( const TIDLayer &  )

delete

Member Function Documentation

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

inlinevirtual

Definition at line 26 of file TIDLayer.h.

References components(), groupedCompatibleDetsV(), mps_fire::result, and theBasicComps.

Referenced by TIDLayer().

{return theBasicComps;}

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

virtual

Definition at line 94 of file TIDLayer.cc.

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

Referenced by basicComponents().

                                                                      {
  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;
 }

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

private

Definition at line 153 of file TIDLayer.cc.

References mps_fire::i, hpstanc_transforms::max, min(), and makeMuonMisalignmentScenario::rot.

Referenced by subDetector(), and TIDLayer().

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

}

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

private

Definition at line 308 of file TIDLayer.cc.

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

Referenced by groupedCompatibleDetsV(), and subDetector().

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

void TIDLayer::fillRingPars ( int  i )

private

Definition at line 111 of file TIDLayer.cc.

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

Referenced by subDetector(), and TIDLayer().

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

}

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

private

Definition at line 320 of file TIDLayer.cc.

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

Referenced by ringIndicesByCrossingProximity(), and subDetector().

{
  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;
}

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

private

Definition at line 337 of file TIDLayer.cc.

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

Referenced by ringIndicesByCrossingProximity(), and subDetector().

{

  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;
}

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

Definition at line 192 of file TIDLayer.cc.

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

Referenced by basicComponents().

{
  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  
#ifdef __INTEL_COMPILER
  const int ringOrder[3]{1,2,0};
#else
  constexpr int ringOrder[3]{1,2,0};
#endif
  auto index = [&ringIndices,& ringOrder](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);  
}

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

delete

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

private

Definition at line 360 of file TIDLayer.cc.

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

Referenced by groupedCompatibleDetsV(), and subDetector().

{
  // 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 > TIDLayer::ringIndicesByCrossingProximity ( const TrajectoryStateOnSurface &  startingState, const Propagator &  prop  ) const

private

Definition at line 256 of file TIDLayer.cc.

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

Referenced by groupedCompatibleDetsV(), and subDetector().

{
  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;
}

virtual SubDetector TIDLayer::subDetector ( ) const

inlinevirtual

Definition at line 36 of file TIDLayer.h.

References computeDisk(), computeWindowSize(), fillRingPars(), findClosest(), findNextIndex(), mps_fire::i, overlapInR(), ringIndicesByCrossingProximity(), GeomDetEnumerators::subDetGeom, GeomDetEnumerators::TID, and Phase2TrackerMonitorDigi_cff::ymax.

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

Member Data Documentation

RingPar TIDLayer::ringPars[3]

private

Definition at line 67 of file TIDLayer.h.

Referenced by findClosest(), findNextIndex(), and overlapInR().

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

private

Definition at line 63 of file TIDLayer.h.

Referenced by basicComponents(), and TIDLayer().

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

mutableprivate

Definition at line 64 of file TIDLayer.h.

Referenced by ~TIDLayer().

const TIDRing* TIDLayer::theComps[3]

private

Definition at line 65 of file TIDLayer.h.

Referenced by groupedCompatibleDetsV(), ringIndicesByCrossingProximity(), TIDLayer(), and ~TIDLayer().