geometrie/src/mg_triangle.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_triangle.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H22
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"
#include "mg_triangle.h"
#include "mg_maillage.h"
#include "ot_decalage_parametre.h"

MG_TRIANGLE::MG_TRIANGLE(unsigned long num,MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,class MG_NOEUD *mgnoeud3,class MG_SEGMENT* mgsegment1,class MG_SEGMENT* mgsegment2,class MG_SEGMENT* mgsegment3,int origine):MG_ELEMENT_MAILLAGE(num,topo,origine),noeud1(mgnoeud1),noeud2(mgnoeud2),noeud3(mgnoeud3),segment1(mgsegment1),segment2(mgsegment2),segment3(mgsegment3)
{
    init_triangle();
}

MG_TRIANGLE::MG_TRIANGLE(MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,class MG_NOEUD *mgnoeud3,class MG_SEGMENT* mgsegment1,class MG_SEGMENT* mgsegment2,class MG_SEGMENT* mgsegment3,int origine):MG_ELEMENT_MAILLAGE(topo,origine),noeud1(mgnoeud1),noeud2(mgnoeud2),noeud3(mgnoeud3),segment1(mgsegment1),segment2(mgsegment2),segment3(mgsegment3)
{
    init_triangle();
}

MG_TRIANGLE::MG_TRIANGLE(MG_TRIANGLE& mdd):MG_ELEMENT_MAILLAGE(mdd),noeud1(mdd.noeud1),noeud2(mdd.noeud2),noeud3(mdd.noeud3),segment1(mdd.segment1),segment2(mdd.segment2),segment3(mdd.segment3)
{
    init_triangle();
}

MG_TRIANGLE* MG_TRIANGLE::dupliquer(MG_MAILLAGE *mgmai,long decalage)
{
    MG_NOEUD* nd1=mgmai->get_mg_noeudid(noeud1->get_id()+decalage);
    MG_NOEUD* nd2=mgmai->get_mg_noeudid(noeud2->get_id()+decalage);
    MG_NOEUD* nd3=mgmai->get_mg_noeudid(noeud3->get_id()+decalage);
    MG_SEGMENT* seg1=mgmai->get_mg_segmentid(segment1->get_id()+decalage);
    MG_SEGMENT* seg2=mgmai->get_mg_segmentid(segment2->get_id()+decalage);
    MG_SEGMENT* seg3=mgmai->get_mg_segmentid(segment3->get_id()+decalage);
    MG_TRIANGLE* tri=new MG_TRIANGLE(this->get_id()+decalage,liaison_topologique,nd1,nd2,nd3,seg1,seg2,seg3,DUPLIQUER);
    mgmai->ajouter_mg_triangle(tri);
    return tri;
}


MG_TRIANGLE::~MG_TRIANGLE()
{
    if (noeud1!=NULL) noeud1->get_lien_triangle()->supprimer(this);
    if (noeud2!=NULL) noeud2->get_lien_triangle()->supprimer(this);
    if (noeud3!=NULL) noeud3->get_lien_triangle()->supprimer(this);
    unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
    noeudminid=std::min(noeudminid,noeud3->get_id());
    if (noeud1!=NULL)
        if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_triangle()->supprimer(this);
    if (noeud2!=NULL)
        if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_triangle()->supprimer(this);
    if (noeud3!=NULL)
        if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_triangle()->supprimer(this);
    if (segment1!=NULL) {
        segment1->decrementer();
        segment1->get_lien_triangle()->supprimer(this);
    }
    if (segment2!=NULL) {
        segment2->decrementer();
        segment2->get_lien_triangle()->supprimer(this);
    }
    if (segment3!=NULL) {
        segment3->decrementer();
        segment3->get_lien_triangle()->supprimer(this);
    }
    if (liaison_topologique!=NULL) 
      if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->supprimer(this);
}

