4. Physik: Visualisieren der Lorentzkraft

Physik: Visualisieren der Lorentzkraft

  • D

    Hi Leute,
    Ich hab hier ein deftiges Problem:
    Für meine Physiksemesterarbeit, soll ich die Bewegung von Elektronen darstellen, die sich durch ein Magnetfeld bewegen, senkrecht zu den Feldlinien. Wenn ich nur die resultierende Linie bräuchte, wär's ja kein Problem: Radius ausrechnen und Kreis zeigen. Tja, das reicht aber nicht, ich brauch von jedem einzelnen Pixel dieses Kreises die Lorentzkraft in x-Richtung und die Lorentzkraft in y-Richtung.
    Im Grunde, ist das ganze ja nicht all zu schwer:
    Man rechnet die Anfangsgeschwindigkeit aus, mit der das Elektron in das Feld kommt:
    v=√2*e/m*Ub (Ub ist die Beschleunigungsspannung)
    Genau genommen ist das ja vx. vy ist zu dem Zeitpunkt noch null.
    So, dann geht's los:
    die Lorentzkraft in y-Richtung ist e*B*vx (B = Magnetfelddichte in Tesla)
    und in x.Richtung: e*B*(-vy)
    Die neue Geschwindigkeit in x-Richtung ist dann vx+FLx/m * Δt (FLx ist die Lorentzkraft in x-Richtung)
    und in y-Richtung: vy+FLy/m *Δt

    Die neue Position ist dann:
    x+vxΔt
    y+vy    Δt

    Tjoar. Eigentlich ganz simpel.
    Falls es wen interessiert, der Quellcode bisher:

    struct SPoint
{
	double x;
	double y;
	operator CPoint()
	{
		return CPoint((int)x,(int)y);
	}
	bool operator==(const SPoint &p)
	{
		return x==p.x&&y==p.y;
	}
};

struct SVector
{
	double X;
	double Y;
};

struct SElectron
{
	SPoint Pos;
	SVector Velocity;
};

const double e = 1.6e-19;
const double m = 9.1e-31;
const double edivm = e/m; // e/m = 1.6*10^-19 C / 9.1*10^-31 kg

void CalcNewElectronPosition(SElectron *pElectron, float fB,float fU,float fR)
{
	double dFLX = e*fB*(-pElectron->Velocity.Y);
	double dFLY = e*fB*pElectron->Velocity.X;
	double deltaT = DeltaT(...);

	pElectron->Velocity.X+=(dFLX/m*deltaT);
	pElectron->Velocity.Y+=(dFLY/m*deltaT);

	pElectron->Pos.x+=(pElectron->Velocity.X*deltaT);
	pElectron->Pos.y+=(pElectron->Velocity.Y*deltaT);

}

