Báo cáo y học hạt nhân và kĩ thuật xạ trị đề tài" Lí thuyết động học của electron tring Klystron" pdf

BÁO CÁO
Y HỌC HẠT NHÂN VÀ KĨ THUẬT XẠ TRỊ
Đề tài: Lí thuyết động học của electron trong Klystron


Giáo viên hướng dẫn: Nguyễn Thái Hà
SV thực hiện: Nguyễn Nhân Tĩnh
Lớp : DTYS – K52
SHSV: 20072926
1. Giới thiệu
Klystron là một thiết bị quan trọng trong máy gia tốc tuyến tính. Nó
có chức năng tạo ra vi sóng công suất lớn để gia tốc chùm điện tử. Ở trong
bài báo cáo này, em đề cập tới quá trình điện tử đi trong Klystron, cụ thể ở
đây là khoang tạo búi. Các công thức, phương trình thể hiện sự chuyển động
đó. Đây cũng là các công thức chính để thiết kế một Klystron. Lí thuyết mà
em trình bày dưới đây nói lên sự quan trọng của hệ số ghép đôi (coupling
coefficient) và các chùm điện tử đi trong các khoang . Điều này rất quan
trọng, đặc biệt ở các sóng cỡ millimet, hoặc nguồn năng lượng có biên độ
đỉnh rất lớn. Ở những sóng này sự ảnh hưởng của các khoang tới nhau là tất
yếu.
Bài báo cáo bao gồm hai phần đó là sự hình thành các búi điện tử
trong khoang tạo búi của Klystron và lí thuyết về hệ số ghép đôi.

2. Lí thuyết về sự tạo búi của điện tử
2.1 Lịch sử hình thành của Klystron:
Để tạo nên được Klystron như ngày nay, là sự đóng góp của rất nhiều
người, từ lí thuyết cho tới thực tế. Ta sẽ điểm qua quá trinh hình thành
nên Klystron.
Người được nhắc đến đầu tiên phải là D.A Rozhansky, giáo sư vật lí ở
trường Tổng Hợp Leningrad. Năm 1932 ông là người đầu tiên đưa ra
phương pháp tạo chùm điện tử có “mật độ biến thiên”. Tuy nhiên ông lại
không tạo ra chùm điện tử để kiểm tra lí thuyết của ông, và chính lí
thuyết đó ông cũng không công bố. Tuy nhiên ông cũng làm việc với
nhiều nhà vật lí trẻ trong học viện của ông, trong đó có Agnessa
Arsenjeva, vợ của Oskar Heil.
Vợ chồng nà Heil đã công bố các bài báo kinh điển về điều chế vận
tốc và tạo búi điện tử vào năm 1935. Trước đó vào năm 1934 họ đã chế
tạo ống điều chế vận tốc của điện tử
Trong thời gian trước thế chiến thứ II, WW. Hansen, một phó giáo sư
của đại học Standford, trong chương trình nghiên cứu chế tạo điện tử
điện áp cao để sử dụng trong phổ tia X. Trong quá trình nghiên cứu ông
đã tạo ra khoang vi sóng (cộng hưởng mà không phụ thuộc vào tụ điện và
cuộn cảm, nên thực hiện ở điện áp, tần số cao, hiệu suất lớn). Ông cũng
phát triển lí thuyết, làm các thành phần mạch, và nêu lên các lí thuyết đầu
tiên về cho các khoang riêng có hình dạng khác nhau.
Làm việc với Hansen ở học viện có hai anh em nhà Varian. Russell-
một nhà vật lí, và Sigurd một phi công của hãng hàng không Mỹ Pan.
Ngày 21-7-1937 Russ Varian đã viết trong nhật kí của mình một phác
thảo về Oscillator hai khoang, và một tháng sau đó ông và anh trai của
mình đã chế tạo nên nó. Việc sử dụng khoang cộng hưởng do Hansen chế
tạo ra có nhiều hữu ích hơn là do vợ chồng nhà Heil làm ra năm 1934.

Cũng trong năm đó, khái niệm klystron ra đời.

