optimisation/src/opt_noeud.cpp

#include "gestionversion.h"
#include "fem_noeud.h"
#include "mg_maillage.h"
#include "opt_noeud.h"


OPT_NOEUD::OPT_NOEUD(FEM_NOEUD* noeud):fem_noeud(noeud)
{
    xyz0[0]=fem_noeud->get_x();
    xyz0[1]=fem_noeud->get_y();
    xyz0[2]=fem_noeud->get_z();
    
    normale[0]=0.;
    normale[1]=0.;
    normale[2]=0.;
    
    normale_initiale[0]=0.;
    normale_initiale[1]=0.;
    normale_initiale[2]=0.;
}

OPT_NOEUD::OPT_NOEUD(OPT_NOEUD& mdd):fem_noeud(mdd.fem_noeud)
{
    xyz0[0]=mdd.get_x_initial();
    xyz0[1]=mdd.get_y_initial();
    xyz0[2]=mdd.get_z_initial();
    
    normale[0]=mdd.normale[0];
    normale[1]=mdd.normale[1];
    normale[2]=mdd.normale[2];
    
    normale_initiale[0]=mdd.normale_initiale[0];
    normale_initiale[1]=mdd.normale_initiale[1];
    normale_initiale[2]=mdd.normale_initiale[2];
}

OPT_NOEUD::~OPT_NOEUD()
{
    
}

FEM_NOEUD* OPT_NOEUD::get_fem_noeud(void)
{
    return fem_noeud;
}

int OPT_NOEUD::get_num(void)
{
    return num;
}

void OPT_NOEUD::change_num(int val)
{
    num=val;
}

int OPT_NOEUD::get_variable(void)
{
    return variable;
}

void OPT_NOEUD::change_variable(int var)
{
    variable=var;
}

int OPT_NOEUD::get_algo_grad(void)
{
    return algo_grad;
}

void OPT_NOEUD::change_algo_grad(int algo)
{
    algo_grad=algo;
}

int OPT_NOEUD::get_num_global(void)
{
    return num_global;
}

void OPT_NOEUD::change_num_global(int num)
{
    num_global=num;
}

double OPT_NOEUD::get_terme_gradient_f(void)
{
    return terme_gradient_f;
}

void OPT_NOEUD::change_terme_gradient_f(double valeur)
{
    terme_gradient_f=valeur;
}

unsigned long OPT_NOEUD::get_id(void)
{
    return fem_noeud->get_id();
}

double OPT_NOEUD::get_x(void)
{
    return fem_noeud->get_x();
}

double OPT_NOEUD::get_y(void)
{
    return fem_noeud->get_y();
}

double OPT_NOEUD::get_z(void)
{
    return fem_noeud->get_z();
}

double OPT_NOEUD::get_x_initial(void)
{
    return xyz0[0];
}

double OPT_NOEUD::get_y_initial(void)
{
    return xyz0[1];
}

double OPT_NOEUD::get_z_initial(void)
{
    return xyz0[2];
}

double* OPT_NOEUD::get_coord(void)
{
    return fem_noeud->get_coord();
}

double OPT_NOEUD::get_norme_orientee_deplacement(void)
{
    return norme_orientee_deplacement;
}

void OPT_NOEUD::change_norme_orientee_deplacement(void)
{
    OT_VECTEUR_3D n=get_normale_initiale();
    OT_VECTEUR_3D D(get_x()-get_x_initial(),get_y()-get_y_initial(),get_z()-get_z_initial());
    
    int signe=1;
    double ps_D_n=D*n;
    if (ps_D_n<0)
        signe=-1;
    norme_orientee_deplacement=D.get_longueur()*signe;
}

void OPT_NOEUD::change_normale(OT_VECTEUR_3D vec)
{
    normale=vec;
}

OT_VECTEUR_3D OPT_NOEUD::get_normale(void)
{
    return normale;
}

OT_VECTEUR_3D OPT_NOEUD::get_normale_initiale(void)
{
    return normale_initiale;
}

void  OPT_NOEUD::change_normale_initiale(void)
{
    normale_initiale=normale;
}

void OPT_NOEUD::change_x(double xx)
{
    fem_noeud->change_x(xx);
}

void OPT_NOEUD::change_y(double yy)
{
    fem_noeud->change_y(yy);
}

void OPT_NOEUD::change_z(double zz)
{
    fem_noeud->change_z(zz);
}

void OPT_NOEUD::change_x_initial(double x_initial)
{
    xyz0[0]=x_initial;
}

void OPT_NOEUD::change_y_initial(double y_initial)
{
    xyz0[1]=y_initial;
}

void OPT_NOEUD::change_z_initial(double z_initial)
{
    xyz0[2]=z_initial;
}

void OPT_NOEUD::change_coord(double *coo)
{
    fem_noeud->change_coord(coo);
}

void OPT_NOEUD::change_solution(double val)
{
    fem_noeud->change_solution(val);
}

