StartingLayerFinder.cc

Go to the documentation of this file.

#include "RecoTracker/MeasurementDet/interface/StartingLayerFinder.h"
 
#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"
#include "DataFormats/TrackingRecHit/interface/TrackingRecHitFwd.h"
#include "DataFormats/TrajectoryState/interface/PTrajectoryStateOnDet.h"
#include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h"
#include "DataFormats/SiStripDetId/interface/StripSubdetector.h"
#include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"
 
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
 
#include <utility>
 
using namespace std;
 
vector<const DetLayer*> StartingLayerFinder::startingLayers(const FTS& aFts, float dr, float dz) const {
  vector<const DetLayer*> mylayers;
  mylayers.reserve(3);
 
  FTS fastFts(aFts.parameters());
 
  //barrel pixel
  TSOS pTsos = propagator()->propagate(fastFts, firstPixelBarrelLayer()->surface());
 
  if (pTsos.isValid()) {
    Range barrZRange(
        firstPixelBarrelLayer()->position().z() - 0.5 * (firstPixelBarrelLayer()->surface().bounds().length()),
        firstPixelBarrelLayer()->position().z() + 0.5 * (firstPixelBarrelLayer()->surface().bounds().length()));
    Range trajZRange(pTsos.globalPosition().z() - dz, pTsos.globalPosition().z() + dz);
 
    if (rangesIntersect(trajZRange, barrZRange)) {
      mylayers.push_back(firstPixelBarrelLayer());
    }
  }
 
  //negative fwd pixel
 
  for (auto infwd : firstPosPixelFwdLayer()) {
    pTsos = propagator()->propagate(fastFts, infwd->surface());
    if (pTsos.isValid()) {
      Range nfwdRRange(infwd->specificSurface().innerRadius(), infwd->specificSurface().outerRadius());
      Range trajRRange(pTsos.globalPosition().perp() - dr, pTsos.globalPosition().perp() + dr);
      if (rangesIntersect(trajRRange, nfwdRRange)) {
        mylayers.push_back(infwd);
      }
    }
  }
 
  //positive fwd pixel
  for (auto ipfwd : firstPosPixelFwdLayer()) {
    pTsos = propagator()->propagate(fastFts, ipfwd->surface());
    if (pTsos.isValid()) {
      Range pfwdRRange(ipfwd->specificSurface().innerRadius(), ipfwd->specificSurface().outerRadius());
      Range trajRRange(pTsos.globalPosition().perp() - dr, pTsos.globalPosition().perp() + dr);
      if (rangesIntersect(trajRRange, pfwdRRange)) {
        mylayers.push_back(ipfwd);
      }
    }
  }
 
  return mylayers;
}
 
vector<const DetLayer*> StartingLayerFinder::startingLayers(const TrajectorySeed& aSeed) const {
  float dr = 0., dz = 0.;
 
  if (propagator()->propagationDirection() != aSeed.direction())
    return vector<const DetLayer*>();
 
  if (aSeed.nHits() != 2)
    return vector<const DetLayer*>();
 
  TrackingRecHitCollection::const_iterator firstHit = aSeed.recHits().first;
  const TrackingRecHit* recHit1 = &(*firstHit);
  const DetLayer* hit1Layer = theMeasurementTracker->geometricSearchTracker()->detLayer(recHit1->geographicalId());
 
  TrackingRecHitCollection::const_iterator secondHit = aSeed.recHits().second;
  const TrackingRecHit* recHit2 = &(*secondHit);
  const DetLayer* hit2Layer = theMeasurementTracker->geometricSearchTracker()->detLayer(recHit2->geographicalId());
 
  GeomDetEnumerators::Location p1 = hit1Layer->location();
  GeomDetEnumerators::Location p2 = hit2Layer->location();
 
  if (p1 == GeomDetEnumerators::barrel && p2 == GeomDetEnumerators::barrel) {
    dr = 0.1;
    dz = 5.;
  } else if (p1 == GeomDetEnumerators::endcap && p2 == GeomDetEnumerators::endcap) {
    dr = 5.;
    dz = 0.1;
  } else {
    dr = 0.1;
    dz = 0.1;
  }
 
  const GeomDet* gdet = theMeasurementTracker->geomTracker()->idToDet(DetId(aSeed.startingState().detId()));
 
  TrajectoryStateOnSurface tsos = trajectoryStateTransform::transientState(
      aSeed.startingState(), &(gdet->surface()), thePropagator->magneticField());
 
  const FreeTrajectoryState* fts = tsos.freeTrajectoryState();
 
  return startingLayers(*fts, dr, dz);
}
 
const BarrelDetLayer* StartingLayerFinder::firstPixelBarrelLayer() const {
  checkPixelLayers();
  return theFirstPixelBarrelLayer;
}
 
const vector<const ForwardDetLayer*> StartingLayerFinder::firstNegPixelFwdLayer() const {
  checkPixelLayers();
  return theFirstNegPixelFwdLayer;
}
 
const vector<const ForwardDetLayer*> StartingLayerFinder::firstPosPixelFwdLayer() const {
  checkPixelLayers();
  return theFirstPosPixelFwdLayer;
}
 
void StartingLayerFinder::checkPixelLayers() const {
  if (!thePixelLayersValid) {
    const GeometricSearchTracker* theGeometricSearchTracker = theMeasurementTracker->geometricSearchTracker();
 
    theFirstPixelBarrelLayer = theGeometricSearchTracker->pixelBarrelLayers().front();
    theFirstNegPixelFwdLayer = theGeometricSearchTracker->negPixelForwardLayers();
    theFirstPosPixelFwdLayer = theGeometricSearchTracker->posPixelForwardLayers();
    thePixelLayersValid = true;
  }
}