Gnn

integration_tests/integration_test.py

@@ -76,7 +76,8 @@ def test_1(self):
                 "pickle": True,
                 "pickle_nodes": "all",
                 "VTK": False,
-                "VTK_binary": True}
+                "VTK_binary": True,
+                "write_GNN": False}
 
         x = 0.1
         y = 20
@@ -124,7 +125,8 @@ def test_2(self):
                 "pickle": True,
                 "pickle_nodes": "all",
                 "VTK": False,
-                "VTK_binary": True}
+                "VTK_binary": True,
+                "write_GNN": False}
 
         x = 0.1
         y = 20
@@ -186,7 +188,8 @@ def test_3(self):
                 "pickle": True,
                 "pickle_nodes": "all",
                 "VTK": False,
-                "VTK_binary": True}
+                "VTK_binary": True,
+                "write_GNN": False}
 
         x = 0.1
         y = 20
@@ -232,7 +235,8 @@ def test_4(self):
                 "pickle": True,
                 "pickle_nodes": "all",
                 "VTK": False,
-                "VTK_binary": True}
+                "VTK_binary": True,
+                "write_GNN": False}
 
         x = 0.1
         y = 20
@@ -278,7 +282,8 @@ def test_vtk(self):
                 "pickle": True,
                 "pickle_nodes": "all",
                 "VTK": True,
-                "VTK_binary": False}
+                "VTK_binary": False,
+                "write_GNN": False}
 
         x = 0.1
         y = 20
@@ -351,7 +356,8 @@ def test_1(self):
                 "pickle_nodes": "all",
                 "output_interval": 1,
                 "VTK": False,
-                "VTK_binary": True}
+                "VTK_binary": True,
+                "write_GNN": False}
 
         # boundary conditions
         x = 1
@@ -394,7 +400,8 @@ def test_2(self):
                 "pickle_nodes": "all",
                 "output_interval": 1,
                 "VTK": False,
-                "VTK_binary": True}
+                "VTK_binary": True,
+                "write_GNN": False}
 
         # boundary conditions
         x = 1
@@ -450,7 +457,8 @@ def test_vtk(self):
                 "pickle_nodes": "all",
                 "output_interval": 1,
                 "VTK": True,
-                "VTK_binary": False}
+                "VTK_binary": False,
+                "write_GNN": False}
 
         # boundary conditions
         x = 1
@@ -517,7 +525,8 @@ def test_moving_load(self):
                 "pickle": True,
                 "pickle_nodes": "all",
                 "VTK": True,
-                "VTK_binary": True}
+                "VTK_binary": True,
+                "write_GNN": False}
 
         x = 10
         y = 10
@@ -576,7 +585,8 @@ def test_moving_load_plane(self):
                 "pickle": True,
                 "pickle_nodes": "all",
                 "VTK": False,
-                "VTK_binary": True}
+                "VTK_binary": True,
+                "write_GNN": False}
 
         x = 10
         y = 10
@@ -649,6 +659,7 @@ def test_with_rose(self):
                 "pickle_nodes": "all",
                 "VTK": False,
                 "VTK_binary": True,
+                "write_GNN": False,
                 "output_interval": 2}
 
         # boundary conditions

integration_tests/test_benchmark_set_2.py

@@ -42,6 +42,7 @@ def test_heaviside_load_1d_column(self, element_type, loading_nodes, n_dim):
                 "pickle_nodes": [3],
                 "VTK": False,
                 "VTK_binary": True,
+                "write_GNN": False,
                 "output_interval": 10
                 }
 
@@ -98,7 +99,7 @@ def test_heaviside_load_1d_column(self, element_type, loading_nodes, n_dim):
 
         # remove output directory
         shutil.rmtree(output_dir)
-        
+
         # compare velocity with analytical solution if CHECK_RESULTS is true
         if CHECK_RESULT:
 

requirements.txt

@@ -4,6 +4,7 @@ scipy==1.16.0
 tqdm==4.67.1
 gstools==1.7.0
 shapely==2.1.1
+h5py==3.15.1
 pytest==8.4.1
 pytest-cov==6.2.1
 tox==4.27.0

run_scatter.py

@@ -13,15 +13,16 @@
             "absorbing_BC_stiff": 1e3,
             "output_interval": 1,
             "pickle": True,
-            "pickle_nodes": "all",
+            "pickle_nodes": ["28"],
             "VTK": False,
             "VTK_binary": True,
+            "write_GNN": True,
             }
 
     x = 1
     y = 10
     z = -1
-    BC = {"bottom": ["020", [[0, 0, 0], [x, 0, 0], [0, 0, z], [x, 0, z]]],
+    BC = {"bottom": ["010", [[0, 0, 0], [x, 0, 0], [0, 0, z], [x, 0, z]]],
           "left": ["100", [[0, 0, 0], [0, 0, z], [0, y, 0], [0, y, z]]],
           "right": ["100", [[x, 0, 0], [x, 0, z], [x, y, 0], [x, y, z]]],
           "front": ["001", [[0, 0, 0], [z, 0, 0], [0, y, 0], [x, y, 0]]],
@@ -31,10 +32,8 @@
     # material dictionary: rho, E, v
     mat = {"solid": {"density": 1500,
                      "Young": 30e6,
-                     "poisson": 0.2},
-           "bottom": {"density": 1500.0,
-                      "Young": 30e6,
-                      "poisson": 0.2}}
+                     "poisson": 0.2}
+          }
 
     load = {"force": [0, -1000, 0],
             "node": [3, 4, 7, 8],
@@ -56,9 +55,9 @@
                 }
 
     # run scatter
