Iterative Berechnung einer Satellitenbahn

[Thison]

Guten Tag,
ich habe vor im Zuge meiner Facharbeit ein Programm zu schreiben welches die Satellitenbahn berechnen soll (evtl. später auch Plantenbahn).

Bisher habe ich das:

public class Satellite
{
    // instance variables - replace the example below with your own
        double x ;
        double y ;
        double vx;
        double vy;        
        double w;
        double r;
        double ax;
        double ay;
        double t;
        double deltaT;

    /**
     * Constructor for objects of class Satellite
     */
    public Satellite(double x, double y, double vx, double vy, double m)
    {
         r = quadratwurzel(x*x+y*y);
         t = 0;
         deltaT = 0.1;
    }

    /**
     * An example of a method - replace this comment with your own
     * 
     * @param  y   a sample parameter for a method
     * @return     the sum of x and y 
     */
    public double xKoordinate(double M){
    ax = -6.673*potenzieren(10, -11)*M*(x/r*r*r);
    vx = vx + ax*deltaT/2;
    x = x + vx*deltaT;
    t = t+deltaT;
    return x;
    }
    
    public double yKoordinate (double M) {
    ay = -6.673*potenzieren(10, -11)*M*(y/r*r*r);
    vy = vy + ay*deltaT/2;
    y = y + vy*deltaT;
    t = t+deltaT;
    return y;
    }
    
        public double quadratwurzel(double a)
    {
        double i;
        for( i = 0.00; i <= 1000.00; i++)
            w = (1 / 2) * (w + a / w);
        return w;
    }
    
    public double potenzieren (double a, int p)
    {    
        double i;
        if (p<0){
         for (i=0; p<i; i--){
          a = 1/a;
         }
        }else{
         for (i=1; p<i;i++){
          a=a*a;
         }
        }
        return a;
    }
   
}

Jedoch wird bei jeder Methode immer NaN ausgegeben. Ich vermute das hat was mit den Datentypen int und double zu tun?

