Pada perancangan CPM ini, penulis menggunakan compiler Microsoft Visual C++ 2008 dan library yang digunakan adalah OpenCV v1.1, library ini menyediakan fungsi-fungsi yang akan digunakan untuk pengolahan citra.
Dalam penulisan dan pembuatan program, akan meliputi bagian-bagian penting dalam setiap langkah-langkah per bagian sesuai dengan algoritma atau logika sekuensial dari awal sampai output. Flowchart program secara global dijelaskan pada gambar 3.2.
Gambar 3.2. Flowchart program Penjelasan flowchart:
1. Inputkan citra sinar x tulang belakang yang akan diproses.
2. Citra yang telah diinputkan selanjutnya diproses menggunakan Modified Tophat filter
3. Citra hasil Modified Tophat filter selanjutnya diproses menggunakan Gaussian cropping. End Citra hasil segmentasi menggunakan CPM It erasi <1000 Hit ung gaya Lorent z Inisialisasi part ikel It erasi dimulai dari 0
Gaussian Cropping M odified Tophat filt er
Input Cit ra Sinar X Tulang Belakang
St art
T
Y
Hit ung gaya Coulomb Hit ung gaya t ot al Updat e posisi partikel It erasi bert ambah 1
4. Hitung gaya Lorentz dari citra hasil Gaussian cropping, digunakan sebagai medan gaya negatif.
5. Selanjutnya proses inisialisasi partikel-partikel yang nantinya akan bergerak menuju tepi dari tulang belakang yang berada di citra.
6. Proses iterasi dimulai dari 0 dan akan berulang sebanyak 1000 iterasi.
7. Hitung gaya Coulomb dari partikel-partikel, kemudian kalkulasikan dengan gaya Lorentz untuk mendapatkan gaya total, dari gaya total akan didapatkan posisi baru dari tiap partikel.
8. Citra hasil segmentasi akan didapatkan setelah langkah ke-7 berulang sebanyak iterasi yang ditentukan.
3.2.1. Perancangan Modified Tophat Filter
Tahap awal dari proses pre-processing adalah proses filtering untuk memperjelas citra tulang belakang dan mengurangi noise di sekitar tulang belakang menggunakan Modified Tophat filter.
Rumus Modified Tophat filter adalah : modTH= ∘
• × Ɣ ...(3.1) Dimana : f = citra gambar
b = struktur elemen
∘ = operator morfologi closing • = operator morfologi opening Ɣ = attenuation factor
Gambar 3.3. Flowchart Modified Tophat filter
Jika diprogram menggunakan rumus Modified Tophat filter, maka dapat ditulis code program sebagai berikut :
int disk = 5, factor = 11;
norMat(f, f32Image, 1);
IplConvKernel *B =cvCreateStructuringElementEx(2*disk+1, 2*disk+1, disk, disk, CV_SHAPE_ELLIPSE, 0); //B = disk(5) cvMorphologyEx(f32Image,TH,tempMat,B,CV_MOP_OPEN,1);//opening cvMorphologyEx(f32Image,CL,tempMat,B,CV_MOP_CLOSE,1);//closing
cvSub(TH,f32Image,TH); //TH=TH-f
cvDiv(TH, CL, modTH, factor); //ModTH=(TH/CL)*atten_factor norMat(modTH,modTH);
cvCopyImage(modTH,result);
Hasil yang diperoleh ditunjukan pada gambar 3.4 : End
Cit ra hasil modified t ophat filt er M odTH = x Ɣ
TH = TH – f TH = f ∘ B (opening)
CL = f • B (closing)
Inisialisasi st rukt ur elem en (B) = disk(5) dan At t enuat ion Fact or (Ɣ) = 11
Input Cit ra Sinar X (f) St art
Gambar 3.4. Hasil Modified Tophat filter
Perancangan Modified Tophat filter dimulai dengan melakukan operasi opening , yaitu proses erosi dilanjutkan dengan dilasi pada citra gambar dengan struktur elemen bertipe disk dengan ukuran 5. Hasil dari proses opening kemudian dikurangkan dengan citra awal dari citra gambar sehingga menyisakan tepi dari objek saja. Selanjutnya dilakukan proses closing menggunakan citra awal, yaitu proses dilasi yang dilanjutkan dengan erosi dengan menggunakan struktur elemen berukuran sama. Proses opening menyebabkan citra menjadi lebih mengembang, sebaliknya proses closing menyebabkan citra menyusut. Kemudian hasil dari opening dikurangi citra awal dibagi dengan hasil closing untuk menghilangkan sisa noise selanjutnya dikalikan dengan attenuation factor untuk memperjelas bentuk tepi.
3.2.2. Perancangan Gaussian Cropping
Tahap kedua dari proses pre-processing adalah dengan menghilangkan dan mereduksi noise pada bagian-bagian dari citra sinar x yang tidak diperlukan khususnya bagian kanan dan kiri dari citra tulang belakang menggunakan Gaussian cropping.
Rumus Gaussian cropping adalah : Gaussian =
( )
( ) ...(3.2) Keterangan : a = koordinat piksel pada citra
b = koordinat center of peak dari fungsi Gaussian c = standar deviasi
Gambar 3.5. Kurva fungsi Gaussian (Sugianto, 2013) Alur dari penggunaan Gaussian cropping bisa dilihat pada gambar 3.6 :
Gambar 3.6 Flowchart Gaussian cropping
Jika diprogram menggunakan rumus Gaussian cropping, maka dapat ditulis kode program sebagai berikut :
Nilai piksel = nilai piksel * gaussian Gaussian = ( ) ( ) Y == Y<height cit ra Inisialisasi garis Simpan koordinat dari
set iap garis ( , ) Y=0
Input Cit ra hasil M odTH St art Y T Y Nilai piksel = 0 Citra hasil segmentasi menggunakan CPM End T
int counter=0;
int jmlh_baru=jmlh;
//baris atas
for (int i=1;i<=koordinat[1][2];i++)
for (int j=0;j<=edge->width;j++)
edge->imageData[edge->widthStep*i + j*edge->nChannels]=0; //baris tengah
int index=1;
for (int y=koordinat[1][2];y<=koordinat[jmlh_baru][2];y++){
if (y==koordinat[index][2]){
y=koordinat[index][2]; float nilai=0;
for (int x=0;x<=edge->width;x++){
double gaussian=0; gaussian=((koordinat[index][1]-x) *(koordinat[index][1]-x)) / ((2*10)*(2*10)); gaussian=exp(-(gaussian)); nilai=(uchar)edge -> imageData[edge->widthStep*y + x*edge->nChannels]; edge->imageData[edge->widthStep * y + x* edge->nChannels]=nilai* gaussian; } index=index+1; }else{
for (int x=0;x<edge->width;x++){
edge->imageData[edge->widthStep * y + x*edge->nChannels] =(uchar)edge ->imageData [edge->widthStep*(y-1) + x*edge->nChannels];
} } }
//baris bawah
for (int y=koordinat[jmlh_baru][2];y<=edge->height-1;y++)
for (int x=0;x<=edge->width;x++)
edge->imageData[edge->widthStep*y + x*edge->nChannels]=0;
cvDestroyWindow("Gaussian Filter");
cvNamedWindow("Gaussian Filter",1);
cvShowImage("Gaussian Filter",edge);
//kosongkan SLL
while (!InitContour.empty()){ InitContour.pop_back(); }
std::cout<<"kosong"<<std::endl;
Kode program untuk proses inisialisasi diletakkan pada function terpisah, ditulis sebagai berikut:
void gausian(IplImage * img)
{
cvCopyImage(img,temp);
int k=0;
int l=0;
for (int x=0;x<InitContour.size();x++)
{
cvLine(temp, InitContour[k], InitContour[l], cvScalarAll(100), 1);
cvShowImage( "srcImage", temp ); k=l;
l=l+1; }
}
void filter( int event, int x, int y, int flags, void* ptr)
{ if(event == CV_EVENT_LBUTTONDOWN) { gausian((IplImage *)ptr); jmlh=jmlh+1; InitContour.push_back(cvPoint(x,y)); koordinat[jmlh][1]=x; koordinat[jmlh][2]=y; q=1; } if (q==1) { if (event==CV_EVENT_MOUSEMOVE) { gausian((IplImage *)ptr); jmlh=jmlh+1; InitContour.push_back(cvPoint(x,y)); koordinat[jmlh][1]=x; koordinat[jmlh][2]=y; } } }
Diawali dengan membuat inisialisasi pada citra tulang belakang menggunakan gerakan mouse dan menyimpan setiap titik yang dilewati oleh mouse. Untuk setiap titik tersebut akan menjadi titik puncak dari fungsi Gaussian sehingga semakin ke kanan dan ke kiri dari koordinat x dari titik puncak akan menghasilkan nilai Gaussian yang mendekati nilai 0, nilai Gaussian tersebut kemudian dikalikan dengan nilai piksel awal untuk menghasilkan nilai piksel yang baru. Penentuan nilai variabel c disesuaikan dengan lebar dari tulang belakang. Hasil yang diperoleh ditunjukan oleh Gambar 3.7.
Gambar 3.7 Hasil Gaussian cropping dengan nilai c=10
3.2.3. Perancangan Charged Particle Model (CPM)
Perancangan CPM meliputi perancangan negative field yang diaplikasikan sebagai gaya Lorentz citra sinar x dan partikel positif yang diaplikasikan sebagai gaya Coulomb. Setelah gaya Lorentz dan Coulomb didapat maka diteruskan dengan perhitungan pergerakan partikel. Partikel bergerak sebanyak 1000 iterasi, dimana tiap iterasinya dihitung nilai Coulomb, gaya total, kecepatan partikel, percepatan partikel, dan posisi partikel yang baru.
A. Perancangan Negatif Field
Gaya Lorentz pada citra berfungsi sebagai medan gaya negatif. Hasil perhitungan dari medan gaya negatif dan partikel positif ini yang menunjukkan arah partikel positif untuk bergerak. Perhitungan gaya Lorentz menggunakan
rumus yang ada pada persamaan (2.7). Alur dari perancangan gaya Lorentz sesuai dengan flowchart pada gambar 3.8.
Gambar 3.8. Flowchart menghitung gaya Lorentz Penjelasan flowchart:
1. Citra input didefinisikan sebagai variabel f.
2. Hitung Gradient Map dari f dan simpan dengan variabel (gx,gy).
3. Setelah mendapat (gx,gy), langkah selanjutnya adalah mencari nilai magnitude didefinisikan sebagai variabel e.
4. Dari variabel e langkah selanjutnya adalah menghitung energi potensial. 5. Hitung Gradient Map dari energi potensial hasil dari langkah sebelumnya,
6. Langkah terakhir adalah menghitung gaya Lorentz (FLx,FLy).
Yang jika diimplementasikan dalam bentuk program ditulis seperti di bawah ini :
IplImage *src;
CvMat *CH, *fx, *fy, *X, *Y, *x, *y; char gam[100], lok[100];
double ip,is,in,itot;
//load image grayscale --> src
strcpy(lok, "C:/2/fr10"); strcpy(gam, lok); strcat(gam, ".jpg"); src = cvLoadImage(gam, CV_LOAD_IMAGE_GRAYSCALE); CH = cvCreateMat(m, n, CV_32FC1); fx = cvCreateMat(m, n, CV_32FC1); fy = cvCreateMat(m, n, CV_32FC1); X = cvCreateMat(m, n, CV_32FC1); Y = cvCreateMat(m, n, CV_32FC1); x = cvCreateMat(1, n, CV_32FC1); y = cvCreateMat(1, m, CV_32FC1);
//menghitung gradient map terhadap sumbu x citra input --> fx
for(int j=0; j<m; j++){
for(int i=0; i<n; i++){
ip = ((double)src -> imageData [src->widthStep*j +
(i+1)*src->nChannels]);
is = ((double)src -> imageData [src->widthStep*j +
i*src->nChannels]);
in = ((double)src -> imageData [src->widthStep*j +
(i-1)*src->nChannels]); if(i==0){ itot = ip-is; }else if(i==n-1){ itot = is-in; }else{
itot = ((ip - is) + (is - in)) / 2; }
cvmSet(fx, j, i, itot); }
}
//menghitung gradient map terhadap sumbu y citra input --> fy
for(int j=0; j<m; j++){
for(int i=0; i<n; i++){
ip = ((double)src -> imageData [src->widthStep*(j+1) +
i*src->nChannels]);
is = ((double)src -> imageData [src->widthStep*j +
i*src->nChannels]);
in = ((double)src -> imageData [src->widthStep*(j-1) +
i*src->nChannels]); if(j==0){ itot = ip-is; }else if(j==m-1){ itot = is-in; }else{
itot = ((ip - is) + (is - in)) / 2; }
} }
//menghitung magnitude --> CH
for (int j=0; j<m; j++){
for (int i=0; i<n; i++){
double aa = cvmGet(fx, j, i); double bb = cvmGet(fy, j, i);
double cc = sqrt((aa * aa) + (bb * bb)); cvmSet(CH, j, i, cc);
} }
for (float i=0; i<n; i++){ cvmSet(x, 0, i, i+1); }
for (float i=0; i<m; i++){ cvmSet(y, 0, i, i+1); }
for (float j=0; j<m; j++){ for (float i=0; i<n; i++){
cvmSet(X, j, i, i+1); cvmSet(Y, j, i, j+1); }
}
for (int j=0; j<m; j++){
for (int i=0; i<n; i++){
LorentzForceX(X,Y,CH,cvmGet(x,0,i),cvmGet(y,0,j),i,j); LorentzForceY(X,Y,CH,cvmGet(x,0,i),cvmGet(y,0,j),i,j); }
}
Program diatas diletakkan pada void main(). Pada penjelasan flowchart nomor 4 dan 5 diatas dijadikan satu menjadi persamaan (2.6). Kemudian persamaan (2.6) disubstitusikan dengan persamaan (2.5) didapatkan persamaan (2.7) yang sudah mencakup langkah 4 sampai 6 pada penjelasan flowchart diatas, kode program tersebut diletakkan pada dua function berikut:
double LorentzForceX (CvMat* X, CvMat* Y, CvMat* CH, double x, double y, int I, int J)
double LorentzForceY (CvMat* X, CvMat* Y, CvMat* CH, double x, double y, int I, int J)
Kode program dari function diatas adalah sebagai berikut:
for (int s=0; s<m; s++){
for (int t=0; t<n; t++){
a = cvmGet(X, s, t); b = cvmGet(Y, s, t); cvmSet(Rx, s, t, a-x); cvmSet(Ry, s, t, b-y); } }//ri-Rk...(1) for (int s=0; s<m; s++){ for (int t=0; t<n; t++){ double a = cvmGet(Rx, s, t); double b = cvmGet(Ry, s, t); double c = (a*a)+(b*b); double d = sqrt(c*c*c); cvmSet(R, s, t, d); } }// (ri-Rk)^3...(2) for (int s=0; s<m; s++){ for (int t=0; t<n; t++){ double a = cvmGet(Rx, s, t); double c = cvmGet(CH, s, t); double d = a*c; if (d==(-0)) d=0; cvmSet(Rx, s, t, d); } }//ek * (ri-Rk)...(3) double ac=0; for (int s=0; s<m; s++){
for (int t=0; t<I; t++){
double a = cvmGet(Rx, s, t); //Ry untuk LorentzY double c = cvmGet(R, s, t);
double d = a/c; ac=ac+d;
}
}//jumlahkan semua nilai tiap piksel pada kolom ke-0 sampai (I-1) double fh=0;
for (int s=0; s<m; s++){
for (int t=I+1; t<n; t++){
double f = cvmGet(Rx, s, t); //Ry untuk LorentzY double h = cvmGet(R, s, t);
double i = f/h; fh=fh+i;
}
}//jumlahkan semua nilai tiap piksel pada kolom ke-(I+1) sampai n Ex=ac+fh; //jumlahkan kedua nilai di atas
double ac=0;
for (int s=0; s<J; s++){
double a = cvmGet(Rx, s, I); //Ry untuk LorentzY double c = cvmGet(R, s, I);
double d = a/c; ac=ac+d;
}//jumlahkan semua nilai tiap piksel pada kolom ke=i //baris ke-0 sampai (J-1)
double fh=0;
for (int s=(J+1); s<m; s++){
double h = cvmGet(R, s, I); double i = f/h;
fh=fh+i;
}//jumlahkan semua nilai tiap piksel pada kolom ke=i //baris ke-(J+1) sampai m
Ex=Ex+ac+fh; //jumlahkan kedua nilai di atas ditambah dengan nilai //Ex sebelumnya
return(Ex); //nilai Ex sebagai nilai akhir dari gaya LorentzX //Ey untuk LorentzY
Perhitungan nilai gaya Lorentz diatas diujicobakan pada citra berukuran 10x20 piksel seperti yang ditunjukkan pada Gambar 3.9.
Gambar 3.9. Citra berukuran 10x20 piksel
Nilai tiap-tiap piksel yang didapat dari hasil perhitungan gaya Lorentz dari gambar 3.9 terhadap sumbu x adalah sebagai berikut :
88.0136 132.995 143.097 68.1244 0.614066 -20.3432 -102.779 -161.597 -118.691 -75.7633 130.631 173.818 99.2419 -15.3685 -31.8323 -0.30634 -31.5865 -129.011 -154.236 -103.792 172.102 146.647 79.4903 3.68569 -55.6242 -9.41755 -55.1135 -103.836 -128.764 -127.789 175.5 104.518 54.2632 -3.33751 -81.0894 -0.77267 -42.7589 -72.8272 -96.6623 -127.571 171.356 88.0211 41.8488 -9.56371 -91.4246 2.34226 -34.1241 -58.9244 -81.4581 -121.924 167.42 82.3215 35.8796 -14.0223 -93.4487 4.26558 -28.6939 -52.4371 -76.9728 -120.273 167.521 80.2915 32.6223 -16.3481 -95.0389 5.21113 -26.5801 -49.958 -75.5929 -118.83 165.129 79.4959 31.0238 -18.3915 -95.754 5.40245 -26.406 -47.6149 -71.8976 -117.938 164.387 77.8843 29.1481 -19.0991 -97.118 5.17375 -24.7204 -46.008 -70.2287 -116.133 163.753 77.1663 28.1702 -19.8747 -97.6683 5.5132 -24.3757 -45.1108 -68.8029 -115.023 163.246 76.7536 27.7391 -20.2475 -97.8299 5.65636 -24.1892 -44.6319 -68.071 -114.374 162.942 76.5766 27.6421 -20.2936 -97.8277 5.70693 -24.0953 -44.4342 -67.7495 -113.974 162.849 76.718 27.9146 -20.0239 -97.6736 5.69847 -24.2137 -44.5416 -67.7276 -113.761 163.046 77.4008 28.8055 -19.2402 -97.2874 5.52523 -24.7741 -45.1849 -68.149 -113.765 163.744 79.3162 30.9802 -17.3622 -96.3358 4.7558 -26.4325 -47.0403 -69.5292 -114.091 165.171 84.7014 36.1198 -12.6919 -92.9475 1.47897 -31.3752 -52.0606 -73.5178 -114.751 164.966 101.394 47.5173 -9.91632 -84.8399 -4.52043 -37.3974 -63.6232 -85.8848 -114.369 146.107 138.453 63.6729 -42.5529 -81.7438 4.36892 -12.5231 -77.3288 -111.616 -104.245 92.8302 123.263 62.201 -26.7152 -32.6177 -13.2994 -22.4757 -78.8592 -98.6632 -69.6802 58.3159 68.691 54.4202 14.6163 -12.2017 -17.6183 -43.2968 -67.7901 -57.9619 -47.2275
Nilai tiap-tiap piksel yang didapat dari hasil perhitungan gaya Lorentz dari gambar 3.9 terhadap sumbu y adalah sebagai berikut :
69.3786 118.156 169.682 142.362 109.183 105 130.439 135.911 86.336 49.7954 68.9034 114.166 78.5412 42.3371 -0.29054 -10.8891 7.87279 47.5936 73.2699 44.832 48.236 55.4428 -13.3538 21.2765 1.12856 -10.0006 -14.5801 -28.2751 29.0034 27.9903 19.4998 5.24815 -31.7258 -36.5684 -59.8018 -64.9066 -48.2962 -31.915 -2.06007 11.5047 6.97394 1.29011 -8.84695 -13.6314 -18.9553 -20.8897 -16.2796 -9.53139 -0.00075 6.02884 5.12057 3.23435 -1.32576 -4.90363 -7.72763 -7.26096 -4.7884 -0.12884 2.57686 3.91392 1.89259 1.54925 -0.44343 -2.40664 -4.35352 -4.45807 -3.76507 -2.84381 0.146992 1.70904 -0.66823 -2.40577 -3.40954 -5.54383 -6.1188 -7.4167 -6.34561 -5.55092 -2.28078 -0.33896 -2.36739 -2.41663 -4.78575 -5.15023 -6.42459 -6.86254 -6.32679 -4.77875 -3.88331 -2.05617 -3.5954 -3.91917 -4.62996 -5.13204 -5.78748 -5.609 -5.38198 -5.19421 -4.09997 -3.16162 -4.66227 -5.00715 -5.29038 -5.51207 -5.65172 -5.64231 -5.52327 -5.28627 -4.86929 -4.36989 -6.27698 -6.39431 -6.37328 -6.28524 -6.19681 -6.14605 -6.13213 -6.10292 -5.98612 -5.74519 -8.20501 -8.00505 -7.5529 -7.04176 -6.66924 -6.57642 -6.75987 -7.07312 -7.32102 -7.34494 -10.5414 -9.76799 -8.4788 -7.17894 -6.25712 -6.14903 -6.82892 -7.87144 -8.82903 -9.29164 -13.5661 -11.5279 -7.98079 -5.24634 -2.62297 -2.76488 -5.00239 -7.76452 -10.5384 -11.9138 -17.4475 -13.2601 -2.67965 2.58831 13.7872 13.5791 3.20758 -4.47956 -13.0181 -16.1817 -31.4903 -26.8202 18.1646 -0.04895 -5.10149 -3.19249 4.42238 12.033 -19.0984 -24.6875 -59.2013 -92.4452 -43.2519 -80.5076 -55.4201 -45.2283 -50.0695 -30.5813 -61.8331 -41.6405 -70.3938 -128.038 -146.115 -135.668 -80.9469 -70.8441 -97.0844 -107.008 -88.9458 -50.2074 -63.9405 -98.5591 -145.558 -131.769 -116.266 -109.296 -111.365 -106.031 -68.9028 -44.7975
B. Perancangan Partikel Positif
Partikel positif yang digunakan merupakan partikel yang diberi gaya Coulomb sehingga partikel bermuatan positif. Partikel positif akan saling tolak menolak dengan partikel positif lainnya, dan tarik menarik dengan medan negatif citra. Alur dari perancangan gaya Coulomb sesuai dengan flowchart pada gambar 3.10.
Gambar 3.10. Flowchart Menghitung Gaya Coulomb
Flowchart pada Gambar 3.10 jika diimplementasikan dalam bentuk program ditulis seperti berikut :
int s=0, sx[100], sy[100];
double CoulombX[100], CoulombY[100];
for (int i=0;i<s;i++){
CoulombX[i]=0; CoulombY[i]=0;
for (int j=0;j<s;j++){
if (j != i){
if ((sx[i]-sx[j] != 0) && (sy[i]-sy[j] != 0)){
CoulombX[i] = CoulombX[i] + ((sx[i]-sx[j]) / pow(Absolut(sx[i] - sx[j]), 3));
CoulombY[i] = CoulombY[i] + ((sy[i]-sy[j]) / pow(Absolut(party[i] - party[j]), 3));
}else if (partx[i] - partx[j] == 0){
CoulombY[i] = CoulombY[i] + ((sy[i]-sy[j]) / pow(Absolut(party[i] - party[j]), 3));
}else if (party[i] - party[j] == 0){
CoulombX[i] = CoulombX[i] + ((sx[i]-sx[j]) / pow(Absolut(sx[i] - sx[j]), 3)); } } } } End CoulombForce = (Fcx , Fcy) = − − = − − [sx , sy] = inisialisasi partikel (f) Baca cit ra input f
Kode program untuk proses inisialisasi diletakkan pada function terpisah, ditulis sebagai berikut:
void showContent(IplImage * img){
cvCopyImage(img,temp);
for (int i=0;i<=part;i++){
cvCircle(temp, cvPoint(sx[i],sy[i]), 2, CV_RGB(255,0,0)); }
cvShowImage("CPM", temp);
}
void on_mouse( int event, int x, int y, int flags, void* ptr){
if (event == CV_EVENT_LBUTTONDOWN){ sx[part] = x;
sy[part] = y;
printf("%i %i %i\n",part,sx[part],sy[part]);
part++;
showContent((IplImage *)ptr); }
}
Untuk mendapatkan nilai gaya Coulomb dimulai dengan input partikel yang dilakukan dengan cara klik pada citra lokasi piksel yang diinginkan. Koordinat piksel partikel disimpan pada variabel sx[s] untuk koordinat sumbu x dan sy[s] untuk koordinat sumbu y, dengan s adalah indeks partikel. Setelah proses inisialisasi, perhitungan dilakukan berdasarkan sumbu x dan y. Hasil dari perhitungan sumbu x disimpan dalam variabel CoulombX, dan CoulombY untuk menyimpan hasil dari perhitungan sumbu y.
C. Perancangan Perhitungan Pergerakan Partikel
Gaya total didapatkan dengan menjumlahkan gaya Lorentz dan gaya Coulomb. Sesuai dengan rumus yang ada pada persamaan (2.10). Berdasarkan penelitian yang dilakukan Jalba dkk, partikel yang bergerak memiliki energi potensial sehingga disebut partikel dinamis, maka rumus untuk menghitung gaya total menjadi Persamaan (3.3).
( )
= ( )
= −∇∅( ) | = ( ( ) )
... (3.4)
Dimana ∅ adalah energi potensial partikel, adalah posisi, adalah kecepatan, dan adalah percepatan. Bila dibandingkan dengan Persamaan (2.3), Persamaan (3.3) memiliki tambahan, ( ) = − , yaitu pengurangan energi yang diperlukan partikel agar mencapai keadaan setimbang, digunakan untuk mengurangi energi potensial (Jalba dkk, 2004). Persamaan (3.3) dan (3.4) di atas belum bisa untuk disubstitusi dikarenakan ( ( ) ) belum diketahui, namun masih bisa untuk mencari turunan pertamanya, yang artinya bisa menggunakan deret Taylor agar persamaan tersebut bisa digunakan.
Untuk memudahkan, tiap partikel menggunakan interval waktu yang sama yaitu ∆ . Oleh karena itu, pada setiap interval waktu = + ∆ gaya yang bekerja pada tiap partikel dihitung sesuai dengan persamaan (3.3) untuk mendapatkan percepatan partikel . Kemudian untuk mendapatkan kecepatan, percepatan, dan posisi dalam tiap interval waktu bisa menggunakan metode Euler. Metode ini dapat mengakibatkan error yang terakumulasi tiap interval waktu.
Oleh karena itu, dikembangkan metode alternatif yang efisien yang didasarkan pada deret Taylor yang memanfaatkan nilai-nilai yang dihitung sebelumnya untuk mendapatkan percepatan dan kecepatan (yaitu metode bertingkat). Untuk mencari kecepatan, percepatan, dan posisi dalam satu interval waktu menggunakan persamaan seperti berikut:
( + ∆ ) = ( ) + ∆ ( ) + ∆ ( ) + ∆ ( )
... (3.5) ( + ∆ ) = ( ) + ∆ ( ) + ∆ ( ) ... (3.6)
Karena implementasi persamaan ( ) / pada komputasi susah dilakukan, dapat digunakan (kuadrat) Lagrange polynomial ( ), dalam satuan waktu { , − ∆ , −2∆ } (Jalba dkk, 2004). Mengambil turunan dari polynomial, dan mensubstitusi = , maka didapat persamaan sebagai berikut.
( )
= ( ) =
∆ ( 3 ( )−4 ( − ∆ ) + ( −2∆ ) ) ... (3.7) Berdasarkan Persamaan (3.3) sampai (3.7) diatas maka bila diasumsikan massa dari partikel positif adalah 1 maka implementasi dalam program adalah sebagai berikut :
percx[i][ite] = (w1 * CoulombX[i]) + (w2 * lorentx) - (beta * kecx[i][ite-1]);
percy[i][ite] = (w1 * CoulombY[i]) + (w2 * lorenty) - (beta * kecy[i][ite-1]);
kecx[i][ite] = kecx[i][ite-1] + (deltat * percx[i][ite-1]) + (0.5 * deltat * deltat * (((3 * percx[i][ite-1]) - (4 *
percx[i][ite-2]) + percx[i][ite-3]) / (2 * deltat)));
kecy[i][ite] = kecy[i][ite-1] + (deltat * percy[i][ite-1]) + (0.5 * deltat * deltat * (((3 * percy[i][ite-1]) - (4 *
percy[i][ite-2]) + percy[i][ite-3]) / (2 * deltat)));
posx[i][ite] = posx[i][ite-1] + (deltat * kecx[i][ite-1]) + (0.5 * deltat * deltat * percx[i][ite-1]) + (0.167 * deltat * deltat * deltat * (((3 * percx[i][ite-1]) - (4 * percx[i][ite-2]) + percx[i][ite-3])));
posy[i][ite] = posy[i][ite-1] + (deltat * kecy[i][ite-1]) + (0.5 * deltat * deltat * percy[i][ite-1]) + (0.167 * deltat * deltat * deltat * (((3 * percy[i][ite-1]) - (4 * percy[i][ite-2]) + percy[i][ite-3])));