--- /dev/null
+<!doctype html public "-//w3c//dtd html 4.0 transitional//en">\r
+<html>\r
+<head>\r
+ <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">\r
+ <meta name="GENERATOR" content="Mozilla/4.73 [en] (WinNT; I) [Netscape]">\r
+ <title>Main Page</title>\r
+<link href="doxygen.css" rel="stylesheet" type="text/css">\r
+</head>\r
+<body>\r
+ \r
+<center>\r
+ <table WIDTH="96%" >\r
+ <tr> \r
+ <td><a href="http://www.opencascade.com"><img src="sources/logocorp.gif" BORDER=0 height=46 width=122></a></td>\r
+ <td> \r
+ <div align=right><a href="http://www.opencascade.org/SALOME/"><img src="sources/application.gif" BORDER=0 height=46 width=108></a></div>\r
+ </td>\r
+ </tr>\r
+ </table>\r
+</center>\r
+<h1><a name="page2">General overview</a> </h1>\r
+<a name="cont"></a><h2>Table of contents </h2>\r
+<b><i>\r
+<ul>\r
+ <li><a href="#1">1. Introduction</a></li>\r
+ <li><a href="#2">2. Definitions </a></li>\r
+ <ul>\r
+ <li><a href="#2_1">2.1 Computing scheme of type DataFlow</a></li>\r
+ <li><a href="#2_2">2.2 Types of nodes </a></li>\r
+ <ul>\r
+ <li><a href="#2_2_1">2.2.1 Computation node </a></li>\r
+ <li><a href="#2_2_2">2.2.2 Loop node </a></li>\r
+ <li><a href="#2_2_3">2.2.3 Switch node </a></li>\r
+ <li><a href="#2_2_4">2.2.4 GOTO node </a></li>\r
+ </ul>\r
+ </ul>\r
+ <li><a href="#3">3. Services and features of the SUPERVISION component</a></li>\r
+ <ul>\r
+ <li><a href="#3_1">3.1 CNode class</a></li>\r
+ <li><a href="#3_2">3.2 FNode class </a></li>\r
+ <li><a href="#3_3">3.3 INode class </a></li>\r
+ <li><a href="#3_4">3.4 GNode class </a></li>\r
+ <li><a href="#3_5">3.5 LNode class </a></li>\r
+ <li><a href="#3_6">3.6 ELNode class </a></li>\r
+ <li><a href="#3_7">3.7 SNode class </a></li>\r
+ <li><a href="#3_8">3.8 ESNode class </a></li>\r
+ <li><a href="#3_9">3.9 Graph class </a></li>\r
+ <li><a href="#3_10">3.10 Link class </a></li>\r
+ <li><a href="#3_11">3.11 Value class </a></li>\r
+ <li><a href="#3_12">3.12 Port class </a></li>\r
+ <li><a href="#3_13">3.13 SuperG class </a></li>\r
+ </ul>\r
+</ul>\r
+</i> </b> <br>\r
+<a name="1"></a><h2>1. Introduction </h2>\r
+<p>The Supervision module of the SALOME platform allows to define and execute \r
+ a chain of distributed numeric components, as well as to control the progress \r
+ of this chain. The various calculations to be chained and the exchanged data \r
+ are specified in a computing scheme, which can be of two types : </p>\r
+<ul>\r
+ <li>Data flow computing schemes. <br>\r
+ These schemes are represented by graphs without loops, conditional branches \r
+ or any operation of control. The execution of theses schemes can be automatically \r
+ optimized by the supervision engine by detecting and executing simultaneously \r
+ independant branches and by managing in a optimal way the life cycle of components.</li>\r
+ <br>\r
+ <br>\r
+ <li>Script type computing schemes.<br>\r
+ These schemes allow to define chainings or complex couplings of components \r
+ using loops, conditional execution and control flow breaks by leaning on a \r
+ scripting language (parametric studies, multi-physical coupling). Contrary \r
+ in data flows, the specification of these schemes must define the sequence \r
+ of execution of components. Notably, the simultaneous execution of components \r
+ should be explicitly defined.</li>\r
+</ul>\r
+<p>Of simple conception, the data flow schemes can be built in a graphic way and \r
+ validated automatically by the supervision engine.</p>\r
+<p>The script type computing schemes, which offer the possibility of building \r
+ complex chains, should be conceived by warned users (developers) who master \r
+ the syntax and the use of the scripting language.</p>\r
+<p>Once specified and validated, certain computing schemes defined by scripts \r
+ can be made customizable (input and output data, parameter sets) and integrated \r
+ into the platform to form components. These components can be used to build \r
+ schemes of higher level. </p>\r
+<p>Besides the definition of computing schemes, the Supervision module must also \r
+ take care of their execution and follow-up (complete execution or step by step) \r
+ : </p>\r
+<ul>\r
+ <li> Asking of instanciation of the components (kernel calls) and data (data \r
+ servers calls),</li>\r
+ <li>Launching computations specified in the computing scheme, </li>\r
+ <li>Managing the events emitted or received by the supervision engine and the \r
+ component,</li>\r
+ <li> Recovering the results of computations and demand of filing for the data \r
+ service. </li>\r
+</ul>\r
+<p>The user can visualize the progress of the scheme and the exchanged data, be \r
+ informed about the evolution of the execution of a component (errors, warning, \r
+ tracks, ...), to intervene by stopping, pausing or by resuming the execution \r
+ of the scheme or a particular component. </p>\r
+ <i><a href="#cont">Back to the contents</a></i>\r
+<a name="2"></a><h2>2. Defintions </h2>\r
+<a name="2_1"></a><h3>2.1 Computing scheme of type DataFlow</h3>\r
+<p>The computing schemes of type dataflow, feasible by the Supervision module, \r
+ are directed acyclic graphs, described by a set of nodes and of directed links. \r
+ A node represents a service of an instance of a computation component.</p>\r
+<p>A node is provided with input port(s) and/or output port(s). The input port(s) \r
+ (resp. output port(s)) represent the input argument(s) (resp. output argument(s)) \r
+ of the service. Certain services can possibly require the use of parameters \r
+ which will be grouped together in configuration files (defined in the Data/Properties \r
+ module, and recorded in the study).</p>\r
+<p>The computing schemes of type data flow do not contain either loops, conditional \r
+ branches or any operation of control. They can thus be built easily in a graphic \r
+ way, by connecting output ports to input ports of nodes. Although the graphic \r
+ construction is the simplest way, these computing schemes can also be defined \r
+ in the language of script.</p>\r
+<p>A node represents a service (function, method) of an instance of a component. \r
+ If the component possesses a unique service (\93Run\94 method), one will omit the \r
+ term \93service of\94. Various services of the same component can be used in various \r
+ nodes of the graph, or the same service can be used several times.</p>\r
+<a name="2_2"></a><h3>2.2 Types of nodes </h3>\r
+<p>In the SUPERVISION module there are the following types of nodes: </p>\r
+<b>\r
+<ul>\r
+ <li>computation node,</li>\r
+ <li> loop node,</li>\r
+ <li> switch node,</li>\r
+ <li> GOTO node. </li>\r
+</ul>\r
+</b> \r
+<p>The dependance between different types of nodes is shown on the following picture: \r
+</p>\r
+<div align="center"><img src="nodestypes.jpg"> </div>\r
+<a name="2_2_1"></a><h4>2.2.1 Computation node </h4>\r
+<p>This node represents a computation algorithm in the graph structure. Nodes \r
+ of such type can present a service registered in the Component Catalog (<b>Factory \r
+ Node</b>) or an external service defined in Python script by user (<b>InLine node</b>). \r
+ Python function of InLine node can be edited in Supervision Graph edit mode. \r
+</p>\r
+<a name="2_2_2"></a><h4><b>2.2.2 Loop node</b> </h4>\r
+<p>Loop node is a kind of Control nodes. In fact two nodes represent Loop: \r
+<b>start</b> loop and <b>end</b> loop nodes. Nodes of such type are always InLine nodes. \r
+User have to supply this type of node by service, which will check conditions of end of loop. </p>\r
+\r
+<p>With that kind of nodes may be defined all kinds of loops:<br><br>\r
+\r
+\93for( initial condition(s) ; end condition(s) ; end loop code )\94 or <br><br>\r
+\r
+\93while( end condition )\94<br><br>\r
+\r
+etc\85</p>\r
+<p>Here you can see a simple example of Python functions set in a Loop node:</p>\r
+<pre><code>\r
+def Init(Index,Min,Max,Incr) : \r
+\r
+ if Min <= Max : \r
+\r
+ Index = Min \r
+\r
+ else : \r
+\r
+ Index = Max \r
+\r
+ return Index,Min,Max,Incr \r
+\r
+ \r
+\r
+def More(Index,Min,Max,Incr) : \r
+\r
+ if Index < Max : \r
+\r
+ DoLoop = 1 \r
+\r
+ else : \r
+\r
+ DoLoop = 0 \r
+\r
+ return DoLoop,Index,Min,Max,Incr \r
+\r
+ \r
+\r
+def Next(Index,Min,Max,Incr) : \r
+\r
+ Index = Index + Incr \r
+\r
+ return Index,Min,Max,Incr\r
+</code></pre>\r
+\r
+<a name="2_2_3"></a><h4>2.2.3 Switch node </h4>\r
+<p>Switch node is a kind of Control node. In fact two nodes present Switch: <b>start</b> Switch and <b>end</b> Switch.\r
+ Nodes of such type are always InLine nodes. You have to supply this type of node by service, which will perform switching. That's why nodes of such type can have at least two or more switch ports (Boolean), but only one switch port can have "True" value at a definite moment of graph execution.</p>\r
+ \r
+ <p> With that kind of node you can define all kinds of tests or switches :</p>\r
+\r
+<p>\93if( condition ) ; else if( condition ) \85 ; else\94 or<br><br>\r
+\r
+\93switch( variable ) ; case value \85; default\94.<br><br>\r
+\r
+Etc\85</p>\r
+<p>The associated Python function will have all input ports of the Switch node \r
+ as input arguments. And that function must return a value for all output ports. \r
+ A simple example of this Python function: </p>\r
+ <pre><code>\r
+ \r
+def Switch(x): \r
+\r
+ i1=0 \r
+\r
+ i2=0 \r
+\r
+ i3=0 \r
+\r
+ if x>13: \r
+\r
+ i1=1 \r
+\r
+ elif x==13: \r
+\r
+ i2=1 \r
+\r
+ else: \r
+\r
+ i3=1 \r
+\r
+ return i1,i2,i3 \r
+ </code></pre>\r
+<p>In this example <b>i1</b>, <b>i2</b>, <b>i3</b> parameters of the function correspond to Switch \r
+ ports of the node. So, depending on the result of execution of the initial condition \r
+ (in our case it's a comparison of the input parameter with an integer 13), one \r
+ of the switch ports will get the value 1. And this port will transmit further \r
+ dataflow to the corresponding node. </p>\r
+<a name="2_2_4"></a><h4>2.2.4 GOTO node </h4>\r
+<p>GOTO node represents a simple transmitter of data from one port into another. \r
+ This InLine node can be with service or without it. In the first case the data \r
+ received by a GOTO node will be processed by this function and only after that \r
+ it will be transferred to another node. GOTO nodes may have as many Input and \r
+ Output ports as it's necessary. </p>\r
+ <i><a href="#cont">Back to the contents</a></i>\r
+<a name="3"></a><h2>3. SUPERVISION module features and services </h2>\r
+<p>The functionality of the SUPERVISION module is provided by a set of classes which are combined into \r
+the <b>SUPERV</b> package.\r
+<p>The API reference of the SUPERVISION component can be found <a href="namespaceSUPERV.html">here</a>.</p>\r
+<a name="3_1"></a><h3>3.1 CNode class </h3>\r
+<p>This is a base class of the SUPERVISION module. It contains a set of methods allowing:</p>\r
+\r
+<ul>\r
+ <li>creating a <b>Computation node </b>and setting its parameters (Name, Author, Comments \r
+ etc.)</li>\r
+ <li>checking the current state of the node in the data flow</li>\r
+ <li>node execution follow-up</li>\r
+ <li>management of the components, which can be initialized for execution of calculations in the data flow. (For that purpose\r
+ CNode class inherits the methods of the <b>Engines:Container</b> class)</li>\r
+</ul>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1CNode.html">here</a>.</p>\r
+\r
+<a name="3_2"></a><h3>3.2 FNode class </h3>\r
+\r
+<p>This class is necessary for management of <b>Factory nodes</b> in the data flow. Besides the inherited methods it contains some methods allowing\r
+to define the component from the container, which will be called for execution of the calculation.</p>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1FNode.html">here</a>.</p>\r
+<a name="3_3"></a>\r
+<h3>3.3 INode class </h3>\r
+<p>This class is necessary for management of <b>Inline nodes</b> in the data flow. Besides the inherited methods it contains some methods allowing to set\r
+the Python function, which will be executed for performing calculations, as well as input and output parameters for the node.</p>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1INode.html">here</a>.</p>\r
+\r
+<a name="3_4"></a><h3>3.4 GNode class </h3>\r
+<p>This class is necessary for management of <b>GOTO nodes</b> in the data flow. Besides the inherited methods it contains some methods allowing to define\r
+the couple node, which will be linked to this one.</p>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1GNode.html">here</a>.</p>\r
+\r
+<a name="3_5"></a><h3>3.5 LNode class </h3>\r
+<p>This class is necessary for management of <b>Loop nodes</b> (or <b>Start Loop nodes</b>) in the data flow. Besides the inherited methods it contains some methods allowing to define\r
+the Python function, which will control the loop.</p>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1LNode.html">here</a>.</p>\r
+\r
+<a name="3_6"></a><h3>3.6 ELNode class </h3>\r
+<p>This class is necessary for management of <b>End Loop nodes</b> (or <b>start</b> Loop nodes) in the data flow.</p>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1ELNode.html">here</a>.</p>\r
+\r
+<a name="3_7"></a><h3>3.7 SNode class </h3>\r
+<p>This class is necessary for management of <b>Switch nodes</b> (or <b>Start Switch nodes</b>) in the data flow. </p>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1SNode.html">here</a>.</p>\r
+\r
+<a name="3_8"></a><h3>3.8 ESNode class </h3>\r
+<p>This class is necessary for management of <b>End Switch nodes</b> in the data flow. </p>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1ESNode.html">here</a>.</p>\r
+\r
+<a name="3_9"></a><h3>3.9 Graph class </h3>\r
+<p>This class is used for management of a data flow. It contains a set of methods, which allows:</p>\r
+<ul>\r
+ <li>creation of a data flow consisting of one or several different nodes</li>\r
+ <li>import/export of an existing data flow</li>\r
+ <li>execution of the data flow </li>\r
+ <li>follow-up of data flow execution</li>\r
+ <li>checking the state of the data flow</li>\r
+</ul>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1Graph.html">here</a>.</p>\r
+<a name="3_10"></a><h3>3.10 Link class </h3>\r
+<p>This class contains a set of methods used for representation and management of the links connecting nodes in a data flow. </p>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1Link.html">here</a>.</p>\r
+\r
+<a name="3_11"></a><h3>3.11 Value class </h3>\r
+<p>This class contains a set of methods used for management of the values which can be set in the ports of nodes. </p>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1Value.html">here</a>.</p>\r
+\r
+<a name="3_12"></a><h3>3.12 Port class </h3>\r
+<p>This class contains a set of methods used for management of the ports of the nodes in a data flow: </p>\r
+\r
+<ul>\r
+ <li>setting the attributes of a port</li>\r
+ <li>initialization of input ports with initial values</li>\r
+ <li>linking ports of different nodes</li>\r
+</ul>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1Port.html">here</a>.</p>\r
+\r
+<a name="3_13"></a><h3>3.13 SuperG class </h3>\r
+<p>The main class of the SUPERVISION ccomponent which is used for construction and initialization of a data flow. </p>\r
+<p>The API reference for this class can be found <a href="interfaceSUPERV_1_1SuperG.html">here</a>.</p>\r
+\r
+\r
+<i><a href="#cont">Back to the contents</a></i>\r
+</body>\r
+</html>\r
