mailleur2d_optimisation.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mailleur2d_optimisation.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:55 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "mailleur2d_optimisation.h"
#include "m3d_triangle.h"
#include "mg_gestionnaire.h"
#include "ot_decalage_parametre.h"
#include <math.h>
#include <string.h>
 
 
MAILLEUR2D_OPTIMISATION::MAILLEUR2D_OPTIMISATION(MG_MAILLAGE* mgmai,int niv):MAILLEUR(false),mg_maillage(mgmai),niveau_optimisation(niv)
{
}
 
MAILLEUR2D_OPTIMISATION::~MAILLEUR2D_OPTIMISATION()
{
}
 
void MAILLEUR2D_OPTIMISATION::change_niveau_optimisation(int num)
{
    niveau_optimisation=num;
}
 
int MAILLEUR2D_OPTIMISATION::get_niveau_optimisation(void)
{
    return niveau_optimisation;
}
 
void MAILLEUR2D_OPTIMISATION::optimise(MG_VOLUME* mgvolume)
{
LISTE_MG_TRIANGLE::iterator ittr;
TPL_MAP_ENTITE<M3D_TRIANGLE*> lsttrim3d;
for (MG_TRIANGLE* tri=mg_maillage->get_premier_triangle(ittr);tri!=NULL;tri=mg_maillage->get_suivant_triangle(ittr))
  {
  M3D_TRIANGLE* nvtri=new M3D_TRIANGLE(tri->get_id(),tri->get_lien_topologie(),tri->get_noeud1(),tri->get_noeud2(),tri->get_noeud3(),tri->get_segment1(),tri->get_segment2(),tri->get_segment3(),tri->get_origine());  
  lsttrim3d.ajouter(nvtri);
  }
 
TPL_MAP_ENTITE<M3D_TRIANGLE*>::ITERATEUR it2;
TPL_MAP_ENTITE<MG_NOEUD*> liste_noeud;
 
 
for (M3D_TRIANGLE* tri=lsttrim3d.get_premier(it2);tri!=NULL;tri=lsttrim3d.get_suivant(it2))
  {
  mg_maillage->supprimer_mg_triangleid(tri->get_id());
  mg_maillage->ajouter_mg_triangle(tri);
  liste_noeud.ajouter(tri->get_noeud1());
  liste_noeud.ajouter(tri->get_noeud2());
  liste_noeud.ajouter(tri->get_noeud3());
  }
  
int nbcoquille=mgvolume->get_nb_mg_coquille();
for (int i=0;i<nbcoquille;i++)
  {
  MG_COQUILLE* coq=mgvolume->get_mg_coquille(i);
  int nbface=coq->get_nb_mg_coface();
  for (int j=0;j<nbface;j++)
    {
    MG_FACE* face=coq->get_mg_coface(j)->get_face();
    optimise_avec_calcul_uv(face);
    }
  }
 
}
 
 
void MAILLEUR2D_OPTIMISATION::optimise(MG_COQUE* mgcoque)
{
LISTE_MG_TRIANGLE::iterator ittr;
TPL_MAP_ENTITE<M3D_TRIANGLE*> lsttrim3d;
for (MG_TRIANGLE* tri=mg_maillage->get_premier_triangle(ittr);tri!=NULL;tri=mg_maillage->get_suivant_triangle(ittr))
  {
  M3D_TRIANGLE* nvtri=new M3D_TRIANGLE(tri->get_id(),tri->get_lien_topologie(),tri->get_noeud1(),tri->get_noeud2(),tri->get_noeud3(),tri->get_segment1(),tri->get_segment2(),tri->get_segment3(),tri->get_origine());  
  lsttrim3d.ajouter(nvtri);
  }
 
TPL_MAP_ENTITE<M3D_TRIANGLE*>::ITERATEUR it2;
TPL_MAP_ENTITE<MG_NOEUD*> liste_noeud;
 
 
for (M3D_TRIANGLE* tri=lsttrim3d.get_premier(it2);tri!=NULL;tri=lsttrim3d.get_suivant(it2))
  {
  mg_maillage->supprimer_mg_triangleid(tri->get_id());
  mg_maillage->ajouter_mg_triangle(tri);
  liste_noeud.ajouter(tri->get_noeud1());
  liste_noeud.ajouter(tri->get_noeud2());
  liste_noeud.ajouter(tri->get_noeud3());
  }
  
int nbcoquille=mgcoque->get_nb_mg_coquille();
for (int i=0;i<nbcoquille;i++)
  {
  MG_COQUILLE* coq=mgcoque->get_mg_coquille(i);
  int nbface=coq->get_nb_mg_coface();
  for (int j=0;j<nbface;j++)
    {
    MG_FACE* face=coq->get_mg_coface(j)->get_face();
    optimise_avec_calcul_uv(face);
    }
  }
 
}
void MAILLEUR2D_OPTIMISATION::optimise_avec_calcul_uv(MG_FACE* mgface)
{
TPL_MAP_ENTITE<MG_NOEUD*> liste_noeud;
TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;  
for (MG_TRIANGLE *mgtri=(MG_TRIANGLE*)mgface->get_lien_maillage()->get_premier(it);mgtri!=NULL;mgtri=(MG_TRIANGLE*)mgface->get_lien_maillage()->get_suivant(it))
  {
  if (mg_maillage->get_mg_triangleid(mgtri->get_id())!=mgtri) continue;
  liste_noeud.ajouter(mgtri->get_noeud1());
  liste_noeud.ajouter(mgtri->get_noeud2());
  liste_noeud.ajouter(mgtri->get_noeud3());
  }
TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR it2;
for (MG_NOEUD* no=liste_noeud.get_premier(it2);no!=NULL;no=liste_noeud.get_suivant(it2))
  {
  double uv[2];
  double *xyz=no->get_coord();
  mgface->inverser(uv,xyz);
  no->change_u(uv[0]);
  no->change_v(uv[1]);
  }
  reinit();
  optimise(mgface);
}
 
 
 
