MuRingForwardDoubleLayer Class Reference

#include <MuRingForwardDoubleLayer.h>

Inheritance diagram for MuRingForwardDoubleLayer:

Public Member Functions
const MuRingForwardLayer *	backLayer () const
virtual const std::vector < const GeomDet * > &	basicComponents () const
virtual std::pair< bool, TrajectoryStateOnSurface >	compatible (const TrajectoryStateOnSurface &, const Propagator &, const MeasurementEstimator &) const
virtual std::vector< DetWithState >	compatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const
virtual const std::vector < const GeometricSearchDet * > &	components () const
	Returns basic components, if any. More...
const MuRingForwardLayer *	frontLayer () const
virtual std::vector< DetGroup >	groupedCompatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const
virtual bool	hasGroups () const
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
virtual SubDetector	subDetector () const
	The type of detector (PixelBarrel, PixelEndcap, TIB, TOB, TID, TEC, CSC, DT, RPCBarrel, RPCEndcap) More...
virtual	~MuRingForwardDoubleLayer ()
Public Member Functions inherited from RingedForwardLayer
	RingedForwardLayer ()
virtual	~RingedForwardLayer ()
Public Member Functions inherited from ForwardDetLayer
bool	contains (const Local3DPoint &p) const
	ForwardDetLayer ()
virtual Location	location () const GCC11_FINAL
	Which part of the detector (barrel, endcap) More...
virtual const BoundDisk &	specificSurface () const GCC11_FINAL
virtual const BoundSurface &	surface () const GCC11_FINAL
	The surface of the GeometricSearchDet. More...
virtual	~ForwardDetLayer ()
Public Member Functions inherited from DetLayer
template<typename... Args>
std::vector< const DetLayer * >	compatibleLayers (Args &&...args) const
	Returns all layers compatible. More...
	DetLayer (bool ibar)
bool	isBarrel () const
bool	isForward () const
NavigableLayer *	navigableLayer () const
	Return the NavigableLayer associated with this DetLayer. More...
template<typename... Args>
std::vector< const DetLayer * >	nextLayers (Args &&...args) const
int	seqNum () const
void	setNavigableLayer (NavigableLayer *nlp)
	Set the NavigableLayer associated with this DetLayer. More...
void	setSeqNum (int sq)
virtual	~DetLayer ()
Public Member Functions inherited from GeometricSearchDet
virtual void	compatibleDetsV (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetWithState > &result) const
	GeometricSearchDet ()
virtual void	groupedCompatibleDetsV (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetGroup > &result) const
virtual const Surface::PositionType &	position () const
	Returns position of the surface. More...
virtual	~GeometricSearchDet ()

Protected Member Functions
virtual BoundDisk *	computeSurface ()
Protected Member Functions inherited from ForwardDetLayer
virtual void	initialize ()
float	rmax () const
float	rmin () const
void	setSurface (BoundDisk *cp)
float	zmax () const
float	zmin () const

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

