{ "cells": [ { "cell_type": "markdown", "id": "5ac68bf1", "metadata": {}, "source": [ "# Shallow Recurrent Decoders (SHRED) for Parametric State Estimation\n", "This notebook demostrates how to combine the *pyforce* package with the [pySHRED](https://github.com/PyShred-Dev/PyShred) and our vanilla implemtation in [NuSHRED](https://github.com/ERMETE-Lab/NuSHRED).\n", "\n", "This ML technique is based on the work by [Williams et al. (2024)](https://royalsocietypublishing.org/rspa/article/480/2298/20240054/66770/Sensing-with-shallow-recurrent-decoder), and the extension to parametric problems by [Tomasetto et al. (2025)](https://www.nature.com/articles/s41467-025-65126-y) and [Riva et al. (2025)](https://arxiv.org/abs/2503.08904). \n", "\n", "Two versions of SHRED are available: the official PySHRED package, and the in-house NuSHRED code. The former can be installed via pip:\n", "\n", "```bash\n", "pip install pyshred\n", "```\n", "The latter can be cloned from the GitHub repository and the code can be used directly:\n", "\n", "```bash\n", "git clone https://github.com/ERMETE-Lab/NuSHRED.git\n", "```\n", "\n", "In this notebook, we will consider a parametric flow over cylinder problem, from CFDBench [Luo et al. (2024)](https://arxiv.org/abs/2310.05963): the inlet boundary is parametrized with respect to its intensity, from 0.1 m/s to 1.0 m/s." ] }, { "cell_type": "markdown", "id": "588b26cf", "metadata": {}, "source": [ "At first, let us load the raw snapshots, downloaded from [the benchmark](https://huggingface.co/datasets/chen-yingfa/CFDBench/blob/main/cylinder/bc.zip) - the zenodo folder only contains the first 10 parameters, instead of the full 50." ] }, { "cell_type": "code", "execution_count": 27, "id": "bddf1cff", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of snapshots: 10, Number of time steps: 1000, Grid size: 64 x 64\n" ] } ], "source": [ "import numpy as np\n", "import os\n", "from IPython.display import clear_output\n", "\n", "folder_to_save = '../Datasets/CFDBenchFlowCyl'\n", "\n", "id_cases = [f for f in os.listdir(folder_to_save+'/') if os.path.isdir(os.path.join(folder_to_save+'/', f))]\n", "id_cases.sort()\n", "\n", "snap_data = list()\n", "for case_i in range(1, len(id_cases)):\n", " snap_data.append(dict())\n", "\n", " snap_data[case_i-1]['u'] = np.load(folder_to_save + '/' + id_cases[case_i] + '/u.npy')\n", " snap_data[case_i-1]['v'] = np.load(folder_to_save + '/' + id_cases[case_i] + '/v.npy')\n", "\n", "Nt, Nhx, Nhy = snap_data[0]['u'].shape\n", "Ns = len(snap_data)\n", "\n", "var_names = ['u', 'v']\n", "\n", "print(f'Number of snapshots: {Ns}, Number of time steps: {Nt}, Grid size: {Nhx} x {Nhy}')" ] }, { "cell_type": "markdown", "id": "fa72c541", "metadata": {}, "source": [ "From the benchmark description, the geometry is generated in the pyvista format." ] }, { "cell_type": "code", "execution_count": 28, "id": "1f7c52ea", "metadata": {}, "outputs": [], "source": [ "radius = 0.01\n", "length = 0.16 + 0.06 + 2*radius\n", "height = 2 * 0.06 + 2*radius\n", "\n", "import pyvista as pv\n", "\n", "x = np.linspace(0, length, Nhx)\n", "y = np.linspace(0, height, Nhy)\n", "X, Y = np.meshgrid(x, y, indexing=\"ij\")\n", "points = np.c_[X.ravel(), Y.ravel(), np.zeros_like(X.ravel())]\n", "\n", "# --- Build connectivity for quadrilateral cells ---\n", "# Each quad has 4 vertices, and we store them in the format:\n", "# [4, id0, id1, id2, id3] for each cell\n", "cells = []\n", "for i in range(Nhx - 1):\n", " for j in range(Nhy - 1):\n", " p0 = i * Nhy + j\n", " p1 = p0 + 1\n", " p2 = p0 + Nhy + 1\n", " p3 = p0 + Nhy\n", " cells.append([4, p0, p1, p2, p3])\n", "\n", "cells = np.array(cells, dtype=np.int64).ravel()\n", "\n", "# Cell types: VTK_QUAD = 9\n", "celltypes = np.full((Nhx - 1) * (Nhy - 1), 9, dtype=np.uint8)\n", "\n", "# Plotting the grid\n", "grid = pv.UnstructuredGrid(cells, celltypes, points)\n", "nodes = grid.points[:, :2] # Extract only x and y coordinates" ] }, { "cell_type": "markdown", "id": "2d97d45b", "metadata": {}, "source": [ "The snapshots loaded before are the $x$ and $y$ components of the velocity field, parameterised with respect to the inlet velocity. We are going to store them in numpy arrays of the following shape $N_{params}\\times N_t\\times \\mathcal{N}_h$, where $N_{params}$ is the number of parameters (inlet velocities), $N_t$ is the number of time steps, and $\\mathcal{N}_h$ is the number of spatial degrees of freedom." ] }, { "cell_type": "code", "execution_count": 29, "id": "5ba9388b", "metadata": {}, "outputs": [], "source": [ "snapshots_np = {var_name: np.zeros((Ns, Nt, Nhx * Nhy)) for var_name in var_names}\n", "\n", "for i in range(Ns):\n", " for var_name in var_names:\n", " for tt in range(Nt):\n", " snapshots_np[var_name][i, tt, :] = snap_data[i][var_name][tt].ravel(order='F')\n", "\n", "Nh = Nhx * Nhy\n", "\n", "from matplotlib import patches\n", "def create_circle(ax):\n", " radius = 0.01\n", " center = ((0.06+radius/2), (0.06+radius))\n", " circle = patches.Ellipse(center, 2*radius, 2*radius, edgecolor='black', facecolor='white', linewidth=2)\n", " ax.add_patch(circle)" ] }, { "cell_type": "markdown", "id": "2a2cd7ef", "metadata": {}, "source": [ "## pySHRED implementation\n", "We first demonstrate the pySHRED implementation using POD-based compressive training, either directly from the package or adopted the functionalities of *pyforce*." ] }, { "cell_type": "markdown", "id": "35ef0bc6", "metadata": {}, "source": [ "### Directly from pySHRED package\n", "The parametric version has to be loaded." ] }, { "cell_type": "code", "execution_count": 30, "id": "a71c2086", "metadata": {}, "outputs": [], "source": [ "from pyshred import ParametricDataManager, SHRED, ParametricSHREDEngine\n", "\n", "# Initialize ParametricSHREDDataManager\n", "manager_pod = ParametricDataManager(\n", " lags = 25,\n", " train_size = 0.8,\n", " val_size = 0.1,\n", " test_size = 0.1,\n", " )\n", "\n", "import warnings\n", "warnings.filterwarnings(\"ignore\")" ] }, { "cell_type": "markdown", "id": "1e0368f2", "metadata": {}, "source": [ "Let us add the different fields, the component $u$ is the one we want to reconstruct, while $v$ is indirectly reconstructed." ] }, { "cell_type": "code", "execution_count": 31, "id": "ce6e01c9", "metadata": {}, "outputs": [], "source": [ "# Measured Field\n", "manager_pod.add_data(\n", " data = snapshots_np['u'],\n", " id = 'u',\n", " random = 3,\n", " compress = 15\n", ")\n", "\n", "# Unobserved Field\n", "manager_pod.add_data(\n", " data = snapshots_np['v'],\n", " id = 'v',\n", " compress = 15\n", ")" ] }, { "cell_type": "markdown", "id": "c2293689", "metadata": {}, "source": [ "Here's a summary of the measurements locations" ] }, { "cell_type": "code", "execution_count": 32, "id": "dea1f293", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
data idsensor_numbertypeloc/traj
0u0stationary (random)(3644,)
1u1stationary (random)(2751,)
2u2stationary (random)(3327,)
\n", "
" ], "text/plain": [ " data id sensor_number type loc/traj\n", "0 u 0 stationary (random) (3644,)\n", "1 u 1 stationary (random) (2751,)\n", "2 u 2 stationary (random) (3327,)" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "manager_pod.sensor_summary_df" ] }, { "cell_type": "markdown", "id": "a1e90957", "metadata": {}, "source": [ "Noise can be added *a-posteriori* to the measurements" ] }, { "cell_type": "code", "execution_count": 33, "id": "4bbee355", "metadata": {}, "outputs": [], "source": [ "noise_std = 0.01\n", "random_noise = np.random.normal(loc=0, scale=noise_std, size=manager_pod.sensor_measurements_df.shape)\n", "\n", "manager_pod.sensor_measurements_df += random_noise" ] }, { "cell_type": "markdown", "id": "9b11fe24", "metadata": {}, "source": [ "Let us prepare the data by splitting them into train, valid and test sets." ] }, { "cell_type": "code", "execution_count": 34, "id": "d96e6b96", "metadata": {}, "outputs": [], "source": [ "train_dataset, val_dataset, test_dataset = manager_pod.prepare()" ] }, { "cell_type": "markdown", "id": "73fe3f6c", "metadata": {}, "source": [ "Definition of the SHRED architecture and fitting procedure." ] }, { "cell_type": "code", "execution_count": null, "id": "229cf536", "metadata": {}, "outputs": [], "source": [ "shred_pod = SHRED(\n", " sequence_model=\"LSTM\",\n", " decoder_model=\"MLP\",\n", " latent_forecaster=None\n", ")\n", "\n", "# Fit \n", "val_errors_shredpod = shred_pod.fit(\n", " train_dataset=train_dataset,\n", " val_dataset=val_dataset,\n", " num_epochs=100,\n", " patience=50,\n", " verbose=True,\n", ")" ] }, { "cell_type": "markdown", "id": "a87987f1", "metadata": {}, "source": [ "Let us reconstruct the full state from the measurements." ] }, { "cell_type": "code", "execution_count": 36, "id": "67444a56", "metadata": {}, "outputs": [], "source": [ "ntest = manager_pod.test_indices.shape[0]\n", "ntimes = snapshots_np['u'].shape[1]\n", "\n", "engine_pod = ParametricSHREDEngine(manager_pod, shred_pod)\n", "pod_test_reconstruction = engine_pod.decode(engine_pod.sensor_to_latent(manager_pod.test_sensor_measurements))\n", "pod_test_reconstruction['u'] = pod_test_reconstruction['u'].reshape(ntest, ntimes, -1)\n", "pod_test_reconstruction['v'] = pod_test_reconstruction['v'].reshape(ntest, ntimes, -1)" ] }, { "cell_type": "markdown", "id": "40a4366d", "metadata": {}, "source": [ "Let us store the train, test and validation indices for later use" ] }, { "cell_type": "code", "execution_count": 37, "id": "3e0aa781", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Train indices: [0 1 2 3 4 5 6 7]\n", "Validation indices: [8]\n", "Test indices: [9]\n" ] } ], "source": [ "train_indices = manager_pod.train_indices\n", "val_indices = manager_pod.val_indices\n", "test_indices = manager_pod.test_indices\n", "\n", "print('Train indices:', train_indices)\n", "print('Validation indices:', val_indices)\n", "print('Test indices:', test_indices)" ] }, { "cell_type": "markdown", "id": "4f26b3e1", "metadata": {}, "source": [ "### Compression with external SVD and sensors placed by DEIM\n", "This section will adopt an hybrid approach, where the SVD modes are computed with *pyforce*, and the sensors are placed with DEIM. The SHRED architecture and fitting procedure is still handled by pySHRED." ] }, { "cell_type": "code", "execution_count": 38, "id": "8edd4fb7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SVD of u snapshots calculated in 10.286571 seconds (cpu).\n", "SVD of v snapshots calculated in 10.362647 seconds (cpu).\n" ] } ], "source": [ "from pyforce.tools.functions_list import FunctionsList\n", "from pyforce.offline.pod import rSVD\n", "\n", "pod_pyforce = {\n", " field: rSVD(grid, gdim = 2, varname = field)\n", " for field in var_names\n", "}\n", "\n", "for field in var_names:\n", "\n", " _snap_list = FunctionsList(snap_matrix=snapshots_np[field][train_indices].reshape(-1, Nh).T)\n", " pod_pyforce[field].fit(_snap_list, verbose=True, rank=15)" ] }, { "cell_type": "markdown", "id": "7060322a", "metadata": {}, "source": [ "Let us compute the SVD coefficients with *pyforce*" ] }, { "cell_type": "code", "execution_count": 39, "id": "e8afe62a", "metadata": {}, "outputs": [], "source": [ "pod_coeffs = dict()\n", "\n", "for field in var_names:\n", " _snap_list = FunctionsList(snap_matrix=snapshots_np[field].reshape(-1, Nh).T)\n", " pod_coeffs[field] = pod_pyforce[field].reduce(_snap_list).T.reshape(Ns, Nt, -1)" ] }, { "cell_type": "markdown", "id": "341e50a0", "metadata": {}, "source": [ "Let us place the sensors with DEIM on the POD modes computed with *pyforce*" ] }, { "cell_type": "code", "execution_count": 40, "id": "deaca23b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "DEIM iteration 3/3\r" ] } ], "source": [ "from pyforce.offline.eim import deim\n", "\n", "sensors_deim = deim(pod_pyforce['u'].svd_modes, Mmax = 3, varname='u')[0]\n", "measurements = snapshots_np[field][:, :, sensors_deim]" ] }, { "cell_type": "markdown", "id": "96565a1c", "metadata": {}, "source": [ "Let us now initialize a new data manager for pySHRED with the new measurements and POD coefficients and add the fields as before" ] }, { "cell_type": "code", "execution_count": 41, "id": "9680ca1e", "metadata": {}, "outputs": [], "source": [ "manager_svd = ParametricDataManager(\n", " lags = 25,\n", " train_size = 0.8,\n", " val_size = 0.1,\n", " test_size = 0.1,\n", " )\n", "\n", "manager_svd.add_data(\n", " data = pod_coeffs['u'],\n", " id = 'u',\n", " measurements=measurements,\n", " compress = False\n", ")\n", "\n", "manager_svd.add_data(\n", " data = pod_coeffs['v'],\n", " id = 'v',\n", " compress = False\n", ")\n", "\n", "noise_std = 0.01\n", "random_noise = np.random.normal(loc=0, scale=noise_std, size=manager_pod.sensor_measurements_df.shape)\n", "\n", "manager_pod.sensor_measurements_df += random_noise" ] }, { "cell_type": "markdown", "id": "90c895ad", "metadata": {}, "source": [ "Let us prepare the data by splitting them into train, valid and test sets." ] }, { "cell_type": "code", "execution_count": 42, "id": "236066c1", "metadata": {}, "outputs": [], "source": [ "train_dataset, val_dataset, test_dataset = manager_svd.prepare()" ] }, { "cell_type": "markdown", "id": "c08a40f3", "metadata": {}, "source": [ "Definition of the SHRED architecture and fitting procedure." ] }, { "cell_type": "code", "execution_count": null, "id": "e70d2e21", "metadata": {}, "outputs": [], "source": [ "shred_svd = SHRED(\n", " sequence_model=\"LSTM\",\n", " decoder_model=\"MLP\",\n", " latent_forecaster=None\n", ")\n", "\n", "# Fit\n", "val_errors_shredsvd = shred_svd.fit(\n", " train_dataset=train_dataset,\n", " val_dataset=val_dataset,\n", " num_epochs=100,\n", " patience=50,\n", " verbose=True,\n", ")" ] }, { "cell_type": "markdown", "id": "5667d80b", "metadata": {}, "source": [ "Let us reconstruct the full state from the measurements." ] }, { "cell_type": "code", "execution_count": 44, "id": "29d0622e", "metadata": {}, "outputs": [], "source": [ "ntest = manager_svd.test_indices.shape[0]\n", "ntimes = snapshots_np['v'].shape[1]\n", "\n", "engine_svd = ParametricSHREDEngine(manager_svd, shred_svd)\n", "\n", "svd_test_recon_coeffs = engine_svd.decode(engine_svd.sensor_to_latent(manager_svd.test_sensor_measurements))\n", "svd_test_recon_coeffs['u'] = svd_test_recon_coeffs['u'].reshape(ntest, ntimes, -1)\n", "svd_test_recon_coeffs['v'] = svd_test_recon_coeffs['v'].reshape(ntest, ntimes, -1)\n", "\n", "svd_test_reconstrunction = {\n", " field: pod_pyforce[field].reconstruct(svd_test_recon_coeffs[field][0].T).return_matrix()\n", " for field in var_names\n", "}" ] }, { "cell_type": "markdown", "id": "1f40a828", "metadata": {}, "source": [ "## NuSHRED implementation\n", "We now demonstrate the \"in-house\" implementation of SHRED, named NuSHRED which has been developed parallel to *pyforce*. \n", "\n", "**Disclaimer:** this implementation has been a joint work with Matteo Tomasetto and the other authors of *pySHRED*, but it is not as optimized as the official package." ] }, { "cell_type": "markdown", "id": "a00496b3", "metadata": {}, "source": [ "We are going to exploit some already defined objects from last section." ] }, { "cell_type": "markdown", "id": "4f8fc9fb", "metadata": {}, "source": [ "At first, let us define the measurements in the proper format" ] }, { "cell_type": "code", "execution_count": 66, "id": "e856675b", "metadata": {}, "outputs": [], "source": [ "from sklearn.preprocessing import MinMaxScaler\n", "Xsensor = {\n", " 'train': measurements[manager_svd.train_indices],\n", " 'val': measurements[manager_svd.val_indices],\n", " 'test': measurements[manager_svd.test_indices],\n", "}\n", "\n", "num_sensors = measurements.shape[-1]\n", "\n", "# Add noise\n", "for key in Xsensor.keys():\n", " noise = np.random.normal(loc=0, scale=noise_std, size=Xsensor[key].shape)\n", " Xsensor[key] += noise\n", "\n", "# Rescaling process\n", "sens_scaler = MinMaxScaler()\n", "sens_scaler.fit(Xsensor['train'].reshape(-1, num_sensors))\n", "\n", "rescaled_Xsensor = {\n", " key: sens_scaler.transform(Xsensor[key].reshape(-1, num_sensors)).reshape(Xsensor[key].shape)\n", " for key in Xsensor.keys()\n", "}" ] }, { "cell_type": "markdown", "id": "88258c6b", "metadata": {}, "source": [ "Now, let's focus on the SVD coefficients" ] }, { "cell_type": "code", "execution_count": 52, "id": "585794e4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SVD Coefficients Shape\n", "(8, 1000, 30)\n", "(1, 1000, 30)\n", "(1, 1000, 30)\n" ] } ], "source": [ "_stacked_POD_coeff = np.concatenate([pod_coeffs[field] for field in var_names], axis=-1)\n", "\n", "Nmodes = [15]*len(var_names)\n", "\n", "vpod_scaler = MinMaxScaler()\n", "vpod_scaler.fit(_stacked_POD_coeff[manager_svd.train_indices].reshape(-1, sum(Nmodes)))\n", "\n", "rescaled_v_SVD = {\n", " 'train': vpod_scaler.transform(\n", " _stacked_POD_coeff[manager_svd.train_indices].reshape(-1, sum(Nmodes))\n", " ).reshape(len(train_indices), ntimes, sum(Nmodes)),\n", " 'val': vpod_scaler.transform(\n", " _stacked_POD_coeff[manager_svd.val_indices].reshape(-1, sum(Nmodes))\n", " ).reshape(len(val_indices), ntimes, sum(Nmodes)),\n", " 'test': vpod_scaler.transform(\n", " _stacked_POD_coeff[manager_svd.test_indices].reshape(-1, sum(Nmodes))\n", " ).reshape(len(test_indices), ntimes, sum(Nmodes))\n", "}\n", "\n", "print('SVD Coefficients Shape')\n", "print(rescaled_v_SVD['train'].shape)\n", "print(rescaled_v_SVD['test'].shape)\n", "print(rescaled_v_SVD['val'].shape)" ] }, { "cell_type": "markdown", "id": "da29f6a9", "metadata": {}, "source": [ "Now, that we can all the ingredients to prepare the data for a SHRED approach." ] }, { "cell_type": "code", "execution_count": 54, "id": "b07f384f", "metadata": {}, "outputs": [], "source": [ "import sys\n", "sys.path.append('/Users/sriva/Github/PublicRepo/NuSHRED')\n", "\n", "from shred.processdata import Padding, TimeSeriesDataset, num2p, mre\n", "import torch\n", "from shred.models import SHRED, fit\n", "import os\n", "\n", "# GPU\n", "device = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu'" ] }, { "cell_type": "markdown", "id": "f0185557", "metadata": {}, "source": [ "Let us prepare them for the SHRED architecture." ] }, { "cell_type": "code", "execution_count": 73, "id": "e765cbed", "metadata": {}, "outputs": [], "source": [ "lags = 30\n", "\n", "# Input Data\n", "train_data_in = Padding(torch.from_numpy(rescaled_Xsensor['train']), lag = lags).to(device)\n", "val_data_in = Padding(torch.from_numpy(rescaled_Xsensor['val']), lag = lags).to(device)\n", "test_data_in = Padding(torch.from_numpy(rescaled_Xsensor['test']), lag = lags).to(device)\n", "\n", "# Output Data\n", "train_data_out = Padding(torch.from_numpy(rescaled_v_SVD['train']), lag = 1).squeeze(1).to(device)\n", "val_data_out = Padding(torch.from_numpy(rescaled_v_SVD['val']), lag = 1).squeeze(1).to(device)\n", "test_data_out = Padding(torch.from_numpy(rescaled_v_SVD['test']), lag = 1).squeeze(1).to(device)\n", "\n", "output_size = test_data_out.shape[-1]\n", "\n", "# Create Dataset for SHRED training\n", "train_dataset = TimeSeriesDataset(train_data_in, train_data_out)\n", "valid_dataset = TimeSeriesDataset(val_data_in, val_data_out)\n", "test_dataset = TimeSeriesDataset(test_data_in, test_data_out)" ] }, { "cell_type": "markdown", "id": "5f98a559", "metadata": {}, "source": [ "Let us train the SHRED models for each configuration" ] }, { "cell_type": "code", "execution_count": 74, "id": "02293e19", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training done: Training loss = 1.22% \t Validation loss = 1.54% \n" ] } ], "source": [ "shred_model = SHRED( num_sensors, output_size, \n", " hidden_size = 64, hidden_layers = 2, decoder_sizes = [350, 400], dropout = 0.1).to(device)\n", "\n", "fitting_errs = fit(shred_model, \n", " train_dataset, \n", " valid_dataset, \n", " batch_size = 64, epochs = 100, lr = 1e-3, verbose = True, patience = 50)\n", "shred_model.freeze()" ] }, { "cell_type": "markdown", "id": "f40ed459", "metadata": {}, "source": [ "Let us reconstruct the state" ] }, { "cell_type": "code", "execution_count": 83, "id": "e0c2853a", "metadata": {}, "outputs": [], "source": [ "Ytest_POD_hat = shred_model(test_dataset.X).cpu().detach().numpy()\n", "\n", "Ytest_POD_hat = vpod_scaler.inverse_transform(Ytest_POD_hat).reshape(len(test_indices), ntimes, sum(Nmodes))\n", "\n", "ytest_pod_predicted = {\n", " field: Ytest_POD_hat[:, :, sum(Nmodes[:i]):sum(Nmodes[:i+1])]\n", " for i, field in enumerate(var_names)\n", "}\n", "\n", "my_shred_test_reconstrunction = {\n", " field: pod_pyforce[field].reconstruct(ytest_pod_predicted[field][0].T).return_matrix()\n", " for field in var_names\n", "}" ] }, { "cell_type": "markdown", "id": "d73fe3f0", "metadata": {}, "source": [ "## Comparison of the two implementations\n", "Let us compare the results of the two implementations by plotting the reconstructions for a test case." ] }, { "cell_type": "code", "execution_count": 85, "id": "1b672682", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 0.98, 'Reconstruction at time step 900')" ] }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "nrows = len(pod_test_reconstruction.keys())\n", "ncols = 7\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "cmaps = ['jet', 'twilight']\n", "\n", "tt = 900\n", "fig, axs = plt.subplots(nrows=nrows, ncols=ncols, figsize=(6 * ncols, 4 * nrows))\n", "\n", "for field_i, field in enumerate(pod_test_reconstruction.keys()):\n", "\n", " levels = np.linspace(snapshots_np[field][manager_pod.test_indices[0]].min(), snapshots_np[field][manager_pod.test_indices[0]].max(), 50)\n", " \n", " fom = snapshots_np[field][manager_pod.test_indices[0], tt, :] # there is only one test case\n", " rec_pod_shred = pod_test_reconstruction[field][0, tt, :]\n", " rec_svd_shred = svd_test_reconstrunction[field][:, tt]\n", " rec_my_shred = my_shred_test_reconstrunction[field][:, tt]\n", "\n", " residual_pod_shred = np.abs(fom - rec_pod_shred)\n", " residual_svd_shred = np.abs(fom - rec_svd_shred)\n", " residual_my_shred = np.abs(fom - rec_my_shred)\n", "\n", " res_levels = np.linspace(0, max(residual_pod_shred.max(), residual_svd_shred.max(), residual_my_shred.max()), 20)\n", "\n", " # FOM\n", " c = axs[field_i, 0].tricontourf(nodes[:, 0], nodes[:, 1], fom, levels=levels, cmap=cmaps[field_i])\n", " create_circle(axs[field_i, 0])\n", " cbar = fig.colorbar(c, ax=axs[field_i, 0])\n", "\n", " # SHRED-POD\n", " c = axs[field_i, 1].tricontourf(nodes[:, 0], nodes[:, 1], rec_pod_shred, levels=levels, cmap=cmaps[field_i])\n", " create_circle(axs[field_i, 1])\n", " cbar = fig.colorbar(c, ax=axs[field_i, 1])\n", "\n", " # SHRED-SVD\n", " c = axs[field_i, 2].tricontourf(nodes[:, 0], nodes[:, 1], rec_svd_shred, levels=levels, cmap=cmaps[field_i])\n", " create_circle(axs[field_i, 2])\n", " cbar = fig.colorbar(c, ax=axs[field_i, 2])\n", "\n", " # My SHRED\n", " c = axs[field_i, 3].tricontourf(nodes[:, 0], nodes[:, 1], rec_my_shred, levels=levels, cmap=cmaps[field_i])\n", " create_circle(axs[field_i, 3])\n", " cbar = fig.colorbar(c, ax=axs[field_i, 3])\n", "\n", " # Residual - SHRED-POD\n", " c = axs[field_i, 4].tricontourf(nodes[:, 0], nodes[:, 1], residual_pod_shred, levels=res_levels, cmap='viridis')\n", " create_circle(axs[field_i, 4])\n", " cbar = fig.colorbar(c, ax=axs[field_i, 4])\n", "\n", " # Residual - SHRED-SVD\n", " c = axs[field_i, 5].tricontourf(nodes[:, 0], nodes[:, 1], residual_svd_shred, levels=res_levels, cmap='viridis')\n", " create_circle(axs[field_i, 5])\n", " cbar = fig.colorbar(c, ax=axs[field_i, 5])\n", "\n", " # Residual - My SHRED\n", " c = axs[field_i, 6].tricontourf(nodes[:, 0], nodes[:, 1], residual_my_shred, levels=res_levels, cmap='viridis')\n", " create_circle(axs[field_i, 6])\n", " cbar = fig.colorbar(c, ax=axs[field_i, 6])\n", "\n", " axs[field_i, 0].set_ylabel(f'{field} field', fontsize=16)\n", "\n", "axs[0,0].set_title('FOM')\n", "axs[0,1].set_title('SHRED-POD Reconstruction')\n", "axs[0,2].set_title('SHRED-SVD Reconstruction')\n", "axs[0,3].set_title('My SHRED Reconstruction')\n", "axs[0,4].set_title('Residual SHRED-POD')\n", "axs[0,5].set_title('Residual SHRED-SVD')\n", "axs[0,6].set_title('Residual My SHRED')\n", "\n", "for ax in axs.ravel():\n", " ax.set_xticks([])\n", " ax.set_yticks([])\n", "\n", "fig.suptitle('Reconstruction at time step {}'.format(tt), fontsize=20)" ] } ], "metadata": { "kernelspec": { "display_name": "ml", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.14" } }, "nbformat": 4, "nbformat_minor": 5 }