machwave 0.1.0__py3-none-any.whl

machwave/models/atmosphere/__init__.py

@@ -0,0 +1,87 @@
+"""
+Atmospheric models for use in rocket simulations. The models are used to
+calculate the properties of the atmosphere at a given altitude above mean sea
+level (AMSL).
+"""
+
+from abc import ABC, abstractmethod
+
+
+class Atmosphere(ABC):
+    """Abstract class that represents an atmospheric model."""
+
+    @abstractmethod
+    def get_density(self, y_amsl: float) -> float:
+        """
+        Get the air density at the given altitude above mean sea level (AMSL).
+
+        Args:
+            y_amsl (float): Altitude above mean sea level in meters.
+
+        Returns:
+            float: Air density in kg/m^3.
+        """
+
+    @abstractmethod
+    def get_gravity(self, y_amsl: float) -> float:
+        """
+        Get the acceleration due to gravity at the given altitude above mean
+        sea level (AMSL).
+
+        Args:
+            y_amsl (float): Altitude above mean sea level in meters.
+
+        Returns:
+            float: Acceleration due to gravity in m/s^2.
+        """
+
+    @abstractmethod
+    def get_pressure(self, y_amsl: float) -> float:
+        """
+        Get the air pressure at the given altitude above mean sea level (AMSL).
+
+        Args:
+            y_amsl (float): Altitude above mean sea level in meters.
+
+        Returns:
+            float: Air pressure in Pascal (Pa).
+        """
+
+    @abstractmethod
+    def get_sonic_velocity(self, y_amsl: float) -> float:
+        """
+        Get the speed of sound in air at the given altitude above mean sea
+        level (AMSL).
+
+        Args:
+            y_amsl (float): Altitude above mean sea level in meters.
+
+        Returns:
+            float: Speed of sound in m/s.
+        """
+
+    @abstractmethod
+    def get_wind_velocity(self, y_amsl: float) -> tuple[float, float]:
+        """
+        Get the wind velocity components at the given altitude above mean
+        sea level (AMSL).
+
+        Args:
+            y_amsl (float): Altitude above mean sea level in meters.
+
+        Returns:
+            tuple[float, float]: Wind velocity components (Northward, Eastward) in m/s.
+        """
+
+    @abstractmethod
+    def get_viscosity(self, y_amsl: float) -> float:
+        """
+        Get the dynamic viscosity of air at the given altitude above mean sea
+        level (AMSL).
+
+        Args:
+            y_amsl (float): Altitude above mean sea level in meters.
+
+        Returns:
+            float: Dynamic viscosity of air in Pascal-second (Pa-s).
+        """

machwave/models/atmosphere/atm_1976.py

