hz-b · fannyzotter · Jun 24, 2025 · Jun 24, 2025 · Jun 24, 2025 · Jun 24, 2025
diff --git a/Intern/rayx-core/src/Beamline/Definitions.h b/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 };
+enum class BehaviourType { Mirror, Grating, Slit, Rzp, ImagePlane, Crystal };
 enum class FigureRotation { Yes, Plane, A11 };
 
 // the direction of a plane, either XY or XZ. This is only used in the parsing.

diff --git a/Intern/rayx-core/src/Design/DesignElement.cpp b/Intern/rayx-core/src/Design/DesignElement.cpp
@@ -36,13 +36,13 @@ OpticalElement DesignElement::compile(const glm::dvec4& parentPos, const glm::dm
         return makeElement(*dePtr, serializeMirror(), makeQuadric(*dePtr));
     } else {
         Surface surface = makeSurface(*dePtr);
-        Behaviour behavior = makeBehaviour(*dePtr);
+        Behaviour behaviour = makeBehaviour(*dePtr);
         if (getType() == ElementType::Slit) {
-            return makeElement(*dePtr, behavior, surface, {}, DesignPlane::XY);
+            return makeElement(*dePtr, behaviour, surface, {}, DesignPlane::XY);
         } else if (getType() == ElementType::ImagePlane) {
-            return makeElement(*dePtr, behavior, surface, serializeUnlimited(), DesignPlane::XY);
+            return makeElement(*dePtr, behaviour, surface, serializeUnlimited(), DesignPlane::XY);
         } else {
-            return makeElement(*dePtr, behavior, surface);
+            return makeElement(*dePtr, behaviour, surface);
         }
     }
 }
