Sei sulla pagina 1di 94

Università degli Studi Roma Tre

Facoltà di Ingegneria
Corso di laurea in Ingegneria Civile
Indirizzo Costruzioni Civili

Prova finale

Calcolo di travature
reticolari in ambiente
MATLAB
Relatore: Correlatore:
Prof. Claudio Valente Ing. Stefano Gabriele

Candidato:
Mattia Campolese

Anno Accademico: 2006-2007


Sommario
Introduzione.......................................................................................................2
Le strutture reticolari.........................................................................................................2
Geometria.................................................................................................................................................3
Analisi strutturale..............................................................................................4
Sistemi isostatici................................................................................................................4
Metodo dei nodi........................................................................................................................................4
Sistemi iperstatici..............................................................................................................5
Metodo degli spostamenti........................................................................................................................5
Soluzione manuale con il metodo degli spostamenti.......................................................11
Dati.........................................................................................................................................................11
Equazioni di equilibrio...........................................................................................................................12
Calcolo deformazioni.............................................................................................................................13
Soluzione della matrice degli spostamenti.............................................................................................15
Implementazione MATLAB............................................................................17
L'applicazione CAMP2000..............................................................................................18
Il preprocessore......................................................................................................................................18
Il kernel...................................................................................................................................................24
Il postprocessore.....................................................................................................................................29
Esempio dimostrativo.............................................................................................................................32
Soluzione automatica con il metodo degli spostamenti...................................................38
Preparazione dei dati..............................................................................................................................38
Calcolo in MATLAB..............................................................................................................................39
Calcolo in SAP2000...............................................................................................................................42
Applicazioni....................................................................................................43
Confronto tra diverse travature........................................................................................43
Howe......................................................................................................................................................43
Pratt........................................................................................................................................................47
Polonceau [1]..........................................................................................................................................50
Polonceau [2]..........................................................................................................................................53
Confronto tra la Howe e la Pratt.............................................................................................................56
Confronto tra le due Polonceau..............................................................................................................58
Confronto globale...................................................................................................................................59
Capriata metallica per capannone industriale..................................................................60
Proprietà della capriata...........................................................................................................................61
Modellazione statica: scelta dei vincoli..................................................................................................63
Spostamenti teorici.................................................................................................................................68
Spostamenti reali....................................................................................................................................73
Appendice........................................................................................................77
Contenuto del pacchetto software....................................................................................77
Schermate preprocessore.................................................................................................80
Codice sorgente script MATLAB....................................................................................82
Riferimenti bibliografici..................................................................................92
Ringraziamenti................................................................................................93

1
Introduzione
Le strutture reticolari
Si definisce struttura reticolare un insieme di aste rettilinee incernierate collegate le une
alle altre mediante nodi in modo da formare una struttura portante stabile, piana oppure
spaziale. La trave reticolare è un sistema di aste complanari formante un’unica
membratura nel quale una dimensione (la lunghezza) è largamente preponderante rispetto
all’altra (o alle altre nel caso tridimensionale).
Fra le diverse aste che compongono la struttura si distinguono i correnti, costituiti dalle
aste essenzialmente orientate nella direzione della dimensione maggiore della trave
reticolare, e le diagonali e montanti, costituiti da aste orientate obliquamente o
trasversalmente a tale direzione.

Fig. 1: Struttura reticolare: terminologia

Se i carichi sono costituiti unicamente da forze concentrate sulle cerniere, ogni asta
risulterà soggetta a sola azione assiale, o sforzo normale, essendo quest’ultima l’unica
caratteristica di sollecitazione compatibile con l’equilibrio dei singoli elementi costitutivi
isolati dal complesso strutturale e con le prestazioni statiche dei vincoli.

Una struttura reticolare per definizione ha il seguente schema statico:


● i nodi sono cerniere perfette;
● gli assi delle aste concorrono ai nodi senza eccentricità;
● i carichi agiscono solo sui nodi, affinché le aste possano trasmettere forze solo alle
loro estremità;

In virtù di questa ultima ipotesi le aste saranno soggette soltanto a sforzo normale, di
trazione o compressione. La generica asta tesa si definisce comunemente come tirante,
quella compressa come puntone. Ciò permette un significativo risparmio di materiale
rispetto alle travi a parete piena. E’ molto importante che le travature reticolari siano
caricate solamente da forze concentrate applicate nei nodi affinché negli elementi si
sviluppino solo sforzi di trazione o di compressione; se i carichi fossero applicati
direttamente agli elementi stessi si svilupperebbero anche degli sforzi dovuti alla flessione
e al taglio.

Le inevitabili imperfezioni (peso proprio delle aste, ecc.) introducono solo effetti
secondari, trascurabili in prima approssimazione. Ad esempio il peso proprio delle aste non
è evidentemente trascurabile e se ne tiene conto, in pratica, concentrando la metà del peso
di ogni asta su ciascuna delle sue estremità. Ciò che invece è trascurabile è l’effetto locale
del peso proprio su ciascuna asta considerata isolatamente.

2
Una generica struttura tridimensionale o piana si identifica per sua stessa definizione con
un sistema di corpi rigidi vincolati mutuamente e con l’esterno. Tuttavia è comodo
considerare invertiti i ruoli dei nodi e delle aste: riguardare cioè i primi come corpi
puntiformi, ciascuno dotato di 2 (o 3 nello spazio) gradi di libertà, e le seconde come
vincoli interni semplici che controllano la distanza relativa tra i due nodi.

Geometria
La struttura reticolare quadrata formata da quattro aste non è stabile. Si tratta di un
meccanismo, e lo stesso vale per ogni struttura poligonale formata da quattro o più aste.
Al contrario tre aste che formano un triangolo costituiscono una struttura stabile. Il
triangolo è quindi la forma più semplice di struttura reticolare di cui costituisce pertanto
anche la cellula base per formare un sistema rigido che non può essere deformato
dall’applicazione di forze esterne senza la deformazione di uno o più degli elementi che lo
compongono. Le strutture reticolari formate per semplice giustapposizione di triangoli
sono dette talora triangolazioni semplici. Nello spazio a tre dimensioni la cellula base è il
tetraedro e ogni nodo ha bisogno di tre aste per garantire la sua stabilità.

Fig. 2: Geometria instabile e stabile

Nelle strutture reticolari tutte le travi sono collegate tra loro mediante cerniere che possono
essere considerate sferiche. Ogni trave è dunque una biella (in inglese truss). Se poi i
carichi sono concentrati sui nodi (sulle cerniere) le travi portano solo forze assiali.
Molto spesso è possibile immaginare i vincoli interni come veri e propri corpi rigidi. In
quanto corpo rigido si deve quindi imporre l’equilibrio anche del vincolo tramite le
equazioni cardinali della statica, in genere trascurando il peso del vincolo stesso. Per
azione e reazione ogni corpo rigido esercita sul vincoli forze uguali ed opposte.
Poiché per ipotesi si suppone che le dimensioni della cerniera siano trascurabili, tutte le
forze sono applicate in essa e quindi la seconda equazione cardinale della statica (momenti
nulli) è soddisfatta.

Esiste una relazione tra il numero di nodi e il numero di aste. Se Nc è il numero di cerniere
(nodi), Na il numero di aste e Ne il numero di vincoli semplici esterni, affinché il sistema
sia staticamente e cinematicamente determinato, nell’ipotesi che i vincoli siano ben
disposti (condizione sufficiente), è necessario che il numero di vincoli, Na+Ne, sia pari ai
gradi di libertà del sistema, cioè:

N a N e =2 N c (3 Nc nello spazio)

Nella seguente trattazione verranno affrontate esclusivamente travature reticolari piane.

3
Analisi strutturale
Sistemi isostatici
Il problema statico delle strutture reticolari consiste nel calcolo dello sforzo normale in
tutte le aste. Tale calcolo è possibile servendosi delle sole equazioni di equilibrio.
Tutte le travi sono bielle caricate agli estremi: ogni trave sopporta solo carico assiale
costante lungo la trave. Si noti che questa semplice osservazione permette di affermare che
le equazioni cardinali della statica sono già automaticamente soddisfatte per ogni asta
isolata, qualunque sia il valore delle azioni assiali. In realtà ciò che resta da fare è imporre
l’equilibrio dei perni delle cerniere, cioè dei vincoli interni.

Il primo passo nell’analisi di una struttura reticolare è isolarne una parte e considerare il
sistema di forze agente su di essa. Se alcune forze sono note, è possibile calcolare le altre
mediante le equazioni cardinali della statica, dato che la porzione in esame dovrà risultare
in equilibrio. L’estensione della porzione di struttura scelta per lo studio dell’equilibrio non
è vincolata in alcun modo. Potrebbe essere limitata ad un singolo nodo o ad un insieme
composto da diversi elementi e nodi. Il sistema di forze considerato consiste non solamente
di ciascuna forza esterna applicata alla parte in esame, ma anche delle forze interne alla
struttura.

Una tecnica per la soluzione di strutture reticolari isostatiche è il metodo dei nodi.

Metodo dei nodi


In diverse geometrie di travature è possibile risolvere lo stato di sollecitazione operando
per nodi successivi. Tale procedimento richiede di individuare un nodo semplice o
canonico, definito come nodo in cui convergono due aste e di risolverlo mediante le due
equazioni di equilibrio del nodo stesso. Si procede quindi nell’isolare un nodo della
struttura reticolare tagliando le aste che vi convergono. Si esplicitano quindi gli sforzi
normali trasmessi dalle aste al nodo e le eventuali forze esterne. Si scrivono infine le
equazioni di equilibrio per il nodo in esame.
Poiché le forze sono convergenti al nodo, l’equazione di equilibrio dei momenti rispetto al
nodo stesso è – come detto prima – identicamente soddisfatta. Nel caso piano si hanno
pertanto a disposizione per ogni nodo solo le rimanenti due equazioni di equilibrio:

∑ F x ,nodo =0 ;∑ F y ,nodo
Si procede in sequenza, scrivendo l’equilibrio di un primo nodo e poi, servendosi dei
risultati ottenuti, di un secondo e così di seguito. Tuttavia poiché si hanno a disposizione
solo due equazioni di equilibrio per nodo, è necessario disporre di almeno un nodo a cui
sono collegate solo due aste, in modo da avere in partenza due sole incognite.
Successivamente si procederà utilizzando di volta in volta nodi per i quali si abbiano due
sole incognite.

4
Sistemi iperstatici
Nei sistemi iperstatici la sovrabbondanza di vincoli rende necessario l'utilizzo di equazioni
di congruenza in aggiunta a quelle di equilibrio. Esistono due metodologie di soluzione di
questi problemi: il metodo delle forze (si sostituiscono ai vincoli sovrabbondanti le loro
prestazioni statiche) e il metodo degli spostamenti, più laborioso dal punto di vista
computazionale ma facilmente ed efficacemente automatizzabile.

Metodo degli spostamenti


Il metodo degli spostamenti si basa sull'imposizione dell'equilibrio nei punti nodali della
struttura. Per ciascun nodo sono messe a bilancio le forze esterne note e le forze interne da
determinarsi che ciascun elemento convergente nel nodo esercita sul nodo stesso.
Le forze esterne vengono raccolte nel vettore dei termini noti mentre quelle interne sono
espresse in funzione degli spostamenti nodali (gradi di libertà) per il tramite della matrice
di rigidezza K. Si è infatti nel campo elastico-lineare e si modella l'asta come una molla
avente la sua rigidezza k, soggetta a forze applicate ai suoi due estremi generanti gli
spostamenti (si veda fig. 3).

Dati di input

