sistem pakar pemantau kondisi pasien rawat...

PROYEK AKHIR

MATA KULIAH LOGIKA FUZZY

SEMESTER GENAP 2013-2014

SISTEM PAKAR PEMANTAU KONDISI PASIEN RAWAT

INAP MENGGUNAKAN FUZZY INFERENSI TSUKAMOTO

Disusun oleh:

Kelompok D Kelas A

Eko Subha (105060801111067)

Dosen Pengajar: Wayan Firdaus Mahmudy, Ph.D.

PROGRAM STUDI INFORMATIKA

PROGRAM TEKNOLOGI INFORMASI DAN ILMU KOMPUTER

UNIVERSITAS BRAWIJAYA

MALANG

ii

KATA PENGANTAR

Puji syukur penulis panjatkan kehadirat Allah SWT yang telah

melimpahkan segala kasih sayang dan rahmat-Nya sehingga penulis dapat

menyelesaikan proyek akhir dengan judul “Sistem Pakar Pemantau Kondisi

Pasien Rawat Inap Menggunakan Fuzzy Inferensi Tsukamoto”. Dokumentasi ini

menjadi bagian dari proyek akhir mata kuliah Logika Fuzzy di Program Teknologi

Informasi dan Ilmu Komputer Universitas Brawijaya.

Penulis menyadari bahwa proyek akhir ini tidak dapat terealisasikan

tanpa bantuan dari berbagai pihak, untuk itu penulis menyampaikan penghargaan

dan ucapan terima kasih yang sedalam-dalamnya kepada:

1. Wayan Firdaus Mahmudy, Ph.D., selaku dosen mata kuliah Logika Fuzzy

kelas A 2014;

2. Arief Andy Soebroto, ST.,M.Kom., selaku dosen mata kuliah Sistem

Pakar kelas A 2014;

3. Orang tua penulis yang sudah memberikan sumbangan materiil maupun

non materiil;

4. Teman-teman kelompok 9 mata kuliah Sistem Pakar untuk bantuan, kerja

sama dan semangatnya; dan

5. Semua pihak yang tidak dapat disebutkan satu-persatu.

Penulis menyadari bahwa proyek akhir ini masih jauh dari

kesempurnaan, untuk itu dengan segala kerendahan hati penulis mengharapkan

saran dan kritik yang membangun demi kesempurnaan penulisan selanjutnya.

Semoga laporan proyek akhir ini dapat bermanfaat untuk semua pihak.

Malang, 26 Mei 2014

Penulis

iii

DAFTAR ISI

KATA PENGANTAR............................................................................................................... ii

DAFTAR ISI .......................................................................................................................... iii

DAFTAR GAMBAR ................................................................................................................vi

DAFTAR TABEL ................................................................................................................... vii

DAFTAR PERSAMAAN ........................................................................................................ viii

BAB I PENDAHULUAN ......................................................................................................... 1

1.1 Latar Belakang ............................................................................................................... 1

1.2 Rumusan Masalah ......................................................................................................... 2

1.3 Batasan Masalah ........................................................................................................... 3

1.4 Tujuan ........................................................................................................................... 3

1.5 Manfaat ......................................................................................................................... 4

1.6 Sistematika Penulisan ................................................................................................... 4

BAB II DASAR TEORI ............................................................................................................ 6

2.1 Pelayanan Rawat Inap ................................................................................................... 6

2.2 Sistem Pakar .................................................................................................................. 6

2.2.1 Ciri dan Karakteristik Sistem Pakar .................................................................... 7

2.2.2 Rule .................................................................................................................. 10

2.3 Logika Fuzzy ................................................................................................................ 11

2.3.1 Himpunan Fuzzy ............................................................................................... 12

2.3.2 Fungsi Keanggotaan Fuzzy ............................................................................... 14

2.4 Fuzzy Inference System (FIS) Tsukamoto .................................................................... 15

2.4.1 Forward Chaining ............................................................................................. 15

2.4.2 Backward Chaining .......................................................................................... 16

2.5 Bahasa Pemrograman Java ......................................................................................... 19

2.6 Metode SBAR .............................................................................................................. 21

BAB III METODOLOGI PENELITIAN .................................................................................... 24

3.1 Studi Literatur ............................................................................................................. 25

3.2 Pengumpulan Data ...................................................................................................... 25

3.3 Analisa Kebutuhan ...................................................................................................... 25

iv

3.4 Analisa Perancangan ................................................................................................... 27

3.4.1 Deskripsi Sistem ............................................................................................... 27

3.5 Implementasi Sistem ................................................................................................... 34

3.6 Uji Coba Sistem ........................................................................................................... 34

3.7 Penarikan Kesimpulan ................................................................................................. 36

BAB IV PERANCANGAN ..................................................................................................... 37

4.1 Analisa Kebutuhan Perangkat Lunak .......................................................................... 38

4.1.1 Identifikasi Aktor .............................................................................................. 38

4.1.2 Daftar Kebutuhan Sistem ................................................................................. 38

4.1.3 Diagram Use Case ............................................................................................ 39

4.1.4 Skenario Use Case ............................................................................................ 40

4.2 Perancangan Sistem Pakar .......................................................................................... 41

4.2.1 Akuisisi Pengetahuan ....................................................................................... 41

4.2.2 Basis Pengetahuan ........................................................................................... 41

4.2.2.1 Himpunan Bahasa Variable ....................................................................... 42

4.2.2.2 Semesta Pembicaraan ............................................................................... 42

4.2.2.3 Fungsi Derajat Keanggotaan Variabel Tekanan Darah (SBP) .................... 42

4.2.2.4 Fungsi Derajat Keanggotaan Variabel Heart Rate..................................... 45

4.2.2.5 Fungsi Derajat Keanggotaan Variabel Tingkat kejenuhan Oksigen pada

Darah (SPO2) ......................................................................................................... 47

4.2.2.6 Fungsi Derajat Keanggotaan Variabel Suhu .............................................. 49

4.2.2.7 Fungsi Derajat Keanggotaan Variabel Gula Darah .................................... 51

4.2.2.8 Fungsi Derajat Keanggotaan Output ......................................................... 53

4.2.2.9 Rule ........................................................................................................... 57

4.2.3 Mesin Inferensi ................................................................................................ 86

4.2.4 Subsistem Antarmuka Pengguna ..................................................................... 87

BAB V IMPLEMENTASI ....................................................................................................... 88

5.1 Lingkungan Implementasi ........................................................................................... 88

5.1.1 Kebutuhan Perangkat Keras ............................................................................. 88

5.1.2 Kebutuhan Perangkat Lunak ............................................................................ 88

5.2 Implementasi Aplikasi ................................................................................................. 89

5.2.1 Kode Sumber Aplikasi ...................................................................................... 89

5.2.1.1 BloodSugar.java ........................................................................................ 89

v

5.2.1.2 HeartRate.java .......................................................................................... 93

5.2.1.3 SystolicBloodPressure.java ....................................................................... 97

5.2.1.4 OxygenSaturation.java ............................................................................ 101

5.2.1.5 Temperature.java .................................................................................... 104

5.2.1.6 Risk.java .................................................................................................. 107

5.2.1.7 RiskPrediction.java .................................................................................. 108

5.2.1.8 PCMFuzzy.java ........................................................................................ 113

5.2.1.9 DBConnection.java .................................................................................. 114

5.2.1.10 LoginWindow.java ................................................................................. 115

5.2.1.11 MainWindow.java ................................................................................. 121

5.2.1.12 TestUnit.java ......................................................................................... 138

5.2.2 Antarmuka Aplikasi ........................................................................................ 139

BAB VI PENUTUP ............................................................................................................. 141

7.1 Kesimpulan ................................................................................................................ 141

7.2 Saran ......................................................................................................................... 141

DAFTAR PUSTAKA ........................................................................................................... 142

vi

DAFTAR GAMBAR

Gambar 2.1 Blok Diagram Sistem Pakar ................................................................ 9

Gambar 2.2 Konsep Dasar Fuzzy .......................................................................... 12

Gambar 2.3 Perbandingan Fungsi Keanggotaan Himpunan Fuzzy Terhadap Crisp

............................................................................................................................... 13

Gambar 2.4 Fungsi Keanggotaan Segitiga ............................................................ 14

Gambar 2.5 Fungsi Keanggotaan Trapesium ........................................................ 15

Gambar 2.6 Diagram Blok Sistem Inferensi Fuzzy ............................................... 17

Gambar 2.7 Inferensi dengan menggunakan MetodeTsukamoto ......................... 18

Gambar 3.1 Alur Penelitian................................................................................... 24

Gambar 3.2 Diagram Alir Pengambilan Data Sampel .......................................... 26

Gambar 3.3 Arsitektur Sistem Pakar Pemantau kondisi Rawat Inap .................... 28

Gambar 3.4 Diagram alir aplikasi dari segi user................................................... 32

Gambar 3.5 Diagram alir aplikasi dari segi pakar................................................. 33

Gambar 3.6 Diagram alir proses pengujian dengan akurasi ................................. 34

Gambar 3.7 Diagram alir proses pengujian fungsional sistem ............................. 35

Gambar 4.1 Pohon Perancangan Sistem Pakar Pemantau Kondisi Pasien Rawat

Inap Menggunakan Fuzzy Inferensi Tsukamoto ................................................... 37

Gambar 4.2 Diagram Use Case ............................................................................. 39

Gambar 4.3 Grafik fuzzy set tekanan darah ........................................................... 44

Gambar 4.4 Grafik fuzzy set heart rate ................................................................. 46

Gambar 4.5 Grafik fuzzy set SPO2 ........................................................................ 48

Gambar 4.6 Grafik fuzzy set suhu ......................................................................... 50

Gambar 4.7 Grafik fuzzy set gula darah ................................................................ 51

Gambar 4.8 Grafik fuzzy set risk group ................................................................ 54

Gambar 4.9 Flowchart Metode Fuzzy Tsukamoto ................................................ 86

Gambar 4.10 Antarmuka Sistem ........................................................................... 87

Gambar 5.1 Antarmuka Window Log in ............................................................. 139

Gambar 5.2 Antarmuka Window Utama ............................................................. 140

vii

DAFTAR TABEL

Tabel 3.1 Konsep pengetahuan sistem pakar pemantau kondisi pasien rawat inap

............................................................................................................................... 30

Tabel 4.1 Identifikasi Aktor .................................................................................. 38

Tabel 4.2 Daftar kebutuhan Sistem ....................................................................... 38

Tabel 4.3 Skenario Use Case ................................................................................ 40

Tabel 4.4 Semesta Pembicaraan ............................................................................ 42

Tabel 4.5 Range Fuzzy Set SBP ........................................................................... 43

Tabel 4.6 Range Fuzzy Set Heart Rate.................................................................. 45

Tabel 4.7 Range Fuzzy Set SPO2 .......................................................................... 48

Tabel 4.8 Range Fuzzy Set Suhu ........................................................................... 49

Tabel 4.9 Range Fuzzy Set Gula Darah ................................................................. 51

Tabel 4.10 Range fuzzy set risk group .................................................................. 53

viii

DAFTAR PERSAMAAN

Persamaan 2-1 Fungsi Keanggotaan Himpunan Fuzzy ………………………...13

Persamaan 2-2 Fungsi Keanggotaan Segitiga …………………………………..14

Persamaan 2-3 Fungsi Keanggotaan Trapesium ……………………………….15

BAB I

PENDAHULUAN

1.1 Latar Belakang

Rumah sakit sebagai salah satu institusi pelayanan umum, membutuhkan

keberadaan suatu sistem informasi yang akurat dan handal, serta cukup memadai

untuk meningkatkan pelayanan kepada para pasien serta lingkungan yang terkait

lainnya. Informasi yang intensif memainkan peranan vital dalam pengambilan

keputusan.

Menurut surat Keputusan Menteri Kesehatan RI no.

159b/MENKES/PER/II/1988 tentang rumah sakit, pelayanan kesehatan di rumah

sakit berupa pelayanan rawat jalan, pelayanan rawat inap, dan pelayanan gawat

darurat yang mencangkup pelayanan medik dan pelayanan penunjang medik [8:3].

Masing-masing pelayanan mempunyai sistem informasi yang terintegrasi dalam

suatu sistem informasi rumah sakit. Kondisi penyakit level kronis membutuhkan

pemantauan yang ekstra waspada dari pihak rumah sakit. Pemantauan tersebut

bisa mengenai infus, tekanan darah, detak jantung dan lain-lain. Dengan demikian

dibutuhkan sistem pemantau kondisi pasien untuk memudahkan kerja tenaga

medis dalam melayani pasien.

Sistem Early Warning Scoring System (EWSS) dapat mengidentifikasi

keadaan pasien yang beresiko lebih awal dan menggunakan multi parameter [9:4].

Para ahli mengatakan bahwa, sistem ini dapat menghasilkan manfaat lebih bagi

pasien dan rumah sakit dengan mengidentifikasi penurunan kondisi pasien. EWS

yang digunakan di rumah sakit Indonesia saat ini masih berbasis kertas dan

perhitungannya masih dilakukan manual dengan menggunakan tabel. Perlu

dilakukan trasformasi media dari semula kertas ke media yang dapat dengan

mudah diakses oleh tenaga medis. Salah satu media yang dapat digunakan adalah

komputer.

Pada sistem pakar terdapat salah suatu metode yaitu fuzzy Tsukamoto.

Metode Tsukamoto mengaplikasikan penalaran monoton pada setiap aturannya.

2

Kalau pada penalaran monoton, sistem hanya memiliki satu aturan. Pada metode

Tsukamoto, sistem terdiri atas beberapa aturan [10:22]. Fuzzy Tsukamoto

merupakan metode yang cocok digunakan dalam pemantauan kondisi pasien

rawat inap. Fuzzy Tsukamoto merupakan metode yang sangat fleksibel dan

memiliki toleransi pada data yang ada. Metode ini memiliki kelebihan yaitu lebih

intuitif, diterima oleh banyak pihak, lebih cocok untuk masukan yang diterima

dari manusia bukan mesin.

Pada penelitian sebelumnya yang berjudul “Fuzzy Logic Based Patients’

Monitoring System”(Jumanah Abdullah Al-Dmour. 2013), membahas tentang

pemantauan kondisi pasien rumah sakit menggunakan teknologi RFID untuk

mengintegrasikan tanda-tanda vital seperti suhu tubuh, tekanan darah, gula darah,

dan kadar oksigen dalam darah. Sistem yang telah dibuat sebelumnya terlalu rumit

untuk diaplikasikan pada setiap rumah sakit. Karena tidak semua rumah sakit

mempunyai teknologi serupa.

Berdasarkan permasalahan tersebut maka perlu dikembangkan perangkat

lunak dengan kemampuan sama atau mendekati seorang pakar sistem pemantauan

kondisi pasien rawat inap dengan ketelitian tinggi, lebih sederhana dan lebih

lengkap dibandingkan sistem yang serupa. Untuk itu kami mengangkat judul

“Sistem Pakar Pemantau Kondisi Pasien Rawat Inap Menggunakan Fuzzy

Inferensi Tsukamoto”.

1.2 Rumusan Masalah

Berdasarkan paparan latar belakang tersebut, maka rumusan masalah

adalah sebagai berikut

1. Bagaimana merancang dan mengimplementasikan sistem pakar

pemantau kondisi pasien rawat inap menggunakan fuzzy inferensi

metode Tsukamotto.

2. Bagaimana menguji sistem pakar pemantau kondisi pasien rawat inap

menggunakan fuzzy inferensi metode Tsukamotto.

3

1.3 Batasan Masalah

Penelitian ini dibatasi oleh hal-hal sebagai berikut:

1. Kriteria yang digunakan terdiri dari:

a. SBAR

• Situation

• Background

• Assessment

• Recommendation [7:17]

b. EWS (Early Warning Score). Pengamatan fisiologi yang dilakukan

meliputi:

• Oxygen saturation

• Blood sugar

• Heart rate

• Systolic blood pressure

• Temperature [5:5] [9:7].

2. Pemprosesan data (EWS) menggunakan fuzzy logic dengan metode

inferensi tsukamoto [5:58-62].

3. Bahasa pemrograman yang digunakan adalah bahasa pemrograman Java.

4. DBMS yang digunakan adalah MySQL.

5. Perangkat lunak IDE yang digunakan untuk implementasi sistem ini

adalah Netbeans.

6. Pengujian disesuaikan dengan kebutuhan mata kuliah Logika Fuzzy.

1.4 Tujuan

Tujuan penelitian ini adalah merancang, mengimplementasikan dan

menguji sistem pakar pemantau kondisi pasien rawat inap menggunakan fuzzy

inferensi Tsukamoto.

4

1.5 Manfaat

Manfaat penelitian ini adalah

1.5.1 Bagi Pasien

1. Dapat memberikan kenyaman pada pasien sehingga mengurangi

keluhan dari pasien mengenai lambatnya penanganan dokter.

2. Dapat mempercepat waktu distribusi informasi kondisi pasien.

1.5.2 Bagi Tenaga Medis (Suster dan Dokter)

1. Dapat memberikan kenyaman pada tenaga medis dalam melakukan

monitoring keadaan pasien rawat inap.

2. Dapat meningkatkan efektifitas dan efisiensi waktu antara tenaga

medis

1.5.3 Bagi Rumah Sakit

1. Dapat meningkatkan pelayanan terhadap pasien.

2. Dapat meningkatkan kepercayaan publik terhadap Rumah Sakit.

1.5.4 Bagi Penulis

1. Proyek akhir ini diharapkan dapat menjadi pembelajaran dan dapat

menambah pengalaman di bidang studi keilmuan yang terkait.

1.6 Sistematika Penulisan

Untuk mencapai tujuan yang diharapkan, maka sistematika penulisan yang

disusun dalam proyek akhir ini adalah sebagai berikut:

BAB I Pendahuluan

Bab ini berisi tentang latar belakang, rumusan masalah, batasan masalah,

tujuan penelitian, manfaat penelitian, sistematika penulisan, dan waktu

pengerjaan dari penelitian sistem pakar pemantau kondisi pasien rawat

inap menggunakan fuzzy inferensi Tsukamoto.

5

BAB II Dasar Teori

Bab ini terdiri membahas teori-teori yang mendukung dalam perancangan

dan pengembangan sistem pakar pemantau kondisi pasien rawat inap

menggunakan fuzzy inferensi Tsukamoto.

BAB III Metodologi

Membahas tentang metode yang digunakan dalam penelitian sistem pakar

pemantau kondisi pasien rawat inap menggunakan fuzzy inferensi

Tsukamoto yang berupa studi literatur.

BAB IVAnalisis Kebutuhan dan Perancangan

Membahas tentang analisa kebutuhan dari sistem pakar pemantau kondisi

pasien rawat inap menggunakan fuzzy inferensi Tsukamoto dan kemudian

merancang hal-hal yang berhubungan dengan analisa tersebut.

BAB V Implementasi

Membahas tentang hasil perancangan dari analisis kebutuhan dan

implementasi sistem pakar pemantau kondisi pasien rawat inap

menggunakan fuzzy inferensi Tsukamoto.

BAB VI Penutup

Memuat kesimpulan yang diperoleh dari pembuatan dan pengujian

perangkat lunak sistem pakar pemantau kondisi pasien rawat inap

menggunakan fuzzy inferensi Tsukamoto yang dikembangkan dalam

proyek akhir ini serta saran-saran untuk pengembangan lebih lanjut.

6

BAB II

DASAR TEORI

2.1 Pelayanan Rawat Inap

Pelayanan rawat inap merupakan salah satu bentuk pelayanan rumah sakit

yang memberikan pelayanan kepada pasien yang perlu menginap untuk keperluan

observasi, diagnosis, pengobatan, bagi individu dengan keadaan medis tertentu,

pada kasus bedah, kebidanan, penyakit kronis atau rehabilitasi yang memerlukan

perawatan dokter setiap hari. Sedangkan DepKes 1991 membatasi pelayanan

rawat inap adalah layanan terhadap pasien masuk rumah sakit yang menempati

tempat tidur untuk keperluan observasi, diagnosis, terapi, rehabilitasi medis dan

