feat: production metrics

data/efficiency.json

@@ -0,0 +1,14 @@
+{
+    "opening_time": "0 days 08:30:15",
+    "required_time": "0 days 08:30:15",
+    "unplanned_stop_time": "0 days 08:30:00",
+    "operating_time": "0 days 00:00:15",
+    "net_time": "0 days 00:00:15",
+    "useful_time": "0 days 00:00:08",
+    "quality_rate": 56.25,
+    "operating_rate": 100.0,
+    "availability_rate": 0.04899559039686428,
+    "TRS": 0.02756001959823616,
+    "MTBF": "0 days 00:00:03",
+    "MTTR": "0 days 01:42:00"
+}

data/tool_1.csv

@@ -0,0 +1,3 @@
+Part ID,Timestamp,Position,Orientation,Tool ID,Compliance,Event,Error Code,Error Description,Downtime Start,Downtime End,pos_rolling_mean,pos_rolling_std,pos_rolling_cp,pos_rolling_cpk,ori_rolling_mean,ori_rolling_std,ori_rolling_cp,ori_rolling_cpk
+4,2025-06-06 16:24:31,0.3607,0.3622,1,OK,N/A,N/A,N/A,N/A,N/A,0.3607,,,,0.3622,,,
+8,2025-06-06 21:39:38,0.3889,0.2458,1,OK,N/A,N/A,N/A,N/A,N/A,0.3748,0.019940411229460643,1.6716472368476298,1.2503921331620276,0.304,0.08230722933011414,0.8099734034210165,0.42118616977892853

data/tool_2.csv

@@ -0,0 +1,4 @@
+Part ID,Timestamp,Position,Orientation,Tool ID,Compliance,Event,Error Code,Error Description,Downtime Start,Downtime End,pos_rolling_mean,pos_rolling_std,pos_rolling_cp,pos_rolling_cpk,ori_rolling_mean,ori_rolling_std,ori_rolling_cp,ori_rolling_cpk
+1,2025-06-06 16:09:27,0.3956,0.4285,2,OK,N/A,N/A,N/A,N/A,N/A,0.3956,,,,0.4285,,,
+5,2025-06-06 19:24:33,0.4054,0.3711,2,OK,N/A,N/A,N/A,N/A,N/A,0.40049999999999997,0.006929646455628168,4.810250212153383,4.786198961092618,0.3998,0.04058792924010783,1.6425244626865212,1.6408819382238347
+9,2025-06-06 21:39:39,0.3808,0.5243,2,OK,N/A,N/A,N/A,N/A,N/A,0.3939333333333333,0.01238439878772209,2.6915584603412515,2.528270580413882,0.4413,0.07739793278893178,0.8613494477749186,0.6834807868093978

data/tool_3.csv

@@ -0,0 +1,4 @@
+Part ID,Timestamp,Position,Orientation,Tool ID,Compliance,Event,Error Code,Error Description,Downtime Start,Downtime End,pos_rolling_mean,pos_rolling_std,pos_rolling_cp,pos_rolling_cpk,ori_rolling_mean,ori_rolling_std,ori_rolling_cp,ori_rolling_cpk
+2,2025-06-06 16:09:28,0.3741,0.3253,3,OK,N/A,N/A,N/A,N/A,N/A,0.3741,,,,0.3253,,,
+6,2025-06-06 19:39:35,0.4245,0.3435,3,OK,N/A,N/A,N/A,N/A,N/A,0.3993,0.035638181771801995,0.935326430140936,0.9287791451299494,0.33440000000000003,0.012869343417595179,5.1802694592421,3.481141076610692
+10,2025-06-06 21:39:40,0.3902,0.4416,3,OK,N/A,N/A,N/A,N/A,N/A,0.3962666666666667,0.025741859554689,1.294907745981448,1.246564523464808,0.37013333333333337,0.06255736034499322,1.065688614401428,0.9065457813174815

data/tool_4.csv