Poiché l'equilibrio è scritto nei gradi di libertà attivi (ovvero i nodi non vincolati) della
struttura il primo passo consiste nell'elencazione di tutti i nodi di cui essa si compone e
nell'individuazione dei nodi sede di vincolo. La posizione dei nodi nello spazio è definita
dalle coordinate nodali rispetto ad un “riferimento globale” (valido per l'intera struttura).
La tabella dei vincoli definisce completamente i gradi di libertà (gdl) del problema, cioè il
numero di equazioni di equilibrio, esprimibili come 0 = gdl bloccato e i = gdl libero.

Il secondo passo consiste nel definire la tabella delle incidenze che collega ogni asta ai suoi
due nodi di estremità. E' necessario inoltre per costruire la matrice di rigidezza una matrice
che associ ad ogni asta le caratteristiche geometriche (area) e meccaniche (materiale e
modulo elastico) di cui sono composte le aste.

La trasformazione del modello meccanico della struttura in modello numerico in forma


matriciale è completata tramite una serie di matrici che ne stabiliscono la topologia, i
vincoli e la costituzione in un riferimento globale.

Riassumendo, i dati in ingresso necessari al sistema sono:

nel numero di aste


n numero di nodi
numero di nodi per asta (negli elementi TRUSS è sempre
npel
pari a 2)
numero dei gradi di libertà per nodo (negli elementi
ngdl
TRUSS è sempre pari a 2)
sdof = n * ngdl gradi di libertà del sistema

5
[]
X1 Y1 Matrice delle coordinate geometriche dei nodi rispetto ad
un sistema di riferimento cartesiano O(X,Y).
X2 Y2
gcoord = ⋯ ⋯
Xi Yi
⋯ ⋯
Xn Yn

[ ]
E1 A1 Matrice delle proprietà geometriche e dei materiali delle
aste (modulo elastico e area della sezione)
E2 A2
elprop= ⋯ ⋯
Ei Ai
⋯ ⋯
E nel Anel

[ ]
Nd 1, s Nd 1,e Matrice della connettività dei nodi, indicante per ogni asta
il nodo iniziale (s) e quello terminale (e).
Nd 2,s Nd 2,e
nodes= ⋯ ⋯
Nd i , s Nd i , e
⋯ ⋯
Nd nel , s Nd nel , e

[]
Ga bcdof: matrice indicante i gradi di libertà del sistema che
G sono vincolati e quindi assumono il corrispondente valore
bcdof = b nullo elencato in bcval .
Gc

[]
0
bcval= 0
0

[]
Matrice delle forze esterne applicate ai nodi in entrambe le
f 1, X direzioni X e Y.
f 1,Y
f 2, X
f 2,Y
ff = ..
f i ,X
f i,Y
..
f n ,X
f n, Y

6
Costruzione della matrice di rigidezza

Si ha che la posizione delle aste nel riferimento globale (e quindi nella struttura) è
completamente individuata dai nodi di estremità, infatti la lunghezza è data da:

L=  X B − X A 2Y B−Y A2 con le inclinazioni pari a:

1 1
cos =  X B − X A  sen= Y B−Y A 
L L

Va definita quindi una procedura automatica per l'effettiva costruzione della matrice di
rigidezza. Da un punto di vista algoritmico è conveniente istituire una procedura valida per
un'asta e quindi ripeterla identica per tutte quelle della struttura. Ne consegue che è
necessario definire dapprima la matrice di rigidezza della singola asta rispetto ad un suo
riferimento locale. Essa costituisce il legame elastico tra la variazione di configurazione
conseguente allo spostamento dei nodi di estremità e le forze interne che nascono in
seguito alle estremità dell'asta stessa:

f L= K L u L

Riferimento globale: assi X,Y


spostamenti nodali:
T T
s =[u A v A u B v B ]
forze nodali:
f T =[ H A V A H B V B ]T
matrice di rigidezza globale:
K
Riferimento locale: assi ξ,ζ
spostamenti nodali:
sT =[ A  A  B  B ]T
forze nodali:
T T
f =[ N A T A N B T B ]
Fig. 3: Elemento "truss" - sistemi di riferimento matrice di rigidezza locale:
KL

Considerando le regole di prodotto tra matrici si osserva che se si pone pari ad 1 la i-esima
componente di spostamento in sL e tutte le altre nulle il vettore di forze interne corrisponde
esattamente alla colonna i-esima di KL . Questa osservazione suggerisce anche il modo di
costruire la KL. Si assegna di volta in volta un componente di spostamento unitaria e le
altre nulle e si valutano le forze all'estremità dell'asta che così si generano.

Per costruire la prima colonna di KL si assegna dunque ξA = 1 e ζA = ξB = ζB = 0. L'asta è


EA EA EA
quindi compressa con sforzo assiale di intensità N =  L=  A= quindi la
L L L
forza in A ha lo stesso verso di ξ e NA = EA/L , mentre la forza in B ha verso opposto e N B
= - EA/L (inoltre TA = TB = 0).

7
Per costruire la seconda colonna di KL si assegna ξA = 1 e ξA = ξB = ζB = 0; con l'ipotesi di
piccoli spostamenti l'asta ruota con moto rigido attorno a B e quindi lo stato di
sollecitazione è nullo: NA = NB = TA = TB = 0. La terza e quarta colonna sono costruite allo
stesso modo, in modo da ottenere la seguente matrice di rigidezza di elemento locale:

[ ]
1 0 −1 0
EA 0 0 0 0
K L= tipica di un elemento TRUSS.
L −1 0 1 0
0 0 0 0

Per riportare le componenti di forza e spostamento dal sistema di riferimento locale a


quello globale è necessario effettuare una trasformazione di KL tramite la matrice di
rotazione R:

= X cos Y sin 


= X cos Y sin  [][


=
cos  sin  X
−sin  cos  Y ][ ] R= [cos  sin 
−sin  cos  ]
quindi gli spostamenti nel sistema di riferimento globale sono dati da:

[ ][ ][ ] [ ][ ]
A cos  sin  0 0 uA uA
A cos 0 0 vA 0 vA
= −sin   = R
B 0 0 cos  sin  uB 0 R uB
B 0 0 −sin  cos  vB vB

esprimibile in forma sintetica sia per gli spostamenti che per le componenti di forza da:

s L=T u
f L=T f

Essendo T= [ ]
R 0
0 R
una matrice ortogonale, e quindi tale che T-1 = TT, la matrice di
rigidezza dell'asta i-esima espressa nel sistema di riferimento globale è data da:

[]
1
i i iT i i iT i 0
f L= K L u L ⇒ T f =K L T u ⇒ f =T K L T u ⇒ K =T K L T assumendo u= per
0
0
ottenere esclusivamente la deformazione assiale.

8
In forma esplicita si ha:

[ ]
cos 2 cos sin  −cos2  −cos  sin 
2
EA cos sin  sin  −cos sin  −sin 2 
K i=
L −cos2  −cos  sin  cos 2  cos sin 
2
−cos sin  −sin  cos sin  sin 2 

Questa matrice è singolare, ovvero det Ki = 0 poiché essa si rifersce ad un elemento biella
non vincolato il cui unico grado di libertà deformativo è associato alla variazione di
lunghezza dell'asta, ovvero delle 4 componenti di spostamento solo una è associata alla
deformazione dell'asta mentre le altre tre definiscono un movimento rigido nel piano.

Le matrici di rigidezza delle aste Ki sono partizionabili in quattro sottomatrici 2x2 di


ordine pari ai gdl nodali dal seguente significato meccanico: le matrici sulla diagonale
principale KAA e KBB tengono conto dell'effetto che gli spostamenti di un nodo (A o B)
hanno sulle forze del nodo stesso (A o B), mentre le matrici fuori diagonale KAB e KBA =
KABT considerano l'effetto che gli spostamenti di un nodo (A o B) hanno sulle forze
dell'altro nodo (B o A):

K i=
[ K AA
K TAB
K AB
K BB ]
La matrice di rigidezza dell'intera struttura Ktot è una matrice quadrata di ordine 2nx2n con
n numero di nodi e 2 i gdl per nodo. Le righe sono tante quante le equazioni di equilibrio
che si possono scrivere per la struttura considerata non vincolata, le colonne tante quante le
componenti di spostamento complessive della struttura in assenza di vincoli. Anche la Ktot
può essere partizionata in sottomatrici 2x2 con lo stesso significato delle sottomatrici di
asta:

[ ]
K 11 K 12 K 13 K 14
K 22 K 23 K 24
K tot =
sym K 33 K 34
K 44

La collocazione delle Ki nella Ktot è semplice operando per sottomatrici. Procedendo asta
per asta si prende la KAA e la si aggiunge sommandola di volta in volta alla Kii con indici di
nodo corrispondenti, idem per la KBB. Entrambe queste sottomatrici contribuiscono alle
sottomatrici della diagonale principale di Ktot. Le sottomatrici KAB e KBA contribuiscono ai
termini fuori diagonale della KTOT e si trattano allo stesso modo sommandole alle KIJ con
indici di nodo corrispondenti.

La KTOT è una matrice singolare in quanto non considera i vincoli. I nodi vincolati non
contribuiscono alle equazioni di equilibrio e le corrispondenti righe e colonne devono
pertanto essere eliminate dalla Ktot .

9
Calcolo degli spostamenti nodali

Costruita la Ktot e note le forze esterne ff è possibile calcolare la matrice degli spostamenti
nodali:

D i=inv  K tot ⋅ ff

ovvero un vettore 2n contenente gli spostamenti nei rispettivi gradi di libertà attivi.

Il sistema è ora risolto.

Calcoli successivi

Per ottenere gli sforzi assiali e le tensioni agenti in ogni singola asta è necessario per ogni
asta calcolare il vettore delle forze di elemento:

[][ ]
i i
us Hs
v V
Ki s = s
ue He
ve Ve

ricostruendo la matrice di rigidezza d'elemento e moltiplicandola per il vettore degli


spostamenti associati ai gradi di libertà dei nodi di estremità.

Gli sforzi normali e le tensioni sono quindi date da:

∣N i∣=  H is 2V is 2
∣N i∣
∣ i∣=
Ai

Il vettore di forze di elemento è tale che Hs = - He e Vs = - Ve, pertanto è sufficiente


controllare il segno di He per determinare se gli sforzi sono di trazione o di compressione.

10
Soluzione manuale con il metodo degli spostamenti
E' evidente come la procedura numerica offerta dal metodo degli spostamenti, pur essendo
meno “didattica” per la comprensione della fisica del problema, possa essere efficacemente
utilizzata per la soluzione statica di telai non labili. Il sistema risolvente infatti è sempre
determinato dato che è possibile scrivere tante equazioni di equilibrio quanti sono i gradi di
libertà della struttura.

Verrà ora risolto il seguente problema iperstatico manualmente applicando il metodo degli
spostamenti:

Dati

Fig. 4: Problema iperstatico di esempio

● sistema di riferimento cartesiano x,y


● nodi 1,3,4 vincolati con cerniere
● forza applicata nel nodo 2 in direzione -y pari a 1000 N
● aste dalle seguenti proprietà:

Asta Lunghezza (mm) Area (mm2)


1 2309 2000
2 2000 2500
3 4000 3000
tutte costituite d'acciaio ( E = 200000 MPa )

11
Equazioni di equilibrio
Si scrive l'equazione di equilibrio rispetto all'unico nodo che può spostarsi, ovvero il 2:

Fig. 5: Schema delle forze agenti

x : N 3⋅cos 30 ° −N 1⋅cos 60 ° =0


y : N 1⋅sin 30 °N 2 N 3⋅sin 30° −1000=0

Si hanno due gradi di libertà per nodo e due nodi per ogni asta, ma la struttura ha attivi solo

[]
u
quelli del nodo 2 ( u= 2 ). Per risolvere il problema quindi si riscrivono le equazioni
v2
di equilibrio rispetto a questi gdl, ottenendo il sistema risolvibile di 2 equazioni in 2
incognite.

12
Calcolo deformazioni
Per fare ciò si sfrutta il principio di sovrapposizione degli effetti (valido considerando la
teoria dei piccoli spostamenti per cui si approssimano gli angoli alle loro tangenti)
applicando gli spostamenti uno per volta in direzione positiva (rispetto al sistema di
riferimento indicato in fig. 4) e infine sommandoli:

Spostamento u2:

Fig. 6: Deformazione delle aste in seguito all'applicazione di u2

In seguito all'applicazione di u2 si hanno le seguenti deformazioni delle aste:

u 1
1 =u 2⋅cos 60 ° = u 2
2
u
2 =0
u3 =−u2⋅cos 30° =− u 2
3
2

L'asta 2 è considerata indeformata in quanto – sempre per l'ipotesi dei piccoli spostamenti
– si suppone che l'angolo non vari.

13
Spostamento v2:

Fig. 7: Deformazione delle aste in seguito all'applicazione di v2

In seguito all'applicazione di v2 si hanno le seguenti deformazioni delle aste:

v1=−v 2⋅cos 30 ° =− v 2


3
2
v2=−v 2
1
v3=−v 2⋅cos 60 ° =− v 2
2

Effetti globali

Si sommano quindi le due deformazioni per ogni asta:

1 = u 2 −  v 2
1 3
2 2
2=−v 2
3
3=− u 2− v 2
1
2 2

14
Soluzione della matrice degli spostamenti
Relazioni costitutive

A questo punto è necessario collegare le deformazioni e le forze applicate al materiale e


alle caratteristiche geometriche di ogni asta:

L1
N 1= u 2−  v 2
1 3
1 =
E A1 2 2
L
2= 2 N 2=−v 2
E A2
L
3= 3 N 3=− u 2− v 2
3 1
E A3 2 2

Equazioni di equilibrio

Si sostituiscono i nuovi valori nelle equazioni di equilibrio iniziali ( K u = P ):

Essendo:

N 1=
1
2  3 E A1
u2 − v 2
2 L1 
E A2
N 2 =−v 2
L2

2
3

N 3=−  u 2− v 2
1
2
E A3
L3 
Si ha:


2 L3 2 2 2 L1 2 2 2 
3 E A3  3 u 1 v −1 E A1 1 u − 3 v =0
2 2 2 
2 L1 
2 2 2 2 L2 2 
2 L3 
 3 E A1 1 u − 3 v − E A2 v −1 E A3 3 u 1 v −1000=0
2 2 2 2 
Raccogliendo:

[−
3 E A 3 1 E A1
4 L3

4 L1 ] [
u 2 − 
3 E A3  3 E A1
4 L3

4 L1
v 2=0
]
[ 3 E A 1  3 E A3
4 L1

4 L3
u 2 −
] [
3 E A1 E A2 1 E A3
4 L1

L2

4 L3
v 2=1000
]

15
In forma matriciale:

[ ]
3 A3 1 A1  3 A3   3 A1
− − −
E
4 L3 4 L1 4 L3 4 L1
3 A1 −  3 A3 − 3 A1 − A2 − 1 A3 [ ][ ]
u2
v2
= 0
1000
4 L1 4 L3 4 L1 L 2 4 L 3

Sostituendo i valori si ha:

[ −

][ ] [
3 3000 1 2000 3 3000  3 2000
− −3  3
200000 4 4000 4 4000
 3 2000  3−  3 3000 −
4 4000 4 4000
3 2000 2500 1 3000
− −
u2
v2
= 0
1000 ]
4 4000 4 4000 4 4000 2000 4 4000

[ ][ ] [
9 3
−
33 3

− 
200000
3
16
−3 
8
3
4 4 8
3 5 3 v2
−3 − −
u2
= 0
1000 ]
8 16 8 4 16

[ ][ ] [
−9−2  3 −3  36
200000 16 16
6−3  3 −6  3−23
u2
v2
= 0
1000 ]
16 16

La cui soluzione è:

u2 = - 0,00015475 mm
v2 = - 0,00239948 mm

16
Implementazione MATLAB
MATLAB (abbreviazione di Matrix Laboratory) è un ambiente per il calcolo numerico e
un linguaggio di programmazione (interpretato) creato dalla MathWorks. MATLAB
consente facili manipolazioni di matrici, visualizzazione di funzioni e dati, implementa
algoritmi, consente la creazione di interfacce utente, e si interfaccia con altri programmi.
Nonostante sia specializzato nel calcolo numerico, un toolbox opzionale interfaccia
MATLAB con il motore di calcolo simbolico di Maple. MATLAB è usato da milioni di
persone nell'industria, nelle università e funziona su diversi sistemi operativi, tra cui
Windows, Mac OS, Linux e Unix.

Fig. 8: Ambiente MATLAB (v. 2007a) in Windows

L'ambiente consta in una finestra di comandi nei quali l'utente digita le istruzioni da
eseguire al prompt; queste vengono memorizzate nell' “history”. Le funzioni risiedono in
una cartella di lavoro che rappresenta il percorso di riferimento per tutti i files richiamati
dagli algoritmi, e possono essere modificate dall'editor interno a MATLAB il quale offre
tutte gli strumenti tipici di un software di programmazione (debug, breakpoint, analisi step
by step, ...).

La facilità d'uso e la potenza di questo software hanno reso possibile lo sviluppo di un


solutore numerico per i problemi di analisi strutturale di travature reticolari piane prima
descritti e risolti manualmente. E' stata adottata l'ultima versione attualmente disponibile
(la 7.4.0 della relase R2007a).

17
L'applicazione CAMP2000
L'implementazione è stata articolata in due fasi: inizialmente è stato sviluppato il solutore
MATLAB (il kernel) e in seguito è stato sviluppato un software per facilitare l'inserimento
dei dati (il preprocessore).

Il CAMP2000 infatti è un'applicazione composta da due parti:

● il preprocessore CAMP2000 sviluppato in Delphi 5 per ambienti Windows


● lo script CAMP2000KERNEL sviluppato in MATLAB

Il preprocessore ha il compito di preparare i dati in ingresso al kernel (tramite


l'esportazione di files testuali) il quale esegue i calcoli finali mostrando i risultati in termini
di spostamenti, tensioni e forze.

Il contenuto dei files del preprocessore con le schermate ed il codice sorgente del kernel
sono indicati in appendice.

Il preprocessore
La versione finale attualmente sviluppata è la 0.2.

Installazione

Lanciare il file CAMP2000_02_setup.exe:

Fig. 9: Schermata iniziale dell'installazione

e cliccare su Avanti ; apparirà un messaggio d'avviso da leggere prima dell'installazione


(corrispondente al contenuto del file Leggimi.txt) :

18
Fig. 10: Seconda schermata installazione

Cliccare nuovamente su Avanti e scegliere la cartella dove installare il programma


(ricordando di evitare nomi accentati):

Fig. 11: Terza schermata installazione

Verrà quindi chiesto se aggiungere nel menu Start, sul Desktop e sulla barra dei
collegamenti veloci il collegamento al programma:

Fig. 12: Quarta schermata installazione Fig. 13: Quinta schermata installazione

19
Cliccare quindi su Avanti fino al riepilogo delle informazioni sull'installazione e infine
cliccare su Installa:

Fig. 14: Sesta schermata installazione


quindi su Fine una volta terminato:

Fig. 15: Settima schermata installazione

Fig. 16: Ottava schermata installazione

Il programma è ora installato nella cartella di destinazione.

20
Utilizzo

Lanciato il programma apparirà la seguente finestra:

Fig. 17: Schermata iniziale programma

(nota: cliccando su “?” è possibile accedere alla guida rapida del programma).

Nuova travatura

Per creare una nuova travatura partendo da 0 cliccare su File, quindi su Nuova travatura .

In “Nome travatura” va inserito il nome del problema che si vuole risolvere e affianco
vanno selezionate le unità di misura da considerare (per la forza, la lunghezza e quindi per
l'area e le tensioni; se ad esempio si seleziona N,mm il programma considererà
automaticamente i mm2 per l'area e i N/mm2 per le tensioni). La scelta dell'unità di misura
non altera i valori numerici inseriti.

Dati di input

Va inserito il numero di elementi nel sistema (nel), ovvero il numero di aste dello schema
reticolare e poi il numero di nodi presenti (n) (gli altri due campi sono bloccati in quanto si
considerano esclusivamente bielle nel piano).

21
Griglia dei nodi

Va definita ora la griglia cartesiana rappresentativa dello schema piano:

Fig. 18: Griglia cartesiana interpretata dal programma con disposizione generica degli n nodi

Si definiscono le coordinate X e Y dei nodi, relativi ad un sistema di riferimento orientato


come in figura. Si consiglia di seguire il seguente procedimento:

● Fissare l'origine del sistema di riferimento con il primo nodo (coordinate del nodo 1
pari a 0,0)
● Numerare i nodi da sinistra verso destra e dal basso verso l'alto (come in fig. 18)

Cliccando su Griglia dei nodi si aprirà una nuova finestra con una tabella contenente tante
colonne quanti sono i nodi presenti nel sistema. Inserite le coordinate di ogni nodo,
ricordando l'unità di misura precedentemente adottata e NON utilizzare la virgola per i
decimali bensì il punto “.” .

Proprietà geometriche e dei materiali

Cliccando su Proprietà geometriche e dei materiali si definisce, per ogni asta del sistema,
l'area della sezione e il modulo elastico del materiale che la costituisce. E' inserito come
valore predefinito il modulo elastico dell'acciaio pari a 200000 MPa (N/mm 2) . Questi
valori sono fondamentali per calcolare le tensioni in ogni asta, mentre se si è in fase di
predimensionamento si possono inserire dei valori casuali e calcolare in forma corretta solo
gli sforzi assiali.

22
Per facilitare l'inserimento, nel caso di aste tutte uguali, una volta inseriti i valori per la
prima asta, cliccando su Copia i valori della prima asta nelle altre questi verranno
automaticamente assegnati anche agli altri elementi.

Formazione delle aste

Ogni asta è rappresentata come l'elemento che unisce il nodo iniziale e quello finale.
Pertanto per rappresentare le aste dello schema reticolare considerato, per ognuna di esse
nella tabella “Connessione dei nodi per la formazione delle aste” va indicato il numero del
nodo iniziale e quello finale; con la prescrizione precedente sulla definizione della griglia,
si ricorda che le aste vanno inserite considerando come nodo iniziale e finale
rispettivamente il numero più piccolo e quello più grande tra i due in modo da evitare
errate inclinazioni nel kernel.

Assegnazione dei vincoli

I vincoli vengono assegnati come limitazione ai gradi di libertà del sistema, pertanto
possono essere semplicemente inseriti nel programma nella tabella “Definizione dei vincoli
applicati ai nodi” . Per il nodo nel quale è presente il vincolo assegnare allo spostamento
considerato il valore 0, mentre si lascia 1 se è libero. Ad esempio se nel nodo 1 è presente
una cerniera, sia in Orizzontale (X) che in Verticale (Y) si inserirà 0.

Applicazione delle forze

I carichi esterni trasmettono le loro sollecitazioni alla travatura reticolare tramite forze
applicate direttamente ai nodi. Nella tabella “Applicazione delle forze ai nodi” vanno
assegnati i valori per il nodo in interesse e per la direzione considerata. Si assume il
sistema di riferimento come in figura n.

Salvataggio della travatura

E' possibile salvare la travatura inserita per poterla aprire e modificare in un secondo
momento. Per fare ciò è sufficiente cliccare su File, quindi su Salva travatura attuale ... e
scegliere dove posizionare il file *.c2k che è l'estensione predefinita dei files del
processore; sono archivi in formato CAB contenenti gli stessi file dell'esportazione.

Caricare una travatura salvata

Per recuperare una travatura precedentemente salvata è sufficiente cliccare su File, quindi
su Carica travatura esistente ... e scegliere il file *.c2k salvato.

Esportazione in MATLAB

Compilazione

Una volta completati tutti i campi dell'inserimento il programma è pronto per generare i
file necessari allo script MATLAB per eseguire i calcoli.
I files da generare constano in 6 file *.txt che lo script leggerà, pertanto sarà necessario
definire la cartella nella quale verranno salvati. Per fare ciò si clicca su Esegui, quindi su
Compila . Si sceglie la cartella (è consigliabile utilizzare una sottocartella di quella di

23
lavoro di MATLAB) e il programma esporterà i files. Se questi sono già esistenti, verranno
automaticamente sovrascritti.

Il preprocessore ha quindi terminato il proprio compito preparando il necessario per i


calcoli da parte del kernel.

Il kernel
E' costituito dai seguenti 5 files:

● camp2000kernel.m (script principale)


● feaplyc.m (funzione esterna)
● feasmbl.m (funzione esterna)
● feeldof.m (funzione esterna)
● fetruss.m (funzione esterna)

contenuti nella sottocartella c2kmat del percorso nel quale è installato il preprocessore. Si
possono quindi copiare i files nella cartella di lavoro preferita di MATLAB.

Lo script principale da lanciare è una funzione dalla seguente sintassi:

camp2000kernel(path,verbose);

con:

● path: stringa rappresentante il nome della cartella di riferimento per i files generati
dal preprocessore. Può essere un percorso assoluto (ex: 'C:\Prova\Esempio71') o
semplicemente il nome della sottocartella esportata se questa è contenuta nella
stessa directory dello script (ex: 'Esempio71')
● verbose: stringa indicante il tipo di visualizzazione dei risultati. Per visualizzare
tutti i passaggi svolti nonchè il dettaglio dei risultati scrivere “si”, altrimenti “no”
per visualizzare esclusivamente gli spostamenti, le forze e le tensioni trascurando la
formattazione e i passaggi intermedi.

1) Lettura dei dati in ingresso

Il kernel legge i dati necessari in ingresso da files contenuti nella cartella indicata nella
variabile path, memorizzandoli nelle relative matrici:

File di origine Dati contenuti


1input.txt - nel: numero di elementi nel sistema (numero di aste) [intero]
- nnel: numero di nodi per elemento [intero]
- ndof: numero di gradi di libertà per nodo [intero]
- nnode: numero totale di nodi nel sistema [intero]
- uforza: unità di misura per la forza [stringa]
- ulungh: unità di misura per la lunghezza [stringa]
- uarea: unità di misura per le aree [stringa]
- utens: unità di misura per le tensioni [stringa]

24
2gcoord.txt - gcoord: matrice delle coordinate geometriche dei nodi
3elprop.txt - elprop: matrice delle proprietà geometriche e dei materiali delle aste
4nodes.txt - nodes: matrice della connettività dei nodi per la formazione delle aste
5constraints.txt - constraints: matrice dei vincoli, scomposta in bcdof e bcval
6forces.txt - ff: matrice delle forze applicate ai nodi

Una volta letti i dati dal file 1input.txt il programma calcola i gradi di libertà totali del
sistema:

sdof=nnode*ndof;

e inizializza le matrici che verranno utilizzate:

ff=zeros(sdof,1); %vettore di forze del sistema


kk=zeros(sdof,sdof); %matrice di rigidezza del sistema
displ=zeros(sdof,sdof); %matrice degli spostamenti di sistema
index=zeros(nnel*ndof,1); %vettore degli indici
elforce=zeros(nnel*ndof,1); %vettore di forza dell'elemento
eldisp=zeros(nnel*ndof,1); %vettore della disposizione dei nodi
dell'elemento
k=zeros(nnel*ndof,nnel*ndof); %matrice di rigidezza dell'elemento
stress=zeros(nel,1); %vettore delle tensioni per ogni elemento

Gli altri files sono letti dall'istruzione csvread che interpreta i file CSV (Comma
Separated Values) esportati dal preprocessore. Le matrici infatti vengono salvate con i dati
riga per riga, e i valori in colonna sulla stessa riga separati da virgola; ad esempio la
matrice gcoord dell'esempio Demo1 è:

Contenuto file 2gcoord.txt Matrice importata in MATLAB


0,0 gcoord =
0,1000
1000,0 0 0
1000,1000 0 1000
2000,0 1000 0
2000,1000 1000 1000
2000 0
2000 1000

2) Ciclo degli elementi

Per costruire la matrice di rigidezza della struttura ( kk ) il kernel processa ogni asta:

for iel=1:nel %cicla per il numero totale di elementi

computando la matrice di rigidezza di elemento (k) per poi assemblarla in quella generale
(kk); per ogni asta quindi calcola:

– la lunghezza nella variabile lungh in base alle coordinate cartesiane dei nodi di
estremità dell'asta:

25
nd(1)=nodes(iel,1); %primo nodo connesso con l'elemento iesimo
nd(2)=nodes(iel,2); %secondo nodo connesso con l'elemento iesimo
x1=gcoord(nd(1),1); y1=gcoord(nd(1),2); %coordinate per il primo nodo
x2=gcoord(nd(2),1); y2=gcoord(nd(2),2); %coordinate per il secondo
nodo
length=sqrt((x2-x1)^2+(y2-y1)^2); %lunghezza dell'elemento

– l'inclinazione (radianti) rispetto al sistema di riferimento globale nella variabile beta:

if (x2-x1)==0;
if y2>y1;
beta=2*atan(1);
else
beta=-2*atan(1);
end
else
beta=atan((y2-y1)/(x2-x1));
end

Il campo di validità dell'inclinazione è −90° 90 ° :

Fig. 19: Inclinazioni possibili delle aste interpretate dal programma


(X1,Y1 = coordinate nodo iniziale; X2,Y2 = coordinate nodo finale)

– le proprietà del materiale che costituiscono l'asta (modulo elastico nella variabile el)
nonché l'area della sezione (nella variabile area) dalla matrice elprop:

el=elprop(iel,1); %estrae il modulo elastico


area=elprop(iel,2); %estrae l'area della sezione

– il sistema dei gradi di libertà dell'elemento, ovvero quali gradi di libertà (da 1 a sdof)
sono quelli di interesse dell'asta:

index=feeldof(nd,nnel,ndof); %estrae il sistema dei gradi di libertà


dell'elemento

Questi dati sono assemblati tramite la funzione fetruss:

k=fetruss(el,length,area,beta); %computa la matrice degli elementi

26
che costruisce la seguente matrice:

[ ]
cos  2 cos sin  −cos 2  −cos  sin 
2
EA cos sin  sin  −cos sin  −sin 2 
K i=
L −cos 2  −cos  sin  cos 2  cos sin 
2
−cos sin  −sin  cos sin  sin 2 

(file fetruss.m):

%References: "The finite element method using MATLAB" - Young W. Kwon &
%Hyochoong Bang - CRC Press, 2000
function[k]=fetruss(el,leng,area,beta)
c=cos(beta); s=sin(beta);
k=(area*el/leng)*[c*c c*s -c*c -c*s;...
c*s s*s -c*s -s*s;...
-c*c -c*s c*c c*s;...
-c*s -s*s c*s s*s];
end

Una volta computata la matrice di rigidezza d'asta, questa viene aggiunta all'interno di
quella globale del sistema:

kk=feasmbl(kk,k,index); %assembla la matrice di sistema inserendo quella


di elemento

tramite la funzione feasmbl:

(file feasmbl.m):

function[kk]=feasmbl(kk,k,index)
edof=length(index);
for i=1:edof
ii=index(i);
for j=1:edof
jj=index(j);
kk(ii,jj)=kk(ii,jj)+k(i,j);
end
end

la quale somma il contenuto della k d'asta al contenuto già presente nella kk globale nella
posizione relativa al sistema dei gradi di libertà (indicato dal vettore index) .

3) Assegnazione dei vincoli e soluzione della matrice degli spostamenti

Data la kk (ancora in forma singolare) il kernel ora applica le condizioni al contorno:

[kk,ff]=feaplyc(kk,ff,bcdof,bcval); %applicazione delle condizioni al


contorno

tramite la funzione feaplyc:

27
(file feaplyc.m):

%References: "The finite element method using MATLAB" - Young W. Kwon &
%Hyochoong Bang - CRC Press, 2000
function[kk,ff]=feaplyc(kk,ff,bcdof,bcval)
n=length(bcdof); %numero dei gradi di libertà vincolati
sdof=size(kk); %gradi di libertà del sistema
for i=1:n
c=bcdof(i); %grado di libertà vincolato
for j=1:sdof
kk(c,j)=bcval(i);
kk(j,c)=bcval(i);
end
kk(c,c)=1; %per non annullare il determinante
ff(c)=bcval(i); %la forza sul vincolo è assorbita tutta da esso
end

la quale assegna alle righe e alle colonne della kk relative ai gdl vincolati, indicati nella
matrice bcdof , i valori della matrice bcval (sempre nulli); ad esempio per il problema
Demo1 si ha:

bcdof = bcval =

1 0
2 0
10 0

Inoltre fissa a 1 i valori sulla diagonale principale onde evitare di ridurre il rango della
matrice e annulla l'eventuale forza assegnata al nodo vincolato (in quanto non viene
assorbita dal resto della struttura).

E' ora possibile calcolare la matrice degli spostamenti nodali nella variabile displ :

displ=kk\ff; %risoluzione della matrice per gli spostamenti dei nodi

4) Calcolo delle tensioni e delle forze nelle aste

Per ogni asta si effettua lo stesso ciclo del punto 2) per ricalcolare la matrice di rigidezza
d'elemento k. In seguito si ricavano gli spostamenti relativi ad ogni asta:

for i=1:(nnel*ndof) %estrae gli spostamenti associati con l'elemento


iesimo
eldisp(i)=displ(index(i));
end

e si ricava il vettore forza d' elemento:

elforce=k*eldisp; %vettore forza elemento

A questo punto è possibile ottenere il modulo dello sforzo normale e la tensione alla quale
è soggetta l'asta:

N(iel)=sqrt(elforce(1)^2+elforce(2)^2); %sforzi normali


stress(iel)=N(iel)/area; %tensioni

28
e applicare il segno a seconda se di compressione (-) o trazione (+):

if (elforce(3))<0; %controllo se sono o no di compressione


stress(iel)=-stress(iel);
N(iel)=-N(iel);
end

5) Visualizzazione dei risultati

Nel caso fosse attivata l'opzione “verbosa” sono visualizzati per ogni asta lo sforzo
normale e la tensione con indicato il sistema di riferimento scelto:

if (verbose == 'si')
disp(['Asta ' int2str(iel)]);
disp([' - Sforzo normale elemento: ' num2str(N(iel)) ' ' uforza]);
disp([' - Tensione elemento: ' num2str(stress(iel)) ' ' utens]);
end

In seguito, per ogni grado di libertà del sistema, viene indicato il relativo spostamento:

num=1:1:sdof;
format long
disp([' ']);
disp(['Spostamenti in ' ulungh ': (n. gdl e spostamento)']);
disp([num' displ]);
format short

Come ultima operazione il kernel esporta i valori degli spostamenti, forze e tensioni in tre
files CSV (Spostamenti.txt, N.txt e Tensioni.txt):

% salva i risultati nella cartella dei dati di input


csvwrite([path '\Spostamenti.txt'],displ); %spostamenti
csvwrite([path '\N.txt'],'N); %sollecitazioni assiali
csvwrite([path '\Tensioni.txt'],stress); %tensioni

oltre a salvare tutto l'ouptut della finestra di comando con il comando diary nel file
Output.txt contenuto nella stessa cartella dello script. Se il file è già presente, il testo verrà
aggiunto a quello precedente.
Potrebbero esserci dei problemi di visualizzazione dei dati utilizzando il blocco note di
Windows, poiché il formato nel quale vengono salvati i files è quello UNIX, pertanto è
consigliabile utilizzare un editor di testo esterno per la visualizzazione.

Il postprocessore
E' costituito dal file camp2000pp.m contenuto nella sottocartella c2kmat del percorso nel
quale è installato il preprocessore. Si può quindi copiare il file nella cartella di lavoro
preferita di MATLAB.

Lo script principale da lanciare è una funzione dalla seguente sintassi:

camp2000pp(path);

29
con path avente lo stesso significato dello script precedente. Il postprocessore è lanciato
automaticamente dal kernel se è attivata l'opzione verbosa:

if (verbose == 'si')
%6) LANCIA IL POST PROCESSORE
camp2000pp(path);
...

1) Lettura dei dati in ingresso

Utilizzando le stesse funzioni del kernel, il postprocessore carica i seguenti files per poter
costruire i grafici ed effettuare i calcoli successivi:

File di origine Dati contenuti


1input.txt - nel: numero di elementi nel sistema (numero di aste) [intero]
- nnel: numero di nodi per elemento [intero]
- ndof: numero di gradi di libertà per nodo [intero]
- nnode: numero totale di nodi nel sistema [intero]
- uforza: unità di misura per la forza [stringa]
- ulungh: unità di misura per la lunghezza [stringa]
- uarea: unità di misura per le aree [stringa]
- utens: unità di misura per le tensioni [stringa]
2gcoord.txt - gcoord: matrice delle coordinate geometriche dei nodi
3elprop.txt - elprop: matrice delle proprietà geometriche e dei materiali delle aste
4nodes.txt - nodes: matrice della connettività dei nodi per la formazione delle aste
5constraints.txt - constraints: matrice dei vincoli, scomposta in bcdof e bcval
6forces.txt - ff: matrice delle forze applicate ai nodi
Spostamenti.txt - displ: vettore degli spostamenti dei nodi
N.txt - N: vettore delle sollecitazioni delle aste
Tensioni.txt - stress: vettore delle tensioni delle aste

2) Grafico della travatura

