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 p16(18,(char*)"-enregistrer",MAGIC_PARAMETRE_APPLICATION::BOOL,(char*)"Enregistrement de la dernière étape (pour debbugage) - Defaut false");
MAGIC_PARAMETRE_APPLICATION p17(19,(char*)"-pas",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char*)"Valeur du pas d'integration - Defaut 32");


//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);p5.ajouter_dependance(18);p5.ajouter_dependance(19);
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);p6.ajouter_dependance(18);
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);p14.ajouter_dependance(18);p14.ajouter_dependance(18);
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);p15.ajouter_dependance(18);
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);
lst.push_back(p16);
lst.push_back(p17);

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 fichiersortie2[500];
      char fichiercarte[500];
      int numgeometrie;
      double prioritemetrique;
      int numgroupe;
      int niveau;
      bool analyse;
      bool visufront;
      int niveauopt3d;
      int niveauopt2d;
      int numsol,numchamp;
      bool save;
      int pas;
      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);
      app.recupere_parametre_bool_avec_defaut(18,save,false);
      app.recupere_parametre_int_avec_defaut(19,pas,32);
      if (app.get_erreur()==true) return 0; 
      char message[500];
      strcpy(fichiersortie2,fichiersortie);
      strcat(fichiersortie2,"dbg");
      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);
        if (save==true) gest.enregistrer(fichiersortie2);
    }
    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.change_pas_integration(pas);
            m1d.maille(mggt);
            if (save==true) gest.enregistrer(fichiersortie2);
        }
    }
    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_pas_integration(pas);
            m2d.change_niveau_optimisation(niveauopt2d);
            m2d.maille(mggt);
            if (save==true) gest.enregistrer(fichiersortie2);
        }
    }
    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,save,mgvol);
            m3d.active_affichage(app.affiche);
            m3d.change_niveau_optimisation(niveauopt3d);
            if (visufront) m3d.active_log(fichiersortie);
            if (save==true) m3d.change_nom_fichierdbg(fichiersortie2);
            m3d.change_pas_integration(pas);
            m3d.maille(mgvol);
            if (save==true) gest.enregistrer(fichiersortie2);
            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;
      int pas;
      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,(char*)"Valeur limite d'adaptation manquante");     
      app.recupere_parametre_int_avec_defaut(19,pas,32);
      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.change_pas_integration(pas);
      mesh.active_affichage(app.affiche);
      if (visufront) mesh.active_log(fichier);
      mesh.maille();
      if (analyse)
        {
            MAILLEUR3D m3d(nvmai,nvmai->get_mg_geometrie(),metrique,false);
            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");
   }
  
  
    return 0;
}


