Update app.py

app.py

@@ -1,177 +1,116 @@
 import gradio as gr
-import subprocess
-import numpy as np
-import pyvista as pv
-import matplotlib.pyplot as plt
-from ansys.mapdl.core import launch_mapdl
-from pycalculix import *
+from apdl_generator.apdl_plate import generate_plate_apdl
+from apdl_generator.apdl_beam import generate_beam_apdl
+from simulators.python_simulation import run_python_simulation
+from visualization import visualize_results, visualize_end_product
+import os
 
-# Simulation Workflow
-def simulation_workflow(use_case, simulator, thickness, length, width, hole_diameter, force, load):
-    print(f"Running simulation for use_case={use_case}, simulator={simulator}")
-    
-    # Handle optional parameters with default values
-    hole_diameter = hole_diameter if hole_diameter is not None else 0
-    force = force if force is not None else 0
-    load = load if load is not None else 0
+def simulation_workflow(tool_type, use_case, include_hole, include_force, include_load, thickness, length, width, hole_diameter, force, load, elastic_modulus):
+    """
+    Main simulation workflow that generates multiple formats for APDL, Python code, and simulation results.
+    """
 
-    # Generate APDL script based on user inputs
+    # Handle optional parameters
+    force = force if include_force else 0
+    load = load if include_load else 0
+
+    # Generate APDL script dynamically
     if use_case == "plate":
-        print("Generating APDL script for plate simulation...")
-        apdl_script = f"""
-/PREP7
-MP,EX,1,2E11       ! Elastic modulus
-MP,PRXY,1,0.3      ! Poisson's ratio
-BLOCK,0,{length},0,{width},0,{thickness}  ! Main block geometry
-CYLIND,0,{hole_diameter / 2},0,0,{thickness} ! Circular hole geometry
-VSUB,ALL           ! Subtract the hole from the block
-ET,1,SOLID185      ! Define element type as SOLID185
-ESIZE,5            ! Mesh element size
-VMESH,ALL          ! Mesh the entire volume
-NSEL,S,LOC,Z,0     ! Select bottom face nodes
-D,ALL,ALL          ! Apply constraints on selected nodes
-NSEL,S,LOC,Z,{thickness} ! Select top face nodes
-F,ALL,FY,-{force}  ! Apply vertical force
-/SOLU
-ANTYPE,STATIC      ! Static structural analysis
-SOLVE
-/POST1
-PRNSOL,S,EQV       ! Print equivalent stress results
-PRNSOL,U,SUM       ! Print total deformation results
-/EXIT
-"""
+        hole_diameter = hole_diameter if include_hole else 0
+        apdl_path = generate_plate_apdl(thickness, length, width, hole_diameter, force)
     elif use_case == "beam":
-        print("Generating APDL script for beam simulation...")
-        apdl_script = f"""
-/PREP7
-MP,EX,1,2E11       ! Elastic modulus
-MP,PRXY,1,0.3      ! Poisson's ratio
-BLOCK,0,{length},0,{width},0,{thickness}  ! Beam geometry
-ET,1,SOLID185      ! Define element type as SOLID185
-ESIZE,5            ! Mesh element size
-VMESH,ALL          ! Mesh the entire volume
-NSEL,S,LOC,X,0     ! Select nodes at one end of the beam
-D,ALL,ALL          ! Apply fixed constraints on one end
-NSEL,S,LOC,X,{length} ! Select nodes at the other end
-F,ALL,FY,-{load}   ! Apply uniform load
-/SOLU
-ANTYPE,STATIC      ! Static structural analysis
-SOLVE
-/POST1
-PRNSOL,S,EQV       ! Print equivalent stress results
-PRNSOL,U,SUM       ! Print total deformation results
-/EXIT
-"""
+        apdl_path = generate_beam_apdl(length, width, thickness, load)
     else:
-        print("Invalid use case selected.")
-        return "Invalid use case selected.", None, None
-    
-    # Save APDL script
-    with open("simulation_input.inp", "w") as file:
-        file.write(apdl_script)
-    
-    print(f"APDL script saved at: simulation_input.inp")
-    from time import sleep  # Add this at the top to handle sleep
+        return "Invalid use case selected.", None, None, None
 