atau pelayanan medis lainnya (Antin Yohana. 2006)

2.2 Sistem Pakar

Sistem pakar adalah perangkat lunak komputer yang menggunakan

pengetahuan (aturan-aturan tentang sifat dari suatu unsur masalah), fakta dan

teknik inferensi untuk masalah yang biasanya membutuhkan kemampuan seorang

ahli (Marimin, 2005). Pengetahuan yang digunakan dalam sistem pakar terdiri

dari akidah-kaidah (rules) atau informasi dari pengalaman tentang tingkah laku

suatu unsur dari suatu gugus persoalan. Kaidah-kaidah biasanya memberikan

deskripsi tentang kondisi yang diikuti oleh akibat dari prasyarat tersebut.

Tujuan perancangan sistem pakar adalah untuk mempermudah kerja atau

bahkan menggantikan tenaga ahli, penggabungan ilmu dan pengalaman dari

beberapa tenaga ahli, training tenaga ahli baru, penyediaan keahlian yang

diperlukan oleh suatu proyek yang tidak ada atau tidak mampu membayar tenaga

ahli. Hal tersebut dapat dipahami secara rasional, karena kaderisasi tenaga ahli

dalam suatu organisasi sangat diperlukan, terutama untuk badan usaha yang

mempunyai keterbatasan dana untuk menyediakan tenaga ahli.

Penggabungan ilmu dan pengalaman para tenaga ahli bukan merupakan

pekerjaan yang mudah, khususnya untuk tenaga ahli yang berbeda dalam bidang

7

keahlian. Dalam hal ini sistem pakar dirancang untuk menyimpan dan

menggunakan ilmu serta pengalaman dari satu atau beberapa tenaga ahli. Untuk

itu sustu sistem pakar yang mempunyai kapasitas besar diperkirakan mampu

memecahkan suatu persoalan yang tidak dapat dipecahkan oleh satu atau

sekelompok kecil tenaga ahli [10:12-13].

2.2.1 Ciri dan Karakteristik Sistem Pakar

Ada berbagai ciri dan karakteristik yang membedakan sistem pakar dengan

sistem yang lain. Ciri dan karakteristik ini menjadi pedoman utama dalam

pengembangan sistem pakar. Ciri dan karakteristik yang dimaksud antara lain

[2:1-3]:

1. Pengetahuan sistem pakar merupakan suatu konsep, bukan berbentuk

numeris. Hal ini dikarenakan komputer melakukan proses pengolahan data

secara numerik sedangkan keahlian dari seorang pakar adalah fakta dan

aturan-aturan, bukan numerik.

2. Informasi dalam sistem pakar tidak selalu lengkap, subyektif, tidak

konsisten, subyek terus berubah dan tergantung pada kondisi lingkungan

sehingga keputusan yang diambil bersifat tidak pasti dan tidak mutlak “ya”

atau “tidak” akan tetapi menurut ukuran kebenaran tertentu. Oleh karena

itu dibutuhkan kemampuan sistem untuk belajar secara mandiri dalam

menyelesaikan masalah-masalah dengan pertimbangan-pertimbangan

khusus.

3. Kemungkinan solusi sistem pakar terhadap suatu permasalahan adalah

bervariasi dan mempunyai banyak pilihan jawaban yang dapat diterima,

semua faktor yang ditelusuri memiliki ruang masalah yang luas dan tidak

pasti. Oleh karena itu diperlukan sistem yang fleksibel dalam menangani

kemungkinan solusi dari berbagai permasalahan.

4. Perubahan atau pengembangan pengetahuan dalam sistem pakar dapat

terjadi setiap saat bahkan sepanjang waktu sehingga diperlukan

kemudahan dalam modifikasi sistem untuk menampung jumlah

pengetahuan yang semakin besar dan semakin bervariasi.

8

5. Pandangan dan pendapat setiap pakar tidak selalu sama, oleh karena itu

tidak ada jaminan bahwa solusi sistem pakar merupakan jawaban yang

pasti benar. Setiap pakar akan memberikan pertimbangan-pertimbangan

berdasarkan faktor subyektif.

6. Keputusan merupakan bagian terpenting dari sistem pakar. Sistem pakar

harus memberikan solusi yang akurat berdasarkan masukan pengetahuan

meskipun solusinya sulit sehingga fasilitas informasi sistem harus selalu

diperlukan.

Blok diagram sistem pakar bisa dilihat pada Gambar 2.2. Pada gambar

tersebut menjelaskan bahwa sistem pakar juga dapat dilihat dari sudut pandang

lingkungan (environment) dalam sistem. Terdapat dua lingkungan yaitu

lingkungan konsultasi dan lingkungan pengembangan. Lingkungan konsultasi

diperuntukkan bagi pengguna non pakar untuk melakukan konsultasi dengan

sistem yang tujuannya adalah mendapatkan nasehat pakar. Sedangkan lingkungan

pengembangan ditujukan bagi pembangun sistem pakar untuk membangun

komponen dan memasukkan pengetahuan hasil akuisisi pengetahuan ke dalam

basis pengetahuan.

9

Gambar 2.1 Blok Diagram Sistem Pakar Sumber: [12:24]

Secara umum sistem pakar biasanya terdiri atas beberapa komponen yang

masing-masing berhubungan. Basis pengetahuan sistem pakar yang dibutuhkan

untuk memahami, memformulasi, dan memecahkan masalah. Basis pengetahuan

tersusun atas dua elemen dasar yaitu [11]:

1. Fakta

Fakta disini misalnya situasi, konsisi dan kenyataan dari permasalahan

yang ada, serta teori dalam bidang; sistem pakar diterapkan.

2. Aturan

Aturan, yang mengarahkan penggunaan pengetahuan untuk memecahkan

masalah yang spesifik dalam bidang yang khusus.

Mesin inferensi (inference engine) merupakan otak dari sistem pakar.

Mesin inferensi juga dikenal sebagai penerjemah aturan (rule interpreter).

Komponen ini berupa program komputer yang menyediakan suatu metodologi

Pemakai

Antarmuka

Aksi yang direkomendasikan

FasilitasPenjelas

Mesin Inferensi

WorkplacePerbaikan

Pengetahuan

Basis Pengetahuan :

fakta dan aturan

KnowledgeEngineer

Pakar

LINGKUNGAN KONSULTASI LINGKUNGAN PENGEMBANGAN

Fakta tentangkejadian tertentu

10

untuk memikirkan (reasoning) dan memformulasi kesimpulan. Kerja mesin

inferensi meliputi [11]:

1. Menentukan aturan mana akan dipakai

2. Menyajikan pertanyaan kepada pemakai, ketika diperlukan.

3. Menambahkan jawaban ke dalam memori sistem pakar.

4. Menyimpulkan fakta baru dari sebuah aturan

5. Menambahkan fakta tadi ke dalam memori

2.2.2 Rule

Rule adalah sebuah struktur knowledge yang menghubungkan beberapa

informasi yang sudah diketahui ke informasi lain sehingga dapat disimpulkan.

Sebuah rule adalah sebuah bentuk knowledge yang prosedural. Dengan demikian

yang dimaksud dengan sistem pakar berbasis rule adalah sebuah program

computer untuk memproses masalah dari informasi spesifik yang terdapat dalam

memori aktif dengan sebuah set dari rule dalam knowledge base, dengan

menggunakan inference engine untuk menghasilkan informasi baru.

Struktur rule secara logika menghubungkan satu atau lebih anteseden (juga

disebut premis) yang terletak dalam bagian IF dengan satu atau lebih konsekuen

(juga disebut konklusi) yang terletak dalam bagian THEN. Secara umum, sebuah

rule dapat mempunyai premis jamak dihubungkan dengan pernyataan AND

(konjungsi) pernyataan OR (disjungsi) atau kombinasi dari keduanya.

Dalam sistem pakar berbasis aturan domain knowledge ditampung dalam

sebuah set dari rules dan dimasukkan dalam basis sistem pengetahuan. Sistem

menggunakan aturan ini dengan informasi selama berada dalam memori aktif

untuk memecahkan masalah. Sistem pakar berbasis aturan mempunyai arsitektur

yang dapat dijelaskan sebagai berikut [10:14-15]:

1. User interface

Digunakan sebagai media oleh user untuk melihat dan berinteraksi dengan

sistem.

2. Developer interface

Media yang digunakan untuk mengembangkan sistem oleh engineer.

11

3. Fasilitas penjelasan

Sub sistem yang berfungsi untuk menyediakan penjelesan dalam sistem

reasoning.

4. Program eksternal

5. Program seperti basis data, spreadsheet, yang bekerja dalam mendukung

keseluruhan sistem.

2.3 Logika Fuzzy

Logika fuzzy didasarkan pada logika Boolean yang umum digunakan

dalam komputasi. Secara ringkas, teorema fuzzy memungkinkan komputer

“berpikir” tidak hanya dalam skala hitam-putih (0 dan 1, mati atau hidup) tetapi

juga dalam skala abu-abu. Dalam Logika Fuzzy suatu preposisi dapat

direpresentasikan dalam derajat kebenaran (truthfulness) atau kesalahan

(falsehood) tertentu.

Pada sistem diagnosis fuzzy peranan manusia/operator lebih dominan.

Pengiriman data dilaksanakan oleh operator ke dalam sistem. Ketika sistem

memerlukan data tambahan. Selain itu operator dapat meminta atau menanyakan

informasi dari sistem diagnosis berupa hasil konklusi atau prosedur detail hasil

diagnosis oleh sistem. Dari sifat sistem ini, sistem diagnosis fuzzy dapat

digolongkan pada sistem pakar fuzzy. Sistem pakar fuzzy adalah sistem pakar yang

menggunakan notasi fuzzy pada aturan-aturan dan proses inference (logika

keputusan).

Banyak sistem yang terlalu kompleks untuk dimodelkan secara akurat,

meskipun dengan persamaan matematis yang kompleks. Dalam kasus seperti itu,

ungkapan bahasa yang digunakan dalam logika kabur dapat membantu

mendefinisikan karakteristik operasional sistem dengan lebih baik. Ungkapan

bahasa untuk karakteristik sistem biasanya dinyatakan dalam bentuk implikasi

logika. Misalnya aturan IF-THEN.

Penerapan logika fuzzy dapat meningkatkan kinerja sistem kendali dengan

menekan munculnya fungsi-fungsi liar pada keluaran yang disebabkan oleh

12

fluktuasi pada variabel masukan. Pendekatan logika fuzzy secara garis besar

diimplementasikan dalam tiga tahapan yaitu [10:15-16]:

1. Tahap pengaburan (fuzzification) yakni pemetaan dari masukan tegas ke

himpunan kabur.

2. Tahap inferensi, yakni pembangkitan aturan kabur.

3. Tahap penegasan (defuzzification), yakni tranformasi keluaran dari nilai

kabur ke nilai tegas.

Gambar 2.2 Konsep Dasar Fuzzy Sumber:[13]

2.3.1 Himpunan Fuzzy

Himpunan fuzzy adalah konsep yang mendasari lahirnya logika fuzzy.

Himpunan fuzzy adalah sebuah himpunan yang anggotanya memiliki derajat

keanggotaan tertentu. Setiap anggota memiliki derajat keanggotaan tertentu yang

ditentukan oleh fungsi keangotaan (membership function) tertentu atau disebut

juga fungsi karakteristik (characteristic function).

Himpunan crisp adalah himpunan klasik yang telah dikenal secara umum.

Himpunan crisp membedakan anggotanya dengan nilai nol atau satu, anggota

himpunan atau bukan. Sebagai contoh himpunan crisp yaitu, pada himpunan

manusia. Himpunan wanita atau laki-laki dapat dipresentasikan dengan mudah

Fuzi

ficat

ion

Inference Mechanism

Rule-base

Def

uzifi

catio

n

Process

ReferenceInput

Fuzzy Controller

Input Output

13

dengan cara himpunan klasik. Akan tetapi, bagaimana mempresentasikan

himpunan pada manusia muda atau tua. Muda atau tua itu cukup relatif tidak

langsung terpisah hanya karena berbeda satu hal. Dalam hal ini himpunan fuzzy

dapat memberikan pengelompokan dengan memberi nilai dalam derajat tertentu.

Berbeda dengan himpunan klasik, keanggotaan himpunan fuzzy dapat bernilai

parsial [6:1].

Gambar 2.3 Perbandingan Fungsi Keanggotaan Himpunan Fuzzy Terhadap Crisp

Sumber : [6:1]

Fungsi keanggotaan didefinisikan sebagai berikut: Jika X adalah himpunan

semesta, maka fungsi keanggotaan �� (fungsi keanggotaan/fungsi karakteristik A

pada X) yang didefinisikan oleh himpunan fuzzy A memiliki ketentuan berikut: �� ∶ � → [0,1]………………………………………………………(2-1)

nilai [0,1] adalah interval bilangan real dari nol sampai dengan satu. Dua

himpunan A dan B dinyatakan sama jika dan hanya jika ��(x) = ��(x). Jika ��(x)

bernilai nol, berarti x bukan anggota dari himpunan fuzzy A. Jika ��(x) bernilai

satu, menunjukkan x adalah himpunan fuzzy A. Sementara nilai antara nol hingga

X

1.0

0.0

Classical (crips) set A

Fuzzy set Ā

Membership

function µ(x)

µ(x)

14

satu menunjukkan bahwa x merupakan anggota dari himpunan fuzzy A secara

parsial [6:1-2].

2.3.2 Fungsi Keanggotaan Fuzzy

Fungsi keanggotaan (membership function) adalah suatu kurva yang

menunjukkan pemetaan titik-titik input data ke dalam nilai keanggotaannya

(sering juga disebut dengan derajat keanggotaan) yang memiliki interval 0 sampai

1. Salah satu cara yang dapat digunakan untuk mendapatkan nilai keanggotaan

adalah menggunakan pendekatan fungsi. Macam-macam fungsi keanggotaan

[10:16-17]:

1. Fungsi keanggotaan yang mempunyai parameter a, b, dan c dengan

formulasi segitiga (x: a, b, c) = max{min{(x –a)/(b-a), (c-x)/(c-b)}, 0}.

Gambar 2.4 Fungsi Keanggotaan Segitiga Sumber: [10:17]

dengan a, b, dan c merupakan parameter segitiga (x: a, b, c). Fungsi

Keanggotaan Kurva Segitiga:

�[ ]��0; ≤ �� ≥ �� ; � < ≤ �� ; � < < � …………………………………….…(2-2)

15

2. Fungsi keanggotaan yang mempunyai parameter a,b,c, dan d dengan

formulasi Trapesium (x; a, b, c, d) = max{min{(x-a)/(b-a), 1, (d-x)/(d-c)},

0}.

Gambar 2.5 Fungsi Keanggotaan Trapesium Sumber : [10:17]

dengan a,b,c, dan d merupakan parameter trapesium (x: a, b, c, d). Fungsi

Keanggotaan Kurva Trapesium:

�[ ]�!�!�0; ≤ �� ≥ "�� ; � < ≤ �1; � < ≤ ��#��#� � ; � < < "…………………………..………….(2-3)

2.4 Fuzzy Inference System (FIS) Tsukamoto

Inferensi adalah proses penggabungan banyak aturan berdasarkan data

yang tersedia. Komponen yang melakukan inferensi dalam sistem pakar disebut

mesin inferensi. Dua pendekatan untuk menarik kesimpulan pada IF-THEN rule

(aturan jika-maka) adalah forward chaining dan backward chaining [3:36].

2.4.1 Forward Chaining

Forward chaining mencari bagian JIKA terlebih dahulu. Setelah semua

kondisi dipenuhi, aturan dipilih untuk mendapatkan kesimpulan. Jika kesimpulan

16

yang diambil dari keadaan pertama bukan dari keadaan yang terakhir, maka ia

akan digunakan sebagai fakta untuk disesuaikan dengan kondisi aturan JIKA yang

lain untuk mendapatkan kesimpulan yang lebih baik. Proses ini berlanjut hingga

dicapai kesimpulan akhir.

2.4.2 Backward Chaining

Backward chaining adalah kebalikan dari forward chaining. Pendekatan ini

dimulai dari kesimpulan dan hipotesis bahwa kesimpulan adalah benar. Mesin

inferensi kemudian mengidentifikasi kondisi JIKA yang diperlukan untuk

membuat kesimpulan benar dan mencari fakta untuk menguji apakah kondisi

JIKA adalah benar. Jika semua kondisi JIKA adalah benar, maka aturan dipilih

dan kesimpulan dicapai. Jika beberapa kondisi salah, maka aturan dibuang dan

aturan berikutnya digunakan sebagai hipotesis kedua. Jika tidak ada fakta yang

membuktikan bahwa semua kondisi JIKA adalah benar atau salah, maka mesin

inferensi terus mencari aturan yang kesimpulannya sesuai dengan kondisi JIKA

yang tidak diputuskan untuk bergerak satu langkah ke depan memeriksa kondisi

tersebut. Proses ini berlanjut hingga suatu set aturan didapat untuk mencapai

kesimpulan atau untuk membuktikan tidak dapat mencapai kesimpulan.

Sistem inferensi fuzzy merupakan suatu kerangka komputasi yang

didasarkan pada teori himpunan fuzzy, aturan fuzzy yang berbentuk IF-THEN, dan

penalaran fuzzy. Secara garis besar, diagram blok proses inferensi fuzzy terlihat

pada Gambar 2.6.

17

Gambar 2.6 Diagram Blok Sistem Inferensi Fuzzy

Sumber: [3:37]

Sistem inferensi fuzzy menerima input crisp. Data input kemudian dikirim

ke basis pengetahuan yang berisi n aturan fuzzy dalam bentuk IF-THEN. Fire

strength (nilai keanggotaan anteseden atau α) akan dicari pada setiap aturan. Apabila

aturan lebih dari satu, maka akan dilakukan agregasi semua aturan. Selanjutnya

pada hasil agregasi akan dilakukan defuzzy untuk mendapatkan nilai crisp sebagai

output sistem. Salah satu metode FIS yang dapat digunakan untuk pengambilan

keputusan adalah metodeTsukamoto.

Pada metode Tsukamoto, implikasi setiap aturan berbentuk implikasi

"Sebab-Akibat"/Implikasi "Input-Output" yang antara anteseden dan konsekuen harus ada

berhubungan. Setiap aturan direpresentasikan menggunakan himpunan-himpunan

fuzzy, dengan fungsi keanggotaan yang monoton. Kemudian untuk menentukan

hasil tegas (crisp solution) digunakan rumus penegasan (defuzzifikasi) yang

disebut "Metode rata-rata terpusat" atau "Metode defuzzifikasi rata-rata terpusat

(center average deffuzzyfier). Untuk lebih memahami metodeTsukamoto,

perhatikan Contoh 2.1.

Contoh 2.1: Misalkan ada 2 variabel input, Var-1 (x) dan Var-2(x), serta variabel

output, Var-3(z), dimana Var-1 terbagi atas 2 himpunan yaitu A1 dan A2. Var-2

Input

IF-THEN

IF-THEN

Agregasi

Defuzzy

Output

Crips

Aturan-1

Aturan-n

Fuzzy

FuzzyFuzzy

Crips

18

terbagi atas 2 himpunan B1 dan B2, Var-3 juga terbagi atas 2 himpunan yaitu C1

dan C2 (C1 dan C2 harus monoton). Ada 2 aturan yang digunakan, yaitu:

[R1] IF (x is A1) and (y is B2) THEN (z is C1)

[R2] IF (x is A2) and (y is B1) THEN (z is C2)

Pertama-tama dicari fungsi keanggotaan dari masing-masing himpunan

fuzzy dari setiap aturan, yaitu himpunan A1, B2 dan C1 dari aturan fuzzy [R1], dan

himpunan A2, B1 dan C2 dari aturan fuzzy [R2]. Aturan fuzzy R1 dan R2 dapat

direpresentasikan dalam Gambar 2.7 untuk mendapatkan suatu nilai crisp Z.

Gambar 2.7 Inferensi dengan menggunakan MetodeTsukamoto

Sumber: [3:39]

