Repository: dtamayo/reboundx (language: python)

Issue:
Minor



Discussion / hints:

Fix patch:
diff --git a/doc/effect_headers.txt b/doc/effect_headers.txt
index a1a9da75..41792355 100644
--- a/doc/effect_headers.txt
+++ b/doc/effect_headers.txt
@@ -25,6 +25,10 @@ $$$$$$$$$$$$
 Radiation Forces
 ^^^^^^^^^^^^^^^^
 
+$$$$$$$$$$$$
+Stochastic Forces
+^^^^^^^^^^^^^^^^
+
 $$$$$$$$$$$$
 Mass Modifications
 ^^^^^^^^^^^^^^^^^^
@@ -63,4 +67,4 @@ Inner disk edge
 
 $$$$$$$$$$$$$$$$$$
 Type I migration
-^^^^^^^^^^^^^^^^^^
\ No newline at end of file
+^^^^^^^^^^^^^^^^^^
diff --git a/doc/effects.rst b/doc/effects.rst
index 2d2010c0..dabb9ba1 100644
--- a/doc/effects.rst
+++ b/doc/effects.rst
@@ -342,6 +342,41 @@ beta (float)                 Yes         Ratio of radiation pressure force to gr
 ============================ =========== ==================================================================
 
 
+Stochastic Forces
+^^^^^^^^^^^^^^^^
+
+.. _stochastic_forces:
+
+stochastic_forces
+*****************
+
+======================= ===============================================
+Authors                 H. Rein
+Based on                `Rein and Papaloizou 2009 <https://ui.adsabs.harvard.edu/abs/2009A%26A...497..595R/abstract>`_.
+C Example               :ref:`c_example_stochastic_forces`
+Python Example          `StochasticForces.ipynb <https://github.com/dtamayo/reboundx/blob/master/ipython_examples/StochasticForces.ipynb>`_,
+======================= ===============================================
+
+This applies stochastic forces to particles in the simulation.  
+
+**Effect Parameters**
+
+None
+
+**Particle Parameters**
+
+All particles which have the field kappa set, will experience stochastic forces.
+The particle with index 0 cannot experience stochastic forces.
+
+============================ =========== ==================================================================================
+Field (C type)               Required    Description
+============================ =========== ==================================================================================
+kappa (double)               Yes         Strength of stochastic forces relative to gravity from central object 
+tau_kappa (double)           No          Auto-correlation time of stochastic forces. Defaults to orbital period if not set.
+                                         The units are relative to the current orbital period.
+============================ =========== ==================================================================================
+
+
 Mass Modifications
 ^^^^^^^^^^^^^^^^^^
 
@@ -578,4 +613,4 @@ Inner disk edge
 ^^^^^^^^^^^^^^^^^
 
 Type I migration
