Skip to content
TheChatArchiveThe Chat Archive
Coherecommand-a-03-2025· CohereHugging Face LMArena Human Preference 140K

write a particle simulation code in python

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Qwenqwen3-235b-a22b-no-thinking’s answer.
  1. User

    write a particle simulation code in python

  2. Cohere Assistant

    Below is a simple Python code for a 2D particle simulation using the NumPy library for numerical computations and Matplotlib for visualization. This simulation models particles moving under the influence of a force (e.g., gravity) and colliding elastically with each other and the boundaries of the simulation area.

    import numpy as np
    import matplotlib.pyplot as plt
    import matplotlib.animation as animation
    
    # Simulation parameters
    num_particles = 10
    radius = 0.02
    mass = 1.0
    dt = 0.01  # Time step
    width, height = 1.0, 1.0  # Simulation area dimensions
    gravity = np.array([0.0, -0.1])  # Gravity vector
    
    # Initialize particle positions, velocities, and accelerations
    np.random.seed(42)
    positions = np.random.rand(num_particles, 2) * np.array([width, height])
    velocities = np.random.rand(num_particles, 2) * 0.1 - 0.05
    accelerations = np.zeros((num_particles, 2))
    
    def update_positions(positions, velocities, accelerations, dt):
        """Update positions using Euler integration."""
        positions += velocities * dt + 0.5 * accelerations * dt**2
    
    def update_velocities(velocities, accelerations, dt):
        """Update velocities."""
        velocities += accelerations * dt
    
    def apply_forces(accelerations, mass, gravity):
        """Apply forces to particles."""
        accelerations[:] = gravity / mass
    
    def handle_collisions(positions, velocities, radius, width, height):
        """Handle particle collisions with walls and each other."""
        for i in range(num_particles):
            # Collision with walls
            for j in range(2):
                if positions[i][j] < radius:
                    positions[i][j] = radius
                    velocities[i][j] = -velocities[i][j] * 0.9  # Elastic collision
                elif positions[i][j] > (width if j == 0 else height) - radius:
                    positions[i][j] = (width if j == 0 else height) - radius
                    velocities[i][j] = -velocities[i][j] * 0.9  # Elastic collision
    
            # Particle-particle collisions
            for k in range(i + 1, num_particles):
                delta = positions[i] - positions[k]
                dist = np.linalg.norm(delta)
                if dist < 2 * radius:
                    # Move particles apart
                    delta /= dist
                    positions[i] += delta * (2 * radius - dist) / 2
                    positions[k] -= delta * (2 * radius - dist) / 2
    
                    # Update velocities for collision response
                    normal = delta / dist
                    relative_velocity = velocities[i] - velocities[k]
                    speed = np.dot(relative_velocity, normal)
                    if speed < 0:
                        impulse = (2 * mass * speed) / (2 * mass)
                        velocities[i] -= impulse * normal
                        velocities[k] += impulse * normal
    
    def animate(i):
        """Animation function for Matplotlib."""
        global positions, velocities, accelerations
    
        apply_forces(accelerations, mass, gravity)
        update_velocities(velocities, accelerations, dt)
        update_positions(positions, velocities, accelerations, dt)
        handle_collisions(positions, velocities, radius, width, height)
    
        scatter.set_offsets(positions)
        return scatter,
    
    # Set up the animation
    fig, ax = plt.subplots()
    scatter = ax.scatter(positions[:, 0], positions[:, 1], s=100)
    ax.set_xlim(0, width)
    ax.set_ylim(0, height)
    ax.set_aspect('equal')
    
    ani = animation.FuncAnimation(fig, animate, frames=1000, interval=20, blit=True)
    plt.show()
    

    Explanation:

    1. Initialization: Particles are initialized with random positions and velocities within the simulation area.
    2. Forces: Gravity is applied to all particles.
    3. Integration: Positions and velocities are updated using Euler integration.
    4. Collisions: Particles bounce off the walls and each other elastically.
    5. Animation: Matplotlib's animation module is used to visualize the simulation.

    To run this code, ensure you have numpy and matplotlib installed:

    pip install numpy matplotlib
    

    This is a basic simulation and can be extended with more complex physics, interactions, or visualization features.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.