Des weiteren habe ich die Frage wie es möglich ist, die Satellitenbahn grafisch darzustellen (sprich aus der Vogelperspektive.

-Ich muss den Objekten aufjedenfall ein Bild zuweisen und die Objekte dann im Bild platzieren.
-Dabei soll das Koordinatensystem im Mittelpunkt des Zentralkörpers liegen
-Die Bahn müsste sich zeichnen lassen in dem ich das Objekte immer auf die nächste X und Y Koordinate bewege

Danke vielmals!

MfG,
Thison

 

[vanny]

r = quadratwurzel(x*x+y*y);

Ich würde nur x und y übergeben und die Berechnungen der Methode überlassen.

also

r = quadratwurzel(x, y);

und dann in der Methode

x*x+y*y;

Vieleicht hilft das ja, aber auf jeden Fall ist es schöner.

Gruß Vanny

//Edit: Zu der grafischen Geschichte:

1. Solltest du Grundkenntnisse in GUI-Programmierung besitzen.
2. Schau dir mal Tutorials oder Beiträge hier zu "paintComponent()" an.
3. Auch Multithreading und Syncronisation sind Sachen, die hier wahrscheinlich wichtig sein könnten.

 

[Thison]

Die Quadratwurzel so ja aus der Variablen bzw. dem Parameter a gezogen werden.

a ist in dem Fall x*x+y*y

Ich verstehe also nicht so recht worauf du hinaus willst.

 

[Marco13]

Schreib' sowas wie
w = (1 / 2) * (w + a / w);
mal lieber als
w = 0.5 * (w + a / w);

Ansonsten: Poste das ganze in Code-Tags, mit einer main()-Methode dabei, und ein paar System.out.printlns, damit man sieht WO dort WAS schiefgeht (vermutlich findest du den Fehler dann schon selbst....)

 

[vanny]

Die Quadratwurzel so ja aus der Variablen bzw. dem Parameter a gezogen werden.

a ist in dem Fall x*x+y*y

Ich verstehe also nicht so recht worauf du hinaus willst.

Ich will darauf hinaus, dass du als Argument eine Formel übergibst, die du genauso gut auch in der Methode errechnen könntest. Sowas macht den Code lesbarer und hilft mit unter bei der Fehlersuche.

 

[langhaar!]

Wieso programmierst du Funktionen wie Quadratwurzel und Potenzieren selbst?
Abgesehen davon erscheint mir folgende Zeile fehlerhaft:
w = (1 / 2) * (w + a / w);

Die Variable w wird nirgendwo initialisiert, hat also keinen Wert.
Bedeutung von NaN:

NaN wird als Fehlerindikator für das Ergebnis von undefinierten Rechenoperationen benutzt, etwa 0/0.

Schau dir folgendes mal an:
Math (Java 2 Platform SE v1.4.2)

Du brauchst sqrt und pow.

Ich will darauf hinaus, dass du als Argument eine Formel übergibst, die du genauso gut auch in der Methode errechnen könntest. Sowas macht den Code lesbarer und hilft mit unter bei der Fehlersuche.

Eine Funktion zur Errechnung einer Quadratwurzel hat ein Argument.
Egal, ob dieses als Formel übergeben wird oder nicht.
Natürlich kann man die Formel in der Funktion berechnen.
Aber wer versteht eine Quadratwurzelfunktion mit mehreren Argumenten?
Und was macht man, wenn die Quadratwurzel aus einer anderen Formel berechnet werden soll?
Eine weiterer Methode schreiben?

 

[Marco13]

Im zweifelsfall hat eine nicht initialiserte Variable den Wert 'null', 0 oder 'false'.

Das mit [c]quadratwurzel(x, y);[/c] ist auch fragwürdig. Die Passende Funktion dafür wäre dann wohl Math.hypot. Aber vielleicht war das explizite, manuelle Implementieren dieser Methoden ja Absicht...?

 

[0x7F800000]

double x ;
double y ;

Bevor du auch nur eine einzelne Zeile deiner Satellitenklasse schreibst, sorge erstmal dafür, dass du vernünftig mit 2D (oder doch lieber 3D?) Vektoren rumrechnen kannst, d.h. lege dir eine Klasse [c]Vector[/c] oder [c]Double3[/c] o.ä. an, die für dich solche x-y-Paare kapselt und einen haufen üblicher Rechenoperationen (Vektoraddition, Länge, Kreuzprodukte usw.) zur Verfügung stellt, sonst kommst du in diesem ganzen x-y-xy-yx-y-xyx-y-xy-Kram garantiert um.

r = quadratwurzel(x*x+y*y);

Wenn du wurzel ziehen willst, verwende Math.sqrt. Wenn du die Länge eines 2D-Vektors ausrechnen willst, verwende Math.hypot: ist wesentlich stabiler und mindestens um den faktor 5000 schneller.

ax = -6.673*potenzieren(10, -11)

Deine Potenziermethode ist
1) falsch implementiert, obwohl die idee funktionieren würde, theoretisch
2) falsch von der idee, selbst wenn das Rechnen mit doubles ohne Rundungsfehler funktionieren würde
3) einfach nur falsch von der Idee, weil es eben double's sind
4) völlig unangebracht, weil es für sowas die Syntax [c]-6.6E-10[/c] gibt.

Des weiteren habe ich die Frage wie es möglich ist, die Satellitenbahn grafisch darzustellen (sprich aus der Vogelperspektive.

Billiges Swing mit bisschen AWT sollte reichen.
1) Du erstellst dir eine neue JComponent-Instanz mit einer überschriebenen paint-methode
2) in dieser paint-methode malst du dein zeugs, strich für strich, kreis für kreis.
3) du packst das ganze in ein JFrame, fertig.
Wenn man sich ein bisschen anstrengt, kriegt man das sogar in 3D mit purem AWT recht passabel hin (weil es da keine überschneidenden Dreiecke gibt, solange man die Planeten einfach als Kreise hinmalt, man muss nur bisschen sortieren, bevor man zeichnet), hab's damals in meiner Facharbeit mit dem Sonnensystem so gemacht, hat prima geklappt.

