Revert "Expose maketitle by just using \input"

fix path

.github/workflows/latex-lint.yml

@@ -0,0 +1,52 @@
+name: LaTeX Lint
+
+on:
+  push:
+    branches:
+      - main
+      - dev
+    paths:
+      - 'latex/**/*.tex'
+      - 'latex/main.tex'
+  workflow_dispatch:
+  
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install chktex
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y chktex
+
+      - name: Run chktex inside latex/
+        working-directory: latex
+        run: |
+          TEX_FILES=$(find . -type f -name "*.tex")
+          if [ -z "$TEX_FILES" ]; then
+            echo "No .tex files found in latex/. Skipping lint."
+            exit 0
+          fi
+          
+          echo "🔍 Linting .tex files with chktex..."
+          FAIL=0
+          
+          for f in $TEX_FILES; do
+            echo "▶ Checking $f"
+            # Run chktex and show output; capture error status
+            if ! chktex "$f"; then
+              echo "::warning file=$f::ChkTeX found issues in $f"
+              FAIL=1
+            fi
+          done
+          
+          if [ $FAIL -ne 0 ]; then
+            echo "::error::❌ Lint errors or warnings were found in one or more .tex files above."
+            exit 1
+          else
+            echo "✅ All files passed chktex lint."
+          fi

.github/workflows/latexdiff.yml

@@ -0,0 +1,89 @@
+name: LaTeX Diff
+
+on:
+  workflow_dispatch:
+    inputs:
+      base_branch:
+        description: 'Base branch (older version)'
+        required: true
+      compare_branch:
+        description: 'Compare branch (new version)'
+        required: true
+
+jobs:
+  latexdiff:
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/xu-cheng/texlive-full:latest
+      options: --user root
+
+    steps:
+      - name: Install latexpand (Perl script)
+        run: |
+          tlmgr init-usertree
+          tlmgr install latexpand
+        
+      - name: Checkout base branch
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.inputs.base_branch }}
+          path: base
+
+      - name: Checkout compare branch
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.inputs.compare_branch }}
+          path: compare
+
+
+      - name: Create output folder
+        run: mkdir -p diff_output
+
+      - name: Flatten base/main.tex (with latexpand)
+        run: |
+          cd base/latex
+          echo "📂 Listing files in base/latex:"
+          ls -R
+          echo "🔄 Flattening with latexpand..."
+          latexpand --verbose --keep-comments --output=../../diff_output/base_flat.tex main.tex
+          echo "✅ Preview of base_flat.tex:"
+          head -n 50 ../../diff_output/base_flat.tex
+
+
+      - name: Flatten compare/main.tex (with latexpand)
+        run: |
+          cd compare/latex
+          echo "📂 Listing files in compare/latex:"
+          ls -R
+          echo "🔄 Flattening with latexpand..."
+          latexpand --verbose --keep-comments --output=../../diff_output/compare_flat.tex main.tex
+          echo "✅ Preview of compare_flat.tex:"
+          head -n 50 ../../diff_output/compare_flat.tex
+
+      - name: Generate diff.tex using latexdiff
+        run: |
+          latexdiff diff_output/base_flat.tex diff_output/compare_flat.tex > diff_output/diff.tex
+          
+      - name: Upload flattened .tex and diff.tex early
+        uses: actions/upload-artifact@v4
+        with:
+          name: latex-diff-tex
+          path: |
+            diff_output/base_flat.tex
+            diff_output/compare_flat.tex
+            diff_output/diff.tex
+            
+      - name: Copy thesis.cls to diff_output
+        run: cp compare/latex/thesis.cls diff_output/
+        
+      - name: Compile diff.tex to PDF
+        working-directory: diff_output
+        run: |
+          xelatex -interaction=nonstopmode diff.tex
+          xelatex -interaction=nonstopmode diff.tex
+
+      - name: Upload diff output files
+        uses: actions/upload-artifact@v4
+        with:
+          name: latex-diff-output
+          path: diff_output/

.github/workflows/latexmk.yml

@@ -0,0 +1,29 @@
+name: Render XeLaTeX on PR to dev
+
+on:
+  pull_request:
+    branches:
+      - dev
+
+jobs:
+  build-pdf:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Compile XeLaTeX
+        uses: dante-ev/latex-action@2021-A
+        with:
+          root_file: main.tex
+          working_directory: latex
+          compiler: xelatex
+          args: -interaction=nonstopmode -halt-on-error -file-line-error
+          extra_system_packages: "fonts-freefont-otf"
+
+      - name: Upload compiled PDF
+        uses: actions/upload-artifact@v4
+        with:
+          name: compiled-pdf
+          path: latex/main.pdf

.gitignore

@@ -2,17 +2,4 @@
 data/**/*.csv
 .venv/
 *.pyc
-*.egg-info/
+*.egg-info/
-
-# Latex
-*.aux
-*.log
-*.out
-*.toc
-*.bbl
-*.blg
-*.fdb_latexmk
-*.fls
-*.synctex.gz
-*.dvi
-latex/.build/*

.vscode/settings.json

@@ -1,29 +1,4 @@
 {
-  "files.autoSave": "off", // Disable autosave
+  "python.analysis.extraPaths": ["./code/src/features"],
-  "python.analysis.extraPaths": [
+  "jupyter.notebookFileRoot": "${workspaceFolder}/code"
-    "./code/src/features",
-    "${workspaceFolder}/code/src"
-  ],
-  "jupyter.notebookFileRoot": "${workspaceFolder}/code",
-  "latex-workshop.latex.outDir": "./.build",
-  // "latex-workshop.latex.tools": [
-  // {
-  //   "name": "xelatex",
-  //   "command": "xelatex",
-  //   "args": [
-  //     "-synctex=1",
-  //     "-interaction=nonstopmode",
-  //     "-output-directory=./latex/.build",
-  //     "%DOC%"
-  //   ]
-  // }
-  // ],
-  // "latex-workshop.latex.recipes": [
-  //   {
-  //     "name": "xelatex",
-  //     "tools": ["xelatex"]
-  //   }
-  // ],
-  "latex-workshop.latex.recipe.default": "latexmk (xelatex)", // Optional: Use the last used recipe
-
 }

code/src/data_preprocessing.py

@@ -1,357 +0,0 @@
-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
-from pprint import pprint
-
-# class DamageFilesIndices(TypedDict):
-#     damage_index: int
-#     files: list[int]
-OriginalSingleDamageScenarioFilePath = str
-DamageScenarioGroupIndex = int
-OriginalSingleDamageScenario = pd.DataFrame
-SensorIndex = int
-VectorColumnIndex = List[SensorIndex]
-VectorColumnIndices = List[VectorColumnIndex]
-DamageScenarioGroup = List[OriginalSingleDamageScenario]
-GroupDataset = List[DamageScenarioGroup]
-
-
-class DamageFilesIndices(TypedDict):
-    damage_index: int
-    files: List[str]
-
-def complement_pairs(n, prefix, extension):
-    """
-    Return the four complement tuples for zzzBD<n>.TXT
-    """
-    filename = f"{prefix}{n}.{extension}" # TODO: shouldnt be hardcoded
-    orig_a   = (n - 1) % 5 + 1                # 1 … 5
-    for a in range(1, 6):              # a = 1 … 5
-        if a != orig_a:                # skip original a
-            yield (filename, [a, a + 25]) # use yield instead of return to return a generator of tuples
-
-def generate_df_tuples(prefix: str, total_dfs: int=30, extension: str="TXT", first_col_start: int=1, last_col_offset: int=25, 
-                      group_size: int=5, special_groups: list=None, group: bool=True):
-    """
-    Generate a structured list of tuples containing DataFrame references and column indices.
-    
-    Parameters:
-    -----------
-    total_dfs : int, default 30
-        Total number of DataFrames to include in the tuples
-    group_size : int, default 5
-        Number of DataFrames in each group (determines the pattern repeat)
-    prefix : str
-        Prefix for DataFrame variable names
-    first_col_start : int, default 1
-        Starting value for the first column index (1-indexed)
-    last_col_offset : int, default 25
-        Offset to add to first_col_start to get the last column index
-    special_groups : list of dict, optional
-        List of special groups to insert, each dict should contain:
-        - 'df_name': The DataFrame name to use for all tuples in this group
-        - 'position': Where to insert this group (0 for beginning)
-        - 'size': Size of this group (default: same as group_size)
-    
-    Returns:
-    --------
-    list
-        List of tuples, where each tuple contains (df_name, [first_col, last_col])
-    """
-    result = []
-    if group:
-        # Group tuples into sublists of group_size
-        for g in range(6):                # TODO: shouldnt be hardcoded
-            group = []
-            for i in range(1, 6):         # TODO: shouldnt be hardcoded
-                n = g * 5 + i
-                bottom_end = i                           # 1, 2, 3, 4, 5
-                top_end = bottom_end + 25                # 26, 27, 28, 29, 30 # TODO: shouldnt be hardcoded
-                group.append((f"{prefix}{n}.{extension}", [bottom_end, top_end]))
-            result.append(group)
-
-    # Add special groups at specified positions (other than beginning)
-    if special_groups:
-        result.insert(0, special_groups)
-    
-    
-    return result
-
-
-    # file_path = os.path.join(base_path, f"zzz{prefix}D{file_index}.TXT")
-    # df = pd.read_csv(file_path, sep="\t", skiprows=10)  # Read with explicit column names
-
-
-class DataProcessor:
-    def __init__(self, file_index, cache_path: str = None, base_path: str = None, include_time: bool = False):
-        self.file_index = file_index
-        self.base_path = base_path
-        self.include_time = include_time
-        if cache_path:
-            self.data = load(cache_path)
-        else:
-            self.data = self.load_data()
-
-    def load_data(self):
-        for idxs, group in enumerate(self.file_index):
-            for idx, tuple in enumerate(group):
-                file_path = os.path.join(self.base_path, tuple[0]) # ('zzzAD1.TXT')
-                if self.include_time:
-                    col_indices = [0] + tuple[1]  # [1, 26] + [0] -> [0, 1, 26]
-                else:
-                    col_indices = tuple[1] # [1, 26]
-                try:
-                    # Read the CSV file
-                    df = pd.read_csv(file_path, delim_whitespace=True, skiprows=10, header=0, memory_map=True)
-                    self.file_index[idxs][idx] = df.iloc[:, col_indices].copy()  # Extract the specified columns
-                    
-                    print(f"Processed {file_path}, extracted columns: {col_indices}")
-                    
-                except Exception as e:
-                    print(f"Error processing {file_path}: {str(e)}")
-    def _load_dataframe(self, file_path: str) -> OriginalSingleDamageScenario:
-        """
-        Loads a single data file into a pandas DataFrame.
-
-        :param file_path: Path to the data file.
-        :return: DataFrame containing the numerical data.
-        """
-        df = pd.read_csv(file_path, delim_whitespace=True, skiprows=10, header=0, memory_map=True, nrows=1)
-        return df
-
-    def _load_all_data(self) -> GroupDataset:
-        """
-        Loads all data files based on the grouping dictionary and returns a nested list.
-
-        :return: A nested list of DataFrames where the outer index corresponds to group_idx - 1.
-        """
-        data = []
-        # Find the maximum group index to determine the list size
-        max_group_idx = len(self.file_index) if self.file_index else 0
-
-        # Handle case when file_index is empty
-        if max_group_idx == 0:
-            raise ValueError("No file index provided; file_index is empty.")
-
-        # Initialize empty lists
-        for _ in range(max_group_idx):
-            data.append([])
-
-        # Fill the list with data
-        for group_idx, file_list in self.file_index.items():
-            group_idx -= 1 # adjust due to undamage file
-            data[group_idx] = [self._load_dataframe(file) for file in file_list]
-        return data
-
-    def get_group_data(self, group_idx: int) -> List[pd.DataFrame]:
-        """
-        Returns the list of DataFrames for the given group index.
-
-        :param group_idx: Index of the group.
-        :return: List of DataFrames.
-        """
-        return self.data.get([group_idx, []])
-
-    def get_column_names(self, group_idx: int, file_idx: int = 0) -> List[str]:
-        """
-        Returns the column names for the given group and file indices.
-
-        :param group_idx: Index of the group.
-        :param file_idx: Index of the file in the group.
-        :return: List of column names.
-        """
-        if group_idx in self.data and len(self.data[group_idx]) > file_idx:
-            return self.data[group_idx][file_idx].columns.tolist()
-        return []
-
-    def get_data_info(self):
-        """
-        Print information about the loaded data structure.
-        Adapted for when self.data is a List instead of a Dictionary.
-        """
-        if isinstance(self.data, list):
-            # For each sublist in self.data, get the type names of all elements
-            pprint(
-                [
-                    (
-                        [type(item).__name__ for item in sublist]
-                        if isinstance(sublist, list)
-                        else type(sublist).__name__
-                    )
-                    for sublist in self.data
-                ]
-            )
-        else:
-            pprint(
-                {
-                    key: [type(df).__name__ for df in value]
-                    for key, value in self.data.items()
-                }
-                if isinstance(self.data, dict)
-                else type(self.data).__name__
-            )
-
-    def _create_vector_column_index(self) -> VectorColumnIndices:
-        vector_col_idx: VectorColumnIndices = []
-        y = 0
-        for data_group in self.data:  # len(data_group[i]) = 5
-            for j in data_group:  # len(j[i]) =
-                c: VectorColumnIndex = []
-                x = 0
-                for _ in range(6):  # TODO: range(6) should be dynamic and parameterized
-                    c.append(x + y)
-                    x += 5
-                vector_col_idx.append(c)
-                y += 1
-            return vector_col_idx # TODO: refactor this so that it returns just from first data_group without using for loops through the self.data that seems unnecessary
-
-    def create_vector_column(self, overwrite=True) -> List[List[List[pd.DataFrame]]]:
-        """
-        Create a vector column from the loaded data.
-
-        :param overwrite: Overwrite the original data with vector column-based data.
-        """
-        idxs = self._create_vector_column_index()
-        for i, group in enumerate(self.data):
-            # add 1 to all indices to account for 'Time' being at position 0
-            for j, df in enumerate(group):
-                idx = [_ + 1 for _ in idxs[j]]
-                # slice out the desired columns, copy into a fresh DataFrame,
-                # then overwrite self.data[i][j] with it
-                self.data[i][j] = df.iloc[:, idx].copy()
-
-            # TODO: if !overwrite:
-
-    def create_limited_sensor_vector_column(self, overwrite=True):
-        """
-        Create a vector column from the loaded data.
-
-        :param overwrite: Overwrite the original data with vector column-based data.
-        """
-        idx = self._create_vector_column_index()
-        # if overwrite:
-        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 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 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.file_index, start=0):
-            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):
-                out1 = os.path.join(group_folder, f"{file_prefix}_{group_idx}_TEST{test_idx}_01.csv")
-                cols_to_export = [0, 1] if self.include_time else [1]
-                df.iloc[:, cols_to_export].to_csv(out1, index=False)
-
-                out2 = os.path.join(group_folder, f"{file_prefix}_{group_idx}_TEST{test_idx}_02.csv")
-                cols_to_export = [0, 2] if self.include_time else [2]
-                df.iloc[:, cols_to_export].to_csv(out2, index=False)
-
-# def create_damage_files(base_path, output_base, prefix):
-#     # Initialize colorama
-#     init(autoreset=True)
-
-#     # Generate column labels based on expected duplication in input files
-#     columns = ["Real"] + [
-#         f"Real.{i}" for i in range(1, 30)
-#     ]  # Explicitly setting column names
-
-#     sensor_end_map = {
-#         1: "Real.25",
-#         2: "Real.26",
-#         3: "Real.27",
-#         4: "Real.28",
-#         5: "Real.29",
-#     }
-
-#     # Define the damage scenarios and the corresponding original file indices
-#     damage_scenarios = {
-#         1: range(1, 6),  # Damage 1 files from zzzAD1.csv to zzzAD5.csv
-#         2: range(6, 11),  # Damage 2 files from zzzAD6.csv to zzzAD10.csv
-#         3: range(11, 16),  # Damage 3 files from zzzAD11.csv to zzzAD15.csvs
-#         4: range(16, 21),  # Damage 4 files from zzzAD16.csv to zzzAD20.csv
-#         5: range(21, 26),  # Damage 5 files from zzzAD21.csv to zzzAD25.csv
-#         6: range(26, 31),  # Damage 6 files from zzzAD26.csv to zzzAD30.csv
-#     }
-#     damage_pad = len(str(len(damage_scenarios)))
-#     test_pad = len(str(30))
-
-#     for damage, files in damage_scenarios.items():
-#         for i, file_index in enumerate(files, start=1):
-#             # Load original data file
-#             file_path = os.path.join(base_path, f"zzz{prefix}D{file_index}.TXT")
-#             df = pd.read_csv(
-#                 file_path, sep="\t", skiprows=10
-#             )  # Read with explicit column names
-
-#             top_sensor = columns[i - 1]
-#             print(top_sensor, type(top_sensor))
-#             output_file_1 = os.path.join(
-#                 output_base, f"DAMAGE_{damage}", f"DAMAGE{damage}_TEST{i}_01.csv"
-#             )
-#             print(f"Creating {output_file_1} from taking zzz{prefix}D{file_index}.TXT")
-#             print("Taking datetime column on index 0...")
-#             print(f"Taking `{top_sensor}`...")
-#             os.makedirs(os.path.dirname(output_file_1), exist_ok=True)
-#             df[["Time", top_sensor]].to_csv(output_file_1, index=False)
-#             print(Fore.GREEN + "Done")
-
-#             bottom_sensor = sensor_end_map[i]
-#             output_file_2 = os.path.join(
-#                 output_base, f"DAMAGE_{damage}", f"DAMAGE{damage}_TEST{i}_02.csv"
-#             )
-#             print(f"Creating {output_file_2} from taking zzz{prefix}D{file_index}.TXT")
-#             print("Taking datetime column on index 0...")
-#             print(f"Taking `{bottom_sensor}`...")
-#             os.makedirs(os.path.dirname(output_file_2), exist_ok=True)
-#             df[["Time", bottom_sensor]].to_csv(output_file_2, index=False)
-#             print(Fore.GREEN + "Done")
-#             print("---")
-
-
-def main():
-    if len(sys.argv) < 2:
-        print("Usage: python convert.py <path_to_csv_files>")
-        sys.exit(1)
-
-    base_path = sys.argv[1]
-    output_base = sys.argv[2]
-    prefix = sys.argv[3]  # Define output directory
-
-    # Create output folders if they don't exist
-    # for i in range(1, 7):
-    #     os.makedirs(os.path.join(output_base, f'DAMAGE_{i}'), exist_ok=True)
-
-    create_damage_files(base_path, output_base, prefix)
-    print(Fore.YELLOW + Style.BRIGHT + "All files have been created successfully.")
-
-
-if __name__ == "__main__":
-    main()

code/src/ml/inference.py

@@ -1,190 +0,0 @@
-from joblib import load
-import pandas as pd
-from src.data_preprocessing import *
-from src.process_stft import compute_stft
-from typing import List, Tuple
-from sklearn.base import BaseEstimator
-import json
-
-def probability_damage(pred: Tuple[np.ndarray, np.ndarray], model_classes: BaseEstimator, percentage=False) -> Dict[str, int]:
-    """
-    Process the prediction output to return unique labels and their counts.
-    """
-    labels, counts = np.unique(pred, return_counts=True)
-    label_counts = dict(zip(labels, counts))
-
-    # init all models classes probability of damage with 0 in dictionary
-    pod: Dict[np.ndarray, int] = dict.fromkeys(model_classes.classes_, 0)
-
-    # update corresponding data
-    pod.update(label_counts)
-    
-    # turn the value into ratio instead of prediction counts
-    for label, count in pod.items():
-
-        ratio: float = count/np.sum(counts)
-
-        if percentage:
-            pod[label] = ratio * 100
-        else:
-            pod[label] = ratio
-    return pod
-
-def convert_keys_to_strings(obj):
-    """
-    Recursively convert all dictionary keys to strings.
-    """
-    if isinstance(obj, dict):
-        return {str(key): convert_keys_to_strings(value) for key, value in obj["data"].items()}
-    elif isinstance(obj, list):
-        return [convert_keys_to_strings(item) for item in obj["data"]]
-    else:
-        return obj
-
-def inference(model_sensor_A_path: str, model_sensor_B_path: str, file_path: str):
-
-    # Generate column indices
-    column_index: List[Tuple[int, int]] = [
-                                            (i + 1, i + 26) 
-                                            for i in range(5)
-                                          ]
-    # Load a single case data
-    df: pd.DataFrame = pd.read_csv(file_path, delim_whitespace=True, skiprows=10, header=0, memory_map=True)
-    # Take case name
-    case_name: str = file_path.split("/")[-1].split(".")[0]
-    # Extract relevant columns for each sensor
-    column_data: List[Tuple[pd.Series[float], pd.Series[float]]] = [
-                                                                        (df.iloc[:, i[0]], df.iloc[:, i[1]]) 
-                                                                        for i in column_index
-                                                                   ]
-
-    column_data_stft: List[Tuple[pd.DataFrame, pd.DataFrame]] = [
-                                                                    (compute_stft(sensor_A), compute_stft(sensor_B)) 
-                                                                    for (sensor_A, sensor_B) in column_data
-                                                                ]
-    
-    # Load the model
-    model_sensor_A = load(model_sensor_A_path)
-    model_sensor_B = load(model_sensor_B_path)
-
-    res = {}
-
-    for i, (stft_A, stft_B) in enumerate(column_data_stft):
-        # Make predictions using the model
-        pred_A: list[int] = model_sensor_A.predict(stft_A)
-        pred_B: list[int] = model_sensor_B.predict(stft_B)
-
-        
-        percentage_A = probability_damage(pred_A, model_sensor_A)
-        percentage_B = probability_damage(pred_B, model_sensor_B)
-        
-
-        res[f"Column_{i+1}"] = {
-            "Sensor_A": {
-                # "Predictions": pred_A,
-                "PoD": percentage_A
-            },
-            "Sensor_B": {
-                # "Predictions": pred_B,
-                "PoD": percentage_B
-            }
-        }
-    final_res = {"data": res, "case": case_name}
-    return final_res
-
-def heatmap(result, damage_classes: list[int] = [1, 2, 3, 4, 5, 6]):
-    from scipy.interpolate import RectBivariateSpline
-    resolution = 300
-    y = list(range(1, len(damage_classes)+1))
-
-    # length of column
-    x = list(range(len(result["data"])))
-
-    # X, Y = np.meshgrid(x, y)
-    Z = []
-    for _, column_data in result["data"].items():
-        sensor_a_pod = column_data['Sensor_A']['PoD']
-        Z.append([sensor_a_pod.get(cls, 0) for cls in damage_classes])
-    Z = np.array(Z).T
-
-    y2 = np.linspace(1, len(damage_classes), resolution)
-    x2 = np.linspace(0,4,resolution)
-    f = RectBivariateSpline(x, y, Z.T, kx=2, ky=2) # 2nd degree quadratic spline interpolation
-
-    Z2 = f(x2, y2).T.clip(0, 1) # clip to ignores negative values from cubic interpolation
-
-    X2, Y2 = np.meshgrid(x2, y2)
-    # breakpoint()
-    c = plt.pcolormesh(X2, Y2, Z2, cmap='jet', shading='auto')
-
-    # Add a colorbar
-    plt.colorbar(c, label='Probability of Damage (PoD)')
-    plt.gca().invert_xaxis()
-    plt.grid(True, linestyle='-', alpha=0.7)
-    plt.xticks(np.arange(int(X2.min()), int(X2.max())+1, 1))
-    plt.xlabel("Column Index")
-    plt.ylabel("Damage Index")
-    plt.title(result["case"])
-    # plt.xticks(ticks=x2, labels=[f'Col_{i+1}' for i in range(len(result))])
-    # plt.gca().xaxis.set_major_locator(MultipleLocator(65/4))
-    plt.show()
-    
-if __name__ == "__main__":
-    import matplotlib.pyplot as plt
-    import json
-    from scipy.interpolate import UnivariateSpline
-    
-
-    result = inference(
-        "D:/thesis/models/Sensor A/SVM with StandardScaler and PCA.joblib",
-        "D:/thesis/models/Sensor B/SVM with StandardScaler and PCA.joblib",
-        "D:/thesis/data/dataset_B/zzzBD19.TXT"
-    )
-
-    # heatmap(result)
-    # Convert all keys to strings before dumping to JSON
-    # result_with_string_keys = convert_keys_to_strings(result)
-    # print(json.dumps(result_with_string_keys, indent=4))
-
-    # Create a 5x2 subplot grid (5 rows for each column, 2 columns for sensors)
-    fig, axes = plt.subplots(nrows=5, ncols=2, figsize=(5, 50))
-    
-    # # Define damage class labels for x-axis
-    damage_classes = [1, 2, 3, 4, 5, 6]
-
-    # # Loop through each column in the data
-    for row_idx, (column_name, column_data) in enumerate(result['data'].items()):
-        # Plot Sensor A in the first column of subplots
-        sensor_a_pod = column_data['Sensor_A']['PoD']
-        x_values = list(range(len(damage_classes)))
-        y_values = [sensor_a_pod.get(cls, 0) for cls in damage_classes]
-
-        # x2 = np.linspace(1, 6, 100)
-        # interp = UnivariateSpline(x_values, y_values, s=0)
-        axes[row_idx, 0].plot(x_values, y_values, '-', linewidth=2, markersize=8)
-        axes[row_idx, 0].set_title(f"{column_name} - Sensor A", fontsize=10)
-        axes[row_idx, 0].set_xticks(x_values)
-        axes[row_idx, 0].set_xticklabels(damage_classes)
-        axes[row_idx, 0].set_ylim(0, 1.05)
-        axes[row_idx, 0].set_ylabel('Probability')
-        axes[row_idx, 0].set_xlabel('Damage Class')
-        axes[row_idx, 0].grid(True, linestyle='-', alpha=0.5)
-        
-        # Plot Sensor B in the second column of subplots
-        sensor_b_pod = column_data['Sensor_B']['PoD']
-        y_values = [sensor_b_pod.get(cls, 0) for cls in damage_classes]
-        axes[row_idx, 1].plot(x_values, y_values, '-', linewidth=2, markersize=8)
-        axes[row_idx, 1].set_title(f"{column_name} - Sensor B", fontsize=10)
-        axes[row_idx, 1].set_xticks(x_values)
-        axes[row_idx, 1].set_xticklabels(damage_classes)
-        axes[row_idx, 1].set_ylim(0, 1.05)
-        axes[row_idx, 1].set_ylabel('Probability')
-        axes[row_idx, 1].set_xlabel('Damage Class')
-        axes[row_idx, 1].grid(True, linestyle='-', alpha=0.5)
-    
-    # Adjust layout to prevent overlap
-    fig.tight_layout(rect=[0, 0, 1, 0.96])  # Leave space for suptitle
-    plt.subplots_adjust(hspace=1, wspace=0.3)  # Adjust spacing between subplots
-    plt.suptitle(f"Case {result['case']}", fontsize=16, y=0.98)  # Adjust suptitle position
-    plt.show()
-    

code/src/ml/model_selection.py

@@ -1,14 +1,13 @@
 import numpy as np
 import pandas as pd
 import os
-import matplotlib.pyplot as plt
+from sklearn.model_selection import train_test_split as sklearn_split
-from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
+
-from joblib import load
 
 def create_ready_data(
     stft_data_path: str,
     stratify: np.ndarray = None,
-) -> tuple[pd.DataFrame, np.ndarray]:
+) -> tuple:
     """
     Create a stratified train-test split from STFT data.
 
@@ -22,13 +21,13 @@ def create_ready_data(
     Returns:
     --------
     tuple
-        (pd.DataFrame, np.ndarray) - Combined data and corresponding labels
+        (X_train, X_test, y_train, y_test) - Split datasets
     """
     ready_data = []
     for file in os.listdir(stft_data_path):
-        ready_data.append(pd.read_csv(os.path.join(stft_data_path, file), skiprows=1))
+        ready_data.append(pd.read_csv(os.path.join(stft_data_path, file)))
 
-    y_data = [i for i in range(len(ready_data))] # TODO: Should be replaced with actual desired labels
+    y_data = [i for i in range(len(ready_data))]
 
     # Combine all dataframes in ready_data into a single dataframe
     if ready_data:  # Check if the list is not empty
@@ -56,216 +55,3 @@ def create_ready_data(
         y = np.array([])
 
     return X, y
-
-
-def train_and_evaluate_model(
-    model, model_name, sensor_label, x_train, y_train, x_test, y_test, export=None
-):
-    """
-    Train a machine learning model, evaluate its performance, and optionally export it.
-
-    This function trains the provided model on the training data, evaluates its
-    performance on test data using accuracy score, and can save the trained model
-    to disk if an export path is provided.
-
-    Parameters
-    ----------
-    model : estimator object
-        The machine learning model to train.
-    model_name : str
-        Name of the model, used for the export filename and in the returned results.
-    sensor_label : str
-        Label identifying which sensor's data the model is being trained on.
-    x_train : array-like or pandas.DataFrame
-        The training input samples.
-    y_train : array-like
-        The target values for training.
-    x_test : array-like or pandas.DataFrame
-        The test input samples.
-    y_test : array-like
-        The target values for testing.
-    export : str, optional
-        Directory path where the trained model should be saved. If None, model won't be saved.
-
-    Returns
-    -------
-    dict
-        Dictionary containing:
-        - 'model': model_name (str)
-        - 'sensor': sensor_label (str)
-        - 'accuracy': accuracy percentage (float)
-
-    Example
-    -------
-    >>> from sklearn.svm import SVC
-    >>> from sklearn.model_selection import train_test_split
-    >>> X_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2)
-    >>> result = train_and_evaluate_model(
-    ...     SVC(),
-    ...     "SVM",
-    ...     "sensor1",
-    ...     X_train,
-    ...     y_train,
-    ...     X_test,
-    ...     y_test,
-    ...     export="models/sensor1"
-    ... )
-    >>> print(f"Model accuracy: {result['accuracy']:.2f}%")
-    """
-    from sklearn.metrics import accuracy_score
-
-    result = {"model": model_name, "sensor": sensor_label, "success": False}
-
-    try:
-        import time
-        start_time = time.time()
-
-        # Train the model
-        model.fit(x_train, y_train)
-
-        result["elapsed_time_training"] = time.time() - start_time
-        try:
-            # Predict on the test set (validation)
-            start_time = time.time()
-    
-            y_pred = model.predict(x_test)
-
-            result["elapsed_time_validation"] = time.time() - start_time
-            result["y_pred"] = y_pred  # Convert to numpy array
-        except Exception as e:
-            result["error"] = f"Prediction error: {str(e)}"
-            return result
-
-        # Calculate accuracy
-        try:
-            accuracy = accuracy_score(y_test, y_pred) * 100
-            result["accuracy"] = accuracy
-        except Exception as e:
-            result["error"] = f"Accuracy calculation error: {str(e)}"
-            return result
-
-        # Export model if requested
-        if export:
-            try:
-                import joblib
-
-                full_path = os.path.join(export, f"{model_name}.joblib")
-                os.makedirs(os.path.dirname(full_path), exist_ok=True)
-                joblib.dump(model, full_path)
-                print(f"Model saved to {full_path}")
-            except Exception as e:
-                print(f"Warning: Failed to export model to {export}: {str(e)}")
-                result["export_error"] = str(e)
-                # Continue despite export error
-
-        result["success"] = True
-        return result
-
-    except Exception as e:
-        result["error"] = f"Training error: {str(e)}"
-        return result
-def plot_confusion_matrix(results_sensor, y_test, title):
-    """
-    Plot confusion matrices for each model in results_sensor1.
-
-    Parameters:
-    -----------
-    results_sensor1 : list
-        List of dictionaries containing model results.
-    x_test1 : array-like
-        Test input samples.
-    y_test : array-like
-        True labels for the test samples.
-
-    Returns:
-    --------
-    None
-    This function will display confusion matrices for each model in results_sensor1.
-
-    Example
-    -------
-    >>> results_sensor1 = [
-    ...     {'model': 'model1', 'accuracy': 95.0},
-    ...     {'model': 'model2', 'accuracy': 90.0}
-    ... ]
-    >>> x_test1 = np.random.rand(100, 10)  # Example test data
-    >>> y_test = np.random.randint(0, 2, size=100)  # Example true labels
-    >>> plot_confusion_matrix(results_sensor1, x_test1, y_test)
-    """
-    # Iterate through each model result and plot confusion matrix
-    for i in results_sensor:
-        model = load(f"D:/thesis/models/{i['sensor']}/{i['model']}.joblib")
-        cm = confusion_matrix(y_test, i['y_pred']) # -> ndarray
-
-        # get the class labels
-        labels = model.classes_
-        # Plot
-        disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)
-        disp.plot(cmap=plt.cm.Blues)  # You can change colormap
-        plt.title(f"{title}")
-
-def calculate_label_percentages(labels):
-    """
-    Calculate and print the percentage distribution of unique labels in a numpy array.
-
-    Parameters:
-        labels (np.array): Input array of labels.
-
-    Returns:
-        None
-    """
-    # Count occurrences of each unique label
-    unique, counts = np.unique(labels, return_counts=True)
-
-    # Calculate percentages
-    percentages = (counts / len(labels)) * 100
-
-    # Build and print the result string
-    result = "\n".join([f"Label {label}: {percentage:.2f}%" for label, percentage in zip(unique, percentages)])
-    return print(result)
-
-def inference_model(
-    models, raw_file, column_question: int = None
-):
-    """
-    Perform inference using a trained machine learning model on a raw vibration data file with questioned column grid.
-
-    Parameters
-    ----------
-    model : dict with some exported model path
-        The trained machine learning model to use for inference.
-    x_test : array-like or pandas.DataFrame
-        The input samples for which predictions are to be made.
-    export : str, optional
-        Directory path where the predictions should be saved. If None, predictions won't be saved.
-
-    Returns
-    -------
-    np.ndarray
-        Array of predicted values.
-
-    Example
-    -------
-    >>> from sklearn.svm import SVC
-    >>> model = {"SVM": "models/sensor1/SVM.joblib", "SVM with PCA": "models/sensor1/SVM_with_PCA.joblib"}
-    >>> inference_model(model["SVM"], "zzzAD1.TXT", column_question=1)
-    """
-    df = pd.read_csv(raw_file, delim_whitespace=True, skiprows=10, header=0, memory_map=True)
-    col_idx = []
-    for i in range(1,6):
-        idx = [i, i+5, i+10, i+15, i+20, i+25]
-        col_idx.append(idx)
-    vibration_data = df.iloc[:, column_question].values
-    # Perform STFT
-    from scipy.signal import stft, hann
-    freq, times, Zxx = stft(
-                            vibration_data, 
-                            fs=1024, 
-                            window=hann(1024), 
-                            nperseg=1024, 
-                            noverlap=1024-512
-                            )
-    data = pd.DataFrame(np.abs(Zxx).T, columns=[f"Freq_{freq:.2f}" for freq in np.linspace(0, 1024/2, Zxx.shape[1])])
-    data = data.rename(columns={"Freq_0.00": "00"}) # To match the model input format
-    model = load(models)  # Load the model from the provided path
-    return calculate_label_percentages(model.predict(data.iloc[:21,:]))

code/src/process_stft.py

@@ -1,11 +1,9 @@
 import os
 import pandas as pd
 import numpy as np
-from scipy.signal import stft
+from scipy.signal import stft, hann
-from scipy.signal.windows import hann
 import glob
 import multiprocessing  # Added import for multiprocessing
-from typing import Union, Tuple
 
 # Define the base directory where DAMAGE_X folders are located
 damage_base_path = 'D:/thesis/data/converted/raw'
@@ -21,65 +19,32 @@ for dir_path in output_dirs.values():
     os.makedirs(dir_path, exist_ok=True)
 
 # Define STFT parameters
+window_size = 1024
+hop_size = 512
+window = hann(window_size)
+Fs = 1024
 
 # Number of damage cases (adjust as needed)
 num_damage_cases = 6  # Change to 30 if you have 30 damage cases
 
+# Number of test runs per damage case
+num_test_runs = 5
+
 # Function to perform STFT and return magnitude
-def compute_stft(vibration_data: np.ndarray, return_param: bool = False) -> Union[pd.DataFrame, Tuple[pd.DataFrame, list[int, int, int]]]:
+def compute_stft(vibration_data):
-    """
-    Computes the Short-Time Fourier Transform (STFT) magnitude of the input vibration data.
-
-    Parameters
-    ----------
-    vibration_data : numpy.ndarray
-        The input vibration data as a 1D NumPy array.
-    return_param : bool, optional
-        If True, the function returns additional STFT parameters (window size, hop size, and sampling frequency).
-        Defaults to False.
-
-    Returns
-    -------
-    pd.DataFrame
-        The transposed STFT magnitude, with frequencies as columns, if `return_param` is False.
-    tuple
-        If `return_param` is True, returns a tuple containing:
-        - pd.DataFrame: The transposed STFT magnitude, with frequencies as columns.
-        - list[int, int, int]: A list of STFT parameters [window_size, hop_size, Fs].
-    """
-        
-    window_size = 1024
-    hop_size = 512
-    window = hann(window_size)
-    Fs = 1024
-
     frequencies, times, Zxx = stft(
-                                    vibration_data, 
+        vibration_data, 
-                                    fs=Fs, 
+        fs=Fs, 
-                                    window=window, 
+        window=window, 
-                                    nperseg=window_size, 
+        nperseg=window_size, 
-                                    noverlap=window_size - hop_size
+        noverlap=window_size - hop_size
-                                )
-    stft_magnitude = np.abs(Zxx)
-
-    # Convert STFT result to DataFrame
-    df_stft = pd.DataFrame(
-        stft_magnitude.T, 
-        columns=[f"Freq_{freq:.2f}" for freq in np.linspace(0, Fs/2, stft_magnitude.shape[1])]
     )
-    # breakpoint()
+    stft_magnitude = np.abs(Zxx)
-    if return_param:
+    return stft_magnitude.T  # Transpose to have frequencies as columns
-        return df_stft, [window_size, hop_size, Fs]
-    else:
-        return df_stft
 
 def process_damage_case(damage_num):
     damage_folder = os.path.join(damage_base_path, f'DAMAGE_{damage_num}')
-    if damage_num == 0:
+    
-        # Number of test runs per damage case
-        num_test_runs = 120
-    else:
-        num_test_runs = 5
     # Check if the damage folder exists
     if not os.path.isdir(damage_folder):
         print(f"Folder {damage_folder} does not exist. Skipping...")
@@ -114,24 +79,20 @@ def process_damage_case(damage_num):
                 print(f"Unexpected number of columns in {file_path}. Expected 2, got {df.shape[1]}. Skipping...")
                 continue
             
+            # Extract vibration data (assuming the second column is sensor data)
             vibration_data = df.iloc[:, 1].values
             
             # Perform STFT
-            df_stft = compute_stft(vibration_data)
+            stft_magnitude = compute_stft(vibration_data)
-
+            
-            # only inlcude 21 samples vector features for first 45 num_test_runs else include 22 samples vector features
+            # Convert STFT result to DataFrame
-            if damage_num == 0:
+            df_stft = pd.DataFrame(
-                print(f"Processing damage_num = 0, test_num = {test_num}")
+                stft_magnitude, 
-                if test_num <= 45:
+                columns=[f"Freq_{freq:.2f}" for freq in np.linspace(0, Fs/2, stft_magnitude.shape[1])]
-                    df_stft = df_stft.iloc[:22, :]
+            )
-                    print(f"Reduced df_stft shape (21 samples): {df_stft.shape}")
-                else:
-                    df_stft = df_stft.iloc[:21, :]
-                    print(f"Reduced df_stft shape (22 samples): {df_stft.shape}")
             
             # Append to the aggregated list
             aggregated_stft.append(df_stft)
-            print(sum(df.shape[0] for df in aggregated_stft))
         
         # Concatenate all STFT DataFrames vertically
         if aggregated_stft:
@@ -144,13 +105,11 @@ def process_damage_case(damage_num):
             )
             
             # Save the aggregated STFT to CSV
-            with open(output_file, 'w') as file:
+            df_aggregated.to_csv(output_file, index=False)
-                file.write('sep=,\n')
-                df_aggregated.to_csv(file, index=False)
             print(f"Saved aggregated STFT for Sensor {sensor_num}, Damage {damage_num} to {output_file}")
         else:
             print(f"No STFT data aggregated for Sensor {sensor_num}, Damage {damage_num}.")
 
 if __name__ == "__main__":  # Added main guard for multiprocessing
     with multiprocessing.Pool() as pool:
-        pool.map(process_damage_case, range(num_damage_cases + 1))
+        pool.map(process_damage_case, range(1, num_damage_cases + 1))

data/QUGS/convert.py

@@ -0,0 +1,360 @@
+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
+from pprint import pprint
+
+# class DamageFilesIndices(TypedDict):
+#     damage_index: int
+#     files: list[int]
+OriginalSingleDamageScenarioFilePath = str
+DamageScenarioGroupIndex = int
+OriginalSingleDamageScenario = pd.DataFrame
+SensorIndex = int
+VectorColumnIndex = List[SensorIndex]
+VectorColumnIndices = List[VectorColumnIndex]
+DamageScenarioGroup = List[OriginalSingleDamageScenario]
+GroupDataset = List[DamageScenarioGroup]
+
+
+class DamageFilesIndices(TypedDict):
+    damage_index: int
+    files: List[str]
+
+
+def generate_damage_files_index(**kwargs) -> DamageFilesIndices:
+    prefix: str = kwargs.get("prefix", "zzzAD")
+    extension: str = kwargs.get("extension", ".TXT")
+    num_damage: int = kwargs.get("num_damage")
+    file_index_start: int = kwargs.get("file_index_start")
+    col: int = kwargs.get("col")
+    base_path: str = kwargs.get("base_path")
+
+    damage_scenarios = {}
+    a = file_index_start
+    b = col + 1
+    for i in range(1, num_damage + 1):
+        damage_scenarios[i] = range(a, b)
+        a += col
+        b += col
+
+    # return damage_scenarios
+
+    x = {}
+    for damage, files in damage_scenarios.items():
+        x[damage] = []  # Initialize each key with an empty list
+        for i, file_index in enumerate(files, start=1):
+            if base_path:
+                x[damage].append(
+                    os.path.normpath(
+                        os.path.join(base_path, f"{prefix}{file_index}{extension}")
+                    )
+                )
+                # if not os.path.exists(file_path):
+                #     print(Fore.RED + f"File {file_path} does not exist.")
+                #     continue
+            else:
+                x[damage].append(f"{prefix}{file_index}{extension}")
+    return x
+
+    # file_path = os.path.join(base_path, f"zzz{prefix}D{file_index}.TXT")
+    # df = pd.read_csv( file_path, sep="\t", skiprows=10)  # Read with explicit column names
+
+
+class DataProcessor:
+    def __init__(self, file_index: DamageFilesIndices, cache_path: str = None):
+        self.file_index = file_index
+        if cache_path:
+            self.data = load(cache_path)
+        else:
+            self.data = self._load_all_data()
+
+    def _extract_column_names(self, file_path: str) -> List[str]:
+        """
+        Extracts column names from the header of the given file.
+        Assumes the 6th line contains column names.
+
+        :param file_path: Path to the data file.
+        :return: List of column names.
+        """
+        with open(file_path, "r") as f:
+            header_lines = [next(f) for _ in range(12)]
+
+        # Extract column names from the 6th line
+        channel_line = header_lines[10].strip()
+        tokens = re.findall(r'"([^"]+)"', channel_line)
+        if not channel_line.startswith('"'):
+            first_token = channel_line.split()[0]
+            tokens = [first_token] + tokens
+
+        return tokens  # Prepend 'Time' column if applicable
+
+    def _load_dataframe(self, file_path: str) -> OriginalSingleDamageScenario:
+        """
+        Loads a single data file into a pandas DataFrame.
+
+        :param file_path: Path to the data file.
+        :return: DataFrame containing the numerical data.
+        """
+        col_names = self._extract_column_names(file_path)
+        df = pd.read_csv(
+            file_path, delim_whitespace=True, skiprows=11, header=None, memory_map=True
+        )
+        df.columns = col_names
+        return df
+
+    def _load_all_data(self) -> GroupDataset:
+        """
+        Loads all data files based on the grouping dictionary and returns a nested list.
+
+        :return: A nested list of DataFrames where the outer index corresponds to group_idx - 1.
+        """
+        data = []
+        # Find the maximum group index to determine the list size
+        max_group_idx = max(self.file_index.keys()) if self.file_index else 0
+
+        # Initialize empty lists
+        for _ in range(max_group_idx):
+            data.append([])
+
+        # Fill the list with data
+        for group_idx, file_list in self.file_index.items():
+            # Adjust index to be 0-based
+            list_idx = group_idx - 1
+            data[list_idx] = [self._load_dataframe(file) for file in file_list]
+
+        return data
+
+    def get_group_data(self, group_idx: int) -> List[pd.DataFrame]:
+        """
+        Returns the list of DataFrames for the given group index.
+
+        :param group_idx: Index of the group.
+        :return: List of DataFrames.
+        """
+        return self.data.get([group_idx, []])
+
+    def get_column_names(self, group_idx: int, file_idx: int = 0) -> List[str]:
+        """
+        Returns the column names for the given group and file indices.
+
+        :param group_idx: Index of the group.
+        :param file_idx: Index of the file in the group.
+        :return: List of column names.
+        """
+        if group_idx in self.data and len(self.data[group_idx]) > file_idx:
+            return self.data[group_idx][file_idx].columns.tolist()
+        return []
+
+    def get_data_info(self):
+        """
+        Print information about the loaded data structure.
+        Adapted for when self.data is a List instead of a Dictionary.
+        """
+        if isinstance(self.data, list):
+            # For each sublist in self.data, get the type names of all elements
+            pprint(
+                [
+                    (
+                        [type(item).__name__ for item in sublist]
+                        if isinstance(sublist, list)
+                        else type(sublist).__name__
+                    )
+                    for sublist in self.data
+                ]
+            )
+        else:
+            pprint(
+                {
+                    key: [type(df).__name__ for df in value]
+                    for key, value in self.data.items()
+                }
+                if isinstance(self.data, dict)
+                else type(self.data).__name__
+            )
+
+    def _create_vector_column_index(self) -> VectorColumnIndices:
+        vector_col_idx: VectorColumnIndices = []
+        y = 0
+        for data_group in self.data:  # len(data_group[i]) = 5
+            for j in data_group:  # len(j[i]) =
+                c: VectorColumnIndex = []  # column vector c_{j}
+                x = 0
+                for _ in range(6):  # TODO: range(6) should be dynamic and parameterized
+                    c.append(x + y)
+                    x += 5
+                vector_col_idx.append(c)
+                y += 1
+            return vector_col_idx
+
+    def create_vector_column(self, overwrite=True) -> List[List[List[pd.DataFrame]]]:
+        """
+        Create a vector column from the loaded data.
+
+        :param overwrite: Overwrite the original data with vector column-based data.
+        """
+        idx = self._create_vector_column_index()
+        # if overwrite:
+        for i in range(len(self.data)):
+            for j in range(len(self.data[i])):
+                # 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
+                real_indices = [index + 1 for index in indices]
+
+                # Create list with Time column index (0) and the adjusted Real indices
+                all_indices = [0] + real_indices
+
+                # Apply the slicing
+                self.data[i][j] = df.iloc[:, all_indices]
+        # TODO: if !overwrite:
+
+    def create_limited_sensor_vector_column(self, overwrite=True):
+        """
+        Create a vector column from the loaded data.
+
+        :param overwrite: Overwrite the original data with vector column-based data.
+        """
+        idx = self._create_vector_column_index()
+        # if overwrite:
+        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 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 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
+    init(autoreset=True)
+
+    # Generate column labels based on expected duplication in input files
+    columns = ["Real"] + [
+        f"Real.{i}" for i in range(1, 30)
+    ]  # Explicitly setting column names
+
+    sensor_end_map = {
+        1: "Real.25",
+        2: "Real.26",
+        3: "Real.27",
+        4: "Real.28",
+        5: "Real.29",
+    }
+
+    # Define the damage scenarios and the corresponding original file indices
+    damage_scenarios = {
+        1: range(1, 6),  # Damage 1 files from zzzAD1.csv to zzzAD5.csv
+        2: range(6, 11),  # Damage 2 files from zzzAD6.csv to zzzAD10.csv
+        3: range(11, 16),  # Damage 3 files from zzzAD11.csv to zzzAD15.csvs
+        4: range(16, 21),  # Damage 4 files from zzzAD16.csv to zzzAD20.csv
+        5: range(21, 26),  # Damage 5 files from zzzAD21.csv to zzzAD25.csv
+        6: range(26, 31),  # Damage 6 files from zzzAD26.csv to zzzAD30.csv
+    }
+    damage_pad = len(str(len(damage_scenarios)))
+    test_pad = len(str(30))
+
+    for damage, files in damage_scenarios.items():
+        for i, file_index in enumerate(files, start=1):
+            # Load original data file
+            file_path = os.path.join(base_path, f"zzz{prefix}D{file_index}.TXT")
+            df = pd.read_csv(
+                file_path, sep="\t", skiprows=10
+            )  # Read with explicit column names
+
+            top_sensor = columns[i - 1]
+            print(top_sensor, type(top_sensor))
+            output_file_1 = os.path.join(
+                output_base, f"DAMAGE_{damage}", f"DAMAGE{damage}_TEST{i}_01.csv"
+            )
+            print(f"Creating {output_file_1} from taking zzz{prefix}D{file_index}.TXT")
+            print("Taking datetime column on index 0...")
+            print(f"Taking `{top_sensor}`...")
+            os.makedirs(os.path.dirname(output_file_1), exist_ok=True)
+            df[["Time", top_sensor]].to_csv(output_file_1, index=False)
+            print(Fore.GREEN + "Done")
+
+            bottom_sensor = sensor_end_map[i]
+            output_file_2 = os.path.join(
+                output_base, f"DAMAGE_{damage}", f"DAMAGE{damage}_TEST{i}_02.csv"
+            )
+            print(f"Creating {output_file_2} from taking zzz{prefix}D{file_index}.TXT")
+            print("Taking datetime column on index 0...")
+            print(f"Taking `{bottom_sensor}`...")
+            os.makedirs(os.path.dirname(output_file_2), exist_ok=True)
+            df[["Time", bottom_sensor]].to_csv(output_file_2, index=False)
+            print(Fore.GREEN + "Done")
+            print("---")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python convert.py <path_to_csv_files>")
+        sys.exit(1)
+
+    base_path = sys.argv[1]
+    output_base = sys.argv[2]
+    prefix = sys.argv[3]  # Define output directory
+
+    # Create output folders if they don't exist
+    # for i in range(1, 7):
+    #     os.makedirs(os.path.join(output_base, f'DAMAGE_{i}'), exist_ok=True)
+
+    create_damage_files(base_path, output_base, prefix)
+    print(Fore.YELLOW + Style.BRIGHT + "All files have been created successfully.")
+
+
+if __name__ == "__main__":
+    main()

data/QUGS/test.py

@@ -1,52 +1,25 @@
-from data_preprocessing import *
+from convert import *
 from joblib import dump, load
 
-# b = generate_damage_files_index(
-#     num_damage=6,
-#     file_index_start=1,
-#     col=5,
-#     base_path="D:/thesis/data/dataset_B",
-#     prefix="zzzBD",
-#     # undamage_file="zzzBU.TXT"
-# )
-# Example: Generate tuples with a special group of df0 at the beginning
-special_groups_A = [
-    {'df_name': 'zzzAU.TXT', 'position': 0, 'size': 5}  # Add at beginning
-]
-
-special_groups_B = [
-    {'df_name': 'zzzBU.TXT', 'position': 0, 'size': 5}  # Add at beginning
-]
-
-# Generate the tuples with the special group
-a_complement = [(comp)
-                for n in range(1, 31)
-                for comp in complement_pairs(n)]
-a = generate_df_tuples(special_groups=a_complement, prefix="zzzAD")
-
-# b_complement = [(comp)
-#                 for n in range(1, 31)
-#                 for comp in complement_pairs(n)]
-# b = generate_df_tuples(special_groups=b_complement, prefix="zzzBD")
-
-
 # a = generate_damage_files_index(
-#     num_damage=6,
+#     num_damage=6, file_index_start=1, col=5, base_path="D:/thesis/data/dataset_A"
-#     file_index_start=1,
-#     col=5,
-#     base_path="D:/thesis/data/dataset_A",
-#     prefix="zzzAD",
-#     # undamage_file="zzzBU.TXT"
 # )
 
-data_A = DataProcessor(file_index=a, base_path="D:/thesis/data/dataset_A", include_time=True)
+b = generate_damage_files_index(
-# data_A.create_vector_column(overwrite=True)
+    num_damage=6,
-# # data_A.create_limited_sensor_vector_column(overwrite=True)
+    file_index_start=1,
-data_A.export_to_csv("D:/thesis/data/converted/raw")
+    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, base_path="D:/thesis/data/dataset_B", include_time=True)
+data_B = DataProcessor(file_index=b)
-# data_B.create_vector_column(overwrite=True)
+# data.create_vector_column(overwrite=True)
-# # data_B.create_limited_sensor_vector_column(overwrite=True)
+data_B.create_limited_sensor_vector_column(overwrite=True)
-# data_B.export_to_csv("D:/thesis/data/converted/raw_B")
+data_B.export_to_csv("D:/thesis/data/converted/raw_B")
 # a = load("D:/cache.joblib")
-# breakpoint()
+# breakpoint()

latex/bahasa-apa.lbx

@@ -1,373 +0,0 @@
-\ProvidesFile{bahasa-apa.lbx}[2023/03/20\space v9.17\space APA biblatex localisation]
-\InheritBibliographyExtras{bahasa}
-
-\NewBibliographyString{publication}
-\NewBibliographyString{jourarticle}
-\NewBibliographyString{revisededition}
-\NewBibliographyString{typevolume}
-\NewBibliographyString{typevolumes}
-\NewBibliographyString{typeseries}
-\NewBibliographyString{typeseriess}
-\NewBibliographyString{typevolseries}
-\NewBibliographyString{typevolseriess}
-\NewBibliographyString{chair}
-\NewBibliographyString{chairs}
-\NewBibliographyString{on}
-\NewBibliographyString{retrieved}
-\NewBibliographyString{available}
-\NewBibliographyString{from}
-\NewBibliographyString{archivedat}
-\NewBibliographyString{origyear}
-\NewBibliographyString{reviewof}
-\NewBibliographyString{with}
-\NewBibliographyString{supplement}
-\NewBibliographyString{commenton}
-\NewBibliographyString{manunpub}
-\NewBibliographyString{maninprep}
-\NewBibliographyString{mansub}
-\NewBibliographyString{producer}
-\NewBibliographyString{producers}
-\NewBibliographyString{execproducer}
-\NewBibliographyString{execproducers}
-\NewBibliographyString{director}
-\NewBibliographyString{directors}
-\NewBibliographyString{execdirector}
-\NewBibliographyString{execdirectors}
-\NewBibliographyString{writer}
-\NewBibliographyString{writers}
-\NewBibliographyString{host}
-\NewBibliographyString{hosts}
-\NewBibliographyString{guestexpert}
-\NewBibliographyString{guestexperts}
-\NewBibliographyString{narrator}
-\NewBibliographyString{narrators}
-\NewBibliographyString{film}
-\NewBibliographyString{tvseries}
-\NewBibliographyString{tvepisode}
-\NewBibliographyString{video}
-\NewBibliographyString{song}
-\NewBibliographyString{album}
-\NewBibliographyString{podcast}
-\NewBibliographyString{podcastepisode}
-\NewBibliographyString{interview}
-\NewBibliographyString{speech}
-\NewBibliographyString{lithograph}
-\NewBibliographyString{map}
-\NewBibliographyString{lecturenotes}
-\NewBibliographyString{powerpoint}
-\NewBibliographyString{photograph}
-\NewBibliographyString{photographs}
-\NewBibliographyString{present}
-\NewBibliographyString{painting}
-\NewBibliographyString{article}
-\NewBibliographyString{execorder}
-\NewBibliographyString{senate}
-\NewBibliographyString{resolution}
-\NewBibliographyString{houseofrepresentatives}
-\NewBibliographyString{report}
-\NewBibliographyString{us}
-\NewBibliographyString{southcarolina}
-\NewBibliographyString{constitution}
-\NewBibliographyString{section}
-\NewBibliographyString{amendment}
-\NewBibliographyString{proposed}
-\NewBibliographyString{repealed}
-\NewBibliographyString{unitednations}
-\NewBibliographyString{charter}
-\NewBibliographyString{ofthe}
-\NewBibliographyString{tothe}
-\NewBibliographyString{alabama}
-\NewBibliographyString{alaska}
-\NewBibliographyString{arizona}
-\NewBibliographyString{arkansas}
-\NewBibliographyString{california}
-\NewBibliographyString{colorado}
-\NewBibliographyString{connecticut}
-\NewBibliographyString{delaware}
-\NewBibliographyString{florida}
-\NewBibliographyString{georgia}
-\NewBibliographyString{hawaii}
-\NewBibliographyString{idaho}
-\NewBibliographyString{illinois}
-\NewBibliographyString{indiana}
-\NewBibliographyString{iowa}
-\NewBibliographyString{kansas}
-\NewBibliographyString{kentucky}
-\NewBibliographyString{louisiana}
-\NewBibliographyString{maine}
-\NewBibliographyString{maryland}
-\NewBibliographyString{massachusetts}
-\NewBibliographyString{michigan}
-\NewBibliographyString{minnesota}
-\NewBibliographyString{mississippi}
-\NewBibliographyString{missouri}
-\NewBibliographyString{montana}
-\NewBibliographyString{nebraska}
-\NewBibliographyString{nevada}
-\NewBibliographyString{newhampshire}
-\NewBibliographyString{newjersey}
-\NewBibliographyString{newmexico}
-\NewBibliographyString{newyork}
-\NewBibliographyString{northcarolina}
-\NewBibliographyString{northdakota}
-\NewBibliographyString{ohio}
-\NewBibliographyString{oklahoma}
-\NewBibliographyString{oregon}
-\NewBibliographyString{pennsylvania}
-\NewBibliographyString{rhodeisland}
-\NewBibliographyString{southcarolina}
-\NewBibliographyString{southdakota}
-\NewBibliographyString{tennessee}
-\NewBibliographyString{texas}
-\NewBibliographyString{utah}
-\NewBibliographyString{vermont}
-\NewBibliographyString{virginia}
-\NewBibliographyString{washington}
-\NewBibliographyString{westvirginia}
-\NewBibliographyString{wisconsin}
-\NewBibliographyString{wyoming}
-
-\DeclareBibliographyStrings{%
-  inherit          = {bahasa},
-  jourarticle      = {{artikel}{artikel}},
-  ofthe            = {{dari}{dari}},
-  tothe            = {{ke}{ke}},
-  unitednations    = {{Perserikatan Bangsa-Bangsa}{P\adddot B\adddot B\adddot}},
-  charter          = {{piagam}{piagam}},
-  proposed         = {{diusulkan}{diusulkan}},
-  repealed         = {{dicabut pada}{dicabut}},
-  execorder        = {{Perintah Eksekutif}{Per\adddot\ Eksekutif}},
-  senate           = {{Senate}{S\adddot}},
-  resolution       = {{Resolusi}{Res\adddot}},
-  houseofrepresentatives = {{House\space of\space Representatives}{H\adddot R\adddot}},
-  report           = {{Laporan}{Lap\adddot}},
-  us               = {{A\adddot S\adddot}{A\adddot S\adddot}},
-  southcarolina    = {{South\space Carolina}{S\adddot C\adddot}},
-  constitution     = {{Constitution}{Const\adddot}},
-  section          = {{Bagian}{§}},
-  amendment        = {{amendemen}{amend\adddot}},
-  article          = {{pasal}{ps\adddot}},
-  painting         = {{lukisan}{lukisan}},
-  present          = {{saat ini}{saat ini}},
-  song             = {{lagu}{lagu}},
-  album            = {{album}{album}},
-  map              = {{peta}{peta}},
-  photograph       = {{foto}{foto}},
-  photographs      = {{foto}{foto}},
-  powerpoint       = {{Salindia Powerpoint}{Salindia Powerpoint}},
-  lecturenotes     = {{catatan kuliah}{catatan kuliah}},
-  podcast          = {{siniar audio}{siniar audio}},
-  podcastepisode   = {{episode siniar audio}{episode siniar audio}},
-  interview        = {{wawancara}{wawancara}},
-  speech           = {{rekaman audio pidato}{rekaman audio pidato}},
-  lithograph       = {{litograf}{litograf}},
-  video            = {{video}{video}},
-  film             = {{film}{film}},
-  tvseries         = {{serial TV}{serial TV}},
-  tvepisode        = {{episode serial TV}{episode serial TV}},
-  manunpub         = {{naskah tidak diterbitkan}{naskah tidak diterbitkan}},
-  maninprep        = {{naskah dalam persiapan}{naskah dalam persiapan}},
-  mansub           = {{naskah diserahkan untuk publikasi}{naskah diserahkan untuk publikasi}},
-  supplement       = {{suplemen}{supl\adddot}},
-  revisededition   = {{Edisi Revisi}{Ed\adddot\ Rev\adddot}},
-  reviewof         = {{tinjauan atas}{tinjauan atas}},
-  page             = {{Halaman}{hlm\adddot}},
-  pages            = {{Halaman}{hlm\adddot}},
-  on               = {{pada}{pada}},
-  retrieved        = {{Diakses}{Diakses}},
-  available        = {{Tersedia}{Tersedia}},
-  from             = {{dari}{dari}},
-  archivedat       = {{Diarsipkan di}{Diarsipkan di}},
-  with             = {{dengan}{dengan}},
-  reprintas        = {{dicetak ulang sebagai}{dicetak ulang sbg\adddot}},
-  reprintfrom      = {{dicetak ulang dari}{dicetak ulang dari}},
-  commenton        = {{komentar pada}{komentar pada}},
-  part             = {{bagian}{bag\adddot}},
-  paragraph        = {{Paragraf}{par\adddot}},
-  paragraphs       = {{Paragraf}{par\adddot}},
-  narrator         = {{narator}{nar\adddot}},
-  narrators        = {{narator}{nar\adddot}},
-  producer         = {{produser}{produser}},
-  producers        = {{produser}{produser}},
-  execproducer     = {{Produser Eksekutif}{Prod\adddot\ Eks\adddot}},
-  execproducers    = {{Produser Eksekutif}{Prod\adddot\ Eks\adddot}},
-  execdirector     = {{Direktur Eksekutif}{Dir\adddot\ Eks\adddot}},
-  execdirectors    = {{Direktur Eksekutif}{Dir\adddot\ Eks\adddot}},
-  chair            = {{Ketua}{Ketua}},
-  chairs           = {{Ketua}{Ketua}},
-  director         = {{sutradara}{sut\adddot}},
-  directors        = {{sutradara}{sut\adddot}},
-  writer           = {{penulis}{penulis}},
-  writers          = {{penulis}{penulis}},
-  host             = {{pembawa acara}{pembawa acara}},
-  hosts            = {{pembawa acara}{pembawa acara}},
-  guestexpert      = {{Pakar Tamu}{Pakar Tamu}},
-  guestexperts     = {{Pakar Tamu}{Pakar Tamu}},
-  mathesis         = {{Tesis magister}{Tesis magister}},
-  phdthesis        = {{Disertasi doktoral}{Disertasi doktoral}},
-  origyear         = {{karya asli terbit}{karya asli terbit}},
-  typevolume       = {{Penyunting Volume}{Peny\adddot\ Vol\adddot}},
-  typevolumes      = {{Penyunting Volume}{Peny\adddot\ Vol\adddot}},
-  typeseries       = {{Penyunting Seri}{Peny\adddot\ Seri}},
-  typeseriess      = {{Penyunting Seri}{Peny\adddot\ Seri}},
-  typevolseries    = {{Penyunting Seri dan Volume}{Peny\adddot\ Seri & Vol\adddot}},
-  typevolseriess   = {{Penyunting Seri dan Volume}{Peny\adddot\ Seri & Vol\adddot}},
-  annodomini       = {{Masehi}{M\adddot}},
-  beforechrist     = {{Sebelum Masehi}{SM\adddot}},
-  commonera        = {{Masehi}{M\adddot}},
-  beforecommonera  = {{Sebelum Masehi}{SM\adddot}},
-  alabama       = {{Alabama}{{A\adddot L\adddot}}},
-  alaska        = {{Alaska}{{A\adddot K\adddot}}},
-  arizona       = {{Arizona}{{A\adddot Z\adddot}}},
-  arkansas      = {{Arkansas}{{A\adddot R\adddot}}},
-  california    = {{California}{{C\adddot A\adddot}}},
-  colorado      = {{Colorado}{{C\adddot O\adddot}}},
-  connecticut   = {{Connecticut}{{C\adddot T\adddot}}},
-  delaware      = {{Delaware}{{D\adddot E\adddot}}},
-  florida       = {{Florida}{{F\adddot L\adddot}}},
-  georgia       = {{Georgia}{{G\adddot A\adddot}}},
-  hawaii        = {{Hawaii}{{H\adddot I\adddot}}},
-  idaho         = {{Idaho}{{I\adddot D\adddot}}},
-  illinois      = {{Illinois}{{I\adddot L\adddot}}},
-  indiana       = {{Indiana}{{I\adddot N\adddot}}},
-  iowa          = {{Iowa}{{I\adddot A\adddot}}},
-  kansas        = {{Kansas}{{K\adddot S\adddot}}},
-  kentucky      = {{Kentucky}{{K\adddot Y\adddot}}},
-  louisiana     = {{Louisiana}{{L\adddot A\adddot}}},
-  maine         = {{Maine}{{M\adddot E\adddot}}},
-  maryland      = {{Maryland}{{M\adddot D\adddot}}},
-  massachusetts = {{Massachusetts}{{M\adddot A\adddot}}},
-  michigan      = {{Michigan}{{M\adddot I\adddot}}},
-  minnesota     = {{Minnesota}{{M\adddot N\adddot}}},
-  mississippi   = {{Mississippi}{{M\adddot S\adddot}}},
-  missouri      = {{Missouri}{{M\adddot O\adddot}}},
-  montana       = {{Montana}{{M\adddot T\adddot}}},
-  nebraska      = {{Nebraska}{{N\adddot E\adddot}}},
-  nevada        = {{Nevada}{{N\adddot V\adddot}}},
-  newhampshire  = {{New Hampshire}{{N\adddot H\adddot}}},
-  newjersey     = {{New Jersey}{{N\adddot J\adddot}}},
-  newmexico     = {{New Mexico}{{N\adddot M\adddot}}},
-  newyork       = {{New York}{{N\adddot Y\adddot}}},
-  northcarolina = {{North Carolina}{{N\adddot C\adddot}}},
-  northdakota   = {{North Dakota}{{N\adddot D\adddot}}},
-  ohio          = {{Ohio}{{O\adddot H\adddot}}},
-  oklahoma      = {{Oklahoma}{{O\adddot K\adddot}}},
-  oregon        = {{Oregon}{{O\adddot R\adddot}}},
-  pennsylvania  = {{Pennsylvania}{{P\adddot A\adddot}}},
-  rhodeisland   = {{Rhode Island}{{R\adddot I\adddot}}},
-  southcarolina = {{South Carolina}{{S\adddot C\adddot}}},
-  southdakota   = {{South Dakota}{{S\adddot D\adddot}}},
-  tennessee     = {{Tennessee}{{T\adddot N\adddot}}},
-  texas         = {{Texas}{{T\adddot X\adddot}}},
-  utah          = {{Utah}{{U\adddot T\adddot}}},
-  vermont       = {{Vermont}{{V\adddot T\adddot}}},
-  virginia      = {{Virginia}{{V\adddot A\adddot}}},
-  washington    = {{Washington}{{W\adddot A\adddot}}},
-  westvirginia  = {{West Virginia}{{W\adddot V\adddot}}},
-  wisconsin     = {{Wisconsin}{{W\adddot I\adddot}}},
-  wyoming       = {{Wyoming}{{W\adddot Y\adddot}}},
-  publication   = {{Publikasi}{Publikasi}}
-}
-
-%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Drop end* when they are the same as *
-% You must use \print*date to get here otherwise it will be ignored
-
-\DeclareBibliographyExtras{%
-  \def\urldatecomma{\addcomma\addspace}%
-  \protected\def\mkbibdateapalong#1#2#3#4{%
-    % As per 10.1, Articles only have year
-    \ifboolexpr{ (test {\ifentrytype{article}}
-                  or (test {\ifentrytype{inbook}} and not test {\ifnameundef{editor}}))
-                 and not test {\iffieldequalstr{entrysubtype}{nonacademic}} }
-      {\clearfield{labelmonth}%
-       \clearfield{labelday}}
-      {}%
-    \iffieldundef{#1}% YEAR
-      {}%
-      {\iffieldbibstring{#1}{\bibncpstring{\thefield{#1}}}{\thefield{#1}}}%
-    \iffieldundef{#2}% YEARDIVISION
-      {}%
-      {\iffieldundef{#1}%
-        {}%
-        {\addcomma\addspace}%
-       \iffieldbibstring{#2}{\bibcplstring{\thefield{#2}}}{\thefield{#2}}}%
-    \iffieldundef{#3}% MONTH
-      {}%
-      {\iffieldundef{#1}%
-        {}%
-        {\addcomma\addspace}%
-       \mkbibmonth{\thefield{#3}}}%
-    \iffieldundef{#4}% DAY
-      {}%
-      {\iffieldundef{#3}%
-        {}%
-        {\addspace}%
-       \stripzeros{\thefield{#4}}}}%
-  \protected\def\mkbibdateapalongextra#1#2#3#4{%
-    % As per 10.1, Articles only have year
-    \ifboolexpr{ (test {\ifentrytype{article}}
-                  or (test {\ifentrytype{inbook}} and not test {\ifnameundef{editor}}))
-                 and not test {\iffieldequalstr{entrysubtype}{nonacademic}} }
-      {\clearfield{labelmonth}%
-       \clearfield{labelday}}
-      {}%
-    \iffieldundef{#1}% YEAR
-      {}%
-      {\iffieldbibstring{#1}{\bibncpstring{\thefield{#1}}}{\thefield{#1}}\printfield{extradate}}%
-    \iffieldundef{#2}% YEARDIVISION
-      {}%
-      {\iffieldundef{#1}%
-        {}%
-        {\addcomma\addspace}%
-       \iffieldbibstring{#2}{\bibcplstring{\thefield{#2}}}{\thefield{#2}}}%
-    \iffieldundef{#3}% MONTH
-      {}%
-      {\iffieldundef{#1}%
-        {}%
-        {\addcomma\addspace}%
-       \mkbibmonth{\thefield{#3}}}%
-    \iffieldundef{#4}% DAY
-      {}%
-      {\iffieldundef{#3}%
-        {}%
-        {\addspace}%
-       \stripzeros{\thefield{#4}}}}%
-  \protected\def\mkbibdateapalongmdy#1#2#3#4{%
-    % As per 10.1, Articles only have year
-    \ifboolexpr{ (test {\ifentrytype{article}}
-                  or (test {\ifentrytype{inbook}} and not test {\ifnameundef{editor}}))
-                 and not test {\iffieldequalstr{entrysubtype}{nonacademic}} }
-      {\clearfield{labelmonth}%
-       \clearfield{labelday}}
-      {}%
-    \iffieldundef{#2}% YEARDIVISION
-      {}%
-      {\iffieldundef{#1}%
-        {}%
-        {\addcomma\addspace}%
-       \iffieldbibstring{#2}{\bibcplstring{\thefield{#2}}}{\thefield{#2}}}%
-    \iffieldundef{#3}% MONTH
-      {}%
-      {\mkbibmonth{\thefield{#3}}}%
-    \iffieldundef{#4}% DAY
-      {}%
-      {\addspace}%
-       \stripzeros{\thefield{#4}}%
-    \iffieldundef{#1}% YEAR
-      {}%
-      {\iffieldundef{#4}%
-        {\iffieldundef{#3}%
-          {}%
-          {\addspace}}%
-        {\addcomma\addspace}%
-       \iffieldbibstring{#1}{\bibncpstring{\thefield{#1}}}{\thefield{#1}}}}}
-
-%
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-
-\endinput

latex/bahasa.lbx

@@ -1,747 +0,0 @@
-\ProvidesFile{bahasa.lbx}
-[\abx@lbxid]
-
-\DeclareRedundantLanguages{english,american}{english,american,british,
-canadian,australian,newzealand,USenglish,UKenglish}
-
-\DeclareBibliographyExtras{%
-  \renewrobustcmd*{\bibdatesep}{-}%
-  \protected\def\bibrangedash{%
-    \textendash\penalty\hyphenpenalty}% breakable dash
-  \def\finalandcomma{\addcomma}%
-  \def\finalandsemicolon{\addsemicolon}%
-  \protected\def\mkbibordinal#1{%
-    \begingroup
-    \@tempcnta0#1\relax\number\@tempcnta
-    \@whilenum\@tempcnta>100\do{\advance\@tempcnta-100\relax}%
-    \ifnum\@tempcnta>20
-      \@whilenum\@tempcnta>9\do{\advance\@tempcnta-10\relax}%
-    \fi
-    \ifcase\@tempcnta th\or st\or nd\or rd\else th\fi
-    \endgroup}%
-  \protected\def\mkbibmascord{\mkbibordinal}%
-  \protected\def\mkbibfemord{\mkbibordinal}%
-  \protected\def\mkbibneutord{\mkbibordinal}%
-  \protected\def\mkbibdatelong#1#2#3{%
-    \iffieldundef{#2}
-      {}
-      {\mkbibmonth{\thefield{#2}}%
-       \iffieldundef{#3}
-         {\iffieldundef{#1}{}{\space}}
-         {\nobreakspace}}%
-    \iffieldundef{#3}
-      {}
-      {\stripzeros{\thefield{#3}}%
-       \iffieldundef{#1}{}{,\space}}%
-     \iffieldbibstring{#1}
-       {\bibstring{\thefield{#1}}}
-       {\dateeraprintpre{#1}\stripzeros{\thefield{#1}}}}%
-  \protected\def\mkbibdateshort#1#2#3{%
-    \iffieldundef{#3}
-      {}
-      {\mkdayzeros{\thefield{#3}}%
-       \iffieldundef{#2}
-         {\iffieldundef{#1}{}{\bibdatesep}}
-         {-}}%
-    \iffieldundef{#2}
-      {}
-      {\mkmonthzeros{\thefield{#2}}%
-       \iffieldundef{#1}{}{\bibdatesep}}%
-     \iffieldbibstring{#1}
-       {\bibstring{\thefield{#1}}}
-       {\dateeraprintpre{#1}\mkyearzeros{\thefield{#1}}}}%
-  \expandafter\protected\expandafter\def\csname mkbibtime24h\endcsname#1#2#3#4{%
-      \iffieldundef{#1}
-        {}
-        {\mktimezeros{\thefield{#1}}%
-         \iffieldundef{#2}{}{\bibtimesep}}%
-      \iffieldundef{#2}
-        {}
-        {\mktimezeros{\thefield{#2}}%
-         \iffieldundef{#3}{}{\bibtimesep}}%
-      \iffieldundef{#3}
-        {}
-        {\mktimezeros{\thefield{#3}}}%
-      \iffieldundef{#4}{}
-        {\bibtimezonesep
-         \mkbibtimezone{\thefield{#4}}}}%
-  \expandafter\protected\expandafter\def\csname mkbibtime12h\endcsname#1#2#3#4{%
-      \stripzeros{\mktimehh{\thefield{#1}}}%
-      \bibtimesep
-      \forcezerosmdt{\thefield{#2}}%
-      \iffieldundef{#3}{}
-        {\bibtimesep
-         \forcezerosmdt{\thefield{#3}}}%
-       \space
-       \ifnumless{\thefield{#1}}{12}
-         {\bibstring{am}}
-         {\bibstring{pm}}%
-      \iffieldundef{#4}{}
-       {\space\bibtimezonesep
-        \parentext{\mkbibtimezone{\thefield{#4}}}}}%
-  \protected\def\mkbibyeardivisiondateshort#1#2{%
-    \mkbibyeardivision{\thefield{#2}}%
-    \iffieldundef{#1}{}{\space}%
-    \dateeraprintpre{#1}\mkyearzeros{\thefield{#1}}}%
-  \protected\def\mkbibyeardivisiondatelong#1#2{%
-    \mkbibyeardivision{\thefield{#2}}%
-    \iffieldundef{#1}{}{\space}%
-    \dateeraprintpre{#1}\mkyearzeros{\thefield{#1}}}%
-  \savecommand\mkdaterangecomp
-  \savecommand\mkdaterangecompextra
-  \savecommand\mkdaterangeterse
-  \savecommand\mkdaterangeterseextra
-  \protected\def\mkdaterangecomp{%
-    \lbx@us@mkdaterangetrunc@long{long}}%
-  \protected\def\mkdaterangeterse{%
-    \lbx@us@mkdaterangetrunc@short{short}}%
-  \protected\def\mkdaterangecompextra{%
-    \lbx@us@mkdaterangetruncextra@long{long}}%
-  \protected\def\mkdaterangeterseextra{%
-    \lbx@us@mkdaterangetruncextra@short{short}}%
-}
-
-\UndeclareBibliographyExtras{%
-  \restorecommand\mkdaterangecomp
-  \restorecommand\mkdaterangecompextra
-  \restorecommand\mkdaterangeterse
-  \restorecommand\mkdaterangeterseextra
-}
-
-\DeclareBibliographyStrings{%
-  bibliography     = {{Daftar Pustaka}{Daftar Pustaka}},
-  references       = {{Referensi}{Referensi}},
-  shorthands       = {{Daftar Singkatan}{Singkatan}},
-  editor           = {{editor}{Ed\adddot}},
-  editors          = {{editor}{Ed\adddot}},
-  compiler         = {{penyusun}{pnysn\adddot}},
-  compilers        = {{penyusun}{pnysn\adddot}},
-  redactor         = {{redaktur}{red\adddot}},
-  redactors        = {{redaktur}{red\adddot}},
-  reviser          = {{perevisi}{perev\adddot}},
-  revisers         = {{perevisi}{perev\adddot}},
-  founder          = {{pendiri}{pendiri}},
-  founders         = {{pendiri}{pendiri}},
-  continuator      = {{pelanjut}{pelanj\adddot}}, % FIXME: unsure
-  continuators     = {{pelanjut}{pelanj\adddot}}, % FIXME: unsure
-  collaborator     = {{kolaborator}{kol\adddot}},
-  collaborators    = {{kolaborator}{kol\adddot}},
-  translator       = {{penerjemah}{penerj\adddot}},
-  translators      = {{penerjemah}{penerj\adddot}},
-  commentator      = {{komentator}{kom\adddot}},
-  commentators     = {{komentator}{kom\adddot}},
-  annotator        = {{anotator}{anot\adddot}},
-  annotators       = {{anotator}{anot\adddot}},
-  commentary       = {{komentar}{kom\adddot}},
-  annotations      = {{anotasi}{anot\adddot}},
-  introduction     = {{pengantar}{peng\adddot}},
-  foreword         = {{kata pengantar}{kata peng\adddot}}, % FIXME: unsure shorthands
-  afterword        = {{kata penutup}{kata pen\adddot}}, % FIXME: unsure shorthands
-  editortr         = {{penyunting dan penerjemah}%
-                         {peny\adddot\ dan penerj\adddot}},
-  editorstr        = {{penyunting dan penerjemah}%
-                         {peny\adddot\ dan penerj\adddot}},
-  editorco         = {{penyunting dan komentator}%
-                         {peny\adddot\ dan kom\adddot}},
-  editorsco        = {{penyunting dan komentator}%
-                         {peny\adddot\ dan kom\adddot}},
-  editoran         = {{penyunting dan anotator}%
-                         {peny\adddot\ dan anot\adddot}},
-  editorsan        = {{penyunting dan anotator}%
-                         {peny\adddot\ dan anot\adddot}},
-  editorin         = {{penyunting dan pengantar}%
-                         {peny\adddot\ dan peng\adddot}},
-  editorsin        = {{penyunting dan pengantar}%
-                         {peny\adddot\ dan peng\adddot}},
-  editorfo         = {{penyunting dan kata pengantar}%
-                         {peny\adddot\ dan kata peng\adddot}},
-  editorsfo        = {{penyunting dan kata pengantar}%
-                         {peny\adddot\ dan kata peng\adddot}},
-  editoraf         = {{penyunting dan kata penutup}%
-                         {peny\adddot\ dan kata pen\adddot}},
-  editorsaf        = {{penyunting dan kata penutup}%
-                         {peny\adddot\ dan kata pen\adddot}},
-  editortrco       = {{penyunting, penerjemah, dan komentator}%
-                         {peny\adddot, penerj\adddot, dan kom\adddot}},
-  editorstrco      = {{penyunting, penerjemah, dan komentator}%
-                         {peny\adddot, penerj\adddot, dan kom\adddot}},
-  editortran       = {{penyunting, penerjemah, dan anotator}%
-                         {peny\adddot, penerj\adddot, dan anot\adddot}},
-  editorstran      = {{penyunting, penerjemah, dan anotator}%
-                         {peny\adddot, penerj\adddot, dan anot\adddot}},
-  editortrin       = {{penyunting, penerjemah, dan pengantar}%
-                         {peny\adddot, penerj\adddot, dan peng\adddot}},
-  editorstrin      = {{penyunting, penerjemah, dan pengantar}%
-                         {peny\adddot, penerj\adddot, dan peng\adddot}},
-  editortrfo       = {{penyunting, penerjemah, dan kata pengantar}%
-                         {peny\adddot, penerj\adddot, dan kata peng\adddot}},
-  editorstrfo      = {{penyunting, penerjemah, dan kata pengantar}%
-                         {peny\adddot, penerj\adddot, dan kata peng\adddot}},
-  editortraf       = {{penyunting, penerjemah, dan kata penutup}%
-                         {peny\adddot, penerj\adddot, dan kata pen\adddot}},
-  editorstraf      = {{penyunting, penerjemah, dan kata penutup}%
-                         {peny\adddot, penerj\adddot, dan kata pen\adddot}},
-  editorcoin       = {{penyunting, komentator, dan pengantar}%
-                         {peny\adddot, kom\adddot, dan peng\adddot}},
-  editorscoin      = {{penyunting, komentator, dan pengantar}%
-                         {peny\adddot, kom\adddot, dan peng\adddot}},
-  editorcofo       = {{penyunting, komentator, dan kata pengantar}%
-                         {peny\adddot, kom\adddot, dan kata peng\adddot}},
-  editorscofo      = {{penyunting, komentator, dan kata pengantar}%
-                         {peny\adddot, kom\adddot, dan kata peng\adddot}},
-  editorcoaf       = {{penyunting, komentator, dan kata penutup}%
-                         {peny\adddot, kom\adddot, dan kata pen\adddot}},
-  editorscoaf      = {{penyunting, komentator, dan kata penutup}%
-                         {peny\adddot, kom\adddot, dan kata pen\adddot}},
-  editoranin       = {{penyunting, anotator, dan pengantar}%
-                         {peny\adddot, anot\adddot, dan peng\adddot}},
-  editorsanin      = {{penyunting, anotator, dan pengantar}%
-                         {peny\adddot, anot\adddot, dan peng\adddot}},
-  editoranfo       = {{penyunting, anotator, dan kata pengantar}%
-                         {peny\adddot, anot\adddot, dan kata peng\adddot}},
-  editorsanfo      = {{penyunting, anotator, dan kata pengantar}%
-                         {peny\adddot, anot\adddot, dan kata peng\adddot}},
-  editoranaf       = {{penyunting, anotator, dan kata penutup}%
-                         {peny\adddot, anot\adddot, dan kata pen\adddot}},
-  editorsanaf      = {{penyunting, anotator, dan kata penutup}%
-                         {peny\adddot, anot\adddot, dan kata pen\adddot}},
-  editortrcoin     = {{penyunting, penerjemah, komentator, dan pengantar}%
-                         {peny\adddot, penerj\adddot, kom\adddot, dan peng\adddot}},
-  editorstrcoin    = {{penyunting, penerjemah, komentator, dan pengantar}%
-                         {peny\adddot, penerj\adddot, kom\adddot, dan peng\adddot}},
-  editortrcofo     = {{penyunting, penerjemah, komentator, dan kata pengantar}%
-                         {peny\adddot, penerj\adddot, kom\adddot, dan kata peng\adddot}},
-  editorstrcofo    = {{penyunting, penerjemah, komentator, dan kata pengantar}%
-                         {peny\adddot, penerj\adddot, kom\adddot, dan kata peng\adddot}},
-  editortrcoaf     = {{penyunting, penerjemah, komentator, dan kata penutup}%
-                         {peny\adddot, penerj\adddot, kom\adddot, dan kata pen\adddot}},
-  editorstrcoaf    = {{penyunting, penerjemah, komentator, dan kata penutup}%
-                         {peny\adddot, penerj\adddot, kom\adddot, dan kata pen\adddot}},
-  editortranin     = {{penyunting, penerjemah, anotator, dan pengantar}%
-                         {peny\adddot, penerj\adddot, anot\adddot, dan peng\adddot}},
-  editorstranin    = {{penyunting, penerjemah, anotator, dan pengantar}%
-                         {peny\adddot, penerj\adddot, anot\adddot, dan peng\adddot}},
-  editortranfo     = {{penyunting, penerjemah, anotator, dan kata pengantar}%
-                         {peny\adddot, penerj\adddot, anot\adddot, dan kata peng\adddot}},
-  editorstranfo    = {{penyunting, penerjemah, anotator, dan kata pengantar}%
-                         {peny\adddot, penerj\adddot, anot\adddot, dan kata peng\adddot}},
-  editortranaf     = {{penyunting, penerjemah, anotator, dan kata penutup}%
-                         {peny\adddot, penerj\adddot, anot\adddot, dan kata pen\adddot}},
-  editorstranaf    = {{penyunting, penerjemah, anotator, dan kata penutup}%
-                         {peny\adddot, penerj\adddot, anot\adddot, dan kata pen\adddot}},
-  translatorco     = {{penerjemah dan komentator}%
-                         {penerj\adddot\ dan kom\adddot}},
-  translatorsco    = {{penerjemah dan komentator}%
-                         {penerj\adddot\ dan kom\adddot}},
-  translatoran     = {{penerjemah dan anotator}%
-                         {penerj\adddot\ dan anot\adddot}},
-  translatorsan    = {{penerjemah dan anotator}%
-                         {penerj\adddot\ dan anot\adddot}},
-  translatorin     = {{penerjemahan dan pengantar}%
-                         {penerj\adddot\ dan peng\adddot}},
-  translatorsin    = {{penerjemahan dan pengantar}%
-                         {penerj\adddot\ dan peng\adddot}},
-  translatorfo     = {{penerjemahan dan kata pengantar}%
-                         {penerj\adddot\ dan kata peng\adddot}},
-  translatorsfo    = {{penerjemahan dan kata pengantar}%
-                         {penerj\adddot\ dan kata peng\adddot}},
-  translatoraf     = {{penerjemahan dan kata penutup}%
-                         {penerj\adddot\ dan kata pen\adddot}},
-  translatorsaf    = {{penerjemahan dan kata penutup}%
-                         {penerj\adddot\ dan kata pen\adddot}},
-  translatorcoin   = {{penerjemahan, komentar, dan pengantar}%
-                         {penerj\adddot, kom\adddot, dan peng\adddot}},
-  translatorscoin  = {{penerjemahan, komentar, dan pengantar}%
-                         {penerj\adddot, kom\adddot, dan peng\adddot}},
-  translatorcofo   = {{penerjemahan, komentar, dan kata pengantar}%
-                         {penerj\adddot, kom\adddot, dan kata peng\adddot}},
-  translatorscofo  = {{penerjemahan, komentar, dan kata pengantar}%
-                         {penerj\adddot, kom\adddot, dan kata peng\adddot}},
-  translatorcoaf   = {{penerjemahan, komentar, dan kata penutup}%
-                         {penerj\adddot, kom\adddot, dan kata pen\adddot}},
-  translatorscoaf  = {{penerjemahan, komentar, dan kata penutup}%
-                         {penerj\adddot, kom\adddot, dan kata pen\adddot}},
-  translatoranin   = {{penerjemahan, anotasi, dan pengantar}%
-                         {penerj\adddot, anot\adddot, dan peng\adddot}},
-  translatorsanin  = {{penerjemahan, anotasi, dan pengantar}%
-                         {penerj\adddot, anot\adddot, dan peng\adddot}},
-  translatoranfo   = {{penerjemahan, anotasi, dan kata pengantar}%
-                         {penerj\adddot, anot\adddot, dan kata peng\adddot}},
-  translatorsanfo  = {{penerjemahan, anotasi, dan kata pengantar}%
-                         {penerj\adddot, anot\adddot, dan kata peng\adddot}},
-  translatoranaf   = {{penerjemahan, anotasi, dan kata penutup}%
-                         {penerj\adddot, anot\adddot, dan kata pen\adddot}},
-  translatorsanaf  = {{penerjemahan, anotasi, dan kata penutup}%
-                         {penerj\adddot, anot\adddot, dan kata pen\adddot}},
-  organizer        = {{penyelenggara}{penyelenggara}},
-  organizers       = {{penyelenggara}{penyelenggara}},
-  byorganizer      = {{diselenggarakan oleh}{diselenggarakan oleh}},
-  byauthor         = {{oleh}{oleh}},
-  byeditor         = {{disunting oleh}{sun\adddot\ oleh}},
-  bycompiler       = {{disusun oleh}{disusun oleh}},
-  byredactor       = {{diredaksi oleh}{red\adddot\ oleh}},
-  byreviser        = {{direvisi oleh}{direvisi oleh}},
-  byreviewer       = {{ditinjau oleh}{ditinjau oleh}},
-  byfounder        = {{didirikan oleh}{didirikan oleh}},
-  bycontinuator    = {{dilanjutkan oleh}{dilanjutkan oleh}},
-  bycollaborator   = {{berkolaborasi dengan}{berkolaborasi dengan}},
-  bytranslator     = {{diterjemahkan \lbx@lfromlang\ oleh}{terj\adddot\ \lbx@sfromlang\ oleh}},
-  bycommentator    = {{diberi komentar oleh}{diberi kom\adddot\ oleh}},
-  byannotator      = {{dianotasi oleh}{dianotasi oleh}},
-  withcommentator  = {{dengan komentar oleh}{dgn\adddot\ kom\adddot\ oleh}},
-  withannotator    = {{dengan anotasi oleh}{dgn\adddot\ anot\adddot\ oleh}},
-  withintroduction = {{dengan pengantar oleh}{dgn\adddot\ peng\adddot\ oleh}},
-  withforeword     = {{dengan kata pengantar oleh}{dgn\adddot\ kata peng\adddot\ oleh}},
-  withafterword    = {{dengan kata penutup oleh}{dgn\adddot\ kata pen\adddot\ oleh}},
-  byeditortr       = {{disunting dan diterjemahkan \lbx@lfromlang\ oleh}%
-                         {sun\adddot\ dan terj\adddot\ \lbx@sfromlang\ oleh}},
-  byeditorco       = {{disunting dan diberi komentar oleh}%
-                         {sun\adddot\ dan diberi kom\adddot\ oleh}},
-  byeditoran       = {{disunting dan dianotasi oleh}%
-                         {sun\adddot\ dan dianotasi oleh}},
-  byeditorin       = {{disunting, dengan pengantar, oleh}%
-                         {sun\adddot, dgn\adddot\ peng\adddot, oleh}},
-  byeditorfo       = {{disunting, dengan kata pengantar, oleh}%
-                         {sun\adddot, dgn\adddot\ kata peng\adddot, oleh}},
-  byeditoraf       = {{disunting, dengan kata penutup, oleh}%
-                         {sun\adddot, dgn\adddot\ kata pen\adddot, oleh}},
-  byeditortrco     = {{disunting, diterjemahkan \lbx@lfromlang, dan diberi komentar oleh}%
-                         {sun\adddot, terj\adddot\ \lbx@sfromlang, dan diberi kom\adddot\ oleh}},
-  byeditortran     = {{disunting, diterjemahkan \lbx@lfromlang, dan dianotasi oleh}%
-                         {sun\adddot, terj\adddot\ \lbx@sfromlang, dan dianotasi oleh}},
-  byeditortrin     = {{disunting dan diterjemahkan \lbx@lfromlang, dengan pengantar, oleh}%
-                         {sun\adddot\ dan terj\adddot\ \lbx@sfromlang, dgn\adddot\ peng\adddot, oleh}},
-  byeditortrfo     = {{disunting dan diterjemahkan \lbx@lfromlang, dengan kata pengantar, oleh}%
-                         {sun\adddot\ dan terj\adddot\ \lbx@sfromlang, dgn\adddot\ kata peng\adddot, oleh}},
-  byeditortraf     = {{disunting dan diterjemahkan \lbx@lfromlang, dengan kata penutup, oleh}%
-                         {sun\adddot\ dan terj\adddot\ \lbx@sfromlang, dgn\adddot\ kata pen\adddot, oleh}},
-  byeditorcoin     = {{disunting dan diberi komentar, dengan pengantar, oleh}%
-                         {sun\adddot\ dan diberi kom\adddot, dgn\adddot\ peng\adddot, oleh}},
-  byeditorcofo     = {{disunting dan diberi komentar, dengan kata pengantar, oleh}%
-                         {sun\adddot\ dan diberi kom\adddot, dgn\adddot\ kata peng\adddot, oleh}},
-  byeditorcoaf     = {{disunting dan diberi komentar, dengan kata penutup, oleh}%
-                         {sun\adddot\ dan diberi kom\adddot, dgn\adddot\ kata pen\adddot, oleh}},
-  byeditoranin     = {{disunting dan dianotasi, dengan pengantar, oleh}%
-                         {sun\adddot\ dan dianotasi, dgn\adddot\ peng\adddot, oleh}},
-  byeditoranfo     = {{disunting dan dianotasi, dengan kata pengantar, oleh}%
-                         {sun\adddot\ dan dianotasi, dgn\adddot\ kata peng\adddot, oleh}},
-  byeditoranaf     = {{disunting dan dianotasi, dengan kata penutup, oleh}%
-                         {sun\adddot\ dan dianotasi, dgn\adddot\ kata pen\adddot, oleh}},
-  byeditortrcoin   = {{disunting, diterjemahkan \lbx@lfromlang, dan diberi komentar, dengan pengantar, oleh}%
-                         {sun\adddot, terj\adddot\ \lbx@sfromlang, dan diberi kom\adddot, dgn\adddot\ peng\adddot, oleh}},
-  byeditortrcofo   = {{disunting, diterjemahkan \lbx@lfromlang, dan diberi komentar, dengan kata pengantar, oleh}%
-                         {sun\adddot, terj\adddot\ \lbx@sfromlang, dan diberi kom\adddot, dgn\adddot\ kata peng\adddot, oleh}},
-  byeditortrcoaf   = {{disunting, diterjemahkan \lbx@lfromlang, dan diberi komentar, dengan kata penutup, oleh}%
-                         {sun\adddot, terj\adddot\ \lbx@sfromlang, dan diberi kom\adddot, dgn\adddot\ kata pen\adddot, oleh}},
-  byeditortranin   = {{disunting, diterjemahkan \lbx@lfromlang, dan dianotasi, dengan pengantar, oleh}%
-                         {sun\adddot, terj\adddot\ \lbx@sfromlang, dan dianotasi, dgn\adddot\ peng\adddot, oleh}},
-  byeditortranfo   = {{disunting, diterjemahkan \lbx@lfromlang, dan dianotasi, dengan kata pengantar, oleh}%
-                         {sun\adddot, terj\adddot\ \lbx@sfromlang, dan dianotasi, dgn\adddot\ kata peng\adddot, oleh}},
-  byeditortranaf   = {{disunting, diterjemahkan \lbx@lfromlang, dan dianotasi, dengan kata penutup, oleh}%
-                         {sun\adddot, terj\adddot\ \lbx@sfromlang, dan dianotasi, dgn\adddot\ kata pen\adddot, oleh}},
-  bytranslatorco   = {{diterjemahkan \lbx@lfromlang\ dan diberi komentar oleh}%
-                         {terj\adddot\ \lbx@sfromlang\ dan diberi kom\adddot\ oleh}},
-  bytranslatoran   = {{diterjemahkan \lbx@lfromlang\ dan dianotasi oleh}%
-                         {terj\adddot\ \lbx@sfromlang\ dan dianotasi oleh}},
-  bytranslatorin   = {{diterjemahkan \lbx@lfromlang, dengan pengantar, oleh}%
-                         {terj\adddot\ \lbx@sfromlang, dgn\adddot\ peng\adddot, oleh}},
-  bytranslatorfo   = {{diterjemahkan \lbx@lfromlang, dengan kata pengantar, oleh}%
-                         {terj\adddot\ \lbx@sfromlang, dgn\adddot\ kata peng\adddot, oleh}},
-  bytranslatoraf   = {{diterjemahkan \lbx@lfromlang, dengan kata penutup, oleh}%
-                         {terj\adddot\ \lbx@sfromlang, dgn\adddot\ kata pen\adddot, oleh}},
-  bytranslatorcoin = {{diterjemahkan \lbx@lfromlang\ dan diberi komentar, dengan pengantar, oleh}%
-                         {terj\adddot\ \lbx@sfromlang, dan diberi kom\adddot, dgn\adddot\ peng\adddot, oleh}},
-  bytranslatorcofo = {{diterjemahkan \lbx@lfromlang\ dan diberi komentar, dengan kata pengantar, oleh}%
-                         {terj\adddot\ \lbx@sfromlang, dan diberi kom\adddot, dgn\adddot\ kata peng\adddot, oleh}},
-  bytranslatorcoaf = {{diterjemahkan \lbx@lfromlang\ dan diberi komentar, dengan kata penutup, oleh}%
-                         {terj\adddot\ \lbx@sfromlang, dan diberi kom\adddot, dgn\adddot\ kata pen\adddot, oleh}},
-  bytranslatoranin = {{diterjemahkan \lbx@lfromlang\ dan dianotasi, dengan pengantar, oleh}%
-                         {terj\adddot\ \lbx@sfromlang, dan dianotasi, dgn\adddot\ peng\adddot, oleh}},
-  bytranslatoranfo = {{diterjemahkan \lbx@lfromlang\ dan dianotasi, dengan kata pengantar, oleh}%
-                         {terj\adddot\ \lbx@sfromlang, dan dianotasi, dgn\adddot\ kata peng\adddot, oleh}},
-  bytranslatoranaf = {{diterjemahkan \lbx@lfromlang\ dan dianotasi, dengan kata penutup, oleh}%
-                         {terj\adddot\ \lbx@sfromlang, dan dianotasi, dgn\adddot\ kata pen\adddot, oleh}},
-  and              = {{dan}{dan}},
-  andothers        = {{dan kawan-kawan}{dkk\adddot}},
-  andmore          = {{dan kawan-kawan}{dkk\adddot}},
-  volume           = {{volume}{vol\adddot}},
-  volumes          = {{volume}{vol\adddot}},
-  involumes        = {{dalam}{dalam}},
-  jourvol          = {{volume}{vol\adddot}},
-  jourser          = {{seri}{ser\adddot}},
-  book             = {{buku}{buku}},
-  part             = {{bagian}{bag\adddot}},
-  issue            = {{nomor}{no\adddot}},
-  newseries        = {{seri baru}{ser\adddot\ baru}},
-  oldseries        = {{seri lama}{ser\adddot\ lama}},
-  edition          = {{edisi}{ed\adddot}},
-  reprint          = {{cetak ulang}{cet\adddot\ ul\adddot}},
-  reprintof        = {{cetakan ulang dari}{cet\adddot\ ul\adddot\ dari}},
-  reprintas        = {{dicetak ulang sebagai}{dicetak ulang sbg\adddot}},
-  reprintfrom      = {{dicetak ulang dari}{dicetak ulang dari}},
-  reviewof         = {{tinjauan dari}{tinjauan dari}},
-  translationof    = {{terjemahan dari}{terj\adddot\ dari}},
-  translationas    = {{diterjemahkan sebagai}{diterj\adddot\ sbg\adddot}},
-  translationfrom  = {{diterjemahkan dari}{diterj\adddot\ dari}},
-  origpubas        = {{pertama kali terbit sebagai}{pertama terbit sbg\adddot}},
-  origpubin        = {{pertama kali terbit dalam}{pertama terbit dlm\adddot}},
-  astitle          = {{sebagai}{sbg\adddot}},
-  bypublisher      = {{oleh}{oleh}},
-  nodate           = {{tanpa tanggal}{t.t\adddot}},
-  page             = {{halaman}{hlm\adddot}},
-  pages            = {{halaman}{hlm\adddot}},
-  column           = {{kolom}{kol\adddot}},
-  columns          = {{kolom}{kol\adddot}},
-  line             = {{baris}{brs\adddot}},
-  lines            = {{baris}{brs\adddot}},
-  verse            = {{ayat}{ayat}},
-  verses           = {{ayat}{ayat}},
-  section          = {{bagian}{\S}},
-  sections         = {{bagian}{\S\S}},
-  paragraph        = {{paragraf}{par\adddot}},
-  paragraphs       = {{paragraf}{par\adddot}},
-  pagetotal        = {{halaman}{hlm\adddot}},
-  pagetotals       = {{halaman}{hlm\adddot}},
-  columntotal      = {{kolom}{kol\adddot}},
-  columntotals     = {{kolom}{kol\adddot}},
-  linetotal        = {{baris}{brs\adddot}},
-  linetotals       = {{baris}{brs\adddot}},
-  versetotal       = {{ayat}{ayat}},
-  versetotals      = {{ayat}{ayat}},
-  sectiontotal     = {{bagian}{\S}},
-  sectiontotals    = {{bagian}{\S\S}},
-  paragraphtotal   = {{paragraf}{par\adddot}},
-  paragraphtotals  = {{paragraf}{par\adddot}},
-  in               = {{dalam}{dalam}},
-  inseries         = {{dalam seri}{dalam seri}},
-  ofseries         = {{dari seri}{dari seri}},
-  number           = {{nomor}{no\adddot}},
-  chapter          = {{bab}{bab}},
-  bathesis         = {{skripsi}{skripsi}},
-  mathesis         = {{tesis}{tesis}},
-  phdthesis        = {{disertasi}{disertasi}},
-  candthesis       = {{tesis kandidat}{tesis kand\adddot}},% FIXME: unsure
-  resreport        = {{laporan penelitian}{lap\adddot\ pen\adddot}},
-  techreport       = {{laporan teknis}{lap\adddot\ tek\adddot}},
-  software         = {{perangkat lunak}{perangkat lunak}},
-  datacd           = {{CD-ROM}{CD-ROM}},
-  audiocd          = {{CD audio}{CD audio}},
-  version          = {{versi}{ver}},
-  url              = {{URL}{URL}},
-  urlfrom          = {{tersedia dari}{tersedia dari}},
-  urlseen          = {{diakses pada}{diakses pada}},
-  inpreparation    = {{dalam persiapan}{dalam persiapan}},
-  submitted        = {{diserahkan}{diserahkan}},
-  forthcoming      = {{akan terbit}{akan terbit}},
-  inpress          = {{dalam proses cetak}{dalam proses cetak}},
-  prepublished     = {{praterbit}{praterbit}},
-  citedas          = {{selanjutnya dikutip sebagai}{selanjutnya dikutip sbg\adddot}},
-  thiscite         = {{khususnya}{khususnya}},
-  seenote          = {{lihat catatan}{lih\adddot\ ctt\adddot}},
-  quotedin         = {{dikutip dalam}{dikutip dlm\adddot}},
-  idem             = {{idem}{idem}},
-  idemsm           = {{idem}{idem}},
-  idemsf           = {{eadem}{eadem}},
-  idemsn           = {{idem}{idem}},
-  idempm           = {{eidem}{eidem}},
-  idempf           = {{eaedem}{eaedem}},
-  idempn           = {{eadem}{eadem}},
-  idempp           = {{eidem}{eidem}},
-  ibidem           = {{ibidem}{ibid\adddot}},
-  opcit            = {{op\adddotspace cit\adddot}{op\adddotspace cit\adddot}},
-  loccit           = {{loc\adddotspace cit\adddot}{loc\adddotspace cit\adddot}},
-  confer           = {{bandingkan}{bdk\adddot}},
-  sequens          = {{sq\adddot}{sq\adddot}},
-  sequentes        = {{sqq\adddot}{sqq\adddot}},
-  passim           = {{passim}{passim}},
-  see              = {{lihat}{lih\adddot}},
-  seealso          = {{lihat juga}{lih\adddot\ juga}},
-  backrefpage      = {{dikutip pada halaman}{dikutip hlm\adddot}},
-  backrefpages     = {{dikutip pada halaman}{dikutip hlm\adddot}},
-  january          = {{Januari}{Jan\adddot}},
-  february         = {{Februari}{Feb\adddot}},
-  march            = {{Maret}{Mar\adddot}},
-  april            = {{April}{Apr\adddot}},
-  may              = {{Mei}{Mei}},
-  june             = {{Juni}{Jun\adddot}},
-  july             = {{Juli}{Jul\adddot}},
-  august           = {{Agustus}{Ags\adddot}},
-  september        = {{September}{Sep\adddot}},
-  october          = {{Oktober}{Okt\adddot}},
-  november         = {{November}{Nov\adddot}},
-  december         = {{Desember}{Des\adddot}},
-  langamerican     = {{Amerika}{Amerika}},
-  langbasque       = {{Bask}{Bask}},
-  langbrazilian    = {{Brasil}{Brasil}},
-  langbulgarian    = {{Bulgaria}{Bulgaria}},
-  langcatalan      = {{Katala}{Katala}},
-  langcroatian     = {{Kroasia}{Kroasia}},
-  langczech        = {{Ceko}{Ceko}},
-  langdanish       = {{Denmark}{Denmark}},
-  langdutch        = {{Belanda}{Belanda}},
-  langenglish      = {{Inggris}{Inggris}},
-  langestonian     = {{Estonia}{Estonia}},
-  langfinnish      = {{Finlandia}{Finlandia}},
-  langfrench       = {{Prancis}{Prancis}},
-  langgalician     = {{Galisia}{Galisia}},
-  langgerman       = {{Jerman}{Jerman}},
-  langgreek        = {{Yunani}{Yunani}},
-  langhungarian    = {{Hungaria}{Hungaria}},
-  langitalian      = {{Italia}{Italia}},
-  langjapanese     = {{Jepang}{Jepang}},
-  langlatin        = {{Latin}{Latin}},
-  langlatvian      = {{Latvia}{Latvia}},
-  langlithuanian   = {{Lituania}{Lituania}},
-  langmarathi      = {{Marathi}{Marathi}},
-  langnorwegian    = {{Norwegia}{Norwegia}},
-  langpolish       = {{Polandia}{Polandia}},
-  langportuguese   = {{Portugis}{Portugis}},
-  langromanian     = {{Rumania}{Rumania}},
-  langrussian      = {{Rusia}{Rusia}},
-  langserbian      = {{Serbia}{Serbia}},
-  langslovak       = {{Slowakia}{Slowakia}},
-  langslovene      = {{Slovenia}{Slovenia}},
-  langspanish      = {{Spanyol}{Spanyol}},
-  langswedish      = {{Swedia}{Swedia}},
-  langturkish      = {{Turki}{Turki}},
-  langukrainian    = {{Ukraina}{Ukraina}},
-  fromamerican     = {{dari bahasa Amerika}{dari bahasa Amerika}},
-  frombasque       = {{dari bahasa Bask}{dari bahasa Bask}},
-  frombrazilian    = {{dari bahasa Brasil}{dari bahasa Brasil}},
-  frombulgarian    = {{dari bahasa Bulgaria}{dari bahasa Bulgaria}},
-  fromcatalan      = {{dari bahasa Katala}{dari bahasa Katala}},
-  fromcroatian     = {{dari bahasa Kroasia}{dari bahasa Kroasia}},
-  fromczech        = {{dari bahasa Ceko}{dari bahasa Ceko}},
-  fromdanish       = {{dari bahasa Denmark}{dari bahasa Denmark}},
-  fromdutch        = {{dari bahasa Belanda}{dari bahasa Belanda}},
-  fromenglish      = {{dari bahasa Inggris}{dari bahasa Inggris}},
-  fromestonian     = {{dari bahasa Estonia}{dari bahasa Estonia}},
-  fromfinnish      = {{dari bahasa Finlandia}{dari bahasa Finlandia}},
-  fromfrench       = {{dari bahasa Prancis}{dari bahasa Prancis}},
-  fromgalician     = {{dari bahasa Galisia}{dari bahasa Galisia}},
-  fromgerman       = {{dari bahasa Jerman}{dari bahasa Jerman}},
-  fromgreek        = {{dari bahasa Yunani}{dari bahasa Yunani}},
-  fromhungarian    = {{dari bahasa Hungaria}{dari bahasa Hungaria}},
-  fromitalian      = {{dari bahasa Italia}{dari bahasa Italia}},
-  fromjapanese     = {{dari bahasa Jepang}{dari bahasa Jepang}},
-  fromlatin        = {{dari bahasa Latin}{dari bahasa Latin}},
-  fromlatvian      = {{dari bahasa Latvia}{dari bahasa Latvia}},
-  fromlithuanian   = {{dari bahasa Lituania}{dari bahasa Lituania}},
-  frommarathi      = {{dari bahasa Marathi}{dari bahasa Marathi}},
-  fromnorwegian    = {{dari bahasa Norwegia}{dari bahasa Norwegia}},
-  frompolish       = {{dari bahasa Polandia}{dari bahasa Polandia}},
-  fromportuguese   = {{dari bahasa Portugis}{dari bahasa Portugis}},
-  fromromanian     = {{dari bahasa Rumania}{dari bahasa Rumania}},
-  fromrussian      = {{dari bahasa Rusia}{dari bahasa Rusia}},
-  fromserbian      = {{dari bahasa Serbia}{dari bahasa Serbia}},
-  fromslovak       = {{dari bahasa Slowakia}{dari bahasa Slowakia}},
-  fromslovene      = {{dari bahasa Slovenia}{dari bahasa Slovenia}},
-  fromspanish      = {{dari bahasa Spanyol}{dari bahasa Spanyol}},
-  fromswedish      = {{dari bahasa Swedia}{dari bahasa Swedia}},
-  fromturkish      = {{dari bahasa Turki}{dari bahasa Turki}},
-  fromukrainian    = {{dari bahasa Ukraina}{dari bahasa Ukraina}},
-  countryde        = {{Jerman}{DE}},
-  countryeu        = {{Uni Eropa}{UE}},
-  countryep        = {{Uni Eropa}{UE}},
-  countryfr        = {{Prancis}{FR}},
-  countryuk        = {{Britania Raya}{GB}},
-  countryus        = {{Amerika Serikat}{AS}},
-  patent           = {{paten}{pat\adddot}},
-  patentde         = {{paten Jerman}{pat\adddot\ Jerman}},
-  patenteu         = {{paten Eropa}{pat\adddot\ Eropa}},
-  patentfr         = {{paten Prancis}{pat\adddot\ Prancis}},
-  patentuk         = {{paten Britania}{pat\adddot\ Britania}},
-  patentus         = {{paten A.S.}{pat\adddot\ A\adddot S\adddot}},
-  patreq           = {{permohonan paten}{permohonan pat\adddot}},
-  patreqde         = {{permohonan paten Jerman}{permohonan pat\adddot\ Jerman}},
-  patreqeu         = {{permohonan paten Eropa}{permohonan pat\adddot\ Eropa}},
-  patreqfr         = {{permohonan paten Prancis}{permohonan pat\adddot\ Prancis}},
-  patrequk         = {{permohonan paten Britania}{permohonan pat\adddot\ Britania}},
-  patrequs         = {{permohonan paten A.S.}{permohonan pat\adddot\ A\adddot S\adddot}},
-  file             = {{berkas}{berkas}},
-  library          = {{perpustakaan}{perpustakaan}},
-  abstract         = {{abstrak}{abstrak}},
-  annotation       = {{anotasi}{anotasi}},
-  commonera        = {{era umum}{CE}}, % FIXME: inconsistent shorthands
-  beforecommonera  = {{sebelum era umum}{BCE}}, % FIXME: inconsistent shorthands
-  annodomini       = {{masehi}{M}},
-  beforechrist     = {{sebelum masehi}{SM}},
-  circa            = {{circa}{ca\adddot}},
-  spring           = {{musim semi}{musim semi}},% FIXME: unsure
-  summer           = {{musim panas}{musim panas}},% FIXME: unsure
-  autumn           = {{musim gugur}{musim gugur}},% FIXME: unsure
-  winter           = {{musim dingin}{musim dingin}},% FIXME: unsure
-  springN          = {{musim semi (belahan utara)}{musim semi (BU)}},% FIXME: unsure
-  summerN          = {{musim panas (belahan utara)}{musim panas (BU)}},% FIXME: unsure
-  autumnN          = {{musim gugur (belahan utara)}{musim gugur (BU)}},% FIXME: unsure
-  winterN          = {{musim dingin (belahan utara)}{musim dingin (BU)}},% FIXME: unsure
-  springS          = {{musim semi (belahan selatan)}{musim semi (BS)}},% FIXME: unsure
-  summerS          = {{musim panas (belahan selatan)}{musim panas (BS)}},% FIXME: unsure
-  autumnS          = {{musim gugur (belahan selatan)}{musim gugur (BS)}},% FIXME: unsure
-  winterS          = {{musim dingin (belahan selatan)}{musim dingin (BS)}},% FIXME: unsure
-  Q1               = {{kuartal 1}{K1}},
-  Q2               = {{kuartal 2}{K2}},
-  Q3               = {{kuartal 3}{K3}},
-  Q4               = {{kuartal 4}{K4}},
-  QD1              = {{caturwulan 1}{QD1}},% FIXME: unsure
-  QD2              = {{caturwulan 2}{QD2}},% FIXME: unsure
-  QD3              = {{caturwulan 3}{QD3}},% FIXME: unsure
-  S1               = {{semester 1}{S1}},
-  S2               = {{semester 2}{S2}},
-  am               = {{AM}{AM}},
-  pm               = {{PM}{PM}},
-}
-
-\protected\gdef\lbx@us@mkdaterangetrunc@long#1#2{%
-  \blx@if@printanytimes{#2}
-    {\mkdaterangefull{#1}{#2}}
-    {\lbx@us@mkdaterangetrunc@long@i{#1}{#2}}}
-
-\protected\gdef\lbx@us@mkdaterangetrunc@long@i#1#2{%
-  \begingroup
-    \blx@metadateinfo{#2}%
-    \iffieldundef{#2year}
-      {\blx@nounit}
-      {\printtext[{#2date}]{%
-         \datecircaprint
-         \iffieldundef{#2yeardivision}
-           {\ifdateyearsequal{#2}{#2end}
-             {\csuse{mkbibdate#1}{}{#2month}{#2day}}
-             {\csuse{mkbibdate#1}{#2year}{#2month}{#2day}%
-              \dateeraprint{#2year}}}
-           {\ifdateyearsequal{#2}{#2end}
-             {\csuse{mkbibyeardivisiondate#1}{}{#2yeardivision}}
-             {\csuse{mkbibyeardivisiondate#1}{#2year}{#2yeardivision}%
-              \dateeraprint{#2year}}}%
-         \dateuncertainprint
-         \iffieldundef{#2endyear}
-           {}
-           {\iffieldequalstr{#2endyear}{}
-             {\mbox{\bibdaterangesep}}
-             {\bibdaterangesep
-              \enddatecircaprint
-              \iffieldundef{#2endyeardivision}
-                {\ifdateyearsequal{#2}{#2end}
-                  {\iffieldsequal{#2month}{#2endmonth}
-                    {\csuse{mkbibdate#1}{#2endyear}{}{#2endday}}
-                    {\csuse{mkbibdate#1}{#2endyear}{#2endmonth}{#2endday}}}
-                  {\csuse{mkbibdate#1}{#2endyear}{#2endmonth}{#2endday}}}
-                {\csuse{mkbibyeardivisiondate#1}{#2endyear}{#2endyeardivision}}%
-              \enddateuncertainprint
-              \dateeraprint{#2endyear}}}}}%
-  \endgroup}
-
-\protected\gdef\lbx@us@mkdaterangetrunc@short#1#2{%
-  \blx@if@printanytimes{#2}
-    {\mkdaterangefull{#1}{#2}}
-    {\lbx@us@mkdaterangetrunc@short@i{#1}{#2}}}
-
-\protected\gdef\lbx@us@mkdaterangetrunc@short@i#1#2{%
-  \begingroup
-    \blx@metadateinfo{#2}%
-    \iffieldundef{#2year}
-      {\blx@nounit}
-      {\printtext[{#2date}]{%
-         \datecircaprint
-         \iffieldundef{#2yeardivision}
-           {\ifdateyearsequal{#2}{#2end}
-             {\csuse{mkbibdate#1}{}{#2month}{#2day}}
-             {\csuse{mkbibdate#1}{#2year}{#2month}{#2day}%
-              \dateeraprint{#2year}}}
-           {\ifdateyearsequal{#2}{#2end}
-             {\csuse{mkbibyeardivisiondate#1}{}{#2yeardivision}}
-             {\csuse{mkbibyeardivisiondate#1}{#2year}{#2yeardivision}%
-              \dateeraprint{#2year}}}%
-         \dateuncertainprint
-         \iffieldundef{#2endyear}
-           {}
-           {\iffieldequalstr{#2endyear}{}
-              {\mbox{\bibdaterangesep}}
-              {\bibdaterangesep
-               \enddatecircaprint
-               \iffieldundef{#2endyeardivision}
-                 {\csuse{mkbibdate#1}{#2endyear}{#2endmonth}{#2endday}}
-                 {\csuse{mkbibyeardivisiondate#1}{#2endyear}{#2endyeardivision}}%
-               \enddateuncertainprint
-               \dateeraprint{#2endyear}}}}}%
-  \endgroup}
-
-\protected\gdef\lbx@us@mkdaterangetruncextra@long#1#2{%
-  \blx@if@printanytimes{#2}
-    {\mkdaterangefullextra{#1}{#2}}
-    {\lbx@us@mkdaterangetruncextra@long@i{#1}{#2}}}
-
-\protected\gdef\lbx@us@mkdaterangetruncextra@long@i#1#2{%
-  \begingroup
-    \blx@metadateinfo{#2}%
-    \iffieldundef{#2year}
-      {\blx@nounit}
-      {\printtext[{#2date}]{%
-         \datecircaprint
-         \iffieldundef{#2yeardivision}
-           {\ifdateyearsequal{#2}{#2end}
-             {\csuse{mkbibdate#1}{}{#2month}{#2day}}
-             {\csuse{mkbibdate#1}{#2year}{#2month}{#2day}%
-              \dateeraprint{#2year}}}
-           {\ifdateyearsequal{#2}{#2end}
-             {\csuse{mkbibyeardivisiondate#1}{}{#2yeardivision}}
-             {\csuse{mkbibyeardivisiondate#1}{#2year}{#2yeardivision}%
-              \dateeraprint{#2year}}}%
-         \dateuncertainprint
-         \iffieldundef{#2endyear}
-           {\printfield{extradate}}
-           {\iffieldequalstr{#2endyear}{}
-              {\printfield{extradate}%
-               \mbox{\bibdaterangesep}}
-              {\bibdaterangesep
-               \enddatecircaprint
-               \iffieldundef{#2endyeardivision}
-                 {\ifdateyearsequal{#2}{#2end}
-                   {\iffieldsequal{#2month}{#2endmonth}
-                      {\csuse{mkbibdate#1}{#2endyear}{}{#2endday}}
-                      {\csuse{mkbibdate#1}{#2endyear}{#2endmonth}{#2endday}}}
-                   {\csuse{mkbibdate#1}{#2endyear}{#2endmonth}{#2endday}}}
-                 {\csuse{mkbibyeardivisiondate#1}{#2endyear}{#2endyeardivision}}%
-               \printfield{extradate}%
-               \enddateuncertainprint
-               \dateeraprint{#2endyear}}}}}%
-  \endgroup}
-
-\protected\gdef\lbx@us@mkdaterangetruncextra@short#1#2{%
-  \blx@if@printanytimes{#2}
-    {\mkdaterangefullextra{#1}{#2}}
-    {\lbx@us@mkdaterangetruncextra@short@i{#1}{#2}}}
-
-\protected\gdef\lbx@us@mkdaterangetruncextra@short@i#1#2{%
-  \begingroup
-    \blx@metadateinfo{#2}%
-    \iffieldundef{#2year}
-      {\blx@nounit}
-      {\printtext[{#2date}]{%
-         \datecircaprint
-         \iffieldundef{#2yeardivision}
-           {\ifdateyearsequal{#2}{#2end}
-             {\csuse{mkbibdate#1}{}{#2month}{#2day}}
-             {\csuse{mkbibdate#1}{#2year}{#2month}{#2day}%
-              \dateeraprint{#2year}}}
-           {\ifdateyearsequal{#2}{#2end}
-             {\csuse{mkbibyeardivisiondate#1}{}{#2yeardivision}}
-             {\csuse{mkbibyeardivisiondate#1}{#2year}{#2yeardivision}%
-              \dateeraprint{#2year}}}%
-         \dateuncertainprint
-         \iffieldundef{#2endyear}
-           {\printfield{extradate}}
-           {\iffieldequalstr{#2endyear}{}
-              {\printfield{extradate}%
-            \mbox{\bibdaterangesep}}
-           {\bibdaterangesep
-            \enddatecircaprint
-            \iffieldundef{#2endyeardivision}
-              {\csuse{mkbibdate#1}{#2endyear}{#2endmonth}{#2endday}}
-              {\csuse{mkbibyeardivisiondate#1}{#2endyear}{#2endyeardivision}}%
-            \printfield{extradate}%
-            \enddateuncertainprint
-            \dateeraprint{#2endyear}}}}}%
-  \endgroup}
-
-\endinput

latex/bibliography.bib

@@ -962,16 +962,4 @@
 
 @thesis{zotero-622,
   type = {thesis}
-}
+}
-
-@thesis{rytter1993,
-  title = {Vibrational {{Based Inspection}} of {{Civil Engineering Structures}}},
-  author = {Rytter, Anders},
-  date = {1993},
-  institution = {Aalborg University},
-  location = {Aalborg},
-  url = {https://vbn.aau.dk/en/publications/vibrational-based-inspection-of-civil-engineering-structures},
-  abstract = {The thesis has been written in relation to two different research projects. Firstly, an offshore test programme, Integrated Experimental/Numerical Analysis of the Dynamic behavior  of offshore structures, which was performed at the department of Building Technology and Structural Engineering at the University of Aalborg from 1988 to 1991. Secondly, a research project, In-Field Vibration Based Inspection of Civil Engineering Structures, which has been performed as a pilot project by the Consulting Engineers Rambøll, Hannemann and Højlund in cooperation with the department of Building Technology and Structural Engineering at the University of Aalborg since the beginning of 1992. Both projects have been supported by the Danish Technical Research Council. Further, the first mentioned project was supported by the Danish Energy Agency. Their financial support is gratefully acknowledged.},
-  langid = {english},
-  keywords = {Beam,Bridges,Cracks,Damping,Offshore Platform,Piles,Structural Damage,VBI,Vibration Based Inspection}
-}

latex/chapters/01_introduction.tex

@@ -1,88 +1,25 @@
-\chapter{Pendahuluan}
+\chapter{PENDAHULUAN}
 
 \section{Latar Belakang}
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc consequat lectus dolor, a commodo odio suscipit nec. Aliquam posuere elit eget tellus dapibus, auctor ornare mi porttitor. Donec auctor aliquet nisl, quis convallis ligula rutrum id. Duis tortor ipsum, scelerisque vestibulum viverra eu, maximus vel mi. Nullam volutpat nunc et varius tempor. Vivamus convallis mi eros, aliquam semper dui tincidunt a. Morbi nunc dui, accumsan ac arcu nec, condimentum efficitur mauris. Etiam sed mauris semper, volutpat justo eu, placerat mauris. Suspendisse at erat eu arcu gravida mattis et id nunc. Aliquam malesuada magna odio, ac dictum erat vestibulum a. Mauris vel nisi sit amet elit tempor bibendum sit amet a velit. Morbi dignissim facilisis placerat.\par
 
-\indent Monitoring Kesehatan Struktur (\textit{Structural Health Monitoring} atau SHM) merupakan riset penting yang tersebar di berbagai disiplin ilmu, termasuk teknik dirgantara, teknik sipil, dan teknik mesin. Tujuan utama dari monitor kesehatan struktur adalah memastikan keamanan dan keandalan struktur dengan mendeteksi kerusakan sedini mungkin. Dengan mengombinasikan teknologi sensor yang canggih serta pengolahan data secara \textit{real-time}, sistem monitor kesehatan struktur menjadi kekuatan para insinyur untuk memonitor integritas struktur, strategi optimisasi \textit{maintenance}, dan memprediksi sisa umur struktur. 
+\begin{figure}
+    \centering
+    \includegraphics[width=0.5\linewidth]{frontmatter/img/slice1.jpg}
+    \caption{Enter Caption}
+    \label{fig:enter-label}
+\end{figure}
 
-\indent Sistem SHM yang tangguh mengikuti \textit{framework} secara hierarkis untuk mengidentifikasi dan menilai kerusakan struktural. Menurut \textcite{rytter1993}, lima tahapan SHM tersebut adalah: 
+Pellentesque vel accumsan lorem, id vulputate metus. Nulla mollis orci ante, et euismod erat venenatis eget. Proin tempus lobortis feugiat. Fusce vitae sem quis lacus iaculis dignissim ut eget turpis. Vivamus ut nisl in enim porttitor fringilla vel et mauris. Mauris quis porttitor magna. Pellentesque molestie viverra arcu at tincidunt. Maecenas non elit arcu.\par
-\begin{enumerate}
-    \item (Tingkat 1) Keberadaan Kerusakan: Menentukan apakah ada kerusakan pada struktur. Pada tahap ini, pengukuran getaran cukup untuk memastikan adanya kerusakan.
-    \item (Tingkat 2) Lokasi Kerusakan: Mengidentifikasi lokasi geometris kerusakan, baik kerusakan tunggal maupun ganda.
-    \item (Tingkat 3) Tipe Kerusakan: Mencirikan sifat kerusakan, yang dapat meliputi retakan, perubahan pada kondisi tumpuan, atau perubahan dalam sambungan struktur.
-    \item (Tingkat 4) Tingkat Keparahan: Mengukur secara kuantitatif seberapa parah kerusakan terjadi. Biasanya melalui eksperimen atau model terkalibrasi yang menggambarkan efek kerusakan, seperti penurunan kekakuan atau panjang retakan.
-    \item (Tingkat 5): Memprediksi sisa umur pakai struktur dengan mengandalkan pemantauan secara \textit{real-time} dan komprehensif serta model dengan fidelitas tinggi yang menggambarkan perkembangan kerusakan seiring waktu.
-\end{enumerate}
-Semakin tinggi tingkat identifikasi kerusakan, semakin besar pula kebutuhan akan sensor yang presisi, algoritma yang kompleks, serta parameter model yang akurat. Jika pada Tingkat 1 hanya diperlukan data yang terbatas untuk mendeteksi adanya kerusakan, maka Tingkat 5 membutuhkan akuisisi data secara \textit{real-time} dan canggih serta model prediktif yang memiliki fidelitas tinggi. 
 
-\par Tantangan utama terletak pada pengembangan sistem \acrshort{shm} yang mampu mengakomodasi berbagai tahapan identifikasi kerusakan secara efektif, baik dalam kondisi operasional normal maupun dalam situasi ekstrem seperti gempa bumi.
+Etiam feugiat enim sit amet tortor interdum lobortis. Curabitur elementum faucibus sapien. Morbi eget facilisis lorem. In sed suscipit metus. Etiam porttitor, libero sit amet sodales hendrerit, libero dolor hendrerit nulla, sed convallis risus leo posuere metus. Cras gravida ac elit viverra ultrices. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Maecenas dictum urna elit, nec eleifend nulla mattis sit amet. Pellentesque suscipit metus vitae leo suscipit, a vehicula quam pretium. Sed eu est ut risus convallis hendrerit a vulputate justo. Nulla sollicitudin quam ut risus euismod, quis consequat dui mattis. Mauris id eros varius, pellentesque quam quis, venenatis tellus. Nulla vitae condimentum nisl. Vestibulum suscipit scelerisque dui, non posuere purus finibus nec. Nulla ultrices felis quis vestibulum porta. Suspendisse potenti.\par
 
-% Penelitian ini difokuskan pada lima tahapan identifikasi kerusakan, dengan tujuan untuk mengembangkan pendekatan yang lebih komprehensif terhadap diagnosis kerusakan dan peningkatan akurasi pelokasian (Tingkat 2), sekaligus mengoptimalkan strategi penempatan sensor dan perancangan algoritma guna mencapai efisiensi biaya yang lebih tinggi.
+Nam tempus tincidunt interdum. Pellentesque at ligula ac massa semper efficitur vitae non ante. Suspendisse potenti. Cras vitae interdum erat, nec facilisis urna. Nulla commodo porttitor tellus non posuere. Vestibulum tristique ut urna quis porttitor. Sed pellentesque lectus sit amet ultrices aliquam. Aliquam erat volutpat. Nam dictum eu erat a mollis. Donec eget nulla vel risus aliquet suscipit sed at libero.\par
-\par Dalam konteks pengembangan sistem \acrshort{shm} yang efektif, perlu memperhatikan elemen struktural yang rentan terhadap kerusakan namun sering kali terabaikan dalam pemantauan konvensional. % <- Transition sentence
-Salah satu komponen struktural yang umum digunakan dalam penyambungan adalah sambungan baut (\textit{bolt joint}), yang dikenal karena kemudahan dalam perakitan dan penggunaannya. Namun, sambungan berulir ini rentan mengalami kelonggaran akibat beban kejut atau getaran terus-menerus \parencite{chen2017}. Kelonggaran baut yang tidak terdeteksi sejak dini dapat menyebabkan kerusakan serius pada struktur, sehingga identifikasi dini terhadap kerusakan sambungan baut menjadi krusial dalam bidang teknik sipil, mesin, dan kedirgantaraan. % <- Target
-Pemantauan kondisi sambungan ini tidak hanya relevan dalam konteks deteksi dini (Tingkat 1), tetapi juga sangat penting untuk diagnosis kerusakan dan penentuan lokasi secara akurat (Tingkat 2), seiring dengan meningkatnya kebutuhan akan sistem \acrshort{shm} yang responsif dan adaptif terhadap dinamika kerusakan struktural. % <- closing sentences
-
-\indent Deteksi kelonggaran baut telah dilakukan melalui berbagai metode. Kelompok pertama adalah inspeksi \textit{in-situ}, seperti inspeksi visual atau penggunaan alat mekanis seperti kunci torsi dan palu. Meskipun sederhana dan murah, metode ini sulit untuk mendeteksi kerusakan pada tahap awal \parencite{j.h.park2015}. Metode palu lebih efektif dibanding visual untuk mendeteksi awal kelonggaran, tetapi akurasinya dapat terganggu oleh kebisingan lingkungan, serta memakan waktu bila diaplikasikan pada struktur dengan banyak sambungan seperti jembatan \parencite{j.h.park2015,wang2013}.
-
-\indent Kelompok kedua menggunakan teknik berbasis penglihatan komputer seperti kamera dan pencitraan digital, termasuk deteksi rotasi kepala baut menggunakan CNN dan Faster R-CNN \parencite{zhang2020,zhao2019}. Meskipun teknik ini dapat mendeteksi kerusakan secara visual tanpa dipengaruhi oleh kebisingan akustik, tantangan tetap ada dalam hal penempatan kamera dan beban komputasi tinggi dari model \gls{deep-learning}, terutama dalam kondisi ruang yang sangat seperti mesin kendaraan atau turbin.
-
-\indent Kelompok ketiga dan yang menjadi fokus penelitian ini adalah teknik berbasis sensor, terutama pendekatan berbasis getaran (\textit{vibration-based}). Metode ini tidak hanya efektif dalam mengatasi keterbatasan teknik sebelumnya, tetapi juga mampu mendeteksi kelonggaran baut pada tahap awal secara baik dan akurat \parencite{nichols2004,razi2013}. Dalam penelitian ini, deteksi dilakukan melalui data akselerasi struktur yang diambil dari titik-titik sambungan dalam \textit{sistem grid} yang mewakili koneksi baut secara arah kolom.
-
-\indent Penelitian oleh \textcite{abdeljaber2017} merupakan tonggak penting dalam sistem pemantauan kesehatan struktur (SHM), dengan menerapkan 30 model \acrlong{1d-cnn} pada 30 sensor akselerometer dalam struktur grid QUGS. Pendekatan ini menunjukkan bahwa metode pembelajaran mendalam sangat efektif dalam mendeteksi dan melokalisasi kerusakan dengan presisi tinggi. Namun, metode tersebut memerlukan sumber daya komputasi yang besar karena pemrosesan paralel data mentah berdimensi tinggi dari seluruh sensor \parencite{yang2020, liu2022}. 
-
-\indent Menanggapi tantangan ini, studi lanjutan seperti \parencite{shahid2022, doi:10.1007/s13349-023-00715-3} memperkenalkan pendekatan VMD-HT-CNN yang menggabungkan teknik ekstraksi fitur berbasis Variational Mode Decomposition (VMD) dan Hilbert Transform (HT) sebelum klasifikasi CNN. Metode ini secara signifikan meningkatkan efisiensi pelatihan dan akurasi deteksi meskipun dengan jumlah sensor yang lebih sedikit. 
-
-\indent Berdasarkan celah ini, penelitian ini mengadopsi strategi pengurangan jumlah sensor menjadi dua per jalur kolom (atas dan bawah), merepresentasikan sambungan vertikal seperti susunan baut, untuk menyederhanakan model tanpa kehilangan akurasi deteksi kerusakan. Data diubah melalui transformasi STFT sebelum diklasifikasikan menggunakan berbagai model pembelajaran mesin klasik. Dengan evaluasi antar berbagai pengklasifikasi dan validasi silang antar kolom, studi ini berkontribusi pada pengembangan sistem SHM yang efisien, hemat biaya, dan mudah diimplementasikan.
 
 
 
-\section{Rumusan Masalah}
+Maecenas hendrerit pharetra bibendum. Donec ut tortor ac augue aliquam ullamcorper nec id eros. Quisque consectetur elementum ipsum vitae posuere. Sed ultricies ipsum nibh, vitae volutpat neque bibendum at. Morbi dictum metus eu bibendum malesuada. Nam scelerisque purus erat, id dictum nisl pretium vitae. Curabitur finibus commodo dui ac molestie. In sed sem ac dui dapibus ullamcorper. Aenean molestie nulla eu lorem maximus hendrerit. Vivamus viverra velit dolor, in vehicula eros facilisis at. Vivamus in rhoncus sem.
-Untuk memandu arah penelitian ini, beberapa permasalahan utama yang akan dibahas adalah sebagai berikut:
-
-\begin{enumerate}
-    \item Apakah sinyal getaran yang hanya diperoleh dari sensor pada bagian atas dan bawah suatu jalur kolom masih mampu merepresentasikan fitur-fitur penting yang diperlukan untuk mengklasifikasikan kerusakan struktur secara akurat?
-
-    \item Apakah penggabungan data dari beberapa jalur kolom dapat meningkatkan kemampuan generalisasi model, meskipun jumlah sensor pada tiap jalur dibatasi?
-
-    \item Apakah algoritma pemelajaran mesin klasik yang sederhana masih mampu menghasilkan model dengan kinerja yang cukup layak dibandingkan dengan model \textit{supervised} yang lebih kompleks ketika diterapkan pada skenario dengan input data sensor yang terbatas?
-\end{enumerate}
-% \section{Identifikasi Masalah}
-% \begin{itemize}
-%     \item Kebanyakan kerangka kerja pada monitoring kesehatan struktur membutuhkan deretan sensor yang banyak, hal ini dibutuhkan biaya yang tinggi dan kurang praktikal untuk banyak pengaplikasian.
-
-%     \item Banyak model dengan performa tinggi bergantung pada teknik pemelajaran mendalam, sehingga dibutuhkan sumberdaya komputasi yang tinggi dan memungkinkan kurangnya kemudahan dan keterjangkauan untuk aplikasikan.
-
-%     \item Kurangnya kesederhanaan, pendeketan umum yang menyeimbangkan penggunaan sensor dengan keandalan dalam lokalisasi kerusakan.
-% \end{itemize}
 \section{Lingkup Penelitian}
-Studi ini berfokus pada dataset yang tersedia secara publik didapat dari Queen's University Grandstand Simulator (QUGS), sebuah kerangka besi level laboratorium yang dipasang dengan tiga puluh titik sensor akselerometer dan \textit{white shaker noise}. Riset terdahulu telah dilakukan pengaplikasian pemelajaran mesin jaringan saraf terhadap seluruh sensor yang terpasang penuh pada setiap titik \textit{joint} untuk mencapai akurasi yang tinggi. Akan tetapi, pada praktiknya, instrumentasi penuh seperti ini terkadang kurang efektif dari segi biaya dan kurang layak dalam skala besar.
-
 \section{Tujuan Penelitian}
-\begin{enumerate}
-    \item Mengembangkan alur sistem (\textit{pipeline}) pemantauan kesehatan struktur (Structural Health Monitoring/SHM) yang disederhanakan dengan hanya menggunakan sepasang sensor di ujung-ujung struktur.
-
-    % \item Memperlakukan setiap grup kolom sensor sebagai elemen balok satu dimensi yang disederhanakan, dan mengevaluasi apakah karakteristik kerusakan tetap terjaga dalam energi getaran yang ditransmisikan antara kedua ujungnya.
-
-    % \item Menyusun setiap grup kolom sebagai satu dataset terpisah dan melakukan lima pengujian berbeda, di mana masing-masing grup kolom berperan sebagai data validasi secara bergantian.
-
-    % \item Menyertakan data dari setiap grup kolom ke dalam data pelatihan untuk membentuk satu model umum yang dapat digunakan untuk seluruh grup kolom.
-
-    \item Mengeksplorasi kemungkinan generalisasi satu model terhadap berbagai jalur kolom hanya dengan memanfaatkan data dari sensor pada kedua ujung kolom.
-\end{enumerate}
-
-% Dalam merespon hal tersebut, penelitian ini memperkenalkan pendekatan baru yang menekankan efisiensi pada penanganan data dan interpretasi fisik. Data pada sensor-sensor yang terpasang pada struktur grid ini dikelompokkan menjadi beberapa grup kolom, dan hanya menyisakan sensor awal dan sensor paling akhir dari setiap grup sensor sebagai input pengklasifikasian. Terdapat hipotesis bahwa energi getaran bergerak di sepanjang jalur kolom terjaga secara cukup baik antara ujung-ujung sensor untuk memungkinkan algoritma pemelajaran mesin, seperti Support-Vector Machine (SVM), Bagged Trees, Random Forest, Decision Tree, KNN, LDA, dan XGBoost, medeteksi dan mengklasifikasi secara akurat letak kerusakan.
-
 \section{Manfaat Penelitian}
-
+% \subsubsection{Dolor}
-Penelitian ini memberikan beberapa manfaat yang diharapkan dapat berkontribusi dalam pengembangan sistem deteksi kerusakan struktur, antara lain:
-
-\begin{enumerate}
-    \item Penelitian ini tidak berfokus pada pengembangan arsitektur model baru maupun penerapan \textit{transfer learning}, melainkan pada perancangan alur (\textit{pipeline}) klasifikasi yang sederhana dan mudah dipahami sebagai solusi tahap awal untuk pengembangan sistem monitor kesehatan struktur.
-    
-    \item Dengan pemilihan titik sensor strategis yang terbatas (hanya di ujung atas dan bawah jalur kolom \textit{grid}) serta prapemrosesan berbasis transformasi STFT, penelitian ini menunjukkan bahwa efisiensi dapat dicapai tanpa mengorbankan akurasi secara signifikan.
-    
-    \item Studi ini membuktikan bahwa algoritma pembelajaran mesin klasik seperti \gls{svm}, KNN, dan LDA masih mampu memberikan performa model yang kompetitif dalam klasifikasi kerusakan, apabila dipadukan dengan ekstraksi fitur yang tepat.
-    
-    \item Hasil penelitian ini diharapkan dapat menjadi alternatif sistem SHM yang lebih terjangkau dan praktis untuk diterapkan pada struktur nyata, khususnya dalam kondisi keterbatasan sumber daya.
-    
-    \item Rangkaian eksperimen dan pendekatan sistematis dalam penelitian ini dapat dijadikan tolok ukur atau \textit{baseline} untuk studi komparatif selanjutnya dan pengembangan model arsitektur yang lebih kompleks.
-\end{enumerate}

latex/chapters/02_literature_review.tex

@@ -1,63 +0,0 @@
-\chapter{TINJAUAN PUSTAKA DAN LANDASAN TEORI}
-\section{Tinjauan Pustaka}
-
-\begin{figure}[!ht]
-    \centering
-    \includegraphics[width=0.5\linewidth]{frontmatter/img/slice1.jpg}
-    \caption{Enter Caption}
-    \label{fig:enter-label}
-\end{figure}
-
-\section{Dasar Teori}
-
-This chapter discusses the theoretical basis used in this research, including signal processing techniques and machine learning algorithms. These foundations form the core of the method used for vibration-based damage localization in a beam structure.
-
-\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.
-
-\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.
-
-\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.
-% \subsubsection{Dolor}

latex/chapters/03_methodology.tex

@@ -1,67 +0,0 @@
-\chapter{METODE PENELITIAN}
-
-\section{Bahan dan Materi}
-
-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:original-data}.
-
-\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}
-\clearpage
-
-\section{Alat}
-
-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, SciPy, dan Pandas} – digunakan untuk manipulasi sinyal dan perhitungan numerik.
-    \item \textbf{Matplotlib} – digunakan untuk menghasilkan spektrum STFT (Short-Time Fourier Transform).
-    \item \textbf{PyTorch 2.3} – digunakan untuk membangun dan melatih model dengan algoritma pemelajaran mesin klasik.
-    \item \textbf{Google Colab / Komputer Lokal} – digunakan untuk pelatihan model dan percobaan eksperimental.
-\end{itemize}
-
-
-% \section{Place and Time}
-% This research was conducted between [Month] and [Month] 2025 at the [Your Lab or Campus] using publicly available data. No new data collection was performed. All computational processes, including preprocessing, model training, and evaluation, were executed using Google Colab and a local machine.
-
-\section{Langkah-Langkah Penelitian}
-Alur keseluruhan penelitian ini dilakukan melalui tahapan-tahapan sebagai berikut:
-
-\begin{enumerate}
-    \item \textbf{Akuisisi Data:} Mengunduh dataset dari Abdeljaber et al. 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}
-
-\section{Data Analysis}
-
-The processed data were analyzed using classification metrics. The trained model's output was evaluated based on the ability to correctly identify damaged vs. undamaged scenarios. The main metrics used were:
-
-\begin{itemize}
-  \item \textbf{Accuracy:} Overall correct predictions across all classes.
-  \item \textbf{Confusion Matrix:} To visualize classification performance across damage cases.
-  \item \textbf{Precision and Recall:} For measuring the model's performance in detecting damage cases specifically.
-\end{itemize}
-
-Additionally, experiments were repeated for varying numbers of sensors to simulate reduced-sensor configurations, analyzing how model performance changed with less input data.

latex/chapters/04_results.tex

@@ -1,13 +0,0 @@
-\chapter{Hasil Penelitian dan Pembahasan}
-\begin{table}[ht]
-    \centering
-    \begin{tabular}{c|c}
-         &  \\
-         & 
-    \end{tabular}
-    \caption{Caption}
-    \label{tab:my_label}
-\end{table}
-\section{}
-\section{}
-\section{}

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

@@ -1,8 +1,8 @@
-\chapter{LITERATURE REVIEW AND THEORITICAL FOUNDATION}
+\chapter{LITERATURE REVIEW AND THEORETICAL FOUNDATION}
 \section{Literature Review}
 \input{chapters/id/02_literature_review/literature_review/abdeljaber2017}
 
-\section{Theoritical Foundation}
+\section{Theoretical Foundation}
 \input{chapters/id/02_literature_review/theoritical_foundation/stft}
 \input{chapters/id/02_literature_review/theoritical_foundation/machine_learning}
 

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

@@ -1,4 +1,4 @@
-\chapter{Tinjauan Pustaka dan Landasan Teori}
+\chapter{TINJAUAN PUSTAKA DAN LANDASAN TEORI}
 \section{Tinjauan Pustaka}
 % \input{chapters/id/02_literature_review/index}
 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 aplikasi \textit{real-time} karena beban komputasi pada fase ekstraksi fitur.

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

@@ -1,6 +1,6 @@
 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}.
+\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.
 

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

@@ -1,77 +1,42 @@
 \section{Analisis Data}
-
-% Dalam studi ini, setiap sensor menghasilkan data akselerasi yang direkam sebagai sebuah vektor numerik kontinu. Secara matematis, 
-% setiap data sensor didefinisikan sebagai
-% \begin{equation}
-% n \in \mathbb{R}^{262144},
-% \end{equation}
-% di mana \(n\) adalah vektor berisi 262144 sampel pengukuran akselerasi seperti yang dijelaskan pada persamaan~\ref{eq:sample}.
-
-% Selanjutnya, data akselerasi untuk 30 sensor (atau \textit{node}) disimpan dalam sebuah berkas \texttt{.TXT}. Maka, setiap berkas tersebut dapat direpresentasikan sebagai matriks
-% \begin{equation}
-% N \in \mathbb{R}^{262144 \times 30},
-% \end{equation}
-% di mana setiap kolom dari \(N\) merupakan data akselerasi untuk satu sensor dari 30 sensor yang ada.
-
 \subsection{Grid, Kode \textit{Joint}, dan Nama File}
 
-Masing-masing *sensor node* diberi nama menurut indeks \(n\) (dengan \(n = 0,1,\dots,29\)).  
+% \begin{figure}[ht]
-Berkas data mentah tiap node disimpan dalam berkas teks berformat
+%     \centering
-\texttt{zzzAD<n>.TXT}; penamaannya dapat dirumuskan sebagai  
+%     \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}:
-Z_{n} \;=\; \texttt{``zzzAD}n\texttt{.TXT''}, 
-\qquad n = 1,\dots,30.
-\]
-
-Pada pembahasan selanjutnya, simbol \(Z_{n}\) dipakai sebagai penunjuk
-berkas data untuk node ke-\(n\). 
-Untuk merujuk satu kanal (kolom) tertentu di dalam matriks
-\(\mathbf{D}^{(n)}\), digunakan notasi
-
-\[
-\gls{not:damage_file}_{s}^{(\gls{not:joint_index})} \in \mathbb{R}^{262144},
-\]
-
-dengan ketentuan:
-
-* superskrip \((\gls{not:joint_index})\) menandakan indeks kasus kerusakan
-  (1–30),
-* subskrip \(s\) menandakan indeks kanal sensor yang dipilih
-  (\(s = 1,\dots,30\)).
-
-Dengan demikian,
-\(\gls{not:damage_file}_{s}^{(n)}\) merepresentasikan sebuah vektor
-\(262144 \times 1\) yang berisi deret waktu hasil pengukuran kanal
-\(s\) pada skenario kerusakan ke-\(n\).
-
-\subsection{Pemetaan Sensor ke Dalam Folder (Damage-case)}
-
-Semua tiga puluh \textit{node} dikelompokkan ke dalam enam folder yang merepresentasikan enam skenario kerusakan, masing-masing dilabeli \(d_{i}\) dengan \(i=0,\dots,5\). Setiap folder mengandung tepat lima \textit{node} berurutan, sehingga didefinisikan:
 \begin{equation*}
-\gls{not:damage_file_set_case}_{i} = \bigl\{
+n_{k}^{F_{k}}
-\,\mathbf{D}_{5i}^{(5i)},
+\quad\text{adalah \textit{node} dengan indeks }k\text{ yang datanya diambil dari \textit{file} }F_{k}.
-\;\mathbf{D}_{5i+1}^{(5i+1)},
+\end{equation*}
-\;\mathbf{D}_{5i+2}^{(5i+2)},
+
-\;\mathbf{D}_{5i+3}^{(5i+3)},
+\subsection{Pemetaan Sensor}
-\;\mathbf{D}_{5i+4}^{(5i+4)}
+
-\bigr\},
+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*}
-\begin{equation}
+Atau secara konkrit, 
-    \mathcal{D}_i = \bigl\{
-\end{equation}
-Sebagai contoh 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}\},\\[1ex]
+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}\},\\[1ex]
+d_1&=\{n_{5}^{F_5},\;n_{6}^{F_6},\;n_{7}^{F_7},\;n_{8}^{F_8},\;n_{9}^{F_9}\}\\
-&\;\;\vdots\\[1ex]
+\;\;\vdots\\
-d_5 &= \{n_{25}^{F_{25}},\;n_{26}^{F_{26}},\;n_{27}^{F_{27}},\;n_{28}^{F_{28}},\;n_{29}^{F_{29}}\}.
+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)}
 
-Untuk mensimulasikan tata letak sensor terbatas, dari setiap folder kerusakan hanya diambil \textit{node} pertama dan terakhir. Subset domain waktu ini dilambangkan sebagai
+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\},
@@ -80,28 +45,29 @@ d_{i}^{\mathrm{TD}}
 
 \subsection{Ekstraksi Fitur}
 
-Operator STFT \(\mathcal{T}\) didefinisikan untuk memetakan sinyal domain waktu mentah (vektor dengan panjang \(L=262144\)) menjadi spektrogram berukuran \(513\times513\). Langkah-langkahnya adalah:
+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) Fungsi jendela:}\quad
+\text{(1) Window function:}\quad
-w[n] &= \frac{1}{2}\Bigl(1 - \cos\frac{2\pi n}{N_w - 1}\Bigr),
+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},\\[1ex]
+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 untuk \textit{node} \(k\) sebagai
+
+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 operator STFT dapat dituliskan sebagai:
+Dengan demikian operatornya adalah
 \begin{equation*}
 \mathcal{T}:\; n_{k}^{F_{k}}\in\mathbb{R}^{262144}
 \;\longmapsto\;
@@ -110,7 +76,7 @@ Dengan demikian operator STFT dapat dituliskan sebagai:
 
 \subsection{Subset Domain Frekuensi}
 
-Operator \(\mathcal{T}\) diterapkan pada \textit{node} ujung-ujung yang telah dipilih, sehingga diperoleh:
+Kemudian, \(\mathcal{T}\) diterapkan pada \textit{node} ujung-ujung yang telah dipilih, dihasilkan:
 \begin{equation*}
 d_{i}^{\mathrm{FD}}
 = \bigl\{\,
@@ -123,7 +89,7 @@ d_{i}^{\mathrm{FD}}
 
 \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 data dari keenam kasus kerusakan digabungkan menjadi dua himpunan:
+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}
 =
@@ -146,15 +112,15 @@ Sensor-sensor ujung bagian bawah dilabeli sebagai Sensor A dan sensor-sensor uju
 
 \subsection{Perakitan Baris dan Pelabelan}
 
-Setiap spektrogram berukuran \(513\times513\) diartikan sebagai 513 vektor fitur berdimensi 513. Untuk setiap kasus kerusakan \(i\) dan sensor \(s\), vektor fitur ini direplikasi sebanyak 5 kali (indeks pengulangan \(r\in\{0,\dots,4\}\)) dan diambil masing-masing baris/kolom ke-\(t\) dengan
+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}.
+\mathbf{x}_{i,s,r,t}\in\mathbb{R}^{513}
 \end{equation*}
-Label skalar untuk kasus kerusakan dinyatakan sebagai
+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*}
-Selanjutnya, fungsi \textit{slicing} didefinisikan sebagai
+Kemudian didefinisikan fungsi \textit{slicing} sebagai
 \begin{equation*}
 \Lambda(i,s,r,t)
 \;=\;
@@ -167,7 +133,7 @@ Selanjutnya, fungsi \textit{slicing} didefinisikan sebagai
 
 \subsection{Bentuk Akhir Data untuk Pelatihan}
 
-Seluruh baris dari enam kasus kerusakan, lima pengulangan, dan 513 potongan waktu digabungkan menjadi dataset untuk satu sisi sensor:
+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)}
 =
@@ -179,7 +145,7 @@ 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 adalah:
+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

@@ -1,4 +1,4 @@
-\chapter{Metode Penelitian}
+\chapter{METODE PENELITIAN}
 
 \input{chapters/id/03_methodology/material/index}
 \input{chapters/id/03_methodology/tool/index}

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

@@ -23,4 +23,4 @@ Struktur dataset yang digunakan ditampilkan pada Gambar~\ref{fig:specimen-photo}
     \includegraphics[width=0.75\linewidth]{chapters/img/specimen.png}
     \caption{Bentuk benda uji}
     \label{fig:specimen-photo}
-\end{figure}
+\end{figure}

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

@@ -1,10 +1,9 @@
-Dataset yang digunakan dalam penelitian ini bersumber dari basis data getaran yang dipublikasi oleh \textcite{abdeljaber2017}. Dataset tersebut dapat diakses dan diunduh melalui tautan DOI berikut:  
+Dataset yang digunakan dalam penelitian ini bersumber dari basis data getaran yang dipublikasi oleh \textcite{abdeljaber2017}.
-\url{https://doi.org/10.17632/52rmx5bjcr.1}
 
 Dataset terdiri dari dua folder:
 \begin{itemize}
-  \item \texttt{Dataset A/} – digunakan untuk pelatihan (training)
+  \item \texttt{Dataset A/} – biasanya digunakan untuk pelatihan (training)
-  \item \texttt{Dataset B/} – digunakan untuk pengujian (testing)
+  \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:
@@ -21,34 +20,14 @@ Sepuluh baris pertama dari setiap berkas berisi metadata yang menjelaskan konfig
   \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 $t = 256$ detik, sehingga menghasilkan:
+Setiap sinyal di-\textit{sampling} pada frekuensi $f_s = 1024$ Hz dan direkam selama durasi total $T = 256$ detik, sehingga menghasilkan:
-\begin{align}
-\gls{not:signal} &= \gls{not:sampling_freq} \cdot \gls{not:time_length} \nonumber \\
-  &= 1024 \cdot 256 \nonumber \\
-  &= 262144 \quad \text{sampel per kanal} \label{eq:sample}
-\end{align}
 
-Dengan demikian, setiap berkas \verb|zzzAD|$n$\verb|.TXT| dapat direpresentasikan sebagai matriks:
+\begin{equation*}
-\begin{equation}
+N = f_s \cdot T = 1024 \times 256 = 262{,}144 \quad \text{sampel per kanal}
-    \mathbf{D}^{(n)} \in \mathbb{R}^{262144 \times 30}, \quad n = 1, \dots, 30
+\end{equation*}
-\end{equation}
-di mana $n$ mengacu pada indeks kasus (1–30 = kerusakan pada \textit{joint} ke-$n$), dan berkas tanpa kerusakan pada seluruh \textit{joint}, \verb|zzzAU|\verb|.TXT|, direpresentasikan dengan matriks:
-\begin{equation}
-    \mathbf{U} \in \mathbb{R}^{262144 \times 30}
-\end{equation}
 
-
+Dengan demikian, setiap berkas dapat direpresentasikan sebagai matriks:
-Kemudian \textit{dataset} A dapat direpresentasikan sebagai matriks:
+\begin{equation*}
-\begin{equation}
+\mathbf{X}^{(c)} \in \mathbb{R}^{262{,}144 \times 31}, \quad c = 0, 1, \dots, 30
-  \gls{not:dataset_A}
+\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.
-  \Bigl\{
-      \mathbf{U} \in \mathbb{R}^{262144 \times 30}
-  \Bigr\}
-  \;\cup\;
-  \Bigl\{
-      \mathbf{D}^{(n)} \in \mathbb{R}^{262144 \times 30}
-      \;\bigm|\;
-      n = 1, \dots, 30
-  \Bigr\}.
-\end{equation}

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

@@ -3,7 +3,7 @@ Alur keseluruhan penelitian ini dilakukan melalui tahapan-tahapan sebagai beriku
 
 \begin{figure}[H]
     \centering
-    \includegraphics[width=0.3\linewidth]{chapters/img/flow.png}
+    \includegraphics[width=0.3\linewidth]{chapters/id/flow.png}
     \caption{Diagram alir tahapan penelitian}
     \label{fig:flowchart}
 \end{figure}

latex/chapters/id/03_methodology/steps/preprocessing/data_augmentation.tex

@@ -1,24 +0,0 @@
-We now introduce a simple “data‐augmentation” logic across repeated tests as:
-\[
-\mathbf{c}_{j}^{(i)}
-\;=\;
-\Bigl[S_{0+j}^{(i)},\,S_{5+j}^{(i)},\,S_{10+j}^{(i)},\,S_{15+j}^{(i)},\,S_{20+j}^{(i)},\,S_{25+j}^{(i)}\Bigr]^{T}
-\;\in\mathbb{R}^{6}\!,
-\]
-where \(S_{k}^{(i)}\) is the \(k\)th sensor’s time‐frequency feature vector (after STFT+log‐scaling) from the \(i\)-th replicate of scenario \(j\).
-
-For each fixed scenario \(j\), collect the five replicates into the set
-\[
-\mathcal{D}^{(j)}
-=\bigl\{\mathbf{c}_{j}^{(1)},\,\mathbf{c}_{j}^{(2)},\,\mathbf{c}_{j}^{(3)},\,\mathbf{c}_{j}^{(4)},\,\mathbf{c}_{j}^{(5)}\bigr\},
-\]
-so \(|\mathcal{D}^{(j)}|=5\).  Across all six scenarios, the total augmented dataset is
-\[
-\mathcal{D}
-=\bigcup_{j=0}^{5}\mathcal{D}^{(j)}
-=\bigl\{\mathbf{c}_{j}^{(i)}: j=0,\dots,5,\;i=1,\dots,5\bigr\},
-\]
-with \(\lvert\mathcal{D}\rvert = 6 \times 5 = 30\) samples.
-
-Each \(\mathbf{c}_{j}^{(i)}\) hence represents one ``column‐based’’ damage sample,
-and the collection \(\mathcal{D}\) serves as the input set for subsequent classification.  

latex/chapters/id/03_methodology/steps/preprocessing/data_representation.tex

@@ -1,9 +0,0 @@
-Let $\mathcal{G}$ represent the $6 \times 5$ structural grid, where each node is denoted with row and column as $N_{r,c}$ with $r \in \{1,2,...,6\}$ and $c \in \{1,2,...,5\}$.\\
-
-\begin{figure}[ht]
-    \centering
-    % \includegraphics[width=\textwidth]{}
-    \input{chapters/img/specimen}
-    \caption{Diagram joint and sensors placement}
-    \label{fig:specimen}
-\end{figure}

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

@@ -1,66 +0,0 @@
-\subsection{Signal Normalization}
-Each raw acceleration time series 
-\(\mathbf{a}_{k}(n)\), \(n = 0,1,\dots,N-1\) with \(N=262144\) samples (collected at \(f_s=1024\) Hz over 256 s) :contentReference[oaicite:0]{index=0} is first standardized to zero mean and unit variance:
-\[
-\tilde a_{k}(n)
-=\frac{a_{k}(n)-\mu_{k}}{\sigma_{k}},
-\quad
-\mu_{k}=\frac{1}{N}\sum_{n=0}^{N-1}a_{k}(n),
-\quad
-\sigma_{k}=\sqrt{\frac{1}{N}\sum_{n=0}^{N-1}\bigl(a_{k}(n)-\mu_{k}\bigr)^{2}}.
-\]
-
-\subsection{Framing and Windowing}
-The normalized signal \(\tilde a_{k}(n)\) is chopped into overlapping frames of length \(W\) samples with hop size \(H\). The \(p\)-th frame is
-\[
-x_{k,p}[m]
-=\tilde a_{k}(pH + m)\,w[m],
-\quad
-m=0,1,\dots,W-1,
-\]
-where \(w[m]\) is a chosen window function (e.g., Hamming).
-
-\subsection{Short-Time Fourier Transform (STFT)}
-For each frame \(x_{k,p}[m]\), compute its STFT:
-\[
-S_{k}(f,p)
-=\sum_{m=0}^{W-1}x_{k,p}[m]\;e^{-j2\pi\,f\,m/W},
-\]
-where \(f=0,1,\dots,W-1\) indexes frequency bins :contentReference[oaicite:1]{index=1}.
-
-\subsection{Spectrogram and Log-Magnitude}
-Form the magnitude spectrogram
-\[
-M_{k}(f,p)
-=\bigl|S_{k}(f,p)\bigr|,
-\]
-and apply log scaling for numerical stability:
-\[
-L_{k}(f,p)
-=\log\bigl(1 + M_{k}(f,p)^{2}\bigr).
-\]
-This yields a time–frequency representation
-\(\mathbf{L}_{k}\in\mathbb{R}^{F\times P}\), with \(F\) frequency bins and \(P\) frames.
-
-\subsection{Feature Matrix Assembly}
-For each column \(j\in\{1,\dots,5\}\), select only the two endpoint sensors:
-\[
-\mathbf{L}_{\text{bot},j} = \mathbf{L}_{(j)},\quad
-\mathbf{L}_{\text{top},j} = \mathbf{L}_{(25+j)},
-\]
-and stack them:
-\[
-\mathbf{F}_{j}
-=
-\begin{bmatrix}
-\mathbf{L}_{\text{bot},j} \\[6pt]
-\mathbf{L}_{\text{top},j}
-\end{bmatrix}
-\;\in\mathbb{R}^{2F\times P}.
-\]
-Finally, flatten into a feature vector:
-\[
-\mathbf{f}_{j}
-=\operatorname{vec}\bigl(\mathbf{F}_{j}\bigr)
-\;\in\mathbb{R}^{2FP}.
-\]

latex/chapters/id/03_methodology/steps/preprocessing/limited_sensor_approach.tex

@@ -1,20 +0,0 @@
-For the vertical column approach with limited sensors 
-% we
-are defined as column vector $\mathbf{c}_j$:
-
-\begin{equation}
-\mathbf{c}_j^{(i,d)} = [S_{0+j}^{(i+d)}, S_{5+j}^{(i+d)}, S_{10+j}^{(i+d)}, S_{15+j}^{(i+d)}, S_{20+j}^{(i+d)}, S_{25+j}^{(i+d)}]^T
-\end{equation}
-\begin{equation}
-\mathbf{D}^{(i)} = [\mathbf{c}_0^{(i,i+1)}, \mathbf{c}_1^{(i,i+6)}, \mathbf{c}_2^{(i,i+11)}, \mathbf{c}_3^{(i,i+16)}, \mathbf{c}_4^{(i,i+21)}]^T
-\end{equation}
-
-where $j \in \{0, 1,2,3,4\}$ represents the column index.
-
-For the limited sensor case focusing on endpoints only, we use:
-
-\begin{equation}
-\mathbf{c}^{\text{limited}}_j = [S_{0+(j-1)}, S_{25+(j-1)}]^T
-\end{equation}
-
-representing only the lower sensor (sensor A) and upper sensor (sensor B) of column $j$.

latex/chapters/id/03_methodology/steps/preprocessing/time_series_data.tex

@@ -1,23 +0,0 @@
-Untuk setiap sensor $S_k$ dengan $k \in \{0,1,2,...,29\}$ diletakkan pada \textit{node} $N_{k}$, deret deret akselerasi waktu didefinisikan sebagai:
-
-\begin{equation}
-\mathbf{a}_{k}(t) = [a_{k}(t_1), a_{k}(t_2), \ldots, a_{k}(t_{262144})]
-\end{equation}
-
-% where $N = 262144$ samples at a sampling frequency of 1024 Hz over 256 seconds.
-% $k \in \{i,(i+1),...,(i+(r\times j))\}$
-
-Satu dataset utuh untuk setiap skenario ($A|B$) dapat direpresentasikan sebagai matrix $\mathbf{X}_d \in \mathbb{R}^{30 \times 262144}$:
-
-\begin{equation}
-\mathbf{{X}_d}^\intercal = 
-\begin{bmatrix}
-\mathbf{a}_{0}(t) \\
-\mathbf{a}_{1}(t) \\
-\mathbf{a}_{2}(t) \\
-\vdots \\
-\mathbf{a}_{29}(t)
-\end{bmatrix}
-\end{equation}
-
-di mana $d \in \{0, 1, 2, \ldots, 30\}$ merepresentasikan skenario kerusakan, dengan $d=0$ mengindikasikan tanpa kasus kerusakan.

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

@@ -1,8 +1,8 @@
 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:accel393}) untuk merekam respons percepatan pada sebagian besar titik pengukuran.
+    \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:accel393}) digunakan pada beberapa lokasi untuk validasi tambahan.
+    \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}).

latex/chapters/img/specimen.tex

@@ -1,15 +1,13 @@
-$$
 \begin{matrix}
-S_{29} & \text{---} & S_{28} & \text{---} & S_{27} & \text{---} & S_{26} & \text{---} & S_{25} \\
+N_{6,5} & \text{---} & N_{6,4} & \text{---} & N_{6,3} & \text{---} & N_{6,2} & \text{---} & N_{6,1} \\
 \vert    &          & \vert    &          & \vert    &          & \vert    &          & \vert    \\
-S_{24} & \text{---} & S_{23} & \text{---} & S_{22} & \text{---} & S_{21} & \text{---} & S_{20} \\
+N_{5,5} & \text{---} & N_{5,4} & \text{---} & N_{5,3} & \text{---} & N_{5,2} & \text{---} & N_{5,1} \\
 \vert    &          & \vert    &          & \vert    &          & \vert    &          & \vert    \\
-S_{19} & \text{---} & S_{18} & \text{---} & S_{17} & \text{---} & S_{16} & \text{---} & S_{15} \\
+N_{4,5} & \text{---} & N_{4,4} & \text{---} & N_{4,3} & \text{---} & N_{4,2} & \text{---} & N_{4,1} \\
 \vert    &          & \vert    &          & \vert    &          & \vert    &          & \vert    \\
-S_{14} & \text{---} & S_{13} & \text{---} & S_{12} & \text{---} & S_{11} & \text{---} & S_{10} \\
+N_{3,5} & \text{---} & N_{3,4} & \text{---} & N_{3,3} & \text{---} & N_{3,2} & \text{---} & N_{3,1} \\
 \vert    &          & \vert    &          & \vert    &          & \vert    &          & \vert    \\
-S_{9}  & \text{---} & S_{8}  & \text{---} & S_{7}  & \text{---} & S_{6}  & \text{---} & S_{5}  \\
+N_{2,5} & \text{---} & N_{2,4} & \text{---} & N_{2,3} & \text{---} & N_{2,2} & \text{---} & N_{2,1} \\
 \vert    &          & \vert    &          & \vert    &          & \vert    &          & \vert    \\
-S_{4}  & \text{---} & S_{3}  & \text{---} & S_{2}  & \text{---} & S_{1}  & \text{---} & S_{0}  \\
+N_{1,5} & \text{---} & N_{1,4} & \text{---} & N_{1,3} & \text{---} & N_{1,2} & \text{---} & N_{1,1} \\
-\end{matrix}
+\end{matrix}
-$$

latex/diff.tex

@@ -1,5 +0,0 @@
-\RequirePackage{shellesc}
-\ShellEscape{latexdiff --flatten main-staged1.tex main.tex > main-d.tex}
-\input{main-d}
-\documentclass{thesis}
-\title{Latexdiff}

latex/flatten.tex

@@ -1,4 +0,0 @@
-\RequirePackage{shellesc}
-\ShellEscape{latexpand main.tex > main-staged1.tex}
-\documentclass{book}
-\title{Demonstrating latexdiff}

latex/frontmatter/abstract.tex

@@ -1,9 +0,0 @@
-
-\chapter{\abstractname}
-\singlespacing
-\noindent Monitoring Kesehatan Struktur (SHM) secara tradisional membutuhkan banyak sensor dan model yang kompleks, sehingga tidak praktikal untuk pengaplikasian di lapangan. Studi ini menginvestigasi apakah sinyal yang direkam hanya pada sensor ujung atas dan bawah dari kolom-kolom grup sensor cukup untuk memberikan informasi yang akurat pada klasifikasi lokasi kerusakan. Pengujian dilakukan pada dataset QUGS, sebuhah struktur \textit{grid} baja dengan jumlah \textit{node} 6$\times$5 terpasang sensor akselerometer dan digetarkan pada \textit{white noise shaker}. Sinyal getaran dikonversi menjadi fitur frekuensi-waktu menggunakan STFT dan lima algoritma \textit{machine learning} digunakan untuk klasifikasi. Setiap kolom grup dievaluasi dengan \textit{cross-validation} untuk menguji generalisasi model. Hasil menunjukkan bahwa dengan jumlah sensor yang tereduksi, lima algoritma \textit{machine learning} mencapai akurasi klasifikasi lebih dari 90\%. Studi ini menunjukkan bahwa posisi sensor yang strategis dan ekstraksi fitur berbasis STFT cukup untuk mendeteksi lokasi kerusakan secara efektif dan menjadi alternatif yang simpel untuk pendekatan monitoring kesehatan struktur yang kompleks.
-
-\cleardoublepage
-\setmainlanguage{english}
-\chapter{\abstractname}
-\noindent \textit{Structural Health Monitoring (SHM) traditionally requires dense sensor arrays and complex models, which can be impractical for field deployment. This study investigates whether vibration signals captured from only the top and bottom sensors of grouped structural columns retain sufficient information for accurate damage location classification. Experiments are conducted on the QUGS dataset, which represents a 6$\times$5 steel-frame grid structure under controlled laboratory conditions. Vibration signals are converted into time-frequency features using the Short-Time Fourier Transform (STFT), and five classical machine learning algorithms, including Support Vector Machines (SVM), are used for classification. Each vertical column group is evaluated through cross-validation to test generalisation across paths. Results show that even with reduced sensor input, all five algorithms achieve over 90\% classification accuracy. These findings demonstrate that strategic sensor placement and STFT-based features are sufficient to detect structural damage effectively, offering a simple and interpretable alternative to more complex SHM approaches}

latex/frontmatter/acknowledgement.tex

@@ -1,12 +0,0 @@
-\chapter{Lembar Pernyataan}
-
-Saya yang bertanda tangan di bawah ini:
-\renewcommand{\arraystretch}{1.2}
-\begin{center}
-\begin{tabular}{llp{10cm}}
-\textbf{Nama} & : & \theauthor \\
-\textbf{NIM} & : & \theauthorid \\
-\textbf{Judul} & : & \thetitle \\
-\end{tabular}
-\end{center}
-Menyatakan bahwa tugas akhir in merupakan bagian dari penilitian payung dosen pembimbing yang berjudul \thetitle dan didanai melalui skema hibah ... pada tahun oleh tahun anggaran ... dengan nomor hibah ...                                   

latex/frontmatter/acronym.tex

@@ -1,16 +0,0 @@
-% Define an abbreviation (acronym)
-% Acronyms for the thesis
-\newacronym{ml}{ML}{machine learning}
-\newacronym{stft}{STFT}{short-time fourier transform}
-\newacronym{ai}{AI}{artificial intelligence}
-\newacronym{dl}{DL}{deep learning}
-\newacronym{nn}{NN}{neural network}
-\newacronym{fft}{FFT}{fast fourier transform}
-\newacronym{svm}{SVM}{support vector machine}
-\newacronym{cnn}{CNN}{convolutional neural network}
-\newacronym{rnn}{RNN}{recurrent neural network}
-\newacronym{vbi}{VBI}{vibration-based inspection}
-\newacronym{shm}{SHM}{structural health monitoring}
-\newacronym{fea}{FEA}{finite element analysis}
-\newacronym{1d-cnn}{1-D CNN}{\textit{One-Dimensional Convolutional Neural Network}}
-\newacronym{pca}{PCA}{\textit{principal component analysis}}

latex/frontmatter/approval.tex

@@ -1,35 +1,35 @@
-% frontmatter/approval.tex
+% frontmatter/endorsement.tex
-\chapter{Lembar Persetujuan Tugas Akhir}
+\setmainfont{Times New Roman}
-% \addcontentsline{toc}{chapter}{LEMBAR PERSETUJUAN TUGAS AKHIR}
+\addcontentsline{toc}{chapter}{LEMBAR PERSETUJUAN TUGAS AKHIR}
+
 \begin{center}
-    {\normalsize\textit{APPROVAL SHEET}}
+    \textbf{\Large LEMBAR PERSETUJUAN TUGAS AKHIR} \\[0.5em]
+    \textit{APPROVAL SHEET}
 \end{center}
 
 \vspace{1em}
-% \renewcommand{\arraystretch}{1.2}
+
-\noindent
+\renewcommand{\arraystretch}{1.2}
-\begin{tabular}{lll}
+\begin{tabular}{llp{10cm}}
-\textbf{Judul} & : & \thetitle \\
+\textbf{Judul} & : & \thesistitle \\
 \textit{Title} &   & \\
 
-\textbf{Mahasiswa} & : & \theauthor \\
+\textbf{Mahasiswa} & : & \studentname \\
 \textit{Student} &   & \\
 
-\textbf{Nomor Mahasiswa} & : & \theauthorid \\
+\textbf{Nomor Mahasiswa} & : &\studentid \\
 \textit{Student ID.} &   & \\
 
-\textbf{Dosen Pembimbing} & : & \thefirstadvisor \\
+\textbf{Dosen Pembimbing} & : & 1. \firstadvisor \\
-\textit{Advisors} &  & \thesecondadvisor \\
+\textit{Advisors} &   & 2. \secondadvisor
 \end{tabular}
 
 \vspace{1em}
-\noindent
 \textbf{Telah disetujui oleh Tim Penguji:} \\
 \textit{Approved by the Committee on Oral Examination}
 
 \vspace{1em}
-\noindent
+\begin{tabular}{lp{5cm}}
-\begin{tabular}{ll}
     \textbf{\firstadvisor} &:
     % \vspace{2cm} % signature space
     % \\[1em] % pull up next row
@@ -38,7 +38,7 @@
     \noindent\makebox[5cm]{\hrulefill}\\[-0.5em]
     \textit{\small Chair} & \small Yogyakarta, \dotfill 2020 
     \\
-    \textbf{\thesecondadvisor} &:
+    \textbf{\secondadvisor} &:
     % \vspace{2cm} % signature space
     % \\[1em] % pull up next row
     \\
@@ -52,7 +52,7 @@
 \textbf{Diterima dan disetujui sebagai persyaratan untuk memperoleh gelar Sarjana Teknik} \\
 \textit{Accepted in partial fulfillment of the requirements for the degree of Bachelor of Engineering}
 
-\vspace{1.5pt}
+\vspace{2em}
 \begin{center}
     \textbf{Ketua Program Studi} \\
     \textit{Head of Department}
@@ -60,6 +60,6 @@
 
 \vspace{3em}
 \begin{center}
-    \textbf{\theheaddepartement} \\
+    \textbf{\headdepartement} \\
-    NIK. \theheaddepartementid
+    NIK. \headdepartementid
 \end{center}

latex/frontmatter/endorsement.tex

@@ -2,7 +2,6 @@
 \setmainfont{Times New Roman}
 
 \chapter*{LEMBAR PENGESAHAN TUGAS AKHIR}
-\addcontentsline{toc}{chapter}{LEMBAR PENGESAHAN TUGAS AKHIR}
 \begin{center}
     {\normalsize\textit{ENDORSEMENT SHEET}}
 \end{center}

latex/frontmatter/glossaries.tex

@@ -1,86 +0,0 @@
-% Define the Indonesian term and link it to the English term
-\newglossaryentry{jaringansaraf}{
-  name=Jaringan Saraf,
-  description={The Indonesian term for \gls{nn}}
-}
-% \newglossaryentry{pemelajaranmesin}{
-%   name=Pemelajaran Mesin,
-%   description={Lihat \gls{machinelearning}}
-% }
-
-% Define the English term and link it to its acronym
-% \newglossaryentry{neuralnetwork}{
-%   name=Neural Network,
-%   description={A computational model inspired by the human brain, see \gls{nn}}
-% }
-% \newacronym
-%  [description={statistical pattern recognition technique}]
-%  {svm}{SVM}{support vector machine}
-% \newglossaryentry{machinelearning}{
-%   name=Machine Learning,
-%   description={A program or system that trains a model from input data. The trained model can make useful predictions from new (never-before-seen) data drawn from the same distribution as the one used to train the model.}}
-% \longnewglossaryentry{machinelearning}{name={machine learning}}
-% {A program or system that trains a model from input data. The trained model can make useful predictions from new (never-before-seen) data drawn from the same distribution as the one used to train the model.}
-% \newterm[see={machinelearning}]{pemelajaranmesin}
-% \newglossaryentry{pemelajaran mesin}{}
-% \addterm{machinelearning}{pemelajaran mesin}{pemelajaran mesin}{machine learning}{A program or system that trains a model from input data. The trained model can make useful predictions from new (never-before-seen) data drawn from the same distribution as the one used to train the model.}
-
-\newglossaryentry{algoritma-genetika}{
-  name={Algoritma Genetika},
-  description={Kelas algoritma optimasi dan pencarian yang terinspirasi oleh proses evolusi biologis, seperti seleksi alam, mutasi, dan rekombinasi. Algoritma ini sering digunakan untuk menemukan solusi perkiraan untuk masalah yang kompleks dan sulit dipecahkan secara analitis.},
-  sort={Algoritma Genetika}
-}
-
-\newglossaryentry{deep-learning}{
-  name={\textit{deep learning}},
-  description={Bagian dari keluarga metode pembelajaran mesin yang lebih luas berdasarkan jaringan saraf tiruan dengan banyak lapisan (deep neural networks). Arsitektur ini memungkinkan model untuk belajar representasi data secara hierarkis, mulai dari fitur tingkat rendah hingga konsep abstrak tingkat tinggi.},
-  sort={Pembelajaran Mendalam}
-}
-
-\newglossaryentry{jaringan-saraf-tiruan}{
-  name={Jaringan Saraf Tiruan (Artificial Neural Network)},
-  description={Model komputasi yang terinspirasi oleh struktur dan fungsi jaringan saraf biologis di otak. JST terdiri dari unit pemrosesan yang saling terhubung (neuron) yang bekerja secara paralel untuk memproses informasi dan belajar dari data melalui penyesuaian bobot koneksi.},
-  sort={Jaringan Saraf Tiruan}
-}
-
-\newglossaryentry{pemrosesan-bahasa-alami}{
-  name={Pemrosesan Bahasa Alami (Natural Language Processing)},
-  description={Cabang ilmu komputer dan kecerdasan buatan yang berfokus pada interaksi antara komputer dan bahasa manusia. Tujuannya adalah untuk memungkinkan komputer memproses, memahami, menafsirkan, dan menghasilkan bahasa manusia dengan cara yang bermakna dan berguna.},
-  sort={Pemrosesan Bahasa Alami}
-}
-
-\newglossaryentry{pembelajaran-penguatan}{
-  name={Pembelajaran Penguatan (Reinforcement Learning)},
-  description={Area pembelajaran mesin yang berkaitan dengan bagaimana agen perangkat lunak harus mengambil tindakan dalam suatu lingkungan untuk memaksimalkan beberapa gagasan tentang imbalan kumulatif. Agen belajar melalui trial-and-error, menerima umpan balik berupa imbalan atau hukuman.},
-  sort={Pembelajaran Penguatan}
-}
-
-\newglossaryentry{visi-komputer}{
-  name={Visi Komputer (Computer Vision)},
-  description={Bidang interdisipliner yang membahas bagaimana komputer dapat dibuat untuk mendapatkan pemahaman tingkat tinggi dari gambar atau video digital. Dari perspektif rekayasa, ia berupaya mengotomatiskan tugas-tugas yang dapat dilakukan oleh sistem visual manusia.},
-  sort={Visi Komputer}
-}
-
-\newglossaryentry{model-generatif}{
-  name={Model Generatif},
-  description={Jenis model statistik dalam pembelajaran mesin yang bertujuan untuk mempelajari distribusi probabilitas dari data pelatihan. Setelah dilatih, model ini dapat menghasilkan sampel data baru yang mirip dengan data pelatihan, seperti membuat gambar, teks, atau suara baru.},
-  sort={Model Generatif}
-}
-
-\newglossaryentry{heuristik}{
-  name={Heuristik},
-  description={Teknik pemecahan masalah yang menggunakan pendekatan praktis atau jalan pintas yang tidak dijamin optimal atau sempurna, tetapi cukup untuk mencapai tujuan jangka pendek atau perkiraan solusi. Heuristik sering digunakan ketika pencarian solusi optimal terlalu mahal secara komputasi.},
-  sort={Heuristik}
-}
-
-\newglossaryentry{validasi-silang}{
-  name={Validasi Silang (Cross-Validation)},
-  description={Teknik statistik untuk mengevaluasi seberapa baik hasil analisis statistik (seperti model prediktif) akan generalisasi ke kumpulan data independen. Ini penting untuk menghindari overfitting dan mendapatkan estimasi kinerja model yang lebih andal pada data yang belum pernah dilihat.},
-  sort={Validasi Silang}
-}
-
-\newglossaryentry{bias-algoritmik}{
-  name={Bias Algoritmik},
-  description={Mengacu pada kesalahan sistematis atau hasil yang tidak adil yang dihasilkan oleh sistem kecerdasan buatan karena asumsi yang salah dalam proses pembelajaran mesin atau karena data pelatihan yang bias. Bias ini dapat mereplikasi atau bahkan memperkuat prasangka sosial yang ada.},
-  sort={Bias Algoritmik}
-}

latex/frontmatter/maketitle.tex

@@ -11,17 +11,19 @@
 \includegraphics[width=5cm]{frontmatter/img/logo.png}
 \vspace{1.5cm}
 
+
 \textbf{Disusun oleh:} \\
 {\fontsize{14pt}{16pt}\selectfont \textbf{\theauthor}} \\
-{\fontsize{14pt}{16pt}\selectfont \textbf{\theauthorid}} \\
+{\fontsize{14pt}{16pt}\selectfont \textbf{\studentid}} \\
+
 
 \vfill
 
 {\fontsize{12pt}{14pt}\selectfont
-\textbf{\MakeUppercase\theprogram} \\
+\textbf{\program} \\
-\textbf{\MakeUppercase\thefaculty} \\
+\textbf{\faculty} \\
-\textbf{\MakeUppercase\theuniversity} \\
+\textbf{\university} \\
-% \textbf{\yearofsubmission}
+\textbf{\yearofsubmission}
 }
 
 \end{titlepage}%

latex/frontmatter/maketitle_secondary.tex

@@ -14,17 +14,16 @@
 
 \textbf{Disusun oleh:} \\
 {\fontsize{14pt}{16pt}\selectfont \textbf{\theauthor}} \\
-{\fontsize{14pt}{16pt}\selectfont \textbf{\theauthorid}} \\
+{\fontsize{14pt}{16pt}\selectfont \textbf{\studentid}} \\
 
 
 \vfill
 
 {\fontsize{12pt}{14pt}\selectfont
-\textbf{\MakeUppercase\theprogram} \\
+\textbf{\program} \\
-\textbf{\MakeUppercase\thefaculty} \\
+\textbf{\faculty} \\
-\textbf{\MakeUppercase\theuniversity} \\
+\textbf{\university} \\
-% \textbf{\yearofsubmission}
+\textbf{\yearofsubmission}
 }
 
-\end{titlepage}%
+\end{titlepage}%
-

latex/frontmatter/notations.tex

@@ -1,241 +0,0 @@
-% --- Glossary Definitions ---
-% Note: Descriptions are based on the provided Indonesian text but translated to English
-% for typical glossary conventions. You can adjust the language as needed.
-
-\newglossaryentry{not:signal}{
-    name={\ensuremath{S}},
-    description={vektor sinyal akselerometer berdimensi 1$\times$262144},
-    sort={s},
-    type=notation,
-}
-
-\newglossaryentry{not:sampling_freq}{
-    name={\ensuremath{f_s}},
-    description={frekuensi dengan nilai \textit{sampling} ($s$) di mana sinyal kontinu didigitalkan},
-    sort={fs},
-    type=notation,
-}
-
-\newglossaryentry{not:time_length}{
-    name={\ensuremath{t}},
-    description={panjang waktu data dalam detik},
-    sort={t},
-    type=notation,
-}
-
-\newglossaryentry{not:dataset_A}{
-    name={\ensuremath{\mathcal{A}}},
-    description={matriks dataset A},
-    sort={adataset},
-    type=notation,
-}
-
-\newglossaryentry{not:dataset_B}{
-    name={\ensuremath{\mathcal{B}}},
-    description={matriks dataset B},
-    sort={bdataset},
-    type=notation,
-}
-
-\newglossaryentry{not:damage_file}{
-    name={\ensuremath{\mathbf{D}}},
-    description={matriks akselerometer untuk setiap berkas dengan bentuk $262144\times30$},
-    sort={filedamage},
-    type=notation,
-}
-\newglossaryentry{not:joint_index}{
-    name={\ensuremath{n}},
-    description={indeks atau nomor kerusakan \textit{joint}},
-    sort={indexjoint},
-    type=notation,
-}
-\newglossaryentry{not:damage_file_set_case}{
-    name={\ensuremath{\mathbf{d}}},
-    description={set matriks kerusakan},
-    sort={damagefilesetcase},
-    type=notation,
-}
-
-\newglossaryentry{not:k}{
-  name={$k$},
-  description={Index for measurement nodes, an integer ranging from 0 to 29.},
-  sort={k},
-  type=notation,
-}
-
-\newglossaryentry{not:Fk}{
-  name={$F_{k}$},
-  description={Filename string for the raw time-domain signal from node $k$. The specific format mentioned is \texttt{zzzAD}$k$\texttt{.TXT}.},
-  sort={Fk},
-  type=notation,
-}
-
-\newglossaryentry{not:nkFk}{
-  name={$n_{k}^{F_{k}}$},
-  description={Represents the measurement \textit{node} with index $k$. The raw time-domain signal data from this node, $x_k$, has a length of $L=262144$ samples.},
-  sort={nkFk},
-  type=notation,
-}
-
-\newglossaryentry{not:i}{
-  name={$i$},
-  description={Index for ``damage-case'' folders, an integer ranging from 0 to 5.},
-  sort={i},
-  type=notation,
-}
-
-\newglossaryentry{not:di}{
-  name={$d_{i}$},
-  description={Set representing the $i$-th damage scenario, containing data from five consecutive nodes: $\bigl\{\,n_{5i}^{F_{5i}},\;n_{5i+1}^{F_{5i+1}},\;\dots,\;n_{5i+4}^{F_{5i+4}}\bigr\}$. Cardinality: $|d_i|=5$ nodes.},
-  sort={di},
-  type=notation,
-}
-
-\newglossaryentry{not:diTD}{
-  name={$d_{i}^{\mathrm{TD}}$},
-  description={Time-domain subset of nodes from damage case $d_i$, containing only the first and last nodes: $\bigl\{\,n_{5i}^{F_{5i}},\;n_{5i+4}^{F_{5i+4}}\bigr\}$. Cardinality: $|d_{i}^{\mathrm{TD}}| = 2$ nodes.},
-  sort={diTD},
-  type=notation,
-}
-
-\newglossaryentry{not:calT}{
-  name={$\mathcal{T}$},
-  description={Short-Time Fourier Transform (STFT) operator. It maps a raw time-domain signal $n_k^{F_k}$ (or $x_k$) from $\mathbb{R}^{L}$ (with $L=262144$) to a magnitude spectrogram matrix $\widetilde{n}_k^{F_k}$ in $\mathbb{R}^{513 \times 513}$.},
-  sort={Tcal},
-  type=notation,
-}
-
-\newglossaryentry{not:L}{
-  name={$L$},
-  description={Length of the raw time-domain signal, $L=262144$ samples.},
-  sort={L},
-  type=notation,
-}
-
-\newglossaryentry{not:Nw}{
-  name={$N_{w}$},
-  description={Length of the Hanning window used in the STFT, $N_{w}=1024$ samples.},
-  sort={Nw},
-  type=notation,
-}
-
-\newglossaryentry{not:Nh}{
-  name={$N_{h}$},
-  description={Hop size (or step size) used in the STFT, $N_{h}=512$ samples.},
-  sort={Nh},
-  type=notation,
-}
-
-\newglossaryentry{not:wn}{
-  name={$w[n]$},
-  description={Value of the Hanning window function at sample index $n$. The window spans $N_w$ samples.},
-  sort={wn},
-  type=notation,
-}
-
-\newglossaryentry{not:n_summation}{
-  name={$n$},
-  description={Sample index within the Hanning window and for the STFT summation, an integer ranging from $0$ to $N_w-1$.},
-  sort={n_summation},
-  type=notation,
-}
-
-\newglossaryentry{not:xkm}{
-  name={$x_k[m]$}, % Or x_k if it's treated as the whole signal vector
-  description={Represents the raw time-domain signal for node $k$. As a discrete signal, it consists of $L=262144$ samples. $x_k[m]$ would be the $m$-th sample.},
-  sort={xkm},
-  type=notation,
-}
-
-\newglossaryentry{not:Skpt}{
-  name={$S_k(p,t)$},
-  description={Complex-valued result of the STFT for node $k$ at frequency bin $p$ and time frame $t$. This is a scalar value for each $(p,t)$ pair.},
-  sort={Skpt},
-  type=notation,
-}
-
-\newglossaryentry{not:p}{
-  name={$p$},
-  description={Frequency bin index in the STFT or spectrogram, an integer ranging from $0$ to $512$.},
-  sort={p},
-  type=notation,
-}
-
-\newglossaryentry{not:t_stft}{ % Differentiating t for STFT time frame and t for feature vector time slice if necessary
-  name={$t$},
-  description={Time frame index in the STFT or spectrogram, an integer ranging from $0$ to $512$. Also used as the time slice index for extracting feature vectors $\mathbf{x}_{i,s,r,t}$ from spectrograms.},
-  sort={t},
-  type=notation,
-}
-
-\newglossaryentry{not:ntildekFk}{ % New entry for the matrix
-  name={$\widetilde{n}_k^{F_k}$},
-  description={The magnitude spectrogram matrix for node $k$, obtained by applying the STFT operator $\mathcal{T}$ to the time-domain signal $n_k^{F_k}$. This matrix is an element of $\mathbb{R}^{513 \times 513}$.},
-  sort={ntildekFk},
-  type=notation,
-}
-
-\newglossaryentry{not:ntildekFkpt}{ % Modified entry for the element
-  name={$\widetilde{n}_k^{F_k}(p,t)$},
-  description={Scalar value representing the magnitude of the STFT for node $k$ at frequency bin $p$ and time frame $t$; specifically, $\widetilde{n}_k^{F_k}(p,t) = |S_k(p,t)|$. This is an element of the spectrogram matrix $\widetilde{n}_k^{F_k}$.},
-  sort={ntildekFkpt},
-  type=notation,
-}
-
-\newglossaryentry{not:R}{
-  name={$\mathbb{R}$},
-  description={The set of real numbers. Used to denote vector spaces like $\mathbb{R}^{N}$ (N-dimensional real vectors) or $\mathbb{R}^{M \times N}$ (M-by-N real matrices).},
-  sort={Rbb},
-  type=notation,
-}
-
-\newglossaryentry{not:diFD}{
-  name={$d_{i}^{\mathrm{FD}}$},
-  description={Frequency-domain subset for damage case $i$. It contains two spectrogram matrices: $\bigl\{\,\widetilde{n}_{5i}^{F_{5i}},\; \widetilde{n}_{5i+4}^{F_{5i+4}}\,\bigr\}$, where each spectrogram $\widetilde{n}$ is in $\mathbb{R}^{513 \times 513}$. Cardinality: $|d_{i}^{\mathrm{FD}}| = 2$ spectrograms.},
-  sort={diFD},
-  type=notation,
-}
-
-\newglossaryentry{not:r_repetition}{
-  name={$r$},
-  description={Repetition index within a single damage case, an integer ranging from $0$ to $4$.},
-  sort={r_repetition},
-  type=notation,
-}
-
-\newglossaryentry{not:xboldisr}{
-  name={$\mathbf{x}_{i,s,r,t}$},
-  description={Feature vector (a row or column, often referred to as a time slice) taken from the $r$-th spectrogram repetition, for damage case $i$ and sensor side $s$, at time slice $t$. This vector is an element of $\mathbb{R}^{513}$.},
-  sort={xisrt_bold},
-  type=notation,
-}
-
-\newglossaryentry{not:s_sensor}{
-  name={$s$},
-  description={Index representing the sensor side (e.g., identifying Sensor A or Sensor B).},
-  sort={s_sensor},
-  type=notation,
-}
-
-\newglossaryentry{not:yi}{
-  name={$y_{i}$},
-  description={Scalar label for the damage case $i$, defined as $y_i = i$. This is an integer value from 0 to 5.},
-  sort={yi},
-  type=notation,
-}
-
-\newglossaryentry{not:Lambda}{
-  name={$\Lambda(i,s,r,t)$},
-  description={Slicing function that concatenates a feature vector $\mathbf{x}_{i,s,r,t} \in \mathbb{R}^{513}$ with its corresponding damage case label $y_i \in \mathbb{R}$, resulting in a combined vector $\bigl[\,\mathbf{x}_{i,s,r,t}, \;y_{i}\bigr] \in \mathbb{R}^{514}$.},
-  sort={Lambda},
-  type=notation,
-}
-
-\newglossaryentry{not:calDs}{
-  name={$\mathcal{D}^{(s)}$},
-  description={The complete dataset for sensor side $s$. It is a collection of $15390$ data points, where each point is a vector in $\mathbb{R}^{514}$ (513 features + 1 label). Thus, the dataset can be viewed as a matrix of size $15390 \times 514$.},
-  sort={Dcal_s},
-  type=notation,
-}
-
-% --- End Glossary Definitions ---

latex/frontmatter/originality.tex

@@ -1,5 +1,8 @@
 % frontmatter/originality.tex
-\chapter{Pernyataan Keaslian}
+\setmainfont{Times New Roman}
+
+\chapter*{PERNYATAAN KEASLIAN}
+\addcontentsline{toc}{chapter}{PERNYATAAN KEASLIAN}
 % \begin{center}
 %     {\normalsize\textit{ORIGINALITY STATEMENT}}
 % \end{center}
@@ -7,9 +10,9 @@ Saya yang bertanda tangan di bawah ini:
 \renewcommand{\arraystretch}{1.2}
 \begin{center}
 \begin{tabular}{llp{10cm}}
-\textbf{Nama} & : & \theauthor \\
+\textbf{Nama} & : & \studentname \\
-\textbf{Nomor Mahasiswa} & : & \theauthorid \\
+\textbf{Nomor Mahasiswa} & : & \studentid \\
-\textbf{Judul} & : & \thetitle \\
+\textbf{Judul} & : & \thesistitle \\
 \end{tabular}
 \end{center}
 Menyatakan dengan sebenarnya bahwa tugas akhir ini merupakan karya says sendiri. Apabila terdapat karya orang lain yang saya kutip, maka saya akan mencantumkan sumber secara jelas. Jika dikemudian hari ditemukan dengan ketidakbenaran dalam pernyataan in, maka saya bersedia menerima sanksi dengan aturan yang berlaku. Demikian pernyataan ini saya buat tanpa ada paksaan dari pihak mana pun.\par
@@ -20,10 +23,10 @@ Menyatakan dengan sebenarnya bahwa tugas akhir ini merupakan karya says sendiri.
 Yogyakarta, \today \\[1em]
 Yang membuat pernyataan, \\[0.5cm] % space for signature
 % Materai box
-\hspace*{-3cm}% shift the box slightly left
+\hspace*{-2cm}% shift the box slightly left
 \begin{tabular}{@{}c@{}}
   \fbox{
-    \begin{minipage}[c][1.8cm][c]{1.6cm}
+    \begin{minipage}[c][2cm][c]{2.5cm}
       \centering
       Materai\\
       6000
@@ -32,6 +35,6 @@ Yang membuat pernyataan, \\[0.5cm] % space for signature
 \end{tabular}
 \\[1cm]
 % \rule{6cm}{0.4pt} % signature line
-\theauthor
+Rifqi Damar Panuluh
 \end{minipage}
 \end{flushright}

latex/main-staged.tex

@@ -1,871 +0,0 @@
-\documentclass[draftmark]{thesis}
-\title{Prediksi Lokasi Kerusakan dengan Machine Learning}
-\author{Rifqi Damar Panuluh}
-\date{\today}
-\authorid{20210110224}
-\firstadvisor{Ir. Muhammad Ibnu Syamsi, Ph.D.}
-\secondadvisor{}
-\headdepartement{Puji Harsanto, S.T., M.T., Ph.D.}
-\headdepartementid{19740607201404123064}
-\faculty{Fakultas Teknik}
-\program{Program Studi Teknik Sipil}
-\university{Universitas Muhammadiyah Yogyakarta}
- \newcommand{\eg}{\textit{e.g.},\ }
-\newcommand{\ie}{\textit{i.e.},\ }
-\newcommand{\etal}{\textit{et al.}}
-
-\let\oldtableofcontents\tableofcontents 
-
-\let\oldaddcontentsline\addcontentsline
-\newcommand{\ADDCONTENTSLINE}[3]{\oldaddcontentsline{#1}{#2}{\MakeUppercase{#3}}}
-\newcommand{\CAPinToC}{\let\addcontentsline\ADDCONTENTSLINE}
-\newcommand{\noCAPinToC}{\let\addcontentsline\oldaddcontentsline}
- 
-\addbibresource{bibliography.bib}
-
-\makeglossaries
-\newacronym{ml}{ML}{machine learning}
-\newacronym{stft}{STFT}{short-time fourier transform}
-\newacronym{ai}{AI}{artificial intelligence}
-\newacronym{dl}{DL}{deep learning}
-\newacronym{nn}{NN}{neural network}
-\newacronym{fft}{FFT}{fast fourier transform}
-\newacronym{svm}{SVM}{support vector machine}
-\newacronym{cnn}{CNN}{convolutional neural network}
-\newacronym{rnn}{RNN}{recurrent neural network}
-\newacronym{vbi}{VBI}{vibration-based inspection}
-\newacronym{shm}{SHM}{structural health monitoring}
-\newacronym{fea}{FEA}{finite element analysis}
-\newacronym{1d-cnn}{1-D CNN}{\textit{One-Dimensional Convolutional Neural Network}}
- \newglossaryentry{jaringansaraf}{
-  name=Jaringan Saraf,
-  description={The Indonesian term for \gls{nn}}
-}
-
-
-
-
-\newglossaryentry{algoritma-genetika}{
-  name={Algoritma Genetika},
-  description={Kelas algoritma optimasi dan pencarian yang terinspirasi oleh proses evolusi biologis, seperti seleksi alam, mutasi, dan rekombinasi. Algoritma ini sering digunakan untuk menemukan solusi perkiraan untuk masalah yang kompleks dan sulit dipecahkan secara analitis.},
-  sort={Algoritma Genetika}
-}
-
-\newglossaryentry{deep-learning}{
-  name={\textit{deep learning}},
-  description={Bagian dari keluarga metode pembelajaran mesin yang lebih luas berdasarkan jaringan saraf tiruan dengan banyak lapisan (deep neural networks). Arsitektur ini memungkinkan model untuk belajar representasi data secara hierarkis, mulai dari fitur tingkat rendah hingga konsep abstrak tingkat tinggi.},
-  sort={Pembelajaran Mendalam}
-}
-
-\newglossaryentry{jaringan-saraf-tiruan}{
-  name={Jaringan Saraf Tiruan (Artificial Neural Network)},
-  description={Model komputasi yang terinspirasi oleh struktur dan fungsi jaringan saraf biologis di otak. JST terdiri dari unit pemrosesan yang saling terhubung (neuron) yang bekerja secara paralel untuk memproses informasi dan belajar dari data melalui penyesuaian bobot koneksi.},
-  sort={Jaringan Saraf Tiruan}
-}
-
-\newglossaryentry{pemrosesan-bahasa-alami}{
-  name={Pemrosesan Bahasa Alami (Natural Language Processing)},
-  description={Cabang ilmu komputer dan kecerdasan buatan yang berfokus pada interaksi antara komputer dan bahasa manusia. Tujuannya adalah untuk memungkinkan komputer memproses, memahami, menafsirkan, dan menghasilkan bahasa manusia dengan cara yang bermakna dan berguna.},
-  sort={Pemrosesan Bahasa Alami}
-}
-
-\newglossaryentry{pembelajaran-penguatan}{
-  name={Pembelajaran Penguatan (Reinforcement Learning)},
-  description={Area pembelajaran mesin yang berkaitan dengan bagaimana agen perangkat lunak harus mengambil tindakan dalam suatu lingkungan untuk memaksimalkan beberapa gagasan tentang imbalan kumulatif. Agen belajar melalui trial-and-error, menerima umpan balik berupa imbalan atau hukuman.},
-  sort={Pembelajaran Penguatan}
-}
-
-\newglossaryentry{visi-komputer}{
-  name={Visi Komputer (Computer Vision)},
-  description={Bidang interdisipliner yang membahas bagaimana komputer dapat dibuat untuk mendapatkan pemahaman tingkat tinggi dari gambar atau video digital. Dari perspektif rekayasa, ia berupaya mengotomatiskan tugas-tugas yang dapat dilakukan oleh sistem visual manusia.},
-  sort={Visi Komputer}
-}
-
-\newglossaryentry{model-generatif}{
-  name={Model Generatif},
-  description={Jenis model statistik dalam pembelajaran mesin yang bertujuan untuk mempelajari distribusi probabilitas dari data pelatihan. Setelah dilatih, model ini dapat menghasilkan sampel data baru yang mirip dengan data pelatihan, seperti membuat gambar, teks, atau suara baru.},
-  sort={Model Generatif}
-}
-
-\newglossaryentry{heuristik}{
-  name={Heuristik},
-  description={Teknik pemecahan masalah yang menggunakan pendekatan praktis atau jalan pintas yang tidak dijamin optimal atau sempurna, tetapi cukup untuk mencapai tujuan jangka pendek atau perkiraan solusi. Heuristik sering digunakan ketika pencarian solusi optimal terlalu mahal secara komputasi.},
-  sort={Heuristik}
-}
-
-\newglossaryentry{validasi-silang}{
-  name={Validasi Silang (Cross-Validation)},
-  description={Teknik statistik untuk mengevaluasi seberapa baik hasil analisis statistik (seperti model prediktif) akan generalisasi ke kumpulan data independen. Ini penting untuk menghindari overfitting dan mendapatkan estimasi kinerja model yang lebih andal pada data yang belum pernah dilihat.},
-  sort={Validasi Silang}
-}
-
-\newglossaryentry{bias-algoritmik}{
-  name={Bias Algoritmik},
-  description={Mengacu pada kesalahan sistematis atau hasil yang tidak adil yang dihasilkan oleh sistem kecerdasan buatan karena asumsi yang salah dalam proses pembelajaran mesin atau karena data pelatihan yang bias. Bias ini dapat mereplikasi atau bahkan memperkuat prasangka sosial yang ada.},
-  sort={Bias Algoritmik}
-} 
-
-\newglossaryentry{not:signal}{
-    name={\ensuremath{S}},
-    description={vektor sinyal akselerometer berdimensi 1$\times$262144},
-    sort={s},
-    type=notation,
-}
-
-\newglossaryentry{not:sampling_freq}{
-    name={\ensuremath{f_s}},
-    description={frekuensi dengan nilai \textit{sampling} ($s$) di mana sinyal kontinu didigitalkan},
-    sort={fs},
-    type=notation,
-}
-
-\newglossaryentry{not:time_length}{
-    name={\ensuremath{t}},
-    description={panjang waktu data dalam detik},
-    sort={t},
-    type=notation,
-}
-
-\newglossaryentry{not:dataset_A}{
-    name={\ensuremath{\mathcal{A}}},
-    description={matriks dataset A},
-    sort={adataset},
-    type=notation,
-}
-
-\newglossaryentry{not:dataset_B}{
-    name={\ensuremath{\mathcal{B}}},
-    description={matriks dataset B},
-    sort={bdataset},
-    type=notation,
-}
-
-\newglossaryentry{not:damage_file}{
-    name={\ensuremath{\mathbf{D}}},
-    description={matriks akselerometer untuk setiap berkas dengan bentuk $262144\times30$},
-    sort={filedamage},
-    type=notation,
-}
-\newglossaryentry{not:joint_index}{
-    name={\ensuremath{n}},
-    description={indeks atau nomor kerusakan \textit{joint}},
-    sort={indexjoint},
-    type=notation,
-}
-\newglossaryentry{not:damage_file_set_case}{
-    name={\ensuremath{\mathbf{d}}},
-    description={set matriks kerusakan},
-    sort={damagefilesetcase},
-    type=notation,
-}
-
-\newglossaryentry{not:k}{
-  name={$k$},
-  description={Index for measurement nodes, an integer ranging from 0 to 29.},
-  sort={k},
-  type=notation,
-}
-
-\newglossaryentry{not:Fk}{
-  name={$F_{k}$},
-  description={Filename string for the raw time-domain signal from node $k$. The specific format mentioned is \texttt{zzzAD}$k$\texttt{.TXT}.},
-  sort={Fk},
-  type=notation,
-}
-
-\newglossaryentry{not:nkFk}{
-  name={$n_{k}^{F_{k}}$},
-  description={Represents the measurement \textit{node} with index $k$. The raw time-domain signal data from this node, $x_k$, has a length of $L=262144$ samples.},
-  sort={nkFk},
-  type=notation,
-}
-
-\newglossaryentry{not:i}{
-  name={$i$},
-  description={Index for ``damage-case'' folders, an integer ranging from 0 to 5.},
-  sort={i},
-  type=notation,
-}
-
-\newglossaryentry{not:di}{
-  name={$d_{i}$},
-  description={Set representing the $i$-th damage scenario, containing data from five consecutive nodes: $\bigl\{\,n_{5i}^{F_{5i}},\;n_{5i+1}^{F_{5i+1}},\;\dots,\;n_{5i+4}^{F_{5i+4}}\bigr\}$. Cardinality: $|d_i|=5$ nodes.},
-  sort={di},
-  type=notation,
-}
-
-\newglossaryentry{not:diTD}{
-  name={$d_{i}^{\mathrm{TD}}$},
-  description={Time-domain subset of nodes from damage case $d_i$, containing only the first and last nodes: $\bigl\{\,n_{5i}^{F_{5i}},\;n_{5i+4}^{F_{5i+4}}\bigr\}$. Cardinality: $|d_{i}^{\mathrm{TD}}| = 2$ nodes.},
-  sort={diTD},
-  type=notation,
-}
-
-\newglossaryentry{not:calT}{
-  name={$\mathcal{T}$},
-  description={Short-Time Fourier Transform (STFT) operator. It maps a raw time-domain signal $n_k^{F_k}$ (or $x_k$) from $\mathbb{R}^{L}$ (with $L=262144$) to a magnitude spectrogram matrix $\widetilde{n}_k^{F_k}$ in $\mathbb{R}^{513 \times 513}$.},
-  sort={Tcal},
-  type=notation,
-}
-
-\newglossaryentry{not:L}{
-  name={$L$},
-  description={Length of the raw time-domain signal, $L=262144$ samples.},
-  sort={L},
-  type=notation,
-}
-
-\newglossaryentry{not:Nw}{
-  name={$N_{w}$},
-  description={Length of the Hanning window used in the STFT, $N_{w}=1024$ samples.},
-  sort={Nw},
-  type=notation,
-}
-
-\newglossaryentry{not:Nh}{
-  name={$N_{h}$},
-  description={Hop size (or step size) used in the STFT, $N_{h}=512$ samples.},
-  sort={Nh},
-  type=notation,
-}
-
-\newglossaryentry{not:wn}{
-  name={$w[n]$},
-  description={Value of the Hanning window function at sample index $n$. The window spans $N_w$ samples.},
-  sort={wn},
-  type=notation,
-}
-
-\newglossaryentry{not:n_summation}{
-  name={$n$},
-  description={Sample index within the Hanning window and for the STFT summation, an integer ranging from $0$ to $N_w-1$.},
-  sort={n_summation},
-  type=notation,
-}
-
-\newglossaryentry{not:xkm}{
-  name={$x_k[m]$}, description={Represents the raw time-domain signal for node $k$. As a discrete signal, it consists of $L=262144$ samples. $x_k[m]$ would be the $m$-th sample.},
-  sort={xkm},
-  type=notation,
-}
-
-\newglossaryentry{not:Skpt}{
-  name={$S_k(p,t)$},
-  description={Complex-valued result of the STFT for node $k$ at frequency bin $p$ and time frame $t$. This is a scalar value for each $(p,t)$ pair.},
-  sort={Skpt},
-  type=notation,
-}
-
-\newglossaryentry{not:p}{
-  name={$p$},
-  description={Frequency bin index in the STFT or spectrogram, an integer ranging from $0$ to $512$.},
-  sort={p},
-  type=notation,
-}
-
-\newglossaryentry{not:t_stft}{ name={$t$},
-  description={Time frame index in the STFT or spectrogram, an integer ranging from $0$ to $512$. Also used as the time slice index for extracting feature vectors $\mathbf{x}_{i,s,r,t}$ from spectrograms.},
-  sort={t},
-  type=notation,
-}
-
-\newglossaryentry{not:ntildekFk}{ name={$\widetilde{n}_k^{F_k}$},
-  description={The magnitude spectrogram matrix for node $k$, obtained by applying the STFT operator $\mathcal{T}$ to the time-domain signal $n_k^{F_k}$. This matrix is an element of $\mathbb{R}^{513 \times 513}$.},
-  sort={ntildekFk},
-  type=notation,
-}
-
-\newglossaryentry{not:ntildekFkpt}{ name={$\widetilde{n}_k^{F_k}(p,t)$},
-  description={Scalar value representing the magnitude of the STFT for node $k$ at frequency bin $p$ and time frame $t$; specifically, $\widetilde{n}_k^{F_k}(p,t) = |S_k(p,t)|$. This is an element of the spectrogram matrix $\widetilde{n}_k^{F_k}$.},
-  sort={ntildekFkpt},
-  type=notation,
-}
-
-\newglossaryentry{not:R}{
-  name={$\mathbb{R}$},
-  description={The set of real numbers. Used to denote vector spaces like $\mathbb{R}^{N}$ (N-dimensional real vectors) or $\mathbb{R}^{M \times N}$ (M-by-N real matrices).},
-  sort={Rbb},
-  type=notation,
-}
-
-\newglossaryentry{not:diFD}{
-  name={$d_{i}^{\mathrm{FD}}$},
-  description={Frequency-domain subset for damage case $i$. It contains two spectrogram matrices: $\bigl\{\,\widetilde{n}_{5i}^{F_{5i}},\; \widetilde{n}_{5i+4}^{F_{5i+4}}\,\bigr\}$, where each spectrogram $\widetilde{n}$ is in $\mathbb{R}^{513 \times 513}$. Cardinality: $|d_{i}^{\mathrm{FD}}| = 2$ spectrograms.},
-  sort={diFD},
-  type=notation,
-}
-
-\newglossaryentry{not:r_repetition}{
-  name={$r$},
-  description={Repetition index within a single damage case, an integer ranging from $0$ to $4$.},
-  sort={r_repetition},
-  type=notation,
-}
-
-\newglossaryentry{not:xboldisr}{
-  name={$\mathbf{x}_{i,s,r,t}$},
-  description={Feature vector (a row or column, often referred to as a time slice) taken from the $r$-th spectrogram repetition, for damage case $i$ and sensor side $s$, at time slice $t$. This vector is an element of $\mathbb{R}^{513}$.},
-  sort={xisrt_bold},
-  type=notation,
-}
-
-\newglossaryentry{not:s_sensor}{
-  name={$s$},
-  description={Index representing the sensor side (e.g., identifying Sensor A or Sensor B).},
-  sort={s_sensor},
-  type=notation,
-}
-
-\newglossaryentry{not:yi}{
-  name={$y_{i}$},
-  description={Scalar label for the damage case $i$, defined as $y_i = i$. This is an integer value from 0 to 5.},
-  sort={yi},
-  type=notation,
-}
-
-\newglossaryentry{not:Lambda}{
-  name={$\Lambda(i,s,r,t)$},
-  description={Slicing function that concatenates a feature vector $\mathbf{x}_{i,s,r,t} \in \mathbb{R}^{513}$ with its corresponding damage case label $y_i \in \mathbb{R}$, resulting in a combined vector $\bigl[\,\mathbf{x}_{i,s,r,t}, \;y_{i}\bigr] \in \mathbb{R}^{514}$.},
-  sort={Lambda},
-  type=notation,
-}
-
-\newglossaryentry{not:calDs}{
-  name={$\mathcal{D}^{(s)}$},
-  description={The complete dataset for sensor side $s$. It is a collection of $15390$ data points, where each point is a vector in $\mathbb{R}^{514}$ (513 features + 1 label). Thus, the dataset can be viewed as a matrix of size $15390 \times 514$.},
-  sort={Dcal_s},
-  type=notation,
-}
-
-%
- 
-\begin{document}
-\frontmatter
-\glsaddall[types={main,notation,\acronymtype}]
-
-\printglossary[type=notation,style=altlong3customheader,title=Daftar Simbol dan Lambang]
-\printglossary[type=\acronymtype,style=supercol,title=Daftar Singkatan]
-\printglossary[type=main,style=mylistalt]
-\mainmatter
-\include{content/abstract}
-\include{content/introduction}
-\clearpage{}\chapter{PENDAHULUAN}
-
-\section{Latar Belakang}
-
-\indent Monitor Kesehatan Struktur (\textit{Structural Health Monitoring} atau SHM) merupakan riset penting yang tersebar di berbagai disiplin ilmu, termasuk teknik dirgantara, teknik sipil, dan teknik mesin. Tujuan utama dari monitor kesehatan struktur adalah memastikan keamanan dan keandalan struktur dengan mendeteksi kerusakan sedini mungkin. Dengan mengombinasikan teknologi sensor yang canggih serta pengolahan data secara \textit{real-time}, sistem monitor kesehatan struktur menjadi kekuatan para insinyur untuk memonitor integritas struktur, strategi optimisasi \textit{maintenance}, dan memprediksi sisa umur struktur. 
-
-\indent Sistem SHM yang tangguh mengikuti \textit{framework} secara hierarkis untuk mengidentifikasi dan menilai kerusakan struktural. Menurut \textcite{rytter1993}, lima tahapan SHM tersebut adalah: 
-\begin{enumerate}
-    \item (Tingkat 1) Keberadaan Kerusakan: Menentukan apakah ada kerusakan pada struktur. Pada tahap ini, pengukuran getaran cukup untuk memastikan adanya kerusakan.
-    \item (Tingkat 2) Lokasi Kerusakan: Mengidentifikasi lokasi geometris kerusakan, baik kerusakan tunggal maupun ganda.
-    \item (Tingkat 3) Tipe Kerusakan: Mencirikan sifat kerusakan, yang dapat meliputi retakan, perubahan pada kondisi tumpuan, atau perubahan dalam sambungan struktur.
-    \item (Tingkat 4) Tingkat Keparahan: Mengukur secara kuantitatif seberapa parah kerusakan terjadi. Biasanya melalui eksperimen atau model terkalibrasi yang menggambarkan efek kerusakan, seperti penurunan kekakuan atau panjang retakan.
-    \item (Tingkat 5): Memprediksi sisa umur pakai struktur dengan mengandalkan pemantauan secara \textit{real-time} dan komprehensif serta model dengan fidelitas tinggi yang menggambarkan perkembangan kerusakan seiring waktu.
-\end{enumerate}
-Semakin tinggi tingkat identifikasi kerusakan, semakin besar pula kebutuhan akan sensor yang presisi, algoritma yang kompleks, serta parameter model yang akurat. Jika pada Tingkat 1 hanya diperlukan data yang terbatas untuk mendeteksi adanya kerusakan, maka Tingkat 5 membutuhkan akuisisi data secara \textit{real-time} dan canggih serta model prediktif yang memiliki fidelitas tinggi. 
-
-\par Tantangan utama terletak pada pengembangan sistem \acrshort{shm} yang mampu mengakomodasi berbagai tahapan identifikasi kerusakan secara efektif, baik dalam kondisi operasional normal maupun dalam situasi ekstrem seperti gempa bumi.
-
-\par Dalam konteks pengembangan sistem \acrshort{shm} yang efektif, perlu memperhatikan elemen struktural yang rentan terhadap kerusakan namun sering kali terabaikan dalam pemantauan konvensional. Salah satu komponen struktural yang umum digunakan dalam penyambungan adalah sambungan baut (\textit{bolt joint}), yang dikenal karena kemudahan dalam perakitan dan penggunaannya. Namun, sambungan berulir ini rentan mengalami kelonggaran akibat beban kejut atau getaran terus-menerus \parencite{chen2017}. Kelonggaran baut yang tidak terdeteksi sejak dini dapat menyebabkan kerusakan serius pada struktur, sehingga identifikasi dini terhadap kerusakan sambungan baut menjadi krusial dalam bidang teknik sipil, mesin, dan kedirgantaraan. Pemantauan kondisi sambungan ini tidak hanya relevan dalam konteks deteksi dini (Tingkat 1), tetapi juga sangat penting untuk diagnosis kerusakan dan penentuan lokasi secara akurat (Tingkat 2), seiring dengan meningkatnya kebutuhan akan sistem \acrshort{shm} yang responsif dan adaptif terhadap dinamika kerusakan struktural. 
-
-\indent Deteksi kelonggaran baut telah dilakukan melalui berbagai metode. Kelompok pertama adalah inspeksi \textit{in-situ}, seperti inspeksi visual atau penggunaan alat mekanis seperti kunci torsi dan palu. Meskipun sederhana dan murah, metode ini sulit untuk mendeteksi kerusakan pada tahap awal \parencite{j.h.park2015}. Metode palu lebih efektif dibanding visual untuk mendeteksi awal kelonggaran, tetapi akurasinya dapat terganggu oleh kebisingan lingkungan, serta memakan waktu bila diaplikasikan pada struktur dengan banyak sambungan seperti jembatan \parencite{j.h.park2015,wang2013}.
-
-\indent Kelompok kedua menggunakan teknik berbasis penglihatan komputer seperti kamera dan pencitraan digital, termasuk deteksi rotasi kepala baut menggunakan CNN dan Faster R-CNN \parencite{zhang2020,zhao2019}. Meskipun teknik ini dapat mendeteksi kerusakan secara visual tanpa dipengaruhi oleh kebisingan akustik, tantangan tetap ada dalam hal penempatan kamera dan beban komputasi tinggi dari model \gls{deep-learning}, terutama dalam kondisi ruang yang sangat seperti mesin kendaraan atau turbin.
-
-\indent Kelompok ketiga dan yang menjadi fokus penelitian ini adalah teknik berbasis sensor, terutama pendekatan berbasis getaran (\textit{vibration-based}). Metode ini tidak hanya efektif dalam mengatasi keterbatasan teknik sebelumnya, tetapi juga mampu mendeteksi kelonggaran baut pada tahap awal secara baik dan akurat \parencite{nichols2004,razi2013}. Dalam penelitian ini, deteksi dilakukan melalui data akselerasi struktur yang diambil dari titik-titik sambungan dalam \textit{sistem grid} yang mewakili koneksi baut secara arah kolom.
-
-\indent Penelitian oleh \textcite{abdeljaber2017} merupakan tonggak penting dalam sistem pemantauan kesehatan struktur (SHM), dengan menerapkan 30 model \acrlong{1d-cnn} pada 30 sensor akselerometer dalam struktur grid QUGS. Pendekatan ini menunjukkan bahwa metode pembelajaran mendalam sangat efektif dalam mendeteksi dan melokalisasi kerusakan dengan presisi tinggi. Namun, metode tersebut memerlukan sumber daya komputasi yang besar karena pemrosesan paralel data mentah berdimensi tinggi dari seluruh sensor \parencite{yang2020, liu2022}. 
-
-\indent Menanggapi tantangan ini, studi lanjutan seperti \parencite{shahid2022, doi:10.1007/s13349-023-00715-3} memperkenalkan pendekatan VMD-HT-CNN yang menggabungkan teknik ekstraksi fitur berbasis Variational Mode Decomposition (VMD) dan Hilbert Transform (HT) sebelum klasifikasi CNN. Metode ini secara signifikan meningkatkan efisiensi pelatihan dan akurasi deteksi meskipun dengan jumlah sensor yang lebih sedikit. 
-
-\indent Berdasarkan celah ini, penelitian ini mengadopsi strategi pengurangan jumlah sensor menjadi dua per jalur kolom (atas dan bawah), merepresentasikan sambungan vertikal seperti susunan baut, untuk menyederhanakan model tanpa kehilangan akurasi deteksi kerusakan. Data diubah melalui transformasi STFT sebelum diklasifikasikan menggunakan berbagai model pembelajaran mesin klasik. Dengan evaluasi antar berbagai pengklasifikasi dan validasi silang antar kolom, studi ini berkontribusi pada pengembangan sistem SHM yang efisien, hemat biaya, dan mudah diimplementasikan.
-
-
-
-\section{Rumusan Masalah}
-Untuk memandu arah penelitian ini, beberapa permasalahan utama yang akan dibahas adalah sebagai berikut:
-
-\begin{enumerate}
-    \item Apakah sinyal getaran yang hanya diperoleh dari sensor pada bagian atas dan bawah suatu jalur kolom masih mampu merepresentasikan fitur-fitur penting yang diperlukan untuk mengklasifikasikan kerusakan struktur secara akurat?
-
-    \item Apakah penggabungan data dari beberapa jalur kolom dapat meningkatkan kemampuan generalisasi model, meskipun jumlah sensor pada tiap jalur dibatasi?
-
-    \item Apakah algoritma pemelajaran mesin klasik yang sederhana masih mampu menghasilkan model dengan kinerja yang cukup layak dibandingkan dengan model \textit{supervised} yang lebih kompleks ketika diterapkan pada skenario dengan input data sensor yang terbatas?
-\end{enumerate}
-
-
-
-
-\section{Lingkup Penelitian}
-Studi ini berfokus pada dataset yang tersedia secara publik didapat dari Queen's University Grandstand Simulator (QUGS), sebuah kerangka besi level laboratorium yang dipasang dengan tiga puluh titik sensor akselerometer dan \textit{white shaker noise}. Riset terdahulu telah dilakukan pengaplikasian pemelajaran mesin jaringan saraf terhadap seluruh sensor yang terpasang penuh pada setiap titik \textit{joint} untuk mencapai akurasi yang tinggi. Akan tetapi, pada praktiknya, instrumentasi penuh seperti ini terkadang kurang efektif dari segi biaya dan kurang layak dalam skala besar.
-
-\section{Tujuan Penelitian}
-\begin{enumerate}
-    \item Mengembangkan alur sistem (\textit{pipeline}) pemantauan kesehatan struktur (Structural Health Monitoring/SHM) yang disederhanakan dengan hanya menggunakan sepasang sensor di ujung-ujung struktur.
-
-
-
-
-
-
-
-    \item Mengeksplorasi kemungkinan generalisasi satu model terhadap berbagai jalur kolom hanya dengan memanfaatkan data dari sensor pada kedua ujung kolom.
-\end{enumerate}
-
-
-
-\section{Manfaat Penelitian}
-
-Penelitian ini memberikan beberapa manfaat yang diharapkan dapat berkontribusi dalam pengembangan sistem deteksi kerusakan struktur, antara lain:
-
-\begin{enumerate}
-    \item Penelitian ini tidak berfokus pada pengembangan arsitektur model baru maupun penerapan \textit{transfer learning}, melainkan pada perancangan alur (\textit{pipeline}) klasifikasi yang sederhana dan mudah dipahami sebagai solusi tahap awal untuk pengembangan sistem monitor kesehatan struktur.
-    
-    \item Dengan pemilihan titik sensor strategis yang terbatas (hanya di ujung atas dan bawah jalur kolom \textit{grid}) serta prapemrosesan berbasis transformasi STFT, penelitian ini menunjukkan bahwa efisiensi dapat dicapai tanpa mengorbankan akurasi secara signifikan.
-    
-    \item Studi ini membuktikan bahwa algoritma pembelajaran mesin klasik seperti \gls{svm} \gls{svm}, KNN, dan LDA masih mampu memberikan performa model yang kompetitif dalam klasifikasi kerusakan, apabila dipadukan dengan ekstraksi fitur yang tepat.
-    
-    \item Hasil penelitian ini diharapkan dapat menjadi alternatif sistem SHM yang lebih terjangkau dan praktis untuk diterapkan pada struktur nyata, khususnya dalam kondisi keterbatasan sumber daya.
-    
-    \item Rangkaian eksperimen dan pendekatan sistematis dalam penelitian ini dapat dijadikan tolok ukur atau \textit{baseline} untuk studi komparatif selanjutnya dan pengembangan model arsitektur yang lebih kompleks.
-\end{enumerate}\clearpage{}
-\clearpage{}\chapter{TINJAUAN PUSTAKA DAN LANDASAN TEORI}
-\section{Tinjauan Pustaka}
-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 aplikasi \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}.
-
-\textcite{eraliev2022} memperkenalkan teknik baru untuk mendeteksi dan mengidentifikasi tahap awal kelonggaran pada sambungan baut ganda menggunakan algoritma pembelajaran mesin. Studi ini difokuskan pada sebuah motor yang dikencangkan dengan empat baut dan dioperasikan dalam tiga kondisi putaran berbeda (800 rpm, 1000 rpm, dan 1200 rpm) guna mengumpulkan data getaran yang cukup untuk dianalisis. Studi ini menyoroti keterbatasan metode inspeksi tradisional, seperti inspeksi visual dan teknik pukulan palu, yang dinilai memakan waktu dan rentan terhadap gangguan kebisingan lingkungan \parencite{j.h.park2015, kong2018}.
-
-Untuk meningkatkan akurasi deteksi, \textcite{eraliev2022} menggunakan transformasi Fourier waktu-singkat (STFT) sebagai metode ekstraksi fitur, yang menghasilkan 513 fitur frekuensidari sinyal getaran. Berbagai pengklasifikasi model pemelajaran mesin dilatih dan dievaluasi, dengan hasil menunjukkan performa yang memuaskan dalam mendeteksi baut longgar serta mengidentifikasi baut spesifik yang mulai kehilangan tegangan awal (preload). Studi ini juga menekankan pentingnya penempatan sensor, karena posisi sensor sangat memengaruhi akurasi dari pengklasifikasi yang digunakan \parencite{pham2020}. Temuan penelitian ini menunjukkan bahwa pengklasifikasi pada studi ini dapat digunakan untuk sistem pemantauan baut yang longgar secara daring (\textit{online monitoring}) pada pengaplikasian di masa depan, sehingga berkontribusi dalam pengembangan sistem pemantauan kesehatan struktur yang lebih baik.
-
-STFT diidentifikasi sebagai metode peningkatan sinyal yang efektif, bersanding dengan \textit{wavelet transform} dan \textit{fractional fourier transform}. Keunggulan STFT terletak pada kemampuannya dalam menganalisis sinyal non-stasioner secara lokal, yang dapat meningkatkan kualitas fitur dalam mengenali pola, termasuk dalam tugas-tugas klasifikasi berbasis respon getaran struktur \parencite{zhang2023}.
-
-Lebih lanjut, pendekatan yang dikembangkan oleh \textcite{garrido2016} menunjukkan potensi untuk menjembatani efektivitas fitur domain waktu-frekuensi dengan efisiensi pemrosesan model \textit{end-to-end}. Model ini mengintegrasikan proses STFT langsung ke dalam arsitektur jaringan \textit{feedforward}, memungkinkan sistem untuk tetap menggunakan representasi waktu-frekuensi namun tanpa biaya komputasi berat dari transformasi eksplisit di luar jaringan. Dengan demikian, pendekatan ini menawarkan jalan tengah yang menjanjikan antara kompleksitas 1-D CNN berbasis \textit{real-time raw signal} dan keunggulan struktural dari representasi domain frekuensi. Dalam konteks penelitian ini, meskipun transformasi dilakukan secara eksplisit, gagasan ini mendukung hipotesis bahwa representasi STFT dapat menjadi alternatif yang efisien dan kompetitif dibanding pemrosesan sinyal mentah dalam skenario pembelajaran mesin dengan sensor terbatas.
-
-
-
-
-
-
-\indent Teknik deteksi berbasis getaran terbukti efektif dalam mengidentifikasi tanda-tanda awal anomali pada 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. Misalnya, studi oleh \textcite{zhao2019, eraliev2022} 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.
-
-\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.
-
-\section{Dasar Teori}
-\subsection{Short-Time Fourier Transform (STFT)}
-
-Short-Time Fourier Transform (STFT) adalah teknik fundamental yang digunakan untuk menganalisis sinyal non-stasioner, seperti yang diperoleh dari struktur dalam keadaan menerima beban dinamik atau eksitasi derau putih. Meskipun tradisional transformasi fourier memberikan informasi domain frekuensi, teknik ini tidak memiliki resolusi waktu. STFT mengatasi limitasi tersebut dengan menerapkan transformasi fourier segment-segment sinyal pendek yang tumpang tindih, dengan demikian diperoleh representasi waktu-frekuensi.
-
-Secara matematis, STFT dari sinyal $x(t)$ diberikan sebagai berikut:
-\begin{equation}
-X(m, \omega) = \sum_{n=-\infty}^{\infty} x[n] \cdot w[n - m] \cdot e^{-j \omega n}
-\end{equation}
-
-
-dengan $w(\tau - t)$ adalah sebuah fungsi \textit{windowing} berpusat pada waktu $t$ dan $\omega$ adalah frekuensi angular.
-
-Pada studi ini, STFT digunakan untuk mengekstrak domain waktu-frekuensi dari sinyal getaran yang diperoleh dari dari respon struktur terhadap getaran yang diberikan oleh mesin \textit{shaker}. Fitur-fitur ini kemudian digunakan sebagai input pada klasifikasi pemelajaran mesin. Proces ini merekap frekuensi lokal setiap waktu, yang dinilai krusial pada pengidentifikasian perubahan struktur akibat kerusakan. \subsubsection{Fungsi \textit{Windowing}}
-Fungsi jendela $w(n)$ berfungsi untuk melokalisasi sinyal dalam domain waktu, dengan meruncingkan sinyal di kedua ujungnya guna meminimalkan diskontinuitas. Hal ini sangat penting untuk mengurangi kebocoran spektral—sebuah fenomena di mana energi sinyal menyebar ke bin frekuensi di sekitarnya akibat pemotongan sinyal secara tiba-tiba. Pemilihan jenis jendela sangat memengaruhi resolusi dan akurasi representasi waktu-frekuensi.
- \subsubsection{Hann window}
-Salah satu fungsi \textit{windowing} yang paling umum digunakan dalam STFT adalah \textit{Hann window}. Jendela ni adalah jenis jendela kosinus yang memberikan hasil yang baik antara resolusi frekuensi dan kebocoran spektral. \textit{Hann windowing} diskret dengan panjang $N$ didefinisikan sebagai:
-
-\begin{equation}
-w(n) = 0{.}5 \left(1 - \cos\left( \frac{2\pi n}{N - 1} \right) \right), \quad 0 \leq n \leq N - 1
-\end{equation}
-
-Fungsi ini secara halus meruncingkan sinyal menjadi nol di kedua ujungnya, sehingga mengurangi \textit{side lobe} dalam domain frekuensi sambil mempertahankan lebar \textit{lobe} utama yang relatif sempit. Dibandingkan dengan jendela persegi (rectangular window) yang memiliki tepi tajam, jendela Hann mengurangi fenomena Gibbs dan sangat cocok untuk aplikasi yang melibatkan estimasi spektral.
-
-
-
-
-
-
-
- \subsection{Algoritma Klasifikasi}
-
-Penelitian ini mengevaluasi lima algoritma pemelajaran mesin klasik untuk melakukan tugas pengklasifikasian terhadap lokalisasi kerusakan. Setiap algoritma memiliki keunggulan dan limitasi masing-masing, dan performa untuk setiap algoritma dijadikan tolok ukur untuk mengidentifikasi manakah algoritma yang paling sesuai untuk setiap \textit{dataset} yang diberikan.
-
-\subsubsection{Support Vector Machine (SVM)}
-
-Mesin vektor pendukung (SVM) adalah sebuah algoritma pemelajaran mesin terarah yang mencari \textit{hyperplane} optimal dengan cara memisahkan data ke dalam kelas-kelas dengan margin maksimum. SVM bekerja dengan baik pada ruang dimensi tinggi dan cukup kokoh terhadap \textit{overfitting}, terutama pada kasus yang membutuhkan batasan margin secara jelas \parencite{cortes1995}.
-
-SVM sesuai untuk klasifikasi sinyal getaran karena kemampuannya untuk mengatasi keputusan batasan-batasan non-linier apabila dilengkapi dengan fungsi kernel, seperti fungsi kernel berbasis radial (RBF).
-
-\subsubsection{K-Nearest Neighbors (KNN)}
-
-KNN merupakan sebuah algoritma pemelajaran non-parametrik, berbasis contoh. Algoritma ini mengklasifikasi titik data yang berbasis pada pungutan suara terbanyak dari tetangga terdekat $k$ pada ruang fitur. Meskipun dinilai sederhana, KNN dapat dinilai efektif ketika datanya terdistribusi dengan baik dan batasan-batasan pada kelasnya merata.
-
-Performa algoritma ini sensitif pada pemilihan $k$ dan jarak metriknya. Untuk data dengan dimensi tinggi seperti fitur STFT, mungkin diperlukan optimalisasi atau penskalaan dimensi.
-
-\subsubsection{Decision Tree (DT)}
-
-Decision Tree adalah algoritma pemelajaran terarah (\textit{supervised learning}) berbasis struktur pohon, di mana setiap \textit{node} internal mewakili suatu keputusan berdasarkan atribut tertentu, setiap cabang mewakili hasil dari keputusan tersebut, dan setiap daun (leaf node) mewakili label kelas. Algoritma ini secara rekursif membagi data ke dalam subset berdasarkan fitur yang memberikan informasi paling tinggi, seperti diukur dengan Gini index atau entropi (information gain).
-
-Kelebihan dari Decision Tree adalah interpretabilitasnya yang tinggi dan kemampuannya menangani data numerik maupun kategorikal. Namun, pohon keputusan rentan terhadap \textit{overfitting}, terutama jika kedalaman pohon tidak dikontrol.
-
-\subsubsection{Random Forest (RF)}
-
-Random Forest adalah metode ensemble yang terdiri dari banyak Decision Tree yang dilatih pada subset data dan subset fitur yang diacak. Setiap pohon dalam hutan memberikan prediksi, dan hasil akhir ditentukan melalui agregasi (misalnya, voting mayoritas untuk klasifikasi).
-
-Dengan menggabungkan banyak pohon, Random Forest mengurangi varian model dan meningkatkan generalisasi. Teknik ini efektif untuk dataset yang kompleks dan sangat cocok untuk menghindari \textit{overfitting} yang umum terjadi pada satu pohon keputusan tunggal.
-
-\subsubsection{Bagged Trees (BT)}
-
-\textit{Bagged Trees} atau \textit{Bootstrap Aggregated Trees} adalah pendekatan \textit{ensemble} yang mirip dengan Random Forest, namun perbedaannya terletak pada pemilihan fitur. Dalam \textit{Bagged Trees}, pohon-pohon dibangun dari sampel acak \textit{bootstrap} dari dataset pelatihan, tetapi tanpa pengacakan subset fitur seperti pada Random Forest.
-
-\subsubsection{XGBoost (Extreme Gradient Boosting)}
-
-XGBoost adalah algoritma pemelajaran mesin berbasis \textit{gradient boosting} yang dirancang untuk efisiensi dan performa tinggi. Algoritma ini bekerja dengan membangun model secara bertahap, di mana setiap pohon selanjutnya mencoba memperbaiki kesalahan dari pohon sebelumnya dengan mengoptimasi fungsi kerugian (\textit{loss function}) menggunakan metode gradien.
-
-XGBoost menggabungkan beberapa teknik seperti regularisasi $L1$ dan $L2$, pemangkasan pohon (\textit{pruning}), dan pemrosesan paralel, sehingga menghindari terjadinya \textit{overfitting} dan unggul dalam akurasi prediksi dibanding metode pohon lainnya. Algoritma ini sangat populer dalam kompetisi data karena kemampuannya menangani data besar, fitur multivariat, dan klasifikasi multi-kelas secara efisien.
-
-\subsubsection{Linear Discriminant Analysis (LDA)}
-
-Linear Discriminant Analysis (LDA) adalah teknik klasifikasi dan reduksi dimensi yang mengasumsikan bahwa data berasal dari distribusi normal multivariat dan memiliki kovarians yang seragam untuk setiap kelas. LDA bertujuan untuk memproyeksikan data ke ruang berdimensi lebih rendah yang memaksimalkan pemisahan antar kelas (rasio varians antar kelas terhadap varians dalam kelas).
-
-LDA sangat cocok ketika distribusi data mendekati normal dan jumlah fitur tidak terlalu besar dibanding jumlah sampel. Selain sebagai klasifikator, LDA juga sering digunakan sebagai teknik prapemrosesan untuk ekstraksi fitur sebelum digunakan dalam algoritma lain.
-
-\bigskip 
-Dasar teori ini memberikan kerangka metodologi untuk mengimplementasi dan mengevaluasi usulan sistem lokalisasi kerusakan pada penelitian ini. Kokmbinasi dari analisis waktu-frekuensi menggunakan STFT dan klasifikasi pemelajaran mesin klasik memungkinkan ketercapaian monitor kesehatan struktur yang efisien dan mudah diterapkan.\clearpage{}
-\clearpage{}\chapter{METODE PENELITIAN}
-
-\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.75\linewidth]{chapters/img/specimen.png}
-    \caption{Bentuk benda uji}
-    \label{fig:specimen-photo}
-\end{figure} \section{Alat}
-
-\subsection{Alat Perangkat Keras}
-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:accel393}) untuk merekam respons percepatan pada sebagian besar titik pengukuran.
-    \item \textbf{3 akselerometer B\&K model 8344} (Gambar~\ref{fig:accel393}) 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{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}
- 
-\subsection{Alat Perangkat Lunak}
-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}  \clearpage
-\section{Tahapan Penelitian}
-Alur keseluruhan penelitian ini dilakukan melalui tahapan-tahapan sebagai berikut:
-
-\begin{figure}[H]
-    \centering
-    \includegraphics[width=0.3\linewidth]{chapters/img/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{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}
-Dataset yang digunakan dalam penelitian ini bersumber dari basis data getaran yang dipublikasi oleh \textcite{abdeljaber2017}. Dataset tersebut dapat diakses dan diunduh melalui tautan DOI berikut:  
-\url{https://doi.org/10.17632/52rmx5bjcr.1}
-
-Dataset terdiri dari dua folder:
-\begin{itemize}
-  \item \texttt{Dataset A/} – digunakan untuk pelatihan (training)
-  \item \texttt{Dataset B/} – 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 $t = 256$ detik, sehingga menghasilkan:
-\begin{align}
-\gls{not:signal} &= \gls{not:sampling_freq} \cdot \gls{not:time_length} \nonumber \\
-  &= 1024 \cdot 256 \nonumber \\
-  &= 262144 \quad \text{sampel per kanal} \label{eq:sample}
-\end{align}
-
-Dengan demikian, setiap berkas \verb|zzzAD|$n$\verb|.TXT| dapat direpresentasikan sebagai matriks:
-\begin{equation}
-    \mathbf{D}^{(n)} \in \mathbb{R}^{262144 \times 30}, \quad n = 1, \dots, 30
-\end{equation}
-di mana $n$ mengacu pada indeks kasus (1–30 = kerusakan pada \textit{joint} ke-$n$), dan berkas tanpa kerusakan pada seluruh \textit{joint}, \verb|zzzAU|\verb|.TXT|, direpresentasikan dengan matriks:
-\begin{equation}
-    \mathbf{U} \in \mathbb{R}^{262144 \times 30}
-\end{equation}
-
-
-Kemudian \textit{dataset} A dapat direpresentasikan sebagai matriks:
-\begin{equation}
-  \gls{not:dataset_A}
-  =
-  \Bigl\{
-      \mathbf{U} \in \mathbb{R}^{262144 \times 30}
-  \Bigr\}
-  \;\cup\;
-  \Bigl\{
-      \mathbf{D}^{(n)} \in \mathbb{R}^{262144 \times 30}
-      \;\bigm|\;
-      n = 1, \dots, 30
-  \Bigr\}.
-\end{equation}
- 
-
-
- \section{Analisis Data}
-
-
-
-
-
-\subsection{Grid, Kode \textit{Joint}, dan Nama File}
-
-Masing-masing *sensor node* diberi nama menurut indeks \(n\) (dengan \(n = 0,1,\dots,29\)).  
-Berkas data mentah tiap node disimpan dalam berkas teks berformat
-\texttt{zzzAD<n>.TXT}; penamaannya dapat dirumuskan sebagai  
-
-\[
-Z_{n} \;=\; \texttt{``zzzAD}n\texttt{.TXT''}, 
-\qquad n = 1,\dots,30.
-\]
-
-Pada pembahasan selanjutnya, simbol \(Z_{n}\) dipakai sebagai penunjuk
-berkas data untuk node ke-\(n\). 
-Untuk merujuk satu kanal (kolom) tertentu di dalam matriks
-\(\mathbf{D}^{(n)}\), digunakan notasi
-
-\[
-\gls{not:damage_file}_{s}^{(\gls{not:joint_index})} \in \mathbb{R}^{262144},
-\]
-
-dengan ketentuan:
-
-* superskrip \((\gls{not:joint_index})\) menandakan indeks kasus kerusakan
-  (1–30),
-* subskrip \(s\) menandakan indeks kanal sensor yang dipilih
-  (\(s = 1,\dots,30\)).
-
-Dengan demikian,
-\(\gls{not:damage_file}_{s}^{(n)}\) merepresentasikan sebuah vektor
-\(262144 \times 1\) yang berisi deret waktu hasil pengukuran kanal
-\(s\) pada skenario kerusakan ke-\(n\).
-
-\subsection{Pemetaan Sensor ke Dalam Folder (Damage-case)}
-
-Semua tiga puluh \textit{node} dikelompokkan ke dalam enam folder yang merepresentasikan enam skenario kerusakan, masing-masing dilabeli \(d_{i}\) dengan \(i=0,\dots,5\). Setiap folder mengandung tepat lima \textit{node} berurutan, sehingga didefinisikan:
-\begin{equation*}
-\gls{not:damage_file_set_case}_{i} = \bigl\{
-\,\mathbf{D}_{5i}^{(5i)},
-\;\mathbf{D}_{5i+1}^{(5i+1)},
-\;\mathbf{D}_{5i+2}^{(5i+2)},
-\;\mathbf{D}_{5i+3}^{(5i+3)},
-\;\mathbf{D}_{5i+4}^{(5i+4)}
-\bigr\},
-\quad i = 0,\dots,5.
-\end{equation*}
-\begin{equation}
-    \mathcal{D}_i = \bigl\{
-\end{equation}
-Sebagai contoh 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}\},\\[1ex]
-d_1 &= \{n_{5}^{F_5},\;n_{6}^{F_6},\;n_{7}^{F_7},\;n_{8}^{F_8},\;n_{9}^{F_9}\},\\[1ex]
-&\;\;\vdots\\[1ex]
-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)}
-
-Untuk mensimulasikan tata letak sensor terbatas, dari setiap folder kerusakan hanya diambil \textit{node} pertama dan terakhir. Subset domain waktu ini dilambangkan sebagai
-\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}
-
-Operator STFT \(\mathcal{T}\) didefinisikan untuk memetakan sinyal domain waktu mentah (vektor dengan panjang \(L=262144\)) menjadi spektrogram berukuran \(513\times513\). Langkah-langkahnya adalah:
-\begin{equation*}
-\begin{aligned}
-\text{(1) Fungsi jendela:}\quad
-w[n] &= \frac{1}{2}\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},\\[1ex]
-&\quad
-p = 0,\ldots,512,\quad t = 0,\ldots,512.
-\end{aligned}
-\end{equation*}
-Pengambilan magnitudo menghasilkan matriks spektrogram untuk \textit{node} \(k\) sebagai
-\begin{equation*}
-\widetilde n_{k}^{F_{k}}(p,t) \;=\; \bigl|S_{k}(p,t)\bigr|
-\;\in\;\mathbb{R}^{513\times513}.
-\end{equation*}
-Dengan demikian operator STFT dapat dituliskan sebagai:
-\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}
-
-Operator \(\mathcal{T}\) diterapkan pada \textit{node} ujung-ujung yang telah dipilih, sehingga diperoleh:
-\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 data dari keenam kasus kerusakan digabungkan menjadi dua himpunan:
-\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. Untuk setiap kasus kerusakan \(i\) dan sensor \(s\), vektor fitur ini direplikasi sebanyak 5 kali (indeks pengulangan \(r\in\{0,\dots,4\}\)) dan diambil masing-masing baris/kolom ke-\(t\) dengan
-\begin{equation*}
-\mathbf{x}_{i,s,r,t}\in\mathbb{R}^{513}.
-\end{equation*}
-Label skalar untuk kasus kerusakan dinyatakan sebagai
-\begin{equation*}
-y_{i} = i,\quad i=0,\dots,5.
-\end{equation*}
-Selanjutnya, fungsi \textit{slicing} didefinisikan 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 digabungkan menjadi 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 adalah:
-\begin{equation*}
-|\mathcal{D}^{(s)}| = 15\,390 \times 514.
-\end{equation*} \clearpage{}
-
-
-\printbibliography
-
-
-\end{document}

latex/main-staged1.tex

@@ -1,932 +0,0 @@
-\documentclass[draftmark]{thesis}
-\title{Prediksi Lokasi Kerusakan dengan Machine Learning}
-\author{Rifqi Damar Panuluh}
-\date{\today}
-\authorid{20210110224}
-\firstadvisor{Ir. Muhammad Ibnu Syamsi, Ph.D.}
-\secondadvisor{}
-\headdepartement{Puji Harsanto, S.T., M.T., Ph.D.}
-\headdepartementid{19740607201404123064}
-\faculty{Fakultas Teknik}
-\program{Program Studi Teknik Sipil}
-\university{Universitas Muhammadiyah Yogyakarta}
- \newcommand{\eg}{\textit{e.g.},\ }
-\newcommand{\ie}{\textit{i.e.},\ }
-\newcommand{\etal}{\textit{et al.}}
-
-\let\oldtableofcontents\tableofcontents 
-
-\let\oldaddcontentsline\addcontentsline
-\newcommand{\ADDCONTENTSLINE}[3]{\oldaddcontentsline{#1}{#2}{\MakeUppercase{#3}}}
-\newcommand{\CAPinToC}{\let\addcontentsline\ADDCONTENTSLINE}
-\newcommand{\noCAPinToC}{\let\addcontentsline\oldaddcontentsline}
- 
-\addbibresource{bibliography.bib}
-
-\makeglossaries
-\newacronym{ml}{ML}{machine learning}
-\newacronym{stft}{STFT}{short-time fourier transform}
-\newacronym{ai}{AI}{artificial intelligence}
-\newacronym{dl}{DL}{deep learning}
-\newacronym{nn}{NN}{neural network}
-\newacronym{fft}{FFT}{fast fourier transform}
-\newacronym{svm}{SVM}{support vector machine}
-\newacronym{cnn}{CNN}{convolutional neural network}
-\newacronym{rnn}{RNN}{recurrent neural network}
-\newacronym{vbi}{VBI}{vibration-based inspection}
-\newacronym{shm}{SHM}{structural health monitoring}
-\newacronym{fea}{FEA}{finite element analysis}
-\newacronym{1d-cnn}{1-D CNN}{\textit{One-Dimensional Convolutional Neural Network}}
- \newglossaryentry{jaringansaraf}{
-  name=Jaringan Saraf,
-  description={The Indonesian term for \gls{nn}}
-}
-
-
-
-
-\newglossaryentry{algoritma-genetika}{
-  name={Algoritma Genetika},
-  description={Kelas algoritma optimasi dan pencarian yang terinspirasi oleh proses evolusi biologis, seperti seleksi alam, mutasi, dan rekombinasi. Algoritma ini sering digunakan untuk menemukan solusi perkiraan untuk masalah yang kompleks dan sulit dipecahkan secara analitis.},
-  sort={Algoritma Genetika}
-}
-
-\newglossaryentry{deep-learning}{
-  name={\textit{deep learning}},
-  description={Bagian dari keluarga metode pembelajaran mesin yang lebih luas berdasarkan jaringan saraf tiruan dengan banyak lapisan (deep neural networks). Arsitektur ini memungkinkan model untuk belajar representasi data secara hierarkis, mulai dari fitur tingkat rendah hingga konsep abstrak tingkat tinggi.},
-  sort={Pembelajaran Mendalam}
-}
-
-\newglossaryentry{jaringan-saraf-tiruan}{
-  name={Jaringan Saraf Tiruan (Artificial Neural Network)},
-  description={Model komputasi yang terinspirasi oleh struktur dan fungsi jaringan saraf biologis di otak. JST terdiri dari unit pemrosesan yang saling terhubung (neuron) yang bekerja secara paralel untuk memproses informasi dan belajar dari data melalui penyesuaian bobot koneksi.},
-  sort={Jaringan Saraf Tiruan}
-}
-
-\newglossaryentry{pemrosesan-bahasa-alami}{
-  name={Pemrosesan Bahasa Alami (Natural Language Processing)},
-  description={Cabang ilmu komputer dan kecerdasan buatan yang berfokus pada interaksi antara komputer dan bahasa manusia. Tujuannya adalah untuk memungkinkan komputer memproses, memahami, menafsirkan, dan menghasilkan bahasa manusia dengan cara yang bermakna dan berguna.},
-  sort={Pemrosesan Bahasa Alami}
-}
-
-\newglossaryentry{pembelajaran-penguatan}{
-  name={Pembelajaran Penguatan (Reinforcement Learning)},
-  description={Area pembelajaran mesin yang berkaitan dengan bagaimana agen perangkat lunak harus mengambil tindakan dalam suatu lingkungan untuk memaksimalkan beberapa gagasan tentang imbalan kumulatif. Agen belajar melalui trial-and-error, menerima umpan balik berupa imbalan atau hukuman.},
-  sort={Pembelajaran Penguatan}
-}
-
-\newglossaryentry{visi-komputer}{
-  name={Visi Komputer (Computer Vision)},
-  description={Bidang interdisipliner yang membahas bagaimana komputer dapat dibuat untuk mendapatkan pemahaman tingkat tinggi dari gambar atau video digital. Dari perspektif rekayasa, ia berupaya mengotomatiskan tugas-tugas yang dapat dilakukan oleh sistem visual manusia.},
-  sort={Visi Komputer}
-}
-
-\newglossaryentry{model-generatif}{
-  name={Model Generatif},
-  description={Jenis model statistik dalam pembelajaran mesin yang bertujuan untuk mempelajari distribusi probabilitas dari data pelatihan. Setelah dilatih, model ini dapat menghasilkan sampel data baru yang mirip dengan data pelatihan, seperti membuat gambar, teks, atau suara baru.},
-  sort={Model Generatif}
-}
-
-\newglossaryentry{heuristik}{
-  name={Heuristik},
-  description={Teknik pemecahan masalah yang menggunakan pendekatan praktis atau jalan pintas yang tidak dijamin optimal atau sempurna, tetapi cukup untuk mencapai tujuan jangka pendek atau perkiraan solusi. Heuristik sering digunakan ketika pencarian solusi optimal terlalu mahal secara komputasi.},
-  sort={Heuristik}
-}
-
-\newglossaryentry{validasi-silang}{
-  name={Validasi Silang (Cross-Validation)},
-  description={Teknik statistik untuk mengevaluasi seberapa baik hasil analisis statistik (seperti model prediktif) akan generalisasi ke kumpulan data independen. Ini penting untuk menghindari overfitting dan mendapatkan estimasi kinerja model yang lebih andal pada data yang belum pernah dilihat.},
-  sort={Validasi Silang}
-}
-
-\newglossaryentry{bias-algoritmik}{
-  name={Bias Algoritmik},
-  description={Mengacu pada kesalahan sistematis atau hasil yang tidak adil yang dihasilkan oleh sistem kecerdasan buatan karena asumsi yang salah dalam proses pembelajaran mesin atau karena data pelatihan yang bias. Bias ini dapat mereplikasi atau bahkan memperkuat prasangka sosial yang ada.},
-  sort={Bias Algoritmik}
-} 
-
-\newglossaryentry{not:signal}{
-    name={\ensuremath{S}},
-    description={vektor sinyal akselerometer berdimensi 1$\times$262144},
-    sort={s},
-    type=notation,
-}
-
-\newglossaryentry{not:sampling_freq}{
-    name={\ensuremath{f_s}},
-    description={frekuensi dengan nilai \textit{sampling} ($s$) di mana sinyal kontinu didigitalkan},
-    sort={fs},
-    type=notation,
-}
-
-\newglossaryentry{not:time_length}{
-    name={\ensuremath{t}},
-    description={panjang waktu data dalam detik},
-    sort={t},
-    type=notation,
-}
-
-\newglossaryentry{not:dataset_A}{
-    name={\ensuremath{\mathcal{A}}},
-    description={matriks dataset A},
-    sort={adataset},
-    type=notation,
-}
-
-\newglossaryentry{not:dataset_B}{
-    name={\ensuremath{\mathcal{B}}},
-    description={matriks dataset B},
-    sort={bdataset},
-    type=notation,
-}
-
-\newglossaryentry{not:damage_file}{
-    name={\ensuremath{\mathbf{D}}},
-    description={matriks akselerometer untuk setiap berkas dengan bentuk $262144\times30$},
-    sort={filedamage},
-    type=notation,
-}
-\newglossaryentry{not:joint_index}{
-    name={\ensuremath{n}},
-    description={indeks atau nomor kerusakan \textit{joint}},
-    sort={indexjoint},
-    type=notation,
-}
-\newglossaryentry{not:damage_file_set_case}{
-    name={\ensuremath{\mathbf{d}}},
-    description={set matriks kerusakan},
-    sort={damagefilesetcase},
-    type=notation,
-}
-
-\newglossaryentry{not:k}{
-  name={$k$},
-  description={Index for measurement nodes, an integer ranging from 0 to 29.},
-  sort={k},
-  type=notation,
-}
-
-\newglossaryentry{not:Fk}{
-  name={$F_{k}$},
-  description={Filename string for the raw time-domain signal from node $k$. The specific format mentioned is \texttt{zzzAD}$k$\texttt{.TXT}.},
-  sort={Fk},
-  type=notation,
-}
-
-\newglossaryentry{not:nkFk}{
-  name={$n_{k}^{F_{k}}$},
-  description={Represents the measurement \textit{node} with index $k$. The raw time-domain signal data from this node, $x_k$, has a length of $L=262144$ samples.},
-  sort={nkFk},
-  type=notation,
-}
-
-\newglossaryentry{not:i}{
-  name={$i$},
-  description={Index for ``damage-case'' folders, an integer ranging from 0 to 5.},
-  sort={i},
-  type=notation,
-}
-
-\newglossaryentry{not:di}{
-  name={$d_{i}$},
-  description={Set representing the $i$-th damage scenario, containing data from five consecutive nodes: $\bigl\{\,n_{5i}^{F_{5i}},\;n_{5i+1}^{F_{5i+1}},\;\dots,\;n_{5i+4}^{F_{5i+4}}\bigr\}$. Cardinality: $|d_i|=5$ nodes.},
-  sort={di},
-  type=notation,
-}
-
-\newglossaryentry{not:diTD}{
-  name={$d_{i}^{\mathrm{TD}}$},
-  description={Time-domain subset of nodes from damage case $d_i$, containing only the first and last nodes: $\bigl\{\,n_{5i}^{F_{5i}},\;n_{5i+4}^{F_{5i+4}}\bigr\}$. Cardinality: $|d_{i}^{\mathrm{TD}}| = 2$ nodes.},
-  sort={diTD},
-  type=notation,
-}
-
-\newglossaryentry{not:calT}{
-  name={$\mathcal{T}$},
-  description={Short-Time Fourier Transform (STFT) operator. It maps a raw time-domain signal $n_k^{F_k}$ (or $x_k$) from $\mathbb{R}^{L}$ (with $L=262144$) to a magnitude spectrogram matrix $\widetilde{n}_k^{F_k}$ in $\mathbb{R}^{513 \times 513}$.},
-  sort={Tcal},
-  type=notation,
-}
-
-\newglossaryentry{not:L}{
-  name={$L$},
-  description={Length of the raw time-domain signal, $L=262144$ samples.},
-  sort={L},
-  type=notation,
-}
-
-\newglossaryentry{not:Nw}{
-  name={$N_{w}$},
-  description={Length of the Hanning window used in the STFT, $N_{w}=1024$ samples.},
-  sort={Nw},
-  type=notation,
-}
-
-\newglossaryentry{not:Nh}{
-  name={$N_{h}$},
-  description={Hop size (or step size) used in the STFT, $N_{h}=512$ samples.},
-  sort={Nh},
-  type=notation,
-}
-
-\newglossaryentry{not:wn}{
-  name={$w[n]$},
-  description={Value of the Hanning window function at sample index $n$. The window spans $N_w$ samples.},
-  sort={wn},
-  type=notation,
-}
-
-\newglossaryentry{not:n_summation}{
-  name={$n$},
-  description={Sample index within the Hanning window and for the STFT summation, an integer ranging from $0$ to $N_w-1$.},
-  sort={n_summation},
-  type=notation,
-}
-
-\newglossaryentry{not:xkm}{
-  name={$x_k[m]$}, description={Represents the raw time-domain signal for node $k$. As a discrete signal, it consists of $L=262144$ samples. $x_k[m]$ would be the $m$-th sample.},
-  sort={xkm},
-  type=notation,
-}
-
-\newglossaryentry{not:Skpt}{
-  name={$S_k(p,t)$},
-  description={Complex-valued result of the STFT for node $k$ at frequency bin $p$ and time frame $t$. This is a scalar value for each $(p,t)$ pair.},
-  sort={Skpt},
-  type=notation,
-}
-
-\newglossaryentry{not:p}{
-  name={$p$},
-  description={Frequency bin index in the STFT or spectrogram, an integer ranging from $0$ to $512$.},
-  sort={p},
-  type=notation,
-}
-
-\newglossaryentry{not:t_stft}{ name={$t$},
-  description={Time frame index in the STFT or spectrogram, an integer ranging from $0$ to $512$. Also used as the time slice index for extracting feature vectors $\mathbf{x}_{i,s,r,t}$ from spectrograms.},
-  sort={t},
-  type=notation,
-}
-
-\newglossaryentry{not:ntildekFk}{ name={$\widetilde{n}_k^{F_k}$},
-  description={The magnitude spectrogram matrix for node $k$, obtained by applying the STFT operator $\mathcal{T}$ to the time-domain signal $n_k^{F_k}$. This matrix is an element of $\mathbb{R}^{513 \times 513}$.},
-  sort={ntildekFk},
-  type=notation,
-}
-
-\newglossaryentry{not:ntildekFkpt}{ name={$\widetilde{n}_k^{F_k}(p,t)$},
-  description={Scalar value representing the magnitude of the STFT for node $k$ at frequency bin $p$ and time frame $t$; specifically, $\widetilde{n}_k^{F_k}(p,t) = |S_k(p,t)|$. This is an element of the spectrogram matrix $\widetilde{n}_k^{F_k}$.},
-  sort={ntildekFkpt},
-  type=notation,
-}
-
-\newglossaryentry{not:R}{
-  name={$\mathbb{R}$},
-  description={The set of real numbers. Used to denote vector spaces like $\mathbb{R}^{N}$ (N-dimensional real vectors) or $\mathbb{R}^{M \times N}$ (M-by-N real matrices).},
-  sort={Rbb},
-  type=notation,
-}
-
-\newglossaryentry{not:diFD}{
-  name={$d_{i}^{\mathrm{FD}}$},
-  description={Frequency-domain subset for damage case $i$. It contains two spectrogram matrices: $\bigl\{\,\widetilde{n}_{5i}^{F_{5i}},\; \widetilde{n}_{5i+4}^{F_{5i+4}}\,\bigr\}$, where each spectrogram $\widetilde{n}$ is in $\mathbb{R}^{513 \times 513}$. Cardinality: $|d_{i}^{\mathrm{FD}}| = 2$ spectrograms.},
-  sort={diFD},
-  type=notation,
-}
-
-\newglossaryentry{not:r_repetition}{
-  name={$r$},
-  description={Repetition index within a single damage case, an integer ranging from $0$ to $4$.},
-  sort={r_repetition},
-  type=notation,
-}
-
-\newglossaryentry{not:xboldisr}{
-  name={$\mathbf{x}_{i,s,r,t}$},
-  description={Feature vector (a row or column, often referred to as a time slice) taken from the $r$-th spectrogram repetition, for damage case $i$ and sensor side $s$, at time slice $t$. This vector is an element of $\mathbb{R}^{513}$.},
-  sort={xisrt_bold},
-  type=notation,
-}
-
-\newglossaryentry{not:s_sensor}{
-  name={$s$},
-  description={Index representing the sensor side (e.g., identifying Sensor A or Sensor B).},
-  sort={s_sensor},
-  type=notation,
-}
-
-\newglossaryentry{not:yi}{
-  name={$y_{i}$},
-  description={Scalar label for the damage case $i$, defined as $y_i = i$. This is an integer value from 0 to 5.},
-  sort={yi},
-  type=notation,
-}
-
-\newglossaryentry{not:Lambda}{
-  name={$\Lambda(i,s,r,t)$},
-  description={Slicing function that concatenates a feature vector $\mathbf{x}_{i,s,r,t} \in \mathbb{R}^{513}$ with its corresponding damage case label $y_i \in \mathbb{R}$, resulting in a combined vector $\bigl[\,\mathbf{x}_{i,s,r,t}, \;y_{i}\bigr] \in \mathbb{R}^{514}$.},
-  sort={Lambda},
-  type=notation,
-}
-
-\newglossaryentry{not:calDs}{
-  name={$\mathcal{D}^{(s)}$},
-  description={The complete dataset for sensor side $s$. It is a collection of $15390$ data points, where each point is a vector in $\mathbb{R}^{514}$ (513 features + 1 label). Thus, the dataset can be viewed as a matrix of size $15390 \times 514$.},
-  sort={Dcal_s},
-  type=notation,
-}
-
-%
- 
-\begin{document}
-\frontmatter
-\begin{titlepage}
-\centering
-\vspace*{1cm}
-
-{\fontsize{14pt}{16pt}\selectfont \textbf{\MakeUppercase{Tugas Akhir}}\par}
-\vspace{1.5cm}
-
-{\fontsize{14pt}{16pt}\selectfont \textbf{\MakeUppercase{\thetitle}}\par}
-\vspace{1.5cm}
-
-\includegraphics[width=5cm]{frontmatter/img/logo.png}
-\vspace{1.5cm}
-
-\textbf{Disusun oleh:} \\
-{\fontsize{14pt}{16pt}\selectfont \textbf{\theauthor}} \\
-{\fontsize{14pt}{16pt}\selectfont \textbf{\theauthorid}} \\
-
-\vfill
-
-{\fontsize{12pt}{14pt}\selectfont
-\textbf{\MakeUppercase\theprogram} \\
-\textbf{\MakeUppercase\thefaculty} \\
-\textbf{\MakeUppercase\theuniversity} \\
-}
-
-\end{titlepage}
-
- \begin{titlepage}
-\centering
-{\fontsize{14pt}{16pt}\selectfont \textbf{\MakeUppercase{Tugas Akhir}}\par}
-\vspace{1.5cm}
-
-{\fontsize{14pt}{16pt}\selectfont \textbf{\MakeUppercase{\thetitle}}\par}
-\vspace{1cm}
-{\normalsize\selectfont Diajukan guna melengkapi persyaratan untuk memenuhi gelar Sarjana Teknik di Program Studi Teknik Sipil, Fakultas Teknik, Universitas Muhammadiyah Yogyakarta\par}
-\vspace{1.5cm}
-
-\includegraphics[width=5cm]{frontmatter/img/logo.png}
-\vspace{1.5cm}
-
-
-\textbf{Disusun oleh:} \\
-{\fontsize{14pt}{16pt}\selectfont \textbf{\theauthor}} \\
-{\fontsize{14pt}{16pt}\selectfont \textbf{\theauthorid}} \\
-
-
-\vfill
-
-{\fontsize{12pt}{14pt}\selectfont
-\textbf{\MakeUppercase\theprogram} \\
-\textbf{\MakeUppercase\thefaculty} \\
-\textbf{\MakeUppercase\theuniversity} \\
-}
-
-\end{titlepage}
-
- \glsaddall[types={main,notation,\acronymtype}]
-
-\printglossary[type=notation,style=altlong3customheader,title=Daftar Simbol dan Lambang]
-\printglossary[type=\acronymtype,style=supercol,title=Daftar Singkatan]
-\printglossary[type=main,style=mylistalt]
-\chapter{Abstrak}
-\singlespacing
-\noindent Monitoring Kesehatan Struktur (SHM) secara tradisional membutuhkan banyak sensor dan model yang kompleks, sehingga tidak praktikal untuk pengaplikasian di lapangan. Studi ini menginvestigasi apakah sinyal yang direkam hanya pada sensor ujung atas dan bawah dari kolom-kolom grup sensor cukup untuk memberikan informasi yang akurat pada klasifikasi lokasi kerusakan. Pengujian dilakukan pada dataset QUGS, sebuhah struktur \textit{grid} baja dengan jumlah \textit{node} 6$\times$5 terpasang sensor akselerometer dan digetarkan pada \textit{white noise shaker}. Sinyal getaran dikonversi menjadi fitur frekuensi-waktu menggunakan STFT dan lima algoritma \textit{machine learning} digunakan untuk klasifikasi. Setiap kolom grup dievaluasi dengan \textit{cross-validation} untuk menguji generalisasi model. Hasil menunjukkan bahwa dengan jumlah sensor yang tereduksi, lima algoritma \textit{machine learning} mencapai akurasi klasifikasi lebih dari 90\%. Studi ini menunjukkan bahwa posisi sensor yang strategis dan ekstraksi fitur berbasis STFT cukup untuk mendeteksi lokasi kerusakan secara efektif dan menjadi alternatif yang simpel untuk pendekatan monitoring kesehatan struktur yang kompleks.
-
-\cleardoublepage
-
-\chapter{\textit{Abstract}}
-\noindent \textit{Structural Health Monitoring (SHM) traditionally requires dense sensor arrays and complex models, which can be impractical for field deployment. This study investigates whether vibration signals captured from only the top and bottom sensors of grouped structural columns retain sufficient information for accurate damage location classification. Experiments are conducted on the QUGS dataset, which represents a 6$\times$5 steel-frame grid structure under controlled laboratory conditions. Vibration signals are converted into time-frequency features using the Short-Time Fourier Transform (STFT), and five classical machine learning algorithms, including Support Vector Machines (SVM), are used for classification. Each vertical column group is evaluated through cross-validation to test generalisation across paths. Results show that even with reduced sensor input, all five algorithms achieve over 90\% classification accuracy. These findings demonstrate that strategic sensor placement and STFT-based features are sufficient to detect structural damage effectively, offering a simple and interpretable alternative to more complex SHM approaches} \mainmatter
-\clearpage{}\chapter{PENDAHULUAN}
-
-\section{Latar Belakang}
-
-\indent Asep Kesehatan Struktur (\textit{Structural Health Monitoring} atau SHM) merupakan riset penting yang tersebar di berbagai disiplin ilmu, termasuk teknik dirgantara, teknik sipil, dan teknik mesin. Tujuan utama dari monitor kesehatan struktur adalah memastikan keamanan dan keandalan struktur dengan mendeteksi kerusakan sedini mungkin. Dengan mengombinasikan teknologi sensor yang canggih serta pengolahan data secara \textit{real-time}, sistem monitor kesehatan struktur menjadi kekuatan para insinyur untuk memonitor integritas struktur, strategi optimisasi \textit{maintenance}, dan memprediksi sisa umur struktur. 
-
-\indent Sistem SHM yang tangguh mengikuti \textit{framework} secara hierarkis untuk mengidentifikasi dan menilai kerusakan struktural. Menurut \textcite{rytter1993}, lima tahapan SHM tersebut adalah: 
-\begin{enumerate}
-    \item (Tingkat 1) Keberadaan Kerusakan: Menentukan apakah ada kerusakan pada struktur. Pada tahap ini, pengukuran getaran cukup untuk memastikan adanya kerusakan.
-    \item (Tingkat 2) Lokasi Kerusakan: Mengidentifikasi lokasi geometris kerusakan, baik kerusakan tunggal maupun ganda.
-    \item (Tingkat 3) Tipe Kerusakan: Mencirikan sifat kerusakan, yang dapat meliputi retakan, perubahan pada kondisi tumpuan, atau perubahan dalam sambungan struktur.
-    \item (Tingkat 4) Tingkat Keparahan: Mengukur secara kuantitatif seberapa parah kerusakan terjadi. Biasanya melalui eksperimen atau model terkalibrasi yang menggambarkan efek kerusakan, seperti penurunan kekakuan atau panjang retakan.
-    \item (Tingkat 5): Memprediksi sisa umur pakai struktur dengan mengandalkan pemantauan secara \textit{real-time} dan komprehensif serta model dengan fidelitas tinggi yang menggambarkan perkembangan kerusakan seiring waktu.
-\end{enumerate}
-Semakin tinggi tingkat identifikasi kerusakan, semakin besar pula kebutuhan akan sensor yang presisi, algoritma yang kompleks, serta parameter model yang akurat. Jika pada Tingkat 1 hanya diperlukan data yang terbatas untuk mendeteksi adanya kerusakan, maka Tingkat 5 membutuhkan akuisisi data secara \textit{real-time} dan canggih serta model prediktif yang memiliki fidelitas tinggi. 
-
-\par Tantangan utama terletak pada pengembangan sistem \acrshort{shm} yang mampu mengakomodasi berbagai tahapan identifikasi kerusakan secara efektif, baik dalam kondisi operasional normal maupun dalam situasi ekstrem seperti gempa bumi.
-
-\par Dalam konteks pengembangan sistem \acrshort{shm} yang efektif, perlu memperhatikan elemen struktural yang rentan terhadap kerusakan namun sering kali terabaikan dalam pemantauan konvensional. Salah satu komponen struktural yang umum digunakan dalam penyambungan adalah sambungan baut (\textit{bolt joint}), yang dikenal karena kemudahan dalam perakitan dan penggunaannya. Namun, sambungan berulir ini rentan mengalami kelonggaran akibat beban kejut atau getaran terus-menerus \parencite{chen2017}. Kelonggaran baut yang tidak terdeteksi sejak dini dapat menyebabkan kerusakan serius pada struktur, sehingga identifikasi dini terhadap kerusakan sambungan baut menjadi krusial dalam bidang teknik sipil, mesin, dan kedirgantaraan. Pemantauan kondisi sambungan ini tidak hanya relevan dalam konteks deteksi dini (Tingkat 1), tetapi juga sangat penting untuk diagnosis kerusakan dan penentuan lokasi secara akurat (Tingkat 2), seiring dengan meningkatnya kebutuhan akan sistem \acrshort{shm} yang responsif dan adaptif terhadap dinamika kerusakan struktural. 
-
-\indent Deteksi kelonggaran baut telah dilakukan melalui berbagai metode. Kelompok pertama adalah inspeksi \textit{in-situ}, seperti inspeksi visual atau penggunaan alat mekanis seperti kunci torsi dan palu. Meskipun sederhana dan murah, metode ini sulit untuk mendeteksi kerusakan pada tahap awal \parencite{j.h.park2015}. Metode palu lebih efektif dibanding visual untuk mendeteksi awal kelonggaran, tetapi akurasinya dapat terganggu oleh kebisingan lingkungan, serta memakan waktu bila diaplikasikan pada struktur dengan banyak sambungan seperti jembatan \parencite{j.h.park2015,wang2013}.
-
-\indent Kelompok kedua menggunakan teknik berbasis penglihatan komputer seperti kamera dan pencitraan digital, termasuk deteksi rotasi kepala baut menggunakan CNN dan Faster R-CNN \parencite{zhang2020,zhao2019}. Meskipun teknik ini dapat mendeteksi kerusakan secara visual tanpa dipengaruhi oleh kebisingan akustik, tantangan tetap ada dalam hal penempatan kamera dan beban komputasi tinggi dari model \gls{deep-learning}, terutama dalam kondisi ruang yang sangat seperti mesin kendaraan atau turbin.
-
-\indent Kelompok ketiga dan yang menjadi fokus penelitian ini adalah teknik berbasis sensor, terutama pendekatan berbasis getaran (\textit{vibration-based}). Metode ini tidak hanya efektif dalam mengatasi keterbatasan teknik sebelumnya, tetapi juga mampu mendeteksi kelonggaran baut pada tahap awal secara baik dan akurat \parencite{nichols2004,razi2013}. Dalam penelitian ini, deteksi dilakukan melalui data akselerasi struktur yang diambil dari titik-titik sambungan dalam \textit{sistem grid} yang mewakili koneksi baut secara arah kolom.
-
-\indent Penelitian oleh \textcite{abdeljaber2017} merupakan tonggak penting dalam sistem pemantauan kesehatan struktur (SHM), dengan menerapkan 30 model \acrlong{1d-cnn} pada 30 sensor akselerometer dalam struktur grid QUGS. Pendekatan ini menunjukkan bahwa metode pembelajaran mendalam sangat efektif dalam mendeteksi dan melokalisasi kerusakan dengan presisi tinggi. Namun, metode tersebut memerlukan sumber daya komputasi yang besar karena pemrosesan paralel data mentah berdimensi tinggi dari seluruh sensor \parencite{yang2020, liu2022}. 
-
-\indent Menanggapi tantangan ini, studi lanjutan seperti \parencite{shahid2022, doi:10.1007/s13349-023-00715-3} memperkenalkan pendekatan VMD-HT-CNN yang menggabungkan teknik ekstraksi fitur berbasis Variational Mode Decomposition (VMD) dan Hilbert Transform (HT) sebelum klasifikasi CNN. Metode ini secara signifikan meningkatkan efisiensi pelatihan dan akurasi deteksi meskipun dengan jumlah sensor yang lebih sedikit. 
-
-\indent Berdasarkan celah ini, penelitian ini mengadopsi strategi pengurangan jumlah sensor menjadi dua per jalur kolom (atas dan bawah), merepresentasikan sambungan vertikal seperti susunan baut, untuk menyederhanakan model tanpa kehilangan akurasi deteksi kerusakan. Data diubah melalui transformasi STFT sebelum diklasifikasikan menggunakan berbagai model pembelajaran mesin klasik. Dengan evaluasi antar berbagai pengklasifikasi dan validasi silang antar kolom, studi ini berkontribusi pada pengembangan sistem SHM yang efisien, hemat biaya, dan mudah diimplementasikan.
-
-
-
-\section{Rumusan Masalah}
-Untuk memandu arah penelitian ini, beberapa permasalahan utama yang akan dibahas adalah sebagai berikut:
-
-\begin{enumerate}
-    \item Apakah sinyal getaran yang hanya diperoleh dari sensor pada bagian atas dan bawah suatu jalur kolom masih mampu merepresentasikan fitur-fitur penting yang diperlukan untuk mengklasifikasikan kerusakan struktur secara akurat?
-
-    \item Apakah penggabungan data dari beberapa jalur kolom dapat meningkatkan kemampuan generalisasi model, meskipun jumlah sensor pada tiap jalur dibatasi?
-
-    \item Apakah algoritma pemelajaran mesin klasik yang sederhana masih mampu menghasilkan model dengan kinerja yang cukup layak dibandingkan dengan model \textit{supervised} yang lebih kompleks ketika diterapkan pada skenario dengan input data sensor yang terbatas?
-\end{enumerate}
-
-
-
-
-\section{Lingkup Penelitian}
-Studi ini berfokus pada dataset yang tersedia secara publik didapat dari Queen's University Grandstand Simulator (QUGS), sebuah kerangka besi level laboratorium yang dipasang dengan tiga puluh titik sensor akselerometer dan \textit{white shaker noise}. Riset terdahulu telah dilakukan pengaplikasian pemelajaran mesin jaringan saraf terhadap seluruh sensor yang terpasang penuh pada setiap titik \textit{joint} untuk mencapai akurasi yang tinggi. Akan tetapi, pada praktiknya, instrumentasi penuh seperti ini terkadang kurang efektif dari segi biaya dan kurang layak dalam skala besar.
-
-\section{Tujuan Penelitian}
-\begin{enumerate}
-    \item Mengembangkan alur sistem (\textit{pipeline}) pemantauan kesehatan struktur (Structural Health Monitoring/SHM) yang disederhanakan dengan hanya menggunakan sepasang sensor di ujung-ujung struktur.
-
-
-
-
-
-
-
-    \item Mengeksplorasi kemungkinan generalisasi satu model terhadap berbagai jalur kolom hanya dengan memanfaatkan data dari sensor pada kedua ujung kolom.
-\end{enumerate}
-
-
-
-\section{Manfaat Penelitian}
-
-Penelitian ini memberikan beberapa manfaat yang diharapkan dapat berkontribusi dalam pengembangan sistem deteksi kerusakan struktur, antara lain:
-
-\begin{enumerate}
-    \item Penelitian ini tidak berfokus pada pengembangan arsitektur model baru maupun penerapan \textit{transfer learning}, melainkan pada perancangan alur (\textit{pipeline}) klasifikasi yang sederhana dan mudah dipahami sebagai solusi tahap awal untuk pengembangan sistem monitor kesehatan struktur.
-    
-    \item Dengan pemilihan titik sensor strategis yang terbatas (hanya di ujung atas dan bawah jalur kolom \textit{grid}) serta prapemrosesan berbasis transformasi STFT, penelitian ini menunjukkan bahwa efisiensi dapat dicapai tanpa mengorbankan akurasi secara signifikan.
-    
-    \item Studi ini membuktikan bahwa algoritma pembelajaran mesin klasik seperti \gls{svm} \gls{svm}, KNN, dan LDA masih mampu memberikan performa model yang kompetitif dalam klasifikasi kerusakan, apabila dipadukan dengan ekstraksi fitur yang tepat.
-    
-    \item Hasil penelitian ini diharapkan dapat menjadi alternatif sistem SHM yang lebih terjangkau dan praktis untuk diterapkan pada struktur nyata, khususnya dalam kondisi keterbatasan sumber daya.
-    
-    \item Rangkaian eksperimen dan pendekatan sistematis dalam penelitian ini dapat dijadikan tolok ukur atau \textit{baseline} untuk studi komparatif selanjutnya dan pengembangan model arsitektur yang lebih kompleks.
-\end{enumerate}\clearpage{}
-\clearpage{}\chapter{TINJAUAN PUSTAKA DAN LANDASAN TEORI}
-\section{Tinjauan Pustaka}
-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 aplikasi \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}.
-
-\textcite{eraliev2022} memperkenalkan teknik baru untuk mendeteksi dan mengidentifikasi tahap awal kelonggaran pada sambungan baut ganda menggunakan algoritma pembelajaran mesin. Studi ini difokuskan pada sebuah motor yang dikencangkan dengan empat baut dan dioperasikan dalam tiga kondisi putaran berbeda (800 rpm, 1000 rpm, dan 1200 rpm) guna mengumpulkan data getaran yang cukup untuk dianalisis. Studi ini menyoroti keterbatasan metode inspeksi tradisional, seperti inspeksi visual dan teknik pukulan palu, yang dinilai memakan waktu dan rentan terhadap gangguan kebisingan lingkungan \parencite{j.h.park2015, kong2018}.
-
-Untuk meningkatkan akurasi deteksi, \textcite{eraliev2022} menggunakan transformasi Fourier waktu-singkat (STFT) sebagai metode ekstraksi fitur, yang menghasilkan 513 fitur frekuensidari sinyal getaran. Berbagai pengklasifikasi model pemelajaran mesin dilatih dan dievaluasi, dengan hasil menunjukkan performa yang memuaskan dalam mendeteksi baut longgar serta mengidentifikasi baut spesifik yang mulai kehilangan tegangan awal (preload). Studi ini juga menekankan pentingnya penempatan sensor, karena posisi sensor sangat memengaruhi akurasi dari pengklasifikasi yang digunakan \parencite{pham2020}. Temuan penelitian ini menunjukkan bahwa pengklasifikasi pada studi ini dapat digunakan untuk sistem pemantauan baut yang longgar secara daring (\textit{online monitoring}) pada pengaplikasian di masa depan, sehingga berkontribusi dalam pengembangan sistem pemantauan kesehatan struktur yang lebih baik.
-
-STFT diidentifikasi sebagai metode peningkatan sinyal yang efektif, bersanding dengan \textit{wavelet transform} dan \textit{fractional fourier transform}. Keunggulan STFT terletak pada kemampuannya dalam menganalisis sinyal non-stasioner secara lokal, yang dapat meningkatkan kualitas fitur dalam mengenali pola, termasuk dalam tugas-tugas klasifikasi berbasis respon getaran struktur \parencite{zhang2023}.
-
-Lebih lanjut, pendekatan yang dikembangkan oleh \textcite{garrido2016} menunjukkan potensi untuk menjembatani efektivitas fitur domain waktu-frekuensi dengan efisiensi pemrosesan model \textit{end-to-end}. Model ini mengintegrasikan proses STFT langsung ke dalam arsitektur jaringan \textit{feedforward}, memungkinkan sistem untuk tetap menggunakan representasi waktu-frekuensi namun tanpa biaya komputasi berat dari transformasi eksplisit di luar jaringan. Dengan demikian, pendekatan ini menawarkan jalan tengah yang menjanjikan antara kompleksitas 1-D CNN berbasis \textit{real-time raw signal} dan keunggulan struktural dari representasi domain frekuensi. Dalam konteks penelitian ini, meskipun transformasi dilakukan secara eksplisit, gagasan ini mendukung hipotesis bahwa representasi STFT dapat menjadi alternatif yang efisien dan kompetitif dibanding pemrosesan sinyal mentah dalam skenario pembelajaran mesin dengan sensor terbatas.
-
-
-
-
-
-
-\indent Teknik deteksi berbasis getaran terbukti efektif dalam mengidentifikasi tanda-tanda awal anomali pada 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. Misalnya, studi oleh \textcite{zhao2019, eraliev2022} 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.
-
-\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.
-
-\section{Dasar Teori}
-\subsection{Short-Time Fourier Transform (STFT)}
-
-Short-Time Fourier Transform (STFT) adalah teknik fundamental yang digunakan untuk menganalisis sinyal non-stasioner, seperti yang diperoleh dari struktur dalam keadaan menerima beban dinamik atau eksitasi derau putih. Meskipun tradisional transformasi fourier memberikan informasi domain frekuensi, teknik ini tidak memiliki resolusi waktu. STFT mengatasi limitasi tersebut dengan menerapkan transformasi fourier segment-segment sinyal pendek yang tumpang tindih, dengan demikian diperoleh representasi waktu-frekuensi.
-
-Secara matematis, STFT dari sinyal $x(t)$ diberikan sebagai berikut:
-\begin{equation}
-X(m, \omega) = \sum_{n=-\infty}^{\infty} x[n] \cdot w[n - m] \cdot e^{-j \omega n}
-\end{equation}
-
-
-dengan $w(\tau - t)$ adalah sebuah fungsi \textit{windowing} berpusat pada waktu $t$ dan $\omega$ adalah frekuensi angular.
-
-Pada studi ini, STFT digunakan untuk mengekstrak domain waktu-frekuensi dari sinyal getaran yang diperoleh dari dari respon struktur terhadap getaran yang diberikan oleh mesin \textit{shaker}. Fitur-fitur ini kemudian digunakan sebagai input pada klasifikasi pemelajaran mesin. Proces ini merekap frekuensi lokal setiap waktu, yang dinilai krusial pada pengidentifikasian perubahan struktur akibat kerusakan. \subsubsection{Fungsi \textit{Windowing}}
-Fungsi jendela $w(n)$ berfungsi untuk melokalisasi sinyal dalam domain waktu, dengan meruncingkan sinyal di kedua ujungnya guna meminimalkan diskontinuitas. Hal ini sangat penting untuk mengurangi kebocoran spektral—sebuah fenomena di mana energi sinyal menyebar ke bin frekuensi di sekitarnya akibat pemotongan sinyal secara tiba-tiba. Pemilihan jenis jendela sangat memengaruhi resolusi dan akurasi representasi waktu-frekuensi.
- \subsubsection{Hann window}
-Salah satu fungsi \textit{windowing} yang paling umum digunakan dalam STFT adalah \textit{Hann window}. Jendela ni adalah jenis jendela kosinus yang memberikan hasil yang baik antara resolusi frekuensi dan kebocoran spektral. \textit{Hann windowing} diskret dengan panjang $N$ didefinisikan sebagai:
-
-\begin{equation}
-w(n) = 0{.}5 \left(1 - \cos\left( \frac{2\pi n}{N - 1} \right) \right), \quad 0 \leq n \leq N - 1
-\end{equation}
-
-Fungsi ini secara halus meruncingkan sinyal menjadi nol di kedua ujungnya, sehingga mengurangi \textit{side lobe} dalam domain frekuensi sambil mempertahankan lebar \textit{lobe} utama yang relatif sempit. Dibandingkan dengan jendela persegi (rectangular window) yang memiliki tepi tajam, jendela Hann mengurangi fenomena Gibbs dan sangat cocok untuk aplikasi yang melibatkan estimasi spektral.
-
-
-
-
-
-
-
- \subsection{Algoritma Klasifikasi}
-
-Penelitian ini mengevaluasi lima algoritma pemelajaran mesin klasik untuk melakukan tugas pengklasifikasian terhadap lokalisasi kerusakan. Setiap algoritma memiliki keunggulan dan limitasi masing-masing, dan performa untuk setiap algoritma dijadikan tolok ukur untuk mengidentifikasi manakah algoritma yang paling sesuai untuk setiap \textit{dataset} yang diberikan.
-
-\subsubsection{Support Vector Machine (SVM)}
-
-Mesin vektor pendukung (SVM) adalah sebuah algoritma pemelajaran mesin terarah yang mencari \textit{hyperplane} optimal dengan cara memisahkan data ke dalam kelas-kelas dengan margin maksimum. SVM bekerja dengan baik pada ruang dimensi tinggi dan cukup kokoh terhadap \textit{overfitting}, terutama pada kasus yang membutuhkan batasan margin secara jelas \parencite{cortes1995}.
-
-SVM sesuai untuk klasifikasi sinyal getaran karena kemampuannya untuk mengatasi keputusan batasan-batasan non-linier apabila dilengkapi dengan fungsi kernel, seperti fungsi kernel berbasis radial (RBF).
-
-\subsubsection{K-Nearest Neighbors (KNN)}
-
-KNN merupakan sebuah algoritma pemelajaran non-parametrik, berbasis contoh. Algoritma ini mengklasifikasi titik data yang berbasis pada pungutan suara terbanyak dari tetangga terdekat $k$ pada ruang fitur. Meskipun dinilai sederhana, KNN dapat dinilai efektif ketika datanya terdistribusi dengan baik dan batasan-batasan pada kelasnya merata.
-
-Performa algoritma ini sensitif pada pemilihan $k$ dan jarak metriknya. Untuk data dengan dimensi tinggi seperti fitur STFT, mungkin diperlukan optimalisasi atau penskalaan dimensi.
-
-\subsubsection{Decision Tree (DT)}
-
-Decision Tree adalah algoritma pemelajaran terarah (\textit{supervised learning}) berbasis struktur pohon, di mana setiap \textit{node} internal mewakili suatu keputusan berdasarkan atribut tertentu, setiap cabang mewakili hasil dari keputusan tersebut, dan setiap daun (leaf node) mewakili label kelas. Algoritma ini secara rekursif membagi data ke dalam subset berdasarkan fitur yang memberikan informasi paling tinggi, seperti diukur dengan Gini index atau entropi (information gain).
-
-Kelebihan dari Decision Tree adalah interpretabilitasnya yang tinggi dan kemampuannya menangani data numerik maupun kategorikal. Namun, pohon keputusan rentan terhadap \textit{overfitting}, terutama jika kedalaman pohon tidak dikontrol.
-
-\subsubsection{Random Forest (RF)}
-
-Random Forest adalah metode ensemble yang terdiri dari banyak Decision Tree yang dilatih pada subset data dan subset fitur yang diacak. Setiap pohon dalam hutan memberikan prediksi, dan hasil akhir ditentukan melalui agregasi (misalnya, voting mayoritas untuk klasifikasi).
-
-Dengan menggabungkan banyak pohon, Random Forest mengurangi varian model dan meningkatkan generalisasi. Teknik ini efektif untuk dataset yang kompleks dan sangat cocok untuk menghindari \textit{overfitting} yang umum terjadi pada satu pohon keputusan tunggal.
-
-\subsubsection{Bagged Trees (BT)}
-
-\textit{Bagged Trees} atau \textit{Bootstrap Aggregated Trees} adalah pendekatan \textit{ensemble} yang mirip dengan Random Forest, namun perbedaannya terletak pada pemilihan fitur. Dalam \textit{Bagged Trees}, pohon-pohon dibangun dari sampel acak \textit{bootstrap} dari dataset pelatihan, tetapi tanpa pengacakan subset fitur seperti pada Random Forest.
-
-\subsubsection{XGBoost (Extreme Gradient Boosting)}
-
-XGBoost adalah algoritma pemelajaran mesin berbasis \textit{gradient boosting} yang dirancang untuk efisiensi dan performa tinggi. Algoritma ini bekerja dengan membangun model secara bertahap, di mana setiap pohon selanjutnya mencoba memperbaiki kesalahan dari pohon sebelumnya dengan mengoptimasi fungsi kerugian (\textit{loss function}) menggunakan metode gradien.
-
-XGBoost menggabungkan beberapa teknik seperti regularisasi $L1$ dan $L2$, pemangkasan pohon (\textit{pruning}), dan pemrosesan paralel, sehingga menghindari terjadinya \textit{overfitting} dan unggul dalam akurasi prediksi dibanding metode pohon lainnya. Algoritma ini sangat populer dalam kompetisi data karena kemampuannya menangani data besar, fitur multivariat, dan klasifikasi multi-kelas secara efisien.
-
-\subsubsection{Linear Discriminant Analysis (LDA)}
-
-Linear Discriminant Analysis (LDA) adalah teknik klasifikasi dan reduksi dimensi yang mengasumsikan bahwa data berasal dari distribusi normal multivariat dan memiliki kovarians yang seragam untuk setiap kelas. LDA bertujuan untuk memproyeksikan data ke ruang berdimensi lebih rendah yang memaksimalkan pemisahan antar kelas (rasio varians antar kelas terhadap varians dalam kelas).
-
-LDA sangat cocok ketika distribusi data mendekati normal dan jumlah fitur tidak terlalu besar dibanding jumlah sampel. Selain sebagai klasifikator, LDA juga sering digunakan sebagai teknik prapemrosesan untuk ekstraksi fitur sebelum digunakan dalam algoritma lain.
-
-\bigskip 
-Dasar teori ini memberikan kerangka metodologi untuk mengimplementasi dan mengevaluasi usulan sistem lokalisasi kerusakan pada penelitian ini. Kokmbinasi dari analisis waktu-frekuensi menggunakan STFT dan klasifikasi pemelajaran mesin klasik memungkinkan ketercapaian monitor kesehatan struktur yang efisien dan mudah diterapkan.\clearpage{}
-\clearpage{}\chapter{METODE PENELITIAN}
-
-\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.75\linewidth]{chapters/img/specimen.png}
-    \caption{Bentuk benda uji}
-    \label{fig:specimen-photo}
-\end{figure} \section{Alat}
-
-\subsection{Alat Perangkat Keras}
-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:accel393}) untuk merekam respons percepatan pada sebagian besar titik pengukuran.
-    \item \textbf{3 akselerometer B\&K model 8344} (Gambar~\ref{fig:accel393}) 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{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}
- 
-\subsection{Alat Perangkat Lunak}
-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}  \clearpage
-\section{Tahapan Penelitian}
-Alur keseluruhan penelitian ini dilakukan melalui tahapan-tahapan sebagai berikut:
-
-\begin{figure}[H]
-    \centering
-    \includegraphics[width=0.3\linewidth]{chapters/img/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{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}
-Dataset yang digunakan dalam penelitian ini bersumber dari basis data getaran yang dipublikasi oleh \textcite{abdeljaber2017}. Dataset tersebut dapat diakses dan diunduh melalui tautan DOI berikut:  
-\url{https://doi.org/10.17632/52rmx5bjcr.1}
-
-Dataset terdiri dari dua folder:
-\begin{itemize}
-  \item \texttt{Dataset A/} – digunakan untuk pelatihan (training)
-  \item \texttt{Dataset B/} – 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 $t = 256$ detik, sehingga menghasilkan:
-\begin{align}
-\gls{not:signal} &= \gls{not:sampling_freq} \cdot \gls{not:time_length} \nonumber \\
-  &= 1024 \cdot 256 \nonumber \\
-  &= 262144 \quad \text{sampel per kanal} \label{eq:sample}
-\end{align}
-
-Dengan demikian, setiap berkas \verb|zzzAD|$n$\verb|.TXT| dapat direpresentasikan sebagai matriks:
-\begin{equation}
-    \mathbf{D}^{(n)} \in \mathbb{R}^{262144 \times 30}, \quad n = 1, \dots, 30
-\end{equation}
-di mana $n$ mengacu pada indeks kasus (1–30 = kerusakan pada \textit{joint} ke-$n$), dan berkas tanpa kerusakan pada seluruh \textit{joint}, \verb|zzzAU|\verb|.TXT|, direpresentasikan dengan matriks:
-\begin{equation}
-    \mathbf{U} \in \mathbb{R}^{262144 \times 30}
-\end{equation}
-
-
-Kemudian \textit{dataset} A dapat direpresentasikan sebagai matriks:
-\begin{equation}
-  \gls{not:dataset_A}
-  =
-  \Bigl\{
-      \mathbf{U} \in \mathbb{R}^{262144 \times 30}
-  \Bigr\}
-  \;\cup\;
-  \Bigl\{
-      \mathbf{D}^{(n)} \in \mathbb{R}^{262144 \times 30}
-      \;\bigm|\;
-      n = 1, \dots, 30
-  \Bigr\}.
-\end{equation}
- 
-
-
- \section{Analisis Data}
-
-
-
-
-
-\subsection{Grid, Kode \textit{Joint}, dan Nama File}
-
-Masing-masing *sensor node* diberi nama menurut indeks \(n\) (dengan \(n = 0,1,\dots,29\)).  
-Berkas data mentah tiap node disimpan dalam berkas teks berformat
-\texttt{zzzAD<n>.TXT}; penamaannya dapat dirumuskan sebagai  
-
-\[
-Z_{n} \;=\; \texttt{``zzzAD}n\texttt{.TXT''}, 
-\qquad n = 1,\dots,30.
-\]
-
-Pada pembahasan selanjutnya, simbol \(Z_{n}\) dipakai sebagai penunjuk
-berkas data untuk node ke-\(n\). 
-Untuk merujuk satu kanal (kolom) tertentu di dalam matriks
-\(\mathbf{D}^{(n)}\), digunakan notasi
-
-\[
-\gls{not:damage_file}_{s}^{(\gls{not:joint_index})} \in \mathbb{R}^{262144},
-\]
-
-dengan ketentuan:
-
-* superskrip \((\gls{not:joint_index})\) menandakan indeks kasus kerusakan
-  (1–30),
-* subskrip \(s\) menandakan indeks kanal sensor yang dipilih
-  (\(s = 1,\dots,30\)).
-
-Dengan demikian,
-\(\gls{not:damage_file}_{s}^{(n)}\) merepresentasikan sebuah vektor
-\(262144 \times 1\) yang berisi deret waktu hasil pengukuran kanal
-\(s\) pada skenario kerusakan ke-\(n\).
-
-\subsection{Pemetaan Sensor ke Dalam Folder (Damage-case)}
-
-Semua tiga puluh \textit{node} dikelompokkan ke dalam enam folder yang merepresentasikan enam skenario kerusakan, masing-masing dilabeli \(d_{i}\) dengan \(i=0,\dots,5\). Setiap folder mengandung tepat lima \textit{node} berurutan, sehingga didefinisikan:
-\begin{equation*}
-\gls{not:damage_file_set_case}_{i} = \bigl\{
-\,\mathbf{D}_{5i}^{(5i)},
-\;\mathbf{D}_{5i+1}^{(5i+1)},
-\;\mathbf{D}_{5i+2}^{(5i+2)},
-\;\mathbf{D}_{5i+3}^{(5i+3)},
-\;\mathbf{D}_{5i+4}^{(5i+4)}
-\bigr\},
-\quad i = 0,\dots,5.
-\end{equation*}
-\begin{equation}
-    \mathcal{D}_i = \bigl\{
-\end{equation}
-Sebagai contoh 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}\},\\[1ex]
-d_1 &= \{n_{5}^{F_5},\;n_{6}^{F_6},\;n_{7}^{F_7},\;n_{8}^{F_8},\;n_{9}^{F_9}\},\\[1ex]
-&\;\;\vdots\\[1ex]
-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)}
-
-Untuk mensimulasikan tata letak sensor terbatas, dari setiap folder kerusakan hanya diambil \textit{node} pertama dan terakhir. Subset domain waktu ini dilambangkan sebagai
-\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}
-
-Operator STFT \(\mathcal{T}\) didefinisikan untuk memetakan sinyal domain waktu mentah (vektor dengan panjang \(L=262144\)) menjadi spektrogram berukuran \(513\times513\). Langkah-langkahnya adalah:
-\begin{equation*}
-\begin{aligned}
-\text{(1) Fungsi jendela:}\quad
-w[n] &= \frac{1}{2}\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},\\[1ex]
-&\quad
-p = 0,\ldots,512,\quad t = 0,\ldots,512.
-\end{aligned}
-\end{equation*}
-Pengambilan magnitudo menghasilkan matriks spektrogram untuk \textit{node} \(k\) sebagai
-\begin{equation*}
-\widetilde n_{k}^{F_{k}}(p,t) \;=\; \bigl|S_{k}(p,t)\bigr|
-\;\in\;\mathbb{R}^{513\times513}.
-\end{equation*}
-Dengan demikian operator STFT dapat dituliskan sebagai:
-\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}
-
-Operator \(\mathcal{T}\) diterapkan pada \textit{node} ujung-ujung yang telah dipilih, sehingga diperoleh:
-\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 data dari keenam kasus kerusakan digabungkan menjadi dua himpunan:
-\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. Untuk setiap kasus kerusakan \(i\) dan sensor \(s\), vektor fitur ini direplikasi sebanyak 5 kali (indeks pengulangan \(r\in\{0,\dots,4\}\)) dan diambil masing-masing baris/kolom ke-\(t\) dengan
-\begin{equation*}
-\mathbf{x}_{i,s,r,t}\in\mathbb{R}^{513}.
-\end{equation*}
-Label skalar untuk kasus kerusakan dinyatakan sebagai
-\begin{equation*}
-y_{i} = i,\quad i=0,\dots,5.
-\end{equation*}
-Selanjutnya, fungsi \textit{slicing} didefinisikan 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 digabungkan menjadi 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 adalah:
-\begin{equation*}
-|\mathcal{D}^{(s)}| = 15\,390 \times 514.
-\end{equation*} \clearpage{}
-
-
-\printbibliography
-
-
-\end{document}

latex/main.tex

@@ -1,55 +1,39 @@
 \documentclass[draftmark]{thesis}
-\title{Prediksi Lokasi Kerusakan dengan Machine Learning}
+
-\author{Rifqi Damar Panuluh}
+% Title Information
-\date{\today}
+\setthesisinfo
-\authorid{20210110224}
+  {Prediksi Lokasi Kerusakan dengan Machine Learning}
-\firstadvisor{Ir. Muhammad Ibnu Syamsi, Ph.D.}
+  {Rifqi Damar Panuluh}
-\secondadvisor{}
+  {20210110224}
-\headdepartement{Puji Harsanto, S.T., M.T., Ph.D.}
+  {PROGRAM STUDI TEKNIK SIPIL}
-\headdepartementid{19740607201404123064}
+  {FAKULTAS TEKNIK}
-\faculty{Fakultas Teknik}
+  {UNIVERSITAS MUHAMMADIYAH YOGYAKARTA}
-\program{Program Studi Teknik Sipil}
+  {2025}
-\university{Universitas Muhammadiyah Yogyakarta}
+
 % Input preamble
 \input{preamble/packages}
 % \input{preamble/fonts}
 \input{preamble/macros}
 
-\addbibresource{bibliography.bib}
-
-\makeglossaries
-\input{frontmatter/acronym}
-\input{frontmatter/glossaries}
-\input{frontmatter/notations}
-
 \begin{document}
-\frontmatter
-% \maketitle
-\include{frontmatter/maketitle}
-\include{frontmatter/maketitle_secondary}
-\include{frontmatter/approval}
-\include{frontmatter/originality}
-\include{frontmatter/acknowledgement}
-\tableofcontents
-\listoffigures
-\listoftables
-\glsaddall[types={main,notation,\acronymtype}]
 
-\printglossary[type=notation,style=altlong3customheader,title=Daftar Simbol dan Lambang]
+\maketitle
-\printglossary[type=\acronymtype,style=supercol,title=Daftar Singkatan]
+\frontmatter
-\printglossary[type=main,style=mylistalt]
+\input{frontmatter/approval}\clearpage
-\include{frontmatter/abstract}
+\input{frontmatter/originality}\clearpage
-% \pagestyle{fancyplain}
+\input{frontmatter/acknowledgement}\clearpage
+\tableofcontents
+\clearpage
 \mainmatter
+\pagestyle{fancyplain}
 % Include content
+\include{content/abstract}
+\include{content/introduction}
 \include{chapters/01_introduction}
-\include{chapters/id/02_literature_review/index}
+\include{content/chapter2}
-\include{chapters/id/03_methodology/index}
+\include{content/conclusion}
-% \include{chapters/04_results}
+
-% \include{content/conclusion}
-\backmatter
 % Bibliography
-\printbibliography[heading=bibintoc]
 % \bibliographystyle{IEEEtran}
 % \bibliography{references}
 

latex/metadata.tex

@@ -0,0 +1,11 @@
+\newcommand{\studentname}{Rifqi Damar Panuluh}
+\newcommand{\studentid}{20210110224}
+\newcommand{\thesistitle}{Prediksi Lokasi Kerusakan dengan Machine Learning}
+\newcommand{\firstadvisor}{Ir. Muhammad Ibnu Syamsi, Ph.D.}
+\newcommand{\secondadvisor}{}
+\newcommand{\headdepartement}{Puji Harsanto, S.T. M.T., Ph.D.}
+\newcommand{\headdepartementid}{19740607201404123064}
+\newcommand{\faculty}{Fakultas Teknik}
+\newcommand{\program}{Teknik Sipil}
+\newcommand{\university}{Universitas Muhammadiyah Yogyakarta}
+\newcommand{\yearofsubmission}{2025}

latex/preamble/macros.tex

@@ -2,11 +2,4 @@
 \newcommand{\ie}{\textit{i.e.},\ }
 \newcommand{\etal}{\textit{et al.}}
 
-\let\oldtableofcontents\tableofcontents % backup
+\let\oldtableofcontents\tableofcontents % backup
-
-\let\oldaddcontentsline\addcontentsline
-\newcommand{\ADDCONTENTSLINE}[3]{
-	\oldaddcontentsline{#1}{#2}{\uppercase{#3}}
-}
-\newcommand{\CAPinToC}{\let\addcontentsline\ADDCONTENTSLINE}
-\newcommand{\noCAPinToC}{\let\addcontentsline\oldaddcontentsline}

latex/preamble/packages.tex

@@ -1,3 +1,3 @@
-% \usepackage{amsmath, amssymb, siunitx}
+\usepackage{amsmath, amssymb, siunitx}
-% \usepackage{caption}
+\usepackage{caption}
-% \usepackage{subcaption}
+\usepackage{subcaption}

latex/thesis.cls

@@ -1,15 +1,10 @@
 \NeedsTeXFormat{LaTeX2e}
 \ProvidesClass{thesis}[2025/05/10 Bachelor Thesis Class]
 
-\newif\if@draftmark \@draftmarkfalse
+\newif\if@draftmark
-\newif\if@primarytitle   \@primarytitletrue
+\@draftmarkfalse
-\newif\if@secondarytitle \@secondarytitletrue
-
 
 \DeclareOption{draftmark}{\@draftmarktrue}
-\DeclareOption{noprimarytitle}{\@primarytitlefalse}
-\DeclareOption{nosecondarytitle}{\@secondarytitlefalse}
-
 \ProcessOptions \relax
 \LoadClass[a4paper,12pt,oneside]{book}
 
@@ -17,82 +12,42 @@
 \RequirePackage{polyglossia}
 \RequirePackage{fontspec}
 \RequirePackage{titlesec}
-\RequirePackage{titling}
 \RequirePackage{fancyhdr}
 \RequirePackage{geometry}
 \RequirePackage{setspace}
 \RequirePackage{graphicx}
-\RequirePackage{svg}
-\RequirePackage{etoolbox}
-\RequirePackage[titles]{tocloft}
-\RequirePackage{tocbibind}
-\RequirePackage{indentfirst}
-\RequirePackage{float}
-\RequirePackage{amsmath,amsfonts,amssymb}
-\RequirePackage[style=apa,%
-                % dateabbrev=false,% when false, don't abbreviate months/year divisions
-                % julian=true,% convert dates before gregorianstart to Julian Calendar
-                % gregorianstart=1582-10-15,% Default
-                % alldates=short,%
-                % alldates=ymd,% Year-Month-Day format
-                % alldates=iso,% ISO8601 format
-                % alldatesusetime=true, % print time components in non-compact date ranges
-                % alltimes=12h,%
-                alltimes=24h,% prints 24 hour format times (default)
-                % alltimes=24hcomp,% prints 24 hour compressed format times
-                % seconds=true,% uncomment to print seconds
-                % timezones=true,% uncomment to print timezones
-                datezeros=false,% pad date components with zeros?
-                dateera=secular,% prints BCE/CE controlled by dateerauto, datezeros
-                % dateera=christian,% prints BC/AD controlled by dateerauto, datezeros
-                % dateera=astronomical,% prints astronomical dates, controlled by datezeros
-                dateeraauto=600,% Sets the max year ceiling for automatic printing of era
-                % abbreviate=false,% prints full date localisation strings
-                dateuncertain=true,%
-                datecirca=true,%
-                sorting=none,%
-                backend=biber]{biblatex}
 \RequirePackage{hyperref}
-\RequirePackage[acronym, nogroupskip, toc]{glossaries}
+\RequirePackage{etoolbox}
-% \RequirePackage{glossaries-extra}
+\RequirePackage{tocloft}
-% \RequirePackage{hyperxmp}
+\RequirePackage{tocbibind}
+\RequirePackage{amsmath,amsfonts,amssymb}
+\RequirePackage{svg}           % Allows including SVG images directly
+\RequirePackage{indentfirst}   % Makes first paragraph after headings indented
+\RequirePackage{float}         % Provides [H] option to force figure/table placement
 
 % Polyglossia set language
-\setdefaultlanguage[variant=indonesian]{malay}
++ \setdefaultlanguage[variant=indonesian]{malay}  % Proper Indonesian language setup
-\setotherlanguage{english}
++ \setotherlanguage{english}             % Enables English as secondary language
 
-% Change "Bibliography" to "Daftar Pustaka" for book class
++ \DefineBibliographyStrings{english}{%  % Customizes bibliography text
-% \DefineBibliographyStrings{english}{%
++   andothers={dkk\adddot},              % Changes "et al." to "dkk."
-% andothers={dkk\adddot},
++   pages={hlm\adddot},                  % Changes "pp." to "hlm."
-% pages    ={hlm\adddot},
++ }
-% }
-
-
-% \DefineBibliographyStrings{english}{
-%   bibliography = {Daftar Pustaka},
-% }
-
-% \DefineBibliographyStrings{american-apa}{%
-%     bibliography = {Daftar Pustaka},
-% }
-% \renewcommand{\bibname}{DAFTAR PUSTAKA}
 
 % Conditionally load the watermark package and settings
 \if@draftmark
   \RequirePackage{draftwatermark}
-  \SetWatermarkText{nuluh/thesis (wip)[draft: \today)}
+  \SetWatermarkText{nuluh/thesis (wip) draft: \today}
-  \SetWatermarkColor[gray]{0.8}
+  \SetWatermarkColor[gray]{0.8}                    % Opacity: 0.8 = 20% transparent  
   \SetWatermarkFontSize{1.5cm}
   \SetWatermarkAngle{90}
   \SetWatermarkHorCenter{1.5cm}
-  \RequirePackage[left]{lineno}
-  \linenumbers
 \fi
 
 % Page layout
-\geometry{left=4cm, top=3cm, right=3cm, bottom=3cm}
+\geometry{left=3cm, top=3cm, right=3cm, bottom=3cm}
 \setlength{\parskip}{0.5em}
-% \setlength{\parindent}{0pt}
+\setlength{\parindent}{0pt}
 \onehalfspacing
 
 % Fonts
@@ -102,17 +57,17 @@
 \setmonofont{Courier New}
 
 % Metadata commands
-% \input{metadata}
+\input{metadata}
 
-% \newcommand{\setthesisinfo}[7]{%
+\newcommand{\setthesisinfo}[7]{%
-%   \renewcommand{\thesistitle}{#1}%
+  \renewcommand{\thesistitle}{#1}%
-%   \renewcommand{\studentname}{#2}%
+  \renewcommand{\studentname}{#2}%
-%   \renewcommand{\studentid}{#3}%
+  \renewcommand{\studentid}{#3}%
-%   \renewcommand{\program}{#4}%
+  \renewcommand{\program}{#4}%
-%   \renewcommand{\faculty}{#5}%
+  \renewcommand{\faculty}{#5}%
-%   \renewcommand{\university}{#6}%
+  \renewcommand{\university}{#6}%
-%   \renewcommand{\yearofsubmission}{#7}%
+  \renewcommand{\yearofsubmission}{#7}%
-% }
+}
 
 % % Header and footer
 \fancypagestyle{fancy}{%
@@ -131,27 +86,10 @@
     \fancyhead[R]{\thepage}
 }
 
-% change the behaviour of \backmatter to change page number into roman by continue frontmatter page counter (modified from original book.cls)
-\newcounter{savepagenumber}
-\renewcommand\mainmatter{%
-  \cleardoublepage
-  \setcounter{savepagenumber}{\value{page}}
-  \@mainmattertrue
-  \pagenumbering{arabic}%
-}
-\renewcommand\backmatter{%
-  \if@openright
-    \cleardoublepage
-  \else
-    \clearpage
-  \fi
-  \pagenumbering{roman}%
-  \setcounter{page}{\value{savepagenumber}}%
-  \@mainmatterfalse
-}
-
 % Chapter formatting
-\titlespacing{\chapter}{0pt}{0cm}{*1.5}
+\titlespacing{\chapter}{0pt}{0cm}{*1.5}    % 0pt→0cm: same value, different unit
+                                             % 0pt = no space above chapter title
+                                             % *1.5 = 1.5× line spacing after title
 
 \titleformat{\chapter}[display]
   {\normalsize\bfseries\centering}
@@ -165,41 +103,30 @@
     {\normalsize\bfseries}{\thesubsection}{1em}{}
 
 % Section numbering depth
-\setcounter{secnumdepth}{3}
+\setcounter{secnumdepth}{3}               % Enables numbering for:
+                                          % 1 = chapters, 2 = sections, 3 = subsections
 
 % Ensure chapter reference in TOC matches
 \renewcommand{\cftchappresnum}{BAB~}
 \renewcommand{\cftchapaftersnum}{\quad}
 
+% \titlespacing*{\chapter}{0pt}{-10pt}{20pt}
 
 % Redefine \maketitle
-\renewcommand{\maketitle}{%
+\renewcommand{\maketitle}{\input{frontmatter/maketitle}}
-  \if@primarytitle
-    \input{frontmatter/maketitle}%
-  \fi
-  \if@secondarytitle
-    \clearpage
-    \input{frontmatter/maketitle_secondary}%
-  \fi
-}
 
 % Chapter & Section format
-% thanks to https://latex.org/forum/viewtopic.php?p=83118&sid=a22ccb456531faabf65070c18af69680#p83118 for elegant solution
-\makeatletter
-\patchcmd{\l@chapter}
-  {\cftchapfont #1}% original
-  {\cftchapfont{#1}}% patched
-  {}{}            % success/failure handlers
-\makeatother
 \renewcommand{\cftchapfont}{\normalsize\MakeUppercase}
 % \renewcommand{\cftsecfont}{}
 % \renewcommand{\cftsubsecfont}{\itshape}
 % \renewcommand{\thesection}{\textup{\Roman{chapter}}.\arabic{section}}
 
+
 % Dot leaders, spacing, indentation
-\setlength{\cftbeforetoctitleskip}{0cm}
+\setlength{\cftbeforetoctitleskip}{0cm}   % Space above "DAFTAR ISI" title
-\setlength{\cftbeforeloftitleskip}{0cm}
+\setlength{\cftbeforeloftitleskip}{0cm}   % Space above "DAFTAR GAMBAR" title  
-\setlength{\cftbeforelottitleskip}{0cm}
+\setlength{\cftbeforelottitleskip}{0cm}   % Space above "DAFTAR TABEL" title
+
 \setlength{\cftbeforechapskip}{0em}
 \setlength{\cftchapindent}{0pt}
 \setlength{\cftsecindent}{0em}
@@ -209,15 +136,11 @@
 \setlength{\cftsubsecnumwidth}{2.5em}
 \setlength{\cftfignumwidth}{5em}
 \setlength{\cfttabnumwidth}{4em}
-\renewcommand \cftchapdotsep{1} % https://tex.stackexchange.com/a/273764
+\renewcommand \cftchapdotsep{1}           % Denser dots (closer together) https://tex.stackexchange.com/a/273764
-\renewcommand \cftsecdotsep{1} % https://tex.stackexchange.com/a/273764
+\renewcommand \cftsecdotsep{1}            % Apply to sections too
-\renewcommand \cftsubsecdotsep{1} % https://tex.stackexchange.com/a/273764
+\renewcommand \cftsubsecdotsep{1}         % Apply to subsections too
-\renewcommand \cftfigdotsep{1.5} % https://tex.stackexchange.com/a/273764
-\renewcommand \cfttabdotsep{1.5} % https://tex.stackexchange.com/a/273764
 \renewcommand{\cftchapleader}{\normalfont\cftdotfill{\cftsecdotsep}}
 \renewcommand{\cftchappagefont}{\normalfont}
-
-% Add Prefix in the Lof and LoT entries
 \renewcommand{\cftfigpresnum}{\figurename~}
 \renewcommand{\cfttabpresnum}{\tablename~}
 
@@ -230,154 +153,17 @@
 \renewcommand{\thetable}{\arabic{chapter}.\arabic{table}}
 \renewcommand{\theequation}{\arabic{chapter}.\arabic{equation}}
 
-% Table of Content (TOC, LoF, LoT) Title styling
+% Table of Content (TOC) Title styling
-% \renewcommand{\contentsname}{DAFTAR ISI}
 \renewcommand{\cfttoctitlefont}{\hfill\bfseries\MakeUppercase}
 \renewcommand{\cftaftertoctitle}{\hfill} % https://tex.stackexchange.com/a/255699/394075
+% List of Figures (LOF) Title styling
 \renewcommand{\cftloftitlefont}{\hfill\bfseries\MakeUppercase}
 \renewcommand{\cftafterloftitle}{\hfill}
+% List of Tables (LOT) Title styling
 \renewcommand{\cftlottitlefont}{\hfill\bfseries\MakeUppercase}
 \renewcommand{\cftafterlottitle}{\hfill}
-
+% \renewcommand{\cfttoctitlefont}{\bfseries\MakeUppercase}
-% Defines a new glossary called “notation”
+% \renewcommand{\cftaftertoctitle}{\vskip 2em}
-\newglossary[nlg]{notation}{not}{ntn}{Notation}
-
-% Define the new glossary style called 'mylistalt'
-\makeatletter
-\newglossarystyle{mylistalt}{%
-  % start the list, initializing glossaries internals
-  \renewenvironment{theglossary}%
-    {\glslistinit\begin{enumerate}}%
-    {\end{enumerate}}%
-  % suppress all headers/groupskips
-  \renewcommand*{\glossaryheader}{}%
-  \renewcommand*{\glsgroupheading}[1]{}%
-  \renewcommand*{\glsgroupskip}{}%
-  % main entries: let \item produce "1." etc., then break
-  \renewcommand*{\glossentry}[2]{%
-    \item \glstarget{##1}{\glossentryname{##1}}%
-    \mbox{}\\
-    \glossentrydesc{##1}\space 
-    [##2] % appears on page x
-  }%
-  % sub-entries as separate paragraphs, still aligned
-  \renewcommand*{\subglossentry}[3]{%
-    \par
-    \glssubentryitem{##2}%
-    \glstarget{##2}{\strut}\space
-    \glossentrydesc{##2}\space ##3%
-  }%
-}
-
-% Define the header for the location column
-\providecommand*{\locationname}{Location}
-
-% Define the new glossary style 'altlong3customheader'
-\newglossarystyle{altlong3customheader}{%
-  % The glossary will be a longtable environment with three columns:
-  % 1. Symbol (left-aligned)
-  % 2. Description (paragraph, width \glsdescwidth)
-  % 3. Location (paragraph, width \glspagelistwidth)
-  \renewenvironment{theglossary}%
-    {\begin{longtable}{lp{\glsdescwidth}p{\glspagelistwidth}}}%
-    {\end{longtable}}%
-  % Define the table header row
-  \renewcommand*{\symbolname}{Simbol}
-  \renewcommand*{\descriptionname}{Keterangan}
-  \renewcommand*{\locationname}{Halaman}
-  \renewcommand*{\glossaryheader}{%
-    \bfseries\symbolname & \bfseries\descriptionname & \bfseries\locationname \tabularnewline\endhead}%
-  % Suppress group headings (e.g., A, B, C...)
-  \renewcommand*{\glsgroupheading}[1]{}%
-  % Define how a main glossary entry is displayed
-  % ##1 is the entry label
-  % ##2 is the location list (page numbers)
-  \renewcommand{\glossentry}[2]{%
-    \glsentryitem{##1}% Inserts entry number if entrycounter option is used
-    \glstarget{##1}{\glossentryname{##1}} & % Column 1: Symbol (with hyperlink target)
-    \glossentrydesc{##1}\glspostdescription & % Column 2: Description (with post-description punctuation)
-    ##2\tabularnewline % Column 3: Location list
-  }%
-  % Define how a sub-entry is displayed
-  % ##1 is the sub-entry level (e.g., 1 for first sub-level)
-  % ##2 is the entry label
-  % ##3 is the location list
-  \renewcommand{\subglossentry}[3]{%
-    & % Column 1 (Symbol) is left blank for sub-entries to create an indented look
-    \glssubentryitem{##2}% Inserts sub-entry number if subentrycounter is used
-    \glstarget{##2}{\strut}\glossentrydesc{##2}\glspostdescription & % Column 2: Description (target on strut for hyperlink)
-    ##3\tabularnewline % Column 3: Location list
-  }%
-  % Define the skip between letter groups (if group headings were enabled)
-  % For 3 columns, we need 2 ampersands for a full blank row if not using \multicolumn
-  \ifglsnogroupskip
-    \renewcommand*{\glsgroupskip}{}%
-  \else
-    \renewcommand*{\glsgroupskip}{& & \tabularnewline}%
-  \fi
-}
-
-% Define a new style 'supercol' based on 'super'
-\newglossarystyle{supercol}{%
-  \setglossarystyle{super}% inherit everything from the original
-  % override just the main-entry format:
-  \renewcommand*{\glossentry}[2]{%
-    \glsentryitem{##1}%
-    \glstarget{##1}{\glossentryname{##1}}\space  % <-- added colon here
-    &: \glossentrydesc{##1}\glspostdescription\space ##2\tabularnewline
-  }%
-  % likewise for sub‐entries, if you want a colon there too:
-  \renewcommand*{\subglossentry}[3]{%
-    &: 
-    \glssubentryitem{##2}%
-    \glstarget{##2}{\strut}\glossentryname{##2}\space % <-- and here
-    \glossentrydesc{##2}\glspostdescription\space ##3\tabularnewline
-  }%
-}
-\makeatother
-
-% A new command that enables us to enter bi-lingual (Slovene and English) terms
-% syntax: \addterm[options]{label}{Slovene}{Slovene first use}{English}{Slovene
-% description}
-\newcommand{\addterm}[6][]{
-  \newglossaryentry{#2}{
-    name={#3 (angl.\ #5)},
-    first={#4 (\emph{#5})},
-    text={#3},
-    sort={#3},
-    description={#6},
-    #1 % pass additional options to \newglossaryentry
-  }
-}
-
-% A new command that enables us to enter (English) acronyms with bi-lingual
-% (Slovene and English) long versions
-% syntax: \addacronym[options]{label}{abbreviation}{Slovene long}{Slovene first
-% use long}{English long}{Slovene description}
-\newcommand{\addacronym}[7][]{
-  % Create the main glossary entry with \newacronym
-  % \newacronym[key-val list]{label}{abbrv}{long}
-  \newacronym[
-    name={#4 (angl.\ #6,\ #3)},
-    first={\emph{#5} (angl.\ \emph{#6},\ \emph{#3})},
-    sort={#4},
-    description={#7},
-    #1 % pass additional options to \newglossaryentry
-    ]
-    {#2}{#3}{#4}
-  % Create a cross-reference from the abbreviation to the main glossary entry by
-  % creating an auxiliary glossary entry (note: we set the label of this entry
-  % to '<original label>_auxiliary' to avoid clashes)
-  \newglossaryentry{#2_auxiliary}{
-    name={#3},
-    sort={#3},
-    description={\makefirstuc{#6}},
-    see=[See:]{#2}
-  }
-}
-
-% Change the text of the cross-reference links to the Slovene long version.
-\renewcommand*{\glsseeitemformat}[1]{\emph{\acrlong{#1}}.}
 
 % % Apply a custom fancyhdr layout only on the first page of each \chapter, and use no header/footer elsewhere
 % % \let\oldchapter\chapter
@@ -389,58 +175,4 @@
 % %   \pagestyle{fancyplain}% switch for subsequent pages
 % % }
 
-\makeatletter
-% Extracting the Year from \today
-\newcommand{\theyear}{%
-  \expandafter\@car\expandafter\@gobble\the\year\@nil
-}
-
-% Declare internal macros as initially empty
-\newcommand{\@authorid}{}
-\newcommand{\@firstadvisor}{}
-\newcommand{\@secondadvisor}{}
-\newcommand{\@headdepartement}{}
-\newcommand{\@headdepartementid}{}
-\newcommand{\@faculty}{}
-\newcommand{\@program}{}
-\newcommand{\@university}{}
-\newcommand{\@yearofsubmission}{}
-
-% Define user commands to set these values.
-\newcommand{\authorid}[1]{\gdef\@authorid{#1}}
-\newcommand{\firstadvisor}[1]{\gdef\@firstadvisor{#1}}
-\newcommand{\secondadvisor}[1]{\gdef\@secondadvisor{#1}}
-\newcommand{\headdepartement}[1]{\gdef\@headdepartement{#1}}
-\newcommand{\headdepartementid}[1]{\gdef\@headdepartementid{#1}}
-\newcommand{\faculty}[1]{\gdef\@faculty{#1}}
-\newcommand{\program}[1]{\gdef\@program{#1}}
-\newcommand{\university}[1]{\gdef\@university{#1}}
-% \newcommand{\yearofsubmission}[1]{\gdef\@yearofsubmission{#1}}
-
-% Now expose robust “the‑” getters to access the values
-\newcommand{\theauthorid}{\@authorid}
-\newcommand{\thefirstadvisor}{\@firstadvisor}
-\newcommand{\thesecondadvisor}{\@secondadvisor}
-\newcommand{\theheaddepartement}{\@headdepartement}
-\newcommand{\theheaddepartementid}{\@headdepartementid}
-\newcommand{\thefaculty}{\@faculty}
-\newcommand{\theprogram}{\@program}
-\newcommand{\theuniversity}{\@university}
-
-% Ensure title/author/date get expanded correctly in hypersetup
-% \hypersetup{
-%   pdftitle={\@title},
-%   pdfauthor={\@author},
-%   pdfdate={\@date},
-%   pdfsubject={Bachelor Thesis},
-%   pdfkeywords={structural health monitoring, machine learning, stft, vibration, signal},
-%   pdfpublisher={Universitas Muhammadiyah Yogyakarta},
-%   pdfcontactemail={rifqi.damar.ft21@mail.umy.ac.id},
-%   pdflicenseurl={https://github.com/nuluh/thesis/blob/main/LICENSE},
-%   pdflang={id},
-%   pdfcreator={XeLaTeX with hyperref and hyperxmp},
-%   pdfproducer={TeX Live 2024},
-%   pdftrapped=False
-% }
-\makeatother
 \endinput