mtu/src/mg_volume.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_volume.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:54 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------


#include "gestionversion.h"
#include "mg_volume.h"
#include "ot_mathematique.h"
#include "mg_maillage.h"
#include "vct_volume.h"

MG_VOLUME::MG_VOLUME(std::string idori,unsigned long num):MG_ELEMENT_TOPOLOGIQUE(num,idori),num_materiau(-1),vect(NULL),mince(false)
{
}

MG_VOLUME::MG_VOLUME(std::string idori):MG_ELEMENT_TOPOLOGIQUE(idori),num_materiau(-1),vect(NULL),mince(false)
{
}

MG_VOLUME::MG_VOLUME(MG_VOLUME& mdd):MG_ELEMENT_TOPOLOGIQUE(mdd),lst_coquille(mdd.lst_coquille),vect(mdd.vect),mince(mdd.mince)
{
}

MG_VOLUME::~MG_VOLUME()
{
}

void MG_VOLUME::ajouter_mg_coquille(class MG_COQUILLE* mgcoq)
{
    lst_coquille.insert(lst_coquille.end(),mgcoq);
}

void MG_VOLUME::supprimer_mg_coquille(class MG_COQUILLE* mgcoq)
{
    std::vector<MG_COQUILLE*>::iterator i;
    for (i=lst_coquille.begin();i!=lst_coquille.end();i++)
    {
        if ((*i)==mgcoq)
        {
            lst_coquille.erase(i);
            return;
        }
    }
}


int MG_VOLUME::get_nb_mg_coquille(void)
{
    return lst_coquille.size();
}

MG_COQUILLE* MG_VOLUME::get_mg_coquille(int num)
{
    return lst_coquille[num];
}

int MG_VOLUME::get_dimension(void)
{
    return 3;
}

int MG_VOLUME::get_type(void)
{
  return TYPE_ELEMENT_TOPOLOGIQUE::VOLUME;
}

VCT& MG_VOLUME::get_vectorisation(void)
{
    if (vect==NULL) vect=new VCT_VOLUME(this);
    return *vect;
}
void MG_VOLUME::get_topologie_sousjacente(TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> *lst)
{
    int nbcoq=lst_coquille.size();
    for (int i=0;i<nbcoq;i++)
    {
        MG_COQUILLE* coq=lst_coquille[i];
        int nbface=coq->get_nb_mg_coface();
        for (int j=0;j<nbface;j++)
        {
            MG_FACE* face=coq->get_mg_coface(j)->get_face();
            lst->ajouter(face);
            face->get_topologie_sousjacente(lst);
        }
    }
}


BOITE_3D MG_VOLUME::get_boite_3D(void)
{
BOITE_3D boitevol;
int nb_coquille=get_nb_mg_coquille();
for (int i=0;i<nb_coquille;i++)
    {
    MG_COQUILLE* coq=get_mg_coquille(i);
    int nb_face=coq->get_nb_mg_coface();
    for (int j=0;j<nb_face;j++)
          {
          MG_FACE* face=coq->get_mg_coface(j)->get_face();
          BOITE_3D tmp=face->get_boite_3D();
          if ((i==0) && (j==0))  boitevol=tmp;
          else boitevol=tmp+boitevol;
          }
    }
return boitevol;
}

