]> SALOME platform Git repositories - modules/smesh.git/blob - src/Tools/MeshCut/MeshCut_Utils.cxx
Salome HOME
f8d26b366916beb9d89a2bbc2826855cedabb714
[modules/smesh.git] / src / Tools / MeshCut / MeshCut_Utils.cxx
1 // Copyright (C) 2006-2016  EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 #include "MeshCut_Utils.hxx"
21
22 #include <iostream>
23 #include <string>
24 #include <sstream>
25 #include <cstdlib>
26 #include <cstring>
27 #include <ctime>
28 #include <algorithm>
29
30 using namespace std;
31 using namespace MESHCUT;
32
33 //string pathUsers = (string) "/var/www/XMeshLab/users/";
34
35 bool MESHCUT::estUnTypeMaille(std::string S)
36 {
37   if (S == (string) "POI1" || S == (string) "SEG2" || S == (string) "SEG3" || S == (string) "TRIA3" || S
38       == (string) "TRIA6" || S == (string) "QUAD4" || S == (string) "QUAD8" || S == (string) "QUAD9" || S
39       == (string) "TETRA4" || S == (string) "TETRA10" || S == (string) "PYRAM5" || S == (string) "PYRAM13" || S
40       == (string) "PENTA6" || S == (string) "PENTA15" || S == (string) "HEXA8" || S == (string) "HEXA20" || S
41       == (string) "HEXA27")
42     return true;
43   else
44     return false;
45 }
46
47 void MESHCUT::ERREUR(const char* msg)
48 {
49   cout << endl << "====== ERROR ====== " << msg << endl << endl;
50   exit(-1);
51 }
52
53 char* MESHCUT::string2char(std::string str)
54 {
55   // créer le buffer pour copier la chaîne
56   size_t size = str.size() + 1;
57   char* buffer = new char[size];
58   // copier la chaîne
59   strncpy(buffer, str.c_str(), size);
60
61   // libérer la mémoire
62   //delete [] buffer;
63
64   return buffer;
65 }
66
67 std::string MESHCUT::int2string(int k)
68 {
69   std::stringstream oss;
70   oss << k;
71   return oss.str(); //  oss.seekp (ios_base::beg);
72 }
73
74 float MESHCUT::char2float(const char* ch)
75 {
76   return atof(ch);
77 }
78
79 std::string MESHCUT::float2string(float f)
80 {
81   stringstream buf;
82   buf << fixed << f;
83   string s = buf.str();
84   return s;
85 }
86
87 bool MESHCUT::appartient(std::string e, std::string tableau[], int taille)
88 {
89   for (int i = 0; i < taille; i++)
90     if (tableau[i] == e)
91       return true;
92   return false;
93 }
94
95 float MESHCUT::arrondi(float x)
96 {
97   if (x > 0 && x < 1.0e-5)
98     return 0;
99   else if (x < 0 && x > -1.0e-5)
100     return 0;
101   else
102     return x;
103 }
104
105 int MESHCUT::numNoeudPointe(std::string b1, std::string b2, std::string b3)
106 {
107   if (b1 == "1" && b2 == "1" && b3 == "2")
108     return 2;
109   else if (b1 == "1" && b2 == "2" && b3 == "1")
110     return 1;
111   else if (b1 == "1" && b2 == "2" && b3 == "2")
112     return 2;
113   else if (b1 == "2" && b2 == "1" && b3 == "1")
114     return 3;
115   else if (b1 == "2" && b2 == "1" && b3 == "2")
116     return 3;
117   else if (b1 == "2" && b2 == "2" && b3 == "1")
118     return 1;
119   else
120     return -1;
121 }
122
123 std::string MESHCUT::strip(std::string S)
124 {
125   if (S.empty())
126     return S;
127   int startIndex = S.find_first_not_of(" ");
128   int endIndex = S.find_last_not_of(" ");
129   return S.substr(startIndex, (endIndex - startIndex + 1));
130 }
131
132 std::string MESHCUT::entierSur10_g(int i)
133 {
134   if (i > 999999999)
135     ERREUR("trying to write a number superior to 999999999 on more than 10 chars");
136   if (i < 10)
137     return int2string(i) + (string) "         ";
138   else if (i < 100)
139     return int2string(i) + (string) "        ";
140   else if (i < 1000)
141     return int2string(i) + (string) "       ";
142   else if (i < 10000)
143     return int2string(i) + (string) "      ";
144   else if (i < 100000)
145     return int2string(i) + (string) "     ";
146   else if (i < 1000000)
147     return int2string(i) + (string) "    ";
148   else if (i < 10000000)
149     return int2string(i) + (string) "   ";
150   else if (i < 100000000)
151     return int2string(i) + (string) "  ";
152   else if (i < 1000000000)
153     return int2string(i) + (string) " ";
154   else
155     return int2string(i);
156 }
157
158 std::string MESHCUT::entierSur10_d(int i)
159 {
160   if (i > 999999999)
161     ERREUR("trying to write a number superior to 999999999 on more than 10 chars");
162   if (i < 10)
163     return (string) "         " + int2string(i);
164   else if (i < 100)
165     return (string) "        " + int2string(i);
166   else if (i < 1000)
167     return (string) "       " + int2string(i);
168   else if (i < 10000)
169     return (string) "      " + int2string(i);
170   else if (i < 100000)
171     return (string) "     " + int2string(i);
172   else if (i < 1000000)
173     return (string) "    " + int2string(i);
174   else if (i < 10000000)
175     return (string) "   " + int2string(i);
176   else if (i < 100000000)
177     return (string) "  " + int2string(i);
178   else if (i < 1000000000)
179     return (string) " " + int2string(i);
180   else
181     return int2string(i);
182 }
183
184 std::string MESHCUT::typeEnsight(std::string type)
185 {
186   if (type == (string) "POI1")
187     return (string) "point";
188   else if (type == (string) "SEG2")
189     return (string) "bar2";
190   else if (type == (string) "SEG3")
191     return (string) "bar2";// ATTENTION, triche!
192   else if (type == (string) "TRIA3")
193     return (string) "tria3";
194   else if (type == (string) "TRIA6")
195     return (string) "tria3";// ATTENTION, triche!
196   else if (type == (string) "QUAD4")
197     return (string) "quad4";
198   else if (type == (string) "QUAD8")
199     return (string) "quad4"; // ATTENTION, triche!
200   else if (type == (string) "QUAD9")
201     ERREUR("Type QUAD9 not supported by Ensight");
202   else if (type == (string) "TETRA4")
203     return (string) "tetra4";
204   else if (type == (string) "TETRA10")
205     return (string) "tetra4"; // ATTENTION, triche!
206   else if (type == (string) "PYRAM5")
207     return (string) "pyramid5";
208   else if (type == (string) "PYRAM13")
209     return (string) "pyramid5"; // ATTENTION, triche!
210   else if (type == (string) "PENTA6")
211     return (string) "penta6";
212   else if (type == (string) "PENTA15")
213     return (string) "penta6"; // ATTENTION, triche!
214   else if (type == (string) "HEXA8")
215     return (string) "hexa8";
216   else if (type == (string) "HEXA20")
217     return (string) "hexa8"; // ATTENTION, triche!
218   else if (type == (string) "HEXA27")
219     ERREUR("Type HEXA27 not supported by Ensight");
220   else
221     ERREUR("Type of element not accepted (method \"typeEnsight\"");
222   return (string) "";
223 }
224
225 int MESHCUT::Nnoeuds(TYPE_MAILLE type)
226 {
227   switch (type)
228   {
229     case POI1:
230       {
231         return 1;
232         break;
233       }
234     case SEG2:
235       {
236         return 2;
237         break;
238       }
239     case SEG3:
240       {
241         return 3;
242         break;
243       }
244     case TRIA3:
245       {
246         return 3;
247         break;
248       }
249     case TRIA6:
250       {
251         return 6;
252         break;
253       }
254     case QUAD4:
255       {
256         return 4;
257         break;
258       }
259     case QUAD8:
260       {
261         return 8;
262         break;
263       }
264       //case QUAD9:                   { return 9; break; }
265     case TETRA4:
266       {
267         return 4;
268         break;
269       }
270     case TETRA10:
271       {
272         return 10;
273         break;
274       }
275     case PYRAM5:
276       {
277         return 5;
278         break;
279       }
280     case PYRAM13:
281       {
282         return 13;
283         break;
284       }
285     case PENTA6:
286       {
287         return 6;
288         break;
289       }
290     case PENTA15:
291       {
292         return 15;
293         break;
294       }
295     case HEXA8:
296       {
297         return 8;
298         break;
299       }
300     case HEXA20:
301       {
302         return 20;
303         break;
304       }
305       //case HEXA27:                      { return 27;    break; }
306     default:
307       ERREUR("Type of elem not accepted (method Nnoeuds)");
308   }
309   return 0;
310 }
311
312 int MESHCUT::NnoeudsGeom(TYPE_MAILLE type)
313 {
314   switch (type)
315   {
316     case POI1:
317       {
318         return 1;
319         break;
320       }
321     case SEG2:
322       {
323         return 2;
324         break;
325       }
326     case SEG3:
327       {
328         return 2;
329         break;
330       }
331     case TRIA3:
332       {
333         return 3;
334         break;
335       }
336     case TRIA6:
337       {
338         return 3;
339         break;
340       }
341     case QUAD4:
342       {
343         return 4;
344         break;
345       }
346     case QUAD8:
347       {
348         return 4;
349         break;
350       }
351       //case QUAD9:                   { return 9; break; }
352     case TETRA4:
353       {
354         return 4;
355         break;
356       }
357     case TETRA10:
358       {
359         return 4;
360         break;
361       }
362     case PYRAM5:
363       {
364         return 5;
365         break;
366       }
367     case PYRAM13:
368       {
369         return 5;
370         break;
371       }
372     case PENTA6:
373       {
374         return 6;
375         break;
376       }
377     case PENTA15:
378       {
379         return 6;
380         break;
381       }
382     case HEXA8:
383       {
384         return 8;
385         break;
386       }
387     case HEXA20:
388       {
389         return 8;
390         break;
391       }
392       //case HEXA27:                      { return 27;    break; }
393     default:
394       ERREUR("Type of elem not accepted (method NnoeudsGeom)");
395   }
396   return 0;
397 }
398
399 int MESHCUT::codeGMSH(std::string type)
400 {
401   if (type == (string) "POI1")
402     ERREUR("POI1 not taken into account by GMSH");
403   else if (type == (string) "SEG2")
404     return 1;
405   else if (type == (string) "SEG3")
406     return 8;
407   else if (type == (string) "TRIA3")
408     return 2;
409   else if (type == (string) "TRIA6")
410     return 9;
411   else if (type == (string) "QUAD4")
412     return 3;
413   else if (type == (string) "QUAD8")
414     return 16;
415   else if (type == (string) "QUAD9")
416     return 10;
417   else if (type == (string) "TETRA4")
418     return 4;
419   else if (type == (string) "TETRA10")
420     return 11;
421   else if (type == (string) "PYRAM5")
422     return 7;
423   else if (type == (string) "PENTA6")
424     return 6;
425   else if (type == (string) "PENTA15")
426     return 18;
427   else if (type == (string) "HEXA8")
428     return 5;
429   else if (type == (string) "HEXA20")
430     return 17;
431   else if (type == (string) "HEXA27")
432     return 12;
433   else
434     ERREUR("Type of elem not accepted (method codeGMSH)");
435   return 0;
436 }
437
438 std::string MESHCUT::floatEnsight(float x)
439 {
440   char buf[12];
441   string s;
442   if (x < 0.0)
443     sprintf(buf, "%1.5E", x);
444   else
445     sprintf(buf, " %1.5E", x);
446   s = (string) buf;
447   s.erase(10, 1);
448   return s;
449 }
450
451 bool MESHCUT::typeComplexe(std::string type)
452 {
453   if (type == (string) "SEG3")
454     return true;
455   else if (type == (string) "TRIA6")
456     return true;
457   else if (type == (string) "QUAD8")
458     return true;
459   else if (type == (string) "QUAD9")
460     return true;
461   else if (type == (string) "TETRA10")
462     return true;
463   else if (type == (string) "PYRAM13")
464     return true;
465   else if (type == (string) "PENTA15")
466     return true;
467   else if (type == (string) "HEXA20")
468     return true;
469   else if (type == (string) "HEXA27")
470     return true;
471   else
472     return false;
473 }
474
475 std::string MESHCUT::ASTER8(std::string s)
476 {
477   if (s.size() == 0)
478     return (s + (string) "        ");
479   else if (s.size() == 1)
480     return (s + (string) "       ");
481   else if (s.size() == 2)
482     return (s + (string) "      ");
483   else if (s.size() == 3)
484     return (s + (string) "     ");
485   else if (s.size() == 4)
486     return (s + (string) "    ");
487   else if (s.size() == 5)
488     return (s + (string) "   ");
489   else if (s.size() == 6)
490     return (s + (string) "  ");
491   else if (s.size() == 7)
492     return (s + (string) " ");
493   else if (s.size() == 8)
494     return (s);
495   else
496     ERREUR("More than 8 char for an ASTER string");
497   return (s);
498 }
499
500 /*!
501  *  Distance à laquelle doit se tenir l'observateur sur un axe
502  *  pour voir sous 90° un objet centré de dimensions a et b selon les deux autres axes.
503  *  Si on ne tient pas compte de la dimension de l'objet selon l'axe choisi,
504  *  la formule d_obs=max(a,b)/2 donne la cote
505  *  qui permet de voir l'objet plat dans un angle de 90°.
506  *  A cela il faut ajouter la dimension de l'objet selon l'axe d'observation = c.
507  *
508  *  @param a dimensions de l'objet selon un des axes normal à l'axe d'observation
509  *  @param b dimensions de l'objet selon l'autre axe normal à l'axe d'observation
510  *  @param c est la dimension de l'objet selon l'axe d'observation
511  */
512 float MESHCUT::dObservateur(float a, float b, float c)
513 {
514   return (max(a, b) / 2.0 + c);
515 }
516
517 int MESHCUT::copieFichier(std::string source, std::string cible)
518 {
519   FILE *fsource, *fcible;
520   char buffer[512];
521   int NbLu;
522   if ((fsource = fopen(string2char(source), "rb")) == NULL)
523     return -1;
524   if ((fcible = fopen(string2char(cible), "wb")) == NULL)
525     {
526       fclose(fsource);
527       return -2;
528     }
529   while ((NbLu = fread(buffer, 1, 512, fsource)) != 0)
530     fwrite(buffer, 1, NbLu, fcible);
531   fclose(fcible);
532   fclose(fsource);
533   return 0;
534 }
535
536 med_geometry_type MESHCUT::InstanceMGE(TYPE_MAILLE TYPE)
537 {
538   med_geometry_type typeBanaliseMED = MED_NONE;
539
540   switch (TYPE)
541   {
542     case POI1:
543       typeBanaliseMED = MED_POINT1;
544       break; // Attention, piège !
545     case SEG2:
546       typeBanaliseMED = MED_SEG2;
547       break;
548     case SEG3:
549       typeBanaliseMED = MED_SEG3;
550       break;
551     case TRIA3:
552       typeBanaliseMED = MED_TRIA3;
553       break;
554     case TRIA6:
555       typeBanaliseMED = MED_TRIA6;
556       break;
557     case QUAD4:
558       typeBanaliseMED = MED_QUAD4;
559       break;
560     case QUAD8:
561       typeBanaliseMED = MED_QUAD8;
562       break;
563     case TETRA4:
564       typeBanaliseMED = MED_TETRA4;
565       break;
566     case TETRA10:
567       typeBanaliseMED = MED_TETRA10;
568       break;
569     case PYRAM5:
570       typeBanaliseMED = MED_PYRA5;
571       break; // Attention, piège !
572     case PYRAM13:
573       typeBanaliseMED = MED_PYRA13;
574       break; // Attention, piège !
575     case PENTA6:
576       typeBanaliseMED = MED_PENTA6;
577       break;
578     case PENTA15:
579       typeBanaliseMED = MED_PENTA15;
580       break;
581     case HEXA8:
582       typeBanaliseMED = MED_HEXA8;
583       break;
584     case HEXA20:
585       typeBanaliseMED = MED_HEXA20;
586       break;
587     default:
588       ERREUR("Method InstanceMGE, unknown type ");
589   }
590   return typeBanaliseMED;
591 }
592
593 int MESHCUT::salome_chrono()
594 {
595   return clock() / CLOCKS_PER_SEC;
596 }
597
598 TYPE_MAILLE MESHCUT::typeMaille(std::string type)
599 {
600   if (type == (string) "POI1")
601     return POI1;
602   else if (type == (string) "SEG2")
603     return SEG2;
604   else if (type == (string) "SEG3")
605     return SEG3;
606   else if (type == (string) "TRIA3")
607     return TRIA3;
608   else if (type == (string) "TRIA6")
609     return TRIA6;
610   else if (type == (string) "QUAD4")
611     return QUAD4;
612   else if (type == (string) "QUAD8")
613     return QUAD8;
614   else if (type == (string) "TETRA4")
615     return TETRA4;
616   else if (type == (string) "TETRA10")
617     return TETRA10;
618   else if (type == (string) "PYRAM5")
619     return PYRAM5;
620   else if (type == (string) "PYRAM13")
621     return PYRAM13;
622   else if (type == (string) "PENTA6")
623     return PENTA6;
624   else if (type == (string) "PENTA15")
625     return PENTA15;
626   else if (type == (string) "HEXA8")
627     return HEXA8;
628   else if (type == (string) "HEXA20")
629     return HEXA20;
630   else
631     ERREUR("ERROR method typeMaille, unknown type");
632   return POI1;
633 }
634
635 std::string MESHCUT::MGE2string(med_geometry_type MGE)
636 {
637   if (MGE == MED_NONE)
638     return (string) "NOEUD";
639   else if (MGE == MED_POINT1)
640     return (string) "POI1";
641   else if (MGE == MED_SEG2)
642     return (string) "SEG2";
643   else if (MGE == MED_SEG3)
644     return (string) "SEG3";
645   else if (MGE == MED_TRIA3)
646     return (string) "TRIA3";
647   else if (MGE == MED_TRIA6)
648     return (string) "TRIA6";
649   else if (MGE == MED_QUAD4)
650     return (string) "QUAD4";
651   else if (MGE == MED_QUAD8)
652     return (string) "QUAD8";
653   else if (MGE == MED_TETRA4)
654     return (string) "TETRA4";
655   else if (MGE == MED_TETRA10)
656     return (string) "TETRA10";
657   else if (MGE == MED_PYRA5)
658     return (string) "PYRAM5";
659   else if (MGE == MED_PYRA13)
660     return (string) "PYRAM13";
661   else if (MGE == MED_PENTA6)
662     return (string) "PENTA6";
663   else if (MGE == MED_PENTA15)
664     return (string) "PENTA15";
665   else if (MGE == MED_HEXA8)
666     return (string) "HEXA8";
667   else if (MGE == MED_HEXA20)
668     return (string) "HEXA20";
669   else
670     ERREUR("ERROR method MGE2string, unknown type");
671   return (string) "NOEUD";
672 }
673
674 std::string MESHCUT::TM2string(TYPE_MAILLE MGE)
675 {
676   if (MGE == POI1)
677     return (string) "POI1";
678   else if (MGE == SEG2)
679     return (string) "SEG2";
680   else if (MGE == SEG3)
681     return (string) "SEG3";
682   else if (MGE == TRIA3)
683     return (string) "TRIA3";
684   else if (MGE == TRIA6)
685     return (string) "TRIA6";
686   else if (MGE == QUAD4)
687     return (string) "QUAD4";
688   else if (MGE == QUAD8)
689     return (string) "QUAD8";
690   else if (MGE == TETRA4)
691     return (string) "TETRA4";
692   else if (MGE == TETRA10)
693     return (string) "TETRA10";
694   else if (MGE == PYRAM5)
695     return (string) "PYRAM5";
696   else if (MGE == PYRAM13)
697     return (string) "PYRAM13";
698   else if (MGE == PENTA6)
699     return (string) "PENTA6";
700   else if (MGE == PENTA15)
701     return (string) "PENTA15";
702   else if (MGE == HEXA8)
703     return (string) "HEXA8";
704   else if (MGE == HEXA20)
705     return (string) "HEXA20";
706   else
707     ERREUR("ERROR method TM2string, unknown type");
708   return (string) "POI1";
709 }
710
711 TYPE_MAILLE MESHCUT::string2TM(std::string stm)
712 {
713   if (stm == (string) "POI1")
714     return POI1;
715   else if (stm == (string) "SEG2")
716     return SEG2;
717   else if (stm == (string) "SEG3")
718     return SEG3;
719   else if (stm == (string) "TRIA3")
720     return TRIA3;
721   else if (stm == (string) "TRIA6")
722     return TRIA6;
723   else if (stm == (string) "QUAD4")
724     return QUAD4;
725   else if (stm == (string) "QUAD8")
726     return QUAD8;
727   else if (stm == (string) "TETRA4")
728     return TETRA4;
729   else if (stm == (string) "TETRA10")
730     return TETRA10;
731   else if (stm == (string) "PYRAM5")
732     return PYRAM5;
733   else if (stm == (string) "PYRAM13")
734     return PYRAM13;
735   else if (stm == (string) "PENTA6")
736     return PENTA6;
737   else if (stm == (string) "PENTA15")
738     return PENTA15;
739   else if (stm == (string) "HEXA8")
740     return HEXA8;
741   else if (stm == (string) "HEXA20")
742     return HEXA20;
743   else
744     ERREUR("ERROR method string2TM, unknown type");
745   return POI1;
746 }
747
748 std::string MESHCUT::coordIndex_ILS(TYPE_MAILLE tm)
749 {
750   if (tm == SEG2)
751     return (string) " 0,1 ";
752   else if (tm == SEG3)
753     return (string) " 0,1 "; // Idem SEG2
754   else if (tm == TRIA3)
755     return (string) " 0,1,2,0 ";
756   else if (tm == TRIA6)
757     return (string) " 0,1,2,0 ";
758   else if (tm == QUAD4)
759     return (string) " 0,1,2,3,0 ";
760   else if (tm == QUAD8)
761     return (string) " 0,1,2,3,0 ";
762   else if (tm == TETRA4)
763     return (string) " 0,1,2,0,-1, 0,3,-1, 1,3,-1, 2,3,-1 ";
764   else if (tm == TETRA10)
765     return (string) " 0,1,2,0,-1, 0,3,-1, 1,3,-1, 2,3,-1 ";
766   else if (tm == PYRAM5)
767     return (string) " 0,1,2,3,0,-1, 0,4,-1, 1,4,-1, 2,4,-1, 3,4,-1 ";
768   else if (tm == PYRAM13)
769     return (string) " 0,1,2,3,0,-1, 0,4,-1, 1,4,-1, 2,4,-1, 3,4,-1 ";
770   else if (tm == PENTA6)
771     return (string) " 0,1,2,0,-1, 3,4,5,3,-1, 0,3,-1, 1,4,-1, 2,5,-1 ";
772   else if (tm == PENTA15)
773     return (string) " 0,1,2,0,-1, 3,4,5,3,-1, 0,3,-1, 1,4,-1, 2,5,-1 ";
774   else if (tm == HEXA8)
775     return (string) " 0,1,2,3,0,-1, 4,5,6,7,4,-1, 0,4,-1, 1,5,-1, 2,6,-1, 3,7,-1 ";
776   else if (tm == HEXA20)
777     return (string) " 0,1,2,3,0,-1, 4,5,6,7,4,-1, 0,4,-1, 1,5,-1, 2,6,-1, 3,7,-1 ";
778   else
779     return (string) "";
780 }
781
782 std::string MESHCUT::coordIndex_IFS(TYPE_MAILLE tm)
783 {
784   if (tm == SEG2)
785     return (string) "  ";
786   else if (tm == SEG3)
787     return (string) "  "; // Idem SEG2
788   else if (tm == TRIA3)
789     return (string) " 0,1,2,0,-1, 0,2,1,0,-1 ";
790   else if (tm == TRIA6)
791     return (string) " 0,1,2,0,-1, 0,2,1,0,-1 ";
792   else if (tm == QUAD4)
793     return (string) " 0,1,2,3,0,-1, 0,3,2,1,0,-1 ";
794   else if (tm == QUAD8)
795     return (string) " 0,1,2,3,0,-1, 0,3,2,1,0,-1 ";
796   else if (tm == TETRA4)
797     return (string) " 0,1,2,0,-1, 0,2,1,0,-1, 0,3,1,0,-1, 0,1,3,0,-1, 1,3,2,1,-1, 1,2,3,1,-1, 0,2,3,0,-1, 0,3,2,0,-1 ";
798   else if (tm == TETRA10)
799     return (string) " 0,1,2,0,-1, 0,2,1,0,-1, 0,3,1,0,-1, 0,1,3,0,-1, 1,3,2,1,-1, 1,2,3,1,-1, 0,2,3,0,-1, 0,3,2,0,-1 ";
800   else if (tm == PYRAM5)
801     return (string) " 0,1,2,3,0,-1, 0,3,2,1,0,-1, 0,1,4,0,-1, 0,4,1,0,-1, 1,2,4,1,-1, 1,4,2,1,-1, 2,4,3,2,-1, 2,3,4,2,-1, 3,4,0,3,-1, 3,0,4,3,-1 ";
802   else if (tm == PYRAM13)
803     return (string) " 0,1,2,3,0,-1, 0,3,2,1,0,-1, 0,1,4,0,-1, 0,4,1,0,-1, 1,2,4,1,-1, 1,4,2,1,-1, 2,4,3,2,-1, 2,3,4,2,-1, 3,4,0,3,-1, 3,0,4,3,-1 ";
804   else if (tm == PENTA6)
805     return (string) " 0,1,2,0,-1, 0,2,1,0,-1, 3,4,5,3,-1, 3,5,4,3,-1, 0,1,4,3,0,-1, 0,3,4,1,0,-1, 1,4,5,2,1,-1, 1,2,5,4,1,-1, 0,3,5,2,0,-1, 0,2,5,3,0,-1 ";
806   else if (tm == PENTA15)
807     return (string) " 0,1,2,0,-1, 0,2,1,0,-1, 3,4,5,3,-1, 3,5,4,3,-1, 0,1,4,3,0,-1, 0,3,4,1,0,-1, 1,4,5,2,1,-1, 1,2,5,4,1,-1, 0,3,5,2,0,-1, 0,2,5,3,0,-1 ";
808   else if (tm == HEXA8)
809     return (string) " 0,1,2,3,0,-1, 0,3,2,1,0,-1, 1,5,6,2,1,-1, 1,2,6,5,1,-1, 5,4,7,6,5,-1, 5,6,7,4,5,-1, 4,0,3,7,4,-1, 4,7,3,0,4,-1, 0,4,5,1,0,-1, 0,1,5,4,0,-1, 3,7,6,2,3,-1, 3,2,6,7,3,-1 ";
810   else if (tm == HEXA20)
811     return (string) " 0,1,2,3,0,-1, 0,3,2,1,0,-1, 1,5,6,2,1,-1, 1,2,6,5,1,-1, 5,4,7,6,5,-1, 5,6,7,4,5,-1, 4,0,3,7,4,-1, 4,7,3,0,4,-1, 0,4,5,1,0,-1, 0,1,5,4,0,-1, 3,7,6,2,3,-1, 3,2,6,7,3,-1 ";
812   else
813     return (string) "";
814 }
815
816 std::string MESHCUT::SIGNE(double x)
817 {
818   if (x < 0)
819     return "-";
820   else if (x > 0)
821     return "+";
822   else
823     return "0";
824 }
825
826 void MESHCUT::champType(std::string type, med_entity_type MEM, med_geometry_type MGE, med_idt fid, med_idt fidout,
827                         char *maa, char *nomChamp, char *nomChampMoy, med_field_type typeChamp, char *compChamp,
828                         char *unitChamp, med_int nCompChamp, std::map<std::string, int> REFGAUSS, int ichamp)
829 {
830
831   bool debug = true;
832   int ipt, nmailles, ngauss, imaille, igauss, icomp;
833   //  int ival, ngpdt;
834   med_int nval, numdt, numo, nPasTemps;
835   char dtunit[MED_SNAME_SIZE + 1] = "";
836   char locname[MED_NAME_SIZE + 1] = "";
837   char nomprofil[MED_NAME_SIZE + 1] = "";
838   med_float dt = 0.0;
839   med_float *valr = NULL;
840   med_float *valr2 = NULL;
841   med_bool local;
842   //  med_int nbrefmaa;
843   med_field_type fieldType;
844
845   if (MEDfieldInfo(fid, ichamp, nomChamp, maa, &local, &fieldType, compChamp, unitChamp, dtunit, &nPasTemps) < 0)
846     ERREUR("Error MEDfieldInfo");
847   cout << type << " : " << (int) nPasTemps << " timestep  " << endl;
848
849   for (ipt = 1; ipt <= nPasTemps; ipt++)
850     {
851       //for (ipt=1; ipt<=min(nPasTemps,1); ipt++) {
852       if (debug)
853         cout << endl;
854       if (debug)
855         cout << "************************************************************" << endl;
856       if (debug)
857         cout << "                    FIELD " << ichamp << endl;
858       if (debug)
859         cout << "          " << nomChamp << endl;
860       if (debug)
861         cout << "          " << type << "   ---   Timestep " << ipt << endl;
862       if (debug)
863         cout << "************************************************************" << endl;
864       if (debug)
865         cout << endl;
866
867       if (MEDfieldComputingStepInfo(fid, nomChamp, ipt, &numdt, &numo, &dt) < 0)
868         {
869           cout << endl;
870           cout << endl << "####################################################################" << endl;
871           cout << "                   ERROR MEDpasdetempsInfo                         " << endl;
872           cout << endl << "####################################################################" << endl;
873           cout << "                  Field: " << (string) nomChamp << endl;
874           cout << "                  Geometrie: " << MGE2string(MGE) << endl;
875           cout << "                  Timestep " << ipt << " ignored" << endl;
876
877           continue;
878         }
879
880       med_int profilesize, nintegrationpoint;
881       nval = MEDfieldnValueWithProfile(fid, nomChamp, numdt, numo, MEM, MGE, ipt, MED_COMPACT_PFLMODE, nomprofil,
882                                        &profilesize, locname, &nintegrationpoint);
883       if (debug)
884         cout << "     Number of values in this timestep: " << (int) nval << endl;
885
886       if (typeChamp == MED_FLOAT64)
887         valr = (med_float*) calloc(nCompChamp * nval, sizeof(med_float));
888       else
889         ERREUR("Type of field not taken into account");
890
891       if (MEDfieldValueWithProfileRd(fid, maa, numdt, numo, MEM, MGE, MED_COMPACT_PFLMODE, nomprofil,
892                                      MED_FULL_INTERLACE, MED_ALL_CONSTITUENT, (unsigned char*) valr) < 0)
893         {
894           cout << endl;
895           cout << endl << "####################################################################" << endl;
896           cout << "                         ERROR MEDchampLire                        " << endl;
897           cout << endl << "####################################################################" << endl;
898           cout << endl;
899           cout << "   Field: " << (string) nomChamp << endl;
900           cout << "   Geometry: " << MGE2string(MGE) << endl;
901           cout << "   Timestep " << ipt << " ignored" << endl;
902           cout << endl << endl;
903           continue;
904         }
905
906       if (debug)
907         cout << "       profile  = " << (string) nomprofil << endl;
908       // Localisation du champ aux points de Gauss
909       if (debug)
910         cout << "       locname = " << (string) locname << endl;
911
912       if (REFGAUSS[(string) locname])
913         {
914           ngauss = REFGAUSS[(string) locname];
915           if (debug)
916             cout << "       " << ngauss << " Gauss points by element)" << endl;
917         }
918       else
919         ngauss = 1;
920
921       nmailles = nval / ngauss;
922       if (debug)
923         cout << "      Nbre de mailles: " << nmailles << endl;
924
925       if (debug)
926         {
927           cout << endl << "       Liste des valeurs du champ brut aux 3 premiers éléments:" << endl;
928           for (imaille = 0; imaille < std::min(nmailles, 3); imaille++)
929             {
930               cout << "         Maille " << imaille << endl;
931               for (igauss = 0; igauss < ngauss; igauss++)
932                 {
933                   cout << "             PG " << igauss << " : ";
934                   for (icomp = 0; icomp < nCompChamp; icomp++)
935                     cout << " " << *(valr + imaille * ngauss * nCompChamp + igauss * nCompChamp + icomp);
936                   cout << endl;
937                 }
938               cout << endl;
939             }
940           cout << endl;
941         }
942
943       if (ngauss > 1)
944         {
945
946           valr2 = (med_float*) calloc(nCompChamp * nmailles, sizeof(med_float));
947
948           if (debug)
949             cout << endl << "       Moyenne sur les PG des mailles" << endl;
950           for (imaille = 0; imaille < nmailles; imaille++)
951             {
952               for (icomp = 0; icomp < nCompChamp; icomp++)
953                 {
954                   float valCompMaille = 0.0;
955                   for (igauss = 0; igauss < ngauss; igauss++)
956                     valCompMaille += *(valr + imaille * ngauss * nCompChamp + igauss * nCompChamp + icomp);
957                   *(valr2 + imaille * nCompChamp + icomp) = valCompMaille / ngauss;
958
959                 }
960             }
961
962           //cout << endl << "Nom champ moy = " <<  (string)nomChampMoy << endl;
963           //cout << endl << "Type champ = " <<  typeChamp << endl;
964           //cout << endl << "Comp champ = " <<  (string)compChamp << endl;
965           //cout << endl << "Unit champ = " <<  (string)unitChamp << endl;
966           //cout << endl << "N comp champ = " <<  nCompChamp << endl;
967
968           if (MEDfieldValueWithProfileWr(fidout, nomChampMoy, numdt, numo, dt, MEM, MGE, MED_COMPACT_PFLMODE,
969                                          nomprofil, MED_NO_LOCALIZATION, MED_FULL_INTERLACE, MED_ALL_CONSTITUENT,
970                                          (med_int) nmailles, (unsigned char*) valr2) < 0)
971             {
972               cout << endl;
973               cout << endl << "********************************************************************" << endl;
974               cout << "********************                         ***********************" << endl;
975               cout << "********************   ERROR MEDchampEcr     ***********************" << endl;
976               cout << "********************                         ***********************" << endl;
977               cout << "********************************************************************" << endl;
978               cout << endl;
979               cout << "   Champ: " << (string) nomChampMoy << endl;
980               cout << "   Géométrie: " << MGE2string(MGE) << endl;
981               cout << "   Pas de temps " << ipt << " ignoré" << endl;
982               cout << endl << endl;
983               continue;
984             }
985
986           if (debug)
987             cout << "    Writing mean values in new field: OK " << endl;
988
989           // Restitution du champ moyenné
990           if (debug)
991             {
992               cout << endl << "       Liste des valeurs du champ moyenné aux 3 premiers éléments:" << endl;
993               for (imaille = 0; imaille < min(nmailles, 3); imaille++)
994                 {
995                   cout << "         Maille " << imaille << endl;
996                   for (icomp = 0; icomp < nCompChamp; icomp++)
997                     cout << " " << *(valr2 + imaille * nCompChamp + icomp);
998                   cout << endl;
999                 }
1000               cout << endl;
1001             }
1002
1003         }
1004
1005       free(valr);
1006       free(valr2);
1007
1008     } // boucle sur les pas de temps
1009
1010   cout << endl;
1011 }
1012
1013 std::string MESHCUT::nomMaille(TYPE_MAILLE tm, int nl)
1014 {
1015   return (TM2string(tm) + (string) "_" + int2string(nl));
1016 }
1017
1018 bool MESHCUT::appartientVN(int n, std::vector<int> V)
1019 {
1020   bool app = false;
1021   for (unsigned int i = 0; i < V.size(); i++)
1022     if (n == V[i])
1023       {
1024         app = true;
1025         break;
1026       }
1027   return app;
1028 }
1029
1030 float MESHCUT::distance2(float x1, float y1, float z1, float x2, float y2, float z2)
1031 {
1032   return (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) + (z2 - z1) * (z2 - z1);
1033 }
1034
1035 /*!
1036  *  Conversion HL-MED d'une table de connectivités
1037  */
1038 void MESHCUT::conversionCNX(int *CNXtm, TYPE_MAILLE tm, int N)
1039 {
1040
1041   int n = Nnoeuds(tm);
1042
1043   if (tm == TETRA4)
1044     {
1045       for (int i = 0; i < N; i++)
1046         {
1047           int i1 = CNXtm[i * n + 1];
1048           int i2 = CNXtm[i * n + 2];
1049           CNXtm[i * n + 1] = i2;
1050           CNXtm[i * n + 2] = i1;
1051         }
1052     }
1053   else if (tm == PYRAM5)
1054     {
1055       for (int i = 0; i < N; i++)
1056         {
1057           int i1 = CNXtm[i * n + 1];
1058           int i3 = CNXtm[i * n + 3];
1059           CNXtm[i * n + 1] = i3;
1060           CNXtm[i * n + 3] = i1;
1061         }
1062     }
1063   else if (tm == PENTA6)
1064     {
1065       for (int i = 0; i < N; i++)
1066         {
1067           int i0 = CNXtm[i * n + 0];
1068           int i1 = CNXtm[i * n + 1];
1069           int i2 = CNXtm[i * n + 2];
1070           int i3 = CNXtm[i * n + 3];
1071           int i4 = CNXtm[i * n + 4];
1072           int i5 = CNXtm[i * n + 5];
1073           CNXtm[i * n + 0] = i3;
1074           CNXtm[i * n + 1] = i4;
1075           CNXtm[i * n + 2] = i5;
1076           CNXtm[i * n + 3] = i0;
1077           CNXtm[i * n + 4] = i1;
1078           CNXtm[i * n + 5] = i2;
1079         }
1080     }
1081
1082   else if (tm == HEXA8)
1083     {
1084       for (int i = 0; i < N; i++)
1085         {
1086           int i0 = CNXtm[i * n + 0];
1087           int i1 = CNXtm[i * n + 1];
1088           int i2 = CNXtm[i * n + 2];
1089           int i3 = CNXtm[i * n + 3];
1090           int i4 = CNXtm[i * n + 4];
1091           int i5 = CNXtm[i * n + 5];
1092           int i6 = CNXtm[i * n + 6];
1093           int i7 = CNXtm[i * n + 7];
1094           CNXtm[i * n + 0] = i4;
1095           CNXtm[i * n + 1] = i5;
1096           CNXtm[i * n + 2] = i6;
1097           CNXtm[i * n + 3] = i7;
1098           CNXtm[i * n + 4] = i0;
1099           CNXtm[i * n + 5] = i1;
1100           CNXtm[i * n + 6] = i2;
1101           CNXtm[i * n + 7] = i3;
1102         }
1103     }
1104 }
1105