In seguito il postprocessore apre una finestra grafica in MATLAB rappresentando la


travatura reticolare con le forze applicate, i vincoli e la numerazione delle aste in modo da
poter mostrare graficamente eventuali errori di inserimento dei dati nel preprocessore.

3) Calcolo dei valori massimi

In base ai dati esportati dal kernel, il postprocessore individua i valori massimi degli
spostamenti, delle sollecitazioni e delle tensioni.

Per gli spostamenti vengono distinti quelli in direzione orizzontale (1° grado di libertà del
nodo) e in direzione verticale (2° grado di libertà del nodo) estraendo per i primi i valori
con indice dispari dal vettore displ e per i secondi quelli con indice pari:

30
for j=1:nnode %cicla per il numero di nodi
doriz(j) = displ((j*ndof)-1);
dvert(j) = displ((j*ndof));
end

Il valore massimo è preso considerando il valore assoluto dei due vettori:

[DHmax,NDHmax]=max(abs(doriz)); %orizzontale
[DVmax,NDVmax]=max(abs(dvert)); %verticale

indicando in NDHmax e NDVmin il nodo per il quale si ha il valore DHmax e DVmax.

Per le sollecitazioni e le tensioni si calcolano i valori massimi (trazione maggiore) e


minimi (compressione maggiore):

[Nmax,ANmax]=max(N); %trazione
[Nmin,ANmin]=min(N); %compressione
[Smax,ASmax]=max(stress); %trazione
[Smin,ASmin]=min(stress); %compressione

indicando le aste per le quali si hanno i valori individuati.

4) Grafico delle sollecitazioni e delle tensioni

In seguito al calcolo dei valori massimi, il programma aprirà due finestre grafiche in
ognuna delle quali è rappresentata la travatura reticolare con i vincoli applicati e sulle aste
(colorate a seconda se tese o compresse) i valori (arrotondati alla cifra intera prossima) di
sollecitazione e tensione corrispondente, evidenziando in grassetto i valori maggiori.

Fig. 20: Finestre grafiche di esempio esportate dal post-processore

31
Esempio dimostrativo
Il seguente esempio dimostrativo (presente anche nella guida d'uso del software) verrà
risolto sia con il software che manualmente con il metodo dei nodi.

Problema

Risolvere il seguente schema:

Fig. 21: Schema travatura reticolare di esempio

nel quale sono già numerate le aste (da 1 a 9) e i nodi (da 1 a 6), composte tutte in acciaio
(E = 200 GPa) e di area A = 2000 mm2 .

32
Soluzione con CAMP2000

1) Dati di input

Si impostano le 9 aste e i 6 nodi adottando l'unità N e mm:

Fig. 22: Preprocessore - passaggio 1

2) Griglia dei nodi

Cliccare su Griglia dei nodi per definire le coordinate cartesiane del sistema.
Fissare convenzionalmente l'origine con il nodo 1 con x positivo verso destra e y positivo
verso l'alto:

Fig. 23: Preprocessore - passaggio 2


(le dimensioni sono in millimetri come precedentemente indicato).
Cliccare su Salva per salvare le impostazioni.

3) Proprietà geometriche e dei materiali

Cliccare nella finestra principale su Proprietà geometriche e dei materiali ... .


Poichè tutte le aste sono uguali, vanno definiti i valori per la prima asta e poi è sufficiente
cliccare su Copia i valori della prima asta nelle altre :

33
Fig. 24: Preprocessore - passaggio 3
(le dimensioni sono in N/mm2 = MPa e mm2 ).
Cliccare su Salva per salvare le impostazioni.

4) Formazione delle aste

Va indicato ora al programma come sono formate le aste, ovvero come sono connesse
indicando il nodo iniziale e finale per ognuna di esse inserendo i valori nella tabella
Connessione dei nodi per la formazione delle aste:

Fig. 25: Preprocessore - passaggio 4 (aste dalla 1 alla 6)

Fig. 26: Preprocessore - passaggio 4 (aste dalla 3 alla 9)

5) Assegnazione dei vincoli

In seguito è necessario indicare i vincoli del telaio, espressi come vincoli dei gradi di
libertà del nodo interessato, nella tabella Definizione dei vincoli applicati ai nodi .

34
Nell'esempio si nota come nel nodo 1 sia presente una cerniera (vincolati entrambi i g.d.l.)
mentre nel nodo 5 un carrello (vincolato solo lo spostamento verticale):

Fig. 27: Preprocessore - passaggio 5

6) Applicazione delle forze

Una volta definita la travatura reticolare l'ultimo passaggio è l'applicazione dei carichi
esterni espressi come forze applicate ai nodi definibili nella tabella Applicazione delle
forze ai nodi .

Nell'esempio si nota come sia applicata una forza diretta verticalmente verso il basso nel
nodo 4 pari a 400 N:

Fig. 28: Preprocessore - passaggio 6

7) Compilazione dei dati

Il problema è stato definito. E' consigliabile in questa fase salvare la travatura.


Si clicca su Esegui, quindi su Compila e si sceglie (creandone una nuova, ad esempio
“Demo1”) una sottocartella di quella nella quale sono ospitati gli script MATLAB. Una
volta dato l'Ok si aprirà la cartella contenente i files esportati a conferma dell'operazione.

8) Calcolo in MATLAB

Il preprocessore termina qui il suo lavoro. Va ora aperto l'ambiente MATLAB e impostata
come current directory quella dello script.

Per lanciare lo script va dato il seguente comando al prompt:

camp2000kernel('Demo1','no');

e il kernel inizierà i calcoli (è consigliabile utilizzare l'opzione verbosa - quindi 'si' al posto
di 'no' - per comprendere al meglio il funzionamento del codice).

35
Il risultato sarà:

Spostamenti in mm: (n. gdl e spostamento)


1.000000000000000 0
2.000000000000000 0
3.000000000000000 0.000500000000000
4.000000000000000 -0.000000000000000
5.000000000000000 0.000500000000000
6.000000000000000 -0.001914213562373
7.000000000000000 0.000500000000000
8.000000000000000 -0.001914213562373
9.000000000000000 0.001000000000000
10.000000000000000 0
11.000000000000000 0.000500000000000
12.000000000000000 0.000000000000000

tensioni =

1.0000 0
2.0000 0.1000
3.0000 -0.1414
4.0000 0.0000
5.0000 -0.0000
6.0000 0.1000
7.0000 -0.1414
8.0000 0
9.0000 0.0000

forze =

1.0000 0
2.0000 200.0000
3.0000 -282.8427
4.0000 0.0000
5.0000 -0.0000
6.0000 200.0000
7.0000 -282.8427
8.0000 0
9.0000 0.0000

con le forze espresse in N e le tensioni in MPa.

36
Soluzione con il metodo dei nodi

Lo schema statico è banalmente risolvibile, in quanto le due reazioni vincolari sono pari a
y = 200 N dirette verso l'alto.

Si definiscono gli sforzi assiali di ogni asta come vettori uscenti dai nodi, pertanto –
definendo per ognuno di essi un sistema di riferimento cartesiano destrorso – si hanno le
seguenti equazioni di equilibrio alla traslazione:

Nodo Traslazione asse x: Traslazione asse y:


N3 N3
1 N 2 =0 N 1 200N =0
2 2
2 N 1=0 N 4 =0
3 N 6− N 2=0 N 5=0
N3 N7 N3 N7
4 −N 4N 8−  =0 N 5400  =0
2 2  2 2
N7 N7
5 N 6 =0 N 9200 =0
2 2
6 N 8=0 N 9=0

I risultati del calcolo manuale e quello automatico al confronto sono i seguenti:

Sforzo nell'asta Soluzione manuale Soluzione con il CAMP2000


N1 0N 0N
N2 200 N 200 N
N3 - 282,84 N - 282,84 N
N4 0N 0N
N5 0N 0N
N6 200 N 200 N
N7 -282,84 N -282,84 N
N8 0N 0N
N9 0N 0N

tutti coincidenti.

37
Soluzione automatica con il metodo degli
spostamenti
Verrà ora risolto col CAMP2000 il problema precedentemente svolto manualmente con il
metodo degli spostamenti.

Preparazione dei dati


In riferimento alla fig.4, adottando la stessa numerazione dei nodi e delle aste, fissando
l'origine nel nodo 1 si sono calcolate le coordinate dei nodi e si sono inseriti i seguenti dati:

Fig. 29: Schermata CAMP2000 con i dati inseriti

38
Calcolo in MATLAB
Lanciando lo script con l'opzione verbosa attivata si ha:
CAMP2000 - Kernel
-----------------
1) Dati di input:
Travatura "Esercizio svolto manualmente" calcolata in data: 09-Sep-2007 19:19:27
Numero di elementi: 3
Numero di nodi per elemento: 2
Numero di gradi di libertà per nodo: 2
Numero totale di nodi nel sistema: 4
Numero totale dei gradi di libertà del sistema: 8

Matrici caricate:

gcoord =

1.0e+003 *

0 0
1.1547 -2.0000
1.1547 0
4.6188 0

nodes =

1 2
2 3
2 4

elprop =

200000 2000
200000 2500
200000 3000

bcdof =

1
2
5
6
7
8

bcval =

0
0
0
0
0
0

ff =

0
0
0
-1000
0
0
0
0

39
2) Ciclo degli elementi:
Asta 1
- lunghezza: 2309.4008 mm
- inclinazione (deg): -60
cos(betax) e cos(betay): 0.5 -0.86603
betax e betay (deg): 60 150
- modulo elastico: 200000 N/mm^2
- area: 2000 mm^2
- sistema di gradi di libertà: 1 2 3 4
- matrice di rigidezza dell'elemento:

k =

1.0e+005 *

0.4330 -0.7500 -0.4330 0.7500


-0.7500 1.2990 0.7500 -1.2990
-0.4330 0.7500 0.4330 -0.7500
0.7500 -1.2990 -0.7500 1.2990

Asta 2
- lunghezza: 2000 mm
- inclinazione (deg): 90
cos(betax) e cos(betay): 0 1
betax e betay (deg): 90 0
- modulo elastico: 200000 N/mm^2
- area: 2500 mm^2
- sistema di gradi di libertà: 3 4 5 6
- matrice di rigidezza dell'elemento:

k =

1.0e+005 *

0.0000 0.0000 -0.0000 -0.0000


0.0000 2.5000 -0.0000 -2.5000
-0.0000 -0.0000 0.0000 0.0000
-0.0000 -2.5000 0.0000 2.5000

Asta 3
- lunghezza: 3999.9986 mm
- inclinazione (deg): 30
cos(betax) e cos(betay): 0.86603 0.5
betax e betay (deg): 30 60
- modulo elastico: 200000 N/mm^2
- area: 3000 mm^2
- sistema di gradi di libertà: 3 4 7 8
- matrice di rigidezza dell'elemento:

k =

1.0e+005 *

1.1250 0.6495 -1.1250 -0.6495


0.6495 0.3750 -0.6495 -0.3750
-1.1250 -0.6495 1.1250 0.6495
-0.6495 -0.3750 0.6495 0.3750

3) Assegnazione dei vincoli e soluzione della matrice


Matrice di rigidezza del sistema senza vincoli dei gdl:

kk =

1.0e+005 *

0.4330 -0.7500 -0.4330 0.7500 0 0 0 0


-0.7500 1.2990 0.7500 -1.2990 0 0 0 0
-0.4330 0.7500 1.5580 -0.1005 -0.0000 -0.0000 -1.1250 -0.6495
0.7500 -1.2990 -0.1005 4.1740 -0.0000 -2.5000 -0.6495 -0.3750
0 0 -0.0000 -0.0000 0.0000 0.0000 0 0
0 0 -0.0000 -2.5000 0.0000 2.5000 0 0
0 0 -1.1250 -0.6495 0 0 1.1250 0.6495
0 0 -0.6495 -0.3750 0 0 0.6495 0.3750

Matrice di rigidezza del sistema con i vincoli dei gdl:

40
kk =

1.0e+005 *

0.0000 0 0 0 0 0 0 0
0 0.0000 0 0 0 0 0 0
0 0 1.5580 -0.1005 0 0 0 0
0 0 -0.1005 4.1740 0 0 0 0
0 0 0 0 0.0000 0 0 0
0 0 0 0 0 0.0000 0 0
0 0 0 0 0 0 0.0000 0
0 0 0 0 0 0 0 0.0000

Matrice delle forze di sistema:

ff =

0
0
0
-1000
0
0
0
0

RIEPILOGO:
Asta 1
- Sforzo normale elemento: 346.5213 N
- Tensione elemento: 0.17326 N/mm^2
Asta 2
- Sforzo normale elemento: 599.8716 N
- Tensione elemento: 0.23995 N/mm^2
Asta 3
- Sforzo normale elemento: 200.0641 N
- Tensione elemento: 0.066688 N/mm^2

Spostamenti in mm: (n. gdl e spostamento)


1.000000000000000 0
2.000000000000000 0
3.000000000000000 -0.000154749416860
4.000000000000000 -0.002399486302799
5.000000000000000 0
6.000000000000000 0
7.000000000000000 0
8.000000000000000 0

CAMP2000 - POST PROCESSORE


- Spostamento massimo orizzontale: -0.00015475 mm
presente nel nodo 2
- Spostamento massimo verticale: -0.0023995 mm
presente nel nodo 2
- Sforzo normale maggiore di trazione: 599.87 N
presente nell'asta 2
Tutte le aste sono tese
- Tensione maggiore di trazione: 0.23995 N/mm^2
presente nell'asta 2

I gradi di libertà del nodo 2 sono il 3 e il 4 per i quali corrispondono i seguenti


spostamenti:

u2 = - 0,00015475 mm
v2 = - 0,00239949 mm

coincidenti con il risultato ottenuto con la soluzione manuale del problema.

41
L'output grafico è il seguente:

Fig. 30: 2 dei 3 grafici esportati dal postprocessore MATLAB

Calcolo in SAP2000
Il SAP2000 è un software di analisi strutturale di validità universalmente riconosciuta nel
settore dell'ingegneria civile.
Il problema è stato risolto anche con questo software per validare definitivamente il
programma:

Fig. 31: Esercizio risolto in SAP2000 – diagramma sforzi assiali

Come si nota il risultato è identico.

42
Applicazioni
Dopo aver validato il software con opportuni esempi verrà ora utilizzato per la soluzione di
alcune applicazioni pratiche. Si mostrerà quindi il vantaggio di avere a disposizione un
pacchetto software dal codice aperto che fornisce all'utente una maggiore trasparenza e
fiducia nei calcoli effettuati.

La prima è un confronto tra diverse tipologie di travature esistenti, soggette agli stessi
carichi, aventi la stessa luce e stesso numero di “moduli”. Le travature saranno anche
calcolate in SAP2000 per effettuare un ulteriore validazione. Infine verrà analizzato il caso
di una travatura reticolare esistente, ovvero un capannone industriale modellato in
SAP2000 e per il quale è stata effettuata una prova di carico.

Confronto tra diverse travature


Utilizzando il programma si procederà ad un'applicazione pratica effettuando il confronto
dei risultati dell'analisi di una trave di tipo “Howe”, una “Pratt” e due capriate di tipo
“Polonceau” .
Per poter effettuare un confronto efficace tutte le aste sono di area A = 2000 mm2 e in
acciaio (E = 200 GPa).

Howe

Fig. 32: Problema 1: travatura Howe

Calcolo in MATLAB

Dati di input esportati dal preprocessore e acquisiti dal kernel:


Numero di elementi: 25
Numero di nodi per elemento: 2
Numero di gradi di libertà per nodo: 2
Numero totale di nodi nel sistema: 14
Numero totale dei gradi di libertà del sistema: 28