@@ -0,0 +1,4 @@
+Part ID,Timestamp,Position,Orientation,Tool ID,Compliance,Event,Error Code,Error Description,Downtime Start,Downtime End,pos_rolling_mean,pos_rolling_std,pos_rolling_cp,pos_rolling_cpk,ori_rolling_mean,ori_rolling_std,ori_rolling_cp,ori_rolling_cpk
+3,2025-06-06 16:24:30,0.3412,0.9907,4,NOK,N/A,N/A,N/A,N/A,N/A,0.3412,,,,0.9907,,,
+7,2025-06-06 21:39:37,0.395,0.3865,4,OK,N/A,N/A,N/A,N/A,N/A,0.3681,0.038042344827836284,0.876216581395969,0.5967034919306549,0.6886,0.42723391719291204,0.15604254246641233,-0.06912684631262067
+11,2025-06-07 00:39:42,0.6491,0.5659,4,NOK,N/A,N/A,N/A,N/A,N/A,0.46176666666666666,0.16445042819443598,0.20269532709225951,0.0774971800582739,0.6477,0.310294763088261,0.21484947410376964,-0.051241599573749144

data/tool_all.csv

@@ -0,0 +1,12 @@
+Part ID,Timestamp,Position,Orientation,Tool ID,Compliance,Event,Error Code,Error Description,Downtime Start,Downtime End,pos_rolling_mean,pos_rolling_std,pos_rolling_cp,pos_rolling_cpk,ori_rolling_mean,ori_rolling_std,ori_rolling_cp,ori_rolling_cpk
+1,2025-06-06 16:09:27,0.3956,0.4285,2,OK,N/A,N/A,N/A,N/A,N/A,0.3956,,,,0.4285,,,
+2,2025-06-06 16:09:28,0.3741,0.3253,3,OK,N/A,N/A,N/A,N/A,N/A,0.38485,0.015202795795510805,2.19257916646991,1.8604034227497193,0.3769,0.07297341981845173,0.9135746526957974,0.8080567803094328
+3,2025-06-06 16:24:30,0.3412,0.9907,4,NOK,N/A,N/A,N/A,N/A,N/A,0.3703,0.02739835761501045,1.2166179375318231,0.8552824100848719,0.5815,0.35811456267513053,0.1861601666479685,0.017219815414937053
+4,2025-06-06 16:24:31,0.3607,0.3622,1,OK,N/A,N/A,N/A,N/A,N/A,0.3679,0.022879831001706884,1.4568872178665393,0.9892264209313804,0.526675,0.3122826964466651,0.2134817824530111,0.07826775849183518
+5,2025-06-06 19:24:33,0.4054,0.3711,2,OK,N/A,N/A,N/A,N/A,N/A,0.3754,0.02595890983843505,1.2840806313052342,0.9681967960041469,0.49555999999999994,0.2792509230065319,0.2387339169693891,0.12466685144141502
+6,2025-06-06 19:39:35,0.4245,0.3435,3,OK,N/A,N/A,N/A,N/A,N/A,0.38358333333333333,0.03067399006759092,1.0866970113729086,0.9082975853391895,0.47021666666666667,0.257368548324512,0.25903191007864607,0.1680901236485347
+7,2025-06-06 21:39:37,0.395,0.3865,4,OK,N/A,N/A,N/A,N/A,N/A,0.3852142857142857,0.028331927135973208,1.1765289799510255,1.0025707664868377,0.4582571428571428,0.2370654330007003,0.28121631155930576,0.19930201737795947
+8,2025-06-06 21:39:38,0.3889,0.2458,1,OK,N/A,N/A,N/A,N/A,N/A,0.385675,0.026262616015926513,1.269231264437591,1.087413885806906,0.4317,0.23197780066204612,0.2873838206776912,0.24183348510027716
+9,2025-06-06 21:39:39,0.3808,0.5243,2,OK,N/A,N/A,N/A,N/A,N/A,0.3851333333333333,0.024620113728413193,1.3539065538460338,1.15262577950759,0.4419888888888889,0.21917969479655525,0.30416442877405825,0.24030679675532682
+10,2025-06-06 21:39:40,0.3902,0.4416,3,OK,N/A,N/A,N/A,N/A,N/A,0.38564,0.023267297030620273,1.4326259423028787,1.226900856988185,0.44195,0.2066446345783021,0.3226150381436844,0.25494653389304656
+11,2025-06-07 00:39:42,0.6491,0.5659,4,NOK,N/A,N/A,N/A,N/A,N/A,0.40959090909090906,0.08244596357063765,0.4043052187118193,0.3655286727353676,0.45321818181818185,0.19957077851319724,0.33405024103896114,0.24516250871886658

src/production/flow.py

@@ -5,6 +5,7 @@ import pandas as pd
 from datetime import datetime, timedelta
 
 from .downtime import machine_errors
