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 ``schema.xml``, dans le   |
  64 |     répertoire du cas                                         |
  65 |                                                               |
  66 |     Retourne un entier :                                      |
  67 |         * 0 : écriture réussie                                |
  68 |         * autre valeur : problème                             |
  69 +---------------------------------------------------------------+
  70 | .. module:: WriteOnFile                                       |
  71 |                                                               |
  72 | **WriteOnFile(file_xml)**                                     |
  73 |     Ecrit le schéma dans un fichier désigné.                  |
  74 |                                                               |
  75 |     - ``file_xml`` : nom du fichier xml du schéma             |
  76 |                                                               |
  77 |     Retourne un entier :                                      |
  78 |         * 0 : écriture réussie                                |
  79 |         * autre valeur : problème                             |
  80 +---------------------------------------------------------------+
  81 | .. module:: Delete                                            |
  82 |                                                               |
  83 | **Delete(option)**                                            |
  84 |     Detruit le schéma.                                        |
  85 |                                                               |
  86 |     - ``option`` : un entier précisant ce qui est fait du     |
  87 |       fichier xml du schéma                                   |
  88 |                                                               |
  89 |         * 0 : le fichier est conservé                         |
  90 |         * 1 : le fichier est détruit                          |
  91 |                                                               |
  92 |     Retourne un entier :                                      |
  93 |         * 0 : destruction réussie                             |
  94 |         * autre valeur : problème                             |
  95 +---------------------------------------------------------------+
  96
  97
  98 Informations sur le schéma
  99 ==========================
 100
 101 +---------------------------------------------------------------+
 102 +---------------------------------------------------------------+
 103 | .. module:: GetName                                           |
 104 |                                                               |
 105 | **GetName()**                                                 |
 106 |     Retourne le nom du schéma                                 |
 107 +---------------------------------------------------------------+
 108 | .. module:: GetType                                           |
 109 |                                                               |
 110 | **GetType()**                                                 |
 111 |     Retourne le type du schéma                                |
 112 |                                                               |
 113 |         * 1 : statique                                        |
 114 |         * 2 : transitoire                                     |
 115 +---------------------------------------------------------------+
 116 | .. module:: SetScriptFile                                     |
 117 |                                                               |
 118 | **SetScriptFile(script_file)**                                |
 119 |     Définit le fichier du script python de lancement du calcul|
 120 |                                                               |
 121 |     - ``script_file`` : le nom du fichier qui contient le     |
 122 |       le script python                                        |
 123 +---------------------------------------------------------------+
 124 | .. module:: GetScriptFile                                     |
 125 |                                                               |
 126 | **GetScriptFile()**                                           |
 127 |     Retourne le nom du fichier MED qui contient le script     |
 128 |     python                                                    |
 129 +---------------------------------------------------------------+
 130 | .. module:: SetDirName                                        |
 131 |                                                               |
 132 | **SetDirName(dir_name)**                                      |
 133 |     Définit le nom du répertoire de calcul                    |
 134 |                                                               |
 135 |     - ``dir_name`` : le nom du répertoire de calcul           |
 136 +---------------------------------------------------------------+
 137 | .. module:: GetDirName                                        |
 138 |                                                               |
 139 | **GetDirName()**                                              |
 140 |     Retourne le nom du répertoire de calcul                   |
 141 +---------------------------------------------------------------+
 142 | .. module:: SetMeshFile                                       |
 143 |                                                               |
 144 | **SetMeshFile(mesh_file)**                                    |
 145 |     Définit le fichier MED du tout premier maillage           |
 146 |                                                               |
 147 |     - ``mesh_file`` : le nom du fichier MED contenant le tout |
 148 |       premier maillage de calcul                              |
 149 +---------------------------------------------------------------+
 150 | .. module:: GetMeshFile                                       |
 151 |                                                               |
 152 | **GetMeshFile()**                                             |
 153 |     Retourne le nom du fichier MED du tout premier maillage   |
 154 |     de calcul                                                 |
 155 +---------------------------------------------------------------+
 156
 157
 158 Exemple
 159 *******
 160 La création d'un schéma se fait ainsi :
 161 ::
 162
 163     ScriptFile = "/scratch/D68518/Salome/HOMARD_SALOME/HOMARD_SRC/doc/files/ScriptAster.py"
 164     DirName = "/scratch/D68518/calcul"
 165     MeshFile = "/scratch/D68518/calcul/maill.00.med"
 166     YACS_0 = Case.CreateYACSSchema("YACS_0", ScriptFile, DirName, MeshFile)
 167
 168 On peut ensuite l'écrire dans un fichier :
 169 ::
 170
 171     YACSFile = "/scratch/D68518/calcul/yacs.xml"
 172     codret = YACS_0.WriteOnFile(YACSFile)
 173
 174 Saisie graphique correspondante
 175 *******************************
 176 Consulter :ref:`gui_create_yacs`
 177
 178
 179