Single Particle Motion via

Computer Simulation
Stefano Markidis (markidis@pdc.kth.se)
HPCViz Department - CSC School - KTH
 Useful Info
I work for KTH HPC computer center (PDC) and department (http://
www.pdc.kth.se/), located in TEKNIKRINGEN 14, PLAN 4. You can
contact me by email markidis@pdc.kth.se.

The material for this class is available at:

http://www.pdc.kth.se/education/computational-plasma-physics/
computational-plasma-physics

You will need to download Matlab/Octave codes to complete your

assignments!
 Outline
Introduction

Equation of motion of a charged particle

Crash course on Matlab/Octave

Numerical solution of equation of motion for charged particles:

Constant uniform fields (E x B drift)

Spatially varying magnetic field

Magnetic dipole (Earth-like magnetic dipole)

Guiding center approximation. Numerical solution of guiding center

approximation.
 Introduction
We will study the trajectory and dynamics of charged particles (electron,
proton, alpha particles) in a given static magnetic field configuration.

We will solve numerically the equations that govern the motion of

particles using programming language Matlab or Octave (free version of
Matlab).

I will teach basic commands of Matlab/Octave, so you can understand the

code for todays and next lecture and learn how to modify to solve the
assignment

I will present an approximated model of charged particle motion in a

(strong) magnetic field (Guide Center approximation), its equation and
numerical solution with Matlab/Octave
 Equation of Motion
dp
= q(E + v B) + FnonEM
dt

p = momentum = m v (we will assume non relativistic

motion for today = 1)
q = particle charge
E = electric field acting on the particle
B = magnetic field on the particle
Fnon-EM = other forces acting on particle (gravitational, ...)
E = const and B = 0 (neglect the
non-EM forces)
dv q
= E
dt m
Constant acceleration in the direction of E.

a e - E
 E = 0 and B = const uniform
The equation on the right describe
helical motion that:
is constant in the
direction of B
qB 2m v m vx2 + vy2

circular in the (x,y) plane c =

m
T =
qB
=
|c |
=
|q|N
z
The centre of gyro-motion is called
guiding center (GC).
guiding center
 E = 0 and B = const (continued)
dv
The equation of motion is: m = qv B
dt
Taking the inner product with v of both sides of the equation
2
dv d mv
m v = ( )=0
dt dt 2

Consequently, the kinetic energy and the speed (module of velocity) remain
constant. We will use this results in the computer experiments.
Computer Simulation of Single Particle Motion
Use Matlab programming language when available (computer labs,
student licenses). Otherwise we will use Octave (like I do).

Matlab and Octave provide:

Efficient ODE solvers are already implemented. Caveat: Matlab and

Octave use different name for ODE solvers and sightly different
syntax.

Plotting subroutines.
 Matlab/Octave

Matlab is not free but available to all KTH students as joint student
license.

