Merge branch 'multilayer_merge'

Author: fannyzotter

Intern/rayx-core/CMakeLists.txt

@@ -90,6 +90,7 @@ if(MSVC)
     set(MSVC_CXX_FLAGS /W3) # enable warning level 3
     list(APPEND MSVC_CXX_FLAGS /wd4251) # disable warnings related to missing DLL export annotation on members of exported classes
     list(APPEND MSVC_CXX_FLAGS /wd4267) # disable warnings related to narrowing conversion
+    list(APPEND MSVC_CXX_FLAGS /wd221) # disable warnings related to narrowing conversion
     list(APPEND MSVC_CXX_FLAGS /Zc:preprocessor) # enable __VA_OPT__
     if(RAYX_WERROR)
         list(APPEND MSVC_CXX_FLAGS /WX) # handle warnings as errors

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

@@ -277,7 +277,7 @@ void DesignElement::setExpertsCubic(Surface value) {
     m_elementParameters["expertsParams"]["B31"] = cub.m_b31;
     m_elementParameters["expertsParams"]["B32"] = cub.m_b32;
 
-    m_elementParameters["expertsParams"]["tangentAngleAlpha"] = cub.m_psi * 180 / PI;
+    m_elementParameters["expertsParams"]["psi"] = cub.m_psi;
 }
 
 Surface DesignElement::getExpertsCubic() const {
@@ -300,8 +300,7 @@ Surface DesignElement::getExpertsCubic() const {
     cub.m_b31 = m_elementParameters["expertsParams"]["B31"].as_double();
     cub.m_b32 = m_elementParameters["expertsParams"]["B32"].as_double();
 
-    cub.m_psi = m_elementParameters["expertsParams"]["tangentAngleAlpha"].as_double() * PI / 180;
-
+    cub.m_psi = m_elementParameters["expertsParams"]["psi"].as_double();
     return Surface::Cubic{cub};
 }
 
@@ -510,4 +509,62 @@ double DesignElement::getRoughnessSubstrate() const { return m_elementParameters
 void DesignElement::setDesignPlane(DesignPlane value) { m_elementParameters["designPlane"] = value; }
 DesignPlane DesignElement::getDesignPlane() const { return m_elementParameters["designPlane"].as_designPlane(); }
 
+void DesignElement::setSurfaceCoatingType(SurfaceCoatingType value) { m_elementParameters["surfaceCoatingType"] = value; }
+SurfaceCoatingType DesignElement::getSurfaceCoatingType() const { return m_elementParameters["surfaceCoatingType"].as_surfaceCoatingType(); }
+
+
+void DesignElement::setMultilayerCoating(const Coating::MultilayerCoating& coating) {
+    m_elementParameters["numLayers"] = coating.numLayers;
+    m_elementParameters["coating"] = Map();
+    for (int i = 0; i < coating.numLayers; ++i) {
+        m_elementParameters["coating"]["layer" + std::to_string(i + 1)] = Map();
+        m_elementParameters["coating"]["layer" + std::to_string(i + 1)]["material"] = coating.material[i];
+        m_elementParameters["coating"]["layer" + std::to_string(i + 1)]["thickness"] = coating.thickness[i];
+        m_elementParameters["coating"]["layer" + std::to_string(i + 1)]["roughness"] = coating.roughness[i];
+    }
+}
+
+Coating DesignElement::getCoating() const { // 0 = substrate only, 1 = one coating, 2 = multiple coatings
+    SurfaceCoatingType type = getSurfaceCoatingType();
+    if (type == SurfaceCoatingType::SubstrateOnly) {
+        return Coating::SubstrateOnly{};
+    } else if (type == SurfaceCoatingType::OneCoating) {
+        Coating::OneCoating oneCoating;
+        oneCoating.material = static_cast<int>(getMaterialCoating());
+        oneCoating.thickness = getThicknessCoating();
+        oneCoating.roughness = getRoughnessCoating();
+        return Coating::OneCoating{oneCoating};
+    } else if (type == SurfaceCoatingType::MultipleCoatings) {
+        Coating::MultilayerCoating mlCoating;
+        mlCoating.numLayers = m_elementParameters["numLayers"].as_int();
+        for (int i = 0; i < mlCoating.numLayers; ++i) {
+            std::string layerKey = "layer" + std::to_string(i + 1);
+            try {
+                mlCoating.material[i] = m_elementParameters["coating"][layerKey]["material"].as_int();
+                mlCoating.thickness[i] = m_elementParameters["coating"][layerKey]["thickness"].as_double();
+                mlCoating.roughness[i] = m_elementParameters["coating"][layerKey]["roughness"].as_double();
+            } catch (const std::exception& e) {
+                std::cerr << "Error deserializing layer " << layerKey << ": " << e.what() << std::endl;
+            }
+        }
+        if (0 > mlCoating.material[0] || mlCoating.material[0] > 97) {
+            std::cerr << "Warning: No coating layers found in DesignElement." << std::endl;
+            return Coating::SubstrateOnly{}; // Default case if no layers are found
+        }
+        return Coating::MultilayerCoating{mlCoating};
+    } else {
+        return Coating::SubstrateOnly{}; // Placeholder for multiple coatings, needs implementation
+    }
+}
+
+// material coating
+void DesignElement::setMaterialCoating(Material value) { m_elementParameters["materialCoating"] = value; }
+Material DesignElement::getMaterialCoating() const { return m_elementParameters["materialCoating"].as_material(); }
+
+void DesignElement::setThicknessCoating(double value) { m_elementParameters["thicknessCoating"] = value; }
+double DesignElement::getThicknessCoating() const { return m_elementParameters["thicknessCoating"].as_double(); }
+
+void DesignElement::setRoughnessCoating(double value) { m_elementParameters["roughnessCoating"] = value; }
+double DesignElement::getRoughnessCoating() const { return m_elementParameters["roughnessCoating"].as_double(); }
+
 }  // namespace RAYX

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

@@ -243,5 +243,21 @@ struct RAYX_API DesignElement : public BeamlineNode {
 
     void setDesignPlane(DesignPlane value);
     DesignPlane getDesignPlane() const;
+
+    void setSurfaceCoatingType(SurfaceCoatingType value);
+    SurfaceCoatingType getSurfaceCoatingType() const;
+
+    void setMultilayerCoating(const Coating::MultilayerCoating& coating);
+    
+    Coating getCoating() const;
+
+    void setMaterialCoating(Material value);
+    Material getMaterialCoating() const;
+
+    void setThicknessCoating(double value);
+    double getThicknessCoating() const;
+
+    void setRoughnessCoating(double value);
+    double getRoughnessCoating() const;
 };
 }  // namespace RAYX

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

