AM10176109611095

###################################################################################
####################
# Carregar as bibliotecas DesignScript e padrão do Python
# import sys

# import clr
# clr.AddReference('ProtoGeometry')
# from Autodesk.DesignScript.Geometry import *
import math as mt

# As entradas para este nó serão armazenadas como uma lista nas variáveis IN.

base = IN[0]/100.0 #Dimensão Base do pilar

altura = IN[1]/100.0 #Dimensão Altura do pilar
cobrimento = IN[2]/100.0 #Cobrimento, sem considerar armaduras
fcd = 1000000.0*IN[3]/1.4 #Fck do concreto
dar = IN[4]/1000.0 #Diâmetro da Armadura
des = IN[5]/1000.0 #Diâmetro do Estribo
dag = IN[6]/1000.0 #Diâmetro máximo do Agregado
fyd = 1000000.0*IN[7]/1.15 #Tensão de escoamento do aço
nd = IN[8]*1000.0 #Força normal solicitantede cálculo
mdx = IN[9]*1000.0 #Momento solicitante de cálculo
mdy = IN[10]*1000.0 #Momento solicitante de cálculo

# Insira o código abaixo desta linha

def espacamento(base, altura, cobrimento, diametro, dagregado, destribo): #Calcula

espaçamentos na seção
s=max(0.02,diametro+0.04*diametro,1.2*dagregado)
seixos=s+diametro+0.04*diametro
dlinha=cobrimento+destribo+(diametro+0.04*diametro)/2
slivrex=base-2*dlinha
slivrey=altura-2*dlinha
return dlinha, slivrex, slivrey, seixos

def distbarras(base, altura, astot, dar, dlinha, slx, sly, seixos): #Dsitribui as 4
barras padrao e inicia a simetria
x11=dlinha
x12=base-dlinha
y11=dlinha
y12=altura-dlinha
nbart=astot/((mt.pi*(dar)**2.0)/4)
nbar=round(nbart)
if nbar<nbart:
nbar=nbar+1
if nbar%2!=0:
nbar=nbar+1
if nbar>4:
pn=[]
if altura>base:
eixo="y"
elif base>altura:
eixo="x"
else:
eixo="xy"
 pn=simetria(pn, x11, x12, y11, y12, eixo, nbar, slx, sly, seixos)
else:
pn=[[x11,y11],[x11,y12],[x12,y12],[x12,y11]]
px=[]
py=[]
for i in range(len(pn)):
px.append(pn[i][0])
py.append(pn[i][1])
return px, py

def asminmax(base, altura):

asmin=max((0.004*base*altura),(mt.pi*0.01*0.01))
asmax=0.04*base*altura
return asmin, asmax

def asminmax1(base, altura, nd, fyd):

asmin=max((0.15*nd/fyd),(0.004*base*altura),(mt.pi()*0.001**2))
asmax=0.04*base*altura
return asmin, asmax

def simetria(pn, x11, x12, y11, y12, eixo, nbarras, slivrex, slivrey, seixos):
#Distribui as barras simetricamente
nbx=round(slivrex/seixos)
nby=round(slivrey/seixos)
if nbx<(slivrex/seixos):
nbx=nbx+1
if nby<(slivrey/seixos):
nby=nby+1
if nbarras%2!=0: #Verifica se a quantidade de barras é par para distribuição
simétrica
nbarras=nbarras+1
ns=int(nbarras/2)
if eixo=="x" and nbx>0: #Espelha no eixo X, distribuindo na parte superior e
inferior
if ns<=nbx:
ni=ns
if ns==1:
ni=0
sb=slivrex/2
j=1
else:
j=0
sb=slivrex/(ns-1)
nbarras1=0
else:
ni=nbx
j=0
sb=slivrex/(nbx-1)
nbarras1=(ns-(nbx))*2
for i in range(int(ni)):
pn.append([x11+(i)*sb+(j)*sb, y11])
pn.append([x11+(i)*sb+(j)*sb, y12])
if nbarras1 >= 1 and (slivrey-2*seixos)>0:
pn=simetria(pn, x11, x12, (y11+seixos), (y12-seixos), eixo, nbarras1,
slivrex, (slivrey-2*seixos), seixos)
elif eixo=="y" and nby>0:
if ns<=nby:
ni=ns
if ns==1:
 ni=0
