Simplified apertures

CMakeLists.txt

@@ -12,7 +12,6 @@ include(SetEnvironment)
 
 #----- define all individual modules to be built beforehand
 
-set(HECTOR_MODULES Core IO Elements Beamline Propagator Utils)
 set(HECTOR_SOURCE_DIR ${PROJECT_SOURCE_DIR}/src)
 set(PYHECTOR_SOURCE_DIR ${PROJECT_SOURCE_DIR}/python)
 
@@ -23,6 +22,7 @@ file(GLOB LIB_SRC ${HECTOR_SOURCE_DIR}/*.cc
                   ${HECTOR_SOURCE_DIR}/Core/*.cc
                   ${HECTOR_SOURCE_DIR}/IO/*.cc
                   ${HECTOR_SOURCE_DIR}/Elements/*.cc
+                  ${HECTOR_SOURCE_DIR}/Apertures/*.cc
                   ${HECTOR_SOURCE_DIR}/Propagator/*.cc
                   ${HECTOR_SOURCE_DIR}/Utils/*.cc)
 file(GLOB_RECURSE HECTOR_INCLUDES ${PROJECT_SOURCE_DIR}/Hector/*.h)

Hector/Elements/ApertureBase.h → Hector/Apertures/ApertureBase.h

@@ -1,8 +1,8 @@
-#ifndef Hector_Elements_ApertureBase_h
-#define Hector_Elements_ApertureBase_h
+#ifndef Hector_Apertures_ApertureBase_h
+#define Hector_Apertures_ApertureBase_h
 
 #include "Hector/Core/Algebra.h"
-#include "Hector/Elements/ApertureType.h"
+#include "Hector/Apertures/ApertureType.h"
 
 #include <vector>
 #include <memory>

Hector/Elements/ApertureType.h → Hector/Apertures/ApertureType.h

@@ -1,5 +1,5 @@
-#ifndef Hector_Elements_ApertureType_h
-#define Hector_Elements_ApertureType_h
+#ifndef Hector_Apertures_ApertureType_h
+#define Hector_Apertures_ApertureType_h
 
 #include <iosfwd>
 

Hector/Apertures/Circular.h

@@ -0,0 +1,20 @@
+#ifndef Hector_Apertures_Circular_h
+#define Hector_Apertures_Circular_h
+
+#include "Hector/Apertures/Elliptic.h"
+
+namespace hector {
+  namespace aperture {
+    /// Round shape aperture
+    class Circular : public Elliptic {
+    public:
+      /// Class constructor
+      Circular(double, const TwoVector& pos = TwoVector());
+      ~Circular();
+
+      std::shared_ptr<ApertureBase> clone() const override { return std::make_shared<Circular>(*this); }
+    };
+  }  // namespace aperture
+}  // namespace hector
+
+#endif

Hector/Elements/EllipticAperture.h → Hector/Apertures/Elliptic.h

@@ -1,18 +1,18 @@
-#ifndef Hector_Elements_EllipticAperture
-#define Hector_Elements_EllipticAperture
+#ifndef Hector_Apertures_Elliptic_h
+#define Hector_Apertures_Elliptic_h
 
-#include "ApertureBase.h"
+#include "Hector/Apertures/ApertureBase.h"
 
 namespace hector {
   namespace aperture {
     /// Elliptic shape aperture
-    class EllipticAperture : public ApertureBase {
+    class Elliptic : public ApertureBase {
     public:
       /// Class constructor
-      EllipticAperture(double, double, const TwoVector& pos = TwoVector());
-      ~EllipticAperture();
+      Elliptic(double, double, const TwoVector& pos = TwoVector());
+      ~Elliptic();
 
-      std::shared_ptr<ApertureBase> clone() const override { return std::make_shared<EllipticAperture>(*this); }
+      std::shared_ptr<ApertureBase> clone() const override { return std::make_shared<Elliptic>(*this); }
 
       bool contains(const TwoVector&) const override;
       TwoVector limits() const override;

Hector/Elements/RectEllipticAperture.h → Hector/Apertures/RectElliptic.h

@@ -1,18 +1,18 @@
-#ifndef Hector_Elements_RectEllipticAperture
-#define Hector_Elements_RectEllipticAperture
+#ifndef Hector_Apertures_RectElliptic_h
+#define Hector_Apertures_RectElliptic_h
 
-#include "ApertureBase.h"
+#include "Hector/Apertures/ApertureBase.h"
 
 namespace hector {
   namespace aperture {
     /// Rectangular/elliptic shape aperture
-    class RectEllipticAperture : public ApertureBase {
+    class RectElliptic : public ApertureBase {
     public:
       /// Class constructor
-      RectEllipticAperture(double, double, double, double, const TwoVector& pos = TwoVector());
-      ~RectEllipticAperture();
+      RectElliptic(double, double, double, double, const TwoVector& pos = TwoVector());
+      ~RectElliptic();
 
-      std::shared_ptr<ApertureBase> clone() const override { return std::make_shared<RectEllipticAperture>(*this); }
+      std::shared_ptr<ApertureBase> clone() const override { return std::make_shared<RectElliptic>(*this); }
 
       bool contains(const TwoVector&) const override;
       TwoVector limits() const override;

Hector/Elements/RectangularAperture.h → Hector/Apertures/Rectangular.h

@@ -1,18 +1,18 @@
-#ifndef Hector_Elements_RectangularAperture
-#define Hector_Elements_RectangularAperture
+#ifndef Hector_Apertures_Rectangular_h
+#define Hector_Apertures_Rectangular_h
 
-#include "ApertureBase.h"
+#include "Hector/Apertures/ApertureBase.h"
 
 namespace hector {
   namespace aperture {
     /// Rectangular shape aperture
-    class RectangularAperture : public ApertureBase {
+    class Rectangular : public ApertureBase {
     public:
       /// Class constructor
-      RectangularAperture(double, double, const TwoVector& pos = TwoVector());
-      ~RectangularAperture();
+      Rectangular(double, double, const TwoVector& pos = TwoVector());
+      ~Rectangular();
 
-      std::shared_ptr<ApertureBase> clone() const override { return std::make_shared<RectangularAperture>(*this); }
+      std::shared_ptr<ApertureBase> clone() const override { return std::make_shared<Rectangular>(*this); }
 
       bool contains(const TwoVector&) const override;
       TwoVector limits() const override;

Hector/Elements/ElementBase.h

@@ -3,7 +3,7 @@
 
 #include "Hector/Core/Algebra.h"
 #include "Hector/Core/Parameters.h"
-#include "Hector/Elements/ApertureBase.h"
+#include "Hector/Apertures/ApertureBase.h"
 #include "Hector/Elements/ElementType.h"
 
 #include <memory>

Hector/IO/TwissHandler.h

@@ -5,7 +5,7 @@
 #include "Hector/Utils/UnorderedParametersMap.h"
 
 #include "Hector/Elements/ElementBase.h"
-#include "Hector/Elements/ApertureType.h"
+#include "Hector/Apertures/ApertureType.h"
 
 #include <fstream>
 #include <regex>

python/PythonWrapper.cc

@@ -15,11 +15,11 @@
 #include "Hector/Elements/Kicker.h"
 #include "Hector/Elements/Collimator.h"
 
-#include "Hector/Elements/ApertureBase.h"
-#include "Hector/Elements/CircularAperture.h"
-#include "Hector/Elements/EllipticAperture.h"
-#include "Hector/Elements/RectangularAperture.h"
-#include "Hector/Elements/RectEllipticAperture.h"
+#include "Hector/Apertures/ApertureBase.h"
+#include "Hector/Apertures/Circular.h"
+#include "Hector/Apertures/Elliptic.h"
+#include "Hector/Apertures/Rectangular.h"
+#include "Hector/Apertures/RectElliptic.h"
 
 #include "Hector/IO/TwissHandler.h"
 #include "Hector/IO/HBLFileHandler.h"
@@ -479,11 +479,10 @@ BOOST_PYTHON_MODULE(pyhector) {
            "Offset the barycentre by a given vertical-horizontal coordinate");
   py::register_ptr_to_python<hector::aperture::ApertureBase*>();
 
-  convertAperture<hector::aperture::CircularAperture, py::init<double, hector::TwoVector> >("CircularAperture");
-  convertAperture<hector::aperture::EllipticAperture, py::init<double, double, hector::TwoVector> >("EllipticAperture");
-  convertAperture<hector::aperture::RectangularAperture, py::init<double, double, hector::TwoVector> >(
-      "RectangularAperture");
-  convertAperture<hector::aperture::RectEllipticAperture, py::init<double, double, double, double, hector::TwoVector> >(
+  convertAperture<hector::aperture::Circular, py::init<double, hector::TwoVector> >("CircularAperture");
+  convertAperture<hector::aperture::Elliptic, py::init<double, double, hector::TwoVector> >("EllipticAperture");
+  convertAperture<hector::aperture::Rectangular, py::init<double, double, hector::TwoVector> >("RectangularAperture");
+  convertAperture<hector::aperture::RectElliptic, py::init<double, double, double, double, hector::TwoVector> >(
       "RectEllipticAperture");
 
   //----- BEAMLINE DEFINITION

src/Elements/ApertureBase.cc → src/Apertures/ApertureBase.cc

@@ -1,4 +1,4 @@
-#include "Hector/Elements/ApertureBase.h"
+#include "Hector/Apertures/ApertureBase.h"
 #include "Hector/Utils/Utils.h"
 
 #include <sstream>

src/Elements/ApertureType.cc → src/Apertures/ApertureType.cc

@@ -1,4 +1,4 @@
-#include "Hector/Elements/ApertureType.h"
+#include "Hector/Apertures/ApertureType.h"
 #include <iostream>
 
 namespace hector {

src/Apertures/Circular.cc

@@ -0,0 +1,9 @@
+#include "Hector/Apertures/Circular.h"
+
+namespace hector {
+  namespace aperture {
+    Circular::Circular(double radius, const TwoVector& pos) : Elliptic(radius, radius, pos) {}
+
+    Circular::~Circular() {}
+  }  // namespace aperture
+}  // namespace hector

src/Apertures/Elliptic.cc

@@ -0,0 +1,17 @@
+#include "Hector/Apertures/Elliptic.h"
+
+namespace hector {
+  namespace aperture {
+    Elliptic::Elliptic(double ell_length, double ell_height, const TwoVector& pos)
+        : ApertureBase(anEllipticAperture, pos, {{ell_length, ell_height, 0.f, 0.f}}) {}
+
+    Elliptic::~Elliptic() {}
+
+    bool Elliptic::contains(const TwoVector& pos) const {
+      const TwoVector vec((pos.x() - pos_.x()) / p(0), (pos.y() - pos_.y()) / p(1));
+      return (vec.mag2() < 1.);
+    }
+
+    TwoVector Elliptic::limits() const { return TwoVector(p(0), p(1)); }
+  }  // namespace aperture
+}  // namespace hector

src/Elements/RectEllipticAperture.cc → src/Apertures/RectElliptic.cc

@@ -1,20 +1,20 @@
-#include "Hector/Elements/RectEllipticAperture.h"
+#include "Hector/Apertures/RectElliptic.h"
 
 namespace hector {
   namespace aperture {
-    RectEllipticAperture::RectEllipticAperture(
+    RectElliptic::RectElliptic(
         double rect_size_x, double rect_size_y, double ell_size_x, double ell_size_y, const TwoVector& pos)
         : ApertureBase(aRectEllipticAperture, pos, {{rect_size_x, rect_size_y, ell_size_x, ell_size_y}}) {}
 
-    RectEllipticAperture::~RectEllipticAperture() {}
+    RectElliptic::~RectElliptic() {}
 
-    bool RectEllipticAperture::contains(const TwoVector& pos) const {
+    bool RectElliptic::contains(const TwoVector& pos) const {
       const TwoVector vec1(pos - pos_), vec2(vec1.x() / p(2), vec1.y() / p(3));
       return ((fabs(vec1.x()) < p(0)) && (fabs(vec1.y()) < p(1))  // rectangular part
               && (vec2.mag2() < 1.));                             // elliptic part
     }
 
-    TwoVector RectEllipticAperture::limits() const {  //FIXME
+    TwoVector RectElliptic::limits() const {  //FIXME
       return TwoVector(std::min(p(0), p(2)), std::min(p(1), p(3)));
     }
   }  // namespace aperture

src/Apertures/Rectangular.cc

@@ -0,0 +1,17 @@
+#include "Hector/Apertures/Rectangular.h"
+
+namespace hector {
+  namespace aperture {
+    Rectangular::Rectangular(double rect_length, double rect_height, const TwoVector& pos)
+        : ApertureBase(aRectangularAperture, pos, {{rect_length, rect_height, 0., 0.}}) {}
+
+    Rectangular::~Rectangular() {}
+
+    bool Rectangular::contains(const TwoVector& pos) const {
+      const TwoVector vec(pos - pos_);
+      return (fabs(vec.x()) < p(0) && fabs(vec.y()) < p(1));
+    }
+
+    TwoVector Rectangular::limits() const { return TwoVector(p(0), p(1)); }
+  }  // namespace aperture
+}  // namespace hector

src/IO/HBLFileHandler.cc

@@ -8,10 +8,11 @@
 #include "Hector/Elements/Dipole.h"
 #include "Hector/Elements/Quadrupole.h"
 #include "Hector/Elements/Collimator.h"
-#include "Hector/Elements/RectangularAperture.h"
-#include "Hector/Elements/CircularAperture.h"
-#include "Hector/Elements/EllipticAperture.h"
-#include "Hector/Elements/RectEllipticAperture.h"
+
+#include "Hector/Apertures/Rectangular.h"
+#include "Hector/Apertures/Circular.h"
+#include "Hector/Apertures/Elliptic.h"
+#include "Hector/Apertures/RectElliptic.h"
 
 #include "Hector/IO/HBLFileStructures.h"
 
@@ -96,32 +97,30 @@ namespace hector {
           case aperture::anInvalidAperture:
             break;
           case aperture::aRectangularAperture:
-            elem->setAperture(std::make_shared<aperture::RectangularAperture>(
+            elem->setAperture(std::make_shared<aperture::Rectangular>(
                 el.aperture_p1, el.aperture_p2, TwoVector(el.aperture_x, el.aperture_y)));
             break;
           case aperture::anEllipticAperture:
-            elem->setAperture(std::make_shared<aperture::EllipticAperture>(
+            elem->setAperture(std::make_shared<aperture::Elliptic>(
                 el.aperture_p1, el.aperture_p2, TwoVector(el.aperture_x, el.aperture_y)));
             break;
           case aperture::aCircularAperture:
             elem->setAperture(
-                std::make_shared<aperture::CircularAperture>(el.aperture_p1, TwoVector(el.aperture_x, el.aperture_y)));
+                std::make_shared<aperture::Circular>(el.aperture_p1, TwoVector(el.aperture_x, el.aperture_y)));
             break;
           case aperture::aRectEllipticAperture:
-            elem->setAperture(
-                std::make_shared<aperture::RectEllipticAperture>(el.aperture_p1,
-                                                                 el.aperture_p2,
-                                                                 el.aperture_p3,
-                                                                 el.aperture_p4,
-                                                                 TwoVector(el.aperture_x, el.aperture_y)));
+            elem->setAperture(std::make_shared<aperture::RectElliptic>(el.aperture_p1,
+                                                                       el.aperture_p2,
+                                                                       el.aperture_p3,
+                                                                       el.aperture_p4,
+                                                                       TwoVector(el.aperture_x, el.aperture_y)));
             break;
           case aperture::aRectCircularAperture:
-            elem->setAperture(
-                std::make_shared<aperture::RectEllipticAperture>(el.aperture_p1,
-                                                                 el.aperture_p2,
-                                                                 el.aperture_p3,
-                                                                 el.aperture_p3,
-                                                                 TwoVector(el.aperture_x, el.aperture_y)));
+            elem->setAperture(std::make_shared<aperture::RectElliptic>(el.aperture_p1,
+                                                                       el.aperture_p2,
+                                                                       el.aperture_p3,
+                                                                       el.aperture_p3,
+                                                                       TwoVector(el.aperture_x, el.aperture_y)));
             break;
           //case aperture::aRaceTrackAperture:
           //case aperture::anOctagonalAperture: