Octave Script Workspace: dalla pagina Analysis allo script registrato

La pagina Analysis di GX-TXT permette di accedere agli script scientifici salvati mediante il pannello opzionale Scripts (CORE). In questa guida prepariamo uno script GNU Octave, gli associamo un Dataset canonico attraverso un alias semantico e verifichiamo l’esecuzione effettiva senza usare la Script Library.

Le schermate si riferiscono a GX-TXT DEV112 con Octave Script Workspace 1.8.3. Il caso usa esclusivamente cinque valori sintetici, una Session dedicata e le API pubbliche disponibili in GX-TXT. È importante distinguere il pannello CORE per gli script registrati dal vecchio percorso di configurazione del modulo Analysis.

1. Mostrare Scripts (CORE) nella pagina Analysis

Aprire la Session scientifica in cui si desidera lavorare. Nella scheda Modules, cercare Optional CORE workspace surfaces e abilitare la casella Show Script Workspace. La stessa preferenza è denominata Show Script Workspace in Analysis in Configuration → Scripts.

Scheda Modules di GX-TXT con la sezione Optional CORE workspace surfaces e la casella Show Script Workspace.
Figura 1 — Il controllo Show Script Workspace rende disponibile il pannello Scripts (CORE) nella pagina Analysis.

Questa preferenza riguarda la presentazione dell’interfaccia; non è un comando Run e non cambia automaticamente la selezione dei moduli del calcolo. Dopo l’attivazione, la pagina Analysis ospita un pannello per selezionare e rivedere gli script registrati.

2. Preparare e salvare lo script nel Source

Aprire Octave Script Workspace, creare un nuovo file .m e salvarlo come script della Session. Nel caso di esempio, il sorgente dichiara un parametro gain, richiede l’API dei Dataset canonici e verifica che il contesto d’esecuzione contenga l’alias measured.

% Registered Octave Source, with synthetic input data.
gxtxt_parameter_declare('gain', 'double', 'default', 1.5, ...
                        'min', 0.1, 'max', 3.0, ...
                        'description', 'Synthetic input scale');

ctx = gxtxt_context();
gxtxt_api_require('CANONICAL_DATASET_API_v2');

if (!isfield(ctx.inputs, 'measured'))
  error('Expected reviewed semantic input alias measured is missing');
endif

bound_id = ctx.inputs.measured.dataset_id;
if (!strcmp(bound_id, 'o19_input_signal'))
  error('Unexpected canonical Dataset ID selected');
endif

fprintf('MEASURED_INPUT_DATASET=%s\n', bound_id);
fprintf('SOURCE_GAIN=%.2f\n', ctx.parameters.gain);
fprintf('WORKING_DIRECTORY=%s\n', pwd());
disp('Registered source integration completed');
Source editor Octave con lo script che legge gxtxt_context(), richiede CANONICAL_DATASET_API_v2 e controlla l’alias measured.
Figura 2 — Il Source Octave registrato mostra la lettura di gxtxt_context(), il requisito API e il controllo dell’alias.

L’ID o19_input_signal è un nome dimostrativo: in una Session reale va sostituito con quello del proprio Dataset. Nelle Script properties, impostare Additional required APIs a CANONICAL_DATASET_API_v2 e salvare con File → Save. Il registro conserva versione, revisione, SHA-256 e requisito API insieme al codice. Il salvataggio non esegue Octave.

3. Selezionare lo script nella pagina Analysis

Passare a Analysis e raggiungere Scripts (CORE). Il campo Registered script elenca gli script disponibili, compresi quelli salvati nella Session. Selezionare lo script desiderato e controllare che il riferimento inizi con session:.

Pagina Analysis di GX-TXT con il pannello Scripts (CORE), il riferimento registrato e i pulsanti Run registered script e Script Jobs.
Figura 3 — Nella pagina Analysis il pannello Scripts (CORE) mostra il riferimento registrato e i pulsanti Run registered script… e Script Jobs.

Il percorso operativo è Analysis → Scripts (CORE) → Run registered script…. Non è necessario aprire la Script Library. Uno script User deve essere disponibile al contesto di esecuzione previsto; il caso illustrato utilizza direttamente uno script registrato nella Session.

4. Aprire Script Runner e verificare la revisione

Premere Run registered script…. Compare il normale Script Runner con nome, linguaggio, riferimento registrato, versione, revisione e SHA-256 del sorgente salvato. La sezione Invocation parameters contiene gain con default 1.5.

Script Runner aperto da Analysis con identità dello script, revisione, SHA-256 e parametro gain con default 1.5.
Figura 4 — La finestra Runner aperta dalla pagina Analysis mostra l’identità dello script e il parametro tipizzato.

Aprire il Runner non invia un Job. La revisione e lo SHA-256 indicano quale sorgente sarà riesaminato. Se si modifica il codice nell’editor, è necessario salvare o scegliere esplicitamente quale revisione utilizzare prima di procedere.

5. Associare il Dataset con namespace e alias

Prima della prova è disponibile nella Session un Dataset canonico sintetico table.generic, con cinque campioni e le variabili time_s e response_V. Il Dataset è collocato nel namespace bench/measurements.

In Runner aprire Inputs and output, premere Add input Dataset, quindi scegliere:

