Ce sont des algorithmes qui va me permettre de simuler la physique planétaire?

Vous avez besoin de connaître et de comprendre La Loi de Newton de la Gravitation Universelle et Les Lois de Kepler du Mouvement des planètes. Ces deux sont simples et je suis sûr que vous avez entendu parler d'eux, si ce n'est étudié dans l'école secondaire. Enfin, si vous voulez que votre simulateur d'être aussi précis que possible, vous devriez vous familiariser avec les problème à n Corps.

Vous devriez commencer simple. Essayez de faire un Sun objet et un Earth objet qui tourne autour d'elle. Cela devrait vous donner un très bon départ et il est assez facile de développer à partir de là. Une planète de l'objet devrait ressembler à quelque chose comme:

Class Planet {
  float x;
  float y;
  float z; //If you want to work in 3D
  double velocity;
  int mass;
}

Rappelez-vous juste que F = MA et le reste vient tout juste ennuyeux de maths 😛

Vous voudrez peut-être jeter un oeil à Celestia, un espace libre simulateur. Je crois que vous pouvez l'utiliser pour créer fictif systèmes solaires et il est open source.

En physique, il est connu comme le Problème À N Corps. Il est célèbre parce que vous ne pouvez pas résoudre ce problème en main pour un système avec plus de trois planètes. Heureusement, vous pouvez obtenir approximative des solutions avec un ordinateur très facilement.

Un beau livre sur l'écriture de ce code à partir de la base peut être trouvé ici.

Cependant, je me sens un mot d'avertissement est important ici. Vous ne pouvez pas obtenir les résultats que vous attendez. Si vous voulez voir comment:

1. la masse d'une planète affecte sa vitesse orbitale autour du Soleil, c'est cool. Vous verrez que.
2. les différentes planètes interagir les uns avec les autres, vous allez être déçu.

Le problème est présent.

Ouais, les astronomes modernes sont concerné par la façon de Saturne masse des changements de l'orbite de la Terre autour du Soleil. Mais c'est un effet mineur. Si vous allez tracer la trajectoire d'une planète autour du Soleil, il ne sera guère question qu'il existe d'autres planètes dans le Système Solaire. Le Soleil est tellement grosse qu'elle va se noyer tous les autres de la gravité. Les seules exceptions à cette règle sont:

1. Si vos planètes ont très orbites elliptiques. Ce sera la cause de planètes potentiellement se rapprocher, de sorte qu'ils communiquent le plus.
2. Si vos planètes sont presque exactement à la même distance du Soleil. Ils interagissent plus.
3. Si vous faites vos planètes afin de comique, c'est que les grands ils sont en concurrence avec le Soleil, par gravité à l'extérieur du Système Solaire.

Pour être clair, oui, vous serez en mesure de calculer certaines interactions entre les planètes. Mais non, ces interactions ne sera pas significatif à l'œil nu si vous créez un réaliste du Système Solaire.

Essayer si, et vous trouverez!

Algorithmes pour simuler la physique planétaire.

Voici une implémentation de l'hôtel Keppler pièces, dans mon application Android. Les parties principales sont sur mon site web vous pouvez télécharger l'ensemble de la source: http://www.barrythomas.co.uk/keppler.html

C'est ma méthode de dessin de la planète à la " prochaine de la position de l'orbite. Réfléchir aux étapes comme de marcher autour d'un cercle, d'un degré à un moment, sur un cercle qui a la même période, la planète vous êtes en train de suivre. En dehors de cette méthode que j'utilise un mondial du double que le compteur de pas - disant dTime, qui contient un certain nombre de degrés de rotation.