Sonstiges:
1) Was sollen die "yKoordinate" und "xKoordinate" sein, haben die irgendeine semantische Bedeutung, hast du irgendeine Vorstellung, wie du das anwenden willst?
2) Explizites Eulerverfahren ist okay für den Anfang, aber ich verrate dir jetzt schonmal: es wird dir letztendlich nicht besonders akkurate Rosettenbahnen liefern. Bei 2 Körpern lässt sich die Position und Zeit übrigens explizit exakt ausrechnen.

 

[Thison]

Guten Tag,
erstmal vielen Dank für eure Hilfe. Ich hab probiert das angemerkte zu verbessern. Das Resultat ist folgendes.

public class Satellite
{
// instance variables - replace the example below with your own

double x;
double xAnfang;
double y;
double yAnfang;
double vx;
double vxAnfang;
double vy;
double vyAnfang;
double m ;
double M;
double w;
double r;
double ax;
double ay;
double t;
double deltaT;
double a;
double v;
double T;
double schritteDOUBLE;
int schritteINT;
int counter = 1;

/**
* Constructor for objects of class Satellite
*/
public Satellite(double xKoordinate, double yKoordinate, double xGeschwindigkeit, double yGeschwindigkeit, double MasseSatellit, double MasseZentralkörper)
{
x = xKoordinate;
xAnfang = xKoordinate;
y = yKoordinate;
yAnfang = yKoordinate;
vx = xGeschwindigkeit;
vxAnfang = xGeschwindigkeit;
vy = yGeschwindigkeit;
vyAnfang = yGeschwindigkeit;
m = MasseSatellit;
M = MasseZentralkörper;
r = Math.sqrt(x*x+y*y);
t = 0.0;
deltaT = 0.1;
}

/**
* An example of a method - replace this comment with your own
*
* @param y a sample parameter for a method
* @return the sum of x and y
*/


public void KoordinatenBerechnen (){
if (counter == 1) {

r = Math.sqrt(x*x+y*y);

ax = -6.673*Math.pow(10.0, -11.0)*M*x*Math.pow(Math.pow(r, 3.0),-1);
vx = vx + ax*deltaT/2;
x = x + vx*deltaT;

ay = -6.673*Math.pow(10.0, -11.0)*M*y*Math.pow(Math.pow(r, 3.0),-1);
vy = vy + ay*deltaT/2;
y = y + vy*deltaT;

t = t+deltaT;
counter = 0;
}else{
r = Math.sqrt(x*x+y*y);

ax = -6.673*Math.pow(10.0, -11.0)*M*x*Math.pow(Math.pow(r, 3.0),-1);
vx = vx + ax*deltaT;
x = x + vx*deltaT;

ay = -6.673*Math.pow(10.0, -11.0)*M*y*Math.pow(Math.pow(r, 3.0),-1);
vy = vy + ay*deltaT;
y = y + vy*deltaT;
t = t+deltaT;
}
}

public double yKoordinateMeth () {
KoordinatenBerechnen ();
return y;
}

public double xKoordinateMeth(){
KoordinatenBerechnen ();
return x;
}

private void UmlaufzeitHalbachse(){
x = xAnfang;
y = yAnfang;
vx = vxAnfang;
vy = vyAnfang;
r = Math.sqrt(x*x+y*y);
v = Math.sqrt(vx*vx+vy*vy);
a = (6.673*Math.pow(10.0, -11.0)*M)/(((2*6.673*Math.pow(10.0, -11.0)*M)/r)-v*v);
T = Math.sqrt((4.0*Math.pow(Math.PI,2.0)*Math.pow(a, 3.0))/(6.673*Math.pow(10.0, -11.0)*M));
}

public double aHalbachse () {
UmlaufzeitHalbachse();
return a;

}

public double TUmlaufzeit (){
UmlaufzeitHalbachse();
return T;
}

public void PunkteTabelle (){
UmlaufzeitHalbachse();
schritteDOUBLE = T/deltaT;
schritteDOUBLE = Math.ceil(schritteDOUBLE);
schritteINT = (int) schritteDOUBLE;
double[][] Punkte = new double[2][schritteINT];
for ( int i = 0; i < schritteINT; i++){
KoordinatenBerechnen ();
Punkte [0]=x;
Punkte [1]=y;
}
}

public double[][] KoordinatenTabelle(){
UmlaufzeitHalbachse();
schritteDOUBLE = T/deltaT;
schritteDOUBLE = Math.ceil(schritteDOUBLE);
schritteINT = (int) schritteDOUBLE;
double[][] Punkte = new double[2][schritteINT];
for ( int i = 0; i < schritteINT; i++){
KoordinatenBerechnen ();
Punkte [0]=x;
Punkte [1]=y;
}
return Punkte;
}



}