Karena pada metode Tsukamoto operasi himpunan yang digunakan adalah

konjungsi (AND), maka nilai keanggotaan anteseden dari aturan fuzzy [R1] adalah

irisan dari nilai keanggotaan A1 dari Var-1 dengan nilai keanggotaan B1 dari Var-2.

Menurut teori operasi himpunan, maka nilai keanggotaan anteseden dari operasi

konjungsi (And) dari aturan fuzzy [R1] adalah nilai minimum antara nilai

19

keanggotaan A1 dari Var-1 dan nilai keanggotaan B2 dari Var-2. Demikian pula

nilai keanggotaan anteseden dari aturan fuzzy [R2] adalah nilai minimum antara

nilai keanggotaan A2 dari Var-1 dengan nilai keanggotaan B1 dari Var-2.

Selanjutnya, nilai keanggotaan anteseden dari aturan fuzzy [R1] dan [R2]

masing-masing disebut dengan α1 dan α2. Nilai α1 dan α2 kemudian disubstitusikan

pada fungsi keanggotaan himpunan C1 dan C2 sesuai aturan fuzzy [R1] dan [R2]

untuk memperoleh nilai z1 dan z2, yaitu nilai z (nilai perkiraan produksi) untuk

aturan fuzzy [R1] dan [R2]. Nilai output crisp/nilai tegas Z dapat diperoleh

dengan cara mengubah input (berupa himpunan fuzzy yang diperoleh dari

komposisi aturan-aturan fuzzy) menjadi suatu bilangan pada domain himpunan

fuzzy tersebut. Cara ini disebut dengan metode defuzzifikasi(penegasan). Metode

defuzzifikasi yang digunakan dalam metode Tsukamoto adalah metode

defuzzifikasi rata-rata terpusat (center average defuzzyfier).

2.5 Bahasa Pemrograman Java

Bahasa pemrograman Java dikembangkan di Sun Microsystems dibawah

pengawasan dari tokoh-tokoh dari Net yaitu James Gosling dan Bill Joy. Java

didesain agar menjadi bahasa pemrograman yang independen terhadap jenis

mesin (machine-independent) yang cukup aman untuk melintasi jaringan dan

kuat untuk menggantikan kode executable asal.

Sebagian besar antusiasme untuk Java pada awalnya tersentralisasi sekitar

kapabilitasnya untuk membangun aplikasi tertanam (embedded applications)

untuk World Wide Web; aplikasi ini disebut applets. Applets dapat menjadi

program mandiri pada dirinya sendiri, atau front-end mutakhir pada program

yang dijalankan pada server. Ketertarikan telah bergeser ke area lain akhir-akhir

ini. Dengan Java 2, Java memiliki alat paling mutakhir untuk membangun

antarmuka pengguna berbasis grafis (graphical user interface); perkembangan ini

membuat Java menjadi platform populer untuk mengembangkan perangkat lunak

aplikasi tradisional. Java juga sudah menjadi platform penting untuk aplikasi sisi

server, menggunakan antarmuka servlet, dan untuk aplikasi enterprise

20

menggunakan teknologi seperti Enterprise JavaBeans. Dan Java adalah pilihan

platform untuk aplikasi terdistribusi modern.

“Bibit” Java ditanam pada tahun 1990 oleh kepala peneliti Sun

Microsystems yaitu Bill Joy. Sun telah mendorong suatu ide sejak permulaan Sun

di awal tahun 1980: “Jaringan adalah computer”. Sun berkompetisi dalam

workstation market yang relatif kecil pada waktu itu, sedangkan Microsoft

memulai dominasi dari dunia PC berbasis Intel. Saat Sun ketinggalan dalam

revolusi PC, Joy ditarik ke Aspen, Colorado, untuk bekerja pada penelitian yang

lebih lanjut. Ia berkomitmen untuk menyelesaikan tugas kompleks dengan

perangkat lunak sederhana, dan menemukan yang tepatnya disebut Sun Aspen

Smallworks.

Dari anggota asli tim programmer kecil yang dibentuk di Aspen, James

Gosling yang akan diingat sebagai bapak Java. Gosling pertama kali melejitkan

namanya di awal tahun 1980 sebagai penulis Gosling Emacs, versi pertama dari

editor Emacs populer yang ditulis bengan bahasa C dan dijalankan dibawah

Unix. Gosling Emacs menjadi populer, namun kemudian tertutup oleh versi

gratis, GNU Emacs, yang ditulis oleh desainer asli Emacs. Gosling telah pindah

untuk mendesain sistem window NeWS dari Sun pada waktu itu.

Mendesain NeWS mengajarkan Gosling kekuatan dari integrasi bahasa

ekspresif dengan network-aware windowing GUI. Hal tersebut juga mengajarkan

Sun bahwa komunitas pemrograman internet akan menolak untuk menerima

standar hak milik, tidak peduli seberapa bagus hal tersebut nantinya. “Bibit” dari

skema lisensi permissive disebarkan oleh kegagalan NeWS. Gosling membawa

apa yang telah ia pelajari ke proyek Aspen baru milik Bill Joy, dan pada 1992,

bekerja pada proyek memimpin ke penemuan cabang Sun, FirstPerson, Inc.

Misinya adalah untuk memimpin Sun menuju dunia elektronik consumer.

Tim FirstPerson bekerja pada mengembangkan perangkat lunak untuk alat

informasi, seperti telepon seluler dan personal digital assistants (PDAs).

Tujuannya adalah untuk meng-enable transfer informasi dan aplikasi real-time

melalui infrared murah dan jaringan berbasis paket. Limitasi memori dan

bandwidth mendiktekan kode kecil dan efisien. Basis dari aplikasi juga menuntut

mereka untuk menjadi aman dan kuat. Gosling dan anggota timnya memulai

21

memrogram di C++, namun mereka kemudian terkepung dalam bahasa yang

terlalu kompleks, berat, dan tidak aman untuk tugasnya. Mereka memutuskan

untuk memulai dari awal, dan Gosling memulai bekerja pada sesuatu yang ia

juluki “C++ minus minus”.

Telah menjadi kenyataan bahwa bahtera PDA belum sampai dengan

tenggelamnya Apple Newton, jadi Sun mengalihkan usaha FirstPerson ke TV

interaktif (ITV). Bahasa pemrograman terpilih untuk ITV merupakan nenek

moyang dekat dari Java, yaitu Oak. Oak tidak mampu menyelamatkan penyebab

hilangnya ITV bahkan dengan keeleganannya dan kemampuannya untuk

menyediakan interaktifitas aman. Pelanggan tidak menginginkannya, dan Sun

kemudian mengabaikan konsep tersebut.

Joy dan Gosling berkolaborasi untuk memutuskan strategi baru untuk

bahasa mereka pada waktu itu. Pada waktu itu di tahun 1993, terjadi ledakan

interest di internet, khususnya World Wide Web, yang mempersembahkan

kesempatan baru. Oak adalah bahasa pemrograman yang kecil, kuat,

architecture-independent, dan berorientasi obyek. Selama hal tersebut terjadi,

terdapat pula kebutuhan untuk bahasa pemrograman yang universal dan pandai-

jaringan (network-savvy). Sun dengan cepat mengubah fokus, dengan sedikit

melengkapi kembali, Oak menjadi Java [4 : 10]

2.6 Metode SBAR

Kerangka komunikasi efektif yang digunakan di rumah sakit adalah

komunikasi SBAR (Situation, Background, Assessment, Recommendation).

Metode komunikasi ini digunakan pada saat perawat melakukan handover ke

pasien. Komunikasi SBAR adalah kerangka teknik komunikasi yang disediakan

untuk petugas kesehatan dalam menyampaikan kondisi pasien[14:6].

SBAR adalah metode terstruktur untuk mengkomunikasikan informasi

penting yang membutuhkan perhatian segera dan tindakan berkontribusi terhadap

eskalasi yang efektif dan meningkatkan keselamatan pasien. SBAR juga dapat

digunakan secara efektif untuk meningkatkan serah terima antar shift atau antara

staf di daerah klinis yang sama atau berbeda. Melibatkan semua anggota tim

22

kesehatan untuk memberikan masukan ke dalam situasi pasien termasuk

memberikan rekomendasi. SBAR memberikan kesempatan untuk diskusi antara

anggota tim kesehatan atau tim kesehatan lainnya.

Keuntungan dari penggunaan metode SBAR adalah[14:6-7]:

1. Kekuatan perawat berkomunikasi secara efektif.

2. Dokter percaya pada analisa perawat karena menunjukkan perawat paham

akan kondisi pasien.

3. Memperbaiki komunikasi sama dengan memperbaiki keamanan pasien.

Komunikasi efektif SBAR dapat diterapkan oleh semua tenaga kesehatan,

diharapkan semua tenaga kesehatan maka dokumentasi tidak terpecah sendiri-

sendiri. Diharapkan dokumentasi catatan perkembangan pasien terintegrasi

dengan baik. sehingga tenaga kesehatan lain dapat mengetahui perkembangan

pasien.

1. Situation: Bagaimana situasi yang akan dibicarakan/dilaporkan?

- Mengidentifikasi nama diri petugas dan pasien.

- Diagnosa medis

- Apa yang terjadi dengan pasien yang memprihatinkan

2. Background: Apa latar belakang informasi klinis yang berhubungan dengan

situasi?

- Obat saat ini dan alergi

- Tanda-tanda vital terbaru

- Hasil laboratorium: tanggal dan waktu tes dilakukan dan hasil tes

sebelumnya untuk perbandingan

- Riwayat medis

- Temuan klinis terbaru

3. Assessment: berbagai hasil penilaian klinis perawat

- Apa temuan klinis?

- Apa analisis dan pertimbangan perawat

- Apakah masalah ini parah atau mengancam kehidupan?

4. Recommendation: apa yang perawat inginkan terjadi dan kapan?

- Apa tindakan/rekomendasi yang diperlukan untuk memperbaiki masalah?

- Apa solusi yang bisa perawat tawarkan dokter?

23

- Apa yang perawat butuhkan dari dokter untuk memperbaiki kondisi

pasien?

- Kapan waktu yang perawat harapkan tindakan ini terjadi?

Sebelum serah terima pasien, perawat harus melakukan [14:8]:

1. Perawat mendapatkan pengkajian kondisi pasien terkini.

2. Perawat mengkumpulkan data-data yang diperlukan yang berhubungan

dengan kondisi pasien yang akan dilaporkan.

3. Perawat memastikan diagnosa medis pasien dan prioritas masalah

keperawatan yang harus dilanjutkan.

4. Perawat membaca dan pahami catatan perkembangan terkini & hasil

pengkajian perawat shift sebelumnya.

5. Perawat menyiapkan medical record pasien termasuk rencana perawat harian.

24

BAB III

METODOLOGI PENELITIAN

Pada bab ini akan dibahas tentang langkah-langkah yang akan dilakukan

dalam penyusunan proyek akhir mata kuliah Logika Fuzzy, yang meliputi: studi

literatur, pengumpulan data, analisa dan perancangan, implementasi, pengujian

sistem, pembuatan laporan. Berikut adalah diagram alir dari metode penelitian

yang dilakukan.

Gambar 3.1 Alur Penelitian

Sumber: Perancangan

25

3.1 Studi Literatur

Dasar teori yang digunakan untuk menunjang penulisan serta pengerjaan

proyek akhi, dipelajari dalam studi literatur. Teori-teori pendukung penulisan serta

pemahaman tentang tugas akhir diperoleh dari buku, jurnal, e-book, penelitian

sebelumnya yang berkaitan tentang topic proyek akhir ini, bantuan dan mesin

pencari (search engine) internet. Referensi utama yang diperlukan untuk

menunjang penulisan ini adalah:

1. Pelayanan rawat inap

2. Sistem Pakar

3. Metode Fuzzy Tsukamotto

4. Metode SBAR

5. EWS (early warning score)

6. Pengujian Akurasi

3.2 Pengumpulan Data

Lokasi penelitian proyek akhir ini adalah Rumah Sakit Umum Lavalette

Malang. Hipotesis penelitian ini merancang, membangun, dan

mengimplementasikan sistem pakar pemantau kondisi pasien rawat inap

menggunakan fuzzy inferensi Tsukamotto. Pengumpulan data pada penelitian ini

menggunakan data primer. Data primer adalah data yang didapatkan langsung dari

sumber penelitian. Pengumpulan data primer dapat dilakukan menggunakan

wawancara, kuisioner maupun observasi.

3.3 Analisa Kebutuhan

Analisis kebutuhan bertujuan untuk mendapatkan semua kebutuhan dalam

membangun sistem pakar pemantau kondisi pasien rawat inap. Metode analisis

yang digunakan adalah Object Oriented Analysis dengan menggunakan bahasa

pemodelan UML (Unified Modeling Language). Diagram Use Case digunakan

untuk mendeskripsikan kebutuhan-kebutuhan dan fungsionalitas sistem dari

26

perspektif end-user. Analisis kebutuhan dilakukan dengan mengidentifikasi semua

kebutuhan (requirements) sistem.

Sumber data yang digunakan berasal rumah sakit Lavalette. Data yang

dimaksud adalah sistem pemantauan kondisi pasien rawat inap yang sudah ada di

rumah sakit Lavalette sebagai acuan dalam pengembangan aplikasi dan

perancangan sistem. Selain itu, diperlukan juga kuisioner, untuk menentukan

kebutuhan pasien dan tenaga medis dalam sistem yang diinginkan. Data-data

tersebut digunakan untuk menghitung tingkat keberhasilan dari sistem. Diagram

alir untuk pengambilan data sampel ditunjukkan pada Gambar 3.2.

Gambar 3.2 Diagram Alir Pengambilan Data Sampel Sumber: Perancangan

Spesifikasi Kebutuhan perangkat yang digunakan dalam pembuatan sistem

pakar diantaranya:

1. Spesifikasi Kebutuhan Hardware

a. Komputer (PC)/Laptop

27

2. Spesifikasi Kebutuhan Software

a. Linux distribusi Ubuntu 12.04 sebagai sistem operasi yang

digunakan.

b. MySql sebagai sistem manajemen database.

c. Bahasa Java dipilih untuk membangun aplikasi.

3.4 Analisa Perancangan

Analisa dan perancangan sistem dilakukan sebelum penelitian

dilaksanakan, Analisa dan perancangan sistem berisi uraian umum tentang

jalannya sistem.

3.4.1 Deskripsi Sistem

Sistem pakar pemantau kondisi pasien rawat inap dibangun dengan

menerapkan metode fuzzy inferensi Tsukamotto. Arsitektur sistem pakar pemantau

kondisi pasien rawat inap dibentuk seperti pada Gambar 3.3.

28

Gambar 3.3 Arsitektur Sistem Pakar Pemantau kondisi Rawat Inap

Sumber: Perancangan

Proses yang dapat dijelaskan dari arsitektur sistem pakar pemantau kondisi

pasien rawat inap yakni, pertama perawat akan memasukkan data PHR (Personal

Healt Record) yang meliputi tekanan darah, heart rate, suhu, gula darah dan

tingkat kejenuhan oksigen (SPO2) ke dalam sistem. Selanjutnya, masuan tersebut

akan menentukan rekomendasi tindakan dari tenaga medis yang sesuai.

Proses interaksi user dengan sistem dilakukan melalui antarmuka

pengguna. Pada antarmuka juga dilengkapi dengan fasilitas penjelas yang

memberikan penjelasan bagaimana hasil kesimpulan diperoleh sehingga dapat

meyakinkan pengguna. Kesimpulan yang diperoleh dari input yang diberikan

berupa rekomendasi tindakan yang harus dilakukan oleh tenaga medis yang sesuai

dengan kondisi pasien saat itu.

29

Pakar mengambil peranan sangat aktif dalam pembuatan basis

pengetahuan. Tempat kerja disediakan bagi pakar untuk membantu memberikan

solusi bagi permasalahan saat sistem dijalankan dan menyedikan fasilitas untuk

menulis agenda dan deskripsi terhadap permasalahan khusus yang belum

diprediksi. Knowledge engineer bertanggung jawab membuat kesan yang tepat,

secara positif mengomunikasikan informasi tentang proyek, memahami tipe

pakar, mempersiapkan sesi, dan seterusnya.

Metode akuisisi pengetahuan yang digunakan adalah metode manual, yang

terdiri dari:

1. Metode wawancara terstuktur

Teknik wawancara melibatkan dialog langsung antara pakar dan

knowledge engineer. Informasi dikumpulkan dengan bantuan instrumen

konvensional (misalnya tape recorder atau kuisioner) dan selanjutnya

ditranskip, dianalisis dan dikodekan. Metode wawancara terstruktur

adalah proses berorientasi tujuan yang sistematik. Proses berorientasi

tujuan menekankan komunikasi terorganisasi antara knowledge engineer

dan pakar. Struktur sistematik mengurangi persoalan interpretasi yang

inheren dan memungkinkan knowledge engineer mencegah distorsi yang

disebabkan oleh subjektivitas pakar domain.

2. Metode analisis kasus

Pada metode analisis kasus, pakar ditanya bagaimana mereka menangani

kasus khusus di masa sebelumnya. Biasanya metode ini melibatkan

analisis dokumentasi .

Basis pengetahuan sistem pakar ini berisi pengetahuan setara pakar yang

telah diisi oleh knowledge engineer. Basis pengetahuan berisi fakta tindakan-

tindakan yang harus dilakukan seorang tenaga medis yang sesuai dengan kondisi

pasien serta aturan yang berhubungan dengan metode fuzzy. Representasi yang

digunakan yaitu aturan produksi, karena pada basis pengetahuan digunakan aturan

pengetahuan sedangkan pada mesin inferensi dapat digunakan aturan inferensi

dengan menerapkan metode fuzzy.

30

Konsep pengetahuan yang dibangun terdiri dari atribut dan alternatif yang

dibutuhkan. Atribut yang diperlukan disesuaikan dengan data input PHR.

Alternatif yang dihasilkan sesuai dengan yang ditentukan pada batasan masalah.

Konsep pengetahuan yang dibangun, digambarkan pada Tabel 3.1.

Tabel 3.1 Konsep pengetahuan sistem pakar pemantau kondisi pasien rawat inap

Total Score Minimum

Observation Frequency

Alert Response

1 12 Hourly Nurse in charge Nurse in charge to

review if new score 1

2 6 Hourly Nurse in charge Nurse in charge t

review

3 4 Hourly Nurse in charge & Team/On-call SHO

1. SHO to review within 1 hour

4-6 1 Hourly

Nurse in charge & Team/On-call SHO

1. SHO to review within ½ hour

2. If no response to treatment within 1 hour, contact Registrar

3. Consider continuous patient monitoring

4. Consider transfer to higher level of care

>= 7 ½ Hourly

Nurse in charge & Team/On-call Registrar inform Team/On-call Consultant

1. Registrar to review immediately

2. Continuous patient monitoring recommended

3. Plan to transfer to higher level of care

4. Activate Emergency Response System (ERS) (as appropriate to hospital model)

31

Note: Single score triggers

Score of 2 HR <= 40

(Bradicardia) ½ Hourly


1. SHO to review immediately

*score of 3 in any single parameter

½ Hourly pr as indicated by patient’s condition


1. SHO to review immediately

2. If no response to treatment or still concerned contact Registrar

3. Consider activating ERS

* in certain circumstances a score of 3 in a single parameter may not require ½ hourly observations. i.e. some patients on O2

• When communicatingpatiens score inform relevant personnel if patient is charted for supplemental oxygen e.g. post-op.

• Document all communication and management plans at each escalation point in medical and nursing notes.

• Escalation protocol may be stepped down as appropriate and documented in management plan.

IMPORTANT:

1. If response is not carried out as above CNM/Nurse in charge must contact the Registrar or Consultant.

2. If you are concerned about a patient ascalate care regardless of score. Sumber: [12:24]

Basis pengetahuan berinteraksi dua arah dengan mesin inferensi; pada

mesin inferensi ini sendiri dilakukan proses pengambilan kesimpulan. Metode

penalaran yang dilakukan adalah forward chaining, yaitu berjalan dari fakta

