The model module

These thermal model classes provide an easy-to-use interface to compute the thermal rating. They store conductor and span metadata as well as the weather parameters, compute all the heating and cooling effects and use those to estimate the thermal rating and conductor temperature. All numerical heavy-lifting is handled by the linerate.equations and the linerate.solver modules.

class linerate.model.ThermalModel(span, weather)

Abstract class for a minimal conductor thermal model.

abstractmethod compute_resistance(conductor_temperature, current)

Compute the conductor resistance, \(R~\left[\Omega~\text{m}^{-1}\right]\).

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(R~\left[\Omega\right]\). The resistance at the given temperature and current.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

abstractmethod compute_joule_heating(conductor_temperature, current)

Compute the Joule heating, \(P_J~\left[\text{W}~\text{m}^{-1}\right]\).

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(P_J~\left[\text{W}~\text{m}^{-1}\right]\). The Joule heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_solar_heating()

Compute the solar heating, \(P_S~\left[\text{W}~\text{m}^{-1}\right]\).

Returns:

\(P_s~\left[\text{W}~\text{m}^{-1}\right]\). The solar heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

abstractmethod compute_global_radiation_intensity()

Compute the global radiation intensity, \(I_T~\left[\text{W}~\text{m}^{-2}\right]\).

Returns:

\(I_T~\left[\text{W}~\text{m}^{-1}\right]\). The solar heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

abstractmethod compute_convective_cooling(conductor_temperature)

Compute the convective cooling, \(P_c~\left[\text{W}~\text{m}^{-1}\right]\).

Parameters:

conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

Returns:

\(P_c~\left[\text{W}~\text{m}^{-1}\right]\). The convective cooling.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

abstractmethod compute_radiative_cooling(conductor_temperature)

Compute the radiative cooling, \(P_r~\left[\text{W}~\text{m}^{-1}\right]\).

Parameters:

conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

Returns:

\(P_r~\left[\text{W}~\text{m}^{-1}\right]\). The radiative cooling heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_heat_balance(conductor_temperature, current)

Compute the conductor’s heat balance. Positive means heating and negative means cooling.

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(P_J + P_s - P_c - P_r~\left[\text{W}~\text{m}^{-1}\right]\). The heat balance.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_info(conductor_temperature, current)

Create a dictionary with the different heating and cooling effects.

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

A dictionary with the magnitude of the different heating and cooling effects.

Return type:

Dict[str, WattPerMeter]

compute_steady_state_ampacity(max_conductor_temperature, min_ampacity=0, max_ampacity=5000, tolerance=1.0, accept_invalid_values=False)

Use the bisection method to compute the steady-state thermal rating (ampacity).

Parameters:

• max_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{max}~\left[^\circ\text{C}\right]\). Maximum allowed conductor temperature

• min_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Lower bound for the numerical scheme for computing the ampacity

• max_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Upper bound for the numerical scheme for computing the ampacity

• tolerance (float) – \(\Delta I~\left[\text{A}\right]\). The numerical accuracy of the ampacity. The bisection iterations will stop once the numerical ampacity uncertainty is below \(\Delta I\). The bisection method will run for \(\left\lceil\frac{I_\text{min} - I_\text{min}}{\Delta I}\right\rceil\) iterations.

• accept_invalid_values (bool) – If True, np.nan is returned whenever the current cannot be found within the provided search interval. If False, a ValueError will be raised instead.

Returns:

\(I~\left[\text{A}\right]\). The thermal rating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_conductor_temperature(current, min_temperature=-30, max_temperature=150, tolerance=0.5)

Use the bisection method to compute the steady state conductor temperature.

Parameters:

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{max}~\left[\text{A}\right]\). The current flowing through the conductor. NOTE that the current is the total current for all conductors in the span. When computing the temperature, the current is divided by the number of conductors.

• min_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{min}~\left[^\circ\text{C}\right]\). Lower bound for the numerical scheme for computing the temperature

• max_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{max}~\left[^\circ\text{C}\right]\). Upper bound for the numerical scheme for computing the temperature

• tolerance (float) – \(\Delta T~\left[^\circ\text{C}\right]\). The numerical accuracy of the temperature. The bisection iterations will stop once the numerical temperature uncertainty is below \(\Delta T\). The bisection method will run for \(\left\lceil\frac{T_\text{min} - T_\text{min}}{\Delta T}\right\rceil\) iterations.

Returns:

\(I~\left[\text{A}\right]\). The thermal rating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_heat_capacity_per_unit_length(conductor_temperature)

