ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/REPOS_ERICCA/magic/app/mgoperation/src/main.cpp
Revision: 788
Committed: Tue Mar 15 17:04:38 2016 UTC (9 years, 3 months ago) by francois
File size: 74054 byte(s)
Log Message: 
ajout d'une propriete dans les conditions aux limites pour dire si l'effort est suivi ou non en non lineaire.
par defaut non suivi. Si non suivi rien ne change par rapport avant. 
compatible avec les operations anterieurs mais le fichier magic passe en version 2.1

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