MuRingForwardDoubleLayer Class Reference

#include <MuRingForwardDoubleLayer.h>

Inheritance diagram for MuRingForwardDoubleLayer:

Public Member Functions
const MuRingForwardLayer *	backLayer () const
const std::vector< const GeomDet * > &	basicComponents () const override
std::pair< bool, TrajectoryStateOnSurface >	compatible (const TrajectoryStateOnSurface &, const Propagator &, const MeasurementEstimator &) 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
const MuRingForwardLayer *	frontLayer () const
std::vector< DetGroup >	groupedCompatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const override
bool	isCrack (const GlobalPoint &gp) const
bool	isInsideOut (const TrajectoryStateOnSurface &tsos) const
	MuRingForwardDoubleLayer (const std::vector< const ForwardDetRing * > &frontRings, const std::vector< const ForwardDetRing * > &backRings)
	Constructor, takes ownership of pointers. More...
virtual const std::vector< const ForwardDetRing * > &	rings () const
	Return the vector of rings. More...
void	selfTest () const
SubDetector	subDetector () const override
	~MuRingForwardDoubleLayer () override

Protected Member Functions
BoundDisk *	computeSurface () override

Private Attributes
MuRingForwardLayer	theBackLayer
std::vector< const GeomDet * >	theBasicComponents
std::vector< const GeometricSearchDet * >	theComponents
MuRingForwardLayer	theFrontLayer
std::vector< const ForwardDetRing * >	theRings

Detailed Description

A plane composed two layers of disks. Represents forward muon CSC stations.

Author

R. Wilkinson

Definition at line 19 of file MuRingForwardDoubleLayer.h.

Constructor & Destructor Documentation

MuRingForwardDoubleLayer()

MuRingForwardDoubleLayer::MuRingForwardDoubleLayer	(	const std::vector< const ForwardDetRing * > &	frontRings,
		const std::vector< const ForwardDetRing * > &	backRings
	)

Constructor, takes ownership of pointers.

Definition at line 21 of file MuRingForwardDoubleLayer.cc.

    : RingedForwardLayer(true),
      theFrontLayer(frontRings),
      theBackLayer(backRings),
      theRings(frontRings),  // add back later
      theComponents(),
      theBasicComponents() {
  const std::string metname = "Muon|RecoMuon|RecoMuonDetLayers|MuRingForwardDoubleLayer";
 
  theRings.insert(theRings.end(), backRings.begin(), backRings.end());
  theComponents = std::vector<const GeometricSearchDet*>(theRings.begin(), theRings.end());
 
  // Cache chamber pointers (the basic components_)
  // and find extension in R and Z
  for (vector<const ForwardDetRing*>::const_iterator it = theRings.begin(); it != theRings.end(); it++) {
    vector<const GeomDet*> tmp2 = (*it)->basicComponents();
    theBasicComponents.insert(theBasicComponents.end(), tmp2.begin(), tmp2.end());
  }
 
  setSurface(computeSurface());
 
  LogTrace(metname) << "Constructing MuRingForwardDoubleLayer: " << basicComponents().size() << " Dets "
                    << theRings.size() << " Rings "
                    << " Z: " << specificSurface().position().z() << " R1: " << specificSurface().innerRadius()
                    << " R2: " << specificSurface().outerRadius();
 
  selfTest();
}

References basicComponents(), computeSurface(), LogTrace, metname, selfTest(), AlCaHLTBitMon_QueryRunRegistry::string, theBasicComponents, theComponents, and theRings.

~MuRingForwardDoubleLayer()

MuRingForwardDoubleLayer::~MuRingForwardDoubleLayer ( )

inlineoverride

Definition at line 25 of file MuRingForwardDoubleLayer.h.

{}

Member Function Documentation

backLayer()

const MuRingForwardLayer* MuRingForwardDoubleLayer::backLayer ( ) const

inline

Definition at line 59 of file MuRingForwardDoubleLayer.h.

{ return &theBackLayer; }

References theBackLayer.

basicComponents()

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

inlineoverride