2.2 Cấu tạo Klystron
Klystron bao gồm :
- Cathode
- Anode
- Khoang tạo búi
- Khoang cộng hưởng (khoang bẫy điện tử)
- Các lưới gia tốc
- Collector
- Bộ phận làm mát
- Nguồn cung cấp
(Hình vẽ của một Klystron cơ bản như hình 1)
Ở trong khuôn khổ bài tìm hiểu này, em chỉ đề cập chủ yếu tới hai khoang
cơ bản trong Klystron là khoang tạo búi và khoang cộng hưởng.

Hình 1: Cấu tạo của klystron
2.3 Xây dựng hệ thức động học

Khi đặt điện áp vào sợi đốt ở cathode, sợi đốt được nung nóng và phát
xạ ra điện tử. Giữa hai đầu cathode và anode có điện áp V
0
nên điện tử phun
ra từ cathode sẽ được gia tốc bởi điện trường. Khi ra khỏi lưới 1, chùm điện
tử có vận tốc v
o
và đi vào buồng đầu tiên là buồng tạo búi điện tử. Tại đây,
chùm điện tử được kích thích bởi một nguồn sóng radio công suât thấp gọi là
RF driver.

Hình 2: Klystron hai khoang

Phương trình của sóng RF: V
1
.sin(ωt)
Động năng của e sau khi đi ra khỏi lưới là:


.m.v
0
2
= e.V
0
(1)
ở đây e là điện tích của điện tử. Sau khi ra khỏi lưới, chùm e sẽ chịu
tác động của sóng điện từ (RF). Giả sử sau khi chịu tác động của RF, chùm e
có vận tốc là “v” ta có biểu thức liên hệ:


.m.v
2
-


.m.v
0
2
= e.M.V
1
.sin(ωt) (2)

Với M là hệ số ghép đôi (coupling coefficient) – ta sẽ tìm hiểu về hệ
số này sau
Từ đó ta có:
v = v
0.
1
0
1 sin( )
MV
t
V


(3)
Ta có công thức gần đúng sau:
Với x <<1 thì ta có: (1 + x)
n
≈ 1 + nx
ở đây nếu ta có: V1 << V0 thì:
v = v
0
(1 +
1
0
sin
2.
MV
t
V


) (4)
Ta giả thiết, khoảng cách giữa hai khoang trống là “l”, tại thời điểm t
1

thì chùm điện tử ở trung tâm khoang tạo búi, sau khi đi qua khoang trống tới
trung tâm khoang bẫy điện tử ở thời điểm t
2
.
 t
2
= t
1
+



= t
1
+
1
0
0
.
v (1 sin )
2.
l
MV
t
V




≈ t
1
+


-
1
1
0
sin
2. .
o
lMV
t
vV

(5)
Nhân cả hai vế với ω ta có:
ω.t
2
= ωt
1
+ ω.


– ω.

1

1
0
sin
2. .
o
lMV
t
vV


ωt
2
= ωt
1
+ θ
0
– Xsin(ωt
1
) (6)
Với θ
0
=
0
1
v

và X =
1
00
2

lMV
vV

gọi là các hệ số búi. Chúng ta sẽ khảo sát sự
ảnh hưởng của θ
0
và X tới sự hình thành các búi điện tử.
Dựa vào công thức (6) ta thấy, ωt
2
là một hàm số của ωt
1
. Ta bắt đầu khảo
sát. Coi ωt
1
là một biến.
- Khi X = 0. => ωt
2
= ωt
1
+ θ
0
. Đây là đường thẳng qua gốc
- Khi X tăng dần lên ta có hàm bắt đầu uốn cong gần theo dạng hình sin
- Khi X > 1 ta có ωt
2
là một hàm đa trị của ωt
1

Tức là khi X >1 thì với mỗi giá trị của ωt
2

ta có thể tìm được nhiều giá trị
của ωt
1
, hay khi ta tăng dần giá trị của X thì chùm điện tử bắt đầu tạo búi với
các giá trị X gần giống nhau, còn với các giá trị X < 1, đồ thị là đơn điệu,
hay cùm điện tử chuyển động tự do, đơn lẻ mà không chuyển động cặp với
nhau.





Đồ thị biểu diễn sự phụ thuộc của ω.t
2
vào ω.t
1
với ảnh hưởng của hệ số búi
X:

Hình 2: Đồ thị thể hiện pha bắt đầu và tới của điện tử trong Klystron hai
khoang như một hàm của hệ số tạo búi X
Ta gọi số lượng điện tích đi từ khoang tạo búi từ thời điểm t
1
tới t
1
+ dt
1
là
Io.dt
1

và tại t
1
= 0 thì I
0
chính là cường độ dòng điện tử đi vào khoang và bắt
đầu tạo búi. Điện tích này rời khỏi khoang tạo búi, qua drift space tới khoang
bẫy điện tử, ở thời điểm t
2
tới t
2
+ dt
2
. Gọi It là dòng tổng tới được khoang
bẫy điện tử bao gồm dòng một chiều của điện tử và xoay chiều của sóng RF,
thì theo định luật bảo toàn điện tích ta luôn có:
Io.dt
1
= It.dt
2
(7)
Trở lại với phương trình (6). Vi phân 2 vế của phương trình (6) ta có:
d(ω.t
2
) = d(ωt
1
) – Xcos(ωt
1
).d(ωt
1
)

bỏ ω ở cả hai vế ta có:
d(t
2
) = d(t
1
) – Xcos(ωt
1
)d(t
1
)
ωt
2

ωt
1


2
1
()
()
dt
dt
= 1 – X.cos(ωt
1
) (8)
kết hợp với (7) ta có:
It
Io

= 1 – Xcos(ωt
1
)
 It =
1
1 cos( )
Io
Xt



Từ công thức (9) ta có thể thấy sự phụ thuộc của dòng điện tử vào X.
Tức là X chính là nhân tố tạo nên dạng sóng của dòng điện tử.
Khi X = 0, It = Io => sóng là một đường thẳng.
Khi X nhỏ: It  I
0
(1 + Xcos(ωt
1
)) dạng sóng ta thu được là hình sin.
Khi ta tăng dần X lên, ta thấy dòng điện tử bắt đầu xuất hiện các búi,
và khi X  1 thì các búi này bắt đầu tách hẳn nhau ra, các điện tử sẽ đi
thành từng búi riêng biệt với nhau, tùy vào hệ số X của mỗi điện tử.
Chú ý X =
1
00
2
lMV
vV


Đồ thị của It với sự ảnh hưởng của tham số X:

Hình 3: dạng sóng của búi điện tử phụ thuộc vào X
( code vẽ đồ thị thể hiện sự thay đổi bằng Matlab phụ lục)
Kết luận:
Với sự tác động của sóng RF, thì chùm điện tử được tăng tốc hoặc giảm tốc
theo các búi gọi là búi điện tử có vận tốc gần nhau.
Vì It là hàm tuần hoàn của ωt
2
, vì vậy ta có thể phân tích nó thành chuỗi
Fourier như sau:
It = Io +
2 0 2 0
1
[ cos ( ) sin ( )]
nn
a n t b n t
   


  

(11)
Với các hệ số a
n
và b
n
được cho bởi:
a
n
=
0
0
2 0 2
1
cos ( ) ( )
t
I n t d t


  





(12)
Và:
b

n
=
0
0
2 0 2
1
sin ( ) ( )
t
I n t d t


  





(13)
Ta có: ωt
2
= ωt
1
+ θo – Xsinωt
1

 ωt
2
– θo = ωt
1
– Xsinωt

1

Ta lại có: I
t
.d(ωt
2
) = Io.d(ωt
1
)
Lần lượt thế vào phương trình (12) và (13) ta có:
a
n
=
0
1 1 1
cos ( sin( )) ( )
t
I
I n t X t d t


  




(14)
Và :
b
n

=
0
1 1 1
sin ( sin( )) ( )
t
I
I n t X t d t


  




