ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/REPOS_ERICCA/magic/app/mgoperation/src/main.cpp
Revision: 694
Committed: Thu Jul 16 16:13:12 2015 UTC (9 years, 11 months ago) by francois
File size: 56608 byte(s)
Log Message: 
Pour le calcul statique lineaire en 3D ou en elasticite 2D les valeurs de contrainte et deformation sont directement calculé aux noeuds au lieu d'être calculé aux noeuds par éléments. Pour revenir à l'ancienne facon definir la variable d'environnement ASTER_ELNO=Oui.
Pour les plaques rien de change toujours par noeud par element et les coques aussi rien de change

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 691 #include "mg_primitive.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     MAGIC_PARAMETRE_APPLICATION p22(23,(char*)"-optis",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Conversion de fichier magic en format OPTIS");
87     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     MAGIC_PARAMETRE_APPLICATION p48(49,(char*)"-valeur",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Condition aux limites à appliquer sous la forme id:ccf:valeur");
113     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 mejrim 597 MAGIC_PARAMETRE_APPLICATION p62(63,(char*)"-mecanique",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Calcul aster en mécanique");
127     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 454 p1.ajouter_dependance(1);p1.ajouter_dependance(3);p1.ajouter_dependance(55);
140 francois 432 p3.ajouter_dependance(1);p3.ajouter_dependance(5);
141     p5.ajouter_dependance(1);p5.ajouter_dependance(7);
142     p7.ajouter_dependance(1);
143     p8.ajouter_dependance(1);p8.ajouter_dependance(10);
144 francois 652 p10.ajouter_dependance(1);p10.ajouter_dependance(13);p10.ajouter_dependance(14);p10.ajouter_dependance(15);;p10.ajouter_dependance(16);
145 francois 432 p11.ajouter_dependance(1);p11.ajouter_dependance(10);
146 francois 652 p16.ajouter_dependance(1);p16.ajouter_dependance(13);p16.ajouter_dependance(14);p16.ajouter_dependance(15);;p16.ajouter_dependance(16);
147 francois 656 p17.ajouter_dependance(1);p17.ajouter_dependance(19);p17.ajouter_dependance(20);p17.ajouter_dependance(75);
148 francois 432 p20.ajouter_dependance(1);p20.ajouter_dependance(19);p20.ajouter_dependance(22);
149     p22.ajouter_dependance(1);p22.ajouter_dependance(7);
150     p23.ajouter_dependance(1);p23.ajouter_dependance(19);p23.ajouter_dependance(25);p23.ajouter_dependance(26);p23.ajouter_dependance(27);p23.ajouter_dependance(28);
151     p28.ajouter_dependance(1);p28.ajouter_dependance(31);p28.ajouter_dependance(32);p28.ajouter_dependance(33);p28.ajouter_dependance(34);
152     p29.ajouter_dependance(1);p29.ajouter_dependance(31);p29.ajouter_dependance(32);p29.ajouter_dependance(33);p29.ajouter_dependance(34);
153     p34.ajouter_dependance(1);p34.ajouter_dependance(19);p34.ajouter_dependance(36);p34.ajouter_dependance(37);
154 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);
155 francois 432 p38.ajouter_dependance(1);p38.ajouter_dependance(31);
156     p45.ajouter_dependance(1);p45.ajouter_dependance(31);p45.ajouter_dependance(49);
157     p46.ajouter_dependance(1);p46.ajouter_dependance(31);p46.ajouter_dependance(49);
158     p49.ajouter_dependance(1);p49.ajouter_dependance(19);p49.ajouter_dependance(51);p49.ajouter_dependance(5);
159     p51.ajouter_dependance(1);p51.ajouter_dependance(10);p51.ajouter_dependance(53);
160 francois 603 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);
161 francois 469 p55.ajouter_dependance(1);
162 francois 475 p56.ajouter_dependance(1);p56.ajouter_dependance(19);
163 francois 514 p57.ajouter_dependance(1);p57.ajouter_dependance(19);p57.ajouter_dependance(59);
164     p59.ajouter_dependance(1);p59.ajouter_dependance(19);p59.ajouter_dependance(59);
165 francois 517 p61.ajouter_dependance(1);p61.ajouter_dependance(5);p61.ajouter_dependance(19);
166 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);
167     p71.ajouter_dependance(1);p71.ajouter_dependance(73);p71.ajouter_dependance(68);p71.ajouter_dependance(69);p71.ajouter_dependance(19);p71.ajouter_dependance(5);
168     p73.ajouter_dependance(1);p73.ajouter_dependance(5);p73.ajouter_dependance(40);p73.ajouter_dependance(41);p73.ajouter_dependance(43);p73.ajouter_dependance(44);
169 francois 432 lst.push_back(p1);
170     lst.push_back(p2);
171     lst.push_back(p3);
172     lst.push_back(p4);
173     lst.push_back(p5);
174     lst.push_back(p6);
175     lst.push_back(p7);
176     lst.push_back(p8);
177     lst.push_back(p9);
178     lst.push_back(p10);
179     lst.push_back(p11);
180     lst.push_back(p12);
181     lst.push_back(p13);
182     lst.push_back(p14);
183     lst.push_back(p15);
184     lst.push_back(p16);
185     lst.push_back(p17);
186     lst.push_back(p18);
187     lst.push_back(p19);
188     lst.push_back(p20);
189     lst.push_back(p21);
190     lst.push_back(p22);
191     lst.push_back(p23);
192     lst.push_back(p24);
193     lst.push_back(p25);
194     lst.push_back(p26);
195     lst.push_back(p27);
196     lst.push_back(p28);
197     lst.push_back(p29);
198     lst.push_back(p30);
199     lst.push_back(p31);
200     lst.push_back(p32);
201     lst.push_back(p33);
202     lst.push_back(p34);
203     lst.push_back(p35);
204     lst.push_back(p36);
205     lst.push_back(p37);
206     lst.push_back(p38);
207     lst.push_back(p39);
208     lst.push_back(p40);
209     lst.push_back(p41);
210     lst.push_back(p42);
211     lst.push_back(p43);
212     lst.push_back(p44);
213     lst.push_back(p45);
214     lst.push_back(p46);
215     lst.push_back(p47);
216     lst.push_back(p48);
217     lst.push_back(p49);
218     lst.push_back(p50);
219     lst.push_back(p51);
220     lst.push_back(p52);
221     lst.push_back(p53);
222 francois 454 lst.push_back(p54);
223 francois 469 lst.push_back(p55);
224 francois 475 lst.push_back(p56);
225 francois 514 lst.push_back(p57);
226     lst.push_back(p58);
227     lst.push_back(p59);
228 francois 516 lst.push_back(p60);
229 francois 517 lst.push_back(p61);
230 mejrim 597 lst.push_back(p62);
231     lst.push_back(p63);
232 francois 603 lst.push_back(p64);
233     lst.push_back(p65);
234 francois 604 lst.push_back(p66);
235     lst.push_back(p67);
236     lst.push_back(p68);
237     lst.push_back(p69);
238     lst.push_back(p70);
239 francois 628 lst.push_back(p71);
240     lst.push_back(p72);
241     lst.push_back(p73);
242 francois 432 MAGIC_APPLICATION app((char*)"Operation dans l'environnement MAGiC",argc,argv,lst,true,false);
243     char nomfichier[3000];
244     char* p;
245     if (app.get_action()!=48)
246     {
247     if (app.get_erreur()==true) return 0;
248     app.recupere_parametre_string(1,nomfichier,(char*)"Fichier entrant manquant");
249     p=strrchr(nomfichier,'.');
250     }
251     char chaine[1000];for (int i=0;i<1000;i++) chaine[i]=0;
252     if (app.get_action()==2)
253     {
254     bool desactivedeforme;
255     app.recupere_parametre_bool_avec_defaut(4,desactivedeforme,false);
256 francois 454 bool corres;
257     app.recupere_parametre_bool_avec_defaut(55,corres,false);
258 francois 432 if (app.get_erreur()==true) return 0;
259     char mess[2000];
260     sprintf(mess,"Conversion MAGiC vers GMSH");
261     app.affiche(mess);
262 francois 283 MG_FILE gest(nomfichier);
263     int nb=gest.get_nb_mg_maillage();
264     for (int i=0;i<nb;i++)
265     {
266     MG_MAILLAGE* mai=gest.get_mg_maillage(i);
267     unsigned long id=mai->get_id();
268     strncpy(chaine,nomfichier,p-nomfichier);
269     char chaine2[3000];
270     sprintf(chaine2,"%s%lu",chaine,id);
271     std::string namefic=chaine2;
272     MG_EXPORT exp;
273 francois 339 sprintf(mess," Maillage geometrique : creation de %s.msh",namefic.c_str());
274 francois 432 app.affiche(mess);
275 francois 454 if (corres==false) exp.gmsh(mai,namefic); else exp.gmsh_avec_correspondance(mai,namefic);
276     }
277 francois 283 nb=gest.get_nb_fem_maillage();
278     for (int i=0;i<nb;i++)
279     {
280     FEM_MAILLAGE* mai=gest.get_fem_maillage(i);
281 francois 432 if (desactivedeforme) mai->desactive_deforme();
282 gervaislavoie 304 unsigned long id=mai->get_id();
283 francois 283 strncpy(chaine,nomfichier,p-nomfichier);
284     char chaine2[3000];
285     sprintf(chaine2,"%s%lu",chaine,id);
286     std::string namefic=chaine2;
287     MG_EXPORT exp;
288 francois 331 sprintf(mess," Maillage EF : Creation de %s.msh",namefic.c_str());
289 francois 432 app.affiche(mess);
290 francois 454 if (corres==false) exp.gmsh(mai,namefic); else exp.gmsh_avec_correspondance(mai,namefic);
291 francois 283 }
292     }
293 francois 432 if (app.get_action()==4)
294 francois 331 {
295 francois 432 char fichierout[2000];
296     app.recupere_parametre_string(5,fichierout,(char*)"Fichier sortant manquant");
297     if (app.get_erreur()==true) return 0;
298     char mess[2000];
299     sprintf(mess,"Copie de fichier MAGiC");
300     app.affiche(mess);
301 francois 331 MG_FILE gest(nomfichier);
302     gest.enregistrer(fichierout);
303 francois 432 }
304     if (app.get_action()==6)
305 francois 283 {
306 francois 432 char mess[500];
307     char coderesu[10];
308     app.recupere_parametre_string_avec_defaut(7,coderesu,(char*)"11111111");
309     if (app.get_erreur()==true) return 0;
310     sprintf(mess,"Conversion MAGiC vers code ASTER");
311     app.affiche(mess);
312 francois 283 MG_FILE gest(nomfichier);
313     int nb=gest.get_nb_fem_maillage();
314     for (int i=0;i<nb;i++)
315     {
316     FEM_MAILLAGE* mai=gest.get_fem_maillage(i);
317 francois 319 MG_VOLUME* vol=mai->get_mg_geometrie()->get_mg_volume(0);
318     MG_COQUE* coq=mai->get_mg_geometrie()->get_mg_coque(0);
319 francois 283 unsigned long id=mai->get_id();
320     strncpy(chaine,nomfichier,p-nomfichier);
321     char chaine2[3000];
322     sprintf(chaine2,"%s%lu",chaine,id);
323     std::string namefic=chaine2;
324     MG_EXPORT exp;
325 francois 581 if (vol!=NULL) exp.aster(vol,mai,namefic,MAGIC::CALCUL_ASTER::MECANIQUE,coderesu);
326     if (coq!=NULL) exp.aster(coq,mai,namefic,MAGIC::CALCUL_ASTER::MECANIQUE,coderesu);
327 francois 283 }
328     }
329 francois 432 if (app.get_action()==8)
330 francois 283 {
331 francois 432 if (app.get_erreur()==true) return 0;
332     char mess[500];
333 francois 505 sprintf(mess," Conversion carte de taille ancienne version vers GMSH");
334 francois 432 app.affiche(mess);
335     FCT_GENERATEUR_3D<4> carte;
336 francois 283 carte.lire(nomfichier);
337     strncpy(chaine,nomfichier,p-nomfichier);
338     std::string namefic=chaine;
339 francois 492 FCT_EXPORT exp;
340 francois 283 exp.gmsh(&carte,namefic);
341 francois 432 }
342     #ifdef BREP_STEP
343     if (app.get_action()==9)
344 francois 283 {
345 francois 432 double unite;
346     app.recupere_parametre_double_avec_defaut(10,unite,1.);
347     if (app.get_erreur()==true) return 0;
348     char mess[500];
349     sprintf(mess," Conversion STEP vers MAGiC");
350     app.affiche(mess);
351 francois 283 STEP_IMPORT stepimport;
352     MG_GESTIONNAIRE gest;
353     stepimport.importer(gest,nomfichier) ;
354     strncpy(chaine,nomfichier,p-nomfichier);
355     std::string namefic=chaine;
356     namefic=namefic + ".magic";
357     int nb=gest.get_nb_mg_geometrie();
358     for (int i=0;i<nb;i++)
359     gest.get_mg_geometrie(i)->change_valeur_unite(unite);
360     gest.enregistrer(namefic.c_str());
361     }
362 francois 432 #endif
363     #ifdef BREP_OCC
364     if (app.get_action()==11)
365 francois 283 {
366 francois 652 double eps,eps2;
367 francois 432 bool importstl,importtriangulation;
368     app.recupere_parametre_double_avec_defaut(13,eps,0.000001);
369     app.recupere_parametre_double_avec_defaut(14,eps2,1.);
370     app.recupere_parametre_bool_avec_defaut(15,importstl,false);
371     app.recupere_parametre_bool_avec_defaut(16,importtriangulation,false);
372     if (app.get_erreur()==true) return 0;
373     int importtri=0;
374     if (importstl) importtri=1;
375     if (importtriangulation) importtri=2;
376     char mess[500];
377     sprintf(mess," Conversion STEP via OpenCascade vers MAGiC avec epsilon=%lf",eps);
378     app.affiche(mess);
379 francois 283 MG_GESTIONNAIRE gest;
380 francois 432 OCC_IMPORT occimport;
381 francois 652 MG_GEOMETRIE* mggeo=occimport.importer(gest,nomfichier,FICHIERSTEP,eps) ;
382 francois 432 if (importtri>0) occimport.importer(gest,mggeo,eps2,importtri);
383 francois 283 strncpy(chaine,nomfichier,p-nomfichier);
384     std::string namefic=chaine;
385     namefic=namefic + ".magic";
386     gest.enregistrer(namefic.c_str());
387     }
388 francois 432 #endif
389     #ifdef BREP_SAT
390     if (app.get_action()==12)
391 francois 283 {
392 francois 432 double unite;
393     app.recupere_parametre_double_avec_defaut(10,unite,1.);
394     if (app.get_erreur()==true) return 0;
395     char mess[500];
396     sprintf(mess," Conversion SAT vers MAGiC");
397     app.affiche(mess);
398 francois 283 MG_GESTIONNAIRE gest;
399 francois 432 ACIS_IMPORT acisimport;
400     acisimport.importer(gest,nomfichier) ;
401 francois 283 strncpy(chaine,nomfichier,p-nomfichier);
402     std::string namefic=chaine;
403     namefic=namefic + ".magic";
404     int nb=gest.get_nb_mg_geometrie();
405     for (int i=0;i<nb;i++)
406     gest.get_mg_geometrie(i)->change_valeur_unite(unite);
407     gest.enregistrer(namefic.c_str());
408     }
409 francois 432 #endif
410     #ifdef BREP_OCC
411     if (app.get_action()==17)
412 francois 283 {
413 francois 652 double eps,eps2;
414 francois 432 bool importstl,importtriangulation;
415     app.recupere_parametre_double_avec_defaut(13,eps,0.000001);
416     app.recupere_parametre_double_avec_defaut(14,eps2,1.);
417     app.recupere_parametre_bool_avec_defaut(15,importstl,false);
418     app.recupere_parametre_bool_avec_defaut(16,importtriangulation,false);
419     if (app.get_erreur()==true) return 0;
420     int importtri=0;
421     if (importstl) importtri=1;
422     if (importtriangulation) importtri=2;
423     char mess[500];
424     sprintf(mess," Conversion OpenCascade vers MAGiC");
425     app.affiche(mess);
426 francois 283 MG_GESTIONNAIRE gest;
427     OCC_IMPORT occimport;
428 francois 652 MG_GEOMETRIE* mggeo=occimport.importer(gest,nomfichier,FICHIEROCC,eps) ;
429 francois 283 if (importtri>0) occimport.importer(gest,mggeo,eps2,importtri);
430     strncpy(chaine,nomfichier,p-nomfichier);
431     std::string namefic=chaine;
432     namefic=namefic + ".magic";
433     gest.enregistrer(namefic.c_str());
434 francois 432 }
435 francois 283 #endif
436 francois 432 if (app.get_action()==18)
437 francois 283 {
438 francois 432 int degre,nummai;
439 francois 656 bool analyse;
440 francois 432 app.recupere_parametre_int_avec_defaut(19,nummai,0);
441     app.recupere_parametre_int(20,degre,(char*)"Degré du maillage manquant");
442 francois 656 app.recupere_parametre_bool_avec_defaut(75,analyse,false);
443 francois 432 if (app.get_erreur()==true) return 0;
444     char mess[500];
445 francois 283 sprintf(mess," Creation d'un maillage FEM");
446 francois 432 app.affiche(mess);
447 francois 283 MG_FILE gest(nomfichier);
448 francois 432 MG_MAILLAGE* mai;
449     if (nummai==0) mai=gest.get_mg_maillage(nummai); else mai=gest.get_mg_maillageid(nummai);
450 francois 283 FEM_MAILLAGE* fem=new FEM_MAILLAGE(mai->get_mg_geometrie(),mai,degre);
451     gest.ajouter_fem_maillage(fem);
452     fem->construire(0);
453     gest.enregistrer(nomfichier);
454 francois 656 if (analyse==true)
455     if (degre==2)
456 francois 612 {
457     //char message [5000];
458     FEM_MAILLAGE_QUADRATIQUE_OUTILS ou ;
459     double moy=ou.get_distortion_moy(fem);
460     double min=ou.get_distortion_min (fem);
461     int nb=ou.get_nombre_elements_invalides(fem);
462     sprintf(mess," maillage quadratique :");
463     app.affiche(mess);
464     sprintf(mess," ");
465     app.affiche(mess);
466     sprintf(mess," distorsion moy %f ",moy);
467     app.affiche(mess);
468     sprintf(mess," distorsion min %f ",min);
469     app.affiche(mess);
470     sprintf(mess," nombre elements invalides %d ",nb);
471     app.affiche(mess);
472     }
473    
474    
475 francois 432 }
476     if (app.get_action()==21)
477 francois 283 {
478 francois 432 int nummai;
479     char fichieraster[500];
480     app.recupere_parametre_int_avec_defaut(19,nummai,0);
481 francois 535 app.recupere_parametre_string(22,fichieraster,(char*)"Fichier aster manquant");
482 francois 432 if (app.get_erreur()==true) return 0;
483     char mess[500];
484 francois 283 sprintf(mess," Importation des résultats ASTER vers MAGIC");
485 francois 432 app.affiche(mess);
486 francois 283 MG_FILE gest(nomfichier);
487 francois 432 FEM_MAILLAGE* mai;
488     if (nummai==0) mai=gest.get_fem_maillage(nummai); else mai=gest.get_fem_maillageid(nummai);
489 francois 283 MG_IMPORT imp;
490 francois 581 std::string res=imp.aster(mai,fichieraster,nomfichier);
491 francois 691 app.affiche((char*)("\033[1;31m"+res+"\033[1;32m").c_str());
492 francois 283 gest.enregistrer(nomfichier);
493 francois 432 }
494    
495     if (app.get_action()==23)
496 francois 283 {
497 francois 432 char coderesu[10];
498     app.recupere_parametre_string_avec_defaut(7,coderesu,(char*)"11111111");
499     if (app.get_erreur()==true) return 0;
500     char mess[500];
501     sprintf(mess," Conversion MAGiC vers OPTIS");
502     app.affiche(mess);
503 francois 283 MG_FILE gest(nomfichier);
504     int nb=gest.get_nb_fem_maillage();
505     for (int i=0;i<nb;i++)
506     {
507     FEM_MAILLAGE* mai=gest.get_fem_maillage(i);
508     unsigned long id=mai->get_id();
509     strncpy(chaine,nomfichier,p-nomfichier);
510     char chaine2[3000];
511     sprintf(chaine2,"%s%lu",chaine,id);
512     std::string namefic=chaine2;
513     MG_EXPORT exp;
514 francois 319 MG_VOLUME* vol=mai->get_mg_geometrie()->get_mg_volume(0);
515     MG_COQUE* coq=mai->get_mg_geometrie()->get_mg_coque(0);
516 francois 581 if (vol!=NULL) exp.aster(vol,mai,namefic,MAGIC::CALCUL_ASTER::OPTISHERBROOKE,coderesu);
517     if (coq!=NULL) exp.aster(coq,mai,namefic,MAGIC::CALCUL_ASTER::OPTISHERBROOKE,coderesu);
518 francois 283 }
519     }
520 francois 432 if (app.get_action()==24)
521 francois 283 {
522 francois 432 int nummai;
523     char fichieroptis[500];
524     char fichierflottant[500];
525     double niveau,seuil;
526     app.recupere_parametre_int_avec_defaut(19,nummai,0);
527     app.recupere_parametre_string(25,fichieroptis,(char*)"Fichier OPTIS manquant");
528     app.recupere_parametre_string_avec_defaut(26,fichieroptis,(char*)"");
529     app.recupere_parametre_double(27,seuil,(char*)"Seuil manquant");
530     app.recupere_parametre_double(28,niveau,(char*)"Niveau manquant");
531     if (app.get_erreur()==true) return 0;
532     char mess[500];
533     sprintf(mess," Importation des résultats d'optimisation vers MAGIC");
534     app.affiche(mess);
535 francois 283 MG_FILE gest(nomfichier);
536 francois 432 FEM_MAILLAGE* mai;
537     if (nummai==0) mai=gest.get_fem_maillage(nummai); else mai=gest.get_fem_maillageid(nummai);
538 francois 283 MG_IMPORT imp;
539 francois 432 int flottant=0;
540     if (strlen(fichierflottant)>0) flottant=1;
541 francois 283 imp.optis(mai,fichieroptis,fichierflottant,seuil,niveau,flottant);
542     gest.enregistrer(nomfichier);
543 francois 432 }
544    
545     if (app.get_action()==29)
546 francois 283 {
547 francois 432 int numgeo,numgt,numentite;
548     bool expand;
549     app.recupere_parametre_int_avec_defaut(31,numgeo,0);
550     app.recupere_parametre_int_avec_defaut(32,numgt,0);
551     app.recupere_parametre_int(33,numentite,(char*)"Numéro d'entité manquant");
552     app.recupere_parametre_bool_avec_defaut(34,expand,false);
553     if (app.get_erreur()==true) return 0;
554     char mess[500];
555     sprintf(mess," Selection de groupe topologique");
556     app.affiche(mess);
557 francois 283 MG_FILE gest(nomfichier);
558 francois 432 MG_GEOMETRIE* mggeo;
559     if (numgeo==0) mggeo=gest.get_mg_geometrie(numgeo); else mggeo=gest.get_mg_geometrieid(numgeo);
560 francois 283 MG_GROUPE_TOPOLOGIQUE* mggt;
561     if (numgt==0)
562     {
563     mggt=new MG_GROUPE_TOPOLOGIQUE;
564     mggeo->ajouter_mg_groupe_topologique(mggt);
565     }
566     else mggt=mggeo->get_mg_groupe_topologiqueid(numgt);
567     MG_ELEMENT_TOPOLOGIQUE* ele;
568     ele=mggeo->get_mg_sommetid(numentite);
569     if (ele==NULL) ele=mggeo->get_mg_areteid(numentite);
570     if (ele==NULL) ele=mggeo->get_mg_faceid(numentite);
571     if (ele==NULL) ele=mggeo->get_mg_volumeid(numentite);
572     if (ele!=NULL)
573     {
574     mggt->ajouter(ele);
575     if (expand)
576     {
577     TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> lst;
578     ele->get_topologie_sousjacente(&lst);
579     TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*>::ITERATEUR it;
580     for (MG_ELEMENT_TOPOLOGIQUE *ele2=lst.get_premier(it);ele2!=NULL;ele2=lst.get_suivant(it))
581     mggt->ajouter(ele2);
582     }
583     }
584     gest.enregistrer(nomfichier);
585     }
586 francois 432 if (app.get_action()==30)
587 francois 283 {
588 francois 432 int numgeo,numgt,numentite;
589     bool expand;
590     app.recupere_parametre_int_avec_defaut(31,numgeo,0);
591     app.recupere_parametre_int_avec_defaut(32,numgt,0);
592     app.recupere_parametre_int(33,numentite,(char*)"Numéro d'entité manquant");
593     app.recupere_parametre_bool_avec_defaut(34,expand,false);
594     if (app.get_erreur()==true) return 0;
595     char mess[500];
596     sprintf(mess," Deselection de groupe topologique");
597     app.affiche(mess);
598 francois 283 MG_FILE gest(nomfichier);
599     MG_GEOMETRIE* mggeo=gest.get_mg_geometrieid(numgeo);
600     MG_GROUPE_TOPOLOGIQUE* mggt=mggeo->get_mg_groupe_topologiqueid(numgt);
601     MG_ELEMENT_TOPOLOGIQUE* ele;
602     ele=mggeo->get_mg_sommetid(numentite);
603     if (ele==NULL) ele=mggeo->get_mg_areteid(numentite);
604     if (ele==NULL) ele=mggeo->get_mg_faceid(numentite);
605     if (ele==NULL) ele=mggeo->get_mg_volumeid(numentite);
606     if (ele!=NULL)
607     {
608     mggt->supprimer(ele);
609     if (expand)
610     {
611     TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> lst;
612     ele->get_topologie_sousjacente(&lst);
613     TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*>::ITERATEUR it;
614     for (MG_ELEMENT_TOPOLOGIQUE *ele2=lst.get_premier(it);ele2!=NULL;ele2=lst.get_suivant(it))
615     mggt->supprimer(ele2);
616     }
617     }
618     gest.enregistrer(nomfichier);
619 francois 432 }
620    
621     if (app.get_action()==35)
622 francois 283 {
623 francois 432 int nummai;
624     double angle;
625     char fichierlog[500];
626 francois 477 strcpy(fichierlog,"");
627 francois 432 app.recupere_parametre_int_avec_defaut(19,nummai,-1);
628     app.recupere_parametre_double_avec_defaut(36,angle,0.03);
629     app.recupere_parametre_string_avec_defaut(37,fichierlog,(char*)fichierlog);
630     if (app.get_erreur()==true) return 0;
631     char mess[500];
632     sprintf(mess," Contenu d'un fichier MAGIC");
633     app.affiche(mess);
634 francois 283 MG_FILE gest(nomfichier);
635 francois 425 if (nummai!=-1)
636     {
637     MG_MAILLAGE* mai=gest.get_mg_maillageid(nummai);
638     MAILLEUR_ANALYSE m3d(mai);
639 francois 432 m3d.active_affichage(app.affiche);
640 francois 426 m3d.change_eps_angle_retourne(angle);
641 francois 432 if (strlen(fichierlog)==0)
642 francois 425 m3d.analyse();
643     else
644     m3d.analyse(fichierlog);
645     }
646     else
647     {
648     char message [5000];
649 francois 691 int nbarbre=gest.get_nb_mg_arbre();
650     sprintf(message," \033[1;32m%d\033[1;33m arbres :",nbarbre);
651     for (int i=0;i<nbarbre;i++)
652     {
653     MG_ARBRE* arb=gest.get_mg_arbre(i);
654     sprintf(message,"%s \033[1;31m%lu\033[1;33m ",message,arb->get_id());
655     }
656     app.affiche(message);
657     for (int i=0;i<nbarbre;i++)
658     {
659     MG_ARBRE* arb=gest.get_mg_arbre(i);
660     sprintf(message," arbre \033[1;31m%lu\033[1;33m",arb->get_id());
661     app.affiche(message);
662     int nbprim=arb->get_nb_mg_primitive();
663     sprintf(message," \033[1;32m%d\033[1;33m primitives",nbprim);
664     //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());
665     app.affiche(message);
666     int nbope=arb->get_nb_mg_operateur_boolean();
667     sprintf(message," \033[1;32m%d\033[1;33m operateurs booleans",nbope);
668     app.affiche(message);
669     }
670     int nbgeo=gest.get_nb_mg_geometrie();
671     sprintf(message," \033[1;32m%d\033[1;33m geometries :",nbgeo);
672 francois 283 for (int i=0;i<nbgeo;i++)
673     {
674     MG_GEOMETRIE* geo=gest.get_mg_geometrie(i);
675 francois 691 sprintf(message,"%s \033[1;31m%lu\033[1;33m ",message,geo->get_id());
676 francois 283 }
677 francois 432 app.affiche(message);
678 francois 283 for (int i=0;i<nbgeo;i++)
679     {
680     MG_GEOMETRIE* geo=gest.get_mg_geometrie(i);
681 francois 691 sprintf(message," geometrie \033[1;31m%lu\033[1;33m",geo->get_id());
682 francois 432 app.affiche(message);
683 francois 283 int nbmg=geo->get_nb_mg_groupe_topologique();
684 francois 691 sprintf(message," \033[1;32m%d\033[1;33m groupe topologique",nbmg);
685 francois 283 for (int j=0;j<nbmg;j++)
686     {
687     MG_GROUPE_TOPOLOGIQUE* mggp=geo->get_mg_groupe_topologique(j);
688 francois 691 sprintf(message,"%s \033[1;31m%lu\033[1;33m ",message,mggp->get_id());
689 francois 283 }
690 francois 432 app.affiche(message);
691 francois 299 int nbvolume=geo->get_nb_mg_volume();
692 francois 691 if (nbvolume==0) sprintf(message," \033[1;32m%d\033[1;33m volumes",geo->get_nb_mg_volume());
693     else sprintf(message," \033[1;32m%d\033[1;33m volumes : ",geo->get_nb_mg_volume());
694     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());
695 francois 432 app.affiche(message);
696 francois 299 int nbcoque=geo->get_nb_mg_coque();
697 francois 691 if (nbcoque==0) sprintf(message," \033[1;32m%d\033[1;33m coques",geo->get_nb_mg_coque());
698     else sprintf(message," \033[1;32m%d\033[1;33m coques : ",geo->get_nb_mg_coque());
699     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());
700 francois 432 app.affiche(message);
701 francois 299 int nbpoutre=geo->get_nb_mg_poutre();
702 francois 691 if (nbpoutre==0) sprintf(message," \033[1;32m%d\033[1;33m poutres",geo->get_nb_mg_poutre());
703     else sprintf(message," \033[1;32m%d\033[1;33m poutres : ",geo->get_nb_mg_poutre());
704     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());
705 francois 432 app.affiche(message);
706 francois 691 sprintf(message," \033[1;32m%d\033[1;33m coquilles",geo->get_nb_mg_coquille());
707 francois 432 app.affiche(message);
708 francois 691 sprintf(message," \033[1;32m%d\033[1;33m faces",geo->get_nb_mg_face());
709 francois 432 app.affiche(message);
710 francois 691 sprintf(message," \033[1;32m%d\033[1;33m aretes",geo->get_nb_mg_arete());
711 francois 432 app.affiche(message);
712 francois 691 sprintf(message," \033[1;32m%d\033[1;33m sommets",geo->get_nb_mg_sommet());
713 francois 432 app.affiche(message);
714 francois 425
715 francois 283
716     }
717     int nbmai=gest.get_nb_mg_maillage();
718 francois 691 sprintf(message," \033[1;32m%d\033[1;33m maillage geometrique :",nbmai);
719 francois 432 app.affiche(message);
720 francois 283 for (int i=0;i<nbmai;i++)
721     {
722     MG_MAILLAGE* mai=gest.get_mg_maillage(i);
723 francois 691 sprintf(message," maillage geometrique \033[1;31m%lu\033[1;33m ",mai->get_id());
724 francois 432 app.affiche(message);
725 francois 691 sprintf(message," \033[1;32m%d\033[1;33m noeuds",mai->get_nb_mg_noeud());
726 francois 432 app.affiche(message);
727 francois 691 sprintf(message," \033[1;32m%d\033[1;33m segments",mai->get_nb_mg_segment());
728 francois 432 app.affiche(message);
729 francois 691 sprintf(message," \033[1;32m%d\033[1;33m triangles",mai->get_nb_mg_triangle());
730 francois 432 app.affiche(message);
731 francois 691 sprintf(message," \033[1;32m%d\033[1;33m quadrangles",mai->get_nb_mg_quadrangle());
732 francois 674 app.affiche(message);
733 francois 691 sprintf(message," \033[1;32m%d\033[1;33m tetras",mai->get_nb_mg_tetra());
734 francois 432 app.affiche(message);
735 francois 691 sprintf(message," \033[1;32m%d\033[1;33m hexas",mai->get_nb_mg_hexa());
736 francois 674 app.affiche(message);
737 francois 283 }
738     int nbmaif=gest.get_nb_fem_maillage();
739 francois 691 sprintf(message," \033[1;32m%d\033[1;33m maillage FEM :",nbmaif);
740 francois 432 app.affiche(message);
741 francois 283 for (int i=0;i<nbmaif;i++)
742     {
743     FEM_MAILLAGE* maif=gest.get_fem_maillage(i);
744 francois 691 sprintf(message," maillage FEM\033[1;31m%lu\033[1;33m ",maif->get_id());
745 francois 432 app.affiche(message);
746 francois 691 sprintf(message," \033[1;32m%d\033[1;33m noeuds",maif->get_nb_fem_noeud());
747 francois 432 app.affiche(message);
748 francois 691 sprintf(message," \033[1;32m%d\033[1;33m elements 1D",maif->get_nb_fem_element1());
749 francois 432 app.affiche(message);
750 francois 691 sprintf(message," \033[1;32m%d\033[1;33m elements 2D",maif->get_nb_fem_element2());
751 francois 432 app.affiche(message);
752 francois 691 sprintf(message," \033[1;32m%d\033[1;33m elements 3D",maif->get_nb_fem_element3());
753 francois 432 app.affiche(message);
754 francois 325 double rx,ry,rz;
755     maif->calcul_somme_reaction(rx,ry,rz);
756 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);
757 francois 432 app.affiche(message);
758 francois 325
759 francois 283 }
760     int nbsol=gest.get_nb_mg_solution();
761 francois 691 sprintf(message," \033[1;32m%d\033[1;33m solution maillage geometrique :",nbsol);
762     app.affiche(message);
763     message[0]=0;
764     for (int i=0;i<nbsol;i++)
765 francois 283 {
766     MG_SOLUTION* sol=gest.get_mg_solution(i);
767 francois 628 char legende[500];
768 francois 691 legende[0]=0;
769     message[0]=0;
770 francois 628 for (int j=0;j<sol->get_nb_champ();j++)
771     sprintf(legende,"%s%s_%s ",legende,(char*)sol->get_nom().c_str(),(char*)sol->get_legende(j).c_str());
772 francois 691 sprintf(message," \033[1;31m%lu(%s)\033[1;33m ",sol->get_id(),legende);
773 francois 628 app.affiche(message);
774 francois 283 }
775     int nbsolf=gest.get_nb_fem_solution();
776 francois 691 sprintf(message," \033[1;32m%d\033[1;33m solution maillage FEM :",nbsolf);
777 francois 628 app.affiche(message);
778 francois 660 message[0]=0;
779     for (int i=0;i<nbsolf;i++)
780 francois 283 {
781 francois 628 FEM_SOLUTION* sol=gest.get_fem_solution(i);
782     char legende[500];
783 francois 670 legende[0]=0;
784 francois 660 message[0]=0;
785 francois 628 for (int j=0;j<sol->get_nb_champ();j++)
786     sprintf(legende,"%s%s_%s ",legende,(char*)sol->get_nom().c_str(),(char*)sol->get_legende(j).c_str());
787 francois 691 sprintf(message," \033[1;31m%lu(%s)\033[1;33m ",sol->get_id(),legende);
788 francois 628 app.affiche(message);
789     }
790 francois 283 }
791     }
792 francois 432 if (app.get_action()==38)
793 francois 283 {
794 francois 432 int nummai;
795     int numsol1,numsol2,numsol3;
796     int numchamp1,numchamp2,numchamp3;
797 francois 516 double coef;
798 francois 432 app.recupere_parametre_int_avec_defaut(19,nummai,0);
799     app.recupere_parametre_int(40,numsol1,(char*)"Numéro solution 1 manquant");
800     app.recupere_parametre_int(41,numsol2,(char*)"Numéro solution 2 manquant");
801     app.recupere_parametre_int(42,numsol3,(char*)"Numéro solution 3 manquant");
802     app.recupere_parametre_int(43,numchamp1,(char*)"Numéro champs 1 manquant");
803     app.recupere_parametre_int(44,numchamp2,(char*)"Numéro champs 2 manquant");
804     app.recupere_parametre_int(45,numchamp3,(char*)"Numéro champs 3 manquant");
805 francois 516 app.recupere_parametre_double_avec_defaut(61,coef,0.);
806 francois 432 if (app.get_erreur()==true) return 0;
807     char mess[500];
808     sprintf(mess," Calcul de deforme");
809     app.affiche(mess);
810 francois 283 MG_FILE gest(nomfichier);
811 francois 432 FEM_MAILLAGE* mai;
812     if (nummai==0) mai=gest.get_fem_maillage(nummai); else mai=gest.get_fem_maillageid(nummai);
813 francois 283 FEM_SOLUTION* sol1=gest.get_fem_solutionid(numsol1);
814     FEM_SOLUTION* sol2=gest.get_fem_solutionid(numsol2);
815     FEM_SOLUTION* sol3=gest.get_fem_solutionid(numsol3);
816     mai->calcul_deforme(sol1,numchamp1,sol2,numchamp2,sol3,numchamp3);
817 francois 516 if (coef>1e-16)
818     {
819     sprintf(mess," Création du maillage deforme");
820     app.affiche(mess);
821     MG_MAILLAGE* mgmai=new MG_MAILLAGE(mai,coef);
822     }
823     sprintf(mess," Enregistrement");
824     app.affiche(mess);
825     gest.enregistrer(nomfichier);
826 francois 283 }
827 francois 432 if (app.get_action()==39)
828 francois 283 {
829 francois 432 int numgeo;
830     app.recupere_parametre_int_avec_defaut (31,numgeo,0);
831     if (app.get_erreur()==true) return 0;
832     char mess[500];
833     sprintf(mess," Fusion de géométrie");
834     app.affiche(mess);
835 francois 283 MG_FILE gest(nomfichier);
836 francois 432 MG_GEOMETRIE* mggeo;
837     if (numgeo==0) mggeo=gest.get_mg_geometrie(numgeo); else mggeo=gest.get_mg_geometrieid(numgeo);
838 francois 283 VCT_MULTI_MODELE fusion(mggeo);
839     fusion.recherche_identite();
840     gest.enregistrer(nomfichier);
841 francois 432 }
842     if ((app.get_action()==46) || (app.get_action()==47))
843 francois 283 {
844 francois 432 int numgeo;
845     char ccf[500];
846     app.recupere_parametre_int_avec_defaut (31,numgeo,0);
847     app.recupere_parametre_string(49,ccf,(char*)"Valeur de la condition aux limites manquant");
848     if (app.get_erreur()==true) return 0;
849     char mess[500];
850     sprintf(mess," Selection de condition aux limites");
851 francois 296 unsigned long identity;
852     char typeccf[3];
853 gervaislavoie 318 typeccf[2]=0;
854 gervaislavoie 302 double valccf=0.5; // Valeur par défaut
855 francois 296 sscanf(ccf,"%lu:%c%c:%le\n",&identity,&typeccf[0],&typeccf[1],&valccf);
856     MC_GESTIONNAIRE mcgest;
857     int res=mcgest.existe(typeccf);
858     if (res==0)
859     {
860     sprintf(mess," ERREUR!!!! Code conditions aux limites inconnu");
861 francois 432 app.affiche(mess);
862 francois 296 return 0;
863     }
864     sprintf(mess," Ajout d'une condition aux limites : %s",mcgest.get_description(typeccf).c_str());
865 francois 432 app.affiche(mess);
866 francois 292 MG_FILE gest(nomfichier);
867 francois 432 MG_GEOMETRIE* geo;
868     if (numgeo==0) geo=gest.get_mg_geometrie(numgeo); else geo=gest.get_mg_geometrieid(numgeo);
869 francois 292 TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> liste;
870 francois 296 MG_VOLUME* ele;
871     ele=geo->get_mg_volumeid(identity);
872 francois 292 if (ele!=NULL) liste.ajouter(ele);
873 francois 296 else
874     {
875     MG_COQUE* ele;
876     ele=geo->get_mg_coqueid(identity);
877     if (ele!=NULL) liste.ajouter(ele);
878     else
879 francois 292 {
880 francois 296 MG_POUTRE* ele;
881     ele=geo->get_mg_poutreid(identity);
882 francois 292 if (ele!=NULL) liste.ajouter(ele);
883     else
884 francois 296 {
885     MG_FACE* ele;
886     ele=geo->get_mg_faceid(identity);
887     if (ele!=NULL) liste.ajouter(ele);
888     else
889     {
890     MG_ARETE* ele;
891     ele=geo->get_mg_areteid(identity);
892     if (ele!=NULL) liste.ajouter(ele);
893     else
894     {
895     MG_SOMMET* ele;
896     ele=geo->get_mg_sommetid(identity);
897     if (ele!=NULL) liste.ajouter(ele);
898     }
899     }
900     }
901 francois 292 }
902 francois 296 }
903 francois 432 if (app.get_action()==47)
904 francois 292 {
905     int nb=liste.get_nb();
906     for (int i=0;i<nb;i++) liste.get(i)->get_topologie_sousjacente(&liste);
907     }
908     int nb=liste.get_nb();
909     for (int i=0;i<nb;i++) liste.get(i)->ajouter_ccf(typeccf,valccf);;
910     gest.enregistrer(nomfichier);
911 francois 432 }
912     if (app.get_action()==48)
913 francois 296 {
914 francois 432 char mess[500];
915 francois 296 sprintf(mess," Liste des conditions aux limites disponibles");
916 francois 432 app.affiche(mess);
917 francois 296 MC_GESTIONNAIRE mcgest;
918     int ok=0;
919     do
920     {
921     std::string code;
922     std::string description;
923     int res=mcgest.get_description(code,description);
924     if (res)
925     {
926     sprintf(mess," %s : %s",code.c_str(),description.c_str());
927 francois 432 app.affiche(mess);
928 francois 296 }
929     else ok=1;
930     }
931     while (ok==0);
932 francois 432 }
933     if (app.get_action()==50)
934 francois 326 {
935 francois 432 int numgeo,nummai,numcoque;
936     char fichierout[500];
937     app.recupere_parametre_int_avec_defaut(31,numgeo,0);
938     app.recupere_parametre_int_avec_defaut(19,nummai,0);
939     app.recupere_parametre_int_avec_defaut(51,numcoque,0);
940     app.recupere_parametre_string_avec_defaut(5,fichierout,nomfichier);
941     if (app.get_erreur()==true) return 0;
942     char mess[500];
943 gervaislavoie 328 sprintf(mess," Orientation d'une coque");
944 francois 432 app.affiche(mess);
945 gervaislavoie 328 MG_FILE gest(nomfichier);
946 francois 432 MG_GEOMETRIE* geo;
947     if (numgeo==0) geo=gest.get_mg_geometrie(numgeo); else geo=gest.get_mg_geometrieid(numgeo);
948     MG_MAILLAGE* mai;
949     if (nummai==0) mai=gest.get_mg_maillage(nummai); else mai=gest.get_mg_maillageid(nummai);
950     MG_COQUE* coque;
951     if (numcoque==0) coque=mai->get_mg_geometrie()->get_mg_coque(numcoque); else coque=mai->get_mg_geometrie()->get_mg_coqueid(numcoque);
952 gervaislavoie 328 coque->orienter(mai);
953     gest.enregistrer(fichierout);
954 francois 432 }
955     if (app.get_action()==52)
956 francois 428 {
957 francois 432 double epsf,unite;
958     app.recupere_parametre_double_avec_defaut(10,unite,1.);
959     app.recupere_parametre_double_avec_defaut(53,epsf,0.0001);
960     if (app.get_erreur()==true) return 0;
961     char mess[500];
962     sprintf(mess," Conversion STL vers MAGiC");
963     app.affiche(mess);
964     MG_GESTIONNAIRE gest;
965 francois 428 STL_IMPORT stlimport;
966 francois 429 stlimport.change_eps(epsf);
967 francois 428 stlimport.importer(gest,nomfichier) ;
968     strncpy(chaine,nomfichier,p-nomfichier);
969     std::string namefic=chaine;
970     namefic=namefic + ".magic";
971     int nb=gest.get_nb_mg_geometrie();
972     for (int i=0;i<nb;i++)
973     gest.get_mg_geometrie(i)->change_valeur_unite(unite);
974     gest.enregistrer(namefic.c_str());
975     }
976 francois 432 if (app.get_action()==54)
977 mejrim 597 {
978 francois 432 int nummai;
979     char coderesu[10];
980 mejrim 597 bool mecanique;
981     bool thermique;
982 francois 603 bool conplane;
983     bool defplane;
984 francois 432 app.recupere_parametre_int_avec_defaut(19,nummai,0);
985     app.recupere_parametre_string_avec_defaut(7,coderesu,(char*)"11111111");
986 mejrim 597 app.recupere_parametre_bool_avec_defaut(63,mecanique,false);
987     app.recupere_parametre_bool_avec_defaut(64,thermique,false);
988 francois 603 app.recupere_parametre_bool_avec_defaut(65,conplane,false);
989     app.recupere_parametre_bool_avec_defaut(66,defplane,false);
990 francois 432 if (app.get_erreur()==true) return 0;
991     char mess[500];
992     sprintf(mess," Calcul ASTER");
993     app.affiche(mess);
994     char nometude[1000];
995     char *p=strchr(nomfichier,'.');
996     strncpy(nometude,nomfichier,p-nomfichier);
997     nometude[p-nomfichier]=0;
998     MG_FILE gest(nomfichier);
999     FEM_MAILLAGE* mai;
1000     if (nummai==0) mai=gest.get_fem_maillage(nummai); else mai=gest.get_fem_maillageid(nummai);
1001     MGASTER mgaster;
1002     mgaster.active_affichage(app.affiche);
1003 mejrim 597 if (mecanique) mgaster.calcule(mai,nometude,MAGIC::CALCUL_ASTER::MECANIQUE,coderesu);
1004 francois 603 if (conplane) mgaster.calcule(mai,nometude,MAGIC::CALCUL_ASTER::CONTRAINTE_PLANE,coderesu);
1005     if (defplane) mgaster.calcule(mai,nometude,MAGIC::CALCUL_ASTER::DEFORMATION_PLANE,coderesu);
1006 mejrim 597 if (thermique) mgaster.calcule(mai,nometude,MAGIC::CALCUL_ASTER::THERMIQUE,(char*)"");
1007 francois 432 }
1008 francois 469 if (app.get_action()==56)
1009     {
1010     if (app.get_erreur()==true) return 0;
1011     char mess[500];
1012 francois 505 sprintf(mess," Conversion carte de taille nouvelle version vers GMSH");
1013 francois 469 app.affiche(mess);
1014     FCT_TAILLE_FEM_SOLUTION carte(nomfichier);
1015     strncpy(chaine,nomfichier,p-nomfichier);
1016     std::string namefic=chaine;
1017     MG_EXPORT exp;
1018 francois 505 exp.gmsh(&carte,namefic);
1019 francois 469 sprintf(mess," Carte de taille FEM : Creation de %s.msh",namefic.c_str());
1020     app.affiche(mess);
1021     }
1022 francois 514 if ((app.get_action()==58) || (app.get_action()==60))
1023     {
1024     int nummai;
1025     app.recupere_parametre_int_avec_defaut(19,nummai,0);
1026     char nomcarte[500];
1027     if (app.get_action()==58)
1028     app.recupere_parametre_string(59,nomcarte,(char*)"Fichier carte manquant");
1029     if (app.get_action()==60)
1030     app.recupere_parametre_string(59,nomcarte,(char*)"Fichier carte manquant");
1031     if (app.get_erreur()==true) return 0;
1032     char mess[500];
1033     sprintf(mess," Comparaison de la taille reelle d'un maillage avec la carte de taille");
1034     app.affiche(mess);
1035     sprintf(mess," Lecture fichier MAGiC");
1036     app.affiche(mess);
1037     MG_FILE gest(nomfichier);
1038     MG_MAILLAGE* mai;
1039     if (nummai==0) mai=gest.get_mg_maillage(nummai); else mai=gest.get_mg_maillageid(nummai);
1040     sprintf(mess," Lecture fichier carte de taille");
1041     app.affiche(mess);
1042     FCT_TAILLE *carte;
1043     if (app.get_action()==58)
1044     carte=new FCT_GENERATEUR_3D<4>(nomcarte);
1045 francois 518 if (app.get_action()==60)
1046 francois 514 carte=new FCT_TAILLE_FEM_SOLUTION(nomcarte);
1047     char nometude[1000];
1048     char *p=strchr(nomfichier,'.');
1049     strncpy(nometude,nomfichier,p-nomfichier);
1050     nometude[p-nomfichier]=0;
1051     char nomsolution[500];
1052     sprintf(nomsolution,"%s_comp%lu.sol",nometude,mai->get_id());
1053     sprintf(mess," Comparaison");
1054     app.affiche(mess);
1055     MAILLEUR_ANALYSE m3d(mai);
1056 francois 577 sprintf(mess," Respect global de la taille demandee");
1057     app.affiche(mess);
1058     double tabtaille[3];
1059     m3d.compare_maillage_carte_isotrope(carte,nomsolution,tabtaille);
1060     sprintf(mess," Nombre de maille théorique : %lf - Nombre de maille reelle : %lf",tabtaille[0],tabtaille[1]);
1061     app.affiche(mess);
1062     sprintf(mess," Erreur : %lf%%",tabtaille[2]);
1063     app.affiche(mess);
1064 francois 560 MG_SOLUTION *sol=gest.get_mg_solution(gest.get_nb_mg_solution()-1);
1065     sol->active_solution(2);
1066     LISTE_MG_NOEUD::iterator it;
1067     int tab[201];
1068     for (int i=0;i<201;i++) tab[i]=0;
1069     for (MG_NOEUD* no=mai->get_premier_noeud(it);no!=NULL;no=mai->get_suivant_noeud(it))
1070     {
1071     double val=no->get_solution();
1072     int valint=(int)val+100;
1073     if (valint<0) valint=0;
1074     if (valint>200) valint=200;
1075     tab[valint]++;
1076     }
1077 francois 577 sprintf(mess," Repartition du respect de la taille demandee");
1078 francois 560 app.affiche(mess);
1079     char nomanalyse[500];
1080     sprintf(nomanalyse,"%s_comp%lu.csv",nometude,mai->get_id());
1081     FILE *in=fopen(nomanalyse,"wt");
1082     for (int i=0;i<201;i++)
1083     if (i<101) fprintf(in,"%d;%d;\n",i-100,tab[i]);
1084     else fprintf(in,"%d;%d;%d;\n",i-100,tab[i],tab[i]+tab[200-i]);
1085     fclose(in);
1086 francois 514 sprintf(mess," Enregistrement");
1087     app.affiche(mess);
1088     sprintf(nomsolution,"%s_comp%lu.magic",nometude,mai->get_id());
1089     gest.enregistrer(nomsolution);
1090     delete carte;
1091     }
1092 francois 475 if (app.get_action()==57)
1093     {
1094     int nummai;
1095     app.recupere_parametre_int_avec_defaut(19,nummai,0);
1096     if (app.get_erreur()==true) return 0;
1097     char mess[500];
1098     sprintf(mess," Conversion mg maillage en stl");
1099     app.affiche(mess);
1100     MG_FILE gest(nomfichier);
1101     strncpy(chaine,nomfichier,p-nomfichier);
1102     MG_MAILLAGE* mai;
1103     if (nummai==0) mai=gest.get_mg_maillage(0); else mai=gest.get_mg_maillageid(nummai);
1104     sprintf(chaine,"%s%lu",chaine,mai->get_id());
1105     std::string namefic=chaine;
1106     MG_EXPORT exp;
1107     exp.stl(mai,namefic);
1108     sprintf(mess," creation de %s.stl",namefic.c_str());
1109     app.affiche(mess);
1110    
1111     }
1112 francois 517 if (app.get_action()==62)
1113     {
1114     int nummai;
1115     app.recupere_parametre_int_avec_defaut(19,nummai,0);
1116     char outfile[500];
1117     app.recupere_parametre_string(5,outfile,(char*)"Fichier de sortie manquant");
1118     if (app.get_erreur()==true) return 0;
1119     char mess[500];
1120     sprintf(mess," Détachement d'un mg maillage de sa geometrie");
1121     app.affiche(mess);
1122     MG_FILE gest(nomfichier);
1123     MG_MAILLAGE* mai;
1124     if (nummai==0) mai=gest.get_mg_maillage(0); else mai=gest.get_mg_maillageid(nummai);
1125     MG_GESTIONNAIRE gest2;
1126     MG_MAILLAGE *mai2=mai->detacher(&gest2);
1127     sprintf(mess," Enregistrement");
1128     app.affiche(mess);
1129     gest2.enregistrer(outfile);
1130 francois 604 }
1131     if (app.get_action()==67)
1132     {
1133     int numsol;
1134     int numchamp;
1135     int numare;
1136     int numgeo;
1137     char outfile[500];
1138     app.recupere_parametre_int_avec_defaut(31,numgeo,0);
1139     app.recupere_parametre_int_avec_defaut(68,numsol,0);
1140     app.recupere_parametre_int_avec_defaut(69,numchamp,0);
1141     app.recupere_parametre_int_avec_defaut(71,numare,0);
1142     app.recupere_parametre_string(70,outfile,(char*)"Fichier de sortie manquant");
1143     if (app.get_erreur()==true) return 0;
1144     MG_FILE gest(nomfichier);
1145     FEM_SOLUTION* sol;
1146     if (numsol==0) sol=gest.get_fem_solution(0); else sol=gest.get_fem_solutionid(numsol);
1147     MG_GEOMETRIE* geo;
1148     if (numgeo==0) geo=gest.get_mg_geometrie(0); else geo=gest.get_mg_geometrie(numgeo);
1149     MG_ARETE *are;
1150     if (numare==0) are=geo->get_mg_arete(0); else are=geo->get_mg_areteid(numare);
1151     char mess[500];
1152 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());
1153 francois 604 app.affiche(mess);
1154     are->recupere_resultat(sol,numchamp,outfile);
1155    
1156     }
1157 francois 628 if (app.get_action()==72)
1158     {
1159     int numsol;
1160     int numchamp;
1161     int nummai;
1162     char outfile[500];
1163     char infile[500];
1164     app.recupere_parametre_int_avec_defaut(68,numsol,0);
1165     app.recupere_parametre_int_avec_defaut(69,numchamp,0);
1166     app.recupere_parametre_int_avec_defaut(19,nummai,0);
1167     app.recupere_parametre_string(73,infile,(char*)"Fichier de solution manquant");
1168     app.recupere_parametre_string_avec_defaut(5,outfile,infile);
1169     if (app.get_erreur()==true) return 0;
1170 francois 633 app.affiche((char*)"Lecture du fichier MAGIC");
1171     MG_FILE gest(nomfichier);
1172     app.affiche((char*)"Lecture de la solution a projeter");
1173     MG_FILE gestsol(infile);
1174 francois 628 FEM_SOLUTION* sol;
1175     if (numsol==0) sol=gestsol.get_fem_solution(0); else sol=gestsol.get_fem_solutionid(numsol);
1176     FEM_MAILLAGE* fem;
1177     if (nummai==0) fem=gest.get_fem_maillage(0); else fem=gest.get_fem_maillageid(nummai);
1178     char mess[500];
1179     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());
1180     app.affiche(mess);
1181     FEM_MAILLAGE_OUTILS otfem;
1182 francois 635 int res=otfem.projete_solution_maillage(sol,numchamp,fem);
1183     if (res==MAGIC::PROJECTION::SUCCES) gest.enregistrer(outfile);
1184     if (res==MAGIC::PROJECTION::DIMENSION_MAILLAGE_INCOMPATIBLE) app.affiche((char*)" Erreur : Dimension des maillages incompatibles");
1185     if (res==MAGIC::PROJECTION::TYPE_SOLUTION_INCORRECT) app.affiche((char*)" Erreur : Solution a projeter n'est pas exprimer aux noeuds");
1186     if (res==MAGIC::PROJECTION::NON_IMPLEMENTER) app.affiche((char*)" Erreur : Cas de projection non implementer");
1187 francois 628 }
1188     if (app.get_action()==74)
1189     {
1190     int numsol1;
1191     int numchamp1;
1192     int numsol2;
1193     int numchamp2;
1194     char outfile[500];
1195     app.recupere_parametre_int_avec_defaut(40,numsol1,0);
1196     app.recupere_parametre_int_avec_defaut(41,numsol2,0);
1197     app.recupere_parametre_int_avec_defaut(43,numchamp1,0);
1198     app.recupere_parametre_int_avec_defaut(44,numchamp2,0);
1199     app.recupere_parametre_string_avec_defaut(5,outfile,nomfichier);
1200     if (app.get_erreur()==true) return 0;
1201     MG_FILE gest(nomfichier);
1202     FEM_SOLUTION* sol1;
1203     if (numsol1==0) sol1=gest.get_fem_solution(0); else sol1=gest.get_fem_solutionid(numsol1);
1204     FEM_SOLUTION* sol2;
1205     if (numsol2==0) sol2=gest.get_fem_solution(0); else sol2=gest.get_fem_solutionid(numsol2);
1206     char mess[500];
1207     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());
1208     app.affiche(mess);
1209     FEM_MAILLAGE_OUTILS otfem;
1210 francois 674 otfem.compare_champs_solution(sol1,numchamp1,sol2,numchamp2);
1211 francois 628 gest.enregistrer(outfile);
1212     }
1213 francois 432 char mess[255];
1214     sprintf(mess,"Fin");
1215     app.affiche(mess);
1216     }
1217    
1218    
1219    
1220    
1221    
1222    
1223    
1224    
1225    
1226    
1227    
1228    
1229    
1230    
1231