void MAILLEUR2D_OPTIMISATION::reinit(void)
{
  lst_tri[0].clear();
  lst_tri[1].clear();
  lst_triid[0].clear();
  lst_triid[1].clear();
}
 
 
void MAILLEUR2D_OPTIMISATION::ajouter_ordre_tri(M3D_TRIANGLE* tri,int num)
{
    double val;
    if (num==0) val=tri->get_qualite();
    if (num==1) val=1./tri->get_qualite();
    std::pair<double,M3D_TRIANGLE*> tmp(val,tri);
    ORDRE_TRIANGLE::iterator p=lst_tri[num].insert(tmp);
    lst_triid[num][tri->get_id()]=p;
}
 
 
void MAILLEUR2D_OPTIMISATION::supprimer_ordre_tri(M3D_TRIANGLE* tri)
{
    int num=0;
    ORDRE_TRIANGLE_PARID::iterator it=lst_triid[num].find(tri->get_id());
    if (it==lst_triid[num].end())
    {
        num=1;
        it=lst_triid[num].find(tri->get_id());
    }
    if (it==lst_triid[num].end()) return;
    lst_tri[num].erase(it->second);
    lst_triid[num].erase(it);
}
 
 
void MAILLEUR2D_OPTIMISATION::optimise(MG_FACE* mgface)
{
periode_u=mgface->get_surface()->get_periode_u();
periode_v=mgface->get_surface()->get_periode_v();
decalage=new OT_DECALAGE_PARAMETRE(periode_u,periode_v);
std::vector<int> strategie;
char* code=(char*)param.get_nom("Optimisation_2D").c_str();
for (int i=0;i<strlen(code);i++)
  {
  if (code[i]=='1') strategie.push_back(1);
  if (code[i]=='2') strategie.push_back(2);
  if (code[i]=='3') strategie.push_back(3);
  if (code[i]=='4') strategie.push_back(4);
  }
 
int nb_level=strategie.size();
std::string info="       stratégie d'optimisation ";
for (int level=0;level<nb_level;level++)
{
char chaine[10];
sprintf(chaine,"%d",strategie[level]);
info = info + chaine;
reinit();
TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;  
for (MG_TRIANGLE *mgtri=(MG_TRIANGLE*)mgface->get_lien_maillage()->get_premier(it);mgtri!=NULL;mgtri=(MG_TRIANGLE*)mgface->get_lien_maillage()->get_suivant(it))
  {
  if (mg_maillage->get_mg_triangleid(mgtri->get_id())!=mgtri) continue;
  M3D_TRIANGLE* mtri=(M3D_TRIANGLE*)mgtri;
  double qual=OPERATEUR::qualite_triangle(mtri->get_noeud1()->get_coord(),mtri->get_noeud2()->get_coord(),mtri->get_noeud3()->get_coord());
  mtri->change_qualite(qual);
  if (mtri->get_qualite()<0.1*niveau_optimisation) 
             ajouter_ordre_tri(mtri,0);                                        
  }
 
for (int phase=0;phase<2;phase++)
        {
        int ok=0;
        do
                {
                ORDRE_TRIANGLE::iterator i=lst_tri[phase].begin();
                if (i==lst_tri[phase].end())
                        {
                        ok=1;
                        continue;
                        }
                M3D_TRIANGLE* tri=(*i).second;
                supprimer_ordre_tri(tri);
                switch (strategie[level])
                    {
                    case 1: operateur_bouge_de_point(phase,mgface,tri);
                            break;
                    case 2: operateur_inverse_diagonale(phase,mgface,&tri);
                            break;
                    case 3: operateur_bouge_de_point(phase,mgface,tri);
                            operateur_inverse_diagonale(phase,mgface,&tri);
                            break;
                    case 4: operateur_inverse_diagonale(phase,mgface,&tri);
                            if (tri!=NULL) operateur_bouge_de_point(phase,mgface,tri);
                            break;
                    }
                if (tri!=NULL)
                if ((tri->get_qualite()<0.1*niveau_optimisation) && (phase==0))
                        ajouter_ordre_tri(tri,1);
                }
        while (ok==0);
        }
}
affiche((char*)info.c_str());
delete decalage;
}
 