+from .processing import process
 
 PRODUCTION = False
 PROD_STATE = {
@@ -32,7 +33,7 @@ def synthetic_data():
         if not PRODUCTION:
             break
 
-        if random.random() < 0.001:
+        if random.random() < 0.2:
             error_key = random.choice(list(machine_errors.keys()))
             error = machine_errors[error_key]
             downtime = error["downtime"]
@@ -69,7 +70,7 @@ def synthetic_data():
 
             print(f"     - part {part_id} data generated")
             part_id += 1
-            time.sleep(1)
+            time.sleep(0.5)
 
         current_time += timedelta(seconds=1)
 
@@ -79,13 +80,13 @@ def synthetic_data():
 
     return data
 
-def update_display(data):
+def compile(data):
     """
     Update production data in real-time.
     """
-    display_data = []
+    raw_data = []
     for row in data:
-        display_data.append({
+        raw_data.append({
             "Part ID": row.get("part_id", "N/A"),
             "Timestamp": row.get("timestamp", "N/A"),
             "Position": row.get("position", "N/A"),
@@ -98,28 +99,28 @@ def update_display(data):
             "Downtime Start": row.get("downtime_start", "N/A"),
             "Downtime End": row.get("downtime_end", "N/A")
         })
-    return pd.DataFrame(display_data)
+    return pd.DataFrame(raw_data)
 
 
 def play_fn():
     """
     Start the production simulation and generate synthetic data.
     """
-    print("=== Continuation production ===")
+    print("=== STARTING PRODUCTION ===")
     global PRODUCTION
     PRODUCTION = True
     while PRODUCTION:
         data = synthetic_data()
-        display_data = update_display(data)
-        yield display_data
-        time.sleep(1)
+        raw_data = compile(data)
+        yield raw_data
+        process(raw_data)
 
 
 def pause_fn():
     """
     Pause the production simulation.
     """
-    print("=== Stopping production ===")
+    print("--- PAUSE ---")
     global PRODUCTION
     PRODUCTION = False
 

src/production/metrics/machine.py

@@ -0,0 +1,72 @@
+import pandas as pd
+import json
+import os
+
+def machine_metrics(raw_data):
+    """
+    Calculate machine efficiency metrics from raw production data.
+    :param raw_data: collection of raw production data containing timestamps, downtime, and compliance information.
+    :return: a dictionary with calculated metrics including opening time, required time, unplanned stop time, operating time, net time, useful time, quality rate, operating rate, availability rate, TRS (Total Resource Score), MTBF (Mean Time Between Failures), and MTTR (Mean Time To Repair).
+    """
+    df = pd.DataFrame(raw_data)
+    df['Timestamp'] = pd.to_datetime(df['Timestamp'])
+    df['Downtime Start'] = pd.to_datetime(df['Downtime Start'], format="%Y-%m-%d %H:%M:%S", errors='coerce')
+    df['Downtime End'] = pd.to_datetime(df['Downtime End'], format="%Y-%m-%d %H:%M:%S", errors='coerce')
+
+    opening_time = df['Timestamp'].max() - df['Timestamp'].min()        # Calculate opening time
+    planned_stop_time = pd.Timedelta(0)                                 # Planned stop time (not implemented)
+    required_time = opening_time - planned_stop_time
+
+    downtime_df = df.dropna(subset=['Downtime Start', 'Downtime End'])                              # Create a subset for calculating unplanned stop time
+    unplanned_stop_time = (downtime_df['Downtime End'] - downtime_df['Downtime Start']).sum()       # Calculate unplanned stop time
+    operating_time = required_time - unplanned_stop_time                                            # Operating time
+
+    cadency_variance = pd.Timedelta(0)                  # Cadency variance (not implemented)
+    net_time = operating_time - cadency_variance        # Net time
+
+    nok_time = df[df['Compliance'] != 'OK']['Timestamp'].count()        # Time NOK (non-compliant)
+    useful_time = net_time - pd.Timedelta(seconds=nok_time)             # Useful time
+
+    total_parts = df['Part ID'].count()                                         # Compliance metrics
+    compliant_parts = df[df['Compliance'] == 'OK']['Compliance'].count()
+
+    quality_rate = (compliant_parts / total_parts) * 100            # Quality rate
+    operating_rate = (net_time / operating_time) * 100              # Operating rate
+    availability_rate = (operating_time / required_time) * 100      # Availability rate
+
+    # Overall Equipment Effectiveness (OEE)
+    TRS = (quality_rate / 100) * (operating_rate / 100) * (availability_rate / 100) * 100
+
+    # Mean Time Between Failures (MTBF)
+    if len(downtime_df) > 0:
+        mtbf = operating_time / len(downtime_df)
+    else:
+        mtbf = pd.Timedelta(0)
+
+    # Mean Time To Repair (MTTR)
+    if len(downtime_df) > 0:
+        mttr = unplanned_stop_time / len(downtime_df)
+    else:
+        mttr = pd.Timedelta(0)
+
+    results = {
+        "opening_time": str(opening_time),
+        "required_time": str(required_time),
+        "unplanned_stop_time": str(unplanned_stop_time),
+        "operating_time": str(operating_time),
+        "net_time": str(net_time),
+        "useful_time": str(useful_time),
+        "quality_rate": quality_rate,
+        "operating_rate": operating_rate,
+        "availability_rate": availability_rate,
+        "TRS": TRS,
+        "MTBF": str(mtbf),
+        "MTTR": str(mttr)
+    }
+
+    os.makedirs('data', exist_ok=True)
+
+    with open('data/efficiency.json', 'w') as json_file:
+        json.dump(results, json_file, indent=4)
+
+    return results

src/production/metrics/tools.py

@@ -0,0 +1,52 @@
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor
+
+def stats_metrics(data, column, usl, lsl):
+    """
+    Calculate rolling mean, standard deviation, Cp, and Cpk for a given column.
+    Args:
+        data (pd.DataFrame): DataFrame containing the production data.
+        column (str): The column for which to calculate metrics.
+        usl (float): Upper specification limit.
+        lsl (float): Lower specification limit.
+    """
+    rolling_mean = data[column].expanding().mean()
+    rolling_std = data[column].expanding().std()
+    cp = (usl - lsl) / (6 * rolling_std)
+    cpk = np.minimum(
+        (usl - rolling_mean) / (3 * rolling_std),
+        (rolling_mean - lsl) / (3 * rolling_std)
+    )
+    cpk[rolling_std == 0] = 0
+    return rolling_mean, rolling_std, cp, cpk
+
+
+def process_unique_tool(tool, raw_data, file_id=None):
+    """
+    Process data for a single tool and save the results to a CSV file.
+    Args:
+        tool (str): Tool ID to process.
+        raw_data (pd.DataFrame): DataFrame containing the raw production data.
+    """
+    tool_data = raw_data[raw_data['Tool ID'] == tool].copy()
+    tool_data['pos_rolling_mean'], tool_data['pos_rolling_std'], tool_data['pos_rolling_cp'], tool_data['pos_rolling_cpk'] = stats_metrics(tool_data, 'Position', 0.5, 0.3)
+    tool_data['ori_rolling_mean'], tool_data['ori_rolling_std'], tool_data['ori_rolling_cp'], tool_data['ori_rolling_cpk'] = stats_metrics(tool_data, 'Orientation', 0.6, 0.2)
+    tool_data.to_csv(f'./data/tool_{file_id}.csv', index=False)
+
+
+def tools_metrics(raw_data):
+    """
+    Process the raw production data to extract tool metrics in parallel.
+    """
+    tools = raw_data['Tool ID'].unique()
+
+    with ThreadPoolExecutor() as executor:
+        executor.map(lambda tool: process_unique_tool(tool, raw_data, file_id=tool), tools)
+
+    # Calculate metrics for all tools together
+    all_tools_data = raw_data.copy()
+    all_tools_data = all_tools_data[all_tools_data['Tool ID'] != 'N/A']
+
+    all_tools_data['pos_rolling_mean'], all_tools_data['pos_rolling_std'], all_tools_data['pos_rolling_cp'], all_tools_data['pos_rolling_cpk'] = stats_metrics(all_tools_data, 'Position', 0.5, 0.3)
+    all_tools_data['ori_rolling_mean'], all_tools_data['ori_rolling_std'], all_tools_data['ori_rolling_cp'], all_tools_data['ori_rolling_cpk'] = stats_metrics(all_tools_data, 'Orientation', 0.6, 0.2)
+    all_tools_data.to_csv('./data/tool_all.csv', index=False)

src/production/processing.py

@@ -0,0 +1,9 @@
+from .metrics.tools import tools_metrics
+from .metrics.machine import machine_metrics
+
+def process(raw_data):
+    """
+    Process the raw production data to extract metrics.
+    """
+    tools_metrics(raw_data)
+    machine_metrics(raw_data)