double OPT_NOEUD::get_solution(void)
{
    fem_noeud->get_solution();
}
Revision:	470
Committed:	Fri Dec 6 22:32:32 2013 UTC (11 years, 8 months ago) by francois
File size:	3543 byte(s)
Log Message:	MAGIC V4 pour l'optimisation de mouvement normal
#	Content
1	#include "gestionversion.h"
2	#include "fem_noeud.h"
3	#include "mg_maillage.h"
4	#include "opt_noeud.h"
5
6
7	OPT_NOEUD::OPT_NOEUD(FEM_NOEUD* noeud):fem_noeud(noeud)
8	{
9	xyz0[0]=fem_noeud->get_x();
10	xyz0[1]=fem_noeud->get_y();
11	xyz0[2]=fem_noeud->get_z();
12
13	normale[0]=0.;
14	normale[1]=0.;
15	normale[2]=0.;
16
17	normale_initiale[0]=0.;
18	normale_initiale[1]=0.;
19	normale_initiale[2]=0.;
20	}
21
22	OPT_NOEUD::OPT_NOEUD(OPT_NOEUD& mdd):fem_noeud(mdd.fem_noeud)
23	{
24	xyz0[0]=mdd.get_x_initial();
25	xyz0[1]=mdd.get_y_initial();
26	xyz0[2]=mdd.get_z_initial();
27
28	normale[0]=mdd.normale[0];
29	normale[1]=mdd.normale[1];
30	normale[2]=mdd.normale[2];
31
32	normale_initiale[0]=mdd.normale_initiale[0];
33	normale_initiale[1]=mdd.normale_initiale[1];
34	normale_initiale[2]=mdd.normale_initiale[2];
35	}
36
37	OPT_NOEUD::~OPT_NOEUD()
38	{
39
40	}
41
42	FEM_NOEUD* OPT_NOEUD::get_fem_noeud(void)
43	{
44	return fem_noeud;
45	}
46
47	int OPT_NOEUD::get_num(void)
48	{
49	return num;
50	}
51
52	void OPT_NOEUD::change_num(int val)
53	{
54	num=val;
55	}
56
57	int OPT_NOEUD::get_variable(void)
58	{
59	return variable;
60	}
61
62	void OPT_NOEUD::change_variable(int var)
63	{
64	variable=var;
65	}
66
67	int OPT_NOEUD::get_algo_grad(void)
68	{
69	return algo_grad;
70	}
71
72	void OPT_NOEUD::change_algo_grad(int algo)
73	{
74	algo_grad=algo;
75	}
76
77	int OPT_NOEUD::get_num_global(void)
78	{
79	return num_global;
80	}
81
82	void OPT_NOEUD::change_num_global(int num)
83	{
84	num_global=num;
85	}
86
87	double OPT_NOEUD::get_terme_gradient_f(void)
88	{
89	return terme_gradient_f;
90	}
91
92	void OPT_NOEUD::change_terme_gradient_f(double valeur)
93	{
94	terme_gradient_f=valeur;
95	}
96
97	unsigned long OPT_NOEUD::get_id(void)
98	{
99	return fem_noeud->get_id();
100	}
101
102	double OPT_NOEUD::get_x(void)
103	{
104	return fem_noeud->get_x();
105	}
106
107	double OPT_NOEUD::get_y(void)
108	{
109	return fem_noeud->get_y();
110	}
111
112	double OPT_NOEUD::get_z(void)
113	{
114	return fem_noeud->get_z();
115	}
116
117	double OPT_NOEUD::get_x_initial(void)
118	{
119	return xyz0[0];
120	}
121
122	double OPT_NOEUD::get_y_initial(void)
123	{
124	return xyz0[1];
125	}
126
127	double OPT_NOEUD::get_z_initial(void)
128	{
129	return xyz0[2];
130	}
131
132	double* OPT_NOEUD::get_coord(void)
133	{
134	return fem_noeud->get_coord();
135	}
136
137	double OPT_NOEUD::get_norme_orientee_deplacement(void)
138	{
139	return norme_orientee_deplacement;
140	}
141
142	void OPT_NOEUD::change_norme_orientee_deplacement(void)
143	{
144	OT_VECTEUR_3D n=get_normale_initiale();
145	OT_VECTEUR_3D D(get_x()-get_x_initial(),get_y()-get_y_initial(),get_z()-get_z_initial());
146
147	int signe=1;
148	double ps_D_n=D*n;
149	if (ps_D_n<0)
150	signe=-1;
151	norme_orientee_deplacement=D.get_longueur()*signe;
152	}
153
154	void OPT_NOEUD::change_normale(OT_VECTEUR_3D vec)
155	{
156	normale=vec;
157	}
158
159	OT_VECTEUR_3D OPT_NOEUD::get_normale(void)
160	{
161	return normale;
162	}
163
164	OT_VECTEUR_3D OPT_NOEUD::get_normale_initiale(void)
165	{
166	return normale_initiale;
167	}
168
169	void OPT_NOEUD::change_normale_initiale(void)
170	{
171	normale_initiale=normale;
172	}
173
174	void OPT_NOEUD::change_x(double xx)
175	{
176	fem_noeud->change_x(xx);
177	}
178
179	void OPT_NOEUD::change_y(double yy)
180	{
181	fem_noeud->change_y(yy);
182	}
183
184	void OPT_NOEUD::change_z(double zz)
185	{
186	fem_noeud->change_z(zz);
187	}
188
189	void OPT_NOEUD::change_x_initial(double x_initial)
190	{
191	xyz0[0]=x_initial;
192	}
193
194	void OPT_NOEUD::change_y_initial(double y_initial)
195	{
196	xyz0[1]=y_initial;
197	}
198
199	void OPT_NOEUD::change_z_initial(double z_initial)
200	{
201	xyz0[2]=z_initial;
202	}
203
204	void OPT_NOEUD::change_coord(double *coo)
205	{
206	fem_noeud->change_coord(coo);
207	}
208
209	void OPT_NOEUD::change_solution(double val)
210	{
211	fem_noeud->change_solution(val);
212	}
213
214	double OPT_NOEUD::get_solution(void)
215	{
216	fem_noeud->get_solution();
217	}