Foil (#391)

* optical Foil

strings for ui

* use complex + format

---------

Co-authored-by: F Zotter <[email protected]>

Author: fannyzotter

Intern/rayx-core/src/Beamline/Definitions.h

@@ -17,7 +17,7 @@ enum class CurvatureType {
     Quadric,
     RzpSphere
 };  // order is crucial for xml prser
-enum class BehaviourType { Mirror, Grating, Slit, Rzp, ImagePlane, Crystal };
+enum class BehaviourType { Mirror, Grating, Slit, Rzp, ImagePlane, Crystal, Foil };
 enum class FigureRotation { Yes, Plane, A11 };
 
 // the direction of a plane, either XY or XZ. This is only used in the parsing.

Intern/rayx-core/src/Design/DesignElement.cpp

@@ -32,17 +32,19 @@ OpticalElement DesignElement::compile(const glm::dvec4& parentPos, const glm::dm
     dePtr->setPosition(worldPos);
     dePtr->setOrientation(worldOri);
 
+    DesignPlane plane = getDesignPlane();
+
     if (getType() == ElementType::ExpertsMirror) {
-        return makeElement(*dePtr, serializeMirror(), makeQuadric(*dePtr));
+        return makeElement(*dePtr, serializeMirror(), makeQuadric(*dePtr), plane);
     } else {
         Surface surface = makeSurface(*dePtr);
         Behaviour behaviour = makeBehaviour(*dePtr);
         if (getType() == ElementType::Slit) {
-            return makeElement(*dePtr, behaviour, surface, {}, DesignPlane::XY);
+            return makeElement(*dePtr, behaviour, surface, plane, {});
         } else if (getType() == ElementType::ImagePlane) {
-            return makeElement(*dePtr, behaviour, surface, serializeUnlimited(), DesignPlane::XY);
+            return makeElement(*dePtr, behaviour, surface, plane, serializeUnlimited());
         } else {
-            return makeElement(*dePtr, behaviour, surface);
+            return makeElement(*dePtr, behaviour, surface, plane);
         }
     }
 }
@@ -490,4 +492,13 @@ double DesignElement::getDSpacing2() const { return m_elementParameters["dSpacin
 void DesignElement::setOffsetAngle(Rad value) { m_elementParameters["offsetAngle"] = value; }
 Rad DesignElement::getOffsetAngle() const { return m_elementParameters["offsetAngle"].as_rad(); }
 
+void DesignElement::setThicknessSubstrate(double value) { m_elementParameters["thicknessSubstrate"] = value; }
+double DesignElement::getThicknessSubstrate() const { return m_elementParameters["thicknessSubstrate"].as_double(); }
+
+void DesignElement::setRoughnessSubstrate(double value) { m_elementParameters["roughnessSubstrate"] = value; }
+double DesignElement::getRoughnessSubstrate() const { return m_elementParameters["roughnessSubstrate"].as_double(); }
+
+void DesignElement::setDesignPlane(DesignPlane value) { m_elementParameters["designPlane"] = value; }
+DesignPlane DesignElement::getDesignPlane() const { return m_elementParameters["designPlane"].as_designPlane(); }
+
 }  // namespace RAYX

Intern/rayx-core/src/Design/DesignElement.h

@@ -234,5 +234,14 @@ struct RAYX_API DesignElement : public BeamlineNode {
 
     void setDSpacing2(double value);
     double getDSpacing2() const;
+
+    void setThicknessSubstrate(double value);
+    double getThicknessSubstrate() const;
+
+    void setRoughnessSubstrate(double value);
+    double getRoughnessSubstrate() const;
+    
+    void setDesignPlane(DesignPlane value);
+    DesignPlane getDesignPlane() const;
 };
 }  // namespace RAYX

Intern/rayx-core/src/Design/Value.cpp

@@ -52,6 +52,7 @@ ValueType DesignMap::type() const {
         ValueType::ElementType,
         ValueType::GratingMount,
         ValueType::CrystalType,
+        ValueType::DesignPlane,
     };
     return types[m_variant.index()];
 }
@@ -191,6 +192,11 @@ CrystalType DesignMap::as_crystalType() const {
     throw std::runtime_error("as_crystalType() called on non-crystalType!");
 }
 
