Freeze naive-ordering complete scores and bounded LOG parser
This commit is contained in:
1 parent
81dede0bd1
commit
9b7121a407
30 files changed
+1735298
No files matched your search
@@ -0,0 +1,113 @@
|
||||
"""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')))
|
||||
Reference in new issue
Block a user