Project 17: WavePINN Demo: From Discrete Simulation to a Continuous Field

Project code: projects/17-wavepinn-nif__project-space

This project is best understood as a three-step story:

Without my PINN: a reference wave simulation exists as discrete field samples over time.
With my PINN: the dynamics are learned as a continuous function u(x, z, t).
Final Taichi demo: that learned field is resampled onto a fixed-topology surface and presented as a polished real-time render.

The important point is not that the final video looks nicer. The important point is that the representation of the simulation changes. A traditional solver gives you a grid of states. The WavePINN gives you a callable field.

Without My PINN vs With My PINN

The comparison that matters is not "old version vs new version." It is "non-neural reference field vs learned surrogate field."

Without My PINN Reference / baseline wavefield sampled directly from the solver.	With My PINN Trained WavePINN output for the same phenomenon over the same time window.

The left side is the target. The right side is the learned surrogate. What matters is that the learned model is not producing plausible-looking noise. It is preserving recognizable wave fronts and propagation timing strongly enough to stay faithful to the reference dynamics.

Why This Matters

Here is the strongest way to frame the project:

This work replaces a discrete wave simulation with a continuous neural field that can be queried at arbitrary space-time coordinates, then rendered in real time as a stable surface demo.

That matters for a few reasons.

1. A simulation becomes a function

Classical wave solvers give you discrete snapshots on a fixed grid. You run the solver, store the outputs, and then work with those samples. The WavePINN instead learns u(x, z, t) directly. That means the result is no longer just a sequence of states. It is a callable field.

This is the core representation shift in the project:

without the PINN, the simulation is a stored sequence
with the PINN, the simulation becomes a reusable function

That is not a cosmetic improvement. It changes what can be done with the result.

2. The numbers show it is fitting structure, not noise

The learned model is not being judged by appearance alone.

PSNR: 34.81 dB
MSE: 3.30e-4
MAE: 0.0142
Relative L2: 0.349

Those values show that the network is approximating the reference field with enough fidelity to preserve front shape and temporal structure. The point of the metrics is not decoration. The point is to demonstrate that the learned field remains physically coherent enough to trust as a surrogate.

3. One checkpoint drives the whole pipeline

One trained .pt file now drives:

validation plots
motion assets
the final Taichi surface demo
future interactive sampling tools

That is the underrated architectural win here. The learning step and the presentation step are decoupled. Once the field is learned, the same representation can be resampled, re-rendered, and repackaged without rerunning the original simulation pipeline.

4. Simulation and rendering are no longer tied together

In a traditional workflow, simulation resolution and render resolution are tightly coupled. With the WavePINN, rendering becomes a sampling problem. The learned field can be queried at whatever grid resolution is useful for validation, visualization, or interaction.

That is what enables the Taichi demo to exist as a clean endpoint instead of a brittle export trick.

5. The Taichi demo closes the loop

The final surface render is not just presentation polish. It is evidence that the learned field is stable enough to be remapped onto geometry and played back in a real-time viewer. If the learned field were noisy or temporally incoherent, the surface would expose that immediately.

So the Taichi demo is doing more than looking good. It is validating that the learned representation survives contact with a more demanding presentation layer.

Final Taichi Demo

The final presentation path samples the learned field on a regular x-z grid, maps amplitude to vertical displacement, and renders it as one fixed-topology surface in Taichi GGUI.

It matters because it demonstrates the full pipeline:

reference solver -> learned surrogate -> continuous resampling -> real-time presentation

And it does that in a way that reads clearly to both technical and non-technical viewers.

Taichi presets

Research

Research Taichi preset

Pitch

Dramatic

Dramatic Taichi preset

The Bigger Picture

Physics-informed neural networks matter because simulation is expensive, discrete, and often hard to repurpose once it has been run. This project shows a more useful workflow:

generate a trustworthy reference field
learn a compact continuous surrogate
resample it arbitrarily
present it interactively or offline from the same checkpoint

That is why this project is more than a visualization exercise. The neural representation is the actual product of the pipeline. The demo is proof that it works.

What Would Make This More Realistic

The current result is strong as a continuous wavefield surrogate demo, but it is still not the strongest possible version of a realistic learned wave system.

The main realism limit is that the learned field is still tied to a fairly clean, controlled reference process and a presentation pipeline that deliberately smooths and bounds the surface so the result reads clearly. That is the right choice for a demo, but it also means there is still headroom between “convincing technical field demo” and “fully rich wave simulation surrogate.”

Realism has to improve across the whole stack

For this project, realism is not just about making the Taichi surface prettier. It depends on several layers at once:

Reference physics: the target field needs rich, physically meaningful behavior.
Field representation: the model needs to preserve phase, amplitude, and fine structure without collapsing into blur or speckle.
Temporal fidelity: the learned field needs to stay coherent across time, not just fit isolated snapshots.
Sampling and resampling: the continuous-field promise has to hold up when queried away from the exact training grid.
Presentation: the final surface should reveal the learned structure, not hide weak structure behind styling.

If any one of those layers is weak, the whole result reads as weaker than it really is. A good-looking surface cannot rescue a noisy field. A clean field that is only valid on one fixed sampling grid does not fully cash out the continuous-field claim.

1. Make the reference process physically richer

The learned model can only be as physically rich as the reference process it is trained against.

