Ingegneria Forum

Ingegneria Edile, Strutturale & Geotecnica => .:C#, Excel, VB e Programmazione:. => Topic started by: zax2010 on 07 April , 2011, 14:02:46 PM

Title: Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 07 April , 2011, 14:02:46 PM
Tutto nasce da una mia “pretesa” di oltre una decina di anni fa di riuscire a fare un programma per la verifica a presso-tenso-flessione deviata di sezioni generiche in cemento armato. Oltre dieci anni significa pieno periodo di verifiche alle tensioni ammissibili.

Ovviamente non ci sono riuscito, per mia scarsa conoscenza del linguaggio C, che allora pensavo di meglio padroneggiare, ed anche per la scarsa padronanza dell'interfaccia Windows lato “programmatore”.
Però tutto quanto ho recuperato ed imparato allora non è materiale perduto. Anche oggi le verifiche SLE alle tensioni vanno fatte, anche oggi le verifiche SLE a fessurazione implicano la conoscenza di uno stato tensionale di ogni singola barra, ecc.

Allora ero riuscito a ricavare quasi da solo - poiché non era mai stato menzionato in nessuno dei libri su cui avevo studiato, e nemmeno l'ho mai successivamente ritrovato (seppur non abbia cercato a fondo) – il cosiddetto “metodo della matrice di rigidezza della sezione”; che consente appunto, agli SLE, di fare ciò che recita il titolo del topic.

In parte mi meraviglio di come ci sia riuscito. Senza fonti, senza libri, ma semplicemente telefonando ad un ingegnere che un programma simile aveva fatto, e che rispondeva alle mie domande, da un lato cercando di non far trapelare un segreto “industriale” di grande portata; dall'altro invece con grande voglia di svelarmi i grandi segreti di sapienza da lui posseduti.

Nel tentativo di essere quanto più “didattico” possibile sto preparando un po' di materiale che, penso e spero, condividerò con voi a cadenza settimanale circa.

Per quanto riguarda la prima parte, ovvero le verifiche SLE, ho delle vecchie porzioni di codice che, adeguatamente rivedute e corrette, vorrei pubblicare per dare spunti a chi è più bravo e volenteroso di me.
Per le verifiche SLU probabilmente saranno più le chiacchiere che il resto.

Comunque, vedremo.

In ultimo: una dedica speciale ad Afazio, non ultimo nella condivisione della conoscenza.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 07 April , 2011, 14:04:45 PM
Parte 1

Geometria della sezione
Per prima cosa occorre definire matematicamente la sezione di forma generica.

Essa è costituita da una serie di n vertici, riferiti ad un sistema cartesiano, numerati in sequenza, ed in sequenza uniti da segmenti, fino a formare, unendo il primo e l'ultimo vertice, un poligono chiuso.
Dimenticatevi raccordi circolari ellittici, ecc. Questi potranno essere “riprodotti” con opportuni raffittimenti di vertici che approssimeranno più o meno bene queste parti curvilinee della vostra sezione. Ma in ogni caso comunque la sezione rimane poligonale.

Ecco un esempio di quanto intendo:

(http://s3.postimage.org/g1zl6io4/Sezione_generica1.png) (http://www.postimage.org/)

Per descrivere quindi in un software una simile geometria basterebbe memorizzare le n coppie di coordinate x,y di ogni singolo vertice.

Purtroppo però spesso la realtà non è così semplice come nell'immagine. Una sezione di forma realmente generica può essere costituita da parti piene e parti vuote, oppure da porzioni di sezione fatte con differente materiale (esempio sezioni precompresse con soletta di differenti caratteristiche del calcestruzzo, oppure sezioni in acciaio-calcestruzzo, ecc.).
Solamente quella dei vuoti è una situazione che è possibile bypassare semplicemente facendo “arrotolare” il poligono su se stesso. Ad esempio il famoso programma VCASLU del prof. Gelfi non permette di inserire più poligoni, però con questa accortezza è in grado di eseguire verifiche anche di sezioni cave.
Poco male però per noi, in quanto semplicemente la sezione verrà rappresentata non da uno, ma da più poligoni. Vedremo in seguito come il metodo assolutamente generico che propongo è in grado di gestire queste situazioni (ma anche parti di sezione che si parzializzano a trazione, oppure no).
Per adesso quindi ci concentreremo sul singolo poligono, si estenderanno poi i concetti espressi anche alle sezioni pluri-poligonali.
Alla prossima.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 07 April , 2011, 14:11:14 PM
Io ringrazio per la dedica speciale e seguo con attenzione. Chissà ...
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Massimo.T on 07 April , 2011, 14:16:53 PM
quando arrivi in fondo con gli SLE, qualcuno parte con gli SLU?
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 07 April , 2011, 16:23:13 PM
Parte 2

Calcolo delle caratteristiche geometriche delle sezioni
Premetto che queste nozioni di base sono finalizzate al calcolo SLE delle sezioni.
Il calcolo delle caratteristiche geometriche di una sezione rappresentata da un poligono, intendo baricentri, momenti statici e di inerzia rispetto agli assi coordinati, va svolta utilizzando una sommatoria di momenti statici e di inerzie riferite ad un singolo segmento del poligono stesso.
Ad esempio nella prima immagine sottostante potete vedere cosa si intende.

(http://s2.postimage.org/1j18r6pus/Sezione_generica2.png) (http://www.postimage.org/)

(http://s2.postimage.org/1j1ioestg/Sezione_generica3.png) (http://www.postimage.org/)

E' semplice verificare cosa accade se vogliamo calcolare l'area del poligono. Basterà calcolare l'area del trapezio sotteso ad ogni segmento (quello in grigio nella figura), per capire, girando segmento per segmento del poligono, fino all'ultimo segmento che unisce l'ultimo vertice con il primo, che alcuni trapezi avranno area positiva (ad esempio quello segnato), altri area negativa (quello della seconda immagine, perchè x[i+1]-x[i ] diventa negativo), e pertanto la somma algebrica di tutte queste aree restituisce, appunto, l'area del poligono.
Per le altre caratteristiche geometriche, si procederà in maniera analoga.

Il mattone “elementare” quindi diventa calcolare le caratteristiche geometriche del trapezio segnato nelle figure.
E' giusto che io non taccia e che dica subito che tutte le caratteristiche geometriche, però saranno riferite al sistema di riferimento prescelto, e quindi, almeno per i momenti statici e di inerzia, agli assi x ed y di figura.
Poco male. Basterà utilizzare i teoremi di trasporto per ritrovare momenti statici ed inerzie riferiti al baricentro della sezione. Perchè è questi che di seguito ci interesseranno.

Allora, per semplificare le varie formule ho indicato con a il valore (x[i+1]-x[i ]) e con d il valore (y[i+1]-y[i ]). In questo modo l'area sarà la somma di un rettangolo e di un triangolo (anche di area negativa se d è negativo), ed anche i momenti statici e le inerzie verranno spezzettate sommando inerzie di rettangoli e triangoli.

In definitiva avremo:

area
a*y[i ]+a*d/2   --> ovvero semplificando: a*(y[i ]+d/2)

momento statico attorno all'asse x
a*y[i ]^2/2+a*d/2*(y[i ]+d/3)   --> ovvero semplificando: a/2*(y[i ]^2+d^2/3+d*y[i ])

momento statico attorno all'asse y
In questo caso dovete immaginare il trapezio disposto in verticale proiettando il segmento sull'asse y, piuttosto che sull'asse x.
-d*x[i ]^2/2+d*a/2*(x[i ]+a/3)   --> ovvero semplificando: -d/2*(x[i ]^2+a^2/3+a*x[i ])

momento d'inerzia attorno all'asse x
a*y[i ]^3/3+a*d^3/36+a*d/2*(y[i ]+d/3)^2   --> ovvero semplificando: a/3*(y[i ]^3+y[i ]*d^2+3*y[i ]^2*d/2+d^3/4)

momento d'inerzia attorno all'asse y
Anche in questo caso il trapezio è ruotato, proiettando il segmento sull'asse y.
-d*x[i ]^3/3+d*a^3/36+d*a/2*(y[i ]+a/3)^2   --> ovvero semplificando: -d/3*(x[i ]^3+x[i ]*a^2+3*x[i ]^2*a/2+a^3/4)

momento d'inerzia xy
Non ricordo bene come lo abbia ricavato a suo tempo, ma pigliatelo come atto di fede, nella formulazione già semplificata:
a*(x[i ]/2*(y[i ]^2+d^2/3+d*hy)+a/2*(y[i ]^2/2+d^2/4+2*d*hy/3))

Adesso, ottenute tutte queste grandezze, sommandole tra loro, segmento per segmento costituente il poligono, ed eventualmente ripetendo ancora l'operazione per gli altri poligoni che compongono la sezione è possibile trovare il baricentro della sezione:

xg=Mstaticoy/areatot
yg=Mstaticox/areatot

Ed una volta avuto il baricentro, con i vari teoremi di trasporto ricavare le inerzie. Ad esempio:

inerziaxg=inerziax-areatot*yg^2

E così via.
Personalmente ho sempre avuto qualche difficoltà proprio in questa fase, specie per l'inerzia xy.
Pertanto avevo preferito, allungando un po' il brodo, calcolare prima aree e momenti statici, in modo da determinarmi inizialmente i baricentri, ed infine calcolarmi le inerzie direttamente dal baricentro (con una banale traslazione degli assi).

Per completare questa prima parte, preliminare si, ma assai basilare, introduco anche il valore di alfa, ovvero l'angolo degli assi principali di inerzia rispetto agli assi coordinati, ed i valori dei momenti principali di inerzia rispetto agli assi principali.
Come in tutti i manuali di geometria delle masse:

alfa=atan(-2*inerziagxy/(inerziagx-inerziagy))/2

ialfa=(inerziagx+inerziagy)/2+sqrt((inerziagx-inerziagy)^2+4*inerziagxy^2)/2
ibeta=(inerziagx+inerziagy)/2+sqrt((inerziagx-inerziagy)^2+4*inerziagxy^2)/2

Insomma, pare tutto facile. Però in effetti le cose non sono così semplici come io ve le ho raccontate finora. Infatti, domandatevi:

Cosa succede e cosa cambia se invece di inserire il poligono con i vertici via via in senso orario, li inserissi in senso antiorario?

E le armature, non ne parliamo?

Le risposte alla prossima.


Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 07 April , 2011, 16:45:31 PM
Intanto accadrebbe come prima cosa che l'area ottenuta sarebbe negativa.
Poco male dirai tu, perchè sara possibile ricorrere a questa caratteristica per poter inserire anche le cavità fissando a priori che il contorno esterno della sezione deve essere inputato con la sequenza dei vertici in senso orario mentre i contorni delle cavità devono essere inseriti coi vertici in senso antiorario.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 07 April , 2011, 16:47:37 PM
Esattamente, caro Afazio.

Io però, questa caratteristica che tu hai appena enunciato, e che esiste ovviamente, non intendo sfruttarla.
Spiegherò meglio alla prossima.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 07 April , 2011, 16:55:06 PM
dal link che metto a seguire, potete scaricare un file excel che calcola la caratteristiche meccaniche per qualsiasi sezione (ma senza cavità).

http://www.box.net/shared/dmxqgjt77a (http://www.box.net/shared/dmxqgjt77a)

Il fogklio implementa le formule descritte da Zax ricorrendo alla funzione scarto per ottenere le differenze tra le coordinate.

ciao

NB.: Anche questo file gode delle stesse restrizioni che ho imposto per la procedura di disegno dei pali.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 07 April , 2011, 21:09:01 PM
Bravo Zax, bella iniziativa. Non mancherà di certo il mio contributo.

Ciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 07 April , 2011, 22:38:58 PM
Bravo Zax, bella iniziativa. Non mancherà di certo il mio contributo.

Ciao.

Ti chiedo scusa per la madornale scortesia nei tuoi confronti.
Arci contento del "ritorno" di Afazio, ho dimenticato di richiamare anche te nel mio messaggio iniziale.

Chi meglio di te, che già un programma del genere hai fatto, e soprattutto hai condiviso (il DORO se non sbaglio), doveva essere richiamato e ringraziato?

Spero certamente nel tuo contributo, e non esitare a darlo, specie se troverai inesattezze in quanto ho già detto e dirò.
Ancora non ho pubblicato qui alcuna riga di codice, ed ho previsto di farlo nella parte 4, spero vivamente che non inorridirai.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 08 April , 2011, 21:04:26 PM
Ti chiedo scusa per la madornale scortesia nei tuoi confronti.
Arci contento del "ritorno" di Afazio, ho dimenticato di richiamare anche te nel mio messaggio iniziale.

Chi meglio di te, che già un programma del genere hai fatto, e soprattutto hai condiviso (il DORO se non sbaglio), doveva essere richiamato e ringraziato?

Spero certamente nel tuo contributo, e non esitare a darlo, specie se troverai inesattezze in quanto ho già detto e dirò.
Ancora non ho pubblicato qui alcuna riga di codice, ed ho previsto di farlo nella parte 4, spero vivamente che non inorridirai.

Assolutamente nessuna scortesia, ci mancherebbe.
Anch'io sono super contento del ritorno di Afazio dopo tanti mesi; spero che possa essere una nuova occasione per confrontarsi ancora una volta.
Una piccola inesattezza se mi consenti la hai già scritta, ieri non ho avuto 5 min. per scrivertelo. I momenti d'inerzia riportali subito al baricentro geometrico, quelli sulla terna di riferimento "globale" sono inutili (spesso) e possono portare ad una errata valutazione dell'inerzia rispetto ad un asse generico (serve una doppia trasposizione).
Non credo di aver motivo di inorridire, però penso di poterti indirizzare su scelte più avvedute. E' vero che sbagliando si impara, ma quando si tratta di scrivere un codice di calcolo è meglio pensare tre volte e lavorare una volta sola piuttosto che il viceversa.
Quando vuoi scrivimi pure, in privato o in pubblico che sia, sono contento di aiutarti se posso. L'importante è di partire col piede giusto e con le idee chiare (l'algoritmo), dopodichè lo sviluppo del codice ed il debug sono il meno.

Ciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 09 April , 2011, 11:36:11 AM
Parte 3

Complichiamo un po le cose
Nella Parte 1 avevo parlato di vuoti che le sezioni reali possono possedere, oppure di differenti materiali costituenti porzioni separate della sezione totale.
Nel determinare le caratteristiche geometriche della sezione però non ne ho più fatto cenno.

Torniamo però adesso alla questione rimasta in sospeso nella Parte 2. Ovvero cosa accade se nell'input dei vertici di un poligono qualcuno inserisce i vertici in senso antiorario, piuttosto che in senso orario così come dalle figure riportate nella Parte 1.
E' semplice: l'area del poligono, ad esempio, risulterà negativa, così come tutte le altre caratteristiche geometriche.
Come mi hanno già fatto osservare, questo “problema” potrebbe trasformarsi invece in una opportunità. I “pieni” di una sezione vanno inseriti in senso orario, i “vuoti” di una sezione in senso antiorario. Basterebbe informare l'utente di una simile opportunità.
Questa caratteristica però non risolverebbe tutte le problematiche connesse con “realtà” articolate.

Un esempio chiarirà meglio.
Immaginate di avere una sezione precompressa, cava, che viene completata in opera, con un getto di calcestruzzo di differenti caratteristiche meccaniche, a sua volta cavo, perchè alleggerito con del polistirolo.
Ecco, per rappresentare una simile sezione occorreranno 4 poligoni. Un primo poligono sarà la parte “esterna” della sezione in c.a.p., il secondo poligono, la parte “vuota” della stessa, un terzo poligono il contorno esterno del getto in opera, ed infine il quarto poligono il vuoto all'interno della soletta.
Scopriamo l'acqua calda sapendo che i due calcestruzzi differenti di cui è composta la sezione nel suo complesso, possono essere trattati come se fossero uno solamente introducendo il fattore n di omogeneizzazione dato dal rapporto tra i moduli elastici dei due calcestruzzi.

Quindi basterà introdurre un semplice moltiplicatore, per ogni poligono costituente la sezione, per risolvere il problema. Moltiplicatore che di seguito chiamerò “omog”.

Tale moltiplicatore può valere ad esempio 1.0 per il poligono “pieno” esterno della sezione in c.a.p., -1.0 per il poligono che rappresenta il “vuoto” della sezione predetta, valere (esempio) 0.79 per il poligono che rappresenta la parte esterna della soletta, ed infine -0.79 per la sua parte “vuota”.
Se avessi optato per un “poligono antiorario” per il 4° poligono avrei tolto più area di quanto invece non ne avevo messo con il 3° poligono.

Pertanto un moltiplicatore “omog” negativo rappresenta un vuoto, un moltiplicatore “omog” positivo, una parte di sezione piena. Non necessariamente “omog” dovrà essere limitato nella sua espressione numerica, esso può valere anche più di 1.0
L'esempio classico è quello della sezione mista acciaio calcestruzzo. Il poligono che rappresenta il profilo metallico che la costituisce potrà avere “omog” 15.0, oppure 6.0, ecc.

A questo punto però è essenziale che gli algoritmi del programma si trovino sempre dei poligoni inseriti in senso orario.
Da un punto di vista di un programma software si può procedere in due modi: Si avvisa l'Utente “a lettere maiuscole” che nell'input deve procedere in senso orario, oppure si provvede a creare un “automatismo” per cui è il software che all'occorrenza “raddrizza” input “storti”.
Io personalmente prediligo questa seconda via, vista anche l'esperienza giornaliera che ognuno di noi fa con la chat di questo forum.
E la prossima volta vi fornirò una funzioncina che esegue proprio questo raddrizzamento.

Piccolo inciso. Le possibilità che l'input dell'utente possa essere “storto” non si limitano a questo solo aspetto. Tante altre possono essere le possibilità di “sbagliare” l'input. Essendomi concentrato più sull'output in realtà non voglio parlare degli aspetti riguardanti l'input. Se però qualcuno di voi volesse.....a disposizione.

Anche nel caso delle armature, da inserire anch'esse per il calcolo delle caratteristiche statiche della sezione, sarà necessario utilizzare la variabile “omog”. In questo caso essa piglierà il tipico valore 15, oppure il valore ritenuto opportuno.
Ogni singola barra di armatura verrà considerata come una massa concentrata disposta nelle coordinate x,y e di area af. Ossia come in figura:

(http://s2.postimage.org/20qdjmyqs/Sezione_generica5.png) (http://www.postimage.org/)

In questo modo le varie entità geometriche dovranno essere aumentate delle quantità, calcolate barra per barra:

area
omog*af

momento statico attorno all'asse x
omog*af*y[i ]

momento statico attorno all'asse y
omog*af*x[i ]

momento d'inerzia attorno all'asse x
omog*af*y[i ]^2

momento d'inerzia attorno all'asse y
omog*af*x[i ]^2

momento d'inerzia xy
omog*af*x[i ]*y[i ]
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Ing. Edoardo on 09 April , 2011, 11:44:00 AM
afazio ti chiedo se possiamo pubblicare nella sezione download, il foglio che tu hai gentilmente condiviso qui.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 09 April , 2011, 17:48:22 PM
@Zax

Ti dico come lo ho impostato io in due miei programmi: la polilinea è unica per ogni materiale e deve essere inserita sempre in senso orario. L'utente verifica l'area dopo l'input; in caso di sezione cave (semplicemente connesse o pluriconnesse - 2 o più fori -) la parte interna viene definita in senso "antiorario" (e lo virgoletto) "aprendo" la sezione con un taglio fittizio e richiudendo la sezione definendo nuovamente le coordinate dei vertici in corrispondenza del taglio. Anche nel caso di sezioni cave è opportuno un controllo sull'area da parte dell'utente (potrebbe inserire tutto in senso orario, con aree doppie al posto dei vuoti). In tutti i casi il programma dopo aver calcolato l'area verifica che sia >0 e in caso contrario "consiglia" all'utente l'inversione automatica dei vertici.
Sui coefficienti di omogeneizzazione ho qualche riserva concettuale essendo un approccio di calcolo tipico delle tensioni ammissibili. Ci ritornerò, anche se agli SLE le cose vanno comunque bene.

Ciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Gilean on 09 April , 2011, 17:49:24 PM
ing edo, puoi farlo tranquillamente, inserendo nel download creato non gia' il file, bensi il link al suo hdd virtuale.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 09 April , 2011, 22:21:26 PM
@ Edo

esatto, e' come dice Gil. Il file deve continuare a risiedere sul mio Box.net

Grazie
Ciao

@ Zax
Interessante davvero il ricorso al fattore sottrattivo per l'inserimento di vuoti "dello stesso materiale". Non ci avevo mai pensato.

Ti seguo.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 14 April , 2011, 14:11:01 PM
Parte 4

Un po' di linee di codice
Prima di addentrarci nelle verifiche vere e proprie, cominciamo a buttare giù pezzetti di programma, in modo da “consolidare” quanto detto nelle parti precedenti.

In un header file, per prima cosa definiamo le seguenti strutture dati:

Code: [Select]
struct poligono_sezione
{
 float x[100];   /* coordinata x del vertice */
 float y[100];   /* coordinata y del vertice */
 int numv;       /* numero di vertici del poligono */
 float omog;     /* coefficiente di omogeneizzazione */
 int traz;       /* 0=non reagente a trazione; 1=reagente a trazione */
 float fd;       /* Resistenza massima di calcolo */
 int dominio;    /* 0=parabola-rettangolo (cls) 1=bilatera (acciaio) */
 int fase;       /* A futura memoria per gestire fasi di realizzazione */
};

struct armature_sezione
{
 float af[200];  /* area della barra di armatura */
 float x[200];   /* coordinata x della barra */
 float y[200];   /* coordinata y della barra */
 int numarm;     /* numero di barre per l'intera sezione */
 float omogarm;  /* coefficiente di omogeneizzazione */
 int fase;       /* A futura memoria per gestire fasi di realizzazione */
};

La prima struttura dati è relativa ai singoli poligoni che costituiranno la sezione, la seconda viceversa riguarda le armature.
fd e dominio per i poligoni sono variabili che serviranno quando parleremo delle verifiche SLU.
Quelle che abbiamo scritto, non sono ancora delle variabili vere e proprie, sono solamente dei “prototipi”. Ovvero si informa il compilatore che prima o poi avremo bisogno di una o più variabili con questa “forma” e di prepararsi ad utilizzare l'opportuno spazio in memoria per esse.
Infatti, come variabile globale prima o poi scriveremo, nel programma principale, due righe del genere:

Code: [Select]
struct poligono_sezione poli[5];
struct armature_sezione arm;

Ovvero abbiamo “creato” 5 poligoni, costituenti la sezione, ognuno da 100 vertici. E 200 barre di armatura.
Nel seguito dei listati vedrete delle espressioni tipo: poli[3].x[34], in questo caso l'espressione indica la coordinata x del 35-simo vertice del quarto poligono costituente la sezione (nel C i vettori iniziano tutti dal termine 0, per cui aver dichiarato 100 entità significa che i vertici andranno da 0 a 99, e i poligoni da 0 a 4). O ancora: arm.y[34], coordinata y della barra n. 35.

Apro una parentesi per evidenziare la mia pochezza come programmatore. Con queste semplici prime righe, in definitiva io mi sono già tagliato le gambe. Ovvero ho già dato dei limiti al mio programma. 100 al massimo i vertici per poligono, e 5 al massimo i poligoni per sezione, 200 le barre di armatura.
Certo potrei utilizzare le macro (#define NUMVERTMAX 100 oppure #define NUMPOLIMAX 5) e quindi modificare agevolmente questi vincoli (il 100 ed il 5 delle macro), che però in ogni caso rimangono. Inoltre impegnerò una uguale quantità di memoria sia che un singolo poligono sia costituito da 5 vertici, che da 99 vertici; sia che la mia sezione sia costituita da 5 poligoni, o che sia costituita da uno solo.
Un programmatore più esperto e scafato di me, avrebbe proceduto con una assegnazione dinamica delle variabili, in modo da creare lo spazio in memoria, mano mano che esso si rendesse necessario, e di liberarlo se esso non servisse più. A quel punto il limite per rappresentare una sezione diventa semplicemente la quantità di RAM libera a disposizione del sistema.
Accontentiamoci.

Le caratteristiche geometriche della sezione sono essenziali per sviluppare il resto degli algoritmi, pertanto, anche in questo caso, si utilizzerà la struttura dati:

Code: [Select]
struct geometria_sezione
{
 float area;    /* Area della sezione */
 float scx;     /* Momento statico rispetto ad asse x baricentrico */
 float scy;     /* Momento statico rispetto ad asse y baricentrico */
 float ix;      /* Momento d'inerzia rispetto ad asse x baricentrico */
 float iy;      /* Momento d'inerzia rispetto ad asse y baricentrico */
 float ixy;     /* Momento d'inerzia polare rispetto ad assi x,y baricentrici */
 float alfa;    /* Inclinazione (rad) degli assi principali d'inerzia */
 float ia;      /* Momenti principali di inerzia */
 float ib;
};

Anche in questo caso si tratta di un “prototipo”.
Le ultime 3 variabili alfa, ia, ib, sono assolutamente ininfluenti per le verifiche che faremo in seguito, ma possono risultare utili nel caso in cui si volesse far disegnare al programma l'ellisse centrale d'inerzia della sezione.
Così come prototipi, da inserire in un header file, sono le due dichiarazioni di funzioni:

Code: [Select]
struct geometria_sezione calcola_caratt_geometriche (struct poligono_sezione *);
void inversione_poligono (int);

Scrivo il “corpo” della prima funzione, poi cercherò di spiegarne il funzionamento:

Code: [Select]
struct geometria_sezione calcola_caratt_geometriche (struct poligono_sezione *polic)
{
 int register k,kp1,np;
 float a,d,hy,hx;
 struct geometria_sezione geo;

 /* Azzera inizialmente tutte le variabili statiche da calcolare */
 geo.area=0.0; geo.scx=0.0; geo.scy=0.0;
 geo.ix=0.0;   geo.iy=0.0;  geo.ixy=0.0;
 /* Calcola le caratteristiche statiche di ogni singolo poligono */
 for (np=0;np<=4;np++)
     {
      for (k=0;k<=polic[np].numv-1;k++)
          {
           if (k==polic[np].numv-1) kp1=0; else kp1=k+1;

           a=polic[np].x[kp1]-polic[np].x[k];
           d=polic[np].y[kp1]-polic[np].y[k];
           hy=polic[np].y[k]-yg;
           hx=polic[np].x[k]-xg;

           geo.area+=polic[np].omog*a*(hy+d/2);
           geo.scx+=polic[np].omog*a/2*(hy*hy+d*d/3+d*hy);
           geo.scy-=polic[np].omog*d/2*(hx*hx+a*a/3+a*hx);
           geo.ix+=polic[np].omog*a/3*(pow(hy,3)+hy*d*d+3*hy*hy*d/2+pow(d,3)/4);
           geo.iy-=polic[np].omog*d/3*(pow(hx,3)+hx*a*a+3*hx*hx*a/2+pow(a,3)/4);
           geo.ixy+=polic[np].omog*a*(hx/2*(hy*hy+d*d/3+d*hy)+a/2*(hy*hy/2+d*d/4+2*d*hy/3));
          }
     }
 /* Inserisce le armature nelle caratteristiche statiche */
 for (k=0;k<=arm.numarm-1;k++)
     {
      if (arm.af[k]!=0.0)
         {
          geo.area+=arm.omogarm*arm.af[k];
          geo.scx+=arm.omogarm*arm.af[k]*(arm.y[k]-yg);
          geo.scy+=arm.omogarm*arm.af[k]*(arm.x[k]-xg);
          geo.ix+=arm.omogarm*arm.af[k]*pow(arm.y[k]-yg,2);
          geo.iy+=arm.omogarm*arm.af[k]*pow(arm.x[k]-xg,2);
          geo.ixy+=arm.omogarm*arm.af[k]*(arm.x[k]-xg)*(arm.y[k]-yg);
         }
     }
 
 /* Calcola l'inclinazione degli assi principali d'inerzia */
 if (geo.ix-geo.iy!=0) geo.alfa=atan(-2*geo.ixy/(geo.ix-geo.iy))/2; else alfa=0;
 if (geo.ix<geo.iy)    geo.alfa+=1.570796327;
 /* E le inerzie secondo gli assi principali */
 geo.iga=(geo.ix+geo.iy)/2+sqrt(pow(geo.ix-geo.iy,2)+4*pow(geo.ixy,2))/2;
 geo.igb=(geo.ix+geo.iy)/2-sqrt(pow(geo.ix-geo.iy,2)+4*pow(geo.ixy,2))/2;
 
 return (geo);
}

La funzione ammette come parametri di ingresso i dati dei vari poligoni, trasferiti però su una variabile locale (il puntatore alla struttura dati polic) – vedremo in seguito che questo permette di calcolare caratteristiche geometriche di poligoni differenti da quelli inputati dall'utente – e restituisce le varie caratteristiche geometriche condensandole tutte nella struttura geo. Delle varie formule è inutile parlarne, in quanto sono praticamente quelle della parte 2 e 3 di questa dissertazione. Come annunciato (ma anche suggerito da Alberto Ferrari) con le varie caratteristiche geometriche calcolate direttamente rispetto ad assi che passano per il baricentro xg,yg della sezione omogenea (baricentro che qui è una variabile globale e che dovrebbe essere calcolato a parte, prima dell'utilizzo della funzione stessa). Nel listato del programma un utilizzo tipico della funzione è:

Code: [Select]
geo=calcola_caratt_geometriche(poli);
In questo modo al “ritorno” dalla funzione, la variabile geo (è una struttura dati), viene “riempita” con tutti i valori geometrici che interessano. I parametri di ingresso, sono tutti raggruppati nel puntatore alle varie strutture dati poli[5] definiti dall'utente.
Faccio notare come il calcolo del momento statico della sezione rispetto al baricentro della stessa non avrebbe senso. Per definizione tali momenti statici sono infatti nulli. Ma questo accade solamente per la sezione “intera”. Ma non è il caso di anticipare ora, esigenze che si avvertiranno successivamente.

Code: [Select]
void inversione_poligono(int np)
{
 int register k;
 float provv;

 for (k=1;k<=poli[np].numv/2;k++)
     {
      provv=poli[np].x[k]; poli[np].x[k]=poli[np].x[poli[np].numv-k]; poli[np].x[poli[np].numv-k]=provv;
     
      provv=poli[np].y[k]; poli[np].y[k]=poli[np].y[poli[np].numv-k]; poli[np].y[poli[np].numv-k]=provv;
     }
}

Questa funzione non fa altro che invertire l'ordine di inserimento dei vertici del poligono np, in modo da avere sempre i poligoni descritti in modo orario. Questo perchè le varie formuline viste nella parte 2, per funzionare, presuppongono, che i vertici vengano inseriti in questo modo. Non fa altro quindi che scambiare i vertici tra loro, utilizzando la variabile di appoggio provv.
Ci dovrebbe essere una porzione di codice che calcola l'area di ogni singolo poligono inserito dall'utente, e se questa è negativa, chiama la funzione inversione_poligono(), in modo che l'input sia come il programma lo desidera. In pratica una porzione come questa:

Code: [Select]
for (np=0;np<=4;np++)
    {
     area=0.0;
     for (k=0;k<=poli[np].numv-1;k++)
         {
          if (k==poli[np].numv-1) kp1=0; else kp1=k+1;

          a=poli[np].x[kp1]-poli[np].x[k];
          d=poli[np].y[kp1]-poli[np].y[k];

          area+=a*(poli[np].y[k]+d/2);
         }
     if (area*poli[np].omog<0.0) inversione_poligono(np);
    }

Vedete che nel calcolo dell'area, questa volta non si è utilizzata la variabile omog, in quanto per un poligono “vuoto”, nel caso di vertici disposti in modo orario, l'area sarebbe stata negativa (visto che omog=-1.0 per un poligono vuoto), e quindi si sarebbe invertito un poligono già buono.
In ultimo segnalo che si sta intervenendo su un input dell'utente (infatti ho invertito la variabile globale poli[np]). Questo modo di agire, potrebbe essere assai sgradito. Pertanto si potrebbe pensare di manipolare delle strutture dati “copia”, in modo che l'utente continui con le sue abitudini, e viceversa il programma mette le cose a posto per come gli servono. Ovviamente è una scelta che si paga in termini di occupazione in memoria delle strutture dati (ma con 4Gb di RAM, ormai...).
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 15 April , 2011, 14:18:02 PM
Parte 5

Facciamo sul serio
Cominciamo a questo punto ad entrare - e finalmente direte voi - nel merito effettivo di uno degli argomenti di questo topic. Ovvero nella verifica della sezione generica a presso-tenso-flessione deviata agli SLE.
Scusatemi, ma inizierò da lontano, ovvero non parlando di sezioni in cemento armato, ma di sezioni di forma generica qualsivoglia ma con tutti i poligoni reagenti sia a trazione che a compressione. Ovvero di sezioni che non si parzializzano.

Posizioniamo per benino le pedine nello scacchiere.
Innanzitutto calcoliamo il baricentro della sezione ideale della nostra sezione complessiva. Abbiamo visto nella parte 2 e 3 come fare. Se non ve lo ricordate andrete a guardare nuovamente.
Comunque ecco uno spezzone di programma che calcola le variabili globali xg ed yg (coordinate di suddetto baricentro – ed avendo prima provveduto a invertire i poligoni non inseriti in senso orario – vedi Parte 4):

Code: [Select]
area=0.0; scx=0.0; scy=0.0;
 /* Caratteristiche statiche di ogni poligono */
 for (np=0;np<=4;np++)
     {
      for (k=0;k<=poli[np].numv-1;k++)
          {
           if (k==poli[np].numv-1) kp1=0; else kp1=k+1;

           a=poli[np].x[kp1]-poli[np].x[k];
           d=poli[np].y[kp1]-poli[np].y[k];
           hy=poli[np].y[k];
           hx=poli[np].x[k];

           area+=poli[np].omog*a*(hy+d/2);
           scx+=poli[np].omog*a/2*(hy*hy+d*d/3+d*hy);
           scy-=poli[np].omog*d/2*(hx*hx+a*a/3+a*hx);
          }
     }

 if (area!=0.0) { xg=scy/area; yg=scx/area; }
 else /* Quello che si vuole: Messaggio di errore, stop del programma, ecc. */

Nel calcolo del baricentro della sezione omogenea, non si sono considerate le armature.
Ipotizziamo adesso di avere una tripletta di sollecitazioni, precisamente:
N, ovvero una forza disposta con direzione ortogonale al piano della sezione, essa avrà verso positivo se genera compressione nella sezione e negativo se genera trazione, e con punto di applicazione coincidente con il baricentro della sezione omogenea;
Mx, ovvero un momento flettente con asse momento coincidente con l'asse x e con verso positivo se esso genera compressione nelle fibre della sezione disposte lungo il verso positivo dell'asse y (diciamo quindi regola della mano sinistra);
My, ovvero un momento flettente con asse momento coincidente con l'asse y e con verso positivo se esso genera compressione nelle fibre della sezione disposte lungo il verso positivo dell'asse x (diciamo quindi regola della mano destra).

Normalmente, per una sezione generica, il buon e volenteroso ingegnere, provvederebbe a determinare le caratteristiche geometriche della sezione, a determinare l'inclinazione degli assi principali rispetto agli assi coordinati, poi proietta i momenti flettenti su questi assi, ed infine utilizza una formula del tipo N/A+Mbeta/Walfa+Malfa/Wbeta.
Procederemo invece per differente strada, forse più complicata da percorrere nel caso specifico, ma che ci apre la strada a tante possibilità in più, che applicheremo successivamente alle sezioni parzializzate.

Ora, tutto il discorso non può esulare dalle solite, classiche, equazioni di equilibrio. Scriviamole, in maniera generica per la sezione nella loro forma più generale, introducendo la funzione σ(x,y) che non rappresenta altro che la tensione che agisce nel punto generico (x,y)  della sezione:

∫σ(x,y)*dΩ+Σaf*σf(xa,ya)=N

∫σ(x,y)*y*dΩ+Σaf*σf(xa,ya)*ya=Mx

∫σ(x,y)*x*dΩ+Σaf*σf(xa,ya)*xa=My

Dove gli integrali sono estesi all'intera area Ω della sezione; e dove, attenzione, x ed y sono coordinate riferite ad un sistema di assi che ha origine nel baricentro della sezione omogenea (baricentro che è anche punto di applicazione di N). xa,ya sono le coordinate di ogni singola barra di armatura, sempre rispetto a questo sistema di assi.
In definitiva le tre equazioni messe a sistema altro non dicono che l'insieme delle tensioni che si instaurano punto per punto nella sezione devono essere in grado di equilibrare contemporaneamente lo sforzo normale esterno e i due momenti flettenti.

Fino a questo momento la generalità delle equazioni è tale che non siamo stati costretti a fare alcuna ipotesi “restrittiva” su tensioni, comportamento della sezione sotto carico, ecc.
Ebbene, dobbiamo cominciare a farlo adesso.
Ovviamente trattasi delle ipotesi “classiche” che qui vengono richiamate:

1) Deformazione piana della sezione;
2) Elasticità lineare dei materiali costituenti la sezione.

Con questi due concetti essenziali, è possibile fare delle considerazioni che tolgono certamente generalità alle 3 equazioni scritte prima, ma che consentono anche di risolverle in maniera “comoda”.

Immaginiamo adesso di abbandonare le tensioni presenti nella sezione e di concentrarci sulla deformazione della stessa. Ovvero sulla funzione deform(x,y) che ci restituisce la deformazione sotto carico nel generico punto x,y della sezione.
Per la prima ipotesi, visto che deformandosi la sezione deve rimanere piana, tale funzione dipende da tre soli parametri: una deformazione lineare in corrispondenza del baricentro della sezione, una rotazione della stessa attorno all'asse x (sempre baricentrico) ed una rotazione attorno all'asse y (sempre baricentrico).

In pratica la funzione avrà una espressione (ovviamente stiamo parlando di piccoli spostamenti e piccole rotazioni, tali da far ritenere tan(φx)=φx e tan(φy)=φy):

deform(x,y)=u+φx*y+φy*x

Le convenzioni riguardo questi tre parametri sono sostanzialmente identiche alle convenzioni sui segni esposte per le sollecitazioni esterne, pertanto:
u è una deformazione positiva se “comprime” la sezione.
φx è la rotazione attorno all'asse x, positiva se la parte di sezione in direzione +y si “comprime” (regola della mano sinistra).
φy è la rotazione attorno all'asse y, positiva se la parte di sezione in direzione +x si “comprime” (regola della mano destra).
(Fateci caso, spostamenti e sollecitazioni esterne hanno le stesse convenzioni riguardo segni negativi o positivi).

Ma d'altra parte per la seconda ipotesi, la elasticità lineare del materiale, esiste una costante di linearità - il modulo elastico del materiale – che lega deformazione a tensione, per cui:

σ(x,y)=E*deform(x,y)

Ed in ultima analisi:

σ(x,y)=E*(u+φx*y+φy*x)

E se adesso sostituissimo questo risultato alle tre equazioni di equilibrio?
(Ovviamente dobbiamo ricordarci che le armature hanno un differente modulo elastico e quindi per esse dovremo moltiplicare la funzione σ(x,y) per il coefficiente “omog” introdotto nella Parte 3)

Ecco cosa si ottiene:

E*[u*∫dΩ+φx*∫y*dΩ+φy*∫x*dΩ+omog*(u*Σaf+φx*y*Σaf+φy*x*Σaf)]=N

E*[u*∫y*dΩ+ φx*∫y^2*dΩ+ φy*∫x*y*dΩ+omog*(u*y*Σaf+φx*y^2*Σaf+φy*x*y*Σaf)]=Mx

E*[u*∫x*dΩ+ φx*∫x*y*dΩ+ φy*∫x^2*dΩ+omog*(u*x*Σaf+φx*x*y*Σaf+φy*x^2*Σaf)]=My

Ci si può subito rendere conto a questo punto che i singoli coefficienti dell'equazione (sia riferiti alla sezione vera e propria, sia alle armature) non sono altro che l'area ed i momenti statici e di inerzia della sezione ideale.
Pertanto le equazioni di equilibrio possono essere essere scritte nella seguente forma più compatta:

E*[Area*u+Sx*φx+Sy*φy]=N
E*[Sx*u+Ix*φx+Ixy*φy]=Mx
E*[Sy*u+Ixy*φx+Iy*φy]=Mx

Possiamo anche scriverlo in maniera matriciale, individuando una matrice dei coefficienti (Area, Sx, ecc.) un vettore deformazione (u,φx,φy), ed infine un termine noto (N,Mx,My). In questo modo:

  | Area Sx    Sy | |u | |N |
E*| Sx   Ix   Ixy |*|φx|=|Mx|
  | Sy   Ixy   Iy | |φy| |My|


La matrice dei coefficienti prende anche il nome di “matrice di rigidezza della sezione”.
Se la guardate bene infatti gode delle stesse proprietà di una matrice di rigidezza di strutture più complesse ad articolate. Area, Ix, Iy, i termini sulla diagonale, sono essenzialmente positivi, ed è anche simmetrica. Non so se queste siano condizioni sufficienti a definire di rango 3 la matrice, ma questo certamente accade. Senza tema di smentite.
Capite bene che tale sistema è risolvibile. Abbiamo tre equazioni di equilibrio e tre incognite (u,φx,φy), che, attraverso il termine noto (N,Mx,My), possono essere tranquillamente ricavate.
Un sistema in 3 incognite alla portata di tutti e di qualsiasi scalcinato elaboratore elettronico.
L'incomodo E può tranquillamente essere trascurato. Nel senso che risolvendo il sistema, senza moltiplicare tutte le equazioni per E, non si trovano effettivamente le deformazioni della sezione, ma 3 numeri “ibridi”, che però, con la formula:

u+φx*y+φy*x

Darebbero, a meno del fattore “omog”, direttamente la tensione nel punto generico di coordinate x,y.

Per ricavare le massime o minime tensioni nella sezione basterà indagare le tensioni agenti sui vari vertici della stessa. Per le ipotesi fatte, i massimi e minimi possono annidarsi solamente in quei punti.
Riguardo il fattore “omog” l'unica accortezza sarà, nel caso di vuoti della sezione, di renderne positivo il valore, affinchè non si invertano tutti i segni delle tensioni nei vertici di un poligono vuoto.

Faccio infine notare che l'algoritmo che è uscito fuori, esula assolutamente dalla necessità di definire o di ricavare una posizione dell'asse neutro della sezione (asse che divide la parte tesa della sezione dalla parte compressa) per risolvere le equazioni di equilibrio. L'asse neutro può tranquillamente essere ricavato dal “campo” di tensioni che esce fuori dal calcolo, ma esso non serve affatto in sede di determinazione delle tensioni stesse.
Questo è un concetto importante quando andremo a trattare il caso delle sezioni che si parzializzano a trazione. Il che sarà il prossimo passo.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 15 April , 2011, 20:41:55 PM
Ragionamento impeccabile ma forse un po' troppo sofisticato (perdona la mia critica). Io il problema lo ho risolto in modo un po' differente, ovvero calcolando gli sforzi in ciascun vertice di cls (o barra d'armatura) con le solite N/A+Mx/Wx+My/Wy (considerando le proprietà omogeneizzate) per poi generare una procedura ciclica iterativa nel caso di sezione parzializzata (calcolando ad ogni passo di carico le coordinate della sezione reagente). Ovviamente serve un test d'arresto (numero massimo di iterazioni raggiunto) ed uno di convergenza (tolleranza sulle sollecitazioni integrate).

Ciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 15 April , 2011, 21:45:50 PM
Ragionamento impeccabile ma forse un po' troppo sofisticato (perdona la mia critica). Io il problema lo ho risolto in modo un po' differente, ovvero calcolando gli sforzi in ciascun vertice di cls (o barra d'armatura) con le solite N/A+Mx/Wx+My/Wy (considerando le proprietà omogeneizzate) per poi generare una procedura ciclica iterativa nel caso di sezione parzializzata (calcolando ad ogni passo di carico le coordinate della sezione reagente). Ovviamente serve un test d'arresto (numero massimo di iterazioni raggiunto) ed uno di convergenza (tolleranza sulle sollecitazioni integrate).

Ciao.

penso che fino a questo punto non ci sia differenza sostanziale tra come hai proceduto tu e come procede Zax salvo la maggiore eleganza del metodo con le matrici. Infatti sia tu che lui dovete ogni volta ricalcolare le caratteristiche geometriche della sezione, caratteristiche che Zax inserisce in una matrice e che tu utilizzi direttamente per determinare le tensioni nei vertici.
Vediamo come procede nella determinazione dei vertici della sezione reagente e poi come hai proceduto tu.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 15 April , 2011, 22:15:00 PM
penso che fino a questo punto non ci sia differenza sostanziale tra come hai proceduto tu e come procede Zax salvo la maggiore eleganza del metodo con le matrici. Infatti sia tu che lui dovete ogni volta ricalcolare le caratteristiche geometriche della sezione, caratteristiche che Zax inserisce in una matrice e che tu utilizzi direttamente per determinare le tensioni nei vertici.
Vediamo come procede nella determinazione dei vertici della sezione reagente e poi come hai proceduto tu.

Sono d'accordo sull'eleganza del modo, peraltro non avevo mai visto né sentito parlare di "matrice di rigidezza della sezione".

Ciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 15 April , 2011, 22:19:43 PM
...
Vediamo come procede nella determinazione dei vertici della sezione reagente e poi come hai proceduto tu.

Bah, è una cosa abbastanza semplice, la procedura di convergenza invece è più difficile (peraltro nel mio codice ho avuto anche problemi di stabilità numerica in alcuni casi): attendiamo Zax, non vorrei togliergli il piacere.

Riciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 16 April , 2011, 12:24:52 PM
Parte 6

Le sezioni che si parzializzano
Adesso dovrei fare come Jucas Casella ed esordire dicendo: “al mio 3 …. dimenticatevi dell'asse neutro!”.
Se aprite i testi su cui avete studiato (io ad esempio il Giangreco) vi accorgerete della “fatica” con cui è possibile arrivare alle tensioni in sezioni, anche di semplice geometria, ma sollecitate a presso-flessione deviata. Costruzioni grafiche, artifici vari, e soprattutto l'onnipresente “asse neutro” che continuamente rompe le balle.

Ovviamente vi chiederete come fare a meno dell'asse neutro, quella retta che separa la zona tesa dalla compressa, proprio in una sezione che si parzializza. Specifico quindi meglio: l'asse neutro sarà un risultato, non sarà l'input di partenza da cui far scaturire tutto.
Vedrete che questo semplice “ribaltamento” di pensiero semplificherà parecchio le cose.
Poiché il vero input come abbiamo già visto nella parte precedente, con il metodo della “matrice di rigidezza della sezione” rimane sempre una tripletta deformativa, ossia la formula principe rimane:

deform(x,y)=u+φx*y+φy*x

Questa con le precisazioni di cui alla parte 5, circa il valore di E da mettere da parte, coincide con il “campo” di tensioni agente sull'intera superficie della sezione. Sostituendo ad xv ed yv le coordinate di un qualsiasi vertice di un poligono della sezione (coordinate rispetto al baricentro della sezione omogenea), restituisce la tensione nel vertice stesso.

Allora, diciamo subito che il metodo visto nella parte 5 è perfettamente utilizzabile anche per le sezioni che si parzializzano. Basterà sostituire ai coefficienti della “matrice di rigidezza” le caratteristiche statiche della sola parte reagente di sezione, piuttosto che le caratteristiche della sezione intera come abbia fatto finora, perchè il tutto continui a funzionare liscio come l'olio.
Bello direte voi. Epperò con un ma. Ovvero:

Ma se a priori non si sa come la sezione si parzializza, come si fa a calcolare le caratteristiche geometriche corrette? E' il gatto che si morde la coda, no?

Ancora una volta è più semplice di quanto si creda. Vi spiego anzitutto il criterio generale. I “mattoni” particolari, certamente non secondari, li tengo per ultimo, perchè ritengo che prima bisogna sapere cosa fare, poi arriverà il come.
Bisogna partire da una tripletta di valori per (u,φx,φy) di primo tentativo, e poi procedere per iterazioni successive. Qualcuno (non so chi) ha dimostrato che basta partire da una tripletta (1,0,0) perchè il problema sia sempre convergente (è vero!). Faccio notare che imporre u=1 e rotazioni nulle, significa di fatto non avere trazione (inizialmente) nella sezione e che quindi le varie caratteristiche geometriche della sezione “parzializzata” sono proprio quelle della sezione intera.

Lo schema di procedimento segue quindi questa sequenza:

1) Con la tripletta di primo tentativo (1,0,0) si determinano i coefficienti della matrice di rigidezza (quelli della sezione intera, quindi);
2) Con il termine noto dato dalle sollecitazioni si risolve il sistema lineare a tre incognite e tre equazioni, trovando una differente tripletta di valori per (u,φx,φy);
3) Con questi tre valori deformativi si è in grado di verificare quali vertici della sezione “intera” sono in trazione e quali in compressione;
4) Si definisce una nuova geometria per la sezione che comprende la sola parte compressa (le armature sono sempre presenti);
5) Si determinano nuovamente i coefficienti della matrice di rigidezza con la nuova geometria e si riparte con il passo 2.

