mailleur/src/mailleur2d_structure.cpp

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mailleur2d_structure.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:55 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include <stdio.h>
#include <math.h>
#include "mg_gestionnaire.h"
#include "mailleur2d_structure.h"
#include "mg_maillage.h"
#include "fem_maillage.h"
#include "fem_hexa20.h"
#include "mg_geometrie.h"
#include "mg_sommet_noeud.h"
#include "mg_arete_element.h"
#include "mg_face_element.h"
#include "mg_volume_element.h"
#include "tpl_octree.h"
#include "mg_maillage_outils.h"
#include <vector>


struct integrale
{
    double ti;
    double li;
};

MAILLEUR2D_STRUCTURE::MAILLEUR2D_STRUCTURE(double xmintmp, double xmaxtmp, double ymintmp, double ymaxtmp, int ntmp, int mtmp, MG_GESTIONNAIRE* gesttmp,int avecgeo,double unit):MAILLEUR(false),xmin(xmintmp),xmax(xmaxtmp),ymin(ymintmp),ymax(ymaxtmp),n(ntmp),m(mtmp),gest(gesttmp),geovirtuel(avecgeo),densitevariable(false),unite(unit),nbfonction(0)
{  
}    
MAILLEUR2D_STRUCTURE::MAILLEUR2D_STRUCTURE( double xmintmp, double xmaxtmp, double ymintmp, double ymaxtmp, double (*fx)(double),double (*fy)(double),MG_GESTIONNAIRE* gesttmp,int avecgeo,double unit):MAILLEUR(false),xmin(xmintmp),xmax(xmaxtmp),ymin(ymintmp),ymax(ymaxtmp),gest(gesttmp),geovirtuel(avecgeo),enx(fx),eny(fy),densitevariable(true),unite(unit),nbfonction(0)
{
}

MAILLEUR2D_STRUCTURE::MAILLEUR2D_STRUCTURE( MAILLEUR2D_STRUCTURE& mdd):MAILLEUR(mdd),
xmin(mdd.xmin),xmax(mdd.xmax),ymin(mdd.ymin),ymax(mdd.ymax),n(mdd.n),m(mdd.m),gest(mdd.gest),nbfonction(mdd.nbfonction)
{  
}  

MAILLEUR2D_STRUCTURE::~MAILLEUR2D_STRUCTURE()
{
}


void MAILLEUR2D_STRUCTURE::discretise(std::vector<double> &tab,double min,double max,int &nb,double (*en)(double))
{
    double t1=0;
    double t2=1;
    std::vector<integrale> tab_integrale;
    double ti,tii,t;
    double longueur_metrique=0.;
    tii=t1;
    double dt=1./pas;
    do
    {
        ti=tii;
        tii=ti+(t2-t1)*dt;
        if (tii>t2) tii=t2;
        t=0.7886751345*ti+0.2113248654*tii;
        double facteur1=(max-min)/(*en)(t);
        t=0.7886751345*tii+0.2113248654*ti;
        double facteur2=(max-min)/(*en)(t);
        longueur_metrique=longueur_metrique+0.5*(tii-ti)*(facteur1+facteur2);
        integrale pas;
        pas.ti=ti;
        pas.li=longueur_metrique;
        tab_integrale.insert(tab_integrale.end(),pas);
    }
    while (tii<t2);
    nb=(int)floor(longueur_metrique);
    if (longueur_metrique-floor(longueur_metrique)>0.5) nb++;
    if (nb<1)  nb=1;
    double valeur_cible=longueur_metrique/nb;
    tab.push_back(min);
    int nbcree=0;
    int nb_pas_integrale=tab_integrale.size();
    for (int i=0;i<nb_pas_integrale;i++)
    {
        while ((tab_integrale[i].li>(nbcree+1)*valeur_cible) && (nbcree<nb-1))
        {
            double ti=tab_integrale[i].ti;
            double tii=t2;
            double li=0.;
            if (i!=0) li=tab_integrale[i-1].li;
            double lii=tab_integrale[i].li;
            if (i!=nb_pas_integrale-1) tii=tab_integrale[i+1].ti;
            t=ti+(tii-ti)/(lii-li)*((nbcree+1)*valeur_cible-li);
            double x=min+t*(max-min);
            tab.push_back(x);
            nbcree++;
        }
    }
    tab.push_back(max);
    
}
void MAILLEUR2D_STRUCTURE::ajouter_fonction_geometrie(int nb)
{
nbfonction=nb;  
}

