mailleur/src/main.cpp

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuilli�e et Vincent FRANCOIS
//  D�artement de G�ie M�anique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du d�artement
//  de g�ie m�anique de l'Universit�du Qu�ec �
//  Trois Rivi�es
//  Les librairies ne peuvent �re utilis�s sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       main.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 �11H25
//------------------------------------------------------------
//------------------------------------------------------------
#include "gestionversion.h"
#ifdef WINDOWS_VERSION
#include "fenetre.h"
#endif

#pragma hdrstop

#include "magic_application.h"
#include <string.h>
#include "mg_file.h"
#include "fct_taille.h"
#include "mailleur0d.h"
#include "mailleur1d.h"
#include "mailleur2d.h"
#include "mailleur3d.h"
#include "mailleur_adaptatif.h"
#include "fct_generateur_3D.h"
#include "mg_export.h"
#include "step_import.h"
#include "acis_import.h"

//---------------------------------------------------------------------------

int main(int argc,char **argv)
{
std::vector<MAGIC_PARAMETRE_APPLICATION> lst;
MAGIC_PARAMETRE_APPLICATION p1(3,(char*)"-carte",MAGIC_PARAMETRE_APPLICATION::STRING,(char*)"Fichier de carte de taille");
MAGIC_PARAMETRE_APPLICATION p2(4,(char*)"-niveauopt",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Limite supérieure des mailles à optimiser - Défaut 2");
MAGIC_PARAMETRE_APPLICATION p3(5,(char*)"-niveau",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Dimension limite des entités à mailler - Défaut 3");
MAGIC_PARAMETRE_APPLICATION p5(6,(char*)"-front",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Maillage d'une géométrie par la méthode frontale - Defaut");
MAGIC_PARAMETRE_APPLICATION p6(7,(char*)"-adapt",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Maillage adaptatif d'une géométrie maillée");
MAGIC_PARAMETRE_APPLICATION p4(8,(char*)"-prioritemetrique",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Valeur de la prise en compte de la métrique versus la qualité - Défaut 0.65");
MAGIC_PARAMETRE_APPLICATION p7(9,(char*)"-numgeo",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numero de géometrie à mailler - Défaut la première");
MAGIC_PARAMETRE_APPLICATION p8(10,(char*)"-groupe",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Groupe topologique à mailler - Défaut pas de groupe");
MAGIC_PARAMETRE_APPLICATION p9(11,(char*)"-analyse",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Analyse de la qualité du maillage après le maillage");
MAGIC_PARAMETRE_APPLICATION p10(12,(char*)"-visufront",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Activation de la visalisation dynamique du front");
MAGIC_PARAMETRE_APPLICATION p11(13,(char*)"-nummai",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Numéro du maillage à adapter - Défaut le premier");
MAGIC_PARAMETRE_APPLICATION p12(14,(char*)"-limitadapt",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Limite inférieure en %d'erreur pour conserver les mailles");


//MAGIC_PARAMETRE_APPLICATION p7(8,(char*)"-tailleoctree",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char*)"Taille des octants par rapport à la taille souhaitée - Défaut 2.");
//MAGIC_PARAMETRE_APPLICATION p8(9,(char*)"-fem",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Création du maillage fem");
//MAGIC_PARAMETRE_APPLICATION p9(10,(char*)"-degre",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Degre du maillage fem - Défaut 1");
p5.ajouter_dependance(1);p5.ajouter_dependance(2);p5.ajouter_dependance(3);p5.ajouter_dependance(4);p5.ajouter_dependance(5);p5.ajouter_dependance(8);p5.ajouter_dependance(9);p5.ajouter_dependance(10);p5.ajouter_dependance(11);p5.ajouter_dependance(12);
p6.ajouter_dependance(1);p6.ajouter_dependance(2);p6.ajouter_dependance(3);p6.ajouter_dependance(11);p6.ajouter_dependance(12);p6.ajouter_dependance(13);p6.ajouter_dependance(14);
lst.push_back(p1);
lst.push_back(p2);
lst.push_back(p3);
lst.push_back(p5);
lst.push_back(p6);
lst.push_back(p4);
lst.push_back(p7);
lst.push_back(p8);
lst.push_back(p9);
lst.push_back(p10);
lst.push_back(p11);
lst.push_back(p12);

MAGIC_APPLICATION app((char*)"Mailleur d'une géometrie par la méthode frontale",argc,argv,lst,true,true);
if (app.get_erreur()==true) return 0;  
 
if (app.get_action()==-1)  app.change_action(6);
  
 if (app.get_action()==6)
      {
      char fichier[500];
      char fichiersortie[500];
      char fichiercarte[500];
      int numgeometrie;
      double prioritemetrique;
      int numgroupe;
      int niveau;
      bool analyse;
      bool visufront;
      int niveauopt;
      app.recupere_parametre_string(1,fichier,(char*)"Fichier d'entrée manquant");
      app.recupere_parametre_string_avec_defaut(2,fichiersortie,fichier);
      app.recupere_parametre_string(3,fichiercarte,(char*)"Fichier carte manquant");
      app.recupere_parametre_double_avec_defaut(8,prioritemetrique,0.65);
      app.recupere_parametre_int_avec_defaut(9,numgeometrie,0);
      app.recupere_parametre_int_avec_defaut(10,numgroupe,0);
      app.recupere_parametre_int_avec_defaut(5,niveau,3);
      app.recupere_parametre_bool_avec_defaut(11,analyse,false);
      app.recupere_parametre_bool_avec_defaut(12,visufront,false);
      app.recupere_parametre_int_avec_defaut(4,niveauopt,2);
      if (app.get_erreur()==true) return 0; 
      char message[500];
      app.affiche((char*)"Parametre d'etude du mailleur");
      sprintf(message,"   Fichier magic : %s",fichier);
      app.affiche(message);
      sprintf(message,"   Numero de geometrie : %d",numgeometrie);
      sprintf(message,"   Fichier carte : %s",fichiercarte);
      app.affiche(message);
      sprintf(message,"   Parametre de metrique : %2.2f",prioritemetrique*100);
      app.affiche(message);
      app.affiche((char*)"Lecture du fichier M.A.G.i.C");
      MG_FILE gest(fichier);
      MG_GEOMETRIE* mggeo;
      if (numgeometrie==0) mggeo=gest.get_mg_geometrie(numgeometrie); else mggeo=gest.get_mg_geometrieid(numgeometrie);
      MG_MAILLAGE* mgmai=new MG_MAILLAGE(mggeo);
      gest.ajouter_mg_maillage(mgmai);
      FCT_GENERATEUR_3D<4> carte;
      FCT_TAILLE* metrique;
      MAILLEUR2D::priorite_metrique=prioritemetrique;
      MG_GROUPE_TOPOLOGIQUE* mggt=NULL;
      if (numgroupe!=0)
        mggt=mggeo->get_mg_groupe_topologiqueid(numgroupe);
      app.affiche((char*)"Lecture carte de taille");
      carte.lire(fichiercarte);
      metrique=&carte;
     if (niveau>-1)
    {
        app.affiche((char*)"MAILLAGE 0D");
        MAILLEUR0D m0d(mgmai,mggeo);
        m0d.maille(mggt);
    }
    TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> lst;
    if (mggt!=NULL)
    {
        int nb=mggt->get_nb();
        for (int i=0;i<nb;i++)
        {
            lst.ajouter(mggt->get(i));
            mggt->get(i)->get_topologie_sousjacente(&lst);
        }
    }
    if (niveau>0)
    {
        app.affiche((char*)"MAILLAGE 1D");
        int nb=mggeo->get_nb_mg_arete();
        for (int i=0;i<nb;i++)
        {
            MG_ARETE* arete=mggeo->get_mg_arete(i);
            if (mggt!=NULL)
                if (lst.existe(arete)==0) continue;
            char mess[100];
            sprintf(mess,"    arete %d",i);
            app.affiche(mess);
            MAILLEUR1D m1d(mgmai,mggeo,metrique,arete);
            m1d.maille(mggt);
        }
    }
    if (niveau>1)
    {
        app.affiche((char*)"MAILLAGE 2D");
        int nb=mggeo->get_nb_mg_face();
        for (int i=0;i<nb;i++)
        {
            MG_FACE* mgface=mggeo->get_mg_face(i);
            if (mggt!=NULL)
                if (lst.existe(mgface)==0) continue;
            char mess[100];
            sprintf(mess,"    face %d",i);
            app.affiche(mess);
            MAILLEUR2D m2d(mgmai,mggeo,metrique,mgface);
            m2d.maille(mggt);
        }
    }
    if (niveau==3)
    {
        app.affiche((char*)"MAILLAGE 3D");
        int nb=mggeo->get_nb_mg_volume();
        for (int i=0;i<nb;i++)
        {
            MG_VOLUME* mgvol=mggeo->get_mg_volume(i);
            if (mggt!=NULL)
                if (lst.existe(mgvol)==0) continue;
            MAILLEUR3D m3d(mgmai,mggeo,metrique,mgvol);
            m3d.active_affichage(app.affiche);
            m3d.change_niveau_optimisation(niveauopt);
            if (visufront) m3d.active_log(fichiersortie);
            m3d.maille(mgvol);
            if (analyse)
            {
                app.affiche((char*)"Analyse maillage");
                double vol;int tab[4];
                m3d.analyse_maillage_obtenu(vol,tab);
                char mess[100];
                sprintf(mess,"    1) Respect de la carte de taille");
                app.affiche(mess);
                sprintf(mess,"    nombre de tetra theorique %f, nombre de tetra pratique %d ",vol,mgmai->get_nb_mg_tetra());
                app.affiche(mess);
                sprintf(mess,"    erreur : %.2f%%",(mgmai->get_nb_mg_tetra()-vol)*100./vol);
                app.affiche(mess);
                sprintf(mess,"    2) Qualite du maillage");
                app.affiche(mess);
                sprintf(mess,"    nombre de tetra bon (qualite>0.5)        : %d (%.2f%%)",tab[3],tab[3]*100./mgmai->get_nb_mg_tetra());
                app.affiche(mess);
                sprintf(mess,"    nombre de tetra acceptable (qualite>0.2) : %d (%.2f%%) ",tab[2],tab[2]*100./mgmai->get_nb_mg_tetra());
                app.affiche(mess);
                sprintf(mess,"    nombre de tetra moyen (qualite>0.1)      : %d (%.2f%%) ",tab[1],tab[1]*100./mgmai->get_nb_mg_tetra());
                app.affiche(mess);
                sprintf(mess,"    nombre de tetra mauvais (qualite>0.)     : %d (%.2f%%) ",tab[0],tab[0]*100./mgmai->get_nb_mg_tetra());
                app.affiche(mess);
            }
        }
    }
    app.affiche((char*)"Enregistrement");
    gest.enregistrer(fichier);
    app.affiche((char*)"Fin");
        
}
  
 if (app.get_action()==7)
    {
      char fichier[500];
      char fichiersortie[500];
      char fichiercarte[500];
      int nummaillage;
      double prioritemetrique;
      bool analyse;
      bool visufront;
      double limiteadapt;
      app.recupere_parametre_string(1,fichier,(char*)"Fichier d'entrée manquant");
      app.recupere_parametre_string_avec_defaut(2,fichiersortie,fichier);
      app.recupere_parametre_string(3,fichiercarte,(char*)"Fichier carte manquant");
      app.recupere_parametre_double_avec_defaut(8,prioritemetrique,0.65);
      app.recupere_parametre_int_avec_defaut(13,nummaillage,0);
      app.recupere_parametre_bool_avec_defaut(11,analyse,false);
      app.recupere_parametre_bool_avec_defaut(12,visufront,false);
      app.recupere_parametre_double(14,limiteadapt,"Valeur limite d'adaptation manquante");
      if (app.get_erreur()==true) return 0; 
      char message[500];
      app.affiche((char*)"Adaptation de maillage");
      sprintf(message,"   Fichier magic : %s",fichier);
      app.affiche(message);
      printf(message,"   Numero de maillage : %d",nummaillage);
      app.affiche(message);
      sprintf(message,"   Carte : %s",fichiercarte);
      app.affiche(message);
      MG_FILE gest(fichier);
      MG_MAILLAGE* mai;
      if (nummaillage==0) mai=gest.get_mg_maillage(nummaillage); else mai=gest.get_mg_maillageid(nummaillage);
      FCT_GENERATEUR_3D<4> carte;
      FCT_TAILLE* metrique;
      carte.lire(fichiercarte);
      metrique=&carte;
      MG_MAILLAGE* nvmai=new MG_MAILLAGE(mai->get_mg_geometrie());
      gest.ajouter_mg_maillage(nvmai);
      MAILLEUR_ADAPTATIF mesh(mai,nvmai,metrique,limiteadapt);
      mesh.active_affichage(app.affiche);
      if (visufront) mesh.active_log(fichier);
      mesh.maille();
      if (analyse)
        {
            MAILLEUR3D m3d(nvmai,nvmai->get_mg_geometrie(),metrique);
            app.affiche((char*)"Analyse maillage");
            double vol;int tab[4];
            m3d.analyse_maillage_obtenu(vol,tab);
            char mess[100];
            sprintf(mess,"    1) Respect de la carte de taille");
            app.affiche(mess);
            sprintf(mess,"    nombre de tetra theorique %f, nombre de tetra pratique %d ",vol,nvmai->get_nb_mg_tetra());
            app.affiche(mess);
            sprintf(mess,"    erreur : %.2f%%",(nvmai->get_nb_mg_tetra()-vol)*100./vol);
            app.affiche(mess);
            sprintf(mess,"    2) Qualite du maillage");
            app.affiche(mess);
            sprintf(mess,"    nombre de tetra bon (qualite>0.5)        : %d (%.2f%%)",tab[3],tab[3]*100./nvmai->get_nb_mg_tetra());
            app.affiche(mess);
            sprintf(mess,"    nombre de tetra acceptable (qualite>0.2) : %d (%.2f%%) ",tab[2],tab[2]*100./nvmai->get_nb_mg_tetra());
            app.affiche(mess);
            sprintf(mess,"    nombre de tetra moyen (qualite>0.1)      : %d (%.2f%%) ",tab[1],tab[1]*100./nvmai->get_nb_mg_tetra());
            app.affiche(mess);
            sprintf(mess,"    nombre de tetra mauvais (qualite>0.)     : %d (%.2f%%) ",tab[0],tab[0]*100./nvmai->get_nb_mg_tetra());
            app.affiche(mess);
            }
        app.affiche((char*)"Enregistrement");
        gest.enregistrer(fichiersortie);
        app.affiche((char*)"Fin");
   }
  
  
 /* 
    char fichier[1000],fichier2[1000],fichiercarte[1000];
    int typecarte,niveau=3,numgeometrie=0,adapt=0,nummaillage=0;
    int exportgmsh=0;
    int visufront=0;
    int analyse=0;
    int diff=0;
    int niveauopt=2;
    int octal=0;
    int verif=0;
    double coef=2.;
    double eps,dg,prioritemetrique=0.65;
    double limiteadapt=0.25;
    int numgroupe=0;
    int numgeo;
    int fem=0;
    int degre=1;
    bool versioncompilee=false;
    for (int i=0;i<argc;i++)
    {
        if (strcmp(argv[i],"-magic")==0)        strcpy(fichier,argv[i+1]);
        if (strcmp(argv[i],"-typecarte")==0)    typecarte=atoi(argv[i+1]);
        if (strcmp(argv[i],"-carte")==0)        strcpy(fichiercarte,argv[i+1]);
        if (strcmp(argv[i],"-eng")==0)          dg=atof(argv[i+1]);
        if (strcmp(argv[i],"-eps")==0)          eps=atof(argv[i+1]);
        if (strcmp(argv[i],"-niveau")==0)       niveau=atoi(argv[i+1]);
        if (strcmp(argv[i],"-prioritemetrique")==0) prioritemetrique=atof(argv[i+1]);
        if (strcmp(argv[i],"-numgeo")==0)       numgeometrie=atoi(argv[i+1]);
        if (strcmp(argv[i],"-adapt")==0)       adapt=1;
        if (strcmp(argv[i],"-nummai")==0)       nummaillage=atoi(argv[i+1]);
        if (strcmp(argv[i],"-exportgmsh")==0)       exportgmsh=1;
        if (strcmp(argv[i],"-visufront")==0)       visufront=1;
        if (strcmp(argv[i],"-analyse")==0)       analyse=1;
        if (strcmp(argv[i],"-out")==0)       {
            strcpy(fichier2,argv[i+1]);
            diff=1;
        }
        if (strcmp(argv[i],"-niveauopt")==0)       {
            niveauopt=atoi(argv[i+1]);
        }
        if (strcmp(argv[i],"-limitadapt")==0)       {
            limiteadapt=atof(argv[i+1]);
        }
        if (strcmp(argv[i],"-octal")==0)       octal=1;
        if (strcmp(argv[i],"-verif")==0)       verif=1;
        if (strcmp(argv[i],"-coef")==0)       coef=atof(argv[i+1]);
        if (strcmp(argv[i],"-groupe")==0) numgroupe=atoi(argv[i+1]);
        if (strcmp(argv[i],"-geo")==0) numgeo=atoi(argv[i+1]);
        if (strcmp(argv[i],"-fem")==0) fem=1;
        if (strcmp(argv[i],"-degre")==0) degre=atoi(argv[i+1]);
        if (strcmp(argv[i],"-version")==0) versioncompilee=true;
    }
    affiche((char*)"Mailleur MAGiC");
        if (versioncompilee)
          {
          GESTIONVERSION v;
          char version[500];
          v.print(version);
          affiche(version);
          }
    char message[500];
    char nomtypecarte[9][9]={"Standard","Fichier"};
    if (adapt)
    {
        affiche((char*)"Adaptation de maillage");
        sprintf(message,"   Fichier magic : %s",fichier);
        affiche(message);
        sprintf(message,"   Numero de maillage : %d",nummaillage);
        affiche(message);
        sprintf(message,"   Carte : %s",fichiercarte);
        affiche(message);
        MG_FILE gest(fichier);
        MG_MAILLAGE* mai=gest.get_mg_maillageid(nummaillage);
        FCT_GENERATEUR_3D<4> carte;
        FCT_TAILLE* metrique;
        carte.lire(fichiercarte);
        metrique=&carte;
        if (diff) strcpy(fichier,fichier2);
        MG_MAILLAGE* nvmai=new MG_MAILLAGE(mai->get_mg_geometrie());
        gest.ajouter_mg_maillage(nvmai);
        MAILLEUR_ADAPTATIF mesh(mai,nvmai,metrique,limiteadapt);
        mesh.active_affichage(affiche);
        if (visufront) mesh.active_log(fichier);
        mesh.maille();
        if (analyse)
        {
            MAILLEUR3D m3d(nvmai,nvmai->get_mg_geometrie(),NULL,metrique);
            affiche((char*)"Analyse maillage");
            double vol;int tab[4];
            m3d.analyse_maillage_obtenu(vol,tab);
            char mess[100];
             sprintf(mess,"    1) Respect de la carte de taille");
             affiche(mess);
                sprintf(mess,"    nombre de tetra theorique %f, nombre de tetra pratique %d ",vol,nvmai->get_nb_mg_tetra());
                affiche(mess);
                sprintf(mess,"    erreur : %.2f%%",(nvmai->get_nb_mg_tetra()-vol)*100./vol);
                affiche(mess);
                sprintf(mess,"    2) Qualite du maillage");
                affiche(mess);
                sprintf(mess,"    nombre de tetra bon (qualite>0.5)        : %d (%.2f%%)",tab[3],tab[3]*100./nvmai->get_nb_mg_tetra());
                affiche(mess);
                sprintf(mess,"    nombre de tetra acceptable (qualite>0.2) : %d (%.2f%%) ",tab[2],tab[2]*100./nvmai->get_nb_mg_tetra());
                affiche(mess);
                sprintf(mess,"    nombre de tetra moyen (qualite>0.1)      : %d (%.2f%%) ",tab[1],tab[1]*100./nvmai->get_nb_mg_tetra());
                affiche(mess);
                sprintf(mess,"    nombre de tetra mauvais (qualite>0.)     : %d (%.2f%%) ",tab[0],tab[0]*100./nvmai->get_nb_mg_tetra());
                affiche(mess);
            }
        affiche((char*)"Enregistrement");
        //strcat(fichier,".magic");
        gest.enregistrer(fichier);
        if (exportgmsh)
        {
            affiche((char*)"Exportation GMSH");
            MG_EXPORT exp;
            exp.gmsh(mai,fichier);
        }
        affiche((char*)"Fin");
        return 1;
    }
    if (octal)
    {
        sprintf(message,"   Fichier magic : %s",fichier);
        affiche(message);
        sprintf(message,"   Type de carte : %s",nomtypecarte[1]);
        affiche(message);
        sprintf(message,"   Fichier carte : %s",fichiercarte);
        affiche(message);
        affiche((char*)"Lecture carte de taille");
        FCT_GENERATEUR_3D<4> carte;
        carte.lire(fichiercarte);
        affiche((char*)"Maillage");
        MG_GESTIONNAIRE* gest;
        MG_FILE* file=new MG_FILE(fichier);
        if (file->get_code_de_lecture()==0)
        {
            delete file;
            MG_GESTIONNAIRE* gest2=new MG_GESTIONNAIRE;
            gest=gest2;
        }
        else gest=file;
        MG_MAILLAGE* mgmai=new MG_MAILLAGE(NULL);
        gest->ajouter_mg_maillage(mgmai);
        MAILLEUR3D mailleur(&carte,mgmai);
        mailleur.change_coef(coef);
        mailleur.maille();
        if (verif)
        {
            affiche((char*)"Verification");
            MG_MAILLAGE* mgmai2=new MG_MAILLAGE(NULL);
            gest->ajouter_mg_maillage(mgmai2);
            mailleur.verifie_conformite_octale(mgmai,mgmai2);
        }
        if (fem)
        {
            affiche((char*)"Maillage FEM");
            FEM_MAILLAGE* femmai=new FEM_MAILLAGE(mgmai->get_mg_geometrie(),mgmai,degre);
            gest->ajouter_fem_maillage(femmai);
            femmai->construire(0);
        }
        affiche((char*)"Enregistrement");
        gest->enregistrer(fichier);
        if (exportgmsh)
        {
            affiche((char*)"Exportation GMSH");
            MG_EXPORT exp;
            if (fem)
            {
                affiche((char*)"Maillage FEM");
                FEM_MAILLAGE* femmai=new FEM_MAILLAGE(mgmai->get_mg_geometrie(),mgmai,degre);
                gest->ajouter_fem_maillage(femmai);
                femmai->construire(0);
            }      exp.gmsh(mgmai,fichier);
        }
        delete gest;
        affiche((char*)"Fin");
        return 1;
    }*/
    return 0;
}


#pragma package(smart_init)
Revision:	446
Committed:	Fri Oct 25 19:30:16 2013 UTC (11 years, 7 months ago) by francois
File size:	20168 byte(s)
Log Message:	suppression de la vieille compatibilité avec la these de VF sur la carte de taille. Maintenant la carte de taille est a priori obligatoirement
#	User	Rev	Content
1	francois	283	//------------------------------------------------------------
2			//------------------------------------------------------------
3			// MAGiC
4			// Jean Christophe Cuilli�e et Vincent FRANCOIS
5			// D�artement de G�ie M�anique - UQTR
6			//------------------------------------------------------------
7			// Le projet MAGIC est un projet de recherche du d�artement
8			// de g�ie m�anique de l'Universit�du Qu�ec �
9			// Trois Rivi�es
10			// Les librairies ne peuvent �re utilis�s sans l'accord
11			// des auteurs (contact : francois@uqtr.ca)
12			//------------------------------------------------------------
13			//------------------------------------------------------------
14			//
15			// main.cpp
16			//
17			//------------------------------------------------------------
18			//------------------------------------------------------------
19			// COPYRIGHT 2000
20			// Version du 02/03/2006 �11H25
21			//------------------------------------------------------------
22			//------------------------------------------------------------
23			#include "gestionversion.h"
24			#ifdef WINDOWS_VERSION
25			#include "fenetre.h"
26			#endif
27
28			#pragma hdrstop
29
30	francois	432	#include "magic_application.h"
31	francois	283	#include <string.h>
32			#include "mg_file.h"
33			#include "fct_taille.h"
34			#include "mailleur0d.h"
35			#include "mailleur1d.h"
36			#include "mailleur2d.h"
37			#include "mailleur3d.h"
38			#include "mailleur_adaptatif.h"
39			#include "fct_generateur_3D.h"
40			#include "mg_export.h"
41			#include "step_import.h"
42			#include "acis_import.h"
43
44			//---------------------------------------------------------------------------
45
46	francois	432	int main(int argc,char **argv)
47	francois	283	{
48	francois	432	std::vector<MAGIC_PARAMETRE_APPLICATION> lst;
49			MAGIC_PARAMETRE_APPLICATION p1(3,(char)"-carte",MAGIC_PARAMETRE_APPLICATION::STRING,(char)"Fichier de carte de taille");
50			MAGIC_PARAMETRE_APPLICATION p2(4,(char)"-niveauopt",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Limite supérieure des mailles à optimiser - Défaut 2");
51			MAGIC_PARAMETRE_APPLICATION p3(5,(char)"-niveau",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Dimension limite des entités à mailler - Défaut 3");
52			MAGIC_PARAMETRE_APPLICATION p5(6,(char)"-front",MAGIC_PARAMETRE_APPLICATION::ACTION,(char)"Maillage d'une géométrie par la méthode frontale - Defaut");
53			MAGIC_PARAMETRE_APPLICATION p6(7,(char)"-adapt",MAGIC_PARAMETRE_APPLICATION::ACTION,(char)"Maillage adaptatif d'une géométrie maillée");
54			MAGIC_PARAMETRE_APPLICATION p4(8,(char)"-prioritemetrique",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char)"Valeur de la prise en compte de la métrique versus la qualité - Défaut 0.65");
55			MAGIC_PARAMETRE_APPLICATION p7(9,(char)"-numgeo",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Numero de géometrie à mailler - Défaut la première");
56			MAGIC_PARAMETRE_APPLICATION p8(10,(char)"-groupe",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Groupe topologique à mailler - Défaut pas de groupe");
57			MAGIC_PARAMETRE_APPLICATION p9(11,(char)"-analyse",MAGIC_PARAMETRE_APPLICATION::BOOL,(char)"Analyse de la qualité du maillage après le maillage");
58			MAGIC_PARAMETRE_APPLICATION p10(12,(char)"-visufront",MAGIC_PARAMETRE_APPLICATION::BOOL,(char)"Activation de la visalisation dynamique du front");
59			MAGIC_PARAMETRE_APPLICATION p11(13,(char)"-nummai",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Numéro du maillage à adapter - Défaut le premier");
60			MAGIC_PARAMETRE_APPLICATION p12(14,(char)"-limitadapt",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char)"Limite inférieure en %d'erreur pour conserver les mailles");
61	francois	283
62
63
64	francois	432
65			//MAGIC_PARAMETRE_APPLICATION p7(8,(char)"-tailleoctree",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char)"Taille des octants par rapport à la taille souhaitée - Défaut 2.");
66			//MAGIC_PARAMETRE_APPLICATION p8(9,(char)"-fem",MAGIC_PARAMETRE_APPLICATION::BOOL,(char)"Création du maillage fem");
67			//MAGIC_PARAMETRE_APPLICATION p9(10,(char)"-degre",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Degre du maillage fem - Défaut 1");
68			p5.ajouter_dependance(1);p5.ajouter_dependance(2);p5.ajouter_dependance(3);p5.ajouter_dependance(4);p5.ajouter_dependance(5);p5.ajouter_dependance(8);p5.ajouter_dependance(9);p5.ajouter_dependance(10);p5.ajouter_dependance(11);p5.ajouter_dependance(12);
69			p6.ajouter_dependance(1);p6.ajouter_dependance(2);p6.ajouter_dependance(3);p6.ajouter_dependance(11);p6.ajouter_dependance(12);p6.ajouter_dependance(13);p6.ajouter_dependance(14);
70			lst.push_back(p1);
71			lst.push_back(p2);
72			lst.push_back(p3);
73			lst.push_back(p5);
74			lst.push_back(p6);
75			lst.push_back(p4);
76			lst.push_back(p7);
77			lst.push_back(p8);
78			lst.push_back(p9);
79			lst.push_back(p10);
80			lst.push_back(p11);
81			lst.push_back(p12);
82
83			MAGIC_APPLICATION app((char*)"Mailleur d'une géometrie par la méthode frontale",argc,argv,lst,true,true);
84			if (app.get_erreur()==true) return 0;
85
86			if (app.get_action()==-1) app.change_action(6);
87
88			if (app.get_action()==6)
89			{
90			char fichier[500];
91			char fichiersortie[500];
92			char fichiercarte[500];
93			int numgeometrie;
94			double prioritemetrique;
95			int numgroupe;
96			int niveau;
97			bool analyse;
98			bool visufront;
99			int niveauopt;
100			app.recupere_parametre_string(1,fichier,(char*)"Fichier d'entrée manquant");
101			app.recupere_parametre_string_avec_defaut(2,fichiersortie,fichier);
102			app.recupere_parametre_string(3,fichiercarte,(char*)"Fichier carte manquant");
103			app.recupere_parametre_double_avec_defaut(8,prioritemetrique,0.65);
104			app.recupere_parametre_int_avec_defaut(9,numgeometrie,0);
105			app.recupere_parametre_int_avec_defaut(10,numgroupe,0);
106			app.recupere_parametre_int_avec_defaut(5,niveau,3);
107			app.recupere_parametre_bool_avec_defaut(11,analyse,false);
108			app.recupere_parametre_bool_avec_defaut(12,visufront,false);
109			app.recupere_parametre_int_avec_defaut(4,niveauopt,2);
110			if (app.get_erreur()==true) return 0;
111			char message[500];
112			app.affiche((char*)"Parametre d'etude du mailleur");
113			sprintf(message," Fichier magic : %s",fichier);
114			app.affiche(message);
115			sprintf(message," Numero de geometrie : %d",numgeometrie);
116			sprintf(message," Fichier carte : %s",fichiercarte);
117			app.affiche(message);
118			sprintf(message," Parametre de metrique : %2.2f",prioritemetrique*100);
119			app.affiche(message);
120			app.affiche((char*)"Lecture du fichier M.A.G.i.C");
121			MG_FILE gest(fichier);
122			MG_GEOMETRIE* mggeo;
123			if (numgeometrie==0) mggeo=gest.get_mg_geometrie(numgeometrie); else mggeo=gest.get_mg_geometrieid(numgeometrie);
124			MG_MAILLAGE* mgmai=new MG_MAILLAGE(mggeo);
125			gest.ajouter_mg_maillage(mgmai);
126			FCT_GENERATEUR_3D<4> carte;
127			FCT_TAILLE* metrique;
128			MAILLEUR2D::priorite_metrique=prioritemetrique;
129			MG_GROUPE_TOPOLOGIQUE* mggt=NULL;
130			if (numgroupe!=0)
131			mggt=mggeo->get_mg_groupe_topologiqueid(numgroupe);
132			app.affiche((char*)"Lecture carte de taille");
133			carte.lire(fichiercarte);
134			metrique=&carte;
135			if (niveau>-1)
136	francois	283	{
137	francois	432	app.affiche((char*)"MAILLAGE 0D");
138			MAILLEUR0D m0d(mgmai,mggeo);
139			m0d.maille(mggt);
140	francois	283	}
141	francois	432	TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> lst;
142			if (mggt!=NULL)
143			{
144			int nb=mggt->get_nb();
145			for (int i=0;i<nb;i++)
146			{
147			lst.ajouter(mggt->get(i));
148			mggt->get(i)->get_topologie_sousjacente(&lst);
149			}
150			}
151			if (niveau>0)
152			{
153			app.affiche((char*)"MAILLAGE 1D");
154			int nb=mggeo->get_nb_mg_arete();
155			for (int i=0;i<nb;i++)
156			{
157			MG_ARETE* arete=mggeo->get_mg_arete(i);
158			if (mggt!=NULL)
159			if (lst.existe(arete)==0) continue;
160			char mess[100];
161			sprintf(mess," arete %d",i);
162			app.affiche(mess);
163	francois	446	MAILLEUR1D m1d(mgmai,mggeo,metrique,arete);
164	francois	432	m1d.maille(mggt);
165			}
166			}
167			if (niveau>1)
168			{
169			app.affiche((char*)"MAILLAGE 2D");
170			int nb=mggeo->get_nb_mg_face();
171			for (int i=0;i<nb;i++)
172			{
173			MG_FACE* mgface=mggeo->get_mg_face(i);
174			if (mggt!=NULL)
175			if (lst.existe(mgface)==0) continue;
176			char mess[100];
177			sprintf(mess," face %d",i);
178			app.affiche(mess);
179	francois	446	MAILLEUR2D m2d(mgmai,mggeo,metrique,mgface);
180	francois	432	m2d.maille(mggt);
181			}
182			}
183			if (niveau==3)
184			{
185			app.affiche((char*)"MAILLAGE 3D");
186			int nb=mggeo->get_nb_mg_volume();
187			for (int i=0;i<nb;i++)
188			{
189			MG_VOLUME* mgvol=mggeo->get_mg_volume(i);
190			if (mggt!=NULL)
191			if (lst.existe(mgvol)==0) continue;
192	francois	446	MAILLEUR3D m3d(mgmai,mggeo,metrique,mgvol);
193	francois	432	m3d.active_affichage(app.affiche);
194			m3d.change_niveau_optimisation(niveauopt);
195			if (visufront) m3d.active_log(fichiersortie);
196			m3d.maille(mgvol);
197			if (analyse)
198			{
199			app.affiche((char*)"Analyse maillage");
200			double vol;int tab[4];
201			m3d.analyse_maillage_obtenu(vol,tab);
202			char mess[100];
203			sprintf(mess," 1) Respect de la carte de taille");
204			app.affiche(mess);
205			sprintf(mess," nombre de tetra theorique %f, nombre de tetra pratique %d ",vol,mgmai->get_nb_mg_tetra());
206			app.affiche(mess);
207			sprintf(mess," erreur : %.2f%%",(mgmai->get_nb_mg_tetra()-vol)*100./vol);
208			app.affiche(mess);
209			sprintf(mess," 2) Qualite du maillage");
210			app.affiche(mess);
211			sprintf(mess," nombre de tetra bon (qualite>0.5) : %d (%.2f%%)",tab[3],tab[3]*100./mgmai->get_nb_mg_tetra());
212			app.affiche(mess);
213			sprintf(mess," nombre de tetra acceptable (qualite>0.2) : %d (%.2f%%) ",tab[2],tab[2]*100./mgmai->get_nb_mg_tetra());
214			app.affiche(mess);
215			sprintf(mess," nombre de tetra moyen (qualite>0.1) : %d (%.2f%%) ",tab[1],tab[1]*100./mgmai->get_nb_mg_tetra());
216			app.affiche(mess);
217			sprintf(mess," nombre de tetra mauvais (qualite>0.) : %d (%.2f%%) ",tab[0],tab[0]*100./mgmai->get_nb_mg_tetra());
218			app.affiche(mess);
219			}
220			}
221			}
222			app.affiche((char*)"Enregistrement");
223			gest.enregistrer(fichier);
224			app.affiche((char*)"Fin");
225
226			}
227
228			if (app.get_action()==7)
229			{
230			char fichier[500];
231			char fichiersortie[500];
232			char fichiercarte[500];
233			int nummaillage;
234			double prioritemetrique;
235			bool analyse;
236			bool visufront;
237			double limiteadapt;
238			app.recupere_parametre_string(1,fichier,(char*)"Fichier d'entrée manquant");
239			app.recupere_parametre_string_avec_defaut(2,fichiersortie,fichier);
240			app.recupere_parametre_string(3,fichiercarte,(char*)"Fichier carte manquant");
241			app.recupere_parametre_double_avec_defaut(8,prioritemetrique,0.65);
242			app.recupere_parametre_int_avec_defaut(13,nummaillage,0);
243			app.recupere_parametre_bool_avec_defaut(11,analyse,false);
244			app.recupere_parametre_bool_avec_defaut(12,visufront,false);
245			app.recupere_parametre_double(14,limiteadapt,"Valeur limite d'adaptation manquante");
246			if (app.get_erreur()==true) return 0;
247			char message[500];
248			app.affiche((char*)"Adaptation de maillage");
249			sprintf(message," Fichier magic : %s",fichier);
250			app.affiche(message);
251			printf(message," Numero de maillage : %d",nummaillage);
252			app.affiche(message);
253			sprintf(message," Carte : %s",fichiercarte);
254			app.affiche(message);
255			MG_FILE gest(fichier);
256			MG_MAILLAGE* mai;
257			if (nummaillage==0) mai=gest.get_mg_maillage(nummaillage); else mai=gest.get_mg_maillageid(nummaillage);
258			FCT_GENERATEUR_3D<4> carte;
259			FCT_TAILLE* metrique;
260			carte.lire(fichiercarte);
261			metrique=&carte;
262			MG_MAILLAGE* nvmai=new MG_MAILLAGE(mai->get_mg_geometrie());
263			gest.ajouter_mg_maillage(nvmai);
264			MAILLEUR_ADAPTATIF mesh(mai,nvmai,metrique,limiteadapt);
265			mesh.active_affichage(app.affiche);
266			if (visufront) mesh.active_log(fichier);
267			mesh.maille();
268			if (analyse)
269			{
270	francois	446	MAILLEUR3D m3d(nvmai,nvmai->get_mg_geometrie(),metrique);
271	francois	432	app.affiche((char*)"Analyse maillage");
272			double vol;int tab[4];
273			m3d.analyse_maillage_obtenu(vol,tab);
274			char mess[100];
275			sprintf(mess," 1) Respect de la carte de taille");
276			app.affiche(mess);
277			sprintf(mess," nombre de tetra theorique %f, nombre de tetra pratique %d ",vol,nvmai->get_nb_mg_tetra());
278			app.affiche(mess);
279			sprintf(mess," erreur : %.2f%%",(nvmai->get_nb_mg_tetra()-vol)*100./vol);
280			app.affiche(mess);
281			sprintf(mess," 2) Qualite du maillage");
282			app.affiche(mess);
283			sprintf(mess," nombre de tetra bon (qualite>0.5) : %d (%.2f%%)",tab[3],tab[3]*100./nvmai->get_nb_mg_tetra());
284			app.affiche(mess);
285			sprintf(mess," nombre de tetra acceptable (qualite>0.2) : %d (%.2f%%) ",tab[2],tab[2]*100./nvmai->get_nb_mg_tetra());
286			app.affiche(mess);
287			sprintf(mess," nombre de tetra moyen (qualite>0.1) : %d (%.2f%%) ",tab[1],tab[1]*100./nvmai->get_nb_mg_tetra());
288			app.affiche(mess);
289			sprintf(mess," nombre de tetra mauvais (qualite>0.) : %d (%.2f%%) ",tab[0],tab[0]*100./nvmai->get_nb_mg_tetra());
290			app.affiche(mess);
291			}
292			app.affiche((char*)"Enregistrement");
293			gest.enregistrer(fichiersortie);
294			app.affiche((char*)"Fin");
295			}
296
297
298
299			/*
300	francois	283	char fichier[1000],fichier2[1000],fichiercarte[1000];
301			int typecarte,niveau=3,numgeometrie=0,adapt=0,nummaillage=0;
302			int exportgmsh=0;
303			int visufront=0;
304			int analyse=0;
305			int diff=0;
306			int niveauopt=2;
307			int octal=0;
308			int verif=0;
309			double coef=2.;
310			double eps,dg,prioritemetrique=0.65;
311			double limiteadapt=0.25;
312			int numgroupe=0;
313			int numgeo;
314			int fem=0;
315			int degre=1;
316	francois	375	bool versioncompilee=false;
317	francois	283	for (int i=0;i<argc;i++)
318			{
319			if (strcmp(argv[i],"-magic")==0) strcpy(fichier,argv[i+1]);
320			if (strcmp(argv[i],"-typecarte")==0) typecarte=atoi(argv[i+1]);
321			if (strcmp(argv[i],"-carte")==0) strcpy(fichiercarte,argv[i+1]);
322			if (strcmp(argv[i],"-eng")==0) dg=atof(argv[i+1]);
323			if (strcmp(argv[i],"-eps")==0) eps=atof(argv[i+1]);
324			if (strcmp(argv[i],"-niveau")==0) niveau=atoi(argv[i+1]);
325			if (strcmp(argv[i],"-prioritemetrique")==0) prioritemetrique=atof(argv[i+1]);
326			if (strcmp(argv[i],"-numgeo")==0) numgeometrie=atoi(argv[i+1]);
327			if (strcmp(argv[i],"-adapt")==0) adapt=1;
328			if (strcmp(argv[i],"-nummai")==0) nummaillage=atoi(argv[i+1]);
329			if (strcmp(argv[i],"-exportgmsh")==0) exportgmsh=1;
330			if (strcmp(argv[i],"-visufront")==0) visufront=1;
331			if (strcmp(argv[i],"-analyse")==0) analyse=1;
332			if (strcmp(argv[i],"-out")==0) {
333			strcpy(fichier2,argv[i+1]);
334			diff=1;
335			}
336			if (strcmp(argv[i],"-niveauopt")==0) {
337			niveauopt=atoi(argv[i+1]);
338			}
339			if (strcmp(argv[i],"-limitadapt")==0) {
340			limiteadapt=atof(argv[i+1]);
341			}
342			if (strcmp(argv[i],"-octal")==0) octal=1;
343			if (strcmp(argv[i],"-verif")==0) verif=1;
344			if (strcmp(argv[i],"-coef")==0) coef=atof(argv[i+1]);
345			if (strcmp(argv[i],"-groupe")==0) numgroupe=atoi(argv[i+1]);
346			if (strcmp(argv[i],"-geo")==0) numgeo=atoi(argv[i+1]);
347			if (strcmp(argv[i],"-fem")==0) fem=1;
348			if (strcmp(argv[i],"-degre")==0) degre=atoi(argv[i+1]);
349	francois	375	if (strcmp(argv[i],"-version")==0) versioncompilee=true;
350	francois	283	}
351	francois	375	affiche((char*)"Mailleur MAGiC");
352			if (versioncompilee)
353			{
354			GESTIONVERSION v;
355			char version[500];
356			v.print(version);
357			affiche(version);
358			}
359	francois	283	char message[500];
360			char nomtypecarte[9][9]={"Standard","Fichier"};
361			if (adapt)
362			{
363			affiche((char*)"Adaptation de maillage");
364			sprintf(message," Fichier magic : %s",fichier);
365			affiche(message);
366			sprintf(message," Numero de maillage : %d",nummaillage);
367			affiche(message);
368			sprintf(message," Carte : %s",fichiercarte);
369			affiche(message);
370			MG_FILE gest(fichier);
371			MG_MAILLAGE* mai=gest.get_mg_maillageid(nummaillage);
372			FCT_GENERATEUR_3D<4> carte;
373			FCT_TAILLE* metrique;
374			carte.lire(fichiercarte);
375			metrique=&carte;
376			if (diff) strcpy(fichier,fichier2);
377			MG_MAILLAGE* nvmai=new MG_MAILLAGE(mai->get_mg_geometrie());
378			gest.ajouter_mg_maillage(nvmai);
379			MAILLEUR_ADAPTATIF mesh(mai,nvmai,metrique,limiteadapt);
380			mesh.active_affichage(affiche);
381			if (visufront) mesh.active_log(fichier);
382			mesh.maille();
383			if (analyse)
384			{
385			MAILLEUR3D m3d(nvmai,nvmai->get_mg_geometrie(),NULL,metrique);
386			affiche((char*)"Analyse maillage");
387	francois	424	double vol;int tab[4];
388			m3d.analyse_maillage_obtenu(vol,tab);
389	francois	283	char mess[100];
390	francois	424	sprintf(mess," 1) Respect de la carte de taille");
391			affiche(mess);
392			sprintf(mess," nombre de tetra theorique %f, nombre de tetra pratique %d ",vol,nvmai->get_nb_mg_tetra());
393			affiche(mess);
394			sprintf(mess," erreur : %.2f%%",(nvmai->get_nb_mg_tetra()-vol)*100./vol);
395			affiche(mess);
396			sprintf(mess," 2) Qualite du maillage");
397			affiche(mess);
398			sprintf(mess," nombre de tetra bon (qualite>0.5) : %d (%.2f%%)",tab[3],tab[3]*100./nvmai->get_nb_mg_tetra());
399			affiche(mess);
400			sprintf(mess," nombre de tetra acceptable (qualite>0.2) : %d (%.2f%%) ",tab[2],tab[2]*100./nvmai->get_nb_mg_tetra());
401			affiche(mess);
402			sprintf(mess," nombre de tetra moyen (qualite>0.1) : %d (%.2f%%) ",tab[1],tab[1]*100./nvmai->get_nb_mg_tetra());
403			affiche(mess);
404			sprintf(mess," nombre de tetra mauvais (qualite>0.) : %d (%.2f%%) ",tab[0],tab[0]*100./nvmai->get_nb_mg_tetra());
405			affiche(mess);
406			}
407	francois	283	affiche((char*)"Enregistrement");
408			//strcat(fichier,".magic");
409			gest.enregistrer(fichier);
410			if (exportgmsh)
411			{
412			affiche((char*)"Exportation GMSH");
413			MG_EXPORT exp;
414			exp.gmsh(mai,fichier);
415			}
416			affiche((char*)"Fin");
417			return 1;
418			}
419			if (octal)
420			{
421			sprintf(message," Fichier magic : %s",fichier);
422			affiche(message);
423			sprintf(message," Type de carte : %s",nomtypecarte[1]);
424			affiche(message);
425			sprintf(message," Fichier carte : %s",fichiercarte);
426			affiche(message);
427			affiche((char*)"Lecture carte de taille");
428			FCT_GENERATEUR_3D<4> carte;
429			carte.lire(fichiercarte);
430			affiche((char*)"Maillage");
431			MG_GESTIONNAIRE* gest;
432			MG_FILE* file=new MG_FILE(fichier);
433			if (file->get_code_de_lecture()==0)
434			{
435			delete file;
436			MG_GESTIONNAIRE* gest2=new MG_GESTIONNAIRE;
437			gest=gest2;
438			}
439			else gest=file;
440			MG_MAILLAGE* mgmai=new MG_MAILLAGE(NULL);
441			gest->ajouter_mg_maillage(mgmai);
442			MAILLEUR3D mailleur(&carte,mgmai);
443			mailleur.change_coef(coef);
444			mailleur.maille();
445			if (verif)
446			{
447			affiche((char*)"Verification");
448			MG_MAILLAGE* mgmai2=new MG_MAILLAGE(NULL);
449			gest->ajouter_mg_maillage(mgmai2);
450			mailleur.verifie_conformite_octale(mgmai,mgmai2);
451			}
452			if (fem)
453			{
454			affiche((char*)"Maillage FEM");
455			FEM_MAILLAGE* femmai=new FEM_MAILLAGE(mgmai->get_mg_geometrie(),mgmai,degre);
456			gest->ajouter_fem_maillage(femmai);
457			femmai->construire(0);
458			}
459			affiche((char*)"Enregistrement");
460			gest->enregistrer(fichier);
461			if (exportgmsh)
462			{
463			affiche((char*)"Exportation GMSH");
464			MG_EXPORT exp;
465			if (fem)
466			{
467			affiche((char*)"Maillage FEM");
468			FEM_MAILLAGE* femmai=new FEM_MAILLAGE(mgmai->get_mg_geometrie(),mgmai,degre);
469			gest->ajouter_fem_maillage(femmai);
470			femmai->construire(0);
471			} exp.gmsh(mgmai,fichier);
472			}
473			delete gest;
474			affiche((char*)"Fin");
475			return 1;
476	francois	432	}*/
477	francois	283	return 0;
478			}
479
480
481
482			#pragma package(smart_init)