In questo modo, a poco a poco, l'algoritmo proposto “aggiusta” la sezione. Per ogni tripletta deformativa ricavata la sezione modifica la sua forma, fino a quando la differenza tra la tripletta della iterazione n-1 e la iterazione n non diventa più piccola di un fattore di tolleranza imposto (oppure quando la differenza tra le aree della sezione reagente tra l'iterazione n-1 ed n non è inferiore ad un valore imposto).
Io proporrò che la differenza in valore assoluto tra “norma” della tripletta n e tra la “norma” della tripletta n-1 sia inferiore a 0.001.
Per norma ovviamente intendo radq(u²+φx²+φy²).

Non immaginatevi chissà quante iterazioni prima di giungere ad un risultato stabile. Con 6-7 iterazioni normalmente si arriva al risultato definitivo. Al massimo con 10. Da un punto di vista computazionale il vostro elaboratore perderà più tempo a ricalcolare ogni volta la matrice dei coefficienti che a risolvere il sistema.

Un ultimo commento prima di andare avanti. L'algoritmo organizzato in questa maniera non si ferma davanti a nulla. Immaginate ad esempio che le sollecitazioni siano tali che la sezione non si parzializza (risultante all'interno del nocciolo centrale d'inerzia). Problemi? No, una semplice iterazione inutile in più, ma il problema è risolto ugualmente. Infatti: matrice dei coefficienti riempita con le caratteristiche statiche della sezione intera. Risolto il sistema e quindi ricavata la tripletta deformativa, indaghiamo sulle parti in trazione: non ce ne sono, pertanto la matrice dei coefficienti viene riempita nuovamente con le caratteristiche statiche della sezione intera. Risolto il sistema troviamo, e per forza, la stessa tripletta di prima. Fine del ciclo.
Insomma un vero algoritmo “Casanova” che accontenta tutte le sezioni, le belle e le brutte, che si parzializzino o che non lo facciano.

Torniamo al nocciolo del problema. Alla fine il vero “problema” diventa riuscire a ricavare ad ogni iterazione i nuovi poligoni che rappresentano la sola parte compressa della sezione.
Guardiamo la seguente figura:

(http://s3.postimage.org/ea3587d0/Sezione_generica6.jpg) (http://postimage.org/image/ea3587d0/)

Non guardate la linea rossa, ancora Jucas non vi ha schioccato le dita contro il viso. Quello che conta sono i vari casi possibili che vedete a destra.
Immaginiamo che siamo al primo step, e che risolvendo il sistema con la matrice dei coefficienti “piena“ delle caratteristiche statiche della sezione intera, si sia addivenuti ad una tripletta data genericamente da (u, φx, φy). Con queste deformazioni (che poi sono tensioni) alcune parti della sezione verranno sollecitate a trazione, altre a compressione.
Analizziamo adesso quindi cosa succede su ogni lato dei nostri poligoni.
Il caso 1 riporta il lato 1-6 che risulta essere sempre teso, pertanto esso non potrà far parte del nostro poligono “reagente”. Semplicemente esso si scarta. Quella parte di sezione non interessa;
Il caso 2, al contrario rappresenta il lato 2-3, che risulta essere sempre compresso. Questo lato, con i relativi vertici, farà parte del poligono “reagente”;
Il caso 3, infine è proprio quello di maggiore interesse. E' il lato 1-2 (ma il lato 3-4 ha la stessa situazione) che presenta il vertice 1 con tensione di trazione, il vertice 2 con tensione di compressione. E' ovvio che lì in mezzo, tra il vertice 1 e 2 si “anniderà” un punto di tensione 0.0 (ricordo, anche se non sarebbe necessario, che la tensione varia linearmente da -σ1 a σ2 lungo il lato 1-2 per le ipotesi di partenza circa la deformazione piana della sezione e per il rapporto di linearità tra tensione e deformazione). E' proprio quel punto di tensione nulla che farà da confine per il nuovo poligono che deve rappresentate la sola parte compressa della sezione. Esso quindi sarà un “nuovo” vertice del poligono. Nella figura ho rappresentato con 1*, 2*, 3*, 4* il nuovo poligono “compresso” di cui calcolare le caratteristiche statiche per la successiva iterazione di calcolo.
Le coordinate del nuovo vertice 1*, con considerazioni semplici di rapporti tra triangoli (vedi figura), e considerando i valori delle tensioni nel loro valore assoluto (senza segno), sono esprimibili con le formuline:

x1*=x1+σ1*(x2-x1)/(σ1+σ2)
y1*=y1+σ1*(y2-y1)/(σ1+σ2)

Se poi siamo affezionati ai segni:

x1*=x1-σ1*(x2-x1)/(σ2-σ1)
y1*=y1-σ1*(y2-y1)/(σ2-σ1)

E faccio notare come questa formula funziona anche se σ1 è positivo e σ2 è negativo (ovvero 1 è vertice compresso e 2 vertice teso), poiché il numeratore (σ1) cambia segno, ma anche il denominatore (σ2-σ1).
Adesso qualcuno potrebbe obiettare che nello spezzare la sezione reale in “porzioni” potrebbero accadere cose strane. Prendiamo ad esempio questa figura:

(http://s3.postimage.org/e9kybdxg/Sezione_generica7.jpg) (http://postimage.org/image/e9kybdxg/)

Se la parte compressa fosse quella inferiore, il singolo poligono che rappresenta la sezione dovrebbe potersi scomporre nei due “cornini” rappresentati in alto a destra nella stessa figura. Oppure potrebbe scomporsi anche in più di 2 cornini. Scombinando un po' le carte in tavola.
Ma tutto ciò invece non è un problema se il poligono compresso viene rappresentato come nel contorno in rosso. Si tratta sempre di un solo poligono, in cui il lato 3*-4* “giace” sul lato 6*-1*. Per come sono organizzati gli algoritmi di calcolo delle caratteristiche statiche dare in pasto il doppio poligono (sopra) o il poligono “quasi intrecciato” (sotto) non fa alcuna differenza. I numeri rimarrebbero gli stessi.
E proprio per questo che nella prossima parte, in cui proporrò un po' di codice, di queste situazioni potrò bellamente infischiarmene.

Bene, è il momento dello schiocco di dita. Visto come l'asse neutro lo abbiamo disegnato solamente alla fine semplicemente valutando le sue intersezioni con i poligoni delle sezioni? Siamo stati costretti a ricorrere ad esso? Abbiamo dovuto definirlo analiticamente come retta y=mx+q, con tutte le questioni di geometria analitica che ne sarebbero sorte?
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 16 April , 2011, 12:41:00 PM

Guardiamo la seguente figura:

(http://s3.postimage.org/ea3587d0/Sezione_generica6.jpg) (http://postimage.org/image/ea3587d0/)


Questa figura è stata fulminante
Grazie Zax.

Adesso si tratta solo di organizzare una nuova matrice di coordinate dei vertici in altra parte di memoria, matrice che varierà ad ogni ciclo e sulla quale opererai per la determinazione della matrice di rigidezza della sezione.

Di nuovo grazie.


P.S.: Tuttavia mi resta ancora un dubbio.
considera il ciclo iesimo, ciclo in cui hai considerato una nuova sezione in cui mancano alcuni vertici della sezione originaria, dai risultati di questo ciclo sorge la necessita di "riconsiderare" un vertice che prima c'era e che adesso non 'è piu nella matrice delle coordinate dei vertici.
Ritengo che nel caso in cui ricorra questa eventualità, sia necessario "riesumare" due vertici. Come procedi?

ok ok, mi rispondo da solo. Continui a calcolare le tensioni sui vertici della sezione originaria (oltre ai vertici aggiunti nei vari cicli) e per aggiungere o togliere vertici ti riferisci sempre ai vertici originari.

[admin]afazio, se vuoi aumentare il Karma di Zax,ti ricordo che puoi cliccare sul tasto ringrazia.[/admin]
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 16 April , 2011, 13:15:02 PM
Si afazio ti sei risposto da solo. Parto sempre ad ogni ciclo dalla sezione di partenza, pertanto quanto da te paventato non accade. Ma ciò che fino ad adesso mi meraviglia è che a quanto pare nessuno conoscesse il metodo. Possibile?
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 16 April , 2011, 13:40:16 PM
Si afazio ti sei risposto da solo. Parto sempre ad ogni ciclo dalla sezione di partenza, pertanto quanto da te paventato non accade. Ma ciò che fino ad adesso mi meraviglia è che a quanto pare nessuno conoscesse il metodo. Possibile?

Personalmente, pur avendo applicato metodi similari che prevedono la riduzione di qualcosa a seguito intersezione, non ho mai pensato ad applicarlo nella risoluzione di sezioni pressoinflesse.
Ma non escludo che gran parte dei programmi specifici lo facciano. Spesso basta una piccola scintilla per avere l'illuminazione dell'acqua calda. Purtroppo non l'ho mai avuta e mi sono fatto le sezioni con acqua tiepida.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: SpinoWeb on 16 April , 2011, 15:06:27 PM
Si afazio ti sei risposto da solo. Parto sempre ad ogni ciclo dalla sezione di partenza, pertanto quanto da te paventato non accade. Ma ciò che fino ad adesso mi meraviglia è che a quanto pare nessuno conoscesse il metodo. Possibile?
La metodologia della "matrice della sezione" è in realtà nota (per esempio puoi dare un'occhiata qui: http://dx.doi.org/10.1061/(ASCE)0733-9445(1985)111:12(2659) (http://dx.doi.org/10.1061/(ASCE)0733-9445(1985)111:12(2659)) ). Ad ogni modo tutti i "trucchetti" che hai postato ti assicuro che nessuno li riporta nei vari articoli, quindi ... grazie ancora!
Io ho sempre implementato il "metodo delle strisce" determinando l'asse neutro, ecc.. perchè ho sempre cercato soluzioni più leggere da un punto di vista computazionale, ma non è detto che quella che proponi tu non possa esserlo.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 16 April , 2011, 20:59:33 PM
Ma ciò che fino ad adesso mi meraviglia è che a quanto pare nessuno conoscesse il metodo. Possibile?

Bah, io lo ho implementato qualche anno fa in Doro con le verifiche col metodo N. Non formalmente scritto nel modo "elegante" delle matrici ma la procedura è identica e confermo l'esattezza della stessa. Bypassando la scrittura matriciale di fatto l'algoritmo è ancora più efficiente (meno operazioni e nessun sistema da risolvere).
Un consiglio: quando interpoli sul lato per il calcolo delle coordinate del punto con sforzo nullo prevedi la possibilità di mettere in conto la resistenza a trazione del cls a volte è interessante. Un altro aspetto interessante di questa procedura riguarda le sezioni precompresse (ci sono un paio di cose da aggiungere in quel caso) e quelle a cavi non aderenti (semplicemente settando il coefficiente di omogeneizzazione a 0).
Se ti serve qualcosa fammi un fischio.

Bravo Jucas, c.v.d.

Appena ho un attimo metto nero su bianco i miei dubbi (formali) su questa procedura con le nuove norme agli SL.

Ciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Betoniera on 17 April , 2011, 11:28:53 AM
PROPOSTA DI UN METODO PER CALCOLARE LE TENSIONI DI UNA SEZIONE IN PRESSOFLESSIONE DEVIATA UTILIZZANDO LE FORMULE DELLA PRESSOFLESSIONE RETTA.

Innanzi tutto complimeti a Zax2010 per la programmazione di livello elevato che stà conducendo.
Ma attenzione a non fare l'errore di fare progetti troppo faraonici che poi non si concludono perchè
richiedono un dispendio di tempo ed energia che una singola persona non riesce a sostenere.
Mi associo, su questo punto a Ferrari Alberto e alle sue perplessità.
Mi associo anche ad Afazio che dice "... a volte basta una scintilla per scoprire l'acqua calda ..."

Invio queste considerazioni perchè potrebbe essere la scintilla che risolve il problema senza eccessiva fatica.
Per ora faccio riferimento a verifiche allo SLU per coerenza con la figura, ma lo stesso ragionamento vale per le tensioni ammissibili, che anzi sono più facili da gestire.

Spiego il metodo che propongo.
Tempo fa avevo fatto un programma di verifica di una sezione generica allo SLU.
La sezione e le armature sono individuate per punti (leggibili anche tramite disegno)
La verifica viene effettuata in pressoflessione retta.
Questo è il risultato.

(http://img683.imageshack.us/img683/8279/sezionegenerica.jpg)

Il programma funzione nel seguente modo:
- Si stabilisce la posizione di un asse neutro tramite una retta parallela all'asse X che interseca la sezione.
- Si individuano la sola sezione compressa tramite il taglio della sezione originaria in corrispondenza dell'asse neutro
- si calcolano le caratteristiche geometriche della sezione parzializzata, deformazioni, tensioni e quindi azione assiale e momento resistente. Si ottiene un punto del dominio.
- Si fa scorrere l'asse neutro lungo tutta la sezione ottenendo l'intero dominio.
- l'asse neutro in SLU è quello che corrisponde a Nu = Nd sollecitante.
Nel caso di Tensioni ammissibili non è necessario costruire il dominio, si calcola l'asse neutro per iterazione con la formula della pressoflessione di 3° grado.
- quindi il problema è ottenere matematicamente la nuva sezione tagliata per calcolare le caratteristiche geometriche della sezione parzializzata. Ma questa cosa l'ho già fatta ed è più semplice di quanto appare a prima vista. Da notare che la sezione tagliata gestisce anche le cavità.
- allo stesso modo con cui si calcola il momento delle tensioni secondo X (MsezX), si può anche calcolare il Momento delle tensioni della sezione secondo Y (MsezY).

Ora attenzione:
1) Il fatto che la sezione verifichi lo Stato Limite Ultimo anzichè le Tensioni è inifluente. Basta combiare la legge costituita o applicare le formule della pressoflessione retta (paraltro più semplici)
2) Nulla mi vieta, anzichè inclinare l'asse neutro, girare l'intera sezione. Questo mi permette di riverifcare la sezione con le stesse formule della pressoflessione retta come se avessi girato l'asse neutro però, in questo modo ho applicato le stesse formule della pressoflessione retta.

Allora la verifica potrebbe essere molto più facilmente condotta in questo modo:
1) introduzione della sezione e dei ferri per punti la sezione sarà soggetta ad N, Mx e My
2) calcolo dell'asse neutro in pressoflessione retta fino ad equilibrare My. Si deve anche calcolare lo stato di deformazione della sezione. Si osserva che:
- Il Momento dello stato tensionale della sezione MsezX (rispetto al centro sezione) dovrà essere per forza uguale al momento sollecitante Mx (altrimenti l'asse neutro sarebbe sbagliato)
- Il momento dello stato tensionale della sezione MsezY, in genere sarà diverso dal momento sollecitante My.
3) a questo punto si deve fare ruotare la sezione fino a quando si trova MSezY = My. I momenti sollecitanti devono essere corretti con la nuova rotazione.

Quindi il problema si riconduce alla semplice rotazione della sezione (molto più facile da gestire) e a un problema di convergenza della soluzione. Si potrebbe calcolare la differenza tra MsezY e My e si applica il metodo delle bisezioni.

Non voglio distrarre Zax2010 dal sua opera, però se dovesse credere più semplice a facile il metodo che ho illustrato potrei estrarre dal mio programma le parti di codice che interessano.
Forse ho scoperto la scintilla per ottenere l'acqua calda.

Ciao a tutti





Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 17 April , 2011, 15:09:27 PM
A mio avviso la procedura di Zax è più semplice di quella proposta da Betoniera ma ha il limite dei coefficienti di omogeneizzazione (tipici del metodo delle tensioni ammissibili). E' altrettanto vero che non ho mai sentito dire da nessun prof. universitario che le verifiche in esercizio (SLE) si effettuano con metodi di calcolo diversi dal metodo delle tensioni ammissibili (con i coeff. di omogeneizzazione appunto).
Ora la domanda potrebbe essere questa (e qui illustro brevemente i miei dubbi su questa procedura con le nuove norme): è possibile note le sollecitazioni SLE N, Mx, My implementare una procedura alla "Betoniera" (consentimi) per verificare la sezione (calcolo di sforzi e/o deformazioni)? Lo stesso Betoniera accenna alla risposta quando scrive "basta combiare la legge costituTIVa". Ma non è così semplice, ci sono un po' di problemi: la viscosità per esempio, la tangente all'origine (o al 40% della resistenza se si preferisce) del tipico legame costitutivo parabola-rettangolo per il cls (provare a calcolarla ed a confrontarla col modulo elastico del cls da norma, Ecm). Credo che il metodo dei coefficienti di omogeneizzazione resterà ancora per un bel po', almeno agli SLE.

Ciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 17 April , 2011, 15:28:43 PM
Un pò di risposte.

@SpinoWeb
La metodologia della "matrice della sezione" è in realtà nota (per esempio puoi dare un'occhiata qui: http://dx.doi.org/10.1061/(ASCE)0733-9445(1985)111:12(2659) (http://dx.doi.org/10.1061/(ASCE)0733-9445(1985)111:12(2659)) ).

Che non sia io lo "scopritore dell'acqua calda" ne avevo piena consapevolezza, e non mi voglio affatto arrogare meriti che non ho. Ribadisco invece, come detto nella premessa di questo topic, di non aver mai visto nei libri da me consultati una procedura "numerica" come quella da me proposta, oppure implementata da Ferrari nel suo DORO. Magari perchè i libri da me consultati sono datati, e le procedure grafiche un tempo venivano privilegiate rispetto a procedure più "pesanti" da un punto di vista computazionale.

Rispondo volentieri a Betoniera, su due cose del suo intervento.

Come non quotarti circa la "fatica" per giungere a dei risultati accettabili in ambito programmazione. Ho accennato ad inizio topic che pur provando a programmare, fino a 10 anni fa, alla fine ho smesso, per varie ragioni. Non ultima la fatica, appunto.
Io lo so che sto giocando sporco con gli utenti di questo forum. Io sto dando qui parti di codice, alla fine poche righe come si vedrà, che risolvono un problema. Ok, so che si tratta di una risoluzione generale, senza se e senza ma, del "vecchio" problema della verifica a presso-flessione deviata di una sezione generica in c.a.
Però immagino ci possa essere qualcuno che prenda il motore per costruirci attorno la macchina.
Gioco sporco, perchè so che in un programma la parte "algoritmica" è la "meno spesa" come si dice dalla mie parti. Il controllo dell'input, la gestione dell'interfaccia, la necessità di far capire cosa deve fare una terza persona, ecc. sono quelle le parti dove le nottate non bastano.

Circa invece il suggerimento per il prossimo sviluppo di questo topic, ovvero la verifica SLU delle sezioni, esso è assai ben accetto proprio perchè, come te, sono anch'io convinto di procedere con una presso flessione retta (o meglio con asse neutro orizzontale) e poi, piuttosto che far ruotare l'asse neutro, procede con "inganno" facendo ruotare la sezione.
A differenza tua, però (ma potrei anche non aver capito bene il tuo metodo), io voglio ricavare la fetta di salame. Ovvero dominio Mx-My per dato N. Pertanto le sollecitazioni flettenti esterne (che tu utilizzi già per il posizionamento dell'asse neutro) alla fine serviranno solamente a verificare di stare dentro o fuori il dominio.
In ogni caso avremo modo di confrontarci. Voglio sempre arrivare alle cose per "mattoni" successivi. Specificando bene come ogni "mattone" deve lavorare da solo ed insieme agli altri.

Nel senso che lo spirito del topic non è solamente didattico puro. Vorrei che si capisse (proprio perchè sulla mia pelle per prima ho vissuto il fenomeno) che le cose che sembrano semplici o semplicissime, nel momento in cui si cerca di implementarle comportano sempre dei ragionamenti, delle difficoltà, delle risorse, di cui inizialmente si ritiene non avere necessità o bisogno.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 17 April , 2011, 15:38:06 PM
Nel lontano 1980 il compianto prof. Michele Capurso scrisse nel basic del Commodore 64 (appena 64kb di memoria utente) una serie di magici piccoli programmi (da 8Kb max cadauno !!!) tra i quali quello relativo alla pressoflessione deviata alle T.A.
Il codice sorgente era liberamente consultabile ed il metodo seguito era proprio quello della matrice di rigidezza della sezione (indicato da Zax) con risoluzione del sistema di terzo grado ad ogni iterazione. Resta il metodo più conveniente da utilizzare per le verifiche SLE in esercizio

Per quanto riguarda la risoluzione dello stesso problema allo SLU il suddetto algoritmo validissimo in elasticità lineare (e cls parzializzabile) non è utilizzabile utilmente a causa dell'interesse ad ottenere come soluzione i soli punti del dominio ultimo:  il numero di iterazioni col metodo precedente cresce enormemente in vicinanza della superficie del dominio rendendo inefficiente il procedimento che resterebbe cmq valido solo con leggi dei materiali monotone non decrescenti.
La soluzione in questo caso è molto più difficile tanto è vero che le stesse normative NTC ed Eurocodici concedono l'uso di metodi semplificati per la risoluzione pratica del problema.
Per una soluzione rigorosa del problema diventa importante sia l'impostazione del problema che la strategia iterativa. L'impostazione descritta da Betoniera secondo me risulta molto valida (è la stessa che ho io stesso seguito) in quanto parte dal calcolo in pressoflessione retta per poi ruotare l'asse neutro fino a convergenza. Ma Betoniera parla (se ho ben capito) di deformazione della sezione in equilibrio con i momenti assegnati Mx,My mentre a noi interessa la deformazione della sezione corrispontente ai momenti Mux Muy ultimi  tali che il rapporto Muy/Mux = My/Mx 
       
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: SpinoWeb on 17 April , 2011, 16:43:40 PM
@SpinoWeb
Che non sia io lo "scopritore dell'acqua calda" ne avevo piena consapevolezza, e non mi voglio affatto arrogare meriti che non ho. Ribadisco invece, come detto nella premessa di questo topic, di non aver mai visto nei libri da me consultati una procedura "numerica" come quella da me proposta, oppure implementata da Ferrari nel suo DORO. Magari perchè i libri da me consultati sono datati, e le procedure grafiche un tempo venivano privilegiate rispetto a procedure più "pesanti" da un punto di vista computazionale.
Il mio intervento non era per sottolineare che il metodo fosse noto, ma solo per rispondere alla tua domanda se qualcuno ne avesse mai sentito parlare.
Inoltre, come tu stesso riporti, è assai difficile che qualcuno diffonda le procedure numeriche che usa. Tutti scrivono le equazioni base dei metodi che propongono, ma poi questi vanno implementati e nessuno spiega come si risolvono importanti problemi numerici. Tu lo stai facendo ed infatti di questo ti ringrazio ancora perchè rende questo topic ancor più interessante.

Io personalmente ho usato un metodo delle strisce ruotando la sezione (come ha fatto anche Betoniera) ed è abbastanza veloce anche nel ricavare la "fetta di salame". Le difficoltà invece sorgono quando modifico il legame costitutivo e provo a mettere una legge di tipo softening: lì i risultati non sono ancora buoni.

Nel lontano 1980 il compianto prof. Michele Capurso scrisse nel basic del Commodore 64 (appena 64kb di memoria utente) una serie di magici piccoli programmi (da 8Kb max cadauno !!!) tra i quali quello relativo alla pressoflessione deviata alle T.A.
Il codice sorgente era liberamente consultabile ed il metodo seguito era proprio quello della matrice di rigidezza della sezione (indicato da Zax) con risoluzione del sistema di terzo grado ad ogni iterazione. Resta il metodo più conveniente da utilizzare per le verifiche SLE in esercizio
Recupare i programmini di Capurso sarebbe una gran cosa. E' uno che ci ha studiato tanto su questi argomenti
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 17 April , 2011, 19:02:12 PM
Quote from: zax2010

...
A differenza tua, però (ma potrei anche non aver capito bene il tuo metodo), io voglio ricavare la fetta di salame. Ovvero dominio Mx-My per dato N.
...

E' la strada giusta per le verifiche SLU, sono pienamente d'accordo. La "complessità" del calcolo è simile a quella che hai già affrontato.

Ciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: pasquale on 17 April , 2011, 20:16:51 PM
se può servire, c'è quest'articolo del prof. Rosati (UniNA) ed altri, ( che ha causato anche qualche polemica per il fraintendimento del titolo "Così si verificano le sezioni in c.a. pressoinflesse") a pag. 18
www.ordineingegnerinapoli.it/notiziario/notiz202.pdf (http://www.ordineingegnerinapoli.it/notiziario/notiz202.pdf)
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 18 April , 2011, 06:43:20 AM
se può servire, c'è quest'articolo del prof. Rosati (UniNA) ed altri, ( che ha causato anche qualche polemica per il fraintendimento del titolo "Così si verificano le sezioni in c.a. pressoinflesse") a pag. 18
www.ordineingegnerinapoli.it/notiziario/notiz202.pdf (http://www.ordineingegnerinapoli.it/notiziario/notiz202.pdf)


I signori hanno scomodato l'analisi tensoriale pur di non far capire "una mazza" del procedimento numerico seguito.
Quando bastava invece un po' di geometria analitica...
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 18 April , 2011, 09:52:38 AM
I signori hanno scomodato l'analisi tensoriale pur di non far capire "una mazza" del procedimento numerico seguito.
Quando bastava invece un po' di geometria analitica...

Stessa cosa che ho pensato io. Della serie "come rendere complicato qualcosa che altrimenti sarebbe chiaro e comprensibile".
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: SpinoWeb on 18 April , 2011, 16:45:43 PM
se può servire, c'è quest'articolo del prof. Rosati (UniNA) ed altri, ( che ha causato anche qualche polemica per il fraintendimento del titolo "Così si verificano le sezioni in c.a. pressoinflesse") a pag. 18
www.ordineingegnerinapoli.it/notiziario/notiz202.pdf (http://www.ordineingegnerinapoli.it/notiziario/notiz202.pdf)
:)
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 18 April , 2011, 18:38:39 PM
Parte 7

Il codice SLE
In pratica per quanto riguarda la verifica SLE abbiamo già finito. Il problema è stato sviscerato nella sua parte teorica, rimane solamente da presentare un listato.
Ho provato a scrivere una funzione quanto più indipendente dal resto del codice che ci sta attorno. A parte le strutture dati che definiscono la geometria della sezione, le uniche variabili globali sono xg e yg, ovvero le coordinate x,y del baricentro della sezione omogenea.
E poiché le combinazioni cui una sezione viene sottoposta sono ormai numerose, la funzione accetta in ingresso una tripletta di sollecitazioni e restituisce la corrispondente tripletta deformativa. Sarà poi la funzione chiamante (che magari avrà un ciclo di chiamata per ognuna delle combinazioni) a decidere cosa fare di questo output (calcolare le tensioni, stampare una porzione di tabulato, disegnare la parte compressa, determinare il massimo valore di compressione calcestruzzo o acciaio tra più combinazioni, ecc.)

Nel solito header file bisognerà definire altre 2 strutture dati (lo so, ci sono affezionato e forse esagero)

Code: [Select]
struct deform
{
 float u[3];
};

struct sollecitazioni_esterne
{
 float n;    /* Sforzo normale (positivo di compressione) */
 float mx;   /* Momento flettente asse x (positivo se comprime fibre +y) */
 float my;   /* Momento flettente asse y (positivo se comprime fibre +x) */
 int tipo;   /* 0=SleQp / 1=SleFr / 2=SleRa / 3=Slu */
};

Ed il prototipo della funzione:

Code: [Select]
struct deform verifica_SLE(struct sollecitazioni_esterne);
Infine, ecco la funzione. Intanto leggetela, alla fine il commento.

Code: [Select]
struct deform verifica_SLE(struct sollecitazioni_esterne soll)
{
 int register k,np;
 float norma0,norma1=1.0;
 float s1,s2;
 struct deform def;
 struct poligono_sezione polic[4];
 struct geometria_sezione geo;

  /* Se tutte le sollecitazioni sono nulle ritorna la struttura def fatta da 0.0 */
 if (soll.n==0.0 && soll.mx==0.0 && soll.my==0.0) { def.u[0]=0.0; def.u[1]=0.0; def.u[2]=0.0; return(def); }

 def.u[0]=1.0; def.u[1]=0.0; def.u[2]=0.0;
 do
   {
    float parz;

    norma0=norma1;

    /* Determina la geometria della sezione “reagente” */
    for (np=0;np<=4;np++)
        {
         /* Se il poligono reagisce anche a compressione esso rimane sempre interamente reagente */
         /* quindi "poli" viene copiato così come è in "polic" e la procedura passa al poligono successivo */
         if (poli[np].traz==1) { polic[np]=poli[np]; continue; }

         /* Prima determina i veri punti che definiscono il contorno "reagente" */
         /* Calcola la tensione nel punto precedente quello di interesse */
         s1=def.u[0]+(poli[np].y[poli[np].numv-1]-yg)*def.u[1]+(poli[np].x[poli[np].numv-1]-xg)*def.u[2];

         polic[np].numv=0; polic[np].omog=poli[np].omog;
         for (k=0;k<=poli[np].numv-1;k++)
             {
              int km1=k-1;

              if (k==0) km1=poli[np].numv-1;

              /* Calcola la tensione nel punto voluto per prendere decisioni */
              s2=def.u[0]+(poli[np].y[k]-yg)*def.u[1]+(poli[np].x[k]-xg)*def.u[2];

              if (s1*s2<=0.0)
                 {
                  polic[np].x[polic[np].numv]=poli[np].x[k]-s2*(poli[np].x[k]-poli[np].x[km1])/(s2-s1);
                  polic[np].y[polic[np].numv]=poli[np].y[k]-s2*(poli[np].y[k]-poli[np].y[km1])/(s2-s1);
                  polic[np].numv++;
                 }

              if (s2>0.0)
                 {
                  polic[np].x[polic[np].numv]=poli[np].x[k];
                  polic[np].y[polic[np].numv]=poli[np].y[k];
                  polic[np].numv++;
                 }

              /* Fa diventare s2 la tensione del punto precedente per il ciclo successivo */
              s1=s2;
             }
        }

    /* Con i nuovi contorni chiama la funzione che determina le caratteristiche geometriche della sezione reagente */
    geo=calcola_caratt_geometriche (polic);

    /* Risolve l'equazione a 3 incognite */
    parz=geo.ix*geo.area-pow(geo.scx,2);
    def.u[2]=((soll.my*geo.area-soll.n*geo.scy)*parz-(soll.mx*geo.area-soll.n*geo.scx)*(geo.ixy*geo.area-geo.scy*geo.scx))/((geo.iy*geo.area-geo.scy*geo.scy)*parz-pow(geo.ixy*geo.area-geo.scy*geo.scx,2));
    def.u[1]=((soll.mx*geo.area-soll.n*geo.scx)-(geo.ixy*geo.area-geo.scx*geo.scy)*def.u[2])/parz;
    def.u[0]=soll.n/geo.area-def.u[1]*geo.scx/geo.area-def.u[2]*geo.scy/geo.area;

    norma1=sqrt(pow(def.u[0],2)+pow(def.u[1],2)+pow(def.u[2],2));
   }
 while (fabs(norma1-norma0)>1e-3);

 return (def);
}

Rispetto a quanto visto nella parte precedente, come si può vedere, mi sono limitato a riportare la formula che individua il punto a tensione 0.0 all'interno di un lato del poligono per definire il nuovo poligono “reagente”, ed inoltre ho aggiunto il caso in cui uno o più dei poligoni invece che parzializzarsi possa reagire anche a trazione (è il valore di traz, tra i vari dati della struttura dati che definisce ogni singolo poligono). E' una cosa comoda quando si vuol calcolare una sezione metallica composta, o altro.

Il tutto è concentrato tra l'istruzione do e l'istruzione while.
In sintesi:
1) Con le deformazioni dell'iterazione precedente si definisce la reale geometria della sezione reagente (quando si entra per la prima volta nel ciclo le deformazioni valgono 1,0,0 come da riga precedente che le inizializza in tal senso).
2) Si chiama la funzione calcola_caratt_geometriche che determina i valori da inserire nella matrice di rigidezza della sezione
3) Si risolve il sistema lineare 3x3 (senza scomodare alcun metodo, Gauss-Siedel, Kholesky, ecc. Ho riportato materialmente le espressioni definitive avendo risolto prima “a mano” il sistema in maniera simbolica, dunque tre sole formuline)
4) Si calcola la norma della nuova soluzione e la si confronta con la norma della precedente soluzione (nell'istruzione while)
5) Se l'esito della condizione è positivo la funzione termina restituendo la struttura deform alla funzione chiamante, altrimenti il ciclo viene ripetuto fino a convergenza.

Faccio notare che nel determinare le “tensioni” per definire la porzione reagente di poligono, non ho affatto adoperato il fattore omog. Non è necessario infatti che le tensioni siano quelle vere; importante è che il rapporto s2/(s2-s1) sia quello corretto (e lo è visto che parliamo dello stesso poligono ed il fattore omog sarebbe comune), insomma una moltiplicazione in meno.

Altra cosa che faccio notare è che potrebbe capitare, in sezioni costituite da più poligoni, che nella parzializzazione della sezione un intero poligono potrebbe essere tutto in trazione e quindi scomparire. Che succede in quel caso?
Nulla. Perchè, se è vero che nessun vertice viene definito nelle sue coordinate x e y, il numero dei vertici del poligono reagente polic[np].numv impostato inizialmente a 0 dalla funzione rimane tale. E la funzione calcola_caratt_geometriche non si offende affatto di un simile evento, infatti con la riga:

Code: [Select]
      for (k=0;k<=polic[np].numv-1;k++)
semplicemente l'intero ciclo non viene svolto in quanto la condizione k<=polic[np].numv-1 è subito vera. Ovvero come se il poligono non esistesse.

Terza cosa che faccio notare è che una volta usciti dalla funzione inesorabilmente si perdono anche le caratteristiche statiche della sezione reagente “faticosamente” trovate dall'algoritmo (in quanto variabili locali valide solamente all'interno della funzione). Se queste fossero di interesse poco male. Si estenderebbe la struttura dati struct deform andando a definire all'interno di essa, oltre alla tripletta deformativa, anche scx, scy, ix, iy, ixy. Con una semplice assegnazione di queste variabili poco prima del return (def), ovvero def.scx=geo.scx; ecc. ci si potrà “portare indietro” anche queste informazioni.