(15)
Ta thấy ở biểu thức thứ (15) thì hàm số dưới dấu tích phân là hàm lẻ của ωt
1
, và
cận tích phân thì đối xứng nhau:
 b
n
= 0
Nó chỉ ra rằng biểu thức (14) cho hệ số a
n
biểu diễn cho hàm bessel của dạng
đầu tiên và dạng thứ n :
a
n
= 2.I
0

J
n
(nX) (16)
Do đó thì tại khoang bẫy điện tử thì dòng It có thể viết lại thành:
0 0 1 0
1
2 ( )cos ( )
tn
I I I J nX n t


  

(17)
Khi n = 1 thì ta có dạng đơn giản của dòng I
t
là:
0
()
1 0 1 0 0 1
2 ( )cos( ) Re[2 ( ) ]
jt
I I J X t I J X e



  
(18)
Khi X < 1, ta có trong phương trình (17) hội tụ với mọi giá trị của t2. Cho X
= 1 và X > 1, ta cho t

2
thay đổi ta sẽ thu được như hình vẽ (5)

Hình 5: Hàm Bessel của biến nX.
J
1
đạt giá trị cực đại tại nX = 1.84 và giá trị cực đại là 0.582
Biên độ điều hòa tương ứng với đỉnh của hàm Bessel. Nếu dòng It là một chuỗi
các hàm δ thì tất cả các hàm điều hòa sẽ bằng nhau. Trong trường hợp này, nó
gần như bằng nhau.
3. Phân tích tín hiệu nhỏ cho hệ số tạo cặp:
Lý thuyết Feenberg và hầu hết các cuốn sách về Klystron xuất bản những năm
40 và đầu những năm 50 về thiết kế của Klystrons tất cả đều giả thiết là v
0
<< c.
Tuy nhiên với các máy Klystrons có công suất lớn, thì sự chuyển động của điện
tử là lớn, nó có thể đạt tới vận tốc cỡ c/3 hoặc hơn nữa, vì vậy lí thuyết về
chuyển động tương đối của điện tử là rất cần thiết trong thiết kế các Klystron và
máy gia tốc như thế này.
Và tiếp tục ta sẽ xác định một hệ số là hệ số tạo cặp – M. Trong chế tạo
Klystron, thì có lẽ hệ số M là một hệ số quan trọng nhất. Hệ số khuếch đại của
tín hiệu phụ thuộc trực tiếp vào hệ số M, (g = M
2n
, trong đó n là số khoang cộng
hưởng). Hệ số M này cũng rất nhạy cảm với đường kính chìm tia, trong khi
chẳng bao giờ ta có thể biết một cách chính xác giá trị đó. Do đó, những khác
biệt trong tính toán hoặc mô phỏng sự khuếch đại của Klystron luôn luôn bắt
nguồn từ sự không chính xác đó. Nó là cả một vấn đề mà ta không dễ giải
quyết. Chúng ta sẽ bắt đầu tìm hiểu nó.
Chúng ta bắt đầu với phương trình chuyển động của điện tử trong khoảng

không lưới với điện trường E(z) được định nghĩa như sau:
E
z
(z,t) = E
m
f(z)e
jωt

Trong đó thì f(z) là “field shape factor” – FSF.
Và E
m
liên hệ với điện thế V
1
của sóng radio đi qua khoang trống qua phương
trình:
V
1
=
0
( , )
d
z
E z t dz

=
j
0
( )e
d
t

m
E f z dz


(21)
Ta sẽ xét thông thông số, đó là α, ta gọi nó là độ sâu điều chế của chùng điện tử.
α =


(22)
với các tín hiệu nhỏ thì α << 1
ta bắt đầu xét sự gia tốc của điện tử bắt đầu qua trường của khoang trống :
2
2
( , ) ( )
jt
m
d z e e
E z t E f z e
dt m m


(23)
ta nhân hai vế của phương trình (23) với 2dz, ta sẽ thu được bình phương của vi
phân vận tốc v:
2
2
2
dz d z
dt

