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,
           std::vector<double> theMinDim,
           std::vector<double> theMaxDim,
           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 = 0;
     } else {
       theCylinder = dynamic_cast<BoundCylinder*>(theSurface);
       theDisk = 0;
       theDiskInnerRadius = 0.;
       theDiskOuterRadius = 0.;
     }

   }

  TrackerLayer(BoundSurface* theSurface,
           unsigned int theLayerNumber,
           std::vector<double> theMinDim,
           std::vector<double> theMaxDim,
           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 = 0;
   }

  inline bool sensitive() const { return isSensitive; }

  inline bool forward() const { return isForward; }

  inline const BoundSurface& surface() const { return *theSurface; }

  inline BoundCylinder* cylinder() const { return theCylinder; }

  inline BoundDisk* 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