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


#include "gestionversion.h"
#include "mg_quadrangle.h"
#include "mg_hexa.h"
#include "mg_maillage.h"
#include "ot_decalage_parametre.h"

MG_QUADRANGLE::MG_QUADRANGLE(unsigned long num,MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,class MG_NOEUD *mgnoeud3,class MG_NOEUD *mgnoeud4,class MG_SEGMENT* mgsegment1,class MG_SEGMENT* mgsegment2,class MG_SEGMENT* mgsegment3,class MG_SEGMENT* mgsegment4,int origine):MG_ELEMENT_MAILLAGE(num,topo,origine),noeud1(mgnoeud1),noeud2(mgnoeud2),noeud3(mgnoeud3),noeud4(mgnoeud4),segment1(mgsegment1),segment2(mgsegment2),segment3(mgsegment3),segment4(mgsegment4)
{
    init_quadrangle();
}

MG_QUADRANGLE::MG_QUADRANGLE(MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD *mgnoeud1,class MG_NOEUD *mgnoeud2,class MG_NOEUD *mgnoeud3,class MG_NOEUD *mgnoeud4,class MG_SEGMENT* mgsegment1,class MG_SEGMENT* mgsegment2,class MG_SEGMENT* mgsegment3,class MG_SEGMENT* mgsegment4,int origine):MG_ELEMENT_MAILLAGE(topo,origine),noeud1(mgnoeud1),noeud2(mgnoeud2),noeud3(mgnoeud3),noeud4(mgnoeud4),segment1(mgsegment1),segment2(mgsegment2),segment3(mgsegment3),segment4(mgsegment4)
{
    init_quadrangle();
}

MG_QUADRANGLE::MG_QUADRANGLE(MG_QUADRANGLE& mdd):MG_ELEMENT_MAILLAGE(mdd),noeud1(mdd.noeud1),noeud2(mdd.noeud2),noeud3(mdd.noeud3),noeud4(mdd.noeud4),segment1(mdd.segment1),segment2(mdd.segment2),segment3(mdd.segment3),segment4(mdd.segment4)
{
    init_quadrangle();
}

MG_QUADRANGLE* MG_QUADRANGLE::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_NOEUD* nd4=mgmai->get_mg_noeudid(noeud4->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_SEGMENT* seg4=mgmai->get_mg_segmentid(segment4->get_id()+decalage);
    MG_QUADRANGLE* quad=new MG_QUADRANGLE(this->get_id()+decalage,liaison_topologique,nd1,nd2,nd3,nd4,seg1,seg2,seg3,seg4,DUPLIQUER);
    mgmai->ajouter_mg_quadrangle(quad);
    return quad;
}


MG_QUADRANGLE::~MG_QUADRANGLE()
{
    if (noeud1!=NULL) noeud1->get_lien_quadrangle()->supprimer(this);
    if (noeud2!=NULL) noeud2->get_lien_quadrangle()->supprimer(this);
    if (noeud3!=NULL) noeud3->get_lien_quadrangle()->supprimer(this);
    if (noeud4!=NULL) noeud4->get_lien_quadrangle()->supprimer(this);
    unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
    noeudminid=std::min(noeudminid,noeud3->get_id());
    noeudminid=std::min(noeudminid,noeud4->get_id());
    if (noeud1!=NULL)
        if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_quadrangle()->supprimer(this);
    if (noeud2!=NULL)
        if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_quadrangle()->supprimer(this);
    if (noeud3!=NULL)
        if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_quadrangle()->supprimer(this);
    if (noeud4!=NULL)
        if (noeud4->get_id()==noeudminid) noeud4->get_lien_petit_quadrangle()->supprimer(this);
    if (segment1!=NULL) {
        segment1->decrementer();
        segment1->get_lien_quadrangle()->supprimer(this);
    }
    if (segment2!=NULL) {
        segment2->decrementer();
        segment2->get_lien_quadrangle()->supprimer(this);
    }
    if (segment3!=NULL) {
        segment3->decrementer();
        segment3->get_lien_quadrangle()->supprimer(this);
    }
    if (segment4!=NULL) {
        segment4->decrementer();
        segment4->get_lien_quadrangle()->supprimer(this);
    }
    if (liaison_topologique==NULL) return;
    if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->supprimer(this);
}

