doc/fr/tui_create_yacs.rst

   1 .. _tui_create_yacs:
   2
   3 Le schéma YACS
   4 ##############
   5
   6 .. index:: single: YACS
   7
   8 Les variables sont décrites dans :ref:`gui_create_yacs`.
   9
  10 Méthodes de la classe cas
  11 *************************
  12 Voir également dans :ref:`tui_create_case`.
  13
  14 +---------------------------------------------------------------+
  15 +---------------------------------------------------------------+
  16 | .. module:: CreateYACSSchema                                  |
  17 |                                                               |
  18 | **CreateYACSSchema(yacs_name, ScriptFile, DirName, MeshFile)**|
  19 |     Retourne une instance de la classe ``yacs`` après sa      |
  20 |     création                                                  |
  21 |                                                               |
  22 |     - ``yacs_name`` : le nom du schéma                        |
  23 |     - ``ScriptFile`` : le fichier du script python qui permet |
  24 |       de lancer le calcul à coupler avec l'adaptation de      |
  25 |       maillage                                                |
  26 |     - ``DirName`` : le répertoire où a lieu le calcul         |
  27 |     - ``MeshFile`` : le fichier MED contenant le tout premier |
  28 |       maillage de calcul                                      |
  29 +---------------------------------------------------------------+
  30
  31 Méthodes de la classe homard
  32 ****************************
  33
  34 +---------------------------------------------------------------+
  35 +---------------------------------------------------------------+
  36 | .. module:: GetYACS                                           |
  37 |                                                               |
  38 | **GetYACS(yacs_name)**                                        |
  39 |     Retourne l'instance de la classe ``yacs`` connue par      |
  40 |     son nom                                                   |
  41 |                                                               |
  42 |     - ``yacs_name`` : le nom du schéma                        |
  43 +---------------------------------------------------------------+
  44 | .. module:: GetAllYACSsName                                   |
  45 |                                                               |
  46 | **GetAllYACSsName()**                                         |
  47 |     Retourne la liste des noms de tous les schémas existant   |
  48 +---------------------------------------------------------------+
  49
  50
  51
  52 Méthodes de la classe YACS
  53 **************************
  54
  55 Généralités
  56 ===========
  57
  58 +---------------------------------------------------------------+
  59 +---------------------------------------------------------------+
  60 | .. module:: Write                                             |
  61 |                                                               |
  62 | **Write()**                                                   |
  63 |     Ecrit le schéma dans le fichier lié au schéma             |
  64 |     Par défaut, c'est le fichier ``schema.xml``, dans le      |
  65 |     répertoire du cas. Si ``WriteOnFile`` a été utilisé       |
  66 |     auparavant, l'écriture a lieu dans le nouveau fichier.    |
  67 |                                                               |
  68 |     Retourne un entier :                                      |
  69 |         * 0 : écriture réussie                                |
  70 |         * autre valeur : problème                             |
  71 +---------------------------------------------------------------+
  72 | .. module:: WriteOnFile                                       |
  73 |                                                               |
  74 | **WriteOnFile(file_xml)**                                     |
  75 |     Ecrit le schéma dans un fichier désigné.                  |
  76 |                                                               |
  77 |     - ``file_xml`` : nom du fichier xml du schéma             |
  78 |                                                               |
  79 |     Retourne un entier :                                      |
  80 |         * 0 : écriture réussie                                |
  81 |         * autre valeur : problème                             |
  82 +---------------------------------------------------------------+
  83 | .. module:: Delete                                            |
  84 |                                                               |
  85 | **Delete(option)**                                            |
  86 |     Detruit le schéma.                                        |
  87 |                                                               |
  88 |     - ``option`` : un entier précisant ce qui est fait du     |
  89 |       fichier xml du schéma                                   |
  90 |                                                               |
  91 |         * 0 : le fichier est conservé                         |
  92 |         * 1 : le fichier est détruit                          |
  93 |                                                               |
  94 |     Retourne un entier :                                      |
  95 |         * 0 : destruction réussie                             |
  96 |         * autre valeur : problème                             |
  97 +---------------------------------------------------------------+
  98
  99
 100 Informations sur le schéma
 101 ==========================
 102
 103 +---------------------------------------------------------------+
 104 +---------------------------------------------------------------+
 105 | .. module:: GetName                                           |
 106 |                                                               |
 107 | **GetName()**                                                 |
 108 |     Retourne le nom du schéma                                 |
 109 +---------------------------------------------------------------+
 110 | .. module:: SetType                                           |
 111 |                                                               |
 112 | **SetType(Type)**                                             |
 113 |     Définit le type de schéma.                                |
 114 |                                                               |
 115 |     - ``Type`` : le type de schéma                            |
 116 |                                                               |
 117 |         * 1 : constant                                        |
 118 |         * 2 : variable                                        |
 119 +---------------------------------------------------------------+
 120 | .. module:: GetType                                           |
 121 |                                                               |
 122 | **GetType()**                                                 |
 123 |     Retourne le type du schéma                                |
 124 +---------------------------------------------------------------+
 125 | .. module:: SetScriptFile                                     |
 126 |                                                               |
 127 | **SetScriptFile(script_file)**                                |
 128 |     Définit le fichier du script python de lancement du calcul|
 129 |                                                               |
 130 |     - ``script_file`` : le nom du fichier qui contient le     |
 131 |       le script python                                        |
 132 +---------------------------------------------------------------+
 133 | .. module:: GetScriptFile                                     |
 134 |                                                               |
 135 | **GetScriptFile()**                                           |
 136 |     Retourne le nom du fichier MED qui contient le script     |
 137 |     python                                                    |
 138 +---------------------------------------------------------------+
 139 | .. module:: SetDirName                                        |
 140 |                                                               |
 141 | **SetDirName(dir_name)**                                      |
 142 |     Définit le nom du répertoire de calcul                    |
 143 |                                                               |
 144 |     - ``dir_name`` : le nom du répertoire de calcul           |
 145 +---------------------------------------------------------------+
 146 | .. module:: GetDirName                                        |
 147 |                                                               |
 148 | **GetDirName()**                                              |
 149 |     Retourne le nom du répertoire de calcul                   |
 150 +---------------------------------------------------------------+
 151 | .. module:: SetMeshFile                                       |
 152 |                                                               |
 153 | **SetMeshFile(mesh_file)**                                    |
 154 |     Définit le fichier MED du tout premier maillage           |
 155 |                                                               |
 156 |     - ``mesh_file`` : le nom du fichier MED contenant le tout |
 157 |       premier maillage de calcul                              |
 158 +---------------------------------------------------------------+
 159 | .. module:: GetMeshFile                                       |
 160 |                                                               |
 161 | **GetMeshFile()**                                             |
 162 |     Retourne le nom du fichier MED du tout premier maillage   |
 163 |     de calcul                                                 |
 164 +---------------------------------------------------------------+
 165 | .. module:: SetXMLFile                                        |
 166 |                                                               |
 167 | **SetXMLFile(xml_file)**                                      |
 168 |     Définit le fichier xml pour l'écriture                    |
 169 |                                                               |
 170 |     - ``xml_file`` : le nom du fichier xml                    |
 171 +---------------------------------------------------------------+
 172 | .. module:: GetXMLFile                                        |
 173 |                                                               |
 174 | **GetXMLFile()**                                              |
 175 |     Retourne le nom du fichier xml                            |
 176 +---------------------------------------------------------------+
 177
 178
 179 Exemple
 180 *******
 181 La création d'un schéma se fait ainsi :
 182 ::
 183
 184     ScriptFile = "/scratch/D68518/Salome/HOMARD_SALOME/HOMARD_SRC/doc/files/ScriptAster.py"
 185     DirName = "/scratch/D68518/calcul"
 186     MeshFile = "/scratch/D68518/calcul/maill.00.med"
 187     YACS_0 = Case.CreateYACSSchema("YACS_0", ScriptFile, DirName, MeshFile)
 188
 189 On peut ensuite l'écrire dans un fichier :
 190 ::
 191
 192     YACSFile = "/scratch/D68518/calcul/yacs.xml"
 193     codret = YACS_0.WriteOnFile(YACSFile)
 194
 195 Saisie graphique correspondante
 196 *******************************
 197 Consulter :ref:`gui_create_yacs`
 198
 199
 200