ELEC 06 — Dove sono stati calcolati i numeri: GX-TXT, GNU Octave e riproducibilità
Progetto ELEC · ELEC 01 — Azoto, cloro e pH
Come si risale da un risultato pubblicato al Job che l’ha prodotto? Le due integrazioni native a 0 e 100 rpm, gli script in GNU Octave, gli output canonici e i controlli ancora da eseguire ricostruiscono la provenienza dei risultati.
Nativo non significa assenza di codice del modello
Un ambiente scientifico riutilizzabile non elimina le definizioni matematiche: ne rende espliciti ingresso, unità, parametri, versione e produzione dei risultati. In questo progetto «nativo» significa che un vero Viewer o un progetto registrato ha ammesso gli ingressi, eseguito un calcolo e pubblicato gli output attraverso il percorso GX-TXT. GNU Octave può essere il motore di un Job autentico; il suo impiego non rende esterno il risultato. Viceversa importare un CSV prodotto da un batch esterno non crea retroattivamente una produzione nativa.
Chi riprende l’analisi può usare le definizioni fornite scegliendo sorgenti e variabili, parametri e maschere Fixed, intervalli e varianti dei grafici nei controlli previsti. Non deve riscrivere il programma per ogni confronto. Una nuova equazione fuori dai modelli consegnati richiede invece una definizione scientifica e una risorsa coerente; l’interfaccia non sostituisce questa scelta. I commenti inglesi degli script originali qui consultabili sono conservati integralmente.
| Strumento | Produzione effettiva | Che cosa non significa |
|---|---|---|
| Digitizer | Centri delle figure, calibrazione immagine/assi e identità di curva/punto | Non dati grezzi degli autori o barre d’errore non acquisite |
| Fitter, SafeFormula e Model registrato | Calibrazioni, controlli a parametri tutti fissi, risposte ai tempi richiesti e residui | Non selezione automatica del meccanismo; codice riutilizzabile può essere parte del Model |
| Dataset Expression | Trasformazioni algebriche con unità, p_max e frazioni sulle vere righe pH | Non simulazione dinamica o misura di un flusso |
| Worksheet | Legami fra sorgenti, conversioni e bilanci/rapporti con provenienza di riga | Non creazione di osservazioni mancanti o riallineamento non dichiarato |
| Mathematics Explorer | Sensibilità simbolico-numeriche pubblicate, come le nove componenti iniziali al pH | Non condizioni locali misurate nel reattore |
| Rete di reazione generica e Script/Job | Integrazione fresca di equazioni e pubblicazione multitabella | Non identità automatica fra specie simulate e saggi |
| Curve Viewer | Confronto, assi/stili, Graph e Workspace modificabili | Un overlay non riesegue un fit o un’ODE |
Transizioni realmente documentate
I vecchi batch standalone V6 ridotto e V7 limite rapido rimangono materiale storico di riferimento. Il successivo Job nativo del ridotto, script-20261118T093245Z-4091642-1794994365236654, ha prodotto nuovamente lo studio a 23 casi con il progetto registrato elec_reduced_competing_scenarios: è riproduzione numerica della stessa formulazione nel suo ambito dichiarato, non importazione dei CSV storici e non validazione fisica. Il protocollo completo del limite rapido non risulta concluso; le sole proiezioni scalari effettivamente valutate non lo completano.
I Gate 1 e 2 erano già calcoli registrati nativi, rispettivamente di bilancio e benchmark neutro fabbricato. Il benchmark non è una misura di trasporto nel becher. L’esportazione CSV del Gate 1 usa un diverso vero Job Python di sola serializzazione; alcune copie di presentazione del Gate 2 sono invece serializzazioni offline di HDF5 già nativi. Né una serializzazione né una copia per il sito sono una nuova simulazione. La mappa storica delle transizioni conserva le distinzioni, con le successive integrazioni generiche aggiornate qui.
Le famiglie operative, S2 e H_P/H_L non sono tutte ripetizioni dello stesso studio: cambiano sorgenti, parametri liberi o assunzioni. Le sei previsioni sul cloro sono valutazioni fissate, non nuovi fit. Il Model ODE registrato è stato usato tramite Fitter; non si attribuiscono quei fit al successivo editor generico. Gli script della rete generica eseguono poi gli stessi due pool operativi nelle varianti 0 e 100 rpm, con parametri già accettati: non introducono una nuova calibrazione.
Due vere esecuzioni della rete generica
| Caso | Job completato, exit 0 | Griglia dichiarata | Tabelle canoniche |
|---|---|---|---|
| 0 rpm | script-20261120T043918Z-2293038-1795149558474630 | 61 tempi, 0–1200 s | 9 |
| 100 rpm | script-20261120T064007Z-2529515-1795156807585422 | 151 tempi, 0–3000 s | 9 |
I quattro file sotto sono copiati dalle revisioni congelate di entrambi i Job, con identità di byte verificata dalla mappa di esecuzione. network_entry.m è l’ingresso effettivo; reaction_network.m, network_numeric.m e network_publish.m costituiscono la catena di helper direttamente chiamata. I sorgenti fixed/reduced/fast presenti nello stesso progetto ammesso non vengono dichiarati eseguiti da questi Job. I parametri appartengono ai modelli salvati e alle ricevute, non a costanti aggiunte ai listati per questa pagina.
L’ODE riusa Numeric e il backend dichiarato ode45; le tolleranze si applicano a quantità molari ed estensioni, non direttamente alle concentrazioni. Gli istanti effettivi restituiti vengono conservati. Finitezza, positività dichiarata e bilanci numerici sono verifiche software; un bilancio elementare completo non è dichiarato per pool senza composizione e carica identificate. Il confronto analitico indipendente controlla le traiettorie già native e non le sostituisce.
Script originali consultabili
Ogni listato è inizialmente chiuso, con nome, ruolo, versione ed esecuzioni d’origine. Il download conserva i byte originali e i commenti inglesi. Non sono i sorgenti della nuova forzante 0.2.6, né un candidato di ottimizzazione.
La raccolta comprende inoltre i sorgenti registrati esatti dei Gate, del Runner ridotto e dei Model scalari realmente invocati, deduplicati per identità di byte. Un commento storico «UNEXECUTED» resta nel file originale: la ricevuta del Job successivo ne documenta l’esecuzione senza riscriverne i commenti. I tentativi falliti sono conservati e marcati separatamente nell’archivio tecnico; non costituiscono risultati scientifici accettati. La presenza di una funzione nel file non dimostra che ogni suo ramo o proiezione sia stato chiamato. I vecchi sorgenti standalone esterni non sono sostituiti con candidati preparati né spacciati per sorgenti nativi verificati.
network_entry.m — Generic actual entrypoint
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Generic0.2.5
script-20261120T043918Z-2293038-1795149558474630 COMPLETED exit0; script-20261120T064007Z-2529515-1795156807585422 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 32dbca680c1882d36474477c7c410e3c3cba99d3c6a55b6226f4ebf6e44e5143
% Generic data-only network workflow. Actual Viewer Bridge admits native Jobs.
gxtxt_api_require('NUMERIC_API_v1@1');
gxtxt_api_require('DOCUMENT_SOURCE_API_v1@1');
gxtxt_api_require('DATASET_PUBLICATION_API_v2@2');
ctx=gxtxt_context();q=ctx.parameters;source_receipt=struct();
if strcmp(q.mode,'import')
if !isfield(ctx.inputs,'network'),error('Network:Source','Bind a canonical network text Dataset');endif
source_receipt=gxtxt_api_call('DOCUMENT_SOURCE_API_v1','read',{struct('dataset_id',ctx.inputs.network.dataset_id,'limit',262144)});
if !source_receipt.complete,error('Network:Source','Truncated network JSON cannot be imported');endif
q.network_json=source_receipt.source;
endif
if numel(q.network_json)>262144,error('Network:Size','Network JSON exceeds 256 KiB');endif
network=jsondecode(q.network_json,'makeValidName',false);model=reaction_network('validate',network);
record=struct('schema','gxtxt.reaction_network_execution.v1','module_version','0.2.5',...
'mode',q.mode,'run_id',ctx.run_id,'script_sha256',ctx.script_sha256,...
'network_sha256',hash('sha256',q.network_json),'network_json',q.network_json,...
'source_receipt',source_receipt,'input_bindings',ctx.inputs,...
'composition_status',model.composition_status,'scientific_status','User-defined network; no physical validation claimed');
if any(strcmp(q.mode,{'save_model','solve'}))
if isempty(regexp(q.output_prefix,'^[A-Za-z][A-Za-z0-9_.-]{0,100}$','once')),error('Network:Prefix','A fresh bounded output prefix is required');endif
description=gxtxt_api_call('DOCUMENT_SOURCE_API_v1','describe',{struct()});
record.model_publication=gxtxt_api_call('DOCUMENT_SOURCE_API_v1','write',{struct('mode','new','dataset_id',[q.output_prefix '.network'],'text',[q.network_json sprintf('\n')],'expected_session',description.session)});
endif
if strcmp(q.mode,'solve')
result=reaction_network('solve',network);
if !result.valid_trajectory
% Failed raw trajectory is a Job artifact, never an accepted canonical curve.
save('-binary',fullfile(ctx.output_dir,'FAILED_RAW_NETWORK_TRAJECTORY.mat'),'result','network');
if strcmp(result.numerical_domain_status,'FAILED_NONFINITE_COMPUTED_QUANTITIES')
error('Network:NumericalDomain','Computed publication quantities are nonfinite (%s); raw failure retained only as Job artifact',strjoin(result.numerical_domain_failures,','));
endif
error('Network:Positivity','Accepted amount exceeds its declared negative tolerance; raw failure retained only as Job artifact');
endif
record.solver=struct('requested_method',result.solver.method,'actual_backend',result.solver.backend_method,'integration_protocol',result.solver.integration_protocol,'returned_solver_rows',numel(result.solver.time),'retained_rows',numel(result.time_s));
record.solver.requested_time_s=result.requested_time_s;record.solver.actual_time_s=result.time_s;
record.solver.state_timestamp_policy=result.solver.state_timestamp_policy;
record.publications=network_publish(ctx,q.output_prefix,network,result);
record.accepted_state_positivity=result.accepted_state_positivity;
record.positivity_scope=result.positivity_scope;
record.numerical_domain_status=result.numerical_domain_status;
endif
record.state='EXECUTED';
fid=fopen(fullfile(ctx.output_dir,'viewer_bridge_result.json'),'w');
if fid<0,error('Network:Receipt','Cannot create native Job receipt');endif
unwind_protect
fprintf(fid,'%s\n',jsonencode(struct('schema','gxtxt.viewer_bridge_result.v1','module_id',ctx.module_id,'run_id',ctx.run_id,'action','run','result',record)));
unwind_protect_cleanup,fclose(fid);end_unwind_protect
reaction_network.m — Direct called helper in the actual generic entrypoint/ODE/publication source chain
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Generic0.2.5
script-20261120T043918Z-2293038-1795149558474630 COMPLETED exit0; script-20261120T064007Z-2529515-1795156807585422 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 b7ecdc0e3084fdf7cfe433a0fadff5888f5d146346a4749a9c99609b47f89aa6
function out=reaction_network(action,net,varargin)
% Data-driven homogeneous/boundary amount network; public Numeric owns maths.
% No ELEC constants, cases, equations or reaction identities are built in.
if strcmp(action,'validate'),out=prepare(net);return;endif
model=prepare(net);
if strcmp(action,'rates'),out=rates(model,varargin{1},varargin{2});return;endif
if !strcmp(action,'solve'),error('Network:Action','Unknown network action');endif
grid=linspace(net.time.start_s,net.time.end_s,net.time.samples)';
% Retain/check all provider-returned adaptive/refined rows on each two-point
% span. dense_times merges grids and hides internal rows; never use it.
ns=numel(model.n0);nr=numel(model.reactions);
rhs=@(t,y) derivative(model,t,y,ns);
state=zeros(numel(grid),ns+nr);state(1,:)=[model.n0;zeros(nr,1)]';
retained_time=grid;accepted_time=grid(1);accepted_state=state(1,:);segments={};backends={};
for interval=1:numel(grid)-1
segment=network_numeric('foundation','ode','solve',rhs,[retained_time(interval);grid(interval+1)],state(interval,:)',net.solver);
if !segment.success||segment.cancelled||segment.terminated_by_event||numel(segment.time)<2||any(!isfinite(segment.time))||any(diff(segment.time)<0)||segment.time(end)<=retained_time(interval)||any(segment.state_imaginary(:)!=0)
error('Network:Integration','Public ODE segment did not complete the requested real endpoint');
endif
if rows(segment.state_real)!=numel(segment.time)||columns(segment.state_real)!=ns+nr||any(!isfinite(segment.state_real(:)))
error('Network:Integration','Public ODE returned an invalid state trajectory');
endif
state(interval+1,:)=segment.state_real(end,:);
% Public completion can return a terminal time differing by floating
% representation. Carry/publish the ACTUAL time; never relabel its state.
retained_time(interval+1)=segment.time(end);
accepted_time=[accepted_time;segment.time(2:end)];
accepted_state=[accepted_state;segment.state_real(2:end,:)];
segments{end+1}=segment;backends{end+1}=segment.backend_method;
endfor
result=struct('method',net.solver.method,'backend_method',strjoin(unique(backends,'stable'),','),...
'integration_protocol','ADJACENT_TWO_POINT_SPANS_WITH_FULL_RETURNED_STATE_CHECK',...
'time',accepted_time,'state_real',accepted_state,'segments',{segments},'success',true,...
'retained_time',retained_time,'requested_time',grid,'retained_state_real',state,...
'state_timestamp_policy','ACTUAL_PROVIDER_TERMINAL_TIMES_CARRIED_FORWARD');
amounts=state(:,1:ns);extents=state(:,ns+1:end);accepted_amounts=accepted_state(:,1:ns);
rr=zeros(rows(amounts),nr);
for k=1:rows(amounts),rr(k,:)=rates(model,retained_time(k),amounts(k,:)')';endfor
exchange=extents(:,model.boundary)*(model.composition*model.S(:,model.boundary))';
totals=amounts*model.composition';initial=model.composition*model.n0;
out=struct('time_s',retained_time,'requested_time_s',grid,'amounts_mol',amounts,'concentrations_mol_m3',amounts/net.volume_m3,...
'rates_mol_s',rr,'extents_mol',extents,'balance_totals_mol',totals,...
'external_exchange_mol',exchange,'balance_residual_mol',totals-repmat(initial',rows(amounts),1)-exchange,...
'kinematic_residual_mol',amounts-repmat(model.n0',rows(amounts),1)-extents*model.S',...
'minimum_amount_mol',min([accepted_amounts;amounts]),'negative_amount_count',sum(accepted_amounts<0),...
'accepted_minimum_amount_mol',min(accepted_amounts),'retained_minimum_amount_mol',min(amounts),...
'retained_negative_amount_count',sum(amounts<0),...
'composition_status',model.composition_status,'balance_labels',{model.balance_labels},...
'species_ids',{model.species_ids},'reaction_ids',{model.reaction_ids},'solver',result,...
'scientific_status','User-defined network; numerical execution is not physical validation');
out.accepted_state_positivity='PASS_DECLARED_AMOUNT_TOLERANCES';
out.positivity_scope='PROVIDER_RETURNED_STATES_AND_RETAINED_ENDPOINTS_NOT_CONTINUOUS_TIME_PROOF';
out.numerical_domain_status='PASS_FINITE_COMPUTED_QUANTITIES';out.numerical_domain_failures={};
fields={'time_s','requested_time_s','amounts_mol','concentrations_mol_m3','rates_mol_s','extents_mol',...
'balance_totals_mol','external_exchange_mol','balance_residual_mol','kinematic_residual_mol',...
'minimum_amount_mol','negative_amount_count','accepted_minimum_amount_mol','retained_minimum_amount_mol','retained_negative_amount_count'};
for f=fields
v=out.(f{1});
if !isnumeric(v)||!isreal(v)||any(!isfinite(v(:))),out.numerical_domain_failures{end+1}=f{1};endif
endfor
out.valid_trajectory=isempty(out.numerical_domain_failures);
if !out.valid_trajectory,out.numerical_domain_status='FAILED_NONFINITE_COMPUTED_QUANTITIES';endif
for k=1:ns
if !model.species{k}.signed_reservoir&&any([accepted_amounts(:,k);amounts(:,k)]<-model.species{k}.absolute_tolerance_mol)
out.valid_trajectory=false;out.accepted_state_positivity='FAILED_AMOUNT_BELOW_DECLARED_TOLERANCE';
endif
endfor
endfunction
function m=prepare(n)
required(n,{'schema','id','volume_m3','species','parameters','reactions','time','solver'});
if !strcmp(n.schema,'gxtxt.reaction_network.v1'),error('Network:Schema','Unsupported network schema');endif
identity(n.id);positive(n.volume_m3,'Constant volume m^3');
required(n.time,{'start_s','end_s','samples'});required(n.solver,{'method','reltol','abstol','max_step'});
finite_scalar(n.time.end_s,'End time');finite_scalar(n.time.samples,'Time samples');
positive(n.solver.reltol,'Solver relative tolerance');positive(n.solver.abstol,'Solver absolute tolerance');positive(n.solver.max_step,'Maximum solver step');
if !any(strcmp(n.solver.method,{'ode45','ode15s'})),error('Network:Solver','Choose public Numeric ode45 or ode15s');endif
if !all(ismember(fieldnames(n.solver),{'method','reltol','abstol','max_step'})),error('Network:Solver','Unsupported solver setting');endif
positive(n.time.end_s-n.time.start_s,'Time interval');finite_scalar(n.time.start_s,'Start time');
if n.time.samples<2||n.time.samples>10001||n.time.samples!=fix(n.time.samples),error('Network:Size','Time samples must be an integer from 2 to 10001');endif
species=items(n.species);parameters=items(n.parameters);rx=items(n.reactions);
ns=numel(species);nr=numel(rx);
if ns<1||ns>48||nr<1||nr>128||numel(parameters)>14||ns+numel(parameters)+2>64,error('Network:Size','Network exceeds 48 species, 128 reactions, 14 parameters or 64 expression symbols');endif
ids={};n0=zeros(ns,1);elements={};element_known=false(1,ns);charge_known=false(1,ns);symbols=struct('t',n.time.start_s,'V',n.volume_m3);units=struct('t','s','V','m^3');
for k=1:ns
s=species{k};required(s,{'id','formula','elements','charge','initial_value','unit','signed_reservoir','absolute_tolerance_mol','initial_basis'});identity(s.id);
positive(s.absolute_tolerance_mol,'Accepted-state absolute amount tolerance mol');
if !ischar(s.formula)||numel(s.formula)>1024,error('Network:Formula','Formula label must be bounded text; explicit composition governs balance');endif
if any(strcmp(s.id,[ids,{'t','V','pi','e'}])),error('Network:Identity','Species IDs must be unique and not reserved');endif
ids{end+1}=s.id;finite_scalar(s.initial_value,'Initial amount');
if !islogical(s.signed_reservoir)||!isscalar(s.signed_reservoir),error('Network:Reservoir','signed_reservoir must be a boolean');endif
if s.initial_value<0&&!s.signed_reservoir,error('Network:Amount','Negative initial amount requires explicit signed bookkeeping reservoir');endif
target='mol';if strcmp(s.initial_basis,'concentration'),target='mol/m^3';elseif !strcmp(s.initial_basis,'amount'),error('Network:Basis','Initial basis must be amount or concentration');endif
conversion=network_numeric('expression_evaluate','a',struct('a',s.initial_value),struct('a',s.unit),struct('output_unit',target));
n0(k)=conversion.values;if strcmp(s.initial_basis,'concentration'),n0(k)*=n.volume_m3;endif;
computed_finite(n0(k),'Converted initial amount');symbols.(s.id)=n0(k);units.(s.id)='mol';
if !isstruct(s.elements)||numel(s.elements)!=1,error('Network:Elements','Element composition must be an element-to-count object');endif
for e=fieldnames(s.elements)'
if isempty(regexp(e{1},'^[A-Z][a-z]?$','once')),error('Network:Elements','Element keys must be chemical element symbols');endif
v=s.elements.(e{1});finite_scalar(v,'Element count');
if v<0||v!=fix(v)||v>flintmax,error('Network:Elements','Element counts must be exact nonnegative integers within binary64 range');endif
elements=union(elements,e);element_known(k)=element_known(k)||v>0;
endfor
if !isempty(s.charge),finite_scalar(s.charge,'Formal species charge');charge_known(k)=true;endif
endfor
pids={};
for k=1:numel(parameters)
p=parameters{k};required(p,{'id','value','unit'});identity(p.id);finite_scalar(p.value,'Parameter value');
if any(strcmp(p.id,[ids,pids,{'t','V','pi','e'}])),error('Network:Identity','Parameter IDs must be unique and not reserved');endif
% Parse/convert each declared unit through the public expression owner.
network_numeric('expression_evaluate','a',struct('a',p.value),struct('a',p.unit));
pids{end+1}=p.id;symbols.(p.id)=p.value;units.(p.id)=p.unit;
endfor
C=zeros(numel(elements)+1,ns);labels=[elements,{'formal_charge'}];
for k=1:ns
for j=1:numel(elements),if isfield(species{k}.elements,elements{j}),C(j,k)=species{k}.elements.(elements{j});endif,endfor
if !isempty(species{k}.charge),C(end,k)=species{k}.charge;endif
endfor
computed_finite(n0/n.volume_m3,'Initial concentrations');
computed_finite(C*n0,'Initial declared element/charge totals');
S=zeros(ns,nr);rids={};boundary=false(1,nr);
for j=1:nr
r=rx{j};required(r,{'id','kind','stoichiometry','rate_type','rate_basis'});identity(r.id);
if any(strcmp(r.id,rids)),error('Network:Identity','Reaction IDs must be unique');endif;rids{end+1}=r.id;
if !any(strcmp(r.kind,{'homogeneous','boundary'})),error('Network:Boundary','Reaction kind must be homogeneous or boundary');endif
boundary(j)=strcmp(r.kind,'boundary');
if !any(strcmp(r.rate_basis,{'amount','concentration'})),error('Network:Basis','Rate basis must be amount or concentration');endif
if !isstruct(r.stoichiometry)||numel(r.stoichiometry)!=1,error('Network:Stoichiometry','Stoichiometry must be an ID-to-number object');endif
for q=fieldnames(r.stoichiometry)'
k=find(strcmp(q{1},ids));if isempty(k),error('Network:Species','Unknown stoichiometric species');endif
finite_scalar(r.stoichiometry.(q{1}),'Stoichiometric coefficient');S(k,j)=r.stoichiometry.(q{1});
endfor
if !any(S(:,j)),error('Network:Stoichiometry','A reaction requires nonzero stoichiometry');endif
if strcmp(r.kind,'homogeneous')
involved=find(S(:,j)!=0);
verified_rows=[repmat(all(element_known(involved)),numel(elements),1);all(charge_known(involved))];
verify_balance(C(verified_rows,:),S(:,j));
endif
if strcmp(r.rate_type,'mass_action')
required(r,{'rate_constant','orders'});
if !isstruct(r.orders)||numel(r.orders)!=1,error('Network:Order','Kinetic orders must be an ID-to-number object');endif
if !any(strcmp(r.rate_constant,pids)),error('Network:Parameter','Mass-action constant must reference a declared parameter');endif
expr=r.rate_constant;
for q=fieldnames(r.orders)'
if !any(strcmp(q{1},ids)),error('Network:Species','Unknown kinetic-order species');endif
v=r.orders.(q{1});finite_scalar(v,'Kinetic order');if v<0,error('Network:Order','Mass-action kinetic orders must be nonnegative');endif
expr=[expr '*' q{1} '^(' sprintf('%.17g',v) ')'];
endfor
elseif strcmp(r.rate_type,'expression')
required(r,{'expression'});expr=r.expression;
else error('Network:Rate','Rate type must be mass_action or expression');endif
if !ischar(expr)||numel(expr)>8192,error('Network:Rate','Rate expression must be bounded text');endif
u=units;target='mol/s';
if strcmp(r.rate_basis,'concentration'),target='mol/m^3/s';for k=1:ns,u.(ids{k})='mol/m^3';endfor,endif
% Shared public grammar/dimensional checker admits no code evaluation.
network_numeric('expression_dimensions',expr,u,target);
rx{j}.compiled_expression=expr;rx{j}.symbol_units=u;rx{j}.output_unit=target;
endfor
known=all(element_known)&&all(charge_known);
status='CONSISTENT_DECLARED_COMPOSITION_TO_ARITHMETIC_PRECISION';if !known,status='UNVERIFIED_MISSING_COMPOSITION_OR_CHARGE';endif
m=struct('network',n,'species', {species},'species_ids',{ids},'reaction_ids',{rids},'reactions',{rx},'n0',n0,'S',S,...
'composition',C,'element_composition_known',element_known,'charge_known',charge_known,'composition_status',status,'balance_labels',{labels},'symbols',symbols,'units',units,'boundary',boundary);
% Validate initial numeric rate domains separately from dimensions.
rates(m,n.time.start_s,n0);
endfunction
function out=rates(m,t,n)
symbols=m.symbols;symbols.t=t;out=zeros(numel(m.reactions),1);
for j=1:numel(m.reactions)
r=m.reactions{j};
for k=1:numel(n)
symbols.(m.species_ids{k})=n(k);
if strcmp(r.rate_basis,'concentration'),symbols.(m.species_ids{k})/=m.network.volume_m3;endif
endfor
result=network_numeric('expression_evaluate',r.compiled_expression,symbols,r.symbol_units,struct('output_unit',r.output_unit));
v=result.values;if !isscalar(v)||!isreal(v)||!isfinite(v)||v<0,error('Network:RateDomain','Directed channel rate must be one finite nonnegative real value; solver trial domain errors are not accepted-state positivity checks');endif
if strcmp(r.rate_basis,'concentration'),v*=m.network.volume_m3;endif
if !isfinite(v)||!isreal(v)||v<0,error('Network:RateDomain','Directed amount rate is not finite nonnegative after physical volume conversion');endif
out(j)=v;
endfor
endfunction
function out=derivative(m,t,y,ns),r=rates(m,t,y(1:ns));out=[m.S*r;r];endfunction
function out=items(v),if isempty(v),out={};elseif iscell(v),out=v(:)';elseif isstruct(v),out=num2cell(v);else error('Network:Schema','Expected an array of objects');endif,endfunction
function required(v,fields),if !isstruct(v)||!all(isfield(v,fields)),error('Network:Schema','Network object lacks required fields');endif,endfunction
function identity(s),if !ischar(s)||isempty(regexp(s,'^[A-Za-z][A-Za-z0-9_]{0,47}$','once')),error('Network:Identity','IDs must be bounded stable ASCII identifiers');endif,endfunction
function finite_scalar(v,label),if !isnumeric(v)||!isscalar(v)||!isreal(v)||!isfinite(v),error('Network:Domain','%s must be finite real scalar',label);endif,endfunction
function positive(v,label),finite_scalar(v,label);if v<=0,error('Network:Domain','%s must be positive',label);endif,endfunction
function computed_finite(v,label),if !isnumeric(v)||!isreal(v)||any(!isfinite(v(:))),error('Network:NumericalDomain','%s cannot be represented as finite real computed values',label);endif,endfunction
function verify_balance(C,s)
% Floating dot-product roundoff envelope, not a chemical acceptance tolerance.
terms=C.*repmat(s',rows(C),1);scale=sum(abs(terms),2);residual=sum(terms,2);
operations=2*numel(s);gamma=operations*eps/(1-operations*eps);bound=gamma*scale;
if any(!isfinite(terms(:)))||any(!isfinite(scale))||any(!isfinite(residual))||any(!isfinite(bound))
error('Network:Balance','Declared balance arithmetic is not finite');
endif
if any(((C!=0)&repmat(s'!=0,rows(C),1)&(terms==0))(:))
error('Network:Balance','Declared balance product underflows binary64 representation');
endif
if any(abs(residual)>bound),error('Network:Balance','Known homogeneous channel is inconsistent with declared element/charge balance to arithmetic precision');endif
endfunction
network_numeric.m — Direct called helper in the actual generic entrypoint/ODE/publication source chain
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Generic0.2.5
script-20261120T043918Z-2293038-1795149558474630 COMPLETED exit0; script-20261120T064007Z-2529515-1795156807585422 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 78a85cc92e594b86fd81b1eba297da8a835c4a4633395582a4d52074b0942403
function out=network_numeric(varargin)
% Use the existing CORE-owned public Numeric resolver on the managed path.
% Project source paths and provider binding identity remain their owners.
if exist('gxtxt_analysis_numeric_call','file')!=2
error('Network:Numeric','The managed Script runtime must expose its existing CORE Numeric helper');
endif
out=gxtxt_analysis_numeric_call(varargin{:});
endfunction
network_publish.m — Direct called helper in the actual generic entrypoint/ODE/publication source chain
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Generic0.2.5
script-20261120T043918Z-2293038-1795149558474630 COMPLETED exit0; script-20261120T064007Z-2529515-1795156807585422 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 aa810da2270ea87f62c33340d625f7838a2ee2fa45b5354ee697a062362fa0c5
function receipts=network_publish(ctx,prefix,network,R)
% Public canonical Dataset ownership and standard Curve Viewer consumption.
% Whole-bundle validation must finish BEFORE the first numeric writer exists.
if !isfield(R,'valid_trajectory')||!R.valid_trajectory,error('Network:Publication','A failed trajectory cannot be published as numeric canonical data');endif
fields={'time_s','requested_time_s','amounts_mol','concentrations_mol_m3','rates_mol_s','extents_mol',...
'balance_totals_mol','external_exchange_mol','balance_residual_mol','kinematic_residual_mol',...
'minimum_amount_mol','negative_amount_count','retained_negative_amount_count'};
for f=fields
v=R.(f{1});if !isnumeric(v)||!isreal(v)||any(!isfinite(v(:))),error('Network:NumericalDomain','Numeric publication refused: nonfinite or nonreal computed field %s',f{1});endif
endfor
def=struct('contract','table.generic','storage','auto','replace_owned',false,'producer_version','0.2.1',...
'source_dataset_ids',{{[prefix '.network']}},'source','User-defined reaction network',...
'provenance',['Native Job ' ctx.run_id '; source bundle ' ctx.script_sha256 '; requested solver ' R.solver.method '; actual backend ' R.solver.backend_method '; integration protocol ' R.solver.integration_protocol],...
'notes',['dn/dt=S*r; amount basis mol; explicit constant volume; directed channels. ' R.scientific_status '. Composition: ' R.composition_status '. Positivity checks provider-returned states and retained endpoints; no continuous-time proof. Integration restarts on adjacent requested endpoints and retains every provider-returned row. Missing composition means partial declared-element totals only, never verified chemical conservation. Formal-charge ledger is mol of elementary-charge equivalents, not coulombs. Negative counts refer to returned solver rows; retained-grid counts are separate. No experimental uncertainty estimated; numerical negatives are never clipped.']);
receipts={};
specs={'amounts','amounts_mol','mol','species_ids';'concentrations','concentrations_mol_m3','mol/m^3','species_ids';...
'rates','rates_mol_s','mol/s','reaction_ids';'extents','extents_mol','mol','reaction_ids';...
'balance_totals','balance_totals_mol','mol','balance_labels';'external_exchange','external_exchange_mol','mol','balance_labels';...
'balance_residual','balance_residual_mol','mol','balance_labels';'kinematic_residual','kinematic_residual_mol','mol','species_ids'};
for i=1:rows(specs)
labels=R.(specs{i,4});matrix=R.(specs{i,2});cols=struct('time_s',R.time_s,'requested_time_s',R.requested_time_s);units=struct('time_s','s','requested_time_s','s');
for j=1:numel(labels),key=['v_' labels{j}];cols.(key)=matrix(:,j);units.(key)=specs{i,3};endfor
def.dataset_id=[prefix '.' specs{i,1}];receipts{end+1}=publish(def,cols,units);
endfor
cols=struct();units=struct();
for k=1:numel(R.species_ids)
key=['minimum_' R.species_ids{k}];cols.(key)=R.minimum_amount_mol(k);units.(key)='mol';
key=['negative_count_' R.species_ids{k}];cols.(key)=R.negative_amount_count(k);units.(key)='1';
key=['retained_negative_count_' R.species_ids{k}];cols.(key)=R.retained_negative_amount_count(k);units.(key)='1';
endfor
def.dataset_id=[prefix '.diagnostics'];receipts{end+1}=publish(def,cols,units);
endfunction
function receipt=publish(def,cols,units)
keys=fieldnames(cols);count=numel(cols.(keys{1}));writer=gxtxt_api_call('DATASET_PUBLICATION_API_v2','begin',{def});
try
gxtxt_api_call('DATASET_PUBLICATION_API_v2','declare_dimension',{writer,'row',count,struct('extendible',false)});
for k=1:numel(keys)
key=keys{k};value=cols.(key);
schema=struct('dtype','float64','value_kind','number','rank',1,'dimension_ids',{{'row'}},'name',key,'unit',units.(key),'coordinate_role','data','axis_kind','explicit');
schema=elec_reaction_time_schema(key,schema);
if strcmp(key,'time_s'),schema.semantic_reason='Actual provider-returned state timestamp carried through declared segmented integration';endif
if strcmp(key,'requested_time_s')
schema=elec_reaction_time_schema('time_s',schema);
schema.name='Requested endpoint [s]; actual state timestamp is time_s';
schema.semantic_reason='Requested elapsed endpoint target; actual state timestamp is stored separately in time_s';
endif
gxtxt_api_call('DATASET_PUBLICATION_API_v2','declare_variable',{writer,key,schema});
gxtxt_api_call('DATASET_PUBLICATION_API_v2','write_variable',{writer,key,value,count});
endfor
receipt=gxtxt_api_call('DATASET_PUBLICATION_API_v2','finalize',{writer});
catch err
try gxtxt_api_call('DATASET_PUBLICATION_API_v2','abort',{writer});catch,end_try_catch
rethrow(err);
end_try_catch
endfunction
elec_assay_chlorine_public_ode_model_011–a3bc58e40115864d.m — registered_source
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261118T175236Z-2032555-1795024356189422 COMPLETED exit0; script-20261118T175851Z-2051373-1795024731681928 COMPLETED exit0; script-20261118T180542Z-2079340-1795025142476552 COMPLETED exit0; script-20261118T181604Z-2120608-1795025764069564 COMPLETED exit0; script-20261119T071755Z-4173920-1795072675933183 COMPLETED exit0; script-20261119T114703Z-462161-1795088823383992 COMPLETED exit0; script-20261119T115607Z-478844-1795089367556973 COMPLETED exit0; script-20261119T120611Z-494366-1795089971876246 COMPLETED exit0; script-20261119T121435Z-506415-1795090475332791 COMPLETED exit0; script-20261119T122917Z-528961-1795091357129979 COMPLETED exit0; script-20261119T123943Z-542392-1795091983312698 COMPLETED exit0; script-20261119T124852Z-552817-1795092532720787 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 a3bc58e40115864d4e43dcd726b462ca93f2e26a84f69106ffcff06f9b3a5986
% Owned Model0.1.1; explicit clock-roundoff protocol elec.clock_roundoff.v1.
% Fitter responses approximate requested coordinates; actual clocks and bounded
% coordinate contributions remain in owned public_ode_callback_XXXXX.mat records.
% Public requirement/context initialization occurs BEFORE callback registration.
gxtxt_api_require('NUMERIC_API_v1@1');
global ELEC_ASSAY_ODE_CONTEXT;
initial_context=gxtxt_context();
ELEC_ASSAY_ODE_CONTEXT=struct('output_dir',initial_context.output_dir,'run_id',initial_context.run_id,'script_sha256',initial_context.script_sha256,'calls',0);
function response=elec_assay_chlorine_public_ode_N(parameters,predictors)
[response,unused]=coupled_public_ode(parameters,predictors);
endfunction
function response=elec_assay_chlorine_public_ode_B(parameters,predictors)
[unused,response]=coupled_public_ode(parameters,predictors);
endfunction
function [Nmass,Bout]=coupled_public_ode(parameters,predictors)
% w=int(B dt), units mol*s/m^3; exact transformation, public ODE only.
if !isnumeric(parameters)||!isreal(parameters)||numel(parameters)!=10||any(!isfinite(parameters(:)))
error('ELEC:Parameters','Ten finite real parameters in declared order required');
endif
p=parameters(:);h=p(1);f=p(2);km=p(3);nu=p(4);C0=p(5);MN=p(6);I=p(7);V=p(8);F=p(9);reference_s=p(10);
if h<0||h>1||f<0||f>1||km<0||km>10||nu<=0||C0<0||MN<=0||I<0||V<=0||F<=0||reference_s<=0
error('ELEC:Domain','Require h,f in [0,1], loss in [0,10]/min, positive nu,M_N,V,F,reference_s and nonnegative N0,I');
endif
if !isnumeric(predictors)||!isreal(predictors)||columns(predictors)!=1||numel(predictors)>2048||any(!isfinite(predictors(:)))||any(predictors(:)<0)||any(predictors(:)>60)
error('ELEC:Predictors','At most 2048 finite elapsed-minute query values in 0..60 required');
endif
t=60*predictors(:);[query,unused,mapping]=unique(t);
A0=C0/MN;P=f*I/(2*F*V);kappa=km/60;
if C0==0,kA=0;else,kA=h/(reference_s*A0);endif
if !all(isfinite([A0,P,kappa,kA])),error('ELEC:Finite','Finite derived source/rate scales required');endif
opts=struct('method','ode45','reltol',1e-10,'abstol',1e-10,'max_step',2);
record=struct('schema','elec.assay_public_ode_callback.v1','parameters',p,'predictor_min',predictors(:),'requested_time_s',query,'solver',opts,'w_unit','mol*s/m^3','positivity_amount_tolerance_mol',1e-12,'clock_protocol','elec.clock_roundoff.v1','segments',{{}},'scientific_scope','Conditional operational assay pool, first-order effective oxidant loss, no N fate or physical validation');
nquery=C0*ones(size(query));bquery=zeros(size(query));actual_query=zeros(size(query));clock_query=cell(size(query));w=0;now=0;segments={};
try
for j=1:numel(query)
target=query(j);
if target==0,clock_query{j}=clock_roundoff_diagnostic(0,0,C0,kA,P,kappa,nu,A0);continue;endif
clock_require_forward(target,now);
rhs=@(tt,ww) exposure_rhs(tt,ww,P,kappa,nu,kA,A0);
s=network_numeric('foundation','ode','solve',rhs,[now;target],w,opts);
segment=struct('provider',s);segments{end+1}=segment;record.segments=segments;
if !s.success||s.cancelled||s.terminated_by_event||!strcmp(s.backend_method,'ode45')||numel(s.time)<2||columns(s.state_real)!=1||rows(s.state_real)!=numel(s.time)||any(!isfinite([s.time(:);s.state_real(:)]))||any(s.state_imaginary(:)!=0)||any(diff(s.time)<0)
error('ELEC:ODE','Public ODE must complete a finite real ode45 segment');
endif
clock_require_continuity(s,now,w);
% Never overwrite provider clocks. This bounds only coordinate displacement.
clock=clock_roundoff_diagnostic(target,s.time(end),C0,kA,P,kappa,nu,A0);
segments{end}.clock=clock;record.segments=segments;
if !clock.accepted,error('ELEC:ODETime','Clock discrepancy exceeds finite four-ULP or induced-N bound');endif
actual_query(j)=s.time(end);clock_query{j}=clock;
physical=physical_rows(s.time,s.state_real(:,1),P,kappa,nu,kA,A0,C0,MN,V,I,F,opts);
segments{end}.physical=physical;record.segments=segments;
w=s.state_real(end,1);now=s.time(end);nquery(j)=physical.N_mg_L(end);bquery(j)=physical.B_mol_m3(end);
endfor
Nmass=nquery(mapping);Bout=bquery(mapping);
if any(!isfinite([Nmass;Bout])),error('ELEC:Finite','Finite Model response required');endif
record.response_requested_time_s=t;record.query_mapping=mapping;record.query_actual_time_s=actual_query;record.query_clock_diagnostics=clock_query;record.response_actual_time_s=actual_query(mapping);record.response_clock_diagnostics=clock_query(mapping);record.N_mg_L=Nmass;record.B_mol_m3=Bout;record.state='COMPLETED_CALLBACK';store_callback_record(record);
catch e
record.segments=segments;record.state='FAILED_CALLBACK';record.error=struct('identifier',e.identifier,'message',e.message);
try
store_callback_record(record);
catch artifact_error
fprintf(2,'Secondary callback-artifact failure: %s\n',artifact_error.message);
end_try_catch
rethrow(e);
end_try_catch
endfunction
function clock_require_forward(target,previous_actual)
if !isreal([target,previous_actual])||any(!isfinite([target,previous_actual]))||target<=previous_actual
error('ELEC:ODETimeOrder','Next requested endpoint is not later than finite actual continuation time');
endif
endfunction
function clock_require_continuity(s,previous_actual,previous_state)
if s.time(1)!=previous_actual||s.state_real(1,1)!=previous_state||s.time(end)<=previous_actual
error('ELEC:ODEContinuity','Raw provider initial clock/state continuity and forward endpoint required');
endif
endfunction
function d=clock_roundoff_diagnostic(requested,actual,C0,kA,P,kappa,nu,A0)
% Positive binary64 bit patterns are monotone; distance counts adjacent values.
v=[requested,actual,C0,kA,P,kappa,nu,A0];
if !isreal(v)||any(!isfinite(v))||any(v<0)||nu<=0
error('ELEC:ClockFinite','Finite nonnegative clock-bound inputs and positive nu required');
endif
if (requested==0||actual==0)&&!(requested==0&&actual==0)
error('ELEC:ClockDomain','Only an exact zero/zero clock pair is allowed at zero');
endif
requested_bits=typecast(double(requested),'uint64');actual_bits=typecast(double(actual),'uint64');
if requested_bits>=actual_bits,steps=requested_bits-actual_bits;else steps=actual_bits-requested_bits;endif
delta=actual-requested;T=max(requested,actual);
delta_magnitude_bound=clock_up_nonnegative(abs(delta));
kP=clock_product_up(kA,P);kPT=clock_product_up(kP,T);e_clock=clock_product_up(kPT,delta_magnitude_bound);Nlimit=1e-12*C0;EN=clock_product_up(C0,e_clock);
if C0==0
if kA!=0,error('ELEC:ClockZero','Zero initial N requires exact zero reaction coefficient');endif
Naccepted=true;
else
Naccepted=e_clock<=1e-12;
endif
reaction=clock_product_up(nu,kA);reactionA=clock_product_up(reaction,A0);loss=clock_sum_up(reactionA,kappa);
lossT=clock_product_up(loss,T);Bfactor=clock_sum_up(1,lossT);BP=clock_product_up(P,Bfactor);EB=clock_product_up(BP,delta_magnitude_bound);
computed=[delta,delta_magnitude_bound,T,kP,kPT,e_clock,EN,Nlimit,reaction,reactionA,loss,lossT,Bfactor,BP,EB];
if any(!isfinite(computed))
error('ELEC:ClockFinite','Nonfinite intermediate clock-bound diagnostic');
endif
d=struct('protocol','elec.clock_roundoff.v1','requested_time_s',requested,'actual_time_s',actual,'delta_time_s',delta,'absolute_delta_time_bound_s',delta_magnitude_bound,'requested_binary64_bits',requested_bits,'actual_binary64_bits',actual_bits,'adjacent_binary64_steps',steps,'binary64_step_limit',uint64(4),'normalized_N_coordinate_error_bound',e_clock,'normalized_N_coordinate_error_limit',1e-12,'N_coordinate_error_bound_mg_L',EN,'N_coordinate_error_limit_mg_L',Nlimit,'B_coordinate_error_bound_mol_m3',EB,'accepted',steps<=uint64(4)&&Naccepted,'scope','Exact-solution coordinate displacement bound only; not solver truncation error or physical uncertainty. Actual provider clock/state unchanged.');
endfunction
function result=clock_up_nonnegative(value)
if !isreal(value)||!isscalar(value)||!isfinite(value)||value<0
error('ELEC:ClockFinite','Finite nonnegative scalar bound required');
endif
if value==0,result=0;return;endif
result=typecast(typecast(double(value),'uint64')+uint64(1),'double');
if !isfinite(result),error('ELEC:ClockFinite','Outward bound overflows binary64');endif
endfunction
function result=clock_product_up(a,b)
if any(!isfinite([a,b]))||any([a,b]<0),error('ELEC:ClockFinite','Finite nonnegative bound factors required');endif
if a==0||b==0,result=0;return;endif
value=a*b;
if !isfinite(value),error('ELEC:ClockFinite','Bound product overflows binary64');endif
if value==0,result=typecast(uint64(1),'double');else result=clock_up_nonnegative(value);endif
endfunction
function result=clock_sum_up(a,b)
if any(!isfinite([a,b]))||any([a,b]<0),error('ELEC:ClockFinite','Finite nonnegative bound summands required');endif
if a==0&&b==0,result=0;return;endif
result=clock_up_nonnegative(a+b);
endfunction
function value=exposure_rhs(t,w,P,kappa,nu,kA,A0)
% Smooth mathematical extension at solver trial states; no rate clipping.
value=P*t-kappa*w+nu*A0*expm1(-kA*w);
if !isreal(value)||!isscalar(value)||!isfinite(value),error('ELEC:RHS','Finite real exposure derivative required');endif
endfunction
function r=physical_rows(t,w,P,kappa,nu,kA,A0,C0,MN,V,I,F,opts)
t=t(:);w=w(:);A=A0*exp(-kA*w);deltaA=-A0*expm1(-kA*w);
terms=[P*t,-kappa*w,-nu*deltaA];B=sum(terms,2);
roundoff_scale=16*eps*sum(abs(terms),2);
local_solver_B_scale=(kappa+nu*kA*A).*(opts.abstol+opts.reltol*abs(w));
% Local solver scale is diagnostic, NOT a global error or acceptance bound.
amount_tolerance=1e-12;concentration_tolerance=amount_tolerance/V;
positivity_limit=concentration_tolerance+roundoff_scale;
if any(!isfinite([A;B;deltaA;roundoff_scale;local_solver_B_scale]))||any(w < -opts.abstol)||any(A < -concentration_tolerance)||any(A>A0+concentration_tolerance)||any(B < -positivity_limit)
error('ELEC:Positivity','Returned physical state outside explicit amount tolerance; no clipping or solver-error relabelling');
endif
ICRR=2*F*V*kappa*B;current_tolerance=2*F*kappa*amount_tolerance+64*eps*max(I,realmin);
if any(!isfinite(ICRR))||any(ICRR < -current_tolerance)||any(ICRR>f_source_current(P,V,F)+current_tolerance)
error('ELEC:Current','Returned reduction current exceeds the conditional source-current comparison bound');
endif
r=struct('actual_time_s',t,'w_mol_s_m3',w,'A_mol_m3',A,'N_mg_L',MN*A,'B_mol_m3',B,'removed_N_pool_mol_m3',deltaA,'CER_extent_mol_m3',P*t,'loss_extent_mol_m3',kappa*w,'oxidant_balance_residual_mol_m3',B+nu*deltaA+kappa*w-P*t,'B_roundoff_scale_mol_m3',roundoff_scale,'B_local_solver_scale_mol_m3',local_solver_B_scale,'B_positivity_limit_mol_m3',positivity_limit,'I_CRR_A',ICRR,'I_HER_A',I-ICRR,'current_tolerance_A',current_tolerance,'state_check_scope','Every provider-returned row; no continuous-time positivity proof. Allowed numerical negatives retained, not clipped.');
endfunction
function current=f_source_current(P,V,F),current=2*F*V*P;endfunction
function store_callback_record(record)
global ELEC_ASSAY_ODE_CONTEXT;
if !isstruct(ELEC_ASSAY_ODE_CONTEXT)||!isfield(ELEC_ASSAY_ODE_CONTEXT,'output_dir')||isempty(ELEC_ASSAY_ODE_CONTEXT.output_dir)
error('ELEC:Context','Native owned output context must be initialized before callback registration');
endif
ELEC_ASSAY_ODE_CONTEXT.calls+=1;index=ELEC_ASSAY_ODE_CONTEXT.calls;
record.run_id=ELEC_ASSAY_ODE_CONTEXT.run_id;record.script_sha256=ELEC_ASSAY_ODE_CONTEXT.script_sha256;record.callback_index=index;
path=fullfile(ELEC_ASSAY_ODE_CONTEXT.output_dir,sprintf('public_ode_callback_%05d.mat',index));
if exist(path,'file'),error('ELEC:Artifact','Refuse existing callback artifact');endif
save('-mat7-binary',path,'record');
endfunction
% BEGIN EXACT OWNED GENERIC 0.2.1 PUBLIC NUMERIC BINDING HELPER
function out=network_numeric(varargin)
% Resolve only the advertised public Octave binding; never source runtime code.
persistent entry fn;
if isempty(entry)
context=canonicalize_file_name(which('gxtxt_context'));
if isempty(context),error('Network:Numeric','Native Script context binding is unavailable');endif
root=fileparts(fileparts(fileparts(fileparts(context))));
owner=canonicalize_file_name(fullfile(root,'plugins','modules','math.numeric'));
descriptor=gxtxt_ini_read(fullfile(owner,'module.ini'));
if !strcmp(gxtxt_ini_get(descriptor,'meta.id',''),'math.numeric')||!strcmp(gxtxt_ini_get(descriptor,'public_api.NUMERIC_API_v1.api_version',''),'1')
error('Network:Numeric','Public Numeric provider identity is unavailable');
endif
fn=gxtxt_ini_get(descriptor,'public_api.NUMERIC_API_v1.octave_function','');
entry=canonicalize_file_name(fullfile(owner,gxtxt_ini_get(descriptor,'public_api.NUMERIC_API_v1.octave_entrypoint','')));
if isempty(entry)||isempty(regexp(fn,'^[A-Za-z][A-Za-z0-9_]*$','once'))||!strncmp(entry,[owner filesep],numel(owner)+1)
error('Network:Numeric','Public Numeric entrypoint is invalid');
endif
addpath(fileparts(entry));
endif
if !strcmp(canonicalize_file_name(which(fn)),entry),error('Network:Numeric','Public Numeric binding is shadowed');endif
out=feval(fn,varargin{:});
endfunction
elec_assay_chlorine_public_ode_model–bff324667dc585dc.m — registered_source
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261118T171040Z-1885714-1795021840020015 COMPLETED exit0; script-20261118T171850Z-1910964-1795022330401613 COMPLETED exit0; script-20261118T172456Z-1928011-1795022696668613 COMPLETED exit0; script-20261118T173121Z-1948046-1795023081106788 FAILED exit1; script-20261118T181245Z-2107917-1795025565175113 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 bff324667dc585dce543560be6fb19437fa8286b379a3426e388543b7bc44ecd
% Public requirement/context initialization occurs BEFORE callback registration.
gxtxt_api_require('NUMERIC_API_v1@1');
global ELEC_ASSAY_ODE_CONTEXT;
initial_context=gxtxt_context();
ELEC_ASSAY_ODE_CONTEXT=struct('output_dir',initial_context.output_dir,'run_id',initial_context.run_id,'script_sha256',initial_context.script_sha256,'calls',0);
function response=elec_assay_chlorine_public_ode_N(parameters,predictors)
[response,unused]=coupled_public_ode(parameters,predictors);
endfunction
function response=elec_assay_chlorine_public_ode_B(parameters,predictors)
[unused,response]=coupled_public_ode(parameters,predictors);
endfunction
function [Nmass,Bout]=coupled_public_ode(parameters,predictors)
% w=int(B dt), units mol*s/m^3; exact transformation, public ODE only.
if !isnumeric(parameters)||!isreal(parameters)||numel(parameters)!=10||any(!isfinite(parameters(:)))
error('ELEC:Parameters','Ten finite real parameters in declared order required');
endif
p=parameters(:);h=p(1);f=p(2);km=p(3);nu=p(4);C0=p(5);MN=p(6);I=p(7);V=p(8);F=p(9);reference_s=p(10);
if h<0||h>1||f<0||f>1||km<0||km>10||nu<=0||C0<0||MN<=0||I<0||V<=0||F<=0||reference_s<=0
error('ELEC:Domain','Require h,f in [0,1], loss in [0,10]/min, positive nu,M_N,V,F,reference_s and nonnegative N0,I');
endif
if !isnumeric(predictors)||!isreal(predictors)||columns(predictors)!=1||numel(predictors)>2048||any(!isfinite(predictors(:)))||any(predictors(:)<0)||any(predictors(:)>60)
error('ELEC:Predictors','At most 2048 finite elapsed-minute query values in 0..60 required');
endif
t=60*predictors(:);[query,unused,mapping]=unique(t);
A0=C0/MN;P=f*I/(2*F*V);kappa=km/60;
if C0==0,kA=0;else,kA=h/(reference_s*A0);endif
if !all(isfinite([A0,P,kappa,kA])),error('ELEC:Finite','Finite derived source/rate scales required');endif
opts=struct('method','ode45','reltol',1e-10,'abstol',1e-10,'max_step',2);
record=struct('schema','elec.assay_public_ode_callback.v1','parameters',p,'predictor_min',predictors(:),'requested_time_s',query,'solver',opts,'w_unit','mol*s/m^3','positivity_amount_tolerance_mol',1e-12,'segments',{{}},'scientific_scope','Conditional operational assay pool, first-order effective oxidant loss, no N fate or physical validation');
nquery=C0*ones(size(query));bquery=zeros(size(query));w=0;now=0;segments={};
try
for j=1:numel(query)
target=query(j);
if target==0,continue;endif
rhs=@(tt,ww) exposure_rhs(tt,ww,P,kappa,nu,kA,A0);
s=network_numeric('foundation','ode','solve',rhs,[now;target],w,opts);
segment=struct('provider',s);segments{end+1}=segment;record.segments=segments;
if !s.success||s.cancelled||s.terminated_by_event||!strcmp(s.backend_method,'ode45')||numel(s.time)<2||columns(s.state_real)!=1||rows(s.state_real)!=numel(s.time)||any(!isfinite([s.time(:);s.state_real(:)]))||any(s.state_imaginary(:)!=0)||any(diff(s.time)<0)
error('ELEC:ODE','Public ODE must complete a finite real ode45 segment');
endif
% The Fitter coordinate must be the actual retained endpoint, not relabelled.
if s.time(end)!=target,error('ELEC:ODETime','Provider endpoint differs from requested Model coordinate; no relabelling');endif
physical=physical_rows(s.time,s.state_real(:,1),P,kappa,nu,kA,A0,C0,MN,V,I,F,opts);
segments{end}.physical=physical;record.segments=segments;
w=s.state_real(end,1);now=s.time(end);nquery(j)=physical.N_mg_L(end);bquery(j)=physical.B_mol_m3(end);
endfor
Nmass=nquery(mapping);Bout=bquery(mapping);
if any(!isfinite([Nmass;Bout])),error('ELEC:Finite','Finite Model response required');endif
record.N_mg_L=Nmass;record.B_mol_m3=Bout;record.state='COMPLETED_CALLBACK';store_callback_record(record);
catch e
record.segments=segments;record.state='FAILED_CALLBACK';record.error=struct('identifier',e.identifier,'message',e.message);
try
store_callback_record(record);
catch artifact_error
fprintf(2,'Secondary callback-artifact failure: %s\n',artifact_error.message);
end_try_catch
rethrow(e);
end_try_catch
endfunction
function value=exposure_rhs(t,w,P,kappa,nu,kA,A0)
% Smooth mathematical extension at solver trial states; no rate clipping.
value=P*t-kappa*w+nu*A0*expm1(-kA*w);
if !isreal(value)||!isscalar(value)||!isfinite(value),error('ELEC:RHS','Finite real exposure derivative required');endif
endfunction
function r=physical_rows(t,w,P,kappa,nu,kA,A0,C0,MN,V,I,F,opts)
t=t(:);w=w(:);A=A0*exp(-kA*w);deltaA=-A0*expm1(-kA*w);
terms=[P*t,-kappa*w,-nu*deltaA];B=sum(terms,2);
roundoff_scale=16*eps*sum(abs(terms),2);
local_solver_B_scale=(kappa+nu*kA*A).*(opts.abstol+opts.reltol*abs(w));
% Local solver scale is diagnostic, NOT a global error or acceptance bound.
amount_tolerance=1e-12;concentration_tolerance=amount_tolerance/V;
positivity_limit=concentration_tolerance+roundoff_scale;
if any(!isfinite([A;B;deltaA;roundoff_scale;local_solver_B_scale]))||any(w < -opts.abstol)||any(A < -concentration_tolerance)||any(A>A0+concentration_tolerance)||any(B < -positivity_limit)
error('ELEC:Positivity','Returned physical state outside explicit amount tolerance; no clipping or solver-error relabelling');
endif
ICRR=2*F*V*kappa*B;current_tolerance=2*F*kappa*amount_tolerance+64*eps*max(I,realmin);
if any(!isfinite(ICRR))||any(ICRR < -current_tolerance)||any(ICRR>f_source_current(P,V,F)+current_tolerance)
error('ELEC:Current','Returned reduction current exceeds the conditional source-current comparison bound');
endif
r=struct('actual_time_s',t,'w_mol_s_m3',w,'A_mol_m3',A,'N_mg_L',MN*A,'B_mol_m3',B,'removed_N_pool_mol_m3',deltaA,'CER_extent_mol_m3',P*t,'loss_extent_mol_m3',kappa*w,'oxidant_balance_residual_mol_m3',B+nu*deltaA+kappa*w-P*t,'B_roundoff_scale_mol_m3',roundoff_scale,'B_local_solver_scale_mol_m3',local_solver_B_scale,'B_positivity_limit_mol_m3',positivity_limit,'I_CRR_A',ICRR,'I_HER_A',I-ICRR,'current_tolerance_A',current_tolerance,'state_check_scope','Every provider-returned row; no continuous-time positivity proof. Allowed numerical negatives retained, not clipped.');
endfunction
function current=f_source_current(P,V,F),current=2*F*V*P;endfunction
function store_callback_record(record)
global ELEC_ASSAY_ODE_CONTEXT;
if !isstruct(ELEC_ASSAY_ODE_CONTEXT)||!isfield(ELEC_ASSAY_ODE_CONTEXT,'output_dir')||isempty(ELEC_ASSAY_ODE_CONTEXT.output_dir)
error('ELEC:Context','Native owned output context must be initialized before callback registration');
endif
ELEC_ASSAY_ODE_CONTEXT.calls+=1;index=ELEC_ASSAY_ODE_CONTEXT.calls;
record.run_id=ELEC_ASSAY_ODE_CONTEXT.run_id;record.script_sha256=ELEC_ASSAY_ODE_CONTEXT.script_sha256;record.callback_index=index;
path=fullfile(ELEC_ASSAY_ODE_CONTEXT.output_dir,sprintf('public_ode_callback_%05d.mat',index));
if exist(path,'file'),error('ELEC:Artifact','Refuse existing callback artifact');endif
save('-mat7-binary',path,'record');
endfunction
% BEGIN EXACT OWNED GENERIC 0.2.1 PUBLIC NUMERIC BINDING HELPER
function out=network_numeric(varargin)
% Resolve only the advertised public Octave binding; never source runtime code.
persistent entry fn;
if isempty(entry)
context=canonicalize_file_name(which('gxtxt_context'));
if isempty(context),error('Network:Numeric','Native Script context binding is unavailable');endif
root=fileparts(fileparts(fileparts(fileparts(context))));
owner=canonicalize_file_name(fullfile(root,'plugins','modules','math.numeric'));
descriptor=gxtxt_ini_read(fullfile(owner,'module.ini'));
if !strcmp(gxtxt_ini_get(descriptor,'meta.id',''),'math.numeric')||!strcmp(gxtxt_ini_get(descriptor,'public_api.NUMERIC_API_v1.api_version',''),'1')
error('Network:Numeric','Public Numeric provider identity is unavailable');
endif
fn=gxtxt_ini_get(descriptor,'public_api.NUMERIC_API_v1.octave_function','');
entry=canonicalize_file_name(fullfile(owner,gxtxt_ini_get(descriptor,'public_api.NUMERIC_API_v1.octave_entrypoint','')));
if isempty(entry)||isempty(regexp(fn,'^[A-Za-z][A-Za-z0-9_]*$','once'))||!strncmp(entry,[owner filesep],numel(owner)+1)
error('Network:Numeric','Public Numeric entrypoint is invalid');
endif
addpath(fileparts(entry));
endif
if !strcmp(canonicalize_file_name(which(fn)),entry),error('Network:Numeric','Public Numeric binding is shadowed');endif
out=feval(fn,varargin{:});
endfunction
elec_assay_chlorine_noloss_model–378ed2a4d6944f01.m — registered_source
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261118T160756Z-1650017-1795018076725365 COMPLETED exit0; script-20261118T161141Z-1667460-1795018301512618 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 378ed2a4d6944f01aa52c91fffcfb68e14b1049525da28936ac99f256726a0e6
1; % Inert definitions; actual science executes in a native registered Model Job.
function response=elec_assay_chlorine_noloss_N(parameters,predictors)
[response,unused]=coupled_noloss_closed_form(parameters,predictors);
endfunction
function response=elec_assay_chlorine_noloss_B(parameters,predictors)
[unused,response]=coupled_noloss_closed_form(parameters,predictors);
endfunction
function [Nmass,B]=coupled_noloss_closed_form(parameters,predictors)
% Exact coupled no-loss branch; existing base erfcx/erfc, no numerical solver.
% Parameter h sets lambda=h/reference_s=k_A*A0; h=0 is exact no reaction.
if !isnumeric(parameters)||!isreal(parameters)||numel(parameters)!=9||any(!isfinite(parameters(:)))
error('ELEC:Parameters','Nine finite real parameters in declared order required');
endif
p=parameters(:);h=p(1);f=p(2);nu=p(3);C0=p(4);MN=p(5);I=p(6);V=p(7);F=p(8);reference_s=p(9);
if h<0||h>1||f<0||f>1||nu<=0||C0<0||MN<=0||I<0||V<=0||F<=0||reference_s<=0
error('ELEC:Domain','Require h,f in [0,1], nu,M_N,V,F,reference_s positive and N0,I nonnegative');
endif
if !isnumeric(predictors)||!isreal(predictors)||columns(predictors)!=1||any(!isfinite(predictors(:)))||any(predictors(:)<0)||any(predictors(:)>60)
error('ELEC:Predictors','One finite elapsed-minute column in 0..60 required');
endif
t=60*predictors(:);A0=C0/MN;P=f*I/(2*F*V);Nmass=C0*ones(size(t));B=P*t;
if any(!isfinite([A0;P;B])),error('ELEC:Finite','Finite nominal stock and source required');endif
if C0==0,Nmass=zeros(size(t));return;endif
if h==0||P==0,return;endif
lambda=h/reference_s;kA=lambda/A0;a=nu*lambda;b=kA*P/2;
if !all(isfinite([lambda,kA,a,b]))||lambda<=0||b<=0
error('ELEC:ComputedDomain','Finite positive derived rate scales required; no underflow substitution');
endif
root_b=sqrt(b);z=a/(2*root_b);q=sqrt(pi)*z;
% Domain bound makes subtraction conditioning explicit; never floor d.
if !isfinite(z)||z<=0||z>32,error('ELEC:Conditioning','Declared numerical domain requires 0<z<=32');endif
d=1-q*erfcx(z);
if !isfinite(d)||d<=0,error('ELEC:Conditioning','Positive finite Mills remainder required; no flooring');endif
for j=1:numel(t)
if t(j)==0,continue;endif
v=z-root_b*t(j);g=a*t(j)-b*t(j)*t(j);
if !all(isfinite([v,g])),error('ELEC:Finite','Finite transformed time coordinates required');endif
if v>=0
e=erfcx(v);
if !isfinite(e)||e<=0,error('ELEC:SpecialFunction','Positive finite erfcx required');endif
log_e=log(e);
else
% erfc(v) is in (1,2); avoid overflow of erfcx for negative v.
log_e=v*v+log(erfc(v));
endif
l1=log(d)-g;l2=log(q)+log_e;m=max(l1,l2);
logden=m+log(exp(l1-m)+exp(l2-m));
if !isfinite(logden),error('ELEC:Finite','Finite log denominator required');endif
Nmass(j)=exp(log(C0)-logden);
endfor
A=Nmass/MN;B=P*t-nu*(A0-A);
stock_tolerance=128*eps*(P*t+nu*A0);
if any(!isfinite([Nmass;B]))||any(Nmass<0)||any(Nmass>C0+128*eps*C0)||any(B < -stock_tolerance)
error('ELEC:Balance','Finite nonnegative N and oxidant required to numerical stock tolerance; no clipping');
endif
% Preserve actual values, including any allowed floating negative B.
endfunction
elec_chlorine_transport_model–97d95d60ee602159.m — registered_source
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261118T153414Z-1557672-1795016054192090 COMPLETED exit0; script-20261118T154059Z-1574287-1795016459880389 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 97d95d60ee6021593d81c94b37492c3d9ea599e96451c2fcb5a346e14c909a99
1; % Inert Script Library definitions; no top-level scientific calculation.
function response=elec_chlorine_transport(parameters,predictors)
% Exact no-N solution. No custom solver, Bridge, IO or external output.
if !isnumeric(parameters)||!isreal(parameters)||numel(parameters)!=6||any(!isfinite(parameters(:)))
error('ELEC:Parameters','Six finite real parameters in declared order required');
endif
p=parameters(:);f=p(1);k=p(2);I=p(3);V=p(4);F=p(5);M=p(6);
if f<0||f>1||k<0||I<0||V<=0||F<=0||M<=0
error('ELEC:Domain','Require 0<=f<=1, k>=0, I>=0 and positive V,F,M');
endif
if !isnumeric(predictors)||!isreal(predictors)||columns(predictors)!=1||any(!isfinite(predictors(:)))||any(predictors(:)<0)||any(predictors(:)>60)
error('ELEC:Predictors','Finite N-by-1 elapsed minutes in 0..60 required');
endif
t=predictors(:);pmax=M*I*60/(2*F*V);response=zeros(size(t));
if !isfinite(pmax),error('ELEC:Finite','Finite current-equivalent production ceiling required');endif
if k==0
response=f*pmax*t;
else
response=f*pmax*(-expm1(-k*t))/k;
endif
ceiling=f*pmax*t;
if any(!isfinite([response;ceiling]))||any(response<0)||any(response>ceiling+64*eps*max(ceiling,realmin))
error('ELEC:Balance','Finite nonnegative response below its current-source ceiling required');
endif
endfunction
elec_fast_checkpoint_model–8bb61aa56d1576d2.m — registered_source
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261118T115546Z-719262-1795002946560971 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 8bb61aa56d1576d2060fd0209f7e33cdd1aa78b1d66ef48ef2436255674b67e1
1; % Script-local callable definitions only; no top-level production.
function response=elec_fast_n_concentration(parameters,predictors)
response=elec_fast_projection(parameters,predictors,'n_concentration');
endfunction
function response=elec_fast_n_fraction(parameters,predictors)
response=elec_fast_projection(parameters,predictors,'n_fraction');
endfunction
function response=elec_fast_oxidant_amount(parameters,predictors)
response=elec_fast_projection(parameters,predictors,'oxidant_amount');
endfunction
function response=elec_fast_projection(parameters,predictors,quantity)
% Pure, per-execution cached projection of the unchanged complete kernel.
% No nested Bridge calls, external results, file access or interpolation.
persistent cached_key cached_result;
if !isnumeric(parameters)||!isreal(parameters)||numel(parameters)!=7||any(!isfinite(parameters(:)))
error('ELEC:ModelParameters','Seven finite real parameters in declared order are required');
endif
parameters=parameters(:);case_index=parameters(7);
if case_index!=fix(case_index)||case_index<1||case_index>6
error('ELEC:ModelCase','Case index must be an integer from1 through6');
endif
if !isnumeric(predictors)||!isreal(predictors)||columns(predictors)!=1||any(!isfinite(predictors(:)))
error('ELEC:ModelPredictors','Predictors must be a finite real N-by-1 column in seconds');
endif
allowed=(0:60:300)';
if !all(ismember(predictors,allowed))
error('ELEC:ModelGrid','Only exact declared checkpoints0:60:300 seconds are supported; no interpolation or extrapolation');
endif
key=parameters(1:6);
if isempty(cached_result)||!isequal(cached_key,key)
p=struct('volume_m3',key(1),'current_A',key(2),'initial_N_g_m3',key(3),'background_NaCl_mol_m3',key(4),'F_C_mol',key(5),'M_N_g_mol',key(6),'specification_sha256','98f2d76191b8b6eab76b434012fcd83cd245c4ca866e6a2f682708d42588ae71');
result=fast_evaluate(p);
if !result.passed,error('ELEC:ModelChecks','Unchanged kernel checks/coverage did not pass; no prediction accepted');endif
cached_result=result;cached_key=key;
endif
cp=cached_result.checkpoints(cached_result.checkpoints(:,1)==case_index & cached_result.checkpoints(:,2)==3,:);
if !isequal(cp(:,3),allowed),error('ELEC:ModelCoverage','Exact finest-level checkpoint grid is required');endif
[present,index]=ismember(predictors,cp(:,3));
if !all(present),error('ELEC:ModelGrid','No source checkpoint for query');endif
switch quantity
case 'n_concentration',response=cp(index,4)*key(6)/key(1);
case 'n_fraction',response=cp(index,4)/(key(3)*key(1)/key(6));
case 'oxidant_amount',response=cp(index,5);
otherwise,error('ELEC:ModelQuantity','Unsupported scalar projection');
endswitch
response=response(:);
if any(!isfinite(response)),error('ELEC:ModelFinite','Finite response is required');endif
endfunction
% BEGIN EXACT UNCHANGED REVIEWED KERNEL
function R=fast_evaluate(p)
% SOURCE ONLY: illustrative reduced kinetics, no assay or physical pH model.
spec='98f2d76191b8b6eab76b434012fcd83cd245c4ca866e6a2f682708d42588ae71';
if !strcmp(p.specification_sha256,spec),error('Reduced:Spec','Exact reviewed specification04 required');endif
positive={'volume_m3','F_C_mol','M_N_g_mol'};
nonnegative={'current_A','initial_N_g_m3','background_NaCl_mol_m3'};
for k=1:numel(positive),input_guard(p,positive{k},true);endfor
for k=1:numel(nonnegative),input_guard(p,nonnegative{k},false);endfor
% Normalization and stored controls require nominal positive N inventory.
if p.initial_N_g_m3<=0,error('Reduced:Input','initial_N_g_m3 must be >0; chlorine-only controls are generated explicitly');endif
R.species={'formal_NH3','formal_HOCl_equivalent','chloride','exported_Cl2','stipulated_N2','signed_acid','water_reservoir_delta','O2_cumulative','H2_cumulative','electron_reservoir_delta','Na_spectator'};
R.reactions={'CER','OER','CRR','HER','formal_N2_endpoint','formal_Cl2_export'};
R.elements={'N','Cl','H','O','Na','formal_charge'};
E=[1 0 0 0 2 0 0 0 0 0 0;0 1 1 2 0 0 0 0 0 0 0;3 1 0 0 0 1 2 0 2 0 0;0 1 0 0 0 0 1 2 0 0 0;0 0 0 0 0 0 0 0 0 0 1;0 0 -1 0 0 1 0 0 0 -1 1];
nu=[0 0 0 0 -2 0;1 0 -1 0 -3 -1;-1 0 1 0 3 -1;0 0 0 0 0 1;0 0 0 0 1 0;1 4 -1 -2 3 -1;-1 -2 1 0 3 1;0 1 0 0 0 0;0 0 0 1 0 0;2 4 -2 -2 0 0;0 0 0 0 0 0];
R.element_matrix=E;R.reaction_matrix=nu;
C=struct('name',{},'actual',{},'limit',{},'unit',{},'comparison',{},'pass',{});
C=check(C,'integer_element_charge_nullspace',max(abs((E*nu)(:))),0,'1');
Nnom=p.initial_N_g_m3*p.volume_m3/p.M_N_g_mol;Na=p.background_NaCl_mol_m3*p.volume_m3;
if !all(isfinite([Nnom,Na]))||Nnom<=0,error('Reduced:Input','Derived N/Na amounts invalid: %s mol',jsonencode([Nnom,Na]));endif
base=struct('label','L_m0_common_P_pH7p5','family','common','m',0,'pH_ext',7.5,'fCER',.6,'fCRR',.15,'tau',600,'HB',.1*p.volume_m3,'HL',p.volume_m3,'I',p.current_A,'N0',Nnom,'Na0',Na,'B0',0,'reference_kind','none');
cases={};
for tau=[60,6]
for scenario=1:3
a=base;a.tau=tau;
if scenario==1,a.label=sprintf('L_m0_tau%d',tau);a.family='common';
elseif scenario==2,a.label=sprintf('L_m4_tau%d',tau);a.family='loss';a.m=4;a.fCRR=.15+.45*4/5;
else,a.label=sprintf('P_pH11_tau%d',tau);a.family='imposed_selectivity';a.pH_ext=11;a.fCER=.6+.4*(1/(1+10^(11-7.5))-.5);endif
cases{end+1}=a;
endfor
endfor
if numel(cases)!=6,error('Fast:Plan','Fixed6case plan violated');endif
R.cases=cases;R.state_headers=[{'case_index','level','step','time_s','dt_s'},R.species,strcat('extent_',R.reactions),strcat('rate_used_',R.reactions),{'I_CER_A','I_OER_A','I_CRR_A','I_HER_A','Q_C','Q_CER_C','Q_OER_C','Q_CRR_C','Q_HER_C','tiny_negative_flag','dt_limiter_code'}];
R.checkpoint_headers=[{'case_index','level','time_s'},R.species,strcat('extent_',R.reactions),{'Q_C'}];
R.balance_headers={'case_index','level','step','time_s','N_residual','N_limit','Cl_residual','Cl_limit','oxidant_residual','oxidant_limit','acid_Cl_residual','acid_Cl_limit','Na_residual','Na_limit','formal_charge','formal_charge_limit','anode_Q_residual','Q_limit','cathode_Q_residual','N_ceiling_excess','N_ceiling_limit','min_stock','stock_lower_bound','element_scaled_max','kappa_residual','kappa_limit'};
R.summary_headers={'case_index','level','dt_max_s','accepted_steps','final_N_atoms_mol','final_oxidant_mol','t50_s','t50_reached','t90_s','t90_reached','implicit_time_residual_max','stationary_error_max'};
states={};balances={};checkpoints={};summary=[];sampled=cell(6,3);totalsteps=0;implicit=zeros(6,3);
for ci=1:6
a=cases{ci};
if any(!isfinite([a.fCER,a.fCRR,a.tau,a.HB,a.HL,a.I,a.N0,a.Na0,a.B0]))||any([a.fCER,a.fCRR]<0)||any([a.fCER,a.fCRR]>1)||min([a.tau,a.HB,a.HL])<=0||min([a.I,a.N0,a.Na0,a.B0])<0,error('Reduced:Case','Invalid fixed case %s',a.label);endif
y0=[a.N0;a.B0;a.Na0+a.N0;0;0;a.N0;0;0;0;0;a.Na0];
for level=1:3
dtmax=[.2,.1,.05](level);t=0;y=y0;x=zeros(6,1);step=0;next_time=60;
ss=zeros(20001,numel(R.state_headers));bb=zeros(20001,numel(R.balance_headers));cp=zeros(6,numel(R.checkpoint_headers));ns=1;nc=1;
rates=rate(a,y,p.F_C_mol);ss(1,:)=state_row(ci,level,0,t,0,y,x,rates,a.I,p.F_C_mol);
bb(1,:)=balance_row(ci,level,0,t,y,y0,x,a,E,nu,p.F_C_mol);cp(1,:)=[ci,level,0,y',x',0];
imax=0;smax=0;t50=0;t90=0;hit50=false;hit90=false;
while t<300
rates=rate(a,y,p.F_C_mol);dt=min(dtmax,next_time-t);limiter=1;if next_time-t<dtmax,limiter=2;endif
sinks=[2*rates(5),rates(3)+3*rates(5),rates(1)];stock=[y(1),y(2),y(3)];
for q=1:3,if sinks(q)>0,bound=.5*stock(q)/sinks(q);if bound<dt,dt=bound;limiter=q+2;endif;endif;endfor
if !isfinite(dt)||dt<=0||t+dt<=t,error('Reduced:Step','Invalid dt at case%d level%d step%d: %s',ci,level,step,jsonencode(struct('dt_s',dt,'stocks_mol',stock,'sinks_mol_s',sinks)));endif
yn=y+nu*(dt*rates);xn=x+dt*rates;tn=t+dt;
if any(!isfinite([yn;xn]))||min(yn([1:5,8:9,11]))<0,error('Reduced:Stock','No clipping; case%d level%d step%d actual=%s mol lower_bound=0 (amount tolerance1e-14mol; any negative retained here and stops evaluation)',ci,level,step+1,jsonencode(yn'));endif
if !hit50&&a.N0>0&&yn(1)<=.5*a.N0,t50=t+dt*(y(1)-.5*a.N0)/(y(1)-yn(1));hit50=true;endif
if !hit90&&a.N0>0&&yn(1)<=.1*a.N0,t90=t+dt*(y(1)-.1*a.N0)/(y(1)-yn(1));hit90=true;endif
t=tn;y=yn;x=xn;step+=1;totalsteps+=1;
if step>20000||totalsteps>500000,error('Reduced:Budget','Fixed step budget exceeded case%d level%d count%d total%d',ci,level,step,totalsteps);endif
ns+=1;ss(ns,:)=state_row(ci,level,step,t,dt,y,x,rates,a.I,p.F_C_mol,limiter);
bb(ns,:)=balance_row(ci,level,step,t,y,y0,x,a,E,nu,p.F_C_mol);
if strcmp(a.reference_kind,'zero_oxidant'),smax=max(smax,max(abs(y-y0)));endif
if t==next_time
nc+=1;cp(nc,:)=[ci,level,t,y',x',a.I*t];
if any(strcmp(a.reference_kind,{'kappa_zero','kappa_positive'}))
lrN=log1p((y(1)-a.N0)/a.N0);
if strcmp(a.reference_kind,'kappa_zero')
rhs=-lrN+(2*a.HB/3)*(1/y(1)-1/a.N0);
else
kappa=a.B0-1.5*a.N0;lrB=log1p((y(2)-a.B0)/a.B0);rhs=-lrN-(a.HB/kappa)*(lrN-lrB);
endif
residual=abs(a.tau*rhs-t)/300;
if !isfinite(residual),error('Reduced:Reference','Nonfinite declared current-off reference case%d level%d',ci,level);endif
imax=max(imax,residual);
endif
next_time=min(300,next_time+60);
endif
endwhile
if nc!=6,error('Reduced:Checkpoint','Exact6checkpoint schedule required');endif
states{end+1}=ss(1:ns,:);balances{end+1}=bb(1:ns,:);checkpoints{end+1}=cp;
% Retain all actual/limit pairs per step; summary checks aggregate normalized ratios.
diag=bb(1:ns,:);ratios=[abs(diag(:,5))./diag(:,6),abs(diag(:,7))./diag(:,8),abs(diag(:,9))./diag(:,10),abs(diag(:,11))./diag(:,12),abs(diag(:,13))./diag(:,14),abs(diag(:,15))./diag(:,16),abs(diag(:,17))./diag(:,18),abs(diag(:,19))./diag(:,18),max(0,diag(:,20))./diag(:,21),diag(:,24),abs(diag(:,25))./diag(:,26)];
labels={'N','Cl','oxidant','acid_Cl','Na','formal_charge','anode_Q','cathode_Q','N_ceiling','all_elements','kappa'};
for z=1:numel(labels),C=check(C,sprintf('%s_level%d_%s_all_steps',a.label,level,labels{z}),max(ratios(:,z)),1,'1');endfor
C=check(C,sprintf('%s_level%d_instant_anode',a.label,level),max(abs(ss(1:ns,29)+ss(1:ns,30)-a.I)),1e-12+1e-10*a.I,'A');
C=check(C,sprintf('%s_level%d_instant_cathode',a.label,level),max(abs(ss(1:ns,31)+ss(1:ns,32)-a.I)),1e-12+1e-10*a.I,'A');
C=check(C,sprintf('%s_level%d_initial_state',a.label,level),max(abs(ss(1,6:16)'-y0)),0,'mol');
C=check(C,sprintf('%s_level%d_nonnegative_stocks',a.label,level),max(0,-min(diag(:,22))),1e-14,'mol');
if a.N0==0,C=check(C,sprintf('%s_level%d_zero_N',a.label,level),max(abs([ss(1:ns,6);ss(1:ns,10)])),0,'mol');endif
if strcmp(a.reference_kind,'zero_oxidant'),C=check(C,sprintf('%s_level%d_stationary',a.label,level),smax,0,'mol');endif
if level==3&&any(strcmp(a.reference_kind,{'kappa_zero','kappa_positive'})),C=check(C,[a.label '_fine_implicit_time'],imax,.01,'1');endif
summary(end+1,:)=[ci,level,dtmax,step,y(1),y(2),t50,double(hit50),t90,double(hit90),imax,smax];implicit(ci,level)=imax;
Bscale=max([a.B0+a.I*300/(2*p.F_C_mol),Nnom,a.HB]);
sampled{ci,level}=[cp(:,4)/Nnom,cp(:,5)/Bscale,cp(:,19)/Nnom,cp(:,15)/Bscale,cp(:,17)/Bscale,cp(:,16)/Bscale,cp(:,18)/Bscale];
endfor
endfor
R.states=vertcat(states{:});R.balances=vertcat(balances{:});R.checkpoints=vertcat(checkpoints{:});R.summary=summary;
R.refinement_headers={'case_index','E21','E10','order','order_assessed','stationary_exempt','error_floor','order_lower','order_upper','difference_limit'};
conv=[];convlabels={};assessed=0;required=0;
for ci=1:6
e21=max(abs(sampled{ci,1}(:)-sampled{ci,2}(:)));e10=max(abs(sampled{ci,2}(:)-sampled{ci,3}(:)));order=0;available=false;exempt=strcmp(cases{ci}.reference_kind,'zero_oxidant');
C=check(C,[cases{ci}.label '_fine_difference'],e10,.01,'1');
if exempt,status='EXACT_STATIONARY_EXEMPT';else
required+=1;
if e21>1e-9&&e10>1e-9
order=log2(e21/e10);available=true;assessed+=1;status='ASSESSED';C=check(C,[cases{ci}.label '_order_lower'],.7-order,0,'1');C=check(C,[cases{ci}.label '_order_upper'],order-1.3,0,'1');
else status='NOT_ASSESSED_ERROR_FLOOR';endif
endif
conv(end+1,:)=[ci,e21,e10,order,double(available),double(exempt),1e-9,.7,1.3,.01];convlabels{end+1,1}=status;
endfor
ph=[6;7;7.5;8.4;9;11];aa=1./(1+10.^(9.3-ph));bb=1./(1+10.^(ph-7.5));g=aa.*bb;
C=check(C,'dimensionless_prefactor_derivative_at_mean_pKa',abs(log(10)*g(4)*(bb(4)-aa(4))),1e-14,'1');
C=check(C,'dimensionless_prefactor_declared_grid_maximum',max(g)-g(4),1e-14,'1');
R.refinement=conv;R.refinement_labels=convlabels;R.checks=C;R.arithmetic_checks_passed=all([C.pass]);R.convergence_rows_assessed=assessed;R.convergence_rows_total=required;R.convergence_verified=assessed==required;
R.passed=R.arithmetic_checks_passed&&R.convergence_verified;
if !R.arithmetic_checks_passed,R.validation_status='FAILED_CHECK';elseif !R.convergence_verified,R.validation_status='PARTIAL_ERROR_FLOOR';else R.validation_status='VERIFIED_NUMERICS_ILLUSTRATIVE_ONLY';endif
R.prefactor=[ph,aa,bb,g];
R.prefactor_headers={'external_pH_label','alpha_NH3','alpha_HOCl','dimensionless_formation_prefactor'};
R.total_steps=totalsteps;R.implicit_residual_by_level=implicit;
endfunction
function r=rate(a,y,F)
cer=a.fCER*a.I/(2*F)*y(3)/(y(3)+a.HL);crr=a.fCRR*a.I/(2*F)*y(2)/(y(2)+a.HB);n2=y(1)/(2*a.tau)*y(2)/(y(2)+a.HB);
r=[cer;(a.I-2*F*cer)/(4*F);crr;(a.I-2*F*crr)/(2*F);n2;0];
if any(!isfinite(r))||any(r<0),error('Reduced:Rate','Invalid rate vector actual=%s mol/s lower0',jsonencode(r'));endif
endfunction
function row=state_row(ci,level,step,t,dt,y,x,r,I,F,limiter)
if nargin<11,limiter=0;endif
row=[ci,level,step,t,dt,y',x',r',2*F*r(1),4*F*r(2),2*F*r(3),2*F*r(4),I*t,2*F*x(1),4*F*x(2),2*F*x(3),2*F*x(4),double(any(y([1:5,8:9,11])<0)),limiter];
if any(!isfinite(row)),error('Reduced:Finite','Entire state row must be finite');endif
endfunction
function row=balance_row(ci,level,step,t,y,y0,x,a,E,nu,F)
atol=1e-14;rtol=1e-10;Q=a.I*t;
nr=y(1)+2*x(5)-a.N0;nl=atol+rtol*(a.N0+2*x(5));cl=y(3)+y(2)+2*x(6)-(y0(3)+a.B0);cll=atol+rtol*(y0(3)+a.B0+x(1)+x(3)+3*x(5)+2*x(6));
ox=y(2)+x(6)+3*x(5)+x(3)-(a.B0+x(1));ol=atol+rtol*(a.B0+x(1)+x(3)+3*x(5)+x(6));acid=y(6)-y(3)-(y0(6)-y0(3));al=atol+rtol*(abs(y0(6))+abs(y0(3))+sum(abs(y-y0)));
nar=y(11)-a.Na0;nal=atol+rtol*a.Na0;z=y(6)-y(3)+y(11)-y(10);ql=1e-9+rtol*abs(Q);
% Gross integrated species transfers count both consumed and produced
% stoichiometric contributions, without cancellation of net stock changes.
scale=atol+rtol*(abs(E)*abs(y0)+abs(E)*abs(nu)*x);element_residual=E*(y-y0);
if any(!isfinite(scale))||any(scale<=0)||any(!isfinite(element_residual)),error('Reduced:ElementFinite','Finite positive elemental limits and finite residuals required; actual_scale=%s mol actual_residual=%s mol',mat2str(scale'),mat2str(element_residual'));endif
elem=max(abs(element_residual)./scale);
cap=min(a.N0,2*a.B0/3+Q/(3*F));capl=atol+rtol*(a.N0+a.B0+Q/(3*F));kr=0;kl=atol+rtol*(a.B0+1.5*a.N0);
if a.I==0,kr=(y(2)-1.5*y(1))-(a.B0-1.5*a.N0);endif
row=[ci,level,step,t,nr,nl,cl,cll,ox,ol,acid,al,nar,nal,z,al,2*F*x(1)+4*F*x(2)-Q,ql,2*F*x(3)+2*F*x(4)-Q,2*x(5)-cap,capl,min(y([1:5,8:9,11])),-atol,elem,kr,kl];
if any(!isfinite(row))||any([nl,cll,ol,al,nal,ql,capl,kl]<=0),error('Reduced:Finite','Balance actuals and finite positive bounds required');endif
endfunction
function C=check(C,name,actual,limit,unit)
pass=isnumeric(actual)&&isscalar(actual)&&isfinite(actual)&&isnumeric(limit)&&isscalar(limit)&&isfinite(limit)&&actual<=limit;
C(end+1)=struct('name',name,'actual',full(actual),'limit',full(limit),'unit',unit,'comparison','le','pass',pass);
endfunction
function input_guard(p,name,positive)
if !isfield(p,name)||!isnumeric(p.(name))||!isscalar(p.(name))||!isreal(p.(name))||!isfinite(p.(name)),error('Reduced:Input','Finite real scalar required: %s',name);endif
if (positive&&p.(name)<=0)||(!positive&&p.(name)<0),error('Reduced:Input','Invalid %s actual=%s bound0 positive=%d',name,jsonencode(p.(name)),positive);endif
endfunction
elec_reduced_checkpoint_model–cb7961b4e124362d.m — registered_source
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261118T114821Z-670675-1795002501706446 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 cb7961b4e124362d34f6bc29017462758ac04d4a3b3a726846cf59883ab464b6
1; % Script-local callable definitions only; no top-level production.
function response=elec_reduced_n_concentration(parameters,predictors)
response=elec_reduced_projection(parameters,predictors,'n_concentration');
endfunction
function response=elec_reduced_n_fraction(parameters,predictors)
response=elec_reduced_projection(parameters,predictors,'n_fraction');
endfunction
function response=elec_reduced_oxidant_amount(parameters,predictors)
response=elec_reduced_projection(parameters,predictors,'oxidant_amount');
endfunction
function response=elec_reduced_projection(parameters,predictors,quantity)
% Pure, per-execution cached projection of the unchanged complete kernel.
% No nested Bridge calls, external results, file access or interpolation.
persistent cached_key cached_result;
if !isnumeric(parameters)||!isreal(parameters)||numel(parameters)!=7||any(!isfinite(parameters(:)))
error('ELEC:ModelParameters','Seven finite real parameters in declared order are required');
endif
parameters=parameters(:);case_index=parameters(7);
if case_index!=fix(case_index)||case_index<1||case_index>23
error('ELEC:ModelCase','Case index must be an integer from1 through23');
endif
if !isnumeric(predictors)||!isreal(predictors)||columns(predictors)!=1||any(!isfinite(predictors(:)))
error('ELEC:ModelPredictors','Predictors must be a finite real N-by-1 column in seconds');
endif
allowed=(0:60:1200)';
if !all(ismember(predictors,allowed))
error('ELEC:ModelGrid','Only exact declared checkpoints0:60:1200 seconds are supported; no interpolation or extrapolation');
endif
key=parameters(1:6);
if isempty(cached_result)||!isequal(cached_key,key)
p=struct('volume_m3',key(1),'current_A',key(2),'initial_N_g_m3',key(3),'background_NaCl_mol_m3',key(4),'F_C_mol',key(5),'M_N_g_mol',key(6),'specification_sha256','2961766955c2b471fcc2c58b48a4f65730ef9fa89a999b630e626534810b89f4');
result=reduced_evaluate(p);
if !result.passed,error('ELEC:ModelChecks','Unchanged kernel checks/coverage did not pass; no prediction accepted');endif
cached_result=result;cached_key=key;
endif
cp=cached_result.checkpoints(cached_result.checkpoints(:,1)==case_index & cached_result.checkpoints(:,2)==3,:);
if !isequal(cp(:,3),allowed),error('ELEC:ModelCoverage','Exact finest-level checkpoint grid is required');endif
[present,index]=ismember(predictors,cp(:,3));
if !all(present),error('ELEC:ModelGrid','No source checkpoint for query');endif
switch quantity
case 'n_concentration',response=cp(index,4)*key(6)/key(1);
case 'n_fraction',response=cp(index,4)/(key(3)*key(1)/key(6));
case 'oxidant_amount',response=cp(index,5);
otherwise,error('ELEC:ModelQuantity','Unsupported scalar projection');
endswitch
response=response(:);
if any(!isfinite(response)),error('ELEC:ModelFinite','Finite response is required');endif
endfunction
% BEGIN EXACT UNCHANGED REVIEWED KERNEL
function R=reduced_evaluate(p)
% SOURCE ONLY: illustrative reduced kinetics, no assay or physical pH model.
spec='2961766955c2b471fcc2c58b48a4f65730ef9fa89a999b630e626534810b89f4';
if !strcmp(p.specification_sha256,spec),error('Reduced:Spec','Exact reviewed specification04 required');endif
positive={'volume_m3','F_C_mol','M_N_g_mol'};
nonnegative={'current_A','initial_N_g_m3','background_NaCl_mol_m3'};
for k=1:numel(positive),input_guard(p,positive{k},true);endfor
for k=1:numel(nonnegative),input_guard(p,nonnegative{k},false);endfor
% Normalization and stored controls require nominal positive N inventory.
if p.initial_N_g_m3<=0,error('Reduced:Input','initial_N_g_m3 must be >0; chlorine-only controls are generated explicitly');endif
R.species={'formal_NH3','formal_HOCl_equivalent','chloride','exported_Cl2','stipulated_N2','signed_acid','water_reservoir_delta','O2_cumulative','H2_cumulative','electron_reservoir_delta','Na_spectator'};
R.reactions={'CER','OER','CRR','HER','formal_N2_endpoint','formal_Cl2_export'};
R.elements={'N','Cl','H','O','Na','formal_charge'};
E=[1 0 0 0 2 0 0 0 0 0 0;0 1 1 2 0 0 0 0 0 0 0;3 1 0 0 0 1 2 0 2 0 0;0 1 0 0 0 0 1 2 0 0 0;0 0 0 0 0 0 0 0 0 0 1;0 0 -1 0 0 1 0 0 0 -1 1];
nu=[0 0 0 0 -2 0;1 0 -1 0 -3 -1;-1 0 1 0 3 -1;0 0 0 0 0 1;0 0 0 0 1 0;1 4 -1 -2 3 -1;-1 -2 1 0 3 1;0 1 0 0 0 0;0 0 0 1 0 0;2 4 -2 -2 0 0;0 0 0 0 0 0];
R.element_matrix=E;R.reaction_matrix=nu;
C=struct('name',{},'actual',{},'limit',{},'unit',{},'comparison',{},'pass',{});
C=check(C,'integer_element_charge_nullspace',max(abs((E*nu)(:))),0,'1');
Nnom=p.initial_N_g_m3*p.volume_m3/p.M_N_g_mol;Na=p.background_NaCl_mol_m3*p.volume_m3;
if !all(isfinite([Nnom,Na]))||Nnom<=0,error('Reduced:Input','Derived N/Na amounts invalid: %s mol',jsonencode([Nnom,Na]));endif
base=struct('label','L_m0_common_P_pH7p5','family','common','m',0,'pH_ext',7.5,'fCER',.6,'fCRR',.15,'tau',600,'HB',.1*p.volume_m3,'HL',p.volume_m3,'I',p.current_A,'N0',Nnom,'Na0',Na,'B0',0,'reference_kind','none');
cases={base};
for m=[1,2,4],a=base;a.label=sprintf('L_m%d',m);a.family='loss';a.m=m;a.fCRR=.15+.45*m/(1+m);cases{end+1}=a;endfor
for ph=[6,7,8.4,9,11],a=base;a.label=['P_pH' strrep(num2str(ph),'.','p')];a.family='imposed_selectivity';a.pH_ext=ph;a.fCER=.6+.4*(1/(1+10^(ph-7.5))-.5);cases{end+1}=a;endfor
for scale=[.5,2],a=base;a.label=['sensitivity_tau_' strrep(num2str(scale),'.','p')];a.family='sensitivity';a.tau=600*scale;cases{end+1}=a;endfor
for scale=[.5,2],a=base;a.label=['sensitivity_HB_' strrep(num2str(scale),'.','p')];a.family='sensitivity';a.HB=base.HB*scale;cases{end+1}=a;endfor
for scale=[.5,1.5],a=cases{3};a.label=['sensitivity_loss_contrast_' strrep(num2str(scale),'.','p')];a.family='sensitivity';a.fCRR=.15+.45*scale*2/3;cases{end+1}=a;endfor
for scale=[.5,1.5],a=cases{8};a.label=['sensitivity_selectivity_contrast_' strrep(num2str(scale),'.','p')];a.family='sensitivity';a.fCER=.6+.4*scale*(1/(1+10^(9-7.5))-.5);cases{end+1}=a;endfor
for index=[1,4,9],a=cases{index};a.label=['chlorine_only_' a.label];a.family='chlorine_only';a.N0=0;cases{end+1}=a;endfor
for kind={'zero_oxidant','kappa_zero','kappa_positive'}
a=base;a.label=['current_off_' kind{1}];a.family='current_off';a.reference_kind=kind{1};a.I=0;a.fCER=0;a.fCRR=0;
if strcmp(kind{1},'kappa_zero'),a.B0=1.5*Nnom;elseif strcmp(kind{1},'kappa_positive'),a.B0=3*Nnom;endif
cases{end+1}=a;
endfor
if numel(cases)!=23,error('Reduced:Plan','Fixed23case plan violated');endif
R.cases=cases;R.state_headers=[{'case_index','level','step','time_s','dt_s'},R.species,strcat('extent_',R.reactions),strcat('rate_used_',R.reactions),{'I_CER_A','I_OER_A','I_CRR_A','I_HER_A','Q_C','Q_CER_C','Q_OER_C','Q_CRR_C','Q_HER_C','tiny_negative_flag','dt_limiter_code'}];
R.checkpoint_headers=[{'case_index','level','time_s'},R.species,strcat('extent_',R.reactions),{'Q_C'}];
R.balance_headers={'case_index','level','step','time_s','N_residual','N_limit','Cl_residual','Cl_limit','oxidant_residual','oxidant_limit','acid_Cl_residual','acid_Cl_limit','Na_residual','Na_limit','formal_charge','formal_charge_limit','anode_Q_residual','Q_limit','cathode_Q_residual','N_ceiling_excess','N_ceiling_limit','min_stock','stock_lower_bound','element_scaled_max','kappa_residual','kappa_limit'};
R.summary_headers={'case_index','level','dt_max_s','accepted_steps','final_N_atoms_mol','final_oxidant_mol','t50_s','t50_reached','t90_s','t90_reached','implicit_time_residual_max','stationary_error_max'};
states={};balances={};checkpoints={};summary=[];sampled=cell(23,3);totalsteps=0;implicit=zeros(23,3);
for ci=1:23
a=cases{ci};
if any(!isfinite([a.fCER,a.fCRR,a.tau,a.HB,a.HL,a.I,a.N0,a.Na0,a.B0]))||any([a.fCER,a.fCRR]<0)||any([a.fCER,a.fCRR]>1)||min([a.tau,a.HB,a.HL])<=0||min([a.I,a.N0,a.Na0,a.B0])<0,error('Reduced:Case','Invalid fixed case %s',a.label);endif
y0=[a.N0;a.B0;a.Na0+a.N0;0;0;a.N0;0;0;0;0;a.Na0];
for level=1:3
dtmax=[2,1,.5](level);t=0;y=y0;x=zeros(6,1);step=0;next_time=60;
ss=zeros(20001,numel(R.state_headers));bb=zeros(20001,numel(R.balance_headers));cp=zeros(21,numel(R.checkpoint_headers));ns=1;nc=1;
rates=rate(a,y,p.F_C_mol);ss(1,:)=state_row(ci,level,0,t,0,y,x,rates,a.I,p.F_C_mol);
bb(1,:)=balance_row(ci,level,0,t,y,y0,x,a,E,nu,p.F_C_mol);cp(1,:)=[ci,level,0,y',x',0];
imax=0;smax=0;t50=0;t90=0;hit50=false;hit90=false;
while t<1200
rates=rate(a,y,p.F_C_mol);dt=min(dtmax,next_time-t);limiter=1;if next_time-t<dtmax,limiter=2;endif
sinks=[2*rates(5),rates(3)+3*rates(5),rates(1)];stock=[y(1),y(2),y(3)];
for q=1:3,if sinks(q)>0,bound=.5*stock(q)/sinks(q);if bound<dt,dt=bound;limiter=q+2;endif;endif;endfor
if !isfinite(dt)||dt<=0||t+dt<=t,error('Reduced:Step','Invalid dt at case%d level%d step%d: %s',ci,level,step,jsonencode(struct('dt_s',dt,'stocks_mol',stock,'sinks_mol_s',sinks)));endif
yn=y+nu*(dt*rates);xn=x+dt*rates;tn=t+dt;
if any(!isfinite([yn;xn]))||min(yn([1:5,8:9,11]))<0,error('Reduced:Stock','No clipping; case%d level%d step%d actual=%s mol lower_bound=0 (amount tolerance1e-14mol; any negative retained here and stops evaluation)',ci,level,step+1,jsonencode(yn'));endif
if !hit50&&a.N0>0&&yn(1)<=.5*a.N0,t50=t+dt*(y(1)-.5*a.N0)/(y(1)-yn(1));hit50=true;endif
if !hit90&&a.N0>0&&yn(1)<=.1*a.N0,t90=t+dt*(y(1)-.1*a.N0)/(y(1)-yn(1));hit90=true;endif
t=tn;y=yn;x=xn;step+=1;totalsteps+=1;
if step>20000||totalsteps>500000,error('Reduced:Budget','Fixed step budget exceeded case%d level%d count%d total%d',ci,level,step,totalsteps);endif
ns+=1;ss(ns,:)=state_row(ci,level,step,t,dt,y,x,rates,a.I,p.F_C_mol,limiter);
bb(ns,:)=balance_row(ci,level,step,t,y,y0,x,a,E,nu,p.F_C_mol);
if strcmp(a.reference_kind,'zero_oxidant'),smax=max(smax,max(abs(y-y0)));endif
if t==next_time
nc+=1;cp(nc,:)=[ci,level,t,y',x',a.I*t];
if any(strcmp(a.reference_kind,{'kappa_zero','kappa_positive'}))
lrN=log1p((y(1)-a.N0)/a.N0);
if strcmp(a.reference_kind,'kappa_zero')
rhs=-lrN+(2*a.HB/3)*(1/y(1)-1/a.N0);
else
kappa=a.B0-1.5*a.N0;lrB=log1p((y(2)-a.B0)/a.B0);rhs=-lrN-(a.HB/kappa)*(lrN-lrB);
endif
residual=abs(a.tau*rhs-t)/1200;
if !isfinite(residual),error('Reduced:Reference','Nonfinite declared current-off reference case%d level%d',ci,level);endif
imax=max(imax,residual);
endif
next_time=min(1200,next_time+60);
endif
endwhile
if nc!=21,error('Reduced:Checkpoint','Exact21checkpoint schedule required');endif
states{end+1}=ss(1:ns,:);balances{end+1}=bb(1:ns,:);checkpoints{end+1}=cp;
% Retain all actual/limit pairs per step; summary checks aggregate normalized ratios.
diag=bb(1:ns,:);ratios=[abs(diag(:,5))./diag(:,6),abs(diag(:,7))./diag(:,8),abs(diag(:,9))./diag(:,10),abs(diag(:,11))./diag(:,12),abs(diag(:,13))./diag(:,14),abs(diag(:,15))./diag(:,16),abs(diag(:,17))./diag(:,18),abs(diag(:,19))./diag(:,18),max(0,diag(:,20))./diag(:,21),diag(:,24),abs(diag(:,25))./diag(:,26)];
labels={'N','Cl','oxidant','acid_Cl','Na','formal_charge','anode_Q','cathode_Q','N_ceiling','all_elements','kappa'};
for z=1:numel(labels),C=check(C,sprintf('%s_level%d_%s_all_steps',a.label,level,labels{z}),max(ratios(:,z)),1,'1');endfor
C=check(C,sprintf('%s_level%d_instant_anode',a.label,level),max(abs(ss(1:ns,29)+ss(1:ns,30)-a.I)),1e-12+1e-10*a.I,'A');
C=check(C,sprintf('%s_level%d_instant_cathode',a.label,level),max(abs(ss(1:ns,31)+ss(1:ns,32)-a.I)),1e-12+1e-10*a.I,'A');
C=check(C,sprintf('%s_level%d_initial_state',a.label,level),max(abs(ss(1,6:16)'-y0)),0,'mol');
C=check(C,sprintf('%s_level%d_nonnegative_stocks',a.label,level),max(0,-min(diag(:,22))),1e-14,'mol');
if a.N0==0,C=check(C,sprintf('%s_level%d_zero_N',a.label,level),max(abs([ss(1:ns,6);ss(1:ns,10)])),0,'mol');endif
if strcmp(a.reference_kind,'zero_oxidant'),C=check(C,sprintf('%s_level%d_stationary',a.label,level),smax,0,'mol');endif
if level==3&&any(strcmp(a.reference_kind,{'kappa_zero','kappa_positive'})),C=check(C,[a.label '_fine_implicit_time'],imax,.01,'1');endif
summary(end+1,:)=[ci,level,dtmax,step,y(1),y(2),t50,double(hit50),t90,double(hit90),imax,smax];implicit(ci,level)=imax;
Bscale=max([a.B0+a.I*1200/(2*p.F_C_mol),Nnom,a.HB]);
sampled{ci,level}=[cp(:,4)/Nnom,cp(:,5)/Bscale,cp(:,19)/Nnom,cp(:,15)/Bscale,cp(:,17)/Bscale,cp(:,16)/Bscale,cp(:,18)/Bscale];
endfor
endfor
R.states=vertcat(states{:});R.balances=vertcat(balances{:});R.checkpoints=vertcat(checkpoints{:});R.summary=summary;
R.refinement_headers={'case_index','E21','E10','order','order_assessed','stationary_exempt','error_floor','order_lower','order_upper','difference_limit'};
conv=[];convlabels={};assessed=0;required=0;
for ci=1:23
e21=max(abs(sampled{ci,1}(:)-sampled{ci,2}(:)));e10=max(abs(sampled{ci,2}(:)-sampled{ci,3}(:)));order=0;available=false;exempt=strcmp(cases{ci}.reference_kind,'zero_oxidant');
C=check(C,[cases{ci}.label '_fine_difference'],e10,.01,'1');
if exempt,status='EXACT_STATIONARY_EXEMPT';else
required+=1;
if e21>1e-9&&e10>1e-9
order=log2(e21/e10);available=true;assessed+=1;status='ASSESSED';C=check(C,[cases{ci}.label '_order_lower'],.7-order,0,'1');C=check(C,[cases{ci}.label '_order_upper'],order-1.3,0,'1');
else status='NOT_ASSESSED_ERROR_FLOOR';endif
endif
conv(end+1,:)=[ci,e21,e10,order,double(available),double(exempt),1e-9,.7,1.3,.01];convlabels{end+1,1}=status;
endfor
ph=[6;7;7.5;8.4;9;11];aa=1./(1+10.^(9.3-ph));bb=1./(1+10.^(ph-7.5));g=aa.*bb;
C=check(C,'dimensionless_prefactor_derivative_at_mean_pKa',abs(log(10)*g(4)*(bb(4)-aa(4))),1e-14,'1');
C=check(C,'dimensionless_prefactor_declared_grid_maximum',max(g)-g(4),1e-14,'1');
R.refinement=conv;R.refinement_labels=convlabels;R.checks=C;R.arithmetic_checks_passed=all([C.pass]);R.convergence_rows_assessed=assessed;R.convergence_rows_total=required;R.convergence_verified=assessed==required;
R.passed=R.arithmetic_checks_passed&&R.convergence_verified;
if !R.arithmetic_checks_passed,R.validation_status='FAILED_CHECK';elseif !R.convergence_verified,R.validation_status='PARTIAL_ERROR_FLOOR';else R.validation_status='VERIFIED_NUMERICS_ILLUSTRATIVE_ONLY';endif
R.prefactor=[ph,aa,bb,g];
R.prefactor_headers={'external_pH_label','alpha_NH3','alpha_HOCl','dimensionless_formation_prefactor'};
R.total_steps=totalsteps;R.implicit_residual_by_level=implicit;
endfunction
function r=rate(a,y,F)
cer=a.fCER*a.I/(2*F)*y(3)/(y(3)+a.HL);crr=a.fCRR*a.I/(2*F)*y(2)/(y(2)+a.HB);n2=y(1)/(2*a.tau)*y(2)/(y(2)+a.HB);
r=[cer;(a.I-2*F*cer)/(4*F);crr;(a.I-2*F*crr)/(2*F);n2;0];
if any(!isfinite(r))||any(r<0),error('Reduced:Rate','Invalid rate vector actual=%s mol/s lower0',jsonencode(r'));endif
endfunction
function row=state_row(ci,level,step,t,dt,y,x,r,I,F,limiter)
if nargin<11,limiter=0;endif
row=[ci,level,step,t,dt,y',x',r',2*F*r(1),4*F*r(2),2*F*r(3),2*F*r(4),I*t,2*F*x(1),4*F*x(2),2*F*x(3),2*F*x(4),double(any(y([1:5,8:9,11])<0)),limiter];
if any(!isfinite(row)),error('Reduced:Finite','Entire state row must be finite');endif
endfunction
function row=balance_row(ci,level,step,t,y,y0,x,a,E,nu,F)
atol=1e-14;rtol=1e-10;Q=a.I*t;
nr=y(1)+2*x(5)-a.N0;nl=atol+rtol*(a.N0+2*x(5));cl=y(3)+y(2)+2*x(6)-(y0(3)+a.B0);cll=atol+rtol*(y0(3)+a.B0+x(1)+x(3)+3*x(5)+2*x(6));
ox=y(2)+x(6)+3*x(5)+x(3)-(a.B0+x(1));ol=atol+rtol*(a.B0+x(1)+x(3)+3*x(5)+x(6));acid=y(6)-y(3)-(y0(6)-y0(3));al=atol+rtol*(abs(y0(6))+abs(y0(3))+sum(abs(y-y0)));
nar=y(11)-a.Na0;nal=atol+rtol*a.Na0;z=y(6)-y(3)+y(11)-y(10);ql=1e-9+rtol*abs(Q);
% Gross integrated species transfers count both consumed and produced
% stoichiometric contributions, without cancellation of net stock changes.
scale=atol+rtol*(abs(E)*abs(y0)+abs(E)*abs(nu)*x);element_residual=E*(y-y0);
if any(!isfinite(scale))||any(scale<=0)||any(!isfinite(element_residual)),error('Reduced:ElementFinite','Finite positive elemental limits and finite residuals required; actual_scale=%s mol actual_residual=%s mol',mat2str(scale'),mat2str(element_residual'));endif
elem=max(abs(element_residual)./scale);
cap=min(a.N0,2*a.B0/3+Q/(3*F));capl=atol+rtol*(a.N0+a.B0+Q/(3*F));kr=0;kl=atol+rtol*(a.B0+1.5*a.N0);
if a.I==0,kr=(y(2)-1.5*y(1))-(a.B0-1.5*a.N0);endif
row=[ci,level,step,t,nr,nl,cl,cll,ox,ol,acid,al,nar,nal,z,al,2*F*x(1)+4*F*x(2)-Q,ql,2*F*x(3)+2*F*x(4)-Q,2*x(5)-cap,capl,min(y([1:5,8:9,11])),-atol,elem,kr,kl];
if any(!isfinite(row))||any([nl,cll,ol,al,nal,ql,capl,kl]<=0),error('Reduced:Finite','Balance actuals and finite positive bounds required');endif
endfunction
function C=check(C,name,actual,limit,unit)
pass=isnumeric(actual)&&isscalar(actual)&&isfinite(actual)&&isnumeric(limit)&&isscalar(limit)&&isfinite(limit)&&actual<=limit;
C(end+1)=struct('name',name,'actual',full(actual),'limit',full(limit),'unit',unit,'comparison','le','pass',pass);
endfunction
function input_guard(p,name,positive)
if !isfield(p,name)||!isnumeric(p.(name))||!isscalar(p.(name))||!isreal(p.(name))||!isfinite(p.(name)),error('Reduced:Input','Finite real scalar required: %s',name);endif
if (positive&&p.(name)<=0)||(!positive&&p.(name)<0),error('Reduced:Input','Invalid %s actual=%s bound0 positive=%d',name,jsonencode(p.(name)),positive);endif
endfunction
elec_reduced_competing_scenarios__reduced_evaluate–b5901a87d083922b.m — Direct named helper referenced by entrypoint
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261118T093245Z-4091642-1794994365236654 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 b5901a87d083922b4cf192687986d19cdd81a60de70cb9cbc3d399b07601561c
function R=reduced_evaluate(p)
% SOURCE ONLY: illustrative reduced kinetics, no assay or physical pH model.
spec='2961766955c2b471fcc2c58b48a4f65730ef9fa89a999b630e626534810b89f4';
if !strcmp(p.specification_sha256,spec),error('Reduced:Spec','Exact reviewed specification04 required');endif
positive={'volume_m3','F_C_mol','M_N_g_mol'};
nonnegative={'current_A','initial_N_g_m3','background_NaCl_mol_m3'};
for k=1:numel(positive),input_guard(p,positive{k},true);endfor
for k=1:numel(nonnegative),input_guard(p,nonnegative{k},false);endfor
% Normalization and stored controls require nominal positive N inventory.
if p.initial_N_g_m3<=0,error('Reduced:Input','initial_N_g_m3 must be >0; chlorine-only controls are generated explicitly');endif
R.species={'formal_NH3','formal_HOCl_equivalent','chloride','exported_Cl2','stipulated_N2','signed_acid','water_reservoir_delta','O2_cumulative','H2_cumulative','electron_reservoir_delta','Na_spectator'};
R.reactions={'CER','OER','CRR','HER','formal_N2_endpoint','formal_Cl2_export'};
R.elements={'N','Cl','H','O','Na','formal_charge'};
E=[1 0 0 0 2 0 0 0 0 0 0;0 1 1 2 0 0 0 0 0 0 0;3 1 0 0 0 1 2 0 2 0 0;0 1 0 0 0 0 1 2 0 0 0;0 0 0 0 0 0 0 0 0 0 1;0 0 -1 0 0 1 0 0 0 -1 1];
nu=[0 0 0 0 -2 0;1 0 -1 0 -3 -1;-1 0 1 0 3 -1;0 0 0 0 0 1;0 0 0 0 1 0;1 4 -1 -2 3 -1;-1 -2 1 0 3 1;0 1 0 0 0 0;0 0 0 1 0 0;2 4 -2 -2 0 0;0 0 0 0 0 0];
R.element_matrix=E;R.reaction_matrix=nu;
C=struct('name',{},'actual',{},'limit',{},'unit',{},'comparison',{},'pass',{});
C=check(C,'integer_element_charge_nullspace',max(abs((E*nu)(:))),0,'1');
Nnom=p.initial_N_g_m3*p.volume_m3/p.M_N_g_mol;Na=p.background_NaCl_mol_m3*p.volume_m3;
if !all(isfinite([Nnom,Na]))||Nnom<=0,error('Reduced:Input','Derived N/Na amounts invalid: %s mol',jsonencode([Nnom,Na]));endif
base=struct('label','L_m0_common_P_pH7p5','family','common','m',0,'pH_ext',7.5,'fCER',.6,'fCRR',.15,'tau',600,'HB',.1*p.volume_m3,'HL',p.volume_m3,'I',p.current_A,'N0',Nnom,'Na0',Na,'B0',0,'reference_kind','none');
cases={base};
for m=[1,2,4],a=base;a.label=sprintf('L_m%d',m);a.family='loss';a.m=m;a.fCRR=.15+.45*m/(1+m);cases{end+1}=a;endfor
for ph=[6,7,8.4,9,11],a=base;a.label=['P_pH' strrep(num2str(ph),'.','p')];a.family='imposed_selectivity';a.pH_ext=ph;a.fCER=.6+.4*(1/(1+10^(ph-7.5))-.5);cases{end+1}=a;endfor
for scale=[.5,2],a=base;a.label=['sensitivity_tau_' strrep(num2str(scale),'.','p')];a.family='sensitivity';a.tau=600*scale;cases{end+1}=a;endfor
for scale=[.5,2],a=base;a.label=['sensitivity_HB_' strrep(num2str(scale),'.','p')];a.family='sensitivity';a.HB=base.HB*scale;cases{end+1}=a;endfor
for scale=[.5,1.5],a=cases{3};a.label=['sensitivity_loss_contrast_' strrep(num2str(scale),'.','p')];a.family='sensitivity';a.fCRR=.15+.45*scale*2/3;cases{end+1}=a;endfor
for scale=[.5,1.5],a=cases{8};a.label=['sensitivity_selectivity_contrast_' strrep(num2str(scale),'.','p')];a.family='sensitivity';a.fCER=.6+.4*scale*(1/(1+10^(9-7.5))-.5);cases{end+1}=a;endfor
for index=[1,4,9],a=cases{index};a.label=['chlorine_only_' a.label];a.family='chlorine_only';a.N0=0;cases{end+1}=a;endfor
for kind={'zero_oxidant','kappa_zero','kappa_positive'}
a=base;a.label=['current_off_' kind{1}];a.family='current_off';a.reference_kind=kind{1};a.I=0;a.fCER=0;a.fCRR=0;
if strcmp(kind{1},'kappa_zero'),a.B0=1.5*Nnom;elseif strcmp(kind{1},'kappa_positive'),a.B0=3*Nnom;endif
cases{end+1}=a;
endfor
if numel(cases)!=23,error('Reduced:Plan','Fixed23case plan violated');endif
R.cases=cases;R.state_headers=[{'case_index','level','step','time_s','dt_s'},R.species,strcat('extent_',R.reactions),strcat('rate_used_',R.reactions),{'I_CER_A','I_OER_A','I_CRR_A','I_HER_A','Q_C','Q_CER_C','Q_OER_C','Q_CRR_C','Q_HER_C','tiny_negative_flag','dt_limiter_code'}];
R.checkpoint_headers=[{'case_index','level','time_s'},R.species,strcat('extent_',R.reactions),{'Q_C'}];
R.balance_headers={'case_index','level','step','time_s','N_residual','N_limit','Cl_residual','Cl_limit','oxidant_residual','oxidant_limit','acid_Cl_residual','acid_Cl_limit','Na_residual','Na_limit','formal_charge','formal_charge_limit','anode_Q_residual','Q_limit','cathode_Q_residual','N_ceiling_excess','N_ceiling_limit','min_stock','stock_lower_bound','element_scaled_max','kappa_residual','kappa_limit'};
R.summary_headers={'case_index','level','dt_max_s','accepted_steps','final_N_atoms_mol','final_oxidant_mol','t50_s','t50_reached','t90_s','t90_reached','implicit_time_residual_max','stationary_error_max'};
states={};balances={};checkpoints={};summary=[];sampled=cell(23,3);totalsteps=0;implicit=zeros(23,3);
for ci=1:23
a=cases{ci};
if any(!isfinite([a.fCER,a.fCRR,a.tau,a.HB,a.HL,a.I,a.N0,a.Na0,a.B0]))||any([a.fCER,a.fCRR]<0)||any([a.fCER,a.fCRR]>1)||min([a.tau,a.HB,a.HL])<=0||min([a.I,a.N0,a.Na0,a.B0])<0,error('Reduced:Case','Invalid fixed case %s',a.label);endif
y0=[a.N0;a.B0;a.Na0+a.N0;0;0;a.N0;0;0;0;0;a.Na0];
for level=1:3
dtmax=[2,1,.5](level);t=0;y=y0;x=zeros(6,1);step=0;next_time=60;
ss=zeros(20001,numel(R.state_headers));bb=zeros(20001,numel(R.balance_headers));cp=zeros(21,numel(R.checkpoint_headers));ns=1;nc=1;
rates=rate(a,y,p.F_C_mol);ss(1,:)=state_row(ci,level,0,t,0,y,x,rates,a.I,p.F_C_mol);
bb(1,:)=balance_row(ci,level,0,t,y,y0,x,a,E,nu,p.F_C_mol);cp(1,:)=[ci,level,0,y',x',0];
imax=0;smax=0;t50=0;t90=0;hit50=false;hit90=false;
while t<1200
rates=rate(a,y,p.F_C_mol);dt=min(dtmax,next_time-t);limiter=1;if next_time-t<dtmax,limiter=2;endif
sinks=[2*rates(5),rates(3)+3*rates(5),rates(1)];stock=[y(1),y(2),y(3)];
for q=1:3,if sinks(q)>0,bound=.5*stock(q)/sinks(q);if bound<dt,dt=bound;limiter=q+2;endif;endif;endfor
if !isfinite(dt)||dt<=0||t+dt<=t,error('Reduced:Step','Invalid dt at case%d level%d step%d: %s',ci,level,step,jsonencode(struct('dt_s',dt,'stocks_mol',stock,'sinks_mol_s',sinks)));endif
yn=y+nu*(dt*rates);xn=x+dt*rates;tn=t+dt;
if any(!isfinite([yn;xn]))||min(yn([1:5,8:9,11]))<0,error('Reduced:Stock','No clipping; case%d level%d step%d actual=%s mol lower_bound=0 (amount tolerance1e-14mol; any negative retained here and stops evaluation)',ci,level,step+1,jsonencode(yn'));endif
if !hit50&&a.N0>0&&yn(1)<=.5*a.N0,t50=t+dt*(y(1)-.5*a.N0)/(y(1)-yn(1));hit50=true;endif
if !hit90&&a.N0>0&&yn(1)<=.1*a.N0,t90=t+dt*(y(1)-.1*a.N0)/(y(1)-yn(1));hit90=true;endif
t=tn;y=yn;x=xn;step+=1;totalsteps+=1;
if step>20000||totalsteps>500000,error('Reduced:Budget','Fixed step budget exceeded case%d level%d count%d total%d',ci,level,step,totalsteps);endif
ns+=1;ss(ns,:)=state_row(ci,level,step,t,dt,y,x,rates,a.I,p.F_C_mol,limiter);
bb(ns,:)=balance_row(ci,level,step,t,y,y0,x,a,E,nu,p.F_C_mol);
if strcmp(a.reference_kind,'zero_oxidant'),smax=max(smax,max(abs(y-y0)));endif
if t==next_time
nc+=1;cp(nc,:)=[ci,level,t,y',x',a.I*t];
if any(strcmp(a.reference_kind,{'kappa_zero','kappa_positive'}))
lrN=log1p((y(1)-a.N0)/a.N0);
if strcmp(a.reference_kind,'kappa_zero')
rhs=-lrN+(2*a.HB/3)*(1/y(1)-1/a.N0);
else
kappa=a.B0-1.5*a.N0;lrB=log1p((y(2)-a.B0)/a.B0);rhs=-lrN-(a.HB/kappa)*(lrN-lrB);
endif
residual=abs(a.tau*rhs-t)/1200;
if !isfinite(residual),error('Reduced:Reference','Nonfinite declared current-off reference case%d level%d',ci,level);endif
imax=max(imax,residual);
endif
next_time=min(1200,next_time+60);
endif
endwhile
if nc!=21,error('Reduced:Checkpoint','Exact21checkpoint schedule required');endif
states{end+1}=ss(1:ns,:);balances{end+1}=bb(1:ns,:);checkpoints{end+1}=cp;
% Retain all actual/limit pairs per step; summary checks aggregate normalized ratios.
diag=bb(1:ns,:);ratios=[abs(diag(:,5))./diag(:,6),abs(diag(:,7))./diag(:,8),abs(diag(:,9))./diag(:,10),abs(diag(:,11))./diag(:,12),abs(diag(:,13))./diag(:,14),abs(diag(:,15))./diag(:,16),abs(diag(:,17))./diag(:,18),abs(diag(:,19))./diag(:,18),max(0,diag(:,20))./diag(:,21),diag(:,24),abs(diag(:,25))./diag(:,26)];
labels={'N','Cl','oxidant','acid_Cl','Na','formal_charge','anode_Q','cathode_Q','N_ceiling','all_elements','kappa'};
for z=1:numel(labels),C=check(C,sprintf('%s_level%d_%s_all_steps',a.label,level,labels{z}),max(ratios(:,z)),1,'1');endfor
C=check(C,sprintf('%s_level%d_instant_anode',a.label,level),max(abs(ss(1:ns,29)+ss(1:ns,30)-a.I)),1e-12+1e-10*a.I,'A');
C=check(C,sprintf('%s_level%d_instant_cathode',a.label,level),max(abs(ss(1:ns,31)+ss(1:ns,32)-a.I)),1e-12+1e-10*a.I,'A');
C=check(C,sprintf('%s_level%d_initial_state',a.label,level),max(abs(ss(1,6:16)'-y0)),0,'mol');
C=check(C,sprintf('%s_level%d_nonnegative_stocks',a.label,level),max(0,-min(diag(:,22))),1e-14,'mol');
if a.N0==0,C=check(C,sprintf('%s_level%d_zero_N',a.label,level),max(abs([ss(1:ns,6);ss(1:ns,10)])),0,'mol');endif
if strcmp(a.reference_kind,'zero_oxidant'),C=check(C,sprintf('%s_level%d_stationary',a.label,level),smax,0,'mol');endif
if level==3&&any(strcmp(a.reference_kind,{'kappa_zero','kappa_positive'})),C=check(C,[a.label '_fine_implicit_time'],imax,.01,'1');endif
summary(end+1,:)=[ci,level,dtmax,step,y(1),y(2),t50,double(hit50),t90,double(hit90),imax,smax];implicit(ci,level)=imax;
Bscale=max([a.B0+a.I*1200/(2*p.F_C_mol),Nnom,a.HB]);
sampled{ci,level}=[cp(:,4)/Nnom,cp(:,5)/Bscale,cp(:,19)/Nnom,cp(:,15)/Bscale,cp(:,17)/Bscale,cp(:,16)/Bscale,cp(:,18)/Bscale];
endfor
endfor
R.states=vertcat(states{:});R.balances=vertcat(balances{:});R.checkpoints=vertcat(checkpoints{:});R.summary=summary;
R.refinement_headers={'case_index','E21','E10','order','order_assessed','stationary_exempt','error_floor','order_lower','order_upper','difference_limit'};
conv=[];convlabels={};assessed=0;required=0;
for ci=1:23
e21=max(abs(sampled{ci,1}(:)-sampled{ci,2}(:)));e10=max(abs(sampled{ci,2}(:)-sampled{ci,3}(:)));order=0;available=false;exempt=strcmp(cases{ci}.reference_kind,'zero_oxidant');
C=check(C,[cases{ci}.label '_fine_difference'],e10,.01,'1');
if exempt,status='EXACT_STATIONARY_EXEMPT';else
required+=1;
if e21>1e-9&&e10>1e-9
order=log2(e21/e10);available=true;assessed+=1;status='ASSESSED';C=check(C,[cases{ci}.label '_order_lower'],.7-order,0,'1');C=check(C,[cases{ci}.label '_order_upper'],order-1.3,0,'1');
else status='NOT_ASSESSED_ERROR_FLOOR';endif
endif
conv(end+1,:)=[ci,e21,e10,order,double(available),double(exempt),1e-9,.7,1.3,.01];convlabels{end+1,1}=status;
endfor
ph=[6;7;7.5;8.4;9;11];aa=1./(1+10.^(9.3-ph));bb=1./(1+10.^(ph-7.5));g=aa.*bb;
C=check(C,'dimensionless_prefactor_derivative_at_mean_pKa',abs(log(10)*g(4)*(bb(4)-aa(4))),1e-14,'1');
C=check(C,'dimensionless_prefactor_declared_grid_maximum',max(g)-g(4),1e-14,'1');
R.refinement=conv;R.refinement_labels=convlabels;R.checks=C;R.arithmetic_checks_passed=all([C.pass]);R.convergence_rows_assessed=assessed;R.convergence_rows_total=required;R.convergence_verified=assessed==required;
R.passed=R.arithmetic_checks_passed&&R.convergence_verified;
if !R.arithmetic_checks_passed,R.validation_status='FAILED_CHECK';elseif !R.convergence_verified,R.validation_status='PARTIAL_ERROR_FLOOR';else R.validation_status='VERIFIED_NUMERICS_ILLUSTRATIVE_ONLY';endif
R.prefactor=[ph,aa,bb,g];
R.prefactor_headers={'external_pH_label','alpha_NH3','alpha_HOCl','dimensionless_formation_prefactor'};
R.total_steps=totalsteps;R.implicit_residual_by_level=implicit;
endfunction
function r=rate(a,y,F)
cer=a.fCER*a.I/(2*F)*y(3)/(y(3)+a.HL);crr=a.fCRR*a.I/(2*F)*y(2)/(y(2)+a.HB);n2=y(1)/(2*a.tau)*y(2)/(y(2)+a.HB);
r=[cer;(a.I-2*F*cer)/(4*F);crr;(a.I-2*F*crr)/(2*F);n2;0];
if any(!isfinite(r))||any(r<0),error('Reduced:Rate','Invalid rate vector actual=%s mol/s lower0',jsonencode(r'));endif
endfunction
function row=state_row(ci,level,step,t,dt,y,x,r,I,F,limiter)
if nargin<11,limiter=0;endif
row=[ci,level,step,t,dt,y',x',r',2*F*r(1),4*F*r(2),2*F*r(3),2*F*r(4),I*t,2*F*x(1),4*F*x(2),2*F*x(3),2*F*x(4),double(any(y([1:5,8:9,11])<0)),limiter];
if any(!isfinite(row)),error('Reduced:Finite','Entire state row must be finite');endif
endfunction
function row=balance_row(ci,level,step,t,y,y0,x,a,E,nu,F)
atol=1e-14;rtol=1e-10;Q=a.I*t;
nr=y(1)+2*x(5)-a.N0;nl=atol+rtol*(a.N0+2*x(5));cl=y(3)+y(2)+2*x(6)-(y0(3)+a.B0);cll=atol+rtol*(y0(3)+a.B0+x(1)+x(3)+3*x(5)+2*x(6));
ox=y(2)+x(6)+3*x(5)+x(3)-(a.B0+x(1));ol=atol+rtol*(a.B0+x(1)+x(3)+3*x(5)+x(6));acid=y(6)-y(3)-(y0(6)-y0(3));al=atol+rtol*(abs(y0(6))+abs(y0(3))+sum(abs(y-y0)));
nar=y(11)-a.Na0;nal=atol+rtol*a.Na0;z=y(6)-y(3)+y(11)-y(10);ql=1e-9+rtol*abs(Q);
% Gross integrated species transfers count both consumed and produced
% stoichiometric contributions, without cancellation of net stock changes.
scale=atol+rtol*(abs(E)*abs(y0)+abs(E)*abs(nu)*x);element_residual=E*(y-y0);
if any(!isfinite(scale))||any(scale<=0)||any(!isfinite(element_residual)),error('Reduced:ElementFinite','Finite positive elemental limits and finite residuals required; actual_scale=%s mol actual_residual=%s mol',mat2str(scale'),mat2str(element_residual'));endif
elem=max(abs(element_residual)./scale);
cap=min(a.N0,2*a.B0/3+Q/(3*F));capl=atol+rtol*(a.N0+a.B0+Q/(3*F));kr=0;kl=atol+rtol*(a.B0+1.5*a.N0);
if a.I==0,kr=(y(2)-1.5*y(1))-(a.B0-1.5*a.N0);endif
row=[ci,level,step,t,nr,nl,cl,cll,ox,ol,acid,al,nar,nal,z,al,2*F*x(1)+4*F*x(2)-Q,ql,2*F*x(3)+2*F*x(4)-Q,2*x(5)-cap,capl,min(y([1:5,8:9,11])),-atol,elem,kr,kl];
if any(!isfinite(row))||any([nl,cll,ol,al,nal,ql,capl,kl]<=0),error('Reduced:Finite','Balance actuals and finite positive bounds required');endif
endfunction
function C=check(C,name,actual,limit,unit)
pass=isnumeric(actual)&&isscalar(actual)&&isfinite(actual)&&isnumeric(limit)&&isscalar(limit)&&isfinite(limit)&&actual<=limit;
C(end+1)=struct('name',name,'actual',full(actual),'limit',full(limit),'unit',unit,'comparison','le','pass',pass);
endfunction
function input_guard(p,name,positive)
if !isfield(p,name)||!isnumeric(p.(name))||!isscalar(p.(name))||!isreal(p.(name))||!isfinite(p.(name)),error('Reduced:Input','Finite real scalar required: %s',name);endif
if (positive&&p.(name)<=0)||(!positive&&p.(name)<0),error('Reduced:Input','Invalid %s actual=%s bound0 positive=%d',name,jsonencode(p.(name)),positive);endif
endfunction
elec_reduced_competing_scenarios__reduced_publish–b4aff1557ad8aab4.m — Direct named helper referenced by entrypoint
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261118T093245Z-4091642-1794994365236654 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 b4aff1557ad8aab4a6c99f1ea6ecbc90a953d72b710d2d20c4d6458e017fd874
function receipts=reduced_publish(ctx,p,R)
% Public create-only tables; no direct canonical storage/registry access.
if isempty(regexp(p.output_prefix,'^[A-Za-z][A-Za-z0-9_.-]{0,100}$','once')),error('Reduced:ID','New bounded output prefix required');endif
def=struct('contract','table.generic','storage','auto','replace_owned',false,'producer_version','1.0.3', ...
'source_dataset_ids',{{p.source_dataset_id}},'source','Illustrative conservative reduced model', ...
'provenance',['Actual run ' ctx.run_id '; Project SHA ' ctx.script_sha256 '; reviewed spec ' p.specification_sha256], ...
'notes','Formal NH3/HOCl-equivalent bookkeeping with NH4Cl counterion and Na spectator; no free-H+/physical pH or TNT830/DPD observation model. No RPM fit. Prescribed pH is a scenario label. N2/O2/H2/export are cumulative stipulated product ledgers. Stripping is explicitly zero. Units mol for chemical amounts retain distinct elemental/oxidant/product bases in variable names; they must not be pooled as one observable.');
receipts={};
keys=fieldnames(p);values=cell(numel(keys),1);refs=values;status=values;units=values;
nominal=struct('volume_m3',.0002,'current_A',.12,'initial_N_g_m3',10,'background_NaCl_mol_m3',84,'F_C_mol',96485.33212,'M_N_g_mol',14.0067);
for k=1:numel(keys)
key=keys{k};values{k}=jsonencode(p.(key));refs{k}='';status{k}='execution_or_source_label';units{k}='1';
if isfield(nominal,key)
refs{k}=jsonencode(nominal.(key));
if any(strcmp(key,{'F_C_mol','M_N_g_mol'})),status{k}='adopted_physical_constant';else status{k}='source_reported_nominal';endif
if !isequal(p.(key),nominal.(key)),status{k}=['explicit_override_of_' status{k}];endif
endif
switch key
case 'volume_m3',units{k}='m^3';case 'current_A',units{k}='A';case 'initial_N_g_m3',units{k}='g/m^3';case 'background_NaCl_mol_m3',units{k}='mol/m^3';case 'F_C_mol',units{k}='A*s/mol';case 'M_N_g_mol',units{k}='g/mol';
endswitch
endfor
cols=struct('parameter',{keys},'actual_literal',{values},'nominal_reference_literal',{refs},'unit_label',{units},'status',{status});
receipts=commit(receipts,[p.output_prefix '.inputs'],cols,struct(),def);
c=R.cases;n=numel(c);cols=struct('case_index',(1:n)');
text={'label','family','reference_kind'};num={'m','pH_ext','fCER','fCRR','tau','HB','HL','I','N0','Na0','B0'};
for k=1:numel(text),v=cell(n,1);for j=1:n,v{j}=c{j}.(text{k});endfor;cols.(text{k})=v;endfor
um=struct('tau','s','HB','mol','HL','mol','I','A','N0','mol','Na0','mol','B0','mol');
for k=1:numel(num),v=zeros(n,1);for j=1:n,v(j)=c{j}.(num{k});endfor;cols.(num{k})=v;endfor
cols.parameter_status=repmat({'illustrative_programmed_scenario_not_fitted'},n,1);
receipts=commit(receipts,[p.output_prefix '.cases'],cols,um,def);
descriptions={'states','state_headers';'balances','balance_headers';'checkpoints','checkpoint_headers';'summary','summary_headers';'refinement','refinement_headers';'prefactor','prefactor_headers'};
for d=1:size(descriptions,1)
key=descriptions{d,1};headers=R.(descriptions{d,2});matrix=R.(key);
if size(matrix,2)!=numel(headers),error('Reduced:Shape','Header mismatch %s',key);endif
cols=struct();um=struct();
for k=1:numel(headers),cols.(headers{k})=matrix(:,k);um.(headers{k})=unit_for(key,headers{k});endfor
% V9 publication-only unit conversions from this Job's computed states.
% 1 g/m^3 equals 1 mg/L. This is formal remaining N, not an assay model.
if any(strcmp(key,{'states','checkpoints'}))
cols.time_min=cols.time_s/60;um.time_min='min';
cols.formal_N_mgN_L=cols.formal_NH3*p.M_N_g_mol/p.volume_m3;um.formal_N_mgN_L='mg/L';
nominal_N=p.initial_N_g_m3*p.volume_m3/p.M_N_g_mol;
cols.formal_N_fraction_nominal=cols.formal_NH3/nominal_N;um.formal_N_fraction_nominal='1';
labels=cell(size(matrix,1),1);
for row=1:size(matrix,1)
index=cols.case_index(row);
if index!=fix(index)||index<1||index>numel(R.cases),error('Reduced:Case','Invalid publication case index');endif
labels{row}=R.cases{index}.label;
endfor
cols.case_label=labels;
cols.observation_scope=repmat({'illustrative_formal_N_not_validated_TNT830_assay'},size(matrix,1),1);
endif
if strcmp(key,'refinement'),cols.order_status=R.refinement_labels;endif
receipts=commit(receipts,[p.output_prefix '.' key],cols,um,def);
endfor
species={};reactions={};v=[];
for j=1:numel(R.species),for k=1:numel(R.reactions),species{end+1,1}=R.species{j};reactions{end+1,1}=R.reactions{k};v(end+1,1)=R.reaction_matrix(j,k);endfor;endfor
receipts=commit(receipts,[p.output_prefix '.stoichiometry'],struct('species',{species},'reaction',{reactions},'integer_coefficient',v),struct(),def);
species={};elements={};v=[];
for j=1:numel(R.species),for k=1:numel(R.elements),species{end+1,1}=R.species{j};elements{end+1,1}=R.elements{k};v(end+1,1)=R.element_matrix(k,j);endfor;endfor
receipts=commit(receipts,[p.output_prefix '.elements'],struct('species',{species},'element_or_formal_charge',{elements},'integer_coefficient',v),struct(),def);
C=R.checks;cols=struct('check_name',{{C.name}'},'actual',[C.actual]','limit',[C.limit]','unit_label',{{C.unit}'},'comparison',{{C.comparison}'},'passed',double([C.pass]'));
receipts=commit(receipts,[p.output_prefix '.checks'],cols,struct(),def);
endfunction
function unit=unit_for(table,key)
unit='1';
if strcmp(table,'states')
if any(strcmp(key,{'time_s','dt_s'})),unit='s';elseif strncmp(key,'rate_used_',10),unit='mol/s';elseif strncmp(key,'I_',2),unit='A';elseif strncmp(key,'Q_',2),unit='A*s';elseif !any(strcmp(key,{'case_index','level','step','tiny_negative_flag','dt_limiter_code'})),unit='mol';endif
elseif strcmp(table,'checkpoints')
if strcmp(key,'time_s'),unit='s';elseif strcmp(key,'Q_C'),unit='A*s';elseif !any(strcmp(key,{'case_index','level'})),unit='mol';endif
elseif strcmp(table,'balances')
if strcmp(key,'time_s'),unit='s';elseif any(strcmp(key,{'anode_Q_residual','Q_limit','cathode_Q_residual'})),unit='A*s';elseif !any(strcmp(key,{'case_index','level','step','element_scaled_max'})),unit='mol';endif
elseif strcmp(table,'summary')
if any(strcmp(key,{'dt_max_s','t50_s','t90_s'})),unit='s';elseif any(strcmp(key,{'final_N_atoms_mol','final_oxidant_mol','stationary_error_max'})),unit='mol';endif
endif
endfunction
function receipts=commit(receipts,id,cols,units,def)
def.dataset_id=id;keys=fieldnames(cols);count=numel(cols.(keys{1}));writer=gxtxt_api_call('DATASET_PUBLICATION_API_v2','begin',{def});
try
gxtxt_api_call('DATASET_PUBLICATION_API_v2','declare_dimension',{writer,'row',count,struct('extendible',false)});
for k=1:numel(keys)
key=keys{k};v=cols.(key);unit='1';if isfield(units,key),unit=units.(key);endif
if numel(v)!=count,error('Reduced:Shape','Column mismatch %s',key);endif
if iscell(v),dtype='string';kind='text';else
v=full(v);if !isreal(v)||any(!isfinite(v(:))),error('Reduced:Finite','Finite real dense publication column required: %s',key);endif
dtype='float64';kind='number';
endif
schema=struct('dtype',dtype,'value_kind',kind,'rank',1,'dimension_ids',{{'row'}},'name',key,'unit',unit,'coordinate_role','data','axis_kind','explicit');
gxtxt_api_call('DATASET_PUBLICATION_API_v2','declare_variable',{writer,key,schema});
gxtxt_api_call('DATASET_PUBLICATION_API_v2','write_variable',{writer,key,v,count});
endfor
receipt=gxtxt_api_call('DATASET_PUBLICATION_API_v2','finalize',{writer});receipts{end+1}=receipt;fprintf('CANONICAL_RECEIPT %s\n',jsonencode(receipt));
catch err
try gxtxt_api_call('DATASET_PUBLICATION_API_v2','abort',{writer});catch,end_try_catch
rethrow(err);
end_try_catch
endfunction
elec_reduced_competing_scenarios__reduced_run–49100713bcc10a52.m — Actual invoked project entrypoint
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261118T093245Z-4091642-1794994365236654 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 49100713bcc10a5298d09cdc6c4b94d5f4af008dd984bee10c24d20ec046857a
% Reduced source1.0.3: source-only, same primary ELEC-01, no physical validation.
gxtxt_api_require('DATASET_PUBLICATION_API_v2@2');
gxtxt_api_require('DATASET_FILE_PUBLICATION_API_v1@1');
gxtxt_api_require('UNIT_REGISTRY_API_v1@1');
gxtxt_parameter_declare('volume_m3','double','default',.0002,'min',0,'description','Source-reported nominal beaker volume; override labelled explicitly');
gxtxt_parameter_declare('current_A','double','default',.12,'min',0,'description','Source-reported nominal current; current-off controls override this');
gxtxt_parameter_declare('initial_N_g_m3','double','default',10,'min',0,'description','Source-reported nominal NH4Cl nitrogen; must be positive, N0=0 controls explicit');
gxtxt_parameter_declare('background_NaCl_mol_m3','double','default',84,'min',0,'description','Background NaCl only; NH4Cl adds chloride');
gxtxt_parameter_declare('F_C_mol','double','default',96485.33212,'min',0,'description','Adopted Faraday constant');
gxtxt_parameter_declare('M_N_g_mol','double','default',14.0067,'min',0,'description','Adopted nitrogen molar mass');
gxtxt_parameter_declare('output_prefix','string','default','elec_reduced_v1_01','description','NEW create-only canonical prefix');
gxtxt_parameter_declare('source_dataset_id','string','default','ref-001_atrashkevich_2025_hal_accepted','description','Actual HAL paper context binding');
gxtxt_parameter_declare('specification_sha256','string','default','2961766955c2b471fcc2c58b48a4f65730ef9fa89a999b630e626534810b89f4','description','Reviewed exact reduced specification04');
ctx=gxtxt_context();p=ctx.parameters;
if !all(isfield(ctx,{'output_dir','run_id','script_sha256','inputs'})),error('Reduced:Context','Actual registered native context required');endif
try
todo={ctx.inputs};bound={};
while !isempty(todo)
value=todo{end};todo(end)=[];
if isstruct(value)
for j=1:numel(value)
if isfield(value(j),'dataset_id')&&ischar(value(j).dataset_id),bound{end+1}=value(j).dataset_id;endif
names=fieldnames(value(j));for k=1:numel(names),v=value(j).(names{k});if isstruct(v)||iscell(v),todo{end+1}=v;endif;endfor
endfor
elseif iscell(value),todo=[todo,value(:)'];endif
endwhile
if !any(strcmp(bound,p.source_dataset_id)),error('Reduced:Binding','Actual bound HAL PDF required');endif
cv=gxtxt_api_call('UNIT_REGISTRY_API_v1','convert',{1,'mm','m'});
if !isscalar(cv)||!isfinite(cv)||abs(cv-.001)>1e-13,error('Reduced:Unit','Native mm-to-m conversion failed');endif
R=reduced_evaluate(p);
% Preserve complete fresh numerical evidence before scientific checks can fail.
diagnostics_path=fullfile(ctx.output_dir,'reduced_diagnostics.mat');
save('-mat7-binary',diagnostics_path,'R');
report=struct('schema','elec.reduced.illustrative.v1','source_version','1.0.3','run_id',ctx.run_id,'project_sha256',ctx.script_sha256,'module_id',ctx.module_id, ...
'parameters',p,'input_bindings',ctx.inputs,'runtime',struct('octave_version',version(),'architecture',computer(),'OMP_NUM_THREADS',getenv('OMP_NUM_THREADS'),'OPENBLAS_NUM_THREADS',getenv('OPENBLAS_NUM_THREADS')), ...
'expected_experiment_id','experiment-20261117T171059Z-846242-1794935459579080-1','validation_status',R.validation_status, ...
'arithmetic_checks_passed',R.arithmetic_checks_passed,'convergence_verified',R.convergence_verified,'convergence_rows_assessed',R.convergence_rows_assessed,'convergence_rows_total',R.convergence_rows_total, ...
'required_checks_passed',R.passed,'diagnostics_artifact','reduced_diagnostics.mat','diagnostics_format','MATLAB-v7 binary via Octave -mat7-binary', ...
'complete_evaluation_returned',true,'completed_case_levels',size(R.summary,1),'retained_state_rows',size(R.states,1),'retained_balance_rows',size(R.balances,1),'retained_checkpoint_rows',size(R.checkpoints,1), ...
'elemental_scale_convention','initial absolute elemental amounts plus abs(E)*abs(nu)*cumulative_extents; both consumed and produced species contributions', ...
'total_steps',R.total_steps,'cases',{R.cases},'checks',R.checks,'implicit_residual_by_level',R.implicit_residual_by_level, ...
'scope','Shared illustrative production/loss alternatives only; no RPM fit, no physical pH, no assay/N2 validation; zero stripping explicit');
reportpath=fullfile(ctx.output_dir,'reduced_report.json');fid=fopen(reportpath,'w');if fid<0,error('Reduced:Output','Cannot write owned diagnostic');endif
unwind_protect
fprintf(fid,'%s\n',jsonencode(report));
unwind_protect_cleanup
fclose(fid);
end_unwind_protect
if !R.passed,error('Reduced:Checks','Required checks/coverage incomplete; owned report retained, no PASS publication');endif
receipts=reduced_publish(ctx,p,R);
request=struct('dataset_id',[p.output_prefix '.report'],'contract','document.text','format','json','source_file',reportpath,'storage_kind','text','media_type','application/json','producer_version','1.0.3','source_dataset_ids',{{p.source_dataset_id}},'source','Illustrative reduced native Project','provenance',['Actual run ' ctx.run_id '; Project SHA ' ctx.script_sha256],'notes','Numerical verification only; no mechanistic/assay/physical validation.');
receipt=gxtxt_api_call('DATASET_FILE_PUBLICATION_API_v1','publish',{request});fprintf('CANONICAL_RECEIPT %s\n',jsonencode(receipt));
fid=fopen(fullfile(ctx.output_dir,'reduced_publication_receipts.json'),'w');if fid<0,error('Reduced:Output','Cannot write owned diagnostic');endif
unwind_protect
fprintf(fid,'%s\n',jsonencode(struct('tables',{receipts},'report',receipt)));
unwind_protect_cleanup
fclose(fid);
end_unwind_protect
catch err
failure=struct('schema','elec.reduced.failure.v1','run_id',ctx.run_id,'project_sha256',ctx.script_sha256,'parameters',p,'complete_evaluation_returned',exist('R','var')==1,'diagnostics_artifact_if_written','reduced_diagnostics.mat','early_guard_scope','If evaluator did not return, no complete69integration evidence is claimed; retained guard message/stack only', ...
'identifier',err.identifier,'message',err.message,'stack',err.stack);
fid=fopen(fullfile(ctx.output_dir,'reduced_failure.json'),'w');
if fid>=0
unwind_protect
fprintf(fid,'%s\n',jsonencode(failure));
unwind_protect_cleanup
fclose(fid);
end_unwind_protect
endif
rethrow(err);
end_try_catch
elec_gate2_neutral_diffusion_corrected__gate2_evaluate–e6abade0c9b2c81a.m — Direct named helper referenced by entrypoint
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261117T214559Z-1706497-1794951959732939 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 e6abade0c9b2c81ad4a0e9a8ea0b1d639f60901cc2d1da849f79c4f3eabcc8b7
function R=gate2_evaluate(p)
% Unexecuted Gate2 v1.0.2: fixed manufactured neutral diffusion problems.
for name={'length_m','diffusivity_m2_s','concentration_mol_m3','epsilon'}
key=name{1};if !isfield(p,key)||!isnumeric(p.(key))||!isscalar(p.(key))||!isfinite(p.(key))||p.(key)<=0
error('Gate2:Input','%s must be finite and positive',key);
endif
endfor
if p.epsilon>=1,error('Gate2:Input','epsilon must be below one');endif
L=p.length_m;D=p.diffusivity_m2_s;cref=p.concentration_mol_m3;epsilon=p.epsilon;
T=0.1*L^2/D;mass_scale=cref*L;flux_scale=D*cref/L;
if !all(isfinite([T,mass_scale,flux_scale]))||any([T,mass_scale,flux_scale]<=0)
error('Gate2:Scale','Derived T and fixed physical scales must be finite positive');
endif
plans={};
for N=[20,40,80]
plans{end+1}=struct('label',sprintf('closed_N%d_steps80',N),'N',N,'steps',80,'kind','closed','control',false);
plans{end+1}=struct('label',sprintf('open_N%d_steps80',N),'N',N,'steps',80,'kind','open','control',false);
endfor
for steps=[20,40]
plans{end+1}=struct('label',sprintf('closed_N40_steps%d',steps),'N',40,'steps',steps,'kind','closed','control',false);
endfor
plans{end+1}=struct('label','unequal_Dirichlet_steady_control','N',40,'steps',1,'kind','steady','control',true);
plans{end+1}=struct('label','equal_Dirichlet_constant_control','N',40,'steps',1,'kind','constant','control',true);
R.plan=plans;R.inputs=p;R.final_time_s=T;
R.fields=[];R.fluxes=[];R.budgets=[];R.operator=[];R.forcing=[];R.summary=[];R.convergence=[];
R.checks=struct('name',{},'actual',{},'limit',{},'unit',{},'comparison',{},'pass',{});
for run=1:numel(plans)
plan=plans{run};N=plan.N;h=L/N;dt=T/plan.steps;r=D/h^2;
x=((1:N)'-0.5)*h;k=pi/L;S=sin(k*h/2)/(k*h/2);
if !all(isfinite([h,dt,r,S]))||any([h,dt,r]<=0),error('Gate2:Scale','Invalid mesh/time/operator scale');endif
A=spdiags([r*ones(N,1),-2*r*ones(N,1),r*ones(N,1)],[-1,0,1],N,N);
forcing=zeros(N,1);cl=cref;cr=2*cref;
if strcmp(plan.kind,'closed')
A(1,1)=-r;A(N,N)=-r;steady=cref*ones(N,1);
v=cos(pi*((1:N)'-0.5)/N);amp=cref*epsilon*S;
else
if strcmp(plan.kind,'constant'),cr=cref;endif
A(1,1)=-3*r;A(N,N)=-3*r;
forcing(1)=2*r*cl;forcing(N)=2*r*cr;
steady=cl+(cr-cl)*x/L;v=sin(pi*((1:N)'-0.5)/N);
amp=0.25*cref*S;if plan.control,amp=0;endif
endif
lambda=4*D/h^2*sin(pi/(2*N))^2;
normalizers=[r*cref,cref/dt,h*r,lambda,D*k^2];
if !all(isfinite(normalizers))||any(normalizers<=0),error('Gate2:Scale','Nonfinite or underflowed normalization/reference rate');endif
B=speye(N)-dt*A;
if !all(isfinite(nonzeros(B)))||!all(isfinite(forcing)),error('Gate2:Finite','Nonfinite actual system');endif
expected=A*steady+forcing;
R.checks=check(R.checks,[plan.label '_steady_operator'],max(abs(expected))/(r*cref),1e-10,'1','le');
R.checks=check(R.checks,[plan.label '_actual_operator_mode'],max(abs(A*v+lambda*v))/r,1e-10,'1','le');
if strcmp(plan.kind,'closed')
R.checks=check(R.checks,[plan.label '_constant_row_sums'],max(abs(A*ones(N,1)))/r,1e-10,'1','le');
R.checks=check(R.checks,[plan.label '_weighted_column_sums'],max(abs(h*sum(A,1)))/(h*r),1e-10,'1','le');
endif
% Explicit independent stencil/forcing contract checks for actual matrix.
expectedA=zeros(N);expectedf=zeros(N,1);
for i=1:N
if i>1,expectedA(i,i-1)=r;endif
if i<N,expectedA(i,i+1)=r;endif
expectedA(i,i)=-2*r;
endfor
if strcmp(plan.kind,'closed'),expectedA(1,1)=-r;expectedA(N,N)=-r;
else expectedA(1,1)=-3*r;expectedA(N,N)=-3*r;expectedf(1)=2*r*cl;expectedf(N)=2*r*cr;endif
R.checks=check(R.checks,[plan.label '_stencil_entries'],max(abs(full(A)(:)-expectedA(:)))/r,1e-10,'1','le');
R.checks=check(R.checks,[plan.label '_forcing_entries'],max(abs(forcing-expectedf))/(r*cref),1e-10,'1','le');
[ii,jj,vv]=find(A);R.operator=[R.operator;[run*ones(numel(vv),1),ii,jj,vv]];
R.forcing=[R.forcing;[run*ones(N,1),(1:N)',x,forcing,steady,v]];
C=steady+amp*v;initial_mass=h*sum(C);cumulative=0;
for step=0:plan.steps
t=step*dt;
if step>0
old=C;C=B\(old+dt*forcing);
residual=(C-old)/dt-A*C-forcing;
R.checks=check(R.checks,sprintf('%s_step%d_equation',plan.label,step),max(abs(residual))/(cref/dt),1e-10,'1','le');
endif
J=zeros(N+1,1);J(2:N)=-D*diff(C)/h;
if !strcmp(plan.kind,'closed'),J(1)=-D*(C(1)-cl)/(h/2);J(end)=-D*(cr-C(end))/(h/2);endif
if step>0,cumulative+=dt*(J(1)-J(end));endif
continuum=steady+amp*v*exp(-D*k^2*t);
semidiscrete=steady+amp*v*exp(-lambda*t);
discrete=steady+amp*v*(1+dt*lambda)^(-step);
mass=h*sum(C);budget=mass-initial_mass-cumulative;
if strcmp(plan.kind,'closed'),continuum_mass=cref*L;
else continuum_mass=L*(cl+cr)/2+2*(amp/S)*exp(-D*k^2*t)/k;endif
exact_initial_mass=L*(cl+cr)/2+2*(amp/S)/k;
if strcmp(plan.kind,'closed'),exact_initial_mass=cref*L;endif
continuum_transfer=continuum_mass-exact_initial_mass;
econt=norms(C-continuum,h,L,cref);esemi=norms(C-semidiscrete,h,L,cref);
eBE=norms(C-discrete,h,L,cref);espace=norms(semidiscrete-continuum,h,L,cref);
if step==0
R.checks=check(R.checks,[plan.label '_exact_initial_inventory'],abs(mass-exact_initial_mass)/mass_scale,1e-10,'1','le');
else
local_budget=mass-h*sum(old)-dt*(J(1)-J(end));
R.checks=check(R.checks,sprintf('%s_step%d_local_budget',plan.label,step),abs(local_budget)/mass_scale,1e-10,'1','le');
endif
R.checks=check(R.checks,sprintf('%s_step%d_budget',plan.label,step),abs(budget)/mass_scale,1e-10,'1','le');
R.checks=check(R.checks,sprintf('%s_step%d_BE_mode',plan.label,step),eBE(1),1e-10,'1','le');
R.checks=check(R.checks,sprintf('%s_step%d_nonnegative',plan.label,step),min(C)/cref,-1e-12,'1','ge');
if strcmp(plan.kind,'closed')
R.checks=check(R.checks,sprintf('%s_step%d_closed_inventory',plan.label,step),abs(mass-cref*L)/mass_scale,1e-10,'1','le');
endif
if plan.control
exact_flux=D*(cl-cr)/L;
R.checks=check(R.checks,sprintf('%s_step%d_steady_flux',plan.label,step),max(abs(J-exact_flux))/flux_scale,1e-10,'1','le');
R.checks=check(R.checks,sprintf('%s_step%d_preservation',plan.label,step),max(abs(C-steady))/cref,1e-10,'1','le');
endif
R.fields=[R.fields;[run*ones(N,1),step*ones(N,1),t*ones(N,1),(1:N)',x,C,continuum,semidiscrete,discrete,C-continuum,C-semidiscrete,C-discrete,double(C<0)]];
R.fluxes=[R.fluxes;[run*ones(N+1,1),step*ones(N+1,1),t*ones(N+1,1),(0:N)',(0:N)'*h,J]];
R.budgets=[R.budgets;[run,step,t,dt,mass,initial_mass,cumulative,budget,J(1),J(end),continuum_mass,continuum_transfer,min(C),econt,esemi,eBE,espace]];
endfor
R.summary=[R.summary;[run,N,plan.steps,h,dt,T,lambda,econt,esemi,eBE,espace]];
endfor
% Fixed closed studies: auxiliary80-step cases at runs1/3/5; time runs7/8/3.
groups={struct('name','spatial_semidiscrete','runs',[1,3,5],'columns',[14,15],'lo',1.8,'hi',2.2), ...
struct('name','temporal_samegrid_BE','runs',[7,8,3],'columns',[10,11],'lo',0.8,'hi',1.2)};
R.arithmetic_checks_passed=all([R.checks.pass]);
R.convergence_labels={};R.convergence_studies={};R.convergence_norms={};
for group=1:2
g=groups{group};
for normidx=1:2
for pair=1:2
coarse=R.summary(g.runs(pair),g.columns(normidx));fine=R.summary(g.runs(pair+1),g.columns(normidx));
eligible=(coarse>1e-11&&fine>1e-11);rate=0;
if eligible
rate=log(coarse/fine)/log(2);
R.checks=check(R.checks,sprintf('%s_norm%d_pair%d_lower',g.name,normidx,pair),rate,g.lo,'1','ge');
R.checks=check(R.checks,sprintf('%s_norm%d_pair%d_upper',g.name,normidx,pair),rate,g.hi,'1','le');
endif
R.convergence=[R.convergence;[group,normidx,g.runs(pair),g.runs(pair+1),coarse,fine,rate,double(eligible),1e-11,g.lo,g.hi]];
R.convergence_studies{end+1,1}=g.name;
if normidx==1,R.convergence_norms{end+1,1}='normalized_Linf';else R.convergence_norms{end+1,1}='normalized_cell_weighted_L2';endif
if eligible,R.convergence_labels{end+1,1}='rate_assessed';else R.convergence_labels{end+1,1}='error_floor_limited_rate_unavailable';endif
endfor
endfor
endfor
for name={'fields','fluxes','budgets','operator','forcing','summary','convergence'}
key=name{1};if !all(isfinite(R.(key)(:))),error('Gate2:Finite','Nonfinite output in %s',key);endif
endfor
R.passed=all([R.checks.pass]);
R.convergence_rows_assessed=sum(R.convergence(:,8));R.convergence_rows_total=size(R.convergence,1);
R.convergence_verified=R.passed&&R.convergence_rows_assessed==R.convergence_rows_total;
R.validation_status='FAIL';
if R.passed&&R.convergence_verified,R.validation_status='PASS_MANUFACTURED_BENCHMARK_ONLY';
elseif R.passed,R.validation_status='PARTIAL_ERROR_FLOOR';endif
endfunction
function e=norms(delta,h,L,cref)
e=[max(abs(delta))/cref,sqrt(sum(h*delta.^2)/L)/cref];
endfunction
function C=check(C,name,actual,limit,unit,comparison)
% Store scalar facts densely; sparse FV reductions are not binary wire arrays.
if !isnumeric(actual)||!isscalar(actual)||!isreal(actual)||!isnumeric(limit)||!isscalar(limit)||!isreal(limit)
error('Gate2:CheckShape','Checks require real numeric scalar actual/limit');
endif
actual=full(actual);limit=full(limit);
finite=isfinite(actual)&&isfinite(limit);
if strcmp(comparison,'le'),passed=finite&&actual<=limit;else passed=finite&&actual>=limit;endif
C(end+1)=struct('name',name,'actual',actual,'limit',limit,'unit',unit,'comparison',comparison,'pass',logical(passed));
endfunction
elec_gate2_neutral_diffusion_corrected__gate2_publish–2a78f4d63a09ccaf.m — Direct named helper referenced by entrypoint
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261117T214559Z-1706497-1794951959732939 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 2a78f4d63a09ccafada6a6feb07acaa79ac7861d04ecb53137a5048847963405
function receipts=gate2_publish(ctx,p,R)
% Unexecuted current-context public publisher; commits are independent.
if isempty(regexp(p.output_prefix,'^[A-Za-z][A-Za-z0-9_.-]{0,100}$','once')),error('Gate2:ID','New simple prefix required');endif
definition=struct('contract','table.generic','storage','auto','replace_owned',false, ...
'producer_version','1.0.2','source_dataset_ids',{{p.source_dataset_id}}, ...
'source','Gate2 manufactured neutral diffusion', ...
'provenance',['Registered run ' ctx.run_id '; source ' ctx.script_sha256 '; spec ' p.specification_sha256], ...
'notes','Manufactured neutral tracer mathematics only; HAL source is context, not provenance for L/D/c_ref. No physical beaker/RPM/assay validation. Analytical continuum, analytical semidiscrete, analytical fully discrete modal references and actual BE fields remain separately labelled. Same primary ELEC-01.');
definition.notes=[definition.notes ' Validation coverage: ' R.validation_status '. Unavailable convergence order is NOT VERIFIED.'];
receipts={};
names=fieldnames(p);values=cell(numel(names),1);statuses=cell(numel(names),1);units=cell(numel(names),1);
for k=1:numel(names)
key=names{k};values{k}=jsonencode(p.(key));units{k}='1';statuses{k}='execution_or_source_label';
if any(strcmp(key,{'length_m','diffusivity_m2_s','concentration_mol_m3','epsilon'})),statuses{k}='manufactured_not_measured';endif
switch key
case 'length_m',units{k}='m';case 'diffusivity_m2_s',units{k}='m^2/s';case 'concentration_mol_m3',units{k}='mol/m^3';
endswitch
endfor
columns=struct('parameter',{names},'literal',{values},'unit_label',{units},'status',{statuses});
receipts{end+1}=table_publish([p.output_prefix '.inputs'],columns,struct(),definition);log_receipt(receipts{end});
labels=cell(numel(R.plan),1);kinds=labels;Ns=[];steps=[];
for k=1:numel(R.plan),labels{k}=R.plan{k}.label;kinds{k}=R.plan{k}.kind;Ns(k,1)=R.plan{k}.N;steps(k,1)=R.plan{k}.steps;endfor
columns=struct('run_index',(1:numel(R.plan))','label',{labels},'case_kind',{kinds},'cells',Ns,'BE_steps',steps);
receipts{end+1}=table_publish([p.output_prefix '.plan'],columns,struct(),definition);log_receipt(receipts{end});
descriptions={ ...
'fields',{'run_index','step','time_s','cell','x_m','actual_BE','analytical_continuum_cell_average','analytical_semidiscrete','analytical_fully_discrete_mode','actual_minus_continuum','actual_minus_semidiscrete','actual_minus_discrete_mode','tiny_negative_flag'}, ...
{'1','1','s','1','m','mol/m^3','mol/m^3','mol/m^3','mol/m^3','mol/m^3','mol/m^3','mol/m^3','1'}; ...
'fluxes',{'run_index','step','time_s','face','x_m','actual_newtime_flux'}, ...
{'1','1','s','1','m','mol/m^2/s'}; ...
'budgets',{'run_index','step','time_s','dt_s','actual_inventory_per_area','initial_inventory_per_area','cumulative_actual_boundary_transfer','budget_residual','left_flux','right_flux','analytical_continuum_inventory','analytical_continuum_transfer','actual_min_concentration','actual_continuum_Linf','actual_continuum_L2','actual_semidiscrete_Linf','actual_semidiscrete_L2','actual_discrete_Linf','actual_discrete_L2','semidiscrete_continuum_Linf','semidiscrete_continuum_L2'}, ...
{'1','1','s','s','mol/m^2','mol/m^2','mol/m^2','mol/m^2','mol/m^2/s','mol/m^2/s','mol/m^2','mol/m^2','mol/m^3','1','1','1','1','1','1','1','1'}; ...
'operator',{'run_index','row','column','actual_coefficient'}, {'1','1','1','1/s'}; ...
'forcing',{'run_index','cell','x_m','actual_forcing','exact_steady_cell_average','dimensionless_mode'}, {'1','1','m','mol/m^3/s','mol/m^3','1'}; ...
'summary',{'run_index','cells','BE_steps','h_m','dt_s','final_time_s','lambda_h','actual_continuum_Linf','actual_continuum_L2','actual_semidiscrete_Linf','actual_semidiscrete_L2','actual_discrete_Linf','actual_discrete_L2','semidiscrete_continuum_Linf','semidiscrete_continuum_L2'}, ...
{'1','1','1','m','s','s','1/s','1','1','1','1','1','1','1','1'}; ...
'convergence',{'study_index','norm_index','coarse_run','fine_run','coarse_error','fine_error','order_value','order_available','error_floor','order_lower','order_upper'}, repmat({'1'},1,11)};
for d=1:size(descriptions,1)
key=descriptions{d,1};headers=descriptions{d,2};declared_units=descriptions{d,3};matrix=R.(key);
if size(matrix,2)!=numel(headers)||numel(headers)!=numel(declared_units),error('Gate2:Shape','Header mismatch %s',key);endif
columns=struct();unitmap=struct();
for k=1:numel(headers),columns.(headers{k})=matrix(:,k);unitmap.(headers{k})=declared_units{k};endfor
if strcmp(key,'convergence')
columns.order_status=R.convergence_labels;columns.study_name=R.convergence_studies;columns.norm_name=R.convergence_norms;
endif
receipts{end+1}=table_publish([p.output_prefix '.' key],columns,unitmap,definition);log_receipt(receipts{end});
endfor
C=R.checks;columns=struct('check_name',{{C.name}'},'actual',[C.actual]','limit',[C.limit]', ...
'unit_label',{{C.unit}'},'comparison',{{C.comparison}'},'passed',double([C.pass]'));
receipts{end+1}=table_publish([p.output_prefix '.checks'],columns,struct(),definition);log_receipt(receipts{end});
endfunction
function result=table_publish(id,columns,unitmap,definition)
keys=fieldnames(columns);count=numel(columns.(keys{1}));definition.dataset_id=id;
writer=gxtxt_api_call('DATASET_PUBLICATION_API_v2','begin',{definition});
try
gxtxt_api_call('DATASET_PUBLICATION_API_v2','declare_dimension',{writer,'row',count,struct('extendible',false)});
for k=1:numel(keys)
key=keys{k};value=columns.(key);
% Serialization boundary only: preserve values/shape, no sparse fwrite.
if isnumeric(value)||islogical(value),value=full(value);endif
if numel(value)!=count,error('Gate2:Shape','Column mismatch');endif
unit='1';if isfield(unitmap,key),unit=unitmap.(key);endif
if iscell(value),dtype='string';kind='text';else dtype='float64';kind='number';endif
schema=struct('dtype',dtype,'value_kind',kind,'rank',1,'dimension_ids',{{'row'}},'name',key,'unit',unit,'coordinate_role','data','axis_kind','explicit');
gxtxt_api_call('DATASET_PUBLICATION_API_v2','declare_variable',{writer,key,schema});
gxtxt_api_call('DATASET_PUBLICATION_API_v2','write_variable',{writer,key,value,count});
endfor
result=gxtxt_api_call('DATASET_PUBLICATION_API_v2','finalize',{writer});
catch err
try gxtxt_api_call('DATASET_PUBLICATION_API_v2','abort',{writer});catch,end_try_catch
rethrow(err);
end_try_catch
endfunction
function log_receipt(receipt)
fprintf('CANONICAL_RECEIPT %s\n',jsonencode(receipt));
endfunction
elec_gate2_neutral_diffusion_corrected__gate2_run–3d172540cb53b587.m — Actual invoked project entrypoint
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261117T214559Z-1706497-1794951959732939 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 3d172540cb53b58722694f2414adb82989061142ddba6a17c14cb40a512ed36b
% Gate2 source1.0.2; UNEXECUTED, existing primary ELEC-01 only.
gxtxt_api_require('DATASET_PUBLICATION_API_v2@2');
gxtxt_api_require('DATASET_FILE_PUBLICATION_API_v1@1');
gxtxt_api_require('UNIT_REGISTRY_API_v1@1');
gxtxt_parameter_declare('length_m','double','default',0.0001,'min',0,'description','Manufactured slab L, not identified beaker film thickness');
gxtxt_parameter_declare('diffusivity_m2_s','double','default',0.000000001,'min',0,'description','Manufactured neutral tracer D, not sourced electrolyte diffusivity');
gxtxt_parameter_declare('concentration_mol_m3','double','default',1,'min',0,'description','Manufactured neutral tracer reference concentration');
gxtxt_parameter_declare('epsilon','double','default',0.25,'min',0,'max',1,'description','Manufactured closed-mode relative amplitude; strict0<epsilon<1');
gxtxt_parameter_declare('output_prefix','string','default','elec_gate2_v1_02','description','Choose NEW create-only canonical output prefix');
gxtxt_parameter_declare('source_dataset_id','string','default','ref-001_atrashkevich_2025_hal_accepted','description','Actual context PDF binding, not source for manufactured parameters');
gxtxt_parameter_declare('specification_sha256','string','default','aa6b2f4b0a3ffde78db2ccaba9da97f98b369aa474cabfdb030be4770649b1f3','description','Reviewed spec02 hash; reference-category and fixed-schedule contract');
ctx=gxtxt_context();p=ctx.parameters;
if !isfield(ctx,'output_dir')||!isfield(ctx,'run_id')||!isfield(ctx,'script_sha256'),error('Gate2:Context','Registered native context required');endif
try
bound={};todo={ctx.inputs};
while !isempty(todo)
value=todo{end};todo(end)=[];
if isstruct(value)
for j=1:numel(value)
if isfield(value(j),'dataset_id')&&ischar(value(j).dataset_id),bound{end+1}=value(j).dataset_id;endif
keys=fieldnames(value(j));for k=1:numel(keys),child=value(j).(keys{k});if isstruct(child)||iscell(child),todo{end+1}=child;endif;endfor
endfor
elseif iscell(value),todo=[todo,value(:)'];endif
endwhile
if !any(strcmp(bound,p.source_dataset_id)),error('Gate2:Binding','Bind actual context PDF as Runner input');endif
converted=gxtxt_api_call('UNIT_REGISTRY_API_v1','convert',{1,'mm','m'});
if !isscalar(converted)||!isfinite(converted)||abs(converted-0.001)>1e-13,error('Gate2:Unit','Native unit conversion failed');endif
R=gate2_evaluate(p);
report=struct('schema','elec.neutral_diffusion.gate2.v1','source_version','1.0.2', ...
'run_id',ctx.run_id,'project_sha256',ctx.script_sha256,'module_id',ctx.module_id,'parameters',p,'input_bindings',ctx.inputs, ...
'runtime',struct('octave_version',version(),'architecture',computer(),'OMP_NUM_THREADS',getenv('OMP_NUM_THREADS'),'OPENBLAS_NUM_THREADS',getenv('OPENBLAS_NUM_THREADS')), ...
'expected_experiment_id','experiment-20261117T171059Z-846242-1794935459579080-1', ...
'scope','Manufactured neutral transport only; analytic references distinct from actual native BE solve; no physical beaker/RPM/assay validation', ...
'plan',{R.plan},'checks',R.checks,'required_checks_passed',R.passed, ...
'arithmetic_checks_passed',R.arithmetic_checks_passed,'convergence_rows_assessed',R.convergence_rows_assessed, ...
'convergence_rows_total',R.convergence_rows_total,'convergence_verified',R.convergence_verified, ...
'validation_status',R.validation_status,'final_time_s',R.final_time_s);
path=fullfile(ctx.output_dir,'gate2_report.json');fid=fopen(path,'w');if fid<0,error('Gate2:Output','Cannot write owned report');endif
unwind_protect
fprintf(fid,'%s\n',jsonencode(report));
unwind_protect_cleanup
fclose(fid);
end_unwind_protect
if !R.passed,error('Gate2:Checks','Required check failed; owned report retained, no PASS publication');endif
receipts=gate2_publish(ctx,p,R);
request=struct('dataset_id',[p.output_prefix '.report'],'contract','document.text','format','json','source_file',path,'storage_kind','text','media_type','application/json','producer_version','1.0.2','source_dataset_ids',{{p.source_dataset_id}},'source','Gate2 native registered Project','provenance',['Actual run ' ctx.run_id '; project SHA ' ctx.script_sha256],'notes','Manufactured neutral diffusion benchmark only. No physical validation.');
receipt=gxtxt_api_call('DATASET_FILE_PUBLICATION_API_v1','publish',{request});
fprintf('CANONICAL_RECEIPT %s\n',jsonencode(receipt));
path=fullfile(ctx.output_dir,'gate2_publication_receipts.json');fid=fopen(path,'w');if fid<0,error('Gate2:Output','Cannot write receipt ledger');endif
unwind_protect
fprintf(fid,'%s\n',jsonencode(struct('tables',{receipts},'report',receipt)));
unwind_protect_cleanup
fclose(fid);
end_unwind_protect
catch err
failure=struct('schema','elec.gate2.failure.v1','run_id',ctx.run_id,'project_sha256',ctx.script_sha256,'parameters',p,'identifier',err.identifier,'message',err.message,'stack',err.stack);
fid=fopen(fullfile(ctx.output_dir,'gate2_failure.json'),'w');
if fid>=0
unwind_protect
fprintf(fid,'%s\n',jsonencode(failure));
unwind_protect_cleanup
fclose(fid);
end_unwind_protect
endif
rethrow(err);
end_try_catch
elec_gate1_bookkeeping__gate1_evaluate–e04e8acc9e8ea480.m — Direct named helper referenced by entrypoint
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261117T203042Z-1446901-1794947442736238 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 e04e8acc9e8ea48039e1e49d8e4ab8e244ba8c9621e1668e3fc2e30c8d62ef6b
function R = gate1_evaluate(p)
% Gate1 v1.0.2: reviewed analytic/manufactured bookkeeping, never assay physics.
positive = {'duration_s','volume_m3','area_m2','F_C_mol','M_N_g_mol','M_Cl2_g_mol'};
nonnegative = {'current_A','background_NaCl_mol_m3','initial_N_g_m3','stored_HOCl_mol'};
fractions = {'mixed_CER_fraction','mixed_CRR_fraction','mixed_N2_fraction','mixed_strip_fraction','stored_N2_fraction'};
for k=1:numel(positive)
must_scalar(p,positive{k}); if p.(positive{k})<=0,fail_guard(positive{k},p.(positive{k}),0,input_unit(positive{k}),'gt');endif
endfor
for k=1:numel(nonnegative)
must_scalar(p,nonnegative{k}); if p.(nonnegative{k})<0,fail_guard(nonnegative{k},p.(nonnegative{k}),0,input_unit(nonnegative{k}),'ge');endif
endfor
for k=1:numel(fractions)
must_scalar(p,fractions{k}); if p.(fractions{k})<0||p.(fractions{k})>1,fail_guard(fractions{k},p.(fractions{k}),[0,1],'1','within');endif
endfor
R.species={'formal_NH3','neutral_HOCl','chloride','escaped_Cl2','stipulated_N2','signed_acid','water_reservoir_delta','O2_cumulative','H2_cumulative','electron_reservoir_delta','Na_spectator'};
R.reactions={'hydrolyzed_CER','OER','CRR','HER','formal_N2_endpoint','formal_Cl2_stripping'};
R.elements={'N','Cl','H','O','Na','formal_charge'};
% Columns follow species above; charge includes electron and fixed Na+.
B=[1 0 0 0 2 0 0 0 0 0 0;
0 1 1 2 0 0 0 0 0 0 0;
3 1 0 0 0 1 2 0 2 0 0;
0 1 0 0 0 0 1 2 0 0 0;
0 0 0 0 0 0 0 0 0 0 1;
0 0 -1 0 0 1 0 0 0 -1 1];
% Integer columns are six formal reactions, including water/electron reservoirs.
nu=[0 0 0 0 -2 0;
1 0 -1 0 -3 -1;
-1 0 1 0 3 -1;
0 0 0 0 0 1;
0 0 0 0 1 0;
1 4 -1 -2 3 -1;
-1 -2 1 0 3 1;
0 1 0 0 0 0;
0 0 0 1 0 0;
2 4 -2 -2 0 0;
0 0 0 0 0 0];
R.element_matrix=B; R.reaction_matrix=nu;
C=struct('name',{},'actual',{},'limit',{},'unit',{},'comparison',{},'pass',{});
C=add_check(C,'integer_element_charge_nullspace',max(abs((B*nu)(:))),0,'1','le');
F=p.F_C_mol; N0=p.initial_N_g_m3*p.volume_m3/p.M_N_g_mol;
Na0=p.background_NaCl_mol_m3*p.volume_m3;
L0=Na0+N0; A0=N0;
if !all(isfinite([N0,Na0,L0,A0])),fail_guard('derived_initial_amounts',[N0,Na0,L0,A0],'finite','mol','type');endif
% NH4Cl source formally translated to NH3 + H+ + Cl-.
R.initial=struct('N0_mol_atoms',N0,'Na0_mol',Na0,'background_Cl_mol',Na0,'L0_total_chloride_mol',L0,'A0_formal_acid_mol',A0);
% A/B/C are current-on manufactured extents; D/E explicitly override I=0.
S={struct('name','A_all_CER_HER','I',p.current_A,'B0',0,'fcer',1,'fcrr',0,'alpha',0,'beta',0,'stored',false),
struct('name','B_all_OER_HER','I',p.current_A,'B0',0,'fcer',0,'fcrr',0,'alpha',0,'beta',0,'stored',false),
struct('name','C_illustrative_mixed','I',p.current_A,'B0',0,'fcer',p.mixed_CER_fraction,'fcrr',p.mixed_CRR_fraction,'alpha',p.mixed_N2_fraction,'beta',p.mixed_strip_fraction,'stored',false),
struct('name','D_current_off_stored_HOCl','I',0,'B0',p.stored_HOCl_mol,'fcer',0,'fcrr',0,'alpha',p.stored_N2_fraction,'beta',0,'stored',true),
struct('name','E_current_off_no_oxidant','I',0,'B0',0,'fcer',0,'fcrr',0,'alpha',p.stored_N2_fraction,'beta',0,'stored',true)};
sampled=[0 .25 .5 .75 1]; rows=[]; names={};
headers={'scenario_index','fractional_time','time_s','current_A','Q_C','initial_HOCl_mol'};
headers=[headers,R.species,{'x_CER_mol','x_OER_mol','x_CRR_mol','x_HER_mol','x_N2_mol','x_strip_mol','Q_CER_C','Q_OER_C','Q_CRR_C','Q_HER_C','N_converted_atoms_mol','gross_Cl2eq_charge_ceiling_mol','N_charge_storage_ceiling_atoms_mol','geometric_current_density_A_m2','N_residual_mol','Cl_residual_mol','oxidant_residual_mol','acid_Cl_residual_mol','global_formal_charge_mol','formal_N_g_m3','gross_Cl2eq_charge_ceiling_g_m3','N_charge_storage_ceiling_g_m3','tiny_negative_stock_flag'}];
amount_atol=1e-14; charge_atol=1e-9; rtol=1e-10;
for i=1:numel(S)
a=S{i};
y0=[N0;a.B0;L0;0;0;A0;0;0;0;0;Na0];
for j=1:numel(sampled)
s=sampled(j); t=p.duration_s*s; Q=a.I*t;
xcer=a.fcer*Q/(2*F); xoer=(1-a.fcer)*Q/(4*F);
xcrr=a.fcrr*Q/(2*F); xher=(1-a.fcrr)*Q/(2*F);
if !all(isfinite([t,Q,xcer,xoer,xcrr,xher])),fail_guard('derived_schedule_nonfinite',[t,Q,xcer,xoer,xcrr,xher],'finite','mixed_s_A*s_mol','type');endif
tag=sprintf('%s_sample_%d_',a.name,j);
% Prospective sequential path checks, not a posteriori stock clipping.
if xcer>L0,fail_guard([tag 'CER_initial_chloride'],xcer,L0,'mol','le');endif
if xcrr>a.B0+xcer,fail_guard([tag 'CRR_available_HOCl'],xcrr,a.B0+xcer,'mol','le');endif
l_electrode=L0-xcer+xcrr;
if l_electrode<0,fail_guard([tag 'electrode_chloride'],l_electrode,0,'mol','ge');endif
available=a.B0+xcer-xcrr;
if available<0,fail_guard([tag 'available_oxidant'],available,0,'mol','ge');endif
fraction=a.alpha;if a.stored,fraction=s*a.alpha;endif
% Algebraic limiting-substrate residuals avoid subtracting equal floating
% products at alpha=1. This is not clipping a computed negative stock.
N_capacity=1.5*N0;
if available<=N_capacity
xn=fraction*available/3;
b_before_strip=(1-fraction)*available;
else
xn=fraction*N0/2;
b_before_strip=(available-N_capacity)+(1-fraction)*N_capacity;
endif
l_before_strip=l_electrode+3*xn;
if b_before_strip<0,fail_guard([tag 'post_N_oxidant'],b_before_strip,0,'mol','ge');endif
if l_before_strip<0,fail_guard([tag 'post_N_chloride'],l_before_strip,0,'mol','ge');endif
xs=a.beta*b_before_strip;
if xs>l_before_strip,fail_guard([tag 'stripping_chloride'],xs,l_before_strip,'mol','le');endif
extent=[xcer;xoer;xcrr;xher;xn;xs]; y=y0+nu*extent;
qcer=2*F*xcer; qoer=4*F*xoer; qcrr=2*F*xcrr; qher=2*F*xher;
Nres=y(1)+2*y(5)-N0; Clres=y(3)+y(2)+2*y(4)-(L0+a.B0);
Eres=y(2)+y(4)+3*y(5)+xcrr-(a.B0+xcer);
acidres=y(6)-y(3)-(A0-L0); z=y(6)-y(3)+y(11);
Nlimit=amount_atol+rtol*max([N0,2*xn,abs(y(1))]);
Cllimit=amount_atol+rtol*max([L0+a.B0,abs(y(3))+abs(y(2))+2*abs(y(4))]);
Elimit=amount_atol+rtol*max([a.B0+xcer,xcrr+3*xn+xs,abs(y(2))]);
acidlimit=amount_atol+rtol*max([abs(A0-L0),abs(y(6))+abs(y(3))]);
Nalimit=amount_atol+rtol*abs(Na0);
charge_limit=charge_atol+rtol*abs(Q);
C=add_check(C,[tag 'N_balance'],abs(Nres),Nlimit,'mol','le');
C=add_check(C,[tag 'Cl_balance'],abs(Clres),Cllimit,'mol','le');
C=add_check(C,[tag 'oxidant_source_minus_sink'],abs(Eres),Elimit,'mol','le');
C=add_check(C,[tag 'formal_acid_minus_Cl'],abs(acidres),acidlimit,'mol','le');
C=add_check(C,[tag 'fixed_Na_spectator'],abs(y(11)-Na0),Nalimit,'mol','le');
C=add_check(C,[tag 'global_formal_charge'],abs(z),acidlimit,'mol','le');
delta=nu*extent;
for element=1:size(B,1)
element_scale=sum(abs(B(element,:)).*(abs(y0)+abs(delta))');
C=add_check(C,[tag R.elements{element} '_reservoir_delta'],abs(B(element,:)*(y-y0)),amount_atol+rtol*element_scale,'mol','le');
endfor
C=add_check(C,[tag 'anode_current_integral'],abs(qcer+qoer-Q),charge_limit,'A*s','le');
C=add_check(C,[tag 'cathode_current_integral'],abs(qcrr+qher-Q),charge_limit,'A*s','le');
C=add_check(C,[tag 'net_electron_flow'],abs(y(10)),amount_atol+rtol*max([2*xcer+4*xoer,2*xcrr+2*xher]),'mol','le');
C=add_check(C,[tag 'nonnegative_nonreservoir_stocks'],min(y([1:5,8:9,11])), -amount_atol,'mol','ge');
converted=2*y(5); ceiling=2*a.B0/3+Q/(3*F);
C=add_check(C,[tag 'N_initial_substrate_ceiling'],converted-N0,Nlimit,'mol','le');
C=add_check(C,[tag 'N_charge_storage_ceiling'],converted-ceiling,amount_atol+rtol*max([converted,ceiling]),'mol','le');
if j==1
C=add_check(C,[tag 'initial_state_preserved'],max(abs(y-y0)),0,'mol','le');
endif
if i==1
C=add_check(C,[tag 'all_CER_gross_Cl2eq_ceiling'],abs(y(2)-Q/(2*F)),Elimit,'mol','le');
endif
if i==2
C=add_check(C,[tag 'zero_chlorine_production'],abs(y(2)+y(4)),0,'mol','le');
endif
if i==5
C=add_check(C,[tag 'no_oxidant_no_conversion'],abs(converted),0,'mol','le');
endif
if i==4&&j==numel(sampled)
C=add_check(C,[tag 'current_off_zero_charge'],abs(Q),0,'A*s','le');
% Strictly positive formal conversion is a counterexample, not a rate law.
C=add_check(C,[tag 'stored_oxidant_conversion_positive'],converted,0,'mol','gt');
endif
row=[i,s,t,a.I,Q,a.B0,y',extent',qcer,qoer,qcrr,qher,converted,Q/(2*F),ceiling,a.I/p.area_m2,Nres,Clres,Eres,acidres,z,y(1)*p.M_N_g_mol/p.volume_m3,(Q/(2*F))*p.M_Cl2_g_mol/p.volume_m3,ceiling*p.M_N_g_mol/p.volume_m3,double(any(y([1:5,8:9,11])<0))];
if !all(isfinite(row)),fail_guard([tag 'derived_output_row'],row,'finite','mixed_see_state_units','type');endif
if numel(row)!=numel(headers),error('Gate1:Shape','State column mismatch');endif
rows(end+1,:)=row; names{end+1,1}=a.name;
endfor
endfor
R.state_names=headers; R.state_values=rows; R.scenario_names=names; R.checks=C;
R.tolerances=struct('relative',rtol,'amount_atol_mol',amount_atol,'charge_atol_C',charge_atol);
R.passed=all([C.pass]);
endfunction
function must_scalar(p,name)
if !isfield(p,name)
fail_guard(name,'MISSING','finite_numeric_scalar',input_unit(name),'type');
endif
if !isnumeric(p.(name))||!isscalar(p.(name))||!isfinite(p.(name))
fail_guard(name,p.(name),'finite_numeric_scalar',input_unit(name),'type');
endif
endfunction
function C=add_check(C,name,actual,limit,unit,comparison)
switch comparison
case 'le', passed=isfinite(actual)&&isfinite(limit)&&actual<=limit;
case 'ge', passed=isfinite(actual)&&isfinite(limit)&&actual>=limit;
case 'gt', passed=isfinite(actual)&&isfinite(limit)&&actual>limit;
otherwise, error('Gate1:Check','Unknown comparison');
endswitch
C(end+1)=struct('name',name,'actual',actual,'limit',limit,'unit',unit,'comparison',comparison,'pass',logical(passed));
endfunction
function fail_guard(name,actual,bound,unit,relation)
diagnostic=struct('guard',name,'actual',actual,'bound',bound,'unit',unit,'required_relation',relation);
error('Gate1:Guard','GATE1_DIAGNOSTIC:%s',jsonencode(diagnostic));
endfunction
function unit=input_unit(name)
switch name
case 'current_A',unit='A';case 'duration_s',unit='s';
case 'volume_m3',unit='m^3';case 'area_m2',unit='m^2';
case 'F_C_mol',unit='A*s/mol';case {'M_N_g_mol','M_Cl2_g_mol'},unit='g/mol';
case 'background_NaCl_mol_m3',unit='mol/m^3';case 'initial_N_g_m3',unit='g/m^3';
case 'stored_HOCl_mol',unit='mol';otherwise,unit='1';
endswitch
endfunction
elec_gate1_bookkeeping__gate1_publish–a0e79d5c59456bc6.m — Direct named helper referenced by entrypoint
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261117T203042Z-1446901-1794947442736238 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 a0e79d5c59456bc6e43bd69ef5ae5ec782a3fd0a47d31fb23e27a0ad3541175d
function receipts = gate1_publish(ctx,p,R)
% Current-context public publication only. Tables commit independently.
prefix=p.output_prefix;
if isempty(regexp(prefix,'^[A-Za-z][A-Za-z0-9_.-]{0,100}$','once'))
error('Gate1:ID','Choose a simple new public output prefix');
endif
notes=['Analytical/manufactured Gate1 bookkeeping, not experimental or assay validation. ' ...
'Formal NH4Cl translation includes N0 additional Cl and A0 signed acid; fixed Na spectator. ' ...
'HOCl counts one Cl atom/one Cl2-equivalent; gas Cl2 counts two Cl atoms/one equivalent. ' ...
'O2/H2/escaped Cl2 are cumulative product/export ledgers. No physical pH. ' ...
'V5: existing primary ELEC-01 experiment-20261117T171059Z-846242-1794935459579080-1.'];
provenance=sprintf('Gate1 v1.0.2; registered run %s; source SHA %s; nominal inputs %s; declared paper SHA %s',ctx.run_id,ctx.script_sha256,p.source_dataset_id,p.declared_paper_sha256);
definition=struct('contract','table.generic','storage','auto','replace_owned',false, ...
'producer_version','1.0.2','source_dataset_ids',{{p.source_dataset_id}}, ...
'source','ELEC Gate1 registered Octave benchmark','provenance',provenance,'notes',notes);
receipts={};
% Input literals retain exact typed Registry values in the Job/preset; this table labels them.
keys=fieldnames(p); n=numel(keys); literals=cell(n,1); units=cell(n,1); status=cell(n,1);
nominal={'current_A','duration_s','volume_m3','area_m2','background_NaCl_mol_m3','initial_N_g_m3'};
reported=struct('current_A',0.12,'duration_s',3600,'volume_m3',0.0002,'area_m2',0.0006,'background_NaCl_mol_m3',84,'initial_N_g_m3',10);
reference=cell(n,1);
constants={'F_C_mol','M_N_g_mol','M_Cl2_g_mol'};
for k=1:n
key=keys{k};literals{k}=jsonencode(p.(key));units{k}='1';reference{k}='not_applicable';
if any(strcmp(key,nominal))
reference{k}=jsonencode(reported.(key));
if isequal(p.(key),reported.(key)),status{k}='source_reported_nominal';else status{k}='user_override_of_reported_nominal';endif
elseif any(strcmp(key,constants)),status{k}='declared_constant_convention';
elseif strncmp(key,'mixed_',6)||strncmp(key,'stored_',7),status{k}='illustrative';
else status{k}='execution_or_source_label';endif
switch key
case 'current_A',units{k}='A';case 'duration_s',units{k}='s';
case 'volume_m3',units{k}='m^3';case 'area_m2',units{k}='m^2';
case 'background_NaCl_mol_m3',units{k}='mol/m^3';
case 'initial_N_g_m3',units{k}='g/m^3';case 'stored_HOCl_mol',units{k}='mol';
case 'F_C_mol',units{k}='A*s/mol';case {'M_N_g_mol','M_Cl2_g_mol'},units{k}='g/mol';
endswitch
endfor
columns=struct('parameter',{keys},'value_literal',{literals},'unit_label',{units},'source_status',{status},'reported_reference_literal',{reference});
receipts{end+1}=publish_table([prefix '.inputs'],columns,struct(),definition);
fprintf('CANONICAL_RECEIPT %s\n',jsonencode(receipts{end}));
species={};reactions={};coefficient=[];elements=[];
for a=1:numel(R.reactions)
for b=1:numel(R.species)
species{end+1,1}=R.species{b};reactions{end+1,1}=R.reactions{a};
coefficient(end+1,1)=R.reaction_matrix(b,a);elements(end+1,:)=R.element_matrix(:,b)';
endfor
endfor
columns=struct('species',{species},'reaction',{reactions},'coefficient',coefficient);
for k=1:numel(R.elements),columns.(['per_species_' R.elements{k}])=elements(:,k);endfor
receipts{end+1}=publish_table([prefix '.stoichiometry'],columns,struct(),definition);
fprintf('CANONICAL_RECEIPT %s\n',jsonencode(receipts{end}));
columns=struct('scenario_name',{R.scenario_names});unitmap=struct();
for k=1:numel(R.state_names)
key=R.state_names{k};columns.(key)=R.state_values(:,k);
if any(strcmp(key,{'scenario_index','fractional_time','tiny_negative_stock_flag'})),unitmap.(key)='1';
elseif strcmp(key,'time_s'),unitmap.(key)='s';
elseif strcmp(key,'current_A'),unitmap.(key)='A';
elseif strcmp(key,'geometric_current_density_A_m2'),unitmap.(key)='A/m^2';
elseif !isempty(regexp(key,'_g_m3$','once')),unitmap.(key)='g/m^3';
elseif strcmp(key,'Q_C')||strncmp(key,'Q_',2),unitmap.(key)='A*s';
else unitmap.(key)='mol';endif
endfor
receipts{end+1}=publish_table([prefix '.states'],columns,unitmap,definition);
fprintf('CANONICAL_RECEIPT %s\n',jsonencode(receipts{end}));
C=R.checks;
columns=struct('check_name',{{C.name}'},'actual',[C.actual]','limit',[C.limit]', ...
'quantity_unit',{{C.unit}'},'comparison',{{C.comparison}'},'passed',double([C.pass]'));
% actual/limit have per-row quantities; explicit quantity_unit is authoritative.
receipts{end+1}=publish_table([prefix '.checks'],columns,struct(),definition);
fprintf('CANONICAL_RECEIPT %s\n',jsonencode(receipts{end}));
endfunction
function receipt=publish_table(id,columns,unitmap,definition)
keys=fieldnames(columns); n=numel(columns.(keys{1}));definition.dataset_id=id;
writer=gxtxt_api_call('DATASET_PUBLICATION_API_v2','begin',{definition});
try
gxtxt_api_call('DATASET_PUBLICATION_API_v2','declare_dimension',{writer,'row',n,struct('extendible',false)});
for k=1:numel(keys)
key=keys{k};value=columns.(key);
if numel(value)!=n,error('Gate1:Shape','Output column lengths differ');endif
unit='1';if isfield(unitmap,key),unit=unitmap.(key);endif
if iscell(value),dtype='string';kind='text';else dtype='float64';kind='number';endif
schema=struct('dtype',dtype,'value_kind',kind,'rank',1,'dimension_ids',{{'row'}}, ...
'name',key,'unit',unit,'coordinate_role','data','axis_kind','explicit');
gxtxt_api_call('DATASET_PUBLICATION_API_v2','declare_variable',{writer,key,schema});
gxtxt_api_call('DATASET_PUBLICATION_API_v2','write_variable',{writer,key,value,n});
endfor
receipt=gxtxt_api_call('DATASET_PUBLICATION_API_v2','finalize',{writer});
catch err
try gxtxt_api_call('DATASET_PUBLICATION_API_v2','abort',{writer});catch,end_try_catch
rethrow(err);
end_try_catch
endfunction
elec_gate1_bookkeeping__gate1_run–af6e44ddd88880e1.m — Actual invoked project entrypoint
EXECUTED_SOURCE_CHAIN_COMPLETED_NATIVE_USE · Exact retained registered-source revision
script-20261117T203042Z-1446901-1794947442736238 COMPLETED exit0
Sorgente congelato: commenti storici immutati; non ogni funzione contenuta è stata necessariamente chiamata.
Scarica il file originale · SHA256 af6e44ddd88880e1b8e9c1dfb14b251b18e9a0e96f928d907d940d70a70ae086
% Gate1 v1.0.2 — intended registered Octave Project entrypoint, NOT EXECUTED.
% V5: run only in existing primary ELEC-01 after independent implementation review.
gxtxt_api_require('DATASET_PUBLICATION_API_v2@2');
gxtxt_api_require('DATASET_FILE_PUBLICATION_API_v1@1');
gxtxt_api_require('UNIT_REGISTRY_API_v1@1');
gxtxt_parameter_declare('current_A','double','default',0.12,'min',0,'description','Reported nominal open-cell current A; not measured current history');
gxtxt_parameter_declare('duration_s','double','default',3600,'min',0,'description','Declared observation duration s; evaluator requires positive');
gxtxt_parameter_declare('volume_m3','double','default',0.0002,'min',0,'description','Reported nominal solution volume m^3');
gxtxt_parameter_declare('area_m2','double','default',0.0006,'min',0,'description','Projected geometric area only; not electrochemically active area');
gxtxt_parameter_declare('background_NaCl_mol_m3','double','default',84,'min',0,'description','Reported background NaCl concentration; NH4Cl adds N0 further chloride');
gxtxt_parameter_declare('initial_N_g_m3','double','default',10,'min',0,'description','Reported nominal nitrogen mass concentration g N/m^3; numeric mg N/L equivalent');
gxtxt_parameter_declare('F_C_mol','double','default',96485.33212,'min',0,'description','Declared rounded Faraday constant A*s/mol, not fitted');
gxtxt_parameter_declare('M_N_g_mol','double','default',14.0067,'min',0,'description','Declared nitrogen atomic molar-mass convention g/mol');
gxtxt_parameter_declare('M_Cl2_g_mol','double','default',70.906,'min',0,'description','Declared Cl2 molecular molar-mass convention g/mol');
gxtxt_parameter_declare('stored_HOCl_mol','double','default',0.00001,'min',0,'description','Illustrative neutral external HOCl initial store in current-off case, not NaOCl dose');
gxtxt_parameter_declare('mixed_CER_fraction','double','default',0.6,'min',0,'max',1,'description','Illustrative current fraction, not measured CER efficiency');
gxtxt_parameter_declare('mixed_CRR_fraction','double','default',0.25,'min',0,'max',1,'description','Illustrative cathodic current fraction; availability checked');
gxtxt_parameter_declare('mixed_N2_fraction','double','default',0.25,'min',0,'max',1,'description','Illustrative fraction of substrate-limited formal N2 extent');
gxtxt_parameter_declare('mixed_strip_fraction','double','default',0.1,'min',0,'max',1,'description','Illustrative fraction of post-N oxidant formally stripped');
gxtxt_parameter_declare('stored_N2_fraction','double','default',0.5,'min',0,'max',1,'description','Illustrative current-off schedule fraction; zero disables the required positive counterexample');
gxtxt_parameter_declare('output_prefix','string','default','elec_gate1_v1_01','description','Choose a NEW canonical output prefix; existing IDs never replaced');
gxtxt_parameter_declare('source_dataset_id','string','default','ref-001_atrashkevich_2025_hal_accepted','description','Actual same-Session authentic source PDF ID; bind as a Runner input too');
gxtxt_parameter_declare('declared_paper_sha256','string','default','29d3a64cd947d50967a4316623f3684d0fe099422df343d2df98fe0abd788260','description','Declared reviewed HAL PDF SHA; independent input/archive readback remains required');
gxtxt_parameter_declare('source_note_ref','string','default','Atrashkevich2025 DOI10.1016/j.watres.2025.123732 HAL physical PDF7 NH4Cl/background NaCl; nominal conditions only','description','Reviewed source locator; not automatic extraction');
ctx=gxtxt_context();p=ctx.parameters;
if !isfield(ctx,'output_dir')||!isfield(ctx,'run_id')||!isfield(ctx,'script_sha256')
error('Gate1:Context','A registered supervised GX-TXT Script context is required');
endif
try
% Public context input aliases are logical Dataset bindings, not storage paths.
bound={};todo={ctx.inputs};
while !isempty(todo)
value=todo{end};todo(end)=[];
if isstruct(value)
for j=1:numel(value)
if isfield(value(j),'dataset_id')&&ischar(value(j).dataset_id),bound{end+1}=value(j).dataset_id;endif
fields=fieldnames(value(j));
for k=1:numel(fields)
child=value(j).(fields{k});if isstruct(child)||iscell(child),todo{end+1}=child;endif
endfor
endfor
elseif iscell(value)
todo=[todo,value(:)'];
endif
endwhile
if !any(strcmp(bound,p.source_dataset_id))
error('Gate1:InputBinding','Bind the actual same-Session source PDF as a Runner input before execution');
endif
% The operator verifies the stable experiment ID in the normal Runner GUI.
% A parameter label is not an attestation of the active Session identity.
R=gate1_evaluate(p);
unit_cases={{1,'min','s',60},{1,'cm^3','m^3',0.000001},{1,'mg','g',0.001}};
for k=1:numel(unit_cases)
a=unit_cases{k};observed=gxtxt_api_call('UNIT_REGISTRY_API_v1','convert',{a{1},a{2},a{3}});
residual=abs(observed-a{4});limit=1e-14+1e-10*abs(a{4});
R.checks(end+1)=struct('name',['CORE_unit_conversion_' a{2} '_to_' a{3}], ...
'actual',residual,'limit',limit,'unit',a{3},'comparison','le','pass',logical(isfinite(residual)&&residual<=limit));
endfor
R.passed=all([R.checks.pass]);
report=struct('schema','elec.gate1.bookkeeping.v1','source_version','1.0.2', ...
'status','FAIL','run_id',ctx.run_id,'registered_script_sha256',ctx.script_sha256, ...
'module_id',ctx.module_id,'parameters',p,'input_bindings',ctx.inputs, ...
'runtime',struct('octave_version',version(),'architecture',computer(), ...
'OMP_NUM_THREADS',getenv('OMP_NUM_THREADS'),'OPENBLAS_NUM_THREADS',getenv('OPENBLAS_NUM_THREADS')), ...
'expected_experiment_id','experiment-20261117T171059Z-846242-1794935459579080-1', ...
'scope','Analytical/manufactured bookkeeping; no physical pH, assay, kinetic or mechanism validation', ...
'initial_composition',R.initial,'tolerances',R.tolerances,'checks',R.checks);
if R.passed,report.status='PASS_DECLARED_BOOKKEEPING_ONLY';endif
report_path=fullfile(ctx.output_dir,'gate1_report.json');
fid=fopen(report_path,'w');if fid<0,error('Gate1:Output','Cannot write owned report');endif
unwind_protect
fprintf(fid,'%s\n',jsonencode(report));
unwind_protect_cleanup
fclose(fid);
end_unwind_protect
fprintf('Gate1 checks: %d; passed: %d.\n',numel(R.checks),sum([R.checks.pass]));
if !R.passed,error('Gate1:Verification','Required check failed; owned diagnostic report retained, no PASS publication');endif
receipts=gate1_publish(ctx,p,R);
request=struct('dataset_id',[p.output_prefix '.report'],'contract','document.text','format','json', ...
'source_file',report_path,'storage_kind','text','media_type','application/json','producer_version','1.0.2', ...
'source_dataset_ids',{{p.source_dataset_id}},'source','ELEC Gate1 native registered Script', ...
'provenance',['Registered run ' ctx.run_id '; source SHA ' ctx.script_sha256], ...
'notes','Formal bookkeeping verification only; input statuses and limitations retained; no physical validation.');
report_receipt=gxtxt_api_call('DATASET_FILE_PUBLICATION_API_v1','publish',{request});
publication_path=fullfile(ctx.output_dir,'gate1_publication_receipts.json');
fid=fopen(publication_path,'w');if fid<0,error('Gate1:Output','Cannot write publication receipts');endif
unwind_protect
fprintf(fid,'%s\n',jsonencode(struct('tables',{receipts},'report',report_receipt)));
unwind_protect_cleanup
fclose(fid);
end_unwind_protect
fprintf('Gate1 native canonical publication completed; inspect original receipts.\n');
catch err
failure=struct('schema','elec.gate1.failure.v1','status','FAILED_BEFORE_OR_DURING_PUBLICATION', ...
'run_id',ctx.run_id,'source_sha256',ctx.script_sha256,'parameters',p, ...
'identifier',err.identifier,'message',err.message,'stack',err.stack);
token=regexp(err.message,'GATE1_DIAGNOSTIC:(\{.*\})','tokens','once');
if !isempty(token),failure.guard=jsondecode(token{1});endif
failure_path=fullfile(ctx.output_dir,'gate1_failure.json');
fid=fopen(failure_path,'w');
if fid>=0
unwind_protect
fprintf(fid,'%s\n',jsonencode(failure));
unwind_protect_cleanup
fclose(fid);
end_unwind_protect
else
fprintf(2,'Unable to retain owned failure report: %s\n',failure_path);
endif
rethrow(err);
end_try_catch
Come consultare e riprodurre senza confondere le versioni
I dati e i grafici di questa pagina hanno identità native e file di riferimento consultabili. Un Workspace è una configurazione modificabile con sorgenti e scelte; un Graph pubblicato è un risultato di presentazione. Salvataggio, riapertura e archivio Portable hanno ricevute proprie: un Job completato non prova da solo tutte queste tappe. Non si costruiscono nuove griglie comuni né si rietichetta il pH come tempo per semplificare l’importazione.
Le esecuzioni generiche documentate sono della versione privata 0.2.5. La 0.2.6 è installata, ma nessun uso scientifico della nuova forzante è qui dichiarato qualificato. Worksheet 2.1.8 è una versione privata successiva; Numeric 1.65.3 rimane una proposta non installata. I sorgenti e le correzioni private sono consegnati separatamente al proprietario per valutazione: non equivalgono a una release pubblica.
P013 è l’obiettivo di riproduzione assunto dal proprietario, da verificare a cura di MAIN; non è disponibile o verificata al riferimento di questa consegna. Non si propone di eseguire questi listati autonomamente e chiamare il risultato «nativo». La riproduzione su P013 dovrà usare la release effettiva verificata, gli stessi modelli/ingressi/unità e il normale percorso di ammissione e Job, confrontando gli output con i record qui conservati. Il progetto WordPress è soltanto documentazione offline pronta per un successivo atto editoriale del proprietario; non modifica il sito o la Session.
Chiusura nativa effettivamente verificata
L’esportazione Portable ufficiale finale è completata e verificata: 4533 file della Session, più il singolo header del pacchetto, con controllo CRC e appartenenza al manifest. L’archivio completo, che contiene anche PDF conservati privatamente, appartiene alla consegna scientifica privata e non al pacchetto pubblico WordPress. I grafici p0037 e p0038 sono pubblicati, salvati e riaperti in Workspace distinti con ricevute finali. Nessun grafico della nuova rete generica o delle frazioni è stato pubblicato: le rispettive produzioni canoniche restano consultabili come dati, senza una figura inventata. Il successo dell’archivio non trasforma i candidati non eseguiti in risultati.
Percorso pratico GX-TXT: dalla fonte al risultato
Cinque capitoli illustrati insegnano i percorsi principali realmente impiegati. Le definizioni specifiche, gli script e la mappa dei Job completano il percorso per i risultati consegnati; non è una nuova esecuzione né una promessa di riproduzione P013 già verificata.
- 1. Sessione, PDF e figura sorgente
- 2. Digitalizzazione: quattro pannelli, quattro calibrazioni
- 3. Fit, espressioni, fogli e sensibilità
- 4. Grafici, unità e Workspace modificabili
- 5. Rete di reazione, Job e riproduzione
Copertura delle procedure · 26 casi MAIN/P013 NOT_RUN · Consegna a MAIN.
Dataset
Risultati e acquisizioni su cui si basa questo articolo.
Scalare di corrente e contesto · Calibrazioni S2 e controlli a h comune · Rapporti al limite di corrente · Sei trasferimenti a parametri fissati · Deficit libero/totale · Nove componenti iniziali al pH · Rete operativa0rpm: nove output · Rete operativa100rpm: nove output · Due tracce pH acquisite · Frazione NH₃ ideale · Tre frazioni condizionali del cloro · Centri originali del saggio N · Cloro con N: acquisizione parziale · Controlli originali senza N
Dataset digitalizzati dalla figura 3 (CSV, ZIP) · Dataset nativi dei modelli e dei vincoli (CSV, ZIP)
Altre tappe del progetto
- ELEC 02 — Gerarchia dei modelli: descrizione efficace, trasferimento e identificabilità
- ELEC 03 — Dai fit ai vincoli: che cosa rivela il bilancio del cloro?
- ELEC 04 — Cinetica, speciazione e trasporto: dalla reazione alla risposta del reattore
- ELEC 05 — Perdita gassosa, clorammine e bilancio dei protoni
- ELEC 07 — Fonti, conclusioni e confronti discriminanti
- ELEC 01 — Che cosa misura l’esperimento? Azoto, cloro e pH