-
+2
.Come ben sappiamo in questo forum molti di noi hanno problemi.
I problemi che possiamo risolvere sono prettamente di natura tecnica. Per gli altri.....
Un problema che da sempre affligge il nostro utente quattropassi è la verifica delle flange circolari bullonate.
Non trova programma o algoritmo che proceda come vuole lui. Senza le semplificazioni che spesso vengono adoperate e che illustrerò a breve.
A questo punto io ho deciso di fare un vero e proprio sgarbo a quattropassi. Ebbene si, si tratterà di uno vero sgarbo se riesco a risolvergli il problema, perchè poi bisognerà che egli si trovi un altro problema da risolvere..... e si sa che in qualche modo ai problemi insoluti ci si affeziona.
In generale la verifica di una flangia bullonata si eseguirebbe come per una sezione in cemento armato, con sezione a corona circolare e con i 'ferri di armatura', i bulloni, disposti lungo il perimetro di un cerchio. Come nel caso di una sezione in c.a. una parte della corona circolare risulterà compressa, e quindi reagirà alle forze esterne, ed una parte invece sarà soggetta a trazione ed è come se non esistesse.
Agli SLE non bisognerà introdurre alcun fattore di omogeneizzazione dei ferri (n=15 per intenderci), considerando che i materiali (flangia e bulloni) sono sempre acciaio, ed agli SLU bisognerà indicare che il materiale compresso ha un legame costitutivo che non è quello parabola rettangolo del cls.
Ma questo modo di operare quattropassi lo trova 'impreciso'. Ovvero non tiene conto della reale situazione geometrica della flangia.
Allora, vediamo cosa 'desidera' quattropassi:
1) Nelle verifiche (SLE ed SLU) la porzione compressa delle flange deve tenere conto della presenza dei fori;
2) I bulloni che vanno in compressione non devono essere considerati tra gli oggetti 'resistenti'.
Io ho pensato di utilizzare il mio solito algoritmo per la verifica delle sezioni in c.a., opportunamente modificato, per togliere a quattropassi il problema.
Ho già predisposto una provvisoria interfaccia per un programmino che dovrebbe fare quel che quattropassi vuole. Eccolo qui, seppur ancora 'incompletissimo'.
Non so nemmeno se ho già indovinato tutte le grandezze geometriche necessarie alla risoluzione del problema. E certamente mi mancano parecchi ulteriori input di tipo 'meccanico'.
Ovviamente devo ancora 'montarci' sopra il codice che verifica le sezioni generiche in cemento armato.
Come ricorderete il codice opera su poligoni. Quindi sono costretto a 'poligonizzare' tutti i cerchi, sia quelli costituenti la corona circolare delle flange che i fori dei bulloni.
Codice che dovrò modificare nei seguenti punti:
1) In mio codice originario è 'statico' e prevede un numero di poligoni costituenti la sezione (singoli poligoni che possono essere pieni o vuoti) nel numero massimo di 6;
Spronato anche da altri utenti in questo forum so adesso come operare per rimuovere questa limitazione gestendo la memoria in modo 'dinamico', ed in modo che il codice abbia il numero di poligoni che effettivamente servono (i poligoni sono 2 - corona esterna ed interna - più tutti i fori);
2) Così come il codice è in grado di 'togliere' la porzione di sezione che è in trazione, devo aggiungere l'ulteriore condizione di esclusione dei bulloni che possano trovarsi in compressione.
Per fortuna nel mio codice vi è già la possibilità di considerare un comportamento elastico-indefinitamente plastico della porzione compressa (rispetto al solito parabola-rettangolo).
E' al momento un semplice abbozzo. Caldo torrido permettendo, e stanchezza lavorativa, vedremo di andare avanti prossimamente.
. -
.
Interessante. Lo seguirò da visitatore e cercherò di seguire anche le tue tracce che sicuramente saranno ben delineate e chiare.
Mi spiace non poter contribuire e spero possano farlo coloro che, non interessati dai giochi di prestigio che si sono visti negli ultimi tempi, avranno ancora voglia di seguire e contribuire anche solo nelle critiche finalizzate alla costruzione.
Saluti.. -
.
Ringrazio molto zax2013 per l'attenzione al problema.
Per la verità la flangia circolare è interessante sì, ma non tanto quella rettangola dove i problemi N+Mx+My si fanno ben più articolati (grossomodo nella circoflangia ogni asse di sollecitazione finisce con l'essere principale). -
+1 .
quattropassi.....ma sei proprio incontentabile.
A dirti la verità, intanto che stavo 'giocando' con il programma nuovo, e che pensavo al 'trapianto' di strutture dati, funzioni, ecc. dal mio programma di verifica di sezioni generiche a questo nuovo programmino 'dimostrativo', e pensando poi a quante variabili dovrei 'manipolare' (o fissare, senza possibilità di variazioni) nel programmino (legame costitutivo, parametri di calcolo vari, ecc.) replicando di fatto quanto ho già bello e pronto nel programma 'vero', con tanto di interfaccia pronta........mi sono chiesto se non vale invece la pena di eseguire lo 'sforzo' sul programma 'vero'.
In fondo dovrei semplicemente 'sfondare' il limite dei 6 poligoni che mi ero imposto inizialmente, e creare un nuovo 'oggetto' di input: il bullone.
Bullone che avrebbe le caratteristiche di poter reagire solamente a trazione, eliminandolo nel calcolo se in compressione, e magari con una possibile pretensione come suggeriva in chat Tex.
A questo punto con 'motore' e 'carrozzeria' già pronta dovrei inserire solamente lo 'specchietto retrovisore' costituito da un wizard che generi la flangia con i vari buchi e bulloni.....ed il gioco è fatto (wizard che è proprio l'esperimento di questi giorni). E per farti contento ancor di più, anche lo specchietto lato passeggero: Wizard per la flangia quadrata/rettangolare.
Ma vista la generalità del programma, a questo punto, e con un pò di pazienza, anche la flangia a stella, a forma di nuvola, ecc.
Potrei anche approfittarne per inserire la stampa in rtf ed ecco pronto un progetto di sviluppo che durerà almeno fino a Natale....... -
.
vedo che l'elmo con cimiero è un'icona ricorrente nei programmini di zax...
a parte questo, considerato lo sviluppo orizzontale dei monitor, non sarebbe più opportuno mettere la figura di fianco?. -
.
Reversi, l'elmo romano da legionario è icona standard di tutti i nuovi progetti sviluppati con il mio compilatore.
Così come i progetti in Lazarus sviluppati da afazio hanno una icona standard costituita dalle impronte di un felino.
Non saprei dirti il perchè di tale scelta da parte della softwarehouse (che era in origine la Borland, che con Delphi ha una sorta di busto di Venere o altra dea come icona standard).
Poichè il mio compilatore è della serie Builder, le icone alternative settabili variano da una sorta di skyline di palazzi in costruzione ad altre ancora più scipite.. -
.
nel frattempo che scrivevo il post precedente, zax scriveva: ........mi sono chiesto se non vale invece la pena di eseguire lo 'sforzo' sul programma 'vero'.
bene, se così sarà, non dimenticare di correggere questo errore di visualizzazione, e questo altro piccolo errore nel codice.. -
Paolo Rugarli .
User deleted
Non trova il programma ma esiste da anni.... 😊
Sì chiama connection study environment.
Circa l E eguale a quello dell'acciaio non sono d'accordo : dipende.
Ho molto lavorato sulle bullonature con superficie di contrasto.
Molto è spiegato in documenti liberamente scaricabili.
Ps
Mi spiace vedere quel che sta succedendo qui: è un peccato.. -
.
Ok, diciamo che per adesso mi sono convinto a procedere aggiungendo al programma 'serio' quello che serve per la verifica delle flange bullonate così come dai desideri di 4p. In questo modo posso ottenere verifiche SLE ed SLU senza grossi lavori di programmazione.
Vediamo inizialmente cosa significa aggiungere un 'oggetto' bullone.
Relativamente alle armature il solito codice ha questa struttura dati:CODICE/* -------------------------------------------------------------------------- */
/* Struttura dati in cui sono definiti i dati delle singole barre di armatura */
/* presenti nella sezione */
/* -------------------------------------------------------------------------- */
struct armature_sezione
{
float af[NMAXARM]; /* area della barra di armatura */
float diam[NMAXARM]; /* diametro della barra */
float x[NMAXARM]; /* coordinata x della barra */
float y[NMAXARM]; /* coordinata y della barra */
int numarm; /* numero di barre per l'intera sezione */
float omogarm; /* coefficiente di omogeneizzazione (per verifiche SLE) */
char qualitarm[10]; /* Nome di norma dell'acciaio */
float fydarm; /* Tensione di calcolo di snervamento */
float epsc0arm; /* Deformazione a snervamento acciaio */
float epscuarm; /* Deformazione ultima acciaio */
int selez[NMAXARM]; /* 1=armatura selezionata 0=armatura non selezionata */
int cong[NMAXARM]; /* 0=non congelato 1=congelato */
float Earm; /* Modulo elastico acciaio armature */
float incrarm; /* Fattore di incrudimento acciaio > 1.0 */
};
Diciamo che per il bullone tutti questi dati sono anch'essi necessari. Ma con l'aggiunta di qualche campo.
Penso ad esempio ad una doppia area, non si sa mai, l'area del bullone filettato e l'area del gambo (in effetti se dovessimo eseguire la verifica a taglio la differenziazione avrebbe certamente senso, ma lavorando solamente a trazione probabilmente è inutile).
Ma un campo essenziale che va introdotto è un flag che indichi se il bullone è in trazione oppure in compressione.
Nelle verifiche SLU il flag sarebbe di fatto inutile. Essendo il codice organizzato in modo che la parte compressa della sezione è sempre quella superiore e l'asse neutro sempre orizzontale (ricordate? per la determinazione del dominio di rottura viene ruotata la sezione e determinata la posizione dell'asse neutro considerandolo sempre orizzontale). Quindi è facile stabilire se conteggiare o meno un bullone: basta controllare la sua ordinata. Se essa è maggiore della ordinata dell'asse neutro, il bullone è in compressione ed esso, rispondendo ai desideri di 4p, non deve essere considerato.
Ma per le verifiche SLE con assi neutri dei più variamente sbiecati non è così più semplice stabilire la compressione/trazione del bullone dalle sue coordinate.
Nella procedura SLE, che procede per iterazioni, ad ogni iterazione sarà possibile stabilire se il bullone è compresso o teso, quindi si inizializzerà il flag di conseguenza. Quando si darà in pasto l'intera struttura 'bulloni' alla funzione che determina le caratteristiche geometriche della sezione, sarà quest'ultima a decidere, tramite il flag, se considerare o meno il bullone.
Rimane ovvio che per me il bullone sarà schematizzato come un punto nella sezione. Esattamente come le armature.. -
.
La geometria
Prima di partire con le funzioni di calcolo, bisogna organizzare l'input.
La sezione in definitiva è costituita da una serie di cerchi, pieni o vuoti. I 2 della flanga (il cerchio esterno pieno, quello interno vuoto), e tutti i cerchi che costituiscono i fori.
Ma come dicevo nel primo post il codice funziona solamente con poligoni di lati rettilinei. Quindi i cerchi verranno approssimati con poligoni regolari inscritti ai vari cerchi.
Nella schermata di input (del wizard o del programma stand-alone) oltre al diametro infatti sono presenti tutti i controlli che definiscono il numero di punti che andranno ad approssimare i vari cerchi. Ho inserito la limitazione di 16 punti come minimo, ma posso arrivare anche a 100 per ogni singolo cerchio.
Quindi ho creato la funzione che restituisce un poligono 'circolare':CODICEstruct poligono_sezione definisci_poli_cerchio(float fi_cerchio,int npunti,float xc,float yc)
{
int register k;
float pi,alfa,alfa_step;
struct poligono_sezione circle;
pi=4*atan(1);
alfa_step=2*pi/npunti;
alfa=0;
for (k=0;k<=npunti-1;k++)
{
circle.x[k]=xc+fi_cerchio/2*sin(alfa);
circle.y[k]=yc-fi_cerchio/2*cos(alfa);
alfa+=alfa_step;
}
return (circle);
}
Semplice geometria polare, che non vale la meno nemmeno spiegare. xc ed yc il centro del cerchio.
Quindi da qualche parte ci sarà un codice del genere:CODICE/* Inserisce i dati nei singoli poligoni */
poli=(struct poligono_sezione *) calloc(2,sizeof(struct poligono_sezione));
/* Cerchio esterno */
poli[0]=definisci_poli_cerchio(diame,discre,0.0,0.0);
poli[0].omog=1.0;
/* Cerchio interno */
poli[1]=definisci_poli_cerchio(diami,discri,0.0,0.0);
poli[1].omog=-1.0;
/* Alloca memoria per i cerchi dei singoli fori */
poli=(struct poligono_sezione *) realloc(poli,(2+numf)*sizeof(struct poligono_sezione));
pi=4*atan(1);
alfa_step=2*pi/numf;
alfa=0.0;
/* Quindi definisce i singoli fori */
for (k=0;k<=numf-1;k++)
{
px=x+diamf/2*sin(alfa);
py=y-diamf/2*cos(alfa);
poli[k+2]=definisci_poli_cerchio(diamff,discrf,px,py);
poli[k+2].omog=-1.0;
alfa+=alfa_step;
}
Ovvero il richiamo della funzione definisci_poli_cerchio() per ogni singolo poligono che costituisce la sezione.
L'occupazione in memoria viene gestita in maniera dinamica. Per cui inizialmente viene riservata memoria per 2 poligoni (il diametro esterno ed interno della flangia), quindi viene aumentata la dimensione del vettore in base al numero dei fori nella flangia stessa.
La flangia viene posta con centro dei cerchi nel punto di coordinate 0,0 - i centri dei fori vengono determinati anche loro tramite semplice geometria polare.
In corrispondenza del centro di ogni foro verrà infine posizionato l'oggetto 'bullone' di cui tratterò nel prossimo post.. -
.
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....... -
Paolo Rugarli+2 .
User deleted
Posto qualche immagine che può indurre a qualche riflessione.
Come ho accennato mi sono occupato a lungo di un problema generale che ricomprende questo: le bullonature con superficie di contrasto.
La superficie di contrasto è il luogo dei punti che possono scambiare tensioni di compressione le quali aiutano la bullonatura a portare azioni assiali o momenti che comportino distribuzioni di tensioni normali di compressione.
A seconda dei casi, la superficie di contrasto può coinvolgere l'intera superficie di contatto o solo una parte. Chi decide è la flessibilità della piastra (cfr formula di EC3.1.3 ovvero la "orlatura" di un impronta di carico con la parte limitrofa di piastra che reagisce. La larghezza della orlatura altro non è che la luce della mensola che porta il carico sigma dando luogo a un momento sigma*L^2/2 resistito da flim * t^2 / 4, essendo flim la tensione di snervamento della piastra. Decisa la sigma max si decide l'ampiezza di orlatura e si sa che la piastra sarà in grado di portare la sigma = pressione normale = carico applicato).
A seconda dello spessore della piastra e della presenza di irrigidimenti, la superficie di contrasto può limitarsi alla mera impronta di carico (tubo+irrigidimenti) o alla intera superficie di contatto o situazioni intermedie (come in figura).
La legge costitutiva del contrasto dipende dalle situazioni. In questo caso il contrasto è un plinto solido, e dunque una buona legge costitutiva è la parabola rettangolo. In altri casi, ad esempio per i collegamenti flangiati, i problemi sono totalmente diversi. Se il contrasto è molto rigido la rotazione avviene attorno a un punto minimo intorno a un lato o punto di contatto.
Qui si vede la distribuzione di tensioni normali di contatto:
Anche interessante è il problema della verifica del pezzo bullonato e dei suoi irrigidimenti, che io spesso risolvo con la automatica creazione di un modello fem (pochi secondi e il modello è pronto....). Vedi figura.
L'analisi può essere condotta in campo lineare (come nella immagine successiva dove il max evidenziato è 261.11 per avere in rosso le zone che superano 235), oppure in campo non lineare, con non linearità di contatto, di materiale e geometrica, selezionabili disgiuntamente (la NL di contatto porta a una "vera" distribuzione di tensioni normali scambiate e determina per via iterativa la "vera" superficie di contrasto).
L'argomento, come ho detto, è stato oggetto da parte mia di numerosi studi portati avanti sin dall'anno 2000. Capite che non potevo esimermi dal dire la mia :-) E' un lavoro interessantissimo .
Qui il collega Marco Croci ha spiegato (lezioni multimediali):
www.castaliaweb.com/ita/P/CSE/lezioni/205_Ter_Contrasto.exe
http://www.castaliaweb.com/ita/P/CSE/lezio..._Superficie.exe
http://www.castaliaweb.com/ita/P/CSE/lezio...Costitutiva.exe. -
.
Grazie Rugarli per l'interessante intervento.
Tra l'altro vidi già che la cosa era molto studiata presso il Florida D.O.T.
http://www.dot.state.fl.us/structures/stru...edResearch.shtm
In particolare il report di Ron COOK:
Use of Grout Pads for Sign and Lighting Structures Part-1 Structural Evaluation
http://www.dot.state.fl.us/structures/stru.../FDOT_BB512.pdf
Design Guidelines for Annular Base Plates
http://www.dot.state.fl.us/structures/stru...plates(inc).pdf
Comunque le flange da considerare sono di due tipologie:
la flangia di base (con grout pad)
che può pure esser quadrata
e la flangia tubo-tubo
. -
Paolo Rugarli .
User deleted
Caro quattropassi non conoscevo questi documenti avendo lavorato in solitudine e sostanzialmente per conto mio: comunque è sempre interessante vedere come hanno fatto gli altri e li guarderò appena riuscirò ad avere il tempo. CITAZIONEcomunque le flange da considerare sono di due tipologie
Nel mio approccio ai collegamenti la forma è generica. La flangia può avere la forma che si vuole e così gli irrigidimenti: l'approccio (e gli studi che lo hanno consentito) sono generali. Questo è appunto il bello. Potrei fare lo stesso calcolo con un tubo ellittico o con una sezione a forma di ghirigoro. Posizionando liberamente bulloni e costole di irrigidimento.
Sì, certo che il problema tubo-tubo esiste anche lui l'ho ben presente, ma come ho detto per me questi sono tutti casi particolari di una trattazione molto generale (che è quella che mi interessava).. -
.Potrei fare lo stesso calcolo con un tubo ellittico o con una sezione a forma di ghirigoro.
e dai, dai, voglio proprio vedere: https://bar-ingegneria.forumfree.it/?t=71173777
.
La foroflangia |
