GNN implementation

Converters/DLR2h5.py

@@ -0,0 +1,148 @@
+#!/bin/env python
+#
+# Conversion from NLR7301 dataset to 
+# pyLOM v3.0 format
+#
+# 27/09/2024
+import os
+import glob
+import numpy as np
+import netCDF4 as NC4
+import matplotlib.pyplot as plt
+import torch
+from tqdm import tqdm
+
+import pyLOM
+from pyLOM.NN import Graph
+
+
+def process_edge_vectors(edge_index: np.ndarray, xyz: np.ndarray) -> np.ndarray:
+    """
+    Process edge vectors from Cartesian to polar coordinates.
+    """
+    edge_vecs = np.zeros((edge_index.shape[1], 2), dtype=np.float64)
+    for i, edge in enumerate(edge_index.T):
+        c_i = xyz[edge[0]]
+        c_j = xyz[edge[1]]
+        d_ij = c_j - c_i
+        edge_vecs[i, :] = [np.linalg.norm(d_ij), np.arctan2(d_ij[1], d_ij[0])]
+    return edge_vecs
+
+
+def convert_dataset(dset: str, datapath: str, npoints: int, ptable: pyLOM.PartitionTable) -> None:
+    print(f"[{dset.upper()}] Processing dataset")
+    folder = os.path.join(datapath, dset)
+    filelist = glob.glob(os.path.join(folder, '*'))
+
+    Mvec = [float(f.split('_')[-2][1:]) for f in filelist]
+    AoAvec = [float(f.split('_')[-1][3:]) for f in filelist]
+    case = [int(f.split('_')[-3][4:]) for f in filelist]
+
+    xyz = np.zeros((npoints, 2), np.double)
+    X = np.zeros((npoints, len(Mvec)), np.double)
+
+    for ii, (c, M, AoA) in enumerate(tqdm(zip(case, Mvec, AoAvec), total=len(Mvec), desc=f"[{dset}]")):
+        fname = os.path.join(folder, f"Snap_Case{c:04d}_M{M:.5f}_AoA{AoA:.5f}")
+        with NC4.Dataset(fname) as ncfile:
+            xyz[:, 0] = ncfile.variables['x'][:npoints]
+            xyz[:, 1] = ncfile.variables['z'][:npoints]
+            X[:, ii] = ncfile.variables['cp'][:npoints]
+
+    d = pyLOM.Dataset(
+        xyz=xyz,
+        ptable=ptable,
+        order=np.arange(npoints),
+        point=True,
+        vars={
+            'Mach': {'idim': 0, 'value': np.array(Mvec)},
+            'AoA': {'idim': 0, 'value': np.array(AoAvec)},
+        },
+        CP={'ndim': 1, 'value': X},
+    )
+    out_path = os.path.join(datapath, f"{dset.upper()}_converter.h5")
+    d.save(out_path, append=False)
+    print(f"[{dset.upper()}] Saved to {out_path}\n")
+    return d
+
+
+def create_graph(datapath: str, npoints: int) -> Graph:
+    sample_file = os.path.join(datapath, 'train', 'Snap_Case0000_M0.52500_AoA-0.33333')
+    with NC4.Dataset(sample_file) as ncfile:
+        xyz = np.zeros((npoints, 2), np.double)
+        xyz[:, 0] = ncfile.variables['x'][:npoints]
+        xyz[:, 1] = ncfile.variables['z'][:npoints]
+
+    normals = np.load(os.path.join(datapath, "normals.npz"))['normals']
+    wall_normals = np.load(os.path.join(datapath, "faceNormals.npz"))['faceNormals']
+    edge_index = torch.tensor(np.load(os.path.join(datapath, "edgesCOO.npz"))['edgesCOO'], dtype=torch.long)
+
+    x_dict = {
+        'xyz': torch.tensor(xyz, dtype=torch.float),
+        'normals': torch.tensor(normals, dtype=torch.float),
+    }
+    edge_vecs = process_edge_vectors(edge_index.numpy(), xyz)
+    edge_attr_dict = {
+        'edge_vecs': torch.tensor(edge_vecs, dtype=torch.float),
+        'wall_normals': torch.tensor(wall_normals, dtype=torch.float),
+    }
+
+    g = Graph(edge_index=edge_index, x_dict=x_dict, edge_attr_dict=edge_attr_dict)
+    print("Graph created.")
+    return g
+
+def plot_graph_cp(x: np.ndarray, z: np.ndarray, normals: np.ndarray, cp: np.ndarray, mach: float, aoa: float, savepath: os.path) -> None:
+    """ Plot the NLR7301 airfoil, along with surface normals and CP distribution for a given Mach and AoA.
+    Args:
+        x (np.ndarray): X-coordinates of the airfoil.
+        z (np.ndarray): Z-coordinates of the airfoil.
+        normals (np.ndarray): Surface normals at each point.
+        cp (np.ndarray): CP distribution at each point.
+        mach (float): Mach number for the case.
+        aoa (float): Angle of attack for the case.
+    """
+    plt.style.use('seaborn-v0_8-darkgrid')
+    plt.rcParams.update({'font.size': 14})
+    plt.figure(figsize=(10, 6))
+    plt.scatter(x, z, s=10)
+    plt.plot(x, cp, label='CP', color='blue')
+    plt.quiver(x, z, normals[:, 0], normals[:, 1], color='red', scale=10, label='Normals')
+    plt.title(f'CP Distribution (Mach: {mach}, AoA: {aoa})')
+    plt.xlabel('X')
+    plt.ylabel('Z')
+    plt.legend()
+    plt.grid()
+    plt.savefig(os.path.join(savepath,f"cp_plot_mach{mach}_aoa{aoa}.png"), dpi=300, bbox_inches='tight')
+    plt.show(block=True)
+
+
+def main():
+    datapath = "/home/p.yeste/CETACEO_DATA/nlr7301/"
+    datasets = ['test', 'train', 'val']
+    npoints = 597
+    ptable = pyLOM.PartitionTable.new(1, npoints, npoints)
+
+    for dset in datasets:
+        saved_dset = convert_dataset(dset, datapath, npoints, ptable)
+
+    g = create_graph(datapath, npoints)
+    for dset in datasets:
+        path = os.path.join(datapath, f"{dset.upper()}_converter.h5")
+        print(f"Appending graph to {path}")
+        g.save(path, mode='a')
+
+    # Select a snapshot from the dataset and plot the airfoil with CP distribution
+    i_case = 0  # First case for demonstration 
+    xyz = g.xyz
+    x = xyz[:, 0]
+    z = xyz[:, 1]
+    normals = g.normals
+    cp = saved_dset.fields['CP']['value'][:, i_case].flatten()
+    mach = saved_dset.get_variable('Mach')[i_case]
+    aoa = saved_dset.get_variable('AoA')[i_case]
+
+    plot_graph_cp(x, z, normals, cp, mach, aoa, savepath=datapath)
+
+
+
+if __name__ == "__main__":
+    main()

