class BrushlessMotor:
 def __init__(self, kv, stator_width, stator_height, weight_g):
 self.kv = kv
 self.stator_width = stator_width
 self.stator_height = stator_height
 self.weight = weight_g

 def no_load_rpm(self, voltage):
 return self.kv * voltage

 def max_thrust_grams(self, voltage):
 return self.kv * voltage * 0.08

 def efficiency_at_throttle(self, throttle_pct):
 if throttle_pct <= 50:
 return 0.5 + (throttle_pct / 100)
 else:
 return 1.0 - ((throttle_pct - 50) / 100 * 0.6)

# Compare motor sizes
motors = [
 BrushlessMotor(kv=2300, stator_width=22, stator_height=7, weight_g=31),
 BrushlessMotor(kv=2400, stator_width=23, stator_height=6, weight_g=28),
 BrushlessMotor(kv=1700, stator_width=28, stator_height=12, weight_g=55),
]

voltage = 14.8 # 4S LiPo
for m in motors:
 print(f"{m.stator_width}{m.stator_height} @ {m.kv}KV")
 print(f" No-load RPM: {m.no_load_rpm(voltage):.0f}")
 print(f" Max thrust: {m.max_thrust_grams(voltage):.0f}g")
 print(f" Weight: {m.weight}g")
 print(f" Thrust/Weight: {m.max_thrust_grams(voltage)/m.weight:.1f}:1\n")

def kv_recommendation(voltage, prop_diameter_inches):
 """Recommend KV range based on battery and prop size"""
 # Rule of thumb: KV * voltage * prop_diameter should be ~constant
 magic_number = voltage * prop_diameter_inches

 if magic_number < 50:
 return "High KV (2800+)", "Micro/whoop builds"
 elif magic_number < 70:
 return "Medium-High KV (2400-2800)", "3-4 inch builds"
 elif magic_number < 90:
 return "Medium KV (2200-2500)", "5 inch standard"
 elif magic_number < 120:
 return "Low-Medium KV (1700-2200)", "5-6 inch long range"
 else:
 return "Low KV (1400-1700)", "7+ inch heavy lift"

configs = [
 (7.4, 3), # 2S, 3-inch
 (14.8, 5), # 4S, 5-inch
 (22.2, 5), # 6S, 5-inch
 (22.2, 7), # 6S, 7-inch
]
for v, p in configs:
 kv_range, use = kv_recommendation(v, p)
 print(f"{v}V + {p}inch prop: {kv_range} — {use}")

class Propeller:
 def __init__(self, diameter_inches, pitch_inches, blades=2):
 self.diameter = diameter_inches
 self.pitch = pitch_inches
 self.blades = blades
 self.diameter_m = diameter_inches * 0.0254
 self.pitch_m = pitch_inches * 0.0254

 def advance_ratio(self, velocity_ms, rpm):
 """J = V / (n * D) — ratio of forward speed to tip speed"""
 n = rpm / 60 # rev/s
 return velocity_ms / (n * self.diameter_m) if n > 0 else 0

 def theoretical_thrust_constant(self):
 """Simplified thrust coefficient based on blade area"""
 blade_area = self.blades * 0.1 * self.diameter_m ** 2
 disk_area = math.pi * (self.diameter_m / 2) ** 2
 solidity = blade_area / disk_area
 return solidity * 0.05 # Simplified Ct

 def thrust_at_rpm(self, rpm, air_density=1.225):
 """T = Ct * rho * n^2 * D^4"""
 Ct = self.theoretical_thrust_constant()
 n = rpm / 60
 thrust = Ct * air_density * (n ** 2) * (self.diameter_m ** 4)
 return thrust # Newtons

 def pitch_speed(self):
 """Theoretical max speed from pitch: Pitch * RPM"""
 return self.pitch_m # meters per revolution

 def __repr__(self):
 return f"{self.diameter}x{self.pitch}x{self.blades}"

