ubc-solar-physics 1.3.0__cp39-cp39-win_amd64.whl

physics/models/battery/battery.rs

@@ -0,0 +1,78 @@
+use std::f64;
+use numpy::ndarray::ArrayViewD;
+
+/// Evaluate a polynomial given coefficients and an input value (x)
+fn evaluate_polynomial(coefficients: &[f64], x: f64) -> f64 {
+    coefficients.iter().fold(0.0, |acc, &coeff| acc * x + coeff)
+}
+
+/// Evolve the battery state for a single step
+fn battery_evolve(
+    power: f64,                    // Watts
+    tick: f64,                     // Seconds
+    state_of_charge: f64,          // Dimensionless, 0 < SOC < 1
+    polarization_potential: f64,   // Volts
+    polarization_resistance: f64,  // Ohms
+    internal_resistance: f64,      // Ohms
+    open_circuit_voltage: f64,     // Volts
+    time_constant: f64,            // Seconds
+    nominal_charge_capacity: f64,  // Nominal charge capacity (Coulombs)
+) -> (f64, f64, f64) {
+    // Compute current (I) based on power input/output
+    let current: f64 = power / (open_circuit_voltage + polarization_potential + internal_resistance);
+
+    // Update state of charge and polarization potential
+    let new_state_of_charge: f64 = state_of_charge + (current * tick / nominal_charge_capacity);
+    let new_polarization_potential: f64 = f64::exp(-tick / time_constant) * polarization_potential
+        + current * polarization_resistance * (1.0 - f64::exp(-tick / time_constant));
+    let terminal_voltage: f64 = open_circuit_voltage + new_polarization_potential
+        + (current * internal_resistance); // Terminal voltage
+
+    (new_state_of_charge, new_polarization_potential, terminal_voltage)
+}
+
+pub fn update_battery_array(
+    delta_energy_array: ArrayViewD<'_, f64>,            // W*s
+    tick: f64,                                          // Seconds
+    initial_state_of_charge: f64,                       // dimensionless, 0 < SOC < 1
+    initial_polarization_potential: f64,                // Volts
+    polarization_resistance: f64,                       // Ohms
+    internal_resistance_coeffs: ArrayViewD<'_, f64>,    // Coefficients for internal resistance
+    open_circuit_voltage_coeffs: ArrayViewD<'_, f64>,   // Coefficients for open-circuit voltage
+    time_constant: f64,                                 // Seconds 
+    nominal_charge_capacity: f64,                       // Coulombs
+) -> (Vec<f64>, Vec<f64>) {
+    let mut state_of_charge: f64 = initial_state_of_charge; 
+    let mut polarization_potential: f64 = initial_polarization_potential;
+    let mut soc_array: Vec<f64> = Vec::with_capacity(delta_energy_array.len());
+    let mut voltage_array: Vec<f64> = Vec::with_capacity(delta_energy_array.len());
+
+    for &power in delta_energy_array.iter() {
+        // Interpolate values from coefficient
+        let open_circuit_voltage: f64 = evaluate_polynomial(open_circuit_voltage_coeffs.as_slice().unwrap(), state_of_charge);
+        let internal_resistance: f64 = evaluate_polynomial(internal_resistance_coeffs.as_slice().unwrap(), state_of_charge);
+
+        let (new_state_of_charge, new_polarization_potential, terminal_voltage) = battery_evolve(
+            power,
+            tick,
+            state_of_charge,
+            polarization_potential,
+            polarization_resistance,
+            internal_resistance,
+            open_circuit_voltage,
+            time_constant,
+            nominal_charge_capacity,
+        );
+
+        // Update state for the next iteration
+        state_of_charge = new_state_of_charge;
+        polarization_potential = new_polarization_potential;
+
+        // Store results
+        soc_array.push(new_state_of_charge);
+        voltage_array.push(terminal_voltage);
+    }
+
+    (soc_array, voltage_array)
+}
+

physics/models/battery/battery_config.py