int MAILLEUR2D_STRUCTURE::maille(MG_GROUPE_TOPOLOGIQUE* mggt)
{
 affiche((char*)"Création d'un maillage MG structuré");
 double intx, inty;
 std::vector<double> tabx,taby;
 if (densitevariable==false)
    {
    intx=fabs(xmax-xmin)/n;
    inty=fabs(ymax-ymin)/m;
    }
 else
    {
    discretise(tabx,xmin,xmax,n,enx);  
    discretise(taby,ymin,ymax,m,eny);  
    }

 MG_GEOMETRIE* geo=NULL;
 MG_SOMMET_NOEUD *som1=NULL;
 MG_SOMMET_NOEUD *som2=NULL;
 MG_SOMMET_NOEUD *som3=NULL;
 MG_SOMMET_NOEUD *som4=NULL;
 MG_ARETE_ELEMENT* are1=NULL;
 MG_ARETE_ELEMENT* are2=NULL;
 MG_ARETE_ELEMENT* are3=NULL;
 MG_ARETE_ELEMENT* are4=NULL;
 MG_FACE_ELEMENT* face1=NULL;
 if (geovirtuel==true) 
          {     
          geo=new MG_GEOMETRIE((char*)"VIRTUEL",(char*)"VIRTUEL");
          geo->change_valeur_unite(unite);
          gest->ajouter_mg_geometrie(geo);
          som1=new MG_SOMMET_NOEUD(NULL);
          geo->ajouter_mg_sommet(som1);
          som2=new MG_SOMMET_NOEUD(NULL);
          geo->ajouter_mg_sommet(som2);
          som3=new MG_SOMMET_NOEUD(NULL);
          geo->ajouter_mg_sommet(som3);
          som4=new MG_SOMMET_NOEUD(NULL);
          geo->ajouter_mg_sommet(som4);
          are1=new MG_ARETE_ELEMENT();
          geo->ajouter_mg_arete(are1);
          are2=new MG_ARETE_ELEMENT();
          geo->ajouter_mg_arete(are2);
          are3=new MG_ARETE_ELEMENT();
          geo->ajouter_mg_arete(are3);
          are4=new MG_ARETE_ELEMENT();
          geo->ajouter_mg_arete(are4);
          face1=new MG_FACE_ELEMENT();
          geo->ajouter_mg_face(face1);
          for (int i=0;i<nbfonction;i++)
            {
            MG_GEOM_FONCTION *fonc=new MG_GEOM_FONCTION(0);
            geo->ajouter_mg_geom_fonction(fonc);
            }
          }
 MG_MAILLAGE* mai=new MG_MAILLAGE(geo);
 gest->ajouter_mg_maillage(mai); 
 std::vector<MG_NOEUD*> vecnod;
     for (int j=0; j<=m;j++)
      {
       for (int i=0; i<=n;i++)
         { 
           MG_ELEMENT_TOPOLOGIQUE *topo=NULL;
           if (geovirtuel)
            {
            if ((i==0) && (j==0)) topo=som1;
            else if ((i==0) && (j==m)) topo=som2;
            else if ((i==0) && (j==m)) topo=som3;
            else if ((i==0) && (j==0)) topo=som4;
            else if (j==0) topo=are1;
            else if (i==n) topo=are2;
            else if (j==m) topo=are3;
            else if (j==0) topo=are4;
            else topo=face1;
            }
    double x,y;
          if (densitevariable==false)
            {
            y=ymin+(j*inty);
            x=xmin+(i*intx);
            }
          else
            {
            x=tabx[i];  
            y=taby[j];  
            }
          MG_NOEUD* nou=mai->ajouter_mg_noeud(topo,x,y,0.,MAGIC::ORIGINE::MAILLEUR_AUTO);
          vecnod.push_back(nou);
          if (geovirtuel)
            {
            if ((i==0) && (j==0)) som1->change_mg_noeud(nou);
            else if ((i==n) && (j==0) ) som2->change_mg_noeud(nou);
            else if ((i==n) && (j==m) ) som3->change_mg_noeud(nou);
            else if ((i==0) && (j==m) ) som4->change_mg_noeud(nou);
            }
         }
    }
if (geovirtuel)
  {
  for(int i=0; i<n;i++)
    {
    int j=0;
    MG_NOEUD* nod1=vecnod[i+((n+1)*j)];
    MG_NOEUD* nod2=vecnod[(i+1)+((n+1)*j)]; 
    mai->ajouter_mg_segment(are1,nod1,nod2,MAGIC::ORIGINE::MAILLEUR_AUTO);
    j=m;
    MG_NOEUD* nod3=vecnod[i+((n+1)*j)];
    MG_NOEUD* nod4=vecnod[(i+1)+((n+1)*j)]; 
    mai->ajouter_mg_segment(are3,nod3,nod4,MAGIC::ORIGINE::MAILLEUR_AUTO);
    }
  for(int j=0; j<m;j++)
    {
    int i=0;
    MG_NOEUD* nod1=vecnod[i+((n+1)*j)];
    MG_NOEUD* nod2=vecnod[i+((n+1)*(j+1))]; 
    mai->ajouter_mg_segment(are4,nod1,nod2,MAGIC::ORIGINE::MAILLEUR_AUTO);
    i=n;
    MG_NOEUD* nod3=vecnod[i+((n+1)*j)];
    MG_NOEUD* nod4=vecnod[i+((n+1)*(j+1))]; 
    mai->ajouter_mg_segment(are2,nod3,nod4,MAGIC::ORIGINE::MAILLEUR_AUTO);
    }
  }
 for (int i=0;i<n;i++)
    for (int j=0;j<m;j++)
      {
      MG_NOEUD* nod1=vecnod[i+((n+1)*j)];
      MG_NOEUD* nod2=vecnod[(i+1)+((n+1)*j)]; 
      MG_NOEUD* nod3=vecnod[(i+1)+((n+1)*(j+1))]; 
      MG_NOEUD* nod4=vecnod[i+((n+1)*(j+1))];
      mai->ajouter_mg_quadrangle(face1,nod1,nod4,nod3,nod2,MAGIC::ORIGINE::MAILLEUR_AUTO);
      }
  
 BOITE_3D b(xmin,ymin,0.,xmax,ymax,0.);
 mai->change_param_structure(b,n,m,0);
 /*affiche((char*)"Création d'un maillage FEM structuré");
 FEM_MAILLAGE* fem = new FEM_MAILLAGE(geo, mai,1);
 gest->ajouter_fem_maillage(fem);
 fem->construire();*/
 return OK;
}


