cdm.ing.unimore.it

Questa pagina è in sola lettura. Puoi visualizzare il sorgente, ma non puoi modificarlo. Contatta l'amministratore se pensi che ci sia un errore.
 ======= Lezione 6 =======

 ===== Costruzione della matrice rigidezza vincolata =====
Prendendo in esame la stessa struttura si illustra un esempio di costruzione della "Matrice di rigidezza vincolata".
Nel caso specifico si considerano vincolati i nodi "1" e "4" rispettivamente con carrello e cerniera, corrispondenti ai gradi di libertà "2", "7" e "8".   
{{ :wikipaom2015:schema_semplice_struttura_paom.png?300 |}}

Rispetto al riferimento illustrato sopra, gli spostamenti imposti sono:
{**U4=0**, **V4=0**,**V1=V1'(spostamento fissato)**}
Come descritto dalla lezione 4, l'introduzione dei vincoli comporta la modifica del sistema di equazioni ricavato imponendo il solo equilibrio nodale **K * δ = F**.
 
{{ :wikipaom2015:schema_semplice_struttura_paom.pdf |}}


{{:wikipaom2015:assemblaggio_da_prof-0.png?300|}}

Pertanto alle equazioni di equilibrio corrispondenti ai gradi di libertà vincolati (2,7,8) si sostituiscono l'equazioni di congruenza come mostrato di seguito.
Considerando nello specifico il grado di libertà "7", si annullano tutti gli elementi della settima riga tranne quello diagonale posto uguale a "1".
In questo modo senza togliere il carattere di incognita ad "**U4**", risulta essere pari a zero indipendentemente dagli altri valori. 

{{:wikipaom2015:assemblaggio_da_prof-1.png?300|}}

Si esegue la medesima operazione sulla colonna "7" collocando gli elementi della stessa nel vettore dei termini noti, in questo modo si recupera la simmetria della matrice.


{{:wikipaom2015:assemblaggio_da_prof-2.png?300|}}


{{:wikipaom2015:assemblaggio_da_prof-3.png?300|}}

Si ottiene così il sistema matriciale vincolato relativo al grado di libertà "7". 

{{:wikipaom2015:assemblaggio_da_prof-4.png?300|}}

Si effettuano le stesse operazioni per i gradi di libertà "2" e "8" relativi ai restanti vincoli scelti.  

{{:wikipaom2015:assemblaggio_da_prof-5.png?300|}}

La matrice ottenuta è la "**Matrice rigidezza vincolata**".
La soluzione avrà forma del tipo  **δ' = Kv<sup>-1</sup> * Fv**
Da "δ'" si ricavano come è noto il campo delle deformazioni  e lo stato tensionale relativi alla deformata.
Si ricavano quindi le reazioni vincolari sotto le quali questa rimane in equilibrio.
In particolare riconsiderando la matrice di rigidezza "**K**" ed indicando con "**R**" le reazioni vincolari, quest'ultime si ricavano:  "**R = K * δ' - F**"   

{{:wikipaom2015:assemblaggio_da_prof.pdf|procedura asseblaggio (ipe,pdf)}}




 

 ===== Il Fortran =====

Vedere anche 
[[http://web.stanford.edu/class/me200c/tutorial_77/| Tutorial Fortran 77  Stanford]]
[[https://cdm.ing.unimo.it/files/progettazione_assistita/materiale_didattico/tutorial_fortran77_stanford.pdf|pdf]]
[[https://cdm.ing.unimo.it/files/progettazione_assistita/materiale_didattico/tutorial_fortran77_stanford_single.html|html]]
 ==== Cosa è il Fortran? ====

Il '''''FORTRAN''''' è un __linguaggio di programmazione standardizzato__ che nasce dall'esigenza di avere un interprete che faccia da tramite tra macchina e operatore.
Esso rappresenta il primo tentativo di scrivere un linguaggio standard formalizzato, che tutte le macchine possano riconoscere indipendentemente dalla diversità della CPU, ossia, indipendentemente dai diversi linguaggi macchina. Ad esempio, un processore ''INTEL'' ha un linguaggio macchina differente da un processore basato su architettura ''ARM''. 
Dunque, con il linguaggio di programmazione l'utente non scrive direttamente in linguaggio macchina (che cambia da tipo a tipo di processore), ma scrive in un linguaggio tale da essere traducibile in linguaggio macchina.

In particolare, il '''''Fortran 77''''' è stata la prima versione di questo linguaggio ad essere sviluppata e, nonostante la sua estrema semplicità, costituisce la base su cui sono programmati svariati solutori artificiali come , ad esempio, il software ad elementi finiti '''''MSC Marc'''''. Utilizzeremo la versione del Fortran 77 in quanto è la più utilizzata e leggibile anche dai fortran successivi (es. Fortran 90).

 ==== Introduzione all'utilizzo del FORTRAN ====

Per scrivere il programma abbiamo bisogno innanzitutto di un editor di testo. Es: //gedit// che permette di scrivere file di testo non formattati. Posso pertanto scrivere come se avessi righe e colonne (ad esempio la lettera m è larga quanto la lettera i).
Per salvare un file scritto con //gedit// come programma Fortran dobbiamo salvarlo con estensione **.for**.
Una delle peculiarità del Fortran è quella di non essere //case sensitive//, ossia, di non fare alcuna distinzione tra lettere maiuscole e minuscole.
Per compilare il programma vi sono delle convenzioni da conoscere:

  * Il compilatore utilizza solo le prime 72 colonne di ogni riga, ciò significa che tutti i caratteri dalla 73° colonna in poi saranno ignorati e, pertanto, non eseguiti.
  * La prima colonna è riservata all'informazione riguardo la riga,ovvero, il carattere della prima colonna stabilisce se la riga è una //riga di comando// o di //commento//. Nel caso in cui si voglia inserire una riga di commento, bisogna inserire la lettera __C__ o il carattere //*// in modo che la riga stessa venga bypassat dal compilatore e, quindi, non eseguita. Una versione più recente di commento non presente in Fortran 77, ma solitamente accettata dal compilatore è il "!" nella prima colonna seguito dal commento.
  * La 2°,3°,4° e 5° colonna sono spazi riservati per //l'identificazione della riga// di comando. Infatti, è possibile assegnare un'etichetta o "label" ad una data riga di comando con un massimo di quattro caratteri. Questo può risultare utile nella scrittura del programma nel caso in cui si voglia fare riferimento ad una data riga o rimandare il programma all'esecuzione della stessa.

  ATTENZIONE: non è obbligatorio dare un'etichetta a tutte le righe del codice ma non ci possono essere due etichette
  aventi stesso nome all'interno dello stesso blocco ( //program-end//, //subroutine-end//). Inoltre, se il nome
  delle righe è numerico,  l'identificazione delle stesse non deve essere necessariamente crescente, ossia, una riga 
  che segue un'altra può essere identificata da un numero minore di quella che la precede.

  * La 6° colonna è riservata alla simbologia di continuazione di comando. Questo serve per portare a capo un'istruzione, nel caso in cui una sola riga non basti per esaurire un'istruzione, causa il raggiungimento della 72° colonna del codice. E' possibile, quindi, continuare l'istruzione sulla riga successiva, indicando la stessa come continuazione della precedente, inserendo un qualsiasi simbolo FORTRAN eccetto lo spazio e lo 0 in corrispondenza della 6° colonna. Per fare questo, si potrebbe, per esempio, utilizzare il dollaro //$// o il simbolo //+// spesso più intuitivo.
  * Dalla 7° alla 72° colonna vi è l'istruzione che il compilatore deve eseguire.

 ==== Linee guida per la compilazione corretta del programma ====
Visto quanto detto sopra, è buona regola di programmazione iniziare il programma con una riga che metta in evidenza lo spazio a nostra disposizione per scrivere le istruzioni e identifichi le colonne adibite a funzioni specifiche. Quindi, volendo è possibile identificare le prime 7 colonne con il proprio indice colonna, in modo da mettere in evidenza le colonne con le funzionalità precedentemente descritte, le colonne dalla 8° alla 71° con un simbolo generico, come ad esempio =, per identificare lo spazio a disposizione e la 72° con il carattere !, in modo da avere uno "warning" della fine dello spazio disponibile.
Per poter compilare adeguatamente il programma, è bene concepirlo inizialmente come un insieme funzionale di blocchi, nel modo seguente:
  * **Nome del programma** si indica il nome mediante il comando __PROGRAM__  //nome del programma//
  * **Dichiariamo le variabili** il FORTRAN utilizza un' //allocazione di memoria statica//, ossia, dichiarando le variabili indichiamo esplicitamente la totalità della memoria necessaria per l'esecuzione di tutto il programma. Questo è importante perché, in fase di esecuzione (//Run Time//), il programma non potrà richiedere alcuna memoria aggiuntiva. Se avessimo la possibilità di richiedere di utilizzare più memoria durante il programma si parlerebbe di allocazione dinamica. Le variabili possono essere, essenzialmente, dei seguenti 6 tipi:
  * **INTEGER** :  la variabile indica un numero intero.
  * **REAL** : la variabile indica un numero reale, in virgola mobile con o senza segno, in singola precisione (7 cifre significative).
  * **DOUBLE PRECISION** :  La variabile indica un numero REAL, sempre con la virgola, ma con doppia precisione (circa 15 cifre significative). 
  * **COMPLEX** : indica un numero complesso, quindi, si devono indicare parte reale e parte immaginaria.
  * **LOGICAL** : memorizza solo due valori: __.true.__ e __.false.__.
  * **CHARACTER** : memorizza una stringa completa di tipo "caratteri".
  * **Corpo del programma** è un listato di comandi che il compilatore esegue, effettuando operazioni tra le variabili indicate nella dichiarazione. **ATTENZIONE:** il listato deve terminare con un comando del tipo **STOP**.
  * **END** è il comando che termina l'esecuzione del programma.

Per far girare correttamente il file editor appena creato, esso dovrà essere salvato tramite il comando **SAVE AS** inserendo il **nomefile.for**. In questo modo, il file potrà essere letto ed eseguito correttamente dal terminale della macchina sulla quale si sta lavorando.

Nel caso in cui il terminale dovesse dare un errore di file inesistente è necessario assicurarsi di aver salvato il file in // cygwin > home > nome utente //

Una volta salvato il file, si deve aprire il terminale ed inserire il seguente comando.
  * Nel caso in cui si lavori in ambiente LINUX:

  gfortran nomefile.for &&./a.out

  * Nel caso in cui si lavori in ambiente WINDOWS:

  gfortran nomefile.for &&./a.exe

dove **a.out** (o **a.exe**) sono gli eseguibili creati con la compilazione e sono sostanzialmente la traduzione del codice Fortran in linguaggio macchina, per l’architettura specifica. 
Do sia il comando di compilazione che di esecuzione accodati tramite il doppio &&, se la compilazione va a buon fine eseguo altrimenti no.
Il costrutto **./a.out** si può 'tradurre' con: //lancia il file a.out in questa cartella//, dove il punto prima della barra (./) indica "questa cartella", la barra indica "dentro".

**osservazione**: cosa vuol dire single o double precision? Allora, secondo lo standard IEEE 754 la struttura di un numero
(in virgola mobile) è rappresentato su "parole" di 32bit (single precision) o 64 bit (double precision). Tali bit
possono essere suddivisi in 3 parti:

  * **per i single precision (32 bit)** 
    * 1)  un bit di segno
    * 2)  8 bit per l'esponente
    * 3)  23 bit per la mantissa (dove posso scrivere 2^23 numeri)
 

  1    8              23                -> lunghezza in bit
  +-+--------+----------------------+
  31 30      22                     0    -> indice dei bit

  * **per i double precision (64 bit)**
    * 1)  un bit di segno
    * 2)  11 bit per l'esponente
    * 3)  52 bit per la mantissa (dove posso scrivere 2^52 numeri)


  1    8              52                 -> lunghezza in bit
  +-+--------+----------------------+
  63 62      51                     0    -> indice dei bit

==== Esempi programmi====

===Hello World===
Un primo approccio alla programmazione è stato la compilazione del programma **Hello World**.


  c234567==============================================================72      
        program HeLLow
        write(*,*) 'Hello World by group 6!!!'
        end

Questo programma, una volta eseguito, stampa il testo //Hello World by group 6!!!//.
Questa è la prima occasione in cui vediamo il comando **WRITE(*,*)**. Tale comando valuta una lista di istruzioni e le esegue con formato standard (indicato da __*__). Il primo posto all'interno del WRITE serve per indicare l'UNITA' mentre il secondo indica il FORMATO. Con l'* si intende l'unità o il formato standard. Quindi letteralmente WRITE(*,*) significa //scrivi quello che segue in output sull'unità standard (video) con formato standard//. 

Possiamo accodare dei file in output separandoli con una virgola. In questo modo, senza richiamare più volte il comando su righe successive, è possibile scrivere più stringhe, una in sequenza all'altra nel modo seguente:

 write(*,*)‘stringa_1’ , ‘stringa_2’

Nel caso in cui il comando fosse troppo lungo, poichè oltrepassante la 72° colonna, lo si può spezzare andando a capo e scrivendo, in corrispondenza della sesta colonna della riga siccessiva, un qualsivoglia carattere come un __$__ o un __+__, **ma non uno spazio**:

  c234567==============================================================!
        write(*,*) 'HelloWorlddddddddddddddddddddddddddddddddddddddddddd
       +dddddddddddddddddd!'


~~DISCUSSION|Note di redazione~~