# Physik - Anziehungskraft



## Nuss (6. Jun 2014)

Hallo,

(ich hoffe, dass das der richtige Thread ist)

als Einsteiger in der JAVA-Programmierung dachte ich nun, ich wäre soweit eine kleine Simulation zu bauen. Eine Kugel (2D) fällt von oben, prallt auf den Boden auf, wird dadurch wieder in die Luft geschleudert, während sie aber wieder von der Anziehung auf den Boden gezogen wird. Eine Art Gummiball eben. Dies geschieht solange, bis die Kugel aufgrund der Erdanziehung ganz zum Stillstand kommt. Der Impuls, der sie beim Aufprall nach oben schleudert, wird natürlich von Aufprall zu Aufprall kleiner.

Ich habe in Form von Kommentaren im Code hoffentlich alles verständlich genug erklärt. 


```
import java.awt.Color;
import java.awt.Graphics;

import javax.swing.JFrame;
import javax.swing.JLabel;

public class KugelPhysik extends JFrame{
	private Screen screen;
	private float kugel_posx=400;
	private float kugel_posy=300;
	
	private static float faktor=100;
	private static float masse=1;
	private static float g=9.81f; //Erdanziehung
	private float sec=1; // Simulation startet bei Sekunde 1
	private float v; // die Geschwindigkeit die jede Sekunde neu berechnet wird
	private float p; // der Impuls, der beim Aufprall der Kugel nach oben (-y) geht
	private static float floory=530; // die y-Position des Bodens
	private float speed; // die Geschwindigkeit des Impulses
	private boolean touched=false; // ob die Kugel den Boden berührt hat
	
	public KugelPhysik(){
		super("KugelPhysik");
		screen = new Screen();
		screen.setBounds(0,0,800,600);
		add(screen);
		
	}
	
	public void repaintScreen(){
		screen.repaint();
	}
	private class Screen extends JLabel{
		protected void paintComponent(Graphics g) {
			super.paintComponent(g);
			g.setColor(Color.RED);
			g.fillOval((int)kugel_posx, (int)kugel_posy, 50, 50); // ein Kreis wird erstellt
		}
		
	}
	public static void main(String[] args) {
		KugelPhysik kp = new KugelPhysik();
		kp.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		kp.setSize(800,600);
		kp.setVisible(true);
		kp.setResizable(false);
		while(true)
		{
			if(kp.kugel_posy>=floory){ 
				kp.touched=true; // wenn die Kugel am Boden angekommen ist, dann setzte touched auf true
			}
			
			
			if(kp.touched==false){
				kp.kugel_posy=g*kp.sec*kp.sec/2/faktor; // y-Position der Kugel nach folgender Formel: 
														// Erdbeschleunigung*sec^2/2/faktor -- den Faktor habe ich verwendet
														// da der Vorgang sonst zu schnell wäre
				kp.speed=g*kp.sec/faktor;				// berechne die Geschwindigkeit für den Impuls
				
			}

			if(kp.touched==true){
				
				kp.p=masse*kp.speed; // der Impuls=Masse*Geschwindigkeit
				kp.kugel_posy-=kp.p; // steuert die Kugel nach oben - Impuls
				kp.kugel_posy+=g*kp.sec*kp.sec/2/faktor/faktor; // die Erdanziehung besteht aber natürlich immer noch
																// "/faktor/faktor" kann ich mir nicht erklären, habe ich
																// allerdings nach herumprobieren so angepasst
				
				
			}
			
			try {
				Thread.sleep(15);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			kp.sec+=1; //zähle die Sekunde hoch
			System.out.println(kp.kugel_posy); //gib die derzeitige Kugelposition aus
			kp.repaintScreen(); //den Screen neu zeichnen
		}
	}
	
	

}
```

Mein Problem besteht darin, dass die Kugel beim zweiten Aufprall nicht wieder einen weiteren Impuls nach oben erhält, der natürlich kleiner sein soll. Ich könnte eine weitere if-Abfrage dazwischenschieben, die dann nach dem ersten Impuls prüft, ob die Kugel den Boden nicht mehr berührt und touched auf false setzt. Dadurch soll dann beim nächsten Aufprall wieder ein Impuls nach oben berechnet werden.


```
if(kp.kugel_posy<floory){ 
				kp.touched=false; // wenn die Kugel nicht am Boden ist, setze touched auf false
			}
```

Diese Zeile führt allerdings zu einem Grafik-Bug. Beim zweiten Aufprall steckt die Kugel fest. Irgendwie sitze ich hier fest und weiß nicht genau, wo der Fehler liegt. Ob das zu schlampig programmiert ist oder mir nur mehr irgendeine Zeile zum Resultat fehlt?

Danke für Eure Hilfe schon im Voraus!


----------



## Tobse (6. Jun 2014)

