1. 1. Jalankan perintah sudo apt-get install nvidia-current nvidia-current-dev nvidia-current-updates nvidia-current-updates-dev
2. Buat link simbolik berikut ini. ln -s /usr/lib/nvidia-current/libGL.so /usr/lib/libGL.so
3. Ganti baris LINKFLAGS += menjadi LINKFLAGS += -L/usr/lib/nvidia-current di file ~/NVIDIA_GPU_Computing_SDK/C/common/common.mk
4. Jalankan perintah make di ~/NVIDIA_GPU_Computing_SDK/C
5. Jalankan sebuah contoh program. ~/NVIDIA_GPU_Computing_SDK/C$ ./bin/linux/release/deviceQuery

Hasilnya adalah sebagai berikut

[deviceQuery] starting...
./bin/linux/release/deviceQuery Starting...

Press ENTER to exit...


Selamat tahun baru…

Mata lantas tertuju pda paket python-mpmath, yang segera saya install, sudo apt-get install python-mpmath.

Setelahnya, saya masuk ke shell python.
>>> import mpmath
>>> dir(mpmath)
['FPContext', 'MPContext', 'MPIntervalContext', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__path__', '__version__', '_ctx_mp', 'absmax', 'absmin', 'acos', 'acosh', 'acot', 'acoth', 'acsc', 'acsch', 'agm', 'airyai', 'airybi', 'almosteq', 'altzeta', 'apery', 'appellf1', 'appellf2', 'appellf3', 'appellf4', 'arange', 'arg', 'asec', 'asech', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'autoprec', 'barnesg', 'bei', 'bell', 'ber', 'bernfrac', 'bernoulli', 'bernpoly', 'besseli', 'besselj', 'besselk', 'bessely', 'beta', 'betainc', 'bihyper', 'binomial', 'calculus', 'catalan', 'cbrt', 'ceil', 'chebyfit', 'chebyt', 'chebyu', 'chi', 'cholesky', 'cholesky_solve', 'chop', 'ci', 'clcos', 'clsin', 'cond', 'conj', 'convert', 'cos', 'cos_sin', 'cosh', 'cosm', 'cospi', 'cospi_sinpi', 'cot', 'coth', 'coulombc', 'coulombf', 'coulombg', 'cplot', 'csc', 'csch', 'ctx_base', 'ctx_fp', 'ctx_iv', 'ctx_mp', 'ctx_mp_python', 'cyclotomic', 'degree', 'degrees', 'det', 'diag', 'diff', 'difference', 'differint', 'diffs', 'diffun', 'digamma', 'dirichlet', 'doctests', 'e', 'e1', 'ei', 'ellipe', 'ellipfun', 'ellipk', 'eps', 'erf', 'erfc', 'erfi', 'erfinv', 'euler', 'eulernum', 'eulerpoly', 'exp', 'expint', 'expj', 'expjpi', 'expm', 'expm1', 'extend', 'extradps', 'extraprec', 'eye', 'fabs', 'fac', 'fac2', 'factorial', 'fadd', 'fdiv', 'fdot', 'ff', 'fib', 'fibonacci', 'findpoly', 'findroot', 'floor', 'fmod', 'fmul', 'fneg', 'fourier', 'fourierval', 'fp', 'fprod', 'frac', 'fraction', 'fresnelc', 'fresnels', 'frexp', 'fsub', 'fsum', 'function_docs', 'functions', 'gamma', 'gammainc', 'gammaprod', 'gegenbauer', 'glaisher', 'grampoint', 'hankel1', 'hankel2', 'harmonic', 'hermite', 'hilbert', 'hurwitz', 'hyp0f1', 'hyp1f1', 'hyp1f2', 'hyp2f0', 'hyp2f1', 'hyp2f2', 'hyp2f3', 'hyp3f2', 'hyper', 'hyper2d', 'hypercomb', 'hyperfac', 'hyperu', 'hypot', 'identification', 'identify', 'im', 'inf', 'inverse', 'isinf', 'isint', 'isnan', 'isnormal', 'iv', 'j', 'j0', 'j1', 'jacobi', 'jacobian', 'jtheta', 'kei', 'ker', 'kfrom', 'khinchin', 'kleinj', 'laguerre', 'lambertw', 'ldexp', 'legendre', 'legenp', 'legenq', 'li', 'libmp', 'limit', 'linspace', 'ln', 'ln10', 'ln2', 'log', 'log10', 'loggamma', 'logm', 'lu', 'lu_solve', 'mag', 'make_mpc', 'make_mpf', 'math2', 'matrices', 'matrix', 'maxcalls', 'meijerg', 'memoize', 'mertens', 'mfrom', 'mnorm', 'monitor', 'mp', 'mpc', 'mpf', 'mpi', 'mpmathify', 'multiplicity', 'nan', 'ncdf', 'ninf', 'nint', 'nint_distance', 'norm', 'npdf', 'nprint', 'nprod', 'nstr', 'nsum', 'nthroot', 'odefun', 'ones', 'pade', 'phase', 'phi', 'pi', 'plot', 'polar', 'polyexp', 'polygamma', 'polylog', 'polyroots', 'polyval', 'power', 'powm', 'powm1', 'primepi', 'primepi2', 'primezeta', 'psi', 'pslq', 'qbarfrom', 'qfac', 'qfrom', 'qgamma', 'qhyper', 'qp', 'qr_solve', 'quad', 'quadgl', 'quadosc', 'quadts', 'radians', 'rand', 'randmatrix', 'rational', 're', 'rect', 'residual', 'rf', 'rgamma', 'richardson', 'riemannr', 'root', 'runtests', 'sec', 'sech', 'shanks', 'shi', 'si', 'siegeltheta', 'siegelz', 'sign', 'sin', 'sinc', 'sincpi', 'sinh', 'sinm', 'sinpi', 'spherharm', 'splot', 'sqrt', 'sqrtm', 'stieltjes', 'struveh', 'struvel', 'sumem', 'superfac', 'swap_row', 'tan', 'tanh', 'taufrom', 'taylor', 'timing', 'twinprime', 'unitroots', 'unitvector', 'usertools', 'visualization', 'whitm', 'whitw', 'workdps', 'workprec', 'zeros', 'zeta', 'zetazero']

Nah, ada method fac. Untuk memastikan saya ketik lagi

>>> mpmath.fac.__doc__
"\nComputes the factorial, `x!`. For integers `n \\ge 0`, we have\n`n! = 1 \\cdot 2 \\cdots (n-1) \\cdot n` and more generally the factorial\nis defined for real or complex `x` by `x! = \\Gamma(x+1)`.\n\n**Examples**\n\nBasic values and limits::\n\n >>> from mpmath import *\n >>> mp.dps = 15; mp.pretty = True\n >>> for k in range(6):\n ... print k, fac(k)\n ...\n 0 1.0\n 1 1.0\n 2 2.0\n 3 6.0\n 4 24.0\n 5 120.0\n >>> fac(inf)\n +inf\n >>> fac(0.5), sqrt(pi)/2\n (0.886226925452758, 0.886226925452758)\n\nFor large positive `x`, `x!` can be approximated by\nStirling's formula::\n\n >>> x = 10**10\n >>> fac(x)\n 2.32579620567308e+95657055186\n >>> sqrt(2*pi*x)*(x/e)**x\n 2.32579597597705e+95657055186\n\n:func:`~mpmath.fac` supports evaluation for astronomically large values::\n\n >>> fac(10**30)\n 6.22311232304258e+29565705518096748172348871081098\n\nReciprocal factorials appear in the Taylor series of the\nexponential function (among many other contexts)::\n\n >>> nsum(lambda k: 1/fac(k), [0, inf]), exp(1)\n (2.71828182845905, 2.71828182845905)\n >>> nsum(lambda k: pi**k/fac(k), [0, inf]), exp(pi)\n (23.1406926327793, 23.1406926327793)\n\n"

Aha, benar saya perkirakan. Akhirnya saya langsung saja berhitung
>>> mpmath.fac(3)
mpf('6.0')
>>> mpmath.fac(4)
mpf('24.0')
>>> mpmath.fac(2000)
mpf('3.3162750924506333e+5735')

Python benar2 luar biasa, hidup jadi sedemikian mudahnya, semoga gak malah jadi bodoh dengan berbagai kemudahan ini…

1. Unduh pustaka, masing-masing cudatoolkit, cudatools, dan contoh aplikasinya
2. Setelah terunduh sempurna, cudatoolkit dan cudatools diinstalasi. Jalankan
   sudo sh cudatoolkit_4.0.17_linux_64_ubuntu10.10.run
sudo sh cudatools_4.0.17_linux_64.run
3. Berikutnya adalah meng-install driver dari perangkat GPU. Untuk kasus ini, saya memilih untuk menggunakan driver yang ada di repository ubuntu. Jalankan
   sudo apt-get install nvidia-common nvidia-current
4. Modifikasi isi berkas ~/.bashrc dengan menambahkan baris berikut.
   export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/
export PATH=$PATH:/usr/local/cuda/lib:/usr/local/cuda/bin
   Simpan dan jalankan perintah source ~/.bashrc
5. Selanjutnya, instalasi alat bantu yang diperlukan. Jalankan perintah
   sudo apt-get install buil-essential gcc-4.4 g++-4.4 cpp-4.4 libxi-dev libxmu-dev freeglut3
   Instalasi paket build-essential sebenarnya telah mengikutsertakan kompilator default dari GNU versi 4.6. Namun, contoh aplikasi yang disertakan oleh NVIDIA (dalam paket gpucomputing) memerlukan kompilator versi 4.4, sehingga perlu diinstal lagi.
6. Kemudian, untuk mengarahkan kompilator ke versi 4.4, beberapa modifikasi perlu dilakukan. Jalankan perintah berikut
   sudo update-alternatives –install /usr/bin/gcc gcc /usr/bin/gcc-4.4 20
sudo update-alternatives –install /usr/bin/g++ g++ /usr/bin/g++-4.4 20
sudo update-alternatives –install /usr/bin/cpp cpp /usr/bin/cpp-4.4 20
   Untuk mengujinya, kita dapat melihat arah dari link simbolik dengan menjalankan perintah ls -alh /etc/alternatives/gcc.
7. Kemudian, instalasi contoh aplikasi gpucomputing. Jalankan perintah
   sh gpucomputingsdk_4.0.17_linux.run.
8. Yang terakhir adalah melakukan kompilasi. Arahkan current directory ke ~/NVIDIA_GPU_Computing_SDK/C untuk CUDA dan ~/NVIDIA_GPU_Computing_SDK/OpenCL untuk OpenCL. CUDA adala tools yang dikembangkan dan dioptimasi oleh dan untuk perangkat NVIDIA. Sedangkan OpenCL dikembangkan Khronos Group yang mengakomodasi perangkat dari NVIDIA dan ATI. Untuk melakukan kompilasi, jalankan perintah make

Untuk melihat hasilnya, kita dapat menjalankan salah satu contoh aplikasi yang disertakan. Sebagai contoh, jalankan perintah
./bin/linux/release/deviceQuery dari current directory C atau OpenCl. Sejauh ini, saya belum berhasil mengkompilasi aplikasi yang dikembangkan menggunakan CUDA. Kesalahan linking masih terjadi:
/usr/bin/ld: cannot find -lXi
oceanFFT: src/oceanFFT/Makefile.ph_build Error 2

Jika menggunakan aplikasi OpenCL, deviceQuery menghasilkan informasi berikut.


./oclDeviceQuery Starting...

Local Time/Date = 06:54:21, 12/09/2011
CPU Name: Intel(R) Core(TM)2 Duo CPU E7500 @ 2.93GHz
# of CPU processors: 2
Linux version 3.0.0-13-generic (buildd@crested) (gcc version 4.6.1 (Ubuntu/Linaro 4.6.1-9ubuntu3) ) #22-Ubuntu SMP Wed Nov 2 13:27:26 UTC 2011


Sedangkan aplikasi oclNbody, menghasilkanGambar berikut.

Contoh aplikasi oclNbody

Semoga bermanfaat…

Yang perlu diperhatikan adalah OpenFOAM telah menyertakan pustaka yang mengakomodasi operasi komputasi parallel, yaitu openMPI. Hal ini bisa dilihat dari respon yang diberikan oleh perintah which mpirun. Respon yang diberikan adalah sebagai berikut.

/home/arya/OpenFOAM/ThirdParty-1.7.1/platforms/linuxGcc/openmpi-1.4.1/bin/mpirun

Karena itu, aktivitas yang terkait instalasi pustaka operasi komputasi parallel untuk persiapan lingkungan cluster dapat diabaikan. Sehingga kita dapat melangkah ke tahap selanjutnya.

Tahap selanjutnya adalah mewadahi keperluan penggunaan data secara bersama oleh semua node hitung (compute node). Hal ini dilakukan dengan menginstall sistem file terdistribusi seperti NFS (Network File System). Instalasi dapat dilakukan dengan menjalankan perintah berikut.

sudo apt-get install nfs-common nfs-kernel-server

Selanjutnya adalah mendefinisikan direktori kerja di mana data simulasi akan digunakan bersama oleh setiap node hitung. Mendefinisikannya dapat dilakukan dengan panduan ini. Sebagai contoh, kita akan menggunakan bersama direktori kerja di /home/arya/OpenFoam/arya-1.7.1/run. Kemudian, ada dua node hitung yang terlibat, masing-masing node01 dan node02. Maka, modifikasi berkas /etc/exports dengan mengisikan beris berikut ini.

/home/arya/OpenFoam/arya-1.7.1/run \
node01(rw,insecure,no_subtree_check,no_root_squash,sync) \
node02(rw,insecure,no_subtree_check,no_root_squash,sync)

Setelahnya, kita dapat memulai melakukan simulasi.

Terkait eksekusi secara parallel, OpenFOAM memberikan fasilitas untuk mendekomposisi domain (obyek yang disimulasi). Dekomposisi kita lakukan sebelum perhitungan secara parallel dilakukan. Sehingga kita harus mendefinisikan bahwa obyek yang akan disimulasi akan dipecah menjadi berapa bagian dan dengan cara apa. Jumlah sub domain tersebut akan didefinisikan ulang oleh OpenFOAM terkait batas sub domain, serta berbagai variabel dalam sub domain tersebut. Berikut ini adalah mekanisme dekomposisinya.

1. Definisi dekomposisi diletakkan di berkas decomposeParDict. Berkas tersebut berisi beberapa informasi berikut ini.
   • Banyaknya sub domain
   • Cara pembagian. Pada contoh, disebutkan bahwa pembagian domain dilakukan dengan cara simple, yang berarti pembagian dilakukan dengan ukuran yang sama. Cara pembagian yang lain dapat dipelajari dari dokumentasi OpenFOAM yang dikompilasi dengan dikompilasinya paket OpenFAOM kita.
   • Apakah data dekomposisi domain tersebar di beberapa disk/node? Sebaiknya tidak (diisi no) karena belum diuji jika terdistribusi. Apalagi kita telah memasang nfs sebagai mediator ketersebaran data.

   Contoh dari definisi dekomposisi tersebut adalah seperti di bawah ini

   
   FoamFile
   {
       version     2.0;
       format      ascii ;
       class       dictionary ;
       location    " system " ;
       object      decomposeParDict ;
   }
   
   numberOfSubdomains 2 ;
   method  simple;
   simpleCoeffs
   {
       n       (2 1 1);
       delta   0.001;
   }
   distributed no ;
   roots ( );
   
   

2. Setelah mendefinisi pembagian domain obyek yang disimulasi, eksekusinya dilakukan dengan perintah berikut. Setelah menjalankan perintah tersebut, akan terdapat tambahan direktori yang diawali kata processor dengan n adalah nomor pemroses. Di bawahnya, akan terdapat struktur direktori dan berkas yang sama dengan struktur di atasnya. Data tersebut yang nantinya akan disitribusikan ke pemroses setelah daemon MPI diinisiasi dan setiap pemroses mendapatkan nilai rank.

   decomposePar

3. Langkah selanjutnya adalah menjalankan perhitungan secara parallel dengan perintah berikut. Perintah tersebut akan mengeksekusi simulasi icoFOAM (aliran laminar, incompressible, isothermal, dengan mesh seragam) secara parallel di mesin-mesin yang didefinisikan oleh berkas yang dijelaskan oleh argumen machines, sebanyak dua (seperti yang didefinisikan dalam berkas dekomposisi domain), untuk kemudian menyimpan log hasil hasil perhitungan ke dalam berkas yang diberi nama log.

   mpirun --hostfile -np 2 icoFoam -parallel > log &

4. Perhitungan yang dilakukan tetap disimpan dalam bentuk subdomain. Karenanya, untuk mengembalikan lagi dekomposisi menjadi obyek simulasi utuh seperti di awal, perlu dijalankan perintah berikut.

   reconstructPar

5. Setelah rekonstruksi domain dilakukan, kita dapat melihat hasilnya menggunakan Paraview. Jalankan perintah berikut. menunjukkan direktori kasus yang sedang disimulasi.

   paraFoam -case

Seperti telah dijelaskan sebelumnya, persamaan yang mendasari perhitungan Runge Kutta ada dua, masing-masing adalah persamaan untuk menghitung nilai antara dan persamaan untuk menghitung nilai fungsi. Pada metode Picard, tidak diperlukan mencari matriks Jacobian dari persamaan nilai antara. Cukup menggunakan persamaan nilai antara saja.

Tahap pertama, nilai tebakan awal (yang juga merupakan initial value) dijadikan sebagai nilai antara. Selanjutnya, nilai tebakan awal itu digunakan untuk menghitung nilai antara yang diperbarui. Persamaan nilai antara adalah seperti persamaan (1)

     (1)

Dari persamaan (1) kita sekarang memiliki dua nilai antara. Yang pertama adalah nilai antara yang di-assigned dari nilai tebakan awal. Dan yang kedua adalah nilai antara dari hasil memasukkan nilai tebakan awal ke persamaan (1). Selisih nilai antara kedua dan pertama dibandingkan. Jika lebih kecil atau sama dengan nilai toleransi, maka perhitungan nilai antara untuk step pertama dapat dilanjutkan dengan perhitungan nilai fungsi. Jika masih lebih besar, maka nilai antara kedua menjadi nilai antara pertama. Sedangkan nilai antara kedua dihitung ulang dari nilai antara pertama yang diperbarui. Hal ini dilakukan berulang hingga seluruh rentang waktu diakomodasi. Berikut adalah program perhitungan Runge Kutta dengan metode iterasi Picard. Seperti pada iterasi Newton, program ini dibuat dengan asumsi jika iterasi pada suatu step mencapai 5000, sedangkan selisih nilai antara pertama dan kedua masih lebih besar dari nilai toleransi, maka kondisi tersebut mengindikasikan tidak tercapainya konvergensi, sehingga perhitungan harus dihentikan.

from numpy import *
from numpy import linalg as la
import os.path
from time import *
from Equations import *
from Butcher import *
from Symbols import *
class PicardRKSolver():
	def __init__(self,Eq,Symbols,Butcher,Initial,Stop,StepSize,TimeTarget):
		self.errorStatus=0

		"""lenEq: banyaknya persamaan"""
		self.lenEq=len(Eq)

		"""persamaan yang akan diselesaikan"""
		self.equations=Eq

		"""simbol/variabel yang digunakan"""
		self.symbols=Symbols

		"""orde: orde penyelesaian"""
		self.orde=len(Butcher[1])

		"""x: nilai target yang akan dihitung pada setiap step size"""
		self.x1=array(Initial)

		"""y: nilai antara dalam bentuk sub array untuk menghitung derivatif"""
		"""y1: nilai antara, yang tebakan awalnya disamakan dengan nilai awal"""
		tempY=[]
		for i in range(self.orde):
			tempY.append(Initial)
		self.y=array(tempY)
		self.y1=array(tempY)
		self.y1=reshape(self.y1,(self.orde*self.lenEq,1))

		"""y2: nilai antara yang diperbarui"""
		self.y2=arange(1)

		"""delta: perbaikan nilai antara"""
		self.delta=self.y1

		"""a,b,c: komponen array Butcher"""
		self.a=Butcher[0]
		self.b=Butcher[1]
		self.c=Butcher[2]

		"""
		self.stop: stopping criteria
		self.h=step size
		"""
		self.stop=Stop
		self.h=StepSize
		self.t=TimeTarget
		self.selisih=self.t/self.h-int(self.t/self.h)
		self.stop=Stop
		self.h=StepSize
		self.t=TimeTarget
		self.selisih=self.t/self.h-int(self.t/self.h)

		self.__setY()

		self.elapsed=0
		self.start=time()
		if self.selisih==float(0):
			i=0
			while(i<int(self.t/self.h) and self.errorStatus==0):
				self.__iterate()
				self.__setY()
				i+=1
			self.elapsed=time()-self.start
		else:
			i=0
			while(i<int(self.t/self.h) and self.errorStatus==0):
				self.__iterate()
				self.__setY()
				i+=1
			self.h=self.selisih
			i=int(self.t/self.h)+1
			self.__extraIterate()
			self.elapsed=time()-self.start

		self.namafile.close()
		if self.errorStatus==1:
			print 'Quit unseccessful in ' + str(self.elapsed) + 'seconds ... '
		else:
			print 'Computation done ...'	

	def __setY(self):
		l=0
		for i in range(self.orde):
			for j in range(self.lenEq):
				self.y[i][j]=self.y1[l]
				l+=1
		p=[]
		l=0
		for i in range(self.orde):
			for j in range(self.lenEq):
				q=0
				for k in range(self.orde):
					q=q+(self.a[i][k]*self.y[k][j])
				p.append(self.x1[j]+q*self.h)
				l+=1
		self.y2=array(p)
		self.y2=reshape(self.y2,(self.orde*self.lenEq,1))

	def __iterate(self):
		l=0
		self.delta=self.y2-self.y1
		self.y1=self.y2
		l+=1
		while(self.stop<linalg.norm(self.delta) and l=5000:
			self.errorStatus=1

	def __setX(self):
		self.y1=reshape(self.y1,(self.orde,self.lenEq))
		for i in range(self.lenEq):
			tempY=0
			for j in range(self.orde):
				tempY=tempY+(self.b[j]*self.y1[j][i])
			self.x1[i]=self.x1[i]+(self.h*tempY)
		self.y1=reshape(self.y1,(self.orde*self.lenEq,1))

Referensi
[1] R. Holsapple, R. Iyer, and D. Doman, Variable step-size selection methods for implicit integration schemes for odes, International Journal of Numerical Analysis and Modeling, vol. 4, no. 2, pp. 212–242, 2007.

     (1)

Selanjutnya, diselesaikan sehingga nilainya lebih kecil atau sama dengan nilai toleransi. Saat kondisi tercapai, nilai digunakan untuk memperbaiki nilai antara menggunakan persamaan (2). Yang perlu diperhatikan adalah elemen harus sebanyak jumlah persamaan dikalikan orde penyelesaian.

     (2)

Nilai antara yang diperoleh dari persamaan di atas, digunakan untuk memperperbaiki nilai fungsi di titik step size dikalikan k. k adalah nilai step ke sekian dalam iterasi. Nilai fungsi diperbaiki dengan persamaan (3).

     (3)

Nilai fungsi yang baru digunakan kembali untuk memprediksi nilai antara, melalui persamaan (4).

     (4)

Jika dikaitkan dengan persamaan (1), nilai diperoleh dari persamaan (4), tepatnya seperti persamaan (5).

     (5)

Sedangkan nilai dari persamaan (1), merupakan matriks jacobian dari persamaan yang terlibat dalam sistem. Sebagai contoh, sistem dengan dua persamaan dan akan diselesaikan dengan RK orde dua, maka akan terdapat matriks berukuran 4 x 4. Kenapa bisa begitu?

Dari faktor orde penyelesaian, akan diperoleh matriks berdimensi orde x orde. Nah, setiap elemen dalam matriks berdimensi orde x orde tersebut, sejatinya merupakan matriks juga yang berdimensi n x n, dengan n adalah banyaknya persamaan (dan sudah tentu banyaknya variabel) yang terlibat dalam sistem. Karena orde penyelesaian yang digunakan adalah dua, dan jumlah persamaannya juga dua, maka dimensi matriks keseluruhan adalah 4 x 4. Kesimpulannya, sistem dengan m persamaan dan diselesaikan dengan orde n, akan dihasilkan matriks dengan dimensi mn x mn. Lalu bagaiman mengisi setiap elemen matriks tersebut?

Matriks pertama berdimensi orde x orde, telah disebutkan berisi matriks berdimensi n x n, dengan n adalah jumlah persamaan yang terlibat. Untuk matriks yang kedua ini, isinya adalah sebagai berikut. Jika terdapat sistem dengan dua persamaan, masing-masing dan , serta variabel masing-masing dan , maka isi matriks kedua adalah seperti persamaan (6)

     (6)

Jika orde penyelesaian sama dengan dua, maka persamaan (6) adalah bagian dari elemen ke dari matriks berdimensi orde x orde. Matriks berdimensi 2 x 2 tersebut adalah seperti persamaan (7), dengan adalah matriks identitas, sedangkan adalah matriks dari persamaan (6)

     (7)

Terkahir, program python untuk menyelesaikan sistem persamaan non-linier dengan runge kutta implisit adalah seperti program berikut ini. Program tersebut mengunakan asumsi bahwa ketika dalam suatu step, iterasi untuk mencapai konvergensi (nilai lebih kecil daripada nilai toleransi) melebihi 5000, maka iterasi dihentikan. Perhitungan runge kutta dengan iterasi Newton selanjutnya dihentikan.

from numpy import *
from numpy import linalg as la
import os.path
from time import *
from Equations import *
from Butcher import *
from Symbols import *
class NewtonRKSolver():
	def __init__(self,Eq,Symbols,Butcher,Initial,Stop,StepSize,TimeTarget):
		"""lenEq: banyaknya persamaan"""
		self.lenEq=len(Eq)

		"""persamaan yang akan diselesaikan"""
		self.equations=Eq

		"""simbol/variabel yang digunakan"""
		self.symbols=Symbols

		"""orde: orde penyelesaian"""
		self.orde=len(Butcher[1])

		"""Jv=-F: sistem persamaan linier yang akan diselesaikan"""
		self.F=arange(1)
		self.v=arange(1)
		self.J=arange(1)

		"""x: nilai target yang akan dihitung pada setiap step size"""
		self.x1=array(Initial)

		self.errorStatus=0

		"""
		self.stop: stopping criteria
		self.h=step size
		"""
		self.stop=Stop
		self.h=StepSize
		self.t=TimeTarget
		self.selisih=self.t/self.h-int(self.t/self.h)

		"""y: nilai antara dalam bentuk sub array untuk menghitung derivatif"""
		"""y1: nilai antara, yang tebakan awalnya disamakan dengan nilai awal"""
		tempY=[]
		for i in range(self.orde):
			tempY.append(Initial)
		self.y=array(tempY)
		self.y1=array(tempY)
		self.y1=reshape(self.y1,(self.orde*self.lenEq,1))
		l=0

		"""delta: perbaikan nilai antara"""
		self.delta=self.y1

		"""a,b,c: komponen array Butcher"""
		self.a=Butcher[0]
		self.b=Butcher[1]
		self.c=Butcher[2]

		"""membentuk vektor F"""
		self.__setF()

		"""membentuk matriks J"""
		self.__setJ()

		self.elapsed=0
		self.start=time()
		if self.selisih==float(0):
			i=0
			while(i<int(self.t/self.h) and self.errorStatus==0):
				self.__iterate()
				self.__setY()
				self.__setF()
				self.__setJ()
				i+=1
			self.elapsed=time()-self.start	

		else:
			i=0
			while(i<int(self.t/self.h) and self.errorStatus==0):
				self.__iterate()
				self.__setY()
				self.__setF()
				self.__setJ()
				i+=1
			self.h=self.selisih
			self.__iterate()
			i=int(self.t/self.h)+1
			self.elapsed=time()-self.start

		if self.errorStatus==1:
			print 'Quit unseccessful in ' + str(self.elapsed) + 'seconds ... '
			print 'Tidak konvergen di tahap-' + str(i)

	def __getNumDerivative(self,eq,number,val):
		a=self.equations[eq]
		b=self.equations[eq]
		for i in range(self.lenEq):
			if i==number:
				a=a.subs(self.symbols[i],(val[i]+0.001))
				b=b.subs(self.symbols[i],val[i])
			else:
				a=a.subs(self.symbols[i],val[i])
				b=b.subs(self.symbols[i],val[i])
		return (a-b)/0.001

	def __setF(self):
		p=[]
		l=0
		for i in range(self.orde):
			for j in range(self.lenEq):
				q=0
				for k in range(self.orde):
					q=q+self.a[i][k]*self.y[k][j]
				p.append(self.x1[j]-self.y1[l]+q*self.h)
				l+=1
		self.F=array(p)

		self.F=reshape(self.F,(self.orde*self.lenEq,1))

	def __setJ(self):
		tempJ=[]
		for i in range(self.orde):
			for l in range(self.orde):
				tempJ1=[]
				for j in range(self.lenEq):
					for k in range(self.lenEq):
						tempJ1.append(self.__getNumDerivative(j,k,self.y[l]))
				tempJ1=array(tempJ1)
				tempJ1=reshape(tempJ1,(self.lenEq,self.lenEq))
				tempJ.append(tempJ1)
		tempJ=array(tempJ)
		p=[]
		k=0
		for i in range(self.orde):
			for j in range(self.orde):
				if i==j:
					q=identity(self.lenEq)-self.h*self.a[i][j]*tempJ[k]
					p.append(q)
				else:
					q=-self.h*self.a[i][j]*tempJ[k]
					p.append(q)
				k+=1
		self.J=array(p)
		p=[]
		for i in range(self.orde):
			for j in range(self.lenEq):
				for k in range(self.orde*i,self.orde*(i+1)):
					for l in range(self.lenEq):
						p.append(self.J[k][j][l])
		self.J=array(p)
		x=self.orde*self.lenEq
		self.J=reshape(self.J,(x,x))

	def __setX(self):
		self.y1=reshape(self.y1,(self.orde,self.lenEq))
		for i in range(self.lenEq):
			tempY=0
			for j in range(self.orde):
				tempY=tempY+(self.b[j]*self.y1[j][i])
			self.x1[i]=self.x1[i]+(self.h*tempY)
		self.y1=reshape(self.y1,(self.orde*self.lenEq,1))

	def __setY(self):
		l=0
		for i in range(self.orde):
			for j in range(self.lenEq):
				self.y[i][j]=self.y1[l]
				l+=1

	def __iterate(self):
		l=0
		self.delta=linalg.solve(self.J,self.F)
		self.y1=self.delta+self.y1
		l+=1
		while(self.stop<linalg.norm(self.delta) and l=5000:
			self.errorStatus=1

	def getF(self):
		return self.F

	def getJ(self):
		return self.J

Referensi
[1]. G. Hall and J.M. Watt. Modern Numerical Methods for Ordinary Differential Equations. Oxford University Press, 1976.

Gambar 1. Diagram kebutuhan

Selanjutnya, untuk melakukan perhitungan runge kutta, di mana banyak diperlukan operasi matriks dan sistem persamaan linier, dibutuhkan juga pustaka numerik. Karenanya, kedua pustaka tersebut harus diinstal dulu ke dalam sistem. Untungnya, repositori Ubuntu telah menyediakan pustaka tersebut. Jalankan perintah berikut untuk menginstall keduanya dalam sistem.

sudo apt-get install python-sympy python-numpy python-numpy-doc

Langkah selanjutnya adalah menerapkan kebutuhan tersebut dalam program python. Kebutuhan tersebut akan diterapkan dalam class yang berbeda. Asumsi yang digunakan adalah jumlah persamaan sama dengan jumlah variabel bebas dalam setiap persamaan. Selain itu, class untuk mendefinisikan variabel akan dipisahkan dengan class untuk mendefinisikan persamaan. Penyatuannya sejauh ini tidak membuat kerumitan class karena pendefinisian variabel cukup sederhana. Silakan mencoba jika ingin menyatukan keduanya. Sedangkan kebutuhan untuk memilih array Butcher digunakan agar pengguna dapat mendefinisikan konstanta Butcher yang digunakan dalam persamaan penyelesaian Runge Kutta, baik jenis maupun ordenya.

Seperti diketahui, persamaan untuk menyelesaikan Runge Kutta secara implisit menggunakan dua persamaan berikut. variabel ,, tersebut yang didefinisikan dalam konstanta Butcher (Butcher array)

Kemudian, karena kebutuhan yang didefinisikan dalam Gambar 1 akan diterapkan dalam class, kita perlu mengetahui bagaimana python menjalankan pemrograman berorientasi obyek. Seperti pemrograman berorientasi obyek lainnya, class dalam python juga diawali dengan kata kunci class kemudian diikuti dengan nama class yang kita definisikan. Setelah mendefinisikan class, kita mendefinisikan constructor, berupa kata kunci init yang diapit dua karakter underscore. Argumen yang harus dibawa oleh konstructor, di contoh berikut diset sebagai self, digunakan sebagai simbol instance dari class yang bersangkutan. Dari manapun di dalam class, argumen tersebut digunakan untuk merujuk ke attribute mapun method pada class. Jika class membutuhkan instance dari obyek lain, tambahkan dalam daftar argumen pada definisi constructor. Sedangkan untuk method yang bersifat private, deklarasikan dengan karakter underscore ganda di depan nama method pada saat didefinisikan. Sekali lagi, nama obyek untuk instance class yang kita buat harus selalu diikutkan dalam argumen setiap method, meski deklarasi pemanggilannya tidak perlu disertakan.

Ilustrasinya seperti pada potongan program berikut ini.

class NamaClass():
	def __init__(self):
		self.a=0
		self.b='Arya'
		self.__privateMethod()
	def __privateMethod(self):
		self.a=1

Setelah itu, kita dapat mulai menerapkan kebutuhan yang didefinisikan dalam Gambar .

1. Class Symbols. Digunakan untuk mendefinisikan simbol variabel yang digunakan dalam persaman. Deklarasinya mengharuskan pengguna teleh memberikan jumlah variabel yang diperlukan pada setiap persamaan. Berikut adalah isi dari class Symbols.

   
   from sympy import *
   class Symbols():
   	def __init__(self,Number):
   		self.symbols=range(Number)
   		for i in range(Number):
   			self.symbols[i]=raw_input('Symbol#' + str(i+1) + '=')
   
   	def getSymbols(self):
   		return self.symbols
   
   	def getNumber(self):
   		return len(self.symbols)
   
   

2. Class Butcher. Class ini berisi definisi nilai variabel , , dan , berdasarkan jenis dan orde. Yang diterapkan dalam program barulah jenis Gauss dan Radau IIA dengan orde 1 sampai 3. Penjelasan detil dapat dilihat di sini. Meski ilustrasi yang diberikan untuk Runge Kutta eksplisit, tetapi metode implisit dicirikan dengan konstanta di atas diagonal utama yang tidak sama dengan nol.
   Potongan class Butcher adalah sebagai berikut (hanya untuk Gauss orde 1). Class ini membutuhkan argumen jenis dan orde Runge Kutta.

   
   from numpy import *
   class Butcher():
   	def __init__(self,Orde, Butcher):
   		if Orde==1:
   			self.orde=Orde
   			if Butcher=='Gauss' or Butcher=='gauss':
   				self.c=[0.5]
   				self.b=[1.0]
   				self.a=[0.5]
   				self.abc=[self.a,self.b,self.c]
   
   

3. Class Equations. Di class inilah didefinisikan persamaan yang terlibat dalam sistem. Class ini memerlukan argumen simbol variabel. Selain itu, sebelum sebuah persamaan didefinisikan, diperkenalkan terlebih dulu simbol variabel yang diperlukan. Di class ini juga didefinisikan fungsi derivetif numerik. Fungsi ini akan digunakan ketika itarasi yang digunakan adalah metode Newton. Berikut ini adalah isi dari class Equations.

   
   from numpy import *
   from sympy import *
   class Equations():
   	def __init__(self,Symbols):
   		self.symbols=Symbols
   		self.equations=range(len(Symbols))
   		self.eqNumber=len(Symbols)
   
   		print 'Set Equations'
   		for i in range(self.eqNumber):
   			for j in range(self.eqNumber):
   				var(self.symbols[j])
   			x=input('Eq#' + str(i+1) + ': ')
   			self.equations[i]=x
   
   	def getEquations(self):
   		return self.equations
   
   	def getNumDerivative(self,eq,number,val,h):
   		a=self.equations[eq]
   		b=self.equations[eq]
   		for i in range(len(val)):
   			if i==number:
   				a=a.subs(self.symbols[i],(val[i]+h))
   				b=b.subs(self.symbols[i],val[i])
   			else:
   				a=a.subs(self.symbols[i],val[i])
   				b=b.subs(self.symbols[i],val[i])
   		return (a-b)/h
   
   

Selanjutnya, Runge Kutta akan diselesaikan, baik dengan iterasi Newton maupun Picard.

1. Mengunduh paket OpenFOAM. Ada dua paket yang diperlukan, masing-masing adalah OpenFOAM-1.7.1 dan ThirdParty-1.7.1.
2. Membuat direktori kerja di $HOME/OpenFOAM. Ekstraski dari unduhan sebelumnya kemudian diletakkan di direktori kerja ini.
3. Menambahkan baris berikut ke berkas ~.bashrc. Tujuannya adalah mendefinisikan path dari setiap direktori yang diperlukan OpenFOAM.
   . $HOME/OpenFOAM/OpenFOAM-1.7.1/etc/bashrc
4. Menyimpan konfigurasi dengan menjalankan perintah berikut.
   source ~.bashrc
5. Menginstalasi paket-paket berikut ke dalam sistem Ubuntu, agar OpenFOAM dapat diinstalasi dengan baik.
   sudo apt-get install build-essential
sudo apt-get install flex scotch libscotch-5.1 libscotch-dev
sudo apt-get install libptscothch-5.1 libptscotch-dev
sudo apt-get install paraview
6. Instalasi paket MPI. Untuk mudahnya, gunakan saja openmpi.
   sudo apt-get install libopenmpi-dev openmpi-bin openmpi-doc
sudo apt-get install ssh
ssh-keygen -t dsa
cd ~/.ssh
cat id_pub.dsa >> authorized_keys
7. Berpindah ke direktori $HOME/OpenFOAM/OpenFOAM-1.7.1 lalu jalankan perintah berikut. Tunggu proses instalasi yang cukup lama untuk mesin Core2Duo bermemori 2 GB.
   ./Allwmake
8. Buat direktori kerja, jalankan perintah berikut. Sebenarnya sih bisa di mana aja, tapi OpenFOAM udah membuat skema yang didefiniskan di berkas bashrc yang sebelumnya dibahas, so saya pilih ikut OpenFOAM aja dl. Dampaknya kita bisa lebih mudah mencoba contoh kasus yang disertakan OpenFOAM.
   mkdir -p $HOME/OpenFOAM/$USER-1.7.1
cd $HOME/OpenFOAM/$USER-1.7.1
mkdir -p $FOAM_RUN
cp -r $FOAM_TUTORIALS $FOAM_RUN
9. Selanjutnya, kita bisa mencoba salah satunya contohnya. Jalankan perintah berikut.
   cd $FOAM_RUN/tutorials/incompressible/icoFOAM/cavity
blockMesh
icoFOAM
paraFOAM

Akhirnya, ingin lihat bagaimana OpenFOAM menampilkan hasil simulasinya? Gambar 1 berikut ini jawabannya.

Gambar 1. Paraview menampilkan hasil simulasi OpenFOAM

Persamaan PDF tersebut menggambarkan persentase paket yang diterima (CBRRecv) terhadap paket yang dikirim (CBRSend). Paket yang diterima dan dikirim dalam hal ini adalah paket CBR dari agent yang di-embed ke node WSN.

Kemudian, faktor selanjutnya adalah ETD yang diformulasikan dengan persamaan sebagai berikut.

Persamaan ETD tersebut menggambarkan selisih waktu saat paket diterima (CBRRecvTime) dan waktu saat paket dikirim (CBRSendTime). Karena paket yang dikirim memiliki kemungkinan untuk gagal diterima, waktu yang terlibat dalam perhitungan hanya untuk paket yang sama, yang dalam NS direkam sebagai paket-paket dengan nomor identitas yang sama. Selisih waktu tesebut kemudian dibagi dengan jumlah paket yang diterima.

Faktor ketiga, PDL tidak saya pertimbangkan karena hanya merupakan selisih antara paket yang dikirim dengan paket yang diterima. Menurut saya, parameter ini dapat diwakilkan dengan parameter PDF. Lalu, bagaimana mengolahnya?

Untuk kasus simulasi yang berbeda, NS akan mendokumentasi aktifitas simulasi dengan format yang berbeda juga. Ini adalah salah satu contohnya. Akan tetapi, file simulasi NS-2 yang saya buat menghasilkan baris-baris informasi seperti berikut ini.

s 0.000000000 _1_ AGT --- 0 cbr 4096 [0 0 0 0] [energy 100.000000 ei 0.000 es 0.000 et 0.000 er 0.000] ------- [1:2 0:0 32 0] [0] 0 0
r 58.041651834 _0_ AGT --- 5 cbr 4116 [13a 0 1 800] [energy 99.985864 ei 0.000 es 0.000 et 0.001 er 0.013] ------- [1:2 0:0 30 0] [5] 1 0

Terlihat beberapa perbedaan dengan format file trace yang diberikan sebelumnya. Akhirnya, saya memperoleh informasi format file tersebut dari sini.

Dari baris-baris informasi tersebut, berikut adalah field yang perlu diambil untuk menghitung ETD. Field tersebut dipisah dengan karakter spasi.

1. Karakter pertama, “s” atau “r”, masing-masing mengindikasikan bahwa paket tersebut adalah paket yang dikirim atau yang diterima.
2. Field kedua, angka riil, adalah waktu kejadian, baik pengiriman atau penerimaan file.
3. Field ketiga, angka integer yang diapit karakter underscore di kiri dan kanannya, mengindikasikan identitas node. Jika baris informasi diawali karakter “s”, maka node tersebut adalah node yang mengirimkan paket. Sedangkan jika diawali karakter “r”, maka node tersebut adalah node yang menerima paket.
4. Field ke-6 adalah identitas paket. Identitas ini yang diperlukan untuk menentukan waktu yang akan dihitung. Petunjuknya, waktu penerimaan harus dikurangi dengan waktu pengiriman dari paket yang identitasnya sama. Field lainnya, dapat diabaikan.

Setalah mengetahui karakternya, saya lalu membuat diagram alur sebagai berikut.

Diagram alur pengolah file trace sederhana

Akhirnya, program dengan Python untuk tujuan ini dibuat sebagai berikut. Program sederhana ini dapat dieksekusi melalui terminal dengan perintah ./nsproc.py <filetrace>. nsproc.py adalah asumsi nama program python ini. Jika nama lain digunakan, ganti saja namanya dengan nama yang digunakan. Selain itu, untuk dapat mengeksekusinya tanpa path absolut maupun relative, simpan saja file tersebut didirectory /usr/bin, tentu dengan atribut excecutable yang sudah disematkan pada file ini terlebih dahulu.

#!/usr/bin/python
import re
import sys
if len(sys.argv)!=2:
	print 'Perintahnya: nsproc.py <filetrace>'
	sys.exit(1)

logfile = open(sys.argv[1], "r").readlines()
patternS=re.compile(r'^(s)(\s)(\d)+\.(\d)+(\s)(_)(\d+)(_)(\s)(AGT).')
patternR=re.compile(r'^(r)(\s)(\d)+\.(\d)+(\s)(_)(\d+)(_)(\s)(AGT).')
waktukirim = {}
waktuterima = []
temp = []
idpaket = []
selisih = 0.0
cacahkirim=0
cacahterima=0
for line in logfile:
	if patternS.search(line):
		cacahkirim+=1
		for word in line.split():
			temp.append(word)
		a=temp[5]
		b=temp[1]
		waktukirim[a]=b
		temp = []
	else:
		if patternR.search(line):
			cacahterima+=1
			for word in line.split():
				temp.append(word)
			waktuterima.append(temp[1])
			idpaket.append(temp[5])
			temp = []

for i in range(len(idpaket)):
	b=int(idpaket[i])
	if str(b) in waktukirim:
		a=float(waktuterima[i])-float(waktukirim[str(b)])
		selisih=selisih+(a)
print 'Selisih waktu = ' + str(selisih)
print 'Jumlah paket yang dikirim = ' + str(cacahkirim)
print 'Jumlah paket yang diterima = ' + str(cacahterima)

int MPI_Scatter(void *sendbuf, int sendcnt, MPI_Datatype sendtype,
               void *recvbuf, int recvcnt, MPI_Datatype recvtype, int root,
               MPI_Comm comm)

Berikut ini adalah penjelasan dari parameter yang diperlukan.

1. void *sendbuf: variabel array data yang akan didistribusikan
2. int sendcnt: jumlah elemen array yang akan didistribusikan ke setiap node
3. MPI_Datatype sendtype: tipe data baru yang menjadi tipe data bagi array yang akan didistribusikan
4. void *recvbuf: variabel pada node penerima yang digunakan untuk menampung data yang didistribusikan
5. int recvcnt: jumlah elemen array yang diterima node
6. MPI_Datatype recvtype: tipe data baru bagi variabel pada node yang menerima data
7. int root: rank head node, biasanya 0
8. MPI_Comm comm: komunikator dalam MPI, terbentuk saat perintah MPI_Init() dijalankan

Setelah memahami penggunaannya, kita lanjutkan dengan membuat program untuk memenuhi apa yang telah dijelaskan di awal tulisan ini. Berikut adalah program tersebut.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "mpi.h"

struct data {
	int a;
};

int operasi(int a) {
	return a/2;
}

int main(int argc, char ** argv) {
	int jmlData=8;
	int id,p;
	unsigned int iseed=(unsigned int)time(NULL);
	srand(iseed);
	struct data sendData[jmlData];
	for(int i=0;i<jmlData;i++) {
		sendData[i].a=rand();
	}

	MPI_Datatype mytype;
	MPI_Datatype type=MPI_INT;
	int blocklen=1;
	MPI_Aint disp;
	disp=(int)(&sendData[0].a)-(int)(&sendData[0]);

	MPI_Init(&argc,&argv);

	MPI_Type_create_struct(1,&blocklen,&disp,&type,&mytype);
	MPI_Type_commit(&mytype);

	MPI_Comm_rank(MPI_COMM_WORLD,&id);
	MPI_Comm_size(MPI_COMM_WORLD,&p);

	int recvContent=jmlData/p;
	struct data recvData[recvContent];

	MPI_Scatter(sendData,recvContent,mytype,recvData,recvContent,mytype,0,MPI_COMM_WORLD);
	for(int i=0;i<p;i++) {
		printf("Data dari proses ke-%d\n",id);
		for(int j=0;j<recvContent;j++) {
			printf("index-%d,%d bagi 2 = %d\n",j,recvData[j].a,operasi(recvData[j].a));
		}
		printf("\n");
	}
	MPI_Finalize();
	return 0;
}

Jika dijalankan dengan dua proses, maka akan diperoleh hasil sebagai berikut. Tentunya setelah program tersebut dikompilasi. Akan tetapi, perlu diperhatikan bahwa kompilasi untuk program ini memerlukan opsi -std yang nilainya diberikan sebagai c99. Sehingga perintah kompilasi menjadi mpicc -std=c99 -o cobascatter cobascatter.c.

Data dari proses ke-0
index-0,1545926779 bagi 2 = 772963389
index-1,49064449 bagi 2 = 24532224
index-2,1071228553 bagi 2 = 535614276
index-3,1233134636 bagi 2 = 616567318

Data dari proses ke-1
index-0,465037100 bagi 2 = 232518550
index-1,1641429207 bagi 2 = 820714603
index-2,1325758038 bagi 2 = 662879019
index-3,161477691 bagi 2 = 80738845