@@ -346,91 +346,72 @@ double DesignElement::getOpeningHeight() const { return m_elementParameters["ope
 void DesignElement::setCentralBeamstop(CentralBeamstop value) { m_elementParameters["centralBeamstop"] = value; }
 CentralBeamstop DesignElement::getCentralBeamstop() const { return m_elementParameters["centralBeamstop"].as_centralBeamStop(); }
 
-// Stop Width
 void DesignElement::setStopWidth(double width) { m_elementParameters["stopWidth"] = width; }
 double DesignElement::getStopWidth() const { return m_elementParameters["stopWidth"].as_double(); }
 
-// Stop Height
 void DesignElement::setStopHeight(double height) { m_elementParameters["stopHeight"] = height; }
 double DesignElement::getStopHeight() const { return m_elementParameters["stopHeight"].as_double(); }
 
-// Total Width
 void DesignElement::setTotalWidth(double width) { m_elementParameters["totalWidth"] = width; }
 double DesignElement::getTotalWidth() const { return m_elementParameters["totalWidth"].as_double(); }
 
-// Profile Kind
 void DesignElement::setProfileKind(int value) { m_elementParameters["profileKind"] = value; }
 int DesignElement::getProfileKind() const { return m_elementParameters["profileKind"].as_int(); }
 
-// Profile File
 void DesignElement::setProfileFile(double filePath) { m_elementParameters["profileFile"] = filePath; }
 double DesignElement::getProfileFile() const { return m_elementParameters["profileFile"].as_double(); }
 
-// Total Length
 void DesignElement::setTotalLength(double value) { m_elementParameters["totalLength"] = value; }
 double DesignElement::getTotalLength() const { return m_elementParameters["totalLength"].as_double(); }
 
-// Grazing Inc Angle
 void DesignElement::setGrazingIncAngle(Rad value) { m_elementParameters["grazingIncAngle"] = value; }
 Rad DesignElement::getGrazingIncAngle() const { return m_elementParameters["grazingIncAngle"].as_rad(); }
 
 void DesignElement::setDeviationAngle(Rad value) { m_elementParameters["deviationAngle"] = value; }
 Rad DesignElement::getDeviationAngle() const { return m_elementParameters["deviationAngle"].as_rad(); }
 
-// Entrance Arm Length
 void DesignElement::setEntranceArmLength(double value) { m_elementParameters["entranceArmLength"] = value; }
 double DesignElement::getEntranceArmLength() const { return m_elementParameters["entranceArmLength"].as_double(); }
 
-// Exit Arm Length
 void DesignElement::setExitArmLength(double value) { m_elementParameters["exitArmLength"] = value; }
 double DesignElement::getExitArmLength() const { return m_elementParameters["exitArmLength"].as_double(); }
 
-// bendingRadius
 void DesignElement::setRadiusDirection(CylinderDirection value) { m_elementParameters["bendingRadius"] = value; }
 CylinderDirection DesignElement::getRadiusDirection() const { return m_elementParameters["bendingRadius"].as_cylinderDirection(); }
 
-// radius
 void DesignElement::setRadius(double value) { m_elementParameters["radius"] = value; }
 double DesignElement::getRadius() const { return m_elementParameters["radius"].as_double(); }
 
 void DesignElement::setDesignGrazingIncAngle(Rad value) { m_elementParameters["designGrazingIncAngle"] = value; }
 Rad DesignElement::getDesignGrazingIncAngle() const { return m_elementParameters["designGrazingIncAngle"].as_rad(); }
 
-// longHalfAxisA
 void DesignElement::setLongHalfAxisA(double value) { m_elementParameters["longHalfAxisA"] = value; }
 double DesignElement::getLongHalfAxisA() const { return m_elementParameters["longHalfAxisA"].as_double(); }
 
-// shortHalfAxisB
 void DesignElement::setShortHalfAxisB(double value) { m_elementParameters["shortHalfAxisB"] = value; }
 double DesignElement::getShortHalfAxisB() const { return m_elementParameters["shortHalfAxisB"].as_double(); }
 
 void DesignElement::setParameterA11(double value) { m_elementParameters["parameter_a11"] = value; }
 double DesignElement::getParameterA11() const { return m_elementParameters["parameter_a11"].as_double(); }
 
-// figureRotation
 void DesignElement::setFigureRotation(FigureRotation value) { m_elementParameters["figureRotation"] = value; }
 FigureRotation DesignElement::getFigureRotation() const { return m_elementParameters["figureRotation"].as_figureRotation(); }
 
-// armLength
 void DesignElement::setArmLength(double value) { m_elementParameters["armLength"] = value; }
 double DesignElement::getArmLength() const { return m_elementParameters["armLength"].as_double(); }
 
-// parameter_P
 void DesignElement::setParameterP(double value) { m_elementParameters["parameter_P"] = value; }
 double DesignElement::getParameterP() const { return m_elementParameters["parameter_P"].as_double(); }
 
-// parameter_P_type
 void DesignElement::setParameterPType(double value) { m_elementParameters["parameter_P_type"] = value; }
 double DesignElement::getParameterPType() const { return m_elementParameters["parameter_P_type"].as_double(); }
 
-// Setter and Getter for lineDensity
 void DesignElement::setLineDensity(double value) { m_elementParameters["lineDensity"] = value; }
 double DesignElement::getLineDensity() const { return m_elementParameters["lineDensity"].as_double(); }
 
 void DesignElement::setShortRadius(double value) { m_elementParameters["shortRadius"] = value; }
 double DesignElement::getShortRadius() const { return m_elementParameters["shortRadius"].as_double(); }
 
-// Setter and Getter for longRadius
 void DesignElement::setLongRadius(double value) { m_elementParameters["longRadius"] = value; }
 double DesignElement::getLongRadius() const { return m_elementParameters["longRadius"].as_double(); }
 
@@ -476,4 +457,37 @@ CurvatureType DesignElement::getCurvatureType() const { return m_elementParamete
 void DesignElement::setBehaviourType(BehaviourType value) { m_elementParameters["behaviourType"] = value; }
 BehaviourType DesignElement::getBehaviourType() const { return m_elementParameters["behaviourType"].as_behaviourType(); }
 
+void DesignElement::setCrystalType(CrystalType value) { m_elementParameters["crystalType"] = value; }
+CrystalType DesignElement::getCrystalType() const { return m_elementParameters["crystalType"].as_crystalType(); }
+
+void DesignElement::setCrystalMaterial(const std::string& value) { m_elementParameters["crystalMaterial"] = value; }
+std::string DesignElement::getCrystalMaterial() const { return m_elementParameters["crystalMaterial"].as_string(); }
+
+void DesignElement::setStructureFactorReF0(double value) { m_elementParameters["structureFactorReF0"] = value; }
+double DesignElement::getStructureFactorReF0() const { return m_elementParameters["structureFactorReF0"].as_double(); }
+
+void DesignElement::setStructureFactorImF0(double value) { m_elementParameters["structureFactorImF0"] = value; }
+double DesignElement::getStructureFactorImF0() const { return m_elementParameters["structureFactorImF0"].as_double(); }
+
+void DesignElement::setStructureFactorReFH(double value) { m_elementParameters["structureFactorReFH"] = value; }
+double DesignElement::getStructureFactorReFH() const { return m_elementParameters["structureFactorReFH"].as_double(); }
+
+void DesignElement::setStructureFactorImFH(double value) { m_elementParameters["structureFactorImFH"] = value; }
+double DesignElement::getStructureFactorImFH() const { return m_elementParameters["structureFactorImFH"].as_double(); }
+
+void DesignElement::setStructureFactorReFHC(double value) { m_elementParameters["structureFactorReFHC"] = value; }
+double DesignElement::getStructureFactorReFHC() const { return m_elementParameters["structureFactorReFHC"].as_double(); }
+
+void DesignElement::setStructureFactorImFHC(double value) { m_elementParameters["structureFactorImFHC"] = value; }
+double DesignElement::getStructureFactorImFHC() const { return m_elementParameters["structureFactorImFHC"].as_double(); }
+
+void DesignElement::setUnitCellVolume(double value) { m_elementParameters["unitCellVolume"] = value; }
+double DesignElement::getUnitCellVolume() const { return m_elementParameters["unitCellVolume"].as_double(); }
+
+void DesignElement::setDSpacing2(double value) { m_elementParameters["dSpacing2"] = value; }
+double DesignElement::getDSpacing2() const { return m_elementParameters["dSpacing2"].as_double(); }
+
+void DesignElement::setOffsetAngle(Rad value) { m_elementParameters["offsetAngle"] = value;}
+Rad DesignElement::getOffsetAngle() const { return m_elementParameters["offsetAngle"].as_rad();}
+
 }  // namespace RAYX
diff --git a/Intern/rayx-core/src/Design/DesignElement.h b/Intern/rayx-core/src/Design/DesignElement.h
@@ -157,27 +157,21 @@ struct RAYX_API DesignElement : public BeamlineNode {
     void setFresnelZOffset(double value);
     double getFresnelZOffset() const;
 
-    // Setter and Getter for designAlphaAngle
     void setDesignAlphaAngle(Rad value);
     Rad getDesignAlphaAngle() const;
 
-    // Setter and Getter for designBetaAngle
     void setDesignBetaAngle(Rad value);
     Rad getDesignBetaAngle() const;
 
-    // Setter and Getter for designOrderOfDiffraction
     void setDesignOrderOfDiffraction(double value);
     double getDesignOrderOfDiffraction() const;
 
-    // Setter and Getter for designEnergy
     void setDesignEnergy(double value);
     double getDesignEnergy() const;
 
-    // Setter and Getter for designSagittalEntranceArmLength
     void setDesignSagittalEntranceArmLength(double value);
     double getDesignSagittalEntranceArmLength() const;
 
-    // Setter and Getter for designSagittalExitArmLength
     void setDesignSagittalExitArmLength(double value);
     double getDesignSagittalExitArmLength() const;
 
@@ -204,5 +198,43 @@ struct RAYX_API DesignElement : public BeamlineNode {
 
     void setBehaviourType(BehaviourType value);
     BehaviourType getBehaviourType() const;
+
+    void setCrystalType(CrystalType value);
+    CrystalType getCrystalType() const;
+
+    void setCrystalMaterial(const std::string& value);
+    std::string getCrystalMaterial() const;
+
+    void setOffsetAngleType(OffsetAngleType value);
+    OffsetAngleType getOffsetAngleType() const;
+
+    void setOffsetAngle(Rad value);
+    Rad getOffsetAngle() const;
+
+    void setStructureFactorReF0(double value);
+    double getStructureFactorReF0() const;
+
+    void setStructureFactorImF0(double value);
+    double getStructureFactorImF0() const;
+
+    void setStructureFactorReFH(double value);
+    double getStructureFactorReFH() const;
+
+    void setStructureFactorImFH(double value);
+    double getStructureFactorImFH() const;
+
+    void setStructureFactorReFHC(double value);
+    double getStructureFactorReFHC() const;
+
+    void setStructureFactorImFHC(double value);
+    double getStructureFactorImFHC() const;
+
+    void setUnitCellVolume(double value);
+    double getUnitCellVolume() const;
+
+    void setDSpacing2(double value);
+    double getDSpacing2() const;
+
+
 };
 }  // namespace RAYX
diff --git a/Intern/rayx-core/src/Design/DesignSource.cpp b/Intern/rayx-core/src/Design/DesignSource.cpp
@@ -38,6 +38,8 @@ std::vector<Ray> DesignSource::compile(int numThreads, const glm::dvec4& groupPo
             return MatrixSource(*dsPtr).getRays(numThreads);
         case ElementType::DipoleSource:
             return DipoleSource(*dsPtr).getRays(numThreads);
+        case ElementType::DipoleSrc:
+            return DipoleSource(*dsPtr).getRays(numThreads);
         case ElementType::PixelSource:
             return PixelSource(*dsPtr).getRays(numThreads);
         case ElementType::CircleSource:

diff --git a/Intern/rayx-core/src/Design/Value.cpp b/Intern/rayx-core/src/Design/Value.cpp
@@ -51,6 +51,7 @@ ValueType DesignMap::type() const {
         ValueType::BehaviourType,
         ValueType::ElementType,
         ValueType::GratingMount,
+        ValueType::CrystalType,
     };
     return types[m_variant.index()];
 }
@@ -185,6 +186,11 @@ GratingMount DesignMap::as_gratingMount() const {
     throw std::runtime_error("as_gratingMount() called on non-gratingMount!");
 }
 
+CrystalType DesignMap::as_crystalType() const {
+    if (auto* x = std::get_if<CrystalType>(&m_variant)) return *x;
+    throw std::runtime_error("as_crystalType() called on non-crystalType!");
+}
+
 const DesignMap& DesignMap::operator[](const std::string& s) const {
     if (auto* m = std::get_if<Map>(&m_variant)) {
         auto it = m->find(s);

diff --git a/Intern/rayx-core/src/Design/Value.h b/Intern/rayx-core/src/Design/Value.h
@@ -46,7 +46,8 @@ enum class ValueType {
     SigmaType,
     BehaviourType,
     ElementType,
-    GratingMount
+    GratingMount,
+    CrystalType
 };
 
 class Undefined {};
@@ -94,6 +95,7 @@ class RAYX_API DesignMap {
     DesignMap(BehaviourType x) : m_variant(x) {}
     DesignMap(ElementType x) : m_variant(x) {}
     DesignMap(GratingMount x) : m_variant(x) {}
+    DesignMap(CrystalType x) : m_variant(x) {}
 
     // Assignment operators
     void operator=(double x) { m_variant = x; }
@@ -123,6 +125,7 @@ class RAYX_API DesignMap {
     void operator=(BehaviourType x) { m_variant = x; }
     void operator=(GratingMount x) { m_variant = x; }
     void operator=(ElementType x) { m_variant = x; }
+    void operator=(CrystalType x) { m_variant = x; }
 
     // Deep copy (clone) method.
     DesignMap clone() const;
@@ -156,6 +159,7 @@ class RAYX_API DesignMap {
     BehaviourType as_behaviourType() const;
     ElementType as_elementType() const;
     GratingMount as_gratingMount() const;
+    CrystalType as_crystalType() const;
 
     // Subscript operators.
     const DesignMap& operator[](const std::string& s) const;
@@ -232,7 +236,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>
+                 SpreadType, Rad, Material, EnergySpreadUnit, std::string, SigmaType, BehaviourType, ElementType, GratingMount, CrystalType>
         m_variant;
 };
 

diff --git a/Intern/rayx-core/src/Element/Behaviour.cpp b/Intern/rayx-core/src/Element/Behaviour.cpp
@@ -9,6 +9,8 @@ namespace RAYX {
 
 Behaviour makeBehaviour(const DesignElement& dele) {
     switch (dele.getBehaviourType()) {
+        case BehaviourType::Crystal:
+            return makeCrystal(dele);
         case BehaviourType::Grating:
             return makeGrating(dele);
         case BehaviourType::Mirror:
@@ -22,6 +24,35 @@ Behaviour makeBehaviour(const DesignElement& dele) {
     }
 }
 
+Behaviour makeCrystal(const DesignElement& dele) {
+
+    auto dSpacing2 = dele.getDSpacing2();
+    auto unitCellVoulume = dele.getUnitCellVolume();
+    auto offsetAngle = dele.getOffsetAngle();
+
+    auto structureFactorReF0 = dele.getStructureFactorReF0();
+    auto structureFactorImF0 = dele.getStructureFactorImF0();
+    auto structureFactorReFH = dele.getStructureFactorReFH();
+    auto structureFactorImFH = dele.getStructureFactorImFH();
+    auto structureFactorReFHC = dele.getStructureFactorReFHC();
+    auto structureFactorImFHC = dele.getStructureFactorImFHC();
+
+    return serializeCrystal({
+
+        .m_dSpacing2 = dSpacing2,
+        .m_unitCellVolume = unitCellVoulume,
+        .m_offsetAngle = offsetAngle.rad,
+
+        .m_structureFactorReF0 = structureFactorReF0,
+        .m_structureFactorImF0 = structureFactorImF0,
+        .m_structureFactorReFH = structureFactorReFH,
+        .m_structureFactorImFH = structureFactorImFH,
+        .m_structureFactorReFHC = structureFactorReFHC,
+        .m_structureFactorImFHC = structureFactorImFHC,
+    });
+}
+
+
 Behaviour makeGrating(const DesignElement& dele) {
     auto vls = dele.getVLSParameters();
     return serializeGrating({