Les bases du service web et de l'API avec l'exemple du VBA
Pour le formatage de la chaîne, le format XML est utilisé selon les spécifications du protocole SOAP. Voici un exemple avec la requête suivante :
<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/">
<Body>
<get_active_model xmlns="http://www.dlubal.com/rfem.xsd"/>
</Body>
</Envelope>
Un élément typique du formatage XML est le début d'une section avec le caractère « < ». Il est suivi d'un identificateur et, s'il n'y a pas d'autres éléments subordonnés, la section se termine par « /> ». Voici un exemple à la troisième ligne :
<get_active_model xmlns="http://www.dlubal.com/rfem.xsd"/>
S'il y a des sous-éléments, ils commencent par « < », la commande et « > » puis se terminent par « </ », la commande et « > ». L'exemple approprié est la section « Corps » :
<Body>
<get_active_model xmlns="http://www.dlubal.com/rfem.xsd"/>
</Body>
Le formatage avec des espaces et des sauts de ligne est ici uniquement utilisé à des fins d'illustration. Cette opération n'est pas requise pour le transfert. Les éléments « Body » et « Envelope » sont des éléments standards pour le transfert et sont utilisés pour chaque commande.
Toutes les commandes disponibles peuvent être lues à l'aide de l'interface WSDL. Il existe plusieurs logiciels qui permettent de créer des listes. SoapUI est un exemple de ce type de logiciel. Il existe deux listes pour l'API de RFEM 6 : les commandes pour l'application et celles pour le modèle. Ces deux listes peuvent être téléchargées à la fin de cet article.
Les commandes étant envoyées via HTTP, les adresses URL sont requises pour l'adressage. L'adresse par défaut des applications RSTAB/RFEM est « http://localhost:8081/ » et peut être modifiée dans les paramètres du logiciel. Les adresses des modèles ouverts sont attribuées dans l'ordre croissant de sorte que le premier modèle ouvert possède l'adresse « http://localhost:8082/ ». Pour obtenir l'adresse du modèle actif, la commande « get_active_model » est envoyée. La réponse correspondante de RFEM 6 ressemble à ceci :
<?xml version="1.0"?>
<Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:soap-enc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<soap:Body>
<n1:get_active_modelResponse
xmlns:n1="http://www.dlubal.com/rfem.xsd">
<value>
http://127.0.0.1:8082/
</value>
</n1:get_active_modelResponse>
</soap:Body>
</soap:Envelope>
Les détails supplémentaires de la section « Enveloppe » ainsi que la ligne précédente "<?xml version="1.0"?>" doivent en premier lieu servir d'exemples de normes utilisées et ne seront pas abordées plus amplement ici. Dans tous les cas, les éléments "Envelope" et "Body" sont à nouveau utilisés. La réponse de RFEM 6 est disponible dans « Body » avec le nom de la commande « get_active_model » et le mot « Response » accolé. Le contenu de cette réponse est une valeur ("value"), c'est-à-dire l'adresse du modèle actif. De plus, RFEM est désormais verrouillé pour un accès ultérieur.
Dans l'exemple suivant, nous voulons créer une barre avec deux appuis nodaux et une charge. Pour pouvoir communiquer avec RFEM via VBA, les objets suivants sont requis :
request As MSXML2.XMLHTTP60
response As MSXML2.DOMDocument
L'objet XMLHTTP60 a une fonction intégrée pour envoyer une requête HTTP à une URL et est donc utilisée pour la requête. La réponse peut ensuite être évaluée à l'aide du DOMDocument. L'exemple suivant combine la requête « get_active_model » précédemment affichée avec les commandes utilisées sous VBA :
' get active model url with "get_active_model" command
str_envelope =
"<Envelope xmlns=""http://schemas.xmlsoap.org/soap/envelope/"">" & _
" <Body>" & _
" <get_active_model xmlns=""http://www.dlubal.com/rfem.xsd""/>" & _
" </Body>" & _
"</Envelope>"
' open request and send it
request.Open "Post", "http://localhost:8081/", False
request.Send (str_envelope)
' get response and transform it to an xml-object
response.LoadXML (request.responseText)
La requête est d'abord enregistrée au format XML dans la variable « str_envelope » et la requête est ouverte dans RFEM à l'aide de la méthode « Open » de la variable « request ». Le contenu de la variable « str_envelope » peut maintenant être envoyé à l'aide de la méthode « Send ». La réponse est alors accessible à l'aide de la méthode "ResponseText". Dans ce cas précis, celui-ci est importé directement via la méthode « LoadXML » de la variable « response ».
La variable « response » de type DOMDocuments a la méthode LoadXML et peut donc reconnaître le formatage XML. L'avantage est que le type DOMDocuments fournit également la méthode GetElementsByTagName. Cela vous permet d'extraire des éléments directement du code. Dans ce qui suit, le code précédent est étendu afin que l'adresse URL du modèle soit disponible :
' get http-status
status = request.status
If status <> "200" Then
MsgBox "get_active_model: Échec de l'envoi - " & response.Text
Exit Sub
End If
url_model = response.GetElementsByTagName("value")(0).Text
Le statut de la réponse peut être vérifié avant la lecture de l'URL. Il s'agit de codes de statut HTTP normalisés. Le statut « 200 » signifie que le transfert était « OK ». Après cette requête, l'URL du modèle est enregistrée dans la chaîne url_model. Pour ce faire, l'élément « value » est recherché dans la réponse XML. Si une réponse contient plusieurs éléments, toutes les valeurs sont enregistrées dans la section « value », de sorte qu'aucune évaluation avec l'identifiant « value » n'est possible, mais les sous-éléments de « value » sont traités. L'exemple pratique sera plus parlant. Dans le cas de l'adresse de modèle, la seule valeur renvoyée est l'URL, donc « value » est valide ici.
Exemple pratique en VBA
Maintenant que nous connaissons tous les éléments de base, voici un exemple simple. Nous voulons créer une poutre sur deux poteaux, sur laquelle une charge de barre peut être appliquée.
Les variables décrites ci-dessus sont d'abord définies et initialisées :
' define variables
Dim request As MSXML2.XMLHTTP60
Dim response As MSXML2.DOMDocument60
Dim str_envelope As String
Dim url_app As String
Dim url_model As String
' init variables
Set request = New MSXML2.XMLHTTP60
Set response = New MSXML2.DOMDocument60
With response
.async = False
.preserveWhiteSpace = False
.validateOnParse = False
.resolveExternals = False
' Use full XPath functionality
.SetProperty "SelectionLanguage", "XPath"
' Add specific Namespaces to work with Paths
.SetProperty "SelectionNamespaces", "xmlns:soap=""http://www.w3.org/2003/05/soap-envelope"" " & _
"xmlns:xsd=""http://www.dlubal.com/rfem.xsd"" " & _
"xmlns:n1=""urn:schemas-microsoft-com:rowset"" " & _
"xmlns=""http://www.dlubal.com/rfem.xsd"" "
End With
url_app = "http://localhost:8081/"
Outre les variables « request » et « response », la chaîne « str_envelope » est créée pour la requête et « url_app » et « url_model » pour les adresses de l'application et du modèle. Lors de l'initialisation, les spécifications connues du protocole SOAP peuvent être transférées pour évaluer le formatage XML de la réponse. L'adresse du modèle sera prise ultérieurement, mais l'adresse de l'application doit être précisée. Comme déjà mentionné, l'adresse par défaut « http://localhost:8081/» doit être entrée.
L'étape suivante consiste à tester la connexion à l'application. Pour ce test, les informations standard de l'application sont interrogées à l'aide de la commande « get_information » :
' check application url with command "get_information"
str_envelope = "<Envelope xmlns=""http://schemas.xmlsoap.org/soap/envelope/"">" & _
" <Corps>" & _
" <get_information xmlns=""http://www.dlubal.com/rfem.xsd""/>" & _
" </Body>" & _
"</Envelope>"
' open request and send it
request.Open "Post", url_app, False
request.Send (str_envelope)
' get response and transform it to an xml-object
response.LoadXML (request.responseText)
' get http-status
status = request.Status
If status <> "200" Then
MsgBox "get_information: Sending not successful - " & response.Text
Exit Sub
End If
' read application information
Dim str1 As String
str1 = ""
str1 = str1 & response.GetElementsByTagName("name")(0).Text & vbLf
str1 = str1 & response.GetElementsByTagName("type")(0).Text & vbLf
str1 = str1 & response.GetElementsByTagName("version")(0).Text & vbLf
str1 = str1 & response.GetElementsByTagName("language_name")(0).Text & vbLf
str1 = str1 & response.GetElementsByTagName("language_id")(0).Text
MsgBox str1, vbInformation, "Response to ""get_information"" request"
Comme décrit dans la première partie, la requête au format XML est préparée et enregistrée dans « str_envelope ». « request.Open » ouvre la connexion à l'application. Le mot-clé « Post » correspond à l'envoi de la demande. Le troisième paramètre est défini sur « true » et une transmission synchrone est ainsi effectuée. Enfin, « request.Send » envoie la chaîne préparée.
Après le transfert, la réponse est enregistrée dans « response » et vérifiée avec « request.Status » pour déterminer si la requête a abouti. Le statut est donné par RFEM de sorte à ce qu'une erreur soit renvoyée si la requête est incorrecte, comme dans le cas d'une commande inconnue, par exemple. Si le statut n'est pas « 200 », le programme est abandonné et l'erreur est affichée dans une fenêtre (MsgBox).
Si aucune erreur ne s'est produite, les différentes informations transférées peuvent maintenant être lues à l'aide de « GetElementsByTagName ». Dans cet exemple, les informations sont ensuite affichées dans une fenêtre.
Les éléments suivants étant très similaires, seules les fonctionnalités spéciales sont décrites (le code source complet peut être téléchargé). Pour paramétrer une poutre sur deux poteaux avec une charge de barre, les fonctions suivantes sont requises :
- Nœud - set_node
- Ligne - set_line
- Matériau - set_material
- Section - set_section
- Barre - set_member
- Appui nodal - set_nodal_support
- Paramètres de calcul - set_static_analysis_settings
- Cas de charge - set_load_case
- Charge de barre - set_member_load
Comme la plupart des autres, la fonction « set_node » a de nombreux paramètres, mais ils ne sont généralement pas requis. Dans la liste de commandes déjà mentionnée du modèle RFEM, vous pouvez voir la variété de paramètres. Les paramètres qui ne sont pas marqués comme « facultatifs » sont avant tout importants, car ils doivent être renseignés dans chaque cas. Dans l'exemple, les paramètres suivants sont transférés :
begin_modification (url_model)
' set node 1 on [0,0,0] with "set_node" command
str_envelope =
"<Envelope xmlns=""http://schemas.xmlsoap.org/soap/envelope/"">" & _
"<Body>" & _
"<set_node xmlns=""http://www.dlubal.com/rfem.xsd"">" & _
"<value xmlns="""">" & _
"<no>1</no>" & _
"<type>TYPE_STANDARD</type>" & _
"<coordinate_1>0</coordinate_1>" & _
"<coordinate_2>0</coordinate_2>" & _
"<coordinate_3>0</coordinate_3>" & _
"</value>" & _
"</set_node>" & _
"</Body>" & _
"</Envelope>"
Seul le numéro de nœud est requis, le reste peut être assigné, mais pas obligatoirement. Outre les paramètres possibles, la liste des commandes affiche également des listes de types. Dans ce cas précis, cinq types différents sont actuellement possibles. Le type par défaut « TYPE_STANDARD » a été sélectionné. Le premier nœud affiché ici est créé à l'emplacement (0;0;0), le deuxième nœud à (5,5;0;0). Les valeurs des nombres décimaux sont les suivantes :
...
"<value xmlns="""">" & _
"<no>2</no>" & _
"<type>TYPE_STANDARD</type>" & _
"<coordinate_1>5.5</coordinate_1>" & _
"<coordinate_2>0</coordinate_2>" & _
"<coordinate_3>0</coordinate_3>" & _
"</valeur>" & _
...
Les listes constituent une autre fonctionnalité. La ligne a besoin de deux nœuds dont les numéros peuvent être transférés sous forme de liste. Les éléments d'une liste, tels que « definition_nodes », sont séparés par des espaces :
...
"<set_line xmlns=""http://www.dlubal.com/rfem.xsd"">" & _
"<value xmlns="""">" & _
"<no>1</no>" & _
"<type>TYPE_POLYLINE</type>" & _
"<definition_nodes>1 2</definition_nodes>" & _
"</value>" & _
"</set_line>" & _
...
Pour pouvoir créer la barre, une section doit être créée, ce qui nécessite un matériau. Les sections et les matériaux peuvent être utilisés à partir de la base de données interne. Il suffit donc d'indiquer un identifiant connu. L'identifiant du matériau est « S235 » et la section porte le nom « IPE 300 » :
...
"<set_section xmlns=""http://www.dlubal.com/rfem.xsd"">" & _
"<value xmlns="""">" & _
"<no>1</no>" & _
"<material>1</material>" & _
"<type>TYPE_STANDARDIZED_STEEL</type>" & _
"<name>IPE 300</name>" & _
"</value>" & _
"</set_section>" & _
...
Pour vérifier si un nom tel que « IPE 300 » est valide, vous pouvez utiliser l'entrée dans l'interface graphique.
Aucune connaissance supplémentaire n'est requise pour entrer la barre elle-même, mais pour entrer un appui fixe, vous devez définir une rigidité de ressort « infinie ». Le mot-clé « INF » est utilisé pour le transfert :
...
"<set_nodal_support xmlns=""http://www.dlubal.com/rfem.xsd"">" & _
"<value xmlns="""">" & _
"<no>1</no>" & _
"<nodes>1</nodes>" & _
"<spring_x>INF</spring_x>" & _
"<spring_y>INF</spring_y>" & _
"<spring_z>INF</spring_z>" & _
"<rotational_restraint_x>INF</rotational_restraint_x>" & _
"<rotational_restraint_y>0</rotational_restraint_y>" & _
"<rotational_restraint_z>INF</rotational_restraint_z>" & _
"</value>" & _
"</set_nodal_support>" & _
...
La création du cas de charge et des paramètres de calcul ne nécessite aucune connaissance supplémentaire. La dernière particularité est une valeur supplémentaire lors de la création de la charge, car elle doit être spécifiée en dehors de la zone « <value> ». Dans le cas d'une charge de barre, le cas de charge correspondant doit y être transféré :
...
"<set_member_load xmlns=""http://www.dlubal.com/rfem.xsd"">" & _
"<load_case_no xmlns="""">1</load_case_no>" & _
"<value xmlns="""">" & _
"<no>1</no>" & _
"<load_type>LOAD_TYPE_FORCE</load_type>" & _
"<members>1</members>" & _
"<load_distribution>LOAD_DISTRIBUTION_UNIFORM</load_distribution>" & _
"<load_direction>LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE</load_direction>" & _
"<magnitude>1000</magnitude>" & _
"</value>" & _
"</set_member_load>" & _
...
De plus, il doit être indiqué que l'ordre des éléments dans la zone « value » n'est pas important, mais qu'en dehors il l'est. Le cas de charge spécifié doit alors venir avant la zone « value ».
Outre les fonctions précédentes de création et d'exportation de données, deux fonctions spéciales sont présentées ici. Si des éléments sont transférés dans le programme, le programme passe automatiquement en mode « Modification ». Le programme contrôle les nouveaux éléments et les intègre. Si plusieurs nouveaux éléments doivent être créés, il est alors utile de laisser le programme dans ce mode de paramétrage pour ce cas précis, de sorte à ce que le processus soit plus rapide. Les fonctions « begin_modification » et « finish_modification » sont disponibles pour cela. Dans l'exemple, « begin_modification » est appelé avant la création du premier nœud et « finish_modification » est appelé à la fin après la création du cas de charge. Ces deux fonctions ont également été créées en tant que fonctions VBA dans le programme. Les fonctions sont indépendantes et les variables « request » et « response » sont alors à nouveau créées dans les fonctions. Aucun nouvel élément n'est cependant requis pour cette opération et ne sera pas décrit davantage ici. Il est intéressant de comparer avec et sans l'usage de ces fonctions, ce qui entraînera toujours une différence de rapidité.
Résumé
Le service web et l'API sont des outils puissants pour RFEM et RSTAB. Le transfert simple basé sur HTTP permet à l'interface d'être implémentée dans de nombreux langages de programmation, pas seulement en VBA comme indiqué ici, et la programmation multiplateforme devient possible.
.png?mw=350&hash=b2324c4db119938012b5490afaa56e9aa826cdcc)