-^^^^^^^^^^^^^^^^^^
\ No newline at end of file
+^^^^^^^^^^^^^^^^^^
diff --git a/examples/stochastic_forces/Makefile b/examples/stochastic_forces/Makefile
new file mode 100644
index 00000000..bd65ebe7
--- /dev/null
+++ b/examples/stochastic_forces/Makefile
@@ -0,0 +1,48 @@
+export OPENGL=1
+
+ifndef REB_DIR
+ifneq ($(wildcard ../../../rebound/.*),) # Check for REBOUND in default location
+REB_DIR=../../../rebound
+endif
+ifneq ($(wildcard ../../../../rebound/.*),) # Check for REBOUNDx being inside REBOUND directory
+REB_DIR=../../../
+endif
+endif
+ifndef REB_DIR # REBOUND is not in default location and REB_DIR is not set
+    $(error REBOUNDx not in the same directory as REBOUND.  To use a custom location, you Must set the REB_DIR environment variable for the path to your rebound directory, e.g., export REB_DIR=/Users/dtamayo/rebound.  See reboundx.readthedocs.org)
+endif
+PROBLEMDIR=$(shell basename `dirname \`pwd\``)"/"$(shell basename `pwd`)
+
+include $(REB_DIR)/src/Makefile.defs
+
+REBX_DIR=../../
+
+all: librebound.so libreboundx.so
+	@echo ""
+	@echo "Compiling problem file ..."
+	$(CC) -I$(REBX_DIR)/src/ -I$(REB_DIR)/src/ -Wl,-rpath,./ $(OPT) $(PREDEF) problem.c -L. -lreboundx -lrebound $(LIB) -o rebound
+	@echo ""
+	@echo "Problem file compiled successfully."
+
+librebound.so:
+	@echo "Compiling shared library librebound.so ..."
+	$(MAKE) -C $(REB_DIR)/src/
+	@echo "Creating link for shared library librebound.so ..."
+	@-rm -f librebound.so
+	@ln -s $(REB_DIR)/src/librebound.so .
+
+libreboundx.so: 
+	@echo "Compiling shared library libreboundx.so ..."
+	$(MAKE) -C $(REBX_DIR)/src/
+	@-rm -f libreboundx.so
+	@ln -s $(REBX_DIR)/src/libreboundx.so .
+
+clean:
+	@echo "Cleaning up shared library librebound.so ..."
+	@-rm -f librebound.so
+	$(MAKE) -C $(REB_DIR)/src/ clean
+	@echo "Cleaning up shared library libreboundx.so ..."
+	@-rm -f libreboundx.so
+	$(MAKE) -C $(REBX_DIR)/src/ clean
+	@echo "Cleaning up local directory ..."
+	@-rm -vf rebound
diff --git a/examples/stochastic_forces/problem.c b/examples/stochastic_forces/problem.c
new file mode 100644
index 00000000..a84e289c
--- /dev/null
+++ b/examples/stochastic_forces/problem.c
@@ -0,0 +1,72 @@
+/**
+ * Stochastic forces on a single planet
+ * 
+ * This example shows how to add a stochastic force to a single planet. 
+ * As a result, the planet will undergo a random walk in its orbital
+ * parameters. See also [Rein (2010)](https://ui.adsabs.harvard.edu/abs/2010PhDT.......196R/abstract) and [Rein and Papaloizou (2009)](https://ui.adsabs.harvard.edu/abs/2009A%26A...497..595R/abstract)
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <math.h>
+#include "rebound.h"
+#include "reboundx.h"
+
+void heartbeat(struct reb_simulation* r);
+
+double tmax = 1e4*M_PI*2.0; // 1e4 orbits
+
+int main(int argc, char* argv[]){
+    // Let's first setup the simulation.
+    // Note that we are using the WHFast integrator with a fixed timestep. 
+    // It's important to point out that the IAS15 integrator is not well 
+    // suited for stochastic forces because it automatically reduces the 
+    // timestep if it doesn't achieve an accuracy near machine precision. 
+    // Because the stochastic forces are random, it might never converge.
+
+    struct reb_simulation* sim = reb_create_simulation();
+    sim->integrator     = REB_INTEGRATOR_WHFAST;
+    sim->dt             = 1e-2;          // At ~100 AU, orbital periods are ~1000 yrs, so here we use ~1% of that, in sec
+    sim->heartbeat      = heartbeat;
+    
+    reb_add_fmt(sim, "m", 1.); // Sun 
+    reb_add_fmt(sim, "m a", 1e-3, 1.0); // Jupiter mass planet at 1AU
+    reb_move_to_com(sim);
+
+    // Next, we add the `stochastic_forces` module in REBOUNDx
+    struct rebx_extras* rebx = rebx_attach(sim);
+    struct rebx_force* sto = rebx_load_force(rebx, "stochastic_forces");
+    rebx_add_force(rebx, sto);
+
+    // We can now turn on stochastic forces for a particle by setting 
+    // the field `kappa` to a finite value. This parameter determines 
+    // the strength of the stochastic forces and is relative to the 
+    // gravitational force that the particle experiences from the 
+    // center of mass interior to its orbit. 
+    rebx_set_param_double(rebx, &sim->particles[1].ap, "kappa", 1e-5);
+
+    // The auto-correlation time of the stochastic forces is by default
+    // the orbital period. We can set it to a fraction or multiple of
+    // the orbital period by chanhging the `tau_kappa` parameter.
+
+    // rebx_set_param_double(rebx, &sim->particles[1].ap, "tau_kappa", 1.); // Not needed. Already the default.
+
+
+    // Let's integrate the system.
+    reb_integrate(sim, tmax);
+
+    rebx_free(rebx);                                
+    reb_free_simulation(sim);
+}
+
+void heartbeat(struct reb_simulation* sim){
+    // Periodically output the semi-major axis of the planet.
+    if(reb_output_check(sim, 1.e2*M_PI*2.0)){
+        reb_output_timing(sim, tmax);
+        FILE* f = fopen("orbit.txt", "a+");
+        struct reb_orbit o =  reb_tools_particle_to_orbit(sim->G, sim->particles[1], sim->particles[0]);
+        fprintf(f, "%.8e\t%.8e\n", sim->t, o.a);
+        fclose(f);
+    }
+}
diff --git a/ipython_examples/StochasticForces.ipynb b/ipython_examples/StochasticForces.ipynb
new file mode 100644
index 00000000..83865ed7
--- /dev/null
+++ b/ipython_examples/StochasticForces.ipynb
@@ -0,0 +1,276 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Adding stochastic forces\n",
+    "\n",
+    "In this example, we add a stochastic force to a planet. This can be used simulate migration in a turbulent disk. See e.g. [Rein (2012)](https://ui.adsabs.harvard.edu/abs/2012MNRAS.427L..21R/abstract) and [Rein and Papaloizou (2009)](https://ui.adsabs.harvard.edu/abs/2009A%26A...497..595R/abstract). First, let's setup a REBOUND Simulation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import rebound\n",
+    "sim = rebound.Simulation()\n",
+    "sim.add(m=1.) # Star\n",
+    "sim.add(m=1e-3, a=1) # Jupiter mass planet\n",
+    "sim.move_to_com() "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will be using the WHFast integrator with a fixed timestep. It's important to point out that the default IAS15 integrator is not well suited for stochastic forces because it automatically reduces the timestep if it doesn't achieve an accuracy near machine precision. Because the stochastic forces are noisy by design, it might never converge or reduce the timestep to a very small value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.integrator = \"whfast\"\n",
+    "sim.dt = sim.particles[1].P/34.5678 # About 30 steps per orbit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we add the `stochastic_forces` module in REBOUNDx"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import reboundx\n",
+    "rebx = reboundx.Extras(sim)\n",
+    "sto = rebx.load_force(\"stochastic_forces\")\n",
+    "rebx.add_force(sto)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now turn on stochastic forces for a particle by setting the particle's $\\kappa$ (`kappa`) field to a finite value. This parameter determines the strength of the stochastic forces and is expressed relative to the gravitational force that the particle experiences from the centeral object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.particles[1].params[\"kappa\"] = 1.0e-5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can also specify the auto-correlation time of the stochastic forces in units of the current orbital period. The default of $\\tau_\\kappa$ is 1, so we don't really needs this line:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.particles[1].params[\"tau_kappa\"] = 1.0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now run the simulation for 10000 orbits."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "times = np.linspace(0.,1e4*np.pi*2., 1000)\n",
+    "semia = np.zeros(len(times))\n",
+    "for i, t in enumerate(times):\n",
+    "    sim.integrate(t)\n",
+    "    semia[i] = sim.particles[1].a"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's plot the random walk of the semi-major axis."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "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": [
+    "import matplotlib.pyplot as plt\n",
+    "fig, ax = plt.subplots(1,1)\n",
+    "ax.set_xlabel(\"time [orbits]\")\n",
+    "ax.set_ylabel(\"semi-major axis\")\n",
+    "ax.plot(times/np.pi/2., semia);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let us run a few more simulations with different diffusion parameters and verify that the planet is indeed undergoing a random walk where the semi-major axes grow as $\\Delta a \\sim \\sqrt{t}$. [Rein and Papaloizou (2009)](https://ui.adsabs.harvard.edu/abs/2009A%26A...497..595R/abstract) provide equations for all orbital elements in single planet systems as well as for libration ampltidues in two-planet systems. In our case, we are interested in the change of semi-major axis which is given by (see their Eq 46):\n",
+    "$$ \\left( \\Delta A\\right)^2 = 4 \\frac{D\\,t}{n^2} $$\n",
+    "where $n$ is the mean motion of the planet and $D$ is the diffusion coefficient, given by:\n",
+    "$$ D = 2 \\langle F^2 \\rangle \\tau_\\kappa $$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def runsim(kappa):\n",
+    "    sim = rebound.Simulation()\n",
+    "    sim.add(m=1.) # Star\n",
+    "    sim.add(m=1e-3, a=1) # Jupiter mass planet\n",
+    "    sim.move_to_com() \n",
+    "\n",
+    "    sim.integrator = \"whfast\"\n",
+    "    sim.dt = sim.particles[1].P/30.3\n",
+    "    \n",
+    "    rebx = reboundx.Extras(sim)\n",
+    "    sto = rebx.load_force(\"stochastic_forces\")\n",
+    "    rebx.add_force(sto)\n",
+    "    \n",
+    "    sim.particles[1].params[\"kappa\"] = kappa\n",
+    "    \n",
+    "    times = np.pi*2.*np.logspace(0.,5, 1000)\n",
+    "    semia = np.zeros(len(times))\n",
+    "    for i, t in enumerate(times):\n",
+    "        sim.integrate(t)\n",
+    "        semia[i] = sim.particles[1].a\n",
+    "    return times, semia"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "kappas = [1e-5, 1e-6, 1e-7]\n",
+    "results = np.zeros((len(kappas),1000))\n",
+    "for i, kappa in enumerate(kappas):\n",
+    "    times, results[i] = runsim(kappa)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following plot compares the analytic predictions (dashed lines) to the numerical simulations (solid lines). Because this is a stochastic process, we can only expect that the analytic predictions hold in the average sense. This is indeed the case:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1,1, figsize=(10,5))\n",
+    "ax.set_xscale(\"log\")\n",
+    "ax.set_yscale(\"log\")\n",
+    "ax.set_xlabel(\"time [orbits]\")\n",
+    "ax.set_ylim([1e-6,1e-1])\n",
+    "ax.set_ylabel(\"relative change in semi-major axis\")\n",
+    "for i, kappa in enumerate(kappas):\n",
+    "    p = ax.plot(times/np.pi/2., np.abs(1.-results[i]), label=\"$\\kappa = 10^{%.0f}$\"%np.log10(kappa))\n",
+    "    tau = sim.particles[1].P\n",
+    "    D = 2.*kappa**2*tau\n",
+    "    ax.plot(times/np.pi/2., np.sqrt(4.*D/sim.particles[1].n**2*times), color=p[0].get_color(), ls=\"--\") \n",
+    "ax.legend();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `stochastic_forces` module uses the internal pseudo random number generator of REBOUND. This means that by default, each simulation starts with a random seed. If you want to generate reproducible results, you can manually set the seed to the same value every time you run the simulation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.rand_seed = 123"
+   ]
+  }
+ ],
+ "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": 1
+}
diff --git a/ipython_examples/StochasticForcesCartesian.ipynb b/ipython_examples/StochasticForcesCartesian.ipynb
new file mode 100644
index 00000000..bcfe495a
--- /dev/null
+++ b/ipython_examples/StochasticForcesCartesian.ipynb
@@ -0,0 +1,241 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Adding stochastic forces in cartesian coordinates\n",
+    "\n",
+    "In this example, we add a stochastic force in the x and y direction to a free floating particle."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import rebound\n",
+    "sim = rebound.Simulation()\n",
+    "sim.add(m=1.) # free floating particle"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will be using the Leap-Frog integrator with a fixed timestep. It's important to point out that the default IAS15 integrator is not well suited for stochastic forces because it automatically reduces the timestep if it doesn't achieve an accuracy near machine precision. Because the stochastic forces are noisy by design, it might never converge or reduce the timestep to a very small value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.integrator = \"leapfrog\"\n",
+    "sim.dt = 0.01"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we add the `stochastic_forces` module in REBOUNDx"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import reboundx\n",
+    "rebx = reboundx.Extras(sim)\n",
+    "sto = rebx.load_force(\"stochastic_forces\")\n",
+    "rebx.add_force(sto)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now turn on stochastic forces in the $x$ and $y$ direction for a particle. We do this by setting the particle's $\\kappa_x$ (`kappa_x`) and $\\kappa_y$ (`kappa_y`) fields to a finite value. These parameter determine the standard deviation of the stochastic forces in the given direction. The strengths can be different in the different directions, as shown in this example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.particles[0].params[\"kappa_x\"] = 5.0\n",
+    "sim.particles[0].params[\"kappa_y\"] = 1.0 "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We also need to specify the auto-correlation time of the stochastic forces. Note that the timestep needs to be smaller than the correlation time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.particles[0].params[\"tau_kappa_x\"] = 10.0\n",
+    "sim.particles[0].params[\"tau_kappa_y\"] = 1.0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can now run the simulation for some 100 time units and record the particle's position, velocity, and stochastic forces."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "times = np.linspace(0.,100, 1000)\n",
+    "xys = np.zeros((len(times),2))\n",
+    "vxvys = np.zeros((len(times),2))\n",
+    "forces = np.zeros((len(times),2))\n",
+    "for i, t in enumerate(times):\n",
+    "    sim.integrate(t)\n",
+    "    xys[i] = [sim.particles[0].x, sim.particles[0].y]\n",
+    "    vxvys[i] = [sim.particles[0].vx, sim.particles[0].vy]\n",
+    "    try:\n",
+    "        forces[i] = [sim.particles[0].params[\"stochastic_force_x\"], sim.particles[0].params[\"stochastic_force_y\"]]\n",
+    "    except:\n",
+    "        pass # not set before first timestep"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's plot the positions and velocities as a function of time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "fig, ax = plt.subplots(2,1, sharex=True)\n",
+    "#ax.set_aspect(\"equal\")\n",
+    "ax[0].set_ylabel(\"position\")\n",
+    "ax[0].plot(times, xys[:,0],label=\"x\")\n",
+    "ax[0].plot(times, xys[:,1],label=\"y\")\n",
+    "ax[1].set_xlabel(\"time\")\n",
+    "ax[1].set_ylabel(\"velocity\")\n",
+    "ax[1].plot(times, vxvys[:,0])\n",
+    "ax[1].plot(times, vxvys[:,1])\n",
+    "ax[0].legend();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can see that the velocities undergo an random walk, whereas the positions undergo an integrated random walk. With the parameters that we have chosen, the diffusion coefficient (see e.g. [Rein and Papaloizou 2009](https://ui.adsabs.harvard.edu/abs/2009A%26A...497..595R/abstract)) in the $x$ direction is larger than in the $y$ direction, resulting in a faster random walk in the $x$ direction."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also plot the stochastic forces that have been applied to the particle. Notice the differences in both amplitude and correlation time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "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\")\n",
+    "ax.set_ylabel(\"force\")\n",
+    "p=ax.plot(times, forces[:,0], label=\"$F_x$\")\n",
+    "ax.hlines(np.std(forces[:,0]), xmin=times[0], xmax=times[-1],zorder=4, color=p[0].get_color(), ls=\"--\", label=\"$\\sigma_{F,x}$\")\n",
+    "p=ax.plot(times, forces[:,1], label=\"$F_y$\")\n",
+    "ax.hlines(np.std(forces[:,1]), xmin=times[0], xmax=times[-1],zorder=4, color=p[0].get_color(), ls=\"--\", label=\"$\\sigma_{F,y}$\")\n",
+    "ax.legend();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `stochastic_forces` module uses the internal pseudo random number generator of REBOUND. This means that by default, each simulation starts with a random seed. If you want to generate reproducible results, you can manually set the seed to the same value every time you run the simulation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.rand_seed = 123"
+   ]
+  }
+ ],
+ "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": 1
+}
diff --git a/reboundx/params.py b/reboundx/params.py
index f3616fb6..d6690551 100644
--- a/reboundx/params.py
+++ b/reboundx/params.py
@@ -1,5 +1,9 @@
 import rebound
-from collections import MutableMapping
+import sys
+if sys.version_info[:2] >= (3, 8):
+    from collections.abc import MutableMapping
+else:
+    from collections import MutableMapping
 from .extras import Param, Node, Force, Operator, Extras, REBX_CTYPES
 from . import clibreboundx
 from ctypes import byref, c_double, c_int, c_int32, c_int64, c_uint, c_uint32, c_longlong, c_char_p, POINTER, cast
diff --git a/setup.py b/setup.py
index 406a1bcd..0bd4e5e5 100644
--- a/setup.py
+++ b/setup.py
@@ -43,7 +43,7 @@ def finalize_options(self):
         # get site-packages dir to add to paths in case reb & rebx installed simul in tmp dir
         rebdirsp = get_python_lib()+'/'#[p for p in sys.path if p.endswith('site-packages')][0]+'/'
         self.include_dirs.append(rebdir)
-        sources = [ 'src/inner_disk_edge.c', 'src/modify_orbits_forces.c', 'src/gr_potential.c', 'src/integrator_implicit_midpoint.c', 'src/radiation_forces.c', 'src/central_force.c', 'src/linkedlist.c', 'src/modify_mass.c', 'src/gr.c', 'src/core.c', 'src/exponential_migration.c', 'src/integrator_rk4.c', 'src/integrator_rk2.c', 'src/rebxtools.c', 'src/gr_full.c', 'src/integrator_euler.c', 'src/output.c', 'src/tides_constant_time_lag.c', 'src/input.c', 'src/steppers.c', 'src/track_min_distance.c', 'src/type_I_migration.c', 'src/integrate_force.c', 'src/interpolation.c', 'src/gravitational_harmonics.c', 'src/modify_orbits_direct.c'],
+        sources = [ 'src/inner_disk_edge.c', 'src/modify_orbits_forces.c', 'src/gr_potential.c', 'src/integrator_implicit_midpoint.c', 'src/stochastic_forces.c', 'src/radiation_forces.c', 'src/central_force.c', 'src/linkedlist.c', 'src/modify_mass.c', 'src/gr.c', 'src/core.c', 'src/exponential_migration.c', 'src/integrator_rk4.c', 'src/integrator_rk2.c', 'src/rebxtools.c', 'src/gr_full.c', 'src/integrator_euler.c', 'src/output.c', 'src/tides_constant_time_lag.c', 'src/input.c', 'src/steppers.c', 'src/track_min_distance.c', 'src/type_I_migration.c', 'src/integrate_force.c', 'src/interpolation.c', 'src/gravitational_harmonics.c', 'src/modify_orbits_direct.c'],
         self.library_dirs.append(rebdir+'/../')
         self.library_dirs.append(rebdirsp)
         for ext in self.extensions:
@@ -62,7 +62,7 @@ def finalize_options(self):
     extra_link_args.append('-Wl,-install_name,@rpath/libreboundx'+suffix)
 
 libreboundxmodule = Extension('libreboundx',
-        sources = [ 'src/inner_disk_edge.c', 'src/modify_orbits_forces.c', 'src/gr_potential.c', 'src/integrator_implicit_midpoint.c', 'src/radiation_forces.c', 'src/central_force.c', 'src/linkedlist.c', 'src/modify_mass.c', 'src/gr.c', 'src/core.c', 'src/exponential_migration.c', 'src/integrator_rk4.c', 'src/integrator_rk2.c', 'src/rebxtools.c', 'src/gr_full.c', 'src/integrator_euler.c', 'src/output.c', 'src/tides_constant_time_lag.c', 'src/input.c', 'src/steppers.c', 'src/track_min_distance.c', 'src/type_I_migration.c', 'src/integrate_force.c', 'src/interpolation.c', 'src/gravitational_harmonics.c', 'src/modify_orbits_direct.c'],
+        sources = [ 'src/inner_disk_edge.c', 'src/modify_orbits_forces.c', 'src/gr_potential.c', 'src/integrator_implicit_midpoint.c', 'src/stochastic_forces.c', 'src/radiation_forces.c', 'src/central_force.c', 'src/linkedlist.c', 'src/modify_mass.c', 'src/gr.c', 'src/core.c', 'src/exponential_migration.c', 'src/integrator_rk4.c', 'src/integrator_rk2.c', 'src/rebxtools.c', 'src/gr_full.c', 'src/integrator_euler.c', 'src/output.c', 'src/tides_constant_time_lag.c', 'src/input.c', 'src/steppers.c', 'src/track_min_distance.c', 'src/type_I_migration.c', 'src/integrate_force.c', 'src/interpolation.c', 'src/gravitational_harmonics.c', 'src/modify_orbits_direct.c'],
                     include_dirs = ['src'],
                     library_dirs = [],
                     runtime_library_dirs = ["."],
diff --git a/src/Makefile b/src/Makefile
index 933357dd..26f32592 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -22,7 +22,7 @@ ifndef REBXGITHASH
 	PREDEF+= -DREBXGITHASH=$(REBXGITHASH)
 endif
 
-SOURCES=inner_disk_edge.c modify_orbits_forces.c gr_potential.c integrator_implicit_midpoint.c radiation_forces.c central_force.c linkedlist.c modify_mass.c gr.c core.c exponential_migration.c integrator_rk4.c integrator_rk2.c rebxtools.c gr_full.c integrator_euler.c output.c tides_constant_time_lag.c input.c steppers.c track_min_distance.c type_I_migration.c integrate_force.c interpolation.c gravitational_harmonics.c modify_orbits_direct.c 
+SOURCES=inner_disk_edge.c modify_orbits_forces.c gr_potential.c integrator_implicit_midpoint.c stochastic_forces.c radiation_forces.c central_force.c linkedlist.c modify_mass.c gr.c core.c exponential_migration.c integrator_rk4.c integrator_rk2.c rebxtools.c gr_full.c integrator_euler.c output.c tides_constant_time_lag.c input.c steppers.c track_min_distance.c type_I_migration.c integrate_force.c interpolation.c gravitational_harmonics.c modify_orbits_direct.c 
 OBJECTS=$(SOURCES:.c=.o)
 HEADERS=rebxtools.h reboundx.h linkedlist.h
 
diff --git a/src/core.c b/src/core.c
index 6767f709..4cc19614 100644
--- a/src/core.c
+++ b/src/core.c
@@ -72,6 +72,19 @@ void rebx_register_default_params(struct rebx_extras* rebx){
     rebx_register_param(rebx, "em_afin", REBX_TYPE_DOUBLE);
     rebx_register_param(rebx, "primary", REBX_TYPE_INT);
     rebx_register_param(rebx, "radiation_source", REBX_TYPE_INT);
+    rebx_register_param(rebx, "kappa", REBX_TYPE_DOUBLE);
+    rebx_register_param(rebx, "kappa_x", REBX_TYPE_DOUBLE);
+    rebx_register_param(rebx, "kappa_y", REBX_TYPE_DOUBLE);
+    rebx_register_param(rebx, "kappa_z", REBX_TYPE_DOUBLE);
+    rebx_register_param(rebx, "tau_kappa", REBX_TYPE_DOUBLE);
+    rebx_register_param(rebx, "tau_kappa_x", REBX_TYPE_DOUBLE);
+    rebx_register_param(rebx, "tau_kappa_y", REBX_TYPE_DOUBLE);
+    rebx_register_param(rebx, "tau_kappa_z", REBX_TYPE_DOUBLE);
+    rebx_register_param(rebx, "stochastic_force_r", REBX_TYPE_DOUBLE);
+    rebx_register_param(rebx, "stochastic_force_phi", REBX_TYPE_DOUBLE);
+    rebx_register_param(rebx, "stochastic_force_x", REBX_TYPE_DOUBLE);
+    rebx_register_param(rebx, "stochastic_force_y", REBX_TYPE_DOUBLE);
+    rebx_register_param(rebx, "stochastic_force_z", REBX_TYPE_DOUBLE);
     rebx_register_param(rebx, "beta", REBX_TYPE_DOUBLE);
     rebx_register_param(rebx, "tides_primary", REBX_TYPE_INT);
     rebx_register_param(rebx, "R_tides", REBX_TYPE_DOUBLE);
@@ -268,6 +281,10 @@ struct rebx_force* rebx_load_force(struct rebx_extras* const rebx, const char* n
         force->update_accelerations = rebx_radiation_forces;
         force->force_type = REBX_FORCE_VEL;
     }
+    else if (strcmp(name, "stochastic_forces") == 0){
+        force->update_accelerations = rebx_stochastic_forces;
+        force->force_type = REBX_FORCE_VEL;
+    }
     else if (strcmp(name, "tides_constant_time_lag") == 0){
         force->update_accelerations = rebx_tides_constant_time_lag;
         force->force_type = REBX_FORCE_VEL;
diff --git a/src/core.h b/src/core.h
index e98248b4..80497068 100644
--- a/src/core.h
+++ b/src/core.h
@@ -68,6 +68,7 @@ void rebx_gr(struct reb_simulation* const sim, struct rebx_force* const force, s
 void rebx_gr_full(struct reb_simulation* const sim, struct rebx_force* const force, struct reb_particle* const particles, const int N);
 void rebx_gr_potential(struct reb_simulation* const sim, struct rebx_force* const force, struct reb_particle* const particles, const int N);
 void rebx_radiation_forces(struct reb_simulation* const sim, struct rebx_force* const force, struct reb_particle* const particles, const int N);
+void rebx_stochastic_forces(struct reb_simulation* const sim, struct rebx_force* const force, struct reb_particle* const particles, const int N);
 void rebx_modify_orbits_forces(struct reb_simulation* const sim, struct rebx_force* const force, struct reb_particle* const particles, const int N);
 void rebx_exponential_migration(struct reb_simulation* const sim, struct rebx_force* const force, struct reb_particle* const particles, const int N);
 void rebx_tides_constant_time_lag(struct reb_simulation* const sim, struct rebx_force* const force, struct reb_particle* const particles, const int N);
diff --git a/src/stochastic_forces.c b/src/stochastic_forces.c
new file mode 100644
index 00000000..5a2b7e3a
--- /dev/null
+++ b/src/stochastic_forces.c
@@ -0,0 +1,251 @@
+/**
+ * @file    stochastic_forces.c
+ * @brief   Add stochastic forces
+ * @author  Hanno Rein <hanno@hanno-rein.de>
+ * 
+ * @section     LICENSE
+ * Copyright (c) 2022 Hanno Rein, Dan Tamayo
+ *
+ * This file is part of reboundx.
+ *
+ * reboundx 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.
+ *
+ * reboundx 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/>.
+ *
+ * The section after the dollar signs gets built into the documentation by a script.  All lines must start with space * space like below.
+ * Tables always must be preceded and followed by a blank line.  See http://docutils.sourceforge.net/docs/user/rst/quickstart.html for a primer on rst.
+ * $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
+ *
+ * $Stochastic Forces$     
+ *
+ * ======================= ===============================================
+ * Authors                 H. Rein
+ * Based on                `Rein and Papaloizou 2009 <https://ui.adsabs.harvard.edu/abs/2009A%26A...497..595R/abstract>`_.
+ * C Example               :ref:`c_example_stochastic_forces`
+ * Python Example          `StochasticForces.ipynb <https://github.com/dtamayo/reboundx/blob/master/ipython_examples/StochasticForces.ipynb>`_,
+ * ======================= ===============================================
+ * 
+ * This applies stochastic forces to particles in the simulation.  
+ * 
+ * **Effect Parameters**
+ * 
+ * None
+ *
+ * **Particle Parameters**
+ *
+ * All particles which have the field kappa set, will experience stochastic forces.
+ * The particle with index 0 cannot experience stochastic forces.
+ *
+ * ============================ =========== ==================================================================================
+ * Field (C type)               Required    Description
+ * ============================ =========== ==================================================================================
+ * kappa (double)               Yes         Strength of stochastic forces relative to gravity from central object 
+ * tau_kappa (double)           No          Auto-correlation time of stochastic forces. Defaults to orbital period if not set.
+ *                                          The units are relative to the current orbital period.
+ * ============================ =========== ==================================================================================
+ * 
+ */
+
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include "reboundx.h"
+
+
+static void rebx_random_normal2(struct reb_simulation* r, double* n0, double* n1){
+	double v1,v2,rsq=1.;
+	while(rsq>=1. || rsq<1.0e-12){
+		v1=2.*((double)rand_r(&(r->rand_seed)))/((double)(RAND_MAX))-1.0;
+		v2=2.*((double)rand_r(&(r->rand_seed)))/((double)(RAND_MAX))-1.0;
+		rsq=v1*v1+v2*v2;
+	}
+	*n0 = v1*sqrt(-2.*log(rsq)/rsq);
+	*n1 = v2*sqrt(-2.*log(rsq)/rsq);
+}
+
+
+void rebx_stochastic_forces(struct reb_simulation* const sim, struct rebx_force* const radiation_forces, struct reb_particle* const particles, const int N){
+    struct rebx_extras* const rebx = sim->extras;
+    struct reb_particle com = particles[0];
+    
+    for (int i=0; i<N; i++){
+        double* kappa = rebx_get_param(rebx, particles[i].ap, "kappa");
+        if (i>0 && kappa != NULL){
+            double* stochastic_force_r = rebx_get_param(rebx, particles[i].ap, "stochastic_force_r");
+            if (stochastic_force_r == NULL) { // First run?
+                rebx_set_param_double(rebx, (struct rebx_node**)&particles[i].ap, "stochastic_force_r", 0.);
+                stochastic_force_r = rebx_get_param(rebx, particles[i].ap, "stochastic_force_r");
+            }
+            double* stochastic_force_phi = rebx_get_param(rebx, particles[i].ap, "stochastic_force_phi");
+            if (stochastic_force_phi == NULL) { // First run?
+                rebx_set_param_double(rebx, (struct rebx_node**)&particles[i].ap, "stochastic_force_phi", 0.);
+                stochastic_force_phi = rebx_get_param(rebx, particles[i].ap, "stochastic_force_phi");
+            }
+
+            const struct reb_particle p = particles[i];
+
+            // Get auto-correlation time
+            int err=0;
+            struct reb_orbit o = reb_tools_particle_to_orbit_err(sim->G, particles[i], com, &err);
+            if (err){
+                reb_error(sim, "An error occured during the orbit calculation in rebx_stochastic_forces.\n");
+                return;
+            }
+            double tau = o.P; // Default is current orbital period.
+            
+            double* tau_kappa = rebx_get_param(rebx, particles[i].ap, "tau_kappa");
+            if (tau_kappa != NULL){
+                tau *= *tau_kappa;
+            }
+
+            double dt = sim->dt_last_done;
+            
+            double prefac = exp(-dt/tau);
+
+            // Decay
+            *stochastic_force_r = (*stochastic_force_r) * prefac;
+            *stochastic_force_phi = (*stochastic_force_phi) * prefac;
+
+            double variance = 1.- prefac*prefac;
+            if (variance <0.){
+                reb_error(sim, "Timestep is larger than the correlation time for stochastic forces.\n");
+                return;
+            }
+            double std = sqrt(variance);
+
+            double n0, n1;
+            rebx_random_normal2(sim, &n0, &n1);
+            
+            // Excitation
+            *stochastic_force_r = (*stochastic_force_r) + n0*std;
+            *stochastic_force_phi = (*stochastic_force_phi) + n1*std;
+
+            const double dx = p.x - com.x; 
+            const double dy = p.y - com.y;
+            const double dz = p.z - com.z;
+            const double dr = sqrt(dx*dx + dy*dy + dz*dz);
+            
+            const double dvx = p.vx - com.vx; 
+            const double dvy = p.vy - com.vy;
+            const double dvz = p.vz - com.vz;
+            const double dv = sqrt(dvx*dvx + dvy*dvy + dvz*dvz);
+
+            const double force_prefac = (*kappa) *sim->G/(dr*dr)*com.m;
+            particles[i].ax += force_prefac*(*stochastic_force_r*dx/dr + *stochastic_force_phi*dvx/dv);
+            particles[i].ay += force_prefac*(*stochastic_force_r*dy/dr + *stochastic_force_phi*dvy/dv);
+            particles[i].az += force_prefac*(*stochastic_force_r*dz/dr + *stochastic_force_phi*dvz/dv);
+
+
+		    com = reb_get_com_of_pair(com, p);
+        }
+        double* kappa_x = rebx_get_param(rebx, particles[i].ap, "kappa_x");
+        if (kappa_x != NULL){
+            double* stochastic_force_x = rebx_get_param(rebx, particles[i].ap, "stochastic_force_x");
+            if (stochastic_force_x == NULL) { // First run?
+                rebx_set_param_double(rebx, (struct rebx_node**)&particles[i].ap, "stochastic_force_x", 0.);
+                stochastic_force_x = rebx_get_param(rebx, particles[i].ap, "stochastic_force_x");
+            }
+            
+            double* tau_kappa_x = rebx_get_param(rebx, particles[i].ap, "tau_kappa_x");
+            if (tau_kappa_x == NULL){
+                reb_error(sim, "Need to set tau_kappa_x to enable stochastic forces.\n");
+                return;
+            }
+
+            double dt = sim->dt_last_done;
+            double prefac = exp(-dt/ (*tau_kappa_x));
+
+            // Decay
+            *stochastic_force_x = (*stochastic_force_x) * prefac;
+
+            // Excitation
+            double variance = 1.- prefac*prefac;
+            if (variance <0.){
+                reb_error(sim, "Timestep is larger than the correlation time for stochastic forces.\n");
+                return;
+            }
+            double std = (*kappa_x)*sqrt(variance);
+            double n0, n1;
+            rebx_random_normal2(sim, &n0, &n1);
+            *stochastic_force_x = (*stochastic_force_x) + n0*std;
+            
+            particles[i].ax += *stochastic_force_x;
+        }
+        double* kappa_y = rebx_get_param(rebx, particles[i].ap, "kappa_y");
+        if (kappa_y != NULL){
+            double* stochastic_force_y = rebx_get_param(rebx, particles[i].ap, "stochastic_force_y");
+            if (stochastic_force_y == NULL) { // First run?
+                rebx_set_param_double(rebx, (struct rebx_node**)&particles[i].ap, "stochastic_force_y", 0.);
+                stochastic_force_y = rebx_get_param(rebx, particles[i].ap, "stochastic_force_y");
+            }
+            
+            double* tau_kappa_y = rebx_get_param(rebx, particles[i].ap, "tau_kappa_y");
+            if (tau_kappa_y == NULL){
+                reb_error(sim, "Need to set tau_kappa_y to enable stochastic forces.\n");
+                return;
+            }
+
+            double dt = sim->dt_last_done;
+            double prefac = exp(-dt/ (*tau_kappa_y));
+
+            // Decay
+            *stochastic_force_y = (*stochastic_force_y) * prefac;
+
+            // Excitation
+            double variance = 1.- prefac*prefac;
+            if (variance <0.){
+                reb_error(sim, "Timestep is larger than the correlation time for stochastic forces.\n");
+                return;
+            }
+            double std = (*kappa_y)*sqrt(variance);
+            double n0, n1;
+            rebx_random_normal2(sim, &n0, &n1);
+            *stochastic_force_y = (*stochastic_force_y) + n0*std;
+            
+            particles[i].ay += *stochastic_force_y;
+        }
+        double* kappa_z = rebx_get_param(rebx, particles[i].ap, "kappa_z");
+        if (kappa_z != NULL){
+            double* stochastic_force_z = rebx_get_param(rebx, particles[i].ap, "stochastic_force_z");
+            if (stochastic_force_z == NULL) { // First run?
+                rebx_set_param_double(rebx, (struct rebx_node**)&particles[i].ap, "stochastic_force_z", 0.);
+                stochastic_force_z = rebx_get_param(rebx, particles[i].ap, "stochastic_force_z");
+            }
+            
+            double* tau_kappa_z = rebx_get_param(rebx, particles[i].ap, "tau_kappa_z");
+            if (tau_kappa_z == NULL){
+                reb_error(sim, "Need to set tau_kappa_z to enable stochastic forces.\n");
+                return;
+            }
+
+            double dt = sim->dt_last_done;
+            double prefac = exp(-dt/ (*tau_kappa_z));
+
+            // Decay
+            *stochastic_force_z = (*stochastic_force_z) * prefac;
+
+            // Excitation
+            double variance = 1.- prefac*prefac;
+            if (variance <0.){
+                reb_error(sim, "Timestep is larger than the correlation time for stochastic forces.\n");
+                return;
+            }
+            double std = (*kappa_z)*sqrt(variance);
+            double n0, n1;
+            rebx_random_normal2(sim, &n0, &n1);
+            *stochastic_force_z = (*stochastic_force_z) + n0*std;
+            
+            particles[i].az += *stochastic_force_z;
+        }
+    }
+}
+


