From 7e8ae9aecff7ddfaf190662cc8908dba8e1ac4c7 Mon Sep 17 00:00:00 2001 From: Olivier Pigeon Date: Fri, 9 Jan 2026 17:43:52 +0100 Subject: [PATCH 1/3] feat(#66): Replace pandas.Dataframe by np.ndarrays in solvers Signed-off-by: Olivier Pigeon --- src/thermohl/solver/base.py | 25 +++++++++++ src/thermohl/solver/slv1t.py | 38 +++++------------ src/thermohl/solver/slv3t.py | 52 ++++++++--------------- test/test_shape.py | 27 +++++++----- test/test_solver1t.py | 16 +++---- test/test_solver3t.py | 22 +++++----- test/unit/solver/test_slv1t.py | 76 +++++++++++++++++----------------- 7 files changed, 126 insertions(+), 130 deletions(-) diff --git a/src/thermohl/solver/base.py b/src/thermohl/solver/base.py index aebce35..8f7b08e 100644 --- a/src/thermohl/solver/base.py +++ b/src/thermohl/solver/base.py @@ -278,6 +278,31 @@ def transient_temperature(self) -> Dict[str, Any]: def steady_intensity(self) -> pd.DataFrame: raise NotImplementedError + @staticmethod + def format_output(columns_names: list[str], data: list[np.ndarray]) -> dict[str, np.ndarray]: + if len(columns_names) != len(data): + raise ValueError(f"columns_names and data must have the same length but len(columns_names)={len(columns_names)} and len(data)={len(data)}") + + return {columns_names[i]: data[i] for i in range(len(columns_names))} + + def add_error_and_power_if_needed(self, T, err, output, return_err, return_power): + self.add_error_if_needed(err, output, return_err) + self.add_powers_if_needed(T, output, return_power) + + @staticmethod + def add_error_if_needed(err, output, return_err): + if return_err: + output[Solver.Names.err] = err + + def add_powers_if_needed(self, temperature_average, output, return_power, temperature_surface=None): + if return_power: + temperature_surface = temperature_surface if temperature_surface is not None else temperature_average + output[Solver.Names.pjle] = self.jh.value(temperature_average) + output[Solver.Names.psol] = self.sh.value(temperature_surface) + output[Solver.Names.pcnv] = self.cc.value(temperature_surface) + output[Solver.Names.prad] = self.rc.value(temperature_surface) + output[Solver.Names.ppre] = self.pc.value(temperature_surface) + def reshape(input_array: numberArrayLike, nb_row: int, nb_columns: int) -> numberArray: """ diff --git a/src/thermohl/solver/slv1t.py b/src/thermohl/solver/slv1t.py index adfdd39..2c2b113 100644 --- a/src/thermohl/solver/slv1t.py +++ b/src/thermohl/solver/slv1t.py @@ -19,6 +19,7 @@ class Solver1T(Solver_): + def steady_temperature( self, Tmin: float = DP.tmin, @@ -27,7 +28,7 @@ def steady_temperature( maxiter: int = DP.maxiter, return_err: bool = False, return_power: bool = True, - ) -> pd.DataFrame: + ) -> dict[str, np.ndarray]: """ Compute steady-state temperature. @@ -40,7 +41,7 @@ def steady_temperature( return_power (bool, optional): Return power term values. The default is True. Returns: - pandas.DataFrame: A DataFrame with temperature and other results (depending on inputs) in the columns. + dict[str, np.ndarray]: A dictionary with temperature and other results (depending on inputs) in the keys. """ @@ -50,19 +51,10 @@ def steady_temperature( ) # format output - df = pd.DataFrame(data=T, columns=[Solver_.Names.temp]) - - if return_err: - df[Solver_.Names.err] = err - - if return_power: - df[Solver_.Names.pjle] = self.jh.value(T) - df[Solver_.Names.psol] = self.sh.value(T) - df[Solver_.Names.pcnv] = self.cc.value(T) - df[Solver_.Names.prad] = self.rc.value(T) - df[Solver_.Names.ppre] = self.pc.value(T) + result = self.format_output([Solver_.Names.temp], [T]) + self.add_error_and_power_if_needed(T, err, result, return_err, return_power) - return df + return result def transient_temperature( self, @@ -169,7 +161,7 @@ def steady_intensity( maxiter: int = DP.maxiter, return_err: bool = False, return_power: bool = True, - ) -> pd.DataFrame: + ) -> dict[str, np.ndarray]: """Compute steady-state max intensity. Compute the maximum intensity that can be run in a conductor without @@ -185,7 +177,7 @@ def steady_intensity( return_power (bool, optional): Return power term values. The default is True. Returns: - pandas.DataFrame: A dataframe with maximum intensity and other results (depending on inputs) in the columns. + dict[str, np.array]: A dictionary with temperature and other results (depending on inputs) in the keys. """ @@ -213,16 +205,8 @@ def fun(i: floatArray) -> floatArrayLike: self.args.transit = transit # format output - df = pd.DataFrame(data=A, columns=[Solver_.Names.transit]) - - if return_err: - df[Solver_.Names.err] = err + result = self.format_output([Solver_.Names.transit], [A]) + self.add_error_and_power_if_needed(T_, err, result, return_err, return_power) - if return_power: - df[Solver_.Names.pjle] = self.jh.value(T) - df[Solver_.Names.psol] = self.sh.value(T) - df[Solver_.Names.pcnv] = self.cc.value(T) - df[Solver_.Names.prad] = self.rc.value(T) - df[Solver_.Names.ppre] = self.pc.value(T) + return result - return df diff --git a/src/thermohl/solver/slv3t.py b/src/thermohl/solver/slv3t.py index 581882f..6032fc5 100644 --- a/src/thermohl/solver/slv3t.py +++ b/src/thermohl/solver/slv3t.py @@ -190,7 +190,7 @@ def steady_temperature( maxiter: int = DP.maxiter, return_err: bool = False, return_power: bool = True, - ) -> pd.DataFrame: + ) -> dict[str, np.ndarray]: """ Compute the steady-state temperature distribution. @@ -203,7 +203,7 @@ def steady_temperature( return_power (bool): If True, power-related values are included in the returned DataFrame. Returns: - pd.DataFrame: DataFrame containing the steady-state temperatures and optionally the error and power-related values. + dict[str, np.ndarray]: Dictionary containing the steady-state temperatures and optionally the error and power-related values. """ # if no guess provided, use ambient temp @@ -229,21 +229,10 @@ def steady_temperature( # format output z = self.average(x, y) - df = pd.DataFrame( - {Solver_.Names.tsurf: x, Solver_.Names.tavg: z, Solver_.Names.tcore: y} - ) - - if return_err: - df[Solver_.Names.err] = err - - if return_power: - df[Solver_.Names.pjle] = self.joule(x, y) - df[Solver_.Names.psol] = self.sh.value(x) - df[Solver_.Names.pcnv] = self.cc.value(x) - df[Solver_.Names.prad] = self.rc.value(x) - df[Solver_.Names.ppre] = self.pc.value(x) + result = self.format_output([Solver_.Names.tsurf, Solver_.Names.tavg, Solver_.Names.tcore], [x, z, y]) + self.add_error_and_power_if_needed(x, err, result, return_err, return_power) - return df + return result def _morgan_transient(self): """Morgan coefficients for transient temperature.""" @@ -459,7 +448,7 @@ def steady_intensity( return_err: bool = False, return_temp: bool = True, return_power: bool = True, - ) -> pd.DataFrame: + ) -> dict[str, np.ndarray]: """ Compute the steady-state intensity for a given temperature profile. @@ -473,7 +462,7 @@ def steady_intensity( return_power (bool): If True, return the power profiles in the output DataFrame. Default is True. Returns: - pd.DataFrame: DataFrame containing the steady-state intensity and optionally the error, temperature profiles, and power profiles. + dict[str, np.ndarray]: A dictionary with temperature and other results (depending on inputs) in the keys. """ Tmax, newtheader = self._steady_intensity_header(T, target) @@ -499,7 +488,7 @@ def morgan(i: floatArray, tg: floatArray) -> floatArray: x, y, cnt, err = quasi_newton_2d( balance, morgan, - r[Solver_.Names.transit].values, + r[Solver_.Names.transit], Tmax, relative_tolerance=tol, max_iterations=maxiter, @@ -510,25 +499,18 @@ def morgan(i: floatArray, tg: floatArray) -> floatArray: print(f"rstat_analytic max err is {np.max(err):.3E} in {cnt:d} iterations") # format output - df = pd.DataFrame({Solver_.Names.transit: x}) - - if return_err: - df["err"] = err + result = self.format_output([Solver_.Names.transit], [x]) + self.add_error_if_needed(err, result, return_err) if return_temp or return_power: ts, tc = newtheader(x, y) ta = self.average(ts, tc) if return_temp: - df[Solver_.Names.tsurf] = ts - df[Solver_.Names.tavg] = ta - df[Solver_.Names.tcore] = tc - - if return_power: - df[Solver_.Names.pjle] = self.jh.value(ta) - df[Solver_.Names.psol] = self.sh.value(ts) - df[Solver_.Names.pcnv] = self.cc.value(ts) - df[Solver_.Names.prad] = self.rc.value(ts) - df[Solver_.Names.ppre] = self.pc.value(ts) - - return df + result[Solver_.Names.tsurf] = ts + result[Solver_.Names.tavg] = ta + result[Solver_.Names.tcore] = tc + + self.add_powers_if_needed(ta, result, return_power, temperature_surface=ts) + + return result diff --git a/test/test_shape.py b/test/test_shape.py index ec39f25..23ae668 100644 --- a/test/test_shape.py +++ b/test/test_shape.py @@ -21,9 +21,9 @@ def _solvers(): def _ampargs(s: solver.Solver, t: pd.DataFrame): if isinstance(s, solver.Solver1T): - a = dict(T=t[solver.Solver.Names.temp].values) + a = dict(T=t[solver.Solver.Names.temp]) elif isinstance(s, solver.Solver3T): - a = dict(T=t[solver.Solver.Names.tsurf].values, target=solver.Solver.Names.surf) + a = dict(T=t[solver.Solver.Names.tsurf], target=solver.Solver.Names.surf) else: raise NotImplementedError return a @@ -31,12 +31,12 @@ def _ampargs(s: solver.Solver, t: pd.DataFrame): def _traargs(s: solver.Solver, ds: pd.DataFrame, t): if isinstance(s, solver.Solver1T): - a = dict(time=t, T0=ds[solver.Solver.Names.temp].values) + a = dict(time=t, T0=ds[solver.Solver.Names.temp]) elif isinstance(s, solver.Solver3T): a = dict( time=t, - Ts0=ds[solver.Solver.Names.tsurf].values, - Tc0=ds[solver.Solver.Names.tcore].values, + Ts0=ds[solver.Solver.Names.tsurf], + Tc0=ds[solver.Solver.Names.tcore], ) else: raise NotImplementedError @@ -75,8 +75,13 @@ def test_steady_default(): t = s.steady_temperature() a = _ampargs(s, t) i = s.steady_intensity(**a) - assert len(t) == 1 - assert len(i) == 1 + check_number_of_lines_in_result(t, 1) + check_number_of_lines_in_result(i, 1) + + +def check_number_of_lines_in_result(dictionary, expected_lines: int): + for (key, val) in dictionary.items(): + assert val.shape == (expected_lines,) def test_steady_1d(): @@ -87,8 +92,8 @@ def test_steady_1d(): t = s.steady_temperature() a = _ampargs(s, t) i = s.steady_intensity(**a) - assert len(t) == n - assert len(i) == n + check_number_of_lines_in_result(t, n) + check_number_of_lines_in_result(i, n) def test_steady_1d_mix(): @@ -100,8 +105,8 @@ def test_steady_1d_mix(): t = s.steady_temperature() a = _ampargs(s, t) i = s.steady_intensity(**a) - assert len(t) == n - assert len(i) == n + check_number_of_lines_in_result(t, n) + check_number_of_lines_in_result(i, n) def test_transient_0(): diff --git a/test/test_solver1t.py b/test/test_solver1t.py index 99df08d..140c317 100644 --- a/test/test_solver1t.py +++ b/test/test_solver1t.py @@ -73,20 +73,20 @@ def test_consistency(): ) for s in _solvers(dic): - df = s.steady_intensity( + result = s.steady_intensity( T=100.0, return_err=True, return_power=True, tol=1.0e-09, maxiter=64 ) bl = ( - df["P_joule"] - + df["P_solar"] - - df["P_convection"] - - df["P_radiation"] - - df["P_precipitation"] + result["P_joule"] + + result["P_solar"] + - result["P_convection"] + - result["P_radiation"] + - result["P_precipitation"] ) assert np.allclose(bl, 0.0, atol=1.0e-06) - s.args["transit"] = df["transit"].values + s.args["transit"] = result["transit"] s.update() dg = s.steady_temperature( return_err=True, return_power=True, tol=1.0e-09, maxiter=64 ) - assert np.allclose(dg["t"].values, 100.0) + assert np.allclose(dg["t"], 100.0) diff --git a/test/test_solver3t.py b/test/test_solver3t.py index 891c503..9e6ec99 100644 --- a/test/test_solver3t.py +++ b/test/test_solver3t.py @@ -46,7 +46,7 @@ def test_balance(): t1 = s1.steady_temperature( tol=2.0, maxiter=16, return_err=False, return_power=False ) - t1 = t1["t"].values + t1 = t1["t"] # 3t solve df = s.steady_temperature( Tsg=t1, Tcg=t1, return_err=True, return_power=True, tol=tol, maxiter=64 @@ -54,10 +54,10 @@ def test_balance(): # checks assert np.all(df["err"] < tol) assert np.allclose( - s.balance(ts=df["t_surf"], tc=df["t_core"]).values, 0.0, atol=tol + s.balance(ts=df["t_surf"], tc=df["t_core"]), 0.0, atol=tol ) assert np.allclose( - s.morgan(ts=df["t_surf"], tc=df["t_core"]).values, 0.0, atol=tol + s.morgan(ts=df["t_surf"], tc=df["t_core"]), 0.0, atol=tol ) @@ -81,7 +81,7 @@ def test_consistency(): for s in _solvers(dic): for t in ["surf", "avg", "core"]: # solve intensity with different targets - df = s.steady_intensity( + result = s.steady_intensity( T=100.0, target=t, return_err=True, @@ -89,24 +89,24 @@ def test_consistency(): tol=1.0e-09, maxiter=64, ) - assert np.all(df["err"] < tol) + assert np.all(result["err"] < tol) # set args intensity to newly founds ampacities - s.args.transit = df["transit"].values + s.args.I = result["transit"] s.update() assert np.allclose( - s.balance(ts=df["t_surf"], tc=df["t_core"]).values, 0.0, atol=tol + s.balance(ts=result["t_surf"], tc=result["t_core"]), 0.0, atol=tol ) assert np.allclose( - s.morgan(ts=df["t_surf"], tc=df["t_core"]).values, 0.0, atol=tol + s.morgan(ts=result["t_surf"], tc=result["t_core"]), 0.0, atol=tol ) # 3t solve dg = s.steady_temperature( - Tsg=df["t_surf"].round(1).values, - Tcg=df["t_core"].round(1).values, + Tsg=result["t_surf"].round(1), + Tcg=result["t_core"].round(1), return_err=True, return_power=True, tol=1.0e-09, maxiter=64, ) # check consistency - assert np.allclose(dg["t_" + t].values, 100.0) + assert np.allclose(dg["t_" + t], 100.0) diff --git a/test/unit/solver/test_slv1t.py b/test/unit/solver/test_slv1t.py index f39ed06..a34b277 100644 --- a/test/unit/solver/test_slv1t.py +++ b/test/unit/solver/test_slv1t.py @@ -34,33 +34,33 @@ def solver(): def test_steady_temperature_default(solver): result = solver.steady_temperature() - assert isinstance(result, pd.DataFrame) - assert Solver1T.Names.temp in result.columns - assert Solver1T.Names.pjle in result.columns - assert Solver1T.Names.psol in result.columns - assert Solver1T.Names.pcnv in result.columns - assert Solver1T.Names.prad in result.columns - assert Solver1T.Names.ppre in result.columns + assert isinstance(result, dict) + assert Solver1T.Names.temp in result.keys() + assert Solver1T.Names.pjle in result.keys() + assert Solver1T.Names.psol in result.keys() + assert Solver1T.Names.pcnv in result.keys() + assert Solver1T.Names.prad in result.keys() + assert Solver1T.Names.ppre in result.keys() def test_steady_temperature_with_error(solver): result = solver.steady_temperature(return_err=True) - assert isinstance(result, pd.DataFrame) - assert Solver1T.Names.temp in result.columns - assert Solver1T.Names.err in result.columns + assert isinstance(result, dict) + assert Solver1T.Names.temp in result.keys() + assert Solver1T.Names.err in result.keys() def test_steady_temperature_no_power(solver): result = solver.steady_temperature(return_power=False) - assert isinstance(result, pd.DataFrame) - assert Solver1T.Names.temp in result.columns - assert Solver1T.Names.pjle not in result.columns - assert Solver1T.Names.psol not in result.columns - assert Solver1T.Names.pcnv not in result.columns - assert Solver1T.Names.prad not in result.columns - assert Solver1T.Names.ppre not in result.columns + assert isinstance(result, dict) + assert Solver1T.Names.temp in result.keys() + assert Solver1T.Names.pjle not in result.keys() + assert Solver1T.Names.psol not in result.keys() + assert Solver1T.Names.pcnv not in result.keys() + assert Solver1T.Names.prad not in result.keys() + assert Solver1T.Names.ppre not in result.keys() def test_steady_temperature_custom_params(solver): @@ -76,8 +76,8 @@ def test_steady_temperature_custom_params(solver): maxiter=maxiter, ) - assert isinstance(result, pd.DataFrame) - assert Solver1T.Names.temp in result.columns + assert isinstance(result, dict) + assert Solver1T.Names.temp in result.keys() def test_transient_temperature_default(solver): @@ -128,13 +128,13 @@ def test_steady_intensity_default(solver): result = solver.steady_intensity(T) - assert isinstance(result, pd.DataFrame) - assert Solver1T.Names.transit in result.columns - assert Solver1T.Names.pjle in result.columns - assert Solver1T.Names.psol in result.columns - assert Solver1T.Names.pcnv in result.columns - assert Solver1T.Names.prad in result.columns - assert Solver1T.Names.ppre in result.columns + assert isinstance(result, dict) + assert Solver1T.Names.transit in result.keys() + assert Solver1T.Names.pjle in result.keys() + assert Solver1T.Names.psol in result.keys() + assert Solver1T.Names.pcnv in result.keys() + assert Solver1T.Names.prad in result.keys() + assert Solver1T.Names.ppre in result.keys() def test_steady_intensity_with_error(solver): @@ -142,9 +142,9 @@ def test_steady_intensity_with_error(solver): result = solver.steady_intensity(T, return_err=True) - assert isinstance(result, pd.DataFrame) - assert Solver1T.Names.transit in result.columns - assert Solver1T.Names.err in result.columns + assert isinstance(result, dict) + assert Solver1T.Names.transit in result.keys() + assert Solver1T.Names.err in result.keys() def test_steady_intensity_no_power(solver): @@ -152,13 +152,13 @@ def test_steady_intensity_no_power(solver): result = solver.steady_intensity(T, return_power=False) - assert isinstance(result, pd.DataFrame) - assert Solver1T.Names.transit in result.columns - assert Solver1T.Names.pjle not in result.columns - assert Solver1T.Names.psol not in result.columns - assert Solver1T.Names.pcnv not in result.columns - assert Solver1T.Names.prad not in result.columns - assert Solver1T.Names.ppre not in result.columns + assert isinstance(result, dict) + assert Solver1T.Names.transit in result.keys() + assert Solver1T.Names.pjle not in result.keys() + assert Solver1T.Names.psol not in result.keys() + assert Solver1T.Names.pcnv not in result.keys() + assert Solver1T.Names.prad not in result.keys() + assert Solver1T.Names.ppre not in result.keys() def test_steady_intensity_custom_params(solver): @@ -170,5 +170,5 @@ def test_steady_intensity_custom_params(solver): result = solver.steady_intensity(T, Imin=Imin, Imax=Imax, tol=tol, maxiter=maxiter) - assert isinstance(result, pd.DataFrame) - assert Solver1T.Names.transit in result.columns + assert isinstance(result, dict) + assert Solver1T.Names.transit in result.keys() From 4c7811e43d3f0dd4429317dd97d9cac29b9e85f3 Mon Sep 17 00:00:00 2001 From: Olivier Pigeon Date: Mon, 12 Jan 2026 16:07:38 +0100 Subject: [PATCH 2/3] feat(#66): Remove pandas from examples, jupyter and test files Signed-off-by: Olivier Pigeon --- examples/example_solver_intensity.py | 16 +- examples/example_transient.py | 10 +- examples/example_transient2.py | 4 +- src/thermohl/solver/slv1t.py | 2 +- src/thermohl/solver/slv3t.py | 2 +- test/test_shape.py | 5 +- test/unit/solver/test_slv1t.py | 1 - .../docs/examples/ex_transient_3t.ipynb | 245 ++++++++++-------- 8 files changed, 158 insertions(+), 127 deletions(-) diff --git a/examples/example_solver_intensity.py b/examples/example_solver_intensity.py index f497a97..b4c0989 100644 --- a/examples/example_solver_intensity.py +++ b/examples/example_solver_intensity.py @@ -64,7 +64,7 @@ def test_solve(dct, Trep, tol=1.0e-06, mxi=64): # Test 1 : compute max intensity Trep = 99.0 - df = test_solve(dct, Trep, tol=1.0e-03, mxi=16) + dictionary = test_solve(dct, Trep, tol=1.0e-03, mxi=16) # Test 2 : check balance and consistency tol = 1.0e-06 @@ -81,16 +81,16 @@ def test_solve(dct, Trep, tol=1.0e-06, mxi=64): fig, ax = plt.subplots(nrows=2, ncols=5) for i, d in enumerate(mdl): slv = d["model"] - df = slv.steady_intensity(Trep, tol=tol, maxiter=mxi, return_power=True) - df["pb"] = ( - df["P_joule"] + df["P_solar"] - df["P_convection"] - df["P_radiation"] + dictionary = slv.steady_intensity(Trep, tol=tol, maxiter=mxi, return_power=True) + dictionary["pb"] = ( + dictionary["P_joule"] + dictionary["P_solar"] - dictionary["P_convection"] - dictionary["P_radiation"] ) - slv.dc["transit"] = df["I_max"].values - df["TIrep"] = slv.steady_temperature(return_power=False)["T_surf"] + slv.dc["transit"] = dictionary["I_max"] + dictionary["TIrep"] = slv.steady_temperature(return_power=False)["T_surf"] - ax[0, i].hist(df["pb"], bins=100) + ax[0, i].hist(dictionary["pb"], bins=100) ax[0, i].grid(True) - ax[1, i].hist(np.abs(1.0 - df["TIrep"] / Trep), bins=100) + ax[1, i].hist(np.abs(1.0 - dictionary["TIrep"] / Trep), bins=100) ax[1, i].grid(True) ax[0, i].set_title(d["label"]) diff --git a/examples/example_transient.py b/examples/example_transient.py index 3b973e3..557bf4d 100644 --- a/examples/example_transient.py +++ b/examples/example_transient.py @@ -65,10 +65,10 @@ for i, key in enumerate(slv): elm = slv[key] elm.dc["transit"] = transit - df = elm.steady_temperature() + dct = elm.steady_temperature() elm.dc["transit"] = np.nan cl = "C%d" % (i % 10,) - T1 = df["T_surf"].values + T1 = dct["T_surf"] T2 = elm.transient_temperature(t, T0=np.array(T1[0]), transit=transit)["T_surf"] plt.plot(t, T1, "--", c=cl, label="%s - steady" % (key,)) plt.plot(t, T2, "-", c=cl, label="%s - transient" % (key,)) @@ -83,14 +83,14 @@ plt.figure() elm = slv["rte"] elm.dc["transit"] = transit - df = elm.steady_temperature(return_avg=True, return_core=True) + dct = elm.steady_temperature(return_avg=True, return_core=True) elm.dc["transit"] = np.nan cl = "C0" dg = elm.transient_temperature( t, T0=T1[0], transit=transit, return_avg=True, return_core=True ) - plt.fill_between(t, df["T_surf"], df["T_core"], fc=cl, alpha=0.33) - plt.plot(t, df["T_avg"], "--", c=cl, label="%s - steady" % (key,)) + plt.fill_between(t, dct["T_surf"], dct["T_core"], fc=cl, alpha=0.33) + plt.plot(t, dct["T_avg"], "--", c=cl, label="%s - steady" % (key,)) plt.fill_between(t, dg["T_surf"], dg["T_core"], fc=cl, alpha=0.33) plt.plot(t, dg["T_avg"], "-", c=cl, label="%s - transient" % (key,)) diff --git a/examples/example_transient2.py b/examples/example_transient2.py index a6d1bb9..ba1842e 100644 --- a/examples/example_transient2.py +++ b/examples/example_transient2.py @@ -67,11 +67,11 @@ elm = slv[key] elm.dc["transit"] = transit[:, 1] elm.dc["Ta"] = elm.dc["Ta"][1] - df = elm.steady_temperature() + dictionary = elm.steady_temperature() elm.dc["transit"] = np.nan elm.dc["Ta"] = dct["Ta"] cl = "C%d" % (i % 10,) - T1 = df["T_surf"].values + T1 = dictionary["T_surf"] T2 = elm.transient_temperature(t, T0=np.array(T1[0]), transit=transit) for j in range(3): plt.plot(t, T2["T_surf"][:, j], "-", c=cl, label="%s - transient" % (key,)) diff --git a/src/thermohl/solver/slv1t.py b/src/thermohl/solver/slv1t.py index 2c2b113..817358c 100644 --- a/src/thermohl/solver/slv1t.py +++ b/src/thermohl/solver/slv1t.py @@ -177,7 +177,7 @@ def steady_intensity( return_power (bool, optional): Return power term values. The default is True. Returns: - dict[str, np.array]: A dictionary with temperature and other results (depending on inputs) in the keys. + dict[str, np.array]: A dictionary with intensity and other results (depending on inputs) in the keys. """ diff --git a/src/thermohl/solver/slv3t.py b/src/thermohl/solver/slv3t.py index 6032fc5..af9dc13 100644 --- a/src/thermohl/solver/slv3t.py +++ b/src/thermohl/solver/slv3t.py @@ -462,7 +462,7 @@ def steady_intensity( return_power (bool): If True, return the power profiles in the output DataFrame. Default is True. Returns: - dict[str, np.ndarray]: A dictionary with temperature and other results (depending on inputs) in the keys. + dict[str, np.ndarray]: A dictionary with intensity and other results (depending on inputs) in the keys. """ Tmax, newtheader = self._steady_intensity_header(T, target) diff --git a/test/test_shape.py b/test/test_shape.py index 23ae668..7b3f771 100644 --- a/test/test_shape.py +++ b/test/test_shape.py @@ -6,7 +6,6 @@ # SPDX-License-Identifier: MPL-2.0 import numpy as np -import pandas as pd from thermohl import solver @@ -19,7 +18,7 @@ def _solvers(): return li -def _ampargs(s: solver.Solver, t: pd.DataFrame): +def _ampargs(s: solver.Solver, t: dict[str, np.ndarray]): if isinstance(s, solver.Solver1T): a = dict(T=t[solver.Solver.Names.temp]) elif isinstance(s, solver.Solver3T): @@ -29,7 +28,7 @@ def _ampargs(s: solver.Solver, t: pd.DataFrame): return a -def _traargs(s: solver.Solver, ds: pd.DataFrame, t): +def _traargs(s: solver.Solver, ds: dict[str, np.ndarray], t): if isinstance(s, solver.Solver1T): a = dict(time=t, T0=ds[solver.Solver.Names.temp]) elif isinstance(s, solver.Solver3T): diff --git a/test/unit/solver/test_slv1t.py b/test/unit/solver/test_slv1t.py index a34b277..f0c2577 100644 --- a/test/unit/solver/test_slv1t.py +++ b/test/unit/solver/test_slv1t.py @@ -7,7 +7,6 @@ import pytest import numpy as np -import pandas as pd from thermohl.solver.slv1t import Solver1T diff --git a/thermohl-docs/docs/examples/ex_transient_3t.ipynb b/thermohl-docs/docs/examples/ex_transient_3t.ipynb index 86d6ee8..4e1a512 100644 --- a/thermohl-docs/docs/examples/ex_transient_3t.ipynb +++ b/thermohl-docs/docs/examples/ex_transient_3t.ipynb @@ -1,115 +1,148 @@ { "cells": [ { - "cell_type": "code", - "execution_count": 3, - "id": "756e1159-fcbe-4fda-8de9-1e4c1c87214d", "metadata": {}, - "outputs": [], + "cell_type": "raw", "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "from thermohl import solver" - ] - }, - { - "cell_type": "markdown", - "id": "454c9c02-11c1-49a7-800b-3cc28c8f5046", - "metadata": {}, - "source": [ - "This function plots conductor temperatures (surface, average and core) when a step of transit occurs. Simulation made with the 3t solver and RTE power terms. " - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "54a4c33b-f71b-43b1-a9d0-a1ddf1230154", - "metadata": {}, - "outputs": [], - "source": [ - "def example_solver3t_transient(dic):\n", - " # create solver with rte power terms and 3t heat equation\n", - " slvr = solver.rte(dic, heateq=\"3t\")\n", - "\n", - " # change solver args to get initial state, compute initial values of surface\n", - " # and core temperature using steady temperature\n", - " slvr.args[\"transit\"] = 400.0\n", - " slvr.update()\n", - " dtstdy = slvr.steady_temperature()\n", - " T_surf = dtstdy[\"t_surf\"].values\n", - " T_core = dtstdy[\"t_core\"].values\n", - "\n", - " # restore initial transit in dic\n", - " slvr.args[\"transit\"] = dic[\"transit\"]\n", - " slvr.update()\n", - "\n", - " # compute temperature\n", - " dtemp = slvr.transient_temperature(t, Ts0=T_surf, Tc0=T_core, return_power=True)\n", - "\n", - " # plot\n", - " fig, ax = plt.subplots(nrows=1, ncols=1)\n", - " tm = t / 60\n", - " ax.fill_between(\n", - " tm, dtemp[\"t_surf\"], dtemp[\"t_core\"], fc=\"gray\", alpha=0.33, ec=None\n", - " )\n", - " ax.plot(tm, dtemp[\"t_surf\"], c=\"C0\", label=\"Surface Conductor temperature (C)\")\n", - " ax.plot(tm, dtemp[\"t_avg\"], c=\"C1\", label=\"average Conductor temperature (C)\")\n", - " ax.plot(tm, dtemp[\"t_core\"], c=\"C3\", label=\"Core Conductor temperature (C)\")\n", - " ax.set_xlabel(\"Time (hour)\")\n", - " ax.set_ylabel(\"Temperature (C)\")\n", - " ax.grid(True)\n", - " ax.legend()\n", - " %matplotlib inline\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "65ce6328-af5c-43e6-b389-2ec8157c348a", - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib\n", - "\n", - "matplotlib.use(\"TkAgg\")\n", - "plt.close(\"all\")\n", - "\n", - "# Generate input dict (for the sake of simplicity, only a few inputs are\n", - "# used, the rest is filled with default values).\n", - "dic = dict(\n", - " lat=46.1,\n", - " alt=123.0,\n", - " azm=31.0,\n", - " month=6,\n", - " day=20,\n", - " hour=0.0,\n", - " transit=700.0,\n", - ")\n", - "t = np.linspace(0, 3600, 901)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "349c1e0c-af4e-4331-95da-4e0f353a651d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } + "{\n", + " \"cells\": [\n", + " {\n", + " \"cell_type\": \"code\",\n", + " \"execution_count\": 3,\n", + " \"id\": \"756e1159-fcbe-4fda-8de9-1e4c1c87214d\",\n", + " \"metadata\": {},\n", + " \"outputs\": [],\n", + " \"source\": [\n", + " \"import matplotlib.pyplot as plt\\n\",\n", + " \"import numpy as np\\n\",\n", + " \"\\n\",\n", + " \"from thermohl import solver\"\n", + " ]\n", + " },\n", + " {\n", + " \"cell_type\": \"markdown\",\n", + " \"id\": \"454c9c02-11c1-49a7-800b-3cc28c8f5046\",\n", + " \"metadata\": {},\n", + " \"source\": [\n", + " \"This function plots conductor temperatures (surface, average and core) when a step of transit occurs. Simulation made with the 3t solver and RTE power terms. \"\n", + " ]\n", + " },\n", + " {\n", + " \"cell_type\": \"code\",\n", + " \"execution_count\": 7,\n", + " \"id\": \"54a4c33b-f71b-43b1-a9d0-a1ddf1230154\",\n", + " \"metadata\": {},\n", + " \"outputs\": [],\n", + " \"source\": [\n", + " \"def example_solver3t_transient(dic):\\n\",\n", + " \"\\n\",\n", + " \" # create solver with rte power terms and 3t heat equation\\n\",\n", + " \" slvr = solver.rte(dic, heateq=\\\"3t\\\")\\n\",\n", + " \"\\n\",\n", + " \" # change solver args to get initial state, compute initial values of surface\\n\",\n", + " \" # and core temperature using steady temperature\\n\",\n", + " \" slvr.args[\\\"transit\\\"] = 400.0\\n\",\n", + " \" slvr.update()\\n\",\n", + " \" dtstdy = slvr.steady_temperature()\\n\",\n", + " \" T_surf = dtstdy['t_surf']\\n\",\n", + " \" T_core = dtstdy['t_core']\\n\",\n", + " \"\\n\",\n", + " \" # restore initial transit in dic\\n\",\n", + " \" slvr.args[\\\"transit\\\"] = dic[\\\"transit\\\"]\\n\",\n", + " \" slvr.update()\\n\",\n", + " \"\\n\",\n", + " \"\\n\",\n", + " \" # compute temperature\\n\",\n", + " \" dtemp = slvr.transient_temperature(t, Ts0=T_surf, Tc0=T_core, return_power=True)\\n\",\n", + " \"\\n\",\n", + " \" # plot\\n\",\n", + " \" fig, ax = plt.subplots(nrows=1, ncols=1)\\n\",\n", + " \" tm = t / 60\\n\",\n", + " \" ax.fill_between(tm, dtemp['t_surf'], dtemp['t_core'], fc='gray', alpha=0.33, ec=None)\\n\",\n", + " \" ax.plot(tm, dtemp['t_surf'], c='C0', label='Surface Conductor temperature (C)')\\n\",\n", + " \" ax.plot(tm, dtemp['t_avg'], c='C1', label='average Conductor temperature (C)')\\n\",\n", + " \" ax.plot(tm, dtemp['t_core'], c='C3', label='Core Conductor temperature (C)')\\n\",\n", + " \" ax.set_xlabel(\\\"Time (hour)\\\")\\n\",\n", + " \" ax.set_ylabel(\\\"Temperature (C)\\\")\\n\",\n", + " \" ax.grid(True)\\n\",\n", + " \" ax.legend()\\n\",\n", + " \" %matplotlib inline\\n\",\n", + " \" plt.show()\"\n", + " ]\n", + " },\n", + " {\n", + " \"cell_type\": \"code\",\n", + " \"execution_count\": 8,\n", + " \"id\": \"65ce6328-af5c-43e6-b389-2ec8157c348a\",\n", + " \"metadata\": {},\n", + " \"outputs\": [],\n", + " \"source\": [\n", + " \"import matplotlib\\n\",\n", + " \"\\n\",\n", + " \"matplotlib.use(\\\"TkAgg\\\")\\n\",\n", + " \"plt.close(\\\"all\\\")\\n\",\n", + " \"\\n\",\n", + " \"# Generate input dict (for the sake of simplicity, only a few inputs are\\n\",\n", + " \"# used, the rest is filled with default values).\\n\",\n", + " \"dic = dict(\\n\",\n", + " \" lat=46.1,\\n\",\n", + " \" alt=123.0,\\n\",\n", + " \" azm=31.0,\\n\",\n", + " \" month=6,\\n\",\n", + " \" day=20,\\n\",\n", + " \" hour=0.0,\\n\",\n", + " \" transit=700.0,\\n\",\n", + " \")\\n\",\n", + " \"t = np.linspace(0, 3600, 901)\\n\",\n", + " \"\\n\"\n", + " ]\n", + " },\n", + " {\n", + " \"cell_type\": \"code\",\n", + " \"execution_count\": 9,\n", + " \"id\": \"349c1e0c-af4e-4331-95da-4e0f353a651d\",\n", + " \"metadata\": {},\n", + " \"outputs\": [\n", + " {\n", + " \"data\": {\n", + " \"image/png\": \"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\",\n", + " \"text/plain\": [\n", + " \"
\"\n", + " ]\n", + " },\n", + " \"metadata\": {},\n", + " \"output_type\": \"display_data\"\n", + " }\n", + " ],\n", + " \"source\": [\n", + " \"example_solver3t_transient(dic)\"\n", + " ]\n", + " }\n", + " ],\n", + " \"metadata\": {\n", + " \"kernelspec\": {\n", + " \"display_name\": \"Python 3 (ipykernel)\",\n", + " \"language\": \"python\",\n", + " \"name\": \"python3\"\n", + " },\n", + " \"language_info\": {\n", + " \"codemirror_mode\": {\n", + " \"name\": \"ipython\",\n", + " \"version\": 3\n", + " },\n", + " \"file_extension\": \".py\",\n", + " \"mimetype\": \"text/x-python\",\n", + " \"name\": \"python\",\n", + " \"nbconvert_exporter\": \"python\",\n", + " \"pygments_lexer\": \"ipython3\",\n", + " \"version\": \"3.12.4\"\n", + " }\n", + " },\n", + " \"nbformat\": 4,\n", + " \"nbformat_minor\": 5\n", + "}\n" ], - "source": [ - "example_solver3t_transient(dic)" - ] + "id": "72578da3234b296a" } ], "metadata": { From 131863f1af9c0b3c137cafacbe7f04ae8cab3595 Mon Sep 17 00:00:00 2001 From: Olivier Pigeon Date: Fri, 23 Jan 2026 13:31:34 +0100 Subject: [PATCH 3/3] feat(#2): Make the branch uv compliant Signed-off-by: Olivier Pigeon --- examples/example_solver_intensity.py | 5 ++++- src/thermohl/solver/base.py | 22 ++++++++++++++++------ src/thermohl/solver/slv1t.py | 3 --- src/thermohl/solver/slv3t.py | 5 +++-- test/test_shape.py | 2 +- test/test_solver1t.py | 18 +++++++++--------- test/test_solver3t.py | 12 ++++-------- 7 files changed, 37 insertions(+), 30 deletions(-) diff --git a/examples/example_solver_intensity.py b/examples/example_solver_intensity.py index b4c0989..034fe18 100644 --- a/examples/example_solver_intensity.py +++ b/examples/example_solver_intensity.py @@ -83,7 +83,10 @@ def test_solve(dct, Trep, tol=1.0e-06, mxi=64): slv = d["model"] dictionary = slv.steady_intensity(Trep, tol=tol, maxiter=mxi, return_power=True) dictionary["pb"] = ( - dictionary["P_joule"] + dictionary["P_solar"] - dictionary["P_convection"] - dictionary["P_radiation"] + dictionary["P_joule"] + + dictionary["P_solar"] + - dictionary["P_convection"] + - dictionary["P_radiation"] ) slv.dc["transit"] = dictionary["I_max"] dictionary["TIrep"] = slv.steady_temperature(return_power=False)["T_surf"] diff --git a/src/thermohl/solver/base.py b/src/thermohl/solver/base.py index 8f7b08e..5bffe86 100644 --- a/src/thermohl/solver/base.py +++ b/src/thermohl/solver/base.py @@ -267,7 +267,7 @@ def balance(self, T: floatArrayLike) -> floatArrayLike: ) @abstractmethod - def steady_temperature(self) -> pd.DataFrame: + def steady_temperature(self) -> dict[str, np.ndarray]: raise NotImplementedError @abstractmethod @@ -275,13 +275,17 @@ def transient_temperature(self) -> Dict[str, Any]: raise NotImplementedError @abstractmethod - def steady_intensity(self) -> pd.DataFrame: + def steady_intensity(self) -> dict[str, np.ndarray]: raise NotImplementedError @staticmethod - def format_output(columns_names: list[str], data: list[np.ndarray]) -> dict[str, np.ndarray]: + def format_output( + columns_names: list[str], data: list[np.ndarray] + ) -> dict[str, np.ndarray]: if len(columns_names) != len(data): - raise ValueError(f"columns_names and data must have the same length but len(columns_names)={len(columns_names)} and len(data)={len(data)}") + raise ValueError( + f"columns_names and data must have the same length but len(columns_names)={len(columns_names)} and len(data)={len(data)}" + ) return {columns_names[i]: data[i] for i in range(len(columns_names))} @@ -294,9 +298,15 @@ def add_error_if_needed(err, output, return_err): if return_err: output[Solver.Names.err] = err - def add_powers_if_needed(self, temperature_average, output, return_power, temperature_surface=None): + def add_powers_if_needed( + self, temperature_average, output, return_power, temperature_surface=None + ): if return_power: - temperature_surface = temperature_surface if temperature_surface is not None else temperature_average + temperature_surface = ( + temperature_surface + if temperature_surface is not None + else temperature_average + ) output[Solver.Names.pjle] = self.jh.value(temperature_average) output[Solver.Names.psol] = self.sh.value(temperature_surface) output[Solver.Names.pcnv] = self.cc.value(temperature_surface) diff --git a/src/thermohl/solver/slv1t.py b/src/thermohl/solver/slv1t.py index 817358c..cdf4a73 100644 --- a/src/thermohl/solver/slv1t.py +++ b/src/thermohl/solver/slv1t.py @@ -9,7 +9,6 @@ from typing import Dict, Any, Optional import numpy as np -import pandas as pd from thermohl import floatArrayLike, floatArray from thermohl.solver.base import Solver as Solver_ @@ -19,7 +18,6 @@ class Solver1T(Solver_): - def steady_temperature( self, Tmin: float = DP.tmin, @@ -209,4 +207,3 @@ def fun(i: floatArray) -> floatArrayLike: self.add_error_and_power_if_needed(T_, err, result, return_err, return_power) return result - diff --git a/src/thermohl/solver/slv3t.py b/src/thermohl/solver/slv3t.py index af9dc13..f0d728c 100644 --- a/src/thermohl/solver/slv3t.py +++ b/src/thermohl/solver/slv3t.py @@ -8,7 +8,6 @@ from typing import Tuple, Type, Optional, Dict, Any, Callable import numpy as np -import pandas as pd from thermohl import floatArrayLike, floatArray, strListLike, intArray from thermohl.power import PowerTerm @@ -229,7 +228,9 @@ def steady_temperature( # format output z = self.average(x, y) - result = self.format_output([Solver_.Names.tsurf, Solver_.Names.tavg, Solver_.Names.tcore], [x, z, y]) + result = self.format_output( + [Solver_.Names.tsurf, Solver_.Names.tavg, Solver_.Names.tcore], [x, z, y] + ) self.add_error_and_power_if_needed(x, err, result, return_err, return_power) return result diff --git a/test/test_shape.py b/test/test_shape.py index 7b3f771..a269f3e 100644 --- a/test/test_shape.py +++ b/test/test_shape.py @@ -79,7 +79,7 @@ def test_steady_default(): def check_number_of_lines_in_result(dictionary, expected_lines: int): - for (key, val) in dictionary.items(): + for key, val in dictionary.items(): assert val.shape == (expected_lines,) diff --git a/test/test_solver1t.py b/test/test_solver1t.py index 140c317..bdafbbb 100644 --- a/test/test_solver1t.py +++ b/test/test_solver1t.py @@ -38,20 +38,20 @@ def test_balance(): ) for s in _solvers(dic): - df = s.steady_temperature( + dct = s.steady_temperature( return_err=True, return_power=True, tol=tol, maxiter=64 ) - assert np.all(df["err"] < tol) + assert np.all(dct["err"] < tol) bl = np.abs( - df["P_joule"] - + df["P_solar"] - - df["P_convection"] - - df["P_radiation"] - - df["P_precipitation"] + dct["P_joule"] + + dct["P_solar"] + - dct["P_convection"] + - dct["P_radiation"] + - dct["P_precipitation"] ) atol = np.maximum( - np.abs(s.balance(df["t"] + 0.5 * df["err"])), - np.abs(s.balance(df["t"] - 0.5 * df["err"])), + np.abs(s.balance(dct["t"] + 0.5 * dct["err"])), + np.abs(s.balance(dct["t"] - 0.5 * dct["err"])), ) assert np.allclose(bl, 0.0, atol=atol) diff --git a/test/test_solver3t.py b/test/test_solver3t.py index 9e6ec99..f309468 100644 --- a/test/test_solver3t.py +++ b/test/test_solver3t.py @@ -48,17 +48,13 @@ def test_balance(): ) t1 = t1["t"] # 3t solve - df = s.steady_temperature( + dct = s.steady_temperature( Tsg=t1, Tcg=t1, return_err=True, return_power=True, tol=tol, maxiter=64 ) # checks - assert np.all(df["err"] < tol) - assert np.allclose( - s.balance(ts=df["t_surf"], tc=df["t_core"]), 0.0, atol=tol - ) - assert np.allclose( - s.morgan(ts=df["t_surf"], tc=df["t_core"]), 0.0, atol=tol - ) + assert np.all(dct["err"] < tol) + assert np.allclose(s.balance(ts=dct["t_surf"], tc=dct["t_core"]), 0.0, atol=tol) + assert np.allclose(s.morgan(ts=dct["t_surf"], tc=dct["t_core"]), 0.0, atol=tol) def test_consistency():