Update latex/chapters/id/03_methodology/data_analysis/index.tex

fix(latex): Fix typo

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

code/notebooks/stft.ipynb

@@ -121,6 +121,7 @@
     "signal_sensor2_test1 = []\n",
     "\n",
     "for data in df:\n",
+    "    if not data.empty and 'sensor 1' in data.columns and 'sensor 2' in data.columns:\n",
     "        signal_sensor1_test1.append(data['sensor 1'].values)\n",
     "        signal_sensor2_test1.append(data['sensor 2'].values)\n",
     "\n",
@@ -156,8 +157,6 @@
     "from scipy.signal import stft, hann\n",
     "from multiprocessing import Pool\n",
     "\n",
-    "\n",
-    "\n",
     "# Function to compute and append STFT data\n",
     "def process_stft(args):\n",
     "    # Define STFT parameters\n",
@@ -199,23 +198,22 @@
     "    # Compute STFT\n",
     "    frequencies, times, Zxx = stft(sensor_data, fs=Fs, window=window, nperseg=window_size, noverlap=window_size - hop_size)\n",
     "    magnitude = np.abs(Zxx)\n",
-    "    flattened_stft = magnitude.flatten()\n",
+    "    df_stft = pd.DataFrame(magnitude, index=frequencies, columns=times).T\n",
+    "    df_stft.columns = [f\"Freq_{i}\" for i in frequencies]\n",
     "    \n",
     "    # Define the output CSV file path\n",
     "    stft_file_name = f'stft_data{sensor_num}_{damage_num}.csv'\n",
     "    sensor_output_dir = os.path.join(damage_base_path, sensor_name.lower())\n",
     "    os.makedirs(sensor_output_dir, exist_ok=True)\n",
     "    stft_file_path = os.path.join(sensor_output_dir, stft_file_name)\n",
-    "    print(stft_file_path)\n",
     "    # Append the flattened STFT to the CSV\n",
     "    try:\n",
-    "        flattened_stft_df = pd.DataFrame([flattened_stft])\n",
     "        if not os.path.isfile(stft_file_path):\n",
     "            # Create a new CSV\n",
-    "            flattened_stft_df.to_csv(stft_file_path, index=False, header=False)\n",
+    "            df_stft.to_csv(stft_file_path, index=False, header=False)\n",
     "        else:\n",
     "            # Append to existing CSV\n",
-    "            flattened_stft_df.to_csv(stft_file_path, mode='a', index=False, header=False)\n",
+    "            df_stft.to_csv(stft_file_path, mode='a', index=False, header=False)\n",
     "        print(f\"Appended STFT data to {stft_file_path}\")\n",
     "    except Exception as e:\n",
     "        print(f\"Error writing to {stft_file_path}: {e}\")"
@@ -295,7 +293,7 @@
     "\n",
     "# get current y ticks in list\n",
     "print(len(frequencies))\n",
-    "print(len(times))\n"
+    "print(len(times))"
    ]
   },
   {
@@ -326,7 +324,6 @@
     "ready_data1 = []\n",
     "for file in os.listdir('D:/thesis/data/converted/raw/sensor1'):\n",
     "    ready_data1.append(pd.read_csv(os.path.join('D:/thesis/data/converted/raw/sensor1', file)))\n",
-    "ready_data1[0]\n",
     "# colormesh give title x is frequency and y is time and rotate/transpose the data\n",
     "# Plotting the STFT Data"
    ]
