Supervisore e linguaggio di comando

U1.03.01
Indice
Riassunto 3

1 Introduzione 4

2 Meccanismo generale di funzionamento del supervisore 5

2.1 Architettura generale . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Esecuzione globale passo-passo . . . . . . . . . . . . . . . . . . 6
2.3 Costruzione delle tappe . . . . . . . . . . . . . . . . . . . . . . 8
2.4 Elaborazione di macro-comandi . . . . . . . . . . . . . . . . . 8
2.5 Procedure di avvio . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6 Collegamenti con EFICAS . . . . . . . . . . . . . . . . . . . . 10

3 Linguaggio di comando 11
3.1 Python e il linguaggio di comando . . . . . . . . . . . . . . . . 11
3.2 Nozioni di concetto . . . . . . . . . . . . . . . . . . . . . . . . 12
3.3 Operazioni possibili . . . . . . . . . . . . . . . . . . . . . . . . 13
3.4 Regole sul concetto prodotto da un operatore . . . . . . . . . 14
3.4.1 Principi di base . . . . . . . . . . . . . . . . . . . . . . 14
3.4.2 Concetto prodotto e concetto riutilizzato . . . . . . . . 14
3.4.3 Verifiche eseguite dal supervisore sui concetti prodotti . 14
3.5 Corpo di un comando . . . . . . . . . . . . . . . . . . . . . . . 16
3.5.1 Introduzione . . . . . . . . . . . . . . . . . . . . . . . . 16
3.5.2 Parola-chiave . . . . . . . . . . . . . . . . . . . . . . . 16
3.5.3 Parola-chiave semplice . . . . . . . . . . . . . . . . . . 17
3.5.3.1 Tipi di argomento . . . . . . . . . . . . . . . 17
3.5.3.2 Nozione di lista . . . . . . . . . . . . . . . . . 18
3.5.4 Parola-chiave-fattore . . . . . . . . . . . . . . . . . . . 19
3.5.4.1 Nozione del valore di default . . . . . . . . . . 20

4 Definizione valori e valutazioni espressioni 21

5 Utilizzo di Python nel file di comando 22

5.1 Macro-comandi persaonalizzati . . . . . . . . . . . . . . . . . 22
5.2 Istruzioni generali di Python e comandi utili . . . . . . . . . . 22
5.3 Eccezioni di Python del modulo Aster . . . . . . . . . . . . . . 23
5.3.1 Intercettazione di errori <S> . . . . . . . . . . . . . . . 23
5.3.2 Intercettazione di errori fatali <F> . . . . . . . . . . . 24
5.3.3 Validità dei concetti in caso di eccezione . . . . . . . . 25
5.3.4 Precauzioni d’uso delle eccezioni . . . . . . . . . . . . . 25
5.4 Recupero dei valori calcolati nelle variabili Python . . . . . . . 26

1
5.5 Esempio di costruzione dinamica delle parole-chiavi-fattore . . 27

2
Riassunto
Questo documento descrive il ruolo e il funzionamento di due elementi
fondamentali:

• Il supervisore: Gestisce l’esecuzione di un calcolo Code-Aster

• Il linguaggio di comando: Permette la comunicazione utente/codice

3
1 Introduzione
Il ruolo del supervisore è quello di fornire il comando del flusso di lavoro in
esecuzione di un programma. Le istruzioni di esecuzione sono generalmente
fornite dall’utente. Ciò richiede una formalizzazione delle comunicazioni tra
il codice e il suo operatore, è il linguaggio di comando.

Il linguaggio Python viene utilizzato per scrivere: il catalogo dei comandi,

il supervisore e i file di comando dell’utente. Per i file di comando, questo
libera il supervisore dall’attività di analisi sintattica assegnata a Python stesso.

Un file di comando è una successione di chiamate a funzioni Python,

definite nel catalogo dei comandi. Queste funzioni hanno argomenti di input
(parole chiave e il loro contenuto) e argomenti di output (concetti prodotti).
L’utente che compone il suo file di comando deve quindi sottoporsi alle regole
generali della sintassi di Python (parentesi, rientro, . . . ) e alle regole imposte
dal catalogo dei comandi (gli argomenti forniti devono essere coerenti con ciò
che la funzione richiede).

In un primo contatto con il codice, il lettore potrebbe non essere in grado

di comprendere il Capitolo 2.

4
2 Meccanismo generale di funzionamento del
supervisore
2.1 Architettura generale
Gli elementi di base coinvolti nell’esecuzione di un calcolo Aster sono:

• Il file di comando, fornito dall’utente

• Il catalogo dei comandi, rappresentato da un modulo Python di nome

cata inserito nel pacchetto Cata

• L’oggetto di alto livello SUPERVISEUR

• L’oggetto JDC creato da quest’ultimo e che viene infine eseguito

L’oggetto SUPERVISEUR è un oggetto Python che analizza le opzioni passate

sulla riga di comando, importa il catalogo dei comandi, crea l’oggetto JDC
dal file di comando ed esegue.

L’oggetto JDC (abbreviativo di Jeu De Commandes) è un oggetto Python

