DynaRef 6.1.2__tar.gz → 6.2.0__tar.gz

{dynaref-6.1.2/src/DynaRef.egg-info → dynaref-6.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DynaRef
-Version: 6.1.2
+Version: 6.2.0
 Summary: Dyna: X-ray magnetic reflectivity simulation
 Author-email: Stephane Grenier <stephane.grenier@neel.cnrs.fr>
 License-Expression: GPL-2.0-or-later
@@ -80,6 +80,40 @@ cd Dyna
 pip install -e .
 dyna
 
+### Python API
+
+Dyna calculations can run without starting the Qt interface:
+
+```python
+from dyna import Experiment, Formalism, run_reflectivity
+from dyna.Samples.Samples import SampleIni
+
+experiment = Experiment()
+experiment.Formalism = Formalism.STEPANOV_ANGLE
+experiment.Angle = [0.1, 5.0, 0.01, 0.0]
+experiment.Energy[0] = 700.0
+
+result = run_reflectivity(SampleIni(), experiment)
+print(result.x, result.intensity)
+```
+
+For reproducible batch calculations, use a JSON configuration such as
+`examples/stepanov-angle.json`:
+
+```console
+dyna-sim examples/stepanov-angle.json --output reflectivity.csv
+dyna-sim examples/stepanov-angle.json --output reflectivity.npz
+```
+
+The same file can be used directly from Python:
+
+```python
+from dyna import load_config
+
+result = load_config("examples/stepanov-angle.json").run()
+result.save("reflectivity.csv")
+```
+
 ### Features
 
 * magnetic-sensitive susceptibility, arbitrary magnetic moment direction described by Euler angles, with the limitation of neglictible spin-orbit coupling in the valence states

{dynaref-6.1.2 → dynaref-6.2.0}/README.md

@@ -56,6 +56,40 @@ cd Dyna
 pip install -e .
 dyna
 
+### Python API
+
+Dyna calculations can run without starting the Qt interface:
+
+```python
+from dyna import Experiment, Formalism, run_reflectivity
+from dyna.Samples.Samples import SampleIni
+
+experiment = Experiment()
+experiment.Formalism = Formalism.STEPANOV_ANGLE
+experiment.Angle = [0.1, 5.0, 0.01, 0.0]
+experiment.Energy[0] = 700.0
+
+result = run_reflectivity(SampleIni(), experiment)
+print(result.x, result.intensity)
+```
+
+For reproducible batch calculations, use a JSON configuration such as
+`examples/stepanov-angle.json`:
+
+```console
+dyna-sim examples/stepanov-angle.json --output reflectivity.csv
+dyna-sim examples/stepanov-angle.json --output reflectivity.npz
+```
+
+The same file can be used directly from Python:
+
+```python
+from dyna import load_config
+
+result = load_config("examples/stepanov-angle.json").run()
+result.save("reflectivity.csv")
+```
+
 ### Features
 
 * magnetic-sensitive susceptibility, arbitrary magnetic moment direction described by Euler angles, with the limitation of neglictible spin-orbit coupling in the valence states

{dynaref-6.1.2 → dynaref-6.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "DynaRef"
-version = "6.1.2"
+version = "6.2.0"
 description = "Dyna: X-ray magnetic reflectivity simulation"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -28,6 +28,7 @@ Changelog     = "https://gitlab.com/dynadevgroup/Dyna/-/blob/main/CHANGELOG.rst"
 
 [project.scripts]
 dyna = "dyna.__main__:main"
+dyna-sim = "dyna.cli:main"
 
 #[tool.setuptools]
 #package-dir         = {"" = "src"}

{dynaref-6.1.2 → dynaref-6.2.0/src/DynaRef.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: DynaRef
-Version: 6.1.2
+Version: 6.2.0
 Summary: Dyna: X-ray magnetic reflectivity simulation
 Author-email: Stephane Grenier <stephane.grenier@neel.cnrs.fr>
 License-Expression: GPL-2.0-or-later
@@ -80,6 +80,40 @@ cd Dyna
 pip install -e .
 dyna
 
+### Python API
+
+Dyna calculations can run without starting the Qt interface:
+
+```python
+from dyna import Experiment, Formalism, run_reflectivity
+from dyna.Samples.Samples import SampleIni
+
+experiment = Experiment()
+experiment.Formalism = Formalism.STEPANOV_ANGLE
+experiment.Angle = [0.1, 5.0, 0.01, 0.0]
+experiment.Energy[0] = 700.0
+
+result = run_reflectivity(SampleIni(), experiment)
+print(result.x, result.intensity)
+```
+
+For reproducible batch calculations, use a JSON configuration such as
+`examples/stepanov-angle.json`:
+
+```console
+dyna-sim examples/stepanov-angle.json --output reflectivity.csv
+dyna-sim examples/stepanov-angle.json --output reflectivity.npz
+```
+
+The same file can be used directly from Python:
+
+```python
+from dyna import load_config
+
+result = load_config("examples/stepanov-angle.json").run()
+result.save("reflectivity.csv")
+```
+
 ### Features
 
 * magnetic-sensitive susceptibility, arbitrary magnetic moment direction described by Euler angles, with the limitation of neglictible spin-orbit coupling in the valence states

{dynaref-6.1.2 → dynaref-6.2.0}/src/DynaRef.egg-info/SOURCES.txt

@@ -13,8 +13,11 @@ src/dyna/ExperimentClass.py
 src/dyna/LayerClass.py
 src/dyna/__init__.py
 src/dyna/__main__.py
+src/dyna/cli.py
 src/dyna/config.py
+src/dyna/configuration.py
 src/dyna/constants.py
+src/dyna/simulation.py
 src/dyna/Samples/Samples.py
 src/dyna/Samples/__init__.py
 src/dyna/Samples/test_yaml_import.py
@@ -26,7 +29,12 @@ src/dyna/functions/Roughness.py
 src/dyna/functions/SFFunctions.py
 src/dyna/functions/XrayFunc.py
 src/dyna/functions/__init__.py
+src/dyna/functions/dielectric.py
+src/dyna/functions/magneto_optics.py
+src/dyna/functions/physics.py
+src/dyna/functions/stepanov.py
 src/dyna/functions/test.py
+src/dyna/functions/transfer_matrix.py
 src/dyna/gui/Dyna.ui
 src/dyna/gui/DynaGUIClass.py
 src/dyna/gui/DynaGUIMessages.py
@@ -1150,9 +1158,14 @@ src/dyna/resources/Tables/note/Zr.txt
 src/dyna/resources/Tables/note/filename.note
 src/dyna/resources/Tables/note/layer.txt
 src/dyna/resources/Tables/note/tmp.note
+tests/test_ConfigurationCLI.py
 tests/test_DynaGraphTabs.py
 tests/test_ElzoRef_vs_StepanovRef.py
+tests/test_FaradayLiteratureBenchmark.py
+tests/test_HeadlessSimulationAPI.py
+tests/test_KerrLiteratureBenchmark.py
 tests/test_OptimisationLoadData.py
+tests/test_PhysicsModuleAPI.py
 tests/test_layerManager.py
 tests/test_optimization_no_data.py
 tests/test_simBox.py

{dynaref-6.1.2 → dynaref-6.2.0}/src/DynaRef.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 dyna = dyna.__main__:main
+dyna-sim = dyna.cli:main

{dynaref-6.1.2 → dynaref-6.2.0}/src/dyna/ExperimentClass.py

@@ -19,7 +19,7 @@ ExperimentClass
 
 """
 import numpy as np
-from dyna.functions.Functions import F0, F0F1Ref, StepanovRef
+from dyna.functions.physics import F0, F0F1Ref, StepanovRef
 
 # import scipy.constants as cst
 
@@ -176,7 +176,7 @@ class Experiment :
                 
 
         # IF FIX ENERGY SIMULATION "ASCAN"
-        if self.Formalism in (0,2): 
+        if self.Formalism in (0, 2, 4):
         
             if not _OptimFlag :           
 
@@ -193,7 +193,7 @@ class Experiment :
 
 
         # IF FIX ANGLE SIMULATION "ESCAN"
-        if self.Formalism in (1,3): # Fix Angle
+        if self.Formalism in (1, 3, 5): # Fix Angle
                 
             if not _OptimFlag :  
                 
@@ -205,7 +205,7 @@ class Experiment :
 
 
         # IF FIX MAGNETIC SIMULATION, ADD REVERSED FIELD POLARIZATION TO ALLOCATION
-        if self.Formalism in (2,3): 
+        if self.Formalism in (2, 3, 4, 5):
 
             self.RefCalcPhi = np.zeros(len(self.XRange))
             self.TransCalcPhi = np.zeros(len(self.XRange))

{dynaref-6.1.2 → dynaref-6.2.0}/src/dyna/__init__.py

@@ -97,6 +97,37 @@ def doc_str():
     return __doc__
 
 
+from dyna.ExperimentClass import Experiment
+from dyna.simulation import (
+    Formalism,
+    ReflectivityResult,
+    build_scattering_factors,
+    run_reflectivity,
+    save_result,
+)
+from dyna.configuration import (
+    LayerConfig,
+    SampleConfig,
+    ScanRange,
+    SimulationConfig,
+    load_config,
+)
+
+__all__ = [
+    "Experiment",
+    "Formalism",
+    "LayerConfig",
+    "ReflectivityResult",
+    "SampleConfig",
+    "ScanRange",
+    "SimulationConfig",
+    "build_scattering_factors",
+    "load_config",
+    "run_reflectivity",
+    "save_result",
+]
+
+
 def main():
     # paste old start.py code here
     print("running simulation")

dynaref-6.2.0/src/dyna/cli.py

@@ -0,0 +1,54 @@
+"""Command-line interface for headless Dyna simulations."""
+
+import argparse
+from pathlib import Path
+import sys
+
+import numpy as np
+
+from dyna import __version__
+from dyna.configuration import load_config
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="dyna-sim",
+        description="Run a Dyna reflectivity simulation without the GUI.",
+    )
+    parser.add_argument("config", type=Path, help="JSON simulation configuration")
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        help="output path (.csv, .txt, or .npz); CSV is written to stdout by default",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    return parser
+
+
+def main(argv=None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        result = load_config(args.config).run()
+        if args.output is not None:
+            result.save(args.output)
+        else:
+            columns = ["x", "intensity"]
+            if result.reversed_intensity is not None:
+                columns.append("reversed_intensity")
+            np.savetxt(
+                sys.stdout,
+                result.to_table(),
+                delimiter=",",
+                header=",".join(columns),
+                comments="",
+            )
+    except (OSError, ValueError) as exc:
+        parser.exit(2, f"{parser.prog}: error: {exc}\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

dynaref-6.2.0/src/dyna/configuration.py

@@ -0,0 +1,247 @@
+"""Typed configuration and sample construction for headless simulations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+
+from dyna.ExperimentClass import Experiment
+from dyna.LayerClass import Layer
+from dyna.simulation import Formalism, ReflectivityResult, run_reflectivity
+
+
+_POLARIZATIONS = {
+    "unpolarized": 0,
+    "circ-plus": 1,
+    "circ-minus": 2,
+    "sigma": 3,
+    "pi": 4,
+}
+
+
+@dataclass(frozen=True)
+class LayerConfig:
+    """Scalar values describing one layer in a scriptable sample."""
+
+    material: str
+    multiplicity: int = 1
+    density: float = 0.0
+    thickness: float = 0.0
+    roughness: float = 0.0
+    mms: float = 0.0
+    phi: float = 0.0
+    gamma: float = 0.0
+
+    def __post_init__(self) -> None:
+        if not self.material.strip():
+            raise ValueError("layer material cannot be empty")
+        if self.multiplicity < 1:
+            raise ValueError("layer multiplicity must be at least 1")
+        if self.density < 0 or self.thickness < 0 or self.roughness < 0:
+            raise ValueError("layer density, thickness, and roughness must be non-negative")
+
+    @classmethod
+    def from_mapping(cls, values: Mapping[str, Any]) -> LayerConfig:
+        _reject_unknown(values, cls.__dataclass_fields__, "layer")
+        try:
+            return cls(**values)
+        except TypeError as exc:
+            raise ValueError(f"invalid layer configuration: {exc}") from exc
+
+    def to_layer(self) -> Layer:
+        """Create the legacy calculation layer used by the physics engine."""
+        layer = Layer()
+        layer.TakeValues([
+            self.material,
+            self.multiplicity,
+            _fixed(self.density),
+            _fixed(self.thickness),
+            _fixed(self.roughness),
+            _fixed(self.mms),
+            _fixed(self.phi),
+            _fixed(self.gamma),
+        ])
+        return layer
+
+
+@dataclass(frozen=True)
+class SampleConfig:
+    """Ordered sample definition from vacuum to substrate."""
+
+    layers: tuple[LayerConfig, ...]
+
+    def __post_init__(self) -> None:
+        if len(self.layers) < 2:
+            raise ValueError("sample must contain vacuum and at least one material layer")
+        if self.layers[0].material.casefold() != "vacuum":
+            raise ValueError("the first sample layer must be Vacuum")
+
+    @classmethod
+    def from_sequence(cls, values: Sequence[Mapping[str, Any]]) -> SampleConfig:
+        if isinstance(values, (str, bytes)):
+            raise ValueError("sample must be a list of layer objects")
+        return cls(tuple(LayerConfig.from_mapping(value) for value in values))
+
+    def to_layers(self) -> list[Layer]:
+        return [layer.to_layer() for layer in self.layers]
+
+
+@dataclass(frozen=True)
+class ScanRange:
+    """Inclusive scan range and optional experimental resolution."""
+
+    start: float
+    stop: float
+    step: float
+    resolution: float = 0.0
+
+    def __post_init__(self) -> None:
+        if self.stop < self.start:
+            raise ValueError("scan stop must be greater than or equal to start")
+        if self.step <= 0:
+            raise ValueError("scan step must be positive")
+        if self.resolution < 0:
+            raise ValueError("scan resolution must be non-negative")
+
+    @classmethod
+    def from_mapping(cls, values: Mapping[str, Any], name: str) -> ScanRange:
+        _reject_unknown(values, cls.__dataclass_fields__, name)
+        try:
+            return cls(**values)
+        except TypeError as exc:
+            raise ValueError(f"invalid {name} range: {exc}") from exc
+
+
+@dataclass(frozen=True)
+class SimulationConfig:
+    """Complete, GUI-independent Dyna simulation configuration."""
+
+    sample: SampleConfig
+    formalism: Formalism = Formalism.STEPANOV_ANGLE
+    angle: ScanRange = ScanRange(0.001, 2.0, 0.002)
+    energy: ScanRange = ScanRange(8047.0, 9000.0, 1.0)
+    incident_polarization: str = "sigma"
+    analyzed_polarization: str = "unpolarized"
+    sample_length: float = 100.0
+    beam_thickness: float = 1.0
+    normalization: float = 1.0
+    background: float = 0.0
+    invert_magnetization: bool = True
+
+    def __post_init__(self) -> None:
+        _polarization_index(self.incident_polarization)
+        _polarization_index(self.analyzed_polarization)
+        if self.sample_length <= 0 or self.beam_thickness <= 0:
+            raise ValueError("sample_length and beam_thickness must be positive")
+
+    @classmethod
+    def from_mapping(cls, values: Mapping[str, Any]) -> SimulationConfig:
+        accepted = set(cls.__dataclass_fields__)
+        _reject_unknown(values, accepted, "simulation")
+        if "sample" not in values:
+            raise ValueError("simulation configuration requires a sample")
+
+        kwargs = dict(values)
+        kwargs["sample"] = SampleConfig.from_sequence(kwargs["sample"])
+        if "formalism" in kwargs:
+            kwargs["formalism"] = parse_formalism(kwargs["formalism"])
+        if "angle" in kwargs:
+            kwargs["angle"] = ScanRange.from_mapping(kwargs["angle"], "angle")
+        if "energy" in kwargs:
+            kwargs["energy"] = ScanRange.from_mapping(kwargs["energy"], "energy")
+
+        try:
+            return cls(**kwargs)
+        except TypeError as exc:
+            raise ValueError(f"invalid simulation configuration: {exc}") from exc
+
+    def to_experiment(self) -> Experiment:
+        experiment = Experiment()
+        experiment.Formalism = self.formalism
+        experiment.Angle = [
+            self.angle.start,
+            self.angle.stop,
+            self.angle.step,
+            self.angle.resolution,
+        ]
+        experiment.Energy = [
+            self.energy.start,
+            self.energy.stop,
+            self.energy.step,
+            self.energy.resolution,
+        ]
+        experiment.SampleLength = self.sample_length
+        experiment.BeamThickness = self.beam_thickness
+        experiment.CalcNorm[1] = self.normalization
+        experiment.CalcBkg[1] = self.background
+        experiment.Mag_or_Pol_InvertedToggle = self.invert_magnetization
+        experiment.SetPolFunc([
+            _polarization_index(self.incident_polarization),
+            _polarization_index(self.analyzed_polarization),
+        ])
+        return experiment
+
+    def run(self) -> ReflectivityResult:
+        return run_reflectivity(self.sample.to_layers(), self.to_experiment())
+
+
+def load_config(path: str | Path) -> SimulationConfig:
+    """Load a JSON simulation configuration from disk."""
+    source = Path(path)
+    try:
+        values = json.loads(source.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"invalid JSON in {source}: {exc.msg}") from exc
+    if not isinstance(values, dict):
+        raise ValueError("simulation configuration must be a JSON object")
+    return SimulationConfig.from_mapping(values)
+
+
+def parse_formalism(value: Formalism | str | int) -> Formalism:
+    if isinstance(value, Formalism):
+        return value
+    if isinstance(value, int):
+        try:
+            return Formalism(value)
+        except ValueError as exc:
+            raise ValueError(f"unknown formalism index: {value}") from exc
+    if isinstance(value, str):
+        normalized = value.strip().lower().replace("_", "-")
+        for formalism in Formalism:
+            if formalism.name.lower().replace("_", "-") == normalized:
+                return formalism
+    choices = ", ".join(item.name.lower().replace("_", "-") for item in Formalism)
+    raise ValueError(f"unknown formalism {value!r}; choose one of: {choices}")
+
+
+def _polarization_index(value: str) -> int:
+    normalized = value.strip().lower().replace("_", "-").replace(" ", "-")
+    normalized = normalized.replace("circ-+", "circ-plus").replace("circ--", "circ-minus")
+    try:
+        return _POLARIZATIONS[normalized]
+    except KeyError as exc:
+        choices = ", ".join(_POLARIZATIONS)
+        raise ValueError(f"unknown polarization {value!r}; choose one of: {choices}") from exc
+
+
+def _fixed(value: float) -> list[float]:
+    number = float(value)
+    return [number, number, number]
+
+
+def _reject_unknown(values: Mapping[str, Any], accepted, name: str) -> None:
+    unknown = sorted(set(values) - set(accepted))
+    if unknown:
+        raise ValueError(f"unknown {name} field(s): {', '.join(unknown)}")
+
+
+__all__ = [
+    "LayerConfig",
+    "SampleConfig",
+    "ScanRange",
+    "SimulationConfig",
+    "load_config",
+    "parse_formalism",
+]

dynaref-6.2.0/src/dyna/functions/Functions.py

@@ -0,0 +1,14 @@
+# This file is part of Dyna.
+#
+# Dyna is free software distributed under the GNU General Public License,
+# version 2 or later.
+# Copyright (C) 2008-present CNRS, stephane.grenier@neel.cnrs.fr
+
+"""Backward-compatible imports for the reorganized Dyna physics API.
+
+New code should import from :mod:`dyna.functions.physics` or from one of
+its focused implementation modules.
+"""
+
+from dyna.functions.physics import *
+from dyna.functions.physics import __all__

{dynaref-6.1.2 → dynaref-6.2.0}/src/dyna/functions/Post.py

@@ -111,7 +111,7 @@ def Post(_sim):
                 tmp = np.matmul(_sim.Pol_out.T, tmp)
                 tmp_RefPostPhi = np.square(np.absolute(tmp))
 
-        if (_sim.Formalism == 2)  and (_sim.Angle[3]>0): #angular resolution
+        if (_sim.Formalism in (2, 4)) and (_sim.Angle[3]>0): #angular resolution
             
             tmp_RefPost    = AngDiv(_sim.XRange, tmp_RefPost)
             tmp_RefPostPhi = AngDiv(_sim.XRange, tmp_RefPostPhi)
@@ -123,4 +123,4 @@ def Post(_sim):
         _RefPostPhi = tmp_RefPostPhi[:,:,0]*_sim.CalcNorm[1] * _sim.Imprint[:]
         _RefPostPhi = _RefPostPhi + _sim.CalcBkg[1]             
         
-    return _RefPost, _RefPostPhi
+    return _RefPost, _RefPostPhi

{dynaref-6.1.2 → dynaref-6.2.0}/src/dyna/functions/SFFunctions.py

@@ -6,6 +6,7 @@ Scattering factor allocation and interpolation.
 Functions
 ---------
 SF_AllocCalc    : allocate and fill the scattering factor array for one simulation.
+build_scattering_factors : interpolate factors for a sample without a GUI.
 MakeNewSFCalc   : build a 5-column scattering factor table for a molecule.
 SFCalc          : interpolate tabulated .cf / .mf files onto an energy grid.
 
@@ -65,15 +66,36 @@ def SF_AllocCalc(self, sim_index: int, optim_flag: int) -> np.ndarray:
     )
     SF = np.zeros(shape, dtype=np.complex128)
 
-    for layer_index, layer in enumerate(self.Sample):
-        SF[sim_index, layer_index] = SFCalc(
-            layer.name,
-            self.Sim[sim_index].EnergyRange,
-        )
+    SF[sim_index] = build_scattering_factors(
+        self.Sample,
+        self.Sim[sim_index].EnergyRange,
+    )
 
     return SF
 
 
+def build_scattering_factors(sample, energy: np.ndarray) -> np.ndarray:
+    """Interpolate charge and magnetic factors for every layer in ``sample``.
+
+    Parameters
+    ----------
+    sample : sequence of Layer
+        Layers ordered from vacuum to substrate.
+    energy : np.ndarray, shape (N,)
+        Photon energies in eV.
+
+    Returns
+    -------
+    np.ndarray, shape (n_layers, N, 2), complex128
+        Charge and magnetic scattering factors ready for the physics API.
+    """
+    energy = np.asarray(energy, dtype=float).reshape(-1)
+    return np.asarray(
+        [SFCalc(layer.name, energy) for layer in sample],
+        dtype=np.complex128,
+    )
+
+
 def MakeNewSFCalc(
     mol: List[Tuple[str, float]],
     energybox: Tuple[float, float, float],
@@ -184,4 +206,4 @@ def SFCalc(name: str, energy: np.ndarray) -> np.ndarray:
          np.interp(energy, t_mf[:, 0], t_mf[:, 1])
         - 1j * np.interp(energy, t_mf[:, 0], t_mf[:, 2])
     )
-    return sf
+    return sf

dynaref-6.2.0/src/dyna/functions/__init__.py

@@ -0,0 +1,4 @@
+"""Dyna calculation functions."""
+
+from dyna.functions.physics import *
+from dyna.functions.physics import __all__