void MG_TRIANGLE::init_triangle(void)
{
    if (noeud1!=NULL) noeud1->get_lien_triangle()->ajouter(this);
    if (noeud2!=NULL) noeud2->get_lien_triangle()->ajouter(this);
    if (noeud3!=NULL) noeud3->get_lien_triangle()->ajouter(this);
    unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
    noeudminid=std::min(noeudminid,noeud3->get_id());
    if (noeud1!=NULL)
        if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_triangle()->ajouter(this);
    if (noeud2!=NULL)
        if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_triangle()->ajouter(this);
    if (noeud3!=NULL)
        if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_triangle()->ajouter(this);
    if (segment1!=NULL) {
        segment1->incrementer();
        segment1->get_lien_triangle()->ajouter(this);
    }
    if (segment2!=NULL) {
        segment2->incrementer();
        segment2->get_lien_triangle()->ajouter(this);
    }
    if (segment3!=NULL) {
        segment3->incrementer();
        segment3->get_lien_triangle()->ajouter(this);
    }
    if ( (segment1!=NULL) &&  (segment2!=NULL)&& (segment3!=NULL) )longueur=0.3333333333333333*(segment1->get_longueur()+segment2->get_longueur()+segment3->get_longueur());
    if (liaison_topologique==NULL) return;
    if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->ajouter(this);
}


int MG_TRIANGLE::get_type_entite(void)
{
    return IDMG_TRIANGLE;
}


MG_NOEUD* MG_TRIANGLE::get_noeud1(void)
{
    return noeud1;
}

MG_NOEUD* MG_TRIANGLE::get_noeud2(void)
{
    return noeud2;
}


MG_NOEUD* MG_TRIANGLE::get_noeud3(void)
{
    return noeud3;
}

MG_SEGMENT* MG_TRIANGLE::get_segment1(void)
{
    return segment1;
}

MG_SEGMENT* MG_TRIANGLE::get_segment2(void)
{
    return segment2;
}

MG_SEGMENT* MG_TRIANGLE::get_segment3(void)
{
    return segment3;
}

void MG_TRIANGLE::inverse_sens(void)
{
MG_NOEUD* noeud=noeud2;
noeud2=noeud3;
noeud3=noeud;
MG_SEGMENT* segment=segment3;
segment2=segment3;
segment3=segment;
}

int MG_TRIANGLE::get_dimension(void)
{
    return 2;
}

double MG_TRIANGLE::get_longueur(void)
{
    return longueur;
}

TPL_LISTE_ENTITE<class MG_TETRA*>* MG_TRIANGLE::get_lien_tetra(void)
{
    return &tetra;
}

BOITE_2D MG_TRIANGLE::get_boite_2D(double periodeu,double periodev)
{
    OT_DECALAGE_PARAMETRE decalage(periodeu,periodev);

    double coouv1[2];
    double coouv2[2];
    double coouv3[2];
    coouv1[0]=noeud1->get_u();
    coouv1[1]=noeud1->get_v();
    coouv2[0]=noeud2->get_u();
    coouv2[1]=noeud2->get_v();
    coouv3[0]=noeud3->get_u();
    coouv3[1]=noeud3->get_v();
    double coouvd1[2];
    double coouvd2[2];
    double coouvd3[2];
    double du=decalage.calcul_decalage_parametre_u(coouv1[0]);
    double dv=decalage.calcul_decalage_parametre_v(coouv1[1]);
    coouvd1[0]=decalage.decalage_parametre_u(coouv1[0],du);
    coouvd1[1]=decalage.decalage_parametre_v(coouv1[1],dv);
    coouvd2[0]=decalage.decalage_parametre_u(coouv2[0],du);
    coouvd2[1]=decalage.decalage_parametre_v(coouv2[1],dv);
    coouvd3[0]=decalage.decalage_parametre_u(coouv3[0],du);
    coouvd3[1]=decalage.decalage_parametre_v(coouv3[1],dv);
    double umin,vmin,umax,vmax;
    umin=std::min(coouvd1[0],coouvd2[0]);
    umin=std::min(umin,coouvd3[0]);
    umax=std::max(coouvd1[0],coouvd2[0]);
    umax=std::max(umax,coouvd3[0]);
    vmin=std::min(coouvd1[1],coouvd2[1]);
    vmin=std::min(vmin,coouvd3[1]);
    vmax=std::max(coouv1[1],coouvd2[1]);
    vmax=std::max(vmax,coouvd3[1]);
    umin=umin-du;
    umax=umax-du;
    vmin=vmin-dv;
    vmax=vmax-dv;
    BOITE_2D boite(umin,vmin,umax,vmax);
    return boite;
}