dt dt
=
2
2 ( )
d dz
dt
dt dt
= 2E
m
f(z)e
jωt
dz (24)
Nếu trường điện từ trong khoang trống nhỏ ( α << 1), lúc đó vị trí của điện tử
tại thời điểm t có thể tính xấp xỉ theo công thức:
0
vt
 z (25)
Chúng ta đặt
0
e
v



“the beam propagation factor”. Nhân 2 vế của phương
trình (25) với
e

ta được:
ωt =

e

z (26)
Như vậy ta có được công thức liên hệ giữa t và z. Ta thế ωt bởi
e

z vào phương
trình (24)
2
2 ( )
d dz
dt
dt dt
= 2E
m
f(z)
e
z
e

dz
Loại bỏ 2, chú ý: v =
dz
dt
, tích phân 2 vế:
j
22
0
0
2 ( )e

e
d
z
m
e
v v E f z dz
m





2
2
j
0
0
( )e
22
e
d
z
m
mv
mv
eE f z dz



(27)

Ở đây v là vận tốc của điện tử ở cuối của khoang trống, v
0
là vận tốc tương ứng
với điện thế của chùm điện tử V
0
. Từ phương trình (27) ta thấy: vế trái của
phương trình là hiệu động năng của điện tử ở và cuối khoang trống, sự thay đổi
động năng này của điện tử khi đi được một khoảng cách có thể được biểu diễn
bởi một điện thế gọi là điện thế hiệu dụng V
eff

∆w =
2
2
0
22
mv
mv

= eV
eff

Thế vào phương trinh (27) :
V
eff
=
j
0
( )e
e

d
z
m
E f z dz


=
j
z
0
E (z,t)e
e
d
z
dz


(28)
Ta thiết lập tỉ số giữa điện thế hiệu dụng này với tích phân của điện trường
trong ống, và định nghĩa tỉ số này, gọi là hệ số tạo cặp – M ( coupling
coefficient)
j
0
0
( )e
()
()
e
d
z

z
e
d
z
E z dz
M
E z dz





(29)
Ta thấy hệ số tạo cặp M là một đại lượng không thứ nguyên, nó chỉ phụ thuộc
vào yếu tố định dạng trường ( f(z)). Nếu trường là một hằng số, thì tích phân ở
mẫu là không đáng kể.






Ta có thể tổng quát hóa phương trình (29), bằng tích phân suy rộng, tức là cận
lấy tích phân sẽ là toàn bộ trục z.

khi đó thì z sẽ không chỉ ở trong khoảng (0;d) mà là
( ; ) 
. Như hình vẽ (6)
j
e

1
( )e
()
()
e
z
z
ff
e
z
E z dz
V
M
V
E z dz









(30)
Nói cách khác, M là kết quả của tích chập điện trường
()
z
Ez
với số mũ

j
e
e
z


(V
eff
)chia cho điện thế qua khoang trống (V
1
)









TÀI LIỆU THAM KHẢO
1. High Power Klystrons: Theory and Practice at the Stanford Linear
Accelerator Center
- George Caryotakis
2.
3.
4.
5.
6.

Và một số tài liệu khác




























PHỤ LỤC

Tạo búi điện tử trong Klystron hai khoang:
Chương trình được viết bởi C++, sử dụng thư viện đồ họa Mesa.
The white coloured vertical line to the left of each screenshot is the buncher
cavity, and a similar line towards the right in each screenshot is the catcher cavity. A
small horizontal line over the virtical buncher cavity line shows the direction to the
instantaneous RF field applied at the buncher cavity. The length of the horizontal line
shows the strength of the electric field. The white dots, representing electrons, are
generated randomly and pop onto the screen from the left side. As they move towards the
right through the buncher cavity, their velocity is changed due to the RF field applied to
buncher cavity. This change in the velocity of electrons causes "velocity modulation"
which in turn causes bunching of the electrons as they travel towards the catcher cavity
Fig
1.1
Here the electric field is directed towards the right. So the electrons entering from
the left side get retarded.