sb=slivrey/2
j=1
else:
j=0
sb=slivrey/(ns-1)
nbarras1=0
else:
ni=nby
j=0
sb=slivrey/(nby-1)
nbarras1=(ns-(nby))*2
for i in range(int(ni)):
pn.append([x11, y11+(i)*sb+(j)*sb])
pn.append([x12, y11+(i)*sb+(j)*sb])
if nbarras1 >= 1 and (slivrex-2*seixos)>0:
pn=simetria(pn, (x11+seixos), (x12-seixos), y11, y12, eixo, nbarras1,
(slivrex-2*seixos), slivrey, seixos)
elif eixo=="xy":
if ns%2!=0: #Verifica se a quantidade de barras é par para distribuição
simétrica
ns=ns+1
nsx=ns/2+1
else:
nsx=int(ns/2)+1
if nsx<=nbx:
ni=nsx
if nsx==1:
ni=0
sbx=slivrex/2
j=1
else:
j=0
sbx=slivrex/(nsx-1)
nbarrasx=0
else:
ni=nbx
j=0
sbx=slivrex/(nbx-1)
nbarrasx=(nsx-(nbx))*2
for i in range(int(ni)):
pn.append([x11+(i)*sbx+(j)*sbx, y11])
pn.append([x11+(i)*sbx+(j)*sbx, y12])

for k in range(int(ni-2)):
pn.append([x11, y11+sbx+(k)*sbx+(j)*sbx])
pn.append([x12, y11+sbx+(k)*sbx+(j)*sbx])
if (nbarrasx*2) >= 1 and (slivrey-2*seixos)>0 and (slivrey-2*seixos)>0:
pn=simetria(pn, (x11+sbx), (x12-sbx), (y11+sbx), (y12-sbx), eixo,
(nbarrasx*2), (slivrex-2*sbx), (slivrex-2*sbx), seixos)
return pn

#########################################################################
def regiao123(altura, dlinha, x, y): #retorna deformação no ponto
d=altura-dlinha
if (x/d)<=0.259: # regiao I> D1 e D2>
esu=+0.01
e=esu*((x-y)/(x-d))
elif (x/d)>=0.259 and x<=altura: #regiao II> D3, D4 e D4a
 ecu=-0.0035
e=ecu*((x-y)/x)
elif x>=altura: #regiao III> D5
ecu=-0.002
e=ecu*((x-y)/(x-(3*altura/7)))
return e

def tensaonoconcreto(altura, dlinha, fcd, x, y): #calcula a tensão na fibra mais

comprimida do concreto
ec=regiao123(altura, dlinha, x, y)
fck=fcd*1.4
if fck<=50000000:
ec1=-0.002
ecu=-0.0035
elif fck>50000000 and fck<=90000000:
ec1=-(0.002+0.000085*(fck-50000000)**0.53)
ecu=-(0.0026+0.035*(90000000-fck/100000000)**4)
if ec>=0:
sigmac=0
elif 0>ec and ec>=ec1:
sigmac=850*fcd*(1+250*ec)*ec
elif ec1>=ec and ec>=ecu:
sigmac=-0.85*fcd
if fck>50000000 and fck<=90000000:
sigmac=-0.85*(1-(fck-50000000)/200000000)
return sigmac

def tensaonoaco(fyd, es): #retorna tensão no aço

eyd=fyd/(210000000000.0)
if abs(es)<=eyd:
sigmas=es/eyd*fyd
elif abs(es)>eyd:
sigmas=(es/abs(es))*fyd
return sigmas

def calcas(base, altura, dlinha, nd, md, fcd, fyd, pn, x): #Calcula posição da
linha neutra diferença dos momentos
ts=[] #armazenar as tensões das barras
for n in range(len(pn)): #loop para calcular as tensões das barras
ts.append(tensaonoaco(fyd,regiao123(altura, dlinha, x, pn[n])))
tts=0.0
tti=0.0
ttsy=0.0
ttiy=0.0
for i in range(len(ts)): #loop para somatoria de tensões e tensão x ys
if pn[i]<=altura/2.0:
tts=tts+ts[i] #soma tensoes acima do cg
ttsy=ttsy+(ts[i]*(altura/2.0-pn[i])) #soma momento acima do cg
else:
tti=tti+ts[i] #soma tensoes abaixo do cg
ttiy=ttiy+(ts[i]*(altura/2.0-pn[i])) #soma momento abaixo do cg
ttys=ttiy+ttsy #momento da armadura em relação ao cg
tt=abs(tts)+abs(tti) #tensão total resistente tração e/ou compressão do aço
tc=tensaonoconcreto(altura, dlinha, fcd, x, 0.0) #cálculo da tensão no concreto
>> 0 para tracao y1, y2, y3
x1=x
if x<=0.0:
x1=0
if x>1.25*altura:
 x1=1.25*altura