+DesignPlane DesignMap::as_designPlane() const {
+    if (auto* x = std::get_if<DesignPlane>(&m_variant)) return *x;
+    throw std::runtime_error("as_designPlane() called on non-designPlane!");
+}
+
 const DesignMap& DesignMap::operator[](const std::string& s) const {
     if (auto* m = std::get_if<Map>(&m_variant)) {
         auto it = m->find(s);

Intern/rayx-core/src/Design/Value.h

@@ -47,7 +47,8 @@ enum class ValueType {
     BehaviourType,
     ElementType,
     GratingMount,
-    CrystalType
+    CrystalType,
+    DesignPlane
 };
 
 class Undefined {};
@@ -96,6 +97,7 @@ class RAYX_API DesignMap {
     DesignMap(ElementType x) : m_variant(x) {}
     DesignMap(GratingMount x) : m_variant(x) {}
     DesignMap(CrystalType x) : m_variant(x) {}
+    DesignMap(DesignPlane x) : m_variant(x) {}
 
     // Assignment operators
     void operator=(double x) { m_variant = x; }
@@ -126,6 +128,7 @@ class RAYX_API DesignMap {
     void operator=(GratingMount x) { m_variant = x; }
     void operator=(ElementType x) { m_variant = x; }
     void operator=(CrystalType x) { m_variant = x; }
+    void operator=(DesignPlane x) { m_variant = x; }
 
     // Deep copy (clone) method.
     DesignMap clone() const;
@@ -160,6 +163,7 @@ class RAYX_API DesignMap {
     ElementType as_elementType() const;
     GratingMount as_gratingMount() const;
     CrystalType as_crystalType() const;
+    DesignPlane as_designPlane() const;
 
     // Subscript operators.
     const DesignMap& operator[](const std::string& s) const;
@@ -236,7 +240,7 @@ class RAYX_API DesignMap {
   private:
     std::variant<Undefined, double, int, ElectronEnergyOrientation, glm::dvec4, glm::dmat4x4, bool, EnergyDistributionType, Misalignment,
                  CentralBeamstop, Cutout, CutoutType, EventType, CylinderDirection, FigureRotation, Map, Surface, CurvatureType, SourceDist,
-                 SpreadType, Rad, Material, EnergySpreadUnit, std::string, SigmaType, BehaviourType, ElementType, GratingMount, CrystalType>
+                 SpreadType, Rad, Material, EnergySpreadUnit, std::string, SigmaType, BehaviourType, ElementType, GratingMount, CrystalType, DesignPlane>
         m_variant;
 };
 

Intern/rayx-core/src/Element/Behaviour.cpp

@@ -19,6 +19,8 @@ Behaviour makeBehaviour(const DesignElement& dele) {
             return makeRZPBehaviour(dele);
         case BehaviourType::Slit:
             return makeSlit(dele);
+        case BehaviourType::Foil:
+            return makeFoil(dele);
         default:
             return serializeImagePlane();
     }
@@ -147,4 +149,15 @@ Behaviour makeRZPBehaviour(const DesignElement& dele) {
                          .m_additionalOrder = (double)additionalOrder});
 }
 
+// Foil Behaviour
+Behaviour makeFoil(const DesignElement& dele) {
+    auto thicknessSubstrate = dele.getThicknessSubstrate();
+    auto roughnessSubstrate = dele.getRoughnessSubstrate();
+
+    return serializeFoil({
+        .m_thicknessSubstrate = thicknessSubstrate,
+        .m_roughnessSubstrate = roughnessSubstrate,
+    });
+}
+
 }  // namespace RAYX

Intern/rayx-core/src/Element/Behaviour.h

@@ -16,6 +16,7 @@ enum class BehaveType {
     RZP,
     ImagePlane,
     Crystal,
+    Foil
 };
 
 struct Behaviour {
@@ -35,7 +36,7 @@ Behaviour makeCrystal(const DesignElement& dele);
 Behaviour makeGrating(const DesignElement& dele);  //< creates a Grating Behaviour from the parameters given in `dele`.
 Behaviour makeSlit(const DesignElement& dele);
 Behaviour makeRZPBehaviour(const DesignElement& dele);
-Behaviour makeCrystalBehaviour(const DesignElement& dele);
+Behaviour makeFoil(const DesignElement& dele);
 
 ////////////////////
 // Mirror
@@ -266,6 +267,33 @@ inline CrystalBehaviour deserializeCrystal(const Behaviour& b) {
     return c;
 }
 
+/////////////////
+// FOIL
+////////////////
+
+struct FoilBehaviour {
+    //Substrates
+    double m_thicknessSubstrate;
+    double m_roughnessSubstrate;
+};
+
+RAYX_FN_ACC
+inline Behaviour serializeFoil(FoilBehaviour f) {
+    Behaviour b;
+    b.m_type = BehaveType::Foil;
+    b.m_private_serialization_params[0] = f.m_thicknessSubstrate;
+    b.m_private_serialization_params[1] = f.m_roughnessSubstrate;
+    return b;
+}
+
+RAYX_FN_ACC
+inline FoilBehaviour deserializeFoil(Behaviour b) {
+    FoilBehaviour f;
+    f.m_thicknessSubstrate = b.m_private_serialization_params[0];
+    f.m_roughnessSubstrate = b.m_private_serialization_params[1];
+    return f;
+}
+
 // This prevents m_private_serialization_params from being used outside of this file - making them practically private.
 #define m_private_serialization_params "m_private_serialization_params are private! Use the corresponding serialize & deserialize functions instead."
 

Intern/rayx-core/src/Element/Element.cpp

@@ -53,7 +53,7 @@ inline glm::dmat4x4 defaultOutMatrix(const DesignElement& dele, DesignPlane plan
 
 inline int defaultMaterial(const DesignElement& dele) { return static_cast<int>(dele.getMaterial()); }
 
-OpticalElement makeElement(const DesignElement& dele, Behaviour behaviour, Surface surface, std::optional<Cutout> cutout, DesignPlane plane) {
+OpticalElement makeElement(const DesignElement& dele, Behaviour behaviour, Surface surface, DesignPlane plane, std::optional<Cutout> cutout ) {
     if (!cutout) {
         cutout = dele.getCutout();
     }
@@ -95,7 +95,8 @@ std::map<ElementType, std::string> ElementStringMap = {{ElementType::CircleSourc
                                                        {ElementType::DipoleSrc, "Dipole"},
                                                        {ElementType::PixelSource, "Pixel Source"},
                                                        {ElementType::EllipsoidMirror, "Ellipsoid"},
-                                                       {ElementType::Crystal, "Crystal"}};
+                                                       {ElementType::Crystal, "Crystal"},
+                                                       {ElementType::Foil, "Foil"}};
 
 ElementType findElementString(const std::string& name) {
     auto it = std::find_if(ElementStringMap.begin(), ElementStringMap.end(),

Intern/rayx-core/src/Element/Element.h

@@ -23,6 +23,7 @@ enum class ElementType {
     CylinderMirror,
     EllipsoidMirror,
     ExpertsMirror,
+    Foil,
     ParaboloidMirror,
     PlaneGrating,
     PlaneMirror,
@@ -63,8 +64,8 @@ static_assert(std::is_trivially_default_constructible_v<OpticalElement>);
 RAYX_API glm::dmat4 calcTransformationMatrices(glm::dvec4 position, glm::dmat4 orientation, bool calcInMatrix, DesignPlane plane);
 
 // constructs an OpticalElement given all of its components. Some information that is not explicitly given, will be parsed from the ` dele`.
-OpticalElement makeElement(const DesignElement& dele, Behaviour behaviour, Surface surface, std::optional<Cutout> cutout = {},
-                           DesignPlane plane = DesignPlane::XZ);
+OpticalElement makeElement(const DesignElement& dele, Behaviour behaviour, Surface surface, DesignPlane plane = DesignPlane::XZ,
+                            std::optional<Cutout> cutout = {});
 
 extern std::map<ElementType, std::string> RAYX_API ElementStringMap;
 ElementType RAYX_API findElementString(const std::string& name);

Intern/rayx-core/src/Element/Surface.cpp

@@ -27,7 +27,7 @@ Surface makeSurface(const DesignElement& dele) {
     }
 }
 
-Surface makePlane() { return serializePlaneXZ(); }
+Surface makePlane() { return serializePlane(); }
 
 Surface makeCylinder(const DesignElement& dele) {
     auto cyl_direction = dele.getRadiusDirection();