-    print("Running ANSYS simulation...")
-    mapdl = launch_mapdl()
-    mapdl.input("simulation_input.inp")
-    sleep(5)  # Wait for 5 seconds to ensure results are calculated
+    # Read the generated APDL program
+    with open(apdl_path, "r") as file:
+        apdl_program = file.read()
 
-# Check if the values are being fetched correctly
-try:
-    max_stress = mapdl.get_value("NODE", 0, "S", "EQV")
-    deformation = mapdl.get_value("NODE", 0, "U", "SUM")
- print("Running ANSYS simulation...")
-mapdl = launch_mapdl()
-mapdl.input("simulation_input.inp")
-sleep(5)  # Wait for 5 seconds to ensure results are calculated
+    # Run simulation using Python-based solver
+    stress, deformation = run_python_simulation(apdl_path, use_case, thickness, length, width, force, load, elastic_modulus)
 
-# Check if the values are being fetched correctly
-try:
-    max_stress = mapdl.get_value("NODE", 0, "S", "EQV")
-    deformation = mapdl.get_value("NODE", 0, "U", "SUM")
-except Exception as e:  # <-- This line should have the same indentation as the try block
-    print(f"Error reading ANSYS results: {e}")
-    max_stress = deformation = 0  # Default values in case of error
+    # Explanation for negligible deformation
+    if deformation < 1e-6:
+        deformation_note = "\nNote: Deformation is negligible due to the high rigidity of the material."
+    else:
+        deformation_note = ""
 
-mapdl.exit()
-stress, deformation = max_stress, deformation
-print(f"Stress: {stress}, Deformation: {deformation}")
+    # Generate 2D simulation visualization
+    graph_path, _ = visualize_results("Python-Based Solver", length, width, thickness, stress, deformation)
+    
+    # Generate end-product visualization
+    product_path = visualize_end_product(use_case, length, width, thickness, deformation)
 
-    # Run the selected simulator
-if simulator == "PyCalculix":
-        print("Running PyCalculix simulation...")
-       model = Model("pycalculix_simulation")
-    model.set_units("mm")
-    part = Part("block", model)
-    part.make_box(0, length, 0, width, 0, thickness)
- if use_case == "plate":
-    part.cut_cylinder(0, hole_diameter / 2, 0, hole_diameter / 2, thickness)
-    model.make_step_static(force if force else load)
+    # Save Python code for simulation
+    python_code = f"""
+import numpy as np
 
-# Check if simulation is finished
-try:
-    model.run()
-    stress = model.results().max_stress()
-    deformation = model.results().max_displacement()
-except Exception as e:
-    print(f"Error reading PyCalculix results: {e}")
-    stress = deformation = 0  # Default values in case of error
+# Define material properties
+elastic_modulus = {elastic_modulus}
+thickness = {thickness}
+length = {length}
+width = {width}
 
-    print(f"PyCalculix Stress: {stress}, Deformation: {deformation}")()
-    elif simulator == "ANSYS":
-        print("Running ANSYS simulation...")
-        mapdl = launch_mapdl()
-        mapdl.input("simulation_input.inp")
-        max_stress = mapdl.get_value("NODE", 0, "S", "EQV")
-        deformation = mapdl.get_value("NODE", 0, "U", "SUM")
-        mapdl.exit()
-        stress, deformation = max_stress, deformation
-    else:
-        print("Invalid simulator selected.")
-        return "Invalid simulator selected.", None, None
+# Simulate stress and deformation (simplified example)
+def simulate():
+    stress = elastic_modulus * thickness * width / length  # Example formula
+    deformation = stress / elastic_modulus  # Simplified deformation
+    return stress, deformation
 
-    print(f"Simulation results - Stress: {stress}, Deformation: {deformation}")
-
-    # Visualize results (both 2D and 3D)
-    print("Visualizing results...")
-    fig, ax = plt.subplots()
-    ax.bar(["Stress", "Deformation"], [stress, deformation], color=["red", "blue"])
-    ax.set_title(f"Results ({simulator})")
-    plt.savefig("results_2d.png")
-    plt.close(fig)
+# Run the simulation
+stress, deformation = simulate()
+print(f"Stress: {stress:.2f} MPa")
+print(f"Deformation: {deformation:.6f} mm")
+"""
+    python_file_path = "simulation_code.py"
+    with open(python_file_path, "w") as f:
+        f.write(python_code)
 
