doc/schemaxml.rst

   1 .. _schemaxml:
   2
   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:
   6
   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
  12    * des initialisations
  13
  14 La présentation de ces définitions sera faite progressivement. On commence
  15 dans un premier temps par :
  16
  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
  21
  22 Dans un deuxième temps, on ajoute des compléments sur :
  23
  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
  28
  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::
  31
  32   <proc>
  33   </proc>
  34
  35 Il ne contient aucune définition et ne fait rien.
  36
  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::
  43
  44   <type name="mydble" kind="double"/>
  45
  46 On peut ensuite utiliser mydble à la place de double.
  47
  48
  49 Référence d'objet
  50 '''''''''''''''''''''
  51 La forme la plus simple pour définir un type référence d'objet est::
  52
  53   <objref name="mesh"/>
  54
  55 L'attribut name du tag objref donne le nom du nouveau type.
  56 La forme complète pour définir ce type serait::
  57
  58   <objref name="mesh" id="IDL:mesh:1.0/>
  59
  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.
  62
  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::
  66
  67   <objref name="refinedmesh">
  68     <base>mesh</base>
  69   </objref>
  70
  71 Si on a plusieurs types de base, on écrira::
  72
  73   <objref name="refinedmesh">
  74     <base>mesh</base>
  75     <base>unautretype</base>
  76   </objref>
  77
  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::
  80
  81   <objref name="myns/mesh"/>
  82
  83 Séquence
  84 ''''''''''
  85 Pour définir une séquence de double, on écrira::
  86
  87   <sequence name="myseqdble" content="double"/>
  88
  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::
  93
  94   <sequence name="myseqseqdble" content="myseqdble"/>
  95
  96 On peut également définir une séquence de références d'objet par::
  97
  98   <sequence name="myseqmesh" content="refinedmesh"/>
  99
 100 Structure
 101 '''''''''''''
 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::
 105
 106     <struct name="S1" >
 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"/>
 112     </struct>
 113
 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.
 117
 118 Définition des noeuds de calcul élémentaires
 119 -----------------------------------------------
 120 Noeud script Python
 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::
 124
 125     <inline name="node1" >
 126       <script>
 127         <code>p1=10</code>
 128       </script>
 129       <outport name="p1" type="int"/>
 130     </inline>
 131
 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.
 136 Par exemple::
 137
 138   <script>
 139     <code><![CDATA[a=0
 140   p1= 10
 141   print "a:",a
 142   ]]>
 143     </code>
 144   </script>
 145
 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
 151 du tag outport.
 152
 153 Un exemple de noeud avec des ports d'entrée et de sortie::
 154
 155          <inline name="node1" >
 156            <script>
 157              <code>p1=p1+10</code>
 158            </script>
 159            <inport name="p1" type="int"/>
 160            <outport name="p1" type="int"/>
 161          </inline>
 162
 163 Maintenant le noeud reçoit p1 comme variable d'entrée, lui ajoute 10 et l'exporte
 164 comme variable de sortie.
 165
 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::
 170
 171     <inline name="node1" >
 172       <function name="f">
 173         <code>def f(p1):</code>
 174         <code>  p1=p1+10</code>
 175         <code>  return p1</code>
 176       </function>
 177       <inport name="p1" type="int"/>
 178       <outport name="p1" type="int"/>
 179     </inline>
 180
 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.
 186
 187 Noeud de service SALOME
 188 ''''''''''''''''''''''''''
 189 Comme il est dit dans :ref:`principes`, on a deux façons de décrire un noeud
 190 de service SALOME.
 191
 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::
 194
 195     <service name="node4" >
 196       <component>AddComponent</component>
 197       <method>Add</method>
 198       <inport name="x" type="double"/>
 199       <inport name="y" type="double"/>
 200       <outport name="FuncValue" type="double"/>
 201       <outport name="z" type="double"/>
 202     </service>
 203
 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
 208 de SALOME.
 209
 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::
 212
 213   <service name="node5" >
 214     <node>node4</node>
 215     <method>Setx</method>
 216     <inport name="x" type="double"/>
 217   </service>
 218
 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.
 221
 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.
 228
 229 Lien de contrôle
 230 ''''''''''''''''''
 231 Un lien de contrôle est défini en utilisant le tag control comme dans l'exemple
 232 suivant::
 233
 234  <control>
 235    <fromnode>node1</fromnode>
 236    <tonode>node2</tonode>
 237  </control>
 238
 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.
 241
 242 Lien dataflow
 243 ''''''''''''''''
 244 Un lien dataflow est défini en utilisant le tag datalink comme dans l'exemple
 245 suivant::
 246
 247   <datalink>
 248     <fromnode>node1</fromnode> <fromport>p1</fromport>
 249     <tonode>node2</tonode> <toport>p1</toport>
 250   </datalink>
 251
 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.
 257
 258 Lien data
 259 ''''''''''
 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::
 262
 263   <datalink control="false">
 264     <fromnode>node1</fromnode> <fromport>p1</fromport>
 265     <tonode>node2</tonode> <toport>p1</toport>
 266   </datalink>
 267
 268 Le lien dataflow ci-dessus peut donc être aussi écrit comme suit::
 269
 270   <control>
 271     <fromnode>node1</fromnode>
 272     <tonode>node2</tonode>
 273   </control>
 274   <datalink control="false">
 275     <fromnode>node1</fromnode> <fromport>p1</fromport>
 276     <tonode>node2</tonode> <toport>p1</toport>
 277   </datalink>
 278
 279 .. _initialisation:
 280
 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/).
 288
 289 Exemple d'initialisation::
 290
 291     <parameter>
 292       <tonode>node1</tonode> <toport>p1</toport>
 293       <value><string>coucou</string></value>
 294     </parameter>
 295
 296 On initialise le port p1 du noeud node1 avec une constante de type chaine de
 297 caractères ("coucou").
 298
 299 Voici quelques exemples d'encodage XML-RPC:
 300
 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>``
 309 liste d'entiers                ::
 310
 311                                <array> <data>
 312                                <value><int>1</int> </value>
 313                                <value><int>0</int> </value>
 314                                </data> </array>
 315 structure (2 membres)          ::
 316
 317                                <struct>
 318                                <member> <name>s</name>
 319                                <value><int>1</int> </value>
 320                                </member>
 321                                <member> <name>t</name>
 322                                <value><int>1</int> </value>
 323                                </member>
 324                                </struct>
 325
 326 ============================ ==============================================
 327
 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. ::
 332
 333   <proc>
 334     <inline name="node1" >
 335       <script>
 336         <code>p1=p1+10</code>
 337       </script>
 338       <inport name="p1" type="int"/>
 339       <outport name="p1" type="int"/>
 340     </inline>
 341     <inline name="node2" >
 342       <script>
 343         <code>p1=2*p1</code>
 344       </script>
 345       <inport name="p1" type="int"/>
 346       <outport name="p1" type="int"/>
 347     </inline>
 348     <service name="node4" >
 349         <component>ECHO</component>
 350         <method>echoDouble</method>
 351         <inport name="p1" type="double"/>
 352         <outport name="p1" type="double"/>
 353     </service>
 354     <control>
 355       <fromnode>node1</fromnode> <tonode>node2</tonode>
 356     </control>
 357     <control>
 358       <fromnode>node1</fromnode> <tonode>node4</tonode>
 359     </control>
 360     <datalink>
 361       <fromnode>node1</fromnode> <fromport>p1</fromport>
 362       <tonode>node2</tonode> <toport>p1</toport>
 363     </datalink>
 364     <datalink>
 365       <fromnode>node1</fromnode> <fromport>p1</fromport>
 366       <tonode>node4</tonode> <toport>p1</toport>
 367     </datalink>
 368     <parameter>
 369       <tonode>node1</tonode> <toport>p1</toport>
 370       <value><int>5</int></value>
 371     </parameter>
 372   </proc>
 373
 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.
 377
 378 .. image:: images/ex1.png
 379    :align: center
 380
 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).
 385
 386 Bloc
 387 ''''''''
 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.
 392
 393 Voici un exemple de Bloc qui reprend une partie de l'exemple ci-dessus::
 394
 395   <bloc name="b">
 396     <inline name="node1" >
 397       <script>
 398         <code>p1=p1+10</code>
 399       </script>
 400       <inport name="p1" type="int"/>
 401       <outport name="p1" type="int"/>
 402     </inline>
 403     <service name="node4" >
 404         <component>ECHO</component>
 405         <method>echoDouble</method>
 406         <inport name="p1" type="double"/>
 407         <outport name="p1" type="double"/>
 408     </service>
 409     <control>
 410       <fromnode>node1</fromnode> <tonode>node4</tonode>
 411     </control>
 412     <datalink>
 413       <fromnode>node1</fromnode> <fromport>p1</fromport>
 414       <tonode>node4</tonode> <toport>p1</toport>
 415     </datalink>
 416   </bloc>
 417
 418 Ce bloc peut maintenant être connecté à d'autres noeuds comme un simple noeud élémentaire.
 419 Il faut respecter quelques règles :
 420
 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`)
 424
 425 ForLoop
 426 '''''''''''
 427
 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.
 434
 435 Passons à un exemple::
 436
 437     <forloop name="l1" nsteps="5">
 438       <inline name="node2" >
 439         <script>
 440           <code>p1=p1+10</code>
 441         </script>
 442         <inport name="p1" type="int"/>
 443         <outport name="p1" type="int"/>
 444       </inline>
 445     </forloop>
 446
 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
 451 noeud ForLoop.
 452
 453 Voici un exemple avec rebouclage sur le port p1::
 454
 455   <forloop name="l1" nsteps="5">
 456       <inline name="node2" >
 457         <script>
 458           <code>p1=p1+10</code>
 459         </script>
 460         <inport name="p1" type="int"/>
 461         <outport name="p1" type="int"/>
 462       </inline>
 463       <datalink control="false">
 464         <fromnode>node2</fromnode> <fromport>p1</fromport>
 465         <tonode>node2</tonode> <toport>p1</toport>
 466       </datalink>
 467   </forloop>
 468
 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::
 471
 472     <inline name="n" >
 473       <script>
 474             <code>nsteps=3</code>
 475       </script>
 476       <outport name="nsteps" type="int"/>
 477     </inline>
 478
 479     <forloop name="l1" >
 480       <inline name="node2" >
 481         <script>
 482           <code>p1=p1+10</code>
 483         </script>
 484         <inport name="p1" type="int"/>
 485         <outport name="p1" type="int"/>
 486       </inline>
 487     </forloop>
 488
 489     <datalink>
 490       <fromnode>n</fromnode><fromport>nsteps</fromport>
 491       <tonode>l1</tonode> <toport>nsteps</toport>
 492     </datalink>
 493
 494 WhileLoop
 495 ''''''''''''
 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.
 498
 499 Voici un exemple de boucle while qui incrémente la variable p1 jusqu'à ce qu'elle dépasse la valeur 40::
 500
 501   <while name="l1" >
 502     <bloc name="b">
 503       <inline name="node2" >
 504         <script>
 505           <code>p1=p1+10</code>
 506           <code><![CDATA[condition=p1 < 40.]]> </code>
 507         </script>
 508         <inport name="p1" type="int"/>
 509         <outport name="p1" type="int"/>
 510         <outport name="condition" type="bool"/>
 511       </inline>
 512       <datalink control="false">
 513         <fromnode>node2</fromnode> <fromport>p1</fromport>
 514         <tonode>node2</tonode> <toport>p1</toport>
 515       </datalink>
 516     </bloc>
 517   </while>
 518   <datalink control="false">
 519     <fromnode>l1.b.node2</fromnode> <fromport>condition</fromport>
 520     <tonode>l1</tonode> <toport>condition</toport>
 521   </datalink>
 522   <parameter>
 523     <tonode>l1.b.node2</tonode> <toport>p1</toport>
 524     <value><int>23</int> </value>
 525   </parameter>
 526
 527 On peut bien sûr définir des boucles while imbriquées.
 528
 529 Boucle ForEach
 530 ''''''''''''''''
 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é).
 537
 538 Voici un exemple minimal de boucle ForEach::
 539
 540     <inline name="node0" >
 541       <script>
 542         <code>p1=[i*0.5 for i in range(10)]</code>
 543       </script>
 544       <outport name="p1" type="dblevec"/>
 545     </inline>
 546     <foreach name="b1" nbranch="3" type="double" >
 547       <inline name="node2" >
 548         <function name="f">
 549             <code>def f(p1):</code>
 550             <code>  p1= p1+10.</code>
 551             <code>  print p1</code>
 552             <code>  return p1</code>
 553         </function>
 554         <inport name="p1" type="double"/>
 555         <outport name="p1" type="double"/>
 556       </inline>
 557     </foreach>
 558     <inline name="node1" >
 559       <script>
 560         <code>print p1</code>
 561       </script>
 562       <inport name="p1" type="dblevec"/>
 563     </inline>
 564     <datalink>
 565       <fromnode>node0</fromnode><fromport>p1</fromport>
 566       <tonode>b1</tonode> <toport>SmplsCollection</toport>
 567     </datalink>
 568     <datalink>
 569       <fromnode>b1</fromnode><fromport>SmplPrt</fromport>
 570       <tonode>b1.node2</tonode> <toport>p1</toport>
 571     </datalink>
 572     <datalink>
 573       <fromnode>b1.node2</fromnode><fromport>p1</fromport>
 574       <tonode>node1</tonode> <toport>p1</toport>
 575     </datalink>
 576
 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.
 581
 582 Switch
 583 ''''''''''
 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.
 588
 589 Un exemple minimal de switch::
 590
 591     <inline name="n" >
 592         <script>
 593             <code>select=3</code>
 594         </script>
 595         <outport name="select" type="int"/>
 596     </inline>
 597
 598     <switch name="b1">
 599       <case id="3">
 600         <inline name="n2" >
 601           <script><code>print p1</code></script>
 602           <inport name="p1" type="double"/>
 603           <outport name="p1" type="double"/>
 604         </inline>
 605       </case>
 606       <default>
 607         <inline name="n2" >
 608           <script><code>print p1</code></script>
 609           <inport name="p1" type="double"/>
 610           <outport name="p1" type="double"/>
 611         </inline>
 612       </default>
 613     </switch>
 614
 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>
 618     <parameter>
 619         <tonode>b1.p3_n2</tonode> <toport>p1</toport>
 620         <value><double>54</double> </value>
 621     </parameter>
 622     <parameter>
 623         <tonode>b1.default_n2</tonode> <toport>p1</toport>
 624         <value><double>54</double> </value>
 625     </parameter>
 626
 627
 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.
 636
 637 Voici un exemple de container défini par l'IHM graphique::
 638
 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=""/>
 650    </container>
 651
 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é.
 656
 657 Si on veut placer le service SALOME défini plus haut sur le container DefaultContainer, on écrira::
 658
 659     <service name="node4" >
 660       <component>AddComponent</component>
 661       <load container="DefaultContainer"/>
 662       <method>Add</method>
 663       <inport name="x" type="double"/>
 664       <inport name="y" type="double"/>
 665       <outport name="FuncValue" type="double"/>
 666       <outport name="z" type="double"/>
 667     </service>
 668
 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.
 673
 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.
 677
 678 Exemple avec un noeud de service SALOME::
 679
 680     <service name="node4" >
 681       <component>AddComponent</component>
 682       <method>Add</method>
 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"/>
 688     </service>
 689
 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.
 692
 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
 697 le noeud de service.
 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.
 704
 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. ::
 708
 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"/>
 715       </instream>
 716       <outstream name="STP_EN" type="CALCIUM_integer">
 717         <property name="DependencyType" value="TIME_DEPENDENCY"/>
 718       </outstream>
 719     </service>
 720
 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.
 727
 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). ::
 731
 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"/>
 738       </instream>
 739       <outstream name="STP_EN" type="CALCIUM_integer">
 740         <property name="DependencyType" value="TIME_DEPENDENCY"/>
 741       </outstream>
 742     </service>
 743
 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"/>
 750       </instream>
 751       <outstream name="STP_EN" type="CALCIUM_integer">
 752         <property name="DependencyType" value="TIME_DEPENDENCY"/>
 753       </outstream>
 754     </service>
 755
 756     <stream>
 757       <fromnode>node2</fromnode> <fromport>STP_EN</fromport>
 758       <tonode>node1</tonode> <toport>ETP_EN</toport>
 759       <property name="DateCalSchem" value="TI_SCHEM"/>
 760     </stream>
 761
 762     <stream>
 763       <fromnode>node1</fromnode> <fromport>STP_EN</fromport>
 764       <tonode>node2</tonode> <toport>ETP_EN</toport>
 765       <property name="DateCalSchem" value="TI_SCHEM"/>
 766     </stream>
 767
 768 D'autres noeuds élémentaires
 769 --------------------------------
 770 Noeud SalomePython
 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
 776 SALOME.
 777
 778 Voici un exemple d'appel du composant PYHELLO depuis un noeud SalomePython::
 779
 780     <sinline name="node1" >
 781       <function name="f">
 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>
 794       </function>
 795       <load container="A"/>
 796       <inport name="p1" type="string"/>
 797     </sinline>
 798
 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.
 802
 803 Noeud DataIn
 804 ''''''''''''''''
 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`)
 810
 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)::
 813
 814     <datanode name="a">
 815       <parameter name="f" type="file">
 816          <value><objref>f.data</objref></value>
 817       </parameter>
 818       <parameter name="b" type="double" ><value><double>5.</double></value></parameter>
 819       <parameter name="c" type="double" ><value><double>-1.</double></value></parameter>
 820     </datanode>
 821
 822 Noeud DataOut
 823 ''''''''''''''''
 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).
 833
 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::
 837
 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"/>
 844         </outnode>
 845
 846 Noeud StudyIn
 847 '''''''''''''''
 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).
 851
 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.
 855
 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. ::
 859
 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"/>
 864     </datanode>
 865
 866 Noeud StudyOut
 867 ''''''''''''''''''
 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).
 872
 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.
 876
 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::
 879
 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"/>
 884    </outnode>
 885