Test patch:
diff --git a/reboundx/test/test_stochastic_forces.py b/reboundx/test/test_stochastic_forces.py
new file mode 100644
index 00000000..507172df
--- /dev/null
+++ b/reboundx/test/test_stochastic_forces.py
@@ -0,0 +1,68 @@
+import rebound
+import reboundx
+import unittest
+import os
+import numpy as np
+
+class TestStochastic(unittest.TestCase):
+    def test_default(self):
+        self.sim = rebound.Simulation()
+        self.sim.add(m=1., r=0.005)
+        self.sim.add(m=1.e-3, a=1.0, e=0.1)
+        self.sim.integrator = "whfast"
+        self.sim.rand_seed = 0
+        self.sim.dt = self.sim.particles[1].P/20.2
+        self.sim.move_to_com()
+        self.rebx = reboundx.Extras(self.sim)
+        self.force = self.rebx.load_force("stochastic_forces")
+        self.rebx.add_force(self.force)
+        ps = self.sim.particles
+        ps[1].params['kappa'] = 1e-5
+        self.sim.integrate(ps[1].P*1000)
+        self.assertLess(np.abs(1.-ps[1].a), 0.004)
+
+    def test_scaling(self):
+        self.sim = rebound.Simulation()
+        self.sim.add(m=1., r=0.005)
+        self.sim.add(m=1.e-3, a=0.001, e=0.1)
+        self.sim.integrator = "whfast"
+        self.sim.rand_seed = 0
+        self.sim.dt = self.sim.particles[1].P/20.2
+        self.sim.move_to_com()
+        self.rebx = reboundx.Extras(self.sim)
+        self.force = self.rebx.load_force("stochastic_forces")
+        self.rebx.add_force(self.force)
+        ps = self.sim.particles
+        ps[1].params['kappa'] = 1e-5
+        self.sim.integrate(ps[1].P*1000)
+        self.assertLess(np.abs(0.001-ps[1].a), 0.000004)
+
+    def test_binary(self):
+        self.sim = rebound.Simulation()
+        self.sim.add(m=1., r=0.005)
+        self.sim.add(m=1.e-3, a=1, e=0.1)
+        self.sim.integrator = "whfast"
+        self.sim.rand_seed = 0
+        self.sim.dt = self.sim.particles[1].P/20.2
+        self.sim.move_to_com()
+        self.rebx = reboundx.Extras(self.sim)
+        self.force = self.rebx.load_force("stochastic_forces")
+        self.rebx.add_force(self.force)
+        ps = self.sim.particles
+        ps[1].params['kappa'] = 1e-5
+        self.sim.integrate(ps[1].P*10)
+
+        self.sim.save("binary.bin")
+        self.rebx.save("binary.rebx")
+
+        self.sim.integrate(ps[1].P*20.5)
+
+        sim2 = rebound.Simulation("binary.bin")
+        rebx2 = reboundx.Extras(sim2, "binary.rebx")
+        
+        sim2.integrate(self.sim.t)
+        self.assertEqual(self.sim.particles[1].x, sim2.particles[1].x)
+        self.assertEqual(self.sim.particles[1].params["kappa"], sim2.particles[1].params["kappa"])
+
+if __name__ == '__main__':
+    unittest.main()