BarrelDetLayer.cc

Go to the documentation of this file.

#include "TrackingTools/DetLayers/interface/BarrelDetLayer.h"
#include "DataFormats/GeometrySurface/interface/Surface.h" 
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" 
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "DataFormats/GeometrySurface/interface/SimpleCylinderBounds.h"
#include "DataFormats/GeometrySurface/interface/BoundingBox.h"

using namespace std;

BarrelDetLayer::~BarrelDetLayer() {}



//--- Extension of the interface
void BarrelDetLayer::setSurface( BoundCylinder* cp) { 
  theCylinder = cp;
}

bool BarrelDetLayer::contains(const Local3DPoint& p) const {
  return surface().bounds().inside(p);
}

void BarrelDetLayer::initialize() 
{
  setSurface( computeSurface());
}



//--- protected methods
BoundCylinder* BarrelDetLayer::computeSurface() {
  vector< const GeomDet*> comps = basicComponents();

  // Find extension in Z
  float theRmin = comps.front()->position().perp();   
  float theRmax = theRmin;
  float theZmin = comps.front()->position().z(); 
  float theZmax = theZmin;
  for ( vector< const GeomDet*>::const_iterator deti = comps.begin(); 
    deti != comps.end(); deti++) {
    vector<GlobalPoint> corners = 
      BoundingBox().corners( dynamic_cast<const Plane&>((*deti)->surface()));
    for (vector<GlobalPoint>::const_iterator ic = corners.begin();
     ic != corners.end(); ic++) {
      float r = ic->perp();
      float z = ic->z();
      theRmin = min( theRmin, r);
      theRmax = max( theRmax, r);
      theZmin = min( theZmin, z);
      theZmax = max( theZmax, z);
    }
    // in addition to the corners we have to check the middle of the 
    // det +/- thickness/2
    // , since the min  radius for some barrel dets is reached there
    float rdet = (**deti).position().perp();
    float thick = (**deti).surface().bounds().thickness();
    theRmin = min( theRmin, rdet-thick/2.F);
    theRmax = max( theRmax, rdet+thick/2.F);
  }
  
  // By default the barrel layers are positioned at the center of the 
  // global frame, and the axes of their local frame coincide with 
  // those of the global grame (z along the cylinder axis)
  PositionType pos(0.,0.,0.);
  RotationType rot;

  auto scp = new SimpleCylinderBounds( theRmin, theRmax,
                                       theZmin, theZmax);
  return new Cylinder(Cylinder::computeRadius(*scp), pos, rot, scp);
}  


pair<bool, TrajectoryStateOnSurface>
BarrelDetLayer::compatible( const TrajectoryStateOnSurface& ts, 
                const Propagator& prop, 
                const MeasurementEstimator&) const
{
  if unlikely(theCylinder == nullptr)  edm::LogError("DetLayers") 
    << "ERROR: BarrelDetLayer::compatible() is used before the layer surface is initialized" ;
  // throw an exception? which one?

  TrajectoryStateOnSurface myState = prop.propagate( ts, specificSurface());
  if unlikely(!myState.isValid()) return make_pair( false, myState);
  

  // check z assuming symmetric bounds around position().z()
  auto z0 = std::abs(myState.globalPosition().z()-specificSurface().position().z());
  auto deltaZ = 0.5f*bounds().length();
  if (z0<deltaZ) return make_pair( true, myState);

  // take into account the thickness of the layer
  deltaZ += 0.5f*bounds().thickness() *
    std::abs(myState.globalDirection().z())/myState.globalDirection().perp();

  // take also into account the error on the predicted state
  const float nSigma = 3.;
  if (myState.hasError())
    deltaZ += nSigma * sqrt( myState.cartesianError().position().czz());
  //
  //  check z again
  return make_pair(z0<deltaZ, myState);
}