@@ -0,0 +1,22 @@
+import tomli
+from pydantic import BaseModel
+from typing import List
+import os
+import pathlib
+
+class BatteryModelConfig(BaseModel):
+    R_0_data: List[float]
+    R_P: float
+    C_P: float
+    Q_total: float
+    SOC_data: List[float]
+    Uoc_data: List[float]
+    max_current_capacity: float
+    max_energy_capacity: float
+
+def load_battery_config(absolute_path: str) -> BatteryModelConfig:
+    # Build the full path to the config file
+    full_path = pathlib.Path(absolute_path)
+    with open(full_path, 'rb') as f:
+        data = tomli.load(f)
+    return BatteryModelConfig.model_validate(data)

physics/models/battery/battery_config.toml

@@ -0,0 +1,8 @@
+R_0_data = [0.002564, 0.002541, 0.002541, 0.002558, 0.002549, 0.002574, 0.002596, 0.002626, 0.002676, 0.002789]
+R_P = 0.000530
+C_P = 14646         
+Q_total = 259200
+SOC_data = [0.0752, 0.1705, 0.2677, 0.366, 0.4654, 0.5666, 0.6701, 0.7767, 0.8865, 1.0]
+Uoc_data = [3.481, 3.557, 3.597, 3.623, 3.660, 3.750, 3.846, 3.946, 4.056, 4.183]
+max_current_capacity = 40
+max_energy_capacity = 500

physics/models/battery/battery_model.py

