MuRingForwardLayer Class Reference

#include <MuRingForwardLayer.h>

Inheritance diagram for MuRingForwardLayer:

Public Member Functions
virtual const std::vector < const GeomDet * > &	basicComponents () const
virtual std::vector< DetWithState >	compatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const
virtual const std::vector < const GeometricSearchDet * > &	components () const
virtual std::vector< DetGroup >	groupedCompatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const
	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...
virtual SubDetector	subDetector () const
virtual	~MuRingForwardLayer ()

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

(

const std::vector< const ForwardDetRing * > &

rings

)

Constructor, takes ownership of pointers.

Definition at line 24 of file MuRingForwardLayer.cc.

References basicComponents(), isOverlapping, RBorderFinder::isROverlapping(), RBorderFinder::isRPeriodic(), LogTrace, bookConverter::max, metname, min(), makeMuonMisalignmentScenario::rot, AlCaHLTBitMon_QueryRunRegistry::string, theBasicComps, theBinFinder, and theRings.

                                                                                 :
  RingedForwardLayer(false),
  theRings(rings),
  theComponents(theRings.begin(),theRings.end()),
  theBinFinder(0),
  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 ( )

virtual

Definition at line 82 of file MuRingForwardLayer.cc.

References i, theBinFinder, and theRings.

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

Member Function Documentation

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

inlinevirtual

Definition at line 30 of file MuRingForwardLayer.h.

References theBasicComps.

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

{return theBasicComps;}

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

virtual

Definition at line 90 of file MuRingForwardLayer.cc.

References BaseBinFinder< T >::binIndex(), 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.size()!=0) {
    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.size()!=0) {
    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;
}

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

virtual

Definition at line 222 of file MuRingForwardLayer.cc.

References theComponents.

                                     {
  return theComponents;
}

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

virtual

Definition at line 207 of file MuRingForwardLayer.cc.

References gather_cfg::cout.

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

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

inlinevirtual

Return the vector of rings.

Definition at line 53 of file MuRingForwardLayer.h.

References theRings.

Referenced by MuRingForwardDoubleLayer::isCrack().

{return theRings;}

GeomDetEnumerators::SubDetector MuRingForwardLayer::subDetector ( ) const

virtual

Definition at line 217 of file MuRingForwardLayer.cc.

References theBasicComps.

Referenced by MuRingForwardDoubleLayer::subDetector().

                                                                    {
  return theBasicComps.front()->subDetector();
}

Member Data Documentation

bool MuRingForwardLayer::isOverlapping

private

Definition at line 61 of file MuRingForwardLayer.h.

Referenced by MuRingForwardLayer().

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

private

Definition at line 59 of file MuRingForwardLayer.h.

Referenced by basicComponents(), MuRingForwardLayer(), and subDetector().

BaseBinFinder<double>* MuRingForwardLayer::theBinFinder

private

Definition at line 60 of file MuRingForwardLayer.h.

Referenced by compatibleDets(), MuRingForwardLayer(), and ~MuRingForwardLayer().

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

private

Definition at line 58 of file MuRingForwardLayer.h.

Referenced by components().

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

private

Definition at line 57 of file MuRingForwardLayer.h.

Referenced by compatibleDets(), MuRingForwardLayer(), rings(), and ~MuRingForwardLayer().