menuju kesimpulan. Pada sistem ini dilakukan update pengetahuan dan perbaikan

secara teratur sehingga informasi yang diberikan tetap valid.

Berikut ini adalah penjelasan antarmuka pengguna saat user mengakses

aplikasi sistem pakar yang digambarkan dalam diagram alir:

1. Perawat

32

Proses penggunaan aplikasi saat log in sebagai perawat harus melakukan

log in untuk bisa masuk ke sistem. Setelah masuk ke sistem perawat harus

memasukan data PHR. Pada tahap selanjutnya proses akan berlangsung

secara otomatis. Masukan akan diproses dengan metode fuzzy sehingga

akan ditampilkan penjelasan pengambilan kesimpulan dan analisis dari

pakar.

Gambar 3.4 Diagram alir aplikasi dari segi user

Sumber: Perancangan

Proses representasi pengetahuan yang menggunakan metode aturan

produksi ditunjukkan saat proses user memasukkan data. Teknik penalaran

forward chaining ditunjukkan saat user melakukan entry data berupa fakta

hingga akhirnya mendapat keluaran berupa tindakan yang perlu dilakukan.

33

Proses inferensi dilakukan dengan menerapkan metode TOPSIS, sehingga

diperoleh kesimpulan dari fakta yang diketahui.

2. Pakar

Proses penggunaan aplikasi dari segi pakar dimulai dari pakar melakukan

log in. Setelah masuk sebagai pakar, akan muncul halaman utama. Pada

halaman utama, pakar dapat melihat data-data masukan PHR dan data

rekomendasi hasil analisis dari sistem. Selanjutnya terhadapa menu untuk

pakar mengedit data. Edit data dimaksudkan untuk mengubah data dan

atau menambahkan data hasil analisis dari sistem. Data yang telah

diakusisi oleh pakar akan ditampilkan sebagai hasil akhir.

Gambar 3.5 Diagram alir aplikasi dari segi pakar Sumber: Perancangan

34

3.5 Implementasi Sistem

Implementasi aplikasi dilakukan dengan mengacu kepada perancangan

aplikasi. Implementasi perangkat lunak dilakukan menggunakan bahasa

pemrograman Java dengan Netbeans IDE. Pada pembuatan database sistem pakar,

digunakan Database Management System (DBMS) MySQL.

3.6 Uji Coba Sistem

Pengujian sistem dilakukan untuk mengetahui kesesuai dengan harapan

awal. Pengujian terdiri dari:

1. Pengujian akurasi

Melakukan pengujian berdasarkan implementasi yang telah dibuat

melalui perhitungan akurasi. Perhitungan akurasi digambarkan pada

diagram alir berikut.

Gambar 3.6 Diagram alir proses pengujian dengan akurasi

Sumber: Perancangan

35

Pada Gambar 3.6, pertama dilakukan perhitungan antara data hasil

keluaran dari sistem dengan hasil keluaran yang diberikan oleh pakar

yang menggunakan proses manual. Proses manual pakar adalah proses

yang biasa dilakukan pakar untuk memberi keluaran dengan

subjektifitas pakar kesahatan. Hasil akurasi yang didapat akan

digunakan sebagai acuan sebagai hasil akhir akurasi.

2. Pengujian fungsional sistem

Pengujian fungsional sistem berfungsi untuk mengetahui kinerja sistem

sesuai dengan rancangan dan tujuan yang dibuat. Berikut ini adalah

diagram alir pengujian fungsional dari sistem pakar pemilihan bidang

studi.

Gambar 3.7 Diagram alir proses pengujian fungsional sistem

Sumber: Perancangan

36

Pengujian fungsional ini dilakukan dengan memeriksa keterpenuhan

fungsional sistem pada aplikasi sistem pakar yang dibuat.

3.7 Penarikan Kesimpulan

Kesimpulan dilakukan setelah semua tahapan perancangan, implementasi

dan pengujian sistem terhadap metode yang digunakan. Penulisan saran berguna

untuk memberikan pertimbangan atas hasil yang telah dilakukan.

37

BAB IV

PERANCANGAN

Pada bab ini akan dibahas tentang perancangan sistem pakar untuk

pemantau kondisi pasien rawat inap. Tahap perancangan sistem terdiri dari

analisis kebutuhan perangkat lunak dan perancangan sistem pakar. Tahap analisis

kebutuhan perangkat lunak meliputi identifikasi aktor, daftar kebutuhan sistem,

dan use case diagram serta skenario use case. Sedangkan tahap perancangan

sistem pakar meliputi akuisisi pengetahuan, basis pengetahuan, mesin inferensi,

dan sub sistem antarmuka. Berikut ilustrasi pohon perancangan Sistem Pakar

Pemantau Kondisi Pasien Rawat Inap Menggunakan Fuzzy Inferensi Tsukamoto.

Gambar 4.1 Pohon Perancangan Sistem Pakar Pemantau Kondisi Pasien Rawat Inap Menggunakan Fuzzy Inferensi Tsukamoto

Sumber: Perancangan

4. Perancangan

4.1 Analisis Kebutuhan

Perangkat Lunak

4.1.1 Identifikasi Aktor

4.1.2 Daftar Kebutuhan Sistem

4.1.3 Use Case Diagram

4.1.4 Skenario Use Case

4.2 Perancangan Sistem Pakar

4.2.1 Akuisisi Pengetahuan

4.2.2 Basis Pengetahuan

4.2.3 Mesin Inferensi

4.2.4 Subsistem Antarmuka

38

4.1 Analisa Kebutuhan Perangkat Lunak

Tahapan analisa kebutuhan sistem memiliki tujuan untuk memodelkan

informasi yang akan digunakan dalam tahapan perancangan. Analisa kebutuhan

sistem yang diperlukan meliputi identifikasi aktor, daftar kebutuhan sistem, dan

use case diagram. Berikut ini merupakan penjelasan dari masing-masing

tahapannya.

4.1.1 Identifikasi Aktor

Tahapan ini bertujuan untuk mengidentifikasi aktor-aktor yang nantinya

akan berinteraksi dengan sistem. Pada kolom aktor disebutkan aktor yang

berperan dalam sistem dan pada kolom lainnya akan menunjukkan deskripsi dari

aktor. Tabel 4.1 memperlihatkan aktor yang berperan dalam sistem yang

dilengkapi dengan penjelasannya yang merupakan hasil dari proses identifikasi

aktor.

Tabel 4.1 Identifikasi Aktor

Aktor Deskripsi Aktor

User User merupakan aktor pengguna yang ingin mendapatkan analisis sistem pakar yang berupa pemantau kondisi pasien.

Sumber: Perancangan

4.1.2 Daftar Kebutuhan Sistem

Tahapan ini bertujuan untuk menjelaskan kebutuhan sistem yang harus

dipenuhi saat aktor melakukan sebuah aksi. Daftar kebutuhan ini terdiri dari

sebuah kolom yang merupakan hal-hal yang harus disediakan oleh sistem,

sedangkan pada kolom yang lain menunjukkan nama use case yang menampilkan

fungsionalitas masing-masing kebutuhan tersebut.

Tabel 4.2 Daftar kebutuhan Sistem

Kebutuhan Aktor Nama Use Case

39

Sistem harus User

User

User

User

Sumber: Perancangan

4.1.3 Diagram Use Case

Use case diagram merupakan salah satu diagram yang digunakan untuk

menggambarkan kebutuhan-kebutuhan dan fungsionalitas dari sistem serta

digunakan untuk menunjukan aksi-aksi yang dilakukan oleh aktor dari sistem.

Gambar 4.2 merupakan diagram use case sistem pakar yang menunjukkan

spesifikasi fungsionalitas yang disediakan oleh sistem dari segi aktor Admin dan

User.

Gambar 4.2 Diagram Use Case

Calculate

Reset

Lihat Hasil

Lihat Rule

Remove Rule

User

40

Sumber: Perancangan

Dalam sistem ini aktor dapat memasukkan kondisi pasien. Selain itu aktor

juga dapat mengkalkulasi hasil dari inputan kondisi pasien. Secara otomatis

sistem akan menyimpan hasil-hasil analisa sistem pakar serta dapat melihat rule.

Disamping itu user dapat mengatur ulang input kondisi pasien serta menghapus

rule.

4.1.4 Skenario Use Case

Use case yang telah digambarkan dalam diagram use case akan lebih

dijelaskan secara terperinci dalam skenario use case. Penggunaan skenario use

case ini bertujuan untuk mendapatkan deskripsi secara global mengenai use case,

kondisi awal dan akhir yang harus dipenuhi oleh use case setelah fungsionalitas

telah dijalankan. Dalam Tabel 4.3 akan menjelaskan bagaimana tanggapan sistem

terhadap aksi yang dilakukan oleh aktor.

Tabel 4.3 Skenario Use Case

Identifikasi

Nama Mengolah data

Deskripsi Use case ini menjelaskan tentang proses input data dalam sistem

Aktor User

Pra-kondisi Sistem telah menampilkan halaman user

Skenario Input Data

Aksi Aktor Reaksi Sistem

• Aktor masuk ke halaman utama • Sistem menampilkan halaman utama

• Aktor masuk ke menu input data • Sistem menampilkan halaman menu input data

• Aktor masukkan data-data berupa kondisi pasien.

• Sistem memasukkan data yang telah dimasukkan oleh aktor ke dalam database.

• Sistem menampilkan hasil analisis sistem pakar.

41

• Aktor melihat hasil data sebelumnya.

• Sistem menampilkan hasil proses data yang dimasukkan sebelumnya.

• Aktor mereset hasil data. • Sistem mereset hasil data. Sumber: Perancangan

4.2 Perancangan Sistem Pakar

Berikut ini dijelaskan tentang perancangan sistem pakar yang terdiri dari

akuisisi pengetahuan, basis pengetahuan, mesin inferensi, dan subsistem

antarmuka.

4.2.1 Akuisisi Pengetahuan

Akuisisi pengetahuan dilakukan dengan mencari berbagai informasi

tentang kondisi pasien berdasarkan tekanan darah (SBP), Heart Rate (HR),

kejenuhan kandungan oksigen dalam darah pasien (SPO2), Suhu (Temp), gula

darah (BS), dan mesin inferensi. Informasi diperoleh dari buku, jurnal, laporan

penelitian, skripsi yang telah ada sebelumnya, dan internet. Informasi-informasi

yang diperoleh membantu dalam proses pembuatan sistem pakar untuk

pemantauan kondisi pasien rawat inap.

4.2.2 Basis Pengetahuan

Basis pengetahuan berisi pengetahuan-pengetahuan pakar berupa fakta-

fakta, konsep, aturan, prosedur, dan hubungan di antaranya, yang telah

direpresentasikan dalam bentuk yang dimengerti oleh sistem. Basis pengetahuan

dibutuhkan untuk memahami, memformulasikan, dan memecahkan masalah yang

dihadapi oleh sistem, di sini basis pengetahuan berfungsi sebagai sumber referensi

untuk mengambil suatu tindakan. Basis pengetahuan dalam sistem pakar ini

meliputi himpunan bahasa variabel, semesta pembicaraan, fungsi derajat

keanggotaan, dan rule.

42

4.2.2.1 Himpunan Bahasa Variable

Himpunan bahasa variabel pada sistem pakar pemantau kondisi pasien

rawat inap adalah sebagai berikut

1.Tekanan Darah (SBP) : Low-3, Low-2, Low-1, Normal-0, High-2.

2.Heart Rate (HR) : Low-2, Low-1, Normal-0, High-1, High-2, High-3

3.Saturasi O2 (SPO2) : Low-3, Low-2, Low-1, Normal-0.

4.Suhu (TEMP) : Low-2, Normal-0, High-2

5.Gula Darah (BS) : Low-3, Low-2, Normal-0, High-2, High-3.

4.2.2.2 Semesta Pembicaraan

Berikut ini adalah semesta pembicaraan yang menjelaskan tentang kondisi

pasien rawat inap yang berdasarkan rentang kriteria-kriteria beserta rentang nilai

yang ditentukan oleh pakar.

Tabel 4.4 Semesta Pembicaraan

Input Low-3 Low-2 Low-1 Normal-0 High-1 High-2 High-3

SBP <75 70-80 80-100 95-199 - - >185

HR - <50 45-60 53-100 95-110 105-

130

>125

SPO2 <85 83-90 87-95 >93 - - -

TEMP - <36.5 - 36-38.5 - >38 -

BS <66 63-72 - 70-110 - 106-

150

>140

Sumber: Perancangan

4.2.2.3 Fungsi Derajat Keanggotaan Variabel Tekanan Darah (SBP)

Nilai-nilai yang berbeda tekanan darah mengubah hasilnya dengan mudah.

Dalam hal ini, kami menggunakan tekanan darah sistolik. Variabel input ini dibagi

menjadi 5 fuzzy set yaitu Low-3, Low-2, Low-1, Normal-0, dan High-2; fungsi

keanggotaan dari 5 fuzzy set adalah trapesium. Langkah pertama dalam

menerapkan algoritma kontrol logika fuzzy adalah untuk fuzzify variabel yang

43

diukur. Untuk fuzzify variabel SBP, harus ditentukan range nilai untuk SBP.

Ditentukan nilai SBP menjadi 100 sampai 185mm Hg (mungkin, tidak semua

orang setuju dengan hal ini, pilihan ini berdasarkan pengalaman “ahli”). Dengan

demikian kita membuat himpunan fuzzy berlabel Normal-0 dan menetapkan nilai-

nilai SBP antara 101 dan 199 mm Hg ke tingkat keanggotaan dari 1,0 di set ini.

Selanjutnya kita mengatasi masalah lebih jelas dari apa yang kisaran nilai untuk

SBP mungkin bisa normal, tetapi juga menjadi abnormal. Setiap saran ahli,

kisaran 185-199 diputuskan untuk berada di ujung atas dan 95 sampai 100 di

ujung bawah pertama. Dengan kata lain, jika SBP di atas 199 mm Hg, itu terlalu

tinggi (yang diberi label High-2 pada fuzzy set), pilihan terbaik adalah rentang

nilai antara 185 dan 199 mm Hg. Tabel fungsi keanggotaan dan grafik fuzzy set

dan variabel SBP secara berturut-turut ditunjukkan pada Tabel 4.5 dan Gambar

4.3.

Tabel 4.5 Range Fuzzy Set SBP

Input Field Range Fuzzy Set

Tekanan Darah Sistolik

(TDS)

<75 Low-3

70 – 85 Low-2

80 – 100 Low-1

95 – 199 Normal-0

>185 High-2

Sumber: Perancangan

44

Gambar 4.3 Grafik fuzzy set tekanan darah

Sumber: Perancangan

Fungsi Derajat Keanggotaan SBP

�$%&�'[ ] =) 1, < 70+,��+,�+- ,70 ≤ < 750, ≥ 75 ...........................................................(4-1)

�$%&�/[ ] =

�!�!� ��+-+,�+- ,70 ≤ < 751,75 ≤ < 801,��1,�1- ,80 ≤ < 850, ≤ 70�� ≥ 85

........................................................(4-2)

0

0.2

0.4

0.6

0.8

1

1.2

0 50 100 150 200 250

SBP

Low-3

Low-2

Low-1

Normal-0

High-2

45

�$%&�2[ ] =

�!�!� ��1-1,�1- ,80 ≤ < 851,85 ≤ < 952--��2--�4, ,95 ≤ < 1000, ≤ 80�� ≥ 100

.....................................................(4-3)

�5%67�8�-[ ] =

�!�!� ��4,2--�4, ,95 ≤ < 1001,100 ≤ < 185244��244�21, ,185 ≤ < 1990, ≤ 95�� ≥ 199

.............................................(4-4)

�9:;<�/[ ] =) ��21,244�21, ,185 ≤ < 1991, ≥ 1990, < 185 .....................................................(4-5)

4.2.2.4 Fungsi Derajat Keanggotaan Variabel Heart Rate

Berdasarkan sistem MEWS scoring dan setiap saran ahli, enam fuzzy set

(Low-2, Low-1, Normal-0, High-1, High-2, dan High-3) digunakan dalam variabel

heart rate. Fungsi keanggotaan dari fuzzy set ini adalah trapesium. Penentuan nilai

HR mirip dengan penentuan nilai SBP. Tabel fungsi keanggotaan dan grafik fuzzy

set variabel heart rate secara berturut-turut ditunjukkan pada Tabel 4.6 dan

Gambar 4.4.

Tabel 4.6 Range Fuzzy Set Heart Rate


Heart Rate (HR)

<50 Low-2

45 - 60 Low-1

46

53 - 100 Normal-0

95 - 110 High-1

105 - 130 High-2

>125 High-3

Sumber: Perancangan

Gambar 4.4 Grafik fuzzy set heart rate

Sumber: Perancangan

Fungsi Derajat Keanggotaan HR

�$%&�/[ ] =) 1, < 45,-��,-�>, ,45 ≤ < 500, ≥ 50 .............................................................(4-6)

�$%&�2[ ] =

�!�!� ��>,,'�>, ,45 ≤ < 501,50 ≤ < 53@-��@-�,' ,53 ≤ < 600, ≤ 45�� ≥ 60

.........................................................(4-7)

0

0.2

0.4

0.6

0.8

1

1.2

0 50 100 150 200

HR

Low-2

Low-1

Normal-0

High-1

High-3

High-2

47

�5%67�8�-[ ] =

�!�!� ��,'@-�,' ,53 ≤ < 601,60 ≤ < 952--��2--�4, ,95 ≤ < 1000, ≤ 53�� ≥ 100

.................................................(4-8)

�9:;<�2[ ] =

�!�!� ��4,2--�4, ,95 ≤ < 1001,100 ≤ < 10522-��22-�2-, ,105 ≤ < 1100, ≤ 95�� ≥ 110

.................................................(4-9)

�9:;<�/[ ] =

�!�!� ��2-,22-�2-, ,105 ≤ < 1101,110 ≤ < 1252'-��2'-�2/, ,125 ≤ < 1300, ≤ 105�� ≥ 130

..............................................(4-10)

�9:;<�'[ ] =) ��2/,2'-�2/, ,125 ≤ < 1301, ≥ 1300, < 125 ..................................................(4-11)

4.2.2.5 Fungsi Derajat Keanggotaan Variabel Tingkat kejenuhan Oksigen pada

Darah (SPO2)

Nilai variabel ini adalah tingkat kejenuhan oksigen pada darah pasien.

Dalam hal ini, digunakan empat variabel linguistik (fuzzy set) (Low-3, Low-2,

Low-1, dan Normal-0). Setiap nilai yang lebih tinggi dari 95(>95) dianggap

48

sebagai Normal-0. Pada table ini fuzzy set didefinisikan. Fungsi keanggotaan dari

fuzzy set adalah trapesium dan ditunjukkan pada Gambar 4.5.

Tabel 4.7 Range Fuzzy Set SPO2


SPO2

<85 Low-3

83 - 90 Low-2

87 - 95 Low-1

>93 Normal-0

Sumber: Perancangan

Gambar 4.5 Grafik fuzzy set SPO2

Sumber: Perancangan

Fungsi Derajat Keanggotaan SPO2

�$%&�'[ ] =) 1, < 831,��1,�1' ,83 ≤ < 850, ≥ 85 ...........................................................(4-12)

0

0.2

0.4

0.6

0.8

1

1.2

0 50 100 150

SPO2

Low-3

Low-2

Low-1

Normal-0

49

�$%&�/[ ] =

�!�!� ��1'1,�1' ,83 ≤ < 851,85 ≤ < 874-��4-�1+ ,87 ≤ < 900, ≤ 83�� ≥ 90

.......................................................(4-13)

�$%&�2[ ] =

�!�!� ��1+4-�1+ ,87 ≤ < 901,90 ≤ < 934,��4,�4' ,93 ≤ < 950, ≤ 87�� ≥ 95

.......................................................(4-14)

�5%67�8�-[ ] =) ��4'4,�4' ,93 ≤ < 951, ≥ 950, < 93 ......................................................(4-15)

4.2.2.6 Fungsi Derajat Keanggotaan Variabel Suhu