BOITE_3D MG_TRIANGLE::get_boite_3D(void)
{
    double coo1[3];
    double coo2[3];
    double coo3[3];
    coo1[0]=noeud1->get_x();
    coo1[1]=noeud1->get_y();
    coo1[2]=noeud1->get_z();
    coo2[0]=noeud2->get_x();
    coo2[1]=noeud2->get_y();
    coo2[2]=noeud2->get_z();
    coo3[0]=noeud3->get_x();
    coo3[1]=noeud3->get_y();
    coo3[2]=noeud3->get_z();
    double xmin,ymin,zmin,xmax,ymax,zmax;
    xmin=std::min(coo1[0],coo2[0]);
    xmin=std::min(xmin,coo3[0]);
    xmax=std::max(coo1[0],coo2[0]);
    xmax=std::max(xmax,coo3[0]);
    ymin=std::min(coo1[1],coo2[1]);
    ymin=std::min(ymin,coo3[1]);
    ymax=std::max(coo1[1],coo2[1]);
    ymax=std::max(ymax,coo3[1]);
    zmin=std::min(coo1[2],coo2[2]);
    zmin=std::min(zmin,coo3[2]);
    zmax=std::max(coo1[2],coo2[2]);
    zmax=std::max(zmax,coo3[2]);
    BOITE_3D boite(xmin,ymin,zmin,xmax,ymax,zmax);
    return boite;
}
void MG_TRIANGLE::extrapoler_solution_noeud(void)
{
    for (int j=0;j<MAX_TYPE_SOLUTION;j++)
      {
      noeud1->change_solution(solution[j],j);
      noeud2->change_solution(solution[j],j);
      noeud3->change_solution(solution[j],j);
      }
}


void MG_TRIANGLE::enregistrer(std::ostream& o)
{
    if ((liaison_topologique==NULL) && (MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO!=2)) return;
    if (liaison_topologique==NULL) o << "%" << get_id() << "=TRIANGLE(NULL,$" << noeud1->get_id() << ",$" << noeud2->get_id() << ",$" << noeud3->get_id()  << "," << origine_creation << ");" << std::endl;
    else if (liaison_topologique->get_dimension()==2)  o << "%" << get_id() << "=TRIANGLE($"<< get_lien_topologie()->get_id() << ",$" << noeud1->get_id() << ",$" << noeud2->get_id() << ",$" << noeud3->get_id()  << "," << origine_creation << ");" << std::endl;
}