Compute the heat capacity of the conductor per unit length. :param conductor_temperature: \(T~\left[^\circ\text{C}\right]\) Conductor temperature.

Returns:

\(c~\left[\text{J}\text{kg}^{-1}\text{K}^{-1}\text{m}^{-1}\right]\). Conductor heat capacity per unit length.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_temperature_after_heating(initial_conductor_temperature, heating_duration, current, time_step=np.timedelta64(1, 's'))

Compute conductor temperature after it is heated for a time using an iterative method.

Parameters:

• initial_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{init}~\left[^\circ\text{C}\right]\). Temperature of the conductor at the start of heating.

• heating_duration (timedelta64) – \(t\). Duration of heating.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). Current heating the conductor

• time_step (timedelta64) – \(\Delta t\). Time step of heating. Unit is changed to seconds in the function.

Returns:

\(T~\left[^\circ\text{C}\right]\). Conductor temperature.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_transient_ampacity(max_conductor_temperature, heating_duration, initial_conductor_temperature, time_step=np.timedelta64(60, 's'), min_ampacity=0, max_ampacity=5000, tolerance=1.0, accept_invalid_values=False)

Use the bisection method to compute the transient thermal rating (ampacity).

Parameters:

• max_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{max}~\left[^\circ\text{C}\right]\). Maximum allowed conductor temperature

• heating_duration (timedelta64) – \(t\). Duration of heating.

• initial_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{init}~\left[^\circ\text{C}\right]\). Temperature of the conductor at the start of heating.

• time_step (timedelta64) – \(\Delta t\). Time step of heating. Unit is changed to seconds in the function.

• min_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Lower bound for the numerical scheme for computing the ampacity

• max_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Upper bound for the numerical scheme for computing the ampacity

• tolerance (float) – \(\Delta I~\left[\text{A}\right]\). The numerical accuracy of the ampacity. The bisection iterations will stop once the numerical ampacity uncertainty is below \(\Delta I\). The bisection method will run for \(\left\lceil\frac{I_\text{min} - I_\text{min}}{\Delta I}\right\rceil\) iterations.

• accept_invalid_values (bool) – If True, np.nan is returned whenever the current cannot be found within the provided search interval. If False, a ValueError will be raised instead.

Returns:

\(I~\left[\text{A}\right]\). The transient thermal rating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

class linerate.model.Cigre601(span, weather, time, max_reynolds_number=4000.0)

Extension of the BaseCigre601 model that uses the solar radiation parametrisation in CIGRE601.

compute_global_radiation_intensity()

Compute the global radiation intensity, \(I_T~\left[\text{W}~\text{m}^{-2}\right]\).

Returns:

\(I_T~\left[\text{W}~\text{m}^{-1}\right]\). The solar heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_conductor_temperature(current, min_temperature=-30, max_temperature=150, tolerance=0.5)

Use the bisection method to compute the steady state conductor temperature.

Parameters:

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{max}~\left[\text{A}\right]\). The current flowing through the conductor. NOTE that the current is the total current for all conductors in the span. When computing the temperature, the current is divided by the number of conductors.

• min_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{min}~\left[^\circ\text{C}\right]\). Lower bound for the numerical scheme for computing the temperature

• max_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{max}~\left[^\circ\text{C}\right]\). Upper bound for the numerical scheme for computing the temperature

• tolerance (float) – \(\Delta T~\left[^\circ\text{C}\right]\). The numerical accuracy of the temperature. The bisection iterations will stop once the numerical temperature uncertainty is below \(\Delta T\). The bisection method will run for \(\left\lceil\frac{T_\text{min} - T_\text{min}}{\Delta T}\right\rceil\) iterations.

Returns:

\(I~\left[\text{A}\right]\). The thermal rating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_convective_cooling(conductor_temperature)

Compute the convective cooling, \(P_c~\left[\text{W}~\text{m}^{-1}\right]\).

Parameters:

conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

Returns:

\(P_c~\left[\text{W}~\text{m}^{-1}\right]\). The convective cooling.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_heat_balance(conductor_temperature, current)

Compute the conductor’s heat balance. Positive means heating and negative means cooling.

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(P_J + P_s - P_c - P_r~\left[\text{W}~\text{m}^{-1}\right]\). The heat balance.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_heat_capacity_per_unit_length(conductor_temperature)

Compute the heat capacity of the conductor per unit length. :param conductor_temperature: \(T~\left[^\circ\text{C}\right]\) Conductor temperature.