ac=0.8*x1*base #area do concreto comprimido para ln <= 1.25h
yc=(altura/2.0)-(0.4*x1) #cg da area de concreto comprimida
nrc=0.8*tc*ac #forca resistente do concreto 0.8 simplifica o diagrama
mrc=nrc*yc #momento resistente do concreto
if nd==0: #flexão simples
if (md+mrc)>0: #considera área de armadura dupla
ast=(md+mrc)/(-ttys)
else:
ast=0
else: #flexão composta
ast=(nd+nrc)/(tt)
if (nd+nrc)<=0:
ast=0
mra=ast*ttys #momento resistente da armadura de aço
mr=-(mrc+mra) #momento resistente
dif=mr-md #diferença entre os momentos, saida para otimizacao
ast=ast*len(pn)
return dif, ast

def fx(x, args):

dif, ast = calcas(args[0], args[1], args[2], args[3], args[4], args[5],
args[6], args[7], x)
return dif

def procxln(xL, xH, mxe, maxit, args):

nit=0
ndint=100
raiz=0.0
inter=[]
err=1.0
while abs(fx(raiz, args))>mxe and nit<maxit and err>1e-9:
nit=nit+1
if abs(fx(xL, args))>mxe or abs(fx(xH, args))>mxe:
for i in range(ndint):
i0=(i*(xH-xL)/ndint)+xL
i1=((i+1)*(xH-xL)/ndint)+xL
if fx(i0,args)*fx(i1,args)<0:
inter.append([i0,i1])
if len(inter)>0:
if len(inter)>1:
i=len(inter)-1
raiz, nit=procxln(inter[i][0],inter[i][1],mxe,maxit, args)
xL=inter[i][0]
xH=inter[i][1]
else:
xL=inter[0][0]
xH=inter[0][1]
inter=[]
else:
if abs(fx(xL, args))<mxe:
raiz=xL
else:
raiz=xH
err=xH-xL
if err<1e-9:
raiz=xL
return raiz, nit
#########################################################################

def asfinal(As1, Err1, As2, Err2):

asf=0.0
if As1>As2:
if abs(Err1)<=1e-3:
asf=As1
elif abs(Err2)<=1e-3:
asf=As2
elif Err1>0 and abs(Err1)<abs(Err2):
asf=As1
elif abs(Err1)<abs(Err2):
asf=As1
else:
asf=As2
else:
if abs(Err2)<=1e-3:
asf=As2
elif abs(Err1)<1e-3:
asf=As1
elif Err2>0 and abs(Err2)<abs(Err1):
asf=As2
elif abs(Err2)<abs(Err1):
asf=As2
else:
asf=As1
return asf

#########################################################################

dlinha, slx, sly, seixos=espacamento(base, altura, cobrimento, dar, dag, des)

asmin, asmax =asminmax(base, altura)

astot=asmin
astbarras=0
astf=1
inter=0
while astbarras<astf and inter<5:
pnx, pny=distbarras(base, altura, astot, dar, dlinha, slx, sly, seixos)
############################### BASE X ALTURA
argsbh=[base, altura, dlinha, nd, mdy, fcd, fyd, pny]
pxlnbh, nitbh=procxln(0.0, (15.0*argsbh[1]), 0.001, 15, argsbh)
difbh, astbh = calcas(argsbh[0], argsbh[1], argsbh[2], argsbh[3], argsbh[4],
argsbh[5], argsbh[6], argsbh[7], pxlnbh)
############################### ALTURA X BASE
argshb=[altura, base, dlinha, nd, mdx, fcd, fyd, pnx]
pxlnhb, nithb=procxln(0.0, (15.0*argshb[1]), 0.001, 15, argshb)
difhb, asthb = calcas(argshb[0], argshb[1], argshb[2], argshb[3], argshb[4],
argshb[5], argshb[6], argshb[7], pxlnhb)

astbarras=round(len(pnx)*(mt.pi*(dar/2)**2),10)
astf=round(asfinal(astbh, difbh, asthb, difhb),10)
astot=astf
inter=inter+1
if astot<asmin:
#astot=asmin #Nos caso de As=0 adota-se asmin
inter=6
elif astot>asmax:
 #astot=1000
pnx, pny=distbarras(base, altura, astot, dar, dlinha, slx, sly, seixos)
inter=6

txaco=round((astot-asmin)/(asmax-asmin),3)

# Atribua a sua saída para a variável OUT.

OUT= astot, astbarras, txaco, pnx, pny