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) 
          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;
}

void MG_QUADRANGLE::inverse_sens(void)
{
MG_NOEUD *noeud=noeud4;  
noeud4=noeud2;
noeud2=noeud;
MG_SEGMENT *segment=segment4;
segment4=segment2;
segment2=segment;  
} 

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,double version)
{
    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:	763
Committed:	Wed Dec 2 19:55:53 2015 UTC (9 years, 5 months ago) by francois
File size:	11725 byte(s)
Log Message:	Le fichier MAGiC est maintenant versionné. LA version actuelle est 2.0. L'ancienne version est 1.0. Tout est transparent pour l'utilisateur. Les vieilles versions sont lisibles mais les nouveaux enregistrements sont dans la version la plus récente. Changement des conditions aux limites : ajout d'un parametre pour dire si la condition numerique est une valeur ou une formule ou un lien vers une autre entité magic. Les parametres pour saisir sont maintenant -ccf -ccfi -ccff -ccft -ccfit -ccfft
#	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	francois	663	if (liaison_topologique!=NULL)
97			if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->supprimer(this);
98	francois	308	}
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	francois	702	void MG_QUADRANGLE::inverse_sens(void)
188			{
189			MG_NOEUD *noeud=noeud4;
190			noeud4=noeud2;
191			noeud2=noeud;
192			MG_SEGMENT *segment=segment4;
193			segment4=segment2;
194			segment2=segment;
195			}
196	francois	308
197			int MG_QUADRANGLE::get_dimension(void)
198			{
199			return 2;
200			}
201
202			double MG_QUADRANGLE::get_longueur(void)
203			{
204			return longueur;
205			}
206
207			TPL_LISTE_ENTITE<class MG_HEXA> MG_QUADRANGLE::get_lien_hexa(void)
208			{
209			return &hexa;
210			}
211
212			BOITE_2D MG_QUADRANGLE::get_boite_2D(double periodeu,double periodev)
213			{
214			OT_DECALAGE_PARAMETRE decalage(periodeu,periodev);
215
216			double coouv1[2];
217			double coouv2[2];
218			double coouv3[2];
219			double coouv4[2];
220			coouv1[0]=noeud1->get_u();
221			coouv1[1]=noeud1->get_v();
222			coouv2[0]=noeud2->get_u();
223			coouv2[1]=noeud2->get_v();
224			coouv3[0]=noeud3->get_u();
225			coouv3[1]=noeud3->get_v();
226			coouv4[0]=noeud4->get_u();
227			coouv4[1]=noeud4->get_v();
228			double coouvd1[2];
229			double coouvd2[2];
230			double coouvd3[2];
231			double coouvd4[2];
232			double du=decalage.calcul_decalage_parametre_u(coouv1[0]);
233			double dv=decalage.calcul_decalage_parametre_v(coouv1[1]);
234			coouvd1[0]=decalage.decalage_parametre_u(coouv1[0],du);
235			coouvd1[1]=decalage.decalage_parametre_v(coouv1[1],dv);
236			coouvd2[0]=decalage.decalage_parametre_u(coouv2[0],du);
237			coouvd2[1]=decalage.decalage_parametre_v(coouv2[1],dv);
238			coouvd3[0]=decalage.decalage_parametre_u(coouv3[0],du);
239			coouvd3[1]=decalage.decalage_parametre_v(coouv3[1],dv);
240			coouvd4[0]=decalage.decalage_parametre_u(coouv4[0],du);
241			coouvd4[1]=decalage.decalage_parametre_v(coouv4[1],dv);
242			double umin,vmin,umax,vmax;
243			umin=std::min(coouvd1[0],coouvd2[0]);
244			umin=std::min(umin,coouvd3[0]);
245			umin=std::min(umin,coouvd4[0]);
246			umax=std::max(coouvd1[0],coouvd2[0]);
247			umax=std::max(umax,coouvd3[0]);
248			umax=std::max(umax,coouvd4[0]);
249			vmin=std::min(coouvd1[1],coouvd2[1]);
250			vmin=std::min(vmin,coouvd3[1]);
251			vmin=std::min(vmin,coouvd4[1]);
252			vmax=std::max(coouv1[1],coouvd2[1]);
253			vmax=std::max(vmax,coouvd3[1]);
254			vmax=std::max(vmax,coouvd4[1]);
255			umin=umin-du;
256			umax=umax-du;
257			vmin=vmin-dv;
258			vmax=vmax-dv;
259			BOITE_2D boite(umin,vmin,umax,vmax);
260			return boite;
261			}
262
263			BOITE_3D MG_QUADRANGLE::get_boite_3D(void)
264			{
265			double coo1[3];
266			double coo2[3];
267			double coo3[3];
268			double coo4[3];
269			coo1[0]=noeud1->get_x();
270			coo1[1]=noeud1->get_y();
271			coo1[2]=noeud1->get_z();
272			coo2[0]=noeud2->get_x();
273			coo2[1]=noeud2->get_y();
274			coo2[2]=noeud2->get_z();
275			coo3[0]=noeud3->get_x();
276			coo3[1]=noeud3->get_y();
277			coo3[2]=noeud3->get_z();
278			coo4[0]=noeud4->get_x();
279			coo4[1]=noeud4->get_y();
280			coo4[2]=noeud4->get_z();
281			double xmin,ymin,zmin,xmax,ymax,zmax;
282			xmin=std::min(coo1[0],coo2[0]);
283			xmin=std::min(xmin,coo3[0]);
284			xmin=std::min(xmin,coo4[0]);
285			xmax=std::max(coo1[0],coo2[0]);
286			xmax=std::max(xmax,coo3[0]);
287			xmax=std::max(xmax,coo4[0]);
288			ymin=std::min(coo1[1],coo2[1]);
289			ymin=std::min(ymin,coo3[1]);
290			ymin=std::min(ymin,coo4[1]);
291			ymax=std::max(coo1[1],coo2[1]);
292			ymax=std::max(ymax,coo3[1]);
293			ymax=std::max(ymax,coo4[1]);
294			zmin=std::min(coo1[2],coo2[2]);
295			zmin=std::min(zmin,coo3[2]);
296			zmin=std::min(zmin,coo4[2]);
297			zmax=std::max(coo1[2],coo2[2]);
298			zmax=std::max(zmax,coo3[2]);
299			zmax=std::max(zmax,coo4[2]);
300			BOITE_3D boite(xmin,ymin,zmin,xmax,ymax,zmax);
301			return boite;
302			}
303			void MG_QUADRANGLE::extrapoler_solution_noeud(void)
304			{
305	francois	377	for (int j=0;j<MAX_TYPE_SOLUTION;j++)
306			{
307			noeud1->change_solution(solution[j],j);
308			noeud2->change_solution(solution[j],j);
309			noeud3->change_solution(solution[j],j);
310			noeud4->change_solution(solution[j],j);
311			} }
312	francois	308
313
314
315	francois	763	void MG_QUADRANGLE::enregistrer(std::ostream& o,double version)
316	francois	308	{
317			if ((liaison_topologique==NULL) && (MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO!=2)) return;
318			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;
319			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;
320			}
321
322
323
324
325
326