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