重力和许多粒子

Question

我在太空中有很多粒子。

每个粒子都知道它在空间中的位置以及质量、速度和加速度等信息。

public class Particle
{
    float mass;
    float velocity;
    float acceleration;
}

我有一个控制重力的类。这个类有一个List，是所有Particles。我可以使用下面的公式计算两个粒子的重力。

F1 = F2 = G*M1*M2/d^2

当我的 List 中有 5 个粒子时，我该如何计算？未来还会有更多。

元素 0 与 1，元素 1 与 2，元素 2 与 3，元素 3 与 4，以及元素 4 与 0？ （这似乎不是一个好主意）。

Answer 1

实际上，万有引力定律仅适用于 2 个物体。这与地球和物体在太空或表面上的一般研究一样。

https://en.wikipedia.org/wiki/Newton's_law_of_universal_gravitation

如果你有 5 个质量，你可以做的是让一个质量静止或相对。这将是M1 然后测试与它相关的所有质量，找到每个质量。也许在这里你也需要某种foreach 循环。

在太空中处理 5 个物体，即使是牛顿先生也很难，这就是为什么他给了你一个 2 个物体的方程。与是相互关联的。您可以使用这 2 个物体，并检查每个物体的重力。将它们相互关联，因为最初它们是不相关的。

Answer 2

在模拟的每个时间步，计算每个粒子上的总矢量力，并以等于总力除以粒子质量的加速度移动该粒子。

要找到每个粒子上的总力，请计算一个粒子与其他每个粒子之间的引力，然后将它们加起来。请注意，当您计算每个力时，它必须是矢量力，即具有等式中大小的力，以及朝向另一个粒子的方向。 （即使用这个版本的牛顿万有引力定律：http://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation#Vector_form）

除了力之外，这里的一切都应该使用向量来完成：位置、速度、加速度和力，都作为向量。正如您所描述的问题，质量是您唯一的标量。 （也就是说，在您的Particle 类中，质量可以是浮点数，但速度和加速度需要是向量，具有 x、y 和 z 分量。）

Answer 3

这应该是一个很好的起点：

namespace SO.NBody
{
    public class Particle
    {
        public double mass;
        public double[] position;
        public double[] velocity;
        public double[] acceleration;

        public Particle(double mass)
        {
            this.mass=mass;
            this.position=new double[Simulation.DOF];
            this.velocity=new double[Simulation.DOF];
            this.acceleration=new double[Simulation.DOF];
        }
    }

    public class Simulation
    {
        // Degrees of Freedom, Planar Simulation = 2, Spatial Simulation = 3
        public static int DOF=2;
        // Set Universal Gravity as Needed here
        public const double G=100;

        public Simulation()
        {
            Bodies=new List<Particle>();
            Time=0;
        }
        public List<Particle> Bodies { get; private set; }
        public double Time { get; set; }

        public void CalculateAllAccelerations()
        {
            for (int i=0; i<Bodies.Count; i++)
            {
                Bodies[i].acceleration=new double[DOF];
                for (int j=0; j<i; j++)
                {
                    // Find relative position, which is needed for
                    //   a) Distance
                    //   b) Direction
                    double[] step=new double[DOF];
                    double distance=0;
                    for (int k=0; k<DOF; k++)
                    {
                        step[k]=Bodies[i].position[k]-Bodies[j].position[k];
                        // distance is |x^2+y^2+..|
                        distance+=step[k]*step[k];
                    }
                    distance=Math.Sqrt(distance);
                    // Law of gravity
                    double force=G*Bodies[i].mass*Bodies[j].mass/(distance*distance);
                    // direction vector from [j] to [i]
                    double[] direction=new double[DOF];
                    for (int k=0; k<DOF; k++)
                    {
                        direction[k]=step[k]/distance;
                    }
                    // Add equal and opposite acceleration components
                    for (int k=0; k<DOF; k++)
                    {
                        Bodies[i].acceleration[k]-=direction[k]*(force/Bodies[i].mass);
                        Bodies[j].acceleration[k]+=direction[k]*(force/Bodies[j].mass);
                    }
                }
            }

        }

        public void UpdatePositions(double time_step)
        {
            CalculateAllAccelerations();
            // Use symplectic integration
            for (int i=0; i<Bodies.Count; i++)
            {
                for (int k=0; k<DOF; k++)
                {
                    Bodies[i].velocity[k]+=time_step*Bodies[i].acceleration[k];
                    Bodies[i].position[k]+=time_step*Bodies[i].velocity[k];
                }
            }
            Time+=time_step;
        }

        public void RunSimulation(double end_time, int steps)
        {
            double h=(end_time-Time)/steps;
            while (Time<end_time)
            {
                // Trim last step if needed so the sim ends when specified
                if (Time+h>end_time) { h=end_time-Time; }
                UpdatePositions(h);
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var world=new Simulation();
            var sun=new Particle(1000);
            var p1=new Particle(1.15)
            {
                position=new double[] { 100, 0 },
                velocity = new double[] { 0, 10 }
            };
            var p2=new Particle(1.05)
            {
                position=new double[] { 120, 0 },
                velocity=new double[] { 0, 6 }
            };
            // ...

            world.Bodies.Add(sun);
            world.Bodies.Add(p1);
            world.Bodies.Add(p2);
            //...

            // Run for t=10.0, with 100 steps
            world.RunSimulation(10.0, 100);
        }
    }
}