Author Topic: Programma di verifica a presso-flessione deviata di sezioni generiche in c.a  (Read 134606 times)

0 Members and 1 Guest are viewing this topic.

Offline afazio

  • Veterano del forum
  • ****
  • Posts: 663
  • Karma: 273
  • dovizio mi delizio
    • CI si vede al Bar
@ 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.
« Ogni qualvolta una teoria ti sembra essere l’unica possibile, prendilo come un segno che non hai capito né la teoria né il problema che si intendeva risolvere. »
K.P.

zax2010

  • Guest
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...).
« Last Edit: 15 June , 2011, 08:38:55 AM by zax2010 »

zax2010

  • Guest
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.

Offline ferrarialberto

  • Semi Esperto
  • **
  • Posts: 137
  • Karma: 26
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.
ing. FERRARI Alberto - www.ferrarialberto.it

Offline afazio

  • Veterano del forum
  • ****
  • Posts: 663
  • Karma: 273
  • dovizio mi delizio
    • CI si vede al Bar
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.
« Ogni qualvolta una teoria ti sembra essere l’unica possibile, prendilo come un segno che non hai capito né la teoria né il problema che si intendeva risolvere. »
K.P.

Offline ferrarialberto

  • Semi Esperto
  • **
  • Posts: 137
  • Karma: 26
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.
ing. FERRARI Alberto - www.ferrarialberto.it

Offline ferrarialberto

  • Semi Esperto
  • **
  • Posts: 137
  • Karma: 26
...
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.
ing. FERRARI Alberto - www.ferrarialberto.it

zax2010

  • Guest
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:



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:



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?
« Last Edit: 16 April , 2011, 12:27:35 PM by zax2010 »

Offline afazio

  • Veterano del forum
  • ****
  • Posts: 663
  • Karma: 273
  • dovizio mi delizio
    • CI si vede al Bar

Guardiamo la seguente figura:




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]
« Last Edit: 16 April , 2011, 14:04:29 PM by Gilean »
« Ogni qualvolta una teoria ti sembra essere l’unica possibile, prendilo come un segno che non hai capito né la teoria né il problema che si intendeva risolvere. »
K.P.

zax2010

  • Guest
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?

Offline afazio

  • Veterano del forum
  • ****
  • Posts: 663
  • Karma: 273
  • dovizio mi delizio
    • CI si vede al Bar
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.
« Ogni qualvolta una teoria ti sembra essere l’unica possibile, prendilo come un segno che non hai capito né la teoria né il problema che si intendeva risolvere. »
K.P.

Offline SpinoWeb

  • Novizio del forum
  • *
  • Posts: 26
  • Karma: 5
  • Novizio
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) ). 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.

Offline ferrarialberto

  • Semi Esperto
  • **
  • Posts: 137
  • Karma: 26
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.
ing. FERRARI Alberto - www.ferrarialberto.it

Offline Betoniera

  • Esperto del forum
  • ***
  • Posts: 217
  • Karma: 74
  • Neo - Laureato
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.



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





« Last Edit: 17 April , 2011, 15:45:43 PM by Betoniera »

Offline ferrarialberto

  • Semi Esperto
  • **
  • Posts: 137
  • Karma: 26
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.
ing. FERRARI Alberto - www.ferrarialberto.it

 

Sitemap 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24