creato dall’oggetto SUPERVISEUR dal testo del file di comando e dal modulo
catalogo comandi. Contiene gli oggetti ETAPE (tappa). L’oggetto JDC è
rappresentativo del file dei comandi utente.

Gli oggetti ETAPE sono rappresentativi di ciascuna delle chiamate ai

comandi Aster nel file dei comandi. Ogni oggetto ETAPE prende il nome dal
comando a cui fa riferimento, l’elenco delle parole chiave attive e i loro valori,
il tipo e il nome del concetto di prodotto.

La costruzione e quindi l’esecuzione dell’oggetto JDC innesca le seguenti

azioni:

• Analisi del file di comando utente: è qui che viene controllata la sintassi
di Python (parentesi, virgole tra parole chiave, rientro, . . . ). Il rileva-
mento di un errore (SyntaxError Python) provoca l’interruzione
dell’esecuzione di Aster. L’errore è di tipo <F>

• Costruzione del passo: consiste nella creazione di un oggetto ETAPE

per ogni chiamata a un comando Aster nel file di comando. Questo
oggetto è registrato con JDC che gestisce l’elenco di passaggi e concetti
correlati

5
 • Verifica di ogni ETAPE: se la chiamata a un comando nel file utente non
è coerente con il catalogo dei comandi, viene visualizzato un rapporto
e l’esecuzione viene interrotta a questo livello. Questa è una verifica
semantica

• Esecuzione effettiva dei comandi: per ogni passaggio effettuato nel-

l’ordine, chiamare la corrispondente routine Fortran di alto livello
(op0nnn.f)

2.2 Esecuzione globale passo-passo

Un set di comandi può essere costruito ed eseguito in due modalità:

• La modalità globale per la quale tutte le fasi del set di comandi vengono
prima costruite e quindi eseguite nel loro ordine di apparizione. Questa
modalità è scelta dalla parola chiave PAR_LOT = ’OUI’ nel comando
di avvio DEBUT

• La modalità passo-passo per cui ogni passo viene immediatamente

eseguito dopo la sua costruzione. Questa modalità è scelta dalla parola
chiave PAR_LOT = ’NON’ nel comando DEBUT

Se l’utente non specifica nulla nel comando di avvio, viene mantenuta la

modalità globale (PAR_LOT = ’OUI’). Queste due modalità hanno ciascuna
i loro vantaggi e svantaggi.

La modalità di esecuzione globale garantisce all’utente che l’intero file sia

semanticamente corretto prima di iniziare i calcoli che potrebbero non riuscire
o non convergere. Sarebbe un peccato fermarsi in un errore fatale dopo una
lunga risoluzione a causa di una parola chiave dimenticata in un ordine di
post-elaborazione. Significa anche che tutti i passaggi del set di comandi sono
creati e archiviati in memoria. Se si raggiungono diverse migliaia di passaggi,
può richiedere molta memoria e questa modalità non è più consigliata.

La modalità passo-passo crea solo un passo dopo aver eseguito quello

precedente. Rileva solo gli errori semantici del comando corrente e presenta
lo svantaggio sopra descritto. Tuttavia, consente di utilizzare un risultato
calcolato (in un concetto) nel file di comando per, ad esempio, inserire
istruzioni condizionali in esso. In questa modalità, il passaggio eseguito viene
immediatamente rilasciato dalla memoria. La memoria utilizzata è quindi
indipendente dal numero di passaggi da eseguire.

6
 Ecco un esempio di un ciclo con un criterio di arresto sul valore di una
quantità RELV[k] calcolata, memorizzato in un concetto di tipo table. Se
ad esempio manca una parola chiave obbligatoria nella chiamata al comando
POST_RELEVE_T, questa verrà rilevata solo dopo l’esecuzione completa del
primo MECA_STATIQUE. D’altra parte, la modalità graduale consente qui di
assegnare la variabile SYY poiché il concetto RELV[k] è stato completamente
calcolato nel momento in cui il supervisore esegue questa linea.
DEBUT(PAR_LOT=’NON’)

RESU = [None]*10
RELV = [None]*10

for k in range(1,10):
RESU[k] = MECA_STATIQUE( ... )
RELV[k] = POST_RELEVE_T( ... )
SYY = RELV[k][’VMIS’, 4]

if SYY < critere:

break

FIN()
Và fatto notare che la scelta di una modalità di esecuzione condiziona l’ordine
in cui avrà luogo l’analisi semantica (ETAPE by ETAPE o globalmente per
tutto il JDC). Ma in entrambi i casi, l’analisi sintattica di Python viene
sempre eseguita in anticipo per l’intero file di comando.

Note

EFICAS può solo generare e rileggere set di comandi che conten-

gono solo comandi Aster, senza altre istruzioni di Python. Questo
indipendentemente dalla modalità PAR_LOT selezionata.

7
2.3 Costruzione delle tappe
Quando si costruisce ciascun oggetto ETAPE, ne controlliamo la coerenza
semantica con il catalogo del comando a cui si riferisce. Qualsiasi errore
rilevato viene registrato in un report che, nella modalità di esecuzione globale,
viene consegnato dopo l’analisi dell’intero file di comando.