int MAILLEUR2D_OPTIMISATION::inverse_diagonale(MG_FACE* face,int num,M3D_TRIANGLE* tri,M3D_TRIANGLE** autretri,double &crit,MG_NOEUD** tabnoeudres)
{
MG_SEGMENT* seg;
MG_NOEUD* no1;
MG_NOEUD* no2;
MG_NOEUD* no3;
if (tri->get_origine()==MAGIC::ORIGINE::IMPOSE) return 0;  
if (num==0)
    {
    seg=tri->get_segment1();
    no1=tri->get_noeud1();
    no2=tri->get_noeud2();
    no3=tri->get_noeud3();
    }
else if (num==1)
    {
    seg=tri->get_segment2();
    no1=tri->get_noeud2();
    no2=tri->get_noeud3();
    no3=tri->get_noeud1();
    }
else if (num==2)
    {
    seg=tri->get_segment3();
    no1=tri->get_noeud3();
    no2=tri->get_noeud1();
    no3=tri->get_noeud2();
    }
else return 0;
if (seg->get_lien_topologie()!=face) return 0;
 
 
*autretri=NULL;
for (int i=0;i<no1->get_lien_triangle()->get_nb();i++)
  for (int j=0;j<no2->get_lien_triangle()->get_nb();j++)
      {
      MG_TRIANGLE* tri1=no1->get_lien_triangle()->get(i);
      MG_TRIANGLE* tri2=no2->get_lien_triangle()->get(j);
      if (tri1==tri2)
       if (tri1!=tri) *autretri=(M3D_TRIANGLE*)tri1;      
      } 
if ((*autretri)==NULL) return 0;
if ((*autretri)->get_origine()==MAGIC::ORIGINE::IMPOSE) return 0;   
MG_NOEUD* no4;
if (((*autretri)->get_noeud1()!=no1) && ((*autretri)->get_noeud1()!=no2)) no4=(*autretri)->get_noeud1();
if (((*autretri)->get_noeud2()!=no1) && ((*autretri)->get_noeud2()!=no2)) no4=(*autretri)->get_noeud2();
if (((*autretri)->get_noeud3()!=no1) && ((*autretri)->get_noeud3()!=no2)) no4=(*autretri)->get_noeud3();
double qual1=tri->get_qualite();
double qual2=(*autretri)->get_qualite();
double qualmin=std::min(qual1,qual2);
double nqual1=OPERATEUR::qualite_triangle(no1->get_coord(),no4->get_coord(),no3->get_coord());
double nqual2=OPERATEUR::qualite_triangle(no2->get_coord(),no3->get_coord(),no4->get_coord());
OT_VECTEUR_3D n1n3(no1->get_coord(),no3->get_coord());
OT_VECTEUR_3D n1n4(no1->get_coord(),no4->get_coord());
double xyznormal[3];
double uv[2]={no1->get_u(),no1->get_v()};
face->calcul_normale_unitaire(uv,xyznormal);
OT_VECTEUR_3D normalface(xyznormal);
OT_VECTEUR_3D normal=normalface&n1n3;
normal.norme();
n1n4.norme();
if (normal*n1n4<0.0001) nqual1=0.;
OT_VECTEUR_3D n2n4(no2->get_coord(),no4->get_coord());
OT_VECTEUR_3D n2n3(no2->get_coord(),no3->get_coord());
double uv2[2]={no2->get_u(),no2->get_v()};
face->calcul_normale_unitaire(uv2,xyznormal);
OT_VECTEUR_3D normalface2(xyznormal);
OT_VECTEUR_3D normal2=normalface&n2n4;
normal2.norme();
n2n3.norme();
if (normal2*n2n3<0.0001) nqual2=0.;
double nqualmin=std::min(nqual1,nqual2);
if (nqualmin>qualmin) 
    {
    crit=nqualmin;
    tabnoeudres[0]=no1;
    tabnoeudres[1]=no4;
    tabnoeudres[2]=no3;
    tabnoeudres[3]=no2;
    tabnoeudres[4]=no3;
    tabnoeudres[5]=no4;
    return 1;
    }
return 0;
}
 