#pragma package(smart_init)
Revision:	532
Committed:	Fri Jul 4 14:39:20 2014 UTC (10 years, 11 months ago) by francois
File size:	16894 byte(s)
Log Message:	Resolution de bug avec le mailleur3D et la nouvelle formulation de carte de taille + parametrisation du pas d'integration dans le calcul des longueurs dans une metrique
#	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	francois	481	#include "fct_generateur_3d.h"
40	francois	467	#include "fct_taille_fem_solution.h"
41	francois	283	#include "mg_export.h"
42			#include "step_import.h"
43			#include "acis_import.h"
44
45			//---------------------------------------------------------------------------
46
47	francois	432	int main(int argc,char **argv)
48	francois	283	{
49	francois	432	std::vector<MAGIC_PARAMETRE_APPLICATION> lst;
50			MAGIC_PARAMETRE_APPLICATION p1(3,(char)"-carte",MAGIC_PARAMETRE_APPLICATION::STRING,(char)"Fichier de carte de taille");
51	francois	447	MAGIC_PARAMETRE_APPLICATION p2(4,(char)"-niveauopt3d",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Limite supérieure des mailles à optimiser - Défaut 2");
52	francois	432	MAGIC_PARAMETRE_APPLICATION p3(5,(char)"-niveau",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Dimension limite des entités à mailler - Défaut 3");
53			MAGIC_PARAMETRE_APPLICATION p5(6,(char)"-front",MAGIC_PARAMETRE_APPLICATION::ACTION,(char)"Maillage d'une géométrie par la méthode frontale - Defaut");
54			MAGIC_PARAMETRE_APPLICATION p6(7,(char)"-adapt",MAGIC_PARAMETRE_APPLICATION::ACTION,(char)"Maillage adaptatif d'une géométrie maillée");
55			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");
56			MAGIC_PARAMETRE_APPLICATION p7(9,(char)"-numgeo",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Numero de géometrie à mailler - Défaut la première");
57			MAGIC_PARAMETRE_APPLICATION p8(10,(char)"-groupe",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Groupe topologique à mailler - Défaut pas de groupe");
58			MAGIC_PARAMETRE_APPLICATION p9(11,(char)"-analyse",MAGIC_PARAMETRE_APPLICATION::BOOL,(char)"Analyse de la qualité du maillage après le maillage");
59			MAGIC_PARAMETRE_APPLICATION p10(12,(char)"-visufront",MAGIC_PARAMETRE_APPLICATION::BOOL,(char)"Activation de la visalisation dynamique du front");
60			MAGIC_PARAMETRE_APPLICATION p11(13,(char)"-nummai",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Numéro du maillage à adapter - Défaut le premier");
61			MAGIC_PARAMETRE_APPLICATION p12(14,(char)"-limitadapt",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char)"Limite inférieure en %d'erreur pour conserver les mailles");
62	francois	447	MAGIC_PARAMETRE_APPLICATION p13(15,(char)"-niveauopt2d",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Limite supérieure des mailles à optimiser - Défaut 5");
63	francois	467	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");
64			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");
65	francois	494	MAGIC_PARAMETRE_APPLICATION p16(18,(char)"-enregistrer",MAGIC_PARAMETRE_APPLICATION::BOOL,(char)"Enregistrement de la dernière étape (pour debbugage) - Defaut false");
66	francois	532	MAGIC_PARAMETRE_APPLICATION p17(19,(char)"-pas",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Valeur du pas d'integration - Defaut 32");
67	francois	283
68
69
70	francois	432
71			//MAGIC_PARAMETRE_APPLICATION p7(8,(char)"-tailleoctree",MAGIC_PARAMETRE_APPLICATION::DOUBLE,(char)"Taille des octants par rapport à la taille souhaitée - Défaut 2.");
72			//MAGIC_PARAMETRE_APPLICATION p8(9,(char)"-fem",MAGIC_PARAMETRE_APPLICATION::BOOL,(char)"Création du maillage fem");
73			//MAGIC_PARAMETRE_APPLICATION p9(10,(char)"-degre",MAGIC_PARAMETRE_APPLICATION::INTEGER,(char)"Degre du maillage fem - Défaut 1");
74	francois	532	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);p5.ajouter_dependance(18);p5.ajouter_dependance(19);
75			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);p6.ajouter_dependance(18);
76			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);p14.ajouter_dependance(18);p14.ajouter_dependance(18);
77			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);p15.ajouter_dependance(18);
78	francois	432	lst.push_back(p1);
79			lst.push_back(p2);
80			lst.push_back(p3);
81			lst.push_back(p5);
82			lst.push_back(p6);
83			lst.push_back(p4);
84			lst.push_back(p7);
85			lst.push_back(p8);
86			lst.push_back(p9);
87			lst.push_back(p10);
88			lst.push_back(p11);
89			lst.push_back(p12);
90	francois	447	lst.push_back(p13);
91	francois	467	lst.push_back(p14);
92			lst.push_back(p15);
93	francois	494	lst.push_back(p16);
94	francois	532	lst.push_back(p17);
95	francois	432
96			MAGIC_APPLICATION app((char*)"Mailleur d'une géometrie par la méthode frontale",argc,argv,lst,true,true);
97			if (app.get_erreur()==true) return 0;
98
99			if (app.get_action()==-1) app.change_action(6);
100
101	francois	467	if ((app.get_action()==6) \|\| (app.get_action()==16))
102	francois	432	{
103			char fichier[500];
104			char fichiersortie[500];
105	francois	494	char fichiersortie2[500];
106	francois	432	char fichiercarte[500];
107			int numgeometrie;
108			double prioritemetrique;
109			int numgroupe;
110			int niveau;
111			bool analyse;
112			bool visufront;
113	francois	447	int niveauopt3d;
114			int niveauopt2d;
115	francois	467	int numsol,numchamp;
116	francois	494	bool save;
117	francois	532	int pas;
118	francois	432	app.recupere_parametre_string(1,fichier,(char*)"Fichier d'entrée manquant");
119			app.recupere_parametre_string_avec_defaut(2,fichiersortie,fichier);
120			app.recupere_parametre_string(3,fichiercarte,(char*)"Fichier carte manquant");
121			app.recupere_parametre_double_avec_defaut(8,prioritemetrique,0.65);
122			app.recupere_parametre_int_avec_defaut(9,numgeometrie,0);
123			app.recupere_parametre_int_avec_defaut(10,numgroupe,0);
124			app.recupere_parametre_int_avec_defaut(5,niveau,3);
125			app.recupere_parametre_bool_avec_defaut(11,analyse,false);
126			app.recupere_parametre_bool_avec_defaut(12,visufront,false);
127	francois	447	app.recupere_parametre_int_avec_defaut(4,niveauopt3d,2);
128			app.recupere_parametre_int_avec_defaut(15,niveauopt2d,5);
129	francois	526	app.recupere_parametre_bool_avec_defaut(18,save,false);
130	francois	532	app.recupere_parametre_int_avec_defaut(19,pas,32);
131	francois	432	if (app.get_erreur()==true) return 0;
132			char message[500];
133	francois	494	strcpy(fichiersortie2,fichiersortie);
134			strcat(fichiersortie2,"dbg");
135	francois	432	app.affiche((char*)"Parametre d'etude du mailleur");
136			sprintf(message," Fichier magic : %s",fichier);
137			app.affiche(message);
138			sprintf(message," Numero de geometrie : %d",numgeometrie);
139			sprintf(message," Fichier carte : %s",fichiercarte);
140			app.affiche(message);
141			sprintf(message," Parametre de metrique : %2.2f",prioritemetrique*100);
142			app.affiche(message);
143			app.affiche((char*)"Lecture du fichier M.A.G.i.C");
144			MG_FILE gest(fichier);
145			MG_GEOMETRIE* mggeo;
146			if (numgeometrie==0) mggeo=gest.get_mg_geometrie(numgeometrie); else mggeo=gest.get_mg_geometrieid(numgeometrie);
147			MG_MAILLAGE* mgmai=new MG_MAILLAGE(mggeo);
148			gest.ajouter_mg_maillage(mgmai);
149	francois	467	app.affiche((char*)"Lecture carte de taille");
150	francois	432	FCT_TAILLE* metrique;
151	francois	467	if (app.get_action()==6)
152			{
153			FCT_GENERATEUR_3D<4> *carte=new FCT_GENERATEUR_3D<4>;
154			carte->lire(fichiercarte);
155			metrique=carte;
156			}
157			MG_FILE *gestcarte;
158			if (app.get_action()==16)
159			{
160			FCT_TAILLE_FEM_SOLUTION *carte=new FCT_TAILLE_FEM_SOLUTION(fichiercarte);
161			metrique=carte;
162			}
163	francois	432	MAILLEUR2D::priorite_metrique=prioritemetrique;
164			MG_GROUPE_TOPOLOGIQUE* mggt=NULL;
165			if (numgroupe!=0)
166			mggt=mggeo->get_mg_groupe_topologiqueid(numgroupe);
167			if (niveau>-1)
168	francois	283	{
169	francois	432	app.affiche((char*)"MAILLAGE 0D");
170			MAILLEUR0D m0d(mgmai,mggeo);
171			m0d.maille(mggt);
172	francois	494	if (save==true) gest.enregistrer(fichiersortie2);
173	francois	283	}
174	francois	432	TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> lst;
175			if (mggt!=NULL)
176			{
177			int nb=mggt->get_nb();
178			for (int i=0;i<nb;i++)
179			{
180			lst.ajouter(mggt->get(i));
181			mggt->get(i)->get_topologie_sousjacente(&lst);
182			}
183			}
184			if (niveau>0)
185			{
186			app.affiche((char*)"MAILLAGE 1D");
187			int nb=mggeo->get_nb_mg_arete();
188			for (int i=0;i<nb;i++)
189			{
190			MG_ARETE* arete=mggeo->get_mg_arete(i);
191			if (mggt!=NULL)
192			if (lst.existe(arete)==0) continue;
193			char mess[100];
194			sprintf(mess," arete %d",i);
195			app.affiche(mess);
196	francois	446	MAILLEUR1D m1d(mgmai,mggeo,metrique,arete);
197	francois	532	m1d.change_pas_integration(pas);
198	francois	432	m1d.maille(mggt);
199	francois	494	if (save==true) gest.enregistrer(fichiersortie2);
200	francois	432	}
201			}
202			if (niveau>1)
203			{
204			app.affiche((char*)"MAILLAGE 2D");
205			int nb=mggeo->get_nb_mg_face();
206			for (int i=0;i<nb;i++)
207			{
208			MG_FACE* mgface=mggeo->get_mg_face(i);
209			if (mggt!=NULL)
210			if (lst.existe(mgface)==0) continue;
211			char mess[100];
212			sprintf(mess," face %d",i);
213			app.affiche(mess);
214	francois	446	MAILLEUR2D m2d(mgmai,mggeo,metrique,mgface);
215	francois	532	m2d.change_pas_integration(pas);
216	francois	447	m2d.change_niveau_optimisation(niveauopt2d);
217	francois	432	m2d.maille(mggt);
218	francois	494	if (save==true) gest.enregistrer(fichiersortie2);
219	francois	432	}
220			}
221			if (niveau==3)
222			{
223			app.affiche((char*)"MAILLAGE 3D");
224			int nb=mggeo->get_nb_mg_volume();
225			for (int i=0;i<nb;i++)
226			{
227			MG_VOLUME* mgvol=mggeo->get_mg_volume(i);
228			if (mggt!=NULL)
229			if (lst.existe(mgvol)==0) continue;
230	francois	532	MAILLEUR3D m3d(mgmai,mggeo,metrique,save,mgvol);
231	francois	432	m3d.active_affichage(app.affiche);
232	francois	447	m3d.change_niveau_optimisation(niveauopt3d);
233	francois	432	if (visufront) m3d.active_log(fichiersortie);
234	francois	494	if (save==true) m3d.change_nom_fichierdbg(fichiersortie2);
235	francois	532	m3d.change_pas_integration(pas);
236	francois	494	m3d.maille(mgvol);
237			if (save==true) gest.enregistrer(fichiersortie2);
238	francois	432	if (analyse)
239			{
240			app.affiche((char*)"Analyse maillage");
241			double vol;int tab[4];
242			m3d.analyse_maillage_obtenu(vol,tab);
243			char mess[100];
244			sprintf(mess," 1) Respect de la carte de taille");
245			app.affiche(mess);
246			sprintf(mess," nombre de tetra theorique %f, nombre de tetra pratique %d ",vol,mgmai->get_nb_mg_tetra());
247			app.affiche(mess);
248			sprintf(mess," erreur : %.2f%%",(mgmai->get_nb_mg_tetra()-vol)*100./vol);
249			app.affiche(mess);
250			sprintf(mess," 2) Qualite du maillage");
251			app.affiche(mess);
252			sprintf(mess," nombre de tetra bon (qualite>0.5) : %d (%.2f%%)",tab[3],tab[3]*100./mgmai->get_nb_mg_tetra());
253			app.affiche(mess);
254			sprintf(mess," nombre de tetra acceptable (qualite>0.2) : %d (%.2f%%) ",tab[2],tab[2]*100./mgmai->get_nb_mg_tetra());
255			app.affiche(mess);
256			sprintf(mess," nombre de tetra moyen (qualite>0.1) : %d (%.2f%%) ",tab[1],tab[1]*100./mgmai->get_nb_mg_tetra());
257			app.affiche(mess);
258			sprintf(mess," nombre de tetra mauvais (qualite>0.) : %d (%.2f%%) ",tab[0],tab[0]*100./mgmai->get_nb_mg_tetra());
259			app.affiche(mess);
260			}
261			}
262			}
263			app.affiche((char*)"Enregistrement");
264	francois	449	gest.enregistrer(fichiersortie);
265	francois	467	if (app.get_action()==6)
266			delete metrique;
267			if (app.get_action()==16)
268			{
269			delete metrique;
270			delete gestcarte;
271			}
272	francois	432	app.affiche((char*)"Fin");
273
274			}
275
276	francois	467	if ((app.get_action()==7)\|\|(app.get_action()==17))
277	francois	432	{
278			char fichier[500];
279			char fichiersortie[500];
280			char fichiercarte[500];
281			int nummaillage;
282			double prioritemetrique;
283			bool analyse;
284			bool visufront;
285			double limiteadapt;
286	francois	467	int numsol,numchamp;
287	francois	532	int pas;
288	francois	432	app.recupere_parametre_string(1,fichier,(char*)"Fichier d'entrée manquant");
289			app.recupere_parametre_string_avec_defaut(2,fichiersortie,fichier);
290			app.recupere_parametre_string(3,fichiercarte,(char*)"Fichier carte manquant");
291			app.recupere_parametre_double_avec_defaut(8,prioritemetrique,0.65);
292			app.recupere_parametre_int_avec_defaut(13,nummaillage,0);
293			app.recupere_parametre_bool_avec_defaut(11,analyse,false);
294			app.recupere_parametre_bool_avec_defaut(12,visufront,false);
295	francois	532	app.recupere_parametre_double(14,limiteadapt,(char*)"Valeur limite d'adaptation manquante");
296			app.recupere_parametre_int_avec_defaut(19,pas,32);
297	francois	467	if (app.get_action()==17)
298			{
299			app.recupere_parametre_int_avec_defaut(18,numsol,0);
300			app.recupere_parametre_int_avec_defaut(19,numchamp,0);
301			}
302	francois	432	if (app.get_erreur()==true) return 0;
303			char message[500];
304			app.affiche((char*)"Adaptation de maillage");
305			sprintf(message," Fichier magic : %s",fichier);
306			app.affiche(message);
307			printf(message," Numero de maillage : %d",nummaillage);
308			app.affiche(message);
309			sprintf(message," Carte : %s",fichiercarte);
310			app.affiche(message);
311			MG_FILE gest(fichier);
312			MG_MAILLAGE* mai;
313			if (nummaillage==0) mai=gest.get_mg_maillage(nummaillage); else mai=gest.get_mg_maillageid(nummaillage);
314			FCT_TAILLE* metrique;
315	francois	467	if (app.get_action()==7)
316			{
317			FCT_GENERATEUR_3D<4> *carte=new FCT_GENERATEUR_3D<4>;
318			carte->lire(fichiercarte);
319			metrique=carte;
320			}
321			MG_FILE *gestcarte;
322			if (app.get_action()==17)
323			{
324			FCT_TAILLE_FEM_SOLUTION *carte=new FCT_TAILLE_FEM_SOLUTION(fichiercarte);
325			metrique=carte;
326			}
327	francois	432	MG_MAILLAGE* nvmai=new MG_MAILLAGE(mai->get_mg_geometrie());
328			gest.ajouter_mg_maillage(nvmai);
329			MAILLEUR_ADAPTATIF mesh(mai,nvmai,metrique,limiteadapt);
330	francois	532	mesh.change_pas_integration(pas);
331	francois	432	mesh.active_affichage(app.affiche);
332			if (visufront) mesh.active_log(fichier);
333			mesh.maille();
334			if (analyse)
335			{
336	francois	494	MAILLEUR3D m3d(nvmai,nvmai->get_mg_geometrie(),metrique,false);
337	francois	432	app.affiche((char*)"Analyse maillage");
338			double vol;int tab[4];
339			m3d.analyse_maillage_obtenu(vol,tab);
340			char mess[100];
341			sprintf(mess," 1) Respect de la carte de taille");
342			app.affiche(mess);
343			sprintf(mess," nombre de tetra theorique %f, nombre de tetra pratique %d ",vol,nvmai->get_nb_mg_tetra());
344			app.affiche(mess);
345			sprintf(mess," erreur : %.2f%%",(nvmai->get_nb_mg_tetra()-vol)*100./vol);
346			app.affiche(mess);
347			sprintf(mess," 2) Qualite du maillage");
348			app.affiche(mess);
349			sprintf(mess," nombre de tetra bon (qualite>0.5) : %d (%.2f%%)",tab[3],tab[3]*100./nvmai->get_nb_mg_tetra());
350			app.affiche(mess);
351			sprintf(mess," nombre de tetra acceptable (qualite>0.2) : %d (%.2f%%) ",tab[2],tab[2]*100./nvmai->get_nb_mg_tetra());
352			app.affiche(mess);
353			sprintf(mess," nombre de tetra moyen (qualite>0.1) : %d (%.2f%%) ",tab[1],tab[1]*100./nvmai->get_nb_mg_tetra());
354			app.affiche(mess);
355			sprintf(mess," nombre de tetra mauvais (qualite>0.) : %d (%.2f%%) ",tab[0],tab[0]*100./nvmai->get_nb_mg_tetra());
356			app.affiche(mess);
357			}
358			app.affiche((char*)"Enregistrement");
359			gest.enregistrer(fichiersortie);
360	francois	467	if (app.get_action()==7)
361			delete metrique;
362			if (app.get_action()==17)
363			{
364			delete metrique;
365			delete gestcarte;
366			}
367			app.affiche((char*)"Fin");
368	francois	432	}
369
370
371	francois	532
372	francois	283	return 0;
373			}
374
375
376
377			#pragma package(smart_init)