@@ -0,0 +1,86 @@
+"""
+Implementation of the 1976 Standard Atmosphere model.
+"""
+
+from fluids.atmosphere import ATMOSPHERE_1976
+import numpy as np
+
+from machwave.models.atmosphere import Atmosphere
+
+
+class Atmosphere1976(Atmosphere):
+    """
+    Atmospheric model based on the 1976 Standard Atmosphere. This model uses
+    the fluids library to calculate the properties of the atmosphere.
+    """
+
+    def get_density(self, y_amsl: float) -> float:
+        return ATMOSPHERE_1976(y_amsl).rho
+
+    def get_gravity(self, y_amsl: float) -> float:
+        return ATMOSPHERE_1976.gravity(y_amsl)
+
+    def get_pressure(self, y_amsl: float) -> float:
+        return ATMOSPHERE_1976(y_amsl).P
+
+    def get_sonic_velocity(self, y_amsl: float) -> float:
+        return ATMOSPHERE_1976(y_amsl).v_sonic
+
+    def get_wind_velocity(self, y_amsl: float) -> tuple[float, float]:
+        """
+        7 m/s wind velocity in both x and y directions.
+        """
+        return (7, 7)
+
+    def get_viscosity(self, y_amsl: float) -> float:
+        return ATMOSPHERE_1976(y_amsl).mu
+
+
+class Atmosphere1976WindPowerLaw(Atmosphere1976):
+    """
+    Atmospheric model based on the 1976 Standard Atmosphere, using a power-law
+    model for wind velocity variation with altitude.
+    """
+
+    def __init__(self, v_ref: float, z_ref: float, alpha: float, direction_deg: float):
+        """
+        Initialize the atmosphere model with power-law wind parameters.
+
+        Args:
+            v_ref (float): Wind speed at the reference height (in m/s).
+            z_ref (float): Reference height (in meters) where the wind speed is known.
+            alpha (float): Wind shear exponent.
+            direction_deg (float): Wind direction in degrees (0° is North, 90° is East).
+        """
+        super().__init__()
+
+        if z_ref == 0:
+            raise ValueError("Please provide a non-zero reference height 'z_ref'.")
+
+        self.v_ref = v_ref
+        self.z_ref = z_ref
+        self.alpha = alpha
+        self.direction_deg = direction_deg
+
+    def get_wind_velocity(self, y_amsl: float) -> tuple[float, float]:
+        """
+        Get the wind velocity components at the given altitude above mean sea level (AMSL)
+        using the power law.
+
+        Args:
+            y_amsl (float): Altitude above mean sea level in meters.
+
+        Returns:
+            tuple[float, float]: Wind velocity components (Northward, Eastward) in m/s.
+        """
+        if y_amsl <= 0:
+            y_amsl = self.z_ref
+
+        wind_speed = self.v_ref * (y_amsl / self.z_ref) ** self.alpha
+
+        direction_rad = np.radians(self.direction_deg)
+
+        v_northward = wind_speed * np.cos(direction_rad)
+        v_eastward = wind_speed * np.sin(direction_rad)
+
+        return v_northward, v_eastward

machwave/models/materials/__init__.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Material:
+    """
+    Base class representing a generic material.
+
+    Attributes:
+        density (float): Density of the material.
+        yield_strength (float): Yield strength of the material.
+        ultimate_strength (float): Ultimate strength of the material.
+    """
+
+    density: float
+    yield_strength: float
+    ultimate_strength: float
+
+
+@dataclass
+class NozzleMaterial(Material):
+    """
+    Base class for a Nozzle material.
+
+    Contains all attributes from the Material class, adding c_1 and c_2 for
+    calculating isentropic flow correction factors. These special parameters
+    are referenced in the a015140 paper.
+
+    Attributes:
+        c_1 (float): Coefficient related to heat transfer properties of a BATES
+            motor.
+        c_2 (float): Time constant obtained from the analysis of the transient
+            heating of a standard BATES motor.
+    """
+
+    c_1: float
+    c_2: float

machwave/models/materials/metals.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+
+from . import NozzleMaterial
+
+
+@dataclass
+class Steel(NozzleMaterial):
+    """
+    Steel material class derived from the NozzleMaterial base class.
+
+    This class represents a specific type of material, Steel, which inherits
+    properties from the NozzleMaterial base class. It provides default values
+    for the density, yield strength, ultimate strength, c_1, and c_2 specific to
+    Steel.
+
+    Data obtained from:
+    https://www.thyssenkrupp-materials.co.uk/stainless-steel-304-14301.html
+
+    Inherits:
+        NozzleMaterial: Base class representing a nozzle material.
+
+    Attributes:
+        None
+    """
+
+    density: float = 8000
+    yield_strength: float = 210e6
+    ultimate_strength: float = 520e6
+    c_1: float = 0.00506
+    c_2: float = 0.0
+
+
+@dataclass
+class Al6063T5(NozzleMaterial):
+    """
+    Al6063T5 (Aluminum) material class derived from the NozzleMaterial base
+    class.
+
+    This class represents a specific type of material, Al6063T5 (Aluminum),
+    which inherits properties from the NozzleMaterial base class. It provides
+    default values for the density, yield strength, ultimate strength, c_1, and
+    c_2 specific to Al6063T5.
+
+    Data obtained from:
+    https://www.makeitfrom.com/material-properties/6063-T5-Aluminum
+
+    Inherits:
+        NozzleMaterial: Base class representing a nozzle material.
+
+    Attributes:
+        None
+    """
+
+    density: float = 2700
+    yield_strength: float = 145e6
+    ultimate_strength: float = 185e6
+    c_1: float = 0.00506
+    c_2: float = 0.0
+
+
+@dataclass
+class Al6061T6(NozzleMaterial):
+    """
+    Al6061T6 (Aluminum) material class derived from the NozzleMaterial base
+    class.
+
+    This class represents a specific type of material, Al6061T6 (Aluminum),
+    which inherits properties from the NozzleMaterial base class. It provides
+    default values for the density, yield strength, ultimate strength, c_1, and
+    c_2 specific to Al6061T6.
+
+    Data obtained from:
+    https://matweb.com/search/DataSheet.aspx?MatGUID=b8d536e0b9b54bd7b69e4124d8f1d20a&ckck=1
+
+    Inherits:
+        NozzleMaterial: Base class representing a nozzle material.
+
+    Attributes:
+        None
+    """
+
+    density: float = 2700
+    yield_strength: float = 262e6
+    ultimate_strength: float = 290e6
+    c_1: float = 0.00506
+    c_2: float = 0.0

