mailleur_adaptatif.cpp

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mailleur_adaptatif.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:55 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
#include "gestionversion.h"
#include "mailleur_adaptatif.h"
#include "mg_solution.h"
#include "mg_maillage.h"
#include "mg_gestionnaire.h"
#include "fct_taille.h"
#include "mailleur0d.h"
#include "mailleur1d.h"
#include "mailleur2d.h"
#include "mailleur3d.h"
#include <math.h>
 
#define DETRUIT 2000
#define NONDETRUIT 3000
 
 
MAILLEUR_ADAPTATIF::MAILLEUR_ADAPTATIF(MG_MAILLAGE* mai,MG_MAILLAGE* nvmai,FCT_TAILLE* carte,double coef):MAILLEUR(false),mg_maillage(mai),metrique(carte),limite(coef),nv_maillage(nvmai),activelog(0)
{
}
 
MAILLEUR_ADAPTATIF::~MAILLEUR_ADAPTATIF()
{
}
 
int MAILLEUR_ADAPTATIF::maille(MG_GROUPE_TOPOLOGIQUE* mggt)
{
affiche((char*)"  Adaptation de maillage");
char mess[255];
sprintf(mess,"     Destruction des mailles ne respectant pas la carte de taille a %.2f %%",limite*100);
affiche(mess);
LISTE_MG_NOEUD::iterator itnoeud;
for (MG_NOEUD* noeud=mg_maillage->get_premier_noeud(itnoeud);noeud;noeud=mg_maillage->get_suivant_noeud(itnoeud))
        noeud->change_nouveau_numero(NONDETRUIT);
LISTE_MG_SEGMENT::iterator itsegment;
for (MG_SEGMENT* seg=mg_maillage->get_premier_segment(itsegment);seg;seg=mg_maillage->get_suivant_segment(itsegment))
        seg->change_nouveau_numero(NONDETRUIT);
LISTE_MG_TRIANGLE::iterator ittriangle;
for (MG_TRIANGLE* tri=mg_maillage->get_premier_triangle(ittriangle);tri;tri=mg_maillage->get_suivant_triangle(ittriangle))
        tri->change_nouveau_numero(NONDETRUIT);
LISTE_MG_TETRA::iterator ittetra;
for (MG_TETRA* tet=mg_maillage->get_premier_tetra(ittetra);tet;tet=mg_maillage->get_suivant_tetra(ittetra))
        tet->change_nouveau_numero(NONDETRUIT);
 
 
MG_SOLUTION* sol=mg_maillage->calculer_carte_taille_reelle((char*)"temp.soltmp");
sol->active_solution(0);
for (MG_NOEUD* noeud=mg_maillage->get_premier_noeud(itnoeud);noeud;noeud=mg_maillage->get_suivant_noeud(itnoeud))
        {
        double *xyz=noeud->get_coord();
        double tenseur[9];
        metrique->evaluer(xyz,tenseur);
        double val=1./sqrt(tenseur[0]);
        double err=fabs((val-noeud->get_solution())/noeud->get_solution());
        if (err>limite)
                {
                int nb_tetra=noeud->get_lien_tetra()->get_nb();
                if (nb_tetra!=0)
                        {
                        for (int j=0;j<nb_tetra;j++)
                                noeud->get_lien_tetra()->get(j)->change_nouveau_numero(DETRUIT);
                        }
                int nb_tri=noeud->get_lien_triangle()->get_nb();
                if (nb_tri!=0)
                        {
                        for (int j=0;j<nb_tri;j++)
                                if (noeud->get_lien_triangle()->get(j)->get_lien_topologie()->get_dimension()==2)
                                        noeud->get_lien_triangle()->get(j)->change_nouveau_numero(DETRUIT);
                        }
                int nb_seg=noeud->get_lien_segment()->get_nb();
                if (nb_seg!=0)
                        {
                        for (int j=0;j<nb_seg;j++)
                                if (noeud->get_lien_segment()->get(j)->get_lien_topologie()->get_dimension()==1)
                                        noeud->get_lien_segment()->get(j)->change_nouveau_numero(DETRUIT);
                        }
 
                }
        }
delete sol;
for (MG_NOEUD* noeud=mg_maillage->get_premier_noeud(itnoeud);noeud;noeud=mg_maillage->get_suivant_noeud(itnoeud))
        {
        if (noeud->get_lien_topologie()->get_dimension()==1)
                {
                int nb_seg_sur_arete=0;
                int nb_seg=noeud->get_lien_segment()->get_nb();
                for (int j=0;j<nb_seg;j++)
                        if ((noeud->get_lien_segment()->get(j)->get_lien_topologie()->get_dimension()==1) &&
                             (noeud->get_lien_segment()->get(j)->get_nouveau_numero()==NONDETRUIT)) 
                                         nb_seg_sur_arete++;
 
                if (nb_seg_sur_arete==0)
                        {
                        int nb_tri=noeud->get_lien_triangle()->get_nb();
                        for (int j=0;j<nb_tri;j++)
                        if (noeud->get_lien_triangle()->get(j)->get_lien_topologie()->get_dimension()==2)
                                noeud->get_lien_triangle()->get(j)->change_nouveau_numero(DETRUIT);
                        int nb_tetra=noeud->get_lien_tetra()->get_nb();
                        for (int j=0;j<nb_tetra;j++)
                                noeud->get_lien_tetra()->get(j)->change_nouveau_numero(DETRUIT);
                        }
                }
        if (noeud->get_lien_topologie()->get_dimension()==2)
                {
                int nb_tri_sur_face=0;
                int nb_tri=noeud->get_lien_triangle()->get_nb();
                for (int j=0;j<nb_tri;j++)
                        if ((noeud->get_lien_triangle()->get(j)->get_lien_topologie()->get_dimension()==2) &&
                            (noeud->get_lien_triangle()->get(j)->get_nouveau_numero()==NONDETRUIT) )
                                        nb_tri_sur_face++;
 
                if (nb_tri_sur_face==0)
                        {
                        int nb_tetra=noeud->get_lien_tetra()->get_nb();
                        for (int j=0;j<nb_tetra;j++)
                                noeud->get_lien_tetra()->get(j)->change_nouveau_numero(DETRUIT);
                        }
                }
}
int nb_sommet=mg_maillage->get_mg_geometrie()->get_nb_mg_sommet();
for (int i=0;i<nb_sommet;i++)
        {
        MG_SOMMET* som=mg_maillage->get_mg_geometrie()->get_mg_sommet(i);
        int nb_noeud=som->get_lien_maillage()->get_nb();
        for (int j=0;j<nb_noeud;j++)
                {
                MG_NOEUD* noeud=(MG_NOEUD*)som->get_lien_maillage()->get(j);
                if (mg_maillage->get_mg_noeudid(noeud->get_id())==NULL) continue;
                if (noeud->get_nouveau_numero()==DETRUIT) continue;
                MG_NOEUD* nv_noeud=nv_maillage->ajouter_mg_noeud(som,noeud->get_x(),noeud->get_y(),noeud->get_z(),MAGIC::ORIGINE::IMPOSE);
                noeud->change_element_reference(nv_noeud);
                nv_noeud->change_element_reference(noeud);
                }
 
        }
affiche((char*)"     Adaptation maillage 0D");
MAILLEUR0D m0d(nv_maillage,nv_maillage->get_mg_geometrie());
m0d.adapte();
affiche((char*)"     Adaptation maillage 1D");
int nb_arete=mg_maillage->get_mg_geometrie()->get_nb_mg_arete();
for (int i=0;i<nb_arete;i++)
        {
        MG_ARETE* arete=mg_maillage->get_mg_geometrie()->get_mg_arete(i);
        int nb_seg=arete->get_lien_maillage()->get_nb();
        for (int j=0;j<nb_seg;j++)
                {
                MG_SEGMENT* seg=(MG_SEGMENT*)arete->get_lien_maillage()->get(j);
                if (mg_maillage->get_mg_segmentid(seg->get_id())==NULL) continue;
                if (seg->get_nouveau_numero()==DETRUIT) continue;
                MG_NOEUD* noeud1=(MG_NOEUD*)seg->get_noeud1()->get_element_reference();
                MG_NOEUD* noeud2=(MG_NOEUD*)seg->get_noeud2()->get_element_reference();
                if (noeud1==NULL)
                        {
                        noeud1=nv_maillage->ajouter_mg_noeud(arete,seg->get_noeud1()->get_x(),seg->get_noeud1()->get_y(),seg->get_noeud1()->get_z(),MAGIC::ORIGINE::IMPOSE);
                        noeud1->change_element_reference(seg->get_noeud1());
                        seg->get_noeud1()->change_element_reference(noeud1);
                        }
                if (noeud2==NULL)
                        {
                        noeud2=nv_maillage->ajouter_mg_noeud(arete,seg->get_noeud2()->get_x(),seg->get_noeud2()->get_y(),seg->get_noeud2()->get_z(),MAGIC::ORIGINE::IMPOSE);
                        noeud2->change_element_reference(seg->get_noeud2());
                        seg->get_noeud2()->change_element_reference(noeud2);
                        }
                nv_maillage->ajouter_mg_segment(arete,noeud1,noeud2,MAGIC::ORIGINE::IMPOSE);
                }
        MAILLEUR1D m1d(nv_maillage,nv_maillage->get_mg_geometrie(),metrique,arete);
        m1d.change_pas_integration(pas);
        m1d.adapte();
        }
affiche((char*)"     Adaptation maillage 2D");
int nb_face=mg_maillage->get_mg_geometrie()->get_nb_mg_face();
for (int i=0;i<nb_face;i++)
        {
        MG_FACE* face=mg_maillage->get_mg_geometrie()->get_mg_face(i);
        int nb_tri=face->get_lien_maillage()->get_nb();
        TPL_LISTE_ENTITE<MG_TRIANGLE*> lsttri;
        for (int j=0;j<nb_tri;j++)
                {
                MG_TRIANGLE* tri=(MG_TRIANGLE*)face->get_lien_maillage()->get(j);
                if (mg_maillage->get_mg_triangleid(tri->get_id())==NULL) continue;
                if (tri->get_nouveau_numero()==DETRUIT) continue;
                MG_NOEUD* noeud1=tri->get_noeud1();
                MG_NOEUD* noeud2=tri->get_noeud2();
                MG_NOEUD* noeud3=tri->get_noeud3();
                double *xyz1,*xyz2,*xyz3;
                xyz1=noeud1->get_coord();
                xyz2=noeud2->get_coord();
                xyz3=noeud3->get_coord();
                MG_NOEUD* noeudtmp1=new MG_NOEUD(NULL,xyz1[0],xyz1[1],xyz1[2],MAGIC::ORIGINE::IMPOSE);
                MG_NOEUD* noeudtmp2=new MG_NOEUD(NULL,xyz2[0],xyz2[1],xyz2[2],MAGIC::ORIGINE::IMPOSE);
                MG_NOEUD* noeudtmp3=new MG_NOEUD(NULL,xyz3[0],xyz3[1],xyz3[2],MAGIC::ORIGINE::IMPOSE);
                MG_TRIANGLE* tritmp=new MG_TRIANGLE(NULL,noeudtmp1,noeudtmp2,noeudtmp3,NULL,NULL,NULL,MAGIC::ORIGINE::IMPOSE);
                lsttri.ajouter(tritmp);
                }
        MAILLEUR2D m2d(nv_maillage,nv_maillage->get_mg_geometrie(),metrique,face);
        m2d.change_pas_integration(pas);
        m2d.maille(face,NULL,&lsttri);
        nb_tri=lsttri.get_nb();
        for (int j=0;j<nb_tri;j++)
                {
                MG_TRIANGLE* tri=lsttri.get(0);
                MG_NOEUD* noeud1=tri->get_noeud1();
                MG_NOEUD* noeud2=tri->get_noeud2();
                MG_NOEUD* noeud3=tri->get_noeud3();
                lsttri.supprimer(tri);
                delete tri;
                delete noeud1;
                delete noeud2;
                delete noeud3;
                }
 
        }
affiche((char*)"     Adaptation maillage 3D");
int nb_vol=mg_maillage->get_mg_geometrie()->get_nb_mg_volume();
for (int i=0;i<nb_vol;i++)
        {
        MG_VOLUME* vol=mg_maillage->get_mg_geometrie()->get_mg_volume(i);
        int nb_tet=vol->get_lien_maillage()->get_nb();
        TPL_LISTE_ENTITE<MG_TETRA*> lsttet;
        for (int j=0;j<nb_tet;j++)
                {
                MG_TETRA* tet=(MG_TETRA*)vol->get_lien_maillage()->get(j);
                if (mg_maillage->get_mg_tetraid(tet->get_id())==NULL) continue;
                if (tet->get_nouveau_numero()==DETRUIT) continue;
                MG_NOEUD* noeud1=tet->get_noeud1();
                MG_NOEUD* noeud2=tet->get_noeud2();
                MG_NOEUD* noeud3=tet->get_noeud3();
                MG_NOEUD* noeud4=tet->get_noeud4();
                double *xyz1,*xyz2,*xyz3,*xyz4;
                xyz1=noeud1->get_coord();
                xyz2=noeud2->get_coord();
                xyz3=noeud3->get_coord();
                xyz4=noeud4->get_coord();
                MG_NOEUD* noeudtmp1=new MG_NOEUD(NULL,xyz1[0],xyz1[1],xyz1[2],MAGIC::ORIGINE::IMPOSE);
                MG_NOEUD* noeudtmp2=new MG_NOEUD(NULL,xyz2[0],xyz2[1],xyz2[2],MAGIC::ORIGINE::IMPOSE);
                MG_NOEUD* noeudtmp3=new MG_NOEUD(NULL,xyz3[0],xyz3[1],xyz3[2],MAGIC::ORIGINE::IMPOSE);
                MG_NOEUD* noeudtmp4=new MG_NOEUD(NULL,xyz4[0],xyz4[1],xyz4[2],MAGIC::ORIGINE::IMPOSE);
                MG_TETRA* tetra=new MG_TETRA(NULL,noeudtmp1,noeudtmp2,noeudtmp3,noeudtmp4,NULL,NULL,NULL,NULL,MAGIC::ORIGINE::IMPOSE);
                lsttet.ajouter(tetra);
                }
        MAILLEUR3D m3d(nv_maillage,nv_maillage->get_mg_geometrie(),metrique,vol);
        m3d.active_affichage(affiche2); 
        m3d.change_pas_integration(pas);
        if (activelog) m3d.active_log(nomlog); 
        m3d.maille(vol,NULL,&lsttet);
        nb_tet=lsttet.get_nb();
        for (int j=0;j<nb_tet;j++)
                {
                MG_TETRA* tet=lsttet.get(0);
                MG_NOEUD* noeud1=tet->get_noeud1();
                MG_NOEUD* noeud2=tet->get_noeud2();
                MG_NOEUD* noeud3=tet->get_noeud3();
                MG_NOEUD* noeud4=tet->get_noeud4();
                lsttet.supprimer(tet);
                delete tet;
                delete noeud1;
                delete noeud2;
                delete noeud3;
                delete noeud4;
                }
 
        }
 
affiche((char*)"  Fin de l'adaptation de maillage");
return OK;
}
 
 
 
void MAILLEUR_ADAPTATIF::active_log(char* nomfile)
{
activelog=1;
nomlog=nomfile;
}
 
void MAILLEUR_ADAPTATIF::desactive_log(void)
{
activelog=0;
}