void MG_QUADRANGLE::init_quadrangle(void)
{
    if (noeud1!=NULL) noeud1->get_lien_quadrangle()->ajouter(this);
    if (noeud2!=NULL) noeud2->get_lien_quadrangle()->ajouter(this);
    if (noeud3!=NULL) noeud3->get_lien_quadrangle()->ajouter(this);
    if (noeud4!=NULL) noeud4->get_lien_quadrangle()->ajouter(this);
    unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
    noeudminid=std::min(noeudminid,noeud3->get_id());
    noeudminid=std::min(noeudminid,noeud4->get_id());
    if (noeud1!=NULL)
        if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_quadrangle()->ajouter(this);
    if (noeud2!=NULL)
        if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_quadrangle()->ajouter(this);
    if (noeud3!=NULL)
        if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_quadrangle()->ajouter(this);
    if (noeud4!=NULL)
        if (noeud4->get_id()==noeudminid) noeud4->get_lien_petit_quadrangle()->ajouter(this);
    if (segment1!=NULL) {
        segment1->incrementer();
        segment1->get_lien_quadrangle()->ajouter(this);
    }
    if (segment2!=NULL) {
        segment2->incrementer();
        segment2->get_lien_quadrangle()->ajouter(this);
    }
    if (segment3!=NULL) {
        segment3->incrementer();
        segment3->get_lien_quadrangle()->ajouter(this);
    }
    if (segment4!=NULL) {
        segment4->incrementer();
        segment4->get_lien_quadrangle()->ajouter(this);
    }
    if ( (segment1!=NULL) &&  (segment2!=NULL)&& (segment3!=NULL) && (segment4!=NULL) ) longueur=0.25*(segment1->get_longueur()+segment2->get_longueur()+segment3->get_longueur()+segment4->get_longueur());
    if (liaison_topologique==NULL) return;
    if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->ajouter(this);
}


int MG_QUADRANGLE::get_type_entite(void)
{
    return IDMG_QUADRANGLE;
}


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

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


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

MG_NOEUD* MG_QUADRANGLE::get_noeud4(void)
{
    return noeud4;
}

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

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

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

MG_SEGMENT* MG_QUADRANGLE::get_segment4(void)
{
    return segment4;
}


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

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

