EKLMGeometry.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
/* KLM headers. */
#include <klm/dataobjects/eklm/EKLMElementNumbers.h>
 
/* ROOT headers. */
#include <TObject.h>
 
/* CLHEP headers. */
#include <CLHEP/Geometry/Point3D.h>
 
namespace Belle2 {
  class EKLMGeometry : public TObject {
 
  public:
 
    class EndcapStructureGeometry : public TObject {
 
    public:
 
      EndcapStructureGeometry();
 
      ~EndcapStructureGeometry();
 
      double getPhi() const
      {
        return m_Phi;
      }
 
      void setPhi(double phi)
      {
        m_Phi = phi;
      }
 
      int getNSides() const
      {
        return m_NSides;
      }
 
      void setNSides(int nSides)
      {
        m_NSides = nSides;
      }
 
    private:
 
      double m_Phi = 0;
 
      int m_NSides = 0;
 
      ClassDef(EndcapStructureGeometry, 1);
 
    };
 
    class ElementPosition : public TObject {
 
    public:
 
      ElementPosition();
 
      double getInnerR() const
      {
        return m_InnerR;
      }
 
      void setInnerR(double innerR)
      {
        m_InnerR = innerR;
      }
 
      double getOuterR() const
      {
        return m_OuterR;
      }
 
      void setOuterR(double outerR)
      {
        m_OuterR = outerR;
      }
 
      double getLength() const
      {
        return m_Length;
      }
 
      void setLength(double length)
      {
        m_Length = length;
      }
 
      double getX() const
      {
        return m_X;
      }
 
      void setX(double x)
      {
        m_X = x;
      }
 
      double getY() const
      {
        return m_Y;
      }
 
      void setY(double y)
      {
        m_Y = y;
      }
 
      double getZ() const
      {
        return m_Z;
      }
 
      void setZ(double z)
      {
        m_Z = z;
      }
 
    private:
 
      double m_InnerR = 0;
 
      double m_OuterR = 0;
 
      double m_Length = 0;
 
      double m_X = 0;
 
      double m_Y = 0;
 
      double m_Z = 0;
 
      ClassDef(ElementPosition, 1);
 
    };
 
    class SectorSupportGeometry : public TObject {
 
    public:
 
      SectorSupportGeometry();
 
      double getThickness() const
      {
        return m_Thickness;
      }
 
      void setThickness(double thickness)
      {
        m_Thickness = thickness;
      }
 
      double getDeltaLY() const
      {
        return m_DeltaLY;
      }
 
      void setDeltaLY(double deltaLY)
      {
        m_DeltaLY = deltaLY;
      }
 
      double getCornerX() const
      {
        return m_CornerX;
      }
 
      void setCornerX(double cornerX)
      {
        m_CornerX = cornerX;
      }
 
      double getCorner1LX() const
      {
        return m_Corner1LX;
      }
 
      void setCorner1LX(double corner1LX)
      {
        m_Corner1LX = corner1LX;
      }
 
      double getCorner1Width() const
      {
        return m_Corner1Width;
      }
 
      void setCorner1Width(double corner1Width)
      {
        m_Corner1Width = corner1Width;
      }
 
      double getCorner1Thickness() const
      {
        return m_Corner1Thickness;
      }
 
      void setCorner1Thickness(double corner1Thickness)
      {
        m_Corner1Thickness = corner1Thickness;
      }
 
      double getCorner1Z() const
      {
        return m_Corner1Z;
      }
 
      void setCorner1Z(double corner1Z)
      {
        m_Corner1Z = corner1Z;
      }
 
      double getCorner2LX() const
      {
        return m_Corner2LX;
      }
 
      void setCorner2LX(double corner2LX)
      {
        m_Corner2LX = corner2LX;
      }
 
      double getCorner2LY() const
      {
        return m_Corner2LY;
      }
 
      void setCorner2LY(double corner2LY)
      {
        m_Corner2LY = corner2LY;
      }
 
      double getCorner2Thickness() const
      {
        return m_Corner2Thickness;
      }
 
      void setCorner2Thickness(double corner2Thickness)
      {
        m_Corner2Thickness = corner2Thickness;
      }
 
      double getCorner2Z() const
      {
        return m_Corner2Z;
      }
 
      void setCorner2Z(double corner2Z)
      {
        m_Corner2Z = corner2Z;
      }
 
      double getCorner3LX() const
      {
        return m_Corner3LX;
      }
 
      void setCorner3LX(double corner3LX)
      {
        m_Corner3LX = corner3LX;
      }
 
      double getCorner3LY() const
      {
        return m_Corner3LY;
      }
 