43
Matrici caricate:

gcoord = nodes = elprop =

0 0 1 2 200000 2000
0 1000 1 3 200000 2000
1000 0 1 4 200000 2000
1000 1000 2 4 200000 2000
2000 0 3 4 200000 2000
2000 1000 3 5 200000 2000
3000 0 3 6 200000 2000
3000 1000 4 6 200000 2000
4000 0 5 6 200000 2000
4000 1000 5 7 200000 2000
5000 0 5 8 200000 2000
5000 1000 6 8 200000 2000
6000 0 7 8 200000 2000
6000 1000 7 9 200000 2000
8 9 200000 2000
8 10 200000 2000
9 10 200000 2000
9 11 200000 2000
10 11 200000 2000
10 12 200000 2000
11 12 200000 2000
11 13 200000 2000
12 13 200000 2000
12 14 200000 2000
13 14 200000 2000
bcdof = bcval = ff =

1 0 0
2 0 0
26 0 0
-5000
0
0
0
-10000
0
0
0
-10000
0
0
0
-10000
0
0
0
-10000
0
0
0
-10000
0
0
0
-5000

44
Risultati dello script:

Spostamenti in mm: (n. gdl e spostamento)

Nodo Gradi di libertà Spostamento (mm)


1 0
1
2 0
3 0.4375
2
4 -0.0125
5 0.0625
3
6 -0.65178
7 0.4375
4
8 -0.61428
9 0.1625
5
10 -1.0828
11 0.375
6
12 -1.0703
13 0.275
7
14 -1.2307
15 0.275
8
16 -1.2307
17 0.3875
9
18 -1.0828
19 0.175
10
20 -1.0703
21 0.4875
11
22 -0.65178
23 0.1125
12
24 -0.61428
25 0.55
13
26 0
27 0.1125
14
28 -0.0125

45
Tensioni e forze:

Asta Tensioni (MPa) Sollecitazioni (N)


1 -2.5 -5000
2 12.5 25000
3 -17.678 -35355
4 1.4552e-014* 2.9104e-011
5 7.5 15000
6 20 40000
7 -10.607 -21213
8 -12.5 -25000
9 2.5 5000
10 22.5 45000
11 -3.5355 -7071.1
12 -20 -40000
13 5.8208e-014 1.1642e-010
14 22.5 45000
15 -3.5355 -7071.1
16 -20 -40000
17 2.5 5000
18 20 40000
19 -10.607 -21213
20 -12.5 -25000
21 7.5 15000
22 12.5 25000
23 -17.678 -35355
24 -7.276e-015 -1.4552e-011
25 -2.5 -5000

* Il valore è assumibile a 0; la non corrispondenza è causata dal prodotto di valori non nulli (ma prossimi a
0) nella costruzione della matrice di rigidezza globale (iterazione di calcoli trigonometrici)

46
Pratt

Fig. 33: Problema 2: travatura Pratt

Calcolo in MATLAB

Dati di input esportati dal preprocessore e acquisiti dal kernel:

Numero di elementi: 25
Numero di nodi per elemento: 2
Numero di gradi di libertà per nodo: 2
Numero totale di nodi nel sistema: 14
Numero totale dei gradi di libertà del sistema: 28
Matrici caricate:

gcoord = nodes = elprop =

0 0 1 2 200000 2000
0 1000 1 3 200000 2000
1000 0 2 3 200000 2000
1000 1000 2 4 200000 2000
2000 0 3 4 200000 2000
2000 1000 3 5 200000 2000
3000 0 4 5 200000 2000
3000 1000 4 6 200000 2000
4000 0 5 6 200000 2000
4000 1000 5 7 200000 2000
5000 0 6 7 200000 2000
5000 1000 6 8 200000 2000
6000 0 7 8 200000 2000
6000 1000 7 9 200000 2000
7 10 200000 2000
8 10 200000 2000
9 10 200000 2000
9 11 200000 2000
9 12 200000 2000
10 12 200000 2000
11 12 200000 2000
11 13 200000 2000
11 14 200000 2000
12 14 200000 2000
13 14 200000 2000

47
bcdof = bcval = ff =

1 0 0
2 0 0
26 0 0
-5000
0
0
0
-10000
0
0
0
-10000
0
0
0
-10000
0
0
0
-10000
0
0
0
-10000
0
0
0
-5000

Risultati dello script:

Spostamenti in mm: (n. gdl e spostamento)

Nodo Gradi di libertà Spostamento (mm)


1 0
1
2 0
3 0.4375
2
4 -0.075
5 5.2935e-017
3
6 -0.68928
7 0.375
4
8 -0.75178
9 0.0625
5
10 -1.1703
11 0.275
6
12 -1.2078
13 0.1625
7
14 -1.3557
15 0.1625
8
16 -1.3807
17 0.2625
9
18 -1.1703
19 0.05
10
20 -1.2078

48
21 0.325
11
22 -0.68928
23 -0.05
12
24 -0.75178
25 0.325
13
26 0
27 -0.1125
14
28 -0.075

Tensioni e forze:

Asta Tensioni (MPa) Sollecitazioni (N)


1 -15 -30000
2 1.0587e-014 2.1174e-011
3 17.678 35355
4 -12.5 -25000
5 -12.5 -25000
6 12.5 25000
7 10.607 21213
8 -20 -40000
9 -7.5 -15000
10 20 40000
11 3.5355 7071.1
12 -22.5 -45000
13 -5 -10000
14 20 40000
15 3.5355 7071.1
16 -22.5 -45000
17 -7.5 -15000
18 12.5 25000
19 10.607 21213
20 -20 -40000
21 -12.5 -25000
22 0 0
23 17.678 35355
24 -12.5 -25000
25 -15 -30000

49
Polonceau [1]

Fig. 34: Problema 3: travatura Polonceau [1]

Calcolo in MATLAB

Dati di input esportati dal preprocessore e acquisiti dal kernel:

Numero di elementi: 21
Numero di nodi per elemento: 2
Numero di gradi di libertà per nodo: 2
Numero totale di nodi nel sistema: 12
Numero totale dei gradi di libertà del sistema: 24
Matrici caricate:

gcoord = nodes = elprop =

1.0e+003 * 1 2 200000 2000


1 3 200000 2000
0 0 2 3 200000 2000
1.0000 0 3 5 200000 2000
1.0000 0.3333 2 5 200000 2000
2.0000 0 2 4 200000 2000
2.0000 0.6667 4 5 200000 2000
3.0000 0 5 7 200000 2000
3.0000 1.0000 4 7 200000 2000
4.0000 0 4 6 200000 2000
4.0000 0.6667 6 7 200000 2000
5.0000 0 7 9 200000 2000
5.0000 0.3333 8 7 200000 2000
6.0000 0 6 8 200000 2000
8 9 200000 2000
11 9 200000 2000
10 9 200000 2000
8 10 200000 2000
10 11 200000 2000
12 11 200000 2000
10 12 200000 2000

50
bcdof = bcval = ff =

1 0 0
2 0 -5000*
24 0 0
0
0
-10000
0
0
0
-10000
0
0
0
-10000
0
0
0
-10000
0
0
0
-10000
0
-5000*

Risultati dello script:

Spostamenti in mm: (n. gdl e spostamento)

Nodo Gradi di libertà Spostamento (mm)


1 0
1
2 0
3 0.1875
2
4 -2.6443
5 0.66462
3
6 -2.6527
7 0.3375
4
8 -3.1882
9 0.63187
5
10 -3.2132
11 0.45
6
12 -3.1947
13 0.45
7
14 -3.1947
15 0.5625
8
16 -3.1882
17 0.26813
9
18 -3.2132
19 0.7125
10
20 -2.6443
21 0.23538
11
22 -2.6527
23 0.9
12
24 0

* Queste forze saranno assorbite direttamente dal vincolo e quindi eliminate dal vettore nel calcolo degli
spostamenti

51
Tensioni e forze:

Asta Tensioni (MPa) Sollecitazioni (N)


1 37.5 75000
2 -39.528 -79057
3 -5 -10000
4 -39.528 -79057
5 9.0139 18028
6 30 60000
7 -7.5 -15000
8 -31.623 -63246
9 10.607 21213
10 22.5 45000
11 -6.4623e-030 -1.2925e-026
12 -31.623 63246
13 10.607 21213
14 22.5 45000
15 -7.5 -15000
16 -39.528 -79057
17 9.0139 18028
18 30 60000
19 -5 -10000
20 -39.528 -79057
21 37.5 75000

52
Polonceau [2]

Fig. 35: Problema 4: travatura Polonceau [2]

Calcolo in MATLAB

Dati di input esportati dal preprocessore e acquisiti dal kernel:

Numero di elementi: 21
Numero di nodi per elemento: 2
Numero di gradi di libertà per nodo: 2
Numero totale di nodi nel sistema: 12
Numero totale dei gradi di libertà del sistema: 24
Matrici caricate:
gcoord = nodes = elprop =

1.0e+003 * 1 2 200000 2000


1 3 200000 2000
0 0 2 3 200000 2000
1.0000 0 3 5 200000 2000
1.0000 0.3333 4 3 200000 2000
2.0000 0 2 4 200000 2000
2.0000 0.6667 4 5 200000 2000
3.0000 0 5 7 200000 2000
3.0000 1.0000 6 5 200000 2000
4.0000 0 4 6 200000 2000
4.0000 0.6667 6 7 200000 2000
5.0000 0 9 7 200000 2000
5.0000 0.3333 6 9 200000 2000
6.0000 0 6 8 200000 2000
8 9 200000 2000
11 9 200000 2000
8 11 200000 2000
8 10 200000 2000
10 11 200000 2000
12 11 200000 2000
10 12 200000 2000

53
bcdof = bcval = ff =

1 0 0
2 0 -5000
24 0 0
0
0
-10000
0
0
0
-10000
0
0
0
-10000
0
0
0
-10000
0
0
0
-10000
0
-5000

Risultati dello script:

Spostamenti in mm: (n. gdl e spostamento)

Nodo Gradi di libertà Spostamento (mm)


1 0
1
2 0
3 0.1875
2
4 -2.5234
5 0.62152
3
6 -2.5234
7 0.375
4
8 -3.1311
9 0.64565
5
10 -3.1228
11 0.525
6
12 -3.2061
13 0.525
7
14 -3.1561
15 0.675
8
16 -3.1311
17 0.40435
9
18 -3.1228
19 0.8625
10
20 -2.5234
21 0.42848
11
22 -2.5234
23 1.05
12
24 0

54
Tensioni e forze:

Asta Tensioni (MPa) Sollecitazioni (N)


1 37.5 75000
2 -39.528 -79057
3 0 0
4 -31.623 -63246
5 -7.9057 -15811
6 37.5 75000
7 2.5 5000
8 -23.717 -47434
9 -9.0139 -18028
10 30 60000
11 10 20000
12 -23.717 -47434
13 -9.0139 -18028
14 30 60000
15 2.5 5000
16 -31.623 -63246
17 -7.9057 -15811
18 37.5 75000
19 0 0
20 -39.528 -79057
21 37.5 75000

55
Confronto tra la Howe e la Pratt
Sfruttando la rappresentazione grafica dei risultati del postprocessore è possibile avere una
visione di insieme delle sollecitazioni presenti nei diversi problemi analizzati (in blu le aste
compresse, in rosso quelle tese, in nero quelle scariche e in grassetto i valori massimi):

Fig. 36: Problema 1: sollecitazioni travatura Howe

Fig. 37: Problema 2: sollecitazioni travatura Pratt

I risultati ottenuti con il SAP2000 sono i seguenti:

Fig. 38: Problema 1: sollecitazioni travatura Howe calcolate in SAP2000

Fig. 39: Problema 2: sollecitazioni travatura Pratt calcolate in SAP2000

coincidenti perfettamente con i risultati ottenuti dal CAMP2000.

56
Confrontando le due travature, differenti esclusivamente per l'inclinazione delle diagonali,
si nota come:

● le sollecitazioni del corrente inferiore della Howe sono pari all'opposto di quelle del
corrente superiore della Pratt, idem per il corrente superiore rispetto all'altro
inferiore
● i montanti nella Howe – ad eccezione di quelli di estremità che scaricano le forze
sui due vincoli – sono tutti tesi (con quello centrale scarico) mentre nella Pratt sono
tutti compressi con sollecitazioni (in valore assoluto) maggiori
● le diagonali nella Howe hanno sollecitazioni uguali e opposte rispetto a quelle della
Pratt (compresse invece che tese nelle seconde)

Alla luce di queste annotazioni si possono fare le seguenti considerazioni progettuali: le


sollecitazioni di trazioni sono praticamente comparabili, con il valore maggiore nella
Howe. La Pratt ha più aste compresse (tutti i montanti più il corrente superiore) con la
sollecitazione maggiore (-45000 N) e quindi potrebbe presentare maggiori problemi di
instabilità rispetto alla Howe. Qui però sono i diagonali – elementi più lunghi e quindi con
maggiore lunghezza libera di inflessione – a soffrire di questo problema.

Per approfondire questo problema è necessario riprendere il modello di asta di Eulero nel
2 EI
quale si ha la relazione del carico critico che produce sbandamento: N cr = 2 .
L

Nei due problemi analizzati la lunghezza delle diagonali e quella dei montanti sono legate
dalla seguente relazione: L D =L M⋅ 2
Effettuando il rapporto dei carichi critici nelle due tipologie di aste si ottiene:

N CR , D EI 2 L2M 1
= ⋅ =
N CR ,M 2 L2M EI 2 2

ovvero che il carico critico delle diagonali è la metà di quello dei montanti.
Considerando che le aste dei correnti hanno la stessa lunghezza dei montanti, si prenda la
diagonale più caricata (N = -35355 N, Howe) e il montante/corrente più caricato (N =
-45000 N, Pratt).
Per stabilire la condizione più gravosa si prenda il maggiore tra i due rapporti:
ND NM
e
N CR , D N CR ,M
Essendo N CR , M =2⋅N CR , D
35355 45000 /2=22500
si ha 
N CR , D N CR , D
Si nota, alla luce di queste ultime considerazioni, come il fenomeno di instabilità sia più
pericoloso nella Howe rispetto alla Pratt (sempre a parità di rigidezza considerando le aste
tutte uguali e con le luci adottate).

57
Confronto tra le due Polonceau
Si effettua ora il confronto tra le due Polonceau, differenti anch'esse per l'inclinazione delle
diagonali, ottenute a partire dalla Howe e dalla Pratt:

Fig. 40: Problema 3: sollecitazioni travatura Polonceau [1]

Fig. 41: Problema 4: sollecitazioni travatura Polonceau [2]

I risultati ottenuti con il SAP2000 sono i seguenti:

Fig. 42: Problema 3: sollecitazioni travatura Polonceau [1] calcolate in SAP2000

Fig. 43: Problema 4: sollecitazioni travatura Polonceau [2] calcolate in SAP2000

coincidenti perfettamente con i risultati ottenuti dal CAMP2000.

58
Si può notare che:

● Entrambi i correnti inferiori sono tesi, ma nella [2] le sollecitazioni sono quasi
sempre maggiori
● Entrambi i correnti superiori sono compressi, ma nella [1] le sollecitazioni sono
quasi sempre maggiori
● I montanti nella [1], ad eccezione di quello centrale scarico, sono tutti compressi
mentre nella [2] sono tutti tesi ad eccezione dei due laterali scarichi
● Le diagonali nella [1] sono tese mentre nella [2] sono compresse
● Le sollecitazioni massime di trazione e compressione sono identiche

Ipotizzando di adottare lo stesso corrente superiore ed inferiore per entrambe (le


sollecitazioni massime sono identiche), anche qui si confronta il problema di instabilità dei
montanti e delle diagonali. Si nota come nella [2] siano presenti diagonali più lunghe e più
sollecitate dei montanti nella [1], quindi localmente saranno necessarie aste “rinforzate” (e
quindi più materiale) a fronte però di una minor lunghezza in genere delle diagonali della
[2] rispetto alla [1].