machwave/models/materials/polymers.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass
+
+from . import Material
+
+
+@dataclass
+class EPDM(Material):
+    """
+    EPDM (Ethylene Propylene Diene Monomer) material class.
+
+    Data obtained from:
+    https://www.matweb.com/search/datasheet.aspx?matguid=f8e3355cc2c541fbb0174960466819c0&ckck=1
+
+    Inherits:
+        Material: Base class representing a generic material.
+
+    Attributes:
+        None
+    """
+
+    density: float = 1500
+    yield_strength: float = None
+    ultimate_strength: float = 17e6
+
+
+class EpoxiResin(Material):
+    """
+    EpoxiResin material class.
+
+    Inherits:
+        Material: Base class representing a generic material.
+
+    Attributes:
+        None
+    """
+
+    def __init__(self) -> None:
+        """
+        Initialize an EpoxiResin object.
+
+        This constructor sets the default values for the density, yield
+        strength, and ultimate strength of EpoxiResin.
+
+        Args:
+            None
+
+        Returns:
+            None
+        """
+        super().__init__(density=1100, yield_strength=60e6, ultimate_strength=60e6)

machwave/models/propulsion/__init__.py

@@ -0,0 +1,209 @@
+from abc import ABC, abstractmethod
+
+import numpy as np
+
+from machwave.models.propulsion.grain import Grain
+from machwave.models.propulsion.propellants import Propellant
+from machwave.models.propulsion.structure import MotorStructure
+from machwave.services.isentropic_flow import (
+    get_thrust_coefficients,
+    get_thrust_from_cf,
+)
+
+
+class Motor(ABC):
+    """
+    Abstract rocket motor/engine class. Can be used to model any chemical
+    rocket propulsion system, such as Solid, Hybrid and Liquid.
+    """
+
+    def __init__(
+        self,
+        propellant: Propellant,
+        structure: MotorStructure,
+    ) -> None:
+        """
+        Instantiates object attributes common to any motor/engine (Solid,
+        Hybrid or Liquid).
+
+        Args:
+            propellant (Propellant): Object representing the propellant used in the motor.
+            structure (MotorStructure): Object representing the structure of the motor.
+        """
+        self.propellant = propellant
+        self.structure = structure
+
+    @abstractmethod
+    def get_launch_mass(self) -> float:
+        """
+        Calculates the total mass of the rocket before launch.
+
+        Returns:
+            float: Total mass of the rocket before launch, in kg
+        """
+        pass
+
+    @abstractmethod
+    def get_dry_mass(self) -> float:
+        """
+        Calculates the dry mass of the rocket at any time.
+
+        Returns:
+            float: Dry mass of the rocket, in kg
+        """
+        pass
+
+    @abstractmethod
+    def get_center_of_gravity(self) -> np.ndarray:
+        """
+        Calculates center of gravity of the propulsion system.
+
+        Coordinate system is originated in the point defined by the nozzle's
+        exit area surface and the combustion chamber axis.
+
+        Returns:
+            np.ndarray: Center of gravity position, in m, [x, y, z]
+        """
+        pass
+
+    @abstractmethod
+    def get_thrust_coefficient_correction_factor(self) -> float:
+        """
+        Calculates the thrust coefficient correction factor. This factor is
+        adimensional and should be applied to the ideal thrust coefficient to
+        get the real thrust coefficient.
+
+        Returns:
+            float: Thrust coefficient correction factor
+        """
+        pass
+
+    @abstractmethod
+    def get_thrust_coefficient(self) -> float:
+        """
+        Calculates the thrust coefficient at a particular instant.
+
+        Returns:
+            float: Thrust coefficient
+        """
+        pass
+
+    def get_thrust(self, cf: float, chamber_pressure: float) -> float:
+        """
+        Calculates the thrust based on instantaneous thrust coefficient and
+        chamber pressure.
+
+        Utilized nozzle throat area from the structure and nozzle classes.
+
+        Args:
+            cf (float): Instantaneous thrust coefficient, adimensional
+            chamber_pressure (float): Instantaneous chamber pressure, in Pa
+
+        Returns:
+            float: Instantaneous thrust, in Newtons
+        """
+        return get_thrust_from_cf(
+            cf,
+            chamber_pressure,
+            self.structure.nozzle.get_throat_area(),
+        )
+
+
+class SolidMotor(Motor):
+    def __init__(
+        self,
+        grain: Grain,
+        propellant: Propellant,
+        structure: MotorStructure,
+    ) -> None:
+        self.grain = grain
+        super().__init__(propellant, structure)
+
+        self.cf_ideal = None  # ideal thrust coefficient
+        self.cf_real = None  # real thrust coefficient
+
+    def get_free_chamber_volume(self, propellant_volume: float) -> float:
+        """
+        Calculates the chamber volume without any propellant.
+
+        Args:
+            propellant_volume (float): Propellant volume, in m^3
+
+        Returns:
+            float: Free chamber volume, in m^3
+        """
+        return self.structure.chamber.empty_volume - propellant_volume
+
+    @property
+    def initial_propellant_mass(self) -> float:
+        """
+        Returns:
+            float: Initial propellant mass, in kg
+        """
+        return (
+            self.grain.get_propellant_volume(web_distance=0) * self.propellant.density
+        )
+
+    def get_thrust_coefficient_correction_factor(
+        self, n_kin: float, n_bl: float, n_tp: float
+    ) -> float:
+        """
+        Args:
+            n_kin (float): Kinematic correction factor, adimensional
+            n_bl (float): Boundary layer correction factor, adimensional
+            n_tp (float): Two-phase correction factor, adimensional
+
+        Returns:
+            float: Thrust coefficient correction factor, adimensional
+        """
+        return (
+            (100 - (n_kin + n_bl + n_tp))
+            * self.structure.nozzle.get_divergent_correction_factor()
+            / 100
+            * self.propellant.combustion_efficiency
+        )
+
+    def get_thrust_coefficient(
+        self,
+        chamber_pressure: float,
+        exit_pressure: float,
+        external_pressure: float,
+        expansion_ratio: float,
+        k_2ph_ex: float,
+        n_cf: float,
+    ) -> float:
+        """
+        Args:
+            chamber_pressure (float): Chamber pressure, in Pa
+            exit_pressure (float): Exit pressure, in Pa
+            external_pressure (float): External pressure, in Pa
+            expansion_ratio (float): Expansion ratio, adimensional
+            k_2ph_ex (float): Two-phase isentropic coefficient, adimensional
+            n_cf (float): Thrust coefficient correction factor, adimensional
+
+        Returns:
+            float: Instanteneous thrust coefficient, adimensional
+        """
+        self.cf_ideal, self.cf_real = get_thrust_coefficients(
+            chamber_pressure,
+            exit_pressure,
+            external_pressure,
+            expansion_ratio,
+            k_2ph_ex,
+            n_cf,
+        )
+        return self.cf_real
+
+    def get_launch_mass(self) -> float:
+        return self.structure.dry_mass + self.initial_propellant_mass
+
+    def get_dry_mass(self) -> float:
+        return self.structure.dry_mass
+
+    def get_center_of_gravity(self) -> np.ndarray:
+        """
+        Constant CG throughout the operation. Half the chamber length.
+
+        TODO: implement grain CG calculation.
+        """
+        return np.array([self.structure.chamber.length / 2, 0, 0])