Python Scripts Index (JAX)

Click on a script name to download it.

• dg/

  • classical_approach/

    • general_elliptic/

      • solve_1d_convection_diffusion.py: Convection-dominated DG: a boundary layer, SIPG diffusion plus upwind advection.

      • solve_1d_nonlinear_diffusion.py: Solve a nonlinear diffusion problem via Newton-Raphson DG.

      • solve_2d_monge_ampere_picard.py: DG solver for Monge-Ampère via Picard iteration on [0,1]².

      • solve_2d_periodic_reaction_diffusion.py: Solve a steady, periodic 2D reaction-diffusion problem with DG.

      • solve_2d_system_diffusion_advection.py: Résolution d’un système 2D couplé d’advection-diffusion par DG.

      • solve_2d_system_diffusion_advection_multi_space.py: Système couplé advection-diffusion avec deux espaces DG indépendants.

    • laplacian/

      • solve_1d_laplacian_polynomial_solution_SIPG.py: Solve the Laplacian DG scheme via Newton-Raphson.

      • solve_2d_laplacian_boundary_conditions.py: DG on the unit square: Laplace with Dirichlet, Neumann and Robin conditions.

    • multi_materials/

      • solve_2d_magneto_static.py: Solve the 2D Laplacian DG scheme via Newton-Raphson.

      • solve_2d_magneto_static_3mat.py: Magnetostatic DG-SIPG à 3 matériaux.

    • navier_stokes/

      • solve_lid_driven_cavity_navier_stokes_dg_2d.py: Lid-driven cavity in discontinuous Galerkin, Q2/Q1, against Ghia et al.

    • space_time/

      • solve_1d_laplacian_time.py: Solve the Laplacian DG scheme via Newton-Raphson.

    • stokes/

      • solve_stokes_dg_block_preconditioners_2d.py: Stokes in discontinuous Galerkin, Q2/Q1, with the block preconditioners of the FEM.

  • enriched_approach/

    • 1d_linear_advection.py: Linear transport with a reaction source, DG basis enriched with a PINN prior.

    • 1d_shallow_water.py: Shallow water over a bump, DG basis enriched with a PINN prior.

    • 2d_shallow_water.py: 2D shallow water over an axisymmetric bump, DG basis enriched with a PINN prior.

  • learnable_approach/

    • dg_fem_pinn_decomposition_disk_2d.py: Domain decomposition: a polynomial basis in the middle, an enriched one outside.

    • dgelliptic_inverse_reaction_coeff.py: Learning c(x) in -Delta u + c(x) u = f(x) through a differentiable DG solve.

    • dgelliptic_learnable_flux_1d.py: Learn the SIPG penalty constant, kept inside the range that makes it work.

    • dgelliptic_learnable_post_processing_1d.py: Learn the post-processing operator of an elliptic DG solve, by physical loss.

    • dgelliptic_learned_basis.py: A learned DG basis beats the classical one at the same number of DOFs.

    • dgelliptic_mapping_1d.py: Learn a 1D mesh mapping that refines where the boundary layer is.

    • dgelliptic_mapping_2d.py: Learn a 2D mesh mapping that refines where the boundary layer is.

  • time_dependent/

    • 1d_heat_equation_parametric.py: 1D parametric heat equation with TimeDiscreteDGscheme, vmapped over alpha.

    • 1d_sod_shock_tube.py: 1D Sod shock tube for the compressible Euler equations, DG + HLLC.

    • 1d_transport_equation.py: 1D linear transport equation with TimeDiscreteDGscheme, periodic BC.

    • 2d_gray_scott_reaction_diffusion.py: Gray-Scott reaction-diffusion system in 2D, periodic – with TimeDiscreteDGscheme.

    • 2d_heat_equation_unstructured_disk.py: Time-dependent DG on an unstructured mesh: the heat equation on a disk.

• fbpinns/

  • gmsh_subdomains_exploration.py: Exploration: FBPINN window functions on GMSH-based, non-Cartesian subdomains.

  • laplacian_1d_fbpinn.py: Solves a 1D Poisson PDE with Dirichlet boundary conditions using PINNs.

  • laplacian_2d_fbpinn.py: Solves a 2D Poisson PDE with Dirichlet boundary conditions using PINNs.

  • laplacian_2d_fbpinn_disk.py: Solves a 2D Poisson PDE with Dirichlet boundary conditions using PINNs.

  • laplacian_3d_fbpinn_ball.py: Solves a 3D Poisson PDE with Dirichlet boundary conditions using PINNs.