Fig
1.2
The electric field is now directed towards the left, thus accelerating the electrons
coming from the left. These accelerated electrons are going to bump onto the
previously slow moving retarded electrons. Such bunching can be seen taking place
in the middle of the Klystron.


Fig
1.3
A big bunch of electrons thus formed can be seen moving towards the catcher
cavity.











Fig
1.4
The electron bunch passes through the catcher cavity inducing sinusoidal
oscillations whose magnitude will depend on the amount of bunching that has

taken place. These sinusoidal oscillations induced are conceptually similar to those
that are induced in a class C amplifier.



Sau đây là code của chương trình:
#include <GL/gl.h>
#include <GL/glut.h>

#include <stdio.h>
#include <math.h>
#include <unistd.h>
#include <stdlib.h>
#include <vector>
#include <iostream>
using namespace std;



///////////////////////////////////////////////////////////////////////////
// Time
///////////////////////////////////////////////////////////////////////////

float t;
float dt = 0.01;

void advance_time ()
{
t += dt;
}

///////////////////////////////////////////////////////////////////////////
// Sinusoid
///////////////////////////////////////////////////////////////////////////


class Sinusoid
{
public:
float w; // radian frequency
float A; // Amplitude

Sinusoid (float frequency_ = 1, float amplitude_ = 1);
float value ();
};

Sinusoid::Sinusoid (float frequency_, float amplitude_)
{
w = frequency_;
A = amplitude_;
}

float Sinusoid::value ()
{
return A * sin(w * t);
}

///////////////////////////////////////////////////////////////////////////
// Electron
///////////////////////////////////////////////////////////////////////////

enum ElectronState {
Invalid,
Valid
};

class Electron
{
public:
float x, y;
float velocity;
enum ElectronState state;
bool affected_by_rf;

public:
Electron ();
~Electron ();

void reset ();
void advance ();
};

Electron::Electron ()
: x(0), y(0), velocity(0), state(Invalid), affected_by_rf(false)
{
}

Electron::~Electron ()
{
}

void Electron::reset ()
{
x = 0;
y = 0;
affected_by_rf = false;
state = Invalid;
}

void Electron::advance ()
{
x += velocity;
}


///////////////////////////////////////////////////////////////////////////
// Surface
///////////////////////////////////////////////////////////////////////////

class Surface
{
public:
const int width;
const int height;
Surface ();
~Surface ();

};

Surface::Surface ()
: width(800), height(100)
{
}

Surface::~Surface ()
{
}


///////////////////////////////////////////////////////////////////////////
// Klystron
///////////////////////////////////////////////////////////////////////////

// The vector of Electrons will grow initially. As the cavity gets
// full with electrons, the size of the vector will stabilize


struct BuncherCavity
{
int x;
};

struct CatcherCavity
{
int x;
};

class Klystron
{
public:
vector<Electron> elist;
Sinusoid rfsignal;
Surface surface;
BuncherCavity buncher_cavity;
CatcherCavity catcher_cavity;

public:
Klystron ();
~Klystron ();

void randomize_electron (Electron&);
void iterate ();
void draw ();
void draw_electrons ();
};


Klystron::Klystron ()
: rfsignal(1, 1.5)
{
srand (time(0));
elist.reserve (100);
buncher_cavity.x = 100;
catcher_cavity.x = 700;
}

Klystron::~Klystron ()

{
}

void Klystron::randomize_electron (Electron& e)
{
e.x = 0;
e.y = 100. * (((float) rand ()) / RAND_MAX);
e.velocity = 3.0;
}

void Klystron::draw ()
{
glColor3f(.5,.5,.5);
glBegin (GL_LINE);
glVertex2i (buncher_cavity.x, -100);
glVertex2i (buncher_cavity.x, 200);
glEnd ();

glBegin (GL_LINE);
glVertex2i (catcher_cavity.x, -100);
glVertex2i (catcher_cavity.x, 200);
glEnd ();

glColor3f(1,1,1);

glBegin (GL_LINE);
glVertex3f ((float)buncher_cavity.x, 100+30., 0.);
glVertex3f ((float)buncher_cavity.x - 10 * rfsignal.value(), 100+30., 0.);
glEnd ();

draw_electrons ();
}

