Aerospace MCP

Instructions

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)
• aerospace_mcp/integrations/propellers.py:110-122 (schema)

  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")
• aerospace_mcp/integrations/propellers.py:286-314 (helper)

  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)
• aerospace_mcp/integrations/propellers.py:184-283 (helper)

  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