Lorenzo Rotondi LM-PRN - Collegio Didattico di Ingegneria Civile

UNIVERSITÁ DEGLI STUDI ROMA TRE
Dipartimento di Ingegneria
Corso di Laurea in
Ingegneria Civile per la Protezione dai Rischi Naturali
Relazione di fine tirocinio
Studente:
Lorenzo Rotondi
Tutor:
Ing. Stefano Gabriele
Anno Accademico 2014/2015
Indice
1 Introduzione
1
2 Matlab
2
3 SAP2000-matlab
5
4 Implementazione analisi
4.1 Gap . . . . . . . . . . . . . . . . . . . . . . . .
4.1.1 Definizione modello per mezzo di codice
4.1.2 Risultati analisi . . . . . . . . . . . . . .
4.2 Modello mensola . . . . . . . . . . . . . . . . .
4.2.1 Definizione modello per mezzo di codice
4.2.2 Risultati analisi . . . . . . . . . . . . . .
4.3 Conclusioni . . . . . . . . . . . . . . . . . . . .
i
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8
8
8
14
15
15
23
25
Capitolo 1
Introduzione
Il tesista Lorenzo Rotondi ha svolto l’attività di tirocinio presso il laboratorio di modellazione e simulazione (LaMS) internamente all’Università degli studi di Roma Tre.
L’attività svolta è stata la base per poter affrontare il successivo lavoro di tesi.
Il tirocinio ha visto il tesista alle prese con l’apprendimento del software matlab
e l’acquisizione dei principi di programmazione nel linguaggio matlab con il fine di
riuscire ad interfacciare quest’ultimo con il software di analisi agli elementi finiti SAP2000.
Questa possibilità è permessa attraverso l’utilizzo delle Application Programming Interface
(API)che permettono lo sviluppo di applicazioni esterne al software SAP2000. Il seguente
lavoro è stato necessario per affrontare le problematiche e la metodologia di lavoro adottata
per lo sviluppo dell’argomento di tesi. Inizialmente ci si è interessati allo studio e alla
comprensione del software matlab e del suo linguaggio di programmazione.
Nel capitolo 1 si introdurrà il software matlab e si spiegheranno brevemente le sue
capacità. Nel capitolo 2 è fornita un introduzione alle API di SAP2000 e alla metodologia
di accesso alla struttura interna del software tramite applicazioni esterne. Nell’ultimo
capitolo sono stati sviluppati dei codici in linguaggio matlab costituenti un’applicazione
capace di interagire con il software di analisi agli elementi finiti, vengono inoltre mostrate
le capacità di gestione dei dati di input e di elaborazione dei dati di output.
L’uso di applicazioni esterne di interfaccia con SAP2000 hanno messo in evidenza
la riduzione dei tempi di studio di un problema, specialmente se sono necessarie un
numero elevato analisi, a patto che sia redatto un corretto codice in grado di eseguire tale
procedure.
1
Capitolo 2
Matlab
Matlab è un linguaggio per la computazione tecnica. In un ambiente interattivo
esso, tramite notazione matematica, integra il calcolo numerico, la visualizzazione e la
programmazione.
Figura 2.1: Programma matlab
É pensato per le seguenti utilità:
• Matematica e calcolo;
• Sviluppo di procedura, modellistica, simulazione e prototyping;
• Disegno industriale e scientifico;
• Sviluppo di applicazione, compreso la costruzione grafica dell’interfaccia di utente.
2
Matlab si basa sul calcolo matriciale, l’elemento di base è un array che non richiede
di essere dimensionato. Ciò permette la risoluzione di molti problemi di calcolo tecnici, in
particolare quelli con formulazioni vettoriali e matriciali, attraverso algoritmi molto più
semplici e snelli rispetto a quelli che sarebbero necessari in un programma di linguaggio
scalare non interattivo. Non a caso il nome del programma matlab è un abbreviazione
per matrix laboratory. Questo tipo di dati sono, in generale, vettori bidimensionali con m
righe e n colonne i cui singoli elementi sono variabili reali oppure complesse. Una matrice
può essere creata introducendo esplicitamente i suoi valori mediante un comando di
assegnazione, oppure come risultato di comandi o funzioni predefiniti. Ad esempio il
comando:
A= [1 2 3; 4 5 6]
crea la matrice A inoltre il ; fa si che il valore della variabile non sia visualizzato a
seguito della definizione. Ovviamente matlab ha anche altri modi di immagazzinare dati
numerici e dati non numerici. L’ambiente matlab è composto da cinque parti:
• Ambiente di sviluppo.
• Un insieme di tool che facilitano l’uso di matlab. Questo include il desktop
matlab, la command window, la command history , il workspace, oltre alla sezione
help che mostra l’elenco delle procedure per le quali è disponibile una descrizione
per avere informazioni specifiche su un comando.
• La libreria di funzioni matematiche. Una vasta collezione di algoritmi che spaziano
dalle funzioni matematiche elementari fino a quelle più complesse(calcolo degli
autovalori, Fast Fourier Transform).
• Il linguaggio di programmazione. Un linguaggio di alto livello con controllo di flusso,
funzioni, strutture, input, output.
• Permette di programmare e realizzare programmi complessi.
• Supporto per i grafici. Un numero consistente di facilities per realizzare grafici a
due o tre dimensioni ma anche processing, animazioni e presentazioni.
• Matlab API. Una libreria che permette di integrare funzioni matlab con altri
linguaggi.
Molto utili per gli utenti solo le cosiddette toolboxes, queste sono delle collezioni
complete di funzioni matlab che estendono l’ambiente di matlab per risolvere particolari
categorie di problemi. Tra le varie sono disponibili negli ambiti: elaborazione dei segnali,
sistemi di controllo, simulazione e molti altri.
Matlab è un linguaggio di programmazione potente, i file che contengono codice
matlab sono chiamati M-files. Dopo aver creato un M-file usando un qualsiasi editor di
testo, tale file può essere usato come un comando od una funzione matlab. Esistono due
generi di M-file. Gli script non accettano argomenti d’entrata o di uscita, operano su dati
3
nel workspace. Quando si richiama uno script matlab esegue i comandi presenti nel file.
Gli script possono loro operare su dati esistenti nel workspace o possono creare dei nuovi
dati su cui operare. Sebbene gli script non forniscano dati di output, qualsiasi variabile
che loro creano rimane nel workspace, per essere usata in calcoli successivi. Inoltre gli
script possono produrre dei grafici usando funzioni come plot. Functions che possono
accettare argomenti d’entrata e argomenti di uscita. Il nome dell’M-file e della funzione
devono essere identici. Le funzioni operano su variabili definite nel proprio workspace,
diverso da quello a cui si accede all’ingresso di matlab.
Questa prima fase è stata incentrata sul conoscere il software e il suo linguaggio di
programmazione. Ciò ha comportato la necessità di acquisire familiarità con i vari tipi di
variabili del linguaggio, le varie funzioni predefinite nel software, le capacità grafiche e le
capacità di automatizzazione e di controllo da remoto.
4
Capitolo 3
SAP2000-matlab
Questa parte è dedicata a mostrare come usare le Open Application Programming Interface
di SAP2000 o OAPI per far partire SAP2000, costruire un modello, e lanciare l’analisi da
un applicazione esterna. In questo caso è stato utilizzato il linguaggio di programmazione
matlab sebbene anche altri linguaggi possano essere utilizzati come ad esempio Visual
Basic per accedere alle funzioni OAPI di SAP2000. Incluso con il software si trova la
documentazione OAPI che descrive ogni funzione OAPI nel dettaglio i capitoli includono:
• Introduction;
• Release Notes;
• Getting Started;
• CSi OAPI Functions;
• Exaples Codes;
• Una lista in ordine alfabetico delle funzioni;
• Funzioni Obsolete.
Per ogni funzione è specificata la sintassi, la procedura in un linguaggio Visual Basic,
i parametri necessari, la descrizione della funzione e un semplice esempio di codice
riguardante la funzione interessata. Possiamo controllare SAP2000 da un file matlab
definendo anche la geometria del modello utilizzando questo linguaggio di programmazione.
Per creare un modello bisogna eseguire tutti gli step che si eseguirebbero se si operasse
direttamente con SAP2000 solo che queste operazioni vengono condotte da dietro le
quinte attraverso un codice in linguaggio matlab. Ovviamente una buona conoscenza
del software SAP2000 è una condizione necessaria per controllare un modello attraverso
le sue OAPI.
Le Application Programming Interface (API) permettono di creare spreadsheet, plugin
e applicazioni che possono interfacciarsi con i software CSI. Le API sono compatibili
con la maggior parte dei linguaggi di programmazione inclusi Visual Basic, C++, Visual
Fortan, Python e matlab.
5
Le Application Programming Interface (API) di SAP2000 sono uno strumento di programmazione finalizzato ad offrire una possibilità di accesso all’analisi e alla progettazione
del software SAP2000, permettendo di stabilire un legame diretto, durante la run-time,
tra l’applicazione esterna e il software di analisi. In aggiunta, attraverso l’uso delle API, si
ha la possibilità di sviluppare dei plug-in che estendono il campo di utilizzo del software.
In termini di programmazione le API consistono in una libreria che offre accesso ad una
serie di oggetti e funzioni capaci di controllare in remoto il comportamento di SAP2000,
superando la procedura standard di utilizzo del software stesso. Le principali funzioni che
le API permettono sono riassunte di seguito:
• Interazione diretta ed efficace con i metodi di analisi e progettazione di SAP2000;
• Possibilità di gestire i dati sia in entrata che in uscita, two-way data flow, per
facilitare le procedure di pre e post-elaborazione;
• Compatibilità con la maggior parte dei linguaggi di programmazione;
• Sviluppo di applicazioni che restano compatibili anche con le future versioni di
SAP2000;
• Possibilità di sviluppo di una interfaccia di SAP2000 calibrata secondo le necessità
dell’utente.
Per accedere alle API è richiesta la classica istallazione di SAP2000 niente di più.
Tutte le componenti sono istallate durante il normale setup del programma. L’utilizzo
dipende in maggior parte dalla scelta del linguaggio di programmazione e dall’ambiente
di programmazione con cui ci si deve interfacciare, con questa frrase si vuole indicare che
la sintassi da utilizzare e le potenzialità di organizzazione dell’applicazione che si intende
sviluppare differiscono a seconda dei vari linguaggi. Come assistenza nell’utilizzo delle
API di SAP2000, una dettagliata documentazione è fornita attraverso l’istallazione. La
guida contiene una lista di ogni funzione a disposizione, con la rispettiva esatta sintassi,
una dettagliata descrizione degli argomenti che contiene la funzione e un esempio semplice
di applicazione. (inserire diagramma di flusso)
Matlab è in grado di leggere tutto quello che c’è sul modello. Da un punto di vista
informatico questa cosa è possibile perché esiste ed è prevista in SAP2000 un linguaggio di
scambio tra SAP2000 e altri linguaggi esterni, normalmente linguaggi di programmazione
esterna (visual basic,C++, etc. . . ) per cui si può gestire un modello in forma nascosta
non agendo direttamente sull’interfaccia di SAP2000. Ovviamente come tutti i linguaggi
di programmazione per poterlo utilizzare bisogna conoscere la sintassi per poter impostare
certe funzioni ed organizzare una procedura ma anche per ricavare e trattare i dati. In
generale, tutto ciò che si può fare normalmente tramite l’interfaccia di SAP2000 si può
fare anche da codice, persino i risultati di un analisi si possono riprendere ed elaborare
da un file già aperto. Inoltre è un ottimo mezzo nel caso in cui si debbano ripetere le
stesse analisi per un numero elevato di volte o per lavorare in maniera iterativa. Perciò
è comodo far lavorare matlab in automatico secondo un criterio prestabilito invece di
eseguire tutto manualmente, ovviamente i tempi sarebbero completamente diversi. Il
6
caso di processi iterativi è solo un semplice esempio dell’importanza di poter controllare
SAP2000 in maniera automatica dalle retrovie.
Il primo step che permette di utilizzare le CSi API da un applicazione esterna è di
collegare SAP2000 alla stessa applicazione. Per poter effettuare uno scambio di dati tra
le applicazioni esterne e SAP2000 questi bisogna che siano organizzati secondo un array
in 1 dimensione. Per far questo si introducono due linee di codice che restano immutate
per tutte le applicazioni.
Codice 3.1: Scambio dati array 1 dimensione
% pass data to Sap2000 as one - dimensional arrays
feature ( ’ COM_SafeArraySingleDim ’ , 1);
% pass non - scalar arrays to Sap2000 API by reference
feature ( ’ COM_PassSafeArrayByRef ’ , 1);
Successivamente bisogna creare un oggetto SAP2000 nell’applicazione, una volta creato
il collegamento si può aprire il software. A questo punto si può aprire un nuovo file o uno
già esistente, in generale tutti i comandi sono preceduti dalla dicitura SapObject.SapModel
per cercare di abbreviare questa scrittura tal volta conviene definire un SapModel object.
I seguenti codici eseguono quanto appena detto.
Codice 3.2: Creazione SapObject
% create Sap2000 object
SapObject = actxserver ( ’ Sap2000v16 . SapObject ’);
% create SapModel object
SapModel = SapObject . SapModel ;
% start Sap2000 application
SapObject . ApplicationStart ;
Impostare questi comandi permette di accedere alla struttura interna del software
effettuando tutte le operazioni dall’esterno. In questo caso sono state evidenziate solo le
funzioni che permettono l’interazione con applicazioni esterne e sono una serie di azioni
comuni a tutti i codici. La parte successiva dell’applicazione sarà relativa allo scopo che si
vuole e quindi cambierà da caso a caso. In questo senso lo sviluppo di un codice completo
sarà trattato nel prossimo capitolo.
7
Capitolo 4
Implementazione analisi
Scopo della seguente sezione è quella di mostrare l’interazione tra SAP2000 e matlab
attraverso dei semplici esempi. Per fare ciò sono stati realizzati degli script ad hoc che
saranno introdotti e descritti man mano. Nei paragrafi seguenti si analizzerà prima il
comportamento di un elemento non lineare della libreria di SAP2000 successivamente si
eseguirà un’analisi su delle strutture semplici schematizzate come sistemi ad 1 gdl il tutto
sfruttando le OAPI di SAP2000 e implementando un codice matlab capace di eseguire
queste operazioni.
4.1
4.1.1
Gap
Definizione modello per mezzo di codice
Il primo esempio di interazione matlab-SAP2000 è presentato di seguito e consiste nella
definizione e analisi di un elemento non linear link: il gap. Lo script realizzato è un
semplice esempio delle potenzialità delle OAPI di SAP2000 e delle capacità del software
di interagire con linguaggi di programmazione esterni.
Il link gap è un elemento che connette due nodi adiacenti e permette, per esempio,
di modellarne il contatto tra due strutture adiacenti. Si tratta di un elemento elastico
non lineare caratterizzato da una apertura in compressione e da una rigidezza elastica.
L’elemento si attiva quando i nodi alle sue estremità si avvicinano chiudendo l’apertura e
si disattiva quando si allontanano si tratta perciò di un elemento che per definizione è
funzionante solamente in compressione. Una forza di collisione si genera quando l’apertura
del gap è uguale a zero. In SAP2000 questo elemento è dotato di 6 gradi di libertà,
ogni gdl può essere attivato o meno ed avere delle determinate proprietà di rigidezza e
proprietà dissipative.
Mentre la massa del link è imputata in parti uguali ai due nodi estremi del link.
Generalmente i valori di rigidezza sono 102 − 104 volte la rigidezza degli elementi cui è
collegato. Durante un analisi non lineare una relazione forza-spostamento non lineare
viene utilizzata per i gdl cui sono state specificate proprietà non lineari. Per tutti gli
altri gdl, che al contrario non hanno specificate proprietà non lineari, sono utilizzate le
8
Figura 4.1: Schema nlink gap
caratteristiche elastiche in caso si effettui un analisi non lineare. Solo i risultati di analisi
non lineari prevedono il comportamento non lineare dell’elemento.
La relazione non lineare forza-spostamento che caratterizza l’elemento è data dalla
seguente relazione:
(
k(d + open), se d+open<0
f=
0,
altrimenti
Dove k è la rigidezza della molla , e open è l’apertura iniziale del gap che può essere
positiva o nulla.
Il codice scritto tramite linguaggio matlab permette di interagire con SAP2000
aprire l’applicazione e definire l’elemento link con successiva analisi ed estrapolazione
dei dati. Per ogni operazione che si vuole eseguire su SAP2000 bisogna scrivere la
corrispondente funzione nel codice rispettando la classe dei parametri definiti all’interno
di una funzione OAPI. La funzione che permette di definire un elemento gap e le sue
proprietà è SetGap. Aprendo la documentazione si comprende quale siano i parametri da
definire nella funzione affinché un elemento gap sia correttamente creato in SAP2000.
La sintassi della funzione è spiegata anch’essa e prevede che sia definito:
• Il nome da assegnare al link come stringa;
• I gdl attivi o no attraverso valori boolean True, False;
• I gdl fissi attraverso valori boolean True, False;
• I gdl con proprietà non lineari attraverso valori boolean True, False;
• I valori della rigidezza effettiva per ogni gdl, tramite un array di double;
9
• I valori dello smorzamento effettivo per ogni gdl, tramite un array di double;
• I valori della rigidezza non lineare per ogni gdl con proprietà non lineari, tramite
array di double;
• I valori di apertura iniziali per ogni gdl con proprietà non lineari, tramite un array
di double;
Per evitare problemi numerici è stato assegnato anche un valore minimo di massa al link,
attraverso la funzione SetWeightAndMass nella quale vanno inseriti il nome del link cui si
vuole modificare il parametro e il valore del nuovo parametro da immettere.
Definite le proprietà che deve possedere il link si procede con la sua assegnazione tra
due punti nel modello. Questa parte è possibile grazie alla funzione AddByCoord che
permette di definire, tramite coordinate da specificare nella funzione, i nodi estremi tra
cui andrà inserito il link. Infine come ultimo passo per la costruzione del modello sono
stati assegnati i vincoli ai nodi grazie alla funzione SetRestraints. Ogni vincolo, carrello,
cerniera, incastro è definito attraverso una variabile indipendente rappresentata da un
array di valori boolean True e False ad indicare se un determinato gdl è vincolato o meno.
Nel linguaggio matlab per passare da valori double a valori boolean si utilizza il comando
di matlab logical. Perciò ogni vincolo è stato definito con un array di 6 valori double
contenenti 0 o 1 e poi trasformati in valori boolean così che rispettassero la sintassi di
input della funzione SetRestraint.Nel modello un nodo è stato vincolato applicandogli un
incastro e il nodo esterno è stato lasciato libero.
La parte di codice relativa alle operazioni fino a qui descritte è riportata di seguito.
Codice 4.1: Definizione nlink gap
% GAP
% 1 DOF da assegnare al Link
DOF = logical ([1;0;0;0;0;0]);
% 2 DOF fissi
Fixed = logical ([0;0;0;0;0;0]);
% 3 NON LINEAR PROPERTIES da assegnare al Link
NLPROP = logical ([1;0;0;0;0;0]);
% 4 effective stiffness
Ke = [100000;0;0;0;0;0];
% 5 effective damping
Ce = [0;0;0;0;0;0];
% 6 initial stiffness applies for nonlinear analyses
KGAP = input ( ’ inserire K Gap [ Default : 100000]: ’);
if isempty ( KGAP )
KGAP = 100000;
end
k = [ KGAP ;0;0;0;0;0];
10
% 7 initial open GAP
op = [0.02;0;0;0;0;0];
ret = SapModel . PropLink . SetGap ( ’ GAP ’ , DOF , Fixed , NLPROP , Ke , Ce ,k , op ,0 ,0);
% set link property weight and mass
ret = SapModel . PropLink . SetWeightAndMass ( ’ GAP ’ ,0 ,0.001 ,0 ,0 ,0);
% aggiunge link tra 2 nodi
ret = SapModel . LinkObj . AddByPoint ( ’3 ’ , ’4 ’ , ’ GAP ’ ,0 , ’ ’ , ’ GAP ’);
Una volta realizzato l’elemento si passa alla definizione ed analisi dello stesso. Queste
fasi sono state fatte anch’esse sotto forma di codice. La sequenza di azioni per definire
un analisi prevede dapprima la definizione di un load pattern, l’applicazione del load
pattern al modello e infine la creazione di un load case che definisce il tipo di analisi che
si vuole effettuare. Per questa applicazione si è deciso di effettuare un analisi statica
non lineare in controllo di spostamento. In genere un’analisi in spostamento risulta più
efficace anche perché quasi sempre si conosce il range di spostamento da indagare ma non
si conoscono le entità delle forze cui sarà soggetta la struttura. Per effettuare l’analisi in
controllo di spostamento bisogna specificare un elemento da monitorare, generalmente un
nodo, e specificare lo spostamento obiettivo dell’analisi. La scelta di salvare i risultati
intermedi permette di vedere come l’elemento, più in generale la struttura, reagisce
durante l’avanzare dell’analisi. La specificata combinazione di carichi è applicata in modo
incrementale, usando gli step necessari a soddisfare l’equilibrio ed a produrre il numero
richiesto di output da salvare. Le equazioni non lineari sono risolte iterativamente ad
ogni step. Questo richiede ogni volta la risoluzione della matrice di rigidezza, le iterazioni
terminano quando la la soluzione converge.
Si definisce il load denominato forza da assegnare al nodo libero dell’elemento gap,
questo è stato fatto tramite la funzione LoadPatterns.Add che permette di definire un
nuovo load pattern assegnandogli un nome e specificando anche il tipo di load ( dead, live,
quake etc. . . ) . Mentre per assegnare il load case ad un nodo ci si è serviti della funzione
PointObj.SetLoadForce in cui va specificato il nome del nodo cui si vuole assegnare il
load pattern, il nome del load pattern stesso e il valore che deve avere tramite un array di
double in cui ogni elemento rappresenta una componente della sollecitazione.
F1 F2 F3 M1 M2 M3
Infine si è potuto definire l’analisi statica non lineare. La funzione StaticNonLinear con
le varie estensioni .SetCase, .SetLoadApplication, .SetLoads, .SetResultsSaved permettono
di definire tutti i parametri del load case. L’analisi è in controllo di spostamento e
termina quando il nodo controllato raggiunge i valori di spostamento prefissati. L’analisi
è composta da una serie di step consecutivi di cui si conservano i dati e che verranno
utilizzati nel seguito.
La parte di codice relativa alle operazioni fino a qui descritte è riportata di seguito.
Codice 4.2: Definizione analisi statica non lineare
11
% Analisi statica non lineare
% add new load pattern
ret = SapModel . LoadPatterns . Add ( ’ Forza ’ ,1);
% Assegna load to point
Value = [1;0;0;0;0;0];
ret = SapModel . PointObj . SetLoadForce ( ’4 ’ , ’ Forza ’ , Value );
% add static nonlinear load case
ret = SapModel . LoadCases . StaticNonlinear . SetCase ( ’ NLST ’);
% Definisce i parametri di applicazione del carico
LoadControl = 2;
DispType = 2;
Displ = 0.04;
Monitor =1;
DOF =1;
ret = SapModel . LoadCases . StaticNonlinear ...
... SetLoadApplication ( ’ NLST ’ ,2 ,2 , Displ ,1 , DOF , ’4 ’ , ’ ’);
% set load date
LoadT ={ ’ Load ’; ’ Load ’};
LoadN ={ ’ DEAD ’; ’ Forza ’};
SF ={ -1; -1};
ret = SapModel . LoadCases . StaticNonlinear ...
... SetLoads ( ’ NLST ’ ,2 , LoadT , LoadN , SF );
% set results saved parameters
Savestep = logical (1);
MinStep =40;
MaxStep =40;
OnlyPos = logical (0);
ret = SapModel . LoadCases . StaticNonlinear ...
... SetResultsSaved ( ’ NLST ’ , Savestep , MinStep , MaxStep , OnlyPos );
L’ultima parte del codice è relativa al lancio dell’analisi e all’estrapolazione dei dati e
alla loro elaborazione in forma grafica.
Codice 4.3: Run analysis
% Run model ( this will create the analysis model )
ret = SapModel . Analyze . RunAnalysis ;
% Seleziona il solo load case che interessa
ret = SapModel . Results . Setup . D e s e l e c t A l l C a s e s A n d C o m b o s F o r O u t p u t ;
ret = SapModel . Results . Setup . S e t Ca s e Se l e ct e d Fo r O u tp u t ( ’ NLST ’);
12
Per l’estrapolazione dei dati sono state create delle variabili nulle che successivamente
conterranno i dati di output del modello questa operazione preliminare è necessaria per
estrarre i dati altrimenti non si potrebbero leggere in alcun modo se non accedendo
direttamente al programma SAP2000. Si dice che le variabili vengono inizializzate.
Codice 4.4: Estrapolazione dati di output
% Deformazione
% Inizializza le variabili
GA PNumeroRisultati = 0;
GAPObj = cellstr ( ’ ’);
GAPElm = cellstr ( ’ ’);
GAPLoadCase = cellstr ( ’ ’);
GAPStepType = cellstr ( ’ ’);
GAPStepNum = 0;
GAPU1 = 0;
GAPU2 = 0;
GAPU3 = 0;
GAPR1 = 0;
GAPR2 = 0;
GAPR3 = 0;
% get link deformations for link object
[ ret , GAPNumeroRisultati , GAPObj , GAPElm , GAPLoadCase , GAPStepType ,...
... GAP0StepNum , GAPU1 , GAPU2 , GAPU3 , GAPR1 , GAPR2 , GAPR3 ]=...
... SapModel . Results . LinkDeformation ( ’ GAP ’ ,1 , GAPNumeroRisultati ,...
... GAPObj , GAPElm , GAPLoadCase , GAPStepType , GAPStepNum ,...
... GAPU1 , GAPU2 , GAPU3 , GAPR1 , GAPR2 , GAPR3 );
% Sollecitazioni
% Inizializza le variabili
G APNumeroRisultatiS = 0;
GAPObjS = cellstr ( ’ ’);
GAPElmS = cellstr ( ’ ’);
GAPPointElmS = cellstr ( ’ ’);
GAPLoadCaseS = cellstr ( ’ ’);
GAPStepTypeS = cellstr ( ’ ’);
GAPStepNumS = 0;
GAPPoutp = 0;
GAPV2 = 0;
GAPV3 = 0;
GAPT = 0;
GAPM2L = 0;
GAPM3L = 0;
% get link forces for link object
[ ret , GAPNumeroRisultatiS , GAPObjS , GAPElmS , GAPPointElmS ,...
... GAPLoadCaseS , GAPStepTypeS , GAPStepNumS , GAPPoutp ,...
... GAPV2 , GAPV3 , GAPT , GAPM2L , GAPM3L ] =...
... SapModel . Results . LinkForce ( ’ GAP ’ ,1 , GAPNumeroRisultatiS , GAPObjS ,...
13
... GAPElmS , GAPPointElmS , GAPLoadCaseS , GAPStepTypeS , GAPStepNumS ,...
... GAPPoutp , GAPV2 , GAPV3 , GAPT , GAPM2L , GAPM3L );
Matlab raccoglie i dati dell’analisi nelle variabili che sono state inizializzate. A questo
punto è in grado di gestirli ed elaborarli. Per esempio i dati di output dell’analisi possono
essere utilizzati dal codice per disegnare la curva forza spostamento che caratterizza il
link. L’utilizzo del codice permette anche di inserire rapidamente nel grafico i nomi degli
assi di riferimento, la leggenda e il titolo del grafico.
Codice 4.5: Elaborazione dati di output
% PLOT GRAFICO FORZA - DEFORMAZIONE
% DATI
% FORZA
N = GAPN ;
% DEFORMAZIONE
d = GAPU1
% PLOT
plot (d , N );
hold all
title ( ’ Modello giunto ’);
xlabel ( ’ Deformazione [ m ] ’);
ylabel ( ’ Forza [ kN ] ’);
Il codice introdotto in precedenza rappresenta una successione di operazioni che permette di eseguire un analisi su l’elemento gap operando solamente nell’ambiente matlab.
Una volta realizzato si possono eseguire un gran numero di analisi automatizzando l’intero
procedimento e con notevole risparmio di tempo. Per una completa trattazione del
problema i risultati dell’analisi saranno presentati nel paragrafo successivo.
4.1.2
Risultati analisi
Completato il codice lo si può far girare semplicemente lanciandolo dalla command window
di matlab. A questo punto verranno eseguite tutta la serie di operazioni specificate nel
codice e si potranno ottenere direttamente i risultati dell’analisi.
La finalità ultima dello script realizzato è quella di analizzare il comportamento del
non linear link gap. Per capire ciò si analizza la relazione forza-spostamento che lo
definisce. Questa relazione è stata rappresentata sotto forma di un diagramma che viene
riportato qui di seguito. Come si può vedere questa è caratterizzata da un primo tratto a
rigidezza nulla che coincide con la fase in cui il gap si trova ancora in una configurazione
aperta. Poi una volta che l’apertura si è chiusa il link inizia a reagire seguendo un ramo
di curva stabilito dalla rigidezza predefinita in fase di input.
Questa semplice analisi ha permesso di mostrare le potenzialità di SAP2000 di riuscire
ad interagire con applicazioni esterne al programma tramite i più diffusi linguaggi di
programmazione in uso. La creazione di un codice in linguaggio matlab ha permesso di
14
0
−20
Punto chiusura
Forza [kN]
−40
Tratto gap reagente
−60
−80
−100
−120
−0.045
−0.04
−0.035
−0.03
−0.025
−0.02
Deformazione [m]
−0.015
−0.01
−0.005
0
Figura 4.2: Relazione forza-spostamento gap
analizzare il comportamento dell’elemento gap senza operare direttamente nell’interfaccia
di SAP2000. É stato, quindi, evidenziato il comportamento non lineare del non linear
link, tracciando il legame forza-spostamento che lo caratterizza. Dato che l’elemento gap
ben si presta alla modellazione del contatto tra strutture, nel prossimo paragrafo si vedrà
un applicazione in tal senso.
4.2
4.2.1
Modello mensola
Definizione modello per mezzo di codice
Le capacità delle OAPI non si limitano alla possibilità di indagare elementi singoli ma
permettono di affrontare tutti i problemi che si affronterebbero direttamente su SAP2000.
In questo capitolo si mostrerà un’applicazione dell’elemento gap studiato precedentemente.
Il non linear link verrà inserito tra strutture adiacenti, modellate semplicemente e se ne
indagherà il comportamento sotto l’azione di una storia accelerometrica. Le strutture
avranno la stessa altezza e saranno collegate in testa tramite un elemento gap, sebbene
siano caratterizzate da una stessa altezza le strutture hanno proprietà dinamiche differenti,
ciò è stato possibile intervenendo sui modificatori di proprietà. L’analisi e l’estrapolazione
dei dati verrà interamente gestita da codice. Il semplice modello è costituito da due
sistemi a un gdl. Volendo operare in remoto vanno quindi effettuate tutte le fasi previste,
sotto forma di codice, dalla definizione del materiale alla definizione dell’analisi.
Per prima cosa si definisce un materiale. Questa funzione aggiunge un nuovo materiale
al modello basata su normative o codici e altre proprietà definite nel file ’CSiMaterialLibrary*.xml’ che si trova nella cartella di installazione. É possibile specificare il nome che
il programma dovrà assegnare alle proprietà del materiale, il tipo di materiale (acciaio,
cemento armato, alluminio, etc.), la regione (intesa come nazione) delle proprietà del
15
materiale predefinita nel file ’CSiMaterialLibrary*.xml , in questo caso Italia, la normativa
o linea guida di quella regione da seguire per la definizione del materiale in questo caso le
UNI EN 206-1:2006 e UNI 11104:2004. Il calcestruzzo utilizzato è un C32/40.
Si definisce quindi una sezione, che verrà successivamente assegnata all’elemento
creato, specificando il nome della sezione, il materiale da cui è composta tra quelli definiti
e le dimensioni. In questo caso si è utilizzata la funzione SetRectangle che prevede la
definizione di sole sezioni rettangolari, qualora si volesse una sezione dalla forma diversa
basta cambiare la funzione di input scegliendo tra quelle presenti nelle OAPI con la
funzione voluta.
Codice 4.6: Definizione materiale e sezione
% definizione materiale
ret = SapModel . PropMaterial . AddMaterial ( ’ C32 /40 ’ ,2 , ’ Italy ’ ,...
... ’ UNI EN 206 -1:2006 e UNI 11104:2004 ’ , ’ C32 /40 ’);
% definizione sezione
ret = SapModel . PropFrame . SetRectangle ( ’30 x30 ’ , ’ C32 /40 ’ ,0.3 ,0.3);
Veniamo adesso alla costruzione della geometria del modello vera e propria. Sono
stati aggiunti al modello due elementi frame specificando le coordinate del nodo i di inizio
elemento e del non j di fine elemento definendo anche il nome dell’oggetto e il materiale
che lo caratterizza. Un altra possibilità di definizione dell’oggetto è quella di inserirlo tra
due nodi già esistenti e in questo caso non si dovrebbero inserire le coordinate ma solo i
nomi dei nodi. Ai due elementi frame vanno quindi assegnati degli opportuni vincoli, in
particolare si crea un vincolo incastro alla base dell’elemento mentre il nodo in sommità
è lasciato libero. L’assegnazione dei vincoli è qui effettuata attraverso un vettore nel
quale sono specificati i gradi di libertà vincolati, in questo caso l’elemento del vettore è
True, oppure se sono gradi di libertà non vincolati e in questo caso l’elemento del vettore
corrispondente sarà False. Il vettore è composto nel seguente modo:
U 1 U 2 U 3 R1 R2 R3
Ogni grado di libertà ha un esatta posizione nel vettore e per vincolarlo o non vincolarlo
bisogna immettere i valori boolean True o False nella posizione relativa al gdl che si
vuole controllare. Costruito il modello geometrico composto da due mensole bisogna
inserire un link gap che colleghi i nodi di sommità delle due. Quindi bisogna definire
innanzitutto le proprietà del link e successivamente assegnarlo specificando i nodi di inizio
e di fine elemento. La definizione delle proprietà del gap è effettuata attraverso il comando
SetGap che è definito da una serie di parametri di ingresso tra cui il nome da assegnare
all’elemento, i gradi di libertà che si vuole siano attivi o fissi cioè vincolati, se uno specifico
gdl abbia proprietà non lineari attive o meno, la rigidezza elastica dell’elemento e il suo
eventuale coefficiente di smorzamento elastico (queste proprietà sono prese per l’elemento
qualora si effettui un’analisi elastica oppure non siano attive le non linearità del gdl), le
proprietà non lineari del link quindi rigidezza ed apertura del giunto. Solo successivamente
si può assegnare il link tra due nodi alla stregua di quanto si farebbe direttamente da
SAP2000 utilizzando il comando ’draw 2 link joint’.
16
Codice 4.7: Definizione geometria modello
% Strutture 1 e 2
% add frame object by coordinates
ret = SapModel . FrameObj . AddByCoord (0.5 , 0 , 0 , 0.5 , 0 , 4 ,...
... ’ Str1 ’ , ’ C32 /40 ’ , ’ Str1 ’);
ret = SapModel . FrameObj . AddByCoord (2 , 0 , 0 , 2 , 0 , 4 ,...
... ’ Str2 ’ , ’ C32 /40 ’ , ’ Str2 ’);
% Cambia nome dei nodi di estremita delle strutture
ret = SapModel . PointObj . ChangeName ( ’1 ’ , ’ BaseStr1 ’);
ret = SapModel . PointObj . ChangeName ( ’2 ’ , ’ TopStr1 ’);
ret = SapModel . PointObj . ChangeName ( ’3 ’ , ’ BaseStr2 ’);
ret = SapModel . PointObj . ChangeName ( ’4 ’ , ’ TopStr2 ’);
% Vincoli Nodi
Incastro = logical ([1;1;1;1;1;1]);
Cerniera = logical ([1;1;1;0;0;0]);
Carrello = logical ([0;0;1;0;0;0]);
Libero = logical ([0;0;0;0;0;0]);
% Imposta il vincolo al nodo
ret = SapModel . PointObj . SetRestraint ( ’ BaseStr1 ’ , Incastro );
ret = SapModel . PointObj . SetRestraint ( ’ TopStr1 ’ , Libero );
ret = SapModel . PointObj . SetRestraint ( ’ BaseStr2 ’ , Incastro );
ret = SapModel . PointObj . SetRestraint ( ’ TopStr2 ’ , Libero );
% Modifica proprieta delle strutture
% Modificatori
MassMod = input ( ’ inserire modificatore massa struttura 1: ’);
ValMod =[1;1;1;1;1;1; MassMod ;1];
ret = SapModel . FrameObj . SetModifiers ( ’ Str1 ’ , ValMod );
% rapporto tra le masse
RapMass = input ( ’ inserire rapporto tra le due masse ( m2 / m1 ): ’);
MassMod = MassMod * RapMass ;
ValMod =[1;1;1;1;1;1; MassMod ;1];
ret = SapModel . FrameObj . SetModifiers ( ’ Str2 ’ , ValMod );
% GAP
% 1 DOF da assegnare al Link
DOF = logical ([1;0;0;0;0;0]);
% 2 DOF fissi
Fixed = logical ([0;0;0;0;0;0]);
% 3 NON LINEAR PROPERTIES da assegnare al Link
NLPROP = logical ([1;0;0;0;0;0]);
% 4 effective stiffness
Ke = [100000;0;0;0;0;0];
% 5 effective damping
17
Ce = [0;0;0;0;0;0];
% 6 initial stiffness applies for nonlinear analyses
KGAP = input ( ’ inserire K Gap [ Default : 100000]: ’);
if isempty ( KGAP )
KGAP = 100000;
end
k = [ KGAP ;0;0;0;0;0];
% 7 initial open GAP
op = [0.02;0;0;0;0;0];
ret = SapModel . PropLink . SetGap ( ’ GAP ’ , DOF , Fixed , NLPROP , Ke , Ce ,k , op ,0 ,0);
% set link property weight and mass
ret = SapModel . PropLink . SetWeightAndMass ( ’ GAP ’ ,0 ,0.001 ,0 ,0 ,0);
% aggiunge link tra 2 nodi
ret = SapModel . LinkObj . AddByPoint ( ’ TopStr1 ’ , ’ TopStr2 ’ , ’ GAP ’ ,0 , ’ GAP ’);
Le due strutture appaiono come una coppia di pilastri affiancati l’un l’altro. Gli elementi
beam sono caratterizzati da una sezione 0.3 m x 0.3 m ed hanno altezza pari a 4 m.
Figura 4.3: Modello a 2 gdl.
Costruito il modello occorre definire un analisi e lanciarla ed estrarre i risultati. Si è
scelto di sollecitare lo schema composto dalle due mensole tramite un accelerazione alla
base. Un’analisi non linear time history è eseguita utilizzando come storia di accelerazione
18
Figura 4.4: El Centro time history
alla base la storia accelerometrica dell’evento sismico di El Centro. Se le strutture
avessero le stesse proprietà dinamiche (periodo e frequenza) queste non arriverebbero
mai al contatto perché le due strutture si muoverebbero in fase. Quindi in questo caso le
strutture sono state ideate in modo tale che abbiano caratteristiche dinamiche differenti
anche se ad una prima occhiata sembrerebbe che possiedano la stessa configurazione. In
particolare agendo sui property modifiers della struttura 2 si è definita per quest’ultima
una massa 2 volte maggiore che la struttura 1. In questo modo le due strutture hanno
diverse proprietà dinamiche e vibreranno fuori fase. Inoltre per livelli di oscillazioni di
una certa entità potranno anche collidere tra di loro. Il codice matlab relativo alla
definizione della non linear time history analysis è riportato di seguito.
Codice 4.8: Definizione non linear time history analysis
% Definisce funzione time history da un file
ret = SapModel . Func . FuncTH . SetFromFile_1 ....
...( ’ ElCentro ’ , ’ C :\ Program Files ( x86 )\...
... Computers and Structures \ SAP2000 16\ Time History Functions \....
... ELCENTRO ’ ,0 ,0 ,3 ,2 ,1);
% Define nonlinear direct history load case
ret = SapModel . LoadCases . DirHistNonlinear . SetCase ( ’ NLDTH ’);
% Define load cases
MyLoadType ={ ’ Accel ’; ’ Accel ’};
MyLoadName ={ ’ U1 ’; ’ U1 ’};
MyFunc ={ ’ ElCentro ’; ’ ElCentro ’};
ScaleFactor = input ( ’ inserire fattore di scala : ’);
19
MySF ={ ScaleFactor ;1};
MyTF ={1;1};
MyAT ={0;0};
MyCSys ={ ’ ’; ’ ’};
MyAng ={0;0};
ret = SapModel . LoadCases . DirHistNonlinear . SetLoads ( ’ NLDTH ’ ,2 , MyLoadType ,...
... MyLoadName , MyFunc , MySF , MyTF , MyAT , MyCSys , MyAng );
% set proportional damping
Damp = input ( ’ inserire smorzamento per tutti i modi : [0:1] ’);
ret = SapModel . LoadCases . DirHistNonlinear ...
... SetDampProportional ( ’ NLDTH ’ ,2 ,0 ,0 ,0.01 ,5 , Damp , Damp );
% set time step data
nstep = input ( ’ inserire numero di time step : ’);
nsize = input ( ’ inserire la grandezza dei time step : ’);
ret = SapModel . LoadCases . DirHistNonlinear . SetTimeStep ...
...( ’ NLDTH ’ , nstep , nsize );
Bisogna innanzitutto creare una funzione time history, in questo caso la funzione
stabilita è l’accelerazione al suolo di El Centro. Quest’ultima è molto diffusa nella
letteratura grazie anche al fatto che si trova in un file presente nella cartella di SAP2000.
Quindi per definire la time history si carica il file inserendo nella funzione matlab il
percorso completo del file stesso. Successivamente si definisce il load case vero e proprio e
nella sua definizione verrà specificata come azione agente la storia accelerometrica di El
Centro, agente nella direzione interessata in questo caso U1. Ovviamente questa funzione
può essere anche scalata a piacere attraverso la variabile scale factor che è l’ultimo
parametro necessario per definire l’azione di carico. Invece per portare a compimento la
definizione del load case bisogna settare il coefficiente di smorzamento che si vuole assegnare
alla struttura durante l’analisi e inoltre specificare il passo temporale di integrazione ed
il numero di punti totali. Ovviamente con l’aumentare dei punti cresce l’accuratezza
dell’analisi ma allo stesso tempo cresce l’onere computazionale aumentando i tempi di
risoluzione. Le righe di codice qui di seguito permettono infine di salvare il modello
facendo aprire direttamente la stessa finestra che si aprirebbe se si salvasse sa SAP2000
ed una volta che il modello è stato salvato attraverso la funzione RunAnalysis viene fatta
partire l’analisi.
Codice 4.9: Salvataggio e run analysis
% Salva il modello
[ nomefile , percorso ]= uiputfile ({ ’*. sdb ’ , ’ File SAP2000
(*. sdb ) ’} ,...
... ’ Salva modello ’);
ret = SapModel . File . Save ( fullfile ( percorso , nomefile ));
% Vengono salvti i risultati ad ogni step
ret = SapModel . Results . Setup . SetOptionModalHist (2);
% Run model ( this will create the analysis model )
ret = SapModel . Analyze . RunAnalysis ;
20
L’estrazione dei risultati dal modello analizzato è un altra operazione realizzabile attraverso
il codice di programmazione. In più è possibile scrivere il codice anche in modo che una
volta estratti i dati vengano elaborati e i risultati per esempio plottati in via grafica in
modo automatico. L’estrazione dei dati di output del modello è possibile creando delle
variabili vuote per ogni tipologia di dato che si vuole raccogliere e definite in modo che
rispettino la classe di variabili a cui appartengono ogni dato. Quando si esegue una tale
operazione si parla di inizializzare le variabili. Essendo i dati raccolti nelle rispettive
variabili è possibile elaborarli eseguendo delle operazioni sulle variabili stesse. In fine si
plottano i risultati graficamente.
Codice 4.10: Estrapolazione dati di output
% Spostamento Joint
% Inizializza le variabili
t1NumeroRisultati = 0;
t1Obj = cellstr ( ’ ’);
t1Elm = cellstr ( ’ ’);
t1LoadCase = cellstr ( ’ ’);
t1StepType = cellstr ( ’ ’);
t1StepNum = 0;
t1U1 = 0;
t1U2 = 0;
t1U3 = 0;
t1R1 = 0;
t1R2 = 0;
t1R3 = 0;
[ ret , t1NumeroRisultati , t1Obj , t1Elm , t1LoadCase , t1StepType ,...
... t1StepNum , t1U1 , t1U2 , t1U3 , t1R1 , t1R2 , t1R3 ]=...
... SapModel . Results . JointDispl ( ’ TopStr1 ’ , 1 , t1NumeroRisultati ,...
... t1Obj , t1Elm , t1LoadCase , t1StepType , t1StepNum ,...
... t1U1 , t1U2 , t1U3 , t1R1 , t1R2 , t1R3 );
% Inizializza le variabili
t2NumeroRisultati = 0;
t2Obj = cellstr ( ’ ’);
t2Elm = cellstr ( ’ ’);
t2LoadCase = cellstr ( ’ ’);
t2StepType = cellstr ( ’ ’);
t2StepNum = 0;
t2U1 = 0;
t2U2 = 0;
t2U3 = 0;
t2R1 = 0;
t2R2 = 0;
t2R3 = 0;
[ ret , t2NumeroRisultati , t2Obj , t2Elm , t2LoadCase , t2StepType ,...
... t2StepNum , t2U1 , t2U2 , t2U3 , t2R1 , t2R2 , t2R3 ]=...
... SapModel . Results . JointDispl ( ’ TopStr2 ’ , 1 , t2NumeroRisultati ,...
21
... t2Obj , t2Elm , t2LoadCase , t2StepType , t2StepNum ,...
... t2U1 , t2U2 , t2U3 , t2R1 , t2R2 , t2R3 );
% Deformazione
% Inizializza le variabili
GA PNumeroRisultati = 0;
GAPObj = cellstr ( ’ ’);
GAPElm = cellstr ( ’ ’);
GAPLoadCase = cellstr ( ’ ’);
GAPStepType = cellstr ( ’ ’);
GAPStepNum = 0;
GAPU1 = 0;
GAPU2 = 0;
GAPU3 = 0;
GAPR1 = 0;
GAPR2 = 0;
GAPR3 = 0;
% get link deformations for link object
[ ret , GAPNumeroRisultati , GAPObj , GAPElm , GAPLoadCase , GAPStepType ,...
... GAP0StepNum , GAPU1 , GAPU2 , GAPU3 , GAPR1 , GAPR2 , GAPR3 ]=...
... SapModel . Results . LinkDeformation ( ’ GAP ’ ,1 , GAPNumeroRisultati ,...
... GAPObj , GAPElm , GAPLoadCase , GAPStepType , GAPStepNum ,...
... GAPU1 , GAPU2 , GAPU3 , GAPR1 , GAPR2 , GAPR3 );
% Sollecitazioni
% Inizializza le variabili
G APNumeroRisultatiS = 0;
GAPObjS = cellstr ( ’ ’);
GAPElmS = cellstr ( ’ ’);
GAPPointElmS = cellstr ( ’ ’);
GAPLoadCaseS = cellstr ( ’ ’);
GAPStepTypeS = cellstr ( ’ ’);
GAPStepNumS = 0;
GAPPoutp = 0;
GAPV2 = 0;
GAPV3 = 0;
GAPT = 0;
GAPM2L = 0;
GAPM3L = 0;
% get link forces for link object
[ ret , GAPNumeroRisultatiS , GAPObjS , GAPElmS , GAPPointElmS ,...
... GAPLoadCaseS , GAPStepTypeS , GAPStepNumS , GAPPoutp ,...
... GAPV2 , GAPV3 , GAPT , GAPM2L , GAPM3L ] =...
... SapModel . Results . LinkForce ( ’ GAP ’ ,1 , GAPNumeroRisultatiS , GAPObjS ,...
... GAPElmS , GAPPointElmS , GAPLoadCaseS , GAPStepTypeS , GAPStepNumS ,...
... GAPPoutp , GAPV2 , GAPV3 , GAPT , GAPM2L , GAPM3L );
22
Codice 4.11: Elaborazione dati di output
% PLOT GRAFICO FORZA - DEFORMAZIONE
figure (1)
plot ( t1StepNum , t1U1 );
hold all
title ( ’ Spostamento TopStr1 ’);
xlabel ( ’ Tempo ( sec ) ’);
ylabel ( ’ Spostamento ( m ) ’);
figure (2)
plot ( t2StepNum , t2U1 );
hold all
title ( ’ Spostamento TopStr2 ’);
xlabel ( ’ Tempo ( sec ) ’);
ylabel ( ’ Spostamento ( m ) ’);
figure (3)
plot ( GAPStepNum , GAPN );
hold all
title ( ’ Forza gap ’);
xlabel ( ’ Tempo ( sec ) ’);
ylabel ( ’ Forza ( kN ) ’);
figure (4)
plot ( GAPStepNum , GAPU1 );
hold all
title ( ’ Deformazione gap ’);
xlabel ( ’ Tempo ( sec ) ’);
ylabel ( ’ Spostamento ( m ) ’);
La scrittura di un codice completo che va dalla definizione del modello fino all’elaborazione
dei dati non è un operazione immediata e prevede un livello sufficiente di capacità di
programmazione e per questo richiede del tempo. Però una volta messo a punto un codice
si hanno notevoli vantaggi. Nel caso in cui si abbia interesse ad eseguire numerose analisi
o se si volessero cambiare rapidamente i parametri del modello. Lanciando lo script
contenente il codice è il calcolatore che svolge tutto in automatico seguendo le righe di
codice scritte. Con la finestra di SAP2000 a vista si vedrebbe come il file evolve man
mano che lo script avanza e si assisterebbe alla creazione del modello e alla sua analisi
senza alcun ulteriore intervento esterno.
4.2.2
Risultati analisi
Lo scopo principale di connettere due strutture tramite un elemento gap è che quest’ultimo
è in grado di trasmette forze di impatto attraverso il link quando le due strutture adiacenti
si avvicinano ed entrano in contatto l’un l’altra portando a chiusura il gap di separazione
tra le strutture stesse. Il codice implementato ha permesso una rapida disamina dei risultati
dell’analisi effettuata sul modello a 2 gdl. Nel seguito si metteranno in riporteranno
23
Spostamento TopStr1
0.04
Spostamento (m)
0.03
0.02
0.01
0
−0.01
−0.02
−0.03
−0.04
0
2
4
6
Tempo (sec)
8
10
12
10
12
Figura 4.5: Spostamento sommità struttura 1
Spostamento TopStr2
0.04
0.03
Spostamento (m)
0.02
0.01
0
−0.01
−0.02
−0.03
−0.04
0
2
4
6
Tempo (sec)
8
Figura 4.6: Spostamento sommità struttura 2
gli andamenti temporali dello spostamento dei punti di sommità delle due strutture,
la deformazione dei nlink che in questo caso coincide con la variazione temporale della
distanza tra le due strutture, e lo sforzo normale agente nel non linear gap durante l’analisi.
I diagrammi di forza e deformazione del gap descrivono bene i momenti di chiusura del
gap per cui si giunge a contatto tra le strutture. Tutti questi istanti coincidono con i picchi
dell’andamento temporale della deformazione dell n link che superano in compressione
i 2cm. Negli stessi istanti temporali coincidono dei picchi di forza agente ne link che
rappresentano la forza che si scambiano le due strutture del modello quando arrivano a
contatto. Conseguentemente la storia di spostamento dei nodi di sommità degli edifici
è influenzata da questa non linearità di contatto che si manifesta istantaneamente, in
aggiunta le due storie di spostamento differiscono per via delle diverse proprietà dinamiche
che possiedono e che le portano a vibrare fuori fase.
24
Deformazione gap
0.04
Spostamento (m)
0.03
0.02
0.01
0
−0.01
−0.02
−0.03
−0.04
0
2
4
6
Tempo (sec)
8
10
12
10
12
Figura 4.7: Deformazione non linear gap
Forza gap
0
Forza (kN)
−10
−20
−30
−40
−50
0
2
4
6
Tempo (sec)
8
Figura 4.8: Forza normale non linear gap
4.3
Conclusioni
Lo scopo prefissato era quello di introdurre un nuovo approccio per effettuare analisi
attraverso il software SAP2000 implementando un codice in linguaggio di programmazione
matlab. Il suddetto scopo è stato possibile raggiungerlo utilizzando una delle ultime
tecnologie disponibili nel software SAP2000: le Application Programming Interface (API).
Per poter raggiungere questo obiettivo ed evidenziare le capacità di utilizzo delle API
sono state sviluppate due applicazioni in linguaggio di programmazione matlab che
permettono il controllo di SAP2000 da remoto. Le applicazioni create riguardano l’analisi
di elementi non lineari presenti nella libreria di SAP2000 e una semplice loro inserimento
in un modello a 2 gdl. Il codice realizzato permette la gestione dei dati di input sia di
output ed una successiva elaborazione. Il controllo dei modelli e dei risultati da una
piattaforma esterna al software di analisi Essendo le API di SAP2000 una generica
funzione che permette il controllo dell’intera struttura del software di analisi lo stile di
25
programmazione utilizzato deve essere adattato alle funzioni definite nelle linee guide.
Bisogna quindi avere conoscenza del linguaggio di programmazione utilizzato e in primo
luogo la necessaria conoscenza dell’utilizzo di SAP2000 nella procedura standard.
Il lavoro svolto nel periodo di tirocinio è servito come base per proseguire il lavoro
di tesi, nel quale è stato fatto un ampio utilizzo di applicazioni esterne a SAP2000
opportunamente organizzate per gli scopi prefissati. Infatti sono state sviluppate diverse
applicazioni aventi controllo su un gran numero di parametri del modello e su un gran
numero di analisi da eseguire e in queste circostante sono evidenti i vantaggi di utilizzare
una procedura automatizzata da remoto.
In ultima non è da dimenticare l’importanza della supervisione umana sull’applicazione
di qualsiasi procedura e la capacità dell’utente e sensibilità di selezionare le variabili di
analisi ed interpretare i risultati che in fin dei conti è l’aspetto più importante di un
analisi.
26