TPL_LISTE_ENTITE<class MG_HEXA*>* MG_QUADRANGLE::get_lien_hexa(void)
{
    return &hexa;
}

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

    double coouv1[2];
    double coouv2[2];
    double coouv3[2];
    double coouv4[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();
    coouv4[0]=noeud4->get_u();
    coouv4[1]=noeud4->get_v();
    double coouvd1[2];
    double coouvd2[2];
    double coouvd3[2];
    double coouvd4[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);
    coouvd4[0]=decalage.decalage_parametre_u(coouv4[0],du);
    coouvd4[1]=decalage.decalage_parametre_v(coouv4[1],dv);
    double umin,vmin,umax,vmax;
    umin=std::min(coouvd1[0],coouvd2[0]);
    umin=std::min(umin,coouvd3[0]);
    umin=std::min(umin,coouvd4[0]);
    umax=std::max(coouvd1[0],coouvd2[0]);
    umax=std::max(umax,coouvd3[0]);
    umax=std::max(umax,coouvd4[0]);
    vmin=std::min(coouvd1[1],coouvd2[1]);
    vmin=std::min(vmin,coouvd3[1]);
    vmin=std::min(vmin,coouvd4[1]);
    vmax=std::max(coouv1[1],coouvd2[1]);
    vmax=std::max(vmax,coouvd3[1]);
    vmax=std::max(vmax,coouvd4[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_QUADRANGLE::get_boite_3D(void)
{
    double coo1[3];
    double coo2[3];
    double coo3[3];
    double coo4[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();
    coo4[0]=noeud4->get_x();
    coo4[1]=noeud4->get_y();
    coo4[2]=noeud4->get_z();
    double xmin,ymin,zmin,xmax,ymax,zmax;
    xmin=std::min(coo1[0],coo2[0]);
    xmin=std::min(xmin,coo3[0]);
    xmin=std::min(xmin,coo4[0]);
    xmax=std::max(coo1[0],coo2[0]);
    xmax=std::max(xmax,coo3[0]);
    xmax=std::max(xmax,coo4[0]);
    ymin=std::min(coo1[1],coo2[1]);
    ymin=std::min(ymin,coo3[1]);
    ymin=std::min(ymin,coo4[1]);
    ymax=std::max(coo1[1],coo2[1]);
    ymax=std::max(ymax,coo3[1]);
    ymax=std::max(ymax,coo4[1]);
    zmin=std::min(coo1[2],coo2[2]);
    zmin=std::min(zmin,coo3[2]);
    zmin=std::min(zmin,coo4[2]);
    zmax=std::max(coo1[2],coo2[2]);
    zmax=std::max(zmax,coo3[2]);
    zmax=std::max(zmax,coo4[2]);
    BOITE_3D boite(xmin,ymin,zmin,xmax,ymax,zmax);
    return boite;
}
void MG_QUADRANGLE::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);
      noeud4->change_solution(solution[j],j);
}     }                               


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


Revision:	377
Committed:	Thu Nov 15 15:23:45 2012 UTC (12 years, 5 months ago) by francois
File size:	11550 byte(s)
Log Message:	Les solution mg sont aussi vectorielles
#	User	Rev	Content
1	francois	308	//------------------------------------------------------------
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_quadrangle.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_quadrangle.h"
27			#include "mg_hexa.h"
28			#include "mg_maillage.h"
29			#include "ot_decalage_parametre.h"
30
31			MG_QUADRANGLE::MG_QUADRANGLE(unsigned long num,MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD mgnoeud1,class MG_NOEUD mgnoeud2,class MG_NOEUD mgnoeud3,class MG_NOEUD mgnoeud4,class MG_SEGMENT* mgsegment1,class MG_SEGMENT* mgsegment2,class MG_SEGMENT* mgsegment3,class MG_SEGMENT* mgsegment4,int origine):MG_ELEMENT_MAILLAGE(num,topo,origine),noeud1(mgnoeud1),noeud2(mgnoeud2),noeud3(mgnoeud3),noeud4(mgnoeud4),segment1(mgsegment1),segment2(mgsegment2),segment3(mgsegment3),segment4(mgsegment4)
32			{
33			init_quadrangle();
34			}
35
36			MG_QUADRANGLE::MG_QUADRANGLE(MG_ELEMENT_TOPOLOGIQUE* topo,class MG_NOEUD mgnoeud1,class MG_NOEUD mgnoeud2,class MG_NOEUD mgnoeud3,class MG_NOEUD mgnoeud4,class MG_SEGMENT* mgsegment1,class MG_SEGMENT* mgsegment2,class MG_SEGMENT* mgsegment3,class MG_SEGMENT* mgsegment4,int origine):MG_ELEMENT_MAILLAGE(topo,origine),noeud1(mgnoeud1),noeud2(mgnoeud2),noeud3(mgnoeud3),noeud4(mgnoeud4),segment1(mgsegment1),segment2(mgsegment2),segment3(mgsegment3),segment4(mgsegment4)
37			{
38			init_quadrangle();
39			}
40
41			MG_QUADRANGLE::MG_QUADRANGLE(MG_QUADRANGLE& mdd):MG_ELEMENT_MAILLAGE(mdd),noeud1(mdd.noeud1),noeud2(mdd.noeud2),noeud3(mdd.noeud3),noeud4(mdd.noeud4),segment1(mdd.segment1),segment2(mdd.segment2),segment3(mdd.segment3),segment4(mdd.segment4)
42			{
43			init_quadrangle();
44			}
45
46			MG_QUADRANGLE* MG_QUADRANGLE::dupliquer(MG_MAILLAGE *mgmai,long decalage)
47			{
48			MG_NOEUD* nd1=mgmai->get_mg_noeudid(noeud1->get_id()+decalage);
49			MG_NOEUD* nd2=mgmai->get_mg_noeudid(noeud2->get_id()+decalage);
50			MG_NOEUD* nd3=mgmai->get_mg_noeudid(noeud3->get_id()+decalage);
51			MG_NOEUD* nd4=mgmai->get_mg_noeudid(noeud4->get_id()+decalage);
52			MG_SEGMENT* seg1=mgmai->get_mg_segmentid(segment1->get_id()+decalage);
53			MG_SEGMENT* seg2=mgmai->get_mg_segmentid(segment2->get_id()+decalage);
54			MG_SEGMENT* seg3=mgmai->get_mg_segmentid(segment3->get_id()+decalage);
55			MG_SEGMENT* seg4=mgmai->get_mg_segmentid(segment4->get_id()+decalage);
56			MG_QUADRANGLE* quad=new MG_QUADRANGLE(this->get_id()+decalage,liaison_topologique,nd1,nd2,nd3,nd4,seg1,seg2,seg3,seg4,DUPLIQUER);
57			mgmai->ajouter_mg_quadrangle(quad);
58			return quad;
59			}
60
61
62
63			MG_QUADRANGLE::~MG_QUADRANGLE()
64			{
65			if (noeud1!=NULL) noeud1->get_lien_quadrangle()->supprimer(this);
66			if (noeud2!=NULL) noeud2->get_lien_quadrangle()->supprimer(this);
67			if (noeud3!=NULL) noeud3->get_lien_quadrangle()->supprimer(this);
68			if (noeud4!=NULL) noeud4->get_lien_quadrangle()->supprimer(this);
69			unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
70			noeudminid=std::min(noeudminid,noeud3->get_id());
71			noeudminid=std::min(noeudminid,noeud4->get_id());
72			if (noeud1!=NULL)
73			if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_quadrangle()->supprimer(this);
74			if (noeud2!=NULL)
75			if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_quadrangle()->supprimer(this);
76			if (noeud3!=NULL)
77			if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_quadrangle()->supprimer(this);
78			if (noeud4!=NULL)
79			if (noeud4->get_id()==noeudminid) noeud4->get_lien_petit_quadrangle()->supprimer(this);
80			if (segment1!=NULL) {
81			segment1->decrementer();
82			segment1->get_lien_quadrangle()->supprimer(this);
83			}
84			if (segment2!=NULL) {
85			segment2->decrementer();
86			segment2->get_lien_quadrangle()->supprimer(this);
87			}
88			if (segment3!=NULL) {
89			segment3->decrementer();
90			segment3->get_lien_quadrangle()->supprimer(this);
91			}
92			if (segment4!=NULL) {
93			segment4->decrementer();
94			segment4->get_lien_quadrangle()->supprimer(this);
95			}
96			if (liaison_topologique==NULL) return;
97			if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->supprimer(this);
98			}
99
100			void MG_QUADRANGLE::init_quadrangle(void)
101			{
102			if (noeud1!=NULL) noeud1->get_lien_quadrangle()->ajouter(this);
103			if (noeud2!=NULL) noeud2->get_lien_quadrangle()->ajouter(this);
104			if (noeud3!=NULL) noeud3->get_lien_quadrangle()->ajouter(this);
105			if (noeud4!=NULL) noeud4->get_lien_quadrangle()->ajouter(this);
106			unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
107			noeudminid=std::min(noeudminid,noeud3->get_id());
108			noeudminid=std::min(noeudminid,noeud4->get_id());
109			if (noeud1!=NULL)
110			if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_quadrangle()->ajouter(this);
111			if (noeud2!=NULL)
112			if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_quadrangle()->ajouter(this);
113			if (noeud3!=NULL)
114			if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_quadrangle()->ajouter(this);
115			if (noeud4!=NULL)
116			if (noeud4->get_id()==noeudminid) noeud4->get_lien_petit_quadrangle()->ajouter(this);
117			if (segment1!=NULL) {
118			segment1->incrementer();
119			segment1->get_lien_quadrangle()->ajouter(this);
120			}
121			if (segment2!=NULL) {
122			segment2->incrementer();
123			segment2->get_lien_quadrangle()->ajouter(this);
124			}
125			if (segment3!=NULL) {
126			segment3->incrementer();
127			segment3->get_lien_quadrangle()->ajouter(this);
128			}
129			if (segment4!=NULL) {
130			segment4->incrementer();
131			segment4->get_lien_quadrangle()->ajouter(this);
132			}
133			if ( (segment1!=NULL) && (segment2!=NULL)&& (segment3!=NULL) && (segment4!=NULL) ) longueur=0.25*(segment1->get_longueur()+segment2->get_longueur()+segment3->get_longueur()+segment4->get_longueur());
134			if (liaison_topologique==NULL) return;
135			if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->ajouter(this);
136			}
137
138
139			int MG_QUADRANGLE::get_type_entite(void)
140			{
141			return IDMG_QUADRANGLE;
142			}
143
144
145
146			MG_NOEUD* MG_QUADRANGLE::get_noeud1(void)
147			{
148			return noeud1;
149			}
150
151			MG_NOEUD* MG_QUADRANGLE::get_noeud2(void)
152			{
153			return noeud2;
154			}
155
156
157			MG_NOEUD* MG_QUADRANGLE::get_noeud3(void)
158			{
159			return noeud3;
160			}
161
162			MG_NOEUD* MG_QUADRANGLE::get_noeud4(void)
163			{
164			return noeud4;
165			}
166
167			MG_SEGMENT* MG_QUADRANGLE::get_segment1(void)
168			{
169			return segment1;
170			}
171
172			MG_SEGMENT* MG_QUADRANGLE::get_segment2(void)
173			{
174			return segment2;
175			}
176
177			MG_SEGMENT* MG_QUADRANGLE::get_segment3(void)
178			{
179			return segment3;
180			}
181
182			MG_SEGMENT* MG_QUADRANGLE::get_segment4(void)
183			{
184			return segment4;
185			}
186
187
188			int MG_QUADRANGLE::get_dimension(void)
189			{
190			return 2;
191			}
192
193			double MG_QUADRANGLE::get_longueur(void)
194			{
195			return longueur;
196			}
197
198			TPL_LISTE_ENTITE<class MG_HEXA> MG_QUADRANGLE::get_lien_hexa(void)
199			{
200			return &hexa;
201			}
202
203			BOITE_2D MG_QUADRANGLE::get_boite_2D(double periodeu,double periodev)
204			{
205			OT_DECALAGE_PARAMETRE decalage(periodeu,periodev);
206
207			double coouv1[2];
208			double coouv2[2];
209			double coouv3[2];
210			double coouv4[2];
211			coouv1[0]=noeud1->get_u();
212			coouv1[1]=noeud1->get_v();
213			coouv2[0]=noeud2->get_u();
214			coouv2[1]=noeud2->get_v();
215			coouv3[0]=noeud3->get_u();
216			coouv3[1]=noeud3->get_v();
217			coouv4[0]=noeud4->get_u();
218			coouv4[1]=noeud4->get_v();
219			double coouvd1[2];
220			double coouvd2[2];
221			double coouvd3[2];
222			double coouvd4[2];
223			double du=decalage.calcul_decalage_parametre_u(coouv1[0]);
224			double dv=decalage.calcul_decalage_parametre_v(coouv1[1]);
225			coouvd1[0]=decalage.decalage_parametre_u(coouv1[0],du);
226			coouvd1[1]=decalage.decalage_parametre_v(coouv1[1],dv);
227			coouvd2[0]=decalage.decalage_parametre_u(coouv2[0],du);
228			coouvd2[1]=decalage.decalage_parametre_v(coouv2[1],dv);
229			coouvd3[0]=decalage.decalage_parametre_u(coouv3[0],du);
230			coouvd3[1]=decalage.decalage_parametre_v(coouv3[1],dv);
231			coouvd4[0]=decalage.decalage_parametre_u(coouv4[0],du);
232			coouvd4[1]=decalage.decalage_parametre_v(coouv4[1],dv);
233			double umin,vmin,umax,vmax;
234			umin=std::min(coouvd1[0],coouvd2[0]);
235			umin=std::min(umin,coouvd3[0]);
236			umin=std::min(umin,coouvd4[0]);
237			umax=std::max(coouvd1[0],coouvd2[0]);
238			umax=std::max(umax,coouvd3[0]);
239			umax=std::max(umax,coouvd4[0]);
240			vmin=std::min(coouvd1[1],coouvd2[1]);
241			vmin=std::min(vmin,coouvd3[1]);
242			vmin=std::min(vmin,coouvd4[1]);
243			vmax=std::max(coouv1[1],coouvd2[1]);
244			vmax=std::max(vmax,coouvd3[1]);
245			vmax=std::max(vmax,coouvd4[1]);
246			umin=umin-du;
247			umax=umax-du;
248			vmin=vmin-dv;
249			vmax=vmax-dv;
250			BOITE_2D boite(umin,vmin,umax,vmax);
251			return boite;
252			}
253
254			BOITE_3D MG_QUADRANGLE::get_boite_3D(void)
255			{
256			double coo1[3];
257			double coo2[3];
258			double coo3[3];
259			double coo4[3];
260			coo1[0]=noeud1->get_x();
261			coo1[1]=noeud1->get_y();
262			coo1[2]=noeud1->get_z();
263			coo2[0]=noeud2->get_x();
264			coo2[1]=noeud2->get_y();
265			coo2[2]=noeud2->get_z();
266			coo3[0]=noeud3->get_x();
267			coo3[1]=noeud3->get_y();
268			coo3[2]=noeud3->get_z();
269			coo4[0]=noeud4->get_x();
270			coo4[1]=noeud4->get_y();
271			coo4[2]=noeud4->get_z();
272			double xmin,ymin,zmin,xmax,ymax,zmax;
273			xmin=std::min(coo1[0],coo2[0]);
274			xmin=std::min(xmin,coo3[0]);
275			xmin=std::min(xmin,coo4[0]);
276			xmax=std::max(coo1[0],coo2[0]);
277			xmax=std::max(xmax,coo3[0]);
278			xmax=std::max(xmax,coo4[0]);
279			ymin=std::min(coo1[1],coo2[1]);
280			ymin=std::min(ymin,coo3[1]);
281			ymin=std::min(ymin,coo4[1]);
282			ymax=std::max(coo1[1],coo2[1]);
283			ymax=std::max(ymax,coo3[1]);
284			ymax=std::max(ymax,coo4[1]);
285			zmin=std::min(coo1[2],coo2[2]);
286			zmin=std::min(zmin,coo3[2]);
287			zmin=std::min(zmin,coo4[2]);
288			zmax=std::max(coo1[2],coo2[2]);
289			zmax=std::max(zmax,coo3[2]);
290			zmax=std::max(zmax,coo4[2]);
291			BOITE_3D boite(xmin,ymin,zmin,xmax,ymax,zmax);
292			return boite;
293			}
294			void MG_QUADRANGLE::extrapoler_solution_noeud(void)
295			{
296	francois	377	for (int j=0;j<MAX_TYPE_SOLUTION;j++)
297			{
298			noeud1->change_solution(solution[j],j);
299			noeud2->change_solution(solution[j],j);
300			noeud3->change_solution(solution[j],j);
301			noeud4->change_solution(solution[j],j);
302			} }
303	francois	308
304
305
306			void MG_QUADRANGLE::enregistrer(std::ostream& o)
307			{
308			if ((liaison_topologique==NULL) && (MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO!=2)) return;
309			if (liaison_topologique==NULL) o << "%" << get_id() << "=QUADRANGLE(NULL,$" << noeud1->get_id() << ",$" << noeud2->get_id() << ",$" << noeud3->get_id() << ",$" << noeud4->get_id() << "," << origine_creation << ");" << std::endl;
310			else if (liaison_topologique->get_dimension()==2) o << "%" << get_id() << "=QUADRANGLE($"<< get_lien_topologie()->get_id() << ",$" << noeud1->get_id() << ",$" << noeud2->get_id() << ",$" << noeud3->get_id() << ",$" << noeud4->get_id() << "," << origine_creation << ");" << std::endl;
311			}
312
313
314
315
316
317