Question

import pygame
import random
import numpy as np
import matplotlib.pyplot as plt
import math

number_of_particles = 70
my_particles = []
background_colour = (255,255,255)
width, height = 500, 500
sigma = 1
e = 1
dt = 0.1
v = 0
a = 0
r = 1

def r(p1,p2):
    dx = p1.x - p2.x
    dy = p1.y - p2.y
    angle = 0.5 * math.pi - math.atan2(dy, dx)
    dist = np.hypot(dx, dy)
    return dist

def collide(p1, p2):
    dx = p1.x - p2.x
    dy = p1.y - p2.y

    dist = np.hypot(dx, dy)
    if dist < (p1.size + p2.size):
        tangent = math.atan2(dy, dx)
        angle = 0.5 * np.pi + tangent

        angle1 = 2*tangent - p1.angle
        angle2 = 2*tangent - p2.angle
        speed1 = p2.speed
        speed2 = p1.speed
        (p1.angle, p1.speed) = (angle1, speed1)
        (p2.angle, p2.speed) = (angle2, speed2)

        overlap = 0.5*(p1.size + p2.size - dist+1)
        p1.x += np.sin(angle) * overlap
        p1.y -= np.cos(angle) * overlap
        p2.x -= np.sin(angle) * overlap
        p2.y += np.cos(angle) * overlap
def LJ(r):
    return -24*e*((2/r*(sigma/r)**12)-1/r*(sigma/r)**6)

def verlet():
    a1 = -LJ(r(p1,p2))
    r = r + dt*v+0.5*dt**2*a1
    a2 = -LJ(r(p1,p2))
    v = v + 0.5*dt*(a1+a2)
    return r, v
class Particle():
    def __init__(self, (x, y), size):
        self.x = x
        self.y = y
        self.size = size
        self.colour = (0, 0, 255)
        self.thickness = 1
        self.speed = 0
        self.angle = 0

    def display(self):
        pygame.draw.circle(screen, self.colour, (int(self.x), int(self.y)), self.size, self.thickness)

    def move(self):
        self.x += np.sin(self.angle) 
        self.y -= np.cos(self.angle) 

    def bounce(self):
        if self.x > width - self.size:
            self.x = 2*(width - self.size) - self.x
            self.angle = - self.angle

        elif self.x < self.size:
            self.x = 2*self.size - self.x
            self.angle = - self.angle

        if self.y > height - self.size:
            self.y = 2*(height - self.size) - self.y
            self.angle = np.pi - self.angle

        elif self.y < self.size:
            self.y = 2*self.size - self.y
            self.angle = np.pi - self.angle             

screen = pygame.display.set_mode((width, height))

for n in range(number_of_particles):
    x = random.randint(15, width-15)
    y = random.randint(15, height-15)

    particle = Particle((x, y), 15)
    particle.speed = random.random()
    particle.angle = random.uniform(0, np.pi*2)

    my_particles.append(particle)

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
    screen.fill(background_colour)

    for i, particle in enumerate(my_particles):
        particle.move()
        particle.bounce()
        for particle2 in my_particles[i+1:]:
            collide(particle, particle2)
        particle.display()

    pygame.display.flip()
pygame.quit()

我想通过Lennard-Jones潜力来模拟粒子。我的代码问题是我不知道如何使用Verlet算法。

我不知道应该在哪里实现Verlet算法;在课堂内或外面？
如何在move方法中使用Verlet算法的速度？
我的Verlet算法实现是否正确，还是应该使用数组来保存结果？
我还应该改变什么以使其有效？

Answer 1

您可以将动态变量，位置和速度保持在类实例中，但是每个类都需要一个加速度向量来累积力贡献。 Verlet集成商具有控制器的作用，它从外部作用于所有粒子的集合。将角度保持在计算之外，使用三角函数保持四边形和背面，并且不需要它们的反转。使所有2D矢量的位置，速度和加速度。

实现 velocity Verlet变体的一种方法是（参见https://stackoverflow.com/tags/verlet-integration/info）

verlet_step:
    v += a*0.5*dt;
    x += v*dt; t += dt;
    do_collisions(t,x,v,dt);
    a = eval_a(x);
    v += a*0.5*dt;
    do_statistics(t,x,v);

假设一个矢量化变体。在您的框架中，将对粒子集合进行一些迭代以包含，

verlet_step:
    for p in particles:
        p.v += p.a*0.5*dt; p.x += p.v*dt; 
    t += dt;
    for i, p1 in enumerate(particles):
        for p2 in particles[i+1:]:
            collide(p1,p2);
    for i, p1 in enumerate(particles):
        for p2 in particles[i+1:]:
            apply_LJ_forces(p1,p2);
    for p in particles:
        p.v += p.a*0.5*dt;
    do_statistics(t,x,v);

不，你没有做错任何事，因为你实际上没有调用Verlet函数来更新位置和速度。不，不需要严格的矢量化，见上文。通过particles数组的隐式向量化就足够了。如果你想用scipy.integrate中的标准积分器的结果进行比较，你只需要一个完整的矢量化，使用相同的模型来提供ODE函数。

Lennard-Jones潜在的模拟

1 个答案: