"""Read-only LOG diagnostics under tolerances fixed before numeric rows were read.""" import math import re FIELDS = ('time_s', 'fill_percent', 'injection_pressure_Pa', 'clamp_force_N', 'flow_m3_s', 'frozen_percent') def parse(raw): # LF is the archive's physical line delimiter; retain raw CR bytes in raw files. lines = raw.decode('utf-8', errors='strict').split('\n') rows, headers, units, unsupported, mentions, transitions = [], [], [], [], [], [] active = False for number, original in enumerate(lines, 1): text = original.rstrip('\r').strip() if re.search(r'V/P|velocity/pressure|switch.over', text, re.I): mentions.append(dict(line=number, text=text)) if '|' in text and 'Time' in text: active = 'Fill Vol' in text and 'Flow Rate' in text if active: headers.append(dict(line=number, text=text)) continue if text.startswith('End of filling') or text.startswith('Pack Analysis'): active = False if not active or not text.startswith('|'): continue columns = [v.strip() for v in text.strip('|').split('|')] if '(s)' in text: units.append(dict(line=number, text=text)) continue if set(text) <= set('|-+ '): continue try: if len(columns) != 7: raise ValueError('expected seven table columns') values = [float(v) for v in columns[:6]] if not all(math.isfinite(v) for v in values): raise ValueError('nonfinite printed value') except ValueError as exc: unsupported.append(dict(line=number, text=text, reason=str(exc))) continue row = dict(zip(FIELDS, values), line=number, status=columns[6], printed_columns=columns, raw_line=original.rstrip('\r')) rows.append(row) if len(rows) == 1 or rows[-2]['status'] != row['status']: transitions.append(dict(line=number, time_s=row['time_s'], fill_percent=row['fill_percent'], status=row['status'])) expected_units = ('(s)', '(%)', '(Pa)', '(N)', '(m^3/s)', 'Vol (%)') units_supported = bool(units) and all(all(x in u['text'] for x in expected_units) for u in units) return dict(table_present=bool(headers), headers=headers, units=units, units_supported=units_supported, rows=rows, unsupported_rows=unsupported, status_transitions=transitions, switch_mentions=mentions, physical_line_count=len(lines)) def flow_window(rows, tolerance): if len(rows) < 2 or rows[-1]['time_s'] <= rows[0]['time_s']: return dict(defined=False, reason='insufficient_time_span', rows=len(rows)) span = rows[-1]['time_s'] - rows[0]['time_s'] integral = sum((b['time_s']-a['time_s'])*(a['flow_m3_s']+b['flow_m3_s'])/2 for a, b in zip(rows, rows[1:])) mean = integral/span common = dict(rows=len(rows), first_time_s=rows[0]['time_s'], last_time_s=rows[-1]['time_s'], first_fill_percent=rows[0]['fill_percent'], last_fill_percent=rows[-1]['fill_percent'], printed_flow_time_weighted_mean=mean, all_printed_flow_zero=all(r['flow_m3_s'] == 0 for r in rows)) if mean == 0: return dict(common, defined=False, reason='zero_printed_mean_cannot_assess_relative_flatness') departure = max(abs(r['flow_m3_s']-mean) for r in rows)/abs(mean) return dict(common, defined=True, max_relative_departure=departure, within_fixed_tolerance=departure <= tolerance) def diagnose(parsed, contract): rows = parsed['rows'] if not parsed['table_present']: return dict(status='NO_MATCHING_TABLE_HEADER', quantitative_defined=False) if parsed['unsupported_rows'] or not parsed['units_supported'] or len(rows) < 2: return dict(status='TABLE_PRESENT_BUT_UNSUPPORTED_OR_INSUFFICIENT', quantitative_defined=False) epsilon = contract['monotonicity_numeric_tolerance'] end = next((i for i, r in enumerate(rows) if r['fill_percent'] >= 100-epsilon), None) fill = rows[:end+1] if end is not None else rows violations = [dict(left_line=a['line'], right_line=b['line']) for a,b in zip(fill,fill[1:]) if b['time_s'] < a['time_s']-epsilon or b['fill_percent'] < a['fill_percent']-epsilon] if violations or any(r['fill_percent'] < -epsilon or r['fill_percent'] > 100+epsilon or r['time_s'] < 0 for r in fill): return dict(status='NONMONOTONE_OR_OUT_OF_RANGE', quantitative_defined=False, violations=violations) first, last = fill[0], fill[-1] span = last['time_s']-first['time_s'] if span <= 0: return dict(status='INSUFFICIENT_TIME_SPAN', quantitative_defined=False) residuals = [r['fill_percent']-(first['fill_percent']+(last['fill_percent']-first['fill_percent'])* (r['time_s']-first['time_s'])/span) for r in fill] maximum = max(map(abs,residuals)) switch = [dict(line=r['line'], time_s=r['time_s'], fill_percent=r['fill_percent'], status=r['status']) for r in fill if re.search(r'V\s*/\s*P|switch.over',r['status'],re.I)] pre = [r for r in fill if switch and r['line'] < switch[0]['line']] supplement = None if end is not None and last['time_s'] > 0: supp = max(abs(r['fill_percent']-100*r['time_s']/last['time_s']) for r in fill) supplement = dict(assumed_origin=[0,0], max_deviation_percentage_points=supp, within_fixed_tolerance=supp <= contract['linearity_tolerance_percentage_points']) return dict(status='PARSED', quantitative_defined=True, filling_rows=len(fill), first_row=first, last_row=last, reached_printed_100_percent=end is not None, equal_printed_time_intervals=sum(a['time_s']==b['time_s'] for a,b in zip(fill,fill[1:])), observed_switch_rows=switch, no_switch_time_inferred_from_settings=True, linearity=dict(max_deviation_percentage_points=maximum, within_fixed_tolerance=maximum <= contract['linearity_tolerance_percentage_points'], endpoint_residuals_pp=residuals, assumed_origin_supplement=supplement), flow=dict(whole_fill=flow_window(fill,contract['flow_flatness_relative_tolerance']), fixed_5_to_95_percent=flow_window([r for r in fill if 5<=r['fill_percent']<=95],contract['flow_flatness_relative_tolerance']), before_explicit_VP=flow_window(pre,contract['flow_flatness_relative_tolerance']) if switch else dict(defined=False,reason='no_explicit_switch_row')))