def testeFunicular(vetores,funicular,tolerancia):
prm1 = gh.LineXLine(rs.coerceline(vetores[0]),funicular[0])[0]
prm2 = gh.LineXLine(rs.coerceline(vetores[0]),funicular[-1])[0]
if abs(prm1 - prm2) <= tolerancia :
return True
else:
return False
def Cremona2(no, nomes, Linhas, countPF, dicPF):
ptos1 = []
dicUp = {}
for i in range(countPF):
if i == 0:
Spt = dicPF[nomes[i]].PointAt(0)
Ept = dicPF[nomes[i]].PointAt(1)
else:
if i == 1:
cond1 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0),
dicPF[nomes[i]].PointAt(1), Tol)
cond2 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0),
dicPF[nomes[i]].PointAt(0), Tol)
if cond1 or cond2:
pAux3 = Spt
Spt = Ept
Ept = pAux3
if rs.PointCompare(Ept, dicPF[nomes[i]].PointAt(1), Tol):
ptAux1 = dicPF[nomes[i]].PointAt(1)
ptAux2 = dicPF[nomes[i]].PointAt(0)
else:
ptAux1 = dicPF[nomes[i]].PointAt(0)
ptAux2 = dicPF[nomes[i]].PointAt(1)
Ept += (ptAux2 - ptAux1)
vAux1 = Line(rs.CurveStartPoint(Linhas[-2]), Ept)
vAux2 = Line(rs.CurveStartPoint(Linhas[-1]), Spt)
F1 = gh.Move(rs.coerceline(Linhas[-2]), vAux1)[0]
F2 = gh.Move(rs.coerceline(Linhas[-1]), vAux2)[0]
inter = gh.LineXLine(F1, F2)[2]
F1 = rs.AddLine(Ept, inter)
F2 = rs.AddLine(inter, Spt)
dicUp[nomes[-2]] = rs.coerceline(F1)
dicUp[nomes[-1]] = rs.coerceline(F2)
#-cargas e nomenclatura
#teste de tração e compressão
sin1 = TraComp(no, F1, rs.coerceline(Linhas[-2]), nomes[-2])
sin2 = TraComp(no, F2, rs.coerceline(Linhas[-1]), nomes[-1])
#valores das cargas
carga1 = rs.CurveLength(F1) * sin1 / Escala
carga2 = rs.CurveLength(F2) * sin2 / Escala
#teste de tensão admissivel
cor1 = teste_elemento(nomes[-2], carga1, Linhas[-2])
cor2 = teste_elemento(nomes[-1], carga2, Linhas[-1])
#nomenclatura do FG
txt1 = nomes[-2] + ' = ' + str('%.2f' % carga1)
txt2 = nomes[-1] + ' = ' + str('%.2f' % carga2)
pt1 = rs.coerceline(Linhas[-2]).PointAt(.5)
pt2 = rs.coerceline(Linhas[-1]).PointAt(.5)
ptos1 += [pt1, txt1, cor1]
ptos1 += [pt2, txt2, cor2]
#nimenclatura do PF
pt1 = rs.coerceline(F1).PointAt(.5)
pt2 = rs.coerceline(F2).PointAt(.5)
txt1 = nomes[-2]
txt2 = nomes[-1]
ptos1 += [pt1, txt1, cor1]
ptos1 += [pt2, txt2, cor2]
return dicUp, ptos1
def Cremona1(no, nomes, Linhas, countPF, dicPF):
ptos1 = []
dicUp = {}
for i in range(countPF):
if i == 0:
Spt = dicPF[nomes[i]].PointAt(0)
Ept = dicPF[nomes[i]].PointAt(1)
else:
if i == 1:
cond1 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0),
dicPF[nomes[i]].PointAt(1), Tol)
cond2 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0),
dicPF[nomes[i]].PointAt(0), Tol)
if cond1 or cond2:
pAux3 = Spt
Spt = Ept
Ept = pAux3
if rs.PointCompare(Ept, dicPF[nomes[i]].PointAt(1), Tol):
ptAux1 = dicPF[nomes[i]].PointAt(1)
ptAux2 = dicPF[nomes[i]].PointAt(0)
else:
ptAux1 = dicPF[nomes[i]].PointAt(0)
ptAux2 = dicPF[nomes[i]].PointAt(1)
Ept += (ptAux2 - ptAux1)
F1 = rs.AddLine(Ept, Spt)
#verificar o paralelismo entre F1 no PF e FG
vec1 = rs.VectorCreate(rs.CurveEndPoint(Linhas[-1]),
rs.CurveStartPoint(Linhas[-1]))
vec2 = rs.VectorCreate(Spt, Ept)
if rs.IsVectorParallelTo(vec2, vec1):
print '______Paralelismo______'
#colovcando F1 no dicionario do PF
dicUp[nomes[-1]] = rs.coerceline(F1)
#-cargas e nomenclatura
#teste de tração e compressão
sin1 = TraComp(no, F1, rs.coerceline(Linhas[-1]), nomes[-1])
#valores das cargas
carga1 = rs.CurveLength(F1) * sin1 / Escala
#teste de tensão admissivel
cor1 = teste_elemento(nomes[-1], carga1, Linhas[-1])
#nomenclatura do FG
txt1 = nomes[-1] + ' = ' + str('%.2f' % carga1)
pt1 = rs.coerceline(Linhas[-1]).PointAt(.5)
ptos1 += [pt1, txt1, cor1]
#nomenclatura do PF
pt1 = rs.coerceline(F1).PointAt(.5)
txt1 = nomes[-1]
ptos1 += [pt1, txt1, cor1]
return dicUp, ptos1
def ChangeLineLength(obj, fixedLengths):
rhobj = rs.coerceline(obj)
stPt = rhobj.PointAt(0)
vec = rs.VectorCreate(rhobj.PointAt(1), stPt)
vec.Unitize()
newEndPt = stPt.Add(stPt, vec*fixedLengths[0])
return rc.Geometry.Line(stPt, newEndPt)
def estendeFG(linha,corda,ponto):
linnha = rs.coerceline(linha)
ponto = rs.coerce3dpoint(ponto)
if not gh.CurveXCurve(linha,corda)[0]:
pt =gh.EndPoints(linha)[0]
construc_aux.append(Line(pt,ponto))
return True
else:
return False
def TraComp(no, forcePF, forceFG, nome):
pontoFG = forceFG.PointAt(.5)
movevec = rs.AddLine(rs.CurveEndPoint(forcePF), no)
movevec = rs.coerceline(movevec)
testeLin = gh.Move(rs.coerceline(forcePF), movevec)[0]
dist1 = rs.Distance(testeLin.PointAt(0), pontoFG)
dist2 = gh.Length(testeLin)
dist2 += (gh.Length(forceFG) / 2)
#testando tração
if abs(dist1 - dist2) <= Tol:
#coloca a nomenclattura do elemento na lista de objetos tracionados
Ltrac.append(nome)
#retorna 1 para tração
return 1
#se compressão
else:
#coloca a nomenclattura do elemento na lista de objetos comprimidos
Lcomp.append(nome)
#retorna -1 para compressão
return -1
def Linhas_de_Cargas(viga, cargas, nome):
Cargasvigas = []
ptos1 = []
nos = rs.PolylineVertices(viga[0])
for i in range(len(cargas)):
lincarg = Linha_force_extena(nos[i], cargas[i], Escala)
linCoe = rs.coerceline(lincarg)
pt1 = linCoe.PointAt(.5)
pt2 = linCoe.PointAt(0)
texto1 = str('%.2f' % cargas[i])
texto2 = 'P' + str(i) + '_' + nome
Cargasvigas.append(lincarg)
ptos1 += [pt1, texto1, corcargas]
ptos1 += [pt2, texto2, corcargas]
return Cargasvigas, ptos1
def OrdenaLinhasDeAcao(no, cirDir, Linhas, nomes, dicPF, Plano):
#serando contadores
countPF = 0
countCalcular = 0
#lista do comprimento das Linhas
compList = [rs.CurveLength(x) for x in Linhas]
cRaio = min(compList) / 2
#circulo com direção de desenho na direeção de escolha dos vetores
Circulo = SentidoNo(cirDir, no, Plano, cRaio)
#lista de paramentos paara ordenar
paramAux = []
#para cada linha da entrada 3
for I in range(len(Linhas)):
iCoe = rs.coerceline(Linhas[I])
#testa se a força atuante no elemento já e conehcida
if nomes[I] in dicPF:
#contador de forças conecidas no no
countPF += 1
else:
#contador das forças desconhecidas que atuam no no
countCalcular += 1
cirCoe = rs.coercecurve(Circulo)
#lista - inter = [ponto de interseção,parametro no circulo,parametro na linha)]
inter = gh.CurveXCurve(cirCoe, iCoe)
# coloca parametro de interceção entre Linha e circulo na lista
# lista - paramAux - tem a mesma ordem das curvas em Linhas e os nomes
paramAux.append(inter[1])
#ordenando linhas e nomes de acordo com os parametros -- paramAux
Linhas = [
x for (y, x) in sorted(zip(paramAux, Linhas), key=lambda pair: pair[0])
]
nomes = [
x for (y, x) in sorted(zip(paramAux, nomes), key=lambda pair: pair[0])
]
if (0 < countPF):
while nomes[0] in dicPF:
nomes = nomes[1:] + nomes[:1]
Linhas = Linhas[1:] + Linhas[:1]
while nomes[0] not in dicPF:
nomes = nomes[1:] + nomes[:1]
Linhas = Linhas[1:] + Linhas[:1]
return nomes, Linhas, countPF, countCalcular
def get_segment(self, i, _in, _input_node_index_num):
"""Sorts out and gets the params of the input (number | curve | line)
Args:
i (int): The index of the segment to be analysed
_in (number | curve | line): The input item to be analysed
Returns:
(namedtuple) Segment(length='', width='', i_thickness='', i_lambda='')
"""
Segment = namedtuple('Segment',
['length', 'width', 'i_thickness', 'i_lambda'])
try:
# If its just a regular number input
length = float(LBT2PH.helpers.convert_value_to_metric(_in, 'M'))
return Segment(length, None, None, None)
except AttributeError as e:
# OK, so its not a regular number, try and sort out what geometry it is...
seg_GUID = self.get_input_GUID(i, _input_node_index_num)
if isinstance(_in, Rhino.Geometry.Curve):
if self.is_gh_geometry(seg_GUID):
crv = rs.coercecurve(_in)
crv_length = crv.GetLength()
return Segment(crv_length, None, None, None)
else:
return Segment(*self.get_params_from_rhino(seg_GUID))
elif isinstance(_in, Rhino.Geometry.Line):
if self.is_gh_geometry(seg_GUID):
line = rs.coerceline(_in)
line_len = line.Length
return Segment(line_len, None, None, None)
else:
return Segment(*self.get_params_from_rhino(seg_GUID))
else:
msg = ' Sorry, I do not understand the input for _duct_length?\n'\
'Please input either: a list of Rhino Curves, Lines or numbers representing\n'\
'the lengths of the duct segments.\n\n{}'.format(e)
raise Exception(msg)
def Cargas_Vigas(viga, plD, plB, plC, cob, borda1, borda2, conv):
#
cob = rs.coercecurve(cob)
forces = []
#separando entrada viga em seus elementos (polilinhas)
#bs = banzo superior, diag = diagonais, bi = banzo inferior
bs, diag, bi = viga
#extraindo os nós do banzo superior
nos = rs.PolylineVertices(bs)
# explodindo polilinhas
bs = rs.ExplodeCurves(bs)
diag = rs.ExplodeCurves(diag)
bi = rs.ExplodeCurves(bi)
for i in range(len(nos)):
P = 0
if 0 < i < (len(nos) - 1):
#banzo inferior
P = rs.CurveLength(bi[i]) * plB
#banzo superior
P += (rs.CurveLength(bs[i - 1]) + rs.CurveLength(bs[i])) / 2 * plB
#diagonais
P += (rs.CurveLength(diag[i * 2]) +
rs.CurveLength(diag[(i * 2) + 1])) * plD
#cobertura
bs1 = bs[i - 1]
bs1 = rs.coerceline(bs1)
ptAux1 = bs1.PointAt(.5)
bs2 = bs[i]
bs2 = rs.coerceline(bs2)
ptAux2 = bs2.PointAt(.5)
param1 = rs.CurveClosestPoint(cob, ptAux1)
param2 = rs.CurveClosestPoint(cob, ptAux2)
elif i == 0:
#banzo inferior
P = rs.CurveLength(bi[i]) * plB
#banzo superior
P += (rs.CurveLength(bs[i]) / 2) * plB
#diagonais
P += (rs.CurveLength(diag[i * 2]) +
rs.CurveLength(diag[(i * 2) + 1])) * plD
#cobertura
param1 = 0
bs1 = bs[i]
bs1 = rs.coerceline(bs1)
ptAux = bs1.PointAt(.5)
#teste.append(ptAux)
param2 = rs.CurveClosestPoint(cob, ptAux)
elif i == (len(nos) - 1):
#banzo superior e conector
P = (rs.CurveLength(bs[i - 1]) + rs.CurveLength(borda1)) / 2 * plB
#conector
P += rs.CurveLength(borda2) * plB
#cobertura
bs1 = bs[i - 1]
bs1 = rs.coerceline(bs1)
ptAux1 = bs1.PointAt(.5)
borda1 = rs.coerceline(borda1)
ptAux2 = borda1.PointAt(.5)
param1 = rs.CurveClosestPoint(cob, ptAux1)
param2 = rs.CurveClosestPoint(cob, ptAux2)
if not len(diag) % 2 == 0:
#banzo inferior
P += rs.CurveLength(bi[i]) * plB
#diagonal
P += (rs.CurveLength(diag[i * 2])) * plD
P_viga = P
if not param1 == param2:
cobAux = rs.TrimCurve(cob, [param1, param2], False)
P_cob = rs.CurveLength(cobAux) * plC
P += P_cob
P *= conv
forces.append(P)
return forces, P_viga, P_cob
v2 = Eixos[3:6]
v3 = Eixos[6:9]
#invertendo sentido da viga v3
rs.ReverseCurve(v3[0])
rs.ReverseCurve(v3[1])
rs.ReverseCurve(v3[2])
#diagonais
Diagonais = [v1[1], v2[1], v3[1]]
#banzos
Banzo_Sup = [v1[0], v2[0], v3[0]]
Banzo_Inf = [v1[2], v2[2], v3[2]]
#apoios
Apoios = [rs.CurveStartPoint(v1[2]), rs.CurveStartPoint(v2[2])]
#Eixo de Simetria do conector
EixoSimetria = Conector[0]
EixoSimetria = rs.coerceline(EixoSimetria)
def Volumetria(eixos, dist_e, dist_l, pto):
plAux = rs.CopyObject(eixos, -eZ * (dist_l))
plAux2 = rs.CopyObject(eixos, eZ * (dist_l))
pl1 = rs.OffsetCurve(plAux, pto, dist_e, eZ)
pl1 = rs.coercegeometry(pl1)
pl2 = rs.OffsetCurve(plAux, pto, -dist_e, eZ)
pl2 = rs.coercegeometry(pl2)
pl3 = rs.AddLine(rs.CurveStartPoint(pl1), rs.CurveStartPoint(pl2))
pl4 = rs.AddLine(rs.CurveEndPoint(pl1), rs.CurveEndPoint(pl2))
#uma reta que intercepta a Curva no ponto do eixo
#caso seja um float:
if type(Eixo_de_Simetria) == float:
#ptX1 = coordenadas da curva no ponto de interceção com o eixo de simetria
#vct1 = tangente da curva no ponto
#prm1 = parametro da curva no ponto
ptX1, vtc1, prm1 = gh.EvaluateLength(BzSup1, Eixo_de_Simetria, True)
ptAux = gh.Move(ptX1, -eY)[0]
#-desenhando linha do Exio de simetria
Eixo_de_Simetria = rs.AddLine(ptX1, ptAux)
#caso seja uma linha
elif str(type(Eixo_de_Simetria)) == "<type 'Guid'>":
#ptX1 = coordenadas do ponto de interceção da Curva com o eixo de simetria
#prm1 = parametro da curva no ponto
#count = conta o número de interceções
ptX1, prm1, count = gh.CurveXLine(BzSup1, rs.coerceline(Eixo_de_Simetria))
ptAux = gh.Move(ptX1, -eY)[0]
#caso o vão da viga seja definido pela variavel VigaDist
if VigaDist:
ptobase = rs.CurveStartPoint(Curva)
ptoAux = rs.LineClosestPoint(Eixo_de_Simetria, ptobase)
dist1 = rs.Distance(ptobase, ptoAux)
escala = (VigaDist / 2) / dist1
escala = [escala, escala, escala]
Curva, Eixo_de_Simetria = rs.ScaleObjects((Curva, Eixo_de_Simetria),
ptobase, escala)
#ptX1 = coordenadas do ponto de interceção da Curva com o eixo de simetria
#prm1 = parametro da curva no ponto
#count = conta o número de interceções
BzSup1 = rs.coercecurve(Curva)
ptX1, prm1, count = gh.CurveXLine(BzSup1, rs.coerceline(Eixo_de_Simetria))
pt1 = gh.EndPoints(reta1)[0]
pt2 = reta2.ClosestPoint(pt1,False)
return gh.Length(Line(pt1,pt2))
# Desenhando o poligono de forças
pAux = rs.coerce3dpoint(pto_inicial)
polo = rs.coerce3dpoint(polo)
#primeiro raio polar
raios.append(Line(polo,pAux))
for v in vetores:
vAux1 = rs.coerceline(v)
vAux2 = pAux - v.PointAt(0)
vAux3 = gh.Move(vAux1,vAux2)[0]
pAux = vAux3.PointAt(1)
PF.append(vAux3)
r=Line(polo,pAux)
raios.append(r)
#desenhando a resultante
result=Line(rs.coerce3dpoint(pto_inicial),pAux)
#Desenhando o funicular
j = len(raios)
def PF_funic(pto_inicial, polo, carreg, nomes_cargas):
raios = []
ptos = []
dicUp = {}
PF = []
resultante = []
funicular = []
## -- Desenhando o poligono de forças -- ##
pAux = rs.coerce3dpoint(pto_inicial)
# polo do PF do Shed
polo = rs.coerce3dpoint(polo)
#primeiro raio polar
raios.append(Line(polo, pAux))
ptos += [polo, 'polo', cornode]
#desenhando carregamentos no PF e os raios polares
for i in range(len(carreg)):
v = carreg[i]
#carregamento no FG
vAux1 = rs.coerceline(v)
#vetor auxiliar para mover o carregamento para a posição de soma
vAux2 = pAux - v.PointAt(0)
# carregamento no PF
vAux3 = gh.Move(vAux1, vAux2)[0]
#Nomenclatura - texto da reação Pi
nome = nomes_cargas[i]
#Nomenclatua - posição do texto
txtPt = vAux3.PointAt(.5)
# Nomenclatura do PF
ptos += [txtPt, nome, corcargas]
# colocando carregamento na lista do PF
PF.append(vAux3)
# olocando carregamento no dicionario do PF
dicUp[nome] = vAux3
# ponto da posição de soma para o proximo carregamento
pAux = vAux3.PointAt(1)
#desenhando raio polar
r = Line(polo, pAux)
#colocando raio polar na lista de raios
raios.append(r)
#desenhando a resultante no PF
#ponto final da resultante R1
pto_R1 = pAux
#resultante r1 no PF
R1PF = Line(rs.coerce3dpoint(pto_inicial), pto_R1)
#colocando R1 na lista de resultantes
resultante.append(R1PF)
#R1 no dicionario do PF
dicUp['R1'] = R1PF
#Desenhando o funicular
for i in range(len(raios)):
r = rs.coerceline(raios[i])
#caso da primeira corda
if i == 0:
pAux = (rs.coerceline(carreg[0]).PointAt(0))
vAux1 = Line(r.PointAt(0), pAux)
corda = gh.Move(r, vAux1)[0]
corda = rs.coerceline(corda)
#cordas intermediarias
elif i < len(raios) - 1:
vAux1 = Line(r.PointAt(1), pAux)
crdAux = gh.Move(r, vAux1)[0]
crdAux = rs.coerceline(crdAux)
pAux2 = pAux
pAux = gh.LineXLine(crdAux, carreg[i])[-1]
corda = Line(pAux2, pAux)
#caso da ultima corda
else:
vAux1 = Line(r.PointAt(1), pAux)
corda = gh.Move(r, vAux1)[0]
corda = rs.coerceline(corda)
#adicionando corda na lista do funicular
funicular.append(corda)
#resesenhando as cordas extremas
return dicUp, raios, funicular, resultante, ptos
# lista com as forças limites para banzos e diagonais
F_adm = [(x * T_adm) / coe_Trac for x in Areas[0]]
#Separando os eixos em listas
#conector
Conector = Eixos[-2:]
#vigas
v1 = Eixos[:3]
v2 = Eixos[3:6]
v3 = Eixos[6:9]
#apoios
Apoios = [rs.CurveStartPoint(v1[2]), rs.CurveStartPoint(v2[2])]
#Eixo de Simetria do conector
EixoSimetria = Conector[0]
Bconect = Conector[1]
EixoSimetria = rs.coerceline(EixoSimetria)
ptX = gh.EndPoints(EixoSimetria)
# vareável booleana para iniciar análise
if Iniciar_Analise == None:
Iniciar_Analise = True # calcula tensões para True ou none
if Iniciar_Analise: #não calcula para False
#Cargas na viga v1
C_v1, ptC_v1 = Linhas_de_Cargas(v1, P_v1, 'V1')
Linhas_de_Carga += C_v1
txt_pontos += ptC_v1
#Cargas na viga v2
C_v2, ptC_v2 = Linhas_de_Cargas(v2, P_v2, 'V2')
Linhas_de_Carga += C_v2
txt_pontos += ptC_v2
#Cargas na viga v3
C_v3, ptC_v3 = Linhas_de_Cargas(v3, P_v3, 'V3')