mtu/src/mg_quadrangle.cpp

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mg_quadrangle.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:53 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------


#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,MAGIC::ORIGINE::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 MAGIC::TYPE_ENTITE::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;
}

TPL_LISTE_ENTITE<class MG_PENTA*>* MG_QUADRANGLE::get_lien_penta(void)
{
    return &penta;
}

TPL_LISTE_ENTITE<class MG_PYRAMIDE*>* MG_QUADRANGLE::get_lien_pyramide(void)
{
    return &pyramide;
}

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:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (11 months, 1 week ago) by francois
File size:	12019 byte(s)
Log Message:	compatibilité Ubuntu 22.04 Suppression des refeences à Windows Ajout d'une banière
#	User	Rev	Content
1	francois	1158	//####//------------------------------------------------------------
2			//####//------------------------------------------------------------
3			//####// MAGiC
4			//####// Jean Christophe Cuilliere et Vincent FRANCOIS
5			//####// Departement de Genie Mecanique - UQTR
6			//####//------------------------------------------------------------
7			//####// MAGIC est un projet de recherche de l equipe ERICCA
8			//####// du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
9			//####// http://www.uqtr.ca/ericca
10			//####// http://www.uqtr.ca/
11			//####//------------------------------------------------------------
12			//####//------------------------------------------------------------
13			//####//
14			//####// mg_quadrangle.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:53 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	francois	308
23
24			#include "gestionversion.h"
25			#include "mg_quadrangle.h"
26			#include "mg_hexa.h"
27			#include "mg_maillage.h"
28			#include "ot_decalage_parametre.h"
29
30			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)
31			{
32			init_quadrangle();
33			}
34
35			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)
36			{
37			init_quadrangle();
38			}
39
40			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)
41			{
42			init_quadrangle();
43			}
44
45			MG_QUADRANGLE* MG_QUADRANGLE::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_NOEUD* nd4=mgmai->get_mg_noeudid(noeud4->get_id()+decalage);
51			MG_SEGMENT* seg1=mgmai->get_mg_segmentid(segment1->get_id()+decalage);
52			MG_SEGMENT* seg2=mgmai->get_mg_segmentid(segment2->get_id()+decalage);
53			MG_SEGMENT* seg3=mgmai->get_mg_segmentid(segment3->get_id()+decalage);
54			MG_SEGMENT* seg4=mgmai->get_mg_segmentid(segment4->get_id()+decalage);
55	francois	791	MG_QUADRANGLE* quad=new MG_QUADRANGLE(this->get_id()+decalage,liaison_topologique,nd1,nd2,nd3,nd4,seg1,seg2,seg3,seg4,MAGIC::ORIGINE::DUPLIQUER);
56	francois	308	mgmai->ajouter_mg_quadrangle(quad);
57			return quad;
58			}
59
60
61
62			MG_QUADRANGLE::~MG_QUADRANGLE()
63			{
64			if (noeud1!=NULL) noeud1->get_lien_quadrangle()->supprimer(this);
65			if (noeud2!=NULL) noeud2->get_lien_quadrangle()->supprimer(this);
66			if (noeud3!=NULL) noeud3->get_lien_quadrangle()->supprimer(this);
67			if (noeud4!=NULL) noeud4->get_lien_quadrangle()->supprimer(this);
68			unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
69			noeudminid=std::min(noeudminid,noeud3->get_id());
70			noeudminid=std::min(noeudminid,noeud4->get_id());
71			if (noeud1!=NULL)
72			if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_quadrangle()->supprimer(this);
73			if (noeud2!=NULL)
74			if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_quadrangle()->supprimer(this);
75			if (noeud3!=NULL)
76			if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_quadrangle()->supprimer(this);
77			if (noeud4!=NULL)
78			if (noeud4->get_id()==noeudminid) noeud4->get_lien_petit_quadrangle()->supprimer(this);
79			if (segment1!=NULL) {
80			segment1->decrementer();
81			segment1->get_lien_quadrangle()->supprimer(this);
82			}
83			if (segment2!=NULL) {
84			segment2->decrementer();
85			segment2->get_lien_quadrangle()->supprimer(this);
86			}
87			if (segment3!=NULL) {
88			segment3->decrementer();
89			segment3->get_lien_quadrangle()->supprimer(this);
90			}
91			if (segment4!=NULL) {
92			segment4->decrementer();
93			segment4->get_lien_quadrangle()->supprimer(this);
94			}
95	francois	663	if (liaison_topologique!=NULL)
96			if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->supprimer(this);
97	francois	308	}
98
99			void MG_QUADRANGLE::init_quadrangle(void)
100			{
101			if (noeud1!=NULL) noeud1->get_lien_quadrangle()->ajouter(this);
102			if (noeud2!=NULL) noeud2->get_lien_quadrangle()->ajouter(this);
103			if (noeud3!=NULL) noeud3->get_lien_quadrangle()->ajouter(this);
104			if (noeud4!=NULL) noeud4->get_lien_quadrangle()->ajouter(this);
105			unsigned long noeudminid=std::min(noeud1->get_id(),noeud2->get_id());
106			noeudminid=std::min(noeudminid,noeud3->get_id());
107			noeudminid=std::min(noeudminid,noeud4->get_id());
108			if (noeud1!=NULL)
109			if (noeud1->get_id()==noeudminid) noeud1->get_lien_petit_quadrangle()->ajouter(this);
110			if (noeud2!=NULL)
111			if (noeud2->get_id()==noeudminid) noeud2->get_lien_petit_quadrangle()->ajouter(this);
112			if (noeud3!=NULL)
113			if (noeud3->get_id()==noeudminid) noeud3->get_lien_petit_quadrangle()->ajouter(this);
114			if (noeud4!=NULL)
115			if (noeud4->get_id()==noeudminid) noeud4->get_lien_petit_quadrangle()->ajouter(this);
116			if (segment1!=NULL) {
117			segment1->incrementer();
118			segment1->get_lien_quadrangle()->ajouter(this);
119			}
120			if (segment2!=NULL) {
121			segment2->incrementer();
122			segment2->get_lien_quadrangle()->ajouter(this);
123			}
124			if (segment3!=NULL) {
125			segment3->incrementer();
126			segment3->get_lien_quadrangle()->ajouter(this);
127			}
128			if (segment4!=NULL) {
129			segment4->incrementer();
130			segment4->get_lien_quadrangle()->ajouter(this);
131			}
132			if ( (segment1!=NULL) && (segment2!=NULL)&& (segment3!=NULL) && (segment4!=NULL) ) longueur=0.25*(segment1->get_longueur()+segment2->get_longueur()+segment3->get_longueur()+segment4->get_longueur());
133			if (liaison_topologique==NULL) return;
134			if (liaison_topologique->get_dimension()==2) liaison_topologique->get_lien_maillage()->ajouter(this);
135			}
136
137
138			int MG_QUADRANGLE::get_type_entite(void)
139			{
140	francois	1150	return MAGIC::TYPE_ENTITE::IDMG_QUADRANGLE;
141	francois	308	}
142
143
144
145			MG_NOEUD* MG_QUADRANGLE::get_noeud1(void)
146			{
147			return noeud1;
148			}
149
150			MG_NOEUD* MG_QUADRANGLE::get_noeud2(void)
151			{
152			return noeud2;
153			}
154
155
156			MG_NOEUD* MG_QUADRANGLE::get_noeud3(void)
157			{
158			return noeud3;
159			}
160
161			MG_NOEUD* MG_QUADRANGLE::get_noeud4(void)
162			{
163			return noeud4;
164			}
165
166			MG_SEGMENT* MG_QUADRANGLE::get_segment1(void)
167			{
168			return segment1;
169			}
170
171			MG_SEGMENT* MG_QUADRANGLE::get_segment2(void)
172			{
173			return segment2;
174			}
175
176			MG_SEGMENT* MG_QUADRANGLE::get_segment3(void)
177			{
178			return segment3;
179			}
180
181			MG_SEGMENT* MG_QUADRANGLE::get_segment4(void)
182			{
183			return segment4;
184			}
185
186	francois	702	void MG_QUADRANGLE::inverse_sens(void)
187			{
188			MG_NOEUD *noeud=noeud4;
189			noeud4=noeud2;
190			noeud2=noeud;
191			MG_SEGMENT *segment=segment4;
192			segment4=segment2;
193			segment2=segment;
194			}
195	francois	308
196			int MG_QUADRANGLE::get_dimension(void)
197			{
198			return 2;
199			}
200
201			double MG_QUADRANGLE::get_longueur(void)
202			{
203			return longueur;
204			}
205
206			TPL_LISTE_ENTITE<class MG_HEXA> MG_QUADRANGLE::get_lien_hexa(void)
207			{
208			return &hexa;
209			}
210
211	francois	876	TPL_LISTE_ENTITE<class MG_PENTA> MG_QUADRANGLE::get_lien_penta(void)
212			{
213			return &penta;
214			}
215
216	francois	1123	TPL_LISTE_ENTITE<class MG_PYRAMIDE> MG_QUADRANGLE::get_lien_pyramide(void)
217			{
218			return &pyramide;
219			}
220
221	francois	308	BOITE_2D MG_QUADRANGLE::get_boite_2D(double periodeu,double periodev)
222			{
223			OT_DECALAGE_PARAMETRE decalage(periodeu,periodev);
224
225			double coouv1[2];
226			double coouv2[2];
227			double coouv3[2];
228			double coouv4[2];
229			coouv1[0]=noeud1->get_u();
230			coouv1[1]=noeud1->get_v();
231			coouv2[0]=noeud2->get_u();
232			coouv2[1]=noeud2->get_v();
233			coouv3[0]=noeud3->get_u();
234			coouv3[1]=noeud3->get_v();
235			coouv4[0]=noeud4->get_u();
236			coouv4[1]=noeud4->get_v();
237			double coouvd1[2];
238			double coouvd2[2];
239			double coouvd3[2];
240			double coouvd4[2];
241			double du=decalage.calcul_decalage_parametre_u(coouv1[0]);
242			double dv=decalage.calcul_decalage_parametre_v(coouv1[1]);
243			coouvd1[0]=decalage.decalage_parametre_u(coouv1[0],du);
244			coouvd1[1]=decalage.decalage_parametre_v(coouv1[1],dv);
245			coouvd2[0]=decalage.decalage_parametre_u(coouv2[0],du);
246			coouvd2[1]=decalage.decalage_parametre_v(coouv2[1],dv);
247			coouvd3[0]=decalage.decalage_parametre_u(coouv3[0],du);
248			coouvd3[1]=decalage.decalage_parametre_v(coouv3[1],dv);
249			coouvd4[0]=decalage.decalage_parametre_u(coouv4[0],du);
250			coouvd4[1]=decalage.decalage_parametre_v(coouv4[1],dv);
251			double umin,vmin,umax,vmax;
252			umin=std::min(coouvd1[0],coouvd2[0]);
253			umin=std::min(umin,coouvd3[0]);
254			umin=std::min(umin,coouvd4[0]);
255			umax=std::max(coouvd1[0],coouvd2[0]);
256			umax=std::max(umax,coouvd3[0]);
257			umax=std::max(umax,coouvd4[0]);
258			vmin=std::min(coouvd1[1],coouvd2[1]);
259			vmin=std::min(vmin,coouvd3[1]);
260			vmin=std::min(vmin,coouvd4[1]);
261			vmax=std::max(coouv1[1],coouvd2[1]);
262			vmax=std::max(vmax,coouvd3[1]);
263			vmax=std::max(vmax,coouvd4[1]);
264			umin=umin-du;
265			umax=umax-du;
266			vmin=vmin-dv;
267			vmax=vmax-dv;
268			BOITE_2D boite(umin,vmin,umax,vmax);
269			return boite;
270			}
271
272			BOITE_3D MG_QUADRANGLE::get_boite_3D(void)
273			{
274			double coo1[3];
275			double coo2[3];
276			double coo3[3];
277			double coo4[3];
278			coo1[0]=noeud1->get_x();
279			coo1[1]=noeud1->get_y();
280			coo1[2]=noeud1->get_z();
281			coo2[0]=noeud2->get_x();
282			coo2[1]=noeud2->get_y();
283			coo2[2]=noeud2->get_z();
284			coo3[0]=noeud3->get_x();
285			coo3[1]=noeud3->get_y();
286			coo3[2]=noeud3->get_z();
287			coo4[0]=noeud4->get_x();
288			coo4[1]=noeud4->get_y();
289			coo4[2]=noeud4->get_z();
290			double xmin,ymin,zmin,xmax,ymax,zmax;
291			xmin=std::min(coo1[0],coo2[0]);
292			xmin=std::min(xmin,coo3[0]);
293			xmin=std::min(xmin,coo4[0]);
294			xmax=std::max(coo1[0],coo2[0]);
295			xmax=std::max(xmax,coo3[0]);
296			xmax=std::max(xmax,coo4[0]);
297			ymin=std::min(coo1[1],coo2[1]);
298			ymin=std::min(ymin,coo3[1]);
299			ymin=std::min(ymin,coo4[1]);
300			ymax=std::max(coo1[1],coo2[1]);
301			ymax=std::max(ymax,coo3[1]);
302			ymax=std::max(ymax,coo4[1]);
303			zmin=std::min(coo1[2],coo2[2]);
304			zmin=std::min(zmin,coo3[2]);
305			zmin=std::min(zmin,coo4[2]);
306			zmax=std::max(coo1[2],coo2[2]);
307			zmax=std::max(zmax,coo3[2]);
308			zmax=std::max(zmax,coo4[2]);
309			BOITE_3D boite(xmin,ymin,zmin,xmax,ymax,zmax);
310			return boite;
311			}
312			void MG_QUADRANGLE::extrapoler_solution_noeud(void)
313			{
314	francois	377	for (int j=0;j<MAX_TYPE_SOLUTION;j++)
315			{
316			noeud1->change_solution(solution[j],j);
317			noeud2->change_solution(solution[j],j);
318			noeud3->change_solution(solution[j],j);
319			noeud4->change_solution(solution[j],j);
320			} }
321	francois	308
322
323
324	francois	763	void MG_QUADRANGLE::enregistrer(std::ostream& o,double version)
325	francois	308	{
326			if ((liaison_topologique==NULL) && (MG_MAILLAGE::DIMENSIONMAILLAGESANSTOPO!=2)) return;
327			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;
328			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;
329			}
330
331
332
333
334
335