Confronto globale
Mettendo tutte e quattro le travature a confronto si può constatare che le Polonceau
necessiterebbero di minor materiale rispetto alla Howe e alla Pratt (minor numero di aste e
minor lunghezza); di contro presentano sollecitazioni maggiori sia di trazione che di
compressione quindi necessitano di sezioni maggiorate soprattutto nei correnti.

59
Capriata metallica per capannone industriale
Verrà ora analizzata una capriata metallica facente parte della struttura portante della
copertura di un capannone industriale di un impianto di acquacoltura. La struttura è stata
modellata in SAP2000 secondo tre schemi statici ed è stata sottoposta ad una prova
sperimentale di carico. Verrà modellata anche nel CAMP2000 confrontando i risultati del
software con gli spostamenti teorici del SAP2000 e con quelli sperimentali.
Poiché il capannone è in realtà una struttura tridimensionale, il carico applicato sarà
ripartito sulle capriate adiacenti; ci si aspetteranno quindi risultati diversi dalla
modellazione numerica. Utilizzando la modellazione in SAP2000 si modellerà il telaio in
CAMP2000 in modo da ottenere come risultato gli spostamenti reali misurati.

Fig. 44: Modellazione 3D in SAP2000 del capannone industriale

60
Proprietà della capriata
La capriata (la seconda a partire dalla vista frontale) è sorretta da due pilastri (profilati
HEA 200) collegati a dei pilastrini in calcestruzzo armato, ancorati a loro volta ad una
platea di calcestruzzo che costituisce il basamento del capannone. Il corrente superiore è un
profilato IPE220, quello inferiore e le aste sono composti da profilati a doppia L. La luce
netta della capriata è di 28 m. E' posta in parallelo ad altre capriate del tutto identiche,
collegate tra loro da arcarecci e da dei controventi.
I profilati sono tutti in acciaio (E = 210 GPa).
Il carico di progetto richiesto è di 5,9 KN/m; per poterlo simulare verranno applicate due
forze concentrate equivalenti in corrispondenza dei nodi posti a distanza 10,50 m dagli
appoggi (nodi 10 e 13 – si veda in seguito) e del valore di 48 KN.

Dati geometrici

La capriata, descritta in fig. 46, è dotata delle seguenti proprietà:

Fig. 45: Numerazione delle aste per la capriata modellata in CAMP2000

Numero aste Profilato Area (m2)


1, 39 HEA200 5.1e-03
2,6,10,14,18,24,28,32,36,5,
Due L 70*7 accoppiate 1.302e-03
7,9,35,33,31
4,8,12,16,20,21,26,30,34,38 IPE220 3.213e-03
3,37 Due L 80*8 accoppiate 1.712e-03
11,29 Due L 60*6 accoppiate 9.48e-04
13,15,17,19,22,23,25,27 Due L 50*5 accoppiate 6.5e-04

61
Fig. 46: Vista frontale capriata

62
Modellazione statica: scelta dei vincoli
La travatura può essere modellata in diversi modi variando la tipologia di vincoli. Sia in
SAP2000 che nel CAMP2000 sono stati adottati i seguenti 3 schemi (considerando per
entrambi come unità di misura i KN e i m):

1) Cerniera – carrello

La struttura reticolare è isostatica ed è libera di deformarsi orizzontalmente; si trascura


quindi l'effetto dei pilastri:

Fig. 47: Modellazione in SAP2000 e in CAMP2000 - cerniera e carrello

Dati di input esportati dal preprocessore e acquisiti dal kernel (attivata l'opzione format
long per visualizzare tutti i valori decimali per la matrice elprop):

Numero di elementi: 39
Numero di nodi per elemento: 2
Numero di gradi di libertà per nodo: 2
Numero totale di nodi nel sistema: 21
Numero totale dei gradi di libertà del sistema: 42
Matrici caricate:
gcoord = nodes = elprop =

0 0 1 2 1.0e+008 *
0 0.3000 1 3
1.7630 0 3 2 2.100000000000000 0.000000000051000
1.7630 0.5324 2 4 2.100000000000000 0.000000000013020
3.5250 0 3 4 2.100000000000000 0.000000000017120
3.5250 0.7648 3 5 2.100000000000000 0.000000000032130
7.0500 0 5 4 2.100000000000000 0.000000000013020
7.0500 1.2295 4 6 2.100000000000000 0.000000000013020
10.5750 0 5 6 2.100000000000000 0.000000000013020
10.5750 1.6943 5 7 2.100000000000000 0.000000000032130
14.1000 2.1943 7 6 2.100000000000000 0.000000000013020
17.6250 0 6 8 2.100000000000000 0.000000000013020
17.6250 1.6943 7 8 2.100000000000000 0.000000000009480
21.1500 0 7 9 2.100000000000000 0.000000000032130
21.1500 1.2295 7 10 2.100000000000000 0.000000000006500
24.6750 0 8 10 2.100000000000000 0.000000000013020
24.6750 0.7648 9 10 2.100000000000000 0.000000000006500
26.4370 0 9 12 2.100000000000000 0.000000000032130
26.4370 0.5324 9 11 2.100000000000000 0.000000000006500
28.2000 0 10 11 2.100000000000000 0.000000000013020
28.2000 0.3000 11 13 2.100000000000000 0.000000000006500
12 11 2.100000000000000 0.000000000032130
12 13 2.100000000000000 0.000000000032130
12 14 2.100000000000000 0.000000000006500
14 13 2.100000000000000 0.000000000006500
13 15 2.100000000000000 0.000000000013020
14 15 2.100000000000000 0.000000000006500

63
14 16 2.100000000000000 0.000000000032130
14 17 2.100000000000000 0.000000000006500
15 17 2.100000000000000 0.000000000013020
16 17 2.100000000000000 0.000000000009480
16 18 2.100000000000000 0.000000000032130
16 19 2.100000000000000 0.000000000013020
17 19 2.100000000000000 0.000000000013020
18 19 2.100000000000000 0.000000000013020
18 20 2.100000000000000 0.000000000032130
18 21 2.100000000000000 0.000000000013020
19 21 2.100000000000000 0.000000000013020
20 21 2.100000000000000 0.000000000017120
2.100000000000000 0.000000000032130
2.100000000000000 0.000000000051000
bcdof = bcval = ff =

1 0 0
2 0 0
40 0 0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
-48
0
0
0
0
0
-48
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

64
2) Cerniera – cerniera

Si considera ora il massimo effetto teorico dei pilastri, ovvero il totale impedimento delle
deformazioni orizzontali:

Fig. 48: Modellazione in SAP2000 e in CAMP2000 - cerniera e cerniera

I dati di input esportati dal preprocessore e acquisiti dal kernel sono identici al caso
precedente, a meno ovviamente delle matrici dei vincoli:

bcdof = bcval =

1 0
2 0
39 0
40 0

3) Presenza dei pilastri

Si considera ora il caso più prossimo a quello reale, ovvero si modellano anche i pilastri
considerati incastrati alla base. Si possono avere due situazioni:

- i pilastri non sono in grado di confinare la capriata in maniera adeguata che quindi è più
libera di deformarsi orizzontalmente; la modellazione in SAP2000 è la seguente:

Fig. 49: Modellazione SAP2000 della capriata - evidenziati i rilasci dei momenti

con i rilasci dei momenti in corrispondenza della connessione capriata – pilastro.

65
- i pilastri sono in grado di effettuare un'efficace confinamento:

Fig. 50: Modellazione SAP2000 della capriata - irrigidimento della connessione capriata - pilastro

Come si nota ora con il pilastro è stato introdotto un elemento di tipo “trave”, ovvero un
asta che può anche deformarsi per flessione, dotata di 3 gradi di libertà nel piano per nodo
(le due traslazioni e la rotazione). Per modellare la struttura in CAMP2000, dato che
vengono analizzati solo elementi “biella”, si introducono delle aste dotate di una rigidezza
equivalente al modello di trave disposte perpendicolarmente tra loro (in fig. 51 è indicato il
lato sinistro della capriata; le aste aggiunte sono la 40 e la 41):

Fig. 51: Modellazione CAMP2000 della capriata con pilastri – lato sinistro

Lo spostamento verticale in corrispondenza del pilastro è simulato da un'asta verticale di


EA
lunghezza e area unitaria dotata di rigidezza pari a K = ; essendo L = 3 m, A =
L
5.1e-03 m2, E = 210 GPa, la rigidezza equivalente sarà pari a 357000 KN/m2 (aste 40 e 42).

Nel primo caso, ovvero quello di pilastro non in grado di effettuare confinamento, il
modello statico equivalente da adottare per lo spostamento orizzontale è il seguente:

Fig. 52: Estratto delle soluzioni notevoli per travi isostatiche ad EJ costanti

66
La capriata infatti trasmette al pilastro una forza orizzontale P e la deformazione
3 EI
orizzontale di quest'ultimo dipenderà dalla sua rigidezza flessionale pari a K = 3 ;
L
dato E = 210 GPa, IHEA220=3.509e-05 m4 e L = 3,3 m, si ha K = 818.7667 KN/m2 .

Si aggiunge quindi un'asta orizzontale di area e lunghezza unitaria ed E = K (aste 41 e 43).

Nel secondo caso, ovvero con il pilastro in grado di effettuare il confinamento della
capriata, va modellato il collegamento rigido. Per fare ciò si deve simulare il
comportamento dell'elemento “trave” analizzando quindi lo schema statico di trave
doppiamente incastrata, dotata della seguente matrice di rigidezza:

[ ]
EA −EA
0 0 0 0
L L
EI EI EI EI
0 12 6 0 −12 6
L3 L2 L3 L2
EI EI EI EI
0 6 2 4 0 −6 2 2
L L L L
K L=
EA EA
− 0 0 0 0
L L
EI EI EI EI
0 −12 −6 0 12 −6
L3 L2 L3 L2
EI EI EI EI
0 6 2 2 0 −6 2 4
L L L L
Fig. 53: Schema elemento "beam"

T
con f l =[ N 1 T 1 M 1 N 2 T 2 M 2] e u l = [ u1 v 1  1 u 2 v 2  2 ]

Ricordando sempre che si è in regime elastico-lineare nel quale vale il principio di


sovrapposizione degli effetti, la rigidezza equivalente dell'asta orizzontale è data dalla
somma delle rigidezze della trave che si oppongono alle sollecitazioni M1, M2 e T2 rispetto
agli spostamenti v2, θ1*L e θ2*L; considerando i valori di E, I, L precedenti si ha:
EI EI EI EI KN
K =12 3 6 2 4 2 =22925 2 (nuova rigidezza delle aste 41 e 43).
L L L L m

Considerando le aste aggiunte, le modifiche delle matrici delle coordinate, d'incidenza e di


proprietà dell'asta sono le seguenti:

gcoord = nodes = elprop =

... ... ... ... ... ...


0 -1.0000 1 22 0.003570000000000 0.000000010000000
-1.0000 0 1 23 (1) 0.0000081876670 0.00000001
28.2000 -1.0000 20 24 (2) 0.00022925 0.00000001
29.2000 0 20 25 0.003570000000000 0.000000010000000
(1) 0.0000081876670 0.00000001
(2) 0.00022925 0.00000001

67
Spostamenti teorici
Lanciando l'analisi per ognuno degli schemi analizzati, si hanno i seguenti risultati:

1) Cerniera – carrello

Fig. 54: Spostamenti calcolati con modello in SAP2000 - cerniera e carrello

In corrispondenza dei due nodi di mezzeria si registra lo spostamento verticale massimo


pari a 9,517 cm . Le sollecitazioni sono pari a:

Fig. 55: Sollecitazioni assiali capriata in SAP2000 - cerniera e carrello

I valori massimi sono -302,6 KN di compressione nel corrente superiore e -299,62 KN di


trazione in quello inferiore.

In CAMP2000 i due nodi in mezzeria son quelli che collegano l'asta 18, ovvero il nodo 9 e
il nodo 12 per i quali si hanno i seguenti spostamenti:

Nodo Gradi di libertà Spostamento (m)


... ...
...
... ...
17 0.007738943930466
9
18 -0.095126342883828
... ...
...
... ...
23 0.013703586837787
12
24 -0.095126342883826

Coincidenti, a meno della 5° cifra decimale, con i risultati del SAP2000.

Le sollecitazioni infatti sono identiche (ps: i grafici in CAMP2000 mostrano i valori


arrotondati):

68
Fig. 56: Sollecitazioni assiali capriata in CAMP2000 - cerniera e carrello

2) Cerniera – cerniera

Fig. 57: Spostamenti calcolati con modello in SAP2000 - cerniera e cerniera

In corrispondenza dei due nodi di mezzeria si registra lo spostamento verticale massimo


pari a 4,468 cm . Le sollecitazioni sono pari a:

Fig. 58: Sollecitazioni assiali capriata in SAP2000 - cerniera e cerniera

In CAMP2000 si sono ottenuti i seguenti risultati:

Nodo Gradi di libertà Spostamento (m)


... ...
...
... ...
17 -0.000302005107629
9
18 -0.048689571008143
... ...
...
... ...
23 0.000302005107629
12
24 -0.048689571008142

Lo spostamento è pari a 4,869 cm .Questa volta abbastanza diversi dai risultati del
SAP2000 a partire già dalla 3° cifra decimale.

Le sollecitazioni infatti sono:

69
Fig. 59: Sollecitazioni assiali capriata in CAMP2000 - cerniera e cerniera

Con valori in generale maggiori rispetto al risultato in SAP2000.

3) Presenza dei pilastri

- caso di pilastri non efficenti:

Fig. 60: Spostamenti calcolati con modello in SAP2000 - presenza di pilastri cedevoli

In corrispondenza dei due nodi di mezzeria si registra lo spostamento verticale massimo


pari a 9,313 cm . Le sollecitazioni sono pari a:

Fig. 61: Sollecitazioni assiali capriata in SAP2000 – presenza di pilastri cedevoli

I valori massimi sono -302,04 KN di compressione nel corrente superiore e -290,13 KN di


trazione in quello inferiore.

Si nota come i risultati siano molto prossimi al modello di cerniera – carrello.


Ciò è dovuto alla presenza dei rilasci di momento nelle 3 aste che si collegano a ciascun
pilastro e che permettono la rotazione di queste ultime con conseguente deformazione
orizzontale.

70
In CAMP2000 si ha:
Nodo Gradi di libertà Spostamento (m)
... ...
...
... ...
17 -0.002873735309929
9
18 -0.093379529928720
... ...
...
... ...
23 0.002873735309926
12
24 -0.093379529928720
con spostamento verticale massimo pari a 9,338 cm simile a quello in SAP2000.
Le sollecitazioni sono pari a:

Fig. 62: Sollecitazioni assiali capriata in CAMP2000 – presenza di pilastri cedevoli

- caso di pilastri efficenti in grado di confinare la capriata:

Fig. 63: Spostamenti calcolati con modello in SAP2000 - presenza di pilastri efficenti

con spostamento verticale massimo di 7,051 cm . Le sollecitazioni sono pari a:

Fig. 64: Sollecitazioni assiali capriata in SAP2000 – presenza di pilastri efficenti

71
Data la complessità della modellazione dell'incastro capriata – pilastro (effettuata nella
realtà come nella modellazione SAP2000 e non con un'asta di rigidezza equivalente
applicata solo in quel nodo) si può effettuare solo il confronto degli spostamenti teorici
ottenuti.

In CAMP2000 pertanto si ha:

Nodo Gradi di libertà Spostamento (m)


... ...
...
... ...
17 -0.001530257420003
9
18 -0.070103629534791
... ...
...
... ...
23 0.001530257420003
12
24 -0.070103629534791

con spostamento verticale massimo pari a 7,01 cm simile a quello in SAP2000.

Il primo caso come si nota è simile a quello di cerniera – carrello, ma quello più prossimo
alla realtà è il secondo. I pilastri con collegamenti realizzati correttamente infatti sono in
grado di fornire un certo grado di vincolo allo spostamento orizzontale e infatti il valore
ottenuto è intermedio tra i 9,5 cm del cerniera – carrello e i 4,8 cm del caso di cerniera –
cerniera. Si considererà pertanto quest'ultimo come schema valido.

72
Spostamenti reali
Prova sperimentale