int MAILLEUR2D_OPTIMISATION::bouge_point(MG_FACE* mgface,MG_NOEUD* mg_noeud,double& crit,double &u,double& v,double& x,double& y, double& z)
{
if (mg_noeud->get_lien_topologie()!=mgface) return 0;
if (mg_noeud->get_origine()==MAGIC::ORIGINE::IMPOSE) return 0;
double du=decalage->calcul_decalage_parametre_u(mg_noeud->get_u());
double dv=decalage->calcul_decalage_parametre_v(mg_noeud->get_v());
double u1=decalage->decalage_parametre_u(mg_noeud->get_u(),du);
double v1=decalage->decalage_parametre_v(mg_noeud->get_v(),dv);
double uopt=0.;
double vopt=0.;
double qual_dep=1.;
int nb_tri=mg_noeud->get_lien_triangle()->get_nb();
for (int i=0;i<nb_tri;i++)
        {
        M3D_TRIANGLE* tri=(M3D_TRIANGLE*)mg_noeud->get_lien_triangle()->get(i);
        qual_dep=std::min(qual_dep,tri->get_qualite());
        MG_NOEUD* no1=tri->get_noeud1();
        MG_NOEUD* no2=tri->get_noeud2();
        MG_NOEUD* no3=tri->get_noeud3();
        MG_NOEUD *noeud1,*noeud2;
        if (no1==mg_noeud)
                {
                noeud1=no2;
                noeud2=no3;
                }
        if (no2==mg_noeud)
                {
                noeud1=no1;
                noeud2=no3;
                }
        if (no3==mg_noeud)
                {
                noeud1=no1;
                noeud2=no2;
                }
        double u2=noeud1->get_u()+du;
        double v2=noeud1->get_v()+dv;
        uopt=uopt+u2;
        vopt=vopt+v2;
        u2=noeud2->get_u()+du;
        v2=noeud2->get_v()+dv;
        uopt=uopt+u2;
        vopt=vopt+v2;
        }
uopt=uopt/2./nb_tri;
vopt=vopt/2./nb_tri;
 
double ddeb=sqrt((u1-uopt)*(u1-uopt)+(v1-vopt)*(v1-vopt));
double alpha=0.5;
double d=alpha*ddeb;
double qual=qual_dep;
double testu[8]={1.,-1.,0.,0.,0.707106781,-0.707106781,-0.707106781,0.707106781};
double testv[8]={0.,0.,1.,-1.,0.707106781,0.707106781,-0.707106781,-0.707106781};
double uu=u1;
double vv=v1;
while (alpha>0.09)
        {
        double qualcoq=0.;
        for (int nb_essai=0;nb_essai<8;nb_essai++)
                {
                double uv[2];
                double xyz[3];
                uv[0]=uu+d*testu[nb_essai]-du;
                uv[1]=vv+d*testv[nb_essai]-dv;
                int valide1=mgface->valide_parametre_u(uv[0]);
                int valide2=mgface->valide_parametre_v(uv[1]);
                if (!((valide1) && (valide2) )) break;
                mgface->evaluer(uv,xyz);
                double qual1=1.;
                for (int i=0;i<nb_tri;i++)
                        {
                        M3D_TRIANGLE* tri=(M3D_TRIANGLE*)mg_noeud->get_lien_triangle()->get(i);
                        MG_NOEUD* no1=tri->get_noeud1();
                        MG_NOEUD* no2=tri->get_noeud2();
                        MG_NOEUD* no3=tri->get_noeud3();
                        double *xyz1=no1->get_coord();
                        double *xyz2=no2->get_coord();
                        double *xyz3=no3->get_coord();
                        if (no1==mg_noeud) xyz1=xyz;
                        if (no2==mg_noeud) xyz2=xyz;
                        if (no3==mg_noeud) xyz3=xyz;
                        double qualtmp=OPERATEUR::qualite_triangle(xyz1,xyz2,xyz3);
                        OT_VECTEUR_3D n1n3(xyz1,xyz3);
                        OT_VECTEUR_3D n1n2(xyz1,xyz2);
                        double xyznormal[3];
                        mgface->calcul_normale_unitaire(uv,xyznormal);
                        OT_VECTEUR_3D normalface(xyznormal);
                        OT_VECTEUR_3D normal=normalface&n1n3;
                        normal.norme();
                        n1n2.norme();
                        if (normal*n1n2<0.0001) qualtmp=0.;
                        if (qualtmp<qual1) qual1=qualtmp;
                        }
                if (qual1>qualcoq)
                        {
                        qualcoq=qual1;
                        crit=qualcoq;
                        u=uv[0]+du;
                        v=uv[1]+dv;
                        }
                }
 
        if (qualcoq<qual+0.0001) alpha=alpha-0.1;
        else
                {
                qual=qualcoq;
                uu=u;
                vv=v;
                }
        d=ddeb*alpha;
 
        }
if (qual>qual_dep)
        {
        u=decalage->decalage_parametre_u(u,-du);
        v=decalage->decalage_parametre_v(v,-dv);
        double uv[2];
        uv[0]=u;
        uv[1]=v;
        double xyz[3];
        mgface->evaluer(uv,xyz);
        x=xyz[0];
        y=xyz[1];
        z=xyz[2];
        return 1;
        }
return 0;
}
 