Octave is free (http://www.gnu.org/software/octave/) but less fancy

than Matlab (plots looks no as good as the one in Matlab).
 Matlab/Octave Crash Course
Good tutorial available at http://www4.ncsu.edu/~mahaider/
NCSU_RTG_Site/RTM_Matlab_Intro.pdf (caveat some functions
might not working on Octave). Today I will talk about how to use:

Matlab and Octave file, and how to run command line

Arrays and matrices

Plots

Control statements
 Matlab/Octave Files and Start
Typically, you will write your Matlab/Octave code using a text editor (Matlab has one,
for Octave you can use emacs, vi, and other editor). The file name has extension .m i.e.
TrajMagnDipole.m

When you start Matlab/Octave, a command line will appear:

>>
you probably need to change directory (where you saved your program)

>>cd your_directory
and then run the code

>>TrajMagnDipole without .m !
Matlab and Octave will keep in memory the varaiables of your main
code you launched, so you can use those variables for doing some
extra-processing
 Arrays and Matrices
Everything in Matlab/Octave is an array or a matrix. Scalar are vector of size 1.

In the first particle trajectory program, we will use arrays for storing in memory:
- Particle positions x, y, z
- time t
In my next lecture we will use:
- Electric field on the cell centers Eg
- Electrostatic potential Phi
- Energy and momentum histories histTotEnergy, ...

Today we will use matrices for storing the solution of our problem:
- ODE solution matrix x_sol
In my next lecture we will use:
- Matrix for saving interpolation values mat
- Matrices for saving the output. histEfield, ...
 Assignment of Arrays and Matrices
To enter a matrix, stick some rows together. For example, a 2x2 matrix B
could be entered as:
1 2
B=[1 2; 3 4] This enters the matrix B =
3 4
To simplify typing vectors, some shortcuts are introduced. For example, to
obtain the vector t = [0 0.5 1 1.5 2 .. 9 9.5 10], you can type
t=[0:.5:10], which creates a vector from 0 to 10 in 0.5 increments. Or, to
get a vector containing equally spaced entries, you can use the linspace
command. For example, to get 400 elements from 0 to 100 equally spaced, you
could type
r = linspace(0,100,400).
Extract Parts of Vectors and Arrays
For instance, to obtain the 5th entry of a vector r, type
>> r(5)
For a range of values, i.e. from a to b, type
>> r(a:b)
For a matrix, the syntax is (row, column). So to get the i; j entry of the
matrix B, type
>> B(i,j).
Similarly, you can pull out ranges of values as you could with a vector. If
you wanted the entire range of rows, or columns, use the
colon (:). So the rowspace of the fourth column of A would be A(:,4).
 Useful Functions for Array Matrices
size() returns the dimension of a matrix/vector. If you just want the length
of a vector, use length(), numel().

eye(n) creates the nxn identity matrix.

zeros(n,m) creates an nxm matrix of zeros. Useful for initializing vectors

and matrices.

ones(n,m) creates a matrix of ones.

rand(n,m) creates a nxm matrix with entries from a random uniform

distribution on the unit interval.

randn(n,m) creates a nxm matrix from a random normal gaussian

distribution.
 Operations
All the standard operations, sin; cos; tan; arctan; log; ln;
and exp exist in MATLAB/Octave. You can apply these to vectors. If you
wanted the sine of a vector, just do b=sin(a). Moreover you will have
sum, mean, cov to calculate the sum, the average ad covariance of a
vector.
Matrix multiplication works as you expect, so long as the dimensions match
of course. To multiply 2 matrices A*B just do
>> C=A*B
You can also do element wise operations on matrices and vectors using
the dot notation. For example
>> C=A.*B
will create a matrix C whose elements are denoted as cij =aij*bij . The dot
notation works with multiplication, *, division, /, and exponentiation.
Today we will use Plots
>> plot3(x, y, z, options)
to plot the trajectories. x, y, z vectors contain the particle coordinate at
different times steps
The most basic way to plot 2D data is using the plot command:
>> plot(time,x, options)
where time is a vector denoting the independent vector and x is the
data you want to plot and options is where you can specify color,
thickness,..., i.e. plot(time,x,r.) use red dot line
Other plots you will use in my next lecture:
- hist ----> make an histogram
- semilogy ----> make a plot with logarithmic y-axis
- bar -----> make bar plot
- pcolor ----> make a contourplot
- surf ----> make a surface plot
 Control Statements: for and while
There are two kinds of loops we will use: for and while loops.
A for loop is used to repeat a statement of a group of statements for a fixed
number of times. An example:
for it=1:NT
num = 1/(it+1);
end

A while loop is used to execute a statement or a group of statements for an

indefinite number of times until the condition specified by while is no longer
satisfied. An example: while num < 10000
num = 2^i;
v = [v; num];
i = i+1;
end
 Control Statements: if
Frequently you'll have to write statements that will occur only if some condition is
true. Typically you'll have an if statement, and if it isn't satisfied, a corresponding
else or elseif statement. Along with the standard greater than, and less than
conditions (a>b, b<a, a>=b, b<=a), there are also:
- and a & b Example
i=6; j=21;
- or a | b
if i >5
- not-equal a ~= b
k=i;
- equal (notice the two equal signs!): a==b
elseif (i>1) &
(j==20)
k=5i+j;
else
k=1;
end
 Functions
In Matlab/Octave, the equations are passed to the ODE solver via function

Function are typically defined in separate .m file

returned value name of the function
input argument
(can be scalar or vector) same of .m file

function x_res = Newton_Lorenz(x_vect,t)

...
...
endfunction
 Matlab and Octave ODE solvers
- Octave uses lsode: vector with
initial values independent variable
[x_sol,t] = lsode("Newton_LorenzOct",[x0 ;y0; z0; u0; v0; w0],time);

2 component
- Matlab uses ode23: independent variable
initial and final time
initial values
[t,x_sol] = ode23(@Newton_LorenzMat, [0 final_time], [x0 ;y0; z0; u0; v0; w0]);

Newton_LorenzOct and Newton_LorenzMat will have different ordering in initial values and independent
variables
function x_res = Newton_LorenzOct(x_vect,t)
function x_res = Newton_LorenzMat(t,x_vect)
 Equation of Motion Function
function x_res = ExBfunc(x_vect,t)
% function x_res = ExBfunc(t, x_vect)

dx % x_vect(1) = x

=v %
%
x_vect(2)
x_vect(3)
=
=
y
z

dt %
%
%
x_vect(4)
x_vect(5)
x_vect(6)
=
=
=
u
v
w

global Bx; global By; global Bz;

dv q global Ex; global Ey; global Ez;
global qom;
= (E + v B)
dt m x_res = zeros(6,1);

x_res(1) = x_vect(4); % dx/dt = u

x_res(2) = x_vect(5); % dy/dt = v
x_res(3) = x_vect(6); % dz/dt = w
x_res(4) = qom*(Ex + x_vect(5)*Bz - x_vect(6)*By);
x_res(5) = qom*(Ey + x_vect(6)*Bx - x_vect(4)*Bz);
x_res(6) = qom*(Ez + x_vect(4)*By - x_vect(5)*Bx);

endfunction
 Motion in Constant and Uniform Fields
(EcrossBdrift.m) ...
% EM
Bz =
Bx =
fields
1.0 ; % B in z direction
0.0 ;
By = 0.0 ;
B = 1.0 Ex = 0.2 ; % E in x direction
main code Ey =
Ez =
0.0 ;
0.0 ;

(EcrossBdrift.m) % initial position

x0 = 0;
simulation parameters y0 = 0;
z0 = 0;

% initial velocity
u0 = 0.5;
v0 = 0.0;
w0 = 0.0;
...

z E = 0.2
function for ODE solver (ExB function)
x x_res(1) = x_vect(4); % dx/dt = u
x_res(2) = x_vect(5); % dy/dt = v
x_res(3) = x_vect(6); % dz/dt = w
x_res(4) = qom*(Ex + x_vect(5)*Bz - x_vect(6)*By); % du/dt = qom*(E + vel x B)_x
x_res(5) = qom*(Ey + x_vect(6)*Bx - x_vect(4)*Bz); % dv/dt = qom*(E + vel x B)_y
x_res(6) = qom*(Ez + x_vect(4)*By - x_vect(5)*Bx); % dw/dt = qom*(E + vel x B)_z
 Solution Matrix from ODE Solvers
The lsode (Octave) and ode23 (Matlab) solvers will return a matrix [x_sol, time]
(Octave) and [x_sol, time] (Matlab)
- time is a vector with different time values
- x_sol is a matrix containing the results x_sol
time x y z u v w
0
0.1
...
z
E x B drift Velocity

y
x

Trajectory
x0, y0 v

v
time

octave-3.2.3:96> mean(x_sol(:,5))
ans = -0.20135
Is -0.20135, the value we
x
expected for the drift velocity ?
 Grad-B Drift (GradBdrift.m)
...
% charge to mass ratio
qom = 1
% EM fields
B = (1.0 x) k Bz = 1.0 ; % B in z direction
Bx = 0.0 ; % here we have spatial variation
By = 0.0 ;
main code Ex = 0.0 ; % no electric field just B gradient
Ey = 0.0 ;
(GradBdrift.m) Ez = 0.0 ;
% initial position

z simulation set-up x0 = 1.0;

y0 = 0;
z0 = 0;
% initial velocity
u0 = 0.3;
v0 = 0.0;
x w0 = 0.0;
...

function for ODE solver ...

Bz = 1*x_vect(1);
(gradBfunc.m). Here x_res(1) = x_vect(4); % dx/dt = u
we define the B gradient. ...
 Grad B Drift Results
Trajectory

u time
y
octave-3.2.3:88> mean(x_sol(:,5))
ans = 0.039055
x0, y0

What do you expect this grad B drift velocity value ?

x
 Try This at Home !
% charge to mass ratio
qom = 1 1 2
% EM fields % EM fields
Bz = 1.0 ; % B in z direction Bz = 1.0 ; % B in z direction
Bx = 0.0 ; Bx = 0.0 ;
By = 0.0 ; By = 0.0 ;
Ex = 0.0 ; Ex = 0.0 ;
Ey = 0.0 ; Ey = 0.0 ;
Ez = 0.0 ; Ez = 0.0 ;

% initial position % initial position

x0 = 0.1; x0 = 0.1;
y0 = 0; x0 is very close to null y0 = 0;
z0 = 0; and negative B regions ! z0 = 0;

% initial velocity % initial velocity

u0 = 0.01; u0 = 0.3;
v0 = 0.0; v0 = 0.0;
w0 = 0.0; w0 = 0.0;

tfin = 400 tfin = 50

time = 0:0.01:tfin;
As third example, we calculate numerically the trajectory of charged particles in a
simplified model of Earths magnetic field
0
Bdip = 3
(3(M
r )r M)
4r
r = x
x + y
y + z
z
z M = Magnetic moment
M = M
z
At magnetic equator (x = Re, y =0, z=0)
B0 = 3.07*10-5 T, so:
x 3
0 M/4 = B 0 Re

B0 Re3
Bdip = 5 (3xz y + (2z 2 x2 y 2 )
x + 3yz z)
r
Matlab/Octave Magnetic Dipole
(Newton_Lorenz.m)
...
% x_vect(1) = x
% x_vect(2) = y
% x_vect(3) = z

fac1 = -B0*Re^3/(x_vect(1)^2 + x_vect(2)^2 + x_vect(3)^2)^2.5;

Bx = 3*x_vect(1)*x_vect(3)*fac1;
By = 3*x_vect(2)*x_vect(3)*fac1;
Bz = (2*x_vect(3)^2 -x_vect(1)^2- x_vect(2)^2)*fac1;
...
Octave Code - Newton Lorenz Eqs (GC_TrajMagnDipole.m)
close all;
clear all;
global B0; global q; global m; global Re;
% parameters
e = 1.602176565e-19; % Elementary charge (Coulomb)
m_pr = 1.672621777e-27; % Proton mass (kg)
m_el = 9.10938291e-31; % Electron mass (kg)
c = 299792458; % speed of light (m/s)
% Earth parameters
B0 = 3.07e-5 % Tesla
Re = 6378137 % meter (Earth radius)
% use electron/proton
m = m_pr % we choose proton, change to m_el when simulating electron
q = e % positive charge, change to -e when simulating electron
Simulation parameters
% Trajectory of a proton with 10MeV kinetic energy in dipole field
K = 1e7 % kinetic energy in eV
K = K*e; % convert to Joule
% Find corresponding speed:
v_mod = c/sqrt(1+(m*c^2)/K)
% initial position: equatorial plane 4Re from Earth
x0 = 4*Re;
y0 = 0;
z0 = 0;
pitch_angle = 30.0 % initial angle between velocity and mag.field (degrees)
% initial velocity
u0 = 0.0;
v0 = v_mod*sin(pitch_angle*pi/180);
w0 = v_mod*cos(pitch_angle*pi/180);

tfin = 10 % in s
time = 0:0.01:tfin;
[x_sol,t] = lsode("Newton_Lorenz",[x0 ;y0; z0; u0; v0; w0],time); % solve equation of motion simulation
plot3(x_sol(:,1)/Re,x_sol(:,2)/Re,x_sol(:,3)/Re,'r'); % plot trajectory in 3D
ODE function (Newton_Lorenz.m)
function x_res = Newton_Lorenz(x_vect,t)

% x_vect(1) = x
% x_vect(2) = y
% x_vect(3) = z
% x_vect(4) = u
% x_vect(5) = v
% x_vect(6) = w

global B0; global q; global m; global Re;

x_res = zeros(6,1);

% calculate 3 Cartesian components of the magnetic field

Magnetic dipole
fac1 = -B0*Re^3/(x_vect(1)^2 + x_vect(2)^2 + x_vect(3)^2)^2.5;
Bx = 3*x_vect(1)*x_vect(3)*fac1;
By = 3*x_vect(2)*x_vect(3)*fac1;
Bz = (2*x_vect(3)^2 -x_vect(1)^2- x_vect(2)^2)*fac1;

qom = q/m;
x_res(1) = x_vect(4); % dx/dt = u
x_res(2) = x_vect(5); % dy/dt = v
x_res(3) = x_vect(6); % dz/dt = w
x_res(4) = qom*(x_vect(5)*Bz - x_vect(6)*By); % du/dt = qom*(vel x B)_x
x_res(5) = qom*(x_vect(6)*Bx - x_vect(4)*Bz); % dv/dt = qom*(vel x B)_y
x_res(6) = qom*(x_vect(4)*By - x_vect(5)*Bx); % dw/dt = qom*(vel x B)_z

endfunction
Case p+ 10 MeV pitch angle = o
30 at t = 50 s

plot3(x_sol(:,1)/Re,x_sol(:,2)/Re,x_sol(:,3)/Re);
xlabel('x[Re]')
ylabel('y[Re]')
zlabel('z[Re]')
title('Proton 10 MeV starting from x = 4Re, y = 0, z = 0')
hold on;
sphere(40);
hold off;
 Is Kinetic Energy Conserved ? Yes!

Kinetic Energy [J]

time [s]
u 2 v2 w 2
plot(time,0.5*m*(x_sol(:,4).^2 + x_sol(:,5).^2 + x_sol(:,6).^2))
arged particle 65

Charged particles can be

trapped in the magnetic
mirrors formed by a dipolar
planetary magnetic field. Their
motion is the superposition of
three components: 1) the
gyration around a field line 2)
the bounce between magnetic
mirrors in opposite
hemispheres 3) azimuthal drift
produced by the transverse
magnetic field gradient.