@@ -0,0 +1,135 @@
+import numpy as np
+import core
+from scipy import optimize
+from physics.models.battery.battery_config import BatteryModelConfig
+
+
+class BatteryModel:
+    """
+    Class representing the Thevenin equivalent battery model with modular parameters.
+
+    Attributes:
+        R_P (float): Polarization resistance of the battery (Ohms).
+        C_P (float): Polarization capacitance of the battery (Farads).
+        max_current_capacity (float): Nominal capacity of the battery (Ah).
+        max_energy_capacity (float): Maximum energy capacity of the battery (Wh).
+        nominal_charge_capacity (float): Total charge capacity of the battery (Coulombs).
+        state_of_charge (float): Current state of charge (dimensionless, 0.0 to 1.0).
+        U_oc_coefficients (np.ndarray): Coefficients for the open-circuit voltage polynomial.
+        R_0_coefficients (np.ndarray): Coefficients for the ohmic resistance polynomial.
+        U_oc (callable): Function for open-circuit voltage as a function of state of charge (V).
+        R_0 (callable): Function for ohmic resistance as a function of state of charge (Ohms).
+        U_P (float): Current polarization potential (V).
+        U_L (float): Current terminal voltage (V).
+        tau (float): Time constant of the battery model (seconds).
+    """
+
+    def __init__(self, battery_config: BatteryModelConfig, state_of_charge=1):
+        """
+        Constructor for the BatteryModel class.
+
+        :param BatteryModelConfig battery_config: Configuration object containing the battery's parameters and data.
+        :param float state_of_charge: Initial state of charge of the battery (default is 1.0, fully charged).
+        """
+
+        # ----- Load Config -----
+
+        self.R_P = battery_config.R_P
+        self.C_P = battery_config.C_P
+        self.max_current_capacity = battery_config.max_current_capacity
+        self.max_energy_capacity = battery_config.max_energy_capacity
+        self.nominal_charge_capacity = battery_config.Q_total
+        Soc_data = battery_config.SOC_data
+        Uoc_data = battery_config.Uoc_data
+        R_0_data = battery_config.R_0_data
+
+        # ----- Initialize Parameters -----
+        def quintic_polynomial(x, x0, x1, x2, x3, x4):
+            return np.polyval(np.array([x0, x1, x2, x3, x4]), x)
+
+        self.U_oc_coefficients, _ = optimize.curve_fit(quintic_polynomial, Soc_data, Uoc_data)
+        self.R_0_coefficients, _ = optimize.curve_fit(quintic_polynomial, Soc_data, R_0_data)
+        self.U_oc = lambda soc: np.polyval(self.U_oc_coefficients, soc)  # V
+        self.R_0 = lambda soc: np.polyval(self.R_0_coefficients, soc)  # Ohms
+
+        self.U_P = 0.0  # V
+        self.U_L = 0.0  # V
+        self.state_of_charge = state_of_charge
+
+        self.tau = self.R_P * self.C_P  # Characteristic Time (seconds)
+
+        # calculated the charging and discharging currents
+        self.discharge_current = lambda P, U_oc, U_P, R_0: ((U_oc - U_P) - np.sqrt(
+            np.power((U_oc - U_P), 2) - 4 * R_0 * P)) / (2 * R_0)
+        self.charge_current = lambda P, U_oc, U_P, R_0: (-(U_oc + U_P) + np.sqrt(
+            np.power((U_oc + U_P), 2) + 4 * R_0 * P)) / (2 * R_0)
+
+    def _evolve(self, power: float, tick: float) -> None:
+        """
+        Update the battery state given the power and time elapsed.
+
+        :param float power: Power applied to the battery (W). Positive for charging, negative for discharging.
+        :param float T: Time interval over which the power is applied (seconds).
+        """
+        soc = self.state_of_charge  # State of Charge (dimensionless, 0 < soc < 1)
+        U_P = self.U_P  # Polarization Potential (V)
+        R_P = self.R_P  # Polarization Resistance (Ohms)
+        U_oc = self.U_oc(soc)  # Open-Circuit Potential (V)
+        R_0 = self.R_0(soc)  # Ohmic Resistance (Ohms)
+        Q = self.nominal_charge_capacity  # Nominal Charge Capacity (C)
+
+        current = self.discharge_current(power, U_oc, U_P, R_0) if power <= 0 else self.charge_current(power, U_oc, U_P, R_0)  # Current (A)
+
+        new_soc = soc + (current * tick / Q)
+        new_U_P = np.exp(-tick / self.tau) * U_P + current * R_P * (1 - np.exp(-tick / self.tau))
+
+        self.state_of_charge = new_soc
+        self.U_P = new_U_P
+        self.U_L = U_oc + U_P + (current * R_0)
+
+    def update_array(self, delta_energy_array, tick, rust=True):
+        """
+        Compute the battery's state of charge, voltage, and stored energy over time.
+        This function is a wrapper for the Rust-based and Python-based implementations.
+
+        :param np.ndarray delta_energy_array: Array of energy changes (J) at each time step.
+        :param float tick: Time interval for each step (seconds).
+        :param bool rust: If True, use Rust-based calculations (default is True).
+
+        :return: A tuple containing arrays for state-of-charge, voltage, and stored energy.
+        :rtype: tuple[np.ndarray, np.ndarray, np.ndarray]
+        """
+
+        if rust:
+            return core.update_battery_array(
+                delta_energy_array,
+                tick,
+                self.state_of_charge,
+                self.U_P,
+                self.R_P,
+                self.R_0_coefficients,
+                self.U_oc_coefficients,
+                self.tau,
+                self.nominal_charge_capacity
+            )
+        else:
+            return self._update_array_py(delta_energy_array, tick)
+
+    def _update_array_py(self, delta_energy_array, tick):
+        """
+        Perform energy calculations using Python (fallback method if Rust is disabled).
+
+        :param np.ndarray delta_energy_array: Array of energy changes (J) at each time step.
+        :param float tick: Time interval for each step (seconds).
+
+        :return: A tuple containing arrays for state-of-charge and voltage.
+        :rtype: tuple[np.ndarray, np.ndarray]
+        """
+        soc = np.empty_like(delta_energy_array, dtype=float)
+        voltage = np.empty_like(delta_energy_array, dtype=float)
+        for i, energy in enumerate(delta_energy_array):
+            self._evolve(energy, tick)
+            soc[i] = self.state_of_charge
+            voltage[i] = self.U_L
+
+        return soc, voltage

physics/models/battery/kalman_filter.py

