Update app.py

app.py

@@ -1,6 +1,9 @@
+import dolfinx
+from dolfinx import mesh, fem
+from mpi4py import MPI
+import numpy as np
 import gradio as gr
 import pandas as pd
-import numpy as np
 import random
 import time
 import concurrent.futures
@@ -11,20 +14,6 @@ from sympy import symbols, Eq, solve
 from sympy.parsing.sympy_parser import parse_expr
 from sklearn.feature_extraction.text import CountVectorizer
 from sklearn.ensemble import RandomForestClassifier
-from fenics import (
-    Mesh,
-    FunctionSpace,
-    TrialFunction,
-    TestFunction,
-    dot,
-    grad,
-    dx,
-    solve,
-    Function,
-    Constant,
-    DirichletBC
-)
-  # Ensure FEniCS is installed
 
 ########################################
 # 1. Domain Assumption Matrix
@@ -99,40 +88,53 @@ class ConfidenceIndex:
         return self.index
 
 ########################################
-# 3. HPC PDE concurrency (FEniCS)
+# 3. HPC PDE concurrency (FEniCSx)
 ########################################
 
 class HPCSolver:
     """
-    Solves PDEs using FEniCS and generates visualizations.
+    Solves PDEs using FEniCSx and generates visualizations.
     """
     def solve_pde(self, problem_type: str, mesh_size: int) -> str:
         """
-        Solve a PDE using FEniCS and save a plot.
+        Solve a PDE using FEniCSx and save a plot.
         Supported problem_type: 'Poisson'
         """
         if problem_type == "Poisson":
             try:
-                mesh = UnitSquareMesh(mesh_size, mesh_size)
-                V = FunctionSpace(mesh, "P", 1)
-
-                u = TrialFunction(V)
-                v = TestFunction(V)
-                f = Constant(-6.0)
-
-                a = dot(grad(u), grad(v)) * dx
-                L = f * v * dx
-
-                u_sol = Function(V)
-                solve(a == L, u_sol)
-
-                plt.figure()
-                plot(u_sol, title="Poisson Solution")
-                plt.colorbar()
-                plt.savefig("poisson_solution.png")
-                plt.close()
-
-                return "Poisson PDE solved. Visualization saved as 'poisson_solution.png'."
+                # Create mesh
+                domain = mesh.create_unit_square(MPI.COMM_WORLD, mesh_size, mesh_size)
+                
+                # Define function space
+                V = fem.FunctionSpace(domain, ("Lagrange", 1))
+                
+                # Define boundary condition
+                u_D = fem.Function(V)
+                with u_D.vector.localForm() as loc:
+                    loc.set(0.0)
+                
+                def boundary(x):
+                    return np.full(x.shape[1], True)
+                
+                bc = fem.dirichletbc(u_D, fem.locate_dofs_geometrical(V, boundary))
+                
+                # Define variational problem
+                u = fem.TrialFunction(V)
+                v = fem.TestFunction(V)
+                f = fem.Constant(domain, -6.0)
+                a = fem.form(fem.dot(fem.grad(u), fem.grad(v)) * fem.dx)
+                L = fem.form(f * v * fem.dx)
+                
+                # Compute solution
+                u_sol = fem.Function(V)
+                fem.petsc.solve(a == L, u_sol, bc)
+                
+                # Plot solution
+                with dolfinx.io.XDMFFile(domain.comm, "poisson_solution.xdmf", "w") as xdmf:
+                    xdmf.write_mesh(domain)
+                    xdmf.write_function(u_sol)
+                
+                return "Poisson PDE solved. Visualization saved as 'poisson_solution.xdmf'."
             except Exception as e:
                 return f"Error solving Poisson PDE: {e}"
         else:
@@ -430,7 +432,7 @@ def build_interface():
             chat_btn.click(fn=chat_func, inputs=[chat_input], outputs=[chat_output])
 
         with gr.Tab("HPC PDE Solvers"):
-            gr.Markdown("**Simulate solving PDEs using FEniCS with concurrency support.**")
+            gr.Markdown("**Simulate solving PDEs using FEniCSx with concurrency support.**")
             with gr.Row():
                 problem_type = gr.Dropdown(choices=["Poisson"], label="PDE Type", value="Poisson")
                 mesh_size = gr.Slider(label="Mesh Size", minimum=10, maximum=100, step=10, value=32)