      void setCorner3LY(double corner3LY)
      {
        m_Corner3LY = corner3LY;
      }
 
      double getCorner3Thickness() const
      {
        return m_Corner3Thickness;
      }
 
      void setCorner3Thickness(double corner3Thickness)
      {
        m_Corner3Thickness = corner3Thickness;
      }
 
      double getCorner3Z() const
      {
        return m_Corner3Z;
      }
 
      void setCorner3Z(double corner3Z)
      {
        m_Corner3Z = corner3Z;
      }
 
      double getCorner4LX() const
      {
        return m_Corner4LX;
      }
 
      void setCorner4LX(double corner4LX)
      {
        m_Corner4LX = corner4LX;
      }
 
      double getCorner4LY() const
      {
        return m_Corner4LY;
      }
 
      void setCorner4LY(double corner4LY)
      {
        m_Corner4LY = corner4LY;
      }
 
      double getCorner4Thickness() const
      {
        return m_Corner4Thickness;
      }
 
      void setCorner4Thickness(double corner4Thickness)
      {
        m_Corner4Thickness = corner4Thickness;
      }
 
      double getCorner4Z() const
      {
        return m_Corner4Z;
      }
 
      void setCorner4Z(double corner4Z)
      {
        m_Corner4Z = corner4Z;
      }
 
      double getCornerAngle() const
      {
        return m_CornerAngle;
      }
 
      void setCornerAngle(double cornerAngle)
      {
        m_CornerAngle = cornerAngle;
      }
 
      const HepGeom::Point3D<double>& getCorner1A() const
      {
        return m_Corner1A;
      }
 
      void setCorner1A(const HepGeom::Point3D<double>& corner1A)
      {
        m_Corner1A = corner1A;
      }
 
      const HepGeom::Point3D<double>& getCorner1AInner() const
      {
        return m_Corner1AInner;
      }
 
      void setCorner1AInner(const HepGeom::Point3D<double>& corner1AInner)
      {
        m_Corner1AInner = corner1AInner;
      }
 
      const HepGeom::Point3D<double>& getCorner1B() const
      {
        return m_Corner1B;
      }
 
      void setCorner1B(const HepGeom::Point3D<double>& corner1B)
      {
        m_Corner1B = corner1B;
      }
 
      const HepGeom::Point3D<double>& getCorner1BInner() const
      {
        return m_Corner1BInner;
      }
 
      void setCorner1BInner(const HepGeom::Point3D<double>& corner1BInner)
      {
        m_Corner1BInner = corner1BInner;
      }
 
      const HepGeom::Point3D<double>& getCorner2Inner() const
      {
        return m_Corner2Inner;
      }
 
      void setCorner2Inner(const HepGeom::Point3D<double>& corner2Inner)
      {
        m_Corner2Inner = corner2Inner;
      }
 
      const HepGeom::Point3D<double>& getCorner3() const
      {
        return m_Corner3;
      }
 
      void setCorner3(const HepGeom::Point3D<double>& corner3)
      {
        m_Corner3 = corner3;
      }
 
      const HepGeom::Point3D<double>& getCorner3Inner() const
      {
        return m_Corner3Inner;
      }
 
      void setCorner3Inner(const HepGeom::Point3D<double>& corner3Inner)
      {
        m_Corner3Inner = corner3Inner;
      }
 
      const HepGeom::Point3D<double>& getCorner3Prism() const
      {
        return m_Corner3Prism;
      }
 
      void setCorner3Prism(const HepGeom::Point3D<double>& corner3Prism)
      {
        m_Corner3Prism = corner3Prism;
      }
 
      const HepGeom::Point3D<double>& getCorner4() const
      {
        return m_Corner4;
      }
 
      void setCorner4(const HepGeom::Point3D<double>& corner4)
      {
        m_Corner4 = corner4;
      }
 
      const HepGeom::Point3D<double>& getCorner4Inner() const
      {
        return m_Corner4Inner;
      }
 
      void setCorner4Inner(const HepGeom::Point3D<double>& corner4Inner)
      {
        m_Corner4Inner = corner4Inner;
      }
 
      const HepGeom::Point3D<double>& getCorner4Prism() const
      {
        return m_Corner4Prism;
      }
 
      void setCorner4Prism(const HepGeom::Point3D<double>& corner4Prism)
      {
        m_Corner4Prism = corner4Prism;
      }
 
    private:
 
      double m_Thickness = 0;
 
      double m_DeltaLY = 0;
 
      double m_CornerX = 0;
 
      double m_Corner1LX = 0;
 
      double m_Corner1Width = 0;
 
      double m_Corner1Thickness = 0;
 