Das einzige was jetzt noch fehlt ist halt das Graphische.

@0x7F800000:

Billiges Swing mit bisschen AWT sollte reichen.

Mal abgesehen davon das mir das nichts sagt und das hier nichts "billig" für mich ist werde ich mich mal versuchen dort hineinzulesen.

Außerderm handelt es sich um das modifizierte explizites Eulerverfahren wird auch Heun-Verfahren genannt. Die daraus resultierende Bahn sollte dann doch ganz passabel aussehen.

 

[timbeau]

Java-tags!

Die große rote schrift kann man doch nicht übersehen!

 

[0x7F800000]

Guten Tag,
erstmal vielen Dank für eure Hilfe. Ich hab probiert das angemerkte zu verbessern.

Dafür ist erstaunlich wenig passiert. Das ganze sieht nach wie vor nicht mal im entferntesten nach Java-Code aus. Es erinnert viel eher an irgendsoeiner Art Registermachinen-code mit Makros, ohne erkennbare Struktur. Ich behaupte einfach mal, dass es in der Natur keine menschen-generierte Java-Klasse mit 21 double-Variablen geben kann (bzw darf).

double x;
double xAnfang;
double y;
double yAnfang;
double vx;
double vxAnfang;
double vy;
double vyAnfang;
double m ;
double M;
double w;
double r;
double ax;
double ay;
double t;
double deltaT;
double a;
double v;
double T;
double schritteDOUBLE;

das ist pures Chaos, 90% von all dem sollte weg.

r = Math.sqrt(x*x+y*y);

Wurde zwar schon mindesten 2x gesagt, aber ich sag's nochmal: Math.hypot() ist schneller.

Math.pow(Math.pow(r, 3.0),-1);

Wenigstens das könntest du doch zusammenfassen...

Mal abgesehen davon das mir das nichts sagt und das hier nichts "billig" für mich ist werde ich mich mal versuchen dort hineinzulesen.

Bei Java ist es zumindest nicht unnötig kompliziert. Es gibt auch andere Sprachen/Pakete, wo man als Neuling erstmal einen halben Tag braucht, um ein leeres Fenster aufzumachen, und dann noch einen halben Tag, um es wieder zuzumachen. Lies dir das entsprechende Kapitel in der Insel durch, dann kriegst du das locker hin.

Außerderm handelt es sich um das modifizierte explizites Eulerverfahren wird auch Heun-Verfahren genannt. Die daraus resultierende Bahn sollte dann doch ganz passabel aussehen.

Jaaa, dt runterschrauben, dann wird's schon gehen.

 

[Thison]

Sooo...
@0x7F800000: Ich weiß ja nicht was für Maßstäbe du an mich hast...aber wenig ist das nicht. Die Variablen brauch ich alle. Ob ich da irgendwie in irgendeiner Form von der Rechenoperatoren gesehen etwas weglassen oder zusammenfassen kann sollte mich jetzt noch nicht stören. Ich kann alles nachvollziehen und eine Struktur ist für mich auch vorhanden.