Tiga fuzzy set (Low-2, Normal-0, dan High-2) digunakan untuk variabel

suhu. Dalam tabel ini fuzzy set didefinisikan. Fungsi keanggotaan dari fuzzy set

ini adalah trapesium. Fungsi keanggotaan ini dijelaskan dalam Gambar 4.6.

Tabel 4.8 Range Fuzzy Set Suhu


Temperatur (TEMP)

<36.5 Low-2

36 - 38.5 Normal-0

>38 High-2

Sumber: Perancangan

50

Gambar 4.6 Grafik fuzzy set suhu

Sumber: Perancangan

Fungsi Derajat Keanggotaan suhu

�$%&�/[ ] =) 1, < 36'@.,��'@.,�'@ ,36 ≤ < 36.50, ≥ 36.5 .....................................................(4-16)

�5%67�8�-[ ] =

�!�!� ��'@'@.,�'@ ,36 ≤ < 36.51,36.5 ≤ < 38'1.,��'1.,�'1 ,38 ≤ < 38.50, ≤ 36�� ≥ 38.5

............................................(4-17)

�9:;<�/[ ] =) ��'1'1.,�'1 ,38 ≤ < 38.51, ≥ 38.50, < 38 .....................................................(4-18)

0

0.2

0.4

0.6

0.8

1

1.2

0 10 20 30 40 50

TEMP

Low-2

Normal-0

High-2

51

4.2.2.7 Fungsi Derajat Keanggotaan Variabel Gula Darah

Gula darah merupakan faktor yang sangat penting. Input field ini memiliki

lima fuzzy set (Low-3, Low-2, Normal-0, High-2, dan High-3). Dalam sistem ini,

Telah ditetapkan bahwa jika nilai jumlah gula darah lebih rendah dari 66 (<66)

maka pasien memiliki gula darag rendah (Low-3), jika lebih tinggi dari 140

(>140) maka pasien memiliki gula darah yang sangat tinggi (High-3), dan set

lainnya ditunjukkan pada tabel dibawah ini. Gambar 4.7 menunjukkan fungsi

keanggotaan gula darah. Fungsi keanggotaan dari fuzzy set ini adalah trapesium.

Tabel 4.9 Range Fuzzy Set Gula Darah


Gula Darah

<66 Low-3

63 - 72 Low-2

70 - 110 Normal-0

106 - 150 High-2

>140 High-3

Sumber: Perancangan

Gambar 4.7 Grafik fuzzy set gula darah

Sumber: Perancangan

0

0.2

0.4

0.6

0.8

1

1.2

0 100 200 300 400 500

BS

Low-3

Low-2

Normal-0

High-2

High-3

52

Fungsi Derajat Keanggotaan Gula Darah

�$%&�'[ ] =) 1, < 63@@��@@�@' ,63 ≤ < 660, ≥ 66 ...........................................................(4-19)

�$%&�/[ ] =

�!�!� ��@'@@�@' ,63 ≤ < 661,66 ≤ < 70+/��+/�+- ,70 ≤ < 720, ≤ 63�� ≥ 72

.......................................................(4-20)

�5%67�8�-[ ] =

�!�!� ��+-+/�+- ,70 ≤ < 721,72 ≤ < 10622-��22-�2-@ ,106 ≤ < 1100, ≤ 70�� ≥ 110

...........................................(4-21)

�9:;<�/[ ] =

�!�!� ��2-@22-�2-@ ,106 ≤ < 1101,110 ≤ < 1402,-��2,-�2>- ,140 ≤ < 1500, ≤ 106�� ≥ 150

..............................................(4-22)

�9:;<�'[ ] =) ��2>-2,-�2>- ,140 ≤ < 1501, ≥ 1500, < 140 ..................................................(4-23)

53

4.2.2.8 Fungsi Derajat Keanggotaan Output

Pada subseksi ini menjelaskan output dari sistem logika fuzzy. Terdapat

satu output variabel “Risk Group”, yang mengarahkan ketingkat kemungkinan

kondisi pasien. Range-nya dari 0 sampai 14. Nilai tertinggi adalah nilai resiko

kesehatan tertinggi pasien. Sistem ini mempunyai 15 fuzzy set untuk output

variabel risk group yaitu NRM, LRG1, LRG2, LRG3, LRG4, HRG5, HRG6,

HRG7, HRG8, HRG9, HRG10, HRG11, HRG12, HRG13, dan HRG14.

Membership functions pada variabel ini adalah trapesium. Detail membership

Functions dapat dilihat pada Tabel 4.10 dan Gambar 4.8

Tabel 4.10 Range fuzzy set risk group

Output Field Range Fuzzy Set

Risk Group

0<RG<0.5 NRM

0.5<RG<1.5 LRG 1

1.5<RG<2.5 LRG 2

2.5<RG<3.5 LRG 3

3.5<RG<4.5 LRG 4

4.5<RG<5.5 HRG 5

5.5<RG<6.5 HRG 6

6.5<RG<7.5 HRG 7

7.5<RG<8.5 HRG 8

8.5<RG<9.5 HRG 9

9.5<RG<10.5 HRG 10

10.5<RG<11.5 HRG 11

11.5<RG<12.5 HRG 12

12.5<RG<13.5 HRG 13

13.5<RG<14 HRG 14

Sumber: Perancangan

54

Gambar 4.8 Grafik fuzzy set risk group

Sumber: Perancangan

Fungsi Derajat Keanggotaan Output

�5DE[ ] = F -.,��-.,�- ,0 ≤ < 0.50, ≤ 0�� ≥ 0.5...............................................(4-24)

�$DG�2[ ] =H��-.,2�-., ,0.5 ≤ < 12.,��2.,�2 ,1 ≤ < 1.50, ≤ 0.5�� ≥ 1.5.....................................................(4-25)

�$DG�/[ ] =H��2.,/�2., ,1.5 ≤ < 2/.,��/.,�/ ,2 ≤ < 2.50, ≤ 1.5�� ≥ 2.5.....................................................(4-26)

0

0.2

0.4

0.6

0.8

1

1.2

-1 4 9 14

Risk Group

NRM

LRG1

LRG2

LRG3

LRG4

HRG5

HRG6

HRG7

HRG8

HRG9

55

�$DG�'[ ] =H��/.,'�/., ,2.5 ≤ < 3'.,��'.,�' ,3 ≤ < 3.50, ≤ 2.5�� ≥ 3.5.....................................................(4-27)

�$DG�>[ ] =H��'.,>�'., ,3.5 ≤ < 4>.,��>.,�> ,4 ≤ < 4.50, ≤ 3.5�� ≥ 4.5.....................................................(4-28)

�9DG�,[ ] =H��>.,,�>., ,4.5 ≤ < 5,.,��,.,�, ,5 ≤ < 5.50, ≤ 4.5�� ≥ 5.5.....................................................(4-29)

�9DG�@[ ] =H��,.,@�,., ,5.5 ≤ < 6@.,��@.,�@ ,6 ≤ < 6.50, ≤ 5.5�� ≥ 6.5.....................................................(4-30)

�9DG�+[ ] =H��@.,+�@., ,6.5 ≤ < 7+.,��+.,�+ ,7 ≤ < 7.50, ≤ 6.5�� ≥ 7.5.....................................................(4-31)

56

�9DG�1[ ] =H��+.,1�+., ,7.5 ≤ < 81.,��1.,�1 ,8 ≤ < 8.50, ≤ 7.5�� ≥ 8.5.....................................................(4-32)

�9DG�4[ ] =H��1.,4�1., ,8.5 ≤ < 94.,��4.,�4 ,9 ≤ < 9.50, ≤ 8.5�� ≥ 9.5.....................................................(4-33)

�9DG�2-[ ] =H ��4.,2-�4., ,9.5 ≤ < 102-.,��2-.,�2- ,10 ≤ < 10.50, ≤ 9.5�� ≥ 10.5................................................(4-34)

�9DG�22[ ] =H ��2-.,22�2-., ,10.5 ≤ < 1122.,��22.,�22 ,11 ≤ < 11.50, ≤ 10.5�� ≥ 11.5.............................................(4-35)

�9DG�2/[ ] =H ��22.,2/�22., ,11.5 ≤ < 122/.,��2/.,�2/ ,12 ≤ < 12.50, ≤ 11.5�� ≥ 12.5............................................(4-36)

57

�9DG�2'[ ] =H ��2/.,2'�2/., ,12.5 ≤ < 132'.,��2'.,�2' ,13 ≤ < 13.50, ≤ 12.5�� ≥ 13.5.............................................(4-37)

�9DG�2>[ ] =F ��2'.,2>�2'., ,13.5 ≤ < 140, ≤ 13.5 ................................................(4-38)

4.2.2.9 Rule

Rule merupakan serangkaian aturan yang digunakan sebagai dasar

perhitungan yang akan dilakukan dalam metode fuzzy Tsukamoto. Dibawah ini

adalah rule yang dibuat oleh pakar untuk Sistem Pakar Pemantau Kondisi Pasien

Rawat Inap Menggunakan Fuzzy Inferensi Tsukamoto.

1. If SBP=low3 and HR=low2 and SPO2=low3 and TEMP=low2 and BS=low3 THEN EWS SCORE=13


3. If SBP=low3 and HR=low2 and SPO2=low3 and TEMP=low2 and BS=normal THEN EWS SCORE=10

4. If SBP=low3 and HR=low2 and SPO2=low3 and TEMP=low2 and BS=high2 THEN EWS SCORE=12


6. If SBP=low3 and HR=low2 and SPO2=low3 and TEMP=normal and BS=low3 THEN EWS SCORE=11


8. If SBP=low3 and HR=low2 and SPO2=low3 and TEMP=normal and BS=normal THEN EWS SCORE=8

9. If SBP=low3 and HR=low2 and SPO2=low3 and TEMP=normal and BS=high2 THEN EWS SCORE=10

58


11. If SBP=low3 and HR=low2 and SPO2=low3 and TEMP=high2 and BS=low3 THEN EWS SCORE=13


13. If SBP=low3 and HR=low2 and SPO2=low3 and TEMP=high2 and BS=normal THEN EWS SCORE=10

14. If SBP=low3 and HR=low2 and SPO2=low3 and TEMP=high2 and BS=high2 THEN EWS SCORE=12
















59

















46. If SBP=low3 and HR=low2 and SPO2=normal and TEMP=low2 and BS=low3 THEN EWS SCORE=10


48. If SBP=low3 and HR=low2 and SPO2=normal and TEMP=low2 and BS=normal THEN EWS SCORE=7

49. If SBP=low3 and HR=low2 and SPO2=normal and TEMP=low2 and BS=high2 THEN EWS SCORE=9

60


51. If SBP=low3 and HR=low2 and SPO2=normal and TEMP=normal and BS=low3 THEN EWS SCORE=8


53. If SBP=low3 and HR=low2 and SPO2=normal and TEMP=normal and BS=normal THEN EWS SCORE=5

54. If SBP=low3 and HR=low2 and SPO2=normal and TEMP=normal and BS=high2 THEN EWS SCORE=7


56. If SBP=low3 and HR=low2 and SPO2=normal and TEMP=high2 and BS=low3 THEN EWS SCORE=10


58. If SBP=low3 and HR=low2 and SPO2=normal and TEMP=high2 and BS=normal THEN EWS SCORE=7

59. If SBP=low3 and HR=low2 and SPO2=normal and TEMP=high2 and BS=high2 THEN EWS SCORE=9











61





















62





















63












121. If SBP=low3 and HR=normal and SPO2=low3 and TEMP=low2 and BS=low3 THEN EWS SCORE=11


123. If SBP=low3 and HR=normal and SPO2=low3 and TEMP=low2 and BS=normal THEN EWS SCORE=8

124. If SBP=low3 and HR=normal and SPO2=low3 and TEMP=low2 and BS=high2 THEN EWS SCORE=10


126. If SBP=low3 and HR=normal and SPO2=low3 and TEMP=normal and BS=low3 THEN EWS SCORE=9


128. If SBP=low3 and HR=normal and SPO2=low3 and TEMP=normal and BS=normal THEN EWS SCORE=6

129. If SBP=low3 and HR=normal and SPO2=low3 and TEMP=normal and BS=high2 THEN EWS SCORE=8

64


131. If SBP=low3 and HR=normal and SPO2=low3 and TEMP=high2 and BS=low3 THEN EWS SCORE=11


133. If SBP=low3 and HR=normal and SPO2=low3 and TEMP=high2 and BS=normal THEN EWS SCORE=8

134. If SBP=low3 and HR=normal and SPO2=low3 and TEMP=high2 and BS=high2 THEN EWS SCORE=10
















65

















166. If SBP=low3 and HR=normal and SPO2=normal and TEMP=low2 and BS=low3 THEN EWS SCORE=8


168. If SBP=low3 and HR=normal and SPO2=normal and TEMP=low2 and BS=normal THEN EWS SCORE=5

169. If SBP=low3 and HR=normal and SPO2=normal and TEMP=low2 and BS=high2 THEN EWS SCORE=7

66


171. If SBP=low3 and HR=normal and SPO2=normal and TEMP=normal and BS=low3 THEN EWS SCORE=6


173. If SBP=low3 and HR=normal and SPO2=normal and TEMP=normal and BS=normal THEN EWS SCORE=3

174. If SBP=low3 and HR=normal and SPO2=normal and TEMP=normal and BS=high2 THEN EWS SCORE=5


176. If SBP=low3 and HR=normal and SPO2=normal and TEMP=high2 and BS=low3 THEN EWS SCORE=8


178. If SBP=low3 and HR=normal and SPO2=normal and TEMP=high2 and BS=normal THEN EWS SCORE=5

179. If SBP=low3 and HR=normal and SPO2=normal and TEMP=high2 and BS=high2 THEN EWS SCORE=7


181. If SBP=low3 and HR=high1 and SPO2=low3 and TEMP=low2 and BS=low3 THEN EWS SCORE=12


183. If SBP=low3 and HR=high1 and SPO2=low3 and TEMP=low2 and BS=normal THEN EWS SCORE=9

184. If SBP=low3 and HR=high1 and SPO2=low3 and TEMP=low2 and BS=high2 THEN EWS SCORE=11


186. If SBP=low3 and HR=high1 and SPO2=low3 and TEMP=normal and BS=low3 THEN EWS SCORE=10


188. If SBP=low3 and HR=high1 and SPO2=low3 and TEMP=normal and BS=normal THEN EWS SCORE=7

189. If SBP=low3 and HR=high1 and SPO2=low3 and TEMP=normal and BS=high2 THEN EWS SCORE=9

67


191. If SBP=low3 and HR=high1 and SPO2=low3 and TEMP=high2 and BS=low3 THEN EWS SCORE=12


193. If SBP=low3 and HR=high1 and SPO2=low3 and TEMP=high2 and BS=normal THEN EWS SCORE=9

194. If SBP=low3 and HR=high1 and SPO2=low3 and TEMP=high2 and BS=high2 THEN EWS SCORE=11
















68

















226. If SBP=low3 and HR=high1 and SPO2=normal and TEMP=low2 and BS=low3 THEN EWS SCORE=9


228. If SBP=low3 and HR=high1 and SPO2=normal and TEMP=low2 and BS=normal THEN EWS SCORE=6

229. If SBP=low3 and HR=high1 and SPO2=normal and TEMP=low2 and BS=high2 THEN EWS SCORE=8

69


231. If SBP=low3 and HR=high1 and SPO2=normal and TEMP=normal and BS=low3 THEN EWS SCORE=7


233. If SBP=low3 and HR=high1 and SPO2=normal and TEMP=normal and BS=normal THEN EWS SCORE=4

234. If SBP=low3 and HR=high1 and SPO2=normal and TEMP=normal and BS=high2 THEN EWS SCORE=6


236. If SBP=low3 and HR=high1 and SPO2=normal and TEMP=high2 and BS=low3 THEN EWS SCORE=9


238. If SBP=low3 and HR=high1 and SPO2=normal and TEMP=high2 and BS=normal THEN EWS SCORE=6

239. If SBP=low3 and HR=high1 and SPO2=normal and TEMP=high2 and BS=high2 THEN EWS SCORE=8











70





















71





















72





















73





















74





















75





















76





















77





















78





















79





















80





















81





















82





















83



















528. If SBP=low2 and HR=normal and SPO2=normal and TEMP=low2 and BS=normal THEN EWS SCORE=4


84




533. If SBP=low2 and HR=normal and SPO2=normal and TEMP=normal and BS=normal THEN EWS SCORE=2





538. If SBP=low2 and HR=normal and SPO2=normal and TEMP=high2 and BS=normal THEN EWS SCORE=4












85





















86

4.2.3 Mesin Inferensi

Dalam mesin inferensi ini akan dimodelkan cara sistem memproses data

dengan menggunakan metode ini. Proses tersebut dimulai dengan memasukkan

data dari user, kemudian data masuan user dihitung sesuai dengan perumusan

Tsukamoto.

Gambar 4.9 Flowchart Metode Fuzzy Tsukamoto

Sumber: Perancangan

87

4.2.4 Subsistem Antarmuka Pengguna

Untuk mempermudah dalam proses implementasi program, diperlukan

adanya rancangan yang menggambarkan program aplikasi yang akan dibuat ini.

Rancangan ini berupa sketsa fitur-fitur yang akan diimplementasikan dalam

aplikasi. Secara garis besar, aplikasi “Sistem Pakar Pemantau Kondisi Pasien

Rawat Inap Menggunakan Fuzzy Inferensi Tsukamoto”. Untuk lebih jelasnya,

dapat dilihat pada serangkaian Gambar 4.4. Pada saat aplikasi pertama kali

dijalankan, user akan masuk ke halaman utama.

Gambar 4.10 Antarmuka Sistem

Sumber: Perancangan

88

BAB V

IMPLEMENTASI

Pada bab ini akan dijelaskan tentang implementasi rancangan Sistem Pakar

Pemantau Kondisi Pasien Rawat Inap Menggunakan Fuzzy Inferensi Tsukamoto.

Ruang lingkup implementasi dalam sistem pakar ini meliputi Lingkungan

Implementasi, dan Implementasi Aplikasi (Kode Sumber Aplikasi).

5.1 Lingkungan Implementasi

Lingkungan implementasi Sistem Pakar Pemantau Kondisi Pasien Rawat

Inap Menggunakan Fuzzy Inferensi Tsukamoto meliputi lingkup perangkat keras

dan perangkat lunak komputer yang bisa digunakan untuk menjalankan sistem ini.

5.1.1 Kebutuhan Perangkat Keras

Spesifikasi perangkat keras yang digunakan dalam pengembangan Sistem

Pakar Pemantau Kondisi Pasien Rawat Inap Menggunakan Fuzzy Inferensi

Tsukamoto adalah

1. Prosesor : Intel Pentium Core i3

2. Memori (RAM) : 8 GB

3. Harddisk : 500 GB

5.1.2 Kebutuhan Perangkat Lunak

Spesifikasi perangkat lunak yang digunakan dalam pengembangan Sistem

Pakar Pemantau Kondisi Pasien Rawat Inap Menggunakan Fuzzy Inferensi

Tsukamoto adalah adalah

1. Sistem operasi : Linux Distribusi Ubuntu 12.04

2. IDE : Netbeans IDE 8.0

3. Bahasa Pemrograman : Java

4. JRE - JDK : OpenJDK Java 7

5. DBMS : MySQL

89

5.2 Implementasi Aplikasi

Tahap implementasi aplikasi menjadi salah satu bagian utama dalam

pengembangan Sistem Pakar Pemantau Kondisi Pasien Rawat Inap Menggunakan

Fuzzy Inferensi Tsukamoto. Implementasi aplikasi meliputi implementasi pada

bagian kode sumber aplikasi (back end) dan implementasi antarmuka aplikasi

(front end). Berikut ini uraian masing-masing bagian pada tahap implementasi

aplikasi.

5.2.1 Kode Sumber Aplikasi

Sistem Pakar Pemantau Kondisi Pasien Rawat Inap ini dibangun

menggunakan bahasa Java dan dalam implemetasinya, sistem ini dibangun dengan