Esempi di verifica semantica:

• Rispetto del numero di argomenti delle parole chiave

• Rispetto del tipo di argomento

• Appartenenza di un argomento a un elenco di possibili valori

• Correttezza dell’ortografia di una parola chiave o fattore parola chiave

• Rispetto delle regole di esclusione o di implicazione tra parole chiave

• Presenza di parole chiave obbligatorie

A questo punto, se il comando è un operatore e produce un concetto, il

concetto viene digitato. Il supervisore verifica che un concetto con lo stesso
nome non sia già stato definito o, se viene riutilizzato, che il comando lo
autorizzi.

2.4 Elaborazione di macro-comandi

Un macro-comando è un comando normale dato all’utilizzatore. In realtà,
non chiama direttamente una routine Fortran di alto livello ma genera altri
comandi.

Esistono due tipi di macro-comandi:

• Macro in Python

• Macro del supervisore: sono i comandi speciali (DEBUT, FORMULE,

INCLUDE, INCLUDE_MATERIAU, POURSUITE) che richiedono un trat-
tamento a livello della loro costruzione.

Come lo stesso JDC, la chiamata a un macro-comando produce un oggetto

padre (di tipo MACRO-ETAPE) che contiene oggetti figlio: i passaggi generati
dalla macro o anche altre macro.

8
 Un macro-comando del JDC viene prima trattato come gli altri comandi
(controllo della sintassi, costruzione del passo della macro). Quindi viene
costruito applicando il metodo build di Python sull’oggetto JDC. Dopo
la sua costruzione, i passaggi dei comandi prodotti dalla macro vengono
sostituiti con il passaggio della macro stessa, per una successiva esecuzione.

È importante notare che la fase di costruzione dei macro-comandi avviene

appena prima della loro esecuzione e non durante il passaggio globale sul file
di comando in modalità PAR_LOT = ’OUI’. Ciò ha due conseguenze:

• EFICAS analizza la sintassi della macro stessa, ma non quella dei suoi
sottocomandi.

• D’altra parte, è possibile sfruttare, nella programmazione delle macro, i

dati precedentemente calcolati e rimpatriati nello spazio dei nomi Python,
senza dover imporre la modalità PAR_LOT = ’NON’ all’utente della
macro.

2.5 Procedure di avvio

Le procedure di avvio disponibili sono:

• DEBUT [U4.11.01]

• POURSUITE [U4.11.03]

Almeno una di queste due procedure deve essere presente nel file di comando.
Nessun altro comando Aster deve precederli. In questo caso o se non è presente
nessuno, l’esecuzione verrà interrotta non appena viene creato il JDC. Sono
queste procedure che contengono le informazioni sulla modalità di esecuzio-
ne (PAR_LOT = ’OUI’ oppure PAR_LOT = ’NON’) che condizionano la
modalità di esecuzione dei comandi che seguono.

Si tratta di un supervisore di macro comandi che, alla loro costruzione,

chiama le routine Fortran consentendo di inizializzare il calcolo con le seguenti
attività:

• Connessione delle unità logiche dei file standard

• Apertura dei database

• Lettura del catalogo degli elementi

9
Il primo compito è mettere in corrispondenza il numero di unità logiche dei
file di input/output standard (messaggio, errore, risultato).

La seconda attività consiste nel definire e aprire i database (file di accesso

diretto utilizzato dal gestore della memoria) conformemente alle istruzioni
dell’utente, che può ridefinire i parametri di questi file (vedere i documenti
[U4.11.01] e [U4.11.03] sulle procedure di avvio). Questa è chiamata routi-
ne di inizializzazione JEVEUX (vedi documento [D6.02.01] Gestione della
memoria, JEVEUX).

La sequenza di comandi da eseguire termina necessariamente con il coman-

