diff --git a/.vscode/settings.json b/.vscode/settings.json
index 826180c..8b99756 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -9,7 +9,7 @@
     ],
     "python.envFile": "${workspaceFolder}/.env",
     "python.terminal.activateEnvironment": true,
-    "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
+    "python.defaultInterpreterPath": "${workspaceFolder}/.venv/Scripts/python",
     // Test settings
     "python.testing.pytestEnabled": true,
     "python.testing.unittestEnabled": false,
@@ -31,5 +31,24 @@
         "tag:yaml.org,2002:python/name:material.extensions.emoji.twemoji",
         "tag:yaml.org,2002:python/name:pymdownx.superfences.fence_code_format",
         "tag:yaml.org,2002:python/object/apply:pymdownx.slugs.slugify mapping"
-    ]
-}
+    ],
+    "workbench.colorCustomizations": {
+        "activityBar.activeBackground": "#30577f",
+        "activityBar.background": "#30577f",
+        "activityBar.foreground": "#e7e7e7",
+        "activityBar.inactiveForeground": "#e7e7e799",
+        "activityBarBadge.background": "#2e1120",
+        "activityBarBadge.foreground": "#e7e7e7",
+        "commandCenter.border": "#e7e7e799",
+        "sash.hoverBorder": "#30577f",
+        "statusBar.background": "#223e5a",
+        "statusBar.foreground": "#e7e7e7",
+        "statusBarItem.hoverBackground": "#30577f",
+        "statusBarItem.remoteBackground": "#223e5a",
+        "statusBarItem.remoteForeground": "#e7e7e7",
+        "titleBar.activeBackground": "#223e5a",
+        "titleBar.activeForeground": "#e7e7e7",
+        "titleBar.inactiveBackground": "#223e5a99",
+        "titleBar.inactiveForeground": "#e7e7e799"
+    }
+}
\ No newline at end of file
diff --git a/100 - generate_test_data.ipynb b/100 - generate_test_data.ipynb
new file mode 100644
index 0000000..53e81e5
--- /dev/null
+++ b/100 - generate_test_data.ipynb	
@@ -0,0 +1,703 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "59573d47",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'scipy'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mModuleNotFoundError\u001b[39m                       Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 4\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m numpy \u001b[38;5;28;01mas\u001b[39;00m np\n\u001b[32m      2\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m matplotlib.pyplot \u001b[38;5;28;01mas\u001b[39;00m plt\n\u001b[32m      3\u001b[39m \n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m scipy.stats \u001b[38;5;28;01mimport\u001b[39;00m norm\n\u001b[32m      5\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m numpy.typing \u001b[38;5;28;01mimport\u001b[39;00m ArrayLike\n",
+      "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'scipy'"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from scipy.stats import norm\n",
+    "from numpy.typing import ArrayLike"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f0870150",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def _power_law_stress(\n",
+    "    n_cycles: ArrayLike, power_law_coef: float, power_law_exp: float\n",
+    ") -> ArrayLike:\n",
+    "    \"\"\"Calculate stress amplitude from fatigue life using a power law relationship.\n",
+    "\n",
+    "    Parameters:\n",
+    "    n_cycles : ArrayLike\n",
+    "        The fatigue life (N) in cycles. Must be positive.\n",
+    "    power_law_coef : float\n",
+    "        Material constant representing the power law coefficient (MPa^power_law_exp).\n",
+    "    power_law_exp : float\n",
+    "        Material constant representing the power law exponent.\n",
+    "\n",
+    "    Returns:\n",
+    "    ArrayLike\n",
+    "        The calculated stress amplitude (σ_a) in MPa.\n",
+    "\n",
+    "    Raises:\n",
+    "    ValueError\n",
+    "        If n_cycles contains non-positive values, or if power_law_coef or power_law_exp are not positive.\n",
+    "    \"\"\"\n",
+    "    stress = power_law_coef * n_cycles ** (-1 / power_law_exp)\n",
+    "\n",
+    "    return stress\n",
+    "\n",
+    "\n",
+    "def _power_law_life(\n",
+    "    stress_amp: ArrayLike, power_law_coef: float, power_law_exp: float\n",
+    ") -> ArrayLike:\n",
+    "    \"\"\"Calculate fatigue life from stress amplitude using a power law relationship.\n",
+    "\n",
+    "    Parameters:\n",
+    "    stress_amp : ArrayLike\n",
+    "        The stress amplitude (σ_a) in MPa. Must be positive.\n",
+    "    power_law_coef : float\n",
+    "        Material constant representing the power law coefficient (MPa^power_law_exp).\n",
+    "    power_law_exp : float\n",
+    "        Material constant representing the power law exponent.\n",
+    "\n",
+    "    Returns:\n",
+    "    ArrayLike\n",
+    "        The calculated fatigue life (N) in cycles.\n",
+    "\n",
+    "    Raises:\n",
+    "    ValueError\n",
+    "        If stress_amp contains non-positive values, or if power_law_coef or power_law_exp are not positive.\n",
+    "    \"\"\"\n",
+    "    n_cycles = (power_law_coef / stress_amp) ** power_law_exp\n",
+    "\n",
+    "    return n_cycles"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c1ecda6e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class WholerPowerLaw:\n",
+    "    \"\"\"Wöhler (S-N) curve model using a power law relationship.\"\"\"\n",
+    "\n",
+    "    # def __init__(\n",
+    "    #     self,\n",
+    "    #     power_law_coef: float,\n",
+    "    #     power_law_exp: float,\n",
+    "    #     n_cycles: ArrayLike | None = None,\n",
+    "    #     stress: ArrayLike | None = None,\n",
+    "    #     runout: ArrayLike | None = None,\n",
+    "    # ):\n",
+    "    #     \"\"\"Initialize the Wöhler power law model.\n",
+    "\n",
+    "    #     Parameters:\n",
+    "    #     power_law_coef : float\n",
+    "    #         Material constant representing the power law coefficient (MPa^power_law_exp).\n",
+    "    #     power_law_exp : float\n",
+    "    #         Material constant representing the power law exponent.\n",
+    "\n",
+    "    #     Raises:\n",
+    "    #     ValueError\n",
+    "    #         If any parameter is not positive.\n",
+    "    #     \"\"\"\n",
+    "    #     super().__init__()\n",
+    "\n",
+    "    #     if power_law_coef <= 0:\n",
+    "    #         raise ValueError(f\"power_law_coef must be positive, got {power_law_coef}\")\n",
+    "    #     if power_law_exp <= 0:\n",
+    "    #         raise ValueError(f\"power_law_exp must be positive, got {power_law_exp}\")\n",
+    "\n",
+    "    #     self.power_law_coef = power_law_coef\n",
+    "    #     self.power_law_exp = power_law_exp\n",
+    "    #     self._n_cycles = np.asarray([] if n_cycles is None else n_cycles)\n",
+    "    #     self._stress = np.asarray([] if stress is None else stress)\n",
+    "    #     self._runout = np.asarray([] if runout is None else runout)\n",
+    "\n",
+    "    def set_curve_parameters(self, power_law_coef: float, power_law_exp: float) -> None:\n",
+    "        \"\"\"Set the parameters of the Wöhler power law curve.\n",
+    "\n",
+    "        Parameters:\n",
+    "        power_law_coef : float\n",
+    "            Material constant representing the power law coefficient (MPa^power_law_exp).\n",
+    "        power_law_exp : float\n",
+    "            Material constant representing the power law exponent.\n",
+    "\n",
+    "        Raises:\n",
+    "        ValueError\n",
+    "            If any parameter is not positive.\n",
+    "        \"\"\"\n",
+    "        if power_law_coef <= 0:\n",
+    "            raise ValueError(f\"power_law_coef must be positive, got {power_law_coef}\")\n",
+    "        if power_law_exp <= 0:\n",
+    "            raise ValueError(f\"power_law_exp must be positive, got {power_law_exp}\")\n",
+    "\n",
+    "        self.power_law_coef = power_law_coef\n",
+    "        self.power_law_exp = power_law_exp\n",
+    "\n",
+    "    def set_data_points(\n",
+    "        self, stress: ArrayLike, n_cycles: ArrayLike, runout: ArrayLike\n",
+    "    ) -> None:\n",
+    "        \"\"\"Set the calibration data points for the Wöhler power law curve.\n",
+    "\n",
+    "        Parameters:\n",
+    "        n_cycles : ArrayLike\n",
+    "            Calibration data points (N) in cycles. Must be positive.\n",
+    "        stress : ArrayLike\n",
+    "            Equivalent stress values (σ_a) in MPa corresponding to the calibration data points. Must be positive.\n",
+    "        runout : ArrayLike\n",
+    "            Runout indicators corresponding to the calibration data points (1 for runout, 0 for failure).\n",
+    "\n",
+    "        Raises:\n",
+    "        ValueError\n",
+    "            If n_cycles or stress contains non-positive values, or if runout contains values other than 0 or 1.\n",
+    "        \"\"\"\n",
+    "        n_cycles_array = np.asarray(n_cycles)\n",
+    "        stress_array = np.asarray(stress)\n",
+    "        runout_array = np.asarray(runout)\n",
+    "\n",
+    "        if np.any(n_cycles_array <= 0):\n",
+    "            raise ValueError(\"n_cycles must contain only positive values\")\n",
+    "        if np.any(stress_array <= 0):\n",
+    "            raise ValueError(\"stress must contain only positive values\")\n",
+    "        if not np.all(np.isin(runout_array, [0, 1])):  # convert to boolen array\n",
+    "            raise ValueError(\"runout must contain only 0 or 1 values\")\n",
+    "\n",
+    "        self._n_cycles = n_cycles_array\n",
+    "        self._stress = stress_array\n",
+    "        self._runout = np.logical_not(runout_array.astype(bool))\n",
+    "\n",
+    "    def get_stress(self, n_cycles: ArrayLike, probability: float = 0.5) -> ArrayLike:\n",
+    "        \"\"\"Calculate stress amplitude from fatigue life using the Wöhler power law.\n",
+    "\n",
+    "        Parameters:\n",
+    "        n_cycles : ArrayLike\n",
+    "            The fatigue life (N) in cycles. Must be positive.\n",
+    "        probability : float, optional\n",
+    "            The probability of failure (default is 0.5).\n",
+    "\n",
+    "        Returns:\n",
+    "        ArrayLike\n",
+    "            The calculated stress amplitude (σ_a) in MPa.\n",
+    "\n",
+    "        Raises:\n",
+    "        ValueError\n",
+    "            If n_cycles contains non-positive values.\n",
+    "        \"\"\"\n",
+    "        n_cycles_array = np.asarray(n_cycles)\n",
+    "        if np.any(n_cycles_array <= 0):\n",
+    "            raise ValueError(\"n_cycles must contain only positive values\")\n",
+    "\n",
+    "        if probability == 0.5:\n",
+    "            coef = self.power_law_coef\n",
+    "        else:\n",
+    "            coef = 10 ** (\n",
+    "                np.log10(self.power_law_coef)\n",
+    "                - norm.ppf(probability)\n",
+    "                * self.statistics[\"log_Stress_std\"]\n",
+    "            )\n",
+    "\n",
+    "        stress = _power_law_stress(n_cycles_array, coef, self.power_law_exp)\n",
+    "\n",
+    "        return stress\n",
+    "\n",
+    "    def get_life(self, stress_amp: ArrayLike, probability: float = 0.5) -> ArrayLike:\n",
+    "        \"\"\"Calculate fatigue life from stress amplitude using the Wöhler power law.\n",
+    "\n",
+    "        Parameters:\n",
+    "        stress_amp : ArrayLike\n",
+    "            The stress amplitude (σ_a) in MPa. Must be positive.\n",
+    "        probability : float, optional\n",
+    "            The probability of failure (default is 0.5).\n",
+    "\n",
+    "        Returns:\n",
+    "        ArrayLike\n",
+    "            The calculated fatigue life (N) in cycles.\n",
+    "\n",
+    "        Raises:\n",
+    "        ValueError\n",
+    "            If stress_amp contains non-positive values.\n",
+    "        \"\"\"\n",
+    "        stress_amp_array = np.asarray(stress_amp)\n",
+    "        if np.any(stress_amp_array <= 0):\n",
+    "            raise ValueError(\"stress_amp must contain only positive values\")\n",
+    "\n",
+    "        if probability == 0.5:\n",
+    "            coef = self.power_law_coef\n",
+    "        else:\n",
+    "            coef = 10 ** (\n",
+    "                np.log10(self.power_law_coef)\n",
+    "                - norm.ppf(probability)\n",
+    "                * self.statistics[\"log_N_cycles_std\"]\n",
+    "                / self.power_law_exp\n",
+    "            )\n",
+    "\n",
+    "        n_cycles = _power_law_life(stress_amp_array, coef, self.power_law_exp)\n",
+    "\n",
+    "        return n_cycles\n",
+    "\n",
+    "    def fit_data(self) -> None:\n",
+    "        \"\"\"Fit the Wöhler power law model to calibration data points.\n",
+    "\n",
+    "        Parameters:\n",
+    "        data_points : ArrayLike\n",
+    "            Calibration data points (N) in cycles.\n",
+    "        S_eqN : ArrayLike\n",
+    "            Equivalent stress values (σ_a) in MPa corresponding to the calibration data points.\n",
+    "        \"\"\"\n",
+    "        log_stess = np.log10(self._stress[self._runout])\n",
+    "        log_n_cycles = np.log10(self._n_cycles[self._runout])\n",
+    "\n",
+    "        # sn_fit = np.polynomial.Polynomial.fit(log_n_cycles, log_stess, deg=1)\n",
+    "        sn_fit = np.polynomial.Polynomial.fit(\n",
+    "            x=np.flip(log_stess), y=np.flip(log_n_cycles), deg=1\n",
+    "        )\n",
+    "        intercept, slope = sn_fit.convert().coef\n",
+    "\n",
+    "        self.power_law_exp = -slope\n",
+    "        self.power_law_coef = 10 ** (-intercept / slope)\n",
+    "\n",
+    "    def get_statistics(self, dist: str = \"LogNormal\") -> dict:\n",
+    "        \"\"\"Get a statistical summary of the fitted Wöhler power law model.\n",
+    "\n",
+    "        Returns:\n",
+    "        dict\n",
+    "            A dictionary containing the fitted power law coefficient and exponent.\n",
+    "        \"\"\"\n",
+    "        log_stess = np.log10(self._stress[self._runout])\n",
+    "        stress_pred = self.get_stress(self._n_cycles[self._runout])\n",
+    "        log_stress_pred = np.log10(stress_pred)\n",
+    "\n",
+    "        log_n_cycles = np.log10(self._n_cycles[self._runout])\n",
+    "        n_cycles_pred = self.get_life(self._stress[self._runout])\n",
+    "        log_n_cycles_pred = np.log10(n_cycles_pred)\n",
+    "\n",
+    "        if dist == \"LogNormal\":\n",
+    "            residuals_stress = log_stess - log_stress_pred\n",
+    "            std_stress = np.std(residuals_stress, ddof=1)\n",
+    "\n",
+    "            residuals_n_cycles = log_n_cycles - log_n_cycles_pred\n",
+    "            std_n_cycles = np.std(residuals_n_cycles, ddof=1)\n",
+    "\n",
+    "            statistical_data = {\n",
+    "                \"distribution_name\": dist,\n",
+    "                \"log_Stress_std\": std_stress,\n",
+    "                \"log_N_cycles_std\": std_n_cycles,\n",
+    "            }\n",
+    "        else:\n",
+    "            raise ValueError(f\"Unsupported distribution: {dist}\")\n",
+    "\n",
+    "        self.statistics = statistical_data\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2b3964ba",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape: (11, 3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "file_path = \"data.txt\"  # update with your actual path\n",
+    "data = np.loadtxt(file_path)\n",
+    "\n",
+    "print(\"Shape:\", data.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "80107097",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "my_curve = WholerPowerLaw()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f9f66302",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "my_curve.set_data_points(n_cycles=data[:, 0], stress=data[:, 1], runout=data[:, 2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4fe79c7a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "my_curve.fit_data()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ab8b18c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "my_curve.get_statistics()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "48cf1524",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fitted power law coefficient: 555.26\n",
+      "Fitted power law exponent: 7.7368\n",
+      "Stress std: 0.0184\n",
+      "N_cycles std: 0.1423\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Fitted power law coefficient: {my_curve.power_law_coef:.2f}\")\n",
+    "print(f\"Fitted power law exponent: {my_curve.power_law_exp:.4f}\")\n",
+    "print(f\"Stress std: {my_curve.statistics['log_Stress_std']:.4f}\")\n",
+    "print(f\"N_cycles std: {my_curve.statistics['log_N_cycles_std']:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "83dfc9a0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "np.float64(0.018393752733358894)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "my_curve.statistics[\"log_N_cycles_std\"] / my_curve.power_law_exp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2dbd999a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "N = np.logspace(3.9, 6.2, num=10)\n",
+    "S_a = my_curve.get_stress(N)\n",
+    "S_a_10 = my_curve.get_stress(N, probability=0.1)\n",
+    "S_a_90 = my_curve.get_stress(N, probability=0.9)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "615591ef",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 506,
+       "width": 697
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(8, 6))\n",
+    "ax.scatter(data[:, 0], data[:, 1], c=data[:, 2], cmap=\"coolwarm\", label=\"Data Points\")\n",
+    "ax.loglog(N, S_a, label=\"Fitted Power Law\", color=\"black\")\n",
+    "ax.loglog(N, S_a_10, label=\"Fitted Power Law - 10%\", color=\"tab:red\")\n",
+    "ax.loglog(N, S_a_90, label=\"Fitted Power Law - 90%\", color=\"tab:blue\")\n",
+    "ax.legend()\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_yscale(\"log\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "326da7e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "S_a_calc = np.logspace(np.log10(S_a[-1]), np.log10(S_a[0]))\n",
+    "N_calc = my_curve.get_life(S_a_calc)\n",
+    "N_calc_10 = my_curve.get_life(S_a_calc, probability=0.1)\n",
+    "N_calc_90 = my_curve.get_life(S_a_calc, probability=0.9)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3f5d2d7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 506,
+       "width": 697
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(8, 6))\n",
+    "ax.scatter(data[:, 0], data[:, 1], c=data[:, 2], cmap=\"coolwarm\", label=\"Data Points\")\n",
+    "ax.loglog(N_calc, S_a_calc, label=\"Fitted Power Law\", color=\"black\")\n",
+    "ax.loglog(N_calc_10, S_a_calc, label=\"Fitted Power Law - 10%\", color=\"tab:red\")\n",
+    "ax.loglog(N_calc_90, S_a_calc, label=\"Fitted Power Law - 90%\", color=\"tab:blue\")\n",
+    "ax.legend()\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_yscale(\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50aeb612",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "64d7da1a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x129a8fa40>]"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 413,
+       "width": 547
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "x = np.log10(np.flip(data[data[:, 2] == 0, 1]))\n",
+    "y = np.log10(np.flip(data[data[:, 2] == 0, 0]))\n",
+    "plt.plot(x, y, \"o\", label=\"Data Points (Failures)\", color=\"blue\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b2bcb37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sn_fit = np.polynomial.Polynomial.fit(x, y, deg=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c672aef0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fitted l: 21.233645279192476\n",
+      "Fitted k: -7.736807920395017\n",
+      "Fitted power law coefficient: 555.26\n",
+      "Fitted power law exponent: 7.7368\n"
+     ]
+    }
+   ],
+   "source": [
+    "l, k = sn_fit.convert().coef\n",
+    "print(f\"Fitted l: {l}\")\n",
+    "print(f\"Fitted k: {k}\")\n",
+    "print(f\"Fitted power law coefficient: {10 ** (-l / k):.2f}\")\n",
+    "print(f\"Fitted power law exponent: {-k:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c694b70f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Standard deviation of log(Stress): 0.0184\n",
+      "Predicted stress for 1e5 cycles: 125.38 MPa\n"
+     ]
+    }
+   ],
+   "source": [
+    "stdev = my_curve.statistics[\"log_Stress_std\"]\n",
+    "print(f\"Standard deviation of log(Stress): {stdev:.4f}\")\n",
+    "mean = my_curve.get_stress(1e5)\n",
+    "print(f\"Predicted stress for 1e5 cycles: {mean:.2f} MPa\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f4d97cb2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "np.float64(586.2318810972395)"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "10 ** (np.log10(my_curve.power_law_coef) - norm.ppf(0.1) * stdev)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2b638446",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1.95424251, 1.95424251, 2.07918125, 2.        , 2.20411998,\n",
+       "       2.20411998, 2.14612804, 2.        , 2.07918125])"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "944386ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([6.22899467, 5.80857487, 5.15168848, 5.89274667, 4.21122737,\n",
+       "       4.05200098, 4.72720768, 5.85538103, 5.1062181 ])"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "947deca1",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "FatPy (3.12.8)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/110 - log_bi-linear_power_law.ipynb b/110 - log_bi-linear_power_law.ipynb
new file mode 100644
index 0000000..ddc8fa8
--- /dev/null
+++ b/110 - log_bi-linear_power_law.ipynb	
@@ -0,0 +1,710 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2e890b97",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'scipy'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mModuleNotFoundError\u001b[39m                       Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 5\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m numpy \u001b[38;5;28;01mas\u001b[39;00m np\n\u001b[32m      2\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m matplotlib.pyplot \u001b[38;5;28;01mas\u001b[39;00m plt\n\u001b[32m      3\u001b[39m \n\u001b[32m      4\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m numpy.typing \u001b[38;5;28;01mimport\u001b[39;00m ArrayLike\n\u001b[32m----> \u001b[39m\u001b[32m5\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m scipy.stats \u001b[38;5;28;01mimport\u001b[39;00m norm\n",
+      "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'scipy'"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from numpy.typing import ArrayLike\n",
+    "from scipy.stats import norm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "af3081e4",
+   "metadata": {},
+   "source": [
+    "# Utility functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e00982de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def _power_law_stress(\n",
+    "    n_cycles: ArrayLike, power_law_coef: float, power_law_exp: float\n",
+    ") -> ArrayLike:\n",
+    "    \"\"\"Calculate stress amplitude from fatigue life using a power law relationship.\n",
+    "\n",
+    "    Parameters:\n",
+    "    n_cycles : ArrayLike\n",
+    "        The fatigue life (N) in cycles. Must be positive.\n",
+    "    power_law_coef : float\n",
+    "        Material constant representing the power law coefficient (MPa^power_law_exp).\n",
+    "    power_law_exp : float\n",
+    "        Material constant representing the power law exponent.\n",
+    "\n",
+    "    Returns:\n",
+    "    ArrayLike\n",
+    "        The calculated stress amplitude (σ_a) in MPa.\n",
+    "\n",
+    "    Raises:\n",
+    "    ValueError\n",
+    "        If n_cycles contains non-positive values, or if power_law_coef or power_law_exp are not positive.\n",
+    "    \"\"\"\n",
+    "    stress = power_law_coef * n_cycles ** (-1 / power_law_exp)\n",
+    "\n",
+    "    return stress\n",
+    "\n",
+    "def _power_law_life(\n",
+    "    stress_amp: ArrayLike, power_law_coef: float, power_law_exp: float\n",
+    ") -> ArrayLike:\n",
+    "    \"\"\"Calculate fatigue life from stress amplitude using a power law relationship.\n",
+    "\n",
+    "    Parameters:\n",
+    "    stress_amp : ArrayLike\n",
+    "        The stress amplitude (σ_a) in MPa. Must be positive.\n",
+    "    power_law_coef : float\n",
+    "        Material constant representing the power law coefficient (MPa^power_law_exp).\n",
+    "    power_law_exp : float\n",
+    "        Material constant representing the power law exponent.\n",
+    "\n",
+    "    Returns:\n",
+    "    ArrayLike\n",
+    "        The calculated fatigue life (N) in cycles.\n",
+    "\n",
+    "    Raises:\n",
+    "    ValueError\n",
+    "        If stress_amp contains non-positive values, or if power_law_coef or power_law_exp are not positive.\n",
+    "    \"\"\"\n",
+    "    n_cycles = (power_law_coef / stress_amp) ** power_law_exp\n",
+    "\n",
+    "    return n_cycles\n",
+    "\n",
+    "def _get_intersection(params: list) -> float:\n",
+    "    \"\"\"Calculate the stress amplitude at which the two power law segments intersect.\n",
+    "\n",
+    "    Returns:\n",
+    "    float\n",
+    "        The stress amplitude (σ_a) in MPa at the intersection point.\n",
+    "    \"\"\"\n",
+    "    # Placeholder values for the coefficients and exponents of the two segments\n",
+    "    c1 = params[0, 0]  # coefficient for segment 1 (MPa^power_law_exp1)\n",
+    "    b1 = params[0, 1]   # Exponent for segment 1\n",
+    "    c2 = params[1, 0]  # coefficient for segment 2 (MPa^power_law_exp2)\n",
+    "    b2 = params[1, 1]   # Exponent for segment 2\n",
+    "\n",
+    "    # Calculate the intersection stress amplitude\n",
+    "    intersection_life = np.power(c1 / c2, b1 * b2 / (b2 - b1))\n",
+    "    intersection_stress = _power_law_stress(intersection_life, c1, b1)\n",
+    "\n",
+    "    return intersection_stress, intersection_life\n",
+    "\n",
+    "def _fit_data(stress: ArrayLike, life: ArrayLike) -> tuple:\n",
+    "    \"\"\"Fit the Wöhler power law model to calibration data points.\n",
+    "\n",
+    "    Parameters:\n",
+    "    data_points : ArrayLike\n",
+    "        Calibration data points (N) in cycles.\n",
+    "    S_eqN : ArrayLike\n",
+    "        Equivalent stress values (σ_a) in MPa corresponding to the calibration data points.\n",
+    "    \"\"\"\n",
+    "    log_stess = np.log10(stress)\n",
+    "    log_n_cycles = np.log10(life)\n",
+    "\n",
+    "    # sn_fit = np.polynomial.Polynomial.fit(log_n_cycles, log_stess, deg=1)\n",
+    "    sn_fit = np.polynomial.Polynomial.fit(\n",
+    "        x=log_stess, y=log_n_cycles, deg=1\n",
+    "    )\n",
+    "    intercept, slope = sn_fit.convert().coef\n",
+    "\n",
+    "    power_law_exp = -slope\n",
+    "    power_law_coef = 10 ** (-intercept / slope)\n",
+    "\n",
+    "    return power_law_coef, power_law_exp\n",
+    "\n",
+    "def get_statistics(_stress: ArrayLike, _life: ArrayLike, params: list, dist: str = \"LogNormal\") -> dict:\n",
+    "    \"\"\"Get a statistical summary of the fitted Wöhler power law model.\n",
+    "\n",
+    "    Returns:\n",
+    "    dict\n",
+    "        A dictionary containing the fitted power law coefficient and exponent.\n",
+    "    \"\"\"\n",
+    "    log_stess = np.log10(_stress)\n",
+    "    stress_pred = _power_law_stress(_life, params[0], params[1])\n",
+    "    log_stress_pred = np.log10(stress_pred)\n",
+    "\n",
+    "    log_n_cycles = np.log10(_life)\n",
+    "    n_cycles_pred = _power_law_life(_stress, params[0], params[1])\n",
+    "    log_n_cycles_pred = np.log10(n_cycles_pred)\n",
+    "\n",
+    "    if dist == \"LogNormal\":\n",
+    "        residuals_stress = log_stess - log_stress_pred\n",
+    "        std_stress = np.std(residuals_stress, ddof=1)\n",
+    "\n",
+    "        residuals_n_cycles = log_n_cycles - log_n_cycles_pred\n",
+    "        std_n_cycles = np.std(residuals_n_cycles, ddof=1)\n",
+    "\n",
+    "        statistical_data = {\n",
+    "            \"distribution_name\": dist,\n",
+    "            \"log_Stress_std\": std_stress,\n",
+    "            \"log_N_cycles_std\": std_n_cycles,\n",
+    "        }\n",
+    "    else:\n",
+    "        raise ValueError(f\"Unsupported distribution: {dist}\")\n",
+    "\n",
+    "    return statistical_data\n",
+    "\n",
+    "def shift_powlaw_constant(params: list, probability: float, statistics: dict) -> float:\n",
+    "    \"\"\"Calculate the coefficient for the power law constant based on the desired probability level.\n",
+    "\n",
+    "    Parameters:\n",
+    "        params: list of power law coefficient and exponent\n",
+    "        probability: desired probability level (e.g., 0.95 for 95% confidence)\n",
+    "        statistics: dictionary containing the log-standard deviations of stress from the fitted model\n",
+    "    returns:\n",
+    "        coefficient to be applied to the power law constant\n",
+    "    \"\"\"\n",
+    "    if statistics[\"distribution_name\"] != \"LogNormal\":\n",
+    "        raise ValueError(f\"Unsupported distribution: {statistics['distribution_name']}\")\n",
+    "\n",
+    "    coef_stress = 10 ** (\n",
+    "        np.log10(params[0])\n",
+    "        - norm.ppf(probability)\n",
+    "        * statistics[\"log_Stress_std\"]\n",
+    "    )\n",
+    "\n",
+    "    # coef_life = 10 ** (\n",
+    "    #     np.log10(params[0])\n",
+    "    #     - norm.ppf(probability)\n",
+    "    #     * statistics[\"log_N_cycles_std\"]\n",
+    "    #     / params[1]\n",
+    "    # )\n",
+    "\n",
+    "    return coef_stress#, coef_life\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "47182d20",
+   "metadata": {},
+   "source": [
+    "# Load experimental data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f33292fb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape: (19, 2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "file_path = \"IvanBiLin.txt\"  # update with your actual path\n",
+    "data = np.loadtxt(file_path)\n",
+    "\n",
+    "print(\"Shape:\", data.shape)\n",
+    "life_experiment = data[:, 1]\n",
+    "stress_experiment = data[:, 0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe48381a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 414,
+       "width": 552
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.semilogx(life_experiment, stress_experiment, \"o\", label=\"Data Points (Failures)\")\n",
+    "plt.grid()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d807feae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stress = np.flip(stress_experiment)\n",
+    "life = np.flip(life_experiment)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b86191a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of Pieces: 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "init_intersection_stress = [492.3837501262413]  # MPa, adjust based on your data\n",
+    "n_pieces = len(init_intersection_stress) + 1\n",
+    "print(f\"Number of Pieces: {n_pieces}\")\n",
+    "params_est = np.zeros((n_pieces, 2), dtype=float)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3cc70643",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([480.        , 492.38375013, 660.        ])"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "stress_main = np.empty(n_pieces + 1, dtype=float)\n",
+    "for i in range(n_pieces+1):\n",
+    "    if i == 0:\n",
+    "        stress_main[i] = np.min(stress_experiment)\n",
+    "    elif i == n_pieces:\n",
+    "        stress_main[i] = np.max(stress_experiment)\n",
+    "    else:\n",
+    "        stress_main[i] = init_intersection_stress[i - 1]\n",
+    "stress_main"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36d609e7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[550.56066924 129.31403539]\n",
+      " [957.45421939  21.71610227]]\n",
+      "Segment 1: {'distribution_name': 'LogNormal', 'log_Stress_std': np.float64(0.00260658336873527), 'log_N_cycles_std': np.float64(0.33706781399718555)}\n",
+      "Segment 2: {'distribution_name': 'LogNormal', 'log_Stress_std': np.float64(0.012734473568770352), 'log_N_cycles_std': np.float64(0.2765431303838136)}\n"
+     ]
+    }
+   ],
+   "source": [
+    "life_estimated = np.zeros_like(life)\n",
+    "statistical_data = []\n",
+    "\n",
+    "for i in range(n_pieces):\n",
+    "    if i == 0:\n",
+    "        mask = (stress >= stress_main[i]) & (stress <= stress_main[i + 1])\n",
+    "    else:\n",
+    "        mask = (stress > stress_main[i]) & (stress <= stress_main[i + 1])\n",
+    "\n",
+    "    params_est[i] = _fit_data(stress[mask], life[mask])\n",
+    "\n",
+    "    ### optional for the purpose of plotting the fitted curves\n",
+    "    life_estimated[mask] = _power_law_life(\n",
+    "        stress[mask],\n",
+    "        params_est[i, 0],\n",
+    "        params_est[i, 1]\n",
+    "    )\n",
+    "    statistical_data.append(\n",
+    "        get_statistics(\n",
+    "            stress[mask],\n",
+    "            life[mask],\n",
+    "            (params_est[i, 0], params_est[i, 1])\n",
+    "        )\n",
+    "    )\n",
+    "\n",
+    "print(params_est)\n",
+    "for i in range(n_pieces):\n",
+    "    print(f\"Segment {i + 1}: {statistical_data[i]}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d50945d9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Intersection Stress: 492.38,\n",
+      "Intersection Life: 1870342\n"
+     ]
+    }
+   ],
+   "source": [
+    "stress_interception, life_interception = _get_intersection(params_est)\n",
+    "print(f\"Intersection Stress: {stress_interception:.2f},\\nIntersection Life: {life_interception:.0f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d40ebb0f",
+   "metadata": {},
+   "source": [
+    "# Plotting\n",
+    "\n",
+    "## Generate data for mean curve\n",
+    "\n",
+    "Mean stress array is generated for each part separately, with two points. The knee point is repeated."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d8ccceb5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[480.        , 492.38375013],\n",
+       "       [492.38375013, 660.        ]])"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "stress_plot_50 = np.empty((n_pieces, 2), dtype=float)\n",
+    "for i in range(n_pieces):\n",
+    "    stress_plot_50[i, 0] = stress_main[i]\n",
+    "    stress_plot_50[i, 1] = stress_main[i + 1]\n",
+    "stress_plot_50"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c119e13a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "life_array_50 = np.zeros_like(stress_plot_50)\n",
+    "\n",
+    "for i, j in np.ndindex((n_pieces, 2)):\n",
+    "    life_array_50[i, j] = _power_law_life(\n",
+    "        stress_plot_50[i, j],\n",
+    "        params_est[i, 0],\n",
+    "        params_est[i, 1]\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f346ae7",
+   "metadata": {},
+   "source": [
+    "## Generate data for probability curves\n",
+    "\n",
+    "Process requires:\n",
+    "* shifting mean curve for the selected probability value -- calculate new Constants for each segment.\n",
+    "* calculate a new knee point\n",
+    "* generate new stress vector\n",
+    "* calculate life\n",
+    "\n",
+    "### 10% probability"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "db4c5061",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([480.        , 493.20173369, 660.        ])"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "params_est_10 = params_est.copy()\n",
+    "for i in range(n_pieces):\n",
+    "    params_est_10[i, 0] = shift_powlaw_constant(params_est[i], 0.10, statistical_data[i])\n",
+    "\n",
+    "stress_main_10 = stress_main.copy()\n",
+    "stress_main_10[1] = _get_intersection(params_est_10)[0]\n",
+    "stress_main_10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "78e6f01f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[480.        , 493.20173369],\n",
+       "       [493.20173369, 660.        ]])"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "stress_plot_10 = stress_plot_50.copy()\n",
+    "for i in range(n_pieces):\n",
+    "    stress_plot_10[i, 0] = stress_main_10[i]\n",
+    "    stress_plot_10[i, 1] = stress_main_10[i + 1]\n",
+    "stress_plot_10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f9303043",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "life_array_10 = np.zeros_like(stress_plot_10)\n",
+    "for i, j in np.ndindex((n_pieces, 2)):\n",
+    "    life_array_10[i, j] = _power_law_life(\n",
+    "        stress_plot_10[i, j],\n",
+    "        params_est_10[i, 0],\n",
+    "        params_est_10[i, 1]\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22b6ba02",
+   "metadata": {},
+   "source": [
+    "### 90% probability"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29a2dc7b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([480.       , 491.5671232, 660.       ])"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "params_est_90 = params_est.copy()\n",
+    "for i in range(n_pieces):\n",
+    "    params_est_90[i, 0] = shift_powlaw_constant(params_est[i], 0.90, statistical_data[i])\n",
+    "\n",
+    "stress_main_90 = stress_main.copy()\n",
+    "stress_main_90[1] = _get_intersection(params_est_90)[0]\n",
+    "stress_main_90"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3be75038",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[480.       , 491.5671232],\n",
+       "       [491.5671232, 660.       ]])"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "stress_plot_90 = stress_plot_50.copy()\n",
+    "for i in range(n_pieces):\n",
+    "    stress_plot_90[i, 0] = stress_main_90[i]\n",
+    "    stress_plot_90[i, 1] = stress_main_90[i + 1]\n",
+    "stress_plot_90"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e264755",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "life_array_90 = np.zeros_like(stress_plot_90)\n",
+    "for i, j in np.ndindex((n_pieces, 2)):\n",
+    "    life_array_90[i, j] = _power_law_life(\n",
+    "        stress_plot_90[i, j],\n",
+    "        params_est_90[i, 0],\n",
+    "        params_est_90[i, 1]\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d967124",
+   "metadata": {},
+   "source": [
+    "## Plot curves"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fd09582f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 506,
+       "width": 697
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(8, 6))\n",
+    "ax.loglog(life_experiment, stress_experiment, \"o\", label=\"Data Points (Failures)\")\n",
+    "ax.loglog(life_estimated, stress, \"d\", label=\"Estimated Life (Segment 1)\")\n",
+    "for i in range(n_pieces):\n",
+    "    ax.loglog(life_array_50[i], stress_plot_50[i], c='tab:orange')\n",
+    "    ax.loglog(life_array_10[i], stress_plot_10[i], c='tab:red')\n",
+    "    ax.loglog(life_array_90[i], stress_plot_90[i], c='tab:blue')\n",
+    "ax.grid()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "854bb256",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1.36277445e+08, 5.05697473e+06],\n",
+       "       [4.22985306e+06, 7.29732296e+03]])"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "life_array_10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f08f711c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "127f36f3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cd050637",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "FatPy (3.12.8)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Bagci_issue.md b/Bagci_issue.md
new file mode 100644
index 0000000..390618c
--- /dev/null
+++ b/Bagci_issue.md
@@ -0,0 +1,225 @@
+<!-- TEMPLATE GUIDELINE
+
+MANDATORY blocks must be completed.
+OPTIONAL blocks are provided inside HTML comments: `< !--`, `-- >`
+    remove comment markers to enable
+
+IMPORTANT:
+Function docstrings are our documentation source of truth, so all relevant information should be included there.
+
+Any important information captured in the issue should be reflected in the function signature, docstring, and/or test cases to ensure it is not lost during implementation.
+-->
+
+## ℹ️ General Information
+
+<!-- MANDATORY: this section reflects current planning -->
+
+**Component Name:** Bagci
+
+**Component Location:** core/stress_life/damage_params/uniaxial_stress_eq_amp/
+
+**Suggested Python Name:** `calc_stress_eq_amp_bagci`
+
+**FABER WG Relation:** WG4.1
+
+**Priority:** (1-10 scale) 2
+
+**Technical Complexity:** (1-10 scale) 2
+
+**Estimated Effort:** (1-10 scale) 2
+
+**Dependencies:** <!-- List any dependencies on other components, libraries, or tools -->
+
+**Related Issues:** <!-- Link to related issues, if any  using #Number_of_issue-->
+
+---
+
+<!-- MANDATORY -->
+## 📋 Problem Description
+
+Implement the Bagci equivalent stress amplitude function enabling mean stress effect correction in stress-life calculation.
+
+### Mathematical Formulation
+
+<!-- Describe algorithms, equations, and mathematical relationships -->
+
+$$
+\sigma_{a,eq}=\frac{\sigma_a}{1-\left( \frac{\sigma_m}{\sigma_y} \right)^4}
+$$
+
+**Latex text:**
+<!-- copy the formula inside the code block below for easier copy-pasting -->
+```
+$$
+\sigma_{a,eq}=\frac{\sigma_a}{1-\left( \frac{\sigma_m}{\sigma_y} \right)^4}
+$$
+```
+
+<!-- MANDATORY -->
+## 🔧 Implementation Guideline
+
+<!-- OPTIONAL
+### Abstraction / Interface Design
+
+Reference existing abstraction if any (base class, protocol, interface, abstract method).
+If no abstraction exists, explicitly state: "No existing abstraction applies."
+
+**Abstraction Reference:**
+Example: src/fatpy/core/strain_life/base_methods.py::BaseMethod
+
+-->
+
+### Function Signature
+
+<!--
+Change function signature
+- Use type hints for all parameters and return types
+- Include default values for optional parameters
+- Provide a docstring that describes the function's purpose, parameters, return value, and any
+    exceptions it may raise
+-->
+
+```python
+import numpy as np
+from numpy.typing import ArrayLike, Optional, NDArray
+
+def calc_stress_eq_amp_bagci(
+    stress_amp: ArrayLike | np.float64,
+    mean_stress: ArrayLike | np.float64,
+    yield_strength: ArrayLike | np.float64,
+    allow_neg_mean_stress: bool = True,
+    rtol: float = _RTOL,
+    atol: float = _ATOL,
+) -> NDArray[np.float64]:
+    """Calculate equivalent stress amplitude using Bagci criterion.
+
+    The Bagci equivalent stress amplitude is calculated as:
+
+    $$
+    \sigma_{aeq}=\frac{\sigma_a}{1-\left(\frac{\sigma_m}{\sigma_y}\right)^4}
+    $$
+
+    Args:
+        stress_amp: Array-like of stress amplitudes. Leading dimensions are preserved.
+        mean_stress: Array-like of mean stresses. Must be broadcastable with
+            stress_amp. Leading dimensions are preserved.
+        yield_strength: Array-like of yield strengths. Must be broadcastable with
+            stress_amp and mean_stress. Leading dimensions are preserved.
+        allow_neg_mean_stress: A flag to control the calculation method.
+            Defaults to True. If set to False, the equivalent stress amplitude will be
+            set equal to the original stress amplitude for cases where the mean stress
+            is negative, ignoring the correction.
+        rtol: Relative tolerance for checking if mean stress magnitude is close to
+            yield strength.
+        atol: Absolute tolerance for checking if mean stress magnitude is close to
+            yield strength.
+
+    Returns:
+        Array of equivalent stress amplitudes. Shape follows NumPy broadcasting
+            rules for the input arrays.
+
+    Raises:
+        Warning: If mean stress magnitude exceeds yield strength ($|\sigma_m| > R_e$).
+        Warning: If stress amplitude is negative ($\sigma_a < 0$).
+        ValueError: If yield strength is not positive ($R_e > 0$).
+        ValueError: If mean stress magnitude is close to yield strength
+            (within tolerance), the equivalent stress amplitude tends to infinity.
+            ($\left|\frac{\sigma_m}{R_e}\right| \approx 1.0$ within tolerance).
+    """        
+    pass  # Implementation goes here
+```
+
+### Inputs
+
+1. Static tensile parameters
+
+    | Parameter | Symbol | Type | Description | Units | Constraints |
+    |-----------|--------|------|-------------|-------|-------------|
+    | yield_strength | $\sigma_{y}$ | array of floats | Tensile yield strength | MPa | $>0$ |
+
+2. Stress / Strain values
+
+    | Parameter | Symbol | Type | Description | Units | Range |
+    |-----------|--------|------|-------------|-------|-------|
+    | stress_amp | $\sigma_a$ | array of floats | stress amplitude | MPa | $(0; \infty)$ |
+    | mean_stress | $\sigma_m$ | array of floats | mean stress | MPa | $(-\infty;\infty)$ |
+
+3. Additional inputs
+
+    | Parameter | Type | Description |
+    |-----------|------|-------------|
+    | allow_neg_mean_stress |  bool | Flag control for negative mean stress |
+    | rtol | float | Relative tolerance used in np.close() |
+    | atol |  float | Absolute tolerance used in np.close() |
+
+### Outputs
+
+| Parameter | Type | Description | Units | Range |
+|-----------|------|-------------|-------|-------|
+| $\sigma_{aeq}$ | array of floats | Equivalent stress amplitude by Bagci | - | $(0;\infty)$ |
+
+<!-- OPTIONAL-->
+### Expected Behavior
+
+- Catch invalid material parameter $\sigma_y < 0$
+- Catch invalid mathematical case, where the expression in denominator: $\left|\frac{\sigma_m}{\sigma_y}\right| \approx 1.0$ (use np.close() with accessible values of tolerances)
+- Raise warning for cases where ($|\sigma_m| > \sigma_y$)
+- Raise warning for cases where ($\sigma_a < 0$)
+- Allow for negative mean stress handling based on user selected flag control: allow_neg_mean_stress
+  - True $\rightarrow$ negative mean stress is used in calculation of equivalent stress amplitude $\sigma_{aeq}$
+  - False $\rightarrow$ equivalent stress amplitude $\sigma_{aeq}$ is set to the original stress amplitude $\sigma_a$ in cases where mean stress is negative
+
+<!--
+
+### Error Handling
+
+Document validation and failure behavior if applicable:
+- Input validation rules
+- Raised exceptions and when they occur
+- Message style for user-facing errors
+- Behavior for non-fatal issues (warning vs error)
+
+<!-- MANDATORY -->
+## ✅ Validation & Testing
+
+### Test Cases for numerical calculation
+
+<!-- Provide specific test cases with expected results -->
+| Test Case | Inputs | Expected Outputs | Notes |
+|-----------|--------|------------------|-------|
+| Case 1 | $\sigma_y = 500 MPa; \sigma_a = 180 MPa, \sigma_m = 100 MPa$ | $\sigma_{aeq} = 180.29 MPa$ | correct numerical calculation |
+| Case 2 | $\sigma_y = 500 MPa; \sigma_a = 180 MPa, \sigma_m = -100 MPa$ | $\sigma_{aeq} = -180.29 MPa$ | negative mean stress |
+| Case 3 | $\sigma_y = 500 MPa; \sigma_a = 180 MPa, \sigma_m = 0 MPa$ | $\sigma_{aeq} = \sigma_a = 180 MPa$ | zero mean stress |
+| Case 4 | $\sigma_y = 500 MPa; \sigma_a = 180 MPa, \sigma_m = -100 MPa$, allow_neg_mean_stress = False | $\sigma_{aeq} = \sigma_a = 180 MPa$ | negative mean stress + flag control |
+| Case 5 | $\sigma_y = 500 MPa; \sigma_a = 180 MPa, \sigma_m = [-100, 0.0, 100] MPa$, allow_neg_mean_stress = False | $\sigma_{aeq} = [180, 180, 180.29] MPa$ | flag control on array |
+
+### Test cases for Broadcasting
+
+test broadcasting of different combinations of 1D arrays with 2D arrays:
+
+- one or more inputs 1D with other scalar inputs
+- all inputs 1D
+- one or more inputs 2D with other scalar inputs
+- combination of 1D, 2D and scalar inputs
+
+### Test cases for raising Errors and Warnings
+
+- test if ValueError is raised when $\sigma_y < 0$
+- test if ValueError is raised when $\left|\frac{\sigma_m}{\sigma_y}\right| \approx 1.0$
+- test if Warning is raised when $|\sigma_m| > \sigma_y$
+- test if Warning is raised when $\sigma_a < 0$
+
+### Acceptance Criteria
+<!-- Define clear acceptance criteria for the implementation -->
+- [ ] Implementation meets all specified requirements
+- [ ] Code is well-documented and follows style guidelines
+- [ ] All test cases pass successfully
+<!-- If additional criteria are needed, list them here -->
+
+<!-- MANDATORY -->
+## 📚 References & Resources
+
+<!-- MANDATORY: literature, papers, existing implementations, theory -->
+<!-- Ideally provide links to online resources -->
+- [Papuga 2018](https://www.matec-conferences.org/articles/matecconf/pdf/2018/24/matecconf_fatigue2018_10018.pdf)
+- [Bagci 1981](https://www.sciencedirect.com/science/article/pii/0094114X81900094)
diff --git a/IvanBiLin.txt b/IvanBiLin.txt
new file mode 100644
index 0000000..fca8d59
--- /dev/null
+++ b/IvanBiLin.txt
@@ -0,0 +1,44 @@
+660.0	1058							
+650.0	4800							
+640.0	7268							
+620.0	9625							
+602.1	48213							
+580.0	150000							
+553.3	219101							
+530.0	244258							
+530.0	539905							
+497.5	542000							
+510.0	593010							
+510.0	1049796							
+500.0	904939							
+490.0	6200803							
+490.0	1905438							
+485.0	5438790							
+495.0	3443054							
+485.0	34535434							
+480.0	48543534							
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
+								
\ No newline at end of file
diff --git a/data.txt b/data.txt
new file mode 100644
index 0000000..6349c06
--- /dev/null
+++ b/data.txt
@@ -0,0 +1,11 @@
+127708	120	0
+716772	100	0
+53359	140	0
+2300000	80	1
+11272	160	0
+16264	160	0
+781172	100	0
+141804	120	0
+643539	90	0
+1694317	90	0
+2600000	80	1
diff --git a/docs/images/FP_logo.png b/docs/images/FP_logo.png
new file mode 100644
index 0000000..13621f7
Binary files /dev/null and b/docs/images/FP_logo.png differ
diff --git a/docs/images/fatpy_logo.png b/docs/images/fatpy_logo.png
new file mode 100644
index 0000000..0923050
Binary files /dev/null and b/docs/images/fatpy_logo.png differ
diff --git a/docs/images/logo.png b/docs/images/logo.png
new file mode 100644
index 0000000..5580c9a
Binary files /dev/null and b/docs/images/logo.png differ
diff --git a/docs/images/logo.svg b/docs/images/logo.svg
new file mode 100644
index 0000000..9ea9c0c
--- /dev/null
+++ b/docs/images/logo.svg
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Uploaded to: SVG Repo, www.svgrepo.com, Generator: SVG Repo Mixer Tools -->
+<svg width="800px" height="800px" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M13.2535 19.4243C12.9606 19.1314 12.4857 19.1314 12.1928 19.4243C11.8999 19.7172 11.8999 20.1921 12.1928 20.485L13.2535 19.4243ZM15.6157 22V21.25V22ZM4.04537 5.49167L4.5757 6.022H4.5757L4.04537 5.49167ZM3.51504 11.8072C3.80794 12.1001 4.28281 12.1001 4.5757 11.8072C4.8686 11.5143 4.8686 11.0394 4.5757 10.7465L3.51504 11.8072ZM11.2769 4.04537L11.8072 4.5757C11.9478 4.43505 12.0269 4.24428 12.0269 4.04537C12.0269 3.84646 11.9478 3.65569 11.8072 3.51504L11.2769 4.04537ZM5.49167 4.04537L4.96134 3.51504L4.96134 3.51504L5.49167 4.04537ZM19.9546 12.7231L20.485 12.1928C20.3443 12.0522 20.1535 11.9731 19.9546 11.9731C19.7557 11.9731 19.565 12.0522 19.4243 12.1928L19.9546 12.7231ZM22 15.6157H22.75H22ZM8.33603 5.92553C8.04314 6.21843 8.04314 6.6933 8.33603 6.98619C8.62892 7.27909 9.1038 7.27909 9.39669 6.98619L8.33603 5.92553ZM17.0138 14.6033C16.7209 14.8962 16.7209 15.3711 17.0138 15.664C17.3067 15.9569 17.7816 15.9569 18.0745 15.664L17.0138 14.6033ZM18.4868 21.0343C18.7819 20.7435 18.7854 20.2687 18.4947 19.9736C18.204 19.6786 17.7291 19.675 17.4341 19.9657L18.4868 21.0343ZM19.9274 17.473C19.6363 17.7677 19.6393 18.2426 19.934 18.5336C20.2287 18.8247 20.7036 18.8217 20.9946 18.527L19.9274 17.473ZM4.96134 3.51504L3.51504 4.96134L4.5757 6.022L6.022 4.5757L4.96134 3.51504ZM12.1928 20.485C12.8596 21.1518 13.4119 21.7063 13.9081 22.0849C14.4217 22.4767 14.9622 22.75 15.6157 22.75V21.25C15.422 21.25 15.1981 21.1824 14.818 20.8924C14.4206 20.5892 13.9503 20.1211 13.2535 19.4243L12.1928 20.485ZM3.51504 4.96134C2.84824 5.62814 2.29367 6.18046 1.91508 6.67666C1.52328 7.19018 1.25 7.73073 1.25 8.38426H2.75C2.75 8.19057 2.81761 7.96662 3.10761 7.58654C3.41081 7.18914 3.87892 6.71878 4.5757 6.022L3.51504 4.96134ZM4.5757 10.7465C3.87892 10.0497 3.41081 9.57937 3.10761 9.18198C2.81761 8.8019 2.75 8.57795 2.75 8.38426H1.25C1.25 9.03779 1.52328 9.57835 1.91508 10.0919C2.29367 10.5881 2.84824 11.1404 3.51504 11.8072L4.5757 10.7465ZM11.8072 3.51504C11.1404 2.84824 10.5881 2.29367 10.0919 1.91508C9.57835 1.52328 9.03779 1.25 8.38426 1.25V2.75C8.57795 2.75 8.8019 2.81761 9.18199 3.10761C9.57938 3.41081 10.0497 3.87892 10.7465 4.5757L11.8072 3.51504ZM6.022 4.5757C6.71878 3.87892 7.18914 3.41081 7.58654 3.10761C7.96662 2.81762 8.19057 2.75 8.38426 2.75V1.25C7.73073 1.25 7.19018 1.52328 6.67666 1.91508C6.18046 2.29367 5.62814 2.84824 4.96134 3.51504L6.022 4.5757ZM19.4243 13.2535C20.1211 13.9503 20.5892 14.4206 20.8924 14.818C21.1824 15.1981 21.25 15.422 21.25 15.6157H22.75C22.75 14.9622 22.4767 14.4217 22.0849 13.9081C21.7063 13.4119 21.1518 12.8596 20.485 12.1928L19.4243 13.2535ZM10.7465 3.51504L8.33603 5.92553L9.39669 6.98619L11.8072 4.5757L10.7465 3.51504ZM19.4243 12.1928L17.0138 14.6033L18.0745 15.664L20.485 13.2535L19.4243 12.1928ZM17.4341 19.9657C16.9239 20.4684 16.5635 20.7975 16.2586 21.0043C15.9715 21.199 15.784 21.25 15.6157 21.25V22.75C16.173 22.75 16.6504 22.551 17.1005 22.2457C17.5329 21.9525 17.982 21.5316 18.4868 21.0343L17.4341 19.9657ZM20.9946 18.527C21.504 18.0112 21.9345 17.5549 22.2339 17.1178C22.5457 16.6628 22.75 16.1805 22.75 15.6157H21.25C21.25 15.7859 21.1978 15.9762 20.9966 16.2699C20.783 16.5815 20.4439 16.9499 19.9274 17.473L20.9946 18.527Z" fill="#1C274C"/>
+<path d="M14.3601 4.07866L15.2869 3.15178C16.8226 1.61607 19.3125 1.61607 20.8482 3.15178C22.3839 4.68748 22.3839 7.17735 20.8482 8.71306L19.9213 9.63993M14.3601 4.07866C14.3601 4.07866 14.4759 6.04828 16.2138 7.78618C17.9517 9.52407 19.9213 9.63993 19.9213 9.63993M14.3601 4.07866L12 6.43872M19.9213 9.63993L14.6607 14.9006L11.5613 18L11.4001 18.1612C10.8229 18.7383 10.5344 19.0269 10.2162 19.2751C9.84082 19.5679 9.43469 19.8189 9.00498 20.0237C8.6407 20.1973 8.25352 20.3263 7.47918 20.5844L4.19792 21.6782M4.19792 21.6782L3.39584 21.9456C3.01478 22.0726 2.59466 21.9734 2.31063 21.6894C2.0266 21.4053 1.92743 20.9852 2.05445 20.6042L2.32181 19.8021M4.19792 21.6782L2.32181 19.8021M2.32181 19.8021L3.41556 16.5208C3.67368 15.7465 3.80273 15.3593 3.97634 14.995C4.18114 14.5653 4.43213 14.1592 4.7249 13.7838C4.97308 13.4656 5.26166 13.1771 5.83882 12.5999L8.5 9.93872" stroke="#1C274C" stroke-width="1.5" stroke-linecap="round"/>
+</svg>
\ No newline at end of file
diff --git a/kohout_vechet.py b/kohout_vechet.py
new file mode 100644
index 0000000..d753a22
--- /dev/null
+++ b/kohout_vechet.py
@@ -0,0 +1,79 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+from src.fatpy.material_laws.sn_curve import WholerPowerLaw, WohlerKohoutVechet
+
+stress_amp_kv = np.array(
+    [
+        704.1,
+        613.4,
+        544.8,
+        465.6,
+        400.1,
+        362.5,
+        295.8,
+        242.2,
+        191.8,
+        167.2,
+        140.7,
+        136.6,
+        133.2,
+    ],
+    dtype=np.float64,
+)
+
+life_kv = np.array(
+    [
+        1000,
+        5000,
+        10000,
+        20000,
+        35360,
+        50000,
+        100000,
+        200000,
+        500000,
+        1000000,
+        5000000,
+        10000000,
+        50000000,
+    ],
+    dtype=np.float64,
+)
+
+SN_kv = WohlerKohoutVechet(A=16651.6, B=7214.0, C=960478.0, beta=-0.351)
+
+calculated_stress_amp = SN_kv.stress_amp(life=life_kv)
+calculated_life = SN_kv.life(stress_amp=stress_amp_kv)
+
+plt.figure(figsize=(8, 6))
+plt.loglog(life_kv, stress_amp_kv, "o", label="Experimental Data")
+plt.loglog(life_kv, calculated_stress_amp, "-", label="Kohout-Vechet Fit")
+plt.loglog(calculated_life, stress_amp_kv, "x", label="Inverse Calculation")
+plt.xlabel("Fatigue Life (N) [cycles]")
+plt.ylabel("Stress Amplitude (σ_a) [MPa]")
+plt.title("Kohout-Věchet S-N Curve Fit")
+plt.legend()
+plt.grid(True, which="both", linestyle="--", linewidth=0.5)
+plt.show()
+
+stress_amp_power_law = np.array([100.0, 200.0, 300.0, 400.0, 500.0], dtype=np.float64)
+life_power_law = np.array(
+    [22000000.0, 2750000.0, 814814.8, 343750.0, 176000.0], dtype=np.float64
+)
+
+SN_power_law = WholerPowerLaw(SN_C=2.2e13, SN_w=3.0)
+
+calculated_stress_amp_pl = SN_power_law.stress_amp(life=life_power_law)
+calculated_life_pl = SN_power_law.life(stress_amp=stress_amp_power_law)
+
+# plt.figure(figsize=(8, 6))
+# plt.loglog(life_power_law, stress_amp_power_law, "o", label="Experimental Data")
+# plt.loglog(life_power_law, calculated_stress_amp_pl, "-", label="PowerLaw Fit")
+# plt.loglog(calculated_life_pl, stress_amp_power_law, "x", label="Inverse Calculation")
+# plt.xlabel("Fatigue Life (N) [cycles]")
+# plt.ylabel("Stress Amplitude (σ_a) [MPa]")
+# plt.title("Wöhler Power Law S-N Curve Fit")
+# plt.legend()
+# plt.grid(True, which="both", linestyle="--", linewidth=0.5)
+# plt.show()
diff --git a/mean_stress_corection_methods.md b/mean_stress_corection_methods.md
new file mode 100644
index 0000000..303ef99
--- /dev/null
+++ b/mean_stress_corection_methods.md
@@ -0,0 +1,28 @@
+# Mean-Stress Correction Methods — Reference
+
+| Method | Mathematical formula | Boundary conditions / domain | Errors / Warnings (implementation notes) |
+|---|---|---|---|
+| ASME | <div style="white-space:nowrap;">$\displaystyle\sigma_{a,eq}=\dfrac{\sigma_a}{\sqrt{1-\left(\dfrac{\sigma_m}{R_e}\right)^2}}$</div> | Requires $\lvert\sigma_m\rvert < R_e$. Denominator $\to 0$ as $\lvert\sigma_m\rvert \to R_e$. | Raises `ValueError` if $\lvert\sigma_m\rvert > R_e$ or if $\lvert\sigma_m/R_e - 1\rvert \le 1\times10^{-4}$ (treated as equal). |
+| Bagci | <div style="white-space:nowrap;">$\displaystyle\sigma_{a,eq}=\dfrac{\sigma_a}{1-\left(\dfrac{\sigma_m}{R_e}\right)^4}$</div> | Requires $1-\left(\dfrac{\sigma_m}{R_e}\right)^4 \neq 0$ (i.e. $\lvert\sigma_m\rvert \neq R_e$). | Implementation raises `ValueError` if $\lvert\sigma_m\rvert == R_e$, warns (`UserWarning`) if $\lvert\sigma_m\rvert > R_e$. |
+| Gerber | <div style="white-space:nowrap;">$\displaystyle\sigma_{a,eq}=\dfrac{\sigma_a}{1-\left(\dfrac{\sigma_m}{R_m}\right)^2}$</div> | Requires $\lvert\sigma_m\rvert < R_m$. Denominator zero at $\lvert\sigma_m\rvert = R_m$. | Implementation raises `ValueError` if $\lvert\sigma_m\rvert == R_m$, warns if $\lvert\sigma_m\rvert > R_m$. Fixed bug so result is always computed. |
+| Goodman | <div style="white-space:nowrap;">$\displaystyle\sigma_{a,eq}=\dfrac{\sigma_a}{1-\dfrac{\sigma_m}{R_m}}$</div> | Requires $\left(1-\dfrac{\sigma_m}{R_m}\right) \neq 0$ (i.e. $\sigma_m \neq R_m$). | Raises `ValueError` if $\sigma_m == R_m$, warns if $\lvert\sigma_m\rvert > R_m$. |
+| Half-slope | <div style="white-space:nowrap;">$\displaystyle\sigma_{a,eq}=\dfrac{\sigma_a}{1-\dfrac{\sigma_m}{2\,R_m}}$</div> | Denominator zero at $\sigma_m = 2 R_m$; typical domain requires $\sigma_m/(2R_m) < 1$. | Raises `ValueError` if $\sigma_m == 2 R_m$, warns if $\lvert\sigma_m\rvert > R_m$ (implementation uses this warning). |
+| Linear | <div style="white-space:nowrap;">$\displaystyle\sigma_{a,eq}=\dfrac{\sigma_a}{1-\dfrac{\sigma_m}{M}}$</div> | Requires $\sigma_m \neq M$ and usually $M > 0$. | Raises `ValueError` if $\sigma_m == M$, warns if $\lvert\sigma_m\rvert > M$. |
+| Morrow | <div style="white-space:nowrap;">$\displaystyle\sigma_{a,eq}=\dfrac{\sigma_a}{1-\dfrac{\sigma_m}{\sigma_{true}}}$</div> | Requires $\sigma_{true} > 0$ and $\sigma_m \neq \sigma_{true}$. | Raises `ValueError` if $\sigma_m == \sigma_{true}$, warns if $\lvert\sigma_m\rvert > \sigma_{true}$. |
+| Soderberg | <div style="white-space:nowrap;">$\displaystyle\sigma_{a,eq}=\dfrac{\sigma_a}{1-\dfrac{\sigma_m}{R_e}}$</div> | Requires $\sigma_m \neq R_e$. | Raises `ValueError` if $\sigma_m == R_e$, warns if $\lvert\sigma_m\rvert > R_e$. |
+| Smith | <div style="white-space:nowrap;">$\displaystyle\sigma_{a,eq}=\dfrac{\sigma_a\left(1+\dfrac{\sigma_m}{R_m}\right)}{1-\dfrac{\sigma_m}{R_m}}$</div> | Requires denominator $\neq 0$ (i.e. $\sigma_m \neq R_m$). | Raises `ValueError` if $\sigma_m == R_m$, warns if $\lvert\sigma_m\rvert > R_m$. Watch for sign flips and large amplification near the singularity. |
+| SWT (Smith–Watson–Topper) | <div style="white-space:nowrap;">$\displaystyle\sigma_{a,eq}=\sqrt{\sigma_a\left(\sigma_a+\sigma_m\right)}$</div> | Requires $\sigma_a + \sigma_m \ge 0$ for real result. | Returns `NaN` or raises for negative radicand; validate domain before use. |
+| Walker | <div style="white-space:nowrap;">$\displaystyle\sigma_{a,eq}=(\sigma_a+\sigma_m)^{1-\gamma}\,\sigma_a^{\gamma}$</div> | Requires $(\sigma_a+\sigma_m) > 0$ when non-integer powers used; parameter $\gamma \in [0,1]$. | Domain errors for negative base or invalid $\gamma$. Ensure parameter validated. |
+
+Notes
+
+- Column "Boundary conditions" lists mathematical domain constraints that make the formula finite and real.
+- Column "Errors / Warnings" reflects the current implementation behaviour in src/fatpy/core/stress_life/damage_params/uniaxial_stress_eq_amp.py (raise vs warn).
+- The ASME implementation treats values within an absolute tolerance of $1\times10^{-4}$ from ratio $=1$ as equal and raises an error to avoid numerical blow-up.
+
+If you want, I can also:
+
+- add links to the exact function implementations in src/fatpy/core/stress_life/damage_params/uniaxial_stress_eq_amp.py.
+- include recommended handling patterns (clip, warnings-as-errors toggle, or safe fallbacks).
+
+($\left|\frac{\sigma_m}{R_e}\right| \approx 1.0$ within tolerance)
\ No newline at end of file
diff --git a/raiflow_to_damage_example.ipynb b/raiflow_to_damage_example.ipynb
new file mode 100644
index 0000000..f8be233
--- /dev/null
+++ b/raiflow_to_damage_example.ipynb
@@ -0,0 +1,868 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "6861e89c",
+   "metadata": {},
+   "source": [
+    "# Showcase of FatPy usage on damage calculation based on stress history\n",
+    "\n",
+    "Prague WG 6 meeting 16. - 19. 06. 2026"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "83a18c30",
+   "metadata": {},
+   "source": [
+    "## Task\n",
+    "\n",
+    "Calculate the fatigue damage of a component based on its stress history using FatPy. \n",
+    "1. Define the stress history as a time series of stress values.\n",
+    "2. Use Rainflow to identify the stress cycles (\\sigma_min, \\sigma_max) and their corresponding number of occurrences.\n",
+    "3. Calculate stress amplitudes and mean stresses for each cycle.\n",
+    "4. Use selected mean stress correction methods to adjust the stress amplitudes.\n",
+    "5. Define an S-N curve (Power Law) for the material and calculate the fatigue life for each cycle.\n",
+    "6. Calculate the damage for each cycle using Palmgren-Miner's rule and sum the total damage."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58516dfe",
+   "metadata": {},
+   "source": [
+    "## Workflow using FatPy\n",
+    "\n",
+    "### Part 1: Stress History Processing\n",
+    "\n",
+    "```mermaid\n",
+    "%%{init: {'flowchart': {'curve': 'linear'}, 'theme': 'base', 'themeVariables': { 'primaryColor':'#1e1e1e', 'primaryBorderColor':'#464646', 'primaryTextColor':'#e0e0e0', 'lineColor':'#888888', 'secondaryColor':'#2d2d2d', 'tertiaryColor':'#3d3d3d'}}}%%\n",
+    "flowchart LR\n",
+    "    A([\"Define Stress<br/>History\"]) --> B[\"Rainflow<br/>Algorithm\"]\n",
+    "    B --> C[\"Extracted<br/>σ_min, σ_max\"]\n",
+    "    C --> D[\"Stress<br/>Amplitudes\"]\n",
+    "    C --> E[\"Mean<br/>Stresses\"]\n",
+    "    D --> V[\"Validity<br/>Check\"]\n",
+    "    E --> V\n",
+    "    \n",
+    "    MD([\"Material<br/>Data\"]) -.-> F\n",
+    "    \n",
+    "    V --> F{{\"Mean Stress<br/>Correction\"}}\n",
+    "    F -->F1[\"Goodman\"]\n",
+    "    F -->F2[\"Gerber\"]\n",
+    "    F -->F3[\"SWT\"]\n",
+    "    F -->F4[\"Other\"]\n",
+    "    F1 --> G[(\"S-N Curve\")]\n",
+    "    F2 --> G\n",
+    "    F3 --> G\n",
+    "    F4 --> G\n",
+    "    G --> NC([\"N Cycles\"])\n",
+    "    \n",
+    "    style A fill:#6a1b9a,stroke:#9c27b0,color:#fff\n",
+    "    style B fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style C fill:#808080,stroke:#a9a9a9,color:#fff\n",
+    "    style D fill:#808080,stroke:#a9a9a9,color:#fff\n",
+    "    style E fill:#808080,stroke:#a9a9a9,color:#fff\n",
+    "    style V fill:#d32f2f,stroke:#f44336,color:#fff\n",
+    "    style MD fill:#6a1b9a,stroke:#9c27b0,color:#fff\n",
+    "    style F fill:#f57f17,stroke:#ffa726,color:#fff\n",
+    "    style F1 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style F2 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style F3 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style F4 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style G fill:#8b6f47,stroke:#b8956a,color:#fff\n",
+    "    style NC fill:#2e7d32,stroke:#81c784,color:#fff\n",
+    "```\n",
+    "\n",
+    "### Part 2: S-N Curve Definition & Damage Calculation\n",
+    "\n",
+    "```mermaid\n",
+    "%%{init: {'flowchart': {'curve': 'linear'}, 'theme': 'base', 'themeVariables': { 'primaryColor':'#1e1e1e', 'primaryBorderColor':'#464646', 'primaryTextColor':'#e0e0e0', 'lineColor':'#888888', 'secondaryColor':'#2d2d2d', 'tertiaryColor':'#3d3d3d'}}}%%\n",
+    "flowchart LR\n",
+    "    EMS([\"Equivalent<br/>Mean Stress\"]) -.-> NC([\"N Cycles\"])\n",
+    "    \n",
+    "    A([\"Define Material<br/>Parameters\"]) --> B{{\"S-N Curve<br/>Model\"}}\n",
+    "    B -->B1[\"Power Law\"]\n",
+    "    B -->B2[\"Kohout & Věchet\"]\n",
+    "    B -->B3[\"Other\"]\n",
+    "    B1 --> G[(\"S-N Curve\")]\n",
+    "    B2 --> G\n",
+    "    B3 --> G\n",
+    "    G --> NC\n",
+    "    \n",
+    "    NC --> DC{{\"Damage<br/>Cumulation\"}}\n",
+    "    DC -->DC1[\"Palmgren-Miner<br/>Basic\"]\n",
+    "    DC -->DC2[\"Palmgren-Miner<br/>Elementary\"]\n",
+    "    DC -->DC3[\"Palmgren-Miner<br/>Haibach\"]\n",
+    "    DC -->DC4[\"Other\"]\n",
+    "    DC1 --> I([\"Sum Total<br/>Damage\"])\n",
+    "    DC2 --> I\n",
+    "    DC3 --> I\n",
+    "    DC4 --> I\n",
+    "    \n",
+    "    I --> J([\"Sequences till<br/>Failure\"])\n",
+    "\n",
+    "    \n",
+    "    style EMS fill:#6a1b9a,stroke:#9c27b0,color:#fff\n",
+    "    style A fill:#6a1b9a,stroke:#9c27b0,color:#fff\n",
+    "    style B fill:#f57f17,stroke:#ffa726,color:#fff\n",
+    "    style B1 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style B2 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style B3 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style G fill:#8b6f47,stroke:#b8956a,color:#fff\n",
+    "    style NC fill:#2e7d32,stroke:#81c784,color:#fff\n",
+    "    style DC fill:#f57f17,stroke:#ffa726,color:#fff\n",
+    "    style DC1 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style DC2 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style DC3 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style DC4 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style I fill:#2e7d32,stroke:#81c784,color:#fff\n",
+    "    style J fill:#2e7d32,stroke:#81c784,color:#fff\n",
+    "```\n",
+    "\n",
+    "**Legend:**\n",
+    "- **Blue blocks**: FatPy functions\n",
+    "- **Brown rounded block**: Data structure (S-N Curve)\n",
+    "- **Purple rounded blocks**: Input data\n",
+    "- **Gray blocks**: Generic operations or custom implementations\n",
+    "- **Red block**: Validation/Check\n",
+    "- **Green block**: Resulting data\n",
+    "- **Orange diamonds**: Decision/selection points\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a66fbdc7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import fatpy\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "\n",
+    "stress = np.array([500, -200, 500, -400, 200, -400, 500, -200, 500, 0, 500 ], dtype=float)\n",
+    "times = np.arange(stress.size, dtype=float)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4f3ad68a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x350 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "def plot_stress_history(times: np.ndarray, stresses: np.ndarray) -> None:\n",
+    "    \"\"\"Plot stress history and optionally save to `save_path`.\n",
+    "\n",
+    "    - `times`: array of time steps\n",
+    "    - `stresses`: array of stresses (same length as `times`)\n",
+    "    - `save_path`: file path to save the figure (PNG/PDF). If None, figure is not saved.\n",
+    "    - `show`: if True, calls `plt.show()` to display interactively.\n",
+    "    \"\"\"\n",
+    "    fig, ax = plt.subplots(figsize=(8, 3.5))\n",
+    "    ax.plot(times, stresses, marker=\"o\", linestyle=\"-\", color=\"C0\")\n",
+    "    ax.axhline(y=0, color=\"black\", linestyle=\"--\", linewidth=1) \n",
+    "    ax.set_xlabel(\"Time step\")\n",
+    "    ax.set_ylabel(\"Stress [MPa]\")\n",
+    "    ax.set_title(\"Uniaxial Stress History\")\n",
+    "    ax.grid(True, linestyle=\"--\", alpha=0.6)\n",
+    "    ax.set_xticks(times)\n",
+    "    ax.set_yticks(np.arange(stress.min() - 100, stress.max() + 100, 100))\n",
+    "    fig.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "    # fig_rot, ax_rot = plt.subplots(figsize=(5, 8))\n",
+    "    # ax_rot.plot(stresses, times, marker=\"o\", linestyle=\"-\", color=\"C0\")\n",
+    "    # ax_rot.axvline(x=0, color=\"black\", linestyle=\"--\", linewidth=1)\n",
+    "    # ax_rot.set_xlabel(\"Stress [MPa]\")\n",
+    "    # ax_rot.set_ylabel(\"Time step\")\n",
+    "    # ax_rot.set_title(\"Uniaxial Stress History (Rotated 90°)\")\n",
+    "    # ax_rot.grid(True, linestyle=\"--\", alpha=0.6)\n",
+    "    # ax_rot.set_yticks(times)\n",
+    "    # ax_rot.set_xticks(np.arange(stresses.min() - 100, stresses.max() + 100, 100))\n",
+    "    # ax_rot.xaxis.set_label_position(\"top\")\n",
+    "    # ax_rot.xaxis.tick_top()\n",
+    "    # ax_rot.invert_yaxis()\n",
+    "    # fig_rot.tight_layout()\n",
+    "    # fig_rot.savefig(\"stress_history_rotated.png\", dpi=300)\n",
+    "\n",
+    "plot_stress_history(times, stress)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "67236d86",
+   "metadata": {},
+   "source": [
+    "## Solved rainflow (Manually since rainflow is not implemented yet)\n",
+    "<table>\n",
+    "    <tr>\n",
+    "        <td width=\"45%\" style=\"vertical-align: middle; text-align: center;\">\n",
+    "            <img src=\"stress_history_rotated.png\"\n",
+    "                     alt=\"Stress history\"\n",
+    "                     style=\"width:50%; height:auto; border:1px solid #ddd;\">\n",
+    "        </td>\n",
+    "        <td width=\"55%\" style=\"vertical-align: middle; text-align: center;\">\n",
+    "            <table>\n",
+    "                <thead>\n",
+    "                    <tr>\n",
+    "                        <th><i>i</i></th>\n",
+    "                        <th><i>n</i></th>\n",
+    "                        <th>&sigma;<sub>min</sub> [MPa]</th>\n",
+    "                        <th>&sigma;<sub>max</sub> [MPa]</th>\n",
+    "                    </tr>\n",
+    "                </thead>\n",
+    "                <tbody>\n",
+    "                    <tr><td>1</td><td>1</td><td>-400</td><td>500</td></tr>\n",
+    "                    <tr><td>2</td><td>2</td><td>-200</td><td>500</td></tr>\n",
+    "                    <tr><td>3</td><td>1</td><td>-400</td><td>200</td></tr>\n",
+    "                    <tr><td>4</td><td>1</td><td>0</td><td>500</td></tr>\n",
+    "                </tbody>\n",
+    "            </table>\n",
+    "        </td>\n",
+    "    </tr>\n",
+    "</table>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "038ab58d",
+   "metadata": {},
+   "source": [
+    "## Stress amplitudes and mean stresses\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a3dea8e9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   i  n  sigma_min  sigma_max  mean_stress  stress_amp\n",
+      "0  1  1     -400.0      500.0         50.0       450.0\n",
+      "1  2  2     -200.0      500.0        150.0       350.0\n",
+      "2  3  1     -400.0      200.0       -100.0       300.0\n",
+      "3  4  1        0.0      500.0        250.0       250.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# input cycles: (i, n, sigma_min, sigma_max)\n",
+    "data = [\n",
+    "    (1, 1, -400.0, 500.0),\n",
+    "    (2, 2, -200.0, 500.0),\n",
+    "    (3, 1, -400.0, 200.0),\n",
+    "    (4, 1,    0.0, 500.0),\n",
+    "]\n",
+    "\n",
+    "dtype = [('i', 'i4'), ('n', 'i4'), ('sigma_min', 'f8'), ('sigma_max', 'f8')]\n",
+    "cycles = np.array(data, dtype=dtype)\n",
+    "\n",
+    "mean_stress = (cycles['sigma_max'] + cycles['sigma_min']) / 2.0\n",
+    "stress_amp = (cycles['sigma_max'] - cycles['sigma_min']) / 2.0\n",
+    "\n",
+    "dtype_out = dtype + [('mean_stress', 'f8'), ('stress_amp', 'f8')]\n",
+    "out = np.zeros(cycles.shape, dtype=dtype_out)\n",
+    "for name in ['i', 'n', 'sigma_min', 'sigma_max']:\n",
+    "    out[name] = cycles[name]\n",
+    "out['stress_amp'] = stress_amp\n",
+    "out['mean_stress'] = mean_stress\n",
+    "\n",
+    "print(pd.DataFrame(out))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e5b92e15",
+   "metadata": {},
+   "source": [
+    "## Equivalent stress amplitude from FatPy's mean stress correction module"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "28d4d97d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   S_eq_goodman  S_eq_gerber    S_eq_swt\n",
+      "0    475.000000   451.250000  474.341649\n",
+      "1    415.625000   358.948864  418.330013\n",
+      "2    300.000000   300.000000  300.000000\n",
+      "3    339.285714   268.601190  353.553391\n"
+     ]
+    }
+   ],
+   "source": [
+    "from src.fatpy.core.stress_life.damage_params import uniaxial_stress_eq_amp as eq_amp\n",
+    "\n",
+    "s_eq_goodman = eq_amp.calc_stress_eq_amp_goodman(stress_amp, mean_stress,ult_tensile_strength=950,allow_neg_mean_stress=False)\n",
+    "s_eq_gerber = eq_amp.calc_stress_eq_amp_gerber(stress_amp, mean_stress,950,allow_neg_mean_stress=False)\n",
+    "s_eq_swt = eq_amp.calc_stress_eq_amp_swt(stress_amp, mean_stress,allow_neg_mean_stress=False)\n",
+    "sigma_eq = pd.DataFrame({'S_eq_goodman': s_eq_goodman, 'S_eq_gerber': s_eq_gerber, 'S_eq_swt': s_eq_swt})\n",
+    "print(sigma_eq)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dbc5bbe0",
+   "metadata": {},
+   "source": [
+    "# Define S-N curve (Power Law form) from FatPy's material laws module"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "1c6d7781",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from abc import ABC, abstractmethod\n",
+    "\n",
+    "import numpy as np\n",
+    "from numpy.typing import ArrayLike\n",
+    "\n",
+    "\n",
+    "class SN_Curve(ABC):\n",
+    "    \"\"\"Abstract base class for stress-life (S-N) curve models.\"\"\"\n",
+    "\n",
+    "    @abstractmethod\n",
+    "    def stress_amp(self, n_cycles: ArrayLike, probability: float) -> ArrayLike:\n",
+    "        \"\"\"Calculate stress amplitude from fatigue life.\"\"\"\n",
+    "        pass\n",
+    "\n",
+    "    @abstractmethod\n",
+    "    def life(self, stress_amp: ArrayLike, probability: float) -> ArrayLike:\n",
+    "        \"\"\"Calculate fatigue life from stress amplitude.\"\"\"\n",
+    "        pass\n",
+    "\n",
+    "\n",
+    "class PowerLaw(SN_Curve):\n",
+    "    \"\"\"Power law curve model using a power law relationship.\"\"\"\n",
+    "\n",
+    "    def __init__(self, power_law_coef: float, power_law_exp: float):\n",
+    "        \"\"\"Initialize the power law model.\n",
+    "\n",
+    "        Parameters:\n",
+    "        power_law_coef : float\n",
+    "            Material constant representing the power law coefficient (MPa^power_law_exp).\n",
+    "        power_law_exp : float\n",
+    "            Material constant representing the power law exponent.\n",
+    "\n",
+    "        Raises:\n",
+    "        ValueError\n",
+    "            If any parameter is not positive.\n",
+    "        \"\"\"\n",
+    "        if power_law_coef <= 0:\n",
+    "            raise ValueError(f\"power_law_coef must be positive, got {power_law_coef}\")\n",
+    "        if power_law_exp <= 0:\n",
+    "            raise ValueError(f\"power_law_exp must be positive, got {power_law_exp}\")\n",
+    "\n",
+    "        self.power_law_coef = power_law_coef\n",
+    "        self.power_law_exp = power_law_exp\n",
+    "\n",
+    "    def stress_amp(self, n_cycles: ArrayLike) -> ArrayLike:\n",
+    "        \"\"\"Calculate stress amplitude from fatigue life using the Wöhler power law.\n",
+    "\n",
+    "        Parameters:\n",
+    "        n_cycles : ArrayLike\n",
+    "            The fatigue life (N) in cycles. Must be positive.\n",
+    "\n",
+    "        Returns:\n",
+    "        ArrayLike\n",
+    "            The calculated stress amplitude (σ_a) in MPa.\n",
+    "\n",
+    "        Raises:\n",
+    "        ValueError\n",
+    "            If n_cycles contains non-positive values.\n",
+    "        \"\"\"\n",
+    "        n_cycles_array = np.asarray(n_cycles)\n",
+    "        if np.any(n_cycles_array <= 0):\n",
+    "            raise ValueError(\"n_cycles must contain only positive values\")\n",
+    "\n",
+    "        return (self.power_law_coef / n_cycles_array) ** (1 / self.power_law_exp)\n",
+    "\n",
+    "    def life(self, stress_amp: ArrayLike) -> ArrayLike:\n",
+    "        \"\"\"Calculate fatigue life from stress amplitude using the Wöhler power law.\n",
+    "\n",
+    "        Parameters:\n",
+    "        stress_amp : ArrayLike\n",
+    "            The stress amplitude (σ_a) in MPa. Must be positive.\n",
+    "\n",
+    "        Returns:\n",
+    "        ArrayLike\n",
+    "            The calculated fatigue life (N) in cycles.\n",
+    "\n",
+    "        Raises:\n",
+    "        ValueError\n",
+    "            If stress_amp contains non-positive values.\n",
+    "        \"\"\"\n",
+    "        stress_amp_array = np.asarray(stress_amp)\n",
+    "        if np.any(stress_amp_array <= 0):\n",
+    "            raise ValueError(\"stress_amp must contain only positive values\")\n",
+    "\n",
+    "        return self.power_law_coef / (stress_amp**self.power_law_exp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "9b8547d3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# from src.fatpy.material_laws import sn_curve\n",
+    "\n",
+    "POWER_LAW_COEF = 8e16\n",
+    "POWER_LAW_EXP = 4.5\n",
+    "\n",
+    "sn_power_law = PowerLaw(POWER_LAW_COEF,POWER_LAW_EXP)\n",
+    "\n",
+    "N = np.logspace(np.log10(1e4), np.log10(1e7), num=50)\n",
+    "S_a = sn_power_law.stress_amp(N)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(6, 4),dpi = 150)\n",
+    "ax.loglog(N, S_a, lw=2, color='C0')\n",
+    "ax.loglog([1e7, 5e7], [S_a[-1], S_a[-1]], 'C0--', lw=1.5, label='Endurance limit')\n",
+    "ax.set_xlabel('Cycles (N)')\n",
+    "ax.set_ylabel('Stress amplitude $\\\\sigma_a$ [MPa]')\n",
+    "ax.set_title('S–N curve (Wöhler power law)')\n",
+    "ax.grid(True, which='both', ls='--', alpha=0.6)\n",
+    "ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f'{int(x)}'))\n",
+    "ax.set_yticks(np.arange(100, int(S_a.max()) + 100, 100))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30c6c1ab",
+   "metadata": {},
+   "source": [
+    "## Calculate fatigue life for each equivalent stress amplitude"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "4c8148e5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "       n_goodman       n_gerber          n_swt\n",
+      "0   72105.558270   90826.487642   72557.000586\n",
+      "1  131502.044530  254356.806968  127718.667085\n",
+      "2  570222.488089  570222.488089  570222.488089\n",
+      "3  327751.663204  937787.171831  272296.749924\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "n_goodman = sn_power_law.life(s_eq_goodman)\n",
+    "n_gerber = sn_power_law.life(s_eq_gerber)\n",
+    "n_swt = sn_power_law.life(s_eq_swt)\n",
+    "n_cycles = pd.DataFrame({'n_goodman': n_goodman, 'n_gerber': n_gerber, 'n_swt': n_swt})\n",
+    "print(n_cycles)\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(6, 4),dpi = 150)\n",
+    "ax.loglog(N, S_a, lw=2, color='C0')\n",
+    "ax.loglog([1e7, 5e7], [S_a[-1], S_a[-1]], 'C0--', lw=2, label='Endurance limit')\n",
+    "ax.scatter(n_gerber, sigma_eq['S_eq_gerber'], color='orange', marker='s', label='Gerber')\n",
+    "ax.scatter(n_goodman, sigma_eq['S_eq_goodman'], color='red', marker='^', label='Goodman')\n",
+    "ax.scatter(n_swt, sigma_eq['S_eq_swt'], color='green', marker='o', label='SWT')\n",
+    "ax.legend()\n",
+    "ax.set_xlabel('Cycles (N)')\n",
+    "ax.set_ylabel('Stress amplitude $\\\\sigma_a$ [MPa]')\n",
+    "ax.set_title('S–N curve (Wöhler power law)')\n",
+    "ax.grid(True, which='both', ls='--', alpha=0.6)\n",
+    "ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, _: f'{int(x)}'))\n",
+    "ax.set_yticks(np.arange(100, int(S_a.max()) + 100, 100))\n",
+    "plt.show()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "caf4d8e2",
+   "metadata": {},
+   "source": [
+    "## Damage cumulation using Palmgren-Miner's Elementary rule"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "0c397542",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def damage_cumulation_elementary(\n",
+    "    n_cycles: float,\n",
+    "    number_occurrences: int,\n",
+    ") -> float:\n",
+    "    r\"\"\"Elementary version of Palmgren-Miner linear damage accumulation.\n",
+    "\n",
+    "    The same slope k of the S-N curve below and above the fatigue limit.\n",
+    "\n",
+    "    ??? abstract \"Math Equations\"\n",
+    "        $$\n",
+    "        D = n/N\n",
+    "        $$\n",
+    "\n",
+    "    \"\"\"\n",
+    "\n",
+    "    damage: float = number_occurrences / n_cycles\n",
+    "\n",
+    "    return damage\n",
+    "\n",
+    "def palmgren_miner_elementary(\n",
+    "    slope_k: float,\n",
+    "    constant: float,\n",
+    "    sig: float,\n",
+    "    number_occurrences: int,\n",
+    ") -> float:\n",
+    "    r\"\"\"Elementary version of Palmgren-Miner linear damage accumulation.\n",
+    "\n",
+    "    The same slope k of the S-N curve below and above the fatigue limit.\n",
+    "\n",
+    "    ??? abstract \"Math Equations\"\n",
+    "        $$\n",
+    "        D = n/N = n\\,\\frac{\\sigma^k}{C}\n",
+    "        $$\n",
+    "\n",
+    "    \"\"\"\n",
+    "    total_occurrences: float = constant / sig**slope_k\n",
+    "\n",
+    "    damage: float = number_occurrences / total_occurrences\n",
+    "\n",
+    "    return damage\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "a6be1256",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                       damage_goodman damage_gerber damage_swt\n",
+      "0                            0.000014      0.000011   0.000014\n",
+      "1                            0.000015      0.000008   0.000016\n",
+      "2                            0.000002      0.000002   0.000002\n",
+      "3                            0.000003      0.000001   0.000004\n",
+      "---                          --------      --------   --------\n",
+      "Sum                          0.000034      0.000022   0.000035\n",
+      "Sequences till failure          29513         46097      28679\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "damage_goodman = damage_cumulation_elementary(n_goodman, cycles['n'])\n",
+    "damage_gerber = damage_cumulation_elementary(n_gerber, cycles['n'])\n",
+    "damage_swt = damage_cumulation_elementary(n_swt, cycles['n'])\n",
+    "damage = pd.DataFrame({'damage_goodman': damage_goodman, 'damage_gerber': damage_gerber, 'damage_swt': damage_swt})\n",
+    "\n",
+    "total_damage = damage.sum().rename(\"Total damage\")\n",
+    "sec_till_failure = (1 / total_damage).astype(int)\n",
+    "damage.loc[\"---\"] = \"--------\"\n",
+    "damage.loc[\"Sum\"] = total_damage\n",
+    "damage.loc[\"Sequences till failure\"] = sec_till_failure\n",
+    "\n",
+    "print(damage)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a5c9ab2",
+   "metadata": {},
+   "source": [
+    "## Workflow using FatPy\n",
+    "\n",
+    "### Part 1: Stress History Processing\n",
+    "\n",
+    "```mermaid\n",
+    "%%{init: {'flowchart': {'curve': 'linear'}, 'theme': 'base', 'themeVariables': { 'primaryColor':'#1e1e1e', 'primaryBorderColor':'#464646', 'primaryTextColor':'#e0e0e0', 'lineColor':'#888888', 'secondaryColor':'#2d2d2d', 'tertiaryColor':'#3d3d3d'}}}%%\n",
+    "flowchart LR\n",
+    "    A([\"Define Stress<br/>History\"]) --> B[\"Rainflow<br/>Algorithm\"]\n",
+    "    B --> C[\"Extracted<br/>σ_min, σ_max\"]\n",
+    "    C --> D[\"Stress<br/>Amplitudes\"]\n",
+    "    C --> E[\"Mean<br/>Stresses\"]\n",
+    "    D --> V[\"Validity<br/>Check\"]\n",
+    "    E --> V\n",
+    "    \n",
+    "    MD([\"Material<br/>Data\"]) -.-> F\n",
+    "    \n",
+    "    V --> F{{\"Mean Stress<br/>Correction\"}}\n",
+    "    F -->F1[\"Goodman\"]\n",
+    "    F -->F2[\"Gerber\"]\n",
+    "    F -->F3[\"SWT\"]\n",
+    "    F -->F4[\"Other\"]\n",
+    "    F1 --> G[(\"S-N Curve\")]\n",
+    "    F2 --> G\n",
+    "    F3 --> G\n",
+    "    F4 --> G\n",
+    "    G --> NC([\"N Cycles\"])\n",
+    "    \n",
+    "    style A fill:#6a1b9a,stroke:#9c27b0,color:#fff\n",
+    "    style B fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style C fill:#808080,stroke:#a9a9a9,color:#fff\n",
+    "    style D fill:#808080,stroke:#a9a9a9,color:#fff\n",
+    "    style E fill:#808080,stroke:#a9a9a9,color:#fff\n",
+    "    style V fill:#d32f2f,stroke:#f44336,color:#fff\n",
+    "    style MD fill:#6a1b9a,stroke:#9c27b0,color:#fff\n",
+    "    style F fill:#f57f17,stroke:#ffa726,color:#fff\n",
+    "    style F1 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style F2 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style F3 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style F4 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style G fill:#8b6f47,stroke:#b8956a,color:#fff\n",
+    "    style NC fill:#2e7d32,stroke:#81c784,color:#fff\n",
+    "```\n",
+    "\n",
+    "### Part 2: S-N Curve Definition & Damage Calculation\n",
+    "\n",
+    "```mermaid\n",
+    "%%{init: {'flowchart': {'curve': 'linear'}, 'theme': 'base', 'themeVariables': { 'primaryColor':'#1e1e1e', 'primaryBorderColor':'#464646', 'primaryTextColor':'#e0e0e0', 'lineColor':'#888888', 'secondaryColor':'#2d2d2d', 'tertiaryColor':'#3d3d3d'}}}%%\n",
+    "flowchart LR\n",
+    "    EMS([\"Equivalent<br/>Mean Stress\"]) -.-> NC([\"N Cycles\"])\n",
+    "    \n",
+    "    A([\"Define Material<br/>Parameters\"]) --> B{{\"S-N Curve<br/>Model\"}}\n",
+    "    B -->B1[\"Power Law\"]\n",
+    "    B -->B2[\"Kohout & Věchet\"]\n",
+    "    B -->B3[\"Other\"]\n",
+    "    B1 --> G[(\"S-N Curve\")]\n",
+    "    B2 --> G\n",
+    "    B3 --> G\n",
+    "    G --> NC\n",
+    "    \n",
+    "    NC --> DC{{\"Damage<br/>Cumulation\"}}\n",
+    "    DC -->DC1[\"Palmgren-Miner<br/>Basic\"]\n",
+    "    DC -->DC2[\"Palmgren-Miner<br/>Elementary\"]\n",
+    "    DC -->DC3[\"Palmgren-Miner<br/>Haibach\"]\n",
+    "    DC -->DC4[\"Other\"]\n",
+    "    DC1 --> I([\"Sum Total<br/>Damage\"])\n",
+    "    DC2 --> I\n",
+    "    DC3 --> I\n",
+    "    DC4 --> I\n",
+    "    \n",
+    "    I --> J([\"Sequences till<br/>Failure\"])\n",
+    "\n",
+    "    \n",
+    "    style EMS fill:#6a1b9a,stroke:#9c27b0,color:#fff\n",
+    "    style A fill:#6a1b9a,stroke:#9c27b0,color:#fff\n",
+    "    style B fill:#f57f17,stroke:#ffa726,color:#fff\n",
+    "    style B1 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style B2 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style B3 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style G fill:#8b6f47,stroke:#b8956a,color:#fff\n",
+    "    style NC fill:#2e7d32,stroke:#81c784,color:#fff\n",
+    "    style DC fill:#f57f17,stroke:#ffa726,color:#fff\n",
+    "    style DC1 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style DC2 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style DC3 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style DC4 fill:#1565c0,stroke:#42a5f5,color:#fff\n",
+    "    style I fill:#2e7d32,stroke:#81c784,color:#fff\n",
+    "    style J fill:#2e7d32,stroke:#81c784,color:#fff\n",
+    "```\n",
+    "\n",
+    "**Legend:**\n",
+    "- **Blue blocks**: FatPy functions\n",
+    "- **Brown rounded block**: Data structure (S-N Curve)\n",
+    "- **Purple rounded blocks**: Input data\n",
+    "- **Gray blocks**: Generic operations or custom implementations\n",
+    "- **Red block**: Validation/Check\n",
+    "- **Green block**: Resulting data\n",
+    "- **Orange diamonds**: Decision/selection points\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "841dd150",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   n  sigma_min  sigma_max  mean_stress  stress_amp\n",
+      "0  1     -400.0      500.0         50.0       450.0\n",
+      "1  2     -200.0      500.0        150.0       350.0\n",
+      "2  1     -400.0      200.0       -100.0       300.0\n",
+      "3  1        0.0      500.0        250.0       250.0\n",
+      "\n",
+      "\n",
+      "   S_eq_goodman  S_eq_gerber    S_eq_swt\n",
+      "0    475.000000   451.250000  474.341649\n",
+      "1    415.625000   358.948864  418.330013\n",
+      "2    300.000000   300.000000  300.000000\n",
+      "3    339.285714   268.601190  353.553391\n",
+      "\n",
+      "\n",
+      "       n_goodman       n_gerber          n_swt\n",
+      "0   72105.558270   90826.487642   72557.000586\n",
+      "1  131502.044530  254356.806968  127718.667085\n",
+      "2  570222.488089  570222.488089  570222.488089\n",
+      "3  327751.663204  937787.171831  272296.749924\n",
+      "\n",
+      "\n",
+      "                       damage_goodman damage_gerber damage_swt\n",
+      "0                            0.000014      0.000011   0.000014\n",
+      "1                            0.000015      0.000008   0.000016\n",
+      "2                            0.000002      0.000002   0.000002\n",
+      "3                            0.000003      0.000001   0.000004\n",
+      "---                          --------      --------   --------\n",
+      "Sum                          0.000034      0.000022   0.000035\n",
+      "Sequences till failure          29513         46097      28679\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import fatpy\n",
+    "from src.fatpy.core.stress_life.damage_params import uniaxial_stress_eq_amp as eq_amp\n",
+    "# from src.fatpy.material_laws import sn_curve\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Material data\n",
+    "ULT_TENSILE_STRENGTH = 950.0\n",
+    "POWER_LAW_COEF = 8e16\n",
+    "POWER_LAW_EXP = 4.5\n",
+    "\n",
+    "# Stress history input (MPa)\n",
+    "stress_history = np.array([500, -200, 500, -400, 200, -400, 500, -200, 500, 0, 500 ], dtype=float)\n",
+    "\n",
+    "#TODO: rainflow_res = fatpy.rainflow.count_cycles(stress_history)\n",
+    "rainflow_res = [\n",
+    "    (1, -400.0, 500.0),\n",
+    "    (2, -200.0, 500.0),\n",
+    "    (1, -400.0, 200.0),\n",
+    "    (1,    0.0, 500.0),\n",
+    "]\n",
+    "rainflow_res = np.array(rainflow_res, dtype=[('n', 'i4'), ('sigma_min', 'f8'), ('sigma_max', 'f8')])\n",
+    "\n",
+    "# Mean stress and stress amplitude calculation\n",
+    "mean_stress = (rainflow_res['sigma_max'] + rainflow_res['sigma_min']) / 2.0\n",
+    "stress_amp = (rainflow_res['sigma_max'] - rainflow_res['sigma_min']) / 2.0\n",
+    "\n",
+    "dtype_sequences = [('n', 'i4'), ('sigma_min', 'f8'), ('sigma_max', 'f8'), ('mean_stress', 'f8'), ('stress_amp', 'f8')]\n",
+    "sequences = np.zeros(rainflow_res.shape, dtype=dtype_sequences)\n",
+    "for name in ['n', 'sigma_min', 'sigma_max']:\n",
+    "    sequences[name] = rainflow_res[name]\n",
+    "sequences['stress_amp'] = stress_amp\n",
+    "sequences['mean_stress'] = mean_stress\n",
+    "print(pd.DataFrame(sequences))\n",
+    "print(\"\\n\")\n",
+    "\n",
+    "# Mean stress correction to equivalent stress amplitude\n",
+    "s_eq_goodman = eq_amp.calc_stress_eq_amp_goodman(sequences['stress_amp'], sequences['mean_stress'], ULT_TENSILE_STRENGTH, allow_neg_mean_stress=False)\n",
+    "s_eq_gerber = eq_amp.calc_stress_eq_amp_gerber(sequences['stress_amp'], sequences['mean_stress'], ULT_TENSILE_STRENGTH, allow_neg_mean_stress=False)\n",
+    "s_eq_swt = eq_amp.calc_stress_eq_amp_swt(sequences['stress_amp'], sequences['mean_stress'], allow_neg_mean_stress=False)\n",
+    "print(pd.DataFrame({'S_eq_goodman': s_eq_goodman, 'S_eq_gerber': s_eq_gerber, 'S_eq_swt': s_eq_swt}))\n",
+    "print(\"\\n\")\n",
+    "\n",
+    "# S-N curve model initialization\n",
+    "# TODO: sn_curve_model = sn_curve.WholerPowerLaw(POWER_LAW_COEF, POWER_LAW_EXP)\n",
+    "sn_power_law = PowerLaw(POWER_LAW_COEF, POWER_LAW_EXP)\n",
+    "\n",
+    "# Fatigue life calculation from equivalent stress amplitude\n",
+    "n_goodman = sn_power_law.life(s_eq_goodman)\n",
+    "n_gerber = sn_power_law.life(s_eq_gerber)\n",
+    "n_swt = sn_power_law.life(s_eq_swt)\n",
+    "print(pd.DataFrame({'n_goodman': n_goodman, 'n_gerber': n_gerber, 'n_swt': n_swt}))\n",
+    "print(\"\\n\")\n",
+    "\n",
+    "# Damage accumulation using Palmgren-Miner elementary rule\n",
+    "damage_goodman = palmgren_miner_elementary(POWER_LAW_EXP, POWER_LAW_COEF, s_eq_goodman, sequences['n'])\n",
+    "damage_gerber = palmgren_miner_elementary(POWER_LAW_EXP, POWER_LAW_COEF, s_eq_gerber, sequences['n'])\n",
+    "damage_swt = palmgren_miner_elementary(POWER_LAW_EXP, POWER_LAW_COEF, s_eq_swt, sequences['n'])\n",
+    "\n",
+    "damage = pd.DataFrame({'damage_goodman': damage_goodman, 'damage_gerber': damage_gerber, 'damage_swt': damage_swt})\n",
+    "\n",
+    "total_damage = damage.sum().rename(\"Total damage\")\n",
+    "sec_till_failure = (1 / total_damage).astype(int)\n",
+    "damage.loc[\"---\"] = \"--------\"\n",
+    "damage.loc[\"Sum\"] = total_damage\n",
+    "damage.loc[\"Sequences till failure\"] = sec_till_failure\n",
+    "\n",
+    "print(damage)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "FatPy (3.12.8)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/fatpy/material_laws/sn_curve.py b/src/fatpy/material_laws/sn_curve.py
index bfc9709..0133f9a 100644
--- a/src/fatpy/material_laws/sn_curve.py
+++ b/src/fatpy/material_laws/sn_curve.py
@@ -3,3 +3,337 @@
 Provides implementations of Wöhler (S-N) curve models along with methods for converting
 between stress amplitude and fatigue life in both directions.
 """
+
+import warnings
+from abc import ABC, abstractmethod
+
+import numpy as np
+from numpy.typing import ArrayLike
+
+def _power_law():
+    pass
+
+
+class SN_Curve(ABC):
+    """Abstract base class for stress-life (S-N) curve models.
+    
+    Parameters:
+    - data_points
+    - log N - standard deviation
+    - log S - standard deviation
+    - T - T-score/ratio
+
+    """
+
+    def __init__(self) -> None:
+        self._data_points = np.asarray([])
+        self._standard_dev_log_N = float
+        self._S_log_S = float
+        self._T = float
+        self._SN_curve_params = dict()
+
+    @property
+    def data_points(self) -> ArrayLike:
+        """Return calibration data points used by the model."""
+    pass
+
+    @property
+    def S_log_N(self) -> ArrayLike:
+        """Return equivalent stress values at N cycles used by the model."""
+    pass
+
+    @property.setter
+    def S_log_N(self, value: float) -> None:
+        # added functionality for setting the property (like value checking)
+        pass
+
+
+    @property
+    def S_log_S(self) -> ArrayLike:
+        """Return equivalent stress values at N cycles used by the model."""
+    pass
+
+    @property
+    def T(self) -> ArrayLike:
+        """Return equivalent stress values at N cycles used by the model."""
+    pass
+
+    @property
+    @abstractmethod
+    def SN_curve_params(self,param_1,param_2,probability=50):
+        # self._SN_curve_params.append("probability",[param1,param2])
+        # ("50",[C,w])
+        # ("5",[param1,param2])
+        #("95",[param1,param2])
+    pass
+
+    # Usecase:
+    # sn_curve_object.get_life(stress,probability = 50) -> life at given probability
+
+    @abstractmethod
+    def get_stress(self, n_cycles: ArrayLike, probability: float = 50) -> ArrayLike:
+        """Calculate stress from fatigue life.
+
+        Parameters:
+        n_cycles : ArrayLike
+            The fatigue life (N) in cycles.
+
+        Returns:
+        ArrayLike
+            The calculated stress amplitude (σ_a) in MPa.
+        """
+        pass
+
+    @abstractmethod
+    def get_life(self, stress: ArrayLike, probability:float=50) -> ArrayLike:
+        """Calculate fatigue life from stress amplitude.
+
+        Parameters:
+        stress_amp : ArrayLike
+            The stress (σ) in MPa.
+
+        Returns:
+        ArrayLike
+            The calculated fatigue life (N) in cycles.
+        """
+        pass
+
+    @abstractmethod
+    def least_square_curve_fitting(self,n_iterations , eps) -> None:
+        # it should update the self._SN_curve_params (or rather call the method for updating)
+        pass
+
+    @abstractmethod
+    def get_params_at_probability(self, new_probability)-> None:
+        # 1. check if the probability is already there
+        # what is the result
+        pass
+
+    @abstractmethod
+    def plot_SN_curve(self, probability=50,ranges_for_x_and_y)
+        pass
+
+class WholerPowerLaw(SN_Curve):
+    """Wöhler (S-N) curve model using a power law relationship."""
+
+    def __init__(self) -> None:
+        """Initialize the Wöhler power law model.
+
+        Parameters:
+        power_law_coef : float
+            Material constant representing the power law coefficient (MPa^power_law_exp).
+        power_law_exp : float
+            Material constant representing the power law exponent.
+
+        Raises:
+        ValueError
+            If any parameter is not positive.
+        """
+        super().__init__()
+
+        if power_law_coef <= 0:
+            raise ValueError(f"power_law_coef must be positive, got {power_law_coef}")
+        if power_law_exp <= 0:
+            raise ValueError(f"power_law_exp must be positive, got {power_law_exp}")
+
+        self.power_law_coef = power_law_coef
+        self.power_law_exp = power_law_exp
+        self._data_points = np.asarray([] if data_points is None else data_points)
+        self._S_eqN = np.asarray([] if S_eqN is None else S_eqN)
+
+    def stress_amp(self, n_cycles: ArrayLike) -> ArrayLike:
+        """Calculate stress amplitude from fatigue life using the Wöhler power law.
+
+        Parameters:
+        n_cycles : ArrayLike
+            The fatigue life (N) in cycles. Must be positive.
+
+        Returns:
+        ArrayLike
+            The calculated stress amplitude (σ_a) in MPa.
+
+        Raises:
+        ValueError
+            If n_cycles contains non-positive values.
+        """
+        n_cycles_array = np.asarray(n_cycles)
+        if np.any(n_cycles_array <= 0):
+            raise ValueError("n_cycles must contain only positive values")
+
+        return (self.power_law_coef / n_cycles_array) ** (1 / self.power_law_exp)
+
+    def life(self, stress_amp: ArrayLike) -> ArrayLike:
+        """Calculate fatigue life from stress amplitude using the Wöhler power law.
+
+        Parameters:
+        stress_amp : ArrayLike
+            The stress amplitude (σ_a) in MPa. Must be positive.
+
+        Returns:
+        ArrayLike
+            The calculated fatigue life (N) in cycles.
+
+        Raises:
+        ValueError
+            If stress_amp contains non-positive values.
+        """
+        stress_amp_array = np.asarray(stress_amp)
+        if np.any(stress_amp_array <= 0):
+            raise ValueError("stress_amp must contain only positive values")
+
+        return self.SN_C / (stress_amp**self.SN_w)
+
+
+class WohlerKohoutVechet(SN_Curve):
+    """Wöhler S-N curve model using the Kohout-Věchet method.
+
+    This model uses a more sophisticated relationship that accounts for
+    the asymptotic behavior of S-N curves at high cycle counts.
+    """
+
+    def __init__(self, A: float, B: float, C: float, beta: float):
+        """Initialize the Kohout-Věchet S-N curve model.
+
+        Parameters:
+        A : float
+            Material constant representing the stress amplitude scaling factor.
+        B : float
+            Material constant representing the life offset parameter.
+        C : float
+            Material constant representing the asymptotic life parameter.
+        beta : float
+            Material constant representing the power law exponent.
+
+        Raises:
+        ValueError
+            If A, B, C parameters are not positive or if beta is not negative.
+        """
+        if A <= 0:
+            raise ValueError(f"A must be positive, got {A}")
+        if B <= 0:
+            raise ValueError(f"B must be positive, got {B}")
+        if C <= 0:
+            raise ValueError(f"C must be positive, got {C}")
+        if beta >= 0:
+            raise ValueError(f"beta must be negative, got {beta}")
+
+        self.A = A
+        self.B = B
+        self.C = C
+        self.beta = beta
+
+    def stress_amp(self, life: ArrayLike) -> ArrayLike:
+        """Calculate stress amplitude from fatigue life using Kohout-Věchet method.
+
+        ??? abstract "Math Equations"
+            Uses the forward relationship:
+            σ_a = A * (C * (N + B) / (N + C))^β
+
+        Parameters:
+        life : ArrayLike
+            The fatigue life (N) in cycles. Must be positive.
+
+        Returns:
+        ArrayLike
+            The calculated stress amplitude (σ_a) in MPa.
+
+        Raises:
+        ValueError
+            If life contains non-positive values.
+        """
+        life_array = np.asarray(life)
+        if np.any(life_array <= 0):
+            raise ValueError("life must contain only positive values")
+
+        stress_amp = (
+            self.A
+            * (self.C * ((life_array + self.B) / (life_array + self.C))) ** self.beta
+        )
+
+        return stress_amp
+
+    def life(
+        self,
+        stress_amp: ArrayLike,
+        max_iterations: int = 100,
+        tolerance: float = 1e-6,
+        start_life_guess: float = 1e5,
+    ) -> ArrayLike:
+        """Calculate fatigue life from stress amplitude using Newton solver.
+
+        ??? abstract "Math Equations"
+            Uses a vectorized Newton solver to find the inverse of:
+            σ_a = A * (C * (N + B) / (N + C))^β
+
+        Parameters:
+        stress_amp : ArrayLike
+            The stress amplitude (σ_a) in MPa. Must be positive.
+        max_iterations : int, optional
+            Maximum number of Newton iterations. Default is 100.
+        tolerance : float, optional
+            Tolerance for convergence. Default is 1e-6.
+        start_life_guess : float, optional
+            Initial guess for the fatigue life. Default is 1e5.
+
+        Returns:
+        ArrayLike
+            The calculated fatigue life (N) in cycles.
+
+        Raises:
+        ValueError
+            If stress_amp contains non-positive values.
+        """
+        stress_amp_array = np.asarray(stress_amp)
+        if np.any(stress_amp_array <= 0):
+            raise ValueError("stress_amp must contain only positive values")
+
+        # Initialize solution array with starting guess
+        N = np.full_like(stress_amp_array, start_life_guess, dtype=np.float64)
+
+        # Pre-calculate constants
+        derivative_constant = self.A * self.beta * (self.C**self.beta)
+
+        converged = False
+        for _ in range(max_iterations):
+            # Calculate function value f(N) = A * (C*(N+B)/(N+C))^β - σ_a
+            f_N = (
+                self.A * (self.C * (N + self.B) / (N + self.C)) ** self.beta
+                - stress_amp_array
+            )
+
+            # Calculate derivative f'(N) = A*β*C^β*(N+B)^(β-1)*(C-B)/(N+C)^(β+1)
+            f_prime_N = (
+                derivative_constant
+                * ((N + self.B) ** (self.beta - 1))
+                * (self.C - self.B)
+            ) / ((N + self.C) ** (self.beta + 1))
+
+            # Avoid division by zero
+            f_prime_N = np.where(np.abs(f_prime_N) < 1e-15, 1e-15, f_prime_N)
+            # TODO limits based on float type or catch the case where derivative is zero, ie. B=C should B<C checked since the KV model expects it?
+
+            # Newton update
+            N_new = N - f_N / f_prime_N
+
+            # TODO Clamp negative values to small positive number
+            N_new = np.maximum(N_new, 1.0)
+
+            # Check convergence
+            relative_change = np.abs((N_new - N) / np.maximum(N, 1e-15))
+            if np.all(relative_change < tolerance):
+                converged = True
+                break
+
+            N = N_new
+
+        # Issue warning if Newton solver did not converge
+        if not converged:
+            warnings.warn(
+                f"Newton solver did not converge after {max_iterations} "
+                f"iterations. Results may be inaccurate. Consider adjusting "
+                f"tolerance or max_iterations.",
+                RuntimeWarning,
+                stacklevel=2,
+            )
+
+        return N
diff --git a/stress_history_rotated.png b/stress_history_rotated.png
new file mode 100644
index 0000000..38274d0
Binary files /dev/null and b/stress_history_rotated.png differ
diff --git a/stress_history_rotated_solved.png b/stress_history_rotated_solved.png
new file mode 100644
index 0000000..33d1fab
Binary files /dev/null and b/stress_history_rotated_solved.png differ
diff --git a/test.csv b/test.csv
new file mode 100644
index 0000000..4233862
--- /dev/null
+++ b/test.csv
@@ -0,0 +1,2 @@
+stress, cycles, damage
+100, 50, 10,
\ No newline at end of file
diff --git a/tests/material_laws/test_sn_curve.py b/tests/material_laws/test_sn_curve.py
new file mode 100644
index 0000000..9f5177c
--- /dev/null
+++ b/tests/material_laws/test_sn_curve.py
@@ -0,0 +1,455 @@
+"""Tests for S-N curve implementations.
+
+This module tests the implementation of S-N curve models for fatigue analysis.
+The tests verify:
+    1. Correct mathematical implementation of the S-N curve models
+    2. Inverse relationship between stress amplitude and fatigue life calculations
+    3. Proper handling of different input types (scalars and arrays)
+    4. Parameter and input validation
+    5. Numerical accuracy and edge case behavior
+"""
+
+import numpy as np
+import pytest
+from numpy.typing import ArrayLike, NDArray
+
+from fatpy.material_laws.sn_curve import WholerPowerLaw, WohlerKohoutVechet
+
+
+@pytest.fixture
+def sn_curve_sample() -> WholerPowerLaw:
+    """Fixture providing a sample Wöhler power law S-N curve model.
+
+    Returns:
+        WholerPowerLaw: S-N curve with material parameters C=2.2e13 MPa^3, w=3.
+    """
+    return WholerPowerLaw(SN_C=2.2e13, SN_w=3.0)
+
+
+@pytest.fixture
+def sn_curve_negative_constants() -> dict:
+    """Fixture providing negative constants for WholerPowerLaw parameter validation.
+
+    Returns:
+        dict: Dictionary with negative parameter combinations for testing validation.
+    """
+    return {
+        "negative_C": {"SN_C": -2.2e13, "SN_w": 3.0},
+        "negative_w": {"SN_C": 2.2e13, "SN_w": -3.0},
+        "both_negative": {"SN_C": -2.2e13, "SN_w": -3.0},
+        "zero_C": {"SN_C": 0.0, "SN_w": 3.0},
+        "zero_w": {"SN_C": 2.2e13, "SN_w": 0.0},
+    }
+
+
+@pytest.fixture
+def stress_amp_sample() -> NDArray[np.float64]:
+    """Fixture providing sample stress amplitudes for testing.
+
+    Returns:
+        NDArray[np.float64]: Array of stress amplitudes in MPa.
+    """
+    return np.array([100.0, 200.0, 300.0, 400.0, 500.0], dtype=np.float64)
+
+
+@pytest.fixture
+def life_sample() -> NDArray[np.float64]:
+    """Fixture providing sample fatigue lives corresponding to stress_amp_sample.
+
+    Returns:
+        NDArray[np.float64]: Array of fatigue lives in cycles.
+    """
+    # Calculated using N = C / σ_a^w with C=2.2e13, w=3
+    return np.array(
+        [22000000.0, 2750000.0, 814814.8, 343750.0, 176000.0], dtype=np.float64
+    )
+
+
+@pytest.fixture
+def kohout_vechet_sample() -> WohlerKohoutVechet:
+    """Fixture providing a sample Kohout-Věchet S-N curve model.
+
+    Returns:
+        WohlerKohoutVechet: S-N curve with validation material parameters.
+    """
+    return WohlerKohoutVechet(A=16651.6, B=7214.0, C=960478.0, beta=-0.351)
+
+
+@pytest.fixture
+def kohout_negative_constants() -> dict:
+    """Fixture providing negative constants for WohlerKohoutVechet parameter validation.
+
+    Returns:
+        dict: Dictionary with invalid parameter combinations for testing validation.
+    """
+    return {
+        "negative_A": {"A": -16651.6, "B": 7214.0, "C": 960478.0, "beta": -0.351},
+        "negative_B": {"A": 16651.6, "B": -7214.0, "C": 960478.0, "beta": -0.351},
+        "negative_C": {"A": 16651.6, "B": 7214.0, "C": -960478.0, "beta": -0.351},
+        "positive_beta": {"A": 16651.6, "B": 7214.0, "C": 960478.0, "beta": 0.351},
+        "zero_A": {"A": 0.0, "B": 7214.0, "C": 960478.0, "beta": -0.351},
+        "zero_B": {"A": 16651.6, "B": 0.0, "C": 960478.0, "beta": -0.351},
+        "zero_C": {"A": 16651.6, "B": 7214.0, "C": 0.0, "beta": -0.351},
+        "zero_beta": {"A": 16651.6, "B": 7214.0, "C": 960478.0, "beta": 0.0},
+    }
+
+
+@pytest.fixture
+def invalid_input_samples() -> list[ArrayLike]:
+    """Fixture providing invalid input samples for testing input validation.
+
+    Returns:
+        list[ArrayLike]: List of invalid input values (negative, zero, mixed).
+    """
+    return [
+        np.array([-1.0, 2.0, 3.0]),  # negative value
+        np.array([0.0, 2.0, 3.0]),  # zero value
+        np.array([1.0, -2.0, 3.0]),  # negative in middle
+        -5.0,  # scalar negative
+        0.0,  # scalar zero
+    ]
+
+
+@pytest.fixture
+def kohout_stress_amp_sample() -> NDArray[np.float64]:
+    """Fixture providing validation stress amplitudes for Kohout-Věchet testing.
+
+    Returns:
+        NDArray[np.float64]: Array of stress amplitudes in MPa from validation data.
+    """
+    # Calculated using material constants: A=16651.6, B=7214.0, C=960478.0, beta=-0.351
+
+    return np.array(
+        [
+            704.0539,  # 1000 cycles
+            613.4234,  # 5000 cycles
+            544.8041,  # 10000 cycles
+            465.5705,  # 20000 cycles
+            400.0713,  # 35360 cycles
+            362.5004,  # 50000 cycles
+            295.7574,  # 100000 cycles
+            242.2297,  # 200000 cycles
+            191.7867,  # 500000 cycles
+            167.1576,  # 1000000 cycles
+            140.6593,  # 5000000 cycles
+            136.607,  # 10000000 cycles
+            133.193,  # 50000000 cycles
+        ],
+        dtype=np.float64,
+    )
+
+
+@pytest.fixture
+def kohout_life_sample() -> NDArray[np.float64]:
+    """Fixture providing validation fatigue lives for Kohout-Věchet testing.
+
+    Returns:
+        NDArray[np.float64]: Array of fatigue lives in cycles from validation data.
+    """
+    return np.array(
+        [
+            1000,
+            5000,
+            10000,
+            20000,
+            35360,
+            50000,
+            100000,
+            200000,
+            500000,
+            1000000,
+            5000000,
+            10000000,
+            50000000,
+        ],
+        dtype=np.float64,
+    )
+
+
+class TestWholerPowerLaw:
+    """Test cases for the Wöhler power law S-N curve model."""
+
+    def test_life_calculation_scalar(
+        self,
+        sn_curve_sample: WholerPowerLaw,
+    ) -> None:
+        """Test fatigue life calculation with scalar stress amplitude input.
+
+        Uses the reference case: σ_a = 300 MPa should give N ≈ 814,815 cycles.
+        """
+        stress_amp = 300.0  # MPa
+        expected_life = 814814.815  # cycles (more precise value)
+
+        calculated_life = np.asarray(sn_curve_sample.life(stress_amp))
+
+        np.testing.assert_allclose(calculated_life, expected_life, rtol=1e-6)
+
+    def test_stress_amp_calculation_scalar(
+        self,
+        sn_curve_sample: WholerPowerLaw,
+    ) -> None:
+        """Test stress amplitude calculation with scalar fatigue life input.
+
+        Uses the reference case: N ≈ 814,814 cycles should give σ_a = 300 MPa.
+        """
+        life = 814814  # cycles
+        expected_stress_amp = 300.0  # MPa
+
+        calculated_stress_amp = np.asarray(sn_curve_sample.stress_amp(life))
+
+        np.testing.assert_allclose(
+            calculated_stress_amp, expected_stress_amp, rtol=1e-6
+        )
+
+    def test_inverse_relationship(
+        self,
+        sn_curve_sample: WholerPowerLaw,
+        stress_amp_sample: NDArray[np.float64],
+    ) -> None:
+        """Test that stress_amp and life methods are mathematically inverse.
+
+        Verifies the relationship: stress_amp(life(σ)) = σ for all stress values.
+
+        Args:
+            sn_curve_sample: S-N curve model fixture.
+            stress_amp_sample: Array of test stress amplitudes.
+        """
+        # Calculate life from stress, then stress from life
+        calculated_lives = sn_curve_sample.life(stress_amp_sample)
+        recovered_stress_amps = sn_curve_sample.stress_amp(calculated_lives)
+
+        # Should recover original stress amplitudes exactly
+        assert np.allclose(recovered_stress_amps, stress_amp_sample, rtol=1e-12)
+
+    def test_life_calculation_array(
+        self,
+        sn_curve_sample: WholerPowerLaw,
+        stress_amp_sample: NDArray[np.float64],
+        life_sample: NDArray[np.float64],
+    ) -> None:
+        """Test fatigue life calculation with array stress amplitude inputs.
+
+        Args:
+            sn_curve_sample: S-N curve model fixture.
+            stress_amp_sample: Array of test stress amplitudes.
+            life_sample: Expected fatigue lives corresponding to stress_amp_sample.
+        """
+        calculated_lives = np.asarray(sn_curve_sample.life(stress_amp_sample))
+        assert calculated_lives.shape == stress_amp_sample.shape
+        np.testing.assert_allclose(calculated_lives, life_sample, rtol=1e-5)
+
+    def test_stress_amp_calculation_array(
+        self,
+        sn_curve_sample: WholerPowerLaw,
+        stress_amp_sample: NDArray[np.float64],
+        life_sample: NDArray[np.float64],
+    ) -> None:
+        """Test stress amplitude calculation with array fatigue life inputs.
+
+        Args:
+            sn_curve_sample: S-N curve model fixture.
+            stress_amp_sample: Expected stress amplitudes.
+            life_sample: Array of test fatigue lives.
+        """
+        calculated_stress_amps = np.asarray(sn_curve_sample.stress_amp(life_sample))
+
+        assert calculated_stress_amps.shape == life_sample.shape
+        assert np.allclose(calculated_stress_amps, stress_amp_sample, rtol=1e-5)
+
+
+class TestWohlerKohoutVechet:
+    """Test cases for the Kohout-Věchet S-N curve model."""
+
+    def test_life_calculation_scalar(
+        self,
+        kohout_vechet_sample: WohlerKohoutVechet,
+    ) -> None:
+        """Test fatigue life calculation with scalar stress amplitude input.
+
+        Uses the reference validation case: σ_a = 400.0713 MPa → N = 35360 cycles.
+        """
+        stress_amp = 400.0713  # MPa
+        expected_life = 35360  # cycles
+
+        calculated_life = np.asarray(kohout_vechet_sample.life(stress_amp))
+
+        assert np.allclose(calculated_life, expected_life, rtol=1e-2)
+
+    def test_stress_amp_calculation_scalar(
+        self,
+        kohout_vechet_sample: WohlerKohoutVechet,
+    ) -> None:
+        """Test stress amplitude calculation with scalar fatigue life input.
+
+        Uses the reference validation case: N = 35360 cycles → σ_a = 400.0713 MPa.
+        """
+        life = 35360  # cycles
+        expected_stress_amp = 400.0713  # MPa (precise validation data)
+
+        calculated_stress_amp = np.asarray(kohout_vechet_sample.stress_amp(life))
+
+        assert np.allclose(calculated_stress_amp, expected_stress_amp, rtol=1e-6)
+
+    def test_inverse_relationship(
+        self,
+        kohout_vechet_sample: WohlerKohoutVechet,
+        kohout_stress_amp_sample: NDArray[np.float64],
+    ) -> None:
+        """Test that stress_amp and life methods are mathematically inverse.
+
+        Verifies the relationship: stress_amp(life(σ)) = σ for all stress values.
+
+        Args:
+            kohout_vechet_sample: Kohout-Věchet S-N curve model fixture.
+            kohout_stress_amp_sample: Array of validation stress amplitudes.
+        """
+        # Calculate life from stress, then stress from life
+        calculated_lives = np.asarray(
+            kohout_vechet_sample.life(kohout_stress_amp_sample)
+        )
+        recovered_stress_amps = np.asarray(
+            kohout_vechet_sample.stress_amp(calculated_lives)
+        )
+
+        # Should recover original stress amplitudes exactly
+        assert np.allclose(recovered_stress_amps, kohout_stress_amp_sample, rtol=1e-6)
+
+    def test_life_calculation_array(
+        self,
+        kohout_vechet_sample: WohlerKohoutVechet,
+        kohout_stress_amp_sample: NDArray[np.float64],
+        kohout_life_sample: NDArray[np.float64],
+    ) -> None:
+        """Test fatigue life calculation with array stress amplitude inputs.
+
+        Args:
+            kohout_vechet_sample: Kohout-Věchet S-N curve model fixture.
+            kohout_stress_amp_sample: Array of validation stress amplitudes.
+            kohout_life_sample: Expected fatigue lives from validation data.
+        """
+        calculated_lives = np.asarray(
+            kohout_vechet_sample.life(kohout_stress_amp_sample)
+        )
+
+        assert calculated_lives.shape == kohout_stress_amp_sample.shape
+        assert np.allclose(calculated_lives, kohout_life_sample, rtol=0.01)
+
+    def test_stress_amp_calculation_array(
+        self,
+        kohout_vechet_sample: WohlerKohoutVechet,
+        kohout_stress_amp_sample: NDArray[np.float64],
+        kohout_life_sample: NDArray[np.float64],
+    ) -> None:
+        """Test stress amplitude calculation with array fatigue life inputs.
+
+        Args:
+            kohout_vechet_sample: Kohout-Věchet S-N curve model fixture.
+            kohout_stress_amp_sample: Expected stress amplitudes from validation data.
+            kohout_life_sample: Array of validation fatigue lives.
+        """
+        calculated_stress_amps = np.asarray(
+            kohout_vechet_sample.stress_amp(kohout_life_sample)
+        )
+        assert calculated_stress_amps.shape == kohout_life_sample.shape
+        assert np.allclose(calculated_stress_amps, kohout_stress_amp_sample, rtol=1e-6)
+
+    def test_edge_cases(
+        self,
+        kohout_vechet_sample: WohlerKohoutVechet,
+    ) -> None:
+        """Test edge cases and boundary conditions for numerical stability."""
+        # Test with very high stress (low life) - ensures solver handles extreme values
+        high_stress = 800.0  # MPa
+        calculated_life = kohout_vechet_sample.life(high_stress)
+        assert np.all(calculated_life > 0)  # Should be positive
+
+        # Test with very low stress (high life) - ensures solver handles extreme values
+        low_stress = 50.0  # MPa
+        calculated_life = kohout_vechet_sample.life(low_stress)
+        assert np.all(calculated_life > 0)  # Should be positive
+
+
+class TestParameterValidation:
+    """Test parameter validation for S-N curve constructors."""
+
+    @pytest.mark.parametrize(
+        "params",
+        ["negative_C", "negative_w", "both_negative", "zero_C", "zero_w"],
+    )
+    def test_wholer_power_law_invalid_parameters(
+        self, sn_curve_negative_constants: dict, params: str
+    ) -> None:
+        """Test that WholerPowerLaw raises ValueError for invalid parameters.
+
+        Args:
+            sn_curve_negative_constants: Fixture with invalid parameter combinations.
+            params: Parameter combination key to test.
+        """
+        with pytest.raises(ValueError, match=r".* must be positive"):
+            WholerPowerLaw(**sn_curve_negative_constants[params])
+
+    @pytest.mark.parametrize(
+        "params",
+        [
+            "negative_A",
+            "negative_B",
+            "negative_C",
+            "positive_beta",
+            "zero_A",
+            "zero_B",
+            "zero_C",
+            "zero_beta",
+        ],
+    )
+    def test_kohout_vechet_invalid_parameters(
+        self, kohout_negative_constants: dict, params: str
+    ) -> None:
+        """Test that WohlerKohoutVechet raises ValueError for invalid parameters.
+
+        Args:
+            kohout_negative_constants: Fixture with invalid parameter combinations.
+            params: Parameter combination key to test.
+        """
+        with pytest.raises(ValueError, match=r".* must be (positive|negative)"):
+            WohlerKohoutVechet(**kohout_negative_constants[params])
+
+
+class TestInputValidation:
+    """Test input validation for S-N curve method parameters."""
+
+    @pytest.mark.parametrize(
+        "model_fixture,method_name",
+        [
+            ("sn_curve_sample", "stress_amp"),
+            ("sn_curve_sample", "life"),
+            ("kohout_vechet_sample", "stress_amp"),
+            ("kohout_vechet_sample", "life"),
+        ],
+    )
+    def test_invalid_input_validation(
+        self,
+        request: pytest.FixtureRequest,
+        model_fixture: str,
+        method_name: str,
+        invalid_input_samples: list[ArrayLike],
+    ) -> None:
+        """Test that all S-N curve methods raise ValueError for invalid inputs.
+
+        Args:
+            request: Pytest fixture request for dynamic fixture access.
+            model_fixture: Name of the S-N curve model fixture.
+            method_name: Name of the method to test ('stress_amp' or 'life').
+            invalid_input_samples: List of invalid input samples to test.
+        """
+        model = request.getfixturevalue(model_fixture)
+        method = getattr(model, method_name)
+
+        expected_message = (
+            "life must contain only positive values"
+            if method_name == "stress_amp"
+            else "stress_amp must contain only positive values"
+        )
+
+        for invalid_input in invalid_input_samples:
+            with pytest.raises(ValueError, match=expected_message):
+                method(invalid_input)
diff --git a/uniax_stress.py b/uniax_stress.py
new file mode 100644
index 0000000..487bc24
--- /dev/null
+++ b/uniax_stress.py
@@ -0,0 +1,29 @@
+import numpy as np
+
+from src.fatpy.core.stress_life.damage_params import uniaxial_stress_eq_amp as eq_amp
+
+# Mat params
+RE = 539.0
+RM = 706.0
+SF = 784
+M = 1168
+Y = 0.56
+
+stress_amp = 150.0
+
+mean_stress_arr_re = np.array([538.0, 538.5, 538.8, 538.9, 538.95, 538.99])
+mean_stress_arr_larger_re = np.array([540.0, 539.5, 539.2, 539.1, 539.05, 539.01])
+
+mean_stress_arr_rm = np.array([705.0, 705.5, 705.8, 705.9, 705.95, 705.99])
+mean_stress_arr_larger_rm = np.array([707.0, 706.5, 706.2, 706.1, 706.05, 706.01])
+
+mean_stress_arr_m = np.array([1166.0, 1167.5, 1167.8, 1167.9, 1167.95, 1167.99])
+mean_stress_arr_larger_m = np.array([1169.0, 1168.5, 1168.2, 1168.1, 1168.05, 1168.01])
+
+mean_stress_arr_sf = np.array([783.0, 783.5, 783.8, 783.9, 783.95, 783.99])
+mean_stress_arr_larger_sf = np.array([785.0, 784.5, 784.2, 784.1, 784.05, 784.01])
+
+
+for mean_stress in mean_stress_arr_re:
+    S_eq = eq_amp.calc_stress_eq_amp_swt(stress_amp, mean_stress)
+    print(f"mean_stress= {mean_stress:.2f}, S_eq= {S_eq:.2f}\n")