Additional Inherited Members
Public Types inherited from DetLayer
typedef GeomDetEnumerators::Location	Location
typedef GeomDetEnumerators::SubDetector	SubDetector
Public Types inherited from GeometricSearchDet
typedef std::pair< const GeomDet *, TrajectoryStateOnSurface >	DetWithState
typedef BoundSurface::PositionType	PositionType
typedef BoundSurface::RotationType	RotationType
typedef TrajectoryStateOnSurface	TrajectoryState
Protected Attributes inherited from GeometricSearchDet
GeomDetCompatibilityChecker	theCompatibilityChecker

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	(	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.

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

                                                                                       :

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

virtual MuRingForwardDoubleLayer::~MuRingForwardDoubleLayer ( )

inlinevirtual

Definition at line 27 of file MuRingForwardDoubleLayer.h.

{}

Member Function Documentation

const MuRingForwardLayer* MuRingForwardDoubleLayer::backLayer ( ) const

inline

Definition at line 69 of file MuRingForwardDoubleLayer.h.

References theBackLayer.

{return &theBackLayer;}

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

inlinevirtual

Implements GeometricSearchDet.

Definition at line 32 of file MuRingForwardDoubleLayer.h.

References theBasicComponents.

Referenced by MuRingForwardDoubleLayer().

{return theBasicComponents;}

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

virtual

tests the geometrical compatibility of the Det with the predicted state. The FreeTrajectoryState argument is propagated to the Det surface using the Propagator argument. The resulting TrajectoryStateOnSurface is tested for compatibility with the surface bounds. If compatible, a std::pair< true, propagatedState> is returned. If the propagation fails, or if the state is not compatible, a std::pair< false, propagatedState> is returned.

Reimplemented from ForwardDetLayer.

Definition at line 88 of file MuRingForwardDoubleLayer.cc.

References Surface::bounds(), deltaR(), TrajectoryStateOnSurface::hasError(), insideOut, isInsideOut(), TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localDirection(), TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localPosition(), LogTrace, metname, LocalTrajectoryError::positionError(), Propagator::propagate(), ForwardDetLayer::rmax(), ForwardDetLayer::rmin(), ForwardDetLayer::specificSurface(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, ForwardDetLayer::surface(), funct::tan(), theBackLayer, theFrontLayer, PV3DBase< T, PVType, FrameType >::theta(), Bounds::thickness(), tmp, LocalError::xx(), LocalError::yy(), ForwardDetLayer::zmax(), ForwardDetLayer::zmin(), and zPos.

Referenced by compatibleDets().

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

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

virtual

Returns all Dets compatible with a trajectory state according to the estimator est. The startingState should be propagated to the surface of each compatible Det using the Propagator passed as an argument. The default implementation should be overridden in dets with specific surface types to avoid propagation to a generic Surface

Reimplemented from GeometricSearchDet.

Definition at line 133 of file MuRingForwardDoubleLayer.cc.

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

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

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

inlinevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 34 of file MuRingForwardDoubleLayer.h.

References theComponents.

{return theComponents;}

BoundDisk * MuRingForwardDoubleLayer::computeSurface ( )

protectedvirtual

Reimplemented from ForwardDetLayer.

Definition at line 57 of file MuRingForwardDoubleLayer.cc.

References max(), bookConverter::min, ForwardDetLayer::rmax(), ForwardDetLayer::rmin(), makeMuonMisalignmentScenario::rot, ForwardDetLayer::specificSurface(), theBackLayer, theFrontLayer, ForwardDetLayer::zmax(), ForwardDetLayer::zmin(), and zPos.

Referenced by MuRingForwardDoubleLayer().

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

const MuRingForwardLayer* MuRingForwardDoubleLayer::frontLayer ( ) const

inline

Definition at line 68 of file MuRingForwardDoubleLayer.h.

References theFrontLayer.

{return &theFrontLayer;}

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

virtual

Similar to compatibleDets(), but the compatible Dets are grouped in one or more groups. Dets are put in the same group if they are mutually exclusive for track crossing, i.e. a reconstructible track cannot cross more than one Det from a group. Pathological tracks (spirals etc.) can of course violate this rule.
The DetGroups are sorted in the sequence of crossing by a track. In order to define the direction of crossing the Propagator used in this method should have a defined direction() : either "alongMomentum" or "oppositeToMomentum" but not "anyDirection".
The three signatures of this method differ by the input trajectory state arguments: the starting state can be a TrajectoryStateOnSurface or a FreeTrajectoryState, and the state on this CompositeDet may be already known or not. The last two arguments are as for the method compatibleDets().
First signature: The first argument is a TrajectoryStateOnSurface, usually not on the surface of this CompositeDet.

Reimplemented from GeometricSearchDet.

Definition at line 168 of file MuRingForwardDoubleLayer.cc.

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

Referenced by compatibleDets().

                                                                                  {

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

virtual bool MuRingForwardDoubleLayer::hasGroups ( ) const

inlinevirtual

Implements GeometricSearchDet.

Definition at line 54 of file MuRingForwardDoubleLayer.h.

{return true;}

bool MuRingForwardDoubleLayer::isCrack

(

const GlobalPoint &

gp

)

const

Definition at line 191 of file MuRingForwardDoubleLayer.cc.

References LogTrace, metname, PV3DBase< T, PVType, FrameType >::perp(), alignCSCRings::r, query::result, MuRingForwardLayer::rings(), ForwardDetRing::specificSurface(), AlCaHLTBitMon_QueryRunRegistry::string, and theBackLayer.

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

bool MuRingForwardDoubleLayer::isInsideOut

(

const TrajectoryStateOnSurface &

tsos

)

const

Definition at line 80 of file MuRingForwardDoubleLayer.cc.

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

Referenced by compatible().

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

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

inlinevirtual

Return the vector of rings.

Definition at line 64 of file MuRingForwardDoubleLayer.h.

References theRings.

{return theRings;}

void MuRingForwardDoubleLayer::selfTest

(

)

const

Definition at line 214 of file MuRingForwardDoubleLayer.cc.

References MuRingForwardLayer::basicComponents(), theBackLayer, and theFrontLayer.

Referenced by MuRingForwardDoubleLayer().

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

virtual SubDetector MuRingForwardDoubleLayer::subDetector ( ) const

inlinevirtual

The type of detector (PixelBarrel, PixelEndcap, TIB, TOB, TID, TEC, CSC, DT, RPCBarrel, RPCEndcap)

Implements DetLayer.

Definition at line 58 of file MuRingForwardDoubleLayer.h.

References MuRingForwardLayer::subDetector(), and theBackLayer.

{return theBackLayer.subDetector();}

Member Data Documentation

MuRingForwardLayer MuRingForwardDoubleLayer::theBackLayer

private

Definition at line 76 of file MuRingForwardDoubleLayer.h.

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

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

private

Definition at line 79 of file MuRingForwardDoubleLayer.h.

Referenced by basicComponents(), and MuRingForwardDoubleLayer().

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

private

Definition at line 78 of file MuRingForwardDoubleLayer.h.

Referenced by components(), and MuRingForwardDoubleLayer().

MuRingForwardLayer MuRingForwardDoubleLayer::theFrontLayer

private

Definition at line 75 of file MuRingForwardDoubleLayer.h.

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

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

private

Definition at line 77 of file MuRingForwardDoubleLayer.h.

Referenced by MuRingForwardDoubleLayer(), and rings().