void Plot(CDC *pDC, float fUb, float fB, float fU, float fR)
{
	SElectron e;
	e.Pos.x=100;
	e.Pos.y=150;
	e.Velocity.X=sqrt(2.0*edivm*(double)fUb);
	e.Velocity.Y=0;
	int i=0; 
	SPoint OldPos=e.Pos;
	while(i++<300000)
	{
		CalcNewElectronPosition(&e,fB,fU,fR);
		if(!(e.Pos==OldPos))
		{
			OldPos=e.Pos;
			pDC->SetPixel(e.Pos,RGB(255,0,0));
		}
	}
}

    Wie ihr vielleicht gesehen habt, wird "deltaT" mit der Funktion DeltaT initialisiert, die nirgendwo definiert ist. Und genau hier liegt mein Problem!
    Das Δt darf nicht bei jedem Funktionsaufruf gleich sein, da die Geschwindigkeit des Elektrons immer größer wird und die Abstände der einzelnen gesetzten Pixel immer größer würden. Also hab ich versucht, das Δt zu berechnen.
    Habe es auf verschiedene Arten probiert:

    • Δt = 1.0/√vx²+vy²
      Hm, fragt mich nicht, wie ich darauf gekommen bin, hab das schon vor 4 Wochen geschrieben ... Ergibt übrigens ne Spirale, keinen Kreis.
    • Δt = (-vx+√v²+(0.001*F*m)))/(2F)
      Hier habe ich versucht, das Δt so hinzubekommen, dass sich der x-Wert immer um eins vergrössert. Herleitung über obige Formel: 0,00025 = vx      Δt
      Auf 0,00025 kommt man einfach dadurch, dass ich im programm definiert hab, dass 200 pixel 5 cm seien.
      Das Problem hierbei ist, dass double nicht genau genug ist. Laut Taschenrechner, wäre das erste Ergebnis ca 3,5e-51.
      So genau packt das kein double, man hat im Grunde ja folgendes:
      (-vx + die Wurzel) / irgendwas
      tja, die Wurzel sieht aber so aus: √vx²+(0.001*F*m)
      F ist die Lorentzkraft. Hat nen Wert von ca 5,1e-14. m ist das Elektronengewicht: 9,1e-31. D.h, der Wert der Wurzel ist auf ziemlich viele Stellen hinter dem Komma gleich der Geschwindigkeit, die von der Wurzel abgezogen wird. Da double nicht genau genug ist, sind beide Werte identisch, die Zahl im Zähler wird 0, mein Δt auch und somit bleibt die Geschwindigkeit meines Elektrons konstant.

    Tja. Ich hab keine Idee mehr, wie ich das noch angehen könnte. Ein kleiner Tip o.ä wäre sehr willkommen 🙂

    0
  • G

    dEUs schrieb:

    da die Geschwindigkeit des Elektrons immer größer wird

    Verstehe ich nicht. Hier wirkt doch nur die Lorentzkraft, oder habe ich da etwas übersehen? Die Lorentzkraft verrichtet keine Arbeit, durch diese Kraft kann dein Elektron also nicht schneller werden. Es kann nur seine Bewegungsrichtung ändern.

    0
  • D

    Hm ... Da hast du eigentlich recht ...
    Andererseits bedeutet eine Änderung der Bewegungsrichtung eine Änderung der Geschwindigkeit in x-Achse und y-Achse. Insofern ändert sich die Geschwindigkeit dann doch. Mit meinem Code gibt das jedenfalls eine Spirale, wenn man Δt konstant macht ... Allerdings auch, wenn man es nicht konstant macht *lol* 😞

    0
  • G

    Ohne mir jetzt deinen Code und deinen Beitrag ganz oben genau anzugucken, vermute ich einfach mal, dass die Spirale an folgendem liegt:

    Dein Algorithmus berechnet die Bewegung des Elektrons "schrittweise". Dadurch kommt es zu Stande, dass sich die jeweils systematisch entstehenden Fehler aufsummieren und am Schluss so groß sind, dass aus dem Kreis leider eine Spirale geworden ist.

    Ich würde die schrittweise Berechnung, wenn möglich aufgeben und stattdessen versuchen, eine explizite Formel für die Trajektorie r(t) herzuleiten (oder wenn du etwas anderes brauchst eine entsprechende andere Formel, hab deinen Beitrag ja nicht wirklich gelesen ;)). Die Werte, die du darstellen mußt, erhälst du dann durch Einsetzen in die Formel.

    0
  • D

    Ich hab irgendwie das Gefühl, dass meine CalcNewElectronPosition nicht so das wahre ist ... Dort WIRD die Geschwindigkeit nämlich mehr. Sieht man gleich beim ersten Durchlauf: vy ist Null, deswegen bleibt vx gleich beim ersten mal. vy wird aber geändert, auf einen Wert größer null.
    Mir ist grad was aufgefallen: Der Geschwindigkeitsvektor beschreibt ja einen Kreis, vielleicht kann ich mir das irgendwie zu Nutze machen ... Mal n bissle rumspielen 🙂

    0
  • D

    Hm, hälst du es für so ne gute Idee, die Position von der Zeit abhängig zu machen? So ein Elektron ist verflucht schnell *g* -> Zeit ziemlich klein. Ausserdem müsste ich mit der Funktion dann zwei Werte berechnen: x und y ...

    0
  • D

    Und noch was: Ich brauch ja zu jedem Punkt die Kraft und auch die Geschwindigkeit! Meinst du, das geht überhaupt über die Bahnkurve? Das würde doch bedeuten, dass ich aus einem x- und einem y-Wert die Geschwindigkeit, die Richtung der Geschwindigkeit, die Kraft und die Richtung der Kraft herleiten kann. Das erscheint mir aber n bissle unwahrscheinlich, dass das möglich ist.

    0
  • G

    Was sollst du jetzt eigentlich nochmal genau ausrechnen? Oben hast du geschrieben, dass du die Lorentzkraft für diverse Punkte auf der entstehenden Kreisbahn ausrechnen sollst. Ist das alles?

    0
  • D

    Da hast du was falsch verstanden. Ich benötige die Lorentzkraft, BEVOR die Kreisbahn angezeigt wird, da ich noch ne elektrische Kraft mit einarbeiten muss (elektrische Feldlinien sind senkrecht zu den magnetischen Feldlinien und spannen sich zwischen zwei Kondensatorplatten auf)

    0
  • G

    Gehen wir mal anders an die Sache heran.

    1. Die Lorentzkraft ist hier die Zentripetalkraft, dass heißt, ihr Betrag ist immer m*omega^2*r und die Richtung ist immer in Richtung des Mittelpunktes des Kreises. r kann man mit dem Ansatz "Lorentzkraft = Zentripetalkraft" schnell an einem Punkt, an dem es leicht geht, ausrechnen.

    2. Die Geschwindigkeit ist konstant und steht immer senkrecht zur Lorentzkraft. Wenn du die Lorentzkraft für einen Punkt auf der Kreisbahn hast, kannst du somit auch leicht den Geschwindigkeitsvektor an der gegebenen Stelle berechnen.

    0
  • G

    dEUs schrieb:

    Da hast du was falsch verstanden. Ich benötige die Lorentzkraft, BEVOR die Kreisbahn angezeigt wird, da ich noch ne elektrische Kraft mit einarbeiten muss (elektrische Feldlinien sind senkrecht zu den magnetischen Feldlinien und spannen sich zwischen zwei Kondensatorplatten auf)

    Ach so. Dann geht das wohl doch nicht ganz so leicht. Naja, ich geh jetzt schlafen. Gute Nacht.

    0
  • D

    Jo, sonst hät ich schon längst einfach die Circle-Funktion verwendet 😉
    Kannst dir den Beitrag morgen bzw nachher nochmals anschauen. Danke für deine Hilfe soweit. Gute Nacht.

    0
  • D

    ok, habs hinbekommen 🙂

    struct SPoint
{
	double x;
	double y;
	operator CPoint()
	{
		return CPoint((int)x,(int)y);
	}
	bool operator==(const SPoint &p)
	{
		return x==p.x&&y==p.y;
	}
};