@@ -0,0 +1,341 @@
+import numpy as np
+from scipy import optimize
+from filterpy.kalman import ExtendedKalmanFilter as EKF
+from physics.models.battery.battery_config import BatteryModelConfig
+
+
+class EKF_SOC:
+    def __init__(self, battery_config: BatteryModelConfig, initial_SOC=1, initial_Uc=0):
+        """
+        EKF_SOC represents the Kalman filter used for predicting state of charge.
+
+        :param BatteryModelConfig battery_config: Contains the HPPC parameters of the battery model.
+        :param float initial_SOC: Initial state of charge of the battery (ranges from 0 to 1 inclusive, default is 1).
+        :param float initial_Uc: Initial polarization voltage of the battery in volts (default is 0).
+        """
+        # Initial state
+        self.SOC = initial_SOC
+        self.Uc = initial_Uc  # Polarization Voltage
+
+        # Covariance Matrices
+        self.Q_covariance = np.eye(2) * 0.0001
+        self.R_covariance = np.eye(1) * 0.5  # currently not really trusting the predicted state
+
+        # Load Config data
+        self.R_P = battery_config.R_P
+        self.C_P = battery_config.C_P
+        self.Q_total = battery_config.Q_total
+        SOC_data = battery_config.SOC_data
+        Uoc_data = battery_config.Uoc_data
+        R_0_data = battery_config.R_0_data
+
+        def quintic_polynomial(x, x0, x1, x2, x3, x4):
+            return np.polyval([x0, x1, x2, x3, x4], x)
+
+        U_oc_coefficients, _ = optimize.curve_fit(quintic_polynomial, SOC_data, Uoc_data)
+        R_0_coefficients, _ = optimize.curve_fit(quintic_polynomial, SOC_data, R_0_data)
+        self.U_oc = lambda soc: np.polyval(U_oc_coefficients, soc)  # Open-circuit voltage as a function of SOC
+        self.R_0 = lambda soc: np.polyval(R_0_coefficients, soc)  # Resistance as a function of SOC
+        self.Uoc_derivative = lambda soc: np.polyval(np.polyder(U_oc_coefficients), soc)  # Derivative of Uoc wrt SOC
+
+        self.tau = self.R_P / self.C_P
+
+        # initializing the ekf object
+        self.ekf = EKF(dim_x=2, dim_z=1)
+        self.ekf.x = np.array([self.SOC, self.Uc])
+        self.ekf.P = np.diag([1e-6, 1e-6])  # I'm keeping low uncertainty in initial SOC and Uc
+        self.ekf.Q = self.Q_covariance
+        self.ekf.R = self.R_covariance
+
+        # For logs
+        self.predicted_measurement = 0
+    
+    def get_SOC(self): 
+        """
+        Return the current state of charge of the battery.
+
+        :return: The current state of charge.
+        :rtype: float
+        """
+        return self.SOC
+
+    def get_Uc(self):
+        """
+        Return the polarization voltage of the battery.
+
+        :return: The current polarization voltage.
+        :rtype: float
+        """
+        return self.Uc
+
+    def get_predicted_Ut(self):
+        """
+        Return the predicted terminal voltage for the last prediction step.
+
+        :return: The predicted terminal voltage.
+        :rtype: float
+        """
+        return self.predicted_measurement
+        
+    def update_filter(self, measured_Ut, I):
+        """
+        Update the filter based on a new measurement and the predicted state.
+        This function should be called after `predict_state` in a typical predict-update workflow.
+
+        :param float measured_Ut: The actual voltage across the terminals of the battery.
+        :param float I: The current being sourced by the battery.
+        """
+        check_Terminal_V(measured_Ut)
+
+        h_jacobian = self._measurement_jacobian
+        Hx = self._measurement_function
+
+        self.ekf.update(z=measured_Ut, HJacobian=h_jacobian, Hx=Hx, hx_args=I)
+
+        self.SOC, self.Uc = self.ekf.x
+
+    def predict_state(self, I, time_step):
+        """
+        Predict the next evolution of the state vector (SOC, Uc).
+        This function should be called before updating the filter in a typical predict-update workflow.
+
+        :param float I: The current being sourced by the battery. Positive indicates current being drawn.
+        :param float time_step: Time elapsed between this prediction and the last updated state of the filter (seconds).
+        """       
+        check_current(I)
+        # Control matrix B (for input current I_k)
+        self.ekf.B = np.array([-time_step / self.Q_total, self.R_P * (1 - np.exp(-time_step / self.tau))])
+        self.ekf.F = self._state_jacobian(time_step)
+
+        self.ekf.predict(u=I)
+        print(f'ekf prediction: {self.ekf.x_prior}')
+
+    def predict_then_update(self, measured_Ut, I, time_step):
+        """
+        Predict the next evolution of the state vector (SOC, Uc), then update the filter
+        based on this prediction and a measurement. Abstracts the full predict-update workflow of the EKF.
+
+        :param float measured_Ut: The actual voltage across the terminals of the battery.
+        :param float I: The current being sourced by the battery. Positive indicates current being drawn.
+        :param float time_step: Time elapsed between this prediction and the last updated state of the filter (seconds).
+        """
+        check_current(I)
+        check_Terminal_V(measured_Ut)
+
+        self.predict_state(I, time_step)
+        print(f'predicted: {self.ekf.x_prior}')
+
+        self.update_filter(measured_Ut, I)
+        print(f'SOC: {self.ekf.x[0]}, Uc: {self.ekf.x[1]}')
+
+    def _state_jacobian(self, time_step):
+        """
+        Return the state Jacobian matrix for the current time step.
+
+        :param float time_step: Time elapsed between this prediction and the last updated state of the filter (seconds).
+        :return: The state Jacobian matrix.
+        :rtype: np.ndarray
+        """
+        return np.array([[1, 0], [0, np.exp(-time_step / self.tau)]])
+
+    def _measurement_jacobian(self, x):
+        """
+        Return the measurement Jacobian matrix for the current state vector.
+
+        :param list[float, float] x: The state vector [SOC, Uc].
+        :return: The measurement Jacobian matrix.
+        :rtype: np.ndarray
+        """
+        SOC = x[0]
+        derivative = self.Uoc_derivative(SOC)
+        return np.array([[derivative, -1]])
+
+    def _measurement_function(self, x, I):
+        """
+        Return the measurement function relating terminal voltage to SOC and polarization voltage.
+
+        :param list[float, float] x: The state vector [SOC, Uc].
+        :param float I: The current being sourced by the battery.
+        :return: The predicted terminal voltage.
+        :rtype: float
+        """
+        SOC, Uc = x
+        R_0 = self.R_0(SOC)
+        Uoc = self.U_oc(SOC)
+        self.predicted_measurement = Uoc - Uc - R_0 * I
+        return self.predicted_measurement
+
+
+def check_current(I):
+    if not isinstance(I, (float, int)):
+        raise TypeError(f"Invalid type for current I: {type(I)}. Expected float or int.")
+    if not (-45.0 <= I <= 45.0):
+        raise ValueError(f"Invalid value for current (I): {I}. Must be between -45.0A and 45.0A.")
+
+
+def check_Terminal_V(Ut):
+    if not isinstance(Ut, (float, int)):
+        raise TypeError(f"Invalid type for measured_Ut: {type(Ut)}. Expected float or int.")
+    if not (0.0 <= Ut <= 5.0):
+        raise ValueError(f"Invalid value for terminal voltage (measured_Ut): {Ut}. Must be between 0.0 and 5.0 volts.")
+
+import numpy as np
+from filterpy.kalman import ExtendedKalmanFilter as EKF
+from physics.models.battery.battery_config import BatteryModelConfig
+import numpy as np
+
+class EKF_SOC():
+    def __init__(self, battery_config: BatteryModelConfig,  initial_SOC = 1, initial_Uc = 0):
+        """
+        EKF_SOC represents the kalman filter used for predicting state of charge.
+
+        Attributes:
+            battery_model_config (BatteryModelConfig): This contains the HPPC parameters of the battery model
+            initial_SOC (float/int): Ranges from 0 to 1 inclusive. The initial state of charge of the battery.
+            initial_Uc (float/int):  The initial polarization volatge of the battery. (V)
+        """
+        # Inital state
+        self.SOC = initial_SOC
+        self.Uc = initial_Uc  # Polarization Volatge
+
+        # Covariance Matrices
+        self.Q_covariance = np.eye(2) * 0.0001
+        self.R_covariance = np.eye(1) * 0.5     # currently not really trusting the predicted state
+
+        # Load Config data
+        self.R_P = battery_config.R_P
+        self.C_P = battery_config.C_P
+        self.Q_total = battery_config.Q_total
+        SOC_data = np.array(battery_config.SOC_data)
+        Uoc_data = np.array(battery_config.Uoc_data)
+        R_0_data = np.array(battery_config.R_0_data)
+
+        # polynomial interpolation
+        self.Uoc_coefficients = np.polyfit(SOC_data, Uoc_data, 7)
+        self.R_0_coefficients = np.polyfit(SOC_data, R_0_data, 7)
+        self.Uoc_derivative_coefficients = np.polyder(self.Uoc_coefficients)
+
+        self.tau = self.R_P / self.C_P
+
+        # initializing the ekf object
+        self.ekf = EKF(dim_x=2, dim_z=1)
+        self.ekf.x = np.array([self.SOC, self.Uc])
+        self.ekf.P = np.diag([1e-6, 1e-6])  # I'm keeping low uncertainty in initial SOC and Uc
+        self.ekf.Q = self.Q_covariance
+        self.ekf.R = self.R_covariance
+
+        # For logs
+        self.predicted_measurment = 0
+    
+    def get_SOC(self): 
+        """ Return the state of charge of the battery """
+        return self.SOC
+    
+    def get_Uc(self):
+        """ Return the polarization voltage of the battery """
+        return self.Uc
+    
+    def get_predicted_Ut(self):
+        """ Return the predicted terminal voltage for the last prediction step """
+        return self.predicted_measurment
+        
+    def update_filter(self, measured_Ut, I):
+        """
+        Update the filter based on a new measurment, and the predicted state.
+        This function should be called after predict_state in a typical predict update workflow.
+
+        Attributes:
+            measured_Ut (float/integer): The actual voltage across the terminals of the battery.
+            I (float/integer): The current being sourced by the battery
+        """
+        check_Terminal_V(measured_Ut)
+
+        h_jacobian = self._measurement_jacobian
+        Hx = self._measurement_function
+
+        self.ekf.update(z=measured_Ut, HJacobian=h_jacobian, Hx=Hx, hx_args=I)
+
+        self.SOC, self.Uc = self.ekf.x
+
+    def predict_state(self, I, time_step):
+        """
+        Predicts the next evolution of the state vector (SOC, Uc).
+        This function should be called before updating the filter in a typical predict update workflow.
+
+        Attributes:
+            I (float/integer): The current being sourced by the battery. Positive indicated current being drawn.
+            time_step (float/integer): Time elapsed between this prediction and the last updated state of filter. (Seconds)
+        """        
+        check_current(I)
+        # Control matrix B (for input current I_k)
+        self.ekf.B = np.array([-time_step / self.Q_total, self.R_P * (1 - np.exp(-time_step / self.tau))])
+        self.ekf.F = self._state_jacobian(time_step)
+        
+        self.ekf.predict(u=I)
+        print(f'ekf prediction: {self.ekf.x_prior}')
+
+    def predict_then_update(self, measured_Ut, I, time_step):
+        """
+        Predicts the next evolution of the state vector (SOC, Uc), then updates the filter
+        based on this prediction and a measurement.
+        This function abstracts the full predict update workflow of the EKF. 
+
+        Attributes:
+            measured_Ut (float/integer): The actual voltage across the terminals of the battery.
+            I (float/integer): The current being sourced by the battery. Positive indicated current being drawn.
+            time_step (float/integer): Time elapsed between this prediction and the last updated state of filter. (Seconds)
+        """  
+        check_current(I)
+        check_Terminal_V(measured_Ut)
+
+        self.predict_state(I, time_step)
+        print(f'predicted: {self.ekf.x_prior}')
+
+        self.update_filter(measured_Ut, I)
+        print(f'SOC: {self.ekf.x[0]}, Uc: {self.ekf.x[1]}')
+
+    def _state_jacobian(self, time_step):
+        """ 
+        Returns the state jacobian for the current time 
+
+        Attributes:
+            time_step (float/integer): Time elapsed between this prediction and the last updated state of filter. (Seconds)
+        """
+        return np.array([[1, 0], [0, np.exp(-time_step / self.tau)]])
+
+    def _measurement_jacobian(self, x):
+        """ 
+        Returns the measurement jacobian for the current time 
+
+        Attributes:
+            x [float, float]: The state vector [SOC, Uc], where both values are floats or integers.
+        """
+        SOC = x[0]
+        derivative = np.polyval(self.Uoc_derivative_coefficients, SOC)
+        return np.array([[derivative, -1]])
+
+    def _measurement_function(self, x, I):
+        """
+        The customized measurement equation relating Ut to SOC and Uc
+
+        Attributes:
+            x [float, float]: The state vector [SOC, Uc], where both values are floats or integers.
+            I (float/integer): The current being sourced by the battery. Positive indicated current being drawn.
+        """
+        SOC, Uc = x
+        R_0 = np.polyval(self.R_0_coefficients, SOC)
+        Uoc = np.polyval(self.Uoc_coefficients, SOC)
+        self.predicted_measurment = Uoc - Uc - R_0*I
+        return self.predicted_measurment
+
+def check_current(I):
+    if not isinstance(I, (float, int)):
+        raise TypeError(f"Invalid type for current I: {type(I)}. Expected float or int.")
+    if not (-45.0 <= I <= 45.0):
+        raise ValueError(f"Invalid value for current (I): {I}. Must be between -45.0A and 45.0A.")
+
+def check_Terminal_V(Ut):
+    if not isinstance(Ut, (float, int)):
+        raise TypeError(f"Invalid type for measured_Ut: {type(Ut)}. Expected float or int.")
+    if not (0.0 <= Ut <= 5.0):
+        raise ValueError(f"Invalid value for terminal voltage (measured_Ut): {Ut}. Must be between 0.0 and 5.0 volts.")

