C++ 开普勒和牛顿定律-6ren

C++ 开普勒和牛顿定律

转载作者：行者123 更新时间：2023-11-28 06:19:04

所以我有两个文件。一个主文件和一个 nbody 文件。

我想做的是使用 SFML 绘制到窗口上并基本上模拟银河轨道。我一直遇到的该死的问题是，虽然从语法的角度来看一切正常，但所有的行星都在超出比例并且完全不稳定。

我不明白为什么它不起作用。请帮我解决这个问题..

这是 nbody 文件。

 #include SFML/Graphics.hpp
 #include SFML/Window.hpp
 #include iostream
 #include cmath
 #include cstring
 class Body:sf::Drawable{
  sf::String file;
  sf::Texture texture;

public:
  double x,y;
  double xvel,yvel,mass,scale,winsize;
  sf::Sprite sprite;
  Body(double _x,double _y,double _xvel, double _yvel, double           _mass,std::string _file,double _scale,double _winsize){
    x = _x;
    y = _y;
    xvel = _xvel;
    yvel = _yvel;
    mass = _mass;
    file = _file;
    scale = _scale;

  }
  sf::Sprite Sprite(){
    texture.loadFromFile(file);
    sprite.setTexture(texture);
    sprite.setPosition(x,y);
    return sprite;
  }

  void move(double position, std::vector<Body> galaxy, double time){
    double G = 6.67 * pow(10,-11);
    double Fx=0, Fy=0;

for(double i=0;i<galaxy.size();i++){
  if(position!=i){      
double x1 = x;
double x2 = (galaxy.at(i)).x;
double dx = (x2-x1)*scale;  ////The math here works

double y1 = y;
double y2 = (galaxy.at(i)).y;
double dy = (y2-y1)*scale; /// The math here works

double m2 = (galaxy.at(i)).mass;
double m1 = mass; //results in mass

double r = sqrt((dx * dx)+(dy * dy));
double F = G*m1*m2/(r*r);


Fx += (F*dx)/r;
Fy += (F*dy)/r; 

  }
  xvel += Fx/mass*time;
  yvel += Fy/mass*time;

  x+=xvel/100000;
  y+=yvel/100000;
  Sprite();
}         
  }

 virtual void draw(sf::RenderTarget& target, sf::RenderStates states)      const{
   target.draw(sprite,states); //parameters should be in here
  }  
};

主文件:

#include <cmath>
#include <SFML/Graphics.hpp>
#include <SFML/Window.hpp>
#include <SFML/System.hpp>
#include <iostream>
#include <string>
#include <vector>
#include "nbody.cpp"
int main(int argc, char *argv[]){
  void move(double position, std::vector<Body> galaxy,double scale);
  int f;

  std::cin>>f;
  double radius, scale, winsize;
  winsize = 800;

  std::cin>>radius;
  std::cout<<radius<<" \n";
  std::vector<Body> galaxy;

  scale = radius/(winsize/2);  
  for(double i=0;i<f;i++){ 
    double x,y,xv,yv,m;
    std::string name;
    std::cin>>x;
    std::cin>>y;
    std::cin>>xv;
    std::cin>>yv;  
    std::cin>>m;
    std::cin>>name;
    x = x/scale+(winsize/2);
    y = y/scale+(winsize/2);

    std::cout<<x<<" "<<y<< " " << xv << " " << yv<< " "<< m<< "\n";

    Body b(x,y,xv,yv,m,name,scale,winsize);
    galaxy.push_back(b);
  }  

  sf::RenderWindow window(sf::VideoMode(winsize, winsize), "Universe");    
  double time =0;
  while (window.isOpen())
    {
      sf::Event event;
      while (window.pollEvent(event))
    {
      if (event.type == sf::Event::Closed)
        window.close();
    }

      window.clear();
      for(double i=0;i<galaxy.size();i++){
    double position = i;
    (galaxy.at(i)).move(position,galaxy,time);  
    sf::Sprite a = (galaxy.at(i).sprite);
    window.draw(a);
      } 
      window.display();
      time +=.1;
    }

  return 0;
}

我有一个行星文本文件，它通过管道传输到生成太阳系的函数中。第一个数字是实体的数量，第二个是半径，每行中的所有其他数字是每个行星的属性:顺序为 (x,y,xvel,yvel,mass,imagefile)