void MAILLEUR2D_STRUCTURE::ajuste(class MG_MAILLAGE* mai, MG_MAILLAGE* maibase, int nb)
{
    LISTE_MG_NOEUD::iterator it;
    double xmin=1e300,ymin=1e300,zmin=1e300;
    double xmax=-1e300,ymax=-1e300,zmax=-1e300;
    TPL_LISTE_ENTITE<MG_NOEUD*> lst;
    for (MG_NOEUD* no=maibase->get_premier_noeud(it);no!=NULL;no=maibase->get_suivant_noeud(it))
        {
        if (no->get_x()<xmin) xmin=no->get_x();    
        if (no->get_y()<ymin) ymin=no->get_y();    
        if (no->get_z()<zmin) zmin=no->get_z();    
        if (no->get_x()>xmax) xmax=no->get_x();    
        if (no->get_y()>ymax) ymax=no->get_y();    
        if (no->get_z()>zmax) zmax=no->get_z();    
        lst.ajouter(no);
        }
    BOITE_3D b(xmin,ymin,zmin,xmax,ymax,zmax);
    b.change_grosseur(1.05);
    TPL_OCTREE<MG_TRIANGLE*,MG_NOEUD*> oc;
    oc.initialiser(&lst,1,b.get_xmin(),b.get_xmin(),b.get_zmin(),b.get_xmax(),b.get_xmax(),b.get_zmax());
    LISTE_MG_TRIANGLE::iterator itt;
    for (MG_TRIANGLE* tri=maibase->get_premier_triangle(itt);tri!=NULL;tri=maibase->get_suivant_triangle(itt))
        oc.inserer(tri);
    
    for (MG_NOEUD* no=mai->get_premier_noeud(it);no!=NULL;no=mai->get_suivant_noeud(it))
            {
            double x=no->get_x();    
            double y=no->get_y();    
            double z=no->get_z();    
            TPL_MAP_ENTITE<MG_TRIANGLE*> lsttrouve;
            oc.rechercher(x,y,z,1e-7,lsttrouve);
            TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR itf;
            bool trouve=false;
            for (MG_TRIANGLE* tri=lsttrouve.get_premier(itf);tri!=NULL;tri=lsttrouve.get_suivant(itf))
                {
                MG_MAILLAGE_OUTILS ot;
                int res=ot.estdansletriangle(tri,x,y,z);
                int val=ot.compare_etat_triangle(res,MG_MAILLAGE_OUTILS::INTERIEUR);
                if (val>0) trouve=true;
                }
            if (trouve) no->change_nouveau_numero(1); else no->change_nouveau_numero(0);
            }
    LISTE_MG_QUADRANGLE::iterator itq;
    std::vector<unsigned long> listeasupprimer;
    for (MG_QUADRANGLE* quad=mai->get_premier_quadrangle(itq);quad!=NULL;quad=mai->get_suivant_quadrangle(itq))
            {
            MG_NOEUD* no1=quad->get_noeud1();    
            MG_NOEUD* no2=quad->get_noeud2();    
            MG_NOEUD* no3=quad->get_noeud3();    
            MG_NOEUD* no4=quad->get_noeud4();    
            int val=no1->get_nouveau_numero()+no2->get_nouveau_numero()+no3->get_nouveau_numero()+no4->get_nouveau_numero();
            if (val<nb) 
                listeasupprimer.push_back(quad->get_id());
            }
    for (int i=0;i<listeasupprimer.size();i++)
        mai->supprimer_mg_quadrangleid(listeasupprimer[i]);
    
    
}
Revision:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (10 months, 4 weeks ago) by francois
File size:	11029 byte(s)
Log Message:	compatibilité Ubuntu 22.04 Suppression des refeences à Windows Ajout d'une banière
#	User	Rev	Content
1	francois	1158	//####//------------------------------------------------------------
2			//####//------------------------------------------------------------
3			//####// MAGiC
4			//####// Jean Christophe Cuilliere et Vincent FRANCOIS
5			//####// Departement de Genie Mecanique - UQTR
6			//####//------------------------------------------------------------
7			//####// MAGIC est un projet de recherche de l equipe ERICCA
8			//####// du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
9			//####// http://www.uqtr.ca/ericca
10			//####// http://www.uqtr.ca/
11			//####//------------------------------------------------------------
12			//####//------------------------------------------------------------
13			//####//
14			//####// mailleur2d_structure.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:55 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	francois	1053	#include <stdio.h>
23			#include <math.h>
24			#include "mg_gestionnaire.h"
25			#include "mailleur2d_structure.h"
26			#include "mg_maillage.h"
27			#include "fem_maillage.h"
28			#include "fem_hexa20.h"
29			#include "mg_geometrie.h"
30			#include "mg_sommet_noeud.h"
31			#include "mg_arete_element.h"
32			#include "mg_face_element.h"
33			#include "mg_volume_element.h"
34			#include "tpl_octree.h"
35			#include "mg_maillage_outils.h"
36			#include <vector>
37
38
39			struct integrale
40			{
41			double ti;
42			double li;
43			};
44
45			MAILLEUR2D_STRUCTURE::MAILLEUR2D_STRUCTURE(double xmintmp, double xmaxtmp, double ymintmp, double ymaxtmp, int ntmp, int mtmp, MG_GESTIONNAIRE* gesttmp,int avecgeo,double unit):MAILLEUR(false),xmin(xmintmp),xmax(xmaxtmp),ymin(ymintmp),ymax(ymaxtmp),n(ntmp),m(mtmp),gest(gesttmp),geovirtuel(avecgeo),densitevariable(false),unite(unit),nbfonction(0)
46			{
47			}
48			MAILLEUR2D_STRUCTURE::MAILLEUR2D_STRUCTURE( double xmintmp, double xmaxtmp, double ymintmp, double ymaxtmp, double (fx)(double),double (fy)(double),MG_GESTIONNAIRE* gesttmp,int avecgeo,double unit):MAILLEUR(false),xmin(xmintmp),xmax(xmaxtmp),ymin(ymintmp),ymax(ymaxtmp),gest(gesttmp),geovirtuel(avecgeo),enx(fx),eny(fy),densitevariable(true),unite(unit),nbfonction(0)
49			{
50			}
51
52			MAILLEUR2D_STRUCTURE::MAILLEUR2D_STRUCTURE( MAILLEUR2D_STRUCTURE& mdd):MAILLEUR(mdd),
53			xmin(mdd.xmin),xmax(mdd.xmax),ymin(mdd.ymin),ymax(mdd.ymax),n(mdd.n),m(mdd.m),gest(mdd.gest),nbfonction(mdd.nbfonction)
54			{
55			}
56
57			MAILLEUR2D_STRUCTURE::~MAILLEUR2D_STRUCTURE()
58			{
59			}
60
61
62			void MAILLEUR2D_STRUCTURE::discretise(std::vector<double> &tab,double min,double max,int &nb,double (*en)(double))
63			{
64			double t1=0;
65			double t2=1;
66			std::vector<integrale> tab_integrale;
67			double ti,tii,t;
68			double longueur_metrique=0.;
69			tii=t1;
70			double dt=1./pas;
71			do
72			{
73			ti=tii;
74			tii=ti+(t2-t1)*dt;
75			if (tii>t2) tii=t2;
76			t=0.7886751345ti+0.2113248654tii;
77			double facteur1=(max-min)/(*en)(t);
78			t=0.7886751345tii+0.2113248654ti;
79			double facteur2=(max-min)/(*en)(t);
80			longueur_metrique=longueur_metrique+0.5(tii-ti)(facteur1+facteur2);
81			integrale pas;
82			pas.ti=ti;
83			pas.li=longueur_metrique;
84			tab_integrale.insert(tab_integrale.end(),pas);
85			}
86			while (tii<t2);
87			nb=(int)floor(longueur_metrique);
88			if (longueur_metrique-floor(longueur_metrique)>0.5) nb++;
89			if (nb<1) nb=1;
90			double valeur_cible=longueur_metrique/nb;
91			tab.push_back(min);
92			int nbcree=0;
93			int nb_pas_integrale=tab_integrale.size();
94			for (int i=0;i<nb_pas_integrale;i++)
95			{
96			while ((tab_integrale[i].li>(nbcree+1)*valeur_cible) && (nbcree<nb-1))
97			{
98			double ti=tab_integrale[i].ti;
99			double tii=t2;
100			double li=0.;
101			if (i!=0) li=tab_integrale[i-1].li;
102			double lii=tab_integrale[i].li;
103			if (i!=nb_pas_integrale-1) tii=tab_integrale[i+1].ti;
104			t=ti+(tii-ti)/(lii-li)((nbcree+1)valeur_cible-li);
105			double x=min+t*(max-min);
106			tab.push_back(x);
107			nbcree++;
108			}
109			}
110			tab.push_back(max);
111
112			}
113			void MAILLEUR2D_STRUCTURE::ajouter_fonction_geometrie(int nb)
114			{
115			nbfonction=nb;
116			}
117
118			int MAILLEUR2D_STRUCTURE::maille(MG_GROUPE_TOPOLOGIQUE* mggt)
119			{
120			affiche((char*)"Création d'un maillage MG structuré");
121			double intx, inty;
122			std::vector<double> tabx,taby;
123			if (densitevariable==false)
124			{
125			intx=fabs(xmax-xmin)/n;
126			inty=fabs(ymax-ymin)/m;
127			}
128			else
129			{
130			discretise(tabx,xmin,xmax,n,enx);
131			discretise(taby,ymin,ymax,m,eny);
132			}
133
134			MG_GEOMETRIE* geo=NULL;
135			MG_SOMMET_NOEUD *som1=NULL;
136			MG_SOMMET_NOEUD *som2=NULL;
137			MG_SOMMET_NOEUD *som3=NULL;
138			MG_SOMMET_NOEUD *som4=NULL;
139			MG_ARETE_ELEMENT* are1=NULL;
140			MG_ARETE_ELEMENT* are2=NULL;
141			MG_ARETE_ELEMENT* are3=NULL;
142			MG_ARETE_ELEMENT* are4=NULL;
143			MG_FACE_ELEMENT* face1=NULL;
144			if (geovirtuel==true)
145			{
146			geo=new MG_GEOMETRIE((char)"VIRTUEL",(char)"VIRTUEL");
147			geo->change_valeur_unite(unite);
148			gest->ajouter_mg_geometrie(geo);
149			som1=new MG_SOMMET_NOEUD(NULL);
150			geo->ajouter_mg_sommet(som1);
151			som2=new MG_SOMMET_NOEUD(NULL);
152			geo->ajouter_mg_sommet(som2);
153			som3=new MG_SOMMET_NOEUD(NULL);
154			geo->ajouter_mg_sommet(som3);
155			som4=new MG_SOMMET_NOEUD(NULL);
156			geo->ajouter_mg_sommet(som4);
157			are1=new MG_ARETE_ELEMENT();
158			geo->ajouter_mg_arete(are1);
159			are2=new MG_ARETE_ELEMENT();
160			geo->ajouter_mg_arete(are2);
161			are3=new MG_ARETE_ELEMENT();
162			geo->ajouter_mg_arete(are3);
163			are4=new MG_ARETE_ELEMENT();
164			geo->ajouter_mg_arete(are4);
165			face1=new MG_FACE_ELEMENT();
166			geo->ajouter_mg_face(face1);
167			for (int i=0;i<nbfonction;i++)
168			{
169			MG_GEOM_FONCTION *fonc=new MG_GEOM_FONCTION(0);
170			geo->ajouter_mg_geom_fonction(fonc);
171			}
172			}
173			MG_MAILLAGE* mai=new MG_MAILLAGE(geo);
174			gest->ajouter_mg_maillage(mai);
175			std::vector<MG_NOEUD*> vecnod;
176			for (int j=0; j<=m;j++)
177			{
178			for (int i=0; i<=n;i++)
179			{
180			MG_ELEMENT_TOPOLOGIQUE *topo=NULL;
181			if (geovirtuel)
182			{
183			if ((i==0) && (j==0)) topo=som1;
184			else if ((i==0) && (j==m)) topo=som2;
185			else if ((i==0) && (j==m)) topo=som3;
186			else if ((i==0) && (j==0)) topo=som4;
187			else if (j==0) topo=are1;
188			else if (i==n) topo=are2;
189			else if (j==m) topo=are3;
190			else if (j==0) topo=are4;
191			else topo=face1;
192			}
193			double x,y;
194			if (densitevariable==false)
195			{
196			y=ymin+(j*inty);
197			x=xmin+(i*intx);
198			}
199			else
200			{
201			x=tabx[i];
202			y=taby[j];
203			}
204			MG_NOEUD* nou=mai->ajouter_mg_noeud(topo,x,y,0.,MAGIC::ORIGINE::MAILLEUR_AUTO);
205			vecnod.push_back(nou);
206			if (geovirtuel)
207			{
208			if ((i==0) && (j==0)) som1->change_mg_noeud(nou);
209			else if ((i==n) && (j==0) ) som2->change_mg_noeud(nou);
210			else if ((i==n) && (j==m) ) som3->change_mg_noeud(nou);
211			else if ((i==0) && (j==m) ) som4->change_mg_noeud(nou);
212			}
213			}
214			}
215			if (geovirtuel)
216			{
217			for(int i=0; i<n;i++)
218			{
219			int j=0;
220			MG_NOEUD* nod1=vecnod[i+((n+1)*j)];
221			MG_NOEUD* nod2=vecnod[(i+1)+((n+1)*j)];
222			mai->ajouter_mg_segment(are1,nod1,nod2,MAGIC::ORIGINE::MAILLEUR_AUTO);
223			j=m;
224			MG_NOEUD* nod3=vecnod[i+((n+1)*j)];
225			MG_NOEUD* nod4=vecnod[(i+1)+((n+1)*j)];
226			mai->ajouter_mg_segment(are3,nod3,nod4,MAGIC::ORIGINE::MAILLEUR_AUTO);
227			}
228			for(int j=0; j<m;j++)
229			{
230			int i=0;
231			MG_NOEUD* nod1=vecnod[i+((n+1)*j)];
232			MG_NOEUD* nod2=vecnod[i+((n+1)*(j+1))];
233			mai->ajouter_mg_segment(are4,nod1,nod2,MAGIC::ORIGINE::MAILLEUR_AUTO);
234			i=n;
235			MG_NOEUD* nod3=vecnod[i+((n+1)*j)];
236			MG_NOEUD* nod4=vecnod[i+((n+1)*(j+1))];
237			mai->ajouter_mg_segment(are2,nod3,nod4,MAGIC::ORIGINE::MAILLEUR_AUTO);
238			}
239			}
240			for (int i=0;i<n;i++)
241			for (int j=0;j<m;j++)
242			{
243			MG_NOEUD* nod1=vecnod[i+((n+1)*j)];
244			MG_NOEUD* nod2=vecnod[(i+1)+((n+1)*j)];
245			MG_NOEUD* nod3=vecnod[(i+1)+((n+1)*(j+1))];
246			MG_NOEUD* nod4=vecnod[i+((n+1)*(j+1))];
247			mai->ajouter_mg_quadrangle(face1,nod1,nod4,nod3,nod2,MAGIC::ORIGINE::MAILLEUR_AUTO);
248			}
249
250			BOITE_3D b(xmin,ymin,0.,xmax,ymax,0.);
251			mai->change_param_structure(b,n,m,0);
252			/affiche((char)"Création d'un maillage FEM structuré");
253			FEM_MAILLAGE* fem = new FEM_MAILLAGE(geo, mai,1);
254			gest->ajouter_fem_maillage(fem);
255			fem->construire();*/
256			return OK;
257			}
258
259
260			void MAILLEUR2D_STRUCTURE::ajuste(class MG_MAILLAGE* mai, MG_MAILLAGE* maibase, int nb)
261			{
262			LISTE_MG_NOEUD::iterator it;
263			double xmin=1e300,ymin=1e300,zmin=1e300;
264			double xmax=-1e300,ymax=-1e300,zmax=-1e300;
265			TPL_LISTE_ENTITE<MG_NOEUD*> lst;
266			for (MG_NOEUD* no=maibase->get_premier_noeud(it);no!=NULL;no=maibase->get_suivant_noeud(it))
267			{
268			if (no->get_x()<xmin) xmin=no->get_x();
269			if (no->get_y()<ymin) ymin=no->get_y();
270			if (no->get_z()<zmin) zmin=no->get_z();
271			if (no->get_x()>xmax) xmax=no->get_x();
272			if (no->get_y()>ymax) ymax=no->get_y();
273			if (no->get_z()>zmax) zmax=no->get_z();
274			lst.ajouter(no);
275			}
276			BOITE_3D b(xmin,ymin,zmin,xmax,ymax,zmax);
277			b.change_grosseur(1.05);
278			TPL_OCTREE<MG_TRIANGLE,MG_NOEUD> oc;
279			oc.initialiser(&lst,1,b.get_xmin(),b.get_xmin(),b.get_zmin(),b.get_xmax(),b.get_xmax(),b.get_zmax());
280			LISTE_MG_TRIANGLE::iterator itt;
281			for (MG_TRIANGLE* tri=maibase->get_premier_triangle(itt);tri!=NULL;tri=maibase->get_suivant_triangle(itt))
282			oc.inserer(tri);
283
284			for (MG_NOEUD* no=mai->get_premier_noeud(it);no!=NULL;no=mai->get_suivant_noeud(it))
285			{
286			double x=no->get_x();
287			double y=no->get_y();
288			double z=no->get_z();
289			TPL_MAP_ENTITE<MG_TRIANGLE*> lsttrouve;
290			oc.rechercher(x,y,z,1e-7,lsttrouve);
291			TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR itf;
292			bool trouve=false;
293			for (MG_TRIANGLE* tri=lsttrouve.get_premier(itf);tri!=NULL;tri=lsttrouve.get_suivant(itf))
294			{
295			MG_MAILLAGE_OUTILS ot;
296			int res=ot.estdansletriangle(tri,x,y,z);
297			int val=ot.compare_etat_triangle(res,MG_MAILLAGE_OUTILS::INTERIEUR);
298			if (val>0) trouve=true;
299			}
300			if (trouve) no->change_nouveau_numero(1); else no->change_nouveau_numero(0);
301			}
302			LISTE_MG_QUADRANGLE::iterator itq;
303			std::vector<unsigned long> listeasupprimer;
304			for (MG_QUADRANGLE* quad=mai->get_premier_quadrangle(itq);quad!=NULL;quad=mai->get_suivant_quadrangle(itq))
305			{
306			MG_NOEUD* no1=quad->get_noeud1();
307			MG_NOEUD* no2=quad->get_noeud2();
308			MG_NOEUD* no3=quad->get_noeud3();
309			MG_NOEUD* no4=quad->get_noeud4();
310			int val=no1->get_nouveau_numero()+no2->get_nouveau_numero()+no3->get_nouveau_numero()+no4->get_nouveau_numero();
311			if (val<nb)
312			listeasupprimer.push_back(quad->get_id());
313			}
314			for (int i=0;i<listeasupprimer.size();i++)
315			mai->supprimer_mg_quadrangleid(listeasupprimer[i]);
316
317
318
319			}