aster/src/opt_triangle.cpp

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuilli�re et Vincent FRANCOIS
//  D�partement de G�nie M�canique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du d�partement
//  de g�nie m�canique de l'Universit� du Qu�bec �
//  Trois Rivi�res
//  Les librairies ne peuvent �tre utilis�es sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       opt_triangle.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 � 11H22
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"
#include "mg_maillage.h"
#include "ot_decalage_parametre.h"
#include "opt_triangle.h"
#include "fem_triangle3.h"
#include "opt_noeud.h"


OPT_TRIANGLE::OPT_TRIANGLE(FEM_TRIANGLE3* fem_tri3,OPT_NOEUD* noeud1,OPT_NOEUD* noeud2,OPT_NOEUD* noeud3):fem_triangle3(fem_tri3),opt_noeud1(noeud1),opt_noeud2(noeud2),opt_noeud3(noeud3)
{
    double uv[6];
    
    OT_VECTEUR_3D dNi_de(fem_tri3->get_fonction_derive_interpolation(1,1,uv),fem_tri3->get_fonction_derive_interpolation(2,1,uv),fem_tri3->get_fonction_derive_interpolation(3,1,uv));
    OT_VECTEUR_3D dNi_dn(fem_tri3->get_fonction_derive_interpolation(1,2,uv),fem_tri3->get_fonction_derive_interpolation(2,2,uv),fem_tri3->get_fonction_derive_interpolation(3,2,uv));
    OT_VECTEUR_3D dNi_dZ(0.,0.,0.);
    
    OT_MATRICE_3D dNi(dNi_de,dNi_dn,dNi_dZ);
    dNi_transpose=dNi.transpose();
}

OPT_TRIANGLE::OPT_TRIANGLE(OPT_TRIANGLE& mdd):fem_triangle3(mdd.fem_triangle3),opt_noeud1(mdd.opt_noeud1),opt_noeud2(mdd.opt_noeud2),opt_noeud3(mdd.opt_noeud3)
{
    
}

OPT_TRIANGLE::~OPT_TRIANGLE()
{
    
}

unsigned long OPT_TRIANGLE::get_id(void)
{
    return fem_triangle3->get_id();
}

void OPT_TRIANGLE::change_angle1_initial(double angle)
{
    a1_init=angle;
}

void OPT_TRIANGLE::change_angle2_initial(double angle)
{
    a2_init=angle;
}

void  OPT_TRIANGLE::change_angle3_initial(double angle)
{
    a3_init=angle;
}

void OPT_TRIANGLE::change_angle1(double angle)
{
    a1=angle;
}

void OPT_TRIANGLE::change_angle2(double angle)
{
    a2=angle;
}

void OPT_TRIANGLE::change_angle3(double angle)
{
    a3=angle;
}

void OPT_TRIANGLE::change_normale_unitaire(OT_VECTEUR_3D vec)
{
    normale_unitaire=vec;
}

OT_VECTEUR_3D OPT_TRIANGLE::get_normale_unitaire(void)
{
    return normale_unitaire;
}

OT_MATRICE_3D OPT_TRIANGLE::change_jacobien_inverse(void)
{
    double j[9];
    double uv[6];
    double unite;
    
    fem_triangle3->get_inverse_jacob(j,uv,unite);
    
    OT_VECTEUR_3D col1_ji(j[0],j[3],j[6]);
    OT_VECTEUR_3D col2_ji(j[1],j[4],j[7]);
    OT_VECTEUR_3D col3_ji(j[2],j[5],j[8]);
    
    OT_MATRICE_3D ji(col1_ji,col2_ji,col3_ji);
    jacobien_inverse=ji;
    return jacobien_inverse;
}

OT_MATRICE_3D OPT_TRIANGLE::get_jacobien_inverse(void)
{
    return jacobien_inverse;
}

OT_MATRICE_3D OPT_TRIANGLE::change_matrice_abc(void)
{
    matrice_abc=jacobien_inverse*dNi_transpose;
    return matrice_abc;
}

