CSCLayerGeometry.h

Go to the documentation of this file.

#ifndef Geometry_CSCGeometry_CSCLayerGeometry_H
#define Geometry_CSCGeometry_CSCLayerGeometry_H
 
#include <Geometry/CSCGeometry/interface/CSCStripTopology.h>
#include <Geometry/CSCGeometry/interface/CSCWireTopology.h>
#include <DataFormats/GeometrySurface/interface/TrapezoidalPlaneBounds.h>
#include <DataFormats/GeometryVector/interface/LocalPoint.h>
#include <DataFormats/GeometrySurface/interface/LocalError.h>
 
#include <utility>  // for std::pair
 
class CSCGeometry;
class CSCWireGroupPackage;
 
class CSCLayerGeometry : public TrapezoidalPlaneBounds {
public:
  CSCLayerGeometry(const CSCGeometry* geom,
                   int iChamberType,
                   const TrapezoidalPlaneBounds& bounds,
                   int nstrips,
                   float stripOffset,
                   float stripPhiPitch,
                   float whereStripsMeet,
                   float extentOfStripPlane,
                   float yCentreOfStripPlane,
                   const CSCWireGroupPackage& wg,
                   float wireAngleInDegrees,
                   double yOfFirstWire,
                   float hThickness);
 
  CSCLayerGeometry(const CSCLayerGeometry&);
 
  CSCLayerGeometry& operator=(const CSCLayerGeometry&);
 
  ~CSCLayerGeometry() override;
 
  int numberOfStrips() const { return theStripTopology->nstrips(); }
 
  int numberOfWires() const { return theWireTopology->numberOfWires(); }
 
  int numberOfWireGroups() const { return theWireTopology->numberOfWireGroups(); }
 
  int numberOfWiresPerGroup(int wireGroup) const { return theWireTopology->numberOfWiresPerGroup(wireGroup); }
 
  LocalPoint stripWireIntersection(int strip, float wire) const;
 
  LocalPoint stripWireGroupIntersection(int strip, int wireGroup) const;
 
  int nearestStrip(const LocalPoint& lp) const { return theStripTopology->nearestStrip(lp); }
 
  int nearestWire(const LocalPoint& lp) const { return theWireTopology->nearestWire(lp); }
 
  int wireGroup(int wire) const { return theWireTopology->wireGroup(wire); }
 
  int channel(int strip) const { return theStripTopology->channel(strip); }
 
  float stripOffset(void) const { return theStripTopology->stripOffset(); }
 
  int stagger() const { return static_cast<int>(4.1 * stripOffset()); }
 
  float stripAngle(int strip) const;
 
  float wireAngle() const { return theWireTopology->wireAngle(); }
 
  float wirePitch() const { return theWireTopology->wirePitch(); }
 
  float yResolution(int wireGroup = 1) const { return theWireTopology->yResolution(wireGroup); }
 
  float stripPhiPitch() const { return theStripTopology->phiPitch(); }
 
  float stripPitch() const {
    //    return theStripTopology->pitch(); }
    return stripPitch(LocalPoint(0., 0.));
  }
 
  float stripPitch(const LocalPoint& lp) const { return theStripTopology->localPitch(lp); }
 
  float xOfStrip(int strip, float y = 0.) const { return theStripTopology->xOfStrip(strip, y); }
 
  float strip(const LocalPoint& lp) const { return theStripTopology->strip(lp); }
 
  float middleWireOfGroup(int wireGroup) const { return theWireTopology->middleWireOfGroup(wireGroup); }
 
  float yOfWire(float wire, float x = 0.) const { return theWireTopology->yOfWire(wire, x); }
 
  float yOfWireGroup(int wireGroup, float x = 0.) const { return theWireTopology->yOfWireGroup(wireGroup, x); }
 
  LocalPoint localCenterOfWireGroup(int wireGroup) const;
 
  float lengthOfWireGroup(int wireGroup) const;
 
  std::pair<float, float> yLimitsOfStripPlane() const { return theStripTopology->yLimitsOfStripPlane(); }
 
  bool inside(const Local3DPoint&, const LocalError&, float scale = 1.f) const override;
  bool inside(const Local3DPoint&) const override;
  bool inside(const Local2DPoint&) const override;
 
  std::pair<LocalPoint, float> possibleRecHitPosition(float s, int w1, int w2) const;
 
  LocalPoint intersectionOfStripAndWire(float s, int w) const;
 
  LocalPoint intersectionOfTwoLines(std::pair<float, float> p1, std::pair<float, float> p2) const;
 
  LocalError localError(int strip, float sigmaStrip, float sigmaWire) const;
 
  const CSCStripTopology* topology() const { return theStripTopology; }
 
  void setTopology(CSCStripTopology* topology);
 
  const CSCWireTopology* wireTopology() const { return theWireTopology; }
 
  Bounds* clone() const override { return new CSCLayerGeometry(*this); }
 
  friend std::ostream& operator<<(std::ostream&, const CSCLayerGeometry&);
 
private:
  // The wire information is encapsulated in a CSCWireTopology
  // This class is passed the pointer and takes ownership...
  // e.g. it destroys it.
 
  CSCWireTopology* theWireTopology;
 
  // The strip information is encapsulated in a CSCStripTopology
  // This class owns the pointer... so that copying works with
  // derived classes, need a clone() method which can be virtual.
 
  CSCStripTopology* theStripTopology;
 
  // Cache the trapezoid dimensions even though they could
  // be accessed from the TrapezoidalPlaneBounds
 
  float hBottomEdge;
  float hTopEdge;
  float apothem;
 
  const std::string myName;
  int chamberType;
};
#endif