rged particles can be trapped in the magnetic bottle formed by

ry magnetic field. Their motion is the superposition of three
Mirror effect in Earths Dipole
A 10 MeV proton with a pitch
bounce motion angle of = 30 starting at 4RE is
trapped in the Earth magnetic
field. The particle performs a
hierarchy of three periodic
motions: gyration about the field
line, bouncing between the mirror
points, and a slow (toroidal) drift in
the equatorial plane
drift motion
 Bounce Motion
Bounce motion proceeds
along the field lines. The
motion slows down as it
moves towards locations
with stronger magnetic
field, reflecting back at the
mirror points. The bounce
motion is much slower than
the cyclotron motion.
time [s]

plot(time,x_sol(:,3)/Re)
xlabel('time [s]')
ylabel('z [Re]')
 Bounce Period
As you saw in class period, for pitch angle approximately = 90 o the bounce
frequency:
3v
B =
2R0
R0 = equatorial distance to the guiding line

Therefore, the bounce perod is:

2 2R0
B =
3v
 Drift Motion
The drift motion takes x0 = 2Re x0 = 4Re
particles across field lines
(perpendicular to the bounce
motion). In general drift
motion is faster at larger
distances. Particles in dipole
magnetic field lines are
trapped on closed drift
shells as long as they are not
perturbed by collisions or
interactions with EM waves
x [Re]

