hz-b · fannyzotter · Oct 22, 2025 · Oct 28, 2025
diff --git a/Data/CROMER/AC.f12 b/Data/CROMER/AC.f12
diff --git a/Data/CROMER/AG.f12 b/Data/CROMER/AG.f12
diff --git a/Data/CROMER/AL.f12 b/Data/CROMER/AL.f12
diff --git a/Data/CROMER/AR.f12 b/Data/CROMER/AR.f12
diff --git a/Data/CROMER/AS.f12 b/Data/CROMER/AS.f12
diff --git a/Data/CROMER/AT.f12 b/Data/CROMER/AT.f12
diff --git a/Data/CROMER/AU.f12 b/Data/CROMER/AU.f12
diff --git a/Data/CROMER/B.f12 b/Data/CROMER/B.f12
diff --git a/Data/CROMER/BA.f12 b/Data/CROMER/BA.f12
diff --git a/Data/CROMER/BE.f12 b/Data/CROMER/BE.f12
diff --git a/Data/CROMER/BI.f12 b/Data/CROMER/BI.f12
diff --git a/Data/CROMER/BR.f12 b/Data/CROMER/BR.f12
diff --git a/Data/CROMER/C.f12 b/Data/CROMER/C.f12
diff --git a/Data/CROMER/CA.f12 b/Data/CROMER/CA.f12
diff --git a/Data/CROMER/CD.f12 b/Data/CROMER/CD.f12
diff --git a/Data/CROMER/CE.f12 b/Data/CROMER/CE.f12
diff --git a/Data/CROMER/CL.f12 b/Data/CROMER/CL.f12
diff --git a/Data/CROMER/CO.f12 b/Data/CROMER/CO.f12
diff --git a/Data/CROMER/CR.f12 b/Data/CROMER/CR.f12
diff --git a/Data/CROMER/CS.f12 b/Data/CROMER/CS.f12
diff --git a/Data/CROMER/CU.f12 b/Data/CROMER/CU.f12
diff --git a/Data/CROMER/F.f12 b/Data/CROMER/F.f12
diff --git a/Data/CROMER/FE.f12 b/Data/CROMER/FE.f12
diff --git a/Data/CROMER/FR.f12 b/Data/CROMER/FR.f12
diff --git a/Data/CROMER/GA.f12 b/Data/CROMER/GA.f12
diff --git a/Data/CROMER/GE.f12 b/Data/CROMER/GE.f12
diff --git a/Data/CROMER/HG.f12 b/Data/CROMER/HG.f12
diff --git a/Data/CROMER/I.f12 b/Data/CROMER/I.f12
diff --git a/Data/CROMER/IN.f12 b/Data/CROMER/IN.f12
diff --git a/Data/CROMER/IR.f12 b/Data/CROMER/IR.f12
diff --git a/Data/CROMER/K.f12 b/Data/CROMER/K.f12
diff --git a/Data/CROMER/KR.f12 b/Data/CROMER/KR.f12
diff --git a/Data/CROMER/LA.f12 b/Data/CROMER/LA.f12
diff --git a/Data/CROMER/LI.f12 b/Data/CROMER/LI.f12
diff --git a/Data/CROMER/MG.f12 b/Data/CROMER/MG.f12
diff --git a/Data/CROMER/MN.f12 b/Data/CROMER/MN.f12
diff --git a/Data/CROMER/MO.f12 b/Data/CROMER/MO.f12
diff --git a/Data/CROMER/NA.f12 b/Data/CROMER/NA.f12
diff --git a/Data/CROMER/NB.f12 b/Data/CROMER/NB.f12
diff --git a/Data/CROMER/NE.f12 b/Data/CROMER/NE.f12
diff --git a/Data/CROMER/NI.f12 b/Data/CROMER/NI.f12
diff --git a/Data/CROMER/NP.f12 b/Data/CROMER/NP.f12
diff --git a/Data/CROMER/O.f12 b/Data/CROMER/O.f12
diff --git a/Data/CROMER/OS.f12 b/Data/CROMER/OS.f12
diff --git a/Data/CROMER/P.f12 b/Data/CROMER/P.f12
diff --git a/Data/CROMER/PA.f12 b/Data/CROMER/PA.f12
diff --git a/Data/CROMER/PB.f12 b/Data/CROMER/PB.f12
diff --git a/Data/CROMER/PD.f12 b/Data/CROMER/PD.f12
diff --git a/Data/CROMER/PO.f12 b/Data/CROMER/PO.f12
diff --git a/Data/CROMER/PT.f12 b/Data/CROMER/PT.f12
diff --git a/Data/CROMER/PU.f12 b/Data/CROMER/PU.f12
diff --git a/Data/CROMER/RA.f12 b/Data/CROMER/RA.f12
diff --git a/Data/CROMER/RB.f12 b/Data/CROMER/RB.f12
diff --git a/Data/CROMER/RE.f12 b/Data/CROMER/RE.f12
diff --git a/Data/CROMER/RH.f12 b/Data/CROMER/RH.f12
diff --git a/Data/CROMER/RN.f12 b/Data/CROMER/RN.f12
diff --git a/Data/CROMER/RU.f12 b/Data/CROMER/RU.f12
diff --git a/Data/CROMER/S.f12 b/Data/CROMER/S.f12
diff --git a/Data/CROMER/SB.f12 b/Data/CROMER/SB.f12
diff --git a/Data/CROMER/SC.f12 b/Data/CROMER/SC.f12
diff --git a/Data/CROMER/SE.f12 b/Data/CROMER/SE.f12
diff --git a/Data/CROMER/SI.f12 b/Data/CROMER/SI.f12
diff --git a/Data/CROMER/SN.f12 b/Data/CROMER/SN.f12
diff --git a/Data/CROMER/SR.f12 b/Data/CROMER/SR.f12
diff --git a/Data/CROMER/TC.f12 b/Data/CROMER/TC.f12
diff --git a/Data/CROMER/TE.f12 b/Data/CROMER/TE.f12
diff --git a/Data/CROMER/TH.f12 b/Data/CROMER/TH.f12
diff --git a/Data/CROMER/TI.f12 b/Data/CROMER/TI.f12
diff --git a/Data/CROMER/TL.f12 b/Data/CROMER/TL.f12
diff --git a/Data/CROMER/U.f12 b/Data/CROMER/U.f12
diff --git a/Data/CROMER/V.f12 b/Data/CROMER/V.f12
diff --git a/Data/CROMER/W.f12 b/Data/CROMER/W.f12
diff --git a/Data/CROMER/XE.f12 b/Data/CROMER/XE.f12
diff --git a/Data/CROMER/Y.f12 b/Data/CROMER/Y.f12
diff --git a/Data/CROMER/ZN.f12 b/Data/CROMER/ZN.f12
diff --git a/Data/CROMER/ZR.f12 b/Data/CROMER/ZR.f12
diff --git a/Intern/rayx-core/src/Material/CromerTable.cpp b/Intern/rayx-core/src/Material/CromerTable.cpp
@@ -0,0 +1,53 @@
+#include "CromerTable.h"
+
+#include <algorithm>
+#include <fstream>
+
+#include "Debug/Debug.h"
+#include "Rml/Locate.h"
+
+namespace RAYX {
+
+bool CromerTable::load(const char* element, CromerTable* out) {
+    std::string elementString = element;
+    std::transform(elementString.begin(), elementString.end(), elementString.begin(), [](unsigned char c) { return std::toupper(c); });
+
+    std::filesystem::path f = ResourceHandler::getInstance().getResourcePath(std::filesystem::path("Data") / "CROMER" / (elementString + ".f12"));
+    RAYX_VERB << "Loading CromerTable from " << f;
+    std::ifstream s(f);
+
+    if (s.fail()) {
+        return false;
+    }
+
+    std::string line;
+
+    // ignore first three lines
+    for (int i = 0; i < 3; i++) {
+        std::getline(s, line);
+    }
+
+    // line 4..EOF
+    for (uint32_t lineidx = 4; std::getline(s, line); lineidx++) {
+        if (line.empty()) {
+            continue;
+        }
+
+        CromerEntry e{};
+#if defined(WIN32)
+        if (sscanf_s(line.c_str(), "%le %le %le", &e.m_energy, &e.m_n, &e.m_k) != 3) {
+#else
+        if (sscanf(line.c_str(), "%le %le %le", &e.m_energy, &e.m_n, &e.m_k) != 3) {
+#endif
+            RAYX_WARN << "Failed to parse CromerTable \"" << element << "\", at line " << lineidx << ": \"" << line << "\"";
+            return false;
+        }
+        out->m_Lines.push_back(e);
+    }
+
+    out->m_element = element;
+
+    return true;
+}
+
+}  // namespace RAYX
diff --git a/Intern/rayx-core/src/Material/CromerTable.h b/Intern/rayx-core/src/Material/CromerTable.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+// This file defines the CromerEntry.
+#include "../Shader/RefractiveIndex.h"
+
+namespace RAYX {
+/** This struct represents the contents of a .f12 file.
+ *
+ * Example usage:
+ *
+ * CromerTable cu;
+ * bool success = CromerTable::load("CU", &cu); // the cromer table for copper!
+ *
+ */
+struct CromerTable {
+    std::string m_element;
+    std::vector<CromerEntry> m_Lines;
+
+    /** loads the .NKP file of the element `element` and writes it's contents to
+     * `out` */
+    static bool load(const char* element, CromerTable* out);
+
+    // double interpolate(double x) const;
+};
+
+}  // namespace RAYX
diff --git a/Intern/rayx-core/src/Material/Material.cpp b/Intern/rayx-core/src/Material/Material.cpp
@@ -9,6 +9,7 @@
 #include "Debug/Debug.h"
 #include "NffTable.h"
 #include "PalikTable.h"
+#include "CromerTable.h"
 
 namespace RAYX {
 
@@ -98,6 +99,24 @@ MaterialTables loadMaterialTables(std::array<bool, 92> relevantMaterials) {
         }
     }
 
+    // add cromer table content
+    for (size_t i = 0; i < mats.size(); i++) {
+        out.indices.push_back(out.materials.size());
+        if (relevantMaterials[i]) {
+            CromerTable t;
+
+            if (!CromerTable::load(getMaterialName(mats[i]), &t)) {
+                RAYX_EXIT << "could not load CromerTable!";
+            }
+
+            for (auto x : t.m_Lines) {
+                out.materials.push_back(x.m_energy);
+                out.materials.push_back(x.m_n);
+                out.materials.push_back(x.m_k);
+            }
+        }
+    }
+
     // this extra index simplifies computation on the GPU, as then the table
     // within indices[i]..indices[i+1] can be used without checks.
     out.indices.push_back(out.materials.size());

diff --git a/Intern/rayx-core/src/Material/Material.h b/Intern/rayx-core/src/Material/Material.h
@@ -35,7 +35,7 @@ struct RAYX_API MaterialTables {
     std::vector<int> indices;
 };
 
-// the following function loads the Palik & Nff tables.
+// 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);
 

diff --git a/Intern/rayx-core/src/Shader/RefractiveIndex.cpp b/Intern/rayx-core/src/Shader/RefractiveIndex.cpp
@@ -41,6 +41,16 @@ int RAYX_API getNffEntryCount(const int material, const int* materialIndices) {
     // the offset of 92 (== 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;
+
+}
+
+/// The number of cromer entries we currently store for this material.
+RAYX_FN_ACC
+int RAYX_API getCromerEntryCount(const int material, const int* materialIndices) {
+    int m = material - 1;  // in [0, 91]
+    // the offset of 184 (== number of materials * 2), skips the palik table and
+    // reaches into the cromer table. the rest of the logic is as above.
+    return (materialIndices[184 + m + 1] - materialIndices[184 + m]) / 3;
 }
 
 // Indexes into the palik table of a particular material at a given index.
@@ -74,6 +84,21 @@ NffEntry RAYX_API getNffEntry(int index, int material, const int* __restrict mat
     return e;
 }
 
+RAYX_FN_ACC
+CromerEntry RAYX_API getCromerEntry(int index, int material, const int* __restrict materialIndices, const double* __restrict materialTable) {
+    int m = material - 1;  // in [0, 91]
+    // materialIndices[184+m] is the start of the Cromer table of material m.
+    // 3*index skips 'index'-many entries.
+    int i = materialIndices[184 + m] + 3 * index;
+
+    CromerEntry e;
+    e.m_energy = materialTable[i];
+    e.m_n = materialTable[i + 1];
+    e.m_k = materialTable[i + 2];
+
+    return e;
+}
+
 // returns dvec2 to represent a complex number
 RAYX_FN_ACC
 complex::Complex RAYX_API getRefractiveIndex(double energy, int material, const int* __restrict materialIndices,
@@ -88,6 +113,35 @@ complex::Complex RAYX_API getRefractiveIndex(double energy, int material, const
         return complex::Complex(-1.0, -1.0);
     }
 
+        // get refractive index with Nff table
+    if (getNffEntryCount(material, materialIndices) > 0) {           // don't try binary search if there are 0 entries!
+        int low = 0;                                                 // <= energy
+        int high = getNffEntryCount(material, materialIndices) - 1;  // >= energy
+
+        // binary search
+        while (high - low > 1) {
+            int center = (low + high) / 2;
+            NffEntry center_entry = getNffEntry(center, material, materialIndices, materialTable);
+            if (energy < center_entry.m_energy) {
+                high = center;
+            } else {
+                low = center;
+            }
+        }
+
+        // compute n, k from the Nff data.
+        glm::dvec2 massAndRho = getAtomicMassAndRho(material);
+        double mass = massAndRho.x;
+        double rho = massAndRho.y;
+
+        NffEntry entry = getNffEntry(low, material, materialIndices, materialTable);
+        double e = entry.m_energy;
+        double n = 1 - (415.252 * rho * entry.m_f1) / (e * e * mass);
+        double k = (415.252 * rho * entry.m_f2) / (e * e * mass);
+
+        return complex::Complex(n, k);
+    }
+
     // try to get refractive index using Palik table
     if (getPalikEntryCount(material, materialIndices) > 0) {           // don't try binary search if there are 0 entries!
         int low = 0;                                                   // <= energy
@@ -113,33 +167,25 @@ complex::Complex RAYX_API getRefractiveIndex(double energy, int material, const
         }
     }
 
-    // get refractive index with Nff table
-    if (getNffEntryCount(material, materialIndices) > 0) {           // don't try binary search if there are 0 entries!
+
+    // get refractive index with Cromer table
+    if (getCromerEntryCount(material, materialIndices) > 0) {           // don't try binary search if there are 0 entries!
         int low = 0;                                                 // <= energy
-        int high = getNffEntryCount(material, materialIndices) - 1;  // >= energy
+        int high = getCromerEntryCount(material, materialIndices) - 1;  // >= energy
 
         // binary search
         while (high - low > 1) {
             int center = (low + high) / 2;
-            NffEntry center_entry = getNffEntry(center, material, materialIndices, materialTable);
+            CromerEntry center_entry = getCromerEntry(center, material, materialIndices, materialTable);
             if (energy < center_entry.m_energy) {
                 high = center;
             } else {
                 low = center;
             }
         }
 
-        // compute n, k from the Nff data.
-        glm::dvec2 massAndRho = getAtomicMassAndRho(material);
-        double mass = massAndRho.x;
-        double rho = massAndRho.y;
-
-        NffEntry entry = getNffEntry(low, material, materialIndices, materialTable);
-        double e = entry.m_energy;
-        double n = 1 - (415.252 * rho * entry.m_f1) / (e * e * mass);
-        double k = (415.252 * rho * entry.m_f2) / (e * e * mass);
-
-        return complex::Complex(n, k);
+        CromerEntry entry = getCromerEntry(low, material, materialIndices, materialTable);
+        return complex::Complex(entry.m_n, entry.m_k);
     }
 
     _throw("getRefractiveIndex: no matching entry found!");

diff --git a/Intern/rayx-core/src/Shader/RefractiveIndex.h b/Intern/rayx-core/src/Shader/RefractiveIndex.h
@@ -25,14 +25,25 @@ struct NffEntry {
     double m_f2;
 };
 
+/// This struct represents one line of a .f12 file from the cromer materialtables.
+struct CromerEntry {
+    double m_energy;
+    double m_n;
+    double m_k;
+};
+
 RAYX_FN_ACC int RAYX_API getPalikEntryCount(int material, const int* materialIndices);
 
 RAYX_FN_ACC int RAYX_API getNffEntryCount(int material, const int* materialIndices);
 
+RAYX_FN_ACC int RAYX_API getCromerEntryCount(int material, const int* materialIndices);
+
 RAYX_FN_ACC PalikEntry RAYX_API getPalikEntry(int index, int material, const int* materialIndices, const double* materialTable);
 
 RAYX_FN_ACC NffEntry RAYX_API getNffEntry(int index, int material, const int* materialIndices, const double* materialTable);
 
+RAYX_FN_ACC CromerEntry RAYX_API getCromerEntry(int index, int material, const int* materialIndices, const double* materialTable);
+
 // returns dvec2 to represent a complex number
 RAYX_FN_ACC complex::Complex RAYX_API getRefractiveIndex(double energy, int material, const int* materialIndices, const double* materialTable);
 

diff --git a/Intern/rayx-core/tests/testShader.cpp b/Intern/rayx-core/tests/testShader.cpp
@@ -1291,6 +1291,33 @@ TEST_F(TestSuite, testNff) {
     CHECK_EQ(Au10.m_f2, 2.67227);
 }
 
+// test cromer tables 
+TEST_F(TestSuite, testCromer) {
+    auto mat = createMaterialTables({Material::Cu, Material::Au});
+
+    int Cu = static_cast<int>(Material::Cu);
+    CHECK_EQ(getCromerEntryCount(Cu, mat.indices.data()), 450);
+
+    auto Cu0 = getCromerEntry(0, Cu, mat.indices.data(), mat.materials.data());
+    CHECK_EQ(Cu0.m_n, 28.455647403258698);
+    CHECK_EQ(Cu0.m_k, 1.3255343263698971);
+
+    auto Cu10 = getCromerEntry(10, Cu, mat.indices.data(), mat.materials.data());
+    CHECK_EQ(Cu10.m_n, 28.125870077993461);
+    CHECK_EQ(Cu10.m_k, 0.96636626222754107);
+
+    int Au = static_cast<int>(Material::Au);
+    CHECK_EQ(getCromerEntryCount(Au, mat.indices.data()), 450);
+
+    auto Au0 = getCromerEntry(0, Au, mat.indices.data(), mat.materials.data());
+    CHECK_EQ(Au0.m_n, 75.80310173166059);
+    CHECK_EQ(Au0.m_k, 14.68569867739777);
+
+    auto Au10 = getCromerEntry(10, Au, mat.indices.data(), mat.materials.data());
+    CHECK_EQ(Au10.m_n, 76.187030489298166);
+    CHECK_EQ(Au10.m_k, 11.20875960827477);
+}
+
 TEST_F(TestSuite, testRefractiveIndex) {
     auto mat = createMaterialTables({Material::Cu, Material::Au});