fix: apply ruff-formatting

Author: Flo-rhein

src/weac/analysis/analyzer.py

@@ -21,7 +21,6 @@
 logger = logging.getLogger(__name__)
 
 
-
 def track_analyzer_call(func):
     """Decorator to track call count and execution time of Analyzer methods."""
 
@@ -163,7 +162,9 @@ def rasterize_solution(
             if not ki[i]:
                 issupported[nic[i] : nic[i + 1]] = False
             # Compute segment solution
-            zi = self.sm.z(xi, C[:, [i]], length, phi, theta, ki[i], is_loaded = gi[i], qs=qs)
+            zi = self.sm.z(
+                xi, C[:, [i]], length, phi, theta, ki[i], is_loaded=gi[i], qs=qs
+            )
             # Assemble global solution matrix
             zs[:, nic[i] : nic[i + 1]] = zi
 
@@ -586,7 +587,7 @@ def incremental_ERR(
         C_uncracked = self.sm.uncracked_unknown_constants
         C_cracked = self.sm.unknown_constants
         phi = self.sm.scenario.phi
-        theta=self.sm.scenario.theta
+        theta = self.sm.scenario.theta
         qs = self.sm.scenario.surface_load
 
         # Reduce inputs to segments with crack advance
@@ -634,7 +635,6 @@ def incremental_ERR(
                 self._integrand_GII, z_uncracked=z_uncracked, z_cracked=z_cracked
             )
 
-
             # Segment contributions to total crack opening integral
             Ginc1 += quad(intGI, 0, length, epsabs=tolerance, epsrel=tolerance)[0] / (
                 2 * da
@@ -663,7 +663,7 @@ def differential_ERR(
         gi = self.sm.scenario.gi
         C = self.sm.unknown_constants
         phi = self.sm.scenario.phi
-        theta= self.sm.scenario.theta
+        theta = self.sm.scenario.theta
         qs = self.sm.scenario.surface_load
 
         # Get number and indices of segment transitions
@@ -681,31 +681,75 @@ def differential_ERR(
 
         # Compute energy relase rate of all crack tips
         for j, idx in enumerate(ict):
-
             # Solution at crack tip
 
             # Solution at unpertrubed side
 
             # Mode I, II and III differential energy release rates
             if not self.sm.is_generalized:
                 z = self.sm.z(
-                    li[idx], C[:, [idx]], li[idx], phi=phi, theta=theta,has_foundation=ki[idx],is_loaded=gi[idx], qs=qs if gi[idx] else 0
+                    li[idx],
+                    C[:, [idx]],
+                    li[idx],
+                    phi=phi,
+                    theta=theta,
+                    has_foundation=ki[idx],
+                    is_loaded=gi[idx],
+                    qs=qs if gi[idx] else 0,
                 )
                 Gdif[1:3, j] = np.concatenate(
                     (self.sm.fq.Gi(z, unit=unit), self.sm.fq.Gii(z, unit=unit))
                 )
             else:
                 if ki[idx]:
-                    z_ct = self.sm.z(li[idx], C[:,[idx]], li[idx], phi=phi, theta=theta, has_foundation=ki[idx], is_loaded=gi[idx], qs=qs)
-                    z_ub = self.sm.z(li[idx], C[:,[idx]], li[idx], phi=phi, theta=theta, has_foundation=ki[idx], is_loaded=gi[idx], qs=qs)
+                    z_ct = self.sm.z(
+                        li[idx],
+                        C[:, [idx]],
+                        li[idx],
+                        phi=phi,
+                        theta=theta,
+                        has_foundation=ki[idx],
+                        is_loaded=gi[idx],
+                        qs=qs,
+                    )
+                    z_ub = self.sm.z(
+                        li[idx],
+                        C[:, [idx]],
+                        li[idx],
+                        phi=phi,
+                        theta=theta,
+                        has_foundation=ki[idx],
+                        is_loaded=gi[idx],
+                        qs=qs,
+                    )
                 else:
-                    z_ct = self.sm.z(li[idx], C[:,[idx]], li[idx],  phi=phi, theta=theta, has_foundation=ki[idx], is_loaded=gi[idx], qs=qs)
-                    z_ub = self.sm.z(li[idx], C[:,[idx]], li[idx],  phi=phi, theta=theta, has_foundation=ki[idx], is_loaded=gi[idx], qs=qs)
-                Gdif[1:,j] = np.concatenate(
-                    (self.sm.fq.Gi(z_ct,z_ub,  phi=phi, theta=theta,  unit=unit),
-                    self.sm.fq.Gii(z_ct,z_ub,  phi=phi, theta=theta,  unit=unit),
-                    self.sm.fq.Giii(z_ct,z_ub, phi, theta, unit=unit),)
+                    z_ct = self.sm.z(
+                        li[idx],
+                        C[:, [idx]],
+                        li[idx],
+                        phi=phi,
+                        theta=theta,
+                        has_foundation=ki[idx],
+                        is_loaded=gi[idx],
+                        qs=qs,
+                    )
+                    z_ub = self.sm.z(
+                        li[idx],
+                        C[:, [idx]],
+                        li[idx],
+                        phi=phi,
+                        theta=theta,
+                        has_foundation=ki[idx],
+                        is_loaded=gi[idx],
+                        qs=qs,
                     )
+                Gdif[1:, j] = np.concatenate(
+                    (
+                        self.sm.fq.Gi(z_ct, z_ub, phi=phi, theta=theta, unit=unit),
+                        self.sm.fq.Gii(z_ct, z_ub, phi=phi, theta=theta, unit=unit),
+                        self.sm.fq.Giii(z_ct, z_ub, phi, theta, unit=unit),
+                    )
+                )
         # Sum mode I and II contributions
         Gdif[0, :] = Gdif[1, :] + Gdif[2, :] + Gdif[3, :]
 

src/weac/analysis/criteria_evaluator.py

@@ -746,7 +746,7 @@ def evaluate_SteadyState(
         system_copy.set_forced_touchdown_mode(mode)
         touchdown_distance = system_copy.slab_touchdown.touchdown_distance
         analyzer = Analyzer(system_copy, printing_enabled=print_call_stats)
-        energy_release_rate, _, _, _  = analyzer.differential_ERR(unit="J/m^2")
+        energy_release_rate, _, _, _ = analyzer.differential_ERR(unit="J/m^2")
         maximal_stress_result = self._calculate_maximal_stresses(
             system_copy, print_call_stats=print_call_stats
         )
@@ -1129,7 +1129,13 @@ def _calculate_sigma_tau_at_x(
         is_loaded = system.scenario.gi[segment_index]
         # Calculate the displacement field
         Z = system.z(
-            coordinate_in_segment, C, li_segment, phi, theta,   has_foundation=has_foundation, is_loaded=is_loaded
+            coordinate_in_segment,
+            C,
+            li_segment,
+            phi,
+            theta,
+            has_foundation=has_foundation,
+            is_loaded=is_loaded,
         )
 
         # Calculate the stresses

src/weac/analysis/plotter.py

@@ -2062,15 +2062,15 @@ def plot_displacements(
                 [x / 10, analyzer.sm.fq.u(z, unit="mm"), r"$u_0\ (\mathrm{mm})$"],
                 [x / 10, -analyzer.sm.fq.w(z, unit="mm"), r"$-w\ (\mathrm{mm})$"],
                 [x / 10, analyzer.sm.fq.psi(z, unit="deg"), r"$\psi\ (^\circ)$ "],
-                ]
+            ]
         else:
             data = [
                 [x / 10, analyzer.sm.fq.u(z, unit="mm"), r"$u_0\ (\mathrm{mm})$"],
                 [x / 10, analyzer.sm.fq.v(z, unit="mm"), r"$v_0\ (\mathrm{mm})$"],
                 [x / 10, -analyzer.sm.fq.w(z, unit="mm"), r"$-w\ (\mathrm{mm})$"],
                 [x / 10, analyzer.sm.fq.psiy(z, unit="deg"), r"$\psi_y\ (^\circ)$ "],
                 [x / 10, analyzer.sm.fq.psiz(z, unit="deg"), r"$\psi_z\ (^\circ)$ "],
-                ]
+            ]
         self._plot_data(
             scenario=analyzer.sm.scenario,
             ax1label=r"Displacements",

src/weac/components/layer.py

@@ -254,7 +254,9 @@ class WeakLayer(BaseModel):
 
     rho: float = Field(default=125, gt=0, description="Density of the Slab  [kg m⁻³]")
     h: float = Field(default=20, gt=0, description="Height/Thickness of the slab  [mm]")
-    f:  float | None  = Field(default=None, description="Weight density of the weak layer [N/mm^3]")
+    f: float | None = Field(
+        default=None, description="Weight density of the weak layer [N/mm^3]"
+    )
     collapse_height: float = Field(
         default=0.0, ge=0, description="Collapse height [mm]"
     )
@@ -284,7 +286,10 @@ class WeakLayer(BaseModel):
         default="bergfeld",
         description="Method to calculate the Young's modulus",
     )
-    constitutive_model: Literal["PlaneStrain", "PlaneStress","Uniaxial"] = Field(default = "PlaneStrain", description="Marks how interlinked the weak layer is in out-of-plane direction.")
+    constitutive_model: Literal["PlaneStrain", "PlaneStress", "Uniaxial"] = Field(
+        default="PlaneStrain",
+        description="Marks how interlinked the weak layer is in out-of-plane direction.",
+    )
     grain_type: GrainType | None = Field(default=None, description="Grain type")
     grain_size: float | None = Field(default=None, description="Grain size [mm]")
     hand_hardness: HandHardness | None = Field(
@@ -308,7 +313,6 @@ def model_post_init(self, _ctx):  # pylint: disable=arguments-differ
         object.__setattr__(
             self, "collapse_height", self.collapse_height or _collapse_height(self.h)
         )
-        
 
         # Validate that collapse height is smaller than layer height
         if self.collapse_height >= self.h:
@@ -318,14 +322,13 @@ def model_post_init(self, _ctx):  # pylint: disable=arguments-differ
                 f"increasing layer thickness."
             )
 
-
-        if self.constitutive_model =='PlaneStrain':
+        if self.constitutive_model == "PlaneStrain":
             nu_eff = self.nu
             E_eff = self.E
-        elif self.constitutive_model == 'PlaneStress':
-            nu_eff = self.nu/(1+self.nu)
-            E_eff = self.E*(1+2*self.nu)/((1+self.nu)**2)
-        elif self.constitutive_model == 'Uniaxial':
+        elif self.constitutive_model == "PlaneStress":
+            nu_eff = self.nu / (1 + self.nu)
+            E_eff = self.E * (1 + 2 * self.nu) / ((1 + self.nu) ** 2)
+        elif self.constitutive_model == "Uniaxial":
             nu_eff = 0
             E_eff = self.E
         object.__setattr__(self, "nu", nu_eff)
@@ -334,7 +337,9 @@ def model_post_init(self, _ctx):  # pylint: disable=arguments-differ
         E_plane = self.E / (1 - self.nu**2)  # plane-strain Young
         object.__setattr__(self, "kn", self.kn or E_plane / self.h)
         object.__setattr__(self, "kt", self.kt or self.G / self.h)
-        object.__setattr__(self, "f", self.f if self.f is not None else self.rho*1e-12*G_MM_S2)
+        object.__setattr__(
+            self, "f", self.f if self.f is not None else self.rho * 1e-12 * G_MM_S2
+        )
 
     @model_validator(mode="after")
     def validate_positive_E_G(self):

src/weac/components/scenario_config.py

@@ -4,7 +4,14 @@
 
 from typing import Literal, Any, Annotated
 
-from pydantic import BaseModel, Field, field_validator, ConfigDict, PlainSerializer, WithJsonSchema
+from pydantic import (
+    BaseModel,
+    Field,
+    field_validator,
+    ConfigDict,
+    PlainSerializer,
+    WithJsonSchema,
+)
 import numpy as np
 
 
@@ -16,7 +23,9 @@ def _serialize_ndarray(arr: np.ndarray) -> list:
 NumpyArray = Annotated[
     np.ndarray,
     PlainSerializer(_serialize_ndarray, return_type=list),
-    WithJsonSchema({"type": "array", "items": {"type": "array", "items": {"type": "number"}}}),
+    WithJsonSchema(
+        {"type": "array", "items": {"type": "array", "items": {"type": "number"}}}
+    ),
 ]
 
 SystemType = Literal[
@@ -83,7 +92,7 @@ class ScenarioConfig(BaseModel):
         description="Rotation angle in degrees (counterclockwise positive)",
     )
     b: float = Field(
-        default = 300, ge=1, description= "Out-of-plane width of the model in [mm]"
+        default=300, ge=1, description="Out-of-plane width of the model in [mm]"
     )
     cut_length: float = Field(
         default=0.0, ge=0, description="Cut length of performed PST or VPST [mm]"
@@ -100,14 +109,14 @@ class ScenarioConfig(BaseModel):
         "Adam et al. (2024)",
     )
     load_vector_left: NumpyArray = Field(
-        default_factory = lambda: np.zeros((6,1)),
-        description="Load vector on the left side of the configuration to model external loading in mode III experiments.")
-
+        default_factory=lambda: np.zeros((6, 1)),
+        description="Load vector on the left side of the configuration to model external loading in mode III experiments.",
+    )
 
     load_vector_right: NumpyArray = Field(
-        default_factory = lambda: np.zeros((6,1)),
-        description="Load vector on the right side of the configuration to model external loading in mode III experiments.")
-
+        default_factory=lambda: np.zeros((6, 1)),
+        description="Load vector on the right side of the configuration to model external loading in mode III experiments.",
+    )
 
     @field_validator("load_vector_left", "load_vector_right", mode="after")
     @classmethod
@@ -119,5 +128,7 @@ def check_load_vector_shape(cls, value: Any) -> Any:
             # Try to reshape if possible
             arr = arr.reshape(-1, 1)
             if arr.shape[0] != 6:
-                raise ValueError(f"load vectors must have shape (6, 1), got {arr.shape}")
+                raise ValueError(
+                    f"load vectors must have shape (6, 1), got {arr.shape}"
+                )
         return arr

src/weac/components/segment.py

@@ -18,9 +18,12 @@ def _serialize_ndarray(arr: np.ndarray) -> list:
 NumpyArray = Annotated[
     np.ndarray,
     PlainSerializer(_serialize_ndarray, return_type=list),
-    WithJsonSchema({"type": "array", "items": {"type": "array", "items": {"type": "number"}}}),
+    WithJsonSchema(
+        {"type": "array", "items": {"type": "array", "items": {"type": "number"}}}
+    ),
 ]
 
+
 class Segment(BaseModel):
     """
     Defines a snow-slab segment: its length, foundation support, and applied loads.
@@ -37,6 +40,7 @@ class Segment(BaseModel):
     m: float
         Skier mass at the segment's right edge [kg].
     """
+
     model_config = ConfigDict(arbitrary_types_allowed=True)
     length: float = Field(default=5e3, ge=0, description="Segment length in [mm]")
     has_foundation: bool = Field(
@@ -45,14 +49,15 @@ class Segment(BaseModel):
         "cracked/free-hanging (no foundation)",
     )
     is_loaded: bool = Field(
-        default=True, description="Whether additional loading is applied at the segment's top side"
+        default=True,
+        description="Whether additional loading is applied at the segment's top side",
     )
     m: float = Field(
         default=0, ge=0, description="Skier mass at the segment's right edge in [kg]"
     )
 
     f: NumpyArray = Field(
-        default_factory=lambda: np.zeros((6,1), dtype=float),
+        default_factory=lambda: np.zeros((6, 1), dtype=float),
         description=(
             "Load vector acting on the right side of the segment. "
             "Includes the six section forces [Nx, Vy, Vz, Mx, My, Mz]."

src/weac/core/eigensystem.py

@@ -297,7 +297,7 @@ def zp(
             Particular integral vector (6x1) at position x.
         """
         # Get weight and surface loads
-        qw_t, _, qw_n  = decompose_to_xyz(f=self.slab.qw, phi=phi)
+        qw_t, _, qw_n = decompose_to_xyz(f=self.slab.qw, phi=phi)
         qs_t, _, qs_n = decompose_to_xyz(f=qs, phi=phi)
 
         # Weak Layer properties

src/weac/core/field_quantities.py

@@ -139,9 +139,8 @@ def Gi(self, Ztip: np.ndarray, unit: EnergyUnit = "kJ/m^2") -> float | np.ndarra
             Desired output unit. Default is kJ/m^2.
         """
         return (
-            self._unit_factor(unit) * 
-            self.es.weak_layer.kn  / 2 * self.w(Ztip)**2
-            #self.sig(Ztip) ** 2 / (2 * self.es.weak_layer.kn)
+            self._unit_factor(unit) * self.es.weak_layer.kn / 2 * self.w(Ztip) ** 2
+            # self.sig(Ztip) ** 2 / (2 * self.es.weak_layer.kn)
         )
 
     def Gii(self, Ztip: np.ndarray, unit: EnergyUnit = "kJ/m^2") -> float | np.ndarray: