refactor: fix more type issues

Author: CPrescher

glassure/calc.py

@@ -37,7 +37,7 @@ def create_calculate_pdf_configs(
     data: Pattern,
     composition: Composition,
     density: float,
-    bkg: Pattern = None,
+    bkg: Pattern | None = None,
     bkg_scaling: float = 1,
 ) -> tuple[DataConfig, CalculationConfig]:
     """
@@ -79,6 +79,9 @@ def calculate_pdf(
     config = calculation_config
     transform = config.transform
     composition = config.sample.composition
+    sample_atomic_density = config.sample.atomic_density
+    if sample_atomic_density is None:
+        raise ValueError("Sample atomic density must be provided for PDF calculation.")
 
     # subtract background
     if data_config.bkg is not None:
@@ -150,7 +153,7 @@ def calculate_pdf(
 
         n, norm = normalize(
             sample_pattern=sample,
-            atomic_density=config.sample.atomic_density,
+            atomic_density=sample_atomic_density,
             f_squared_mean=f_squared_mean,
             f_mean_squared=f_mean_squared,
             incoherent_scattering=norm_inc,
@@ -207,7 +210,7 @@ def calculate_pdf(
         opt = config.optimize
         sq = optimize_sq(
             sq,
-            atomic_density=config.sample.atomic_density,
+            atomic_density=sample_atomic_density,
             r_cutoff=opt.r_cutoff,
             r_step=transform.r_step,
             iterations=opt.iterations,
@@ -228,7 +231,7 @@ def calculate_pdf(
 
     gr = calculate_gr(
         fr,
-        atomic_density=config.sample.atomic_density,
+        atomic_density=sample_atomic_density,
     )
 
     res = Result(

glassure/configuration.py

@@ -34,15 +34,15 @@ class SampleConfig(BaseModel):
     )
     @property
     def atomic_density(self) -> Optional[float]:
-        if self.composition == {}:  # empty composition
+        if self.composition == {} or self.density is None:  # empty composition or density is not set
             return None
         return convert_density_to_atoms_per_cubic_angstrom(
             self.composition, self.density
         )
 
     @atomic_density.setter
     def atomic_density(self, value: Optional[float]):
-        if self.composition == {}:
+        if self.composition == {} or value is None:
             self.density = None
         else:
             self.density = convert_density_to_grams_per_cubic_centimeter(

glassure/optimization.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 from copy import deepcopy
-from typing import Optional
+from typing import Any
 
 import numpy as np
 from lmfit import Parameters, minimize
@@ -179,14 +179,14 @@ def fit_polynom_through_origin(x, y , degree: int) -> np.ndarray:
 
 
 from .calc import calculate_pdf
-from .configuration import CalculationConfig, DataConfig
+from .configuration import CalculationConfig, DataConfig, Result
 
 
 def optimize_density(
     data_config: DataConfig,
     calculation_config: CalculationConfig,
     method: str = "fr",
-    min_range: Optional[tuple[float, float]] = None,
+    min_range: tuple[float, float] | None = None,
     vary_bkg_scaling: bool = True,
     bkg_limits: tuple[float, float] = (0.9, 1.1),
     optimization_method: str = "lsq",
@@ -272,17 +272,30 @@ def optimize_density(
     )
 
     optim_config = calculation_config.model_copy(deep=True)
+    reference_result: Result | None = None
+    range_limits: tuple[float, float] | None = min_range
 
     if method == "sq":
         reference_config = calculation_config.model_copy(deep=True)
         reference_config.optimize = None
         reference_result = calculate_pdf(data_config, reference_config)
-        if min_range is None:
-            min_range = (0, reference_config.transform.q_max)
+        if range_limits is None:
+            range_limits = (0, reference_config.transform.q_max)
+    elif method in ("gr", "fr"):
+        if range_limits is None:
+            optimize_settings = optim_config.optimize
+            if optimize_settings is None:
+                raise ValueError(
+                    "Optimization range cannot be inferred because calculation_config.optimize is None."
+                )
+            range_limits = (0, optimize_settings.r_cutoff)
+    else:
+        raise ValueError(
+            f"Invalid optimize density method: {method}, only 'gr', 'fr' and 'sq' are supported."
+        )
 
-    elif method == "gr" or method == "fr":
-        if min_range is None:
-            min_range = (0, optim_config.optimize.r_cutoff)
+    if range_limits is None:
+        raise ValueError("Optimization range must be specified.")
 
     def fcn(params):
         density = params["density"].value
@@ -292,46 +305,52 @@ def fcn(params):
         result = calculate_pdf(data_config, optim_config)
 
         if method == "gr":
-            r, gr = result.gr.limit(*min_range).data
+            if result.gr is None:
+                raise ValueError("Result does not contain g(r) data required for 'gr' optimization.")
+            r, gr = result.gr.limit(*range_limits).data
             residual = gr * (r[1] - r[0])
         elif method == "fr":
+            if result.fr is None:
+                raise ValueError("Result does not contain F(r) data required for 'fr' optimization.")
             atomic_density = optim_config.sample.atomic_density
-            r, fr = result.fr.limit(*min_range).data
+            if atomic_density is None:
+                raise ValueError("Sample atomic density must be set for 'fr' optimization.")
+            r, fr = result.fr.limit(*range_limits).data
             residual = (fr + 4 * np.pi * r * atomic_density) * (r[1] - r[0])
         elif method == "sq":
-            q, sq = result.sq.limit(*min_range).data
-            sq_ref = reference_result.sq.limit(*min_range).y
+            if reference_result is None or reference_result.sq is None:
+                raise ValueError("Reference result does not contain S(q) data required for 'sq' optimization.")
+            if result.sq is None:
+                raise ValueError("Result does not contain S(q) data required for 'sq' optimization.")
+            q, sq = result.sq.limit(*range_limits).data
+            sq_ref = reference_result.sq.limit(*range_limits).y
             residual = (sq - sq_ref) * (q[1] - q[0])
-        else:
-            raise ValueError(
-                f"Invalid optimize density method: {method}, only 'gr', 'fr' and 'sq' are supported."
-            )
         return residual
 
     if optimization_method == "nelder":
-        res = minimize(
+        nelder_res: Any = minimize(
             fcn,
             params,
             method="nelder",
             options={"maxfev": 500, "fatol": 0.0001, "xatol": 0.0001},
         )
         return (
-            res.params["density"].value,
-            np.sum(res.residual**2),
-            res.params["bkg_scaling"].value,
-            np.sum(res.residual**2),
+            nelder_res.params["density"].value,
+            np.sum(nelder_res.residual**2),
+            nelder_res.params["bkg_scaling"].value,
+            np.sum(nelder_res.residual**2),
         )
     elif optimization_method == "lsq":
-        res = minimize(
+        lsq_res: Any = minimize(
             fcn,
             params,
             method="least_squares",
         )
         return (
-            res.params["density"].value,
-            res.params["density"].stderr,
-            res.params["bkg_scaling"].value,
-            res.params["bkg_scaling"].stderr,
+            lsq_res.params["density"].value,
+            lsq_res.params["density"].stderr,
+            lsq_res.params["bkg_scaling"].value,
+            lsq_res.params["bkg_scaling"].stderr,
         )
     else:
         raise ValueError(f"Invalid optimization method: {optimization_method}")

glassure/pattern.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 import os
 from typing_extensions import Annotated
-from typing import Union, Optional, TYPE_CHECKING
+from typing import Union, Optional, TYPE_CHECKING, Sequence
 from pydantic import PlainSerializer, PlainValidator
 import numpy as np
 import base64
@@ -304,21 +304,22 @@ def __radd__(self, other: Union[float, Pattern]) -> Pattern:
         """
         return self.__add__(other)
 
