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')