Infine una osservazione: Se considerate che questa funzione, comprese le righe di commento, ha circa 70 righe, e che l'altra funzione realmente necessaria, quella di calcolo delle caratteristiche geometriche, ne ha poco meno di 50, possiamo considerare che è realmente “poca cosa” la sola parte risolutiva di un programma che verifica le sezioni in c.a. agli SLE.

Un'ultima porzione di codice, tanto per gradire. La funzione chiamante sarebbe più o meno così:

Code: [Select]
for (nc=0;nc<=numcomb-1;nc++)
{
 if (soll[nc].tipo<=2) def[nc]=verifica_SLE(soll[nc]);
 
 /* Calcola le tensioni vertice per vertice della sezione */
 for (np=0;np<=4;np++)
     {
      omog=fabs(poli[np].omog);
     
      for (k=0;k<=poli[np].numv-1;k++)
          {
           tens=omog*(def[nc].u[0]+def[nc].u[1]*(poli[np].y[k]-yg)+def[nc].u[2]*(poli[np].x[k]-xg));
           if (tens<0.0 && poli[np].traz==0) scarta il risultato
           else gestisce questo valore per farne ciò che si vuole
          }
     }
 /* Calcola le tensioni armatura per armatura */
 for (k=0;k<=arm.numarm-1;k++)
     {
      tens=arm.omogarm*(def[nc].u[0]+def[nc].u[1]*(arm.y[k]-yg)+def[nc].u[2]*(arm.x[k]-xg));
     ed anche in questo caso si può farne ciò che si vuole
     }
}

Dove numcomb sarebbe il numero di combinazioni cui è sottoposta la sezione. Le scritte dopo il calcolo della tensione (es. scarta il risultato) non fanno parte ovviamente della funzione ma sono state messe lì da me per indicare la possibilità che si vuole.

Ho dimenticato di dire finora, che il codice fin qui presentato dovrebbe essere puro ANSI C e pertanto compilabile da qualsiasi compilatore C, C++.
Vista la presenza di funzioni tipo fabs (valore assoluto di numeri float) e sqrt (radice quadrata) sarà necessario, nel solito header file, inserire il comando:

#include "math.h"

Ovvero includere la libreria matematica standard del C.

E con questo penso di poter chiudere questa prima parte, passando tosto, con le altre prossime parti, alle verifiche SLU.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 20 April , 2011, 17:49:49 PM
Parte 2

Calcolo delle caratteristiche geometriche delle sezioni

momento d'inerzia xy
Non ricordo bene come lo abbia ricavato a suo tempo, ma pigliatelo come atto di fede, nella formulazione già semplificata:
a*(x[i ]/2*(y[i ]^2+d^2/3+d*hy)+a/2*(y[i ]^2/2+d^2/4+2*d*hy/3))


Scusa Zax, ma potresti rivedere la formula di Jxy. Non capisco cosa indichi con hy.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 20 April , 2011, 18:40:00 PM
In questa parte di funzione, quella già pubblicata, il valore di hy è definito correttamente.

Code: [Select]
for (np=0;np<=4;np++)
     {
      for (k=0;k<=polic[np].numv-1;k++)
          {
           if (k==polic[np].numv-1) kp1=0; else kp1=k+1;

           a=polic[np].x[kp1]-polic[np].x[k];
           d=polic[np].y[kp1]-polic[np].y[k];
           hy=polic[np].y[k]-yg;
           hx=polic[np].x[k]-xg;

           geo.area+=polic[np].omog*a*(hy+d/2);
           geo.scx+=polic[np].omog*a/2*(hy*hy+d*d/3+d*hy);
           geo.scy-=polic[np].omog*d/2*(hx*hx+a*a/3+a*hx);
           geo.ix+=polic[np].omog*a/3*(pow(hy,3)+hy*d*d+3*hy*hy*d/2+pow(d,3)/4);
           geo.iy-=polic[np].omog*d/3*(pow(hx,3)+hx*a*a+3*hx*hx*a/2+pow(a,3)/4);
           geo.ixy+=polic[np].omog*a*(hx/2*(hy*hy+d*d/3+d*hy)+a/2*(hy*hy/2+d*d/4+2*d*hy/3));
          }
     }

In pratica nella formula simbolica non c'è differenza tra y[i ] e hy (mio errore, chiedo scusa), ovvero hy è a tutti gli effetti y[i ].
Valutando però ixy rispetto agli assi baricentrici esso (hy) vale y[i ]-yg
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 20 April , 2011, 19:33:38 PM
In questa parte di funzione, quella già pubblicata, il valore di hy è definito correttamente.

Code: [Select]
for (np=0;np<=4;np++)
     {
      for (k=0;k<=polic[np].numv-1;k++)
          {
           if (k==polic[np].numv-1) kp1=0; else kp1=k+1;

           a=polic[np].x[kp1]-polic[np].x[k];
           d=polic[np].y[kp1]-polic[np].y[k];
           hy=polic[np].y[k]-yg;
           hx=polic[np].x[k]-xg;

           geo.area+=polic[np].omog*a*(hy+d/2);
           geo.scx+=polic[np].omog*a/2*(hy*hy+d*d/3+d*hy);
           geo.scy-=polic[np].omog*d/2*(hx*hx+a*a/3+a*hx);
           geo.ix+=polic[np].omog*a/3*(pow(hy,3)+hy*d*d+3*hy*hy*d/2+pow(d,3)/4);
           geo.iy-=polic[np].omog*d/3*(pow(hx,3)+hx*a*a+3*hx*hx*a/2+pow(a,3)/4);
           geo.ixy+=polic[np].omog*a*(hx/2*(hy*hy+d*d/3+d*hy)+a/2*(hy*hy/2+d*d/4+2*d*hy/3));
          }
     }

In pratica nella formula simbolica non c'è differenza tra y[i ] e hy (mio errore, chiedo scusa), ovvero hy è a tutti gli effetti y[i ].
Valutando però ixy rispetto agli assi baricentrici esso (hy) vale y[i ]-yg

Ok
Adesso ti chiedo, ma per lo scopo specifico della verifica a presso-tensoflessione deviata, serve conoscere il momento centrifugo o i momenti di inerzia principali?
Altra cosa che chiedeo: nella sezione che si va via parzializzando nei vari cicli di iterazione le coordinate del baricentro della sezione reagente omogeneizzata non cambiano?

Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 20 April , 2011, 21:38:51 PM
Doppia risposta.
Il momento centrifugo non serve mai. I momenti principali d'inerzia per l'algoritmo proposto sono sostanzialmente inutili. Per un approccio alla "Ferrari" viceversa penso servano.
E' così la sezione reagente omogeneizzata alla fine avrà un baricentro differente dal baricentro della sezione omogeneizzata interamente reagente, e ad ogni ciclo esso si modifica come posizione poichè si modifica la forma della sezione stessa.
Mi fermerei qui, ma mi pare che la domanda ne nasconda un'altra.
Non so se è pertinente, ma ti faccio notare che sia la tripletta deformativa che la tripletta di sollecitazioni è sempre riferita ad un unico punto, il baricentro della sezione omogenea "intera". Inseguire il baricentro della reagente nei suoi spostamenti significherebbe modificare i valori di Mx ed My ad ogni nuova sezione indagata.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 20 April , 2011, 21:46:15 PM
Ok
Adesso ti chiedo, ma per lo scopo specifico della verifica a presso-tensoflessione deviata, serve conoscere il momento centrifugo o i momenti di inerzia principali?
Altra cosa che chiedeo: nella sezione che si va via parzializzando nei vari cicli di iterazione le coordinate del baricentro della sezione reagente omogeneizzata non cambiano?


Ciao Afazio,
   ti rispondo io se vuoi. Ad ogni iterazione cambia la sezione reagente omogeneizzata quindi area, coordinate baricentro, momenti d'inerzia principali, orientamento della terna principale d'inerzia e moduli di resistenza elastica. Pensa alla forma scritta in modo più semplice sigma=N/A+Mx/Wx+My/Wy da calcolare per ogni iterata in ciascun vertice della sezione (di partenza): A, Wx e Wy cambiano ad ogni iterata e sono le proprietà omogeneizzate; anche N, Mx ed My cambiano poichè sono le sollecitazioni riportate al baricentro della sezione reagente omogeneizzata (trasporti la N e ruoti i vettori Mx ed My nella terna principale d'inerzia della sezione reagente omogeneizzata, vado a memoria...zax correggimi se ho sbagliato per le azioni...).

Ciao.

P.S. Rinspondo lo stesso anche se zax mi ha anticipato... Riciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 20 April , 2011, 21:53:41 PM
Doppia risposta.
Il momento centrifugo non serve mai. I momenti principali d'inerzia per l'algoritmo proposto sono sostanzialmente inutili. Per un approccio alla "Ferrari" viceversa penso servano.

Si servono, come pure il Jxy che determina l'orientamento della terna principale della sezione reagente omogeneizzata.

...
Non so se è pertinente, ma ti faccio notare che sia la tripletta deformativa che la tripletta di sollecitazioni è sempre riferita ad un unico punto, il baricentro della sezione omogenea "intera". Inseguire il baricentro della reagente nei suoi spostamenti significherebbe modificare i valori di Mx ed My ad ogni nuova sezione indagata.

Ecco questa è una cosa interessante: in effetti nel mio algoritmo ad ogni iterata riporto i carichi N, Mx ed My nella terna principale della sezione reagente omogeneizzata. Bravo Zax, mi era sfuggita questa differenza.

Ciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 20 April , 2011, 22:54:28 PM
Parte 8

SLU – Si comincia
Annuncio subito che questa volta non ci saranno algoritmi sconosciuti o procedure “magiche”.

Intanto vediamo cosa cerchiamo. La verifica SLU consisterà nel determinare il dominio di rottura nel piano Mx-My dato un determinato Nd agente sulla sezione.
Tale “fetta di salame” verrà ricavata tramite le equazioni di equilibrio, per punti, posizionando l'asse neutro all'interno della sezione in modo che le risultanti di compressione e di trazione dei vari elementi della sezione diano proprio Nd, e facendo via via ruotare l'asse neutro, in modo da ricavare più punti di tale dominio.

Vedrete comunque che tutti gli algoritmi presentati si riferiranno al una inclinazione ben precisa dell'asse neutro, ovvero asse neutro inclinato di 0 gradi rispetto all'asse delle X.
Perchè la “furbata” proposta consiste nel far ruotare la sezione piuttosto che l'asse neutro.
Ovviamente i vari risultati, ricavati per una rotazione ben precisa della sezione, dovranno essere “ruotati al contrario” affinchè si abbiano valori congruenti.

Perchè questa scelta?
E' semplicemente un modo di semplificare le equazioni di geometria analitica che altrimenti dovremmo gestire. Ad esempio per convenzione definiremo la parte compressa della sezione tutta quella che sta al di sopra dell'asse neutro. E quindi un vertice di sezione sarà nella zona compressa se la sua coordinata y è maggiore della coordinata yn dell'asse neutro. Così come sarà facile trovare il vertice compresso più distante dall'asse neutro.
Attenzione nulla che non possa risolversi anche nel caso “storto”, ma certamente con qualche complicazione in più che invece con questa impostazione potremo risparmiarci.

In pratica, una volta posizionato l'asse neutro in una posizione di partenza, procederò tagliando in strisce orizzontali, abbastanza sottili, la parte compressa della sezione. Per ogni striscia dovrò determinare il dN che essa è in grado di esprimere. La sommatoria di tutti questi dN oltre alla ?Na espressa dalle armature compresse mi definisce una N complessiva della parte compressa della sezione. Ricavata la Na delle armature tese, il semplice N-Na mi indica un valore di Nd che la sezione nel suo complesso è in grado di esprimere. Se questo Nd è quello dato, allora la posizione dell'asse neutro è corretta, e posso ricavare, sapendo le posizioni della risultante di N compressa e Na tesa, i momenti Mx ed My di rottura corrispondenti (rispetto al baricentro della sezione omogenea), altrimenti si deve riposizionare l'asse neutro e procedere per iterazioni successive.

Una semplice figura, come questa qui sotto vale più di 100 parole. Le crocette in rosso scuro (posizionate a casaccio, lo ammetto) sarebbero le risultanti degli sforzi di compressione e di trazione.

(http://s1.postimage.org/2exs5ffd0/Sezione_generica8.png) (http://www.postimage.org/)

Quindi è chiaro, dobbiamo concentrarci sul calcolo di risultanti di compressione. Tutto il resto sono iterazioni che per adesso non ci interesseranno.
Vediamo un po' cosa serve intanto, data una posizione ben definita dell'asse neutro, per calcolare la N risultante complessiva tra parte compressa e tesa:

1) Una configurazione deformata di “rottura” della sezione;
2) Larghezza di ogni singola striscia in cui si suddivide la parte compressa della sezione;
3) Legge costitutiva del calcestruzzo per ricavare il dN di ogni striscia;
4) Legge costitutiva dell'acciaio per le armature tese e compresse;

Circa il primo punto la Norma ci viene abbastanza incontro, semplificando il problema (che in ogni caso non era nemmeno così complesso anche prima), se per l'acciaio si utilizza la legge costitutiva “elastica-perfettamente plastica indefinita”, riportata nella figura 4.1.2-(b) del §4.1.2.1.2.3
Poiché utilizzando questo diagramma non si ha alcuna limitazione alla massima deformazione dell'acciaio, questo implica che alla massima deformazione di rottura si arriva sempre lato calcestruzzo, e per quest'ultimo si utilizzerà il classico diagramma parabola rettangolo riportato nella figura 4.1.1-(a) del § 4.1.2.1.2.2 che prevede una deformazione massima a rottura del calcestruzzo compresso pari al 3.5 per mille.
Ovvero, il vertice con la ordinata maggiore (ymax) di tutta la sezione avrà sempre una deformazione pari al 3.5 per mille. Con semplice proporzione tra triangoli si può definire la deformazione insita in ogni singola striscia della parte compressa:

def(y)=0.0035*(y-yn)/(ymax-yn)

dove y è la generica ordinata della fibra di indagine (con y>yn visto che parliamo di parti compresse), e yn la ordinata dell'asse neutro. Anche per le armature vale la stessa espressione, inserendo la ordinata y della barra, con la semplice accortezza che valori positivi di def(Y) indicano compressione nelle barre, valori negativi trazione.
Poiché abbiamo “incapsulato” tra i dati dei poligoni anche il massimo valore di sforzo di compressione (fd) procederò a definire i diagrammi costitutivi dei materiali in maniera adimensionalizzata.

Partiamo con il diagramma parabola-rettangolo del calcestruzzo.
Esso prevede una parte parabolica fino al 2 per mille (0.002) ed una parte orizzontale dal 2 per mille al 3.5 per mille (0.0035). Bene, il nostro diagramma varrà 1 da 0.002 a 0.0035 e sarà una parabola che passa per l'origine, passa per il punto 0.002,1 ed infine avrà tangente orizzontale in quest'ultimo punto.
Visto che l'equazione di una parabola è y=ax²+bx+c
Il passaggio per il punto di coordinate 0,0 implica che c=0, invece le altre due condizioni portano al sistema:

1=a*0.002²+b*0.002
0=2*a*0.002+b

Che risolto da i risultati:

a=-250000
b=1000

Allora una funzione che avendo in ingresso il valore di deformazione della singola striscia restituisca in uscita il valore alfa del diagramma parabola rettangolo che moltiplicato per fd sia proprio la tensione di lavoro desiderata, più o meno è scritta così:

Code: [Select]
float parabola_rett(float); /* Prototipo della funzione */

float parabola_rett(float def)
{
 float alfa;

 if (def>=0.002) alfa=1.0;
 else alfa=-250000*def*def+1000*def;

 return (alfa);
}

Ovviamente ho lasciato all'interno della funzione i valori di 0.002, ecc. In effetti ci si potrebbe “divertire” a rendere ancor più parametrica la funzione dando la possibilità di modificare lo 0.002, così come d'altra parte prevede la norma per cls con classe di resistenza superiore al C50/60 (e a dire il vero in questo caso anche la deformazione ultima del cls, invece del 3.5 per mille diventa altro). Ma per il momento lasciamo le cose “semplici”. In ogni caso la variazione ad un “mattone” non porta affatto a far cadere tutta la costruzione.

La analoga funzione per l'acciaio sarebbe:

Code: [Select]
float elast_plast_indef(float); /* Prototipo della funzione */

float elast_plast_indef(float def)
{
 float alfa;

 if (def>=fyd/Ea) alfa=1.0;
 else alfa=def*Ea/fyd;

 return(alfa);
}

Dove Ea ed fyd sono delle variabili globali, rispettivamente modulo elastico dell'acciaio (tipicamente 2.100.000 daN/cm²) e fyd resistenza caratteristica a trazione/compressione dell'acciaio (tipicamente 3913 daN/cm²).

Insomma se lo stato deformativo è definito, e lo è, lo sono anche le tensioni agenti sul materiale ad ogni fibra.
Diciamo allora che per la parte armatura non ci sono difficoltà di sorta a calcolare lo sforzo normale ultimo che esse generano nella sezione.
Per i poligoni invece a parte la conoscenza dello stato deformativo, serve determinare la larghezza di ogni singola striscia.
E qui bisognerà scomodare un minimo di geometria analitica, vista la geometria generica dei poligoni che si possono incontrare.
Ne parlerò nella prossima parte. Anticipo però questa figura, per far capire quali casi devo essere in grado di gestire.