• fem/

  • solve/

    • classical_approach/

      • divdiv_curlcurl/

        • solve_hdiv_hcurl_unstructured_disk_2d.py: Grad-div on Raviart-Thomas and curl-curl on Nédélec, on an unstructured curved disk.

      • elasticity/

        • solve_2d_linear_elasticity_cantilever.py: Linear elasticity, CG-FEM: the Timoshenko-Goodier cantilever, solved exactly.

      • free_boundary/

        • exterior_problems.py: The far-field conditions on the two classical exterior problems, CG-FEM Q2.

        • iter_vacuum_field.py: Vacuum flux of the ITER coils, free boundary, CG-FEM Q2.

      • general_elliptic/

        • solve_2d_system_diffusion_advection_multi_space.py: Système couplé advection-diffusion avec deux espaces CG-FEM indépendants.

        • solve_2d_system_diffusion_advection_multi_space_mg.py: Multigrille sur un système MULTI-SPACE à maillages DIFFÉRENTS.

        • solve_2d_system_diffusion_advection_multi_space_radapt.py: Système advection-diffusion multi-espace + r-adaptation par Monge-Ampère.

        • uq_batched_transport_1d.py: Un LOT d’EDP résolu d’un coup, et l’incertitude qu’on en tire (advection-diffusion 1D).

        • uq_batched_transport_1d_mg.py: Le même lot d’EDP, mais résolu par Krylov + multigrille.

      • grad_shafranov/

        • _fem_vs_pinn.py: Shared by the JET and MAST scripts: the same equilibrium by FEM and by PINN.

        • grad_shafranov_jet_fem_vs_pinn.py: Fixed-boundary Grad-Shafranov on JET: FEM Q2 and PINN, same model, compared.

        • grad_shafranov_mast_fem_vs_pinn.py: Fixed-boundary Grad-Shafranov on MAST: FEM Q2 and PINN, same model, compared.

      • helmholtz/

        • solve_2d_helmholtz_robin_unstructured_disk.py: Complex Helmholtz on an unstructured disk, with a point source and an ABC.

        • solve_2d_helmholtz_robin_unstructured_disk_batched_sources.py: Complex Helmholtz on an unstructured disk, N_RHS random Gaussian-mixture

        • solve_helmholtz_shifted_laplacian_precond_heterogeneous_hard.py: Heterogeneous Helmholtz, pushed harder: k_bg=100 background, k=150 inside

      • laplacian/

        • solve_1d_laplacian.py: Solve the Laplacian FEM scheme via Newton-Raphson.

        • solve_2d_bspline_dirichlet_neumann_robin_nitsche.py: Boundary conditions on a spline space: which ones keep the order, and which

        • solve_2d_laplacian.py: Solve the 2D Laplacian FEM scheme on a single mesh — matrix-free solver.

        • solve_2d_mixed_dirichlet_neumann.py: CG-FEM on the unit square with mixed boundary conditions, one per side.

        • solve_2d_robin.py: CG-FEM on the unit square with Robin conditions.

        • solve_laplacian_unstructured_2d.py: -Delta u = 1 on unstructured quadrilateral meshes read from GMSH.

      • multi_materials/

        • solve_2d_magneto_static.py: 2D magnetostatics with a permanent magnet, CG-FEM, materials as named regions.

        • solve_2d_magneto_static_3mat.py: 2D magnetostatics with a magnet and a pole piece, CG-FEM, three named regions.

        • solve_2d_magneto_static_nmat.py: 2D magnetostatics with 5 magnets and 4 pole pieces, CG-FEM, named regions.

      • navier_stokes/

        • solve_cylinder_schaefer_turek_2d.py: Flow past a cylinder, Schäfer-Turek benchmark 2D-1 (Re = 20, stationary).

        • solve_lid_driven_cavity_fas_2d.py: Lid-driven cavity, stationary Navier-Stokes, solved by a NONLINEAR multigrid (FAS).

        • solve_lid_driven_cavity_navier_stokes_2d.py: Lid-driven cavity, stationary Navier-Stokes, Taylor-Hood Q2/Q1, against Ghia et al.

      • stokes/

        • solve_stokes_block_preconditioners_2d.py: Stokes, Taylor-Hood Q2/Q1: block preconditioners, iterations flat in h.

        • solve_stokes_saddle_2d.py: Stokes on the unit square, and what the inf-sup condition actually does.

        • solve_stokes_splines_2d.py: Stokes on spline spaces: which pairs satisfy inf-sup, and how far that goes.

    • time_dependent/

      • advanced_examples/

        • 2d_anisotropic_diffusion_disk.py: Time-dependent CG-FEM: rotational anisotropic diffusion on the disk.

        • 2d_current_hole_reduced_mhd.py: The current hole: an internal kink in reduced resistive MHD, CG-FEM on the disk.

      • 1d_heat_equation_parametric.py: 1D parametric heat equation with TimeDiscreteFEscheme, vmapped over alpha.

      • 2d_gray_scott_reaction_diffusion.py: Gray-Scott reaction-diffusion system in 2D with TimeDiscreteFEscheme.

      • 2d_heat_equation_unstructured_disk.py: Time-dependent CG-FEM on an unstructured mesh: the heat equation on a disk.

