Analisi Elastica Con Il Metodo Degli Elementi Finiti: Sviluppo Di Un Codice e Confronto Con Programmi Di Uso Commerciale.

UNIVERSITA DEGLI STUDI DI TRIESTE FACOLTA DI INGEGNERIA Corso di Laurea in Ingegneria Civile ed Ambientale
A.A. 2008 / 2009
Tesi di laurea triennale in
Analisi Numerica delle Strutture
Analisi elastica con il metodo degli elementi niti:

sviluppo di un codice e confronto con programmi di uso commerciale
Relatore:
Laureando:
Prof. Ing. Alfonso Nappi
Enrico Bergamo
Indice
Introduzione 1 Cenni sul metodo degli elementi niti 1.1 Introduzione . . . . . . . . . . . . . . . . . . . . 1.2 Panoramica del metodo . . . . . . . . . . . . . . 1.2.1 Scelta del modello matematico pi` adatto u 1.2.2 Scelta del tipo di elemento nito . . . . . 1.2.3 Meshing . . . . . . . . . . . . . . . . . . 1.2.4 Propriet` dei materiali . . . . . . . . . . . a 1.2.5 Matrice di rigidezza . . . . . . . . . . . . 1.2.6 Rinumerazione dei nodi . . . . . . . . . . 1.2.7 Attribuzione dei vincoli . . . . . . . . . . 1.2.8 Attribuzione dei carichi . . . . . . . . . . 1.2.9 Assemblaggio del sistema risolvente . . . 1.2.10 Risoluzione del sistema lineare . . . . . . 2 Ambiente di sviluppo 2.1 Linguaggio di programmazione 2.2 .NET Framework . . . . . . . 2.3 IDE SharpDevelop . . . . . . . 2.4 EasyMesh . . . . . . . . . . . 2.5 Math.NET . . . . . . . . . . . 2.6 Open Cascade . . . . . . . . . 3 Analisi del codice 3.1 Organizzazione del progetto 3.1.1 Thesis . . . . . . . 3.1.2 Kmatrix . . . . . . 3.1.3 Calc . . . . . . . . i 1 1 1 2 3 8 9 9 11 12 12 14 18 21 21 21 23 23 24 25 27 27 28 28 29
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
3.2 3.3
3.4 3.5 3.6
Geometria e discretizzazione . . . . . . . Matrice di rigidezza . . . . . . . . . . . . 3.3.1 La matrice di rigidezza elemento . 3.3.2 Assemblaggio della matrice globale Vincoli . . . . . . . . . . . . . . . . . . . Carichi . . . . . . . . . . . . . . . . . . . Soluzione . . . . . . . . . . . . . . . . . . 3.6.1 calc.calcolo.ordina() . . . . . . . . 3.6.2 calc.calcolo.sislin() . . . . . . . . 3.6.3 calc.calcolo.spostamenti() . . . . . 3.6.4 calc.calcolo.stress() . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
29 33 34 37 42 44 44 45 50 51 53 61 61 61 61 64 68 73 78 83 89 91
4 Confronti con software di calcolo commerciali 4.1 Introduzione . . . . . . . . . . . . . . . . . 4.1.1 SAP2000 . . . . . . . . . . . . . . . 4.1.2 COMSOL Multiphysics . . . . . . . 4.2 Primo problema . . . . . . . . . . . . . . . 4.3 Secondo problema . . . . . . . . . . . . . . 4.4 Terzo problema . . . . . . . . . . . . . . . 4.5 Quarto problema . . . . . . . . . . . . . . . 4.6 Quinto problema . . . . . . . . . . . . . . . Conclusioni Bibliograa
Introduzione
Con questo lavoro si vuole esporre il percorso di sviluppo e validazione di un codice di calcolo in grado di eseguire analisi elastico lineari su lastre bidimensionali sollecitate nel proprio piano. A tal proposito ` stato elaborato un software che ` disponibile, e e unitamente al codice sorgente, nel CD-ROM allegato. Nelle prossime pagine viene esposta una diretta applicazione degli argomenti trattati nellambito del corso di Analisi Numerica delle Strutture, tenuto dal prof. ing. Alfonso Nappi. La tesi ha anche un secondo obiettivo: dimostrare che le competenze informatiche necessarie ad elaborare un codice funzionante sono acquisibili anche individualmente. I linguaggi di programmazione di alto livello (Java, C#, ecc.) sono oggigiorno performanti tanto quanto C o C++ e consentono una programmazione veloce ed assistita. Gli strumenti, anche open source, a disposizione di questi linguaggi stanno crescendo in maniera esponenziale e rendono limplementazione di funzioni complesse sempre pi` semplice. u Nel primo capitolo ` contenuta una breve panoramica del metodo degli elementi e niti. La trattazione ` orientata ad evidenziare lapplicazione del metodo per il caso e piano. Nel secondo capitolo si illustrano gli strumenti che sono stati utilizzati nello sviluppo del software. Il terzo capitolo ` dedicato allanalisi del codice ideato, mentre e nel quarto capitolo vengono confrontati i risultati prodotti con quelli di altri due programmi: SAP2000 e COMSOL Multiphysics.
Capitolo 1
Cenni sul metodo degli elementi niti

1.1 Introduzione
Le equazioni dierenziali alle derivate parziali vengono comunemente usate per formulare e risolvere problemi quali la propagazione del suono o del calore, in aerodinamica, nel calcolo strutturale o in meccanica dei uidi. Il metodo degli elementi niti trova le proprie origini nella necessit` di dare una soluzione numerica ai problemi formulati a tramite queste equazioni. I problemi per cui per la prima volta1 , negli anni 1930-35, si sent` la necessit` di una soluzione numerica furono lanalisi elastica e strutturale a nel campo dellingegneria civile ed aeronautica. Tuttavia la nascita vera e propria e lo sviluppo del metodo agli elementi niti si colloca nella seconda met` degli anni a 50 con il contributo fondamentale di M. J. Turner della Boeing, che formul` e pero fezion` il primo approccio agli elementi niti nel campo del continuo. Altri contributi o fondamentali alla storia dei FEM sono quelli di B. M. Irons, cui sono dovuti gli elementi isoparametrici e il concetto di funzione di forma. Con la crescente disponibilit` a di calcolatori elettronici, dagli anni 70 in poi, il metodo ha trovato diusione come strategia di modellazione numerica di sistemi sici in unampia variet` di problemi. a
1.2
Panoramica del metodo
Il processo di traduzione del metodo in programma per elaboratore prevede alcune fasi dalle quali non ` possibile prescindere. In questo capitolo se ne dar` una descrizione e a
1
lavori di A. R. Collar e W. J. Duncan
seguendo un ordine logico, mentre nel prossimo capitolo si aronter` largomento dal a punto di vista dellelaboratore, seguendo sequenzialmente lo svolgersi dellanalisi.
1.2.1
Scelta del modello matematico pi` adatto u
Ogni problema di elasticit` `, a rigore, un problema tridimensionale; tuttavia, in a e moltissimi casi, il problema si pone in modo da poter utilizzare le trattazioni approssimate descritte in teoria, come ad esempio: teoria tecnica della trave; stato piano di sforzo; stato piano di deformazione; assialsimmetria. Prima di descrivere il modello che si ` utilizzato vanno fatte alcune doverose pree cisazioni sulle ipotesi di calcolo che si sono assunte. La scelta del modello matematico comporta inevitabilmente anche lassunzione di alcune ipotesi fondamentali. In questo caso si sono assunte le seguenti ipotesi: omogeneit`: il corpo possiede le medesime propriet` siche in ogni punto, a a indipendentemente dalla posizione; isotropia: il corpo risponde alle sollecitazioni indipendentemente dalla direzione dalle quali esse provengono; elasticit` lineare: esiste un legame lineare tra sforzi e deformazioni; a regime di piccoli spostamenti: consente di trascurare le non linearit` nelle a relazioni cinematiche e quindi di assumere la congurazione indeformata come riferimento per scrivere le equazioni di equilibrio; sistema di forze agenti nel piano denito dal corpo: la lastra verr` sola lecitata solamente nel proprio piano. Nel programma oggetto di questa tesi si utilizzer` la teoria dello stato piano di a sforzo. Questa prevede che gli unici sforzi non nulli siano paralleli al piano medio della lamina e che non ci siano n sforzi normali, n sforzi tangenziali perpendicolari e e al piano stesso.
1.2 Panoramica del metodo
Assumendo il sistema di riferimento indicato in Figura 1.1 ci` equivale a dire o che z = yz = zx = 0 Le incognite coinvolte saranno perci` o il vettore delle deformazioni = {x , y , xy }T e il vettore degli sforzi ={
x, y, T xy }
Figura 1.1: Stato piano di sforzo, sistema di riferimento
Nei materiali elastici lineari esiste una relazione lineare con coe cienti costanti che lega le deformazioni agli sforzi: = D La matrice D, nel caso generale di materiale omogeneo e isotropo, pu` essere o scritta come 8 > + 2G > > > > > < > > > > > > : 0 0 0 + 2G 0 0 0 9 0 0 0> > > 0 0 0> > > = + 2G 0 0 0 0 G 0 0> > > > 0 0 G 0> > ; 0 0 0 G
D=
E E Dove si pone = (1+)(1 2) (prima costante di Lam`) e G = 2(1+) (seconda e costante di Lam`, modulo di elasticit` tangenziale). In virt` della semplicazione e a u introdotta dalla teoria dello stato piano di sforzo la matrice D diviene
1.2.2
Scelta del tipo di elemento nito
8 1 E < 1 D= 1 2 : 0 0
9 0 = 0 1 ;
2
La scelta del tipo di elemento nito da utilizzare nellanalisi ` fortemente inuenzata e dal tipo di modello matematico che si ` assunto. e
Se, ad esempio, si ` scelto di analizzare e una struttura a telaio la scelta cadr` su un a elemento di tipo biella (elemento truss) o ` di trave (elemento beam). E da notare che questi due tipi di elemento hanno comunque comportamenti molto diversi tra loro. Nel caso pi` generale di problemi piani le possibilit` u a di scelta sono molteplici: ` possibile utilize zare elementi a tre o quattro nodi ma anche elementi, se pur di forma simile, con una differente formulazione al ne di poter cogliere stati di deformazione e sforzo pi` dettagliati u Figura 1.2: Elemento CST (come triangoli a sei nodi o quadrilateri a otto nodi). Nel programma oggetto di questa tesi si ` deciso di implementare elementi e triangolari a tre nodi, data la semplicit` della formulazione e la facilit` di gestione a a a livello software che questi oono. Questo tipo di elemento ` meglio conosciuto come e 2 ed ` in grado, a partire da un campo di spostamenti lineari, di elemento CST e descrivere stati di deformazione (e quindi di sollecitazione) costanti. Occorre denire un modello di spostamenti al ne di stimare la posizione di ogni punto allinterno dellelemento una volta che il corpo ` stato deformato. Gli spostamenti coinvolti e saranno u e v, ovvero i due gradi di libert` che possiede un punto nel piano. Essi a saranno funzione delle coordinate e di sei parametri cha andranno stimati mediante le condizioni al contorno: u(x, y) = 1 + 2 x + 3 y v(x, y) = 4 + 5 x + 6 y
8 < u(0, 0) = u1 = 1 u(x2 , 0) = u2 = 1 + 2 x2 : u(x3 , y3 ) = u3 = 1 + 2 x3 + 3 y3 8 < 1 = u1 2 = u2x2u1 =) : 3 = u3y3u1 +

u1 u2 x2 x3
Constant Strain Triangle
8 < v(0, 0) = v1 = 4 v(x2 , 0) = v2 = 4 + 5 x2 : v(x3 , y3 ) = v3 = 4 + 5 x3 + 6 y3 8 < 4 = v1 5 = v2x2v1 =) : 6 = v3y3v1 +