-    scatter(r"./mesh/column.msh", "./results_abs_newmark", mat, BC, sett, load, time_step=0.05e-4,
+    scatter(r"./mesh/column.msh", "./results_abs_newmark_explicit", mat, BC, sett, load, time_step=0.05e-4,
             solver=NewmarkExplicit(linear_solver=SparseDirectSolverLU(),
                                    preconditioner=None))
-    scatter(r"./mesh/column.msh", "./results_abs_bathe", mat, BC, sett, load, time_step=0.05e-4,
-            solver=NewmarkImplicitForce(linear_solver=CGSolver(),
-                                        preconditioner=JacobiPreconditioner()))
+    scatter(r"./mesh/column.msh", "./results_abs_newmark_implicit", mat, BC, sett, load, time_step=0.05e-4,
+            solver=NewmarkImplicitForce(linear_solver=SparseDirectSolverLU(),
+                                        preconditioner=None))

run_scatter_gnn.py

@@ -0,0 +1,76 @@
+from pathlib import Path
+import numpy as np
+import create_geo_file
+from scatter.scatter import scatter
+from solvers.newmark_solver import NewmarkExplicit
+from solvers.preconditioners import JacobiPreconditioner
+from solvers.linear_equations_solvers import CGSolver
+
+
+if __name__ == "__main__":
+    # computational settings
+    sett = {"gamma": 0.5,
+            "beta": 0.25,
+            "int_order": 2,
+            "damping": [1, 0.01, 80, 0.01],
+            "absorbing_BC": [1, 1],
+            "absorbing_BC_stiff": 1e3,
+            "pickle": True,
+            "pickle_nodes": "4",
+            "VTK": False,
+            "VTK_binary": True,
+            "output_interval": 1,
+            "write_GNN": True,
+            }
+
+
+    for i in range(50):
+        np.random.seed(i)
+        element_size = np.round(np.random.uniform(0.2, 1), 2)
+        model_size = int(np.random.uniform(5, 20))
+        model_depth = int(np.random.uniform(5, 20))
+        aniso_z = int(np.random.uniform(1, 10))
+        theta = np.random.uniform(1, 10)
+
+        x = model_size
+        y = model_depth
+        z = model_size
+
+        BC = {"bottom": ["010", [[0, 0, 0], [x, 0, 0], [0, 0, z], [x, 0, z]]],
+            "left": ["100", [[0, 0, 0], [0, 0, z], [0, y, 0], [0, y, z]]],
+            "right": ["200", [[x, 0, 0], [x, 0, z], [x, y, 0], [x, y, z]]],
+            "front": ["001", [[0, 0, 0], [z, 0, 0], [0, y, 0], [x, y, 0]]],
+            "back": ["002", [[0, 0, z], [x, 0, z], [0, y, z], [x, y, z]]],
+            }
+
+        create_geo_file.main(x, y, z, element_size, Path(f"./GNN/run_{i}"), name=f"brick")
+
+        # material dictionary: rho, E, v
+        mat = {"solid": {"density": 1500,
+                        "Young": 30e6,
+                        "poisson": 0.2},
+                }
+
+        load = {"force": [0, -1e6, 0],
+                "node": [4],
+                "time": 0.4,
+                "type": "heaviside",  # pulse or heaviside or moving
+                "speed": 80}  # only for moving
+
+        # Random field properties
+        RF_props = {"number_realisations": 1,
+                    "element_size": element_size,
+                    "theta": theta,
+                    "seed_number": i,
+                    "material": "solid",
+                    "key_material": "Young",
+                    "std_value": 50e6,
+                    "aniso_x": 1,
+                    "aniso_z": aniso_z,
+                    "model_name": "Gaussian",
+                    }
+
+        # run scatter
+        scatter(Path(f"./GNN/run_{i}") / "brick.msh", Path(f"GNN/run_{i}"), mat, BC, sett, load, time_step=5e-4,
+                solver=NewmarkExplicit(linear_solver=CGSolver(),
+                                        preconditioner=JacobiPreconditioner()), random_props=RF_props)

run_scatter_rose_2D.py

@@ -1,4 +1,6 @@
-from solvers.newmark_solver import NewmarkImplicitForce
+from solvers.newmark_solver import NewmarkImplicitForceGPU
+from solvers.preconditioners import JacobiPreconditionerGPU
+from solvers.linear_equations_solvers import CGSolverGPU
 
 from scatter.scatter import scatter
 from scatter.rose_utils import RoseUtils
@@ -55,7 +57,8 @@
     rose_data["time_integration"]["n_t_ini"] = round(rose_data["time_integration"]["tot_ini_time"] / time_step)
     rose_data["time_integration"]["n_t_calc"] = round(rose_data["time_integration"]["tot_calc_time"] / time_step)
 
-    coupled_model = RoseUtils.assign_data_to_coupled_model(rose_data, solver=NewmarkImplicitForce())
+    coupled_model = RoseUtils.assign_data_to_coupled_model(rose_data, solver=NewmarkImplicitForceGPU(linear_solver=CGSolverGPU(),
+                                                                   preconditioner=JacobiPreconditionerGPU()))
 
     load = {"model": coupled_model,
             "type": "rose",
@@ -76,4 +79,6 @@
 
     # run scatter
     scatter(r"./mesh/rose_2D_side.msh", "./results_rose_2D_side", mat, BC, sett, load, time_step=time_step,
-            random_props=RF_props, solver=NewmarkImplicitForce())
+            random_props=RF_props, solver=NewmarkImplicitForceGPU(linear_solver=CGSolverGPU(),
+                                                                   preconditioner=JacobiPreconditionerGPU()))
+