OT_MATRICE_3D OPT_TRIANGLE::get_matrice_abc(void)
{
    return matrice_abc;
}

void OPT_TRIANGLE::change_vecteur_deplacement_reel(void)
{
    OPT_NOEUD* opt_n1=get_noeud1();
    OPT_NOEUD* opt_n2=get_noeud2();
    OPT_NOEUD* opt_n3=get_noeud3();
    
    double d1=opt_n1->get_norme_orientee_deplacement();
    double d2=opt_n2->get_norme_orientee_deplacement();
    double d3=opt_n3->get_norme_orientee_deplacement();
    
    OT_VECTEUR_3D D(d1,d2,d3);
    vec_deplacement_reel=D;
}

OT_VECTEUR_3D OPT_TRIANGLE::get_vecteur_deplacement_reel(void)
{
    return vec_deplacement_reel;
}

void OPT_TRIANGLE::change_vecteur_sol_deplacement_virtuel(void )
{
    OPT_NOEUD* opt_n1=get_noeud1();
    OPT_NOEUD* opt_n2=get_noeud2();
    OPT_NOEUD* opt_n3=get_noeud3();
    
    double d1=opt_n1->get_sol_deplacement_virtuel();
    double d2=opt_n2->get_sol_deplacement_virtuel();
    double d3=opt_n3->get_sol_deplacement_virtuel();
    
    OT_VECTEUR_3D D(d1,d2,d3);
    vec_sol_deplacement_virtuel=D;
}

OT_VECTEUR_3D OPT_TRIANGLE::get_vecteur_sol_deplacement_virtuel(void )
{
    return vec_sol_deplacement_virtuel;
}

void OPT_TRIANGLE::change_norme_gradient_deplacement_reel(void)
{
    OT_VECTEUR_3D gradient_deplacement_reel=matrice_abc*vec_deplacement_reel;
    norme_gradient_deplacement_reel=gradient_deplacement_reel.get_longueur();
}

double OPT_TRIANGLE::get_norme_gradient_deplacement_reel(void)
{
    return norme_gradient_deplacement_reel;
}

void OPT_TRIANGLE::change_norme_gradient_deplacement_virtuel(void)
{
    /*OPT_NOEUD* opt_n1=get_noeud1();
    OPT_NOEUD* opt_n2=get_noeud2();
    OPT_NOEUD* opt_n3=get_noeud3();

    OT_MATRICE_3D abc=get_matrice_abc();

    double d1=opt_n1->get_sol_deplacement_virtuel();
    double d2=opt_n2->get_sol_deplacement_virtuel();
    double d3=opt_n3->get_sol_deplacement_virtuel();

    OT_VECTEUR_3D D(d1,d2,d3);
      
    OT_VECTEUR_3D gradient_deplacement=abc*D;*/
    OT_VECTEUR_3D gradient_deplacement_virtuel=matrice_abc*vec_sol_deplacement_virtuel;
    norme_gradient_deplacement_virtuel=gradient_deplacement_virtuel.get_longueur();
}

double OPT_TRIANGLE::get_norme_gradient_deplacement_virtuel(void)
{
    return norme_gradient_deplacement_virtuel;
}

void OPT_TRIANGLE::change_noeuds_fixes_3(int val)
{
    noeuds_fixes_3=val;
}

int OPT_TRIANGLE::get_noeuds_fixes_3(void)
{
    return noeuds_fixes_3;
}

void OPT_TRIANGLE::change_nb_noeuds_fixes_iter(int nb)
{
    nb_noeuds_fixes_iter=nb;
}

int OPT_TRIANGLE::get_nb_noeuds_fixes_iter(void)
{
    return nb_noeuds_fixes_iter;
}

double OPT_TRIANGLE::get_angle1_initial(void)
{
    return a1_init;
}

double OPT_TRIANGLE::get_angle2_initial(void)
{
    return a2_init;
}

double OPT_TRIANGLE::get_angle3_initial(void)
{
    return a3_init;
}

double OPT_TRIANGLE::get_angle1(void)
{
    return a1;
}

double OPT_TRIANGLE::get_angle2(void)
{
    return a2;
}