Ich denke du bist da mit der Physik noch nicht ganz durcgestiegen. Ein Flummi funktioniert folgendermaßen:

1. Freier Fall aus höhe [c]h_0[/c] beginnt
 Bewegungsenergie [c]E_kin = 0[/c]
 Lageenergie [c]E_pot = E_pot_max[ (ist maximal)/c]
 Morphologische Energie (Verformung) [c]E_morph = 0[/c]
 Während des freien falls wird die Lageenergie komplet in Bewegungsenergie umgewandelt (abzüglich eines Teils wegen des Luftiwederstandes)
2. Kontakt mit dem Boden
 [c]E_kin = E_kin_max[/c]
 [c]E_pot = 0[/c]
 [c]E_morph = 0[/c]
3.1 Der Gummi verformt sich (da der Impuls drückt, der Boden aber nicht nachgibt)
 Vom Bodenkontakt bis zur maximalen verformung:
 [c]E_kin wird 0[/c]
 [c]E_pot = 0[/c]
 [c]E_morph wird E_morph_max[/c]
 Die Bewegungsenergie wird komplett in Morphologische Energie umgewandelt (abzüglich eines Teils, da die Vorformung selbst Energie benötigt)
3.1 Der Gummi verformt sich (da der Gummi in seine Ursprüngliche Form zurück geht).
 [c]E_kin wird E_kin_max[/c]
 [c]E_pot = 0[/c]
 [c]E_morph wird 0[/c]
 Die Morphologische Energie wird komplett in Bewegungsenergie umgewandelt (abzüglich eines Teils, da die Verformung selbst Energie benötigt)
4. Der Flummi erreicht den Hochpunkt
 [c]E_kin = 0[/c]
 [c]E_pot = E_pot_max[/c]
 [c]E_morph = 0[/c]
 Die Bewegungsenergie wird (durch das entgegenwirken der Anzeihungskraft nach unten) komplett in Lageenergie umgewandelt (abzüglich eines Teils wegen des Luftwiederstandes).

Wenn du einen Flummi simulieren willst musst du diese 3 Energieen zu jedm Zeitpunkt kennen. Die Wärmeenergie (welche bei der Reibung in der Luft und bei der Verformung von der Energie des Balls selbst abgezogen wird) kannst du vernachlässigen.
Als grober schätzwert kannst du sagen, dass pro Fall, Aufprall und "Steigflug" 5-8% der Energie des Balls als Wärmeenergie in die Umwelt geht.

Die Formeln, um von den Energieen auf die Relevanten werte zu schließen (Geschwindigkeit, Höhe, Kraft etc.)

```
(m ist immer die Masse des Balls)

g ist der Ortsfaktor, auf der Erde 9.81 N/Kg

E_kin = 0.5 * m * v²
    v = wurzel(2 * E_kin / m)

F_g = m * g

E_pot = F_g * h
    h = E_pot / F_g
```

In einer beschleunigten Bewegung (Freier Fall, "wurf" nach oben):

```
(m ist immer die Masse des Balls)

a = F / m
s = 0.5 * a * t²
```


----------



## Nuss (7. Jun 2014)

Gut,

vielen Dank! Ich werde mir das gleich mal ansehen und schauen, was ich daraus so basteln kann. Mir war wohl durchaus klar, dass so etwas wie Kinetische und Potenzielle Energie besteht, auch dass beim "Aufprall" Wärme entweicht sowie verformt wird, aber der Gedanke auch das mit einzuberechnen, entging mir irgendwie.

Nochmals großen Dank!


----------



## Nuss (7. Jun 2014)

Ich stehe grade wieder auf dem Schlauch. Irgendwie sehe ich das Problem, welches JAVA sieht, nicht.