class M3D_TRIANGLE* MAILLEUR2D_OPTIMISATION::insere_triangle(class MG_FACE* mgface,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,int origine)
{
    MG_SEGMENT* segment1=mg_maillage->get_mg_segment(noeud1->get_id(),noeud2->get_id());
    MG_SEGMENT* segment2=mg_maillage->get_mg_segment(noeud2->get_id(),noeud3->get_id());
    MG_SEGMENT* segment3=mg_maillage->get_mg_segment(noeud3->get_id(),noeud1->get_id());
    if (segment1==NULL) segment1=cree_segment(mgface,noeud1,noeud2,origine);
    if (segment2==NULL) segment2=cree_segment(mgface,noeud2,noeud3,origine);
    if (segment3==NULL) segment3=cree_segment(mgface,noeud3,noeud1,origine);
    M3D_TRIANGLE* tri=cree_triangle(mgface,noeud1,noeud2,noeud3,segment1,segment2,segment3,origine);
    double qual=OPERATEUR::qualite_triangle(noeud1->get_coord(),noeud2->get_coord(),noeud3->get_coord());
    tri->change_qualite(qual);
    return tri;
}
 
 
 
 
void MAILLEUR2D_OPTIMISATION::operateur_bouge_de_point(int phase,MG_FACE* mgface,M3D_TRIANGLE* tri)
{
if (tri->get_qualite()<0.1*niveau_optimisation)
                        {
                        MG_NOEUD* no[3];
                        no[0]=tri->get_noeud1();
                        no[1]=tri->get_noeud2();
                        no[2]=tri->get_noeud3();
                        double crit[3],u[3],v[3],x[3],y[3],z[3];
                        int ierr=bouge_point(mgface,no[0],crit[0],u[0],v[0],x[0],y[0],z[0]);
                        if (ierr==0) crit[0]=0.;
                        ierr=bouge_point(mgface,no[1],crit[1],u[1],v[1],x[1],y[1],z[1]);
                        if (ierr==0) crit[1]=0.;
                        ierr=bouge_point(mgface,no[2],crit[2],u[2],v[2],x[2],y[2],z[2]);
                        if (ierr==0) crit[2]=0.;
                        double critopt=std::max(crit[0],crit[1]);
                        critopt=std::max(critopt,crit[2]);
                        int num=-1;
                        if (critopt>tri->get_qualite())
                                {
                                if (critopt==crit[0]) num=0;
                                if (critopt==crit[1]) num=1;
                                if (critopt==crit[2]) num=2;
                                }
                        if (num!=-1)
                                {
                                no[num]->change_u(u[num]);
                                no[num]->change_v(v[num]);
                                no[num]->change_x(x[num]);
                                no[num]->change_y(y[num]);
                                no[num]->change_z(z[num]);
                                int nb_tri=no[num]->get_lien_triangle()->get_nb();
                                for (int i=0;i<nb_tri;i++)
                                        {
                                        M3D_TRIANGLE* mtri=(M3D_TRIANGLE*)no[num]->get_lien_triangle()->get(i);
                                        double qual=OPERATEUR::qualite_triangle(mtri->get_noeud1()->get_coord(),mtri->get_noeud2()->get_coord(),mtri->get_noeud3()->get_coord());
                                        mtri->change_qualite(qual);
                                        if (mtri!=tri)
                                          {
                                          supprimer_ordre_tri(mtri);
                                          if (mtri->get_qualite()<0.1*niveau_optimisation) ajouter_ordre_tri(mtri,phase);
                                          }
                                          
                                        }
                                }
                        }
}
 
 
void MAILLEUR2D_OPTIMISATION::operateur_inverse_diagonale(int phase,MG_FACE* mgface,M3D_TRIANGLE** tri)
{
if ((*tri)->get_qualite()<0.1*niveau_optimisation)
                    {
                    MG_NOEUD* tab1[6];  
                    MG_NOEUD* tab2[6];  
                    MG_NOEUD* tab3[6];  
                    double crit1,crit2,crit3;
                    M3D_TRIANGLE* autretri1;
                    M3D_TRIANGLE* autretri2;
                    M3D_TRIANGLE* autretri3;
                    int ierr1=inverse_diagonale(mgface,0,*tri,&autretri1,crit1,tab1);
                    int ierr2=inverse_diagonale(mgface,1,*tri,&autretri2,crit2,tab2);
                    int ierr3=inverse_diagonale(mgface,2,*tri,&autretri3,crit3,tab3);
                    double maxcrit=std::max(ierr1*crit1,ierr2*crit2);
                    maxcrit=std::max(maxcrit,ierr3*crit3);
                    MG_NOEUD** tab;
                    M3D_TRIANGLE *autretri;
                    if (maxcrit>(*tri)->get_qualite())  
                          {
                          if (maxcrit==ierr1*crit1)  {tab=tab1;autretri=autretri1;}
                          if (maxcrit==ierr2*crit2)  {tab=tab2;autretri=autretri2;}
                          if (maxcrit==ierr3*crit3)  {tab=tab3;autretri=autretri3;}
                          M3D_TRIANGLE* nvtri1=insere_triangle(mgface,tab[0],tab[1],tab[2],MAGIC::ORIGINE::MAILLEUR_AUTO);
                          M3D_TRIANGLE* nvtri2=insere_triangle(mgface,tab[3],tab[4],tab[5],MAGIC::ORIGINE::MAILLEUR_AUTO);
                          if (nvtri1->get_qualite()<0.1*niveau_optimisation) ajouter_ordre_tri(nvtri1,phase);  
                          if (nvtri2->get_qualite()<0.1*niveau_optimisation) ajouter_ordre_tri(nvtri2,phase);  
                          supprimer_ordre_tri(autretri);
                          mg_maillage->supprimer_mg_triangleid((*tri)->get_id());(*tri)=NULL;
                          mg_maillage->supprimer_mg_triangleid(autretri->get_id());
                          }
                    }
}
M3D_TRIANGLE* MAILLEUR2D_OPTIMISATION::cree_triangle(class MG_FACE* mgface,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_SEGMENT* segment1,MG_SEGMENT* segment2,MG_SEGMENT* segment3,int origine)
{
    M3D_TRIANGLE* tri=new M3D_TRIANGLE(mgface,noeud1,noeud2,noeud3,segment1,segment2,segment3,origine);
    mg_maillage->ajouter_mg_triangle(tri);
    return tri;
}
 
 
 
MG_SEGMENT* MAILLEUR2D_OPTIMISATION::cree_segment(class MG_FACE* mgface,MG_NOEUD* noeud1,MG_NOEUD* noeud2,int origine)
{
    MG_SEGMENT* seg=mg_maillage->ajouter_mg_segment(mgface,noeud1,noeud2,origine);
    seg->change_dimension_topo_null(3);
    return seg;
}