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