Math.hypot hattest du zuvor einmal erwähnt und das hab ich jetzt geändert.

Reingelesen hab ich mich so ein bisschen in das Thema Swing und AWT...hänge aber jetzt an einer allgemeineren Frage:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

/**
  *
  * Beschreibung
  *
  * @version 1.0 vom 25.10.2011
  * @author
  */

public class SatelliteJFrame extends JFrame  {
  // Anfang Attribute
  JButton oeffnen;
  JButton schließe;
  // Ende Attribute

  public SatelliteJFrame(String title) {
    // Frame-Initialisierung
    super(title);
    setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
    int frameWidth = 300;
    int frameHeight = 300;
    setSize(frameWidth, frameHeight);
    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
    int x = (d.width - getSize().width) / 2;
    int y = (d.height - getSize().height) / 2;
    setLocation(x, y);
    Container cp = getContentPane();
    cp.setLayout(null);

    setMenuBar(this.getMenubar ());
    setResizable(false);
    setVisible(true);
  }
  protected MenuBar getMenubar () {
    // Menüleiste anlegen
    MenuBar menueLeiste = new MenuBar ();
    // Ein Menü anlegen
    Menu menu = new Menu ("Datei");
    // Einen Menüeintrag anlegen
    MenuItem oeffnen = new MenuItem ("Neue Berechnung");
    // Den Eintrag dem Menü hinzufügen
    oeffnen.addActionListener(new ActionListener() {
                               public void actionPerformed(ActionEvent e) {
                                 SatelliteErstellen ();
                               }
                             }
    );
    menu.add (oeffnen);
    MenuItem schließen = new MenuItem ("Programm beenden");
    // Den Eintrag dem Menü hinzufügen
    schließen.addActionListener(new ActionListener() {
                               public void actionPerformed(ActionEvent e) {
                                 System.exit(0);
                               }
                             }
     );
     menu.add (schließen);
    // Das Menü der Leiste hinzufügen
    menueLeiste.add(menu);

    // Noch ein Menü anlegen
    Menu objekt = new Menu ("Objekt");
    // ... und noch ein Menü
    Menu information = new Menu ("Informationen");
    //...das Menü dem Extramenü als Untermenü hinzufügen
    information.add(information);
    // Das Untermenü mit Einträgen füllen
    information.add("Sans");
    information.add("Sans Serif");
    information.addSeparator();
    information.add("Courier");
    // Das Extramenü der Leiste hinzufügen
    menueLeiste.add(information);

    return menueLeiste;
  }
  // Anfang Methoden


  public void SatelliteErstellen () {
  Satelitte satellite = new Satellite ("Harald");
  }
  // Ende Methoden


  public static void main(String[] args) {
    new SatelliteJFrame("SatelliteJFrame");
  }
}

Und zwar habe ich gedacht, das wenn ich im Menü auf "Neue Berechnung" klicke einen neues Objekt der Klasse Satellite erstelle. Im Untermenü "Informationen" sollen dann bestimmte Werte des Satelliten ablesbar bzw. aufrufbar sein. Ist das irgendwie möglich?

 

[0x7F800000]

Ich weiß ja nicht was für Maßstäbe du an mich hast...aber wenig ist das nicht.

Naja, du hast dich ja in einem Java-Forum, und nicht in einem Basic- oder Assembler-Frum gemeldet, also versuche ich hier irgendwie Java-mäßige Tipps zu verteilen.

Die Variablen brauch ich alle.

Irgendwo einmal in irgendwelchen gaaanz kleinen lokalen Scopes, aber doch nicht als 25 member-Variablen eines God-Objects

Ich kann alles nachvollziehen und eine Struktur ist für mich auch vorhanden.

Echt? Dann sag mir mal, welche Beschreibung Du in einem Physikbuch eher erwarten würdest:

Variante A

