TrackerLayer.h

Go to the documentation of this file.

#ifndef _TrackerLayer_H_
#define _TrackerLayer_H_
 
#include "DataFormats/GeometrySurface/interface/BoundSurface.h"
#include "DataFormats/GeometrySurface/interface/BoundCylinder.h"
#include "DataFormats/GeometrySurface/interface/BoundDisk.h"
 
#include <vector>
 
class TrackerLayer {
public:
  TrackerLayer(BoundSurface* theSurface,
               bool isForward,
               unsigned int theLayerNumber,
               const std::vector<double>& theMinDim,
               const std::vector<double>& theMaxDim,
               const std::vector<double>& theFudge)
      : theSurface(theSurface),
        isForward(isForward),
        theLayerNumber(theLayerNumber),
        theDimensionMinValues(theMinDim),
        theDimensionMaxValues(theMaxDim),
        theFudgeFactors(theFudge),
        theNumberOfFudgeFactors(theFudgeFactors.size()) {
    isSensitive = (theLayerNumber < 100);
    if (isForward) {
      theDisk = dynamic_cast<BoundDisk*>(theSurface);
      theDiskInnerRadius = theDisk->innerRadius();
      theDiskOuterRadius = theDisk->outerRadius();
      theCylinder = nullptr;
    } else {
      theCylinder = dynamic_cast<BoundCylinder*>(theSurface);
      theDisk = nullptr;
      theDiskInnerRadius = 0.;
      theDiskOuterRadius = 0.;
    }
  }
 
  TrackerLayer(BoundSurface* theSurface,
               unsigned int theLayerNumber,
               const std::vector<double>& theMinDim,
               const std::vector<double>& theMaxDim,
               const std::vector<double>& theFudge)
      : theSurface(theSurface),
        theLayerNumber(theLayerNumber),
        theDimensionMinValues(theMinDim),
        theDimensionMaxValues(theMaxDim),
        theFudgeFactors(theFudge),
        theNumberOfFudgeFactors(theFudgeFactors.size()) {
    isSensitive = true;
    isForward = true;
    theDisk = dynamic_cast<BoundDisk*>(theSurface);
    theDiskInnerRadius = theDisk->innerRadius();
    theDiskOuterRadius = theDisk->outerRadius();
    theCylinder = nullptr;
  }
 
  inline bool sensitive() const { return isSensitive; }
 
  inline bool forward() const { return isForward; }
 
  inline const BoundSurface& surface() const { return *theSurface; }
 
  inline BoundCylinder const* cylinder() const { return theCylinder; }
 
  inline BoundDisk const* disk() const { return theDisk; }
 
  inline unsigned int layerNumber() const { return theLayerNumber; }
 
  inline double diskInnerRadius() const { return theDiskInnerRadius; }
 
  inline double diskOuterRadius() const { return theDiskOuterRadius; }
 
  /*
  void setFudgeFactor(double min, double max, double f) { 
    ++theNumberOfFudgeFactors;
    theDimensionMinValues.push_back(min);
    theDimensionMaxValues.push_back(max);
    theFudgeFactors.push_back(f);
  }
  */
 
  inline unsigned int fudgeNumber() const { return theNumberOfFudgeFactors; }
  inline double fudgeMin(unsigned iFudge) const {
    return (iFudge < theNumberOfFudgeFactors) ? theDimensionMinValues[iFudge] : 999.;
  }
  inline double fudgeMax(unsigned iFudge) const {
    return (iFudge < theNumberOfFudgeFactors) ? theDimensionMaxValues[iFudge] : -999.;
  }
  inline double fudgeFactor(unsigned iFudge) const {
    return (iFudge < theNumberOfFudgeFactors) ? theFudgeFactors[iFudge] : 0.;
  }
 
private:
  BoundSurface* theSurface;
  BoundDisk* theDisk;
  BoundCylinder* theCylinder;
  bool isForward;
  unsigned int theLayerNumber;
  bool isSensitive;
  double theDiskInnerRadius;
  double theDiskOuterRadius;
 
  std::vector<double> theDimensionMinValues;
  std::vector<double> theDimensionMaxValues;
  std::vector<double> theFudgeFactors;
  unsigned int theNumberOfFudgeFactors;
};
#endif