]> SALOME platform Git repositories - modules/homard.git/blob - src/HOMARD/HomardDriver.cxx
Salome HOME
Remplacement de mktemp par mkdtemp ou mkstemp.
[modules/homard.git] / src / HOMARD / HomardDriver.cxx
1 //  HOMARD HOMARD : implementation of HOMARD idl descriptions
2 //
3 // Copyright (C) 2011-2014  CEA/DEN, EDF R&D
4 //
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Lesser General Public
7 // License as published by the Free Software Foundation; either
8 // version 2.1 of the License, or (at your option) any later version.
9 //
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 // Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
18 //
19 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 //
21
22 // Pilote l'ecriture du fichier de configuration pour lancer l'execution de HOMARD
23
24 #include <cstring>
25 #ifndef WIN32
26 #include <unistd.h>
27 #endif
28 #include <sys/stat.h>
29
30 #include "HomardDriver.hxx"
31 #include "Utils_SALOME_Exception.hxx"
32 #include "utilities.h"
33
34 //=============================================================================
35 //=============================================================================
36 HomardDriver::HomardDriver(const std::string siter, const std::string siterp1):
37   _HOMARD_Exec( "" ), _NomDir( "" ), _NomFichierConfBase( "HOMARD.Configuration" ),
38   _NomFichierConf( "" ), _NomFichierDonn( "" ), _siter( "" ), _siterp1( "" ),
39   _Texte( "" ), _bLu( false )
40 {
41   MESSAGE("siter = "<<siter<<", siterp1 = "<<siterp1);
42 // Le repertoire ou se trouve l'executable HOMARD
43   std::string dir ;
44   if ( getenv("HOMARD_REP_EXE_PRIVATE") != NULL ) { dir = getenv("HOMARD_REP_EXE_PRIVATE") ; }
45   else                                            { dir = getenv("HOMARD_REP_EXE") ; }
46   MESSAGE("dir ="<<dir);
47 // L'executable HOMARD
48   std::string executable ;
49   if ( getenv("HOMARD_EXE_PRIVATE") != NULL ) { executable = getenv("HOMARD_EXE_PRIVATE") ; }
50   else                                        { executable = getenv("HOMARD_EXE") ; }
51   MESSAGE("executable ="<<executable);
52 // Memorisation du nom complet de l'executable HOMARD
53   _HOMARD_Exec = dir + "/" + executable ;
54   MESSAGE("==> _HOMARD_Exec ="<<_HOMARD_Exec) ;
55 //
56   _siter = siter ;
57   _siterp1 = siterp1 ;
58 }
59 //=============================================================================
60 //=============================================================================
61 HomardDriver::~HomardDriver()
62 {
63 }
64 //===============================================================================
65 // A. Generalites
66 //===============================================================================
67 void HomardDriver::TexteInit( const std::string DirCompute, const std::string LogFile, const std::string Langue )
68 {
69   MESSAGE("TexteInit, DirCompute ="<<DirCompute<<", LogFile ="<<LogFile);
70 //
71   _Texte  = "ListeStd \"" + LogFile + "\"\n" ;
72   _Texte += "RepeTrav \"" + DirCompute + "\"\n" ;
73   _Texte += "RepeInfo \"" + DirCompute + "\"\n" ;
74   _Texte += "Langue \"" + Langue + "\"\n" ;
75 //
76 }
77 //===============================================================================
78 void HomardDriver::TexteAdap( )
79 {
80   MESSAGE("TexteAdap");
81 //
82   _Texte += "Action   homa\n" ;
83   _Texte += "CCAssoci med\n" ;
84   _Texte += "ModeHOMA 1\n" ;
85   _Texte += "NumeIter " + _siter + "\n" ;
86 //
87 }
88 //===============================================================================
89 void HomardDriver::TexteInfo( int TypeBila, int NumeIter )
90 {
91   MESSAGE("TexteInit, TypeBila ="<<TypeBila);
92 //
93   _Texte += "ModeHOMA 2\n" ;
94   std::stringstream saux1 ;
95   saux1 << TypeBila ;
96   std::string saux2 = saux1.str() ;
97   _Texte += "TypeBila " + saux2 + "\n" ;
98   if ( NumeIter ==  0 )
99   {
100     _Texte += "NumeIter 0\n" ;
101     _Texte += "Action   info_av\n" ;
102     _Texte += "CCAssoci med\n" ;
103   }
104   else
105   {
106     _Texte += "NumeIter " + _siter + "\n" ;
107     _Texte += "Action   info_ap\n" ;
108     _Texte += "CCAssoci homard\n" ;
109   }
110 //
111 }
112 //===============================================================================
113 // B. Les maillages en entree et en sortie
114 //===============================================================================
115 void HomardDriver::TexteMaillage( const std::string NomMesh, const std::string MeshFile, int apres )
116 {
117   MESSAGE("TexteMaillage, NomMesh  = "<<NomMesh);
118   MESSAGE("TexteMaillage, MeshFile = "<<MeshFile);
119   MESSAGE("TexteMaillage, apres = "<<apres);
120   std::string saux ;
121   saux = "P1" ;
122   if ( apres < 1 ) { saux = "__" ; }
123
124   _Texte += "# Maillages Med " + saux + "\n" ;
125   _Texte += "CCNoMN" + saux + " \"" + NomMesh  + "\"\n" ;
126   _Texte += "CCMaiN" + saux + " \"" + MeshFile + "\"\n" ;
127 }
128
129 //===============================================================================
130 void HomardDriver::TexteMaillageHOMARD( const std::string Dir, const std::string liter, int apres )
131 {
132   MESSAGE("TexteMaillageHOMARD, Dir ="<<Dir<<", liter ="<<liter<<", apres ="<<apres);
133   std::string saux ;
134   if ( apres < 1 ) { saux = "__" ; }
135   else             { saux = "P1" ; }
136
137   _Texte += "# Maillage HOMARD " + liter + "\n" ;
138   _Texte += "HOMaiN" + saux + " Mai" + liter   + " \"" + Dir + "/maill." + liter   + ".hom.med\"\n" ;
139 }
140
141 //===============================================================================
142 // C. Le pilotage de l'adaptation
143 //===============================================================================
144 void HomardDriver::TexteConfRaffDera( int ConfType, int TypeAdap, int TypeRaff, int TypeDera )
145 {
146   MESSAGE("TexteConfRaffDera, ConfType ="<<ConfType);
147   MESSAGE("TexteConfRaffDera, TypeAdap ="<<TypeAdap<<", TypeRaff ="<<TypeRaff<<", TypeDera ="<<TypeDera);
148 //
149 // Type de conformite
150 //
151   std::string saux ;
152   switch (ConfType)
153   {
154     case -1: //
155     {
156       saux = "conforme_boites" ;
157       break;
158     }
159     case 1: //
160     {
161       saux = "conforme" ;
162       break;
163     }
164     case 2: //
165     {
166       saux = "non_conforme_1_noeud" ;
167       break;
168     }
169     case 3: //
170     {
171       saux = "non_conforme_1_arete" ;
172       break;
173     }
174     case 4: //
175     {
176       saux = "non_conforme_indicateur" ;
177       break;
178     }
179   }
180   _Texte += "# Type de conformite\nTypeConf " + saux + "\n" ;
181 //
182 // Type de raffinement/deraffinement
183 //
184   if ( TypeAdap == -1 )
185   {
186     if ( TypeRaff == 1 )
187     {
188       saux = "TypeRaff uniforme\n" ;
189     }
190     else
191     {
192       saux = "TypeRaff non\n" ;
193     }
194     if ( TypeDera == 1 )
195     {
196       saux += "TypeDera uniforme" ;
197     }
198     else
199     {
200       saux += "TypeDera non" ;
201     }
202   }
203   else
204   {
205     if ( TypeRaff == 1 )
206     {
207       saux = "TypeRaff libre\n" ;
208     }
209     else
210     {
211       saux = "TypeRaff non\n" ;
212     }
213     if ( TypeDera == 1 )
214     {
215       saux += "TypeDera libre" ;
216     }
217     else
218     {
219       saux += "TypeDera non" ;
220     }
221   }
222   _Texte += "# Type de raffinement/deraffinement\n" + saux + "\n" ;
223 //
224 //   MESSAGE("A la fin de HomardDriver::TexteConfRaffDera, _Texte ="<<_Texte);
225 }
226 //===============================================================================
227 void HomardDriver::TexteCompo( int NumeComp, const std::string NompCompo)
228 {
229   MESSAGE("TexteCompo, NumeComp = "<<NumeComp<<", NompCompo = "<<NompCompo);
230   _Texte +="CCCoChaI \"" + NompCompo + "\"\n" ;
231 }
232 //===============================================================================
233 void HomardDriver::TexteZone( int NumeZone, int ZoneType, int TypeUse, double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8 )
234 {
235   MESSAGE("TexteZone, NumeZone = "<<NumeZone<<", ZoneType = "<<ZoneType<<", TypeUse = "<<TypeUse);
236   MESSAGE("TexteZone, coor = "<< x0<<","<<x1<< ","<< x2<< ","<< x3<<","<<x4<<","<<x5<<","<<x6<<","<<x7<<","<<x8);
237 //
238   std::string saux, saux2 ;
239 //
240 // Type de zones
241 // On convertit le type de zone au sens du module HOMARD dans Salome, ZoneType, dans le
242 // type au sens de l'executable HOMARD, ZoneTypeHOMARD
243 // Attention a mettre le bon signe a ZoneTypeHOMARD :
244 //    >0 signifie que l'on raffinera les mailles contenues dans la zone,
245 //    <0 signifie que l'on deraffinera
246 //
247   int ZoneTypeHOMARD ;
248   if ( ZoneType >= 11 && ZoneType <= 13 ) { ZoneTypeHOMARD = 1 ; }
249   else if ( ZoneType >= 31 && ZoneType <= 33 ) { ZoneTypeHOMARD = 3 ; }
250   else if ( ZoneType >= 61 && ZoneType <= 63 ) { ZoneTypeHOMARD = 6 ; }
251   else { ZoneTypeHOMARD = ZoneType ; }
252 //
253   if ( TypeUse < 0 ) { ZoneTypeHOMARD = -ZoneTypeHOMARD ; }
254 //
255   std::stringstream saux1 ;
256   saux1 << NumeZone ;
257   saux = "#\n# Zone numero " + saux1.str() + "\n" ;
258 //
259   { std::stringstream saux1 ;
260     saux1 << NumeZone << " " << ZoneTypeHOMARD ;
261     saux += "ZoRaType " + saux1.str() + "\n" ;
262   }
263 //
264 // Cas du rectangle
265 //
266   if ( ZoneType == 11 ) // Z est constant X Homard <=> X Salome
267 //                                        Y Homard <=> Y Salome
268   {
269     saux += "#Rectangle\n" ;
270     { std::stringstream saux1 ;
271       saux1 << NumeZone << " " << x0 ;
272       saux += "ZoRaXmin " + saux1.str() + "\n" ;
273     }
274     { std::stringstream saux1 ;
275       saux1 << NumeZone << " " << x1 ;
276       saux += "ZoRaXmax " + saux1.str() + "\n" ;
277     }
278     { std::stringstream saux1 ;
279       saux1 << NumeZone << " " << x2 ;
280       saux += "ZoRaYmin " + saux1.str() + "\n" ;
281     }
282     { std::stringstream saux1 ;
283       saux1 << NumeZone << " " << x3 ;
284       saux += "ZoRaYmax " + saux1.str() + "\n" ;
285     }
286   }
287 //
288   else if ( ZoneType == 12 ) // X est constant X Homard <=> Y Salome
289 //                                             Y Homard <=> Z Salome
290   {
291     saux += "#Rectangle\n" ;
292     { std::stringstream saux1 ;
293       saux1 << NumeZone << " " << x2 ;
294       saux += "ZoRaXmin " + saux1.str() + "\n" ;
295     }
296     { std::stringstream saux1 ;
297       saux1 << NumeZone << " " << x3 ;
298       saux += "ZoRaXmax " + saux1.str() + "\n" ;
299     }
300     { std::stringstream saux1 ;
301       saux1 << NumeZone << " " << x4 ;
302       saux += "ZoRaYmin " + saux1.str() + "\n" ;
303     }
304     { std::stringstream saux1 ;
305       saux1 << NumeZone << " " << x5 ;
306       saux += "ZoRaYmax " + saux1.str() + "\n" ;
307     }
308   }
309 //
310   else if ( ZoneType == 13 ) // Y est constant X Homard <=> X Salome
311 //                                             Y Homard <=> Z Salome
312   {
313     saux += "#Rectangle\n" ;
314     { std::stringstream saux1 ;
315       saux1 << NumeZone << " " << x0 ;
316       saux += "ZoRaXmin " + saux1.str() + "\n" ;
317     }
318     { std::stringstream saux1 ;
319       saux1 << NumeZone << " " << x1 ;
320       saux += "ZoRaXmax " + saux1.str() + "\n" ;
321     }
322     { std::stringstream saux1 ;
323       saux1 << NumeZone << " " << x4 ;
324       saux += "ZoRaYmin " + saux1.str() + "\n" ;
325     }
326     { std::stringstream saux1 ;
327       saux1 << NumeZone << " " << x5 ;
328       saux += "ZoRaYmax " + saux1.str() + "\n" ;
329     }
330   }
331 //
332 // Cas du parallelepipede
333 //
334   else if ( ZoneType == 2 )
335   {
336     saux += "# Boite\n" ;
337     { std::stringstream saux1 ;
338       saux1 << NumeZone << " " << x0 ;
339       saux += "ZoRaXmin " + saux1.str() + "\n" ;
340     }
341     { std::stringstream saux1 ;
342       saux1 << NumeZone << " " << x1 ;
343       saux += "ZoRaXmax " + saux1.str() + "\n" ;
344     }
345     { std::stringstream saux1 ;
346       saux1 << NumeZone << " " << x2 ;
347       saux += "ZoRaYmin " + saux1.str() + "\n" ;
348     }
349     { std::stringstream saux1 ;
350       saux1 << NumeZone << " " << x3 ;
351       saux += "ZoRaYmax " + saux1.str() + "\n" ;
352     }
353     { std::stringstream saux1 ;
354       saux1 << NumeZone << " " << x4 ;
355       saux += "ZoRaZmin " + saux1.str() + "\n" ;
356     }
357     { std::stringstream saux1 ;
358       saux1 << NumeZone << " " << x5 ;
359       saux += "ZoRaZmax " + saux1.str() + "\n" ;
360     }
361   }
362 //
363 // Cas du disque
364 //
365   else if ( ZoneType == 31 || ZoneType == 61 )
366   {
367     saux += "# Sphere\n" ;
368     { std::stringstream saux1 ;
369       saux1 << NumeZone << " " << x0 ;
370       saux += "ZoRaXCen " + saux1.str() + "\n" ;
371     }
372     { std::stringstream saux1 ;
373       saux1 << NumeZone << " " << x1 ;
374       saux += "ZoRaYCen " + saux1.str() + "\n" ;
375     }
376     { std::stringstream saux1 ;
377       saux1 << NumeZone << " " << x6 ;
378       saux2 = saux1.str() ;
379       if ( ZoneType == 61 ) { saux += "ZoRaRayE " + saux2 + "\n" ; }
380       else                  { saux += "ZoRaRayo " + saux2 + "\n" ; }
381     }
382     if ( ZoneType == 61 )
383     { std::stringstream saux1 ;
384       saux1 << NumeZone << " " << x8 ;
385       saux += "ZoRaRayI " + saux1.str() + "\n" ;
386     }
387   }
388   else if ( ZoneType == 32 || ZoneType == 62 )
389   {
390     saux += "# Sphere\n" ;
391     { std::stringstream saux1 ;
392       saux1 << NumeZone << " " << x1 ;
393       saux += "ZoRaXCen " + saux1.str() + "\n" ;
394     }
395     { std::stringstream saux1 ;
396       saux1 << NumeZone << " " << x2 ;
397       saux += "ZoRaYCen " + saux1.str() + "\n" ;
398     }
399     { std::stringstream saux1 ;
400       saux1 << NumeZone << " " << x6 ;
401       saux2 = saux1.str() ;
402       if ( ZoneType == 62 ) { saux += "ZoRaRayE " + saux2 + "\n" ; }
403       else                  { saux += "ZoRaRayo " + saux2 + "\n" ; }
404     }
405     if ( ZoneType == 62 )
406     { std::stringstream saux1 ;
407       saux1 << NumeZone << " " << x8 ;
408       saux += "ZoRaRayI " + saux1.str() + "\n" ;
409     }
410   }
411   else if ( ZoneType == 33 || ZoneType == 63 )
412   {
413     saux += "# Sphere\n" ;
414     { std::stringstream saux1 ;
415       saux1 << NumeZone << " " << x0 ;
416       saux += "ZoRaXCen " + saux1.str() + "\n" ;
417     }
418     { std::stringstream saux1 ;
419       saux1 << NumeZone << " " << x2 ;
420       saux += "ZoRaYCen " + saux1.str() + "\n" ;
421     }
422     { std::stringstream saux1 ;
423       saux1 << NumeZone << " " << x6 ;
424       saux2 = saux1.str() ;
425       if ( ZoneType == 63 ) { saux += "ZoRaRayE " + saux2 + "\n" ; }
426       else                  { saux += "ZoRaRayo " + saux2 + "\n" ; }
427     }
428     if ( ZoneType == 63 )
429     { std::stringstream saux1 ;
430       saux1 << NumeZone << " " << x8 ;
431       saux += "ZoRaRayI " + saux1.str() + "\n" ;
432     }
433   }
434 //
435 // Cas de la sphere
436 //
437   else if ( ZoneType == 4 )
438   {
439     saux += "# Sphere\n" ;
440     { std::stringstream saux1 ;
441       saux1 << NumeZone << " " << x0 ;
442       saux += "ZoRaXCen " + saux1.str() + "\n" ;
443     }
444     { std::stringstream saux1 ;
445       saux1 << NumeZone << " " << x1 ;
446       saux += "ZoRaYCen " + saux1.str() + "\n" ;
447     }
448     { std::stringstream saux1 ;
449       saux1 << NumeZone << " " << x2 ;
450       saux += "ZoRaZCen " + saux1.str() + "\n" ;
451     }
452     { std::stringstream saux1 ;
453       saux1 << NumeZone << " " << x3 ;
454       saux += "ZoRaRayo " + saux1.str() + "\n" ;
455     }
456   }
457 //
458 // Cas du cylindre ou du tuyau
459 //
460   else if ( ZoneType == 5 || ZoneType == 7 )
461   {
462     if ( ZoneType == 5 ) { saux += "# Cylindre\n" ; }
463     else                 { saux += "# Tuyau\n" ; }
464     { std::stringstream saux1 ;
465       saux1 << NumeZone << " " << x0 ;
466       saux += "ZoRaXBas " + saux1.str() + "\n" ;
467     }
468     { std::stringstream saux1 ;
469       saux1 << NumeZone << " " << x1 ;
470       saux += "ZoRaYBas " + saux1.str() + "\n" ;
471     }
472     { std::stringstream saux1 ;
473       saux1 << NumeZone << " " << x2 ;
474       saux += "ZoRaZBas " + saux1.str() + "\n" ;
475     }
476     { std::stringstream saux1 ;
477       saux1 << NumeZone << " " << x3 ;
478       saux += "ZoRaXAxe " + saux1.str() + "\n" ;
479     }
480     { std::stringstream saux1 ;
481       saux1 << NumeZone << " " << x4 ;
482       saux += "ZoRaYAxe " + saux1.str() + "\n" ;
483     }
484     { std::stringstream saux1 ;
485       saux1 << NumeZone << " " << x5 ;
486       saux += "ZoRaZAxe " + saux1.str() + "\n" ;
487     }
488     { std::stringstream saux1 ;
489       saux1 << NumeZone << " " << x6 ;
490       saux2 = saux1.str() ;
491      if ( ZoneType == 5 ) { saux += "ZoRaRayo " + saux2 + "\n" ; }
492      else                 { saux += "ZoRaRayE " + saux2 + "\n" ; }
493     }
494     { std::stringstream saux1 ;
495       saux1 << NumeZone << " " << x7 ;
496       saux += "ZoRaHaut " + saux1.str() + "\n" ;
497     }
498     if ( ZoneType == 7 )
499     { std::stringstream saux1 ;
500       saux1 << NumeZone << " " << x8 ;
501       saux += "ZoRaRayI " + saux1.str() + "\n" ;
502     }
503   }
504 //
505   _Texte += saux + "#\n" ;
506 //
507 //   MESSAGE("A la fin de HomardDriver::TexteZone, _Texte ="<<_Texte);
508 }
509 //===============================================================================
510 void HomardDriver::TexteField( const std::string FieldName, const std::string FieldFile, int TimeStep, int Rank,
511                int TypeThR, double ThreshR, int TypeThC, double ThreshC,
512                int UsField, int UsCmpI )
513 {
514   MESSAGE("TexteField, FieldName = "<<FieldName<<", FieldFile = "<<FieldFile);
515   MESSAGE("TexteField, TimeStep = "<<TimeStep<<", Rank = "<<Rank);
516
517   std::string saux, saux2 ;
518 //
519 //
520   _Texte += "# Champ d'indicateurs\n" ;
521   _Texte += "CCIndica \"" + FieldFile  + "\"\n" ;
522   _Texte += "CCNoChaI \"" + FieldName  + "\"\n" ;
523
524 // Cas ou on prend le dernier pas de temps
525   if ( TimeStep == -2 )
526   { _Texte += "CCNumPTI Last\n" ; }
527 // Cas avec pas de temps
528   else if ( TimeStep >= 0 )
529   {
530     {
531       std::stringstream saux1 ;
532       saux1 << TimeStep ;
533       saux2 = saux1.str() ;
534       _Texte += "CCNumPTI " + saux2  + "\n" ;
535     }
536     if ( Rank >= 0 )
537     {
538       std::stringstream saux1 ;
539       saux1 << Rank ;
540       saux2 = saux1.str() ;
541       _Texte += "CCNumOrI " + saux2  + "\n" ;
542     }
543   }
544 //
545   saux = " " ;
546   if ( TypeThR == 1 )
547   { saux = "Hau" ; }
548   if ( TypeThR == 2 )
549   { saux = "HRe" ; }
550   if ( TypeThR == 3 )
551   { saux = "HPE" ; }
552   if ( TypeThR == 4 )
553   { saux = "HMS" ; }
554   if ( saux != " " )
555   {
556     std::stringstream saux1 ;
557     saux1 << ThreshR ;
558     _Texte += "Seuil" + saux + " " + saux1.str()  + "\n" ;
559   }
560 //
561   saux = " " ;
562   if ( TypeThC == 1 )
563   { saux = "Bas" ; }
564   if ( TypeThC == 2 )
565   { saux = "BRe" ; }
566   if ( TypeThC == 3 )
567   { saux = "BPE" ; }
568   if ( TypeThC == 4 )
569   { saux = "BMS" ; }
570   if ( saux != " " )
571   {
572     std::stringstream saux1 ;
573     saux1 << ThreshC ;
574     _Texte += "Seuil" + saux + " " + saux1.str()  + "\n" ;
575   }
576 //
577   saux = " " ;
578   if ( UsField == 0 )
579   { saux = "MAILLE" ; }
580   if ( UsField == 1 )
581   { saux = "SAUT" ; }
582   if ( saux != " " )
583   {
584     _Texte += "CCModeFI " + saux  + "\n" ;
585   }
586 //
587   saux = " " ;
588   if ( UsCmpI == 0 )
589   { saux = "L2" ; }
590   if ( UsCmpI == 1 )
591   { saux = "INFINI" ; }
592   if ( UsCmpI == 2 )
593   { saux = "RELATIF" ; }
594   if ( saux != " " )
595   {
596     _Texte += "CCUsCmpI " + saux  + "\n" ;
597   }
598 }
599 //===============================================================================
600 void HomardDriver::TexteGroup( const std::string GroupName )
601 {
602   MESSAGE("TexteGroup, GroupName = "<<GroupName);
603 //
604   _Texte += "CCGroAda \"" + GroupName  + "\"\n" ;
605 //
606 }
607 //===============================================================================
608 // D. Les frontieres
609 //===============================================================================
610 void HomardDriver::TexteBoundaryOption( int BoundaryOption )
611 {
612   MESSAGE("TexteBoundaryOption, BoundaryOption = "<<BoundaryOption);
613 //
614 // Type de suivi de frontiere
615 //
616   std::stringstream saux1 ;
617   saux1 << BoundaryOption ;
618   std::string saux = saux1.str() ;
619   _Texte += "SuivFron " + saux + "\n" ;
620 //
621 }
622 //===============================================================================
623 void HomardDriver::TexteBoundaryDi(  const std::string MeshName, const std::string MeshFile )
624 {
625   MESSAGE("TexteBoundaryDi, MeshName  = "<<MeshName);
626   MESSAGE("TexteBoundaryDi, MeshFile  = "<<MeshFile);
627 //
628   _Texte += "#\n# Frontiere discrete\n" ;
629   _Texte += "CCNoMFro \"" + MeshName + "\"\n" ;
630   _Texte += "CCFronti \"" + MeshFile + "\"\n" ;
631 //
632 }
633 //===============================================================================
634 void HomardDriver::TexteBoundaryDiGr(  const std::string GroupName )
635 {
636   MESSAGE("TexteBoundaryDiGr, GroupName  = "<<GroupName);
637 //
638   _Texte += "CCGroFro \"" + GroupName + "\"\n" ;
639 //
640 }
641 //===============================================================================
642 void HomardDriver::TexteBoundaryAn( const std::string NameBoundary, int NumeBoundary, int BoundaryType, double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7 )
643 {
644   MESSAGE("TexteBoundaryAn, NameBoundary = "<<NameBoundary);
645 //   MESSAGE("TexteBoundaryAn, NumeBoundary = "<<NumeBoundary);
646   MESSAGE("TexteBoundaryAn, BoundaryType = "<<BoundaryType);
647 //   MESSAGE("TexteBoundaryAn, coor         = "<< x0<<","<<x1<< ","<< x2<< ","<< x3<<","<<x4<<","<<x5<<","<<x6","<<x7);
648 //
649   std::string saux, saux2 ;
650 //
651 // Commentaires
652 //
653   std::stringstream saux1 ;
654   saux1 << NumeBoundary ;
655   saux2 = saux1.str() ;
656   saux = "#\n# Frontiere numero " + saux2 + "\n" ;
657   if ( BoundaryType == 1 )
658   { saux += "# Cylindre\n" ; }
659   if ( BoundaryType == 2 )
660   { saux += "# Sphere\n" ; }
661   if ( BoundaryType == 3 || BoundaryType == 4 )
662   { saux += "# Cone\n" ; }
663   if ( BoundaryType == 5 )
664   { saux += "# Tore\n" ; }
665 //
666 // Le nom de la frontiere
667 //
668   { std::stringstream saux1 ;
669     saux1 << NumeBoundary ;
670     saux += "FANom " + saux1.str() + " \"" + NameBoundary + "\"\n" ;
671   }
672 //
673 // Type de frontiere
674 //
675   { std::stringstream saux1 ;
676     saux1 << NumeBoundary << " " << BoundaryType ;
677     saux += "FAType " + saux1.str() + "\n" ;
678   }
679 //
680 // Cas du cylindre
681 //
682   if ( BoundaryType == 1 )
683   {
684     { std::stringstream saux1 ;
685       saux1 << NumeBoundary << " " << x0 ;
686       saux2 = saux1.str() ;
687       saux += "FAXCen " + saux1.str() + "\n" ;
688     }
689     { std::stringstream saux1 ;
690       saux1 << NumeBoundary << " " << x1 ;
691       saux += "FAYCen " + saux1.str() + "\n" ;
692     }
693     { std::stringstream saux1 ;
694       saux1 << NumeBoundary << " " << x2 ;
695       saux += "FAZCen " + saux1.str() + "\n" ;
696     }
697     { std::stringstream saux1 ;
698       saux1 << NumeBoundary << " " << x3 ;
699       saux += "FAXAxe " + saux1.str() + "\n" ;
700     }
701     { std::stringstream saux1 ;
702       saux1 << NumeBoundary << " " << x4 ;
703       saux += "FAYAxe " + saux1.str() + "\n" ;
704     }
705     { std::stringstream saux1 ;
706       saux1 << NumeBoundary << " " << x5 ;
707       saux += "FAZAxe " + saux1.str() + "\n" ;
708     }
709     { std::stringstream saux1 ;
710       saux1 << NumeBoundary << " " << x6 ;
711       saux += "FARayon " + saux1.str() + "\n" ;
712     }
713  }
714 //
715 // Cas de la sphere
716 //
717   else if ( BoundaryType == 2 )
718   {
719     { std::stringstream saux1 ;
720       saux1 << NumeBoundary << " " << x0 ;
721       saux += "FAXCen " + saux1.str() + "\n" ;
722     }
723     { std::stringstream saux1 ;
724       saux1 << NumeBoundary << " " << x1 ;
725       saux += "FAYCen " + saux1.str() + "\n" ;
726     }
727     { std::stringstream saux1 ;
728       saux1 << NumeBoundary << " " << x2 ;
729       saux += "FAZCen " + saux1.str() + "\n" ;
730     }
731     { std::stringstream saux1 ;
732       saux1 << NumeBoundary << " " << x3 ;
733       saux += "FARayon " + saux1.str() + "\n" ;
734     }
735   }
736 //
737 // Cas du cone defini par un axe et un angle
738 //
739   if ( BoundaryType == 3 )
740   {
741     { std::stringstream saux1 ;
742       saux1 << NumeBoundary << " " << x0 ;
743       saux += "FAXAxe " + saux1.str() + "\n" ;
744     }
745     { std::stringstream saux1 ;
746       saux1 << NumeBoundary << " " << x1 ;
747       saux += "FAYAxe " + saux1.str() + "\n" ;
748     }
749     { std::stringstream saux1 ;
750       saux1 << NumeBoundary << " " << x2 ;
751       saux += "FAZAxe " + saux1.str() + "\n" ;
752     }
753     { std::stringstream saux1 ;
754       saux1 << NumeBoundary << " " << x3 ;
755       saux += "FAAngle " + saux1.str() + "\n" ;
756     }
757     { std::stringstream saux1 ;
758       saux1 << NumeBoundary << " " << x4 ;
759       saux += "FAXCen " + saux1.str() + "\n" ;
760     }
761     { std::stringstream saux1 ;
762       saux1 << NumeBoundary << " " << x5 ;
763       saux += "FAYCen " + saux1.str() + "\n" ;
764     }
765     { std::stringstream saux1 ;
766       saux1 << NumeBoundary << " " << x6 ;
767       saux += "FAZCen " + saux1.str() + "\n" ;
768     }
769  }
770 //
771 // Cas du cone defini par les 2 rayons
772 //
773   if ( BoundaryType == 4 )
774   {
775     { std::stringstream saux1 ;
776       saux1 << NumeBoundary << " " << x0 ;
777       saux += "FAXCen " + saux1.str() + "\n" ;
778     }
779     { std::stringstream saux1 ;
780       saux1 << NumeBoundary << " " << x1 ;
781       saux += "FAYCen " + saux1.str() + "\n" ;
782     }
783     { std::stringstream saux1 ;
784       saux1 << NumeBoundary << " " << x2 ;
785       saux += "FAZCen " + saux1.str() + "\n" ;
786     }
787     { std::stringstream saux1 ;
788       saux1 << NumeBoundary << " " << x3 ;
789       saux += "FARayon " + saux1.str() + "\n" ;
790     }
791     { std::stringstream saux1 ;
792       saux1 << NumeBoundary << " " << x4 ;
793       saux += "FAXCen2 " + saux1.str() + "\n" ;
794     }
795     { std::stringstream saux1 ;
796       saux1 << NumeBoundary << " " << x5 ;
797       saux += "FAYCen2 " + saux1.str() + "\n" ;
798     }
799     { std::stringstream saux1 ;
800       saux1 << NumeBoundary << " " << x6 ;
801       saux += "FAZCen2 " + saux1.str() + "\n" ;
802     }
803     { std::stringstream saux1 ;
804       saux1 << NumeBoundary << " " << x7 ;
805       saux += "FARayon2 " + saux1.str() + "\n" ;
806     }
807  }
808 //
809 // Cas du tore
810 //
811   if ( BoundaryType == 5 )
812   {
813     { std::stringstream saux1 ;
814       saux1 << NumeBoundary << " " << x0 ;
815       saux2 = saux1.str() ;
816       saux += "FAXCen " + saux1.str() + "\n" ;
817     }
818     { std::stringstream saux1 ;
819       saux1 << NumeBoundary << " " << x1 ;
820       saux += "FAYCen " + saux1.str() + "\n" ;
821     }
822     { std::stringstream saux1 ;
823       saux1 << NumeBoundary << " " << x2 ;
824       saux += "FAZCen " + saux1.str() + "\n" ;
825     }
826     { std::stringstream saux1 ;
827       saux1 << NumeBoundary << " " << x3 ;
828       saux += "FAXAxe " + saux1.str() + "\n" ;
829     }
830     { std::stringstream saux1 ;
831       saux1 << NumeBoundary << " " << x4 ;
832       saux += "FAYAxe " + saux1.str() + "\n" ;
833     }
834     { std::stringstream saux1 ;
835       saux1 << NumeBoundary << " " << x5 ;
836       saux += "FAZAxe " + saux1.str() + "\n" ;
837     }
838     { std::stringstream saux1 ;
839       saux1 << NumeBoundary << " " << x6 ;
840       saux += "FARayon  " + saux1.str() + "\n" ;
841     }
842     { std::stringstream saux1 ;
843       saux1 << NumeBoundary << " " << x7 ;
844       saux += "FARayon2 " + saux1.str() + "\n" ;
845     }
846  }
847 //
848   _Texte += saux + "#\n" ;
849 //
850 }
851 //===============================================================================
852 void HomardDriver::TexteBoundaryAnGr( const std::string NameBoundary, int NumeBoundary, const std::string GroupName )
853 {
854   MESSAGE("TexteBoundaryAnGr, NameBoundary  = "<<NameBoundary);
855 //   MESSAGE("TexteBoundaryAnGr, NumeBoundary  = "<<NumeBoundary);
856 //   MESSAGE("TexteBoundaryAnGr, GroupName  = "<<GroupName);
857 //
858 // Commentaires
859 //
860   std::string saux, saux2 ;
861   std::stringstream saux1 ;
862   saux1 << NumeBoundary ;
863   saux2 = saux1.str() ;
864   saux = "#\n# Lien Frontiere/Groupe numero " + saux2 + "\n" ;
865 //
866   saux += "FGNomFro " + saux2 + " \"" + NameBoundary + "\"\n" ;
867   saux += "FGNomGro " + saux2 + " \"" + GroupName + "\"\n" ;
868 //
869   _Texte += saux + "#\n" ;
870 //
871 }
872 //===============================================================================
873 // E. Les interpolations
874 //===============================================================================
875 // Les fichiers d'entree et de sortie des champs a interpoler
876 void HomardDriver::TexteFieldInterp( const std::string FieldFile, const std::string MeshFile )
877 {
878   MESSAGE("TexteFieldInterp, FieldFile = "<<FieldFile<<", MeshFile = "<<MeshFile);
879 //
880   _Texte += "#\n# Interpolations des champs\n" ;
881 //
882 // Fichier en entree
883   _Texte += "CCSolN__ \"" + FieldFile + "\"\n" ;
884 // Fichier en sortie
885   _Texte += "CCSolNP1 \"" + MeshFile  + "\"\n" ;
886 //
887 //  std::cerr << "A la fin de TexteFieldInterp _Texte ="<<_Texte << std::endl;
888 }
889 //===============================================================================
890 // Tous les champs sont a interpoler
891 void HomardDriver::TexteFieldInterpAll( )
892 {
893   MESSAGE("TexteFieldInterpAll");
894 //
895   _Texte += "CCChaTou oui\n" ;
896 }
897 //===============================================================================
898 // Ecrit les caracteristiques de chaque interpolation sous la forme :
899 //   CCChaNom 1 "DEPL"     ! Nom du 1er champ a interpoler
900 //   CCChaTIn 1 0          ! Mode d'interpolation : automatique
901 //   CCChaNom 2 "VOLUME"   ! Nom du 2nd champ a interpoler
902 //   CCChaTIn 2 1          ! Mode d'interpolation : une variable extensive
903 //   CCChaPdT 2 14         ! Pas de temps 14
904 //   CCChaNuO 2 14         ! Numero d'ordre 14
905 //   etc.
906 //
907 // NumeChamp : numero d'ordre du champ a interpoler
908 // FieldName : nom du champ
909 // TypeInterp : type d'interpolation
910 // TimeStep : pas de temps retenu (>0 si pas de precision)
911 // Rank : numero d'ordre retenu
912 //
913 void HomardDriver::TexteFieldInterpNameType( int NumeChamp, const std::string FieldName, const std::string TypeInterp, int TimeStep, int Rank)
914 {
915   MESSAGE("TexteFieldInterpNameType, NumeChamp = "<<NumeChamp<<", FieldName = "<<FieldName<<", TypeInterp = "<<TypeInterp);
916   MESSAGE("TexteFieldInterpNameType, TimeStep = "<<TimeStep<<", Rank = "<<Rank);
917 // Numero d'ordre du champ a interpoler
918   std::stringstream saux1 ;
919   saux1 << NumeChamp ;
920   std::string saux = saux1.str() ;
921 // Nom du champ
922   _Texte +="CCChaNom " + saux + " \"" + FieldName + "\"\n" ;
923 // Type d'interpolation pour le champ
924   _Texte +="CCChaTIn " + saux + " " + TypeInterp + "\n" ;
925 //
926   if ( TimeStep >= 0 )
927   {
928     {
929       std::stringstream saux1 ;
930       saux1 << TimeStep ;
931       _Texte += "CCChaPdT " + saux + " " + saux1.str()  + "\n" ;
932     }
933     {
934       std::stringstream saux1 ;
935       saux1 << Rank ;
936       _Texte += "CCChaNuO " + saux + " " + saux1.str()  + "\n" ;
937     }
938   }
939 }
940 //===============================================================================
941 // F. Les options avancees
942 //===============================================================================
943 void HomardDriver::TexteAdvanced( int Pyram, int NivMax, double DiamMin, int AdapInit, int LevelOutput )
944 {
945   MESSAGE("TexteAdvanced, Pyram ="<<Pyram<<", NivMax ="<<NivMax<<", DiamMin ="<<DiamMin<<", AdapInit ="<<AdapInit<<", LevelOutput ="<<LevelOutput);
946
947   if ( Pyram > 0 )
948   {
949     _Texte += "# Autorisation de pyramides dans le maillage initial\n" ;
950     _Texte += "TypeElem ignore_pyra\n" ;
951   }
952   if ( NivMax > 0 )
953   {
954     _Texte += "# Niveaux extremes\n" ;
955     { std::stringstream saux1 ;
956       saux1 << NivMax ;
957       _Texte += "NiveauMa " + saux1.str() + "\n" ;
958     }
959   }
960   if ( DiamMin > 0 )
961   {
962     _Texte += "# Diametre minimal\n" ;
963     { std::stringstream saux1 ;
964       saux1 << DiamMin ;
965       _Texte += "DiametMi " + saux1.str()  + "\n" ;
966     }
967   }
968   if ( AdapInit != 0 )
969   {
970     if ( AdapInit > 0 )
971     { _Texte += "# Raffinement" ; }
972     else
973     { _Texte += "# Deraffinement" ; }
974     _Texte += " des regions sans indicateur\n" ;
975     { std::stringstream saux1 ;
976       saux1 << AdapInit ;
977       _Texte += "AdapInit " + saux1.str() + "\n" ;
978     }
979   }
980   if ( LevelOutput != 0 )
981   {
982     _Texte += "# Sortie des niveaux de raffinement\n" ;
983     _Texte += "NCNiveau NIVEAU\n" ;
984   }
985 }
986 //===============================================================================
987 // G. Les messages
988 //===============================================================================
989 void HomardDriver::TexteInfoCompute( int MessInfo )
990 {
991   MESSAGE("TexteAdvanced, MessInfo ="<<MessInfo);
992
993   if ( MessInfo != 0 )
994   {
995      _Texte += "# Messages d'informations\n" ;
996     { std::stringstream saux1 ;
997       saux1 << MessInfo ;
998       _Texte += "MessInfo " + saux1.str()  + "\n" ;
999     }
1000    }
1001 }
1002 //===============================================================================
1003 void HomardDriver::CreeFichier( )
1004 {
1005 //
1006   if ( _siter != _siterp1 )
1007   { _NomFichierConf = _NomFichierConfBase + "." + _siter + ".vers." + _siterp1 ; }
1008   else
1009   { _NomFichierConf = _NomFichierConfBase + "." + _siter + ".info" ; }
1010 //
1011   std::ofstream Fic(_NomFichierConf.c_str(), std::ios::out ) ;
1012   if (Fic.is_open() == true) { Fic << _Texte << std::endl ; }
1013   Fic.close() ;
1014 //
1015 }
1016 //===============================================================================
1017 // Creation du fichier de donnees pour l'information
1018 //===============================================================================
1019 void HomardDriver::CreeFichierDonn( )
1020 {
1021 //
1022   MESSAGE("CreeFichierDonn");
1023   _NomFichierDonn = "info.donn" ;
1024 //
1025   std::string data ;
1026   data  = "0\n" ;
1027   data += "0\n" ;
1028   data += "q\n" ;
1029   std::ofstream Fic(_NomFichierDonn.c_str(), std::ios::out ) ;
1030   if (Fic.is_open() == true) { Fic << data << std::endl ; }
1031   Fic.close() ;
1032 //
1033 }
1034 //===============================================================================
1035 int HomardDriver::ExecuteHomard(int option)
1036 {
1037   MESSAGE("ExecuteHomard, avec option = "<<option);
1038   std::string commande ;
1039   int codret ;
1040 // Copie des Fichiers HOMARD
1041   commande = "cp " + _NomFichierConf + " " + _NomFichierConfBase ;
1042   codret = system(commande.c_str()) ;
1043
1044 // Execution de HOMARD
1045   if ( codret == 0)
1046   {
1047     commande = _HOMARD_Exec.c_str() ;
1048     if ( _NomFichierDonn != "" ) { commande += " < " + _NomFichierDonn ; }
1049     codret = system(commande.c_str());
1050     if ( codret != 0) { MESSAGE ( "Erreur en executant HOMARD : " << codret ); };
1051     _NomFichierDonn = "" ;
1052   };
1053   return codret ;
1054 }