Les principaux paramètres passés à la méthode sont, dEccentricty, dScalar (un facteur d'échelle si l'orbite s'adapte à tous sur l'écran), dYear (la durée de l'orbite de la Terre en années) et d'orienter l'orbite de sorte que le périhélie est à la bonne place sur le cadran, pour ainsi dire, dLongPeri - la Longitude du Périhélie.

drawPlanet:

public void drawPlanet (double dEccentricity, double dScalar, double dYear, Canvas canvas, Paint paint, 
            String sName, Bitmap bmp, double dLongPeri)
{
        double dE, dr, dv, dSatX, dSatY, dSatXCorrected, dSatYCorrected;
        float fX, fY;
        int iSunXOffset = getWidth() /2;
        int iSunYOffset = getHeight() /2;

        //get the value of E from the angle travelled in this 'tick'

        dE = getE (dTime * (1 /dYear), dEccentricity);

        //get r: the length of 'radius' vector

        dr = getRfromE (dE, dEccentricity, dScalar);

        //calculate v - the true anomaly

        dv = 2 * Math.atan (
                Math.sqrt((1 + dEccentricity) /(1 - dEccentricity))
                *
                Math.tan(dE /2)
                ); 

        //get X and Y coords based on the origin

        dSatX = dr /Math.sin(Math.PI /2) * Math.sin(dv);
        dSatY = Math.sin((Math.PI /2) - dv) * (dSatX /Math.sin(dv));

        //now correct for Longitude of Perihelion for this planet

        dSatXCorrected = dSatX * (float)Math.cos (Math.toRadians(dLongPeri)) - 
            dSatY * (float)Math.sin(Math.toRadians(dLongPeri));
        dSatYCorrected = dSatX * (float)Math.sin (Math.toRadians(dLongPeri)) + 
            dSatY * (float)Math.cos(Math.toRadians(dLongPeri));

        //offset the origin to nearer the centre of the display

        fX = (float)dSatXCorrected + (float)iSunXOffset;
        fY = (float)dSatYCorrected + (float)iSunYOffset;

        if (bDrawOrbits)
            {
            //draw the path of the orbit travelled
            paint.setColor(Color.WHITE);
            paint.setStyle(Paint.Style.STROKE);
            paint.setAntiAlias(true);

            //get the size of the rect which encloses the elliptical orbit

            dE = getE (0.0, dEccentricity);
            dr = getRfromE (dE, dEccentricity, dScalar);
            rectOval.bottom = (float)dr;
            dE = getE (180.0, dEccentricity);
            dr = getRfromE (dE, dEccentricity, dScalar);
            rectOval.top = (float)(0 - dr);

            //calculate minor axis from major axis and eccentricity
            //http://www.1728.org/ellipse.htm

            double dMajor = rectOval.bottom - rectOval.top;
            double dMinor = Math.sqrt(1 - (dEccentricity * dEccentricity)) * dMajor;

            rectOval.left = 0 - (float)(dMinor /2);
            rectOval.right = (float)(dMinor /2);

            rectOval.left += (float)iSunXOffset;
            rectOval.right += (float)iSunXOffset;
            rectOval.top += (float)iSunYOffset;
            rectOval.bottom += (float)iSunYOffset;

            //now correct for Longitude of Perihelion for this orbit's path

            canvas.save();
                canvas.rotate((float)dLongPeri, (float)iSunXOffset, (float)iSunYOffset);
                canvas.drawOval(rectOval, paint);
            canvas.restore();
            }

        int iBitmapHeight = bmp.getHeight();

        canvas.drawBitmap(bmp, fX - (iBitmapHeight /2), fY - (iBitmapHeight /2), null);

        //draw planet label

        myPaint.setColor(Color.WHITE);
        paint.setTextSize(30);
        canvas.drawText(sName, fX+20, fY-20, paint);
}

La méthode ci-dessus appelle deux autres méthodes qui fournissent des valeurs de E (la moyenne de l'anomalie) et r, la longueur du vecteur à la fin de laquelle la planète est trouvé.

getE:

public double getE (double dTime, double dEccentricity)
    {
    //we are passed the degree count in degrees (duh) 
    //and the eccentricity value
    //the method returns E

    double dM1, dD, dE0, dE = 0; //return value E = the mean anomaly
    double dM; //local value of M in radians

    dM = Math.toRadians (dTime);

    int iSign = 1;

    if (dM > 0) iSign = 1; else iSign = -1;

    dM = Math.abs(dM) /(2 * Math.PI); //Meeus, p 206, line 110
    dM = (dM - (long)dM) * (2 * Math.PI) * iSign; //line 120
    if (dM < 0)
        dM = dM + (2 * Math.PI); //line 130
    iSign = 1;
    if (dM > Math.PI) iSign = -1; //line 150
    if (dM > Math.PI) dM = 2 * Math.PI - dM; //line 160

    dE0 = Math.PI /2; //line 170
    dD = Math.PI /4; //line 170

    for (int i = 0; i < 33; i++) //line 180 
        {
        dM1 = dE0 - dEccentricity * Math.sin(dE0); //line 190
        dE0 = dE0 + dD * Math.signum((float)(dM - dM1));
        dD = dD /2; 
        }

    dE = dE0 * iSign;

    return dE;
    }

getRfromE:

public double getRfromE (double dE, double dEccentricty, double dScalar)
{
    return Math.min(getWidth(), getHeight()) /2 * dScalar * (1 - (dEccentricty * Math.cos(dE)));
}

Si vous êtes à la simulation de la physique, je recommande fortement Box2D.

C'est un excellent simulateur physique, et permettra de réduire le montant de la chaudière de la plaque que vous aurez besoin, avec la simulation de la physique.

Dear Friend here is the graphics code that simulate solar system

Kindly refer through it

/*Arpana*/

#include<stdio.h>
#include<graphics.h>
#include<conio.h>
#include<math.h>
#include<dos.h>
void main()
{
int i=0,j=260,k=30,l=150,m=90;
int n=230,o=10,p=280,q=220;
float pi=3.1424,a,b,c,d,e,f,g,h,z;
int gd=DETECT,gm;
initgraph(&gd,&gm,"c:\tc\bgi");
outtextxy(0,10,"SOLAR SYSTEM-Appu");
outtextxy(500,10,"press any key...");
circle(320,240,20);               /* sun */
setfillstyle(1,4);
floodfill(320,240,15);
outtextxy(310,237,"sun");
circle(260,240,8);
setfillstyle(1,2);
floodfill(258,240,15);
floodfill(262,240,15);
outtextxy(240,220,"mercury");
circle(320,300,12);
setfillstyle(1,1);
floodfill(320,298,15);
floodfill(320,302,15);
outtextxy(335,300,"venus");
circle(320,160,10);
setfillstyle(1,5);
floodfill(320,161,15);
floodfill(320,159,15);
outtextxy(332,150, "earth");
circle(453,300,11);
setfillstyle(1,6);
floodfill(445,300,15);
floodfill(448,309,15);
outtextxy(458,280,"mars");
circle(520,240,14);
setfillstyle(1,7);
floodfill(519,240,15);
floodfill(521,240,15);
outtextxy(500,257,"jupiter");
circle(169,122,12);
setfillstyle(1,12);
floodfill(159,125,15);
floodfill(175,125,15);
outtextxy(130,137,"saturn");
circle(320,420,9);
setfillstyle(1,13);
floodfill(320,417,15);
floodfill(320,423,15);
outtextxy(310,400,"urenus");
circle(40,240,9);
setfillstyle(1,10);
floodfill(38,240,15);
floodfill(42,240,15);
outtextxy(25,220,"neptune");
circle(150,420,7);
setfillstyle(1,14);
floodfill(150,419,15);
floodfill(149,422,15);
outtextxy(120,430,"pluto");
getch();
while(!kbhit())             /*animation*/
{
a=(pi/180)*i;
b=(pi/180)*j;
c=(pi/180)*k;
d=(pi/180)*l;
e=(pi/180)*m;
f=(pi/180)*n;
g=(pi/180)*o;
h=(pi/180)*p;
z=(pi/180)*q;
cleardevice();
circle(320,240,20);
setfillstyle(1,4);
floodfill(320,240,15);
outtextxy(310,237,"sun");

circle(320+60*sin(a),240-35*cos(a),8);
setfillstyle(1,2);
pieslice(320+60*sin(a),240-35*cos(a),0,360,8);
circle(320+100*sin(b),240-60*cos(b),12);
setfillstyle(1,1);
pieslice(320+100*sin(b),240-60*cos(b),0,360,12);
circle(320+130*sin(c),240-80*cos(c),10);
setfillstyle(1,5);
pieslice(320+130*sin(c),240-80*cos(c),0,360,10);
circle(320+170*sin(d),240-100*cos(d),11);
setfillstyle(1,6);
pieslice(320+170*sin(d),240-100*cos(d),0,360,11);
circle(320+200*sin(e),240-130*cos(e),14);
setfillstyle(1,7);
pieslice(320+200*sin(e),240-130*cos(e),0,360,14);
circle(320+230*sin(f),240-155*cos(f),12);
setfillstyle(1,12);
pieslice(320+230*sin(f),240-155*cos(f),0,360,12);
circle(320+260*sin(g),240-180*cos(g),9);
setfillstyle(1,13);
pieslice(320+260*sin(g),240-180*cos(g),0,360,9);
circle(320+280*sin(h),240-200*cos(h),9);
setfillstyle(1,10);
pieslice(320+280*sin(h),240-200*cos(h),0,360,9);
circle(320+300*sin(z),240-220*cos(z),7);
setfillstyle(1,14);
pieslice(320+300*sin(z),240-220*cos(z),0,360,7);
delay(20);
i++;
j++;
k++;
l++;
m++;
n++;
o++;
p++;
q+=2;
}
getch();
}