| """CHEM-168 BD FACSAria III cell sorter (2018 specification; 4 lasers 405 / 488 / 561 / 633 nm, 10 fluorescence detectors, ACDU, AMO and |
| sort-collection recirculator options): process runtime. |
| |
| Device (Technical Specifications 23-11585-02 (2018); User's Guide 333608 (2003); facility guides): fluidics cart (10-L sheath and waste, 5-L |
| cleaning reservoirs, 80-100 psi air) feeding a pressurised plenum; Fluidics Startup / Shutdown (shutdown ~3 min with the closed-loop nozzle) and |
| cleaning modes; Sort Setup presets (70 um at 70 / 35 psi, 85, 100, 130 um) setting sheath pressure 5-75 psi, drop drive 1-100,000 Hz, amplitude |
| 1-80 V, plate voltage 0-6000 V, side-stream charges, laser delays and area scaling; stream button; breakoff camera (Drop 1 / Gap, Drop 1 jumps by |
| the drop spacing ~57 px), Sweet Spot (amplitude servo, pauses sorting when the Gap is >2 px off, on a clog turns the stream and plates off, closes |
| the aspirator drawer and unloads the tube); side streams (far left, left, right, far right), test sort, BD Accudrop (diode laser, lower camera, |
| optical filter; automatic drop delay 10-140 drops); masks in 1/32-drop (yield, purity, phase; Purity, 4-Way Purity, Yield, Single Cell, Initial, |
| Fine Tune modes); sample injection chamber with Load / Unload, agitation and 4 / 20 / 37 / 42 C control (~45 min), chamber light; flow rate 1-11 |
| (~10-120 ul/min); lasers need 30 min warm-up, the flow cell access door blocks them; FSC photodiode and SSC / fluorescence PMTs, 262,144 channels, |
| H / A / W, thresholds on any parameter (OR / AND), max 70,000 events/s with 12 compensation pairs and 8 parameters; Emergency stop button (lit while |
| a tube loads); AMO (16 / 69 chamber volumes per minute); sort collection devices 2-way 12 x 75 / 15 mL, 4-way 12 x 75 / 1.5 mL, ACDU plates. |
| |
| Process model (fixed 0.1 s grid, numpy per particle): jet speed Cd sqrt(2 dP / rho), Rayleigh capillary growth of the drop-drive perturbation |
| (breakoff length, Drop 1 / Gap on a strobe-locked camera, drop delay = plenum-to-nozzle transit + breakoff drops), surface tension and density of |
| water (IAPWS 2014, Tanaka 2001) with sheath warm-up; Poisson particle arrivals from tube populations (particle library: Mie FSC / SSC tables; |
| fluorochrome library: FPbase spectra, photon budget calibrated to the documented 85 MESF-FITC / 29 MESF-PE), hydrodynamic core position in the |
| 65-um beam, laser warm-up and noise, photoelectron statistics, PMT gain (V/500)^7, electronic noise, laser-delay capture, area scaling, pulse |
| pile-up within the window extension, the processing limit and electronic aborts; compensation, gates and statistics; drop assignment with the set |
| vs. true drop delay, BD mask logic, conflicts, side-stream landing and capture, sub-threshold particles riding in sorted drops; sorted fractions |
| become new samples (post-sort purity check).""" |
| import copy |
| import json |
| import math |
| import zlib |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| PROTOCOL_VERSION = "1.0.0" |
| ASSET_TYPE_ID = "instrument.bd_facsariaiii" |
| CATALOG_ID = "CHEM-168" |
| ROOT = Path(__file__).resolve().parents[2] |
| ASSET_DIR = ROOT / 'assets/expansion_batch04/t4_measure/bd_facsariaiii' |
| LIBS = {'fluorochromes': 'fluorochrome_library.json', 'particles': 'particle_library.json', 'fluidics': 'fluidics_model.json', 'optics': 'optics_model.json'} |
|
|
|
|
| class ActionRejected(ValueError): |
| """A capability call refused with a declared error code (no state change).""" |
|
|
|
|
| |
| _LIBC = {} |
|
|
|
|
| def _lib(name): |
| if name not in _LIBC: |
| _LIBC[name] = json.loads((ASSET_DIR / LIBS[name]).read_text()) |
| return _LIBC[name] |
|
|
|
|
| def fluorochromes(): |
| return _lib('fluorochromes')['substances'] |
|
|
|
|
| def particles(): |
| return _lib('particles')['substances'] |
|
|
|
|
| def fluidics(): |
| return _lib('fluidics') |
|
|
|
|
| def optics(): |
| return _lib('optics') |
|
|
|
|
| |
| DT = 0.1 |
| PSI = 6894.757 |
| ADC_MAX = 262143.0 |
| LASERS = ['violet', 'blue', 'yellow_green', 'red'] |
| FL_DETS = ['V450_50', 'V510_50', 'B530_30', 'B695_40', 'YG582_15', 'YG610_20', 'YG710_50', 'YG780_60', 'R660_20', 'R780_60'] |
| DETS = ['FSC', 'SSC'] + FL_DETS |
| DET_LASER = {'FSC': 'blue', 'SSC': 'blue', 'V450_50': 'violet', 'V510_50': 'violet', 'B530_30': 'blue', 'B695_40': 'blue', 'YG582_15': 'yellow_green', |
| 'YG610_20': 'yellow_green', 'YG710_50': 'yellow_green', 'YG780_60': 'yellow_green', 'R660_20': 'red', 'R780_60': 'red'} |
| PARAMS = [f'{d}-{x}' for d in DETS for x in ('A', 'H', 'W')] + ['Time'] |
| PIDX = {p: i for i, p in enumerate(PARAMS)} |
| NPAR = len(PARAMS) |
| CHANNEL_AREA = 160e-6 * 250e-6 |
| CORE_SPEED_RATIO = 2.0 |
| BEAM_H, BEAM_W = 9e-6, 65e-6 |
| PULSE_K = 0.8 |
| K_CH = 1.8 |
| PMT_EXP, PMT_REF_V = 7.0, 500.0 |
| FSC_EXP = 3.0 |
| FSC_NOISE_CH = 10.0 |
| WIDTH_SCALE = 65536.0 |
| LASER_NOISE = 0.006 |
| WARMUP_S = 1800.0 |
| WARMUP_TAU_S = 480.0 |
| LASER_POWER_W = {'violet': 60.0, 'blue': 60.0, 'yellow_green': 100.0, 'red': 80.0} |
| BASE_POWER_W = 700.0 |
| SAMPLE_TC_POWER_W = 100.0 |
| RATE_REF = 70000.0 |
| LOAD_TRAVEL = 0.065 |
| PORT_SPEED = LOAD_TRAVEL / 3.0 |
| DRAWER_TRAVEL = 0.080 |
| DRAWER_SPEED = DRAWER_TRAVEL / 1.0 |
| ESTOP_TRAVEL = 0.006 |
| GAUGE_FULL_SCALE_PSI = 160.0 |
| GAUGE_SWEEP = 270.0 * math.pi / 180 |
| CART_AIR_PA = 88.0 * PSI |
| CART_AIR_TAU_S = (20.0, 60.0) |
| SHEATH_TAU_S = 2.0 |
| STARTUP_S, SHUTDOWN_S = 480.0, 180.0 |
| CLEAN_S = {'clean_flow_cell': 360.0, 'prepare_aseptic_sort': 2100.0} |
| PRIME_SHEATH_M3 = 4.0e-4 |
| SAMPLE_CHAMBER_TAU_S = 900.0 |
| TUBE_TAU_S = 300.0 |
| COLLECTION_TAU_S = 600.0 |
| SHEATH_WARM_K, SHEATH_WARM_TAU_S = 1.5, 1200.0 |
| TRANSDUCER_TC = -0.02 |
| ATTENUATION = 0.25 |
| CAMERA_PX_M = None |
| REF_SHEATH_K = 295.15 |
| NB_REF_70 = 20.0 |
| INSTALL_SD = (0.15, 0.03) |
| |
| DROP1_DEFAULT, GAP_DEFAULT = 330.0, 6.0 |
| DROP1_RANGE = (100.0, 600.0) |
| GAP_TOL_PAUSE, DROP1_TOL = 2.0, 10.0 |
| SS_COARSE_V_S, SS_FINE_V_S = 2.0, 0.2 |
| DD_JITTER = 0.02 |
| SIDE_SIGMA_M = (3.5e-4, 5.0e-4) |
| ASPIRATOR_R = 1.5e-3 |
| BEAD_STOCK_PER_M3 = 1.0e12 |
| MAX_EVENTS_LOG = 1000 |
| MAX_RECORDS, MAX_RECORD_EVENTS, MAX_STORED_EVENTS = 40, 100000, 400000 |
| LIVE_BUFFER = 20000 |
| MAX_TUBES, MAX_SAMPLES, MAX_GATES, MAX_LAYOUTS = 40, 40, 64, 16 |
| AGITATION = {'off': 0.0, '100_rpm': 100.0 / 60.0, '200_rpm': 200.0 / 60.0, '300_rpm': 300.0 / 60.0} |
| AGITATION_EFFECT = 0.6 |
| |
| AMO_EXCHANGE_PER_S = {'normal': 16.0 / 60.0, 'rapid': 69.0 / 60.0} |
| SAMPLE_SETPOINTS_K = [277.15, 293.15, 310.15, 315.15] |
| COLLECTION_RANGE_K = (277.15, 315.15) |
| ROOM_RANGE_K = (290.65, 300.65) |
| FAULTS = ['power_loss', 'clog_full', 'clog_partial', 'flow_cell_bubble', 'laser_failure_violet', 'laser_failure_blue', 'laser_failure_yellow_green', |
| 'laser_failure_red', 'breakoff_drift', 'cart_air_leak'] |
| TUBE_TYPES = {'12x75': dict(capacity_m3=5.0e-6, dead_m3=5.0e-8, radius_m=5.5e-3), '15ml': dict(capacity_m3=1.5e-5, dead_m3=2.0e-7, radius_m=7.4e-3), |
| '1.5ml': dict(capacity_m3=1.5e-6, dead_m3=3.0e-8, radius_m=4.5e-3)} |
| PROBE_HEIGHT_M = 2.0e-3 |
| PRECISION = {'purity': (32, 32, 0, False), '4way_purity': (0, 32, 0, False), 'yield': (32, 0, 0, False), 'single_cell': (0, 32, 16, True), |
| 'initial': (32, 0, 0, False), 'fine_tune': (0, 0, 0, False)} |
| STREAMS = ['far_left', 'left', 'right', 'far_right'] |
| STREAM_SIGN = {'far_left': -1, 'left': -1, 'right': 1, 'far_right': 1} |
| DEVICES = { |
| '2way_12x75': dict(kind='tubes', tube='12x75', locations={'left': ('left', -0.014), 'right': ('right', 0.014)}, capture_r=4.4e-3), |
| '2way_15ml': dict(kind='tubes', tube='15ml', locations={'left': ('left', -0.018), 'right': ('right', 0.018)}, capture_r=5.9e-3), |
| '4way_12x75': dict(kind='tubes', tube='12x75', locations={'far_left': ('far_left', -0.0315), 'left': ('left', -0.014), 'right': ('right', 0.014), |
| 'far_right': ('far_right', 0.0315)}, capture_r=4.4e-3), |
| '4way_1.5ml': dict(kind='tubes', tube='1.5ml', locations={'far_left': ('far_left', -0.022), 'left': ('left', -0.0095), 'right': ('right', 0.0095), |
| 'far_right': ('far_right', 0.022)}, capture_r=3.6e-3), |
| 'plate_96': dict(kind='plate', rows='ABCDEFGH', cols=12, well_m3=3.0e-7, capture_r=3.4e-3, move_s=0.25, stream='left', x=-0.014), |
| 'plate_384': dict(kind='plate', rows='ABCDEFGHIJKLMNOP', cols=24, well_m3=8.0e-8, capture_r=1.6e-3, move_s=0.20, stream='left', x=-0.014), |
| |
| 'plate_6': dict(kind='plate', rows='AB', cols=3, well_m3=1.68e-5, capture_r=1.5e-2, move_s=0.60, stream='left', x=-0.014), |
| 'plate_24': dict(kind='plate', rows='ABCD', cols=6, well_m3=3.4e-6, capture_r=6.8e-3, move_s=0.40, stream='left', x=-0.014), |
| 'plate_48': dict(kind='plate', rows='ABCDEF', cols=8, well_m3=1.6e-6, capture_r=4.8e-3, move_s=0.30, stream='left', x=-0.014), |
| } |
| NOZZLES = ['70', '85', '100', '130', 'closed_loop'] |
| DOORS = {'optics': (0.0, 100 * math.pi / 180), 'flow_cell': (0.0, 70 * math.pi / 180), 'side': (0.0, 100 * math.pi / 180), 'sort_chamber': (0.0, 100 * math.pi / 180)} |
| DOOR_CLOSED_RAD = 2.0 * math.pi / 180 |
| SPILL_MIN = 1.0e-3 |
| DOOR_OPEN_RAD = 60.0 * math.pi / 180 |
| PRESET_ATTEN = {'70_high': False, '70_medium': True, '85': False, '100': True, '130': True, '70_custom': False} |
| |
| PRESET_PLATE_V = {'70_high': 6000.0, '70_medium': 5000.0, '100': 5000.0, '85': 5000.0, '130': 5000.0, '70_custom': 0.0} |
| PRESET_ASF = {'70_high': dict(blue=1.40, red=1.00, violet=0.80), '70_medium': dict(blue=1.20, red=0.75, violet=0.35), '100': dict(blue=1.40, red=1.00, violet=0.50), |
| '70_custom': dict(blue=0.75, red=0.50, violet=0.25)} |
| NONSORT_PRESETS = ('70_custom',) |
| LASER_SPOT_ORDER = {'blue': 0.0, 'red': -1.0, 'violet': 1.0, 'yellow_green': 2.0} |
| ROLES_DNA = {'dna_viability', 'viability'} |
|
|
|
|
| def _phi(x): |
| return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0))) |
|
|
|
|
| def _erf_v(x): |
| """Vectorised erf (Abramowitz & Stegun 7.1.26, |error| < 1.5e-7).""" |
| s = np.sign(x) |
| x = np.abs(x) |
| t = 1.0 / (1.0 + 0.3275911 * x) |
| y = 1.0 - (((((1.061405429 * t - 1.453152027) * t) + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t * np.exp(-x * x) |
| return s * y |
|
|
|
|
| def _phi_v(x): |
| return 0.5 * (1.0 + _erf_v(np.asarray(x, float) / math.sqrt(2.0))) |
|
|
|
|
| def _bessel_ratio(x): |
| """I1(x) / I0(x) by series (x < 3).""" |
| i0 = i1 = 0.0 |
| term0, term1 = 1.0, x / 2.0 |
| for k in range(30): |
| i0 += term0 |
| i1 += term1 |
| term0 *= (x / 2.0) ** 2 / ((k + 1) ** 2) |
| term1 *= (x / 2.0) ** 2 / ((k + 1) * (k + 2)) |
| return i1 / i0 |
|
|
|
|
| def water_surface_tension(T): |
| """IAPWS 2014 release on the surface tension of ordinary water (N/m).""" |
| tau = 1.0 - T / 647.096 |
| return 0.2358 * tau ** 1.256 * (1.0 - 0.625 * tau) |
|
|
|
|
| def water_density(T): |
| """Tanaka et al. (2001) density of SMOW at 0.1 MPa (kg/m3), T in K.""" |
| t = T - 273.15 |
| return 999.974950 * (1.0 - (t - 3.983035) ** 2 * (t + 301.797) / (522528.9 * (t + 69.34881))) |
|
|
|
|
| def water_viscosity(T): |
| """Dynamic viscosity of water (Pa s), Vogel form fitted to IAPWS 2008 values 273-373 K (engineering fit, +-1 %).""" |
| return 2.414e-5 * 10 ** (247.8 / (T - 140.0)) |
|
|
|
|
| def jet_speed(p_pa, T, cd): |
| return cd * math.sqrt(2.0 * max(p_pa, 0.0) / water_density(T)) |
|
|
|
|
| LAMBDA_OVER_D = 4.4 |
|
|
|
|
| def growth_rate(a, lam, T): |
| """Rayleigh inviscid growth rate (1/s) of a perturbation of wavelength lam on a jet of radius a; 0 if the wavelength is stable (ka >= 1).""" |
| x = 2.0 * math.pi * a / lam |
| if x >= 1.0 or x <= 0.0: |
| return 0.0 |
| return math.sqrt(water_surface_tension(T) / (water_density(T) * a ** 3) * x * (1.0 - x * x) * _bessel_ratio(x)) |
|
|
|
|
| |
| _CAL = {} |
|
|
|
|
| def _cal(): |
| if _CAL: |
| return _CAL |
| fl = fluidics() |
| pre = fl['presets'] |
| T = REF_SHEATH_K |
| hi = pre['70_high'] |
| cd_hi = fl['discharge_coefficient']['value'] |
| |
| |
| q_hi = _q_sheath(hi['nozzle_m'], jet_speed(hi['sheath_pressure_pa'], T, cd_hi)) |
| cds = {} |
| for name, p in pre.items(): |
| ideal = jet_speed(p['sheath_pressure_pa'], T, 1.0) |
| if name in fl['laser_delay_us']: |
| q = q_hi * fl['laser_delay_us']['70_high'] / fl['laser_delay_us'][name] |
| cds[name] = q / (math.pi / 4 * p['nozzle_m'] ** 2 * ideal) |
| else: |
| cds[name] = LAMBDA_OVER_D * p['nozzle_m'] * p['drop_drive_frequency_hz'] / ideal |
| v_hi = jet_speed(hi['sheath_pressure_pa'], T, cds['70_high']) |
| lam_hi = v_hi / hi['drop_drive_frequency_hz'] |
| px = lam_hi / 57.0 |
| L_ref = NB_REF_70 * lam_hi |
| cam_top = L_ref - (DROP1_DEFAULT - GAP_DEFAULT - _drop_r(hi['nozzle_m'] / 2, lam_hi) / px) * px |
| out = dict(px=px, L_ref=L_ref, cam_top=cam_top, presets={}) |
| v_core_hi = 2.0 * _q_sheath(hi['nozzle_m'], v_hi) / CHANNEL_AREA |
| spot = {L: LASER_SPOT_ORDER[L] * fl['laser_delay_us']['70_high'] * 1e-6 * v_core_hi for L in LASERS} |
| out['spot_m'] = spot |
| for name, p in pre.items(): |
| a = p['nozzle_m'] / 2 |
| f = p['drop_drive_frequency_hz'] |
| v = jet_speed(p['sheath_pressure_pa'], T, cds[name]) |
| lam = v / f |
| om = growth_rate(a, lam, T) |
| nb = L_ref / lam |
| a_eff = p['amplitude_v'] * (ATTENUATION if PRESET_ATTEN[name] else 1.0) |
| G = a / (a_eff * math.exp(nb * om / f)) |
| q = _q_sheath(p['nozzle_m'], v) |
| vdead = max(1e-12, (p['drop_delay_drops'] - nb) * q / f) |
| if name in NONSORT_PRESETS: |
| G, vdead = out['presets']['70_high']['G'], out['presets']['70_high']['vdead'] |
| r_px = _drop_r(a, lam) / px |
| B_ref = (L_ref - cam_top) / px |
| p0 = B_ref + r_px + GAP_DEFAULT |
| out['presets'][name] = dict(nozzle_um=str(int(round(p['nozzle_m'] * 1e6))), a=a, G=G, vdead=vdead, p0=p0, pressure_pa=p['sheath_pressure_pa'], |
| frequency_hz=f, amplitude_v=p['amplitude_v'], drop_delay=p['drop_delay_drops'], v=v, d_drop=2 * _drop_r(a, lam), cd=cds[name], |
| lambda_over_d=lam / p['nozzle_m'], nb_ref=nb) |
| |
| dd = fl['deflection']['side_stream_voltage_pct'] |
| for name in out['presets']: |
| if name in dd and name not in NONSORT_PRESETS: |
| near = dd[name][1] / 100.0 |
| out['presets'][name]['K_defl'] = 0.014 / (near * PRESET_PLATE_V[name]) |
| out['presets'][name]['side_frac'] = [float(x) / 100.0 for x in dd[name]] |
| ref = out['presets']['100'] |
| for name in ('85', '130'): |
| p = out['presets'][name] |
| p['K_defl'] = ref['K_defl'] * (ref['v'] / p['v']) ** 2 * (ref['d_drop'] / p['d_drop']) ** 2 |
| near = 0.014 / (p['K_defl'] * PRESET_PLATE_V[name]) |
| p['side_frac'] = [round(min(1.0, near * 2.25), 3), round(min(1.0, near), 3), round(min(1.0, near), 3), round(min(1.0, near * 2.25), 3)] |
| hi_ = out['presets']['70_high'] |
| for name in NONSORT_PRESETS: |
| p = out['presets'][name] |
| p['K_defl'] = hi_['K_defl'] * (hi_['v'] / p['v']) ** 2 * (hi_['d_drop'] / p['d_drop']) ** 2 |
| p['side_frac'] = [float(x) / 100.0 for x in dd[name]] |
| _CAL.update(out) |
| return _CAL |
|
|
|
|
| def _drop_r(a, lam): |
| return 0.5 * (6.0 * a * a * lam) ** (1.0 / 3.0) |
|
|
|
|
| def _q_sheath(d_noz, v): |
| return math.pi / 4.0 * d_noz ** 2 * v |
|
|
|
|
| |
| _PB = {} |
|
|
|
|
| def _photon(): |
| """Per-dye photoelectrons per molecule at the reference transit (70 psi), saturation k tau, per-detector backgrounds; FSC / SSC scales.""" |
| if _PB: |
| return _PB |
| op = optics() |
| fl = fluorochromes() |
| dets = op['detectors'] |
| cone, T, t_ref = op['collection_solid_angle_fraction'], op['optical_transmission'], op['reference_transit_s'] |
| flux = {dets[d]['laser']: dets[d]['photon_flux_m2_s'] for d in FL_DETS} |
| dyes = sorted(fl) |
| q = np.zeros((len(dyes), len(FL_DETS))) |
| ktau = np.zeros((len(dyes), len(FL_DETS))) |
| for i, k in enumerate(dyes): |
| d = fl[k] |
| for j, det in enumerate(FL_DETS): |
| L = dets[det]['laser'] |
| lex = d['laser_excitation'][L] |
| if lex <= 0: |
| continue |
| kex = 3.82e-25 * d['ext_coeff_m1_cm1'] * lex * flux[L] |
| kt = kex * d['lifetime_s'] |
| q[i, j] = d['quantum_yield'] * t_ref * kex / (1.0 + kt) * cone * T * d['detector_response'][det] / lex |
| ktau[i, j] = kt |
| bg = np.array([dets[d]['background_pe'] for d in FL_DETS]) |
| pl = particles() |
| ref = pl['human_t_cell_cd4'] |
| sc = ref['scatter'] |
| lg = np.log(sc['diameter_um']) |
| s_f = float(np.exp(np.interp(math.log(ref['diameter_um']), lg, np.log(sc['fsc_cross_section_m2'])))) |
| s_s = float(np.exp(np.interp(math.log(ref['diameter_um']), lg, np.log(sc['ssc_cross_section_m2'])))) * ref['granularity_factor'] |
| ph_f = s_f * flux['blue'] * t_ref |
| ph_s = s_s * flux['blue'] * t_ref |
| k_fsc = 60000.0 / (ph_f * (250.0 / 500.0) ** FSC_EXP) |
| t_ssc = 15000.0 / (ph_s * (300.0 / PMT_REF_V) ** PMT_EXP * K_CH) |
| _PB.update(dyes=dyes, didx={k: i for i, k in enumerate(dyes)}, q=q, ktau=ktau, bg=bg, flux=flux, t_ref=t_ref, k_fsc=k_fsc, t_ssc=t_ssc, |
| v_ref=op['reference_cuvette_speed_m_s'], fitc=dyes.index('fluorescein_fitc')) |
| return _PB |
|
|
|
|
| BEAD_DYES = ['fluorescein_fitc', 'pe_r_pe_r_phycoerythrin', 'apc_allophycocyanin', 'pacific_blue', 'bd_horizon_v500', 'percp_cy5_5', 'pe_cf594', 'pe_cy5_5', 'pe_cy7', |
| 'apc_cy7'] |
|
|
|
|
| |
| def number(unit='1', lo=None, hi=None): |
| s = {'type': 'number', 'x-unit': unit} |
| if lo is not None: |
| s['minimum'] = lo |
| if hi is not None: |
| s['maximum'] = hi |
| return s |
|
|
|
|
| def obj(properties, optional=()): |
| return dict(type='object', properties=properties, required=[k for k in properties if k not in optional], additionalProperties=False) |
|
|
|
|
| def nullable(s): |
| return {'anyOf': [s, {'type': 'null'}]} |
|
|
|
|
| def array(s, minimum=0, maximum=4096): |
| return dict(type='array', items=s, minItems=minimum, maxItems=maximum) |
|
|
|
|
| def enum(items): |
| return {'type': 'string', 'enum': list(items)} |
|
|
|
|
| def integer(lo, hi): |
| return {'type': 'integer', 'x-unit': '1', 'minimum': lo, 'maximum': hi} |
|
|
|
|
| BOOL = {'type': 'boolean'} |
| TEXT = {'type': 'string'} |
| INT = {'type': 'integer', 'x-unit': '1'} |
|
|
|
|
| def validate(s, v): |
| if 'anyOf' in s: |
| for o in s['anyOf']: |
| try: |
| validate(o, v) |
| return |
| except ActionRejected: |
| pass |
| raise ActionRejected('INVALID_ARGUMENT') |
| k = s.get('type') |
| if k in ('number', 'integer'): |
| if isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v) or (k == 'integer' and not float(v).is_integer()): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if not s.get('minimum', -math.inf) <= v <= s.get('maximum', math.inf): |
| raise ActionRejected('INVALID_ARGUMENT') |
| elif k == 'object': |
| if not isinstance(v, dict): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if 'properties' in s: |
| req = set(s.get('required', s['properties'])) |
| if not req <= set(v) or not set(v) <= set(s['properties']): |
| raise ActionRejected('INVALID_ARGUMENT') |
| for key, value in v.items(): |
| validate(s['properties'][key], value) |
| elif 'additionalProperties' in s and isinstance(s['additionalProperties'], dict): |
| if len(v) > s.get('maxProperties', math.inf) or len(v) < s.get('minProperties', 0): |
| raise ActionRejected('INVALID_ARGUMENT') |
| for key, value in v.items(): |
| if 'propertyNames' in s: |
| validate(s['propertyNames'], key) |
| validate(s['additionalProperties'], value) |
| elif k == 'array': |
| if not isinstance(v, list) or not s.get('minItems', 0) <= len(v) <= s.get('maxItems', math.inf): |
| raise ActionRejected('INVALID_ARGUMENT') |
| for x in v: |
| validate(s['items'], x) |
| elif k == 'boolean' and type(v) is not bool: |
| raise ActionRejected('INVALID_ARGUMENT') |
| elif k == 'string': |
| if not isinstance(v, str) or len(v) > s.get('maxLength', 10 ** 6) or len(v) < s.get('minLength', 0): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if 'pattern' in s: |
| import re |
| if not re.fullmatch(s['pattern'], v): |
| raise ActionRejected('INVALID_ARGUMENT') |
| elif k == 'null' and v is not None: |
| raise ActionRejected('INVALID_ARGUMENT') |
| if 'enum' in s and v not in s['enum']: |
| raise ActionRejected('INVALID_ARGUMENT') |
|
|
|
|
| |
| CAPS = {} |
|
|
|
|
| def cap(k, s, o, e, c, meaning, visibility='agent', kind='device_command'): |
| CAPS[k] = dict(input_schema=s, output_schema=o, example_arguments=e, component_ids=c, function_zh=meaning, visibility=visibility, kind=kind) |
|
|
|
|
| SID = dict(type='string', minLength=1, maxLength=40, pattern='^[A-Za-z0-9_.:-]+$') |
| LIBID = dict(type='string', minLength=1, maxLength=80) |
| PRESETS = ['70_high', '70_medium', '85', '100', '130', '70_custom'] |
| PARAM_E = enum(PARAMS) |
| DETMAP = lambda s: dict(type='object', propertyNames=enum(DETS), additionalProperties=s, minProperties=1, maxProperties=len(DETS)) |
| LASERMAP = lambda s: dict(type='object', propertyNames=enum(LASERS), additionalProperties=s, minProperties=1, maxProperties=4) |
| STREAMMAP = lambda s: dict(type='object', propertyNames=enum(STREAMS), additionalProperties=s, minProperties=1, maxProperties=4) |
| PLANT_EXAMPLE = dict(room_k=295.15, mains_voltage_v=230.0, noise_seed=1) |
| PLANT = obj(dict(room_k=number('K', 283.15, 308.15), mains_voltage_v=number('V', 0.0, 264.0), noise_seed=integer(0, 2 ** 31 - 1), |
| room_drift_k_per_s=number('K/s', -1e-3, 1e-3)), optional=('room_drift_k_per_s',)) |
| STAIN = obj(dict(dye=LIBID, molecules=number('1', 0.0, 1.0e10), cv=number('1', 0.0, 2.0), target=enum(['all', 'live', 'dead'])), optional=('cv', 'target')) |
| POP = obj(dict(population_id=SID, particle_id=LIBID, concentration_per_m3=number('1/m3', 0.0, 1.0e16), diameter_m=number('m', 2.0e-7, 3.0e-5), |
| diameter_cv=number('1', 0.0, 0.6), dead_fraction=number('1', 0.0, 1.0), doublet_fraction=number('1', 0.0, 0.5), stains=array(STAIN, 0, 12)), |
| optional=('diameter_m', 'diameter_cv', 'dead_fraction', 'doublet_fraction', 'stains')) |
| SAMPLE_EXAMPLE = dict(sample_id='pbmc_cd4_fitc', volume_m3=2.0e-6, populations=[ |
| dict(population_id='cd4_t', particle_id='human_t_cell_cd4', concentration_per_m3=4.0e12, dead_fraction=0.05, |
| stains=[dict(dye='fluorescein_fitc', molecules=45000.0, cv=0.35), dict(dye='propidium_iodide', molecules=1.0e9, cv=0.2, target='dead')]), |
| dict(population_id='b_cells', particle_id='human_b_cell', concentration_per_m3=1.5e12, stains=[dict(dye='fluorescein_fitc', molecules=300.0, cv=0.5)])]) |
| SOURCE = obj(dict(sample_id=SID, bead_id=LIBID, volume_m3=number('m3', 1.0e-10, 1.5e-5), stains=array(STAIN, 0, 4)), optional=('sample_id', 'bead_id', 'stains')) |
| TUBE_EXAMPLE = dict(tube_id='t1', tube_type='12x75', sources=[dict(sample_id='pbmc_cd4_fitc', volume_m3=5.0e-7)], buffer_volume_m3=5.0e-7) |
| OPERATION = obj(dict(operation_id=TEXT)) |
| EVENT = obj(dict(time_s=number('s'), kind=enum(['power', 'laser', 'fluidics', 'stream', 'sample', 'acquisition', 'record', 'sort', 'deflection', 'safety', 'cart', |
| 'warning', 'error', 'fault', 'truth', 'data', 'cst']), code=TEXT, message_zh=TEXT)) |
| GATE = obj(dict(gate_id=SID, parent=nullable(SID), kind=enum(['rectangle', 'polygon', 'interval']), x=PARAM_E, y=nullable(PARAM_E), |
| x_range=nullable(array(number('1'), 2, 2)), y_range=nullable(array(number('1'), 2, 2)), vertices=nullable(array(array(number('1'), 2, 2), 3, 64))), |
| optional=('parent', 'y', 'x_range', 'y_range', 'vertices')) |
| STAT_ROW = obj(dict(gate=TEXT, events=INT, pct_parent=nullable(number('1')), pct_total=nullable(number('1')), |
| parameters=array(obj(dict(parameter=TEXT, mean=nullable(number('1')), median=nullable(number('1')), cv=nullable(number('1')), |
| rcv=nullable(number('1')))), 0, NPAR))) |
| MASKS = obj(dict(yield_mask=integer(0, 32), purity_mask=integer(0, 32), phase_mask=integer(0, 32), single_cell=BOOL)) |
| LAYOUT = obj(dict(layout_id=SID, device=enum(DEVICES), precision_mode=enum(list(PRECISION) + ['custom']), masks=MASKS, |
| targets=dict(type='object', propertyNames=enum(STREAMS + ['plate']), additionalProperties=SID, minProperties=1, maxProperties=4), |
| target_events=dict(type='object', propertyNames=enum(STREAMS + ['plate']), additionalProperties=integer(1, 10 ** 9), maxProperties=4), |
| events_per_well=integer(1, 100000), wells=array(TEXT, 1, 384)), |
| optional=('masks', 'target_events', 'events_per_well', 'wells')) |
| LAYOUT_EXAMPLE = dict(layout_id='two_way', device='2way_12x75', precision_mode='purity', targets={'left': 'cd4_pos', 'right': 'cd4_neg'}, |
| target_events={'left': 10000, 'right': 10000}) |
| LEDGER_KEYS = ['electrical_energy_j', 'sheath_used_m3', 'waste_added_m3', 'sample_used_m3', 'cleaning_fluid_used_m3', 'particles_drawn', 'particles_detected', |
| 'events_processed', 'electronic_aborts', 'coincident_particles', 'drops_formed', 'drops_deflected', 'particles_sorted', 'particles_to_waste', |
| 'particles_lost_off_target', 'particles_in_collection', 'particles_spilled_from_collection', 'particles_leaked_into_collection', |
| 'collection_added_m3', 'collection_spilled_m3', 'aerosol_particles_escaped', 'laser_on_time_s'] |
| LEDGER = obj({k: number('J' if k.endswith('_j') else 'm3' if k.endswith('_m3') else 's' if k.endswith('_s') else '1') for k in LEDGER_KEYS}) |
| POP_TRUTH = obj(dict(population_id=TEXT, particle_id=TEXT, particles=number('1'), concentration_per_m3=number('1/m3'))) |
|
|
| cap('plant.configure', PLANT, obj(dict(plant=obj(dict(room_k=number('K'), mains_voltage_v=number('V'), noise_seed=INT, room_drift_k_per_s=number('K/s'))))), |
| PLANT_EXAMPLE, ['fluidics_body', 'cart_body'], '宿主声明实验室条件：室温（厂家运行范围17.5–27.5 °C）、供电电压、室温漂移与噪声种子（只在首次声明时生效）；液流车鞘液罐满、废液罐空', |
| 'evaluator', 'simulation') |
| cap('power.set', obj(dict(enabled=BOOL)), obj(dict(enabled=BOOL)), dict(enabled=True), ['power_button', 'power_panel'], '开机/关机（主电源；液流车由主机供电）') |
| cap('power.press_switch', obj({}), obj(dict(enabled=BOOL)), {}, ['power_button'], '按一下左侧电源面板的主电源按钮（切换开/关）') |
| cap('lasers.set', obj(dict(laser=enum(LASERS), enabled=BOOL)), obj(dict(laser=TEXT, enabled=BOOL, warm=BOOL)), dict(laser='blue', enabled=True), ['optics_body'], |
| '开/关某台激光器（405/488/561/633 nm）；开机后需预热30 min（厂家）') |
| cap('door.set', obj(dict(door=enum(DOORS), angle_rad=number('rad', 0.0, 100 * math.pi / 180))), obj(dict(door=TEXT, angle_rad=number('rad'))), |
| dict(door='sort_chamber', angle_rad=1.6), ['optics_door', 'flow_cell_door', 'side_door', 'sort_chamber_door'], |
| '用手开/关光学门、比色池检修门（打开时快门挡住激光）、侧门或分选收集室门（角度0为关闭）', 'agent', 'robot_skill') |
| cap('nozzle.install', obj(dict(nozzle=enum(NOZZLES))), obj(dict(nozzle=TEXT)), dict(nozzle='70'), ['flow_cell_door', 'fluidics_body'], |
| '更换喷嘴（70/85/100/130 µm，或关机用的闭环喷嘴）：须液流关闭、比色池检修门打开', 'agent', 'robot_skill') |
| cap('fluidics.startup', obj({}), OPERATION, {}, ['cart_body', 'sheath_tank', 'waste_tank'], |
| 'Fluidics Startup：检查鞘液与废液液位，用鞘液替换管路与压力缓冲罐中的去离子水（约8 min，异步）') |
| cap('fluidics.shutdown', obj({}), OPERATION, {}, ['cart_body', 'cleaning_reservoirs'], |
| 'Fluidics Shutdown：用去离子水替换鞘液并清洗比色池（约3 min，异步；须装闭环喷嘴、液流关闭）') |
| cap('cleaning.run', obj(dict(mode=enum(list(CLEAN_S)))), OPERATION, dict(mode='clean_flow_cell'), ['cart_body', 'cleaning_reservoirs'], |
| '清洗模式：Clean Flow Cell或Prepare for Aseptic Sort（异步）') |
| cap('sort_setup.select', obj(dict(preset=enum(PRESETS))), obj(dict(preset=TEXT, sheath_pressure_pa=number('Pa'), frequency_hz=number('Hz'), amplitude_v=number('V'), |
| drop_delay_drops=number('1'), plate_voltage_v=number('V'))), |
| dict(preset='70_high'), ['fluidics_body'], '选择Sort Setup（70 µm High 70 psi / Medium 35 psi、85、100 µm Low、130 µm，或表3-1的Custom：70 µm 20 psi非分选高灵敏度模式，' |
| '偏转板0 V）：载入鞘液压力、液滴驱动频率与振幅、衰减、液滴延迟、偏转板电压、侧流电荷、激光延迟、面积系数与窗口延长的默认值（须液流关闭、Sweet Spot关闭）') |
| cap('stream.set', obj(dict(on=BOOL)), obj(dict(on=BOOL)), dict(on=True), ['fluidics_body', 'stream_window'], 'Breakoff窗口的Stream按钮：开/关液流（须Fluidics Startup完成、装好分选喷嘴、急停未按下）') |
| cap('breakoff.set', obj(dict(amplitude_v=number('V', 1.0, 80.0), frequency_hz=number('Hz', 1.0, 100000.0), drop1_target_px=number('1', 100.0, 600.0), |
| gap_target_px=number('1', 1.0, 30.0), attenuation=BOOL), optional=('amplitude_v', 'frequency_hz', 'drop1_target_px', 'gap_target_px', 'attenuation')), |
| obj(dict(amplitude_v=number('V'), frequency_hz=number('Hz'), drop1_target_px=number('1'), gap_target_px=number('1'), attenuation=BOOL)), |
| dict(drop1_target_px=330.0), ['fluidics_body'], '设定液滴驱动振幅、频率（Sweet Spot开启时不可改）、Drop 1与Gap目标、衰减（低于30 psi时建议打开）') |
| cap('sweet_spot.set', obj(dict(enabled=BOOL)), obj(dict(enabled=BOOL)), dict(enabled=True), ['fluidics_body'], |
| 'Sweet Spot：自动调振幅保持Drop 1与Gap；Gap偏差>2 px时暂停分选；检测到堵塞时关液流与偏转板、关抽吸抽屉、卸下样品管') |
| cap('sheath.set_pressure', obj(dict(pressure_pa=number('Pa', 5 * PSI, 75 * PSI))), obj(dict(pressure_pa=number('Pa'))), dict(pressure_pa=70 * PSI), ['fluidics_body'], |
| '自定义鞘液压力5–75 psi（Sweet Spot开启时不可用；厂家建议用Sort Setup改压力）') |
| cap('deflection.set', obj(dict(voltage_on=BOOL, plate_voltage_v=number('V', 0.0, 6000.0), side_stream_fraction=STREAMMAP(number('1', 0.0, 1.0)), |
| voltage_center_fraction=number('1', -1.0, 1.0), test_sort=BOOL, optical_filter_in=BOOL), |
| optional=('voltage_on', 'plate_voltage_v', 'side_stream_fraction', 'voltage_center_fraction', 'test_sort', 'optical_filter_in')), |
| obj(dict(voltage_on=BOOL, plate_voltage_v=number('V'), side_stream_fraction=obj({s: number('1') for s in STREAMS}), voltage_center_fraction=number('1'), |
| test_sort=BOOL, optical_filter_in=BOOL)), dict(voltage_on=True), ['deflection_plates', 'deflection_lamp', 'sort_block'], |
| 'Side Stream窗口：偏转板电压开关与大小（0–6000 V）、四个侧流的充电比例（0–1，FACSDiva显示的百分比/100）、电压中心（−1–1）、测试分选、Accudrop光学滤片') |
| cap('drop_delay.set', obj(dict(drops=number('1', 10.0, 140.0))), obj(dict(drops=number('1'))), dict(drops=44.0), ['sort_block'], '设定液滴延迟（10–140滴）') |
| cap('drawer.set', obj(dict(open=BOOL)), obj(dict(open=BOOL)), dict(open=True), ['aspirator_drawer'], 'Sort Layout里的抽吸抽屉按钮：打开/关闭（默认关闭盖住收集管）') |
| cap('amo.set', obj(dict(enabled=BOOL, mode=enum(['normal', 'rapid'])), optional=('mode',)), obj(dict(enabled=BOOL, mode=TEXT, chamber_exchange_rate_per_s=number('1/s'))), |
| dict(enabled=True, mode='normal'), ['sort_chamber', 'sort_chamber_door'], |
| '气溶胶管理选件：抽吸分选收集室（厂家：正常16、快速69个腔体积/min，即0.267/1.15 s⁻¹；须关好分选收集室门）') |
| cap('sample.agitation', obj(dict(speed=enum(list(AGITATION)))), obj(dict(speed=TEXT, rate_hz=number('1/s'))), dict(speed='300_rpm'), ['sample_chamber'], |
| '进样搅拌：选软件档位Off/100/200/300 rpm（转速以1/s发布：300 rpm = 5 s⁻¹）；搅拌只减缓沉降（设施指南：300 rpm也不太有效，易沉降的样品需定期暂停混匀）') |
| cap('sample.temperature', obj(dict(setpoint_k=nullable(dict(type='number', enum=list(SAMPLE_SETPOINTS_K), **{'x-unit': 'K'})))), |
| obj(dict(setpoint_k=nullable(number('K')))), dict(setpoint_k=277.15), ['sample_chamber'], |
| '进样室温控：设定点只能是软件提供的277.15、293.15、310.15、315.15 K（4、20、37、42 °C），null为关（约45 min到温，须关闭进样室）') |
| cap('collection.temperature', obj(dict(setpoint_k=nullable(number('K', *COLLECTION_RANGE_K)))), obj(dict(setpoint_k=nullable(number('K')))), dict(setpoint_k=277.15), |
| ['collection_holder'], '分选收集冷却/加热（循环水选件）设定或关') |
| cap('sample.chamber_light', obj({}), obj(dict(on=BOOL)), {}, ['chamber_light_button', 'chamber_light'], '按进样室照明按钮（开/关照明，看样品管余量）') |
| cap('tube.prepare', obj(dict(tube_id=SID, tube_type=enum(TUBE_TYPES), sources=array(SOURCE, 1, 6), buffer_volume_m3=number('m3', 0.0, 1.5e-5)), |
| optional=('buffer_volume_m3',)), |
| obj(dict(tube_id=TEXT, volume_m3=number('m3'), particles=number('1'))), TUBE_EXAMPLE, ['sample_chamber'], |
| '在实验台上配样品管：从样品取一份、或加库中的微球（可染单一荧光做补偿对照），加缓冲液稀释', 'agent', 'robot_skill') |
| cap('tube.mix', obj(dict(tube_id=SID)), obj(dict(tube_id=TEXT)), dict(tube_id='t1'), ['sample_chamber'], |
| '在实验台上轻弹/涡旋混匀样品管，使沉降的颗粒重新悬浮（管须在实验台上；设施指南：易沉降的样品定期暂停、卸管混匀）', 'agent', 'robot_skill') |
| cap('tube.install', obj(dict(tube_id=SID)), obj(dict(tube_id=TEXT)), dict(tube_id='t1'), ['loading_port'], '把样品管放到下降的进样口管座上', 'agent', 'robot_skill') |
| cap('tube.remove', obj({}), obj(dict(tube_id=TEXT)), {}, ['loading_port'], '从下降的进样口取下样品管放回实验台', 'agent', 'robot_skill') |
| cap('sample.load', obj({}), obj(dict(tube_id=TEXT)), {}, ['loading_port', 'sample_chamber', 'estop_light'], |
| 'Load：进样口升起把管封入进样室（约3 s，急停灯亮），加压、开始搅拌与采集（须液流开启）') |
| cap('sample.unload', obj({}), obj(dict(tube_id=TEXT)), {}, ['loading_port', 'sample_chamber'], |
| 'Unload：停止采集与搅拌，降下进样口；进行中的分选与记录随之结束（failed，SAMPLE_UNLOADED；厂家：换管后重新开始分选时计数归零）') |
| cap('acquisition.set', obj(dict(acquiring=BOOL)), obj(dict(acquiring=BOOL)), dict(acquiring=False), ['sample_chamber'], |
| 'Acquire按钮：已装载时暂停/继续进样（暂停时进样室保持关闭）') |
| cap('acquisition.flow_rate', obj(dict(setting=number('1', 1.0, 11.0))), obj(dict(setting=number('1'), sample_flow_m3_s=number('m3/s'))), dict(setting=1.0), |
| ['sample_chamber'], '样品流速档1.0–11.0（约10–120 µl/min）') |
| cap('cytometer.settings', obj(dict(voltages=DETMAP(number('V', 0.0, 1000.0)), thresholds=array(obj(dict(parameter=enum(DETS), value=number('1', 0.0, ADC_MAX))), 1, 4), |
| threshold_logic=enum(['or', 'and']), laser_delays_s=LASERMAP(number('s', -2.0e-4, 2.0e-4)), area_scaling=LASERMAP(number('1', 0.1, 5.0)), |
| window_extension_s=number('s', 0.0, 1.0e-5), detectors_enabled=array(enum(DETS), 2, len(DETS))), |
| optional=('voltages', 'thresholds', 'threshold_logic', 'laser_delays_s', 'area_scaling', 'window_extension_s', 'detectors_enabled')), |
| obj(dict(max_event_rate_eps=number('1/s'))), dict(voltages={'B530_30': 520.0}), ['optics_body'], |
| '仪器设置：各检测器电压（PMT/FSC 0–1000 V）、阈值参数与数值（可多参数OR/AND）、激光延迟、面积系数、窗口延长、启用的检测器') |
| cap('compensation.set', obj(dict(enabled=BOOL, spillover=nullable(DETMAP(DETMAP(number('1', 0.0, 10.0))))), optional=('spillover',)), |
| obj(dict(enabled=BOOL, pairs=INT)), dict(enabled=True), ['optics_body'], '补偿：开关；给溢出矩阵（荧光检测器→各检测器的溢出比例，对角为1）') |
| cap('compensation.calculate', obj(dict(unstained_record=SID, controls=dict(type='object', propertyNames=enum(FL_DETS), additionalProperties=SID, minProperties=1, |
| maxProperties=len(FL_DETS)))), |
| obj(dict(spillover=dict(type='object', additionalProperties=dict(type='object', additionalProperties=number('1'))), pairs=INT)), |
| dict(unstained_record='unstained', controls={'B530_30': 'fitc_ctrl'}), ['optics_body'], '由未染色与单染对照记录计算溢出矩阵（阳性群与阴性群中位数差之比）并启用补偿') |
| cap('gate.define', GATE, obj(dict(gate_id=TEXT)), dict(gate_id='cells', kind='rectangle', x='FSC-A', y='SSC-A', x_range=[20000.0, 200000.0], y_range=[0.0, 100000.0]), |
| ['optics_body'], '定义门：矩形、多边形或一维区间，可指定父门（层级）', 'agent', 'device_command') |
| cap('gate.delete', obj(dict(gate_id=SID)), obj(dict(gate_id=TEXT)), dict(gate_id='cells'), ['optics_body'], '删除门（有子门或被分选布局引用时不能删）') |
| cap('acquisition.record', obj(dict(record_id=SID, events=integer(1, MAX_RECORD_EVENTS), storage_gate=nullable(SID), stopping_gate=nullable(SID), |
| max_time_s=nullable(number('s', 1.0, 86400.0))), optional=('storage_gate', 'stopping_gate', 'max_time_s')), |
| OPERATION, dict(record_id='unstained', events=10000), ['optics_body'], '记录数据：保存经处理的事件直到达到事件数（可设停止门、存储门、时间上限）；异步') |
| cap('collection.install', obj(dict(device=enum(DEVICES), prefill_m3=number('m3', 0.0, 1.0e-5)), optional=('prefill_m3',)), obj(dict(device=TEXT, locations=array(TEXT, 1, 384))), |
| dict(device='2way_12x75', prefill_m3=5.0e-7), ['collection_holder', 'sort_chamber'], |
| '在分选收集室装收集装置（2/4路管架，或ACDU的6/24/48/96/384孔板；可预加收集液）；须打开分选收集室门', |
| 'agent', 'robot_skill') |
| cap('collection.remove', obj({}), obj(dict(samples=array(TEXT, 0, 384))), {}, ['collection_holder'], |
| '取出收集装置：管架里每管的分选产物成为新样品（可再配管上机检查纯度）；须打开分选收集室门、不在分选', 'agent', 'robot_skill') |
| cap('sort.layout', LAYOUT, obj(dict(layout_id=TEXT, masks=MASKS)), LAYOUT_EXAMPLE, ['sort_block'], |
| 'Sort Layout：收集装置、精度模式（Purity、4-Way Purity、Yield、Single Cell、Initial、Fine Tune或自定义掩码）、每个位置的分选门与目标事件数（板：每孔事件数）') |
| cap('sort.start', obj(dict(layout_id=SID)), OPERATION, dict(layout_id='two_way'), ['sort_block', 'deflection_plates', 'aspirator_drawer'], |
| '开始分选（须采集中、偏转板开、收集装置与布局一致；抽屉自动打开）；异步，到目标数后完成；卸下样品管即结束（换管后重新开始，计数从0起）') |
| cap('sort.pause', obj({}), obj(dict(state=TEXT)), {}, ['sort_block'], '暂停分选（计数停止）') |
| cap('sort.resume', obj({}), obj(dict(state=TEXT)), {}, ['sort_block'], '继续分选') |
| cap('sort.auto_drop_delay', obj({}), OPERATION, {}, ['sort_block', 'deflection_plates'], |
| 'Accudrop自动液滴延迟：用Accudrop微球先按Initial模式粗扫7点、再按Fine Tune细扫13点（每点5 s，共约100 s，异步），按下摄像头看到的左侧流比例取最优延迟') |
| cap('cst.performance_check', obj({}), OPERATION, {}, ['optics_body'], 'CS&T性能检查：用CS&T微球测各检测器rCV，并设定激光延迟与面积系数（异步，约5 min）') |
| cap('safety.emergency_stop', obj({}), obj(dict(latched=BOOL)), {}, ['emergency_stop'], '按急停按钮：卸下样品管、停ACDU、关液流与偏转板电压、关抽吸抽屉（不关激光与主电源），按钮锁住') |
| cap('safety.reset_emergency_stop', obj({}), obj(dict(latched=BOOL)), {}, ['emergency_stop'], '顺时针旋转复位急停按钮') |
| cap('warnings.dismiss', obj({}), obj(dict(dismissed=array(TEXT, 0, 8))), {}, ['optics_body'], '确认液位警告（鞘液低/废液满；15 min未确认会自动关液流）') |
| cap('cart.refill_sheath', obj(dict(volume_m3=number('m3', 0.0, 0.010))), obj(dict(sheath_m3=number('m3'))), dict(volume_m3=0.009), ['sheath_tank'], |
| '给10 L鞘液罐加鞘液（须液流关闭、罐已泄压）', 'agent', 'robot_skill') |
| cap('cart.empty_waste', obj(dict(bleach_m3=number('m3', 0.0, 0.002)), optional=('bleach_m3',)), obj(dict(waste_m3=number('m3'))), dict(bleach_m3=0.001), ['waste_tank'], |
| '倒空10 L废液罐并加入约1 L漂白剂（须液流关闭）', 'agent', 'robot_skill') |
| cap('cart.refill_cleaning', obj({}), obj(dict(cleaning_m3=obj({k: number('m3') for k in ('facsclean', 'facsrinse', 'di_water', 'ethanol')}))), {}, ['cleaning_reservoirs'], |
| '把5 L清洗液瓶（FACSClean、FACSRinse、去离子水、乙醇）加满', 'agent', 'robot_skill') |
| COMP_CHOICE = enum(['recorded', 'current']) |
| cap('statistics.read', obj(dict(source=SID, gates=nullable(array(SID, 1, MAX_GATES)), parameters=nullable(array(PARAM_E, 1, 12)), compensation=COMP_CHOICE), |
| optional=('gates', 'parameters', 'compensation')), |
| obj(dict(source=TEXT, total_events=INT, compensated=BOOL, rows=array(STAT_ROW, 0, MAX_GATES + 1))), dict(source='live', parameters=['FSC-A']), ['optics_body'], |
| '统计：live（最近2万个事件，按当前补偿）或某个记录（默认按记录时保存的补偿矩阵；compensation=current时套用当前补偿）；各门事件数、占父门与总数百分比、' |
| '参数均值/中位数/CV/rCV', 'agent', 'query') |
| cap('record.read', obj(dict(record_id=SID, parameters=array(PARAM_E, 1, 12), max_events=integer(1, 5000), compensation=COMP_CHOICE), optional=('compensation',)), |
| obj(dict(record_id=TEXT, parameters=array(TEXT, 1, 12), events=array(array(number('1'), 1, 12), 0, 5000), total_events=INT, compensated=BOOL)), |
| dict(record_id='unstained', parameters=['FSC-A', 'SSC-A'], max_events=500), ['optics_body'], |
| '读记录中的事件（均匀抽样；荧光参数默认按记录时保存的补偿，compensation=current时套用当前补偿）', 'agent', 'query') |
| cap('records.list', obj({}), obj(dict(records=array(obj(dict(record_id=TEXT, events=INT, tube_id=nullable(TEXT), started_s=number('s'), finished_s=nullable(number('s')), |
| compensated=BOOL)), 0, MAX_RECORDS))), {}, ['optics_body'], '列出记录', 'agent', 'query') |
| cap('sort.side_streams', obj({}), obj(dict(streams=array(obj(dict(stream=TEXT, x_m=nullable(number('m')), spread_m=nullable(number('m')), |
| target=nullable(TEXT), offset_from_target_m=nullable(number('m')))), 0, 5), |
| centre_in_aspirator=BOOL)), {}, ['sort_block'], |
| '看Side Stream窗口：测试分选或分选时各侧流落点、展宽与相对收集管中心的偏差（侧流没形成时为空）', 'agent', 'query') |
| cap('data.export', obj(dict(record_id=SID, kind=enum(['fcs_csv']), compensation=COMP_CHOICE), optional=('compensation',)), |
| obj(dict(file=TEXT, bytes=INT, rows=INT, compensated=BOOL)), dict(record_id='unstained', kind='fcs_csv'), ['optics_body'], |
| '把记录导出为FCS参数表（CSV文本；默认按记录时的补偿；写文件并记事件，不改状态槽）', 'agent', 'device_command') |
| cap('events.read', obj(dict(since_s=number('s', 0.0))), obj(dict(events=array(EVENT, 0, MAX_EVENTS_LOG), dropped=INT)), dict(since_s=0.0), ['optics_body'], '读事件日志', |
| 'agent', 'query') |
| cap('provenance.read', obj({}), obj(dict(libraries=array(obj(dict(name=TEXT, file=TEXT, entries=INT)), 0, 8), |
| detectors=array(obj(dict(detector=TEXT, laser=TEXT, bandpass_m=array(number('m'), 2, 2), intended=TEXT)), 0, 16))), |
| {}, ['optics_body'], '读模板库与检测器配置的来源', 'agent', 'query') |
| cap('sample.provide', obj(dict(sample_id=SID, volume_m3=number('m3', 1.0e-9, 5.0e-5), populations=array(POP, 1, 16))), obj(dict(sample_id=TEXT, particles=number('1'))), |
| SAMPLE_EXAMPLE, ['sample_chamber'], '评测者提供一份细胞/颗粒悬液：各群体的颗粒库类型、浓度、可选粒径、死细胞比例、团聚（双联体）比例与染色（每颗粒荧光分子数、CV、只染活/死细胞）', |
| 'evaluator', 'simulation') |
| cap('tube.inspect', obj(dict(tube_id=SID)), obj(dict(tube_id=TEXT, volume_m3=number('m3'), temperature_k=number('K'), populations=array(POP_TRUTH, 0, 64), |
| settled_depth_m=dict(type='object', additionalProperties=number('m')), liquid_height_m=number('m'))), |
| dict(tube_id='t1'), ['sample_chamber'], '评测者读样品管真值：体积、温度、各群体剩余颗粒数与浓度、各群体沉降前锋深度与液面高度（前锋过了取样针就取不到）', 'evaluator', 'query') |
| cap('collection.inspect', obj({}), obj(dict(device=nullable(TEXT), locations=array(obj(dict(location=TEXT, volume_m3=number('m3'), temperature_k=number('K'), |
| populations=array(POP_TRUTH, 0, 64))), 0, 384))), |
| {}, ['collection_holder'], '评测者读收集装置真值：每个位置的液体体积、温度、各群体颗粒数（纯度与得率的真值）', 'evaluator', 'query') |
| cap('ledger.read', obj({}), obj(dict(ledger=LEDGER)), {}, ['fluidics_body'], '读守恒账目（电能、鞘液/废液/样品/清洗液、颗粒去向、液滴、气溶胶、激光开机时间）', 'evaluator', 'query') |
| cap('fault.inject', obj(dict(fault=enum(FAULTS), active=BOOL)), obj(dict(faults=array(TEXT, 0, 16))), dict(fault='clog_full', active=True), ['fluidics_body'], |
| '评测者故障注入：断电、喷嘴全堵/部分堵、比色池气泡、某台激光失效、断点漂移、液流车漏气', 'evaluator', 'simulation') |
| cap('sim.step', obj(dict(dt_s=number('s', 0.0, 7 * 86400.0))), obj(dict(time_s=number('s'))), dict(dt_s=60.0), ['fluidics_body'], '推进宿主时钟（0.1 s物理网格）', 'evaluator', |
| 'simulation') |
| UNSUPPORTED = { |
| 'laser.uv_355nm': '355 nm紫外激光器不在所选配置内', |
| 'sort.index_sort': '索引分选（每孔记录单细胞参数）未建模', |
| 'acdu.slide_sort': 'ACDU玻片分选与自定义收集装置未建模', |
| 'optics.change_filters': '更换滤光片与二向色镜（用户可换）未建模，配置固定', |
| 'facsdiva.user_accounts': 'BD FACSDiva用户账户、实验模板与工作站文件系统未建模', |
| 'cytometer.sheath_pressure_custom_device': '自定义Sort Setup设备文件未建模（自定义压力用sheath.set_pressure）', |
| } |
| for k, v in UNSUPPORTED.items(): |
| cap(k, obj({}), obj({}), {}, ['optics_body'], v) |
|
|
| |
| SLOTS = {} |
|
|
|
|
| def slot(k, schema, unit, origin, component, meaning, visibility='agent', reference=None): |
| SLOTS[k] = dict(schema=schema, unit=unit, origin=origin, component=component, meaning=meaning, visibility=visibility, reference=reference) |
|
|
|
|
| _PN = lambda u: nullable(number(u)) |
| _LB = obj({L: BOOL for L in LASERS}) |
| _LN = obj({L: number('W') for L in LASERS}) |
| slot('clock.time_s', number('s'), 's', 'derived', 'fluidics_body', '仿真时钟（0.1 s物理网格）') |
| slot('plant.configured', BOOL, '1', 'setpoint', 'fluidics_body', '已声明实验室条件') |
| slot('power.enabled', BOOL, '1', 'derived', 'power_button', '整机通电（主电源开且市电正常）') |
| slot('lasers.on', _LB, '1', 'setpoint', 'optics_body', '各激光器开关') |
| slot('lasers.warm', _LB, '1', 'derived', 'optics_body', '各激光器已预热30 min（厂家）') |
| slot('lasers.power_w', _LN, 'W', 'sensor', 'optics_body', '各激光器输出功率读数（预热中偏低；失效为0）') |
| slot('lasers.shutter_closed', BOOL, '1', 'derived', 'flow_cell_door', '比色池检修门打开时快门挡住激光') |
| for d in DOORS: |
| slot(f'door.{d}_angle_rad', number('rad'), 'rad', 'setpoint', f'{d}_door', f'{d}门开角（0关闭；场景门关节镜像）', reference='关闭位置') |
| slot('nozzle.installed', nullable(enum(NOZZLES)), '1', 'setpoint', 'fluidics_body', '装着的喷嘴（closed_loop为关机用闭环喷嘴）') |
| slot('fluidics.state', enum(['shutdown', 'starting', 'ready', 'shutting_down', 'cleaning']), '1', 'derived', 'cart_body', '液流系统状态') |
| slot('sort_setup.preset', enum(PRESETS + ['custom']), '1', 'setpoint', 'fluidics_body', '当前Sort Setup（改了鞘液压力为custom）') |
| slot('sheath.pressure_setpoint_pa', number('Pa'), 'Pa', 'setpoint', 'fluidics_body', '鞘液压力设定') |
| slot('sheath.pressure_pa', number('Pa'), 'Pa', 'sensor', 'fluidics_body', '鞘液压力读数（液流关闭时为0）') |
| slot('stream.on', BOOL, '1', 'setpoint', 'fluidics_body', '液流开关') |
| slot('breakoff.amplitude_v', number('V'), 'V', 'setpoint', 'fluidics_body', '液滴驱动振幅（Sweet Spot开启时自动调节）') |
| slot('breakoff.frequency_hz', number('Hz'), 'Hz', 'setpoint', 'fluidics_body', '液滴驱动频率') |
| slot('breakoff.attenuation', BOOL, '1', 'setpoint', 'fluidics_body', '液滴驱动衰减') |
| slot('breakoff.drop1_target_px', number('1'), '1', 'setpoint', 'fluidics_body', 'Drop 1目标（像素）') |
| slot('breakoff.gap_target_px', number('1'), '1', 'setpoint', 'fluidics_body', 'Gap目标（像素，默认6）') |
| slot('breakoff.drop1_px', _PN('1'), '1', 'sensor', 'fluidics_body', '上摄像头测得的Drop 1（图像顶部到第一个断开液滴重心的像素；液流关闭或不成滴时为空）') |
| slot('breakoff.gap_px', _PN('1'), '1', 'sensor', 'fluidics_body', '上摄像头测得的Gap（液柱断点到第一个液滴的像素）') |
| slot('breakoff.drop_spacing_px', _PN('1'), '1', 'sensor', 'fluidics_body', '图像中的液滴间距（像素；Drop 1按此跳变）') |
| slot('sweet_spot.on', BOOL, '1', 'setpoint', 'fluidics_body', 'Sweet Spot开关') |
| slot('sweet_spot.paused', BOOL, '1', 'derived', 'fluidics_body', '断点超出范围（Gap偏差>2 px或Drop 1偏差>10 px），分选暂停（不给液滴充电）') |
| slot('deflection.voltage_on', BOOL, '1', 'setpoint', 'deflection_plates', '偏转板电压开关') |
| slot('deflection.plate_voltage_v', number('V'), 'V', 'setpoint', 'deflection_plates', '偏转板电压（0–6000 V）') |
| slot('deflection.side_stream_fraction', obj({s: number('1') for s in STREAMS}), '1', 'setpoint', 'deflection_plates', '四个侧流的充电比例（0–1，FACSDiva显示的百分比/100）') |
| slot('deflection.voltage_center_fraction', number('1'), '1', 'setpoint', 'deflection_plates', '电压中心（−1–1，整体左右移动侧流）') |
| slot('deflection.test_sort', BOOL, '1', 'setpoint', 'deflection_plates', '测试分选（产生测试侧流）') |
| slot('deflection.optical_filter_in', BOOL, '1', 'setpoint', 'sort_block', 'Accudrop光学滤片在下摄像头前') |
| slot('drop_delay.drops', number('1'), '1', 'setpoint', 'sort_block', '液滴延迟设定（滴）') |
| slot('sort.drawer_position_m', number('m'), 'm', 'derived', 'aspirator_drawer', '抽吸抽屉位置（0关闭盖住收集管，0.08 m打开；场景抽屉关节镜像）', reference='关闭位置') |
| slot('sort.drawer_open', BOOL, '1', 'setpoint', 'aspirator_drawer', '抽屉打开指令') |
| slot('amo.on', BOOL, '1', 'setpoint', 'sort_chamber', '气溶胶管理选件开关') |
| slot('amo.mode', enum(['normal', 'rapid']), '1', 'setpoint', 'sort_chamber', 'AMO抽吸模式') |
| slot('sample.agitation_rate_hz', number('1/s'), '1/s', 'setpoint', 'sample_chamber', '进样搅拌转速（1/s；0为关，300 rpm为5 s⁻¹）') |
| slot('sample.temperature_setpoint_k', _PN('K'), 'K', 'setpoint', 'sample_chamber', '进样室温控设定（空为关）') |
| slot('sample.chamber_temperature_k', number('K'), 'K', 'sensor', 'sample_chamber', '进样室温度读数') |
| slot('sample.chamber_light', BOOL, '1', 'setpoint', 'chamber_light', '进样室照明') |
| slot('sample.port_position_m', number('m'), 'm', 'derived', 'loading_port', '进样口升起高度（0下降，0.065 m封入进样室；场景进样口关节镜像）', reference='下降位置') |
| slot('sample.port_state', enum(['down', 'loading', 'up', 'unloading']), '1', 'derived', 'loading_port', '进样口状态') |
| slot('sample.tube_id', nullable(TEXT), '1', 'derived', 'loading_port', '进样口上的样品管') |
| slot('sample.flow_rate_setting', number('1'), '1', 'setpoint', 'sample_chamber', '流速档（1–11）') |
| slot('sample.acquiring', BOOL, '1', 'derived', 'sample_chamber', '正在进样采集（管已封入、加压、采集未暂停）') |
| slot('collection.device', nullable(enum(DEVICES)), '1', 'derived', 'collection_holder', '装着的收集装置') |
| slot('collection.temperature_setpoint_k', _PN('K'), 'K', 'setpoint', 'collection_holder', '收集冷却设定（空为关）') |
| slot('collection.temperature_k', number('K'), 'K', 'sensor', 'collection_holder', '收集管温度读数（循环水）') |
| slot('tubes.on_bench', array(TEXT, 0, MAX_TUBES), '1', 'derived', 'sample_chamber', '实验台上的样品管') |
| slot('samples.available', array(TEXT, 0, MAX_SAMPLES), '1', 'derived', 'sample_chamber', '可取用的样品（评测者提供的样品与取出的分选产物）') |
| slot('acquisition.threshold_rate_eps', number('1/s'), '1/s', 'sensor', 'optics_body', '过阈值事件率（最近1 s）') |
| slot('acquisition.processed_rate_eps', number('1/s'), '1/s', 'sensor', 'optics_body', '处理的事件率（最近1 s）') |
| slot('acquisition.abort_rate_eps', number('1/s'), '1/s', 'sensor', 'optics_body', '电子中止率（超过处理能力被丢弃，最近1 s）') |
| slot('acquisition.events_processed', INT, '1', 'derived', 'optics_body', '本次装载以来处理的事件数') |
| slot('cytometer.voltages', obj({d: number('V') for d in DETS}), 'V', 'setpoint', 'optics_body', '各检测器电压') |
| slot('cytometer.thresholds', array(obj(dict(parameter=TEXT, value=number('1'))), 1, 4), '1', 'setpoint', 'optics_body', '阈值（参数与高度通道值）') |
| slot('cytometer.threshold_logic', enum(['or', 'and']), '1', 'setpoint', 'optics_body', '多阈值逻辑') |
| slot('cytometer.laser_delays_s', obj({L: number('s') for L in LASERS}), 's', 'setpoint', 'optics_body', '各激光相对488 nm的延迟设定') |
| slot('cytometer.area_scaling', obj({L: number('1') for L in LASERS}), '1', 'setpoint', 'optics_body', '各激光的面积系数设定') |
| slot('cytometer.window_extension_s', number('s'), 's', 'setpoint', 'optics_body', '窗口延长') |
| slot('cytometer.detectors_enabled', array(enum(DETS), 2, len(DETS)), '1', 'setpoint', 'optics_body', '启用的检测器（每个给A/H/W）') |
| slot('cytometer.max_event_rate_eps', number('1/s'), '1/s', 'derived', 'optics_body', |
| '处理能力：min(70,000/s, 70,000/s×14/(启用检测器数+补偿对数/2))（厂家：最高70,000/s，8参数12对补偿；参数更多时的下降为假设）') |
| slot('compensation.enabled', BOOL, '1', 'setpoint', 'optics_body', '补偿开关') |
| slot('compensation.pairs', INT, '1', 'derived', 'optics_body', '补偿矩阵非零非对角项数') |
| slot('gates.defined', array(TEXT, 0, MAX_GATES), '1', 'derived', 'optics_body', '已定义的门') |
| slot('records.count', INT, '1', 'derived', 'optics_body', '记录数') |
| slot('sort.layouts', array(TEXT, 0, MAX_LAYOUTS), '1', 'derived', 'sort_block', '分选布局') |
| slot('sort.state', enum(['idle', 'sorting', 'paused', 'completed', 'stopped', 'error']), '1', 'derived', 'sort_block', '分选状态') |
| slot('sort.layout_id', nullable(TEXT), '1', 'derived', 'sort_block', '当前/最近一次分选布局') |
| slot('sort.counts', dict(type='object', additionalProperties=INT), '1', 'derived', 'sort_block', '各位置已分选事件计数（分选决定数）') |
| slot('sort.conflicts', INT, '1', 'derived', 'sort_block', '冲突（掩码或位置冲突而放弃的目标事件）计数') |
| slot('sort.efficiency', _PN('1'), '1', 'derived', 'sort_block', '分选效率（已分选/（已分选+冲突））') |
| slot('sort.sort_rate_eps', number('1/s'), '1/s', 'derived', 'sort_block', '分选率（最近1 s）') |
| slot('sort.elapsed_s', number('s'), 's', 'derived', 'sort_block', '分选已用时间') |
| slot('sort.well', nullable(TEXT), '1', 'derived', 'collection_holder', '板分选当前孔') |
| slot('accudrop.left_stream_fraction', _PN('1'), '1', 'sensor', 'sort_block', '下摄像头（滤片在位）看到的Accudrop微球进入左侧流的比例（最近1 s；不在测量条件时为空）') |
| slot('cst.status', enum(['not_run', 'passed', 'failed']), '1', 'derived', 'optics_body', 'CS&T性能检查结果') |
| slot('cart.sheath_level_fraction', number('1'), '1', 'sensor', 'sheath_tank', '鞘液液位指示（0–1）') |
| slot('cart.waste_level_fraction', number('1'), '1', 'sensor', 'waste_tank', '废液液位指示（0–1）') |
| slot('cart.cleaning_ok', BOOL, '1', 'sensor', 'cleaning_reservoirs', '清洗液瓶指示（都高于20 %）') |
| slot('cart.air_pressure_pa', number('Pa'), 'Pa', 'sensor', 'gauge', '液流车气压表读数') |
| slot('cart.gauge_angle_rad', number('rad'), 'rad', 'derived', 'gauge_needle', '气压表指针转角（0–160 psi对应0–270°；场景指针关节镜像）', reference='0 psi') |
| slot('safety.estop_latched', BOOL, '1', 'derived', 'emergency_stop', '急停按钮按下锁住') |
| slot('safety.estop_position_m', number('m'), 'm', 'derived', 'emergency_stop', '急停按钮按入深度（0或0.006 m；场景按钮关节镜像）', reference='弹出位置') |
| slot('lamp.deflection_plates', BOOL, '1', 'derived', 'deflection_lamp', '偏转板高压警示灯（电压开时亮）') |
| slot('lamp.chamber_light', BOOL, '1', 'derived', 'chamber_light', '进样室照明灯') |
| slot('lamp.estop_light', BOOL, '1', 'derived', 'estop_light', '急停按钮灯（通电时：样品管装载/卸载移动中亮；急停按下锁住时亮，顺时针复位后熄灭，厂家）') |
| slot('operations.running', array(TEXT, 0, 8), '1', 'derived', 'optics_body', '进行中的异步操作类型') |
| slot('operation.started_by_other_agent', BOOL, '1', 'derived', 'optics_body', '进行中的操作是否由另一个agent启动') |
| slot('warnings.active', array(TEXT, 0, 16), '1', 'derived', 'optics_body', '当前警告（SHEATH_LOW、WASTE_FULL、SAMPLE_DRY、LASERS_WARMING等）') |
| slot('errors.active', array(TEXT, 0, 16), '1', 'derived', 'optics_body', '当前错误') |
| slot('truth.sheath_temperature_k', number('K'), 'K', 'process_truth', 'fluidics_body', '喷嘴处鞘液温度真值', 'evaluator') |
| slot('truth.jet_speed_m_s', number('m/s'), 'm/s', 'process_truth', 'fluidics_body', '喷射速度真值', 'evaluator') |
| slot('truth.breakoff_length_m', _PN('m'), 'm', 'process_truth', 'fluidics_body', '喷嘴到断点距离真值', 'evaluator') |
| slot('truth.drop_delay_drops', _PN('1'), '1', 'process_truth', 'sort_block', '真实液滴延迟（滴）', 'evaluator') |
| slot('truth.laser_delays_s', obj({L: number('s') for L in LASERS}), 's', 'process_truth', 'optics_body', '真实激光延迟', 'evaluator') |
| slot('truth.area_scaling', obj({L: number('1') for L in LASERS}), '1', 'process_truth', 'optics_body', '使小颗粒面积等于高度的真实面积系数', 'evaluator') |
| slot('truth.core_radius_m', number('m'), 'm', 'process_truth', 'fluidics_body', '样品芯流半径真值', 'evaluator') |
| slot('truth.side_stream_x_m', obj({s: _PN('m') for s in STREAMS}), 'm', 'process_truth', 'sort_block', '各侧流在收集高度的落点真值', 'evaluator') |
| slot('truth.cart_sheath_m3', number('m3'), 'm3', 'process_truth', 'sheath_tank', '鞘液罐液量真值', 'evaluator') |
| slot('truth.cart_waste_m3', number('m3'), 'm3', 'process_truth', 'waste_tank', '废液罐液量真值', 'evaluator') |
| slot('truth.sample_temperature_k', _PN('K'), 'K', 'process_truth', 'sample_chamber', '进样口上样品管温度真值', 'evaluator') |
| slot('truth.faults', array(TEXT, 0, 16), '1', 'process_truth', 'fluidics_body', '注入的故障', 'evaluator') |
|
|
|
|
| |
| class _Sum: |
| def __init__(self): |
| self.s = 0.0 |
| self.c = 0.0 |
|
|
| def add(self, x): |
| t = self.s + x |
| if abs(self.s) >= abs(x): |
| self.c += (self.s - t) + x |
| else: |
| self.c += (x - t) + self.s |
| self.s = t |
|
|
| def value(self): |
| return self.s + self.c |
|
|
|
|
| def _h(text): |
| return zlib.crc32(str(text).encode()) & 0x7FFFFFFF |
|
|
|
|
| def _rng(seed, *keys): |
| return np.random.Generator(np.random.PCG64(np.random.SeedSequence([int(seed)] + [int(k) & 0xFFFFFFFF for k in keys]))) |
|
|
|
|
| def _pmt_gain(v): |
| return (max(v, 0.0) / PMT_REF_V) ** PMT_EXP if v > 0 else 0.0 |
|
|
|
|
| def _fsc_gain(v): |
| return (max(v, 0.0) / PMT_REF_V) ** FSC_EXP if v > 0 else 0.0 |
|
|
|
|
| def _deflected_fraction(eps, y_mask, sigma): |
| """Fraction of particles that end up in a charged drop when the set drop delay is off by eps drops (true - set), with the yield mask |
| y_mask (1/32 drop) and a breakoff jitter sigma (drops): phase uniform over the assigned drop, jitter by Gauss-Hermite quadrature.""" |
| y = y_mask / 64.0 |
| ph = (np.arange(64) + 0.5) / 64.0 |
| xs, ws = np.polynomial.hermite_e.hermegauss(9) |
| out = 0.0 |
| for x, w in zip(xs, ws): |
| off = np.floor(ph + eps + sigma * x) |
| hit = (off == 0) | ((off == -1) & (ph < y)) | ((off == 1) & (ph >= 1.0 - y)) |
| out += w * float(hit.mean()) |
| return out / math.sqrt(2.0 * math.pi) |
|
|
|
|
| def _in_poly(x, y, verts): |
| inside = np.zeros(len(x), bool) |
| n = len(verts) |
| for i in range(n): |
| x1, y1 = verts[i] |
| x2, y2 = verts[(i + 1) % n] |
| cond = ((y1 > y) != (y2 > y)) |
| with np.errstate(divide='ignore', invalid='ignore'): |
| xc = (x2 - x1) * (y - y1) / ((y2 - y1) if y2 != y1 else 1e-300) + x1 |
| inside ^= cond & (x < xc) |
| return inside |
|
|
|
|
| class BdFacsariaiiiRuntime: |
| def __init__(self, instance_id='facsaria_iii_01'): |
| cal = _cal() |
| _photon() |
| pre = cal['presets']['70_high'] |
| self.instance_id = instance_id |
| self.t = 0.0 |
| self.tick = 0 |
| self.plant = None |
| self.switch_on = False |
| self.power = False |
| self.lasers = {L: dict(on=False, t_on=None) for L in LASERS} |
| self.doors = {d: 0.0 for d in DOORS} |
| self.nozzle = '70' |
| self.fluidics_state = 'shutdown' |
| self.preset = '70_high' |
| self.custom = False |
| self.sheath_set = pre['pressure_pa'] |
| self.sheath_p = 0.0 |
| self.stream = False |
| self.stream_t_on = None |
| self.bo = dict(amplitude_v=pre['amplitude_v'], frequency_hz=pre['frequency_hz'], drop1_target_px=DROP1_DEFAULT, gap_target_px=GAP_DEFAULT, |
| attenuation=PRESET_ATTEN['70_high']) |
| self.sweet = False |
| self.ss_paused = False |
| self.defl = dict(voltage_on=False, plate_voltage_v=PRESET_PLATE_V['70_high'], side_stream_fraction=dict(zip(STREAMS, pre['side_frac'])), |
| voltage_center_fraction=0.0, |
| test_sort=False, optical_filter_in=False) |
| self.dd_set = pre['drop_delay'] |
| self.drawer_open = False |
| self.drawer_pos = 0.0 |
| self.amo = dict(on=False, mode='normal') |
| self.agitation = 'off' |
| self.sample_sp = None |
| self.T_chamber = None |
| self.light = False |
| self.col_sp = None |
| self.T_col = None |
| self.T_sheath = None |
| self.T_room = None |
| self.samples = {} |
| self.popspec = {} |
| self.tubes = {} |
| self.port = dict(tube=None, pos=0.0, state='down', t_up=None) |
| self.acq_on = False |
| self.flow_setting = 1.0 |
| self.events_processed = 0 |
| fl = fluidics() |
| self.settings = dict(voltages={d: (250.0 if d == 'FSC' else 300.0 if d == 'SSC' else 500.0) for d in DETS}, |
| thresholds=[dict(parameter='FSC', value=5000.0)], threshold_logic='or', |
| laser_delays_s={L: LASER_SPOT_ORDER[L] * fl['laser_delay_us']['70_high'] * 1e-6 for L in LASERS}, |
| area_scaling=self._asf_default('70_high'), window_extension_s=fl['window_extension_us'] * 1e-6, detectors_enabled=list(DETS)) |
| self.comp_on = False |
| self.S = np.eye(len(FL_DETS)) |
| self.gates = {} |
| self.records = {} |
| self.live = np.zeros((LIVE_BUFFER, NPAR), np.float32) |
| self.live_n = 0 |
| self.live_pos = 0 |
| self.hist = [] |
| self.collection = None |
| self.layouts = {} |
| self.sortrun = None |
| self.operations = {} |
| self.cart = dict(sheath=0.0, waste=0.0, cleaning=dict(facsclean=0.0, facsrinse=0.0, di_water=0.0, ethanol=0.0), air=0.0) |
| self.estop = False |
| self.level_warn = dict(shown_at=None, next_show=0.0) |
| self.warnings = {} |
| self.errors = {} |
| self.faults = set() |
| self.fault_t = {} |
| self.led = {k: _Sum() for k in LEDGER_KEYS} |
| self.cst_status = 'not_run' |
| self.cst_result = None |
| self.events, self.events_dropped = [], 0 |
| self.exports = {} |
| self.revision = 0 |
| self.seq = dict(op=0, col=0) |
| self._principals = {} |
| self._requests = {} |
| self._owners = {} |
| self._caller = None |
| self._stored = 0 |
| self._inst = {} |
| self._col_volume = 0.0 |
|
|
| |
| @property |
| def time_s(self): |
| return self.t |
|
|
| def register_principal(self, name, visibility): |
| if visibility not in ('agent', 'evaluator') or name in self._principals: |
| raise ActionRejected('INVALID_ARGUMENT') |
| self._principals[name] = visibility |
|
|
| def session(self, name): |
| if name not in self._principals: |
| raise ActionRejected('ACCESS_DENIED') |
| return BdFacsariaiiiSession(self, name) |
|
|
| def _event(self, kind, code, message, ref=None): |
| if len(self.events) >= MAX_EVENTS_LOG: |
| self.events.pop(0) |
| self.events_dropped += 1 |
| self.events.append(dict(time_s=self.t, kind=kind, code=code, message_zh=message, _ref=ref)) |
|
|
| def _error(self, code, message): |
| if code not in self.errors: |
| self.errors[code] = message |
| self._event('error', code, message) |
|
|
| def _own(self, object_id): |
| if self._caller is not None: |
| self._owners[object_id] = self._caller |
|
|
| |
| @staticmethod |
| def _asf_default(preset): |
| base = PRESET_ASF.get(preset, PRESET_ASF['100']) |
| return dict(violet=base['violet'], blue=base['blue'], yellow_green=base['blue'], red=base['red']) |
|
|
| def _nozzle_a(self): |
| return int(self.nozzle) * 0.5e-6 if self.nozzle not in (None, 'closed_loop') else None |
|
|
| def _jet(self): |
| """Jet speed, flow, cuvette speeds at the actual sheath pressure.""" |
| a = self._nozzle_a() |
| T = self.T_sheath if self.T_sheath is not None else REF_SHEATH_K |
| v = jet_speed(self.sheath_p, T, self._cd()) if (a is not None and self.stream) else 0.0 |
| q = math.pi * a * a * v if a is not None else 0.0 |
| v_cuv = q / CHANNEL_AREA |
| return dict(a=a, v=v, q=q, v_cuv=v_cuv, v_core=CORE_SPEED_RATIO * v_cuv, T=T) |
|
|
| def _breakoff(self): |
| """Breakoff state of the running stream: None when no stream or no regular drop formation.""" |
| if not (self.power and self.stream) or self.sheath_p < 0.5 * self.sheath_set: |
| return None |
| j = self._jet() |
| if j['a'] is None or j['v'] <= 0: |
| return None |
| cal = _cal() |
| f = self.bo['frequency_hz'] |
| lam = j['v'] / f |
| om = growth_rate(j['a'], lam, j['T']) |
| if om <= 0: |
| return None |
| pc = self._ncal() |
| dT = j['T'] - REF_SHEATH_K |
| G = pc['G'] * (1.0 + TRANSDUCER_TC * dT) |
| a_eff = self.bo['amplitude_v'] * (ATTENUATION if self.bo['attenuation'] else 1.0) |
| if 'clog_full' in self.faults: |
| return None |
| if 'clog_partial' in self.faults: |
| a_eff *= 1.6 |
| nb = (f / om) * math.log(max(j['a'] / (G * a_eff), 1.0000001)) |
| L_b = nb * lam |
| px = cal['px'] |
| B = (L_b - cal['cam_top']) / px |
| S = lam / px |
| r = _drop_r(j['a'], lam) / px |
| p0 = pc['p0'] |
| |
| jmin = math.floor((B + r - p0) / S) + 1 |
| d1 = p0 + jmin * S |
| gap = d1 - r - B |
| if 'clog_partial' in self.faults: |
| gap += 3.0 |
| if 'flow_cell_bubble' in self.faults: |
| gap += 4.0 * math.sin(self.t * 1.7) |
| visible = (0.0 <= B <= 700.0 - r) and DROP1_RANGE[0] - 60 <= d1 <= 700.0 |
| q = j['q'] |
| dd = f * pc['vdead'] / max(q, 1e-15) + nb |
| overdrive = (not self.bo['attenuation']) and self.sheath_p < 30 * PSI and self.bo['amplitude_v'] > 10.0 |
| return dict(lam=lam, nb=nb, L_b=L_b, B=B, S=S, r=r, drop1=d1 if visible else None, gap=gap if visible else None, dd_true=dd, om=om, f=f, |
| v=j['v'], q=q, a=j['a'], overdrive=overdrive, drop_m3=math.pi * j['a'] ** 2 * lam) |
|
|
| def _cd(self): |
| """Discharge coefficient of the installed nozzle at the present pressure: linear in pressure between the presets of that nozzle size.""" |
| pts = sorted((c['pressure_pa'], c['cd']) for c in _cal()['presets'].values() if c['nozzle_um'] == self.nozzle) |
| if not pts: |
| return fluidics()['discharge_coefficient']['value'] |
| p = self.sheath_set if self.sheath_p <= 0 else self.sheath_p |
| return float(np.interp(p, [x for x, _ in pts], [y for _, y in pts])) |
|
|
| def _ncal(self): |
| """Calibration of the installed nozzle: the preset of that nozzle size whose drop-drive frequency is closest to the present one (transducer |
| coupling, strobe offset, laser-to-nozzle volume, deflection constant).""" |
| cal = _cal()['presets'] |
| cands = [c for c in cal.values() if c['nozzle_um'] == self.nozzle] |
| if not cands: |
| return None |
| c = dict(min(cands, key=lambda c: abs(c['frequency_hz'] - self.bo['frequency_hz']))) |
| zg, zv = self._inst.get(self.nozzle, (0.0, 0.0)) |
| c['G'] = c['G'] * (1.0 + INSTALL_SD[0] * zg) |
| c['vdead'] = c['vdead'] * (1.0 + INSTALL_SD[1] * zv) |
| return c |
|
|
| def _true_laser_delays(self): |
| j = self._jet() |
| if j['v_core'] <= 0: |
| return {L: 0.0 for L in LASERS} |
| return {L: _cal()['spot_m'][L] / j['v_core'] for L in LASERS} |
|
|
| def _true_asf(self): |
| """Area scaling that makes the area of a small particle equal its height: documented preset values scaled with the cuvette speed.""" |
| j = self._jet() |
| base_name = self.preset if self.preset in PRESET_ASF else '100' |
| base = self._asf_default(base_name) |
| pc = _cal()['presets'][base_name] |
| v_ref = CORE_SPEED_RATIO * _q_sheath(int(pc['nozzle_um']) * 1e-6, pc['v']) / CHANNEL_AREA |
| k = (j['v_core'] / v_ref) if j['v_core'] > 0 else 1.0 |
| return {L: base[L] * k for L in LASERS} |
|
|
| def _stream_x(self, stream, bo=None): |
| """Landing position (m) and spread of a side stream at the collection height.""" |
| bo = bo if bo is not None else self._breakoff() |
| if bo is None or not self.defl['voltage_on'] or self.defl['plate_voltage_v'] <= 0: |
| return None, None |
| pc = self._ncal() |
| K = pc['K_defl'] * (pc['v'] / bo['v']) ** 2 if bo['v'] > 0 else pc['K_defl'] |
| V = self.defl['plate_voltage_v'] |
| x = STREAM_SIGN[stream] * K * self.defl['side_stream_fraction'][stream] * V + K * V * self.defl['voltage_center_fraction'] * 0.1 |
| sig = SIDE_SIGMA_M[0 if stream in ('left', 'right') else 1] |
| if bo['gap'] is not None: |
| sig += 1.5e-4 * max(0.0, abs(bo['gap'] - self.bo['gap_target_px']) - 1.0) |
| if bo['overdrive']: |
| sig += 1.0e-3 |
| if 'clog_partial' in self.faults: |
| x += 2.5e-3 |
| sig += 2.0e-3 |
| if 'flow_cell_bubble' in self.faults: |
| sig += 1.0e-3 |
| return x, sig |
|
|
| def _centre_x(self): |
| if 'clog_partial' in self.faults: |
| return 0.012, 3.0e-3 |
| return 0.0, 2.0e-4 |
|
|
| def _rate_limit(self): |
| en = self.settings['detectors_enabled'] |
| pairs = self._pairs() |
| return min(RATE_REF, RATE_REF * (8 + 0.5 * 12) / (len(en) + 0.5 * pairs)) |
| |
|
|
| def _pairs(self): |
| if not self.comp_on: |
| return 0 |
| off = self.S - np.diag(np.diag(self.S)) |
| return int(np.count_nonzero(np.abs(off) > 1e-9)) |
|
|
| def _laser_power(self, L): |
| """Relative output (0-1) and extra noise of a laser (warm-up, failure).""" |
| s = self.lasers[L] |
| if not (self.power and s['on']) or f'laser_failure_{L}' in self.faults: |
| return 0.0, 0.0 |
| age = self.t - s['t_on'] |
| return 1.0 - 0.15 * math.exp(-age / WARMUP_TAU_S), 0.04 * math.exp(-age / WARMUP_TAU_S) |
|
|
| def _laser_warm(self, L): |
| s = self.lasers[L] |
| return bool(self.power and s['on'] and f'laser_failure_{L}' not in self.faults and self.t - s['t_on'] >= WARMUP_S - 1e-9) |
|
|
| def _shutter(self): |
| return self.doors['flow_cell'] > DOOR_CLOSED_RAD |
|
|
| |
| def _need_plant(self): |
| if self.plant is None: |
| raise ActionRejected('PLANT_REQUIRED') |
|
|
| def _need_power(self): |
| self._need_plant() |
| if not self.power: |
| raise ActionRejected('POWER_OFF') |
|
|
| def _mains_ok(self): |
| v = self.plant['mains_voltage_v'] |
| return 'power_loss' not in self.faults and 90.0 <= v <= 253.0 |
|
|
| def _cmd_plant_configure(self, room_k, mains_voltage_v, noise_seed, room_drift_k_per_s=0.0): |
| if self.plant is not None and noise_seed != self.plant['noise_seed']: |
| raise ActionRejected('SEED_FIXED') |
| first = self.plant is None |
| self.plant = dict(room_k=room_k, mains_voltage_v=mains_voltage_v, noise_seed=noise_seed, room_drift_k_per_s=room_drift_k_per_s) |
| if first: |
| rng = _rng(noise_seed, 41) |
| self._inst = {nz: (float(rng.standard_normal()), float(rng.standard_normal())) for nz in NOZZLES if nz != 'closed_loop'} |
| self.T_room = room_k |
| self.T_chamber = room_k |
| self.T_col = room_k |
| self.T_sheath = room_k |
| self.cart.update(sheath=fluidics()['reservoirs']['sheath_m3'], waste=0.0, |
| cleaning={k: fluidics()['reservoirs']['cleaning_m3'] for k in self.cart['cleaning']}) |
| else: |
| self.T_room = room_k |
| if self.power and not self._mains_ok(): |
| self._power_off('mains') |
| elif self.switch_on and not self.power and self._mains_ok(): |
| self._power_up() |
| return dict(plant=dict(self.plant)) |
|
|
| def _power_up(self): |
| self.power = True |
| self._event('power', 'POWER_ON', '主机通电；液流车泵启动，激光器需手动开启并预热') |
|
|
| def _power_off(self, cause): |
| self.power = False |
| for L in LASERS: |
| self.lasers[L].update(on=False, t_on=None) |
| self._stream_stop('POWER_OFF') |
| self.defl['voltage_on'] = False |
| self.defl['test_sort'] = False |
| self.acq_on = False |
| self.sweet = False |
| for op in list(self.operations.values()): |
| if op['phase'] == 'running': |
| self._fail_op(op, 'POWER_OFF') |
| if self.fluidics_state in ('starting', 'shutting_down', 'cleaning'): |
| self.fluidics_state = 'shutdown' |
| self._event('power', 'POWER_OFF', '主机断电（' + ('市电中断' if cause == 'mains' else '电源按钮') + '）：激光、液流、偏转板与采集停止') |
|
|
| def _set_power(self, enabled): |
| self._need_plant() |
| if enabled and not self._mains_ok(): |
| raise ActionRejected('MAINS_OUT_OF_RANGE') |
| self.switch_on = enabled |
| if enabled and not self.power: |
| self._power_up() |
| elif not enabled and self.power: |
| self._power_off('switch') |
| return dict(enabled=self.power) |
|
|
| def _cmd_power_set(self, enabled): |
| return self._set_power(enabled) |
|
|
| def _cmd_power_press_switch(self): |
| return self._set_power(not self.switch_on) |
|
|
| def _cmd_lasers_set(self, laser, enabled): |
| self._need_power() |
| s = self.lasers[laser] |
| if enabled and not s['on']: |
| s.update(on=True, t_on=self.t) |
| self._event('laser', 'LASER_ON', f'{laser}激光器开启（预热30 min）') |
| elif not enabled and s['on']: |
| s.update(on=False, t_on=None) |
| self._event('laser', 'LASER_OFF', f'{laser}激光器关闭') |
| return dict(laser=laser, enabled=s['on'], warm=self._laser_warm(laser)) |
|
|
| |
| def _cmd_door_set(self, door, angle_rad): |
| self._need_plant() |
| if angle_rad > DOORS[door][1] + 1e-12: |
| raise ActionRejected('INVALID_ARGUMENT') |
| if door == 'sort_chamber' and angle_rad > DOOR_CLOSED_RAD and self.amo['on']: |
| self._event('safety', 'AMO_DOOR_OPEN', '分选收集室门打开：AMO抽吸失去密封') |
| self.doors[door] = float(angle_rad) |
| return dict(door=door, angle_rad=self.doors[door]) |
|
|
| def _cmd_nozzle_install(self, nozzle): |
| self._need_plant() |
| if self.stream: |
| raise ActionRejected('STREAM_ON') |
| if self.doors['flow_cell'] < DOOR_OPEN_RAD - 1e-9: |
| raise ActionRejected('DOOR_CLOSED') |
| self.nozzle = nozzle |
| self.faults.discard('clog_full') |
| self.faults.discard('clog_partial') |
| self.errors.pop('CLOG', None) |
| self._event('stream', 'NOZZLE_INSTALLED', f'装上{nozzle}喷嘴') |
| return dict(nozzle=nozzle) |
|
|
| |
| def _new_op(self, kind, duration, **extra): |
| self.seq['op'] += 1 |
| op_id = f'op_{self.seq["op"]}' |
| op = dict(op_id=op_id, kind=kind, phase='running', started_s=self.t, ends_s=self.t + duration if duration is not None else None, error=None, result={}, **extra) |
| self.operations[op_id] = op |
| self._own(op_id) |
| return op |
|
|
| def _running_ops(self, *kinds): |
| return [op for op in self.operations.values() if op['phase'] == 'running' and (not kinds or op['kind'] in kinds)] |
|
|
| def _fail_op(self, op, code): |
| op['phase'] = 'failed' |
| op['error'] = code |
| op['finished_s'] = self.t |
| if op['kind'] == 'sort.start' and self.sortrun is not None and self.sortrun['op_id'] == op['op_id']: |
| self.sortrun['state'] = 'stopped' if code == 'SAMPLE_UNLOADED' else 'error' |
| self.sortrun['error'] = code |
| self.drawer_open = False |
| op['result'] = dict(counts=dict(self.sortrun['counts']), conflicts=self.sortrun['conflicts']) |
| if op['kind'] == 'acquisition.record': |
| r = self.records[op['record_id']] |
| r['finished_s'] = self.t |
| op['result'] = dict(record_id=op['record_id'], events=int(r['n'])) |
| self._event('error' if code not in ('CANCELLED',) else 'sort', 'OPERATION_FAILED', f'{op["kind"]}中止：{ERROR_ZH.get(code, code)}', op['op_id']) |
|
|
| def _cancel_op(self, op): |
| op['phase'] = 'cancelled' |
| op['finished_s'] = self.t |
| if op['kind'] == 'acquisition.record': |
| r = self.records[op['record_id']] |
| r['finished_s'] = self.t |
| op['result'] = dict(record_id=op['record_id'], events=int(r['n'])) |
| if op['kind'] == 'sort.start' and self.sortrun is not None and self.sortrun['op_id'] == op['op_id']: |
| self.sortrun['state'] = 'stopped' |
| self.drawer_open = False |
| if op['kind'] in ('fluidics.startup', 'fluidics.shutdown', 'cleaning.run'): |
| self.fluidics_state = 'shutdown' if op['kind'] != 'cleaning.run' else 'ready' |
| self._event('sort' if op['kind'] == 'sort.start' else 'fluidics', 'OPERATION_CANCELLED', f'{op["kind"]}已取消', op['op_id']) |
|
|
| def _need_fluidics_idle(self): |
| if self._running_ops('fluidics.startup', 'fluidics.shutdown', 'cleaning.run'): |
| raise ActionRejected('FLUIDICS_BUSY') |
|
|
| def _cmd_fluidics_startup(self): |
| self._need_power() |
| self._need_fluidics_idle() |
| if self.fluidics_state != 'shutdown': |
| raise ActionRejected('FLUIDICS_ALREADY_STARTED') |
| if self.nozzle in (None, 'closed_loop'): |
| raise ActionRejected('SORT_NOZZLE_REQUIRED') |
| if self.cart['sheath'] < PRIME_SHEATH_M3 + 1e-4: |
| raise ActionRejected('SHEATH_LOW') |
| if self.cart['waste'] > 0.9 * fluidics()['reservoirs']['waste_m3']: |
| raise ActionRejected('WASTE_FULL') |
| op = self._new_op('fluidics.startup', STARTUP_S) |
| self.fluidics_state = 'starting' |
| self._event('fluidics', 'STARTUP', 'Fluidics Startup开始：检查液位，用鞘液替换管路与压力缓冲罐中的水', op['op_id']) |
| return dict(operation_id=op['op_id']) |
|
|
| def _cmd_fluidics_shutdown(self): |
| self._need_power() |
| self._need_fluidics_idle() |
| if self.fluidics_state != 'ready': |
| raise ActionRejected('FLUIDICS_NOT_READY') |
| if self.stream: |
| raise ActionRejected('STREAM_ON') |
| if self.nozzle != 'closed_loop': |
| raise ActionRejected('CLOSED_LOOP_NOZZLE_REQUIRED') |
| if self.cart['cleaning']['di_water'] < 3.0e-4 or self.cart['cleaning']['facsclean'] < 5.0e-5: |
| raise ActionRejected('CLEANING_FLUID_LOW') |
| op = self._new_op('fluidics.shutdown', SHUTDOWN_S) |
| self.fluidics_state = 'shutting_down' |
| self._event('fluidics', 'SHUTDOWN', 'Fluidics Shutdown开始：去离子水替换鞘液，清洗比色池（约3 min）', op['op_id']) |
| return dict(operation_id=op['op_id']) |
|
|
| def _cmd_cleaning_run(self, mode): |
| self._need_power() |
| self._need_fluidics_idle() |
| if self.fluidics_state != 'ready': |
| raise ActionRejected('FLUIDICS_NOT_READY') |
| if self.stream: |
| raise ActionRejected('STREAM_ON') |
| if mode == 'prepare_aseptic_sort' and self.nozzle != 'closed_loop': |
| raise ActionRejected('CLOSED_LOOP_NOZZLE_REQUIRED') |
| need = dict(facsclean=1.0e-4, facsrinse=1.0e-4, di_water=2.0e-4, ethanol=(1.0e-3 if mode == 'prepare_aseptic_sort' else 0.0)) |
| if any(self.cart['cleaning'][k] < v for k, v in need.items()): |
| raise ActionRejected('CLEANING_FLUID_LOW') |
| op = self._new_op('cleaning.run', CLEAN_S[mode], mode=mode, need=need) |
| self.fluidics_state = 'cleaning' |
| self._event('fluidics', 'CLEANING', f'清洗模式{mode}开始', op['op_id']) |
| return dict(operation_id=op['op_id']) |
|
|
| def _finish_fluidics_op(self, op): |
| res = fluidics()['reservoirs'] |
| if op['kind'] == 'fluidics.startup': |
| self._move_fluid('sheath', PRIME_SHEATH_M3) |
| self.fluidics_state = 'ready' |
| self._event('fluidics', 'STARTUP_DONE', 'Fluidics Startup完成：可以开液流', op['op_id']) |
| elif op['kind'] == 'fluidics.shutdown': |
| self._move_fluid('di_water', 3.0e-4) |
| self._move_fluid('facsclean', 5.0e-5) |
| self.fluidics_state = 'shutdown' |
| self._event('fluidics', 'SHUTDOWN_DONE', 'Fluidics Shutdown完成：可以关机', op['op_id']) |
| else: |
| for k, v in op['need'].items(): |
| self._move_fluid(k, v) |
| self.fluidics_state = 'ready' |
| self._event('fluidics', 'CLEANING_DONE', f'清洗模式{op["mode"]}完成', op['op_id']) |
| op['phase'] = 'succeeded' |
| op['finished_s'] = self.t |
| op['result'] = dict(fluidics_state=self.fluidics_state) |
| del res |
|
|
| def _move_fluid(self, source, vol): |
| """Take vol (m3) from a cart container to the waste (sheath / cleaning fluids).""" |
| if source == 'sheath': |
| take = min(vol, self.cart['sheath']) |
| self.cart['sheath'] -= take |
| self.led['sheath_used_m3'].add(take) |
| else: |
| take = min(vol, self.cart['cleaning'][source]) |
| self.cart['cleaning'][source] -= take |
| self.led['cleaning_fluid_used_m3'].add(take) |
| self._to_waste(take) |
|
|
| def _to_waste(self, vol): |
| self.cart['waste'] += vol |
| self.led['waste_added_m3'].add(vol) |
|
|
| |
| def _cmd_sort_setup_select(self, preset): |
| self._need_power() |
| if self.stream: |
| raise ActionRejected('STREAM_ON') |
| if self.sweet: |
| raise ActionRejected('SWEET_SPOT_ON') |
| if self._running_ops('sort.start', 'sort.auto_drop_delay', 'cst.performance_check'): |
| raise ActionRejected('SORT_IN_PROGRESS') |
| pc = _cal()['presets'][preset] |
| self.preset = preset |
| self.custom = False |
| self.sheath_set = pc['pressure_pa'] |
| self.bo.update(amplitude_v=pc['amplitude_v'], frequency_hz=pc['frequency_hz'], attenuation=PRESET_ATTEN[preset]) |
| self.dd_set = pc['drop_delay'] |
| self.defl.update(plate_voltage_v=PRESET_PLATE_V[preset], side_stream_fraction=dict(zip(STREAMS, pc['side_frac']))) |
| fl = fluidics() |
| self.settings['window_extension_s'] = fl.get('window_extension_us_by_preset', {}).get(preset, fl['window_extension_us']) * 1e-6 |
| dl = fl['laser_delay_us'].get(preset) |
| if dl is None: |
| hi = _cal()['presets']['70_high'] |
| dl = fl['laser_delay_us']['70_high'] * _q_sheath(70e-6, hi['v']) / _q_sheath(int(pc['nozzle_um']) * 1e-6, pc['v']) |
| self.settings['laser_delays_s'] = {L: LASER_SPOT_ORDER[L] * dl * 1e-6 for L in LASERS} |
| self.settings['area_scaling'] = self._asf_default(preset) |
| self._event('stream', 'SORT_SETUP', f'Sort Setup：{preset}（鞘液{pc["pressure_pa"] / PSI:.0f} psi、{pc["frequency_hz"] / 1000:.1f} kHz）') |
| return dict(preset=preset, sheath_pressure_pa=self.sheath_set, frequency_hz=self.bo['frequency_hz'], amplitude_v=self.bo['amplitude_v'], |
| drop_delay_drops=self.dd_set, plate_voltage_v=self.defl['plate_voltage_v']) |
|
|
| def _cmd_sheath_set_pressure(self, pressure_pa): |
| self._need_power() |
| if self.sweet: |
| raise ActionRejected('SWEET_SPOT_ON') |
| if self._running_ops('sort.start', 'sort.auto_drop_delay'): |
| raise ActionRejected('SORT_IN_PROGRESS') |
| if not self.custom: |
| self._custom_base = self.preset |
| self.custom = True |
| self.sheath_set = float(pressure_pa) |
| self._event('stream', 'SHEATH_PRESSURE', f'鞘液压力设为{pressure_pa / PSI:.1f} psi（自定义；激光延迟、面积系数、液滴延迟需重新确定）') |
| return dict(pressure_pa=self.sheath_set) |
|
|
| def _cmd_stream_set(self, on): |
| self._need_power() |
| if on: |
| if self.stream: |
| return dict(on=True) |
| if self.estop: |
| raise ActionRejected('EMERGENCY_STOP_LATCHED') |
| if self.fluidics_state != 'ready': |
| raise ActionRejected('FLUIDICS_NOT_READY') |
| if self.nozzle in (None, 'closed_loop'): |
| raise ActionRejected('SORT_NOZZLE_REQUIRED') |
| if self.cart['sheath'] <= 1e-5: |
| raise ActionRejected('SHEATH_EMPTY') |
| self.stream = True |
| self.stream_t_on = self.t |
| self.level_warn.update(shown_at=None, next_show=self.t) |
| if 'flow_cell_bubble' in self.faults and self.fault_t.get('flow_cell_bubble_off', -1) >= self.fault_t.get('flow_cell_bubble', 0): |
| self.faults.discard('flow_cell_bubble') |
| self._event('stream', 'BUBBLE_CLEARED', '关开液流后比色池气泡排出') |
| self._event('stream', 'STREAM_ON', '液流开启') |
| else: |
| if not self.stream: |
| return dict(on=False) |
| self._stream_stop('USER') |
| return dict(on=self.stream) |
|
|
| def _stream_stop(self, cause): |
| if not self.stream: |
| return |
| self.stream = False |
| self.stream_t_on = None |
| self.sweet = False |
| self.ss_paused = False |
| if 'flow_cell_bubble' in self.faults: |
| self.fault_t['flow_cell_bubble_off'] = self.t |
| for op in self._running_ops('sort.start', 'sort.auto_drop_delay'): |
| self._fail_op(op, 'STREAM_OFF') |
| self._event('stream', 'STREAM_OFF', '液流关闭' + ('' if cause == 'USER' else f'（{cause}）')) |
|
|
| def _cmd_breakoff_set(self, **kw): |
| self._need_power() |
| if not kw: |
| raise ActionRejected('INVALID_ARGUMENT') |
| if self.sweet and ('amplitude_v' in kw or 'frequency_hz' in kw): |
| raise ActionRejected('SWEET_SPOT_ON') |
| if 'frequency_hz' in kw and self._running_ops('sort.start', 'sort.auto_drop_delay'): |
| raise ActionRejected('SORT_IN_PROGRESS') |
| self.bo.update({k: (bool(v) if k == 'attenuation' else float(v)) for k, v in kw.items()}) |
| return dict(self.bo) |
|
|
| def _cmd_sweet_spot_set(self, enabled): |
| self._need_power() |
| if enabled: |
| if not self.stream: |
| raise ActionRejected('STREAM_OFF') |
| bo = self._breakoff() |
| if bo is None or bo['drop1'] is None: |
| raise ActionRejected('NO_BREAKOFF') |
| self.sweet = True |
| self._event('stream', 'SWEET_SPOT_ON', 'Sweet Spot开启：自动调节振幅保持Drop 1与Gap') |
| else: |
| self.sweet = False |
| self.ss_paused = False |
| self._event('stream', 'SWEET_SPOT_OFF', 'Sweet Spot关闭') |
| return dict(enabled=self.sweet) |
|
|
| def _sweet_spot_tick(self, bo): |
| """Sweet Spot servo on the amplitude (documented: coarse to Drop 1, then fine to the Gap); returns the pause flag.""" |
| if bo is None or bo['drop1'] is None: |
| return True |
| cal = _cal() |
| S, r = bo['S'], bo['r'] |
| pc = self._ncal() |
| p0 = pc['p0'] |
| jt = round((self.bo['drop1_target_px'] - p0) / S) |
| p_star = p0 + jt * S |
| B_star = p_star - r - self.bo['gap_target_px'] |
| nb_star = (B_star * cal['px'] + cal['cam_top']) / bo['lam'] |
| j = self._jet() |
| G = pc['G'] * (1.0 + TRANSDUCER_TC * (j['T'] - REF_SHEATH_K)) |
| atten = ATTENUATION if self.bo['attenuation'] else 1.0 |
| a_star = j['a'] / (G * atten * math.exp(nb_star * bo['om'] / bo['f'])) |
| coarse = abs(bo['drop1'] - self.bo['drop1_target_px']) > DROP1_TOL |
| step = (SS_COARSE_V_S if coarse else SS_FINE_V_S) * DT |
| if abs(bo['gap'] - self.bo['gap_target_px']) > 1.0 or coarse: |
| da = max(-step, min(step, a_star - self.bo['amplitude_v'])) |
| self.bo['amplitude_v'] = float(min(80.0, max(1.0, self.bo['amplitude_v'] + da))) |
| return abs(bo['gap'] - self.bo['gap_target_px']) > GAP_TOL_PAUSE or abs(bo['drop1'] - self.bo['drop1_target_px']) > DROP1_TOL |
|
|
| def _clog_protect(self): |
| """Documented Sweet Spot clog response: stream and plates off, aspirator drawer closed, tube unloaded.""" |
| self._event('error', 'CLOG_DETECTED', 'Sweet Spot检测到堵塞：关液流与偏转板、关闭抽吸抽屉、卸下样品管') |
| self._error('CLOG', '喷嘴堵塞（须取下喷嘴超声清洗）') |
| self.defl['voltage_on'] = False |
| self.drawer_open = False |
| self._unload('CLOG') |
| self._stream_stop('CLOG') |
|
|
| |
| def _cmd_deflection_set(self, **kw): |
| self._need_power() |
| if not kw: |
| raise ActionRejected('INVALID_ARGUMENT') |
| if kw.get('voltage_on') and self.estop: |
| raise ActionRejected('EMERGENCY_STOP_LATCHED') |
| if kw.get('test_sort') and not (kw.get('voltage_on', self.defl['voltage_on'])): |
| raise ActionRejected('PLATES_OFF') |
| for k, v in kw.items(): |
| if k == 'side_stream_fraction': |
| self.defl['side_stream_fraction'].update({s: float(x) for s, x in v.items()}) |
| else: |
| self.defl[k] = v if isinstance(v, bool) else float(v) |
| if not self.defl['voltage_on']: |
| self.defl['test_sort'] = False |
| self._event('deflection', 'DEFLECTION', '偏转设置：电压' + ('开' if self.defl['voltage_on'] else '关') + f'，{self.defl["plate_voltage_v"]:.0f} V') |
| out = copy.deepcopy(self.defl) |
| return out |
|
|
| def _cmd_drop_delay_set(self, drops): |
| self._need_power() |
| if self._running_ops('sort.auto_drop_delay'): |
| raise ActionRejected('SORT_IN_PROGRESS') |
| self.dd_set = float(drops) |
| return dict(drops=self.dd_set) |
|
|
| def _cmd_drawer_set(self, open): |
| self._need_power() |
| if open and self.estop: |
| raise ActionRejected('EMERGENCY_STOP_LATCHED') |
| self.drawer_open = bool(open) |
| return dict(open=self.drawer_open) |
|
|
| def _cmd_amo_set(self, enabled, mode=None): |
| self._need_power() |
| if enabled and self.doors['sort_chamber'] > DOOR_CLOSED_RAD: |
| raise ActionRejected('DOOR_OPEN') |
| self.amo['on'] = enabled |
| if mode is not None: |
| self.amo['mode'] = mode |
| return dict(enabled=self.amo['on'], mode=self.amo['mode'], chamber_exchange_rate_per_s=AMO_EXCHANGE_PER_S[self.amo['mode']] if self.amo['on'] else 0.0) |
|
|
| def _cmd_safety_emergency_stop(self): |
| self._need_plant() |
| self.estop = True |
| self._unload('EMERGENCY_STOP') |
| if self.sortrun is not None and self.sortrun['state'] in ('sorting', 'paused'): |
| for op in self._running_ops('sort.start'): |
| self._fail_op(op, 'EMERGENCY_STOP') |
| for op in self._running_ops('sort.auto_drop_delay', 'cst.performance_check', 'acquisition.record'): |
| self._fail_op(op, 'EMERGENCY_STOP') |
| self._stream_stop('EMERGENCY_STOP') |
| self.defl['voltage_on'] = False |
| self.defl['test_sort'] = False |
| self.drawer_open = False |
| who = {'agent': 'agent', 'evaluator': '评测者'}.get(self._principals.get(self._caller), '宿主') |
| self._event('safety', 'EMERGENCY_STOP', f'急停（{who}按下）：卸下样品管、ACDU停止、关液流与偏转板电压、关闭抽吸抽屉（激光与主电源不受影响）；' |
| '按钮锁住、灯亮，顺时针旋转复位') |
| return dict(latched=True) |
|
|
| def _cmd_safety_reset_emergency_stop(self): |
| self._need_plant() |
| self.estop = False |
| self._event('safety', 'EMERGENCY_STOP_RESET', '急停按钮已复位') |
| return dict(latched=False) |
|
|
| def _cmd_warnings_dismiss(self): |
| self._need_power() |
| out = [] |
| if self.level_warn['shown_at'] is not None: |
| self.level_warn.update(shown_at=None, next_show=self.t + 300.0) |
| out = [c for c in ('SHEATH_LOW', 'WASTE_FULL') if c in self.warnings] |
| return dict(dismissed=out) |
|
|
| |
| def _cmd_cart_refill_sheath(self, volume_m3): |
| self._need_plant() |
| if self.stream: |
| raise ActionRejected('STREAM_ON') |
| cap_ = fluidics()['reservoirs']['sheath_m3'] |
| if self.cart['sheath'] + volume_m3 > cap_ + 1e-9: |
| raise ActionRejected('CONTAINER_OVERFLOW') |
| self.cart['sheath'] += volume_m3 |
| if self.cart['sheath'] > 1e-5: |
| self.errors.pop('SHEATH_EMPTY', None) |
| self._event('cart', 'SHEATH_REFILL', f'鞘液罐加入{volume_m3 * 1000:.2f} L') |
| return dict(sheath_m3=self.cart['sheath']) |
|
|
| def _cmd_cart_empty_waste(self, bleach_m3=0.0): |
| self._need_plant() |
| if self.stream: |
| raise ActionRejected('STREAM_ON') |
| self.cart['waste'] = float(bleach_m3) |
| self.errors.pop('WASTE_OVERFLOW', None) |
| self._event('cart', 'WASTE_EMPTIED', '废液罐已倒空' + (f'并加入{bleach_m3 * 1000:.1f} L漂白剂' if bleach_m3 else '')) |
| return dict(waste_m3=self.cart['waste']) |
|
|
| def _cmd_cart_refill_cleaning(self): |
| self._need_plant() |
| for k in self.cart['cleaning']: |
| self.cart['cleaning'][k] = fluidics()['reservoirs']['cleaning_m3'] |
| return dict(cleaning_m3=dict(self.cart['cleaning'])) |
|
|
| |
| def _register_pop(self, key, spec): |
| self.popspec[key] = spec |
| return key |
|
|
| def _cmd_sample_provide(self, sample_id, volume_m3, populations): |
| self._need_plant() |
| if sample_id in self.samples: |
| raise ActionRejected('ITEM_EXISTS') |
| if len(self.samples) >= MAX_SAMPLES: |
| raise ActionRejected('TOO_MANY_ITEMS') |
| pl, fl = particles(), fluorochromes() |
| ids = [p['population_id'] for p in populations] |
| if len(set(ids)) != len(ids): |
| raise ActionRejected('DUPLICATE_POPULATION') |
| counts = {} |
| specs = {} |
| for p in populations: |
| if p['particle_id'] not in pl: |
| raise ActionRejected('UNKNOWN_PARTICLE') |
| for st in p.get('stains', []): |
| if st['dye'] not in fl: |
| raise ActionRejected('UNKNOWN_DYE') |
| lib = pl[p['particle_id']] |
| key = f'{sample_id}/{p["population_id"]}' |
| specs[key] = dict(key=key, population_id=p['population_id'], particle_id=p['particle_id'], kind=lib['kind'], |
| diameter_m=p.get('diameter_m', lib['diameter_um'] * 1e-6), diameter_cv=p.get('diameter_cv', lib['diameter_cv']), |
| dead_fraction=p.get('dead_fraction', 0.0), doublet_fraction=p.get('doublet_fraction', 0.0), |
| stains=[dict(dye=s['dye'], molecules=s['molecules'], cv=s.get('cv', 0.3), target=s.get('target', 'all')) for s in p.get('stains', [])], |
| peaks=None, accudrop=False, density_kg_m3=1070.0 if lib['kind'] == 'cell' else 1050.0) |
| counts[key] = float(round(p['concentration_per_m3'] * volume_m3)) |
| for k, v in specs.items(): |
| self._register_pop(k, v) |
| self.samples[sample_id] = dict(volume_m3=float(volume_m3), counts=counts, origin='evaluator') |
| self._event('sample', 'SAMPLE_PROVIDED', f'样品{sample_id}（{len(populations)}个群体）', sample_id) |
| return dict(sample_id=sample_id, particles=float(sum(counts.values()))) |
|
|
| def _bead_spec(self, bead_id, stains): |
| lib = particles()[bead_id] |
| tag = _h(json.dumps(stains, sort_keys=True)) if stains else 0 |
| key = f'bead:{bead_id}:{tag}' |
| if key not in self.popspec: |
| peaks = lib.get('peaks_mesf') |
| self._register_pop(key, dict(key=key, population_id=bead_id if not stains else f'{bead_id}+stain', particle_id=bead_id, kind='bead', |
| diameter_m=lib['diameter_um'] * 1e-6, diameter_cv=lib['diameter_cv'], dead_fraction=0.0, doublet_fraction=0.01, |
| stains=[dict(dye=s['dye'], molecules=s['molecules'], cv=s.get('cv', 0.05), target='all') for s in stains], |
| peaks=list(peaks) if peaks else None, accudrop=bead_id == 'accudrop_bead', density_kg_m3=1050.0)) |
| return key |
|
|
| def _cmd_tube_prepare(self, tube_id, tube_type, sources, buffer_volume_m3=0.0): |
| self._need_plant() |
| if tube_id in self.tubes: |
| raise ActionRejected('ITEM_EXISTS') |
| if len(self.tubes) >= MAX_TUBES: |
| raise ActionRejected('TOO_MANY_ITEMS') |
| pl, fl = particles(), fluorochromes() |
| vol = float(buffer_volume_m3) |
| take = {} |
| for src in sources: |
| if ('sample_id' in src) == ('bead_id' in src): |
| raise ActionRejected('INVALID_SOURCE') |
| if 'sample_id' in src: |
| if src.get('stains'): |
| raise ActionRejected('INVALID_SOURCE') |
| sm = self.samples.get(src['sample_id']) |
| if sm is None or (self._caller is not None and self._foreign_sample(src['sample_id'])): |
| raise ActionRejected('UNKNOWN_SAMPLE') |
| if src['volume_m3'] > sm['volume_m3'] + 1e-15 - take.get(src['sample_id'], 0.0): |
| raise ActionRejected('INSUFFICIENT_SAMPLE') |
| take[src['sample_id']] = take.get(src['sample_id'], 0.0) + src['volume_m3'] |
| else: |
| if src['bead_id'] not in pl or pl[src['bead_id']]['kind'] != 'bead': |
| raise ActionRejected('UNKNOWN_PARTICLE') |
| for st in src.get('stains', []): |
| if st['dye'] not in fl: |
| raise ActionRejected('UNKNOWN_DYE') |
| vol += src['volume_m3'] |
| if vol > TUBE_TYPES[tube_type]['capacity_m3'] + 1e-12: |
| raise ActionRejected('VOLUME_OUT_OF_RANGE') |
| counts = {} |
| rng = _rng(self.plant['noise_seed'], 11, _h(tube_id), self.tick) |
| for src in sources: |
| if 'sample_id' in src: |
| sm = self.samples[src['sample_id']] |
| frac = src['volume_m3'] / sm['volume_m3'] |
| for k, n in sm['counts'].items(): |
| m = float(rng.binomial(int(n), min(1.0, frac))) if n > 0 else 0.0 |
| sm['counts'][k] = n - m |
| counts[k] = counts.get(k, 0.0) + m |
| sm['volume_m3'] -= src['volume_m3'] |
| else: |
| key = self._bead_spec(src['bead_id'], src.get('stains', [])) |
| counts[key] = counts.get(key, 0.0) + float(rng.poisson(BEAD_STOCK_PER_M3 * src['volume_m3'])) |
| self.tubes[tube_id] = dict(type=tube_type, volume_m3=vol, counts=counts, location='bench', T=self.T_room, settle={k: 0.0 for k in counts}) |
| self._own('tube:' + tube_id) |
| self._event('sample', 'TUBE_PREPARED', f'配好样品管{tube_id}（{vol * 1e6:.2f} ml）', tube_id) |
| return dict(tube_id=tube_id, volume_m3=vol, particles=float(sum(counts.values()))) |
|
|
| def _cmd_tube_mix(self, tube_id): |
| self._need_plant() |
| tb = self.tubes.get(tube_id) |
| if tb is None: |
| raise ActionRejected('UNKNOWN_ITEM') |
| if tb['location'] != 'bench': |
| raise ActionRejected('TUBE_NOT_ON_BENCH') |
| for k in tb['settle']: |
| tb['settle'][k] = 0.0 |
| self._event('sample', 'TUBE_MIXED', f'混匀样品管{tube_id}', tube_id) |
| return dict(tube_id=tube_id) |
|
|
| def _foreign_sample(self, sample_id): |
| owner = self._owners.get('sample:' + sample_id) |
| return owner is not None and owner != self._caller and self._principals.get(owner) == 'agent' |
|
|
| def _cmd_tube_install(self, tube_id): |
| self._need_plant() |
| tb = self.tubes.get(tube_id) |
| if tb is None: |
| raise ActionRejected('UNKNOWN_ITEM') |
| if tb['location'] != 'bench': |
| raise ActionRejected('TUBE_NOT_ON_BENCH') |
| if self.port['tube'] is not None: |
| raise ActionRejected('PORT_OCCUPIED') |
| if self.port['state'] != 'down': |
| raise ActionRejected('PORT_NOT_DOWN') |
| tb['location'] = 'port' |
| self.port['tube'] = tube_id |
| return dict(tube_id=tube_id) |
|
|
| def _cmd_tube_remove(self): |
| self._need_plant() |
| if self.port['tube'] is None: |
| raise ActionRejected('NO_TUBE') |
| if self.port['state'] != 'down': |
| raise ActionRejected('PORT_NOT_DOWN') |
| tid = self.port['tube'] |
| self.tubes[tid]['location'] = 'bench' |
| self.port['tube'] = None |
| return dict(tube_id=tid) |
|
|
| def _cmd_sample_load(self): |
| self._need_power() |
| if self.estop: |
| raise ActionRejected('EMERGENCY_STOP_LATCHED') |
| if not self.stream: |
| raise ActionRejected('STREAM_OFF') |
| if self.port['tube'] is None: |
| raise ActionRejected('NO_TUBE') |
| if self.port['state'] != 'down': |
| raise ActionRejected('PORT_NOT_DOWN') |
| self.port['state'] = 'loading' |
| self.acq_on = True |
| self.events_processed = 0 |
| self.live_n = 0 |
| self.live_pos = 0 |
| self.hist = [] |
| self._event('sample', 'LOAD', f'装载样品管{self.port["tube"]}', self.port['tube']) |
| return dict(tube_id=self.port['tube']) |
|
|
| def _unload(self, cause): |
| if self.port['state'] in ('loading', 'up'): |
| self.port['state'] = 'unloading' |
| self.port['t_up'] = None |
| self.acq_on = False |
| code = 'SAMPLE_UNLOADED' if cause == 'USER' else cause |
| for op in self._running_ops('sort.start', 'acquisition.record'): |
| self._fail_op(op, code) |
| self._event('sample', 'UNLOAD', '卸下样品管' + ('' if cause == 'USER' else f'（{cause}）'), self.port['tube']) |
|
|
| def _cmd_sample_unload(self): |
| self._need_power() |
| if self.port['state'] not in ('loading', 'up'): |
| raise ActionRejected('NOT_LOADED') |
| self._unload('USER') |
| return dict(tube_id=self.port['tube']) |
|
|
| def _cmd_acquisition_set(self, acquiring): |
| self._need_power() |
| if self.port['state'] not in ('loading', 'up'): |
| raise ActionRejected('NOT_LOADED') |
| self.acq_on = bool(acquiring) |
| return dict(acquiring=self.acq_on) |
|
|
| def _flow_m3_s(self): |
| lo, hi = fluidics()['sample_flow_rate_ul_min'] |
| s0, s1 = fluidics()['sample_flow_setting'] |
| return (lo + (self.flow_setting - s0) * (hi - lo) / (s1 - s0)) * 1e-9 / 60.0 |
|
|
| def _cmd_acquisition_flow_rate(self, setting): |
| self._need_power() |
| self.flow_setting = float(setting) |
| return dict(setting=self.flow_setting, sample_flow_m3_s=self._flow_m3_s()) |
|
|
| def _cmd_sample_agitation(self, speed): |
| self._need_power() |
| self.agitation = speed |
| return dict(speed=speed, rate_hz=AGITATION[speed]) |
|
|
| def _cmd_sample_temperature(self, setpoint_k): |
| self._need_power() |
| self.sample_sp = None if setpoint_k is None else float(setpoint_k) |
| return dict(setpoint_k=self.sample_sp) |
|
|
| def _cmd_collection_temperature(self, setpoint_k): |
| self._need_power() |
| self.col_sp = None if setpoint_k is None else float(setpoint_k) |
| return dict(setpoint_k=self.col_sp) |
|
|
| def _cmd_sample_chamber_light(self): |
| self._need_power() |
| self.light = not self.light |
| return dict(on=self.light) |
|
|
| |
| def _cmd_cytometer_settings(self, **kw): |
| self._need_power() |
| if not kw: |
| raise ActionRejected('INVALID_ARGUMENT') |
| if self._running_ops('sort.start', 'acquisition.record', 'cst.performance_check', 'sort.auto_drop_delay') and \ |
| ('detectors_enabled' in kw or 'thresholds' in kw or 'threshold_logic' in kw): |
| raise ActionRejected('ACQUISITION_IN_PROGRESS') |
| en = kw.get('detectors_enabled', self.settings['detectors_enabled']) |
| if len(set(en)) != len(en) or 'FSC' not in en or 'SSC' not in en: |
| raise ActionRejected('INVALID_PARAMETERS') |
| thr = kw.get('thresholds', self.settings['thresholds']) |
| if any(t['parameter'] not in en for t in thr) or len({t['parameter'] for t in thr}) != len(thr): |
| raise ActionRejected('INVALID_THRESHOLD') |
| for k, v in kw.items(): |
| if k in ('voltages', 'laser_delays_s', 'area_scaling'): |
| self.settings[k].update({a: float(b) for a, b in v.items()}) |
| elif k == 'thresholds': |
| self.settings[k] = [dict(parameter=t['parameter'], value=float(t['value'])) for t in v] |
| elif k == 'detectors_enabled': |
| self.settings[k] = [d for d in DETS if d in v] |
| else: |
| self.settings[k] = float(v) if k == 'window_extension_s' else v |
| return dict(max_event_rate_eps=self._rate_limit()) |
|
|
| def _cmd_compensation_set(self, enabled, spillover=None): |
| self._need_power() |
| if spillover is not None: |
| S = np.eye(len(FL_DETS)) |
| for i, d in enumerate(FL_DETS): |
| row = spillover.get(d) |
| if row is None: |
| continue |
| if d in row and abs(row[d] - 1.0) > 1e-9: |
| raise ActionRejected('INVALID_SPILLOVER') |
| for e, v in row.items(): |
| if e not in FL_DETS: |
| raise ActionRejected('INVALID_SPILLOVER') |
| S[i, FL_DETS.index(e)] = v |
| if abs(np.linalg.det(S)) < 1e-6: |
| raise ActionRejected('INVALID_SPILLOVER') |
| self.S = S |
| self.comp_on = bool(enabled) |
| return dict(enabled=self.comp_on, pairs=self._pairs()) |
|
|
| def _record_of(self, rid): |
| r = self.records.get(rid) |
| if r is None: |
| raise ActionRejected('UNKNOWN_RECORD') |
| return r |
|
|
| def _cmd_compensation_calculate(self, unstained_record, controls): |
| self._need_power() |
| un = self._record_of(unstained_record) |
| if un['n'] < 100: |
| raise ActionRejected('TOO_FEW_EVENTS') |
| U = un['data'][:un['n']] |
| S = np.eye(len(FL_DETS)) |
| for det, rid in controls.items(): |
| r = self._record_of(rid) |
| if r['n'] < 100: |
| raise ActionRejected('TOO_FEW_EVENTS') |
| X = r['data'][:r['n']] |
| i = FL_DETS.index(det) |
| prim = PIDX[f'{det}-A'] |
| cut = np.percentile(U[:, prim], 99.5) |
| pos = X[X[:, prim] > cut] |
| if len(pos) < 50: |
| raise ActionRejected('NO_POSITIVE_POPULATION') |
| dp = float(np.median(pos[:, prim]) - np.median(U[:, prim])) |
| if dp <= 0: |
| raise ActionRejected('NO_POSITIVE_POPULATION') |
| for j, e in enumerate(FL_DETS): |
| if j == i: |
| continue |
| c = PIDX[f'{e}-A'] |
| v_ = max(0.0, float(np.median(pos[:, c]) - np.median(U[:, c])) / dp) |
| S[i, j] = v_ if v_ >= SPILL_MIN else 0.0 |
| self.S = S |
| self.comp_on = True |
| self._event('data', 'COMPENSATION', f'由{len(controls)}个单染对照计算补偿矩阵') |
| return dict(spillover={FL_DETS[i]: {FL_DETS[j]: float(S[i, j]) for j in range(len(FL_DETS)) if S[i, j] != 0.0} for i in range(len(FL_DETS))}, |
| pairs=self._pairs()) |
|
|
| def _cmd_gate_define(self, gate_id, kind, x, parent=None, y=None, x_range=None, y_range=None, vertices=None): |
| self._need_plant() |
| if gate_id in self.gates or gate_id == 'live': |
| raise ActionRejected('ITEM_EXISTS') |
| if len(self.gates) >= MAX_GATES: |
| raise ActionRejected('TOO_MANY_ITEMS') |
| if parent is not None and parent not in self.gates: |
| raise ActionRejected('UNKNOWN_GATE') |
| if kind == 'interval': |
| ok = x_range is not None and y is None and vertices is None and x_range[0] < x_range[1] |
| elif kind == 'rectangle': |
| ok = y is not None and x_range is not None and y_range is not None and vertices is None and x_range[0] < x_range[1] and y_range[0] < y_range[1] |
| else: |
| ok = y is not None and vertices is not None and x_range is None and y_range is None |
| if not ok: |
| raise ActionRejected('INVALID_GATE') |
| self.gates[gate_id] = dict(kind=kind, x=x, y=y, parent=parent, x_range=x_range, y_range=y_range, vertices=vertices) |
| self._own('gate:' + gate_id) |
| return dict(gate_id=gate_id) |
|
|
| def _cmd_gate_delete(self, gate_id): |
| self._need_plant() |
| if gate_id not in self.gates: |
| raise ActionRejected('UNKNOWN_GATE') |
| if any(g['parent'] == gate_id for g in self.gates.values()): |
| raise ActionRejected('GATE_IN_USE') |
| if any(gate_id in lay['targets'].values() for lay in self.layouts.values()): |
| raise ActionRejected('GATE_IN_USE') |
| if any(op['phase'] == 'running' and gate_id in (op.get('storage_gate'), op.get('stopping_gate')) for op in self.operations.values()): |
| raise ActionRejected('GATE_IN_USE') |
| del self.gates[gate_id] |
| return dict(gate_id=gate_id) |
|
|
| def _compensate(self, X, S=None, on=None): |
| """Compensated copy of an event matrix (A and H of the fluorescence detectors).""" |
| S = self.S if S is None else S |
| on = self.comp_on if on is None else on |
| if not on or len(X) == 0: |
| return X |
| Y = X.astype(np.float64, copy=True) |
| Si = np.linalg.inv(S) |
| for suf in ('A', 'H'): |
| cols = [PIDX[f'{d}-{suf}'] for d in FL_DETS] |
| Y[:, cols] = Y[:, cols] @ Si |
| return Y |
|
|
| def _gate_mask(self, gid, X, cache): |
| if gid in cache: |
| return cache[gid] |
| g = self.gates[gid] |
| x = X[:, PIDX[g['x']]] |
| if g['kind'] == 'interval': |
| m = (x >= g['x_range'][0]) & (x <= g['x_range'][1]) |
| elif g['kind'] == 'rectangle': |
| yv = X[:, PIDX[g['y']]] |
| m = (x >= g['x_range'][0]) & (x <= g['x_range'][1]) & (yv >= g['y_range'][0]) & (yv <= g['y_range'][1]) |
| else: |
| m = _in_poly(x, X[:, PIDX[g['y']]], g['vertices']) |
| if g['parent'] is not None: |
| m = m & self._gate_mask(g['parent'], X, cache) |
| cache[gid] = m |
| return m |
|
|
| def _cmd_statistics_read(self, source, gates=None, parameters=None, compensation='recorded'): |
| self._need_plant() |
| if source == 'live': |
| n = self.live_n |
| X = np.roll(self.live, -self.live_pos, axis=0)[-n:] if n == LIVE_BUFFER else self.live[:n] |
| S, on = self.S, self.comp_on |
| else: |
| r = self._record_of(source) |
| X = r['data'][:r['n']] |
| S, on = (r['S'], r['comp_on']) if compensation == 'recorded' else (self.S, self.comp_on) |
| gates = list(gates) if gates is not None else sorted(self.gates) |
| if any(g not in self.gates for g in gates): |
| raise ActionRejected('UNKNOWN_GATE') |
| Xc = self._compensate(X, S, on) |
| cache = {} |
| rows = [] |
| tot = len(Xc) |
| params = parameters or [] |
|
|
| def prow(sel): |
| out = [] |
| for p in params: |
| v = Xc[sel, PIDX[p]] if len(Xc) else np.zeros(0) |
| if len(v) == 0: |
| out.append(dict(parameter=p, mean=None, median=None, cv=None, rcv=None)) |
| continue |
| mean, med = float(np.mean(v)), float(np.median(v)) |
| q1, q3 = np.percentile(v, [25, 75]) |
| out.append(dict(parameter=p, mean=mean, median=med, cv=float(np.std(v) / mean) if mean > 0 else None, |
| rcv=float(0.7413 * (q3 - q1) / med) if med > 0 else None)) |
| return out |
| rows.append(dict(gate='All Events', events=int(tot), pct_parent=None, pct_total=100.0 if tot else None, parameters=prow(np.ones(tot, bool)))) |
| for gid in gates: |
| m = self._gate_mask(gid, Xc, cache) |
| par = self.gates[gid]['parent'] |
| pn = int(np.count_nonzero(self._gate_mask(par, Xc, cache))) if par else tot |
| n = int(np.count_nonzero(m)) |
| rows.append(dict(gate=gid, events=n, pct_parent=100.0 * n / pn if pn else None, pct_total=100.0 * n / tot if tot else None, parameters=prow(m))) |
| return dict(source=source, total_events=int(tot), compensated=bool(on), rows=rows) |
|
|
| def _cmd_record_read(self, record_id, parameters, max_events, compensation='recorded'): |
| r = self._record_of(record_id) |
| S, on = (r['S'], r['comp_on']) if compensation == 'recorded' else (self.S, self.comp_on) |
| X = self._compensate(r['data'][:r['n']], S, on) |
| idx = np.linspace(0, len(X) - 1, min(max_events, len(X))).astype(int) if len(X) else np.zeros(0, int) |
| cols = [PIDX[p] for p in parameters] |
| return dict(record_id=record_id, parameters=list(parameters), events=[[float(v) for v in X[i, cols]] for i in idx], total_events=int(r['n']), |
| compensated=bool(on)) |
|
|
| def _cmd_records_list(self): |
| return dict(records=[dict(record_id=k, events=int(r['n']), tube_id=r['tube_id'], started_s=r['started_s'], finished_s=r['finished_s'], compensated=bool(r['comp_on'])) |
| for k, r in self.records.items()]) |
|
|
| def _cmd_data_export(self, record_id, kind, compensation='recorded'): |
| r = self._record_of(record_id) |
| S, on = (r['S'], r['comp_on']) if compensation == 'recorded' else (self.S, self.comp_on) |
| X = self._compensate(r['data'][:r['n']], S, on) |
| en = [p for p in PARAMS if p == 'Time' or p.split('-')[0] in r['detectors']] |
| cols = [PIDX[p] for p in en] |
| lines = [','.join(en)] + [','.join(f'{v:.6g}' for v in row) for row in X[:, cols]] |
| text = '\n'.join(lines) + '\n' |
| name = f'{record_id}.csv' |
| self.exports[name] = text |
| self._event('data', 'EXPORT', f'导出{name}（{len(X)}个事件）', record_id) |
| return dict(file=name, bytes=len(text.encode()), rows=int(len(X)), compensated=bool(on)) |
|
|
| def _cmd_acquisition_record(self, record_id, events, storage_gate=None, stopping_gate=None, max_time_s=None): |
| self._need_power() |
| if record_id in self.records or any(op.get('record_id') == record_id for op in self._running_ops('acquisition.record')): |
| raise ActionRejected('ITEM_EXISTS') |
| if len(self.records) >= MAX_RECORDS: |
| raise ActionRejected('TOO_MANY_ITEMS') |
| if self._stored + events > MAX_STORED_EVENTS: |
| raise ActionRejected('STORAGE_FULL') |
| for g in (storage_gate, stopping_gate): |
| if g is not None and g not in self.gates: |
| raise ActionRejected('UNKNOWN_GATE') |
| if self._running_ops('acquisition.record'): |
| raise ActionRejected('RECORDING_IN_PROGRESS') |
| if self.port['state'] not in ('loading', 'up') or not self.acq_on: |
| raise ActionRejected('NOT_ACQUIRING') |
| op = self._new_op('acquisition.record', max_time_s, record_id=record_id, target=int(events), storage_gate=storage_gate, stopping_gate=stopping_gate) |
| self.records[record_id] = dict(data=np.zeros((min(events, MAX_RECORD_EVENTS), NPAR), np.float32), n=0, stop_count=0, tube_id=self.port['tube'], |
| started_s=self.t, finished_s=None, S=self.S.copy(), comp_on=self.comp_on, detectors=list(self.settings['detectors_enabled']), |
| labels=np.zeros(min(events, MAX_RECORD_EVENTS), np.int32), op_id=op['op_id']) |
| self._stored += events |
| self._own('record:' + record_id) |
| self._event('record', 'RECORD_START', f'开始记录{record_id}（{events}个事件）', record_id) |
| return dict(operation_id=op['op_id']) |
|
|
| def _finish_record(self, op, ok=True, code=None): |
| r = self.records[op['record_id']] |
| r['finished_s'] = self.t |
| op['finished_s'] = self.t |
| if ok: |
| op['phase'] = 'succeeded' |
| else: |
| op['phase'] = 'failed' |
| op['error'] = code |
| op['result'] = dict(record_id=op['record_id'], events=int(r['n'])) |
| self._event('record', 'RECORD_DONE' if ok else 'RECORD_STOPPED', f'记录{op["record_id"]}结束（{r["n"]}个事件）', op['record_id']) |
|
|
| |
| def _cmd_collection_install(self, device, prefill_m3=0.0): |
| self._need_plant() |
| if self.doors['sort_chamber'] < DOOR_OPEN_RAD - 1e-9: |
| raise ActionRejected('DOOR_CLOSED') |
| if self.collection is not None: |
| raise ActionRejected('DEVICE_INSTALLED') |
| dv = DEVICES[device] |
| if dv['kind'] == 'tubes': |
| locs = list(dv['locations']) |
| cap_ = TUBE_TYPES[dv['tube']]['capacity_m3'] |
| else: |
| locs = [f'{r}{c}' for r in dv['rows'] for c in range(1, dv['cols'] + 1)] |
| cap_ = dv['well_m3'] |
| if prefill_m3 > cap_: |
| raise ActionRejected('VOLUME_OUT_OF_RANGE') |
| self.collection = dict(device=device, capacity_m3=cap_, locs={k: dict(volume_m3=float(prefill_m3), counts={}) for k in locs}) |
| self._own('collection') |
| return dict(device=device, locations=locs) |
|
|
| def _cmd_collection_remove(self): |
| self._need_plant() |
| if self.collection is None: |
| raise ActionRejected('NO_DEVICE') |
| if self.doors['sort_chamber'] < DOOR_OPEN_RAD - 1e-9: |
| raise ActionRejected('DOOR_CLOSED') |
| if self._running_ops('sort.start'): |
| raise ActionRejected('SORT_IN_PROGRESS') |
| made = [] |
| self.seq['col'] += 1 |
| dv = DEVICES[self.collection['device']] |
| if dv['kind'] == 'tubes': |
| for loc, c in self.collection['locs'].items(): |
| if c['volume_m3'] <= 0: |
| continue |
| sid = f'sorted_{self.seq["col"]}_{loc}' |
| self.samples[sid] = dict(volume_m3=c['volume_m3'], counts=dict(c['counts']), origin='sorted') |
| self._own('sample:' + sid) |
| made.append(sid) |
| self.collection = None |
| self._event('sort', 'COLLECTION_REMOVED', '取出收集装置' + (f'：{", ".join(made)}' if made else '')) |
| return dict(samples=made) |
|
|
| def _cmd_sort_layout(self, layout_id, device, precision_mode, targets, masks=None, target_events=None, events_per_well=None, wells=None): |
| self._need_plant() |
| if len(self.layouts) >= MAX_LAYOUTS and layout_id not in self.layouts: |
| raise ActionRejected('TOO_MANY_ITEMS') |
| if any(op.get('layout_id') == layout_id for op in self._running_ops('sort.start')): |
| raise ActionRejected('SORT_IN_PROGRESS') |
| dv = DEVICES[device] |
| if dv['kind'] == 'tubes': |
| if not set(targets) <= set(dv['locations']) or events_per_well is not None or wells is not None: |
| raise ActionRejected('INVALID_LAYOUT') |
| if target_events is not None and not set(target_events) <= set(targets): |
| raise ActionRejected('INVALID_LAYOUT') |
| else: |
| if set(targets) != {'plate'} or events_per_well is None: |
| raise ActionRejected('INVALID_LAYOUT') |
| allw = [f'{r}{c}' for r in dv['rows'] for c in range(1, dv['cols'] + 1)] |
| if wells is not None and (not set(wells) <= set(allw) or len(set(wells)) != len(wells)): |
| raise ActionRejected('INVALID_LAYOUT') |
| if any(g not in self.gates for g in targets.values()): |
| raise ActionRejected('UNKNOWN_GATE') |
| if precision_mode == 'custom': |
| if masks is None: |
| raise ActionRejected('INVALID_LAYOUT') |
| m = dict(masks) |
| else: |
| if masks is not None: |
| raise ActionRejected('INVALID_LAYOUT') |
| y, p_, ph, sc = PRECISION[precision_mode] |
| m = dict(yield_mask=y, purity_mask=p_, phase_mask=ph, single_cell=sc) |
| if m['phase_mask'] > 0 or m['single_cell']: |
| m['yield_mask'] = 0 |
| self.layouts[layout_id] = dict(device=device, precision_mode=precision_mode, masks=m, targets=dict(targets), target_events=dict(target_events or {}), |
| events_per_well=events_per_well, wells=list(wells) if wells else None) |
| self._own('layout:' + layout_id) |
| return dict(layout_id=layout_id, masks=m) |
|
|
| |
| def _cmd_sort_start(self, layout_id): |
| self._need_power() |
| lay = self.layouts.get(layout_id) |
| if lay is None: |
| raise ActionRejected('UNKNOWN_LAYOUT') |
| if self._running_ops('sort.start', 'sort.auto_drop_delay', 'cst.performance_check'): |
| raise ActionRejected('SORT_IN_PROGRESS') |
| if self.collection is None or self.collection['device'] != lay['device']: |
| raise ActionRejected('DEVICE_MISMATCH') |
| if not self.stream: |
| raise ActionRejected('STREAM_OFF') |
| if not self.defl['voltage_on']: |
| raise ActionRejected('PLATES_OFF') |
| if self.port['state'] not in ('loading', 'up') or not self.acq_on: |
| raise ActionRejected('NOT_ACQUIRING') |
| if DEVICES[lay['device']]['kind'] == 'plate' and self.doors['sort_chamber'] > DOOR_CLOSED_RAD: |
| raise ActionRejected('DOOR_OPEN') |
| op = self._new_op('sort.start', None, layout_id=layout_id) |
| dv = DEVICES[lay['device']] |
| wells = None |
| if dv['kind'] == 'plate': |
| wells = lay['wells'] or [f'{r}{c}' for r in dv['rows'] for c in range(1, dv['cols'] + 1)] |
| self.sortrun = dict(op_id=op['op_id'], layout_id=layout_id, layout=copy.deepcopy(lay), state='sorting', started_s=self.t, elapsed_s=0.0, |
| counts={k: 0 for k in (lay['targets'] if dv['kind'] == 'tubes' else ['plate'])}, conflicts=0, wells=wells, well_i=0, well_n=0, |
| conflicts_by_location={k: 0 for k in (lay['targets'] if dv['kind'] == 'tubes' else ['plate'])}, |
| move_until=-1.0, error=None, sorted_hist=[]) |
| self.drawer_open = True |
| self._event('sort', 'SORT_START', f'开始分选（{layout_id}，{lay["precision_mode"]}）', op['op_id']) |
| return dict(operation_id=op['op_id']) |
|
|
| def _active_sort(self): |
| sr = self.sortrun |
| if sr is None or not self._running_ops('sort.start'): |
| raise ActionRejected('NOT_SORTING') |
| return sr |
|
|
| def _cmd_sort_pause(self): |
| self._need_power() |
| sr = self._active_sort() |
| if sr['state'] != 'sorting': |
| raise ActionRejected('NOT_SORTING') |
| sr['state'] = 'paused' |
| return dict(state='paused') |
|
|
| def _cmd_sort_resume(self): |
| self._need_power() |
| sr = self._active_sort() |
| if sr['state'] != 'paused': |
| raise ActionRejected('NOT_PAUSED') |
| sr['state'] = 'sorting' |
| return dict(state='sorting') |
|
|
| def _cmd_sort_auto_drop_delay(self): |
| self._need_power() |
| if self._running_ops('sort.start', 'sort.auto_drop_delay', 'cst.performance_check'): |
| raise ActionRejected('SORT_IN_PROGRESS') |
| if not self.stream: |
| raise ActionRejected('STREAM_OFF') |
| if not self.sweet: |
| raise ActionRejected('SWEET_SPOT_OFF') |
| if not self.defl['voltage_on']: |
| raise ActionRejected('PLATES_OFF') |
| if not self._tube_has(lambda s: s['accudrop']): |
| raise ActionRejected('ACCUDROP_BEADS_REQUIRED') |
| if self.port['state'] != 'up' or not self.acq_on: |
| raise ActionRejected('NOT_ACQUIRING') |
| base = round(self.dd_set) |
| steps = [('initial', float(base + k)) for k in range(-3, 4)] |
| op = self._new_op('sort.auto_drop_delay', None, steps=steps, step_i=0, step_t=self.t, scores=[], fine=False, base=base) |
| self.defl['optical_filter_in'] = True |
| self._event('sort', 'AUTO_DROP_DELAY', 'Accudrop自动液滴延迟开始（粗扫7点、细扫13点，每点5 s）', op['op_id']) |
| return dict(operation_id=op['op_id']) |
|
|
| def _cmd_cst_performance_check(self): |
| self._need_power() |
| if self._running_ops('sort.start', 'sort.auto_drop_delay', 'cst.performance_check'): |
| raise ActionRejected('SORT_IN_PROGRESS') |
| if not self._tube_has(lambda s: s['particle_id'].startswith('cst_bead')): |
| raise ActionRejected('CST_BEADS_REQUIRED') |
| if self.port['state'] != 'up' or not self.acq_on: |
| raise ActionRejected('NOT_ACQUIRING') |
| op = self._new_op('cst.performance_check', 300.0) |
| self._event('cst', 'CST_START', 'CS&T性能检查开始（约5 min）', op['op_id']) |
| return dict(operation_id=op['op_id']) |
|
|
| def _tube_has(self, pred): |
| tid = self.port['tube'] |
| if tid is None: |
| return False |
| tb = self.tubes[tid] |
| return any(n > 0 and pred(self.popspec[k]) for k, n in tb['counts'].items()) |
|
|
| def _finish_cst(self, op): |
| ok = True |
| rows = [] |
| j = self._jet() |
| true_d = self._true_laser_delays() |
| true_a = self._true_asf() |
| rng = _rng(self.plant['noise_seed'], 21, self.tick) |
| for L in LASERS: |
| P, extra = self._laser_power(L) |
| if P <= 0: |
| ok = False |
| continue |
| self.settings['laser_delays_s'][L] = true_d[L] + (0.0 if L == 'blue' else float(rng.normal(0.0, 0.2e-6))) |
| self.settings['area_scaling'][L] = true_a[L] * (1.0 + float(rng.normal(0.0, 0.01))) |
| pb = _photon() |
| t_ratio = (BEAM_H / j['v_cuv']) / pb['t_ref'] if j['v_cuv'] > 0 else 0.0 |
| R = math.sqrt(self._flow_m3_s() / max(j['v_core'], 1e-9) / math.pi) if j['v_core'] > 0 else 0.0 |
| pos_rcv = R * R / (2.0 * (BEAM_W / 2) ** 2) |
| bright = 2.0e5 |
| for i, det in enumerate(FL_DETS): |
| L = DET_LASER[det] |
| P, extra = self._laser_power(L) |
| pe = bright * sum(pb['q'][pb['didx'][d], i] for d in BEAD_DYES) * t_ratio * P |
| if pe <= 0: |
| rows.append(dict(detector=det, rcv=None, passed=False)) |
| ok = False |
| continue |
| rcv = math.sqrt(0.02 ** 2 + 1.0 / pe + (LASER_NOISE + extra) ** 2 + pos_rcv ** 2) |
| passed = rcv < 0.06 and self._laser_warm(L) |
| ok = ok and passed |
| rows.append(dict(detector=det, rcv=rcv, passed=passed)) |
| self.cst_status = 'passed' if ok else 'failed' |
| self.cst_result = rows |
| op['phase'] = 'succeeded' |
| op['finished_s'] = self.t |
| op['result'] = dict(status=self.cst_status, detectors=rows) |
| self._event('cst', 'CST_DONE', f'CS&T性能检查{"通过" if ok else "未通过"}；已设定激光延迟与面积系数', op['op_id']) |
|
|
| def _auto_dd_tick(self, op, bo, stats): |
| """Accudrop automatic drop delay: every scan point lasts 5 s; its score is the left-stream share of the Accudrop beads that the lower camera (filter in) |
| saw during those 5 s.""" |
| if not (self.stream and self.defl['voltage_on'] and self.acq_on and self.port['state'] == 'up' and bo is not None): |
| self._fail_op(op, 'CONDITIONS_LOST') |
| return |
| cam = op.setdefault('cam', [0, 0]) |
| cam[0] += int(stats['al']) |
| cam[1] += int(stats['ac']) |
| if self.t - op['step_t'] < 5.0 - 1e-9: |
| return |
| mode, dd = op['steps'][op['step_i']] |
| n = cam[0] + cam[1] |
| op['scores'].append((dd, float(cam[0]) / n if n > 0 else 0.0)) |
| op['cam'] = [0, 0] |
| op['step_i'] += 1 |
| op['step_t'] = self.t |
| if op['step_i'] >= len(op['steps']): |
| if not op['fine']: |
| best = max(op['scores'], key=lambda x: x[1])[0] |
| op['steps'] = [('fine_tune', round(best + 0.1 * k, 2)) for k in range(-6, 7)] |
| op['step_i'] = 0 |
| op['scores_coarse'] = op['scores'] |
| op['scores'] = [] |
| op['fine'] = True |
| else: |
| sc = sorted(op['scores'], key=lambda x: -x[1])[:3] |
| wsum = sum(s for _, s in sc) |
| best = sum(d * s for d, s in sc) / wsum if wsum > 0 else sc[0][0] |
| self.dd_set = float(min(140.0, max(10.0, round(best, 2)))) |
| op['phase'] = 'succeeded' |
| op['finished_s'] = self.t |
| op['result'] = dict(drop_delay_drops=self.dd_set, left_stream_fraction=max(s for _, s in op['scores']), |
| coarse=[dict(drops=d, fraction=s) for d, s in op['scores_coarse']], fine=[dict(drops=d, fraction=s) for d, s in op['scores']]) |
| self._event('sort', 'AUTO_DROP_DELAY_DONE', f'自动液滴延迟完成：{self.dd_set:.2f}滴', op['op_id']) |
|
|
| def _dd_sigma(self, bo): |
| s = DD_JITTER |
| if 'flow_cell_bubble' in self.faults: |
| s += 0.2 |
| if bo is not None and bo['gap'] is not None: |
| s += 0.01 * max(0.0, abs(bo['gap'] - self.bo['gap_target_px']) - 1.0) |
| return s |
|
|
| |
| def _tube_draw(self, tb, q_s, rng): |
| """Units drawn from the loaded tube in this tick: dict of arrays (pop key index, multiplicity, t).""" |
| vol = tb['volume_m3'] |
| dead = TUBE_TYPES[tb['type']]['dead_m3'] |
| avail = max(0.0, vol - dead) |
| dv = min(q_s * DT, avail) |
| if dv <= 0: |
| return None, 0.0 |
| keys = sorted(tb['counts']) |
| h = vol / (math.pi * TUBE_TYPES[tb['type']]['radius_m'] ** 2) |
| out = [] |
| for ki, k in enumerate(keys): |
| n_av = tb['counts'][k] |
| if n_av <= 0: |
| continue |
| sp = self.popspec[k] |
| susp = 1.0 if tb['settle'].get(k, 0.0) < max(h - PROBE_HEIGHT_M, 0.0) else 0.0 |
| lam = n_av / vol * dv * susp |
| df = sp['doublet_fraction'] |
| nu = int(rng.poisson(lam / (1.0 + df))) if lam > 0 else 0 |
| if nu == 0: |
| continue |
| m = 1 + (rng.random(nu) < df).astype(np.int64) |
| cum = np.cumsum(m) |
| keep = cum <= n_av |
| m = m[keep] |
| if len(m) == 0: |
| continue |
| tb['counts'][k] = n_av - float(m.sum()) |
| out.append((k, m)) |
| tb['volume_m3'] = vol - dv |
| self.led['sample_used_m3'].add(dv) |
| return out, dv |
|
|
| def _signals(self, draws, rng, j, t0): |
| """Per-unit detector values (A_true before area scaling, H, A, W per detector), arrival times, labels.""" |
| pb = _photon() |
| pl = particles() |
| fl = fluorochromes() |
| t_ratio = (BEAM_H / j['v_cuv']) / pb['t_ref'] |
| v_core = j['v_core'] |
| tau_s = BEAM_H / v_core |
| |
| keys, mult, D1, D2, lab = [], [], [], [], [] |
| dye_list = ['fluorescein_fitc'] |
| for k, m in draws: |
| sp = self.popspec[k] |
| for st in sp['stains']: |
| if st['dye'] not in dye_list: |
| dye_list.append(st['dye']) |
| if sp['peaks']: |
| for d in BEAD_DYES: |
| if d not in dye_list: |
| dye_list.append(d) |
| di = {d: i for i, d in enumerate(dye_list)} |
| n_tot = sum(len(m) for _, m in draws) |
| M = np.zeros((n_tot, len(dye_list))) |
| sf = np.zeros(n_tot) |
| ss = np.zeros(n_tot) |
| Deff = np.zeros(n_tot) |
| accu = np.zeros(n_tot, bool) |
| cells = np.zeros(n_tot) |
| lab = np.zeros(n_tot, np.int32) |
| pos0 = 0 |
| key_ids = [] |
| for kk, (k, m) in enumerate(draws): |
| sp = self.popspec[k] |
| n = len(m) |
| sl = slice(pos0, pos0 + n) |
| two = m == 2 |
| cv = sp['diameter_cv'] |
| d1 = sp['diameter_m'] * np.exp(cv * rng.standard_normal(n)) |
| d2 = sp['diameter_m'] * np.exp(cv * rng.standard_normal(n)) * two |
| lib = pl[sp['particle_id']] |
| tab = lib['scatter'] |
| lg = np.log(tab['diameter_um']) |
| lf, ls = np.log(tab['fsc_cross_section_m2']), np.log(tab['ssc_cross_section_m2']) |
| def xs(d, table): |
| return np.where(d > 0, np.exp(np.interp(np.log(np.maximum(d, 1e-9) * 1e6), lg, table)), 0.0) |
| gran = lib['granularity_factor'] |
| sf[sl] = xs(d1, lf) + xs(d2, lf) |
| ss[sl] = (xs(d1, ls) + xs(d2, ls)) * gran |
| Deff[sl] = d1 + d2 |
| dead1 = rng.random(n) < sp['dead_fraction'] |
| dead2 = (rng.random(n) < sp['dead_fraction']) & two |
| for st in sp['stains']: |
| sig = math.sqrt(math.log(1.0 + st['cv'] ** 2)) |
| for dead, w in ((dead1, np.ones(n)), (dead2, two.astype(float))): |
| app = np.ones(n) if st['target'] == 'all' else (dead if st['target'] == 'dead' else ~dead).astype(float) |
| M[sl, di[st['dye']]] += st['molecules'] * np.exp(sig * rng.standard_normal(n) - sig * sig / 2) * app * w |
| if sp['peaks']: |
| lev = np.array(sp['peaks'])[rng.integers(0, len(sp['peaks']), n)] |
| for d in BEAD_DYES: |
| M[sl, di[d]] += lev * np.exp(0.03 * rng.standard_normal(n)) * (1 + two) |
| af = lib.get('autofluorescence_fitc_mesf', 0.0) |
| if af: |
| M[sl, di['fluorescein_fitc']] += af * np.exp(0.3 * rng.standard_normal(n) - 0.045) * (1 + two) |
| accu[sl] = sp['accudrop'] |
| cells[sl] = m |
| lab[sl] = kk |
| key_ids.append(k) |
| pos0 += n |
| t = t0 + rng.random(n_tot) * DT |
| if n_tot > 1: |
| o = np.argsort(t, kind='stable') |
| gap = 0.5 * (Deff[o][:-1] + Deff[o][1:]) / max(v_core, 1e-9) |
| G = np.concatenate([[0.0], np.cumsum(gap)]) |
| t[o] = G + np.maximum.accumulate(t[o] - G) |
| |
| R = math.sqrt(self._flow_m3_s() / v_core / math.pi) |
| yv = R * np.sqrt(rng.random(n_tot)) * np.cos(2 * math.pi * rng.random(n_tot)) |
| pos = np.exp(-2.0 * yv ** 2 / (BEAM_W / 2) ** 2) |
| if 'flow_cell_bubble' in self.faults: |
| pos *= np.clip(1.0 + 0.06 * rng.standard_normal(n_tot), 0.2, 2.0) |
| shut = 0.0 if self._shutter() else 1.0 |
| Prel, noise = {}, {} |
| for L in LASERS: |
| P, extra = self._laser_power(L) |
| Prel[L] = P * shut |
| noise[L] = np.clip(1.0 + (LASER_NOISE + extra) * rng.standard_normal(n_tot), 0.0, None) |
| tau_p = np.sqrt(tau_s ** 2 + (PULSE_K * Deff / v_core) ** 2) |
| true_d = self._true_laser_delays() |
| true_a = self._true_asf() |
| ext = self.settings['window_extension_s'] |
| cap = {} |
| for L in LASERS: |
| dlt = abs(self.settings['laser_delays_s'][L] - true_d[L]) |
| hw = tau_p / 2.0 + ext |
| sg = tau_p / 4.0 |
| cap[L] = (_phi_v((hw - dlt) / sg) - _phi_v((-hw - dlt) / sg)) if dlt > 1e-12 else np.ones(n_tot) |
| V = self.settings['voltages'] |
| en = 8.0 |
| out = np.zeros((n_tot, NPAR)) |
| Atrue = np.zeros((n_tot, len(DETS))) |
| |
| idxd = [pb['didx'][d] for d in dye_list] |
| for jd, det in enumerate(FL_DETS): |
| L = DET_LASER[det] |
| P = Prel[L] |
| if P <= 0: |
| pe = np.zeros(n_tot) |
| bg = 0.0 |
| else: |
| kt = pb['ktau'][idxd, jd] |
| qe = pb['q'][idxd, jd] * t_ratio * P * (1.0 + kt) / (1.0 + kt * P) |
| pe = (M @ qe) * pos * noise[L] |
| bg = pb['bg'][jd] * t_ratio * P |
| pe_m = rng.poisson(pe + bg).astype(float) - bg |
| Atrue[:, 2 + jd] = pe_m * _pmt_gain(V[det]) * K_CH * cap[L] |
| |
| P = Prel['blue'] |
| ph_f = sf * pb['flux']['blue'] * (BEAM_H / j['v_cuv']) * P * pos * noise['blue'] |
| Atrue[:, 0] = ph_f * pb['k_fsc'] * _fsc_gain(V['FSC']) |
| pe_s = ss * pb['flux']['blue'] * (BEAM_H / j['v_cuv']) * P * pos * noise['blue'] * pb['t_ssc'] |
| pe_s = pe_s + np.sqrt(np.maximum(pe_s, 0.0)) * rng.standard_normal(n_tot) |
| Atrue[:, 1] = pe_s * _pmt_gain(V['SSC']) * K_CH |
| for jd, det in enumerate(DETS): |
| L = DET_LASER[det] |
| e = math.sqrt(en ** 2 + FSC_NOISE_CH ** 2) if det == 'FSC' else en |
| H = Atrue[:, jd] * tau_s / tau_p + e * rng.standard_normal(n_tot) |
| A = Atrue[:, jd] * self.settings['area_scaling'][L] / max(true_a[L], 1e-9) + e * rng.standard_normal(n_tot) |
| H = np.clip(H, -2000.0, ADC_MAX) |
| A = np.clip(A, -2000.0, ADC_MAX) |
| out[:, 3 * jd] = A |
| out[:, 3 * jd + 1] = H |
| out[:, 3 * jd + 2] = np.clip(WIDTH_SCALE * A / np.maximum(H, 1.0), 0.0, ADC_MAX) |
| out[:, -1] = t |
| order = np.argsort(t, kind='stable') |
| return dict(vals=out[order], t=t[order], lab=lab[order], cells=cells[order], accu=accu[order], tau=tau_p[order], keys=key_ids) |
|
|
| def _threshold(self, vals): |
| en = self.settings['detectors_enabled'] |
| masks = [] |
| for th in self.settings['thresholds']: |
| if th['parameter'] not in en: |
| continue |
| masks.append(vals[:, PIDX[f'{th["parameter"]}-H']] > th['value']) |
| if not masks: |
| return np.zeros(len(vals), bool) |
| m = masks[0] |
| for x in masks[1:]: |
| m = (m | x) if self.settings['threshold_logic'] == 'or' else (m & x) |
| return m |
|
|
| def _merge(self, sig, det_idx): |
| """Pulse pile-up: detected units closer than the previous pulse + window extension form one event (summed areas).""" |
| t = sig['t'][det_idx] |
| tau = sig['tau'][det_idx] |
| vals = sig['vals'][det_idx] |
| if len(t) == 0: |
| return vals, t, det_idx, np.zeros(0, int) |
| ext = self.settings['window_extension_s'] |
| new = np.ones(len(t), bool) |
| new[1:] = (t[1:] - t[:-1]) >= (tau[:-1] + ext) |
| gid = np.cumsum(new) - 1 |
| starts = np.nonzero(new)[0] |
| ev = vals[starts].copy() |
| sizes = np.bincount(gid) |
| for g in np.nonzero(sizes > 1)[0]: |
| mem = np.nonzero(gid == g)[0] |
| dtm = t[mem] - t[mem[0]] |
| for jd in range(len(DETS)): |
| A = vals[mem, 3 * jd] |
| H = vals[mem, 3 * jd + 1] |
| k = int(np.argmax(H)) |
| over = np.clip(1.0 - np.abs(dtm - dtm[k]) / np.maximum(tau[mem], 1e-12), 0.0, 1.0) |
| Hm = H[k] + float(np.sum(np.where(np.arange(len(mem)) == k, 0.0, H * over))) |
| Am = float(np.sum(A)) |
| ev[g, 3 * jd] = min(Am, ADC_MAX) |
| ev[g, 3 * jd + 1] = min(Hm, ADC_MAX) |
| ev[g, 3 * jd + 2] = min(WIDTH_SCALE * Am / max(Hm, 1.0), ADC_MAX) |
| self.led['coincident_particles'].add(float(len(t) - len(starts))) |
| return ev, t[starts], det_idx[starts], gid |
|
|
| def _classify(self, vals): |
| """Location index of each processed event for the running sort (first matching target in layout order), -1 for non-targets.""" |
| sr = self.sortrun |
| locs = self._sort_locs() |
| cls = np.full(len(vals), -1, np.int64) |
| if len(vals) == 0: |
| return cls |
| Xc = self._compensate(vals) |
| cache = {} |
| for li, loc in enumerate(locs): |
| g = sr['layout']['targets'][loc] |
| m = self._gate_mask(g, Xc, cache) & (cls < 0) |
| cls[m] = li |
| return cls |
|
|
| def _sort_locs(self): |
| lay = self.sortrun['layout'] |
| if DEVICES[lay['device']]['kind'] == 'plate': |
| return ['plate'] |
| return [s for s in STREAMS if s in lay['targets']] |
|
|
| def _sort_tick(self, sig, ev_t, ev_first, unit_event, ev_cls, bo, rng): |
| """Drop decisions (BD masks), conflicts, quotas and the fate of every particle drawn in this tick.""" |
| sr = self.sortrun |
| lay = sr['layout'] |
| dv = DEVICES[lay['device']] |
| locs = self._sort_locs() |
| nloc = len(locs) |
| f = bo['f'] |
| mk = lay['masks'] |
| Y, P, Ph, single = mk['yield_mask'], mk['purity_mask'], mk['phase_mask'], mk['single_cell'] |
| xs = ev_t * f + self.dd_set |
| ks = np.floor(xs).astype(np.int64) |
| ph = np.floor((xs - ks) * 32.0) / 32.0 |
| ut = sig['t'] |
| kt_u = np.floor(ut * f + bo['dd_true'] + self._dd_sigma(bo) * rng.standard_normal(len(ut))).astype(np.int64) |
| allk = np.concatenate([ks, kt_u]) if len(ks) else kt_u |
| k0 = int(allk.min()) - 2 if len(allk) else 0 |
| size = int(allk.max()) - k0 + 3 if len(allk) else 3 |
| idx = ks - k0 |
| charged = np.full(size, -1, np.int64) |
| drop_well = np.full(size, -1, np.int64) |
| sorted_now = np.zeros(nloc, np.int64) |
| conflicts = 0 |
| drawer = self.drawer_pos >= DRAWER_TRAVEL - 1e-6 |
| active = sr['state'] == 'sorting' and not self.ss_paused and self.defl['voltage_on'] and self.t >= sr['move_until'] and drawer |
| if active and len(ks) and dv['kind'] == 'tubes': |
| for l_, loc in enumerate(locs): |
| tgt = lay['target_events'].get(loc) |
| if tgt is not None and sr['counts'][loc] >= tgt: |
| ev_cls = np.where(ev_cls == l_, -1, ev_cls) |
| if active and len(ks): |
| cnt_all = np.bincount(idx, minlength=size) |
| cnt_l = [np.bincount(idx[ev_cls == L], minlength=size) for L in range(nloc)] |
|
|
| def edges(m, sel): |
| lead = np.bincount(idx[sel & (ph < m / 64.0)], minlength=size) |
| trail = np.bincount(idx[sel & (ph >= 1.0 - m / 64.0)], minlength=size) |
| return lead, trail |
| tg = np.nonzero(ev_cls >= 0)[0] |
| L = ev_cls[tg] |
| k = idx[tg] |
| phi = ph[tg] |
| ok = np.ones(len(tg), bool) |
| ext_lo = (phi < Y / 64.0) if Y > 0 else np.zeros(len(tg), bool) |
| ext_hi = (phi >= 1.0 - Y / 64.0) if Y > 0 else np.zeros(len(tg), bool) |
| k_lo = k - ext_lo.astype(np.int64) |
| k_hi = k + ext_hi.astype(np.int64) |
| if P > 0: |
| |
| |
| la, ta = edges(P, np.ones(len(ks), bool)) |
| for l_ in range(nloc): |
| sel = L == l_ |
| if not sel.any(): |
| continue |
| ll, tl = edges(P, ev_cls == l_) |
| other = np.concatenate([[0], np.cumsum(cnt_all - cnt_l[l_])]) |
| lo, hi = k_lo[sel], k_hi[sel] |
| inside = (other[hi + 1] - other[lo]) > 0 |
| bad = inside | ((ta[lo - 1] - tl[lo - 1]) > 0) | ((la[hi + 1] - ll[hi + 1]) > 0) |
| ok[sel] &= ~bad |
| if Ph > 0: |
| la, ta = edges(Ph, np.ones(len(ks), bool)) |
| ok &= ~((phi < Ph / 64.0) | (phi >= 1.0 - Ph / 64.0) | (ta[k - 1] > 0) | (la[k + 1] > 0)) |
| if single: |
| for l_ in range(nloc): |
| sel = L == l_ |
| ok[sel] &= cnt_l[l_][k[sel]] < 2 |
| conflicts += int(np.count_nonzero(~ok)) |
| for l_, loc in enumerate(locs): |
| sr['conflicts_by_location'][loc] = sr['conflicts_by_location'].get(loc, 0) + int(np.count_nonzero(~ok & (L == l_))) |
| acc = tg[ok] |
| if dv['kind'] == 'tubes': |
| keep = np.zeros(len(acc), bool) |
| for l_, loc in enumerate(locs): |
| sel = np.nonzero(ev_cls[acc] == l_)[0] |
| tgt = lay['target_events'].get(loc) |
| room = len(sel) if tgt is None else max(0, tgt - sr['counts'][loc]) |
| keep[sel[:room]] = True |
| acc = acc[keep] |
| req_k, req_l = [idx[acc]], [ev_cls[acc]] |
| if Y > 0: |
| lo = acc[ph[acc] < Y / 64.0] |
| hi = acc[ph[acc] >= 1.0 - Y / 64.0] |
| req_k += [idx[lo] - 1, idx[hi] + 1] |
| req_l += [ev_cls[lo], ev_cls[hi]] |
| rk = np.concatenate(req_k) |
| rl = np.concatenate(req_l) |
| first = np.full(size, -1, np.int64) |
| multi = np.zeros(size, bool) |
| for kk_, ll_ in zip(rk, rl): |
| if first[kk_] == -1: |
| first[kk_] = ll_ |
| elif first[kk_] != ll_: |
| multi[kk_] = True |
| charged = np.where(multi, -1, first) |
| main_ok = charged[idx[acc]] == ev_cls[acc] |
| conflicts += int(np.count_nonzero(~main_ok)) |
| for l_, loc in enumerate(locs): |
| sr['conflicts_by_location'][loc] += int(np.count_nonzero(~main_ok & (ev_cls[acc] == l_))) |
| for l_, loc in enumerate(locs): |
| n = int(np.count_nonzero(main_ok & (ev_cls[acc] == l_))) |
| sr['counts'][loc] += n |
| sorted_now[l_] += n |
| else: |
| ppw = lay['events_per_well'] |
| for e in acc: |
| if sr['well_i'] >= len(sr['wells']): |
| break |
| if ev_t[e] < sr['move_until']: |
| continue |
| charged[idx[e]] = 0 |
| drop_well[idx[e]] = sr['well_i'] |
| if Y > 0: |
| for kk_ in ((idx[e] - 1) if ph[e] < Y / 64.0 else -1, (idx[e] + 1) if ph[e] >= 1.0 - Y / 64.0 else -1): |
| if 0 <= kk_ < size and charged[kk_] < 0: |
| charged[kk_] = 0 |
| drop_well[kk_] = sr['well_i'] |
| sr['well_n'] += 1 |
| sr['counts']['plate'] += 1 |
| sorted_now[0] += 1 |
| if sr['well_n'] >= ppw: |
| sr['well_i'] += 1 |
| sr['well_n'] = 0 |
| sr['move_until'] = float(ev_t[e]) + dv['move_s'] |
| |
| valid = (kt_u >= k0) & (kt_u < k0 + size) |
| dest = np.full(len(ut), -1, np.int64) |
| dest[valid] = charged[kt_u[valid] - k0] |
| cells = sig['cells'] |
| coll = self.collection |
| pcap = np.zeros(nloc) |
| for l_, loc in enumerate(locs): |
| stream = dv['locations'][loc][0] if dv['kind'] == 'tubes' else dv['stream'] |
| x, sg = self._stream_x(stream, bo) |
| if x is None: |
| continue |
| xt = dv['locations'][loc][1] if dv['kind'] == 'tubes' else dv['x'] |
| pcap[l_] = _phi((xt + dv['capture_r'] - x) / sg) - _phi((xt - dv['capture_r'] - x) / sg) |
| u = rng.random(len(ut)) |
| n_drops = np.bincount(charged[charged >= 0], minlength=nloc) if (charged >= 0).any() else np.zeros(nloc, np.int64) |
| self.led['drops_deflected'].add(float(n_drops.sum())) |
| to_col = np.zeros(len(ut), bool) |
| for l_, loc in enumerate(locs): |
| sel = dest == l_ |
| got = sel & (u < pcap[l_]) & drawer |
| to_col |= got |
| self.led['particles_lost_off_target'].add(float(cells[sel & ~got].sum())) |
| if coll is None or not drawer: |
| continue |
| for li in np.nonzero(got)[0]: |
| tl = loc if dv['kind'] == 'tubes' else sr['wells'][drop_well[kt_u[li] - k0]] |
| c = coll['locs'][tl] |
| key = sig['keys'][sig['lab'][li]] |
| c['counts'][key] = c['counts'].get(key, 0.0) + float(cells[li]) |
| if dv['kind'] == 'tubes': |
| coll['locs'][loc]['volume_m3'] += float(n_drops[l_]) * bo['drop_m3'] * pcap[l_] |
| else: |
| for kk_ in np.nonzero(drop_well >= 0)[0]: |
| coll['locs'][sr['wells'][drop_well[kk_]]]['volume_m3'] += bo['drop_m3'] * pcap[l_] |
| self.led['particles_sorted'].add(float(cells[to_col].sum())) |
| vol_col = float(sum(n_drops[l_] * bo['drop_m3'] * pcap[l_] for l_ in range(nloc))) if drawer else 0.0 |
| if coll is not None: |
| self._spill(coll, _rng(self.plant['noise_seed'], 37, self.tick)) |
| centre = dest < 0 |
| if coll is not None and drawer and 'clog_partial' in self.faults and dv['kind'] == 'tubes': |
| xc, sc = self._centre_x() |
| best = min(locs, key=lambda q: abs(dv['locations'][q][1] - xc)) |
| xt = dv['locations'][best][1] |
| pc = _phi((xt + dv['capture_r'] - xc) / sc) - _phi((xt - dv['capture_r'] - xc) / sc) |
| leak = centre & (rng.random(len(ut)) < pc) |
| c = coll['locs'][best] |
| for li in np.nonzero(leak)[0]: |
| key = sig['keys'][sig['lab'][li]] |
| c['counts'][key] = c['counts'].get(key, 0.0) + float(cells[li]) |
| c['volume_m3'] += pc * bo['q'] * DT |
| vol_col += pc * bo['q'] * DT |
| self.led['particles_leaked_into_collection'].add(float(cells[leak].sum())) |
| centre &= ~leak |
| self.led['particles_to_waste'].add(float(cells[centre].sum())) |
| accu = sig['accu'] |
| left_i = locs.index('left') if 'left' in locs else (0 if dv['kind'] == 'plate' else None) |
| n_left = int(np.count_nonzero(accu & (dest == left_i))) if left_i is not None else 0 |
| n_cen = int(np.count_nonzero(accu & (dest < 0))) |
| return sorted_now, conflicts, n_left, n_cen, vol_col |
|
|
| def _spill(self, coll, rng): |
| """A collection tube / well that overfills spills the excess liquid; every particle leaves with the spilled share (binomial draw). Truth only: the |
| instrument has no level sensor, so the overflow is an evaluator event (once per location).""" |
| for loc, c in coll['locs'].items(): |
| if c['volume_m3'] > coll['capacity_m3']: |
| frac = 1.0 - coll['capacity_m3'] / c['volume_m3'] |
| lost = 0 |
| for k_ in sorted(c['counts']): |
| n0 = int(round(c['counts'][k_])) |
| m = int(rng.binomial(n0, frac)) if n0 > 0 else 0 |
| c['counts'][k_] = float(n0 - m) |
| lost += m |
| self.led['particles_spilled_from_collection'].add(float(lost)) |
| self.led['collection_spilled_m3'].add(c['volume_m3'] - coll['capacity_m3']) |
| c['volume_m3'] = coll['capacity_m3'] |
| if not c.get('overflow_reported'): |
| c['overflow_reported'] = True |
| self._event('truth', 'COLLECTION_OVERFLOW', f'收集位置{loc}溢出（真值；仪器没有液位传感）') |
|
|
| def _acquire_tick(self, bo, j): |
| """Sample flow, particle signals, thresholds, pile-up, aborts, live data, records, sorting, Accudrop camera.""" |
| stats = dict(det=0, proc=0, abort=0, sorted=0, al=0, ac=0) |
| tid = self.port['tube'] |
| if tid is None or self.port['state'] != 'up' or not self.acq_on or not self.stream or 'clog_full' in self.faults or self.sheath_p < 0.5 * self.sheath_set: |
| return stats, 0.0 |
| tb = self.tubes[tid] |
| q_s = self._flow_m3_s() * (1.0 - math.exp(-(self.t - self.port['t_up']) / 1.0)) |
| rng = _rng(self.plant['noise_seed'], 1, self.tick, _h(tid)) |
| draws, dv = self._tube_draw(tb, q_s, rng) |
| if draws is None: |
| return stats, 0.0 |
| if not draws: |
| sig = None |
| else: |
| sig = self._signals(draws, rng, j, self.t - DT) |
| if sig is None: |
| if self.sortrun is not None and self.sortrun['state'] == 'sorting': |
| self.sortrun['elapsed_s'] += DT |
| return stats, dv |
| cells = sig['cells'] |
| self.led['particles_drawn'].add(float(cells.sum())) |
| det = self._threshold(sig['vals']) |
| det_idx = np.nonzero(det)[0] |
| self.led['particles_detected'].add(float(cells[det_idx].sum())) |
| ev_vals, ev_t, ev_first, gid = self._merge(sig, det_idx) |
| unit_event = np.full(len(cells), -1, np.int64) |
| unit_event[det_idx] = gid |
| n_ev = len(ev_t) |
| cap_n = int(self._rate_limit() * DT) |
| aborted = np.zeros(n_ev, bool) |
| if n_ev > cap_n: |
| aborted[rng.choice(n_ev, n_ev - cap_n, replace=False)] = True |
| proc = ~aborted |
| stats.update(det=n_ev, proc=int(proc.sum()), abort=int(aborted.sum())) |
| self.led['events_processed'].add(float(proc.sum())) |
| self.led['electronic_aborts'].add(float(aborted.sum())) |
| vals = ev_vals[proc].astype(np.float32) |
| en = set(self.settings['detectors_enabled']) |
| for jd, d in enumerate(DETS): |
| if d not in en: |
| vals[:, 3 * jd:3 * jd + 3] = 0.0 |
| self.events_processed += len(vals) |
| self._live_append(vals) |
| labs = sig['lab'][ev_first[proc]] if len(ev_first) else np.zeros(0, np.int32) |
| for op in self._running_ops('acquisition.record'): |
| self._record_append(op, vals, labs, sig['keys']) |
| sr = self.sortrun |
| if sr is not None and sr['state'] in ('sorting', 'paused') and self._running_ops('sort.start') and bo is not None: |
| ev_cls = np.full(n_ev, -2, np.int64) |
| ev_cls[proc] = self._classify(vals.astype(np.float64)) |
| s_now, confl, al, ac, vol_col = self._sort_tick(sig, ev_t, ev_first, unit_event, ev_cls, bo, rng) |
| sr['conflicts'] += confl |
| stats.update(sorted=int(s_now.sum()), al=al, ac=ac) |
| if sr['state'] == 'sorting': |
| sr['elapsed_s'] += DT |
| dv += 0.0 |
| self._col_volume = vol_col |
| else: |
| self.led['particles_to_waste'].add(float(cells.sum())) |
| if self.defl['optical_filter_in']: |
| na = int(np.count_nonzero(sig['accu'])) |
| nl = 0 |
| run = self._running_ops('sort.auto_drop_delay') |
| if run and na and self.defl['voltage_on'] and self.defl['plate_voltage_v'] > 0 and bo is not None: |
| mode, dd = run[0]['steps'][run[0]['step_i']] |
| p = _deflected_fraction(bo['dd_true'] - dd, PRECISION[mode][0], self._dd_sigma(bo)) |
| nl = int(_rng(self.plant['noise_seed'], 29, self.tick).binomial(na, min(1.0, max(0.0, p)))) |
| stats.update(al=nl, ac=na - nl) |
| return stats, dv |
|
|
| def _live_append(self, vals): |
| n = len(vals) |
| if n == 0: |
| return |
| if n >= LIVE_BUFFER: |
| self.live[:] = vals[-LIVE_BUFFER:] |
| self.live_pos = 0 |
| self.live_n = LIVE_BUFFER |
| return |
| end = self.live_pos + n |
| if end <= LIVE_BUFFER: |
| self.live[self.live_pos:end] = vals |
| else: |
| k = LIVE_BUFFER - self.live_pos |
| self.live[self.live_pos:] = vals[:k] |
| self.live[:n - k] = vals[k:] |
| self.live_pos = end % LIVE_BUFFER |
| self.live_n = min(LIVE_BUFFER, self.live_n + n) |
|
|
| def _record_append(self, op, vals, labs, keys): |
| r = self.records[op['record_id']] |
| if len(vals) == 0: |
| return |
| X = vals.astype(np.float64) |
| Xc = self._compensate(X, r['S'], r['comp_on']) |
| cache = {} |
| keep = self._gate_mask(op['storage_gate'], Xc, cache) if op['storage_gate'] else np.ones(len(X), bool) |
| stop_m = self._gate_mask(op['stopping_gate'], Xc, cache) if op['stopping_gate'] else np.ones(len(X), bool) |
| cnt = np.cumsum(stop_m & keep) |
| need = op['target'] - r['stop_count'] |
| if cnt.size and cnt[-1] >= need: |
| last = int(np.searchsorted(cnt, need)) + 1 |
| else: |
| last = len(X) |
| sel = np.nonzero(keep[:last])[0] |
| room = len(r['data']) - r['n'] |
| sel = sel[:room] |
| r['data'][r['n']:r['n'] + len(sel)] = vals[sel] |
| r['labels'][r['n']:r['n'] + len(sel)] = [_h(keys[x]) for x in labs[sel]] if len(sel) else [] |
| r['n'] += len(sel) |
| r['stop_count'] += int(np.count_nonzero(stop_m[:last][keep[:last]][:len(sel)])) if len(sel) else 0 |
| if r['stop_count'] >= op['target'] or r['n'] >= len(r['data']): |
| self._finish_record(op) |
|
|
| |
| def step(self, dt_s): |
| """Advance the host clock: physics on the fixed 0.1 s grid (k * 0.1 s); state between grid points is held, so any split of the same interval |
| gives identical results.""" |
| if dt_s < 0: |
| raise ActionRejected('INVALID_ARGUMENT') |
| t_end = self.t + float(dt_s) |
| if self.plant is None: |
| self.t = t_end |
| return self.t |
| while (self.tick + 1) * DT <= t_end + 1e-9: |
| self.tick += 1 |
| self.t = self.tick * DT |
| self._physics_tick() |
| self.t = t_end |
| return self.t |
|
|
| def _physics_tick(self): |
| pl = self.plant |
| self.T_room += pl['room_drift_k_per_s'] * DT |
| warm = SHEATH_WARM_K if self.stream else 0.0 |
| if 'breakoff_drift' in self.faults: |
| warm += 2.0 * (1.0 - math.exp(-(self.t - self.fault_t.get('breakoff_drift', self.t)) / 600.0)) |
| self.T_sheath += (self.T_room + warm - self.T_sheath) * DT / SHEATH_WARM_TAU_S |
| closed = self.port['state'] == 'up' |
| sp = self.sample_sp if (self.power and self.sample_sp is not None) else None |
| tgt = sp if sp is not None else self.T_room |
| if sp is not None and not closed: |
| tgt = self.T_room + 0.4 * (sp - self.T_room) |
| self.T_chamber += (tgt - self.T_chamber) * DT / (SAMPLE_CHAMBER_TAU_S if closed else 2 * SAMPLE_CHAMBER_TAU_S) |
| ct = self.col_sp if (self.power and self.col_sp is not None) else self.T_room |
| self.T_col += (ct - self.T_col) * DT / COLLECTION_TAU_S |
| for tid, tb in self.tubes.items(): |
| tt = self.T_chamber if (tb['location'] == 'port' and closed) else self.T_room |
| tb['T'] += (tt - tb['T']) * DT / TUBE_TAU_S |
| r_ag = AGITATION[self.agitation] / AGITATION['300_rpm'] if (tb['location'] == 'port' and closed and self.power) else 0.0 |
| for k in tb['settle']: |
| sp_ = self.popspec[k] |
| drho = sp_['density_kg_m3'] - water_density(tb['T']) |
| v_s = max(0.0, 2.0 / 9.0 * drho * 9.80665 * (sp_['diameter_m'] / 2) ** 2 / water_viscosity(tb['T'])) |
| tb['settle'][k] += v_s * (1.0 - AGITATION_EFFECT * r_ag) * DT |
| |
| if self.power: |
| pw = BASE_POWER_W + sum(LASER_POWER_W[L] for L in LASERS if self.lasers[L]['on']) + (SAMPLE_TC_POWER_W if self.sample_sp is not None else 0.0) |
| self.led['electrical_energy_j'].add(pw * DT) |
| self.led['laser_on_time_s'].add(DT * sum(1 for L in LASERS if self.lasers[L]['on'])) |
| air_max = (40.0 * PSI if 'cart_air_leak' in self.faults else CART_AIR_PA) if self.power else 0.0 |
| tau = CART_AIR_TAU_S[0] if air_max > self.cart['air'] else CART_AIR_TAU_S[1] |
| self.cart['air'] += (air_max - self.cart['air']) * DT / tau |
| p_tgt = min(self.sheath_set, max(0.0, self.cart['air'] - 5.0 * PSI)) if (self.stream and self.power) else 0.0 |
| self.sheath_p += (p_tgt - self.sheath_p) * min(1.0, DT / SHEATH_TAU_S) |
| if not self.stream and self.sheath_p < 1.0: |
| self.sheath_p = 0.0 |
| |
| if self.port['state'] == 'loading': |
| self.port['pos'] = min(LOAD_TRAVEL, self.port['pos'] + PORT_SPEED * DT) |
| if self.port['pos'] >= LOAD_TRAVEL - 1e-12: |
| self.port.update(state='up', t_up=self.t) |
| elif self.port['state'] == 'unloading': |
| self.port['pos'] = max(0.0, self.port['pos'] - PORT_SPEED * DT) |
| if self.port['pos'] <= 1e-12: |
| self.port.update(state='down', pos=0.0) |
| dt_ = DRAWER_TRAVEL if (self.drawer_open and self.power) else 0.0 |
| if self.drawer_pos != dt_: |
| step_ = DRAWER_SPEED * DT |
| self.drawer_pos = min(dt_, self.drawer_pos + step_) if dt_ > self.drawer_pos else max(dt_, self.drawer_pos - step_) |
| |
| for op in self._running_ops('fluidics.startup', 'fluidics.shutdown', 'cleaning.run'): |
| if self.t >= op['ends_s'] - 1e-9: |
| self._finish_fluidics_op(op) |
| |
| bo = self._breakoff() |
| if self.stream and 'clog_full' in self.faults and self.sweet: |
| self._clog_protect() |
| bo = None |
| if self.sweet: |
| self.ss_paused = self._sweet_spot_tick(bo) |
| bo = self._breakoff() |
| else: |
| self.ss_paused = False |
| j = self._jet() |
| |
| stats, dv = dict(det=0, proc=0, abort=0, sorted=0, al=0, ac=0), 0.0 |
| self._col_volume = 0.0 |
| if self.stream and self.power and j['q'] > 0: |
| q_sheath = j['q'] |
| take = min(self.cart['sheath'], q_sheath * DT) |
| self.cart['sheath'] -= take |
| self.led['sheath_used_m3'].add(take) |
| self.led['drops_formed'].add(self.bo['frequency_hz'] * DT if bo is not None else 0.0) |
| stats, dv = self._acquire_tick(bo, j) |
| if 'clog_full' in self.faults and not self.sweet and self.collection is not None and self.drawer_pos >= DRAWER_TRAVEL - 1e-6: |
| spray = 0.005 * take |
| for c in self.collection['locs'].values(): |
| c['volume_m3'] += spray / max(1, len(self.collection['locs'])) |
| self._col_volume += spray |
| self._spill(self.collection, _rng(self.plant['noise_seed'], 38, self.tick)) |
| self.led['collection_added_m3'].add(self._col_volume) |
| self._to_waste(max(0.0, take + dv - self._col_volume)) |
| if self.cart['sheath'] <= 1e-9: |
| self._error('SHEATH_EMPTY', '鞘液罐空：液流停止') |
| self._stream_stop('SHEATH_EMPTY') |
| if self.cart['waste'] > fluidics()['reservoirs']['waste_m3']: |
| self._error('WASTE_OVERFLOW', '废液罐溢出') |
| self._warnings(bo) |
| |
| for op in self._running_ops('sort.auto_drop_delay'): |
| self._auto_dd_tick(op, bo, stats) |
| for op in self._running_ops('cst.performance_check'): |
| if not (self.acq_on and self.port['state'] == 'up' and self.stream): |
| self._fail_op(op, 'CONDITIONS_LOST') |
| elif self.t >= op['ends_s'] - 1e-9: |
| self._finish_cst(op) |
| for op in self._running_ops('acquisition.record'): |
| if op['ends_s'] is not None and self.t >= op['ends_s'] - 1e-9: |
| self._finish_record(op) |
| sr = self.sortrun |
| if sr is not None: |
| for op in self._running_ops('sort.start'): |
| if op['op_id'] != sr['op_id']: |
| continue |
| lay = sr['layout'] |
| if DEVICES[lay['device']]['kind'] == 'tubes': |
| done = bool(lay['target_events']) and all(sr['counts'][k] >= n for k, n in lay['target_events'].items()) |
| else: |
| done = sr['well_i'] >= len(sr['wells']) |
| if done: |
| sr['state'] = 'completed' |
| op['phase'] = 'succeeded' |
| op['finished_s'] = self.t |
| op['result'] = dict(counts=dict(sr['counts']), conflicts=sr['conflicts']) |
| self.drawer_open = False |
| self._event('sort', 'SORT_COMPLETE', '分选完成：' + '，'.join(f'{k} {v}' for k, v in sr['counts'].items()), op['op_id']) |
| |
| if self.stream and self.power: |
| gen = 500.0 if 'clog_full' in self.faults or 'clog_partial' in self.faults else (50.0 if (sr is not None and sr['state'] == 'sorting') else 5.0) |
| esc = 0.05 if self.doors['sort_chamber'] > DOOR_CLOSED_RAD else (1e-5 if self.amo['on'] and self.amo['mode'] == 'normal' else 1e-6 if self.amo['on'] else 1e-3) |
| n = _rng(pl['noise_seed'], 31, self.tick).poisson(gen * DT * esc) |
| self.led['aerosol_particles_escaped'].add(float(n)) |
| self.hist.append((stats['det'], stats['proc'], stats['abort'], stats['sorted'], stats['al'], stats['ac'])) |
| if len(self.hist) > 10: |
| self.hist.pop(0) |
| if self.collection is not None: |
| tot = sum(sum(c['counts'].values()) for c in self.collection['locs'].values()) |
| self.led['particles_in_collection'].s = float(tot) |
| self.led['particles_in_collection'].c = 0.0 |
|
|
| def _warnings(self, bo): |
| w = {} |
| res = fluidics()['reservoirs'] |
| low = self.cart['sheath'] < 0.1 * res['sheath_m3'] |
| full = self.cart['waste'] > 0.9 * res['waste_m3'] |
| if self.power and low: |
| w['SHEATH_LOW'] = '鞘液罐液位低' |
| if self.power and full: |
| w['WASTE_FULL'] = '废液罐将满' |
| if self.stream and (low or full): |
| lw = self.level_warn |
| if lw['shown_at'] is None and self.t >= lw['next_show']: |
| lw['shown_at'] = self.t |
| self._event('warning', 'LEVEL_WARNING', '液位警告：鞘液低或废液满（15 min未确认将自动关液流）') |
| if lw['shown_at'] is not None and self.t - lw['shown_at'] >= 900.0 - 1e-9: |
| self._stream_stop('LEVEL_WARNING_TIMEOUT') |
| lw['shown_at'] = None |
| elif not (low or full): |
| self.level_warn.update(shown_at=None, next_show=0.0) |
| if any(self.lasers[L]['on'] and not self._laser_warm(L) and f'laser_failure_{L}' not in self.faults for L in LASERS) and self.power: |
| w['LASERS_WARMING'] = '激光器预热中（30 min）' |
| for L in LASERS: |
| if self.power and self.lasers[L]['on'] and f'laser_failure_{L}' in self.faults: |
| self._error(f'LASER_FAILURE_{L.upper()}', f'{L}激光器无输出') |
| elif f'LASER_FAILURE_{L.upper()}' in self.errors and f'laser_failure_{L}' not in self.faults: |
| del self.errors[f'LASER_FAILURE_{L.upper()}'] |
| tid = self.port['tube'] |
| if tid is not None and self.port['state'] == 'up' and self.acq_on: |
| tb = self.tubes[tid] |
| if tb['volume_m3'] <= TUBE_TYPES[tb['type']]['dead_m3'] + 1e-15: |
| w['SAMPLE_DRY'] = '样品管已空（只剩死体积）' |
| if self.stream and self.stream_t_on is not None and self.t - self.stream_t_on > 10.0 and self.sheath_p < 0.9 * self.sheath_set: |
| w['SHEATH_PRESSURE_LOW'] = '鞘液压力达不到设定（检查液流车气压）' |
| if self.stream and self.stream_t_on is not None and self.t - self.stream_t_on > 5.0 and (bo is None or bo['drop1'] is None): |
| w['STREAM_UNSTABLE'] = '断点图像异常（不成滴或断点不在图像内）' |
| if self.sortrun is not None and self.sortrun['state'] == 'sorting' and self.flow_setting > fluidics()['sort_flow_rate_max_setting']: |
| w['FLOW_RATE_HIGH_FOR_SORT'] = '分选时流速档高于8' |
| if self.T_room is not None and not (ROOM_RANGE_K[0] <= self.T_room <= ROOM_RANGE_K[1]): |
| w['ROOM_TEMPERATURE_OUT_OF_RANGE'] = '室温超出17.5–27.5 °C运行范围' |
| for code, msg in w.items(): |
| if code not in self.warnings: |
| self._event('warning', code, msg) |
| self.warnings = w |
|
|
| |
| def read(self, visibility='agent'): |
| on = self.power |
| bo = self._breakoff() if on else None |
| j = self._jet() |
| sr = self.sortrun |
| h10 = self.hist[-10:] |
| rate = lambda i: float(sum(h[i] for h in h10) / (len(h10) * DT)) if h10 else 0.0 |
| accu = None |
| if on and self.defl['optical_filter_in'] and h10: |
| nl, nc = sum(h[4] for h in h10), sum(h[5] for h in h10) |
| accu = (nl / (nl + nc)) if (nl + nc) > 0 else None |
| res = fluidics()['reservoirs'] |
| sx = {} |
| for s in STREAMS: |
| x, _ = self._stream_x(s, bo) if (on and bo is not None) else (None, None) |
| sx[s] = x |
| ops = sorted({op['kind'] for op in self._running_ops()}) |
| eff = None |
| if sr is not None: |
| tot = sum(sr['counts'].values()) + sr['conflicts'] |
| eff = (sum(sr['counts'].values()) / tot) if tot > 0 else None |
| P = {L: self._laser_power(L)[0] * optics()['lasers'][L]['min_power_w'] * 1.15 for L in LASERS} |
| v = { |
| 'clock.time_s': self.t, 'plant.configured': self.plant is not None, 'power.enabled': on, |
| 'lasers.on': {L: bool(on and self.lasers[L]['on']) for L in LASERS}, 'lasers.warm': {L: self._laser_warm(L) for L in LASERS}, |
| 'lasers.power_w': {L: float(P[L]) for L in LASERS}, 'lasers.shutter_closed': self._shutter(), |
| **{f'door.{d}_angle_rad': float(self.doors[d]) for d in DOORS}, |
| 'nozzle.installed': self.nozzle, 'fluidics.state': self.fluidics_state, 'sort_setup.preset': 'custom' if self.custom else self.preset, |
| 'sheath.pressure_setpoint_pa': float(self.sheath_set), 'sheath.pressure_pa': float(self.sheath_p) if on else 0.0, 'stream.on': bool(self.stream), |
| 'breakoff.amplitude_v': float(self.bo['amplitude_v']), 'breakoff.frequency_hz': float(self.bo['frequency_hz']), 'breakoff.attenuation': bool(self.bo['attenuation']), |
| 'breakoff.drop1_target_px': float(self.bo['drop1_target_px']), 'breakoff.gap_target_px': float(self.bo['gap_target_px']), |
| 'breakoff.drop1_px': (round(bo['drop1'], 1) if (bo is not None and bo['drop1'] is not None) else None), |
| 'breakoff.gap_px': (round(bo['gap'], 1) if (bo is not None and bo['gap'] is not None) else None), |
| 'breakoff.drop_spacing_px': (round(bo['S'], 1) if bo is not None else None), |
| 'sweet_spot.on': bool(self.sweet), 'sweet_spot.paused': bool(self.ss_paused), |
| 'deflection.voltage_on': bool(on and self.defl['voltage_on']), 'deflection.plate_voltage_v': float(self.defl['plate_voltage_v']), |
| 'deflection.side_stream_fraction': {s: float(self.defl['side_stream_fraction'][s]) for s in STREAMS}, |
| 'deflection.voltage_center_fraction': float(self.defl['voltage_center_fraction']), |
| 'deflection.test_sort': bool(on and self.defl['test_sort']), 'deflection.optical_filter_in': bool(self.defl['optical_filter_in']), |
| 'drop_delay.drops': float(self.dd_set), 'sort.drawer_position_m': float(self.drawer_pos), 'sort.drawer_open': bool(self.drawer_open), |
| 'amo.on': bool(on and self.amo['on']), 'amo.mode': self.amo['mode'], |
| 'sample.agitation_rate_hz': float(AGITATION[self.agitation]), 'sample.temperature_setpoint_k': self.sample_sp, |
| 'sample.chamber_temperature_k': float(self.T_chamber if self.T_chamber is not None else 295.15), 'sample.chamber_light': bool(on and self.light), |
| 'sample.port_position_m': float(self.port['pos']), 'sample.port_state': self.port['state'], 'sample.tube_id': self.port['tube'], |
| 'sample.flow_rate_setting': float(self.flow_setting), 'sample.acquiring': bool(on and self.acq_on and self.port['state'] == 'up' and self.stream), |
| 'collection.device': self.collection['device'] if self.collection else None, 'collection.temperature_setpoint_k': self.col_sp, |
| 'collection.temperature_k': float(self.T_col if self.T_col is not None else 295.15), |
| 'tubes.on_bench': sorted(k for k, t in self.tubes.items() if t['location'] == 'bench'), 'samples.available': sorted(self.samples), |
| 'acquisition.threshold_rate_eps': rate(0), 'acquisition.processed_rate_eps': rate(1), 'acquisition.abort_rate_eps': rate(2), |
| 'acquisition.events_processed': int(self.events_processed), |
| 'cytometer.voltages': {d: float(self.settings['voltages'][d]) for d in DETS}, 'cytometer.thresholds': copy.deepcopy(self.settings['thresholds']), |
| 'cytometer.threshold_logic': self.settings['threshold_logic'], 'cytometer.laser_delays_s': dict(self.settings['laser_delays_s']), |
| 'cytometer.area_scaling': dict(self.settings['area_scaling']), 'cytometer.window_extension_s': float(self.settings['window_extension_s']), |
| 'cytometer.detectors_enabled': list(self.settings['detectors_enabled']), 'cytometer.max_event_rate_eps': float(self._rate_limit()), |
| 'compensation.enabled': bool(self.comp_on), 'compensation.pairs': self._pairs(), 'gates.defined': sorted(self.gates), 'records.count': len(self.records), |
| 'sort.layouts': sorted(self.layouts), 'sort.state': sr['state'] if sr is not None else 'idle', 'sort.layout_id': sr['layout_id'] if sr is not None else None, |
| 'sort.counts': dict(sr['counts']) if sr is not None else {}, 'sort.conflicts': int(sr['conflicts']) if sr is not None else 0, 'sort.efficiency': eff, |
| 'sort.sort_rate_eps': rate(3), 'sort.elapsed_s': float(sr['elapsed_s']) if sr is not None else 0.0, |
| 'sort.well': (sr['wells'][sr['well_i']] if (sr is not None and sr['wells'] and sr['well_i'] < len(sr['wells'])) else None), |
| 'accudrop.left_stream_fraction': accu, 'cst.status': self.cst_status, |
| 'cart.sheath_level_fraction': float(self.cart['sheath'] / res['sheath_m3']), 'cart.waste_level_fraction': float(min(1.0, self.cart['waste'] / res['waste_m3'])), |
| 'cart.cleaning_ok': all(x >= 0.2 * res['cleaning_m3'] for x in self.cart['cleaning'].values()), |
| 'cart.air_pressure_pa': float(self.cart['air']), 'cart.gauge_angle_rad': float(min(GAUGE_SWEEP, self.cart['air'] / PSI / GAUGE_FULL_SCALE_PSI * GAUGE_SWEEP)), |
| 'safety.estop_latched': bool(self.estop), 'safety.estop_position_m': ESTOP_TRAVEL if self.estop else 0.0, |
| 'lamp.deflection_plates': bool(on and self.defl['voltage_on']), 'lamp.chamber_light': bool(on and self.light), |
| 'lamp.estop_light': bool(on and (self.estop or self.port['state'] in ('loading', 'unloading'))), |
| 'operations.running': ops, 'operation.started_by_other_agent': False, 'warnings.active': sorted(self.warnings), 'errors.active': sorted(self.errors), |
| 'truth.sheath_temperature_k': float(self.T_sheath if self.T_sheath is not None else 295.15), 'truth.jet_speed_m_s': float(j['v']), |
| 'truth.breakoff_length_m': (float(bo['L_b']) if bo is not None else None), 'truth.drop_delay_drops': (float(bo['dd_true']) if bo is not None else None), |
| 'truth.laser_delays_s': self._true_laser_delays(), 'truth.area_scaling': self._true_asf(), |
| 'truth.core_radius_m': float(math.sqrt(self._flow_m3_s() / j['v_core'] / math.pi)) if j['v_core'] > 0 else 0.0, |
| 'truth.side_stream_x_m': sx, 'truth.cart_sheath_m3': float(self.cart['sheath']), 'truth.cart_waste_m3': float(self.cart['waste']), |
| 'truth.sample_temperature_k': (float(self.tubes[self.port['tube']]['T']) if self.port['tube'] else None), 'truth.faults': sorted(self.faults), |
| } |
| if visibility == 'agent': |
| v = {k: x for k, x in v.items() if SLOTS[k]['visibility'] == 'agent'} |
| return v |
|
|
| def _cmd_sort_side_streams(self): |
| self._need_power() |
| bo = self._breakoff() |
| streams = [] |
| if bo is not None and self.defl['voltage_on'] and (self.defl['test_sort'] or (self.sortrun is not None and self.sortrun['state'] == 'sorting')): |
| dv = DEVICES[self.collection['device']] if self.collection else None |
| for s in STREAMS: |
| x, sg = self._stream_x(s, bo) |
| tgt = None |
| off = None |
| if dv is not None: |
| if dv['kind'] == 'tubes': |
| for loc, (st, xt) in dv['locations'].items(): |
| if st == s: |
| tgt, off = loc, x - xt |
| elif s == dv['stream']: |
| tgt, off = 'plate', x - dv['x'] |
| streams.append(dict(stream=s, x_m=x, spread_m=sg, target=tgt, offset_from_target_m=off)) |
| xc, _ = self._centre_x() |
| if bo is not None: |
| streams.append(dict(stream='centre', x_m=xc, spread_m=2.0e-4 if 'clog_partial' not in self.faults else 3.0e-3, target='waste_aspirator', offset_from_target_m=xc)) |
| return dict(streams=streams, centre_in_aspirator=bool(bo is not None and abs(xc) < ASPIRATOR_R)) |
|
|
| |
| def _pop_truth(self, counts, volume): |
| out = [] |
| for k in sorted(counts): |
| sp = self.popspec[k] |
| out.append(dict(population_id=k, particle_id=sp['particle_id'], particles=float(counts[k]), |
| concentration_per_m3=float(counts[k] / volume) if volume > 0 else 0.0)) |
| return out |
|
|
| def _cmd_tube_inspect(self, tube_id): |
| tb = self.tubes.get(tube_id) |
| if tb is None: |
| raise ActionRejected('UNKNOWN_ITEM') |
| h = tb['volume_m3'] / (math.pi * TUBE_TYPES[tb['type']]['radius_m'] ** 2) |
| return dict(tube_id=tube_id, volume_m3=float(tb['volume_m3']), temperature_k=float(tb['T']), populations=self._pop_truth(tb['counts'], tb['volume_m3']), |
| settled_depth_m={k: float(v) for k, v in sorted(tb['settle'].items())}, liquid_height_m=float(h)) |
|
|
| def _cmd_collection_inspect(self): |
| c = self.collection |
| if c is None: |
| return dict(device=None, locations=[]) |
| return dict(device=c['device'], locations=[dict(location=k, volume_m3=float(x['volume_m3']), temperature_k=float(self.T_col), |
| populations=self._pop_truth(x['counts'], x['volume_m3'])) for k, x in c['locs'].items() |
| if x['volume_m3'] > 0 or x['counts']]) |
|
|
| def _cmd_events_read(self, since_s): |
| return dict(events=[{k: v for k, v in e.items() if k != '_ref'} for e in self.events if e['time_s'] >= since_s], dropped=self.events_dropped) |
|
|
| def _cmd_provenance_read(self): |
| op = optics() |
| return dict(libraries=[dict(name=k, file=v, entries=len(_lib(k).get('substances', _lib(k).get('presets', _lib(k).get('detectors', {}))))) for k, v in LIBS.items()], |
| detectors=[dict(detector=d, laser=op['detectors'][d]['laser'], bandpass_m=[(op['detectors'][d]['bandpass_nm'][0] - op['detectors'][d]['bandpass_nm'][1] / 2) * 1e-9, |
| (op['detectors'][d]['bandpass_nm'][0] + op['detectors'][d]['bandpass_nm'][1] / 2) * 1e-9], |
| intended=op['detectors'][d]['intended']) for d in FL_DETS]) |
|
|
| def ledger(self): |
| return {k: v.value() for k, v in self.led.items()} |
|
|
| def _cmd_ledger_read(self): |
| return dict(ledger=self.ledger()) |
|
|
| def _cmd_fault_inject(self, fault, active): |
| self._need_plant() |
| (self.faults.add if active else self.faults.discard)(fault) |
| if active: |
| self.fault_t[fault] = self.t |
| if fault == 'power_loss': |
| if active and self.power: |
| self._power_off('mains') |
| elif not active and self.switch_on and not self.power and self._mains_ok(): |
| self._power_up() |
| self._event('fault', 'FAULT', f'{fault} {"on" if active else "off"}') |
| return dict(faults=sorted(self.faults)) |
|
|
| def _cmd_sim_step(self, dt_s): |
| self.step(dt_s) |
| return dict(time_s=self.t) |
|
|
| |
| def invoke(self, capability_id, **a): |
| if capability_id not in CAPS: |
| raise ActionRejected('UNKNOWN_CAPABILITY') |
| if capability_id in UNSUPPORTED: |
| raise ActionRejected('UNSUPPORTED') |
| validate(CAPS[capability_id]['input_schema'], a) |
| snap = None |
| if CAPS[capability_id]['kind'] != 'query' and capability_id != 'sim.step': |
| snap = self._snapshot() |
| try: |
| out = getattr(self, '_cmd_' + capability_id.replace('.', '_'))(**a) |
| except ActionRejected: |
| if snap is not None: |
| self._restore(snap) |
| raise |
| if CAPS[capability_id]['kind'] not in ('query',) and capability_id != 'sim.step': |
| self.revision += 1 |
| return out |
|
|
| _NOCOPY = ('live', '_principals', '_requests') |
|
|
| def _snapshot(self): |
| """Atomic rejection: deep copy of the mutable state except the large live buffer and the session tables (commands that fail never touch them).""" |
| d = {} |
| for k, v in self.__dict__.items(): |
| if k in self._NOCOPY: |
| continue |
| if k == 'records': |
| d[k] = {rid: dict(r) for rid, r in v.items()} |
| else: |
| d[k] = copy.deepcopy(v) |
| return d |
|
|
| def _restore(self, snap): |
| for k, v in snap.items(): |
| self.__dict__[k] = v |
|
|
|
|
| |
| ASYNC = {'fluidics.startup', 'fluidics.shutdown', 'cleaning.run', 'acquisition.record', 'sort.start', 'sort.auto_drop_delay', 'cst.performance_check'} |
| _RECORD_QUERIES = {'statistics.read', 'record.read', 'data.export'} |
| _CONTROL_GUARDED = {k for k, v in CAPS.items() if v['visibility'] == 'agent' and v['kind'] in ('device_command', 'robot_skill') and k not in UNSUPPORTED |
| and k not in ('data.export', 'gate.define', 'safety.emergency_stop', 'safety.reset_emergency_stop')} |
|
|
|
|
| class BdFacsariaiiiSession: |
| def __init__(self, host, principal_id): |
| self._host = host |
| self._principal = principal_id |
|
|
| @property |
| def _role(self): |
| return self._host._principals[self._principal] |
|
|
| def _target(self, instance_id): |
| if not isinstance(instance_id, str) or instance_id != self._host.instance_id: |
| raise ActionRejected('UNKNOWN_INSTANCE') |
|
|
| def describe(self, *, instance_id=None, asset_type_id=None): |
| if (instance_id is None) == (asset_type_id is None): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if instance_id is not None: |
| self._target(instance_id) |
| if asset_type_id is not None and asset_type_id != ASSET_TYPE_ID: |
| raise ActionRejected('UNKNOWN_INSTANCE') |
| meta = copy.deepcopy(export_bd_facsariaiii_contract_metadata()) |
| caps = {k: v for k, v in meta['capabilities'].items() if v['visibility'] == 'agent' or self._role != 'agent'} |
| slots = {k: v for k, v in meta['state_slots'].items() if v['visibility'] == 'agent' or self._role != 'agent'} |
| if self._role == 'agent': |
| for c in caps.values(): |
| c['state_effects'] = [e for e in c['state_effects'] if e['state_id'] in slots] |
| c['observes'] = [x for x in c['observes'] if x in slots] |
| for pre in c['preconditions']: |
| pre['state_ids'] = [x for x in pre['state_ids'] if x in slots] |
| c['execution']['completion_state_ids'] = [x for x in c['execution']['completion_state_ids'] if x in slots] |
| for m in meta['mechanisms'].values(): |
| m['state_ids'] = [x for x in m['state_ids'] if x in slots] |
| return dict(protocol_version=PROTOCOL_VERSION, asset_type_id=ASSET_TYPE_ID, asset_version='1.0.0', capabilities=caps, state_slots=slots) |
|
|
| def _foreign(self, object_id): |
| owner = self._host._owners.get(object_id) |
| return owner is not None and owner != self._principal and self._host._principals.get(owner) == 'agent' |
|
|
| def _foreign_op(self): |
| h = self._host |
| return any(self._foreign(op['op_id']) for op in h._running_ops()) |
|
|
| def read(self, *, instance_id, state_ids=None): |
| self._target(instance_id) |
| h = self._host |
| values = h.read(self._role) |
| values['operation.started_by_other_agent'] = self._role == 'agent' and self._foreign_op() |
| if self._role == 'agent': |
| values['tubes.on_bench'] = [x for x in values['tubes.on_bench'] if not self._foreign('tube:' + x)] |
| values['samples.available'] = [x for x in values['samples.available'] if not self._foreign('sample:' + x)] |
| ids = list(values) if state_ids is None else state_ids |
| if not isinstance(ids, list) or any(not isinstance(k, str) for k in ids): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if any(k not in values for k in ids): |
| raise ActionRejected('ACCESS_DENIED') |
| n_h = min(10, len(h.hist)) |
| win = [round((h.tick - n_h) * DT, 9), round(h.tick * DT, 9)] if n_h else None |
| return dict(instance_id=instance_id, status='succeeded', state_revision=h.revision, clock={'domain': 'simulation', 'time_s': h.time_s}, |
| observations={k: dict(value=copy.deepcopy(values[k]), unit=SLOTS[k]['unit'], |
| quality='unavailable' if values[k] is None else 'estimated' if SLOTS[k]['origin'] in ('sensor', 'derived') else 'valid', |
| sample_time_s=h.time_s, |
| sample_window_s=win if (k.startswith(('acquisition.', 'accudrop.')) and k != 'acquisition.events_processed') |
| or k == 'sort.sort_rate_eps' else None) |
| for k in ids}) |
|
|
| def _guard(self, capability_id, arguments): |
| if self._role != 'agent': |
| return |
| h = self._host |
| if capability_id in _CONTROL_GUARDED and self._foreign_op(): |
| if not h.power and ((capability_id == 'power.set' and arguments.get('enabled') is True) or (capability_id == 'power.press_switch' and not h.switch_on)): |
| return |
| raise ActionRejected('ACCESS_DENIED') |
| if capability_id in ('tube.install', 'tube.mix') and self._foreign('tube:' + arguments['tube_id']): |
| raise ActionRejected('ACCESS_DENIED') |
| if capability_id in ('tube.remove', 'sample.load', 'sample.unload', 'acquisition.set') and h.port['tube'] is not None and self._foreign('tube:' + h.port['tube']): |
| raise ActionRejected('ACCESS_DENIED') |
| if capability_id == 'tube.prepare' and any('sample_id' in s and self._foreign('sample:' + s['sample_id']) for s in arguments['sources']): |
| raise ActionRejected('ACCESS_DENIED') |
| if capability_id in _RECORD_QUERIES: |
| rid = arguments.get('record_id', arguments.get('source')) |
| if rid not in (None, 'live') and self._foreign('record:' + rid): |
| raise ActionRejected('ACCESS_DENIED') |
| if capability_id == 'compensation.calculate' and any(self._foreign('record:' + r) for r in [arguments['unstained_record']] + list(arguments['controls'].values())): |
| raise ActionRejected('ACCESS_DENIED') |
| if capability_id in ('sort.start', 'sort.layout') and self._foreign('layout:' + arguments['layout_id']): |
| raise ActionRejected('ACCESS_DENIED') |
| if capability_id == 'gate.delete' and self._foreign('gate:' + arguments['gate_id']): |
| raise ActionRejected('ACCESS_DENIED') |
| if capability_id == 'collection.remove' and h.collection is not None and self._foreign('collection'): |
| raise ActionRejected('ACCESS_DENIED') |
|
|
| def invoke(self, *, instance_id, capability_id, arguments, request_id): |
| h = self._host |
| key = digest = None |
| try: |
| self._target(instance_id) |
| if not isinstance(request_id, str) or not request_id: |
| raise ActionRejected('INVALID_ARGUMENT') |
| key = (self._principal, request_id) |
| try: |
| digest = json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False) |
| except (TypeError, ValueError): |
| digest = None |
| if key in h._requests: |
| old, response = h._requests[key] |
| if digest is None or old != digest or not isinstance(response, dict): |
| raise ActionRejected('REQUEST_CONFLICT') |
| return copy.deepcopy(response) |
| if not isinstance(capability_id, str) or capability_id not in CAPS: |
| raise ActionRejected('UNKNOWN_CAPABILITY') |
| if self._role == 'agent' and CAPS[capability_id]['visibility'] != 'agent': |
| raise ActionRejected('ACCESS_DENIED') |
| if not isinstance(arguments, dict): |
| raise ActionRejected('INVALID_ARGUMENT') |
| validate(CAPS[capability_id]['input_schema'], arguments) |
| self._guard(capability_id, arguments) |
| h._caller = self._principal |
| try: |
| result = h.invoke(capability_id, **arguments) |
| finally: |
| h._caller = None |
| if capability_id == 'sample.provide': |
| h._owners['sample:' + arguments['sample_id']] = self._principal |
| if self._role == 'agent': |
| if capability_id == 'records.list': |
| result = dict(records=[r for r in result['records'] if not self._foreign('record:' + r['record_id'])]) |
| elif capability_id == 'events.read': |
| result = dict(events=[{k: v for k, v in e.items() if k != '_ref'} for e in h.events |
| if e['time_s'] >= arguments['since_s'] and not any(self._foreign(p + str(e.get('_ref'))) for p in ('', 'tube:', 'record:', 'sample:')) |
| and e['kind'] not in ('fault', 'truth')], dropped=h.events_dropped) |
| operation = result.get('operation_id') if capability_id in ASYNC else None |
| response = dict(protocol_version=PROTOCOL_VERSION, instance_id=instance_id, request_id=request_id, operation_id=operation, |
| status='accepted' if operation else 'succeeded', state_revision=h.revision, clock={'domain': 'simulation', 'time_s': h.time_s}, |
| result=copy.deepcopy(result), observations={}, error=None) |
| h._requests[key] = (digest, copy.deepcopy(response)) |
| return response |
| except ActionRejected as exc: |
| response = dict(protocol_version=PROTOCOL_VERSION, instance_id=instance_id, request_id=request_id, operation_id=None, |
| status='unsupported' if str(exc) == 'UNSUPPORTED' else 'rejected', state_revision=h.revision, |
| clock={'domain': 'simulation', 'time_s': h.time_s}, result={}, observations={}, |
| error=dict(code=str(exc), message=ERROR_ZH.get(str(exc), str(exc)), retryable=False, side_effects='none')) |
| if key is not None and digest is not None and key not in h._requests: |
| h._requests[key] = (digest, copy.deepcopy(response)) |
| return response |
|
|
| def write(self, *, instance_id, state_id, value, request_id): |
| self._target(instance_id) |
| raise ActionRejected('ACCESS_DENIED') |
|
|
| def poll(self, operation_id): |
| h = self._host |
| if not isinstance(operation_id, str): |
| raise ActionRejected('INVALID_ARGUMENT') |
| op = h.operations.get(operation_id) |
| if op is None: |
| raise ActionRejected('UNKNOWN_OPERATION') |
| if h._owners.get(operation_id) != self._principal: |
| raise ActionRejected('ACCESS_DENIED') |
| res = dict(kind=op['kind'], error=op['error'], **copy.deepcopy(op.get('result', {}))) |
| if op['kind'] == 'sort.start' and h.sortrun is not None and h.sortrun['op_id'] == operation_id: |
| res.update(state=h.sortrun['state'], counts=dict(h.sortrun['counts']), conflicts=int(h.sortrun['conflicts']), |
| conflicts_by_location=dict(h.sortrun['conflicts_by_location'])) |
| if op['kind'] == 'acquisition.record': |
| res.update(record_id=op['record_id'], events=int(h.records[op['record_id']]['n'])) |
| return dict(operation_id=operation_id, status=op['phase'], result=res) |
|
|
| def cancel(self, operation_id, request_id): |
| h = self._host |
| if not isinstance(request_id, str) or not request_id: |
| raise ActionRejected('INVALID_ARGUMENT') |
| key = (self._principal, request_id) |
| digest = json.dumps(['cancel', operation_id]) if isinstance(operation_id, str) else None |
| if key in h._requests: |
| old, response = h._requests[key] |
| if digest is None or old != digest: |
| raise ActionRejected('REQUEST_CONFLICT') |
| if isinstance(response, str): |
| raise ActionRejected(response) |
| return copy.deepcopy(response) |
| try: |
| self.poll(operation_id) |
| op = h.operations[operation_id] |
| if op['phase'] != 'running': |
| raise ActionRejected('NOT_RUNNING') |
| h._cancel_op(op) |
| except ActionRejected as exc: |
| if digest is not None: |
| h._requests[key] = (digest, str(exc)) |
| raise |
| h.revision += 1 |
| response = dict(protocol_version=PROTOCOL_VERSION, instance_id=h.instance_id, request_id=request_id, operation_id=operation_id, status='succeeded', |
| state_revision=h.revision, clock={'domain': 'simulation', 'time_s': h.time_s}, result=dict(phase=op['phase']), observations={}, error=None) |
| h._requests[key] = (digest, copy.deepcopy(response)) |
| return response |
|
|
|
|
| |
| ERROR_ZH = { |
| 'INVALID_ARGUMENT': '参数不符合输入模式或取值范围', 'REQUEST_CONFLICT': '同一request_id对应不同的调用', 'UNKNOWN_INSTANCE': '实例不存在', |
| 'UNKNOWN_CAPABILITY': '能力不存在', 'UNSUPPORTED': '本配置不支持该能力', 'ACCESS_DENIED': '无权访问（真值、另一个agent的样品管、记录、布局、门或进行中的操作）', |
| 'PLANT_REQUIRED': '尚未声明实验室条件', 'SEED_FIXED': '噪声种子只能在首次声明时设定', 'MAINS_OUT_OF_RANGE': '市电不在100/115/230 VAC ±10 %（或断电）', |
| 'POWER_OFF': '仪器未通电', 'STREAM_ON': '液流开着（须先关液流）', 'STREAM_OFF': '液流没有开', 'DOOR_CLOSED': '须先打开对应的门', 'DOOR_OPEN': '须先关好分选收集室门', |
| 'FLUIDICS_BUSY': '液流程序进行中', 'FLUIDICS_ALREADY_STARTED': '液流系统已启动', 'FLUIDICS_NOT_READY': '液流系统未完成Fluidics Startup（或正在关机/清洗）', |
| 'SORT_NOZZLE_REQUIRED': '须装分选喷嘴（70/85/100/130 µm）', 'CLOSED_LOOP_NOZZLE_REQUIRED': '须装闭环喷嘴', 'SHEATH_LOW': '鞘液不足以启动', |
| 'WASTE_FULL': '废液罐将满', 'CLEANING_FLUID_LOW': '清洗液不足', 'SWEET_SPOT_ON': 'Sweet Spot开启时不能改振幅、频率、鞘液压力或Sort Setup', |
| 'SWEET_SPOT_OFF': '须先开启Sweet Spot', 'SORT_IN_PROGRESS': '分选、自动液滴延迟或CS&T进行中', 'EMERGENCY_STOP_LATCHED': '急停按钮未复位', |
| 'SHEATH_EMPTY': '鞘液罐空', 'NO_BREAKOFF': '没有稳定的断点图像（不成滴或断点不在图像内）', 'PLATES_OFF': '偏转板电压没开', |
| 'CONTAINER_OVERFLOW': '加入量超过容器容量', 'ITEM_EXISTS': 'ID已存在', 'TOO_MANY_ITEMS': '数量已达上限', 'DUPLICATE_POPULATION': '群体ID重复', |
| 'UNKNOWN_PARTICLE': '颗粒类型不在颗粒库中（或不是微球）', 'UNKNOWN_DYE': '荧光染料不在荧光库中', 'INVALID_SOURCE': '每个来源须给样品或微球之一；只有微球可加染色', |
| 'UNKNOWN_SAMPLE': '样品不存在', 'INSUFFICIENT_SAMPLE': '样品体积不够', 'VOLUME_OUT_OF_RANGE': '体积超过管或孔的容量', 'UNKNOWN_ITEM': '样品管不存在', |
| 'TUBE_NOT_ON_BENCH': '样品管不在实验台上', 'PORT_OCCUPIED': '进样口上已有样品管', 'PORT_NOT_DOWN': '进样口没有降下', 'NO_TUBE': '进样口上没有样品管', |
| 'NOT_LOADED': '样品管没有装载', 'ACQUISITION_IN_PROGRESS': '记录、分选或检查进行中不能改阈值与参数', 'INVALID_PARAMETERS': '启用的检测器须含FSC与SSC且不重复', |
| 'INVALID_THRESHOLD': '阈值参数须是启用的检测器且不重复', 'INVALID_SPILLOVER': '溢出矩阵无效（对角须为1、矩阵须可逆、检测器须为荧光检测器）', |
| 'UNKNOWN_RECORD': '记录不存在', 'TOO_FEW_EVENTS': '记录事件太少（<100）', 'NO_POSITIVE_POPULATION': '单染对照没有明显的阳性群', |
| 'UNKNOWN_GATE': '门不存在', 'INVALID_GATE': '门的参数不完整或范围无效', 'GATE_IN_USE': '门有子门、被分选布局或进行中的记录引用', |
| 'STORAGE_FULL': '记录存储已满', 'RECORDING_IN_PROGRESS': '已有记录进行中', 'NOT_ACQUIRING': '没有在采集（须装载样品管并采集）', |
| 'DEVICE_INSTALLED': '已装收集装置', 'NO_DEVICE': '没有收集装置', 'INVALID_LAYOUT': '布局与收集装置不一致（位置、目标数或孔）', 'UNKNOWN_LAYOUT': '布局不存在', |
| 'DEVICE_MISMATCH': '装着的收集装置与布局不一致', 'NOT_SORTING': '没有进行中的分选', 'NOT_PAUSED': '分选没有暂停', |
| 'ACCUDROP_BEADS_REQUIRED': '须装载并采集Accudrop微球', 'CST_BEADS_REQUIRED': '须装载并采集CS&T微球', 'UNKNOWN_OPERATION': '操作不存在', |
| 'NOT_RUNNING': '操作不在进行中', 'POWER_OFF_INTERRUPT': '断电中止', 'STREAM_OFF_INTERRUPT': '液流关闭中止', 'EMERGENCY_STOP': '急停', 'CONDITIONS_LOST': '运行条件丢失（液流、装载或偏转）', |
| 'CLOG': '喷嘴堵塞', 'WASTE_OVERFLOW': '废液罐溢出', 'SAMPLE_UNLOADED': '样品管已卸下（进行中的分选与记录结束）', |
| **{f'LASER_FAILURE_{L.upper()}': f'{L}激光器无输出' for L in LASERS}, |
| } |
| _OPS = ['operations.running', 'warnings.active', 'errors.active'] |
| _LAMPS = ['lamp.deflection_plates', 'lamp.chamber_light', 'lamp.estop_light'] |
| _BO = ['breakoff.drop1_px', 'breakoff.gap_px', 'breakoff.drop_spacing_px', 'breakoff.amplitude_v', 'sweet_spot.paused', 'truth.breakoff_length_m', 'truth.drop_delay_drops', |
| 'truth.jet_speed_m_s', 'truth.laser_delays_s', 'truth.area_scaling', 'truth.core_radius_m', 'truth.side_stream_x_m'] |
| _STREAM = ['stream.on', 'sheath.pressure_pa', 'sweet_spot.on'] + _BO |
| _ACQ = ['acquisition.threshold_rate_eps', 'acquisition.processed_rate_eps', 'acquisition.abort_rate_eps', 'acquisition.events_processed', 'accudrop.left_stream_fraction'] |
| _SORT = ['sort.state', 'sort.layout_id', 'sort.counts', 'sort.conflicts', 'sort.efficiency', 'sort.sort_rate_eps', 'sort.elapsed_s', 'sort.well', 'sort.drawer_open', |
| 'sort.drawer_position_m'] |
| _SAMPLE = ['sample.port_position_m', 'sample.port_state', 'sample.tube_id', 'sample.acquiring', 'tubes.on_bench', 'truth.sample_temperature_k'] |
| _THERM = ['sample.chamber_temperature_k', 'collection.temperature_k', 'truth.sheath_temperature_k', 'truth.sample_temperature_k'] |
| _CART = ['cart.sheath_level_fraction', 'cart.waste_level_fraction', 'cart.cleaning_ok', 'cart.air_pressure_pa', 'cart.gauge_angle_rad', 'truth.cart_sheath_m3', |
| 'truth.cart_waste_m3'] |
| _PWR = ['power.enabled', 'lasers.on', 'lasers.warm', 'lasers.power_w', 'deflection.voltage_on', 'deflection.test_sort', 'sample.chamber_light', 'amo.on', 'fluidics.state', |
| 'sample.acquiring', 'sheath.pressure_pa', 'sort.drawer_open'] + _STREAM + _LAMPS + _OPS + _SORT + _ACQ + ['sample.port_state', 'sample.port_position_m'] |
| _ALL_PHYS = sorted(set(_THERM + _CART + _STREAM + _ACQ + _SORT + _SAMPLE + _LAMPS + _OPS + ['lasers.warm', 'lasers.power_w', 'fluidics.state', 'cst.status', |
| 'deflection.optical_filter_in', 'drop_delay.drops', 'cytometer.laser_delays_s', |
| 'cytometer.area_scaling', 'records.count', 'deflection.voltage_on', |
| 'deflection.test_sort', 'collection.device', 'samples.available'])) |
| EFFECTS = { |
| 'plant.configure': ['plant.configured'] + _THERM + _CART + _PWR, 'power.set': _PWR, 'power.press_switch': _PWR, |
| 'lasers.set': ['lasers.on', 'lasers.warm', 'lasers.power_w', 'warnings.active', 'errors.active'], |
| 'door.set': [f'door.{d}_angle_rad' for d in DOORS] + ['lasers.shutter_closed'], |
| 'nozzle.install': ['nozzle.installed', 'errors.active', 'truth.faults'], |
| 'fluidics.startup': ['fluidics.state', 'operations.running'], 'fluidics.shutdown': ['fluidics.state', 'operations.running'], |
| 'cleaning.run': ['fluidics.state', 'operations.running'], |
| 'sort_setup.select': ['sort_setup.preset', 'sheath.pressure_setpoint_pa', 'breakoff.amplitude_v', 'breakoff.frequency_hz', 'breakoff.attenuation', 'drop_delay.drops', |
| 'deflection.plate_voltage_v', 'deflection.side_stream_fraction', 'cytometer.laser_delays_s', 'cytometer.area_scaling', |
| 'cytometer.window_extension_s', 'truth.area_scaling'], |
| 'stream.set': _STREAM + _SORT + _OPS + ['sample.acquiring', 'truth.faults'], |
| 'breakoff.set': ['breakoff.frequency_hz', 'breakoff.drop1_target_px', 'breakoff.gap_target_px', 'breakoff.attenuation'] + _BO, |
| 'sweet_spot.set': ['sweet_spot.on', 'sweet_spot.paused'], |
| 'sheath.set_pressure': ['sheath.pressure_setpoint_pa', 'sort_setup.preset', 'truth.jet_speed_m_s', 'truth.laser_delays_s', 'truth.area_scaling', 'truth.core_radius_m'] + _BO, |
| 'deflection.set': ['deflection.voltage_on', 'deflection.plate_voltage_v', 'deflection.side_stream_fraction', 'deflection.voltage_center_fraction', 'deflection.test_sort', |
| 'deflection.optical_filter_in', 'lamp.deflection_plates', 'truth.side_stream_x_m', 'accudrop.left_stream_fraction'], |
| 'drop_delay.set': ['drop_delay.drops'], 'drawer.set': ['sort.drawer_open'], 'amo.set': ['amo.on', 'amo.mode'], |
| 'sample.agitation': ['sample.agitation_rate_hz'], 'sample.temperature': ['sample.temperature_setpoint_k'], 'collection.temperature': ['collection.temperature_setpoint_k'], |
| 'sample.chamber_light': ['sample.chamber_light', 'lamp.chamber_light'], 'tube.prepare': ['tubes.on_bench'], 'tube.mix': [], |
| 'tube.install': ['tubes.on_bench', 'sample.tube_id', 'truth.sample_temperature_k'], 'tube.remove': ['tubes.on_bench', 'sample.tube_id', 'truth.sample_temperature_k'], |
| 'sample.load': ['sample.port_state', 'sample.acquiring', 'acquisition.events_processed', 'lamp.estop_light'], |
| 'sample.unload': ['sample.port_state', 'sample.acquiring', 'lamp.estop_light', 'sort.state', 'sort.drawer_open', 'operations.running'], |
| 'acquisition.set': ['sample.acquiring'], |
| 'acquisition.flow_rate': ['sample.flow_rate_setting', 'truth.core_radius_m'], |
| 'cytometer.settings': ['cytometer.voltages', 'cytometer.thresholds', 'cytometer.threshold_logic', 'cytometer.laser_delays_s', 'cytometer.area_scaling', |
| 'cytometer.window_extension_s', 'cytometer.detectors_enabled', 'cytometer.max_event_rate_eps'], |
| 'compensation.set': ['compensation.enabled', 'compensation.pairs', 'cytometer.max_event_rate_eps'], |
| 'compensation.calculate': ['compensation.enabled', 'compensation.pairs', 'cytometer.max_event_rate_eps'], |
| 'gate.define': ['gates.defined'], 'gate.delete': ['gates.defined'], 'acquisition.record': ['records.count', 'operations.running'], |
| 'collection.install': ['collection.device'], 'collection.remove': ['collection.device', 'samples.available'], 'sort.layout': ['sort.layouts'], |
| 'sort.start': _SORT + ['operations.running'], 'sort.pause': ['sort.state'], 'sort.resume': ['sort.state'], |
| 'sort.auto_drop_delay': ['operations.running', 'deflection.optical_filter_in', 'accudrop.left_stream_fraction'], 'cst.performance_check': ['operations.running'], |
| 'safety.emergency_stop': ['safety.estop_latched', 'safety.estop_position_m', 'sample.port_state', 'sample.acquiring', 'lamp.estop_light', 'lamp.deflection_plates', |
| 'deflection.voltage_on', 'deflection.test_sort', 'accudrop.left_stream_fraction'] + _SORT + _STREAM + _OPS, |
| 'safety.reset_emergency_stop': ['safety.estop_latched', 'safety.estop_position_m', 'lamp.estop_light'], 'warnings.dismiss': [], |
| 'cart.refill_sheath': ['cart.sheath_level_fraction', 'truth.cart_sheath_m3', 'errors.active'], |
| 'cart.empty_waste': ['cart.waste_level_fraction', 'truth.cart_waste_m3', 'errors.active'], |
| 'cart.refill_cleaning': ['cart.cleaning_ok'], 'data.export': [], 'sample.provide': ['samples.available'], |
| 'fault.inject': ['truth.faults'] + _PWR + ['errors.active'], 'sim.step': ['clock.time_s'], |
| } |
| |
| |
| _AIR = ['cart.air_pressure_pa', 'cart.gauge_angle_rad'] |
| _LEVELS = ['cart.sheath_level_fraction', 'cart.waste_level_fraction', 'truth.cart_sheath_m3', 'truth.cart_waste_m3', 'cart.cleaning_ok'] |
| _WASTE = ['cart.waste_level_fraction', 'truth.cart_waste_m3'] |
| _PORTMOVE = ['sample.port_position_m', 'sample.port_state', 'sample.acquiring', 'lamp.estop_light'] |
| _PROTECT = ['deflection.voltage_on', 'deflection.test_sort', 'lamp.deflection_plates', 'sort.drawer_open', 'sort.drawer_position_m'] + _PORTMOVE |
| _DATA = _ACQ + _SORT + _OPS + _WASTE |
| |
| _STREAM_ALL = _STREAM + ['truth.sheath_temperature_k'] + _LEVELS + _DATA + _PROTECT |
| _u = lambda *groups: sorted(set(x for g in groups for x in g)) |
| ON_STEP = {k: _ALL_PHYS for k in ('plant.configure', 'power.set', 'power.press_switch', 'fault.inject', 'sim.step')} |
| ON_STEP.update({ |
| 'lasers.set': _u(['lasers.warm', 'lasers.power_w', 'cst.status', 'cytometer.laser_delays_s', 'cytometer.area_scaling'], _DATA), |
| 'door.set': _u(_DATA), |
| 'fluidics.startup': _u(['fluidics.state'], _LEVELS, _OPS), 'fluidics.shutdown': _u(['fluidics.state'], _LEVELS, _OPS), |
| 'cleaning.run': _u(['fluidics.state'], _LEVELS, _OPS), |
| 'stream.set': _u(_STREAM_ALL), 'sweet_spot.set': _u(_STREAM_ALL), 'warnings.dismiss': _u(_STREAM_ALL), |
| 'safety.emergency_stop': _u(_STREAM_ALL, ['sample.chamber_temperature_k', 'truth.sample_temperature_k']), |
| 'breakoff.set': _u(_BO, _DATA), 'sheath.set_pressure': _u(_STREAM, _LEVELS, _DATA), |
| 'deflection.set': _u(_DATA, _WASTE), 'drop_delay.set': _u(_DATA), 'drawer.set': _u(['sort.drawer_position_m'], _DATA, _WASTE), |
| 'sample.agitation': _u(_DATA), 'sample.temperature': _u(['sample.chamber_temperature_k', 'truth.sample_temperature_k'], _DATA), |
| 'collection.temperature': ['collection.temperature_k'], |
| 'sample.load': _u(_PORTMOVE, ['sample.chamber_temperature_k', 'truth.sample_temperature_k'], _DATA, _WASTE), |
| 'sample.unload': _u(_PORTMOVE, ['sample.chamber_temperature_k', 'truth.sample_temperature_k'], _DATA, _WASTE), |
| 'acquisition.set': _u(_DATA, _WASTE), 'acquisition.flow_rate': _u(_DATA, _WASTE), |
| 'cytometer.settings': _u(_DATA), 'compensation.set': _u(_DATA), 'compensation.calculate': _u(_DATA), |
| 'acquisition.record': ['operations.running'], |
| 'sort.start': _u(_DATA, _WASTE, ['sort.drawer_position_m']), 'sort.pause': _u(_DATA, _WASTE), 'sort.resume': _u(_DATA, _WASTE), |
| 'sort.auto_drop_delay': ['accudrop.left_stream_fraction', 'drop_delay.drops', 'operations.running'], |
| 'cst.performance_check': _u(['cst.status', 'cytometer.laser_delays_s', 'cytometer.area_scaling'], _DATA), |
| 'cart.refill_sheath': ['warnings.active'], 'cart.empty_waste': ['warnings.active'], |
| }) |
| ON_STEP_ZH = { |
| 'plant.configure': '声明后所有过程按0.1 s网格演化（室温驱动各温度、鞘液温度与断点）', 'fault.inject': '故障作用于随后的各物理过程（断电、堵塞、气泡、激光、断点漂移、漏气）', |
| 'power.set': '通电后液流车气压升到约88 psi；激光开启后预热30 min；断电后温度、气压回落', 'power.press_switch': '同power.set', |
| 'lasers.set': '激光功率按预热时间常数上升；信号、事件率、分类与分选、记录进度与CS&T结果随之变化', |
| 'door.set': '比色池检修门打开时快门挡光：事件率、记录与分选随之变化（其它门只影响气溶胶账目）', |
| 'fluidics.startup': '约8 min后液流系统就绪，灌注鞘液进废液', 'fluidics.shutdown': '约3 min后完成关机清洗（去离子水与FACSClean进废液）', |
| 'cleaning.run': '清洗程序按时长完成，清洗液进废液', 'stream.set': '鞘液压力约2 s建立，喷嘴处鞘液约20 min升温1.5 K（断点漂移），鞘液消耗、废液增加；采集、分选与堵塞保护随液流', |
| 'breakoff.set': '断点（Drop 1、Gap、真实液滴延迟）随新的振幅、频率与目标演化（Sweet Spot开启时自动调振幅）；分选结果随之变化', |
| 'sweet_spot.set': '每0.1 s按Drop 1/Gap调节振幅；超差时暂停分选；喷嘴全堵时执行保护动作（关液流与偏转板、关抽屉、卸管）', |
| 'sheath.set_pressure': '鞘液压力约2 s到新设定：射流速度、断点、液滴延迟、芯流与激光延迟真值、鞘液消耗、事件率与分选随之变化', |
| 'deflection.set': '分选液滴的偏转与收集（计数、冲突、落点）、收集液量（少进废液）与Accudrop左侧流比例随之变化', |
| 'drop_delay.set': '分选液滴与颗粒实际所在液滴的对应（纯度、计数、冲突）与Accudrop比例随之变化', |
| 'drawer.set': '抽屉约1 s开合；关闭时不分选（偏转液滴落在抽屉上）', 'sample.agitation': '沉降前锋推进变慢（不会再悬浮），颗粒取不到的时刻推迟，事件率与分选随之变化', |
| 'sample.temperature': '进样室约45 min到温（须关闭），样品管跟随；温度改变沉降速度', 'collection.temperature': '收集管约10 min时间常数冷却/加热', |
| 'sample.load': '进样口约3 s升起，进样室加压后开始采集（事件率、记录、分选），样品进废液；管温跟随进样室', 'sample.unload': '进样口约3 s降下，事件率归零', |
| 'acquisition.set': '暂停/继续进样：事件率、记录、分选与样品消耗随之变化', 'acquisition.flow_rate': '样品流量改变：事件率、芯流宽度、分选与样品消耗随之变化', |
| 'cytometer.settings': '阈值、电压、延迟与启用参数改变事件率、处理与中止、门分类、记录进度与分选', 'compensation.set': '补偿对数改变处理能力（中止）与分选门分类', |
| 'compensation.calculate': '同compensation.set', 'acquisition.record': '按事件数（或停止门计数、时间上限）完成', |
| 'sort.start': '分选按掩码逐滴决定，抽屉约1 s打开，到目标数完成；收集液量少进废液', 'sort.pause': '暂停期间不分选、计数不变', 'sort.resume': '继续逐滴分选', |
| 'sort.auto_drop_delay': '粗扫7点与细扫13点每点5 s（约100 s），下摄像头看到的左侧流比例随扫描点变化，结束时设定液滴延迟', |
| 'cst.performance_check': '约5 min后给出结果并设定激光延迟与面积系数（之后的信号随之变化）', |
| 'safety.emergency_stop': '进样口约3 s降下、抽屉约1 s关闭、鞘液压力与断点消失、喷嘴处鞘液回落到室温、事件率归零', |
| 'warnings.dismiss': '确认后5 min内不再提示、不会在15 min后自动关液流（液流相关的演化因而不同）', |
| 'cart.refill_sheath': '鞘液低警告在下一个网格解除', 'cart.empty_waste': '废液满警告在下一个网格解除', 'sim.step': '0.1 s网格积分', |
| } |
| PRECONDITIONS = { |
| 'power.set': ('已声明实验室条件；开机时市电在100/115/230 VAC ±10 %', ['plant.configured']), 'power.press_switch': ('同power.set', ['plant.configured']), |
| 'lasers.set': ('通电', ['power.enabled']), 'door.set': ('已声明实验室条件；角度在门的范围内', ['plant.configured']), |
| 'nozzle.install': ('液流关闭；比色池检修门打开≥60°', ['stream.on', 'door.flow_cell_angle_rad']), |
| 'fluidics.startup': ('通电；液流系统处于关机状态且无液流程序在进行；装分选喷嘴；鞘液≥0.5 L；废液≤90 %', ['power.enabled', 'fluidics.state', 'nozzle.installed', |
| 'cart.sheath_level_fraction', 'cart.waste_level_fraction']), |
| 'fluidics.shutdown': ('通电；液流系统就绪；液流关闭；装闭环喷嘴；去离子水与FACSClean足够', ['power.enabled', 'fluidics.state', 'stream.on', 'nozzle.installed', 'cart.cleaning_ok']), |
| 'cleaning.run': ('通电；液流系统就绪；液流关闭；无菌分选准备须装闭环喷嘴；清洗液足够', ['power.enabled', 'fluidics.state', 'stream.on', 'nozzle.installed', 'cart.cleaning_ok']), |
| 'sort_setup.select': ('通电；液流关闭；Sweet Spot关闭；不在分选、自动液滴延迟或CS&T中', ['power.enabled', 'stream.on', 'sweet_spot.on', 'operations.running']), |
| 'sheath.set_pressure': ('通电；Sweet Spot关闭；不在分选中', ['power.enabled', 'sweet_spot.on', 'operations.running']), |
| 'stream.set': ('通电；开液流时：急停未按下、液流系统就绪、装分选喷嘴、鞘液不空', ['power.enabled', 'safety.estop_latched', 'fluidics.state', 'nozzle.installed', |
| 'cart.sheath_level_fraction']), |
| 'breakoff.set': ('通电；至少一个字段；Sweet Spot开启时不能改振幅与频率；分选中不能改频率', ['power.enabled', 'sweet_spot.on', 'operations.running']), |
| 'sweet_spot.set': ('通电；开启时液流开着且断点图像有效', ['power.enabled', 'stream.on', 'breakoff.drop1_px']), |
| 'deflection.set': ('通电；至少一个字段；急停未按下才能开电压；测试分选须电压开', ['power.enabled', 'safety.estop_latched', 'deflection.voltage_on']), |
| 'drop_delay.set': ('通电；不在自动液滴延迟中', ['power.enabled', 'operations.running']), 'drawer.set': ('通电；打开时急停未按下', ['power.enabled', 'safety.estop_latched']), |
| 'amo.set': ('通电；开启时分选收集室门关闭', ['power.enabled', 'door.sort_chamber_angle_rad']), |
| 'sample.agitation': ('通电', ['power.enabled']), 'sample.temperature': ('通电', ['power.enabled']), 'collection.temperature': ('通电', ['power.enabled']), |
| 'sample.chamber_light': ('通电', ['power.enabled']), |
| 'tube.prepare': ('已声明实验室条件；ID唯一、台上≤40管；每个来源为样品（体积足够）或库中微球（可加染色）；总体积不超过管容量', ['tubes.on_bench', 'samples.available']), |
| 'tube.install': ('样品管在实验台；进样口降下且空', ['tubes.on_bench', 'sample.port_state', 'sample.tube_id']), |
| 'tube.remove': ('进样口降下且有管', ['sample.port_state', 'sample.tube_id']), |
| 'sample.load': ('通电；急停未按下；液流开着；进样口降下且有管', ['power.enabled', 'safety.estop_latched', 'stream.on', 'sample.port_state', 'sample.tube_id']), |
| 'sample.unload': ('通电；已装载或正在装载', ['power.enabled', 'sample.port_state']), 'acquisition.set': ('通电；已装载或正在装载', ['power.enabled', 'sample.port_state']), |
| 'acquisition.flow_rate': ('通电', ['power.enabled']), |
| 'cytometer.settings': ('通电；至少一个字段；启用检测器含FSC与SSC；阈值参数已启用且不重复；记录、分选或检查中不能改阈值与启用检测器', |
| ['power.enabled', 'cytometer.detectors_enabled', 'operations.running']), |
| 'compensation.set': ('通电；溢出矩阵对角为1且可逆', ['power.enabled']), |
| 'compensation.calculate': ('通电；记录存在且≥100个事件；对照有阳性群（计算出的溢出<0.1 %按0处理，不计补偿对）', ['power.enabled', 'records.count']), |
| 'gate.define': ('已声明实验室条件；ID唯一；父门存在；字段与类型一致', ['gates.defined']), 'gate.delete': ('门存在；没有子门、未被布局或进行中的记录引用', ['gates.defined']), |
| 'acquisition.record': ('通电；正在采集；ID唯一；无其它记录进行中；存储未满；门存在', ['power.enabled', 'sample.acquiring', 'records.count', 'operations.running']), |
| 'collection.install': ('分选收集室门打开≥60°；没有装置；预加液不超过容量', ['door.sort_chamber_angle_rad', 'collection.device']), |
| 'collection.remove': ('分选收集室门打开≥60°；有装置；不在分选', ['door.sort_chamber_angle_rad', 'collection.device', 'operations.running']), |
| 'sort.layout': ('位置与装置一致；门存在；板须给每孔事件数；该布局不在分选中', ['gates.defined', 'sort.layouts', 'operations.running']), |
| 'sort.start': ('通电；布局存在；装置与布局一致；液流开；偏转板电压开；正在采集；板分选须关分选收集室门；无其它分选类操作', ['power.enabled', 'sort.layouts', 'collection.device', |
| 'stream.on', 'deflection.voltage_on', 'sample.acquiring', |
| 'door.sort_chamber_angle_rad', 'operations.running']), |
| 'sort.pause': ('通电；分选进行中', ['power.enabled', 'sort.state']), 'sort.resume': ('通电；分选已暂停', ['power.enabled', 'sort.state']), |
| 'sort.auto_drop_delay': ('通电；液流开；Sweet Spot开；偏转板电压开；进样口上的管含Accudrop微球且已升起、正在采集；无其它分选类操作', |
| ['power.enabled', 'stream.on', 'sweet_spot.on', 'deflection.voltage_on', 'sample.tube_id', 'sample.port_state', 'sample.acquiring', |
| 'operations.running']), |
| 'cst.performance_check': ('通电；进样口上的管含CS&T微球且已升起、正在采集；无其它分选类操作', ['power.enabled', 'sample.tube_id', 'sample.port_state', 'sample.acquiring', |
| 'operations.running']), |
| 'safety.emergency_stop': ('已声明实验室条件', ['plant.configured']), 'safety.reset_emergency_stop': ('已声明实验室条件', ['plant.configured']), |
| 'warnings.dismiss': ('通电', ['power.enabled']), 'cart.refill_sheath': ('液流关闭；加入后不超过10 L', ['stream.on', 'cart.sheath_level_fraction']), |
| 'cart.empty_waste': ('液流关闭', ['stream.on']), 'cart.refill_cleaning': ('已声明实验室条件', ['plant.configured']), |
| 'statistics.read': ('记录存在（或live）；门存在', ['records.count', 'gates.defined']), 'record.read': ('记录存在', ['records.count']), |
| 'data.export': ('记录存在', ['records.count']), 'sort.side_streams': ('通电', ['power.enabled']), |
| 'tube.mix': ('已声明实验室条件；样品管在实验台上（先卸管、取下）', ['plant.configured', 'tubes.on_bench']), |
| 'sample.provide': ('已声明实验室条件；样品ID唯一、样品数≤40；群体ID不重复；颗粒与染料在库中', ['plant.configured', 'samples.available']), |
| 'fault.inject': ('已声明实验室条件', ['plant.configured']), |
| } |
| _COMMON_ERRORS = ['INVALID_ARGUMENT', 'REQUEST_CONFLICT', 'UNKNOWN_INSTANCE'] |
| _PW = ['PLANT_REQUIRED', 'POWER_OFF'] |
| CAP_ERRORS = { |
| 'plant.configure': ['SEED_FIXED'], 'power.set': ['PLANT_REQUIRED', 'MAINS_OUT_OF_RANGE'], 'power.press_switch': ['PLANT_REQUIRED', 'MAINS_OUT_OF_RANGE'], |
| 'lasers.set': _PW, 'door.set': ['PLANT_REQUIRED'], 'nozzle.install': ['PLANT_REQUIRED', 'STREAM_ON', 'DOOR_CLOSED'], |
| 'fluidics.startup': _PW + ['FLUIDICS_BUSY', 'FLUIDICS_ALREADY_STARTED', 'SORT_NOZZLE_REQUIRED', 'SHEATH_LOW', 'WASTE_FULL'], |
| 'fluidics.shutdown': _PW + ['FLUIDICS_BUSY', 'FLUIDICS_NOT_READY', 'STREAM_ON', 'CLOSED_LOOP_NOZZLE_REQUIRED', 'CLEANING_FLUID_LOW'], |
| 'cleaning.run': _PW + ['FLUIDICS_BUSY', 'FLUIDICS_NOT_READY', 'STREAM_ON', 'CLOSED_LOOP_NOZZLE_REQUIRED', 'CLEANING_FLUID_LOW'], |
| 'sort_setup.select': _PW + ['STREAM_ON', 'SWEET_SPOT_ON', 'SORT_IN_PROGRESS'], 'sheath.set_pressure': _PW + ['SWEET_SPOT_ON', 'SORT_IN_PROGRESS'], |
| 'stream.set': _PW + ['EMERGENCY_STOP_LATCHED', 'FLUIDICS_NOT_READY', 'SORT_NOZZLE_REQUIRED', 'SHEATH_EMPTY'], |
| 'breakoff.set': _PW + ['SWEET_SPOT_ON', 'SORT_IN_PROGRESS'], 'sweet_spot.set': _PW + ['STREAM_OFF', 'NO_BREAKOFF'], |
| 'deflection.set': _PW + ['EMERGENCY_STOP_LATCHED', 'PLATES_OFF'], 'drop_delay.set': _PW + ['SORT_IN_PROGRESS'], 'drawer.set': _PW + ['EMERGENCY_STOP_LATCHED'], |
| 'amo.set': _PW + ['DOOR_OPEN'], 'sample.agitation': _PW, 'sample.temperature': _PW, 'collection.temperature': _PW, 'sample.chamber_light': _PW, |
| 'tube.prepare': ['PLANT_REQUIRED', 'ITEM_EXISTS', 'TOO_MANY_ITEMS', 'INVALID_SOURCE', 'UNKNOWN_SAMPLE', 'INSUFFICIENT_SAMPLE', 'UNKNOWN_PARTICLE', 'UNKNOWN_DYE', |
| 'VOLUME_OUT_OF_RANGE'], |
| 'tube.mix': ['PLANT_REQUIRED', 'UNKNOWN_ITEM', 'TUBE_NOT_ON_BENCH'], |
| 'tube.install': ['PLANT_REQUIRED', 'UNKNOWN_ITEM', 'TUBE_NOT_ON_BENCH', 'PORT_OCCUPIED', 'PORT_NOT_DOWN'], 'tube.remove': ['PLANT_REQUIRED', 'NO_TUBE', 'PORT_NOT_DOWN'], |
| 'sample.load': _PW + ['EMERGENCY_STOP_LATCHED', 'STREAM_OFF', 'NO_TUBE', 'PORT_NOT_DOWN'], 'sample.unload': _PW + ['NOT_LOADED'], 'acquisition.set': _PW + ['NOT_LOADED'], |
| 'acquisition.flow_rate': _PW, 'cytometer.settings': _PW + ['ACQUISITION_IN_PROGRESS', 'INVALID_PARAMETERS', 'INVALID_THRESHOLD'], |
| 'compensation.set': _PW + ['INVALID_SPILLOVER'], 'compensation.calculate': _PW + ['UNKNOWN_RECORD', 'TOO_FEW_EVENTS', 'NO_POSITIVE_POPULATION'], |
| 'gate.define': ['PLANT_REQUIRED', 'ITEM_EXISTS', 'TOO_MANY_ITEMS', 'UNKNOWN_GATE', 'INVALID_GATE'], 'gate.delete': ['PLANT_REQUIRED', 'UNKNOWN_GATE', 'GATE_IN_USE'], |
| 'acquisition.record': _PW + ['ITEM_EXISTS', 'TOO_MANY_ITEMS', 'STORAGE_FULL', 'UNKNOWN_GATE', 'RECORDING_IN_PROGRESS', 'NOT_ACQUIRING'], |
| 'collection.install': ['PLANT_REQUIRED', 'DOOR_CLOSED', 'DEVICE_INSTALLED', 'VOLUME_OUT_OF_RANGE'], |
| 'collection.remove': ['PLANT_REQUIRED', 'NO_DEVICE', 'DOOR_CLOSED', 'SORT_IN_PROGRESS'], |
| 'sort.layout': ['PLANT_REQUIRED', 'TOO_MANY_ITEMS', 'SORT_IN_PROGRESS', 'INVALID_LAYOUT', 'UNKNOWN_GATE'], |
| 'sort.start': _PW + ['UNKNOWN_LAYOUT', 'SORT_IN_PROGRESS', 'DEVICE_MISMATCH', 'STREAM_OFF', 'PLATES_OFF', 'NOT_ACQUIRING', 'DOOR_OPEN'], |
| 'sort.pause': _PW + ['NOT_SORTING'], 'sort.resume': _PW + ['NOT_SORTING', 'NOT_PAUSED'], |
| 'sort.auto_drop_delay': _PW + ['SORT_IN_PROGRESS', 'STREAM_OFF', 'SWEET_SPOT_OFF', 'PLATES_OFF', 'ACCUDROP_BEADS_REQUIRED', 'NOT_ACQUIRING'], |
| 'cst.performance_check': _PW + ['SORT_IN_PROGRESS', 'CST_BEADS_REQUIRED', 'NOT_ACQUIRING'], 'safety.emergency_stop': ['PLANT_REQUIRED'], 'safety.reset_emergency_stop': ['PLANT_REQUIRED'], |
| 'warnings.dismiss': _PW, 'cart.refill_sheath': ['PLANT_REQUIRED', 'STREAM_ON', 'CONTAINER_OVERFLOW'], 'cart.empty_waste': ['PLANT_REQUIRED', 'STREAM_ON'], |
| 'cart.refill_cleaning': ['PLANT_REQUIRED'], 'statistics.read': ['PLANT_REQUIRED', 'UNKNOWN_RECORD', 'UNKNOWN_GATE'], 'record.read': ['UNKNOWN_RECORD'], |
| 'records.list': [], 'sort.side_streams': _PW, 'data.export': ['UNKNOWN_RECORD'], 'events.read': [], 'provenance.read': [], |
| 'sample.provide': ['PLANT_REQUIRED', 'ITEM_EXISTS', 'TOO_MANY_ITEMS', 'DUPLICATE_POPULATION', 'UNKNOWN_PARTICLE', 'UNKNOWN_DYE'], 'tube.inspect': ['UNKNOWN_ITEM'], |
| 'collection.inspect': [], 'ledger.read': [], 'fault.inject': ['PLANT_REQUIRED'], 'sim.step': [], |
| } |
| MODEL_NONE_ZH = { |
| 'plant.configure': '只声明宿主实验室条件', 'fluidics.startup': '液流程序只在过程层', 'fluidics.shutdown': '同左', 'cleaning.run': '同左', |
| 'sort_setup.select': '设定只在过程层', 'breakoff.set': '断点只在过程层（上摄像头图像为数值）', 'sweet_spot.set': '只在过程层', 'sheath.set_pressure': '只在过程层', |
| 'drop_delay.set': '只在过程层', 'amo.set': 'AMO抽吸只在过程层', 'sample.agitation': '只在过程层', 'sample.temperature': '只在过程层', 'collection.temperature': '只在过程层', |
| 'tube.prepare': '样品管没有场景几何（进样口上表面为接口面）', 'tube.mix': '样品管没有场景几何', 'tube.install': '同左', 'tube.remove': '同左', 'acquisition.set': '只在过程层', 'acquisition.flow_rate': '只在过程层', |
| 'cytometer.settings': '只在过程层', 'compensation.set': '只在过程层', 'compensation.calculate': '只在过程层', 'gate.define': '只在过程层', 'gate.delete': '只在过程层', |
| 'acquisition.record': '数据只在过程层', 'collection.install': '收集装置没有单独的场景几何（4路管架为固定外观）', 'collection.remove': '同左', 'sort.layout': '只在过程层', |
| 'sort.pause': '只在过程层', 'sort.resume': '只在过程层', 'sort.auto_drop_delay': '只在过程层', 'cst.performance_check': '只在过程层', 'warnings.dismiss': '只在过程层', |
| 'cart.refill_sheath': '液位只在过程层（场景罐体为固定外观）', 'cart.empty_waste': '同左', 'cart.refill_cleaning': '同左', 'statistics.read': '只读', 'record.read': '只读', |
| 'records.list': '只读', 'sort.side_streams': '只读', 'data.export': '数据操作', 'events.read': '只读', 'provenance.read': '只读', 'sample.provide': '样品没有场景几何', |
| 'tube.inspect': '只读真值（evaluator）', 'collection.inspect': '只读真值（evaluator）', 'ledger.read': '只读账目（evaluator）', 'fault.inject': '评估者故障注入', 'sim.step': '推进时钟'} |
| SCENE_MIRRORED = {f'door.{d}_angle_rad' for d in DOORS} | {'sample.port_position_m', 'sort.drawer_position_m', 'cart.gauge_angle_rad', 'safety.estop_position_m', |
| 'lamp.deflection_plates', 'lamp.chamber_light', 'lamp.estop_light', 'power.enabled'} |
|
|
|
|
| def _model_effects(k, un): |
| if un: |
| return dict(mode='none', description_zh='不支持：不实现，没有模型变化', binding_ids=[]) |
| seen = sorted((set(EFFECTS.get(k, [])) | set(ON_STEP.get(k, []))) & SCENE_MIRRORED) |
| if seen: |
| return dict(mode='host_required', binding_ids=[], |
| description_zh='状态经宿主桥（Matterix）镜像到场景关节或指示灯（' + '、'.join(seen) + '；绑定见合同model_bindings），运行层本身不驱动模型' |
| + ('；' + MODEL_NONE_ZH[k] if k in MODEL_NONE_ZH else '')) |
| return dict(mode='none', description_zh=MODEL_NONE_ZH.get(k, '没有镜像到场景的状态变化'), binding_ids=[]) |
|
|
|
|
| EXEC_TEXT = { |
| 'fluidics.startup': ('约8 min后fluidics.state为ready（操作succeeded）', '取消或断电：液流系统回到shutdown（需重新启动）；已用的鞘液不退回'), |
| 'fluidics.shutdown': ('约3 min后fluidics.state为shutdown（操作succeeded）', '取消或断电：回到shutdown状态（管路中可能残留鞘液，需重做）'), |
| 'cleaning.run': ('清洗时长结束后fluidics.state回到ready（操作succeeded）', '取消：回到ready；断电：回到shutdown'), |
| 'acquisition.record': ('记录到目标事件数（停止门计数）或时间上限后操作succeeded', |
| '取消：已记录的事件保留（操作cancelled）；卸下样品管（SAMPLE_UNLOADED）、急停、堵塞保护或断电：操作failed，已记录事件保留'), |
| 'sort.start': ('所有位置达到目标事件数（板：所有孔）后sort.state为completed（操作succeeded）；没有目标数的位置连续分选直到取消', |
| '取消（cancel）：sort.state为stopped（操作cancelled），抽屉关闭；卸下样品管：sort.state为stopped（操作failed，SAMPLE_UNLOADED；重新开始分选计数从0起）；' |
| '液流关闭、急停、断电或堵塞保护：sort.state为error（操作failed），已收集的颗粒保留'), |
| 'sort.auto_drop_delay': ('粗扫7点与细扫13点（每点5 s，共约100 s）结束后drop_delay.drops设为最优值（操作succeeded）', '取消或条件丢失（液流、偏转板、装载）：液滴延迟不变'), |
| 'cst.performance_check': ('约5 min后cst.status为passed或failed并设定激光延迟与面积系数（操作succeeded）', '取消或条件丢失：结果不变'), |
| } |
| RESOURCES = {'power.set': ['mains'], 'power.press_switch': ['mains'], 'lasers.set': ['lasers'], 'door.set': ['robot_arm'], 'nozzle.install': ['robot_arm', 'nozzle'], |
| 'fluidics.startup': ['fluidics_cart', 'plenum', 'host_clock'], 'fluidics.shutdown': ['fluidics_cart', 'plenum', 'host_clock'], |
| 'cleaning.run': ['fluidics_cart', 'host_clock'], 'stream.set': ['fluidics_cart', 'nozzle'], 'sample.load': ['loading_port', 'host_clock'], |
| 'sample.unload': ['loading_port', 'host_clock'], 'tube.prepare': ['bench'], 'tube.mix': ['robot_arm', 'bench'], 'tube.install': ['robot_arm', 'loading_port'], 'tube.remove': ['robot_arm', 'loading_port'], |
| 'acquisition.record': ['data_system', 'host_clock'], 'sort.start': ['sort_block', 'deflection_plates', 'aspirator_drawer', 'host_clock'], |
| 'sort.auto_drop_delay': ['sort_block', 'accudrop_camera', 'host_clock'], 'cst.performance_check': ['optics', 'host_clock'], |
| 'collection.install': ['robot_arm', 'sort_chamber'], 'collection.remove': ['robot_arm', 'sort_chamber'], 'cart.refill_sheath': ['robot_arm', 'sheath_tank'], |
| 'cart.empty_waste': ['robot_arm', 'waste_tank'], 'cart.refill_cleaning': ['robot_arm', 'cleaning_reservoirs'], 'plant.configure': ['room', 'mains'], |
| 'fault.inject': ['evaluator'], 'sim.step': ['host_clock'], 'data.export': ['workstation_disk']} |
| OBSERVES = {'power.set': ['power.enabled'], 'power.press_switch': ['power.enabled'], 'lasers.set': ['lasers.on', 'lasers.warm'], 'door.set': [f'door.{d}_angle_rad' for d in DOORS], |
| 'fluidics.startup': ['fluidics.state'], 'fluidics.shutdown': ['fluidics.state'], 'cleaning.run': ['fluidics.state'], 'stream.set': ['stream.on', 'sheath.pressure_pa'], |
| 'breakoff.set': ['breakoff.drop1_px', 'breakoff.gap_px'], 'sweet_spot.set': ['sweet_spot.on', 'breakoff.amplitude_v', 'sweet_spot.paused'], |
| 'deflection.set': ['deflection.voltage_on', 'lamp.deflection_plates'], 'sample.load': ['sample.port_state', 'sample.acquiring', 'acquisition.threshold_rate_eps'], |
| 'sample.unload': ['sample.port_state'], 'acquisition.record': ['records.count', 'operations.running'], |
| 'sort.start': ['sort.state', 'sort.counts', 'sort.conflicts', 'sort.efficiency', 'sort.sort_rate_eps'], 'sort.auto_drop_delay': ['drop_delay.drops', 'operations.running'], |
| 'cst.performance_check': ['cst.status'], 'safety.emergency_stop': ['safety.estop_latched', 'stream.on'], 'drawer.set': ['sort.drawer_position_m'], |
| 'cart.refill_sheath': ['cart.sheath_level_fraction'], 'cart.empty_waste': ['cart.waste_level_fraction']} |
| _WB, _TS, _UG, _BRO, _QR, _MSU, _PAV, _UCH, _FP, _RI, _SIM, _H2O = ('user_workbook', 'manufacturer_primary', 'manufacturer_users_guide', 'manufacturer_brochure', |
| 'manufacturer_quick_reference', 'facility_msu', 'facility_pavir', 'facility_uchicago', 'fpbase', |
| 'refractiveindex_info', 'simulation_assumption', 'water_properties_literature') |
| CAP_SOURCES = {k: [_SIM] for k in CAPS} |
| CAP_SOURCES.update({k: [_UG] for k in ('power.set', 'power.press_switch', 'door.set', 'nozzle.install', 'stream.set', 'drop_delay.set', 'drawer.set', 'sample.chamber_light', |
| 'tube.install', 'tube.remove', 'sample.unload', 'acquisition.set', 'warnings.dismiss', 'safety.reset_emergency_stop', |
| 'gate.define', 'gate.delete', 'records.list', 'events.read', 'sort.pause', 'sort.resume')}) |
| CAP_SOURCES.update({'lasers.set': [_UG, _TS], 'fluidics.startup': [_UG, _TS, _SIM], 'fluidics.shutdown': [_UG, _TS], 'cleaning.run': [_TS, _UG, _SIM], |
| 'sort_setup.select': [_UG, _TS, _MSU, _SIM], 'breakoff.set': [_UG, _TS, _SIM, _H2O], 'sweet_spot.set': [_UG, _UCH, _SIM], |
| 'sheath.set_pressure': [_UG, _TS], 'deflection.set': [_UG, _SIM], 'amo.set': [_TS, _SIM], 'sample.agitation': [_TS, _PAV, _SIM], |
| 'tube.mix': [_PAV, _SIM], |
| 'sample.temperature': [_TS, _UG], 'collection.temperature': [_TS, _SIM], 'tube.prepare': [_TS, _FP, _RI, _SIM], 'sample.load': [_UG], |
| 'acquisition.flow_rate': [_UG, _SIM], 'cytometer.settings': [_TS, _UG, _SIM], 'compensation.set': [_TS, _SIM], 'compensation.calculate': [_SIM], |
| 'acquisition.record': [_TS, _SIM, _FP, _RI], 'collection.install': [_TS, _UG, _SIM], 'collection.remove': [_SIM], |
| 'sort.layout': [_UG, _PAV, _TS], 'sort.start': [_UG, _TS, _UCH, _SIM], 'sort.auto_drop_delay': [_TS, _UG, _SIM], 'cst.performance_check': [_SIM, _TS], |
| 'safety.emergency_stop': [_UG, _UCH], 'cart.refill_sheath': [_TS, _UG], 'cart.empty_waste': [_UG, _TS], 'cart.refill_cleaning': [_TS], |
| 'statistics.read': [_SIM], 'record.read': [_SIM], 'sort.side_streams': [_UG, _SIM], 'data.export': [_TS, _SIM], 'provenance.read': [_FP, _RI, _TS], |
| 'sample.provide': [_FP, _RI, _SIM], 'tube.inspect': [_SIM], 'collection.inspect': [_SIM], 'ledger.read': [_SIM], 'fault.inject': [_SIM, _UG, _UCH], |
| 'plant.configure': [_TS, _SIM]}) |
| CAP_SOURCES.update({k: [_TS, _UG] for k in UNSUPPORTED}) |
| PARAM_ZH = {'room_k': '实验室室温', 'mains_voltage_v': '供电电压', 'noise_seed': '噪声随机数种子（只在首次声明时生效）', 'room_drift_k_per_s': '室温漂移速率'} |
| _DEFAULT_LIMIT = '过程层实现；机器人与硬件层未实现；整体模型边界见mechanisms.flow_sorting_process.limitations。' |
| CAP_LIMITS = { |
| 'sort_setup.select': ['预设按用户指南表3-1（70 µm High 70 psi/90 kHz/60 V/44滴、Medium 35 psi/60 kHz/50 V（衰减开）/45滴、100 µm Low 20 psi/30 kHz/20 V（衰减开）/29滴、' |
| 'Custom 70 µm 20 psi/30 kHz/10 V/10滴（非分选高灵敏度模式：偏转板0 V、侧流0、激光延迟±82 µs、面积系数0.75/0.50/0.25、窗口延长4 µs），' |
| '偏转板电压、侧流电荷、激光延迟、面积系数、窗口延长2 µs）与技术规格（70 psi/90 kHz）；85 µm（45 psi/53 kHz，MSU）的振幅、液滴延迟、偏转与激光延迟，' |
| '以及130 µm（10 psi/16 kHz）全部为假设；Custom的振幅与液滴延迟不是断点设定（喷嘴耦合与流道体积沿用70 µm）；第2–4滴电荷校正与相位不建模。'], |
| 'breakoff.set': ['断点：Rayleigh毛细不稳定（无粘性色散式，水的表面张力IAPWS 2014、密度Tanaka 2001）× 驱动扰动 = 振幅×耦合系数；耦合系数按各预设默认值把断点放在同一图像位置' |
| '（20滴@70 µm High，假设）反推——70 µm High与Medium（衰减0.25，假设）得到同一耦合系数（2.53e-8 m/V）；耦合随鞘液温度−2 %/K（假设）；Drop 1按频闪锁定的液滴位置跳变' |
| '（液滴间距57 px@High，厂家），Gap为液柱末端到第一滴的距离。'], |
| 'sweet_spot.set': ['伺服速率粗调2 V/s、细调0.2 V/s（工程值）；Gap偏差>1 px时调节、>2 px或Drop 1偏差>10 px时暂停分选（厂家）；喷嘴全堵时执行厂家描述的保护动作，部分堵塞不触发停止' |
| '（设施指南），只因Gap偏差暂停分选。'], |
| 'stream.set': ['射流速度=Cd√(2ΔP/ρ)；Cd在70 psi时取0.9（库中假设），其它预设按表3-1激光延迟反推（Medium 0.849、100 µm 0.743；液滴波长/喷嘴直径因此为4.1–4.4，接近Rayleigh最优4.5），' |
| '85/130 µm按波长=4.4倍直径（假设）；液流开启后喷嘴处鞘液约20 min升温1.5 K（假设，对应“等30 min液流稳定”）。'], |
| 'deflection.set': ['侧流落点=K×充电比例×偏转板电压（+电压中心×0.1），K按默认电荷把近侧流放到4路12×75管架±14 mm、远侧流±31.5 mm（管架几何为假设），随射流速度平方反比；' |
| '展宽（近0.35 mm、远0.5 mm）与Gap偏差、过驱、部分堵塞的增宽为工程值。'], |
| 'sample.load': ['进样口约3 s升起（工程值）；样品流量按流速档线性10–120 µl/min（厂家），加压后1 s时间常数建立；死体积12×75管50 µl（假设）。'], |
| 'acquisition.flow_rate': ['芯流半径=√(Q样品/(π v芯))，芯流在65 µm宽光束中的位置使信号rCV≈R²/(2w²)：10 µl/min约0.5 %，120 µl/min约5 %（几何推导）。'], |
| 'cytometer.settings': ['PMT增益∝(V/500 V)^7、FSC增益∝(V/500 V)^3、每光电子1.8通道@500 V、电子噪声8通道、FSC杂散噪声10通道为工程值；' |
| '处理能力=min(70,000/s, 70,000/s×14/(启用检测器数+补偿对数/2))（厂家最高70,000/s（8参数12对补偿）；参数更多时的下降为假设）；' |
| '超过时随机丢弃（电子中止）；W=A/H×65,536（假设）。'], |
| 'acquisition.record': ['信号：每颗粒光电子=Σ分子数×（消光系数×激光处激发×光通量×曝光时间×量子产率×饱和×NA 1.2收集×光学透过0.35×带通内发射×PMT量子效率），背景按厂家85 MESF-FITC/29 MESF-PE灵敏度拟合；' |
| '散射按Mie表（FSC 1–14°、SSC NA锥）；光电子泊松统计、激光噪声0.6 %、预热、芯流位置、激光延迟捕获、面积系数与脉冲堆叠（窗口延长内的颗粒合成一个事件）；' |
| '颗粒到达为硬核泊松过程（相邻两颗粒至少相隔两者半长之和/芯流速度，排除体积），所以重合的两个细胞形成更宽的脉冲（W变大）。'], |
| 'sort.start': ['逐滴决定：事件按设定液滴延迟分到液滴（1/32滴相位），按厂家掩码定义（Yield/Purity/Phase、Single Cell）判断，不同位置抢同一液滴为冲突；颗粒实际所在液滴按真实液滴延迟' |
| '（激光到喷嘴的输运+断点滴数）加断点抖动0.02滴；阈值以下的颗粒看不见但随液滴走（可能混入）；侧流落点偏离收集管口时颗粒损失；抽屉未打开时偏转液滴落到抽屉。'], |
| 'sort.auto_drop_delay': ['自动程序（技术规格“全自动液滴延迟”）：Initial模式粗扫当前延迟±3滴（1滴步长），Fine Tune模式细扫±0.6滴（0.1步长），每点5 s（共约100 s）；' |
| '每点的得分是下摄像头（滤片在位）5 s内看到的Accudrop微球中进入左侧流的比例（偏转份额按掩码与抖动的解析式，逐颗二项抽取）；取前三点加权平均' |
| '（程序细节为假设）。'], |
| 'sample.agitation': ['搅拌档位Off/100/200/300 rpm为假设（厂家：软件可调）；300 rpm时只阻止60 %的Stokes沉降、不会让已沉降的颗粒再悬浮（假设；设施指南：' |
| '300 rpm搅拌也不太有效）；沉降前锋越过取样针（离管底2 mm）后该群体取不到。'], |
| 'tube.mix': ['混匀使所有群体的沉降前锋归零（完全再悬浮）；管须在实验台上（先卸管、取下）；没有剪切对细胞的影响。'], |
| 'sample.unload': ['卸管结束进行中的分选（sort.state=stopped，操作failed：SAMPLE_UNLOADED）与记录；重新开始分选时计数从0起（厂家用户指南第151页）。'], |
| 'collection.install': ['ACDU板：6/24/48孔（SBS孔径34.8/15.6/11.0 mm、孔容16.8/3.4/1.6 ml）、96与384孔；捕获半径与台移动时间为假设；收集管或孔溢出时按溢出份额' |
| '逐颗二项抽取损失颗粒（真值；仪器没有液位传感）。'], |
| 'statistics.read': ['记录的统计默认按记录时保存的补偿矩阵（与records.list的compensated一致），compensation=current时套用当前实验补偿；live按当前补偿。'], |
| 'record.read': ['默认按记录时保存的补偿矩阵，compensation=current时套用当前实验补偿；返回compensated。'], |
| 'data.export': ['默认按记录时保存的补偿矩阵，compensation=current时套用当前实验补偿；只导出CSV文本（不写真实FCS二进制）。'], |
| 'cst.performance_check': ['CS&T简化：亮微球（2e5 MESF，四种染料等量的混合，假设）的rCV按光电子、微球本身2 %、激光噪声与芯流位置计算，<6 %且激光已预热为通过（阈值为假设）；' |
| '激光延迟设为真值±0.2 µs、面积系数±1 %。'], |
| 'amo.set': ['AMO只影响气溶胶逃逸账目（正常模式逃逸率1e-5、快速1e-6、关闭1e-3、开门0.05，堵塞时气溶胶产生率×10，为工程值；厂家：应激条件下<3个Glo Germ颗粒）。'], |
| 'sample.temperature': ['进样室一阶到温，时间常数15 min（厂家：约45 min到温）；进样室打开时只能维持40 %的温差（假设）；样品管5 min时间常数跟随。'], |
| } |
| LIMITATIONS = [ |
| '选定配置：BD FACSAria III（2018规格），405/488/561/633 nm四激光、10个荧光检测器（V450/50、V510/50、B530/30、B695/40、YG582/15、YG610/20、YG710/50、YG780/60、R660/20、R780/60）' |
| '+FSC/SSC，ACDU、AMO与收集冷却选件；355 nm紫外激光、索引分选、玻片与自定义装置不在配置内。', |
| '液流为集总模型：射流速度、流量、比色池芯流速度、Rayleigh断点与液滴延迟按0.1 s网格计算；没有液滴形成的流体力学仿真、卫星滴与液滴充电的电场计算。', |
| '光学为每颗粒的光子预算（库中FPbase光谱、厂家带通、PMT量子效率曲线与透过率为工程值），绝对灵敏度按厂家MESF标定；Mie散射为均匀球；细胞抗原密度、染色强度、自发荧光与粒径分布由样品给出。', |
| '分选逻辑按厂家对掩码的文字描述实现（1/32滴）；同一tick（0.1 s）边界两侧的相邻液滴不互相检查（每tick约9000滴中1滴）；第2–4滴电荷校正与相位不建模；' |
| '表3-1 Custom为非分选模式（偏转板0 V），其振幅与液滴延迟不是断点设定。', |
| '颗粒到达为硬核泊松过程（排除体积），颗粒间没有流体力学相互作用；样品管沉降为各群体的Stokes沉降前锋（无浓度梯度、无团聚动力学），搅拌只部分有效。', |
| '样品管、收集管、板与液滴没有场景几何；配管、装管、装收集装置、开关门与加液为宿主/机器人抽象，没有接触验证；工作站软件界面（图、门的绘制）以能力接口表示。', |
| '气溶胶、无菌、细胞活力与温度对细胞的影响只以账目或温度读数表示；没有真实BD FACSAria III的硬件接口。', |
| ] |
|
|
|
|
| def _sampling_text(k): |
| if k == 'acquisition.events_processed': |
| return 'Running total of the processed events since the tube was loaded (updated on the fixed 0.1 s host grid).' |
| if k.startswith(('acquisition.', 'accudrop.')) or k == 'sort.sort_rate_eps': |
| return 'Counted over the last 1 s of the fixed 0.1 s host grid.' |
| if k.startswith(('sensor', 'truth.', 'sheath.', 'breakoff.', 'cart.', 'sample.', 'sort.', 'lamp.', 'lasers.', 'collection.temperature', 'sweet_spot', 'operations', |
| 'warnings', 'errors', 'fluidics', 'safety', 'cst')) or k == 'clock.time_s': |
| return 'Integrated on the fixed 0.1 s host grid; between grid points the last grid value is held.' |
| return 'Changes when a command is accepted; no other time dynamics.' |
|
|
|
|
| def _errors_of(k): |
| if k in UNSUPPORTED: |
| return ['UNSUPPORTED'] + _COMMON_ERRORS |
| extra = ['ACCESS_DENIED'] if (k in _CONTROL_GUARDED or k in _RECORD_QUERIES or k in ('compensation.calculate', 'tube.prepare') or CAPS[k]['visibility'] != 'agent') else [] |
| return list(dict.fromkeys(CAP_ERRORS.get(k, []) + _COMMON_ERRORS + extra)) |
|
|
|
|
| def _foreign_text(k): |
| if k in _CONTROL_GUARDED: |
| return '；另一个agent的异步操作（液流程序、记录、分选、自动液滴延迟、CS&T）进行中时，agent调用被拒（ACCESS_DENIED；未通电时开机除外）；只能操作自己配的样品管、布局与门' |
| if k in _RECORD_QUERIES or k == 'compensation.calculate': |
| return '；agent只能读自己的记录（ACCESS_DENIED）' |
| return '' |
|
|
|
|
| def _params(): |
| fl, op = fluidics(), optics() |
| cal = _cal() |
| pb = _photon() |
| P = {} |
|
|
| def doc(name, val, unit, meaning, src): |
| P[name] = dict(value=val, unit=unit, meaning_zh=meaning, evidence='documented', source_ids=list(src), uncertainty=None) |
|
|
| def asm(name, val, unit, meaning, unc, src=(_SIM,)): |
| P[name] = dict(value=val, unit=unit, meaning_zh=meaning, evidence='assumption', source_ids=list(src), uncertainty=unc) |
| doc('sheath_pressure_range_pa', [5 * PSI, 75 * PSI], 'Pa', '鞘液压力5–75 psi', [_TS, _WB]) |
| doc('drop_drive_frequency_range_hz', [1.0, 100000.0], 'Hz', '液滴驱动频率1–100,000 Hz（2003版指南为1–102 kHz）', [_TS, _WB]) |
| doc('amplitude_range_v', [1.0, 80.0], 'V', '液滴驱动振幅1–80 V', [_UG]) |
| doc('drop_delay_range_drops', [10.0, 140.0], '1', '液滴延迟10–140滴', [_UG]) |
| doc('drop1_target_range_px', list(DROP1_RANGE), '1', 'Drop 1目标100–600像素；默认330', [_UG]) |
| doc('gap_default_px', GAP_DEFAULT, '1', 'Gap默认6像素', [_UG]) |
| doc('sweet_spot_tolerances_px', dict(gap_adjust=1.0, gap_pause=GAP_TOL_PAUSE, drop1=DROP1_TOL), '1', 'Gap偏差>1 px调节、>2 px暂停分选；Drop 1允许10 px偏差', [_UG]) |
| doc('drop_spacing_high_px', 57.0, '1', 'Drop 1按液滴间距约57像素跳变', [_UG]) |
| doc('plate_voltage_range_v', [0.0, 6000.0], 'V', '偏转板电压0–6000 V（开时两板间约12,000 V电位差）', [_UG]) |
| doc('window_extension_s', fl['window_extension_us'] * 1e-6, 's', '窗口延长2 µs（表3-1）', [_UG]) |
| doc('sample_flow_m3_s', [fl['sample_flow_rate_ul_min'][0] * 1e-9 / 60, fl['sample_flow_rate_ul_min'][1] * 1e-9 / 60], 'm3/s', '流速档1–11约10–120 µl/min', [_UG]) |
| doc('laser_warmup_s', WARMUP_S, 's', '激光开启后预热30 min', [_UG]) |
| doc('sample_temperature_setpoints_k', SAMPLE_SETPOINTS_K, 'K', '进样温控4、20、37、42 °C', [_TS, _WB]) |
| doc('sample_chamber_settle_s', 2700.0, 's', '进样室约45 min到温（须保持关闭）', [_UG]) |
| doc('reservoir_volumes_m3', dict(sheath=0.010, waste=0.010, cleaning=0.005), 'm3', '10 L鞘液与废液罐、5 L清洗液瓶', [_TS]) |
| doc('cart_air_pressure_pa', [80 * PSI, 100 * PSI], 'Pa', '运行时液流车气压80–100 psi（约88 psi）', [_UG]) |
| doc('max_event_rate_eps', RATE_REF, '1/s', '12对补偿、8参数时最高70,000事件/s', [_TS, _WB]) |
| doc('adc_channels', 262144, '1', '262,144通道（10 MHz ADC）', [_TS]) |
| doc('data_parameters', dict(total=20, fluorescence=18, scatter=2), '1', '最多20参数（18荧光+2散射）', [_TS, _WB]) |
| doc('beam_size_m', [BEAM_H, BEAM_W], 'm', '光斑高9 ±3 µm、宽65 ±7 µm', [_TS]) |
| doc('numerical_aperture', op['numerical_aperture'], '1', '凝胶耦合物镜NA 1.2', [_TS]) |
| doc('laser_min_power_w', {L: op['lasers'][L]['min_power_w'] for L in LASERS}, 'W', '激光头输出：405 >50 mW、488 >20 mW、561 >50 mW、633 >18 mW', [_TS]) |
| doc('fluorescence_sensitivity_mesf', dict(fitc=85.0, pe=29.0), '1', '70 psi、90 kHz、SPHERO RCP-30-5A：85 MESF-FITC、29 MESF-PE', [_TS]) |
| doc('cv_spec', dict(pi_cen=0.03, hoechst_cen=0.035, doublet_singlet_ratio=[1.95, 2.05]), '1', 'PI-CEN <3 %、Hoechst-CEN <3.5 %，双联/单体比1.95–2.05', [_TS]) |
| doc('sort_performance_spec', dict(purity_min=0.98, yield_of_poisson_min=0.80, ways=4), '1', |
| '4路分选：纯度>98 %、得率>泊松预期的80 %（条件见sort_performance_threshold_rate、sort_performance_sheath_pressure_pa、sort_performance_frequency_hz）', [_TS]) |
| doc('sort_performance_threshold_rate', 25000.0, '1/s', '性能规格的平均阈值率25,000事件/s', [_TS]) |
| doc('sort_performance_sheath_pressure_pa', 70 * PSI, 'Pa', '性能规格的鞘液压力70 psi', [_TS]) |
| doc('sort_performance_frequency_hz', 90000.0, 'Hz', '性能规格的液滴驱动频率90 kHz', [_TS]) |
| doc('shutdown_s', SHUTDOWN_S, 's', 'Fluidics Shutdown约3 min', [_UG]) |
| doc('amo_exchange_rate_per_s', dict(AMO_EXCHANGE_PER_S), '1/s', 'AMO抽换收集室体积的速率：每分钟16次（正常）/69次（快速）', [_TS]) |
| doc('operating_temperature_k', list(ROOM_RANGE_K), 'K', '运行环境17.5–27.5 °C', [_TS]) |
| doc('max_power_w', 1500.0, 'W', '最大功率1,500 W（100/115/230 VAC、50/60 Hz）', [_TS]) |
| doc('precision_modes', {k: dict(yield_mask=v[0], purity_mask=v[1], phase_mask=v[2], single_cell=v[3]) for k, v in PRECISION.items()}, '1', |
| '精度模式掩码（1/32滴）：Purity 32/32/0、Yield 32/0/0、Single Cell 0/32/16（单细胞）、Initial 32/0/0、Fine Tune 0/0/0、4-Way Purity 0/32/0', [_UG, _PAV]) |
| doc('level_warning_timing_s', dict(repeat=300.0, auto_stream_off=900.0), 's', '鞘液低/废液满警告每5 min重复，15 min未确认自动关液流', [_UG]) |
| doc('nozzles_m', [70e-6, 85e-6, 100e-6, 130e-6], 'm', '喷嘴70、85、100、130 µm', [_TS, _WB]) |
| doc('sort_devices', sorted(DEVICES), '1', '2路12×75/15 mL、4路1.5 mL/12×75、ACDU板6、24、48、96、384孔', [_TS]) |
| pres = fl['presets'] |
| tab = ('70_high', '70_medium', '100', '70_custom') |
| q_hi = _q_sheath(70e-6, cal['presets']['70_high']['v']) |
| dl_asm = {n: fl['laser_delay_us']['70_high'] * 1e-6 * q_hi / _q_sheath(int(cal['presets'][n]['nozzle_um']) * 1e-6, cal['presets'][n]['v']) for n in ('85', '130')} |
| doc('sort_setup_nozzle_m', {n: pres[n]['nozzle_m'] for n in pres}, 'm', 'Sort Setup预设的喷嘴（表3-1：High、Medium与Custom 70 µm、Low 100 µm；85与130 µm为本模型的预设名）', |
| [_UG, _TS]) |
| doc('sort_setup_sheath_pressure_pa', {**{n: pres[n]['sheath_pressure_pa'] for n in tab}, '85': pres['85']['sheath_pressure_pa']}, 'Pa', |
| '鞘液压力：表3-1 High 70、Medium 35、Low 20、Custom 20 psi；85 µm 45 psi（MSU设施文件）', [_UG, _TS, _MSU]) |
| doc('sort_setup_frequency_hz', {**{n: pres[n]['drop_drive_frequency_hz'] for n in tab}, '85': pres['85']['drop_drive_frequency_hz']}, 'Hz', |
| '液滴驱动频率：表3-1 High 90、Medium 60、Low 30、Custom 30 kHz；85 µm 53 kHz（MSU：51–55 kHz，取中值）', [_UG, _TS, _MSU]) |
| doc('sort_setup_amplitude_v', {n: pres[n]['amplitude_v'] for n in tab}, 'V', '振幅：表3-1 60、50、20、10 V', [_UG]) |
| doc('sort_setup_attenuation', {n: PRESET_ATTEN[n] for n in tab}, '1', '衰减：表3-1 High关、Medium开、Low开、Custom关', [_UG]) |
| doc('sort_setup_drop_delay_drops', {n: pres[n]['drop_delay_drops'] for n in tab}, '1', '液滴延迟：表3-1 44、45、29、10滴（Custom非分选）', [_UG]) |
| doc('sort_setup_plate_voltage_v', {n: PRESET_PLATE_V[n] for n in tab}, 'V', '偏转板电压：表3-1 6000、5000、5000、0 V', [_UG]) |
| doc('sort_setup_side_stream_fraction', {n: cal['presets'][n]['side_frac'] for n in tab}, '1', '远左/左/右/远右充电比例：表3-1百分比/100', [_UG]) |
| doc('sort_setup_laser_delay_s', {n: fl['laser_delay_us'][n] * 1e-6 for n in tab}, 's', '激光延迟（红为负、紫为正）：表3-1 36、54、40、82 µs', [_UG]) |
| doc('sort_setup_area_scaling', {n: dict(fl['area_scaling'][n]) for n in tab}, '1', '面积系数（蓝/红/紫）：表3-1', [_UG]) |
| doc('sort_setup_window_extension_s', {n: fl['window_extension_us_by_preset'][n] * 1e-6 for n in tab}, 's', '窗口延长：表3-1 2、2、2、4 µs', [_UG]) |
| asm('sort_setup_assumed_amplitude_v', {n: pres[n]['amplitude_v'] for n in ('85', '130')}, 'V', '85与130 µm预设的振幅', '假设（BD默认值未取得；按断点位置缩放）', |
| [_SIM, _MSU]) |
| asm('sort_setup_assumed_drop_delay_drops', {n: pres[n]['drop_delay_drops'] for n in ('85', '130')}, '1', '85与130 µm预设的液滴延迟', '假设（按Accudrop确定）', [_SIM]) |
| asm('sort_setup_assumed_attenuation', {n: PRESET_ATTEN[n] for n in ('85', '130')}, '1', '85与130 µm预设的衰减', '假设', [_SIM]) |
| asm('sort_setup_assumed_plate_voltage_v', {n: PRESET_PLATE_V[n] for n in ('85', '130')}, 'V', '85与130 µm预设的偏转板电压', '假设', [_SIM]) |
| asm('sort_setup_assumed_side_stream_fraction', {n: cal['presets'][n]['side_frac'] for n in ('85', '130')}, '1', '85与130 µm预设的侧流充电比例', |
| '假设：按偏转常数把近侧流放到±14 mm、远侧流2.25倍', [_SIM]) |
| asm('sort_setup_assumed_laser_delay_s', dl_asm, 's', '85与130 µm预设的激光延迟', '假设：按比色池流量从High的36 µs缩放', [_SIM, _UG]) |
| asm('sort_setup_assumed_area_scaling', {n: dict(PRESET_ASF['100']) for n in ('85', '130')}, '1', '85与130 µm预设的面积系数', '假设：沿用100 µm Low的值', [_SIM, _UG]) |
| asm('sort_setup_130_sheath_pressure_pa', pres['130']['sheath_pressure_pa'], 'Pa', '130 µm预设的鞘液压力10 psi', '假设（按100 µm缩放；BD默认值未取得）', [_SIM]) |
| asm('sort_setup_130_frequency_hz', pres['130']['drop_drive_frequency_hz'], 'Hz', '130 µm预设的液滴驱动频率16 kHz', '假设（液滴波长约4.4倍喷嘴直径）', [_SIM]) |
| asm('discharge_coefficients', {k: round(v['cd'], 4) for k, v in cal['presets'].items()}, '1', '各预设喷嘴流量系数（射流速度=Cd√(2ΔP/ρ)）', |
| '拟合值：High取0.9（库中假设），Medium与Low由表3-1激光延迟36/54/40 µs反推；85/130 µm按液滴波长=4.4倍直径', [_SIM, _UG]) |
| asm('transducer_coupling_m_per_v', {k: v['G'] for k, v in cal['presets'].items()}, 'm/V', '液滴驱动振幅到射流扰动的耦合系数', |
| '拟合值：各预设默认振幅把断点放在20滴@70 µm High的同一图像位置（Rayleigh增长）；70 µm High与Medium一致（2.53e-8 m/V）', [_SIM, _UG]) |
| asm('laser_to_nozzle_volume_m3', {k: v['vdead'] for k, v in cal['presets'].items()}, 'm3', '激光交点到喷嘴出口的鞘液体积（液滴延迟的输运部分）', |
| '拟合值：各预设默认液滴延迟（表3-1、假设值）减去断点滴数', [_SIM, _UG]) |
| asm('deflection_constant_m_per_v', {k: v['K_defl'] for k, v in cal['presets'].items()}, 'm/V', '侧流落点/（充电比例×偏转板电压）', |
| '拟合值：默认电荷落在管架位置（管架几何为假设）；85/130 µm按速度与液滴直径缩放', [_SIM, _UG]) |
| asm('camera_pixel_m', cal['px'], 'm', '断点摄像头像素尺寸', '拟合值：High液滴间距=57像素（厂家）', [_SIM, _UG]) |
| asm('breakoff_drops_high', NB_REF_70, '1', '70 µm High默认时喷嘴到断点的液滴数', '假设（约6 mm）') |
| asm('attenuation_factor', ATTENUATION, '1', '衰减开时驱动振幅系数', '假设；使High与Medium默认值得到同一耦合系数') |
| asm('transducer_temperature_coefficient_per_k', TRANSDUCER_TC, '1/K', '耦合系数随鞘液温度的变化（断点漂移）', '假设：每K约7 px Drop 1漂移') |
| asm('sheath_warmup_delta_k', SHEATH_WARM_K, 'K', '液流开启后喷嘴处鞘液的升温', '假设（“等30 min液流稳定”）') |
| asm('sheath_warmup_tau_s', SHEATH_WARM_TAU_S, 's', '喷嘴处鞘液升温的时间常数', '假设（“等30 min液流稳定”）') |
| asm('cuvette_channel_area_m2', CHANNEL_AREA, 'm2', '比色池流道截面（160×250 µm）', '库中假设') |
| asm('core_speed_ratio', CORE_SPEED_RATIO, '1', '芯流速度/平均速度', '工程值（矩形管道中心线速度约2倍平均）') |
| asm('spot_spacing_m', cal['spot_m'], 'm', '各激光光斑相对488 nm的距离（激光延迟=距离/芯流速度）', '拟合值：High的±36 µs；561 nm光斑在405 nm之后（假设）', [_SIM, _UG]) |
| asm('pulse_size_factor', PULSE_K, '1', '脉宽中颗粒直径的份额', '工程值') |
| asm('channels_per_photoelectron_500v', K_CH, '1', '500 V时每光电子的ADC通道数', '工程值（暗珠噪声≈电子噪声时电压约550 V）') |
| asm('pmt_gain_exponent', PMT_EXP, '1', 'PMT增益∝(V/500 V)^7', '库中假设') |
| asm('fsc_gain_exponent', FSC_EXP, '1', 'FSC增益∝(V/500 V)^3', '假设') |
| asm('electronic_noise_ch', 8.0, '1', '电子噪声（通道rms）', '库中假设') |
| asm('fsc_noise_ch', FSC_NOISE_CH, '1', 'FSC杂散光噪声', '假设') |
| asm('width_scale', WIDTH_SCALE, '1', 'W=A/H×65,536', '假设（FACSDiva约定）') |
| asm('laser_noise_rms', LASER_NOISE, '1', '预热后激光强度噪声', '工程值') |
| asm('laser_warmup_tau_s', WARMUP_TAU_S, 's', '预热过程的功率与噪声时间常数（开机时功率85 %、噪声+4 %）', '假设') |
| asm('electrical_power_w', dict(base=BASE_POWER_W, lasers=LASER_POWER_W, sample_temperature_control=SAMPLE_TC_POWER_W), 'W', '整机功耗分配', '假设（厂家最大1,500 W）') |
| asm('scatter_calibration', dict(fsc_ch_per_photon_500v=pb['k_fsc'], ssc_transmission=pb['t_ssc']), '1', 'FSC与SSC标度', '工程值：淋巴细胞FSC-A 60,000@250、SSC-A 15,000@300 V') |
| asm('sweet_spot_slew_v_s', [SS_COARSE_V_S, SS_FINE_V_S], 'V/s', 'Sweet Spot粗调/细调振幅速率', '工程值') |
| asm('breakoff_jitter_drops', DD_JITTER, '1', '稳定液流的断点抖动', '工程值') |
| asm('side_stream_spread_m', list(SIDE_SIGMA_M), 'm', '近/远侧流在收集高度的展宽', '工程值') |
| asm('device_geometry', {k: dict(capture_r=v['capture_r'], **({'locations': {a: b[1] for a, b in v['locations'].items()}} if v['kind'] == 'tubes' else {'x': v['x']})) |
| for k, v in DEVICES.items()}, 'm', '收集装置管口位置与捕获半径', '假设（管架几何按默认电荷反推）') |
| asm('tube_capacity_m3', {k: v['capacity_m3'] for k, v in TUBE_TYPES.items()}, 'm3', '样品管容量', '工程值') |
| asm('tube_dead_volume_m3', {k: v['dead_m3'] for k, v in TUBE_TYPES.items()}, 'm3', '样品管死体积（取样针取不到）', '工程值') |
| asm('tube_inner_radius_m', {k: v['radius_m'] for k, v in TUBE_TYPES.items()}, 'm', '样品管内半径（液面高度）', '工程值') |
| asm('bead_stock_per_m3', BEAD_STOCK_PER_M3, '1/m3', '微球储液浓度', '假设（1e6/ml）') |
| asm('fluidics_durations_s', dict(startup=STARTUP_S, **CLEAN_S), 's', 'Fluidics Startup与清洗模式时长', '假设（指南：清洗5–10 min、无菌准备10–40 min）') |
| asm('prime_sheath_m3', PRIME_SHEATH_M3, 'm3', '启动时灌注用的鞘液量', '假设') |
| asm('temperature_time_constants_s', dict(chamber=SAMPLE_CHAMBER_TAU_S, tube=TUBE_TAU_S, collection=COLLECTION_TAU_S), 's', '进样室、样品管与收集管的温度时间常数', |
| '进样室按45 min到温；其余为工程值') |
| asm('agitation_rates_hz', dict(AGITATION), '1/s', '搅拌档位Off/100/200/300 rpm的转速', '假设（厂家只说软件可调；PAVIR设施指南提到300 rpm）', [_SIM, _TS, _PAV]) |
| asm('agitation_settling_reduction', AGITATION_EFFECT, '1', '300 rpm搅拌阻止的Stokes沉降份额（其它档按转速比例）', '假设（设施指南：300 rpm也不太有效）', [_SIM, _PAV]) |
| asm('collection_temperature_range_k', list(COLLECTION_RANGE_K), 'K', '收集冷却/加热范围', '假设（循环水选件）') |
| asm('aerosol_generation_rate_per_s', dict(idle=5.0, sorting=50.0, clog=500.0), '1/s', '气溶胶液滴产生率（液流、分选、堵塞）', '工程值（厂家：AMO下应激条件<3个Glo Germ颗粒）') |
| asm('aerosol_escape_fraction', dict(door_open=0.05, closed=1e-3, amo_normal=1e-5, amo_rapid=1e-6), '1', '气溶胶逃出分选收集室的份额', '工程值') |
| asm('stream_settling', dict(probe_height_m=PROBE_HEIGHT_M), 'm', '不搅拌时颗粒按Stokes沉降，沉降前锋过探针后取不到', '工程值') |
| return P |
|
|
|
|
| def _pre_slots(k): |
| errs = CAP_ERRORS.get(k, []) |
| ids = (['plant.configured'] if 'PLANT_REQUIRED' in errs else []) + (['power.enabled'] if 'POWER_OFF' in errs else []) + list(PRECONDITIONS[k][1]) |
| return list(dict.fromkeys(ids + (['operation.started_by_other_agent'] if k in _CONTROL_GUARDED else []))) |
|
|
|
|
| def _pre_text(k): |
| errs, text = CAP_ERRORS.get(k, []), PRECONDITIONS[k][0] |
| if 'POWER_OFF' in errs and '通电' not in text: |
| text = '通电（否则POWER_OFF）；' + text |
| if 'PLANT_REQUIRED' in errs and '实验室条件' not in text: |
| text = '已声明实验室条件（否则PLANT_REQUIRED）；' + text |
| return text |
|
|
|
|
| def export_bd_facsariaiii_contract_metadata(): |
| slots, caps = {}, {} |
| for k, v in SLOTS.items(): |
| slots[k] = dict(meaning_zh=v['meaning'], component_ids=[v['component']], value_schema=copy.deepcopy(v['schema']), unit=v['unit'], |
| reference_conditions=v['reference'], origin=v['origin'], visibility=v['visibility'], access='read_only', |
| read_binding=dict(backend='host', artifact_id='runtime', accessor=f'BdFacsariaiiiSession.read(state_ids=[{k!r}])'), write_via=None, |
| sampling=dict(mode='instant', time_domain='simulation', window_description=_sampling_text(k)), source_ids=['simulation_assumption']) |
| for k, v in CAPS.items(): |
| un = k in UNSUPPORTED |
| async_ = k in ASYNC |
| c = {key: copy.deepcopy(v[key]) for key in ['input_schema', 'output_schema', 'component_ids', 'function_zh', 'kind', 'visibility', 'example_arguments']} |
| c.update(availability='unsupported' if un else 'implemented', |
| implementation={layer: 'absent' if un or layer in ('scene', 'robot', 'hardware') else 'implemented' for layer in ['process', 'scene', 'robot', 'hardware', 'host']}, |
| binding=None if un else dict(backend='host', artifact_id='runtime', entrypoint='asset_runtime.bd_facsariaiii.BdFacsariaiiiSession.invoke', |
| invocation=f'session.invoke(instance_id="facsaria_iii_01",capability_id={k!r},arguments={v["example_arguments"]!r},request_id="unique")'), |
| preconditions=[] if un or k not in PRECONDITIONS else [dict(description_zh=_pre_text(k) + _foreign_text(k) + '；被拒时状态不变。', |
| state_ids=_pre_slots(k), |
| enforced_by='runtime', check='BdFacsariaiiiRuntime.invoke / BdFacsariaiiiSession._guard')], |
| state_effects=[dict(state_id=s, timing='on_step' if k == 'sim.step' else 'immediate', description_zh='设定或立即改变的量') for s in dict.fromkeys(EFFECTS.get(k, []))], |
| observes=[] if un else list(OBSERVES.get(k, [])), model_effects=_model_effects(k, un), |
| execution=dict(mode='asynchronous' if async_ else 'synchronous', time_domain='simulation', |
| completion_criterion=EXEC_TEXT[k][0] if k in EXEC_TEXT else '原子设定、配置或查询（进样口、抽屉、温度与液流在之后的step中演化）', |
| completion_state_ids=['operations.running'] if async_ else [], timeout_s=None, |
| cancellation='supported' if async_ else 'unsupported', retry='same_request_id', resources=list(RESOURCES.get(k, [])), |
| partial_failure_zh=EXEC_TEXT[k][1] if k in EXEC_TEXT else ('不支持：不执行，状态不变' if un else '同步原子操作：成功时一次写入全部效果，被拒时状态不变')), |
| errors=[dict(code=e, meaning_zh=ERROR_ZH.get(e, e), side_effects='none') for e in _errors_of(k)], |
| verification=[], limitations=[UNSUPPORTED[k]] if un else list(CAP_LIMITS.get(k, [_DEFAULT_LIMIT])), source_ids=list(CAP_SOURCES[k])) |
| if k in ON_STEP: |
| c['state_effects'] += [dict(state_id=s, timing='on_step', description_zh=ON_STEP_ZH.get(k, '随step演化')) for s in dict.fromkeys(ON_STEP[k]) |
| if not (k == 'sim.step' and s in EFFECTS.get(k, []))] |
| caps[k] = c |
| mechanism = dict( |
| component_ids=['fluidics_body', 'optics_body', 'sort_block', 'deflection_plates', 'aspirator_drawer', 'sample_chamber', 'loading_port', 'flow_cell_door', |
| 'sort_chamber_door', 'cart_body', 'sheath_tank', 'waste_tank', 'gauge_needle', 'emergency_stop', 'deflection_lamp', 'estop_light', 'chamber_light'], |
| state_ids=list(slots), implementation='lumped', |
| meaning_zh='流式细胞分析与分选：液流车与压力缓冲罐、射流与Rayleigh断点（Drop 1/Gap、Sweet Spot、液滴延迟）、四激光光子预算（FPbase光谱、PMT、噪声、芯流位置、激光延迟、面积系数）、' |
| 'Mie散射、阈值、脉冲堆叠与电子中止、补偿、门与统计、BD掩码逐滴分选、侧流落点与收集、Accudrop、CS&T、进样与收集温控、急停与堵塞保护、液位与气溶胶账目', |
| equations=['v_jet = Cd sqrt(2 dP / rho(T)); Q = pi a^2 v_jet; v_core = 2 Q / A_channel; lambda = v_jet / f', |
| 'omega^2 = sigma(T) / (rho a^3) x (1 - x^2) I1(x) / I0(x), x = 2 pi a / lambda (Rayleigh); N_breakoff = (f / omega) ln(a / (G (1 + beta dT) A_eff))', |
| 'drop delay = f V_dead / Q + N_breakoff; Drop 1 = first strobe-locked drop p0 + j S below the jet end; Gap = Drop 1 - r_drop - breakoff', |
| 'pe = sum_dye N_mol x QY x (t_ex) x k_ex / (1 + k_ex tau) x cone(NA 1.2) x 0.35 x f_band x QE, k_ex = 3.82e-25 eps(lambda_L) Phi_L; background fitted to 85 / 29 MESF', |
| 'pos = exp(-2 y^2 / w^2), y uniform over the core radius sqrt(Q_s / (pi v_core)); A = pe x (V / 500)^7 x 1.8 x capture(laser delay) x ASF_set / ASF_true', |
| 'H = A tau_small / sqrt(tau_small^2 + (0.8 D / v_core)^2); W = 65,536 A / H; events within (tau + window extension) merge; ' |
| 'processed rate <= min(70,000, 70,000 x 14 / (n_det + n_pairs / 2))', |
| 'sort: drop k = floor(t f + DD_set), phase in 1/32; yield / purity / phase masks and single cell per the User\'s Guide; particle drop = floor(t f + DD_true + jitter)', |
| 'side stream x = K q V_plate (q = charge fraction); capture = Phi((x_t + r - x) / s) - Phi((x_t - r - x) / s)', |
| 'arrivals: hard-core Poisson, t_(i+1) - t_i >= (L_i + L_(i+1)) / (2 v_core); settling front dz/dt = v_Stokes (1 - 0.6 r_ag), r_ag = agitation rate / 300 rpm; tube.mix resets the front'], |
| parameters=_params(), source_ids=[_SIM, _WB, _TS, _UG, _BRO, _MSU, _PAV, _UCH, _FP, _RI, _H2O], limitations=list(LIMITATIONS)) |
| import importlib.util |
| spec = importlib.util.spec_from_file_location('_aria_local_annotations', ROOT / 'scripts/asset_runtime/_annotations.py') |
| ann = importlib.util.module_from_spec(spec) |
| spec.loader.exec_module(ann) |
| ann.KEY_ZH.update({k: v['meaning'] for k, v in SLOTS.items()}) |
| ann.PARAM_ZH.update(PARAM_ZH) |
| ann.annotate_export('bd_facsariaiii', caps, slots, {'flow_sorting_process': mechanism}, inputs={'plant.configure': (PLANT, PLANT_EXAMPLE)}) |
| for k, v in SLOTS.items(): |
| slots[k]['meaning_zh'] = v['meaning'] |
| if v['reference']: |
| slots[k]['reference_conditions'] = v['reference'] |
| return dict(asset_type_id=ASSET_TYPE_ID, catalog_id=CATALOG_ID, capabilities=caps, state_slots=slots, mechanisms={'flow_sorting_process': mechanism}) |
|
|