(http://s1.postimage.org/2ey5dq7b8/Sezione_generica9.jpg) (http://postimage.org/image/2ey5dq7b8/)

Ovviamente lo “spessore” di ogni singola striscia potrà essere un parametro fisso, interno al programma, oppure una variabile che l'Utente potrà modificare a proprio giudizio.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 21 April , 2011, 21:29:26 PM
...
Ovvero, il vertice con la ordinata maggiore (ymax) di tutta la sezione avrà sempre una deformazione pari al 3.5 per mille. Con semplice proporzione tra triangoli si può definire la deformazione insita in ogni singola striscia della parte compressa:

def(y)=0.0035*(y-yn)/(ymax-yn)
...

Mi pare che il limite del 3.5 per mille sia valido fino all'Rck 60 MPa. Prevedi una variabile in più.

Ciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 22 April , 2011, 08:56:40 AM
Il modello non prende in considerazione le configurazioni di equlibrio limite in cui tutta la sezione è tesa.
La deformazione limite epcu=0.0035 (che varia leggermente come dice Alberto per cls. molto resist.) va ridotta progressivamente quando la distanza tra l'asse neutro e tra la fibra più tesa della sezione (punto 6 del grafico del cls) è minore di H*epc0/epcu  in cui epc0=.002 ed H = altezza massima della sezione misurata perpendicolamente all'asse neutro.
Per tener conto di questa ultima circostanza è necessario spostare il pivot di rotazione della deformazione piana sezionale dal punto di massima altezza H (punto 2 nel grafico di Zax in cui epsilon=0.0035 )  al nuovo punto sopra indicato (in cui epsilon = 0.002).
 
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Massimo.T on 22 April , 2011, 09:37:36 AM
mi inserisco senza aver seguito, ma dopo aver visto un'immagine..

ritengo che per sezioni "concave" il comportamento SLU sia più delicato del comportamento SLU "normale".
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 22 April , 2011, 12:00:18 PM
mi inserisco senza aver seguito, ma dopo aver visto un'immagine..

ritengo che per sezioni "concave" il comportamento SLU sia più delicato del comportamento SLU "normale".

Spiegati meglio.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Massimo.T on 22 April , 2011, 12:10:23 PM
parto da un esempio: una sezione a "C" di ingombro 30xh40 e di sezione 10cm
non lavora come un rettangolo 30xh40.

un programma dovrebbe tenerne conto in quella fase in cui si imputa la geometria
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 22 April , 2011, 12:33:04 PM
Una risposta per Alberto, una domanda a Renato.

L'osservazione che fai è corretta, e ne avevo fatto cenno anche io. Per chi ci legge: ci riferiamo alle formule del §4.1.2.1.2.2 che definiscono i valori di epsc2 e epscu nel caso di calcestruzzi di classe di resistenza superiore a C50/60.
In particolare, all'aumentare della classe di resistenza il "classico" 3.5 per mille diminuisce (per esempio per un cls C60/75 esso diventa 2.88 per mille) ed invece il "classico" 2 per mille aumenta (con il solito esempio 2.29 per mille).

Ora, Alberto dice: "metti una variabile in più".

Ma questo è il tipico caso in cui aver scelto come hobby la programmazione ti fa riflettere sul fatto che certe cose è meglio farle fare ai programmatori professionisti, e che forse era meglio dedicarsi alla pesca.

Per tenere conto dei differente diagramma non basta inserire 2 variabili (epsc2 ed epscu) in più e riscrivere la piccola funzione già pubblicata (cambiano ogni volta i parametri della parte parabolica che devono essere calcolati dalla funzione stessa, e non si tratta più di numeri "fissi" ricavati a priori).
Visto che la sezione è costituita da più poligoni, e che ogni poligono può essere costituito da differenti materiali (anzi è proprio questa la motivazione della suddivisione in più poligoni per la sezione), il semplice parametro fd, che avevo inserito nella struttura dati di ogni singolo poligono non basta più. Dovrò aggiungere anche le variabili epsc2 ed epscu all'interno della struttura dati. Perchè queste variabili sono e possono essere differenti per ogni singolo poligono.
Se io avessi il programma "finito" in cui memorizzo in un file tali informazioni, l'aggiunta di queste mi farebbe modificare il formato del file dati. In una ipotetica nuova versione gestirò tali informazioni. E però con i miei utenti che hanno i file della versione precedente, che faccio? Gli dico buttate tutto in aria? Ecco quindi che dovrò predisporre apposite funzioncine che mi permettano di aprire i file dati della vecchia e della nuova funzione, ecc.
Ma non basta. Anche a livello di algoritmo di calcolo vero e proprio bisognerà "inventarsi" qualcosa di differente rispetto a quanto precedentemente proposto. Infatti la deformazione nella generica fibra non sarà più 0.0035*(y-yn)/(ymax-yn), in quanto prima si dovrà capire a che poligono appartiene il vertice dotato di ymax (perchè  se appartiene ad un poligono con classe di resistenza maggiore di C50/60 al posto di 0.0035 si dovrà inserire epscu di quel poligono, e fin qui poco male). Ma, se il vertice dotato di ymax appartiene ad un poligono "normale" bisognerà valutare anche se per caso altri vertici di poligono "robusti" (C>60/50) e con y prossimi ad ymax non abbiano deformazioni incompatibili con le formule di normativa (agendo quindi di conseguenza).
Insomma, nulla che non possa essere gestito, ma che rende complesse cose altrimenti più semplici e lineari.

La domanda a Renato.
Sono consapevole, per quanto non ne abbia fatto cenno, che con il sistema proposto io sia in grado di gestire situazioni in cui Nd sia positivo (di compressione) perchè per l'equilibrio per forza devo avere una porzione di calcestruzzo reagente, e che invece per Nd negativi (da un certo punto in poi, comunque) la procedura potrebbe "difettare". In realtà non ne ho accennato per alcuni dubbi che ho, ed approfitto della tua osservazione per meglio capire.

In pratica l'Nd con cui genero il diagramma Mx-My è limitato superiormente ed inferiormente. Per quanto riguarda il limite inferiore (Nd di trazione) questo accade quando tutta la sezione è soggetta a trazione e tutte le armature hanno superato il limite elastico. Questo Nd vale fyd*ΣAf dove tutte le aree di armatura vengono sommate e moltiplicate per la massima tensione di loro lavoro. A questo Nd potrei associare un Mx ed un My nel caso in cui il baricentro delle armature fosse differente rispetto al baricentro della sezione omogenea. In ogni caso, sarei in presenza di una "fetta di salame" che degenera in un solo punto (non necessariamente origine del sistema Mx-My).
L'assenza di una limitazione nella deformazione dell'armatura, sinceramente, mi mette un pò in crisi. Perchè questo punto del dominio io sono in grado di ottenerlo per differenti posizioni dell'asse neutro (esterno alla sezione, ma che può muoversi liberamente, almeno da quando un'ultima barra supera il limite elastico in poi).
Tu, Renato, accenni ad un valore del 0.002 di deformazione per il calcestruzzo (?) per il punto 6 della mia figura. Ecco, qui non ti seguo.
Rileggendo la norma ho riscontrato solamente la frase (§4.1.2.1.2.2) "Per sezioni o parti di sezione soggette a distribuzioni di tensione di compressione approssimativamente uniformi, si assume per la deformazione ultima a rottura il valore epsc2 anzichè epscu" (cosa di cui non ero mai accorto prima e sostanzialmente pericolosissima. Penso a sezioni scatolari a pareti sottili, sollecitate a presso flessione retta. Chi mai ha pensato a ridurre il 3.5 per mille in quel caso? E quando non sono più in presso-flessione retta? torno al 3.5 per mille? Di quanto si modifica il momento di rottura in questo caso?).
Ecco altro sulla trazione non trovo. Ma sintetizzando non saprei come muovermi. Cosa mi sai dire?
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 22 April , 2011, 12:44:05 PM
parto da un esempio: una sezione a "C" di ingombro 30xh40 e di sezione 10cm
non lavora come un rettangolo 30xh40.

un programma dovrebbe tenerne conto in quella fase in cui si imputa la geometria

Ma il programma ne tiene conto certamente non per questo si danno come input non le dimensioni 30x40 di un rettangolo ma le coordinate dei veritci della poligonale che forma la C.

ciao
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Massimo.T on 22 April , 2011, 13:03:39 PM
UHM,
come?

un'ipotesi fondamentale è la conservazione delle sezioni piane.
un'altra ipotesi è che la sezione si mantenga con le medesime proporzioni..

come giustifichi i risultati che otterrai dalla "C" proposta?

Sarebbe corretto che per tale "C" (che ricordo essere d'ingombro 30xh40 e di sezione 10) si ottenga un risultato intermedio tra il risultato della C per quel che viene dal calcolo e
la "I" 10xh40, ossia la parte sinistra della C...

Il risultato della C vera è infatti carente delle due ipotesi citate.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Massimo.T on 22 April , 2011, 13:22:56 PM
Cambiamo esempio:
consideriamo una sezione a "Z" (sempre ingombro 30xh40 e sempre di sezione 10),

si intuisce meglio il comportamento irregolare?

==============

Ulteriori esempi, sezioni ad "N" o ad "H". Quì si nota come conti decisamente e moltissimo la posizione del carico: è sulla "I" di sx o su quella di dx?


....
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 22 April , 2011, 13:29:08 PM
La trattazione di cui si sta discutendo è valida per sezioni compatte in cui sia rispettata la conservazione delle sezioni piana. Nel caso di profili sottili aperti non è chiaramente valida.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Massimo.T on 22 April , 2011, 13:34:24 PM
Perfetto, quindi concordi sul fatto che una sezione simile a quella postata da Betoniera non può essere trattata con queste formulazioni..
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 22 April , 2011, 13:47:34 PM
A zax.
conviene sempre fissare una deformazione ultima a trazione FINITA per l'acciaio (ad esempio 0.0675 per una barra B450C e 0.01 per una barra Feb44k.
Le configurazioni con epcu pari a 0.002 riguardano solo sezioni fortemente compresse che raramente capitano oggi a causa dei limiti introdotti dalle NTC alla azione assiale dei pilastri in zona sismica.
Per quanto riguarda le varie posizioni dell asse neutro conviene generarle in base alla rotazione della traccia del piano di deformazione intorno ai centri di rotazione , detti pivots, indicati nelle immagini seguenti tratte da una mia pubblicazione.  In pratica per le curvature positive bastano 4 punti, assetti 1/2/3/4, per individuare preventivamente i 4 valori dello sforzo  normale entro cui scegliere i pivots di cui alla prima figura postata.


(http://img97.imageshack.us/img97/1091/clip1o.jpg) (http://img97.imageshack.us/i/clip1o.jpg/)

Uploaded with ImageShack.us (http://imageshack.us)

(http://img845.imageshack.us/img845/8083/clip2fa.jpg) (http://img845.imageshack.us/i/clip2fa.jpg/)

Uploaded with ImageShack.us (http://imageshack.us)
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 22 April , 2011, 14:03:32 PM
Perfetto, quindi concordi sul fatto che una sezione simile a quella postata da Betoniera non può essere trattata con queste formulazioni..

A prescindere dal fatto che occorre meglio definire quando una sezione in c.a. non puo' piu' essere considerata compatta e dal fatto che quella postata da Betoniera non mi pare una sezione a parete sottili, ti chiedo se conosci qualche trattazione della pressoflessione deviata per sezioni in c.a. a parete sottili. Ma, nel caso, penso che sarebbe oggetto di programmo apposito. Pertanto se riconosci che la procedura proposta dal volenteroso zax non è applicabile allora ti sarà sufficiente non applicarla, cambiare programma oppure cambiare sezione e mantenere il programma.

salud
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Massimo.T on 22 April , 2011, 14:13:41 PM
A prescindere dal fatto che occorre meglio definire quando una sezione in c.a. non puo' piu' essere considerata compatta e dal fatto che quella postata da Betoniera non mi pare una sezione a parete sottili, ti chiedo se conosci qualche trattazione della pressoflessione deviata per sezioni in c.a. a parete sottili. Ma, nel caso, penso che sarebbe oggetto di programmo apposito. Pertanto se riconosci che la procedura proposta dal volenteroso zax non è applicabile allora ti sarà sufficiente non applicarla, cambiare programma oppure cambiare sezione e mantenere il programma.

salud

la procedura è più che buona, ma ha dei limiti cui è bene rispettare.
le parti non convesse e/o non compatte (come ci ricorda Renato) sono soggette a considerazioni ancor più fini. tutto lì.

inoltre per tali sezioni, tanto più sono non convesse e/o non compatte e tanto più tali risultati SLU saranno sopravvalutati.
una sezione poco compatta come quella di Betoniera (il cui peggior difetto è però la concavità) non può rendere al 100% di quello che il programma sputa fuori..
forse sarà anche il 99%..., ma non il 100%..

detto questo, ripeto a scanso di equivoci, il fine di questo programma è più che buono, ma sarebbe opportuno segnalarne i limiti!
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 22 April , 2011, 14:23:36 PM
la procedura è più che buona, ma ha dei limiti cui è bene rispettare.
le parti non convesse e/o non compatte (come ci ricorda Renato) sono soggette a considerazioni ancor più fini. tutto lì.

inoltre per tali sezioni, tanto più sono non convesse e/o non compatte e tanto più tali risultati SLU saranno sopravvalutati.
una sezione poco compatta come quella di Betoniera (il cui peggior difetto è però la concavità) non può rendere al 100% di quello che il programma sputa fuori..
forse sarà anche il 99%..., ma non il 100%..

detto questo, ripeto a scanso di equivoci, il fine di questo programma è più che buono, ma sarebbe opportuno segnalarne i limiti!

Ma nulla è cambiato rispetto a prima. Tuttavia mi chiedo quali sarebbero le considerazioni ancor piu fini da dover considerare?
Segnalerò al programmatore di inserire un disclaimer (si dice cosi) con specificate tutte le ipotesi del De Saint Venant. Vuoi mettere che a qualche zappaiuolo venisse in mente di usare il programma?
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Massimo.T on 22 April , 2011, 14:28:22 PM
Bah, alle TA (oggi SLE) abbiamo la teoria di Vlasov.

Agli SLU non credo ci sia nulla, ma non per questo puoi non tenerne conto.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 22 April , 2011, 14:37:07 PM
Bah, alle TA (oggi SLE) abbiamo la teoria di Vlasov.

Agli SLU non credo ci sia nulla, ma non per questo puoi non tenerne conto.

Già, la teoria di Vlasov per sezioni aperte a pareti sottili sottoposte a torsione e taglio?.
Ritieni si possa applicare alle sezioni sottili aperte in stato di tensione generata da presso o tensoflessione deviata? E come ne terremmo conto agli stati limiti ultimi?

Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Massimo.T on 22 April , 2011, 14:51:53 PM
il mio parere è che occorre spezzare la risultante dell'azione applicata nelle forze associate ai vari punti di applicazione relativi a varie sottosezioni.
dopodichè ogni sottosezione sarà gestita indipendentemente.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: ferrarialberto on 22 April , 2011, 15:11:52 PM
...
Tu, Renato, accenni ad un valore del 0.002 di deformazione per il calcestruzzo (?) per il punto 6 della mia figura. Ecco, qui non ti seguo.
Rileggendo la norma ho riscontrato solamente la frase (§4.1.2.1.2.2) "Per sezioni o parti di sezione soggette a distribuzioni di tensione di compressione approssimativamente uniformi, si assume per la deformazione ultima a rottura il valore epsc2 anzichè epscu" (cosa di cui non ero mai accorto prima e sostanzialmente pericolosissima. Penso a sezioni scatolari a pareti sottili, sollecitate a presso flessione retta. Chi mai ha pensato a ridurre il 3.5 per mille in quel caso? E quando non sono più in presso-flessione retta? torno al 3.5 per mille? Di quanto si modifica il momento di rottura in questo caso?).
...

Come giustamente indica Renato quando la sezione è tutta compressa il limite di deformazione è ridotto sotto il 3.5 per mille, arrivando al limite del 2 per mille per sezione uniformemente compressa. E' opportuna una pausa, capire bene il dominio M-N prima di passare al Mx-My; in quest'ultimo caso si procede come segue:
1) si fissa la giacitura dell'asse neutro (angolo);
2) si calcolano 6 punti fondamentali del dominio Mteta-N (il dominio M-N in cui il momento è riferiro all'asse baricentrico parallelo all'asse neutro fissato al punto 1);
2b) i 6 punti di cui sopra sono massima trazione (io in Doro indico con T tale punto); contemporanea rottura con momento positivo (CR+, in Doro); limite della sezione completamente compressa con mom. pos. (NC+) ovvero asse neutro tangente alla sezione; compressione massima (C), contemporanea rottura con momento negativo (CR-) e da ultimo limite della sezione completamente compressa con mom. neg. (NC-);
3) il programma controlla che N(C)<=NSd<=N(T), altrimenti la "fetta di salame" non esiste; degenera in un punto, come giustamente scrivi, se sono =;
4) analizzo 3 casi con momento positivo e 3 con momento negativo e precisamente:
4a) se N(CR+)<=NSd<=NT sono nel campo dell'armatura debole (crisi lato acciaio);
4b) se N(NC+)<=NSd<=N(CR+) crisi lato calcestruzzo con sezione parzializzata;
4c) se N(C)<=Nsd<=N(NC+) crisi lato calcestruzzo con sezione interamente reagente (il discorso del 2 per mille per tornare a prima);
4d, 4e, 4f) come gli omologhi a, b, c ma con momento negativo;
5) in ciascuno dei 6 casi di cui al punto 4 la deformazione incognita varia in un campo di deformazioni ben definito (alla "ricerca" della NSd).

E' un po' difficile ma se sei arrivato fino qui ce la fai.

Ciao.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 22 April , 2011, 19:36:46 PM
il mio parere è che occorre spezzare la risultante dell'azione applicata nelle forze associate ai vari punti di applicazione relativi a varie sottosezioni.
dopodichè ogni sottosezione sarà gestita indipendentemente.

Quindi ogni sottosezione potrà deformarsi per conto prprio in barba alla continuità. Resta fermo il principio che anche se la deformazione non mantiere piane le sezioni ingobbendole deve sussistere sempre la continuità.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: SpinoWeb on 22 April , 2011, 20:05:08 PM
Quindi ogni sottosezione potrà deformarsi per conto prprio in barba alla continuità. Resta fermo il principio che anche se la deformazione non mantiere piane le sezioni ingobbendole deve sussistere sempre la continuità.
funziona come se fosse un telaio...
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 22 April , 2011, 21:07:17 PM
@Renato e Alberto

Grazie delle precisazioni. Spero di farne tesoro.

@Massimo
La trattazione che ho fatto finora prevede il DOGMA della conservazione della sezione piana come ATTO DI FEDE.
Ne ho parlato in maniera esplicita nella parte 5 di queste note, e, pur non avendolo detto espressamente, potrai vederne la traduzione in formula (quella della deformazione) nella parte 8 in cui ho iniziato con SLU.
Ovviamente nel caso in cui si ritenesse che la sezione non abbia modo di rispettare queste ipotesi, tutti gli algoritmi qui trattati non vanno bene.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 22 April , 2011, 21:23:50 PM
funziona come se fosse un telaio...

cioè?
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Gilean on 22 April , 2011, 23:32:57 PM
funziona come se fosse un telaio...

che io sappia, anche in un telaio valgono le equazioni di compatibilità.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: SpinoWeb on 23 April , 2011, 00:35:57 AM
che io sappia, anche in un telaio valgono le equazioni di compatibilità.
direi che l'idea sarebbe proprio quella (magari in  letteratura qualcuno ci ha già pensato) e credo che potrebbe funzionare
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Gilean on 23 April , 2011, 00:55:20 AM
direi che l'idea sarebbe proprio quella (magari in  letteratura qualcuno ci ha già pensato) e credo che potrebbe funzionare

Allora non ho capito questo passaggio:

Afazio dice:

Quote
Quindi ogni sottosezione potrà deformarsi per conto prprio in barba alla continuità. Resta fermo il principio che anche se la deformazione non mantiere piane le sezioni ingobbendole deve sussistere sempre la continuità.

Tu dici

Quote
funziona come se fosse un telaio...


non vorrei ripetere la domanda di afazio, ma non avendo capito il senso, la ripeto: cioe'?
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 23 April , 2011, 04:34:38 AM
Qui sotto mostro un esempio di come è possibile modellare una trave (nucleo ascensore) con sezione a C a profilo sottile mediante delle travi aventi sezioni rettangolare (pareti) costituenti sottosezioni della C e per ognuna delle quali (separatamente) resta valido il principio di conservazione delle sezioni piane. Le singole pareti sono collegate solo a livello di piano con link rigidi che simulano ottimamente la reale continuità strutturale lungo i bordi. La soluzione è molto vicina a quella della modellazione dell'intera parete a C mediante shell, la cui verifica allo SLU è molto più complessa ed opinabile.