Ein Satellit ist definiert durch Position x und y, eine Startposition xAnfang und yAnfang, eine Geschwindigkeit vx und vy, eine Startgeschwindigkeit vxAnfang vyAnfang, Massen m, M und w, sowie Radius r, Beschleunigung ax ay, Zeit t, und dann noch irgendwelche lustige Zahlen deltaT, double a, double v, double T, double schritteDOUBLE, von den nicht mal der vorbereitete Leser etwas verstehen muss.

Das ist so ungefähr die Beschreibung, die aus deinem Code abzulesen ist.

Variante B

Wir modellieren den Satelliten als eine Punktmasse. Eine Punktmasse ist bestimmt durch die Masse m, sowie ihre Position und Geschwindigkeit. Die Position und Geschwindigkeit sind jeweils Vektoren in R^3. Zu gegebener Masse des Planeten M, sowie der Zeit t können wir die Position des Satelliten mit hilfe des BlahBlahBlah-verfahrens wie folgt bestimmen: ...

Was dann ungefähr in so einem (immer noch brutalst vereinfachten) Code resultieren würde:

public class Vector{
  public double x;
  public double y;
  public double z;

  ...
}

public class PointMass{
  public double mass; 
  public Vector position;
  public Vector velocity;

  ...
}

public class Satellite extends PointMass{
  private String name;
  ...
}

public class KeplerSimulation{
  public static Vector[] simulateFlight(double centralMass, PointMass body, double dt, int steps){
     ... // berechnet eine liste von positionen zu zeitpunkte 0, dt, 2dt, 3dt ...
  }
}

Wie man sieht, gibt es da zumindest schonmal nirgends einen Wald mit 25 double-Variablen.

Und zwar habe ich gedacht, das wenn ich im Menü auf "Neue Berechnung" klicke einen neues Objekt der Klasse Satellite erstelle.

Und wo erstellst du das, bzw was hast du damit vor? So wie es jetzt ist, wird da was kurzfristig in der lokalen Scope einer methode erzeugt und bald darauf vom GC verschrottet:

public void SatelliteErstellen () {
Satelitte satellite = new Satellite ("Harald");
}

Ist das irgendwie möglich?

Ja, es ist vieles möglich, aber bevor du dich in GUI allzu sehr vertiefst, würde ich dir wärmstens empfehlen, ein paar ganz grundlegende Grundlagen-Basics über Klassen, Methoden, Member Variablen und allgemein Scoping aufzufrischen, sonst verschwendest du unmengen von Zeit darauf, auf gut Glück irgendwo irgendwelche Objekte anzulegen, wo sie nicht benötigt werden.

 

[VfL_Freak]

Moin,

@0x7F800000: Ich weiß ja nicht was für Maßstäbe du an mich hast...aber wenig ist das nicht. Die Variablen brauch ich alle. Ob ich da irgendwie in irgendeiner Form von der Rechenoperatoren gesehen etwas weglassen oder zusammenfassen kann sollte mich jetzt noch nicht stören. Ich kann alles nachvollziehen und eine Struktur ist für mich auch vorhanden.

ich muss 0x7F800000 Recht geben !
Du schreibst zwar, dass Du "alles nachvollziehen und eine Struktur ist für Dich auch vorhanden ist", aber für jeden anderen wohl kaum - vor allem, wenn man sich mit der Materie nicht auskennt (irgendwie sehen die Variablennamen sehr nach Buchstaben aus speziellen Funktionen aus)

Und überleg' Dir einfach mal, ob Du selbst da noch durchblicken wirst, wenn Du das Programm nach - sagen wir - einem Jahr mal wieder in die Hand nehmen musst ... sowas kommt in der Praxis (leider) sehr häufig vor!

Also am besten gewöhnt Du gleich eine strukturiertere Schreibweise und vor allem "sprechende Bezeichner" an!

Nix für ungut !
Gruß
Klaus

 

[Thison]

Guten Tag,

so ich hab versucht ein bisschen Struktur reinzubringen...ist das so schon mal etwas besser?