      double m_Corner1Z = 0;
 
      double m_Corner2LX = 0;
 
      double m_Corner2LY = 0;
 
      double m_Corner2Thickness = 0;
 
      double m_Corner2Z = 0;
 
      double m_Corner3LX = 0;
 
      double m_Corner3LY = 0;
 
      double m_Corner3Thickness = 0;
 
      double m_Corner3Z = 0;
 
      double m_Corner4LX = 0;
 
      double m_Corner4LY = 0;
 
      double m_Corner4Thickness = 0;
 
      double m_Corner4Z = 0;
 
      /* The following data members are not stored in the database. */
 
      double m_CornerAngle = 0;                 
 
      HepGeom::Point3D<double> m_Corner1A;      
 
      HepGeom::Point3D<double> m_Corner1AInner; 
 
      HepGeom::Point3D<double> m_Corner1B;      
 
      HepGeom::Point3D<double> m_Corner1BInner; 
 
      HepGeom::Point3D<double> m_Corner2Inner;  
 
      HepGeom::Point3D<double> m_Corner3;       
 
      HepGeom::Point3D<double> m_Corner3Inner;  
 
      HepGeom::Point3D<double> m_Corner3Prism;  
 
      HepGeom::Point3D<double> m_Corner4;       
 
      HepGeom::Point3D<double> m_Corner4Inner;  
 
      HepGeom::Point3D<double> m_Corner4Prism;  
 
      ClassDef(SectorSupportGeometry, 1);
 
    };
 
    class PlasticSheetGeometry : public TObject {
 
    public:
 
      PlasticSheetGeometry();
 
      double getWidth() const
      {
        return m_Width;
      }
 
      void setWidth(double width)
      {
        m_Width = width;
      }
 
      double getDeltaL() const
      {
        return m_DeltaL;
      }
 
      void setDeltaL(double deltaL)
      {
        m_DeltaL = deltaL;
      }
 
    private:
 
      double m_Width = 0;
 
      double m_DeltaL = 0;
 
      ClassDef(PlasticSheetGeometry, 1);
 
    };
 
    class SegmentSupportGeometry : public TObject {
 
    public:
 
      SegmentSupportGeometry();
 
      double getTopWidth() const
      {
        return m_TopWidth;
      }
 
      void setTopWidth(double topWidth)
      {
        m_TopWidth = topWidth;
      }
 
      double getTopThickness() const
      {
        return m_TopThickness;
      }
 
      void setTopThickness(double topThickness)
      {
        m_TopThickness = topThickness;
      }
 
      double getMiddleWidth() const
      {
        return m_MiddleWidth;
      }
 
      void setMiddleWidth(double middleWidth)
      {
        m_MiddleWidth = middleWidth;
      }
 
      double getMiddleThickness() const
      {
        return m_MiddleThickness;
      }
 
      void setMiddleThickness(double middleThickness)
      {
        m_MiddleThickness = middleThickness;
      }
 
    private:
 
      double m_TopWidth = 0;
 
      double m_TopThickness = 0;
 
      double m_MiddleWidth = 0;
 
      double m_MiddleThickness = 0;
 
      ClassDef(SegmentSupportGeometry, 1);
 
    };
 
    class SegmentSupportPosition : public TObject {
 
    public:
 
      SegmentSupportPosition();
 
      double getDeltaLRight() const
      {
        return m_DeltaLRight;
      }
 
      void setDeltaLRight(double deltaLRight)
      {
        m_DeltaLRight = deltaLRight;
      }
 
      double getDeltaLLeft() const
      {
        return m_DeltaLLeft;
      }
 
      void setDeltaLLeft(double deltaLLeft)
      {
        m_DeltaLLeft = deltaLLeft;
      }
 
      double getLength() const
      {
        return m_Length;
      }
 
      void setLength(double length)
      {
        m_Length = length;
      }
 
      double getX() const
      {
        return m_X;
      }
 
      void setX(double x)
      {
        m_X = x;
      }
 
      double getY() const
      {
        return m_Y;
      }
 
      void setY(double y)
      {
        m_Y = y;
      }
 
      double getZ() const
      {
        return m_Z;
      }
 
      void setZ(double z)
      {
        m_Z = z;
      }
 
    private:
 
      double m_DeltaLRight = 0;
 
      double m_DeltaLLeft = 0;
 
      double m_Length = 0;
 
      double m_X = 0;
 
      double m_Y = 0;
 
      double m_Z = 0;
 
      ClassDef(SegmentSupportPosition, 1);
 
    };
 
    class StripGeometry : public TObject {
 
    public:
 
      StripGeometry();
 
