Upload 468 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+rebound/source/docs/img/reboundbanner.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+EXPOSE 7860
+
+CMD ["python", "rebound/mcp_output/start_mcp.py"]

README.md

@@ -1,10 +1,32 @@
 ---
-title: Rebound
-emoji: 🌖
+title: Rebound MCP
+emoji: 🤖
 colorFrom: blue
-colorTo: green
+colorTo: purple
 sdk: docker
+sdk_version: "4.26.0"
+app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Rebound MCP Service
+
+Auto-generated MCP service for rebound.
+
+## Usage
+
+```
+https://None-rebound-mcp.hf.space/mcp
+```
+
+## Connect with Cursor
+
+```json
+{
+  "mcpServers": {
+    "rebound": {
+      "url": "https://None-rebound-mcp.hf.space/mcp"
+    }
+  }
+}
+```

app.py

@@ -0,0 +1,45 @@
+from fastapi import FastAPI
+import os
+import sys
+
+mcp_plugin_path = os.path.join(os.path.dirname(__file__), "rebound", "mcp_output", "mcp_plugin")
+sys.path.insert(0, mcp_plugin_path)
+
+app = FastAPI(
+    title="Rebound MCP Service",
+    description="Auto-generated MCP service for rebound",
+    version="1.0.0"
+)
+
+@app.get("/")
+def root():
+    return {
+        "service": "Rebound MCP Service",
+        "version": "1.0.0",
+        "status": "running",
+        "transport": os.environ.get("MCP_TRANSPORT", "http")
+    }
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy", "service": "rebound MCP"}
+
+@app.get("/tools")
+def list_tools():
+    try:
+        from mcp_service import create_app
+        mcp_app = create_app()
+        tools = []
+        for tool_name, tool_func in mcp_app.tools.items():
+            tools.append({
+                "name": tool_name,
+                "description": tool_func.__doc__ or "No description available"
+            })
+        return {"tools": tools}
+    except Exception as e:
+        return {"error": f"Failed to load tools: {str(e)}"}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

rebound/mcp_output/README_MCP.md

