|
|
|
Le verifiche SLE
Al momento ho totalmente escluso, per mie deficienze mental-concettuali, la possibile pretensione nei bulloni.
Dovremmo però prima o poi parlarne.
Accontentiamoci quindi al momento della struttura dati che definisce tutti i bulloni presenti nella sezione:
CITAZIONE /* -------------------------------------------------------------------------- */
/* Struttura dati in cui sono definiti i dati dei singoli bulloni */
/* presenti nella sezione */
/* -------------------------------------------------------------------------- */
struct bulloni_sezione
{
float af[NMAXBUL]; /* area del bullone */
float diam[NMAXBUL]; /* diametro del bullone */
float x[NMAXBUL]; /* coordinata x del bullone */
float y[NMAXBUL]; /* coordinata y del bullone */
int numbull; /* numero di bulloni per l'intera sezione */
float omogbull; /* coefficiente di omogeneizzazione (per verifiche SLE) */
char qualitbull[10]; /* Nome di norma dell'acciaio */
float fydarm; /* Tensione di calcolo di snervamento */
float epsc0bull; /* Deformazione a snervamento bullone */
float epscubull; /* Deformazione ultima bullone */
int selez[NMAXBUL]; /* 1=bullone selezionate 0=bullone non selezionato */
int cong[NMAXBUL]; /* 0=non congelato 1=congelato */
float Ebull; /* Modulo elastico acciaio bullone */
float incrbull; /* Fattore di incrudimento acciaio > 1.0 */
int compr[NMAXBUL]; /* 0=bullone compresso 1=bullone in trazione */
};
Ho evidenziato in rosso l'unico campo della struttura dati che differenzia il bullone dalle armature ordinarie.
Ossia una variabile che consenta alle varie routine di decidere se avere a che fare o meno con il bullone conoscendone il suo stato tensionale, se di compressione o di trazione.
Per le verifiche SLE, una volta avuta la geometria della sezione, i fattori di omogeneizzazione dei vari contorni (1.0 per le parti 'piene', -1.0 per quelle vuote (i fori di alloggio dei bulloni), e la posizione dei bulloni, con relativo fattore di omogeneizzazione che potrà valere 1.0 se stiamo trattando un giunto intermedio di una struttura metallica, oppure 15.0 (?) se stiamo trattando una flangia in fondazione a contatto con il calcestruzzo, la verifica agli SLE avviene con le solite due funzioni.
Con piccole, anzi piccolissime variazioni.
Ricorderete che la verifica SLE era costituita nel mio codice da 2 sole funzioni. Una funzione 'principale' che si occupava di risolvere iterativamente il problema trovando di volta in volta quale porzione della sezione era reagente e quale no, ed altra funzione 'di servizio' che determinava le caratteristiche geometriche (area, inerzie, ecc.) della sezione effettivamente reagente.
La funzione principale piglierà quindi questo aspetto:
CITAZIONE /* -------------------------------------------------------------------------- */
/* Scopo funzione : Calcola le deformazioni della sezione (SLE) per date */
/* sollecitazioni, in modo da calcolare le tensioni in */
/* ogni singolo vertice o barra di armatura della sezione */
/* Parametri formali: Struttura dati con le sollecitazioni di calcolo (soll) */
/* xgs,ygs=coordinate polo di sollecitazioni (baric. plgn) */
/* Valore restituito: Struttura dati con la tripletta deformativa */
/* Implementazione : Luglio 2011 */
/* Autore : Zax2010 */
/* Ultima modifica : Luglio 2015 */
/* Autore : Zax2013 */
/* -------------------------------------------------------------------------- */
struct deform verifica_SLE(struct soll_esterne soll,float xgs,float ygs)
{
int register k,np;
float norma,norma1=1.0;
float s1,s2;
struct deform def;
struct poligono_sezione polic[NMAXPOLI];
/*
struct geometria_sezione_verSLE geo;
*/
/* La funzione utilizza la struttura dati polic, in cui vengono memorizzati */
/* dai poligoni reali della sezione le sole porzioni compresse per effetto */
/* delle azioni esterne. Tale struttura dati viene girata alla funzione */
/* calcola_caratt_geometriche() che così può conteggiare correttamente le */
/* caratteristiche geometriche della sola sezione reagente. */
/* 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); }
/* Dati iniziali di primo tentativo */
def.u[0]=1.0; def.u[1]=0.0; def.u[2]=0.0;
do
{
float parz;
/* Rende il vettore del risultato attuale identico al vettore del risultato precedente */
/* norma1 viene ricalcolato alla fine del ciclo in modo da confrontarlo con norma ed */
/* eventualmente interrompre il ciclo. Il valore iniziale di norma1 è 1.0 */
/* poichè associato alla tripletta 1,0,0 */
norma=norma1;
/* Determina dai poligoni di input le sole parti compresse memorizzandole in polic */
for (np=0;np<=NMAXPOLI-1;np++)
{
/* Se il poligono reagisce anche a trazione 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]-ygs)*def.u[1]+(poli[np].x[poli[np].numv-1]-xgs)*def.u[2];
polic[np].numv=0; polic[np].omog=poli[np].omog;
/* Poi calcola la tensione vertice per verifica del singolo poligono */
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]-ygs)*def.u[1]+(poli[np].x[k]-xgs)*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;
}
}
/* Determina quali bulloni sono in compressione per non conteggiarli nella geometria */
for (k=0;k<=bull.numbull-1;k++)
{
/* Calcola la tensione nel bullone per prendere decisioni */
s2=def.u[0]+(bull.y[k]-ygs)*def.u[1]+(bull.x[k]-xgs)*def.u[2];
if (s2>0.0) bull.compr[k]=0; else bull.compr[k]=1;
/* La funzione calcola_caratt_geometriche() tiene conto del valore di compr[k] */
}
/* Con i nuovi contorni chiama la funzione che determina le caratteristiche geometriche della sezione reagente */
def.geo=calcola_caratt_geometriche(polic,arm,bull,xgs,ygs);
/* Risolve l'equazione a 3 incognite */
parz=def.geo.ix*def.geo.area-pow(def.geo.scx,2);
def.u[2]=((soll.my*def.geo.area-soll.n*def.geo.scy)*parz-(soll.mx*def.geo.area-soll.n*def.geo.scx)*(def.geo.ixy*def.geo.area-def.geo.scy*def.geo.scx))/((def.geo.iy*def.geo.area-def.geo.scy*def.geo.scy)*parz-pow(def.geo.ixy*def.geo.area-def.geo.scy*def.geo.scx,2));
def.u[1]=((soll.mx*def.geo.area-soll.n*def.geo.scx)-(def.geo.ixy*def.geo.area-def.geo.scx*def.geo.scy)*def.u[2])/parz;
def.u[0]=soll.n/def.geo.area-def.u[1]*def.geo.scx/def.geo.area-def.u[2]*def.geo.scy/def.geo.area;
/* Calcola il vettore del risultato in modo da confrontarlo con il precedente */
norma1=sqrt(pow(def.u[0],2)+pow(def.u[1],2)+pow(def.u[2],2));
}
while (fabs(norma1-norma)>1e-3);
return (def);
}
Anche qui in rosso ho evidenziato le righe che ho dovuto aggiungere per tenere conto dei bulloni.
Si tratta di poche righe che di fatto inizializzano la nuova variabile compr aggiunta nella struttura bullone_sezione. Controllando se la tensione nel bullone (in funzione della tripletta deformativa) è di compressione la variabile bull.compr[k] assume valore 0, altrimenti 1.
Questi valori vengono poi utilizzati nella funzione che determina le caratteristiche geometriche della sezione reagente:
CITAZIONE /* -------------------------------------------------------------------------- */
/* Scopo funzione : Calcola le caratteristiche geometriche della sezione. */
/* Le sole necessarie per le verifiche SLE. */
/* Rispetto al baricentro della sezione senza armature */
/* (polo delle sollecitazioni --> xgs,ygs) */
/* Parametri formali: Puntatore a struttura dati dei singoli poligoni che co- */
/* stituiscono la sezione (in questo modo si possono pro- */
/* cessare poligoni differenti da quelli di input, ad esem-*/
/* pio la sola parte reagente) */
/* armc struttura dati con caratteristiche delle armature */
/* bullc struttura dati con caratteristiche dei bulloni */
/* xgs,ygs=coordinate polo di sollecitazione (baric. plgn) */
/* Valore restituito: struttura dati con tutte le caratteristiche geometriche */
/* calcolate */
/* Implementazione : Luglio 2011 */
/* Autore : Zax2010 */
/* Ultima modifica : Luglio 2015 */
/* Autore : Zax2013 */
/* -------------------------------------------------------------------------- */
struct geometria_sezione_verSLE calcola_caratt_geometriche (struct poligono_sezione *polic,struct armature_sezione armc,struct bulloni_sezione bullc,float xgs,float ygs)
{
int register k,kp1,np;
float a,d,hy,hx;
struct geometria_sezione_verSLE 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<=NMAXPOLI-1;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]-ygs;
hx=polic[np].x[k]-xgs;
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 ordinarie nelle caratteristiche statiche */
for (k=0;k<=armc.numarm-1;k++)
{
if (armc.af[k]!=0.0 && armc.cong[k]==0)
{
geo.area+=armc.omogarm*armc.af[k];
geo.scx+=armc.omogarm*armc.af[k]*(armc.y[k]-ygs);
geo.scy+=armc.omogarm*armc.af[k]*(armc.x[k]-xgs);
geo.ix+=armc.omogarm*armc.af[k]*pow(armc.y[k]-ygs,2);
geo.iy+=armc.omogarm*armc.af[k]*pow(armc.x[k]-xgs,2);
geo.ixy+=armc.omogarm*armc.af[k]*(armc.x[k]-xgs)*(armc.y[k]-ygs);
}
}
/* Inserisce i bulloni nelle caratteristiche statiche */
for (k=0;k<=bullc.numbull-1;k++)
{
if (bullc.af[k]!=0.0 && bullc.cong[k]==0)
{
geo.area+=bullc.compr[k]*bullc.omogbull*bullc.af[k];
geo.scx+=bullc.compr[k]*bullc.omogbull*bullc.af[k]*(bullc.y[k]-ygs);
geo.scy+=bullc.compr[k]*bullc.omogbull*bullc.af[k]*(bullc.x[k]-xgs);
geo.ix+=bullc.compr[k]*bullc.omogbull*bullc.af[k]*pow(bullc.y[k]-ygs,2);
geo.iy+=bullc.compr[k]*bullc.omogbull*bullc.af[k]*pow(bullc.x[k]-xgs,2);
geo.ixy+=bullc.compr[k]*bullc.omogbull*bullc.af[k]*(bullc.x[k]-xgs)*(bullc.y[k]-ygs);
}
}
return (geo);
}
Anche qui in rosso le aggiunte.
Se la variabile bullc.compr[k] vale 0 (ovvero il bullone è compresso) tutte le espressioni contenute nella nuova porzione di codice varranno 0, ovvero non si modificheranno aree, momenti statici, inerzie.
Proprio quello che volevamo: il bullone compresso è come non esistesse.
Alla fine delle elaborazioni, avremo ottenuto una tripletta deformativa che ci consentirà di ricavare le tensioni in ogni punto della sezione. Quindi potremo avere le tensioni di trazione anche nel punto in cui abbiamo schematizzato il bullone. Moltiplicata tale tensione per l'area del bullone avremo ricavato il suo 'tiro'.
Prima o poi però dovremo ritornare a parlare della pretensione......
|
|
.
.