      double getWidth() const
      {
        return m_Width;
      }
 
      void setWidth(double width)
      {
        m_Width = width;
      }
 
      double getThickness() const
      {
        return m_Thickness;
      }
 
      void setThickness(double thickness)
      {
        m_Thickness = thickness;
      }
 
      double getGrooveDepth() const
      {
        return m_GrooveDepth;
      }
 
      void setGrooveDepth(double grooveDepth)
      {
        m_GrooveDepth = grooveDepth;
      }
 
      double getGrooveWidth() const
      {
        return m_GrooveWidth;
      }
 
      void setGrooveWidth(double grooveWidth)
      {
        m_GrooveWidth = grooveWidth;
      }
 
      double getNoScintillationThickness() const
      {
        return m_NoScintillationThickness;
      }
 
      void setNoScintillationThickness(double thickness)
      {
        m_NoScintillationThickness = thickness;
      }
 
      double getRSSSize() const
      {
        return m_RSSSize;
      }
 
      void setRSSSize(double rssSize)
      {
        m_RSSSize = rssSize;
      }
 
    private:
 
      double m_Width = 0;
 
      double m_Thickness = 0;
 
      double m_GrooveDepth = 0;
 
      double m_GrooveWidth = 0;
 
      double m_NoScintillationThickness = 0;
 
      double m_RSSSize = 0;
 
      ClassDef(StripGeometry, 1);
 
    };
 
    class Point : public TObject {
 
    public:
 
      Point();
 
      double getX() const
      {
        return m_X;
      }
 
      void setX(double x)
      {
        m_X = x;
      }
 
      double getY() const
      {
        return m_Y;
      }
 
      void setY(double y)
      {
        m_Y = y;
      }
 
    private:
 
      double m_X = 0;
 
      double m_Y = 0;
 
      ClassDef(Point, 1);
 
    };
 
    class ShieldDetailGeometry : public TObject {
 
    public:
 
      ShieldDetailGeometry();
 
      ShieldDetailGeometry(const ShieldDetailGeometry& geometry);
 
      ShieldDetailGeometry& operator=(const ShieldDetailGeometry& geometry);
 
      ~ShieldDetailGeometry();
 
      double getLengthX() const
      {
        return m_LengthX;
      }
 
      void setLengthX(double lengthX)
      {
        m_LengthX = lengthX;
      }
 
      double getLengthY() const
      {
        return m_LengthY;
      }
 
      void setLengthY(double lengthY)
      {
        m_LengthY = lengthY;
      }
 
      int getNPoints() const
      {
        return m_NPoints;
      }
 
      void setNPoints(int nPoints);
 
      const Point* getPoint(int i) const;
 
      void setPoint(int i, const Point& point);
 
    private:
 
      double m_LengthX = 0;
 
      double m_LengthY = 0;
 
      int m_NPoints = 0;
 
      Point* m_Points = nullptr; //[m_NPoints]
 
      ClassDef(ShieldDetailGeometry, 1);
 
    };
 
    class ShieldGeometry : public TObject {
 
    public:
 
      ShieldGeometry();
 
      double getThickness() const
      {
        return m_Thickness;
      }
 
      void setThickness(double thickness)
      {
        m_Thickness = thickness;
      }
 
      const ShieldDetailGeometry* getDetailA() const
      {
        return &m_DetailA;
      }
 
      void setDetailA(const ShieldDetailGeometry& geometry)
      {
        m_DetailA = geometry;
      }
 
      const ShieldDetailGeometry* getDetailB() const
      {
        return &m_DetailB;
      }
 
      void setDetailB(const ShieldDetailGeometry& geometry)
      {
        m_DetailB = geometry;
      }
 
      const ShieldDetailGeometry* getDetailC() const
      {
        return &m_DetailC;
      }
 
      void setDetailC(const ShieldDetailGeometry& geometry)
      {
        m_DetailC = geometry;
      }
 
      const ShieldDetailGeometry* getDetailD() const
      {
        return &m_DetailD;
      }
 
      void setDetailD(const ShieldDetailGeometry& geometry)
      {
        m_DetailD = geometry;
      }
 
      const Point* getDetailACenter() const
      {
        return &m_DetailACenter;
      }
 
      void setDetailACenter(double x, double y);
 
      const Point* getDetailBCenter() const
      {
        return &m_DetailBCenter;
      }
 
      void setDetailBCenter(double x, double y);
 
      const Point* getDetailCCenter() const
      {
        return &m_DetailCCenter;
      }
 
      void setDetailCCenter(double x, double y);
 
    private:
 
      double m_Thickness = 0;
 