Returns:

\(c~\left[\text{J}\text{kg}^{-1}\text{K}^{-1}\text{m}^{-1}\right]\). Conductor heat capacity per unit length.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_info(conductor_temperature, current)

Create a dictionary with the different heating and cooling effects.

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

A dictionary with the magnitude of the different heating and cooling effects.

Return type:

Dict[str, WattPerMeter]

compute_joule_heating(conductor_temperature, current)

Compute the Joule heating, \(P_J~\left[\text{W}~\text{m}^{-1}\right]\).

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(P_J~\left[\text{W}~\text{m}^{-1}\right]\). The Joule heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_radiative_cooling(conductor_temperature)

Compute the radiative cooling, \(P_r~\left[\text{W}~\text{m}^{-1}\right]\).

Parameters:

conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

Returns:

\(P_r~\left[\text{W}~\text{m}^{-1}\right]\). The radiative cooling heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_resistance(conductor_temperature, current)

Compute the conductor resistance, \(R~\left[\Omega~\text{m}^{-1}\right]\).

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(R~\left[\Omega\right]\). The resistance at the given temperature and current.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_solar_heating()

Compute the solar heating, \(P_S~\left[\text{W}~\text{m}^{-1}\right]\).

Returns:

\(P_s~\left[\text{W}~\text{m}^{-1}\right]\). The solar heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_steady_state_ampacity(max_conductor_temperature, min_ampacity=0, max_ampacity=5000, tolerance=1.0, accept_invalid_values=False)

Use the bisection method to compute the steady-state thermal rating (ampacity).

Parameters:

• max_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{max}~\left[^\circ\text{C}\right]\). Maximum allowed conductor temperature

• min_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Lower bound for the numerical scheme for computing the ampacity

• max_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Upper bound for the numerical scheme for computing the ampacity

• tolerance (float) – \(\Delta I~\left[\text{A}\right]\). The numerical accuracy of the ampacity. The bisection iterations will stop once the numerical ampacity uncertainty is below \(\Delta I\). The bisection method will run for \(\left\lceil\frac{I_\text{min} - I_\text{min}}{\Delta I}\right\rceil\) iterations.

• accept_invalid_values (bool) – If True, np.nan is returned whenever the current cannot be found within the provided search interval. If False, a ValueError will be raised instead.

Returns:

\(I~\left[\text{A}\right]\). The thermal rating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_temperature_after_heating(initial_conductor_temperature, heating_duration, current, time_step=np.timedelta64(1, 's'))

Compute conductor temperature after it is heated for a time using an iterative method.

Parameters:

• initial_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{init}~\left[^\circ\text{C}\right]\). Temperature of the conductor at the start of heating.

• heating_duration (timedelta64) – \(t\). Duration of heating.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). Current heating the conductor

• time_step (timedelta64) – \(\Delta t\). Time step of heating. Unit is changed to seconds in the function.

Returns:

\(T~\left[^\circ\text{C}\right]\). Conductor temperature.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_temperature_gradient(conductor_temperature, current)

Estimate the difference between the core temperature and the surface temperature.

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(T_c - T_s~\left[^\circ \text{C}\right]\). The difference between the core and the surface temperature of the conductor.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_transient_ampacity(max_conductor_temperature, heating_duration, initial_conductor_temperature, time_step=np.timedelta64(60, 's'), min_ampacity=0, max_ampacity=5000, tolerance=1.0, accept_invalid_values=False)

Use the bisection method to compute the transient thermal rating (ampacity).

Parameters:

• max_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{max}~\left[^\circ\text{C}\right]\). Maximum allowed conductor temperature

• heating_duration (timedelta64) – \(t\). Duration of heating.

• initial_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{init}~\left[^\circ\text{C}\right]\). Temperature of the conductor at the start of heating.

• time_step (timedelta64) – \(\Delta t\). Time step of heating. Unit is changed to seconds in the function.

• min_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Lower bound for the numerical scheme for computing the ampacity

• max_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Upper bound for the numerical scheme for computing the ampacity

• tolerance (float) – \(\Delta I~\left[\text{A}\right]\). The numerical accuracy of the ampacity. The bisection iterations will stop once the numerical ampacity uncertainty is below \(\Delta I\). The bisection method will run for \(\left\lceil\frac{I_\text{min} - I_\text{min}}{\Delta I}\right\rceil\) iterations.

• accept_invalid_values (bool) – If True, np.nan is returned whenever the current cannot be found within the provided search interval. If False, a ValueError will be raised instead.