void MG_VOLUME::enregistrer(std::ostream& o,double version)
{
    o << "%" << get_id() << "=VOLUME(" << get_idoriginal() << ",(";
    for (unsigned int i=0;i<lst_coquille.size();i++)
    {
        o << "$" << lst_coquille[i]->get_id();
        if (i!=lst_coquille.size()-1) o << ",";
        else o << ")";
    }
    int nb=get_nb_ccf();
    if (version<2) 
    {
    o << "," << num_materiau << "," << nb;
    if (nb!=0)
    {
        o << ",(";
        for (int i=0;i<nb;i++)
        {
            char nom[3];
            get_type_ccf(i,nom);
            o << "(" <<  nom << "," << get_valeur_ccf(i) << ")";
            if (i!=nb-1) o << "," ;
        }
        o << ")";
    }
    o << ");" << std::endl;
    }
    else
    {
     if (version>2.2)
        {
          if (mince) o << ",1" ;
          else o << ",0" ;
          if (mince)
            {
            o << ",(" ;  
            for (int i=0;i<get_nb_face_correspondante()-1;i++)
            o <<  "$" << lst_base[i]->get_id() << ","  << "$" <<  lst_extrude[i]->get_id() << "," ; 
            o << "$" << lst_base[get_nb_face_correspondante()-1]->get_id() << ","  << "$" << lst_extrude[get_nb_face_correspondante()-1]->get_id(); 
            o << ")" ;  
            }
        }
    o << "," ;
    enregistrer_ccf(o,version);  
    o << ");" << std::endl;
    }
}

void MG_VOLUME::change_num_materiau(int num)
{
    num_materiau=num;
}

int MG_VOLUME::get_num_materiau(void)
{
    return num_materiau;
}


bool MG_VOLUME::est_un_volume_element(void)
{
return false;
}


void MG_VOLUME::ajouter_face_correspondante(MG_FACE* face1,MG_FACE* face2)
{
lst_base.push_back(face1);  
lst_extrude.push_back(face2);  
mince=true;
}

void MG_VOLUME::get_face_correspondante(int num,MG_FACE** face1,MG_FACE** face2)
{
(*face1)=lst_base[num];  
(*face2)=lst_extrude[num];  
}

int MG_VOLUME::get_nb_face_correspondante(void)
{
return lst_base.size();  
}

bool MG_VOLUME::est_mince(void)
{
return mince;  
}


