High performance numerical platform for Hamiltonian systems

In dedication of scientific endeavours on and applications of explicit symplectic integrators, Zymplectic is an installation free, c/c++ based, high performance scientific computation toolbox that contains the single largest collection of symplectic partioned Runge-Kutta (SPRK) and Runge-Kutta-Nyström (RKN) methods.Zymplectic 0.2.6 - 2020.05.01 | Download links |
---|---|

Documentation | Currently unavailable |

Windows x86-64 | Zymplectic v.0.2.6 win64 gcc Zymplectic v.0.2.6 win64 clang |

Linux x86-64 | Currently unavailable |

See Downloads section for more information

Explicit symplectic integrators (SIs, singular SI) are numerical integration schemes for separable Hamiltonian systems:
$$H=T(p)+V(q)$$
where **H** is the **Hamiltonian** typically associated with the energy of the system. **T** and **V** is typically associated with the **kinetic** and **potential energy** respectively. **p** and **q** denotes the **canonical coordinates** which are often associated with **momentum** and **position** obeying:
$$\dot{p}= -\frac{\partial H}{\partial q}$$
$$\dot{q}= \frac{\partial H}{\partial p}$$
The time evolution of the autonomous and separable Hamiltonian system can be calculated numerically by canonical tranformation of coordinates (**q**_{0},**p**_{0}) → (**q**_{s},**p**_{s}) over the time *τ*:
$$q_i=q_{i - 1} + \tau c_i\frac{\partial T}{\partial p}(p_{i - 1}) $$
$$p_i=p_{i - 1} - \tau d_i\frac{\partial V}{\partial q}(q_i)$$
where **s** is the number of stages equal to the number of **splitting coefficints** **c** or **d**. The accuracy and integration order depends on the choice of the splitting coefficients.
*f* with a smooth second order derivative in the area of integration.

SIs preserve the phase-space volume exactly and counteract dissipation of the initial Hamiltonian as opposed to non-symplectic integrators such as the widely used Runge-Kutta methods. SIs are particularly useful for long-time numerical integration in the fields of celestial mechanics, accelerator physics, molecular dynamics, and quantum chemistry, although symplectic integrators may also be applied for more general or abstract differential equations.

The **leapfrog integrator** (second order) in spite of its poor accuracy is among the most acclaimed SIs, and is often used without the users' awareness of its symplectic properties.

SIs scope of use can be extended to * non-separable systems* where

Zymplectic is vastly different from other ODE-libraries such as GSL or JuliaDiffEq. First of all, the scope of the project is limited to Hamiltonian systems. The bundled binary of Zymplectic does not include a library with numerical methods. Instead Zymplectic is designed to load a file expressing the Hamiltonian system (e.g. TheSolarSystem.cpp), which is interpreted, compiled, loaded and runs the simulation with any desired method or settings optionally set in the graphical user interface. Zymplectic automatically plots relevant data, including simulated objects, the Hamiltonian error and optionally energy surfaces and object tracking.
Users need not to know any large number of functions or calling conventions to make a simulation code, greatly reducing the abstraction of coding aiding the user in expressing advanced Hamiltonian systems.
The c++ files loaded by Zymplectic are macro-augmented to further enhance the ease of use with no negative impact on flexibility or performance.
Zymplectic is fully functional without installation and does not require any IDE or compilers since Zymplectic is bundled with either gcc or clang.
Those who pursue "open source methods" may find it convenient that Zymplectic includes all integrator coefficients and that the program exports a cpp file that includes any selected integration method for the user to compile in his/her own software (currently redacted, will be available later).

Zymplectic includes a large library of high accuracy high order SIs discovered by several authors over the last three decades (see references below - incomplete).

- 1: The Two-body problem
- 2: Trajectories of Hamiltonian systems
- 3: The algorithm (part 1 of 4)
- 4: The quadrupole mass spectrometer
- 5: The Kapitza pendulum
- 6: The double pendulum
- 7: Benchmark: Fifth order integrators
- 8: The bump smoothmap
- 9: The spherical pendulum

Zymplectic is a numerical integration platform intended for scientific and educational purposes.

Zymplectic is a numerical engine for simulating any separable, non-separable, autonomous and non-autonomous Hamiltonian systems.

Zymplectic requires only declarations of the Hamiltonian gradient, initial conditions and and a simple initialization to run. This is done in macro-augmented c++ code, allowing simple declarations of even very complex Hamiltonian systems. A simple but functional implementation of the Hénon-Heiles is shown below

```
const double lambda = 1.0;
double energy_H(Arg) { //Hamiltonian (optional)
double x2 = q1*q1;
double y2 = q2*q2;
return lambda*q2*(x2-y2/3.0) + 0.5*(x2 + y2 + p1*p1 + p2*p2);
}
void dH(Arg) { //Gradient
dq1 = q1 + lambda*2.0*q1*q2;
dq2 = q2 + lambda*(q1*q1 - q2*q2);
dp1 = p1;
dp2 = p2;
}
double _q_init[] = {0.3,0.0}; //initial position
double _p_init[] = {0.0,0.4}; //and momentum
void main() {
Z.H(energy_H,dH,0);
}
```

Each object can also be paired with other objects or assigned to seperate kinetic and potential energies. This allows easy construction of more complicated physical systems with very few lines of code.

Zymplectic's interface includes the GUI control panel, an interactive glut-display window and an output console