do FIN. Il testo che segue FIN deve essere commentato (ovvero, iniziare con
#). Per un file incluso, è il comando RETOUR che segna la fine delle istruzioni
che Aster deve prendere in considerazione.

Nota

In modalità interattiva, inserendo manualmente gli ordini, non inse-

rire il comando FIN ma passare l’argomento -interact sulla riga
comandi di inoltro lavoro.

2.6 Collegamenti con EFICAS

Il kernel del supervisore è comune con EFICAS, l’editor di file di comando
Aster. Quando si modifica un file di comandi, esegue l’analisi sintattica e i
controlli di coerenza dei concetti costruendo il JDC e i suoi oggetti ETAPE.
Naturalmente, EFICAS non realizza il compito di creare i mecro-comandi che
richiederebbe il codice sorgente di Aster.

10
3 Linguaggio di comando
3.1 Python e il linguaggio di comando
Un file di comandi per Code-Aster è composto esclusivamente da istruzioni
Python. Il primo dei vincoli è quindi quello di rispettare le regole di questo
linguaggio. Possiamo leggere il tutorial di Python (www.python.org) op-
pure i numerosi libri introduttivi a Python per maggiori dettagli, ma non è
necessario per l’uso di Aster.

Un file di comando può contenere istruzioni Python di due nature:

• Comandi Aster

• Comandi Python

Infatti, un file di comando è un programma Python a sé stante e in particolare

possiamo posizionare strutture di controllo (loop), strutture di test (if), calcoli
numerici, chiamate a funzioni di pre e post-elaborazione, . . .

Nel contesto di un uso classico del codice in cui il file dei comandi contiene
esclusivamente comandi Aster, le due regole specifiche di Python da ricordare
sono:

• Nessun rientro sulla prima riga di istruzione di un’istruzione

mail = LIRE_MAILLAGE()

Non posizionare spazi bianchi o tabulazioni prima dell’argomento mail

• Gli argomenti di una funzione, ovvero le parole-chiavi del comando,

sono separati da virgole. Ciascuno di questi argomenti è cosituito da
una parola-chiave, il segno = esplicita il contenuto della parola-chiave
stessa.

11
 Importante

L’editor EFICAS produce solo file di comando di questo tipo: con-

tenenti esclusivamente comandi Aster, senza altre istruzioni Python.
L’uso di EFICAS garantisce sostanzialmente tre cose:

• Il file del prodotto avrà una sintassi Python corretta

• Gli ordini prodotti saranno coerenti con il catalogo degli ordini

• I concetti prodotti saranno correttamente concatenati (nessun

uso di un concetto senza che sia stato creato da un comando
precedente)

3.2 Nozioni di concetto

Definizione Le strutture dati Aster sono chiamate concetti, che l’uten-
te può manipolare e nominare. Questi concetti vengono tipizzati al momento
della loro creazione e possono essere utilizzati solo come argomento di input,
del tipo corrispondente, in un comando successivo.

La nozione di concetto consente quindi all’utente di manipolare oggetti

simbolicamente e indipendentemente dalla loro rappresentazione interna (che
potrebbe non conoscere). Inoltre, l’oggetto Python designato dal nome del
concetto non contiene altre informazioni oltre al suo tipo, solo la sua classe in
senso Python (vedi documentazione [D]). Il suo nome, trasmesso dal supervisore
al Fortran, consente ad Aster di trovare la struttura di dati corrispondente
nel database globale. Ma non è possibile avere visibilità della struttura dei
dati dal file di comando. Ad esempio, le seguenti istruzioni non consentono
di stampare la struttura dei dati di tipo mesh dell’oggetto mail:
mail = LIRE_MAILLAGE( ... )
print mail
ma genera il seguente messaggio:
<Cata.cata.maillage_sdaster object at 0x593cad0>
C’è un’eccezione a questa regola: le tabelle. In effetti, un dispositivo
di programmazione consente di recuperare semplicemente le informazioni
contenute in una struttura di dati TABLE manipolandole come una tabella a
due input:

12
 Azione Comando
Stampare un valore print resu[‘DX’ , 1]
Assegnare un valore value = resu[‘DX’ , 1]

Ciò presuppone, ovviamente, che la struttura dei dati di resu, di tipo

TABLE, sia già stata calcolata nel momento in cui si incontra questa istruzione:
quindi in modalità di esecuzione passo-passo (PAR_LOT = ’NON’).

Nota lessicale

I nomi dei concetti non devono superare gli 8 caratteri. I caratteri

alfanumerici sono legali (lettere minuscole e maiuscole e numeri non
in prima posizione) e anche l’underscore _ . Il caso è importante: i
concetti MAIL, Mail e mail possono essere usati nello stesso file di
comando e saranno considerati diversi (case sensitive) . . . Tuttavia,
non consigliabile per la leggibilità del file.

3.3 Operazioni possibili

La struttura del linguaggio di comando ha la forma di una sequenza lineare
di istruzioni. Oltre alle istruzioni Python diverse dai comandi Aster, che al
momento non sono discusse, sono disponibili tre tipi di istruzioni (o comandi):
• L’operatore che esegue un’azione e fornisce un concetto prodotto,
di tipo predefinito, che può essere utilizzato dalle seguenti istruzioni nel
set di comandi
• La procedura che esegue un’azione ma non fornisce nessun concetto
• Il macro-comando che genera una sequenza di istruzioni dei due tipi
precedenti e che può produrre uno o più concetti oppure nessun concetto
Tipicamente, un operatore sarà un comando di assegnazione o risoluzione,
una procedura sarà un comando di stampa (ad esempio su file). Dal punto di
vista sintattico un operatore è nella forma:
nome_concetto = operatore(argomenti)
mentre una procedura è nella forma:
procedura(argomenti)
La sintassi di un operatore o di una procedura è descritta nella sezione
seguente.

13
3.4 Regole sul concetto prodotto da un operatore
3.4.1 Principi di base
Ogni volta che un operatore viene eseguito fornisce un nuovo concetto
prodotto di tipo predefinito, stabilito a seconda del catalogo comandi. I
concetti che appaiono come argomenti di input ai comandi non vengono
modificati.

3.4.2 Concetto prodotto e concetto riutilizzato

Si chiama concetto riutilizzato un concetto prodotto da un operatore che
viene modificato da una nuova occorrenza di quell’operatore, oppure da un
altro operatore. L’uso di un concetto riutilizzato è possibile, in deroga al
principio di base, solo a due condizioni:

• Autorizzazione concessa, dal catalogo e dalla programmazione dell’or-

dine, all’utilizzo di concetti riutilizzabili per l’operatore: l’attributo
reentrant nel catalogo vale ’o’ o ’f’

• Esplicita richiesta dell’utente per il riutilizzo di un concetto prodotto dal-

l’attributo reuse = nome_concetto negli argomenti dei comandi
che lo consentono

3.4.3 Verifiche eseguite dal supervisore sui concetti prodotti

• Concetto prodotto rispettando il principio di base: il supervisore verifica
che il nome del concetto prodotto non sia già assegnato da ordini
precedenti, in particolare da un comando di un’esecuzione precedente
nel caso di un POURSUITE o di un INCLUDE.

• Concetto impiegato nel riutilizzo:

– Il nome del concetto di prodotto è già ben assegnato

– L’operatore è ben qualificato per accettare concetti riutilizzati
– Il tipo di concetto è coerente con il tipo di concetto prodotto
dall’operatore

Di seguito sono mostrati alcuni esempi applicativi dell’argomento, in essi sono

forniti i casi corretti ed incorretti:

14
DEBUT()

concetto = operatore() # (1)

concetto = operatore() # (2)
concetto = operatore(reuse = concetto) # (3)

FIN()
In rispetto alle note commentate della porzione di codice si ha:

1. Corretto: viene definito il concetto

2. Incorretto: si cerca di ridefinire il concetto

3. Corretto se l’operatore accetta concetti esistenti e se il tipo è coerente.

Incorretto se l’operatore non li accetta.

In effetti un concetto può essere creato solo una volta: il che significa che
appare alla sinistra del segno = senza che il reuse sia usato negli argomenti
del comando.

In caso di riutilizzo, ri-dichiarare il nome del concetto dietro l’attributo

reuse è ridondante, soprattutto perché il supervisore verifica che i due nomi
dei concetti siano identici.

15
3.5 Corpo di un comando
3.5.1 Introduzione
Il corpo di un comando contiene la parte variabile del comando. Le di-
chiarazioni sono separate da virgole e, tranne l’attributo di riutilizzo sopra
menzionato, sono tutte nella forma:
parola_chiave = argomento
Una parola-chiave è necessariamente una parola chiave dell’operatore
corrente, dichiarata nel catalogo di quest’ultimo.

3.5.2 Parola-chiave
Una parola-chiave è un identificatore formale, che è il nome dell’attributo
che riceve l’argomento. Ad esempio:
MATRICE = ...

Nota sintattica

• L’ordine di apparizione delle parole-chiavi è libero, non è imposto

dall’ordine di dichiarazione nei cataloghi

• Le parole-chiavi non possono superare i 16 caratteri (ma solo i

primi 10 caratteri sono significativi).

Esistono due tipi di parole-chiavi: le parola-chiavi e le parole-chiavi-

fattore che differiscono per la natura dei loro argomenti.

16
3.5.3 Parola-chiave semplice
3.5.3.1 Tipi di argomento I tipi di argomento di base riconosciuti e
accettati dal supervisore sono elecati come segue:

• Numeri interi

• Numeri reali

• Numeri complessi

• Stringhe di testo

• Valori logici

• Concetti

• Liste dei tipi precedenti

Numeri interi e reali corrispondono esattamente ai tipi equivalenti in Python.

• Parola-chiave semplice opzionale in attesa di un numero intero

Catalogo : INFO = SIMP(statut = ’f’, typ = ’I’),
File : INFO = 1,
• Parola-chiave semplice opzionale in attesa di un numero reale
Catalogo : VALE = SIMP(statut = ’f’, typ = ’R’),
File : VALE = 10.0,

La rappresentazione del tipo complesso è una tupla di dati di Python conte-

nente una stringa di caratteri che indica la modalità di rappresentazione del
numero complesso (parti reali e parte immaginaria oppure modulo e fase),
dopodichè i valori numerici.

Catalogo : VALE_C = SIMP(statut = ’f’, typ = ‘C’),

File : VALE_C = (‘RI’, 0.732, -0.732),
File : VALE_C = (‘MP’, 1.0, -45.0),

Le due notazioni sono strettamente equivalenti. Nella notazione ’MP’, la

fase è in gradi.

17
 Il tipo stringa di testo è dichiarato tra singoli apici ’. Il case-sensitive
dei caratteri (maiuscolo/minuscolo) viene rispettato. Tuttavia, quando una
parola-chiave deve assumere un valore in un elenco predefinito nel catalogo, è
consuetudine che questo valore rimanga capitalizzato.

Catalogo : TOUT = SIMP(typ = ‘TXM’, into = (‘OUI’, ’NON’)),

File : TOUT = ‘OUI’,

Il tipo di capitalizzazione è importante, nel contesto precedente la seguente

riga di comando fallirebbe:

File : TOUT = ‘oui’,

Il tipo logico non è più utilizzato in questo modo nel catalogo dei comandi.

Il concetto della parola-chiave è semplicemente dichiarato attraverso il

nome, senza spazi o virgolette.

3.5.3.2 Nozione di lista Le liste di Aster sono elenchi omogenei, ovvero

in cui gli elementi sono dello stesso tipo di base. Qualsiasi tipo di base può
essere utilizzato nella lista.

Attenzione La parola lista è qui un abuso di linguaggio. Non si tratta

dei tipi lista di Python ma piuttosto delle tuple, nel senso di Python: i diversi
elementi sono dichiarati tra parentesi aperta e parentesi chiusa, sono separati
da virgole.

Esempi di liste

Lista di interi : (1, 2, 3, 4),

Lista di testi : (’hello’, ’code’, ’aster’),
Lista di concetti : (resu1, resu2, resu3),

Facilità d’uso È accettato che un elenco ridotto a un elemento possa

essere descritto senza parentesi.

Esempio di lista errata Elenco eterogeneo errato costituito da numeri

interi e numeri reali:
Lista errata : (1, 2, 3.0, 4.0),

18
3.5.4 Parola-chiave-fattore
Alcune informazioni non possono essere fornite a livello globale (immediata-
mente nel comando), quindi è importante prevedere la ripetizione di alcune
parole-chiavi, per poter assegnare loro argomenti diversi. La parola-chiave-
fattore offre questa possibilità. In una parola-chiave-fattore si troverà quindi
un insieme di parole-chiavi, che possono essere utilizzate ad ogni occorrenza
della parola-chiave-fattore. Migliora anche la leggibilità del file di coman-
do raggruppando parole-chiavi che condividono un senso comune, come ad
esempio: diversi parametri dello stesso materiale. A differenza della parola-
chiave semplice, la parola-chiave-fattore può ricevere solo un tipo di oggetto:
l’oggetto supervisore _F, oppure un suo elenco.

• Quando la parola-chiave-fattore ha una sola occorrenza e la si può

scrivere con la seguenti regole di sintassi:
IMPRESSION = _F (
RESULTAT = resu,
UNITE = 6,
),

IMPRESSION = (
_F (
RESULTAT = resu,
UNITE = 6,
),
),

Nella prima riga, la parola-chiave-fattore IMPRESSION riceve un ogget-

to _F. Nella seconda riga, invece, riceve un singleton _F. Attenzione
alla virgola, in Python una tupla con un singolo elemento viene scritta
(elemento,)

• Quando la parola-chiave-fattore ha più occorrenze, la si può scrivere

con la seguenti regole di sintassi:
IMPRESSION = (
_F (
RESULTAT = resu1,
UNITE = 6,
),
_F (
RESULTAT = resu2,

19
 UNITE = 7,
),
),

Il numero di occorrenze (minimo e massimo) attese da una parola-chiave-

fattore è definito nel catalogo dei comandi.

3.5.4.1 Nozione del valore di default È possibile che il supervisore

assegni valori predefiniti. Questi valori sono definiti nel catalogo dei comandi
e non nel Fortran.

Non vi è alcuna distinzione, dal punto di vista della routine associata al

comando, tra un valore fornito dall’utente e un valore predefinito introdotto
dal supervisore. Questo appare quando il supervisore stampa i comandi utente
nel file di messaggi: tutti i valori predefiniti vengono visualizzati nel testo del
comando, se non sono stati forniti dall’utente.

Promemoria

Non è possibile dare un valore predefinito a un concetto.

20
4 Definizione valori e valutazioni espressioni
È possibile assegnare valori alle variabili Python per usarle come semplici
argomenti di parole chiave: queste variabili sono chiamate parametri in
EFICAS. Possono contenere valori interi, reali, complessi, testi o elenchi di
questi tipi.

Esempio:
young = 2.E+11
material = DEFI_MATERIAU (
ELAS = _F (
E = young,
NU = 0.3,
),
);
Alla fine dell’esecuzione, il contesto Python viene salvato con il database.
Pertanto, nella continuazione che seguirà, i parametri saranno sempre presenti,
con i loro valori predefiniti, proprio come i concetti di Aster.

È possibile eseguire operazioni Python su semplici argomenti di parole

chiave:
half_pi = pi/2.0

command = MA_COMMANDE (
VALE = half_pi,
);
Oppure:
text = ’world’

command = MA_COMMANDE (
VALE1 = pi/2.0,
VALE2 = half_pi+cos(30.0),
TEXTE = ’hello’+text,
),

21
5 Utilizzo di Python nel file di comando
Non è necessario conoscere il linguaggio Python per usare Code-Aster. In
effetti, con alcune regole di base per rispettare il rientro e la parentesi, è
necessaria solo la conoscenza del linguaggio di comando descritto nei cataloghi
dell’ordine. E ancora, EFICAS consente di astenersi dal ricorrere al catalogo
o al paragrafo "sintassi" degli ordini proponendo graficamente le parole chiave
da informare.

Tuttavia, l’utente avanzato può utilizzare la potenza del linguaggio Python

nel suo file di comando, poiché è già scritto in questa lingua.

I quattro utilizzi principali possono essere: la scrittura di macro-comandi

personalizzati, l’uso di istruzioni generali Python, l’importazione di moduli
utili di Python, il recupero di informazioni delle strutture di dati Code-Aster
nelle variabili Python.

5.1 Macro-comandi persaonalizzati

Vedere il documento [D5.01.02] Introdurre un nuovo macro-comando. I
macro-comandi personalizzati sono molto facili da programmare. Possono
essere utilizzati per capitalizzare schemi di calcolo ricorrenti e quindi costituire
uno strumento di business. Si consiglia vivamente di fare un esempio sui
macro comandi esistenti: pacchetto Macro nella directory bibpyt.

5.2 Istruzioni generali di Python e comandi utili

Gli utenti esperti possono trarre grandi vantaggi dall’uso di loop (while,
for), test (if), eccezioni (try, except) e in generale la piena potenza
del linguaggio Python direttamente nel loro file di comando. L’elenco degli usi
è impossibile da stabilire in modo esauriente. Numerosi esempi sono presenti
nei casi test all’interno del relativo database.
Ad esempio, si può fare l’adattamento della mesh posizionando il calco-
lo/remeshing della sequenza in un loop, stabilire un criterio di arresto delle
iterazioni mediante un test su un valore calcolato. Vedi il paragrafo seguente
dedicato alle eccezioni particolari di Aster.
In un ciclo, se ricreiamo un concetto già esistente, dobbiamo pensare di
distruggerlo in anticipo dal comando DETRUIRE.

22
 Le altre varie funzionalità di Python interessanti per l’utente di Code-Aster
possono essere:

• Lettura-scrittura dei file

• Calcolo numerico (ad esempio utilizzando numpy)

• La chiamata tramite il modulo os al linguaggio di scripting, e in

particolare l’avvio di un codice di terze parti (os.system)

• Manipolazione di stringhe di caratteri

• La chiamata ai moduli grafici (grace, gnuplot, . . . )

5.3 Eccezioni di Python del modulo Aster

Il meccanismo delle eccezioni di Python è molto interessante, consente ad
esempio di provare un comando e quindi di riprendere il controllo se si
arresta in modo anomalo sollevando una particolare eccezione:
try:
**instruzione**
except Errore, message:
**blocco eseguibile in caso di Errore**
Nel file di comando, questo meccanismo può essere utilizzato con qualsiasi
eccezione dei moduli Python standard.

Ci sono anche delle eccezioni specifiche a Code-Aster (del modulo Aster),

divise in due categorie, le eccezioni associate agli errori <S> e quelle associate
agli errori <F>.

5.3.1 Intercettazione di errori <S>

In caso di errore <S>, l’errore è identificato dà una di queste eccezioni:

• aster.NonConvergenceError: in caso di mancata convergenza

del calcolo

• aster.EchecComportementError: problema di integrazione della

legge di comportamento

• aster.BandeFrequenceVideError: nessuna modalità trovata al-

l’interno della banda di frequenza

23
 • aster.MatriceSinguliereError: matrice singolare

• aster.TraitementContactError: problema durante l’elaborazio-

ne del contatto

• aster.MatriceContactSinguliereError: matrice di contatto

singolare

• aster.ArretCPUError: arresto a causa della mancanza di tempo

della CPU

Tutte queste eccezioni derivano dall’eccezione generale <S> che è aster.error

Ciò significa che except aster.error rileva tutte le eccezioni elencate
di seguito. È comunque sempre meglio specificare quale errore è previsto.

Esempio di utilizzo:
try:
resu = STAT_NON_LINE(...)
except aster.NonConvergenceError, message:
print ’Ooops errore: %s’ % str(message)
print ’Piu iterazioni’

resu = STAT_NON_LINE(reuse = resu,

...
CONVERGENCE = _F(ITER_GLOB_MAXI = 400,)
...)

except aster.error, message:

print ’Ooops, altro errore: %s’ % str(message)
print ’Stop’

from Utilitai.Utmess import UTMESS

UTMESS(’F’, ’Exemple’, ’Erreur <S> inattendue’)

5.3.2 Intercettazione di errori fatali <F>

In caso di errore fatale, il comportamento può essere modificato dall’utente.
Per impostazione predefinita, il codice si interrompe nell’errore <F>, possiamo
vedere il feedback dell’errore (appello alle routine Fortran) nel file di output.
Se lo si desidera, il codice può generare l’eccezione aster.FatalError,
in questo caso (come per un errore <S>), se l’eccezione viene intercettata

24
da un except, l’utente assume il controllo, altrimenti il codice si arresta
(nessuna segnalazione di errori Fortran). Questa scelta è determinata dai
comandi DEBUT e POURSUITE, fattore chiave ERREUR (vedere [U4.11.01] e
[U4.11.03]) e in qualsiasi momento dal metodo aster.onFatalError.

Quest’ultimo chiamato senza argomento restituisce il comportamento

corrente in caso di errore fatale:
comport = aster.onFatalError()
print ’In caso di errore fatale ... : %s’ % comport
Permette inoltre di definire il comportamento che desideriamo:
# sollevare l’eccezione FatalError
aster.onFatalError(’EXCEPTION’)

# fermare con il recupero di errore

aster.onFatalError(’ABORT’)

5.3.3 Validità dei concetti in caso di eccezione

Quando viene sollevata e intercettata un’eccezione (con except), il concetto
prodotto dal comando in cui si è verificato l’errore viene reso così com’è,
poiché il comando non è stato completato normalmente. In alcuni casi,
specialmente dopo un errore fatale, il concetto di prodotto potrebbe non
essere utilizzabile, quindi utilizzare DETRUIRE per eliminarlo. Allo stesso
modo, se si desidera riutilizzare il nome del concetto per crearne uno nuovo,
è necessario distruggere con DETRUIRE quello ottenuto all’interno del try.

In caso di errore <S> generato in STAT_NON_LINE e DYNA_NON_LINE,

il concetto è generalmente valido e può essere riutilizzato (parole chiave
reuse) per continuare il calcolo con un’altra strategia (come nell’esempio
citato in precedenza).

Infine, prima di restituire la mano all’utente, gli oggetti di base volatili ven-
gono rimossi da una chiamata a JEDETV e il segno Jeveux viene riposizionato
su 1 (con JEDEMA) per rilasciare gli oggetti riportati in memoria.

5.3.4 Precauzioni d’uso delle eccezioni

Le due eccezioni aster.error ed aster.FatalError sono indipendenti
(nessuna deriva dall’altra), il che significa che se vogliamo riprendere il filo in
caso di errore <S> ed errore <F> è necessario:

25
 • Attivare il sollevamento di eccezioni in caso di errore <S> attraverso il
metodo aster.FatalError(’EXCEPTION’), oppure nei comandi
DEBUT e POURSUITE

• Intercettare le due eccezioni, specificandole nel contesto dell’except:

except (aster.error, aster.FatalError), message:
...

È sconsigliabile usare except senza specificare quale eccezione è prevista

(questa è una regola generale in Python indipendentemente dalle eccezioni di
Aster). In effetti, è improbabile che l’elaborazione eseguita con except sia
valida in tutti i casi di errore.

Analogamente, come nell’esempio precedente, è preferibile utilizzare sia

le eccezioni aster.NonConvergenceError, aster.ArretCPUError,
. . . che l’eccezione di livello superiore aster.error. Sempre nell’idea di
sapere esattamente cosa è successo.

5.4 Recupero dei valori calcolati nelle variabili Python

Sfruttare il linguaggio Python nel suo file di comando è interessante solo se
si possono avviare condizionalmente azioni in base a ciò che il codice ha
calcolato.

Esistono alcuni gateway tra Python e le strutture dati calcolate dal codice
e presenti nella memoria JEVEUX. Altri rimangono da programmare. Questo
è un campo in evoluzione e sono previsti sviluppi futuri.

È essenziale comprendere che il recupero dei dati calcolati richiede che

le istruzioni per ottenerli siano state eseguite in anticipo. In altre parole,
è essenziale eseguire il codice in PAR_LOT = ’NON’ (parola chiave del
comando DEBUT). In effetti, in questo caso, non esiste un’analisi globale
del file di comando, ma ogni istruzione viene eseguita in modo sequenziale.
Quando arriviamo a un’istruzione, tutti i concetti precedenti sono già stati
calcolati.

26
 Ecco alcuni metodi per accedere alle strutture di dati. L’elenco non è
esaustivo, consultare la documentazione [U1.03.02].

Stuttura Metodo Tipo di ritorno Informazioni

listr8 LIST_VALEURS list Lista di valori
maillage LIST_GROUP_NO list Lista di gruppi di nodi
LIST_GROUP_MA list Lista di gruppi di mesh
table - float Contenuto della tabella
fonction LISTE_VALEURS list Lista di valori
resultat LIST_CHAMPS list Lista di campi calcolati
LIST_NOM_CMP list Lista di componenti
LIST_VARI_ACCES list Lista di variabili d’accesso
LIST_PARA list Lista di parametri
cham_no EXTR_COMP post_comp_cham_no Contenuto del campo di una tabella
cham_elem EXTR_COMP post_comp_cham_el Contenuto del campo di una tabella
JEVEUX getvectjev list Lista di oggetti del vettore jeveux

5.5 Esempio di costruzione dinamica delle parole-chiavi-

fattore
Nel caso in cui una parola-chiave-fattore sia molto ripetitiva da scrivere,
l’utente potrebbe voler comporne il contenuto tramite script, in un elenco op-
pure in un dizionario, che fornirà quindi alla parola-chiave-fattore. L’esempio
seguente mostra tre modi per scrivere la stessa parola-chiave-fattore.
DEBUT(PAR_LOT=’NON’)

a = [_F(JUSQU_A = 1.0, PAS = 0.1),

_F(JUSQU_A = 2.0, PAS = 0.1),
_F(JUSQU_A = 3.0, PAS = 0.1)]

b = [_F(JUSQU_A = float(i), PAS = 0.1) for i in range(1, 4)]

c = [{’JUSQU_A’:float(i), ’PAS’:0.1} for i in range(1, 4)]

d = [_F(**kargs) for kargs in c]

list = DEFI_LIST_REEL (
DEBUT = 0.0,

27
 INTERVALLE = a,

# oppure
INTERVALLE = b,

# oppure
INTERVALLE = d,
);

FIN()

28