This changelog only includes the most important changes in recent updates. For a full log of all changes, please refer to git.
- Fixes another bug int he BS integrator when additional forces are used.
- Two bugs fixed in the BS integrator. One was related to unitialized memory and the other to issues when the particle number changed.
- Workaround for urllib support in pyodide added
- Silent warning when InterruptiblePool is not available
- InterruptiblePool is optional.
- Fixed an issue that occured when switching integrators while using the SimulationArchive.
- Renamed
srand_seedto make it user accessible.
- Added several examples.
- Changed how pypi is rendering the documentation.
- Fixes a bug relates to test particles of type 0 in MERCURIUS.
- Some compilers seem to complain that a constant cannot be initialized from a constant. Fixed this so that REBOUND works on colaboratory.
- Added a Gragg-Bulirsch-Stoer integrator (short BS for Bulirsch-Stoer). This is an adaptive integrator which uses Richardson extrapolation and the modified midpoint method to obtain solutions to ordinary differential equations. The version in REBOUND is based on the method described in Hairer, Norsett, and Wanner 1993 (see section II.9, page 224ff).
- Added the ability to integrate arbitrary ordinary differential equations with REBOUND. The ODEs can be couple to the N-body simulation. This can be used to simulate spin, tides, and other physical effects. The user-defined ODEs are integrated with the new BS integrator.
- Various improvements and fixes relates to NASA Horizons: small bodies are retrieved correctly, the dates now work with fractional JD values and dates in the format YYYY-MM-DD HH:MM:SS are now supported.
- Fixes an issue in the SimulationArchive that prevented REBOUND from seeing more than one snapshot. This only affected simulations with a large number of particles.
- REBOUND will now uses the new HTTP API from NASA Horizons. This is significantly faster than the old telnet version. Thanks to Lukas Winkler for implementing this.
- REBOUND will now attempt to recover binary files and SimulationArchives which have been corrupted. Simulations can be restarted from corrupt files and in most cases the corrupt files will fix themselves.
- Allow for Horizon queries with future JD dates.
- Moved some function declarations to rebound.h. This is a temporary fix for REBOUNDx.
- Fixed an issue where the simulation struct in python did not match the one in C. This might have lead to unexpected behaviour in rare cases.
- Fixed various typos in the documentation
- MERCURIUS switching functions can now be set from Python. Also inluded more built-in switching functions from Hernandez (2019).
- Added new 'reb_add_fmt()' function. This makes adding particles in C as easy as in python.
- Orbits can now also be initialized using the eccentric anomaly.
- Fixed an issue which prevented one loop in the gravity routine form being parallelized with OpenMP.
- Added a warning message when test particles have finite mass.
- More reliable reading of corrupt SimulationArchive files.
- MERCURIUS: If encounters only involve test-particles (type 0), then the algorithm is now resetting the coordinates of all massive particles after the encounter step. This only changes the outcome at the machine precision, but it makes the trajectories of massive particles independent of the close encounter history. Thanks to Kat Deck for this feature!
- MERCURIUS: The gravity routine is now
$O(0.5 \cdot N^2)$ instead of$O(N^2)$ for non-OPENMP runs. This should lead to a noticable improvement in runtime.
- Orbital parameters of particles can now be changed in-place. For example: 'sim.particles[1].e += 0.1'.
- Implemented more chatty repr functions for most object. Printing REBOUND objects should now give some useful information.
- Improved support for adding/removing particle in MERCURIUS during collisions.
- REBOUND now outputs an error message when one is trying to remove a particle with a negative index.
- Small updates to the documentation.
- New ipython example added, showing how to use a python collision resolve function.
- Due to a bug, WHFast was not thread-safe. It is now.
- Random number generator seed is now stored in the SimulationArchive. This allows you to get reproducible random number even after restarting a simulation.
- Random numbers generated with the
reb_rand_*()functions were not thread-safe. They are thread-safe now. Note that this required an API change. Allreb_rand_*()functions now require the simulation structure as an argument. This is because the random number generator seed is now stored in the simulation structure.
- Correct handling of test particles in reb_transformations.
- Small bug fixes
- WHFast: Fixes multiple issues with testparticles in WHFast.
- IAS15: Fixes a bug which leads to a biased energy error in long term integrations with fixed timesteps (see Hernandez and Holman 2020). The old version of IAS15 can still be used for the time being by setting ri_ias15.neworder=0.
- IAS15: Does not take variational particles into account when predicting new timesteps. This should be beneficial during close encounters.
- A few improvements have been made to the SimulationArchives code including a more efficient loading procedure for large datasets.
- Various small bug fixes
- Added a new function sim.cite() to automatically generate citations depending on the current simulation settings.
- Various bug fixes to MERCURIUS
- Performance increase when using the BASIC Gravity Routine with OpenMP
- Bug fixes to LINE and LINETREE algorithms
- Added LINETREE collision search algorithm. This algorithm uses a tree to check if any two particle trajectories overlapped during the last timestep. This should be beneficial in large N, low density situation as it allows for much larger timesteps. A modification of the collision resolve routine might be necessary to allow for multiple collisions of the same particle during one timestep. This depends on the application and the default is to only allow one collision per timestep.
- Added support for test particles and first-order variational particles to the Embedded Operator Splitting (EOS).
- BASIC Gravity routine changed from O(N^2) to O(0.5 N^2). This should lead to a speed-up in most cases but will break bit-wise reproducibility from earlier versions as the ordering of floating point operations has changed.
- This version adds the new Embedded Operator Splitting methods from Rein (2019). See the tutorial in the ipython_examples folder for how to use them.
- Updates to OrbitPlot. Includes better layout of plot and some syntax changes. See OrbitPlot documentation for the new syntax.
- Small syntax changes for SABA integrator family.
- Includes high order integrators by Blanes et al. (2013).
- Changes for the new version of REBOUNDx.
- Added new high order symplectic integrators from Wisdom et al. (1996) and Laskar & Robutel (2001). The implementation of these integrators are discussed in Rein, Tamayo & Brown (2019).
- Implemented new bit-wise comparison functions for simulations. Python syntax is simply sim1==sim2.
- Fixed a bug in IAS15 which prevented a restarted simulation to reproduce the original simulation exactly.
- Improves and fixes various issues related to variational equations and MEGNO.
- Fixes a bug which resulted in duplicate snapshots in SimulationArchives when restarting simulations.
-
Syntax change on the python side to create a simulation from a binary file or SimulationArchive:
rebound.Simulation.from_file("test.bin") becomes rebound.Simulation("test.bin") rebound.Simulation.from_archive("test.bin",5) becomes rebound.Simulation("test.bin",5)
- The hybrid integrator MERCURIUS has been completely rewritten. It can now much more easily be used in simulations where physical collisions occur. There are no more hidden particle arrays in the background, meaning adding and removing particles can occur in the same way as for other integrators. It also works reliably with any additional forces.
- The old hybrid integrator HERMES has been removed. MERCURIUS should always be equal or better in performance and accuracy.
- Added getBezierPaths to SimulationArchive to allow for easy plotting of complicated trajectories. To do this, store a lot of snapshots in the SimulationArchive (several per orbit!).
- Added functionality to add, subtract, multiply and divide simulations. This might be useful when developing new algorithms, but is most likely not useful for most users.
- Added a deep copy functionality: reb_copy_simulation() in C, and sim.copy() in python.
- Refactored WHFast to enable calling only certain substeps.
- Added the rhill property to reb_orbit in C and the Orbit and Particle classes in Python. This parameter corresponds to the circular Hill radius of the particle: $ a (m/(3M)^{1/3}$.
- Fixes an issue related to collisions and the Mercurius integrator that prevented the lastcollision property to be updated.
- New: Fancy plotting routine. Usage: rebound.OrbitPlot(sim, fancy=True)
- One can now add particles from NASA Horizons using Julian Days. For example: sim.add("Earth", date="JD2458327.500000")
- Fixes a memory leak when using the old SimulationArchive version. Thanks to Ian Rabago for reporting the issue.
- Fixes a memory leak in the SimulationArchive read function.
- Removed function calls to open_memstream and fmemopen which might not work on older Mac OSX versions. This only affects the internals and there are no changes to user interface.
- Minor bug fixes
- SimulationArchive Version 2. With the new version of the SimulationArchive file format, you can now create snapshots of your simulations without any restrictions. You can change the number of particles, the timestep, even the integrator used during the integration. REBOUND automatically detects what has changed and only stores the differences in incremental snaphots. This reduces the filesize while keeping the format as flexible as possible. The old SimulationArchive Version 1 is still supported for now but might become deprecated in the future. All examples have been updated. As usual these are as usual good starting points for understanding the functionality and the syntax.
- Added REB_COLLISION_LINE. This is a collision detection routine which serves for collisions during the last timestep, assuming that all particles travel along straight lines. This can be useful in cases where not every collision needs to be detected exactly, but the overall collision rate should be reproduced. The algorithm is O(N**2).
- Bug related to N_active and variational particles has been fixed.
- A bug where WHFast might not converge in rare cases involving negative timesteps has been fixed.
- Changed default collision behaviour from hardsphere bouncing to halting the simulation. An exception is raised when using the python version. In C, you need to check the status flag after integrating the simulation.
- Refactored OrbitPlot.
- SIGINT handler added. Allows for garceful exit and keyboard interrupts (even from python).
- WebGL widget text overlay added.
- Bug fixes related to WebGL widget and ipywidgets version 6
- Updated WebGL widget to work with ipywidgets version 7
- Various fixed for Mercurius
- Bug fix for N_active=-1 (default)
- Allow for better parallelization of WHFast with OpenMP.
- Addded example of the Solar System with Testparticles.
- Made simulationarchive_append a public function (might be useful for some hacking projects).
- Fixes an issue with the WebGL widget.
- Fixes an issue with external forces and MERCURIUS.
- MERCURIUS is not compatible with binary files and the SimulationArchive.
- The WHFast integrator now supports Jacobi coordinates (default), democratic heliocentric coordinates and WHDS coordinates. The previously separate WHFastHelio integrator has been removed. The coordinate system can now be changed by simply setting the coordinates flag in the ri_whfast struct.
- Included an experimental new integrator MERCURIUS. This is similar to the hybrid integrator in Mercury but uses WHFast and IAS15. Not ready for production yet.
- Added a screenshot functionality for the WebGL ipython widget. This lets you take screenshots programmatically which is useful to create movies of simulations.
- Removed the march=native compiler flag as it seems to be problematic for some OSX/Sierra compilers.
- JANUS integrator added. This is a bit-wise reversible high-order symplectic integrator. At this time, it remains experimental. Details about this integrator will be published in an upcoming paper.
- Changes to the WHFastHelio integrator. This integrator now uses democratic heliocentric coordinates and a Hamiltonian splitted as proposed by Hernandez and Dehnen (2017), WHDS, which splits the Hamiltonian into three parts. It has the advantage that the integrator solves the two body problem exactly. It is not compatible with symplectic correctors, this functionality has been removed for WHFastHelio. For very high accuracy integrations of stable planetary systems, the WHFast integrator in Jacobi coordinated (and potentially symplectic correctors) should be better suited.
- Various minor bug fixes. Added pre-timestep modifications for REBOUNDx.
- Various minor bug fixes. One related to exact_finish_time=1.
- Added real-time interactive 3D visualizations using WebGL for Jupyter notebooks. This is an early release. Not everything might be working yet and new feature will be added to the widget class. To try it out, simply run
sim.getWidget()in a Jupyter notebook. Note that you need to have ipywidgets installed and enabled. - Minor changes to the Visualization backend. This should not have any consequences for users.
- Now stores the first characters of the current githash in binary files. This is helpful when trying to restart simulations from a binary file and making sure one uses the same version of REBOUND than in the original run. Currently, the git hash is not automatically compared when reloading a binary file. To view the githash, use e.g. hexdump. The hash appears between the first and second zero character in the first 64 bytes of the file.
- Updated visualization. REBOUND now uses a modern version of OpenGL (3.3) that allows for custom shaders and therefore better looking visualizations. However, REBOUND now requires glfw3 to compile the visualization module. If you are on a Mac, then the easiest way to install the glfw3 library is with homebrew:
brew tap homebrew/versions && brew install glfw3. If you are on Linux, you can install it with your package manager, for example withsudo apt-get install libglfw3-dev.
- Introducing the Simulation Archive. The Simulation Archive allows for exact (bit-by-bit) reproducibility in N-body simulations and a completely new way of analyzing simulations. See Rein&Tamayo (2017) for details.
- The binary format has changed. Binary files created with an earlier version of REBOUND can not be loaded with this version. However, future binary files will be backwards compatible from this point forward.
- Minor bug fixes in HERMES integrator and some examples.
- NASA Horizons changed a telnet command. This update implements those changes and restores access to NASA Horizons from within REBOUND.
- Improvements to the Kepler solver. This is typically only relevant for extremly long simulation (1e11 timesteps or more) and extremely accurate simulation with symplectic correctors and a relative energy error of less than 1e-10.
- Small changes to HERMES integrator. It now has a Solar Switch Factor SSF to allow for close encounters with the central object.
- Added adaptive HSF for HERMES integrator. More documentation and paper to follow.
- Added symplectic correctors for WHFastHelio integrator. See Wisdom (2006).
- Improved accuracy of symplectic corrector coefficients for WHFast and WHFastHelio.
- Added new WHFastHelio integrator. This integrator uses the WHFast Kepler solver, but uses democratic heliocentric coordinates (WHFast itself uses Jacobi coordinates). Heliocentric coordinates are advantages if planets swap positions.
- Changes to how particle hashes are handled.
- This version removes the old SWIFTER based Wisdom-Holman routine, INTEGRATOR_WH. It wasn't working correctly for a while and the WHFast (INTEGRATOR_WHFAST) should be superior in any possible case we can think of.
-
Added warning/error message system. This allows warning messages to be shown directly in iPython/python programs, rather than being shown on the console. To hide the warning messages, use a filter, e.g. .. code:: python
with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") # Execute a command which triggers a warning message. # The message will not show up.
-
Improvements regarding the WHFast logic for hyperbolic orbis. No changes should be noticeable to users.
-
Added the reb_serialize_particle_data function for fast access to particle data via numpy array. The full syntax is explained in the documentation. Here is a short example: .. code:: python
import numpy as np a = np.zeros((sim.N,3),dtype="float64") sim.serialize_particle_data(xyz=a) print(a)
- When loading a simulation from a binary file, REBOUND now checks if the version of the binary file is the same as the current version.
- When saving a simulation to a binary file, all the auxiliary arrays for IAS15 are now stored. This allows for bit-by-bit reproducibility in simulations that are making use of checkpoints.
- We replaced the old HYBRID integrator with the new and better HERMES integrator. Details of the HERMES integrator will be explained in an upcoming paper Silburt et al (2016, in prep).
-
What used to be called
idin the particle structure is now calledhash. This can be used to uniquely identify particles in a simulation. In many cases, one can just identify particles by their position in the particle array, e.g. usingsim.particles[5]. However, in cases where particles might get reordered in the particle array (e.g. when using a tree code), when particles can merge (by using thecollision_resolve_mergeroutine), or when particles get added or removed manually. -
The syntax is as follows: .. code:: python
sim = rebound.Simulation() sim.add(m=1) sim.add(m=1e-3,a=1)
sim.particles[1].hash = "planet1"
p = sim.get_particle_by_hash("planet1")
sim.particles[1].hash = sim.generate_unique_hash()
uhash = sim.particles[1].hash
p = sim.get_particle_by_hash(uhash)
- We made many changes to the code. Most importantly, REBOUND is now thread-safe and does not use global variables anymore. All the variables that were previously global, are now contained in the
reb_simulationstructure. This has many advantages, for example, you can run separate simulations in parallel from within one process. - We also made it possible to choose all modules at runtime (compared to the selection in the
Makefilethat was used before). This is much more in line with standard UNIX coding practice and does not severely impact performance (it might even help making REBOUND a tiny bit faster). This makes REBOUND a fully functional shared library. We added a prefix to all public functions and struct definitions:reb_. - There are still some features that haven't been fully ported. Most importantly, the MPI parallelization and the SWEEP collision detection routine.
- The best way to get an idea of the changes we made is to look at some of the example problems and the new REBOUND documentation. If you have trouble using the new version or find a bug, please submit an issue or a pull request on github.