Analisis Eksperimen

Simulasi menghasilkan kurva mulus; eksperimen menghasilkan angka ber-noise. Sensor harus dikalibrasi dulu sebelum pembacaannya bisa dipercaya, pengukuran harus diulang sebelum galatnya bisa diperkirakan, dan hasil akhirnya hanya pantas dilaporkan beserta ketidakpastiannya. Chapter ini merangkai alur kerja laboratorium klasik itu — kalibrasi, pengukuran, validasi, propagasi galat, pelaporan — menjadi pipeline MATLAB dari data mentah sampai laporan final. Cakupan kita:

• kurva kalibrasi sensor dengan polyfit dan penerapannya pada pembacaan nyata
• standar deviasi vs standard error dari pengukuran berulang
• propagasi galat sigma_y = |f'(x)| * sigma_x dan deteksi outlier lewat z-score
• format pelaporan nilai ± galat beserta satuannya

Alur Analisis Data Eksperimen #

Aturan mainnya: satu angka hasil pengukuran belum menjawab apa pun sebelum kita tahu (1) bagaimana angka itu dikonversi dari pembacaan mentah, (2) seberapa besar sebarannya bila diulang, dan (3) bagaimana galat itu menjalar ke besaran turunan. Mekanisme di balik layar: setiap tahap memakai alat yang sudah kita kuasai — regresi linear, statistik ringkas, dan logical indexing — hanya saja kini dirantai menjadi satu alur:

Kurva Kalibrasi Sensor #

Aturannya: sensor murah (misalnya thermocouple) mengeluarkan tegangan, bukan suhu — kita perlu fungsi penerjemah. Mekanismenya: ukur tegangan sensor pada beberapa suhu referensi yang diketahui akurat, lalu fit garis T = slope*V + intercept lewat polyfit; polyfit(V, T, 1) mengembalikan koefisien pangkat tertinggi lebih dulu, jadi p(1) adalah slope dan p(2) adalah intercept.

Tref = [0, 10, 20, 30, 40, 50];                 % suhu referensi (deg C)
Vkal = [0.52, 1.38, 2.21, 3.09, 3.92, 4.77];   % tegangan sensor (mV)
p = polyfit(Vkal, Tref, 1);                     % model linear: T = p(1)*V + p(2)
fprintf('Kurva kalibrasi: T = slope*V + intercept\n');
fprintf('slope     = %.4f deg C / mV\n', p(1));
fprintf('intercept = %.4f deg C\n', p(2));
resKal = Tref - polyval(p, Vkal);               % residu titik kalibrasi
fprintf('residu maks = %.3f deg C\n\n', max(abs(resKal)));

Output yang Dihasilkan:

Kurva kalibrasi: T = slope*V + intercept
slope     = 11.7642 deg C / mV
intercept = -6.1555 deg C
residu maks = 0.196 deg C

Mari kita bedah baris-baris kode di atas:

1. Baris 1-2 (Tref, Vkal): enam titik kalibrasi — suhu referensi dari bath presisi dan tegangan yang terbaca di sensor; per 10 °C tegangan naik sekitar 0.85 mV.
2. Baris 3 (p = polyfit(Vkal, Tref, 1)): least squares derajat 1 mencari garis yang meminimalkan kuadrat residu; hasilnya T = 11.7642*V - 6.1555.
3. Baris 7 (resKal): polyval(p, Vkal) mengevaluasi garis pada tegangan kalibrasi; selisihnya terhadap Tref adalah residu — seberapa jauh titik nyata menyimpang dari garis.
4. Baris 8 (fprintf ... max(abs(resKal))): residu terbesar 0.196 °C menjadi indikasi kualitas: linearitas sensor ini layak untuk resolusi 0.5 °C, tidak untuk 0.01 °C.

Konversi Pembacaan dan Galat Pengukuran #

Aturan pengukuran berulang: satu pembacaan membawa keberuntungan, delapan pembacaan membawa rata-rata. Mekanismenya: noise pembacaan yang tidak berkorelasi saling meniadakan sebagian, sehingga ketidakpastian rata-rata menyusut sebanding 1/sqrt(n) — standard error se = s/sqrt(n), dengan s standar deviasi sampel. Konversi ke suhu memakai kalibrasi tadi, dan galatnya ikut dikonversi: untuk fungsi linear, sigma_T = |slope| * sigma_V.

Vs = [2.53, 2.49, 2.55, 2.51, 2.50, 2.52, 2.48, 2.54];  % 8 pembacaan (mV)
n     = numel(Vs);
Vrata = mean(Vs);
sV    = std(Vs);           % standar deviasi pembacaan (mV)
seV   = sV / sqrt(n);      % standar error rata-rata (mV)
Trata = polyval(p, Vrata); % konversi pembacaan ke suhu (deg C)
sT    = abs(p(1)) * sV;    % propagasi linear: sT = |dT/dV| * sV
seT   = abs(p(1)) * seV;
fprintf('Sampel: n = %d pembacaan\n', n);
fprintf('V = %.3f +/- %.3f mV (sebaran, std)\n', Vrata, sV);
fprintf('T = %.2f +/- %.2f deg C (standar error)\n\n', Trata, seT);

Output yang Dihasilkan:

Sampel: n = 8 pembacaan
V = 2.515 +/- 0.024 mV (sebaran, std)
T = 23.43 +/- 0.10 deg C (standar error)