• flows/

  • fig/

  • models/

  • lagrangian_pinn_diffusion_multiflow.py: (No docstring found)

  • lagrangian_pinn_linear_vlasov.py: (No docstring found)

  • lagrangian_pinn_linear_vlasov_2d2v.py: (No docstring found)

  • lagrangian_pinn_linear_vlasov_2d2v_postprocess.py: (No docstring found)

  • lagrangian_pinn_transport_multiflows.py: (No docstring found)

  • lagrangian_pinn_transport_multiflows_rotating_transport.py: (No docstring found)

  • lagrangian_pinn_vlasov_poisson.py: Vlasov-Poisson 1D nonlinéaire — amortissement de Landau.

  • lagrangian_pinn_vlasov_poisson_bilevel.py: Vlasov-Poisson 1D bi-niveau — amortissement de Landau.

  • lagrangian_pinn_vp_fft.py: Vlasov-Poisson 1D — flot PINN + Poisson FFT avec cache E mis à jour par epoch.

  • lagrangian_pinn_vp_fft_bilevel.py: Vlasov-Poisson 1D — flot PINN + Poisson FFT, champ E DIFFÉRENTIABLE (bilevel).

• geometry/

  • tokamak_domains.py: Central definition of the 5 tokamak domains with their 2D and 3D samplers.

  • tokamak_plot_2d.py: 2D visualisation of tokamak poloidal cross-sections.

  • tokamak_plot_3d.py: 3D visualisation of the extruded toroidal volume.

  • tokamak_sampling_plot.py: Visualisation of tokamak domain sampling (2D and 3D).