To make this project more realistic overall, the baseline wave process could be improved with:

more varied source conditions
stronger boundary-condition diversity
heterogeneous media
richer damping regimes
multi-source interference cases
obstacle or reflection cases

That would make the learned field approximate something closer to a broader class of real wave behavior instead of one relatively clean family of reference fields.

2. Preserve sharper spatial and temporal structure

The current model is already coherent, but it still leaves some headroom in fine-scale detail and high-frequency structure.

The next realism gains would likely come from:

better phase preservation
sharper crest and trough structure
less residual speckle in the learned field
stronger fidelity on rapid temporal changes

That could be improved with:

richer Fourier-feature or multiscale conditioning
more explicit supervision on spatial derivatives
losses that care about phase alignment, not only amplitude error
hybrid objectives combining supervised fit with physics residual structure

This matters because wavefields often look “almost right” numerically while still feeling slightly too soft or slightly too noisy when mapped onto a surface.

3. Strengthen the continuous-field claim directly

One of the most important promises of the project is that the learned object is a function u(x, z, t), not just a cache of frames.

That claim becomes more realistic and more meaningful when it is tested more aggressively:

query at unseen times
query at finer spatial grids
render at multiple resolutions
evaluate interpolation quality between training samples
test whether the field remains coherent under off-grid sampling

That would move the project from “a model that fits a training lattice well” to “a field representation that really behaves continuously.”

4. Improve longer-horizon temporal coherence

The current Taichi demo is convincing because the learned field is stable enough to survive a real-time surface viewer. That already matters.

But if I wanted the result to feel more realistic in a deeper sense, I would push further on:

phase stability over longer time windows
amplitude consistency
reduction of temporal speckle
stronger agreement of propagation timing

This is especially important because waves are unforgiving. A field can look good in stills and still feel subtly wrong once it is played as a surface over time.

5. Make the final surface closer to physical intuition

The viewer is already doing the right kind of restrained presentation work, but realism could still improve further with:

more carefully tuned height transfer
better amplitude calibration between field values and surface displacement
more physically intuitive signed coloring
slightly richer shading and normals
clearer relation between reference field amplitude and displayed geometry

Again, this should stay downstream of the learned field itself. Better rendering should help reveal the physics, not substitute for it.

If I compress the realism roadmap to one line, it is this:

The path to a more realistic WavePINN is richer reference physics, sharper field fidelity, stronger off-grid continuity, and only then more polished surface presentation.

What Would Improve The Project Overall

If I step back from realism alone and ask what would make this a stronger project overall, the answer is broader than “make the wave look nicer.”

The core center of gravity here is representation shift. The project matters because it turns a discrete simulation into a callable field. So the best improvements are the ones that make that shift more rigorous, more useful, and more obviously valuable.

1. Prove the continuous-field claim more aggressively

The single most important project improvement would be to show that the model is useful specifically because it is a field, not just because it fits a known grid well.

That means adding demonstrations like:

low-resolution vs high-resolution resampling from the same checkpoint
intermediate-time sampling between known steps
arbitrary camera or mesh resolutions from the same field
derivative or gradient queries

That would make the representation shift much more tangible.

2. Expand the evaluation beyond scalar fit metrics

The current metrics are good and important, but the project would be stronger with a broader evaluation lens.

Useful additions would include:

phase error
amplitude error
arrival-time error
energy-like summaries
off-grid interpolation tests
resolution-transfer tests

That would help show not only that the field is close numerically, but that it behaves correctly in the ways that matter for waves.

3. Add ablations that explain what is doing the real work

The project would become more defensible if it showed which ingredients matter most.

For example:

plain MLP vs Fourier features
supervised-only vs hybrid physics-informed losses
different training window sizes
different sampling densities
with and without display smoothing in Taichi

That would sharpen the project from “strong demo” into “clear technical result.”

4. Build out the query and tooling story

This project becomes much more valuable when the learned field is treated as a real reusable artifact.

That means better downstream tools such as:

a simple field-query CLI
gradient or slice extraction utilities
arbitrary-resolution export helpers
interactive sampling examples
compact deployment benchmarks

Those would make the field feel like a product-grade object rather than only a training outcome.

5. Connect the representation shift to concrete use cases

The “who cares?” question lands harder when the project is attached to real workflows.

For example:

scientific visualization
simulation compression
fast preview rendering
digital twins
interactive educational tools
future inverse or control tasks built on the same field

That is where the project moves from “nice PINN demo” to “useful learned simulation object.”

6. Turn the post itself into a stronger technical artifact

The writeup could carry more of the technical argument directly.

To make the post stronger, I would add:

one explicit representation-shift diagram
one resampling demonstration
one off-grid or intermediate-time example
one compact methodology note on the final supervised path
one short failure or limitation strip

That would make the page more self-contained and much more persuasive to a skeptical reader.

the reference process is still relatively controlled and clean
the learned field still leaves some headroom in fine-scale detail and temporal crispness
the final Taichi demo uses restrained smoothing and bounded height transfer to keep the surface readable
the strongest evidence is still on the specific learned field showcased here, not yet on a wide family of wave problems

None of those invalidate the project. They just define its current scope honestly.

If I reduce the entire post to one sentence, it is this:

The value is not that the project simulates waves nicely. The value is that it turns the simulation itself into a continuous, reusable object.