geometrie/src/mg_maillage.cpp

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuilli�re et Vincent FRANCOIS
//  D�partement de G�nie M�canique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du d�partement
//  de g�nie m�canique de l'Universit� du Qu�bec �
//  Trois Rivi�res
//  Les librairies ne peuvent �tre utilis�es sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       mg_maillage.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H22
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"
#include <fstream>
#include <iostream>


#include "mg_maillage.h"
#include "mg_gestionnaire.h"
#include "mc_gestionnaire.h"
#include "mc_propriete.h"
#include "mc_materiau.h"
#include "tpl_map_entite.h"
//#include "message.h"


int MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO=0;


MG_MAILLAGE::MG_MAILLAGE(MG_GEOMETRIE* geo):MG_IDENTIFICATEUR(),mg_geometrie(geo)
{
}

MG_MAILLAGE::MG_MAILLAGE(unsigned long num,MG_GEOMETRIE* geo):MG_IDENTIFICATEUR(num),mg_geometrie(geo)
{
}

MG_MAILLAGE* MG_MAILLAGE::dupliquer(MG_GESTIONNAIRE* gest)
{
    MG_MAILLAGE* mgmai=new MG_MAILLAGE(this->get_mg_geometrie());
    gest->ajouter_mg_maillage(mgmai);
    long decalage=mgmai->get_id()-this->get_id();
    LISTE_ENTITE::const_iterator i;
// D'abord les noeuds (les segments en dependent)
    LISTE_MG_NOEUD::iterator itNo;
    for (MG_NOEUD * noeud = get_premier_noeud(itNo); noeud; noeud=get_suivant_noeud(itNo))
        noeud->dupliquer(mgmai,decalage);
// Ensuite les segments (les triangles en dependent)
    LISTE_MG_SEGMENT::iterator itSeg;
    for (MG_SEGMENT * segment = get_premier_segment(itSeg); segment; segment=get_suivant_segment(itSeg))
        segment->dupliquer(mgmai,decalage);
// Ensuite les triangles (les tetra en dependent)
    LISTE_MG_TRIANGLE::iterator itTri;
    for (MG_TRIANGLE * triangle = get_premier_triangle(itTri); triangle; triangle=get_suivant_triangle(itTri))
        triangle->dupliquer(mgmai,decalage);
// Pour finir les tetra
    LISTE_MG_TETRA::iterator itTetra;
    for (MG_TETRA * tetra = get_premier_tetra(itTetra); tetra; tetra=get_suivant_tetra(itTetra))
        tetra->dupliquer(mgmai,decalage);
    /* bug quand l'identificateur d'un triangle pr�c�de celui de ses segments
    for (i=lst_entite.begin();i!=lst_entite.end();i++)
         {
            MG_ELEMENT_MAILLAGE& ele=(MG_ELEMENT_MAILLAGE&)(*(*i));
            ele.dupliquer(mgmai,decalage);
         }*/
    int nb_segment = get_nb_mg_segment();
    int nb_triangle = get_nb_mg_triangle();
    int nb_tetra = get_nb_mg_tetra();

    for (MG_TRIANGLE * triangle = get_premier_triangle(itTri); triangle; triangle=get_suivant_triangle(itTri))
    {
        MG_TRIANGLE * triangle2 = mgmai->get_mg_triangleid(triangle->get_id()+decalage);

        TPL_LISTE_ENTITE< MG_TETRA*> * lst_lien_tetra = triangle->get_lien_tetra();
        TPL_LISTE_ENTITE< MG_TETRA*> * lst_lien_tetra2 = triangle2->get_lien_tetra();
        for (int it_tetra = 0; it_tetra != lst_lien_tetra->get_nb(); it_tetra++)
        {
            MG_TETRA * t = lst_lien_tetra->get(it_tetra);
            MG_TETRA * t2 = mgmai->get_mg_tetraid( t->get_id() + decalage );

            lst_lien_tetra2->ajouter ( t2 );
        }
    }

    for (MG_SEGMENT * segment = get_premier_segment(itSeg); segment; segment=get_suivant_segment(itSeg))
    {
        MG_SEGMENT * segment2 = mgmai->get_mg_segmentid(segment->get_id()+decalage);

        TPL_LISTE_ENTITE<MG_TRIANGLE*> * lst_lien_triangle = segment->get_lien_triangle();
        TPL_LISTE_ENTITE<MG_TRIANGLE*> * lst_lien_triangle2 = segment2->get_lien_triangle();
        for (int it_triang = 0; it_triang != lst_lien_triangle->get_nb(); it_triang++)
        {
            MG_TRIANGLE * t = lst_lien_triangle->get(it_triang);
            MG_TRIANGLE * t2 = mgmai->get_mg_triangleid( t->get_id() + decalage );

            lst_lien_triangle2->ajouter ( t2 );
        }
    }

    for (MG_NOEUD * n = get_premier_noeud(itNo); n; n=get_suivant_noeud(itNo))
    {
        MG_NOEUD * n2 = mgmai->get_mg_noeudid(n->get_id()+decalage);

        if (nb_segment != 0)
        {
            TPL_LISTE_ENTITE<MG_SEGMENT*> * lst_lien_segment = n->get_lien_segment();
            TPL_LISTE_ENTITE<MG_SEGMENT*> * lst_lien_segment2 = n2->get_lien_segment();
            for (int it_seg = 0; it_seg != lst_lien_segment->get_nb(); it_seg++)
            {
                MG_SEGMENT * seg = lst_lien_segment->get(it_seg);
                MG_SEGMENT * seg2 = mgmai->get_mg_segmentid( seg->get_id() + decalage );

                lst_lien_segment2->ajouter ( seg2 );
            }

            TPL_LISTE_ENTITE< MG_SEGMENT*> * lst_lien_petit_segment = n->get_lien_petit_segment();
            TPL_LISTE_ENTITE< MG_SEGMENT*> * lst_lien_petit_segment2 = n2->get_lien_petit_segment();
            for (int it_seg = 0; it_seg != lst_lien_petit_segment->get_nb(); it_seg++)
            {
                MG_SEGMENT * seg = lst_lien_petit_segment->get(it_seg);
                MG_SEGMENT * seg2 = mgmai->get_mg_segmentid( seg->get_id() + decalage );

                lst_lien_petit_segment2->ajouter ( seg2 );
            }
        }

        if (nb_triangle != 0)
        {
            TPL_LISTE_ENTITE< MG_TRIANGLE*> * lst_lien_triangle = n->get_lien_triangle();
            TPL_LISTE_ENTITE< MG_TRIANGLE*> * lst_lien_triangle2 = n2->get_lien_triangle();
            for (int it_triang = 0; it_triang != lst_lien_triangle->get_nb(); it_triang++)
            {
                MG_TRIANGLE * t = lst_lien_triangle->get(it_triang);
                MG_TRIANGLE * t2 = mgmai->get_mg_triangleid( t->get_id() + decalage );

                lst_lien_triangle2->ajouter ( t2 );
            }

            TPL_LISTE_ENTITE< MG_TRIANGLE*> * lst_lien_petit_triangle = n->get_lien_petit_triangle();
            TPL_LISTE_ENTITE< MG_TRIANGLE*> * lst_lien_petit_triangle2 = n2->get_lien_petit_triangle();
            for (int it_triang = 0; it_triang != lst_lien_petit_triangle->get_nb(); it_triang++)
            {
                MG_TRIANGLE * t = lst_lien_petit_triangle->get(it_triang);
                MG_TRIANGLE * t2 = mgmai->get_mg_triangleid( t->get_id() + decalage );

                lst_lien_petit_triangle2->ajouter ( t2 );
            }
        }

        if (nb_tetra != 0)
        {
            TPL_LISTE_ENTITE< MG_TETRA*> * lst_lien_tetra = n->get_lien_tetra();
            TPL_LISTE_ENTITE< MG_TETRA*> * lst_lien_tetra2 = n2->get_lien_tetra();
            for (int it_tetra = 0; it_tetra != lst_lien_tetra->get_nb(); it_tetra++)
            {
                MG_TETRA * t = lst_lien_tetra->get(it_tetra);
                MG_TETRA * t2 = mgmai->get_mg_tetraid( t->get_id() + decalage );

                lst_lien_tetra2->ajouter ( t2 );
            }

            TPL_LISTE_ENTITE< MG_TETRA*> * lst_lien_petit_tetra = n->get_lien_petit_tetra();
            TPL_LISTE_ENTITE< MG_TETRA*> * lst_lien_petit_tetra2 = n2->get_lien_petit_tetra();
            for (int it_tetra = 0; it_tetra != lst_lien_petit_tetra->get_nb(); it_tetra++)
            {
                MG_TETRA * t = lst_lien_petit_tetra->get(it_tetra);
                MG_TETRA * t2 = mgmai->get_mg_tetraid( t->get_id() + decalage );

                lst_lien_petit_tetra2->ajouter ( t2 );
            }
        }

    }

    return mgmai;
}


MG_MAILLAGE::~MG_MAILLAGE()
{
    supprimer_tout_mg_tetra();
    supprimer_tout_mg_triangle();
    supprimer_tout_mg_segment();
    supprimer_tout_mg_noeud();
}

MG_GEOMETRIE* MG_MAILLAGE::get_mg_geometrie(void)
{
    return mg_geometrie;
}


void MG_MAILLAGE::change_gestionnaire(MG_GESTIONNAIRE* mggest)
{
    gest=mggest;
}

// ENTITE MG_NOEUD
MG_NOEUD*  MG_MAILLAGE::ajouter_mg_noeud(MG_ELEMENT_TOPOLOGIQUE* topo,double xx,double yy,double zz,int origine,unsigned long num)
{
    MG_NOEUD* mgnoeud;
    if (num==0) mgnoeud=new MG_NOEUD(topo,xx,yy,zz,origine);
    else mgnoeud=new MG_NOEUD(num,topo,xx,yy,zz,origine);
    int resultat = ajouter_mg_noeud(mgnoeud);
    if (resultat==FAIL)
    {
        delete mgnoeud;
        return NULL;
    }
    return mgnoeud;
}

int MG_MAILLAGE::ajouter_mg_noeud(MG_NOEUD *mgnoeud)
{
    gest->recherche_bonid(*mgnoeud);
    MG_IDENTIFICATEUR *id=mgnoeud;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_NOEUD*> tmp(mgnoeud->get_id(),mgnoeud);
    lst_mg_noeud.insert(tmp);
    return OK;
}