Returns:

\(I~\left[\text{A}\right]\). The transient thermal rating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

class linerate.model.IEEE738(span, weather, time, max_reynolds_number=50000.0)

compute_resistance(conductor_temperature, current)

Compute the conductor resistance, \(R~\left[\Omega~\text{m}^{-1}\right]\).

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(R~\left[\Omega\right]\). The resistance at the given temperature and current.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_joule_heating(conductor_temperature, current)

Compute the Joule heating, \(P_J~\left[\text{W}~\text{m}^{-1}\right]\).

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(P_J~\left[\text{W}~\text{m}^{-1}\right]\). The Joule heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_global_radiation_intensity()

Compute the global radiation intensity, \(I_T~\left[\text{W}~\text{m}^{-2}\right]\).

Returns:

\(I_T~\left[\text{W}~\text{m}^{-1}\right]\). The solar heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_convective_cooling(conductor_temperature)

Compute the convective cooling, \(P_c~\left[\text{W}~\text{m}^{-1}\right]\).

Parameters:

conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

Returns:

\(P_c~\left[\text{W}~\text{m}^{-1}\right]\). The convective cooling.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_radiative_cooling(conductor_temperature)

Compute the radiative cooling, \(P_r~\left[\text{W}~\text{m}^{-1}\right]\).

Parameters:

conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

Returns:

\(P_r~\left[\text{W}~\text{m}^{-1}\right]\). The radiative cooling heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_conductor_temperature(current, min_temperature=-30, max_temperature=150, tolerance=0.5)

Use the bisection method to compute the steady state conductor temperature.

Parameters:

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{max}~\left[\text{A}\right]\). The current flowing through the conductor. NOTE that the current is the total current for all conductors in the span. When computing the temperature, the current is divided by the number of conductors.

• min_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{min}~\left[^\circ\text{C}\right]\). Lower bound for the numerical scheme for computing the temperature

• max_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{max}~\left[^\circ\text{C}\right]\). Upper bound for the numerical scheme for computing the temperature

• tolerance (float) – \(\Delta T~\left[^\circ\text{C}\right]\). The numerical accuracy of the temperature. The bisection iterations will stop once the numerical temperature uncertainty is below \(\Delta T\). The bisection method will run for \(\left\lceil\frac{T_\text{min} - T_\text{min}}{\Delta T}\right\rceil\) iterations.

Returns:

\(I~\left[\text{A}\right]\). The thermal rating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_heat_balance(conductor_temperature, current)

Compute the conductor’s heat balance. Positive means heating and negative means cooling.

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(P_J + P_s - P_c - P_r~\left[\text{W}~\text{m}^{-1}\right]\). The heat balance.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_heat_capacity_per_unit_length(conductor_temperature)

Compute the heat capacity of the conductor per unit length. :param conductor_temperature: \(T~\left[^\circ\text{C}\right]\) Conductor temperature.

Returns:

\(c~\left[\text{J}\text{kg}^{-1}\text{K}^{-1}\text{m}^{-1}\right]\). Conductor heat capacity per unit length.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_info(conductor_temperature, current)

Create a dictionary with the different heating and cooling effects.

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

A dictionary with the magnitude of the different heating and cooling effects.

Return type:

Dict[str, WattPerMeter]

compute_solar_heating()

Compute the solar heating, \(P_S~\left[\text{W}~\text{m}^{-1}\right]\).

Returns:

\(P_s~\left[\text{W}~\text{m}^{-1}\right]\). The solar heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_steady_state_ampacity(max_conductor_temperature, min_ampacity=0, max_ampacity=5000, tolerance=1.0, accept_invalid_values=False)

Use the bisection method to compute the steady-state thermal rating (ampacity).

Parameters:

• max_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{max}~\left[^\circ\text{C}\right]\). Maximum allowed conductor temperature

• min_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Lower bound for the numerical scheme for computing the ampacity

• max_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Upper bound for the numerical scheme for computing the ampacity

• tolerance (float) – \(\Delta I~\left[\text{A}\right]\). The numerical accuracy of the ampacity. The bisection iterations will stop once the numerical ampacity uncertainty is below \(\Delta I\). The bisection method will run for \(\left\lceil\frac{I_\text{min} - I_\text{min}}{\Delta I}\right\rceil\) iterations.

• accept_invalid_values (bool) – If True, np.nan is returned whenever the current cannot be found within the provided search interval. If False, a ValueError will be raised instead.

Returns:

\(I~\left[\text{A}\right]\). The thermal rating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_temperature_after_heating(initial_conductor_temperature, heating_duration, current, time_step=np.timedelta64(1, 's'))

Compute conductor temperature after it is heated for a time using an iterative method.

Parameters:

• initial_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{init}~\left[^\circ\text{C}\right]\). Temperature of the conductor at the start of heating.

• heating_duration (timedelta64) – \(t\). Duration of heating.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). Current heating the conductor

• time_step (timedelta64) – \(\Delta t\). Time step of heating. Unit is changed to seconds in the function.

Returns:

\(T~\left[^\circ\text{C}\right]\). Conductor temperature.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_transient_ampacity(max_conductor_temperature, heating_duration, initial_conductor_temperature, time_step=np.timedelta64(60, 's'), min_ampacity=0, max_ampacity=5000, tolerance=1.0, accept_invalid_values=False)

Use the bisection method to compute the transient thermal rating (ampacity).

Parameters:

• max_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{max}~\left[^\circ\text{C}\right]\). Maximum allowed conductor temperature

• heating_duration (timedelta64) – \(t\). Duration of heating.

• initial_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{init}~\left[^\circ\text{C}\right]\). Temperature of the conductor at the start of heating.

• time_step (timedelta64) – \(\Delta t\). Time step of heating. Unit is changed to seconds in the function.

• min_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Lower bound for the numerical scheme for computing the ampacity

• max_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Upper bound for the numerical scheme for computing the ampacity

• tolerance (float) – \(\Delta I~\left[\text{A}\right]\). The numerical accuracy of the ampacity. The bisection iterations will stop once the numerical ampacity uncertainty is below \(\Delta I\). The bisection method will run for \(\left\lceil\frac{I_\text{min} - I_\text{min}}{\Delta I}\right\rceil\) iterations.

• accept_invalid_values (bool) – If True, np.nan is returned whenever the current cannot be found within the provided search interval. If False, a ValueError will be raised instead.

Returns:

\(I~\left[\text{A}\right]\). The transient thermal rating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

class linerate.model.Cigre207(span, weather, time, include_diffuse_radiation=True, direct_radiation_factor=1.0)

compute_joule_heating(conductor_temperature, current)

Compute the Joule heating, \(P_J~\left[\text{W}~\text{m}^{-1}\right]\).

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(P_J~\left[\text{W}~\text{m}^{-1}\right]\). The Joule heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_global_radiation_intensity()

Compute the global radiation intensity, \(I_T~\left[\text{W}~\text{m}^{-2}\right]\).

Returns:

\(I_T~\left[\text{W}~\text{m}^{-1}\right]\). The solar heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_convective_cooling(conductor_temperature)

Compute the convective cooling, \(P_c~\left[\text{W}~\text{m}^{-1}\right]\).

Parameters:

conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

Returns:

\(P_c~\left[\text{W}~\text{m}^{-1}\right]\). The convective cooling.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_radiative_cooling(conductor_temperature)

Compute the radiative cooling, \(P_r~\left[\text{W}~\text{m}^{-1}\right]\).

Parameters:

conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

Returns:

\(P_r~\left[\text{W}~\text{m}^{-1}\right]\). The radiative cooling heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_resistance(conductor_temperature, current)

Compute the conductor resistance, \(R~\left[\Omega~\text{m}^{-1}\right]\).

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(R~\left[\Omega\right]\). The resistance at the given temperature and current.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_conductor_temperature(current, min_temperature=-30, max_temperature=150, tolerance=0.5)

Use the bisection method to compute the steady state conductor temperature.

Parameters:

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{max}~\left[\text{A}\right]\). The current flowing through the conductor. NOTE that the current is the total current for all conductors in the span. When computing the temperature, the current is divided by the number of conductors.

• min_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{min}~\left[^\circ\text{C}\right]\). Lower bound for the numerical scheme for computing the temperature

• max_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{max}~\left[^\circ\text{C}\right]\). Upper bound for the numerical scheme for computing the temperature

• tolerance (float) – \(\Delta T~\left[^\circ\text{C}\right]\). The numerical accuracy of the temperature. The bisection iterations will stop once the numerical temperature uncertainty is below \(\Delta T\). The bisection method will run for \(\left\lceil\frac{T_\text{min} - T_\text{min}}{\Delta T}\right\rceil\) iterations.

Returns:

\(I~\left[\text{A}\right]\). The thermal rating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_heat_balance(conductor_temperature, current)