void Klystron::draw_electrons ()
{
glBegin (GL_POINTS);
for (unsigned i = 0; i < elist.size(); i++) {
if (elist[i].state == Valid)
glVertex3f (int(elist[i].x), int(elist[i].y), 0);
}
glEnd ();
}

void Klystron::iterate ()
{
// calculate the number of new electrons to be added
int n = int (4.0 * float(rand()) / RAND_MAX);

// cout << "elist size = " << elist.size() << endl;

for (int i = 0; i < elist.size(); i++) {
if (!elist[i].affected_by_rf &&
elist[i].x <= buncher_cavity.x &&
elist[i].x + elist[i].velocity > buncher_cavity.x) {

//cout << "RF signal strength = " << rfsignal.value() << endl;
elist[i].velocity += rfsignal.value();
elist[i].affected_by_rf = true;
}

elist[i].advance ();
for (unsigned j = 0; j < elist.size(); j++) {
if (i == j)
continue;

if (fabs(elist[i].y - elist[j].y) < 2.5 && fabs(elist[i].x -
elist[j].x) < 2.5) {
elist[i].velocity = (elist[i].velocity + elist[j].velocity) /
2.0;
elist[j].velocity = elist[i].velocity;
}
}

if (elist[i].x > surface.width) {
elist[i].state = Invalid;

if (n > 0) {
// cout << "Randomizing already existing electron, n = " << n
<< endl;
elist[i].reset ();
randomize_electron (elist[i]);
elist[i].state = Valid;

n ;
}
}
}

// Add electrons
// cout << "n = " << n << endl;

while (n > 0) {
// cout << "Adding electron" << endl;
elist.push_back (Electron());
randomize_electron (elist[elist.size()-1]);
elist[elist.size()-1].state = Valid;

n ;
}
}

// The only instance of the Klystron
Klystron klystron;


static void init ()
{
glClearColor (0,0,0,0);
}


static void display ()
{
int i, j;

glClear (GL_COLOR_BUFFER_BIT);
glLoadIdentity ();
glTranslatef (0,0,-500);

klystron.draw ();

glFlush ();
glutSwapBuffers ();
}


static void idle (void)
{
advance_time ();

// Advance the electrons according to their velocities
klystron.iterate ();

display ();
usleep (10000);
}

static void keyboard (unsigned char key, int x, int y)
{
switch (key) {
case 'q':
case 27:
exit (0);
break;
}
}


static void specialup (int key, int x, int y)
{
switch (key) {

}
}

static void reshape (int w, int h)
{
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glOrtho (0, w, -h/2., h/2., 1, 10000);

glMatrixMode (GL_MODELVIEW);
glViewport (0,0,w,h);
}

int main (int argc, char* argv[])
{
cout << endl;
cout << "Electron Bunching in a two cavity Klystron Amplifier" << endl;
cout << "\t" << "Programmed by Abhir Joshi <>" << endl;
cout << "\t" << "Visit <<
endl;
cout << endl;


glutInit (&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition (10,10);
glutInitWindowSize (640,480);
glutCreateWindow (argv[0]);
glutFullScreen ();

init ();

glutDisplayFunc (display);
glutReshapeFunc (reshape);
glutKeyboardFunc (keyboard);
glutSpecialUpFunc (specialup);
glutIdleFunc (idle);

glutMainLoop ();
return 0;
}


///////////////////////////////////////////////////////
// No code below this line
///////////////////////////////////////////////////////






// class Time
// {
// public:
// float dt;
// public:
// Time() : dt(0.01) {}
// inline float value () {

// return ::t;
// }
// inline void increment () {
// ::t += dt;
// }
// } time; // The global instance of Time :-)





// // Create electrons at random locations
// for (int i = 0; i < max_electrons; i++) {
// randomize_electron (electron[i]);
// }

// field_strength = 0;
// field_frequency = 1;
// time = 0;
// dt = 0.01;