La capriata esistente è stata sottoposta ad una prova di carico tramite martinetti idraulici
posizionati inferiormente (e che quindi agiscono a tiro facendo abbassare la trave – si veda
la fig. 66).
Sono stati collegati tramite catene d'acciaio e ancorati con dei tasselli ad espansione nella
platea di calcestruzzo; la loro forza si può considerare con buona approssimazione come
concentrata.

Collegato al dispositivo del carico c'è il trasduttore di spostamento che lavora in continuo
misurando l'abbassamento e trascrivendolo automaticamente su un rotolo di carta tramite
un pennino scrivente (si veda il risultato in fig. 67).

Il carico è stato applicato gradualmente, crescendo a passi di 10 KN per volta e


mantenendolo per 5 minuti, fino ad arrivare al carico massimo di 48 KN, mantenuto per
circa 10 minuti. In seguito sono stati realizzati due cicli di carico e scarico con forze
massime applicate di 10 KN e 20 KN rispettivamente.

I punti di misura (indicati in fig. 65) sono i due nodi S1 e S3 più il punto di controllo S2.

Fig. 65: Schema della prova con posizione dei carichi e dei punti di misura

Fig. 66: Martinetti idraulici - foto e schema

73
Si sono ottenuti i seguenti risultati (estratti dal totale della registrazione):

Fig. 67: Risultati della prova di carico

Il valore massimo registrato per il caso di 48 KN è pari a 1,99 cm .


Questo valore è molto più piccolo di tutti quelli teorici calcolati, ma ciò è facilmente
giustificabile se si fa la seguente considerazione:

74
La prova è stata effettuata su una delle capriate centrali del capannone, che è collegata alle
due capriate adiacenti attraverso controventi, e quindi ha un comportamento spaziale e non
solo piano. Quando infatti la capriata centrale si abbassa per effetto delle due forze
concentrate applicate nei due punti, i controventi trasmettono la forza alle capriate
adiacenti, ripartendo il carico in modo che all'incirca il 50% gravi sulla capriata centrale,
mentre il restante 50% del carico si divide in 25% su ciascuna delle capriate adiacenti.

Modellazione SAP2000

Per verificare esattamente queste considerazioni è stata effettuata una modellazione della
capriata in SAP2000 aggiungendo le due immediatamente vicine e collegate con dei
controventi dimensionate come segue:

● Forza agente: 48 KN
● Acciaio: B450C (resistenza di progetto allo snervamento fyd = 39,1 KN/cm2)
2
F
● A min= =1,23 cm2=   =1,25 cm
f yd 4
● Sono stati scelti 4 controventi (2 per ogni capriata) con φ = 1,2 cm

E' stata effettuata la modellazione per i modelli statici di cerniera – carrello e cerniera –
cerniera (ovvero i casi estremi):

Fig. 68: Spostamenti capriata con controventi in SAP2000 - cerniera e carrello

Fig. 69: Spostamenti capriata con controventi in SAP2000 - cerniera e cerniera

75
Come si nota la presenza dei controventi fa diminuire di molto lo spostamento della trave
centrale. Nel primo schema, non essendo impedita la traslazione, lo spostamento è
maggiore.
Nella capriata nel piano con lo schema di doppia cerniera lo spostamento era di 4 cm
mentre con quello di trave appoggiata era di 9,5 cm e con quello dei pilastri era di 7 cm.
Ora si ha che con la doppia cerniera lo spostamento è di 2,2 cm mentre quello delle travi
appoggiate è di 4 cm; si può presumibilmente affermare che con un'eventuale
modellazione dei pilastri lo spostamento sarebbe stato intermedio. Comunque si nota come
anche il valore minimo calcolato in SAP2000 (appunto 2,2 cm) sia inferiore allo
spostamento reale registrato di 1,99 cm.

Modellazione CAMP2000

Riprendendo i risultati precedenti in SAP2000 si può ipotizzare che lo spostamento


ottenuto con la modellazione spaziale dei pilastri sarebbe il valore intermedio tra i due casi
estremi di cerniera – cerniera e cerniera – carrello, ovvero (4 + 2,2)/2 = 3,1 cm. E' possibile
calcolare ora la forza fittizia da applicare al telaio in CAMP2000 per considerare la
ripartizione dei carichi sulle altre capriate.
Essendo proporzionali spostamenti e forze, sarà sufficiente risolvere la proporzione:

abbassamento senza controventi : abbassamento con controventi = 48 KN : Ffitt

ovvero, Ffitt = 48 * (3,1 / 7,05) = 48 * 0,4397 = 21,1 KN .

Una volta ripartito il carico si verifica in CAMP2000 come applicando questa forza e
mantenendo la rigidezza della trave a doppio incastro (ovvero considerando
esclusivamente la presenza dei soli pilastri) si riottenga lo spostamento di 3,1 cm:

Nodo Gradi di libertà Spostamento (m)


... ...
...
... ...
17 -0.000672675657543
9
18 -0.030816387149668
... ...
...
... ...
23 0.000672675657543
12
24 -0.030816387149669

Per ottenere lo spostamento reale di 1,99 cm occorrerà aumentare la rigidezza delle due
aste che simulano i pilastri (la 41 e la 43), ma – effettuando tentativi con valori rigidezza
praticamente infiniti – si è riottenuto anche qui il caso di cerniera – cerniera calcolato in
SAP2000 con spostamento massimo di 2,15 cm (simile ai 2,2 precedenti).

Si è dimostrato con questo ultimo esempio come, con opportuni accorgimenti propri della
scienza delle costruzioni, sia possibile utilizzare un modello numerico di calcolo di
travature reticolari piane anche per casi più complessi con elementi strutturali di tipo trave
e ottenendo risultati praticamente identici ai software di calcolo più blasonati. Infine si è
mostrato come, confrontando risultati sperimentali e teorici, sia presente un certo grado di
incertezza tra i valori pur tentando di modellare la struttura fedelmente alla realtà.

76
Appendice
Contenuto del pacchetto software

Fig. 70: Cartella creata dopo l'installazione

● Cartella c2kmat: contiene gli script MATLAB del kernel e del postprocessore

● Cartella Demo: contiene i seguenti quattro esempi di travature:

Fig. 71: Travatura salvata in Demo1.c2k

77
Fig. 72: Travatura salvata in Demo2.c2k

Fig. 73: Travatura salvata in Howe.c2k

Fig. 74: Travatura salvata in Polonceau.c2k

● File camp2000.exe: applicazione principale (vedi paragrafo successivo)

78
● File Conf.ini: contiene le opzioni del programma:

(esempio file Conf.ini)

%FILE DI CONFIGURAZIONE CAMP2000 - NON MODIFICARE


[MATLAB]
Path=C:\Programmi\MATLAB71\bin\win32\MATLAB.exe
Work=C:\Programmi\MATLAB71\work
[SALVATAGGI]
CaricaSave=true
CaricaPath=F:\Università\Materiale\Tesi triennale\CAMP2000\Demo\
SalvaSave=true
SalvaPath=F:\Università\Materiale\Tesi
triennale\MATLAB\Esempi\HoweDemo

● File Guida.chm: guida all'uso del preprocessore:

Fig. 75: Schermata pagina iniziale guida

● File Leggimi.txt: contiene le indicazioni da leggere prima dell'installazione:

(file Leggimi.txt)

CAMP2000 v. 0.2 - by Mattia Campolese


-------------------------------------

LEGGI PRIMA DI INSTALLARE:

E' vietata la copia, modifica e redistribuzione del programma o


parti di esso, è tuttavia utilizzabile anche per scopi commerciali
o didattiche. Per qualsiasi informazione contattare l'autore
all'indirizzo email webmaster@matsoftware.it .

BUG NOTI:

-Esistono dei problemi nel caso la cartella ospitante il programma


contenga lettere non standard (come gli accenti), pertanto è
consigliabile utilizzare la cartella predefinita per
l'installazione del programma.

79
-Alcuni componenti visuali possono crashare

-------------------------------------
1 settembre 2007

● Files unins000.dat e unins000.exe: impostazioni e applicazione per la


disinistallazione del programma

Schermate preprocessore

Fig. 76: Icona


applicazione

Fig. 77: Finestra principale

80
Fig. 78: Finestra coordinate geometriche e dei nodi

Fig. 79: Finestra proprietà geometriche e dei materiali

Fig. 80: Finestra delle opzioni

Fig. 81: Finestra delle informazioni sul programma

81
Codice sorgente script MATLAB
(file camp2000kernel.m)

%CAMP2000 - kernel
%----------------------------------------------------------------------
%by Mattia Campolese - v. 0.2 - 20 agosto 2007 - 13 settembre 2007
%webmaster@matsoftware.it - www.matsoftware.it
%References: "The finite element method using MATLAB" - Young W. Kwon &
%Hyochoong Bang - CRC Press, 2000
%----------------------------------------------------------------------
function[]=camp2000kernel(path,verbose)
%1) CARICAMENTO DATI DI INPUT DA FILE ESTERNI GENERATI DAL PREPROCESSORE
clear functions %elimina le funzioni compilate in memoria
clc; %pulisce la finestra dei comandi
in=0;
%1.1) Dati di input
fid=fopen([path '\1input.txt'],'r');
while feof(fid) == 0
in=in+1;
str = native2unicode(fgetl(fid));
switch in
case 2
name=str; %nome della travatura
case 3
nel=str2num(str); %numero di elementi
case 4
nnel=str2num(str); %numero di nodi per elemento
case 5
ndof=str2num(str); %numero di gradi di libertà per nodo
case 6
nnode=str2num(str); %numero totale di nodi nel sistema
case 8
uforza=str; %unità di misura per la forza
case 9
ulungh=str; %unità di misura per lunghezze
case 10
uarea=str; %unità di misura per le aree
case 11
utens=str; %unità di misura per le tensioni
end
end
fclose(fid);
sdof=nnode*ndof; %gradi di libertà totali
%1.2) Inizializzazione variabili di sistema
ff=zeros(sdof,1); %vettore di forze del sistema
kk=zeros(sdof,sdof); %matrice di rigidezza del sistema
displ=zeros(sdof,sdof); %matrice degli spostamenti di sistema
index=zeros(nnel*ndof,1); %vettore degli indici
elforce=zeros(nnel*ndof,1); %vettore di forza dell'elemento
eldisp=zeros(nnel*ndof,1); %vettore della disposizione dei nodi
dell'elemento
k=zeros(nnel*ndof,nnel*ndof); %matrice di rigidezza dell'elemento
stress=zeros(nel,1); %vettore delle tensioni per ogni elemento
%1.3) Coordinate geometriche dei nodi
gcoord=csvread([path '\2gcoord.txt']);
%1.4) Proprietà geometriche e dei materiali
elprop=csvread([path '\3elprop.txt']);
%1.5) Connettività dei nodi

82
nodes=csvread([path '\4nodes.txt']);
%1.6) Vincoli applicati
constraints=csvread([path '\5constraints.txt']);
bcdof=constraints(:,1);
bcval=constraints(:,2);
%1.7) Forze applicate ai nodi
fid=fopen([path '\6forces.txt'],'r');
in=0;
while feof(fid) == 0
in=in+1;
str = native2unicode(fgets(fid));
ff(in)=str2num(str);
end
fclose(fid);
if (verbose == 'si')
diary Output.txt
disp('CAMP2000 - Kernel');
disp('-----------------');
disp('1) Dati di input: ');
disp(['Travatura "' name '" calcolata in data: ' datestr(now)]);
disp(['Numero di elementi: ' int2str(nel)]);
disp(['Numero di nodi per elemento: ' int2str(nnel)]);
disp(['Numero di gradi di libertà per nodo: ' int2str(ndof)]);
disp(['Numero totale di nodi nel sistema: ' int2str(nnode)]);
disp(['Numero totale dei gradi di libertà del sistema: '
int2str(sdof)]);
disp(' ');
disp('Matrici caricate: ');
[gcoord]
[nodes]
[elprop]
[bcdof]
[bcval]
[ff]
disp(' ');
disp('2) Ciclo degli elementi: ');
end
%2) CICLO DEGLI ELEMENTI
for iel=1:nel %cicla per il numero totale di elementi
nd(1)=nodes(iel,1); %primo nodo connesso con l'elemento iesimo
nd(2)=nodes(iel,2); %secondo nodo connesso con l'elemento iesimo
x1=gcoord(nd(1),1); y1=gcoord(nd(1),2); %coordinate per il primo nodo
x2=gcoord(nd(2),1); y2=gcoord(nd(2),2); %coordinate per il secondo
nodo
lung=sqrt((x2-x1)^2+(y2-y1)^2); %lunghezza dell'elemento
%controllo sull'inclinazione dell'asta rispetto al sistema di
riferimento globale:
if (x2-x1)==0;
if y2>y1;
beta=2*atan(1);
else
beta=-2*atan(1);
end
else
beta=atan((y2-y1)/(x2-x1));
end
el=elprop(iel,1); %estrae il modulo elastico
area=elprop(iel,2); %estrae l'area della sezione
index=feeldof(nd,nnel,ndof); %estrae il sistema dei gradi di libertà
dell'elemento
k=fetruss(el,lung,area,beta); %computa la matrice degli elementi

83
kk=feasmbl(kk,k,index); %assembla la matrice di sistema inserendo
quella di elemento
if (verbose == 'si')
disp(['Asta ' int2str(iel)]);
disp([' - lunghezza: ' num2str(lung) ' ' ulungh]);
disp([' - inclinazione (deg): ' num2str(rad2deg(beta))]);
disp([' cos(betax) e cos(betay): ' num2str((x2-x1)/lung) ' '
num2str((y2-y1)/lung)]);
disp([' betax e betay (deg): ' num2str(acosd((x2-x1)/lung)) ' '
num2str(acosd((y2-y1)/lung))]);
disp([' - modulo elastico: ' num2str(el) ' ' utens]);
disp([' - area: ' num2str(area) ' ' uarea]);
disp([' - sistema di gradi di libertà: ' int2str(index)]);
disp(' - matrice di rigidezza dell''elemento: ');
[k]
end
end
%3) ASSEGNAZIONE DEI VINCOLI E SOLUZIONE DELLA MATRICE
if (verbose == 'si')
disp('3) Assegnazione dei vincoli e soluzione della matrice');
disp('Matrice di rigidezza del sistema senza vincoli dei gdl: ');
[kk]
end
[kk,ff]=feaplyc(kk,ff,bcdof,bcval); %applicazione delle condizioni al
contorno
displ=kk\ff; %risoluzione della matrice per gli spostamenti dei nodi
if (verbose == 'si')
disp('Matrice di rigidezza del sistema con i vincoli dei gdl:');
[kk]
disp('Matrice delle forze di sistema:');
[ff]
disp('RIEPILOGO: ');
end
%4) CALCOLO DELLE FORZE E DELLE TENSIONI
for iel=1:nel %cicla per il numero totale di elementi
nd(1)=nodes(iel,1); %primo nodo connesso per l'elemento iesimo
nd(2)=nodes(iel,2); %secondo nodo connesso per l'elemento iesimo
x1=gcoord(nd(1),1); y1=gcoord(nd(1),2); %coordinate del primo nodo
x2=gcoord(nd(2),1); y2=gcoord(nd(2),2); %coordinate del secondo nodo
lung=sqrt((x2-x1)^2+(y2-y1)^2); %lunghezza dell'elemento
%controllo
if (x2-x1)==0;
if y2>y1;
beta=2*atan(1);
else
beta=-2*atan(1);
end
else
beta=atan((y2-y1)/(x2-x1));
end
el=elprop(iel,1); %estrai il modulo elastico
area=elprop(iel,2); %estrai l'area della sezione
index=feeldof(nd,nnel,ndof); %estrae il sistema dei gradi di libertà
per l'elemento
k=fetruss(el,lung,area,beta); %computa la matrice di elemento
for i=1:(nnel*ndof) %estrae gli spostamenti associati con l'elemento
iesimo
eldisp(i)=displ(index(i));
end
elforce=k*eldisp; %vettore forza elemento
N(iel)=sqrt(elforce(1)^2+elforce(2)^2); %sforzi normali