physics/models/battery.rs

@@ -0,0 +1 @@
+pub mod battery;

physics/models/constants.py

@@ -0,0 +1,23 @@
+# Radius of the Earth (m)
+EARTH_RADIUS = 6371009
+
+# Acceleration caused by gravity (m/s^2)
+ACCELERATION_G = 9.81
+
+# Density of Air at 15C and 101kPa (kg/m^3)
+AIR_DENSITY = 1.225
+
+# Maximum number of waypoints that can be given to generate route data
+MAX_WAYPOINTS = 10
+
+# Solar Irradiance (W/m^2)
+SOLAR_IRRADIANCE = 1353
+
+# As we currently have a limited number of API calls(60) every minute with the
+# current Weather API, we must shrink the dataset significantly. As the
+# OpenWeatherAPI models have a resolution of between 2.5 - 70 km, we will
+# go for a resolution of 25km. Assuming we travel at 100km/h for 12 hours,
+# 1200 kilometres/25 = 48 API calls
+# As the Google Maps API has a resolution of around 40m between points,
+# for ASC, we must cull at 625:1 (because 25,000m / 40m = 625)
+REDUCTION_FACTOR = 625

physics/models/lvs/__init__.py

@@ -0,0 +1,7 @@
+from .base_lvs import BaseLVS
+from .basic_lvs import BasicLVS
+
+__all__ = [
+    "BaseLVS",
+    "BasicLVS"
+]

