Update app.py

app.py

@@ -1,193 +1,102 @@
-# Import necessary libraries
-import cadquery as cq
-import numpy as np
-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
-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):
-    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:
-        tool_life = 1000 / (speed * feed_rate * depth_of_cut)
-        recommended_speed = 0.8 * speed
-        recommended_feed_rate = 0.9 * feed_rate
-
-        return {
-            "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)
-        }
-    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":
-        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":
-        result = run_ansys_simulation(force, die_width, die_height, material_strength)
-        return result, None, None
-    elif simulation_tool == "SolidWorks":
-        result = solidworks_stress_analysis(force, die_width, die_height, material_strength)
-        return result, None, None
-    else:
-        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"):
-            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"):
-            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"):
-            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,
-            )
-app.launch()
+import pandas as pd
+import numpy as np
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from ansys.mapdl.core import launch_mapdl
+
+# Load AI models
+def load_models():
+    # Validation model
+    validation_model = RandomForestClassifier()
+    validation_model.fit([[150, 0.1], [200, 0.2], [250, 0.3], [300, 0.4], [350, 0.5]], [1, 1, 0, 0, 0])
+
+    # Optimization models
+    stress_model = RandomForestRegressor()
+    deformation_model = RandomForestRegressor()
+    X = np.column_stack((np.linspace(10, 25, 4), np.linspace(5000, 12000, 4)))
+    stress_model.fit(X, [300, 250, 200, 150])
+    deformation_model.fit(X, [0.5, 0.4, 0.3, 0.2])
+
+    return validation_model, stress_model, deformation_model
+
+validation_model, stress_model, deformation_model = load_models()
+
+# ANSYS MAPDL simulation function
+def run_simulation(thickness, force):
+    mapdl = launch_mapdl()  # Start MAPDL instance
+    mapdl.clear()
+    mapdl.prep7()
+    
+    # Set up material and geometry
+    mapdl.mp("EX", 1, 2e11)
+    mapdl.mp("PRXY", 1, 0.3)
+    mapdl.block(0, 100, 0, 50, 0, thickness)
+    mapdl.cylind(0, 5, 20, 25, 0, thickness)
+    mapdl.vsubtract("ALL")
+    mapdl.et(1, "SOLID185")
+    mapdl.esize(5)
+    mapdl.vmesh("ALL")
+    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()
+
+    # Extract results
+    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
+
+# Gradio function
+def simulate_and_optimize(thickness, force):
+    # Run ANSYS simulation
+    max_stress, max_deformation = run_simulation(thickness, force)
+
+    # AI validation
+    validation_result = validation_model.predict([[max_stress, max_deformation]])[0]
+
+    # AI optimization
+    thickness_values = np.linspace(10, 30, 5)
+    force_values = np.linspace(5000, 15000, 5)
+    results = []
+    for t in thickness_values:
+        for f in force_values:
+            stress = stress_model.predict([[t, f]])[0]
+            deformation = deformation_model.predict([[t, f]])[0]
+            results.append({"Thickness": t, "Force": f, "Stress": stress, "Deformation": deformation})
+    optimization_df = pd.DataFrame(results)
+
+    return {
+        "Simulation Results": {
+            "Max Stress": max_stress,
+            "Max Deformation": max_deformation,
+            "Validation Status": "Pass" if validation_result else "Fail"
+        },
+        "Optimization Suggestions": optimization_df.to_dict(orient="records")
+    }
+
+# Gradio Interface
+interface = gr.Interface(
+    fn=simulate_and_optimize,
+    inputs=[
+        gr.Number(label="Thickness (mm)", value=20),
+        gr.Number(label="Force (N)", value=5000),
+    ],
+    outputs=[
+        gr.JSON(label="Simulation Results"),
+        gr.JSON(label="Optimization Suggestions"),
+    ],
+    title="AI-Driven Press Tool Simulation & Optimization",
+    description="Automates the design, simulation, and optimization of press tools using AI and ANSYS."
+)
+
+if __name__ == "__main__":
+    interface.launch()