Definition at line 29 of file MuRingForwardDoubleLayer.h.

{ return theBasicComponents; }

References theBasicComponents.

Referenced by MuRingForwardDoubleLayer().

compatible()

std::pair< bool, TrajectoryStateOnSurface > MuRingForwardDoubleLayer::compatible ( const TrajectoryStateOnSurface &  startingState, const Propagator &  prop, const MeasurementEstimator &  est  ) const

override

Definition at line 74 of file MuRingForwardDoubleLayer.cc.

                                                                                                                  {
  // mostly copied from ForwardDetLayer, except propagates to closest surface,
  // not to center
  const std::string metname = "Muon|RecoMuon|RecoMuonDetLayers|MuRingForwardDoubleLayer";
 
  bool insideOut = isInsideOut(startingState);
  const MuRingForwardLayer& closerLayer = (insideOut) ? theFrontLayer : theBackLayer;
  LogTrace("Muon|RecoMuon|RecoMuonDetLayers|MuRingForwardDoubleLayer")
      << "MuRingForwardDoubleLayer::compatible is assuming inside-out direction: " << insideOut;
 
  //std::pair<bool, TrajectoryStateOnSurface> result
  //  = closerLayer.compatible(startingState, prop, est);
  //if(!result.first)
  // {
  //  result = furtherLayer.compatible(startingState, prop, est);
  //}
 
  TrajectoryStateOnSurface myState = prop.propagate(startingState, closerLayer.specificSurface());
  if (!myState.isValid())
    return make_pair(false, myState);
 
  // take into account the thickness of the layer
  float deltaR = surface().bounds().thickness() / 2. * fabs(tan(myState.localDirection().theta()));
 
  // take into account the error on the predicted state
  const float nSigma = 3.;
  if (myState.hasError()) {
    LocalError err = myState.localError().positionError();
    // ignore correlation for the moment...
    deltaR += nSigma * sqrt(err.xx() + err.yy());
  }
 
  float zPos = (zmax() + zmin()) / 2.;
  SimpleDiskBounds tmp(rmin() - deltaR, rmax() + deltaR, zmin() - zPos, zmax() - zPos);
 
  return make_pair(tmp.inside(myState.localPosition()), myState);
}

