diffenix 0.0.0.1__py3-none-any.whl

diffenix/__init__.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+import numpy as np
+import sys
+import os
+from diffenix.Constantes import *
+
+if __name__ == '__main__':
+
+    from diffenix.time_integration import time_integration, restart
+    if len(sys.argv) > 1:
+        import os
+        if sys.argv[1] == "configs":
+            l = os.listdir("./configs")
+            l.sort()
+            if int(sys.argv[2]) < len(l):
+                params = dict(np.load("./configs/" + l[int(sys.argv[2])]))
+                print(int(sys.argv[2]), l[int(sys.argv[2])], params["Simulation"])
+                if not os.path.exists(results + "/" + params["Simulation"]):
+                    time_integration(consts_params=params)
+                # else:
+                #     restart(params["Simulation"], rtol=np.double(1e-4))
+        else:
+            print("argv :", sys.argv[1])
+            restart(int(sys.argv[1]), -1)
+    else:
+        time_integration()

diffenix/chemains.py

@@ -0,0 +1,110 @@
+import os
+import numpy as np
+
+# Defaults values
+
+racine: str = "."
+results: str = racine + "/Results"
+data_leiden: str = racine + "/Leiden_database/"
+data_stars: str = racine + "/data_stars/data_fus.npz"
+data_radmc: str = racine + "/data_radmc"
+
+
+def load_from_files(path_to_file: str = "paths.txt") -> None:
+    """
+
+    Load the path from a txt file
+
+    Parameters
+    ----------
+    path_to_file : str
+        The path to the txt file
+        One path per line, the delimiter between the name of path and the path is `,`
+        The names are racine, results, data_leiden and data_stars
+
+    Returns
+    -------
+    None
+
+    """
+    if not os.path.exists(path_to_file):
+        raise UserWarning("Constante.load_from_files : ", path_to_file, "does not exist")
+    global racine, results, data_leiden, data_stars, data_radmc
+
+    paths = dict(np.loadtxt("paths.txt", dtype=str, delimiter=","))
+    print("Paths : ", paths)
+    if "racine" in paths.keys():
+        if not os.path.exists(paths["racine"]):
+            raise UserWarning("Constante.load_from_files : ", paths["racine"], "does not exist")
+        if not os.path.isdir(paths["racine"]):
+            raise UserWarning("Constante.load_from_files : ", paths["racine"], "is not a directory")
+        racine = paths["racine"]
+
+    if "results" in paths.keys():
+        if not os.path.exists(paths["results"]) and not os.path.exists(racine + paths["results"]):
+            raise UserWarning("Constante.load_from_files : ", paths["results"], "does not exist")
+        if not os.path.isdir(paths["results"]) and not os.path.isdir(racine + paths["results"]):
+            raise UserWarning("Constante.load_from_files : ", paths["results"], "is not a directory")
+
+        if os.path.exists(paths["results"]):
+            results = paths["results"]
+        else:
+            results = racine + paths["results"]
+
+    if "data_leiden" in paths.keys():
+        if not os.path.exists(paths["data_leiden"]) and not os.path.exists(racine + paths["data_leiden"]):
+            raise UserWarning("Constante.load_from_files : ", paths["data_leiden"], "does not exist")
+        if not os.path.isdir(paths["data_leiden"]) and not os.path.isdir(racine + paths["data_leiden"]):
+            raise UserWarning("Constante.load_from_files : ", paths["data_leiden"], "is not a directory")
+
+        if os.path.exists(paths["data_leiden"]):
+            data_leiden = paths["data_leiden"]
+        else:
+            data_leiden = racine + paths["data_leiden"]
+
+    if "data_stars" in paths.keys():
+        if not os.path.exists(paths["data_stars"]) and not os.path.exists(racine + paths["data_stars"]):
+            raise UserWarning("Constante.load_from_files : ", paths["data_stars"], "does not exist")
+
+        if os.path.exists(paths["data_stars"]):
+            data_stars = paths["data_stars"]
+        else:
+            data_stars = racine + paths["data_stars"]
+
+    if "data_radmc" in paths.keys():
+        # if not os.path.exists(paths["data_radmc"]) and not os.path.exists(racine + paths["data_radmc"]):
+        #     raise UserWarning("Constante.load_from_files : ", paths["data_radmc"], "does not exist")
+
+        if os.path.exists(paths["data_radmc"]):
+            data_radmc = paths["data_radmc"]
+        else:
+            data_radmc = racine + paths["data_radmc"]
+
+
+if os.path.exists("./paths.txt"):
+    load_from_files("./paths.txt")
+    if not os.path.exists(racine):
+        raise UserWarning("Constante.load_from_files : ", racine, "does not exist")
+    if not os.path.isdir(racine):
+        raise UserWarning("Constante.load_from_files : ", racine, "is not a directory")
+
+    if not os.path.exists(results):
+        raise UserWarning("Constante.load_from_files : ", results, "does not exist")
+    if not os.path.isdir(results):
+        raise UserWarning("Constante.load_from_files : ", results, "is not a directory")
+
+    if not os.path.exists(data_stars):
+        print("User warning : no data to model the central star as been found. A constant luminosity will be assumed.")
+        # raise UserWarning("Constante.load_from_files : ", data_stars, "does not exist")
+
+    if not os.path.exists(data_leiden):
+        raise UserWarning("Constante.load_from_files : ", data_leiden, "does not exist")
+    if not os.path.isdir(data_leiden):
+        raise UserWarning("Constante.load_from_files : ", data_leiden, "is not a directory")
+
+    # if not os.path.exists(data_radmc):
+    #     raise UserWarning("Constante.load_from_files : ", data_radmc, "does not exist")
+    # if not os.path.isdir(data_radmc):
+    #     raise UserWarning("Constante.load_from_files : ", data_radmc, "is not a directory")
+else:
+    print("No path.txt file has been found. Working directory : ", os.getcwd())