      ShieldDetailGeometry m_DetailA;
 
      ShieldDetailGeometry m_DetailB;
 
      ShieldDetailGeometry m_DetailC;
 
      ShieldDetailGeometry m_DetailD;
 
      /* The following data members are not stored in the database. */
 
      Point m_DetailACenter; 
 
      Point m_DetailBCenter; 
 
      Point m_DetailCCenter; 
 
      ClassDef(ShieldGeometry, 1);
 
    };
 
    EKLMGeometry();
 
    EKLMGeometry(const EKLMGeometry& geometry);
 
    ~EKLMGeometry();
 
    EKLMGeometry& operator=(const EKLMGeometry& geometry);
 
    bool beamBackgroundStudy() const
    {
      return m_BeamBackgroundStudy;
    }
 
    int getNSections() const
    {
      return m_NSections;
    }
 
    int getNLayers() const
    {
      return m_NLayers;
    }
 
    int getNDetectorLayers(int section) const;
 
    int getNSectors() const
    {
      return m_NSectors;
    }
 
    int getNPlanes() const
    {
      return m_NPlanes;
    }
 
    int getNSegments() const
    {
      return m_NSegments;
    }
 
    int getNSegmentSupportElementsSector() const
    {
      return m_NSegmentSupportElementsSector;
    }
 
    int getNStrips() const
    {
      return m_NStrips;
    }
 
    void checkDetectorLayerNumber(int section, int layer) const;
 
    void checkDetectorLayer(int section, int layer) const;
 
    void checkSegmentSupport(int support) const;
 
    void checkStripSegment(int strip) const;
 
    double getSolenoidZ() const
    {
      return m_SolenoidZ;
    }
 
    const EndcapStructureGeometry* getEndcapStructureGeometry() const
    {
      return &m_EndcapStructureGeometry;
    }
 
    const ElementPosition* getSectionPosition() const
    {
      return &m_SectionPosition;
    }
 
    const ElementPosition* getLayerPosition() const
    {
      return &m_LayerPosition;
    }
 
    double getLayerShiftZ() const
    {
      return m_LayerShiftZ;
    }
 
    const ElementPosition* getSectorPosition() const
    {
      return &m_SectorPosition;
    }
 
    const ElementPosition* getSectorSupportPosition() const
    {
      return &m_SectorSupportPosition;
    }
 
    const SectorSupportGeometry* getSectorSupportGeometry() const
    {
      return &m_SectorSupportGeometry;
    }
 
    const ElementPosition* getPlanePosition() const
    {
      return &m_PlanePosition;
    }
 
    const PlasticSheetGeometry* getPlasticSheetGeometry() const
    {
      return &m_PlasticSheetGeometry;
    }
 
    const SegmentSupportGeometry* getSegmentSupportGeometry() const
    {
      return &m_SegmentSupportGeometry;
    }
 
    const SegmentSupportPosition*
    getSegmentSupportPosition(int plane, int support) const;
 
    const StripGeometry* getStripGeometry() const
    {
      return &m_StripGeometry;
    }
 
    const ElementPosition* getStripPosition(int strip) const;
 
    const ShieldGeometry* getShieldGeometry() const
    {
      return &m_ShieldGeometry;
    }
 
  protected:
 
    const EKLMElementNumbers* m_ElementNumbers; 
 
    bool m_BeamBackgroundStudy = false;
 
    int m_NSections;
 
    int m_NLayers;
 
    int* m_NDetectorLayers; //[m_NSections]
 
    int m_NSectors;
 
    int m_NPlanes;
 
    int m_NSegments;
 
    int m_NSegmentSupportElementsSector;
 
    int m_NStrips;
 
    double m_SolenoidZ;
 
    EndcapStructureGeometry m_EndcapStructureGeometry;
 
    ElementPosition m_SectionPosition;
 
    ElementPosition m_LayerPosition;
 
    double m_LayerShiftZ;
 
    ElementPosition m_SectorPosition;
 
    ElementPosition m_SectorSupportPosition;
 
    SectorSupportGeometry m_SectorSupportGeometry;
 
    ElementPosition m_PlanePosition;
 
    PlasticSheetGeometry m_PlasticSheetGeometry;
 
    SegmentSupportGeometry m_SegmentSupportGeometry;
 
    SegmentSupportPosition* m_SegmentSupportPosition; //[m_NSegmentSupportElementsSector]
 
    StripGeometry m_StripGeometry;
 
    ElementPosition* m_StripPosition; //[m_NStrips]
 
    ShieldGeometry m_ShieldGeometry;
 
    ClassDef(Belle2::EKLMGeometry, 6);
 
  };
 
}