/**
 * Write a description of class Vector here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Vector
{
    // instance variables - replace the example below with your own
    public double x;
    public double y;
    public double z;
    /**
     * Constructor for objects of class Vector
     */
    public Vector()
    {
       
    }


    
}



/**
 * Write a description of class PointMass here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class PointMass
{
    // instance variables - replace the example below with your own
    public double mass;
    public Vector position;
    public Vector velocity;
    public Vector acceleration;

    /**
     * Constructor for objects of class PointMass
     */
    public PointMass(double xKoordinate, double yKoordinate, double xGeschwindigkeit, double yGeschwindigkeit, double Masse)
    {
    mass = Masse;
    position.x = xKoordinate;
    position.y = yKoordinate;
    velocity.x = xGeschwindigkeit;
    velocity.y = yGeschwindigkeit;
    }

   
  
}

public class Simulation
{
    // instance variables - replace the example below with your own
    double t;
    double r;
    int counter = 1; 
    PointMass body;
    double centralMass;
    double dt;
    
    //public static Vector [] simulateFlight (double centralMass, PointMass body, double dt, int steps){
    
    //}

    /**
     * Constructor for objects of class Simulation
     */
    public Simulation(double MasseDesZentralKörpers, PointMass NameDesSatelliten, double ZeitSchritt)
    {
    centralMass = MasseDesZentralKörpers;
    body = NameDesSatelliten; 
    dt = ZeitSchritt;
    }
    
    public void CalculateCoordinates(){
    if (counter == 1) {
        
    r = Math.hypot(body.position.x,body.position.y);
    
    body.acceleration.x = -6.673*Math.pow(10.0, -11.0)*centralMass*body.position.x*Math.pow(r, -3.0);
    body.velocity.x = body.velocity.x + body.acceleration.x*dt/2;
    body.position.x = body.position.x + body.velocity.x*dt;
    
    body.acceleration.y = -6.673*Math.pow(10.0, -11.0)*centralMass*body.position.y*Math.pow(r, -3.0);
    body.velocity.y = body.velocity.y + body.acceleration.y*dt/2;
    body.position.y = body.position.y + body.velocity.y*dt;
    
    t = t+dt;
    counter = 0; 
    }else{
    r = Math.hypot(body.position.x,body.position.y);
    
    body.acceleration.x = -6.673*Math.pow(10.0, -11.0)*centralMass*body.position.x*Math.pow(r, -3.0);
    body.velocity.x = body.velocity.x + body.acceleration.x*dt;
    body.position.x = body.position.x + body.velocity.x*dt;
    
    body.acceleration.y = -6.673*Math.pow(10.0, -11.0)*centralMass*body.position.y*Math.pow(r, -3.0);
    body.velocity.y = body.velocity.y + body.acceleration.y*dt;
    body.position.y = body.position.y + body.velocity.y*dt;
    
    }
    }

Bisher bekomm ich immer eine Fehlermeldung und zwar "Java.lang.NullPointerException at PointMass. <init> (PointMass.java:22)

Ich verstehe auch nicht so recht wie ich das weiter Aufbauen soll. Ich habe bisher mit BlueJ gearbeitet. Muss ich jetzt immer Objekte der einzelnen Klassen erstellen?

Danke für eure Hilfe!

 

[VfL_Freak]

Moin,

Dein Null-Pointer wird wohl durch die Deklaration von

PointMass body;

in der Klasse "Simulation verursacht, da Du so das Objekt anlegen kannst

Du hast für "PointMass" nur einen Konstruktor mit 5 Parametern und musst ihn natürlich auch verwenden :

PointMass body = new PointMass( ..... );  // <-- kommen die Parameter  rein

Gruß
Klaus

 

[Thison]

Hallo,
vielen Dank für die schnelle Antwort. Ich hatte das auch schon versucht aber dann folgt die Fehlermeldung ".class expected"

PointMass body = new PointMass(double xKoordinate, double yKoordinate, double xGeschwindigkeit, double yGeschwindigkeit, double Masse);

Der Fehler wird bei "xKoordinate" angezeigt.

Danke!

 

[VfL_Freak]

Moin,

PointMass body = new PointMass(double xKoordinate, double yKoordinate, double xGeschwindigkeit, double yGeschwindigkeit, double Masse);

Der Fehler wird bei "xKoordinate" angezeigt.

Ist klar, da Du ja hierdurch neue Variablen deklarierst :autsch:

Du musst zuerst die Werte anlegen und dann diese beim Aufruf übergeben - etwa so :

double xKoordinate = 0.5;
double yKoordinate = 12.3;
double xGeschwindigkeit = 123.0;
double yGeschwindigkeit = 11.0;
double Masse = 5.0;

PointMass body = new PointMass( xKoordinate, yKoordinate, xGeschwindigkeit, yGeschwindigkeit, Masse );

Gruß
Klaus

 

[Thison]

Tut mir leid aber da kann ich nicht folgen. Eigentlich soll der ja der Benutzer die Koordinaten sowie die Geschwindigkeit bestimmen. Sprich wenn ich ein neues Objekt der klasse PointMass erstelle, soll ein Fenster erscheinen wo ich die Parameter dann initialisiere. So ist es ja normalerweise bei BlueJ auch. Aber in dem Fall halt nicht.

 

[VfL_Freak]

Moin,

Eigentlich soll der ja der Benutzer die Koordinaten sowie die Geschwindigkeit bestimmen. Sprich wenn ich ein neues Objekt der klasse PointMass erstelle, soll ein Fenster erscheinen wo ich die Parameter dann initialisiere.

So ist es ja normalerweise bei BlueJ auch. Aber in dem Fall halt nicht

tja, ich habe nicht versucht, Deinen gesamten Code nachzuvollziehen (und BlueJ kenne ich nicht) .....
Hatte nur auf Deine konkrete Frage geantwortet

So, wie Du es deklariert hast, MUSST Du halt die Parameter übergeben. Wenn Du das nicht willst, dass müssen sie aus der Signatur des Konstruktors raus !

Gruß
Klaus

 

[0x7F800000]

public class Vector
{
    // instance variables - replace the example below with your own
    public double x;
    public double y;
    public double z;
    /**
     * Constructor for objects of class Vector
     */
    public Vector()
    {
       
    }


    
}

Was soll die große leere hier? Hier sollten doch die ganzen methoden für addition und längenbestimmung rein, während das alles

