3 Définition d'un schéma de calcul au format XML
4 =================================================
5 Un fichier XML qui décrit un schéma de calcul peut contenir les informations suivantes:
7 * des définitions de types de données
8 * des définitions de containers
9 * des définitions de noeuds de calcul élémentaires
10 * des définitions de noeuds composés
11 * des définitions de connexions entre noeuds
14 La présentation de ces définitions sera faite progressivement. On commence
15 dans un premier temps par :
17 - la définition des types de données
18 - la définition d'un sous ensemble de noeuds élémentaires
19 - la définition des connexions non datastream
20 - la définition des noeuds composés
22 Dans un deuxième temps, on ajoute des compléments sur :
24 - la définition des containers
25 - la définition des propriétés de noeuds
26 - la définition des connexions datastream
27 - la définition du reste des noeuds élémentaires
29 Un schéma de calcul est défini en utilisant le tag XML proc.
30 Le schéma de calcul le plus simple est le suivant::
35 Il ne contient aucune définition et ne fait rien.
37 Définition des types de données
38 ---------------------------------
39 Il n'est pas possible de définir de types de base autres que ceux existants.
40 Tous les types de base sont prédéfinis par YACS.
41 Il est cependant possible de définir des alias. Par exemple, un alias pour
42 le type double s'écrira::
44 <type name="mydble" kind="double"/>
46 On peut ensuite utiliser mydble à la place de double.
51 La forme la plus simple pour définir un type référence d'objet est::
55 L'attribut name du tag objref donne le nom du nouveau type.
56 La forme complète pour définir ce type serait::
58 <objref name="mesh" id="IDL:mesh:1.0/>
60 où id est le repository id CORBA de l'objet SALOME correspondant. Cet attribut
61 a une valeur par défaut qui est IDL:<nom du type>:1.0.
63 Pour définir un type référence d'objet dérivé d'un autre type, il suffit
64 d'ajouter le nom du ou des types de base.
65 Par exemple, pour un type dérivé de mesh, on écrira::
67 <objref name="refinedmesh">
71 Si on a plusieurs types de base, on écrira::
73 <objref name="refinedmesh">
75 <base>unautretype</base>
78 On peut, comme pour CORBA, utiliser des namespaces pour définir les types.
79 Par exemple, si le type mesh SALOME est défini dans le namespace myns, on écrira::
81 <objref name="myns/mesh"/>
85 Pour définir une séquence de double, on écrira::
87 <sequence name="myseqdble" content="double"/>
89 Tous les attributs du tag sequence sont obligatoires. L'attribut name
90 donne le nom du nouveau type. L'attribut content donne le nom du type
91 des éléments de la séquence.
92 On peut définir une séquence de séquence par::
94 <sequence name="myseqseqdble" content="myseqdble"/>
96 On peut également définir une séquence de références d'objet par::
98 <sequence name="myseqmesh" content="refinedmesh"/>
102 Pour définir une structure, on utilise un tag struct avec des sous tags member
103 pour la définition des membre de la structure.
104 Voici un exemple de définition::
107 <member name="x" type="double"/>
108 <member name="y" type="int"/>
109 <member name="s" type="string"/>
110 <member name="b" type="bool"/>
111 <member name="vd" type="dblevec"/>
114 Le tag member a 2 attributs obligatoires : name qui donne le nom du membre
115 et type qui donne son type. Le tag struct a un attribut obligatoire name
116 qui donne le nom du type.
118 Définition des noeuds de calcul élémentaires
119 -----------------------------------------------
121 '''''''''''''''''''''
122 Pour définir un noeud inline script Python on utilise le tag inline avec le sous tag
123 script comme dans l'exemple suivant::
125 <inline name="node1" >
129 <outport name="p1" type="int"/>
132 L'attribut name (obligatoire) du tag inline est le nom du noeud.
133 Le script Python est donné au moyen du sous tag code. On met autant de lignes code
134 que nécessaire. Si le script contient des caractères inhabituels on peut utiliser
135 une section CDATA. Ceci permet également de n'utiliser qu'un tag code pour un script complet.
146 Le script calcule la variable p1 que l'on veut mettre en variable de sortie du noeud.
147 Le port de sortie "p1" du noeud est défini avec le sous tag outport. Ce tag a 2 attributs
148 obligatoires : name qui donne le nom du port et type qui donne le type de données
149 supporté. Ce type doit être déjà défini.
150 Pour ajouter un port de données d'entrée, on utilisera le tag inport à la place
153 Un exemple de noeud avec des ports d'entrée et de sortie::
155 <inline name="node1" >
157 <code>p1=p1+10</code>
159 <inport name="p1" type="int"/>
160 <outport name="p1" type="int"/>
163 Maintenant le noeud reçoit p1 comme variable d'entrée, lui ajoute 10 et l'exporte
164 comme variable de sortie.
166 Noeud fonction Python
167 ''''''''''''''''''''''''
168 Pour définir un noeud fonction Python on utilise le tag inline et le sous tag function
169 comme dans l'exemple suivant::
171 <inline name="node1" >
173 <code>def f(p1):</code>
174 <code> p1=p1+10</code>
175 <code> return p1</code>
177 <inport name="p1" type="int"/>
178 <outport name="p1" type="int"/>
181 L'attribut name (obligatoire) du tag inline est le nom du noeud.
182 Par rapport au noeud script Python seule la partie exécution change (tag function
183 à la place du tag script).
184 Le tag function a un attribut obligatoire name qui donne le nom de la fonction à
185 exécuter. Le corps de la fonction est donné avec les tags code comme pour le script.
187 Noeud de service SALOME
188 ''''''''''''''''''''''''''
189 Comme il est dit dans :ref:`principes`, on a deux façons de décrire un noeud
192 La première forme de définition utilise le tag service et les sous tags component
193 et method comme dans l'exemple suivant::
195 <service name="node4" >
196 <component>AddComponent</component>
198 <inport name="x" type="double"/>
199 <inport name="y" type="double"/>
200 <outport name="FuncValue" type="double"/>
201 <outport name="z" type="double"/>
204 L'attribut obligatoire name du tag service donne le nom du noeud.
205 Le tag component donne le nom du composant SALOME à utiliser et method
206 le nom du service à exécuter. Ici on veut exécuter le service Add du
207 composant AddComponent que l'on trouve dans les composants exemples
210 La deuxième forme de définition utilise le tag service et les sous tags node
211 et method comme dans l'exemple suivant::
213 <service name="node5" >
215 <method>Setx</method>
216 <inport name="x" type="double"/>
219 Le tag node référence le noeud node4 précédemment défini de façon à utiliser
220 la même instance de composant pour noeud4 et noeud5.
222 Définition des connexions
223 -----------------------------
224 Dans tout ce qui suit concernant les connexions et les initialisations de port,
225 on est amené à identifier un noeud origine et/ou un noeud cible. Dans tous
226 les cas, le nom qui sera utilisé est le nom relatif du noeud par rapport
227 au contexte de définition de la connexion.
231 Un lien de contrôle est défini en utilisant le tag control comme dans l'exemple
235 <fromnode>node1</fromnode>
236 <tonode>node2</tonode>
239 Le sous tag fromnode donne le nom du noeud qui sera exécuté avant le noeud
240 dont le nom est donné par le sous tag tonode.
244 Un lien dataflow est défini en utilisant le tag datalink comme dans l'exemple
248 <fromnode>node1</fromnode> <fromport>p1</fromport>
249 <tonode>node2</tonode> <toport>p1</toport>
252 Les sous tags fromnode et fromport donne le nom du noeud et du port de données
253 sortant qui sera connecté au noeud et au port dont les noms sont donnés pat les
254 sous tags tonode et toport.
255 L'exemple de lien ci-dessus dit que la variable de sortie p1 du noeud node1
256 sera envoyé au noeud node2 et utilisée comme variable d'entrée p1.
260 Un lien data est défini en utilisant le même tag datalink mais en ajoutant
261 l'attribut control avec false comme valeur. Exemple::
263 <datalink control="false">
264 <fromnode>node1</fromnode> <fromport>p1</fromport>
265 <tonode>node2</tonode> <toport>p1</toport>
268 Le lien dataflow ci-dessus peut donc être aussi écrit comme suit::
271 <fromnode>node1</fromnode>
272 <tonode>node2</tonode>
274 <datalink control="false">
275 <fromnode>node1</fromnode> <fromport>p1</fromport>
276 <tonode>node2</tonode> <toport>p1</toport>
281 Initialisation d'un port de données d'entrée
282 -----------------------------------------------
283 Pour initialiser un port de données d'entrée avec des constantes on utilise le tag parameter
284 et les sous tags tonode, toport et value.
285 Le tag toport donne le nom du port d'entrée du noeud de nom tonode à initialiser.
286 La constante d'initialisation est donnée par le tag value.
287 La constante est encodée en utilisant la convention de codage XML-RPC (http://www.xmlrpc.com/).
289 Exemple d'initialisation::
292 <tonode>node1</tonode> <toport>p1</toport>
293 <value><string>coucou</string></value>
296 On initialise le port p1 du noeud node1 avec une constante de type chaine de
297 caractères ("coucou").
299 Voici quelques exemples d'encodage XML-RPC:
301 ============================ ==============================================
302 Constante Encodage XML-RPC
303 ============================ ==============================================
304 string "coucou" ``<string>coucou</string>``
305 double 23. ``<double>23</double>``
306 entier 0 ``<int>0</int>``
307 booléen true ``<boolean>1</boolean>``
308 fichier ``<objref>/tmp/forma01a.med</objref>``
312 <value><int>1</int> </value>
313 <value><int>0</int> </value>
315 structure (2 membres) ::
318 <member> <name>s</name>
319 <value><int>1</int> </value>
321 <member> <name>t</name>
322 <value><int>1</int> </value>
326 ============================ ==============================================
328 Premier exemple à partir des éléments précédents
329 ------------------------------------------------------
330 Il est maintenant possible de définir un schéma de calcul complet
331 avec des définitions de noeuds, des connexions et des initialisations. ::
334 <inline name="node1" >
336 <code>p1=p1+10</code>
338 <inport name="p1" type="int"/>
339 <outport name="p1" type="int"/>
341 <inline name="node2" >
345 <inport name="p1" type="int"/>
346 <outport name="p1" type="int"/>
348 <service name="node4" >
349 <component>ECHO</component>
350 <method>echoDouble</method>
351 <inport name="p1" type="double"/>
352 <outport name="p1" type="double"/>
355 <fromnode>node1</fromnode> <tonode>node2</tonode>
358 <fromnode>node1</fromnode> <tonode>node4</tonode>
361 <fromnode>node1</fromnode> <fromport>p1</fromport>
362 <tonode>node2</tonode> <toport>p1</toport>
365 <fromnode>node1</fromnode> <fromport>p1</fromport>
366 <tonode>node4</tonode> <toport>p1</toport>
369 <tonode>node1</tonode> <toport>p1</toport>
370 <value><int>5</int></value>
374 Le schéma comprend 2 noeuds python (node1, node2) et un noeud SALOME (node4).
375 Les noeuds node2 et node4 peuvent être exécutés en parallèle comme on peut le
376 voir sur le diagramme ci-dessous.
378 .. image:: images/ex1.png
381 Définition de noeuds composés
382 -----------------------------------
383 L'étape suivante est la définition de noeuds composés soit pour modulariser le schéma (Bloc)
384 soit pour introduire des structures de contrôle (Loop, Switch).
388 Tous les éléments de définition précédents (à l'exception des types de données) peuvent être
389 mis dans un noeud Bloc. Pour créer un Bloc, il suffit d'utiliser un tag bloc avec un attribut name
390 obligatoire qui portera le nom du bloc. Ensuite, on ajoute des définitions dans ce tag et on obtient
391 un noeud composé qui est un Bloc.
393 Voici un exemple de Bloc qui reprend une partie de l'exemple ci-dessus::
396 <inline name="node1" >
398 <code>p1=p1+10</code>
400 <inport name="p1" type="int"/>
401 <outport name="p1" type="int"/>
403 <service name="node4" >
404 <component>ECHO</component>
405 <method>echoDouble</method>
406 <inport name="p1" type="double"/>
407 <outport name="p1" type="double"/>
410 <fromnode>node1</fromnode> <tonode>node4</tonode>
413 <fromnode>node1</fromnode> <fromport>p1</fromport>
414 <tonode>node4</tonode> <toport>p1</toport>
418 Ce bloc peut maintenant être connecté à d'autres noeuds comme un simple noeud élémentaire.
419 Il faut respecter quelques règles :
421 - il n'est pas possible de créer un lien de contrôle qui traverse la frontière d'un bloc
422 - il est possible de créer des liens data qui traverse la frontière aussi bien en entrée
423 qu'en sortie à condition d'utiliser un nommage contextuel (voir :ref:`nommage`)
428 Une ForLoop est définie en utilisant un tag forloop. Ce tag a un attribut obligatoire name qui porte le nom du noeud
429 et un attribut facultatif nsteps qui donne le nombre de tours de boucle à exécuter. Si cet attribut n'est pas spécifié,
430 le noeud utilisera la valeur donnée dans son port d'entrée de nom nsteps.
431 Le tag forloop doit contenir la définition d'un et d'un seul noeud interne qui peut être un noeud élémentaire
432 ou un noeud composé. On peut imbriquer des ForLoop sur plusieurs niveaux, par exemple. Si on veut avoir
433 plus d'un noeud de calcul dans la ForLoop, il faut utiliser un Bloc comme noeud interne.
435 Passons à un exemple::
437 <forloop name="l1" nsteps="5">
438 <inline name="node2" >
440 <code>p1=p1+10</code>
442 <inport name="p1" type="int"/>
443 <outport name="p1" type="int"/>
447 On fait ici une boucle qui exécutera 5 tours sur un noeud script python.
448 Les règles à respecter pour la création de liens sont les mêmes que pour les blocs. Pour faire des calculs
449 itératifs, il faut pouvoir connecter un port de sortie d'un noeud interne avec un port d'entrée de
450 ce même noeud interne. On utilise pour ce faire un lien data qui est défini dans le contexte du
453 Voici un exemple avec rebouclage sur le port p1::
455 <forloop name="l1" nsteps="5">
456 <inline name="node2" >
458 <code>p1=p1+10</code>
460 <inport name="p1" type="int"/>
461 <outport name="p1" type="int"/>
463 <datalink control="false">
464 <fromnode>node2</fromnode> <fromport>p1</fromport>
465 <tonode>node2</tonode> <toport>p1</toport>
469 Enfin si le nombre de pas de la boucle est calculé, on utilisera le port d'entrée nsteps de la boucle
470 comme dans l'exemple suivant::
474 <code>nsteps=3</code>
476 <outport name="nsteps" type="int"/>
480 <inline name="node2" >
482 <code>p1=p1+10</code>
484 <inport name="p1" type="int"/>
485 <outport name="p1" type="int"/>
490 <fromnode>n</fromnode><fromport>nsteps</fromport>
491 <tonode>l1</tonode> <toport>nsteps</toport>
496 Une WhileLoop est définie en utilisant le tag while. Il a un seul attribut obligatoire name qui porte le
497 nom du noeud. Le port d'entrée de nom "condition" doit être connecté pour que la boucle soit valide.
499 Voici un exemple de boucle while qui incrémente la variable p1 jusqu'à ce qu'elle dépasse la valeur 40::
503 <inline name="node2" >
505 <code>p1=p1+10</code>
506 <code><![CDATA[condition=p1 < 40.]]> </code>
508 <inport name="p1" type="int"/>
509 <outport name="p1" type="int"/>
510 <outport name="condition" type="bool"/>
512 <datalink control="false">
513 <fromnode>node2</fromnode> <fromport>p1</fromport>
514 <tonode>node2</tonode> <toport>p1</toport>
518 <datalink control="false">
519 <fromnode>l1.b.node2</fromnode> <fromport>condition</fromport>
520 <tonode>l1</tonode> <toport>condition</toport>
523 <tonode>l1.b.node2</tonode> <toport>p1</toport>
524 <value><int>23</int> </value>
527 On peut bien sûr définir des boucles while imbriquées.
531 Une boucle ForEach est définie en utilisant le tag foreach. Il a 2 attributs obligatoires :
532 name qui porte le nom du noeud ForEach et type qui donne le type des éléments de la collection sur lequel
533 la boucle va itérer. Un troisième attribut facultatif nbranch permet de fixer le nombre de branches
534 parallèles que la boucle va gérer. Si cet attribut n'est pas fourni, il faut connecter le port de données
535 d'entrée de la boucle nbBranches.
536 Le tag foreach doit contenir la définition d'un et d'un seul noeud interne (élémentaire ou composé).
538 Voici un exemple minimal de boucle ForEach::
540 <inline name="node0" >
542 <code>p1=[i*0.5 for i in range(10)]</code>
544 <outport name="p1" type="dblevec"/>
546 <foreach name="b1" nbranch="3" type="double" >
547 <inline name="node2" >
549 <code>def f(p1):</code>
550 <code> p1= p1+10.</code>
551 <code> print p1</code>
552 <code> return p1</code>
554 <inport name="p1" type="double"/>
555 <outport name="p1" type="double"/>
558 <inline name="node1" >
560 <code>print p1</code>
562 <inport name="p1" type="dblevec"/>
565 <fromnode>node0</fromnode><fromport>p1</fromport>
566 <tonode>b1</tonode> <toport>SmplsCollection</toport>
569 <fromnode>b1</fromnode><fromport>SmplPrt</fromport>
570 <tonode>b1.node2</tonode> <toport>p1</toport>
573 <fromnode>b1.node2</fromnode><fromport>p1</fromport>
574 <tonode>node1</tonode> <toport>p1</toport>
577 Un premier noeud script Python construit une liste de double. Cette liste sera utilisée par la boucle ForEach
578 pour itérer (connexion au port d'entrée SmplsCollection). Le noeud interne de la boucle est un noeud fonction
579 Python qui ajoute 10 à l'élément qu'il traite. Enfin les résultats sont collectés et reçus par le noeud Python
580 node1 sous la forme d'une liste de doubles.
584 Un noeud Switch est défini avec le tag switch. Il a un seul attribut obligatoire name qui porte le nom du noeud.
585 Chaque cas est défini avec le sous tag case. Le cas par défaut est défini avec le sous tag default.
586 Le tag case a un attribut obligatoire id qui doit être un entier.
587 Le tag default n'a aucun attribut.
589 Un exemple minimal de switch::
593 <code>select=3</code>
595 <outport name="select" type="int"/>
601 <script><code>print p1</code></script>
602 <inport name="p1" type="double"/>
603 <outport name="p1" type="double"/>
608 <script><code>print p1</code></script>
609 <inport name="p1" type="double"/>
610 <outport name="p1" type="double"/>
615 <control> <fromnode>n</fromnode> <tonode>b1</tonode> </control>
616 <datalink> <fromnode>n</fromnode><fromport>select</fromport>
617 <tonode>b1</tonode> <toport>select</toport> </datalink>
619 <tonode>b1.p3_n2</tonode> <toport>p1</toport>
620 <value><double>54</double> </value>
623 <tonode>b1.default_n2</tonode> <toport>p1</toport>
624 <value><double>54</double> </value>
628 Définition de containers
629 --------------------------------
630 Les containers YACS doivent être définis juste après avoir défini les types de données
631 avant la définition des noeuds de calcul. Un container est défini en utilisant le tag conatiner.
632 Ce tag a un seul attribut obligatoire qui est le nom du container.
633 Les contraintes sur le placement du container sont spécifiées au moyen de propriétés définies
634 avec le sous tag property. Ce tag a 2 attributs obligatoires name et value qui donnent le nom
635 de la contrainte et sa valeur sous forme de chaine de caractères.
637 Voici un exemple de container défini par l'IHM graphique::
639 <container name="DefaultContainer">
640 <property name="container_name" value="FactoryServer"/>
641 <property name="cpu_clock" value="0"/>
642 <property name="hostname" value="localhost"/>
643 <property name="isMPI" value="false"/>
644 <property name="mem_mb" value="0"/>
645 <property name="nb_component_nodes" value="0"/>
646 <property name="nb_node" value="0"/>
647 <property name="nb_proc_per_node" value="0"/>
648 <property name="parallelLib" value=""/>
649 <property name="workingdir" value=""/>
652 Une fois que les containers sont définis, on peut placer des composants SALOME sur ce container.
653 Il suffit d'ajouter cette information dans la définition du noeud de service SALOME en utilisant
654 le sous tag load. Ce tag a un seul attribut obligatoire de nom container qui donne le nom du container
655 sur lequel le composant SALOME sera placé.
657 Si on veut placer le service SALOME défini plus haut sur le container DefaultContainer, on écrira::
659 <service name="node4" >
660 <component>AddComponent</component>
661 <load container="DefaultContainer"/>
663 <inport name="x" type="double"/>
664 <inport name="y" type="double"/>
665 <outport name="FuncValue" type="double"/>
666 <outport name="z" type="double"/>
669 Les propriétés de noeuds
670 -----------------------------
671 On peut définir des propriétés pour tous les noeuds élémentaires ou composés.
672 Cependant elles ne sont réellement utiles que pour les noeuds de service SALOME.
674 Une propriété se définit en ajoutant un sous tag property dans la définition d'un noeud.
675 Le tag property a 2 attributs obligatoires name et value qui portent le nom de la propriété
676 et sa valeur sous la forme d'une chaine de caractères.
678 Exemple avec un noeud de service SALOME::
680 <service name="node4" >
681 <component>AddComponent</component>
683 <property name="VERBOSE" value="2" />
684 <inport name="x" type="double"/>
685 <inport name="y" type="double"/>
686 <outport name="FuncValue" type="double"/>
687 <outport name="z" type="double"/>
690 Dans le cas d'un noeud de service SALOME la propriété est transmise au composant
691 et, par défaut, positionnée en tant que variable d'environnement.
693 Les connexions datastream
694 ----------------------------
695 Les connexions datastream ne sont possibles que pour des noeuds de service SALOME comme
696 on l'a vu dans :ref:`principes`. Il faut tout d'abord définir les ports datastream dans
698 Un port datastream d'entrée se définit avec le sous tag instream. Ce tag a 2 attributs
699 obligatoires : name qui donne le nom du port et type qui donne le type de données
700 supporté (voir :ref:`principes` pour les types datastream).
701 Pour définir un port datastream sortant, on utilise le tag outstream à la place de instream.
702 Pour définir une propriété associée au port, on utilise le sous tag property avec ses deux attributs
703 name et value. Pour avoir la liste des propriétés possibles, voir la documentation CALCIUM.
705 Voici un exemple de définition de noeud de service SALOME avec des ports datastream. Il s'agit du
706 composant DSCCODC que l'on peut trouver dans le module DSCCODES de la base EXAMPLES.
707 Les ports datastream sont de type entier avec dépendance temporelle. ::
709 <service name="node1" >
710 <component>DSCCODC</component>
711 <method>prun</method>
712 <inport name="niter" type="int"/>
713 <instream name="ETP_EN" type="CALCIUM_integer">
714 <property name="DependencyType" value="TIME_DEPENDENCY"/>
716 <outstream name="STP_EN" type="CALCIUM_integer">
717 <property name="DependencyType" value="TIME_DEPENDENCY"/>
721 Pour définir des liens datastream, on utilise le tag stream.
722 Les sous tags fromnode et fromport donne le nom du noeud et du port datastream
723 sortant qui sera connecté au noeud et au port dont les noms sont donnés pat les
724 sous tags tonode et toport.
725 Un lien datastream peut être paramétré avec des propriétés (voir la documentation CALCIUM). Une propriété
726 est définie avec le sous tag property.
728 Voici un exemple plus complet avec des liens datastream paramétrés. On a deux composants SALOME
729 avec ports datastream de type entier, avec dépendance temporelle (TIME_DEPENDENCY).
730 Les connexions datastream utilisent un schéma temporel explicite (TI_SCHEM). ::
732 <service name="node1" >
733 <component>DSCCODC</component>
734 <method>prun</method>
735 <inport name="niter" type="int"/>
736 <instream name="ETP_EN" type="CALCIUM_integer">
737 <property name="DependencyType" value="TIME_DEPENDENCY"/>
739 <outstream name="STP_EN" type="CALCIUM_integer">
740 <property name="DependencyType" value="TIME_DEPENDENCY"/>
744 <service name="node2" >
745 <component>DSCCODD</component>
746 <method>prun</method>
747 <inport name="niter" type="int"/>
748 <instream name="ETP_EN" type="CALCIUM_integer">
749 <property name="DependencyType" value="TIME_DEPENDENCY"/>
751 <outstream name="STP_EN" type="CALCIUM_integer">
752 <property name="DependencyType" value="TIME_DEPENDENCY"/>
757 <fromnode>node2</fromnode> <fromport>STP_EN</fromport>
758 <tonode>node1</tonode> <toport>ETP_EN</toport>
759 <property name="DateCalSchem" value="TI_SCHEM"/>
763 <fromnode>node1</fromnode> <fromport>STP_EN</fromport>
764 <tonode>node2</tonode> <toport>ETP_EN</toport>
765 <property name="DateCalSchem" value="TI_SCHEM"/>
768 D'autres noeuds élémentaires
769 --------------------------------
771 '''''''''''''''''''''''
772 Ce type de noeud se définit avec le tag sinline. Il a un attribut obligatoire name qui porte le nom
773 du noeud. Pour le définir, on utilise les mêmes sous tags que pour le noeud fonction Python : function
774 pour le code Python à exécuter, inport et outport pour définir ses ports de données entrants et sortants.
775 Pour définir le placement sur un container, on utilise le sous tag load comme pour le noeud de service
778 Voici un exemple d'appel du composant PYHELLO depuis un noeud SalomePython::
780 <sinline name="node1" >
782 <code>import salome</code>
783 <code>salome.salome_init()</code>
784 <code>import PYHELLO_ORB</code>
785 <code>def f(p1):</code>
786 <code> print __container__from__YACS__</code>
787 <code> machine,container=__container__from__YACS__.split('/')</code>
788 <code> param={}</code>
789 <code> param['hostname']=machine</code>
790 <code> param['container_name']=container</code>
791 <code> compo=salome.lcc.LoadComponent(param, "PYHELLO")</code>
792 <code> print compo.makeBanner(p1)</code>
793 <code> print p1</code>
795 <load container="A"/>
796 <inport name="p1" type="string"/>
799 Le composant PYHELLO sera placé sur le container A. Le choix du container est du ressort de YACS.
800 Le résultat du choix est accessible dans la variable python __container__from__YACS__ et est utilisé
801 par le noeud pour charger le composant en utilisant le LifeCycle de SALOME.
805 Ce type de noeud se définit avec le tag datanode. Il a un attribut obligatoire name qui porte le nom
806 du noeud. Pour définir les données du noeud, on utilisera le sous tag parameter. Ce tag a deux
807 attributs obligatoires name et type qui donnent respectivement le nom de la donnée et son type.
808 La valeur initiale de la donnée est fournie par le sous tag value du tag parameter en utilisant
809 l'encodage XML-RPC (voir :ref:`initialisation`)
811 Voici un exemple de noeud DataIn qui définit 2 données de type double (b et c) et
812 une donnée de type fichier (f)::
815 <parameter name="f" type="file">
816 <value><objref>f.data</objref></value>
818 <parameter name="b" type="double" ><value><double>5.</double></value></parameter>
819 <parameter name="c" type="double" ><value><double>-1.</double></value></parameter>
824 Ce type de noeud se définit avec le tag outnode. Il a un attribut obligatoire name et un attribut facultatif ref.
825 L'attribut name porte le nom du noeud. L'attribut ref donne le nom du fichier dans lequel
826 les valeurs des résultats seront sauvegardées.
827 Pour définir les résultats du noeud, on utilisera le sous tag parameter. Ce tag a deux
828 attributs obligatoires name et type qui donnent respectivement le nom du résultat et son type
829 et un attribut facultatif ref. Ce dernier attribut n'est utile que pour les résultats fichiers.
830 S'il est renseigné, le fichier résultat sera copié dans le fichier dont le nom est donné par l'attribut. Sinon
831 le fichier sera un fichier temporaire généralement localisé dans le répertoire /tmp (éventuellement
832 sur une machine distante).
834 Voici un exemple de noeud DataOut qui définit 5 résultats (a, b, c, d, f) de différents types (double,
835 int, string, vecteur de doubles, fichier) et écrit les valeurs correspondantes dans le fichier g.data.
836 Le fichier résultat sera copié dans le fichier local monfich::
838 <outnode name="out" ref="g.data">
839 <parameter name="a" type="double" />
840 <parameter name="b" type="int" />
841 <parameter name="c" type="string" />
842 <parameter name="d" type="dblevec" />
843 <parameter name="f" type="file" ref="monfich"/>
848 Ce type de noeud se définit comme un noeud DataIn avec le tag datanode. Il suffit d'ajouter l'attribut
849 kind avec la valeur "study".
850 L'étude associée est donnée par une propriété (tag property) de nom StudyID (dont la valeur est un entier).
852 Pour définir les données du noeud, on utilisera le sous tag parameter. Ce tag a deux
853 attributs obligatoires name et type qui donnent respectivement le nom de la donnée et son type.
854 L'attribut ref donne l'entrée dans l'étude sous la forme d'une Entry SALOME ou d'un chemin dans l'arbre d'étude.
856 Voici un exemple de noeud StudyIn qui définit 2 données (b et c) de types GEOM_Object et booléen. L'étude
857 est supposée chargée en mémoire par SALOME sous le StudyID 1. La donnée b est référencée par une Entry SALOME.
858 La donnée c est référencée par un chemin dans l'arbre d'étude. ::
860 <datanode name="s" kind="study" >
861 <property name="StudyID" value="1" />
862 <parameter name="b" type="GEOM/GEOM_Object" ref="0:1:2:2"/>
863 <parameter name="c" type="bool" ref="/Geometry/Box_1"/>
868 Ce type de noeud se définit comme un noeud DataOut avec le tag outnode et l'attribut name.
869 Il suffit d'ajouter l'attribut kind avec la valeur "study".
870 L'attribut facultatif ref donne le nom du fichier dans lequel sera sauvegardée l'étude à la fin du calcul.
871 L'étude associée est donnée par une propriété (tag property) de nom StudyID (dont la valeur est un entier).
873 Pour définir les résultats du noeud, on utilisera le sous tag parameter. Ce tag a deux
874 attributs obligatoires name et type qui donnent respectivement le nom du résultat et son type.
875 L'attribut ref donne l'entrée dans l'étude sous la forme d'une Entry SALOME ou d'un chemin dans l'arbre d'étude.
877 Voici un exemple de noeud StudyOut qui définit 2 résultats (a et b) de type GEOM_Object. L'étude utilisée
878 a le studyId 1. L'étude complète est sauvegardée en fin de calcul dans le fichier study1.hdf::
880 <outnode name="o" kind="study" ref="stud1.hdf">
881 <property name="StudyID" value="1"/>
882 <parameter name="a" type="GEOM/GEOM_Object" ref="/Geometry/YacsFuse"/>
883 <parameter name="b" type="GEOM/GEOM_Object" ref="0:1:1:6"/>