optimisation/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();
}

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

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

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

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

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

double 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[1],j[2]);
    OT_VECTEUR_3D col2_ji(j[3],j[4],j[5]);
    OT_VECTEUR_3D col3_ji(j[6],j[7],j[8]);
    
    OT_MATRICE_3D ji(col1_ji,col2_ji,col3_ji);
    jacobien_inverse=ji;
}

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

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

void OPT_TRIANGLE::change_vecteur_deplacement(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);  // Vecteur contenant la norme orientée du déplacement de chaque noeud du triangle
    vec_deplacement=D;
}

OT_VECTEUR_3D OPT_TRIANGLE::get_vecteur_deplacement(void)
{
    return vec_deplacement;
}

void OPT_TRIANGLE::change_norme_gradient_deplacement_reel(void)
{
    OT_VECTEUR_3D gradient_deplacement=matrice_abc*vec_deplacement;
    norme_gradient_deplacement_reel=gradient_deplacement.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();
    double d2=opt_n2->get_sol_deplacement();
    double d3=opt_n3->get_sol_deplacement();

    OT_VECTEUR_3D D(d1,d2,d3);
      
    OT_VECTEUR_3D gradient_deplacement=abc*D;
    norme_gradient_deplacement_virtuel=gradient_deplacement.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;
}

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:	495
Committed:	Thu Mar 20 19:43:02 2014 UTC (11 years, 1 month ago) by gervaislavoie
File size:	6295 byte(s)
Log Message:	Mise a jour de la methode du mouvement normal. Minimisation, par l'algorithme du gradient, d'une fonction f definie comme la somme de la difference au carre entre la norme du gradient de deplacement de chaque triangle et la valeur seuil imposee. La methode fonctionne globalement mais il reste quelques problemes mineurs: - Gradient non respecte si plus d'un noeud d'un triangle, ayant 3 noeuds mobiles au debut de l'iteration, sont bloques au cours de cette iteration (l'algo diverge). - Gradient non respecte pour certains noeuds reintegres au processus d'optimisation et dont tous les noeuds voisins sont fixes (l'algo diverge).
#	User	Rev	Content
1	gervaislavoie	332	//------------------------------------------------------------
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	francois	470	#include "fem_triangle3.h"
30			#include "opt_noeud.h"
31	gervaislavoie	332
32
33	francois	470	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	gervaislavoie	332	{
35	francois	470	double uv[6];
36	gervaislavoie	332
37	francois	470	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	gervaislavoie	332	}
44
45	francois	470	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	gervaislavoie	332	{
47	francois	470
48	gervaislavoie	332	}
49
50			OPT_TRIANGLE::~OPT_TRIANGLE()
51			{
52	francois	470
53	gervaislavoie	332	}
54
55			unsigned long OPT_TRIANGLE::get_id(void)
56			{
57	francois	470	return fem_triangle3->get_id();
58	gervaislavoie	332	}
59
60			double OPT_TRIANGLE::change_angle1_initial(double angle)
61			{
62			a1_init=angle;
63			}
64
65			double OPT_TRIANGLE::change_angle2_initial(double angle)
66			{
67			a2_init=angle;
68			}
69
70			double OPT_TRIANGLE::change_angle3_initial(double angle)
71			{
72			a3_init=angle;
73			}
74
75			double OPT_TRIANGLE::change_angle1(double angle)
76			{
77			a1=angle;
78			}
79
80			double OPT_TRIANGLE::change_angle2(double angle)
81			{
82			a2=angle;
83			}
84
85			double OPT_TRIANGLE::change_angle3(double angle)
86			{
87			a3=angle;
88			}
89
90	gervaislavoie	495	void OPT_TRIANGLE::change_normale_unitaire(OT_VECTEUR_3D vec)
91			{
92			normale_unitaire=vec;
93			}
94
95	gervaislavoie	382	OT_VECTEUR_3D OPT_TRIANGLE::get_normale_unitaire(void)
96	gervaislavoie	332	{
97	gervaislavoie	382	return normale_unitaire;
98	gervaislavoie	332	}
99
100	francois	470	OT_MATRICE_3D OPT_TRIANGLE::change_jacobien_inverse(void)
101	gervaislavoie	392	{
102	francois	470	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[1],j[2]);
109			OT_VECTEUR_3D col2_ji(j[3],j[4],j[5]);
110			OT_VECTEUR_3D col3_ji(j[6],j[7],j[8]);
111
112			OT_MATRICE_3D ji(col1_ji,col2_ji,col3_ji);
113			jacobien_inverse=ji;
114	gervaislavoie	392	}
115
116	gervaislavoie	495	OT_MATRICE_3D OPT_TRIANGLE::get_jacobien_inverse(void)
117	gervaislavoie	398	{
118	gervaislavoie	495	return jacobien_inverse;
119	gervaislavoie	398	}
120
121	gervaislavoie	495	OT_MATRICE_3D OPT_TRIANGLE::change_matrice_abc(void)
122	gervaislavoie	332	{
123	gervaislavoie	495	matrice_abc=jacobien_inverse*dNi_transpose;
124	gervaislavoie	332	}
125
126	francois	470	OT_MATRICE_3D OPT_TRIANGLE::get_matrice_abc(void)
127	gervaislavoie	332	{
128	francois	470	return matrice_abc;
129	gervaislavoie	332	}
130
131	francois	470	void OPT_TRIANGLE::change_vecteur_deplacement(void)
132	gervaislavoie	332	{
133	francois	470	OPT_NOEUD* opt_n1=get_noeud1();
134			OPT_NOEUD* opt_n2=get_noeud2();
135			OPT_NOEUD* opt_n3=get_noeud3();
136
137			double d1=opt_n1->get_norme_orientee_deplacement();
138			double d2=opt_n2->get_norme_orientee_deplacement();
139			double d3=opt_n3->get_norme_orientee_deplacement();
140
141			OT_VECTEUR_3D D(d1,d2,d3); // Vecteur contenant la norme orientée du déplacement de chaque noeud du triangle
142			vec_deplacement=D;
143	gervaislavoie	332	}
144
145	gervaislavoie	495	OT_VECTEUR_3D OPT_TRIANGLE::get_vecteur_deplacement(void)
146	gervaislavoie	332	{
147	gervaislavoie	495	return vec_deplacement;
148	gervaislavoie	332	}
149
150	gervaislavoie	495	void OPT_TRIANGLE::change_norme_gradient_deplacement_reel(void)
151	gervaislavoie	332	{
152	francois	470	OT_VECTEUR_3D gradient_deplacement=matrice_abc*vec_deplacement;
153	gervaislavoie	495	norme_gradient_deplacement_reel=gradient_deplacement.get_longueur();
154	gervaislavoie	332	}
155
156	gervaislavoie	495	double OPT_TRIANGLE::get_norme_gradient_deplacement_reel(void)
157			{
158			return norme_gradient_deplacement_reel;
159			}
160
161			void OPT_TRIANGLE::change_norme_gradient_deplacement_virtuel(void)
162			{
163			OPT_NOEUD* opt_n1=get_noeud1();
164			OPT_NOEUD* opt_n2=get_noeud2();
165			OPT_NOEUD* opt_n3=get_noeud3();
166
167			OT_MATRICE_3D abc=get_matrice_abc();
168
169			double d1=opt_n1->get_sol_deplacement();
170			double d2=opt_n2->get_sol_deplacement();
171			double d3=opt_n3->get_sol_deplacement();
172
173			OT_VECTEUR_3D D(d1,d2,d3);
174
175			OT_VECTEUR_3D gradient_deplacement=abc*D;
176			norme_gradient_deplacement_virtuel=gradient_deplacement.get_longueur();
177			}
178
179			double OPT_TRIANGLE::get_norme_gradient_deplacement_virtuel(void)
180			{
181			return norme_gradient_deplacement_virtuel;
182			}
183
184			void OPT_TRIANGLE::change_noeuds_fixes_3(int val)
185			{
186			noeuds_fixes_3=val;
187			}
188
189			int OPT_TRIANGLE::get_noeuds_fixes_3(void)
190			{
191			return noeuds_fixes_3;
192			}
193
194	francois	470	double OPT_TRIANGLE::get_angle1_initial(void)
195	gervaislavoie	332	{
196	francois	470	return a1_init;
197	gervaislavoie	332	}
198
199	francois	470	double OPT_TRIANGLE::get_angle2_initial(void)
200	gervaislavoie	332	{
201	francois	470	return a2_init;
202	gervaislavoie	332	}
203
204	francois	470	double OPT_TRIANGLE::get_angle3_initial(void)
205	gervaislavoie	332	{
206	francois	470	return a3_init;
207	gervaislavoie	332	}
208
209	francois	470	double OPT_TRIANGLE::get_angle1(void)
210	gervaislavoie	332	{
211	francois	470	return a1;
212	gervaislavoie	332	}
213
214	francois	470	double OPT_TRIANGLE::get_angle2(void)
215	gervaislavoie	332	{
216	francois	470	return a2;
217	gervaislavoie	332	}
218
219	francois	470	double OPT_TRIANGLE::get_angle3(void)
220	gervaislavoie	332	{
221	francois	470	return a3;
222	gervaislavoie	332	}
223
224	francois	470	OPT_NOEUD* OPT_TRIANGLE::get_noeud1(void)
225	gervaislavoie	332	{
226	francois	470	return opt_noeud1;
227	gervaislavoie	332	}
228
229	francois	470	OPT_NOEUD* OPT_TRIANGLE::get_noeud2(void)
230	gervaislavoie	332	{
231	francois	470	return opt_noeud2;
232	gervaislavoie	332	}
233
234	francois	470	OPT_NOEUD* OPT_TRIANGLE::get_noeud3(void)
235	gervaislavoie	332	{
236	francois	470	return opt_noeud3;
237	gervaislavoie	332	}
238
239			int OPT_TRIANGLE::get_num(void)
240			{
241	francois	470	return num;
242	gervaislavoie	332	}
243
244			void OPT_TRIANGLE::change_num(int val)
245			{
246			num=val;
247			}
248
249			OPT_TRIANGLE* OPT_TRIANGLE::get_voisin1(void)
250			{
251			return voisin1;
252			}
253
254			OPT_TRIANGLE* OPT_TRIANGLE::get_voisin2(void)
255			{
256			return voisin2;
257			}
258
259			OPT_TRIANGLE* OPT_TRIANGLE::get_voisin3(void)
260			{
261			return voisin3;
262			}
263
264			void OPT_TRIANGLE::change_voisin1(OPT_TRIANGLE* tri)
265			{
266			voisin1=tri;
267			}
268
269			void OPT_TRIANGLE::change_voisin2(OPT_TRIANGLE* tri)
270			{
271			voisin2=tri;
272			}
273
274			void OPT_TRIANGLE::change_voisin3(OPT_TRIANGLE* tri)
275			{
276			voisin3=tri;
277			}