1 Drift in gekreuzten elektrischen und magneti

1
Drift in gekreuzten elektrischen und magnetischen Feldern
In einem Magnetfeld wirkt auf eine bewegte Ladung die Lorentzkraft. Aufgrund der
Lorentzkraft unterscheidet sich die Bewegung parallel und senkrecht zum Magnetfeld.
In einem konstanten Magnetfeld bewegt sich die Ladung in der Ebene senkrecht zum
Magnetfeld auf einer Kreisbahn. Blickt man entgegen der Feldrichtung, so läuft eine positive Ladung im Uhrzeigersinn, eine negative Ladung entgegen dem Uhrzeigersinn um
(Gyrationsbewegung). In einem elektrischen Feld werden die Ladungen durch die Coulombkraft beschleunigt, positve Ladungen in Feldrichtung, negative Ladungen entgegen
der Feldrichtung. Durch die Ladungstrennung entsteht ein rücktreibendes elektrisches
Feld, das die Wirkung des äußeren Feldes schließlich aufhebt.
Legt man senkrecht zum Magnetfeld ein elektrisches Feld an, so wird die Ladungstrennung im elektrischen Feld durch die Gyration im Magnetfeld aufgehoben. Es entsteht
eine Drift des Gyrationszentrums in der zu beiden Feldern senkrechten E ×B-Richtung
(E × B-Drift). Die Driftgeschwindigkeit ist unabhängig von der Ladung und der Masse der Teilchen. Daher tritt die E × B-Drift in Plasmen auch über makroskopische
Distanzen in Erscheinung (Massen- und Energietransport).
1.1
Grundlagen
Bewegungsgleichung: Für ein Teilchen mit Ladung q, Masse m, Geschwindigkeit v
am Ort r in einem elektrischen Feld E(r, t) und magnetischen Feld B(r, t) lautet die
Bewegungsgleichung
1
mv̇ = q E(r, t) + v × B(r, t) .
c
Die Ableitung nach der Zeit t wird durch einen Punkt, die Lichtgeschwindigkeit mit c
bezeichnet.
Konstantes B-Feld: Das Magnetfeld sei konstant und entlang der z-Achse gerichtet:
B = (0, 0, B). Das elektrische Feld sei Null.
Bewegung parallel zu B:
mv̇k = 0,
vk = const
Bewegung senkrecht zu B:
mv̇⊥ =
q
v⊥ ×B,
c
v̇⊥ = v⊥ ×ωg ,
ωg = (0, 0, ±ωg ),
cos(φ ± ωg t)
v⊥ = v⊥
,
sin(φ ∓ ωg t)
v⊥
sin(φ ± ωg t)
r⊥ = rg ±
cos(φ ∓ ωg t)
ωg
1
ωg =
|q|B
,
mc
±1 = sgn(q),
(1)
Konstantes B-Feld und konstantes E-Feld:
Bewegung parallel zu B:
mv̇k = qEk ,
vk = vk (0) + qEk t
Bewegung senkrecht zu B:
1
mv̇⊥ = q E⊥ + v⊥ ×B ,
c
v⊥ = vg + vE
E×B
vE = c
(2)
B2
Hierbei ist vg die allgemeine Lösung der homogenen Gleichung, d.h. die Gyrationsbewegung, und vE eine spezielle Lösung der inhomogenen Gleichung, die E × B-Drift.
Man erhält diese spezielle Lösung, indem man den Trägheitsterm Null setzt und die
Geschwindigkeit aus der Lorentzkraft eliminiert.
1.2
Aufgabe
Lösen Sie die Bewegungsgleichung für eine Ladung in gekreuzten konstanten Feldern
E = (0, E, 0) und B = (0, 0, B) numerisch mit dem Runge-Kutta-Verfahren. Zeigen
Sie, daß in x-Richtung die E × B-Drift auftritt. Welche charakteristischen Bahnen
können auftreten? Wodurch unterscheiden sich die Bahnen unterschiedlicher Ladungen
bzw. unterschiedlicher Massen?
1.3
Anleitung
Dimensionslose Variablen: Anfangsgeschwindigkeit sei v0 6= 0
E
v
vE
rωg
B
E0 = ,
v0 = ,
vE0 =
,
r0 =
,
B0 = ,
B
E
v0
v0
v0
t0 = ωg t.
Dimensionslose Gleichungen: (Notation ohne 0 )
ṙ = v,
v̇ = σ(vE E + v × B),
σ = ±1.
(3)
Differentialgleichungssystem:
ẋ = vx ,
ẏ = vy ,
v̇x = σBvy ,
v̇y = σ(vE E − Bvx ),
x(0) = 0,
y(0) = 0,
vx (0) = 1,
vy (0) = 0
(4)
Die Anfangsbedingungen können ohne Einschränkung so gewählt werden. Die dimensionslosen Feldstärken sind E = 1 und B = 1. Die Lösung hängt also nur noch von
dem einen Parameter vE > 0 und dem Vorzeichen σ = ±1 der Ladungen ab.
2
4
2
yωg / v0
2
0
0
-2
vE=0.0
-2
0
2
-4
4
10
vE=0.2
0
2
4
6
8
15
10
yωg / v0
5
5
0
0
-5
vE=0.5
-5
-10
0
5
10
15
xωg / v0
vE=0.8
-10
20
-15
0
5
10 15 20 25 30
xωg / v0
Abbildung 1: Gyration und ExB-Drift einer positiven Ladung für 5 Gyrationsperioden.
Die Bahn dreht sich im Uhrzeigersinn um die z-Achse und driftet mit der Geschwindigkeit vE in x-Richtung.
1.4
Programmierhinweise
Verwenden Sie das Runge-Kutta Programm aus der letzten Übung. Speichern Sie dieses
Programm in einer eigenen Datei rk4.cpp. In der Headerdatei cs.h sollte die RungeKutta Funktion deklariert werden. Diese Header-Datei wird dann sowohl im Hauptprogramm exb.cpp und im Unterprogramm rk4.cpp mit ] include ”cs.h” eingebunden.
Stellen Sie Bahnkurven y = y(x) für verschiedene Parameter vE und σ grafisch dar.
Verwenden Sie hierzu das Programm xmgrace. Betrachten Sie auch Grafen der Bewegungen x = x(t), y = y(t) und vx = vx (t), vy = vy (t) sowie Phasenraumkurven
vx = vx (x), vy = vy (y).
3
1.5
Beispielprogramm exb.cpp
#include <stdio.h> #include <math.h>
///////////////harmonischer Oszillator////////////
double w=1.0;
void harmfunc( double x, double *y, double *dydx ) {
dydx[0] = y[1];
dydx[1] = -w*w*y[0];
}
//////////////Debye-Abschirmung///////////////////
double n = 1.0; double q = .9994; double p = 10.0;
/* Stufenfunktion */
double stepfunc( double x, double x0 ) {
return ( x > x0 ? 0.0 : 1.0 );}
void deqfunc( double x, double *y, double *dydx ) {
dydx[0] = y[1];
/* Die Ableitung von y ist die 2.Komponente des Vektors */
dydx[1] = stepfunc( x, p ) - n/(x+1e-11) * y[1] - q*exp( -1.0*y[0] ); /* zweite Ableitung ist gegeben durch die DGL */
}
///////////////ExB-Drift////////////////////////
double E=1.0;
//Parameter double B=1.0;
// ExB-Drift double sigma=1.0;//
//fuer double v_E=0.0;
void ExBdriftfunc( double t, double *y, double *dydx ) {
dydx[0] = y[2];
//y[0]=x
dydx[1] = y[3];
//y[1]=y
dydx[2] = 1.0*sigma*B*y[3];
//y[2]=v_x
dydx[3]=1.0*sigma*(v_E*E-B*y[2]);
//y[3]=v_y
}
void runge( double x, double *y, void (*func)( double, double *,
double * ), int n, double dx, double *dy ) {
int i;
double *zp, *k;
double dx6, dx3, dx2;
zp = new double[n];
k = new double[n];
/* Platz fuer den Zwischenpunkt */
/* Platz fuer die Ableitung */
dx2 = 0.5*dx;
dx3 = dx / 3.0;
dx6 = dx / 6.0;
/* muss man nicht viermal berechnen */
(*func)( x, y, k );
for( i = 0; i < n; i ++ )
dy[i] = dx6 * k[i];
/* erster Schritt : k1 = h*f( xn, yn, ) */
/* das ergebnis wird in dy aufgesammelt */
4
for( i = 0; i < n; i ++ )
zp[i] = y[i] + dx2*k[i];
(*func)( x+dx2, zp, k );
for( i = 0; i < n; i ++ )
dy[i] += dx3 * k[i];
for( i = 0; i < n; i ++ )
zp[i] = y[i] + dx2*k[i];
(*func)( x+dx2, zp, k );
for( i = 0; i < n; i ++ )
dy[i] += dx3 * k[i];
for( i = 0; i < n; i ++ )
zp[i] = y[i] + dx*k[i];
(*func)( x+dx, zp, k );
for( i = 0; i < n; i ++ )
dy[i] += dx6*k[i];
delete[] zp;
delete[] k;
/* erster zwischenpunkt: z1 = yn + 1/2*k1 */
/* zweiter schritt: k2 = h*f( xn+dx/2, z1 ) */
/* zu dy addieren */
/* zweiter zwischenpunkt: z2 = yn+1/2*k2 */
/* dritter schritt: k3 = h*f( xn+dx/2, z2 ) */
/* addieren */
/* dritter zwischenpunkt: z3 = yn+k3 */
/* letzter schritt: k4 = h*f( xn+dx, z3 ) */
/* ebenfalls addieren; jetzt ist dy = dx*(k1/6+k2/3+k3/3+k4/6) */
/* aufraeumen */
}
int main() {
FILE *y_t;
y_t=fopen("y_t.dat","w");
double y[4] = {0.0,0.0,1.0,0.0};
/* Anfangswerte in den Vektor laden */
double dy[4];
/* das wird von der runge-funktion berechnet */
double dt = 0.01;
/* schrittweite */
double t =0.0;
/* bei 0 anfangen zu integrieren */
int n_Gy=1;
/* Anzahl Gyrationen */
double tmax = 2.0*3.141*n_Gy;
for(t=0.0;t<=tmax;t+=dt){
fprintf(y_t,"%lf %lf %lf %lf %lf \n", t, y[0],y[1],y[2],y[3]);
runge(t, y, ExBdriftfunc, 4, dt, dy);
y[0] += dy[0];
y[1] += dy[1];
y[2] += dy[2];
y[3] += dy[3];
}
fclose(y_t);
}
5