plot(x_sol(:,1)/Re,x_sol(:,2)/Re,'r')
 Van Allen Radiation Belts
The Earth's Van Allen Belts consist of
highly energetic ionized particles trapped
in the Earth's geomagnetic fields.

They can be found from 1000 km above

the ground up to a distance of 6 Re. These
belts are composed of of electrons with
Energies up to several MeV and proton
with energies up to several hundred MeV.
The dynamics of these particles has been
presented in the simulations From: http://en.wikipedia.org/wiki/Van_Allen_radiation_belt
An Atlas 5 rocket launches
NASA's Radiation Belt
Storm Probes (RBSP)
mission, twin probes that will
study the effects of the solar
wind stream on electrons and
ions in Earth's radiation belts,
such as how they change during
geomagnetic storms. Launch
took place in the pre-dawn
hours of August 30
 Guiding-Center Equations
The guiding center is the geometric center of cyclotron motion. We will
calculate the trajectory of the guiding center.
The particle position r is substituted with:r = R +
Assuming that the cyclotron radius is much smaller than the length scale of the
field we can expand B around R to first order in Taylor series: B(r) = B(R) + ( )B
This expression is substitute into the Newton-Lorenz
equation and the equation is averaged over a gyro-period,
eliminating rapidly oscillating terms containing
and its derivatives
 Guiding-Center Equations
