ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/REPOS_ERICCA/magic/app/mgoperation/src/main.cpp
Revision: 763
Committed: Wed Dec 2 19:55:53 2015 UTC (9 years, 6 months ago) by francois
File size: 71615 byte(s)
Log Message: 
Le fichier MAGiC est maintenant versionné. LA version actuelle est 2.0. L'ancienne version est 1.0.
Tout est transparent pour l'utilisateur. Les vieilles versions sont lisibles mais les nouveaux enregistrements sont dans la version la plus récente.
Changement des conditions aux limites : ajout d'un parametre pour dire si la condition numerique est une valeur ou une formule ou un lien vers une autre entité magic.
Les parametres pour saisir sont maintenant -ccf -ccfi -ccff -ccft -ccfit -ccfft

File Contents

# User Rev Content
1 francois 283
2     //------------------------------------------------------------
3     //------------------------------------------------------------
4     // MAGiC
5     // Jean Christophe Cuilli�e et Vincent FRANCOIS
6     // D�artement de G�ie M�anique - UQTR
7     //------------------------------------------------------------
8     // Le projet MAGIC est un projet de recherche du d�artement
9     // de g�ie m�anique de l'Universit�du Qu�ec �
10     // Trois Rivi�es
11     // Les librairies ne peuvent �re utilis�s sans l'accord
12     // des auteurs (contact : francois@uqtr.ca)
13     //------------------------------------------------------------
14     //------------------------------------------------------------
15     //
16     // main.cpp
17     //
18     //------------------------------------------------------------
19     //------------------------------------------------------------
20     // COPYRIGHT 2000
21     // Version du 02/03/2006 �11H25
22     //------------------------------------------------------------
23     //------------------------------------------------------------
24     #include "gestionversion.h"
25     #ifdef WINDOWS_VERSION
26     #include "fenetre.h"
27     #endif
28    
29    
30     #include <string.h>
31     #include "mg_file.h"
32     #include "mg_export.h"
33 francois 492 #include "fct_export.h"
34 francois 283 #include "mg_import.h"
35     #include "step_import.h"
36     #include "acis_import.h"
37     #include "step_import.h"
38 francois 428 #include "stl_import.h"
39 francois 283 #include "occ_import.h"
40 francois 296 #include "mc_gestionnaire.h"
41 francois 283 #include "vct_multi_modele.h"
42 francois 326 #include "mgaster.h"
43 francois 283 #include <ctype.h>
44     #include <math.h>
45 francois 425 #include "mailleur_analyse.h"
46 francois 432 #include "magic_application.h"
47 francois 469 #include "fct_taille_fem_solution.h"
48 francois 612 #include "fem_maillage_quadratique_outils.h"
49 francois 628 #include "fem_maillage_outils.h"
50 francois 697 #include "mg_table.h"
51 francois 283 //---------------------------------------------------------------------------
52    
53    
54     void minuscule(char * mess)
55     {
56     int nb=strlen(mess);
57     for (int i=0;i<nb;i++)
58     mess[i]=tolower(mess[i]);
59     }
60    
61 francois 432
62 francois 283 int main(int argc,char **argv)
63     {
64 francois 432 std::vector<MAGIC_PARAMETRE_APPLICATION> lst;
65     MAGIC_PARAMETRE_APPLICATION p1(2,(char*)"-gmsh",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Conversion du fichier MAGiC en gmsh");
66     MAGIC_PARAMETRE_APPLICATION p2(3,(char*)"-nodeforme",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Ne convertit pas les deformes des maillages FEM");
67     MAGIC_PARAMETRE_APPLICATION p3(4,(char*)"-copie",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Copie un fichier MAGiC en un autre");
68     MAGIC_PARAMETRE_APPLICATION p4(5,(char*)"-out",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier de sortie");
69 francois 694 MAGIC_PARAMETRE_APPLICATION p5(6,(char*)"-aster",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Conversion MAGiC en format ASTER (uniquement calcul mecanique)");
70 francois 514 MAGIC_PARAMETRE_APPLICATION p6(7,(char*)"-coderesu",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Choix des valeurs à calculer par EF - Defaut 11111111 - |Surface moyenne|Surface inferieure|Surface superieur|Deplacement|Contraintes|Deformations|Contraintes equivalentes|Energie|");
71 francois 505 MAGIC_PARAMETRE_APPLICATION p7(8,(char*)"-carte",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Conversion carte de taille ancien format en format gmsh");
72 francois 432 MAGIC_PARAMETRE_APPLICATION p8(9,(char*)"-step",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Conversion de fichier step en format MAGiC");
73     MAGIC_PARAMETRE_APPLICATION p9(10,(char*)"-unite",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Facteur d'unité pour obtenir des métres - Defaut 1.");
74     MAGIC_PARAMETRE_APPLICATION p10(11,(char*)"-stepocc",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Conversion de fichier step en format MAGiC via opencascade");
75     MAGIC_PARAMETRE_APPLICATION p11(12,(char*)"-sat",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Conversion de fichier sat en format MAGiC");
76     MAGIC_PARAMETRE_APPLICATION p12(13,(char*)"-eps",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Tolérance pour un double - Defaut 0.000001");
77     MAGIC_PARAMETRE_APPLICATION p13(14,(char*)"-epsgeo",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Distance max entre la triangulation et la géométrie - Defaut 1.");
78     MAGIC_PARAMETRE_APPLICATION p14(15,(char*)"-importstl",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Importation de la triangulation STL");
79     MAGIC_PARAMETRE_APPLICATION p15(16,(char*)"-importtriangulation",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Importation de la triangulation STL avec noeuds fusionnés");
80     MAGIC_PARAMETRE_APPLICATION p16(17,(char*)"-occ",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Conversion de fichier opencascade en format MAGiC");
81     MAGIC_PARAMETRE_APPLICATION p17(18,(char*)"-fem",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Création d'un maillage fem");
82     MAGIC_PARAMETRE_APPLICATION p18(19,(char*)"-nummai",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numéro de maillage - Defaut le premier");
83     MAGIC_PARAMETRE_APPLICATION p19(20,(char*)"-degre",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Degre du maillage à créer");
84     MAGIC_PARAMETRE_APPLICATION p20(21,(char*)"-astermagic",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Importation des resultats ASTER dans un maillage");
85     MAGIC_PARAMETRE_APPLICATION p21(22,(char*)"-fichieraster",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier aster");
86 francois 706 MAGIC_PARAMETRE_APPLICATION p22(23,(char*)"-optis",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Conversion de fichier magic en format OPTIS - Fonction esactivée");
87 francois 432 MAGIC_PARAMETRE_APPLICATION p23(24,(char*)"-optismagic",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Importation des résultats OPTIS");
88     MAGIC_PARAMETRE_APPLICATION p24(25,(char*)"-fichieroptis",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier optis");
89     MAGIC_PARAMETRE_APPLICATION p25(26,(char*)"-fichierflottant",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier flottant - Optionnel");
90     MAGIC_PARAMETRE_APPLICATION p26(27,(char*)"-seuil",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Seuil de densité pour conserver les éléments");
91     MAGIC_PARAMETRE_APPLICATION p27(28,(char*)"-niveau",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Facteur pour le seuil (parametre incertain)");
92     MAGIC_PARAMETRE_APPLICATION p28(29,(char*)"-selectgr",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Selection de groupe topologique");
93     MAGIC_PARAMETRE_APPLICATION p29(30,(char*)"-deselectgr",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Deselection de groupe topologique");
94     MAGIC_PARAMETRE_APPLICATION p30(31,(char*)"-numgeo",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numéro de geometrie - Defaut la première");
95     MAGIC_PARAMETRE_APPLICATION p31(32,(char*)"-numgt",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numéro de groupe topologique - Defaut le premier");
96     MAGIC_PARAMETRE_APPLICATION p32(33,(char*)"-numentite",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numéro d'entité à selectionner");
97     MAGIC_PARAMETRE_APPLICATION p33(34,(char*)"-expand",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Prend en compte la topologie sous-jacente dans la selection");
98     MAGIC_PARAMETRE_APPLICATION p34(35,(char*)"-examine",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Contenu d'un fichier MAGiC. Si un numero de maillage est présent l'action analyse ce maillage");
99     MAGIC_PARAMETRE_APPLICATION p35(36,(char*)"-angle",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Angle limite pour l'analyse de retournement de triangle - Defaut 0.03");
100     MAGIC_PARAMETRE_APPLICATION p36(37,(char*)"-fichierlog",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Nom du fichier log");
101 francois 516 MAGIC_PARAMETRE_APPLICATION p37(38,(char*)"-deforme",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Calcul un maillage déforme");
102 francois 432 MAGIC_PARAMETRE_APPLICATION p38(39,(char*)"-fusiongeo",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Fusionne deux géométries");
103     MAGIC_PARAMETRE_APPLICATION p39(40,(char*)"-numsol1",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numéro de solution 1");
104     MAGIC_PARAMETRE_APPLICATION p40(41,(char*)"-numsol2",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numéro de solution 2");
105     MAGIC_PARAMETRE_APPLICATION p41(42,(char*)"-numsol3",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numéro de solution 3");
106     MAGIC_PARAMETRE_APPLICATION p42(43,(char*)"-numchamp1",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numéro de champs de la solution 1");
107     MAGIC_PARAMETRE_APPLICATION p43(44,(char*)"-numchamp2",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numéro de champs de la solution 2");
108     MAGIC_PARAMETRE_APPLICATION p44(45,(char*)"-numchamp3",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numéro de champs de la solution 3");
109     MAGIC_PARAMETRE_APPLICATION p45(46,(char*)"-ccf",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Application de conditions aux limites sur une topologie");
110     MAGIC_PARAMETRE_APPLICATION p46(47,(char*)"-ccft",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Application de conditions aux limites sur une topologie et sur les topologie sous jacente");
111     MAGIC_PARAMETRE_APPLICATION p47(48,(char*)"-ccfhelp",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Liste des conditions aux limites disponibles");
112 francois 763 MAGIC_PARAMETRE_APPLICATION p48(49,(char*)"-valeur",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Condition aux limites à appliquer sous la forme id:ccf:valeur ou id:ccf:formule:var1,var2");
113 francois 432 MAGIC_PARAMETRE_APPLICATION p49(50,(char*)"-oricoque",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Orientation d'une coque");
114     MAGIC_PARAMETRE_APPLICATION p50(51,(char*)"-numcoque",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numéro de la coque - Defaut la premiere");
115 francois 517 MAGIC_PARAMETRE_APPLICATION p51(52,(char*)"-stlmagic",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Importation de fichier STL");
116 francois 432 MAGIC_PARAMETRE_APPLICATION p52(53,(char*)"-epsf",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Tolérance pour un float - Defaut 0.0001");
117 mejrim 597 MAGIC_PARAMETRE_APPLICATION p53(54,(char*)"-calculaster",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Calcul ASTER");
118 francois 454 MAGIC_PARAMETRE_APPLICATION p54(55,(char*)"-correspondance",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Ajout d'un fichier de correspondance entre GMSH et MAGIC");
119 francois 505 MAGIC_PARAMETRE_APPLICATION p55(56,(char*)"-carte2",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Conversion carte de taille nouvelle version en format gmsh");
120 francois 517 MAGIC_PARAMETRE_APPLICATION p56(57,(char*)"-stlout",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Conversion du fichier MAGiC en stl");
121 francois 514 MAGIC_PARAMETRE_APPLICATION p57(58,(char*)"-comparetaille",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Compare la taille d'un maillage avec la taille d'une carte de taille isotrope ancienne version");
122     MAGIC_PARAMETRE_APPLICATION p58(59,(char*)"-cartetaille",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Nom de la carte de taille a fournir");
123     MAGIC_PARAMETRE_APPLICATION p59(60,(char*)"-comparetaille2",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Compare la taille d'un maillage avec la taille d'une carte de taille isotrope nouvelle version");
124 francois 516 MAGIC_PARAMETRE_APPLICATION p60(61,(char*)"-coefdef",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Coefficient de déformé - par defaut 0. = pas de creation de maillage");
125 francois 517 MAGIC_PARAMETRE_APPLICATION p61(62,(char*)"-detachemaillage",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Détache un maillage des ses liens avec la géométrie");
126 francois 706 MAGIC_PARAMETRE_APPLICATION p62(63,(char*)"-elastique",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Calcul aster en elasticité");
127 mejrim 597 MAGIC_PARAMETRE_APPLICATION p63(64,(char*)"-thermique",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Calcul aster en thermique");
128 francois 603 MAGIC_PARAMETRE_APPLICATION p64(65,(char*)"-contrainteplane",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Calcul aster en contrainte plane");
129     MAGIC_PARAMETRE_APPLICATION p65(66,(char*)"-deformationplane",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Calcul aster en deformation plane");
130 francois 604 MAGIC_PARAMETRE_APPLICATION p66(67,(char*)"-sonde",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Obtenir un resultat sur une arete dans un fichier csv");
131     MAGIC_PARAMETRE_APPLICATION p67(68,(char*)"-numsol",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numero de la solution (la premiere par defaut)");
132     MAGIC_PARAMETRE_APPLICATION p68(69,(char*)"-numchamp",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numero du champs de la solution (le premier par defaut)");
133     MAGIC_PARAMETRE_APPLICATION p69(70,(char*)"-csvout",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Nom du fichier csv");
134     MAGIC_PARAMETRE_APPLICATION p70(71,(char*)"-numare",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numero de l'arete à sonder (la premiere par default)");
135 francois 628 MAGIC_PARAMETRE_APPLICATION p71(72,(char*)"-projsolution",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Projeter une solution sur un autre maillage");
136     MAGIC_PARAMETRE_APPLICATION p72(73,(char*)"-fichiersolution",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Nom du fichier contenant la solution");
137     MAGIC_PARAMETRE_APPLICATION p73(74,(char*)"-comparesolution",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Comparer deux champs de solution. La reference est la deuxième solution.");
138 francois 656 MAGIC_PARAMETRE_APPLICATION p74(75,(char*)"-analysequadratique",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Analyse le maillage quadratique. Defaut non.");
139 francois 697 MAGIC_PARAMETRE_APPLICATION p75(76,(char*)"-table",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Extraire des tables de valeurs d'un maillage fem");
140     MAGIC_PARAMETRE_APPLICATION p76(77,(char*)"-noeud",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Action sur les noeuds");
141     MAGIC_PARAMETRE_APPLICATION p77(78,(char*)"-element1",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Action sur les element1D");
142     MAGIC_PARAMETRE_APPLICATION p78(79,(char*)"-element2",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Action sur les element2D");
143     MAGIC_PARAMETRE_APPLICATION p79(80,(char*)"-element3",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Action sur les element3D");
144 francois 698 MAGIC_PARAMETRE_APPLICATION p80(81,(char*)"-numtopo",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Action uniquement sur le numero de topologie mentionnée");
145 francois 702 MAGIC_PARAMETRE_APPLICATION p81(82,(char*)"-maigmsh",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Importation d'un maillage de GMSH (-in peut être omis -out peut etre omis si -in n'est pas omis -numgeo le defaut correspond à un non attechement du maillage)");
146     MAGIC_PARAMETRE_APPLICATION p82(83,(char*)"-fichiergmsh",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Nom du fichier gmsh");
147 francois 706 MAGIC_PARAMETRE_APPLICATION p83(84,(char*)"-param",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Nom du fichier parametre");
148     MAGIC_PARAMETRE_APPLICATION p84(85,(char*)"-creeparam",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Création d'un fichier parametre");
149 francois 712 MAGIC_PARAMETRE_APPLICATION p85(86,(char*)"-importefonction",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Importation d'une fonction dans une géométrie");
150     MAGIC_PARAMETRE_APPLICATION p86(87,(char*)"-fichier",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Nom du fichier à importer");
151 couturad 719 MAGIC_PARAMETRE_APPLICATION p87(88,(char*)"-elastique_gd",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Calcul aster en elasticite grandes deformations");
152     MAGIC_PARAMETRE_APPLICATION p88(89,(char*)"-plastique",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Calcul aster en plasticite");
153 francois 757 MAGIC_PARAMETRE_APPLICATION p89(90,(char*)"-base",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Base de numerotation des entités code aster - Defaut 10");
154     MAGIC_PARAMETRE_APPLICATION p90(91,(char*)"-element_gauss1",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Action aux points de gauss sur les element1D");
155     MAGIC_PARAMETRE_APPLICATION p91(92,(char*)"-element_gauss2",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Action aux points de gauss sur les element2D");
156     MAGIC_PARAMETRE_APPLICATION p92(93,(char*)"-element_gauss3",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Action aux points de gauss sur les element3D");
157 francois 763 MAGIC_PARAMETRE_APPLICATION p93(94,(char*)"-ccfi",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Application de conditions aux limites sur une topologie par identificateur d'une autre entité MAGiC");
158     MAGIC_PARAMETRE_APPLICATION p94(95,(char*)"-ccfit",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Application de conditions aux limites sur une topologie et sur les topologie sous jacente par identificateur d'une autre entité MAGiC");
159     MAGIC_PARAMETRE_APPLICATION p95(96,(char*)"-ccff",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Application de conditions aux limites sur une topologie sous forme de formule");
160     MAGIC_PARAMETRE_APPLICATION p96(97,(char*)"-ccfft",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Application de conditions aux limites sur une topologie et sur les topologie sous forme de formule");
161 couturad 719
162 francois 763
163 francois 454 p1.ajouter_dependance(1);p1.ajouter_dependance(3);p1.ajouter_dependance(55);
164 francois 432 p3.ajouter_dependance(1);p3.ajouter_dependance(5);
165 francois 706 p5.ajouter_dependance(1);p5.ajouter_dependance(7);p5.ajouter_dependance(85);
166 francois 432 p7.ajouter_dependance(1);
167     p8.ajouter_dependance(1);p8.ajouter_dependance(10);
168 francois 652 p10.ajouter_dependance(1);p10.ajouter_dependance(13);p10.ajouter_dependance(14);p10.ajouter_dependance(15);;p10.ajouter_dependance(16);
169 francois 432 p11.ajouter_dependance(1);p11.ajouter_dependance(10);
170 francois 652 p16.ajouter_dependance(1);p16.ajouter_dependance(13);p16.ajouter_dependance(14);p16.ajouter_dependance(15);;p16.ajouter_dependance(16);
171 francois 656 p17.ajouter_dependance(1);p17.ajouter_dependance(19);p17.ajouter_dependance(20);p17.ajouter_dependance(75);
172 francois 757 p20.ajouter_dependance(1);p20.ajouter_dependance(19);p20.ajouter_dependance(22);p20.ajouter_dependance(90);
173 francois 706 //p22.ajouter_dependance(1);p22.ajouter_dependance(7);
174 francois 432 p23.ajouter_dependance(1);p23.ajouter_dependance(19);p23.ajouter_dependance(25);p23.ajouter_dependance(26);p23.ajouter_dependance(27);p23.ajouter_dependance(28);
175     p28.ajouter_dependance(1);p28.ajouter_dependance(31);p28.ajouter_dependance(32);p28.ajouter_dependance(33);p28.ajouter_dependance(34);
176     p29.ajouter_dependance(1);p29.ajouter_dependance(31);p29.ajouter_dependance(32);p29.ajouter_dependance(33);p29.ajouter_dependance(34);
177     p34.ajouter_dependance(1);p34.ajouter_dependance(19);p34.ajouter_dependance(36);p34.ajouter_dependance(37);
178 francois 516 p37.ajouter_dependance(1);p37.ajouter_dependance(19);p37.ajouter_dependance(40);p37.ajouter_dependance(41);p37.ajouter_dependance(42);p37.ajouter_dependance(43);p37.ajouter_dependance(44);p37.ajouter_dependance(45);p37.ajouter_dependance(61);
179 francois 432 p38.ajouter_dependance(1);p38.ajouter_dependance(31);
180     p45.ajouter_dependance(1);p45.ajouter_dependance(31);p45.ajouter_dependance(49);
181     p46.ajouter_dependance(1);p46.ajouter_dependance(31);p46.ajouter_dependance(49);
182     p49.ajouter_dependance(1);p49.ajouter_dependance(19);p49.ajouter_dependance(51);p49.ajouter_dependance(5);
183     p51.ajouter_dependance(1);p51.ajouter_dependance(10);p51.ajouter_dependance(53);
184 couturad 719 p53.ajouter_dependance(1);p53.ajouter_dependance(7);p53.ajouter_dependance(19);p53.ajouter_dependance(63);p53.ajouter_dependance(64);p53.ajouter_dependance(65);p53.ajouter_dependance(66);p53.ajouter_dependance(84);p53.ajouter_dependance(85);p53.ajouter_dependance(88);p53.ajouter_dependance(89);
185 francois 469 p55.ajouter_dependance(1);
186 francois 475 p56.ajouter_dependance(1);p56.ajouter_dependance(19);
187 francois 514 p57.ajouter_dependance(1);p57.ajouter_dependance(19);p57.ajouter_dependance(59);
188     p59.ajouter_dependance(1);p59.ajouter_dependance(19);p59.ajouter_dependance(59);
189 francois 517 p61.ajouter_dependance(1);p61.ajouter_dependance(5);p61.ajouter_dependance(19);
190 francois 628 p66.ajouter_dependance(1);p66.ajouter_dependance(31);p66.ajouter_dependance(68);p66.ajouter_dependance(69);p66.ajouter_dependance(70);p66.ajouter_dependance(71);
191     p71.ajouter_dependance(1);p71.ajouter_dependance(73);p71.ajouter_dependance(68);p71.ajouter_dependance(69);p71.ajouter_dependance(19);p71.ajouter_dependance(5);
192     p73.ajouter_dependance(1);p73.ajouter_dependance(5);p73.ajouter_dependance(40);p73.ajouter_dependance(41);p73.ajouter_dependance(43);p73.ajouter_dependance(44);
193 francois 757 p75.ajouter_dependance(1);p75.ajouter_dependance(5);p75.ajouter_dependance(19);p75.ajouter_dependance(77);p75.ajouter_dependance(78);p75.ajouter_dependance(79);p75.ajouter_dependance(80);p75.ajouter_dependance(81);p75.ajouter_dependance(91);p75.ajouter_dependance(92);p75.ajouter_dependance(93);
194 francois 702 p81.ajouter_dependance(1);p81.ajouter_dependance(5);p81.ajouter_dependance(31);p81.ajouter_dependance(83);
195 francois 712 p85.ajouter_dependance(1);p85.ajouter_dependance(31);p85.ajouter_dependance(87);
196 francois 763 p93.ajouter_dependance(1);p93.ajouter_dependance(31);p93.ajouter_dependance(49);
197     p94.ajouter_dependance(1);p94.ajouter_dependance(31);p94.ajouter_dependance(49);
198     p95.ajouter_dependance(1);p95.ajouter_dependance(31);p95.ajouter_dependance(49);
199     p96.ajouter_dependance(1);p96.ajouter_dependance(31);p96.ajouter_dependance(49);
200 francois 432 lst.push_back(p1);
201     lst.push_back(p2);
202     lst.push_back(p3);
203     lst.push_back(p4);
204     lst.push_back(p5);
205     lst.push_back(p6);
206     lst.push_back(p7);
207     lst.push_back(p8);
208     lst.push_back(p9);
209     lst.push_back(p10);
210     lst.push_back(p11);
211     lst.push_back(p12);
212     lst.push_back(p13);
213     lst.push_back(p14);
214     lst.push_back(p15);
215     lst.push_back(p16);
216     lst.push_back(p17);
217     lst.push_back(p18);
218     lst.push_back(p19);
219     lst.push_back(p20);
220     lst.push_back(p21);
221     lst.push_back(p22);
222     lst.push_back(p23);
223     lst.push_back(p24);
224     lst.push_back(p25);
225     lst.push_back(p26);
226     lst.push_back(p27);
227     lst.push_back(p28);
228     lst.push_back(p29);
229     lst.push_back(p30);
230     lst.push_back(p31);
231     lst.push_back(p32);
232     lst.push_back(p33);
233     lst.push_back(p34);
234     lst.push_back(p35);
235     lst.push_back(p36);
236     lst.push_back(p37);
237     lst.push_back(p38);
238     lst.push_back(p39);
239     lst.push_back(p40);
240     lst.push_back(p41);
241     lst.push_back(p42);
242     lst.push_back(p43);
243     lst.push_back(p44);
244     lst.push_back(p45);
245     lst.push_back(p46);
246     lst.push_back(p47);
247     lst.push_back(p48);
248     lst.push_back(p49);
249     lst.push_back(p50);
250     lst.push_back(p51);
251     lst.push_back(p52);
252     lst.push_back(p53);
253 francois 454 lst.push_back(p54);
254 francois 469 lst.push_back(p55);
255 francois 475 lst.push_back(p56);
256 francois 514 lst.push_back(p57);
257     lst.push_back(p58);
258     lst.push_back(p59);
259 francois 516 lst.push_back(p60);
260 francois 517 lst.push_back(p61);
261 mejrim 597 lst.push_back(p62);
262     lst.push_back(p63);
263 francois 603 lst.push_back(p64);
264     lst.push_back(p65);
265 francois 604 lst.push_back(p66);
266     lst.push_back(p67);
267     lst.push_back(p68);
268     lst.push_back(p69);
269     lst.push_back(p70);
270 francois 628 lst.push_back(p71);
271     lst.push_back(p72);
272     lst.push_back(p73);
273 francois 697 lst.push_back(p74);
274     lst.push_back(p75);
275     lst.push_back(p76);
276     lst.push_back(p77);
277     lst.push_back(p78);
278     lst.push_back(p79);
279 francois 698 lst.push_back(p80);
280 francois 702 lst.push_back(p81);
281     lst.push_back(p82);
282 francois 706 lst.push_back(p83);
283     lst.push_back(p84);
284 francois 712 lst.push_back(p85);
285     lst.push_back(p86);
286 couturad 719 lst.push_back(p87);
287     lst.push_back(p88);
288 francois 757 lst.push_back(p89);
289     lst.push_back(p90);
290     lst.push_back(p91);
291     lst.push_back(p92);
292 francois 763 lst.push_back(p93);
293     lst.push_back(p94);
294     lst.push_back(p95);
295     lst.push_back(p96);
296 francois 432 MAGIC_APPLICATION app((char*)"Operation dans l'environnement MAGiC",argc,argv,lst,true,false);
297     char nomfichier[3000];
298     char* p;
299     if (app.get_action()!=48)
300     {
301     if (app.get_erreur()==true) return 0;
302 francois 748 if ((app.get_action()!=82) && (app.get_action()!=54)&& (app.get_action()!=6))
303 francois 702 {
304     app.recupere_parametre_string(1,nomfichier,(char*)"Fichier entrant manquant");
305     p=strrchr(nomfichier,'.');
306     }
307 francois 432 }
308     char chaine[1000];for (int i=0;i<1000;i++) chaine[i]=0;
309     if (app.get_action()==2)
310     {
311     bool desactivedeforme;
312     app.recupere_parametre_bool_avec_defaut(4,desactivedeforme,false);
313 francois 454 bool corres;
314     app.recupere_parametre_bool_avec_defaut(55,corres,false);
315 francois 432 if (app.get_erreur()==true) return 0;
316     char mess[2000];
317     sprintf(mess,"Conversion MAGiC vers GMSH");
318     app.affiche(mess);
319 francois 283 MG_FILE gest(nomfichier);
320     int nb=gest.get_nb_mg_maillage();
321     for (int i=0;i<nb;i++)
322     {
323     MG_MAILLAGE* mai=gest.get_mg_maillage(i);
324     unsigned long id=mai->get_id();
325     strncpy(chaine,nomfichier,p-nomfichier);
326     char chaine2[3000];
327     sprintf(chaine2,"%s%lu",chaine,id);
328     std::string namefic=chaine2;
329     MG_EXPORT exp;
330 francois 339 sprintf(mess," Maillage geometrique : creation de %s.msh",namefic.c_str());
331 francois 432 app.affiche(mess);
332 francois 454 if (corres==false) exp.gmsh(mai,namefic); else exp.gmsh_avec_correspondance(mai,namefic);
333     }
334 francois 283 nb=gest.get_nb_fem_maillage();
335     for (int i=0;i<nb;i++)
336     {
337     FEM_MAILLAGE* mai=gest.get_fem_maillage(i);
338 francois 432 if (desactivedeforme) mai->desactive_deforme();
339 gervaislavoie 304 unsigned long id=mai->get_id();
340 francois 283 strncpy(chaine,nomfichier,p-nomfichier);
341     char chaine2[3000];
342     sprintf(chaine2,"%s%lu",chaine,id);
343     std::string namefic=chaine2;
344     MG_EXPORT exp;
345 francois 331 sprintf(mess," Maillage EF : Creation de %s.msh",namefic.c_str());
346 francois 432 app.affiche(mess);
347 francois 454 if (corres==false) exp.gmsh(mai,namefic); else exp.gmsh_avec_correspondance(mai,namefic);
348 francois 283 }
349     }
350 francois 432 if (app.get_action()==4)
351 francois 331 {
352 francois 432 char fichierout[2000];
353     app.recupere_parametre_string(5,fichierout,(char*)"Fichier sortant manquant");
354     if (app.get_erreur()==true) return 0;
355     char mess[2000];
356     sprintf(mess,"Copie de fichier MAGiC");
357     app.affiche(mess);
358 francois 331 MG_FILE gest(nomfichier);
359     gest.enregistrer(fichierout);
360 francois 432 }
361     if (app.get_action()==6)
362 francois 283 {
363 francois 432 char mess[500];
364     char coderesu[10];
365 francois 706 char nomparam[500];
366 francois 748 bool creeparam;
367 francois 706 app.recupere_parametre_string_avec_defaut(7,coderesu,(char*)"11111111");
368 francois 748 app.recupere_parametre_bool_avec_defaut(85,creeparam,false);
369     if (!creeparam) app.recupere_parametre_string(84,nomparam,(char*)"Fichier parametre manquant");
370     if (!creeparam) app.recupere_parametre_string(1,nomfichier,(char*)"Fichier entrant manquant");
371 francois 706 app.recupere_parametre_string(84,nomparam,(char*)"Fichier parametre manquant");
372 francois 748 if (app.get_erreur()==true) return 0;
373     if (creeparam)
374     {
375     char mess[500];
376     sprintf(mess," Calcul ASTER\n\nCréation d'un fichier parametre\n");
377     app.affiche(mess);
378     MG_EXPORT exp;
379     exp.ecrire_params_aster(nomparam);
380     }
381     else
382     {
383 francois 432 sprintf(mess,"Conversion MAGiC vers code ASTER");
384     app.affiche(mess);
385 francois 283 MG_FILE gest(nomfichier);
386     int nb=gest.get_nb_fem_maillage();
387     for (int i=0;i<nb;i++)
388     {
389     FEM_MAILLAGE* mai=gest.get_fem_maillage(i);
390 francois 748 MG_GEOMETRIE* geo=mai->get_mg_geometrie();
391 francois 283 unsigned long id=mai->get_id();
392 francois 748 p=strrchr(nomfichier,'.');
393     strncpy(chaine,nomfichier,p-nomfichier);
394 francois 283 char chaine2[3000];
395     sprintf(chaine2,"%s%lu",chaine,id);
396     std::string namefic=chaine2;
397     MG_EXPORT exp;
398 francois 706 exp.lire_params_aster(nomparam);
399 francois 748 exp.aster(geo,mai,namefic,MAGIC::CALCUL_ASTER::ELASTIQUE,coderesu);
400 francois 283 }
401 francois 748
402     }
403 francois 283 }
404 francois 432 if (app.get_action()==8)
405 francois 283 {
406 francois 432 if (app.get_erreur()==true) return 0;
407     char mess[500];
408 francois 505 sprintf(mess," Conversion carte de taille ancienne version vers GMSH");
409 francois 432 app.affiche(mess);
410     FCT_GENERATEUR_3D<4> carte;
411 francois 283 carte.lire(nomfichier);
412     strncpy(chaine,nomfichier,p-nomfichier);
413     std::string namefic=chaine;
414 francois 492 FCT_EXPORT exp;
415 francois 283 exp.gmsh(&carte,namefic);
416 francois 432 }
417     #ifdef BREP_STEP
418     if (app.get_action()==9)
419 francois 283 {
420 francois 432 double unite;
421     app.recupere_parametre_double_avec_defaut(10,unite,1.);
422     if (app.get_erreur()==true) return 0;
423     char mess[500];
424     sprintf(mess," Conversion STEP vers MAGiC");
425     app.affiche(mess);
426 francois 283 STEP_IMPORT stepimport;
427     MG_GESTIONNAIRE gest;
428     stepimport.importer(gest,nomfichier) ;
429     strncpy(chaine,nomfichier,p-nomfichier);
430     std::string namefic=chaine;
431     namefic=namefic + ".magic";
432     int nb=gest.get_nb_mg_geometrie();
433     for (int i=0;i<nb;i++)
434     gest.get_mg_geometrie(i)->change_valeur_unite(unite);
435     gest.enregistrer(namefic.c_str());
436     }
437 francois 432 #endif
438     #ifdef BREP_OCC
439     if (app.get_action()==11)
440 francois 283 {
441 francois 652 double eps,eps2;
442 francois 432 bool importstl,importtriangulation;
443     app.recupere_parametre_double_avec_defaut(13,eps,0.000001);
444     app.recupere_parametre_double_avec_defaut(14,eps2,1.);
445     app.recupere_parametre_bool_avec_defaut(15,importstl,false);
446     app.recupere_parametre_bool_avec_defaut(16,importtriangulation,false);
447     if (app.get_erreur()==true) return 0;
448     int importtri=0;
449     if (importstl) importtri=1;
450     if (importtriangulation) importtri=2;
451     char mess[500];
452     sprintf(mess," Conversion STEP via OpenCascade vers MAGiC avec epsilon=%lf",eps);
453     app.affiche(mess);
454 francois 283 MG_GESTIONNAIRE gest;
455 francois 432 OCC_IMPORT occimport;
456 francois 652 MG_GEOMETRIE* mggeo=occimport.importer(gest,nomfichier,FICHIERSTEP,eps) ;
457 francois 432 if (importtri>0) occimport.importer(gest,mggeo,eps2,importtri);
458 francois 283 strncpy(chaine,nomfichier,p-nomfichier);
459     std::string namefic=chaine;
460     namefic=namefic + ".magic";
461     gest.enregistrer(namefic.c_str());
462     }
463 francois 432 #endif
464     #ifdef BREP_SAT
465     if (app.get_action()==12)
466 francois 283 {
467 francois 432 double unite;
468     app.recupere_parametre_double_avec_defaut(10,unite,1.);
469     if (app.get_erreur()==true) return 0;
470     char mess[500];
471     sprintf(mess," Conversion SAT vers MAGiC");
472     app.affiche(mess);
473 francois 283 MG_GESTIONNAIRE gest;
474 francois 432 ACIS_IMPORT acisimport;
475     acisimport.importer(gest,nomfichier) ;
476 francois 283 strncpy(chaine,nomfichier,p-nomfichier);
477     std::string namefic=chaine;
478     namefic=namefic + ".magic";
479     int nb=gest.get_nb_mg_geometrie();
480     for (int i=0;i<nb;i++)
481     gest.get_mg_geometrie(i)->change_valeur_unite(unite);
482     gest.enregistrer(namefic.c_str());
483     }
484 francois 432 #endif
485     #ifdef BREP_OCC
486     if (app.get_action()==17)
487 francois 283 {
488 francois 652 double eps,eps2;
489 francois 432 bool importstl,importtriangulation;
490     app.recupere_parametre_double_avec_defaut(13,eps,0.000001);
491     app.recupere_parametre_double_avec_defaut(14,eps2,1.);
492     app.recupere_parametre_bool_avec_defaut(15,importstl,false);
493     app.recupere_parametre_bool_avec_defaut(16,importtriangulation,false);
494     if (app.get_erreur()==true) return 0;
495     int importtri=0;
496     if (importstl) importtri=1;
497     if (importtriangulation) importtri=2;
498     char mess[500];
499     sprintf(mess," Conversion OpenCascade vers MAGiC");
500     app.affiche(mess);
501 francois 283 MG_GESTIONNAIRE gest;
502     OCC_IMPORT occimport;
503 francois 652 MG_GEOMETRIE* mggeo=occimport.importer(gest,nomfichier,FICHIEROCC,eps) ;
504 francois 283 if (importtri>0) occimport.importer(gest,mggeo,eps2,importtri);
505     strncpy(chaine,nomfichier,p-nomfichier);
506     std::string namefic=chaine;
507     namefic=namefic + ".magic";
508     gest.enregistrer(namefic.c_str());
509 francois 432 }
510 francois 283 #endif
511 francois 432 if (app.get_action()==18)
512 francois 283 {
513 francois 432 int degre,nummai;
514 francois 656 bool analyse;
515 francois 432 app.recupere_parametre_int_avec_defaut(19,nummai,0);
516     app.recupere_parametre_int(20,degre,(char*)"Degré du maillage manquant");
517 francois 656 app.recupere_parametre_bool_avec_defaut(75,analyse,false);
518 francois 432 if (app.get_erreur()==true) return 0;
519     char mess[500];
520 francois 283 sprintf(mess," Creation d'un maillage FEM");
521 francois 432 app.affiche(mess);
522 francois 283 MG_FILE gest(nomfichier);
523 francois 432 MG_MAILLAGE* mai;
524     if (nummai==0) mai=gest.get_mg_maillage(nummai); else mai=gest.get_mg_maillageid(nummai);
525 francois 283 FEM_MAILLAGE* fem=new FEM_MAILLAGE(mai->get_mg_geometrie(),mai,degre);
526     gest.ajouter_fem_maillage(fem);
527     fem->construire(0);
528     gest.enregistrer(nomfichier);
529 francois 656 if (analyse==true)
530     if (degre==2)
531 francois 612 {
532     //char message [5000];
533     FEM_MAILLAGE_QUADRATIQUE_OUTILS ou ;
534     double moy=ou.get_distortion_moy(fem);
535     double min=ou.get_distortion_min (fem);
536     int nb=ou.get_nombre_elements_invalides(fem);
537     sprintf(mess," maillage quadratique :");
538     app.affiche(mess);
539     sprintf(mess," ");
540     app.affiche(mess);
541     sprintf(mess," distorsion moy %f ",moy);
542     app.affiche(mess);
543     sprintf(mess," distorsion min %f ",min);
544     app.affiche(mess);
545     sprintf(mess," nombre elements invalides %d ",nb);
546     app.affiche(mess);
547     }
548    
549    
550 francois 432 }
551     if (app.get_action()==21)
552 francois 283 {
553 francois 432 int nummai;
554     char fichieraster[500];
555 francois 757 int base;
556 francois 432 app.recupere_parametre_int_avec_defaut(19,nummai,0);
557 francois 535 app.recupere_parametre_string(22,fichieraster,(char*)"Fichier aster manquant");
558 francois 757 app.recupere_parametre_int_avec_defaut(90,base,10);
559 francois 432 if (app.get_erreur()==true) return 0;
560     char mess[500];
561 francois 283 sprintf(mess," Importation des résultats ASTER vers MAGIC");
562 francois 432 app.affiche(mess);
563 francois 283 MG_FILE gest(nomfichier);
564 francois 432 FEM_MAILLAGE* mai;
565     if (nummai==0) mai=gest.get_fem_maillage(nummai); else mai=gest.get_fem_maillageid(nummai);
566 francois 283 MG_IMPORT imp;
567 francois 757 std::string res=imp.aster(base,mai,fichieraster,nomfichier);
568 francois 691 app.affiche((char*)("\033[1;31m"+res+"\033[1;32m").c_str());
569 francois 283 gest.enregistrer(nomfichier);
570 francois 432 }
571    
572     if (app.get_action()==23)
573 francois 283 {
574 francois 706
575 francois 283 }
576 francois 432 if (app.get_action()==24)
577 francois 283 {
578 francois 432 int nummai;
579     char fichieroptis[500];
580     char fichierflottant[500];
581     double niveau,seuil;
582     app.recupere_parametre_int_avec_defaut(19,nummai,0);
583     app.recupere_parametre_string(25,fichieroptis,(char*)"Fichier OPTIS manquant");
584     app.recupere_parametre_string_avec_defaut(26,fichieroptis,(char*)"");
585     app.recupere_parametre_double(27,seuil,(char*)"Seuil manquant");
586     app.recupere_parametre_double(28,niveau,(char*)"Niveau manquant");
587     if (app.get_erreur()==true) return 0;
588     char mess[500];
589     sprintf(mess," Importation des résultats d'optimisation vers MAGIC");
590     app.affiche(mess);
591 francois 283 MG_FILE gest(nomfichier);
592 francois 432 FEM_MAILLAGE* mai;
593     if (nummai==0) mai=gest.get_fem_maillage(nummai); else mai=gest.get_fem_maillageid(nummai);
594 francois 283 MG_IMPORT imp;
595 francois 432 int flottant=0;
596     if (strlen(fichierflottant)>0) flottant=1;
597 francois 283 imp.optis(mai,fichieroptis,fichierflottant,seuil,niveau,flottant);
598     gest.enregistrer(nomfichier);
599 francois 432 }
600    
601     if (app.get_action()==29)
602 francois 283 {
603 francois 432 int numgeo,numgt,numentite;
604     bool expand;
605     app.recupere_parametre_int_avec_defaut(31,numgeo,0);
606     app.recupere_parametre_int_avec_defaut(32,numgt,0);
607     app.recupere_parametre_int(33,numentite,(char*)"Numéro d'entité manquant");
608     app.recupere_parametre_bool_avec_defaut(34,expand,false);
609     if (app.get_erreur()==true) return 0;
610     char mess[500];
611     sprintf(mess," Selection de groupe topologique");
612     app.affiche(mess);
613 francois 283 MG_FILE gest(nomfichier);
614 francois 432 MG_GEOMETRIE* mggeo;
615     if (numgeo==0) mggeo=gest.get_mg_geometrie(numgeo); else mggeo=gest.get_mg_geometrieid(numgeo);
616 francois 283 MG_GROUPE_TOPOLOGIQUE* mggt;
617     if (numgt==0)
618     {
619     mggt=new MG_GROUPE_TOPOLOGIQUE;
620     mggeo->ajouter_mg_groupe_topologique(mggt);
621     }
622     else mggt=mggeo->get_mg_groupe_topologiqueid(numgt);
623     MG_ELEMENT_TOPOLOGIQUE* ele;
624     ele=mggeo->get_mg_sommetid(numentite);
625     if (ele==NULL) ele=mggeo->get_mg_areteid(numentite);
626     if (ele==NULL) ele=mggeo->get_mg_faceid(numentite);
627     if (ele==NULL) ele=mggeo->get_mg_volumeid(numentite);
628     if (ele!=NULL)
629     {
630     mggt->ajouter(ele);
631     if (expand)
632     {
633     TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> lst;
634     ele->get_topologie_sousjacente(&lst);
635     TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*>::ITERATEUR it;
636     for (MG_ELEMENT_TOPOLOGIQUE *ele2=lst.get_premier(it);ele2!=NULL;ele2=lst.get_suivant(it))
637     mggt->ajouter(ele2);
638     }
639     }
640     gest.enregistrer(nomfichier);
641     }
642 francois 432 if (app.get_action()==30)
643 francois 283 {
644 francois 432 int numgeo,numgt,numentite;
645     bool expand;
646     app.recupere_parametre_int_avec_defaut(31,numgeo,0);
647     app.recupere_parametre_int_avec_defaut(32,numgt,0);
648     app.recupere_parametre_int(33,numentite,(char*)"Numéro d'entité manquant");
649     app.recupere_parametre_bool_avec_defaut(34,expand,false);
650     if (app.get_erreur()==true) return 0;
651     char mess[500];
652     sprintf(mess," Deselection de groupe topologique");
653     app.affiche(mess);
654 francois 283 MG_FILE gest(nomfichier);
655     MG_GEOMETRIE* mggeo=gest.get_mg_geometrieid(numgeo);
656     MG_GROUPE_TOPOLOGIQUE* mggt=mggeo->get_mg_groupe_topologiqueid(numgt);
657     MG_ELEMENT_TOPOLOGIQUE* ele;
658     ele=mggeo->get_mg_sommetid(numentite);
659     if (ele==NULL) ele=mggeo->get_mg_areteid(numentite);
660     if (ele==NULL) ele=mggeo->get_mg_faceid(numentite);
661     if (ele==NULL) ele=mggeo->get_mg_volumeid(numentite);
662     if (ele!=NULL)
663     {
664     mggt->supprimer(ele);
665     if (expand)
666     {
667     TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> lst;
668     ele->get_topologie_sousjacente(&lst);
669     TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*>::ITERATEUR it;
670     for (MG_ELEMENT_TOPOLOGIQUE *ele2=lst.get_premier(it);ele2!=NULL;ele2=lst.get_suivant(it))
671     mggt->supprimer(ele2);
672     }
673     }
674     gest.enregistrer(nomfichier);
675 francois 432 }
676    
677     if (app.get_action()==35)
678 francois 283 {
679 francois 432 int nummai;
680     double angle;
681     char fichierlog[500];
682 francois 477 strcpy(fichierlog,"");
683 francois 432 app.recupere_parametre_int_avec_defaut(19,nummai,-1);
684     app.recupere_parametre_double_avec_defaut(36,angle,0.03);
685     app.recupere_parametre_string_avec_defaut(37,fichierlog,(char*)fichierlog);
686     if (app.get_erreur()==true) return 0;
687     char mess[500];
688     sprintf(mess," Contenu d'un fichier MAGIC");
689     app.affiche(mess);
690 francois 283 MG_FILE gest(nomfichier);
691 francois 425 if (nummai!=-1)
692     {
693     MG_MAILLAGE* mai=gest.get_mg_maillageid(nummai);
694     MAILLEUR_ANALYSE m3d(mai);
695 francois 432 m3d.active_affichage(app.affiche);
696 francois 426 m3d.change_eps_angle_retourne(angle);
697 francois 432 if (strlen(fichierlog)==0)
698 francois 425 m3d.analyse();
699     else
700     m3d.analyse(fichierlog);
701     }
702     else
703     {
704     char message [5000];
705 francois 691 int nbarbre=gest.get_nb_mg_arbre();
706     sprintf(message," \033[1;32m%d\033[1;33m arbres :",nbarbre);
707     for (int i=0;i<nbarbre;i++)
708     {
709     MG_ARBRE* arb=gest.get_mg_arbre(i);
710     sprintf(message,"%s \033[1;31m%lu\033[1;33m ",message,arb->get_id());
711     }
712     app.affiche(message);
713     for (int i=0;i<nbarbre;i++)
714     {
715     MG_ARBRE* arb=gest.get_mg_arbre(i);
716     sprintf(message," arbre \033[1;31m%lu\033[1;33m",arb->get_id());
717     app.affiche(message);
718 francois 742 int nbass=arb->get_nb_mg_assemblage();
719     sprintf(message," \033[1;32m%d\033[1;33m assemblages",nbass);
720     app.affiche(message);
721 francois 691 int nbprim=arb->get_nb_mg_primitive();
722     sprintf(message," \033[1;32m%d\033[1;33m primitives",nbprim);
723     //for (int i=0;i<nbprim;i++) sprintf(message,"%s \033[1;31m%lu\033[1;33m",message,arb->get_mg_primitive(i)->get_id());
724     app.affiche(message);
725     int nbope=arb->get_nb_mg_operateur_boolean();
726     sprintf(message," \033[1;32m%d\033[1;33m operateurs booleans",nbope);
727     app.affiche(message);
728     }
729     int nbgeo=gest.get_nb_mg_geometrie();
730     sprintf(message," \033[1;32m%d\033[1;33m geometries :",nbgeo);
731 francois 283 for (int i=0;i<nbgeo;i++)
732     {
733     MG_GEOMETRIE* geo=gest.get_mg_geometrie(i);
734 francois 691 sprintf(message,"%s \033[1;31m%lu\033[1;33m ",message,geo->get_id());
735 francois 283 }
736 francois 432 app.affiche(message);
737 francois 283 for (int i=0;i<nbgeo;i++)
738     {
739     MG_GEOMETRIE* geo=gest.get_mg_geometrie(i);
740 francois 691 sprintf(message," geometrie \033[1;31m%lu\033[1;33m",geo->get_id());
741 francois 432 app.affiche(message);
742 francois 283 int nbmg=geo->get_nb_mg_groupe_topologique();
743 francois 691 sprintf(message," \033[1;32m%d\033[1;33m groupe topologique",nbmg);
744 francois 283 for (int j=0;j<nbmg;j++)
745     {
746     MG_GROUPE_TOPOLOGIQUE* mggp=geo->get_mg_groupe_topologique(j);
747 francois 691 sprintf(message,"%s \033[1;31m%lu\033[1;33m ",message,mggp->get_id());
748 francois 283 }
749 francois 432 app.affiche(message);
750 francois 299 int nbvolume=geo->get_nb_mg_volume();
751 francois 691 if (nbvolume==0) sprintf(message," \033[1;32m%d\033[1;33m volumes",geo->get_nb_mg_volume());
752     else sprintf(message," \033[1;32m%d\033[1;33m volumes : ",geo->get_nb_mg_volume());
753     for (int i=0;i<nbvolume;i++) sprintf(message,"%s \033[1;31m%lu\033[1;33m",message,geo->get_mg_volume(i)->get_id());
754 francois 432 app.affiche(message);
755 francois 299 int nbcoque=geo->get_nb_mg_coque();
756 francois 691 if (nbcoque==0) sprintf(message," \033[1;32m%d\033[1;33m coques",geo->get_nb_mg_coque());
757     else sprintf(message," \033[1;32m%d\033[1;33m coques : ",geo->get_nb_mg_coque());
758     for (int i=0;i<nbcoque;i++) sprintf(message,"%s \033[1;31m%lu\033[1;33m",message,geo->get_mg_coque(i)->get_id());
759 francois 432 app.affiche(message);
760 francois 299 int nbpoutre=geo->get_nb_mg_poutre();
761 francois 691 if (nbpoutre==0) sprintf(message," \033[1;32m%d\033[1;33m poutres",geo->get_nb_mg_poutre());
762     else sprintf(message," \033[1;32m%d\033[1;33m poutres : ",geo->get_nb_mg_poutre());
763     for (int i=0;i<nbpoutre;i++) sprintf(message,"%s \033[1;31m%lu\033[1;33m",message,geo->get_mg_poutre(i)->get_id());
764 francois 432 app.affiche(message);
765 francois 691 sprintf(message," \033[1;32m%d\033[1;33m coquilles",geo->get_nb_mg_coquille());
766 francois 432 app.affiche(message);
767 francois 691 sprintf(message," \033[1;32m%d\033[1;33m faces",geo->get_nb_mg_face());
768 francois 432 app.affiche(message);
769 francois 691 sprintf(message," \033[1;32m%d\033[1;33m aretes",geo->get_nb_mg_arete());
770 francois 432 app.affiche(message);
771 francois 691 sprintf(message," \033[1;32m%d\033[1;33m sommets",geo->get_nb_mg_sommet());
772 francois 432 app.affiche(message);
773 francois 716 int nbgef=geo->get_nb_mg_geom_fonction();
774     if (nbgef==0) sprintf(message," \033[1;32m%d\033[1;33m fonctions geometriques",nbgef);
775     else sprintf(message," \033[1;32m%d\033[1;33m fonctions geometriques : ",nbgef);
776     for (int i=0;i<nbgef;i++) sprintf(message,"%s \033[1;31m%lu\033[1;33m",message,geo->get_mg_geom_fonction(i)->get_id());
777     app.affiche(message);
778 francois 283
779     }
780     int nbmai=gest.get_nb_mg_maillage();
781 francois 691 sprintf(message," \033[1;32m%d\033[1;33m maillage geometrique :",nbmai);
782 francois 432 app.affiche(message);
783 francois 283 for (int i=0;i<nbmai;i++)
784     {
785     MG_MAILLAGE* mai=gest.get_mg_maillage(i);
786 francois 691 sprintf(message," maillage geometrique \033[1;31m%lu\033[1;33m ",mai->get_id());
787 francois 432 app.affiche(message);
788 francois 691 sprintf(message," \033[1;32m%d\033[1;33m noeuds",mai->get_nb_mg_noeud());
789 francois 432 app.affiche(message);
790 francois 691 sprintf(message," \033[1;32m%d\033[1;33m segments",mai->get_nb_mg_segment());
791 francois 432 app.affiche(message);
792 francois 691 sprintf(message," \033[1;32m%d\033[1;33m triangles",mai->get_nb_mg_triangle());
793 francois 432 app.affiche(message);
794 francois 691 sprintf(message," \033[1;32m%d\033[1;33m quadrangles",mai->get_nb_mg_quadrangle());
795 francois 674 app.affiche(message);
796 francois 691 sprintf(message," \033[1;32m%d\033[1;33m tetras",mai->get_nb_mg_tetra());
797 francois 432 app.affiche(message);
798 francois 691 sprintf(message," \033[1;32m%d\033[1;33m hexas",mai->get_nb_mg_hexa());
799 francois 674 app.affiche(message);
800 francois 283 }
801     int nbmaif=gest.get_nb_fem_maillage();
802 francois 691 sprintf(message," \033[1;32m%d\033[1;33m maillage FEM :",nbmaif);
803 francois 432 app.affiche(message);
804 francois 283 for (int i=0;i<nbmaif;i++)
805     {
806     FEM_MAILLAGE* maif=gest.get_fem_maillage(i);
807 francois 748 sprintf(message," maillage FEM \033[1;31m%lu\033[1;33m ",maif->get_id());
808 francois 432 app.affiche(message);
809 francois 691 sprintf(message," \033[1;32m%d\033[1;33m noeuds",maif->get_nb_fem_noeud());
810 francois 432 app.affiche(message);
811 francois 691 sprintf(message," \033[1;32m%d\033[1;33m elements 1D",maif->get_nb_fem_element1());
812 francois 432 app.affiche(message);
813 francois 691 sprintf(message," \033[1;32m%d\033[1;33m elements 2D",maif->get_nb_fem_element2());
814 francois 432 app.affiche(message);
815 francois 691 sprintf(message," \033[1;32m%d\033[1;33m elements 3D",maif->get_nb_fem_element3());
816 francois 432 app.affiche(message);
817 francois 325 double rx,ry,rz;
818     maif->calcul_somme_reaction(rx,ry,rz);
819 francois 691 sprintf(message," Reactions : \n Rx=\033[1;31m%lf\033[1;33m\n Ry=\033[1;31m%lf\033[1;33m\n Rz=\033[1;31m%lf\033[1;33m",rx,ry,rz);
820 francois 432 app.affiche(message);
821 francois 325
822 francois 283 }
823     int nbsol=gest.get_nb_mg_solution();
824 francois 691 sprintf(message," \033[1;32m%d\033[1;33m solution maillage geometrique :",nbsol);
825     app.affiche(message);
826     message[0]=0;
827     for (int i=0;i<nbsol;i++)
828 francois 283 {
829     MG_SOLUTION* sol=gest.get_mg_solution(i);
830 francois 628 char legende[500];
831 francois 691 legende[0]=0;
832     message[0]=0;
833 francois 628 for (int j=0;j<sol->get_nb_champ();j++)
834     sprintf(legende,"%s%s_%s ",legende,(char*)sol->get_nom().c_str(),(char*)sol->get_legende(j).c_str());
835 francois 691 sprintf(message," \033[1;31m%lu(%s)\033[1;33m ",sol->get_id(),legende);
836 francois 628 app.affiche(message);
837 francois 283 }
838     int nbsolf=gest.get_nb_fem_solution();
839 francois 691 sprintf(message," \033[1;32m%d\033[1;33m solution maillage FEM :",nbsolf);
840 francois 628 app.affiche(message);
841 francois 660 message[0]=0;
842     for (int i=0;i<nbsolf;i++)
843 francois 283 {
844 francois 628 FEM_SOLUTION* sol=gest.get_fem_solution(i);
845     char legende[500];
846 francois 670 legende[0]=0;
847 francois 660 message[0]=0;
848 francois 628 for (int j=0;j<sol->get_nb_champ();j++)
849     sprintf(legende,"%s%s_%s ",legende,(char*)sol->get_nom().c_str(),(char*)sol->get_legende(j).c_str());
850 francois 691 sprintf(message," \033[1;31m%lu(%s)\033[1;33m ",sol->get_id(),legende);
851 francois 628 app.affiche(message);
852     }
853 francois 283 }
854     }
855 francois 432 if (app.get_action()==38)
856 francois 283 {
857 francois 432 int nummai;
858     int numsol1,numsol2,numsol3;
859     int numchamp1,numchamp2,numchamp3;
860 francois 516 double coef;
861 francois 432 app.recupere_parametre_int_avec_defaut(19,nummai,0);
862     app.recupere_parametre_int(40,numsol1,(char*)"Numéro solution 1 manquant");
863     app.recupere_parametre_int(41,numsol2,(char*)"Numéro solution 2 manquant");
864     app.recupere_parametre_int(42,numsol3,(char*)"Numéro solution 3 manquant");
865     app.recupere_parametre_int(43,numchamp1,(char*)"Numéro champs 1 manquant");
866     app.recupere_parametre_int(44,numchamp2,(char*)"Numéro champs 2 manquant");
867     app.recupere_parametre_int(45,numchamp3,(char*)"Numéro champs 3 manquant");
868 francois 516 app.recupere_parametre_double_avec_defaut(61,coef,0.);
869 francois 432 if (app.get_erreur()==true) return 0;
870     char mess[500];
871     sprintf(mess," Calcul de deforme");
872     app.affiche(mess);
873 francois 283 MG_FILE gest(nomfichier);
874 francois 432 FEM_MAILLAGE* mai;
875     if (nummai==0) mai=gest.get_fem_maillage(nummai); else mai=gest.get_fem_maillageid(nummai);
876 francois 283 FEM_SOLUTION* sol1=gest.get_fem_solutionid(numsol1);
877     FEM_SOLUTION* sol2=gest.get_fem_solutionid(numsol2);
878     FEM_SOLUTION* sol3=gest.get_fem_solutionid(numsol3);
879     mai->calcul_deforme(sol1,numchamp1,sol2,numchamp2,sol3,numchamp3);
880 francois 516 if (coef>1e-16)
881     {
882     sprintf(mess," Création du maillage deforme");
883     app.affiche(mess);
884     MG_MAILLAGE* mgmai=new MG_MAILLAGE(mai,coef);
885     }
886     sprintf(mess," Enregistrement");
887     app.affiche(mess);
888     gest.enregistrer(nomfichier);
889 francois 283 }
890 francois 432 if (app.get_action()==39)
891 francois 283 {
892 francois 432 int numgeo;
893     app.recupere_parametre_int_avec_defaut (31,numgeo,0);
894     if (app.get_erreur()==true) return 0;
895     char mess[500];
896     sprintf(mess," Fusion de géométrie");
897     app.affiche(mess);
898 francois 283 MG_FILE gest(nomfichier);
899 francois 432 MG_GEOMETRIE* mggeo;
900     if (numgeo==0) mggeo=gest.get_mg_geometrie(numgeo); else mggeo=gest.get_mg_geometrieid(numgeo);
901 francois 283 VCT_MULTI_MODELE fusion(mggeo);
902     fusion.recherche_identite();
903     gest.enregistrer(nomfichier);
904 francois 432 }
905     if ((app.get_action()==46) || (app.get_action()==47))
906 francois 283 {
907 francois 432 int numgeo;
908     char ccf[500];
909     app.recupere_parametre_int_avec_defaut (31,numgeo,0);
910     app.recupere_parametre_string(49,ccf,(char*)"Valeur de la condition aux limites manquant");
911     if (app.get_erreur()==true) return 0;
912     char mess[500];
913     sprintf(mess," Selection de condition aux limites");
914 francois 296 unsigned long identity;
915     char typeccf[3];
916 gervaislavoie 318 typeccf[2]=0;
917 gervaislavoie 302 double valccf=0.5; // Valeur par défaut
918 francois 296 sscanf(ccf,"%lu:%c%c:%le\n",&identity,&typeccf[0],&typeccf[1],&valccf);
919     MC_GESTIONNAIRE mcgest;
920     int res=mcgest.existe(typeccf);
921     if (res==0)
922     {
923     sprintf(mess," ERREUR!!!! Code conditions aux limites inconnu");
924 francois 432 app.affiche(mess);
925 francois 296 return 0;
926     }
927     sprintf(mess," Ajout d'une condition aux limites : %s",mcgest.get_description(typeccf).c_str());
928 francois 432 app.affiche(mess);
929 francois 292 MG_FILE gest(nomfichier);
930 francois 432 MG_GEOMETRIE* geo;
931     if (numgeo==0) geo=gest.get_mg_geometrie(numgeo); else geo=gest.get_mg_geometrieid(numgeo);
932 francois 292 TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> liste;
933 francois 296 MG_VOLUME* ele;
934     ele=geo->get_mg_volumeid(identity);
935 francois 292 if (ele!=NULL) liste.ajouter(ele);
936 francois 296 else
937     {
938     MG_COQUE* ele;
939     ele=geo->get_mg_coqueid(identity);
940     if (ele!=NULL) liste.ajouter(ele);
941     else
942 francois 292 {
943 francois 296 MG_POUTRE* ele;
944     ele=geo->get_mg_poutreid(identity);
945 francois 292 if (ele!=NULL) liste.ajouter(ele);
946     else
947 francois 296 {
948     MG_FACE* ele;
949     ele=geo->get_mg_faceid(identity);
950     if (ele!=NULL) liste.ajouter(ele);
951     else
952     {
953     MG_ARETE* ele;
954     ele=geo->get_mg_areteid(identity);
955     if (ele!=NULL) liste.ajouter(ele);
956     else
957     {
958     MG_SOMMET* ele;
959     ele=geo->get_mg_sommetid(identity);
960     if (ele!=NULL) liste.ajouter(ele);
961     }
962     }
963     }
964 francois 292 }
965 francois 296 }
966 francois 432 if (app.get_action()==47)
967 francois 292 {
968     int nb=liste.get_nb();
969     for (int i=0;i<nb;i++) liste.get(i)->get_topologie_sousjacente(&liste);
970     }
971     int nb=liste.get_nb();
972     for (int i=0;i<nb;i++) liste.get(i)->ajouter_ccf(typeccf,valccf);;
973     gest.enregistrer(nomfichier);
974 francois 432 }
975 francois 763 if ((app.get_action()==94) || (app.get_action()==95))
976     {
977     int numgeo;
978     char ccf[500];
979     app.recupere_parametre_int_avec_defaut (31,numgeo,0);
980     app.recupere_parametre_string(49,ccf,(char*)"Valeur de la condition aux limites manquant");
981     if (app.get_erreur()==true) return 0;
982     char mess[500];
983     sprintf(mess," Selection de condition aux limites");
984     unsigned long identity;
985     char typeccf[3];
986     typeccf[2]=0;
987     unsigned long valccf=0; // Valeur par défaut
988     sscanf(ccf,"%lu:%c%c:%lu\n",&identity,&typeccf[0],&typeccf[1],&valccf);
989     MC_GESTIONNAIRE mcgest;
990     int res=mcgest.existe(typeccf);
991     if (res==0)
992     {
993     sprintf(mess," ERREUR!!!! Code conditions aux limites inconnu");
994     app.affiche(mess);
995     return 0;
996     }
997     sprintf(mess," Ajout d'une condition aux limites : %s",mcgest.get_description(typeccf).c_str());
998     app.affiche(mess);
999     MG_FILE gest(nomfichier);
1000     MG_GEOMETRIE* geo;
1001     if (numgeo==0) geo=gest.get_mg_geometrie(numgeo); else geo=gest.get_mg_geometrieid(numgeo);
1002     TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> liste;
1003     MG_VOLUME* ele;
1004     ele=geo->get_mg_volumeid(identity);
1005     if (ele!=NULL) liste.ajouter(ele);
1006     else
1007     {
1008     MG_COQUE* ele;
1009     ele=geo->get_mg_coqueid(identity);
1010     if (ele!=NULL) liste.ajouter(ele);
1011     else
1012     {
1013     MG_POUTRE* ele;
1014     ele=geo->get_mg_poutreid(identity);
1015     if (ele!=NULL) liste.ajouter(ele);
1016     else
1017     {
1018     MG_FACE* ele;
1019     ele=geo->get_mg_faceid(identity);
1020     if (ele!=NULL) liste.ajouter(ele);
1021     else
1022     {
1023     MG_ARETE* ele;
1024     ele=geo->get_mg_areteid(identity);
1025     if (ele!=NULL) liste.ajouter(ele);
1026     else
1027     {
1028     MG_SOMMET* ele;
1029     ele=geo->get_mg_sommetid(identity);
1030     if (ele!=NULL) liste.ajouter(ele);
1031     }
1032     }
1033     }
1034     }
1035     }
1036     if (app.get_action()==95)
1037     {
1038     int nb=liste.get_nb();
1039     for (int i=0;i<nb;i++) liste.get(i)->get_topologie_sousjacente(&liste);
1040     }
1041     int nb=liste.get_nb();
1042     for (int i=0;i<nb;i++) liste.get(i)->ajouter_ccf(typeccf,valccf);;
1043     gest.enregistrer(nomfichier);
1044     }
1045     if ((app.get_action()==96) || (app.get_action()==97))
1046     {
1047     int numgeo;
1048     char ccf[500];
1049     app.recupere_parametre_int_avec_defaut (31,numgeo,0);
1050     app.recupere_parametre_string(49,ccf,(char*)"Valeur de la condition aux limites manquant");
1051     if (app.get_erreur()==true) return 0;
1052     char mess[500];
1053     sprintf(mess," Selection de condition aux limites");
1054     unsigned long identity;
1055     char typeccf[3];
1056     typeccf[2]=0;
1057     char valccf[500];
1058     char formule[500];
1059     sscanf(ccf,"%lu:%c%c:%s\n",&identity,&typeccf[0],&typeccf[1],formule);
1060     OT_CHAINE ot;
1061     std::vector<std::string> variable=ot.split(formule,':');
1062     strcpy(valccf,variable[0].c_str());
1063     std::vector<std::string> listvariable=ot.split(variable[1].c_str(),',');
1064     MC_GESTIONNAIRE mcgest;
1065     int res=mcgest.existe(typeccf);
1066     if (res==0)
1067     {
1068     sprintf(mess," ERREUR!!!! Code conditions aux limites inconnu");
1069     app.affiche(mess);
1070     return 0;
1071     }
1072     sprintf(mess," Ajout d'une condition aux limites : %s",mcgest.get_description(typeccf).c_str());
1073     app.affiche(mess);
1074     MG_FILE gest(nomfichier);
1075     MG_GEOMETRIE* geo;
1076     if (numgeo==0) geo=gest.get_mg_geometrie(numgeo); else geo=gest.get_mg_geometrieid(numgeo);
1077     TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> liste;
1078     MG_VOLUME* ele;
1079     ele=geo->get_mg_volumeid(identity);
1080     if (ele!=NULL) liste.ajouter(ele);
1081     else
1082     {
1083     MG_COQUE* ele;
1084     ele=geo->get_mg_coqueid(identity);
1085     if (ele!=NULL) liste.ajouter(ele);
1086     else
1087     {
1088     MG_POUTRE* ele;
1089     ele=geo->get_mg_poutreid(identity);
1090     if (ele!=NULL) liste.ajouter(ele);
1091     else
1092     {
1093     MG_FACE* ele;
1094     ele=geo->get_mg_faceid(identity);
1095     if (ele!=NULL) liste.ajouter(ele);
1096     else
1097     {
1098     MG_ARETE* ele;
1099     ele=geo->get_mg_areteid(identity);
1100     if (ele!=NULL) liste.ajouter(ele);
1101     else
1102     {
1103     MG_SOMMET* ele;
1104     ele=geo->get_mg_sommetid(identity);
1105     if (ele!=NULL) liste.ajouter(ele);
1106     }
1107     }
1108     }
1109     }
1110     }
1111     if (app.get_action()==97)
1112     {
1113     int nb=liste.get_nb();
1114     for (int i=0;i<nb;i++) liste.get(i)->get_topologie_sousjacente(&liste);
1115     }
1116     int nb=liste.get_nb();
1117     for (int i=0;i<nb;i++) liste.get(i)->ajouter_ccf(typeccf,valccf,listvariable);;
1118     gest.enregistrer(nomfichier);
1119     }
1120 francois 432 if (app.get_action()==48)
1121 francois 296 {
1122 francois 432 char mess[500];
1123 francois 296 sprintf(mess," Liste des conditions aux limites disponibles");
1124 francois 432 app.affiche(mess);
1125 francois 296 MC_GESTIONNAIRE mcgest;
1126     int ok=0;
1127     do
1128     {
1129     std::string code;
1130     std::string description;
1131     int res=mcgest.get_description(code,description);
1132     if (res)
1133     {
1134     sprintf(mess," %s : %s",code.c_str(),description.c_str());
1135 francois 432 app.affiche(mess);
1136 francois 296 }
1137     else ok=1;
1138     }
1139     while (ok==0);
1140 francois 432 }
1141     if (app.get_action()==50)
1142 francois 326 {
1143 francois 432 int numgeo,nummai,numcoque;
1144     char fichierout[500];
1145     app.recupere_parametre_int_avec_defaut(31,numgeo,0);
1146     app.recupere_parametre_int_avec_defaut(19,nummai,0);
1147     app.recupere_parametre_int_avec_defaut(51,numcoque,0);
1148     app.recupere_parametre_string_avec_defaut(5,fichierout,nomfichier);
1149     if (app.get_erreur()==true) return 0;
1150     char mess[500];
1151 gervaislavoie 328 sprintf(mess," Orientation d'une coque");
1152 francois 432 app.affiche(mess);
1153 gervaislavoie 328 MG_FILE gest(nomfichier);
1154 francois 432 MG_GEOMETRIE* geo;
1155     if (numgeo==0) geo=gest.get_mg_geometrie(numgeo); else geo=gest.get_mg_geometrieid(numgeo);
1156     MG_MAILLAGE* mai;
1157     if (nummai==0) mai=gest.get_mg_maillage(nummai); else mai=gest.get_mg_maillageid(nummai);
1158     MG_COQUE* coque;
1159     if (numcoque==0) coque=mai->get_mg_geometrie()->get_mg_coque(numcoque); else coque=mai->get_mg_geometrie()->get_mg_coqueid(numcoque);
1160 gervaislavoie 328 coque->orienter(mai);
1161     gest.enregistrer(fichierout);
1162 francois 432 }
1163     if (app.get_action()==52)
1164 francois 428 {
1165 francois 432 double epsf,unite;
1166     app.recupere_parametre_double_avec_defaut(10,unite,1.);
1167     app.recupere_parametre_double_avec_defaut(53,epsf,0.0001);
1168     if (app.get_erreur()==true) return 0;
1169     char mess[500];
1170     sprintf(mess," Conversion STL vers MAGiC");
1171     app.affiche(mess);
1172     MG_GESTIONNAIRE gest;
1173 francois 428 STL_IMPORT stlimport;
1174 francois 429 stlimport.change_eps(epsf);
1175 francois 428 stlimport.importer(gest,nomfichier) ;
1176     strncpy(chaine,nomfichier,p-nomfichier);
1177     std::string namefic=chaine;
1178     namefic=namefic + ".magic";
1179     int nb=gest.get_nb_mg_geometrie();
1180     for (int i=0;i<nb;i++)
1181     gest.get_mg_geometrie(i)->change_valeur_unite(unite);
1182     gest.enregistrer(namefic.c_str());
1183     }
1184 francois 432 if (app.get_action()==54)
1185 mejrim 597 {
1186 francois 432 int nummai;
1187     char coderesu[10];
1188 francois 706 bool elastique;
1189 couturad 719 bool elastique_gd;
1190     bool plastique;
1191 mejrim 597 bool thermique;
1192 francois 603 bool conplane;
1193     bool defplane;
1194 francois 706 bool creeparam;
1195     char nomparam[500];
1196 francois 432 app.recupere_parametre_int_avec_defaut(19,nummai,0);
1197     app.recupere_parametre_string_avec_defaut(7,coderesu,(char*)"11111111");
1198 francois 706 app.recupere_parametre_bool_avec_defaut(63,elastique,false);
1199 mejrim 597 app.recupere_parametre_bool_avec_defaut(64,thermique,false);
1200 francois 603 app.recupere_parametre_bool_avec_defaut(65,conplane,false);
1201     app.recupere_parametre_bool_avec_defaut(66,defplane,false);
1202 francois 706 app.recupere_parametre_bool_avec_defaut(85,creeparam,false);
1203 couturad 719 app.recupere_parametre_bool_avec_defaut(88,elastique_gd,false);
1204     app.recupere_parametre_bool_avec_defaut(89,plastique,false);
1205 francois 706 if (!creeparam) app.recupere_parametre_string(1,nomfichier,(char*)"Fichier entrant manquant");
1206     app.recupere_parametre_string(84,nomparam,(char*)"Fichier parametre manquant");
1207 francois 432 if (app.get_erreur()==true) return 0;
1208 francois 706 if (creeparam)
1209     {
1210     char mess[500];
1211     sprintf(mess," Calcul ASTER\n\nCréation d'un fichier parametre\n");
1212     app.affiche(mess);
1213     MG_EXPORT exp;
1214     exp.ecrire_params_aster(nomparam);
1215     }
1216     else
1217     {
1218 francois 432 char mess[500];
1219     sprintf(mess," Calcul ASTER");
1220     app.affiche(mess);
1221     char nometude[1000];
1222     char *p=strchr(nomfichier,'.');
1223     strncpy(nometude,nomfichier,p-nomfichier);
1224     nometude[p-nomfichier]=0;
1225     MG_FILE gest(nomfichier);
1226     FEM_MAILLAGE* mai;
1227     if (nummai==0) mai=gest.get_fem_maillage(nummai); else mai=gest.get_fem_maillageid(nummai);
1228     MGASTER mgaster;
1229     mgaster.active_affichage(app.affiche);
1230 francois 706 if (elastique) mgaster.calcule(nomparam,mai,nometude,MAGIC::CALCUL_ASTER::ELASTIQUE,coderesu);
1231     if (conplane) mgaster.calcule(nomparam,mai,nometude,MAGIC::CALCUL_ASTER::CONTRAINTE_PLANE,coderesu);
1232     if (defplane) mgaster.calcule(nomparam,mai,nometude,MAGIC::CALCUL_ASTER::DEFORMATION_PLANE,coderesu);
1233     if (thermique) mgaster.calcule(nomparam,mai,nometude,MAGIC::CALCUL_ASTER::THERMIQUE,(char*)"");
1234 couturad 719 if (elastique_gd) mgaster.calcule(nomparam,mai,nometude,MAGIC::CALCUL_ASTER::ELASTIQUE_GROT_GDEF,coderesu);
1235     if (plastique) mgaster.calcule(nomparam,mai,nometude,MAGIC::CALCUL_ASTER::PLASTIQUE,coderesu);
1236    
1237 francois 706 }
1238 francois 432 }
1239 francois 469 if (app.get_action()==56)
1240     {
1241     if (app.get_erreur()==true) return 0;
1242     char mess[500];
1243 francois 505 sprintf(mess," Conversion carte de taille nouvelle version vers GMSH");
1244 francois 469 app.affiche(mess);
1245     FCT_TAILLE_FEM_SOLUTION carte(nomfichier);
1246     strncpy(chaine,nomfichier,p-nomfichier);
1247     std::string namefic=chaine;
1248     MG_EXPORT exp;
1249 francois 505 exp.gmsh(&carte,namefic);
1250 francois 469 sprintf(mess," Carte de taille FEM : Creation de %s.msh",namefic.c_str());
1251     app.affiche(mess);
1252     }
1253 francois 514 if ((app.get_action()==58) || (app.get_action()==60))
1254     {
1255     int nummai;
1256     app.recupere_parametre_int_avec_defaut(19,nummai,0);
1257     char nomcarte[500];
1258     if (app.get_action()==58)
1259     app.recupere_parametre_string(59,nomcarte,(char*)"Fichier carte manquant");
1260     if (app.get_action()==60)
1261     app.recupere_parametre_string(59,nomcarte,(char*)"Fichier carte manquant");
1262     if (app.get_erreur()==true) return 0;
1263     char mess[500];
1264     sprintf(mess," Comparaison de la taille reelle d'un maillage avec la carte de taille");
1265     app.affiche(mess);
1266     sprintf(mess," Lecture fichier MAGiC");
1267     app.affiche(mess);
1268     MG_FILE gest(nomfichier);
1269     MG_MAILLAGE* mai;
1270     if (nummai==0) mai=gest.get_mg_maillage(nummai); else mai=gest.get_mg_maillageid(nummai);
1271     sprintf(mess," Lecture fichier carte de taille");
1272     app.affiche(mess);
1273     FCT_TAILLE *carte;
1274     if (app.get_action()==58)
1275     carte=new FCT_GENERATEUR_3D<4>(nomcarte);
1276 francois 518 if (app.get_action()==60)
1277 francois 514 carte=new FCT_TAILLE_FEM_SOLUTION(nomcarte);
1278     char nometude[1000];
1279     char *p=strchr(nomfichier,'.');
1280     strncpy(nometude,nomfichier,p-nomfichier);
1281     nometude[p-nomfichier]=0;
1282     char nomsolution[500];
1283     sprintf(nomsolution,"%s_comp%lu.sol",nometude,mai->get_id());
1284     sprintf(mess," Comparaison");
1285     app.affiche(mess);
1286     MAILLEUR_ANALYSE m3d(mai);
1287 francois 577 sprintf(mess," Respect global de la taille demandee");
1288     app.affiche(mess);
1289     double tabtaille[3];
1290     m3d.compare_maillage_carte_isotrope(carte,nomsolution,tabtaille);
1291     sprintf(mess," Nombre de maille théorique : %lf - Nombre de maille reelle : %lf",tabtaille[0],tabtaille[1]);
1292     app.affiche(mess);
1293     sprintf(mess," Erreur : %lf%%",tabtaille[2]);
1294     app.affiche(mess);
1295 francois 560 MG_SOLUTION *sol=gest.get_mg_solution(gest.get_nb_mg_solution()-1);
1296     sol->active_solution(2);
1297     LISTE_MG_NOEUD::iterator it;
1298     int tab[201];
1299     for (int i=0;i<201;i++) tab[i]=0;
1300     for (MG_NOEUD* no=mai->get_premier_noeud(it);no!=NULL;no=mai->get_suivant_noeud(it))
1301     {
1302     double val=no->get_solution();
1303     int valint=(int)val+100;
1304     if (valint<0) valint=0;
1305     if (valint>200) valint=200;
1306     tab[valint]++;
1307     }
1308 francois 577 sprintf(mess," Repartition du respect de la taille demandee");
1309 francois 560 app.affiche(mess);
1310     char nomanalyse[500];
1311     sprintf(nomanalyse,"%s_comp%lu.csv",nometude,mai->get_id());
1312     FILE *in=fopen(nomanalyse,"wt");
1313     for (int i=0;i<201;i++)
1314     if (i<101) fprintf(in,"%d;%d;\n",i-100,tab[i]);
1315     else fprintf(in,"%d;%d;%d;\n",i-100,tab[i],tab[i]+tab[200-i]);
1316     fclose(in);
1317 francois 514 sprintf(mess," Enregistrement");
1318     app.affiche(mess);
1319     sprintf(nomsolution,"%s_comp%lu.magic",nometude,mai->get_id());
1320     gest.enregistrer(nomsolution);
1321     delete carte;
1322     }
1323 francois 475 if (app.get_action()==57)
1324     {
1325     int nummai;
1326     app.recupere_parametre_int_avec_defaut(19,nummai,0);
1327     if (app.get_erreur()==true) return 0;
1328     char mess[500];
1329     sprintf(mess," Conversion mg maillage en stl");
1330     app.affiche(mess);
1331     MG_FILE gest(nomfichier);
1332     strncpy(chaine,nomfichier,p-nomfichier);
1333     MG_MAILLAGE* mai;
1334     if (nummai==0) mai=gest.get_mg_maillage(0); else mai=gest.get_mg_maillageid(nummai);
1335     sprintf(chaine,"%s%lu",chaine,mai->get_id());
1336     std::string namefic=chaine;
1337     MG_EXPORT exp;
1338     exp.stl(mai,namefic);
1339     sprintf(mess," creation de %s.stl",namefic.c_str());
1340     app.affiche(mess);
1341    
1342     }
1343 francois 517 if (app.get_action()==62)
1344     {
1345     int nummai;
1346     app.recupere_parametre_int_avec_defaut(19,nummai,0);
1347     char outfile[500];
1348     app.recupere_parametre_string(5,outfile,(char*)"Fichier de sortie manquant");
1349     if (app.get_erreur()==true) return 0;
1350     char mess[500];
1351     sprintf(mess," Détachement d'un mg maillage de sa geometrie");
1352     app.affiche(mess);
1353     MG_FILE gest(nomfichier);
1354     MG_MAILLAGE* mai;
1355     if (nummai==0) mai=gest.get_mg_maillage(0); else mai=gest.get_mg_maillageid(nummai);
1356     MG_GESTIONNAIRE gest2;
1357     MG_MAILLAGE *mai2=mai->detacher(&gest2);
1358     sprintf(mess," Enregistrement");
1359     app.affiche(mess);
1360     gest2.enregistrer(outfile);
1361 francois 604 }
1362     if (app.get_action()==67)
1363     {
1364     int numsol;
1365     int numchamp;
1366     int numare;
1367     int numgeo;
1368     char outfile[500];
1369     app.recupere_parametre_int_avec_defaut(31,numgeo,0);
1370     app.recupere_parametre_int_avec_defaut(68,numsol,0);
1371     app.recupere_parametre_int_avec_defaut(69,numchamp,0);
1372     app.recupere_parametre_int_avec_defaut(71,numare,0);
1373     app.recupere_parametre_string(70,outfile,(char*)"Fichier de sortie manquant");
1374     if (app.get_erreur()==true) return 0;
1375     MG_FILE gest(nomfichier);
1376     FEM_SOLUTION* sol;
1377     if (numsol==0) sol=gest.get_fem_solution(0); else sol=gest.get_fem_solutionid(numsol);
1378     MG_GEOMETRIE* geo;
1379     if (numgeo==0) geo=gest.get_mg_geometrie(0); else geo=gest.get_mg_geometrie(numgeo);
1380     MG_ARETE *are;
1381     if (numare==0) are=geo->get_mg_arete(0); else are=geo->get_mg_areteid(numare);
1382     char mess[500];
1383 francois 628 sprintf(mess," Sonde de %s_%s sur l'arète %lu",(char*)sol->get_nom().c_str(),(char*)sol->get_legende(numchamp).c_str(),are->get_id());
1384 francois 604 app.affiche(mess);
1385     are->recupere_resultat(sol,numchamp,outfile);
1386    
1387     }
1388 francois 628 if (app.get_action()==72)
1389     {
1390     int numsol;
1391     int numchamp;
1392     int nummai;
1393     char outfile[500];
1394     char infile[500];
1395     app.recupere_parametre_int_avec_defaut(68,numsol,0);
1396     app.recupere_parametre_int_avec_defaut(69,numchamp,0);
1397     app.recupere_parametre_int_avec_defaut(19,nummai,0);
1398     app.recupere_parametre_string(73,infile,(char*)"Fichier de solution manquant");
1399     app.recupere_parametre_string_avec_defaut(5,outfile,infile);
1400     if (app.get_erreur()==true) return 0;
1401 francois 633 app.affiche((char*)"Lecture du fichier MAGIC");
1402     MG_FILE gest(nomfichier);
1403     app.affiche((char*)"Lecture de la solution a projeter");
1404     MG_FILE gestsol(infile);
1405 francois 628 FEM_SOLUTION* sol;
1406     if (numsol==0) sol=gestsol.get_fem_solution(0); else sol=gestsol.get_fem_solutionid(numsol);
1407     FEM_MAILLAGE* fem;
1408     if (nummai==0) fem=gest.get_fem_maillage(0); else fem=gest.get_fem_maillageid(nummai);
1409     char mess[500];
1410     sprintf(mess," Projection de la solution %s_%s du maillage %lu sur le maillage %lu",(char*)sol->get_nom().c_str(),(char*)sol->get_legende(numchamp).c_str(),sol->get_maillage()->get_id(),fem->get_id());
1411     app.affiche(mess);
1412     FEM_MAILLAGE_OUTILS otfem;
1413 francois 635 int res=otfem.projete_solution_maillage(sol,numchamp,fem);
1414     if (res==MAGIC::PROJECTION::SUCCES) gest.enregistrer(outfile);
1415     if (res==MAGIC::PROJECTION::DIMENSION_MAILLAGE_INCOMPATIBLE) app.affiche((char*)" Erreur : Dimension des maillages incompatibles");
1416     if (res==MAGIC::PROJECTION::TYPE_SOLUTION_INCORRECT) app.affiche((char*)" Erreur : Solution a projeter n'est pas exprimer aux noeuds");
1417     if (res==MAGIC::PROJECTION::NON_IMPLEMENTER) app.affiche((char*)" Erreur : Cas de projection non implementer");
1418 francois 628 }
1419     if (app.get_action()==74)
1420     {
1421     int numsol1;
1422     int numchamp1;
1423     int numsol2;
1424     int numchamp2;
1425     char outfile[500];
1426     app.recupere_parametre_int_avec_defaut(40,numsol1,0);
1427     app.recupere_parametre_int_avec_defaut(41,numsol2,0);
1428     app.recupere_parametre_int_avec_defaut(43,numchamp1,0);
1429     app.recupere_parametre_int_avec_defaut(44,numchamp2,0);
1430     app.recupere_parametre_string_avec_defaut(5,outfile,nomfichier);
1431     if (app.get_erreur()==true) return 0;
1432     MG_FILE gest(nomfichier);
1433     FEM_SOLUTION* sol1;
1434     if (numsol1==0) sol1=gest.get_fem_solution(0); else sol1=gest.get_fem_solutionid(numsol1);
1435     FEM_SOLUTION* sol2;
1436     if (numsol2==0) sol2=gest.get_fem_solution(0); else sol2=gest.get_fem_solutionid(numsol2);
1437     char mess[500];
1438     sprintf(mess," Comparaison de %s_%s et de %s_%s",(char*)sol1->get_nom().c_str(),(char*)sol1->get_legende(numchamp1).c_str(),(char*)sol2->get_nom().c_str(),(char*)sol2->get_legende(numchamp2).c_str());
1439     app.affiche(mess);
1440     FEM_MAILLAGE_OUTILS otfem;
1441 francois 674 otfem.compare_champs_solution(sol1,numchamp1,sol2,numchamp2);
1442 francois 628 gest.enregistrer(outfile);
1443     }
1444 francois 697 if (app.get_action()==76)
1445     {
1446 francois 757 bool bnoeud,belement1,belement2,belement3,bgelement1,bgelement2,bgelement3;
1447 francois 698 int nummai,numtopo;
1448 francois 697 char out[500];
1449     app.recupere_parametre_string(5,out,(char*)"Fichier sortant manquant");
1450     app.recupere_parametre_int_avec_defaut(19,nummai,0);
1451     app.recupere_parametre_bool_avec_defaut(77,bnoeud,false);
1452     app.recupere_parametre_bool_avec_defaut(78,belement1,false);
1453     app.recupere_parametre_bool_avec_defaut(79,belement2,false);
1454     app.recupere_parametre_bool_avec_defaut(80,belement3,false);
1455 francois 757 app.recupere_parametre_bool_avec_defaut(91,bgelement3,false);
1456     app.recupere_parametre_bool_avec_defaut(92,bgelement3,false);
1457     app.recupere_parametre_bool_avec_defaut(93,bgelement3,false);
1458 francois 698 app.recupere_parametre_int_avec_defaut(81,numtopo,0);
1459 francois 697 if (app.get_erreur()==true) return 0;
1460 francois 698 char mess[500];
1461     sprintf(mess," Extraction de tables de valeurs");
1462     app.affiche(mess);
1463 francois 697 MG_FILE gest(nomfichier);
1464     FEM_MAILLAGE *fem;
1465 francois 698 MG_ELEMENT_TOPOLOGIQUE *topo;
1466 francois 697 if (nummai==0) fem=gest.get_fem_maillage(0); else fem=gest.get_fem_maillageid(nummai);
1467 francois 698 if (numtopo==0) topo=NULL;
1468     else
1469     {
1470     MG_GEOMETRIE* geo=fem->get_mg_geometrie();
1471     topo=geo->get_mg_faceid(numtopo);
1472     if (topo==NULL) topo=geo->get_mg_volumeid(numtopo);
1473     if (topo==NULL) topo=geo->get_mg_areteid(numtopo);
1474     if (topo==NULL) topo=geo->get_mg_sommetid(numtopo);
1475     }
1476 francois 697 MG_TABLE tab;
1477     if (bnoeud)
1478     {
1479 francois 698 app.affiche((char*)" Création de la table aux noeuds");
1480 francois 697 char nomout[500];
1481     sprintf(nomout,"%s_noeud.csv",out);
1482 francois 698 tab.info_noeud(fem,nomout,topo);
1483 francois 697 }
1484     if (belement1)
1485     {
1486 francois 698 app.affiche((char*)" Création de la table aux elements 1D");
1487 francois 697 char nomout[500];
1488     sprintf(nomout,"%s_element1.csv",out);
1489 francois 698 tab.info_element1(fem,nomout,topo);
1490 francois 697 }
1491     if (belement2)
1492     {
1493 francois 698 app.affiche((char*)" Création de la table aux elements 2D");
1494 francois 697 char nomout[500];
1495     sprintf(nomout,"%s_element2.csv",out);
1496 francois 698 tab.info_element2(fem,nomout,topo);
1497 francois 697 }
1498     if (belement3)
1499     {
1500 francois 698 app.affiche((char*)" Création de la table aux elements 3D");
1501 francois 697 char nomout[500];
1502     sprintf(nomout,"%s_element3.csv",out);
1503 francois 698 tab.info_element3(fem,nomout,topo);
1504 francois 697 }
1505 francois 757 if (bgelement1)
1506     {
1507     app.affiche((char*)" Création de la table aux point de gauss des elements 1D");
1508     char nomout[500];
1509     sprintf(nomout,"%s_elementgauss1.csv",out);
1510     tab.info_element_gauss1(fem,nomout,topo);
1511     }
1512     if (bgelement2)
1513     {
1514     app.affiche((char*)" Création de la table aux point de gauss des elements 2D");
1515     char nomout[500];
1516     sprintf(nomout,"%s_elementgauss2.csv",out);
1517     tab.info_element_gauss2(fem,nomout,topo);
1518     }
1519     if (bgelement3)
1520     {
1521     app.affiche((char*)" Création de la table aux point de gauss des elements 3D");
1522     char nomout[500];
1523     sprintf(nomout,"%s_elementgauss3.csv",out);
1524     tab.info_element_gauss3(fem,nomout,topo);
1525     }
1526 francois 697 }
1527 francois 702 if (app.get_action()==82)
1528     {
1529     int numgeo;
1530     char out[500];
1531     char in[500];
1532     char fgmsh[500];
1533     app.recupere_parametre_string_avec_defaut(1,in,(char*)"");
1534     if (strcmp(in,"")==0)
1535     app.recupere_parametre_string(5,out,(char*)"Fichier sortant manquant");
1536     else
1537     app.recupere_parametre_string_avec_defaut(5,out,in);
1538     app.recupere_parametre_int_avec_defaut(31,numgeo,0);
1539     app.recupere_parametre_string(83,fgmsh,(char*)"Fichier GMSH manquant");
1540     if (app.get_erreur()==true) return 0;
1541     char mess[2000];
1542     sprintf(mess,"Importation d'un maillage GMSH");
1543     app.affiche(mess);
1544     MG_GESTIONNAIRE *gest;
1545     if (strcmp(in,"")==0) gest=new MG_GESTIONNAIRE; else gest=new MG_FILE(in);
1546     MG_GEOMETRIE *geo;
1547     if ((numgeo!=0) && (gest->get_nb_mg_geometrie()>0)) geo=gest->get_mg_geometrieid(numgeo);
1548     MG_IMPORT imp;
1549     imp.maillage_gmsh(gest,fgmsh,geo);
1550     sprintf(mess,"Enregistrement du fichier");
1551     app.affiche(mess);
1552     gest->enregistrer(out);
1553     delete gest;
1554     }
1555 francois 712 if (app.get_action()==86)
1556     {
1557     int numgeo;
1558     char chemin[1000];
1559     app.recupere_parametre_int_avec_defaut(31,numgeo,0);
1560     app.recupere_parametre_string(87,chemin,(char*)"Fichier de fonction manquant");
1561     if (app.get_erreur()==true) return 0;
1562     char mess[2000];
1563     sprintf(mess,"Importation d'une fonction geometrique");
1564     app.affiche(mess);
1565     sprintf(mess,"\nLecture du fichier MAGiC");
1566     app.affiche(mess);
1567     MG_FILE gest(nomfichier);
1568     MG_GEOMETRIE *geo;
1569     if (numgeo==0) geo=gest.get_mg_geometrie(numgeo); else geo=gest.get_mg_geometrieid(numgeo);
1570     sprintf(mess,"Importation de la courbe");
1571     app.affiche(mess);
1572     MG_GEOM_FONCTION *gf=new MG_GEOM_FONCTION(chemin);
1573     geo->ajouter_mg_geom_fonction(gf);
1574     gest.enregistrer(nomfichier);
1575     }
1576 francois 432 char mess[255];
1577     sprintf(mess,"Fin");
1578     app.affiche(mess);
1579     }
1580    
1581    
1582    
1583    
1584    
1585    
1586    
1587    
1588    
1589    
1590    
1591    
1592    
1593    
1594