(http://img151.imageshack.us/img151/6236/nucleo.jpg) (http://img151.imageshack.us/i/nucleo.jpg/)

Uploaded with ImageShack.us (http://imageshack.us)
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: SpinoWeb on 23 April , 2011, 09:52:08 AM
@Gilean & afazio: Considerando la solita sezione a "C", si potrebbe assumere che le flange e l'anima della sezione si deformino secondo tre piani differenti e che la compatibilità venga successivamente garantita ai "nodi". Non credo che qualcuno non ci abbia già pensato e probabilmente è più facile a dirsi che a farsi, infatti sarebbe simile a quello che ha postato Renato che mi pare essere un'applicazione di un metodo proposto da Capurso qualche decade fà.
Solitamente nelle verifiche di questa tipologia di sezioni si tiene conto di un fattore di rigidezza torsionale che è influenzato dall'ingobbamento (mi pare che questa cosa sià stata già precedentemente accennata). In sostanza viene ridotta rispetto a quella classica.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 23 April , 2011, 10:27:00 AM
Qui sotto mostro un esempio di come è possibile modellare una trave (nucleo ascensore) con sezione a C a profilo sottile mediante delle travi aventi sezioni rettangolare (pareti) costituenti sottosezioni della C e per ognuna delle quali (separatamente) resta valido il principio di conservazione delle sezioni piane. Le singole pareti sono collegate solo a livello di piano con link rigidi che simulano ottimamente la reale continuità strutturale lungo i bordi. La soluzione è molto vicina a quella della modellazione dell'intera parete a C mediante shell, la cui verifica allo SLU è molto più complessa ed opinabile.

(http://img151.imageshack.us/img151/6236/nucleo.jpg) (http://img151.imageshack.us/i/nucleo.jpg/)

Uploaded with ImageShack.us (http://imageshack.us)

Questa schematizzazione viene assunta a monte, nel modello strutturale. A valle ciascuna delle sottosezioni sarà soggetta a delle sollecitazioni e con queste, generalmente, si verificano singolarmnete le singole sottosezioni.
Il caso in esame è: data una sezione (ammettiamo a C ed a pareti sottili) ed una terna di sollecitazioni (N, Mx My), come procedere a determinare le sollecitazioni di verifica per ciascuna sottosezione imponendo una qualche condizione di continuità/congruenza nella deformata?
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 23 April , 2011, 13:24:55 PM
@ Fazio
Si può utilizzare lo stesso programma di telaio tridimensionale assenando un solo impalcato in altezza (ad esempio alto 1 metro) e dichiarando il piano stesso estensionalmente rigido (master di piano baricentrico). Al master di piano si assegnano forze orizzontali tali da generare nelle sezioni di incastro alla base i momenti Mx,My desiderati (Fx=My*1=My:  Fy=Mx*1=Mx). L'eventuale sforzo normale va ripartito nelle 3 sottosezioni rettangolari o in base all'effettivo sforzo presente o in proporzione alle rispettive aree sezionali.
Risolto lo schema tridimensionale ci ritroviamo nelle sezioni di incastro delle tre mensole gli sforzi di verifica relativi alle 3 sottosezioni rettangolari.
Se nel master di piano applichiamo anche un momento torcente di piano il calcolo ci consegnerà anche lo sforzo flettente che fa equilibrio al torcente applicato (il famoso bimomento di Vlasov). In più se la sezione a parete sottile è chiusa e pluriconnessa otteniamo anche i tagli che riferiti alle singole sottosezioni realizzano l'equilibrio con il torcente di piano.
Si può volere di più da uno schema a telaio!
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 23 April , 2011, 13:47:01 PM
@ Fazio
Si può utilizzare lo stesso programma di telaio tridimensionale assenando un solo impalcato in altezza (ad esempio alto 1 metro) e dichiarando il piano stesso estensionalmente rigido (master di piano baricentrico). Al master di piano si assegnano forze orizzontali tali da generare nelle sezioni di incastro alla base i momenti Mx,My desiderati (Fx=My*1=My:  Fy=Mx*1=Mx). L'eventuale sforzo normale va ripartito nelle 3 sottosezioni rettangolari o in base all'effettivo sforzo presente o in proporzione alle rispettive aree sezionali.
Risolto lo schema tridimensionale ci ritroviamo nelle sezioni di incastro delle tre mensole gli sforzi di verifica relativi alle 3 sottosezioni rettangolari.
Se nel master di piano applichiamo anche un momento torcente di piano il calcolo ci consegnerà anche lo sforzo flettente che fa equilibrio al torcente applicato (il famoso bimomento di Vlasov). In più se la sezione a parete sottile è chiusa e pluriconnessa otteniamo anche i tagli che riferiti alle singole sottosezioni realizzano l'equilibrio con il torcente di piano.
Si può volere di più da uno schema a telaio!

Si, si potrebbe fare. Ma tutto cio' sarebbe oggetto di un programma a parte e non inserito in un programma che analizza una sezione generica a presso-tensoflessione deviata.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 23 April , 2011, 16:26:21 PM
Parte 9

Larghezza delle fibre e loro baricentro
Bene, rispetto a quanto detto nella parte 8, dovrò rivedere gli aspetti deformativi della sezione, in modo da tenere conto anche di sforzi normali di trazione agenti sulla sezione, accogliendo così i suggerimenti di Alberto e Renato.
La definizione della lunghezza di ogni singola fibra della (eventuale) parte compressa di calcestruzzo può però essere affrontato, in quanto esso dipende da sole considerazioni geometriche.

Con un po' di geometria analitica bisognerà valutare le intersezioni della retta y=yf (con yf la ordinata della fibra di interesse) con il perimetro di uno dei poligono.
Prima bisognerà però svolgere alcune considerazioni “topologiche”.
La situazione standard infatti è quella della figura a sinistra della volta scorsa, che ripropongo:

(http://s4.postimage.org/1ckr8ia90/Sezione_generica9.jpg) (http://postimage.org/image/1ckr8ia90/)

Un po' più articolato è quanto accade, invece, nella parte destra della stessa figura. Infine, ecco il caso che mi pare il più “complesso” che possa capitare (ma accetto smentite):

(http://s4.postimage.org/1ckw74bqc/Sezione_generica10.png) (http://www.postimage.org/)

In ogni caso si vede che la retta y=yf interseca un singolo poligono, sempre in un numero pari di punti (n), staccando un numero dispari di segmenti (n-1). Si vede anche come la lunghezza complessiva della fibra sia la somma delle lunghezze dei segmenti dispari.
Bene, vediamo adesso le coordinate delle intersezioni tra retta y=yf e poligono. Prendiamo un singolo segmento, come in figura:

(http://s4.postimage.org/1cl2t9ppg/Sezione_generica11.png) (http://www.postimage.org/)

Il segmento i / i+1 ha una equazione y=mx+q, dove:

m=(y[i+1]-y[i ])/(x[i+1]-x[i ])
q=y[i ]-m*x[i ]

Mettendo a sistema le due equazioni:

y=mx+q
y=yf

si ottiene per xf:

xf=(yf-q)/m

Adesso sostituendo ai vari simboli le espressioni, ricaviamo questa espressione per xf un po' articolata:

xf=[(yf-y[i ])*(x[i+1]-x[i ])+(y[i+1]-y[i ])*x[i ]]/(y[i+1]-y[i ])

Ma che mi consente di non dover gestire il caso particolare di segmento del poligono perfettamente verticale (che avrebbe m, coefficiente angolare, infinito). Certo, la formula cadrebbe in difetto nel caso di segmento orizzontale (y[i+1]-y[i ] diventa nullo), ma due rette orizzontali....si incontrano all'infinito comunque.
Per rendere l'algoritmo della funzione un po' più veloce basterà non processare, dunque, tutti i segmenti orizzontali, e tutti i segmenti che hanno punto iniziale e finale contemporaneamente più in alto o più in basso di yf.
Adesso quindi, facendo il giro, segmento per segmento del poligono, troverò tutte le coordinate xf di intersezione del poligono con la retta y=yf.
Faccio notare, ma magari lo avrete già notato guardando la figura con la “greca” e comunque riguardatela, che le coordinate xf non vengono ricavate in maniera crescente, ma a “casaccio”. Può accadere anche nel caso semplice di normale doppia intersezione. Dipende infatti da quale è il primo lato del poligono.
Pertanto dopo aver ricavato tutte le xf bisognerà procedere al loro ordinamento crescente, in modo da poter procedere quindi alla definizione della lunghezza della fibra, che ricordo consiste nel sommare le lunghezze dei segmenti dispari (quindi xf2-xf1 e xf4-xf3 e xf6-xf5, ecc.).

Però in effetti quello che ci serve per i calcoli successivi non è solamente la larghezza della fibra (necessaria per definire un N), ma anche il baricentro di questa serie di segmenti (necessari, trovato l'N voluto, a definire i momenti di rottura della sezione).
Pertanto la funzione che calcola la lunghezza della fibra dovrà restituirmi anche la coordinata xb di tale punto.
Lo sappiamo che in C le funzioni restituiscono un solo valore alla volta. Per cui si potrebbero scrivere 2 funzioni, ognuna con un ben preciso valore restituito. Sarebbe un peccato perchè le 2 funzioni farebbero al 95% lo stesso lavoro. Si potrebbe inserire un flag tra i parametri di chiamata di una singola funzione, in modo da far restituire o la lunghezza della fibra, o il suo baricentro. Ma questo significa chiamare 2 volte la funzione e far calcolare due volte all'elaboratore le stesse cose. La soluzione, quella che come al solito mi piace, ormai lo avrete capito, è quella di una struttura dati. Così:

Code: [Select]
struct lungh_fibra
{
 float lungh;
 float xb;
};

La funzione completa invece sarà:

Code: [Select]
struct lungh_fibra calcola_lungh_fibra(struct poligono_sezione,float); /* Prototipo funzione */

struct lungh_fibra calcola_lungh_fibra (struct poligono_sezione polic,float yf)
{
 int register j,k;
 int ni=0;    /* Numero intersezioni con il poligono */
 float xf[20]; /* Coordinate intersezioni con il poligono */
 float provv,scy=0.0;
 struct lungh_fibra fibra;

 for (k=0;k<=polic.numv-1;k++)
     {
      int kp1=k+1;

      if (k==polic.numv-1) kp1=0;
     
      if (polic.y[k]>yf && polic.y[kp1]>yf) continue; /* Segmento tutto più in alto della fibra */
      if (polic.y[k]<yf && polic.y[kp1]<yf) continue; /* segmento tutto più in basso della fibra */
      if (polic.y[k]==polic.y[kp1]) continue; /* Segmento orizzontale */
     
      xf[ni]=((yf-polic.y[k])*(polic.x[kp1]-polic.x[k])+(polic.y[kp1]-polic.y[k])*polic.x[k])/(polic.y[kp1]-polic.y[k]);
      ni++;
     }
 
 if (ni!=0) /* Controlla se effettivamente ci sono intersezioni */
    {
     /* Ottenute tutte le intersezioni provvede a metterle in ordine crescente */
     for (k=0;k<=ni-1;k++)
         {
          for (j=k+1;j<=ni-1;j++) if (xf[j]<xf[k]) { provv=xf[j]; xf[j]=xf[k]; xf[k]=provv;  }
         }

     /* Infine calcola le lunghezze dei vari tratti */
     fibra.lungh=0.0;
     for (k=0;k<=ni-1;k+=2)
         {
          fibra.lungh+=xf[k+1]-xf[k];
          scy+=(xf[k+1]-xf[k])*(xf[k+1]+xf[k])/2;
         }
     /* e definisce il baricentro della fibra nella sua totalità */
     fibra.xb=scy/fibra.lungh;
     
     return (fibra);
    }
 else { fibra.lungh=0.0; fibra.xb=0.0; return(fibra); }
}

La funzione chiamante provvederà a moltiplicare la lunghezza della fibra per la larghezza della fibra stessa (abbiamo detto un parametro gestibile dall'utente, oppure una variabile globale del programma – 1 mm? 2 mm?), in modo da avere un'area e dunque a moltiplicarla per la tensione ricavata dal diagramma costitutivo del materiale in funzione della effettiva deformazione della fibra.

Per il momento, mi fermo qui, rimandando a dopo pasqua altri sviluppi. Nel frattempo spero non vi siate accapigliati “alla Vlasov” per decidere se una sezione si mantiene piana o meno a seguito della deformazione.

Per rispondere a chi ha tirato fuori la teoria di Vlasov, essa si applica alla torsione di sezioni (forse) aperte a pareti sottili.
In pratica in questi casi oltre a tensioni tangenziali nello stesso piano della sezione si destano nella sezione anche delle tensioni a farfalla agenti in maniera normale alla sezione. Tensioni dunque che si sommano a quelle della flessione (che si potranno ricavare con l'ipotesi di sezione piana?). La tensione a farfalla ha comunque un diagramma strano, nel senso che si inverte sia in senso verticale che orizzontale. Vado a memoria, perchè mi pare, sempre da letteratura tecnica, che sia possibile ricavare un “indicatore geometrico” che consente di stabilire se il “fenomeno Vlasov” ha una influenza importante o meno sulla sezione che si sta studiando.
Per le sezioni in cemento armato le realizzazioni “sottili” sono in genere elementi prefabbricati del tipo tegoli “alari” e simili proposti da vari prefabbricatori. Orbene, per gli spessori usuali (minimo 6-7 cm) e le altre dimensioni della sezione, alla fine anche queste sezioni non sono definibili “sottili” alla Vlasov.

Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Gilean on 23 April , 2011, 20:21:24 PM
vista l'importanza del tread, lo metto in rilievo  ;)
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 26 April , 2011, 11:08:28 AM
@Gilean

Non ho capito in cosa consisterebbe la "messa in rilievo" del topic visto che, bontà vostra, mi sembra che sia stato messo al numero uno fin quasi dall'inizio (sfondo marroncino pallido nella mia visualizzazione).
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Gilean on 26 April , 2011, 11:49:27 AM
infatti avevo notato successivamente che era gia' stato messo in rilievo da un moderatore arzillo.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 30 April , 2011, 00:04:45 AM
Parte 10

Ritornando sui propri passi – Le deformazioni a rottura
Visti gli interventi di Renato ed Alberto Ferrari rettifico alcune cose della parte 8 riguardanti la deformazione a rottura della sezione.
Approfitto della figura che Renato ha gentilmente postato per rubargliela e riaggiustare il discorso.

(http://s2.postimage.org/2ii7xzjz8/Sezione_generica12.jpg) (http://postimage.org/image/2ii7xzjz8/)

La figura può essere letta in due modi:

1) Ho una certa situazione deformativa, da cui ricavo la posizione dell'asse neutro;
2) Ho una certa posizione dell'asse neutro, da cui ricavo la situazione deformativa.

E' questa seconda via quella che perseguirò.

Definiamo un po' di cose:

yn: ordinata dell'asse neutro;
ymax: massima ordinata tra tutti i vertici della sezione;
yamin: minima ordinata tra tutte le barre di armatura;
?a: deformazione in corrispondenza di ymax;
?b: deformazione in corrispondenza di yamin;
?yd: deformazione massima dell'acciaio (valore negativo se di trazione);
?cu: deformazione massima nel calcestruzzo (valore positivo se di compressione)
?c0: deformazione in cui termina il tratto parabolico del “classico” diagramma parabola-rettangolo

Conoscendo le deformazioni in ymax ed yamin, per l'ipotesi di conservazione della planarità, si ricava la deformazione in qualsiasi altra fibra della sezione. Infatti per ogni fibra posta alla generica quota y, si avrà:

?=?a+(?b-?a)*(ymax-y)/(ymax-yamin)

Dove ?b e ?a vanno inseriti con il loro effettivo segno nella formula.

Le situazioni che possono riscontrarsi guardando la figura sono solamente tre, ovvero:

a) Posizione dell'asse neutro: +?>yn>(??yd?*ymax+?cu*yamin)/(?cu+??yd?)
In questo caso:
?a=?yd*(yn-ymax)/(yn-yamin)
?b=?yd (valore negativo)

Come suggerito da Renato, ad ?yd viene assegnato il valore -0.0675 (pari al 90% di 7.5% deformazione a rottura di un acciaio B450C – vedi §4.1.2.1.2.3 e Tab. 11.3.Ib)

b) Posizione dell'asse neutro (??yd?*ymax+?cu*yamin)/(?cu+??yd?)?yn>yamin
In questo caso:
?a=?cu
?b=?cu*(yn-yamin)/(yn-ymax)


c) Posizione dell'asse neutro yamin?yn>-?
In questo caso il diagramma ruota attorno al punto di deformazione ?c0 posto a quota yc0=yamin+?c0*(ymax-yamin)/?cu, e quindi:
?a=?c0*(ymax-yn)/(yc0-yn)
?b=?c0*(yamin-yn)/(yc0-yn)


Osservate come io abbia dato un valore numerico alla sola deformazione massima ?yd, lasciando le altre grandezze “indefinite”. Perchè a questo punto scatta quanto detto da Alberto Ferrari circa i differenti valori di ?c0 ed ?cu per i calcestruzzi con classe di resistenza superiore a C50/60 (vedi §4.1.2.1.2.2).
Questo fatto, come accennato in un post precedente, comporta delle ulteriori elaborazioni da fare prima di definire la corretta deformazione della sezione.

Intanto occorrerà modificare la struttura dati dei poligoni, inserendo anche tre nuovi valori:

Code: [Select]
struct poligono_sezione
{
 float x[100];   /* coordinata x del vertice */
 float y[100];   /* coordinata y del vertice */
 int numv;       /* numero di vertici del poligono */
 float omog;     /* coefficiente di omogeneizzazione */
 int traz;       /* 0=non reagente a trazione; 1=reagente a trazione */
 char classe[8]; /* NUOVO Classe di resistenza del cls */
 float fd;       /* Resistenza massima di calcolo */
 int dominio;    /* 0=parabola-rettangolo (cls) 1=bilatera (acciaio) */
 int fase;       /* A futura memoria per gestire fasi di realizzazione */
 float epsc0;    /* NUOVO deformazione di fine parabola del dominio */
 float epscu;    /* NUOVO deformazione ultima del dominio */
};

Io immagino che ci sia una porzione di programma che in funzione di un input dell'Utente (la classe di resistenza) calcoli con le formule di normativa i valori corretti di epsc0 ed epscu.

Poi bisognerà rettificare la funzione che avendo in entrata la deformazione restituisce il valore alfa da moltiplicare per fd per ottenere la tensione di rottura. La funzione presentata nella parte 8, se ricordate, presentava dei valori fissi, che ovviamente adesso non vanno più bene.
Per la parte parabolica del diagramma, facendo passare la parabola per i punti 0;0 e ?c0;1 ed imponendo la tangenza orizzontale in questo ultimo punto, si ottengono i parametri della parabola: a=-1/?co^2 e b=2/?c0

Pertanto la funzione, aggiungendo il parametro epsc0 in ingresso, diventa:

Code: [Select]
float parabola_rett(float,float); /* Prototipo della funzione */

float parabola_rett(float def,float epsc0)
{
 float alfa;

 if (def>=epsc0) alfa=1.0;
 else alfa=-pow(def,2)/pow(epsc0,2)+2*def/epsc0;

 return (alfa);
}

A questo punto sarei pronto, rettificando tutto quanto ho rettificato, a presentare la funzione che, dato un certo valore yn di ordinata dell'asse neutro determina le deformazioni nei punti di maggiore e minore “altezza” della sezione.

Non senza prima però aggiungere un ulteriore tassello alla questione.
Infatti, se la sezione è costituita da più poligoni, e se alcuni di questi poligoni sono costituiti da calcestruzzo con classe di resistenza superiore a C50/60, e quindi con valori di ?cu ed ?c0 differenti dai soliti 3.5 per mille (minore di tale valore) e 2 per mille (maggiore di tale valore), chi ci garantisce che la deformazione in ymax del 3.5 per mille (poiché per esempio ymax è di un vertice appartenente ad un poligono “normale”) sia compatibile con la massima deformazione possibile di un vertice del poligono “special”, magari posto pochi centimetri più in basso di ymax?
Nella figura successiva viene presentato proprio il caso di cui parlo.

(http://s2.postimage.org/2ii2zdihw/Sezione_generica13.jpg) (http://postimage.org/image/2ii2zdihw/)

Chiaramente quindi, la funzione che definisce le deformazioni limite della sezione, dovrà tenere conto del problema.
Correggere le cose sembra semplice a prima vista (la linea rossa della figura rimette a posto le cose), però, riflettendo, la deformata che “comanda” a questo punto è quella del poligono “forte” (quello più scuro della figura), e questo dovrà rispettare le condizioni a) b) o c) comunque (massima tensione di rottura in un lembo piuttosto che nell'altro).
Però gli effettivi casi che possono realmente verificarsi sono il b) (in quanto al lembo superiore si ha già una deformazione limite, il materiale cls) oppure il c).

Allora, per il caso b) le nuove deformazioni, indicate con ?'a ed ?'b in figura, valgono:

?'a=?'cu*(ymax-yn)/(y'max-yn)
?'b=?'cu*(yn-yamin)/(yn-y'max)


Invece nel caso c) si modifica anche il punto di rotazione della sezione, ovvero:

y'c0=yamin+?'c0*(y'max-yamin)/?'cu, e quindi:
?'a=?'c0*(ymax-yn)/(y'c0-yn)
?'b=?'c0*(yamin-yn)/(y'c0-yn)


Questi controlli di “congruenza” vanno estesi a tutti i poligoni che costituiscono la sezione, ritoccando di volta in volta i numeri. Certamente è uno ed uno solo il poligono che “comanda”.

Infine ecco una nuova struttura dati:

Code: [Select]
struct deform_ultime_sezione
{
 float epsa;
 float epsb;
};

Ed ecco la funzione (preceduta dal solito prototipo), che restituisce proprio una struttura dati come quella di cui sopra:

Code: [Select]
struct deform_ultime_sezione calcola_deform_ultime(struct poligono_sezione *,float,int,float,float);

/* Dati di ingresso della funzione ------------------------ */
/* ymax=massima ordinata della sezione in cls               */
/* npm=numero del poligono in cui si ha la massima ordinata */
/* yamin=minima ordinata delle armature                     */
/* yn=ordinata asse neutro                                  */
struct deform_ultime calcola_deform_ultime(struct poligono_sezione *polic,float ymax,int npm,float yamin,float yn)
{
 int register k,np;
 float y1[5],yc0,dpa;
 struct deform_ultime_sezione def;

 /* Calcola le massime ordinate di ogni singolo poligono */
 for (np=0;np<4;np++)
     {
     y1[np]=-1000000.0;
      for (k=0;k<=polic[np].numv-1;k++)
          {
           if (polic[np].y[k]>y1[np]) y1[np]=polic[np].y[k];
          }
     }

 /* Definisce le deformazioni ultime della sezione */
 if (yn>(fabs(epsyd)*ymax+polic[npm].epscu*yamin)/(polic[npm].epscu+fabs(epsyd)))
    {
     def.epsa=epsyd*(yn-ymax)/(yn-yamin);
     def.epsb=epsyd;
    }
 if (yn<=(fabs(epsyd)*ymax+polic[npm].epscu*yamin)/(polic[npm].epscu+fabs(epsyd)) && yn>yamin)
    {
     def.epsa=polic[npm].epscu;
     def.epsb=polic[npm].epscu*(yn-yamin)/(yn-ymax);
    }
 if (yn<=yamin)
    {
     yc0=yamin+polic[npm].epsc0*(ymax-yamin)/polic[npm].epscu;
     def.epsa=polic[npm].epsc0*(ymax-yn)/(yc0-yn);
     def.epsb=polic[npm].epsc0*(yamin-yn)/(yc0-yn);
    }

 /* Controlla che per tutti i contorni valga quanto ricavato */
 for (np=0;np<=4;np++)
     {
      if (np==npm || polic[np].numv==0) continue;

      dpa=def.epsa+(def.epsb-def.epsa)*(ymax-y1[np])/(ymax-yamin);

      if (dpa>polic[np].epscu)
         {
          if (yn<=(fabs(epsyd)*y1[np]+polic[np].epscu*yamin)/(polic[np].epscu+fabs(epsyd)) && yn>yamin)
             {
              def.epsa=polic[np].epscu*(ymax-yn)/(y1[np]-yn);
              def.epsb=polic[np].epscu*(yn-yamin)/(yn-y1[np]);
             }
          if (yn<=yamin)
             {
              yc0=yamin+polic[np].epsc0*(y1[np]-yamin)/polic[np].epscu;
              def.epsa=polic[np].epsc0*(ymax-yn)/(yc0-yn);
              def.epsb=polic[np].epsc0*(yamin-yn)/(yc0-yn);
             }
         }
     }

 return(def);
}

Come vedete non ho fatto altro che implementare tutte le formule prima ricavate. La variabile epsyd è una variabile di tipo globale. Ovviamente si presuppone che prima di chiamare per la prima volta questa funzione il programma abbia già provveduto a calcolare preventivamente ymax ed yamin.

E' stato complicato, non difficile. Speriamo bene per i prossimi “mattoni”.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 04 May , 2011, 14:11:34 PM
Parte 11

Due funzioni
In questa parte vedremo le due funzioni di “base” per il funzionamento di tutta la procedura. Esse sono: la funzione che determina lo sforzo totale N agente nella parte compressa della sezione e lo sforzo totale N della sola parte tesa.
Ovviamente in queste funzioni si farà ricorso alle funzioni descritte e scritte precedentemente.
Queste due funzioni restituiscono entrambe tre valori, incapsulate nella solita struttura dati, il valore cercato di N e le coordinate x ed y del suo punto di applicazione.

Pertanto definiamo inizialmente la struttura:

Code: [Select]
struct risultante_n
{
 float n;    /* Sforzo normale risultante */
 float x;    /* Coordinate punto di applicazione risultante */
 float y;
};

Ed il prototipo della funzione:

Code: [Select]
struct risultante_n risult_compr(struct poligono_sezione *,struct armature_sezione,float,float,float,struct deform_ultime_sezione);
E il corpo vero e proprio della sezione:

Code: [Select]
/* Dati di ingresso della funzione ------------------------ */
/* ymax=massima ordinata della sezione in cls               */
/* yamin=minima ordinata delle armature                     */
/* yn=ordinata asse neutro                                  */
/* deform.epsa=deformazione lembo più alto della sezione           */
/* deform.epsb=deformazione lembo più basso della sezione          */
struct risultante_n risult_compr(struct poligono_sezione *polic, struct armature_sezione armc,float ymax,float yamin,float yn,struct deform_ultime_sezione deform)
{
 int register k,np;
 int segno;
 float y,dx,def,pressione,forza,scx=0.0,scy=0.0;
 struct risultante_n risult;
 struct lungh_fibra fibra;
 
 risult.n=0.0;
 dx=(ymax-yn)/50;
 if (dx<0.0) { risult.n=0.0; risult.x=0.0; risult.y=0.0; return(risult); }
 
 /* Inizia con i vari contorni della sezione */
 for (np=0;np<=4;np++)
     {
      if (polic[np].numv==0) continue;
      if (polic[np].omog<0.0) segno=-1; else segno=1;

      for (y=yn+dx/2;y<=ymax;y+=dx)
          {
           fibra=calcola_lungh_fibra (polic[np],y);
           def=deform.epsa+(deform.epsb-deform.epsa)*(ymax-y)/(ymax-yamin);
           if (polic[np].dominio==0) pressione=parabola_rett(def,polic[np].epsc0)*polic[np].fd;
           else pressione=elast_plast_indef(def)*fyd;
           forza=segno*fibra.lungh*pressione*dx;
           risult.n+=forza;
           /* Momenti statici per definire risultanti */
           scx+=forza*y;
           scy+=forza*fibra.xb;
          }
     }
 /* Prosegue con le armature compresse */
 for (k=0;k<=armc.numarm-1;k++)
     {
      if (armc.y[k]<yn) continue;
      def=deform.epsa+(deform.epsb-deform.epsa)*(ymax-armc.y[k])/(ymax-yamin);
      pressione=elast_plast_indef(def)*fyd;
      forza=pressione*armc.af[k];
      risult.n+=forza;
      scx+=forza*armc.y[k];
      scy+=forza*armc.x[k];
     }
 risult.x=scy/risult.n;
 risult.y=scx/risult.n;

 return(risult);
}

Tre osservazioni:
1) Il numero di suddivisioni della parte compressa è stato “imposto” in 50 strisce. Ovviamente si è trattato di una scelta personale (e molto sbrigativa). Ovviamente aumentando la “finezza” delle strisce si migliora la precisione numerica del risultato. Oltre ad aumentare il numero delle strisce altri eventuali criteri potrebbero prevedere un numero variabile di strisce in funzione della “profondità” della parte compressa di sezione, oppure un numero n di strisce ma con un controllo valore massimo di larghezza della striscia, oppure un criterio misto tra questi ultimi due, ecc.
2) Anche se alla ordinata y il singolo poligono di cui è composta la sezione non dovesse avere alcuna intersezione con la retta orizzontale, la funzione calcola_lungh_fibra() restituisce correttamente il valore 0.0 della lunghezza fibra (andate a vedere nella parte 9).
3) Controllando il segno di dx si fa in modo di restituire correttamente risultante nulla (nessuna porzione di sezione è compressa) anche se una funzione esterna dovesse chiamare risult_compr() in queste condizioni.

Seconda funzione, al solito per prima il prototipo e poi la funzione vera e propria:

Code: [Select]
struct risultante_n risult_traz(struct armature_sezione,float,float,float,struct deform_ultime_sezione);
Code: [Select]
/* Dati di ingresso della funzione ------------------------ */
/* ymax=massima ordinata della sezione in cls               */
/* yamin=minima ordinata delle armature                     */
/* yn=ordinata asse neutro                                  */
/* epsa=deformazione lembo più alto della sezione           */
/* epsb=deformazione lembo più basso della sezione          */
struct risultante_n risult_traz(struct armature_sezione armc,float ymax,float yamin,float yn,struct deform_ultime_sezione deform)
{
 int register k;
 float y,dx,def,pressione,forza,scx=0.0,scy=0.0;
 struct risultante_n risult;
 
 risult.n=0.0; risult.x=0.0; risult.y=0.0;
 /* Procede con le armature in trazione */
 for (k=0;k<=armc.numarm-1;k++)
     {
      if (armc.y[k]>yn) continue;
      def=deform.epsa+(deform.epsb-deform.epsa)*(ymax-armc.y[k])/(ymax-yamin);
      pressione=-elast_plast_indef(fabs(def))*fyd;
      forza=pressione*armc.af[k];
      risult.n+=forza;
      scx+=forza*armc.y[k];
      scy+=forza*armc.x[k];
     }
     
 if (risult.n!=0)
    {
     risult.x=scy/risult.n;
     risult.y=scx/risult.n;
    }

 return(risult);
}

Nel caso in cui nessuna barra fosse in trazione il controllo if (armc.y[k]>yn) continue; fa si che il valore di risult.n rimanga nullo così come lo si è inizializzato, facendo restituire alla funzione un valore corretto (è chiaro, se nessuna barra è in trazione la risultante di trazione è nulla).

Una sola osservazione. La variabile def assume sempre valore negativo (una convenzione che abbiamo definito precedentemente, quando la deformazione è di trazione). Dalla formula non si evince immediatamente, poiché manca in essa la variabile yn, ma quest'ultima è dentro epsa ed epsb (con il loro effettivo segno). Pertanto per il calcolo del fattore alfa con la funzione elast_plas_indef() ho introdotto il parametro def con il suo valore assoluto, in quanto la funzione, per come è stata scritta nella parte 8, restituirebbe un valore di alfa non corretto con valori negativi della deformazione. Il segno meno viene però introdotto nel prodotto per il calcolo della variabile pressione. Quindi alla fine il valore della variabile risult.n è negativo.
Questa precisazione è utile quando sommeremo le risultanti di trazione e compressione per stabilire l'equilibrio nella sezione.

Per il momento mi fermerei qui. Nella prossima parte la funzione di ricerca della effettiva posizione dell'asse neutro che rispetta l'equilibrio. Infine nella parte successiva ancora altra funzione  che dovrebbe consentire di trovare tutte le doppiette di valori mx-my che determinano la agognata “fetta di salame”.
Insomma una serie di scatole cinesi una dentro l'altra (ed io sono partito dalle più piccole e sto andando verso le più grandi).
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 09 May , 2011, 23:18:44 PM
Parte 12

La determinazione dell'asse neutro
Adesso bisogna scrivere una funzione che, utilizzando tutte le altre già riportate, sia in grado di identificare il corretto posizionamento dell'asse neutro, in modo che lo sforzo normale totale generato nella sezione sia pari ad un Nd sforzo normale dato.
Una volta ricavata la posizione dell'asse neutro sarà un gioco da ragazzi determinare gli mxr ed myr, momenti flettenti di rottura, avendo a disposizione anche la posizione delle risultanti dello sforzo normale della parte compressa e tesa della sezione (e queste le abbiamo perchè le funzioni finora riportate svolgono questo doppio calcolo: risultante e sua posizione nel piano x,y).
E' chiaro che la ricerca della posizione dell'asse neutro deve avvenire per via iterativa. Si stabilisce una posizione dell'asse neutro, si ricavano le risultanti di compressione e trazione, e si controlla che la loro somma algebrica sia pari ad Nd. Se così non è si sposta l'asse neutro e si prova nella nuova configurazione geometrica.
Ovviamente bisognerà rendere intelligente una simile ricerca, senza sprecare inutilmente la potenza dell'elaboratore, considerando poi che la posizione effettiva dell'asse neutro andrebbe da +∞ a -∞.

Come al solito non invento nulla, ed ho implementato un meccanismo banale, una ricerca della posizione dell'asse neutro “a passo variabile”. Sono arci sicuro che esistono dei metodi migliori di quello che propongo, e su questo attendo fiducioso.

Con un semplice esempio vi spiego in cosa consisterebbe il metodo “a passo variabile”.
Immaginiamo che Nd sia 10000 e che da un primo tentativo di posizionamento dell'asse neutro, la somma algebrica di N compressione ed N trazione nella sezione sia pari a 7000.
Risulta evidente che bisogna aumentare la parte compressa di cls per arrivare ad Nd, modifico pertanto il posizionamento dell'asse neutro, posizionandolo più in basso di una quantità “delta”. Da questa nuova posizione, ricalcolando il tutto ottengo una risultante nella sezione di 11000. Ecco quindi che avendo superato Nd mi accorgo che la posizione effettiva dell'asse neutro si trova in mezzo al tratto “delta”. A questo punto riduco il passo “delta” (ad esempio della metà, ad un terzo, ecc.) e “torno indietro” sui miei passi (lo inverto di segno), ed ogni volta che accade che la differenza tra Nd ed N calcolato della sezione vari di segno riduco ulteriormente il passo “delta” di variazione dell'asse neutro (ed il suo segno). Il tutto fino ad ottenere una differenza minima tra Nd ed N calcolato, oppure un passo delta realmente microscopico.
La funzione in questione deve restituire i due valori di momento resistente ricavati. Ecco quindi nascere l'esigenza della ennesima struttura dati:

Code: [Select]
struct risultante_n_finale
{
 struct risultante_n ncf; /* Risultante degli sforzi di compressione nella sezione */
 struct risultante_n ntf; /* Risultante degli sforzi di trazione nella sezione */
};

Ed ecco infine la funzione che implementa questo meccanismo, con l'immancabile prototipo:

Code: [Select]
struct risultante_n_finale determina_asse_neutroSLU(struct poligono_sezione *,struct armature_sezione,float);
Code: [Select]
struct risultante_n_finale determina_asse_neutroSLU(struct poligono_sezione *polic,struct armature_sezione armc,float Nd)
{
 int register k,np;
 int npm;
 float ymax=-1000000.0,yamin=+1000000.0,yn,ntot,delta=10;
 struct risultante_n_finale nfin;
 struct deform_ultime_sezione deform;
 struct risultante_n nc,nt;
 
 /* Per prima cosa determina ymax della sezione */
 for (np=0;np<=4;np++)
     {
      for (k=0;k<=polic[np].numv-1;k++)
          {
           if (polic[np].y[k]>ymax) { ymax=polic[np].y[k]; npm=np; }
          }
     }
 /* Poi determina yamin tra tutte le armature */
 for (k=0;k<=armc.numarm-1;k++)
     {
      if (armc.y[k]<yamin) yamin=armc.y[k];
     }
 /* Quindi definisce un primo posizionamento dell'asse neutro */
 yn=yamin+0.8*(ymax-yamin);
 
 /* Inizia il ciclo iterativo alla ricerca della effettiva posizione dell'asse neutro */
 do
  {
   deform=calcola_deform_ultime(polic,ymax,npm,yamin,yn);
   /* Calcola lo sforzo normale nella parte compressa della sezione */
   nc=risult_compr(polic,armc,ymax,yamin,yn,deform);
   nt=risult_traz(armc,ymax,yamin,yn,deform);
   ntot=nc.c+nt.n;
   
   if (delta*(Nd-ntot)>0.0 && fabs(Nd-ntot)>1.0) { delta=-delta/5; yn+=delta; continue; }
   if (fabs(Nd-ntot)>1.0) yn+=delta;
  }
 while (fabs(Nd-ntot)>1.0 && fabs(delta)>1e-6)
 
 nfin.ncf.n=nc.n; nfin.ncf.x=nc.x; nfin.ncf.y=nc.y;
 nfin.ntf.n=nt.n; nfin.ntf.x=nt.x; nfin.ntf.y=nt.y;

 return (nfin);
}

Come si vede la parte iterativa (il do.....while) è contenuta in pochissime righe (visto che il grosso del lavoro viene svolto comunque da risult_compr e risult_traz e tutte le altre funzioni ad esse collegate, precedentemente esposte). E che la parte “a passo variabile” è contenuta in un solo rigo che merita qualche spiegazione.
La variabile delta è la quantità di cui si alza o si abbassa l'asse neutro. Essa oltre a diminuire via via nelle varie iterazioni deve anche poter cambiare di segno.
Pertanto ci si potrà trovare in queste condizioni:
1) delta è positiva (significa che l'asse neutro si alza via via facendo diminuire lo sforzo normale di compressione); se l'espressione (Nd-ntot) è anch'essa positiva vuol dire che ntot deve aumentare, e quindi delta, oltre a diminuire in valore deve anche modificare il proprio segno (deve aumentare la parte compressa della sezione ovvero abbassarsi l'asse neutro).
2) delta è negativa (significa che l'asse neutro si abbassa ad ogni iterazione); se l'espressione (Nd-ntot) è anch'essa negativa vuol dire che ntot deve diminuire, e quindi delta diminuirà e si modificherà di segno (deve diminuire la parte compressa della sezione ovvero alzarsi l'asse neutro).

Badate bene che questo è vero anche se Nd è uno sforzo di trazione e quindi di segno negativo.

Ed alla fine sono partito da un delta da 10 cm in 10 cm che via via diminuisce di 5 volte (quindi 2 cm, poi 0.4 cm, ecc.).
E questo è tutto per adesso. Alla prossima ed ultima parte.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 11 May , 2011, 18:36:05 PM
Il metodo iterativo illustrato può risultare lento. Consiglio il metodo della bisezione partendo dai valori limite dell'asse neutro corrispondenti agli assetti 2 e 3 del grafico da me precedentemente postato. A partire dalle suddette 2 deformazioni ultime si ottengono i corrispondenti valori dell'asse neutro (immediati) e degli sforzi normali. Se lo sforzo normale di progetto ricade tra i 2 sforzi normali limite vuol dire che il pivot (centro di rotazione della curvatura) è la fibra compressa superiore con def. 0,0035. Si calcola lo sforzo normale con un asse neutro medio dei due assi neutri limite e si controlla in quale dei 2 intervalli ricade lo sforzo normale corrispondente. Si ripete lo stesso procedimento nell'intervallo definito dall'asse neutro medio e da quello individuato dallo sforzo normale.
Bastano 10-15 tentativi per avere un'appossimazione su N di circa 30 kg.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 11 May , 2011, 18:54:23 PM
A dire il vero avevo pensato inizialmente di posizionare l'asse neutro di 1° tentativo in corrispondenza dell'assetto 2.
Poi però riflettendo, ho pensato, iterazione per iterazione, cosa cambia?

Io non saprei dirti il numero di iterazioni per arrivare al mio 1 kg di tolleranza che avrei imposto. Immagino che molto dipenda dalla fortuna (ovvero da quanto parta prossimo al valore "vero" dell'asse neutro).
In ogni caso a livello concettuale non ci sono differenze marcate tra quanto proponi (ogni volta esamino cosa succede dividendo a metà la variabile che ho chiamato"delta"), e quanto ho proposto io, ovvero di dividere per 5 tale valore iniziale e "spazzolare" in questo range.

Ciò che non mi è chiaro dalla tua spiegazione è perchè di "auto-limiti" all'assetto 2-3. Ciò che proponi non sarebbe valido anche per gli altri possibili assetti?
O viceversa, se non ricado in quell'ambito, che dovrei fare?
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 11 May , 2011, 19:28:54 PM
Se ad esempio lo sforzo normale di progetto è superiore a quello dell'assetto 3 occorre cambiare il pivot di rotazione della sezione (utilizzare cioè quello posto a 3/7 circa dell'altezza della sezione con epsilon =0.002)  per ottenere la posizione dell'asse neutro da considerare nella definizione della configurazione della sezione in base alla quale calcolare il nuovo valore di N.
In generale, però,  i valori realistici di progetto dello sforzo normale per un pilastro ricadono tra gli assetti 2 e 3 per cui potrebbe essere sufficiente limitare il calcolo a questo ambito (definito appunto dali 2 valori limite di N prima definiti) semplificando di molto il calcolo in quanto si utilizzerebbe sempre lo stesso pivot. 
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 11 May , 2011, 22:36:20 PM
Caro Renato, mi hai fatto tornare indietro nel tempo.
Quando ragazzotto di periferia mi recavo allo sportello della banca con un assegno in mano nella speranza che me lo cambiassero senza tante storie.
Possibile mai che io non sia mai riuscito nell'impresa senza inconvenienti?
Ogni volta il cassiere, mentre lo guardavo attonito, mi costruiva una montagna virtuale di impedimenti e di eccezioni per cui io, con quell'assegno, con quella richiesta, mi trovavo nel posto sbagliato al momento sbagliato, ecc.
Salvo poi, improvvisamente, e con un guizzo degno di fantastisca scuola attoriale, ecco illuminarsi in volto, e TROVARE la soluzione che mi avrebbe consentito di fare finalmente l'operazione, e che effettivamente faceva. Grazie, grazie, grazie, rispondevo.
Ma un pò di amaro in bocca queste scene me lo lasciavano. Perchè se la soluzione c'è, perchè fare tante storie?
Si è trattato di un rodaggio comunque istruttivo. Nella vita ho poi avuto modo di incontrare parecchi "costruttori" di montagne, per fortuna sempre con traforo incorporato.

Per tornar seri. Condivido ciò che dici. Se sto tra la posizione limite 2 e la posizione limite 3, ecco che il problema si semplifica assai. E condivido anche che nel 90% dei casi "reali" è proprio in quell'ambito che mi troverò.
Ma tu devi scusarmi se mi permetto. Io posso darti ragione una volta, non tutte le volte.
Specie se in una di queste volte, poi, ti contraddici.
Proprio tu, quando nella parte 8 ho parlato della configurazione deformata a rottura della sezione, mi hai bacchettato dicendomi che mi ero limitato ad una sola delle possibile configurazione di rottura.
Ed allora ti ho dato assolutamente ragione. Tanto è vero che nella parte 10 ti ho risposto, partendo proprio dalla tua osservazione, sviluppando (a meno che non ci siano errori) tutte le possibilità che possono riscontrarsi.
Pertanto, proprio perchè il programma che propongo è generico e generale, posso solamente rammaricarmi che se certe ipotesi si verificassero le cose si semplificano. Ma io devo (e così ho fatto) considerare anche le cose che si possono verificare solamente nel 10% del casi.

E quindi stavolta non ti do ragione.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 11 May , 2011, 23:19:19 PM
Non sto dicendoti di limitare il campo di applicazione del programma al settore compreso tra l'assetto 2 e 3.
Ma penso che negli intervalli 1-2 e 3-4 non sia comodo far riferimento, per le iterazioni, alla posizione dell'asse neutro che possono partire da valori tendenti all'infinito. Personalmente delimito i campi e definisco la deformazione da iterare utilizzando i valori delle curvature (non dell'asse neutro) che hanno sempre valori finiti. Cmq alla fine quello che conta sono i risultati che possono essere facilmente controllati anche nelle zone con asse neutro molto distante dalla sezione. A dopo...
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 12 May , 2011, 17:38:37 PM
Parte 13

Il dominio di rottura - finalmente
Siamo praticamente alla fine di questa esposizione. Manca infatti solamente la funzione che materialmente determini il dominio di rottura della sezione per dato Nd.
Come si era detto proprio ad inizio trattazione delle verifiche SLU, tale dominio verrà ricavato da coppie di mrx,mry calcolate non già facendo ruotare l'asse neutro, ma facendo ruotare fittiziamente la sezione stessa.
In questo modo sarà possibile sfruttare tutte le routine che ho via via proposto e che appunto avevano questa impostazione, ovvero di considerare orizzontale l'asse neutro (e con porzione compressa della sezione al di sopra dell'asse neutro).
Chi ha avuto la voglia di seguirmi fin qui, ed è stato particolarmente attento, avrà notato che tutte le funzioni che dovevano “manipolare” i dati geometrici della sezione oppure delle armature non sono state scritte per operare direttamente sulle strutture dati di input della sezione stessa (poli ed arm), ma esse accettano in ingresso sempre le strutture dati polic e armc dove la c finale sta per “copia”. Ciò consente di dare in pasto alle varie funzioni le coordinate della sezione ruotata rispetto all'input dell'utente. E' chiaro ovviamente che quando le funzioni restituiscono le coordinate della risultante di sforzi normale di compressione o trazione, queste ultime devono essere riportate al primigenio sistema di riferimento per determinare i momenti di rottura (che ad unico sistema devono essere riferiti).

Ci servono quindi le formule per la trasformazione delle coordinate dei vertici e delle armature costituenti i vari poligoni della sezione.
Nell'immagine inferiore, lo schema geometrico dell'operazione più generale possibile, ovvero la roto-traslazione:

(http://s4.postimage.org/1210tefhg/Sezione_generica4.png) (http://www.postimage.org/)

Il problema è risolvibile per via geometrica-trigonometrica e permette di ricavare le “nuove” coordinate X,Y dei vertici (in maiuscolo), semplicemente conoscendo le coordinate della origine del nuovo sistema di riferimento, rispetto al vecchio, e la rotazione degli assi.
Le formule generali per la roto-traslazione sono le seguenti:

X= x*cos(alfa)+y*sen(alfa)-x0
Y=-x*sen(alfa)+y*cos(alfa)-y0


Se l'operazione è di semplice rotazione del sistema di riferimento ecco che nelle formule di cui sopra scompaiono i fattori x0 ed y0 solamente.

Quindi propongo l'ennesima struttura dati:

Code: [Select]
struct dominio_rottura
{
 float nd;
 float mrx[24];
 float mry[24];
};

Infine la funzione, preceduta dal solito prototipo:

Code: [Select]
struct dominio_rottura calcola_dominio_SLU(float);
Code: [Select]
struct dominio_rottura calcola_dominio_SLU(float Nd)
{
 int register k,np,step;
 struct poligono_sezione polic[5];
 struct armature_sezione armc;
 struct risultante_n_finale nfin;
 struct dominio_rottura dom;
 float xc,yc,xt,yt;

 dom.nd=Nd;

 for (step=0;step<=23;step++)
     {
      float alfa=step*0.261799; /* alfa in radianti – 0.261799=15° */
      float c=cos(alfa),s=sin(alfa);

      /* Prima copia la sezione in altra struttura dati e poi la ruota di alfa */
      for (np=0;np<=4;np++)
          {
           polic[np]=poli[np];
           for (k=0;k<=poli[np].numv-1;k++)
               {
                polic[np].x[k]= poli[np].x[k]*c+poli[np].y[k]*s;
                polic[np].y[k]=-poli[np].x[k]*s+poli[np].y[k]*c;
               }
          }

      /* Copia le armature in altra struttura dati e poi le ruota di alfa */
      armc=arm;
      for (k=0;k<=arm.numarm-1;k++)
          {
           armc.x[k]= arm.x[k]*c+arm.y[k]*s;
           armc.y[k]=-arm.x[k]*s+arm.y[k]*c;
          }

      /* Chiama la funzione per definire l'asse neutro della sezione ruotata di alfa */
      nfin=determina_asse_neutroSLU(polic,armc,Nd);

      /* Ripristina il sistema di riferimento delle risultanti */
      c=cos(-alfa); s=sin(-alfa);
      xc= nfin.ncf.x*c+nfin.ncf.y*s;
      yc=-nfin.ncf.x*s+nfin.ncf.y*c;

      xt= nfin.ntf.x*c+nfin.ntf.y*s;
      yt=-nfin.ntf.x*s+nfin.ntf.y*c;

      dom.mrx[step]=nfin.ncf.n*(yc-yg)+nfin.ntf.n*(yt-yg);
      dom.mry[step]=nfin.ncf.n*(xc-xg)+nfin.ntf.n*(xt-xg);
     }

 return (dom);
}

A parte l'ingresso con unico parametro, Nd, da segnalare l'utilizzo delle variabili globali xg ed yg, baricentro della sezione omogenea (che ho calcolato precedentemente senza considerare la presenza di armature nella sezione). Polo da cui ricavare i momenti di rottura.

E questo sembrerebbe tutto. Nel senso che effettivamente la funzione restituisce 24 punti del dominio di rottura della sezione per dato Nd (mi è piaciuto così, ma nulla toglie di rendere modificabile da un ipotetico utente questa assunzione).
Al solito la funzione chiamante (ancora più “grande” delle scatole una dentro l'altra che finora abbiamo visto) potrà eseguire questa funzione tutte le volte che serve per tutte le combinazioni di carico cui è sottoposta la sezione, o magari procedere ad Nd via via crescenti per ottenere più “fette di salame” sovrapposte in modo da poter diagrammare in 3D la “safe ball” come la chiamano gli inglesi, ecc.

Ma proprio a questo proposito dobbiamo chiarire un ultimissimo aspetto, accennato in qualche commento, ma ancora da affrontare. Ovvero che non tutti gli Nd sono “buoni” e che non da tutti è possibile ricavare la “fetta di salame”. Ci saranno in effetti un valore di sforzo normale di compressione ed uno di trazione “limite” oltre i quali il dominio di rottura non esiste. Pertanto la funzione che chiama calcola_dominio_SLU dovrà prima capire se Nd è “buono” o meno.
L'Nd massimo di trazione, oltre il quale la sezione non è in grado di spingersi, è dato dal prodotto dell'area complessiva delle barre di armature per fyd. Viceversa l'Nd massimo di compressione è dato dalla sommatoria di tutte le aree dei singoli poligoni per il rispettivo fd, e dall'area totale della barre per fyd, e questo poiché al minimo la sezione è uniformemente deformata del 2 per mille – alcuni contorni di cls particolarmente “buono” come abbiamo visto possono giungere a valori di deformazione limite più alti (vedi formule di normativa) – e con quella deformazione l'acciaio con modulo elastico 2100000 daN/cm² è già snervato (infatti 3913/2100000=0.00186).
Ma in ogni caso e per ogni evenienza è bene fare qualche controllo visto che i numeri possono anche essere differenti da quelli previsti (fyd maggiori di acciai migliori).

In pratica la parte di programma che “chiama” calcola_domino_SLU dovrebbe prima determinare Nd-trazione limite ed Nd-compressione limite, in modo da non “disturbare” la funzione se l'Nd della combinazione è al di fuori di questi limiti. Ovvero:

Code: [Select]
/* Definisce il massimo valore nd di compressione per la sezione */
/* Determina dapprima il minimo valore di epsc0 tra tutti i poligoni della sezione */
epsc0min=1000.0;
for (np=0;np<=4;np++) if (poli[np].epsc0<epsc0min) epsc0min=poli[np].epsc0;

/* Quindi determina l'area e la forza di ogni singolo poligono */
nd_comprlim=0.0;
for (np=0;np<=4;np++)
    {
     area=0.0;
     for (k=0;k<=poli[np].numv-1;k++)
         {
          if (k==poli[np].numv-1) kp1=0; else kp1=k+1;
          area+=(poli[np].x[kp1]-poli[np].x[k])*(poli[np].y[kp1]+poli[np].y[k])/2;
         }
      alfa=parabola_rett(epsc0min,poli[np].epsc0);
      nd_comprlim+=area*alfa*poli[np].fd;
    }
/* Inserisce anche le barre di armatura */
for (k=0;k<=arm.numarm-1;k++)
    {
     alfa=elast_plast_indef(epsc0min);
     nd_comprlim+=arm.af[k]*alfa*fyd;
    }

/* Definisce il massimo valore di nd di trazione per la sezione */
nd_trazlim=0.0;
for (k=0;k<=arm.numarm-1;k++) nd_trazlim-=arm.af[k]*fyd;

/* Ed infine chiama la funzione di costruzione del dominio per ogni combinazione */
for (k=0;k<=numcomb-1;k++)
    {
     if (soll[k].tipo!=3) continue;
     if (soll [k].n>nd_trazlim && soll[k].n<nd_comprlim) dominio=calcola_dominio_SLU(soll[k].n);
     else /* Messaggio di avviso, semplice salto della combinazione, quel che si vuole */
    }

Come si vede ho sempre utilizzato funzioni già definite precedentemente che mi hanno consentito di tenere conto di tutte le possibilità che possano verificarsi. Per le armature compresse ho fatto calcolare il valore alfa dalla funzione elast_plast_indef (ma dovrebbe essere sempre 1.0) inserendo come parametro in ingresso il valore di epsc0min nel caso in cui esso fosse più piccolo del valore di plasticizzazione dell'acciaio (cosa che non ho fatto per le armature tese, per ovvie ragioni).
Per la costruzione del dominio di rottura faccio in modo che vengano processate le sole combinazioni SLU (vedi il controllo di soll[k].tipo che deve valere 3 per proseguire nella elaborazione del ciclo, soll che è una struttura dati definita precedentissimamente) ed inoltre che il valore di n della combinazione stia all'interno dei valori limite.

Più o meno è tutto.
E' arrivato il momento di dire davvero fine a tutta questa trattazione. Non so voi, ma io mi sento pronto adesso, dopo i dieci anni che vi dicevo all'inizio, di rimetterci le mani e completare il programma.

Sono consapevole di aver lasciato qualcosa per strada (ad esempio la possibilità, mai sfruttata, di dichiarare il tipo di diagramma a rottura di un singolo poligono, oppure la possibilità di reagire anche a trazione per le verifiche SLU, le fasi costruttive, ecc.). D'altra parte spero non ci siano errori nelle varie routine proposte. In ogni caso mi impegno fin da adesso a correggerle nel caso in cui mi accorgessi di qualcosa che non funziona.

Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 02 August , 2011, 23:03:59 PM
Penso di fare cosa gradita nel pubblicare in unico file tutte le funzioni e gli spezzoni di codice che ho pubblicato lungo il topic.

Il file .zip in allegato contiene un header file (estensione .h) in cui sono dichiarati tutte le strutture dati utilizzate nei listati, e tutti i prototipi delle funzioni. Nel file con estensione .cpp sono invece contenuti i "corpi" delle varie funzioni.

Si tratta in ambedue i casi di normalissimi file ASCII di testo.

In teoria bastano questi 2 file e la dichiarazione di qualche variabile globale, in un qualsiasi vostro programma in C, per affrontare la verifica a presso-tenso flessione deviata, sia SLE che SLU, di sezioni di qualsivoglia geometria.

Ho cercato di essere quanto più esaustivo nei commenti alle varie linee di codice. Ovviamente gli aspetti teorici sono stati sviluppati nel presente topic e ad essi si riporta per la comprensione migliore di cosa ogni singola funzione calcola e perchè.

Ovviamente spero non ci siano magagne (fino a stasera ho dovuto sostituire un > con un >= per evitare un pernicioso overflow). Se qualcosa in tal senso dovesse spuntare mi impegno, come ho fatto prima a modificare e risolvere.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Cris on 02 August , 2011, 23:57:57 PM
Ringraziamento istituzionale a nome del forum....  :)
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: xalf70 on 03 August , 2011, 09:03:30 AM
Grande zax.
di programmazione in C non ne capisco niente, ma dai due file vedo che hai fatto un grande lavoro e soprattutto lo hai condiviso.

grazie  :clap:
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: _automa_ on 03 August , 2011, 09:48:08 AM
Grande zax.
di programmazione in C non ne capisco niente, ma dai due file vedo che hai fatto un grande lavoro e soprattutto lo hai condiviso.

grazie  :clap:

mi associo a entrambi i concetti, ringraziemnto epr condivisione e assoluta ignoranza per tutto cio' che va oltre il turbo pascal ...
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: BidiBLU on 03 August , 2011, 10:04:14 AM
grazie zax per aver condiviso il tuo sapere e il tuo lavoro

Bidi :-)
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Gilean on 03 August , 2011, 23:17:23 PM
grazie zax per aver condiviso il tuo lavoro....che ne dici di inserirlo nella sezione download del sito in modo che sia piu' visibile ed indicizzabile dai motori di ricerca?
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 03 August , 2011, 23:56:49 PM
Gilean ci avevo pensato, ma devo purtroppo declinare il tuo invito.

Perchè io non voglio scindere le due cose. Il listato è il prodotto finale - tra l'altro parziale, scaturito sostanzialmente come risposta ad un desiderio di afazio, che me lo aveva espressamente richiesto - ma molto più importanti sono i ragionamenti, giusti o sbagliati, che ci stanno dietro. E questi ragionamenti stanno scritti qui. In questo topic.

Scindere, separare le due cose, significa solamente rendere la pappa pronta al downloader di turno che senza la "necessità" di capire quello che fa, copierà e incollerà quanto scaricato da qualche parte, senza capirlo, senza interpretarlo, senza modificarlo (perchè non saprebbe dove metterci le mani), senza impegnarsi, senza ......

Ok. Mi hai capito.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Gilean on 29 October , 2011, 12:49:40 PM
potresti benissimo indicare nella descrizione del download il link a questo post.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: marchionili on 05 November , 2011, 17:53:42 PM
Discussione interessantissima. Ho letto solo l'introduzione del tread e vorrei capire le funzioni dello script. Molto brevemente il codice che hai postato permette di verificare una sezione qualsiasi in c.a.o. e c.a.p. sottoposta alle 6 caratteristiche di sollecitazione, allo SLU e allo SLE, con un numero illimitato di buchi, di vertici, ecc...? Il programma é completo? Su cosa bisognerebbe ancora lavorare?

Inoltre per poter capire come usare il tuo codice bisognerebbe conoscere il C# C++ (quale?). Io fino ad ora ho sempre usato matlab ma vorrei passare ad un linguaggio di programmazione più completo. Secondo te se mi leggo una di queste guide (per favore dimmi quale)
http://programmazione.html.it/guide/ (http://programmazione.html.it/guide/)
posso arrivare a comprendere il listato che hai postato su questo forum?
Un amico a cui ho chiesto mi ha detto che il C é un ottimo linguaggio e che JAVA é meglio ma che entrambi hanno un grosso difetto: sono difficilissimi da imparare ad usare e non permettono la creazione di interfaccie grafiche in modo agevole in stile visual basic. Mi piacerebbe sentire un tuo parere in merito a questo aspetto e magari qualche consiglio per arrivare a comprendere il tuo codice e se possibile contribuire a progetti importanti come questi e altri trattati su questo forum.

Grazie infinite per questo splendido lavoro a nome mio e di tutto il forum
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 05 November , 2011, 19:16:08 PM
Piano.....piano.....non esageriamo.

Intanto: Verifica di sole sezioni in c.a. e soltanto con N, Mx ed My
Quindi niente torsione, nè taglio, retto o deviato che sia.

Rispondo a te, così come ad altri che me lo hanno chiesto in MP. In ogni caso ne avevo fatto cenno nel corso del topic.
Il codice postato è puro ANSI C, e dovrebbe poter essere compilato da qualsiasi compilatore C, C++, C#, in qualsiasi ambiente (Linux, Windows, Os, ecc.). Come da commenti nei file stessi, è necessario dichiarare le variabili globali, di input, utilizzate all'interno delle varie funzioni.
In ogni caso ritengo, vista la semplicità delle istruzioni interne alle singole funzioni che una eventuale "traduzione" in altri linguaggi sia sempre possibile, con una semplice modifica di sintassi.
Forse però, non saprei se per tutti i linguaggi sono previste le strutture dati, che io, per consentire un rapido passaggio di variabili tra le varie funzioni, ho utilizzato a iosa.

Ciò detto le funzioni che trovi all'interno dello zip sono semplicemente il "motore".
Con questa metafora, ci dovrà essere qualcuno che dovrà costruirci attorno carrozzeria, volante, trasmissione, ruote.
Uscendo fuor di metafora bisognerà costruire tutta l'interfaccia di inserimento dei dati di input (ma potrebbe trattarsi anche di un semplice file di testo che viene letto assegnando le variabili che servono), tutta l'interfaccia di presentazione dei risultati, sia a video che eventualmente su file o direttamente in stampa.
L'ho già detto. Non è poca cosa.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: marchionili on 06 November , 2011, 16:55:16 PM
Ma questo software qui:
http://ingegneriaforum.it/index.php?action=downloads;sa=view;down=327 (http://ingegneriaforum.it/index.php?action=downloads;sa=view;down=327)
é un altro programma fatto da gilean oppure é opera tua?

Se mi aiuti a capire il codice e come lavorare con il C provo ad aggiungere la torsione, il taglio e sucessivamente anche la precompressione.

Ovviamente solo a condizione che la filosofia resti la stessa: codice libero sempre e comunque.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: mg on 07 November , 2011, 09:51:00 AM
Ciao Zax,

Non sono un grande programmatore e quindi ti chiedo consiglio. Premettendo che non ho ancora dato un occhio al codice, ma mi chiedevo se secondo te è possible creare una DLL che poi sia possibile inserire in qualunque programma scritto anche in C# o VB.net. ?
Quel che so io è che di certo se creo, ad esempio, una classe in VB.net con dei metodi e la compilo creando una DLL poi, inserendo tale DLL come risorsa di un programma C# posso utilizzare i metodi della classe programmati in VB.net. . Pensi sia possibile fare lo stesso partendo dal C?

MArco
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: marchionili on 13 November , 2011, 22:40:16 PM
Ho visto solo le prime 2 lezioni di Visual C# e non sono esperto di questo linguaggio però anche io ho lo stesso interesse di mg: vorrei prendere il tuo codice e creare un'interfaccia grafica per esso. Non capisco perché dici che "non é poca cosa". Si tratta di mettere una RichTextBox per le coordinate dei punti della figura, una serie di ListBox per i parametri dei materiali e per le coordinate dei ferri ed un pulsante calcola.

Credo che la cosa più sicura e corretta sia quella di tradurre C++ con C#.

A presto e grazie
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 14 November , 2011, 11:44:29 AM
Io non ho detto che si tratti di una cosa "difficile" in se. Ho semplicemente detto che si tratta di una cosa non banale, di quelle che per quanto non complicate alla fine ti fanno perdere parecchio tempo.
Ma se tu vuoi lanciarti, non puoi che avere il mio assoluto ed incondizionato incoraggiamento.

Se tu utilizzi un compilatore C++ sono arcisicuro che il listato ver_SLE_SLU.cpp non ha bisogno di nessuna traduzione o correzione.
Dovrai semplicemente inserire tale file tra quelli del tuo progetto (di solito nei compilatori avrai nel menù una voce Project ed una sotto opzione Add), ed 'alimentarlo' con i dati di input (le strutture dati che nei commenti iniziali del file dico che vanno dichiarate).
Ancor di più, senza passare da Project ecc. Copi&Incolli tutto il listato nel tuo, ed hai risolto.
Fai attenzione perchè alla fine del listato (ma è evidenziato da un commento, spero abbastanza visibile), ci sono delle funzioni 'false' che hanno l'unico scopo di far capire come materialmente utilizzare i 'servizi' che le varie funzioni svolgono.
Ti saranno comunque utili per scrivere il codice che dovrà essere eseguito alla pressione del tuo bottone 'Calcola'.

Andando al C# ritengo che non cambi nulla. Ossia un compilatore C# dovrebbe essere in grado di compilare codice C tranquillamente. Ma qui dovrebbe intervenire Gilean che dovrebbe saperne più di me.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Gilean on 15 November , 2011, 09:34:18 AM
il codice c# e' un codice di programmazione orientato agli oggetti. Pertanto ogni metodo, ogni proprietà risiede all'interno di una classe o di una interfaccia. Ti invito a guardati per bene le mie videolezioni per capire qualcosa di piu'.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: marchionili on 16 November , 2011, 22:55:50 PM
Vi ringrazio molto e quello che farò lo metterò a disposizione della comunità. Il problema é che le lezioni di gilean sono per il c# mentre il codice di zan in c++ e io ho bisogno di entrambe le cose...  :( La domanda che mi sorge spontanea é questa: con le lezioni di gilean sarò in grado di capire quello che ha scritto zax?  :(

Inoltre se io scrivo in c# zax potrà capire il mio script e a sua volta lavorarci su? Io vorrei riprodurre il prodotto di zax su visual c# e non su visual c++. Il c++ ha il fattore positivo di funzionare senza framework quindi può essere usato anche in ambiente linux mentre c# no ma quest'ultimo é più semplice, più logico e più moderno (é nato nel 2002 e non nel 1983!).
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 17 November , 2011, 13:03:35 PM

Inoltre se io scrivo in c# zax potrà capire il mio script e a sua volta lavorarci su? Io vorrei riprodurre il prodotto di zax su visual c# e non su visual c++. Il c++ ha il fattore positivo di funzionare senza framework quindi può essere usato anche in ambiente linux mentre c# no ma quest'ultimo é più semplice, più logico e più moderno (é nato nel 2002 e non nel 1983!).


una serie di dubbi uno sull'altro o uno dietro l'altro? bho!!
io consiglierei di tradurre il codice C++ ed il codice C# della borland ed anche il codice visualC++ e C# in un linguaggio piu' intellegibile, per esempio il visualEgiziano.
In questo modo basta che zanx si fa tradurre da visualEgipt in manualSiciliano e la cosa è fatta. Capirà certamente. Poi per il percorso inverso si fara ricorso ad apposite lezioni visuali di VisualGil. Coraggio, ci sono concrete speranze di perdere di vist il visual.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Gilean on 17 November , 2011, 16:44:18 PM
Vi ringrazio molto e quello che farò lo metterò a disposizione della comunità. Il problema é che le lezioni di gilean sono per il c# mentre il codice di zan in c++ e io ho bisogno di entrambe le cose...  :( La domanda che mi sorge spontanea é questa: con le lezioni di gilean sarò in grado di capire quello che ha scritto zax?  :(

Inoltre se io scrivo in c# zax potrà capire il mio script e a sua volta lavorarci su? Io vorrei riprodurre il prodotto di zax su visual c# e non su visual c++. Il c++ ha il fattore positivo di funzionare senza framework quindi può essere usato anche in ambiente linux mentre c# no ma quest'ultimo é più semplice, più logico e più moderno (é nato nel 2002 e non nel 1983!).


Hai le idee un po confuse, come detto ironicamente da afazio (visualGil? :D).

Ad ogni modo ti consiglio qualche ricerca con google alla voce "porting c++ in c#"

http://msdn.microsoft.com/it-it/magazine/cc301520(en-us).aspx (http://msdn.microsoft.com/it-it/magazine/cc301520(en-us).aspx)
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 17 November , 2011, 20:04:19 PM
il visualGil? Non sai cosa è?
Trattasi di famosa raccolta in forum di libreria visuale.

Porting? Qui non trattasi di porting ma bensi di capire prima di tutto l'algoritmo, cioè tutto il papello (che io ho conservato) di post di spiegazioni date da zax, che illustrato la teoria e l'immediata applicazione. Se poi un costrutto, una variabile strutturata, non esiste in D++, oppure ha sintassi differente in visualFrancoeCiccio deve pensarci il francoecicciologo a trovare soluzione alternativa.
Ieri sera ho sentito di sguincio la notizia, in un tg, che hanno istituito un corso di laurea in Scienza della Gioia ed una delle discipline sarebbe proprio la francoeccicciologia oltre alla bangbangMaledettoWiller.
La notizia mi ha fatto ridere ed ho pensato il caporedattore di quel TG merita certamente la lauera ad honorem.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 14 April , 2012, 20:31:42 PM
E' passato quasi un anno dall'inizio di questo topic. Il numero di visitatori mi dice che gli argomenti trattati abbiano suscitato una certa attenzione.

Mi pare giusto quindi continuare a trattare altri aspetti, diciamo un po' più sofisticati, ma sempre inerenti le verifiche SLU di una sezione generica.
Mi riferisco a tutti gli aspetti relativi alla duttilità di curvatura, e dunque diagrammi momenti-curvatura, determinazione dei momenti di primo snervamento ecc.
In altro topic parallelo a questo avevo iniziato ad affrontare questi aspetti da neofita. Non che da allora io abbia fatto chissà quali passi in avanti, però anche grazie a voi ho avuto modo di chiarirmi meglio le idee.
Pertanto di seguito, sempre terra terra, sempre con un occhio puramente algoritmico, voglio continuare l'argomento.

Sulla questione curvatura, e duttilità di curvatura, che coinvolgono necessariamente concetti di confinamento più o meno condivisi dagli 'sperimentatori', vedrete, ne vedremo delle belle.

Il mio intento comunque non sarà quello di approntare il modello sofisticatissimo dell'ultimo ricercatore di grido. Starò sempre con i piedi per terra.

Unica cosa che vi chiederò è un po' di pazienza. Non sono sicuro di poter postare con grande celerità tutto quello che ho in mente di postare.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 14 April , 2012, 20:35:46 PM
Parte 14

Riprendo un discorso relativo ai diagrammi costitutivi dei materiali. Di essi avevo parlato nella parte 8.

Relativamente all'acciaio avevo implementato uno dei due diagrammi previsti dalla normativa. Il semplice “elasto-plastico indefinito”.
In effetti la norma prevede si possa adoperare anche un diagramma “elasto plastico con incrudimento”.

Avevo imbastito una piccola funzione che prevedeva sostanzialmente in ingresso la deformazione def e che, piuttosto che restituire la tensione, restituiva un valore alfa compreso tra 0 ed 1. Valore che poi nella funzione chiamante, moltiplicato per fyd dava l'effettiva tensione agente nella singola barra deformata di def.

L'aver 'confinato' in una specifica funzione questa operazione torna oggi a mio favore, perchè basta sostituire la funzione iniziale con un'altra per poter utilizzare in teoria tutti i legami costitutivi che si vogliono, anche i più bislacchi, senza modificare, se non per dettagli, gli algoritmi di calcolo più 'pesanti' e che stanno più in alto di tale funzione elementare.

La funzione iniziale era la seguente:

Code: [Select]
float elast_plast_indef(float); /* Prototipo della funzione */

float elast_plast_indef(float def)
{
 float alfa;

 if (def>=fyd/Ea) alfa=1.0;
 else alfa=def*fyd/Ea;

 return(alfa);
}

Dove appunto, superato il valore deformativo di fyd/Ea la funzione restituiva sempre e comunque il valore alfa=1.0, indipendentemente dalla deformazione in ingresso.
Se invece voglio implementare il diagramma come in figura rubata dalla normativa:

(http://s8.postimage.org/42zw6b92p/Legame.jpg) (http://postimage.org/image/42zw6b92p/)

Devo aggiungere la variabile k tra quelle gestite dalla funzione.

Vediamo meglio cosa dice la normativa in proposito.

Tale variabile è denominata “fattore di incrudimento” e definita nella stessa norma con k=(ft/fy)k ovvero valore caratteristico del rapporto tra i valori della tensione di rottura e di snervamento di un generico acciaio.
In sintesi, avendo a disposizione n provini, e determinati per ognuno, la tensione a rottura e la tensione di snervamento, il valore del rapporto ft/fy superato dal 5% dei provini sarà il valore da assegnare a k per quella specifica partita di acciaio.

Dico “per quella specifica partita di acciaio” perchè in effetti la norma non assegna a questa variabile un valore univoco. Al capitolo 11 tra i valori di controllo che consento ad un acciaio di potersi fregiare della sigla B450C si indica solamente che tale rapporto deve essere compreso tra 1.15 e 1.35
Se facciamo il semplice rapporto tra i valori nominali delle tensioni di rottura e snervamento di un acciaio B450C otteniamo 540/450=1.20, numeretto suggerito da parecchi autori.

Guardando bene il diagramma in questione però ci accorgiamo che introdurre la variabile k è necessario, ma non sufficiente. Infatti la parte post snervamento si 'impennerà' da fyd fino a k*fyd nel tratto che va da una deformazione epsyd=fyd/Ea fino a epsud.
epsud per la norma è pari al 90% della deformazione a rottura nominale. Per in B450C tale valore minimo dove essere del 7.5% e pertanto epsud=0.9*7.5=6.75%=0.0675

In definitiva, per semplici similitudini di triangoli, detta def la deformazione, il valore alfa che la nuova funzione deve restituire sarà:

se def<epsyd:   alfa=def*fyd/Ea
se def>=epsyd:   alfa=1+(k-1)*(def-fyd/Ea)/(epsud-fyd/Ea)


Facciamo diventare tutto funzione:

Code: [Select]
float elast_plast_indef(float def)
{
 float alfa;

 if (def>=fyd/Ea) alfa=1.0+(k_incr-1.0)*(def-fyd/Ea)/(epsud-fyd/Ea);
 else alfa=def*fyd/Ea;

 return(alfa);
}

Dove si è presupposto che fyd, Ea, k_incr ed epsud siano delle variabili globali.
Come si vede tutto il resto delle altre funzioni non ha necessità di nessuna variazione.
Ovviamente all'interno del programma si dovrà consentire di gestire le variabili k_incr ed epsud, per assegnarle, modificarle, ecc.

Questa funzione così modificata consente di di poter gestire entrambi i legami costitutivi previsti dalla norma. Risulta infatti banale verificare che assegnando a k_incr il valore 1.0 dal diagramma elasto-plastico con incrudimento si ricade nell'elasto-plastico indefinito.

Per adesso contentatevi di questo.

Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: g.iaria on 15 April , 2012, 12:44:34 PM
Ottimo lavoro zax.
Tempo fa io ho indagato l'effetto combinato del comportamento incrudente dell'acciaio e rammollente del cls nell'evoluzione deformativa che caratterizza la sezione per la determinazione del diagramma momento curvatura.
Premetto che ho eseguito i calcoli consideranto i valori medi delle resistenze:
fcm = fck + 8 [MPa]
fym = fyk + 30 [MPa]
k = 1.2 (rapporto di incrudimento)
eps_u = 7.5% (def. ultima dell'acciaio)
I modelli di comportamento da me adottati sono:
a) Modello tutto parabolico dell'EC2 (con tratto finale rammollente)
b) Modello bilineare dell'acciaio (con tratto plastico incrudente)
(http://s10.postimage.org/sgr8nowpx/Appunti03.jpg) (http://postimage.org/image/sgr8nowpx/)
Detto questo, le risultanze che si sono manifestate con questi due modelli sono sostanzialmente 2:
1) Se indichiamo la risultante degli sforzi di compressione come Nc = b*x*fcm*beta1, il coefficiente beta1 che determina l'entità dell'azione portata dal cls ha questa variazione in funzione della deformazione del lembo compresso di cls:
(http://s13.postimage.org/pq3t0aydv/Appunti01.jpg) (http://postimage.org/image/pq3t0aydv/)
Nel grafico vengono riportati i valori di beta1 per legame parabola-rettangolo (blu) e per legame parabolico (violetto).
E' possibile vedere come rispetto al modello parabola-rettangolo il beta1 del modello parabolico è più basso sul finale (siamo in prossimità del 3.5 per mille), questo comporta una riduzione dell'azione portata dal cls che tende a scaricarsi e a caricare progressivamente le barre compresse, ancor di più in virtù del loro comportamento incrudente.
Questo fenomeno si apprezza confrontando l'entità degli sforzi che vengono portati dal cls compresso, dalle barre compresse e dalle barre tese con modello parabola-rettangolo per il cls + elastoplastico perfetto per l'acciaio (in linee tratteggiate) e modello tutto parabolico del cls + bilineare incrudente dell'acciaio (in linee continue):
(http://s16.postimage.org/l3r5ecpch/Appunti02.jpg) (http://postimage.org/image/l3r5ecpch/)
Sezione quadrata 50x50 cm con 3fi20 per lato con cls C25/30, altezza utile 46 cm, sforzo normale 600 kN.
Sebbene l'entità delle resistenze è diverso, perchè il primo si riferisce ai valori di calcolo mentre il secondo ai valori medi, è comunque possibile apprezzare la forma diversa dei diagrammi nei due casi, in particolare per il cls il tratto fionale è molto discendente.
2) Se indichiamo la distanza dal lembo compresso della risultante delle azioni del cls come beta2*x, il coefficiente beta2 ha questa variazione in funzione della deformazione del lembo compresso di cls:
(http://s18.postimage.org/rp218nrh1/Appunti04.jpg) (http://postimage.org/image/rp218nrh1/)
rispetto al legame parabola-rettangolo (blu) il legame parabolico (violetto) ha un valore maggiore per elevate curvature della sezione, e questo comporta una complessiva riduzione del braccio della coppia interna.
E questo è il risultato finale:
(http://s13.postimage.org/dxq7kjr83/Appunti05.jpg) (http://postimage.org/image/dxq7kjr83/)

N.B. Nei calcoli sopra esposti non è stato attivato il confinamento, ma quella è un'altra storia...


Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 15 April , 2012, 13:52:46 PM
@ g.iaria
mentre per l'analisi strutturale non lineare è pacifico l'uso dei valori medi delle resistenze dei materiali, non altrettanto può dirsi per la verifica di duttilità in curvatura. Infatti non ho mai trovato in alcun testo una esemplificazione chiara dei valori delle resistenze da impiegare (gli autori spesso si rifugiano nel simbolo fc che non vuol dire nulla). Nel volume di Cosenza, Manfredi, Pecce - Strutture in c.a. - vengono addiritura utilizzati i valori di calcolo fcd e dyd.
Personalmente per la verifica di duttilità in curvatura (trattandosi di una verifica locale) utilizzo i valori caratteristici allo scopo di poter veramente contare (con un ottimo frattile del 5%) su valori di resistenza sicuramente verificati rispetto ad un semplice valore medio.
Poi naturalmente se non si considera la rottura del copriferro ed un buon grado di confinamento del cls. non c'è speranza di soddisfare la verifica di duttilità in curvatura dei pilastri.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: g.iaria on 15 April , 2012, 15:48:03 PM
@ g.iaria
mentre per l'analisi strutturale non lineare è pacifico l'uso dei valori medi delle resistenze dei materiali, non altrettanto può dirsi per la verifica di duttilità in curvatura. Infatti non ho mai trovato in alcun testo una esemplificazione chiara dei valori delle resistenze da impiegare (gli autori spesso si rifugiano nel simbolo fc che non vuol dire nulla). Nel volume di Cosenza, Manfredi, Pecce - Strutture in c.a. - vengono addiritura utilizzati i valori di calcolo fcd e dyd.
Personalmente per la verifica di duttilità in curvatura (trattandosi di una verifica locale) utilizzo i valori caratteristici allo scopo di poter veramente contare (con un ottimo frattile del 5%) su valori di resistenza sicuramente verificati rispetto ad un semplice valore medio.
Poi naturalmente se non si considera la rottura del copriferro ed un buon grado di confinamento del cls. non c'è speranza di soddisfare la verifica di duttilità in curvatura dei pilastri.
Concordo con te che non c'è in generale una chiara indicazione della tipologia di resistenze da adottare nelle verifiche di duttilità di curvatura (valori di calcolo, valori caratteristici e valori medi).
Sia Ghersi sia Fardis indicano però che sia più corretto valutare la duttilità con i valori medi delle resistenze, essendo questa operazione finalizzata alla valutazione del comportamento flessionale atteso, piuttosto che alla progettazione ed al dimensionamento in senso stretto (fasi che hanno preceduto quella in questione e che sono state condotte operando con i valori di calcolo).
Penso inoltre che tale assunzione abbia in sè anche una coerenza fisica, dato la verifica di cui al § 7.4.4. non è più una verifica di resistenza, per la quale l'abbattimento delle resistenze ai valori di calcolo avrebbe avuto senso, ma una verifica deformativa del comportamento atteso, la cosa potrà sembrare strana perchè siamo sempre stati abituati ad avere a che fare sempre con forze, tuttavia in questo caso il protagonista non è più la resistenza, ma la deformazione. Forse è l'anticamera di quel "displacement based design" che credo sarà la naturale futura evoluzione delle metodologie di calcolo in ambito sismico.
Visto che inoltre la valutazione del confinamento è indispensabile in alcuni casi, come i pilastri, e visto che i modelli di confinamento da norma (EC2 ed EC8) sono estremamente cautelativi, penalizzare ulteriormente la valutazione della duttilità con i valori caratteristici o addirittura quelli di calcolo è a mio modesto avviso troppo cautelativo, oltre che non necessario per quanto prima argomentato.
Infine, come hai giustamente detto, per le analisi non lineari le due curvature (di snervamento ed ultima) vengono calcolate con i valori medi, dato che tutte le successive espressioni propedeutiche alla implementazione del modello non lineare (rotazione di corda, lunghezza di plasticizzazione, etc.) sono ottenute mediante espressioni empiriche, che tendono a riprodurre i valori medi misurati sperimentalmente.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 15 April , 2012, 17:44:07 PM
@g.iaria
Non ho letto Ghersi (di cui non tanto mi fido), ma nel volume di Fardis (seismic design...) sull'EC8 non ho trovato un'esplicita indicazione del valore medio dei materiali. Se me la indichi mi fai un favore (anche perchè ho richiesto per email direttamente a Fardis tale riferimento ma non mi ha ancora risposto...).
Proprio il paragrafo 7.4.4 NTC fa riferimento nell'ultimo capoverso al raggiungimento delle deformazioni ultime epsilon_c (ambiguo) e epsilon_uk in cui, almeno per l'acciaio, chiarisce l'impiego della deformazione ultima caratteristica e quindi corrispondente al valore caratteristico ftk (e non al valore medio ftm) che del resto è l'unico valore nominale cui fa riferimento la normativa nel capitolo 11.
Circa il calcestruzzo faccio riferimento alla valutazione del confinamento §3.1.9 EC2  (a cui si ispira ovviamente anche l'EC8 e per copia conforme l'NTC):
la pressione laterale di confinamento viene dedotta a partire dai valori caratterisici del calcestruzzo ed a questi valori caratteristici fck,c sono legati tutti i risultati e non certo ai valori medi). Del resto assumere un valore medio superiore di 8 Mpa al valore caratteristico indipendentemente dalla classe mi sembra un po' troppo generico (del resto il valore 8 viene riferito dallo stesso EC2 - quando parla della legge del cls da impiegare per il calcolo non lineare - ad un calcestruzzo di classe indefinita e mediamente confinato ... quindi è cmq un valore altamente spannometrico).
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: g.iaria on 15 April , 2012, 18:04:09 PM
@g.iaria
Non ho letto Ghersi (di cui non tanto mi fido), ma nel volume di Fardis (seismic design...) sull'EC8 non ho trovato un'esplicita indicazione del valore medio dei materiali. Se me la indichi mi fai un favore (anche perchè ho richiesto per email direttamente a Fardis tale riferimento ma non mi ha ancora risposto...).
Proprio il paragrafo 7.4.4 NTC fa riferimento nell'ultimo capoverso al raggiungimento delle deformazioni ultime epsilon_c (ambiguo) e epsilon_uk in cui, almeno per l'acciaio, chiarisce l'impiego della deformazione ultima caratteristica e quindi corrispondente al valore caratteristico ftk (e non al valore medio ftm) che del resto è l'unico valore nominale cui fa riferimento la normativa nel capitolo 11.
Il riferimento sul Fardis è a pag. 195 all'inizio del § 3.2.2.5 scrive che i momenti resistenti da impiegare nel flow chart per la determinazione della curvatura ultima vanno calcolati con i valori medi delle resistenze di acciao e cls.
Dopotutto nella trattazione che esegue non c'è traccia di pedice k.

Anche io avevo chiesto invano un chiarimento via email a Fardis circa questo argomento: http://ingegneriaforum.it/index.php?topic=2601.0 (http://ingegneriaforum.it/index.php?topic=2601.0)
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 15 April , 2012, 18:16:10 PM
Il riferimento sul Fardis è a pag. 195 all'inizio del § 3.2.2.5 scrive che i momenti resistenti da impiegare nel flow chart per la determinazione della curvatura ultima vanno calcolati con i valori medi delle resistenze di acciao e cls.
Dopotutto nella trattazione che esegue non c'è traccia di pedice k.

Anche io avevo chiesto invano un chiarimento via email a Fardis circa questo argomento: http://ingegneriaforum.it/index.php?topic=2601.0 (http://ingegneriaforum.it/index.php?topic=2601.0)


Ma Fardis non dice fcm bensì  "fcm or fc"     senza indicare a quale fc si riferisce! ed è proprio quello che gli ho chiesto in riferimento al calcolo della dutilità in curvatura.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: g.iaria on 15 April , 2012, 18:24:03 PM
Ma Fardis non dice fcm bensì  "fcm or fc"     senza indicare a quale fc si riferisce! ed è proprio quello che gli ho chiesto in riferimento al calcolo della dutilità in curvatura.

Anche se la cosa poteva essere scritta meglio, io interpreto quel  "fcm or fc" e quel "fym or fy" come voler precisare un' equivalenza di simboli, ossia prima ha scritto fc ed fy che senza il giusto pedice non significano niente e che vanno dunque considerati come valori medi.
Ghersi è molto più esplicito, nel suo capitolo sulla duttilità dice chiaramente che vanno usati i valori medi, ed anzi mette a diretto confronto i diagrammi momento curvatura ottenuti assumendo le resistenze di calcolo, quelle caratteristiche e quelle medie.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 17 April , 2012, 10:53:25 AM
Sembra che oltre all'univ. di Napli anche quella di Bari siano convinti che il calcolo della dutilità in curvatura vada fatto in base ai legami costitutivi di calcolo. Mezzina e Raffaeli scrivono infatti a pag. 199 del volume 'Progettazione sismo-resistente di Edifici in ca (Città Studi 2011):
"E' da osservare che, secondo i codici normativi, la curvatura ultima va calcolata convenzionalmente sulla base dei legami costitutivi di calcolo dei materiali, e non direttamente dai legami Momento-Curvatura sperimentali."

Sembra che la questione sia ancora tutta da chiarire...   
Title: Re: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: g.iaria on 17 April , 2012, 12:59:54 PM
Sembra che oltre all'univ. di Napli anche quella di Bari siano convinti che il calcolo della dutilità in curvatura vada fatto in base ai legami costitutivi di calcolo. Mezzina e Raffaeli scrivono infatti a pag. 199 del volume 'Progettazione sismo-resistente di Edifici in ca (Città Studi 2011):
"E' da osservare che, secondo i codici normativi, la curvatura ultima va calcolata convenzionalmente sulla base dei legami costitutivi di calcolo dei materiali, e non direttamente dai legami Momento-Curvatura sperimentali."

Sembra che la questione sia ancora tutta da chiarire...   
A quali codici normativi fanno riferimento?
Sento che molti parlano bene di questo testo, vale la pena acquistarlo?
Ad oggi non sono riuscito a trovare un buon libro di sismica scritto in italiano.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Renato on 17 April , 2012, 13:40:51 PM
A quali codici normativi fanno riferimento?
Sento che molti parlano bene di questo testo, vale la pena acquistarlo?
Ad oggi non sono riuscito a trovare un buon libro di sismica scritto in italiano.

Naturalmente non esplicitano i codici normativi.
Il volume è lottizzato tra vari autori: da quelli prima citati ad A.Vulcano e G.Monti di altre università a S.Casolo e Sanjust
Nel libro c'è un po' di tutto ma vedo solo pochi paragrafi interessanti.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: g.iaria on 18 April , 2012, 11:25:54 AM
Lasciando la questione se sia più corretto usare i valori medi o quelli di calcolo, spulciando sul Fardis ed in rete ho trovato questi due articoli scritti da lui e Biskinis:
http://www.iitk.ac.in/nicee/wcee/article/14_05-03-0153.PDF (http://www.iitk.ac.in/nicee/wcee/article/14_05-03-0153.PDF)
http://www.strulab.civil.upatras.gr/sites/default/files/ACES_Report_SEE2009-01.pdf (http://www.strulab.civil.upatras.gr/sites/default/files/ACES_Report_SEE2009-01.pdf)
Ovviamente questi articoli destano poco interesse per chi non è impegnato in ambiti di ricerca, tuttavia possono dare a noi comuni mortali delle indicazioni circa la precisione con cui i modelli analitici che intendiamo adottare per il calcolo della curvatura ultima riescono a riprodurre i valori dei risultati sperimentali.
Trattandosi di confronti con risultati sperimentali, credo che nei modelli analitici sono stati impiegati i valori medi delle resistenze, anche se negli articoli questo non è esplicitamente indicato.
Mettendo a confronto i vari modelli di confinamento con i risulati sperimentali il rapporto test/previsione analitica della curvatura ultima possiede i seguenti valori medi e coefficienti di variazione (deviazione standard/valor medio):Si noti come il modello di confinamento di EC2 sia quello di gran lunga più cautelativo, sottostimando mediamente la curvatura ultima di un buon 30%.
Questo deve inoltre far pensare di quanto ancor più si sottostima la curvatura ultima se questa viene calcolata senza confinamento.
Il modello EC8 e quello di Mander sono invece molto più precisi, in particolare il primo ha inoltre una migliore dispersione dei risultati rispetto agli altri.
Il modello di Paulay e Pristley sembra invece essere un pò più ottimistico, a fronte di una dispersione dei risultati uguale agli altri.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 28 April , 2012, 14:38:51 PM
Parte 15

Momenti di primo snervamento
Faccio un piccolo, ma necessario, riassunto delle funzioni che consentono di tracciare il dominio di rottura Mx-My di una sezione generica viste nelle parti precedenti:

La prima (parte 13):
calcola_dominio_SLU

Quella più in alto nella 'catena alimentare'. Questa funzione, facendo variare 24 volte l'inclinazione dell'asse neutro (o per meglio dire ruotando fittiziamente la sezione), alla fine restituisce 24 coppie di momenti Mx-My che determinano il dominio di rottura.

Per svolgere questo lavoro, per data inclinazione dell'asse neutro (Ma ancora non definito come posizione), la funzione passa la palla alla seconda funzione (Parte 12):

determina_asse_neutroSLU

Che esegue le varie 'prove' al fine di determinare la posizione effettiva dell'asse neutro, tale che la risultante complessiva nella sezione valga Nd.
Anche questa funzione a sua volta chiama altre funzioni che svolgono funzioni particolari, esse sono:

(Parte 10)
calcola_deform_ultime

(Parte 11)
risult_compr

risult_traz

La prima funzione, fissata una posizione di tentativo dell'asse neutro, è in grado di determinare le deformazioni a rottura della fibra più compressa della sezione e della armatura più tesa, congruenti con le 'regole' delle deformazioni a rottura.
La seconda funzione invece, sempre avendo fissato l'asse neutro di tentativo, determina la risultante di compressione agente sulla sezione, affettando in strisce sottili la parte compressa, utilizzando le uteriori funzioni:

(Parte 9)
calcola_lungh_fibra

(Parte 10)
parabola_rett

(Parte 8, oppure Parte 14)
elast_plast_indef

La terza funzione invece determina la risultante di trazione agente sulla sezione (le armature tese), utilizzando la sola funzione (Parte 8, oppure Parte 14)

elast_plast_indef

Si vedrà alla fine di questa parte che in pratica tutte le funzioni sviluppate finora con il solo fine di definire i momenti di rottura, con una semplice variazione, sono anche perfettamente in grado di calcolare i momenti di primo snervamento.
(Una delle fisse dei programmatori è quella del 'riutilizzo del codice'. Mai come in questo caso, un utilizzo accorto della strutturazione delle varie funzioni si è rivelato vincente.)

Dopo questo piccolo riassunto definiamo dunque il momento di primo snervamento. Trattasi di quel momento, per dato Nd, per cui viene raggiunto il valore di snervamento nelle barre di acciaio poste più in basso nella sezione.
Riprendiamo il solito diagramma che individua i campi di rottura:

(http://s16.postimage.org/ra9n5ld35/Sezione_generica12.jpg) (http://postimage.org/image/ra9n5ld35/)

In pratica nel determinare i momenti di rottura, come visto in precedenza, la configurazione deformata della sezione deve 'passare' per forza attraverso situazioni ben precise. Se però per epsyd invece di intendere il valore di deformazione ultima della barra a rottura, intendessimo il valore di deformazione cui corrisponde lo snervamento (ovvero espyd=fyd/Ea) si potrà continuare a trattare numericamente il problema così come è stato affrontato fino ad adesso.
Ed il tutto senza minimamente modificare tutto il 'meccanismo' che abbiamo messo in piedi per la rottura.
In pratica richiamando in modo opportuno la funzione 'madre' calcola_dominio_SLU potremo ottenere o il dominio di rottura, oppure il dominio di primo snervamento.
Per una migliore 'lettura' del tabulato e per renderlo più facilmente modificabile in futuro si è preferito creare una funzione gemella di calcola_deform_ultime;
chiamandola stavolta (il prototipo):

Code: [Select]
struct deform_ultime_sezione calcola_deform_snerv(struct poligono_sezione *,float,int,float,float);
Ed ecco la funzione:

Code: [Select]
struct deform_sezione calcola_deform_snerv(struct poligono_sezione *polic,float ymax,int npm,float yamin,float yn)
{
 int register k,np;
 float y1[NMAXPOLI],yc0,dpa,epsyd_snerv=-fyd/Ea;
 struct deform_sezione def;

 /* Calcola le massime ordinate di ogni singolo poligono */
 for (np=0;np<NMAXPOLI-1;np++)
     {
      y1[np]=-100000.0;
      for (k=0;k<=polic[np].numv-1;k++)
          {
           if (polic[np].y[k]>y1[np]) y1[np]=polic[np].y[k];
          }
     }

 /* Definisce la deformazione a snervamento della sezione - considerando i vari casi */
 if (yn>(fabs(epsyd_snerv)*ymax+polic[npm].epscu*yamin)/(polic[npm].epscu+fabs(epsyd_snerv)))
    {
     def.epsa=epsyd_snerv*(yn-ymax)/(yn-yamin);
     def.epsb=epsyd_snerv;
    }
 if (yn<=(fabs(epsyd_snerv)*ymax+polic[npm].epscu*yamin)/(polic[npm].epscu+fabs(epsyd_snerv)) && yn>yamin)
    {
     def.epsa=polic[npm].epscu;
     def.epsb=polic[npm].epscu*(yn-yamin)/(yn-ymax);
    }
 if (yn<=yamin)
    {
     yc0=yamin+polic[npm].epsc0*(ymax-yamin)/polic[npm].epscu;
     def.epsa=polic[npm].epsc0*(ymax-yn)/(yc0-yn);
     def.epsb=polic[npm].epsc0*(yamin-yn)/(yc0-yn);
    }

 /* Controlla che per tutti i contorni valga quanto ricavato */
 /* (per effetto di differenti deformazioni limite nei vari contorni) */
 for (np=0;np<=NMAXPOLI-1;np++)
     {
      if (np==npm || polic[np].numv==0) continue;

      dpa=def.epsa+(def.epsb-def.epsa)*(ymax-y1[np])/(ymax-yamin);

      if (dpa>polic[np].epscu)
         {
          if (yn<=(fabs(epsyd_snerv)*y1[np]+polic[np].epscu*yamin)/(polic[np].epscu+fabs(epsyd_snerv)) && yn>yamin)
             {
              def.epsa=polic[np].epscu*(ymax-yn)/(y1[np]-yn);
              def.epsb=polic[np].epscu*(yn-yamin)/(yn-y1[np]);
             }
          if (yn<=yamin)
             {
              yc0=yamin+polic[np].epsc0*(y1[np]-yamin)/polic[np].epscu;
              def.epsa=polic[np].epsc0*(ymax-yn)/(yc0-yn);
              def.epsb=polic[np].epsc0*(yamin-yn)/(yc0-yn);
             }
         }
     }

 return(def);
}

In pratica è la solita funzione scritta nella parte 10 (andate a vedere le varie considerazioni), avendo provveduto a sostituire nelle varie formule, al posto di epsyd la variabile epsyd_snerv ricavata tra l'altro all'interno della funzione stessa.

Bisognerà a questo punto istruire le funzioni che stanno più in alto di questa a chiamare la funzione 'giusta' per ottenere i risultati desiderati: rottura o snervamento.

A tal proposito si definiranno le macro:

Code: [Select]
#define ROTT 0
#define SNERV 1

La funzione calcola_dominio_SLU verrà adesso dotata di un parametro in più, pertanto il suo prototipo diventerà:

Code: [Select]
struct dominio_rottura calcola_dominio_SLU(float,int);
Code: [Select]
struct dominio_rottura calcola_dominio_SLU(float Nd,int dominio)
{
 corpo della funzione
}

Il corpo vero e proprio della funzione rimane di fatto inalterata, e per questo non si riporta - unica variazione la chiamata alla funzione determina_asse_neutroSLU per l'aggiunta di un parametro. Infatti l'ulteriore parametro dominio, in fase di chiamata della funzione sarà ROTT o SNERV, esempio:

Code: [Select]
dom_snerv=calcola_dominio_SLU(Nd,SNERV);
dom_rott=calcola_dominio_SLU(Nd,ROTT);

e tale variabile sarà pari pari 'girata' alla altra funzione: determina_asse_neutroSLU
anch'essa da modificare per l'aggiunta di un ulteriore parametro. Il suo prototipo diventerà:

Code: [Select]
struct risultante_n_finale determina_asse_neutroSLU(struct poligono_sezione *,struct armature_sezione,float, int);
La funzione vera e propria:

Code: [Select]
struct risultante_n_finale determina_asse_neutroSLU(struct poligono_sezione *polic,struct armature_sezione armc,float Nd,int dominio)
{
 int register k,np;
 int npm;
 float ymax=-1000000.0,yamin=+1000000.0,ntot;
 double yn,delta=10.0;
 struct risultante_n_finale nfin;
 struct deform_ultime_sezione deform;
 struct risultante_n nc,nt;

 /* Per prima cosa determina ymax della sezione */
 for (np=0;np<=4;np++)
     {
      for (k=0;k<=polic[np].numv-1;k++)
          {
           if (polic[np].y[k]>ymax) { ymax=polic[np].y[k]; npm=np; }
          }
     }
 /* Poi determina yamin tra tutte le armature */
 for (k=0;k<=armc.numarm-1;k++)
     {
      if (armc.y[k]<yamin) yamin=armc.y[k];
     }
 /* Quindi definisce un primo posizionamento dell'asse neutro */
 yn=yamin+0.8*(ymax-yamin);

 /* Inizia il ciclo iterativo alla ricerca della effettiva posizione dell'asse neutro */
 do
  {
   if (dominio==ROTT)  deform=calcola_deform_ultime(polic,ymax,npm,yamin,yn);
   if (dominio==SNERV) deform=calcola_deform_snerv(polic,ymax,npm,yamin,yn);
   /* Calcola lo sforzo normale nella parte compressa della sezione */
   nc=risult_compr(polic,armc,ymax,yamin,yn,deform);
   nt=risult_traz(armc,ymax,yamin,yn,deform);
   ntot=nc.n+nt.n;

   if (delta*(Nd-ntot)>0.0 && fabs(Nd-ntot)>1.0) { delta=-delta/5; yn+=delta; continue; }
   if (fabs(Nd-ntot)>1.0) yn+=delta;
  }
 while (fabs(Nd-ntot)>1.0 && fabs(delta)>1e-6);

 nfin.ncf.n=nc.n; nfin.ncf.x=nc.x; nfin.ncf.y=nc.y;
 nfin.ntf.n=nt.n; nfin.ntf.x=nt.x; nfin.ntf.y=nt.y;

 return (nfin);
}

Chi ha voglia di confrontare i due listati della funzione, quella della parte 12 e questa, vedrà che l'unica differenza consiste nel fatto che la funzione adesso chiama la funzione calcola_deform_ultime o calcola_deform_snerv in base al valore assunto dalla variabile dominio.

Una considerazione che esula dagli aspetti informatici. E' possibile, specie per elevati valori di  sforzo normale, che alla condizione di rottura si arrivi senza che la deformazione dell'acciaio superi mai quella di snervamento. Di fatto questo significa che il momento di primo snervamento non esiste. Oppure si potrà affermare che i due momenti coincidono.
Con la procedura di cui sopra in questo caso si ricaveranno dei momenti di primo snervamento che saranno identici a quelli di rottura.

Ultima annotazione. Mi sto tenendo abbastanza alla larga dalla diatriba: valori medi, caratterstici, di calcolo.
Quando ho iniziato questo topic il mio obiettivo era determinare momenti di rottura e pertanto per fcd o per fyd ho sempre inteso i valori di calcolo della resistenza a compressione del calcestruzzo, il valore di calcolo di snervamento dell'acciaio.
Nulla vieta in queste stesse routine di sostituire a fcd o fyd il valore che si ritiene più opportuno.
Ovviamente parlando sempre di momenti di rottura e di momenti di snervamento. Per altro....si vedrà.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 28 April , 2012, 15:28:12 PM
(Una delle fisse dei programmatori è quella del 'riutilizzo del codice'. Mai come in questo caso, un utilizzo accorto della strutturazione delle varie funzioni si è rivelato vincente.)


già.
Chapeau
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 08 May , 2012, 19:19:33 PM
Parte 16

Qualche passo indietro per farne qualcuno in avanti
Sarebbe giunto il momento di iniziare a parlare di curvatura.
Alla fine non sarebbe nulla di che. Definiamola, e togliamoci il pensiero.
Per curvatura si intende il rapporto:

epsc/x oppure (epsc-epsa)/d

Dove epsc è la deformazione del calcestruzzo nel suo lembo più compresso, e epsa (con segno opposto perchè ovviamente di trazione) la massima deformazione della barra di armatura più distante dall'asse neutro x, d altezza utile della sezione.
Tale rapporto in definitiva misura la 'inclinazione' che la sezione assume nella sua deformazione piana sotto date sollecitazioni.

Non ho detto nulla sulla natura di epsc e di epsa, perchè queste saranno le generiche deformazioni per 'generiche' sollecitazioni.
Però se queste deformazioni fossero quelle di rottura, troverò una curvatura di rottura, se invece fossero di snervamento, troverò una curvatura di snervamento.
Il rapporto tra la curvatura a rottura e la curvatura a snervamento viene definito 'duttilità di curvatura' e grande rilievo ha ormai assunto nelle analisi sismiche a partire dall'EC8 fino ad arrivare alle nostre NTC08.
(Avviso ai naviganti: per il momento non intendo scomodare confinamento, valori medi, caratteristici, di calcolo).

In pratica il risultato finale, quello che serve, è questo: la 'duttilità di curvatura'. Epperò è molto 'bello' andare a diagrammare la cosiddetta curva “momenti-curvatura”. Essa prevede in ascissa la curvatura, ed in ordinata il momento flettente. Il passo avanti cui accenno nel titolo di questa parte sarebbe dunque la sua costruzione per la sezione generica e genericamente caricata.
Sgombro subito il campo. Nel tracciare il diagramma partirò dal momento di primo snervamento per arrivare al momento di rottura, poco interessandomi della parte iniziale con sezione interamente reagente, poi fessurata, ecc.

Purtroppo dobbiamo però prima puntualizzare alcune cose da un punto di vista 'listato di calcolo', da qui i passi indietro del titolo.
Traduco con la simbologia finora adottata nei vari listati le formule della curvatura:

epsc/(ymax-yn) oppure (epsc-epsa)/(ymax-yamin)

Dove ymax è la massima ordinata dei vertici della sezione fittiziamente ruotata ed yamin la minima ordinata delle barre di armature della sezione fittiziamente ruotata. yn la ordinata dell'asse neutro.

Quelle elencate, sono variabili già calcolate dalle varie funzioni che arrivano a determinare momenti di rottura o momenti di primo snervamento.

Chi conosce però un po' di programmazione strutturata, ovvero quei linguaggi (ormai tutti a dire il vero) che prevedono lo spezzettamento del codice in più e più 'funzioni', sa che quanto avviene all'interno di una funzione, nella esecuzione del programma, sono affari solamente della funzione stessa.
In questi linguaggi un programma è costituito da una funzione principale che chiama delle funzioni secondarie, che a loro volta possono chiamarne altre, con un grado di 'annidamento' che può essere quel che si vuole.
Ciò che è importante qui sottolineare è che se io definisco una variabile all'interno della funzione, e se a questa variabile assegno un valore, essa 'vive' ed a quel valore posso accedere, solamente finchè mi trovo all'interno della funzione stessa. Una volta uscito dalla funzione e rientrato nella funzione che sta sopra di essa, della tipologia di variabile in oggetto non ho più traccia (non a caso queste vengono definite variabili 'locali'), e quindi tanto meno saprò che valore essa ha assunto durante l'elaborazione. A meno che proprio questa variabile non faccia parte di quanto viene restituito alla funzione chiamante.

Per fare un esempio concreto:
La funzione determina_asse_neutroSLU al suo interno dichiara la variabile double yn.
Trattasi in definitiva della posizione dell'asse neutro che proprio questa funzione ha il compito di individuare. Però alla fine tale funzione restituisce una struttura dati, la struct risultante_n_finale, che è fatta così (Parte 12):

Code: [Select]
struct risultante_n_finale
{
 struct risultante_n ncf; /* Risultante di compressione della sezione */
 struct risultante_n ntf; /* Risultante di trazione della sezione */
};

dove a loro volta ncf e ntf sono ulteriori strutture dati con questa forma (Parte 11):

Code: [Select]
struct risultante_n
{
 float n;    /* Sforzo normale risultante */
 float x;    /* Coordinate punto di applicazione risultante */
 float y;
};

ovvero ncf (risultante di compressione e suo punto di applicazione) ed ntf (risultante di trazione e suo punto di applicazione) consentono alla funzione chiamante calcola_dominio_SLU (poiché sono i valori restituiti da determina_asse_neutroSLU), di determinare i momenti di rottura (o di snervamento) della sezione. Ma questa ultima funzione non potrà affatto determinare la curvatura della sezione, poiché non conosce né la posizione dell'asse neutro, né tanto meno la deformazione di calcestruzzo e acciaio. Calcolati certamente da determina_asse_neutroSLU, ma irrimediabilemente perduti nel momento in cui si è usciti dalla funzione suddetta.

Vi ricordo che in C una funzione potrà restituire uno ed un solo 'numero'. Nel corso di tutto il listato che ho presentato però, avendo fatto uso (ed abuso) delle strutture dati di cui sopra, ho potuto bypassare il problema, facendo restituire proprio strutture dati alle varie funzioni. Ovvero: la funzione restituisce effettivamente un solo 'oggetto' alla funzione chiamante, ma questo 'oggetto', pensatelo come una scatola, a sua volta al suo interno comprende più di una informazione.
Come risolvere il problema, quindi? Semplice. Fare entrare nella 'scatola' struttura qualche ulteriore informazione e dunque spedire il tutto alla funzione chiamante.
La struttura dati struct risultante_n_finale diverrà dunque:

Code: [Select]
struct risultante_n_finale
{
 struct risultante_n ncf; /* Risultante di compressione della sezione */
 struct risultante_n ntf; /* Risultante di trazione della sezione */
 float  yn;
 float  epsc;
 float  epss;
};

Come si vede, rispetto a prima, si sono aggiunte le variabili yn, posizione dell'asse neutro,  epsc e epss deformazioni di calcestruzzo ed acciaio.

Se dunque alla fine delle sue elaborazioni determina_asse_neutroSLU, memorizza i dati di yn, epsc ed epss (variabili locali interne alla funzione) nella struttura dati appena 'ampliata' ecco che questi valori potranno essere utilizzati dalla funzione chiamante. In questo modo:

Code: [Select]
struct risultante_n_finale determina_asse_neutro(struct poligono_sezione *polic,struct armature_sezione armc,float Nd,int dominio)
{
 int register k,np;
 int npm;
 float ymax=-1000000.0,yamin=+1000000.0,ntot1,ntot;
 double yn2,yn1,yn,delta=10.0;
 struct risultante_n_finale nfin;
 struct deform_sezione deform;
 struct risultante_n nc,nt;

 /* Per prima cosa determina ymax della sezione */
 for (np=0;np<=NMAXPOLI-1;np++)
     {
      for (k=0;k<=polic[np].numv-1;k++)
          {
           if (polic[np].y[k]>ymax) { ymax=polic[np].y[k]; npm=np; }
          }
     }
 /* Poi determina yamin tra tutte le armature */
 for (k=0;k<=armc.numarm-1;k++)
     {
      if (armc.y[k]<yamin && armc.cong[k]==0) yamin=armc.y[k];
     }

 /* Quindi definisce un primo posizionamento dell'asse neutro */
 yn=yamin+0.8*(ymax-yamin);

 /* Inizia il ciclo iterativo alla ricerca della effettiva posizione dell'asse neutro */
 /* procede con un ciclo a passo variabile, diminuendo il passo di scansione di ricerca */
 /* della posizione dell'asse neutro ogni volta che la differenza tra ncompr ed ntraz cambia di segno */
 do
  {
   /* Calcola le deformazioni ultime/snervamento della sezione */
   if (dominio==ULT)   deform=calcola_deform_ultime(polic,ymax,npm,yamin,yn);
   if (dominio==SNERV) deform=calcola_deform_snerv(polic,ymax,npm,yamin,yn);
   /* Calcola lo sforzo normale nella parte compressa della sezione */
   nc=risult_compr(polic,armc,ymax,yamin,yn,deform);
   /* Calcola lo sforzo normale della parte tesa della sezione */
   nt=risult_traz(polic,armc,ymax,yamin,yn,deform);
   /* Totale sforzo normale sulla sezione da confrontare con Nd */
   ntot=nc.n+nt.n;

   if (delta*(Nd-ntot)>0.0 && fabs(Nd-ntot)>1.0) { delta=-delta/5; yn+=delta; continue; }
   if (fabs(Nd-ntot)>1.0) yn+=delta;
  }
 while (fabs(Nd-ntot)>1.0 && fabs(delta)>1e-6);

 /* Copia nella struttura dati i risultati definitivi con il posizionamento ultimo dell'asse neutro */
 nfin.ncf.n=nc.n; nfin.ncf.x=nc.x; nfin.ncf.y=nc.y;
 nfin.ntf.n=nt.n; nfin.ntf.x=nt.x; nfin.ntf.y=nt.y;
 nfin.yn=yn;
 nfin.epsc=deform.epsa;
 nfin.epss=deform.epsb;

 return (nfin);
}

Come si vede la funzione è sempre quella, ma proprio nelle ultime righe si sono aggiunte le istruzioni per copiare i valori di yn di epsa e di epsb nelle apposite variabili predisposte nella struttura dati struct risultante_n_finale nfin.

Infine sarà opportuno modificare la struttura dati (Parte 13):

Code: [Select]
struct dominio_rottura
{
 float nd;
 float mrx[24];
 float mry[24];
}

Facendola diventare così:

Code: [Select]
struct dominio_rottura
{
 float nd;            /* Sforzo normale con cui si determinano i vari momenti di rottura */
 float mrx[24];       /* vettore con i valori dei momenti Mrx del dominio */
 float mry[24];       /* vettore con i valori dei momenti Mry del dominio */
 float nrc[24];       /* vettore con valori dello sfozo normale nella parte compressa della sezione a rottura */
 float nrt[24];       /* vettore con valori dello sforzo normale nella parte in trazione della sezione a rottura */
 float xrc[24];       /* posizione della risultante dello sforzo di compressione */
 float yrc[24];       /* (nel sistema di riferimento cartesiano della sezione) */
 float xrt[24];       /* posizione della risultante dello sforzo di trazione */
 float yrt[24];       /* (nel sistema di riferimento cartesiano della sezione) */
 float epsc[24];      /* vettore con le deformazioni limite della fibra più compressa */
 float epss[24];      /* vettore con le deformazioni limite della barra di armatura più distante dall'asse neutro */
 float yn[24];        /* posizione asse neutro (nel sistema ruotato di ogni singola verifica) */
 float curv[24];      /* Curvatura della deformazione della sezione per diagrammi momenti-curvatura */
};

Vi abbiamo aggiunto parecchia carne al fuoco, come si vede, sia per poter dar modo al nostro programma di scendere nel 'dettaglio' (ovvero stampare o visualizzare da qualche parte non soltanto i valori di mx ed my, ma anche i valori di sforzo normale di trazione e compressione, posizioni delle risultanti, ecc.)
Nelle ultime posizioni abbiamo inserito anche i dati, epsc, epss, yn, curv che serviranno poi in seguito per poter parlare di curvatura. Per ognuno ho previsto 24 posizioni, poiché il dominio di rottura è previsto essere approssimato dai 24 punti in cui si calcolano i momenti.

Pertanto anche la funzione calcola_dominio_SLU a questo punto si modificherà nella sua coda finale, solamente per l'aggiunta di una serie di assegnazioni delle variabili di cui sopra. Così:

Code: [Select]
struct dominio_rottura calcola_dominio(float Nd,int dominio)
{
 int register k,np,step;
 struct poligono_sezione polic[NMAXPOLI];
 struct armature_sezione armc;
 struct risultante_n_finale nfin;
 struct dominio_rottura dom;
 float xc,yc,xt,yt;

 dom.nd=Nd;

 /* Ruota di 15° in 15° la sezione in modo da applicare sempre gli stessi algoritmi */
 /* di determinazione asse neutro che presuppongono lo stesso sempre orizzontale */
 for (step=0;step<=23;step++)
     {
      float alfa=step*0.261799; /* alfa in radianti – 0.261799=15° */
      float c=cos(alfa),s=sin(alfa);
      /* Calcola una sola volta cos(alfa) e sin(alfa) per evitare elaborazione ogni volta */

      /* Prima copia la sezione in altra struttura dati e poi la ruota di alfa */
      for (np=0;np<=NMAXPOLI-1;np++)
          {
           polic[np]=poli[np];
           for (k=0;k<=poli[np].numv-1;k++)
               {
                polic[np].x[k]= poli[np].x[k]*c+poli[np].y[k]*s;
                polic[np].y[k]=-poli[np].x[k]*s+poli[np].y[k]*c;
               }
          }

      /* Copia le armature in altra struttura dati e poi le ruota di alfa */
      armc=arm;
      for (k=0;k<=arm.numarm-1;k++)
          {
           armc.x[k]= arm.x[k]*c+arm.y[k]*s;
           armc.y[k]=-arm.x[k]*s+arm.y[k]*c;
          }

      /* Chiama la funzione per definire l'asse neutro della sezione (ruotata di alfa) */
      nfin=determina_asse_neutro(polic,armc,Nd,dominio);

      /* Ripristina il sistema di riferimento delle risultanti */
      xc=nfin.ncf.x*c-nfin.ncf.y*s;
      yc=nfin.ncf.x*s+nfin.ncf.y*c;

      xt=nfin.ntf.x*c-nfin.ntf.y*s;
      yt=nfin.ntf.x*s+nfin.ntf.y*c;

      dom.mrx[step]=nfin.ncf.n*(yc-yg)+nfin.ntf.n*(yt-yg);
      dom.mry[step]=nfin.ncf.n*(xc-xg)+nfin.ntf.n*(xt-xg);
      dom.nrc[step]=nfin.ncf.n;
      dom.nrt[step]=nfin.ntf.n;
      dom.xrc[step]=xc; dom.yrc[step]=yc;
      dom.xrt[step]=xt; dom.yrt[step]=yt;
      dom.epsc[step]=nfin.epsc;
      dom.epss[step]=nfin.epss;
      dom.yn[step]=nfin.yn;
     }

 return (dom);
}

Notate come ho ruotato il sistema di riferimento delle coordinate delle risultanti (il motivo è già spiegato nella parte 13), ed invece mi accontento di memorizzare la variabile nfin.yn tale e quale (perchè di averlo 'storto' questo valore non mi importa nulla).
La funzione suddetta restituirà alla funzione chiamante una struttura dati dom, praticamente molto più 'cicciotta' e piena di dati di prima.

Per il momento mi fermo qui, mi pare già di aver messo troppa carne al fuoco.
Mi scuserete per questa lunga dissertazione, ma essa era necessaria per poter continuare nella trattazione.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: afazio on 10 May , 2012, 10:06:53 AM
Quando un forum diventa istruttivo. COme si farebbe su facebook: "mi piace"
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 21 May , 2012, 23:39:57 PM
Parte 17

Momenti con data curvatura
Avendo definito la curvatura come:

epsc/(ymax-yn) oppure (epsc-epsa)/(ymax-yamin)

abbiamo visto come si è dovuto fare un certo lavoro 'preparatorio', ma tutto sommato non sconvolgente, per poter determinare il valore di curvatura che la sezione assume in corrispondenza dello snervamento e della rottura.
Per precisione 'didattica' ricordo che le curvature in tali punti dipendono, oltre che da geometria della sezione, dalle armature e dalle caratteristiche dei materiali, anche e soprattutto dal valore di sforzo normale della sezione.
E' intuibile infatti che maggiore è lo sforzo normale di compressione sulla sezione, minore diventa lo 'spazio' che separa la condizione di rottura da quella di snervamento, e più prossime tra loro diventano le rispettive curvature.
Se la duttilità sezionale è misurata dal rapporto tra curvatura a rottura e curvatura a snervamento, esso diventa via via più piccolo convergendo ad 1.0 per valori elevati di sforzo normale.

In questa parte si vedrà come calcolare, per dato sforzo normale, il momento flettente 'espresso' dalla sezione ad una data curvatura.
Ovvero si fisserà una curvatura compresa tra quella di snervamento e quella di rottura e si calcolerà il momento flettente corrispondente (i due momenti flettenti a dire il vero, poiché sempre nel caso generico ci poniamo).
Anche in questo caso Afazio sarà contento. Poiché basta un minimo di comprensione del problema per poter riutilizzare il solito ed ormai trito codice già scritto ed ampiamente sperimentato.
Guardiamo il seguente diagramma:

(http://s14.postimage.org/4fyi5ksm5/Sezione_generica14.jpg) (http://postimage.org/image/4fyi5ksm5/)

In pratica la barra inclinata in rosso che ho tracciato nel solito diagramma che indica le possibili configurazioni deformative della sezione a rottura, di fatto 'segna' una possibile curvatura (inclinazione della sezione sotto sollecitazione). Invece di seguire il solito 'percorso', ovvero massima deformazione nell'acciaio teso (rotazione attorno al punto A) o massima deformazione nel cls compresso (rotazione attorno al punto B), se decidiamo di non modificare l'inclinazione della barretta segnata nel grafico, di fatto ricercheremo una configurazione deformata della sezione sotto dato sforzo normale, per curvatura 'fissa'.
Ovvero definita la variabile curv (data dalle espressioni riportate), le deformazioni possibili ai lembi estremi della sezione potranno essere solamente:

epsc=curv*(ymax-yn)
epsa=-curv*(yn-yamin)


(ymax massima ordinata della sezione, yamin minima ordinata delle barre di armatura, yn la posizione dell'asse neutro nel sistema di riferimento la vera 'variabile' del problema).
che altro non sono le formule inverse viste sopra.
Se volessimo avere una visione 'geometrica' della situazione queste formule indicano che le deformazioni da ricercare nei lembi inferiore e superiore si ottengono semplicemente traslando la barra rossa tracciata nella figura superiore, senza farla ruotare (come dalle frecce gialle che ho disegnato). Traslazione che comporta un aumento o diminuzione della parte compressa della sezione (ovvero di posizione dell'asse neutro) alla ricerca di quella configurazione che equilibri lo sforzo normale Nd agente nella sezione.

In pratica si riconosce che il procedimento finora seguito per ricavare momenti di rottura e di snervamento potrà continuare ad essere utilizzato, con le solite iterazioni alla ricerca dell'asse neutro, con il solito calcolo dello sforzo normale che le parti compresse e tese sono in grado di esplicare, ma con un differente 'metodo' di determinazione delle massime deformazioni della sezione, lasciando inalterata tutta la costruzione già fatta circa la determinazione corretta dell'asse neutro, e di conseguenza dei momenti, stavolta non di rottura o snervamento, ma per data curvatura della sezione.

In questa parte mi limiterò a riscrivere la sola funzione determina_asse_neutro, nella prossima puntata invece vedrò di sviluppare una funzione di 'più alto livello' che utilizzerà proprio quest'ultima per i propri fini.

Aggiungo intanto una macro alle due già definite nella parte 15:

Code: [Select]
#define ROTT 0
#define SNERV 1
#define CURV 2

Quindi ridefinisco il prototipo di determina_asse_neutro aggiungendo un ulteriore parametro, ovvero la curvatura curv per cui si vuol determinare l'asse neutro e relativi momenti flettenti associati:

Code: [Select]
struct risultante_n_finale determina_asse_neutro(struct poligono_sezione *,struct armature_sezione,float,int,float);
Prima del corpo di questa funzione vera e proprio devo definire una altra funzione che mi consente di calcolare correttamente le deformazioni nella sezione per data curvatura (con prototipo e quindi corpo della funzione):

Code: [Select]
struct deform_sezione calcola_deform_curv(float,float,float,float);

struct deform_sezione calcola_deform_curv(float ymax,float yamin,float yn,float curv)
{
 struct deform_sezione def;

 def.epsa=curv*(ymax-yn);
 def.epsb=-curv*(yn-yamin);

 return(def);
}

Potete vedere come si tratta di funzioncina stupida stupida, poiché ho semplicemente implementato le due formule sopra viste, assegnando il risultato ai membri della struttura struct deform_sezione (ricordo che epsa è la deformazione nella parte alta della sezione – lembo compresso, epsb la deformazione della parte bassa della sezione – armatura in trazione, e che epsb essendo di trazione è negativa per definizione). Non ho volutamente introdotto alcun controllo sulla entità di tali deformazioni, poiché intendo passare alla funzione curvature comprese tra quelle di snervamento e quelle di rottura.

Infine la funzione vera e propria determina_asse_neutro, eccola qui:

Code: [Select]
struct risultante_n_finale determina_asse_neutro(struct poligono_sezione *polic,struct armature_sezione armc,float Nd,int dominio,float curv)
{
 int register k,np;
 int npm;
 float ymax=-1000000.0,yamin=+1000000.0,ntot1,ntot;
 double yn2,yn1,yn,delta=10.0;
 struct risultante_n_finale nfin;
 struct deform_sezione deform;
 struct risultante_n nc,nt;

 /* Per prima cosa determina ymax della sezione */
 for (np=0;np<=NMAXPOLI-1;np++)
     {
      for (k=0;k<=polic[np].numv-1;k++)
          {
           if (polic[np].y[k]>ymax) { ymax=polic[np].y[k]; npm=np; }
          }
     }
 /* Poi determina yamin tra tutte le armature */
 for (k=0;k<=armc.numarm-1;k++)
     {
      if (armc.y[k]<yamin && armc.cong[k]==0) yamin=armc.y[k];
     }

 /* Quindi definisce un primo posizionamento dell'asse neutro */
 yn=yamin+0.8*(ymax-yamin);

 /* Inizia il ciclo iterativo alla ricerca della effettiva posizione dell'asse neutro */
 /* procede con un ciclo a passo variabile, diminuendo il passo di scansione di ricerca */
 /* della posizione dell'asse neutro ogni volta che la differenza tra ncompr ed ntraz cambia di segno */
 do
  {
   /* Calcola le deformazioni ultime/snervamento della sezione */
   if (dominio==ULT)   deform=calcola_deform_ultime(polic,ymax,npm,yamin,yn);
   if (dominio==SNERV) deform=calcola_deform_snerv(polic,ymax,npm,yamin,yn);
   if (dominio==CURV)  deform=calcola_deform_curv(ymax,yamin,yn,curv);
   /* Calcola lo sforzo normale nella parte compressa della sezione */
   nc=risult_compr(polic,armc,ymax,yamin,yn,deform);
   /* Calcola lo sforzo normale della parte tesa della sezione */
   nt=risult_traz(polic,armc,ymax,yamin,yn,deform);
   /* Totale sforzo normale sulla sezione da confrontare con Nd */
   ntot=nc.n+nt.n;

   if (delta*(Nd-ntot)>0.0 && fabs(Nd-ntot)>1.0) { delta=-delta/5; yn+=delta; continue; }
   if (fabs(Nd-ntot)>1.0) yn+=delta;
  }
 while (fabs(Nd-ntot)>1.0 && fabs(delta)>1e-6);

 /* Copia nella struttura dati i risultati definitivi con il posizionamento ultimo dell'asse neutro */
 nfin.ncf.n=nc.n; nfin.ncf.x=nc.x; nfin.ncf.y=nc.y;
 nfin.ntf.n=nt.n; nfin.ntf.x=nt.x; nfin.ntf.y=nt.y;
 nfin.yn=yn;
 nfin.epsc=deform.epsa;
 nfin.epss=deform.epsb;

 return (nfin);
}

Rispetto alle altre volte la variabile dominio potrà avere valori ULT, SNERV, e adesso anche CURV. In funzione di questi 'indici' la funzione diventa 'tutto fare'. Può determinare l'asse neutro in condizioni di rottura, o di snervamento, o per dato valore della curvatura. Dal valore di asse neutro la funzione chiamante è poi in grado di determinare i momenti flettenti associati (di rottura, di snervamento, per data curvatura).

Spendo qualche parola in più sulle macro che ho definito. In effetti ULT, SNERV e CURV, non sono altro che i numeri 0,1 e 2. Avrei potuto scrivere tranquillamente nel listato:

Code: [Select]
   if (dominio==0) deform=calcola_deform_ultime(polic,ymax,npm,yamin,yn);
   if (dominio==1) deform=calcola_deform_snerv(polic,ymax,npm,yamin,yn);
   if (dominio==2) deform=calcola_deform_curv(ymax,yamin,yn,curv);

Ottenendo esattamente gli stessi esiti nelle elaborazioni. In effetti però chi volesse domani rivedere questo pezzetto di codice dovrebbe capire cosa fa effettivamente la funzione se la variabile dominio è uguale a 0, ad 1, a 2. E' facile in questo caso capirlo dalla struttura del listato e dalle funzioni richiamate. Ma possono esserci casi in cui questo non è così evidente. Avere quindi la possibilità di ribattezzare questi indici numerici (non sono nemmeno delle variabili) con un nome 'evocativo' migliora la leggibilità del listati.
I primi programmatori in C (o forse in linguaggi più antichi che prevedevano questa possibilità) hanno pensato bene di rendere ancora più evidente questi indici battezzandoli con nomi, non soltanto 'evocativi', ma anche scritti in maiuscolo (da qui il nome MACRO ad essi assegnato), in modo che spiccassero in tabulati che normalmente sono scritti tutti con lettere minuscole.
A tal proposito il C è un linguaggio 'case sensitive' ovvero la variabile (esempio) dominio, è diversa da Dominio. In ogni caso tutte le parole chiave del C (sono solamente una ventina, ad esempio for, oppure float) vanno sempre scritte in minuscolo, altrimenti non vengono correttamente interpretate come tali.

Tornando al problema esaminato una osservazione che ci servirà la prossima volta.

Abbiamo visto che per determinare il dominio di rottura e di snervamento abbiamo fittiziamente ruotato la sezione, piuttosto che l'asse neutro. Questo al fine di semplificare il problema analitico e di riutilizzare praticamente sempre un unico set di funzioni che ci ha permesso di superare in maniera quasi indolore il fatto che la sezione è di forma assolutamente generica.
Ciò che voglio sottolineare è che per data inclinazione dell'asse neutro si determineranno dei momenti flettenti di rottura, con asse momenti x ed y, che stanno in un determinato rapporto (asse vettore del momento risultante con certa inclinazione).
Orbene, in funzione della effettiva geometria della sezione, i momenti di snervamento Mx ed My, sempre per data inclinazione dell'asse neutro, avranno rapporto in generale differente. Così come lo stesso 'fenomeno' potrà riscontrarsi per momenti flettenti calcolati per date curvature ma a parità sempre di inclinazione dell'asse neutro.
Questo implica, e lo vedremo la prossima volta, che se vogliamo un diagramma momenti-curvatura che generalmente sta su un piano, dovremmo fare qualche ulteriore considerazione.

Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: zax2010 on 19 June , 2012, 20:30:38 PM
Parte 18

Completiamo il discorso sulle curvature
Guardiamo questo diagramma:

(http://s13.postimage.org/lrlzokq43/Sezione_generica15.jpg) (http://postimage.org/image/lrlzokq43/)

Non ha importanza da quale sezione esso derivi. In grigio è segnato il dominio di primo snervamento, ed in rosso il dominio di rottura. Il tutto per un certo valore di Nd.
Come già abbiamo visto con le varie routine, abbiamo sempre calcolato per 24 differenti assetti di inclinazione dell'asse neutro, la coppia di momenti (di snervamento o di rottura).
Preso un punto sulla curva snervamento del diagramma di cui sopra ed il corrispondente nel diagramma di rottura, ad essi è associata una ben precisa curvatura.
Poichè abbiamo visto nella parte precedente come procedere al calcolo dei momenti 'espressi' dalla sezione per data curvatura, ipotizzando di suddividere in 10 parti la differenza tra le 2 curvature di cui sopra, potremmo disegnare 9 ulteriori punti tra il punto del diagramma di snervamento ed il punto sul diagramma di rottura.
E calcolando questi ulteriori punti per tutti gli assetti possibili dell'asse neutro ricavare ulteriori 9 domini concentrici più o meno tra loro e ai due domini sopra riportati.
Attenzione però, questo 'esercizio' è di fatto inutile. Infatti tutti i punti uniti, nel sistema di riferimento scelto (Nd,Mx,My) non sarebbero dotati della stessa curvatura, ma semplicemente avrebbero lo stesso 'step' di differenza di curvatura funzione di quanto distante è la curvatura tra il punto di snervamento ed il punto di rottura.

Pertanto se vogliamo capire meglio come si comporta la nostra sezione, dobbiamo modificare la tipologia di rappresentazione. Ovvero fermo restando gli assi Mx ed My, l'asse ortogonale allo schermo non dovrà più essere Nd, ma proprio la curvatura.
Determinando quindi un diagramma tridimensionale che pressapoco avrebbe questa forma:

(http://s17.postimage.org/uqks9yl7v/sezione_generica16.jpg) (http://postimage.org/image/uqks9yl7v/)

In cui la parte più 'piatta', quella posteriore e più blu risulta essere il dominio di snervamento, ma che non è compreso in un piano, ed a maggior ragione non è compreso in un piano il dominio di rottura, la parte di 'corona' del presente diagramma, che presenta dei picchi di curvatura in corrispondenza degli assi principali della sezione che decrescono notevolmente quando l'asse neutro assume inclinazione molto 'deviate'.
Vediamo, utilizzando ovviamente le routine già descritte nella parte precedente, come fare per ricavare tutte le coordinate dei vari punti che costituiscono il presente diagramma.

Facciamo anzitutto un triplo salto carpiato, definendo una struttura dati 'annidata'.

Code: [Select]
struct dom_momenti_curv
{
 struct dominio_rottura mcurv[12];
};

Sostanzialmente si tratta di un vettore di domini di rottura (per la precisione 12 strutture di tipo dominio_rottura differenti - che vi ricordo contiene al suo interno parecchie altre variabili 'elementari' e tutte relative non ad un solo punto ma all'intero dominio costituito da 24 punti), che però in forma di struttura dati potranno essere trattati alla stessa stregua di una singola variabile (e dunque valore restituibile da una funzione)

All'interno della funzione che calcolerà le variabili da piazzare in mcurv, definirò una variabile di tipo dom_momenti_curv, variabile che a fine elaborazioni restituirò alla funzione chiamante.

Spiego prima l'ossatura della funzione, per poi vedere meglio in dettaglio. Anzitutto si calcolano i domini a snervamento ed a rottura. E questo la funzione lo fa semplicemente richiamando la solita funzione calcola_dominio. Con i singoli valori per ogni punto duale di tali domini, si ricava uno step di curvatura e si ricavano quindi 'manualmente' stavolta, punto per punto i valori dei momenti flettenti per data curvatura, dovendo chiamare ogni volta la funzione determina_asse_neutro precedentemente vista.

Code: [Select]
/* Prototipo della funzione */
struct dom_momenti_curv diagramma_m_curv(float);

Code: [Select]
/* Corpo della funzione */
struct dom_momenti_curv diagramma_m_curv(float nd)
{
 int register step,k,ncurv,np,ns;
 int register unsigned j;
 int numcomb;
 float curv_snerv,curv_ult;
 float ymax,yamin;
 struct poligono_sezione polic[NMAXPOLI];
 struct armature_sezione armc;
 struct risultante_n_finale nfin;
 struct dom_momenti_curv m;
 char buffer[100],num[10];

 /* Comincia ad assegnare i valori ai singoli punti del diagramma */
 m.mcurv[0].nd=0.0;
 for (k=0;k<=23;k++)
     {
      m.mcurv[0].mrx[k]=0.0;  m.mcurv[0].mry[k]=0.0;
      m.mcurv[0].nrc[k]=0.0;  m.mcurv[0].nrt[k]=0.0;
      m.mcurv[0].xrc[k]=0.0;  m.mcurv[0].yrc[k]=0.0;
      m.mcurv[0].xrt[k]=0.0;  m.mcurv[0].yrt[k]=0.0;
      m.mcurv[0].epsc[k]=0.0; m.mcurv[0].epss[k]=0.0;
      m.mcurv[0].yn[k]=0.0;   m.mcurv[0].curv[k]=0.0;
     }

 m.mcurv[1]= calcola_dominio(nd,SNERV);
 m.mcurv[11]=calcola_dominio(nd,ULT);

 for (ncurv=0;ncurv<=23;ncurv++) /* Diagramma momento-curvatura per data inclinazione dell'asse neutro */
     {
      float alfa=ncurv*0.261799; /* alfa in radianti – 0.261799=15° */
      float c=cos(alfa),s=sin(alfa);
      /* Calcola una sola volta cos(alfa) e sin(alfa) per evitare elaborazione ogni volta */

      /* Prima copia la sezione in altra struttura dati e poi la ruota di alfa */
      for (np=0;np<=NMAXPOLI-1;np++)
          {
           polic[np]=poli[np];
           for (k=0;k<=poli[np].numv-1;k++)
               {
                polic[np].x[k]= poli[np].x[k]*c+poli[np].y[k]*s;
                polic[np].y[k]=-poli[np].x[k]*s+poli[np].y[k]*c;
               }
          }

      /* Copia le armature in altra struttura dati e poi le ruota di alfa */
      armc=arm;
      for (k=0;k<=arm.numarm-1;k++)
          {
           armc.x[k]= arm.x[k]*c+arm.y[k]*s;
           armc.y[k]=-arm.x[k]*s+arm.y[k]*c;
          }

      /* Poi determina massima ascissa compressa e minima armatura tesa per determinare altezza utile sezione */
      ymax=-100000.0;
      for (np=0;np<=NMAXPOLI-1;np++)
          {
           for (k=0;k<=polic[np].numv-1;k++) if (ymax<polic[np].y[k]) ymax=polic[np].y[k];
          }
      yamin=100000.0;
      for (k=0;k<=armc.numarm-1;k++) if (yamin>armc.y[k]) yamin=armc.y[k];

      m.mcurv[11].curv[ncurv]=(m.mcurv[11].epsc[ncurv]+fabs(m.mcurv[11].epss[ncurv]))/(ymax-yamin);
      m.mcurv[1].curv[ncurv]=(m.mcurv[1].epsc[ncurv]+fabs(m.mcurv[1].epss[ncurv]))/(ymax-yamin);

      for (step=2;step<=10;step++) /* Singoli punti diagramma-curvatura tra snervamento e rottura per data inclinazione dell'asse neutro */
          {
           float curv,xc,yc,xt,yt;

           curv=m.mcurv[1].curv[ncurv]+(step-1)*(m.mcurv[11].curv[ncurv]-m.mcurv[1].curv[ncurv])/10.0;

           nfin=determina_asse_neutro(polic,armc,nd,CURV,curv);

           /* Ripristina il sistema di riferimento delle risultanti */
           xc=nfin.ncf.x*c-nfin.ncf.y*s;
           yc=nfin.ncf.x*s+nfin.ncf.y*c;

           xt=nfin.ntf.x*c-nfin.ntf.y*s;
           yt=nfin.ntf.x*s+nfin.ntf.y*c;

           m.mcurv[step].mrx[ncurv]=nfin.ncf.n*(yc-yg)+nfin.ntf.n*(yt-yg);
           m.mcurv[step].mry[ncurv]=nfin.ncf.n*(xc-xg)+nfin.ntf.n*(xt-xg);
           m.mcurv[step].nrc[ncurv]=nfin.ncf.n;
           m.mcurv[step].nrt[ncurv]=nfin.ntf.n;
           m.mcurv[step].xrc[ncurv]=xc; m.mcurv[step].yrc[ncurv]=yc;
           m.mcurv[step].xrt[ncurv]=xt; m.mcurv[step].yrt[ncurv]=yt;
           m.mcurv[step].epsc[ncurv]=nfin.epsc;
           m.mcurv[step].epss[ncurv]=nfin.epss;
           m.mcurv[step].yn[ncurv]=nfin.yn;
           m.mcurv[step].curv[ncurv]=curv;
          }
     }
 return (m);
}

Quindi calcolati con due sole istruzioni:

Code: [Select]
mcurv[1]= calcola_dominio(nd,SNERV);
mcurv[11]=calcola_dominio(nd,ULT);

i domini di snervamento e rottura, la funzione prosegue, per assegnate inclinazioni dell'asse neutro (contatore ncurv) a ricavare la posizione effettiva dei vertici della sezione e delle armature (ricordatevi la rotazione, non dell'asse neutro, ma fittizia della sezione), e quindi con le curvature a rottura e snervamento ricava tramite il contatore step, il valore effettivo di curvatura compreso tra la curvatura a snervamento ed a rottura:

Code: [Select]
curv=m.mcurv[1].curv[ncurv]+(step-1)*(m.mcurv[11].curv[ncurv]-m.mcurv[1].curv[ncurv])/10.0;
(Dove il diviso 10 si riferisce al fatto che si sta procedendo per 10 step successivi tra la curvatura a snervamento e quella a rottura), e da questo, dato in pasto alla funzione:

Code: [Select]
determina_asse_neutro(polic,armc,nd,CURV,curv);
ricava i dati 'grezzi' per poter infine riempire la variabile m.mcurv[step], che opportunamente richiamata sarà in grado di far disegnare proprio il diagramma visto sopra.

In sintesi si avrà una funzione chiamante più meno fatta in questo modo:

Code: [Select]
.
struct dom_momenti_curv m;
.
m=diagramma_m_curv(soll[k].nd);
.
.

E si avranno dunque tutti i valori per poter disegnare il diagramma tridimensionale della seconda figura. Si è continuato a 'portarsi dietro' tante variabili parziali, quali le deformazioni dei materiali, o la posizione delle risultanti, in modo all'occorrenza di visualizzare o stampare i dati numerici.

E per disegnare invece un diagramma 'classico', bidimensionale in cui in ascissa si abbia la curvatura ed in ordinata i momenti?
Per quello ho fatto una semplice interpolazione dal diagramma 3D. Vista l'inclinazione del vettore Mdy/Mdx (dove Mdx e Mdy sono i valori dei momenti flettenti di calcolo associati al valore Nd di sforzo normale della singola combinazione di sollecitazioni esterne sulla sezione), proietto con semplice interpolazione lineare l'intersezione di questo piano con il diagramma 3D.
Ovviamente ci sarebbe il modo di poter affinare meglio la soluzione facendo variare più fittamente l'inclinazione dell'asse neutro, per data curvatura in modo da avere dei valori Mx ed My che stiano proprio nel rapporto dato dalle sollecitazioni flettenti esterne.

Come al solito, altra struttura dati:

Code: [Select]
struct d_curv
{
 float mx[12];
 float my[12];
 float nc[12];
 float nt[12];
 float xc[12];
 float yc[12];
 float xt[12];
 float yt[12];
 float epsc[12];
 float epss[12];
 float yn[12];
 float ang[12];
 float m[12];
 float crv[12];
};

Con tutte le variabili del caso in numero di 12, come i punti del diagramma (punto 0 origine, punto 1 il punto di snervamento, punto 11 il punto di rottura, punti intermedi tra 1 e 11 a curvatura via via crescenti).
La porzione di codice dovrà inizialmente, per ogni singolo punto del diagramma momenti-curvatura (variabile contatore step) trovare l'intersezione tra il raggio vettore di inclinazione Mdy/Mdx ed il corrispondente dominio (con il contatore ncurv), indi interpolare linearmente tra il punto ncurv ed ncurv+1 del suddetto dominio. In questo modo:

 
Code: [Select]
/* Determina il diagramma M-curv della specifica sollecitazione */
 dcurv.m[0]=0.0; dcurv.crv[0]=0.0;
 for (step=1;step<=11;step++)
     {
      for (ncurv=0;ncurv<=23;ncurv++)
          {
           int ncurvp1;
           double mdom,qdom,mvx,mvy;
           float xsb,xda,ysb,yda;

           if (ncurv==23) ncurvp1=0; else ncurvp1=ncurv+1;

           /* Parametri della retta del diagramma-3D momenti-curvatura */
           mdom=(m.mcurv[step].mry[ncurvp1]-m.mcurv[step].mry[ncurv])/(m.mcurv[step].mrx[ncurvp1]-m.mcurv[step].mrx[ncurv]);
           qdom=m.mcurv[step].mry[ncurv]-mdom*m.mcurv[step].mrx[ncurv];
           /* Determina i vertici del rettangolo basso sinistra e alto destra della retta del dominio */
           if(m.mcurv[step].mrx[ncurvp1]>=m.mcurv[step].mrx[ncurv]) { xsb=m.mcurv[step].mrx[ncurv];   xda=m.mcurv[step].mrx[ncurvp1]; }
           else                                                     { xsb=m.mcurv[step].mrx[ncurvp1]; xda=m.mcurv[step].mrx[ncurv];   }
           if(m.mcurv[step].mry[ncurvp1]>=m.mcurv[step].mry[ncurv]) { ysb=m.mcurv[step].mry[ncurv];   yda=m.mcurv[step].mry[ncurvp1]; }
           else                                                     { ysb=m.mcurv[step].mry[ncurvp1]; yda=m.mcurv[step].mry[ncurv];   }
           /* Intersezione tra diagramma-3D e retta vettore sollecitazioni */
           if (soll[numcomb].mx!=0.0)
              {
               mvx=qdom/(soll[numcomb].my/soll[numcomb].mx-mdom);
               mvy=soll[numcomb].my/soll[numcomb].mx*mvx;
              }
           else /* Vettore verticale */
              {
               mvx=0.0;
               mvy=qdom;
              }

           if (mvx>=xsb && mvx<=xda && mvy>=ysb && mvy<=yda && soll[numcomb].mx*mvx>=0.0 && soll[numcomb].my*mvy>=0.0)
              {
               dcurv.mx[step]=mvx;
               dcurv.my[step]=mvy;
               dcurv.m[step]=sqrt(mvx*mvx+mvy*mvy);
               dcurv.crv[step]=m.mcurv[step].curv[ncurv]+(mvx-m.mcurv[step].mrx[ncurv])*(m.mcurv[step].curv[ncurvp1]-m.mcurv[step].curv[ncurv])/(m.mcurv[step].mrx[ncurvp1]-m.mcurv[step].mrx[ncurv]);
               dcurv.nc[step]=m.mcurv[step].nrc[ncurv]+(mvx-m.mcurv[step].mrx[ncurv])*(m.mcurv[step].nrc[ncurvp1]-m.mcurv[step].nrc[ncurv])/(m.mcurv[step].mrx[ncurvp1]-m.mcurv[step].mrx[ncurv]);
               dcurv.xc[step]=m.mcurv[step].xrc[ncurv]+(mvx-m.mcurv[step].mrx[ncurv])*(m.mcurv[step].xrc[ncurvp1]-m.mcurv[step].xrc[ncurv])/(m.mcurv[step].mrx[ncurvp1]-m.mcurv[step].mrx[ncurv]);
               dcurv.yc[step]=m.mcurv[step].yrc[ncurv]+(mvx-m.mcurv[step].mrx[ncurv])*(m.mcurv[step].yrc[ncurvp1]-m.mcurv[step].yrc[ncurv])/(m.mcurv[step].mrx[ncurvp1]-m.mcurv[step].mrx[ncurv]);
               dcurv.nt[step]=m.mcurv[step].nrt[ncurv]+(mvx-m.mcurv[step].mrx[ncurv])*(m.mcurv[step].nrt[ncurvp1]-m.mcurv[step].nrt[ncurv])/(m.mcurv[step].mrx[ncurvp1]-m.mcurv[step].mrx[ncurv]);
               dcurv.xt[step]=m.mcurv[step].xrt[ncurv]+(mvx-m.mcurv[step].mrx[ncurv])*(m.mcurv[step].xrt[ncurvp1]-m.mcurv[step].xrt[ncurv])/(m.mcurv[step].mrx[ncurvp1]-m.mcurv[step].mrx[ncurv]);
               dcurv.yt[step]=m.mcurv[step].yrt[ncurv]+(mvx-m.mcurv[step].mrx[ncurv])*(m.mcurv[step].yrt[ncurvp1]-m.mcurv[step].yrt[ncurv])/(m.mcurv[step].mrx[ncurvp1]-m.mcurv[step].mrx[ncurv]);
               dcurv.epsc[step]=m.mcurv[step].epsc[ncurv]+(mvx-m.mcurv[step].mrx[ncurv])*(m.mcurv[step].epsc[ncurvp1]-m.mcurv[step].epsc[ncurv])/(m.mcurv[step].mrx[ncurvp1]-m.mcurv[step].mrx[ncurv]);
               dcurv.epss[step]=m.mcurv[step].epss[ncurv]+(mvx-m.mcurv[step].mrx[ncurv])*(m.mcurv[step].epss[ncurvp1]-m.mcurv[step].epss[ncurv])/(m.mcurv[step].mrx[ncurvp1]-m.mcurv[step].mrx[ncurv]);
               dcurv.yn[step]=m.mcurv[step].yn[ncurv]+(mvx-m.mcurv[step].mrx[ncurv])*(m.mcurv[step].yn[ncurvp1]-m.mcurv[step].yn[ncurv])/(m.mcurv[step].mrx[ncurvp1]-m.mcurv[step].mrx[ncurv]);
               dcurv.ang[step]=ncurv*0.261799+(mvx-m.mcurv[step].mrx[ncurv])*0.261799*(ncurvp1-ncurv)/(m.mcurv[step].mrx[ncurvp1]-m.mcurv[step].mrx[ncurv]);
               break;
              }
          }
     }

Vediamo velocemente come funziona la cosa. Innanzitutto si determina l'equazione della retta del singolo segmento costituente il dominio, con il fattore angolare mdom e l'intersezione con l'asse delle ordinate qdom.
Si stabiliscono i vertici del rettangolo, ordinati da quello in basso a sinistra a quello in alto a destra, disegnato dal segmento del dominio (che ne è la diagonale), in modo che calcolata l'intersezione di tale segmento con il raggio vettore di inclinazione Mdy/Mdx si possa decidere se essa intersezione è interna al segmento stesso. Se si, si procede alla interpolazione lineare tra i il punto ncurv ed ncurv+1, e si interrompe il ciclo (istruzione break; perchè non ha senso continuare inutilmente l'elaborazione se si è già trovato cosa si cercava).
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: genoveffo on 23 May , 2013, 18:17:08 PM
ottimo
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: Salvatore Bennardo on 23 May , 2013, 18:49:18 PM
ottimo

Ora finalmente sai cosa ti eri perso nella vita fino ad oggi.
Title: Re:Programma di verifica a presso-flessione deviata di sezioni generiche in c.a
Post by: genoveffo on 25 May , 2013, 12:07:06 PM
Per la verità il programma in questione io l'ho completato qualche mese fa utilizzando excel e poi matlab , ho implementato anche i rinforzi in frp, in acciaio, e sto lavorando sulle verifiche al fuoco. Mi fa piacere che anche altre persone se ne sono interessate. Se posso esservi utile.