curvature gradient drift and motion along the field
2
dR mv 2 v//
= (1 + )
b
B + v// b
dt 2qB 2 v 2
mirror force The unknowns are the three
dv// coordinate of the guiding
= b B
dt m center and the parallel (to
B) velocity
2
mv is the magnetic moment
=
2B
Octave Code for solving GC equations (GC_TrajMagnDipole.m)
close all;
clear all;
global B0; global q; global m; global Re; global v_mod; global v_par0;
% parameters
e = 1.602176565e-19; % Elementary charge (Coulomb)
m_pr = 1.672621777e-27; % Proton mass (kg)
m_el = 9.10938291e-31; % Electron mass (kg)
c = 299792458; % speed of light (m/s)
% Earth parameters
B0 = 3.07e-5 % Tesla
Re = 6378137 % meter (Earth radius)
% use electron/proton
m = m_pr % replace m_pr with m_el for electron
q = e
Simulation parameters
% Trajectory of a proton with 10MeV kinetic energy in dipole field
K = 1e7 % kinetic energy in eV
K = K*e; % convert to Joule
% Find corresponding speed:
v_mod = c/sqrt(1+(m*c^2)/K)
% initial position
x0 = 4*Re;
y0 = 0;
z0 = 0;

pitch_angle = 30.0 % initial angle between velocity and mag.field (degrees)

