C++ Code Generation

Generate optimized C++ code for production deployment.

Features

  • Zero-copy state vectors: Eigen arrays with memory alignment

  • Compile-time parameters: Constants inlined for optimization

  • Template metaprogramming: Type-safe, efficient code

  • Multiple integrators: RK4, RK45, Velocity Verlet

Basic C++ Generation

compiler = PhysicsCompiler()
compiler.compile_dsl(source)

# Generate standard C++ (single-threaded)
compiler.compile_to_cpp("simulation.cpp", target="standard")

The target parameter options:

  • "standard": Single-threaded, portable C++17

  • "openmp": Multi-threaded with OpenMP pragmas

  • "simd": Explicit SIMD vectorization hints

OpenMP Parallelization

For systems with many particles (SPH) or many bodies (N-body):

compiler.compile_to_cpp("simulation.cpp", target="openmp")

Generated code includes:

#pragma omp parallel for
for (int i = 0; i < N; ++i) {
    compute_forces(particles[i]);
}

Compile with OpenMP support:

g++ -O3 -fopenmp simulation.cpp -o simulation

SPH Fluid Code

Fluid simulations generate specialized SPH code:

fluid_code = r'''
\system{dam_break}
\parameter{h}{0.04}{m}
\fluid{water}
\region{rectangle}{x=0..0.4, y=0..0.8}
\boundary{walls}
\region{line}{x=-0.05, y=0..1.5}
'''

compiler.compile_dsl(fluid_code)
compiler.compile_to_cpp("dam_break.cpp", target="standard", compile_binary=True)

The generated SPH code includes:

  1. Particle structure: Position, velocity, density, pressure

  2. Spatial hash grid: O(N) neighbor finding

  3. Kernel functions: Poly6, Spiky gradient

  4. Velocity Verlet: Symplectic time integration

  5. CSV output: Frame-by-frame particle data

Manual Compilation

If compile_binary=False, compile manually:

# Linux/macOS
g++ -O3 -std=c++17 dam_break.cpp -o dam_break
./dam_break

# Windows (MSVC)
cl /O2 /std:c++17 dam_break.cpp
dam_break.exe

The simulation outputs dam_break_sph.csv for visualization.

Customizing Generated Code

Override integrator settings:

compiler.compile_to_cpp(
    "simulation.cpp",
    target="standard",
    dt=0.001,           # Time step
    t_end=10.0,         # End time
    output_interval=100  # Write every N steps
)

Benchmarks

Typical speedups vs Python (scipy.integrate.solve_ivp):

System

Python (s)

C++ (s)

Speedup

Simple pendulum (10s)

0.05

0.001

50x

Double pendulum (100s)

2.1

0.08

26x

3-body (100s)

5.3

0.15

35x

SPH 1000 particles (2s)

N/A

4.2

N/A

Troubleshooting

Compilation errors:

  1. Ensure C++17 support: g++ --version (need 7+)

  2. Check Eigen is installed or in include path

  3. On Windows, use Developer Command Prompt for MSVC

Runtime errors:

  1. Check for NaN in output (divergent simulation)

  2. Reduce time step if unstable

  3. Verify initial conditions are physical