menerapkan konsep pemrograman berorientasi objek. Dibawah ini kode sumber

aplikasi.

5.2.1.1 BloodSugar.java

package engine; import ui.MainWindow; import java.util.ArrayList; public class BloodSugar { private double bloodSugar; private final int[] bloodSugarLinguistic = {-3, -2,0,2,3}; private ArrayList<Integer> linguistic = new ArrayList<Integer>(); private MainWindow mainWindow; public BloodSugar (double bloodSugar, MainWind ow mainWindow){ this.bloodSugar = bloodSugar; this.mainWindow = mainWindow; } public BloodSugar() { }

90

public double GetBS (){ return bloodSugar; } public int[] getBloodSugarLinguistic() { return bloodSugarLinguistic; } public void SetBS(double BS) { this.bloodSugar = BS; } public void clearLinguistik(){ this.linguistic.clear(); } public int[] convertLinguistik(){ int[] adjacent = new int[this.linguistic.si ze()]; int count = 0; for (Integer n : this.linguistic){ adjacent[count++] = n.intValue(); } return adjacent; } public void setLinguistik(double BS) { mainWindow.setHasilText("BS : "+this.bloodSugar+"\n"); if(BS < 66){ this.linguistic.add(-3); mainWindow.setHasilText("BS : "+this.convertToString(-3)+"\n"); } if(BS >= 63 && BS <= 72){ this.linguistic.add(-2); mainWindow.setHasilText("BS : "+this.convertToString(-2)+"\n"); } if(BS >= 70 && BS <= 110){ this.linguistic.add(0); mainWindow.setHasilText("BS : "+this.convertToString(0)+"\n"); } if(BS >= 106 && BS <= 150){ this.linguistic.add(2);

91

mainWindow.setHasilText("BS : "+this.convertToString(2)+"\n"); } if(BS > 140){ this.linguistic.add(3); mainWindow.setHasilText("BS : "+this.convertToString(3)+"\n"); } } public double selectionRule(int value){ if(value==-3){ return(low3()); }else if(value==-2){ return(low2()); }else if(value==0){ return(normal0()); }else if(value==2){ return(high2()); }else if(value==3){ return(high3()); } else return 0; } public double low3(){ if (bloodSugar <= 63){ return 1; } else if(bloodSugar > 63 && bloodSugar < 6 6){ return (66-bloodSugar)/3; }else { return 0; } } public double low2(){ if (bloodSugar >= 63 && bloodSugar <66){ return (bloodSugar-63)/3; }else if(bloodSugar >= 66 && bloodSugar < 7 0){ return 1; }else if (bloodSugar >= 70 && bloodSugar <= 72){ return (72-bloodSugar)/2; }else { return 0; }

92

} public double normal0(){ if (bloodSugar >= 70 && bloodSugar <72){ return (bloodSugar-70)/2; }else if(bloodSugar >= 72 && bloodSugar < 1 06){ return 1; }else if (bloodSugar >= 106 && bloodSugar < = 110){ return (110-bloodSugar)/4; }else { return 0; } } public double high2(){ if (bloodSugar >= 106 && bloodSugar <110){ return (bloodSugar-106)/4; }else if(bloodSugar >= 110 && bloodSugar < 140){ return 1; }else if (bloodSugar >= 140 && bloodSugar < = 150){ return (150-bloodSugar)/10; }else { return 0; } } public double high3(){ if (bloodSugar >= 150){ return 1; } else if (bloodSugar > 140 && bloodSugar < 150){ return (bloodSugar-140)/10; } else{ return 0; } } private String convertToString(int value){ if(value==-3){ return "low3"; }else if(value==-2){ return "low2"; }else if(value==-1){ return "low1"; }else if(value==0){ return "normal";

93

}else if(value==1){ return "high1"; }else if(value==2){ return "high2"; }else if(value==3){ return "high3"; }else return ""; } }

5.2.1.2 HeartRate.java

package engine; import ui.MainWindow; import java.util.ArrayList; public class HeartRate { private double heartRate; private final int[] heartRateLinguistic = {-2,-1,0,1,2,3}; private ArrayList<Integer> linguistic = new ArrayList<Integer>(); private MainWindow mainWindow; public HeartRate(double heartRate, MainWindow mainWindow){ this.heartRate = heartRate; this.mainWindow = mainWindow; } public HeartRate() { } public double GetHR (){ return heartRate; } public int[] getHeartRateLinguistic() { return heartRateLinguistic; } public void SetHR(double HR) { this.heartRate = HR;

94

} public void clearLinguistik(){ this.linguistic.clear(); } public int[] convertLinguistik(){ int[] adjacent = new int[this.linguistic.si ze()]; int count = 0; for (Integer n : this.linguistic){ adjacent[count++] = n.intValue(); } return adjacent; } public void setLinguistik(double HR) { mainWindow.setHasilText("HR : "+this.heartRate+"\n"); if(HR < 50){ this.linguistic.add(-2); mainWindow.setHasilText("HR : "+this.convertToString(-2)+"\n"); } if(HR >= 45 && HR <= 60){ this.linguistic.add(-1); mainWindow.setHasilText("HR : "+this.convertToString(-1)+"\n"); } if(HR >= 53 && HR <= 100){ this.linguistic.add(0); mainWindow.setHasilText("HR : "+this.convertToString(0)+"\n"); } if(HR >= 95 && HR <= 110){ this.linguistic.add(1); mainWindow.setHasilText("HR : "+this.convertToString(1)+"\n"); } if(HR >= 105 && HR <= 130){ this.linguistic.add(2); mainWindow.setHasilText("HR : "+this.convertToString(2)+"\n"); } if(HR > 125){ this.linguistic.add(3);

95

mainWindow.setHasilText("HR : "+this.convertToString(3)+"\n"); } } public double selectionRule(int value){ if(value==-2){ return(low2()); }else if(value==-1){ return(low1()); }else if(value==0){ return(normal0()); }else if(value==1){ return(high1()); }else if(value==2){ return(high2()); }else if(value==3){ return(high3()); } else return 0; } public double low2(){ if (heartRate <= 45){ return 1; } else if(heartRate > 45 && heartRate < 50) { return (50-heartRate)/5; }else { return 0; } } public double low1(){ if (heartRate >= 45 && heartRate <50){ return (heartRate-45)/5; }else if(heartRate >= 50 && heartRate < 53) { return 1; }else if (heartRate >= 53 && heartRate <= 6 0){ return (60-heartRate)/7; }else { return 0; } } public double normal0(){

96

if (heartRate >= 53 && heartRate <60){ return (heartRate-53)/7; }else if(heartRate >= 60 && heartRate < 95) { return 1; }else if (heartRate >=95 && heartRate <= 10 0){ return (100-heartRate)/5; }else { return 0; } } public double high1(){ if (heartRate >= 95 && heartRate <100){ return (heartRate-95)/5; }else if(heartRate >= 100 && heartRate < 10 5){ return 1; }else if (heartRate >= 105 && heartRate <= 110){ return (110-heartRate)/5; }else { return 0; } } public double high2(){ if (heartRate >= 105 && heartRate <110){ return (heartRate-105)/5; }else if(heartRate >= 110 && heartRate < 12 5){ return 1; }else if (heartRate >= 125 && heartRate <= 130){ return (130-heartRate)/5; }else { return 0; } } public double high3(){ if (heartRate >= 130){ return 1; } else if (heartRate > 125 && heartRate < 1 30){ return (heartRate-125)/5; } else{ return 0; } }

97

private String convertToString(int value){ if(value==-3){ return "low3"; }else if(value==-2){ return "low2"; }else if(value==-1){ return "low1"; }else if(value==0){ return "normal"; }else if(value==1){ return "high1"; }else if(value==2){ return "high2"; }else if(value==3){ return "high3"; }else return ""; } }

5.2.1.3 SystolicBloodPressure.java

package engine; import ui.MainWindow; import java.util.ArrayList; public class SystolicBloodPressure { private double systolicBloodPressure; private final int[] sbpLinguistic = {-3,-2,-1,0 ,2}; private ArrayList<Integer> linguistic = new ArrayList<Integer>(); private MainWindow mainWindow; public SystolicBloodPressure (double systolicBloodPressure, MainWindow mainWindow){ this.systolicBloodPressure = systolicBloodP ressure; this.mainWindow = mainWindow; } public SystolicBloodPressure() { } public double GetSBP (){ return systolicBloodPressure; }

98

public int[] getSbpLinguistic() { return sbpLinguistic; } public void SetSBP(double SBP) { this.systolicBloodPressure = SBP; } public void clearLinguistik(){ this.linguistic.clear(); } public int[] convertLinguistik(){ int[] adjacent = new int[this.linguistic.si ze()]; int count = 0; for (Integer n : this.linguistic){ adjacent[count++] = n.intValue(); } return adjacent; } public void setLinguistik(double SBP) { mainWindow.setHasilText("SBP : "+this.systolicBloodPressure+"\n"); if(SBP < 75){ this.linguistic.add(-3); mainWindow.setHasilText("SBP : "+this.convertToString(-3)+"\n"); } if(SBP >= 70 && SBP <= 85){ this.linguistic.add(-2); mainWindow.setHasilText("SBP : "+this.convertToString(-2)+"\n"); } if(SBP >= 80 && SBP <= 100){ this.linguistic.add(-1); mainWindow.setHasilText("SBP : "+this.convertToString(-1)+"\n"); } if(SBP >= 95 && SBP <= 199){ this.linguistic.add(0); mainWindow.setHasilText("SBP : "+this.convertToString(0)+"\n"); }

99

if(SBP > 185){ this.linguistic.add(2); mainWindow.setHasilText("SBP : "+this.convertToString(2)+"\n"); } } public double selectionRule(int value){ if(value==-3){ return(low3()); }else if(value==-2){ return(low2()); }else if(value==-1){ return(low1()); }else if(value==0){ return(normal0()); }else if(value==2){ return(high2()); } else return 0; } public double low3(){ if (systolicBloodPressure < 70){ return 1; } else if(systolicBloodPressure >= 70 && systolicBloodPressure < 75){ return (75-systolicBloodPressure)/5; }else { return 0; } } public double low2(){ if (systolicBloodPressure >= 70 && systolicBloodPressure <75){ return (systolicBloodPressure-70)/5; }else if(systolicBloodPressure >= 75 && systolicBloodPressure < 80){ return 1; }else if (systolicBloodPressure >= 80 && systolicBloodPressure <= 85){ return (85-systolicBloodPressure)/5; }else { return 0;

100

} } public double low1(){ if (systolicBloodPressure >= 80 && systolicBloodPressure <85){ return (systolicBloodPressure-80)/5; }else if(systolicBloodPressure >= 85 && systolicBloodPressure < 95){ return 1; }else if (systolicBloodPressure >= 95 && systolicBloodPressure <= 100){ return (100-systolicBloodPressure)/5; }else { return 0; } } public double normal0(){ if (systolicBloodPressure >= 95 && systolicBloodPressure <100){ return (systolicBloodPressure-95)/5; }else if(systolicBloodPressure >= 100 && systolicBloodPressure < 185){ return 1; }else if (systolicBloodPressure >= 185 && systolicBloodPressure <= 199){ return (199-systolicBloodPressure)/14; }else { return 0; } } public double high2(){ if (systolicBloodPressure >= 199){ return 1; } else if (systolicBloodPressure > 185 && systolicBloodPressure < 199){ return (systolicBloodPressure-185)/14; } else{ return 0; } } private String convertToString(int value){

101

if(value==-3){ return "low3"; }else if(value==-2){ return "low2"; }else if(value==-1){ return "low1"; }else if(value==0){ return "normal"; }else if(value==1){ return "high1"; }else if(value==2){ return "high2"; }else if(value==3){ return "high3"; }else return ""; } }

5.2.1.4 OxygenSaturation.java

package engine; import ui.MainWindow; import java.util.ArrayList; public class OxygenSaturation { private double oxygenSaturation; private final int[] oxygenSaturationLinguistic = {-3,-2,-1,0}; private ArrayList<Integer> linguistic = new ArrayList<Integer>(); private MainWindow mainWindow; public OxygenSaturation (double oxygenSaturati on, MainWindow mainWindow){ this.oxygenSaturation= oxygenSaturation; this.mainWindow = mainWindow; } public OxygenSaturation() { } public double GetSPO2 (){ return oxygenSaturation; }

102

public int[] getOxygenSaturationLinguistic() { return oxygenSaturationLinguistic; } public void SetSPO2(double SPO2) { this.oxygenSaturation = SPO2; } public void clearLinguistik(){ this.linguistic.clear(); } public int[] convertLinguistik(){ int[] adjacent = new int[this.linguistic.si ze()]; int count = 0; for (Integer n : this.linguistic){ adjacent[count++] = n.intValue(); } return adjacent; } public void setLinguistik(double SPO2) { mainWindow.setHasilText("SPO2 : "+this.oxygenSaturation+"\n"); if(SPO2 < 85){ this.linguistic.add(-3); mainWindow.setHasilText("SPO2 : "+this.convertToString(-3)+"\n"); } if(SPO2 >= 83 && SPO2 <= 90){ this.linguistic.add(-2); mainWindow.setHasilText("SPO2 : "+this.convertToString(-2)+"\n"); } if(SPO2 >= 87 && SPO2 <= 95){ this.linguistic.add(-1); mainWindow.setHasilText("SPO2 : "+this.convertToString(-1)+"\n"); } if(SPO2 > 93){ this.linguistic.add(0); mainWindow.setHasilText("SPO2 : "+this.convertToString(0)+"\n"); }

103

} public double selectionRule(int value){ if(value==-3){ return(low3()); }else if(value==-2){ return(low2()); }else if(value==-1){ return(low1()); }else if(value==0){ return(normal0()); } else return 0; } public double low3(){ if (oxygenSaturation <= 83){ return 1; } else if(oxygenSaturation > 83 && oxygenSa turation < 85){ return (85-oxygenSaturation)/2; }else { return 0; } } public double low2(){ if (oxygenSaturation >=83 && oxygenSaturati on <85){ return (oxygenSaturation-83)/2; }else if(oxygenSaturation >= 85 && oxygenSa turation < 87){ return 1; }else if (oxygenSaturation >= 87 && oxygenSaturatio n <= 90){ return (90-oxygenSaturation)/3; }else { return 0; } } public double low1(){ if (oxygenSaturation >= 87 && oxygenSaturat ion <90){ return (oxygenSaturation-87)/3; }else if(oxygenSaturation >= 90 && oxygenSa turation < 93){

104

return 1; }else if (oxygenSaturatio n >= 93 && oxygenSaturation <= 95){ return (95-oxygenSaturation)/2; }else { return 0; } } public double normal0(){ if (oxygenSaturation >= 95){ return 1; } else if (oxygenS aturation > 93 && oxygenSaturation < 95){ return (oxygenSaturation-93)/2; } else{ return 0; } } private String convertToString(int value){ if(value==-3){ return "low3"; }else if(value==-2){ return "low2"; }else if(value==-1){ return "low1"; }else if(value==0){ return "normal"; }else if(value==1){ return "high1"; }else if(value==2){ return "high2"; }else if(value==3){ return "high3"; }else return ""; } }

5.2.1.5 Temperature.java

package engine; import ui.MainWindow;

105

import java.util.ArrayList; public class Temperature { private double temperature; private final int[] temperatureLinguistic = {-2 ,0,2}; private ArrayList<Integer> linguistic = new ArrayList<Integer>(); private MainWindow mainWindow; public Temperature (double temperature, MainWi ndow mainWindow){ this.temperature = temperature; this.mainWindow = mainWindow; } public Temperature() { } public double GetTEMP (){ return temperature; } public int[] getTemperatureLinguistic() { return temperatureLinguistic; } public void SetTEMP(double TEMP) { this.temperature = TEMP; } public void clearLinguistik(){ this.linguistic.clear(); } public int[] convertLinguistik(){ int[] adjacent = new int[this.linguistic.si ze()]; int count = 0; for (Integer n : this.linguistic){ adjacent[count++] = n.intValue(); } return adjacent; } public void setLinguistik(double TEMP) { mainWindow.setHasilText("TEMP :

106

"+this.temperature+"\n"); if(TEMP < 36.5){ this.linguistic.add(-2); mainWindow.setHasilText("TEMP : "+this.convertToString(-2)+"\n"); } if(TEMP >= 36 && TEMP <= 38.5){ this.linguistic.add(0); mainWindow.setHasilText("TEMP : "+this.convertToString(0)+"\n"); } if(TEMP > 38){ this.linguistic.add(2); mainWindow.setHasilText("TEMP : "+this.convertToString(2)+"\n"); } } public double selectionRule(int value){ if(value==-2){ return(low2()); }else if(value==0){ return(normal0()); }else if(value==2){ return(high2()); } else return 0; } public double low2(){ if (temperature <= 36){ return 1; } else if(temperature > 36 && temperature < 36.5){ return (36.5-temperature)/0.5; }else { return 0; } } public double normal0(){ if (temperature >= 36 && temperature <36.5 ){ return (temperature-36)/0.5; } else if (temperature >=36.5 && temperatur e < 38 ){ return 1; } else if (temperature >=38 && temperature <= 38.5

107

){ return (38.5-temperature)/0.5; }else{ return 0; } } public double high2(){ if (temperature >= 38.5){ return 1; } else if (temperature > 38 && temperature < 38.5){ return (temperature-38)/0.5; } else{ return 0; } } private String convertToString(int value){ if(value==-3){ return "low3"; }else if(value==-2){ return "low2"; }else if(value==-1){ return "low1"; }else if(value==0){ return "normal"; }else if(value==1){ return "high1"; }else if(value==2){ return "high2"; }else if(value==3){ return "high3"; }else return ""; } }

5.2.1.6 Risk.java

package engine; public class Risk { private int Risk; public Risk(int Risk) { this.Risk = Risk;

108

} public Risk() { } public int getRisk() { return Risk; } public void setRisk(int Risk) { this.Risk = Risk; } }

5.2.1.7 RiskPrediction.java

