Material

Author: fannyzotter

Intern/rayx-core/CMakeLists.txt

@@ -256,6 +256,10 @@ install(DIRECTORY ${CMAKE_SOURCE_DIR}/Data/nff
         DESTINATION ${INSTALL_DATA_DIR}/Data)
 install(DIRECTORY ${CMAKE_SOURCE_DIR}/Data/PALIK
         DESTINATION ${INSTALL_DATA_DIR}/Data)
+install(DIRECTORY ${CMAKE_SOURCE_DIR}/Data/CROMER
+        DESTINATION ${INSTALL_DATA_DIR}/Data)
+install(DIRECTORY ${CMAKE_SOURCE_DIR}/Data/MOLEC
+        DESTINATION ${INSTALL_DATA_DIR}/Data)
 install(DIRECTORY ${CMAKE_SOURCE_DIR}/Scripts
         DESTINATION ${INSTALL_DATA_DIR})
 include(InstallRequiredSystemLibraries)

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

@@ -81,11 +81,25 @@ void Group::addChild(std::unique_ptr<BeamlineNode> child) {
 
 MaterialTables Group::calcMinimalMaterialTables() const {
     auto elements = getElements();
-    std::array<bool, 92> relevantMaterials{};
+    std::array<bool, 99> relevantMaterials{};
     relevantMaterials.fill(false);
     for (const auto& elemPtr : elements) {
+        auto coating = elemPtr->getCoating();
+        if (coating.is<Coating::OneCoating>()) {
+            int materialcoating = static_cast<int>(elemPtr->getMaterialCoating());
+            if (materialcoating >= 1 && materialcoating <= 99) {
+                relevantMaterials[materialcoating - 1] = true;
+            }
+        } else if (coating.is<Coating::MultilayerCoating>()) {
+            auto mlCoating = variant::get<Coating::MultilayerCoating>(coating.m_coating);
+            for (const auto& mat : mlCoating.material) {
+                if (mat >= 1 && mat <= 99) {
+                    relevantMaterials[mat - 1] = true;
+                }
+            }
+        }
         int material = static_cast<int>(elemPtr->getMaterial());  // assuming getMaterial() exists
-        if (material >= 1 && material <= 92) {
+        if (material >= 1 && material <= 99) {
             relevantMaterials[material - 1] = true;
         }
     }

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

@@ -55,11 +55,11 @@ bool materialFromString(const char* matname, Material* out) {
     return false;
 }
 
-MaterialTables loadMaterialTables(std::array<bool, 92> relevantMaterials) {
+MaterialTables loadMaterialTables(std::array<bool, 99> relevantMaterials) {
     MaterialTables out;
 
     auto mats = allNormalMaterials();
-    if (mats.size() != 92) {
+    if (mats.size() != 99) {
         RAYX_EXIT << "unexpected number of materials. this is a bug.";
     }
 
@@ -106,7 +106,8 @@ MaterialTables loadMaterialTables(std::array<bool, 92> relevantMaterials) {
             CromerTable t;
 
             if (!CromerTable::load(getMaterialName(mats[i]), &t)) {
-                RAYX_EXIT << "could not load CromerTable!";
+                RAYX_VERB << "could not load CromerTable!";
+                continue;
             }
 
             for (auto x : t.m_Lines) {

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

@@ -37,6 +37,6 @@ struct RAYX_API MaterialTables {
 
 // the following function loads the Palik, Nff, and Cromer tables.
 // the tables will later be written to the mat and matIdx buffers of shader.comp
-MaterialTables RAYX_API loadMaterialTables(std::array<bool, 92> relevantMaterials);
+MaterialTables RAYX_API loadMaterialTables(std::array<bool, 99> relevantMaterials);
 
 }  // namespace RAYX

Intern/rayx-core/src/Material/materials.xmacro

@@ -95,3 +95,17 @@ X(Ac, 89, 227.0278, 10.05)
 X(Th, 90, 232.0381, 11.70)
 X(Pa, 91, 231.0359, 15.34)
 X(U, 92, 238.0289, 18.92)
+// Pseudo-Element für Al2O3
+X(AL2O3, 93, 101.96, 3.97)
+// Pseudo-Element für B4C
+X(B4C, 94, 55.25, 2.52)
+// Pseudo-Element für Diamant
+X(DIAMOND, 95, 12.011, 3.51)
+//weitere elemente aus molec
+X(MgF2, 96, 62.304, 3.15)
+// Pseudo-Element für Si8O26Al4Li2P (Glas/Glaskeramik)
+X(Si8O26Al4Li2P, 97, 793.44, 2.40)
+// Pseudo-Element für SiC
+X(SiC, 98, 40.10, 3.21)
+// Pseudo-Element für SiO2 (Quarz)
+X(SiO2, 99, 60.08, 2.65)

Intern/rayx-core/src/Rml/xml.cpp

@@ -299,6 +299,22 @@ bool paramVls(const rapidxml::xml_node<>* node, std::array<double, 6>* out) {
     return true;
 }
 
+
+double Parser::parseThicknessCoating() const { 
+    if(!xml::paramDouble(node, "thicknessCoating", nullptr)) {
+        return Parser::parseDouble("thicknessCoating1"); 
+    }
+    return Parser::parseDouble("thicknessCoating"); 
+}
+
+double Parser::parseRoughnessCoating() const { 
+    if(!xml::paramDouble(node, "roughnessCoating", nullptr)) {
+        return Parser::parseDouble("roughnessCoating1"); 
+    }
+    return Parser::parseDouble("roughnessCoating"); 
+}
+
+
 bool paramRAYUICoating(const rapidxml::xml_node<>* node, Coating::MultilayerCoating* out) {
     if (!node || !out) { return false; }
 
@@ -334,10 +350,10 @@ bool paramRAYUICoating(const rapidxml::xml_node<>* node, Coating::MultilayerCoat
         }
     }
 
-    const char* materialStr = nullptr;
-    if (paramStr(node, "materialTopLayer", &materialStr)) {
+    const char* materialTopLayer = nullptr;
+    if (!paramStr(node, "materialTopLayer", &materialTopLayer)) {
         Material material;
-        materialFromString(materialStr, &material);
+        materialFromString(materialTopLayer, &material);
         out->material[numberLayer] = static_cast<int>(material);
 
         if (!paramDouble(node, "thicknessTopLayer", &out->thickness[numberLayer])) {
@@ -351,6 +367,7 @@ bool paramRAYUICoating(const rapidxml::xml_node<>* node, Coating::MultilayerCoat
         }
         out->numLayers += 1;
     }
+    return true;
 }
 
 // multilayer coating

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

@@ -114,6 +114,8 @@ struct RAYX_API Parser {
     Rad parseAzimuthalAngle() const;
     std::filesystem::path parseEnergyDistributionFile() const;
     Coating::MultilayerCoating parseCoating() const;
+    double parseThicknessCoating() const;
+    double parseRoughnessCoating() const;
 
     // Parsers for trivial derived parameters
     // this allows for convenient type-safe access to the corresponding parameters.
@@ -223,9 +225,9 @@ struct RAYX_API Parser {
         if (parseInt("surfaceCoating") == 3) {
             return SurfaceCoatingType::MultipleCoatings;
         }
-        return static_cast<SurfaceCoatingType>(parseInt("surfaceCoating"));}  // 0 = substrate only, 1 = one coating, 2 = multiple coatings
-    inline double parseThicknessCoating() const { return parseDouble("thicknessCoating"); }
-    inline double parseRoughnessCoating() const { return parseDouble("roughnessCoating"); }
+        return static_cast<SurfaceCoatingType>(parseInt("surfaceCoating"));
+    }  // 0 = substrate only, 1 = one coating, 2 = multiple coatings
+    
 
     // the XML node of the object you intend to parse.
     rapidxml::xml_node<>* node;

Intern/rayx-core/src/Shader/RefractiveIndex.cpp

@@ -8,13 +8,13 @@ namespace RAYX {
 // Thus, when you want to get some concrete palik entry for a particular element, you need the materialIndices table to "know where to look" in
 // materialTable:
 // * materialIndices[i] is the beginning of the Palik Table in materialTable for the element with atomic number i+1, for i in [0, 91].
-// * materialIndices[i+92] is the beginning of the Nff Table in materialTable for the element with atomic number i+1, for i in [0, 91].
+// * materialIndices[i+99] is the beginning of the Nff Table in materialTable for the element with atomic number i+1, for i in [0, 91].
 // The `i+1` is necessary as atomic numbers start at 1 (Hydrogen), while array indices start at 0.
 // See InvocationState.cpp for more information about these tables.
 
-// If you will, the materialTable table is a "sparse" 4d-datastructure of shape (2, 92, N, 3).
+// If you will, the materialTable table is a "sparse" 4d-datastructure of shape (2, 99, N, 3).
 // - 2 because we store a Palik-table, and an Nff-table
-// - 92, because we support 92 elements of the periodic table (from Hydrogen to Uranium)
+// - 99, because we support 99 elements of the periodic table (from Hydrogen to Uranium)
 // - N is the number of entries in a given Palik/Nff table (this number depends on the periodic element)
 // - 3 because each Palik / Nff entry consists of three doubles.
 // - It is a "sparse" data structure as most of the entries are actually missing, we only load the actually "used" materials into the shader, not all
@@ -38,9 +38,9 @@ int RAYX_API getPalikEntryCount(const int material, const int* materialIndices)
 RAYX_FN_ACC
 int RAYX_API getNffEntryCount(const int material, const int* materialIndices) {
     int m = material - 1;  // in [0, 91]
-    // the offset of 92 (== number of materials), skips the palik table and
+    // the offset of 99 (== number of materials), skips the palik table and
     // reaches into the nff table. the rest of the logic is as above.
-    return (materialIndices[92 + m + 1] - materialIndices[92 + m]) / 3;
+    return (materialIndices[99 + m + 1] - materialIndices[99 + m]) / 3;
 
 }
 
@@ -72,9 +72,9 @@ PalikEntry RAYX_API getPalikEntry(int index, int material, const int* __restrict
 RAYX_FN_ACC
 NffEntry RAYX_API getNffEntry(int index, int material, const int* __restrict materialIndices, const double* __restrict materialTable) {
     int m = material - 1;  // in [0, 91]
-    // materialIndices[92+m] is the start of the Nff table of material m.
+    // materialIndices[99+m] is the start of the Nff table of material m.
     // 3*index skips 'index'-many entries.
-    int i = materialIndices[92 + m] + 3 * index;
+    int i = materialIndices[99 + m] + 3 * index;
 
     NffEntry e;
     e.m_energy = materialTable[i];
@@ -108,7 +108,7 @@ complex::Complex RAYX_API getRefractiveIndex(double energy, int material, const
     }
 
     // out of range check
-    if (material < 1 || material > 92) {
+    if (material < 1 || material > 99) {
         _throw("getRefractiveIndex material out of range!");
         return complex::Complex(-1.0, -1.0);
     }

Intern/rayx-core/tests/setupTests.cpp

@@ -257,7 +257,7 @@ void compareAgainstCorrect(std::string filename, double tolerance) {
 }
 
 MaterialTables createMaterialTables(std::vector<Material> mats_vec) {
-    std::array<bool, 92> mats;
+    std::array<bool, 99> mats;
     mats.fill(false);
     for (auto m : mats_vec) {
         mats[static_cast<int>(m) - 1] = true;