References PbPb_ZMuSkimMuonDPG_cff::deltaR, submitPVResolutionJobs::err, TrajectoryStateOnSurface::hasError(), insideOut, isInsideOut(), TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localDirection(), TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localPosition(), LogTrace, metname, HLTSiStripMonitoring_cff::nSigma, LocalTrajectoryError::positionError(), Propagator::propagate(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, funct::tan(), theBackLayer, theFrontLayer, PV3DBase< T, PVType, FrameType >::theta(), createJobs::tmp, SiStripMonitorCluster_cfi::zmax, and SiStripMonitorCluster_cfi::zmin.

Referenced by compatibleDets().

compatibleDets()

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

override

Definition at line 113 of file MuRingForwardDoubleLayer.cc.

                                                                                                                  {
  vector<DetWithState> result;
  const std::string metname = "Muon|RecoMuon|RecoMuonDetLayers|MuRingForwardDoubleLayer";
  pair<bool, TrajectoryStateOnSurface> compat = compatible(startingState, prop, est);
 
  if (!compat.first) {
    LogTrace(metname) << "     MuRingForwardDoubleLayer::compatibleDets: not compatible"
                      << " (should not have been selected!)";
    return result;
  }
 
  TrajectoryStateOnSurface& tsos = compat.second;
 
  // standard implementation of compatibleDets() for class which have
  // groupedCompatibleDets implemented.
  // This code should be moved in a common place intead of being
  // copied many times.
  vector<DetGroup> vectorGroups = groupedCompatibleDets(tsos, prop, est);
  for (vector<DetGroup>::const_iterator itDG = vectorGroups.begin(); itDG != vectorGroups.end(); itDG++) {
    for (vector<DetGroupElement>::const_iterator itDGE = itDG->begin(); itDGE != itDG->end(); itDGE++) {
      result.push_back(DetWithState(itDGE->det(), itDGE->trajectoryState()));
    }
  }
  return result;
}

References compatible(), groupedCompatibleDets(), LogTrace, metname, mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

components()

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

inlineoverride

Definition at line 31 of file MuRingForwardDoubleLayer.h.

{ return theComponents; }

References theComponents.

computeSurface()

BoundDisk * MuRingForwardDoubleLayer::computeSurface ( )

overrideprotected

Definition at line 51 of file MuRingForwardDoubleLayer.cc.

                                                    {
  const BoundDisk& frontDisk = theFrontLayer.specificSurface();
  const BoundDisk& backDisk = theBackLayer.specificSurface();
 
  float rmin = min(frontDisk.innerRadius(), backDisk.innerRadius());
  float rmax = max(frontDisk.outerRadius(), backDisk.outerRadius());
  float zmin = frontDisk.position().z();
  float halfThickness = frontDisk.bounds().thickness() / 2.;
  zmin = (zmin > 0) ? zmin - halfThickness : zmin + halfThickness;
  float zmax = backDisk.position().z();
  halfThickness = backDisk.bounds().thickness() / 2.;
  zmax = (zmax > 0) ? zmax + halfThickness : zmax - halfThickness;
  float zPos = (zmax + zmin) / 2.;
  PositionType pos(0., 0., zPos);
  RotationType rot;
 
  return new BoundDisk(pos, rot, new SimpleDiskBounds(rmin, rmax, zmin - zPos, zmax - zPos));
}

References SiStripPI::max, min(), makeMuonMisalignmentScenario::rot, theBackLayer, theFrontLayer, SiStripMonitorCluster_cfi::zmax, and SiStripMonitorCluster_cfi::zmin.

Referenced by MuRingForwardDoubleLayer().

frontLayer()

const MuRingForwardLayer* MuRingForwardDoubleLayer::frontLayer ( ) const

inline

Definition at line 58 of file MuRingForwardDoubleLayer.h.

{ return &theFrontLayer; }

References theFrontLayer.

groupedCompatibleDets()

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

override

Definition at line 140 of file MuRingForwardDoubleLayer.cc.

                                                                                                        {
  const std::string metname = "Muon|RecoMuon|RecoMuonDetLayers|MuRingForwardDoubleLayer";
  vector<GeometricSearchDet::DetWithState> detWithStates1, detWithStates2;
 
  LogTrace(metname) << "groupedCompatibleDets are currently given always in inside-out order";
  // this should be fixed either in RecoMuon/MeasurementDet/MuonDetLayerMeasurements or
  // RecoMuon/DetLayers/MuRingForwardDoubleLayer
  // and removed the reverse operation in StandAloneMuonFilter::findBestMeasurements
 
  detWithStates1 = theFrontLayer.compatibleDets(startingState, prop, est);
  detWithStates2 = theBackLayer.compatibleDets(startingState, prop, est);
 
  vector<DetGroup> result;
  if (!detWithStates1.empty())
    result.push_back(DetGroup(detWithStates1));
  if (!detWithStates2.empty())
    result.push_back(DetGroup(detWithStates2));
  LogTrace(metname) << "DoubleLayer Compatible dets: " << result.size();
  return result;
}

References MuRingForwardLayer::compatibleDets(), LogTrace, metname, mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, theBackLayer, and theFrontLayer.

Referenced by compatibleDets().

isCrack()

bool MuRingForwardDoubleLayer::isCrack

(

const GlobalPoint &

gp

)

const

Definition at line 163 of file MuRingForwardDoubleLayer.cc.

                                                                  {
  const std::string metname = "Muon|RecoMuon|RecoMuonDetLayers|MuRingForwardDoubleLayer";
  // approximate
  bool result = false;
  double r = gp.perp();
  const std::vector<const ForwardDetRing*>& backRings = theBackLayer.rings();
  if (backRings.size() > 1) {
    const MuDetRing* innerRing = dynamic_cast<const MuDetRing*>(backRings[0]);
    const MuDetRing* outerRing = dynamic_cast<const MuDetRing*>(backRings[1]);
    assert(innerRing && outerRing);
    float crackInner = innerRing->specificSurface().outerRadius();
    float crackOuter = outerRing->specificSurface().innerRadius();
    LogTrace(metname) << "In a crack:" << crackInner << " " << r << " " << crackOuter;
    if (r > crackInner && r < crackOuter)
      return true;
  }
  // non-overlapping rings
  //double phi = gp.phi().degrees();
  return result;
}

References cms::cuda::assert(), runTauDisplay::gp, LogTrace, metname, alignCSCRings::r, mps_fire::result, MuRingForwardLayer::rings(), ForwardDetRing::specificSurface(), AlCaHLTBitMon_QueryRunRegistry::string, and theBackLayer.

isInsideOut()

bool MuRingForwardDoubleLayer::isInsideOut

(

const TrajectoryStateOnSurface &

tsos

)

const

Definition at line 70 of file MuRingForwardDoubleLayer.cc.

                                                                                     {
  return tsos.globalPosition().basicVector().dot(tsos.globalMomentum().basicVector()) > 0;
}

References PV3DBase< T, PVType, FrameType >::basicVector(), Basic3DVector< T >::dot(), TrajectoryStateOnSurface::globalMomentum(), and TrajectoryStateOnSurface::globalPosition().

Referenced by compatible().

rings()

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

inlinevirtual

Return the vector of rings.

Definition at line 54 of file MuRingForwardDoubleLayer.h.

{ return theRings; }

References theRings.

selfTest()

void MuRingForwardDoubleLayer::selfTest

(

)

const

Definition at line 184 of file MuRingForwardDoubleLayer.cc.

                                              {
  const std::vector<const GeomDet*>& frontDets = theFrontLayer.basicComponents();
  const std::vector<const GeomDet*>& backDets = theBackLayer.basicComponents();
 
  std::vector<const GeomDet*>::const_iterator frontItr = frontDets.begin(), lastFront = frontDets.end(),
                                              backItr = backDets.begin(), lastBack = backDets.end();
 
  // test that each front z is less than each back z
  for (; frontItr != lastFront; ++frontItr) {
    float frontz = fabs((**frontItr).surface().position().z());
    for (; backItr != lastBack; ++backItr) {
      float backz = fabs((**backItr).surface().position().z());
      assert(frontz < backz);
    }
  }
}

References cms::cuda::assert(), MuRingForwardLayer::basicComponents(), theBackLayer, and theFrontLayer.

Referenced by MuRingForwardDoubleLayer().

subDetector()

SubDetector MuRingForwardDoubleLayer::subDetector ( ) const

inlineoverride

Definition at line 49 of file MuRingForwardDoubleLayer.h.

{ return theBackLayer.subDetector(); }

References MuRingForwardLayer::subDetector(), and theBackLayer.

Member Data Documentation

theBackLayer

MuRingForwardLayer MuRingForwardDoubleLayer::theBackLayer

private

Definition at line 68 of file MuRingForwardDoubleLayer.h.

Referenced by backLayer(), compatible(), computeSurface(), groupedCompatibleDets(), isCrack(), selfTest(), and subDetector().

theBasicComponents

std::vector<const GeomDet*> MuRingForwardDoubleLayer::theBasicComponents

private

Definition at line 71 of file MuRingForwardDoubleLayer.h.

Referenced by basicComponents(), and MuRingForwardDoubleLayer().

theComponents

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

private

Definition at line 70 of file MuRingForwardDoubleLayer.h.

Referenced by components(), and MuRingForwardDoubleLayer().

theFrontLayer

MuRingForwardLayer MuRingForwardDoubleLayer::theFrontLayer

private

Definition at line 67 of file MuRingForwardDoubleLayer.h.

Referenced by compatible(), computeSurface(), frontLayer(), groupedCompatibleDets(), and selfTest().

theRings

std::vector<const ForwardDetRing*> MuRingForwardDoubleLayer::theRings

private

Definition at line 69 of file MuRingForwardDoubleLayer.h.

Referenced by MuRingForwardDoubleLayer(), and rings().