使用scipy.integrate将布朗运动纳入粒子轨迹积分

Question

I want to add thermal fluctuations on top of a simple linear particle interaction model. So far (without Brownian motion) everything was done using scipy.integrate.odeint and worked perfectly. Therefore it would be nice to find a way to include random motion by using one of the scipy.integrate metods. The problem is the following: Using a Langevin heat bath i would have to update the particle positions(x) and velocities(v) as follows:

x = x + v * dt

v = v + (interaction_force * dt + random_force * dt) /mass

where: random_force = sqrt(constant/ dt )*random_number

I think there are two problems:

1. The steps size dt comes up inside the random_force. But i don't know the current step size which changes during the run by adaptive step size control.

2. The step size control will get into trouble since as long as two different random_numbers are used for the comparison of the different step sizes there will be relative big difference. (I'm not sure if there are two different random_numbers used)

The only idea i have is to use a method with fixed step size. But i haven't found any jet. Any better ides how to solve this problem?

Answer 1

If you have access to the absolute time inside the model, you can use a pseudo-random number generator that generates a unique random number for a given time.

Such a time-dependent pseudo-random number generator can operate independent of the step size and generates the same value whenever a time-point is visited repeatedly.

If you do not have access to the absolute time, you may be able to simply integrate 1*dt to get the time.

Here is a very crude implementation of such a time-dependent random number generator:

import numpy as np
import matplotlib.pyplot as plt    
import struct

# create a gaussian "random number" that is deterministic in the time parameter
def t_rand(time):
    tmp = struct.pack('f', time)
    int_time = struct.unpack('i', tmp)
    np.random.seed(int_time)
    return np.random.randn()

# demonstrate the behavior of t_rand

t1 = np.linspace(0, 1, 21)
t2 = np.linspace(0, 1, 41)

plt.subplot(2, 1, 1)
plt.plot(t1, [t_rand(t) for t in t1])
plt.plot(t2, [t_rand(t) for t in t2])

plt.subplot(2, 1, 2)
plt.hist([t_rand(t) for t in np.linspace(0, 10, 10000)], 30)

It may not be wise to manipulate the global random seed for this purpose, but if the problem is isolated enough it will work.

The image above shows that for two sequences with different time steps the same value is generated for the same time point. The figure below shows the histogram of the random values, which indicates that at least the shape of the distribution seems untouched by this crude manipulation of the random seed.

I don't know if my approach actually works inside an integrator. Problem 2 may still be an issue, but I think problem 1 is adequately addressed. This may not solve the problem entirely, but it may get you started. A more professional solution could be to use a stochastich differential equation solver, such as PyS³DE .

Answer 2

The kind of methods used in something like odeint are not appropriate for SDEs. Resizable timestep methods don't really work with Brownian motion because the solution doesn't converge to something smooth as the timestep gets smaller.

You're better off just using the Euler Maruyama method . This method is sufficiently simple that you can write the integration routine yourself.

There are more advanced methods: the next most well-known is the Milstein method which can be more accurate for multiplicative SDEs but is equivalent for additive SDEs (such as yours). In general the gain from using more complex methods is not as big for SDEs as for ODEs so I would say just use EM.