struct SVector
{
	double X;
	double Y;
};

struct SElectron
{
	SPoint Pos;
	SVector Velocity;
};

const double ScaleFactor = 1.0;

const double e = 1.6e-19;
const double m = 9.1e-31;
const double edivm = e/m; // e/m = 1.6*10^-19 C / 9.1*10^-31 kg
double DeltaT1(double v,double F)
{
	double tmp = sqrt(pow(v,2)+(4.0*F*m));
	double tmp2 = -v+tmp;
	return tmp2/(2.0*F);
}
void CalcNewElectronPosition(SElectron *pElectron, float fB,float fU,float fR)
{
	double deltaT = 1e-9;
	double dFLY = e*fB*pElectron->Velocity.X - e*fU/fR;
	pElectron->Velocity.Y+=(dFLY/m*deltaT);

	double dFLX = e*fB*(-pElectron->Velocity.Y);
	pElectron->Velocity.X+=(dFLX/m*deltaT);

	double dFL = sqrt(dFLX*dFLX+dFLY*dFLY);
	double dV  = sqrt(pElectron->Velocity.X*pElectron->Velocity.X+pElectron->Velocity.Y*pElectron->Velocity.Y);

	pElectron->Pos.x+=(pElectron->Velocity.X*deltaT)/0.00025;
	pElectron->Pos.y+=(pElectron->Velocity.Y*deltaT)/0.00025;

}

void Plot(CDC *pDC, float fUb, float fB, float fU, float fR)
{
	SElectron e;
	e.Pos.x=100;
	e.Pos.y=150;
	e.Velocity.X=sqrt(2.0*edivm*(double)fUb);
	e.Velocity.Y=0;
	int i=0; 
	SPoint OldPos;
	pDC->Arc(CRect(50,50,150,150),CPoint(100,150),CPoint(100,51));
	while(i++<1000)
	{
		CalcNewElectronPosition(&e,fB,fU,fR);
		if(!(e.Pos==OldPos)&&e.Pos.x>100&&e.Pos.x<300&&e.Pos.y>50&&e.Pos.y<250)
		{
			OldPos=e.Pos;
			pDC->SetPixel(e.Pos,RGB(255,0,0));
		}
	}
}

    Es ist defacto immer noch eine Spirale. Aber so nah am Kreis, dass es (a) nicht stört und dass man es (b) nicht bemerkt 🤡

    0
Anmelden zum Antworten