@@ -0,0 +1,73 @@
+# REBOUND: N-Body Simulation Service
+
+## Project Introduction
+
+REBOUND is an open-source N-body integrator package designed for high-accuracy astronomical simulations. It enables the numerical integration of particle systems under gravitational forces, supporting applications ranging from planetary dynamics to galactic structure formation. The core architecture combines a high-performance C computational core with accessible Python interfaces, allowing researchers to perform complex simulations with minimal setup.
+
+## Installation Method
+
+To install REBOUND, ensure you have the following dependencies:
+
+- Required: `numpy`, `scipy`
+- Optional: `matplotlib`, `mpi4py`
+
+You can install REBOUND using pip:
+
+```
+pip install rebound
+```
+
+## Quick Start
+
+Here's a basic example to get you started with REBOUND:
+
+1. **Initialize a Simulation:**
+
+   Create a simulation instance and add particles.
+
+   ```
+   from rebound import Simulation
+
+   sim = Simulation()
+   sim.add(m=1.0)  # Add a central mass
+   sim.add(m=1e-3, a=1.0)  # Add a particle
+   ```
+
+2. **Integrate the Simulation:**
+
+   Advance the simulation in time.
+
+   ```
+   sim.integrate(100.0)  # Integrate to time t=100
+   ```
+
+3. **Check Simulation Status:**
+
+   Retrieve the current status of the simulation.
+
+   ```
+   status = sim.status()
+   print(status)
+   ```
+
+## Available Tools and Endpoints List
+
+- **Simulation Class:** Manages the main simulation loop and particle states.
+- **Particle Class:** Represents individual particles with kinematic and physical properties.
+- **TRACE Integrator:** Implements the TRACE integrator for specific simulation scenarios.
+
+## Common Issues and Notes
+
+- **Dependencies:** Ensure all required dependencies are installed. Optional dependencies enhance functionality but are not mandatory.
+- **Environment:** REBOUND supports shared-memory parallelization (OpenMP) and distributed computing (MPI) for specialized cases.
+- **Performance:** The system automatically optimizes for platform capabilities, including AVX512 support for the WHFast512 integrator and GPU acceleration where available.
+
+## Reference Links or Documentation
+
+- [REBOUND GitHub Repository](https://github.com/hannorein/rebound)
+- [Documentation](https://rebound.readthedocs.io/)
+- [Numerical Integrators](https://rebound.readthedocs.io/en/latest/integrators.html)
+- [Visualization Capabilities](https://rebound.readthedocs.io/en/latest/visualization.html)
+- [Data Management and Reproducibility](https://rebound.readthedocs.io/en/latest/data_management.html)
+
+For more detailed information about specific subsystems, refer to the dedicated sections on core architecture, integrators, visualization, and data management.

rebound/mcp_output/analysis.json

@@ -0,0 +1,550 @@
+{
+  "summary": {
+    "repository_url": "https://github.com/hannorein/rebound",
+    "summary": "Imported via zip fallback, file count: 150",
+    "file_tree": {
+      ".github/ISSUE_TEMPLATE/advice.md": {
+        "size": 1133
+      },
+      ".github/ISSUE_TEMPLATE/bug_report.md": {
+        "size": 885
+      },
+      ".github/ISSUE_TEMPLATE/feature_request.md": {
+        "size": 370
+      },
+      ".github/ISSUE_TEMPLATE/question.md": {
+        "size": 209
+      },
+      ".github/codecov.yml": {
+        "size": 29
+      },
+      ".github/workflows/build_wheels.yml": {
+        "size": 1473
+      },
+      ".github/workflows/c.yml": {
+        "size": 934
+      },
+      ".github/workflows/cmpi.yml": {
+        "size": 822
+      },
+      ".github/workflows/coverage.yml": {
+        "size": 1085
+      },
+      ".github/workflows/emscripten.yml": {
+        "size": 759
+      },
+      ".github/workflows/ipynb.yml": {
+        "size": 1913
+      },
+      ".github/workflows/lint.yml": {
+        "size": 438
+      },
+      ".github/workflows/python.yml": {
+        "size": 1713
+      },
+      ".github/workflows/reboundx.yml": {
+        "size": 1214
+      },
+      "README.md": {
+        "size": 9665
+      },
+      "changelog.md": {
+        "size": 35767
+      },
+      "docs/addingparticles.md": {
+        "size": 7967
+      },
+      "docs/api.md": {
+        "size": 1472
+      },
+      "docs/binaryformat.md": {
+        "size": 6173
+      },
+      "docs/boundaryconditions.md": {
+        "size": 3807
+      },
+      "docs/c_examples/generate_c_examples.py": {
+        "size": 2860
+      },
+      "docs/c_outputfunctions.md": {
+        "size": 2750
+      },
+      "docs/c_randomsamplingfunctions.md": {
+        "size": 1747
+      },
+      "docs/changelog.md": {
+        "size": 15
+      },
+      "docs/chaos.md": {
+        "size": 4461
+      },
+      "docs/collisions.md": {
+        "size": 9313
+      },
+      "docs/examples.md": {
+        "size": 564
+      },
+      "docs/generate_python_docs.py": {
+        "size": 1054
+      },
+      "docs/gravity.md": {
+        "size": 1154
+      },
+      "docs/index.md": {
+        "size": 7523
+      },
+      "docs/integrators.md": {
+        "size": 42853
+      },
+      "docs/javascripts/config.js": {
+        "size": 300
+      },
+      "docs/miscellaneous.md": {
+        "size": 714
+      },
+      "docs/mpi.md": {
+        "size": 2809
+      },
+      "docs/namingconvention.md": {
+        "size": 2965
+      },
+      "docs/orbitalelements.md": {
+        "size": 3948
+      },
+      "docs/particleoperators.md": {
+        "size": 2663
+      },
+      "docs/particles.md": {
+        "size": 1924
+      },
+      "docs/quickstart_firstexample.md": {
+        "size": 3432
+      },
+      "docs/quickstart_installation.md": {
+        "size": 9025
+      },
+      "docs/quickstart_whereto.md": {
+        "size": 743
+      },
+      "docs/removingparticles.md": {
+        "size": 3025
+      },
+      "docs/requirements.txt": {
+        "size": 119
+      },
+      "docs/simulation.md": {
+        "size": 2958
+      },
+      "docs/simulationarchive.md": {
+        "size": 4157
+      },
+      "docs/simulationbinaryfiles.md": {
+        "size": 1221
+      },
+      "docs/simulationdiagnostics.md": {
+        "size": 1568
+      },
+      "docs/simulationoperators.md": {
+        "size": 3368
+      },
+      "docs/simulationreferenceframes.md": {
+        "size": 2020
+      },
+      "docs/simulationtimestepping.md": {
+        "size": 3657
+      },
+      "docs/simulationvariables.md": {
+        "size": 13898
+      },
+      "docs/units.md": {
+        "size": 3266
+      },
+      "docs/visualization.md": {
+        "size": 7417
+      },
+      "ipython_examples/ipynb2py.py": {
+        "size": 642
+      },
+      "mkdocs.yml": {
+        "size": 7045
+      },
+      "pyproject.toml": {
+        "size": 91
+      },
+      "python_examples/dragforce/problem.py": {
+        "size": 1062
+      },
+      "python_examples/horizons/problem.py": {
+        "size": 1715
+      },
+      "python_examples/longtermtest/problem.py": {
+        "size": 6149
+      },
+      "python_examples/megno/problem.py": {
+        "size": 3505
+      },
+      "python_examples/megno_simple/problem.py": {
+        "size": 1024
+      },
+      "python_examples/orbital_elements/problem.py": {
+        "size": 776
+      },
+      "python_examples/outersolarsystem/problem.py": {
+        "size": 1797
+      },
+      "python_examples/simple_orbit/problem.py": {
+        "size": 495
+      },
+      "python_examples/simulationarchive/problem.py": {
+        "size": 729
+      },
+      "rebound/__init__.py": {
+        "size": 3714
+      },
+      "rebound/binary_field_descriptor.py": {
+        "size": 1166
+      },
+      "rebound/citations.py": {
+        "size": 15301
+      },
+      "rebound/data.py": {
+        "size": 3504
+      },
+      "rebound/frequency_analysis.py": {
+        "size": 3332
+      },
+      "rebound/hash.py": {
+        "size": 824
+      },
+      "rebound/horizons.py": {
+        "size": 11212
+      },
+      "rebound/integrators/__init__.py": {
+        "size": 14
+      },
+      "rebound/integrators/bs.py": {
+        "size": 2606
+      },
+      "rebound/integrators/eos.py": {
+        "size": 2951
+      },
+      "rebound/integrators/ias15.py": {
+        "size": 4176
+      },
+      "rebound/integrators/janus.py": {
+        "size": 766
+      },
+      "rebound/integrators/leapfrog.py": {
+        "size": 453
+      },
+      "rebound/integrators/mercurius.py": {
+        "size": 2848
+      },
+      "rebound/integrators/saba.py": {
+        "size": 2376
+      },
+      "rebound/integrators/sei.py": {
+        "size": 1201
+      },
+      "rebound/integrators/trace.py": {
+        "size": 4982
+      },
+      "rebound/integrators/whfast.py": {
+        "size": 5513
+      },
+      "rebound/integrators/whfast512.py": {
+        "size": 496
+      },
+      "rebound/orbit.py": {
+        "size": 3644
+      },
+      "rebound/particle.py": {
+        "size": 46115
+      },
+      "rebound/particles.py": {
+        "size": 2993
+      },
+      "rebound/plotting.py": {
+        "size": 19417
+      },
+      "rebound/rotation.py": {
+        "size": 10897
+      },
+      "rebound/simulation.py": {
+        "size": 68439
+      },
+      "rebound/simulationarchive.py": {
+        "size": 15852
+      },
+      "rebound/tests/__init__.py": {
+        "size": 1
+      },
+      "rebound/tests/test_additional_forces.py": {
+        "size": 3657
+      },
+      "rebound/tests/test_binary_fields.py": {
+        "size": 498
+      },
+      "rebound/tests/test_boundary.py": {
+        "size": 2750
+      },
+      "rebound/tests/test_bs.py": {
+        "size": 13794
+      },
+      "rebound/tests/test_collisions.py": {
+        "size": 6869
+      },
+      "rebound/tests/test_copy.py": {
+        "size": 9362
+      },
+      "rebound/tests/test_data.py": {
+        "size": 516
+      },
+      "rebound/tests/test_eos.py": {
+        "size": 3340
+      },
+      "rebound/tests/test_eos_megno.py": {
+        "size": 3119
+      },
+      "rebound/tests/test_fpcontract.py": {
+        "size": 407
+      },
+      "rebound/tests/test_frequency_analysis.py": {
+        "size": 2497
+      },
+      "rebound/tests/test_gravity.py": {
+        "size": 3278
+      },
+      "rebound/tests/test_hash.py": {
+        "size": 5188
+      },
+      "rebound/tests/test_horizons.py": {
+        "size": 1220
+      },
+      "rebound/tests/test_import.py": {
+        "size": 330
+      },
+      "rebound/tests/test_integrator.py": {
+        "size": 6243
+      },
+      "rebound/tests/test_janus.py": {
+        "size": 3642
+      },
+      "rebound/tests/test_leapfrog.py": {
+        "size": 1929
+      },
+      "rebound/tests/test_megno.py": {
+        "size": 3445
+      },
+      "rebound/tests/test_mercurius.py": {
+        "size": 10962
+      },
+      "rebound/tests/test_modify_orbital_parameters.py": {
+        "size": 8039
+      },
+      "rebound/tests/test_orbital_elements.py": {
+        "size": 17384
+      },
+      "rebound/tests/test_particle.py": {
+        "size": 12833
+      },
+      "rebound/tests/test_pickle.py": {
+        "size": 1690
+      },
+      "rebound/tests/test_plotting.py": {
+        "size": 1412
+      },
+      "rebound/tests/test_post_timestep_modifications.py": {
+        "size": 2300
+      },
+      "rebound/tests/test_random.py": {
+        "size": 2794
+      },
+      "rebound/tests/test_restart_mercurius.py": {
+        "size": 1484
+      },
+      "rebound/tests/test_rotations.py": {
+        "size": 7131
+      },
+      "rebound/tests/test_saba.py": {
+        "size": 5099
+      },
+      "rebound/tests/test_serialize.py": {
+        "size": 2026
+      },
+      "rebound/tests/test_server.py": {
+        "size": 1835
+      },
+      "rebound/tests/test_shearingsheet.py": {
+        "size": 2361
+      },
+      "rebound/tests/test_simulation.py": {
+        "size": 10588
+      },
+      "rebound/tests/test_simulationarchive.py": {
+        "size": 21397
+      },
+      "rebound/tests/test_simulationarchive_matrix.py": {
+        "size": 5113
+      },
+      "rebound/tests/test_size_of_simulation.py": {
+        "size": 432
+      },
+      "rebound/tests/test_tponly_encounter.py": {
+        "size": 1818
+      },
+      "rebound/tests/test_trace.py": {
+        "size": 17042
+      },
+      "rebound/tests/test_trace_basic.py": {
+        "size": 1798
+      },
+      "rebound/tests/test_trace_full_bs.py": {
+        "size": 15149
+      },
+      "rebound/tests/test_trace_full_ias15.py": {
+        "size": 14914
+      },
+      "rebound/tests/test_transformations.py": {
+        "size": 5691
+      },
+      "rebound/tests/test_units.py": {
+        "size": 2331
+      },
+      "rebound/tests/test_variational.py": {
+        "size": 13967
+      },
+      "rebound/tests/test_whfast.py": {
+        "size": 12075
+      },
+      "rebound/tests/test_whfast_advanced.py": {
+        "size": 6299
+      },
+      "rebound/tests/test_whfast_testparticles.py": {
+        "size": 7007
+      },
+      "rebound/tools.py": {
+        "size": 2412
+      },
+      "rebound/units.py": {
+        "size": 4762
+      },
+      "rebound/variation.py": {
+        "size": 6870
+      },
+      "rebound/vectors.py": {
+        "size": 4253
+      },
+      "rebound/widget.py": {
+        "size": 26664
+      },
+      "requirements.txt": {
+        "size": 17
+      },
+      "setup.py": {
+        "size": 5482
+      },
+      "style.txt": {
+        "size": 2237
+      },
+      "update_version.py": {
+        "size": 3902
+      },
+      "version.txt": {
+        "size": 6
+      }
+    },
+    "processed_by": "zip_fallback",
+    "success": true
+  },
+  "structure": {
+    "packages": [
+      "source.rebound",
+      "source.rebound.integrators",
+      "source.rebound.tests"
+    ]
+  },
+  "dependencies": {
+    "has_environment_yml": false,
+    "has_requirements_txt": true,
+    "pyproject": true,
+    "setup_cfg": false,
+    "setup_py": true
+  },
+  "entry_points": {
+    "imports": [],
+    "cli": [],
+    "modules": []
+  },
+  "llm_analysis": {
+    "core_modules": [
+      {
+        "package": "source.rebound",
+        "module": "simulation",
+        "functions": [
+          "integrate",
+          "add",
+          "status"
+        ],
+        "classes": [
+          "Simulation"
+        ],
+        "description": "Handles the main simulation loop and manages particle states."
+      },
+      {
+        "package": "source.rebound",
+        "module": "particle",
+        "functions": [],
+        "classes": [
+          "Particle"
+        ],
+        "description": "Represents individual particles with kinematic and physical properties."
+      },
+      {
+        "package": "source.rebound.integrators",
+        "module": "trace",
+        "functions": [],
+        "classes": [],
+        "description": "Implements the TRACE integrator for specific simulation scenarios."
+      }
+    ],
+    "cli_commands": [],
+    "import_strategy": {
+      "primary": "import",
+      "fallback": "blackbox",
+      "confidence": 0.8
+    },
+    "dependencies": {
+      "required": [
+        "numpy",
+        "scipy"
+      ],
+      "optional": [
+        "matplotlib",
+        "mpi4py"
+      ]
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.8,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    }
+  },
+  "deepwiki_analysis": {
+    "repo_url": "https://github.com/hannorein/rebound",
+    "repo_name": "rebound",
+    "content": "hannorein/rebound\nCore Architecture\nSimulation Engine\nParticle System\nBuild System\nPython Interface\nSimulation Class\nParticle Management\nData Sources and Units\nNumerical Integrators\nWHFast Integrator\nHybrid Integrators\nSpecialized Integrators\nVisualization\nReal-time Visualization\nStatic Plotting\nData Management\nSimulation Archives\nAnalysis Tools\nExamples and Tutorials\nBasic Examples\nPhysics Applications\nPerformance and Accuracy\nAdvanced Topics\nParallel Computing\nVariational Equations\nTesting and Validation\nchangelog.md\ndocs/index.md\ndocs/integrators.md\ndocs/mpi.md\ndocs/visualization.md\nipython_examples/Holmberg.ipynb\nipython_examples/WHFast.ipynb\nrebound/__init__.py\nrebound/integrators/trace.py\nrebound/particle.py\nrebound/simulation.py\nrebound/tests/test_trace.py\nsrc/input.c\nsrc/input.h\nsrc/integrator_ias15.c\nsrc/integrator_trace.c\nsrc/integrator_whfast.c\nsrc/output.c\nsrc/output.h\nsrc/rebound.c\nsrc/rebound.h\nsrc/tools.c\nsrc/tools.h\nupdate_version.py\nversion.txt\nweb_client/shell_rebound.html\nweb_client/shell_rebound_console.html\nweb_client/shell_rebound_webgl.html\nThis document provides a comprehensive overview of REBOUND, an open-source N-body integrator package designed for high-accuracy astronomical simulations. REBOUND enables the numerical integration of particle systems under gravitational forces, supporting applications ranging from planetary dynamics to galactic structure formation.\nFor information about specific integrators and their configuration, seeNumerical Integrators. For visualization capabilities, seeVisualization. For data management and reproducibility features, seeData Management.\nPurpose and Architecture\nREBOUND is designed as a multi-layered system combining a high-performance C computational core with accessible Python interfaces. The architecture prioritizes both computational efficiency and ease of use, enabling researchers to perform complex N-body simulations with minimal setup while maintaining the flexibility to customize integrators, force calculations, and analysis workflows.\nSystem Architecture Overview\nThe system follows a layered architecture where thereb_simulationstructure serves as the central coordination point for all simulation activities. Each simulation maintains its own particle array, integrator state, and physics configuration.\nreb_simulation\nSources:src/rebound.h489-647src/rebound.c77-185rebound/simulation.py52-94\nCore Data Structures\nREBOUND's functionality centers around two primary data structures that bridge the natural language concepts of \"simulation\" and \"particle\" with concrete code implementations:\nPython InterfaceC ImplementationConceptual LayerN-body SimulationCelestial Bodystruct reb_simulationrebound.h:489struct reb_particlerebound.h:112• t (time)• dt (timestep)• N (particle count)• integrator• x,y,z (position)• vx,vy,vz (velocity)• m (mass)• r (radius)class Simulationsimulation.py:52class Particleparticle.py:11• integrate()• add()• status()• orbital elements• coordinate access\nPython Interface\nC Implementation\nConceptual Layer\nN-body Simulation\nCelestial Body\nstruct reb_simulationrebound.h:489\nstruct reb_particlerebound.h:112\n• t (time)• dt (timestep)• N (particle count)• integrator\n• x,y,z (position)• vx,vy,vz (velocity)• m (mass)• r (radius)\nclass Simulationsimulation.py:52\nclass Particleparticle.py:11\n• integrate()• add()• status()\n• orbital elements• coordinate access\nThereb_simulationstructure contains all simulation state including time evolution parameters, particle arrays, integrator configurations, and physics settings. Thereb_particlestructure represents individual bodies with their kinematic and physical properties.\nreb_simulation\nreb_particle\nSources:src/rebound.h112-141src/rebound.h489-647rebound/simulation.py52-94rebound/particle.py11-48\nIntegration Engine\nThe heart of REBOUND is its integration engine, which advances particle positions and velocities through time using sophisticated numerical methods. The main integration loop coordinates between force calculations, integrator steps, and auxiliary operations:\nEach integrator implements thereb_integrator_part1()andreb_integrator_part2()interface, allowing for modular swapping of numerical methods. The force calculation supports both built-in gravity models and user-defined additional forces.\nreb_integrator_part1()\nreb_integrator_part2()\nSources:src/rebound.c82-185src/integrator.hsrc/gravity.c\nMemory and Data Management\nREBOUND employs dynamic memory management to handle varying particle counts and simulation complexity. The system automatically resizes internal arrays and manages integrator-specific storage:\nreb_simulation_add()\nreb_integrator_*_reset()\nreb_tree_delete()\nreb_simulation_update_tree()\nreb_simulationarchive_*()\nTheN_allocatedfields throughout the codebase track memory allocation sizes separately from active counts, enabling efficient reuse without frequent reallocation.\nN_allocated\nSources:src/rebound.h508src/particle.csrc/tree.csrc/simulationarchive.c\nBuild System and Distribution\nREBOUND supports multiple deployment scenarios through a flexible build system:\nDistribution ChannelsBuild TargetsSource OrganizationC Source Filessrc/.c, src/.hPython Modulesrebound/*.pyExample Problemsexamples/*/librebound.so/.dllShared LibraryPython Extensionctypes InterfaceStandalone C ProgramsWebGL TargetsEmscriptenpip install reboundSource Repositoryconda install reboundBrowser Examples\nDistribution Channels\nBuild Targets\nSource Organization\nC Source Filessrc/.c, src/.h\nPython Modulesrebound/*.py\nExample Problemsexamples/*/\nlibrebound.so/.dllShared Library\nPython Extensionctypes Interface\nStandalone C Programs\nWebGL TargetsEmscripten\npip install rebound\nSource Repository\nconda install rebound\nBrowser Examples\nThe build system detects platform capabilities and optimizes compilation accordingly, including AVX512 support for the WHFast512 integrator and GPU acceleration where available.\nSources:setup.py52-87Makefile entriesREADME.md51-56\nKey Features and Capabilities\nREBOUND provides a comprehensive suite of capabilities for N-body simulations:\nNumerical Integration: Multiple high-precision integrators including adaptive timestep methods (IAS15), symplectic methods (WHFast, SABA), and hybrid approaches (MERCURIUS, TRACE) for different physical scenarios.\nCoordinate Systems: Support for multiple coordinate systems including Jacobi, heliocentric, barycentric, and democratic heliocentric coordinates, with automatic transformations between systems.\nCollision Handling: Sophisticated collision detection using spatial trees or direct methods, with customizable collision resolution including merging, bouncing, and user-defined responses.\nData Reproducibility: The SimulationArchive system enables bit-perfect reproduction of simulation results through binary serialization of complete simulation state.\nVisualization: Real-time 3D visualization supporting both OpenGL (native) and WebGL (browser-based) rendering with interactive controls for simulation monitoring.\nParallelization: Support for shared-memory parallelization (OpenMP), distributed computing (MPI for specialized cases), and SIMD vectorization (AVX512 for WHFast512).\nSources:src/rebound.h1-100README.md25-44docs/integrators.md\nThis overview establishes the foundation for understanding REBOUND's architecture and capabilities. For detailed information about specific subsystems, refer to the dedicated sections on core architecture, integrators, visualization, and data management.\nRefresh this wiki\nOn this page\nPurpose and Architecture\nSystem Architecture Overview\nCore Data Structures\nIntegration Engine\nMemory and Data Management\nBuild System and Distribution\nKey Features and Capabilities",
+    "model": "gpt-4o-2024-08-06",
+    "source": "selenium",
+    "success": true
+  },
+  "deepwiki_options": {
+    "enabled": true,
+    "model": "gpt-4o-2024-08-06"
+  },
+  "risk": {
+    "import_feasibility": 0.8,
+    "intrusiveness_risk": "low",
+    "complexity": "medium"
+  }
+}

rebound/mcp_output/diff_report.md

@@ -0,0 +1,53 @@
+# Difference Report for Rebound Project
+
+## Project Overview
+
+**Repository:** Rebound  
+**Project Type:** Python Library  
+**Main Features:** Basic functionality  
+**Report Generated On:** February 4, 2026, 19:55:00  
+
+The Rebound project is a Python library designed to provide basic functionality for its users. The project is currently under development, with recent updates aimed at enhancing its capabilities.
+
+## Difference Analysis
+
+### Summary of Changes
+
+- **New Files Added:** 8
+- **Modified Files:** 0
+- **Workflow Status:** Success
+- **Test Status:** Failed
+
+The recent update to the Rebound project involved the addition of eight new files. There were no modifications to existing files. The workflow for these changes was successfully executed, but the test suite did not pass, indicating potential issues with the new additions.
+
+## Technical Analysis
+
+### New Files
+
+The addition of eight new files suggests a significant expansion of the project's functionality. However, without modifications to existing files, it appears that these new files are standalone additions rather than enhancements or fixes to current features.
+
+### Workflow and Testing
+
+- **Workflow Status:** The workflow executed successfully, indicating that the integration of new files into the project did not encounter any immediate technical issues.
+- **Test Status:** The failure of the test suite suggests that the new files may contain errors or that they do not integrate seamlessly with the existing codebase.
+
+## Recommendations and Improvements
+
+1. **Review New Files:** Conduct a thorough review of the newly added files to identify any coding errors or integration issues.
+2. **Enhance Testing:** Update the test suite to cover the new functionalities introduced by the new files. Ensure that all edge cases are considered.
+3. **Code Integration:** Evaluate how the new files interact with the existing codebase. Consider refactoring if necessary to improve compatibility and performance.
+4. **Documentation:** Update project documentation to reflect the new features and provide guidance on their usage.
+
+## Deployment Information
+
+Given the current test failures, it is not recommended to deploy the latest changes to a production environment. Addressing the issues identified in the test suite should be prioritized before any deployment.
+
+## Future Planning
+
+1. **Bug Fixes:** Focus on resolving the issues identified in the test suite to ensure the stability and reliability of the new features.
+2. **Feature Expansion:** Once the current issues are resolved, consider expanding the library's functionality further, based on user feedback and project goals.
+3. **Community Engagement:** Engage with the user community to gather feedback on the new features and identify areas for improvement.
+
+## Conclusion
+
+The recent update to the Rebound project has introduced new functionalities through the addition of eight new files. While the workflow was successful, the test failures indicate that further work is needed to ensure these new features are robust and integrate well with the existing codebase. By addressing the identified issues and enhancing the test suite, the project can move towards a stable release in the future.

rebound/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,140 @@
+import os
+import sys
+
+# Path settings
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+sys.path.insert(0, source_path)
+
+# Import statements
+try:
+    from rebound.simulation import Simulation
+    from rebound.particle import Particle
+    from rebound.integrators.trace import TraceIntegrator
+    from rebound.tests.test_trace import test_trace_function
+    import numpy as np
+    import scipy
+    import matplotlib
+    import mpi4py
+except ImportError as e:
+    print(f"Import failed: {e}. Ensure all dependencies are installed and the source path is correct.")
+
+# Adapter class
+class Adapter:
+    """
+    Adapter class for the MCP plugin, providing access to REBOUND's core functionalities.
+    """
+
+    def __init__(self):
+        self.mode = "import"
+
+    # Simulation Module
+    # -------------------------------------------------------------------------
+    def create_simulation_instance(self, *args, **kwargs):
+        """
+        Create an instance of the Simulation class.
+
+        Parameters:
+            *args: Positional arguments for Simulation.
+            **kwargs: Keyword arguments for Simulation.
+
+        Returns:
+            dict: Status and instance of Simulation.
+        """
+        try:
+            simulation = Simulation(*args, **kwargs)
+            return {"status": "success", "simulation": simulation}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # Particle Module
+    # -------------------------------------------------------------------------
+    def create_particle_instance(self, *args, **kwargs):
+        """
+        Create an instance of the Particle class.
+
+        Parameters:
+            *args: Positional arguments for Particle.
+            **kwargs: Keyword arguments for Particle.
+
+        Returns:
+            dict: Status and instance of Particle.
+        """
+        try:
+            particle = Particle(*args, **kwargs)
+            return {"status": "success", "particle": particle}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # Integrator Module
+    # -------------------------------------------------------------------------
+    def create_trace_integrator_instance(self, *args, **kwargs):
+        """
+        Create an instance of the TraceIntegrator class.
+
+        Parameters:
+            *args: Positional arguments for TraceIntegrator.
+            **kwargs: Keyword arguments for TraceIntegrator.
+
+        Returns:
+            dict: Status and instance of TraceIntegrator.
+        """
+        try:
+            integrator = TraceIntegrator(*args, **kwargs)
+            return {"status": "success", "integrator": integrator}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # Test Module
+    # -------------------------------------------------------------------------
+    def call_test_trace_function(self, *args, **kwargs):
+        """
+        Call the test_trace_function.
+
+        Parameters:
+            *args: Positional arguments for test_trace_function.
+            **kwargs: Keyword arguments for test_trace_function.
+
+        Returns:
+            dict: Status and result of test_trace_function.
+        """
+        try:
+            result = test_trace_function(*args, **kwargs)
+            return {"status": "success", "result": result}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # Utility Methods
+    # -------------------------------------------------------------------------
+    def check_dependencies(self):
+        """
+        Check for the presence of required dependencies.
+
+        Returns:
+            dict: Status and list of missing dependencies, if any.
+        """
+        missing_dependencies = []
+        try:
+            import numpy
+        except ImportError:
+            missing_dependencies.append("numpy")
+        try:
+            import scipy
+        except ImportError:
+            missing_dependencies.append("scipy")
+        try:
+            import matplotlib
+        except ImportError:
+            missing_dependencies.append("matplotlib")
+        try:
+            import mpi4py
+        except ImportError:
+            missing_dependencies.append("mpi4py")
+
+        if missing_dependencies:
+            return {"status": "error", "missing_dependencies": missing_dependencies}
+        return {"status": "success", "message": "All dependencies are installed."}
+
+# End of Adapter class
+# -------------------------------------------------------------------------
+# This adapter provides a comprehensive interface to the REBOUND library,
+# ensuring all functionalities are accessible with error handling and status reporting.

rebound/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

rebound/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,80 @@
+import os
+import sys
+
+# Add the local source directory to sys.path
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+from rebound.simulation import Simulation
+from rebound.particle import Particle
+
+# Create the FastMCP service application
+mcp = FastMCP("rebound_service")
+
+@mcp.tool(name="create_simulation", description="Create a new simulation instance")
+def create_simulation() -> dict:
+    """
+    Creates a new simulation instance.
+
+    Returns:
+        dict: A dictionary containing the success status and the simulation instance.
+    """
+    try:
+        sim = Simulation()
+        return {"success": True, "result": sim, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="add_particle", description="Add a particle to the simulation")
+def add_particle(sim: Simulation, mass: float, x: float, y: float, z: float, vx: float, vy: float, vz: float) -> dict:
+    """
+    Adds a particle to the given simulation.
+
+    Parameters:
+        sim (Simulation): The simulation instance.
+        mass (float): Mass of the particle.
+        x (float): X position.
+        y (float): Y position.
+        z (float): Z position.
+        vx (float): X velocity.
+        vy (float): Y velocity.
+        vz (float): Z velocity.
+
+    Returns:
+        dict: A dictionary containing the success status and the updated simulation.
+    """
+    try:
+        particle = Particle(mass=mass, x=x, y=y, z=z, vx=vx, vy=vy, vz=vz)
+        sim.add(particle)
+        return {"success": True, "result": sim, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="integrate_simulation", description="Integrate the simulation over a given time")
+def integrate_simulation(sim: Simulation, time: float) -> dict:
+    """
+    Integrates the simulation over the specified time.
+
+    Parameters:
+        sim (Simulation): The simulation instance.
+        time (float): The time to integrate over.
+
+    Returns:
+        dict: A dictionary containing the success status and the updated simulation.
+    """
+    try:
+        sim.integrate(time)
+        return {"success": True, "result": sim, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+def create_app() -> FastMCP:
+    """
+    Creates and returns the FastMCP application instance.
+
+    Returns:
+        FastMCP: The FastMCP application instance.
+    """
+    return mcp

rebound/mcp_output/requirements.txt

@@ -0,0 +1,7 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+matplotlib
+numpy
+scipy

rebound/mcp_output/start_mcp.py

@@ -0,0 +1,30 @@
+
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

rebound/mcp_output/workflow_summary.json

@@ -0,0 +1,196 @@
+{
+  "repository": {
+    "name": "rebound",
+    "url": "https://github.com/hannorein/rebound",
+    "local_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/rebound",
+    "description": "Python library",
+    "features": "Basic functionality",
+    "tech_stack": "Python",
+    "stars": 0,
+    "forks": 0,
+    "language": "Python",
+    "last_updated": "",
+    "complexity": "medium",
+    "intrusiveness_risk": "low"
+  },
+  "execution": {
+    "start_time": 1770205945.9813013,
+    "end_time": 1770206036.978772,
+    "duration": 90.99747085571289,
+    "status": "success",
+    "workflow_status": "success",
+    "nodes_executed": [
+      "download",
+      "analysis",
+      "env",
+      "generate",
+      "run",
+      "review",
+      "finalize"
+    ],
+    "total_files_processed": 3,
+    "environment_type": "unknown",
+    "llm_calls": 0,
+    "deepwiki_calls": 0
+  },
+  "tests": {
+    "original_project": {
+      "passed": false,
+      "details": {},
+      "test_coverage": "100%",
+      "execution_time": 0,
+      "test_files": []
+    },
+    "mcp_plugin": {
+      "passed": true,
+      "details": {},
+      "service_health": "healthy",
+      "startup_time": 0,
+      "transport_mode": "stdio",
+      "fastmcp_version": "unknown",
+      "mcp_version": "unknown"
+    }
+  },
+  "analysis": {
+    "structure": {
+      "packages": [
+        "source.rebound",
+        "source.rebound.integrators",
+        "source.rebound.tests"
+      ]
+    },
+    "dependencies": {
+      "has_environment_yml": false,
+      "has_requirements_txt": true,
+      "pyproject": true,
+      "setup_cfg": false,
+      "setup_py": true
+    },
+    "entry_points": {
+      "imports": [],
+      "cli": [],
+      "modules": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.8,
+      "intrusiveness_risk": "low",
+      "complexity": "medium"
+    },
+    "deepwiki_analysis": {
+      "repo_url": "https://github.com/hannorein/rebound",
+      "repo_name": "rebound",
+      "content": "hannorein/rebound\nCore Architecture\nSimulation Engine\nParticle System\nBuild System\nPython Interface\nSimulation Class\nParticle Management\nData Sources and Units\nNumerical Integrators\nWHFast Integrator\nHybrid Integrators\nSpecialized Integrators\nVisualization\nReal-time Visualization\nStatic Plotting\nData Management\nSimulation Archives\nAnalysis Tools\nExamples and Tutorials\nBasic Examples\nPhysics Applications\nPerformance and Accuracy\nAdvanced Topics\nParallel Computing\nVariational Equations\nTesting and Validation\nchangelog.md\ndocs/index.md\ndocs/integrators.md\ndocs/mpi.md\ndocs/visualization.md\nipython_examples/Holmberg.ipynb\nipython_examples/WHFast.ipynb\nrebound/__init__.py\nrebound/integrators/trace.py\nrebound/particle.py\nrebound/simulation.py\nrebound/tests/test_trace.py\nsrc/input.c\nsrc/input.h\nsrc/integrator_ias15.c\nsrc/integrator_trace.c\nsrc/integrator_whfast.c\nsrc/output.c\nsrc/output.h\nsrc/rebound.c\nsrc/rebound.h\nsrc/tools.c\nsrc/tools.h\nupdate_version.py\nversion.txt\nweb_client/shell_rebound.html\nweb_client/shell_rebound_console.html\nweb_client/shell_rebound_webgl.html\nThis document provides a comprehensive overview of REBOUND, an open-source N-body integrator package designed for high-accuracy astronomical simulations. REBOUND enables the numerical integration of particle systems under gravitational forces, supporting applications ranging from planetary dynamics to galactic structure formation.\nFor information about specific integrators and their configuration, seeNumerical Integrators. For visualization capabilities, seeVisualization. For data management and reproducibility features, seeData Management.\nPurpose and Architecture\nREBOUND is designed as a multi-layered system combining a high-performance C computational core with accessible Python interfaces. The architecture prioritizes both computational efficiency and ease of use, enabling researchers to perform complex N-body simulations with minimal setup while maintaining the flexibility to customize integrators, force calculations, and analysis workflows.\nSystem Architecture Overview\nThe system follows a layered architecture where thereb_simulationstructure serves as the central coordination point for all simulation activities. Each simulation maintains its own particle array, integrator state, and physics configuration.\nreb_simulation\nSources:src/rebound.h489-647src/rebound.c77-185rebound/simulation.py52-94\nCore Data Structures\nREBOUND's functionality centers around two primary data structures that bridge the natural language concepts of \"simulation\" and \"particle\" with concrete code implementations:\nPython InterfaceC ImplementationConceptual LayerN-body SimulationCelestial Bodystruct reb_simulationrebound.h:489struct reb_particlerebound.h:112• t (time)• dt (timestep)• N (particle count)• integrator• x,y,z (position)• vx,vy,vz (velocity)• m (mass)• r (radius)class Simulationsimulation.py:52class Particleparticle.py:11• integrate()• add()• status()• orbital elements• coordinate access\nPython Interface\nC Implementation\nConceptual Layer\nN-body Simulation\nCelestial Body\nstruct reb_simulationrebound.h:489\nstruct reb_particlerebound.h:112\n• t (time)• dt (timestep)• N (particle count)• integrator\n• x,y,z (position)• vx,vy,vz (velocity)• m (mass)• r (radius)\nclass Simulationsimulation.py:52\nclass Particleparticle.py:11\n• integrate()• add()• status()\n• orbital elements• coordinate access\nThereb_simulationstructure contains all simulation state including time evolution parameters, particle arrays, integrator configurations, and physics settings. Thereb_particlestructure represents individual bodies with their kinematic and physical properties.\nreb_simulation\nreb_particle\nSources:src/rebound.h112-141src/rebound.h489-647rebound/simulation.py52-94rebound/particle.py11-48\nIntegration Engine\nThe heart of REBOUND is its integration engine, which advances particle positions and velocities through time using sophisticated numerical methods. The main integration loop coordinates between force calculations, integrator steps, and auxiliary operations:\nEach integrator implements thereb_integrator_part1()andreb_integrator_part2()interface, allowing for modular swapping of numerical methods. The force calculation supports both built-in gravity models and user-defined additional forces.\nreb_integrator_part1()\nreb_integrator_part2()\nSources:src/rebound.c82-185src/integrator.hsrc/gravity.c\nMemory and Data Management\nREBOUND employs dynamic memory management to handle varying particle counts and simulation complexity. The system automatically resizes internal arrays and manages integrator-specific storage:\nreb_simulation_add()\nreb_integrator_*_reset()\nreb_tree_delete()\nreb_simulation_update_tree()\nreb_simulationarchive_*()\nTheN_allocatedfields throughout the codebase track memory allocation sizes separately from active counts, enabling efficient reuse without frequent reallocation.\nN_allocated\nSources:src/rebound.h508src/particle.csrc/tree.csrc/simulationarchive.c\nBuild System and Distribution\nREBOUND supports multiple deployment scenarios through a flexible build system:\nDistribution ChannelsBuild TargetsSource OrganizationC Source Filessrc/.c, src/.hPython Modulesrebound/*.pyExample Problemsexamples/*/librebound.so/.dllShared LibraryPython Extensionctypes InterfaceStandalone C ProgramsWebGL TargetsEmscriptenpip install reboundSource Repositoryconda install reboundBrowser Examples\nDistribution Channels\nBuild Targets\nSource Organization\nC Source Filessrc/.c, src/.h\nPython Modulesrebound/*.py\nExample Problemsexamples/*/\nlibrebound.so/.dllShared Library\nPython Extensionctypes Interface\nStandalone C Programs\nWebGL TargetsEmscripten\npip install rebound\nSource Repository\nconda install rebound\nBrowser Examples\nThe build system detects platform capabilities and optimizes compilation accordingly, including AVX512 support for the WHFast512 integrator and GPU acceleration where available.\nSources:setup.py52-87Makefile entriesREADME.md51-56\nKey Features and Capabilities\nREBOUND provides a comprehensive suite of capabilities for N-body simulations:\nNumerical Integration: Multiple high-precision integrators including adaptive timestep methods (IAS15), symplectic methods (WHFast, SABA), and hybrid approaches (MERCURIUS, TRACE) for different physical scenarios.\nCoordinate Systems: Support for multiple coordinate systems including Jacobi, heliocentric, barycentric, and democratic heliocentric coordinates, with automatic transformations between systems.\nCollision Handling: Sophisticated collision detection using spatial trees or direct methods, with customizable collision resolution including merging, bouncing, and user-defined responses.\nData Reproducibility: The SimulationArchive system enables bit-perfect reproduction of simulation results through binary serialization of complete simulation state.\nVisualization: Real-time 3D visualization supporting both OpenGL (native) and WebGL (browser-based) rendering with interactive controls for simulation monitoring.\nParallelization: Support for shared-memory parallelization (OpenMP), distributed computing (MPI for specialized cases), and SIMD vectorization (AVX512 for WHFast512).\nSources:src/rebound.h1-100README.md25-44docs/integrators.md\nThis overview establishes the foundation for understanding REBOUND's architecture and capabilities. For detailed information about specific subsystems, refer to the dedicated sections on core architecture, integrators, visualization, and data management.\nRefresh this wiki\nOn this page\nPurpose and Architecture\nSystem Architecture Overview\nCore Data Structures\nIntegration Engine\nMemory and Data Management\nBuild System and Distribution\nKey Features and Capabilities",
+      "model": "gpt-4o-2024-08-06",
+      "source": "selenium",
+      "success": true
+    },
+    "code_complexity": {
+      "cyclomatic_complexity": "medium",
+      "cognitive_complexity": "medium",
+      "maintainability_index": 75
+    },
+    "security_analysis": {
+      "vulnerabilities_found": 0,
+      "security_score": 85,
+      "recommendations": []
+    }
+  },
+  "plugin_generation": {
+    "files_created": [
+      "mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md"
+    ],
+    "main_entry": "start_mcp.py",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ],
+    "readme_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/rebound/mcp_output/README_MCP.md",
+    "adapter_mode": "import",
+    "total_lines_of_code": 0,
+    "generated_files_size": 0,
+    "tool_endpoints": 0,
+    "supported_features": [
+      "Basic functionality"
+    ],
+    "generated_tools": [
+      "Basic tools",
+      "Health check tools",
+      "Version info tools"
+    ]
+  },
+  "code_review": {},
+  "errors": [],
+  "warnings": [],
+  "recommendations": [
+    "Improve test coverage by adding more unit tests for critical modules",
+    "streamline the build process by consolidating configuration files",
+    "enhance documentation with more detailed examples and tutorials",
+    "optimize performance by profiling and refactoring computationally intensive functions",
+    "implement continuous integration to automate testing and deployment",
+    "improve dependency management by using a single configuration file",
+    "enhance code readability by adhering to consistent coding standards",
+    "increase community engagement by addressing open issues and pull requests",
+    "explore opportunities for parallelization to improve simulation speed",
+    "ensure compatibility with the latest versions of dependencies."
+  ],
+  "performance_metrics": {
+    "memory_usage_mb": 0,
+    "cpu_usage_percent": 0,
+    "response_time_ms": 0,
+    "throughput_requests_per_second": 0
+  },
+  "deployment_info": {
+    "supported_platforms": [
+      "Linux",
+      "Windows",
+      "macOS"
+    ],
+    "python_versions": [
+      "3.8",
+      "3.9",
+      "3.10",
+      "3.11",
+      "3.12"
+    ],
+    "deployment_methods": [
+      "Docker",
+      "pip",
+      "conda"
+    ],
+    "monitoring_support": true,
+    "logging_configuration": "structured"
+  },
+  "execution_analysis": {
+    "success_factors": [
+      "Comprehensive workflow execution with all nodes successfully completed",
+      "Efficient processing of repository with medium complexity and low intrusiveness risk"
+    ],
+    "failure_reasons": [],
+    "overall_assessment": "excellent",
+    "node_performance": {
+      "download_time": "Efficient download process, completed without issues",
+      "analysis_time": "Completed successfully, providing detailed insights into the repository structure and dependencies",
+      "generation_time": "Code generation was successful, with all necessary files created",
+      "test_time": "MCP plugin tests passed successfully, although original project tests did not run"
+    },
+    "resource_usage": {
+      "memory_efficiency": "Memory usage was not explicitly measured, but no issues reported",
+      "cpu_efficiency": "CPU usage was not explicitly measured, but no issues reported",
+      "disk_usage": "Disk usage was efficient, with generated files size being minimal"
+    }
+  },
+  "technical_quality": {
+    "code_quality_score": 85,
+    "architecture_score": 80,
+    "performance_score": 75,
+    "maintainability_score": 75,
+    "security_score": 85,
+    "scalability_score": 80
+  }
+}

rebound/source/LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

rebound/source/MANIFEST.in

@@ -0,0 +1,66 @@
+include src/integrator_ias15.c
+include src/integrator_whfast.c
+include src/integrator_whfast512.c
+include src/integrator_saba.c
+include src/integrator_leapfrog.c
+include src/integrator_bs.c
+include src/integrator_sei.c
+include src/integrator_mercurius.c
+include src/integrator_trace.c
+include src/integrator_eos.c
+include src/integrator_janus.c
+include src/integrator.c
+include src/gravity.c
+include src/server.c
+include src/frequency_analysis.c
+include src/collision.c
+include src/boundary.c
+include src/binarydiff.c
+include src/output.c
+include src/input.c
+include src/display.c
+include src/rebound.c
+include src/tools.c
+include src/fmemopen.c
+include src/rotations.c
+include src/derivatives.c
+include src/particle.c
+include src/simulationarchive.c
+include src/integrator_ias15.h
+include src/integrator_whfast.h
+include src/integrator_whfast512.h
+include src/integrator_saba.h
+include src/integrator_leapfrog.h
+include src/integrator_bs.h
+include src/integrator_sei.h
+include src/integrator_mercurius.h
+include src/integrator_trace.h
+include src/integrator_eos.h
+include src/integrator_janus.h
+include src/integrator.h
+include src/collision.h
+include src/boundary.h
+include src/gravity.h
+include src/server.h
+include src/frequency_analysis.h
+include src/tree.h
+include src/tree.c
+include src/tools.h
+include src/fmemopen.h
+include src/rotations.h
+include src/derivatives.h
+include src/particle.h
+include src/rebound.h
+include src/input.h
+include src/display.h
+include src/binarydiff.h
+include src/output.h
+include src/simulationarchive.h
+include src/transformations.h
+include src/transformations.c
+include README.md
+include LICENSE
+include version.txt
+include pyproject.toml
+recursive-include rebound/tests *.py
+include rebound/rebound.h

rebound/source/Makefile

@@ -0,0 +1,16 @@
+# This Makefile compiles the shared dynamic library librebound.so
+include src/Makefile.defs
+
+librebound: 
+	$(MAKE) -C src 
+	@$(LINKORCOPYLIBREBOUNDMAIN)
+	@echo "To compile the example problems, go to a subdirectory of examples/ and execute make there."
+
+.PHONY: pythoncopy
+pythoncopy:
+	-cp librebound.so `python -c "import rebound; print(rebound.__libpath__)"`
+	
+all: librebound pythoncopy
+
+clean:
+	$(MAKE) -C src clean

rebound/source/README.md

@@ -0,0 +1,149 @@
+[![Version](https://img.shields.io/badge/rebound-v4.5.1-green.svg?style=flat)](https://rebound.hanno-rein.de)
+[![codecov](https://codecov.io/github/hannorein/rebound/graph/badge.svg?token=Zmynoi99Vl)](https://codecov.io/github/hannorein/rebound)
+[![PyPI](https://badge.fury.io/py/rebound.svg)](https://badge.fury.io/py/rebound)
+[![GPL](https://img.shields.io/badge/license-GPL-green.svg?style=flat)](https://github.com/hannorein/rebound/blob/main/LICENSE)
+[![Paper](https://img.shields.io/badge/arXiv-1110.4876-green.svg?style=flat)](https://arxiv.org/abs/1110.4876)
+[![Paper](https://img.shields.io/badge/arXiv-1409.4779-green.svg?style=flat)](https://arxiv.org/abs/1409.4779)
+[![Paper](https://img.shields.io/badge/arXiv-1506.01084-green.svg?style=flat)](https://arxiv.org/abs/1506.01084)
+[![Paper](https://img.shields.io/badge/arXiv-1603.03424-green.svg?style=flat)](https://arxiv.org/abs/1603.03424)
+[![Paper](https://img.shields.io/badge/arXiv-1701.07423-green.svg?style=flat)](https://arxiv.org/abs/1701.07423)
+[![Paper](https://img.shields.io/badge/arXiv-1704.07715-green.svg?style=flat)](https://arxiv.org/abs/1704.07715)
+[![Paper](https://img.shields.io/badge/arXiv-1903.04972-green.svg?style=flat)](https://arxiv.org/abs/1903.04972)
+[![Paper](https://img.shields.io/badge/arXiv-1907.11335-green.svg?style=flat)](https://arxiv.org/abs/1907.11335)
+[![Docs](https://img.shields.io/badge/Documentation-green.svg?style=flat)](https://rebound.hanno-rein.de/)
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/hannorein/rebound/main)
+[![REBOUND (C)](https://github.com/hannorein/rebound/actions/workflows/c.yml/badge.svg)](https://github.com/hannorein/rebound/actions/workflows/c.yml)
+[![REBOUND (python)](https://github.com/hannorein/rebound/actions/workflows/python.yml/badge.svg)](https://github.com/hannorein/rebound/actions/workflows/python.yml)
+    
+
+# Welcome to REBOUND
+
+![REBOUND Examples](https://github.com/hannorein/rebound/raw/main/docs/img/reboundbanner.png)
+
+REBOUND is an N-body integrator, i.e. a software package that can integrate the motion of particles under the influence of gravity. The particles can represent stars, planets, moons, ring or dust particles. REBOUND is very flexible and can be customized to accurately and efficiently solve many problems in astrophysics.  
+
+## Features
+
+* No dependencies on external libraries.
+* Runs natively on Linux, MacOS, and Windows. 
+* Symplectic integrators WHFast, SEI, LEAPFROG, EOS.
+* Hybrid symplectic integrators for planetary dynamics with close encounters MERCURIUS
+* Hybrid reversible integrators for planetary dynamics with arbitrary close encounters TRACE
+* High order symplectic integrators for integrating planetary systems SABA, WH Kernel methods.
+* High accuracy non-symplectic integrator with adaptive time-stepping IAS15.
+* Can integrate arbitrary user-defined ODEs that are coupled to N-body dynamics for tides, spin, etc
+* Support for collisional/granular dynamics, various collision detection routines
+* The computationally intensive parts of the code are written entirely in C, conforming to the ISO standard C99, and can be used as a thread-safe shared library
+* Easy-to-use Python module, installation in 3 words: `pip install rebound`
+* Real-time, 3D visualization, for both C and Python.
+* Extensive set of example problems for both C and Python. You can run examples directly from your browser without the need to download or install anything.
+* Parallelized WHFast512 integrator for super fast integrations of planetary systems with SIMD AVX512 instructions
+* Parallelized with OpenMP (for shared memory systems)
+* Parallelized with MPI is supported for some special use cases only (using an essential tree for gravity and collisions)
+* The code is 100% open-source. All features are included in the public repository on github.
+
+## Try out REBOUND 
+
+You can try out REBOUND without installing it. 
+Simply head over to [the documentation](https://rebound.hanno-rein.de/).
+All the C examples have been compiled with emscripten and can run directly in your browser.
+
+## One minute installation
+
+You can install REBOUND with pip if you want to only use the python version of REBOUND:
+
+    pip install rebound
+
+Then, you can run a simple REBOUND simulation such as
+
+```python
+import rebound
+sim = rebound.Simulation()
+sim.add(m=1.0)
+sim.add(m=1.0e-3, a=1.0)
+sim.integrate(1000.)
+sim.status()
+```
+
+If you want to use the C version of REBOUND simply copy and paste this line into your terminal (it won't do anything bad, we promise):
+
+```bash
+git clone https://github.com/hannorein/rebound && cd rebound/examples/shearing_sheet && make && ./rebound
+```
+
+ 
+## Documentation
+The full documentation with many examples, changelogs and tutorials can be found at
+
+<https://rebound.hanno-rein.de>
+
+If you have trouble installing or using REBOUND, please open an issue on github and we'll try to help as much as we can.
+
+There are also short YouTube videos describing various aspects of REBOUND available at https://www.youtube.com/channel/UCNmrCzxcmWVTBwtDPPLxkkw .
+
+## Related projects
+
+### Additional physics
+To easily incorporate additional physics modules such as migration forces, GR effects and spin into your REBOUND simulations, see REBOUNDx at https://github.com/dtamayo/reboundx
+
+### Analytical and semianalytical tools
+If you're interested in comparing numerical simulations to analytical and semianalytical tools for celestial mechanics, see Celmech at https://github.com/shadden/celmech
+
+### Ephemeris-quality integrations of test particles
+To generate ephemeris-quality integrations of test particles in the Solar System with a precision on par with JPL's small body integrator, see ASSIST at https://github.com/matthewholman/assist
+
+## Papers
+
+There are several papers describing the functionality of REBOUND.
+
+1. Rein & Liu 2012 (Astronomy and Astrophysics, Volume 537, A128) describes the code structure and the main feature including the gravity and collision routines for many particle systems. <http://adsabs.harvard.edu/abs/2012A%26A...537A.128R>
+
+2. Rein & Tremaine 2011 (Monthly Notices of the Royal Astronomical Society, Volume 415, Issue 4, pp. 3168-3176) describes the Symplectic Epicycle integrator for shearing sheet simulations. <https://ui.adsabs.harvard.edu/abs/2011MNRAS.415.3168R>
+
+3. Rein & Spiegel 2015 (Monthly Notices of the Royal Astronomical Society, Volume 446, Issue 2, p.1424-1437) describes the versatile high order integrator IAS15 which is now part of REBOUND. <http://adsabs.harvard.edu/abs/2015MNRAS.446.1424R>
+
+4. Rein & Tamayo 2015 (Monthly Notices of the Royal Astronomical Society, Volume 452, Issue 1, p.376-388) describes WHFast, the fast and unbiased implementation of a symplectic Wisdom-Holman integrator for long term gravitational simulations. <http://adsabs.harvard.edu/abs/2015MNRAS.452..376R>
+
+5. Rein & Tamayo 2016 (Monthly Notices of the Royal Astronomical Society, Volume 459, Issue 3, p.2275-2285) develop the framework for second order variational equations. <https://ui.adsabs.harvard.edu/abs/2016MNRAS.459.2275R>
+
+6. Rein & Tamayo 2017 (Monthly Notices of the Royal Astronomical Society, Volume 467, Issue 2, p.2377-2383) describes the Simulationarchive for exact reproducibility of N-body simulations. <https://ui.adsabs.harvard.edu/abs/2017MNRAS.467.2377R>
+
+7. Rein & Tamayo 2018 (Monthly Notices of the Royal Astronomical Society, Volume 473, Issue 3, p.3351–3357) describes the integer based JANUS integrator. <https://ui.adsabs.harvard.edu/abs/2018MNRAS.473.3351R>
+
+8. Rein, Hernandez, Tamayo, Brown, Eckels, Holmes, Lau, Leblanc & Silburt 2019 (Monthly Notices of the Royal Astronomical Society, Volume 485, Issue 4, p.5490-5497) describes the hybrid symplectic integrator MERCURIUS. <https://ui.adsabs.harvard.edu/abs/2019MNRAS.485.5490R>
+
+9. Rein, Tamayo & Brown 2019 (Monthly Notices of the Royal Astronomical Society, Volume 489, Issue 4, November 2019, Pages 4632-4640) describes the implementation of the high order symplectic integrators SABA, SABAC, SABACL, WHCKL, WHCKM, and WHCKC. <https://ui.adsabs.harvard.edu/abs/2019MNRAS.489.4632R/>
+
+## Acknowledgments
+
+If you use this code or parts of this code for results presented in a scientific publication, we would greatly appreciate a citation.
+The simplest way to find the citations relevant to the specific setup of your REBOUND simulation is: 
+
+```python
+sim = rebound.Simulation()
+-your setup-
+sim.cite()
+```
+
+
+## Contributors
+
+* Hanno Rein, University of Toronto, <hanno@hanno-rein.de>
+* Dan Tamayo, Harvey Mudd College, <dtamayo@hmc.edu>
+* David S. Spiegel, Institute for Advanced Study Princeton, <dave@ias.edu>
+* Garett Brown, University of Toronto, <garett.brown@mail.utoronto.ca>
+* Shangfei Liu, Kavli Institute for Astronomy and Astrophysics at Peking University, <liushangfei@pku.edu.cn>
+* Ari Silburt, Penn State University, <ajs725@psu.edu>
+* and many others! Check the git history to find out who contributed to the code.
+
+REBOUND is open source and you are invited to contribute to this project! 
+
+
+## License
+
+REBOUND is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+REBOUND is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with REBOUND.  If not, see <http://www.gnu.org/licenses/>.
+

rebound/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+rebound Project Package Initialization File
+"""

rebound/source/changelog.md

@@ -0,0 +1,589 @@
+# Changelog
+
+This changelog only includes the most important changes in recent updates. For a full log of all changes, please refer to git.
+
+## Version 4.x
+
+### Version 4.5.1
+* Added leapfrog integrators of order 4, 6, and 8. Order can be set with `r->ri_leapfrog->order`.
+* Heartbeat function is now also called when using `reb_simulation_steps()`.
+* OrbitPlot supports more colours. 
+* Fixed an alignment issue when comparing binary snapshots which could have triggered a segfault.
+
+### Version 4.5.0
+* Added support for (Frequency) Modified Fourier Transforms. Heavily based on David Nesvorny's code. The new functions are `reb_frequency_analysis()` in C and `rebound.frequency_analysis()` in python. For usage, see C examples `secular_frequencies` and `frequency_analysis` as well as the iPython notebook `FrequencyAnalysis`. 
+* Support for Jacobi coordinates added when using WHFast with OpenMP.
+* Allow negative periods when initializing hyperbolic orbits.
+
+### Version 4.4.11
+* The collision resolve function now returns a type `enum REB_COLLISION_RESOLVE_OUTCOME`. The actual integer values remain unchanged.
+* Bug in TRACE was fixed.
+* Convergence check for M_to_E function.
+* New API example that shows how to use the Kepler solver without a REBOUND simulation. Updated other examples.
+
+### Version 4.4.10
+* Version bump to rerun github workflows for pypi uploads
+
+### Version 4.4.9
+* Fixes a bug that affected collisions searches with a tree code.
+* Support for mid-timestep add/remove of particles with TRACE.
+* Various small improvements and bugfixes for TRACE.
+* IAS15's `adaptive_mode` is now an ENUM.
+* Some OpenMP improvements.
+
+### Version 4.4.8
+* Added support for symplectic correctors with barycentric coordinates in WHFast.
+
+### Version 4.4.7
+* Added option to disable SSL checks for Horizon queries with `rebound.horizons.SSL_CONTEXT = 'unverified'.`
+* Added unit tests.
+* Added barycentric coordinates for WHFast.
+* Bug fix for when MEGNO is used with adaptive timestepping.
+* Added more error messages.
+* Fixed various issues in documentation.
+
+### Version 4.4.6
+* When initializing particles with "uniform" in python, REBOUND now uses its own `reb_random_uniform()` function. This avoids importing the "random" library and makes results reproducible as the random seed of the simulation is used when generating random numbers.
+* More cracefull interrupt handling. REBOUND now stop the integration after the next timestep when CTRL-C is pressed the first time. If CTRL-C s pressed twice, then long loops (during gravity, collision calculations) are terminated immediately. Continuing an integration after one CTRL-C press should be easier with this change as the simulation does not get corrupted.
+* Fixed typos in documentation.
+
+### Version 4.4.5
+* Version updated to test github workflows
+
+### Version 4.4.4
+* Fixed several memory leaks and other memory issues. It is unlikely that any of those bugs did affect an simulation.
+* When converting units of a particle, the particle radius is now also converted. 
+* Added getter/setters for Pal coordinates to the particle structure in python. Syntax is `sim.particles[1].pal_h`, `sim.particles[1].pal_ix`, etc. 
+
+### Version 4.4.3
+* REBOUND now raises ImportError if it detects a size mismatch between the C and python Simulation structures.
+* Fixes a bug in the WHFast512 synchronization on non-AVX512 systems.
+* Fixes a bug in the SimulationArchive in cases where there are multiple snapshots with t=0.
+* Updates TRACE switching condition to match Lu et al (2024).
+* TRACE binary file size has been reduced.
+* Pericenter passage time is now calculated even if particles are not in a Simulation.
+
+### Version 4.4.2
+* Fixed bug in TRACE when adding particles.
+* Added WHFast fallback for synchronizing WHFast512 simulations with `N_systems` > 1.
+* Output version number used to create Simulationarchive if there is a version mismatch.
+* Added C example `simulationarchive_fields` which outputs all fields in a simulationarchive for debugging purposes.
+
+### Version 4.4.1
+* Fixed bug in TRACE for FULL PERI modes.
+
+### Version 4.4.0
+* Added TRACE integrator. See Lu, Hernandez & Rein (2024) for details on this implementation.
+
+### Version 4.3.2
+* No longer clipping particles and orbits in visualization.
+* Added a scale to visualization. Hide by pressing `t`.
+* Option to take a screenshow manually in png (WebGL) or tga (OpenGL) format by pressing `e`.
+* Improved `plane` visualization mode. Now supporting hyperbolic orbits. 
+* Fixed a memory leak in `reb_simulation_copy`.
+
+### Version 4.3.1
+* Added new `plane` visualization mode for orbits. Press `w` to toggle through available orbit visualization modes.
+* Added python interface for screenshot API.
+* Fixed an issue where no python exception was raised when a particle was added outside a simulation box.
+* Renamed `past_N` to breadcrumbs in visualization module.
+
+### Version 4.3.0
+* Take screenshots of WebGL based visualizations using the `reb_simulation_output_screenshot()` function. You need to connect one web browser to the simulation in order to take screenshots. 
+* Improved synchronization of visualization and simulation on Windows with mutex.
+* Fixes an issue that might lead to NaN values when less than the maximum number of planets are used in WHFast512.
+
+### Version 4.2.0
+* It is now possible to programmatically change all aspects of a REBOUND visualization. This can be used to set up default viewing options or to render animations. See the C examples in `animation_solar_system` and `animation_saturn_rings`.
+* Reworked matrix operations in visualization routines to follow the Model-View-Projection paradigm.
+* Fixed an issues where unit tests would fail because a binary file was not deleted.
+
+### Version 4.1.1
+* Fixed python wheels for windows.
+
+### Version 4.1.0
+* New visualization feature that allows you to show past particle positions and orbits (keyboard commands p, u, and i).
+* After pausing a simulation, you can now advance it by a single timestep by pressing the down arrow or 50 timesteps by pressing the page down key.
+* Visualization now supports scroll to zoom.
+* Fixed memory leaks when using custom ODEs.
+* Fixed broken links in documentations.
+
+### Version 4.0.3
+* Default IAS15 timestepping criterion is now `adaptive_mode=2`. See Pham, Rein, and Spiegel (2024) for details. To use the old default timestepping criterion, set `adaptive_mode=1`.
+* Fixed a race condition that should improve the responsiveness of web based visualizations.
+* Removed the glad dependency from emscripten builds which reduces filesize and improves performance.
+
+### Version 4.0.2
+* Fixes an issue where the default Makefiles included white spaces after the SERVER and OPENGL variable definitions. This caused the main Makefile to ignore these settings.
+* Added `key_callback` function for customizing user interaction in visualizations.
+* Added `simulationarchive_viewer` example.
+* Included `-sGL_ENABLE_GET_PROC_ADDRESS` flag that is now needed for the latest version of emscripten.
+
+### Version 4.0.1
+* Include missing python packages
+
+### Version 4.0.0
+* Major API changes and new features! If you have used a previous version of REBOUND, then you will need to update your code. If you have trouble with the migration, open a GitHub issue!
+* Many function and variable names have changed. They now follow a coherent naming convention. See the naming convention section in the documentation for more information.
+* New visualization module! Previously, using OpenGL visualization required the GLFW library which led to problems on various operating systems. The new visualization module no longer requires ANY dependencies and is compatible with MacOS, Linux, and Windows. It works by running a local web server to which you can point your browser to. In your web browser, an emscripten compiled version of REBOUND handles the WebGL visualization while constantly updating simulation data over HTTP. You can use ssh and port forwarding to visualize simulations on remote servers. Check out the documentation for more details on this new module.
+* OpenGL for all the examples has been turned off by default so that new users don't get stuck at this step. To turn on OPENGL simply change the flag in the Makefile.
+* Added emscripten support. All C examples (including those using visualizations) are now automatically compiled with emscripten on readthedocs.org so you can run from within the browser. No download or installation required.
+* A race condition in OpenGL visualization has been removed. Visualizations run much smoother.
+* `reb_random` functions now callable with `r=NULL`. If `r=NULL` then the time and PID is used as a seed.
+* Removed support for Simulationarchives with version 2. Added some additional support for reading corrupt/old archives.
+* Fixed memory leak in `reb_simulation_copy`.
+* Consistent integer sizes for 32/64bit. This includes padding for `reb_particle` which is stored in the Simulationarchive.
+
+
+## Version 3.x
+
+### Version 3.28.4
+* WHFast512 now support the integration of 2 and 4 planet systems in parallel. Providing a speed up of up to 10x.
+* The sqrt7 function used by IAS15 now support a wider range of input arguments.
+
+### Version 3.28.3
+* Removed distutils requirement in preparation  for python 3.12.
+* Removed rebound.InterruptiblePool as it no longer works with recent python version. Updated examples.
+* Added Holmberg example.
+* Added `adaptive_mode==3` for IAS15 (Aarseth 1985).
+
+### Version 3.28.2
+* Implemented own fmemopen implementation on MacOS. This is mainly to appease conda-forge builds.
+* Improved sqrt7 algorithm allows larger convergence interval.
+
+### Version 3.28.1
+* Improved support for reading old and corrupted Simulationarchives.
+* Renamed `ri_ias15.epsilon_global` to `ri_ias15.adaptive_mode`.
+* Added new timestep method for IAS15 `ri_ias15.adaptive_mode = 2`. This is experimental for now. Details to be described in Pham, Rein & Spiegel (in prep).
+* Added unit tests to check for fused multiply add instruction (these break reproducibility).
+* Added phony target in C Makefile to force rebuilding librebound whenever building examples. 
+
+### Version 3.28.0
+- Native Windows support. REBOUND can now be built natively on Windows (without WSL) using the Microsoft Visual Studio Compiler. 
+- Python Wheels are now provided for Linux, MacOS, and Windows. This should significantly speed up the installation process on a wide variety of systems.
+
+### Version 3.27.0
+* In python, Simulation and Particle objects are now picklable. Just like loading Simulations from a binary file, function pointers will need to be re-set manually after unpickling.
+* The difference between simulations can now be printed out in a human readable form. Python syntax: `sim.diff(sim2)`. C syntax: `reb_simulation_diff(sim2, sim1, 1)`.
+* Reading Simulationarchives with version < 2 is no longer supported.
+* The POSIX function fmemopen() is now required to compile REBOUND. This should not affect many users. However, if you are using macOS, the version needs to be >= 10.13 (this version of macOS, High Sierra, was released in 2017). 
+* Internal changes on how Simulationarchives are written. 
+* Internal variable names that represent the size of allocated buffers now consistently include the name `N_allocated`.
+* The TES (Terrestrial Exoplanet Integrator) has been removed. If you wish to use TES, you will need checkout an earlier version.
+
+### Version 3.26.3
+* A few more changes to reduce the number of compiler warnings. This should not affect any calculation.
+
+### Version 3.26.2
+* Fixed various signed/unsigned int issues. This should reduce the number of compiler warnings but not affect any calculation.
+
+### Version 3.26.1
+* Added support for `AVX512` and `FFP_CONTRACT_OFF` environment variables when using pip to install REBOUND.
+
+### Version 3.26.0
+* Added WHFast512 integrator (Javaheri, Rein, Tamayo 2023)
+
+### Version 3.25.1
+* Bug fixed that prevented the installation via PyPi
+
+### Version 3.25.0
+* MPI parts updated and unit tests added
+* Fixed machine independence bug in TES.
+
+### Version 3.24.3
+* Updated unit tests so they work on 32bit machines
+
+### Version 3.24.2
+* Fixed bug in TES ctypes structure
+
+### Version 3.24.1
+* Added CORS proxy for Horizons request in pyodide
+* Smoother OpenGL animations when using usleep
+* TES calculates orbital period automatically
+
+### Version 3.24.0
+* Added support for Simulationarchive larger than 4 GB.
+* Updated documentation for Lyapunov characteristic number.
+
+### Version 3.23.5
+* Added new units shortcuts (year,years,massist)
+* Rearranged some loops and switch statements (doesn't affect floating point numbers). 
+
+### Version 3.23.4
+* Added pyproject.toml file
+
+### Version 3.23.3
+* Changed the way REBOUND reverses the integration direction when the sign of the timestep is inconsistent with respect to the requested final time.
+* Fixes a memory leak when a tree code is used
+* Fixes an issue where MERCURIUS was not bit-wise reproducible when safe mode was turned off.
+
+### Version 3.23.2
+* Minor changes to the python side of Vec3d to make it more compatible with numpy.
+
+### Version 3.23.1
+* Minor changes related to the REBOUND Rotations framework.
+
+### Version 3.23.0
+* Added the REBOUND Rotations framework.
+* Fixes an issue with showing an incorrect periastron location in OrbitPlot for high mass-ratio systems.
+* Adds pre and post timestep calls to the ode framework.
+
+### Version 3.22.0
+* OrbitPlot is now a class. Checkout the OrbitPlot.ipynb tutorial. This change allows for interactive plots and much faster updates to existing plots. This is great for rendering animations! 
+
+### Version 3.21.0
+* Automatic rescaling of first order variational particles has been added. This will allow you to integrate chaotic systems for longer and obtain a more accruate measure of MEGNO and the Lyapunoc exponent. 
+* Added `sim.stop()` / `reb_simulation_stop()` to end an integration from within the heartbeat function.
+
+### Version 3.20.1
+* Pal coordinates have been added to the `reb_orbit` struct.
+
+### Version 3.20.0
+* A new integrator has been added, the Terrestrial Exoplanet Simulation (TES).
+
+### Version 3.19.10
+* Fixes another bug int he BS integrator when additional forces are used.
+
+### Version 3.19.9
+* Two bugs fixed in the BS integrator. One was related to unitialized memory and the other to issues when the particle number changed.
+
+### Version 3.19.5
+* Workaround for urllib support in pyodide added
+* Silent warning when InterruptiblePool is not available
+
+### Version 3.19.4
+* InterruptiblePool is optional.
+* Fixed an issue that occured when switching integrators while using the Simulationarchive.
+* Renamed `srand_seed` to make it user accessible. 
+
+### Version 3.19.3
+* Added several examples.
+* Changed how pypi is rendering the documentation.
+
+### Version 3.19.2
+* Fixes a bug relates to test particles of type 0 in MERCURIUS.
+
+### Version 3.19.1
+* Some compilers seem to complain that a constant cannot be initialized from a constant. Fixed this so that REBOUND works on colaboratory.
+
+### Version 3.19.0
+* 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.
+
+### Version 3.18.1
+* 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. 
+
+### Version 3.18.0
+* 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. 
+
+### Version 3.17.5
+* 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.
+
+### Version 3.17.4
+* 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.
+
+### Version 3.17.3
+* Allow for Horizon queries with future JD dates.
+
+### Version 3.17.2
+* Moved some function declarations to rebound.h. This is a temporary fix for REBOUNDx.
+
+### Version 3.17.1
+* 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). 
+
+### Version 3.17.0
+* Added new 'reb_simulation_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.
+
+### Version 3.16.0
+* 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.
+
+### Version 3.15.0
+* 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.
+
+### Version 3.14.0
+* 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. All `reb_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. 
+
+### Version 3.13.2
+* Correct handling of test particles in reb_transformations.
+* Small bug fixes 
+
+### Version 3.13.1
+* WHFast: Fixes multiple issues with testparticles in WHFast. 
+
+### Version 3.13.0
+* 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.
+
+### Version 3.12.3
+* Various small bug fixes 
+* Added a new function sim.cite() to automatically generate citations depending on the current simulation settings. 
+
+### Version 3.12.2
+* Various bug fixes to MERCURIUS
+* Performance increase when using the BASIC Gravity Routine with OpenMP
+  
+### Version 3.12.1
+* Bug fixes to LINE and LINETREE algorithms
+  
+### Version 3.12.0
+* 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.
+
+### Version 3.11.1
+* 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.
+
+### Version 3.11.0
+* 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. 
+
+### Version 3.10.2
+* Updates to OrbitPlot. Includes better layout of plot and some syntax changes. See OrbitPlot documentation for the new syntax.
+
+### Version 3.10.1
+* Small syntax changes for SABA integrator family. 
+* Includes high order integrators by Blanes et al. (2013).
+
+### Version 3.10.0
+* Changes for the new version of REBOUNDx. 
+
+### Version 3.9.0
+* 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. 
+
+### Version 3.8.3
+* Improves and fixes various issues related to variational equations and MEGNO. 
+
+### Version 3.8.2
+* Fixes a bug which resulted in duplicate snapshots in Simulationarchives when restarting simulations.
+
+### Version 3.8.1
+*   Syntax change on the python side to create a simulation from a binary file or Simulationarchive:
+    
+    ```python
+    rebound.Simulation.from_file("test.bin") becomes rebound.Simulation("test.bin") 
+    rebound.Simulation.from_archive("test.bin",5) becomes rebound.Simulation("test.bin",5) 
+    ```
+
+### Version 3.8.0
+* 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.
+
+### Version 3.7.1 
+* 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.
+
+### Version 3.7.0
+* Added a deep copy functionality: reb_simulation_copy() in C, and sim.copy() in python. 
+* Refactored WHFast to enable calling only certain substeps. 
+
+### Version 3.6.8
+* 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}$.
+
+### Version 3.6.7
+* Fixes an issue related to collisions and the Mercurius integrator that prevented the last_collision property to be updated.
+
+### Version 3.6.6
+* New: Fancy plotting routine. Usage: rebound.OrbitPlot(sim, fancy=True)
+
+### Version 3.6.5
+* One can now add particles from NASA Horizons using Julian Days. For example: sim.add("Earth", date="JD2458327.500000")
+
+### Version 3.6.4
+* Fixes a memory leak when using the old Simulationarchive version. Thanks to Ian Rabago for reporting the issue.
+
+### Version 3.6.2
+* Fixes a memory leak in the Simulationarchive read function.
+
+### Version 3.6.1
+* 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
+
+### Version 3.6.0
+* 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. 
+
+### Version 3.5.12
+* 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.
+
+### Version 3.5.11
+* 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.
+
+### Version 3.5.10
+* Refactored OrbitPlot.
+
+### Version 3.5.9
+* SIGINT handler added. Allows for garceful exit and keyboard interrupts (even from python).
+
+### Version 3.5.8
+* WebGL widget text overlay added.
+
+### Version 3.5.7
+* Bug fixes related to WebGL widget and ipywidgets version 6
+
+### Version 3.5.6
+* Updated WebGL widget to work with ipywidgets version 7
+
+### Version 3.5.5
+* Various fixed for Mercurius
+
+### Version 3.5.4
+* Bug fix for N_active=-1 (default)
+
+### Version 3.5.3
+* 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).
+
+### Version 3.5.2
+* Fixes an issue with the WebGL widget.
+* Fixes an issue with external forces and MERCURIUS.
+
+### Version 3.5.1
+* MERCURIUS is not compatible with binary files and the Simulationarchive.
+
+### Version 3.5.0
+* 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.
+
+### Version 3.4.0
+* Added a screenshot functionality for the WebGL ipython widget. This lets you take screenshots programmatically which is useful to create movies of simulations. 
+
+### Version 3.3.1
+* Removed the march=native compiler flag as it seems to be problematic for some OSX/Sierra compilers.
+
+### Version 3.3.0
+* 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.
+
+### Version 3.2.4
+* 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.  
+
+### Version 3.2.3
+* Various minor bug fixes. Added pre-timestep modifications for REBOUNDx. 
+
+### Version 3.2.2
+* Various minor bug fixes. One related to exact_finish_time=1. 
+
+### Version 3.2.0
+* 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.widget()` 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.
+
+
+### Version 3.1.1
+* 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. 
+
+### Version 3.1.0
+* 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 with `sudo apt-get install libglfw3-dev`. 
+
+### Version 3.0.0
+* Introducing the Simulationarchive. The Simulationarchive 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.
+
+
+## Version 2.x
+### Version 2.20.6
+* Minor bug fixes in HERMES integrator and some examples.
+
+### Version 2.20.5
+* NASA Horizons changed a telnet command. This update implements those changes and restores access to NASA Horizons from within REBOUND.
+
+### Version 2.20.4
+* 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.
+
+### Version 2.20.3
+* Small changes to HERMES integrator. It now has a Solar Switch Factor SSF to allow for close encounters with the central object. 
+
+### Version 2.20.2
+* Added adaptive HSF for HERMES integrator. More documentation and paper to follow. 
+
+### Version 2.20.1
+* Added symplectic correctors for WHFastHelio integrator. See Wisdom (2006). 
+* Improved accuracy of symplectic corrector coefficients for WHFast and WHFastHelio.
+
+### Version 2.20.0
+* 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. 
+
+### Version 2.19.2
+* Changes to how particle hashes are handled.
+
+### Version 2.19.1
+* 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. 
+
+### Version 2.19.0
+* 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.
+
+### Version 2.18.9
+* Added the reb_simulation_get_serialized_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)
+
+
+### Version 2.18.5
+* 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.
+
+
+### Version 2.18.0
+* 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). 
+
+### Version 2.17.0
+* What used to be called ``id`` in the particle structure is now called ``hash``. 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. using ``sim.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 the ``collision_resolve_merge`` routine), 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)
+   # Setting a hash using a string:
+   sim.particles[1].hash = "planet1"
+   # Finding a particle using a string:
+   p = sim.get_particle_by_hash("planet1")
+   # Setting a random unique hash:
+   sim.particles[1].hash = sim.generate_unique_hash() 
+   # Save unique hash to find particle later
+   uhash = sim.particles[1].hash
+   # Find particle using the hash
+   p = sim.get_particle_by_hash(uhash)
+   
+
+
+### Version 2.0.0
+* 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_simulation`` structure. 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 ``Makefile`` that 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. 
+

rebound/source/docs/addingparticles.md

@@ -0,0 +1,169 @@
+# Adding particles
+
+![type:video](https://www.youtube.com/embed/FoTwDtAeJyk)
+
+Once you've created a [simulation object](simulation.md), you can add particles to it. 
+REBOUND supports several different ways to do that. 
+Also check out the [discussion on particle operators](particleoperators.md).
+
+## Adding particles manually
+One way to add a particle to a simulation is to first manually create a particle object, then calling a function to add the particle to the simulation.
+Because the function will make a copy of the particle, you can safely delete the original particle object after you've added it to a simulation. 
+The following code shows an example on how to add particles this way:
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    struct reb_particle p = {0};
+    p.m = 1.;
+    p.x = 1.;
+    reb_simulation_add(r, p);
+    ```
+    !!! Important
+        The `= {0}` syntax above ensures that the struct is initialized with zeros.
+        Otherwise, you need to set every member of the struct to ensure that there are no
+        uninitialized values.
+
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    p = rebound.Particle()
+    p.m = 1.
+    p.x = 1.
+    sim.add(p)
+    ```
+
+You can also use orbital parameters to initialize the particle object.
+=== "C"
+    In C, this is done by calling the `reb_particle_from_orbit` function. Its arguments are gravitational constant, primary object, mass, semi-major axis, eccentricity, inclination, longitude of ascending node, argument of pericenter, and true anomaly. 
+    It returns an initialized particle object which you can then add to the simulation.
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    struct reb_particle primary = {0};
+    primary.m = 1;
+    reb_simulation_add(r, primary);
+    struct reb_particle planet = reb_particle_from_orbit(r->G, primary, 1e-3, 1., 0., 0., 0., 0., 0.);
+    reb_simulation_add(r, planet);
+    ```
+
+    You can also the coordinates described by [Pal 2009](https://ui.adsabs.harvard.edu/abs/2009MNRAS.396.1737P/abstract) to initialize orbits using the following function:
+
+    ```c
+    struct reb_particle reb_particle_from_pal(double G, struct reb_particle primary, double m, double a, double lambda, double k, double h, double ix, double iy);
+    ``` 
+    Here, `lambda` is the longitude, `h` is $e\cos(\omega)$, `k` is $e\sin(\omega)$, `ix` and `iy` are the x and y components of the inclination respectively. 
+
+=== "Python"
+    In python, you can create and initialize particles using the constructor of the `Particle` class.
+    ```python
+    sim = rebound.Simulation()
+    primary = rebound.Particle(m=1., x=1.)
+    sim.add(primary)
+    ```
+    If you want to use orbital parameters, you need to pass the primary and the simulation to the constructor:
+    ```python
+    planet = rebound.Particle(simulation=sim, primary=primary, m=1e-3, a=1., e=0.1)
+    ```
+    You can use any combination of orbital parameters that makes physically sense. 
+    See [the discussion on orbital elements](orbitalelements.md) for more details.
+
+    !!! Note
+        In most cases you can simply use the convience function described below.
+        This way you don't have to create a particle object just to add it to the simulation.
+
+## Convenience functions
+By far the easiest way to add particles to REBOUND is to use a convenience function.
+=== "C"
+    In C, the function is called `reb_simulation_add_fmt` and has the following syntax:
+    ```c
+    void reb_simulation_add_fmt(struct reb_simulation* r, const char* fmt, ...);
+    ```
+    This is a [variadic function](https://en.cppreference.com/w/c/variadic) which takes a variable number of arguments similar to the `printf` function.
+    The following code shows how this function is used.
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    reb_simulation_add_fmt(r, "m", 1.0);                // star at origin with mass 1
+    reb_simulation_add_fmt(r, "m a", 1e-3, 1.0);        // planet with mass 1e-3 and semi-major axis 1
+    reb_simulation_add_fmt(r, "m a e", 1e-3, 2.0, 0.1); // planet with mass 1e-3, semi-major axis 2, and eccentricity 0.1
+    reb_simulation_add_fmt(r, "m x vy", 1e-6, 1., 1.);  // planet with mass 1e-6, cartesian coordinates
+    ```
+
+    The first argument is the simulation to which you want to add the particle.
+    The second argument is a format string and it determines how many other arguments the function expects.
+
+    !!! Danger
+        You need to pass exactly the right number of arguments to `reb_simulation_add_fmt` as indicated by your format string. 
+        Each argument also has to be the right type (mostly double floating point numbers).
+        The latter is particularly important. If you call the function like this:
+        ```c
+        reb_simulation_add_fmt(r, "m a", 1, 1);
+        ```
+        then the arguments are integers, not doubles. This can lead to unexpected behaviour that is very difficult to debug.
+        The correct way to call the function is by making sure the arguments are doubles (by adding a `.`):
+        ```c
+        reb_simulation_add_fmt(r, "m a", 1.0, 1.0);
+        ```
+
+    The following parameters are supported:
+
+    Parameter | Description
+    --------- | -----------
+    `m`|          mass  (default: 0)
+    `x, y, z`|    positions in Cartesian coordinates  (default: 0)
+    `vx, vy, vz`| velocities in Cartesian coordinates (default: 0)
+    `primary`|    primary body for converting orbital elements to cartesian (default: center of mass of the particles in the passed simulation, i.e., this will yield Jacobi coordinates as one progressively adds particles) 
+    `a`|          semi-major axis (a or P required if passing orbital elements)
+    `P`|          orbital period (a or P required if passing orbital elements)
+    `e`|          eccentricity                (default: 0)
+    `inc`|        inclination                 (default: 0)
+    `Omega`|      longitude of ascending node (default: 0)
+    `omega`|      argument of pericenter      (default: 0)
+    `pomega`|     longitude of pericenter     (default: 0)
+    `f`|          true anomaly                (default: 0)
+    `M`|          mean anomaly                (default: 0)
+    `E`|          eccentric anomaly           (default: 0)
+    `l`|          mean longitude              (default: 0)
+    `theta`|      true longitude              (default: 0)
+    `T`|          time of pericenter passage  
+    `h, k, ix, iy`|      See [Pal 2009](https://ui.adsabs.harvard.edu/abs/2009MNRAS.396.1737P/abstract) for a definition  (default: 0)
+    `r`|          physical particle radius
+ 
+    You can use any combination of these parameters at the same time. 
+    If a combination is unphysical, no particle will be added and an error will be outputted.
+    For example, you can only specify one longitude or anomaly.
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.add(m=1)                 # star at origin with mass 1                                      
+    sim.add(m=1e-3, a=1.)        # planet with mass 1e-3 and semi-major axis 1
+    sim.add(m=1e-3, a=2., e=0.1) # planet with mass 1e-3, semi-major axis 2, and eccentricity 0.1
+    sim.add(m=1e-6, x=1., vy=1.) # planet with mass 1e-6, cartesian coordinates
+    ```
+
+See [the discussion on orbital elements](orbitalelements.md) for more details.
+
+
+## Solar System planets
+If you want to quickly try something out, you can use a set of initial conditions for the Solar System that come with REBOUND: 
+
+```python
+sim = rebound.Simulation()
+rebound.data.add_solar_system(sim)
+```
+
+and similarly for the outer Solar System:
+
+```python
+sim = rebound.Simulation()
+rebound.data.add_outer_solar_system(sim)
+```
+
+
+This is currently only supported in python.
+
+!!! Note
+    These initial conditions are intended for testing integration methods. They might not be very accurate and should not be used for detailed dynamical studies of the Solar System.
+
+

rebound/source/docs/api.md

@@ -0,0 +1,20 @@
+# REBOUND API
+These pages describe the main features of REBOUND and its API.
+
+There are two structures (*objects* in Python) which you will encounter frequently when working with REBOUND.
+The first is the [Simulation structure](simulation.md) which contains all the configuration, status and particle data of one REBOUND simulation.
+The second is the [Particle structure](particles.md) which represents one particle in a simulation.
+
+REBOUND is a modular code.
+You can combine different [gravity solvers](gravity.md), [collision detection algorithms](collisions.md), [boundary conditions](boundaryconditions.md), and [integration methods](integrators.md). 
+Not all combinations make physically sense, and not all combinations are supported.
+We describe the different modules and their configuration in this section.
+
+Also make sure to some of the other concepts documented in this section. 
+They will help you understand the [units](units.md) used in REBOUND, how REBOUND handles [orbital elements](orbitalelements.md), how to save and load simulations to [Simulationarchive](simulationarchive.md) files, how to use [chaos indicators](chaos.md), how to use the [browser based 3D visualization](visualization.md), and several other topics.
+
+
+!!! Info
+    Because the C and Python versions of REBOUND are very similar, we describe both languages in one documentation. 
+    The syntax and examples are provided in both C and Python. 
+    Use the tabs to switch between them.

rebound/source/docs/binaryformat.md

@@ -0,0 +1,172 @@
+# Binary Format
+
+REBOUND comes with its own binary format.
+The binary format allows you to store a current simulation state to a file or to memory.
+The binary format is also used when you make a copy of a simulation or when you compare two simulations with each other.
+The Simulationarchive is an extension of the binary format which allows you to store multiple snapshots of a simulation in one file.
+This page explains the details of the binary format.
+It is mainly intended for people who wish to extend the built-in REBOUND functionality.
+You do not need to know those details if you're only working with binary files to save and load simulations.
+
+REBOUND uses two structures for the binary files:
+
+```c
+struct reb_binary_field {
+    uint32_t type; 
+    uint64_t size;
+};
+```
+
+and 
+
+```c
+struct reb_simulationarchive_blob {
+    int32_t index;
+    int32_t offset_prev;
+    int32_t offset_next;
+};
+```
+
+!!! note
+    Before version 3.18, the offset datatype was `int16_t`. This caused problems for simulations with a large number of particles and has since been change to `int32_t`.
+
+## Binary file (one snapshot)
+You create a binary file if you save a simulation
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    // ... setup simulation ...
+    reb_simulation_save_to_file(r, "snapshot.bin");
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    // ... setup simulation ...
+    sim.save_to_file("snapshot.bin")
+    ```
+Such a binary file with one snapshot is simply a set of `reb_binaryfield`s followed by one `reb_simulationarchive_blob` at the end, for example:
+
+```
+reb_binary_field:
+    type: DT
+    size: 8 bytes
+
+8 bytes of data representing the value of DT
+
+reb_binary_field:
+    type: PARTICLES
+    size: 128 bytes
+
+128 bytes of data representing the values of PARTICLES
+
+...
+
+reb_binary_field:
+    type: END
+    size: 0
+
+reb_simulationarchive_blob:
+    index: 0
+    offset_prev: 0
+    offset_next: 0
+```
+
+Each of the binary fields provides the context (type and size) for the data that immediately follows the field.
+The type is an integer defined in the `reb_binary_field_descriptor_list` (see below).
+The last binary field of type `9999` (`end`) to indicate that the snapshot ends here. 
+
+!!! note
+    Before version 3.27 data was encoded using the enum `REB_BINARY_FIELD_TYPE` instead of `reb_binary_field_descriptor_list`.
+
+
+## Simulationarchive file (multiple snapshots)
+The binary file above can also be interpreted as a Simulationarchive with one snapshot. 
+You can append many (millions!) of snapshots to a binary file.
+REBOUND only stores data that has changed since the original snapshot (typically the particle data, time, etc).
+This allows for a very compact file size, while still maintaining bit-wise reproducibility. 
+
+Each snapshot is separated by a `reb_simulationarchive_blob`. 
+The blob contains the offset to the previous and next blobs. 
+This allows REBOUND to quickly jump from one blob in the archive to the next.
+Between the blobs are the same `reb_binary_field`s we already encountered for a binary file with one snapshot.
+Thus, a Simulationarchive file with multiple snapshots looks something like this:
+
+```
+reb_binary_field:
+    type: DT
+    size: 8 bytes
+
+8 bytes of data representing the value of DT
+
+... more reb_binary_fields ...
+
+reb_binary_field:
+    type: END
+    size: 0
+
+reb_simulationarchive_blob:
+    index: 0
+    offset_prev: 0
+    offset_next: 256 (offset to the next blob)
+
+reb_binary_field:
+    type: DT
+    size: 8 bytes
+
+8 bytes of data representing the value of DT
+
+... more reb_binary_fields ...
+
+reb_binary_field:
+    type: END
+    size: 0
+
+reb_simulationarchive_blob:
+    index: 1
+    offset_prev: 256 (offset to the previous blob)
+    offset_next: 256 (offset to the next blob)
+
+reb_binary_field:
+    type: DT
+    size: 8 bytes
+
+8 bytes of data representing the value of DT
+
+... more reb_binary_fields ...
+
+reb_binary_field:
+    type: END
+    size: 0
+
+reb_simulationarchive_blob:
+    index: 2
+    offset_prev: 256 (offset to the previous blob)
+    offset_next: 0 
+```
+
+The offsets are also used as a sort of checksum to detect if a binary file has been corrupted (for example because a user ran out of disk space). 
+If a binary file is corrupted, REBOUND attempts some magic and will recover the last snapshot which does not appear corrupted.
+You will see a warning message when that happens and should proceed with caution (make a backup!). 
+
+
+## Binary Field Descriptor
+
+REBOUND maintains a list of fields it needs to input/output in order to restore a simulation. 
+This list is of type `struct reb_binary_field_descriptor[]` and defined in `output.c` as `reb_binary_field_descriptor_list`.
+A single struct `reb_binary_field_descriptor` contains the information to input/output one REBOUND field, for example the current simulation time `t`:
+
+```c
+    struct reb_binary_field_descriptor fd_t = { 0, REB_DOUBLE, "t", offsetof(struct reb_simulation, t), 0, 0};
+```
+The first number is a unique identifier (in this case 0). The second entry is the type of data, in this case a single double precision floating point number. The third entry is a string used to identify the field. This is only used when generating human-readable output and is typically the same as the variable name in C. The next entry is the offset of where this variable is stored relative to the beginning of the simulation structure. 
+
+REBOUND also supports array like fields. For example consider the `particles` field:
+```c
+    struct reb_binary_field_descriptor fd_particles = { 85, REB_POINTER, "particles", offsetof(struct reb_simulation, particles), offsetof(struct reb_simulation, N), sizeof(struct reb_particle)};
+```
+
+The second to last entry lists the offset of the a variable in the `reb_simulation` structure that determines the number of array elements. In this case the number of particles. The last entry is the size of a single element. In this case, the size of one `reb_particle`.
+
+If you add an additional field to the `reb_simulation` struct and you want to write it to a binary file and read it back in, then you need to add an entry to `reb_binary_field_descriptor_list`.
+

rebound/source/docs/boundaryconditions.md

@@ -0,0 +1,108 @@
+# Boundary conditions
+
+You can use different boundary conditions with REBOUND. 
+
+## No boundaries
+By default, REBOUND doesn't use boundary conditions.
+This means particle can have arbitrary coordinates in all three dimensions (as long as they can be represented as floating point numbers). 
+Because this is the default setting, you don't need to do anything if you don't want boundary conditions.
+Nevertheless, here is the syntax to set this manually:
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->boundary = REB_BOUNDARY_NONE;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.boundary = "none"
+    ```
+
+## Open
+When open boundary conditions are selected, particles are removed from the simulation if they leave the simulation box.
+You therefore also need to set the size of the simulation box whenever you use open boundary conditions. 
+The syntax is as follows:
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    reb_simulation_configure_box(r, 10., 1, 1, 1); # confine the simulation to a box of size 10
+    r->boundary = REB_BOUNDARY_OPEN;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.configure_box(10.)   # confine the simulation to a box of size 10
+    sim.boundary = "open"
+    ```
+
+## Periodic
+When periodic boundary conditions are uses, particles are reinserted on the opposite side if they leave a simulation box. 
+You can use an arbitrary number of ghost-boxes with this module.
+The syntax is as follows:
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    reb_simulation_configure_box(r, 10., 1, 2, 3); # confine the simulation to a box of size 10x20x30
+    r->boundary = reb_boundary_periodic;
+    ```
+
+=== "python"
+    ```python
+    sim = rebound.simulation()
+    sim.configure_box(10., 1, 2, 3)   # confine the simulation to a box of size 10x20x30
+    sim.boundary = "periodic"
+    ```
+
+Ghost boxes are supported for both periodic and shear-periodic boundary conditions.
+Ghost boxes can be used to allow particle collisions across boundaries and include gravitational forces from outside the box boundaries. 
+This is particularly useful when simulating rings and disks. 
+The following code sets up two rings of ghost boxes in the x and y directions.
+
+=== "C"
+    ```c
+    r->N_ghost_x = 2;
+    r->N_ghost_y = 2;
+    r->N_ghost_z = 0;
+    ```
+
+=== "python"
+    ```python
+    sim.N_ghost_x = 2
+    sim.N_ghost_y = 2
+    sim.N_ghost_z = 0
+    ```
+
+See [Rein & Liu](https://ui.adsabs.harvard.edu/abs/2012A%26A...537A.128R/abstract) for details on the ghost box implementation.
+
+You might encounter the `reb_vec6d` structure in various parts of the code, for example in function related to gravity calculation and collision detection. 
+It often contains the relative position and velocity of a ghost-box.
+If there are no ghost-boxes used, then all elements of this structure will be zero.
+
+## Shear
+![Shearing sheet](img/shear.png)
+
+These are shear periodic boundary conditions. 
+They are similar to periodic boundary conditions, but ghost-boxes are moving with constant speed, set by the shear.
+This is useful when simulation a small patch in a ring or disk. 
+You also need to set the `OMEGA` variable in the simulation which set the epicyclic frequency.
+For more information on how to setup simulations of planetary rings in REBOUND, see [Rein & Liu](https://ui.adsabs.harvard.edu/abs/2012A%26A...537A.128R/abstract). 
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    reb_simulation_configure_box(r, 10., 1, 1, 1); 
+    r->OMEGA = 1.0;
+    r->boundary = REB_BOUNDARY_SHEAR;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.configure_box(10.)
+    sim.OMEGA = 1.0
+    sim.boundary = "shear"
+    ```

rebound/source/docs/c_examples/compile_emcc.bash

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+source emsdk/emsdk_env.sh
+READTHEDOCS_OUTPUT="${READTHEDOCS_OUTPUT:-.}"
+OPTIMI="${1:-3}"
+    
+echo "Compiling C examples with emscripten."
+echo "Output dir: $READTHEDOCS_OUTPUT"
+echo ""
+
+for dir in examples/*/
+do
+    echo "Working on $dir ..."
+    mpi_enabled=$(cat $dir/Makefile | grep -c "export MPI=1")
+    openmp_enabled=$(cat $dir/Makefile | grep -c "export OPENMP=1")
+    server_used=$(cat $dir/problem.c | grep -c "reb_simulation_start_server")
+    if [ $mpi_enabled -eq 0 ] && [ $openmp_enabled -eq 0 ]; then
+        mkdir -p $READTHEDOCS_OUTPUT/html/emscripten_c_$dir/
+        echo "Compiling... "
+        if [ $server_used -eq 0 ]; then
+            emcc -O$OPTIMI -Isrc/ src/*.c $dir/problem.c -DSERVERHIDEWARNING -sSTACK_SIZE=655360 -s -sASYNCIFY -sALLOW_MEMORY_GROWTH -sEXPORTED_RUNTIME_METHODS="callMain" --shell-file web_client/shell_rebound_console.html -o $READTHEDOCS_OUTPUT/html/emscripten_c_$dir/index.html || exit 1
+        else
+            emcc -O$OPTIMI -Isrc/ src/*.c $dir/problem.c -DSERVERHIDEWARNING -DOPENGL=1 -sSTACK_SIZE=655360 -s USE_GLFW=3 -s FULL_ES3=1 -sASYNCIFY -sALLOW_MEMORY_GROWTH -sEXPORTED_RUNTIME_METHODS="callMain" --shell-file web_client/shell_rebound_webgl.html -o $READTHEDOCS_OUTPUT/html/emscripten_c_$dir/index.html || exit 1
+        fi
+        echo "Done. "
+    else
+        echo "Skipping."
+    fi
+    echo ""
+
+done

rebound/source/docs/c_examples/generate_c_examples.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+import glob
+
+# C Example update
+def run(*args, **kwargs):
+    print("Generating C examples.")
+    count = 0
+    for problemc in glob.glob("examples/*/problem.c"):
+        count += 1
+        cname = problemc.split("/")[1]
+        with open("docs/c_examples/"+cname+".md","w") as fd:
+            will_output = 0
+            livepreview=1
+            # Manual exception for file viewer
+            if "_viewer" in cname:
+                livepreview=0
+            if "screenshots" in cname:
+                livepreview=0
+            try:
+                with open("examples/"+cname+"/Makefile","r") as mfd:
+                    Makefile = mfd.read()
+                    if "export MPI=1" in Makefile:
+                        livepreview=0
+                    if "export OPENMP=1" in Makefile:
+                        livepreview=0
+            except:
+                print("Warning: Makefile error in "+problemc)
+            
+            with open(problemc) as pf:
+                did_output=0
+                empty_lines = 0
+                for line in pf:
+                    if line[0:3] == "/**":
+                        will_output += 1
+                    if line[0:3] == " */":
+                        will_output = -1
+                        line = ""
+                        fd.write("\n\n```c\n")
+                    if will_output>1:
+                        if will_output == 2:
+                            line = "   # "+line[3:].strip() + " (C)\n"
+                            if livepreview == 1:
+                                line += "!!! example \"Try it out this example!\"\n"
+                                line += "    REBOUND has been compiled with emscripten to WebAssembly.\n"
+                                line += "    This lets you run this example interactively from within your browser at almost native speed.\n"
+                                line += "    No installation is required.\n"
+                                line += "    [Click here](../../emscripten_c_examples/"+cname+"/) to try it out.\n"
+                        will_output = 2
+                        if len(line[3:].strip())==0:
+                            fd.write("\n\n"+line[3:].strip())
+                        else:
+                            fd.write(line[3:].strip() + " " )
+                    if will_output==-1:
+                        fd.write("" +line.rstrip() + "\n" )
+                        did_output = 1
+                    if will_output>0:
+                        will_output += 1
+                fd.write("```\n")
+                fd.write("\n\nThis example is located in the directory `examples/"+problemc.split("/")[1]+"`\n\n")
+                if did_output==0:
+                    print("Warning: Did not find description in "+problemc)
+    print("Converted %d C examples."%count)
+if __name__ == "__main__":
+    run()

rebound/source/docs/c_outputfunctions.md

@@ -0,0 +1,78 @@
+# C output functions
+
+The functions listed here provide various output functionality. 
+
+## Output check
+
+```c
+int reb_simulation_output_check(struct reb_simulation* r, double interval);
+```
+
+This function can be used to trigger outputs at regular time intervals.
+The function returns 1 if an output is required and 0 otherwise.
+Typically, you would use this within the heartbeat function to generate equally spaced outputs as in this example:
+
+```c
+void heartbeat(struct reb_simulation* const r){
+    if (reb_simulation_output_check(r, 100.)){
+        printf("t = %f\n", r->t); // Will print current time every 100 time units.
+    }
+}
+```
+
+## Timing
+
+```c
+void reb_simulation_output_timing(struct reb_simulation* r, const double tmax);
+```
+
+This function outputs various status information on the screen. An example output looks as follows
+
+```
+N_tot=  10   t= 4610.00   dt= 4.000  cpu= 0.002472 [s]  t/tmax= 0.01%
+```
+
+It shows the number of particles, the current time and time-step, as well as the time since the last output. If `tmax` is non-zero, then the last number indicates how far the simulation has progressed. 
+
+## ASCII orbits 
+```c
+void reb_simulation_output_orbits(struct reb_simulation* r, char* filename);
+```
+This function creates or appends an ASCII file with orbital parameters of all particles.
+The orbital parameters are calculated in Jacobi coordinates.
+Particles are assumed to be sorted from the inside out, the central object having index 0. 
+Each time the function is called N-1 rows are appended to the file with name filename.
+Each row in the file corresponds to one particle and contains the following columns (tab separated):
+
+ - time
+ - semi-major axis
+ - eccentricity
+ - inclination
+ - Omega (longitude ascending node)
+ - omega (argument of pericenter)
+ - lambda (mean longitude)
+ - orbital period,
+ - f (true anomaly) 
+
+## ASCII coordinates
+```c
+void reb_simulation_output_ascii(struct reb_simulation* r, char* filename);
+```
+This function creates or appends an ASCII file with the positions and velocities of all particles to an ASCII file.
+
+## Velocity dispersion
+```c
+void reb_simulation_output_velocity_dispersion(struct reb_simulation* r, char* filename);
+```
+This function creates or appends an ASCII file with the current velocity dispersion of all particles. 
+This is useful for ring simulations where one wants to monitor that the system has reached an equilibrium.
+
+## Binary snapshot
+```c
+void reb_simulation_save_to_file(struct reb_simulation* r, const char* filename);
+```
+
+These functions save the `reb_simulation` structure as a binary file.
+It can be used to save the current status of a REBOUND simulation and later restart the simulation.
+If the file exists, this function will append a snapshot.
+

rebound/source/docs/c_randomsamplingfunctions.md

@@ -0,0 +1,41 @@
+# Random sampling
+
+REBOUND includes several functions which help sampling random numbers from various distributions.
+Each function takes a pointer to a `struct reb_simulation` as a first argument.
+This is because the simulation structure stores the random number generator state in the member `rand_seed`. 
+When a simulation is created, `rand_seed` is initialized using the current time and process id. 
+These functions are thread safe.
+The `rand_seed` variable is stored in binary files. This makes the random number generator reproducible which can be very helpful when debugging simulations that use random numbers. 
+
+The following example draws a number in the interval between 0 and $2\pi$ from a uniform distribution.
+```c
+struct reb_simulation* r = reb_simulation_create();
+double phi = reb_random_uniform(r, 0., 2.*M_PI);
+```
+
+# Uniform
+This function returns a uniformly distributed random variable between `min` and `max`.
+```c
+double reb_random_uniform(struct reb_simulation* r, double min, double max);
+```
+
+# Power law
+This function returns a random variable drawn form a power law distribution with slope `slope` between `min` and `max`. 
+```c
+double reb_random_powerlaw(struct reb_simulation* r, double min, double max, double slope);
+```
+
+# Normal
+This function returns a random number drawn from a normal distribution centerd on zero and with variance `variance`.
+It uses the algorithm by D.E. Knut, 1997, The Art of Computer Programming, Addison-Wesley. 
+```c
+double reb_random_normal(struct reb_simulation* r, double variance);
+```
+
+# Rayleigh
+This function returns a random variable drawn form a Rayleigh distribution with scale parameter `sigma`. 
+```c
+double reb_random_rayleigh(struct reb_simulation* r, double sigma);
+```
+
+

rebound/source/docs/changelog.md

@@ -0,0 +1,589 @@
+# Changelog
+
+This changelog only includes the most important changes in recent updates. For a full log of all changes, please refer to git.
+
+## Version 4.x
+
+### Version 4.5.1
+* Added leapfrog integrators of order 4, 6, and 8. Order can be set with `r->ri_leapfrog->order`.
+* Heartbeat function is now also called when using `reb_simulation_steps()`.
+* OrbitPlot supports more colours. 
+* Fixed an alignment issue when comparing binary snapshots which could have triggered a segfault.
+
+### Version 4.5.0
+* Added support for (Frequency) Modified Fourier Transforms. Heavily based on David Nesvorny's code. The new functions are `reb_frequency_analysis()` in C and `rebound.frequency_analysis()` in python. For usage, see C examples `secular_frequencies` and `frequency_analysis` as well as the iPython notebook `FrequencyAnalysis`. 
+* Support for Jacobi coordinates added when using WHFast with OpenMP.
+* Allow negative periods when initializing hyperbolic orbits.
+
+### Version 4.4.11
+* The collision resolve function now returns a type `enum REB_COLLISION_RESOLVE_OUTCOME`. The actual integer values remain unchanged.
+* Bug in TRACE was fixed.
+* Convergence check for M_to_E function.
+* New API example that shows how to use the Kepler solver without a REBOUND simulation. Updated other examples.
+
+### Version 4.4.10
+* Version bump to rerun github workflows for pypi uploads
+
+### Version 4.4.9
+* Fixes a bug that affected collisions searches with a tree code.
+* Support for mid-timestep add/remove of particles with TRACE.
+* Various small improvements and bugfixes for TRACE.
+* IAS15's `adaptive_mode` is now an ENUM.
+* Some OpenMP improvements.
+
+### Version 4.4.8
+* Added support for symplectic correctors with barycentric coordinates in WHFast.
+
+### Version 4.4.7
+* Added option to disable SSL checks for Horizon queries with `rebound.horizons.SSL_CONTEXT = 'unverified'.`
+* Added unit tests.
+* Added barycentric coordinates for WHFast.
+* Bug fix for when MEGNO is used with adaptive timestepping.
+* Added more error messages.
+* Fixed various issues in documentation.
+
+### Version 4.4.6
+* When initializing particles with "uniform" in python, REBOUND now uses its own `reb_random_uniform()` function. This avoids importing the "random" library and makes results reproducible as the random seed of the simulation is used when generating random numbers.
+* More cracefull interrupt handling. REBOUND now stop the integration after the next timestep when CTRL-C is pressed the first time. If CTRL-C s pressed twice, then long loops (during gravity, collision calculations) are terminated immediately. Continuing an integration after one CTRL-C press should be easier with this change as the simulation does not get corrupted.
+* Fixed typos in documentation.
+
+### Version 4.4.5
+* Version updated to test github workflows
+
+### Version 4.4.4
+* Fixed several memory leaks and other memory issues. It is unlikely that any of those bugs did affect an simulation.
+* When converting units of a particle, the particle radius is now also converted. 
+* Added getter/setters for Pal coordinates to the particle structure in python. Syntax is `sim.particles[1].pal_h`, `sim.particles[1].pal_ix`, etc. 
+
+### Version 4.4.3
+* REBOUND now raises ImportError if it detects a size mismatch between the C and python Simulation structures.
+* Fixes a bug in the WHFast512 synchronization on non-AVX512 systems.
+* Fixes a bug in the SimulationArchive in cases where there are multiple snapshots with t=0.
+* Updates TRACE switching condition to match Lu et al (2024).
+* TRACE binary file size has been reduced.
+* Pericenter passage time is now calculated even if particles are not in a Simulation.
+
+### Version 4.4.2
+* Fixed bug in TRACE when adding particles.
+* Added WHFast fallback for synchronizing WHFast512 simulations with `N_systems` > 1.
+* Output version number used to create Simulationarchive if there is a version mismatch.
+* Added C example `simulationarchive_fields` which outputs all fields in a simulationarchive for debugging purposes.
+
+### Version 4.4.1
+* Fixed bug in TRACE for FULL PERI modes.
+
+### Version 4.4.0
+* Added TRACE integrator. See Lu, Hernandez & Rein (2024) for details on this implementation.
+
+### Version 4.3.2
+* No longer clipping particles and orbits in visualization.
+* Added a scale to visualization. Hide by pressing `t`.
+* Option to take a screenshow manually in png (WebGL) or tga (OpenGL) format by pressing `e`.
+* Improved `plane` visualization mode. Now supporting hyperbolic orbits. 
+* Fixed a memory leak in `reb_simulation_copy`.
+
+### Version 4.3.1
+* Added new `plane` visualization mode for orbits. Press `w` to toggle through available orbit visualization modes.
+* Added python interface for screenshot API.
+* Fixed an issue where no python exception was raised when a particle was added outside a simulation box.
+* Renamed `past_N` to breadcrumbs in visualization module.
+
+### Version 4.3.0
+* Take screenshots of WebGL based visualizations using the `reb_simulation_output_screenshot()` function. You need to connect one web browser to the simulation in order to take screenshots. 
+* Improved synchronization of visualization and simulation on Windows with mutex.
+* Fixes an issue that might lead to NaN values when less than the maximum number of planets are used in WHFast512.
+
+### Version 4.2.0
+* It is now possible to programmatically change all aspects of a REBOUND visualization. This can be used to set up default viewing options or to render animations. See the C examples in `animation_solar_system` and `animation_saturn_rings`.
+* Reworked matrix operations in visualization routines to follow the Model-View-Projection paradigm.
+* Fixed an issues where unit tests would fail because a binary file was not deleted.
+
+### Version 4.1.1
+* Fixed python wheels for windows.
+
+### Version 4.1.0
+* New visualization feature that allows you to show past particle positions and orbits (keyboard commands p, u, and i).
+* After pausing a simulation, you can now advance it by a single timestep by pressing the down arrow or 50 timesteps by pressing the page down key.
+* Visualization now supports scroll to zoom.
+* Fixed memory leaks when using custom ODEs.
+* Fixed broken links in documentations.
+
+### Version 4.0.3
+* Default IAS15 timestepping criterion is now `adaptive_mode=2`. See Pham, Rein, and Spiegel (2024) for details. To use the old default timestepping criterion, set `adaptive_mode=1`.
+* Fixed a race condition that should improve the responsiveness of web based visualizations.
+* Removed the glad dependency from emscripten builds which reduces filesize and improves performance.
+
+### Version 4.0.2
+* Fixes an issue where the default Makefiles included white spaces after the SERVER and OPENGL variable definitions. This caused the main Makefile to ignore these settings.
+* Added `key_callback` function for customizing user interaction in visualizations.
+* Added `simulationarchive_viewer` example.
+* Included `-sGL_ENABLE_GET_PROC_ADDRESS` flag that is now needed for the latest version of emscripten.
+
+### Version 4.0.1
+* Include missing python packages
+
+### Version 4.0.0
+* Major API changes and new features! If you have used a previous version of REBOUND, then you will need to update your code. If you have trouble with the migration, open a GitHub issue!
+* Many function and variable names have changed. They now follow a coherent naming convention. See the naming convention section in the documentation for more information.
+* New visualization module! Previously, using OpenGL visualization required the GLFW library which led to problems on various operating systems. The new visualization module no longer requires ANY dependencies and is compatible with MacOS, Linux, and Windows. It works by running a local web server to which you can point your browser to. In your web browser, an emscripten compiled version of REBOUND handles the WebGL visualization while constantly updating simulation data over HTTP. You can use ssh and port forwarding to visualize simulations on remote servers. Check out the documentation for more details on this new module.
+* OpenGL for all the examples has been turned off by default so that new users don't get stuck at this step. To turn on OPENGL simply change the flag in the Makefile.
+* Added emscripten support. All C examples (including those using visualizations) are now automatically compiled with emscripten on readthedocs.org so you can run from within the browser. No download or installation required.
+* A race condition in OpenGL visualization has been removed. Visualizations run much smoother.
+* `reb_random` functions now callable with `r=NULL`. If `r=NULL` then the time and PID is used as a seed.
+* Removed support for Simulationarchives with version 2. Added some additional support for reading corrupt/old archives.
+* Fixed memory leak in `reb_simulation_copy`.
+* Consistent integer sizes for 32/64bit. This includes padding for `reb_particle` which is stored in the Simulationarchive.
+
+
+## Version 3.x
+
+### Version 3.28.4
+* WHFast512 now support the integration of 2 and 4 planet systems in parallel. Providing a speed up of up to 10x.
+* The sqrt7 function used by IAS15 now support a wider range of input arguments.
+
+### Version 3.28.3
+* Removed distutils requirement in preparation  for python 3.12.
+* Removed rebound.InterruptiblePool as it no longer works with recent python version. Updated examples.
+* Added Holmberg example.
+* Added `adaptive_mode==3` for IAS15 (Aarseth 1985).
+
+### Version 3.28.2
+* Implemented own fmemopen implementation on MacOS. This is mainly to appease conda-forge builds.
+* Improved sqrt7 algorithm allows larger convergence interval.
+
+### Version 3.28.1
+* Improved support for reading old and corrupted Simulationarchives.
+* Renamed `ri_ias15.epsilon_global` to `ri_ias15.adaptive_mode`.
+* Added new timestep method for IAS15 `ri_ias15.adaptive_mode = 2`. This is experimental for now. Details to be described in Pham, Rein & Spiegel (in prep).
+* Added unit tests to check for fused multiply add instruction (these break reproducibility).
+* Added phony target in C Makefile to force rebuilding librebound whenever building examples. 
+
+### Version 3.28.0
+- Native Windows support. REBOUND can now be built natively on Windows (without WSL) using the Microsoft Visual Studio Compiler. 
+- Python Wheels are now provided for Linux, MacOS, and Windows. This should significantly speed up the installation process on a wide variety of systems.
+
+### Version 3.27.0
+* In python, Simulation and Particle objects are now picklable. Just like loading Simulations from a binary file, function pointers will need to be re-set manually after unpickling.
+* The difference between simulations can now be printed out in a human readable form. Python syntax: `sim.diff(sim2)`. C syntax: `reb_simulation_diff(sim2, sim1, 1)`.
+* Reading Simulationarchives with version < 2 is no longer supported.
+* The POSIX function fmemopen() is now required to compile REBOUND. This should not affect many users. However, if you are using macOS, the version needs to be >= 10.13 (this version of macOS, High Sierra, was released in 2017). 
+* Internal changes on how Simulationarchives are written. 
+* Internal variable names that represent the size of allocated buffers now consistently include the name `N_allocated`.
+* The TES (Terrestrial Exoplanet Integrator) has been removed. If you wish to use TES, you will need checkout an earlier version.
+
+### Version 3.26.3
+* A few more changes to reduce the number of compiler warnings. This should not affect any calculation.
+
+### Version 3.26.2
+* Fixed various signed/unsigned int issues. This should reduce the number of compiler warnings but not affect any calculation.
+
+### Version 3.26.1
+* Added support for `AVX512` and `FFP_CONTRACT_OFF` environment variables when using pip to install REBOUND.
+
+### Version 3.26.0
+* Added WHFast512 integrator (Javaheri, Rein, Tamayo 2023)
+
+### Version 3.25.1
+* Bug fixed that prevented the installation via PyPi
+
+### Version 3.25.0
+* MPI parts updated and unit tests added
+* Fixed machine independence bug in TES.
+
+### Version 3.24.3
+* Updated unit tests so they work on 32bit machines
+
+### Version 3.24.2
+* Fixed bug in TES ctypes structure
+
+### Version 3.24.1
+* Added CORS proxy for Horizons request in pyodide
+* Smoother OpenGL animations when using usleep
+* TES calculates orbital period automatically
+
+### Version 3.24.0
+* Added support for Simulationarchive larger than 4 GB.
+* Updated documentation for Lyapunov characteristic number.
+
+### Version 3.23.5
+* Added new units shortcuts (year,years,massist)
+* Rearranged some loops and switch statements (doesn't affect floating point numbers). 
+
+### Version 3.23.4
+* Added pyproject.toml file
+
+### Version 3.23.3
+* Changed the way REBOUND reverses the integration direction when the sign of the timestep is inconsistent with respect to the requested final time.
+* Fixes a memory leak when a tree code is used
+* Fixes an issue where MERCURIUS was not bit-wise reproducible when safe mode was turned off.
+
+### Version 3.23.2
+* Minor changes to the python side of Vec3d to make it more compatible with numpy.
+
+### Version 3.23.1
+* Minor changes related to the REBOUND Rotations framework.
+
+### Version 3.23.0
+* Added the REBOUND Rotations framework.
+* Fixes an issue with showing an incorrect periastron location in OrbitPlot for high mass-ratio systems.
+* Adds pre and post timestep calls to the ode framework.
+
+### Version 3.22.0
+* OrbitPlot is now a class. Checkout the OrbitPlot.ipynb tutorial. This change allows for interactive plots and much faster updates to existing plots. This is great for rendering animations! 
+
+### Version 3.21.0
+* Automatic rescaling of first order variational particles has been added. This will allow you to integrate chaotic systems for longer and obtain a more accruate measure of MEGNO and the Lyapunoc exponent. 
+* Added `sim.stop()` / `reb_simulation_stop()` to end an integration from within the heartbeat function.
+
+### Version 3.20.1
+* Pal coordinates have been added to the `reb_orbit` struct.
+
+### Version 3.20.0
+* A new integrator has been added, the Terrestrial Exoplanet Simulation (TES).
+
+### Version 3.19.10
+* Fixes another bug int he BS integrator when additional forces are used.
+
+### Version 3.19.9
+* Two bugs fixed in the BS integrator. One was related to unitialized memory and the other to issues when the particle number changed.
+
+### Version 3.19.5
+* Workaround for urllib support in pyodide added
+* Silent warning when InterruptiblePool is not available
+
+### Version 3.19.4
+* InterruptiblePool is optional.
+* Fixed an issue that occured when switching integrators while using the Simulationarchive.
+* Renamed `srand_seed` to make it user accessible. 
+
+### Version 3.19.3
+* Added several examples.
+* Changed how pypi is rendering the documentation.
+
+### Version 3.19.2
+* Fixes a bug relates to test particles of type 0 in MERCURIUS.
+
+### Version 3.19.1
+* Some compilers seem to complain that a constant cannot be initialized from a constant. Fixed this so that REBOUND works on colaboratory.
+
+### Version 3.19.0
+* 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.
+
+### Version 3.18.1
+* 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. 
+
+### Version 3.18.0
+* 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. 
+
+### Version 3.17.5
+* 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.
+
+### Version 3.17.4
+* 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.
+
+### Version 3.17.3
+* Allow for Horizon queries with future JD dates.
+
+### Version 3.17.2
+* Moved some function declarations to rebound.h. This is a temporary fix for REBOUNDx.
+
+### Version 3.17.1
+* 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). 
+
+### Version 3.17.0
+* Added new 'reb_simulation_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.
+
+### Version 3.16.0
+* 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.
+
+### Version 3.15.0
+* 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.
+
+### Version 3.14.0
+* 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. All `reb_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. 
+
+### Version 3.13.2
+* Correct handling of test particles in reb_transformations.
+* Small bug fixes 
+
+### Version 3.13.1
+* WHFast: Fixes multiple issues with testparticles in WHFast. 
+
+### Version 3.13.0
+* 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.
+
+### Version 3.12.3
+* Various small bug fixes 
+* Added a new function sim.cite() to automatically generate citations depending on the current simulation settings. 
+
+### Version 3.12.2
+* Various bug fixes to MERCURIUS
+* Performance increase when using the BASIC Gravity Routine with OpenMP
+  
+### Version 3.12.1
+* Bug fixes to LINE and LINETREE algorithms
+  
+### Version 3.12.0
+* 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.
+
+### Version 3.11.1
+* 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.
+
+### Version 3.11.0
+* 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. 
+
+### Version 3.10.2
+* Updates to OrbitPlot. Includes better layout of plot and some syntax changes. See OrbitPlot documentation for the new syntax.
+
+### Version 3.10.1
+* Small syntax changes for SABA integrator family. 
+* Includes high order integrators by Blanes et al. (2013).
+
+### Version 3.10.0
+* Changes for the new version of REBOUNDx. 
+
+### Version 3.9.0
+* 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. 
+
+### Version 3.8.3
+* Improves and fixes various issues related to variational equations and MEGNO. 
+
+### Version 3.8.2
+* Fixes a bug which resulted in duplicate snapshots in Simulationarchives when restarting simulations.
+
+### Version 3.8.1
+*   Syntax change on the python side to create a simulation from a binary file or Simulationarchive:
+    
+    ```python
+    rebound.Simulation.from_file("test.bin") becomes rebound.Simulation("test.bin") 
+    rebound.Simulation.from_archive("test.bin",5) becomes rebound.Simulation("test.bin",5) 
+    ```
+
+### Version 3.8.0
+* 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.
+
+### Version 3.7.1 
+* 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.
+
+### Version 3.7.0
+* Added a deep copy functionality: reb_simulation_copy() in C, and sim.copy() in python. 
+* Refactored WHFast to enable calling only certain substeps. 
+
+### Version 3.6.8
+* 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}$.
+
+### Version 3.6.7
+* Fixes an issue related to collisions and the Mercurius integrator that prevented the last_collision property to be updated.
+
+### Version 3.6.6
+* New: Fancy plotting routine. Usage: rebound.OrbitPlot(sim, fancy=True)
+
+### Version 3.6.5
+* One can now add particles from NASA Horizons using Julian Days. For example: sim.add("Earth", date="JD2458327.500000")
+
+### Version 3.6.4
+* Fixes a memory leak when using the old Simulationarchive version. Thanks to Ian Rabago for reporting the issue.
+
+### Version 3.6.2
+* Fixes a memory leak in the Simulationarchive read function.
+
+### Version 3.6.1
+* 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
+
+### Version 3.6.0
+* 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. 
+
+### Version 3.5.12
+* 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.
+
+### Version 3.5.11
+* 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.
+
+### Version 3.5.10
+* Refactored OrbitPlot.
+
+### Version 3.5.9
+* SIGINT handler added. Allows for garceful exit and keyboard interrupts (even from python).
+
+### Version 3.5.8
+* WebGL widget text overlay added.
+
+### Version 3.5.7
+* Bug fixes related to WebGL widget and ipywidgets version 6
+
+### Version 3.5.6
+* Updated WebGL widget to work with ipywidgets version 7
+
+### Version 3.5.5
+* Various fixed for Mercurius
+
+### Version 3.5.4
+* Bug fix for N_active=-1 (default)
+
+### Version 3.5.3
+* 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).
+
+### Version 3.5.2
+* Fixes an issue with the WebGL widget.
+* Fixes an issue with external forces and MERCURIUS.
+
+### Version 3.5.1
+* MERCURIUS is not compatible with binary files and the Simulationarchive.
+
+### Version 3.5.0
+* 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.
+
+### Version 3.4.0
+* Added a screenshot functionality for the WebGL ipython widget. This lets you take screenshots programmatically which is useful to create movies of simulations. 
+
+### Version 3.3.1
+* Removed the march=native compiler flag as it seems to be problematic for some OSX/Sierra compilers.
+
+### Version 3.3.0
+* 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.
+
+### Version 3.2.4
+* 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.  
+
+### Version 3.2.3
+* Various minor bug fixes. Added pre-timestep modifications for REBOUNDx. 
+
+### Version 3.2.2
+* Various minor bug fixes. One related to exact_finish_time=1. 
+
+### Version 3.2.0
+* 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.widget()` 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.
+
+
+### Version 3.1.1
+* 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. 
+
+### Version 3.1.0
+* 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 with `sudo apt-get install libglfw3-dev`. 
+
+### Version 3.0.0
+* Introducing the Simulationarchive. The Simulationarchive 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.
+
+
+## Version 2.x
+### Version 2.20.6
+* Minor bug fixes in HERMES integrator and some examples.
+
+### Version 2.20.5
+* NASA Horizons changed a telnet command. This update implements those changes and restores access to NASA Horizons from within REBOUND.
+
+### Version 2.20.4
+* 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.
+
+### Version 2.20.3
+* Small changes to HERMES integrator. It now has a Solar Switch Factor SSF to allow for close encounters with the central object. 
+
+### Version 2.20.2
+* Added adaptive HSF for HERMES integrator. More documentation and paper to follow. 
+
+### Version 2.20.1
+* Added symplectic correctors for WHFastHelio integrator. See Wisdom (2006). 
+* Improved accuracy of symplectic corrector coefficients for WHFast and WHFastHelio.
+
+### Version 2.20.0
+* 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. 
+
+### Version 2.19.2
+* Changes to how particle hashes are handled.
+
+### Version 2.19.1
+* 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. 
+
+### Version 2.19.0
+* 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.
+
+### Version 2.18.9
+* Added the reb_simulation_get_serialized_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)
+
+
+### Version 2.18.5
+* 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.
+
+
+### Version 2.18.0
+* 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). 
+
+### Version 2.17.0
+* What used to be called ``id`` in the particle structure is now called ``hash``. 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. using ``sim.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 the ``collision_resolve_merge`` routine), 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)
+   # Setting a hash using a string:
+   sim.particles[1].hash = "planet1"
+   # Finding a particle using a string:
+   p = sim.get_particle_by_hash("planet1")
+   # Setting a random unique hash:
+   sim.particles[1].hash = sim.generate_unique_hash() 
+   # Save unique hash to find particle later
+   uhash = sim.particles[1].hash
+   # Find particle using the hash
+   p = sim.get_particle_by_hash(uhash)
+   
+
+
+### Version 2.0.0
+* 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_simulation`` structure. 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 ``Makefile`` that 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. 
+

rebound/source/docs/chaos.md

@@ -0,0 +1,102 @@
+# Chaos indicators
+REBOUND supports different chaos indicators.
+All of these make use of variational equations, but most of the complexity is hidden.
+
+## Initialization
+If you want to use a chaos indicator in REBOUND, first add all the particles to your simulations.
+Then, initialize the variational particles and MEGNO variables with
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    // ... add particles ...
+    reb_simulation_init_megno(r);
+    ```
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    # ... add particles ...
+    sim.init_megno()
+    ```
+
+REBOUND uses random numbers to initialize the variational particles.
+The initial seed is chosen based on the current time and the process id. 
+This ensures the seed is different every time you run the simulation.
+See the discussion on [random sampling](c_randomsamplingfunctions.md) for more details.
+
+If you want to have reproducible result, you can specify the seed manually:
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    // ... add particles ...
+    reb_simulation_init_megno_seed(r, 0); // 0 is the initial seed
+    ```
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    # ... add particles ...
+    sim.init_megno(seed=0) # 0 is the initial seed
+    ```
+## Accessing chaos indicators
+Once you've initialized the chaos indicators, you can integrate the simulation normally.
+To print out the MEGNO value or the largest Lyapunov characteristic number (LCN), use the following syntax:
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    // ... add particles ...
+    reb_simulation_init_megno_seed(r);
+    // ... integrate ...
+    printf("MEGNO = %f\n", reb_simulation_megno(r));
+    printf("LCN = %f\n", reb_simulation_lyapunov(r));
+    ```
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    # ... add particles ...
+    sim.init_megno()
+    # ... integrate ...
+    print("MEGNO", sim.calculate_megno())
+    print("LCN", sim.lyapunov())
+    ```
+!!! Note
+    Using chaos indicators is not always straightforward. 
+    It can be particularly tricky to figure out how long to integrate for.
+    If the integration time is too short, you might not capture the Lyapunov timescale accurately. 
+    On the other hand, if the integration time is too long, you can run into problems as well because quantities tend to grow exponentially with time in chaotic systems.
+
+!!! Note
+    There are different definitions of the LCN which might differ by a factor of order unity.
+    Here, we're following Eq. 24 of [Cincotta and Simo (2000)](https://aas.aanda.org/articles/aas/abs/2000/20/h1686/h1686.html).
+
+## Re-scaling of variational equations 
+
+!!! Important
+    This is a new feature, first implemented in version 3.21
+
+REBOUND will automatically re-scale first order variational equation once any coordinate of a variational particle becomes larger than $10^{100}$. 
+This is only possible for first order variational equations because they are linear. 
+It is not possible to re-scale second order equations. 
+For the calculation of MEGNO, all this is done behind the scenes and no user intervention is needed.
+However, should you be interested in the actual value of the variational particles, for example to calculate a Lyapunov exponent manually, then you need to take the value of the `lrescale` variable into account. 
+This variable contains the natural logarithm of all re-scaling factors that have been applied throughout the integration to a given set of variational particles.
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    // ... add particles ...
+    reb_simulation_init_megno_seed(r);
+    // ... integrate ...
+    struct reb_variational_configuration* vc = &(r->var_config[0]);
+    double log_x = log(r->particles[vc->index].x) + vc->lrescale; // log of x coordinate of variational particle
+    ```
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    # ... add particles ...
+    sim.init_megno()
+    # ... integrate ...
+    vc = sim.var_config[0]
+    log_x = vc.particles[0] + vc.lrescale // log of x coordinate of variational particle
+
+Note that above the  calculations involving the rescaling factors have been done in log space as floating point numbers cannot be used to represent a number larger than $10^{308}$.
+For a more complete example, check out the [iPython Variational Equation example](ipython_examples/VariationalEquations.ipynb).

rebound/source/docs/collisions.md

@@ -0,0 +1,246 @@
+# Collisions
+
+## Detecting collisions
+
+REBOUND comes with several collision detection modules. 
+These modules check for physical collisions (the distance between two particles is closer than the sum of the radii), not close encounters.
+For a collision to occur between two particles, at least one of them needs to have a finite radius and collision detection needs to be turned on (it is turned off by default).
+
+
+### No collisions
+By default REBOUND does not search for collisions. 
+You can manually set the collision routine to NONE with the following code:
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->collision = REB_COLLISION_NONE;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.collision = "none"
+    ```
+
+### Direct
+The direct collision detection module is a brute force collision search and scales as $O(N^2)$.
+It checks for instantaneous overlaps between every particle pair. 
+The following code enables this module:
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->collision = REB_COLLISION_DIRECT;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.collision = "direct"
+    ```
+
+!!! Important
+    This method checks for instantaneous overlaps. It does this only after each timestep.
+    This means that if the timestep is large enough for particles to pass completely through each other, then the collision will be missed. 
+    
+
+
+### Line
+This is a brute force collision search and scales as $O(N^2)$ but compared to the direct method described above, this algorithm checks for overlapping particles during the timestep (not just at the end).
+It assumes particles travelled along straight lines during the timestep and might therefore miss some collisions.
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->collision = REB_COLLISION_LINE;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.collision = "line"
+    ```
+
+### Tree
+This method uses an oct-tree to check for overlapping particles at the end of the timestep.
+When a large number of particles $N$ is used, this method scales as $O(N log(N))$, rather than $O(N^2)$ for the direct search.
+Note that you need to initialize the simulation box whenever you want to use the tree.
+Below is an example on how to enable the tree based collision search.
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    reb_simulation_configure_box(r, 10, 1, 1, 1); # confine the simulation to a box of size 10
+    r->collision = REB_COLLISION_TREE;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.configure_box(10)   # confine the simulation to a box of size 10
+    sim.collision = "tree"
+    ```
+
+
+### Linetree
+Similar to the tree method, this method also uses an oct-tree and has a scaling of $O(N log(N))$.  
+It checks for overlapping trajectories during the last timestep, not only for overlapping particles at the end of the timestep.
+It might still miss some collisions because it assumes that particles travel along straight lines.
+
+
+Below is an example on how to enable the line-tree collision search.
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    reb_simulation_configure_box(r, 10, 1, 1, 1); # confine the simulation to a box of size 10
+    r->collision = REB_COLLISION_LINETREE;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.configure_box(10)   # confine the simulation to a box of size 10
+    sim.collision = "linetree"
+    ```
+
+## Resolving collisions
+
+Once a collision has been detected, you have a choice on what to do next.
+You might just want to merge particles, let them bounce off each other, or simply keep a log of all collisions that occurred. 
+
+REBOUND comes with several built-in collision resolve functions. 
+You can also write your own.
+
+Internally this functionality is implemented using a [function pointer](https://www.cprogramming.com/tutorial/function-pointers.html). 
+You can set this pointer to a function that should be called when a collision occurs, whether it be a built-in function or your own. 
+
+### Halt
+
+This function resolves a collision by simply halting the integration and setting the `status` flag in the simulation to `REB_STATUS_COLLISION`. 
+In python this will raise the `Collision` exception.
+This is the default.
+It can also be set manually using the following syntax:
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->collision = REB_COLLISION_DIRECT;
+    r->collision_resolve = reb_collision_resolve_halt;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.collision = "direct"
+    sim.collision_resolve = "halt"
+    ```
+
+### Hard-sphere
+
+This assumes a hard-sphere collision and uses the `coefficient_of_restitution` function pointer in `struct reb_simulation` to determine coefficient of restitution which can be velocity dependent
+It conserves momentum and mass.
+Depending on the coefficient of restitution, it also conserves energy.
+
+The following example shows how to set up a hard-sphere collision resolve function and a direct collision detection routine.
+
+=== "C"
+    ```c
+    double coefficient_of_restitution_constant(const struct reb_simulation* const r, double v){
+        // v is the normal impact velocity.
+        // Here, we just use a constant coefficient of restitution
+        return 0.5;
+    }
+    struct reb_simulation* r = reb_simulation_create();
+    r->collision = REB_COLLISION_DIRECT;
+    r->coefficient_of_restitution = coefficient_of_restitution_constant;
+    r->collision_resolve = reb_collision_resolve_hardsphere;
+    ```
+
+=== "Python"
+    ```python
+    def coefficient_of_restitution_constant(r, v):
+        # v is the normal impact velocity.
+        # Here, we just use a constant coefficient of restitution
+        return 0.5
+    sim = rebound.Simulation()
+    sim.collision = "direct"
+    sim.coefficient_of_restitution = coefficient_of_restitution_constant
+    sim.collision_resolve = "hardsphere"
+    ```
+
+
+### Merge
+ 
+This function merges the two colliding particles. 
+It conserves mass, momentum and volume, but not energy.  
+The particle with the higher index will be removed. 
+
+The following example shows how to set up a hard-sphere collision resolve function and a direct collision detection routine.
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->collision = REB_COLLISION_DIRECT;
+    r->collision_resolve = reb_collision_resolve_merge;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.collision = "direct"
+    sim.collision_resolve = "merge"
+    ```
+
+### Custom function
+You can write your own collision resolve function. 
+In your function, you can update the properties of the particles involved in the collision.
+The return value of your function (of type `enum REB_COLLISION_RESOLVE_OUTCOME`) determines if a particle gets removed.
+
+- `REB_COLLISION_RESOLVE_OUTCOME_REMOVE_NONE` or `0`: don't remove either particle from the simulation
+- `REB_COLLISION_RESOLVE_OUTCOME_REMOVE_P1` or `1`: remove the first particle (`p1`) from the simulation
+- `REB_COLLISION_RESOLVE_OUTCOME_REMOVE_P2` or `2`: remove the second particle (`p2`) from the simulation
+- `REB_COLLISION_RESOLVE_OUTCOME_REMOVE_BOTH` or `3`: remove both particles from the simulation
+
+Here is a short example on how to write a simple custom collision resolve function:
+
+=== "C"
+    ```c
+    enum REB_COLLISION_RESOLVE_OUTCOME collision_print_only(struct reb_simulation* const r, struct reb_collision c){
+        printf("%f\t", r->p);
+        printf("%f\t", r->particles[c.p1].x);    // x position of particle 1
+        printf("%f\n", r->particles[c.p2].x);    // x position of particle 2
+        return REB_COLLISION_RESOLVE_OUTCOME_REMOVE_NONE; // Don't remove either particle
+    }
+
+    int main(int argc, char* argv[]){
+        struct reb_simulation* r = reb_simulation_create();
+        r->collision = REB_COLLISION_DIRECT;
+        r->collision_resolve = collision_print_only;
+    }
+    ```
+
+=== "Python"
+    ```python
+    def collision_print_only(sim_pointer, collision):
+        sim = sim_pointer.contents           # get simulation object from pointer
+        print(sim.t)                         # print time 
+        print(sim.particles[collision.p1].x) # x position of particle 1
+        print(sim.particles[collision.p2].x) # x position of particle 2
+        return 0                             # Don't remove either particle
+    
+    sim = rebound.Simulation()
+    sim.collision = "direct"
+    sim.collision_resolve = collision_print_only
+    ```
+The first argument of the collision resolve function is a pointer to the simulation. 
+The second argument is a `reb_collision` structure. 
+It contains information about which particles are involved in the collision and, for periodic or shear-periodic [boundary conditions](boundaryconditions.md), if the collision occurred across a boundary:
+
+`int p1`
+:   Index corresponding to one of the colliding particles
+
+`int p2`
+:   Index corresponding to one of the colliding particles
+
+`struct reb_vec6d gb`
+:   Shift of particle p1 due to a collision across periodic and shearing sheet boundaries. All entries are zero if a normal collision occurs.

rebound/source/docs/examples.md

@@ -0,0 +1,9 @@
+# Examples in REBOUND
+We provide a lot of examples for REBOUND. We think examples are the easiest way to learn how to use REBOUND.
+This page contains a list of all examples that come with REBOUND. 
+The examples are sorted by topic. 
+Note that some examples use the C version, other the python version of REBOUND. 
+Often, the syntax is very similar and you might want to look at the C examples even if you want to write python code and vice verse.
+!!! Info
+    You can find the source code for all examples in the `examples/` and `ipython_examples/` directories. 
+

rebound/source/docs/generate_python_docs.py

@@ -0,0 +1,39 @@
+import rebound
+import inspect
+import docstring_to_markdown
+def convert_code_blocks(doc):
+    new_doc = ""
+    lines = doc.split("\n")
+    first = True
+    for line in lines:
+        if first:
+            if line[:3]==">>>":
+                first = False
+                new_doc += "```python\n"
+                new_doc += line[3:]+"\n"
+            else:
+                new_doc += line+"\n"
+        else:
+            if line[:3]==">>>":
+                new_doc += line[3:]+"\n"
+            else:
+                new_doc += "```\n"
+                new_doc += line+"\n"
+                first = True
+    if first==False:
+        new_doc += "```\n"
+
+    return new_doc
+
+def render_class(cls, functions=None):
+    d = "## Class `"+cls+"`\n"
+    d += convert_code_blocks(inspect.cleandoc(eval(cls).__doc__))
+    for function in functions:
+        f = getattr(eval(cls),function)
+        d += "## Function `"+cls+"."+function+"`\n"
+        d += convert_code_blocks(inspect.cleandoc(f.__doc__))
+
+    return d
+
+print(render_class("rebound.Simulation",["copy"]))
+

rebound/source/docs/gravity.md

@@ -0,0 +1,29 @@
+# Gravity solvers
+
+## Basic
+`REB_GRAVITY_BASIC`
+
+The basic gravity routine works is the default. It works in most cases. 
+It uses direct summation to calculate gravitational forces between all particle pairs.
+OpenMP parallelization is implemented. If OpenMP is turned on, the scaling is $O(N^2)$, otherwise, it is $O(\frac12 N^2)$, where $N$ is the number of particles. 
+
+## Compensated
+`REB_GRAVITY_COMPENSATED`
+
+This routine also uses direct summation but in addition makes use of compensated summation to minimize round-off errors. 
+There are only a few special cases where the round-off error in force calculations has a dominant effect. In most cases, the basic gravity routine is faster and equally accurate.
+
+## Tree
+`REB_GRAVITY_TREE`          
+
+This method uses an oct tree (Barnes and Hut 1986) to approximate self-gravity. It scales as  $O(N \log(N))$.
+
+## Tree
+`REB_GRAVITY_JACOBI`        
+
+Direct summation, scales as $O(N^2)$, includes special terms needed for some symplectic integrators.
+
+## None
+`REB_GRAVITY_NONE`          
+
+By using this gravity routine, no self-gravity calculated. It is still possible to include additional forces. 

rebound/source/docs/index.md

@@ -0,0 +1,103 @@
+# Welcome to REBOUND
+
+![REBOUND Examples](img/reboundbanner.png)
+
+REBOUND is an N-body integrator, i.e. a software package that can integrate the motion of particles under the influence of gravity. The particles can represent stars, planets, moons, ring or dust particles. REBOUND is very flexible and can be customized to accurately and efficiently solve many problems in astrophysics. 
+
+## Features
+
+
+* No dependencies on external libraries.
+* Runs natively on Linux, MacOS, and Windows. 
+* Symplectic integrators ([WHFast](integrators/#whfast), [SEI](integrators/#sei), [LEAPFROG](integrators/#leapfrog), [EOS](integrators/#embedded-operator-splitting-method-eos))
+* Hybrid reversible integrators for planetary dynamics with arbitrary close encounters ([TRACE](integrators/#trace))
+* Hybrid symplectic integrators for planetary dynamics with close encounters ([MERCURIUS](integrators/#mercurius))
+* High order symplectic integrators for integrating planetary systems ([SABA](integrators/#saba), WH Kernel methods)
+* High accuracy non-symplectic integrator with adaptive time-stepping ([IAS15](integrators/#ias15))
+* Can integrate arbitrary user-defined ODEs that are coupled to N-body dynamics for tides, spin, etc
+* Support for collisional/granular dynamics, various collision detection routines
+* The computationally intensive parts of the code are written entirely in C, conforming to the ISO standard C99, and can be used as a thread-safe shared library
+* Easy-to-use Python module, installation in 3 words: `pip install rebound`
+* Real-time, 3D visualization, for both C and Python.
+* Extensive set of example problems for both C and Python. You can run examples directly from your browser without the need to download or install anything.
+* Parallelized [WHFast512](integrators/#whfast512) integrator for super fast integrations of planetary systems with SIMD AVX512 instructions
+* Parallelized with OpenMP (for shared memory systems)
+* Parallelized with [MPI](mpi/) is supported for some special use cases only (using an essential tree for gravity and collisions)
+* The code is 100% open-source. All features are included in the public repository on [github](https://github.com/hannorein/rebound)
+
+## Contributors
+
+* Hanno Rein, University of Toronto, <hanno@hanno-rein.de>
+* Dan Tamayo, Harvey Mudd College <dtamayo@hmc.edu>
+* David S. Spiegel, Institute for Advanced Study Princeton, <dave@ias.edu>
+* Garett Brown, University of Toronto, <garett.brown@mail.utoronto.ca>
+* Shangfei Liu, Kavli Institute for Astronomy and Astrophysics at Peking University, <liushangfei@pku.edu.cn>
+* Ari Silburt, Penn State University, <ajs725@psu.edu>
+* Pejvak Javaheri, University of Toronto, <pejvak.javaheri@mail.utoronto.ca>
+* Ruth Huang, University of Toronto, <ruth.huang@mail.utoronto.ca>
+* and many others! Check the git history to find out who contributed to the code.
+
+REBOUND is open source and you are invited to contribute to this project! 
+
+## YouTube tutorials
+
+There are several short YouTube videos describing various aspects of REBOUND available at <https://www.youtube.com/channel/UCNmrCzxcmWVTBwtDPPLxkkw>.
+
+## Related projects
+
+### Additional physics
+To easily incorporate additional physics modules such as migration forces, GR effects and spin into your REBOUND simulations, see REBOUNDx at <https://github.com/dtamayo/reboundx>.
+
+### Analytical and semianalytical tools
+If you're interested in comparing numerical simulations to analytical and semianalytical tools for celestial mechanics, see Celmech at <https://github.com/shadden/celmech>.
+
+### Ephemeris-quality integrations of test particles
+To generate ephemeris-quality integrations of test particles in the Solar System with a precision on par with JPL's small body integrator, see ASSIST at <https://github.com/matthewholman/assist>.
+
+
+## Papers
+
+There are several papers describing the functionality of REBOUND.
+
+1. Rein & Liu 2012 (Astronomy and Astrophysics, Volume 537, A128) describes the code structure and the main feature including the gravity and collision routines for many particle systems. <http://adsabs.harvard.edu/abs/2012A%26A...537A.128R>
+
+2. Rein & Tremaine 2011 (Monthly Notices of the Royal Astronomical Society, Volume 415, Issue 4, pp. 3168-3176) describes the Symplectic Epicycle integrator for shearing sheet simulations. <https://ui.adsabs.harvard.edu/abs/2011MNRAS.415.3168R>
+
+3. Rein & Spiegel 2015 (Monthly Notices of the Royal Astronomical Society, Volume 446, Issue 2, p.1424-1437) describes the versatile high order integrator IAS15 which is now part of REBOUND. <http://adsabs.harvard.edu/abs/2015MNRAS.446.1424R>
+
+4. Rein & Tamayo 2015 (Monthly Notices of the Royal Astronomical Society, Volume 452, Issue 1, p.376-388) describes WHFast, the fast and unbiased implementation of a symplectic Wisdom-Holman integrator for long term gravitational simulations. <http://adsabs.harvard.edu/abs/2015MNRAS.452..376R>
+
+5. Rein & Tamayo 2016 (Monthly Notices of the Royal Astronomical Society, Volume 459, Issue 3, p.2275-2285) develop the framework for second order variational equations. <https://ui.adsabs.harvard.edu/abs/2016MNRAS.459.2275R>
+
+6. Rein & Tamayo 2017 (Monthly Notices of the Royal Astronomical Society, Volume 467, Issue 2, p.2377-2383) describes the Simulationarchive for exact reproducibility of N-body simulations. <https://ui.adsabs.harvard.edu/abs/2017MNRAS.467.2377R>
+
+7. Rein & Tamayo 2018 (Monthly Notices of the Royal Astronomical Society, Volume 473, Issue 3, p.3351–3357) describes the integer based JANUS integrator. <https://ui.adsabs.harvard.edu/abs/2018MNRAS.473.3351R>
+
+8. Rein, Hernandez, Tamayo, Brown, Eckels, Holmes, Lau, Leblanc & Silburt 2019 (Monthly Notices of the Royal Astronomical Society, Volume 485, Issue 4, p.5490-5497) describes the hybrid symplectic integrator MERCURIUS. <https://ui.adsabs.harvard.edu/abs/2019MNRAS.485.5490R>
+
+9. Rein, Tamayo & Brown 2019 (Monthly Notices of the Royal Astronomical Society, Volume 489, Issue 4, November 2019, Pages 4632-4640) describes the implementation of the high order symplectic integrators SABA, SABAC, SABACL, WHCKL, WHCKM, and WHCKC. <https://ui.adsabs.harvard.edu/abs/2019MNRAS.489.4632R/abstract>
+
+10. Javaheri, Rein & Tamayo 2023 (The Open Journal of Astrophysics, Volume 6, July 2023) describes the WHFast512 integrator which uses AVX512 instructions. <https://ui.adsabs.harvard.edu/abs/2023OJAp....6E..29J/abstract>
+
+## Acknowledgements
+
+If you use this code or parts of this code for results presented in a scientific publication, we would greatly appreciate a citation.
+The simplest way to find the citations relevant to the specific setup of your REBOUND simulation is: 
+
+```python
+sim = rebound.Simulation()
+-your setup-
+sim.cite()
+```
+
+!!! Info
+    When you cite one of the REBOUND papers, your paper will receive an automatic shout-out from the [REBOUND Citation Bot](https://botsin.space/@reboundbot). 
+
+## License
+
+REBOUND is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+REBOUND is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with REBOUND.  If not, see <http://www.gnu.org/licenses/>.
+

rebound/source/docs/integrators.md

@@ -0,0 +1,852 @@
+# Integrators
+
+![type:video](https://www.youtube.com/embed/QW5a-iH62dQ)
+
+Numerical integrators are the backbone of any N-body package. 
+A numerical integrator evolves particles forward in time, one timestep at a time.
+To do that, the integrator needs to know the current position and velocity coordinates of the particles, and the equations of motion which come in the form of a set of ordinary differential equations.
+
+Because an exact solution to these differential equations is in general unknown, each integrator attempts to approximate the true solution numerically. 
+Different integrators do this differently and each of them has some advantages and some disadvantages. 
+Each of the built-in integrators of REBOUND is described in this section.
+
+## IAS15
+
+![type:video](https://www.youtube.com/embed/UILEgdZt-fw)
+
+IAS15 stands for **I**ntegrator with **A**daptive **S**tep-size control, **15**th order. It is a very high order, non-symplectic integrator which can handle arbitrary forces (including those who are velocity dependent). 
+It is in most cases accurate down to machine precision (16 significant decimal digits). 
+The IAS15 implementation in REBOUND can integrate variational equations. 
+The algorithm is described in detail in [Rein & Spiegel 2015](https://ui.adsabs.harvard.edu/abs/2015MNRAS.446.1424R/abstract) and also in the original paper by [Everhart 1985](https://ui.adsabs.harvard.edu/abs/1985ASSL..115..185E/abstract). 
+
+
+IAS15 is the default integrator of REBOUND, so if you want to use it, you don't need to do anything. 
+However, you can also set it explicitly:
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->integrator = REB_INTEGRATOR_IAS15;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.integrator = "ias15"
+    ```
+
+The setting for IAS15 are stored in the `reb_integrator_ias15` structure. 
+
+`epsilon` (`double`)
+:   IAS15 is an adaptive integrator. It chooses its timesteps automatically. This parameter controls the accuracy of the integrator. The default value is $10^{-9}$. Setting this parameter to 0 turns off adaptive timestepping and a constant timestep will is used. Turning off adaptive time-stepping is rarely useful. 
+
+    !!! Important
+        It is tempting to change `epsilon` to achieve a speedup at the loss of some accuracy. However, that makes rarely sense. The reason is that IAS15 is a very high (15th!) order integrator. Suppose we increase the timestep by a factor of 10. This will increase the error by a factor of $10^{15}$. In other words, a simulation that previously was converged to machine precision will now have an error of order unity. 
+
+`min_dt` (`double`)
+:   This sets the minimum allowed timestep. The default value is 0. Set this to a finite value if the adaptive timestep becomes excessively small, for example during close encounters or because of finite floating point precision. Use with caution and make sure the simulation results still make physically sense as you might be in danger of ignoring small timescales in the problem. 
+    The following code sets the smallest timestep to $10^{-3}$ time units: 
+    === "C"
+        ```c
+        struct reb_simulation* r = reb_simulation_create();
+        r->ri_ias15.min_dt = 1e-3;
+        ```
+
+    === "Python"
+        ```python
+        sim = rebound.Simulation()
+        sim.ri_ias15.min_dt = 1e-3
+        ```
+
+`adaptive_mode` `(unsigned int`)
+:   This flag determines how the adaptive timestep is chosen. The previous name of this flag was `epsilon_global`. 
+    The default is 2 which corresponds to the timestep criterion described in Pham, Rein, and Spiegel (2024). 
+    This should be optimal in almost all cases.
+    If set to 0, the fractional error is estimated via `max(acceleration_error/acceleration)` and the timestep criterion of Rein and Spiegel (2015) is used. 
+    If set to 1, IAS15 estimates the fractional error via `max(acceleration_error)/max(acceleration)` where the maximum is taken over all particles. As before, the timestep criterion of Rein and Spiegel (2015) is used. This was the default until January 2024. 
+    If set to 3, then the criterion of [Aarseth 1985](https://ui.adsabs.harvard.edu/abs/1985IAUS..113..251A/abstract) is used.
+
+All other members of this structure are only for internal IAS15 use.
+
+
+## WHFast
+
+![type:video](https://www.youtube.com/embed/ttLUhtNj1Lc)
+
+WHFast is an implementation of the symplectic [Wisdom-Holman](https://ui.adsabs.harvard.edu/abs/1991AJ....102.1528W/abstract) integrator. 
+It is the best choice for systems in which there is a dominant central object and perturbations to the Keplerian orbits are small. 
+It supports first and second symplectic correctors as well as the kernel method of [Wisdom et al. 1996](https://ui.adsabs.harvard.edu/abs/1996FIC....10..217W/abstract) with various different kernels.
+The basic implementation of WHFast is described in detail in [Rein & Tamayo 2015](https://ui.adsabs.harvard.edu/abs/2015MNRAS.452..376R/abstract). 
+The higher order aspects of it are described in [Rein, Tamayo & Brown 2019](https://ui.adsabs.harvard.edu/abs/2019MNRAS.489.4632R/abstract). 
+WHFast also supports first order variational equations which can be used in chaos estimators ([Rein & Tamayo 2016](https://ui.adsabs.harvard.edu/abs/2016MNRAS.459.2275R/abstract)). 
+The user can choose between Jacobi, Democratic Heliocentric, WHDS,  and barycentric coordinates. 
+
+The following code enables the WHFast integrator. 
+Because WHFast is not an adaptive integrator, you also need to set a timestep.
+Typically, this should be a small fraction (a few percent) of the smallest dynamical timescale in the problem.
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->integrator = REB_INTEGRATOR_WHFAST;
+    r->dt = 0.1; 
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.integrator = "whfast"
+    sim.dt = 0.1
+    ```
+
+
+The setting for WHFast are stored in the `reb_integrator_whfast` structure, which itself is part of the simulation structure. 
+
+`unsigned int corrector`
+:   This variable turns on/off different first symplectic correctors for WHFast. 
+    By default, it is set to zero and symplectic correctors are turned off. 
+
+    First symplectic correctors remove error terms up to $O(\epsilon \cdot dt^p)$, where $p$ is the order of the symplectic corrector, and $\epsilon$ is the mass ratio in the system.
+    The following first correctors are implemented in REBOUND:
+
+    Order   | Number of stages 
+    ------- | ----------------
+    0       | Correctors turned off (default)
+    3       | 2
+    5       | 4 
+    7       | 6
+    11      | 10  
+    17      | 16
+
+    For most cases you want to choose the 17th order corrector. 
+    You only want to consider lower order correctors if frequent outputs are required and speed is an issue.
+    Symplectic correctors are turned on as follows.
+
+    
+    === "C"
+        ```c
+        r->ri_whfast.corrector = 17;
+        r->ri_whfast.safe_mode = 0;
+        ```
+
+    === "Python"
+        ```python
+        sim.ri_whfast.corrector = 17
+        sim.ri_whfast.safe_mode = 0
+        ```
+    
+    Note that the above code also turns off the safe mode. 
+    Most likely, you want to do that too (see below for a description of the safe mode).
+
+`unsigned int corrector2`
+:   This variable turns on/off second symplectic correctors for WHFast. 
+    By default, second symplectic correctors are off (0). 
+    Set to 1 to use second symplectic correctors.
+
+    !!! Info
+        The nomenclature can be a bit confusing. 
+        First symplectic correctors are different from second symplectic correctors.
+        And in REBOUND first symplectic correctors have different orders (see above). 
+        Second symplectic correctors on the other hand can only be turned on or off. 
+        See [Rein, Tamayo & Brown 2019](https://ui.adsabs.harvard.edu/abs/2019MNRAS.489.4632R/abstract) for more on high order symplectic integrators.
+
+`unsigned int kernel`
+:   This variable determines the kernel of the WHFast integrator. 
+    The following options are currently supported:
+
+    - The standard Wisdom-Holman kick step. This is the default.
+    - Exact modified kick. This works for Newtonian gravity only. Not additional forces. 
+    - The composition kernel.
+    - Lazy implementer's modified kick. This is often the best option.
+        
+    Check [Rein, Tamayo & Brown 2019](https://ui.adsabs.harvard.edu/abs/2019MNRAS.489.4632R/abstract) for details on what these kernel methods are. 
+    The syntax to use them is 
+    
+    === "C"
+        ```c
+        r->ri_whfast.kernel = REB_WHFAST_KERNEL_DEFAULT;      // or
+        r->ri_whfast.kernel = REB_WHFAST_KERNEL_MODIFIEDKICK; // or
+        r->ri_whfast.kernel = REB_WHFAST_KERNEL_COMPOSITION;  // or
+        r->ri_whfast.kernel = REB_WHFAST_KERNEL_LAZY;
+        ```
+
+    === "Python"
+        ```python
+        sim.ri_whfast.kernel = "default"      # or
+        sim.ri_whfast.kernel = "modifiedkick" # or
+        sim.ri_whfast.kernel = "composition"  # or
+        sim.ri_whfast.kernel = "lazy"
+        ```
+
+`unsigned int coordinates`
+:   WHFast supports different coordinate systems. 
+    Default are Jacobi Coordinates.
+    Other options are democratic heliocentric coordinates, and the WHDS coordinates ([Hernandez & Dehnen, 2017](https://ui.adsabs.harvard.edu/abs/2017MNRAS.468.2614H/abstract))
+    The syntax to use them is 
+    
+    === "C"
+        ```c
+        r->ri_whfast.coordinates = REB_WHFAST_COORDINATES_JACOBI;                  // or
+        r->ri_whfast.coordinates = REB_WHFAST_COORDINATES_DEMOCRATICHELIOCENTRIC;  // or
+        r->ri_whfast.coordinates = REB_WHFAST_COORDINATES_WHDS;                    // or
+        r->ri_whfast.coordinates = REB_WHFAST_COORDINATES_BARYCENTRIC; 
+        ```
+
+    === "Python"
+        ```python
+        sim.ri_whfast.coordinates = "jacobi"                 # or
+        sim.ri_whfast.coordinates = "democraticheliocentric" # or
+        sim.ri_whfast.coordinates = "whds"                   # or
+        sim.ri_whfast.coordinates = "barycentric"
+        ```
+
+`unsigned int recalculate_coordinates_this_timestep`
+:   Setting this flag to one will recalculate the internal coordinates from the particle structure in the next timestep. 
+    After the timestep, the flag gets set back to 0. If you want to change particles after every timestep, you also need to set this flag to 1 before every timestep. Default is 0.
+
+`unsigned int safe_mode`
+:   If this flag is set (the default), WHFast will recalculate the internal coordinates (Jacobi/heliocentric/WHDS/barycentric) and synchronize every timestep, to avoid problems with outputs or particle modifications between timesteps. 
+    Setting it to 0 will result in a speedup, but care must be taken to synchronize and recalculate the internal coordinates when needed. See also the AdvWHFast.ipynb tutorial.
+
+`unsigned int keep_unsynchronized`
+:   This flag determines if the inertial coordinates generated are discarded in subsequent timesteps (cached Jacobi/heliocentric/WHDS/barycentric coordinates are used instead). The default is 0. Set this flag to 1 if you require outputs and bit-wise reproducibility
+
+All other members of the `reb_integrator_whfast` structure are for internal use only.
+
+## Gragg-Bulirsch-Stoer (BS)
+The Gragg-Bulirsch-Stoer integrator (short BS for Bulirsch-Stoer) 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), specifically the JAVA implementation available in the [Hipparchus package](https://github.com/Hipparchus-Math/hipparchus/blob/master/hipparchus-ode/src/main/java/org/hipparchus/ode/nonstiff/GraggBulirschStoerIntegrator.java). The Hipparchus as well as the REBOUND version are adaptive in both the timestep and the order of the method for optimal performance. 
+The BS implementation in REBOUND can integrate first and second order variational equations. 
+
+The BS integrator is particularly useful for short integrations where only medium accuracy is required. For long integrations a symplectic integrator such as WHFast performs better. For high accuracy integrations the IAS15 integrator performs better. Because BS is adaptive, it can handle close encounters. Currently a collision search is only performed after every timestep, i.e. not after a sub-timestep.
+
+The following code enables the BS integrator and sets both the relative and absolute tolerances to 0.0001 (the default is $10^{-8}$):
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->integrator = REB_INTEGRATOR_BS;
+    r->ri_bs.eps_rel = 1e-4;
+    r->ri_bs.eps_abs = 1e-4;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.integrator = "BS"
+    sim.ri_bs.eps_rel = 1e-4
+    sim.ri_bs.eps_abs = 1e-4
+    ```
+
+The BS integrator tries to keep the error of each coordinate $y$ below $\epsilon_{abs} + \epsilon_{rel} \cdot  \left|y\right|$. Note that this applies to both position and velocity coordinates of all particles which implies that the code units you're choosing for the integration matter. If you need fine control over the scales used internally, you can set the `getscale` function pointer in `r->ri_bs.nbody_ode` (this is currently undocumented, search the source code for `getscale` to find out more).
+
+!!! Info
+        The code does not guarantee that the errors remain below the tolerances. In particular, note that BS is not a symplectic integrator which results in errors growing linearly in time (phase errors grow quadratically in time). It requires some experimentation to find the tolerances that offer the best compromise between accuracy and speed for your specific problem. 
+
+
+You can limit the timestep with both a maximum and minimum timestep:
+
+=== "C"
+    ```c
+    r->ri_bs.min_dt = 1e-5;
+    r->ri_bs.max_dt = 1e-2;
+    ```
+
+=== "Python"
+    ```python
+    sim.ri_bs.min_dt = 1e-5
+    sim.ri_bs.max_dt = 1e-2
+    ```
+
+Compared to the other integrators in REBOUND, BS can be used to integrate arbitrary ordinary differential equations (ODEs), not just the N-body problem. We expose an ODE-API in REBOUND which allows you to make use of this. User-defined ODEs are always integrated with BS. You can choose to integrate the N-body equations with BS as well, or any of the other integrators. 
+
+If you choose BS for the N-body equations, then BS will treat all ODEs (N-body + all user-defined ones) as one big system of coupled ODEs. This means your timestep will be set by either the N-body problem or the user-defined ODEs, whichever involves the shorter timescale.
+
+If you choose IAS15 or WHFast for the N-body equation but also have user-defined ODEs, then they cannot be treated as one big coupled system of ODEs anymore. In that case the N-body integration is done first. Then the user-defined ODEs are advanced to the exact same time as the N-body system using BS using whatever timestep is required to achieve the tolerance set in the `ri_bs` struct. During the integration of the user-defined ODEs, the coordinates of the particles in the N-body simulation are assumed to be fixed at their final position and velocity. This introduces an error. However, if the system evolves adiabatically (the timescales in the user-defined ODEs are much longer than in the N-body problem), then the error will be small. 
+
+The following code sets up a REBOUND simulation in which a harmonic oscillator is driven by the phase of a planet orbiting a star:
+
+=== "C"
+    ```c
+    void derivatives(struct reb_ode* const ode, double* const yDot, const double* const y, const double t){
+        struct reb_orbit o = reb_orbit_from_particle(ode->r->G, ode->r->particles[1], ode->r->particles[0]);
+        const double omega = 1;
+        double forcing = sin(o.f);
+        yDot[0] = y[1];
+        yDot[1] = -omega*omega*y[0] + forcing;
+    }
+
+    void run(){
+        struct reb_simulation* r = reb_simulation_create();
+        reb_simulation_add_fmt(r, "m", 1.);
+        reb_simulation_add_fmt(r, "m a e", 1e-3, 1., 0.1);
+
+        r->integrator = REB_INTEGRATOR_BS;
+
+        struct reb_ode* ho = reb_ode_create(r,2);   // Add an ODE with 2 dimensions
+        ho->derivatives = derivatives;              // Right hand side of the ODE
+        ho->y[0] = 1;                               // Initial conditions
+        ho->y[1] = 0;
+    }
+    ```
+
+=== "Python"
+    ```python
+    import numpy as np
+
+    def derivatives(ode, yDot, y, t):
+        omega = 1.0
+        sim_pointer = ode.contents.r
+        orbit = sim_pointer.contents.particles[1]
+        forcing = np.sin(orbit.f)
+        yDot[0] = y[1]
+        yDot[1] = -omega*omega*y[0] + forcing
+
+    sim = rebound.Simulation()
+    sim.add(m=1)
+    sim.add(m=1e-3, a=1, e=0.1)
+
+    sim.integrator = "BS"
+
+    ho = sim.create_ode(length=2)   # Add an ODE with 2 dimensions
+    ho.derivatives = derivatives    # Right hand side of the ODE
+    ho.y[0] = 1.0                   # Initial conditions
+    ho.y[1] = 0.0
+    ```
+
+
+## Mercurius
+
+MERCURIUS is a hybrid symplectic integrator very similar to MERCURY ([Chambers 1999](https://ui.adsabs.harvard.edu/abs/1999MNRAS.304..793C/abstract)). 
+It uses WHFast for long term integrations but switches over smoothly to IAS15 for close encounters.  
+The MERCURIUS implementation is described in [Rein et al 2019](https://ui.adsabs.harvard.edu/abs/2019MNRAS.485.5490R/abstract).
+
+    
+The following code enables MERCURIUS and sets the critical radius to 4 Hill radii
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->integrator = REB_INTEGRATOR_MERCURIUS;
+    r->ri_mercurius.r_crit_hill = 4.;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.integrator = "mercurius"
+    sim.ri_mercurius.r_crit_hill = 4.
+    ```
+
+The `reb_integrator_mercurius` structure contains the configuration and data structures used by the hybrid symplectic MERCURIUS integrator.
+
+`double (*L) (const struct reb_simulation* const r, double d, double dcrit)`
+:   This is a function pointer to the force switching function. 
+    If NULL (the default), the MERCURY switching function will be used. 
+    The argument `d` is the distance between two particles. 
+    The argument `dcrit` is the maximum critical distances of the two particles. 
+    The return value is a scalar between 0 and 1. 
+    If this function always returns 1, then the integrator effectively becomes the standard Wisdom-Holman integrator.
+
+    The following switching functions are available:
+
+
+    - Mercury switching function 
+
+        This is the same polynomial switching function as used in MERCURY. 
+
+        ```c
+        double reb_integrator_mercurius_L_mercury(const struct reb_simulation* const r, double d, double dcrit);           
+        ```
+    - Smooth switching functions 
+
+        These two polynomials switching functions are 4 and 5 times differentiable. 
+        Using smooth switching functions can improve the accuracy. 
+        For a detailed discussion see [Hernandez 2019](https://ui.adsabs.harvard.edu/abs/2019MNRAS.490.4175H/abstract). 
+
+        ```c
+        double reb_integrator_mercurius_L_C4(const struct reb_simulation* const r, double d, double dcrit);
+        double reb_integrator_mercurius_L_C5(const struct reb_simulation* const r, double d, double dcrit); 
+        ```
+
+    - Infinitely differentiable switching function
+
+        This is an infinitely differentiable switching function. 
+
+        ```c
+        double reb_integrator_mercurius_L_infinity(const struct reb_simulation* const r, double d, double dcrit); 
+        ```
+   
+    The switching function can be set using this syntax: 
+
+    === "C"
+        ```c
+        struct reb_simulation* r = reb_simulation_create();
+        r->ri_mercurius.L = reb_integrator_mercurius_L_infinity; 
+        ```
+
+    === "Python"
+        ```python
+        sim = rebound.Simulation()
+        sim.ri_mercurius.L = "infinity"
+        ```
+
+`double r_crit_hill`
+:   The critical switchover radii of particles are calculated automatically based on multiple criteria. One criterion calculates the Hill radius of particles and then multiplies it with the `r_crit_hill` parameter. The parameter is in units of the Hill radius. The default value is 3. 
+
+`unsigned int recalculate_coordinates_this_timestep`
+:   Setting this flag to one will recalculate heliocentric coordinates from the particle structure at the beginning of the next timestep. After a single timestep, the flag gets set back to 0. If one changes a particle manually after a timestep, then one needs to set this flag to 1 before the next timestep.
+
+`unsigned int recalculate_r_crit_this_timestep`
+:   Setting this flag to one will recalculate the critical switchover distances dcrit at the beginning of the next timestep. After one timestep, the flag gets set back to 0. If you want to recalculate `dcrit` at every timestep, you also need to set this flag to 1 before every timestep.
+
+`unsigned int safe_mode`
+:   If this flag is set to 1 (the default), the integrator will recalculate heliocentric coordinates and synchronize after every timestep to avoid problems with outputs or particle modifications between timesteps. Setting this flag to 0 will result in a speedup, but care must be taken to synchronize and recalculate coordinates manually if needed.
+
+## TRACE
+
+TRACE is a hybrid time-reversible integrator, based on the algorithm described in [Hernandez & Dehnen 2023](https://ui.adsabs.harvard.edu/abs/2023MNRAS.522.4639H/abstract). 
+It uses WHFast for long term integrations but switches time-reversibly to BS or IAS15 for all close encounters. TRACE is appropriate for systems with a dominant central mass that will occasionally have close encounters. 
+The TRACE implementation is described in [Lu, Hernandez & Rein](https://ui.adsabs.harvard.edu/abs/2024MNRAS.533.3708L/abstract). 
+
+
+The following code enables TRACE and sets the critical radius to 4 Hill radii
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_create_simulation();
+    r->integrator = REB_INTEGRATOR_TRACE;
+    r->ri_trace.r_crit_hill = 4;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.integrator = "trace"
+    sim.ri_trace.r_crit_hill = 4
+    ```
+
+The `reb_integrator_trace` structure contains the configuration and data structures used by the hybrid symplectic TRACE integrator.
+
+`int (*S) (const struct reb_simulation* const r, const unsigned int i, const unsigned int j)`
+:   This is a function pointer to the switching function for close encounters between non-central bodies.
+    If NULL (the default), the default switching function will be used.
+    The arguments `i` and `j` are the indices of the two particles considered.
+    The return value is either 0 or 1.
+    A return value of 1 means a close encounter has been flagged.
+    If the return values of both this function and the central switching function below are always 0, then the integrator effectively becomes the standard Wisdom-Holman integrator.
+
+    - Default switching function
+
+        This is a similar (but slightly modified) switching function used in MERCURY. It uses a modified Hill radius criteria, with heliocentric distance replacing semimajor axis
+
+        ```c
+        int reb_integrator_trace_switch_default(const struct reb_simulation* const r, const unsigned int i, const unsigned int j);           
+        ```
+
+    The switching function can be manually set using this syntax:
+
+    === "C"
+        ```c
+        struct reb_simulation* r = reb_create_simulation();
+        r->ri_trace.S = reb_integrator_trace_switch_default;
+        ```
+
+    === "Python"
+        ```python
+        sim = rebound.Simulation()
+        sim.ri_trace.S = "default"
+        ```
+        
+`int  (*S_peri) (const struct reb_simulation* const r, const unsigned int j)`
+:   This is a function pointer to the switching function for close encounters involving the central body.
+    If NULL (the default), the default switching function will be used.
+    The argument `j` is the index of the non-central particle considered.
+    The return value is either 0 or 1.
+    A return value of 1 means a close encounter has been flagged. 
+
+    - Default switching function
+
+        This switching function checks if a body is close to its pericenter by considering a timescale derived from high-order derivatives of the particle's herliocentric position, inspired by [Pham, Rein, and Spiegel 2024](https://ui.adsabs.harvard.edu/abs/2024OJAp....7E...1P/abstract).
+
+        ```c
+        int reb_integrator_trace_switch_peri_default(const struct reb_simulation* const r, const unsigned int j);           
+        ```
+    The switching function can be manually set using this syntax:
+
+    === "C"
+        ```c
+        struct reb_simulation* r = reb_create_simulation();
+        r->ri_trace.S_peri = reb_integrator_trace_switch_peri_default; // default
+        r->ri_trace.S_peri = reb_integrator_trace_switch_peri_none; // Turn off pericenter switching
+        ```
+
+    === "Python"
+        ```python
+        sim = rebound.Simulation()
+        sim.ri_trace.S_peri = "default" # Following Pham et al 2024
+        sim.ri_trace.S_peri = "none" # Turn off pericenter switching 
+        ```
+
+`double r_crit_hill`
+:   The critical switchover radii of non-central particles are calculated based on a modified Hill radii criteria. This modified Hill radius for each particle is calculated and then multiplied by the `hillfac` parameter. The parameter is in units of the modified Hill radius. This value is used by the `default` switching function. The default value is 4.
+
+`double peri_crit_eta`
+:   The criteria for a pericenter approach with the central body. This criteria is used in the `default` pericenter switching condition. It flags a particle as in a close pericenter approach if the ratio of the timestep to the condition described in [Pham, Rein, and Spiegel 2024](https://ui.adsabs.harvard.edu/abs/2024OJAp....7E...1P/abstract). The default value is 1.
+
+    The switching criteria can be manually set using this syntax:
+
+    === "C"
+        ```c
+        struct reb_simulation* r = reb_create_simulation();
+        r->ri_trace.peri_crit_eta = 0.5;    // or
+        ```
+
+    === "Python"
+        ```python
+        sim = rebound.Simulation()
+        sim.ri_trace.peri_crit_eta = 0.5    # or
+        ```
+`unsigned int peri_mode`
+:   This variable determines how TRACE integrates close approaches with the central star. 
+    The following options are currently supported:
+
+    - Integrating the entire system with BS. This is the default.
+    - Integrating only the Kepler Step with BS. 
+    - Integrating the entire system with IAS15. 
+        
+    Check [Lu, Hernandez & Rein 2024](https://ui.adsabs.harvard.edu/abs/2024MNRAS.533.3708L/abstract) for details on what these pericenter switching modes entail. 
+    The syntax to use them is 
+    
+    === "C"
+        ```c
+        r->ri_trace.peri_mode = REB_TRACE_PERI_PARTIAL_BS;  // or
+        r->ri_trace.peri_mode = REB_TRACE_PERI_FULL_BS;     // or
+        r->ri_trace.peri_mode = REB_TRACE_PERI_FULL_IAS15;  // or
+        ```
+
+    === "Python"
+        ```python
+        sim.ri_trace.peri_mode = "PARTIAL_BS" # or
+        sim.ri_trace.peri_mode = "FULL_BS"    # or
+        sim.ri_trace.peri_mode = "FULL_IAS15" # or
+        ```
+## SABA
+
+SABA are symplectic integrators developed by [Laskar & Robutel 2001](https://ui.adsabs.harvard.edu/abs/2001CeMDA..80...39L/abstract) and [Blanes et al. 2013](https://ui.adsabs.harvard.edu/abs/2012arXiv1208.0689B/abstract). 
+The implementation in REBOUND supports SABA1, SABA2, SABA3, and SABA4 as well as the corrected versions SABAC1, SABAC2, SABAC3, and SABAC4. 
+Different correctors can be selected. 
+In addition, the following methods with various generalized orders are supported: SABA(8,4,4), SABA(8,6,4), SABA(10,6,4). 
+See [Rein, Tamayo & Brown 2019](https://ui.adsabs.harvard.edu/abs/2019MNRAS.489.4632R/abstract) for details on how these methods work.
+
+The `reb_integrator_saba` structure contains the configuration and data structures used by the SABA integrator family.
+
+`unsigned int type`
+:   This parameter specifies which SABA integrator type is used.
+    The following SABA integrators are supported:
+
+    Numerical value     |  C constant name    | Description 
+    ------------------- | ------------------- | ----------------------------------
+    0x0                 | `REB_SABA_1`        | SABA1 (Wisdom-Holman)
+    0x1                 | `REB_SABA_2`        | SABA2
+    0x2                 | `REB_SABA_3`        | SABA3
+    0x3                 | `REB_SABA_4`        | SABA4
+    0x100               | `REB_SABA_CM_1`     | SABACM1 (Modified kick corrector)
+    0x101               | `REB_SABA_CM_2`     | SABACM2 (Modified kick corrector)
+    0x102               | `REB_SABA_CM_3`     | SABACM3 (Modified kick corrector)
+    0x103               | `REB_SABA_CM_4`     | SABACM4 (Modified kick corrector)
+    0x200               | `REB_SABA_CL_1`     | SABACL1 (lazy corrector)
+    0x201               | `REB_SABA_CL_2`     | SABACL2 (lazy corrector)
+    0x202               | `REB_SABA_CL_3`     | SABACL3 (lazy corrector)
+    0x203               | `REB_SABA_CL_4`     | SABACL4 (lazy corrector)
+    0x4                 | `REB_SABA_10_4`     | SABA(10,4), 7 stages
+    0x5                 | `REB_SABA_8_6_4`    | SABA(8,6,4), 7 stages
+    0x6                 | `REB_SABA_10_6_4`   | SABA(10,6,4), 8 stages, default
+    0x7                 | `REB_SABA_H_8_4_4`  | SABAH(8,4,4), 6 stages
+    0x8                 | `REB_SABA_H_8_6_4`  | SABAH(8,6,4), 8 stages
+    0x9                 | `REB_SABA_H_10_6_4` | SABAH(10,6,4), 9 stages
+
+    SABA(10,6,4) is the default integrator. It has a generalized order of $O(\epsilon dt^{10} + \epsilon^2 dt^6 + \epsilon^3 dt^4)$. 
+
+    Below is an example on how to enable the SABA integrators in REBOUND and set a specific type.
+
+    === "C"
+        ```c
+        struct reb_simulation* r = reb_simulation_create();
+        r->integrator = REB_INTEGRATOR_SABA;
+        r->ri_saba.type = REB_SABA_10_6_4;
+        ```
+
+    === "Python"
+        ```python
+        sim = rebound.Simulation()
+        sim.integrator = "saba"
+        sim.ri_saba.type = "(10,6,4)"
+        ```
+        One can also use the following shorthand: 
+        ```python
+        sim = rebound.Simulation()
+        sim.integrator = "SABA(10,6,4)"
+        ```
+
+`unsigned int safe_mode`
+:   This flag has the same functionality as in WHFast. Default is 1. Setting this to 0 will provide a speedup, but care must be taken with synchronizing integration steps and modifying particles.
+
+`unsigned int keep_unsynchronized`
+:   This flag determines if the inertial coordinates generated are discarded in subsequent timesteps (cached Jacobi coordinates are used instead). The default is 0. Set this flag to 1 if you require outputs and bit-wise reproducibility 
+
+
+
+
+## JANUS
+Janus is a bit-wise time-reversible high-order symplectic integrator using a mix of floating point and integer arithmetic.
+It is described in [Rein & Tamayo 2018](https://ui.adsabs.harvard.edu/abs/2018MNRAS.473.3351R/abstract).
+
+The following code shows how to enable JANUS and set the length and velocity scales.
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->integrator = REB_INTEGRATOR_JANUS;
+    r->ri_janus.scale_pos = 1e-10;
+    r->ri_janus.scale_vel = 1e-10;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.integrator = "janus"
+    sim.ri_janus.scale_pos = 1e-10
+    sim.ri_janus.scale_vel = 1e-10
+    ```
+
+
+The `reb_integrator_janus` structure contains the configuration and data structures used by the bib-wise reversible JANUS integrator.
+
+`double scale_pos`
+:   Scale of the problem. Positions get divided by this number before the conversion to an integer. Default: $10^{-16}$.
+
+`double scale_vel`
+:   Scale of the problem. Velocities get divided by this number before the conversion to an integer. Default: $10^{-16}$. 
+
+`unsigned int order`
+:   The order of the scheme. Default is 6.
+
+`unsigned int recalculate_integer_coordinates_this_timestep`
+:   If this flag is set, then JANUS will recalculate the integer coordinates from floating point coordinates at the next timestep.
+
+All other members of this structure are only for internal use and should not be changed manually.
+
+
+## Embedded Operator Splitting Method (EOS)
+This is the Embedded Operator Splitting (EOS) methods described in [Rein 2019](https://ui.adsabs.harvard.edu/abs/2020MNRAS.492.5413R/abstract).
+
+The `reb_integrator_eos` structure contains the configuration and data structures used by EOS.
+
+`unsigned int phi0`
+:   Outer operator splitting scheme (see below for options)
+
+`unsigned int phi1`
+:   Inner operator splitting scheme (see below for options)
+
+`unsigned int n`
+:   Number of sub-timesteps. Default: 2. 
+
+`unsigned int safe_mode`
+:   If set to 0, always combine drift steps at the beginning and end of `phi0`. If set to 1, `n` needs to be bigger than 1.
+
+
+
+The following operator splitting methods for `phi0` and `phi1` are supported in the EOS integrator.
+
+Numerical value | Constant name         | Description
+--------------- | --------------------- | -------------------------------------------------
+0x00            | `REB_EOS_LF`          | 2nd order, standard leap-frog
+0x01            | `REB_EOS_LF4`         | 4th order, three function evaluations
+0x02            | `REB_EOS_LF6`         | 6th order, nine function evaluations
+0x03            | `REB_EOS_LF8`         | 8th order, seventeen function evaluations, see Blanes & Casa (2016), p91
+0x04            | `REB_EOS_LF4_2`       | generalized order (4,2), two force evaluations, McLachlan 1995
+0x05            | `REB_EOS_LF8_6_4`     | generalized order (8,6,4), seven force evaluations
+0x06            | `REB_EOS_PLF7_6_4`    | generalized order (7,6,4), three force evaluations, pre- and post-processors
+0x07            | `REB_EOS_PMLF4`       | 4th order, one modified force evaluation, pre- and post-processors, Blanes et al. (1999)
+0x08            | `REB_EOS_PMLF6`       | 6th order, three modified force evaluations, pre- and post-processors, Blanes et al. (1999)
+
+
+The following code shows how to enable EOS and set the embedded methods.
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->integrator = REB_INTEGRATOR_EOS;
+    r->ri_eos.phi0 = REB_EOS_LF4;
+    r->ri_eos.phi1 = REB_EOS_LF4;
+    r->ri_eos.n = 6;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.integrator = "eos"
+    sim.ri_eos.phi0 = "LF4"
+    sim.ri_eos.phi1 = "LF4"
+    sim.ri_eos.n = 6
+    ```
+
+## Leapfrog
+`REB_INTEGRATOR_LEAPFROG`     
+
+This is the standard leap frog integrator. It is symplectic. By default it is second order with one force evaluation per step. Higher orders of 4, 6, and 8 can be selected as well. These correspond to the 4th order Yoshida integrator and the 8th order by Blanes & Casa (2016), p91. The higher order methods have more function evaluations and are therefore slower. Note that some substeps of the higher order methods move particles backwards. Therefore higher order methods might not give accurate results when a collision search is turned on.
+
+`unsigned int order`
+:   Set the order of the leapfrog integrator:
+    === "C"
+        ```c
+        struct reb_simulation* r = reb_simulation_create();
+        r->integrator = REB_INTEGRATOR_LEAPFROG;
+        r->ri_leapfrog.order = 8; // 2, 4, 6, or 8
+        ```
+
+    === "Python"
+        ```python
+        sim = rebound.Simulation()
+        sim.integrator = "leapfrog"
+        sim.ri_leapfrog.order = 8  # 2, 4, 6, or 8
+        ```
+
+## Symplectic Epicycle Integrator (SEI)
+`REB_INTEGRATOR_SEI`          
+
+Symplectic Epicycle Integrator (SEI), mixed variable symplectic integrator for the shearing sheet, second order, Rein & Tremaine 2011. The `reb_integrator_sei` structure contains the configuration and data structures used by the Symplectic Epicycle Integrator (SEI).
+
+`double OMEGA`
+:   Epicyclic/orbital frequency. This can be set as follows:
+    === "C"
+        ```c
+        struct reb_simulation* r = reb_simulation_create();
+        r->integrator = REB_INTEGRATOR_SEI;
+        r->ri_sei.OMEGA = 1.0;
+        ```
+
+    === "Python"
+        ```python
+        sim = rebound.Simulation()
+        sim.integrator = "sei"
+        sim.ri_sei.OMEGA = 1.0
+        ```
+
+`double OMEGAZ`
+:   Epicyclic frequency in vertical direction. Defaults to `OMEGA` if not set.
+
+All other members of this structure are only for internal use and should not be changed manually.
+
+
+## No integrator
+Sometimes it might make sense to simply not advance any particle positions or velocities. By selecting this integrator, one can still perform integration steps, but particles will not move.
+
+Here is how to do that:
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->integrator = REB_INTEGRATOR_NONE;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.integrator = "none"
+    ```
+
+## WHFast512
+
+WHFast512 is a symplectic Wisdom-Holman integrator. 
+It is using Single Instruction Multiple Data (SIMD) parallelism and 512-bit Advanced Vector Extensions (AVX512) to speed up the integration of planetary systems by up to 4.7x compared to the standard version of WHFast. 
+
+!!! warning "Important"
+
+    To use WHFast512 you need to compile and run REBOUND on a computer that has a CPU which supports AVX512 instructions.
+    You will see an error message if you try to use WHFast512 but have not compiled REBOUND with the AVX512 flag.
+    We describe below how to do this for both the C and python versions of REBOUND below.
+
+    To find out if your CPU supports AVX512 instructions, check for the AVX512 flags by running
+    ```bash
+    cat /proc/cpuinfo | grep avx512
+    ```
+    
+    Note that you can read Simulationarchives of simulations which used WHFast512 on machines that do not support AVX512 instruction.
+    If a synchronization is required, it will be performed with the standard WHFast integrator.
+
+
+=== "C"
+    To turn on the AVX512 flag, go to the Makefile in problem directory. Add this line at the top:
+    ```
+    export AVX512=1
+    ```
+    To explicitly turn AVX512 off, add
+    ```
+    export AVX512=0
+    ```
+    Also make sure to add the `-march=native` flag to the compiler. This will optimize your code (and enable AVX512 instruction) for the specific CPU you're using.
+    ```
+    export OPT=-march=native
+    ```
+    Then, clean your build directory and (re)-build REBOUND with
+    ```bash
+    make clean
+    make
+    ```
+
+=== "Python"
+    To use WHFast512 from python, you need to compile REBOUND with AVX512 instructions enabled. 
+    They are disabled by default and enabled with the AVX512 environment variable.
+    To install the latest release of REBOUND on pypi use:
+    ```bash
+    export AVX512=1
+    pip install rebound
+    ```
+    Alternatively, you can download the latest development version of REBOUND. 
+    Then set the AVX512 environment variable and install REBOUND by running 
+    ```bash
+    export AVX512=1
+    pip install -e .
+    ```
+    from the main directory. 
+
+Once you have compiled REBOUND with AVX512 enabled, you can use WHFast512 like any other integrator:
+
+=== "C"
+    ```c
+    struct reb_simulation* r = reb_simulation_create();
+    r->integrator = REB_INTEGRATOR_WHFAST512;
+    ```
+
+=== "Python"
+    ```python
+    sim = rebound.Simulation()
+    sim.integrator = "whfast512"
+    ```
+
+See also [this example](../c_examples/whfast512_solar_system) on how to use WHFast512.
+If you are interested in integrating 2 or 4 planet systems in parallel, see [this example](../c_examples/whfast512_2_planets).
+
+To allow for the best performance, WHFast512 has certain limitations that WHFast does not have.
+
+- The number of particles cannot exceed 9 (1 star and 8 planets) and needs to be constant. 
+- Although you can use WHFast512 with any number of planets (up to 8), the performance is best if the system has either 2, 4, or 8 planets. 
+- The gravitational constant needs to be exactly equal to 1. Note that you can always [rescale](../units/) your system such that G=1. 
+- The integrator always combines the first and last drift step (`safe_mode=0` for WHFast). 
+- No variational or test particles are supported (although a particle can have mass 0). 
+- MEGNO and other chaos indicators are not supported.
+- WHFast512 always uses democratic heliocentric coordinates. Jacobi coordinates are not supported.
+- The timestep needs to be constant and the `exact_finish_time` flag needs to be set to 0. To change the timestep, first synchronize the simulation, then call `reb_simulation_reset_integrator()`.
+- The masses of all particles need to be constant. To change the masses, first synchronize the simulation, then call `reb_simulation_reset_integrator()`.
+- Additional forces (other than the GR potential) and REBOUNDx are not supported.
+
+
+The setting for WHFast512 are stored in the `reb_integrator_whfast512` structure, which itself is part of the simulation structure. 
+The following settings are available:
+
+`unsigned int keep_unsynchronized`
+:   This flag determines if democratic heliocentric coordinates are re-used after subsequent calls to `reb_simulation_integrate()`. The default is 0. This makes WHFast512 recalculate democratic heliocentric coordinates at the beginning of each `reb_simulation_integrate()` call. Set this flag to 1 if you want to continue an integration using unsynchronized democratic heliocentric coordinates. This is useful if you require outputs (and therefore synchronization) but don't want the integration to be affected by the output to allow for bit-wise reproducibility.
+
+`unsigned int gr_potential`
+:   This flag determines if an additional $1/r^2$ potential is included in the force calculation. The default is 0. Set to 1 to turn on the potential. This can be used to mimic general relativistic precession. Note that this feature assumes [units](../units/) of AU and year/2pi. 
+
+`unsigned int N_systems`
+:   This flag determines how many systems are integrated in parallel. Possible values are 1, 2, or 4.  By default this is set to 1 which means WHFast512 is integrating only one system at a time. If your system has fewer than 5 planets, then you can use WHFast512 to integrate 2 systems in parallel. If your system has fewer than 3 planets, then you can use WHFast512 to integrate 4 systems in parallel. If multiple systems are integrated at the same time, particles must be added in the following order: Star 1, Planet, Planet, Star 2, Planet, Planet, ... For more information see the [this example](../c_examples/whfast512_2_planets).
+

rebound/source/docs/ipython_examples/AdvWHFast.ipynb

@@ -0,0 +1,440 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "# Advanced settings for WHFast:  Extra speed, accuracy, and additional forces\n",
+    "\n",
+    "There are several performance enhancements one can make to WHFast.  However, each one has pitfalls that an inexperienced user can unwittingly fall into.  We therefore chose safe default settings that make the integrator difficult to misuse.  **This makes the default WHFast substantially slower and less accurate than it can be**.  Here we describe how to alter the integrator settings to improve WHFast's performance.\n",
+    "\n",
+    "**TL;DR**\n",
+    "\n",
+    "As long as \n",
+    "\n",
+    "1. you don't add, remove or otherwise modify particles between timesteps\n",
+    "2. you get your outputs by passing a list of output times ahead of time and access the `particles` pointer between calls to `sim.integrate()` (see, e.g., the Visualization section of [WHFast.ipynb](../WHFast))\n",
+    "\n",
+    "you can set `sim.ri_whfast.safe_mode = 0` to get a substantial performance boost.  Under the same stipulations, you can set `sim.ri_whfast.corrector = 11` to get much higher accuracy, at a nearly negligible loss of performance (as long as there are many timesteps between outputs).\n",
+    "\n",
+    "If you want to modify particles, or if the code breaks with these advanced settings, read below for details, and check out the Common mistake with WHFast section at the bottom of [WHFast.ipynb](../WHFast)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "**The Wisdom-Holman algorithm**\n",
+    "\n",
+    "In order to understand and apply the various integrator flags, we need to first understand the Wisdom-Holman scheme (see, e.g., Wisdom & Holman 1991, or Rein & Tamayo 2015 for more details).\n",
+    "\n",
+    "The Wisdom-Holman algorithm consists of alternating *Keplerian* steps that evolve particles on their two-body Keplerian orbits around the star with *interaction* steps that apply impulses to the particles' velocities from the interactions between bodies.  The basic algorithm for a single timestep $dt$ is a Leapfrog Drift-Kick-Drift scheme with an *interaction* kick over the full $dt$ sandwiched between half timesteps of *Keplerian* drift:\n",
+    "\n",
+    "$H_{Kepler}(dt/2)\\:H_{Interaction}(dt)\\:H_{Kepler}(dt/2)$\n",
+    "\n",
+    "Timesteps like the one above are then concatenated over the full integration:\n",
+    "\n",
+    "$H_{Kepler}(dt/2)\\:H_{Interaction}(dt)\\:H_{Kepler}(dt/2)$ $H_{Kepler}(dt/2)\\:H_{Interaction}(dt)\\:H_{Kepler}(dt/2)$ ... $H_{Kepler}(dt/2)\\:H_{Interaction}(dt)\\:H_{Kepler}(dt/2)$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "**Combining Kepler steps and synchronizing**\n",
+    "\n",
+    "It turns out that Kepler steps take longer than interaction steps as long as you don't have many planets, so an obvious and important performance boost would be to combine adjacent Kepler half-steps into full ones, i.e.:\n",
+    "\n",
+    "$H_{Kepler}(dt/2)\\:H_{Interaction}(dt)\\:H_{Kepler}(dt)\\:H_{Interaction}(dt)\\:H_{Kepler}(dt) ... \\:H_{Interaction}(dt)\\:H_{Kepler}(dt/2)$\n",
+    "\n",
+    "The issue is that if you were to, say, output the state of the particles as the simulation progressed, the positions would not correspond to anything real, since the beginning (or end) of one of the full $H_{Kepler}(dt)$ steps corresponds to some intermediate step in an abstract sequence of calculations for a given timestep.  In order to get the particles' actual positions, we would have to calculate to the end the timestep we want the output for by splitting a full *Kepler* step back into two half-steps, e.g.,\n",
+    "\n",
+    "$H_{Kepler}(dt/2)\\:H_{Interaction}(dt)\\:H_{Kepler}(dt)\\:H_{Interaction}(dt)\\:H_{Kepler}(dt/2) \\text{**PRINT OUTPUT**} H_{Kepler}(dt/2) H_{Interaction}(dt)\\:H_{Kepler}(dt)$...\n",
+    "\n",
+    "We call this step of reinserting half-Kepler steps to obtain the physical state of the particles *synchronizing*.  This must be done whenever the **actual** states of the particles are required, e.g., before every output, or if one wanted to use the particles' states to compute additional changes to the particle orbits between timesteps.  It is also necessary to synchronize each timestep whenever the MEGNO chaos indicator is being computed.\n",
+    "\n",
+    "**Conversions between Jacobi and Inertial Coordinates**\n",
+    "\n",
+    "It turns out that the most convenient coordinate system to work in for performing the Kepler steps is often Jacobi coordinates (see, e.g., 9.5.4 of Murray & Dermott).  WHFast therefore works in Jacobi coordinates by default, converting to inertial coordinates when it needs to (e.g. for output, and for doing the direct gravity calculation in the interaction step, which is most easily done in inertial coordinates).\n",
+    "\n",
+    "One feature of WHFast is that it works in whatever inertial coordinate system you choose for your initial conditions.  This means that whatever happens behind the scenes, the user always gets the particles' inertial coordinates at the front end.  At the beginning of every timestep, WHFast therefore has to somehow obtain the Jacobi coordinates.  The straightforward thing would be to convert from the inertial coordinates to Jacobi coordinates every timestep, but these conversions slow things down, and they represent extra operations that grow the round-off error.\n",
+    "\n",
+    "WHFast therefore stores the Jacobi coordinates internally throughout the time it is running, and only recalculates Jacobi coordinates from the inertial ones if told to do so.  Since Jacobi coordinates reference particles to the center of mass of all the particles with indices lower than their own (typically all the particles interior to them), the main reason you would have to recalculate Jacobi coordinates is if between timesteps you choose to somehow change the particles' positions or velocities (give them kicks in addition to their mutual gravity), or change the particles' masses.  \n",
+    "\n",
+    "**Overriding the defaults**\n",
+    "\n",
+    "Let's begin by importing rebound, and defining a simple function to reset rebound and initialize a new simulation with a test case,"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false,
+    "deletable": true,
+    "editable": true
+   },
+   "outputs": [],
+   "source": [
+    "import rebound\n",
+    "import numpy as np\n",
+    "def test_case():\n",
+    "    sim = rebound.Simulation()\n",
+    "    sim.integrator = 'whfast'\n",
+    "    sim.add(m=1.) # add the Sun\n",
+    "    sim.add(m=3.e-6,e=0.99, a=1.) # add Earth\n",
+    "    sim.move_to_com()\n",
+    "    sim.dt = 0.2\n",
+    "    return sim"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "By default WHFast synchronizes and recalculates the Jacobi coordinates from the inertial ones every timestep.  This guarantees that the user always gets physical particle states for output, and ensures reliable output if the user decides to, e.g., grow the particles' masses between timesteps.  \n",
+    "\n",
+    "Now that you understand the pitfalls, if you want to boost WHFast's performance, you simply set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false,
+    "deletable": true,
+    "editable": true
+   },
+   "outputs": [],
+   "source": [
+    "sim = test_case()\n",
+    "sim.ri_whfast.safe_mode = 0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "Now it becomes the user's responsibility to appropriately synchronize and recalculate jacobi coordinates when needed.  You can tell WHFast to recalculate Jacobi coordinates for a given timestep (say after you change a particle's mass) with the `sim.ri_whfast.recalculate_coordinates_this_timestep` flag.  After it recalculates Jacobi coordinates, WHFast will reset this flag to zero, so you just set it each time you mess with the particles."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "collapsed": false,
+    "deletable": true,
+    "editable": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "safe_mode = 1\n",
+      "---------------------------------\n",
+      "REBOUND version:     \t3.4.0\n",
+      "REBOUND built on:    \tMay 31 2017 11:53:50\n",
+      "Number of particles: \t2\n",
+      "Selected integrator: \twhfast\n",
+      "Simulation time:     \t6.2831853071795858e+05\n",
+      "Current timestep:    \t0.200000\n",
+      "---------------------------------\n",
+      "<rebound.Particle object, m=1.0 x=3.8952737650111065e-06 y=-4.025686466113066e-07 z=0.0 vx=2.1862005456099384e-06 vy=9.999414128270949e-08 vz=0.0>\n",
+      "<rebound.Particle object, m=3e-06 x=-1.2984227143844442 y=0.1341896612527594 z=0.0 vx=-0.7287335151973472 vy=-0.0333313804272124 vz=0.0>\n",
+      "---------------------------------\n",
+      "Safe integration took 1.4043679237365723 seconds\n",
+      "---------------------------------\n",
+      "REBOUND version:     \t3.4.0\n",
+      "REBOUND built on:    \tMay 31 2017 11:53:50\n",
+      "Number of particles: \t2\n",
+      "Selected integrator: \twhfast\n",
+      "Simulation time:     \t6.2831853071795858e+05\n",
+      "Current timestep:    \t0.200000\n",
+      "---------------------------------\n",
+      "<rebound.Particle object, m=1.0 x=3.89491388755522e-06 y=-4.0258518356289257e-07 z=0.0 vx=2.18648433924743e-06 vy=9.996480978405334e-08 vz=0.0>\n",
+      "<rebound.Particle object, m=3e-06 x=-1.298304629185073 y=0.13419506118763086 z=0.0 vx=-0.7288281130824766 vy=-0.03332160326135111 vz=0.0>\n",
+      "---------------------------------\n",
+      "Manual integration took 0.8836901187896729 seconds\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "Porb = 2*np.pi # orbital period for Earth, using units of G = 1, solar masses, AU and yr/2pi\n",
+    "\n",
+    "sim = test_case()\n",
+    "print(\"safe_mode = {0}\".format(sim.ri_whfast.safe_mode))\n",
+    "start_time = time.time()\n",
+    "sim.integrate(1.e5*Porb)\n",
+    "sim.status()\n",
+    "print(\"Safe integration took {0} seconds\".format(time.time() - start_time))\n",
+    "\n",
+    "sim = test_case()\n",
+    "sim.ri_whfast.safe_mode = 0\n",
+    "start_time = time.time()\n",
+    "sim.integrate(1.e5*Porb)\n",
+    "sim.status()\n",
+    "print(\"Manual integration took {0} seconds\".format(time.time() - start_time))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true,
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "In our test case with a single planet, there is effectively no interaction step, and by combining Kepler steps we get almost the full factor of 2 speedup we expect.  Because Kepler steps are expensive (by virtue of having to solve the transcendental Kepler equation), this will always be an important performance boost for few-planet cases.\n",
+    "\n",
+    "Note that one case where REBOUND needs to synchronize every timestep is if you're using the MEGNO chaos indicator.  So if you call"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "collapsed": true,
+    "deletable": true,
+    "editable": true
+   },
+   "outputs": [],
+   "source": [
+    "sim.init_megno()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "REBOUND will synchronize every timestep even if you set `sim.ri_whfast.safe_mode = 0` and never explicitly call `sim.synchronize()`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true,
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "**Modifying particles/forces**\n",
+    "\n",
+    "Again, if performance is a factor in your simulations, you would not want to write a custom stepper in python that modifies the particles, since this will be very slow.  You could either write a modified C version of `reb_simulation_integrate` in `src/librebound.c` (the flags are defined in `librebound.h`, and have the same name as the python ones, just without `sim.` in front), or you can use the REBOUNDXF library, which takes care of this for you and supports many typically used modifications.  We again illustrate a simple scheme with python code:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": true,
+    "deletable": true,
+    "editable": true
+   },
+   "outputs": [],
+   "source": [
+    "sim = test_case()\n",
+    "sim.ri_whfast.safe_mode = 0\n",
+    "def integrate_mod(sim, t_final):\n",
+    "    while sim.t < t_final:\n",
+    "        sim.step()\n",
+    "        sim.particles[1].m += 1.e-10\n",
+    "        sim.ri_whfast.recalculate_coordinates_this_timestep = 1\n",
+    "    sim.synchronize()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "Here, because we grow the mass of the planet every timestep, we have to recalculate Jacobi coordinates every timestep (since they depend on the masses of the particles).  We therefore manually set the flag to recalculate them the next timestep every time we make a change.  Here we would actually get the same result if we just left `sim.ri_whfast.safe_mode = 1`, since when recalculating Jacobi coordinates, WHFast automatically has to synchronize in order to get real positions and velocities for the planets.  In this case WHFast is therefore synchronizing and recalculating Jacobi coordinates every timestep.\n",
+    "\n",
+    "But imagine now that instead of growing the mass, we continually add an impulse to vx:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false,
+    "deletable": true,
+    "editable": true
+   },
+   "outputs": [],
+   "source": [
+    "sim = test_case()\n",
+    "sim.ri_whfast.safe_mode = 0\n",
+    "def integrate_mod(sim, t_final):\n",
+    "    while sim.t < t_final:\n",
+    "        sim.step()\n",
+    "        sim.particles[1].vx += 1.e-10*sim.dt\n",
+    "        sim.ri_whfast.recalculate_coordinates_this_timestep = 1\n",
+    "    sim.synchronize()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "This would not give accurate results, because the `sim.particles[1].vx` we access after `sim.step()` isn't a physical velocity (it's missing a half-Kepler step).  It's basically at an intermediate point in the calculation.  In order to make this work, one would call `sim.synchronize()` between `sim.step()` and accessing `sim.particles[1].vx`, to ensure the velocity is physical."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "**Symplectic correctors**\n",
+    "\n",
+    "Symplectic correctors make the Wisdom-Holman scheme higher order (without symplectic correctors it's second order).  The great thing about them is that they only need to get applied when you synchronize.  So if you just need to synchronize to output, and there are many timesteps between outputs, they represent a very small performance loss for a huge boost in accuracy (compare for example the green line (11th order corrector) to the red line (no corrector) in Fig. 4 of Rein & Tamayo 2015--beyond the right of the plot, where the round-off errors dominate, the two lines would rise in unison).  We have implemented symplectic correctors up to order 11.  You can set the order with (must be an odd number), e.g.,"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "collapsed": true,
+    "deletable": true,
+    "editable": true
+   },
+   "outputs": [],
+   "source": [
+    "sim.ri_whfast.corrector = 11"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "By default, WHFast does not use correctors, i.e., sim.integrator_whfast_corrector = 0.  This is because the default is also to synchronize every timestep.  An Nth order corrector does N-1 Kepler steps of various sizes, so an 11th order corrector done every timestep would increase the number of Kepler steps by an order of magnitude, making WHFast unacceptably slow.  So keep in mind that if you're doing modifications that require recalculating jacobi coordinates or synchronizing every timestep, you should turn off symplectic correctors (the default) unless you really need the accuracy."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Changing the internal coordinate system**\n",
+    "\n",
+    "WHFast by default uses Jacobi coordinates internally. This works well for planetary systems which are stable and orbits are not crossing. However, in some cases a different coordinate system might perform better. WHFast also support so-called democratic heliocentric coordinates and the so called WHDS coordinates. For more information on these coordinates systems [see Hernandez and Dehnen (2016)](https://arxiv.org/abs/1612.05329). To select a different coordinate system, use the following syntax:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "sim.ri_whfast.coordinates = 'jacobi' #default\n",
+    "sim.ri_whfast.coordinates = 'democraticheliocentric' \n",
+    "sim.ri_whfast.coordinates = 'whds' "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that symplectic corrector are only compatible with Jacobi coordinates because both democratic heliocentric and WHDS include a so called jump step."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "deletable": true,
+    "editable": true
+   },
+   "source": [
+    "**Warning messages**\n",
+    "\n",
+    "If you choose a timestep that is larger than the smallest dynamical timescale and WHFast has difficulties to solve the Kepler problem, you will receive a warning message."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "collapsed": false,
+    "deletable": true,
+    "editable": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rein/git/rebound/rebound/simulation.py:305: RuntimeWarning: WHFast convergence issue. Timestep is larger than at least one orbital period.\n",
+      "  warnings.warn(msg[1:], RuntimeWarning)\n"
+     ]
+    }
+   ],
+   "source": [
+    "sim = test_case()\n",
+    "sim.dt = 1000.\n",
+    "sim.integrate(1000.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true,
+    "deletable": true,
+    "editable": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.5.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

rebound/source/docs/ipython_examples/ChaoticHyperion.ipynb

@@ -0,0 +1,250 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "6882e778",
+   "metadata": {},
+   "source": [
+    "# Chaotic Hyperion\n",
+    "In this example, we simulate the spin of Hyperion. The spin evolution is governed by an ordinary differential equation that is coupled to the moon's orbit. \n",
+    "\n",
+    "We start by importing REBOUND, numpy and matplotlib."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e350dbbb",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "import rebound\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0bc568b2",
+   "metadata": {},
+   "source": [
+    "The right hand side of ODEs can be implemented in either python or in C. Although not absolutely necessary for this example, we here show how to implement the RHS in C. This is often significantly faster than using a python callback function. \n",
+    "\n",
+    "We use a simple spin model which is one second order ODE, or a set of two coupled first order ODEs. For more details on the physics behind this model, see  Danby (1962), Goldreich and Peale (1966), and Wisdom and Peale (1983). The RHS of this set of ODEs implemented in C is:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79a48333",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overwriting rhs.c\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%writefile rhs.c\n",
+    "#include \"rebound.h\"\n",
+    "void derivatives(struct reb_ode* const ode, double* const yDot, const double* const y, const double t){\n",
+    "    struct reb_orbit o = reb_orbit_from_particle(ode->r->G, ode->r->particles[1], ode->r->particles[0]);\n",
+    "    \n",
+    "    double omega2 = 3.*0.26; \n",
+    "    yDot[0] = y[1];\n",
+    "    yDot[1] = -omega2/(2.*o.d*o.d*o.d)*sin(2.*(y[0]-o.f));\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "33cd1c9c",
+   "metadata": {},
+   "source": [
+    "We now compile this into a shared library. We need the REBOUND headers and library for this. The following is a bit of hack: we just copy the files into the current folder. This works if you've installed REBOUND from the git repository. Otherwise, you'll need to find these files manually (which might depend on your python environment). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "7d3c176a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!cp ../src/librebound.so .\n",
+    "!cp ../src/rebound.h .\n",
+    "!gcc -c -O3 -fPIC rhs.c -o rhs.o\n",
+    "!gcc -L. -shared rhs.o -o rhs.so -lrebound "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2421c0e7",
+   "metadata": {},
+   "source": [
+    "Using ctypes, we can load the library into python"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11736a91",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ctypes import cdll\n",
+    "clibrhs = cdll.LoadLibrary(\"rhs.so\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37ac5371",
+   "metadata": {},
+   "source": [
+    "The following function is setting up the N-body simulation as well as the ODE system that governs the spin evolution. Note that we set the `derivatives` function pointer to the C function we've just compiled. You could also set this function pointer to a python function and avoid all the C complications."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 133,
+   "id": "18043d1d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def setup():\n",
+    "    sim = rebound.Simulation()\n",
+    "    sim.add(m=1)             # Saturn\n",
+    "    sim.add(a=1, e=0.123233) # Hyperion, massless, semi-major axis of 1\n",
+    "    sim.integrator = \"BS\"\n",
+    "    sim.ri_bs.eps_rel = 1e-12  # tolerance\n",
+    "    sim.ri_bs.eps_abs = 1e-12\n",
+    "    \n",
+    "    ode_spin = sim.create_ode(length=2, needs_nbody=True)\n",
+    "    ode_spin.y[0] = 0.01  # initial conditions that lead to chaos\n",
+    "    ode_spin.y[1] = 1\n",
+    "    ode_spin.derivatives = clibrhs.derivatives\n",
+    "    \n",
+    "    return sim, ode_spin"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "85c097cf",
+   "metadata": {},
+   "source": [
+    "We will create two simulations that are slightly offset from each other."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8182b908",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim, ode_spin = setup()\n",
+    "sim2, ode_spin2 = setup()\n",
+    "ode_spin2.y[0] += 1e-8 # small perturbation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c597773f",
+   "metadata": {},
+   "source": [
+    "With these two simulations, we can measure the growing divergence of nearby trajectories, a key feature of chaos."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 149,
+   "id": "4eb25927",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "times = 2.*np.pi*np.linspace(0,30,100) # a couple of orbits\n",
+    "obliq = np.zeros((len(times)))\n",
+    "obliq2 = obliq.copy()\n",
+    "\n",
+    "for i, t in enumerate(times):\n",
+    "    sim.integrate(t, exact_finish_time=1)\n",
+    "    sim2.integrate(t, exact_finish_time=1)        \n",
+    "    obliq[i] = ode_spin.y[0]\n",
+    "    obliq2[i] = ode_spin2.y[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "98a92abf",
+   "metadata": {},
+   "source": [
+    "Finally, let us plot the divergence as a function of time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 150,
+   "id": "13ac8f3a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1,1)\n",
+    "ax.set_xlabel(\"time [orbits]\")\n",
+    "ax.set_ylabel(\"obliquity difference [degrees]\")\n",
+    "ax.set_yscale(\"log\")\n",
+    "ax.set_ylim([1e-8,1e2])\n",
+    "o1 = np.remainder((obliq-obliq2)*180/np.pi,360.)\n",
+    "o2 = np.remainder((obliq2-obliq)*180/np.pi,360.)\n",
+    "ax.scatter(times/np.pi/2.,np.minimum(o1,o2))\n",
+    "ax.plot(times/np.pi/2.,1e-8/np.pi*180.*np.exp(times/(np.pi*2.)/1.2),color=\"black\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c2bc381f",
+   "metadata": {},
+   "source": [
+    "On a log-linear scale, we see that the divergence follows a straight line, indicating exponential growth. The Lyapunov timescale is approximately 1.2 orbits. About 25 days! (Wikipedia says ~30 days which is close enough given the very simplistic model)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

rebound/source/docs/ipython_examples/Cheartbeat.ipynb

@@ -0,0 +1,300 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Using a C Heartbeat function\n",
+    "The heartbeat function of a REBOUND simulation gets called after every timestep. There are many different things you can do in a heartbeat function, for example creating outputs, adding particles, adjusting parameters that depend on time, etc. REBOUND supports heartbeat functions in both its C and python interface. \n",
+    "\n",
+    "A python heartbeat function can sometimes become the bottleneck of a simulation because it gets called every single timestep. This tutorial shows you how to implement the heartbeat function in C, then link it to REBOUND using python. Note that alternatively you can of course always just use the C version of REBOUND directly and never bother with python at all.\n",
+    "\n",
+    "We start by creating a REBOUND simulation which contains the planets of our Solar System as a test case."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import rebound\n",
+    "sim = rebound.Simulation()\n",
+    "rebound.data.add_solar_system(sim)\n",
+    "sim.integrator = \"whfast\"\n",
+    "sim.dt = sim.particles[1].P/30.13 # About 30 steps for each Mercury Orbit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let us first create a simple heartbeat function in python. It simply calculates the eccentricity of Mercury (you could do something with it, here we just calculate it and then ignore it)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Eccentricity: 0.205636 \n"
+     ]
+    }
+   ],
+   "source": [
+    "# We use a global variable to store the value of the eccentricity\n",
+    "e = 0 \n",
+    "def heartbeat(sim_pointer):\n",
+    "    global e\n",
+    "    # The function argument is a pointer to the simulation:\n",
+    "    # Here we get its contents:\n",
+    "    sim = sim_pointer.contents \n",
+    "    e = sim.particles[1].e\n",
+    "sim.heartbeat = heartbeat\n",
+    "sim.integrate(sim.t+1)\n",
+    "print(\"Eccentricity: %f \" %e)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's measure how long it takes to integrate 1000 orbits:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Runtime: 0.474900 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "start = time.time()\n",
+    "sim.integrate(sim.t + sim.particles[1].P*1000)\n",
+    "stop = time.time()\n",
+    "print(\"Runtime: %f s\"%(stop-start))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We now implement this in C. For this to work, it is best to download and work with a full REBOUND repository (download the package from github, rather than just installing the python package with pip install). \n",
+    "\n",
+    "We first write our heartbeat function in C. The following cell writes to a new file in the current directory, `heartbeat.c` (you can also use an external editor and terminal window to do the same without the jupyter magic commands):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overwriting heartbeat.c\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%writefile heartbeat.c\n",
+    "#include \"rebound.h\"\n",
+    "double e =0; // global variable\n",
+    "void heartbeat(struct reb_simulation* sim_pointer){\n",
+    "    struct reb_orbit orbit = reb_orbit_from_particle(sim_pointer->G, sim_pointer->particles[0], sim_pointer->particles[1]);\n",
+    "    e = orbit.e;\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Before we compile and link our heartbeat function as a shared library, we need the REBOUND header file and the shared library file. Different operating systems and compilers handles the paths to shared libraries differently. This can quickly get rather frustrating. If you're familiar with C, by all means go ahead and do it the proper way. A hack to get around most of these difficulties is to simply copy the REBOUND header and library to the current folder."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!cp ../src/librebound.so .\n",
+    "!cp ../src/rebound.h ."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you installed REBOUND with pip, you can look up the paths to the two files in python and e.g. create symlinks to them into your working directory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/path/to/your/venv/lib/python3.9/site-packages/rebound/../librebound.cpython-39-x86_64-linux-gnu.so\n",
+      "/path/to/your/venv/lib/python3.9/site-packages/rebound/rebound.h\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pathlib import Path\n",
+    "print(rebound.__libpath__)\n",
+    "print(Path(rebound.__file__).parent / \"rebound.h\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next we can compile and link the code. `-fPIC` instructs gcc to create Position Independent Code, which might not be needed on your operating system."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!gcc -c -O3 -fPIC heartbeat.c -o heartbeat.o"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!gcc -L. -shared heartbeat.o -o heartbeat.so -lrebound "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we load the library using ctypes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ctypes import cdll\n",
+    "clibheartbeat = cdll.LoadLibrary(\"heartbeat.so\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now finally set the function pointer in our simulation to the new heartbeat function and then run the simulation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.heartbeat = clibheartbeat.heartbeat"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Runtime: 0.153589 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "start = time.time()\n",
+    "sim.integrate(sim.t + sim.particles[1].P*1000)\n",
+    "stop = time.time()\n",
+    "print(\"Runtime: %f s\"%(stop-start))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that the simulation runs significantly faster using the C heartbeat function as we avoid all the python overhead.\n",
+    "\n",
+    "We can print out the value of the global variable `e` in the heartbeat library (using global variables in a shared library is not the best way to store data - all simulations will see the same variable and you could end up with unexpected behaviour if you are running multiple simulations in one python program)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.2057293010348337\n"
+     ]
+    }
+   ],
+   "source": [
+    "from ctypes import c_double\n",
+    "print(c_double.in_dll(clibheartbeat,\"e\").value)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

rebound/source/docs/ipython_examples/Checkpoints.ipynb

@@ -0,0 +1,120 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Checkpoints\n",
+    "You can easily save and load a REBOUND simulation to a binary file. The binary file includes all information about the particles (mass, position, velocity, etc), as well as the current simulation settings such as time, integrator choice, etc.\n",
+    "\n",
+    "Let's add three particles to REBOUND and save them to a file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "---------------------------------\n",
+      "REBOUND version:     \t3.8.0\n",
+      "REBOUND built on:    \tFeb  3 2019 13:37:32\n",
+      "Number of particles: \t3\n",
+      "Selected integrator: \twhfast\n",
+      "Simulation time:     \t0.0000000000000000e+00\n",
+      "Current timestep:    \t0.001000\n",
+      "---------------------------------\n",
+      "<rebound.Particle object, m=1.0 x=0.0 y=0.0 z=0.0 vx=0.0 vy=0.0 vz=0.0>\n",
+      "<rebound.Particle object, m=1e-06 x=1.0 y=0.0 z=0.0 vx=0.0 vy=1.000000499999875 vz=0.0>\n",
+      "<rebound.Particle object, m=0.0 x=2.000000999999 y=0.0 z=0.0 vx=0.0 vy=0.7071081347393496 vz=0.0>\n",
+      "---------------------------------\n"
+     ]
+    }
+   ],
+   "source": [
+    "import rebound\n",
+    "sim = rebound.Simulation()\n",
+    "sim.add(m=1.)\n",
+    "sim.add(m=1e-6, a=1.)\n",
+    "sim.add(a=2.)\n",
+    "sim.integrator = \"whfast\"\n",
+    "sim.save_to_file(\"checkpoint.bin\")\n",
+    "sim.status()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The binary files are small in size and store every floating point number exactly, so you don't have to worry about efficiency or losing precision. You can make lots of checkpoints if you want!\n",
+    "\n",
+    "Let's delete the old REBOUND simulation (that frees up the memory from that simulation) and then read the binary file we just saved."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "---------------------------------\n",
+      "REBOUND version:     \t3.8.0\n",
+      "REBOUND built on:    \tFeb  3 2019 13:37:32\n",
+      "Number of particles: \t3\n",
+      "Selected integrator: \twhfast\n",
+      "Simulation time:     \t0.0000000000000000e+00\n",
+      "Current timestep:    \t0.001000\n",
+      "---------------------------------\n",
+      "<rebound.Particle object, m=1.0 x=0.0 y=0.0 z=0.0 vx=0.0 vy=0.0 vz=0.0>\n",
+      "<rebound.Particle object, m=1e-06 x=1.0 y=0.0 z=0.0 vx=0.0 vy=1.000000499999875 vz=0.0>\n",
+      "<rebound.Particle object, m=0.0 x=2.000000999999 y=0.0 z=0.0 vx=0.0 vy=0.7071081347393496 vz=0.0>\n",
+      "---------------------------------\n"
+     ]
+    }
+   ],
+   "source": [
+    "del sim\n",
+    "sim = rebound.Simulation(\"checkpoint.bin\")\n",
+    "sim.status()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that you will have to re-set any function pointers manually (if you're using them)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

rebound/source/docs/ipython_examples/CloseEncounters.ipynb

@@ -0,0 +1,332 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Catching close encounters using exceptions\n",
+    "Sometimes one is interested in catching a close encounter between two planets. This can easily be done with REBOUND. What you do when a close encounter happens is up to you.\n",
+    "\n",
+    "Some integrators are better suited to simulate close encounters than others. For example, the non-symplectic integrator IAS15 has an adaptive timestep scheme that resolves close encounters very well. Integrators that use a fixed timestep like WHFast are more likely to miss close encounters.\n",
+    "\n",
+    "Let's start by setting up a two-planet system that will go unstable on a short timescale:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import rebound\n",
+    "import numpy as np\n",
+    "def setupSimulation():\n",
+    "    sim = rebound.Simulation()\n",
+    "    sim.integrator = \"ias15\" # IAS15 is the default integrator, so we don't need this line\n",
+    "    sim.add(m=1.)\n",
+    "    sim.add(m=1e-3,a=1.)\n",
+    "    sim.add(m=5e-3,a=1.25)\n",
+    "    sim.move_to_com()\n",
+    "    return sim"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's integrate this system for 100 orbital periods."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim = setupSimulation()\n",
+    "sim.integrate(100.*2.*np.pi)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Rebound exits the integration routine normally. We can now explore the final particle orbits:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<rebound.Orbit instance, a=4.725537568103762 e=0.7145243085874022 inc=0.0 Omega=0.0 omega=2.7372774231509887 f=4.39210305882742>\n",
+      "<rebound.Orbit instance, a=1.0429076415181782 e=0.12110823999615411 inc=0.0 Omega=0.0 omega=5.927708717019177 f=4.786502097969678>\n"
+     ]
+    }
+   ],
+   "source": [
+    "for o in sim.orbits():\n",
+    "    print(o)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We see that the orbits of both planets changed significantly and we can already speculate that there was a close encounter.\n",
+    "\n",
+    "Let's redo the simulation, but this time set the `sim.exit_min_distance` flag for the simulation. If this flag is set, then REBOUND calculates the minimum distance between all particle pairs each timestep. If the distance is less than `sim.exit_min_distance`, then the integration is stopped and an exception thrown. Here, we'll use the [Hill radius](https://en.wikipedia.org/wiki/Hill_sphere) as the criteria for a close encounter. It is given by $r_{\\rm Hill} \\approx a \\sqrt{\\frac{m}{3M}}$, which is approximately 0.15 AU in our case. \n",
+    "\n",
+    "This setup allows us to catch the exception and deal with it in a customized way.  As a first example, let's catch the exception with a `try`-`except` block, and simply print out the error message. Additionally, let's store the particles' separations while we're integrating:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Two particles had a close encounter (d<exit_min_distance).\n"
+     ]
+    }
+   ],
+   "source": [
+    "sim = setupSimulation() # Resets everything\n",
+    "sim.exit_min_distance = 0.15\n",
+    "Noutputs = 1000\n",
+    "times = np.linspace(0,100.*2.*np.pi,Noutputs)\n",
+    "distances = np.zeros(Noutputs)\n",
+    "ps = sim.particles # ps is now an array of pointers. It will update as the simulation runs.\n",
+    "try:\n",
+    "    for i,time in enumerate(times):\n",
+    "        sim.integrate(time)\n",
+    "        dp = ps[1] - ps[2]   # Calculates the coponentwise difference between particles \n",
+    "        distances[i] = np.sqrt(dp.x*dp.x+dp.y*dp.y+dp.z*dp.z)\n",
+    "except rebound.Encounter as error:\n",
+    "    print(error)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `Encounter` does currently not tell you which particles had a close encounter. But you can easily search for the pair yourself (see below). \n",
+    "\n",
+    "Here, we already know which bodies had a close encounter (the two planets) and we can plot their separation as a function of time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "fig = plt.figure(figsize=(10,5))\n",
+    "ax = plt.subplot(111)\n",
+    "ax.set_xlabel(\"time [orbits]\")\n",
+    "ax.set_xlim([0,sim.t/(2.*np.pi)])\n",
+    "ax.set_ylabel(\"distance\")\n",
+    "plt.plot(times/(2.*np.pi), distances);\n",
+    "plt.plot([0.0,12],[0.2,0.2]); # Plot our close encounter criteria;"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We did indeed find the close encounter correctly. We can now search for the two particles that collided and, for this example, merge them. To do that we'll first calculate our new merged planet coordinates, then remove the two particles that collided from REBOUND and finally add the new particle."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of particles at the beginning of the simulation: 3.\n",
+      "Two particles had a close encounter (d<exit_min_distance).\n",
+      "Number of particles at the end of the simulation: 2.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from itertools import combinations\n",
+    "def mergeParticles(sim):\n",
+    "    # Find two closest particles\n",
+    "    min_d2 = 1e9 # large number\n",
+    "    ps = sim.particles\n",
+    "    for i1, i2 in combinations(range(sim.N),2): # get all pairs of indices\n",
+    "        dp = ps[i1] - ps[i2]   # Calculates the coponentwise difference between particles \n",
+    "        d2 = dp.x*dp.x+dp.y*dp.y+dp.z*dp.z\n",
+    "        if d2<min_d2:\n",
+    "            min_d2 = d2\n",
+    "            col_i1 = i1\n",
+    "            col_i2 = i2\n",
+    "    \n",
+    "    cp1 = ps[col_i1]\n",
+    "    cp2 = ps[col_i2]\n",
+    "    # Merge two closest particles\n",
+    "    \n",
+    "    sum_mass = cp1.m + cp2.m\n",
+    "    mergedPlanet = (cp1*cp1.m + cp2*cp2.m)/sum_mass \n",
+    "    mergedPlanet.m  = sum_mass\n",
+    "    sim.remove(index=col_i2) # Note: Removing a particle changes the sim.particles\n",
+    "    sim.remove(index=col_i1) #       array and the particle indicies.\n",
+    "    sim.add(mergedPlanet, assignHash=True)\n",
+    "\n",
+    "sim = setupSimulation() # Resets everything\n",
+    "sim.exit_min_distance = 0.15\n",
+    "print(\"Number of particles at the beginning of the simulation: %d.\"%sim.N)\n",
+    "for i,time in enumerate(times):\n",
+    "    try:\n",
+    "        sim.integrate(time)\n",
+    "    except rebound.Encounter as error:\n",
+    "        print(error)\n",
+    "        mergeParticles(sim)\n",
+    "print(\"Number of particles at the end of the simulation: %d.\"%sim.N)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    }
+   },
+   "source": [
+    "We can achieve the same outcome by using more of the built-in functionality of REBOUND. For that, we set the radius of the particles to their Hill radius. In practice, you might want to use the physical radius, but for this example, we want the collision to occur in a short amount of time and therefore inflate the particle radii. We set the collision detection routine to `direct` which will do a $O(N^2)$ collision search between all particles. The `collisions_resolve` call-back function is set to `merge`, which will merge the particles together, assuming mass and momentum conservation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def setupSimulation():\n",
+    "    sim = rebound.Simulation()\n",
+    "    sim.integrator = \"ias15\" # IAS15 is the default integrator, so we don't really need this line\n",
+    "    sim.add(m=1.)\n",
+    "    sim.add(m=1e-3, a=1., r=np.sqrt(1e-3/3.)) # we now set collision radii!\n",
+    "    sim.add(m=5e-3, a=1.25, r=1.25*np.sqrt(5e-3/3.))\n",
+    "    sim.move_to_com()\n",
+    "    return sim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Particles in the simulation at t=   0.0: 3\n",
+      "Particles in the simulation at t= 100.0: 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "sim = setupSimulation()\n",
+    "sim.collision = \"direct\"\n",
+    "sim.collision_resolve = \"merge\"\n",
+    "\n",
+    "print(\"Particles in the simulation at t=%6.1f: %d\"%(sim.t,sim.N))\n",
+    "sim.integrate(100.)\n",
+    "print(\"Particles in the simulation at t=%6.1f: %d\"%(sim.t,sim.N))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also use the built-in collision detection and apply our own function to resolve the collision. By default, if we don't set the sim.collision function pointer, `REBOUND` will raise a `Collision` exception when a collision occurs, which we can catch. \n",
+    "\n",
+    "An indirect way of checking which particles collided is to check which ones have a `last_collision` time equal to the current simulation time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Particles [1, 2] collided\n"
+     ]
+    }
+   ],
+   "source": [
+    "sim = setupSimulation()\n",
+    "sim.collision = \"direct\"\n",
+    "# we don't set sim.collision_resolve this time\n",
+    "\n",
+    "try:\n",
+    "    sim.integrate(100.)\n",
+    "except rebound.Collision:\n",
+    "    collided = []\n",
+    "    for p in sim.particles:\n",
+    "        if p.last_collision == sim.t:\n",
+    "            collided.append(p.index)\n",
+    "    # Custom resolution\n",
+    "\n",
+    "print(\"Particles {0} collided\".format(collided))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}