propeller_bemt_analysis
Analyze propeller performance using Blade Element Momentum Theory to calculate thrust, power, and efficiency based on geometry and operating conditions.
Instructions
Analyze propeller performance using Blade Element Momentum Theory.
Args: propeller_geometry: Propeller geometry (diameter_m, pitch_m, num_blades, etc.) operating_conditions: Operating conditions (rpm_list, velocity_ms, altitude_m) analysis_options: Optional analysis settings
Returns: Formatted string with propeller performance analysis
Input Schema
TableJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| propeller_geometry | Yes | ||
| operating_conditions | Yes | ||
| analysis_options | No |
Implementation Reference
- aerospace_mcp/tools/propellers.py:9-84 (handler)MCP tool handler: processes input dicts, validates with PropellerGeometry pydantic model, delegates to core BEMT analysis, formats tabular and JSON output.
def propeller_bemt_analysis( propeller_geometry: dict, operating_conditions: dict, analysis_options: dict | None = None, ) -> str: """Analyze propeller performance using Blade Element Momentum Theory. Args: propeller_geometry: Propeller geometry (diameter_m, pitch_m, num_blades, etc.) operating_conditions: Operating conditions (rpm_list, velocity_ms, altitude_m) analysis_options: Optional analysis settings Returns: Formatted string with propeller performance analysis """ try: from ..integrations.propellers import ( PropellerGeometry, ) from ..integrations.propellers import ( propeller_bemt_analysis as _propeller_analysis, ) # Create geometry object geometry = PropellerGeometry(**propeller_geometry) rpm_list = operating_conditions.get("rpm_list", [2000, 2500, 3000]) velocity_ms = operating_conditions.get("velocity_ms", 20.0) altitude_m = operating_conditions.get("altitude_m", 0.0) # Run analysis results = _propeller_analysis(geometry, rpm_list, velocity_ms, altitude_m) # Format response result_lines = [ "Propeller BEMT Analysis", "=" * 60, f"Propeller: {geometry.diameter_m:.2f}m dia, {geometry.pitch_m:.2f}m pitch, {geometry.num_blades} blades", f"Conditions: {velocity_ms:.1f} m/s @ {altitude_m:.0f}m altitude", "", f"{'RPM':>6} {'Thrust (N)':>10} {'Power (W)':>9} {'Efficiency':>10} {'Adv Ratio':>10}", ] result_lines.append("-" * 60) for result in results: result_lines.append( f"{result.rpm:6.0f} {result.thrust_n:10.1f} {result.power_w:9.0f} " f"{result.efficiency:10.3f} {result.advance_ratio:10.3f}" ) # Add JSON data json_data = json.dumps( [ { "rpm": r.rpm, "thrust_n": r.thrust_n, "torque_nm": r.torque_nm, "power_w": r.power_w, "efficiency": r.efficiency, "advance_ratio": r.advance_ratio, "thrust_coefficient": r.thrust_coefficient, "power_coefficient": r.power_coefficient, } for r in results ], indent=2, ) result_lines.extend(["", "JSON Data:", json_data]) return "\n".join(result_lines) except ImportError: return "Propeller analysis not available - install propulsion packages" except Exception as e: logger.error(f"Propeller analysis error: {str(e)}", exc_info=True) return f"Propeller analysis error: {str(e)}" - aerospace_mcp/fastmcp_server.py:106-106 (registration)FastMCP tool registration: registers the propeller_bemt_analysis function as an MCP tool.
mcp.tool(propeller_bemt_analysis) - Input schema: Pydantic BaseModel for propeller geometry parameters used for validation.
class PropellerGeometry(BaseModel): """Propeller geometric parameters.""" diameter_m: float = Field(..., gt=0, description="Propeller diameter in meters") pitch_m: float = Field(..., gt=0, description="Propeller pitch in meters") num_blades: int = Field(..., ge=2, le=6, description="Number of blades") hub_radius_m: float = Field(0.02, ge=0, description="Hub radius in meters") activity_factor: float = Field( 100, ge=50, le=200, description="Propeller activity factor" ) cl_design: float = Field(0.5, gt=0, le=1.5, description="Design lift coefficient") cd_design: float = Field(0.02, gt=0, le=0.1, description="Design drag coefficient") - Core analysis dispatcher: selects between AeroSandbox BEMT or simplified momentum theory based on availability.
def propeller_bemt_analysis( geometry: PropellerGeometry, rpm_list: list[float], velocity_ms: float, altitude_m: float = 0, ) -> list[PropellerPerformancePoint]: """ Blade Element Momentum Theory propeller analysis. Args: geometry: Propeller geometry parameters rpm_list: List of RPM values to analyze velocity_ms: Forward velocity in m/s altitude_m: Altitude for atmospheric conditions Returns: List of PropellerPerformancePoint objects """ if AEROSANDBOX_AVAILABLE: try: return _aerosandbox_propeller_analysis( geometry, rpm_list, velocity_ms, altitude_m ) except Exception: # Fall back to simple method pass # Use simple momentum theory + basic blade element method return _simple_propeller_analysis(geometry, rpm_list, velocity_ms, altitude_m) - Fallback analysis: Implements simplified BEMT with momentum theory for static/forward flight conditions when AeroSandbox unavailable.
def _simple_propeller_analysis( geometry: PropellerGeometry, rpm_list: list[float], velocity_ms: float, altitude_m: float = 0, ) -> list[PropellerPerformancePoint]: """ Simple propeller analysis using momentum theory and basic blade element methods. Used as fallback when advanced libraries unavailable. """ # Atmospheric conditions if altitude_m < 11000: temp = 288.15 - 0.0065 * altitude_m pressure = 101325 * (temp / 288.15) ** 5.256 else: temp = 216.65 pressure = 22632 * math.exp(-0.0001577 * (altitude_m - 11000)) rho = pressure / (287.04 * temp) results = [] for rpm in rpm_list: n = rpm / 60.0 # Revolutions per second D = geometry.diameter_m # Advance ratio J = velocity_ms / (n * D) if n > 0 else 0 # Simple momentum theory for static thrust if J < 0.1: # Static or near-static conditions # Simplified static thrust estimation CT_static = 0.12 * geometry.num_blades / 2 # Rough approximation thrust_n = CT_static * rho * n**2 * D**4 # Power estimation from simplified BEMT CP_static = ( CT_static ** (3 / 2) / math.sqrt(2) * 1.2 ) # Include profile power power_w = CP_static * rho * n**3 * D**5 efficiency = 0.5 if power_w > 0 else 0 # Low efficiency in static else: # Forward flight conditions # Simplified propeller theory beta = math.atan(geometry.pitch_m / (math.pi * D)) # Geometric pitch angle # Thrust coefficient approximation alpha_eff = beta - math.atan( J / (math.pi * 0.75) ) # Effective angle at 75% radius # Simplified lift and drag cl_eff = ( geometry.cl_design * math.sin(2 * alpha_eff) if abs(alpha_eff) < math.pi / 4 else 0 ) cd_eff = geometry.cd_design + 0.01 * cl_eff**2 # Thrust and power coefficients CT = ( 0.5 * geometry.num_blades * cl_eff * (0.75**2) * (1 - 0.25) ) # Integrated over blade CP = 0.5 * geometry.num_blades * cd_eff * (0.75**2) * ( 1 - 0.25 ) + CT * J / (2 * math.pi) # Apply corrections for finite number of blades CT *= min(1.0, geometry.num_blades / 2) CP *= min(1.0, geometry.num_blades / 2) thrust_n = CT * rho * n**2 * D**4 power_w = CP * rho * n**3 * D**5 efficiency = J * CT / CP if CP > 0 else 0 # Torque torque_nm = power_w / (2 * math.pi * n) if n > 0 else 0 # Limit efficiency and ensure physical values efficiency = max(0, min(0.9, efficiency)) thrust_n = max(0, thrust_n) power_w = max(1, power_w) # Minimum power for losses results.append( PropellerPerformancePoint( rpm=rpm, thrust_n=thrust_n, torque_nm=torque_nm, power_w=power_w, efficiency=efficiency, advance_ratio=J, thrust_coefficient=thrust_n / (rho * n**2 * D**4) if n > 0 else 0, power_coefficient=power_w / (rho * n**3 * D**5) if n > 0 else 0, ) ) return results