@@ -337,8 +334,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "ready_data1[1]\n",
-    "plt.pcolormesh(ready_data1[1])"
+    "ready_data1[0]\n",
+    "plt.pcolormesh(ready_data1[0])"
    ]
   },
   {
@@ -363,8 +360,7 @@
    "source": [
     "ready_data2 = []\n",
     "for file in os.listdir('D:/thesis/data/converted/raw/sensor2'):\n",
-    "    ready_data2.append(pd.read_csv(os.path.join('D:/thesis/data/converted/raw/sensor2', file)))\n",
-    "ready_data2[5]"
+    "    ready_data2.append(pd.read_csv(os.path.join('D:/thesis/data/converted/raw/sensor2', file)))"
    ]
   },
   {
@@ -384,10 +380,25 @@
    "outputs": [],
    "source": [
     "x1 = 0\n",
-    "\n",
+    "print(type(ready_data1[0]))\n",
+    "ready_data1[0].iloc[:,0]\n",
+    "# x1 = x1 + ready_data1[0].shape[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x1 = 0\n",
+    "print(type(x1))\n",
     "for i in range(len(ready_data1)):\n",
-    "    print(ready_data1[i].shape)\n",
+    "    # print(ready_data1[i].shape)\n",
+    "    # print(ready_data1[i].)\n",
+    "    print(type(ready_data1[i].shape[0]))\n",
     "    x1 = x1 + ready_data1[i].shape[0]\n",
+    "    print(type(x1))\n",
     "\n",
     "print(x1)"
    ]
@@ -407,13 +418,6 @@
     "print(x2)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Appending"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -455,10 +459,15 @@
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "### Labeling"
+    "y_1 = [1,1,1,1]\n",
+    "y_2 = [0,1,1,1]\n",
+    "y_3 = [1,0,1,1]\n",
+    "y_4 = [1,1,0,0]"
    ]
   },
   {
@@ -494,16 +503,6 @@
     "    print(ready_data1[i].shape[0])"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for i in range(len(y_data)):\n",
-    "    print(ready_data2[i].shape[0])"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -521,8 +520,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# len(y_data[0])\n",
-    "y_data[0]"
+    "y_data"
    ]
   },
   {
@@ -806,6 +804,7 @@
     "\n",
     "            # df1['s1'] = sensor1[sensor1.columns[-1]]\n",
     "            # df1['s2'] = sensor2[sensor2.columns[-1]]\n",
+    "ed\n",
     "            # # Combined Plot for sensor 1 and sensor 2 from data1 file in which motor is operated at 800 rpm\n",
     "\n",
     "            # plt.plot(df1['s2'], label='sensor 2')\n",
@@ -835,19 +834,14 @@
     "            # plt.show()"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Test with Outside of Its Training Data"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "spectograph('D:/thesis/data/converted/raw')"
+   ]
   }
  ],
  "metadata": {

data/QUGS/convert.py

@@ -2,6 +2,7 @@ import pandas as pd
 import os
 import re
 import sys
+import numpy as np
 from colorama import Fore, Style, init
 from typing import TypedDict, Dict, List
 from joblib import load
@@ -225,25 +226,56 @@ class DataProcessor:
         """
         idx = self._create_vector_column_index()
         # if overwrite:
-        for i in range(len(self.data)):
-            for j in range(len(self.data[i])):
+        for i in range(len(self.data)):  # damage(s)
+            for j in range(len(self.data[i])):  # col(s)
                 # Get the appropriate indices for slicing from idx
                 indices = idx[j]
 
                 # Get the current DataFrame
                 df = self.data[i][j]
 
-                # Keep the 'Time' column and select only specified 'Real' columns
-                # First, we add 1 to all indices to account for 'Time' being at position 0
+                # Keep the 'Time' column and select only specifid 'Real' colmns
+                # First, we add 1 to all indices to acount for 'Time' being at positiion 0
                 real_indices = [index + 1 for index in indices]
 
-                # Create list with Time column index (0) and the adjusted Real indices
+                # Create list with Time column index (0) and the adjustedd Real indices
                 all_indices = [0] + [real_indices[0]] + [real_indices[-1]]
 
                 # Apply the slicing
                 self.data[i][j] = df.iloc[:, all_indices]
         # TODO: if !overwrite:
 
+    def export_to_csv(self, output_dir: str, file_prefix: str = "DAMAGE"):
+        """
+        Export the processed data to CSV files in the required folder structure.
+
+        :param output_dir: Directory to save the CSV files.
+        :param file_prefix: Prefix for the output filenames.
+        """
+        for group_idx, group in enumerate(self.data, start=1):
+            group_folder = os.path.join(output_dir, f"{file_prefix}_{group_idx}")
+            os.makedirs(group_folder, exist_ok=True)
+            for test_idx, df in enumerate(group, start=1):
+                # Ensure columns are named uniquely if duplicated
+                df = df.copy()
+                df.columns = ["Time", "Real_0", "Real_1"]  # Rename
+
+                # Export first Real column
+                out1 = os.path.join(
+                    group_folder, f"{file_prefix}_{group_idx}_TEST{test_idx}_01.csv"
+                )
+                df[["Time", "Real_0"]].rename(columns={"Real_0": "Real"}).to_csv(
+                    out1, index=False
+                )
+
+                # Export last Real column
+                out2 = os.path.join(
+                    group_folder, f"{file_prefix}_{group_idx}_TEST{test_idx}_02.csv"
+                )
+                df[["Time", "Real_1"]].rename(columns={"Real_1": "Real"}).to_csv(
+                    out2, index=False
+                )
+
 
 def create_damage_files(base_path, output_base, prefix):
     # Initialize colorama

data/QUGS/test.py

@@ -4,5 +4,22 @@ from joblib import dump, load
 # a = generate_damage_files_index(
 #     num_damage=6, file_index_start=1, col=5, base_path="D:/thesis/data/dataset_A"
 # )
-# dump(DataProcessor(file_index=a), "D:/cache.joblib")
-a = load("D:/cache.joblib")
+
+b = generate_damage_files_index(
+    num_damage=6,
+    file_index_start=1,
+    col=5,
+    base_path="D:/thesis/data/dataset_B",
+    prefix="zzzBD",
+)
+# data_A = DataProcessor(file_index=a)
+# # data.create_vector_column(overwrite=True)
+# data_A.create_limited_sensor_vector_column(overwrite=True)
+# data_A.export_to_csv("D:/thesis/data/converted/raw")
+
+data_B = DataProcessor(file_index=b)
+# data.create_vector_column(overwrite=True)
+data_B.create_limited_sensor_vector_column(overwrite=True)
+data_B.export_to_csv("D:/thesis/data/converted/raw_B")
+# a = load("D:/cache.joblib")
+# breakpoint()

latex/chapters/en/02_literature_review/index.tex

@@ -1,10 +0,0 @@
-\chapter{LITERATURE REVIEW AND THEORETICAL FOUNDATION}
-\section{Literature Review}
-\input{chapters/id/02_literature_review/literature_review/abdeljaber2017}
-
-\section{Theoretical Foundation}
-\input{chapters/id/02_literature_review/theoritical_foundation/stft}
-\input{chapters/id/02_literature_review/theoritical_foundation/machine_learning}
-
-\bigskip
-These theoretical foundations provide the methodological framework for implementing and evaluating the proposed damage localization system in this research. The combination of time-frequency analysis using STFT and classical machine learning classifiers enables an efficient and interpretable approach to structural health monitoring.

latex/chapters/en/02_literature_review/literature_review/abdeljaber2017.tex

@@ -1,6 +0,0 @@
-Traditional structural health monitoring methods often rely on hand-crafted features and manually tuned classifiers, which pose challenges in terms of generalization, reliability, and computational efficiency. As highlighted by [Author(s), Year], these approaches frequently require a trial-and-error process for feature and classifier selection, which not only reduces their robustness across structures but also hinders their deployment in real-time applications due to the computational load of the feature extraction phase.
-
-[Author(s), Year] introduced a CNN-based structural damage detection approach validated through a large-scale grandstand simulator at Qatar University. The structure, designed to replicate modern stadiums, was equipped with 30 accelerometers and subjected to controlled damage by loosening beam-to-girder bolts. Acceleration data, collected under band-limited white noise excitation and sampled at 1024 Hz, were segmented into 128-sample frames for training localized 1D CNNs—one per joint—creating a decentralized detection system. Across two experimental phases, involving both partial and full-structure monitoring, the method demonstrated high accuracy in damage localization, achieving a training classification error of just 0.54\%. While performance remained strong even under double-damage scenarios, some misclassifications occurred in symmetric or adjacent damage cases. Overall, the proposed method presents a highly efficient and accurate solution for real-time SHM applications.
-
-In the context of this thesis, the dataset and experimental setup introduced by [Author(s), Year] form the foundation for comparative analysis and algorithm testing. The authors have not only demonstrated the efficacy of a compact 1D CNN-based system for vibration-based structural damage detection, but also highlighted the value of using output-only acceleration data—a constraint shared in this thesis’s methodology. The decentralized design of their system, which allows each CNN to process only locally available data, is particularly aligned with this thesis's focus on efficient, sensor-level data analysis without requiring full-system synchronization. Furthermore, since the authors indicate plans to publicly release their dataset and source code, this thesis leverages that open data for applying alternative analysis methods such as support vector machines (SVM) or frequency domain feature extraction techniques, allowing a direct performance comparison between classical and deep learning-based SHM approaches. Thus, this work serves as both a benchmark reference and a data source in the development and evaluation of more accessible, lower-complexity alternatives for structural health monitoring systems.
-

latex/chapters/en/02_literature_review/theoritical_foundation/machine_learning.tex

@@ -1,33 +0,0 @@
-\subsection{Classification Algorithms}
-
-This research evaluates five classical machine learning algorithms to perform the classification task of damage localization. Each algorithm has different strengths and limitations, and their performance is benchmarked to identify the most suitable one for the given dataset.
-
-\subsubsection{Support Vector Machine (SVM)}
-
-SVM is a supervised learning algorithm that seeks an optimal hyperplane that separates data into classes with maximum margin. SVM performs well in high-dimensional spaces and is robust to overfitting, especially in cases with a clear margin of separation.
-
-SVM is appropriate for vibration signal classification due to its capability to handle nonlinear decision boundaries when equipped with kernel functions.
-
-\subsubsection{K-Nearest Neighbors (KNN)}
-
-KNN is a non-parametric, instance-based learning algorithm. It classifies a new data point based on the majority vote of its $k$ nearest neighbors in the feature space. Although simple, KNN can be effective when the data is well-distributed and class boundaries are smooth.
-
-Its performance is sensitive to the choice of $k$ and distance metric. For high-dimensional data like STFT features, dimensionality reduction or careful scaling may be required.
-
-\subsubsection{Decision Tree (DT)}
-
-Decision Tree is a rule-based classifier that splits data into classes using feature thresholds. It builds a tree where each internal node represents a feature, each branch a decision rule, and each leaf a class label. DTs are easy to interpret and can capture non-linear relationships.
-
-However, they are prone to overfitting, especially with noisy or small datasets.
-
-\subsubsection{Random Forest (RF)}
-
-Random Forest is an ensemble learning method based on constructing multiple decision trees during training and outputting the mode of the classes for classification. It improves the generalization capability of individual trees and reduces overfitting.
-
-RF is suitable for damage detection as it provides robustness to noise and variance, making it ideal for real-world sensor data.
-
-\subsubsection{Naïve Bayes (NB)}
-
-Naïve Bayes is a probabilistic classifier based on Bayes' theorem, assuming feature independence. Despite its simplicity, it often performs well in high-dimensional problems and with small datasets.
-
-NB is particularly effective when class-conditional independence holds approximately, which may occur when STFT features are well-separated in distribution.

latex/chapters/en/02_literature_review/theoritical_foundation/stft.tex

@@ -1,11 +0,0 @@
-\subsection{Short-Time Fourier Transform (STFT)}
-
-The Short-Time Fourier Transform (STFT) is a fundamental technique used to analyze non-stationary signals, such as those generated by structures under dynamic load or white noise excitation. While the traditional Fourier Transform provides frequency-domain information, it lacks time resolution. STFT overcomes this limitation by applying the Fourier Transform over short overlapping segments of the signal, thereby producing a time-frequency representation.
-
-Mathematically, the STFT of a signal $x(t)$ is given by:
-\begin{equation}
-X(t, \omega) = \int_{-\infty}^{\infty} x(\tau) w(\tau - t) e^{-j \omega \tau} d\tau
-\end{equation}
-where $w(\tau - t)$ is a window function centered at time $t$, and $\omega$ is the angular frequency.
-
-In this study, the STFT is employed to extract the time-frequency features of the vibration signals collected from the structure. These features are then used as inputs to machine learning classifiers. This process captures localized frequency content over time, which is crucial in identifying structural changes due to damage.

latex/chapters/id/02_literature_review/literature_review/abdeljaber2017.tex

@@ -1,3 +0,0 @@
-Metode monitor kesehatan struktur (SHM) tradisional sering kali mengandalkan fitur yang dibuat secara manual dan pengklasifikasi (\textit{classifier}) yang diatur secara manual, yang menimbulkan tantangan dalam hal generalisasi, keandalan, dan efisiensi komputasi. Seperti yang disorot oleh \textcite{abdeljaber2017}, pendekatan-pendekatan ini umumnya memerlukan proses \textit{trial-and-error} dalam pemilihan fitur dan pengklasifikasi yang tidak hanya mengurangi ketangguhan metode tersebut di berbagai jenis struktur, tetapi juga menghambat penerapannya dalam pengaplikasian secara \textit{real-time} karena beban komputasi pada fase ekstraksi fitur.
-
-\textcite{abdeljaber2017} memperkenalkan pendekatan deteksi kerusakan struktur berbasis CNN yang divalidasi melalui \textit{large-scale grandstand simulator} di Qatar University. Struktur tersebut dirancang untuk mereplikasi stadion modern, dilengkapi dengan 30 akselerometer, dan dikenai kerusakan terkontrol melalui pelonggaran baut sambungan antara balok dan gelagar. Data percepatan yang dikumpulkan di bawah eksitasi \textit{band-limited white noise} dan disampel pada 1024 Hz, kemudian dibagi menjadi bingkai berukuran 128 sampel untuk melatih 1-D CNN yang dilokalkan—satu untuk setiap sambungan (\textit{joint})—menciptakan sistem deteksi terdesentralisasi. Dalam dua fase (skenario) eksperimen, yang melibatkan pemantauan sebagian dan seluruh struktur, metode ini menunjukkan akurasi tinggi dalam pelokalisasian kerusakan, dengan kesalahan klasifikasi saat pelatihan hanya sebesar 0.54\%. Meskipun performa tetap andal bahkan dalam skenario kerusakan ganda, beberapa salah klasifikasi terjadi pada kasus kerusakan yang simetris atau berdekatan. Secara keseluruhan, metode yang diusulkan ini menawarkan solusi yang sangat efisien dan akurat untuk aplikasi SHM secara \textit{real-time}.

latex/chapters/id/02_literature_review/literature_review/index.tex

@@ -1,13 +0,0 @@
-Metode monitor kesehatan struktur (SHM) tradisional sering kali mengandalkan fitur yang dibuat secara manual dan pengklasifikasi (\textit{classifier}) yang diatur secara manual, yang menimbulkan tantangan dalam hal generalisasi, keandalan, dan efisiensi komputasi. Seperti yang disorot oleh \textcite{abdeljaber2017}, pendekatan-pendekatan ini umumnya memerlukan proses \textit{trial-and-error} dalam pemilihan fitur dan pengklasifikasi yang tidak hanya mengurangi ketangguhan metode tersebut di berbagai jenis struktur, tetapi juga menghambat penerapannya dalam pengaplikasian secara \textit{real-time} karena beban komputasi pada fase ekstraksi fitur.
-
-\textcite{abdeljaber2017} memperkenalkan pendekatan deteksi kerusakan struktur berbasis CNN yang divalidasi melalui \textit{large-scale grandstand simulator} di Qatar University. Struktur tersebut dirancang untuk mereplikasi stadion modern, dilengkapi dengan 30 akselerometer, dan dikenai kerusakan terkontrol melalui pelonggaran baut sambungan antara balok dan gelagar. Data percepatan yang dikumpulkan di bawah eksitasi \textit{band-limited white noise} dan disampel pada 1024 Hz, kemudian dibagi menjadi bingkai berukuran 128 sampel untuk melatih 1-D CNN yang dilokalkan—satu untuk setiap sambungan (\textit{joint})—menciptakan sistem deteksi terdesentralisasi. Dalam dua fase (skenario) eksperimen, yang melibatkan pemantauan sebagian dan seluruh struktur, metode ini menunjukkan akurasi tinggi dalam pelokalisasian kerusakan, dengan kesalahan klasifikasi saat pelatihan hanya sebesar 0.54\%. Meskipun performa tetap andal bahkan dalam skenario kerusakan ganda, beberapa salah klasifikasi terjadi pada kasus kerusakan yang simetris atau berdekatan. Secara keseluruhan, metode yang diusulkan ini menawarkan solusi yang sangat efisien dan akurat untuk aplikasi SHM secara\textit{real-time}.
-
-\indent Metode berbasis getaran merupakan salah satu teknik paling umum dalam sistem pemantauan kesehatan struktur (SHM) karena kemampuannya dalam mendeteksi perubahan kondisi struktur secara non-destruktif. Pendekatan ini bergantung pada prinsip bahwa kerusakan pada suatu struktur, seperti kelonggaran sambungan atau penurunan kekakuan elemen, akan mengubah karakteristik dinamikanya, seperti frekuensi alami, bentuk mode, dan respons getaran terhadap eksitasi tertentu.
-
-\indent Salah satu jenis kerusakan struktural yang umum dijumpai dalam sambungan mekanis adalah kelonggaran baut akibat beban dinamis berulang, seperti getaran atau kejutan. Kondisi ini dapat menyebabkan penurunan integritas struktur dan berujung pada kegagalan sistem jika tidak terdeteksi sejak dini. Oleh karena itu, deteksi kelonggaran baut secara dini telah menjadi perhatian utama dalam bidang teknik sipil, mesin, maupun dirgantara [1, 11].
-
-\indent Teknik deteksi berbasis getaran terbukti efektif dalam mengidentifikasi tanda-tanda awal kelonggaran sambungan. Hal ini dilakukan dengan menganalisis perubahan spektrum frekuensi atau energi getaran antar kondisi sehat dan rusak. Dalam praktiknya, data getaran biasanya dikumpulkan melalui akselerometer yang dipasang pada titik-titik tertentu dalam struktur. Perubahan karakteristik getaran, seperti penurunan amplitudo, pergeseran frekuensi dominan, atau pola spektral lainnya, menjadi indikator keberadaan dan lokasi kerusakan.
-
-\indent Sejumlah penelitian telah menerapkan teknik ini dalam konteks struktur kompleks seperti sambungan multi-baut atau grid struktural. Misalnya, studi oleh Zhao et al. [10] menunjukkan bahwa perubahan rotasi kepala baut akibat kelonggaran dapat dikaitkan dengan pola getaran tertentu. Sementara itu, pendekatan yang lebih umum dalam domain teknik sipil adalah memanfaatkan sinyal akselerasi dari sambungan kolom atau balok sebagai masukan untuk sistem klasifikasi kerusakan berbasis pembelajaran mesin [12].
-
-\indent Kelebihan utama dari pendekatan berbasis getaran dibanding metode visual atau inspeksi manual adalah kemampuannya dalam mendeteksi kerusakan mikro secara lebih dini, bahkan sebelum tampak secara fisik. Namun, tantangan tetap ada, terutama dalam penempatan sensor yang optimal, pemrosesan sinyal, dan interpretasi pola dinamik yang kompleks dalam struktur grid. Oleh karena itu, kombinasi antara teknik transformasi sinyal seperti Short-Time Fourier Transform (STFT) dan algoritma pembelajaran mesin menjadi arah baru yang menjanjikan dalam riset SHM masa kini.

latex/chapters/id/03_methodology/data_analysis/index.tex

@@ -0,0 +1,151 @@
+\section{Analisis Data}
+\subsection{Grid, Kode \textit{Joint}, dan Nama File}
+
+% \begin{figure}[ht]
+%     \centering
+%     \input{chapters/img/specimen}
+%     \caption{Caption}
+%     \label{fig:enter-label}
+% \end{figure}
+% Dimulai dengan memberi indeks pada setiap node pengukuran dari struktur grid berukuran 6$\times$5 menggunakan sebuah bilangan bulat tunggal \(k\) dari nol hingga dua puluh sembilan. Setiap sinyal domain waktu mentah disimpan dalam file yang dinamai berdasarkan indeks ini:
+% \begin{equation*}
+% F_{k} = \texttt{``zzzAD}k\texttt{.TXT,''}
+% \quad k = 0,1,\dots,29.
+% \end{equation*}
+
+Direpresentasikan \(F_{k}\) di sini sebagai nama file untuk \textit{node} ke-\(k\). Kemudian dilampirkan nama file tersebut sebagai superskrip pada simbol \textit{node}:
+\begin{equation*}
+n_{k}^{F_{k}}
+\quad\text{adalah \textit{node} dengan indeks }k\text{ yang datanya diambil dari \textit{file} }F_{k}.
+\end{equation*}
+
+\subsection{Pemetaan Sensor}
+
+Semua tiga puluh node dikelompokkan ke dalam enam folder ``damage-case``, dilabeli \(d_{i}\) untuk \(i=0,\dots,5\). Setiap folder berisi tepat lima node berurutan, yang merepresentasikan satu skenario kerusakan:
+\begin{equation*}
+d_{i} = \bigl\{\,n_{5i}^{F_{5i}},\;n_{5i+1}^{F_{5i+1}},\;\dots,\;n_{5i+4}^{F_{5i+4}}\bigr\},
+\quad i = 0,\dots,5.
+\end{equation*}
+Atau secara konkrit, 
+\begin{align*}
+d_0&=\{n_{0}^{F_0},\;n_{1}^{F_1},\;n_{2}^{F_2},\;n_{3}^{F_3},\;n_{4}^{F_4}\}\\
+d_1&=\{n_{5}^{F_5},\;n_{6}^{F_6},\;n_{7}^{F_7},\;n_{8}^{F_8},\;n_{9}^{F_9}\}\\
+\;\;\vdots\\
+d_5&=\{n_{25}^{F_{25}},\;n_{26}^{F_{26}},\;n_{27}^{F_{27}},\;n_{28}^{F_{28}},\;n_{29}^{F_{29}}\}\\
+\end{align*}
+
+\subsection{Seleksi Sensor \textit{Node} Ujung-Ujung (Domain Waktu)}
+
+Dari setiap folder kerusakan, kita hanya menyimpan \textit{node} pertama dan terakhir untuk mensimulasikan tata letak sensor terbatas. Subset domain waktu ini dilambangkan dengan \(d_{i}^{\mathrm{TD}}\):
+\begin{equation*}
+d_{i}^{\mathrm{TD}}
+= \bigl\{\,n_{5i}^{F_{5i}},\;n_{5i+4}^{F_{5i+4}}\bigr\},
+\quad |d_{i}^{\mathrm{TD}}| = 2.
+\end{equation*}
+
+\subsection{Ekstraksi Fitur}
+
+Kemudian, didefinisikan operator STFT \(\mathcal{T}\) untuk memetakan sinyal domain waktu mentah dengan panjang \(L=262144\) sampel menjadi sebuah spektrogram berukuran \(513\times513\). Kemudian digunakan \textit{Hanning window} dengan panjang \(N_{w}=1024\) dan hop size \(N_{h}=512\). Bentuk kompleks dari STFT adalah:
+\begin{equation*}
+\begin{aligned}
+\text{(1) Window function:}\quad
+w[n] &= \frac12\Bigl(1 - \cos\frac{2\pi n}{N_w - 1}\Bigr),
+\quad n=0,\ldots,N_w-1; \\[1ex]
+\text{(2) STFT:}\quad
+S_k(p,t)
+&= \sum_{n=0}^{N_w-1}
+x_k\bigl[t\,N_h + n\bigr]
+\;w[n]\;
+e^{-j2\pi p n / N_w},\\
+&\quad
+p = 0,\ldots,512,\quad t = 0,\ldots,512.
+\end{aligned}
+\end{equation*}
+
+Pengambilan magnitudo menghasilkan matriks spektrogram pada bilah frekuensi $p$ dan \textit{frame} waktu $t$ untuk \textit{node} $k$
+\begin{equation*}
+\widetilde n_{k}^{F_{k}}(p,t) \;=\; \bigl|S_{k}(p,t)\bigr|
+\;\in\;\mathbb{R}^{513\times513}.
+\end{equation*}
+Dengan demikian operatornya adalah
+\begin{equation*}
+\mathcal{T}:\; n_{k}^{F_{k}}\in\mathbb{R}^{262144}
+\;\longmapsto\;
+\widetilde n_{k}^{F_{k}}\in\mathbb{R}^{513\times513}.
+\end{equation*}
+
+\subsection{Subset Domain Frekuensi}
+
+Kemudian, \(\mathcal{T}\) diterapkan pada \textit{node} ujung-ujung yang telah dipilih, dihasilkan:
+\begin{equation*}
+d_{i}^{\mathrm{FD}}
+= \bigl\{\,
+\widetilde n_{5i}^{F_{5i}},\;
+\widetilde n_{5i+4}^{F_{5i+4}}
+\,\bigr\},
+\quad
+|d_{i}^{\mathrm{FD}}| = 2.
+\end{equation*}
+
+\subsection{Pengelompokan Berdasarkan Letak Ujung Sensor}
+
+Sensor-sensor ujung bagian bawah dilabeli sebagai Sensor A dan Sensor-sensor ujung bagian atas dilabeli sebagai Sensor B. Semua enam kasus kerusakan dikumpulkan menjadi satu menghasilkan dua himpunan spektrogram, masing-masing berisi enam (kasus kerusakan):
+\begin{equation*}
+\text{Sensor A}
+=
+\bigl\{\,
+\widetilde n_{0}^{F_{0}},\,
+\widetilde n_{5}^{F_{5}},\,
+\dots,\,
+\widetilde n_{25}^{F_{25}}
+\bigr\},
+\quad
+\text{Sensor B}
+=
+\bigl\{\,
+\widetilde n_{4}^{F_{4}},\,
+\widetilde n_{9}^{F_{9}},\,
+\dots,\,
+\widetilde n_{29}^{F_{29}}
+\bigr\}.
+\end{equation*}
+
+\subsection{Perakitan Baris dan Pelabelan}
+
+Setiap spektrogram berukuran \(513\times513\) diartikan sebagai 513 vektor fitur berdimensi 513. Kemudian diberikan indeks pengulangan dalam satu kasus kerusakan dengan \(r\in\{0,\dots,4\}\) dan potongan waktu dengan \(t\in\{0,\dots,512\}\). Misalkan
+\begin{equation*}
+\mathbf{x}_{i,s,r,t}\in\mathbb{R}^{513}
+\end{equation*}
+menunjukkan baris (atau kolom) ke-\(t\) dari spektrogram ke-\(r\) untuk kasus kerusakan \(i\) dan sensor \(s\). Label skalar untuk kasus kerusakan tersebut adalah
+\begin{equation*}
+y_{i} = i,\quad i=0,\dots,5.
+\end{equation*}
+Kemudian didefinisikan fungsi \textit{slicing} sebagai
+\begin{equation*}
+\Lambda(i,s,r,t)
+\;=\;
+\bigl[\,
+\mathbf{x}_{i,s,r,t},
+\;y_{i}
+\bigr]
+\;\in\;\mathbb{R}^{513+1}.
+\end{equation*}
+
+\subsection{Bentuk Akhir Data untuk Pelatihan}
+
+Seluruh baris dari enam kasus kerusakan, lima pengulangan, dan 513 potongan waktu dikumpulkan menghasilkan \textit{dataset} untuk satu sisi sensor:
+\begin{equation*}
+\mathcal{D}^{(s)}
+=
+\bigl\{
+\Lambda(i,s,r,t)
+\;\big|\;
+i=0,\dots,5,\;
+r=0,\dots,4,\;
+t=0,\dots,512
+\bigr\}.
+\end{equation*}
+Karena terdapat total \(6\times5\times513=15{,}390\) baris dan setiap baris memiliki \(513\) fitur ditambah satu kolom label, maka bentuk akhir dari data untuk satu sisi sensor yang siap digunakan untuk pelatihan adalah
+\begin{equation*}
+|\mathcal{D}^{(s)}| = 15\,390 \times 514.
+\end{equation*}

latex/chapters/id/03_methodology/index.tex

@@ -0,0 +1,7 @@
+\chapter{METODE PENELITIAN}
+
+\input{chapters/id/03_methodology/material/index}
+\input{chapters/id/03_methodology/tool/index}
+\clearpage
+\input{chapters/id/03_methodology/steps/index}
+\input{chapters/id/03_methodology/data_analysis/index}

latex/chapters/id/03_methodology/material/index.tex

@@ -0,0 +1,26 @@
+\section{Benda Uji}
+
+Penelitian ini menggunakan data sekunder dari \textcite{abdeljaber2017}, yang tersedia secara publik dan diperoleh melalui eksperimen menggunakan \textit{Queen's University Grandstand Simulator}. Adapun rincian data yang digunakan adalah sebagai berikut:
+
+\begin{itemize}
+    \item Dataset terdiri atas rekaman respons getaran dari struktur rangka baja berukuran $6 \times 5$ yang dilengkapi dengan 30 akselerometer.
+    \item Setiap skenario dalam dataset mencakup satu kasus struktur tanpa kerusakan (healthy) dan 30 kasus kerusakan tunggal pada masing-masing sambungan (\textit{single-joint damage}).
+    \item Sinyal getaran direkam dengan frekuensi pengambilan sampel sebesar 1024 Hz selama durasi 256 detik untuk tiap skenario.
+    \item Kerusakan struktur disimulasikan dengan cara mengendurkan baut pada sambungan-sambungan tertentu.
+\end{itemize}
+
+Struktur dataset yang digunakan ditampilkan pada Gambar~\ref{fig:specimen-photo}.
+
+% \begin{figure}[!ht]
+%     \centering
+%     \includegraphics[width=0.5\textwidth]{chapters/img/original_data.png}
+%     \caption{Overview of the original data used from Abdeljaber et al. (2017)}
+%     \label{fig:original-data}
+% \end{figure}
+
+\begin{figure}[ht]
+    \centering
+    \includegraphics[width=0.75\linewidth]{chapters/img/specimen.png}
+    \caption{Bentuk benda uji}
+    \label{fig:specimen-photo}
+\end{figure}

latex/chapters/id/03_methodology/steps/data_acquisition.tex

@@ -0,0 +1,33 @@
+Dataset yang digunakan dalam penelitian ini bersumber dari basis data getaran yang dipublikasi oleh \textcite{abdeljaber2017}.
+
+Dataset terdiri dari dua folder:
+\begin{itemize}
+  \item \texttt{Dataset A/} – biasanya digunakan untuk pelatihan (training)
+  \item \texttt{Dataset B/} – biasanya digunakan untuk pengujian (testing)
+\end{itemize}
+
+Setiap folder berisi 31 berkas dalam format \texttt{.TXT}, yang dinamai sesuai dengan kondisi kerusakan struktur. Pola penamaan berkas adalah sebagai berikut:
+
+\begin{itemize}
+  \item \texttt{zzzAU.TXT}, \texttt{zzzBU.TXT} — struktur tanpa kerusakan (sehat)
+  \item \texttt{zzzAD1.TXT}, \texttt{zzzAD2.TXT}, ..., \texttt{zzzAD30.TXT} — Dataset A, kerusakan pada sambungan 1–30
+  \item \texttt{zzzBD1.TXT}, \texttt{zzzBD2.TXT}, ..., \texttt{zzzBD30.TXT} — Dataset B, kerusakan pada sambungan 1–30
+\end{itemize}
+
+Sepuluh baris pertama dari setiap berkas berisi metadata yang menjelaskan konfigurasi pengujian, laju sampling, dan informasi kanal. Oleh karena itu, data deret waktu percepatan dimulai dari baris ke-11 yang berisi 31 kolom:
+\begin{itemize}
+  \item \textbf{Kolom 1:} Waktu dalam detik
+  \item \textbf{Kolom 2–31:} Magnitudo percepatan dari \textit{joint} 1 hingga 30
+\end{itemize}
+
+Setiap sinyal di-\textit{sampling} pada frekuensi $f_s = 1024$ Hz dan direkam selama durasi total $T = 256$ detik, sehingga menghasilkan:
+
+\begin{equation*}
+N = f_s \cdot T = 1024 \times 256 = 262{,}144 \quad \text{sampel per kanal}
+\end{equation*}
+
+Dengan demikian, setiap berkas dapat direpresentasikan sebagai matriks:
+\begin{equation*}
+\mathbf{X}^{(c)} \in \mathbb{R}^{262{,}144 \times 31}, \quad c = 0, 1, \dots, 30
+\end{equation*}
+di mana $c$ mengacu pada indeks kasus (0 = sehat, 1–30 = kerusakan pada \textit{joint}n ke-$c$), dan setiap baris merepresentasikan pengukuran berdasarkan waktu di seluruh 30 kanal sensor.

latex/chapters/id/03_methodology/steps/index.tex

@@ -0,0 +1,29 @@
+\section{Tahapan Penelitian}
+Alur keseluruhan penelitian ini dilakukan melalui tahapan-tahapan sebagai berikut:
+
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=0.3\linewidth]{chapters/id/flow.png}
+    \caption{Diagram alir tahapan penelitian}
+    \label{fig:flowchart}
+\end{figure}
+
+\begin{enumerate}
+    \item \textbf{Akuisisi Data:} Mengunduh dataset dari \textcite{abdeljaber2017} yang berisi sinyal percepatan untuk 31 kondisi struktur (1 kondisi sehat dan 30 kondisi kerusakan tunggal).
+    
+    % \item \textbf{Seleksi Sensor:} Memilih sinyal dari sejumlah sensor terbatas pada garis vertikal tertentu (misalnya, node 1 dan 26) untuk mensimulasikan konfigurasi sensor yang direduksi.
+
+    \item \textbf{Pra-pemrosesan:} Melakukan normalisasi dan mengubah sinyal domain waktu mentah menjadi domain waktu-frekuensi menggunakan metode Short-Time Fourier Transform (STFT).
+
+    \item \textbf{Ekstraksi Fitur:} Menghasilkan \textit{data frame} frekuensi dalam domain waktu.
+
+    \item \textbf{Pengembangan Model:} Membangun dan melatih model klasifikasi berbasis algoritma pemelajaran mesin klasik (SVM, LDA, Bagged Trees, Random Forest, XGBoost) untuk mengklasifikasikan lokasi kerusakan struktur.
+
+    \item \textbf{Evaluasi:} Mengevaluasi kinerja model menggunakan metrik akurasi, presisi, dan confusion matrix pada berbagai skenario pengujian.
+\end{enumerate}
+
+\subsection{Akuisisi Data}
+\input{chapters/id/03_methodology/steps/data_acquisition}
+
+% \subsection{Prapemrosesan Data dan Ekstraksi Fitur}
+

latex/chapters/id/03_methodology/tool/hardware.tex

@@ -0,0 +1,39 @@
+Data getaran struktur yang digunakan dalam penelitian ini diperoleh dari penelitian oleh \textcite{abdeljaber2017}, yang dilakukan menggunakan simulator struktur baja Grandstand di Queen’s University. Dalam eksperimen tersebut, struktur baja dipasang dengan akselerometer pada setiap sambungan-sambungan (\textit{joints}). Rangkaian perangkat keras yang digunakan untuk pengambilan data meliputi:
+
+\begin{itemize}
+    \item \textbf{27 akselerometer PCB model 393B04} (Gambar~\ref{fig:pcb393}) untuk merekam respons percepatan pada sebagian besar titik pengukuran.
+    \item \textbf{3 akselerometer B\&K model 8344} (Gambar~\ref{fig:bk8344}) digunakan pada beberapa lokasi untuk validasi tambahan.
+    \item \textbf{Mounting magnetic PCB model 080A121} digunakan untuk menempelkan akselerometer secara aman pada struktur baja.
+    \item \textbf{Modal shaker (Model 2100E11)} digunakan untuk memberikan eksitasi getaran terkontrol pada struktur (Gambar~\ref{fig:shaker}). Sinyal input untuk shaker dihasilkan melalui \textbf{penguat daya SmartAmp 2100E21-400}.
+    \item \textbf{Dua perangkat akuisisi data 16-kanal (DT9857E-16)} digunakan secara simultan: satu untuk menghasilkan sinyal input ke shaker dan satu lagi untuk merekam data keluaran dari akselerometer (Gambar~\ref{fig:datalogger}).
+\end{itemize}
+
+Seluruh perangkat ini memungkinkan pengambilan data getaran dengan fidelitas tinggi, dengan laju pengambilan sampel sebesar 1024 Hz per kanal selama 256 detik untuk setiap skenario pengujian.
+
+Adapun sumberdaya komputasi yang digunakan untuk pemrosesan semua data dan pemodelan pada skripsi ini, yaitu:
+
+\begin{itemize}
+    \item \textbf{\textit{Processor}:} Intel Core i7 11th-gen @ 2.8 GHz
+    \item \textbf{RAM:} 2$\times$8 GB LPDDR4X
+    % \item \textbf{GPU:} Intel iris Xe Graphics (16 GB VRAM \textit{shared})
+    \item \textbf{Sistem Operasi:} Windows 10 64-bit
+\end{itemize}
+
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=\textwidth]{chapters/img/accel393.png}
+    \caption{Akselerometer yang digunakan: (a) PCB 393B04, (b) B\&K 8344}
+    \label{fig:accel393}
+\end{figure}
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=0.4\textwidth]{chapters/img/shaker.png}
+    \caption{Modal shaker (TMS 2100E11) yang dipasang pada struktur uji}
+    \label{fig:shaker}
+\end{figure}
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=0.7\textwidth]{chapters/img/datalogger.png}
+    \caption{Perangkat akuisisi data (DT9857E-16) dan penguat daya SmartAmp 2100E21-400}
+    \label{fig:datalogger}
+\end{figure}

latex/chapters/id/03_methodology/tool/index.tex

@@ -0,0 +1,7 @@
+\section{Alat}
+
+\subsection{Alat Perangkat Keras}
+\input{chapters/id/03_methodology/tool/hardware}
+
+\subsection{Alat Perangkat Lunak}
+\input{chapters/id/03_methodology/tool/software}

latex/chapters/id/03_methodology/tool/software.tex

@@ -0,0 +1,11 @@
+Berikut merupakan perangkat lunak yang digunakan selama proses penelitian ini:
+
+\begin{itemize}
+    \item \textbf{Python 3.11} – digunakan untuk proses pra-pemrosesan data, pemodelan, dan evaluasi.
+    \item \textbf{NumPy 1.22.4} – digunakan untuk perhitungan deret numerik.
+    \item \textbf{Pandas 1.5.1} – digunakan untuk memanipulasi struktur data.
+    \item \textbf{Pandas 1.7.3} – digunakan untuk memproses sinyal.
+    \item \textbf{Matplotlib 3.7.1} – digunakan untuk menghasilkan plot data.
+    \item \textbf{Scikit-Learn 1.5.1} – digunakan untuk membangun dan melatih model dengan algoritma pemelajaran mesin klasik.
+    \item \textbf{Jupyter Notebook} – digunakan untuk pelatihan model dan percobaan eksperimental secara interaktif.
+\end{itemize}

latex/chapters/img/specimen.tex

@@ -0,0 +1,13 @@
+\begin{matrix}
+N_{6,5} & \text{---} & N_{6,4} & \text{---} & N_{6,3} & \text{---} & N_{6,2} & \text{---} & N_{6,1} \\
+\vert    &          & \vert    &          & \vert    &          & \vert    &          & \vert    \\
+N_{5,5} & \text{---} & N_{5,4} & \text{---} & N_{5,3} & \text{---} & N_{5,2} & \text{---} & N_{5,1} \\
+\vert    &          & \vert    &          & \vert    &          & \vert    &          & \vert    \\
+N_{4,5} & \text{---} & N_{4,4} & \text{---} & N_{4,3} & \text{---} & N_{4,2} & \text{---} & N_{4,1} \\
+\vert    &          & \vert    &          & \vert    &          & \vert    &          & \vert    \\
+N_{3,5} & \text{---} & N_{3,4} & \text{---} & N_{3,3} & \text{---} & N_{3,2} & \text{---} & N_{3,1} \\
+\vert    &          & \vert    &          & \vert    &          & \vert    &          & \vert    \\
+N_{2,5} & \text{---} & N_{2,4} & \text{---} & N_{2,3} & \text{---} & N_{2,2} & \text{---} & N_{2,1} \\
+\vert    &          & \vert    &          & \vert    &          & \vert    &          & \vert    \\
+N_{1,5} & \text{---} & N_{1,4} & \text{---} & N_{1,3} & \text{---} & N_{1,2} & \text{---} & N_{1,1} \\
+\end{matrix}

latex/thesis.cls

@@ -20,6 +20,7 @@
 \RequirePackage{etoolbox}
 \RequirePackage{tocloft}
 \RequirePackage{tocbibind}
+\RequirePackage{amsmath,amsfonts,amssymb}
 
 % Polyglossia set language
 \setmainlanguage{bahasai}