```
import java.awt.Color;
import java.awt.Graphics;

import javax.swing.JFrame;
import javax.swing.JLabel;


public class KugelPhysik extends JFrame {
	Screen screen;
	
	public float kinEnerg;
	public float potEnerg;
	public static int masse = 5;
	public float h; // die Höhe für die potentielle Energie, diese nimmt ab
	public float h_0; // die Höhe für die kinet. Energie, diese nimmt zu
	public float v=0;
	public static float g=9.81f;
	public float kugel_posx=300;
	public float kugel_posy=0;
	public static float kugel_width=50;
	public static float worldsize_x=800;
	public static float worldsize_y=600;
	public float sec=0;
	public static float faktor = 50f; // lässt alles um 50-mal langsamer laufen
	
	
	public KugelPhysik(){
		super("Kugel Physik");
		screen = new Screen();
		screen.setBounds(0,0,800,600);
		add(screen);
		
		
	}
	
	public class Screen extends JLabel{
		protected void paintComponent(Graphics g){
			super.paintComponent(g);
			g.setColor(Color.RED);
			g.fillOval((int)kugel_posx, (int)kugel_posy, (int)kugel_width, (int)kugel_width);
		}
		
		public void repaintScreen(){
			screen.repaint();
		}
	}
	public static void main(String[] args) {
		KugelPhysik kp = new KugelPhysik();
		kp.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		kp.setSize(800, 620);
		kp.setVisible(true);
		kp.setResizable(false);
		kp.kugel_posy+=5;
		while(true){
			kp.sec+=1/faktor; // um die Zeit zu verlangsamen - 50 mal langsamer
			if(kp.kugel_posy>=worldsize_y-kugel_width){
			kp.kugel_posy-=masse*kp.v; // wenn die Kugel am Boden ist, nach oben p=m*v??
			
			}
			else{
				
				kp.h_0 = (kp.kugel_posy);
				kp.h = worldsize_y-(kp.kugel_posy+kugel_width);
				
				kp.v=(float)Math.sqrt(2*g*kp.h_0);
				kp.kugel_posy=kp.v*kp.sec*kp.sec/2;
				
				
				
			}
                                kp.kinEnerg = masse*kp.v*kp.v/2;
				kp.potEnerg=masse*g*kp.h;
				
			try {
				Thread.sleep(15);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			kp.repaint();
		}
	}

}
```

Die Verformung habe ich weggelassen, da ich mir nicht vorstellen kann, wie ich die Verformung der Kugel grafisch darstellen sollte. Ich berechne jetzt in jedem Vorgang die kinet. und potent. Energie. Sobald die Kugel aufkommt, soll sie ja wieder nach oben. Ehrlich gesagt habe ich im Beitrag vorher nicht wirklich herauslesen können, wie ich die Bahn nach oben berechnen kann. Bei Google finde ich dazu (elastischer Stoß, etc...) nichts was ich (meinem derzeitigen Physik-Wissensstand nach) verwenden könnte. Zumindest nichts was funktioniert - denn die Kugel buggt diesmal schon beim ersten Aufprall. Irgendwo liegt hier der Hund begraben.

Ich bitte erneut um Rat 

Danke!


----------



## Tobse (7. Jun 2014)

Also, die Kugel ist heruntergeflogen und hat dabei ihre Potenzielle Energie in kinetische Energie umgewandelt. Beim Flug nach oben läuft das ganze rükwärts ab. Angenommen die Kugel hat die Masse 100g (= 0,1 Kg) und fliegt von einem Meter höhe, hat sie [c]0,1 Kg * 9,81 N/Kg * 1 m  = 0,981 J[/code] Energie. Beim Flug und der Verformung gehen 5% davon verloren, bleiben [c]0,932 Joule[/c]. Mit dieser Energie kommt sie dann aber nichtmehr 1 Meter sondern [c]h = E / (m * g) = 0,932 J / (0,1 Kg * 9,81 N/Kg) = 0,95 m[/c] hoch. *Da die Formel 
	
	
	
	






		Code:In die Zwischenablage kopieren


E = m * g * h

 linear ist, kannst du auch einfach die 5% von der vorherigen Höhe abziehen ohne vorher über die Energie zu gehen.*

Dann also der Flug nach oben. Die verformte Kugel stößt sich vom Boden ab und bringt dadurch eine beschleunigende Kraft nach oben auf welche sie während des "zurückspirngens" in die Ursprüngliche Form beschleunigt. Wäre dann die Erdanziehungskraft nicht da würde die Kugel ab dann mit einer konstanten Geschwindigkeit nach oben fliegen. Hier kannst du wieder ansetzen: es gilt: [c]E_kin = 0.5 * m * v² => v = wurzel[E_kin / (0,5 * m)][/c]. Das [c]E_kin[/c] ist hier die reduzierte Energie, also die [c]0,932 J[/c].
Eine gleichförmige Bewegung wird beschrieben durch: [c]s = v * t[/c].
Nun spielt aber die Anziehungskraft der Erde eben doch eine Rolle. Also wird von dieser Linearen bewegung wieder der Teil abgezogen, den die Kugel zurücklegen würde, hätte der Boden sie nicht daran gehindert. Hier gilt: [c]s = 0,5 * g * t²[/c]. *Wichtig: die zweite Formel wirkt entgegen der ersten, das 
	
	
	
	






		Code:In die Zwischenablage kopieren


-

 also nicht vergessen*.
Es ergibt sich für den Flug nach oben: [c]s = v * t - 0,5 * g * t²[/c]. Und wie es die Physik es will wird 
	
	
	
	





```
s
```
 exakt bei [c]0,95 m[/c] [c]0[/c]. Ab dann beginnt dann der zweite freie Fall.

[EDIT]P.S.: Es empfiehlt sich, hier den Datentyp float zu verwenden und in Millijoule anstadt Joule zu rechnen. So vermeidest du grobe Rundungsfehler.[/EDIT]


----------