Examples/NN/configs/gns_config.yaml

@@ -0,0 +1,118 @@
+# config.yaml — pyLOM experiment configuration (DTO-friendly)
+
+experiment:
+  name: gns_nlr7301_baseline
+  description: "GNS model on NLR7301 airfoil dataset as described by ..."
+  version: 1.0
+  tags: [GNS, airfoil, baseline]
+  results_path: "../CETACEO_RESULTS/nlr7301/"
+  mode: optuna
+
+datasets:
+  train_ds: "../CETACEO_DATA/nlr7301/TRAIN_converter.h5"
+  val_ds:   "../CETACEO_DATA/nlr7301/VAL_converter.h5"
+  test_ds:  "../CETACEO_DATA/nlr7301/TEST_converter.h5"
+
+model:
+  # Kept outside the DTO on purpose (provenance, not a hyperparameter)
+  graph_path: "../CETACEO_DATA/nlr7301/TRAIN_converter.h5"
+  config:
+    # --- GNSModelConfig (pure DTO) ---
+    input_dim: 2
+    output_dim: 1
+    latent_dim: 16
+    hidden_size: 256
+    num_msg_passing_layers: 1
+    encoder_hidden_layers: 6
+    decoder_hidden_layers: 1
+    message_hidden_layers: 2
+    update_hidden_layers: 2
+    groupnorm_groups: 2
+    activation: "torch.nn.ELU"
+    p_dropout: 0.0
+    seed: 42
+    device: "cuda"
+
+training:
+  # --- GNSTrainingConfig (pure DTO) ---
+  epochs: 1000
+  lr: 6.5e-4
+  lr_gamma: 0.9954
+  lr_scheduler_step: 1
+  optimizer: "torch.optim.Adam"
+  scheduler: "torch.optim.lr_scheduler.StepLR"
+  loss_fn: "torch.nn.MSELoss"
+  print_every: 25
+
+  dataloader:
+    batch_size: 15
+    shuffle: true
+    num_workers: 4
+    pin_memory: true
+
+  subgraph_loader:
+    batch_size: 32
+    shuffle: true
+    input_nodes: null
+
+optuna:
+  study:
+    n_trials: 100
+    direction: minimize
+    pruner:
+      type: optuna.pruners.MedianPruner
+      n_startup_trials: 15
+      n_warmup_steps: 100
+    sampler:
+      type: optuna.samplers.TPESampler
+      multivariate: true
+    seed: 42
+
+  # Search space (NOT DTOs) — these stay as distributions for sampling.
+  optimization_params:
+    model:
+      graph_path: "../CETACEO_DATA/nlr7301/TRAIN_converter.h5"
+      config:
+        # Everything here is a search space for sampling -> returns a dict that
+        # we feed to dacite.from_dict(GNSModelConfig, ...)
+        input_dim: 2
+        output_dim: 1
+        latent_dim: { type: int, low: 8, high: 64, step: 2 }
+        hidden_size: { type: int, low: 64, high: 512 }
+        num_msg_passing_layers: { type: int, low: 1, high: 5 }
+        encoder_hidden_layers: { type: int, low: 1, high: 4 }
+        decoder_hidden_layers: { type: int, low: 1, high: 4 }
+        message_hidden_layers: { type: int, low: 1, high: 4 }
+        update_hidden_layers: { type: int, low: 1, high: 4 }
+        groupnorm_groups: 2
+        activation:
+          type: categorical
+          choices:
+            - "torch.nn.ELU"
+            - "torch.nn.ReLU"
+            - "torch.nn.LeakyReLU"
+        p_dropout: { type: float, low: 0.0, high: 0.5 }
+        seed: 42
+        device: "cuda"
+
+    training:
+      # Search space for GNSTrainingConfig (NOT a DTO here)
+      loss_fn:    "torch.nn.MSELoss"
+      optimizer:  "torch.optim.Adam"
+      scheduler:  "torch.optim.lr_scheduler.StepLR"
+      epochs: 1000
+      lr: { type: float, low: 1.0e-5, high: 1.0e-3, log: true }
+      lr_gamma: { type: float, low: 0.9, high: 0.999 }
+      lr_scheduler_step: { type: int, low: 1, high: 10 }
+      print_every: null
+
+      dataloader:
+        batch_size: { type: int, low: 8, high: 64 }
+        shuffle: true
+        num_workers: 4
+        pin_memory: true
+
+      subgraph_loader:
+        batch_size: { type: int, low: 1, high: 597 }
+        shuffle: true
+        input_nodes: null