% initial parallel velocity
v_par0 = v_mod*cos(pitch_angle*pi/180);

tfin = 50.0 % in s
time = 0:0.01:tfin;
lsode_options("integration method","stiff");
[x_sol,t] = lsode("Newton_LorenzGC",[x0 ;y0; z0; v_par0],time);
plot3(x_sol(:,1)/Re,x_sol(:,2)/Re,x_sol(:,3)/Re);
simulation
 Guiding Center Function Newton_Lorenz.m
function x_res = Newton_LorenzGC(x_vect,t)
% x_vect(1) = x
% x_vect(2) = y
% x_vect(3) = z
% x_vect(4) = vpar = parallel (to B) velocity
global B0; global q; global m; global Re; global v_mod; global v_par0;
x_res = zeros(4,1);
vsq = v_mod^2; % This remains unchanged in present of a static B field
fac1 = -B0*Re^3/(x_vect(1)^2 + x_vect(2)^2 + x_vect(3)^2)^2.5;
Bx = 3*x_vect(1)*x_vect(3)*fac1;
By = 3*x_vect(2)*x_vect(3)*fac1;
Bz = (2*x_vect(3)^2 -x_vect(1)^2- x_vect(2)^2)*fac1;

we calculate !
B_mod = sqrt(Bx*Bx + By*By + Bz*Bz);
mu = m*(vsq-x_vect(4)^2)/(2*B_mod); % magnetic moment is an adiabatic invariant
d = 0.001*Re;
% calculate grad(module of B)
gradB_x = (getBmod((x_vect(1)+d),x_vect(2),x_vect(3)) - getBmod((x_vect(1)-d),x_vect(2),x_vect(3)))/(2*d);
gradB_y = (getBmod(x_vect(1),(x_vect(2)+d),x_vect(3)) - getBmod(x_vect(1),(x_vect(2)-d),x_vect(3)))/(2*d);
gradB_z = (getBmod(x_vect(1),x_vect(2),(x_vect(3)+d)) - getBmod(x_vect(1),x_vect(2),(x_vect(3)-d)))/(2*d);
% b unit vector
b_unit_x = Bx/B_mod;
b_unit_y = By/B_mod;
b_unit_z = Bz/B_mod;
% b unit vector cross gradB we need an extra function getBmod.m
bxgB_x = b_unit_y*gradB_z - b_unit_z*gradB_y;
bxgB_y = b_unit_z*gradB_x - b_unit_x*gradB_z;
bxgB_z = b_unit_x*gradB_y - b_unit_y*gradB_x;
% b unit vector inner product gradB
dotpr = b_unit_x*gradB_x + b_unit_y*gradB_y + b_unit_z*gradB_z;
fac = m/(2*q*B_mod^2)*(vsq + x_vect(4)^2);
x_res(1) = fac*bxgB_x + x_vect(4)*b_unit_x;
x_res(2) = fac*bxgB_y + x_vect(4)*b_unit_y;
x_res(3) = fac*bxgB_z + x_vect(4)*b_unit_z;
x_res(4) = -mu/m*dotpr;
endfunction
Case p+ 10 MeV pitch angle = o
30 at t = 50 s

gyro-motion averaged out

 Guiding Center Results
Full Newton Lorenz equation GC approximation

x [Re] x [Re]
 Advantages of GC approach
For numerical stability reason, the time step in the computer
simulations needs to be a fraction of the fastest time scale in the
system (in this case the gyro-period). T = 2*pi*m/(abs(e)*B); .When
we simulate electron the gyro-period can become very small
imposing a very small simulation time step (simulation will take long
time).

Because the GC approximation removes the gyration motion from

the model, we take time step that are larger than the gyro-period
and the simulation will take less time.
 Validity of GC approximation
We derived the GC equation assuming that the Larmor radius is much
smaller than the length scale of the field.

In presence of magnetic null or weak magnetic field, GC approximation

is not valid. This approximation is often used in simulation of fusion
devices where you have very strong magnetic field.

When you have highly energetic particles, the Larmor radius might
become comparable or larger than the length scale of the magnetic
field (in the case of Earths magnetic dipole). In this case, the GC
approximation is not valid.