Baris-baris intinya: std(Vs) mengukur sebaran tiap pembacaan (0.024 mV), sV/sqrt(8) mengecilkannya menjadi 0.0087 mV untuk rata-rata, dan polyval(p, Vrata) menerjemahkan 2.515 mV menjadi 23.43 °C. Galat suhu 0.10 °C berasal dari |slope| * seV — slope 11.76 memperbesar galat tegangan hampir 12 kali lipat, jadi presisi kalibrasi menentukan presisi akhir.

Propagasi Galat #

Aturan ringkasnya: bila hasil y = f(x) dihitung dari besaran terukur x ± sigma_x, galat hasilnya diperkirakan lewat sigma_y = |f'(x)| * sigma_x — turunan fungsi menentukan seberapa sensitif hasil terhadap galat input. Contoh klasiknya mengukur percepatan gravitasi dengan bandul: g = 4*pi^2*L/T^2, dengan hanya periode T yang bergalat:

L    = 1.000;                 % panjang bandul (m)
Tper = 2.006;                 % periode terukur (s)
sigT = 0.004;                 % galat standar periode (s)
g    = 4*pi^2*L / Tper^2;     % percepatan gravitasi (m/s^2)
dgdT = -8*pi^2*L / Tper^3;    % turunan dg/dT
sigG = abs(dgdT) * sigT;      % sigG = |dg/dT| * sigT
fprintf('\nBandul: g = %.3f +/- %.3f m/s^2\n', g, sigG);

Output yang Dihasilkan:

Bandul: g = 9.811 +/- 0.039 m/s^2

Baris 4 menghitung g dari periode 2.006 s; baris 5 adalah turunan dg/dT = -8*pi^2*L/T^3 (muncul karena T berpangkat dua, jadi galat periode terpampat tiga kali di penyebut); baris 6 menerapkan propagasinya: 4 ms galat periode menjadi 0.039 m/s² galat gravitasi. Untuk fungsi banyak variabel, rumusnya diperluas menjadi akar jumlah kuadrat kontribusi tiap variabel — sigma_y^2 = sum((df/dxi * sigma_xi)^2) — dengan pola MATLAB yang sama: hitung turunan, kalikan galat, gabungkan.

Outlier dan Pelaporan Hasil #

Aturan validasi: satu pembacaan yang nyasar bisa menggeser rata-rata jauh melampaui galat noise-nya sendiri. Mekanisme z-score: hitung z = (x - mean)/std untuk tiap data; nilai |z| > 2 menyimpang lebih dari dua standar deviasi dari kelompoknya — kandidat outlier yang ditandai lewat mask logis, lalu dibuang dengan data(~mask) (teknik logical indexing dari Chapter Logical Indexing):

Tukur = [21.4, 21.6, 21.5, 21.3, 21.7, 28.9, 21.4, 21.6, 21.5, 21.5];
z     = (Tukur - mean(Tukur)) / std(Tukur);   % z-score tiap data
mask  = abs(z) > 2;                           % kandidat outlier
fprintf('Seri suhu 10 pembacaan, outlier terdeteksi: %d data\n', sum(mask));
fprintf('z maks       = %.2f (ambang 2.00)\n', max(abs(z)));
fprintf('mean sebelum = %.2f deg C\n', mean(Tukur));
fprintf('mean sesudah = %.2f +/- %.2f deg C\n', mean(Tukur(~mask)), std(Tukur(~mask)));

Output yang Dihasilkan:

Seri suhu 10 pembacaan, outlier terdeteksi: 1 data
z maks       = 2.84 (ambang 2.00)
mean sebelum = 22.24 deg C
mean sesudah = 21.50 +/- 0.12 deg C

Pembacaannya dramatis: satu pembacaan 28.9 °C (z = 2.84) menarik rata-rata dari 21.50 ke 22.24 °C — bias 0.74 °C yang enam kali lebih besar dari sebaran sehat 0.12 °C. Laporan akhir merangkum seluruh pipeline dalam format baku nilai ± galat (satuan):

fprintf('\n=== LAPORAN RINGKAS ===\n');
fprintf('Suhu sampel : %.2f +/- %.2f deg C (n = %d)\n', Trata, seT, n);
fprintf('Gravitasi   : %.3f +/- %.3f m/s^2\n', g, sigG);

Output yang Dihasilkan:

=== LAPORAN RINGKAS ===
Suhu sampel : 23.43 +/- 0.10 deg C (n = 8)
Gravitasi   : 9.811 +/- 0.039 m/s^2

Ringkasan #

Alur eksperimen berujung pada satu baris laporan yang jujur: 23.43 ± 0.10 °C (n = 8). Rantainya: polyfit mengubah pembacaan sensor menjadi satuan fisik (residu maksimum 0.196 °C menilai layak-tidaknya linearitas), mean dan std dari pengukuran berulang memberi nilai terbaik dan sebarannya, std/sqrt(n) mengecilkan sebaran menjadi standard error, z-score dengan logical indexing menandai data yang tersesat, dan propagasi sigma_y = |f'(x)| * sigma_x menjalankan galat ke besaran turunan seperti g dari periode bandul. Berkas contoh.m pada bagian bawah halaman menjalankan rantai lengkap dari kalibrasi sampai laporan dalam satu script.