SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2107.02784 · 2021

Data-driven reduced order modeling of environmental hydrodynamics using deep autoencoders and neural ODEs

arXiv · PDF · Open in the Atlas

Code that ran

15 of 17 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 11 have no contract verdict; 4 failures of our instrument; 2 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2107.02784.json · badge: /api/ran/2107.02784.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
erdc/node_nirom canonical (classifier label)
classifier basis: classifier_2025
3 ran · 0 no recorded run
erdc/pynirom community (classifier label)
classifier basis not recorded on the link
12 ran · 2 no recorded run
FunctionStatusWhere it lives
augment_state Ran
ran on a synthesized input
erdc/pynirom/pynirom/node/node.py
code served (permissive licence) · get_code("8fcd97a3976f6f38")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import tensorflow as tf

# Create small test arrays
state_array = np.random.randn(2, 4).astype(np.float32)
time_array = np.array([0.0, 1.0]).astype(np.float32)
aug_dim = 3

ARGS = {
    "state_array": state_array,
    "time_array": time_array,
    "aug_dim": aug_dim,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_interp_matrix Ran
ran on a synthesized input
erdc/pynirom/pynirom/rbf/rbf.py
code served (permissive licence) · get_code("f01dee026cdb9d91")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import scipy.spatial.distance

# Create small test data for the function
# The function expects Zsnap to be a dictionary of mode arrays
# Each array should have shape (num_modes, num_snapshots)

# Create distinct sizes for different components
# Component 1: 3 modes, 5 snapshots
component_1 = np.random.randn(3, 5)

# Component 2: 2 modes, 5 snapshots  
component_2 = np.random.randn(2, 5)

# Build Zsnap dictionary
Zsnap = {
    'h': component_1,
    'u': component_2
}

# Nt should be num_snapshots - 1 (as per function docstring)
Nt = 4

# Epsilon parameter for RBF kernel
epsilon = 0.05

# Beta parameter for some RBF kernels
beta = 2.5

# RBF kernel type to use
rbf_kernel = 'matern'

ARGS = {
    'Zsnap': Zsnap,
    'Nt': Nt,
    'rbf_kernel': rbf_kernel,
    'epsilon': epsilon,
    'beta': beta
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_kernel Ran
ran on a synthesized input
erdc/pynirom/pynirom/rbf/rbf.py
code served (permissive licence) · get_code("7bca82596cbfac78")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (3, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create a small distance matrix as rij parameter
# This should be a 2D array of pairwise distances between RBF centers
rij = np.array([[0.0, 1.5, 2.3],
                [1.5, 0.0, 1.8],
                [2.3, 1.8, 0.0]])

ARGS = {
    'rij': rij,
    'rbf_kernel': 'matern',
    'epsilon': 0.05
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (3, 3) — shape (3, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_pod_multicomponent Ran
ran; our contract draft was wrong, not the code
erdc/node_nirom/notebooks/node_cylinder.py
code served (permissive licence) · get_code("e67299e850b73c74")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import scipy

# Create sample snapshot data for multiple components
# S_pod is a dictionary where each key maps to an M x N array of snapshots
# Using distinct dimensions: 5 spatial points, 8 time snapshots for first component
# and 6 spatial points, 8 time snapshots for second component

component1_snapshots = np.random.randn(5, 8)
component2_snapshots = np.random.randn(6, 8)

S_pod = {
    'velocity': component1_snapshots,
    'pressure': component2_snapshots
}

ARGS = {
    'S_pod': S_pod,
    'subtract_mean': True,
    'subtract_initial': False,
    'full_matrices': False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_rbf Ran
ran on a synthesized input
erdc/pynirom/pynirom/rbf/rbf.py
code served (permissive licence) · get_code("cdaa0af2555ce42a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import scipy.spatial.distance

# Create minimal test data for compute_rbf
# The function expects Zsnap_rbf to be a dictionary of snapshot arrays
# Each value should be a 2D array: (num_modes, num_snapshots)

np.random.seed(0)

# Create small snapshot arrays for different state variables
# Using distinct sizes: 4 modes, 6 snapshots
Zsnap_rbf = {
    'h': np.random.randn(4, 6),      # 4 modes, 6 snapshots
    'u': np.random.randn(3, 6),      # 3 modes, 6 snapshots
}

# Create time array matching number of snapshots
time_rbf = np.linspace(0, 1, 6)

# Define the ARGS dictionary with all parameters for compute_rbf
ARGS = {
    'Zsnap_rbf': Zsnap_rbf,
    'time_rbf': time_rbf,
    'ep': 0.05,
    'beta': 2.5,
    'rbf_kernel': 'matern'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_trunc_basis Ran
ran; our contract draft was wrong, not the code
erdc/node_nirom/notebooks/node_cylinder.py
code served (permissive licence) · get_code("742ed8bc9159b522")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create small singular value arrays for each component
# D should be a dictionary where each value is a 1D array of singular values
D = {
    'component_1': np.array([10.0, 5.0, 2.0, 0.5, 0.1]),
    'component_2': np.array([8.0, 4.0, 1.5, 0.3]),
}

# Create left singular basis vector arrays
# U should be a dictionary where each value is a 2D array
# Shape should be (n_features, n_singular_values)
U = {
    'component_1': np.random.randn(6, 5),  # 6 features, 5 singular values
    'component_2': np.random.randn(4, 4),  # 4 features, 4 singular values
}

# eng_cap is a float representing the energy capture threshold
eng_cap = 0.999999

ARGS = {
    'D': D,
    'U': U,
    'eng_cap': eng_cap,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_trunc_basis Ran
ran on a synthesized input
erdc/pynirom/pynirom/pod/pod_utils.py
code served (permissive licence) · get_code("ea93e60cd93f4d0c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Construct small, valid test data for compute_trunc_basis
# The function expects:
# D: dictionary of singular values (1D arrays)
# U: dictionary of left singular basis vectors (2D arrays)
# eng_cap: float between 0 and 1
# user_rank: dictionary mapping keys to ranks (can be empty)

# Create singular values for two components
D = {
    'component_1': np.array([10.0, 5.0, 2.0, 0.5, 0.1]),
    'component_2': np.array([8.0, 4.0, 1.5, 0.3])
}

# Create left singular basis vectors matching dimensions
# For component_1: 5 modes (from D), so shape (n_samples, 5)
# For component_2: 4 modes (from D), so shape (m_samples, 4)
U = {
    'component_1': np.random.randn(7, 5),
    'component_2': np.random.randn(6, 4)
}

# Energy capture threshold
eng_cap = 0.999999

# User-specified ranks (empty dict to use energy-based truncation)
user_rank = {}

ARGS = {
    'D': D,
    'U': U,
    'eng_cap': eng_cap,
    'user_rank': user_rank
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
init_cond_onl Ran
ran; our contract draft was wrong, not the code
erdc/pynirom/pynirom/rbf/rom.py
code served (permissive licence) · get_code("8408470eb905f774")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create small test data
np.random.seed(0)

# Define n_pod: dict mapping solution names to number of POD modes
n_pod = {
    'u': 3,
    'v': 2
}

# Define snap_data: dict mapping solution names to snapshot matrices
# Shape: (spatial_dim, n_snapshots)
snap_data = {
    'u': np.random.randn(5, 10),  # 5 spatial points, 10 snapshots
    'v': np.random.randn(4, 10)   # 4 spatial points, 10 snapshots
}

# Define U: list of POD basis matrices
# U[i] has shape (spatial_dim_i, n_pod_i)
U = [
    np.random.randn(5, 3),  # For 'u': 5 spatial dims, 3 POD modes
    np.random.randn(4, 2)   # For 'v': 4 spatial dims, 2 POD modes
]

# Define Smean: dict mapping solution names to mean snapshots
Smean = {
    'u': np.random.randn(5),  # Mean of 5 spatial points
    'v': np.random.randn(4)   # Mean of 4 spatial points
}

# Define other parameters
nt_online = 8  # Number of online time steps
t0_ind = 0     # Initial time index

ARGS = {
    'snap_data': snap_data,
    'nt_online': nt_online,
    'n_pod': n_pod,
    'U': U,
    'Smean': Smean,
    't0_ind': t0_ind
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
prepare_data Ran
ran on a synthesized input
erdc/pynirom/pynirom/utils/data_utils.py
code served (permissive licence) · get_code("265d0246506b1b71")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create sample data dictionary with time and solution fields
time_array = np.array([0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
data = {
    'time': time_array,
    'u': np.random.randn(5, len(time_array)),  # 5 spatial points, 10 time steps
    'v': np.random.randn(5, len(time_array)),  # 5 spatial points, 10 time steps
}

soln_names = ['u', 'v']

options = {
    'start_skip': 1,
    'end_skip': 9,
    'T_start': 0.1,
    'T_end': 0.8,
    'incr': 2,
}

ARGS = {
    'data': data,
    'soln_names': soln_names,
    'options': options,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
project_onto_basis Ran
ran; our contract draft was wrong, not the code
erdc/node_nirom/notebooks/node_cylinder.py
code served (permissive licence) · get_code("badc48beb2854cec")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Set random seed for reproducibility
np.random.seed(0)

# Create small test data
# S: Dict of high-dimensional snapshots for each component
# Each snapshot matrix has shape (spatial_dim, num_snapshots)
S = {
    'p': np.random.randn(4, 2),      # 4 spatial points, 2 snapshots
    'v_x': np.random.randn(5, 2),    # 5 spatial points, 2 snapshots
    'v_y': np.random.randn(6, 2),    # 6 spatial points, 2 snapshots
}

# Phi: Dict of POD basis vectors for each component
# Each basis matrix has shape (spatial_dim, num_modes)
Phi = {
    'p': np.random.randn(4, 3),      # 4 spatial points, 3 POD modes
    'v_x': np.random.randn(5, 3),    # 5 spatial points, 3 POD modes
    'v_y': np.random.randn(6, 3),    # 6 spatial points, 3 POD modes
}

# Orthonormalize the basis vectors (make them orthonormal)
for key in Phi:
    Q, _ = np.linalg.qr(Phi[key])
    Phi[key] = Q

# S_mean: Dict of temporal mean for each component
# Each mean vector has shape (spatial_dim,)
S_mean = {
    'p': np.random.randn(4),         # 4 spatial points
    'v_x': np.random.randn(5),       # 5 spatial points
    'v_y': np.random.randn(6),       # 6 spatial points
}

ARGS = {
    'S': S,
    'Phi': Phi,
    'S_mean': S_mean,
    'msg': False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
project_onto_basis Ran
ran on a synthesized input
erdc/pynirom/pynirom/pod/pod_utils.py
code served (permissive licence) · get_code("fded0b5c3a89c0ff")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create small sample data for testing
np.random.seed(0)

# Define dimensions: 
# - spatial_dim = 4 (high-dimensional space)
# - n_snapshots = 3 (number of temporal snapshots)
# - n_modes = 2 (number of POD basis vectors)

spatial_dim = 4
n_snapshots = 3
n_modes = 2

# Component names
component1 = 'velocity'
component2 = 'pressure'

# S: Dict of high-dimensional snapshots
# Each entry has shape (spatial_dim, n_snapshots)
S = {
    component1: np.random.randn(spatial_dim, n_snapshots),
    component2: np.random.randn(spatial_dim, n_snapshots)
}

# Phi: Dict of POD basis vectors (orthonormal bases)
# Each entry has shape (spatial_dim, n_modes)
Phi = {
    component1: np.random.randn(spatial_dim, n_modes),
    component2: np.random.randn(spatial_dim, n_modes)
}

# Orthonormalize the basis vectors using QR decomposition
for key in Phi.keys():
    Q, R = np.linalg.qr(Phi[key])
    Phi[key] = Q[:, :n_modes]

# S_mean: Dict of temporal mean for each component
# Each entry has shape (spatial_dim,)
S_mean = {
    component1: np.mean(S[component1], axis=1),
    component2: np.mean(S[component2], axis=1)
}

# msg parameter
msg = False

ARGS = {
    'S': S,
    'Phi': Phi,
    'S_mean': S_mean,
    'msg': msg
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
scale_states Ran
ran on a synthesized input
erdc/pynirom/pynirom/node/node.py
code served (permissive licence) · get_code("a6e03e31ed6fc434")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
from sklearn.preprocessing import MinMaxScaler, StandardScaler, MaxAbsScaler

# Create a small 2D numpy array (Time X State)
# Shape: 5 time steps, 3 state dimensions
state_array = np.array([
    [1.0, 2.0, 3.0],
    [2.0, 3.0, 4.0],
    [3.0, 4.0, 5.0],
    [4.0, 5.0, 6.0],
    [5.0, 6.0, 7.0]
], dtype=np.float32)

ARGS = {
    'state_array': state_array,
    'method': 'centered'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
scale_time Ran
ran on a synthesized input
erdc/pynirom/pynirom/node/node.py
code served (permissive licence) · get_code("a6abed9452167983")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create a small time array from 0 to T
time_array = np.linspace(0, 10, 11)  # 11 points from 0 to 10

# Create options dict with optional tscale parameter
options = {
    'tscale': 5.0
}

ARGS = {
    'time_array': time_array,
    'options': options
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
viz_err Ran
ran on a synthesized input
erdc/pynirom/pynirom/rbf/plotting.py
code served (permissive licence) · get_code("cb305b0b881c14b0")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned PolyCollection. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
import matplotlib.pyplot as plt

torch.manual_seed(0)

# Create small test data for a finite element mesh
# nodes: coordinates of mesh nodes (N x 2)
nodes = np.array([
    [0.0, 0.0],
    [1.0, 0.0],
    [0.5, 1.0],
    [0.0, 1.0]
], dtype=np.float32)

# triangles: connectivity indices (M x 3)
triangles = np.array([
    [0, 1, 2],
    [0, 2, 3]
], dtype=np.int32)

# uh: NIROM solution values at nodes (N,)
uh = np.array([0.1, 0.2, 0.15, 0.05], dtype=np.float32)

# snap: snapshot/reference solution values at nodes (N,)
snap = np.array([0.12, 0.18, 0.14, 0.08], dtype=np.float32)

ARGS = {
    "uh": uh,
    "snap": snap,
    "nodes": nodes,
    "triangles": triangles
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PolyCollection — a PolyCollection output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PolyCollection output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
viz_sol Ran
ran on a synthesized input
erdc/pynirom/pynirom/rbf/plotting.py
code served (permissive licence) · get_code("31499761d8eeab82")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import matplotlib.pyplot as plt

# Create small synthetic data for visualization
np.random.seed(0)

# Create nodes: 2D coordinates for mesh vertices
# Shape: (num_nodes, 2)
num_nodes = 6
nodes = np.array([
    [0.0, 0.0],
    [1.0, 0.0],
    [1.0, 1.0],
    [0.0, 1.0],
    [0.5, 0.5],
    [0.25, 0.75]
], dtype=np.float64)

# Create triangles: indices into nodes array
# Shape: (num_triangles, 3)
triangles = np.array([
    [0, 1, 4],
    [1, 2, 4],
    [2, 3, 4],
    [3, 0, 4],
    [0, 4, 5],
    [3, 5, 4]
], dtype=np.int32)

# Create solution values at each node
# Shape: (num_nodes,)
uh = np.array([0.1, 0.5, 0.9, 0.3, 0.6, 0.2], dtype=np.float64)

ARGS = {
    'uh': uh,
    'nodes': nodes,
    'triangles': triangles
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
combine_L Not yet run
unverified (harvested, no recorded run)
erdc/pynirom/pynirom/rbf/greedy.py
code served (permissive licence) · get_code("aa03d22e70261b8e")
How it ran

no invocation recorded.

greedy Not yet run
unverified (harvested, no recorded run)
erdc/pynirom/pynirom/rbf/greedy.py
code served (permissive licence) · get_code("163ff6791fabf8ca")
How it ran

no invocation recorded.

Also present in other papers' code

Of 17 samples lifted from this paper's linked repositories, 17 carry a function identity and 0 do not. Of the 16 distinct functions with an identity, 4 are also present in other papers whose code we hold (4 with at least one paper dated earlier, 0 the same month, 0 later) and 12 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
compute_pod_multicomponent 1 other paper
1 dated earlier
2104.13962 (2021-04)
Neural Ordinary Differential Equations for Data-Driven Reduced Order Modeling of Environmental Hydrodynamics
compute_trunc_basis 1 other paper
1 dated earlier
2104.13962 (2021-04)
Neural Ordinary Differential Equations for Data-Driven Reduced Order Modeling of Environmental Hydrodynamics
init_cond_onl 1 other paper
1 dated earlier
2104.13962 (2021-04)
Neural Ordinary Differential Equations for Data-Driven Reduced Order Modeling of Environmental Hydrodynamics
project_onto_basis 1 other paper
1 dated earlier
2104.13962 (2021-04)
Neural Ordinary Differential Equations for Data-Driven Reduced Order Modeling of Environmental Hydrodynamics

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Model reduction for fluid flow simulation continues to be of great interest across a number of scientific and engineering fields. In a previous work [arXiv:2104.13962], we explored the use of Neural Ordinary Differential Equations (NODE) as a non-intrusive method for propagating the latent-space dynamics in reduced order models. Here, we investigate employing deep autoencoders for discovering the reduced basis representation, the dynamics of which are then approximated by NODE. The ability of deep autoencoders to represent the latent-space is compared to the traditional proper orthogonal decomposition (POD) approach, again in conjunction with NODE for capturing the dynamics. Additionally, we compare their behavior with two classical non-intrusive methods based on POD and radial basis function interpolation as well as dynamic mode decomposition. The test problems we consider include incompressible flow around a cylinder as well as a real-world application of shallow water hydrodynamics in an estuarine system. Our findings indicate that deep autoencoders can leverage nonlinear manifold learning to achieve a highly efficient compression of spatial information and define a latent-space that appears to be more suitable for capturing the temporal dynamics through the NODE framework.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2107.02784")
get_code_for_paper("2107.02784")
have("2107.02784")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2107.02784.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2107.02784.svg)](https://syntology.ai/paper/2107.02784)

Connect an agent — have() is free.