mhpeps_simulation/
├── main.py
├── control_interface.py
├── propulsion/
│   ├── __init__.py
│   ├── plasma_propulsion.py
│   └── thrust_calculation.py
├── power_system/
│   ├── __init__.py
│   ├── solar_power.py
│   └── energy_management.py
├── thermal_management/
│   ├── __init__.py
│   └── heat_transfer.py
├── structural_analysis/
│   ├── __init__.py
│   └── stress_analysis.py
├── control_system/
│   ├── __init__.py
│   └── pid_controller.py
├── utils/
│   ├── __init__.py
│   └── constants.py
└── requirements.txt
```python
# control_system/pid_controller.py

class PIDController:
    def __init__(self, Kp, Ki, Kd, setpoint=0.0):
        """
        Инициализация PID-регулятора.

        :param Kp: Пропорциональный коэффициент
        :param Ki: Интегральный коэффициент
        :param Kd: Дифференциальный коэффициент
        :param setpoint: Заданное значение
        """
        self.Kp = Kp
        self.Ki = Ki
        self.Kd = Kd
        self.setpoint = setpoint
        self.integral = 0.0
        self.previous_error = 0.0

    def update(self, measured_value, dt):
        """
        Обновление регулировки.

        :param measured_value: Измеренное значение
        :param dt: Временной шаг (с)
        :return: Управляющее воздействие
        """
        error = self.setpoint - measured_value
        self.integral += error * dt
        derivative = (error - self.previous_error) / dt if dt > 0 else 0.0
        self.previous_error = error
        control = self.Kp * error + self.Ki * self.integral + self.Kd * derivative
        return control
```
```python
# power_system/energy_management.py

class EnergyManager:
    def __init__(self, power_sources):
        """
        Инициализация менеджера энергии.

        :param power_sources: Список источников энергии (Вт)
        """
        self.power_sources = power_sources

    def total_power(self):
        """
        Расчет общей доступной мощности.

        :return: Общая мощность (Вт)
        """
        return sum(self.power_sources)

    def allocate_power(self, demands):
        """
        Распределение мощности между нагрузками.

        :param demands: Список потребностей в мощности (Вт)
        :return: Список назначенной мощности (Вт)
        """
        total = self.total_power()
        allocated = []
        for demand in demands:
            if total >= demand:
                allocated.append(demand)
                total -= demand
            else:
                allocated.append(total)
                total = 0
        return allocated
```
```python
# power_system/solar_power.py

class SolarPanel:
    def __init__(self, area, efficiency, irradiance=1361):
        """
        Инициализация солнечной панели.

        :param area: Площадь панели (м²)
        :param efficiency: КПД панели (от 0 до 1)
        :param irradiance: Солнечная инсоляция (Вт/м²), по умолчанию 1361 Вт/м²
        """
        self.area = area
        self.efficiency = efficiency
        self.irradiance = irradiance

    def calculate_power_output(self):
        """
        Расчет выходной мощности солнечной панели.

        :return: Мощность (Вт)
        """
        return self.area * self.irradiance * self.efficiency
```
```python
# propulsion/plasma_propulsion.py

from propulsion.thrust_calculation import calculate_thrust, calculate_specific_impulse
import math

class PlasmaThruster:
    def __init__(self, accelerating_voltage, ion_mass, ion_charge=1.602e-19):
        """
        Инициализация плазменного двигателя.

        :param accelerating_voltage: Напряжение ускорения (В)
        :param ion_mass: Масса иона (кг)
        :param ion_charge: Заряд иона (Кл), по умолчанию заряд протона
        """
        self.accelerating_voltage = accelerating_voltage
        self.ion_mass = ion_mass
        self.ion_charge = ion_charge
        self.mass_flow_rate = 0.0  # Изначально ноль

    def calculate_exhaust_velocity(self):
        """
        Расчет скорости истечения на основе напряжения ускорения и массы иона.

        :return: Скорость истечения (м/с)
        """
        return math.sqrt((2 * self.ion_charge * self.accelerating_voltage) / self.ion_mass)

    def set_power(self, power):
        """
        Установка мощности двигателя и расчет соответствующего массового расхода.

        :param power: Выделенная мощность (Вт)
        """
        if power < 0:
            raise ValueError("Мощность не может быть отрицательной.")

        ve = self.calculate_exhaust_velocity()
        if ve == 0:
            self.mass_flow_rate = 0.0
        else:
            self.mass_flow_rate = (2 * power) / (ve ** 2)

    def get_thrust(self):
        """
        Получение тяги на основе текущего массового расхода и скорости истечения.

        :return: Тяга (Н)
        """
        ve = self.calculate_exhaust_velocity()
        return calculate_thrust(self.mass_flow_rate, ve)

    def get_specific_impulse(self):
        """
        Получение удельного импульса на основе скорости истечения.

        :return: Удельный импульс (с)
        """
        ve = self.calculate_exhaust_velocity()
        return calculate_specific_impulse(ve)
```
```python
# propulsion/thrust_calculation.py

from utils.constants import G0

def calculate_thrust(mass_flow_rate, exhaust_velocity):
    """
    Расчет тяги двигателя.

    :param mass_flow_rate: Массовый расход (кг/с)
    :param exhaust_velocity: Скорость истечения (м/с)
    :return: Тяга (Н)
    """
    return mass_flow_rate * exhaust_velocity

def calculate_specific_impulse(exhaust_velocity):
    """
    Расчет удельного импульса.

    :param exhaust_velocity: Скорость истечения (м/с)
    :return: Удельный импульс (с)
    """
    return exhaust_velocity / G0
```
```python
# structural_analysis/stress_analysis.py

class StressAnalysis:
    def __init__(self, force, area, young_modulus, yield_strength):
        """
        Инициализация анализа напряжений.

        :param force: Применяемая сила (Н)
        :param area: Площадь поперечного сечения (м²)
        :param young_modulus: Модуль Юнга материала (Па)
        :param yield_strength: Предел текучести материала (Па)
        """
        self.force = force
        self.area = area
        self.E = young_modulus
        self.sigma_y = yield_strength

    def calculate_stress(self):
        """
        Расчет напряжения.

        :return: Напряжение (Па)
        """
        if self.area <= 0:
            raise ValueError("Площадь поперечного сечения должна быть положительной.")
        return self.force / self.area

    def check_yielding(self):
        """
        Проверка на превышение предела текучести.

        :return: Boolean, True если не превышено, False иначе
        """
        stress = self.calculate_stress()
        return stress < self.sigma_y

    def calculate_deflection(self, length, moment_of_inertia):
        """
        Расчет прогиба балки под нагрузкой.

        :param length: Длина балки (м)
        :param moment_of_inertia: Момент инерции поперечного сечения (м^4)
        :return: Прогиб (м)
        """
        if self.E <= 0 or moment_of_inertia <= 0:
            raise ValueError("Модуль Юнга и момент инерции должны быть положительными.")
        # Прогиб для балки с сосредоточенной нагрузкой в середине (несущая балка)
        return (self.force * length**3) / (48 * self.E * moment_of_inertia)
```
```python
# thermal_management/heat_transfer.py

from utils.constants import STEFAN_BOLTZMANN

class HeatTransfer:
    def __init__(self, thermal_conductivity, area, thickness, temperature_diff):
        """
        Инициализация модели теплопередачи.

        :param thermal_conductivity: Теплопроводность материала (Вт/(м·К))
        :param area: Площадь теплопередающей поверхности (м²)
        :param thickness: Толщина материала (м)
        :param temperature_diff: Разница температур (К)
        """
        self.k = thermal_conductivity
        self.A = area
        self.d = thickness
        self.delta_T = temperature_diff

    def conductive_heat_transfer(self):
        """
        Расчет теплопередачи по проводимости.

        :return: Теплопередача (Вт)
        """
        if self.d <= 0:
            raise ValueError("Толщина должна быть положительной.")
        return self.k * self.A * self.delta_T / self.d

    def radiative_heat_transfer(self, emissivity, T_hot, T_cold):
        """
        Расчет теплопередачи по излучению.

        :param emissivity: Эмиссивность материала (от 0 до 1)
        :param T_hot: Температура горячей поверхности (K)
        :param T_cold: Температура холодной поверхности (K)
        :return: Теплопередача (Вт)
        """
        if not (0 <= emissivity <= 1):
            raise ValueError("Эмиссивность должна быть между 0 и 1.")
        return emissivity * STEFAN_BOLTZMANN * self.A * (T_hot ** 4 - T_cold ** 4)
```
```python
# utils/constants.py

import numpy as np

# Гравитационная ускорение
G0 = 9.80665  # м/с²

# Константа Стефана-Больцмана
STEFAN_BOLTZMANN = 5.67e-8  # Вт/(м²·К⁴)
```
Ознакомься с материалом