• kernel/

  • time_dependent/

    • 1d_heat_equation_parametric_deep_basis.py: 1D parametric heat equation with an UNTRAINED DeepBasis, vmapped over runs.

    • 2d_heat_equation_deep_basis.py: Fixed (random) DeepBasis vs trained DeepBasis on a 2D heat equation.

    • 2d_heat_equation_learn_variance_centers.py: Classical (fixed) RBF kernel vs learnable kernel (trainable centers and

    • advection_reaction_diffusion_2d_square_isotropic_diffusion.py: Solves a 2D advection-diffusion-reaction equation with time-discrete kernel collocation.

    • heat_1d_segment.py: Solves the heat equation in 1D with time-discrete kernel collocation.

    • heat_1d_segment_parametric.py: 1D parametric heat equation with TimeDiscreteCollocationScheme, vmapped over alpha.

    • heat_1d_segment_parametric_rbf.py: 1D parametric heat equation with TimeDiscreteCollocationScheme, vmapped over alpha.

    • nonlinear_reaction_diffusion_1d_segment.py: 1D nonlinear reaction-diffusion, with TimeDiscreteCollocationScheme.

    • wave_2d_square.py: 2D wave equation as a genuinely hyperbolic first-order system,

  • advection_reaction_diffusion_1d_segment.py: Solve a 1D advection-diffusion-reaction (ADR) equation using kernel-based collocation.

  • advection_reaction_diffusion_2d_square_anisotropic_diffusion.py: Solve a 2D advection-diffusion-reaction (ADR) equation with anisotropic diffusion using kernel-based collocation.

  • advection_reaction_diffusion_2d_square_convection_dominated.py: Solve a 2D advection-diffusion-reaction (ADR) equation in a convection-dominated regime using kernel-based collocation.

  • advection_reaction_diffusion_2d_square_isotropic_diffusion.py: Solve a 2D advection-diffusion-reaction (ADR) equation using kernel-based collocation.

  • helmholtz_2d_square.py: Solve a 2D Helmholtz equation using kernel-based collocation.

  • laplacian_2d_batman.py: (No docstring found)

  • laplacian_2d_flower.py: (No docstring found)

  • laplacian_2d_flower_learnable.py: (No docstring found)

  • laplacian_2d_square.py: (No docstring found)

  • laplacian_2d_square_learn_variance.py: Benchmark : Classical RBF method vs Learnable RBF method.

  • laplacian_2d_square_learn_variance_centers.py: Benchmark : Classical RBF method vs Learnable RBF method.

• mesh/

  • meshes_gmesh/

    • example_macro_mesh_flower.py: Macro-mesh of a smooth 3-petal flower, via the parametrized-curve API.

    • example_macro_mesh_from_curve.py: Macro-mesh from a parametrized boundary curve, at increasing refinement.

    • example_macro_mesh_hole.py: Macro-mesh of a rectangle with a hole: GMSH-auto vs hand-built O-grid.

    • example_macro_mesh_lshape.py: Macro-mesh of the classic L-shaped domain: GMSH-auto vs hand-built.

    • example_macro_mesh_step.py: Macro-mesh of the backward-facing step channel: GMSH-auto vs hand-built.

    • example_macro_mesh_tokamak.py: Macro-mesh of real tokamak cross-sections (JET / MAST), via the point-cloud API.

    • example_mesh_hierarchy.py: Nested mesh hierarchy from a curved boundary: k levels, each 4x the previous.

  • earth_crust_mesh.py: The Earth’s crust: a cubed sphere times a graded radial segment.

  • iter_free_boundary_mesh.py: Quad mesh of the ITER free-boundary Grad-Shafranov benchmark.

  • mastu_free_boundary_mesh.py: Quad mesh of MAST-U for a free-boundary Grad-Shafranov problem.

  • mesh_1d.py: Example : Utilisation de Mesh1D avec mappings simples et apprenables

  • mesh_2d.py: Example : Utilisation de Mesh 2D avec mappings simples et apprenables

  • mesh_mapping.py: Visualisation de maillages 2D avec différents mappings géométriques.

  • meshes.py: (No docstring found)

  • phase_space_sphere.py: Phase space: a 2-D domain times a velocity DIRECTION on the sphere.

  • point_location.py: Locating a point in a mesh: is it right, does it vmap, and what does it cost.

  • space_time_heat_1d.py: The 1-D heat equation solved in SPACE-TIME, on a tensorised mesh.

  • tokamak_mesh.py: Building a tokamak by tensorisation, and checking it is one.

  • tokamak_projection_dg.py: Projecting a field onto the tokamak built in tokamak_mesh.py.

• neural_operators/

  • discrete_no/

    • fno_source_to_solution.py: FNO : apprendre l’application source -> solution, avec et sans parametre.

    • gino_jet_laplacian.py: GINO on the JET tokamak: an FNO run on a shape no grid fits.

    • phifem_fno_variable_geometry.py: phi-FEM-FNO: a neural operator that solves on a DIFFERENT domain each time.

    • pointwise_operator_1d.py: Validation de l’API des opérateurs neuronaux DISCRETS, sur un cas à réponse connue.

    • unet_source_to_solution.py: U-Net : apprendre l’application source -> solution, avec et sans parametre.

    • unet_time_stepper_from_fem.py: U-Net as a learned time-stepper: predict :math:u^{n+1} from :math:u^n.

  • graph_based/

    • gnn_jet_advection_diffusion.py: Graph networks on JET: learn u_0 |-> u(T) for an advected, diffused Gaussian.

    • gnn_unet_jet_laplacian.py: A four-level graph U-Net on JET: f |-> u for the Laplacian, GNN and GNO.

    • jet_hierarchy.py: The JET poloidal cross-section as a nested hierarchy of cell graphs.

  • physic_no/

    • laplacian_2d_deep_ritz_unet.py: U-Net physiquement informe sur le laplacien 2D : donnees + Deep Ritz.

    • laplacian_2d_disk_geofno.py: Geo-FNO on a DISK: the reference is FEM, and the deformation is the question.

    • laplacian_2d_strong_residual_fno.py: Physics-informed FNO on the 2D Laplacian: data + a STRONG residual.

  • anti_derivative_data_informed.py: Use a DeepONet to learn the antiderivative operator from dynamical system u’=f on [0,1]

  • anti_derivative_physics_and_data_informed.py: Use a DeepONet to learn the antiderivative operator from dynamical system u’=f on [0,1]

  • anti_derivative_physics_and_data_informed_heterogeneous_data.py: Use a DeepONet to learn the antiderivative operator from dynamical systems u’=f on [0,1]

  • anti_derivative_physics_informed.py: Use a DeepONet to learn the antiderivative operator from dynamical system u’=f on [0,1]

  • laplacian_1d_dg_patchwise_bases.py: (No docstring found)

  • reaction_diffusion_fd.py: Neural Operator Framework — FD solver + RBF decoder

• no_hybride/

  • advection_diffusion_1d_basis_conditioned_by_field.py: The basis is told nothing but the FIELD, sampled on a grid.

  • advection_diffusion_1d_basis_conditioned_by_mu.py: Does a learned basis get better when it is TOLD which PDE it is solving?

  • advection_diffusion_1d_learned_basis.py: NO hybride : le propagateur est un SOLVEUR DG exact, et on apprend la BASE.

  • advection_diffusion_1d_learned_basis_mg.py: Le MÊME cas 1D, mais le propagateur est un MULTIGRILLE. Test de pipeline.

  • learned_basis_variants_1d.py: Quatre FORMES d’enrichissement pour la base d’un NO hybride, sur le cas dur.

  • mg_learned_basis_2levels_1d.py: Un multigrille DEUX NIVEAUX monté sur l’opérateur RÉEL d’une base apprise.

• ode/

  • adams_bashforth_multistep.py: Validates the explicit Adams-Bashforth multistep flows (AB2, AB3) as

  • degenerate_variational_integrator.py: Validates DegenerateVariationalIntegratorFlow (DVI) as a plain

  • degenerate_variational_integrator_lotka_volterra.py: Validates DegenerateVariationalIntegratorFlow (DVI) on the

  • gradient_flow_learning.py: Learns a metric gradient flow dx/dt = -G grad E(x) from trajectory data.

  • implicit_vs_explicit_euler.py: Integrates a weakly nonlinear (cubic damping) ODE for a batch of decay

  • lotka_volterra_noncanonical.py: Validates NonCanonicalHamiltonianVectorFieldSpace and

  • nonseparable_hamiltonian_symplectic.py: Validates SymplecticEulerFlowNonSep and VerletFlowNonSep (the

  • pendulum_batch_integration.py: Integrates the pendulum ODE for a batch of initial conditions, using

  • pendulum_continuous_flow_fit.py: PINN on the flow of a pendulum ODE: a space-time network, not a solver.

  • pendulum_flow.py: Learns the flow of a pendulum ODE using discrete flow networks (JAX version).

  • pendulum_flow_rollout.py: Learns the flow of a pendulum ODE with multi-step rollout training (JAX version).

  • sir_batch_integration.py: Integrates the SIR epidemic ODE for a batch of initial conditions AND

  • sir_beta_identification.py: Identifies the SIR contact rate beta from data.

• phi_fem/

  • batch_of_geometries.py: phiFEM solved on a BATCH of geometries, parametric and not.

  • batch_of_level_sets.py: A BATCH of level sets, classified in one traced program.

  • classify_cells_and_facets_circle.py: Visualise cell and face classification for a circle level-set on a Cartesian mesh.

  • solve_dirichlet_circle.py: phi-FEM Dirichlet solver on a circular domain — convergence study.

  • solve_dirichlet_circle_galerkin.py: phi-FEM on the Galerkin infrastructure: Krylov, gradient in the level set, batch.

• pinns/

  • inverse_problems/

    • helmholtz_inverse_nu.py: Inverse problem: identify ν in -Δu + νu = f from PDE + data.

  • odes/

    • malthus_equation.py: Solves the 1D ODE: Malthus equation:

  • optimal_transport/

    • density_transport_2d.py: Density-to-density transport — comparison of direct vs Picard MA.

    • density_transport_2d_circle_strong_bc.py: Density-to-density transport on the unit disk — strong BC (post-processing).

    • density_transport_2d_circle_weak_bc.py: Density-to-density transport on the unit disk — weak BC (Neumann).

    • density_transport_2d_composed.py: Density transport via composition of two OT maps: T = ∇u₂ ∘ ∇u₁.

    • density_transport_2d_strong_bc.py: Density-to-density transport — strong BC via boundary post-processing.

  • stationary_pdes/

    • elliptic_pdes/

      • bi_material_electrostatic_2d.py: Solves the electrostatics equation in 2D on a bi-material domain using PINNs.

      • grad_shafranov_2d.py: Simplified Grad-Shafranov PINN on a D-shaped tokamak cross-section.

      • grad_shafranov_with_xpoints.py: Grad-Shafranov PINN on a real tokamak cross-section (JET / MAST) with X-points.

      • helmholtz_2d_square_with_features.py: Solves a 2D parametric Helmholtz PDE with a periodic embedding.

      • laplacian_2d_disk_parametric_dirichlet_neumann.py: Solves a 2D Poisson PDE with Dirichlet and Neumann BCs using PINNs.

      • laplacian_2d_fish.py: Solves a 2D Poisson PDE with Dirichlet boundary conditions using PINNs and FEM.

      • laplacian_2d_square.py: Solves a 2D Poisson PDE with Dirichlet boundary conditions using PINNs.

      • laplacian_2d_square_parametric_dirichlet_neumann.py: Solves a 2D Poisson PDE with Dirichlet and Neumann BCs using PINNs.

      • laplacian_4d_hypercube.py: Solves a 4D Poisson PDE with Dirichlet boundary conditions using PINNs.

      • magnetostatic_2d.py: Solves a 2D magnetostatic problem using PINNs.

      • magnetostatic_2d_tri_material.py: Solves a 2D magnetostatic problem with 3 materials using PINNs.

      • magnetostatic_2d_without_interface.py: Magnetostatic PINN with explicit lifting — zero interface loss.

      • poisson_2d_cylindrical.py: Solves a 2D Poisson PDE written directly in cylindrical (polar) coordinates.

      • poisson_3d_axisymmetric.py: Solves a 3D Poisson PDE written directly in axisymmetric coordinates.

      • reaction_diffusion_2d.py: Solves a 2D reaction-diffusion PDE with adaptive ENG matrix regularization.

    • elliptic_systems/

      • navier_stokes_2d_cylinder.py: Stationary Navier-Stokes flow around a cylinder in a rectangular channel.

      • navier_stokes_2d_lid_driven.py: Lid-driven cavity flow (stationary Navier-Stokes, Re=100).

      • navier_stokes_2d_NS2d-C.py: Solves the 2d Navier Stokes Equations described in

      • navier_stokes_2d_square.py: Stationary Boussinesq NS in a differentially heated square cavity.

  • time_dependent_pdes/

    • dispersive_systems/

      • kdv_1d.py: Solves the Korteweg–De Vries (KdV) equation in 1D using a PINN.

    • hyperbolic_pdes/

      • transport_2d.py: Transport of a Gaussian pulse in 2D with a PINN, using a relu4 output activation.

    • hyperbolic_systems/

      • linearized_euler_1d.py: Solves the linearized Euler equations in 1D using a PINN.

      • linearized_euler_1d_strong_bc.py: Solves the linearized Euler equations in 1D using a PINN.

      • wave_nd.py: Solves the wave equation in 2D using a PINN.

    • parabolic_pdes/

      • allen_cahn_1d.py: Solves the Allen–Cahn equation in 1D using a PINN.

      • heat_1d.py: Solves the heat equation in 1D using a PINN.

      • heat_1d_strong_bc_strong_ic.py: Solves the heat equation in 1D using a PINN.

      • heat_1d_variable_diffusion.py: Solves a 1D heat equation with a varying diffusion coefficient using a PINN.

      • heat_2d_cylindrical.py: Solves the heat equation written directly in cylindrical (polar) coordinates.

      • heat_3d_axisymmetric.py: Solves the heat equation written directly in axisymmetric coordinates.

      • heat_nd.py: Solves the heat equation in 1D using a PINN.

      • viscous_burgers_1d.py: Solves the viscous Burgers advection equation in 1D using a PINN.

      • viscous_burgers_1d_with_source.py: Solves the viscous Burgers advection equation in 1D using a PINN.

    • parabolic_systems/

      • gray_scott_2d.py: Gray-Scott reaction-diffusion system in 2D with periodic BCs — time-marching.

      • navier_stokes_2d.py: Solves the Navier-Stokes equations in 2D using a PINN.

• projection/

  • linearized_euler_exact_sol.py: Learns the exact solution of a linearized Euler equation in 1D.

  • linearized_euler_exact_sol_from_data.py: Learns the solution of a linearized Euler equation in 1D from data.

  • projection_with_features.py: Learns the exact solution of a linearized Euler equation in 1D.

  • transport_t1x1v.py: Learns the initial condition of a transport equation in 1D.

• time_discrete_neural_methods/

  • discrete_pinns/

    • advanced_examples/

      • euler_2d_double_shear_layer.py: Solves the 2D isentropic incompressible Euler equations (vorticity-streamfunction

      • euler_2d_double_shear_layer_post_process.py: Post-processing companion to euler_2d_double_shear_layer.py.

    • 1d_advection_imex.py: Solves the advection equation in 1D using a discrete PINN.

    • 1d_euler.py: Solves the 1D full Euler equations with a discrete PINN on Sod’s test case.

    • 1d_heat_variable_diffusion.py: Solves a 1D heat equation with varying diffusion using a discrete PINN.

    • 1d_viscous_burgers_with_source.py: Solves the viscous Burgers advection equation in 1D using a discrete PINN.

    • 2d_anisotropic_diffusion_tokamak_jet.py: Anisotropic diffusion in the JET tokamak, solved with a time-discrete PINN.

    • 2d_anisotropic_diffusion_tokamak_mast.py: Anisotropic diffusion in the MAST tokamak, solved with a time-discrete PINN.

    • 2d_multiscale_euler.py: Solves the 2D compressible Euler equations with a discrete PINN.

    • nd_heat.py: Solves the heat equation in nD using a discrete PINN.

  • neural_sl/

    • advanced_examples/

      • euler_2d_double_shear_layer.py: Solves the 2D isentropic incompressible Euler equations (vorticity-streamfunction

      • euler_2d_double_shear_layer_post_process.py: Post-processing companion to euler_2d_double_shear_layer.py.

      • vlasov_poisson_1d_1v_bump_on_tail.py: Solves the Vlasov-Poisson bump-on-tail instability in 1D-1V using the

    • advection_1d_periodic.py: Solves the advection equation in 1D using Neural Semi-Lagrangian (NSL).

    • advection_1d_periodic_parametric.py: Solves the advection equation in 1D using Neural Semi-Lagrangian (NSL) with a parameter (advection speed).

    • advection_2d_disk.py: Solves the advection equation in 2D using Neural Semi-Lagrangian (NSL).

    • advection_diffusion_1d.py: Verifies “heun”’s higher weak order against “directionwise”/“euler_maruyama”.

    • advection_diffusion_1d_1v.py: Shows the effect of “x”- and “v”-diffusion on a 1D-1V phase-space problem.

    • advection_diffusion_2d.py: Compares NSL’s diffusion strategies on a 2D advection-diffusion equation.

    • advection_diffusion_nd.py: Solves an n-D advection-diffusion equation using Neural Semi-Lagrangian (NSL).

    • advection_reaction_1d.py: Verifies “strang”’s higher splitting order against “lie” for NSL reaction terms.

    • linear_vlasov_1d_1v.py: Solves the Vlasov equation on a periodic square using Neural Semi-Lagrangian.

• vf/

  • hyperbolic/

    • burgers_1d.py: Burgers 1D in finite volume: Rusanov, HLL and exact Godunov fluxes.

    • euler_cylindrical_explosion_2d.py: Cylindrical explosion in 2D: the same four Euler fluxes as the 1D shock tube.

    • euler_naca0012_2d.py: Steady Euler flow around a NACA0012 airfoil, first-order FV on a Gmsh mesh.

    • euler_sod_1d.py: Sod’s shock tube in finite volume: Rusanov, HLL, HLLC and Roe on one plot.

    • transport_rotating_gaussian_2d.py: Upwind P0 finite-volume transport of a Gaussian over one quarter turn.

  • elliptic_1d.py: Cell-centred finite volume for -u'' = 1 on [0, 1].

  • elliptic_2d.py: Cell-centred finite volume for a 2D Dirichlet Poisson problem.