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 "mt_gestionnaire.h"
#include "mt_propriete.h"
#include "mt_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) && (noeud1->get_lien_topologie()->get_dimension()>0))  supprimer_mg_noeudid(noeud1->get_id());
if ((noeud2->get_nb_reference()==0) && (noeud2->get_lien_topologie()->get_dimension()>0))  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) && (noeud1->get_lien_topologie()->get_dimension()>0))  supprimer_mg_noeudid(noeud1->get_id());
if ((noeud2->get_nb_reference()==0) && (noeud2->get_lien_topologie()->get_dimension()>0))  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) && (segment1->get_lien_topologie()->get_dimension()>1))  supprimer_mg_segmentid(segment1->get_id());
if ((segment2->get_nb_reference()==0) && (segment2->get_lien_topologie()->get_dimension()>1))  supprimer_mg_segmentid(segment2->get_id());
if ((segment3->get_nb_reference()==0) && (segment3->get_lien_topologie()->get_dimension()>1))  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) && (segment1->get_lien_topologie()->get_dimension()>1))  supprimer_mg_segmentid(segment1->get_id());
if ((segment2->get_nb_reference()==0) && (segment2->get_lien_topologie()->get_dimension()>1))  supprimer_mg_segmentid(segment2->get_id());
if ((segment3->get_nb_reference()==0) && (segment3->get_lien_topologie()->get_dimension()>1))  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_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(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);
MG_NOEUD* noeud=get_mg_noeudid(id);
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()->get_id()==noeud1id) && (mgtetra->get_noeud2()->get_id()==noeud2id) && (mgtetra->get_noeud3()->get_id()==noeud3id) && (mgtetra->get_noeud4()->get_id()==noeud4id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud1id) && (mgtetra->get_noeud2()->get_id()==noeud2id) && (mgtetra->get_noeud3()->get_id()==noeud4id) && (mgtetra->get_noeud4()->get_id()==noeud3id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud1id) && (mgtetra->get_noeud2()->get_id()==noeud3id) && (mgtetra->get_noeud3()->get_id()==noeud2id) && (mgtetra->get_noeud4()->get_id()==noeud4id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud1id) && (mgtetra->get_noeud2()->get_id()==noeud3id) && (mgtetra->get_noeud3()->get_id()==noeud4id) && (mgtetra->get_noeud4()->get_id()==noeud2id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud1id) && (mgtetra->get_noeud2()->get_id()==noeud4id) && (mgtetra->get_noeud3()->get_id()==noeud2id) && (mgtetra->get_noeud4()->get_id()==noeud3id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud1id) && (mgtetra->get_noeud2()->get_id()==noeud4id) && (mgtetra->get_noeud3()->get_id()==noeud3id) && (mgtetra->get_noeud4()->get_id()==noeud2id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud2id) && (mgtetra->get_noeud2()->get_id()==noeud1id) && (mgtetra->get_noeud3()->get_id()==noeud3id) && (mgtetra->get_noeud4()->get_id()==noeud4id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud2id) && (mgtetra->get_noeud2()->get_id()==noeud1id) && (mgtetra->get_noeud3()->get_id()==noeud4id) && (mgtetra->get_noeud4()->get_id()==noeud3id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud2id) && (mgtetra->get_noeud2()->get_id()==noeud3id) && (mgtetra->get_noeud3()->get_id()==noeud1id) && (mgtetra->get_noeud4()->get_id()==noeud4id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud2id) && (mgtetra->get_noeud2()->get_id()==noeud3id) && (mgtetra->get_noeud3()->get_id()==noeud4id) && (mgtetra->get_noeud4()->get_id()==noeud1id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud2id) && (mgtetra->get_noeud2()->get_id()==noeud4id) && (mgtetra->get_noeud3()->get_id()==noeud1id) && (mgtetra->get_noeud4()->get_id()==noeud3id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud2id) && (mgtetra->get_noeud2()->get_id()==noeud4id) && (mgtetra->get_noeud3()->get_id()==noeud3id) && (mgtetra->get_noeud4()->get_id()==noeud1id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud3id) && (mgtetra->get_noeud2()->get_id()==noeud1id) && (mgtetra->get_noeud3()->get_id()==noeud2id) && (mgtetra->get_noeud4()->get_id()==noeud4id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud3id) && (mgtetra->get_noeud2()->get_id()==noeud1id) && (mgtetra->get_noeud3()->get_id()==noeud4id) && (mgtetra->get_noeud4()->get_id()==noeud2id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud3id) && (mgtetra->get_noeud2()->get_id()==noeud2id) && (mgtetra->get_noeud3()->get_id()==noeud1id) && (mgtetra->get_noeud4()->get_id()==noeud4id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud3id) && (mgtetra->get_noeud2()->get_id()==noeud2id) && (mgtetra->get_noeud3()->get_id()==noeud4id) && (mgtetra->get_noeud4()->get_id()==noeud1id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud3id) && (mgtetra->get_noeud2()->get_id()==noeud4id) && (mgtetra->get_noeud3()->get_id()==noeud1id) && (mgtetra->get_noeud4()->get_id()==noeud2id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud3id) && (mgtetra->get_noeud2()->get_id()==noeud4id) && (mgtetra->get_noeud3()->get_id()==noeud2id) && (mgtetra->get_noeud4()->get_id()==noeud1id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud4id) && (mgtetra->get_noeud2()->get_id()==noeud1id) && (mgtetra->get_noeud3()->get_id()==noeud2id) && (mgtetra->get_noeud4()->get_id()==noeud3id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud4id) && (mgtetra->get_noeud2()->get_id()==noeud1id) && (mgtetra->get_noeud3()->get_id()==noeud3id) && (mgtetra->get_noeud4()->get_id()==noeud2id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud4id) && (mgtetra->get_noeud2()->get_id()==noeud2id) && (mgtetra->get_noeud3()->get_id()==noeud1id) && (mgtetra->get_noeud4()->get_id()==noeud3id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud4id) && (mgtetra->get_noeud2()->get_id()==noeud2id) && (mgtetra->get_noeud3()->get_id()==noeud3id) && (mgtetra->get_noeud4()->get_id()==noeud1id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud4id) && (mgtetra->get_noeud2()->get_id()==noeud3id) && (mgtetra->get_noeud3()->get_id()==noeud1id) && (mgtetra->get_noeud4()->get_id()==noeud2id) ) return mgtetra;
 if ( (mgtetra->get_noeud1()->get_id()==noeud4id) && (mgtetra->get_noeud2()->get_id()==noeud3id) && (mgtetra->get_noeud3()->get_id()==noeud2id) && (mgtetra->get_noeud4()->get_id()==noeud1id) ) 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) && (triangle1->get_lien_topologie()->get_dimension()>2))  supprimer_mg_triangleid(triangle1->get_id());