5
2.50e+11
0.0000e+00  0.0000e+00  0.0000e+00  0.0000e+00  1.9890e+30      sun.gif
 1.4960e+11  0  0.0000e+00  2.9800e+04  5.9740e+24    earth.gif
 2.2790e+11  0           0.0000e+00  2.4100e+04  6.4190e+23     mars.gif
 5.7900e+10  0 0.0000e+00  4.7900e+04  3.3020e+23  mercury.gif
 1.0820e+11  0 0.0000e+00  3.5000e+04  4.8690e+24    venus.gif

谢谢

最佳答案

总是一样的问题:

首先计算所有力，然后，在考虑所有相互作用后，更新速度和位置。将其混合会导致后来的交互越来越多地与新位置一起计算。这引入了一种完全取决于集合中对象顺序的漂移。

看在皮特的份上，使用比辛欧拉更好的东西(我认为你没有意识到这一点)。这对于一些 quick'n'dirty 游戏物理来说是可以接受的，但对于半科学目的来说则不行。至少使用 Verlet 或更好的 RK4 或辛四阶方法。

标准链接:Moving stars around

关于C++ 开普勒和牛顿定律，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29619154/

文章推荐： javascript - 如何通过requestAnimationFrame平滑动画？

文章推荐： ios - animationDidStop 没有被调用？

文章推荐： C++ 调用具有不同签名的函数，具体取决于类型

文章推荐： c++ - 在 meta-toolkit 的 config.toml 中配置默认链

C++定律？ (类似于三巨头法则)
一年多以来，我一直在阅读C++并用它编写小程序。最近我遇到了三巨头法则。我从来不知道这条法律。无意中，我在这里找到了它:Rule of Three . 我可以知道 C++ 中的任何其他此类定律吗？
haskell - 右紧 ArrowLoop 定律
根据 Control.Arrow 文档，对于许多 monads(那些 >>= 操作是严格的)instance MonadFix m => ArrowLoop (Kleisli m)不满足 loop (
haskell - 基于应用的表述的单子(monad)定律
通常在 Haskell 中我们定义 Monad s 表示为 return和>>= 。有时分解也方便>>=进入fmap和join 。 Monad一旦您习惯了这两种公式的定律，它们是众所周知的并且相当直观
scala - 第二单子(monad)定律 :Unit
我正在阅读 James Iry's blog post在 Scala 中的 Monads 上。我在第三部分，我对他关于单元的单子(monad)第二定律的描述感到困惑。特别是这种说法: unit(x)
haskell - 一个简单的例子表明 IO 不满足单子(monad)定律？
我见过提到 IO不满足单子(monad)定律，但我没有找到一个简单的例子来说明这一点。有人知道一个例子吗？谢谢。编辑:如ertes和 n.m.指出，使用 seq有点非法，因为它可以使任何 monad
python - 如何制作一个 Python 程序来演示 Zipf 定律？
齐普夫定律是许多现实生活中的一种模式，齐普夫定律最常见的情况是在文本段落中，其中最常用的单词的数量是第二个最常用单词的两倍。我一直在学习 Python 中的字典，并尝试自己做这件事，但对它们的一些方
ruby - RSpec DSL 是否违反了 Demeter 定律？
这可能是一个幼稚的问题，但是 RSpec 的测试 DSL 是否违反了 Demeter 法则？这是来自 http://rspec.info 的 RSpec DSL 示例: bowling.score.
c++ - Snell 定律 — 如何处理 asin() 中的无效值？
Snell's law指出入射角和折射角的正弦比等于给定 Material 折射率比的倒数: 我想实现一个简单的程序来可视化法律。自 , 和是已知的，这是我计算的方式 : theta2 = asin
java - 用于文本生成的 Java Zipf 定律 - 太慢了
嘿，我正在开发一个文本生成器，它应该可以生成数百万种不同的文本。为了使每篇文章的内容更真实，我使用了 Zipf 定律它运行良好，单词分布正确。但是下面的 next() 函数执行得非常慢，因为我想生成
design-patterns - 我是否应该关心传入 XML 设置文件的类表示违反了 demeter 定律？
我正在使用一个工具来自动生成按层次结构组织的 XML 文件的类表示形式。 XML 文件是我的应用程序需要能够访问的设置文件(只读)。如果我将顶级节点(例如，AppSettings)传递给需要访问一项
Haskell:如何证明(测试)自定义的 Monad 实例是否遵循 Monad 定律？
不使用形式推导，如何测试自定义的Monad实例是否遵循Monad定律？最佳答案 FWIW，这是我最近编写的一组 QuickCheck 属性，用于测试从 F 代数派生的 Maybe 实现的 Monad

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

C++ 开普勒和牛顿定律