void MG_VOLUME::get_propriete_massique(class MG_MAILLAGE* mai,double& volume,double &masse,class OT_VECTEUR_3D& cdm,class OT_MATRICE_3D& inertieglobale,class OT_MATRICE_3D& inertiecdm,double dens,int sens)
{
    double vol=0.;
    double xg=0.;
    double yg=0.;
    double zg=0.;
    double a=0.;
    double b=0.;
    double c=0.;
    double d=0.;
    double e=0.;
    double f=0.;
    int nbcoquille=get_nb_mg_coquille();
    for (int i=0;i<nbcoquille;i++)
    {
        MG_COQUILLE* coq=get_mg_coquille(i);
        int nbface=coq->get_nb_mg_coface();
        for (int j=0;j<nbface;j++)
        {
            MG_COFACE* coface=coq->get_mg_coface(j);
            MG_FACE* face=coface->get_face();
            TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
            for (MG_TRIANGLE* tri=(MG_TRIANGLE*)face->get_lien_maillage()->get_premier(it);tri!=NULL;tri=(MG_TRIANGLE*)face->get_lien_maillage()->get_suivant(it))
            {
                if (mai->get_mg_triangleid(tri->get_id())==NULL) continue;
                MG_NOEUD* noeud1=tri->get_noeud1();
                MG_NOEUD* noeud2=tri->get_noeud2();
                MG_NOEUD* noeud3=tri->get_noeud3();
                double *xyz1=noeud1->get_coord();
                double *xyz2=noeud2->get_coord();
                double *xyz3=noeud3->get_coord();
                OT_VECTEUR_3D vec1(xyz1,xyz2);
                OT_VECTEUR_3D vec2(xyz1,xyz3);
                OT_VECTEUR_3D n=vec1&vec2;
                n=sens*n;
                double detj=n.get_longueur();
                n.norme();
                n=-1.*coface->get_orientation()*n;
                for (int k=0;k<3;k++)
                {
                    double xsi=1./6.;
                    double eta=1./6.;
                    double wi=1./6.;
                    if (k==1) xsi=2./3.;
                    if (k==2) eta=2./3.;
                    double x=(1-xsi-eta)*xyz1[0]+xsi*xyz2[0]+eta*xyz3[0];
                    double y=(1-xsi-eta)*xyz1[1]+xsi*xyz2[1]+eta*xyz3[1];
                    double z=(1-xsi-eta)*xyz1[2]+xsi*xyz2[2]+eta*xyz3[2];
                    OT_VECTEUR_3D psi1(x,0,0);
                    OT_VECTEUR_3D psi2(0.5*x*x,0,0);
                    OT_VECTEUR_3D psi3(0,0.5*y*y,0);
                    OT_VECTEUR_3D psi4(0,0,0.5*z*z);
                    OT_VECTEUR_3D psi5(0,y*y*y/3.,z*z*z/3.);
                    OT_VECTEUR_3D psi6(x*x*x/3.,0,z*z*z/3.);
                    OT_VECTEUR_3D psi7(x*x*x/3.,y*y*y/3.,0);
                    OT_VECTEUR_3D psi8(0.,y*y*z/2.,0);
                    OT_VECTEUR_3D psi9(x*x*z/2.,0.,0);
                    OT_VECTEUR_3D psi10(x*x*y/2.,0,0);
                    vol=vol+detj*wi*(psi1*n);
                    xg=xg+wi*detj*(psi2*n);
                    yg=yg+wi*detj*(psi3*n);
                    zg=zg+wi*detj*(psi4*n);
                    a=a+wi*detj*(psi5*n);
                    b=b+wi*detj*(psi6*n);
                    c=c+wi*detj*(psi7*n);
                    d=d+wi*detj*(psi8*n);
                    e=e+wi*detj*(psi9*n);
                    f=f+wi*detj*(psi10*n);
                }
            }
        }
    }
    volume=vol;
    masse=vol*dens;
    cdm.change_x(xg/volume);
    cdm.change_y(yg/volume);
    cdm.change_z(zg/volume);
    inertieglobale(0,0)=a*dens;
    inertieglobale(1,1)=b*dens;
    inertieglobale(2,2)=c*dens;
    inertieglobale(1,0)=f*dens;
    inertieglobale(0,1)=f*dens;
    inertieglobale(2,0)=e*dens;
    inertieglobale(0,2)=e*dens;
    inertieglobale(2,1)=d*dens;
    inertieglobale(1,2)=d*dens;
    OT_VECTEUR_3D m1(masse*(cdm.get_y()*cdm.get_y()+cdm.get_z()*cdm.get_z()),masse*cdm.get_x()*cdm.get_y(),masse*cdm.get_x()*cdm.get_z());
    OT_VECTEUR_3D m2(masse*cdm.get_x()*cdm.get_y(),masse*(cdm.get_x()*cdm.get_x()+cdm.get_z()*cdm.get_z()),masse*cdm.get_y()*cdm.get_z());
    OT_VECTEUR_3D m3(masse*cdm.get_x()*cdm.get_z(),masse*cdm.get_y()*cdm.get_z(),masse*(cdm.get_x()*cdm.get_x()+cdm.get_y()*cdm.get_y()));
    m1=(-1.)*m1;
    m2=(-1.)*m2;
    m3=(-1.)*m3;
    OT_MATRICE_3D change(m1,m2,m3);
    inertiecdm=inertieglobale+change;
}