# Compare propellers
props = [
 Propeller(5, 4.5, 3), # 5045 triblade
 Propeller(5, 4.0, 2), # 5040 biblade
 Propeller(7, 3.5, 2), # 7035 long range
 Propeller(3, 2.5, 2), # 3025 micro
]

rpm = 20000
print(f"Thrust at {rpm} RPM:")
for p in props:
 thrust_n = p.thrust_at_rpm(rpm)
 thrust_g = thrust_n / 9.81 * 1000
 print(f" {p}: {thrust_g:.0f}g ({thrust_n:.2f}N)")

def analyze_build(motor_thrust_g, motor_count, drone_weight_g):
 total_thrust = motor_thrust_g * motor_count
 twr = total_thrust / drone_weight_g

 print(f"Total thrust: {total_thrust}g")
 print(f"Drone weight: {drone_weight_g}g")
 print(f"Thrust/Weight: {twr:.1f}:1")

 if twr < 2:
 print(" WARNING: Cannot fly! TWR must be > 1")
 elif twr < 3:
 print(" Type: Cinematic / Gentle flying")
 elif twr < 5:
 print(" Type: General purpose / Photography")
 elif twr < 8:
 print(" Type: Racing / Acrobatic")
 else:
 print(" Type: Extreme racing / Competition")
 return twr

print("=== Racing Quad Build ===")
analyze_build(motor_thrust_g=1200, motor_count=4, drone_weight_g=450)

print("\n=== Cinematic Build ===")
analyze_build(motor_thrust_g=800, motor_count=4, drone_weight_g=600)

class PropulsionAnalyzer:
 def __init__(self):
 self.motor_data = {
 "2207_2400KV": {"kv": 2400, "resistance": 0.08, "weight": 31},
 "2306_1700KV": {"kv": 1700, "resistance": 0.10, "weight": 33},
 "2812_1300KV": {"kv": 1300, "resistance": 0.12, "weight": 55},
 }

 def compute_thrust(self, kv, voltage, prop_diameter_m, Cp=0.04):
 rpm = kv * voltage
 n = rpm / 60
 thrust = Cp * 1.225 * (n ** 2) * (prop_diameter_m ** 4)
 return thrust * 1000 # grams

 def compute_power(self, voltage, thrust_g, efficiency=0.7):
 mechanical_power = thrust_g * 9.81 / 1000 * 2 # simplified
 electrical_power = mechanical_power / efficiency
 return electrical_power

 def flight_time_estimate(self, battery_mah, total_power_w, voltage):
 battery_wh = battery_mah * voltage / 1000
 # Only use 80% of battery
 usable_wh = battery_wh * 0.8
 flight_time_h = usable_wh / total_power_w
 return flight_time_h * 60 # minutes

 def analyze_build(self, motor_key, prop_diameter, battery_mah, voltage, drone_weight_g):
 motor = self.motor_data[motor_key]
 thrust_per_motor = self.compute_thrust(motor["kv"], voltage, prop_diameter)
 total_thrust = thrust_per_motor * 4
 twr = total_thrust / drone_weight_g
 power_per_motor = self.compute_power(voltage, thrust_per_motor)
 total_power = power_per_motor * 4
 flight_time = self.flight_time_estimate(battery_mah, total_power, voltage)

 print(f"\nBuild: {motor_key} + {prop_diameter*39.37:.0f}inch + {battery_mah}mAh")
 print(f" Thrust/motor: {thrust_per_motor:.0f}g")
 print(f" Total thrust: {total_thrust:.0f}g")
 print(f" TWR: {twr:.1f}:1")
 print(f" Total power: {total_power:.1f}W")
 print(f" Est. flight time: {flight_time:.1f} min")
 return {"twr": twr, "flight_time": flight_time, "power": total_power}

analyzer = PropulsionAnalyzer()
analyzer.analyze_build("2207_2400KV", 0.127, 1300, 14.8, 350)
analyzer.analyze_build("2812_1300KV", 0.178, 1800, 22.2, 600)