diffenix/generation_configs.py

@@ -0,0 +1,146 @@
+import os.path
+
+import numpy as np
+from scipy.optimize import root
+from wx.py.editor import directory
+
+from diffenix.Constantes import *
+
+dic_ref: dict = {"racine": racine, "results": results,
+                 "C_L": C_L, "C_M": C_M, "C_t": C_t,
+                 "Ms": Msun, "Ts": np.double(5500.), "Rs": Rsun, "Ls": Lsun,
+                 "a_in": .05 * au, "a_out": 10 * a0, "a0": 2.65 * au,
+                 "T0": T0, "pls_temp": np.double(-1/2), "mH_init": zero,
+                 "alpha": np.double(1e-3), "gamma": np.double(1.),
+                 "AB_mdot_st_init": np.double(1e-10) * Mearth / Myr,
+                 "AB_Mbelt": np.double(0.12) * Mearth,
+                 "AB_Abelt": np.double(0.06),
+                 "AB_a0": np.double(2.65) * au, "AB_delta_r": np.double(2.65 / 2.) * au,
+                 "AB_K": np.double(1e-5 * C_L * C_L / C_t), "AB_Phi": np.double(0.6), "AB_rp": np.double(1e-6 * C_L),
+                 "AB_f_ice": np.double(0.2), "AB_rho_refr": np.double(2.5e3 * C_M / (C_L * C_L * C_L)) ,
+                 "AB_rho_ice": np.double(1.e3 * C_M / (C_L * C_L * C_L)), "AB_sublimation_model": "thermal_full",
+                 "AB_const_mdot": zero,
+                 "AB_SD_amax": np.double(1.e6) * C_L, "AB_SD_abig": np.double(120e3) * C_L,
+                 "AB_SD_amed": np.double(20.e3) * C_L, "AB_SD_amin": C_L,
+                 "AB_SD_qh": np.double(-4.5), "AB_SD_qm": np.double(-1.2), "AB_SD_ql": np.double(-3.6),
+                 "AB_sb":  np.double(316) * C_L, "AB_e": np.double(0.075), "AB_i": np.double(0.075 / 2.),
+                 "AB_As": np.double(5.) * C_E / C_M , "AB_bs": np.double(-0.1), "AB_bg": np.double(0.5),
+                 "AB_t0_diss": 150 * Myr, "AB_t1_diss": Myr,
+                 "KB_mdot_st_init": zero,
+                 "KB_Mbelt": np.double(0.01 * Mearth), "KB_Abelt": np.double(0.06),
+                 "KB_a0": np.double(44) * au, "KB_delta_r": np.double(8) * au,
+                 "KB_K": np.double(1e-10 * C_L * C_L / C_t), "KB_Phi": np.double(0.6), "KB_rp": np.double(1e-6 * C_L),
+                 "KB_f_ice": np.double(0.2), "KB_rho_refr": np.double(2.5e3 * C_M / (C_L * C_L * C_L)),
+                 "KB_rho_ice": np.double(1.e3 * C_M / (C_L * C_L * C_L)), "KB_sublimation_model": "none",
+                 "KB_const_mdot": zero,
+                 "KB_SD_amax": np.double(1.e6) * C_L, "KB_SD_abig": np.double(120e3) * C_L,
+                 "KB_SD_amed": np.double(20.e3) * C_L, "KB_SD_amin": C_L,
+                 "KB_SD_qh": np.double(-4.5), "KB_SD_qm": np.double(-1.2), "KB_SD_ql": np.double(-3.6),
+                 "KB_sb":  np.double(316) * C_L, "KB_e": np.double(0.075), "KB_i": np.double(0.075 / 2.),
+                 "KB_As": np.double(5.) * C_E / C_M, "KB_bs": np.double(-0.1), "KB_bg": np.double(0.5),
+                 "KB_t0_diss": np.double(10.) * Gyr, "KB_t1_diss": np.double(10.) * Gyr,
+                 "a_planets": np.array([au]), "m_planets": np.array([Mearth]), "f_accr": np.double(0.5),
+                 "t0": np.double(5. * Myr),
+                 "IT_s": 3000, "dip": 10, "rtol": np.double(1e-6), "atol": np.double(1e-250), "method_root": 'RK45',
+                 }
+
+
+def temp_ppd(r: np.ndarray[np.float64] | np.float64,
+             consts: dict, mdot: np.float64 = zero
+             ) -> np.float64 | np.ndarray[np.float64]:
+    """
+    The temperature of the protoplanetary disc
+    Parameters
+    ----------
+    r : np.float64 | np.ndarray[np.float64]
+        The distance to the central star
+    consts : dict
+        All the constants needed
+    mdot : np.float, optional, default=0
+        The accretion rate on the central star
+
+    Returns
+    -------
+    np.float64 | np.ndarray[np.float64]
+        The temperature of the protoplanetary disc at the dissipation time
+
+    """
+    C: np.float64 = 5  # Ratio between h the heigh at wich the disc became optically thick and Hz the typical scale-heigh
+    # asssumed to be a constant
+    # primordial disc protertys
+    M0 = 0.01 * Msun # total disc mass
+    r0 = 10 * au # reference radius
+    rout = 200 * au # outer radius
+    rin = 0. #inner radius
+    kappa_r = C_L * C_L / C_M  # Rosseland opacity
+    sigma0 = M0 / (2. * Pi * au * (r0 - rin + 2 * np.sqrt(au) * (np.sqrt(rout) - np.sqrt(r0))))
+    tau = np.zeros_like(r)
+    if isinstance(r, np.ndarray):
+        tau[r < r0] = kappa_r * sigma0 * (au / r[r < r0])
+        tau[r >= r0] = kappa_r * sigma0 * ((r[r >= r0] / au) ** (-3 / 2))
+    elif r < r0:
+        tau[r < r0] = kappa_r * sigma0 * (au / r)
+    else:
+        tau[r < r0] = kappa_r * sigma0 * ((r / au) ** (-3 / 2))
+
+    return ((0.2 * interpRs(consts["t0"], consts["Ms"]) / r
+            + (C / 7) * ((Rgp * consts["Rs"] / (G * consts["Ms"] * 2.33 * 1e-3 * C_M)) ** (4 / 7))
+            * ((interpLbol(consts["t0"], consts["Ms"]) / (4. * Pi * sigma * interpRs(consts["t0"], consts["Ms"])
+                                                          - interpRs(consts["t0"], consts["Ms"]))) ** (1 / 7))
+            * (r / interpRs(consts["t0"], consts["Ms"])) ** (2 / 7))
+            * (interpLbol(consts["t0"], consts["Ms"]) / (4. * Pi * sigma * r * r))
+            + ((3 / 4) * (tau + 2 / 3))
+            * 3 * G * consts["Ms"] * mdot * (1. - np.sqrt(interpRs(consts["t0"], consts["Ms"]) / r))
+            / (8. * Pi * sigma * r * r * r)) ** (1 / 4)
+
+
+def ice_line(consts: dict, mdot: np.float64 = zero) -> np.float64:
+    """
+    Return the lacation of the iceline when the protoplanetary disc dissipate
+
+    Parameters
+    ----------
+    consts : dict
+        All the constants needed
+    mdot : np.float, optional, default=0
+        The accretion rate on the central star
+
+    Returns
+    -------
+    np.float64
+        the ice-line location
+    """
+    def null(r: np.float64 | np.ndarray[np.float64]) -> np.ndarray[np.float64] | np.float64:
+        return temp_ppd(r, consts=consts, mdot=mdot) - 170
+    return root(null, x0 = au).x
+
+directory: str = "./configs"
+
+if not os.path.exists(directory):
+    os.mkdir(directory)
+mstars = np.linspace(wfus["M"].min(), wfus["M"].max(), 5) * Msun
+mds = [0.1 * Mearth, 1e-3 * Mearth]
+tinits = [Myr, np.double(5.) * Myr]
+alphas = [1e-3, 1e-1]
+
+for im in range(len(mstars)):
+    for imd in range(len(mds)):
+        for it in range(len(tinits)):
+            consts_ms = dic_ref.copy()
+            consts_ms["Ms"] = mstars[im]
+            consts_ms["t0"] = tinits[it]
+            a0: np.float64 = ice_line(consts_ms, 1e-10 * Msun / yr)
+            a0s = [0.7 * a0, a0, 1.3 * a0]
+            for ialpha in range(len(alphas)):
+                for ia0 in range(len(a0s)):
+                    consts_msi = consts_ms.copy()
+                    consts_msi["AB_Mbelt"] = mds[imd]
+                    consts_msi["alpha"] = alphas[ialpha]
+                    consts_msi["a0"] = a0s[ia0]
+                    consts_msi["a_planets"] = 0.7 * a0s[ia0] * np.double(1 - 0.5)
+                    consts_msi["a_out"] = np.double(100.) * a0s[ia0]
+                    consts_msi["AB_a0"] = a0s[ia0]
+                    consts_msi["AB_delta_r"] = a0s[ia0] * np.double(0.5)
+                    consts_msi["Simulation"] = "Simulation_" + str(im + 1) + str(imd + 1) + str(it + 1) + str(ialpha + 1) + str(ia0 + 1)
+                    print(consts_msi["Simulation"])
+                    np.savez_compressed(directory + "/" + consts_msi["Simulation"], **consts_msi)

