A biblioteca HLF para C#disponibiliza inúmeras funções úteis para a criação de estruturas no RFEM e no RSTAB, algumas das quais serão utilizadas no exemplo seguinte.
Para implementar o código programado, é necessária primeiro uma ligação ao programa. Uma das portas disponíveis tem de ser especificada como endereço. O endereço predefinido do RFEM/RSTAB é http://localhost:8081. Caso seja necessário, pode ser alterado nas opções do programa.
No passo seguinte, vários objetos, tais como nós, linhas e barras podem ser criados utilizando as funções disponíveis na biblioteca C#. A biblioteca inclui classes para todos os objetos disponíveis. Com base em parâmetros, as propriedades dos objetos' podem ser definidas e especificadas. O número de parâmetros pode variar dependendo do caso de uso.
A tabela a seguir mostra como os objetos podem ser definidos utilizando o exemplo de um nó:
nó novoNó = novo()
{
não = nodeId,
coordenadas = new vector_3d() { x = xVector, y = 0,0, z = 0,0 },
tipo_do_sistema_de coordenadas = nó tipo_de_coordenadas_de_coordenadas.COORDINATE_SYSTEM_CARTESIAN,
sistema_de coordenadasEspecificado = verdadeiro,
comment = "nó por viga"
};
As linhas, superfícies e outros objectos são definidos da mesma maneira. Observe que um atributo "Especificado" correspondente deve ser definido e definido como "true" para determinados atributos.
Exemplo prático
Este exemplo mostra como criar uma viga contínua com uma carga de linha constante. O número de vãos, o vão da viga e o valor da carga de linha podem ser definidos de forma variável através da entrada do utilizador.
Primeiro, as variáveis necessárias são definidas pelo utilizador na consola. O programa verifica se a entrada do utilizador é compatível com o tipo de dados da respetiva variável. Se a entrada estiver incorreta ou vazia, aparece uma mensagem de erro na consola. Na programação, foi tomado um cuidado especial para que as casas decimais possam ser introduzidas através de pontos e vírgulas, a fim de minimizar o risco de erros.
Ligação ao RFEM/RSTAB
O seguinte código tenta estabelecer uma ligação com o RFEM/RSTAB dentro de um bloco try-catch:
var registrador = LogManager.GetCurrentClassLogger();
stringDiretórioAtual = Diretório.GetDiretórioAtual();
try
{
informação_aplicaçãoInformação_aplicação;
try
{
//liga à aplicação RFEM6 ou RSTAB9
aplicação = new ClienteAplicação(Ligação, Endereço);
}
catch (exceção, exceção)
{
if (aplicação != zero)
{
if (application.State != CommunicationState.Faulted)
{
aplicação.Fechar();
logger.Error(exception, "Aconteceu algo:" + exception.Message);
}
else
{
aplicação.Anular();
logger.Error(exceção, "Falha na comunicação com o RFEM:" + exceção.Mensagem);
}
}
Console.WriteLine(exceção.ToString());
}
finally
{
InformaçãoAplicação = informação_aplicação();
logger.Info("Nome: {0}, Versão:{1}, Tipo: {2}, idioma: {3} ", InformaçãoAplicativo.nome, InformaçãoAplicativo.versão, Tipo.InfoAplicativo, InformaçãoAplicativo.nome_idioma);
Console.WriteLine("Nome: {0}, Versão:{1}, Tipo: {2}, idioma: {3} ", InformaçãoAplicativo.nome, InformaçãoAplicativo.versão, Tipo.InfoAplicativo, InformaçãoAplicativo.nome_idioma);
}
}
string modelName = "MeuModelodeTeste";
string modelUrl ="";
ModelClient modelo = new ModelClient(Binding, new EndpointAddress(modelUrl));
Para configurar uma ligação, o programa tem de estar aberto antes de executar o código. Após uma ligação bem-sucedida, a informação do programa é apresentada na consola e é criado um novo modelo com um nome definido pelo utilizador no RFEM/RSTAB.
Definição de objetos básicos
No passo seguinte, pode definir o material e a secção da viga contínua. É importante que a descrição corresponde ao nome guardado na biblioteca de materiais ou secções do RFEM.
material materialConcrete = novo material
{
não = 1,
nome = "C20/25 | EN 1992-1-1:2004/A1:2014"
};
secção secçãoRetângulo = nova secção
{
não = 1,
material = materialConcrete.no,
materialEspecificado = verdadeiro,
tipo = tipo_de_secção.TYPE_PARAMETRIC_MASSIVE_I,
tipoEspecificado = verdadeiro,
tipo_de_parametrização = tipo_de_parametrização_parametrização.PARAMETRIC_MASSIVE_I__MASSIVE_RECTANGLE__R_M1,
tipo_de_parametrizaçãoEspecificado = verdadeiro,
nome = "R_M1 0,5/1,0"
};
Com a ajuda de malhas, vários objetos (nós, linhas, barras) são criados e organizados em listas. Os nós são definidos em função do número de vãos definido pelo utilizador e transferidos para a lista "lineDefinitionNodes". A lista será utilizada posteriormente para criar as linhas com base nos seus nós de definição. Ao criar um modelo do RSTAB, a lista é utilizada para definir as barras com base nos nós de definição. Ao utilizar o RFEM, as barras são definidas através de linhas.
SortedList nós = new SortedList();
int[] lineDefinitionNodes = new int[spanNumber + 1];
int IDdeNó = 1;
vector x duplo = 0,0;
for (int i = 0; i < númerospan + 1; i++)
{
nó novoNó = novo()
{
não = nodeId,
coordenadas = new vector_3d() { x = xVector, y = 0,0, z = 0,0 },
tipo_do_sistema_de coordenadas = nó tipo_de_coordenadas_de_coordenadas.COORDINATE_SYSTEM_CARTESIAN,
sistema_de coordenadasEspecificado = verdadeiro,
comment = "peça de betão"
};
nós.Add(Id nó, novoNó);
lineDefinitionNodes[i] = nodeId;
xVector = xVector + vão;
ID de nó++;
}
//cria as linhas
int linhaId = 1;
SortedList linhas = new SortedList();
for (int i = 0; i < spanNumber; i++)
{
linha novaLinha = novo()
{
não = linhaId,
definition_nodes = new int[] { lineDefinitionNodes[i], lineDefinitionNodes[i + 1] },
comentário = "linhas para vigas",
tipo = tipo_de_linha.TYPE_POLYLINE,
tipoEspecificado = verdadeiro,
};
linhas.Adicionar(IDdelinha, novaLinha);
linhaId++;
}
Após a criação de todos os objetos base, são definidos dois apoios de nó diferentes. O apoio de nó no primeiro nó deve ser fixo, os apoios restantes devem ser dimensionados como rolos na direção X. Os nós de definição para os diferentes tipos de apoios são resumidos numa lista separada.
apoio_nodal apoio1 = novo()
{
não = 1,
nós =supportedNodes1.ToArray(),
mola = new vector_3d() { x = duplo.InfinitoPositivo, y = duplo.InfinitoPositivo, z = duplo.InfinitoPositivo },
Rotational_restraint = new vector_3d() { x = double.PositiveInfinity, y = 0,0, z = duplo.PositiveInfinity }
};
apoio_nodal apoio2 = novo()
{
não = 2,
nós =supportedNodes2.ToArray(),
mola = new vector_3d() { x = 0,0, y = duplo.InfinitoPositivo, z = duplo.InfinitoPositivo },
Rotational_restraint = new vector_3d() { x = 0,0, y = 0,0, z = double.PositiveInfinity }
};
nodalApoios.Adicionar(apoio1);
nodalApoios.Adicionar(apoio2);
Transferência de objetos para o RFEM
Para disponibilizar os objetos criados no RFEM/RSTAB, eles devem primeiro ser transferidos para o programa. Isto é feito entre duas funções, ou seja, "model.begin_modification" e "model.end_modification", através de funções específicas de objeto da biblioteca HLF. Os ciclos foreach são utilizados para passar todos os objetos de um tipo para o programa.
try
{
model.begin_modification("Geometria");
model.set_material(materialConcrete);
model.set_secção(secçãoRetângulo);
foreach (KeyValuePair nodeItem em nós)
{
model.set_node(item.Value);
}
foreach (KeyValuePair linhaItem em linhas)
{
model.set_line(Item.Value);
}
foreach (KeyValuePair membroItem em membros)
{
model.set_member(item.Value);
}
foreach (var nodalSupport in nodalSupports)
{
model.set_nodal_support(nodalSupport);
}
}
catch (exceção, exceção)
{
modelo.modificação_cancelar();
logger.Error(exception, "Ocorreu algo durante a criação da geometria" + exception.Message);
arremesso;
}
finally
{
try
{
modelo.modificação_de_acabamento();
}
catch (exceção, exceção)
{
logger.Error(exception, "Algo deu errado ao concluir a modificação da geometria\n" + exceção.Mensagem + "\n");
modelo.redefinir();
}
}
Definição de cargas
Os casos de carga, as combinações de carga e as situações de dimensionamento são criados de forma semelhante aos objectos básicos e depois transferidos para o programa.
Depois, a carga de barra que foi especificada anteriormente pelo utilizador pode ser criada:
SortedList cargas_membro = newListaordenada();
int ID_carga_membro = 1;
for (int i = 0; i < spanNumber; i++)
{
carga_membro novaCargaMembra = novo()
{
não = i + 1,
string_membros = (i + 1).ToString(),
barras = new int[] { i + 1 },
distribuição_carga = distribuição_carga_membro.LOAD_DISTRIBUTION_UNIFORM,
load_distributionSpecified = verdadeiro,
magnitude = barraCarga * 1000,
magnitudeEspecificada = verdadeiro,
load_is_over_total_comprimento = verdadeiro,
load_is_over_total_lengthSpecified = verdadeiro,
};
cargas_membro.Add(i + 1, novaCargaMembra);
id_carga_membro++;
}
Além de cargas uniformemente distribuídas, também são possíveis cargas trapezoidais e parabólicas.
Cálculo e saída de resultados
Através da função model.calculate(all), todos os cálculos são executados no RFEM.
Após o cálculo bem-sucedido, os resultados neste exemplo são exibidos na consola. A biblioteca HLF para C#também permite a exportação dos resultados em ficheiros XML ou CSV.
Por fim, a função model.save() pode ser utilizada para guardar o modelo no caminho de ficheiro indicado entre parênteses:
//guarda o modelo antes de fechar
model.save(DiretórioAtual +@"\testmodels\");
aplicação.close_model(0, verdadeiro);
Resumo
No exemplo apresentado, ficam claras as vantagens e a facilidade de manuseamento da biblioteca C#. A estrutura pode ser adaptada rapidamente através de entradas definidas pelo utilizador, o que poupa muito tempo ao introduzir os sistemas estruturais no RFEM 6 e RSTAB 9. A biblioteca HLF para C#também oferece muitas outras funções, permitindo a criação de sistemas complexos.
![[EN] FAQ 005511 | O que faz cada opção na secção "Cálculo da torção" no menu Resistência...](http://img.youtube.com/vi/5kTWIVwP61A/maxresdefault.jpg)
.png?mw=600&hash=49b6a289915d28aa461360f7308b092631b1446e)