physics/models/lvs/base_lvs.py

@@ -0,0 +1,6 @@
+from abc import ABC
+
+
+class BaseLVS(ABC):
+    def __init__(self, consumed_energy):
+        super().__init__()

physics/models/lvs/basic_lvs.py

@@ -0,0 +1,18 @@
+from physics.models.lvs.base_lvs import BaseLVS
+
+
+class BasicLVS(BaseLVS):
+
+    def __init__(self, consumed_energy, lvs_current, lvs_voltage):
+        super().__init__(consumed_energy)
+        self.lvs_current = lvs_current
+        self.lvs_voltage = lvs_voltage
+
+    def get_consumed_energy(self, tick):
+        """
+            Get the energy consumption of the Low Voltage System (current * voltage * time)
+
+            :param tick - (int) tick time passed
+            :returns: consumed_energy - (number) value of energy consumed
+        """
+        return self.lvs_current * self.lvs_voltage * tick

physics/models/lvs.rs

@@ -0,0 +1 @@
+mod lvs;

physics/models/motor/__init__.py

@@ -0,0 +1,7 @@
+from .base_motor import BaseMotor
+from .basic_motor import BasicMotor
+
+__all__ = [
+    "BaseMotor",
+    "BasicMotor"
+]

physics/models/motor/base_motor.py

@@ -0,0 +1,6 @@
+from abc import ABC
+
+
+class BaseMotor(ABC):
+    def __init__(self):
+        super().__init__()