v1 v2 x2 x3
Noti i parametri ` possibile calcolare le funzioni di forma in u: e u(x, y) = 1 + 2 x + 3 y = u1 u2 = u1 + x+ + x3 y = x2 y3 x2 y3 x y x3 y x3 y y = 1 + u1 + u2 + u3 x2 y3 x2 y3 x2 y3 y3 u2 u1 u3 u1 u(x, y) = '1 (x, y)u1 + '2 (x, y)u2 + '3 (x, y)u3 e in v: v(x, y) = 4 + 5 x + 6 y = v1 v2 = v1 + x+ + x3 y = x2 y3 x2 y3 x y x3 y x3 y y = 1 + v1 + v2 + v3 x2 y3 x2 y3 x2 y3 y3 v2 v1 v3 v1 v(x, y) = '1 (x, y)v1 + '2 (x, y)v2 + '3 (x, y)v3 Volendo dare una rappresentazione graca delle funzioni di forma potremo notare come esse descrivano in modo lineare la partecipazione dello spostamento dei nodi alla denizione dello spostamento del punto generico allinterno dellelemento (gura 1.3). In forma matriciale il modello di spostamento si pu` esprimere nel seguente modo: o ( ) u(x, y) u(x, y) = = (x, y)u v(x, y)
Figura 1.3: Andamento delle funzioni di forma Con u vettore degli spostamenti nodali e (x, y) matrice delle funzioni di forma: u = u1 v1 u2 v2 u3 v3 (x, y) =
T
'1 (x, y) 0 '2 (x, y) 0 '3 (x, y) 0 0 '1 (x, y) 0 '2 (x, y) 0 '3 (x, y)
Lo stato deformativo ` ricavabile, in regime di piccoli spostamenti, derivando le e componenti dello spostamento. @uj 1 @ui ij = + 2 @xj @xi Applicandola agli elementi niti triangolari e limitandosi a considerare le deformazioni nel piano, si ottengono le seguenti espressioni: x = y = @u(x, y) @'1 (x, y) @'2 (x, y) @'3 (x, y) = u1 + u2 + u3 @x @x @x @x @v(x, y) @'1 (x, y) @'2 (x, y) @'3 (x, y) = v1 + v2 + v3 @y @y @y @y
xy =
@u(x, y) @v(x, y) @'1 (x, y) @'1 (x, y) @'2 (x, y) + = u1 + v1 + u2 + @y @x @y @x @y + @'2 (x, y) @'3 (x, y) @'3 (x, y) v2 + u3 + v3 @x @y @x
Da quanto appena dimostrato risulta evidente che scelti tre nodi per ogni elemento triangolare, si pu` descrivere un modello di spostamenti lineare, dal quale consegue o uno stato di deformazione costante. Anche la distribuzione di sforzi che ne risulta sar` a costante in ogni singolo elemento. Infatti, sulla base di quanto detto precedentemente a proposito dello stato piano di sforzo, ` possibile ricavare le sollecitazioni di ogni e elemento con una semplice moltiplicazione matriciale: = D 8 < : 9 x=
y
xy
Quindi per ogni singolo elemento vale lequazione: = DBu
8 > 1 E 2 <
E
>1 : 0
E 1 2 E 1 2
98 9 > < x = = y E >: ; xy ; 2(1+) 0 0
Quanto sin qui visto pu` essere applicato anche per scrivere lequazione di equilibrio o di un elemento nito dopo lapplicazione dei carichi. Lenergia di deformazione che viene immagazzinata ` pari a e Z Z = 0.5 T dV ricordando che = DBu e che (Bu)T = uT BT possiamo scrivere Z= Z
dove B ` la matrice delle derivate delle funzioni di forma: e 8 @' (x,y) @'2 (x,y) @'3 (x,y) > 1 0 0 < @x @x @x @'1 (x,y) @'2 (x,y) 0 0 0 B= @y @y > @'1 (x,y) @'1 (x,y) @'2 (x,y) @'2 (x,y) @'3 (x,y) :
@x @y @x @y @x
@'3 (x,y) @y ; @'3 (x,y) > @y
9 > =
0.5uT ( e
BT DB dV )ue
1.2.3
Meshing
Una volta scelta la formulazione ed il tipo di elemento nito, ` necessario dividere la e struttura in parti o elementi niti. Per la discretizzazione ` opportuno seguire alcune e regole di base: elementi quadrati o triangoli equilateri sono da preferire ad elementi di forma allungata o irregolare; nelle zone in cui si prevede una variazione signicativa dello stato tensionale ` e bene ridurre la dimensione degli elementi e, conseguentemente, aumentarne il numero; per valutare la convergenza del procedimento ` necessario eettuare la stessa e analisi con discretizzazioni via via pi` ra nate. u Il meshing delle strutture analizzate nel programma ` ottenuto sfruttando un e sotto-programma sviluppato al DINMA dellUniversit` di Trieste. Esso si basa sulla a decomposizione di Voronoi e sulla successiva triangolazione di Delaunay: il pezzo da analizzare viene suddiviso in porzioni di spazio delle dimensioni suggerite dallutente, individuando cos` una serie di piccoli domini il cui baricentro diventer` un nodo a della discretizzazione. Unendo tutti i nodi si ottengono gli elementi triangolari.
Figura 1.4: Discretizzazione mediante decomposizione di Voronoi In gura 1.4 ` visibile in rosso il reticolo relativo alla decomposizione di Voronoi e mentre in nero ` rappresentata la suddivisione di Delaunay. e Come ` possibile notare inoltre dalla gura 1.5, questo tipo di discretizzazione pere mette di ottenere elementi abbastanza regolari, necessari per giungere ad una soluzione realistica. Variando inoltre i parametri di input ` possibile ottenere inttimenti nelle e zone desiderate.
Figura 1.5: Elementi di dimensioni dierenti in relazione al gradiente di sforzo
1.2.4
Propriet` dei materiali a
Dopo aver denito la struttura geometrica del problema occorre attribuire ad ogni elemento le corrette propriet` siche. Esse risultano fondamentali in qualunque tipo a di analisi, soprattutto nel caso in cui si debba analizzare il comportamento di due componenti solidali tra loro, ma composti di materiali diversi: si rende necessario denire le propriet` deformative di ogni materiale ed attribuirle a ciascun elemento. a Nel caso dello stato piano di sforzo i soli parametri necessari sono il modulo di Young ed il coe ciente di Poisson.
1.2.5
Matrice di rigidezza
Una volta in possesso dei dati geometrici e delle propriet` siche degli elementi, ina dipendentemente dalla presenza di vincoli o carichi, ` possibile determinare la matrice e di rigidezza K della lastra oggetto dellanalisi. I passi da eettuare sono concettualmente due: ` necessario calcolare le matrici di rigidezza di ogni elemento e successie vamente assemblarle in quella globale che tenga conto della eettiva dislocazione dei nodi e delle mutue inuenze che gli elementi esercitano fra loro. La tipica matrice di rigidezza del triangolo CST ` una matrice quadrata di dimensione 6 x 6. Essa, infatti, e deve rappresentare in maniera e cace la risposta allo spostamento dei tre nodi con due gradi di libert`. Ad essa si perviene calcolando il seguente integrale: a ke = Z BT De Be dV e
Ve
dove B e D sono le matrici denite nei precedenti paragra. Nel caso in cui la discretizzazione sia composta da elementi uguali nella formulazione ma di diverse dimensioni, si render` necessario per ognuno il calcolo della a matrice di rigidezza. La fase successiva consiste nellassemblare le singole matrici. Nel caso piano di elementi triangolari a tre nodi - quindi con matrici 6 x 6 - occorre dividere la matrice in sottomatrici 2 x 2 andando ad individuare cos` nove blocchetti. 8 >k11 > >k > 21 > > < k31 ke = >k41 > > >k51 > > : k61 k12 k22 k32 k42 k52 k62 k13 k23 k33 k43 k53 k63 k14 k24 k34 k44 k54 k64 k15 k25 k35 k45 k55 k65 9 k16 > > > k26 > > > = k36 k46 > > > > k56 > > ; k66
Considerando lelemento generico in gura, possiamo far corrispondere i vari blocchi ai vari nodi: 8 <k11 ke = k21 : k31 9 k13 = k23 ; k33 k11 = k11 k12 k21 k22 k13 k14 k23 k24
k12 k22 k32
dove
Figura 1.6: Elemento generico
k12 = e cos` via.
Questo elemento, di cui ` stata calcolata la matrice di rigidezza, probabilmente e far` parte di un insieme pi` vasto di elementi e molto probabilmente i suoi nodi a u avranno una numerazione dierente. Supponiamo quindi che lelemento si trovi nella condizione di gura 1.7.
10
La suddetta matrice andr` sparsa in a modo adeguato a seconda della posizione globale dei vari nodi. La procedura ` e schematicamente riportata in gura 1.8. Ogni blocchetto della matrice elemento compete ad un nodo che globalmente ricever` anche altri contributi, oltre a quela lo dellelemento in questione. Per questo quando si spargono le matrici elemento, esse vanno sommate a quanto gi` presente nella a posizione di destinazione.
Figura 1.7: Elemento generico
Figura 1.8: Assemblaggio della matrice
1.2.6
Rinumerazione dei nodi
Nei software di calcolo avanzati sono presenti algoritmi atti a velocizzare il calcolo della matrice di rigidezza e la sua memorizzazione. Essa, infatti, gode di alcune particolari propriet` che consentono, con ladozione di dovuti accorgimenti, di ridurre a considerevolmente lonere computazionale: ` simmetrica; e ` semidenita positiva; e ha il determinante nullo;
11
` sparsa (ovvero ` popolata da molti termini nulli e pochi termini non nulli); e e ` in banda (ovvero i termini non nulli tendono a raggrupparsi attorno alla e diagonale principale). Gli ultimi due punti vengono largamente sfruttati dai sopracitati algoritmi, che tendono a memorizzare solamente la zona attorno alla diagonale principale entro la quale certamente si troveranno tutti i termini non nulli. Loperazione di rinumerazione dei nodi viene eettuata facendo uso di criteri presi dalla teoria dei gra, e lo sforzo computazionale in termini di tempo di calcolo ` sempre largae mente inferiore al vantaggio ottenuto in fase di soluzione del problema.
1.2.7
Attribuzione dei vincoli
Il passo successivo allassemblaggio della matrice ` la determinazione dei vincoli ai e quali ` soggetta la struttura. Nella realt` sica i vincoli possono riguardare punti, e a segmenti o superci. Nel Metodo degli elementi niti e in particolare nei problemi analizzati in questa tesi, i vincoli riguardano solamente i nodi. Pi` generalmente, per u simulare particolari situazioni di vincolo possono essere utilizzati altri tipi di elementi niti i cui nodi andranno vincolati secondo precise modalit`. In ogni caso il concetto a di vincolo resta strettamente applicato solo ai nodi.
1.2.8
Attribuzione dei carichi
Le azioni che insistono su una qualunque struttura possono essere di vario tipo: possono essere forze o coppie applicate direttamente a punti della struttura ove sono presenti i nodi (forze nodali), oppure possono essere forze o coppie applicate in punti interni o di bordo di un elemento nito. In questultimo caso si rende necessaria la denizione di un metodo che consenta di pervenire alle cosiddette forze nodali equivalenti. Esso pu` o Figura 1.9: Elemento caricato
12
essere ottenuto sfruttando il medesimo modello di spostamento utlizzato per la costruzione delle funzioni di forma. Si consideri lesempio in gura. Lobiettivo ` e quello di rendere il carico distribuito agente sul lato 13 pari ai carichi equivalenti nodali. Il modello di spostamento utilizzato sar`: a 8 > > > u(x, y) = > > > < > > > > > > : 8 9 <u1 = u2 ! u (x, y) : ; 8 u39 <v1 = v(x, y) = v (x, y) v2 ! : ; v3
u (x, y)
= ['1 (x, y), '2 (x, y), '3 (x, y)] = ['1 (x, y), '2 (x, y), '3 (x, y)]
v (x, y)
Il vettore dei carichi equivalenti nodali sar`: a 8 9 <P1 = Z 3 P2 = : ; 1 P3 8R 3 < 1 :R 3

1
T v (x, y) py (s)ds
Quindi lungo il lato 13 sar`: a
8 9 <P1 = 0 = 0 : ; T p (s)ds; P3 3 (x, y) y

T 1 (x, y) py (s)ds=
8 9 <v1 = v1,3 (x, y) = v (x, y) 0 = '1 (x, y) v1 + '3 (x, y) v3 : ; v3 8 9 < v1 = 0 v1,3 (x, y) = v (x, y) = '1 (x, y) v1 + '3 (x, y) v3 : ; v3 Applicando il Principio dei Lavori Virtuali: Z
3
py (s) v1,3 ds = P1 v1 + P3 v3 Z
3
py (s) v1,3 ds = Z
3
py (s) ['1 (x, y) v1 + '3 (x, y) v3 ] ds Z

3
P1 v1 + P3 v3 = = Z
'1 (x, y) py (s) v1 ds +
'3 (x, y) py (s) v3 ds =
py (s) ['1 (x, y) v1 + '3 (x, y) v3 ] ds
come volevasi dimostrare.
13
1.2.9
Assemblaggio del sistema risolvente
Lassemblaggio ` il procedimento che comprende la creazione della matrice di rigidezza e globale [come visto prima] e che completa i vettori termine noto della parte dovuta ai carichi. Esistono vari approcci per spiegare il signicato di tale operazione. Ne descriviamo due: lapproccio statico e lapproccio energetico. Nellapproccio statico lassemblaggio ` il procedimento che computa e somma, nodo e per nodo, le forze che provengono al nodo stesso a causa del movimento degli altri nodi ed a causa dei carichi applicati. Il singolo termine Kij della matrice di rigidezza globale ` uguale alla forza che occorre esercitare in direzione del grado di libert` i a e a causa dellesistenza di un valore unitario di spostamento del grado di libert` j. Se a il nodo associato al grado di libert` i appartiene ad elementi che non sono connessi a in alcun modo al nodo associato al grado di libert` j, allora Kij = 0. Questo caso ` a e molto frequente, ed infatti la matrice K ` in generale ricca di termini nulli. La somma e di tutte le forze agenti sul grado di libert` i, a causa del movimento dei nodi ` data a e da Ri = j Kij uj dove la sommatoria ` estesa a tutti i gradi di libert` della struttura. Sia poi qi la e a somma delle azioni sul grado di libert` i. Perch` vi sia equilibrio lazione deve essere a e uguale e contraria alla reazione, ovvero: Ri = q i e quindi occorre risolvere il sistema, che ha per incognite gli n spostamenti ui j Kij uj = qi Nellapproccio energetico lassemblaggio ` sostanzialmente visto come il procedimene to che somma i contributi di ciascun elemento allenergia di deformazione elastica, ed al potenziale dei carichi. In eetti lenergia di deformazione dellintera struttura ` data dalla somma delle energie di deformazione dei pezzi di cui ` composta, e ci` e e o ` semplicemente in base alla propriet` additiva degli integrali. Ognuno dei contribue a ti Ze allenergia di deformazione totale viene espresso in funzione del vettore degli spostamenti nodali incogniti: 1 Ze = uT Ke u 2 dove u ` il vettore degli spostamenti incogniti, di dimensione n, e il generico elemento e e Ke la matrice di rigidezza del singolo elemento. Lenergia di deformazione per
14
lintera struttura diventa Z= X1

e
1 uT Ke u = uT K u 2 2
Analogo principio vale per il potenziale dei carichi: X W= uT qe = uT q

e
Impiegando il principio di stazionariet` dellenergia potenziale totale a Y =Z W
, dove
si vede che tale principio ` soddisfatto se ` vero che u soddisfa lequazione e e matriciale Ku=q
Figura 1.10: Struttura esempio Al ne di applicare praticamente quanto esposto procediamo con lanalisi della struttura in gura 1.10. Le matrici di rigidezza dei singoli elementi verranno schematizzate con simboli (rappresentanti blocchetti di dimensione 2 x 2). Lassemblaggio della matrice di rigidezza porter` a dislocare e sommare queste a quattro matrici in una pi` grande di dimensione 12 x 12. Il risultato ` visibile in gura u e 1.11.
15
Figura 1.11: Matrice di rigidezza assemblata ` E possibile notare come la matrice sia disposta in banda, nel senso che gli elementi signicativi si addensano lungo la diagonale principale. Si evince anche come la dierenza massima tra i numeri dei nodi del singolo elemento inuenzi la compattezza di questa banda. Il vettore dei carichi equivalenti nodali viene assemblato analogamente alla matrice di rigidezza. Nella gura 1.12 ogni simbolo rappresenta un sub-vettore di dimensione 2 in quanto sono presenti 6 nodi che possono essere caricati in 2 direzioni.
Figura 1.12: Vettore dei carichi assemblato La lastra avr` quindi il seguente vettore dei carichi: a
16
1 1 2 Q = vX vY vX 0 0 0 0 0 P 0 P 0
Il sistema K U = Q non ` ancora risolvibile in quanto la struttura ` labile. e e Occorre quindi annullare nel vettore degli spostamenti incogniti quelle componenti di spostamento impedite dai vincoli. Nel nostro caso sar`: a U = {0 0 0 v2 u3 v3 u4 v4 u5 v5 u6 v6 }T
essendo u1 = v1 = u2 = 0. I due vettori, U e Q, sono completi ma non ordinati. Per pervenire alla soluzione ` infatti necessario un ulteriore riordino che individui un sotto-sistema relativo agli e spostamenti dei soli nodi non vincolati. Oltre a queste ` necessario eseguire operazioni e di permutazione anche sulla matrice di rigidezza, al ne di assicurare la congruenza con il sistema iniziale. Il vettore U diventer` a U = {v2 u3 v3 u4 v4 u5 v5 u6 v6 0 0 0}T Ovvero si passa dalla situazione U = {V V V L L L L L L L L L}T alla situazione U = {L L L L L L L L L V V V }T Dove per V si intendono nodi vincolati e con L nodi non vincolati. Lo stesso si far` sul vettore Q: a
1 1 2 Q = 0 0 0 0 0 P 0 P 0 vX vY vX T
Il risultato delle operazioni di riordino porter` quindi ad individuare due sottoa vettori distinti: L L U Q U= Q= V U QV Mentre le operazioni di permutazioni di righe e colonne della matrice di rigidezza portano alla determinazione di quattro sotto-matrici: LL K KLV K= KV L KV V Il sistema risolvente sar` quindi: a
17
KLL KLV KV L KV V
UL UV
QL QV
Svolgendo il sistema si ottengono le due seguenti equazioni matriciali disaccoppiate: KLL UL + KLV UV = QL KV L UL + KV V UV = QV
dalla prima equazione matriciale si ottiene KLL UL = QL KLV UV
con KLL simmetrica, in banda, denita positiva e quindi invertibile; QL sottovettore dei carichi applicati; KLV UV vettore dei carichi nodali ttizzi, normalmente nullo a meno di eventuali cedimenti vincolari. La soluzione cercata risulta quindi: UL = KLL
1
QL
KLV UV
Ottenuto in questo modo lintero campo di spostamenti, si possono ricavare le reazioni vincolari QV dalla seconda equazione del sistema: QV = KV L UL + KV V UV Noto il campo degli spostamenti ue (x, y) = (x, y) ue si ottiene il campo delle deformazioni (x, y) = Bue ed il campo degli sforzi (x, y) = D(x, y). La soluzione della struttura sar` in genere approssimata, a meno che la discretizzazione adottata a e la nezza dellelemento sia tale da poter seguire lo schema di carico. Nellesempio descritto si annulla il termine KLV UV in quanto non si hanno cedimenti di vincolo, e la soluzione del problema `: e UL = KLL
1
QL
1.2.10
Risoluzione del sistema lineare
Nellapprocciarsi al sistema risolvente, in genere non si inverte mai esplicitamente KLL ma si adottano metodi computazionali pi` e cienti quale ad esempio il metodo di u Gauss. La tecnica delleliminazione risolve il sistema di equazioni lineari attraverso la riduzione della matrice. Posto un generico sistema di equazioni lineari:
18
il sistema viene sostituito con uno equivalente che ammette lo stesso vettore soluzione. Se k11 6= 0 e dalla seconda equazione si sottrae la prima moltiplicata per (1) (1) m21 = k21 /k11 , dalla terza equazione si sottrae la prima moltiplicata per m31 = (1) k31 /k11 , dalla quarta equazione si sottrae la prima moltiplicata per m41 = k41 /k11 , il sistema diventa: 8 > > < > > :
k11 u1 + 0u1 + 0u1 + 0u1 + [k22 [k32 [k42 k12 u2 +
(1) m21 k12 ]u2 + (1) m31 k12 ]u2 + (1) m41 k12 ]u2 +
8 > k11 u1 + k12 u2 + k13 u3 + k14 u4 > < k21 u1 + k22 u2 + k23 u3 + k24 u4 > k31 u1 + k32 u2 + k33 u3 + k34 u4 > : k41 u1 + k42 u2 + k43 u3 + k44 u4
= q1 = q2 = q3 = q4
k13 u3 + [k23 [k33 [k43

(1) m21 k13 ]u3 + (1) m31 k13 ]u3 + (1) m41 k13 ]u3 +
k14 u4 [k24 [k34 [k44

(1) m21 k14 ]u4 (1) m31 k14 ]u4 (1) m41 k14 ]u4
= = = =
q1 [q2 m21 q1 ] [q3 m31 q1 ] [q4 m41 q1 ]

(1) (1) (1)
Il sistema in basso a destra presenta unincognita in meno, poich ` avvenuta e e (2) leliminazione dellincognita u1 . Ora si ripete il procedimento ammesso che k22 6= 0: (2) (2) (2) dalla terza equazione si sottrae la seconda moltiplicata per m32 = k32 /k22 , dalla (2) (2) (2) quarta equazione si sottrae la seconda moltiplicata per m42 = k42 /k22 . 8 > > < > > :
k11 u1 + 0u1 + 0u1 + 0u1 + k12 u2 +
(2) k22 u2 +
Per maggiore sintesi si pu` riscrivere il sistema come: o 8 > k11 u1 + k12 u2 + k13 u3 + k14 u4 > > < 0u + k (2) u + k (2) u + k (2) u 1 22 2 23 3 24 4 (2) (2) (2) > 0u1 + k32 u2 + k33 u3 + k34 u4 > > : (2) (2) (2) 0u1 + k42 u2 + k43 u3 + k44 u4
= q1 (2) = q2 (2) = q3 (2) = q4
k13 u3 +
(2) k13 u3 + (2) (2) (2) [k33 m32 k23 ]u3 + (2) (2) (2) [k43 m42 k23 ]u3 +
k14 u4
(2) k14 u4 (2) (2) (2) [k34 m32 k24 ]u4 (2) (2) (2) [k44 m42 k24 ]u4
= = = = [q3 [q4
(2) (2)
q1 q2
(2) (2) (2) (2) (2)
0u2 + 0u2 +
m32 q2 ] m42 q2 ]
Riscrivendo il sistema come 8 > k11 u1 + k12 u2 + k13 u3 + k14 u4 > > < 0u + k (2) u + k (2) u + k (2) u 1 22 2 23 3 24 4 (3) (3) > 0u1 + 0u2 + k33 u3 + k34 u4 > > : (3) (3) 0u1 + 0u2 + k43 u3 + k44 u4
= q1 (2) = q2 (3) = q3 (3) = q4
19
` possibile notare come il sistema in basso a destra presenti due incognite in meno e (3) poich ` avvenuta leliminazione delle incognite u1 e u2 . Di nuovo, se k33 6= 0 dalla ee (3) (3) (3) quarta equazione si sottrae la terza moltiplicata per m43 = k43 /k33 . 8 k14 u4 > k11 u1 + k12 u2 + k13 u3 + > > (2) (2) (2) < 0u + k u + k u + k14 u4 1 22 2 13 3 (3) (3) > 0u1 + 0u2 + k33 u3 + k34 u4 > > : (3) (3) (3) 0u1 + 0u2 + 0u3 + [k44 m43 k34 ]u4 = q1 (2) = q2 (3) = q3 (3) (3) (3) = [q4 m43 q3 ]
Il sistema ottenuto ammette le stesse soluzioni del sistema originario, con il vantaggio di ricavare il vettore incognito U, grazie al metodo della sostituzione allindietro. Infatti, a partire dallultima equazione si determina direttamente u4 , che nelle precedenti equazioni viene sostituita. A questo punto ` ricavabile direttamente u3 , che e viene inserita nella prima e nella seconda equazione. Dalla seconda si ricava u2 che, inserita nella prima equazione, porta alla determinazione immediata di u1 . La matrice iniziale dei coe cienti pu` essere ricavata anche come prodotto di una matrice triano golare inferiore moltiplicata per il prodotto di una matrice triangolare superiore della fattorizzazione di Gauss. K = MW con 8 0 0 > 1 > (1) > <m 1 0 21 M= (1) (2) >m31 m32 1 > > (1) : (2) (3) m41 m42 m43 9 0> > > 0= 0> > > ; 1 8 9 >k11 k12 k13 k14 > > > > < 0 k (2) k (2) k (2) > = 22 23 24 W = (3) (3) > 0 0 k33 k34 > > > > > : (4) ; 0 0 0 k44
riscritta come: 8 > k11 u1 + k12 u2 + k13 u3 + k14 u4 > > < 0u + k (2) u + k (2) u + k (2) u 1 22 2 23 3 24 4 (3) (3) > 0u2 + k33 u3 + k34 u4 > 0u1 + > : (4) 0u1 + 0u2 + 0u3 + k44 u4
= q1 (2) = q2 (3) = q3 (4) = q4
20
Capitolo 2
Ambiente di sviluppo
2.1 Linguaggio di programmazione
La scelta di un appropriato linguaggio di programmazione ` uno dei fattori determie nanti per il buon esito di qualunque progetto informatico. Il tipo di applicazione che si sta sviluppando, la piattaforma su cui poi andr` ad operare, la velocit` di calcolo a a richiesta e la modalit` di input dei dati sono solo alcune delle doverose considerazioni a che si devono fare prima di iniziare lo sviluppo. Lapplicazione oggetto di questa tesi ` stata sviluppata in C# (pronunciato c sharp), e un linguaggio di programmazione object-oriented sviluppato da Microsoft a partire dal 2002. Nella sintassi del C# sono riconoscibili costrutti mutuati da Delphi, Java, C++ e Visual Basic. C# ` stato sviluppato nellambito delliniziativa .NET Framework e e possiamo dire che questo linguaggio sia quello che meglio degli altri descrive le linee guida di questo progetto. .NET (pronunciato dotnet) ` un progetto allinterno del e quale Microsoft ha creato una piattaforma di sviluppo software, corredata da una serie di strumenti di sviluppo delle applicazioni, progettati per funzionare in modo integrato allinterno della piattaforma stessa.
2.2
.NET Framework
.NET Framework ` un componente integrante del sistema operativo Windows ed ` e e progettato per ottenere gli obiettivi indicati di seguito: fornire un ambiente di programmazione orientato agli oggetti; fornire un ambiente di esecuzione del codice che minimizzi i conitti di versioni;
21
rendere coerente lesperienza dello sviluppatore attraverso tipi molto vari di applicazioni; generare tutte le comunicazioni in base agli standard industriali per assicurare che il codice basato su .NET Framework possa integrarsi con qualsiasi altro codice. .NET Framework presenta due componenti principali: Common Language Runtime e la libreria di classi .NET Framework. Common Language Runtime rappresenta la base di .NET Framework e pu` essere considerato come un agente che gestisce il o codice in fase di esecuzione, fornendo servizi di base quali gestione della memoria, gestione di thread e servizi remoti.
Figura 2.1: Struttura del Framework .NET La libreria di classi, laltro componente principale di .NET Framework, ` un ine sieme completo orientato agli oggetti di tipi riutilizzabili che possono essere impiegati nello sviluppo delle applicazioni, da quelle tradizionali della riga di comando a quelle con interfaccia utente graca (GUI, Graphical User Interface). In Figura 2.1 viene mostrata la relazione di Common Language Runtime e libreria di classi con le applicazioni e con lintero sistema. Si pu` inoltre notare come opera il codice gestito, o allinterno di unarchitettura pi` ampia. Il progetto .NET comprende inoltre un Comu pact Framework per la programmazione su dispositivi Windows Mobile o Windows
22
2.3 IDE SharpDevelop
CE e un Micro Framework per la programmazione di microcontrollori tramite codice gestito.
2.3
IDE SharpDevelop
Per lo sviluppo dellintera applicazione si ` utilizzato SharpDevelop1 , un IDE (intee grated development environment) gratuito e open source per i linguaggi di programmazione C#, Visual Basic .Net (VB.NET), Boo, F# e IronPython. Esso ` tipicamente e usato come alternativa a Visual Studio .NET della Microsoft. Le sue principali caratteristiche sono: un designer di Windows Forms per C#, VB.NET e Boo; debugger integrato; code completion per C#, VB.NET e Boo; un convertitore C# / VB.NET; completamente scritto in C#; supporto ai template del codice; facilmente estendibile con tool esterni; facilmente estendibile con plug-in; interfaccia tradotta in svariate lingue, tra cui litaliano.
2.4
EasyMesh
Per la discretizzazione delle geometrie, al ne di garantire una pi` ampia variet` di problemi analizzabili, si ` utiu a e lizzato un sotto-programma sviluppato dal Dipartimento di Ingegneria Navale, del Mare e per lAmbiente dellUniversit` di Trieste. EasyMesh2 [Unstructured 2D Grid a Generation] ` stato sviluppato da Bojan Niceno grazie al e Consortium for International Development of the University of Trieste e consente, tramite linserimento delle
1 2
http://www.icsharpcode.net/OpenSource/SD/ http://www-dinma.univ.trieste.it/nirftc/research/easymesh/
Figura 2.2: EasyMesh
23
coordinate e dei segmenti in un le di testo, di ottenere la tabella delle coordinate e la tabella delle incidenze per ogni tipo di geometria bidimensionale. Queste tabelle possono poi essere agevolmente caricate in memoria leggendo i le di output. Il principio su cui si basa ` quello della decomposizione di Voronoi3 , a seguito della quale e il programma assembla i triangoli della discretizzazione. Nellinput della geometria ` e possibile, inoltre, aumentare la densit` della discretizzazione in singoli punti o aree a del pezzo, cos` da produrre una mesh pi` tta nelle zone dove si ci saranno elevati u gradienti di sforzo. In seguito verranno trattate ampiamente le modalit` duso in a modo da permettere allutente il corretto inserimento di qualunque tipo di geometria.
2.5
Math.NET
Per quanto riguarda la risoluzione ottimizzata dei problemi di algebra lineare che si presentano in qualunque problema agli elementi niti, si ` utilizzata una libreria sviluppata e ad hoc per C#: Math.NET. Scaricabile gratuitamente dal sito mathdotnet.com, Math.NET ` un progetto open source che consente di risolvere diversi problemi: e algebra lineare; modelli di probabilit`; a interpolazioni; calcolo integrale; digital signal processing; ...
un particolare tipo di decomposizione di uno spazio metrico determinata dalle distanze rispetto ad un determinato insieme discreto di punti
24
2.6 Open Cascade
2.6
Open Cascade
La visualizzazione graca dei risultati ottenuti ` stata a data ad un ambiente CAD e opensource: Open Cascade. Questo ambiente, scritto in C++, ` stato portato e anche in C# grazie al lavoro di un gruppo di sviluppatori, nellambito del progetto NaroCAD: si tratta di un software cad open source scritto in C# ma basato appunto su Open Cascade. Nel software oggetto di questa tesi si ` utilizzata la stessa libreria e che il team di NaroCAD ha utilizzato per sviluppare il proprio software.
25
26
Capitolo 3
Analisi del codice

In questo capitolo si analizzeranno gli algoritmi che sono stati sviluppati al ne pervenire alla soluzione del problema, descrivendone il loro funzionamento tramite il seguente esempio pilota:
Figura 3.1: Esempio pilota Si tratta di una lastra rettangolare che verr` vincolata e caricata con uno schema a a mensola. Il dominio verr` discretizzato con una maglia molto grande, al ne di a rendere riportabili i vari output numerici che fornir` il programma. a
3.1
Organizzazione del progetto
Il progetto, contenuto nel CD-ROM allegato, ` compatibile con Microsoft Visual Stue dio 2008 e con Sharp Develop. La Figura 3.2 mostra come esso sia stato strutturato.
27
Analisi del codice
Figura 3.2: Struttura del progetto Le quattro cartelle si riferiscono ognuna a quattro dierenti progetti che assolvono a funzioni diverse. Al ne di non appesantire troppo leseguibile principale si ` optato e per a dare alcuni compiti quali il montaggio della matrice di rigidezza e la risoluzione del sistema lineare a librerie sviluppate separatamente.
3.1.1
Thesis
Thesis ` il progetto principale dal quale si ottiene leseguibile e che gestir` tutto il processo di analisi. Ad esso sono infatti a a dati i compiti di: lettura dellinput utente; visualizzazione graca dei risultati; comunicazione con le altre librerie; produzione del rapporto di analisi. Come ` possibile desumere dalle funzioni svolte, questo ` un programma di base, e e privo della maggior parte degli algoritmi di signicato sico. Questi ultimi sono stati implementati separatamente in modo da evitare una monoliticit` del software che a avrebbe portato a rallentamenti e instabilit`. Dato il carattere gestionale di tale a programma ` lecito aspettarsi che esso rimanga attivo durante tutta lanalisi e che e venga richiamato altenativamente a librerie pi` speciche. u
3.1.2
Kmatrix
Il progetto kmatrix ha come scopo nale quello di memorizzare la matrice di rigidezza globale della lastra oggetto dellanalisi. Le fasi sono: 1. ricognizione della posizione dellelemento;
28
3.2 Geometria e discretizzazione
2. calcolo delle matrici B, BT e D; 3. calcolo dellarea degli elementi; 4. moltiplicazione delle matrici per ottenere KE ; 5. assemblaggio della matrice principale. Tutte queste fasi verranno descritte in seguito in maggior dettaglio.
3.1.3
Calc
Calc permette invece la risoluzione del sistema lineare, la ricostruzione dei vettori spostamento e il conseguente calcolo delle sollecitazioni.
3.2
Geometria e discretizzazione
Allavvio il programma presenta nella parte destra la zona dedicata allinput di dati e comandi, mentre nella parte centrale-sinistra ` presente il modulo CAD che visuale izzer` quanto elaborato. a La prima operazione dellanalisi consiste nella denizione della geometria della lastra. Le misure devono essere inserite nellapposita text box alla sezione Geometria. La discretizzazione viene gestita dal sotto-programma EasyMesh, quindi le coordinate andranno inserite nelle modalit` da esso previste. a EasyMesh necessita di due serie di dati: 1. Coordinate dei punti (siano essi punti di bordo esterni o di fori interni) seguite dal fattore di discretizzazione e dal numero identicativo del pezzo; 2. Specicazione dei segmenti. Chiariamo subito il concetto con lesempio pilota. Volendo inserire nel programma la lastra indicata a inizio capitolo, con il sistema di riferimento di gura, ` necessario anzitutto specicare le coordinate dei quattro e punti che la delimitano:
29
Analisi del codice
0 1 2 3
X 0 100 100 0
Y 0 0 50 50
La numerazione dei punti parte da 0 ed ` antioraria per i punti di bordo e oraria e per i fori interni. La stringa tipica accettata da EasyMesh segue la seguente sintassi: numero_nodo: coordinata_X coordinata_Y fattore_discr ID_pezzo Quindi nel nostro caso il primo nodo verr` inserito con la seguente riga: a 0: 0 0 25 1 dove 25 rappresenta la misura in millimetri della ttezza della discretizzazione e 1 ` un fattore identicativo del pezzo1 . e Completando la serie: 0: 1: 2: 3: 0 0 25 1 100 0 25 1 100 50 25 1 0 50 25 1
La seconda serie di dati richiesta contiene la specicazione dei segmenti e avviene con la seguente modalit`: a numero_segmento: primo_punto secondo_punto ID_pezzo ovvero bisogna specicare al programma quale sia punto iniziale e quale quello nale. Nel nostro caso il primo segmento si inserir` cos` a : 0: 0 1 1 per il numero identicativo del pezzo valgono le considerazioni fatte pocanzi. La seconda serie completa sar` quindi: a
Va detto che il programma ` in grado di gestire la discretizzazione di pi` pezzi contemporaneae u mente, cosa che non ` stata implementata nellanalisi, perci` lidenticativo del pezzo sar` sempre e o a 1.
1
30
3.2 Geometria e discretizzazione
0: 1: 2: 3:
0 1 2 3
1 2 3 0
1 1 1 1
Prima di ogni serie di dati il programma richiede di inserire un numero indicante di quanti elementi ` composta la singola serie. Nel nostro caso, dato che sono presenti e quattro punti e quattro segmenti, il numero da inserire sar` 4. a Linput completo ` il seguente: e 4 0: 1: 2: 3: 4 0: 1: 2: 3:
0 0 25 1 100 0 25 1 100 50 25 1 0 50 25 1
0 1 2 3
1 2 3 0
1 1 1 1
Una volta riportate le istruzioni nellapposito box, al click sul pulsante Importa, il programma produce a video la lastra discretizzata come in Figura 3.3.
Figura 3.3: Lastra discretizzata
31
Analisi del codice
Esso ha inoltre memorizzato la tabella delle coordinate dei nodi e la tabella delle incidenze. Quando viene premuto il pulsante Importa il programma richiama il seguente metodo:
void Btn importClick ( o b j e c t sender , EventArgs e ) { s t r i n g S t r T e s t o = t e x t B o x i n p u t . Text ; F i l e . W r i t e A l l T e x t ( DISCR . D , S t r T e s t o ) ; System . D i a g n o s t i c s . P r o c e s s S t a r t I n f o p = new System . D i a g n o s t i c s . P r o c e s s S t a r t I n f o ( d i s c r . b a t ) ; System . D i a g n o s t i c s . P r o c e s s p r o c = new System . D i a g n o s t i c s . P r o c e s s ( ) ; proc . S t a r t I n f o = p ; proc . Start ( ) ; proc . WaitForExit ( ) ; ... }
Ovvero viene copiato il contenuto della textBox_input nel le di testo DISCR.D e viene lanciato il programma discr.bat che non fa altro che inizializzare ad EasyMesh il le di input appena creato. Il sistema attende poi che il programma elabori una discretizzazione e produca i le di output.
La gura illustra il funzionamento input-output di EasyMesh. La fase successiva consiste nella ricognizione di quanto prodotto. Vengono prodotti tre le di testo contenenti informazioni distinte: DISCR.N contiene la tabella delle coordinate dei nodi; DISCR.E contiene la tabella delle incidenze; DISCR.S contiene altre informazioni. Nel nostro esempio la discretizzazione consta di 18 nodi e 22 elementi. Il programma ha prodotto la seguente tabella delle coordinate:
32
3.3 Matrice di rigidezza
--0: 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17:
X ---------------------1.499998377077279e+001 0.000000000000000e+000 2.500000000000000e+001 0.000000000000000e+000 3.499999708541389e+001 1.499998377077279e+001 5.000000000000000e+001 0.000000000000000e+000 2.500000000000000e+001 6.500000291458612e+001 5.000000000000000e+001 7.500000000000000e+001 7.500000000000000e+001 8.500001622922721e+001 8.500001622922721e+001 1.000000000000000e+002 1.000000000000000e+002 1.000000000000000e+002
Y ---------------------1.666646780405902e+001 0.000000000000000e+000 0.000000000000000e+000 2.500000000000000e+001 2.499978948356020e+001 3.333313532405902e+001 0.000000000000000e+000 5.000000000000000e+001 5.000000000000000e+001 2.499978948356020e+001 5.000000000000000e+001 0.000000000000000e+000 5.000000000000000e+001 1.666646780405902e+001 3.333313532405902e+001 0.000000000000000e+000 5.000000000000000e+001 2.500000000000000e+001
ID -0 1 1 1 0 0 1 1 1 0 1 1 1 0 0 1 1 1
e la seguente tabella delle incidenze:

--0: 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: N1 -0 0 0 0 4 4 5 4 6 5 8 9 6 9 9 14 14 13 14 13 13 14 N2 -1 3 2 5 5 2 7 8 9 8 4 10 11 12 11 12 9 11 16 17 15 17 N3 -2 1 4 3 0 6 3 5 4 7 10 4 9 10 13 9 13 15 12 14 17 16
3.3
Matrice di rigidezza
Come gi` accennato sopra, il calcolo della matrice di rigidezza ` a dato alla libreria a e kmatrix.dll. Essa viene richiamata dalla sezione Materiali alla pressione del tasto
33
Analisi del codice
Applica. Pi` precisamente, quando viene cliccato il pulsante, vengono eseguite le u seguenti istruzioni:
void B t n a p p l i c a M a t e r i a l e C l i c k ( o b j e c t sender , EventArgs e ) { s t r i n g combo = C o n v e r t . T o S t r i n g ( c o m b o B o x M a t e r i a l e . S e l e c t e d I t e m ) ; i f ( combo == A c c i a i o ) { G l o b a l s . modEl = 2 0 0 0 0 0 ; Globals . poisson = 0.33; } kmatrix . r i g i d e z z a . Kel ( ) ; k m a t r i x . r i g i d e z z a . Kmatr ( ) ; }
In sintesi: 1. viene riconosciuto il materiale selezionato; 2. se ne memorizzano i parametri caratteristici; 3. si richiama il metodo per costruire le matrici di rigidezza di ogni singolo elemento; 4. si richiama il metodo per assemblare la matrice di rigidezza globale.
3.3.1
La matrice di rigidezza elemento
Analizzando in dettaglio il contenuto del le kmatrix.cs 2 ` possibile noe tare come la prima parte del metodo kmatrix.rigidezza.Kel() sia dedicata alla ricognizione della posizione dellelemento. Si rende necessario, infatti, calcolare le coordinate dei vertici di ciascun elemento in un sistema di riferimento locale che consenta un calcolo pi` agevole della u matrice di rigidezza. Le coordinate che vanno calcolate Figura 3.4: Sistema di riferimento locale saranno quindi solamente le x2 , x3 , y3
2
File sorgente della libreria kmatrix.dll
34
dato che x1 = y1 = y2 = 0 Occorre operare una trasformazione dal sistema di riferimento globale a quello locale. Per trovare, ad esempio, il punto 3 sar` su ciente risolvere: a x3 X3 X1 =R y3 Y3 Y1 dove R ` la nota matrice di trasformazione cos` costituita: e cos sen R= sen cos Una volta note, le tre coordinate vengono memorizzate nel vettore Gl.tcl[,]3 che conter` tante righe quanti sono gli elementi della discretizzazione e tre colonne: a nella prima colonna ( Gl.tcl[x,0] ) verranno memorizzati i valori di x2 , nella seconda ( Gl.tcl[x,1] ) le x3 e nella terza ( Gl.tcl[x,1] ) le y3 . Note le coordinate ` possibile costruire la matrice B. In accordo con quanto esposto e nel secondo capitolo si ` proceduto a derivare le funzioni di forma precedentemente e ricavate. Ricordando che: 8 @' (x,y) 9 @'2 (x,y) @'3 (x,y) > 1 0 0 0 > < @x = @x @x @'1 (x,y) @'2 (x,y) @'3 (x,y) 0 0 0 B= @y @y @y > @'1 (x,y) @'1 (x,y) @'2 (x,y) @'2 (x,y) @'3 (x,y) @'3 (x,y) > : ;
@x @y @x @y @x @y
Si calcolano le varie componenti: @'1 (x, y) @ x y x3 y 1 = 1 + = @x @x x2 y3 x2 y3 x2 @'1 (x, y) @ x y x3 y 1 x3 = 1 + = + @y @y x2 y3 x2 y3 y3 x2 y3 @'2 (x, y) @ x x3 y 1 = = @x @x x2 x2 y3 x2 @'2 (x, y) @ x x3 y x3 = = @y @y x2 x2 y3 x2 y3
3
Dove tcl sta per tabella delle coordinate locali
35
Analisi del codice
Risulter` quindi a B= 8 > < > :
@'3 (x, y) @ y = =0 @x @x y3 @'3 (x, y) @ y 1 = = @y @y y3 y3

1 x2 1 x2
1 y3 1 y3
0 + +
x3 x2 y 3 x3 x2 y 3
1 x2
0
x3 x2 y 3 x3 x2 y 3
1 x2
0 0 0
1 y3 1 > ; y3
9 0> =
Quanto n qui esposto viene implementato nel software con le seguenti istruzioni:
// Prima r i g a Bmatr [ i ,0 ,0]= (1/ G l . t c l [ i , 0 ] ) ; Bmatr [ i , 0 , 1 ] = 0 ; Bmatr [ i , 0 , 2 ] = ( 1 / G l . t c l [ i , 0 ] ) ; Bmatr [ i , 0 , 3 ] = 0 ; Bmatr [ i , 0 , 4 ] = 0 ; Bmatr [ i , 0 , 5 ] = 0 ; // Seconda r i g a Bmatr [ i , 1 , 0 ] = 0 ; Bmatr [ i , 1 , 1 ] = ( ( 1 / G l . t c l [ i , 2 ] ) ) + ( G l . t c l [ i , 1 ] / ( G l . t c l [ i , 0 ] G l . t c l [ i , 2 ] ) ) ; Bmatr [ i , 1 , 2 ] = 0 ; Bmatr [ i ,1 ,3]= ( G l . t c l [ i , 1 ] / ( G l . t c l [ i , 0 ] G l . t c l [ i , 2 ] ) ) ; Bmatr [ i , 1 , 4 ] = 0 ; Bmatr [ i , 1 , 5 ] = 1 / G l . t c l [ i , 2 ] ; // T e r z a r i g a Bmatr [ i , 2 , 0 ] = (1/ G l . t c l [ i , 0 ] ) ; Bmatr [ i , 2 , 1 ] = ( ( 1 / G l . t c l [ i , 2 ] ) ) + ( G l . t c l [ i , 1 ] / ( G l . t c l [ i , 0 ] G l . t c l [ i , 2 ] ) ) ; Bmatr [ i , 2 , 2 ] = 1/ G l . t c l [ i , 0 ] ; Bmatr [ i ,2 ,3]= ( G l . t c l [ i , 1 ] / ( G l . t c l [ i , 0 ] G l . t c l [ i , 2 ] ) ) ; Bmatr [ i , 2 , 4 ] = 0 ; Bmatr [ i , 2 , 5 ] = 1 / G l . t c l [ i , 2 ] ;
Il passo successivo consiste nella memorizzazione della stessa matrice trasposta, che verr` chiamata BTmatr[,,]. a La matrice di rigidezza del materiale D ` unica per tutti gli elementi e viene quindi e calcolata e memorizzata una volta sola. 8 9 > 1 E 2 1E 2 0 > < = E E 0 D = 1 2 1 2 > E > : 0 ; 0 2(1+)
36
Il codice per lassemblaggio della matrice D ` il seguente: e

coeff = Dmatr [ 0 , Dmatr [ 0 , Dmatr [ 0 , Dmatr [ 1 , Dmatr [ 1 , Dmatr [ 1 , Dmatr [ 2 , Dmatr [ 2 , Dmatr [ 2 , G l o b a l s . modEl / ( 1 ( Globals . poisson Globals . poisson )); 0] = coeff ; 1] = coeff Globals . poisson ; 2] = 0; 0] = coeff Globals . poisson ; 1] = coeff ; 2] = 0; 0] = 0; 1] = 0; 2 ] = c o e f f ((1 G l o b a l s . p o i s s o n ) / 2 ) ;
Il passaggio successivo per giungere alla matrice 6x6 del singolo elemento ` il e calcolo dellintegrale Z KE = BT DBdV
VE
che nel caso di elementi CST si riduce ad una semplice moltiplicazione matriciale: KE = A BT D B
Una volta moltiplicate le matrici, la risultante KE viene memorizzata in un vettore tridimensionale, nei cui piani sono memorizzate le matrici di rigidezza di ogni elemento e ogni piano contiene i 6x6 componenti. Riportiamo la matrice di rigidezza dellelemento 0:
258181,62 111879,92 -258181,62 38120,08 0 -150000 111879,92 209131,65 -111879,92 71256,01 0 -280387,66 -258181,62 -111879,92 258181,62 -38120,08 0 150000 38120,08 71256,01 -38120,08 24278,58 0 -95534,58 0 0 0 0 0 0 -150000 -280387,66 150000 -95534,58 0 375922,24
3.3.2
Assemblaggio della matrice globale
Lalgoritmo di assemblaggio consiste sostanzialmente nel dislocare correttamente i nove blocchetti della dimensione 2 x 2 secondo le modalit` viste nel paragrafo 1.2.5. a Sono state specicate, per ogni elemento delle matrici di rigidezza, le posizioni di destinazione individuate mediante la tabella delle incidenze dei nodi. Vediamo un rapido esempio con il blocchetto k11 : lelemento k11 , individuato nel programma da Kelg[0,0], andr` posizionato a nella matrice globale nella posizione kij . Lindice i viene ricavato dalla formula ((TabInc[i,0]+1)*2)-2, dove TabInc ` la tabella delle incidenze. Dato che e lelemento k11 ` un elemento diagonale, lindice j sar` uguale; e a
37
Analisi del codice
lelemento k22 , equivalente a Kelg[1,1], ` anchesso un elemento diagonale e e quindi i suoi nuovi indici i e j saranno uguali. La posizione sar` a ((TabInc[i,0]+1)*2)-1; per quanto riguarda la posizione dellelemento k12 , possiamo immaginare che avr` degli indici diversi: a i = ((TabInc[i,0]+1)*2)-2, j = ((TabInc[i,0]+1)*2)-1 ; inne la posizione di k12 , come ` facilmente intuibile, sar`: e a i = ((TabInc[i,0]+1)*2)-1, j = ((TabInc[i,0]+1)*2)-2 ;
Figura 3.5: Indici per il posizionamento ` E opportuno precisare il motivo per cui il numero del nodo contenuto in TabInc[i,0] venga aumentato di una unit`. Si immagini il caso in cui si debba dislocare un bloca chetto inerente al nodo 0. Senza quel +1 il risultato sarebbe: (0*2)-2 = 0-2 = -2. Si avrebbe cos` un indice negativo che il programma non ` in grado di gestire. e Unaltra spiegazione va data in merito alla moltiplicazione *2. Il fatto che ogni nodo possegga due gradi di libert` implica che la dimensione della matrice non sia a (N umero nodi) (N umero nodi), bens` (N umero nodi GdL) (N umero nodi
38
GdL). Di conseguenza per ogni nodo gli elementi che andranno spostati saranno 2x2 = 4 come visto pocanzi. Il codice completo per il primo blocchetto sar`: a
Kmatr [ ( ( T a b I n c [ i Kmatr [ ( ( T a b I n c [ i Kmatr [ ( ( T a b I n c [ i Kmatr [ ( ( T a b I n c [ i ,0]+1) ,0]+1) ,0]+1) ,0]+1) 2) 2) 2) 2) 2, 1, 1, 2, ( ( TabInc [ i ( ( TabInc [ i ( ( TabInc [ i ( ( TabInc [ i ,0]+1) ,0]+1) ,0]+1) ,0]+1) 2) 2) 2) 2) 2] 1] 2] 1] += += += += Kelg Kelg Kelg Kelg [0 [1 [1 [0 ,0]; ,1]; ,0]; ,1];
A titolo di esempio commentiamo anche altri due blocchi: Il blocco k12 :

Aiutandoci con la gura
Figura 3.6: Indici per il posizionamento Possiamo notare come sostanzialmente il ragionamento si ripeta, questa volta per` considerando come colonne gli elementi contenuti in TabInc[i,1] anzich` in o e TabInc[i,0].
39
Analisi del codice
E il blocco k23 :
e la relativa schematizzazione
Figura 3.7: Indici per il posizionamento Vengono processate tutte le matrici di rigidezza dei singoli elementi a formare la matrice globale di rigidezza:
40
Figura 3.8: Matrice di rigidezza dellesempio pilota

41
Analisi del codice
3.4
Vincoli
Il sistema di immissione dei vincoli ` molto semplice: nella sezione Vincoli ` sufe e ciente selezionare il nodo che si desidera vincolare e il tipo di vincolo scegliendo tra: cerniera; carrello con reazione in direzione X; carrello con reazione in direzione Y. Contestualmente alla creazione della matrice di rigidezza sono stati creati anche il vettore U e il vettore Q. Ricordando che il vettore U contiene le componenti dello spostamento sia orizzontale che verticale, ovvero U = {u1 , v1 , u2 , v2 , u3 , v3 , ...}T si nota come occorra un metodo che consenta di tenere traccia dello spostamento del nodo nelle sue componenti anche dopo la riorganizzazione che porter` ad avere i a vettori L L U Q U= Q= V U QV Quindi il vettore spostamento uvett sar` formato da tante righe quanti sono i nodi a della discretizzazione moltiplicati per 2 (due gradi di libert`) e da tre colonne: nella a prima verr` inserito, successivamente, il valore dello spostamento come soluzione del a sistema lineare; la seconda conterr` il valore 0 per i nodi non vincolati e un valore 1 per a i nodi vincolati; la terza conterr` invece il numero del nodo al quale quello spostamento a viene associato. Si ` deciso di assegnare agli spostamenti orizzontali u leettivo e numero del nodo e di distinguerlo dagli spostamenti v sommando a questultimo una quantita arbitraria di 109 . Lesempio chiarir` la situazione: a qualora volessimo vincolare con delle cerniere i nodi 1, 3 e 7 della discretizzazione, ` su ciente selezionarli dalla lista e cliccare su Applica. Il programma al termine e delloperazione avr` memorizzato il seguente vettore U: a
42
3.4 Vincoli
El | uvett ---------------------------| 0 1 2 | 0 | 0 0 0 1 | 0 0 1000000000 | 2 | 0 1 1 3 | 0 1 1000000001 | 4 | 0 0 2 5 | 0 0 1000000002 | 6 | 0 1 3 7 | 0 1 1000000003 | 8 | 0 0 4 9 | 0 0 1000000004 | 10 | 0 0 5 11 | 0 0 1000000005 | 12 | 0 0 6 13 | 0 0 1000000006 | 14 | 0 1 7 15 | 0 1 1000000007 | 16 | 0 0 8 17 | 0 0 1000000008 ...
Nel caso in cui vincolassimo il nodo 1 con una cerniera e il nodo 7 con un carrello con reazione secondo lasse X il vettore risulterebbe:
El | uvett ---------------------------| 0 1 2 | 0 | 0 0 0 1 | 0 0 1000000000 | 2 | 0 1 1 3 | 0 1 1000000001 | | ... | 14 | 0 1 7 15 | 0 0 1000000007 | ...
Con questultima congurazione eettueremo il calcolo della lastra considerata come esempio.
43
Analisi del codice
3.5
Carichi
Per la denizione del vettore dei carichi si segue una procedura analoga. Nel programma ` stato previsto linserimento di soli carichi concentrati, quindi i dati da inserire e saranno: il numero del nodo, la direzione del carico e lentit` del carico in Newton. Il a programma provveder` ad inserire nella corretta posizione allinterno del vettore Q il a carico desiderato. Ad esempio caricando il nodo 16 con un carico verticale di 500 N il vettore Q memorizzato dal calcolatore sar`: a
El | qvett -----------| 0 | 0 1 | 0 | 2 | 0 3 | 0 | | ... | 30 | 0 31 | 500 | ...
3.6
Soluzione
I passi successivi per il lancio della soluzione richiedono, da parte dellutente, uno sforzo minimo. Essendo un processo gestito completamente dallelaboratore, lunica operazione a data alloperatore ` la pressione del tasto Calcola: e
Le funzioni richiamate da questo evento sono:

void B t n { calc . calc . calc . calc . s t a r t a n a l i s y s C l i c k ( o b j e c t sender , EventArgs e ) calcolo calcolo calcolo calcolo . . . . ordina ( ); sislin (); spostamenti ( ) ; stress ();
MessageBox . Show ( A n a l i s i t e r m i n a t a ) ; }
44
3.6 Soluzione
Le funzioni sono contenute nella libreria calc.dll che prende il nome dal namespace, nel quale sono contenute le quattro funzioni. Oltre al namespace occorre specicare una classe di appartenenza, che in questo caso ` stata chiamata calcolo. La e struttura completa della libreria calc.dll ` quindi: e
namespace c a l c { public class calcolo { p u b l i c s t a t i c double o r d i n a () { ... } p u b l i c s t a t i c double s i s l i n () { ... } p u b l i c s t a t i c double spostamenti () { ... } p u b l i c s t a t i c double s t r e s s () { ... }
Analizziamo ora le quattro funzioni separatamente:
3.6.1
calc.calcolo.ordina()
I vettori U e Q, unitamente alla matrice K, sono completi ma non ordinati. Al ne di ottenere il sistema LL L L K KLV U Q = VL VV V K K U QV sar` necessario un algoritmo che analizzi la seconda colonna del vettore U4 e intervena ga modicando, oltre che lo stesso vettore U, anche il vettore dei carichi e la matrice di rigidezza. Come si nota dal codice che segue, si comincia con il contare quanti siano i nodi non vincolati (!= 1 signica non uguale ad 1) al ne di predisporre i nuovi contenitori per i vettori U, Q e la matrice K.
4
Contenente lindicazione di vincolo
45
Analisi del codice
int w = 0; f o r ( i n t i =0; i < ( G l . numNodi 2 ) ; i ++) { i f ( G l . u v e t t [ i , 1 ] != 1 ) w++; }
Il passo successivo ` infatti la creazione di kRmatr, ovvero di una matrice K e ridotta, sostanzialmente coincidente con KLL .
d o u b l e [ , ] kRmatr ; kRmatr = new d o u b l e [ w , w ] ;
Viene inoltre creata una nuova matrice K globale: quella memorizzata come variabile globale viene riversata in unaltra a due piani. Il primo contiene i dati con signicato sico, il secondo viene inizializzato tutto a 0.
d o u b l e [ , , ] kmatr ; kmatr = new d o u b l e [ G l . numNodi 2 , G l . numNodi 2 , 2 ] ; for ( int r = 0; r < { for ( int c = 0; { kmatr [ r , c , kmatr [ r , c , } } G l . numNodi 2 ; r++) c < G l . numNodi 2 ; c++) 0 ] = G l . Kmatr [ r , c ] ; 1] = 0;
Il motivo ` presto spiegato: nel piano formato da tutti zeri verranno convertiti in e 1 le righe e le colonne relative a spostamenti vincolati. Questa soluzione si rende necessaria al ne di estrarre correttamente la matrice KLL .
f o r ( i n t r = 0 ; r < G l o b a l s . numNodi 2 ; r++) { i f ( G l o b a l s . u v e t t [ r , 1 ] == 1 ) { f o r ( i n t c = 0 ; c < G l o b a l s . numNodi 2 ; c++) { kmatr [ r , c , 1 ] = 1 ; } } else { f o r ( i n t c = 0 ; c < G l o b a l s . numNodi 2 ; c++) { i f ( G l o b a l s . u v e t t [ c , 1 ] == 1 ) { kmatr [ r , c , 1 ] = 1 ; } } } }
46
3.6 Soluzione
Nel nostro esempio i vincoli porteranno a determinare un secondo piano di questo tipo:
Figura 3.9: Inuenza dei vincoli sulle matrice di rigidezza La matrice relativa alla parte non vincolata, contraddistinta dal fatto di possedere il corrispondente termine 0 nel secondo piano, viene a sua volta riversata nella matrice kRmatr. Il passaggio non ` diretto, in quanto occorre prima processare le righe e e memorizzare quanto fatto in una matrice KPassmatr, di passaggio. Successivamente verranno eliminate anche le colonne. Quella che segue ` unoperazione che necessita di un commento un po pi` approfone u dito.
47
Analisi del codice
double [ , , ] kPassmatr ; k P a s s m a t r = new d o u b l e [ w , G l . numNodi 2 , 2 ] ; i n t r1 = 0; int q = 0; f o r ( i n t r = 0 ; r < G l . numNodi 2 ; r++) { i f ( kmatr [ r , q , 1 ] == 0 ) { f o r ( i n t c = 0 ; c < G l . numNodi 2 ; c++) { k P a s s m a t r [ r1 , c , 0 ] = kmatr [ r , c , 0 ] ; k P a s s m a t r [ r1 , c , 1 ] = kmatr [ r , c , 1 ] ; } r 1 ++; } else { i n t c o n t r o l l o =0; f o r ( i n t r c = r ; r c < G l . numNodi 2 ; r c ++) { i f ( kmatr [ r c , q ,1]==0) c o n t r o l l o =1; } i f ( c o n t r o l l o ==0) q++; } }
Lalgoritmo inizia ad analizzare lelemento kmatr[0,0,1] e se individua il valore 0 allora copia lintero contenuto della riga5 nella nuova matrice kPassmatr e ne incrementa lindice (r1++) per memorizzare la prossima serie di dati nella riga sottostante. Qualora il numero fosse stato 1 allora, partendo dallindice r no al termine delle righe della matrice, viene controllato se lintera colonna ` stata vincoe lata. Se il termine controllo rimane pari a zero (ovvero la colonna della matrice ` e formata interamente da numeri 1) allora lintera colonna sar` da eliminare e quindi a bisogner` continuare con il controllo delle righe dalla colonna successiva. a Come al solito, chiariamo con lesempio pilota:
compreso laltro piano
48
3.6 Soluzione
allinizio abbiamo r = 0, q = 0 e r1 = 0; quindi tutta la riga viene viene copiata e r1 viene incrementato di 1.
al secondo ciclo abbiamo quindi: r = 1, q = 0 e r1 = 1.
al terzo ciclo abbiamo quindi: r = 2, q = 0 e r1 = 2. dato il risultato (pari ad 1) lalgoritmo non copia alcuna riga, ma controlla se eettivamente tutta la colonna sia da eliminare o se successivamente, come in questo caso, vi siano altri zeri, e quindi altri termini signicativi da copiare. Lalgoritmo prosegue eliminando tutte le righe nulle. Il controllo di tutta la colonna si rende necessario, in quanto se il nodo vincolato fosse il primo - o i primi6 - lalgoritmo si bloccherebbe senza copiare alcuna riga.
seguendo la numerazione della discretizzazione
49
Analisi del codice
Leliminazione delle colonne rimaste ` implementata nel seguente codice: e

i n t c1 = 0 ; f o r ( i n t c = 0 ; c<G l o b a l s . numNodi 2 ; c++ ) { i f ( k P a s s m a t r [ 0 , c , 1 ] == 0 ) { f o r ( i n t r = 0 ; r < w ; r++) { kRmatr [ r , c1 ] = k P a s s m a t r [ r , c , 0 ] ; } c1++; } }
Per quanto riguarda i vettori U e Q, si ` proceduto ordinando i vettori da Gl.uvett e a u2vett e da Gl.qvett a q2vett e, in un passaggio successivo alla loro riduzione in UL (uRidottovett) e QL (qRidottovett).
3.6.2
calc.calcolo.sislin()
Una volta in possesso di tutte le componenti del sistema KLL UL = QL i comandi per trovare la soluzione risultano davvero elementari:
M a t r i x K1 = M a t r i x . C r e a t e ( G l . kRmatr ) ; M a t r i x P1 = M a t r i x . C r e a t e ( G l . q R i d o t t o v e t t ) ; M a t r i x U1 = K1 . S o l v e ( P1 ) ;
Questo perch` si ` a data la risoluzione del sistema alla libreria Math.NET. In e e questa dll ` infatti presente la funzione solve che necessita, come parametri di input, e
50
3.6 Soluzione
della matrice dei coe cienti e del vettore dei termini noti. La soluzione viene scritta nel vettore U1.
3.6.3
calc.calcolo.spostamenti()
Per il calcolo degli spostamenti si opera sommando il risultato ottenuto dalla risoluzione del sistema lineare (spostamento) alle coordinate dei punti presenti nella tabella delle coordinate. La tabella delle coordinate contiene per` pi` termini del vettore spostao u mento U1. Ecco che allora, la terza colonna contente lindicazione del numero del nodo, risulta di fondamentale importanza.
f o r ( i n t a = 0 ; a < w ; a++) { i f ( Gl . u v e t t [ a , 2 ] < 1000000000) { t a b c o o r d [ C o n v e r t . T o I n t 6 4 ( G l . u v e t t [ a , 2 ] ) , 0 ] += G l . u v e t t [ a , 0 ] ; } else { tabcoord [ ( Convert . ToInt64 ( Gl . u v e t t [ a , 2 ] ) 1 0 0 0 0 0 0 0 0 0 ) , 1 ] += Gl . u v e t t [ a , 0 ] ; } }
Analizzando il codice si nota come, per ogni riga, venga interrogata la terza colonna (Gl.uvett[a,2]) e a seconda che il valore in essa contenuto sia minore o maggiore di 109 , ovvero a seconda che il valore sia inerente ad uno spostamento rispettivamente in X o in Y, esso venga sommato alla colonna 0 o alla colonna 1 della tabella delle coordinate.
Figura 3.10: Congurazione deformata [Fattore 50x]
51
Analisi del codice
La nuova tabella delle coordinate ottenuta ` riferita alla congurazione deformata e del pezzo in esame. Nel nostro esempio avremo il seguente vettore uvett:
uvett ----0 1 2 -------------------------------0,0077531850 0,0024574796 -0,0490598039 -0,0351167311 0,0028991737 0,0122327967 0,0064053726 -0,0551403483 0,0246498561 0,0034277032 -0,0654014042 -0,1164526276 -0,0376582992 0,0692988267 -0,0301807853 0,0009394902 -0,1609460336 ... 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 1000000000 2 1000000002 3 1000000003 4 1000000004 5 1000000005 6 1000000006 1000000007 8 1000000008 9 1000000009 ...
Possiamo confrontare le tabelle delle coordinate nella congurazione indeformata e in quella deformata.
Nodo Config. Deformata Config. Iniziale --------------------------------------------------------X Y X Y 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 14,9922305857 0,0000000000 24,9509401961 0,0028991737 35,0064024580 15,0246336269 49,9345985958 0,0000000000 25,0692988267 65,0009424048 50,0821488503 74,9320906528 75,0856596751 84,9798757869 85,0289055566 99,9298746346 100,1024853517 100,0070664776 16,6689252836 0,0000000000 -0,0351167311 25,0122327967 24,9446491352 33,3365630273 -0,1164526276 49,9623417008 49,9698192147 24,8388434500 49,8905334236 -0,1928976168 49,8029492759 16,4416412180 33,1047288478 -0,2720178725 49,7050747200 24,7253292343 14,99998 0 25 0 35 14,99998 50 0 25 65 50 75 75 85,00002 85,00002 100 100 100 16,66647 0 0 25 24,99979 33,33314 0 50 50 24,99979 50 0 50 16,66647 33,33314 0 50 25
Vincoli: X + Y
Vincoli: X
52
3.6 Soluzione
3.6.4
calc.calcolo.stress()
Per il calcolo degli sforzi si ` seguito un procedimento inverso rispetto a quello che ha e portato alla soluzione del sistema. Si sono calcolati anzitutto i parametri geometrici di ogni triangolo, ottenibili tramite:
ai = aj = ak =
Xj + Xk , Xk + Xi , Xi + Xj ,
bi = Yj bj = Yk bk = Yi
Yk Yi Yj
Dove le coordinate X e Y sono quelle globali contenute nella tabella delle coordinate dei nodi. Larea ` calcolabile come dierenza tra larea del rettangolo e larea e dei tre triangoli esterni allelemento: A = ak bj ma dato che ai + aj + ak = 0 bi + bj + bk = 0 lequazione pu` essere semplicata in o 1 A = (ak bj + aj bk ) 2 1 1 1 ai bi + aj bj + ak bk 2 2 2
53
Analisi del codice
Al ne di giungere alla determinazione degli sforzi dovremo seguire il precorso concettuale spostamenti ! deformazioni ! sforzi. Cerchiamo quindi di ricavare una formulazione che riconduca gli spostamenti al quale ` sogetto lelemento nito alle e deformazioni che lo interessano. Il modello di spostamento ` stato ricavato dalle e seguenti equazioni: u(x, y) = 1 + 2 x + 3 y v(x, y) = 4 + 5 x + 6 y esse possono essere scritte anche in forma matriciale, come segue: 2 5 3 6 Ricordando che: x = @u @x y = @v @y xy = = 1 2A bi bj ai aj bk ak 8 9 < ui vi = uj vj : ; uk vk @u @v + @y @x
Il vettore delle deformazioni sar` esprimibile come: a 8 9 > ui > > > 8 9 >v > 8 9 > i> @u > > > > x = > @x > < < = < = 1 uj @v = y = = B @y : ; > @u @v > 2 A > vj > > > : + ; xy > > >uk > @y @x > > > > : ; vk 8 < bi 0 b j B = 0 ai 0 : ai bi aj 8 < 9 = 0 aj bj 9 bk 0 = 0 ak ; ak bk
dove B ` la matrice dimensionale cos` formata: e
Una volta noto il vettore delle deformazioni dellelemento ` possibile ricavare gli e sforzi al quale ` soggetto mediante una semplice moltiplicazione matriciale: e 8 9 < x = = D y y : ; : ; xy xy
x
dove D ` la matrice gi` vista nel capitolo 1: e a
54
3.6 Soluzione
Il codice per il calcolo delle caratteristiche geometriche ` il seguente: e

a1 a2 a3 b1 b2 b3 = = = = = = Gl . Gl . Gl . Gl . Gl . Gl . tabcoord [ Gl . tabcoord [ Gl . tabcoord [ Gl . tabcoord [ Gl . tabcoord [ Gl . tabcoord [ Gl . tabinc tabinc tabinc tabinc tabinc tabinc [i [i [i [i [i [i ,1] ,2] ,0] ,1] ,2] ,0] , 0 ] + Gl . tabcoord [ Gl . , 0 ] + Gl . tabcoord [ Gl . , 0 ] + Gl . tabcoord [ Gl . ,1] Gl . tabcoord [ Gl . ,1] Gl . tabcoord [ Gl . ,1] Gl . tabcoord [ Gl . tabinc tabinc tabinc tabinc tabinc tabinc [i [i [i [i [i [i ,2] ,0] ,1] ,2] ,0] ,1] ,0]; ,0]; ,0]; ,1]; ,1]; ,1];
8 1 E < 1 D= 1 2 : 0 0
0 0
1 2 (1
; )
9 =
Mentre gli spostamenti sono da intendersi come da illustrazione:
Figura 3.11: Spostamenti

uvvett uvvett uvvett uvvett uvvett uvvett [0] [1] [2] [3] [4] [5] = = = = = = Gl . tabcoordD [ Gl . Gl . tabcoordD [ Gl . Gl . tabcoordD [ Gl . Gl . tabcoordD [ Gl . Gl . tabcoordD [ Gl . Gl . tabcoordD [ Gl . tabinc tabinc tabinc tabinc tabinc tabinc [i [i [i [i [i [i ,0] ,0] ,1] ,1] ,2] ,2] ,0] ,1] ,0] ,1] ,0] ,1] Gl . Gl . Gl . Gl . Gl . Gl . tabcoord [ Gl . tabcoord [ Gl . tabcoord [ Gl . tabcoord [ Gl . tabcoord [ Gl . tabcoord [ Gl . tabinc tabinc tabinc tabinc tabinc tabinc [i [i [i [i [i [i ,0] ,0] ,1] ,1] ,2] ,2] ,0]; ,1]; ,0]; ,1]; ,0]; ,1];
55
Analisi del codice
Segue il riempimento della matrice B e il calcolo dellarea:

Bmatr [ 0 Bmatr [ 0 Bmatr [ 0 Bmatr [ 0 Bmatr [ 0 Bmatr [ 0 ,0] ,1] ,2] ,3] ,4] ,5] = = = = = = b1 ; 0; b2 ; 0; b3 ; 0; Bmatr [ 1 Bmatr [ 1 Bmatr [ 1 Bmatr [ 1 Bmatr [ 1 Bmatr [ 1 ,0] ,1] ,2] ,3] ,4] ,5] = = = = = = 0; a1 ; 0; a2 ; 0; a3 ; Bmatr [ 2 Bmatr [ 2 Bmatr [ 2 Bmatr [ 2 Bmatr [ 2 Bmatr [ 2 ,0] ,1] ,2] ,3] ,4] ,5] = = = = = = a1 ; b1 ; a2 ; b2 ; a3 ; b3 ;
Are a = 0 . 5 ( a3 b2 a2 b3 ) ;
In seguito due moltiplicazioni matriciali consentono di giungere agli sforzi negli elementi:
f o r ( i n t k = 0 ; k < 3 ; k++) { f o r ( i n t j = 0 ; j < 6 ; j ++) { Ematr [ i , k ] += Bmatr [ k , j ] u v v e t t [ j ] ; } } Ematr [ i , 0 ] = Ematr [ i , 0 ] ( 1 / ( 2 Ar ea ) ) ; Ematr [ i , 1 ] = Ematr [ i , 1 ] ( 1 / ( 2 Ar ea ) ) ; Ematr [ i , 2 ] = Ematr [ i , 2 ] ( 1 / ( 2 Ar ea ) ) ;
e
f o r ( i n t k = 0 ; k < 3 ; k++) { f o r ( i n t j = 0 ; j < 3 ; j ++) { s t r e s s v e t t [ i , k ] += G l . Dmatr [ k , j ] Ematr [ i , j ] ; } }
56
3.6 Soluzione
Per terminare lanalisi dellesempio pilota possiamo riportare le mappe relative agli sforzi x , y e xy :
57
Analisi del codice
Riportiamo i dati relativi agli sforzi negli elementi, forniti dal report:
S F O R Z I ----------Nodo Sigma X Sigma Y Sigma XY ---------------------------------------------------0: 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: -1,775645E+002 -5,756963E+001 -1,539611E+001 4,470395E+001 -9,771102E+000 -5,810007E+001 1,056668E+002 1,164459E+001 -9,378687E+000 2,438273E+002 4,995516E+001 -2,299345E+001 -9,673203E+000 1,472084E+001 1,296390E+001 -5,953175E+000 1,238166E+001 -1,081102E+001 6,146935E+001 1,326834E+001 7,678249E+000 4,874526E+001 9,495565E+001 3,410686E+001 3,960895E+001 1,952359E+001 3,181078E+000 3,511549E+001 -1,778426E+002 -1,830156E+001 3,250633E+001 -1,574259E+002 -1,338314E+001 -1,287620E+001 2,867193E+000 -8,208543E-002 3,946312E+000 -1,375332E+001 -1,883881E+001 -5,012464E+000 -3,066166E+001 -1,857281E+001 -8,838677E+000 -7,044538E+001 -4,187634E+000 -1,065648E+001 -2,959588E+001 5,350297E+001 -3,876772E+001 -3,123113E+001 1,638372E+001 -1,752271E+001 -3,084895E+001 5,309980E+001 -1,817776E+001 -1,566217E+001 -1,389030E+001 -6,896067E+000 -1,594972E+001 2,835371E+000 -1,380090E+001 -9,912669E+000 -4,239971E+000 -1,057391E+001 -7,120637E+000 1,140363E+001
Come si pu` notare, una discretizzazione cos` ampia non consente di ottenere o diagrammi qualitativamente fruibili. Riproponiamo quindi le mappe relative allo stesso problema, discretizzate per` con una mesh pi` tta oltre ad un confronto con delle o u mappe ottenute dal programma SAP2000 e provviste di smoothing:
58
3.6 Soluzione
59
Analisi del codice
60
Capitolo 4
Confronti con software di calcolo commerciali

4.1 Introduzione
In questultimo capitolo si confronteranno i risultati ottenuti dal programma sin qui descritto con quelli forniti da due progammi di uso commerciale: SAP2000 e COMSOL Multiphysics. Verranno analizzate cinque geometrie con schemi di carico diversi.
4.1.1
SAP2000
SAP2000 ` un software integrato per analisi strutturale e veriche. Per essere certi di e utilizzare il modello sico corretto verichiamo di aver inserito nellapposita maschera ` i dati corretti. E necessario inoltre controllare le propriet` degli elementi, quali la a scelta della teoria (plane stress o plane strain) e lo spessore della lastra (gura 4.1).
4.1.2
COMSOL Multiphysics
Il secondo programma con cui si ` deciso di confrontare i dati ottenuti ` COMSOL e e Multiphysics. Questo software consente di eettuare analisi strutturali, di uidodinamica, di trasmissione del calore, acustiche e di elettromagnetismo. Oltre a queste esso consente anche di valutare le interazioni che pi` aspetti sici hanno sul problema u ` possibile, ad esempio, valutare come si comporta un pezzo meccaniin esame. E co sollecitato da forze esterne al variare della temperatura. Anche qui, come per il precedente software, controlliamo di avere assunto le stesse ipotesi di base (gura 4.2)
61
Figura 4.1: Parametri SAP 2000
62
4.1 Introduzione
Figura 4.2: Parametri COMSOL Multiphysics
63
4.2
Primo problema
Si comincer` con lanalisi di una lastra rettangolare di dimensioni 250mm x 60mm, a vincolata in semplice in appoggio e caricata allestradosso in mezzeria con un carico concentrato di 1 kN. Riportiamo qui di seguito la geometria inserita in Thesis:
6 0: 1: 2: 3: 4: 5: 6 0: 1: 2: 3: 4: 5: 0 0 4.5 1 125 0 7.5 1 250 0 4.5 1 250 60 7.5 1 125 60 3.5 1 0 60 7.5 1
0 1 2 3 4 5
1 2 3 4 5 0
1 1 1 1 1 1
Sono presenti sei punti invece di quattro perch` in corrispondenza della mezzeria e superiore e delle zone di appoggio ` stato aumentato il numero degli elmenti. e Confrontiamo gli spostamenti che i tre programmi forniscono:
u v Thesis 0,0517 -0,1356 SAP2000 0,0393 -0,1230 COMSOL 0,0398 -0,1256
Si pu` vedere che numericamente vi ` una certa omogeneit` di risultati. Lo o e a spostamento veticale si discosta dalla media degli altri due programmi solo per un 8,33%. Analizzando lo stato tensionale nel punto di carico i risultati sono i seguenti:
64
4.2 Primo problema
Si ricava lo stato tensionale del punto in Thesis come media dello stato tensionale degli elementi concorrenti al nodo, in questo caso il 342:
Nodo 342: Elementi Sigma X 610: -9,024406E+001 621: 2,817026E+001 637: -3,606611E+001 Sigma Y -3,458788E+001 -2,190070E+002 -7,127716E+001 Sigma XY -9,766226E+001 2,591078E+001 1,165955E+002
[mm]
x y xy
Thesis -32,7133 -108,2907 14,9480
SAP2000 -129,7387 -107,6685 0
COMSOL -187,7965 -106,2625 -1,7159
Si ` analizzato lo stato tensionale anche in una zona a basso gradiente di sforzo: e

Nodo 80: (coordinate: 44,6640 ; 21,9094) Elementi Sigma X Sigma Y 126: 8,060143E+000 4,156950E+000 130: 4,870146E+000 -6,069709E+000 140: 2,935961E+000 -3,300120E+000 147: 6,114630E+000 1,064749E+000 156: 6,147715E+000 -2,208049E+000 160: 7,326036E+000 3,527977E+000 166: 5,523098E+000 -1,470096E+000 Sigma XY -1,323452E+001 -1,322586E+001 -1,011122E+001 -8,455883E+000 -9,158331E+000 -9,880195E+000 -9,183329E+000
[MPa]
x y xy
Thesis 5,8540 -0,6140 -10,4642
SAP2000 8,4642 1,6428 -9,5621
COMSOL 7,9930 1,5561 -11,4393
Si nota come gli spostamenti vengano ricavati correttamente, mentre si notano delle incongruenze rilevanti in zone ad alto gradiente di sforzo. Si riportano di seguito le mappe di sforzo prodotte dai tre software:
65
Figura 4.3:
x,
xy
del primo esempio prodotto da Thesis
66
4.2 Primo problema
Figura 4.4:
x,
xy
del primo esempio prodotto da SAP2000
Figura 4.5:
x,
xy
del primo esempio prodotte da COMSOL Multiphysics
67
4.3
Secondo problema
Il confronto presegue con la comparazione di una geometria abbastanza semplice: si tratta di una forma ad L, incernierata a due estremi e caricata in un vertice (gura 4.6).
Figura 4.6: Geometria del secondo esempio Analogamente a prima specichiamo la geometria da inserire in Thesis:
8 0: 1: 2: 3: 4: 5: 6: 7: 8 0: 1: 2: 3: 4: 5: 6: 7:
0 0 24 1 245 0 12.5 1 250 5 12.5 1 250 125 4 1 495 125 12.5 1 500 130 12.5 1 500 250 25 1 0 250 26 1
0 1 2 3 4 5 6 7
1 2 3 4 5 6 7 0
1 1 1 1 1 1 1 1
ed i risultati ottenuti inerenti lo spostamento del punto di applicazione del carico:

[mm] u v Thesis 0,1971 -0,6439 SAP2000 0,1779 -0,6040 COMSOL 0,1431 -0,4943
68
4.3 Secondo problema
In analogia con il caso precedente si ` notato che il programma riesce a descrivere e meglio stati di tensione in zone con bassi gradienti di sforzo: Zone con alto gradiente di sforzo
Nodo 571: Elementi Sigma X 1023: -3,134511E+001 1025: -1,983232E+001 1050: -4,753870E+001 1061: -1,957706E+001 1081: -4,598015E+001 1090: -4,736131E+001 Sigma Y 6,779955E+000 1,168277E+001 2,390713E+001 1,437173E+001 2,867328E+001 2,674509E+001 Sigma XY -1,775916E+000 9,612637E-001 -1,376474E+001 -5,954703E+000 -1,747831E+001 -1,856600E+001
[MPa]
x y xy
Thesis -35,2724 18,6933 -9,4247
SAP2000 -112,7642 -77,3974 -27,8023
COMSOL -108,0193 -21,9323 -24,1359
Zone con basso gradiente di sforzo

Nodo 68: Elementi 105: 110: 117: 128: 136: 139: (coordinate: 104,6696 ; 140,6698) Sigma X Sigma Y Sigma XY 4,983496E-001 3,253074E+000 1,541317E+000 8,977441E-001 3,288232E+000 1,011707E+000 -2,950361E+000 4,423985E+000 -2,430538E+000 2,134345E+000 1,778294E+000 9,850874E-001 -1,196635E+000 4,972731E+000 -1,770513E+000 -1,528793E+000 3,215961E+000 -1,998232E+000
[MPa]
x y xy
Thesis -0,3576 3,4887 -0,4435
SAP2000 -3,2916 7,2780 -1,2459
COMSOL -5,5968 5,7216 -3,6447
Seguono le mappe prodotte dai tre software.
69
Figura 4.7:
x,
xy
del secondo esempio prodotto da Thesis
70
4.3 Secondo problema
Figura 4.8:
x,
xy
del secondo esempio prodotto da SAP2000
71
Figura 4.9:
x,
xy
del secondo esempio prodotte da COMSOL Multiphysics
72
4.4 Terzo problema
4.4
Terzo problema
Passando a sistemi pi` complessi, si ` deciso di analizzare la risposta strutturale di una u e lastra rettangolare di dimensioni 250mm x 300mm con un foro di dimensioni 200mm x 200mm. Essa ` vincolata in semplice appoggio e caricata allestremo superiore sinistro e con una forza concentrata pari a 1kN diretta orizzontalmente. Analogamente a prima si riporta la geometria accettata da Thesis:
12 0: 0 0 10 1 1: 250 0 10 1 2: 250 150 5 1 3: 250 300 10 1 4: 0 300 10 1 5: 0 150 5 1 6: 25 50 10 1 7: 25 150 5 1 8: 25 250 10 1 9: 225 250 10 1 10: 225 150 5 1 11: 225 50 10 1 12 0: 0 1 1 1: 1 2 1 2: 2 3 1 3: 3 4 1 4: 4 5 1 5: 5 0 1 6: 6 7 1 7: 7 8 1 8: 8 9 1 9: 9 10 1 10: 10 11 1 11: 11 6 1
Gli spostamenti del punto di applicazione:

[mm] u v Thesis 1,8443 0,0747 SAP2000 2,3579 0,0819 COMSOL 2,2299 0,0719
e del carrello:
[mm] u Thesis 0,0544 SAP2000 0,0681 COMSOL 0,0590
Nell zone da alto gradiente ` possibile notare il solito rilevante scostamento: e
73
Nodo 552: (coordinate: 65 Elementi Sigma X 100: -9,156440E+001 103: -3,966417E+001 113: -6,524898E+001
; 50) Sigma Y 6,220793E+001 3,749735E+001 2,488868E+001
Sigma XY -1,692209E+001 -2,316949E+000 -9,738443E+000
[MPa]
x y xy
Thesis -65,4925 41,5313 -9,6592
SAP2000 -85,4829 -0,0259 1,7480
COMSOL -80,6085 0,1841 2,2037
Anche nelle zone a basso gradiente il programma trova qualche di colt` nel a cogliere lo stato tensionale.
Nodo 226: Elementi 370: 381: (coordinate: 0 ; 150) Sigma X Sigma Y 1,981370E+000 -1,537996E+001 7,000490E+000 8,743903E+000 Sigma XY 8,323984E+000 1,121672E+001
[MPa]
x y xy
Thesis 5,2630 -12,2032 9,9882
SAP2000 0,0000 30,3444 6,5347
COMSOL 0,2942 30,1300 4,9274
Figura 4.10: Congurazione deformata nel terzo esempio Si riportano la congurazione deformata prodotta da Thesis (amplicata di 50 volte) e le mappe degli sforzi.
74
4.4 Terzo problema
Figura 4.11:
x,
xy
del terzo esempio prodotto da Thesis
75
Figura 4.12:
x,
xy
del terzo esempio prodotto da SAP2000
76
4.4 Terzo problema
Figura 4.13:
x,
xy
del terzo esempio prodotte da COMSOL Multiphysics
77
4.5
Quarto problema
Si ` voluto studiare la soluzione di un problema caratteristico della scienza delle e costruzioni: la lastra in questo caso ` rettangolare (dimensioni 300mm x 150mm) e e presenta un foro circolare di diametro pari ad un decimo dellaltezza. Questa ` stata caricata con un carico distribuito che complessivamente esercita 5kN e di trazione e vincolata in modo continuo con una serie di carrelli che le permettono di potersi deformare trasversalmente senza generare eetti ulteriori sullo stato tensionale.
Figura 4.14: Geometria del quarto problema Gli spostamenti del punto medio di applicazione del carico registrati sono:
Le zone ad alto gradiente analizzate sono le estremit` superiori del foro e quelle a orizzontali. Estremit` verticale del foro a
Nodo 571: Elementi 1042: 1072: 1111: Sigma X 4,753357E+001 2,816789E+001 1,070231E+002 Sigma Y -1,048790E+001 -2,488060E+001 -4,664736E+001 Sigma XY 7,828283E+000 -3,076703E-001 -2,933582E+001
[MPa]
x y xy
Thesis 60,9082 -27,3386 -17,4249
SAP2000 96,5629 6,7051 -0.0155
COMSOL 91,1898 11,6465 -10,1136
78
4.5 Quarto problema
Estremit` orizzontale del foro a

Nodo 469: Elementi Sigma X 850: 1,994914E+001 856: 5,701323E+000 Sigma Y -1,950457E+001 -8,925065E+000 Sigma XY -4,319164E+000 -3,222301E+000
[MPa]
x y xy
Thesis 13,4758 -15,7044 -4,3820
SAP2000 0,2802 -32,4968 0,1189
COMSOL -0,1073 -26,1997 -1,5691
Per la zona a basso gradiente si ` scelto il punto (91,7911mm ; 94,6177mm) e Zona a basso gradiente
Nodo 102: Elementi 164: 165: 184: 186: 206: 207: Sigma X 2,592382E+001 4,021959E+001 4,619789E+001 2,234496E+001 3,702943E+001 3,172928E+001 Sigma Y -1,735481E+001 -1,231466E+001 -2,673230E+001 -1,797539E+001 -2,687717E+001 -2,865300E+001 Sigma XY 3,961739E+000 -1,697830E+000 1,305967E+001 1,021887E+001 1,953006E+001 1,545821E+001
[MPa]
x y xy
Thesis 33,9075 -21,6512 10,0885
SAP2000 32,7951 -0,0417 0,7109
COMSOL 33,1568 -0,2533 0,5130
Si pu` notare come il programma risulti preciso nel determinare gli spostamenti e o solamente la x nella zona a basso gradiente.
79
Figura 4.15:
80
x,
xy
del quarto esempio prodotto da Thesis
4.5 Quarto problema
Figura 4.16:
x,
xy
del quarto esempio prodotto da SAP2000
81
Figura 4.17:
x,
xy
del quarto esempio prodotte da COMSOL Multiphysics
82
4.6 Quinto problema
4.6
Quinto problema
Nellultimo esempio, le dimensioni e le condizioni di carico sono le medesime del quarto problema, con la dierenza che in questo caso il foro ` unellisse con il semiasse e maggiore disposto trasversalmente.
Figura 4.18: Geometria del quinto problema Gli spostamenti del punto medio di applicazione del carico registrati sono:
La zona ad alto gradiente analizzata ` lestremit` superiore del foro. e a Estremit` verticale del foro a
Nodo 619: Elementi 1121: 1125: 1156: Sigma X 9,931185E+001 5,371866E+001 8,048386E+001 Sigma Y 8,281266E+000 -2,993204E+001 -2,798395E+001 Sigma XY 7,901374E+001 5,367208E+001 9,261089E+000
[MPa]
x y xy
Thesis 120,1528 -28,3725 26,1612
SAP2000 138,0006 15,7554 -0,1179
COMSOL 154,2936 19,9257 -2,4092
Per la zona a basso gradiente si ` scelto il punto (87,1188mm ; 80,2100mm) e Zona a basso gradiente
83
Nodo 179: Elementi 303: 307: 329: 336: 359: 362:
Sigma X 1,388065E+001 1,022250E+001 1,352525E+001 6,654447E+000 1,930246E+001 8,428505E+000
Sigma Y -4,949990E+000 1,211536E+000 -4,567515E+000 -3,004670E-001 -1,511417E+000 4,714312E+000
Sigma XY 7,905641E+000 4,965644E+000 5,134933E+000 4,137858E+000 6,896430E+000 4,870567E+000
[MPa]
x y xy
Thesis 12,0023 -0,9006 5,6518
SAP2000 19,3418 4,6537 1,5746
COMSOL 23,9243 5,2571 3,4764
84
4.6 Quinto problema
Figura 4.19:
x,
xy
del quinto esempio prodotto da Thesis
85
Figura 4.20:
x,
xy
del quinto esempio prodotto da SAP2000
86
4.6 Quinto problema
Figura 4.21:
x,
xy
del quinto esempio prodotte da COMSOL Multiphysics
87
88
Conclusioni
Thesis risulta essere su cientemente a dabile nel cogliere gli spostamenti dei vari punti del dominio, altrettanto non si pu` dire invece per quanto riguarda le solo lecitazioni. Il fatto che queste non presentino unadeguata convergenza di risultati ` dovue to alla mancanza di avanzati algoritmi di stress recovery. Nella maggior parte dei software in commercio, infatti, le sollecitazioni ricavate per i vari elementi subiscono processi di correzione. Ne ` un esempio lo smoothing delle mappe degli sforzi, nece essario ad assicurare la continuit` delle sollecitazioni in tutta la lastra. In Thesis non a sono stati implementati metodi avanzati di stress recovery, ma tale argomento esula dagli obiettivi di questa tesi. Questo studio ha confermato la congruenza del metodo degli spostamenti con i risultati ottenuti dai codici commerciali; i risultati di Thesis sono infatti il prodotto dellapplicazione diretta della teoria dello stato piano di sforzo con elementi CST e si discostano mediamente solo per il 12%.
89
Bibliograa
Brebbia C.A., Connor J.J. (1979) Fondamenti del Metodo degli Elementi Finiti, CLUP. Rugarli P. (2004) Calcolo Strutturale con gli Elementi Finiti, EPC Libri. Fenner R.T. (1997) Finite Element Method for Engineers, The Macmillan Press LTD. Pian M., Visintin D. (1991) Introduzione al Metodo degli Elementi Finiti, DICA UniTs. DAntonio L.D. (2008) Calcolo dei Telai Piani, Dario Flaccovio Editore.
91
Indice analitico
.NET Framework, 21 assemblaggio, 10, 37 carichi, 12, 44 coe ciente di Poisson, 9 COMSOL Multiphysics, 61 Delaunay, 8 EasyMesh, 8 equazione di equilibrio, 7 estrazione, 45 funzioni di forma, 5 geometria, 29 linguaggio di programmazione, 21 Math.NET, 24, 50 matrice di rigidezza, 9, 28, 33 matrice elemento, 34 meshing, 8 modello di spostamento, 4 modello matematico, 2 modulo di Young, 9 SAP2000, 61 sistema lineare, 18, 50 sistema risolvente, 14 sollecitazioni, 53 soluzione, 44 spostamenti, 51, 61 Thesis, 28 vettore degli sforzi, 3 vettore delle deformazioni, 3 vincoli, 12 Voronoi, 8
92

Lingua

Analisi Elastica Con Il Metodo Degli Elementi Finiti: Sviluppo Di Un Codice e Confronto Con Programmi Di Uso Commerciale.

Caricato da

Informazioni sul documento

Descrizione:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Descrizione:

Copyright:

Formati disponibili

Analisi Elastica Con Il Metodo Degli Elementi Finiti: Sviluppo Di Un Codice e Confronto Con Programmi Di Uso Commerciale.

Titolo originale:

Caricato da

Descrizione:

Copyright:

Formati disponibili

UNIVERSITA DEGLI STUDI DI TRIESTE FACOLTA DI INGEGNERIA Corso di Laurea in Ingegneria Civile ed Ambientale

A.A. 2008 / 2009

Tesi di laurea triennale in

Analisi Numerica delle Strutture

Analisi elastica con il metodo degli elementi niti:

Prof. Ing. Alfonso Nappi

3.4 3.5 3.6

Cenni sul metodo degli elementi niti

Panoramica del metodo

lavori di A. R. Collar e W. J. Duncan

Cenni sul metodo degli elementi niti

Scelta del modello matematico pi` adatto u

1.2 Panoramica del metodo

Figura 1.1: Stato piano di sforzo, sistema di riferimento

Scelta del tipo di elemento nito

Cenni sul metodo degli elementi niti

8 < u(0, 0) = u1 = 1 u(x2 , 0) = u2 = 1 + 2 x2 : u(x3 , y3 ) = u3 = 1 + 2 x3 + 3 y3 8 < 1 = u1 2 = u2x2u1 =) : 3 = u3y3u1 +

Constant Strain Triangle

1.2 Panoramica del metodo

8 < v(0, 0) = v1 = 4 v(x2 , 0) = v2 = 4 + 5 x2 : v(x3 , y3 ) = v3 = 4 + 5 x3 + 6 y3 8 < 4 = v1 5 = v2x2v1 =) : 6 = v3y3v1 +

Cenni sul metodo degli elementi niti

1.2 Panoramica del metodo

Quindi per ogni singolo elemento vale lequazione: = DBu

98 9 > < x = = y E >: ; xy ; 2(1+) 0 0

@'3 (x,y) @y ; @'3 (x,y) > @y

Cenni sul metodo degli elementi niti

1.2 Panoramica del metodo

Figura 1.5: Elementi di dimensioni dierenti in relazione al gradiente di sforzo

Propriet` dei materiali a

Cenni sul metodo degli elementi niti

k12 k22 k32

Figura 1.6: Elemento generico

k12 = e cos` via.

1.2 Panoramica del metodo

Figura 1.7: Elemento generico

Figura 1.8: Assemblaggio della matrice

Rinumerazione dei nodi

Cenni sul metodo degli elementi niti

Attribuzione dei vincoli

Attribuzione dei carichi

1.2 Panoramica del metodo

Il vettore dei carichi equivalenti nodali sar`: a 8 9 <P1 = Z 3 P2 = : ; 1 P3 8R 3 < 1 :R 3

Quindi lungo il lato 13 sar`: a

8 9 <P1 = 0 = 0 : ; T p (s)ds; P3 3 (x, y) y

py (s) ['1 (x, y) v1 + '3 (x, y) v3 ] ds Z

'1 (x, y) py (s) v1 ds +

'3 (x, y) py (s) v3 ds =

py (s) ['1 (x, y) v1 + '3 (x, y) v3 ] ds

come volevasi dimostrare.

Cenni sul metodo degli elementi niti

Assemblaggio del sistema risolvente

1.2 Panoramica del metodo

lintera struttura diventa Z= X1

Analogo principio vale per il potenziale dei carichi: X W= uT qe = uT q

Impiegando il principio di stazionariet` dellenergia potenziale totale a Y =Z W

Cenni sul metodo degli elementi niti

1.2 Panoramica del metodo

Cenni sul metodo degli elementi niti