Revision:	702
Committed:	Thu Aug 6 18:57:42 2015 UTC (9 years, 9 months ago) by francois
File size:	9490 byte(s)
Log Message:	importation d'un maillage gmsh avec attachement de la topologie et orientation du maillage en convention avec MAGiC
#	User	Rev	Content
1	francois	283	//------------------------------------------------------------
2			//------------------------------------------------------------
3			// MAGiC
4			// Jean Christophe Cuilli�re et Vincent FRANCOIS
5			// D�partement de G�nie M�canique - UQTR
6			//------------------------------------------------------------
7			// Le projet MAGIC est un projet de recherche du d�partement
8			// de g�nie m�canique de l'Universit� du Qu�bec �
9			// Trois Rivi�res
10			// Les librairies ne peuvent �tre utilis�es sans l'accord
11			// des auteurs (contact : francois@uqtr.ca)
12			//------------------------------------------------------------
13			//------------------------------------------------------------
14			//
15			// mg_triangle.cpp
16			//
17			//------------------------------------------------------------
18			//------------------------------------------------------------
19			// COPYRIGHT 2000
20			// Version du 02/03/2006 � 11H22
21			//------------------------------------------------------------
22			//------------------------------------------------------------
23
24
25			#include "gestionversion.h"
26			#include "mg_triangle.h"
27			#include "mg_maillage.h"
28			#include "ot_decalage_parametre.h"
29
30			MG_TRIANGLE::MG_TRIANGLE(unsigned long num,MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD mgnoeud1,class MG_NOEUD mgnoeud2,class MG_NOEUD mgnoeud3,class MG_SEGMENT mgsegment1,class MG_SEGMENT* mgsegment2,class MG_SEGMENT* mgsegment3,int origine):MG_ELEMENT_MAILLAGE(num,topo,origine),noeud1(mgnoeud1),noeud2(mgnoeud2),noeud3(mgnoeud3),segment1(mgsegment1),segment2(mgsegment2),segment3(mgsegment3)
31			{
32			init_triangle();
33			}
34
35			MG_TRIANGLE::MG_TRIANGLE(MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD mgnoeud1,class MG_NOEUD mgnoeud2,class MG_NOEUD mgnoeud3,class MG_SEGMENT mgsegment1,class MG_SEGMENT* mgsegment2,class MG_SEGMENT* mgsegment3,int origine):MG_ELEMENT_MAILLAGE(topo,origine),noeud1(mgnoeud1),noeud2(mgnoeud2),noeud3(mgnoeud3),segment1(mgsegment1),segment2(mgsegment2),segment3(mgsegment3)
36			{
37			init_triangle();
38			}
39
40			MG_TRIANGLE::MG_TRIANGLE(MG_TRIANGLE& mdd):MG_ELEMENT_MAILLAGE(mdd),noeud1(mdd.noeud1),noeud2(mdd.noeud2),noeud3(mdd.noeud3),segment1(mdd.segment1),segment2(mdd.segment2),segment3(mdd.segment3)
41			{
42			init_triangle();
43			}
44
45			MG_TRIANGLE* MG_TRIANGLE::dupliquer(MG_MAILLAGE *mgmai,long decalage)
46			{
47			MG_NOEUD* nd1=mgmai->get_mg_noeudid(noeud1->get_id()+decalage);
48			MG_NOEUD* nd2=mgmai->get_mg_noeudid(noeud2->get_id()+decalage);
49			MG_NOEUD* nd3=mgmai->get_mg_noeudid(noeud3->get_id()+decalage);
50			MG_SEGMENT* seg1=mgmai->get_mg_segmentid(segment1->get_id()+decalage);
51			MG_SEGMENT* seg2=mgmai->get_mg_segmentid(segment2->get_id()+decalage);
52			MG_SEGMENT* seg3=mgmai->get_mg_segmentid(segment3->get_id()+decalage);
53			MG_TRIANGLE* tri=new MG_TRIANGLE(this->get_id()+decalage,liaison_topologique,nd1,nd2,nd3,seg1,seg2,seg3,DUPLIQUER);
54			mgmai->ajouter_mg_triangle(tri);
55			return tri;
56			}
57
58
59
60			MG_TRIANGLE::~MG_TRIANGLE()
61			{
62			if (noeud1!=NULL) noeud1->get_lien_triangle()->supprimer(this);
63			if (noeud2!=NULL) noeud2->get_lien_triangle()->supprimer(this);
64			if (noeud3!=NULL) noeud3->get_lien_triangle()->supprimer(this);
65			unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
66			noeudminid=std::min(noeudminid,noeud3->get_id());
67			if (noeud1!=NULL)
68			if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_triangle()->supprimer(this);
69			if (noeud2!=NULL)
70			if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_triangle()->supprimer(this);
71			if (noeud3!=NULL)
72			if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_triangle()->supprimer(this);
73			if (segment1!=NULL) {
74			segment1->decrementer();
75			segment1->get_lien_triangle()->supprimer(this);
76			}
77			if (segment2!=NULL) {
78			segment2->decrementer();
79			segment2->get_lien_triangle()->supprimer(this);
80			}
81			if (segment3!=NULL) {
82			segment3->decrementer();
83			segment3->get_lien_triangle()->supprimer(this);
84			}
85	francois	663	if (liaison_topologique!=NULL)
86			if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->supprimer(this);
87	francois	283	}
88
89			void MG_TRIANGLE::init_triangle(void)
90			{
91			if (noeud1!=NULL) noeud1->get_lien_triangle()->ajouter(this);
92			if (noeud2!=NULL) noeud2->get_lien_triangle()->ajouter(this);
93			if (noeud3!=NULL) noeud3->get_lien_triangle()->ajouter(this);
94			unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
95			noeudminid=std::min(noeudminid,noeud3->get_id());
96			if (noeud1!=NULL)
97			if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_triangle()->ajouter(this);
98			if (noeud2!=NULL)
99			if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_triangle()->ajouter(this);
100			if (noeud3!=NULL)
101			if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_triangle()->ajouter(this);
102			if (segment1!=NULL) {
103			segment1->incrementer();
104			segment1->get_lien_triangle()->ajouter(this);
105			}
106			if (segment2!=NULL) {
107			segment2->incrementer();
108			segment2->get_lien_triangle()->ajouter(this);
109			}
110			if (segment3!=NULL) {
111			segment3->incrementer();
112			segment3->get_lien_triangle()->ajouter(this);
113			}
114			if ( (segment1!=NULL) && (segment2!=NULL)&& (segment3!=NULL) )longueur=0.3333333333333333*(segment1->get_longueur()+segment2->get_longueur()+segment3->get_longueur());
115			if (liaison_topologique==NULL) return;
116			if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->ajouter(this);
117			}
118
119
120			int MG_TRIANGLE::get_type_entite(void)
121			{
122			return IDMG_TRIANGLE;
123			}
124
125
126
127			MG_NOEUD* MG_TRIANGLE::get_noeud1(void)
128			{
129			return noeud1;
130			}
131
132			MG_NOEUD* MG_TRIANGLE::get_noeud2(void)
133			{
134			return noeud2;
135			}
136
137
138			MG_NOEUD* MG_TRIANGLE::get_noeud3(void)
139			{
140			return noeud3;
141			}
142
143			MG_SEGMENT* MG_TRIANGLE::get_segment1(void)
144			{
145			return segment1;
146			}
147
148			MG_SEGMENT* MG_TRIANGLE::get_segment2(void)
149			{
150			return segment2;
151			}
152
153			MG_SEGMENT* MG_TRIANGLE::get_segment3(void)
154			{
155			return segment3;
156			}
157
158	francois	702	void MG_TRIANGLE::inverse_sens(void)
159			{
160			MG_NOEUD* noeud=noeud2;
161			noeud2=noeud3;
162			noeud3=noeud;
163			MG_SEGMENT* segment=segment3;
164			segment2=segment3;
165			segment3=segment;
166			}
167	francois	283
168			int MG_TRIANGLE::get_dimension(void)
169			{
170			return 2;
171			}
172
173			double MG_TRIANGLE::get_longueur(void)
174			{
175			return longueur;
176			}
177
178			TPL_LISTE_ENTITE<class MG_TETRA> MG_TRIANGLE::get_lien_tetra(void)
179			{
180			return &tetra;
181			}
182
183			BOITE_2D MG_TRIANGLE::get_boite_2D(double periodeu,double periodev)
184			{
185			OT_DECALAGE_PARAMETRE decalage(periodeu,periodev);
186
187			double coouv1[2];
188			double coouv2[2];
189			double coouv3[2];
190			coouv1[0]=noeud1->get_u();
191			coouv1[1]=noeud1->get_v();
192			coouv2[0]=noeud2->get_u();
193			coouv2[1]=noeud2->get_v();
194			coouv3[0]=noeud3->get_u();
195			coouv3[1]=noeud3->get_v();
196			double coouvd1[2];
197			double coouvd2[2];
198			double coouvd3[2];
199			double du=decalage.calcul_decalage_parametre_u(coouv1[0]);
200			double dv=decalage.calcul_decalage_parametre_v(coouv1[1]);
201			coouvd1[0]=decalage.decalage_parametre_u(coouv1[0],du);
202			coouvd1[1]=decalage.decalage_parametre_v(coouv1[1],dv);
203			coouvd2[0]=decalage.decalage_parametre_u(coouv2[0],du);
204			coouvd2[1]=decalage.decalage_parametre_v(coouv2[1],dv);
205			coouvd3[0]=decalage.decalage_parametre_u(coouv3[0],du);
206			coouvd3[1]=decalage.decalage_parametre_v(coouv3[1],dv);
207			double umin,vmin,umax,vmax;
208			umin=std::min(coouvd1[0],coouvd2[0]);
209			umin=std::min(umin,coouvd3[0]);
210			umax=std::max(coouvd1[0],coouvd2[0]);
211			umax=std::max(umax,coouvd3[0]);
212			vmin=std::min(coouvd1[1],coouvd2[1]);
213			vmin=std::min(vmin,coouvd3[1]);
214			vmax=std::max(coouv1[1],coouvd2[1]);
215			vmax=std::max(vmax,coouvd3[1]);
216			umin=umin-du;
217			umax=umax-du;
218			vmin=vmin-dv;
219			vmax=vmax-dv;
220			BOITE_2D boite(umin,vmin,umax,vmax);
221			return boite;
222			}
223
224			BOITE_3D MG_TRIANGLE::get_boite_3D(void)
225			{
226			double coo1[3];
227			double coo2[3];
228			double coo3[3];
229			coo1[0]=noeud1->get_x();
230			coo1[1]=noeud1->get_y();
231			coo1[2]=noeud1->get_z();
232			coo2[0]=noeud2->get_x();
233			coo2[1]=noeud2->get_y();
234			coo2[2]=noeud2->get_z();
235			coo3[0]=noeud3->get_x();
236			coo3[1]=noeud3->get_y();
237			coo3[2]=noeud3->get_z();
238			double xmin,ymin,zmin,xmax,ymax,zmax;
239			xmin=std::min(coo1[0],coo2[0]);
240			xmin=std::min(xmin,coo3[0]);
241			xmax=std::max(coo1[0],coo2[0]);
242			xmax=std::max(xmax,coo3[0]);
243			ymin=std::min(coo1[1],coo2[1]);
244			ymin=std::min(ymin,coo3[1]);
245			ymax=std::max(coo1[1],coo2[1]);
246			ymax=std::max(ymax,coo3[1]);
247			zmin=std::min(coo1[2],coo2[2]);
248			zmin=std::min(zmin,coo3[2]);
249			zmax=std::max(coo1[2],coo2[2]);
250			zmax=std::max(zmax,coo3[2]);
251			BOITE_3D boite(xmin,ymin,zmin,xmax,ymax,zmax);
252			return boite;
253			}
254			void MG_TRIANGLE::extrapoler_solution_noeud(void)
255			{
256	francois	377	for (int j=0;j<MAX_TYPE_SOLUTION;j++)
257			{
258			noeud1->change_solution(solution[j],j);
259			noeud2->change_solution(solution[j],j);
260			noeud3->change_solution(solution[j],j);
261			}
262	francois	283	}
263
264
265			void MG_TRIANGLE::enregistrer(std::ostream& o)
266			{
267			if ((liaison_topologique==NULL) && (MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO!=2)) return;
268			if (liaison_topologique==NULL) o << "%" << get_id() << "=TRIANGLE(NULL,$" << noeud1->get_id() << ",$" << noeud2->get_id() << ",$" << noeud3->get_id() << "," << origine_creation << ");" << std::endl;
269			else if (liaison_topologique->get_dimension()==2) o << "%" << get_id() << "=TRIANGLE($"<< get_lien_topologie()->get_id() << ",$" << noeud1->get_id() << ",$" << noeud2->get_id() << ",$" << noeud3->get_id() << "," << origine_creation << ");" << std::endl;
270			}
271
272
273
274
275
276