-    # 3D Visualization
-    mesh = pv.Box(bounds=(0, length, 0, width, 0, thickness))
-    plotter = pv.Plotter(off_screen=True)
-    plotter.add_mesh(mesh, color="white", show_edges=True)
-    plotter.screenshot("results_3d.png")
+    # Generate results in different formats
+    results_text = f"{tool_type} Simulation\nStress: {stress:.2f} MPa\nDeformation: {deformation:.6f} mm{deformation_note}"
+    
+    # Save results to a .txt file
+    results_file_path = "simulation_results.txt"
+    with open(results_file_path, "w") as f:
+        f.write(results_text)
 
-    return f"Stress: {stress:.2f} MPa, Deformation: {deformation:.2f} mm", "results_2d.png", "results_3d.png"
+    return (
+        results_text,
+        graph_path,
+        product_path,
+        apdl_program,
+        python_file_path,  # Provide the path for Python code download
+        results_file_path  # Provide the path for results file download
+    )
 
-# Define Gradio interface
 interface = gr.Interface(
     fn=simulation_workflow,
     inputs=[
-        gr.Radio(["plate", "beam"], label="Select Use Case"),  # Choose plate or beam simulation
-        gr.Dropdown(["PyCalculix", "ANSYS"], label="Select Simulator"),  # Choose simulator
-        gr.Slider(10, 50, step=1, label="Thickness (mm)"),  # Input: Thickness
-        gr.Slider(100, 500, step=10, label="Length (mm)"),  # Input: Length
-        gr.Slider(50, 200, step=10, label="Width (mm)"),  # Input: Width
-        gr.Slider(5, 25, step=1, label="Hole Diameter (mm)", value=None),  # Input: Hole Diameter (for plate)
-        gr.Slider(1000, 10000, step=500, label="Force (N)", value=None),  # Input: Force (for plate)
-        gr.Slider(1000, 20000, step=1000, label="Load (N)", value=None)  # Input: Load (for beam)
+        gr.Radio(["Punch", "Die"], label="Select Tool Type"),
+        gr.Radio(["plate", "beam"], label="Select Use Case"),
+        gr.Checkbox(label="Include Hole for Plate Simulation"),  # Checkbox for optional hole
+        gr.Checkbox(label="Include Force"),  # Checkbox for optional force
+        gr.Checkbox(label="Include Load"),  # Checkbox for optional load
+        gr.Slider(10, 50, step=1, label="Thickness (mm)"),
+        gr.Slider(100, 500, step=10, label="Length (mm)"),
+        gr.Slider(50, 200, step=10, label="Width (mm)"),
+        gr.Slider(5, 25, step=1, label="Hole Diameter (mm)"),  # Controlled by "Include Hole"
+        gr.Slider(1000, 10000, step=500, label="Force (N)"),  # Controlled by "Include Force"
+        gr.Slider(1000, 20000, step=1000, label="Load (N)"),  # Controlled by "Include Load"
+        gr.Slider(5e10, 3e11, step=1e10, label="Elastic Modulus (Pa)")  # Slider for Elastic Modulus
     ],
     outputs=[
-        gr.Textbox(label="Simulation Results"),  # Output: Simulation text results
-        gr.Image(label="2D Results Visualization"),  # Output: 2D plot (stress and deformation)
-        gr.Image(label="3D Results Visualization")  # Output: 3D plot (stress distribution)
+        gr.Textbox(label="Simulation Results"),
+        gr.Image(label="2D Simulation Visualization"),
+        gr.Image(label="End Product Visualization"),
+        gr.Code(language="python", label="Generated APDL Program"),  # Python Code Output
+        gr.File(label="Download Python Simulation Code"),  # Allow file download of Python code
+        gr.File(label="Download Simulation Results")  # Allow file download of results
     ],
-    title="Unified Simulation Tool (PyCalculix and ANSYS)",
+    title="Punch and Die Simulation Tool with End Product Visualization and APDL",
     live=True
 )
 
 # Launch Gradio interface
-print("Launching Gradio interface...")
 interface.launch()