@@ -53,6 +53,7 @@ ValueType DesignMap::type() const {
         ValueType::GratingMount,
         ValueType::CrystalType,
         ValueType::DesignPlane,
+        ValueType::SurfaceCoatingType,
     };
     return types[m_variant.index()];
 }
@@ -197,6 +198,11 @@ DesignPlane DesignMap::as_designPlane() const {
     throw std::runtime_error("as_designPlane() called on non-designPlane!");
 }
 
+SurfaceCoatingType DesignMap::as_surfaceCoatingType() const {
+    if (auto* x = std::get_if<SurfaceCoatingType>(&m_variant)) return *x;
+    throw std::runtime_error("as_surfaceCoatingType() called on non-surfaceCoatingType!");
+}
+
 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

@@ -48,7 +48,8 @@ enum class ValueType {
     ElementType,
     GratingMount,
     CrystalType,
-    DesignPlane
+    DesignPlane,
+    SurfaceCoatingType
 };
 
 class Undefined {};
@@ -98,6 +99,7 @@ class RAYX_API DesignMap {
     DesignMap(GratingMount x) : m_variant(x) {}
     DesignMap(CrystalType x) : m_variant(x) {}
     DesignMap(DesignPlane x) : m_variant(x) {}
+    DesignMap(SurfaceCoatingType x) : m_variant(x) {}
 
     // Assignment operators
     void operator=(double x) { m_variant = x; }
@@ -129,6 +131,7 @@ class RAYX_API DesignMap {
     void operator=(ElementType x) { m_variant = x; }
     void operator=(CrystalType x) { m_variant = x; }
     void operator=(DesignPlane x) { m_variant = x; }
+    void operator=(SurfaceCoatingType x) { m_variant = x; }
 
     // Deep copy (clone) method.
     DesignMap clone() const;
@@ -164,6 +167,7 @@ class RAYX_API DesignMap {
     GratingMount as_gratingMount() const;
     CrystalType as_crystalType() const;
     DesignPlane as_designPlane() const;
+    SurfaceCoatingType as_surfaceCoatingType() const;
 
     // Subscript operators.
     const DesignMap& operator[](const std::string& s) const;
@@ -241,7 +245,7 @@ class RAYX_API DesignMap {
     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,
-                 DesignPlane>
+                 DesignPlane, SurfaceCoatingType>
         m_variant;
 };
 

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

@@ -11,6 +11,8 @@ namespace RAYX {
 // Each behaviour type has its own `behave` function in `Behave.h`.
 enum class BehaveType { Mirror, Grating, Slit, RZP, ImagePlane, Crystal, Foil };
 
+
+
 struct Behaviour {
     struct Mirror {
         // no parameters
@@ -73,6 +75,7 @@ struct Behaviour {
     Behaviour(T t) : m_behaviour(t) {}
 
     template <typename T>
+    RAYX_FN_ACC
     bool is() const {
         return variant::holds_alternative<T>(m_behaviour);
     }

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

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "Core.h"
+#include <vector>
+
+namespace RAYX {
+
+
+enum class SurfaceCoatingType {
+    SubstrateOnly,  // No coating, only substrate
+    OneCoating,     // One coating layer
+    MultipleCoatings // Multiple coating layers
+};
+
+struct RAYX_API Coating{
+
+    struct RAYX_API SubstrateOnly {
+        // No additional parameters needed
+    };
+
+    struct RAYX_API OneCoating {
+        int material;
+        double thickness;
+        double roughness;
+    };
+
+    struct RAYX_API MultilayerCoating {
+        int numLayers;
+        int material[1000];
+        double thickness[1000];
+        double roughness[1000];
+    };
+
+    variant::variant<SubstrateOnly, OneCoating, MultilayerCoating> m_coating;
+
+    Coating() : Coating(SubstrateOnly{}) {}
+
+    template<typename T>
+    Coating(T t) : m_coating(t) {}
+
+    template <typename T>
+    RAYX_FN_ACC
+    bool is() const {
+        return variant::holds_alternative<T>(m_coating);
+    }
+};
+
+} // namespace RAYX

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

@@ -67,6 +67,7 @@ OpticalElement makeElement(const DesignElement& dele, Behaviour behaviour, Surfa
         .m_behaviour = behaviour,
         .m_surface = surface,
         .m_cutout = *cutout,
+        .m_coating = dele.getCoating(),
         .m_slopeError = dele.getSlopeError(),
         .m_azimuthalAngle = dele.getAzimuthalAngle().rad,
         .m_material = defaultMaterial(dele),

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

@@ -8,6 +8,7 @@
 #include "Behaviour.h"
 #include "Core.h"
 #include "Cutout.h"
+#include "Coating.h"
 #include "Rml/xml.h"
 #include "Shader/SlopeError.h"
 #include "Surface.h"
@@ -52,13 +53,14 @@ struct OpticalElement {
     Behaviour m_behaviour;    ///< Describes what happens to a ray once it collides with this OpticalElement.
     Surface m_surface;        ///< Describes how the OpticalElement's surface is curved.
     Cutout m_cutout;          ///< Limits the Surface to the dimensions of the actual OpticalElement.
+    Coating m_coating;        ///< Describes the coating of the surface, if any.
     SlopeError m_slopeError;  ///< Describes a random noise in the normal vector of a particular surface point.
     double m_azimuthalAngle;  ///< Azimuthal angle at which this element is rotated around the "main-beam".
     int m_material;           ///< The material that this object is made of (see `enum class Material` from Material.h).
 };
 
 // Ensure OpticalElement does not introduce cost on copy or default construction.
-static_assert(std::is_trivially_copyable_v<OpticalElement>);
+//static_assert(std::is_trivially_copyable_v<OpticalElement>);
 
 RAYX_API glm::dmat4 calcTransformationMatrices(glm::dvec4 position, glm::dmat4 orientation, bool calcInMatrix, DesignPlane plane);
 

Intern/rayx-core/src/Rml/DesignElementWriter.h

@@ -18,6 +18,22 @@ namespace RAYX {
  * This only works in combi with the xml parser.
  */
 
+void getSurfaceCoating(xml::Parser parser, DesignElement* de) {
+    if (parser.parseSurfaceCoatingType() == SurfaceCoatingType::SubstrateOnly) {
+        de->setSurfaceCoatingType(parser.parseSurfaceCoatingType());
+        return;
+    } else if (parser.parseSurfaceCoatingType() == SurfaceCoatingType::OneCoating) {
+        de->setSurfaceCoatingType(parser.parseSurfaceCoatingType());
+        de->setMaterialCoating(parser.parseMaterial());
+        de->setThicknessCoating(parser.parseThicknessCoating());
+        de->setRoughnessCoating(parser.parseRoughnessCoating());
+    } else if (parser.parseSurfaceCoatingType() == SurfaceCoatingType::MultipleCoatings) {
+        de->setSurfaceCoatingType(parser.parseSurfaceCoatingType());
+        de->setMultilayerCoating(parser.parseCoating());
+        return;
+    }
+}
+
 void setAllMandatory(xml::Parser parser, DesignElement* de, DesignPlane dp) {
     de->setName(parser.name());
     de->setType(parser.type());
@@ -30,6 +46,7 @@ void setAllMandatory(xml::Parser parser, DesignElement* de, DesignPlane dp) {
     de->setAzimuthalAngle(parser.parseAzimuthalAngle());
     de->setMaterial(parser.parseMaterial());
 
+    de->setSurfaceCoatingType(SurfaceCoatingType::SubstrateOnly);
     de->setDesignPlane(dp);
     if (de->getType() != ElementType::ImagePlane) {
         de->setCutout(parser.parseCutout(dp, ElementStringMap[parser.type()]));
@@ -65,6 +82,8 @@ void getCone(xml::Parser parser, DesignElement* de) {
     de->setCurvatureType(CurvatureType::Cone);
     de->setBehaviourType(BehaviourType::Mirror);
 
+    getSurfaceCoating(parser, de);
+
     de->setGrazingIncAngle(parser.parseGrazingIncAngle());
     de->setEntranceArmLength(parser.parseEntranceArmLength());
     de->setExitArmLength(parser.parseExitArmLength());
@@ -93,6 +112,8 @@ void getCylinder(xml::Parser parser, DesignElement* de) {
     de->setCurvatureType(CurvatureType::Cylinder);
     de->setBehaviourType(BehaviourType::Mirror);
 
+    getSurfaceCoating(parser, de);
+
     de->setRadiusDirection(parser.parseBendingRadius());
     de->setRadius(parser.parseRadius());
     de->setGrazingIncAngle(parser.parseGrazingIncAngle());
@@ -105,6 +126,8 @@ void getEllipsoid(xml::Parser parser, DesignElement* de) {
     de->setCurvatureType(CurvatureType::Ellipsoid);
     de->setBehaviourType(BehaviourType::Mirror);
 
+    getSurfaceCoating(parser, de);
+
     de->setShortHalfAxisB(parser.parseShortHalfAxisB());
     de->setLongHalfAxisA(parser.parseLongHalfAxisA());
     de->setDesignGrazingIncAngle(parser.parseDesignGrazingIncAngle());
@@ -120,6 +143,8 @@ void getParaboloid(xml::Parser parser, DesignElement* de) {
     de->setCurvatureType(CurvatureType::Paraboloid);
     de->setBehaviourType(BehaviourType::Mirror);
 
+    getSurfaceCoating(parser, de);
+
     de->setArmLength(parser.parseArmLength());
     de->setParameterP(parser.parseParameterP());
     de->setParameterPType(parser.parseParameterPType());
@@ -157,13 +182,17 @@ void getPlaneMirror(xml::Parser parser, DesignElement* de) {
     setAllMandatory(parser, de, DesignPlane::XZ);
     de->setCurvatureType(CurvatureType::Plane);
     de->setBehaviourType(BehaviourType::Mirror);
+
+    getSurfaceCoating(parser, de);
 }
 
 void getSphereMirror(xml::Parser parser, DesignElement* de) {
     setAllMandatory(parser, de, DesignPlane::XZ);
     de->setCurvatureType(CurvatureType::Spherical);
     de->setBehaviourType(BehaviourType::Mirror);
 
+    getSurfaceCoating(parser, de);
+
     de->setGrazingIncAngle(parser.parseGrazingIncAngle());
     de->setEntranceArmLength(parser.parseEntranceArmLength());
     de->setExitArmLength(parser.parseExitArmLength());
@@ -175,14 +204,18 @@ void getToroidMirror(xml::Parser parser, DesignElement* de) {
     de->setCurvatureType(CurvatureType::Toroidal);
     de->setBehaviourType(BehaviourType::Mirror);
 
+    getSurfaceCoating(parser, de);
+
     de->setShortRadius(parser.parseShortRadius());
     de->setLongRadius(parser.parseLongRadius());
 }
 
 void getToroidalGrating(xml::Parser parser, DesignElement* de) {
     setAllMandatory(parser, de, DesignPlane::XZ);
     de->setCurvatureType(CurvatureType::Toroidal);
-    de->setBehaviourType(BehaviourType::Mirror);
+    de->setBehaviourType(BehaviourType::Grating);
+
+    getSurfaceCoating(parser, de);
 
     de->setShortRadius(parser.parseShortRadius());
     de->setLongRadius(parser.parseLongRadius());
@@ -221,6 +254,8 @@ void getExpertsCubic(xml::Parser parser, DesignElement* de) {
     de->setCurvatureType(CurvatureType::Cubic);
     de->setBehaviourType(BehaviourType::Mirror);
 
+    getSurfaceCoating(parser, de);
+
     de->setExpertsCubic(parser.parseCubicParameters());
 }
 
@@ -229,6 +264,8 @@ void getExpertsOptics(xml::Parser parser, DesignElement* de) {
     de->setCurvatureType(CurvatureType::Quadric);
     de->setBehaviourType(BehaviourType::Mirror);
 
+    getSurfaceCoating(parser, de);
+
     de->setExpertsOptics(parser.parseQuadricParameters());
 }