Compute the conductor’s heat balance. Positive means heating and negative means cooling.

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

\(P_J + P_s - P_c - P_r~\left[\text{W}~\text{m}^{-1}\right]\). The heat balance.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_heat_capacity_per_unit_length(conductor_temperature)

Compute the heat capacity of the conductor per unit length. :param conductor_temperature: \(T~\left[^\circ\text{C}\right]\) Conductor temperature.

Returns:

\(c~\left[\text{J}\text{kg}^{-1}\text{K}^{-1}\text{m}^{-1}\right]\). Conductor heat capacity per unit length.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_info(conductor_temperature, current)

Create a dictionary with the different heating and cooling effects.

Parameters:

• conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{av}~\left[^\circ\text{C}\right]\). The average conductor temperature.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). The current.

Returns:

A dictionary with the magnitude of the different heating and cooling effects.

Return type:

Dict[str, WattPerMeter]

compute_solar_heating()

Compute the solar heating, \(P_S~\left[\text{W}~\text{m}^{-1}\right]\).

Returns:

\(P_s~\left[\text{W}~\text{m}^{-1}\right]\). The solar heating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_steady_state_ampacity(max_conductor_temperature, min_ampacity=0, max_ampacity=5000, tolerance=1.0, accept_invalid_values=False)

Use the bisection method to compute the steady-state thermal rating (ampacity).

Parameters:

• max_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{max}~\left[^\circ\text{C}\right]\). Maximum allowed conductor temperature

• min_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Lower bound for the numerical scheme for computing the ampacity

• max_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Upper bound for the numerical scheme for computing the ampacity

• tolerance (float) – \(\Delta I~\left[\text{A}\right]\). The numerical accuracy of the ampacity. The bisection iterations will stop once the numerical ampacity uncertainty is below \(\Delta I\). The bisection method will run for \(\left\lceil\frac{I_\text{min} - I_\text{min}}{\Delta I}\right\rceil\) iterations.

• accept_invalid_values (bool) – If True, np.nan is returned whenever the current cannot be found within the provided search interval. If False, a ValueError will be raised instead.

Returns:

\(I~\left[\text{A}\right]\). The thermal rating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_temperature_after_heating(initial_conductor_temperature, heating_duration, current, time_step=np.timedelta64(1, 's'))

Compute conductor temperature after it is heated for a time using an iterative method.

Parameters:

• initial_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{init}~\left[^\circ\text{C}\right]\). Temperature of the conductor at the start of heating.

• heating_duration (timedelta64) – \(t\). Duration of heating.

• current (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I~\left[\text{A}\right]\). Current heating the conductor

• time_step (timedelta64) – \(\Delta t\). Time step of heating. Unit is changed to seconds in the function.

Returns:

\(T~\left[^\circ\text{C}\right]\). Conductor temperature.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]

compute_transient_ampacity(max_conductor_temperature, heating_duration, initial_conductor_temperature, time_step=np.timedelta64(60, 's'), min_ampacity=0, max_ampacity=5000, tolerance=1.0, accept_invalid_values=False)

Use the bisection method to compute the transient thermal rating (ampacity).

Parameters:

• max_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{max}~\left[^\circ\text{C}\right]\). Maximum allowed conductor temperature

• heating_duration (timedelta64) – \(t\). Duration of heating.

• initial_conductor_temperature (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], '°C']) – \(T_\text{init}~\left[^\circ\text{C}\right]\). Temperature of the conductor at the start of heating.

• time_step (timedelta64) – \(\Delta t\). Time step of heating. Unit is changed to seconds in the function.

• min_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Lower bound for the numerical scheme for computing the ampacity

• max_ampacity (Annotated[float | floating | ndarray[tuple[Any, ...], dtype[floating]], 'A']) – \(I_\text{min}~\left[\text{A}\right]\). Upper bound for the numerical scheme for computing the ampacity

• tolerance (float) – \(\Delta I~\left[\text{A}\right]\). The numerical accuracy of the ampacity. The bisection iterations will stop once the numerical ampacity uncertainty is below \(\Delta I\). The bisection method will run for \(\left\lceil\frac{I_\text{min} - I_\text{min}}{\Delta I}\right\rceil\) iterations.

• accept_invalid_values (bool) – If True, np.nan is returned whenever the current cannot be found within the provided search interval. If False, a ValueError will be raised instead.

Returns:

\(I~\left[\text{A}\right]\). The transient thermal rating.

Return type:

Union[float, float64, ndarray[Any, dtype[float64]]]