84
stress(iel)=N(iel)/area; %tensioni
if (elforce(3))<0; %controllo se sono o no di compressione
stress(iel)=-stress(iel);
N(iel)=-N(iel);
end
if (verbose == 'si')
disp(['Asta ' int2str(iel)]);
disp([' - Sforzo normale elemento: ' num2str(N(iel)) ' '
uforza]);
disp([' - Tensione elemento: ' num2str(stress(iel)) ' ' utens]);
end
end
%5) STAMPA DEI RISULTATI (se disabilitata opzione verbosa)
num=1:1:sdof;
format long
disp([' ']);
disp(['Spostamenti in ' ulungh ': (n. gdl e spostamento)']);
disp([num' displ]);
format short
% salva i risultati nella cartella dei dati di input
csvwrite([path '\Spostamenti.txt'],displ); %spostamenti
csvwrite([path '\N.txt'],N'); %sollecitazioni assiali
csvwrite([path '\Tensioni.txt'],stress); %tensioni
if (verbose == 'si')
%6) LANCIA IL POST PROCESSORE
camp2000pp(path);
diary off;
else
numm=1:1:nel;
tensioni=[numm' stress]
forze=[numm' N']
end

85
(file camp2000pp.m)

%CAMP2000 - Post Processore


%----------------------------------------------------------------------
%by Mattia Campolese - v. 0.2 - 13 settembre 2007
%webmaster@matsoftware.it - www.matsoftware.it
%----------------------------------------------------------------------
function[]=camp2000pp(path)
%1) CARICAMENTO DATI DI INPUT DA FILE ESTERNI GENERATI DAL PREPROCESSORE
in=0;
disp('CAMP2000 - POST PROCESSORE');
%1.1) Dati di input
fid=fopen([path '\1input.txt'],'r');
while feof(fid) == 0
in=in+1;
str = native2unicode(fgetl(fid));
switch in
case 2
name=str; %nome della travatura
case 3
nel=str2num(str); %numero di elementi
case 4
nnel=str2num(str); %numero di nodi per elemento
case 5
ndof=str2num(str); %numero di gradi di libertà per nodo
case 6
nnode=str2num(str); %numero totale di nodi nel sistema
case 8
uforza=str; %unità di misura per la forza
case 9
ulungh=str; %unità di misura per lunghezze
case 10
uarea=str; %unità di misura per le aree
case 11
utens=str; %unità di misura per le tensioni
end
end
fclose(fid);
sdof=nnode*ndof; %gradi di libertà totali
%1.2) Coordinate geometriche dei nodi
gcoord=csvread([path '\2gcoord.txt']);
%1.3) Proprietà geometriche e dei materiali
elprop=csvread([path '\3elprop.txt']);
%1.4) Connettività dei nodi
nodes=csvread([path '\4nodes.txt']);
%1.5) Vincoli applicati
constraints=csvread([path '\5constraints.txt']);
bcdof=constraints(:,1);
bcval=constraints(:,2);
%1.6) Forze applicate ai nodi
fid=fopen([path '\6forces.txt'],'r');
in=0;
while feof(fid) == 0
in=in+1;
str = native2unicode(fgets(fid));
ff(in)=str2num(str);
end
fclose(fid);
%1.7) Spostamenti
displ=csvread([path '\Spostamenti.txt']);
%1.8) Forze

86
N=csvread([path '\N.txt']);
%1.9) Tensioni
stress=csvread([path '\Tensioni.txt']);
%2) GRAFICA DELLA TRAVATURA
h1 = figure;
hold on;
%grid on;
%set(gca,'Xcolor',[0.9020 0.9020 0.9020]);
%set(gca,'Ycolor',[0.9020 0.9020 0.9020]);
axis equal;
for iel=1:nel %cicla per il numero totale di elementi
nd(1)=nodes(iel,1); %primo nodo connesso con l'elemento iesimo
nd(2)=nodes(iel,2); %secondo nodo connesso con l'elemento iesimo
x1=gcoord(nd(1),1); y1=gcoord(nd(1),2); %coordinate per il primo nodo
x2=gcoord(nd(2),1); y2=gcoord(nd(2),2); %coordinate per il secondo
nodo
x = [x1,x2];
y = [y1,y2];
plot(x,y,'r');
averagex = (x1 + x2)/2;
averagey = (y1 + y2)/2;
% scegliere cosa visualizzare
text(averagex,averagey,num2str(iel),'BackgroundColor','y'); %asta
% text(averagex,averagey,[num2str(iel) ') ' num2str(elprop(iel,2)) ' '
uarea],'BackgroundColor','y'); %asta e area
% text(averagex,averagey,[num2str(iel) ') ' num2str(elprop(iel,1)) ' '
utens],'BackgroundColor','y'); %asta e modulo elastico

end
%disegna il vincolo del nodo
for j=1:nnode %ciclo per il numero totale dei nodi
kind = 0; %variabile per definire la tipologia di nodo
gdl1 = (j*ndof)-1;
gdl2 = (j*ndof);
x=gcoord(j,1); y=gcoord(j,2); %coordinate del nodo
%controlla se il gdl del nodo j è vincolato
for g=1:length(bcdof)
if ((bcdof(g)==gdl1) | (bcdof(g)==gdl2))
kind = kind + 1;
end
end
%stabilisce il tipo di vincolo
switch kind
case 1
%carrello
plot(x,y,'og');
case 2
%cerniera
plot(x,y,'^g');
end
end
%disegna la forza applicata al nodo
for j=1:nnode %ciclo per il numero totale dei nodi
f1 = (j*ndof)-1;
f2 = (j*ndof);
x=gcoord(j,1); y=gcoord(j,2); %coordinate del nodo
%controlla se la forza è applicata al nodo
%f. orizzontale
if (ff(f1) ~= 0)
if (ff(f1) >= 0)
text(x,y,[num2str(ff(f1)) ' ' uforza]);

87
plot(x,y,'>b')
else
text(x,y,[num2str(ff(f1)) ' ' uforza]);
plot(x,y,'<b')
end
end
%f verticale
if (ff(f2) ~= 0)
if (ff(f2) >= 0)
text(x,y,[num2str(ff(f2)) ' ' uforza]);
plot(x,y,'^b')
else
text(x,y,[num2str(ff(f2)) ' ' uforza]);
plot(x,y,'vb')
end
end
end
title(['Travatura ' name]); %titolo grafico
xlabel(ulungh);
ylabel(ulungh);
%3) CALCOLA I VALORI MASSIMI
% Distingue gli spostamenti orizzontali e verticali
for j=1:nnode %cicla per il numero di nodi
doriz(j) = displ((j*ndof)-1);
dvert(j) = displ((j*ndof));
end
% Ricerca i valori minimi e massimi di spostamenti, N e sigma e indica
% l'asta corrispondente
[DHmax,NDHmax]=max(abs(doriz)); %orizzontale
[DVmax,NDVmax]=max(abs(dvert)); %verticale
[Nmax,ANmax]=max(N); %trazione
[Nmin,ANmin]=min(N); %compressione
[Smax,ASmax]=max(stress); %trazione
[Smin,ASmin]=min(stress); %compressione
disp(['- Spostamento massimo orizzontale: ' num2str(doriz(NDHmax)) ' '
ulungh]);
disp([' presente nel nodo ' num2str(NDHmax)]);
disp(['- Spostamento massimo verticale: ' num2str(dvert(NDVmax)) ' '
ulungh]);
disp([' presente nel nodo ' num2str(NDVmax)]);
if (Nmax > 0)
disp(['- Sforzo normale maggiore di trazione: ' num2str(Nmax) ' '
uforza]);
disp([' presente nell''asta ' num2str(ANmax)]);
else
disp('Tutte le aste sono compresse');
end
if (Nmin < 0)
disp(['- Sforzo normale maggiore di compressione: ' num2str(Nmin) ' '
uforza]);
disp([' presente nell''asta ' num2str(ANmin)]);
else
disp('Tutte le aste sono tese');
end
if (Smax > 0)
disp(['- Tensione maggiore di trazione: ' num2str(Smax) ' ' utens]);
disp([' presente nell''asta ' num2str(ASmax)]);
end
if (Smin < 0)
disp(['- Tensione maggiore di compressione: ' num2str(Smin) ' '
utens]);

88
disp([' presente nell''asta ' num2str(ASmin)]);
end
%3) GRAFICA LE SOLLECITAZIONI
h2 = figure;
hold on;
%grid on;
axis equal;
for iel=1:nel %cicla per il numero totale di elementi
nd(1)=nodes(iel,1); %primo nodo connesso per l'elemento iesimo
nd(2)=nodes(iel,2); %secondo nodo connesso per l'elemento iesimo
x1=gcoord(nd(1),1); y1=gcoord(nd(1),2); %coordinate del primo nodo
x2=gcoord(nd(2),1); y2=gcoord(nd(2),2); %coordinate del secondo nodo
x = [x1,x2];
y = [y1,y2];
%distingue se di tensione o compressione
if (round(N(iel)) > 0)
plot(x,y,'r');
end
if (round(N(iel)) == 0)
plot(x,y,'black');
end
if (round(N(iel)) < 0)
plot(x,y,'b');
end
%disegna il vincolo del nodo
for j=1:nnode %ciclo per il numero totale dei nodi
kind = 0; %variabile per definire la tipologia di nodo
gdl1 = (j*ndof)-1;
gdl2 = (j*ndof);
x=gcoord(j,1); y=gcoord(j,2); %coordinate del nodo
%controlla se il gdl del nodo j è vincolato
for g=1:length(bcdof)
if ((bcdof(g)==gdl1) | (bcdof(g)==gdl2))
kind = kind + 1;
end
end
%stabilisce il tipo di vincolo
switch kind
case 1
%carrello
plot(x,y,'og');
case 2
%cerniera
plot(x,y,'^g');
end
end
%applica la sollecitazione sull'asta
averagex = (x1 + x2)/2;
averagey = (y1 + y2)/2;
%controlla se è il valore massimo di trazione
if ((round(N(iel)) == round(Nmax)) | (round(N(iel)) == round(Nmin)))
text(averagex,averagey,[num2str(round(N(iel))) ' '
uforza],'FontSize',14);
else
text(averagex,averagey,[num2str(round(N(iel))) ' ' uforza]);
end
end
title(['Sollecitazioni travatura ' name]); %titolo grafico
xlabel(ulungh);
ylabel(ulungh);
%4) GRAFICA LE TENSIONI

89
h3 = figure;
hold on;
%grid on;
axis equal;
for iel=1:nel %cicla per il numero totale di elementi
nd(1)=nodes(iel,1); %primo nodo connesso per l'elemento iesimo
nd(2)=nodes(iel,2); %secondo nodo connesso per l'elemento iesimo
x1=gcoord(nd(1),1); y1=gcoord(nd(1),2); %coordinate del primo nodo
x2=gcoord(nd(2),1); y2=gcoord(nd(2),2); %coordinate del secondo nodo
x = [x1,x2];
y = [y1,y2];
%distingue se di tensione o compressione
if (round(stress(iel)) > 0)
plot(x,y,'r');
end
if (round(stress(iel)) == 0)
plot(x,y,'black');
end
if (round(stress(iel)) < 0)
plot(x,y,'b');
end
%disegna il vincolo del nodo
for j=1:nnode %ciclo per il numero totale dei nodi
kind = 0; %variabile per definire la tipologia di nodo
gdl1 = (j*ndof)-1;
gdl2 = (j*ndof);
x=gcoord(j,1); y=gcoord(j,2); %coordinate del nodo
%controlla se il gdl del nodo j è vincolato
for g=1:length(bcdof)
if ((bcdof(g)==gdl1) | (bcdof(g)==gdl2))
kind = kind + 1;
end
end
%stabilisce il tipo di vincolo
switch kind
case 1
%carrello
plot(x,y,'og');
case 2
%cerniera
plot(x,y,'^g');
end
end
%applica la sollecitazione sull'asta
averagex = (x1 + x2)/2;
averagey = (y1 + y2)/2;
%controlla se è il valore massimo di trazione
if ((round(stress(iel)) == round(Smax)) | (round(stress(iel)) ==
round(Smin)))
text(averagex,averagey,[num2str(round(stress(iel))) ' '
utens],'FontSize',14);
else
text(averagex,averagey,[num2str(round(stress(iel))) ' ' utens]);
end
end
title(['Tensioni travatura ' name]); %titolo grafico
xlabel(ulungh);
ylabel(ulungh);

90
(file feaplyc.m)

%References: "The finite element method using MATLAB" - Young W. Kwon &
%Hyochoong Bang - CRC Press, 2000
function[kk,ff]=feaplyc(kk,ff,bcdof,bcval)
n=length(bcdof); %numero dei gradi di libertà vincolati
sdof=size(kk); %gradi di libertà del sistema
for i=1:n
c=bcdof(i); %grado di libertà vincolato
for j=1:sdof
kk(c,j)=bcval(i);
kk(j,c)=bcval(i);
end
kk(c,c)=1; %per non annullare il determinante
ff(c)=bcval(i); %la forza sul vincolo è assorbita tutta da esso
end

(file feasmbl.m)

%References: "The finite element method using MATLAB" - Young W. Kwon &
%Hyochoong Bang - CRC Press, 2000
function[kk]=feasmbl(kk,k,index)
edof=length(index);
for i=1:edof
ii=index(i);
for j=1:edof
jj=index(j);
kk(ii,jj)=kk(ii,jj)+k(i,j);
end
end

(file feeldof.m)

%References: "The finite element method using MATLAB" - Young W. Kwon &
%Hyochoong Bang - CRC Press, 2000
function[index]=feeldof(nd,nnel,ndof)
edof=nnel*ndof;
k=0;
for i=1:nnel
start=(nd(i)-1)*ndof;
for j=1:ndof
k=k+1;
index(k)=start+j;
end
end

(file fetruss.m)

%References: "The finite element method using MATLAB" - Young W. Kwon &
%Hyochoong Bang - CRC Press, 2000
function[k]=fetruss(el,leng,area,beta)
c=cos(beta); s=sin(beta);
k=(area*el/leng)*[c*c c*s -c*c -c*s;...
c*s s*s -c*s -s*s;...
-c*c -c*s c*c c*s;...
-c*s -s*s c*s s*s];
end

91
Riferimenti bibliografici
“The finite element method using MATLAB” - Young W. Kwon & Hyochoong Bang -
CRC Press, 2000.

“Lezioni complementi ed esercizi di scienza delle costruzioni – vol 2” - A. Samuelli


Ferretti, Edizioni Ingegneria 2000.

Dispense e appunti del corso di “Meccanica della trave” del Prof. Claudio Valente presso
la facoltà di Ingegneria Civile – Università RomaTre.

Dispense del corso di “Statica” del Prof. Francesco Romeo presso la Prima facoltà di
Architettura – La Sapienza.

MATLAB. (4 settembre 2007). “Wikipedia, L'enciclopedia libera”. Tratto il 7 settembre


2007, 14:42 da http://it.wikipedia.org/w/index.php?title=MATLAB&oldid=10757257.

“Prove di carico sulle costruzioni” - tesi triennale Ingegneria Civile – Università Roma3 –
di Gabriele Fiorentino, Anno 2005/2006

92
Ringraziamenti
Ringrazio il professore Claudio Valente e l' Ing. Stefano Gabriele per la pazienza
dedicatami nell'assistenza a questo lavoro, nonché l' Ing. Jr Fiorentino Gabriele per
l'assitenza con il lavoro da lui svolto con la sua tesi.

Ringrazio tutte le persone che mi son state vicine in questi tre anni universitari e in
particolare:

● la mia famiglia (Nicola Campolese, Antonella Vastano e Cinzia Campolese) e in


particolare i genitori che mi hanno permesso di sostenere gli studi fuori sede qui a
Roma
● i coinquilini che mi hanno sopportato in tre anni di pazzie mentali (in particolare
Iura Luca, l'ing. jr informatico che mi ha dato qualche suggerimento per il
programma)
● tutti gli amici/colleghi universitari (che hanno suggerito anche l'idea del nome del
software nata come scherzo dopo le prime lezioni di meccanica dei materiali e delle
strutture)
● tutti gli amici/amiche/qualcosadipiùcheamiche che mi hanno sempre apprezzato e
sostenuto e quelli che mi hanno rimproverato quando necessario

93