-    def __rmul__(self, other: float) -> Pattern:
+    def __rmul__(self, other: Union[float, np.ndarray, Sequence[float]]) -> Pattern:
         """
-        Multiplies the pattern with a scalar.
+        Multiplies the pattern with a scalar or an array-like of the same shape as the y-values.
 
-        :param other: scalar to multiply with
+        :param other: scalar or array-like to multiply with
         :return: new Pattern
         """
         orig_x, orig_y = self.data
-        return Pattern(np.copy(orig_x), np.copy(orig_y) * other)
+        multiplier = self._normalize_multiplier(other, orig_y.shape)
+        return Pattern(np.copy(orig_x), np.multiply(orig_y, multiplier))
 
-    def __mul__(self, other: float) -> Pattern:
+    def __mul__(self, other: Union[float, np.ndarray, Sequence[float]]) -> Pattern:
         """
-        Multiplies the pattern with a scalar.
+        Multiplies the pattern with a scalar or an array-like of the same shape as the y-values.
 
-        :param other: scalar to multiply with
+        :param other: scalar or array-like to multiply with
         :return: new Pattern
         """
         return self.__rmul__(other)
@@ -337,6 +338,25 @@ def __eq__(self, other: object) -> bool:
             return True
         return False
 
+    @staticmethod
+    def _normalize_multiplier(
+        multiplier: Union[float, np.ndarray, Sequence[float]], target_shape: tuple[int, ...]
+    ) -> np.ndarray:
+        """
+        Normalizes the multiplier to a float or an array of the same shape as the target shape.
+        :param multiplier: The multiplier to normalize
+        :param target_shape: The shape of the target array
+        :return: The normalized multiplier
+        """
+        array_multiplier = np.asarray(multiplier, dtype=float)
+        if array_multiplier.ndim == 0:
+            return array_multiplier
+        if array_multiplier.shape != target_shape:
+            raise ValueError(
+                "Array multiplier must have the same shape as the pattern's y values."
+            )
+        return array_multiplier
+
 
 class BkgNotInRangeError(Exception):
     def __init__(self, pattern_name: str):