CampoValore dell’esempio
Semantic aliasmeasured
Namespacebench/measurements
Dataset IDo19_input_signal
Display label (optional)Synthetic measured voltage
Riga di ingresso di Script Runner con alias measured, namespace bench/measurements, Dataset o19_input_signal e revision captured.
Figura 5 — L’ingresso measured seleziona il Dataset canonico nel proprio namespace e ne acquisisce la revisione.

La selezione genera l’indicazione revision captured. Il nome measured identifica il collegamento nel contesto dello script, mentre il Dataset ID rimane l’identità canonica dei dati. Non si sposta il Dataset quando si sceglie un namespace nella riga del Runner, e non viene cambiato il namespace corrente della Session.

6. Comprendere come lo script riceve i dati e i parametri

Durante il Job, gxtxt_context() restituisce il contesto della specifica invocazione. Lo script può quindi leggere ctx.inputs.measured.dataset_id e ctx.parameters.gain: questi valori provengono dalla preparazione controllata nel Runner, non da un percorso scritto nel file .m.

Il requisito CANONICAL_DATASET_API_v2 viene controllato prima dell’esecuzione. Si può anche chiamare gxtxt_api_require nel sorgente, come nell’esempio. La directory di lavoro predefinita del Job registrato corrisponde alla Session scientifica, mentre il percorso del sorgente registrato non viene aggiunto automaticamente al path di Octave.

Le API e le rispettive operazioni vanno verificate nelle documentazioni pubbliche GX-TXT installate: un nome di API richiesto non equivale alla disponibilità di qualsiasi operazione immaginabile.

7. Eseguire Validate review prima del Job

Con gain = 1.5 e l’ingresso measured selezionato, premere Validate review. Il Runner controlla identità del sorgente, tipi dei parametri, alias, namespace, Dataset ID e revisione dell’ingresso.

Script Runner con gain 1.5, ingresso measured e il messaggio Review valid. No Job submitted.
Figura 6 — Validate review conferma che la configurazione è pronta, senza avviare Octave.

Il messaggio Review valid. No Job submitted non indica che lo script abbia già lavorato sui dati. È la preparazione necessaria prima della richiesta di esecuzione.

8. Avviare una sola volta il Job Octave

Premere Run Job. Durante l’ammissione la GUI presenta Submitting immutable Script and input snapshots… e disabilita temporaneamente i controlli pertinenti.

Script Runner durante l’invio con il messaggio Submitting immutable Script and input snapshots.
Figura 7 — Il Runner sta inviando uno snapshot immutabile dello script e del Dataset selezionato.

La richiesta registra lo SHA-256 del sorgente, la revisione, il valore di gain e l’identità/revisione del Dataset associato ad measured. Questa fase non è ancora una conferma di completamento; l’esito va letto nel supervisore dei Job.

9. Controllare Script Jobs e il rapporto di esecuzione

Dalla pagina Analysis → Scripts (CORE) utilizzare Script Jobs…, oppure aprire la stessa finestra dopo l’invio. La tabella riporta il Job con nome dello script, linguaggio, versione, revisione e stato terminale.

Finestra Script Jobs con il Job GNU Octave dello script registrato nello stato COMPLETED.
Figura 8 — Script Jobs mostra l’esecuzione GNU Octave effettivamente completata.

Aprendo i dettagli del Job, Program output conferma, per esempio, MEASURED_INPUT_DATASET=o19_input_signal e SOURCE_GAIN=1.50. Il file executed_script.m, conservato dal Job, contiene esattamente il sorgente ammesso all’esecuzione; il rapporto octave_script_run_report.txt registra Status: PASS, GNU Octave 9.4.0, l’API richiesta, Source mode: registered_script e la directory di lavoro effettiva.

Il supervisore distingue gli Script Jobs dell’utente dai Job automatici del CORE, per esempio quelli necessari alla preparazione di una Dataset Preview. Nella prova, il Job Octave risulta COMPLETED e il Dataset d’ingresso resta invariato. Questo script non crea alcun nuovo Dataset di uscita: stampa e verifica le informazioni d’ingresso. La pubblicazione di risultati scientifici attraverso API appartiene a un passo diverso.

10. Distinguere il percorso registrato dalla modalità external_file

Il modulo installato analysis.octave_script definisce anche due modalità di origine del sorgente, ma non entrambe sono selezionabili nel pannello Scripts (CORE) mostrato qui.

AspettoComportamento
Script registrato (registered_script)È il percorso disponibile in Scripts (CORE), con revisione e SHA del registro e Job supervisionato
File esterno (external_file)È previsto dal contratto del modulo e dal runtime, ma non compare come selettore di file nel pannello Scripts (CORE) illustrato
Working directoryPer lo script registrato si utilizza la Session come default; la configurazione di una directory personalizzata appartiene al contratto del modulo, non ai campi di questo pannello
Include script directoryL’opzione riguarda la modalità esterna; nella prova dello script registrato la directory del codice non viene aggiunta al path Octave

Il modulo Analysis Octave può risultare CORE / OFF come modulo tradizionale e non mostrare una propria scheda configurabile: ciò non impedisce il percorso Analysis → Scripts (CORE) quando l’interfaccia opzionale è abilitata. Non è opportuno inventare una procedura GUI per external_file se non esiste un selettore visibile nella propria installazione.

Percorso da ricordare: salvare il codice nel Source, attivare Show Script Workspace, selezionare lo script in Analysis → Scripts (CORE), aprire Run registered script…, associare gli ingressi, effettuare Validate review, inviare Run Job e controllare l’esito in Script Jobs e nel rapporto scientifico.