Update app.py

app.py

@@ -2,17 +2,22 @@ import gradio as gr
 import math
 import itertools
 
+# Available Capacitor Units (kVAR)
 available_capacitors = [25, 20, 15, 10, 5, 2.5, 1.5, 1]
 
+
 def calculate_power_parameters(voltage, current, power_factor):
     if voltage > 0 and current > 0:
         apparent_power = math.sqrt(3) * voltage * current
         real_power = apparent_power * power_factor / 1000
+
         try:
             reactive_power = math.sqrt((apparent_power / 1000) ** 2 - real_power ** 2)
         except ValueError:
             reactive_power = 0.0
+
         calculated_pf = real_power * 1000 / apparent_power if apparent_power > 0 else 0
+
         return {
             "apparent_power": round(apparent_power, 2),
             "real_power": round(real_power, 2),
@@ -26,114 +31,108 @@ def calculate_power_parameters(voltage, current, power_factor):
 def design_unique_capacitor_bank(reactive_power, num_caps):
     if reactive_power > 0 and num_caps > 0:
         best_combo = None
-        min_error = float("inf")
 
-        # Try all unique combinations of sizes with up to num_caps elements
-        for combo in itertools.combinations(available_capacitors, min(num_caps, len(available_capacitors))):
-            if len(combo) < num_caps:
-                # Allow repeated use only when needed
-                extended = list(combo)
-                while len(extended) < num_caps:
-                    extended.append(min(combo))  # repeat the smallest one
-                combo = tuple(extended)
+        for combo in itertools.combinations_with_replacement(available_capacitors, int(num_caps)):
+            if len(set(combo)) < num_caps:
+                continue  # Avoid reuse unless necessary
 
             total = sum(combo)
-            error = abs(total - reactive_power)
 
-            if error < min_error:
-                min_error = error
+            if abs(total - reactive_power) < 0.01:
                 best_combo = combo
-
-            if error == 0:
                 break
 
         if best_combo:
             suggested_capacitors = [f"{cap} kVAR" for cap in best_combo]
             total_kvar = sum(best_combo)
-            message = f"Total Compensation: {round(total_kvar, 2)} kVAR"
-            if abs(total_kvar - reactive_power) > 0.5:
-                message += ". Small mismatch detected. Fine-tuning may be required."
-                mismatch = True
-            else:
-                mismatch = False
+            message = f"✅ Exact Match! Total Compensation: {round(total_kvar, 2)} kVAR"
             return {
                 "suggested_capacitors": suggested_capacitors,
                 "total_kvar": round(total_kvar, 2),
                 "message": message,
-                "mismatch": mismatch
+                "mismatch": False
             }
         else:
-            return {"message": "Could not find a suitable combination."}
+            return {
+                "message": "❌ No exact match found with the selected number of capacitors.",
+                "suggested_capacitors": [],
+                "total_kvar": 0,
+                "mismatch": True
+            }
     return None
 
 
-def calculate_and_store_reactive_power(voltage, current, power_factor, frequency):
-    global stored_reactive_power
+reactive_power_state = gr.State(0.0)
+
+
+def compute_reactive_power(voltage, current, power_factor):
     power_results = calculate_power_parameters(voltage, current, power_factor)
     if power_results:
-        stored_reactive_power = power_results["reactive_power"]
+        apparent_power_out = f"Apparent Power: **{power_results['apparent_power']} VA**"
+        real_power_out = f"Real Power: **{power_results['real_power']} kW**"
+        reactive_power_out = f"Reactive Power: **{power_results['reactive_power']} kVAR**"
+        calculated_pf_out = f"Calculated Power Factor: **{power_results['calculated_pf']}**"
         return (
-            f"Apparent Power: **{power_results['apparent_power']} VA**",
-            f"Real Power: **{power_results['real_power']} kW**",
-            f"Reactive Power: **{power_results['reactive_power']} kVAR**",
-            f"Calculated Power Factor: **{power_results['calculated_pf']}**"
+            apparent_power_out,
+            real_power_out,
+            reactive_power_out,
+            calculated_pf_out,
+            power_results['reactive_power']
         )
     else:
-        return (
-            "⚠️ Please enter valid Voltage and Current!",
-            "", "", ""
-        )
+        return ("Invalid Input", "", "", "", 0.0)
 
 
-def design_bank_from_user_input(num_caps):
-    global stored_reactive_power
-    if stored_reactive_power <= 0:
-        return "Please calculate reactive power first.", "", ""
-    cap_bank_design = design_unique_capacitor_bank(stored_reactive_power, num_caps)
-    if cap_bank_design:
-        suggested_caps = "<br>".join(
-            [f"🔹 Capacitor {i+1}: **{c}**" for i, c in enumerate(cap_bank_design["suggested_capacitors"])]
+def process_capacitor_bank(reactive_power, num_caps):
+    cap_bank_design = design_unique_capacitor_bank(reactive_power, num_caps)
+    if cap_bank_design and not cap_bank_design['mismatch']:
+        suggested_capacitors_text = "<br>".join(
+            [f"🔹 Capacitor {idx + 1}: **{cap}**" for idx, cap in enumerate(cap_bank_design['suggested_capacitors'])]
         )
-        return suggested_caps, cap_bank_design["total_kvar"], cap_bank_design["message"]
+        return suggested_capacitors_text, cap_bank_design['message']
     else:
-        return "No suitable combination found.", "", ""
+        return "<span style='color:red'>No exact match found.</span>", cap_bank_design['message']
 
 
-stored_reactive_power = 0
+with gr.Blocks(title="Three-Phase Power Calculator") as app:
+    gr.Markdown("""
+    # ⚡ Three-Phase Power Calculator & Capacitor Bank Designer
+    Compute power parameters and precisely design your capacitor bank with no mismatch.
+    """)
 
-with gr.Blocks(title="Capacitor Bank Designer") as app:
-    gr.Markdown("## ⚡ Three-Phase Power & Capacitor Bank Designer")
-    
     with gr.Row():
-        voltage = gr.Number(label="Voltage (V)", value=415)
-        current = gr.Number(label="Current (A)", value=250)
-        power_factor = gr.Slider(label="Power Factor", minimum=0.0, maximum=1.0, value=0.85, step=0.01)
-        frequency = gr.Radio(label="Frequency", choices=[50, 60], value=50)
-
-    calc_btn = gr.Button("Calculate Reactive Power")
-    
-    app_power = gr.HTML()
-    real_power = gr.HTML()
-    reactive_power = gr.HTML()
-    pf_result = gr.HTML()
-
-    calc_btn.click(
-        fn=calculate_and_store_reactive_power,
-        inputs=[voltage, current, power_factor, frequency],
-        outputs=[app_power, real_power, reactive_power, pf_result]
+        voltage_input = gr.Number(label="Voltage (V)", value=415)
+        current_input = gr.Number(label="Current (A)", value=250)
+        pf_input = gr.Slider(label="Power Factor", minimum=0.0, maximum=1.0, value=0.85, step=0.01)
+
+    freq_input = gr.Radio(label="Select Frequency (Hz)", choices=[50, 60], value=50)
+    compute_btn = gr.Button("Compute Power")
+
+    app_output = gr.HTML()
+    real_output = gr.HTML()
+    reactive_output = gr.HTML()
+    pf_output = gr.HTML()
+
+    compute_btn.click(
+        compute_reactive_power,
+        inputs=[voltage_input, current_input, pf_input],
+        outputs=[app_output, real_output, reactive_output, pf_output, reactive_power_state]
     )
 
-    gr.Markdown("---")
-    gr.Markdown("### Enter Number of Capacitors to Suggest a Bank")
-
-    num_caps = gr.Number(label="Number of Capacitors", value=3, precision=0)
-    bank_btn = gr.Button("Design Capacitor Bank")
+    gr.Markdown("""
+    ### Capacitor Bank Design (Only exact match results are accepted)
+    """)
 
-    cap_result = gr.HTML()
-    cap_total = gr.HTML()
+    num_caps_input = gr.Number(label="Enter Number of Capacitors", value=2)
+    cap_btn = gr.Button("Design Capacitor Bank")
+    cap_suggestion = gr.HTML()
     cap_message = gr.HTML()
 
-    bank_btn.click(fn=design_bank_from_user_input, inputs=[num_caps], outputs=[cap_result, cap_total, cap_message])
+    cap_btn.click(
+        process_capacitor_bank,
+        inputs=[reactive_power_state, num_caps_input],
+        outputs=[cap_suggestion, cap_message]
+    )
 
 if __name__ == "__main__":
     app.launch()