if ((triangle2->get_nb_reference()==0) && (triangle2->get_lien_topologie()->get_dimension()>2))  supprimer_mg_triangleid(triangle2->get_id());
if ((triangle3->get_nb_reference()==0) && (triangle3->get_lien_topologie()->get_dimension()>2))  supprimer_mg_triangleid(triangle3->get_id());
if ((triangle4->get_nb_reference()==0) && (triangle4->get_lien_topologie()->get_dimension()>2))  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) && (triangle1->get_lien_topologie()->get_dimension()>2))  supprimer_mg_triangleid(triangle1->get_id());
if ((triangle2->get_nb_reference()==0) && (triangle2->get_lien_topologie()->get_dimension()>2))  supprimer_mg_triangleid(triangle2->get_id());
if ((triangle3->get_nb_reference()==0) && (triangle3->get_lien_topologie()->get_dimension()>2))  supprimer_mg_triangleid(triangle3->get_id());
if ((triangle4->get_nb_reference()==0) && (triangle4->get_lien_topologie()->get_dimension()>2))  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;
}


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_triangle()!=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(j,0,ec);
                }
return mgsol;
}


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

Revision:	195
Committed:	Thu Jul 16 22:05:49 2009 UTC (15 years, 10 months ago) by francois
Original Path:	*magic/lib/geometrie/geometrie/src/mg_maillage.cpp*
File size:	57282 byte(s)
Log Message:	Ajout de groupe de topologie pour appliquer des algos sur une partie du fichier magic seulement Ajout de methode qui permette de connaitre la topologie sous jacente a une topologie donnee Gestion des maillages FEM qui ne sont attaches a une geometrie