Revision:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (11 months, 1 week ago) by francois
File size:	9274 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_volume.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:54 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	francois	283
23
24			#include "gestionversion.h"
25			#include "mg_volume.h"
26			#include "ot_mathematique.h"
27			#include "mg_maillage.h"
28			#include "vct_volume.h"
29
30	francois	881	MG_VOLUME::MG_VOLUME(std::string idori,unsigned long num):MG_ELEMENT_TOPOLOGIQUE(num,idori),num_materiau(-1),vect(NULL),mince(false)
31	francois	283	{
32			}
33
34	francois	881	MG_VOLUME::MG_VOLUME(std::string idori):MG_ELEMENT_TOPOLOGIQUE(idori),num_materiau(-1),vect(NULL),mince(false)
35	francois	283	{
36			}
37
38	francois	881	MG_VOLUME::MG_VOLUME(MG_VOLUME& mdd):MG_ELEMENT_TOPOLOGIQUE(mdd),lst_coquille(mdd.lst_coquille),vect(mdd.vect),mince(mdd.mince)
39	francois	283	{
40			}
41
42			MG_VOLUME::~MG_VOLUME()
43			{
44			}
45
46			void MG_VOLUME::ajouter_mg_coquille(class MG_COQUILLE* mgcoq)
47			{
48			lst_coquille.insert(lst_coquille.end(),mgcoq);
49			}
50
51			void MG_VOLUME::supprimer_mg_coquille(class MG_COQUILLE* mgcoq)
52			{
53			std::vector<MG_COQUILLE*>::iterator i;
54			for (i=lst_coquille.begin();i!=lst_coquille.end();i++)
55			{
56			if ((*i)==mgcoq)
57			{
58			lst_coquille.erase(i);
59			return;
60			}
61			}
62			}
63
64
65			int MG_VOLUME::get_nb_mg_coquille(void)
66			{
67			return lst_coquille.size();
68			}
69
70			MG_COQUILLE* MG_VOLUME::get_mg_coquille(int num)
71			{
72			return lst_coquille[num];
73			}
74
75			int MG_VOLUME::get_dimension(void)
76			{
77			return 3;
78			}
79	couturad	906
80			int MG_VOLUME::get_type(void)
81			{
82			return TYPE_ELEMENT_TOPOLOGIQUE::VOLUME;
83			}
84
85	francois	283	VCT& MG_VOLUME::get_vectorisation(void)
86			{
87			if (vect==NULL) vect=new VCT_VOLUME(this);
88			return *vect;
89			}
90			void MG_VOLUME::get_topologie_sousjacente(TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE> lst)
91			{
92			int nbcoq=lst_coquille.size();
93			for (int i=0;i<nbcoq;i++)
94			{
95			MG_COQUILLE* coq=lst_coquille[i];
96			int nbface=coq->get_nb_mg_coface();
97			for (int j=0;j<nbface;j++)
98			{
99			MG_FACE* face=coq->get_mg_coface(j)->get_face();
100			lst->ajouter(face);
101			face->get_topologie_sousjacente(lst);
102			}
103			}
104			}
105
106
107	francois	632
108
109	francois	1095	BOITE_3D MG_VOLUME::get_boite_3D(void)
110	francois	632	{
111			BOITE_3D boitevol;
112			int nb_coquille=get_nb_mg_coquille();
113			for (int i=0;i<nb_coquille;i++)
114			{
115			MG_COQUILLE* coq=get_mg_coquille(i);
116			int nb_face=coq->get_nb_mg_coface();
117			for (int j=0;j<nb_face;j++)
118			{
119			MG_FACE* face=coq->get_mg_coface(j)->get_face();
120	francois	1095	BOITE_3D tmp=face->get_boite_3D();
121	francois	632	if ((i==0) && (j==0)) boitevol=tmp;
122			else boitevol=tmp+boitevol;
123			}
124			}
125			return boitevol;
126			}
127
128	francois	763	void MG_VOLUME::enregistrer(std::ostream& o,double version)
129	francois	283	{
130			o << "%" << get_id() << "=VOLUME(" << get_idoriginal() << ",(";
131			for (unsigned int i=0;i<lst_coquille.size();i++)
132			{
133			o << "$" << lst_coquille[i]->get_id();
134			if (i!=lst_coquille.size()-1) o << ",";
135			else o << ")";
136			}
137			int nb=get_nb_ccf();
138	francois	763	if (version<2)
139			{
140	francois	283	o << "," << num_materiau << "," << nb;
141			if (nb!=0)
142			{
143			o << ",(";
144			for (int i=0;i<nb;i++)
145			{
146			char nom[3];
147			get_type_ccf(i,nom);
148			o << "(" << nom << "," << get_valeur_ccf(i) << ")";
149			if (i!=nb-1) o << "," ;
150			}
151			o << ")";
152			}
153			o << ");" << std::endl;
154	francois	763	}
155			else
156			{
157	francois	881	if (version>2.2)
158			{
159			if (mince) o << ",1" ;
160			else o << ",0" ;
161			if (mince)
162			{
163			o << ",(" ;
164			for (int i=0;i<get_nb_face_correspondante()-1;i++)
165			o << "$" << lst_base[i]->get_id() << "," << "$" << lst_extrude[i]->get_id() << "," ;
166			o << "$" << lst_base[get_nb_face_correspondante()-1]->get_id() << "," << "$" << lst_extrude[get_nb_face_correspondante()-1]->get_id();
167			o << ")" ;
168			}
169			}
170	francois	763	o << "," ;
171			enregistrer_ccf(o,version);
172			o << ");" << std::endl;
173			}
174	francois	283	}
175
176			void MG_VOLUME::change_num_materiau(int num)
177			{
178			num_materiau=num;
179			}
180
181			int MG_VOLUME::get_num_materiau(void)
182			{
183			return num_materiau;
184			}
185
186	francois	576
187			bool MG_VOLUME::est_un_volume_element(void)
188			{
189			return false;
190			}
191	francois	881
192
193
194
195			void MG_VOLUME::ajouter_face_correspondante(MG_FACE* face1,MG_FACE* face2)
196			{
197			lst_base.push_back(face1);
198			lst_extrude.push_back(face2);
199			mince=true;
200			}
201
202			void MG_VOLUME::get_face_correspondante(int num,MG_FACE face1,MG_FACE face2)
203			{
204			(*face1)=lst_base[num];
205			(*face2)=lst_extrude[num];
206			}
207
208			int MG_VOLUME::get_nb_face_correspondante(void)
209			{
210			return lst_base.size();
211			}
212
213			bool MG_VOLUME::est_mince(void)
214			{
215			return mince;
216			}
217
218
219
220	francois	1042	void MG_VOLUME::get_propriete_massique(class MG_MAILLAGE* mai,double& volume,double &masse,class OT_VECTEUR_3D& cdm,class OT_MATRICE_3D& inertieglobale,class OT_MATRICE_3D& inertiecdm,double dens,int sens)
221	francois	283	{
222			double vol=0.;
223			double xg=0.;
224			double yg=0.;
225			double zg=0.;
226			double a=0.;
227			double b=0.;
228			double c=0.;
229			double d=0.;
230			double e=0.;
231			double f=0.;
232			int nbcoquille=get_nb_mg_coquille();
233			for (int i=0;i<nbcoquille;i++)
234			{
235			MG_COQUILLE* coq=get_mg_coquille(i);
236			int nbface=coq->get_nb_mg_coface();
237			for (int j=0;j<nbface;j++)
238			{
239			MG_COFACE* coface=coq->get_mg_coface(j);
240			MG_FACE* face=coface->get_face();
241			TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
242			for (MG_TRIANGLE* tri=(MG_TRIANGLE)face->get_lien_maillage()->get_premier(it);tri!=NULL;tri=(MG_TRIANGLE)face->get_lien_maillage()->get_suivant(it))
243			{
244			if (mai->get_mg_triangleid(tri->get_id())==NULL) continue;
245			MG_NOEUD* noeud1=tri->get_noeud1();
246			MG_NOEUD* noeud2=tri->get_noeud2();
247			MG_NOEUD* noeud3=tri->get_noeud3();
248			double *xyz1=noeud1->get_coord();
249			double *xyz2=noeud2->get_coord();
250			double *xyz3=noeud3->get_coord();
251			OT_VECTEUR_3D vec1(xyz1,xyz2);
252			OT_VECTEUR_3D vec2(xyz1,xyz3);
253			OT_VECTEUR_3D n=vec1&vec2;
254	francois	1042	n=sens*n;
255	francois	283	double detj=n.get_longueur();
256			n.norme();
257			n=-1.coface->get_orientation()n;
258			for (int k=0;k<3;k++)
259			{
260			double xsi=1./6.;
261			double eta=1./6.;
262			double wi=1./6.;
263			if (k==1) xsi=2./3.;
264			if (k==2) eta=2./3.;
265			double x=(1-xsi-eta)xyz1[0]+xsixyz2[0]+eta*xyz3[0];
266			double y=(1-xsi-eta)xyz1[1]+xsixyz2[1]+eta*xyz3[1];
267			double z=(1-xsi-eta)xyz1[2]+xsixyz2[2]+eta*xyz3[2];
268			OT_VECTEUR_3D psi1(x,0,0);
269			OT_VECTEUR_3D psi2(0.5xx,0,0);
270			OT_VECTEUR_3D psi3(0,0.5yy,0);
271			OT_VECTEUR_3D psi4(0,0,0.5zz);
272			OT_VECTEUR_3D psi5(0,yyy/3.,zzz/3.);
273			OT_VECTEUR_3D psi6(xxx/3.,0,zzz/3.);
274			OT_VECTEUR_3D psi7(xxx/3.,yyy/3.,0);
275			OT_VECTEUR_3D psi8(0.,yyz/2.,0);
276			OT_VECTEUR_3D psi9(xxz/2.,0.,0);
277			OT_VECTEUR_3D psi10(xxy/2.,0,0);
278			vol=vol+detjwi(psi1*n);
279			xg=xg+widetj(psi2*n);
280			yg=yg+widetj(psi3*n);
281			zg=zg+widetj(psi4*n);
282			a=a+widetj(psi5*n);
283			b=b+widetj(psi6*n);
284			c=c+widetj(psi7*n);
285			d=d+widetj(psi8*n);
286			e=e+widetj(psi9*n);
287			f=f+widetj(psi10*n);
288			}
289			}
290			}
291			}
292			volume=vol;
293	francois	1042	masse=vol*dens;
294	francois	283	cdm.change_x(xg/volume);
295			cdm.change_y(yg/volume);
296			cdm.change_z(zg/volume);
297			inertieglobale(0,0)=a*dens;
298			inertieglobale(1,1)=b*dens;
299			inertieglobale(2,2)=c*dens;
300			inertieglobale(1,0)=f*dens;
301			inertieglobale(0,1)=f*dens;
302			inertieglobale(2,0)=e*dens;
303			inertieglobale(0,2)=e*dens;
304			inertieglobale(2,1)=d*dens;
305			inertieglobale(1,2)=d*dens;
306	francois	1044	OT_VECTEUR_3D m1(masse(cdm.get_y()cdm.get_y()+cdm.get_z()cdm.get_z()),massecdm.get_x()cdm.get_y(),massecdm.get_x()*cdm.get_z());
307			OT_VECTEUR_3D m2(massecdm.get_x()cdm.get_y(),masse(cdm.get_x()cdm.get_x()+cdm.get_z()cdm.get_z()),massecdm.get_y()*cdm.get_z());
308			OT_VECTEUR_3D m3(massecdm.get_x()cdm.get_z(),massecdm.get_y()cdm.get_z(),masse(cdm.get_x()cdm.get_x()+cdm.get_y()*cdm.get_y()));
309	francois	283	m1=(-1.)*m1;
310			m2=(-1.)*m2;
311			m3=(-1.)*m3;
312			OT_MATRICE_3D change(m1,m2,m3);
313			inertiecdm=inertieglobale+change;
314			}
315