package engine; import ui.MainWindow; import java.sql.ResultSet; import java.sql.SQLException; import java.text.DecimalFormat; import java.util.logging.Level; import java.util.logging.Logger; public class RiskPrediction { private double sbpValue, heartRateValue, spo2Va lue, tempValue, bloodSugarValue; private double alpha[] = new double[50]; private double Z[] = new double[50]; private int[] Lsbp,Lhr,Lspo2,Ltemp,Lbs; private int[] str=new int[7]; private ResultSet rs=null; private DBConnection strconn = null; private MainWindow pcm; public RiskPrediction(double systolicBloodPress ure, double heartRate, double oxygenSaturation, double temperature, double bloodSugar, DBConnection startC onn, MainWindow mainWindow) { this.sbpValue = systolicBloodPressure; this.heartRateValue = heartRate; this.spo2Value = oxygenSaturation; this.tempValue = temperature;

109

this.bloodSugarValue = bloodSugar; this.strconn = startConn; this.pcm = mainWindow; } private double findMin(double a, double b, doub le c, double d, double e) { if (a < b && a < c && a < d && a < e) { return a; } else if (b < a && b < c && b < d && b < e ) { return b; } else if (c < a && c < b && c < d && c < e ) { return c; } else if (d < a && d < b && d < c && d < e ){ return d; }else if (e < a && e < b && e < c && e < d) { return e; }else if (a==b && b==c && c==d && d==e){ return a; }else { return 0; } } private int applyRule() { SystolicBloodPressure SBP = new SystolicBloodPressure(sbpValue, this.pcm); HeartRate HR = new HeartRate(heartRateValue , this.pcm); OxygenSaturation SPO2 = new OxygenSaturation(spo2Value, this.pcm); Temperature TEMP = new Temperature(tempValu e, this.pcm); BloodSugar BS = new BloodSugar(bloodSugarVa lue, this.pcm); Risk risk = new Risk(); int count=0; pcm.ClearHasilText(); pcm.setHasilText("***** Proses *****\n\n\n" ); pcm.setHasilText("=== Fuzzifikasi ===\n"); SBP.setLinguistik(this.sbpValue); Lsbp=SBP.convertLinguistik();

110

SBP.clearLinguistik(); pcm.setHasilText("\n"); HR.setLinguistik(this.heartRateValue); Lhr=HR.convertLinguistik(); HR.clearLinguistik(); pcm.setHasilText("\n"); SPO2.setLinguistik(this.spo2Value); Lspo2=SPO2.convertLinguistik(); SPO2.clearLinguistik(); pcm.setHasilText("\n"); TEMP.setLinguistik(this.tempValue); Ltemp=TEMP.convertLinguistik(); TEMP.clearLinguistik(); pcm.setHasilText("\n"); BS.setLinguistik(this.bloodSugarValue); Lbs=BS.convertLinguistik(); BS.clearLinguistik(); pcm.setHasilText("\n\n"); pcm.setHasilText("=== Selection Rule ===\n" ); for(int a=0;a<Lsbp.length;a++){ for(int b=0;b<Lhr.length;b++){ for(int c=0;c<Lspo2.length;c++){ for(int d=0;d<Ltemp.length;d++) { for(int e=0;e<Lbs.length;e+ +){ rs = strconn.query("SEL ECT * from rule where SBP="+Lsbp[a]+" AND HR="+Lhr[b]+" A ND SPO2="+Lspo2[c]+" AND TEMP="+Ltemp[d]+" AND BS="+Lb s[e]+""); try { while (rs.next()) { str[0]=rs.getIn t(1); str[1]=rs.getIn t(2); str[2]=rs.getIn t(3); str[3]=rs.getIn t(4); str[4]=rs.getIn t(5); str[5]=rs.getIn t(6);

111

str[6]=rs.getIn t(7); } } catch (SQLException e x) { Logger.getLogger(RiskPrediction.class.getName()).lo g(Level.SEVERE, null, ex); } pcm.setProsessText("Rul e No."+st r[0]+" => If SBP="+this.convertToString(str[1])+" a nd HR="+this.convertToString(str[2])+" and SPO2="+this.convertToString(str[3])+" and TEMP="+this.convertToString(str[4])+" and BS="+this.convertToString(str[5])+" THEN EWS SCORE="+str[6]+"\n"); pcm.setHasilText("Rule No."+str[0]+" => If SBP="+this.convertToString(str[ 1])+" and HR="+this.convertToString(str[2])+" and SPO2="+this.convertToString(str[3])+" and TEMP="+this.convertToString(str[4])+" and BS="+this.convertToString(str[5])+" THEN EWS SCORE="+str[6]+"\n"); pcm.setHasilText("miu S BP "+this.convertToString(str[1])+" = "+SBP.selectionRule(str[1])+"\n"); pcm.setHasilText("miu H R "+this.convertToString(str[2])+" = "+HR.selectionRule(str[2])+"\n"); pcm.setHasilText("miu S PO2 "+this.convertToString(str[3])+" = "+SPO2.selectionRule(str[3])+"\n"); pcm.setHasilText("miu T EMP "+this.convertToString(str[4])+" = "+TEMP.selectionRule(str[4])+"\n"); pcm.setHasilText("miu B S "+this.convertToString(str[5])+" = "+BS.selectionRule(str[5])+"\n\n"); alpha[count]=findMin(SBP.selectionRule(str[1]), HR.selectionRule(str[2]), SPO2.selectionRule(str[3] ), TEMP.selectionRule(str[4]), BS.selectionRule(str[5] )); Z[count]=str[6]; count++; } }

112

} } } return count; } private String convertToString(int value){ if(value==-3){ return "low3"; }else if(value==-2){ return "low2"; }else if(value==-1){ return "low1"; }else if(value==0){ return "normal"; }else if(value==1){ return "high1"; }else if(value==2){ return "high2"; }else if(value==3){ return "high3"; }else return ""; } public double getRiskPrediction() { int count = 0; count = applyRule(); return defuzzy(count); } private double defuzzy(int count) { pcm.setHasilText("\n"); pcm.setHasilText("=== Defuzzifikasi ===\n") ; DecimalFormat bulat = new DecimalFormat(".# #"); double a = 0, temp1 = 0, temp2 = 0; double hasil1,hasil2; pcm.setHasilText("EWS Score = (("); for (int i = 0; i < count; i++) { temp1 = temp1+ alpha[i] * Z[i]; temp2 = temp2 + alpha[i]; if(i != count-1)pcm.setHasilText("("+alpha[i]+"*"+Z[i]+")+"); else

113

pcm.setHasilText("("+alpha[i]+"*"+Z[i]+")"); } pcm.setHasilText(")/("); for (int i = 0; i < count; i++) { if(i != count-1)pcm.setHasilText(alpha[ i]+"+"); else pcm.setHasilText(""+alpha[i]); } pcm.setHasilText("))\n"); hasil1 = temp1 / temp2; hasil2 = Double.valueOf(bulat.format(hasil1 )); pcm.setHasilText("EWS Score = "+hasil1); return hasil1; } }

5.2.1.8 PCMFuzzy.java

package engine; import ui.MainWindow; public class PCMFuzzy { private double systolicBloodPressure, heartRate , oxygenSaturation, temperature, bloodSugar; private String assesment, keterangan; private DBConnection startConn = null; private MainWindow mainWindow; public PCMFuzzy(double systolicBloodPressure, d ouble heartRate, double oxygenSaturation, double temperat ure, double bloodSugar, DBConnection startConn, MainWind ow mainWindow) { this.systolicBloodPressure = systolicBloodPressure; this.heartRate = heartRate; this.oxygenSaturation = oxygenSaturatio n; this.temperature = temperature; this.bloodSugar = bloodSugar; this.mainWindow= mainWindow; this.startConn = startConn; } public double getSystolicBloodPressure() { return systolicBloodPressure;

114

} public void setPemrintaan(double SBP) { this.systolicBloodPressure = SBP; } public double getHeartRate() { return heartRate; } public void setHeartRate(double heartRate) { this.heartRate = heartRate; } public double getOxygenSaturation() { return oxygenSaturation; } public void setOxygenSaturation(double oxygenSatura tion) { this.oxygenSaturation = oxygenSaturation; } public double getRiskPrediction(){ return (new RiskPrediction(systolicBloodPressure,heartRate,oxyg enSaturation,temperature,bloodSugar,startConn, mainWindow).getRiskPrediction()); } }

5.2.1.9 DBConnection.java

package engine; import com.mysql.jdbc.Connection; import com.mysql.jdbc.Statement; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; public class DBConnection { private Connection conn = null;

115

public DBConnection(String host, String username, S tring password){ try { this.conn = (Connection) DriverManager.getConnection(host,username,password) ; System.out.println("Connected"); } catch (SQLException ex) { System.out.println("Not Connected"); } } public ResultSet query(String sql){ ResultSet rs = null; try { Statement statement = (Statement) conn.createStatement(); rs = statement.executeQuery(sql); } catch (SQLException ex) {} return rs; } public void dmlQuery(String sql){ try { Statement statement = (Statement) conn.createStatement(); statement.executeUpdate(sql); } catch (SQLException ex) {} } }

5.2.1.10 LoginWindow.java

package ui; import engine.DBConnection; import java.awt.Dimension; import java.awt.Toolkit; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement;

116

import javax.swing.JOptionPane; public class LoginWindow extends javax.swing.JFrame { Connection Con; ResultSet resultSet; Statement statement; DBConnection startConn = null; public LoginWindow() { initComponents(); initDB(); } public void initDB(){ String hosttext="localhost"; String databasetext="pcm"; String usernametext="root"; String passwordtext="My Lab1"; try { Class.forName("com.mysql.jdbc.Driver"); } catch (Exception ex) { System.err.println("Error (1): " + ex); System.exit(1); } startConn = new DBConnection("jdbc:mysql://"+hosttext+":3306/"+data basetext,usernametext,passwordtext); } @SuppressWarnings("unchecked") private void initComponents() { usernameLabel = new javax.swing.JLabel(); usernameField = new javax.swing.JTextField( ); passwordLabel = new javax.swing.JLabel(); loginButton = new javax.swing.JButton(); passwordField = new javax.swing.JPasswordFi eld(); jLabel1 = new javax.swing.JLabel(); jLabel2 = new javax.swing.JLabel(); jSeparator1 = new javax.swing.JSeparator();

117

setDefaultCloseOperation(javax.swing.WindowConstant s.EXIT_ON_CLOSE); usernameLabel.setText("Username"); passwordLabel.setText("Password"); loginButton.setText("Log In"); loginButton.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { loginButtonActionPerformed(evt); } }); jLabel1.setText("Silahkan log in untuk masu k ke Sistem Pakar"); jLabel2.setText("Pemantau Kondisi Pasien Ra wat Inap"); javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); getContentPane().setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(javax.swing.GroupLayout. Alignment.LEADING) .addGroup(javax.swing.GroupLayout.Alignment.TRAILIN G, layout.createSequentialGroup() .addGroup(layout.createParallelGroup(javax.swing.Gr oupLayout.Alignment.TRAILING) .addGroup(layout.createSequenti alGroup() .addContainerGap(javax.swing.GroupLayout.DEFAULT_SI ZE, Short.MAX_VALUE) .addComponent(loginButton)) .addGroup(javax.swing.GroupLayout.Alignment.LEADING , layout.createSequentialGroup() .addGap(60, 60, 60)

118

.addGroup(layout.createParallelGroup(javax.swing.Gr oupLayout

.Alignment.LEADING) .addGroup(layout.createSequentialGroup() .addComponent(usern ameLabel) .addPreferredGap(javax.swing.LayoutStyle.ComponentP lacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addComponent(usernameField, javax.swing.GroupLayout.PREFERRED_SIZE, 130, javax.swing.GroupLayout.PREFERRED_SIZE)) .addGroup(layout.createSequentialGroup() .addComponent(passw ordLabel) .addPreferredGap(javax.swing.LayoutStyle.ComponentP lacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addComponent(passwordField, javax.swing.GroupLayout.PREFERRED_SIZE, 130, javax.swing.GroupLayout.PREFERRED_SIZE)) .addGroup(layout.createSequentialGroup() .addGroup(layout.createParallelGroup(javax.swing.Gr oupLayout.Alignment.LEADING) .addComponent(j Label1) .addGroup(layout.createSequentialGroup() .addGap(25, 25, 25) .addComponent(jLabel2))) .addGap(0, 0, Short.MAX_VALUE))))) .addGap(69, 69, 69)) .addGroup(layout.createSequentialGroup( ) .addGap(28, 28, 28) .addComponent(jSeparator1, javax.swing.GroupLayout.PREFERRED_SIZE, 372, javax.swing.GroupLayout.PREFERRED_SIZE) .addContainerGap(javax.swing.GroupLayout.DEFAULT_SI ZE, Short.MAX_VALUE)) );

119

layout.setVerticalGroup( layout.createParallelGroup(javax.swing.GroupLayout. Alignment.LEADING) .addGroup(layout.createSequentialGroup( ) .addGap(24, 24, 24) .addComponent(jLabel1) .addPreferredGap(javax.swing.LayoutStyle.ComponentP lacement.RELATED) .addComponent(jLabel2) .addPreferredGap(javax.swing.LayoutStyle.ComponentP lacement.UNRELATED) .addComponent(jSeparator1, javax.swing.GroupLayout.PREFERRED_SIZE, 10, javax.swing.GroupLayout.PREFERRED_SIZE) .addPreferredGap(javax.swing.LayoutStyle.ComponentP lacement.RELATED, 31, Short.MAX_VALUE) .addGroup(layout.createParallelGroup(javax.swing.Gr oupLayout.Alignment.LEADING) .addComponent(usernameLabel, javax.swing.GroupLayout.Alignment.TRAILING) .addComponent(usernameField, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) .addGap(18, 18, 18) .addGroup(layout.createParallelGroup(javax.swing.Gr oupLayout.Alignment.BASELINE) .addComponent(passwordField, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) .addComponent(passwordLabel)) .addGap(33, 33, 33) .addComponent(loginButton) .addGap(44, 44, 44)) ); pack();

120

} private void loginButtonActionPerformed(java.awt.event.ActionEve nt evt) { String password = null; String username = null; password = new String(passwordField.getPass word()); username = usernameField.getText(); int countRow = 0; resultSet = startConn.query("select * from admins where username = '"+username+"' and password = '"+password+"'"); try { while (resultSet.next()){ countRow = resultSet.getInt(1); } } catch (SQLException e) { JOptionPane.showMessageDialog(null, e); } if (countRow == 1) { MainWindow mainWindow = new MainWindow( ); mainWindow.setVisible(true); Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize(); int x = (int) ((dimension.getWidth() - mainWindow.getWidth()) / 2); int y = (int) ((dimension.getHeight() - mainWindow.getHeight()) / 2); mainWindow.setLocation(x, y); } else { JOptionPane.showMessageDialog(null, "us ername dan password tidak cocok"); } } private javax.swing.JLabel jLabel1; private javax.swing.JLabel jLabel2; private javax.swing.JSeparator jSeparator1; private javax.swing.JButton loginButton;

121

private javax.swing.JPasswordField passwordFiel d; private javax.swing.JLabel passwordLabel; private javax.swing.JTextField usernameField; private javax.swing.JLabel usernameLabel; }

5.2.1.11 MainWindow.java

package ui; import engine.DBConnection; import engine.BloodSugar; import engine.HeartRate; import engine.PCMFuzzy; import engine.OxygenSaturation; import engine.SystolicBloodPressure; import engine.Temperature; import java.sql.ResultSet; import java.sql.SQLException; import java.util.logging.Level; import java.util.logging.Logger; import javax.swing.JOptionPane; public class MainWindow extends javax.swing.JFrame { public MainWindow() { initComponents(); initDB(); initRule(); } private void initDB(){ String hosttext="localhost"; String databasetext="pcm"; String usernametext="root"; String passwordtext="My Lab1"; try { Class.forName("com.mysql.jdbc.Driver"); } catch (Exception ex) { System.err.println("Error (1): " + ex); System.exit(1); } startConn = new DBConnection("jdbc:mysql://"+hosttext+":3306/"+data basetext,usernametext,passwordtext);

122

} private void initRule(){ int countRow = 0; int[] str = new int[7]; resultSet = startConn.query("select count(* ) from rule"); try { while (resultSet.next()){ countRow=resultSet.getInt(1); } } catch (SQLException ex) { Logger.getLogger(MainWindow.class.getName()).log(Le vel.SEVERE, null, ex); } if (countRow>0){ resultSet=startConn.query("select * fro m rule"); this.ProsessText.setText(""); try { while (resultSet.next()){ countRow=resultSet.getInt(1); str[0]=resultSet.getInt(1); str[1]=resultSet.getInt(2); str[2]=resultSet.getInt(3); str[3]=resultSet.getInt(4); str[4]=resultSet.getInt(5); str[5]=resultSet.getInt(6); str[6]=resultSet.getInt(7); this.ProsessText.append(str[0]+ ". If SBP="+this.convertToString(str[1])+" and HR="+this.convertToString(str[2])+" and SPO2="+this.convertToString(str[3])+" and TEMP="+this.convertToString(str[4])+" and BS="+this.convertToString(str[5])+" THEN EWS SCORE="+str[6]+"\n"); } } catch (SQLException ex) { Logger.getLogger(MainWindow.class.getName()).log(Le vel.SEVERE, null, ex); } this.BtnImportRule.setEnabled(false);

123

this.BtnRemoveRule.setEnabled(true); } else { this.BtnImportRule.setEnabled(true); this.BtnRemoveRule.setEnabled(false); } } @SuppressWarnings("unchecked") private void initComponents() { jTabbedPane1 = new javax.swing.JTabbedPane( ); jPanel1 = new javax.swing.JPanel(); Textsbp = new javax.swing.JTextField(); jScrollPane1 = new javax.swing.JScrollPane( ); HasilText = new javax.swing.JTextArea(); jScrollPane2 = new javax.swing.JScrollPane( ); ProsessText = new javax.swing.JTextArea(); Texthr = new javax.swing.JTextField(); Textspo2 = new javax.swing.JTextField(); Texttemp = new javax.swing.JTextField(); Textbs = new javax.swing.JTextField(); BtnPrediksi = new javax.swing.JButton(); BtnReset = new javax.swing.JButton(); Labelsbp = new javax.swing.JLabel(); Labelhr = new javax.swing.JLabel(); Labelspo2 = new javax.swing.JLabel(); Labeltemp = new javax.swing.JLabel(); Labelbs = new javax.swing.JLabel(); BtnImportRule = new javax.swing.JButton(); BtnRemoveRule = new javax.swing.JToggleButt on(); jMenuBar1 = new javax.swing.JMenuBar(); jMenu1 = new javax.swing.JMenu(); jMenu2 = new javax.swing.JMenu(); setDefaultCloseOperation(javax.swing.WindowConstant s.EXIT_ON_CLOSE); jTabbedPane1.setName("jTabbedPane1"); // NO I18N jPanel1.setName("jPanel1"); // NOI18N Textsbp.setToolTipText("Systolic Blood Plea sure"); Textsbp.setName("Textsbp"); // NOI18N

124

Textsbp.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { TextsbpActionPerformed(evt); } }); Textsbp.addKeyListener(new java.awt.event.KeyAdapter() { public void keyPressed(java.awt.event.K eyEvent evt) { TextsbpKeyPressed(evt); } public void keyReleased(java.awt.event. KeyEvent evt) { TextsbpKeyReleased(evt); } }); jScrollPane1.setName("jScrollPane1"); // NO I18N HasilText.setColumns(20); HasilText.setEditable(false); HasilText.setRows(5); HasilText.setName("HasilText"); // NOI18N jScrollPane1.setViewportView(HasilText); jScrollPane2.setName("jScrollPane2"); // NO I18N ProsessText.setColumns(20); ProsessText.setEditable(false); ProsessText.setRows(5); ProsessText.setName("ProsessText"); // NOI1 8N jScrollPane2.setViewportView(ProsessText); Texthr.setToolTipText("Heart Rate"); Texthr.setName("Texthr"); // NOI18N Texthr.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { TexthrActionPerformed(evt); } }); Texthr.addKeyListener(new

125

java.awt.event.KeyAdapter() { public void keyPressed(java.awt.event.K eyEvent evt) { TexthrKeyPressed(evt); } public void keyReleased(java.awt.event. KeyEvent evt) { TexthrKeyReleased(evt); } }); Textspo2.setToolTipText("Oxygen Saturation" ); Textspo2.setName("Textspo2"); // NOI18N Textspo2.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { Textspo2ActionPerformed(evt); } }); Textspo2.addKeyListener(new java.awt.event.KeyAdapter() { public void keyPressed(java.awt.event.K eyEvent evt) { Textspo2KeyPressed(evt); } public void keyReleased(java.awt.event. KeyEvent evt) { Textspo2KeyReleased(evt); } }); Texttemp.setToolTipText("Temperature"); Texttemp.setName("Texttemp"); // NOI18N Texttemp.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { TexttempActionPerformed(evt); } }); Texttemp.addKeyListener(new java.awt.event.KeyAdapter() { public void keyPressed(java.awt.event.K eyEvent evt) {

126

TexttempKeyPressed(evt); } public void keyReleased(java.awt.event. KeyEvent evt) { TexttempKeyReleased(evt); } }); Textbs.setToolTipText("Blood Sugar"); Textbs.setName("Textbs"); // NOI18N Textbs.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { TextbsActionPerformed(evt); } }); Textbs.addKeyListener(new java.awt.event.KeyAdapter() { public void keyPressed(java.awt.event.K eyEvent evt) { TextbsKeyPressed(evt); } public void keyReleased(java.awt.event. KeyEvent evt) { TextbsKeyReleased(evt); } }); BtnPrediksi.setText("CALCULATE"); BtnPrediksi.setName("BtnPrediksi"); // NOI1 8N BtnPrediksi.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { BtnPrediksiActionPerformed(evt); } }); BtnReset.setText("RESET"); BtnReset.setName("BtnReset"); // NOI18N BtnReset.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) {

127

