Update app.py

app.py

@@ -1,151 +1,221 @@
-import gradio as gr
+import cadquery as cq
 import numpy as np
-import pandas as pd
-from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
-from joblib import dump, load
 import matplotlib.pyplot as plt
+import pyvista as pv
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+import gradio as gr
 import os
-python -c import ansys.mapdl.core
-
-
-# ========== Train AI Models ==========
-def train_models():
-    # Synthetic training data
-    data = {
-        "Thickness": [10, 15, 20, 25],
-        "Hole_Diameter": [5, 10, 15, 20],
-        "Force": [5000, 7000, 10000, 12000],
-        "Max_Stress": [300, 250, 200, 150],
-        "Max_Deformation": [0.5, 0.4, 0.3, 0.2],
-        "Pass_Fail": [1, 1, 0, 0],  # 1: Pass, 0: Fail
-    }
-    df = pd.DataFrame(data)
-    X = df[["Thickness", "Hole_Diameter", "Force"]]
-
-    # Train regression models
-    stress_model = RandomForestRegressor().fit(X, df["Max_Stress"])
-    deformation_model = RandomForestRegressor().fit(X, df["Max_Deformation"])
-
-    # Train classification model
-    pass_fail_model = RandomForestClassifier().fit(X, df["Pass_Fail"])
-
-    # Save models
-    dump(stress_model, "stress_model.pkl")
-    dump(deformation_model, "deformation_model.pkl")
-    dump(pass_fail_model, "pass_fail_model.pkl")
-
-# Train the models
-train_models()
-
-# Load models
-stress_model = load("stress_model.pkl")
-deformation_model = load("deformation_model.pkl")
-pass_fail_model = load("pass_fail_model.pkl")
-
-# ========== ANSYS Simulation ==========
-def run_ansys_simulation(thickness, hole_diameter, force):
-    mapdl = launch_mapdl()
-    mapdl.clear()
-    mapdl.prep7()
-
-    # Material properties
-    mapdl.mp("EX", 1, 2e11)
-    mapdl.mp("PRXY", 1, 0.3)
-
-    # Geometry
-    mapdl.block(0, 100, 0, 50, 0, thickness)
-    mapdl.cylind(0, hole_diameter / 2, 50, 25, 0, thickness)
-    mapdl.vsubtract("ALL")
-
-    # Meshing
-    mapdl.et(1, "SOLID185")
-    mapdl.esize(5)
-    mapdl.vmesh("ALL")
-
-    # Boundary conditions and force
-    mapdl.nsel("S", "LOC", "X", 0)
-    mapdl.d("ALL", "ALL")
-    mapdl.nsel("S", "LOC", "X", 100)
-    mapdl.f("ALL", "FY", -force)
-
-    # Solve
-    mapdl.run("/SOLU")
-    mapdl.antype("STATIC")
-    mapdl.solve()
-    mapdl.finish()
-
-    # Post-process
-    mapdl.post1()
-    max_stress = mapdl.get_value("NODE", 0, "S", "EQV")
-    max_deformation = mapdl.get_value("NODE", 0, "U", "SUM")
-    mapdl.exit()
-
-    return max_stress, max_deformation
-
-# ========== AI and Simulation Workflow ==========
-def ai_and_simulation_workflow(thickness, hole_diameter, force):
-    # AI pre-screening
-    pre_screen = pass_fail_model.predict([[thickness, hole_diameter, force]])[0]
-    if pre_screen == 0:
-        return {
-            "status": "Fail",
-            "message": "AI predicts failure. Please adjust parameters.",
-            "stress": None,
-            "deformation": None,
+from ansys.mapdl.core import launch_mapdl  # For ANSYS integration
+
+
+# Function for Progressive Die Design
+def generate_die(length, width, thickness):
+    try:
+        plate = cq.Workplane("XY").box(length, width, thickness)
+        punch = cq.Workplane("XY").rect(10, 10).extrude(5).translate((length / 4, width / 4, thickness / 2))
+        die = plate.cut(punch)
+        filename = "progressive_die.step"
+        cq.exporters.export(die, filename)
+        return filename
+    except Exception as e:
+        return f"Error generating die: {str(e)}"
+
+
+# Function to visualize die in 3D
+def visualize_die(length, width, thickness):
+    try:
+        plate = cq.Workplane("XY").box(length, width, thickness)
+        punch = cq.Workplane("XY").rect(10, 10).extrude(5).translate((length / 4, width / 4, thickness / 2))
+        die = plate.cut(punch)
+
+        # Export to STL for visualization
+        cq.exporters.exportShape(die.val(), "STL", "progressive_die.stl")
+
+        # Visualize with PyVista
+        mesh = pv.read("progressive_die.stl")
+        plotter = pv.Plotter(off_screen=True)
+        plotter.add_mesh(mesh, color="blue")
+        screenshot = "progressive_die_visualization.png"
+        plotter.screenshot(screenshot)
+        return screenshot
+    except Exception as e:
+        return f"Error visualizing die: {str(e)}"
+
+
+# Function for Python-based Stress Analysis
+def stress_analysis(force, die_width, die_height, material_strength):
+    try:
+        stress = force / (die_width * die_height)
+        safety_factor = material_strength / stress
+
+        fig, ax = plt.subplots()
+        ax.bar(["Stress", "Material Strength"], [stress, material_strength])
+        ax.set_ylabel("Stress (MPa)")
+        ax.set_title("Stress Analysis")
+        plt.close(fig)
+
+        return f"Safety Factor: {round(safety_factor, 2)}", fig
+    except Exception as e:
+        return f"Error in stress analysis: {str(e)}", None
+
+
+# ANSYS Integration for Stress Analysis
+def run_ansys_simulation(force, die_width, die_height, material_strength):
+    try:
+        # Launch ANSYS MAPDL instance
+        mapdl = launch_mapdl()
+        mapdl.prep7()  # Enter pre-processing module
+
+        # Define geometry and material properties
+        mapdl.rectng(0, die_width, 0, die_height)
+        mapdl.mp('EX', 1, material_strength)
+        mapdl.et(1, 'PLANE183')
+
+        # Apply loads
+        mapdl.nsel('S', 'LOC', 'X', 0)
+        mapdl.d('ALL', 'UX', 0)
+        mapdl.f('ALL', 'FY', -force)
+
+        # Solve
+        mapdl.run('/SOLU')
+        mapdl.solve()
+        mapdl.finish()
+
+        # Post-processing
+        mapdl.post1()
+        stress = mapdl.get_value('NODE', 1, 'S', 'EQV')  # Retrieve max equivalent stress
+        mapdl.exit()
+
+        return f"Max Stress: {stress:.2f} MPa"
+    except Exception as e:
+        return f"Error running ANSYS simulation: {str(e)}"
+
+
+# SolidWorks Placeholder for Stress Analysis
+def solidworks_stress_analysis(force, die_width, die_height, material_strength):
+    # Replace this function with SolidWorks API or external script
+    try:
+        output_file = "/path/to/solidworks/output.txt"  # Replace with actual path
+        if os.path.exists(output_file):
+            with open(output_file, "r") as file:
+                result = file.read()
+            return result.strip()
+        else:
+            return "SolidWorks simulation output not found."
+    except Exception as e:
+        return f"Error running SolidWorks simulation: {str(e)}"
+
+
+# Function to generate PDF report
+def generate_pdf_report(data, filename="report.pdf"):
+    try:
+        c = canvas.Canvas(filename, pagesize=letter)
+        c.drawString(100, 750, "Simulation Report")
+        c.drawString(100, 730, f"Max Stress: {data.get('stress', 'N/A')} MPa")
+        c.drawString(100, 710, f"Safety Factor: {data.get('safety_factor', 'N/A')}")
+        c.save()
+        return filename
+    except Exception as e:
+        return f"Error generating report: {str(e)}"
+
+
+# Tool Optimization Function
+def optimize_tool(speed, feed_rate, depth_of_cut, material):
+    try:
+        # Example formula for tool optimization
+        tool_life = 1000 / (speed * feed_rate * depth_of_cut)
+        recommended_speed = 0.8 * speed
+        recommended_feed_rate = 0.9 * feed_rate
+
+        # Return optimization results in dictionary
+        results = {
+            "Estimated Tool Life (hrs)": round(tool_life, 2),
+            "Recommended Speed (m/min)": round(recommended_speed, 2),
+            "Recommended Feed Rate (mm/rev)": round(recommended_feed_rate, 2)
         }
+        return results
+    except Exception as e:
+        return {"Error": str(e)}
+
+
+# Gradio interface functions
+def stress_analysis_interface(force, die_width, die_height, material_strength, simulation_tool):
+    if simulation_tool == "Python":
+        # Python-based stress analysis
+        safety_factor, fig = stress_analysis(force, die_width, die_height, material_strength)
+        data = {"stress": force / (die_width * die_height), "safety_factor": safety_factor}
+        pdf_filename = generate_pdf_report(data)
+        return safety_factor, fig, pdf_filename
+
+    elif simulation_tool == "ANSYS":
+        # Run ANSYS-based simulation
+        result = run_ansys_simulation(force, die_width, die_height, material_strength)
+        return result, None, None
+
+    elif simulation_tool == "SolidWorks":
+        # Run SolidWorks-based simulation
+        result = solidworks_stress_analysis(force, die_width, die_height, material_strength)
+        return result, None, None
 
-    # Run ANSYS simulation
-    max_stress, max_deformation = run_ansys_simulation(thickness, hole_diameter, force)
-
-    # Validate results with AI
-    validation = "Pass" if max_stress < 250 and max_deformation < 0.3 else "Fail"
-
-    # Generate output
-    return {
-        "status": validation,
-        "message": f"Design {validation}.",
-        "stress": max_stress,
-        "deformation": max_deformation,
-    }
-
-# ========== UI ==========
-def visualize_results(results):
-    fig, ax = plt.subplots()
-    labels = ["Stress", "Deformation"]
-    values = [results["stress"], results["deformation"]]
-    ax.bar(labels, values, color=["#FFA07A", "#20B2AA"])
-    ax.set_title("Simulation Results")
-    plt.tight_layout()
-    image_path = "results.png"
-    plt.savefig(image_path)
-    plt.close(fig)
-    return image_path
-
-def run_ui(thickness, hole_diameter, force):
-    results = ai_and_simulation_workflow(thickness, hole_diameter, force)
-    if results["status"] == "Fail":
-        return results["message"], None
     else:
-        image_path = visualize_results(results)
-        return results["message"], image_path
-
-# Gradio Interface
-interface = gr.Interface(
-    fn=run_ui,
-    inputs=[
-        gr.Slider(10, 50, step=1, label="Thickness (mm)"),
-        gr.Slider(5, 25, step=1, label="Hole Diameter (mm)"),
-        gr.Slider(1000, 15000, step=500, label="Force (N)"),
-    ],
-    outputs=[
-        gr.Textbox(label="Simulation Status"),
-        gr.Image(label="Simulation Visualization"),
-    ],
-    title="AI-Driven ANSYS Design Validation",
-    description="Interactive tool for design validation using AI and ANSYS.",
-    theme="default",
-    live=True,
-)
-
-# Launch the interface
-interface.launch()
+        return "Invalid simulation tool selected", None, None
+
+
+# Create Gradio App
+with gr.Blocks() as app:
+    gr.Markdown("## Press Tool AI Suite")
+    gr.Markdown("Select a tool below to get started:")
+
+    with gr.Tabs():
+        with gr.Tab("Progressive Die Design"):
+            gr.Markdown("### Enter Dimensions for Progressive Die")
+            length = gr.Number(label="Length (mm)", value=100)
+            width = gr.Number(label="Width (mm)", value=50)
+            thickness = gr.Number(label="Thickness (mm)", value=10)
+            die_output = gr.Textbox(label="Die Output File")
+            visualization_output = gr.Image(label="3D Visualization")
+            die_button = gr.Button("Generate Die")
+            die_button.click(
+                lambda l, w, t: (generate_die(l, w, t), visualize_die(l, w, t)),
+                inputs=[length, width, thickness],
+                outputs=[die_output, visualization_output],
+            )
+
+        with gr.Tab("Stress Analysis"):
+            gr.Markdown("### Select Simulation Tool and Enter Parameters for Stress Analysis")
+            simulation_tool = gr.Dropdown(
+                choices=["Python", "ANSYS", "SolidWorks"],
+                label="Simulation Tool",
+                value="Python",
+            )
+            force = gr.Number(label="Force (N)", value=10000)
+            die_width = gr.Number(label="Width (m)", value=0.05)
+            die_height = gr.Number(label="Height (m)", value=0.01)
+            material_strength = gr.Number(label="Material Strength (MPa)", value=250)
+            safety_factor_output = gr.Textbox(label="Safety Factor or Simulation Result")
+            stress_chart = gr.Plot()
+            pdf_file = gr.File(label="Download Report (Python Only)")
+            stress_button = gr.Button("Analyze Stress")
+            stress_button.click(
+                stress_analysis_interface,
+                inputs=[force, die_width, die_height, material_strength, simulation_tool],
+                outputs=[safety_factor_output, stress_chart, pdf_file],
+            )
+
+        with gr.Tab("Tool Optimization"):
+            gr.Markdown("### Enter Machining Parameters for Tool Optimization")
+            speed = gr.Number(label="Cutting Speed (m/min)", value=100)
+            feed_rate = gr.Number(label="Feed Rate (mm/rev)", value=0.2)
+            depth_of_cut = gr.Number(label="Depth of Cut (mm)", value=1.0)
+            material = gr.Dropdown(choices=["Steel", "Aluminum", "Titanium"], label="Material", value="Steel")
+            optimization_results = gr.JSON(label="Optimization Results")
+            optimize_button = gr.Button("Optimize Tool")
+            optimize_button.click(
+                optimize_tool,
+                inputs=[speed, feed_rate, depth_of_cut, material],
+                outputs=optimization_results,
+            )
+
+# Launch the app
+app.launch()