From f048c565ae2e019116718aa6e981c62d2d3ed811 Mon Sep 17 00:00:00 2001 From: caioessouza Date: Thu, 24 Apr 2025 19:06:12 -0300 Subject: [PATCH 1/8] Functions associated to the regression updated #801 only_radial_burn optional parameter added and used in the functions related to the grain regression as a conditon to change the applied equations. Still need to update the comment section, the CHANGELOG and maybe the dict related functions, but not sure about the last one yet. --- rocketpy/motors/solid_motor.py | 137 +++++++++++++++++++++++---------- 1 file changed, 96 insertions(+), 41 deletions(-) diff --git a/rocketpy/motors/solid_motor.py b/rocketpy/motors/solid_motor.py index 37d89130e..357bd7434 100644 --- a/rocketpy/motors/solid_motor.py +++ b/rocketpy/motors/solid_motor.py @@ -204,6 +204,7 @@ def __init__( reshape_thrust_curve=False, interpolation_method="linear", coordinate_system_orientation="nozzle_to_combustion_chamber", + only_radial_burn=False, ): """Initialize Motor class, process thrust curve and geometrical parameters and store results. @@ -315,6 +316,7 @@ class Function. Thrust units are Newtons. reshape_thrust_curve=reshape_thrust_curve, interpolation_method=interpolation_method, coordinate_system_orientation=coordinate_system_orientation, + only_radial_burn = only_radial_burn, ) # Nozzle parameters self.throat_radius = throat_radius @@ -339,6 +341,8 @@ class Function. Thrust units are Newtons. self.evaluate_geometry() + # Burn surface definition + self.only_radial_burn = only_radial_burn # Initialize plots and prints object self.prints = _SolidMotorPrints(self) self.plots = _SolidMotorPlots(self) @@ -479,15 +483,25 @@ def geometry_dot(t, y): # Compute state vector derivative grain_inner_radius, grain_height = y - burn_area = ( - 2 - * np.pi - * ( - grain_outer_radius**2 - - grain_inner_radius**2 - + grain_inner_radius * grain_height + if self.only_radial_burn: + burn_area = ( + 2 + * np.pi + * ( + grain_inner_radius * grain_height + ) ) - ) + else: + burn_area = ( + 2 + * np.pi + * ( + grain_outer_radius**2 + - grain_inner_radius**2 + + grain_inner_radius * grain_height + ) + ) + grain_inner_radius_derivative = -volume_diff / burn_area grain_height_derivative = -2 * grain_inner_radius_derivative @@ -500,33 +514,64 @@ def geometry_jacobian(t, y): # Compute jacobian grain_inner_radius, grain_height = y - factor = volume_diff / ( - 2 - * np.pi - * ( - grain_outer_radius**2 - - grain_inner_radius**2 - + grain_inner_radius * grain_height + if self.only_radial_burn: + factor = volume_diff / ( + 2 + * np.pi + * ( + grain_inner_radius * grain_height + ) + ** 2 ) - ** 2 - ) - inner_radius_derivative_wrt_inner_radius = factor * ( - grain_height - 2 * grain_inner_radius - ) - inner_radius_derivative_wrt_height = factor * grain_inner_radius - height_derivative_wrt_inner_radius = ( - -2 * inner_radius_derivative_wrt_inner_radius - ) - height_derivative_wrt_height = -2 * inner_radius_derivative_wrt_height - return [ - [ - inner_radius_derivative_wrt_inner_radius, - inner_radius_derivative_wrt_height, - ], - [height_derivative_wrt_inner_radius, height_derivative_wrt_height], - ] + inner_radius_derivative_wrt_inner_radius = factor * ( + grain_height - 2 * grain_inner_radius + ) + inner_radius_derivative_wrt_height = factor * grain_inner_radius + height_derivative_wrt_inner_radius = 0 + height_derivative_wrt_height = 0 + + return [ + [ + inner_radius_derivative_wrt_inner_radius, + inner_radius_derivative_wrt_height, + ], + [height_derivative_wrt_inner_radius, height_derivative_wrt_height], + + + ] + + else: + factor = volume_diff / ( + 2 + * np.pi + * ( + grain_outer_radius**2 + - grain_inner_radius**2 + + grain_inner_radius * grain_height + ) + ** 2 + ) + inner_radius_derivative_wrt_inner_radius = factor * ( + grain_height - 2 * grain_inner_radius + ) + inner_radius_derivative_wrt_height = factor * grain_inner_radius + height_derivative_wrt_inner_radius = ( + -2 * inner_radius_derivative_wrt_inner_radius + ) + height_derivative_wrt_height = -2 * inner_radius_derivative_wrt_height + + return [ + [ + inner_radius_derivative_wrt_inner_radius, + inner_radius_derivative_wrt_height, + ], + [height_derivative_wrt_inner_radius, height_derivative_wrt_height], + + + ] + def terminate_burn(t, y): # pylint: disable=unused-argument end_function = (self.grain_outer_radius - y[0]) * y[1] return end_function @@ -576,16 +621,26 @@ def burn_area(self): burn_area : Function Function representing the burn area progression with the time. """ - burn_area = ( - 2 - * np.pi - * ( - self.grain_outer_radius**2 - - self.grain_inner_radius**2 - + self.grain_inner_radius * self.grain_height + if self.only_radial_burn: + burn_area = ( + 2 + * np.pi + * ( + self.grain_inner_radius * self.grain_height + ) + * self.grain_number + ) + else: + burn_area = ( + 2 + * np.pi + * ( + self.grain_outer_radius**2 + - self.grain_inner_radius**2 + + self.grain_inner_radius * self.grain_height + ) + * self.grain_number ) - * self.grain_number - ) return burn_area @funcify_method("Time (s)", "burn rate (m/s)") From 4f32f88d2f5c747b0b85097a95e400903b7662c5 Mon Sep 17 00:00:00 2001 From: caioessouza Date: Wed, 30 Apr 2025 19:42:03 -0300 Subject: [PATCH 2/8] super() corrected and dict functions updated #801 The new parameter of the SolidMotor class was removed from super, since it's not on the Motor class. The dict functions were updated to take this new parameter into acount. Also the comments about the SolidMotor class parameters were updated. Still need to do some tests running the code to be sure everything is ok, then I can open the PR. --- rocketpy/motors/solid_motor.py | 33 +++++++++++---------------------- 1 file changed, 11 insertions(+), 22 deletions(-) diff --git a/rocketpy/motors/solid_motor.py b/rocketpy/motors/solid_motor.py index 357bd7434..66f69938f 100644 --- a/rocketpy/motors/solid_motor.py +++ b/rocketpy/motors/solid_motor.py @@ -300,6 +300,11 @@ class Function. Thrust units are Newtons. positions specified. Options are "nozzle_to_combustion_chamber" and "combustion_chamber_to_nozzle". Default is "nozzle_to_combustion_chamber". + only_radial_burn : boolean, optional + If True, inhibits the grain from burning axially, only computing + radial burn. Otherwise, if False, allows the grain to also burn + axially. May be useful for axially inhibited grains or hybrid motors. + Default is False. Returns ------- @@ -316,7 +321,6 @@ class Function. Thrust units are Newtons. reshape_thrust_curve=reshape_thrust_curve, interpolation_method=interpolation_method, coordinate_system_orientation=coordinate_system_orientation, - only_radial_burn = only_radial_burn, ) # Nozzle parameters self.throat_radius = throat_radius @@ -484,13 +488,7 @@ def geometry_dot(t, y): # Compute state vector derivative grain_inner_radius, grain_height = y if self.only_radial_burn: - burn_area = ( - 2 - * np.pi - * ( - grain_inner_radius * grain_height - ) - ) + burn_area = 2 * np.pi * (grain_inner_radius * grain_height) else: burn_area = ( 2 @@ -516,12 +514,7 @@ def geometry_jacobian(t, y): grain_inner_radius, grain_height = y if self.only_radial_burn: factor = volume_diff / ( - 2 - * np.pi - * ( - grain_inner_radius * grain_height - ) - ** 2 + 2 * np.pi * (grain_inner_radius * grain_height) ** 2 ) inner_radius_derivative_wrt_inner_radius = factor * ( @@ -537,8 +530,6 @@ def geometry_jacobian(t, y): inner_radius_derivative_wrt_height, ], [height_derivative_wrt_inner_radius, height_derivative_wrt_height], - - ] else: @@ -568,10 +559,8 @@ def geometry_jacobian(t, y): inner_radius_derivative_wrt_height, ], [height_derivative_wrt_inner_radius, height_derivative_wrt_height], - - ] - + def terminate_burn(t, y): # pylint: disable=unused-argument end_function = (self.grain_outer_radius - y[0]) * y[1] return end_function @@ -625,9 +614,7 @@ def burn_area(self): burn_area = ( 2 * np.pi - * ( - self.grain_inner_radius * self.grain_height - ) + * (self.grain_inner_radius * self.grain_height) * self.grain_number ) else: @@ -812,6 +799,7 @@ def to_dict(self, include_outputs=False): "grain_initial_height": self.grain_initial_height, "grain_separation": self.grain_separation, "grains_center_of_mass_position": self.grains_center_of_mass_position, + "only_radial_burn": self.only_radial_burn, } ) @@ -855,4 +843,5 @@ def from_dict(cls, data): throat_radius=data["throat_radius"], interpolation_method=data["interpolate"], coordinate_system_orientation=data["coordinate_system_orientation"], + only_radial_burn=data.get("only_radial_burn", False), ) From 550e149fac7a3703f57b43810d9b6417b99e55d1 Mon Sep 17 00:00:00 2001 From: caioessouza Date: Sat, 3 May 2025 08:48:49 -0300 Subject: [PATCH 3/8] Last update #801 Corrected some minor code erros, like calling evaluate geometry before defining self.only_radial_burn. Also had to change the grain_height_derivative to zero in the case of only radial burn, it was leading to some physical incoherences, because the grain was still burning axially. The last tests to evaluate the physical behaviour went pretty well, so I'll open the PR. --- rocketpy/motors/solid_motor.py | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/rocketpy/motors/solid_motor.py b/rocketpy/motors/solid_motor.py index 66f69938f..dba121dda 100644 --- a/rocketpy/motors/solid_motor.py +++ b/rocketpy/motors/solid_motor.py @@ -302,7 +302,7 @@ class Function. Thrust units are Newtons. "nozzle_to_combustion_chamber". only_radial_burn : boolean, optional If True, inhibits the grain from burning axially, only computing - radial burn. Otherwise, if False, allows the grain to also burn + radial burn. Otherwise, if False, allows the grain to also burn axially. May be useful for axially inhibited grains or hybrid motors. Default is False. @@ -343,10 +343,11 @@ class Function. Thrust units are Newtons. ) self.grain_initial_mass = self.grain_density * self.grain_initial_volume - self.evaluate_geometry() - # Burn surface definition self.only_radial_burn = only_radial_burn + + self.evaluate_geometry() + # Initialize plots and prints object self.prints = _SolidMotorPrints(self) self.plots = _SolidMotorPlots(self) @@ -489,6 +490,10 @@ def geometry_dot(t, y): grain_inner_radius, grain_height = y if self.only_radial_burn: burn_area = 2 * np.pi * (grain_inner_radius * grain_height) + + grain_inner_radius_derivative = -volume_diff / burn_area + grain_height_derivative = 0 + else: burn_area = ( 2 @@ -500,8 +505,8 @@ def geometry_dot(t, y): ) ) - grain_inner_radius_derivative = -volume_diff / burn_area - grain_height_derivative = -2 * grain_inner_radius_derivative + grain_inner_radius_derivative = -volume_diff / burn_area + grain_height_derivative = -2 * grain_inner_radius_derivative return [grain_inner_radius_derivative, grain_height_derivative] @@ -520,7 +525,7 @@ def geometry_jacobian(t, y): inner_radius_derivative_wrt_inner_radius = factor * ( grain_height - 2 * grain_inner_radius ) - inner_radius_derivative_wrt_height = factor * grain_inner_radius + inner_radius_derivative_wrt_height = 0 height_derivative_wrt_inner_radius = 0 height_derivative_wrt_height = 0 From 7a4267ae85391f6a9e15f34aa48d54a72ca4c4a6 Mon Sep 17 00:00:00 2001 From: caioessouza Date: Fri, 9 May 2025 20:46:46 -0300 Subject: [PATCH 4/8] Update CHANGELOG.md --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6a2503d23..31ae251b2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -43,6 +43,7 @@ Attention: The newest changes should be on top --> ### Added +- ENH: Enable only radial burning [#815](https://github.com/RocketPy-Team/RocketPy/pull/815) - ENH: Parallel mode for monte-carlo simulations 2 [#768](https://github.com/RocketPy-Team/RocketPy/pull/768) - DOC: ASTRA Flight Example [#770](https://github.com/RocketPy-Team/RocketPy/pull/770) - ENH: Add Eccentricity to Stochastic Simulations [#792](https://github.com/RocketPy-Team/RocketPy/pull/792) From 32871380e76a6dc1420865f3400db146cdc80e8f Mon Sep 17 00:00:00 2001 From: caioessouza Date: Tue, 20 May 2025 10:54:14 -0300 Subject: [PATCH 5/8] Only radial burning enabled on hybrid class #801 The "only_radial_burning" parameter was added and set as default on the hybrid class. Also, the description of the new parameter was updated and 2 coments about derivatives set to zero were added. --- rocketpy/motors/hybrid_motor.py | 2 ++ rocketpy/motors/solid_motor.py | 5 +++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/rocketpy/motors/hybrid_motor.py b/rocketpy/motors/hybrid_motor.py index ea01e686f..2ae50d073 100644 --- a/rocketpy/motors/hybrid_motor.py +++ b/rocketpy/motors/hybrid_motor.py @@ -203,6 +203,7 @@ def __init__( # pylint: disable=too-many-arguments reshape_thrust_curve=False, interpolation_method="linear", coordinate_system_orientation="nozzle_to_combustion_chamber", + only_radial_burn=True, ): """Initialize Motor class, process thrust curve and geometrical parameters and store results. @@ -346,6 +347,7 @@ class Function. Thrust units are Newtons. reshape_thrust_curve, interpolation_method, coordinate_system_orientation, + only_radial_burn, ) self.positioned_tanks = self.liquid.positioned_tanks diff --git a/rocketpy/motors/solid_motor.py b/rocketpy/motors/solid_motor.py index dba121dda..941b10019 100644 --- a/rocketpy/motors/solid_motor.py +++ b/rocketpy/motors/solid_motor.py @@ -302,7 +302,7 @@ class Function. Thrust units are Newtons. "nozzle_to_combustion_chamber". only_radial_burn : boolean, optional If True, inhibits the grain from burning axially, only computing - radial burn. Otherwise, if False, allows the grain to also burn + radial burn. If False, allows the grain to also burn axially. May be useful for axially inhibited grains or hybrid motors. Default is False. @@ -492,7 +492,7 @@ def geometry_dot(t, y): burn_area = 2 * np.pi * (grain_inner_radius * grain_height) grain_inner_radius_derivative = -volume_diff / burn_area - grain_height_derivative = 0 + grain_height_derivative = 0 # Set to zero to disable axial burning else: burn_area = ( @@ -528,6 +528,7 @@ def geometry_jacobian(t, y): inner_radius_derivative_wrt_height = 0 height_derivative_wrt_inner_radius = 0 height_derivative_wrt_height = 0 + # Height is a constant, so all the derivatives with respect to it are set to zero return [ [ From d97ba24726feee84fcd5a4dd7ecb7e870f225029 Mon Sep 17 00:00:00 2001 From: caioessouza Date: Fri, 30 May 2025 17:14:36 -0300 Subject: [PATCH 6/8] only_radial_burn on hybrid corrected only_radial_burn argument order corrected --- rocketpy/motors/hybrid_motor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rocketpy/motors/hybrid_motor.py b/rocketpy/motors/hybrid_motor.py index 9a1eb6636..12b270645 100644 --- a/rocketpy/motors/hybrid_motor.py +++ b/rocketpy/motors/hybrid_motor.py @@ -215,8 +215,8 @@ def __init__( # pylint: disable=too-many-arguments reshape_thrust_curve=False, interpolation_method="linear", coordinate_system_orientation="nozzle_to_combustion_chamber", - only_radial_burn=True, reference_pressure=None, + only_radial_burn=True, ): """Initialize Motor class, process thrust curve and geometrical parameters and store results. @@ -364,8 +364,8 @@ class Function. Thrust units are Newtons. reshape_thrust_curve, interpolation_method, coordinate_system_orientation, - only_radial_burn, reference_pressure, + only_radial_burn, ) self.positioned_tanks = self.liquid.positioned_tanks From 0cb0eb539b4373bff8564724c156f15db5403287 Mon Sep 17 00:00:00 2001 From: caioessouza Date: Tue, 12 Aug 2025 21:09:35 -0300 Subject: [PATCH 7/8] Tests created The solid motor integrations test was created and the solid and hybrid motors unit tests were modified to add checks to the new only_radial_burning class and parameters. Also a correction was made in the hybrid unit tests to fix the test time. --- flight.json | 0 tests/integration/test_solidmotor.py | 15 +++++++++++ tests/unit/test_hybridmotor.py | 40 ++++++++++++++++++++++++++-- tests/unit/test_solidmotor.py | 29 ++++++++++++++++++++ 4 files changed, 82 insertions(+), 2 deletions(-) create mode 100644 flight.json create mode 100644 tests/integration/test_solidmotor.py diff --git a/flight.json b/flight.json new file mode 100644 index 000000000..e69de29bb diff --git a/tests/integration/test_solidmotor.py b/tests/integration/test_solidmotor.py new file mode 100644 index 000000000..8cc71adba --- /dev/null +++ b/tests/integration/test_solidmotor.py @@ -0,0 +1,15 @@ +from unittest.mock import patch + +@patch("matplotlib.pyplot.show") +def test_solid_motor_info(mock_show, cesaroni_m1670): + """Tests the SolidMotor.all_info() method. + + Parameters + ---------- + mock_show : mock + Mock of the matplotlib.pyplot.show function. + hybrid_motor : rocketpy.HybridMotor + The SolidMotor object to be used in the tests. + """ + assert cesaroni_m1670.info() is None + assert cesaroni_m1670.all_info() is None \ No newline at end of file diff --git a/tests/unit/test_hybridmotor.py b/tests/unit/test_hybridmotor.py index ef03a1998..a043c094e 100644 --- a/tests/unit/test_hybridmotor.py +++ b/tests/unit/test_hybridmotor.py @@ -121,7 +121,7 @@ def test_hybrid_motor_center_of_mass(hybrid_motor, spherical_oxidizer_tank): propellant_center_of_mass = propellant_balance / (grain_mass + oxidizer_mass) center_of_mass = balance / (grain_mass + oxidizer_mass + DRY_MASS) - for t in np.linspace(0, 100, 100): + for t in np.linspace(0, BURN_TIME, 100): assert pytest.approx( hybrid_motor.center_of_propellant_mass(t) ) == propellant_center_of_mass(t) @@ -170,9 +170,45 @@ def test_hybrid_motor_inertia(hybrid_motor, spherical_oxidizer_tank): + DRY_MASS * (-hybrid_motor.center_of_mass + CENTER_OF_DRY_MASS) ** 2 ) - for t in np.linspace(0, 100, 100): + for t in np.linspace(0, BURN_TIME, 100): assert pytest.approx(hybrid_motor.propellant_I_11(t)) == propellant_inertia(t) assert pytest.approx(hybrid_motor.I_11(t)) == inertia(t) # Assert cylindrical symmetry assert pytest.approx(hybrid_motor.propellant_I_22(t)) == propellant_inertia(t) + +def test_hybrid_motor_only_radial_burn_behavior(hybrid_motor): + """ + Test if only_radial_burn flag in HybridMotor propagates to its SolidMotor + and affects burn_area calculation. + """ + motor = hybrid_motor + + # Activates the radial burning + motor.solid.only_radial_burn = True + assert motor.solid.only_radial_burn is True + + # Calculates the expected initial area + burn_area_radial = ( + 2 + * np.pi + * (motor.solid.grain_inner_radius(0) * motor.solid.grain_height(0)) + * motor.solid.grain_number + ) + + assert np.isclose(motor.solid.burn_area(0), burn_area_radial, atol=1e-12) + + # Deactivates the radial burning and recalculate the geometry + motor.solid.only_radial_burn = False + motor.solid.evaluate_geometry() + assert motor.solid.only_radial_burn is False + + # In this case the burning area also considers tha bases of the grain + inner_radius = motor.solid.grain_inner_radius(0) + outer_radius = motor.solid.grain_outer_radius + burn_area_total = ( + burn_area_radial + + 2 * np.pi * (outer_radius**2 - inner_radius**2) * motor.solid.grain_number + ) + assert np.isclose(motor.solid.burn_area(0), burn_area_total, atol=1e-12) + assert motor.solid.burn_area(0) > burn_area_radial \ No newline at end of file diff --git a/tests/unit/test_solidmotor.py b/tests/unit/test_solidmotor.py index 3f829d222..5e8906b3a 100644 --- a/tests/unit/test_solidmotor.py +++ b/tests/unit/test_solidmotor.py @@ -279,3 +279,32 @@ def test_reshape_thrust_curve_asserts_resultant_thrust_curve_correct( assert thrust_reshaped[1][1] == 100 * (tuple_parametric[1] / 7539.1875) assert thrust_reshaped[7][1] == 2034 * (tuple_parametric[1] / 7539.1875) + +def test_only_radial_burn_parameter_effect(cesaroni_m1670): + # Tests if the only_radial_burn flag is properly set + motor = cesaroni_m1670 + motor.only_radial_burn = True + assert motor.only_radial_burn is True + + # When only_radial_burn is active, burn_area should consider only radial area + burn_area_radial = 2 * np.pi * (motor.grain_inner_radius(0) * motor.grain_height(0)) * motor.grain_number + assert np.isclose(motor.burn_area(0), burn_area_radial, atol=1e-12) + +def test_evaluate_geometry_updates_properties(cesaroni_m1670): + # Checks if after instantiation, grain_inner_radius and grain_height are valid functions + motor = cesaroni_m1670 + + assert hasattr(motor, "grain_inner_radius") + assert hasattr(motor, "grain_height") + + # Checks if the domain of grain_inner_radius function is consistent + times = motor.grain_inner_radius.x_array + values = motor.grain_inner_radius.y_array + + assert times[0] == 0 # expected initial time + assert values[0] == motor.grain_initial_inner_radius # expected initial inner radius + assert values[-1] <= motor.grain_outer_radius # final inner radius should be less or equal than outer radius + + # Evaluates without error + val = motor.grain_inner_radius(0.5) # evaluate at intermediate time + assert isinstance(val, float) \ No newline at end of file From 8de2ab4517f672f752f22b8a93837c829633c0c8 Mon Sep 17 00:00:00 2001 From: caioessouza Date: Thu, 14 Aug 2025 12:57:32 -0300 Subject: [PATCH 8/8] Corrections made based in the review Comments checked and resolved. @Gui-FernandesBR please check the CHANGELOG.md to see if it's correct now. --- CHANGELOG.md | 2 +- flight.json | 0 tests/integration/test_solidmotor.py | 2 +- tests/unit/test_hybridmotor.py | 2 +- 4 files changed, 3 insertions(+), 3 deletions(-) delete mode 100644 flight.json diff --git a/CHANGELOG.md b/CHANGELOG.md index bba3b081f..8801dca32 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -31,6 +31,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/). Attention: The newest changes should be on top --> ### Added +- ENH: Enable only radial burning [#815](https://github.com/RocketPy-Team/RocketPy/pull/815) - ENH: Support for ND arithmetic in Function class. [#810] (https://github.com/RocketPy-Team/RocketPy/pull/810) - ENH: allow users to provide custom samplers [#803](https://github.com/RocketPy-Team/RocketPy/pull/803) - ENH: Implement Multivariate Rejection Sampling (MRS) [#738] (https://github.com/RocketPy-Team/RocketPy/pull/738) @@ -53,7 +54,6 @@ Attention: The newest changes should be on top --> ### Added -- ENH: Enable only radial burning [#815](https://github.com/RocketPy-Team/RocketPy/pull/815) - ENH: Parallel mode for monte-carlo simulations 2 [#768](https://github.com/RocketPy-Team/RocketPy/pull/768) - DOC: ASTRA Flight Example [#770](https://github.com/RocketPy-Team/RocketPy/pull/770) - ENH: Add Eccentricity to Stochastic Simulations [#792](https://github.com/RocketPy-Team/RocketPy/pull/792) diff --git a/flight.json b/flight.json deleted file mode 100644 index e69de29bb..000000000 diff --git a/tests/integration/test_solidmotor.py b/tests/integration/test_solidmotor.py index 8cc71adba..3cd58a345 100644 --- a/tests/integration/test_solidmotor.py +++ b/tests/integration/test_solidmotor.py @@ -8,7 +8,7 @@ def test_solid_motor_info(mock_show, cesaroni_m1670): ---------- mock_show : mock Mock of the matplotlib.pyplot.show function. - hybrid_motor : rocketpy.HybridMotor + cesaroni_m1670 : rocketpy.SolidMotor The SolidMotor object to be used in the tests. """ assert cesaroni_m1670.info() is None diff --git a/tests/unit/test_hybridmotor.py b/tests/unit/test_hybridmotor.py index a043c094e..0c79eaac5 100644 --- a/tests/unit/test_hybridmotor.py +++ b/tests/unit/test_hybridmotor.py @@ -203,7 +203,7 @@ def test_hybrid_motor_only_radial_burn_behavior(hybrid_motor): motor.solid.evaluate_geometry() assert motor.solid.only_radial_burn is False - # In this case the burning area also considers tha bases of the grain + # In this case the burning area also considers the bases of the grain inner_radius = motor.solid.grain_inner_radius(0) outer_radius = motor.solid.grain_outer_radius burn_area_total = (