[mesh motion] RBF convergence tests added

Author: tmaric

src/displacementSmartSimMotionSolver/pytorchApproximationModels/Actual-Stream-Function.png

@@ -3,6 +3,8 @@
 import torch
 import torch.nn as nn
 import torch.optim as optim
+import csv 
+import os
 
 from rbf_network import WendlandLinearNetwork
 
@@ -21,7 +23,7 @@ def compute_velocity(x, y, psi_values):
     v = -dx  # v = -∂ψ/∂x
     return u, v
 
-def visualize_psi(x, y, psi_values, title="Stream Function", centers=None):
+def visualize_psi(x, y, psi_values, centers, title="Stream Function"):
     plt.figure(figsize=(6, 6))
     plt.contourf(x, y, psi_values, levels=20, cmap='viridis')
     plt.colorbar(label='ψ')
@@ -30,24 +32,23 @@ def visualize_psi(x, y, psi_values, title="Stream Function", centers=None):
     plt.ylabel('y')
     plt.grid()
 
-    # Plot centers if provided
-    if centers is not None:
-        centers_np = centers.numpy()  # Convert from torch tensor to numpy
-        plt.scatter(centers_np[:, 0], centers_np[:, 1], color='white', marker='x', s=100, linewidths=2, label='Centers')
-        plt.legend()
+    # Plot centers 
+    centers_np = centers.numpy()  # Convert from torch tensor to numpy
+    plt.scatter(centers_np[:, 0], centers_np[:, 1], color='white', marker='x', s=100, linewidths=2, label='Centers')
+    plt.legend()
 
     fig_name = title.replace(" ", "-")
-    plt.savefig(f"{fig_name}.png", dpi=200)
+    plt.savefig(f"{fig_name}-num_centers-{len(centers)}.png", dpi=200)
 
-def visualize_velocity_field(x, y, u, v, title="Velocity Field"):
+def visualize_velocity_field(x, y, u, v, num_centers, title="Velocity Field"):
     plt.figure(figsize=(6, 6))
     plt.quiver(x, y, u, v)
     plt.title(title)
     plt.xlabel('x')
     plt.ylabel('y')
     plt.grid()
     fig_name = title.replace(" ", "-")
-    plt.savefig(f"{fig_name}.png", dpi=200)
+    plt.savefig(f"{fig_name}-num_centers{num_centers}.png", dpi=200)
 
 def generate_centers(num_centers):
     """
@@ -59,9 +60,8 @@ def generate_centers(num_centers):
     centers = np.vstack([X.ravel(), Y.ravel()]).T
     return torch.tensor(centers, dtype=torch.float32)
 
-def main():
+def main(num_points):
     # Generate training data
-    num_points = 10
     x = np.linspace(0, 1, num_points)
     y = np.linspace(0, 1, num_points)
     X, Y = np.meshgrid(x, y)
@@ -76,7 +76,7 @@ def main():
     # centers = generate_centers(32).clone().detach()
     centers = x_train 
     print(centers.shape)
-    r_max = 0.1 
+    r_max = 3.0 / num_points 
     smoothness = 4  # C^4 smoothness
 
     # Initialize model
@@ -104,9 +104,9 @@ def main():
             print(f'Epoch [{epoch + 1}/{epochs}], Loss: {loss.item():.14f}')
 
     # Generate validation data
-    num_points = 100
-    x_val = np.linspace(0, 1, num_points)
-    y_val = np.linspace(0, 1, num_points)
+    num_points_val = 100
+    x_val = np.linspace(0, 1, num_points_val)
+    y_val = np.linspace(0, 1, num_points_val)
     X_val, Y_val = np.meshgrid(x_val, y_val)
     xy_val = np.column_stack((X_val.flatten(), Y_val.flatten()))
     psi_val = psi(X_val, Y_val)
@@ -122,19 +122,46 @@ def main():
     #psi_actual = psi(X_val, Y_val)
 
     # Visualize actual and predicted stream functions
-    visualize_psi(X_val, Y_val, psi_val, title="Actual Stream Function")
-    visualize_psi(X_val, Y_val, psi_pred, title="Predicted Stream Function")
+    visualize_psi(X_val, Y_val, psi_val, centers, title="Actual Stream Function")
+    visualize_psi(X_val, Y_val, psi_pred, centers, title="Predicted Stream Function")
 
-    visualize_psi(X_val, Y_val, np.abs(psi_pred - psi_val), 
-                  title="Stream Function Approximation Error", 
-                  centers=centers)
+    err_val = np.abs(psi_pred - psi_val)
+    visualize_psi(X_val, Y_val, err_val, centers,
+                  title="Stream Function Approximation Error")
+
+    # Define the filename
+    csv_filename = "stream_function_validation.csv"
+
+    # Define the header and the values to be appended
+    header = ["num_points", "point_dist", "r_max", "err_validation"]
+    data = [num_points, 1.0 / num_points, r_max, np.mean(err_val)]
+
+    # Check if file exists
+    file_exists = os.path.isfile(csv_filename)
+
+    # Open file in append mode
+    with open(csv_filename, mode='a', newline='') as file:
+        writer = csv.writer(file)
+
+        # If the file doesn't exist, write the header first
+        if not file_exists:
+            writer.writerow(header)
+
+        # Append the data row
+        writer.writerow(data)
+
+    print(f"Appended to {csv_filename}: {data}")
 
     # Compute and visualize actual and predicted velocity fields
     u_val, v_val = compute_velocity(X_val, Y_val, psi_val)
-    visualize_velocity_field(X_val, Y_val, u_val, v_val, title="Actual Velocity Field")
+    visualize_velocity_field(X_val, Y_val, u_val, v_val, num_points,
+                             title="Actual Velocity Field")
 
     u_pred, v_pred = compute_velocity(X_val, Y_val, psi_pred)
-    visualize_velocity_field(X_val, Y_val, u_pred, v_pred, title="Predicted Velocity Field")
+    visualize_velocity_field(X_val, Y_val, u_pred, v_pred, num_points,
+                             title="Predicted Velocity Field")
 
 if __name__ == "__main__":
-    main()
+    main(num_points=4)
+    main(num_points=8)
+    main(num_points=16)