Facendo seguito ad un vecchio articolo in cui veniva trattata una funzione Excel per la verifica ed il progetto di pilastri in c.a. con metodo semplificato*, si fornisce qui una nuova funzione che consente la determinazione esatta di Mrd (e non approssimato come prima). In realtà, quella proposta di seguito è solo la prima di una serie ed altre ne verranno aggiunte man mano.
La funzione in questione sostanzialmente è un codice VBA da inserire in un foglio Excel. La procedura è la seguente:
- aprire un nuovo foglio Excel e quindi aprire la pagina progetto di Visual Basic;
- inserire un nuovo modulo;
- copiare ed incollare il codice qui sotto;
- tornare nel foglio Excel;
- nella voce inserisci funzione trovate la nuova funzione tra quelle definite dall’utente.
Da notare che la pagina di progetto di Visual Basic la si trova nella sezione “Sviluppo“. Se non fosse presenta bisogna aggiungerla dalle “Opzioni di Excel“.
Il codice è il seguente:
Function arcCos(numero As Double) As Double
arcCos = Atn(-numero / Sqr(-numero * numero + 1)) + 2 * Atn(1)
End FunctionFunction CalcEpsilon_rottura(H As Double, dmin As Double, _
di As Double, delta As Double, _
Optional epsSmax As Double = 0.0675, _
Optional epsCmax As Double = 0.0035, _
Optional epsCrif As Double = 0.002) As Double
‘Restituisce la deformazione limite per il calcolo del dominio MN funzione dei parametri immessi
‘ Attenzione nell’uso: valori positivi di epsilon per il cls non hanno alcun senso! Controllare la funzione SigmaC
‘Parametri:
‘ h=altezza sezione (mm)
‘ dmin = copriferro superiore o inferiore (mm)
‘ di = distanza della fibra di cui si calcola epsilon dall’estremità superiore della sezione (mm)
‘ delta = coefficiente di campo (da 0 a 5 per i momenti positivi che tendono le fibre inferiori,
‘ da 5 a 10 per i momenti negativi che tendono le fibre superiori)
‘ epsSmax = deformazione limite dell’acciaio
‘ epsCmax = deformazione limite del cls
‘ epsCrif = deformazione limite del cls per compressione sempliceDim x0 As Double ‘ variabile di appoggio
Select Case delta
Case 0 To 1
CalcEpsilon_rottura = epsSmax – (H – dmin – di) / (H – dmin) * (epsSmax * delta)
Case 1 To 2
CalcEpsilon_rottura = epsSmax – (H – dmin – di) / (H – dmin) * (epsSmax + epsCmax * (delta – 1))
Case 2 To 3
CalcEpsilon_rottura = -epsCmax + di / (H – dmin) * (epsCmax + epsSmax * (3 – delta))
Case 3 To 4
CalcEpsilon_rottura = epsCmax * (-1 + di * (4 – delta) / (H – dmin) + di * (delta – 3) / H)
Case 4 To 5
x0 = (epsCmax – epsCrif) * H / epsCmax
CalcEpsilon_rottura = -epsCrif + epsCrif * (5 – delta) * (di – x0) / (H – x0)
Case 5 To 6
CalcEpsilon_rottura = -(6 – delta) * epsCrif – (delta – 5) * epsCmax * di / H
Case 6 To 7
CalcEpsilon_rottura = -epsCmax * ((7 – delta) * dmin * (H – di) / (H * (H – dmin)) + (di – dmin) / (H – dmin))
Case 7 To 8
CalcEpsilon_rottura = -epsCmax * (di – dmin) / (H – dmin) + (delta – 7) * epsSmax * (H – di) / (H – dmin)
Case 8 To 9
CalcEpsilon_rottura = (epsSmax + (9 – delta) * epsCmax) * (H – di) / (H – dmin) – (9 – delta) * epsCmax
Case 9 To 10
CalcEpsilon_rottura = (10 – delta) * epsSmax * (H – di) / (H – dmin) + (delta – 9) * epsSmax
Case Else
CalcEpsilon_rottura = 0
End SelectEnd Function
La spiegazione della terminologia usata la trovate direttamente nel codice. Per maggiore chiarezza si ripetono qui i parametri:
Parametri:
h=altezza sezione (mm)
dmin = copriferro superiore o inferiore (mm)
di = distanza della fibra di cui si calcola epsilon dall’estremità superiore della sezione (mm)
delta = coefficiente di campo (da 0 a 5 per i momenti positivi che tendono le fibre inferiori,
da 5 a 10 per i momenti negativi che tendono le fibre superiori)
epsSmax = deformazione limite dell’acciaio
epsCmax = deformazione limite del cls
epsCrif = deformazione limite del cls per compressione semplice
Qui le funzioni che determinano le tensioni su acciaio o su cls per fissato valore di epsilon:
Public Function SigmaC(eps As Double, sigmaC_max As Double, forma As Integer, _
Optional Emodulus As Double = 0#, _
Optional epsCmax As Double = 0.0035, _
Optional epsCrif As Double = 0.002) As Double
‘Restituisce la tensione del calcestruzzo corrispondente alla deformazione epsilon data
‘Parametri:
‘ eps = deformazione epsilon di cui calcolare la tensione sigma
‘ sigma_max = tensione massima (MPa)
‘ forma = parametro di forma del diagramma:
‘ forma = 1 => parabola-rettangolo EC2
‘ forma = 2 => perfettamente elastico lineare per compressione (il modulo di elasticità è definito da epsCmax)
‘ forma = 3 => elasto-plastico (il modulo di elasticità se non definito è calcolato da epsCrif)
‘ Emodulus = modulo di elasticità (necessario per forma pari a ?) (MPa)
‘ epsSmax = deformazione limite dell’acciaio
‘ epsCmax = deformazione limite del cls
‘ epsCrif = deformazione limite del cls per compressione sempliceIf forma = 1 Then
Select Case eps
Case -epsCmax To -epsCrif
SigmaC = -sigmaC_max
Case -epsCrif To 0
SigmaC = -sigmaC_max * (1 – (1 – Abs(eps) / epsCrif) ^ 2) ‘secondo EC2
Case Else
SigmaC = 0#
End Select
Exit Function
End IfIf forma = 2 Then
If eps < 0 Then
SigmaC = eps * (sigmaC_max / epsCmax)
Else
SigmaC = 0#
End If
Exit Function
End IfIf forma = 3 Then
If (Emodulus = 0 And epsCrif 0) Then Emodulus = sigmaC_max / epsCrif
Select Case eps
Case -epsCmax To -epsCrif
SigmaC = -sigmaC_max
Case -epsCrif To 0
SigmaC = eps * Emodulus
Case Else
SigmaC = 0#
End Select
Exit Function
End IfSigmaC = 0#
End Function
Public Function SigmaS(eps As Double, sigmaS_max As Double, forma As Integer, _
Optional Emodulus As Double = 210000#, _
Optional epsSmax As Double = 0.0675) As Double
‘Restituisce la tensione del’acciaio corrispondente alla deformazione epsilon data
‘Parametri:
‘ eps = deformazione epsilon di cui calcolare la tensione sigma
‘ sigmaS_max = tensione massima (MPa)
‘ forma = parametro di forma del diagramma:
‘ forma = 1 => elasto-plastico
‘ forma = 2 => perfettamente elastico lineare (il modulo di elasticità è definito da epsSmax)
‘ forma = 3 => elasto-plastico incrudente (da sviluppare!)
‘ Emodulus = modulo di elasticità (necessario per forma pari a 1) (MPa)
‘ epsSmax = deformazione limite dell’acciaio
‘ epsCmax = deformazione limite del cls
‘ epsCrif = deformazione limite del cls per compressione sempliceDim epsSrif As Double
If Emodulus 0 Then
epsSrif = sigmaS_max / Emodulus
Else
epsSrif = 0#
End IfIf forma = 1 Then
Select Case eps
Case -epsSmax To -epsSrif
SigmaS = -sigmaS_max
Case -epsSrif To epsSrif
SigmaS = eps * Emodulus
Case epsSrif To epsSmax
SigmaS = sigmaS_max
Case Else
SigmaS = 0#
End Select
Exit Function
End IfIf forma = 2 Then
SigmaS = eps * (sigmaS_max / epsSmax)
Exit Function
End IfSigmaS = 0#
End Function
La funzione che segue calcola Mrd e Nrd per fissato valore di delta per una sezione di forma rettangolare BxH ed avente armatura superiore distinta da quella inferiore ed un solo livello di armatura di parete posta a meta altezza.
Public Function DominioRotturaRett(B As Double, H As Double, c As Double, _
AfInF As Double, AfSup As Double, AfParete As Double, _
fCd As Double, fyd As Double, _
x As Double, flag As Integer)‘ DominioRotturaRett si appoggia alle funzioni
‘ CalcEpsilon_rottura, SigmaC, SigmaS
‘ messe a disposizione da “ing. D.Cattivelli (docholly@infinito.it)” nel suo file CNM.xls‘ la funzione calcola lo sforzo normale e il momento flettente
‘ caratterizzanti un punto del dominio di rottura. Il punto e’ definito
‘ attraverso il parametro x, variabile tra 0 e 5, che rappresenta
‘ la posizione all’interno del campo di rottura
‘
‘ input: dimensioni in mm, aree di ferro in mm²
‘ resistenze in MPA
‘ La funzione restituisce valori diversi in base al parametro flag
‘ flag = 1, restituisce Nrd in N
‘ flag = 2, restituisce Mrd in N*mmDim diVisioni As Integer ‘ numero di strisce in cui si suddivide la sezione
Dim count As IntegerDim yg As Double ‘distanza del baricentro dal bordo superiore
Dim y As Double ‘ distanza del punto generico rispetto al bordo superiore
Dim z As Double ‘ variabile di appoggio per le deformazioni
Dim w As Double ‘ variabile di appoggio per le tensioniDim N_dominio As Double
Dim M_dominio As Double
yg = H / 2
diVisioni = 100 ‘ variare questa variabile per aumentare o diminuire la precisione di calcolo‘ parte relativa al calcestruzzo
For count = 1 To diVisioni
y = (count – 1 / 2) * H / diVisioni
z = CalcEpsilon_rottura(H, c, y, x)
w = SigmaC(z, fCd, 1)
N_dominio = N_dominio + w * B * H / diVisioni
M_dominio = M_dominio + w * B * H / diVisioni * (y – yg)
Next‘ acciaio superiore
y = c
z = CalcEpsilon_rottura(H, c, y, x)
w = SigmaS(z, fyd, 1)
N_dominio = N_dominio + w * AfSup
M_dominio = M_dominio + w * AfSup * (y – yg)‘ acciaio inferiore
y = H – c
z = CalcEpsilon_rottura(H, c, y, x)
w = SigmaS(z, fyd, 1)
N_dominio = N_dominio + w * AfInF
M_dominio = M_dominio + w * AfInF * (y – yg)‘ ferro di parete
y = H / 2
z = CalcEpsilon_rottura(H, c, y, x)
w = SigmaS(z, fyd, 1)
N_dominio = N_dominio + w * AfParete
M_dominio = M_dominio + w * AfParete * (y – yg)Select Case flag
Case 1
DominioRotturaRett = N_dominio
Case 2
DominioRotturaRett = M_dominio
End SelectEnd Function
Ecco la funzione per la sezione rettangolare:
Public Function VsezRettSLU01(B As Double, H As Double, c As Double, _
AfInF As Double, AfSup As Double, AfParete As Double, _
fCd As Double, fyd As Double, _
Ned As Double, flag As Integer) As Variant‘ VsezRettSLU01 si appoggia alle funzioni
‘ CalcEpsilon_rottura, SigmaC, SigmaS
‘ messe a disposizione da “ing. D.Cattivelli (docholly@infinito.it)” nel suo file CNM.xls‘ funzione per la verifica agli stati limite ultimi di una sezione rettangolare
‘ con tre strati di armatura (armatura doppia e dissimmetrica piu armatura di parete a metà altezza).
‘ Input: dimensioni in mm, area ferri in mm², resistenze in MPa
‘ sforzo normale in N
‘ output: in output sono forniti valori diversi in funzione del parametro flag:
‘ flag= 10: restituisce la resistenza massima di trazione in N
‘ flag= 11: restituisce il momento resistente in corrispondenza della massima trazione‘ flag= 20: restituisce la resistenza massima di compressione in N
‘ flag= 21: restituisce il momento resistente in corrispondenza della massima compressione‘ flag= 30 : resistenza a flessione semplice POSITIVA [N*mm] (quindi per Ned=0)
‘ flag= 31 : posizione asse neutro [mm] (dal bordo superiore)
‘ flag= 32 : campo di rottura
‘ flag= 33 : deformazione acciaio inferiore (teso)
‘ flag= 34 : tensione acciaio inferiore [MPa]
‘ flag= 35 : deformazione max cls
‘ flag= 36 : tensione max cls [MPa]
‘ flag= 37 : curvatura per flessione semplice positiva‘ flag= 40 : resistenza a flessione semplice NEGATIVA [N*mm] (quindi per Ned=0)
‘ flag= 41 : posizione asse neutro [mm] (dal bordo inferiore)
‘ flag= 42 : campo di rottura
‘ flag= 43 : deformazione acciaio superiore (teso)
‘ flag= 44 : tensione acciaio superiore [MPa]
‘ flag= 45 : deformazione max cls
‘ flag= 46 : tensione max cls [MPa]
‘ flag= 47 : curvatura per flessione semplice negativa‘ flag= 50: momento di rottura POSITIVO PER Nrd=Ned [N*mm]
‘ flag= 51: posizione asse neutro [mm] (dal bordo superiore)
‘ flag= 52: campo di rottura
‘ flag= 53: deformazione acciaio inferiore
‘ flag= 54: tensione acciaio inferiore [MPa]
‘ flag= 55: deformazione max cls
‘ flag= 56: tensione max cls [MPa]
‘ flag= 57 : curvatura per pressoflessione positiva‘ flag= 60: momento di rottura POSITIVO PER Nrd=Ned [N*mm]
‘ flag= 61: posizione asse neutro [mm] (dal bordo superiore)
‘ flag= 62: campo di rottura
‘ flag= 63: deformazione acciaio inferiore
‘ flag= 64: tensione acciaio inferiore [MPa]
‘ flag= 65: deformazione max cls
‘ flag= 66: tensione max cls [MPa]
‘ flag= 67 : curvatura per pressoflessione negativaDim x As Double ‘variabile di posizione di campo
Dim xi As Double ‘estremo inferiore dell’intervallo di variazione di x
Dim xf As Double ‘estremo superiore dell’intervallo di variazione di xDim Ns_rd As Double ‘resistenza massima a trazione centrata (flag 10)
Dim Ms_rd As Double ‘momento resistente associato a Ns_rd (flag 11)Dim Nc_rd As Double ‘ resistenza massima a compressione centrata (flag 20)
Dim Mc_rd As Double ‘ ‘momento resistente associato a Nc_rd (flag 21)Dim Mrd_0 As Double ‘momento resistente per pura flessione positiva (flag 30)
Dim xc_0 As Variant ‘asse neutro per sola flessione positiva (flag 31)
Dim campo_0 As Variant ‘ campo di rottura per sola flessione positiva(flag 32)
Dim epsF_0 As Variant ‘ deformazione acciaio teso flessione positiva (flag 33)
Dim sigmaF_0 As Variant ‘ tensione acciaio teso flessione positiva(flag 34)
Dim epsC_0 As Variant ‘ deformazione nel cls flessione positiva(flag 35)
Dim sigmaC_0 As Variant ‘ tensione nel cls flessione positiva(flag 36)
Dim fi_0 As Variant ‘curvatura (flag 37)Dim Mrd_1 As Double ‘momento resistente per pura flessione negativa (flag 40)
Dim xc_1 As Variant ‘asse neutro per sola flessione negativa (flag 41)
Dim campo_1 As Variant ‘ campo di rottura per sola flessione negativa(flag 42)
Dim epsF_1 As Variant ‘ deformazione acciaio teso flessione negativa(flag 43)
Dim sigmaF_1 As Variant ‘ tensione acciaio teso flessione negativa(flag 44)
Dim epsC_1 As Variant ‘ deformazione nel cls flessione negativa(flag 45)
Dim sigmaC_1 As Variant ‘ tensione nel cls flessione negativa(flag 46)
Dim fi_1 As Variant ‘curvatura (flag 47)Dim Mrd_N0 As Double ‘momento resistente positivo per N=Ned (flag 50)
Dim xc_N0 As Variant ‘asse neutro per N=Ned (flag 51)
Dim campo_N0 As Variant ‘ campo di rottura per N=Ned(flag 52)
Dim epsF_N0 As Variant ‘ deformazione acciaio teso per N=Ned (flag 53)
Dim sigmaF_N0 As Variant ‘ tensione acciaio teso per N=Ned (flag 54)
Dim epsC_N0 As Variant ‘ deformazione nel cls per N=Ned (flag 55)
Dim sigmaC_N0 As Variant ‘ tensione nel cls per N=Ned (flag 56)
Dim fi_N0 As Variant ‘ curvatura (flag 57)Dim Mrd_N1 As Double ‘momento resistente negativo per N=Ned (flag 60)
Dim xc_N1 As Variant ‘asse neutro per N=Ned (flag 61)
Dim campo_N1 As Variant ‘ campo di rottura per N=Ned(flag 62)
Dim epsF_N1 As Variant ‘ deformazione acciaio teso per N=Ned (flag 63)
Dim sigmaF_N1 As Variant ‘ tensione acciaio teso per N=Ned (flag 64)
Dim epsC_N1 As Variant ‘ deformazione nel cls per N=Ned (flag 65)
Dim sigmaC_N1 As Variant ‘ tensione nel cls per N=Ned (flag 66)
Dim fi_N1 As Variant ‘curvatura (flag 67)Dim count As Integer
Dim precisione As Double
Dim numeroCicli As Integer‘ coordinate del punto generico del dominio
Dim Mrd As Double
Dim Nrd As DoubleDim N_sNv As Double
precisione = 0.01
numeroCicli = 1000‘ calcolo sforzi normali massimo e minimo
Ns_rd = DominioRotturaRett(B, H, c, AfInF, AfSup, AfParete, fCd, fyd, 0, 1)
Ms_rd = DominioRotturaRett(B, H, c, AfInF, AfSup, AfParete, fCd, fyd, 0, 2)Nc_rd = DominioRotturaRett(B, H, c, AfInF, AfSup, AfParete, fCd, fyd, 5, 1)
Mc_rd = DominioRotturaRett(B, H, c, AfInF, AfSup, AfParete, fCd, fyd, 5, 2)If flag = 10 Or flag = 11 Or flag = 20 Or flag = 21 Then GoTo uscita ‘salto il resto di codice
‘ calcola Mrd per flessione semplice positiva
If flag >= 30 And flag 0 Then xi = x Else xf = x
Loop Until ((Abs(Nrd) numeroCicli))
If count > numeroCicli Then
Mrd_0 = 0
xc_0 = “ND”
campo_0 = “ND”
epsF_0 = “ND”
sigmaF_0 = “ND”
epsC_0 = “ND”
sigmaC_0 = “ND”
fi_0 = “ND”Else
xc_0 = asseNeutro(H, c, x)
campo_0 = Int(x) + 1
epsF_0 = CalcEpsilon_rottura(H, c, H – c, x)
sigmaF_0 = SigmaS(CalcEpsilon_rottura(H, c, H – c, x), fyd, 1, 210000)
epsC_0 = CalcEpsilon_rottura(H, c, 0, x)
sigmaC_0 = SigmaC(CalcEpsilon_rottura(H, c, 0, x), fCd, 1)
fi_0 = -(CalcEpsilon_rottura(H, c, 0, x) – CalcEpsilon_rottura(H, c, H, x)) / H
End If
GoTo uscita
End If‘ calcola Mrd per flessione semplice negativa
If flag >= 40 And flag 0 Then xi = x Else xf = x
Loop Until ((Abs(Nrd) numeroCicli))
If count > numeroCicli Then
Mrd_1 = 0
xc_1 = “ND”
campo_1 = “ND”
epsF_1 = “ND”
sigmaF_1 = “ND”
epsC_1 = “ND”
sigmaC_1 = “ND”
fi_1 = “ND”
Else
xc_1 = H – asseNeutro(H, c, x)
campo_1 = Int(x) + 1
epsF_1 = CalcEpsilon_rottura(H, c, c, x)
sigmaF_1 = SigmaS(CalcEpsilon_rottura(H, c, c, x), fyd, 1, 210000)
epsC_1 = CalcEpsilon_rottura(H, c, H, x)
sigmaC_1 = SigmaC(CalcEpsilon_rottura(H, c, H, x), fCd, 1)
fi_1 = -(CalcEpsilon_rottura(H, c, 0, x) – CalcEpsilon_rottura(H, c, H, x)) / HEnd If
GoTo uscita
End If‘ calcola Mrd(Ned)
If flag >= 50 And flag < 70 Then
If Ned = Ns_rd Then
Mrd_N0 = 0
xc_N0 = “ND”
campo_N0 = “ND”
epsF_N0 = “ND”
sigmaF_N0 = “ND”
epsC_N0 = “ND”
sigmaC_N0 = “ND”
fi_N0 = “ND”Mrd_N1 = 0
xc_N1 = “ND”
campo_N1 = “ND”
epsF_N1 = “ND”
sigmaF_N1 = “ND”
epsC_N1 = “ND”
sigmaC_N1 = “ND”
fi_N1 = “ND”GoTo uscita
End If
‘ calcolo Mrd(Ned) flessione positiva
If flag >= 50 And flag Ned Then xi = x Else xf = x
Loop Until ((Abs(Nrd – Ned) numeroCicli))If count > numeroCicli Then
Mrd_N0 = 0
xc_N0 = “ND”
campo_N0 = “ND”
epsF_N0 = “ND”
sigmaF_N0 = “ND”
epsC_N0 = “ND”
sigmaC_N0 = “ND”
fi_N0 = “ND”
Else
xc_N0 = asseNeutro(H, c, x)
campo_N0 = Int(x) + 1
epsF_N0 = CalcEpsilon_rottura(H, c, H – c, x)
sigmaF_N0 = SigmaS(CalcEpsilon_rottura(H, c, H – c, x), fyd, 1, 210000)
epsC_N0 = CalcEpsilon_rottura(H, c, 0, x)
sigmaC_N0 = SigmaC(CalcEpsilon_rottura(H, c, 0, x), fCd, 1, 210000)
fi_N0 = -(CalcEpsilon_rottura(H, c, 0, x) – CalcEpsilon_rottura(H, c, H, x)) / HEnd If
End If
‘ calcolo Mrd(Ned) flessione negativa
If flag >= 60 And flag Ned Then xi = x Else xf = x
Loop Until ((Abs(Nrd – Ned) numeroCicli))
If count > numeroCicli Then
Mrd_N1 = 0
xc_N1 = “ND”
campo_N1 = “ND”
epsF_N1 = “ND”
sigmaF_N1 = “ND”
epsC_N1 = “ND”
sigmaC_N1 = “ND”
fi_N1 = “ND”
Else
xc_N1 = H – asseNeutro(H, c, x)
campo_N1 = Int(x) + 1
epsF_N1 = CalcEpsilon_rottura(H, c, c, x)
sigmaF_N1 = SigmaS(CalcEpsilon_rottura(H, c, c, x), fyd, 1, 210000)
epsC_N1 = CalcEpsilon_rottura(H, c, H, x)
sigmaC_N1 = SigmaC(CalcEpsilon_rottura(H, c, H, x), fCd, 1, 210000)
fi_N1 = -(CalcEpsilon_rottura(H, c, 0, x) – CalcEpsilon_rottura(H, c, H, x)) / H
End If
End If
End Ifuscita:
Select Case flag
Case 10
VsezRettSLU01 = Ns_rd
Case 11
VsezRettSLU01 = Ms_rd
Case 20
VsezRettSLU01 = Nc_rd
Case 21
VsezRettSLU01 = Mc_rdCase 30
VsezRettSLU01 = Mrd_0
Case 31
VsezRettSLU01 = xc_0
Case 32
VsezRettSLU01 = campo_0
Case 33
VsezRettSLU01 = epsF_0
Case 34
VsezRettSLU01 = sigmaF_0
Case 35
VsezRettSLU01 = epsC_0
Case 36
VsezRettSLU01 = sigmaC_0
Case 37
VsezRettSLU01 = fi_0Case 40
VsezRettSLU01 = Mrd_1
Case 41
VsezRettSLU01 = xc_1
Case 42
VsezRettSLU01 = campo_1
Case 43
VsezRettSLU01 = epsF_1
Case 44
VsezRettSLU01 = sigmaF_1
Case 45
VsezRettSLU01 = epsC_1
Case 46
VsezRettSLU01 = sigmaC_1
Case 47
VsezRettSLU01 = fi_1Case 50
VsezRettSLU01 = Mrd_N0
Case 51
VsezRettSLU01 = xc_N0
Case 52
VsezRettSLU01 = campo_N0
Case 53
VsezRettSLU01 = epsF_N0
Case 54
VsezRettSLU01 = sigmaF_N0
Case 55
VsezRettSLU01 = epsC_N0
Case 56
VsezRettSLU01 = sigmaC_N0
Case 57
VsezRettSLU01 = fi_N0Case 60
VsezRettSLU01 = Mrd_N1
Case 61
VsezRettSLU01 = xc_N1
Case 62
VsezRettSLU01 = campo_N1
Case 63
VsezRettSLU01 = epsF_N1
Case 64
VsezRettSLU01 = sigmaF_N1
Case 65
VsezRettSLU01 = epsC_N1
Case 66
VsezRettSLU01 = sigmaC_N1
Case 67
VsezRettSLU01 = fi_N1Case Else
VsezRettSLU01 = “FLAG”End Select
End Function
–
Adesso torna utile la funzione asseneutro che determina la posizione dell’asse neutro per fissato valore di x:
Function asseNeutro(H As Double, c As Double, x As Double, _
Optional epsSmax As Double = 0.0675, _
Optional epsCmax As Double = 0.0035, _
Optional epsCrif As Double = 0.002) As Variant‘ Restituisce la posizione dell’asse neutro rispetto al bordo superiore in funzione dei parametri immessi
‘ h = altezza sezione (mm)
‘ c = copriferro inferiore e superiore (mm)
‘ x = coefficiente di campoIf x = 0 Or x = 5 Or x = 10 Then
asseNeutro = 100000000
Else
asseNeutro = -CalcEpsilon_rottura(H, c, 0, x, epsSmax, epsCmax, epsCrif) * H / (CalcEpsilon_rottura(H, c, H, x, epsSmax, epsCmax, epsCrif) – CalcEpsilon_rottura(H, c, 0, x, epsSmax, epsCmax, epsCrif))
End IfEnd Function
La funzione asseneutro viene richiamata nella funzione che segue:
‘ calcola Mrd per flessione semplice positiva
If flag >= 30 And flag 0 Then xi = x Else xf = x
Loop Until ((Abs(Nrd) numeroCicli))
If count > numeroCicli Then
Mrd_0 = 0
xc_0 = “ND”
campo_0 = “ND”
epsF_0 = “ND”
sigmaF_0 = “ND”
epsC_0 = “ND”
sigmaC_0 = “ND”
fi_0 = “ND”Else
xc_0 = asseNeutro(H, c, x)
campo_0 = Int(x) + 1
epsF_0 = CalcEpsilon_rottura(H, c, H – c, x)
sigmaF_0 = SigmaS(CalcEpsilon_rottura(H, c, H – c, x), fyd, 1, 210000)
epsC_0 = CalcEpsilon_rottura(H, c, 0, x)
sigmaC_0 = SigmaC(CalcEpsilon_rottura(H, c, 0, x), fCd, 1)
fi_0 = -(CalcEpsilon_rottura(H, c, 0, x) – CalcEpsilon_rottura(H, c, H, x)) / H
End If
GoTo uscita
End If
I commenti e la spiegazione delle funzioni suddette, con tanto di esercizio di esempio, li trovate nei commenti presenti sotto l’articolo.
–
–
* il riferimento è al seguente articolo: Verifica e progetto di pilastri in c.a. con metodo semplificato.
Si ringraziano:
- Giovanni, alias Afazio, in quanto creatore delle funzioni presentate e delle altre ad esse correlate che vi faranno seguito;
- Francesco Durante per le segnalazioni riguardanti la precedente funzione.
–
–
Ing. Onorio Francesco Salvatore
–
–
Aggiornamento al 22 luglio 2010:
Dal 1/07 al 22/07 il file con le funzioni Excel ha toccato quota 500 downloads stando alle statistiche di Boxnet.
La prima funzione presentata [ Function arcCos(numero As Double) As Double] si è resa necessaria per la mancanza della funzione arcocoseno nella libreaia di funzioni incorporate in excel.
La seconda funzione, invece, determina la deformazione in un punto generico di una sezione generica a seconda della posizione di campo.
Il parametro principale che viene passato alla funzione CalcEpsilon_rottura e’ il fattore di campo delta. Questo e’ variabile da 0 a 5 per flessione che tende le fibre inferiori e da 5 a 10 per flessione che tende le fibre superiori.
http://img84.imageshack.us/img84/2809/unoj.jpg
Nella immagine del link vi sono rappresentati i campi tipici di rottura.
Nella figura e’ tracciata una generica retta di rottura nel campo 1. Essa viene definitafissando la deformazione al lembo superiore pari ad una aliquota di esu: delta*esu
fissato il valore di delta nel campo 1, la deformazione della fibra posta alla distanza y dal bordo compresso vale:
e=esu-delta*esu*(d-y)/d
con d=h-c
similmente per i campi successivi.
In particolare, una generica retta nel campo 2 è caratterizzata da una deformazione al lebo superiore pari a (delta-1)*ecu mentre nel campo 3 la retta di rottura e’ caratterizzata da una deformazione dell’acciaio inferiore teso pari a (delta-2)*esu
Per fissato valore di deformazione a livello della generica fibra, le tensioni sui materiali vengono determinata in base alla legge costitutiva assunta.
qui le funzioni che determinano le tensioni su acciaio o su cls per fissato valore di epsilon
Public Function SigmaC(eps As Double, sigmaC_max As Double, forma As Integer, _
Optional Emodulus As Double = 0#, _
Optional epsCmax As Double = 0.0035, _
Optional epsCrif As Double = 0.002) As Double
‘Restituisce la tensione del calcestruzzo corrispondente alla deformazione epsilon data
‘Parametri:
‘ eps = deformazione epsilon di cui calcolare la tensione sigma
‘ sigma_max = tensione massima (MPa)
‘ forma = parametro di forma del diagramma:
‘ forma = 1 => parabola-rettangolo EC2
‘ forma = 2 => perfettamente elastico lineare per compressione (il modulo di elasticità è definito da epsCmax)
‘ forma = 3 => elasto-plastico (il modulo di elasticità se non definito è calcolato da epsCrif)
‘ Emodulus = modulo di elasticità (necessario per forma pari a ?) (MPa)
‘ epsSmax = deformazione limite dell’acciaio
‘ epsCmax = deformazione limite del cls
‘ epsCrif = deformazione limite del cls per compressione semplice
If forma = 1 Then
Select Case eps
Case -epsCmax To -epsCrif
SigmaC = -sigmaC_max
Case -epsCrif To 0
SigmaC = -sigmaC_max * (1 – (1 – Abs(eps) / epsCrif) ^ 2) ‘secondo EC2
Case Else
SigmaC = 0#
End Select
Exit Function
End If
If forma = 2 Then
If eps < 0 Then
SigmaC = eps * (sigmaC_max / epsCmax)
Else
SigmaC = 0#
End If
Exit Function
End If
If forma = 3 Then
If (Emodulus = 0 And epsCrif 0) Then Emodulus = sigmaC_max / epsCrif
Select Case eps
Case -epsCmax To -epsCrif
SigmaC = -sigmaC_max
Case -epsCrif To 0
SigmaC = eps * Emodulus
Case Else
SigmaC = 0#
End Select
Exit Function
End If
SigmaC = 0#
End Function
Public Function SigmaS(eps As Double, sigmaS_max As Double, forma As Integer, _
Optional Emodulus As Double = 210000#, _
Optional epsSmax As Double = 0.0675) As Double
‘Restituisce la tensione del’acciaio corrispondente alla deformazione epsilon data
‘Parametri:
‘ eps = deformazione epsilon di cui calcolare la tensione sigma
‘ sigmaS_max = tensione massima (MPa)
‘ forma = parametro di forma del diagramma:
‘ forma = 1 => elasto-plastico
‘ forma = 2 => perfettamente elastico lineare (il modulo di elasticità è definito da epsSmax)
‘ forma = 3 => elasto-plastico incrudente (da sviluppare!)
‘ Emodulus = modulo di elasticità (necessario per forma pari a 1) (MPa)
‘ epsSmax = deformazione limite dell’acciaio
‘ epsCmax = deformazione limite del cls
‘ epsCrif = deformazione limite del cls per compressione semplice
Dim epsSrif As Double
If Emodulus 0 Then
epsSrif = sigmaS_max / Emodulus
Else
epsSrif = 0#
End If
If forma = 1 Then
Select Case eps
Case -epsSmax To -epsSrif
SigmaS = -sigmaS_max
Case -epsSrif To epsSrif
SigmaS = eps * Emodulus
Case epsSrif To epsSmax
SigmaS = sigmaS_max
Case Else
SigmaS = 0#
End Select
Exit Function
End If
If forma = 2 Then
SigmaS = eps * (sigmaS_max / epsSmax)
Exit Function
End If
SigmaS = 0#
End Function
Voglio fare notare che le precedenti funzioni sono stata scritte dall’ing. noto col nick docHolly in una sua applicazione. Da me sono state prese ed applicate alla mia funzione.
Fin qui il flusso di lavoro risulterebbe semplice:
– nota una posizione della retta di rottura, si determina la deformazione in ogni punto di interesse di cls o di acciaio
– nota la deformazione in un punto di cls o di acciaio si determina la tensione corrispondente.
Lo sforzo normale ed il corrispondente momento relativi ad una fissata posizione della retta di rottura (e quindi per fissato valore della variabile delta) rappresenta un punto nel dominio di rottura. Quindi basterebbe saper calcolare N ed M e facendo poi variare delta, per riuscire a costruirsi il dominio di rottura.
La funzione che segue calcola Mrd e Nrd per fissato valore di delta per una sezione di forma rettangolare BxH ed avente armatura superiore distinta da quella inferiore ed un solo livello di armatura di parete posta a meta altezza.
Public Function DominioRotturaRett(B As Double, H As Double, c As Double, _
AfInF As Double, AfSup As Double, AfParete As Double, _
fCd As Double, fyd As Double, _
x As Double, flag As Integer)
‘ DominioRotturaRett si appoggia alle funzioni
‘ CalcEpsilon_rottura, SigmaC, SigmaS
‘ messe a disposizione da “ing. D.Cattivelli (docholly@infinito.it)” nel suo file CNM.xls
‘ la funzione calcola lo sforzo normale e il momento flettente
‘ caratterizzanti un punto del dominio di rottura. Il punto e’ definito
‘ attraverso il parametro x, variabile tra 0 e 5, che rappresenta
‘ la posizione all’interno del campo di rottura
‘
‘ input: dimensioni in mm, aree di ferro in mm²
‘ resistenze in MPA
‘ La funzione restituisce valori diversi in base al parametro flag
‘ flag = 1, restituisce Nrd in N
‘ flag = 2, restituisce Mrd in N*mm
Dim diVisioni As Integer ‘ numero di strisce in cui si suddivide la sezione
Dim count As Integer
Dim yg As Double ‘distanza del baricentro dal bordo superiore
Dim y As Double ‘ distanza del punto generico rispetto al bordo superiore
Dim z As Double ‘ variabile di appoggio per le deformazioni
Dim w As Double ‘ variabile di appoggio per le tensioni
Dim N_dominio As Double
Dim M_dominio As Double
yg = H / 2
diVisioni = 100 ‘ variare questa variabile per aumentare o diminuire la precisione di calcolo
‘ parte relativa al calcestruzzo
For count = 1 To diVisioni
y = (count – 1 / 2) * H / diVisioni
z = CalcEpsilon_rottura(H, c, y, x)
w = SigmaC(z, fCd, 1)
N_dominio = N_dominio + w * B * H / diVisioni
M_dominio = M_dominio + w * B * H / diVisioni * (y – yg)
Next
‘ acciaio superiore
y = c
z = CalcEpsilon_rottura(H, c, y, x)
w = SigmaS(z, fyd, 1)
N_dominio = N_dominio + w * AfSup
M_dominio = M_dominio + w * AfSup * (y – yg)
‘ acciaio inferiore
y = H – c
z = CalcEpsilon_rottura(H, c, y, x)
w = SigmaS(z, fyd, 1)
N_dominio = N_dominio + w * AfInF
M_dominio = M_dominio + w * AfInF * (y – yg)
‘ ferro di parete
y = H / 2
z = CalcEpsilon_rottura(H, c, y, x)
w = SigmaS(z, fyd, 1)
N_dominio = N_dominio + w * AfParete
M_dominio = M_dominio + w * AfParete * (y – yg)
Select Case flag
Case 1
DominioRotturaRett = N_dominio
Case 2
DominioRotturaRett = M_dominio
End Select
End Function
Notare il richiamo alla funzione che calcola la deformazione.
Per esempio nella parte relativa al cls:
– la sezione viene divisa in un numero fissato di strisce uguali
– per ciascuna striscia viene determinata l’area
– per ciascuna striscia viene determinata la sua posizione rispetto al bordo compresso
– per ciascuna striscia ed in funzione della sua posizione viene determinata la deformazione
– nota la deformazione viene determinato il valore della tenzione
– nota la tensione si deterimna il contributo della striscia allo sforzo normale totale ed al momento flettente totale
Stessa cosa avviene per la parte relativa alle armature.
Pertanto chi volesse estendere questa funzione a forme di sezioni diverse da quella rettangolare, non deve far altro che agire proprio in queste due parti di codici.
Ecco la funzione per la sezione rettangolare
Public Function VsezRettSLU01(B As Double, H As Double, c As Double, _
AfInF As Double, AfSup As Double, AfParete As Double, _
fCd As Double, fyd As Double, _
Ned As Double, flag As Integer) As Variant
‘ VsezRettSLU01 si appoggia alle funzioni
‘ CalcEpsilon_rottura, SigmaC, SigmaS
‘ messe a disposizione da “ing. D.Cattivelli (docholly@infinito.it)” nel suo file CNM.xls
‘ funzione per la verifica agli stati limite ultimi di una sezione rettangolare
‘ con tre strati di armatura (armatura doppia e dissimmetrica piu armatura di parete a metà altezza).
‘ Input: dimensioni in mm, area ferri in mm², resistenze in MPa
‘ sforzo normale in N
‘ output: in output sono forniti valori diversi in funzione del parametro flag:
‘ flag= 10: restituisce la resistenza massima di trazione in N
‘ flag= 11: restituisce il momento resistente in corrispondenza della massima trazione
‘ flag= 20: restituisce la resistenza massima di compressione in N
‘ flag= 21: restituisce il momento resistente in corrispondenza della massima compressione
‘ flag= 30 : resistenza a flessione semplice POSITIVA [N*mm] (quindi per Ned=0)
‘ flag= 31 : posizione asse neutro [mm] (dal bordo superiore)
‘ flag= 32 : campo di rottura
‘ flag= 33 : deformazione acciaio inferiore (teso)
‘ flag= 34 : tensione acciaio inferiore [MPa]
‘ flag= 35 : deformazione max cls
‘ flag= 36 : tensione max cls [MPa]
‘ flag= 37 : curvatura per flessione semplice positiva
‘ flag= 40 : resistenza a flessione semplice NEGATIVA [N*mm] (quindi per Ned=0)
‘ flag= 41 : posizione asse neutro [mm] (dal bordo inferiore)
‘ flag= 42 : campo di rottura
‘ flag= 43 : deformazione acciaio superiore (teso)
‘ flag= 44 : tensione acciaio superiore [MPa]
‘ flag= 45 : deformazione max cls
‘ flag= 46 : tensione max cls [MPa]
‘ flag= 47 : curvatura per flessione semplice negativa
‘ flag= 50: momento di rottura POSITIVO PER Nrd=Ned [N*mm]
‘ flag= 51: posizione asse neutro [mm] (dal bordo superiore)
‘ flag= 52: campo di rottura
‘ flag= 53: deformazione acciaio inferiore
‘ flag= 54: tensione acciaio inferiore [MPa]
‘ flag= 55: deformazione max cls
‘ flag= 56: tensione max cls [MPa]
‘ flag= 57 : curvatura per pressoflessione positiva
‘ flag= 60: momento di rottura POSITIVO PER Nrd=Ned [N*mm]
‘ flag= 61: posizione asse neutro [mm] (dal bordo superiore)
‘ flag= 62: campo di rottura
‘ flag= 63: deformazione acciaio inferiore
‘ flag= 64: tensione acciaio inferiore [MPa]
‘ flag= 65: deformazione max cls
‘ flag= 66: tensione max cls [MPa]
‘ flag= 67 : curvatura per pressoflessione negativa
Dim x As Double ‘variabile di posizione di campo
Dim xi As Double ‘estremo inferiore dell’intervallo di variazione di x
Dim xf As Double ‘estremo superiore dell’intervallo di variazione di x
Dim Ns_rd As Double ‘resistenza massima a trazione centrata (flag 10)
Dim Ms_rd As Double ‘momento resistente associato a Ns_rd (flag 11)
Dim Nc_rd As Double ‘ resistenza massima a compressione centrata (flag 20)
Dim Mc_rd As Double ‘ ‘momento resistente associato a Nc_rd (flag 21)
Dim Mrd_0 As Double ‘momento resistente per pura flessione positiva (flag 30)
Dim xc_0 As Variant ‘asse neutro per sola flessione positiva (flag 31)
Dim campo_0 As Variant ‘ campo di rottura per sola flessione positiva(flag 32)
Dim epsF_0 As Variant ‘ deformazione acciaio teso flessione positiva (flag 33)
Dim sigmaF_0 As Variant ‘ tensione acciaio teso flessione positiva(flag 34)
Dim epsC_0 As Variant ‘ deformazione nel cls flessione positiva(flag 35)
Dim sigmaC_0 As Variant ‘ tensione nel cls flessione positiva(flag 36)
Dim fi_0 As Variant ‘curvatura (flag 37)
Dim Mrd_1 As Double ‘momento resistente per pura flessione negativa (flag 40)
Dim xc_1 As Variant ‘asse neutro per sola flessione negativa (flag 41)
Dim campo_1 As Variant ‘ campo di rottura per sola flessione negativa(flag 42)
Dim epsF_1 As Variant ‘ deformazione acciaio teso flessione negativa(flag 43)
Dim sigmaF_1 As Variant ‘ tensione acciaio teso flessione negativa(flag 44)
Dim epsC_1 As Variant ‘ deformazione nel cls flessione negativa(flag 45)
Dim sigmaC_1 As Variant ‘ tensione nel cls flessione negativa(flag 46)
Dim fi_1 As Variant ‘curvatura (flag 47)
Dim Mrd_N0 As Double ‘momento resistente positivo per N=Ned (flag 50)
Dim xc_N0 As Variant ‘asse neutro per N=Ned (flag 51)
Dim campo_N0 As Variant ‘ campo di rottura per N=Ned(flag 52)
Dim epsF_N0 As Variant ‘ deformazione acciaio teso per N=Ned (flag 53)
Dim sigmaF_N0 As Variant ‘ tensione acciaio teso per N=Ned (flag 54)
Dim epsC_N0 As Variant ‘ deformazione nel cls per N=Ned (flag 55)
Dim sigmaC_N0 As Variant ‘ tensione nel cls per N=Ned (flag 56)
Dim fi_N0 As Variant ‘ curvatura (flag 57)
Dim Mrd_N1 As Double ‘momento resistente negativo per N=Ned (flag 60)
Dim xc_N1 As Variant ‘asse neutro per N=Ned (flag 61)
Dim campo_N1 As Variant ‘ campo di rottura per N=Ned(flag 62)
Dim epsF_N1 As Variant ‘ deformazione acciaio teso per N=Ned (flag 63)
Dim sigmaF_N1 As Variant ‘ tensione acciaio teso per N=Ned (flag 64)
Dim epsC_N1 As Variant ‘ deformazione nel cls per N=Ned (flag 65)
Dim sigmaC_N1 As Variant ‘ tensione nel cls per N=Ned (flag 66)
Dim fi_N1 As Variant ‘curvatura (flag 67)
Dim count As Integer
Dim precisione As Double
Dim numeroCicli As Integer
‘ coordinate del punto generico del dominio
Dim Mrd As Double
Dim Nrd As Double
Dim N_sNv As Double
precisione = 0.01
numeroCicli = 1000
‘ calcolo sforzi normali massimo e minimo
Ns_rd = DominioRotturaRett(B, H, c, AfInF, AfSup, AfParete, fCd, fyd, 0, 1)
Ms_rd = DominioRotturaRett(B, H, c, AfInF, AfSup, AfParete, fCd, fyd, 0, 2)
Nc_rd = DominioRotturaRett(B, H, c, AfInF, AfSup, AfParete, fCd, fyd, 5, 1)
Mc_rd = DominioRotturaRett(B, H, c, AfInF, AfSup, AfParete, fCd, fyd, 5, 2)
If flag = 10 Or flag = 11 Or flag = 20 Or flag = 21 Then GoTo uscita ‘salto il resto di codice
‘ calcola Mrd per flessione semplice positiva
If flag >= 30 And flag 0 Then xi = x Else xf = x
Loop Until ((Abs(Nrd) numeroCicli))
If count > numeroCicli Then
Mrd_0 = 0
xc_0 = “ND”
campo_0 = “ND”
epsF_0 = “ND”
sigmaF_0 = “ND”
epsC_0 = “ND”
sigmaC_0 = “ND”
fi_0 = “ND”
Else
xc_0 = asseNeutro(H, c, x)
campo_0 = Int(x) + 1
epsF_0 = CalcEpsilon_rottura(H, c, H – c, x)
sigmaF_0 = SigmaS(CalcEpsilon_rottura(H, c, H – c, x), fyd, 1, 210000)
epsC_0 = CalcEpsilon_rottura(H, c, 0, x)
sigmaC_0 = SigmaC(CalcEpsilon_rottura(H, c, 0, x), fCd, 1)
fi_0 = -(CalcEpsilon_rottura(H, c, 0, x) – CalcEpsilon_rottura(H, c, H, x)) / H
End If
GoTo uscita
End If
‘ calcola Mrd per flessione semplice negativa
If flag >= 40 And flag 0 Then xi = x Else xf = x
Loop Until ((Abs(Nrd) numeroCicli))
If count > numeroCicli Then
Mrd_1 = 0
xc_1 = “ND”
campo_1 = “ND”
epsF_1 = “ND”
sigmaF_1 = “ND”
epsC_1 = “ND”
sigmaC_1 = “ND”
fi_1 = “ND”
Else
xc_1 = H – asseNeutro(H, c, x)
campo_1 = Int(x) + 1
epsF_1 = CalcEpsilon_rottura(H, c, c, x)
sigmaF_1 = SigmaS(CalcEpsilon_rottura(H, c, c, x), fyd, 1, 210000)
epsC_1 = CalcEpsilon_rottura(H, c, H, x)
sigmaC_1 = SigmaC(CalcEpsilon_rottura(H, c, H, x), fCd, 1)
fi_1 = -(CalcEpsilon_rottura(H, c, 0, x) – CalcEpsilon_rottura(H, c, H, x)) / H
End If
GoTo uscita
End If
‘ calcola Mrd(Ned)
If flag >= 50 And flag < 70 Then
If Ned = Ns_rd Then
Mrd_N0 = 0
xc_N0 = “ND”
campo_N0 = “ND”
epsF_N0 = “ND”
sigmaF_N0 = “ND”
epsC_N0 = “ND”
sigmaC_N0 = “ND”
fi_N0 = “ND”
Mrd_N1 = 0
xc_N1 = “ND”
campo_N1 = “ND”
epsF_N1 = “ND”
sigmaF_N1 = “ND”
epsC_N1 = “ND”
sigmaC_N1 = “ND”
fi_N1 = “ND”
GoTo uscita
End If
‘ calcolo Mrd(Ned) flessione positiva
If flag >= 50 And flag Ned Then xi = x Else xf = x
Loop Until ((Abs(Nrd – Ned) numeroCicli))
If count > numeroCicli Then
Mrd_N0 = 0
xc_N0 = “ND”
campo_N0 = “ND”
epsF_N0 = “ND”
sigmaF_N0 = “ND”
epsC_N0 = “ND”
sigmaC_N0 = “ND”
fi_N0 = “ND”
Else
xc_N0 = asseNeutro(H, c, x)
campo_N0 = Int(x) + 1
epsF_N0 = CalcEpsilon_rottura(H, c, H – c, x)
sigmaF_N0 = SigmaS(CalcEpsilon_rottura(H, c, H – c, x), fyd, 1, 210000)
epsC_N0 = CalcEpsilon_rottura(H, c, 0, x)
sigmaC_N0 = SigmaC(CalcEpsilon_rottura(H, c, 0, x), fCd, 1, 210000)
fi_N0 = -(CalcEpsilon_rottura(H, c, 0, x) – CalcEpsilon_rottura(H, c, H, x)) / H
End If
End If
‘ calcolo Mrd(Ned) flessione negativa
If flag >= 60 And flag Ned Then xi = x Else xf = x
Loop Until ((Abs(Nrd – Ned) numeroCicli))
If count > numeroCicli Then
Mrd_N1 = 0
xc_N1 = “ND”
campo_N1 = “ND”
epsF_N1 = “ND”
sigmaF_N1 = “ND”
epsC_N1 = “ND”
sigmaC_N1 = “ND”
fi_N1 = “ND”
Else
xc_N1 = H – asseNeutro(H, c, x)
campo_N1 = Int(x) + 1
epsF_N1 = CalcEpsilon_rottura(H, c, c, x)
sigmaF_N1 = SigmaS(CalcEpsilon_rottura(H, c, c, x), fyd, 1, 210000)
epsC_N1 = CalcEpsilon_rottura(H, c, H, x)
sigmaC_N1 = SigmaC(CalcEpsilon_rottura(H, c, H, x), fCd, 1, 210000)
fi_N1 = -(CalcEpsilon_rottura(H, c, 0, x) – CalcEpsilon_rottura(H, c, H, x)) / H
End If
End If
End If
uscita:
Select Case flag
Case 10
VsezRettSLU01 = Ns_rd
Case 11
VsezRettSLU01 = Ms_rd
Case 20
VsezRettSLU01 = Nc_rd
Case 21
VsezRettSLU01 = Mc_rd
Case 30
VsezRettSLU01 = Mrd_0
Case 31
VsezRettSLU01 = xc_0
Case 32
VsezRettSLU01 = campo_0
Case 33
VsezRettSLU01 = epsF_0
Case 34
VsezRettSLU01 = sigmaF_0
Case 35
VsezRettSLU01 = epsC_0
Case 36
VsezRettSLU01 = sigmaC_0
Case 37
VsezRettSLU01 = fi_0
Case 40
VsezRettSLU01 = Mrd_1
Case 41
VsezRettSLU01 = xc_1
Case 42
VsezRettSLU01 = campo_1
Case 43
VsezRettSLU01 = epsF_1
Case 44
VsezRettSLU01 = sigmaF_1
Case 45
VsezRettSLU01 = epsC_1
Case 46
VsezRettSLU01 = sigmaC_1
Case 47
VsezRettSLU01 = fi_1
Case 50
VsezRettSLU01 = Mrd_N0
Case 51
VsezRettSLU01 = xc_N0
Case 52
VsezRettSLU01 = campo_N0
Case 53
VsezRettSLU01 = epsF_N0
Case 54
VsezRettSLU01 = sigmaF_N0
Case 55
VsezRettSLU01 = epsC_N0
Case 56
VsezRettSLU01 = sigmaC_N0
Case 57
VsezRettSLU01 = fi_N0
Case 60
VsezRettSLU01 = Mrd_N1
Case 61
VsezRettSLU01 = xc_N1
Case 62
VsezRettSLU01 = campo_N1
Case 63
VsezRettSLU01 = epsF_N1
Case 64
VsezRettSLU01 = sigmaF_N1
Case 65
VsezRettSLU01 = epsC_N1
Case 66
VsezRettSLU01 = sigmaC_N1
Case 67
VsezRettSLU01 = fi_N1
Case Else
VsezRettSLU01 = “FLAG”
End Select
End Function
di seguito alcuni commenti
Al solito utilizzo il parametro “flag” passato alla funzione in base al quale stabilisco cosa voglio in output
Dopo la definizione delle variabili (per ciascuna delle quali e’ indicato cosa conterrà), si passa:
A) determinazione dei punti estremi del dominio cioe’ dei punti caratterizzati dalla massimo (minimo) valore di rottura per sforzo assiale ed ai corrispondenti momenti di rottura.
Ns_rd = DominioRotturaRett(B, H, c, AfInF, AfSup, AfParete, fCd, fyd, 0, 1)
Ms_rd = DominioRotturaRett(B, H, c, AfInF, AfSup, AfParete, fCd, fyd, 0, 2)
Nc_rd = DominioRotturaRett(B, H, c, AfInF, AfSup, AfParete, fCd, fyd, 5, 1)
Mc_rd = DominioRotturaRett(B, H, c, AfInF, AfSup, AfParete, fCd, fyd, 5, 2)
Notare che viene chiamata la funzione DominioRotturaRett a cui viene passato il flag 1 o 2 a seconda se si vuole N o M e come parametro di campo vengono passati il valore 0 o 5 a seconda se si vuole il massimo sforzo assiale in trazione o compressione
Lavoro ottimo caro Giovanni!
Ho inserito nell’articolo gli ultimi aggiornamenti, lasciando la spiegazione delle funzioni ai commenti.
Continua a postare che provvederò ad aggiornare l’articolo. Grazie a nome di tutti i lettori (e ne sono parecchi, ormai circa 600 al giorno).
Ovviamente se alla funzione viene richiesto uno dei valori suddetti attraverso uno dei flag 10, 11 , 20 , 21
il codice salta direttamente nella parte di restituzione dei risultati:
If flag = 10 Or flag = 11 Or flag = 20 Or flag = 21 Then GoTo uscita ‘salto il resto di codice
se invece viene richesto altro valore, il codice prosegue con il calcolo di Mrd selezionando la parte di codice che riguarda il valore del flag passato.
Esaminiamo il caso in cui si richiede alla funzione uno dei valori caratteristici (momento, asse neutro, tensioni, curvatura) in presenza di flessione semplice che tende la fibre inferiori (e quindi Ned=0 o se passato un valore diverso da zero comunque ignorato)
Il caso in esame e’ caratterizzato dal flag che varia da 30 a 40 e da un parametro di campo che varia da 0 a 5.
Il flusso e’ il seguente:
1- si fissano i valori limite di campo nelle due variabili xi ed xf
2- si inzializza un contatore in maniera tale da arrestare la funzione se non viene trovata la soluzione entro un numero prefissato di cicli
3- si determinano il valore di Mrd ed Nrd in corrispondenza del valore medio tra xi ed xf (metodo della bisezione)
4 se il valore di Nrd trovato e’ nullo allora abbiamo trovato la soluzione. In realtà è quasi impossibile ottenere l’uguaglianza Nrd=0 e pertanto si stabilisce un limite di tolleranza entro il quale il valore si considera nullo.
5 se invece il valore di Nrd trovato e’ ancora diverso da 0, con Nrd>0, allora poniamo come nuovi estremi di campo il valore medio innanzi ricavato ed il valore finale immutato, altrimenti volore iniziale immutato e valore finale pari al valore medio innanzi ricavato. In questo modo al ciclo successivo si opererà la bisezione del nuovo range. e cosi via a seguire.
6 se il numero di cicli eseguito supera il limite massimo prefissato allora si restituiscono valori stringa che indicano il non raggiungimento della soluzione, in caso contrario, il valore di Mrd ed il valore di x ottenuti uscendo dal ciclo sono quelli cercati.
Qui adesso torna utile la funzione asseneutro che determina la posizione dell’asse neutro per fissato valore di x. La funzione asseneutro la riporto a parte nel prossimo commento.
‘ calcola Mrd per flessione semplice positiva
If flag >= 30 And flag 0 Then xi = x Else xf = x
Loop Until ((Abs(Nrd) numeroCicli))
If count > numeroCicli Then
Mrd_0 = 0
xc_0 = “ND”
campo_0 = “ND”
epsF_0 = “ND”
sigmaF_0 = “ND”
epsC_0 = “ND”
sigmaC_0 = “ND”
fi_0 = “ND”
Else
xc_0 = asseNeutro(H, c, x)
campo_0 = Int(x) + 1
epsF_0 = CalcEpsilon_rottura(H, c, H – c, x)
sigmaF_0 = SigmaS(CalcEpsilon_rottura(H, c, H – c, x), fyd, 1, 210000)
epsC_0 = CalcEpsilon_rottura(H, c, 0, x)
sigmaC_0 = SigmaC(CalcEpsilon_rottura(H, c, 0, x), fCd, 1)
fi_0 = -(CalcEpsilon_rottura(H, c, 0, x) – CalcEpsilon_rottura(H, c, H, x)) / H
End If
GoTo uscita
End If
Function asseNeutro(H As Double, c As Double, x As Double, _
Optional epsSmax As Double = 0.0675, _
Optional epsCmax As Double = 0.0035, _
Optional epsCrif As Double = 0.002) As Variant
‘ Restituisce la posizione dell’asse neutro rispetto al bordo superiore in funzione dei parametri immessi
‘ h = altezza sezione (mm)
‘ c = copriferro inferiore e superiore (mm)
‘ x = coefficiente di campo
If x = 0 Or x = 5 Or x = 10 Then
asseNeutro = 100000000
Else
asseNeutro = -CalcEpsilon_rottura(H, c, 0, x, epsSmax, epsCmax, epsCrif) * H / (CalcEpsilon_rottura(H, c, H, x, epsSmax, epsCmax, epsCrif) – CalcEpsilon_rottura(H, c, 0, x, epsSmax, epsCmax, epsCrif))
End If
End Function
Vediamo adesso come usare le funzioni.
Intanto occorre inserirle in un modulo VBA all’interno del file dove vogliamo utilizzarla.
Per inserire il codice in un modulo seguire i passi:
– aprire un file nuovo di excel
– selezionare la voce di menu “sviluppo”
– quindi premere la prima icona con su scritto “Visual Basica”
N.B.: se non avete la vose “sviluppo” nel menu, occorre farla visualizzare attraverso:
– premere sul “pulsante Office” (il primo in alto a sinistra dello schermo”
– quindi premere il tasto “Opzioni di excel” che trovate in basso nel dialogo che appare prememdo il pulasnte Office
– nelle impostazioni generali spuntare la voce “Mostra scheda di sviluppo sulla barra multifunzione”
Appena siete in ambiente VBA occorre dapprima inserire un nuovo modulo clikkando col destro su una voce qualsiasi del progetto VBA. “inserisci” “nuovo modulo”
Adesso basta copiare ed incollare tutto il codice nel nuovo modulo.
Chiudere l’ambiente VBA e tornare su excel.
Da questo punto in poi avrete a disposizione tra le funzioni definite dall’utente tutte le funzioni incollate nel nuovo modulo.
scusate le k di clik
Adesso vediamo alcune applicazioni:
si voglia il momento resistente per flessione semplice che tende le fibre inferiori di una sezione rettangolare cosi formata:
B=300 mm
H=600 mm
c = 35 mm
Le armature siano :
inferiore: 3Ø18
superiore 3Ø16
di parete: 2Ø12 = 226 mm²
I materiali siano:
cls: fck25—> fcd=0.85*25/1.5 =14.17 MPa
acciaio B450C fyd=450/1.15=391.3 MPa
Scegliere una qualsiasi cella del foglio
da menu scegliere “inserisci funzione”
selezionare quelle definite dall’utente
e quindi scegliere la funzione “VerSezRettSLU01”
vi apparira il form che vi guida all’inserimento dei dati e quindi inserire direttamente i valori che ho esposto attribuendo ad Ned il valore nullo (poichè siamo in flessione semplice ed al flag il valore 30 (poiche vogliamo come output Mrd)
come per magia alla pressione del tasto ok avrete il valore di Mrd espresso in N*mm.
Basta dividere il valore per 1000000 e lo avrete in kN*m oppure per 1000 per averlo in N*m
Se invece avessimo voluto resituita la deformazione dell’acciaio teso o del calcestruzzo compresso o ancora la posizione dell’asse neutro o il campo di rottura o la rotazione sarebbe stato sufficiente dare al parametro flag il corrispondente valore.
Conviene pertanto tenere a portata di mano la corrispondenza “flag” “valore restituito”
Intervengo per dire: ottima idea quella degli esempi Gio’.
Come al solito questa sera aggiornerò tutto.
Supponiamo adesso di volere il Momento di rottura (sempre per flessione che tende le fibre inferiori) ma in corrispondenza di uno sforzo normale di compressione di calcolo pari a Ned=-1000 kN
ricordarsi che la convenzione adottata nella funzione è:
azione assiale di compressione negativa, di trazione positiva e che l’input deve essere nelle unità base: N e mm.
Scegliamo una qualsiasi cella ed inseriamo la stessa funzione di poco fa in cui gli unici valori che variano sono proprio Ned (inseriremo 1000*1000 = 1000000 N) ed il flag (che in questo caso deve essere 50.
Se volessimo la tensione sull’acciaio inferiore il flag da inserire sarebbe 54
Naturalmente i parametri della funzione oltre che essere dei valori numerici direttamente inputati possono essere dei riferimenti a celle contenenti i valori. Da qui ognuno puo’ pensare di strutturarsi un bel foglio di calcolo con i valori da dare in input alla funzione calcolati.
Prossimamente pubblico una possibile applicazione.
@Francesco:
nel caso in cui per l’aggiornamento del 3d utilizzi parti di testo che ho scritto io nei commenti, ti prego di volere apportare le correzioni ai numerosi errori di digitazione che ho disseminato.
Non farmi fare la figura dell’imbecille.
Quando riesco a trovare il giusto tempo, illustrero’ come e’ possibile, sfruttando una delle funzioni, far tracciare l’intero dominio di rottura.
Infine invito tutti quanti a condurre in autonomia anche sfruttando altri software (chiusi) le verifiche di correttezza dei risultati forniti dalla mia funzione e non esitare a segnalare qualsiasi malfunzionamento o errore si manifestasse durante l’uso.
E’ ovvio che la mia funzione non ha scoperto l’acqua calda e che nulla fa che altri programmi dedicati a questa materia non facciano. Ma, al contrario dei programmi chiusi, la mia funzione è “aperta” “gratuita” adattabile e modificale ed infine utilizzabile all’interno di uno strumento potente da tutti utilizzato quale è Excel.
Vi ricordo pero’ che se si volesse utilizzare le funzioni che ho illustrato attraverso modifiche per applicazioni particolari e poi condividere il lavoro, è obbligo morale di citare da qualche parte sia l’autore delle tre funzioni di calcolo di epsilon e di sigmaC e sigmaS (ing D. Cattivelli alias DocHolly) ed il sottoscritto alias “afazio”
grazie
Ok, aggiornato all’ultima funzione lasciando spiegazioni ed esempio nei commenti.
Vediamo adesso come costruire il dominio di rottura per la sezione sopra descritta.
Apriamo un file excel ed incoliamo nel progetto VBA del file il codice.
Poi conviene raggruppare da qualche parte in un foglio le dimensioni della sezione, le armature e le tensioni di calcolo dei materiali in modo da poterci riferire sempre a quelle celle. Cosi sara sufficiente variare il contenuto di queste celle per avere il dominio di una sezione di dimensioni diverse oppure al variare dell’armatura.
Nella immagine che segue ho trascritto i dati dell’esempio che ho trattato.
http://img413.imageshack.us/img413/739/002tp.jpg
Adesso predisponiamo tre colonne destinate a contenere:
– parametro di campo —> x
– Nrd
– Mrd
similmente a quanto rappresentato nella seguente immagine
http://img266.imageshack.us/img266/5591/001mwl.jpg
Adesso popoliamo la colonna relativa al parametro di campo tenendo conto che tanto piu’ fitta e’ la suddivisione tanto piu accurato sarà il dominio di rottura.
Per esempio se vogliamo tracciare solo i punti in corrispondenza delle rette di separazione dei campi di rottura sara sufficiente popolare la colonna delle x con gli interi che variano da 0 a 10.
Per adesso illustro questo caso.
Avremo pertanto una situazione come rappresentata nella immagine che segue.
http://img190.imageshack.us/img190/5638/003ap.jpg
Adesso dobbiamo popolare le due colonne relative ad Nrd e a Mrd sfruttando una delle funzioni che ho trascritto.
Posizioniamoci nella cella D5 ed inseriamo la funzione =DominioRotturaRett in cui i parametri da passare sono quelli relativi alla sezione in esame e raggruppati nelle celle di cui alla prima immagine.
Conviene fissare i riferimenti assoluti ai parametri della sezione. Il parametro x invece e’ quello della colonna x ed il parametro flag è 1. Infine ricordiamoci di dividere per 1000 se vogliamo Nrd espresso in kN.
http://img155.imageshack.us/img155/2849/004oo.jpg
Stessa cosa facciamo posizionandoci sulla cella E5, qui inseriamo ancora la stessa funzione con gli stessi parametri relativi alla sezione e con unica differenza il flag che adesso deve essere 2. Infine dividiamo per 1000000 per ottenere Mrd in kN*m.
Adesso selezioniamo le due celle D5 ed E5 e trasciniamo fino al rigo di x=10
Abbiamo cosi popolato la tabella necessaria per la costruzione del dominio.
Non ci rimane che diagrammare la tabella di dati con grafico tipo “a dispersione x-y con punti uniti la linee.
Dovremmo ottenere una cosa del genere:
http://img34.imageshack.us/img34/5235/005eu.jpg
Come si nota il dominio e’ costituito da una spezzata che approssima per difetto il dominio “continuo” reale.
Se volessimo un dominio piu’ accurato basterebbe, quindi, agire sulla colonna delle x adottando una suddivisione decimale, per esempio con incrementi di 0.1 o anche piu piccoli oppure raffittire solo quelle parti che ci interessano.
Buon divertimento.
A titolo di esempio, questo e’ quanto si ottiene variando la suddivisione del parametro x
ad incrementi di 0.25:
http://img692.imageshack.us/img692/8862/006xk.jpg
e ad incrementi di 0.01
http://img691.imageshack.us/img691/6969/007nig.jpg
Questa ultima suddivisione risulta essere eccessiva in alcuni campi di rottura mentre risulta essere necessaria in altri campi di rottura.
Facendo delle prove di esercizio ciascuno determinerà se conviene adottare o meno questa suddivisione cosi spinta oppure dove agire i raffittimenti.
Saluti
Gio’, scusa se i tuoi commenti non sono stati pubblicati subito ma il sito li mandati in coda di approvazione. Forse per il contenuto (link riconosciuti come spam).
Ok.
L’importante e’ che alla fine siano stati pubblicati. Sinceramente dopo la fatica di fare le immagine mi sarebbe scocciato non si vedesse un tubo.
Adesso lascio maturare un po la questione a coloro che hanno seguito e che han voglia di far delle prove. La potenzialità delle funzioni non si limita a quanto ho illustrato, infatti basta qualche modifica per poter adattare le funzioni al dominio di plasticizzazione o al dominio di fessurazione oppure adattarla a qualsiasi forma di sezione (dalla trapezia alla circolare, con o senza cavità, alla esagonale e cosi via dicendo).
Lo scopo di questa mia pubblicazione non e’ quella di fornire un programma che consente di fare verifiche per qualsiasi caso ma e’ quella di fornire lo strumento per poter fare qualsiasi cosa venga in mente e, ovviamente, con la speranza che ogni eventuale aggiunta/miglioramento/estensione venga pubblicato affinchè anche io possa essere un fruitore.
La “buatta” è questa.
Grazie a tutti.
Chiedo scusa ma non conosco proprio vba. Quando provo a far girare le funzioni su excel incappo sempre in un “errore di sintassi”.
@Braian:
mi spiace, ma non so proprio i motivi per cui non riesci a far girare il codice. Possono essere dal banale errore di copincolla o alla mancanza di una qualche libreria VBA omessa in fase di installazione.
Comunque, tra qualche tempo vedro’ di predisporre un file contenente solo quelle funzioni e lo pubblico. In alternativa vedi se qualche volenteroso puo’ passartelo adesso.
ciao
@ Afazio
Intanto ti ringrazio per la disponibilità e per la tua volontà di condividere risorse, ti apprezzavo già quando ero studente e ti leggevo sui forum. Ieri notte ci ho perso un bel pò di tempo, escludo reiterati errori di copia/incolla. Quando pubblicherai il foglio excel con le ofrmule già preddisposte sarò il primo a scaricarlo!
Ovviamente il buon Afazio non si fa attendere e infatti qualche minuto fa ho ricevuto il file .XLS con le funzioni già inserite e con anche una maschera di input che riassume il significato dei flag:
http://www.box.net/shared/mazg5gha6x
Fantastico foglio, veramente utilissimo.
Provvedo a fare un articolo a parte collegato a questa discussione, dato che il foglio merita ampiamente uno spazio tutto suo.
[…] Questo articolo è da considerarsi una prosecuzione della discussione nata in: “Funzioni Excel per il calcolo del momento resistente di sezioni in cemento armato“ […]
Come riporta il pingback sopra questo commento, il link all’articolo è il seguente:
http://strutturisti.wordpress.com/2010/07/01/versezslu-foglio-di-calcolo-per-la-verifica-di-sezioni-in-cemento-armato/
Continuate a commentare qui per chiarimenti/richieste/segnalazioni.
Intanto 2 download nei primi 2 minuti…
Qualcuno mi ha chiesto se esiste codice similare per le sezioni circolari o per le sezioni a T.
La risposta e’ si. Ho già reso pubblico in passato un foglio che conteneva le verifiche sia di una sezione a T che di una sezione circolare. Basta cercarlo in giro tra i colleghi di ingforum che hanno avuto la possibilità di scaricarlo e farselo passare.
Se si riesce a recuperare il file possiamo aggiungerlo alla sezione “downloads” del sito. Sarebbe utile.
Volevo ringraziare, non avendone avuto prima l’occasione, Afazio, per aver messo a disposizione
il suo lavoro.
Aggiornamento al 22 luglio 2010:
Dal 1/07 al 22/07 il file con le funzioni Excel ha toccato quota 500 downloads stando alle statistiche di Boxnet.
[…] Questo articolo è da considerarsi una prosecuzione della discussione nata in: “Funzioni Excel per il calcolo del momento resistente di sezioni in cemento armato“ […]