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 "fct_taille_fem_solution.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*)"-niveauopt3d",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 p13(15,(char*)"-niveauopt2d",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Limite supérieure des mailles à optimiser - Défaut 5");
MAGIC_PARAMETRE_APPLICATION p14(16,(char*)"-front2",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Maillage d'une géométrie par la méthode frontale avec une carte de taille sous forme de fichier magic");
MAGIC_PARAMETRE_APPLICATION p15(17,(char*)"-adapt2",MAGIC_PARAMETRE_APPLICATION::ACTION,(char*)"Maillage adaptatif d'une géométrie maillée avec une carte de taille sous forme de fichier magic");


//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);p5.ajouter_dependance(15);
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);
p14.ajouter_dependance(1);p14.ajouter_dependance(2);p14.ajouter_dependance(3);p14.ajouter_dependance(4);p14.ajouter_dependance(5);p14.ajouter_dependance(8);p14.ajouter_dependance(9);p14.ajouter_dependance(10);p14.ajouter_dependance(11);p14.ajouter_dependance(12);p14.ajouter_dependance(15);
p15.ajouter_dependance(1);p15.ajouter_dependance(2);p15.ajouter_dependance(3);p15.ajouter_dependance(11);p15.ajouter_dependance(12);p15.ajouter_dependance(13);p15.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);
lst.push_back(p13);
lst.push_back(p14);
lst.push_back(p15);

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) || (app.get_action()==16))
      {
      char fichier[500];
      char fichiersortie[500];
      char fichiercarte[500];
      int numgeometrie;
      double prioritemetrique;
      int numgroupe;
      int niveau;
      bool analyse;
      bool visufront;
      int niveauopt3d;
      int niveauopt2d;
      int numsol,numchamp;
      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,niveauopt3d,2);
      app.recupere_parametre_int_avec_defaut(15,niveauopt2d,5);
      if (app.get_action()==16)
        {
        app.recupere_parametre_int_avec_defaut(18,numsol,0);
        app.recupere_parametre_int_avec_defaut(19,numchamp,0);
        }
      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);
      app.affiche((char*)"Lecture carte de taille");
      FCT_TAILLE* metrique;
      if (app.get_action()==6)
          {
          FCT_GENERATEUR_3D<4> *carte=new FCT_GENERATEUR_3D<4>;
          carte->lire(fichiercarte);
          metrique=carte;
          }
      MG_FILE *gestcarte;
      if (app.get_action()==16)
          {
          FCT_TAILLE_FEM_SOLUTION *carte=new FCT_TAILLE_FEM_SOLUTION(fichiercarte);
          metrique=carte;
          }
      MAILLEUR2D::priorite_metrique=prioritemetrique;
      MG_GROUPE_TOPOLOGIQUE* mggt=NULL;
      if (numgroupe!=0)
        mggt=mggeo->get_mg_groupe_topologiqueid(numgroupe);
     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.change_niveau_optimisation(niveauopt2d);
            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(niveauopt3d);
            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(fichiersortie);
    if (app.get_action()==6)
          delete metrique;
     if (app.get_action()==16)
        {
       delete metrique;
       delete gestcarte;
        }
    app.affiche((char*)"Fin");
        
}
  
 if ((app.get_action()==7)||(app.get_action()==17))
    {
      char fichier[500];
      char fichiersortie[500];
      char fichiercarte[500];
      int nummaillage;
      double prioritemetrique;
      bool analyse;
      bool visufront;
      double limiteadapt;
      int numsol,numchamp;
      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_action()==17)
        {
        app.recupere_parametre_int_avec_defaut(18,numsol,0);
        app.recupere_parametre_int_avec_defaut(19,numchamp,0);
        }
      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_TAILLE* metrique;
      if (app.get_action()==7)
          {
          FCT_GENERATEUR_3D<4> *carte=new FCT_GENERATEUR_3D<4>;
          carte->lire(fichiercarte);
          metrique=carte;
          }
      MG_FILE *gestcarte;
      if (app.get_action()==17)
          {
          FCT_TAILLE_FEM_SOLUTION *carte=new FCT_TAILLE_FEM_SOLUTION(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);
        if (app.get_action()==7)
          delete metrique;
        if (app.get_action()==17)
        {
       delete metrique;
       delete gestcarte;
        }
        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:	467
Committed:	Tue Nov 26 22:30:11 2013 UTC (11 years, 6 months ago) by francois
File size:	22608 byte(s)
Log Message:	nouveaux types de carte sous forme de maillage FEM avec une solution tensorielle + adaptation des mailleurs reste a adapter l'optimisation de topologie et aussi la carte de taille avec un maillage FEM tetra n'est pas encore fonctionnelle