BtnResetActionPerformed(evt); } }); Labelsbp.setText("SBP"); Labelsbp.setName("Labelsbp"); // NOI18N Labelhr.setText("HR"); Labelhr.setName("Labelhr"); // NOI18N Labelspo2.setText("SPO2"); Labelspo2.setName("Labelspo2"); // NOI18N Labeltemp.setText("TEMP"); Labeltemp.setName("Labeltemp"); // NOI18N Labelbs.setText("BS"); Labelbs.setName("Labelbs"); // NOI18N BtnImportRule.setText("Import Rule"); BtnImportRule.setName("BtnImportRule"); // NOI18N BtnImportRule.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { BtnImportRuleActionPerformed(evt); } }); BtnRemoveRule.setText("Remove Rule"); BtnRemoveRule.setName("BtnRemoveRule"); // NOI18N BtnRemoveRule.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { BtnRemoveRuleActionPerformed(evt); } }); javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1); jPanel1.setLayout(jPanel1Layout); jPanel1Layout.setHorizontalGroup( jPanel1Layout.createParallelGroup(javax.swing.Group Layout.Al

128

ignment.LEADING) .addGroup(jPanel1Layout.createSequentia lGroup() .addContainerGap() .addGroup(jPanel1Layout.createParallelGroup(javax.s wing.GroupLayout.Alignment.LEADING) .addComponent(jScrollPane2, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, 649, Short.MA X_VALUE) .addGroup(javax.swing.GroupLayout.Alignment.TRAILIN G, jPanel1Layout.createSequentialGroup() .addGroup(jPanel1Layout.createParallelGroup(javax.s wing.GroupLayout.Alignment.LEADING, false) .addComponent(Labelsbp, javax.swing.GroupLayout.DEFAULT_SIZE, 100, Short.MA X_VALUE) .addComponent(Labelhr, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VAL UE) .addComponent(Labelspo2 , javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VAL UE) .addComponent(BtnPredik si, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VAL UE) .addComponent(Labeltemp , javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VAL UE) .addComponent(Labelbs, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VAL UE)) .addGap(36, 36, 36) .addGroup(jPanel1Layout.createParallelGroup(javax.s wing.GroupLayout.Alignment.LEADING, false) .addComponent(BtnReset, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VAL UE) .addComponent(Textsbp, javax.swing.GroupLayout.DEFAULT_SIZE, 119, Short.MA X_VALUE) .addComponent(Texthr) .addComponent(Textspo2) .addComponent(Texttemp) .addComponent(Textbs))

129

.addGap(66, 66, 66) .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 307, javax.swing.GroupLayout.PREFERRED_SIZE)) .addGroup(jPanel1Layout.createSequentialGroup() .addComponent(BtnImportRule , javax.swing.GroupLayout.PREFERRED_SIZE, 113, javax.swing.GroupLayout.PREFERRED_SIZE) .addPreferredGap(javax.swing.LayoutStyle.ComponentP lacement.UNRELATED) .addComponent(BtnRemoveRule ))) .addContainerGap()) ); jPanel1Layout.setVerticalGroup( jPanel1Layout.createParallelGroup(javax.swing.Group Layout.Alignment.LEADING) .addGroup(jPanel1Layout.createSequentia lGroup() .addContainerGap() .addGroup(jPanel1Layout.createParallelGroup(javax.s wing.GroupLayout.Alignment.LEADING) .addComponent(jScrollPane1) .addGroup(jPanel1Layout.createSequentialGroup() .addGroup(jPanel1Layout.createParallelGroup(javax.s wing.GroupLayout.Alignment.BASELINE) .addComponent(Textsbp, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) .addComponent(Labelsbp) ) .addGap(18, 18, 18) .addGroup(jPanel1Layout.createParallelGroup(javax.s wing.GroupLayout.Alignment.BASELINE) .addComponent(Texthr, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) .addComponent(Labelhr)) .addGap(18, 18, 18)

130

.addGroup(jPanel1Layout.createParallelGroup(javax.s wing.GroupLayout.Alignment.BASELINE) .addComponent(Textspo2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) .addComponent(Labelspo2 )) .addGap(18, 18, 18) .addGroup(jPanel1Layout.createParallelGroup(javax.s wing.GroupLayout.Alignment.BASELINE) .addComponent(Texttemp, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) .addComponent(Labeltemp )) .addGap(18, 18, 18) .addGroup(jPanel1Layout.createParallelGroup(javax.s wing.GroupLayout.Alignment.BASELINE) .addComponent(Textbs, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE) .addComponent(Labelbs)) .addPreferredGap(javax.swing.LayoutStyle.ComponentP lacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addGroup(jPanel1Layout.createParallelGroup(javax.s wing.GroupLayout.Alignment.BASELINE) .addComponent(BtnPredik si) .addComponent(BtnReset) ) .addGap(9, 9, 9))) .addGap(36, 36, 36) .addComponent(jScrollPane2, javax.swing.GroupLayout.PREFERRED_SIZE, 139, javax.swing.GroupLayout.PREFERRED_SIZE) .addGap(7, 7, 7) .addGroup(jPanel1Layout.createParallelGroup(javax.s wing.GroupLayout.Alignment.BASELINE) .addComponent(BtnImportRule)

131

.addComponent(BtnRemoveRule)) .addContainerGap()) ); jTabbedPane1.addTab("main", jPanel1); jMenuBar1.setName("jMenuBar1"); // NOI18N jMenu1.setText("File"); jMenu1.setName("jMenu1"); // NOI18N jMenuBar1.add(jMenu1); jMenu2.setText("Edit"); jMenu2.setName("jMenu2"); // NOI18N jMenuBar1.add(jMenu2); setJMenuBar(jMenuBar1); javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); getContentPane().setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(javax.swing.GroupLayout. Alignment.LEADING) .addComponent(jTabbedPane1, javax.swing.GroupLayout.Alignment.TRAILING) ); layout.setVerticalGroup( layout.createParallelGroup(javax.swing.GroupLayout. Alignment.LEADING) .addComponent(jTabbedPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 477, Short.MAX_VALUE) ); pack(); } private void TextsbpActionPerformed(java.awt.event.ActionEvent e vt) { // TODO add your handling code here: }

132

private void TexthrActionPerformed(java.awt.event.ActionEvent ev t) { // TODO add your handling code here: } private void Textspo2ActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: } private void TexttempActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: } private void TextbsActionPerformed(java.awt.event.ActionEvent ev t) { // TODO add your handling code here: } private void TextsbpKeyPressed(java.awt.event.K eyEvent evt) { if (evt.getKeyCode() == 10 || evt.getKeyCod e() == 11) { Textsbp.requestFocus(); } } private void TexthrKeyPressed(java.awt.event.Ke yEvent evt) { if (evt.getKeyCode() == 10 || evt.getKeyCod e() == 11) { Texthr.requestFocus(); } } private void Textspo2KeyPressed(java.awt.event. KeyEvent evt) { if (evt.getKeyCode() == 10 || evt.getKeyCod e() == 11) { Textspo2.requestFocus(); } } private void TexttempKeyPressed(java.awt.event. KeyEvent

133

evt) { if (evt.getKeyCode() == 10 || evt.getKeyCod e() == 11) { Texttemp.requestFocus(); } } private void TextbsKeyPressed(java.awt.event.Ke yEvent evt) { if (evt.getKeyCode() == 10 || evt.getKeyCod e() == 11) { Textbs.requestFocus(); } } private void TextsbpKeyReleased(java.awt.event. KeyEvent evt) { if (!isInt(evt.getKeyCode())) { JOptionPane.showMessageDialog(null, "Inputan berupa angka!!"); Textsbp.setText(""); } } private void TexthrKeyReleased(java.awt.event.K eyEvent evt) { if (!isInt(evt.getKeyCode())) { J OptionPane.showMessageDialog(null, "Inputan berupa angka!!"); Texthr.setText(""); } } private void Textspo2KeyReleased(java.awt.event.Key Event evt) { if (!isInt(evt.getKeyCode())) { JOptionPane.showM essageDialog(null, "Inputan berupa angka!!"); Textspo2.setText(""); } } private void TexttempKeyReleased(java.awt.event.Key Event evt) { if (!isInt(evt.getKeyCode())) {

134

JOptionPane.showMessageDialog(null, "Inputan berupa angka!!"); Texttemp.setText(""); } } private void TextbsKeyReleased(java.awt.event.K eyEvent evt) { if (!isInt(evt.getKeyCode())) { JOptionPane.showMessageDialog(null, "Inputan berupa angka!!"); Textbs.setText(""); } } private void BtnPrediksiActionPerformed(java.awt.event.ActionEve nt evt) { if (Textsbp.getText().equals("")) { JOptionPane.showMessageDialog(null, "In putan belum lengkap"); Textsbp.requestFocus(); } else if (Texthr.getText().equals("")) { JOptionPane.showMessageDialog(null, "In putan belum lengkap"); Texthr.requestFocus(); } else if (Textspo2.getText().equals("")) { JOptionPane.showMessageDialog(null, "In putan belum lengkap"); Textspo2.requestFocus(); } else if (Texttemp.getText().equals("")) { JOptionPane.showMessageDialog(null, "In putan belum lengkap"); Texttemp.requestFocus(); } else if (Textbs.getText().equals("")) { JOptionPane.showMessageDialog(null, "In putan belum lengkap"); Textbs.requestFocus(); } else { HasilText.setText(""); ProsessText.setText(""); double Risk = new PCMFuzzy(Double.valueOf(Textsbp.getText()), Double.valueOf(Texthr.getText()), Double.valueOf(Textspo2.getText()),

135

Double.valueOf(Texttemp.getText()), Double.valueOf(Textbs.getText()),startConn, this).getRiskPrediction(); HasilText.append("\n\n\n***** FINISHED *****"); } } private void BtnResetActionPerformed(java.awt.event.ActionEvent evt) { Textsbp.setText(""); Texthr.setText(""); Textspo2.setText(""); Texttemp.setText(""); Textbs.setText(""); HasilText.setText(""); initRule(); Textsbp.requestFocus(); } private void BtnImportRuleActionPerformed(java.awt.event.ActionE vent evt) { int sbp[]=systolicBloodPressure.getSbpLingu istic(); int hr[]=heartRate.getHeartRateLinguistic() ; int spo2[]=oxygenSaturation.getOxygenSaturationLinguist ic(); int temp[]=temperature.getTemperatureLingui stic(); int bs[]=bloodSugar.getBloodSugarLinguistic (); int total=0, jumlah=0, jumlahRule=0; String sql=null; //jumlahRule=sbp.length*hr.length*spo2.length*temp. length*bs.length; for(int a=0;a<sbp.length;a++){ for(int b=0;b<hr.length;b++){ for(int c=0;c<spo2.length;c++){ for(int d=0;d<temp.length;d++){ for(int e=0;e<bs.length;e++){ jumlah=Math.abs(sbp[a])+Math.abs(hr[b])+Math.abs(s po2[c])+Math.abs(temp[d])+Math.abs(bs[e]); startConn.dmlQuery("insert into rule (SBP,HR,SPO2,TEMP,BS,risk) values

136

("+sbp[a]+","+hr[b]+","+spo2[c]+","+temp[d]+","+bs[ e]+","+jumlah+")"); //this.ProsessText.append((total+1)+". If SystolicBloodPressure="+this.convertToString(sbp[a] )+" and HeartRate="+this.convertToString(hr[b])+" and OxygenSaturation="+this.convertToString(spo2[c])+" and Temperature="+this.convertToString(temp[d])+" and BloodSugar="+this.convertToString(bs[e])+" THEN EWS SCORE="+jumlah+"\n"); this.ProsessText.setText("added " +total); tot al++; } } } } } initRule(); JOptionPane.showMessageDialog(null, "Succes added "+total+" rule"); } private void BtnRemoveRuleActionPerformed(java.awt.event.ActionE vent evt) { int dialogButton = JOptionPane.NO_OPTION; JOptionPane.showConfirmDialog (null, "Would You Lik e to Delete All Rule ?","Warning",dialogButton); if(dialogButton == 1){ //The ISSUE is here startConn.dmlQuery("truncate rule"); this.ProsessText.setText(""); initRule(); } } private boolean isInt(int key) { if (key >= 48 && key <= 57 || key >= 8 && k ey <= 11|| key == 46) { return true; } else { return false; }

137

} private String convertToString(int value){ if(value==-3){ return "low3"; }else if(value==-2){ return "low2"; }else if(value==-1){ return "low1"; }else if(value==0){ return "normal"; }else if(value==1){ return "high1"; }else if(value==2){ return "high2"; }else if(value==3){ return "high3"; }else return ""; } public void ClearHasilText(){ this.HasilText.setText(""); } public void ClearProsessText(){ this.ProsessText.setText(""); } public void setHasilText(String str){ this.HasilText.append(str); } public void setProsessText(String str){ this.ProsessText.append(str); } private javax.swing.JButton BtnImportRule; private javax.swing.JButton BtnPrediksi; private javax.swing.JToggleButton BtnRemoveRule ; private javax.swing.JButton BtnReset; private javax.swing.JTextArea HasilText; private javax.swing.JLabel Labelbs; private javax.swing.JLabel Labelhr; private javax.swing.JLabel Labelsbp; private javax.swing.JLabel Labelspo2;

138

private javax.swing.JLabel Labeltemp; private javax.swing.JTextArea ProsessText; private javax.swing.JTextField Textbs; private javax.swing.JTextField Texthr; private javax.swing.JTextField Textsbp; private javax.swing.JTextField Textspo2; private javax.swing.JTextField Texttemp; private javax.swing.JMenu jMenu1; private javax.swing.JMenu jMenu2; private javax.swing.JMenuBar jMenuBar1; private javax.swing.JPanel jPanel1; private javax.swing.JScrollPane jScrollPane1; private javax.swing.JScrollPane jScrollPane2; private javax.swing.JTabbedPane jTabbedPane1; private SystolicBloodPressure systolicBloodPres sure = new SystolicBloodPressure(); private HeartRate heartRate = new HeartRate(); private OxygenSaturation oxygenSaturation = new OxygenSaturation(); private Temperature temperature = new Temperatu re(); private BloodSugar bloodSugar = new BloodSugar( ); private DBConnection startConn = null; private ResultSet resultSet = null; }

5.2.1.12 TestUnit.java

package ui; import java.awt.Dimension; import java.awt.Toolkit; public class TestUnit { public static void main(String[] args) { java.awt.EventQueue.invokeLater(new Runnabl e() { public void run() { LoginWindow loginForm = new LoginWi ndow(); loginForm.setVisible(true); Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize(); int x = (int) ((dimension.getWidth( ) - loginForm.getWidth()) / 2); int y = (int) ((dimension.getHeight () -

139

loginForm.getHeight()) / 2); loginForm.setLocation(x, y); } }); } }

5.2.2 Antarmuka Aplikasi

Antarmuka aplikasi terdiri dari dua bagian yaitu antarmuka log in dan

antarmuka utama. Antarmuka log in digunakan untuk autentikasi pengguna

aplikasi. Hanya pengguna dengan level admininistrator yang dapat menggunakan

aplikasi ini, misal perawat dan dokter. Antarmuka utama terditi dari beberapa field

input dan output yaitu field input kondisi pasien berdasarkan tekanan darah

sistolik (SBP), jetak jantung (HR), tingkat kejenuhan oksigen darah (SPO2), suhu

tubuh (TEMP), dan gula darah (BS). Field output terdari dari dua bagian yaitu

field output hasil perhitungan fuzzy dengan metode FIS Tsukamoto dan field

output rule. Gambar

Gambar 5.1 Antarmuka Window Log in

Sumber: Perancangan

140

Gambar 5.2 Antarmuka Window Utama

Sumber: Perancangan

141

BAB VI

PENUTUP

7.1 Kesimpulan

Sistem pakar adalah sistem yang berusaha mengadopsi pengetahuan

manusia ke komputer yang dirancang untuk memodelkan kemampuan

menyelesaikan masalah layaknya seorang pakar. Basis pengetahuan mengandung

pemahaman, formulasi, dan penyelesaian masalah. Komponen sistem pakar

didasarkan pada dua elemen antara lain fakta dan aturan.

Penelitian yang telah dilakukan untuk memantau kondisi pasien rawat inap

menggunakan fuzzy Tsukamoto. Pemantauan kondisi pasien rawat inap tersebut

memantau tekanan darah (SBP), detak jantung (HR), kejenuhan oksigen darah

(SPO2), suhu (TEMP), dan gula darah (BS). Sehingga pemikiran pakar

disampaikan melalu mesin inferensi untuk memudahkan pemantauan kondisi

pasien.

7.2 Saran

- Aplikasi ini memberikan deteksi dini untuk pemantauan pasien rawat inap.

- Untuk dapat mengembangkan Fuzzy Tsukamoto untuk mengetahui faktor-

faktor pada kondisi pasien.

- Untuk menyertakan faktor jenis kelamin dan usia dalam proses

pengambilan keputusan.

Hasil dari sistem yang diusulkan mengkonfirmasi efektivitas logika fuzzy

dalam pemantauan pasien, tetapi masih perlu diuji dalam lingkungan real-time

untuk menunjukkan nilai klinis penuh.

142

DAFTAR PUSTAKA

[1] Yohana, Antin. 2009. Analisis Harapan Dan Kepuasan Pasien Rawat Inap

Penyakit Dalam Terhadap Mutu Pelayanan Dokter Spesialis Di Rsi Sunan

Kudus. Semarang: Universitas Diponegoro.

[2] Teori Penunjang Sistem Pakar. URL: http://www.informatika.web.id,

diakses pada tanggal 7 April 2014.

[3] Abdurrahman, Ginanjar. 2011. Penerapan Metode Tsukamoto (Logika

Fuzzy) dalam Sistem Pendukung Keputusan untuk Menentukan Jumlah

Produksi Barang Berdasarkan Data Persediaan dan Jumlah Permintaan.

Yogyakarta: Universitas Negeri Yogyakarta.

[4] Niemeyer, Pat dan Jonathan Knudsen. 2010. Learning Java. O'Reilly.

[5] Al-Dmour, J.A. 2013. Fuzzy Logic Based Patients’ Monitoring System.

Thesis tidak diterbitkan, United Arab Emirates, Faculty of American

University of Sharjah College of Engineering.

[6] Purwanto, Ikhlas. 2009. Studi Pengukuran Kemiripan Rantai DNA Virus

H5N1 Berbasis Himpunan Fuzzy. Depok: Universitas Indonesia.

[7] Dalgleish, Jordanne and Beatrice Mpamugo Colleen Kearney. 2010.

Adapting and Implementing SBAR in a Home Care Setting.

[8] KepMenKes RI no. 159b/MENKES/PER/II/1988 .Rumah Sakit. Jakarta:

DepKes RI.

[9] The National Early Warning Score Project Governance and Advisory

Groups as a work stream of the Acute Medicine Progamme. 2012. Guiding

Framework and Policy for the National Early Warning Score System to

Recognise and Respond to Clinical Deterioration. Ireland:

Feidhmearnnacht ma Smirbhise Stainte Health Service Execullve.

[10] Thamrin, Fanoeel. Studi Inferensi Fuzzy Tsukamoto untuk Penentuan

Faktor Pembebasan Trafo PLN. Semarang.

[11] Sistem Pakar. URL: http://birtandp.wordpress.com/tag/manfaat-sistem-

pakar/, diakses pada tanggal 29 Mei 2014.

143

[12] Broto, A.S. 2010. Perancangan Dan Implementasi Sistem Pakar Untuk

Analisa Penyakit Dalam. Semarang: Universitas Diponegoro.

[13] Tahap Pemodelan Dalam Fuzzy Logic. URL:

http://fahmizaleeits.wordpress.com/category/kuliah-kontrol/fuzzy-

logic/page/2/, diakses pada tanggal 29 Mei 2014.

[14] Rochmat, Noer. 2014. Implementasi Sasaran Keselamatan Pasien:

Komunikasi Efektif Di Instalasi Rawat Inap. Pemerintah Propinsi Jawa

Tengah RSUD Tugurejo Semarang.

sistem pakar pemantau kondisi pasien rawat...

Documents