-
+1
.La condivisione è potente.
Nel topic Verifiche sezioni complesse in c.a. agli SLE ed SLU ho voluto tradurre in VBA un codice che l'utente Zax aveva gentilmente condiviso ed illustrato nel forum ingegneriaforum per poter avere a disposizione quanto lo stesso zax aveva fatto in ambiente C++ anche nel più popolare Excel, strumento a portata di tutti.
La mia speranza era quella di riuscire a coinvolgere tante più persone possibile e sopratutto destare il loro interesse e mettere in moto anche la loro creatività. Cosa che in effetti è accaduta.
Se zax non avesse condiviso il suo codice, ma più che il codice, se non avesse condiviso la sua idea su come poter risolvere la questione delle sezioni generiche, io non avrei avuto la possibilità di poter fare nulla. E nemmeno chi successivamente ha aggiunto o modificato qualche cosa.
Altri oltre me, come speravo, si sono interessati ed hanno contribuito a portare a termine quello che era lo scopo iniziale e cioè scrivere una serie di routine e di funzioni che leggendo i dati da un foglio excel restituiscono i risultati in forma utile da poter tracciare il dominio di rottura di una sezione qualsiasi.
Successivamente altri si sono chiesti se era possibile sfruttare quelle procedure ed applicarle anche alle sezioni in cemento armato precompresso.
L'utente di questo forum Texitaliano seguendo qualche suggerimento dell'utente Francesco Coppola (perchè questo utente ha condiviso parte delle sue conoscenze sotto forma di un suggerimento? ) è riuscito a comporre un foglio che basandosi sulle procedure sviluppate, risolve anche una sezione in CAP.
In questo topic intendo riportare quanto ha fatto Texitaliano, ma partendo dall'ultima versione del foglio pubblicato nel topic a cui faccio riferimento. Ed infine intendo rendere pubblico e liberamente utilizzabile da chiunque il risultato finale. Naturalmente non potro fare a meno dell'aiuto/contributo dello stesso Texitaliano
La partecipazione è aperta a tutti coloro che condividono il potente principio della condivisione, chi invece non condivide la condivisione, di quanto qui pubblicato puo' farsene privatamente quel che più gradisce ma tenendo conto che qualora pubblicasse qui qualcosa di suo, questo sarebbe sottoposto al principio della libera condivisione.
Il mio ringraziamento oltre che a zax ,autore ed ideatore originario, va anche a Texitaliano.Attached Image
. -
+1 .
Ringrazio Zax2013, AFazio, GIaria per il loro contributo, oltre che i suggerimenti di Francesco.Coppola i quali mi hanno permesso di estendere il foglio al calcolo ed alla visualizzazione del diagramma del dominio di rottura anche alle travi in cap di qualsiasi forma in pressoflessione deviata.
Brevemente vado ad illustrare le modifiche principali fatte al foglio di calcolo VerSectZax.
Innanzitutto definiamo il legame costitutivo bilineare dell'acciaio di precompressione come da normativa EC2.
Uploaded with ImageShack.us
Il codice relativo è il seguente:CODICE' --------------------------------------------------------------------------
' Nome funzione : elast_plast_indefps(
' Scopo funzione : Dal diagramma elasto-plastico lineare adimensionalizzato
' ricava un fattore alfa, funzione della deformazione,
' che moltiplicato per fydp da la effettiva tensione nei
' trefoli
' Parametri formali: def=valore della deformazione dell'acciaio, fydp=tensione
' di snervamento, Ep=modulo elastico dell'acciaio.
' Valore restituito: fattore alfa compreso tra 0 ed 1.xx
' Implementazione : Novembre 2012
' Autore : Tex
' --------------------------------------------------------------------------
Private Function elast_plast_indefps(def As Double, fydp As Double, Ep As Double)
'def --> deformazione della fibra di cls all'altezza del cavo.
'1.15 < k < 1.35 pendenza del tratto plastico valori consigliati da normativa
'cautelativamente usiamo k = 1.15
Const k As Double = 1.15
'euk = 0.035 deformazione di rottura 35 per mille
Const euk As Double = 0.035
Dim coeff As Double
coeff = fydp / Ep
If def >= coeff Then
'elast_plast_indefps = 1#
'Dim A As Double, b As Double
'Dim A1 As Double, B1 As Double
'A = (k - 1#) * fydp
'b = euk - coeff
'B1 = def - coeff
'A1 = A * B1 / b
'elast_plast_indefps = (fydp + A1) / fydp
'ricomponiamo la funzione in un calcolo unico
'elast_plast_indefps = ((fydp - def * Ep) * k + (def - euk) * Ep) / (fydp - euk * Ep)
'dividiamo il tutto per Ep
'elast_plast_indefps = ((fydp / Ep - def) * k + (def - euk)) / (fydp / Ep - euk)
'assegnamo coeff=fydp/Ep da cui
elast_plast_indefps = ((coeff - def) * k + (def - euk)) / (coeff - euk)
Else
elast_plast_indefps = def * Ep / fydp
End If
End Function
Andiamo a definire inoltre una struttura dati per contenere le coordinate dell'acciaio da precompressione, in questo caso per comodità estendiamo la struttura preesistente delle barre di armatura ordinaria:CODICE' -------------------------------------------------------------------------- '
' Struttura dati in cui sono definiti i dati delle singole barre di armatura '
' presenti nella sezione '
' -------------------------------------------------------------------------- '
Public Type armature_sezione
af() As Double ' area della barra di armatura o del trefolo (1 To NMaxArm)
X() As Double ' coordinata x della barra o del trefolo (1 To NMaxArm)
Y() As Double ' coordinata y della barra o del trefolo (1 To NMaxArm)
omogarm() As Double ' coefficiente di omogeneizzazione barre o trefoli (per verifiche SLE) (1 To NMaxArm)
numarm As Integer ' numero di barre e trefoli per l'intera sezione
fyd() As Double ' Tensione snervamento barre o trefoli
sigma_sp0() As Double ' Tensione dei trefoli depurata dalle perdite
def_prec() As Double ' deformazione trefolo dovuto alla precompressione depurata dalle perdite
End Type
' -------------------------------------------------------------------------- '
Bisogna definire la tensione di tesatura dei trefoli sigmaspi, per brevità diamo una percentuale di perdita del 22.4% a tempo infinito.
Per un calcolo più accurato delle perdite si rimanda ai testi di normativa, ed alla bibliografia esistente.
Per lo stato deformativo iniziale dovuto alla precompressione scriviamo questa struttura:CODICEarmp.numarm = NMaxArmp
For i = 1 To n_cavi_sez
armp.X(i) = cx(i) '[mm]
armp.Y(i) = cy(i) '[mm]
armp.af(i) = Asp(i) 'Af [mm2]
armp.omogarm(i) = nsp - 1# 'tengo conto del foro nel cls
armp.fyd(i) = fyd / gammasp 'Tensione snervamento trefoli di progetto
armp.sigma_sp0(i) = sigma_preteso_ultimo(i) - sigma_perdite_ultimo(i)
armp.def_prec(i) = -armp.sigma_sp0(i) / E_armp
Next
Infine calcolo N dovuto alle forze di precompressione sommato a N dovuto ai carichi esterni da applicare alla sezione.CODICEPublic Sub Calcolo_precompressione(ByVal N_ As Double, ByVal Mx_ As Double, ByVal My_ As Double, _
Nd As Double, Mx As Double, My As Double)
'Caratteristiche di sollecitazione dovute ai carichi esterni.
'N_ sforzo normale (compressione positiva) [N]
'Mx_ momento flettente in direzione x [N*mm]
'My_ momento flettente in direzione y [N*mm]
'nd = N_ + N_p --> sforzo assiale per carichi assiali + precomp.
'Mx = Mx_ + Mx_p --> momento per carichi verticali + momento precomp.
'My = My_ + My_p --> momento per carichi orizzontali + momento precomp.
ReDim sigma_preteso_ultimo(0 To n_cavi_sez) As Double
ReDim sigma_perdite_ultimo(0 To n_cavi_sez) As Double
Dim i As Integer
'Tensione iniziale di tesatura
For i = 1 To n_cavi_sez
sigma_preteso(i) = sigma_spi
Next i
'Tensioni nei cavi amplificate (o ridotte)
Dim g_prec As Double
g_prec = 1#
For i = 1 To n_cavi_sez
sigma_preteso_ultimo(i) = sigma_preteso(i) * g_prec
Next i
'*****************************************************************
'Determinazione della sollecitazione dovuta a precompressione
'*****************************************************************
Dim N_p As Double 'Sforzo normale dovuto alle forze di precompressione
Dim Mx_p As Double 'Momento lungo x "
Dim My_p As Double 'Momento lungo y "
Dim sigma_sp0 As Double 'Tensione dei trefoli depurata dalle perdite
N_p = 0#: Mx_p = 0#: My_p = 0#
For i = 1 To n_cavi_sez
sigma_perdite_ultimo(i) = (perdite / 100#) * sigma_preteso(i)
sigma_sp0 = sigma_preteso_ultimo(i) - sigma_perdite_ultimo(i)
N_p = N_p + sigma_sp0 * Asp(i)
Mx_p = Mx_p - sigma_sp0 * Asp(i) * (ygO - cy(i))
My_p = My_p + sigma_sp0 * Asp(i) * (xgO - cx(i))
Next i
Nd = N_ + N_p 'sforzo assiale per carichi assiali + precomp.
Mx = Mx_ + Mx_p 'momento per carichi verticali + momento precomp.
My = My_ + My_p 'momento per carichi orizzontali + momento precomp.
End Sub
Integriamo la funzione risult_traz tenendo conto della deformazione precedentemente assegnata ai trefoli.CODICE' --------------------------------------------------------------------------
' Nome sub :risult_traz(
' Scopo funzione : Calcola la risultante di trazione nella sezione per da-
' to posizionamento dell'asse neutro, ed anche il suo
' punto di applicazione.
' ATTENZIONE per determinare forze derivanti dalle armatu-
' o dai profili metallici, la procedura utilizza le va-
' riabili globali: E_arm,E_prof,fyd_arm,fyd_prof
' Parametri formali: Struttura dati con tutti i poligoni che costituiscono la
' sezione, struttura dati con tutte le armature della se-
' zione. ymax=massima ordinata della sezione in cls,
' yamin=minima ordinata delle barre di armatura, yn=ordi-
' nata dell'asse neutro, struttura dati con le deforma-
' zioni limite a rottura
' Valore restituito: Struttura dati con risultante e punto di applicazione
' Implementazione : Luglio 2011
' Autore : Zax2010
' traduzione in VBA : Afazio Settembre 2012
' modifiche : Giuseppe Iaria Ottobre 2012
' modifiche : Tex Dicembre 2012
' --------------------------------------------------------------------------
Private Function risult_traz(ByRef polic() As poligono_sezione, armco As armature_sezione, armcp As armature_sezione, deform As deform_sezione, _
ymax As Double, yamin As Double, yn As Double) As risultante_n
......
......
For k = 1 To armcp.numarm
If armcp.Y(k) > yn Then GoTo continua3 'esclude le armature compresse
def = deform.epsa + (deform.epsb - deform.epsa) * (ymax - armcp.Y(k)) / (ymax - yamin)
pressione = -elast_plast_indefps(Abs(def + armcp.def_prec(k)), armcp.fyd(k), E_armp) * armcp.fyd(k)
forza = pressione * armcp.af(k)
risult_traz.n = risult_traz.n + forza
Scx = Scx + forza * armcp.Y(k)
Scy = Scy + forza * armcp.X(k)
continua3:
Next
Lo stesso facciamo con risult_compr.CODICE' --------------------------------------------------------------------------
' nome sub : risult_compr(
' Scopo funzione : Calcola la risultante di compressione nella sezione per
' dato posizionamento dell'asse neutro, ed anche il suo
' punto di applicazione
' ATTENZIONE per determinare forze derivanti dalle armatu-
' o dai profili metallici, la procedura utilizza le va-
' riabili globali: E_arm,E_prof,fyd_arm,fyd_prof
' Parametri formali: Struttura dati con tutti i poligoni che costituiscono la
' sezione, struttura dati con tutte le armature della se-
' zione. ymax=massima ordinata della sezione in cls,
' yamin=minima ordinata delle barre di armatura, yn=ordi-
' nata dell'asse neutro, struttura dati con le deforma-
' zioni limite a rottura
' Valore restituito: Struttura dati con risultante e punto di applicazione
' Implementazione : Luglio 2011
' traduzione in VBA : Afazio Settembre 2012
' Autore : Zax2010
' modifiche : Giuseppe Iaria Ottobre 2012
' modifiche : Tex Dicembre 2012
' --------------------------------------------------------------------------
Private Function risult_compr(ByRef polic() As poligono_sezione, armco As armature_sezione, armcp As armature_sezione, _
deform As deform_sezione, ymax As Double, yamin As Double, yn As Double) As risultante_n
.....
.....
For k = 1 To armcp.numarm
If armcp.Y(k) < yn Then GoTo continua7 'le armature sono tese e passa oltre
def = deform.epsa + (deform.epsb - deform.epsa) * (ymax - armcp.Y(k)) / (ymax - yamin)
pressione = elast_plast_indefps(def + armcp.def_prec(k), armcp.fyd(k), E_armp) * armcp.fyd(k)
forza = pressione * armcp.af(k)
risult_compr.n = risult_compr.n + forza
Scx = Scx + forza * armcp.Y(k)
Scy = Scy + forza * armcp.X(k)
continua7:
Next
Edited by texitaliano64 - 18/1/2014, 13:27. -
.
leggo nel codice un continua3 e un continua7: è un messaggio segreto o fa parte del vba?
(p.s. sto "sorseggiando" vba a piccole dosi per non avvelenarmi
)
. -
UncleJack .
User deleted
ci sono i Goto . -
.
Sono delle label utilizzate dal comando di salto deprecato e deprecabile "GOTO Label"
A volte conviene usare il comando GOTO in piccole dosi per evitare contorsionismi inutili col codice.. -
.
@Zax, AFazio, GIaria
Provate a vedere anche voi questo documento con un metodo per il tracciamento del dominio di rottura.
http://www.webalice.it/orrione/File%20pdf/...omini%20C.A.pdf. -
.@Zax, AFazio, GIaria
Provate a vedere anche voi questo documento con un metodo per il tracciamento del dominio di rottura.
www.webalice.it/orrione/File%20pdf/...omini%20C.A.pdf
Tex, salvo il ricorso alle famigerate losange di geniincivili memorie per l'integrazione esatta, non mi pare che faccia nulla di piu' di quanto riusciamo a fare con lo zaxCode.
Lo zaxcode è anniLuce piu' avanti rispetto a quanto puo' fare Dominus, dato che noi possiamo mettere vuoti o semivuoti per meta pieni ed anche lattine di birra come armatura. Dopo essercela bevuta.. -
.
Si lo ZaxCode è molto flessibile, permette di calcolare il dominio di rottura di qualunque multipoligono a patto di conoscere il legame costitutivo dei materiali.
L'integrazione a fibre rettangolari è molto affidabile, e la velocità di calcolo non è male.. -
.
Ho modificato il foglio dando la possibilità all'utente di modificare sia lo spessore minimo delle fibre che il numero massimo di fibre da utilizzare nella integrazione, inoltre grazie a quanto detto a proposito di modifica della ampiezza dati di origine dei grafici (topic Gestione grafici excel via VBA) ho reso possibile la scelta da parte dell'utente del numero di punti utili per tracciare il grafico del dominio di rottura.
Implementata la tecnica di infittimento punti del dominio di rottura qualora non vada a convergenza col numero punti scelto dall'utente, di cui se ne era parlato circa un anno fa nel topic "Verifica di sezioni complesse in ca. agli SLE ed agli SLU", tecnica utile per ridurre i tempi di elaborazione.CODICERicalcola:
Dim flag_convergenza As Boolean
Dim flag_circa As Boolean
Dim index As Integer
Call calcola_MomentiRottura(dominio_slu, soll(25 + n_c), MomentiRottura, flag_convergenza, flag_circa, index)
'Controlliamo la convergenza
If Not flag_convergenza Then
'se non converge infittiamo i punti del contorno del dominio localmente e ricalcoliamo
'npt --> punti del dominio iniziali
'ninf --> numero massimo di infittimenti locali consentiti
'pfis --> numero di punti fisici effettivamente calcolati
'pvt --> numero punti virtuali corrispondenti ad un infittimento globale equivalente
'pfis=(npt*2^ninf)
'pvt=(pfis-npt)*npt
'esempi:
'caso npt=4 ninf=6 corrisponde a 256 punti fisici ed almeno 1008 punti virtuali
'caso npt=8 ninf=5 corrisponde a 256 punti fisici ed almeno 1984 punti virtuali
'caso npt=16 ninf=4 corrisponde a 256 punti fisici ed almeno 3840 punti virtuali
'caso npt=32 ninf=3 corrisponde a 256 punti fisici ed almeno 7168 punti virtuali
'caso npt=64 ninf=2 corrisponde a 256 punti fisici ed almeno 12288 punti virtuali
'caso npt=128 ninf=1 corrisponde a 256 punti fisici ed almeno 16384 punti virtuali
'caso npt=256 ninf=0 corrisponde a 256 punti fisici ed 0 punti virtuali
'caso npt=4 ninf=5 corrisponde a 128 punti fisici ed almeno 496 punti virtuali
'caso npt=8 ninf=4 corrisponde a 128 punti fisici ed almeno 960 punti virtuali
'caso npt=16 ninf=3 corrisponde a 128 punti fisici ed almeno 1792 punti virtuali
'caso npt=32 ninf=2 corrisponde a 128 punti fisici ed almeno 3072 punti virtuali
'caso npt=64 ninf=1 corrisponde a 128 punti fisici ed almeno 4096 punti virtuali
'caso npt=128 ninf=0 corrisponde a 128 punti fisici ed 0 punti virtuali
'caso npt=4 ninf=4 corrisponde a 64 punti fisici ed almeno 240 punti virtuali
'caso npt=8 ninf=3 corrisponde a 64 punti fisici ed almeno 448 punti virtuali
'caso npt=16 ninf=2 corrisponde a 64 punti fisici ed almeno 768 punti virtuali
'caso npt=32 ninf=1 corrisponde a 64 punti fisici ed almeno 1024 punti virtuali
'caso npt=64 ninf=0 corrisponde a 64 punti fisici ed 0 punti virtuali
'caso npt=4 ninf=3 corrisponde a 32 punti fisici ed almeno 112 punti virtuali
'caso npt=8 ninf=2 corrisponde a 32 punti fisici ed almeno 192 punti virtuali
'caso npt=16 ninf=1 corrisponde a 32 punti fisici ed almeno 256 punti virtuali
'caso npt=32 ninf=0 corrisponde a 32 punti fisici ed 0 punti virtuali
'caso npt=4 ninf=2 corrisponde a 16 punti fisici ed almeno 32 punti virtuali
'caso npt=8 ninf=1 corrisponde a 16 punti fisici ed almeno 64 punti virtuali
'caso npt=16 ninf=0 corrisponde a 16 punti fisici ed 0 punti virtuali
'caso npt=4 ninf=1 corrisponde a 8 punti fisici ed almeno 16 punti virtuali
'caso npt=8 ninf=0 corrisponde a 8 punti fisici ed 0 punti virtuali
'caso npt=4 ninf=0 corrisponde a 4 punti fisici ed 0 punti virtuali
If NMaxDom < pfis Then '32
If flag_circa Then
Call Infittimento_Dominio_locale(dominio_slu, NMaxDom, index)
GoTo Ricalcola
Else
'fallimento totale niente soluzione infittimento locale impossibile
'tentiamo con infittimento globale
Call Infittimento_Dominio_globale(dominio_slu, NMaxDom)
GoTo Ricalcola
End If
Else
If Not flag_circa Then
'fallimento totale niente soluzione
Sheets(3).Range("Mrxd") = 0#
Sheets(3).Range("Mryd") = 0#
End If
End If
End If
'-----------------------------------------------------------------
' Infittimento_Dominio_locale
'
' Infittimento punti del dominio solo dove serve
' accorgimento che consente a partà di precisione di velocizzare
' il calcolo consumando meno memoria
'-----------------------------------------------------------------
Private Sub Infittimento_Dominio_locale(ByRef dominio_slu As Dominio_Rottura, NMaxDom As Integer, index As Integer)
Dim i As Integer
Dim k As Integer
' infittiamo i punti del dominio localmente
NMaxDom = NMaxDom + NMaxDom
' ingrandisco campo dati mantenendo i vecchi valori calcolati
ReDim Preserve dominio_slu.mrx(1 To NMaxDom)
ReDim Preserve dominio_slu.mry(1 To NMaxDom)
ReDim Preserve dominio_slu.ang(1 To NMaxDom)
ReDim Preserve dominio_slu.nrc(1 To NMaxDom)
ReDim Preserve dominio_slu.nrt(1 To NMaxDom)
ReDim Preserve dominio_slu.xrc(1 To NMaxDom)
ReDim Preserve dominio_slu.yrc(1 To NMaxDom)
ReDim Preserve dominio_slu.xrt(1 To NMaxDom)
ReDim Preserve dominio_slu.yrt(1 To NMaxDom)
ReDim Preserve dominio_slu.epsc(1 To NMaxDom)
ReDim Preserve dominio_slu.epss(1 To NMaxDom)
ReDim Preserve dominio_slu.yn(1 To NMaxDom)
ReDim Preserve dominio_slu.curv(1 To NMaxDom)
' sposto i valori da index+1 in avanti in modo da lasciare lo spazio per
' l'inserimento dei nuovi valori di infittimento
k = NMaxDom \ 2
For i = index + 1 To k
dominio_slu.mrx(i + k) = dominio_slu.mrx(i)
dominio_slu.mry(i + k) = dominio_slu.mry(i)
dominio_slu.ang(i + k) = dominio_slu.ang(i)
dominio_slu.nrc(i + k) = dominio_slu.nrc(i)
dominio_slu.nrt(i + k) = dominio_slu.nrt(i)
dominio_slu.xrc(i + k) = dominio_slu.xrc(i)
dominio_slu.yrc(i + k) = dominio_slu.yrc(i)
dominio_slu.xrt(i + k) = dominio_slu.xrt(i)
dominio_slu.yrt(i + k) = dominio_slu.yrt(i)
dominio_slu.epsc(i + k) = dominio_slu.epsc(i)
dominio_slu.epss(i + k) = dominio_slu.epss(i)
dominio_slu.yn(i + k) = dominio_slu.yn(i)
dominio_slu.curv(i + k) = dominio_slu.curv(i)
Next i
'PiGreco
PiGreco = 4# * Atn(1#)
'prelevo gli angoli dei due punti estremi del segmento di dominio da considerare
Dim ang1 As Double, ang2 As Double
ang1 = dominio_slu.ang(index)
If index = NMaxDom Then
ang2 = dominio_slu.ang(1)
Else
ang2 = dominio_slu.ang(index + 1)
End If
'arco individuato dai due angoli di cui sopra
Dim arco As Double
arco = ang2 - ang1
If arco < 0# Then arco = arco + 2# * PiGreco
Delta_alfa = arco / (k + 1) ' divido per k+1 per tener conto che i punti estremi sono già calcolati
Dim alfa As Double
alfa = ang1 + Delta_alfa
'calcolo i valori di infittimento
For i = index + 1 To index + k
If alfa >= 2# * PiGreco Then alfa = alfa - 2# * PiGreco
Call calcola_dominio_alfa(dominio_slu, alfa, i)
alfa = alfa + Delta_alfa
Next i
End Sub
'-----------------------------------------------------------------
' Infittimento_Dominio_globale
'
' Infittimento punti del dominio con calcolo solo punti mancanti
'-----------------------------------------------------------------
Private Sub Infittimento_Dominio_globale(ByRef dominio_slu As Dominio_Rottura, ByRef NMaxDom As Integer)
Dim i As Integer
Dim k As Integer
' infittiamo i punti del dominio
NMaxDom = NMaxDom + NMaxDom
' ingrandisco campo dati mantenendo i vecchi valori calcolati
ReDim Preserve dominio_slu.mrx(1 To NMaxDom)
ReDim Preserve dominio_slu.mry(1 To NMaxDom)
ReDim Preserve dominio_slu.ang(1 To NMaxDom)
ReDim Preserve dominio_slu.nrc(1 To NMaxDom)
ReDim Preserve dominio_slu.nrt(1 To NMaxDom)
ReDim Preserve dominio_slu.xrc(1 To NMaxDom)
ReDim Preserve dominio_slu.yrc(1 To NMaxDom)
ReDim Preserve dominio_slu.xrt(1 To NMaxDom)
ReDim Preserve dominio_slu.yrt(1 To NMaxDom)
ReDim Preserve dominio_slu.epsc(1 To NMaxDom)
ReDim Preserve dominio_slu.epss(1 To NMaxDom)
ReDim Preserve dominio_slu.yn(1 To NMaxDom)
ReDim Preserve dominio_slu.curv(1 To NMaxDom)
' sposto i valori opportunamente in modo da lasciare lo spazio per
' l'inserimento dei nuovi valori di infittimento
' il primo valore rimane sul posto poi spazio poi secondo valore
' poi spazio poi terzo valore poi spazio poi quarto valore ecc...
k = NMaxDom \ 2 - 1
For i = NMaxDom - 1 To 3 Step -2
dominio_slu.mrx(i) = dominio_slu.mrx(i - k)
dominio_slu.mry(i) = dominio_slu.mry(i - k)
dominio_slu.ang(i) = dominio_slu.ang(i - k)
dominio_slu.nrc(i) = dominio_slu.nrc(i - k)
dominio_slu.nrt(i) = dominio_slu.nrt(i - k)
dominio_slu.xrc(i) = dominio_slu.xrc(i - k)
dominio_slu.yrc(i) = dominio_slu.yrc(i - k)
dominio_slu.xrt(i) = dominio_slu.xrt(i - k)
dominio_slu.yrt(i) = dominio_slu.yrt(i - k)
dominio_slu.epsc(i) = dominio_slu.epsc(i - k)
dominio_slu.epss(i) = dominio_slu.epss(i - k)
dominio_slu.yn(i) = dominio_slu.yn(i - k)
dominio_slu.curv(i) = dominio_slu.curv(i - k)
k = k - 1
Next i
PiGreco = 4# * Atn(1#)
Delta_alfa = 2# * PiGreco / NMaxDom
Dim alfa As Double
alfa = Delta_alfa
'calcolo solo i valori di infittimento
For i = 2 To NMaxDom Step 2
Call calcola_dominio_alfa(dominio_slu, alfa, i)
alfa = alfa + Delta_alfa + Delta_alfa
Next i
End Sub
' --------------------------------------------------------------------------
' Nome sub calcola_dominio_alfa(
' Scopo funzione : Facendo ruotare di alfa la sezione determina le
' coppie di punti mrx,mry di rottura per dato valore
' di sforzo normale.
' Parametri formali: Nd=sforzo normale di sollecitazione.
' Valore restituito: Struttura dati con varie informazioni: risultanti di
' compressione e trazione, posizioni risultanti, posizio-
' ne asse neutro, deformazioni limite a rottura sezione
' Implementazione : Luglio 2011
' Autore : Zax2010
' --------------------------------------------------------------------------
Public Sub calcola_dominio_alfa(ByRef dom As Dominio_Rottura, alfa As Double, index As Integer)
Dim k As Integer
Dim Np As Integer
Dim polic() As poligono_sezione
ReDim polic(N_POLI)
Dim armco As armo_sezione
Dim armcp As armp_sezione
Dim Nfin As risultante_n_finale
Dim Xc As Double
Dim Yc As Double
Dim xt As Double
Dim yt As Double
Dim c As Double
Dim s As Double
'---------------------------------------------------------------------------------
PiGreco = 4# * Atn(1#)
'hack per risolvere problema di stallo a 90° con poligoni rettangolari sovrapposti
If alfa = PiGreco / 2# Then alfa = alfa + 0.000001
'---------------------------------------------------------------------------------
' Calcola una sola volta cos(alfa) e sin(alfa) per evitare elaborazione ogni volta
c = Cos(alfa)
s = Sin(alfa)
' Prima copia la sezione in altra struttura dati e poi la ruota di alfa
For Np = 1 To N_POLI
polic(Np) = poli(Np)
For k = 1 To polic(Np).numv
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
Next
Next
' Copia le armature in altra struttura dati e poi le ruota di alfa
armco = arm
For k = 1 To arm.numarm
armco.X(k) = arm.X(k) * c + arm.Y(k) * s
armco.Y(k) = -arm.X(k) * s + arm.Y(k) * c
Next
armcp = armp
For k = 1 To armp.numarm
armcp.X(k) = armp.X(k) * c + armp.Y(k) * s
armcp.Y(k) = -armp.X(k) * s + armp.Y(k) * c
Next
' Chiama la funzione per definire l'asse neutro della sezione (ruotata di alfa)
Nfin = asse_neutro_SLU(polic, armco, armcp, dom.nd)
' 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
' Calcola i momenti resistenti per ciascuna configurazione ruotata
dom.mrx(index) = Nfin.ncf.n * (Yc - ygO) + Nfin.ntf.n * (yt - ygO)
dom.mry(index) = Nfin.ncf.n * (Xc - xgO) + Nfin.ntf.n * (xt - xgO)
dom.ang(index) = alfa
dom.nrc(index) = Nfin.ncf.n
dom.nrt(index) = Nfin.ntf.n
dom.xrc(index) = Xc
dom.yrc(index) = Yc
dom.xrt(index) = xt
dom.yrt(index) = yt
dom.epsc(index) = Nfin.epsc
dom.epss(index) = Nfin.epss
dom.yn(index) = Nfin.yn
dom.curv(index) = Nfin.curv
End Sub. -
.
Non c'entra nulla.
Ma io ricordo che sul finire del 2005, esisteva un sito che pubblicizzava un programma per la verifica di travi precompresse che si chiamava proprio Ci A Pi. Forse prodotto a Verona.
Già nel 2005 si trattava di 'vestigia di un lontano passato', nel senso che, sempre dai ricordi, il sito era abbandonato, e forse con una sezione download non più attiva.
Quando è uscito questo topic con questo titolo ho provato a ricercare il vecchio sito. Ormai più nessuna traccia. La rete dimentica in fretta.. -
.Non c'entra nulla.
Ma io ricordo che sul finire del 2005, esisteva un sito che pubblicizzava un programma per la verifica di travi precompresse che si chiamava proprio Ci A Pi. Forse prodotto a Verona.
Già nel 2005 si trattava di 'vestigia di un lontano passato', nel senso che, sempre dai ricordi, il sito era abbandonato, e forse con una sezione download non più attiva.
Quando è uscito questo topic con questo titolo ho provato a ricercare il vecchio sito. Ormai più nessuna traccia. La rete dimentica in fretta.
Non avevo conoscenza dell'esistenza di un software dal titolo proprio Ci A Pi.
Ho dato questo titolo semplicemente perchè è mia abitudine ormai dare titoli ai topic non troppo esplicativi per non facilitare la ricerca con google.. -
.
Per il test del foglio di calcolo facciamo una prova comparativa agli SLU tra un software commerciale che non cito, il VCASLU del prof. Piero Gelfi, ed un programma in VB6 basato su Zaxcode. 
Uploaded with ImageShack.us
Uploaded with ImageShack.us
Come si può notare le differenze sono minime, eccetto per il VCASLU che traccia un dominio meno esteso.
Edited by texitaliano64 - 9/2/2014, 12:52. -
.
Quindi si puo' dire che sia il codice scritto in VBA di Excel che quello scritto in VB6 (entrambi basati sul codice di zax, il primo è quello qui presentato mentre il secondo immagino sia quello che hai inserito nella tua applicazione) che quello di un software commerciale dedicato al precompresso forniscono dati pressochè uguali (scarto piccolo) mentre quello del prof Gelfi, pur arrivando a risultati comparabili coi primi, è leggermente meno accurato. . -
.
Diciamo che VCASLU anche se utilizza un metodo di calcolo simile a quello proposto da Zax da un risultato leggermente diverso, ma comunque cautelativo.
Altro test aggiuntivo di comparazione con trave alare.
Uploaded with ImageShack.us
e questi sono i diagrammi del dominio di rottura:
Ho rifatto il calcolo portando il numero massimo di fibre a 1100 e lo spessore minimo delle fibre a 0.1mm.
Uploaded with ImageShack.us
In questo caso i vari grafici si intrecciano tra di loro.
Edited by texitaliano64 - 12/2/2014, 23:23. -
g.iaria .
User deleted
Strane queste differenze su quest'ultimo esempio.
In particolare la differenza, seppur piccola, tra i due programmi a parità (?) di codice di calcolo.
Mi verrebbe da pensare che le cause siano imputabili a diversi criteri di discretizzazione del dominio, però ZAX_EXCEL é tutto traslato un po a destra sulle due cuspidi.....
A proposito delle differenze con VCASLU, se non ricordo male il programma ha un'opzione di infittimento del dominio, si potrebbe vedere se con questo infittimento i risultati si allineano con quelli degli altri programmi..
Ci A Pi |