double OPT_TRIANGLE::get_angle3(void)
{
    return a3;
}

OPT_NOEUD* OPT_TRIANGLE::get_noeud1(void)
{
    return opt_noeud1;
}

OPT_NOEUD* OPT_TRIANGLE::get_noeud2(void)
{
    return opt_noeud2;
}

OPT_NOEUD* OPT_TRIANGLE::get_noeud3(void)
{
     return opt_noeud3;
}

int OPT_TRIANGLE::get_num(void)
{
    return num;
}
 
void OPT_TRIANGLE::change_num(int val)
{
    num=val;
}

OPT_TRIANGLE* OPT_TRIANGLE::get_voisin1(void)
{
    return voisin1;
}

OPT_TRIANGLE* OPT_TRIANGLE::get_voisin2(void)
{
    return voisin2;
}

OPT_TRIANGLE* OPT_TRIANGLE::get_voisin3(void)
{
    return voisin3;
}

void OPT_TRIANGLE::change_voisin1(OPT_TRIANGLE* tri)
{
    voisin1=tri;
}

void OPT_TRIANGLE::change_voisin2(OPT_TRIANGLE* tri)
{
    voisin2=tri;
}

void OPT_TRIANGLE::change_voisin3(OPT_TRIANGLE* tri)
{
    voisin3=tri;
}
Revision:	1075
Committed:	Tue Aug 10 17:02:54 2021 UTC (4 years ago) by francois
File size:	7118 byte(s)
Log Message:	suppression de warning avec le dernier compilateur
#	Content
1	//------------------------------------------------------------
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	// opt_triangle.cpp
16	//
17	//------------------------------------------------------------
18	//------------------------------------------------------------
19	// COPYRIGHT 2000
20	// Version du 02/03/2006 � 11H22
21	//------------------------------------------------------------
22	//------------------------------------------------------------
23
24
25	#include "gestionversion.h"
26	#include "mg_maillage.h"
27	#include "ot_decalage_parametre.h"
28	#include "opt_triangle.h"
29	#include "fem_triangle3.h"
30	#include "opt_noeud.h"
31
32
33	OPT_TRIANGLE::OPT_TRIANGLE(FEM_TRIANGLE3* fem_tri3,OPT_NOEUD* noeud1,OPT_NOEUD* noeud2,OPT_NOEUD* noeud3):fem_triangle3(fem_tri3),opt_noeud1(noeud1),opt_noeud2(noeud2),opt_noeud3(noeud3)
34	{
35	double uv[6];
36
37	OT_VECTEUR_3D dNi_de(fem_tri3->get_fonction_derive_interpolation(1,1,uv),fem_tri3->get_fonction_derive_interpolation(2,1,uv),fem_tri3->get_fonction_derive_interpolation(3,1,uv));
38	OT_VECTEUR_3D dNi_dn(fem_tri3->get_fonction_derive_interpolation(1,2,uv),fem_tri3->get_fonction_derive_interpolation(2,2,uv),fem_tri3->get_fonction_derive_interpolation(3,2,uv));
39	OT_VECTEUR_3D dNi_dZ(0.,0.,0.);
40
41	OT_MATRICE_3D dNi(dNi_de,dNi_dn,dNi_dZ);
42	dNi_transpose=dNi.transpose();
43	}
44
45	OPT_TRIANGLE::OPT_TRIANGLE(OPT_TRIANGLE& mdd):fem_triangle3(mdd.fem_triangle3),opt_noeud1(mdd.opt_noeud1),opt_noeud2(mdd.opt_noeud2),opt_noeud3(mdd.opt_noeud3)
46	{
47
48	}
49
50	OPT_TRIANGLE::~OPT_TRIANGLE()
51	{
52
53	}
54
55	unsigned long OPT_TRIANGLE::get_id(void)
56	{
57	return fem_triangle3->get_id();
58	}
59
60	void OPT_TRIANGLE::change_angle1_initial(double angle)
61	{
62	a1_init=angle;
63	}
64
65	void OPT_TRIANGLE::change_angle2_initial(double angle)
66	{
67	a2_init=angle;
68	}
69
70	void OPT_TRIANGLE::change_angle3_initial(double angle)
71	{
72	a3_init=angle;
73	}
74
75	void OPT_TRIANGLE::change_angle1(double angle)
76	{
77	a1=angle;
78	}
79
80	void OPT_TRIANGLE::change_angle2(double angle)
81	{
82	a2=angle;
83	}
84
85	void OPT_TRIANGLE::change_angle3(double angle)
86	{
87	a3=angle;
88	}
89
90	void OPT_TRIANGLE::change_normale_unitaire(OT_VECTEUR_3D vec)
91	{
92	normale_unitaire=vec;
93	}
94
95	OT_VECTEUR_3D OPT_TRIANGLE::get_normale_unitaire(void)
96	{
97	return normale_unitaire;
98	}
99
100	OT_MATRICE_3D OPT_TRIANGLE::change_jacobien_inverse(void)
101	{
102	double j[9];
103	double uv[6];
104	double unite;
105
106	fem_triangle3->get_inverse_jacob(j,uv,unite);
107
108	OT_VECTEUR_3D col1_ji(j[0],j[3],j[6]);
109	OT_VECTEUR_3D col2_ji(j[1],j[4],j[7]);
110	OT_VECTEUR_3D col3_ji(j[2],j[5],j[8]);
111
112	OT_MATRICE_3D ji(col1_ji,col2_ji,col3_ji);
113	jacobien_inverse=ji;
114	return jacobien_inverse;
115	}
116
117	OT_MATRICE_3D OPT_TRIANGLE::get_jacobien_inverse(void)
118	{
119	return jacobien_inverse;
120	}
121
122	OT_MATRICE_3D OPT_TRIANGLE::change_matrice_abc(void)
123	{
124	matrice_abc=jacobien_inverse*dNi_transpose;
125	return matrice_abc;
126	}
127
128	OT_MATRICE_3D OPT_TRIANGLE::get_matrice_abc(void)
129	{
130	return matrice_abc;
131	}
132
133	void OPT_TRIANGLE::change_vecteur_deplacement_reel(void)
134	{
135	OPT_NOEUD* opt_n1=get_noeud1();
136	OPT_NOEUD* opt_n2=get_noeud2();
137	OPT_NOEUD* opt_n3=get_noeud3();
138
139	double d1=opt_n1->get_norme_orientee_deplacement();
140	double d2=opt_n2->get_norme_orientee_deplacement();
141	double d3=opt_n3->get_norme_orientee_deplacement();
142
143	OT_VECTEUR_3D D(d1,d2,d3);
144	vec_deplacement_reel=D;
145	}
146
147	OT_VECTEUR_3D OPT_TRIANGLE::get_vecteur_deplacement_reel(void)
148	{
149	return vec_deplacement_reel;
150	}
151
152	void OPT_TRIANGLE::change_vecteur_sol_deplacement_virtuel(void )
153	{
154	OPT_NOEUD* opt_n1=get_noeud1();
155	OPT_NOEUD* opt_n2=get_noeud2();
156	OPT_NOEUD* opt_n3=get_noeud3();
157
158	double d1=opt_n1->get_sol_deplacement_virtuel();
159	double d2=opt_n2->get_sol_deplacement_virtuel();
160	double d3=opt_n3->get_sol_deplacement_virtuel();
161
162	OT_VECTEUR_3D D(d1,d2,d3);
163	vec_sol_deplacement_virtuel=D;
164	}
165
166	OT_VECTEUR_3D OPT_TRIANGLE::get_vecteur_sol_deplacement_virtuel(void )
167	{
168	return vec_sol_deplacement_virtuel;
169	}
170
171	void OPT_TRIANGLE::change_norme_gradient_deplacement_reel(void)
172	{
173	OT_VECTEUR_3D gradient_deplacement_reel=matrice_abc*vec_deplacement_reel;
174	norme_gradient_deplacement_reel=gradient_deplacement_reel.get_longueur();
175	}
176
177	double OPT_TRIANGLE::get_norme_gradient_deplacement_reel(void)
178	{
179	return norme_gradient_deplacement_reel;
180	}
181
182	void OPT_TRIANGLE::change_norme_gradient_deplacement_virtuel(void)
183	{
184	/OPT_NOEUD opt_n1=get_noeud1();
185	OPT_NOEUD* opt_n2=get_noeud2();
186	OPT_NOEUD* opt_n3=get_noeud3();
187
188	OT_MATRICE_3D abc=get_matrice_abc();
189
190	double d1=opt_n1->get_sol_deplacement_virtuel();
191	double d2=opt_n2->get_sol_deplacement_virtuel();
192	double d3=opt_n3->get_sol_deplacement_virtuel();
193
194	OT_VECTEUR_3D D(d1,d2,d3);
195
196	OT_VECTEUR_3D gradient_deplacement=abcD;/
197	OT_VECTEUR_3D gradient_deplacement_virtuel=matrice_abc*vec_sol_deplacement_virtuel;
198	norme_gradient_deplacement_virtuel=gradient_deplacement_virtuel.get_longueur();
199	}
200
201	double OPT_TRIANGLE::get_norme_gradient_deplacement_virtuel(void)
202	{
203	return norme_gradient_deplacement_virtuel;
204	}
205
206	void OPT_TRIANGLE::change_noeuds_fixes_3(int val)
207	{
208	noeuds_fixes_3=val;
209	}
210
211	int OPT_TRIANGLE::get_noeuds_fixes_3(void)
212	{
213	return noeuds_fixes_3;
214	}
215
216	void OPT_TRIANGLE::change_nb_noeuds_fixes_iter(int nb)
217	{
218	nb_noeuds_fixes_iter=nb;
219	}
220
221	int OPT_TRIANGLE::get_nb_noeuds_fixes_iter(void)
222	{
223	return nb_noeuds_fixes_iter;
224	}
225
226	double OPT_TRIANGLE::get_angle1_initial(void)
227	{
228	return a1_init;
229	}
230
231	double OPT_TRIANGLE::get_angle2_initial(void)
232	{
233	return a2_init;
234	}
235
236	double OPT_TRIANGLE::get_angle3_initial(void)
237	{
238	return a3_init;
239	}
240
241	double OPT_TRIANGLE::get_angle1(void)
242	{
243	return a1;
244	}
245
246	double OPT_TRIANGLE::get_angle2(void)
247	{
248	return a2;
249	}
250
251	double OPT_TRIANGLE::get_angle3(void)
252	{
253	return a3;
254	}
255
256	OPT_NOEUD* OPT_TRIANGLE::get_noeud1(void)
257	{
258	return opt_noeud1;
259	}
260
261	OPT_NOEUD* OPT_TRIANGLE::get_noeud2(void)
262	{
263	return opt_noeud2;
264	}
265
266	OPT_NOEUD* OPT_TRIANGLE::get_noeud3(void)
267	{
268	return opt_noeud3;
269	}
270
271	int OPT_TRIANGLE::get_num(void)
272	{
273	return num;
274	}
275
276	void OPT_TRIANGLE::change_num(int val)
277	{
278	num=val;
279	}
280
281	OPT_TRIANGLE* OPT_TRIANGLE::get_voisin1(void)
282	{
283	return voisin1;
284	}
285
286	OPT_TRIANGLE* OPT_TRIANGLE::get_voisin2(void)
287	{
288	return voisin2;
289	}
290
291	OPT_TRIANGLE* OPT_TRIANGLE::get_voisin3(void)
292	{
293	return voisin3;
294	}
295
296	void OPT_TRIANGLE::change_voisin1(OPT_TRIANGLE* tri)
297	{
298	voisin1=tri;
299	}
300
301	void OPT_TRIANGLE::change_voisin2(OPT_TRIANGLE* tri)
302	{
303	voisin2=tri;
304	}
305
306	void OPT_TRIANGLE::change_voisin3(OPT_TRIANGLE* tri)
307	{
308	voisin3=tri;
309	}