""" IPA Roll Compactor Control Performance Synthetic Dataset Generator v1.0 ======================================================================= Generates synthetic time-series process data simulating PID control behavior of roll compactors during dry granulation, grounded in the control performance concepts from: Szappanos-Csordás, K. (2018). "Impact of material properties, process parameters and roll compactor design on roll compaction." Chapter 3.1: Control performance of the different types of roll compactors. Key concepts modeled: - PID controller behavior (P, I, D terms) for SCF and gap width control - Settling time after setpoint changes (material- and design-dependent) - Steady-state deviation from setpoint (mean ± SD, CV%) - Control architecture differences: * No gap control (AlexanderWerk BT120-type): high GW variability * PID with GW + screw speed control (Hosokawa-type): moderate control * PID with SCF + GW control (Bohle/Gerteis-type): best control - Material-dependent control difficulty: MCC (plastic, compressible) is easier to control than mannitol (brittle, less compressible) - Overshoot, oscillation, and disturbance rejection behavior - Twin feed screw advantage: reduced feed fluctuation → lower SCF variance THIS IS SYNTHETIC EDUCATIONAL DATA. NOT REAL CUSTOMER OR LAB DATA. Generated by Innovative Process Applications (IPA) for teaching process control, PID tuning, and SPC concepts. """ import numpy as np import pandas as pd rng = np.random.default_rng(seed=2026) # ============================================================================= # CONTROL ARCHITECTURES (from Chapter 3.1 / Table 1 of the dissertation) # ============================================================================= CONTROL_CONFIGS = { "no_gap_control": { "label": "No Gap Control (HP setpoint only)", "description": "Hydraulic pressure setpoint, no closed-loop gap control", "has_scf_pid": False, "has_gw_pid": False, "scf_settling_base_s": 15.0, "gw_settling_base_s": 50.0, # gap drifts until material equilibrates "scf_noise_base": 0.012, # CV fraction — higher without PID "gw_noise_base": 0.030, # high GW variability (3% CV from Table 2) "overshoot_factor": 0.08, "feed_type": "single_screw", }, "pid_gw_screw": { "label": "PID: GW + Screw Speed Control", "description": "Gap width controlled via PID adjusting screw speed", "has_scf_pid": False, "has_gw_pid": True, "scf_settling_base_s": 12.0, "gw_settling_base_s": 20.0, "scf_noise_base": 0.010, "gw_noise_base": 0.015, "overshoot_factor": 0.12, # GW PID can overshoot on fast changes "feed_type": "single_screw", }, "pid_scf_gw": { "label": "PID: SCF + GW Control", "description": "Both SCF and GW controlled via independent PID loops", "has_scf_pid": True, "has_gw_pid": True, "scf_settling_base_s": 8.0, "gw_settling_base_s": 10.0, "scf_noise_base": 0.006, # best control performance "gw_noise_base": 0.008, "overshoot_factor": 0.05, "feed_type": "single_screw", }, "pid_scf_gw_twin_screw": { "label": "PID: SCF + GW Control + Twin Feed Screw", "description": "Dual PID loops with twin feed screw for uniform feeding", "has_scf_pid": True, "has_gw_pid": True, "scf_settling_base_s": 6.0, "gw_settling_base_s": 8.0, "scf_noise_base": 0.004, # twin screw reduces feed fluctuation "gw_noise_base": 0.006, "overshoot_factor": 0.04, "feed_type": "twin_screw", }, } # ============================================================================= # MATERIALS (control difficulty varies with deformation behavior) # ============================================================================= MATERIALS = { "MCC_101": { "label": "MCC 101 (Plastic)", "control_difficulty": 0.8, # easier — plastic deformation is smoother "settling_multiplier": 0.9, "disturbance_sensitivity": 0.7, }, "Mannitol_SD": { "label": "Mannitol (Brittle)", "control_difficulty": 1.3, # harder — brittle fragmentation causes spikes "settling_multiplier": 1.3, "disturbance_sensitivity": 1.4, }, "MCC_Mannitol_Mix": { "label": "1:1 Mixture", "control_difficulty": 1.0, "settling_multiplier": 1.0, "disturbance_sensitivity": 1.0, }, } # ============================================================================= # SETPOINT CHANGE SCENARIOS (from Table 2/3 patterns in the dissertation) # ============================================================================= SCENARIOS = [ {"scf_from": 4.0, "scf_to": 4.0, "gw_from": 2.0, "gw_to": 2.0, "label": "steady_state_baseline"}, {"scf_from": 4.0, "scf_to": 8.0, "gw_from": 2.0, "gw_to": 2.0, "label": "scf_step_up"}, {"scf_from": 8.0, "scf_to": 4.0, "gw_from": 2.0, "gw_to": 2.0, "label": "scf_step_down"}, {"scf_from": 6.0, "scf_to": 6.0, "gw_from": 3.0, "gw_to": 1.5, "label": "gw_step_down"}, {"scf_from": 6.0, "scf_to": 6.0, "gw_from": 1.5, "gw_to": 3.0, "label": "gw_step_up"}, {"scf_from": 4.0, "scf_to": 8.0, "gw_from": 3.0, "gw_to": 1.5, "label": "simultaneous_change"}, {"scf_from": 12.0, "scf_to": 12.0, "gw_from": 2.0, "gw_to": 2.0, "label": "high_force_steady"}, {"scf_from": 2.0, "scf_to": 2.0, "gw_from": 4.0, "gw_to": 4.0, "label": "low_force_wide_gap"}, ] # ============================================================================= # TIME-SERIES GENERATION # ============================================================================= SAMPLE_RATE_HZ = 2.0 # 2 samples/second (0.5s intervals) RUN_DURATION_S = 180.0 # 3-minute runs — enough to see settling + steady state SETPOINT_CHANGE_AT_S = 30.0 # setpoint changes at t=30s def pid_response(t, setpoint_from, setpoint_to, change_time, settling_time, overshoot_factor, noise_cv, has_pid, disturbance_sensitivity, rng_local): """ Simulate PID controller response to a setpoint change. Without PID: parameter drifts slowly toward equilibrium with high noise. With PID: second-order underdamped response (overshoot + settling). """ n = len(t) values = np.zeros(n) step_size = setpoint_to - setpoint_from for i, ti in enumerate(t): if ti < change_time: # Pre-change: at old setpoint with noise base = setpoint_from else: elapsed = ti - change_time if has_pid and abs(step_size) > 0.01: # Underdamped PID: exponential decay with overshoot tau = settling_time / 4.0 # time constant zeta = 0.4 + rng_local.uniform(-0.05, 0.05) # damping ratio omega_n = 1.0 / tau omega_d = omega_n * np.sqrt(1 - zeta**2) if zeta < 1 else omega_n decay = np.exp(-zeta * omega_n * elapsed) oscillation = np.cos(omega_d * elapsed) overshoot_amp = overshoot_factor * abs(step_size) response = 1.0 - decay * (oscillation + (zeta/np.sqrt(1-zeta**2)) * np.sin(omega_d * elapsed)) if zeta < 1 else \ 1.0 - (1 + omega_n * elapsed) * np.exp(-omega_n * elapsed) response = np.clip(response, -0.5, 1.5) base = setpoint_from + step_size * response elif not has_pid and abs(step_size) > 0.01: # No PID: slow exponential approach, never quite gets there tau = settling_time / 2.0 response = 1.0 - np.exp(-elapsed / tau) # Steady-state offset (no integral term to eliminate it) offset = 0.03 * step_size * disturbance_sensitivity base = setpoint_from + step_size * response * 0.95 + offset else: base = setpoint_to # Process noise (proportional to setpoint magnitude) noise = rng_local.normal(0, noise_cv * abs(base) + 0.01) # Occasional disturbances (feed fluctuations, powder bridging) if rng_local.random() < 0.02 * disturbance_sensitivity: noise += rng_local.normal(0, 0.05 * abs(base)) values[i] = base + noise return values def compute_run_metrics(t, scf_actual, gw_actual, scf_setpoint, gw_setpoint, change_time): """Compute the control performance metrics from Chapter 3.1.""" # Steady-state region: last 60 seconds of the run ss_mask = t >= (t[-1] - 60.0) # Settling region: after change, before steady state settling_mask = (t >= change_time) & (t < change_time + 90.0) # SCF metrics scf_ss = scf_actual[ss_mask] scf_mean = np.mean(scf_ss) scf_std = np.std(scf_ss) scf_cv = (scf_std / abs(scf_mean) * 100) if abs(scf_mean) > 0.1 else 0.0 scf_deviation_pct = abs(scf_mean - scf_setpoint) / scf_setpoint * 100 \ if scf_setpoint > 0.1 else 0.0 # GW metrics gw_ss = gw_actual[ss_mask] gw_mean = np.mean(gw_ss) gw_std = np.std(gw_ss) gw_cv = (gw_std / abs(gw_mean) * 100) if abs(gw_mean) > 0.1 else 0.0 gw_deviation_pct = abs(gw_mean - gw_setpoint) / gw_setpoint * 100 \ if gw_setpoint > 0.1 else 0.0 # Settling time: time after change until value stays within ±2% of final scf_settled_s = _find_settling_time(t, scf_actual, scf_setpoint, change_time, tolerance=0.02) gw_settled_s = _find_settling_time(t, gw_actual, gw_setpoint, change_time, tolerance=0.02) # Overshoot post_change = scf_actual[t >= change_time] if len(post_change) > 0 and scf_setpoint > 0.1: scf_overshoot_pct = (max(post_change) - scf_setpoint) / scf_setpoint * 100 else: scf_overshoot_pct = 0.0 return { "scf_ss_mean": round(scf_mean, 3), "scf_ss_std": round(scf_std, 4), "scf_ss_cv_pct": round(scf_cv, 2), "scf_deviation_from_setpoint_pct": round(scf_deviation_pct, 2), "scf_settling_time_s": round(scf_settled_s, 1), "scf_overshoot_pct": round(max(scf_overshoot_pct, 0), 2), "gw_ss_mean_mm": round(gw_mean, 4), "gw_ss_std_mm": round(gw_std, 4), "gw_ss_cv_pct": round(gw_cv, 2), "gw_deviation_from_setpoint_pct": round(gw_deviation_pct, 2), "gw_settling_time_s": round(gw_settled_s, 1), } def _find_settling_time(t, values, setpoint, change_time, tolerance=0.02): """Find time after change when value stays within tolerance band.""" if abs(setpoint) < 0.1: return 0.0 band = tolerance * abs(setpoint) post_mask = t >= change_time post_t = t[post_mask] post_v = values[post_mask] # Walk backwards from end to find last excursion outside band for i in range(len(post_v) - 1, -1, -1): if abs(post_v[i] - setpoint) > band: if i < len(post_v) - 1: return post_t[i+1] - change_time else: return post_t[-1] - change_time return 0.0 # already settled # ============================================================================= # GENERATE ALL RUNS # ============================================================================= t = np.arange(0, RUN_DURATION_S, 1.0 / SAMPLE_RATE_HZ) n_samples = len(t) summary_rows = [] timeseries_rows = [] run_id = 0 for ctrl_key, ctrl in CONTROL_CONFIGS.items(): for mat_key, mat in MATERIALS.items(): for scenario in SCENARIOS: run_id += 1 # Adjusted settling times and noise for material scf_settling = (ctrl["scf_settling_base_s"] * mat["settling_multiplier"]) gw_settling = (ctrl["gw_settling_base_s"] * mat["settling_multiplier"]) scf_noise = ctrl["scf_noise_base"] * mat["control_difficulty"] gw_noise = ctrl["gw_noise_base"] * mat["control_difficulty"] # Twin screw reduces feed fluctuation → lower noise if ctrl["feed_type"] == "twin_screw": scf_noise *= 0.75 gw_noise *= 0.80 # Generate time series scf_actual = pid_response( t, scenario["scf_from"], scenario["scf_to"], SETPOINT_CHANGE_AT_S, scf_settling, ctrl["overshoot_factor"], scf_noise, ctrl["has_scf_pid"], mat["disturbance_sensitivity"], rng ) gw_actual = pid_response( t, scenario["gw_from"], scenario["gw_to"], SETPOINT_CHANGE_AT_S, gw_settling, ctrl["overshoot_factor"] * 0.7, gw_noise, ctrl["has_gw_pid"], mat["disturbance_sensitivity"], rng ) # Clip to physical limits scf_actual = np.clip(scf_actual, 0.5, 25.0) gw_actual = np.clip(gw_actual, 0.5, 8.0) # Roll speed: constant within a run (not PID-controlled here) rs_setpoint = 3.0 + rng.uniform(-1, 1) rs_actual = rs_setpoint + rng.normal(0, 0.02 * rs_setpoint, n_samples) # Screw speed: varies if GW PID adjusts it ss_base = 30.0 + rng.uniform(-5, 5) if ctrl["has_gw_pid"]: # Screw speed adapts inversely to gap error gw_error = scenario["gw_to"] - gw_actual ss_actual = ss_base + 5.0 * gw_error + rng.normal(0, 0.5, n_samples) else: ss_actual = ss_base + rng.normal(0, 0.3, n_samples) # Store time-series (subsample to every 2s for manageable file size) subsample = np.arange(0, n_samples, 4) # every 2 seconds for idx in subsample: timeseries_rows.append({ "run_id": run_id, "time_s": round(t[idx], 1), "scf_setpoint_kN_per_cm": scenario["scf_to"] if t[idx] >= SETPOINT_CHANGE_AT_S else scenario["scf_from"], "scf_actual_kN_per_cm": round(scf_actual[idx], 3), "gw_setpoint_mm": scenario["gw_to"] if t[idx] >= SETPOINT_CHANGE_AT_S else scenario["gw_from"], "gw_actual_mm": round(gw_actual[idx], 4), "roll_speed_rpm": round(rs_actual[idx], 2), "screw_speed_rpm": round(ss_actual[idx], 1), }) # Compute summary metrics metrics = compute_run_metrics( t, scf_actual, gw_actual, scenario["scf_to"], scenario["gw_to"], SETPOINT_CHANGE_AT_S ) # Classify control quality total_cv = metrics["scf_ss_cv_pct"] + metrics["gw_ss_cv_pct"] if total_cv < 2.0 and metrics["scf_deviation_from_setpoint_pct"] < 1.0: control_quality = "Excellent" elif total_cv < 5.0 and metrics["scf_deviation_from_setpoint_pct"] < 3.0: control_quality = "Good" elif total_cv < 10.0: control_quality = "Acceptable" else: control_quality = "Poor" summary_rows.append({ "run_id": run_id, "control_architecture": ctrl_key, "control_label": ctrl["label"], "feed_type": ctrl["feed_type"], "has_scf_pid": ctrl["has_scf_pid"], "has_gw_pid": ctrl["has_gw_pid"], "material": mat_key, "scenario": scenario["label"], "scf_setpoint_kN_per_cm": scenario["scf_to"], "gw_setpoint_mm": scenario["gw_to"], **metrics, "control_quality_grade": control_quality, }) # ============================================================================= # SAVE # ============================================================================= df_summary = pd.DataFrame(summary_rows) df_timeseries = pd.DataFrame(timeseries_rows) df_summary.to_csv("control_performance_summary_v1.0.csv", index=False) df_timeseries.to_csv("control_performance_timeseries_v1.0.csv", index=False) print(f"Summary: {len(df_summary)} runs, {len(df_summary.columns)} columns") print(f"Time series: {len(df_timeseries)} rows, {len(df_timeseries.columns)} columns") print() print("=== Control quality distribution ===") print(df_summary["control_quality_grade"].value_counts()) print() print("=== Mean SCF CV% by architecture ===") print(df_summary.groupby("control_architecture")["scf_ss_cv_pct"].mean().round(2)) print() print("=== Mean GW CV% by architecture ===") print(df_summary.groupby("control_architecture")["gw_ss_cv_pct"].mean().round(2)) print() print("=== Mean SCF settling time by architecture ===") print(df_summary.groupby("control_architecture")["scf_settling_time_s"].mean().round(1))