Perguntas mais frequentes (FAQ)

Tal como acontece com as secções da biblioteca, isto também funciona com o nome correto. Aqui pode ver um exemplo de programa que deveria criar esta secção:

Cuidado! As dimensões nos nomes das secções têm de ser especificadas em unidades básicas SI, isto é, em metros.

        
from RFEM.initModel import Model
from RFEM.BasicObjects.material import Material
from RFEM.BasicObjects.section import Section

Model(True, "Section")
Model.clientModel.service.begin_modification()
Model.clientModel.service.delete_all()

Material(1, 'S235')

Section(no=1, name='CHS 0.12/0.006/H', material_no=1)

Model.clientModel.service.finish_modification()
Model.clientModel.service.close_connection()

        
    

Uma possibilidade é chamar este URL enquanto o RFEM está em execução:

http://localhost:8082/wsdl

Isso mostra a definição da API completa como XML (ver também WSDL https://en.wikipedia.org/wiki/Web_Services_Description_Language ).

Uma forma pragmática de determinar os parâmetros é, por exemplo, compilar primeiro o material desejado no RFEM e depois ler as propriedades. O seguinte programa mostra o procedimento:

        
de RFEM.initModel import *

Modelo (True, ' Material.rf6 ')
Model.clientModel.service.begin_modification ()

m = Model.clientModel.service.get_material (1)
imprimir (m)

Model.clientModel.service.finish_modification ()
Model.clientModel.service.close_connection ()

        
    

Este método pode ser utilizado para todos os objetos no RFEM.

Uma função para articulações de linha não linear não está atualmente disponível na biblioteca de alto nível do Python. No entanto, uma vez que os parâmetros definidos pelo utilizador podem ser utilizados como habitualmente no método para as articulações de linha, não é um problema gerar também as articulações de linha não lineares.

No programa de exemplo, são criadas primeiro 2 superfícies retangulares com apoios nodais, as quais estão ligadas na linha 6.

A definição da articulação de linha não linear começa na linha 39. Primeiro, é criado um dicionário p com os parâmetros. Tem de ser definido 3 graus de liberdade de deslocamento e um grau de liberdade de rotação. O valor 0.0 significa que a Contagem da liberdade é gratuita. Se em vez disso é escrito um valor numérico, este é interpretado como uma mola. Certifique-se de que são utilizadas aqui as unidades básicas SI. Com inf , o grau de liberdade é definido como fixo.

Deve ser dada uma não linearidade na direção y. É definido com a chave translational_release_u_y_nonlinearity. Este artigo descreve como os valores necessários como NONLINEARITY_TYPE_FAILURE_IF_POSITIVE podem ser determinados.

        
da importação RFEM.enums *
de RFEM.initModel import *
do RFEM.BasicObjects.node importar nó
da linha de importação do RFEM.BasicObjects.line
do material de importação RFEM.BasicObjects.material
from RFEM.BasicObjects.thickness import Espessura
do RFEM.BasicObjects.surface import superfície
from RFEM.TypesForNodes.nodalSupport import NodalSupport
from RFEM.TypesForLines.lineHinge import LineHinge
from RFEM.dataTypes import inf

Modelo (verdadeiro, "articulação de linha")
Model.clientModel.service.begin_modification ()

Nó (1, 0.0, 0.0, 0.0)
Nó (2, 5.0, 0.0, 0.0)
Nó (3, 10.0, 0.0, 0.0)
Nó (4, 0.0, 4.0, 0.0)
Nó (5, 5.0, 4.0, 0.0)
Nó (6, 10.0, 4.0, 0.0)

Linha (1, ' 1 2 ')
Linha (2, ' 2 3 ')
Linha (3, ' 4 5 ')
Linha (4, ' 5 6 ')
Linha (5, ' 1 4 ')
Linha (6, ' 2 5 ')
Linha (7, ' 3 6 ')

Material (1, ' S235 ')

Espessura (1, material_no = 1, uniform_thickness_d = 0,050)

Superfície (1, ' 1 6 3 5 ')
Superfície (2, ' 2 7 4 6 ')

Apoionodal (1, ' 1-3 4-6 ')

p = {
   ' translation_release_u_x ': 0,0,
   ' translation_release_u_y ': 0,0,
   ' translational_release_u_y_nonlinearity ': ' NONLINEARITY_TYPE_FAILURE_IF_POSITIVE ',
   ' translational_release_u_z ': inf,
   ' rotacional_lançamento_phi_x ': inf
}
LineHinge (1, ' 1/6 ', params = p)

Model.clientModel.service.finish_modification ()
Model.clientModel.service.close_connection ()

        
    

No programa de exemplo, é criada primeiro uma consola a partir de um IPE 200. Esta é carregada com uma carga de barra de 3,5 kN e o cálculo é realizado.

Esta tabela é acedida na linha 34:

O método ResultTables.NodesDeformations () requer 3 argumentos. Em primeiro lugar, é determinado que tipo de resultados deve ser lido. Resultados de

• Casos de carga
• Combinações de cargas
• Combinações de resultados
• Situações de dimensionamento
• Fases de construção

ser.

Então é fornecido o número do caso de carga, combinação de cargas etc. Para a descarga, o número do nó é transferido para o método.

O valor de retorno d do método é uma lista que contém um dicionário. Na linha 37, d é apresentado por completo. A linha 40 mostra como é possível aceder a um valor específico. [0] é o índice da lista e [' displacement_z '] é a chave do dicionário.

        
da importação RFEM.enums *
de RFEM.initModel import *
do material de importação RFEM.BasicObjects.material
da Secção de importação do RFEM.BasicObjects.section
do RFEM.BasicObjects.node importar nó
do RFEM.BasicObjects.membrane de importação
from RFEM.TypesForNodes.nodalSupport import NodalSupport
from RFEM.LoadCasesAndCombinations.staticAnalysisSettings import StaticAnalysisSettings
from RFEM.LoadCasesAndCombinations.loadCase import LoadCase
de RFEM.Loads.memberLoad import MemberLoad
de RFEM.Resultados.Resultados importar TabelasResultados

Modelo (Verdadeiro, "Viga.rf6")
Model.clientModel.service.delete_all ()
Model.clientModel.service.begin_modification ()

Material (1, ' S235 ')
Secção (1, ' IPE 200 ')

Nó (1, 0.0, 0.0, 0.0)
Nó (2, 5.0, 0.0, 0.0)

Barra.Viga (1, 1, 2, não_secção_inicial = 1, não_secção_fim = 1)

ApoioNodal (1, ' 1 ', TipoApoioNodal.FIXED)

StaticAnalysisSettings.GeometricallyLinear (1, "Linear")
LoadCase (1, ' Carga ', [Verdadeiro, 0.0, 0.0, 1.0])

MemberLoad (1, 1, ' 1 ', magnitude = 3500)

Calcular_tudo ()

d = ResultTables.NodesDeformations (CaseObjectType.E_OBJECT_TYPE_LOAD_CASE, 1, 2)

# tudo:
imprimir (d)

# deslocamento em Z
print (d [0] [' deslocamento_z '])

Model.clientModel.service.finish_modification ()

        
    

O programa de exemplo mostra dois métodos diferentes para criar apoios de nó... O tipo de enumeração NodalSupportType é usado para o primeiro apoio nodal.

Em alternativa, também pode ser transferida uma lista. A lista tem de conter 6 valores. Os três primeiros valores definem os graus de liberdade de movimento, os três últimos os graus de liberdade de torção.

O valor inf significa que o grau de liberdade é fixo. Com 0 , o grau de liberdade não é mantido. Um valor numérico define uma mola.

        
da importação RFEM.enums *
de RFEM.initModel import *
do RFEM.BasicObjects.node importar nó
from RFEM.TypesForNodes.nodalSupport import NodalSupport
from RFEM.dataTypes import inf

Modelo (Verdadeiro, ' Nodal_support.rf6 ')

Model.clientModel.service.begin_modification ()

Nó (1, 0.0, 0.0, 0.0)
Nó (2, 5.0, 0.0, 0.0)

NodalSupport (1, ' 1 ', NodalSupport.HINGED)
Apoionodal (2, ' 2 ', [inf, inf, inf, 0, 234000, 0])

Model.clientModel.service.finish_modification ()
Model.clientModel.service.close_connection ()

        
    

Na biblioteca de alto nível em Python não existe uma função direta para a geração de material ortotrópico. No entanto, é possível transferir parâmetros definidos pelo usuário para todos os métodos. Isto significa que tal material pode ser facilmente produzido. Este exemplo mostra o procedimento:

        
da importação RFEM.enums *
de RFEM.initModel import *
do material de importação RFEM.BasicObjects.material

Modelo (True, ' Material.rf6 ')
Model.clientModel.service.begin_modification ()

p = {
        "tipo_material": "TYPE_TIMBER",
        "material_model": "MODEL_ORTHOTROPIC_2D",
        "contexto_aplicativo": "TIMBER_DESIGN",
        "modificação_rigidez": É verdade que
        "stiffness_modification_type": "STIFFNESS_MODIFICATION_TYPE_DIVISION"
}
Material (1, ' C24 | EN 338: 2016-04 ', params = p)

Model.clientModel.service.finish_modification ()
Model.clientModel.service.close_connection ()

        
    

O parâmetro definido pelo utilizador é definido primeiro como Dicionário p e depois transferido para params ao criar o material. Este artigo mostra as possibilidades:

Com SetAddonStatus (Model.clientModel, AddOn.timber_design_active, True) a estrutura adicional multicamada é ativada primeiro.

Na próxima etapa, é criado um material ortotrópico. Para fazer isso, é necessário utilizar parâmetros definidos pelo utilizador ao criar o material. Eles são primeiro guardados no dicionário p depois passados como o parâmetro params.

Com Thickness.Layers(1, 'CLT', [[0, 1, 0.012, 0.0], [0, 1, 0.010, 90]]) a espessura é aplicada. É passada uma lista aninhada como parâmetro após o número e o nome. Cada entrada na lista representa uma camada. Se é criado um material isotrópico, a lista deve conter 3 entradas para uma camada, o tipo de camada, o número do material e a espessura da camada. Se o material for ortotrópico, como neste caso, a lista também tem de incluir uma 4ª entrada contém o ângulo de rotação. Cuidado! O ângulo de rotação é dado em graus e não em RAD como é habitual.

        
de RFEM.initModel import *
do material de importação RFEM.BasicObjects.material
from RFEM.BasicObjects.thickness import Espessura

Modelo (new_model = True, model_name = "MeuModelo")
Model.clientModel.service.begin_modification ()
Model.clientModel.service.delete_all ()

SetAddonStatus (Model.clientModel, AddOn.timber_design_active, True)
addonLst = Model.clientModel.service.get_addon_statuses ()
addonLst ["multilayer_surfaces_design_active"] = Verdadeiro
Model.clientModel.service.set_addon_statuses (addonLst)

p = {
        "tipo_material": "TYPE_TIMBER",
        "material_model": "MODEL_ORTHOTROPIC_2D",
        "contexto_aplicativo": "TIMBER_DESIGN",
        "modificação_rigidez": É verdade que
        "stiffness_modification_type": "STIFFNESS_MODIFICATION_TYPE_DIVISION"
}
Material (1, ' CL26E11.8 | Hasslacher ', params = p)

Thickness.Layers(1, 'CLT', [[0, 1, 0.012, 0.0], [0, 1, 0.010, 90]])

Model.clientModel.service.finish_modification ()
Model.clientModel.service.close_connection ()

        
    

Requisitos:

Duas condições têm de ser satisfeitas para que as forças de apoio possam ser adotadas de outros modelos:

1. Os dois modelos precisam estar no mesmo projeto (mesmo ID de projeto)
2. Ambos os modelos têm de ter IDs de modelo diferentes ' s.

Para que os modelos tenham IDs ' diferentes, cada modelo tem de ser criado através de "Ficheiro> Novo ...". Em alternativa, também pode ser guardado um modelo existente como cópia através de "Ficheiro> Guardar como ..."; este também terá um ID diferente. Os ID ' s podem ser visualizados nas informações gerais de um modelo.

Procedimento

Se os requisitos estiverem satisfeitos, a marca de seleção "A partir da reação de apoio ..." pode ser ativada no menu para uma carga nodal no modelo "Filho". No novo separador correspondente, tem de ser especificados o modelo "mãe" (modelo do qual a carga deve ser retirada), a carga (caso de carga/combinação de carga) e o nó do apoio de nó.

Deve-se notar que as cargas podem ser aplicadas mais de uma vez. A posição do nó não tem de ser a mesma que a do modelo "mãe". Quando a carga tiver sido aplicada, o valor "??" aparece primeiro. O valor correto só é apresentado depois de o respetivo caso de carga ter sido calculado. Este cálculo também aciona o cálculo no modelo "mãe".

Alterações no modelo de origem

Se são feitas alterações no modelo "mãe", a carga no modelo "filho" é revertida para "??" definido se o modelo "mãe" foi guardado. Um recálculo do caso de carga no modelo "filho" adota os novos valores.

Durante a criação de uma nova articulação de barra, é necessário especificar um sistema de coordenadas global para a articulação, para que a opção Articulação em tesoura esteja disponível. Após a seleção da função, fica disponível um novo separador de opções, onde pode definir exatamente em que direções a articulação em tesoura deve trabalhar.

No exemplo abaixo existem duas subestruturas. O modelo da esquerda mostra o comportamento de um sistema onde os momentos são transferidos numa direção contínua entre dois elementos com uma articulação em tesoura definida.

O modelo da direita mostra o comportamento de um sistema, onde apenas um dos elementos tem uma articulação em tesoura.