#include <MuRingForwardLayer.h>

Inheritance diagram for MuRingForwardLayer:

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

std::vector< DetWithState >	compatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const override

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

std::vector< DetGroup >	groupedCompatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const override

	MuRingForwardLayer (const std::vector< const ForwardDetRing *> &rings)
	Constructor, takes ownership of pointers. More...

virtual const std::vector< const ForwardDetRing * > &	rings () const
	Return the vector of rings. More...

SubDetector	subDetector () const override

	~MuRingForwardLayer () override

Private Attributes
bool	isOverlapping

std::vector< const GeomDet * >	theBasicComps

BaseBinFinder< double > *	theBinFinder

std::vector< const GeometricSearchDet * >	theComponents

std::vector< const ForwardDetRing * >	theRings

Detailed Description

A plane composed of disks (MuRingForwardDisk). Represents forward muon CSC/RPC stations.

Author: N. Amapane - INFN Torino

Definition at line 18 of file MuRingForwardLayer.h.

Constructor & Destructor Documentation

◆ MuRingForwardLayer()

MuRingForwardLayer::MuRingForwardLayer ( const std::vector< const ForwardDetRing *> & rings )

Constructor, takes ownership of pointers.

Definition at line 23 of file MuRingForwardLayer.cc.

References basicComponents(), isOverlapping, RBorderFinder::isROverlapping(), RBorderFinder::isRPeriodic(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, LogTrace, WZElectronSkims53X_cff::max, metname, SiStripPI::min, rings(), makeMuonMisalignmentScenario::rot, AlCaHLTBitMon_QueryRunRegistry::string, theBasicComps, theBinFinder, and theRings.

     : RingedForwardLayer(false),
       theRings(rings),
       theComponents(theRings.begin(), theRings.end()),
       theBinFinder(nullptr),
       isOverlapping(false) {
   const std::string metname = "Muon|RecoMuon|RecoMuonDetLayers|MuRingForwardLayer";
 
   // Initial values for R and Z bounds
   float theRmin = rings.front()->basicComponents().front()->position().perp();
   float theRmax = theRmin;
   float theZmin = rings.front()->position().z();
   float theZmax = theZmin;
 
   // Cache chamber pointers (the basic components_)
   // and find extension in R and Z
   for (vector<const ForwardDetRing*>::const_iterator it = rings.begin(); it != rings.end(); it++) {
     vector<const GeomDet*> tmp2 = (*it)->basicComponents();
     theBasicComps.insert(theBasicComps.end(), tmp2.begin(), tmp2.end());
 
     theRmin = min(theRmin, (*it)->specificSurface().innerRadius());
     theRmax = max(theRmax, (*it)->specificSurface().outerRadius());
     float halfThick = (*it)->surface().bounds().thickness() / 2.;
     float zCenter = (*it)->surface().position().z();
     theZmin = min(theZmin, zCenter - halfThick);
     theZmax = max(theZmax, zCenter + halfThick);
   }
 
   RBorderFinder bf(theRings);
   isOverlapping = bf.isROverlapping();
   theBinFinder = new GeneralBinFinderInR<double>(bf);
 
   // Build surface
 
   float zPos = (theZmax + theZmin) / 2.;
   PositionType pos(0., 0., zPos);
   RotationType rot;
 
   setSurface(new BoundDisk(pos, rot, new SimpleDiskBounds(theRmin, theRmax, theZmin - zPos, theZmax - zPos)));
 
   LogTrace(metname) << "Constructing MuRingForwardLayer: " << basicComponents().size() << " Dets " << theRings.size()
                     << " Rings "
                     << " Z: " << specificSurface().position().z() << " R1: " << specificSurface().innerRadius()
                     << " R2: " << specificSurface().outerRadius() << " Per.: " << bf.isRPeriodic()
                     << " Overl.: " << bf.isROverlapping();
 }

◆ ~MuRingForwardLayer()

MuRingForwardLayer::~MuRingForwardLayer ( )

override

Definition at line 70 of file MuRingForwardLayer.cc.

References mps_fire::i, theBinFinder, and theRings.

                                         {
   delete theBinFinder;
   for (vector<const ForwardDetRing*>::iterator i = theRings.begin(); i < theRings.end(); i++) {
     delete *i;
   }
 }

Member Function Documentation

◆ basicComponents()

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

inlineoverride

Definition at line 27 of file MuRingForwardLayer.h.

References theBasicComps.

Referenced by MuRingForwardLayer(), and MuRingForwardDoubleLayer::selfTest().

27 { return theBasicComps; }

MuRingForwardLayer::theBasicComps

std::vector< const GeomDet * > theBasicComps

Definition: MuRingForwardLayer.h:50

◆ compatibleDets()

vector< GeometricSearchDet::DetWithState > MuRingForwardLayer::compatibleDets	(	const TrajectoryStateOnSurface &	startingState,
		const Propagator &	prop,
		const MeasurementEstimator &	est
	)		const

override

Definition at line 77 of file MuRingForwardLayer.cc.

References BaseBinFinder< T >::binIndex(), pv::closest(), GeometricSearchDet::compatibleDets(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::hasError(), TrajectoryStateOnSurface::localError(), LogTrace, metname, PV3DBase< T, PVType, FrameType >::perp(), LocalTrajectoryError::positionError(), mps_fire::result, ForwardDetRing::specificSurface(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, theBinFinder, theRings, toLocal(), LocalError::xx(), and LocalError::yy().

Referenced by MuRingForwardDoubleLayer::groupedCompatibleDets().

                                                                                                                   {
   const std::string metname = "Muon|RecoMuon|RecoMuonDetLayers|MuRingForwardLayer";
   vector<DetWithState> result;
 
   LogTrace(metname) << "MuRingForwardLayer::compatibleDets,"
                     << " R1 " << specificSurface().innerRadius() << " R2: " << specificSurface().outerRadius()
                     << " FTS at R: " << startingState.globalPosition().perp();
 
   pair<bool, TrajectoryStateOnSurface> compat = compatible(startingState, prop, est);
 
   if (!compat.first) {
     LogTrace(metname) << "     MuRingForwardLayer::compatibleDets: not compatible"
                       << " (should not have been selected!)";
     return result;
   }
 
   TrajectoryStateOnSurface& tsos = compat.second;
 
   int closest = theBinFinder->binIndex(tsos.globalPosition().perp());
   const ForwardDetRing* closestRing = theRings[closest];
 
   // Check the closest ring
 
   LogTrace(metname) << "     MuRingForwardLayer::fastCompatibleDets, closestRing: " << closest << " R1 "
                     << closestRing->specificSurface().innerRadius()
                     << " R2: " << closestRing->specificSurface().outerRadius()
                     << " FTS R: " << tsos.globalPosition().perp();
   if (tsos.hasError()) {
     LogTrace(metname) << " sR: " << sqrt(tsos.localError().positionError().yy())
                       << " sX: " << sqrt(tsos.localError().positionError().xx());
   }
   LogTrace(metname) << endl;
 
   result = closestRing->compatibleDets(tsos, prop, est);
 
   int nclosest = result.size();
   int nnextdet = 0;  // MDEBUG counters
 
   //FIXME: if closest is not compatible next cannot be either?
 
   // Use state on layer surface. Note that local coordinates and errors
   // are the same on the layer and on all rings surfaces, since
   // all BoundDisks are centered in 0,0 and have the same rotation.
   // CAVEAT: if the rings are not at the same Z, the local position and error
   // will be "Z-projected" to the rings. This is a fairly good approximation.
   // However in this case additional propagation will be done when calling
   // compatibleDets.
   GlobalPoint startPos = tsos.globalPosition();
   LocalPoint nextPos(surface().toLocal(startPos));
 
   for (unsigned int idet = closest + 1; idet < theRings.size(); idet++) {
     bool inside = false;
     if (tsos.hasError()) {
       inside = theRings[idet]->specificSurface().bounds().inside(nextPos, tsos.localError().positionError());
     } else {
       inside = theRings[idet]->specificSurface().bounds().inside(nextPos);
     }
     if (inside) {
       LogTrace(metname) << "     MuRingForwardLayer::fastCompatibleDets:NextRing" << idet << " R1 "
                         << theRings[idet]->specificSurface().innerRadius()
                         << " R2: " << theRings[idet]->specificSurface().outerRadius() << " FTS R " << nextPos.perp();
       nnextdet++;
       vector<DetWithState> nextRodDets = theRings[idet]->compatibleDets(tsos, prop, est);
       if (!nextRodDets.empty()) {
         result.insert(result.end(), nextRodDets.begin(), nextRodDets.end());
       } else {
         break;
       }
     }
   }
 
   for (int idet = closest - 1; idet >= 0; idet--) {
     bool inside = false;
     if (tsos.hasError()) {
       inside = theRings[idet]->specificSurface().bounds().inside(nextPos, tsos.localError().positionError());
     } else {
       inside = theRings[idet]->specificSurface().bounds().inside(nextPos);
     }
     if (inside) {
       LogTrace(metname) << "     MuRingForwardLayer::fastCompatibleDets:PreviousRing:" << idet << " R1 "
                         << theRings[idet]->specificSurface().innerRadius()
                         << " R2: " << theRings[idet]->specificSurface().outerRadius() << " FTS R " << nextPos.perp();
       nnextdet++;
       vector<DetWithState> nextRodDets = theRings[idet]->compatibleDets(tsos, prop, est);
       if (!nextRodDets.empty()) {
         result.insert(result.end(), nextRodDets.begin(), nextRodDets.end());
       } else {
         break;
       }
     }
   }
 
   LogTrace(metname) << "     MuRingForwardLayer::fastCompatibleDets: found: " << result.size()
                     << " on closest: " << nclosest << " # checked rings: " << 1 + nnextdet;
 
   return result;
 }

◆ components()

const vector< const GeometricSearchDet * > & MuRingForwardLayer::components ( ) const

override

Definition at line 186 of file MuRingForwardLayer.cc.

References theComponents.

186 { return theComponents; }

MuRingForwardLayer::theComponents

std::vector< const GeometricSearchDet * > theComponents

Definition: MuRingForwardLayer.h:49

◆ groupedCompatibleDets()

vector< DetGroup > MuRingForwardLayer::groupedCompatibleDets	(	const TrajectoryStateOnSurface &	startingState,
		const Propagator &	prop,
		const MeasurementEstimator &	est
	)		const

override

Definition at line 176 of file MuRingForwardLayer.cc.

References gather_cfg::cout.

                                                                                                   {
   // FIXME should return only 1 group
   cout << "dummy implementation of MuRingForwardLayer::groupedCompatibleDets()" << endl;
   return vector<DetGroup>();
 }