diffenix/m/303/251thodes_num/303/251riques.py

@@ -0,0 +1,332 @@
+from __future__ import annotations
+import numpy as np
+from numpy.linalg import LinAlgError
+from scipy.integrate import solve_ivp
+from scipy.linalg import solve, LinAlgWarning
+from scipy.optimize import approx_fprime
+from scipy.optimize import root
+import phenigraph as g
+
+
+def gradient_weno5(y: np.ndarray, dx: np.float64 = 1.0, axis: int = -1) -> np.ndarray:
+    """
+    Compute the spatial derivative of y following the WENO discretization scheme, robust to discontinuity,
+    along a specified axis.
+
+    Parameters
+    ----------
+    y : np.ndarray
+        The array to be derived
+    dx : np.float64, optional, default: 1.0
+        The space step, the space domain should be evenly spaced with dx
+    axis : int, optional, default: -1
+        The axis along which to compute the derivative
+
+    Returns
+    -------
+    np.ndarray
+        The order 1 spatial derivative of y at each point along the specified axis
+    """
+    eps: np.float64 = np.double(1e-200)
+
+    # Move the specified axis to the last position for easier manipulation
+    y = np.moveaxis(y, axis, -1)
+
+    # Initialize arrays for alpha0, alpha1, alpha2
+    alpha0 = ((13. / 12.) * (y[..., :-4] - 2. * y[..., 1:-3] + y[..., 2:-2]) ** 2
+              + (1. / 4.) * (y[..., :-4] - 4. * y[..., 1:-3] + 3. * y[..., 2:-2]) ** 2)
+    alpha1 = ((13. / 12.) * (y[..., 2:-2] - 2. * y[..., 3:-1] + y[..., 4:]) ** 2
+              + (1. / 4.) * (y[..., 2:-2] - y[..., 4:]) ** 2)
+    alpha2 = ((13. / 12.) * (y[..., 1:-3] - 2. * y[..., 2:-2] + y[..., 3:-1]) ** 2
+              + (1. / 4.) * (y[..., 1:-3] - 4. * y[..., 2:-2] + 3. * y[..., 3:-1]) ** 2)
+    # alpha0 = ((13. / 12.) * (y[..., 2:-2] - 2. * y[..., 3:-1] + y[..., 4:]) ** 2
+    #           + (1. / 4.) * (3. * y[..., 2:-2] - 4. * y[..., 3:-1] + y[..., 4:]) ** 2)
+    # alpha1 = ((13. / 12.) * (y[..., 1:-3] - 2. * y[..., 2:-2] + y[..., 3:-1]) ** 2
+    #           + (1. / 4.) * (y[..., 1:-3] - y[..., 3:-1]) ** 2)
+    # alpha2 = ((13. / 12.) * (y[..., :-4] - 2. * y[..., 1:-3] + y[..., 2:-2]) ** 2
+    #           + (1. / 4.) * (y[..., :-4] - 4. * y[..., 1:-3] + 3. * y[..., 2:-2]) ** 2)
+    eps = 1e-6 * np.min([abs(alpha0), abs(alpha1), abs(alpha2)]) + 1e-150
+    # eps = 1e200
+    # print(eps, np.argwhere(np.isnan(alpha0)), np.argwhere(np.isnan(alpha1)), np.argwhere(np.isnan(alpha2)))
+    # Compute alpha0, alpha1, alpha2 along the last axis
+
+    alpha0 = 0.1 / ((eps + alpha0) * (eps + alpha0))
+
+    alpha1 = 0.6 / ((eps + alpha1) * (eps + alpha1))
+
+    alpha2 = 0.3 / ((eps + alpha2) * (eps + alpha2))
+
+    # print(alpha0, alpha1, alpha2)
+
+    # Compute fp
+    fp = (alpha0 * ((2. / 6.) * y[..., :-4] - (7. / 6.) * y[..., 1:-3] + (11. / 6.) * y[..., 2:-2])
+          + alpha1 * (-(1. / 6.) * y[..., 1:-3] + (5. / 6.) * y[..., 2:-2] + (2. / 6.) * y[..., 3:-1])
+          + alpha2 * ((2. / 6.) * y[..., 2:-2] + (5. / 6.) * y[..., 3:-1] - (1. / 6.) * y[..., 4:])) / (
+                 alpha0 + alpha1 + alpha2)
+    # fp = (alpha0 * ((-1. / 6.) * y[..., :-4] + (5. / 6.) * y[..., 1:-3] + (2. / 6.) * y[..., 2:-2])
+    #       + alpha1 * ((2. / 6.) * y[..., 1:-3] + (5. / 6.) * y[..., 2:-2] - (1. / 6.) * y[..., 3:-1])
+    #       + alpha2 * ((11. / 6.) * y[..., 2:-2] - (7. / 6.) * y[..., 3:-1] + (2. / 6.) * y[..., 4:])) / (
+    #                  alpha0 + alpha1 + alpha2)
+    # Initialize result array
+    res = np.zeros_like(y)
+
+    # Compute the derivative along the last axis
+    res[..., 3:-2] = (fp[..., 1:] - fp[..., :-1]) / dx
+    # res[..., :3] = (y[..., 1:4] - y[..., :3]) / dx
+    res[..., 1:3] = (res[..., 2:4] - res[..., :2]) * 2 / dx
+    res[..., 0] = (y[..., 1] - y[..., 0]) / dx
+    res[..., -2:] = (y[..., -2:] - y[..., -3:-1]) / dx
+
+    # Move the axis back to its original position
+    res = np.moveaxis(res, -1, axis)
+    # return np.gradient(y, axis=axis) / dx
+    # return fp
+    return res
+
+
+def gradient_g(y: np.ndarray[np.float64], dx: np.float64 = np.double(1), axis: int = -1) -> np.ndarray[np.float64]:
+    y = np.moveaxis(y, axis, -1)
+    res = np.zeros_like(y)
+    res[..., 1:] = (y[..., 1:] - y[..., :-1]) / dx
+    res[..., 0] = (y[..., 1] - y[..., 0]) / dx
+    res = np.moveaxis(res, -1, axis)
+    return res
+
+
+def gradient_d(y: np.ndarray[np.float64], dx: np.float64 = np.double(1), axis: int = -1) -> np.ndarray[np.float64]:
+    y = np.moveaxis(y, axis, -1)
+    res = np.zeros_like(y)
+    res[..., :-1] = (y[..., 1:] - y[..., :-1]) / dx
+    res[..., -1] = (y[..., -1] - y[..., -2]) / dx
+    res = np.moveaxis(res, -1, axis)
+    return res
+
+
+def gradient(y: np.ndarray[np.float64], dx: np.float64 = np.double(1), axis: int = -1,
+             radial_speed: np.ndarray[np.float64] = None) -> np.ndarray[np.float64]:
+    y = np.moveaxis(y, axis, -1)
+    dg = gradient_g(y, dx, axis)
+    dd = gradient_d(y, dx, axis)
+    if radial_speed is None:
+        res = (dg+dd) / 2
+    else:
+        res = dd
+        if np.any(radial_speed < 0):
+            idx_negs: np.ndarray[int] = np.argwhere(radial_speed < 0)[:, 0]
+            res[..., idx_negs] = dg[..., idx_negs]
+    res = np.moveaxis(res, -1, axis)
+    return res
+
+
+def gradient2(y: np.ndarray[np.float64], dx: np.float64 = np.double(1), axis: int = -1) -> np.ndarray[np.float64]:
+    y = np.moveaxis(y, axis, -1)
+    res = np.zeros_like(y)
+    res[..., 1:-1] = (y[..., 2:] + y[..., :-2] - 2. * y[..., 1:-1]) / (dx * dx)
+    # res[..., 0] = (y[..., 0] - 2 * y[..., 1] + y[..., 2]) / (dx * dx)
+    # res[..., -1] = (y[..., -3] - 2 * y[..., -2] + y[..., -1]) / (dx * dx)
+    # res[wleft * wright == 0] = 0.
+    res = np.moveaxis(res, -1, axis)
+    return res
+
+
+def dleft(y: np.ndarray[np.float64], dx: np.float64 = np.double(1), axis: int = -1) -> np.ndarray[np.float64]:
+    y = np.moveaxis(y, axis, -1)
+    dleft: np.ndarray[np.float64] = np.zeros_like(y)
+    dright: np.ndarray[np.float64] = np.zeros_like(y)
+    wleft: np.ndarray[np.float64] = np.zeros_like(y)
+    wright: np.ndarray[np.float64] = np.zeros_like(y)
+    dleft[2:] = (1.5 * y[..., 2:] - 2. * y[..., 1:-1] + 0.5 * y[..., :-2]) / dx
+
+    dleft = np.moveaxis(dleft, -1, axis)
+    return dleft
+
+
+def dright(y: np.ndarray[np.float64], dx: np.float64 = np.double(1), axis: int = -1) -> np.ndarray[np.float64]:
+    y = np.moveaxis(y, axis, -1)
+    dright: np.ndarray[np.float64] = np.zeros_like(y)
+    dright[..., :-2] = (-1.5 * y[..., :-2] + 2. * y[..., 1:-1] - 0.5 * y[..., 2:]) / dx
+
+    dright = np.moveaxis(dright, -1, axis)
+    return dright
+
+
+
+def doublons(tab: np.ndarray, prec: np.float64 = np.double(1e-13)) -> np.ndarray:
+    res: list = []
+    idx_poubelle: list = []
+    for i in range(len(tab)):
+        if i not in idx_poubelle:
+            idx = np.argwhere(np.abs((tab - tab[i]) / tab[i]) < prec)[:, 0]
+            if len(idx) > 0:
+                res.append(idx[0])
+            else:
+                res.append(i)
+            idx_poubelle.extend(list(idx))
+    return np.array(res)
+
+
+# Opérations diverses
+def factorielle(n: int) -> int:
+    """
+    Calcul récursivement la factorielle de n
+    :param n: entier naturel dont on souhaite calculer la factorielle
+    :return: n!
+    """
+    if n < 0:
+        raise UserWarning("La factorielle d'un nombre négatif ({}) n'est pas définie".format(n))
+    elif n == 0 or n == 1:
+        return 1
+    else:
+        return n * factorielle(n - 1)
+
+def puissance_entière(x: np.float64 | float | np.ndarray, n: int) -> np.float64 | float | np.ndarray:
+    """Calcul la puissance n de x"""
+    if type(n) is not (int or np.longlong):
+        raise UserWarning("Une puissance entière ne peut être calculé avec un exposant de type :" + str(type(n)))
+    if n == 0:
+        return np.ones_like(x)
+    elif n == -1:
+        return 1 / x
+    elif n == 1:
+        return x
+    else:
+        res: np.float64 | float | np.ndarray = np.copy(x)
+        for k in range(2, n + 1):
+            res *= x
+        return res
+
+
+def calcul_coefficients_pondération(
+        X: np.ndarray | list[float | np.float64],
+        x0: float | np.float64 = np.double(0), ordre: int = 1) -> np.ndarray:
+    """ Cette fonction calcule les coefficients de pondération à appliquer devant les évaluations d'une fonction f aux
+     pas de temps dts autour du point à dériver
+    :param X: Valeurs des point d'évaluation de la fonction
+    :type X : list[double|float] | Array[double|float]
+
+    :param x0: Valeur autour de laquelle on souhaite dériver (option à choisir si x0 n'est pas présent dans x)
+    :type x0: float | double
+
+    :param ordre: Ordre de la dérivation. Par défaut 1. Ne peut être plus grand que le nombre de pas de temps
+    :type ordre : int
+
+    :return: K, tableau de la dimension de X contenant les coefficients à appliquer devant les évaluations de la
+    fonction f à dériver aux pas de temps correspondant
+    :rtype : Array[double | float]
+
+    Remarques :
+    - Le premier pas de temps peut être nul, et les pas de temps peuvent être positifs ou négatifs.
+    - La dérivation sera précise à l'ordre correspondant à la taille de X
+    Exemples :
+    - Cas le plus simple : dérivée d'ordre 1, schéma d'Euler
+        -- On fournit X=[0 ,dt] et la fonction retourne [-1 / dt, 1 / dt]
+    - Dérivation centrée d'ordre 1 :
+        -- On fournit X=[-dt,0,dt] et la fonction retourne [-1 / 2*dt, 0, 1 / 2*dt]
+    """
+    if ordre >= len(X):
+        raise UserWarning(
+            "Attention, pour calculer une dérivée d'ordre " + str(ordre) + ", on doit avoir au moins " + str(
+                ordre) + " pas de temps. Les " + str(len(X)) + " results sont insuffisantes")
+
+    Delta_X: np.ndarray = np.array(X) - x0
+    # mini: np.float64 = np.double(np.min(abs(Delta_X[Delta_X != 0])))
+    # maxi: np.float64 = np.double(np.max(abs(Delta_X[Delta_X != 0])))
+    # alpha: np.float64 = 10 ** ((np.log10(mini) + np.log10(maxi)) / 2)
+    # Delta_X /= alpha  # On rééchelonne les abscisses pour ne pas avoir de trop petites results dans la matrice A
+
+    A: np.ndarray = np.array([list(puissance_entière(Delta_X, i)) for i in range(len(X))])
+    B: np.ndarray = np.zeros_like(X)
+    # B[ordre] = factorielle(ordre) / puissance_entière(alpha, ordre)
+    B[ordre] = factorielle(ordre)
+    K: np.ndarray
+    K = solve(A, B, overwrite_a=True, overwrite_b=True)
+    return K
+
+
+def calcul_matrice_derivation(x: np.ndarray | list, ordre_derivation: int = 1, ordre_discrétisation: int = 2
+                              ) -> np.ndarray:
+    """
+    Retourne une matrice qui multipliée avec tout y=f(x) retourne la dérivée d'ordre ordre_dérivation de f selon l'axe x
+    discrétisé à l'ordre ordre_discrétisation
+    :param x: tableau 1d represantant l'axe de dérivation
+    :param ordre_derivation: ordre de la dérivée voulue
+    :param ordre_discrétisation: ordre de la discrétisation de la dérivée, >= ordre_dérivation < len(x)
+    :return: matrice à multiplier avec y
+    """
+    if type(x) is list:
+        x: np.ndarray = np.array(x)
+    if len(x.shape) > 1:
+        raise UserWarning("calcul_matrice_derivation : l'axe de dérivation doit être de dimension 1."
+                          "Ici x.shape=", x.shape)
+    if ordre_discrétisation < ordre_derivation:
+        raise UserWarning("calcul_matrice_derivation : l'ordre de discrétisation doit être supérieur "
+                          "à l'ordre de dérivation, ici ordre_dérivation=", ordre_derivation,
+                          "et ordre discrétisation=", ordre_discrétisation)
+    if ordre_discrétisation >= len(x):
+        raise UserWarning("calcul_matrice_derivation : l'ordre de discrétisation doit être inférieur "
+                          "à la taille du tableau x. Ici ordre discrétisation=", ordre_discrétisation,
+                          "len(x)=", len(x))
+    K: np.ndarray = np.zeros((len(x), len(x)), dtype=type(x[0]))
+    for i in range(len(x)):
+        i_inf: int = max(0, i - (ordre_discrétisation + 1) // 2)
+        i_sup: int = min(len(x) - 1, i + (ordre_discrétisation + 1) // 2 + (ordre_discrétisation + 1) % 2)
+        i_inf -= max(i + (ordre_discrétisation + 1) // 2 + (ordre_discrétisation + 1) % 2 - (len(x) - 1), 0)
+        i_sup += - min(i - (ordre_discrétisation + 1) // 2, 0)
+        K[i, i_inf:i_sup] = calcul_coefficients_pondération(X=x[i_inf:i_sup], x0=x[i], ordre=ordre_derivation)
+    return K
+
+#
+# def gradient2(f: np.ndarray, x: np.ndarray | None = None, axis: int = 0,
+#               tab_dx: np.ndarray | None = None, derivation_order: int = 1,
+#               discretisation_order: int = 2) -> np.ndarray:
+#     """
+#     Calculate the spatial derivative of f along x
+#     :param f: value to differentiate
+#     :param x: abscisse, if None and tab_dx None = arange(len(f))
+#     :param axis: axis along with the derivative is done (default 0)
+#     :param tab_dx: matrix used to calculate the derivative. If None tab_dx is calculated using x, derivation_order
+#      and discretisation_order
+#     :param derivation_order: int = 1 if tab_dx is None
+#     :param discretisation_order: int = 2 if tab_dx is None
+#     :return:
+#     """
+#     if tab_dx is None:
+#         tab_dx = calcul_matrice_derivation(x, derivation_order, discretisation_order)
+#     # return tab_dx @ f
+#     # return np.tensordot(tab_dx, f, axes=([1], [axis]))
+#     return np.tensordot(f, tab_dx, axes=([axis], [1]))
+
+
+def linear_interpolation(x, y):
+    """
+    Interpolation linéaire vectorisée.
+
+    :param x: Points de données pour la variable indépendante.
+    :param y: Points de données pour les fonctions dépendantes (2D array).
+    :param x_new: Points pour lesquels interpoler.
+    :return: Valeurs interpolées pour chaque dimension.
+    """
+    def result(x_new: np.float64 | np.ndarray) -> np.float64 | np.ndarray:
+        if isinstance(x_new, np.ndarray):
+            # Calculer les indices et les poids pour l'interpolation
+            idx = np.searchsorted(x, x_new) - 1
+            idx = np.clip(idx, 0, len(x) - 2)
+
+            # Calculer les poids pour chaque intervalle
+            x1 = x[idx]
+            x2 = x[idx + 1]
+            alpha = (x_new - x1) / (x2 - x1)
+
+            # Interpolation linéaire vectorisée
+            y_new = (1 - alpha[:, np.newaxis]) * y[idx] + alpha[:, np.newaxis] * y[idx + 1]
+
+            return y_new
+        else:
+            i = np.searchsorted(x, x_new)
+            i = np.clip(i, 0, len(x) - 2)
+            x1 = x[i]
+            x2 = x[i + 1]
+            alpha = (x_new - x1) / (x2 - x1)
+            y_new = (1 - alpha) * y[i] + alpha*y[i + 1]
+            return y_new
+    return result