    body.velocity.x = body.velocity.x + body.acceleration.x*dt/2;
    body.position.x = body.position.x + body.velocity.x*dt;
    
    body.acceleration.y = -6.673*Math.pow(10.0, -11.0)*centralMass*body.position.y*Math.pow(r, -3.0);
    body.velocity.y = body.velocity.y + body.acceleration.y*dt/2;
    body.position.y = body.position.y + body.velocity.y*dt;

selbstverständlich weg muss, es kann doch nicht sein, wo bleibt denn die datenkapselung... Wenn's dir leichter fällt: mach die Vector-Variablen x, y, z erstmal private, dann sagt dir der compiler, wo sie überall nicht vorkommen dürfen.

Ich verstehe auch nicht so recht wie ich das weiter Aufbauen soll. Ich habe bisher mit BlueJ gearbeitet.

Das ist genau das, wovon ich gewarnt habe: du legst auf gut glück irgendwo irgendwelche Variablen an, und am ende passt nichts zusammen. Klopp dieses BlueJ lieber in die Tonne, und lies dir erstmal Kapitel 2 und 3 von Galileo Computing :: Java ist auch eine Insel – durch, sonst wirst du ohne jegliches halbwegs tragbares Fundament nur irgendwelchen Unsinn zusammenklicken, der am Ende eh nicht funktioniert.

In diesem Zusammenhang würde ich gerne noch ein Zitat nachschmeißen:

"Give me six hours to chop down a tree and I will spend the first four sharpening the axe." (Abraham Lincoln)

Und BlueJ zu schärfen macht keinen Sinn, es ist keine Axt, sondern eine Leberwurst.