MG_NOEUD* MG_MAILLAGE::get_mg_noeudid(unsigned long num)
{
    LISTE_MG_NOEUD::iterator i=lst_mg_noeud.find(num);
    if (i==lst_mg_noeud.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_NOEUD* MG_MAILLAGE::get_mg_noeud(unsigned int num)
{
    if (!(num<lst_mg_noeud.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_NOEUD::iterator i=lst_mg_noeud.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_MAILLAGE::get_nb_mg_noeud(void)
{
    return lst_mg_noeud.size();
}


int MG_MAILLAGE::supprimer_mg_noeudid(unsigned long num)
{
    MG_NOEUD* mgnoeud=get_mg_noeudid(num);
    if (mgnoeud==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    if (mgnoeud->get_lien_segment()->get_nb())
    {
//      afficheur << ERRNOEUDSEGMENT << mgnoeud->get_id() << enderr;
        return FAIL;
    }
    if (mgnoeud->get_lien_triangle()->get_nb())
    {
//      afficheur << ERRNOEUDTRIANGLE << mgnoeud->get_id() << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgnoeud;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_NOEUD::iterator j=lst_mg_noeud.find(num);
    lst_mg_noeud.erase(j);
    delete mgnoeud;
    return OK;
}


int MG_MAILLAGE::supprimer_mg_noeud(unsigned int num)
{
    MG_NOEUD* mgnoeud=get_mg_noeud(num);
    if (mgnoeud==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    if (mgnoeud->get_lien_segment()->get_nb())
    {
//      afficheur << ERRNOEUDSEGMENT << mgnoeud->get_id() << enderr;
        return FAIL;
    }
    if (mgnoeud->get_lien_triangle()->get_nb())
    {
//      afficheur << ERRNOEUDTRIANGLE << mgnoeud->get_id() << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgnoeud;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_NOEUD::iterator j=lst_mg_noeud.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_noeud.erase(j);
    delete mgnoeud;
    return OK;
}


void MG_MAILLAGE::supprimer_tout_mg_noeud(void)
{
    while (get_nb_mg_noeud()!=0)
    {
        LISTE_MG_NOEUD::iterator j=lst_mg_noeud.begin();
        MG_NOEUD* mgnoeud=(*j).second;
        MG_IDENTIFICATEUR* id=mgnoeud;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_noeud.erase(j);
        delete mgnoeud;
    }
}


MG_NOEUD* MG_MAILLAGE::get_premier_noeud(LISTE_MG_NOEUD::iterator & it)
{
    it = lst_mg_noeud.begin();
    if (it == lst_mg_noeud.end())
        return NULL;
    return it->second;
}

MG_NOEUD* MG_MAILLAGE::get_suivant_noeud(LISTE_MG_NOEUD::iterator & it)
{
    it++;
    if (it == lst_mg_noeud.end())
        return NULL;
    return it->second;
}


// ENTITE MG_SEGMENT
MG_SEGMENT* MG_MAILLAGE::ajouter_mg_segment(MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,int origine,double longue,unsigned long num)
{
    MG_SEGMENT* mgsegment;
    if (num==0) mgsegment=new MG_SEGMENT(topo,mgnoeud1,mgnoeud2,origine,longue);
    else  mgsegment=new MG_SEGMENT(num,topo,mgnoeud1,mgnoeud2,origine,longue);
    int resultat=ajouter_mg_segment(mgsegment);
    if (resultat==FAIL)
    {
        delete mgsegment;
        return NULL;
    }
    return mgsegment;
}

int MG_MAILLAGE::ajouter_mg_segment(MG_SEGMENT *mgsegment)
{
    gest->recherche_bonid(*mgsegment);
    MG_IDENTIFICATEUR *id=mgsegment;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_SEGMENT*> tmp(mgsegment->get_id(),mgsegment);
    lst_mg_segment.insert(tmp);
    return OK;
}


MG_SEGMENT* MG_MAILLAGE::get_mg_segmentid(unsigned long num)
{
    LISTE_MG_SEGMENT::iterator i=lst_mg_segment.find(num);
    if (i==lst_mg_segment.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}

MG_SEGMENT* MG_MAILLAGE::get_mg_segment(unsigned long  noeud1id,unsigned long noeud2id)
{
    unsigned long id=std::min(noeud1id,noeud2id);
    MG_NOEUD* noeud=get_mg_noeudid(id);
    int nb_segment=noeud->get_lien_petit_segment()->get_nb();
    for (int i=0;i<nb_segment;i++)
    {
        MG_SEGMENT* mgsegment=noeud->get_lien_petit_segment()->get(i);
        if ( (mgsegment->get_noeud1()->get_id()==noeud1id) && (mgsegment->get_noeud2()->get_id()==noeud2id) ) return mgsegment;
        if ( (mgsegment->get_noeud2()->get_id()==noeud1id) && (mgsegment->get_noeud1()->get_id()==noeud2id) ) return mgsegment;
    }
    return NULL;
}

MG_SEGMENT* MG_MAILLAGE::get_mg_segment(unsigned int num)
{
    if (!(num<lst_mg_segment.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_SEGMENT::iterator i=lst_mg_segment.begin();
//for (unsigned long j=0;j<num;j++) i++;
    std::advance(i,num);
    return ((*i).second);
}

MG_SEGMENT* MG_MAILLAGE::get_premier_segment(LISTE_MG_SEGMENT::iterator & it)
{
    it = lst_mg_segment.begin();
    if (it == lst_mg_segment.end())
        return NULL;
    return it->second;
}

MG_SEGMENT* MG_MAILLAGE::get_suivant_segment(LISTE_MG_SEGMENT::iterator & it)
{
    it++;
    if (it == lst_mg_segment.end())
        return NULL;
    return it->second;
}

unsigned int MG_MAILLAGE::get_nb_mg_segment(void)
{
    return lst_mg_segment.size();
}


int MG_MAILLAGE::supprimer_mg_segmentid(unsigned long num)
{
    MG_SEGMENT* mgsegment=get_mg_segmentid(num);
    if (mgsegment==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsegment;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_SEGMENT::iterator j=lst_mg_segment.find(num);
    lst_mg_segment.erase(j);
    MG_NOEUD* noeud1=mgsegment->get_noeud1();
    MG_NOEUD* noeud2=mgsegment->get_noeud2();
    delete mgsegment;
    if (noeud1->get_nb_reference()==0)
        if (noeud1->get_lien_topologie()!=NULL)
        {
            if (noeud1->get_lien_topologie()->get_dimension()>0)  supprimer_mg_noeudid(noeud1->get_id());
        }
        else supprimer_mg_noeudid(noeud1->get_id());
    if (noeud2->get_nb_reference()==0)
        if (noeud2->get_lien_topologie()!=NULL)
        {
            if (noeud2->get_lien_topologie()->get_dimension()>0)  supprimer_mg_noeudid(noeud2->get_id());
        }
        else supprimer_mg_noeudid(noeud2->get_id());
    return OK;
}


int MG_MAILLAGE::supprimer_mg_segment(unsigned int num)
{
    MG_SEGMENT* mgsegment=get_mg_segment(num);
    if (mgsegment==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsegment;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_SEGMENT::iterator j=lst_mg_segment.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_segment.erase(j);
    MG_NOEUD* noeud1=mgsegment->get_noeud1();
    MG_NOEUD* noeud2=mgsegment->get_noeud2();
    delete mgsegment;
    if (noeud1->get_nb_reference()==0)
        if (noeud1->get_lien_topologie()!=NULL)
        {
            if (noeud1->get_lien_topologie()->get_dimension()>0)  supprimer_mg_noeudid(noeud1->get_id());
        }
        else supprimer_mg_noeudid(noeud1->get_id());
    if (noeud2->get_nb_reference()==0)
        if (noeud2->get_lien_topologie()!=NULL)
        {
            if (noeud2->get_lien_topologie()->get_dimension()>0)  supprimer_mg_noeudid(noeud2->get_id());
        }
        else supprimer_mg_noeudid(noeud2->get_id());
    return OK;
}


void MG_MAILLAGE::supprimer_tout_mg_segment(void)
{
    while (get_nb_mg_segment()!=0)
    {
        LISTE_MG_SEGMENT::iterator j=lst_mg_segment.begin();
        MG_SEGMENT* mgsegment=(*j).second;
        MG_IDENTIFICATEUR* id=mgsegment;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_segment.erase(j);
        delete mgsegment;
    }

}

// ENTITE MG_TRIANGLE

MG_TRIANGLE* MG_MAILLAGE::ajouter_mg_triangle(MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,class MG_NOEUD *mgnoeud3,int origine,unsigned long num)
{
    MG_SEGMENT* mgsegment1=get_mg_segment(mgnoeud1->get_id(),mgnoeud2->get_id());
    MG_SEGMENT* mgsegment2=get_mg_segment(mgnoeud2->get_id(),mgnoeud3->get_id());
    MG_SEGMENT* mgsegment3=get_mg_segment(mgnoeud3->get_id(),mgnoeud1->get_id());
    if (mgsegment1==NULL) mgsegment1=ajouter_mg_segment(topo,mgnoeud1,mgnoeud2,origine);
    if (mgsegment2==NULL) mgsegment2=ajouter_mg_segment(topo,mgnoeud2,mgnoeud3,origine);
    if (mgsegment3==NULL) mgsegment3=ajouter_mg_segment(topo,mgnoeud3,mgnoeud1,origine);
    MG_TRIANGLE* mgtriangle;
    if (num==0) mgtriangle=new MG_TRIANGLE(topo,mgnoeud1,mgnoeud2,mgnoeud3,mgsegment1,mgsegment2,mgsegment3,origine);
    else  mgtriangle=new MG_TRIANGLE(num,topo,mgnoeud1,mgnoeud2,mgnoeud3,mgsegment1,mgsegment2,mgsegment3,origine);
    int resultat=ajouter_mg_triangle(mgtriangle);
    if (resultat==FAIL)
    {
        delete mgtriangle;
        return NULL;
    }
    return mgtriangle;
}


int MG_MAILLAGE::ajouter_mg_triangle(MG_TRIANGLE *mgtriangle)
{
    gest->recherche_bonid(*mgtriangle);
    MG_IDENTIFICATEUR *id=mgtriangle;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_TRIANGLE*> tmp(mgtriangle->get_id(),mgtriangle);
    lst_mg_triangle.insert(tmp);
    return OK;
}


MG_TRIANGLE* MG_MAILLAGE::get_mg_triangleid(unsigned long num)
{
    LISTE_MG_TRIANGLE::iterator i=lst_mg_triangle.find(num);
    if (i==lst_mg_triangle.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_TRIANGLE* MG_MAILLAGE::get_mg_triangle(unsigned int num)
{
    if (!(num<lst_mg_triangle.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_TRIANGLE::iterator i=lst_mg_triangle.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}

MG_TRIANGLE* MG_MAILLAGE::get_mg_triangle(unsigned long  noeud1id,unsigned long noeud2id,unsigned long noeud3id)
{
    unsigned long id=std::min(noeud1id,noeud2id);
    id=std::min(id,noeud3id);
    MG_NOEUD* noeud=get_mg_noeudid(id);
    int nb_triangle=noeud->get_lien_petit_triangle()->get_nb();
    for (int i=0;i<nb_triangle;i++)
    {
        MG_TRIANGLE* mgtriangle=noeud->get_lien_petit_triangle()->get(i);
        if ( (mgtriangle->get_noeud1()->get_id()==noeud1id) && (mgtriangle->get_noeud2()->get_id()==noeud2id) && (mgtriangle->get_noeud3()->get_id()==noeud3id) ) return mgtriangle;
        if ( (mgtriangle->get_noeud1()->get_id()==noeud1id) && (mgtriangle->get_noeud2()->get_id()==noeud3id) && (mgtriangle->get_noeud3()->get_id()==noeud2id) ) return mgtriangle;
        if ( (mgtriangle->get_noeud1()->get_id()==noeud2id) && (mgtriangle->get_noeud2()->get_id()==noeud1id) && (mgtriangle->get_noeud3()->get_id()==noeud3id) ) return mgtriangle;
        if ( (mgtriangle->get_noeud1()->get_id()==noeud2id) && (mgtriangle->get_noeud2()->get_id()==noeud3id) && (mgtriangle->get_noeud3()->get_id()==noeud1id) ) return mgtriangle;
        if ( (mgtriangle->get_noeud1()->get_id()==noeud3id) && (mgtriangle->get_noeud2()->get_id()==noeud1id) && (mgtriangle->get_noeud3()->get_id()==noeud2id) ) return mgtriangle;
        if ( (mgtriangle->get_noeud1()->get_id()==noeud3id) && (mgtriangle->get_noeud2()->get_id()==noeud2id) && (mgtriangle->get_noeud3()->get_id()==noeud1id) ) return mgtriangle;
    }
    return NULL;
}

unsigned int MG_MAILLAGE::get_nb_mg_triangle(void)
{
    return lst_mg_triangle.size();
}


int MG_MAILLAGE::supprimer_mg_triangleid(unsigned long num)
{
    MG_TRIANGLE* mgtriangle=get_mg_triangleid(num);
    if (mgtriangle==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgtriangle;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_TRIANGLE::iterator j=lst_mg_triangle.find(num);
    lst_mg_triangle.erase(j);
    MG_SEGMENT* segment1=mgtriangle->get_segment1();
    MG_SEGMENT* segment2=mgtriangle->get_segment2();
    MG_SEGMENT* segment3=mgtriangle->get_segment3();
    delete mgtriangle;
    if (segment1->get_nb_reference()==0)
        if (segment1->get_lien_topologie()!=NULL)
        {
            if (segment1->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment1->get_id());
        }
        else supprimer_mg_segmentid(segment1->get_id());
    if (segment2->get_nb_reference()==0)
        if (segment2->get_lien_topologie()!=NULL)
        {
            if (segment2->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment2->get_id());
        }
        else supprimer_mg_segmentid(segment2->get_id());
    if (segment3->get_nb_reference()==0)
        if (segment3->get_lien_topologie()!=NULL)
        {
            if (segment3->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment3->get_id());
        }
        else supprimer_mg_segmentid(segment3->get_id());
    return OK;
}


int MG_MAILLAGE::supprimer_mg_triangle(unsigned int num)
{
    MG_TRIANGLE* mgtriangle=get_mg_triangle(num);
    if (mgtriangle==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgtriangle;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_TRIANGLE::iterator j=lst_mg_triangle.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_triangle.erase(j);
    MG_SEGMENT* segment1=mgtriangle->get_segment1();
    MG_SEGMENT* segment2=mgtriangle->get_segment2();
    MG_SEGMENT* segment3=mgtriangle->get_segment3();
    delete mgtriangle;
    if (segment1->get_nb_reference()==0)
        if (segment1->get_lien_topologie()!=NULL)
        {
            if (segment1->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment1->get_id());
        }
        else supprimer_mg_segmentid(segment1->get_id());
    if (segment2->get_nb_reference()==0)
        if (segment2->get_lien_topologie()!=NULL)
        {
            if (segment2->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment2->get_id());
        }
        else supprimer_mg_segmentid(segment2->get_id());
    if (segment3->get_nb_reference()==0)
        if (segment3->get_lien_topologie()!=NULL)
        {
            if (segment3->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment3->get_id());
        }
        else supprimer_mg_segmentid(segment3->get_id());
    return OK;
}


void MG_MAILLAGE::supprimer_tout_mg_triangle(void)
{
    while (get_nb_mg_triangle()!=0)
    {
        LISTE_MG_TRIANGLE::iterator j=lst_mg_triangle.begin();
        MG_TRIANGLE* mgtriangle=(*j).second;
        MG_IDENTIFICATEUR* id=mgtriangle;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_triangle.erase(j);
        delete mgtriangle;
    }
}


MG_TRIANGLE* MG_MAILLAGE::get_premier_triangle(LISTE_MG_TRIANGLE::iterator & it)
{
    it = lst_mg_triangle.begin();
    if (it == lst_mg_triangle.end())
        return NULL;
    return it->second;
}

MG_TRIANGLE* MG_MAILLAGE::get_suivant_triangle(LISTE_MG_TRIANGLE::iterator & it)
{
    it++;
    if (it == lst_mg_triangle.end())
        return NULL;
    return it->second;
}


// ENTITE MG_QUADRANGLE

MG_QUADRANGLE* MG_MAILLAGE::ajouter_mg_quadrangle(MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,class MG_NOEUD *mgnoeud3,class MG_NOEUD *mgnoeud4,int origine,unsigned long num)
{
    MG_SEGMENT* mgsegment1=get_mg_segment(mgnoeud1->get_id(),mgnoeud2->get_id());
    MG_SEGMENT* mgsegment2=get_mg_segment(mgnoeud2->get_id(),mgnoeud3->get_id());
    MG_SEGMENT* mgsegment3=get_mg_segment(mgnoeud3->get_id(),mgnoeud4->get_id());
    MG_SEGMENT* mgsegment4=get_mg_segment(mgnoeud4->get_id(),mgnoeud1->get_id());
    if (mgsegment1==NULL) mgsegment1=ajouter_mg_segment(topo,mgnoeud1,mgnoeud2,origine);
    if (mgsegment2==NULL) mgsegment2=ajouter_mg_segment(topo,mgnoeud2,mgnoeud3,origine);
    if (mgsegment3==NULL) mgsegment3=ajouter_mg_segment(topo,mgnoeud3,mgnoeud4,origine);
    if (mgsegment4==NULL) mgsegment4=ajouter_mg_segment(topo,mgnoeud4,mgnoeud1,origine);
    MG_QUADRANGLE* mgquadrangle;
    if (num==0) mgquadrangle=new MG_QUADRANGLE(topo,mgnoeud1,mgnoeud2,mgnoeud3,mgnoeud4,mgsegment1,mgsegment2,mgsegment3,mgsegment4,origine);
    else  mgquadrangle=new MG_QUADRANGLE(num,topo,mgnoeud1,mgnoeud2,mgnoeud3,mgnoeud4,mgsegment1,mgsegment2,mgsegment3,mgsegment4,origine);
    int resultat=ajouter_mg_quadrangle(mgquadrangle);
    if (resultat==FAIL)
    {
        delete mgquadrangle;
        return NULL;
    }
    return mgquadrangle;
}


int MG_MAILLAGE::ajouter_mg_quadrangle(MG_QUADRANGLE *mgquadrangle)
{
    gest->recherche_bonid(*mgquadrangle);
    MG_IDENTIFICATEUR *id=mgquadrangle;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_QUADRANGLE*> tmp(mgquadrangle->get_id(),mgquadrangle);
    lst_mg_quadrangle.insert(tmp);
    return OK;
}


MG_QUADRANGLE* MG_MAILLAGE::get_mg_quadrangleid(unsigned long num)
{
    LISTE_MG_QUADRANGLE::iterator i=lst_mg_quadrangle.find(num);
    if (i==lst_mg_quadrangle.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_QUADRANGLE* MG_MAILLAGE::get_mg_quadrangle(unsigned int num)
{
    if (!(num<lst_mg_quadrangle.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_QUADRANGLE::iterator i=lst_mg_quadrangle.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}

MG_QUADRANGLE* MG_MAILLAGE::get_mg_quadrangle(unsigned long  noeud1id,unsigned long noeud2id,unsigned long noeud3id,unsigned long noeud4id)
{
    unsigned long id=std::min(noeud1id,noeud2id);
    id=std::min(id,noeud3id);
    id=std::min(id,noeud4id);
    std::map<unsigned long,unsigned long> map1;
    map1[noeud1id]=noeud1id;
    map1[noeud2id]=noeud2id;
    map1[noeud3id]=noeud3id;
    map1[noeud4id]=noeud4id;
    MG_NOEUD* noeud=get_mg_noeudid(id);
    int nb_quadrangle=noeud->get_lien_petit_quadrangle()->get_nb();
    for (int i=0;i<nb_quadrangle;i++)
    {
        MG_QUADRANGLE* mgquadrangle=noeud->get_lien_petit_quadrangle()->get(i);
        std::map<unsigned long,unsigned long> map2;
        map2[mgquadrangle->get_noeud1()->get_id()]=mgquadrangle->get_noeud1()->get_id();
        map2[mgquadrangle->get_noeud2()->get_id()]=mgquadrangle->get_noeud2()->get_id();
        map2[mgquadrangle->get_noeud3()->get_id()]=mgquadrangle->get_noeud3()->get_id();
        map2[mgquadrangle->get_noeud4()->get_id()]=mgquadrangle->get_noeud4()->get_id();
        std::map<unsigned long,unsigned long>::iterator it1,it2;
        it1=map1.begin();it2=map2.begin();
        int ok=1;
        while (it1!=map1.end()) 
            {
            if ((*it1).first!=(*it2).first) {ok=0;break;}
            it1++;
            it2++;
            }
        if (ok) return mgquadrangle;
    }
    return NULL;
}

unsigned int MG_MAILLAGE::get_nb_mg_quadrangle(void)
{
    return lst_mg_quadrangle.size();
}


int MG_MAILLAGE::supprimer_mg_quadrangleid(unsigned long num)
{
    MG_QUADRANGLE* mgquadrangle=get_mg_quadrangleid(num);
    if (mgquadrangle==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgquadrangle;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_QUADRANGLE::iterator j=lst_mg_quadrangle.find(num);
    lst_mg_quadrangle.erase(j);
    MG_SEGMENT* segment1=mgquadrangle->get_segment1();
    MG_SEGMENT* segment2=mgquadrangle->get_segment2();
    MG_SEGMENT* segment3=mgquadrangle->get_segment3();
    MG_SEGMENT* segment4=mgquadrangle->get_segment4();
    delete mgquadrangle;
    if (segment1->get_nb_reference()==0)
        if (segment1->get_lien_topologie()!=NULL)
        {
            if (segment1->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment1->get_id());
        }
        else supprimer_mg_segmentid(segment1->get_id());
    if (segment2->get_nb_reference()==0)
        if (segment2->get_lien_topologie()!=NULL)
        {
            if (segment2->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment2->get_id());
        }
        else supprimer_mg_segmentid(segment2->get_id());
    if (segment3->get_nb_reference()==0)
        if (segment3->get_lien_topologie()!=NULL)
        {
            if (segment3->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment3->get_id());
        }
        else supprimer_mg_segmentid(segment3->get_id());
    if (segment4->get_nb_reference()==0)
        if (segment4->get_lien_topologie()!=NULL)
        {
            if (segment4->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment4->get_id());
        }
        else supprimer_mg_segmentid(segment4->get_id());
    return OK;
}


int MG_MAILLAGE::supprimer_mg_quadrangle(unsigned int num)
{
    MG_QUADRANGLE* mgquadrangle=get_mg_quadrangle(num);
    if (mgquadrangle==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgquadrangle;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_QUADRANGLE::iterator j=lst_mg_quadrangle.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_quadrangle.erase(j);
    MG_SEGMENT* segment1=mgquadrangle->get_segment1();
    MG_SEGMENT* segment2=mgquadrangle->get_segment2();
    MG_SEGMENT* segment3=mgquadrangle->get_segment3();
    MG_SEGMENT* segment4=mgquadrangle->get_segment4();
    delete mgquadrangle;
    if (segment1->get_nb_reference()==0)
        if (segment1->get_lien_topologie()!=NULL)
        {
            if (segment1->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment1->get_id());
        }
        else supprimer_mg_segmentid(segment1->get_id());
    if (segment2->get_nb_reference()==0)
        if (segment2->get_lien_topologie()!=NULL)
        {
            if (segment2->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment2->get_id());
        }
        else supprimer_mg_segmentid(segment2->get_id());
    if (segment3->get_nb_reference()==0)
        if (segment3->get_lien_topologie()!=NULL)
        {
            if (segment3->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment3->get_id());
        }
        else supprimer_mg_segmentid(segment3->get_id());
    if (segment4->get_nb_reference()==0)
        if (segment4->get_lien_topologie()!=NULL)
        {
            if (segment4->get_lien_topologie()->get_dimension()>1)  supprimer_mg_segmentid(segment4->get_id());
        }
        else supprimer_mg_segmentid(segment4->get_id());
    return OK;
}


void MG_MAILLAGE::supprimer_tout_mg_quadrangle(void)
{
    while (get_nb_mg_quadrangle()!=0)
    {
        LISTE_MG_QUADRANGLE::iterator j=lst_mg_quadrangle.begin();
        MG_QUADRANGLE* mgquadrangle=(*j).second;
        MG_IDENTIFICATEUR* id=mgquadrangle;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_quadrangle.erase(j);
        delete mgquadrangle;
    }
}


MG_QUADRANGLE* MG_MAILLAGE::get_premier_quadrangle(LISTE_MG_QUADRANGLE::iterator & it)
{
    it = lst_mg_quadrangle.begin();
    if (it == lst_mg_quadrangle.end())
        return NULL;
    return it->second;
}

MG_QUADRANGLE* MG_MAILLAGE::get_suivant_quadrangle(LISTE_MG_QUADRANGLE::iterator & it)
{
    it++;
    if (it == lst_mg_quadrangle.end())
        return NULL;
    return it->second;
}
// ENTITE MG_TETRA

MG_TETRA* MG_MAILLAGE::ajouter_mg_tetra(MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,class MG_NOEUD *mgnoeud3,class MG_NOEUD *mgnoeud4,int origine,unsigned long num)
{
    MG_TRIANGLE* mgtriangle1=get_mg_triangle(mgnoeud1->get_id(),mgnoeud3->get_id(),mgnoeud2->get_id());
    MG_TRIANGLE* mgtriangle2=get_mg_triangle(mgnoeud1->get_id(),mgnoeud2->get_id(),mgnoeud4->get_id());
    MG_TRIANGLE* mgtriangle3=get_mg_triangle(mgnoeud2->get_id(),mgnoeud3->get_id(),mgnoeud4->get_id());
    MG_TRIANGLE* mgtriangle4=get_mg_triangle(mgnoeud1->get_id(),mgnoeud4->get_id(),mgnoeud3->get_id());
    if (mgtriangle1==NULL) mgtriangle1=ajouter_mg_triangle(topo,mgnoeud1,mgnoeud3,mgnoeud2,origine);
    if (mgtriangle2==NULL) mgtriangle2=ajouter_mg_triangle(topo,mgnoeud1,mgnoeud2,mgnoeud4,origine);
    if (mgtriangle3==NULL) mgtriangle3=ajouter_mg_triangle(topo,mgnoeud2,mgnoeud3,mgnoeud4,origine);
    if (mgtriangle4==NULL) mgtriangle4=ajouter_mg_triangle(topo,mgnoeud1,mgnoeud4,mgnoeud3,origine);
    MG_TETRA* mgtetra;
    if (num==0) mgtetra=new MG_TETRA(topo,mgnoeud1,mgnoeud2,mgnoeud3,mgnoeud4,mgtriangle1,mgtriangle2,mgtriangle3,mgtriangle4,origine);
    else mgtetra=new MG_TETRA(num,topo,mgnoeud1,mgnoeud2,mgnoeud3,mgnoeud4,mgtriangle1,mgtriangle2,mgtriangle3,mgtriangle4,origine);
    int resultat=ajouter_mg_tetra(mgtetra);
    if (resultat==FAIL)
    {
        delete mgtetra;
        return NULL;
    }
    return mgtetra;
}


int MG_MAILLAGE::ajouter_mg_tetra(MG_TETRA *mgtetra)
{
    gest->recherche_bonid(*mgtetra);
    MG_IDENTIFICATEUR *id=mgtetra;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_TETRA*> tmp(mgtetra->get_id(),mgtetra);
    lst_mg_tetra.insert(tmp);
    return OK;
}


MG_TETRA* MG_MAILLAGE::get_mg_tetraid(unsigned long num)
{
    LISTE_MG_TETRA::iterator i=lst_mg_tetra.find(num);
    if (i==lst_mg_tetra.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_TETRA* MG_MAILLAGE::get_mg_tetra(unsigned int num)
{
    if (!(num<lst_mg_tetra.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_TETRA::iterator i=lst_mg_tetra.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}

MG_TETRA* MG_MAILLAGE::get_mg_tetra(MG_NOEUD*  noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_NOEUD* noeud4)
{
     MG_NOEUD* noeud=noeud1;
     if (noeud2->get_id()<noeud->get_id()) noeud=noeud2;
     if (noeud3->get_id()<noeud->get_id()) noeud=noeud3;
     if (noeud4->get_id()<noeud->get_id()) noeud=noeud4;
     int nb_tetra=noeud->get_lien_petit_tetra()->get_nb();
    for (int i=0;i<nb_tetra;i++)
    {
        MG_TETRA* mgtetra=noeud->get_lien_petit_tetra()->get(i);
        if ( (mgtetra->get_noeud1()==noeud1) && (mgtetra->get_noeud2()==noeud2) && (mgtetra->get_noeud3()==noeud3) && (mgtetra->get_noeud4()==noeud4) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud1) && (mgtetra->get_noeud2()==noeud2) && (mgtetra->get_noeud3()==noeud4) && (mgtetra->get_noeud4()==noeud3) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud1) && (mgtetra->get_noeud2()==noeud3) && (mgtetra->get_noeud3()==noeud2) && (mgtetra->get_noeud4()==noeud4) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud1) && (mgtetra->get_noeud2()==noeud3) && (mgtetra->get_noeud3()==noeud4) && (mgtetra->get_noeud4()==noeud2) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud1) && (mgtetra->get_noeud2()==noeud4) && (mgtetra->get_noeud3()==noeud2) && (mgtetra->get_noeud4()==noeud3) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud1) && (mgtetra->get_noeud2()==noeud4) && (mgtetra->get_noeud3()==noeud3) && (mgtetra->get_noeud4()==noeud2) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud2) && (mgtetra->get_noeud2()==noeud1) && (mgtetra->get_noeud3()==noeud3) && (mgtetra->get_noeud4()==noeud4) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud2) && (mgtetra->get_noeud2()==noeud1) && (mgtetra->get_noeud3()==noeud4) && (mgtetra->get_noeud4()==noeud3) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud2) && (mgtetra->get_noeud2()==noeud3) && (mgtetra->get_noeud3()==noeud1) && (mgtetra->get_noeud4()==noeud4) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud2) && (mgtetra->get_noeud2()==noeud3) && (mgtetra->get_noeud3()==noeud4) && (mgtetra->get_noeud4()==noeud1) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud2) && (mgtetra->get_noeud2()==noeud4) && (mgtetra->get_noeud3()==noeud1) && (mgtetra->get_noeud4()==noeud3) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud2) && (mgtetra->get_noeud2()==noeud4) && (mgtetra->get_noeud3()==noeud3) && (mgtetra->get_noeud4()==noeud1) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud3) && (mgtetra->get_noeud2()==noeud1) && (mgtetra->get_noeud3()==noeud2) && (mgtetra->get_noeud4()==noeud4) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud3) && (mgtetra->get_noeud2()==noeud1) && (mgtetra->get_noeud3()==noeud4) && (mgtetra->get_noeud4()==noeud2) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud3) && (mgtetra->get_noeud2()==noeud2) && (mgtetra->get_noeud3()==noeud1) && (mgtetra->get_noeud4()==noeud4) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud3) && (mgtetra->get_noeud2()==noeud2) && (mgtetra->get_noeud3()==noeud4) && (mgtetra->get_noeud4()==noeud1) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud3) && (mgtetra->get_noeud2()==noeud4) && (mgtetra->get_noeud3()==noeud1) && (mgtetra->get_noeud4()==noeud2) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud3) && (mgtetra->get_noeud2()==noeud4) && (mgtetra->get_noeud3()==noeud2) && (mgtetra->get_noeud4()==noeud1) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud4) && (mgtetra->get_noeud2()==noeud1) && (mgtetra->get_noeud3()==noeud2) && (mgtetra->get_noeud4()==noeud3) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud4) && (mgtetra->get_noeud2()==noeud1) && (mgtetra->get_noeud3()==noeud3) && (mgtetra->get_noeud4()==noeud2) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud4) && (mgtetra->get_noeud2()==noeud2) && (mgtetra->get_noeud3()==noeud1) && (mgtetra->get_noeud4()==noeud3) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud4) && (mgtetra->get_noeud2()==noeud2) && (mgtetra->get_noeud3()==noeud3) && (mgtetra->get_noeud4()==noeud1) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud4) && (mgtetra->get_noeud2()==noeud3) && (mgtetra->get_noeud3()==noeud1) && (mgtetra->get_noeud4()==noeud2) ) return mgtetra;
        if ( (mgtetra->get_noeud1()==noeud4) && (mgtetra->get_noeud2()==noeud3) && (mgtetra->get_noeud3()==noeud2) && (mgtetra->get_noeud4()==noeud1) ) return mgtetra;
    }
    return NULL;
}

unsigned int MG_MAILLAGE::get_nb_mg_tetra(void)
{
    return lst_mg_tetra.size();
}


int MG_MAILLAGE::supprimer_mg_tetraid(unsigned long num)
{
    MG_TETRA* mgtetra=get_mg_tetraid(num);
    if (mgtetra==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgtetra;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_TETRA::iterator j=lst_mg_tetra.find(num);
    lst_mg_tetra.erase(j);
    MG_TRIANGLE* triangle1=mgtetra->get_triangle1();
    MG_TRIANGLE* triangle2=mgtetra->get_triangle2();
    MG_TRIANGLE* triangle3=mgtetra->get_triangle3();
    MG_TRIANGLE* triangle4=mgtetra->get_triangle4();
    delete mgtetra;
    if (triangle1->get_nb_reference()==0)
        if (triangle1->get_lien_topologie()!=NULL)
        {
            if (triangle1->get_lien_topologie()->get_dimension()>2)  supprimer_mg_triangleid(triangle1->get_id());
        }
        else supprimer_mg_triangleid(triangle1->get_id());
    if (triangle2->get_nb_reference()==0)
        if (triangle2->get_lien_topologie()!=NULL)
        {
            if (triangle2->get_lien_topologie()->get_dimension()>2)  supprimer_mg_triangleid(triangle2->get_id());
        }
        else supprimer_mg_triangleid(triangle2->get_id());
    if (triangle3->get_nb_reference()==0)
        if (triangle3->get_lien_topologie()!=NULL)
        {
            if (triangle3->get_lien_topologie()->get_dimension()>2)  supprimer_mg_triangleid(triangle3->get_id());
        }
        else supprimer_mg_triangleid(triangle3->get_id());
    if (triangle4->get_nb_reference()==0)
        if (triangle4->get_lien_topologie()!=NULL)
        {
            if (triangle4->get_lien_topologie()->get_dimension()>2)  supprimer_mg_triangleid(triangle4->get_id());
        }
        else supprimer_mg_triangleid(triangle4->get_id());
    return OK;
}


int MG_MAILLAGE::supprimer_mg_tetra(unsigned int num)
{
    MG_TETRA* mgtetra=get_mg_tetra(num);
    if (mgtetra==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgtetra;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_TETRA::iterator j=lst_mg_tetra.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_tetra.erase(j);
    MG_TRIANGLE* triangle1=mgtetra->get_triangle1();
    MG_TRIANGLE* triangle2=mgtetra->get_triangle2();
    MG_TRIANGLE* triangle3=mgtetra->get_triangle3();
    MG_TRIANGLE* triangle4=mgtetra->get_triangle4();
    delete mgtetra;
    if (triangle1->get_nb_reference()==0)
        if (triangle1->get_lien_topologie()!=NULL)
        {
            if (triangle1->get_lien_topologie()->get_dimension()>2)  supprimer_mg_triangleid(triangle1->get_id());
        }
        else supprimer_mg_triangleid(triangle1->get_id());
    if (triangle2->get_nb_reference()==0)
        if (triangle2->get_lien_topologie()!=NULL)
        {
            if (triangle2->get_lien_topologie()->get_dimension()>2)  supprimer_mg_triangleid(triangle2->get_id());
        }
        else supprimer_mg_triangleid(triangle2->get_id());
    if (triangle3->get_nb_reference()==0)
        if (triangle3->get_lien_topologie()!=NULL)
        {
            if (triangle3->get_lien_topologie()->get_dimension()>2)  supprimer_mg_triangleid(triangle3->get_id());
        }
        else supprimer_mg_triangleid(triangle3->get_id());
    if (triangle4->get_nb_reference()==0)
        if (triangle4->get_lien_topologie()!=NULL)
        {
            if (triangle4->get_lien_topologie()->get_dimension()>2)  supprimer_mg_triangleid(triangle4->get_id());
        }
        else supprimer_mg_triangleid(triangle4->get_id());
    return OK;
}


void MG_MAILLAGE::supprimer_tout_mg_tetra(void)
{
    while (get_nb_mg_tetra()!=0)
    {
        LISTE_MG_TETRA::iterator j=lst_mg_tetra.begin();
        MG_TETRA* mgtetra=(*j).second;
        MG_IDENTIFICATEUR* id=mgtetra;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_tetra.erase(j);
        delete mgtetra;
    }
}


MG_TETRA* MG_MAILLAGE::get_premier_tetra(LISTE_MG_TETRA::iterator & it)
{
    it = lst_mg_tetra.begin();
    if (it == lst_mg_tetra.end())
        return NULL;
    return it->second;
}

MG_TETRA* MG_MAILLAGE::get_suivant_tetra(LISTE_MG_TETRA::iterator & it)
{
    it++;
    if (it == lst_mg_tetra.end())
        return NULL;
    return it->second;
}
// ENTITE MG_HEXA

MG_HEXA* MG_MAILLAGE::ajouter_mg_hexa(MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,class MG_NOEUD *mgnoeud3,class MG_NOEUD *mgnoeud4,class MG_NOEUD *mgnoeud5,class MG_NOEUD *mgnoeud6,class MG_NOEUD *mgnoeud7,class MG_NOEUD *mgnoeud8,int origine,unsigned long num)
{
    MG_QUADRANGLE* mgquadrangle1=get_mg_quadrangle(mgnoeud1->get_id(),mgnoeud2->get_id(),mgnoeud6->get_id(),mgnoeud5->get_id());
    MG_QUADRANGLE* mgquadrangle2=get_mg_quadrangle(mgnoeud2->get_id(),mgnoeud3->get_id(),mgnoeud7->get_id(),mgnoeud6->get_id());
    MG_QUADRANGLE* mgquadrangle3=get_mg_quadrangle(mgnoeud3->get_id(),mgnoeud4->get_id(),mgnoeud8->get_id(),mgnoeud7->get_id());
    MG_QUADRANGLE* mgquadrangle4=get_mg_quadrangle(mgnoeud4->get_id(),mgnoeud1->get_id(),mgnoeud5->get_id(),mgnoeud8->get_id());
    MG_QUADRANGLE* mgquadrangle5=get_mg_quadrangle(mgnoeud1->get_id(),mgnoeud4->get_id(),mgnoeud3->get_id(),mgnoeud2->get_id());
    MG_QUADRANGLE* mgquadrangle6=get_mg_quadrangle(mgnoeud5->get_id(),mgnoeud6->get_id(),mgnoeud7->get_id(),mgnoeud8->get_id());
    if (mgquadrangle1==NULL) mgquadrangle1=ajouter_mg_quadrangle(topo,mgnoeud1,mgnoeud2,mgnoeud6,mgnoeud5,origine);
    if (mgquadrangle2==NULL) mgquadrangle2=ajouter_mg_quadrangle(topo,mgnoeud2,mgnoeud3,mgnoeud7,mgnoeud6,origine);
    if (mgquadrangle3==NULL) mgquadrangle3=ajouter_mg_quadrangle(topo,mgnoeud3,mgnoeud4,mgnoeud8,mgnoeud7,origine);
    if (mgquadrangle4==NULL) mgquadrangle4=ajouter_mg_quadrangle(topo,mgnoeud4,mgnoeud1,mgnoeud5,mgnoeud8,origine);
    if (mgquadrangle5==NULL) mgquadrangle5=ajouter_mg_quadrangle(topo,mgnoeud1,mgnoeud4,mgnoeud3,mgnoeud2,origine);
    if (mgquadrangle6==NULL) mgquadrangle6=ajouter_mg_quadrangle(topo,mgnoeud5,mgnoeud6,mgnoeud7,mgnoeud8,origine);
    MG_HEXA* mghexa;
    if (num==0) mghexa=new MG_HEXA(topo,mgnoeud1,mgnoeud2,mgnoeud3,mgnoeud4,mgnoeud5,mgnoeud6,mgnoeud7,mgnoeud8,mgquadrangle1,mgquadrangle2,mgquadrangle3,mgquadrangle4,mgquadrangle5,mgquadrangle6,origine);
    else mghexa=new MG_HEXA(num,topo,mgnoeud1,mgnoeud2,mgnoeud3,mgnoeud4,mgnoeud5,mgnoeud6,mgnoeud7,mgnoeud8,mgquadrangle1,mgquadrangle2,mgquadrangle3,mgquadrangle4,mgquadrangle5,mgquadrangle6,origine);
    int resultat=ajouter_mg_hexa(mghexa);
    if (resultat==FAIL)
    {
        delete mghexa;
        return NULL;
    }
    return mghexa;
}


int MG_MAILLAGE::ajouter_mg_hexa(MG_HEXA *mghexa)
{
    gest->recherche_bonid(*mghexa);
    MG_IDENTIFICATEUR *id=mghexa;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_HEXA*> tmp(mghexa->get_id(),mghexa);
    lst_mg_hexa.insert(tmp);
    return OK;
}


MG_HEXA* MG_MAILLAGE::get_mg_hexaid(unsigned long num)
{
    LISTE_MG_HEXA::iterator i=lst_mg_hexa.find(num);
    if (i==lst_mg_hexa.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_HEXA* MG_MAILLAGE::get_mg_hexa(unsigned int num)
{
    if (!(num<lst_mg_hexa.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_HEXA::iterator i=lst_mg_hexa.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}

MG_HEXA* MG_MAILLAGE::get_mg_hexa(MG_NOEUD*  noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_NOEUD* noeud4,MG_NOEUD* noeud5,MG_NOEUD* noeud6,MG_NOEUD* noeud7,MG_NOEUD* noeud8)
{
    MG_NOEUD* noeud=noeud1;
    if (noeud2->get_id()<noeud->get_id()) noeud=noeud2;
    if (noeud3->get_id()<noeud->get_id()) noeud=noeud3;
    if (noeud4->get_id()<noeud->get_id()) noeud=noeud4;
    if (noeud5->get_id()<noeud->get_id()) noeud=noeud5;
    if (noeud6->get_id()<noeud->get_id()) noeud=noeud6;
    if (noeud7->get_id()<noeud->get_id()) noeud=noeud7;
    if (noeud8->get_id()<noeud->get_id()) noeud=noeud8;
    
    
    std::map<unsigned long,unsigned long> map1;
    map1[noeud1->get_id()]=noeud1->get_id();
    map1[noeud2->get_id()]=noeud2->get_id();
    map1[noeud3->get_id()]=noeud3->get_id();
    map1[noeud4->get_id()]=noeud4->get_id();
    map1[noeud5->get_id()]=noeud5->get_id();
    map1[noeud6->get_id()]=noeud6->get_id();
    map1[noeud7->get_id()]=noeud7->get_id();
    map1[noeud8->get_id()]=noeud8->get_id();
    int nb_hexa=noeud->get_lien_petit_hexa()->get_nb();
    for (int i=0;i<nb_hexa;i++)
    {
        MG_HEXA* mghexa=noeud->get_lien_petit_hexa()->get(i);
        std::map<unsigned long,unsigned long> map2;
        map2[mghexa->get_noeud1()->get_id()]=mghexa->get_noeud1()->get_id();
        map2[mghexa->get_noeud2()->get_id()]=mghexa->get_noeud2()->get_id();
        map2[mghexa->get_noeud3()->get_id()]=mghexa->get_noeud3()->get_id();
        map2[mghexa->get_noeud4()->get_id()]=mghexa->get_noeud4()->get_id();
        map2[mghexa->get_noeud5()->get_id()]=mghexa->get_noeud5()->get_id();
        map2[mghexa->get_noeud6()->get_id()]=mghexa->get_noeud6()->get_id();
        map2[mghexa->get_noeud7()->get_id()]=mghexa->get_noeud7()->get_id();
        map2[mghexa->get_noeud8()->get_id()]=mghexa->get_noeud8()->get_id();
        std::map<unsigned long,unsigned long>::iterator it1,it2;
        it1=map1.begin();it2=map2.begin();
        int ok=1;
        while (it1!=map1.end()) 
            {
            if ((*it1).first!=(*it2).first) {ok=0;break;}
            it1++;
            it2++;
            }
        if (ok) return mghexa;
    }
    return NULL;

    
}

unsigned int MG_MAILLAGE::get_nb_mg_hexa(void)
{
    return lst_mg_hexa.size();
}


int MG_MAILLAGE::supprimer_mg_hexaid(unsigned long num)
{
    MG_HEXA* mghexa=get_mg_hexaid(num);
    if (mghexa==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mghexa;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_HEXA::iterator j=lst_mg_hexa.find(num);
    lst_mg_hexa.erase(j);
    MG_QUADRANGLE* quadrangle1=mghexa->get_quadrangle1();
    MG_QUADRANGLE* quadrangle2=mghexa->get_quadrangle2();
    MG_QUADRANGLE* quadrangle3=mghexa->get_quadrangle3();
    MG_QUADRANGLE* quadrangle4=mghexa->get_quadrangle4();
    MG_QUADRANGLE* quadrangle5=mghexa->get_quadrangle5();
    MG_QUADRANGLE* quadrangle6=mghexa->get_quadrangle6();
    delete mghexa;
    if (quadrangle1->get_nb_reference()==0)
        if (quadrangle1->get_lien_topologie()!=NULL)
        {
            if (quadrangle1->get_lien_topologie()->get_dimension()>2)  supprimer_mg_quadrangleid(quadrangle1->get_id());
        }
        else supprimer_mg_quadrangleid(quadrangle1->get_id());
    if (quadrangle2->get_nb_reference()==0)
        if (quadrangle2->get_lien_topologie()!=NULL)
        {
            if (quadrangle2->get_lien_topologie()->get_dimension()>2)  supprimer_mg_quadrangleid(quadrangle2->get_id());
        }
        else supprimer_mg_quadrangleid(quadrangle2->get_id());
    if (quadrangle3->get_nb_reference()==0)
        if (quadrangle3->get_lien_topologie()!=NULL)
        {
            if (quadrangle3->get_lien_topologie()->get_dimension()>2)  supprimer_mg_quadrangleid(quadrangle3->get_id());
        }
        else supprimer_mg_quadrangleid(quadrangle3->get_id());
    if (quadrangle4->get_nb_reference()==0)
        if (quadrangle4->get_lien_topologie()!=NULL)
        {
            if (quadrangle4->get_lien_topologie()->get_dimension()>2)  supprimer_mg_quadrangleid(quadrangle4->get_id());
        }
        else supprimer_mg_quadrangleid(quadrangle4->get_id());
    if (quadrangle5->get_nb_reference()==0)
        if (quadrangle5->get_lien_topologie()!=NULL)
        {
            if (quadrangle5->get_lien_topologie()->get_dimension()>2)  supprimer_mg_quadrangleid(quadrangle5->get_id());
        }
        else supprimer_mg_quadrangleid(quadrangle5->get_id());
    if (quadrangle6->get_nb_reference()==0)
        if (quadrangle6->get_lien_topologie()!=NULL)
        {
            if (quadrangle6->get_lien_topologie()->get_dimension()>2)  supprimer_mg_quadrangleid(quadrangle6->get_id());
        }
        else supprimer_mg_quadrangleid(quadrangle6->get_id());
    return OK;
}


int MG_MAILLAGE::supprimer_mg_hexa(unsigned int num)
{
    MG_HEXA* mghexa=get_mg_hexa(num);
    if (mghexa==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mghexa;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_HEXA::iterator j=lst_mg_hexa.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_hexa.erase(j);
    MG_QUADRANGLE* quadrangle1=mghexa->get_quadrangle1();
    MG_QUADRANGLE* quadrangle2=mghexa->get_quadrangle2();
    MG_QUADRANGLE* quadrangle3=mghexa->get_quadrangle3();
    MG_QUADRANGLE* quadrangle4=mghexa->get_quadrangle4();
    MG_QUADRANGLE* quadrangle5=mghexa->get_quadrangle5();
    MG_QUADRANGLE* quadrangle6=mghexa->get_quadrangle6();
    delete mghexa;
    if (quadrangle1->get_nb_reference()==0)
        if (quadrangle1->get_lien_topologie()!=NULL)
        {
            if (quadrangle1->get_lien_topologie()->get_dimension()>2)  supprimer_mg_quadrangleid(quadrangle1->get_id());
        }
        else supprimer_mg_quadrangleid(quadrangle1->get_id());
    if (quadrangle2->get_nb_reference()==0)
        if (quadrangle2->get_lien_topologie()!=NULL)
        {
            if (quadrangle2->get_lien_topologie()->get_dimension()>2)  supprimer_mg_quadrangleid(quadrangle2->get_id());
        }
        else supprimer_mg_quadrangleid(quadrangle2->get_id());
    if (quadrangle3->get_nb_reference()==0)
        if (quadrangle3->get_lien_topologie()!=NULL)
        {
            if (quadrangle3->get_lien_topologie()->get_dimension()>2)  supprimer_mg_quadrangleid(quadrangle3->get_id());
        }
        else supprimer_mg_quadrangleid(quadrangle3->get_id());
    if (quadrangle4->get_nb_reference()==0)
        if (quadrangle4->get_lien_topologie()!=NULL)
        {
            if (quadrangle4->get_lien_topologie()->get_dimension()>2)  supprimer_mg_quadrangleid(quadrangle4->get_id());
        }
        else supprimer_mg_quadrangleid(quadrangle4->get_id());
    if (quadrangle5->get_nb_reference()==0)
        if (quadrangle5->get_lien_topologie()!=NULL)
        {
            if (quadrangle5->get_lien_topologie()->get_dimension()>2)  supprimer_mg_quadrangleid(quadrangle5->get_id());
        }
        else supprimer_mg_quadrangleid(quadrangle5->get_id());
    if (quadrangle6->get_nb_reference()==0)
        if (quadrangle6->get_lien_topologie()!=NULL)
        {
            if (quadrangle6->get_lien_topologie()->get_dimension()>2)  supprimer_mg_quadrangleid(quadrangle6->get_id());
        }
        else supprimer_mg_quadrangleid(quadrangle6->get_id());
    return OK;
}


void MG_MAILLAGE::supprimer_tout_mg_hexa(void)
{
    while (get_nb_mg_hexa()!=0)
    {
        LISTE_MG_HEXA::iterator j=lst_mg_hexa.begin();
        MG_HEXA* mghexa=(*j).second;
        MG_IDENTIFICATEUR* id=mghexa;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_hexa.erase(j);
        delete mghexa;
    }
}


MG_HEXA* MG_MAILLAGE::get_premier_hexa(LISTE_MG_HEXA::iterator & it)
{
    it = lst_mg_hexa.begin();
    if (it == lst_mg_hexa.end())
        return NULL;
    return it->second;
}

MG_HEXA* MG_MAILLAGE::get_suivant_hexa(LISTE_MG_HEXA::iterator & it)
{
    it++;
    if (it == lst_mg_hexa.end())
        return NULL;
    return it->second;
}


bool MG_MAILLAGE::contient ( MG_IDENTIFICATEUR * id )
{
    return ( lst_entite.find ( id ) != lst_entite.end() );
}

void MG_MAILLAGE::enregistrer(std::ostream& o)
{
    if (mg_geometrie==NULL)
    {
        if (get_nb_mg_tetra()!=0) MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO=3;
        else if (get_nb_mg_hexa()!=0) MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO=3;
        else if (get_nb_mg_triangle()!=0) MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO=2;
        else if (get_nb_mg_quadrangle()!=0) MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO=2;
        else if (get_nb_mg_segment()!=0) MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO=1;
        else MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO=0;
    }
    if (mg_geometrie==NULL) o << "%" << get_id() << "=MAILLAGE(NULL);" << std::endl;
    else o << "%" << get_id() << "=MAILLAGE($" << mg_geometrie->get_id() <<");" << std::endl;
    LISTE_ENTITE::const_iterator i;
    for (i=lst_entite.begin();i!=lst_entite.end();i++)
    {
        MG_IDENTIFICATEUR* entite = *i;
        entite->enregistrer(o);
    }
}

void MG_MAILLAGE::enregistrer_sous_mesh_1D(std::ostream& o)
{

    int nb_noeud=0;
    for (LISTE_MG_NOEUD::iterator i=lst_mg_noeud.begin();i!=lst_mg_noeud.end();i++)
    {
        MG_NOEUD* noeud=((*i).second);
        if (noeud->get_lien_topologie()->get_dimension()<2) nb_noeud++;
    }

    int nb_seg=0;
    for (LISTE_MG_SEGMENT::iterator i=lst_mg_segment.begin();i!=lst_mg_segment.end();i++)
    {
        MG_SEGMENT* seg=((*i).second);
        if (seg->get_lien_topologie()->get_dimension()<2) nb_seg++;
    }

    o << nb_noeud << " " << nb_seg << std::endl;
    int ii=0;
    for (LISTE_MG_NOEUD::iterator i=lst_mg_noeud.begin();i!=lst_mg_noeud.end();i++)
    {
        MG_NOEUD* noeud=((*i).second);
        if (noeud->get_lien_topologie()->get_dimension()<2)
        {
            o << (ii+1) << " " << noeud->get_x() << " " << noeud->get_y() << " " << noeud->get_z() << " " ;
            if (noeud->get_lien_topologie()->get_dimension()==0) o << "vertex ";
            if (noeud->get_lien_topologie()->get_dimension()==1) o << "edge ";
            o << noeud->get_lien_topologie()->get_id() << " " << noeud->get_id() << std::endl;
            noeud->change_nouveau_numero(ii+1);
            ii++;
        }
    }

    for (LISTE_MG_SEGMENT::iterator i=lst_mg_segment.begin();i!=lst_mg_segment.end();i++)
    {
        MG_SEGMENT* seg=((*i).second);
        if (seg->get_lien_topologie()->get_dimension()<2)
        {
            o << "2 " << seg->get_noeud1()->get_nouveau_numero() << " " << seg->get_noeud2()->get_nouveau_numero() << " " ;
            if (seg->get_lien_topologie()->get_dimension()==0) o << "vertex ";
            if (seg->get_lien_topologie()->get_dimension()==1) o << "edge ";
            o << seg->get_lien_topologie()->get_id() << std::endl;
        }
    }

}

void MG_MAILLAGE::enregistrer_sous_mesh_2D
(std::ostream& o)
{
    int nb_noeud=0;
    for (LISTE_MG_NOEUD::iterator i=lst_mg_noeud.begin();i!=lst_mg_noeud.end();i++)
    {
        MG_NOEUD* noeud=((*i).second);
        if (noeud->get_lien_topologie()->get_dimension()<3) nb_noeud++;
    }

    int nb_tri=0;
    for (LISTE_MG_TRIANGLE::iterator i=lst_mg_triangle.begin();i!=lst_mg_triangle.end();i++)
    {
        MG_TRIANGLE* triangle=((*i).second);
        if (triangle->get_lien_topologie()->get_dimension()<3) nb_tri++;
    }

    o << nb_noeud << " " << nb_tri << std::endl;
    int ii=0;
    for (LISTE_MG_NOEUD::iterator i=lst_mg_noeud.begin();i!=lst_mg_noeud.end();i++)
    {
        MG_NOEUD* noeud=((*i).second);
        if (noeud->get_lien_topologie()->get_dimension()<3)
        {
            o << (ii+1) << " " << noeud->get_x() << " " << noeud->get_y() << " " << noeud->get_z() << " " ;
            if (noeud->get_lien_topologie()->get_dimension()==0) o << "vertex ";
            if (noeud->get_lien_topologie()->get_dimension()==1) o << "edge ";
            if (noeud->get_lien_topologie()->get_dimension()==2) o << "face ";
            o << noeud->get_lien_topologie()->get_id() << std::endl;
            noeud->change_nouveau_numero(ii+1);
            ii++;
        }
    }

    int compteur=0;
    for (LISTE_MG_TRIANGLE::iterator i=lst_mg_triangle.begin();i!=lst_mg_triangle.end();i++)
    {
        MG_TRIANGLE* triangle=((*i).second);
        if (triangle->get_lien_topologie()->get_dimension()<3)
        {
            o << "3 " << triangle->get_noeud1()->get_nouveau_numero() << " " << triangle->get_noeud2()->get_nouveau_numero() << " " << triangle->get_noeud3()->get_nouveau_numero() << " " ;
            if (triangle->get_lien_topologie()->get_dimension()==0) o << "vertex ";
            if (triangle->get_lien_topologie()->get_dimension()==1) o << "edge ";
            if (triangle->get_lien_topologie()->get_dimension()==2) o << "face ";
            if (triangle->get_lien_topologie()->get_dimension()==3) o << "body ";
            o << triangle->get_lien_topologie()->get_id() << std::endl;
            compteur++;
        }
    }

}

void MG_MAILLAGE::enregistrer_sous_mesh_3D(std::ostream& o)
{
    o << get_nb_mg_noeud() << " " << get_nb_mg_tetra() << std::endl;
    int ii=0;
    for (LISTE_MG_NOEUD::iterator i=lst_mg_noeud.begin();i!=lst_mg_noeud.end();i++)
    {
        MG_NOEUD* noeud=((*i).second);
        o << (ii+1) << " " << noeud->get_x() << " " << noeud->get_y() << " " << noeud->get_z() << " " ;
        if (noeud->get_lien_topologie()->get_dimension()==0) o << "vertex ";
        if (noeud->get_lien_topologie()->get_dimension()==1) o << "edge ";
        if (noeud->get_lien_topologie()->get_dimension()==2) o << "face ";
        if (noeud->get_lien_topologie()->get_dimension()==3) o << "body ";
        o << noeud->get_lien_topologie()->get_id() << std::endl;
        noeud->change_nouveau_numero(ii+1);
        ii++;
    }


    for (LISTE_MG_TETRA::iterator i=lst_mg_tetra.begin();i!=lst_mg_tetra.end();i++)
    {
        MG_TETRA* tetra=((*i).second);
        o << "4 " << tetra->get_noeud1()->get_nouveau_numero() << " " << tetra->get_noeud2()->get_nouveau_numero() << " " << tetra->get_noeud3()->get_nouveau_numero() << " " << tetra->get_noeud4()->get_nouveau_numero() << " " ;
        if (tetra->get_lien_topologie()->get_dimension()==0) o << "vertex ";
        if (tetra->get_lien_topologie()->get_dimension()==1) o << "edge ";
        if (tetra->get_lien_topologie()->get_dimension()==2) o << "face ";
        if (tetra->get_lien_topologie()->get_dimension()==3) o << "body ";
        o << tetra->get_lien_topologie()->get_id() << std::endl;
    }

}

void MG_MAILLAGE::exporter_mesh(std::string& nomfic)
{
    char chaine[500];
    sprintf(chaine,"%s_1D.mai",nomfic.c_str());
    std::ofstream of1(chaine,std::ios::out|std::ios::trunc);
    of1.precision(16);
    of1.setf(std::ios::showpoint);
    enregistrer_sous_mesh_1D(of1);
    sprintf(chaine,"%s_2D.mai",nomfic.c_str());
    std::ofstream of2(chaine,std::ios::out|std::ios::trunc);
    of2.precision(16);
    of2.setf(std::ios::showpoint);
    enregistrer_sous_mesh_2D(of2);
    sprintf(chaine,"%s_3D.mai",nomfic.c_str());
    std::ofstream of3(chaine,std::ios::out|std::ios::trunc);
    of3.precision(16);
    of3.setf(std::ios::showpoint);
    enregistrer_sous_mesh_3D(of3);
}

/*
void MG_MAILLAGE::exporter_cosmos(std::string& nomfic)
{
char chaine[500];
sprintf(chaine,"%s.ses",nomfic.c_str());
std::ofstream of1(chaine,std::ios::out|std::ios::trunc);
of1.precision(16);
of1.setf(std::ios::showpoint);
of1 << "TITLE, " << chaine << " : Fichier de maillage MAGiC" << std::endl;
of1 << "EGROUP,1,TETRA4,0,0,0,0,0,0,0,0;" << std::endl;
int nb_volume=mg_geometrie->get_nb_mg_volume();
for (int i=0;i<nb_volume;i++)
        {
        MG_VOLUME *mgvol=mg_geometrie->get_mg_volume(i);
        if (mgvol->get_num_materiau()>=0)
                {
                MT_GESTIONNAIRE mtgest(mg_geometrie->get_gest_materiau());
                MT_MATERIAU* mat=mtgest.get_materiau(mgvol->get_num_materiau());
                MT_PROPRIETE* prop=mat->get_propriete("EX");
                of1<< "MPROP, "<< mgvol->get_num_materiau()+1 << ", EX, " << prop->get_valeur(2) << ";" << std::endl;
                prop=mat->get_propriete("NUXY");
                of1<< "MPROP, "<< mgvol->get_num_materiau()+1 << ", NUXY, " << prop->get_valeur(2) << ";" << std::endl;
                prop=mat->get_propriete("GXY");
                of1<< "MPROP, "<< mgvol->get_num_materiau()+1 << ", GXY, " << prop->get_valeur(2) << ";" << std::endl;
                prop=mat->get_propriete("DENS");
                of1<< "MPROP, "<< mgvol->get_num_materiau()+1 << ", DENS, " << prop->get_valeur(2) << ";" << std::endl;
                prop=mat->get_propriete("SIGXT");
                of1<< "MPROP, "<< mgvol->get_num_materiau()+1 << ", SIGXT, " << prop->get_valeur(2) << ";" << std::endl;
                prop=mat->get_propriete("SIGYLD");
                of1<< "MPROP, "<< mgvol->get_num_materiau()+1 << ", SIGYLD, " << prop->get_valeur(2) << ";" << std::endl;
                prop=mat->get_propriete("ALPX");
                of1<< "MPROP, "<< mgvol->get_num_materiau()+1 << ", ALPX, " << prop->get_valeur(2) << ";" << std::endl;
                prop=mat->get_propriete("KX");
                of1<< "MPROP, "<< mgvol->get_num_materiau()+1 << ", KX, " << prop->get_valeur(2) << ";" << std::endl;
                prop=mat->get_propriete("C");
                of1<< "MPROP, "<< mgvol->get_num_materiau()+1 << ", C, " << prop->get_valeur(2) << ";" << std::endl;
                }
        }
of1 << "ACTSET,CS,0;" << std::endl;
of1 << "ACTSET,EG,1;" << std::endl;
int ii=0;
double valeurunite=mg_geometrie->get_valeur_unite();
for (LISTE_MG_NOEUD::iterator i=lst_mg_noeud.begin();i!=lst_mg_noeud.end();i++)
         {
         MG_NOEUD* noeud=((*i).second);
         of1 << "ND, " << (ii+1) << ", " << noeud->get_x()*valeurunite << ", " << noeud->get_y()*valeurunite << ", " << noeud->get_z()*valeurunite << ";" << std::endl;
         char nom[3];
         int nb=noeud->get_lien_topologie()->get_nb_ccf();
         for (int k=0;k<nb;k++)
                {
                noeud->get_lien_topologie()->get_type_ccf(k,nom);
                if (strcmp(nom,"Da")==0) of1 << "DND , " << ii+1 << ", AL, " << noeud->get_lien_topologie()->get_valeur_ccf(k) << ", " << ii+1 << ", 1;" << std::endl;
                if (strcmp(nom,"Dx")==0) of1 << "DND , " << ii+1 << ", UX, " << noeud->get_lien_topologie()->get_valeur_ccf(k) << ", " << ii+1 << ", 1;" << std::endl;
                if (strcmp(nom,"Dy")==0) of1 << "DND , " << ii+1 << ", UY, " << noeud->get_lien_topologie()->get_valeur_ccf(k) << ", " << ii+1 << ", 1;" << std::endl;
                if (strcmp(nom,"Dz")==0) of1 << "DND , " << ii+1 << ", UZ, " << noeud->get_lien_topologie()->get_valeur_ccf(k) << ", " << ii+1 << ", 1;" << std::endl;
                if (strcmp(nom,"Fx")==0) of1 << "FND , " << ii+1 << ", FX, " << noeud->get_lien_topologie()->get_valeur_ccf(k) << ", " << ii+1 << ", 1;" << std::endl;
                if (strcmp(nom,"Fy")==0) of1 << "FND , " << ii+1 << ", FY, " << noeud->get_lien_topologie()->get_valeur_ccf(k) << ", " << ii+1 << ", 1;" << std::endl;
                if (strcmp(nom,"Fz")==0) of1 << "FND , " << ii+1 << ", FZ, " << noeud->get_lien_topologie()->get_valeur_ccf(k) << ", " << ii+1 << ", 1;" << std::endl;
                }
         ii++;
         noeud->change_nouveau_numero(ii);
         }
ii=0;
int nummat=-10;
for (LISTE_MG_TETRA::iterator i=lst_mg_tetra.begin();i!=lst_mg_tetra.end();i++)
        {
        MG_TETRA* tetra=((*i).second);
        MG_VOLUME* vol=(MG_VOLUME*)tetra->get_lien_topologie();
        int nummatac=vol->get_num_materiau();
        if (nummatac!=nummat)
                {
                nummat=nummatac;
                of1 << "ACTSET, MP," << nummat+1 << ";" << std::endl;
                }
        of1 << "EL, " << ii+1 << ", VL, 1, 4, " << tetra->get_noeud1()->get_nouveau_numero() << ", " << tetra->get_noeud2()->get_nouveau_numero() << ", " << tetra->get_noeud3()->get_nouveau_numero() << ", " << tetra->get_noeud4()->get_nouveau_numero() << ", "  ;
        ii++;
        if (tetra->get_triangle1()->get_lien_topologie()->get_dimension()!=3) of1 << "1, "; else of1 << "0, ";
        if (tetra->get_triangle2()->get_lien_topologie()->get_dimension()!=3) of1 << "1, "; else of1 << "0, ";
        if (tetra->get_triangle3()->get_lien_topologie()->get_dimension()!=3) of1 << "1, "; else of1 << "0, ";
        if (tetra->get_triangle4()->get_lien_topologie()->get_dimension()!=3) of1 << "1;" << std::endl ; else of1 << "0;" << std::endl;
        char nom[3];
        int nb=tetra->get_triangle1()->get_lien_topologie()->get_nb_ccf();
        for (int k=0;k<nb;k++)
                {
                tetra->get_triangle1()->get_lien_topologie()->get_type_ccf(k,nom);
                if (strcmp(nom,"Px")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle1()->get_lien_topologie()->get_valeur_ccf(k) << ", 1, " << ii << ", 1, 1;" << std::endl;
                if (strcmp(nom,"Py")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle1()->get_lien_topologie()->get_valeur_ccf(k) << ", 1, " << ii << ", 1, 2;" << std::endl;
                if (strcmp(nom,"Pz")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle1()->get_lien_topologie()->get_valeur_ccf(k) << ", 1, " << ii << ", 1, 3;" << std::endl;
                if (strcmp(nom,"Pn")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle1()->get_lien_topologie()->get_valeur_ccf(k) << ", 1, " << ii << ", 1, 4;" << std::endl;
                }
        nb=tetra->get_triangle2()->get_lien_topologie()->get_nb_ccf();
        for (int k=0;k<nb;k++)
                {
                tetra->get_triangle2()->get_lien_topologie()->get_type_ccf(k,nom);
                if (strcmp(nom,"Px")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle2()->get_lien_topologie()->get_valeur_ccf(k) << ", 2, " << ii << ", 1, 1;" << std::endl;
                if (strcmp(nom,"Py")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle2()->get_lien_topologie()->get_valeur_ccf(k) << ", 2, " << ii << ", 1, 2;" << std::endl;
                if (strcmp(nom,"Pz")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle2()->get_lien_topologie()->get_valeur_ccf(k) << ", 2, " << ii << ", 1, 3;" << std::endl;
                if (strcmp(nom,"Pn")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle2()->get_lien_topologie()->get_valeur_ccf(k) << ", 2, " << ii << ", 1, 4;" << std::endl;
                }
        nb=tetra->get_triangle3()->get_lien_topologie()->get_nb_ccf();
        for (int k=0;k<nb;k++)
                {
                tetra->get_triangle3()->get_lien_topologie()->get_type_ccf(k,nom);
                if (strcmp(nom,"Px")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle3()->get_lien_topologie()->get_valeur_ccf(k) << ", 3, " << ii << ", 1, 1;" << std::endl;
                if (strcmp(nom,"Py")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle3()->get_lien_topologie()->get_valeur_ccf(k) << ", 3, " << ii << ", 1, 2;" << std::endl;
                if (strcmp(nom,"Pz")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle3()->get_lien_topologie()->get_valeur_ccf(k) << ", 3, " << ii << ", 1, 3;" << std::endl;
                if (strcmp(nom,"Pn")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle3()->get_lien_topologie()->get_valeur_ccf(k) << ", 3, " << ii << ", 1, 4;" << std::endl;
                }
        nb=tetra->get_triangle4()->get_lien_topologie()->get_nb_ccf();
        for (int k=0;k<nb;k++)
                {
                tetra->get_triangle4()->get_lien_topologie()->get_type_ccf(k,nom);
                if (strcmp(nom,"Px")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle4()->get_lien_topologie()->get_valeur_ccf(k) << ", 4, " << ii << ", 1, 1;" << std::endl;
                if (strcmp(nom,"Py")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle4()->get_lien_topologie()->get_valeur_ccf(k) << ", 4, " << ii << ", 1, 2;" << std::endl;
                if (strcmp(nom,"Pz")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle4()->get_lien_topologie()->get_valeur_ccf(k) << ", 4, " << ii << ", 1, 3;" << std::endl;
                if (strcmp(nom,"Pn")==0) of1 << "PEL , " << ii <<  ", " << tetra->get_triangle4()->get_lien_topologie()->get_valeur_ccf(k) << ", 4, " << ii << ", 1, 4;" << std::endl;
                }
        }
}

 */


void MG_MAILLAGE::exporter_giref(std::string& nomfic)
{
    char chaine[500];
    sprintf(chaine,"%s.mail",nomfic.c_str());
    FILE *in=fopen(chaine,"wt");
    int lieu=0;

    fprintf(in,"8 Maillage\n");
    fprintf(in,"11 Version 1.0\n");
    fprintf(in,"%lu\n\n",get_id());
    int nb=get_nb_mg_noeud();
    fprintf(in,"%d\n",nb);

    LISTE_MG_NOEUD::iterator ind;
    MG_NOEUD* noeud=get_premier_noeud(ind);
    int i=0;
    while (noeud)
    {
        noeud->change_nouveau_numero(i++);
        MG_ELEMENT_TOPOLOGIQUE* topo=noeud->get_lien_topologie();
        if (topo->get_nouveau_numero()==-1)
        {
            topo->change_nouveau_numero(lieu);
            lieu++;
        }
        fprintf(in,"%.16e %.16e %.16e 0 %d \n",noeud->get_x(),noeud->get_y(),noeud->get_z(),topo->get_nouveau_numero());
        noeud=get_suivant_noeud(ind);
    }


    nb=get_nb_mg_segment();
    fprintf(in,"\n%d\n",nb);

    LISTE_MG_SEGMENT::iterator iseg;
    MG_SEGMENT* seg=get_premier_segment(iseg);
    i=0;

    while (seg)
    {

        seg->change_nouveau_numero(i);
        MG_ELEMENT_TOPOLOGIQUE* topo=seg->get_lien_topologie();
        if (topo->get_nouveau_numero()==-1)
        {
            topo->change_nouveau_numero(lieu);
            lieu++;
        }
        fprintf(in,"%d %d 0 %d \n",seg->get_noeud1()->get_nouveau_numero(),seg->get_noeud2()->get_nouveau_numero(),topo->get_nouveau_numero());
        seg = get_suivant_segment(iseg);
    }
    nb=get_nb_mg_triangle();
    fprintf(in,"\n%d\n",nb);
    for (int i=0;i<nb;i++)
    {
        MG_TRIANGLE* tri=get_mg_triangle(i);
        tri->change_nouveau_numero(i);
        MG_ELEMENT_TOPOLOGIQUE* topo=tri->get_lien_topologie();
        if (topo->get_nouveau_numero()==-1)
        {
            topo->change_nouveau_numero(lieu);
            lieu++;
        }
        fprintf(in,"3 %d %d %d 0 %d \n",tri->get_segment3()->get_nouveau_numero(),tri->get_segment2()->get_nouveau_numero(),tri->get_segment1()->get_nouveau_numero(),topo->get_nouveau_numero());
    }
    nb=get_nb_mg_tetra();
    fprintf(in,"\n0\n\n0\n\n0\n\n%d\n",nb);
    for (int i=0;i<nb;i++)
    {
        MG_TETRA* tet=get_mg_tetra(i);
        tet->change_nouveau_numero(i);
        MG_ELEMENT_TOPOLOGIQUE* topo=tet->get_lien_topologie();
        if (topo->get_nouveau_numero()==-1)
        {
            topo->change_nouveau_numero(lieu);
            lieu++;
        }
        TPL_MAP_ENTITE<MG_SEGMENT*> lst_segment;
        lst_segment.ajouter(tet->get_triangle1()->get_segment1());
        lst_segment.ajouter(tet->get_triangle1()->get_segment2());
        lst_segment.ajouter(tet->get_triangle1()->get_segment3());
        lst_segment.ajouter(tet->get_triangle2()->get_segment1());
        lst_segment.ajouter(tet->get_triangle2()->get_segment2());
        lst_segment.ajouter(tet->get_triangle2()->get_segment3());
        lst_segment.ajouter(tet->get_triangle3()->get_segment1());
        lst_segment.ajouter(tet->get_triangle3()->get_segment2());
        lst_segment.ajouter(tet->get_triangle3()->get_segment3());
        lst_segment.ajouter(tet->get_triangle4()->get_segment1());
        lst_segment.ajouter(tet->get_triangle4()->get_segment2());
        lst_segment.ajouter(tet->get_triangle4()->get_segment3());
        int tab[6];
        for (int j=0;j<6;j++)
        {
            MG_SEGMENT* seg=lst_segment.get(j);
            if ((seg->get_noeud1()==tet->get_noeud1()) && (seg->get_noeud2()==tet->get_noeud2())) tab[0]=j;
            else if ((seg->get_noeud1()==tet->get_noeud2()) && (seg->get_noeud2()==tet->get_noeud1())) tab[0]=j;
            else if ((seg->get_noeud1()==tet->get_noeud1()) && (seg->get_noeud2()==tet->get_noeud3())) tab[1]=j;
            else if ((seg->get_noeud1()==tet->get_noeud3()) && (seg->get_noeud2()==tet->get_noeud1())) tab[1]=j;
            else if ((seg->get_noeud1()==tet->get_noeud1()) && (seg->get_noeud2()==tet->get_noeud4())) tab[2]=j;
            else if ((seg->get_noeud1()==tet->get_noeud4()) && (seg->get_noeud2()==tet->get_noeud1())) tab[2]=j;
            else if ((seg->get_noeud1()==tet->get_noeud2()) && (seg->get_noeud2()==tet->get_noeud3())) tab[3]=j;
            else if ((seg->get_noeud1()==tet->get_noeud3()) && (seg->get_noeud2()==tet->get_noeud2())) tab[3]=j;
            else if ((seg->get_noeud1()==tet->get_noeud2()) && (seg->get_noeud2()==tet->get_noeud4())) tab[4]=j;
            else if ((seg->get_noeud1()==tet->get_noeud4()) && (seg->get_noeud2()==tet->get_noeud2())) tab[4]=j;
            else if ((seg->get_noeud1()==tet->get_noeud3()) && (seg->get_noeud2()==tet->get_noeud4())) tab[5]=j;
            else if ((seg->get_noeud1()==tet->get_noeud4()) && (seg->get_noeud2()==tet->get_noeud3())) tab[5]=j;
        }
        fprintf(in,"%d %d %d %d %d %d %d %d %d %d %d %d %d %d 0 %d \n",tet->get_noeud1()->get_nouveau_numero(),tet->get_noeud2()->get_nouveau_numero(),tet->get_noeud3()->get_nouveau_numero(),tet->get_noeud4()->get_nouveau_numero(),lst_segment.get(tab[0])->get_nouveau_numero(),lst_segment.get(tab[1])->get_nouveau_numero(),lst_segment.get(tab[2])->get_nouveau_numero(),lst_segment.get(tab[3])->get_nouveau_numero(),lst_segment.get(tab[4])->get_nouveau_numero(),lst_segment.get(tab[5])->get_nouveau_numero(),tet->get_triangle1()->get_nouveau_numero(),tet->get_triangle2()->get_nouveau_numero(),tet->get_triangle3()->get_nouveau_numero(),tet->get_triangle4()->get_nouveau_numero(),topo->get_nouveau_numero());
    }

    fprintf(in,"\n0\n\n0\n\n8 Maillage\n",nb);
    fclose(in);
}


std::ostream& operator << (std::ostream& o,MG_MAILLAGE& maillage)
{
    maillage.enregistrer(o);
    return o;
}


MG_SOLUTION* MG_MAILLAGE::calculer_carte_taille_reelle(char* nomfichier)
{
    int nb_noeud=get_nb_mg_noeud();
    std::string nomsol="Carte de taille reelle";
    MG_SOLUTION* mgsol=new MG_SOLUTION(this,1,nomfichier,nb_noeud,nomsol);
    mgsol->change_legende(0,"F(x,y,z)");
    for (int j=0;j<nb_noeud;j++)
    {
        MG_NOEUD* noeud=get_mg_noeud(j);
        int nb_segment=noeud->get_lien_segment()->get_nb();
        double ec=0.;
        int nbr=0;
        for (int k=0;k<nb_segment;k++)
        {
            MG_SEGMENT* seg=noeud->get_lien_segment()->get(k);
            MG_SEGMENT* segtmp=get_mg_segmentid(seg->get_id());
            if (segtmp!=NULL)
            {
                nbr++;
                ec=ec+seg->get_longueur();
            }
        }
        ec=ec/nbr;
        mgsol->ecrire(ec,j,0,0,0);
    }
    return mgsol;
}


MG_GESTIONNAIRE* MG_MAILLAGE::get_gestionnaire(void)
{
    return gest;
}

Revision:	377
Committed:	Thu Nov 15 15:23:45 2012 UTC (12 years, 5 months ago) by francois
File size:	78812 byte(s)
Log Message:	Les solution mg sont aussi vectorielles