API II

O que é uma API?

Uma API (Interface de Programação de Aplicações) é uma interface através da qual diferentes aplicações de software podem comunicar entre si. Uma API define regras sobre como as informações são trocadas entre os programas.

Com as API II, é possível aceder às funções do RFEM 6 / RSTAB 9 usando software programado por você mesmo. Por exemplo, é possível gerar modelos, criar cargas, iniciar o cálculo e, finalmente, ler os resultados.

No RFEM 6 / RSTAB 9 já existe uma API, a interface Webservice (API I). Esta permanecerá. Portanto, não é estritamente necessário migrar o software já criado para a API II.

Se novas funcionalidades são adicionadas ao RFEM 6 / RSTAB 9, elas estarão disponíveis apenas na API II. A API I ficará "congelada" no estado atual.

Quais são as diferenças técnicas em relação à "antiga" API?

Primeiro de tudo, ambas as interfaces são baseadas na tecnologia Webservice. O RFEM 6 / RSTAB 9, portanto, comunica com o software do cliente através do protocolo HTTP (ou HTTPS).

Na API I, o cliente e o servidor trocam mensagens no formato SOAP. Em contraste, a API II utiliza o protocolo gRPC.

Com SOAP, as mensagens são trocadas em formato XML. A comunicação usando SOAP tem um overhead relativamente elevado .

Por outro lado, no gRPC, as mensagens são trocadas num formato binário leve baseado em buffers. Isso é muito mais eficiente do que formatos baseados em texto, como XML ou JSON.

No gRPC, é utilizado o novo protocolo HTTP/2, o que também torna a transmissão mais eficiente.

Na nova API II, é possível que vários objetos sejam agrupados numa lista e depois transferidos. Assim, não são mais necessárias muitas pequenas chamadas de API, mas apenas algumas. Isso também aumenta a eficiência. No exemplo abaixo, é demonstrado como essa técnica de grupos funciona.

Todas essas medidas para aumentar a eficiência fazem com que a comunicação através da nova API II seja cerca de 10 vezes mais rápida do que através da API I.

A API II possibilita que o mesmo código seja executado em três diferentes plataformas sem alterações.

1. Como um programa Python independente, que acede ao RFEM 6 instalado localmente ou na rede.
2. Na consola de script interna do RFEM 6.
3. Na nuvem da Dlubal.

Programa independente

O RFEM normal é instalado no computador do utilizador. Seu programa Python comunica com o RFEM através da API II.

Consola de script

O seu script é executado diretamente na consola de script do RFEM.

Nuvem da Dlubal

Para este caso de utilização, não é necessário ter o RFEM instalado localmente. O utilizador programa a sua aplicação que comunica com um servidor na nuvem da Dlubal. O seu programa de aplicação gera dados de estrutura e carga no servidor. O cálculo é realizado no servidor. A sua aplicação lê os resultados do cálculo e avalia-os.

O que muda na faturação?

Para o uso da antiga API I, era cobrada uma taxa mensal de uso. Esta era independente do uso real.

Com a nova API II, isso muda para um modelo de cobrança baseado na utilização. Isso significa que a chamada de algumas funções específicas da API é cobrada. A cobrança é feita em Créditos Dlubal. Estes podem ser adquiridos na loja online.

Gerar chave de API

Para usar a API II, além da assinatura do Webservice, é necessária uma chave de API. Uma chave de API é um pedaço de texto que serve para identificação e autenticação.

Os utilizadores podem gerar as chaves de API na extranet.

Cada chave de API gerada é atribuída à empresa. Isso significa que qualquer utilizador atribuído à empresa pode usar as chaves.

É possível, e muitas vezes também sensato, gerar várias chaves de API. Isso não acarreta custos adicionais. É sensato, por exemplo, gerar uma chave separada para cada projeto. Isso permite que o utilizador distinga entre projetos individuais na sua faturação interna.

Instalação da interface

O pacote para a interface está disponível via PiPI. Execute o seguinte comando para instalar o pacote:

pip install dlubal.api

Exemplo de programa

Um pequeno exemplo demonstra o uso da nova API II. É criada uma viga em consola constituída por uma secção IPE 200.

Aqui está o código do programa:

import dlubal.api.rfem as rfem

with rfem.Application() as rfem_app:

    rfem_app.create_model(name='cantilever')
    rfem_app.delete_all_objects()

    inf = float('inf')

    structure = [
        rfem.structure_core.Material(
            no=1,
            name='S235'
        ),
        rfem.structure_core.Section(
            no=1,
            name='IPE 200',
            material=1
        ),
        rfem.structure_core.Node(
            no=1
        ),
        rfem.structure_core.Node(
            no=2,
            coordinate_1=6.0
        ),
        rfem.structure_core.Line(
            no=1,
            definition_nodes=[1,2]
        ),
        rfem.structure_core.Member(
            no=1,
            line=1,
            section_start=1
        ),
        rfem.types_for_nodes.NodalSupport(
            no=1,
            nodes=[1],
            spring_x=inf,
            spring_y=inf,
            spring_z=inf,
            rotational_restraint_x=inf,
            rotational_restraint_y=inf,
            rotational_restraint_z=inf
        ),
    ]

    rfem_app.create_object_list(structure)

Primeiro, a biblioteca do RFEM é importada.

Com o comando with, a instância rfem_app dessa classe é criada. Como argumento de rfem.Application(), a chave de API pode ser passada. Por razões de segurança, isso não é recomendado. Em vez disso, a chave de API deve ser armazenada num ficheiro config.ini. Como isso funciona exatamente é explicado na documentação detalhada da API II:

• Documentação da API II

Na próxima linha, um novo modelo RFEM é criado com o método rfem_app.create_model(name='cantilever'). O nome do modelo pode ser passado como parâmetro.

Nas próximas linhas de código, a nova API II diferencia-se fundamentalmente da "antiga" abordagem na API I. Na lista structure, os elementos estruturais são inicialmente definidos. Eles são então transferidos em conjunto com o comando rfem_app.create_object_list(structure).