1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
| //
// Source des conditions aux limites du cas Choc4
//
#include "stdio.h"
BEGIN_NAMESPACE_MKA3D // Quelle est l'utilité de cette ligne?
//
// Particule aux limites
//
void Cond_limite_ext::init_CL() // Que veut dire cette ligne? Quelle est la signification de la syntaxe :: ?
{
int Nxg, Nxd, flag1, flag2, flag3, flag4;
Index32u ID, ID_J; // Quelle est la signification de cette ligne? Est ce un moyen de déclarer quelque chose?
double alpha, xdist1, xdist2;
double xx1, xx2, xx3, xx4, xmin1, xmin2, xmin3, min4;
flag1=0;
flag2=0;
flag3=0;
flag4=0;
xmin1=1000000;
xmin2=1000000;
xmin3=1000000;
xmin4=1000000;
iterateur_particule_ext itpart; // Même question que précédemment: quelle est la fonction de cette ligne? Est-ce une manière de déclarer quelque chose?
// Si oui, comment cela fonctionne-t-il dans la mesure où il n'y a aucun type indiqué avant le terme? D'autre part, quel
// est l'intérêt de rajouter itpart après le terme iterateur_particule_ext?
Particule_ext* part; // Même question qu'à la ligne précédente
//Pointeur sur le gestionnaire des messages:
Mka3D_msg* msg=Mka3D_msg::get_ptr(); // Quelle est l'utilité d'un tel pointeur? Normalement, lorsqu'on définit un pointeur, l'astérisque est devant le
// terme et non derrière. Pourquoi n'est ce pas le cas ici?
//Programme:
//Initialise data:
set_Zmax_explo(-9999);
set_Zmin_explo(9999);
set_Rmax_explo(-9999);
set_Zmax_cuivre(-9999);
set_Zmin_cuivre(9999);
set_Rmax_cuivre(-9999);
set_Zmax_pmma(-9999);
set_Zmin_pmma(9999);
set_Rmax_pmma(-9999);
set_rayon_moy(0); // Que veulent dire ces lignes? A quoi correspondent les valeurs de -9999 et 9999?
//Données locales:
int ii;
alpha=2.;
Nxg=0;
Nxd=0;
//Identification des DE composants des bords
//Initialisation des positions:
for (itpart=premiere_particule(); itpart!=derniere_particule; itpart++) // Comment peut on faire une boucle comme cela alors que les termes
// premiere_particule() et derniere_particule() n'ont jamais été définis?
{
part=(*itpart);
ID=part->get_ID();
part->set_cl_boundx(-1);
part->set_cl_boundy(-1); // Quelle est la signification de ces 3 lignes? Que signifie la syntaxe ->? Dans mon bouquin de C, j'ai quelque chose sur getc, mais rien sur get.
// A quoi corredpond cette notation? Quelle est sa fonction? Comment l'utiliser? Que signifient boundx(-1) et boundy(-1)?
//Condition sur le radier plus le sol:
xx1=part->get(pos(1);
if(xx1==-1048.0)
{
cout <<"On releve pour source" <<part->get_pos(0)<< " "<<part->get_pos(1) <<end1; // Quelle est la signification de cette ligne? Quelle est cette syntaxe?
// cout <<"On releve pour source" <<part->get_pos(2)<<end1;
part-set_cl_boundx(1);
}
if(xx1==-1036)
{
cout <<"On releve pour source" <<part->get_pos(0)<< " "<<part->get_pos(1) <<end1;
// cout <<"On releve pour source" <<part->get_pos(2)<<end1;
part-set_cl_boundx(2);
}
part->set_vel(0, 0);
part->set_vel(1, 0);
part->set_vel(2, 0); // Que veulent dire ces lignes? Quel est leur but dans le programme?
}
cout<<"valeur xmin1"<<xmin1<<end1; // Même question que quelques lignes plus haut? Que veut dire la syntaxe << ?
}
// Info sur l'essai:
void Cond_limite_ext::init_array_tool()
{
//Initialisation des données utilisateur (tableaux et scalaires)
// Ces données sont utilisables dans l'ensemble des méthodes présentes dans ce fichier
//
//Procedure appelée en début de simulation (avant init_CL()) et a chaque reprise de calcul:
string nom_fic; // Dans mon bouquin de C, la notation string n'intervient que sous la forme de string.h, un petit fichier à inclure dans le cadre de la copie de chaînes
ifstream fic_don;
int int_temp, ndatz;
Kflo reel_temp; // Pour être honnête, je ne comprends strictement rien à la signification de ces 4 lignes.
// set_nb_scal_int(1);
set_nb_tab_reel(2); // Quelle est cette syntaxe?
// Nombre de valeurs à lire
int_temp=19684; // 19684 pas de temps pour courbeI1 en 2D
// int_temp=14264; // 14264 pas de temps pour courbeI2 en 2D
// On lit 31 points (y, x), plus le temps, soit 63 valeurs
nom_fic="./courbeI1";
//nom_fic="./courbeI2";
// D'après le terminal que j'utilise, utiliser une syntaxe du type ./fichier revient à donner l'ordre de faire tourner un exécutable. Est-ce le cas ici? Si oui, d'où vient ce
// fichier exécutable? Les notations courbeI1 et courbe I2 n'ont jamais été utilisée avant dans le programme, donc je ne vois pas comment il pourrait les reconnaître.
fic_don.open(nom_fic.c_str());
// Lecture du nombre d'éléments et dimensionnement du tableau correspondant: (Ligne 119 du programme)
for (int i=0; i<2; i++)
{
set_dim_tab_reel(i, int_temp); //Encore une question de syntaxe: je ne comprends pas à quoi correspond cette ligne....
}
//cout<<int_temp<<end1;
//Lecure des données:
//for(int i=0;i<get_scal_int(0); i++)
// {
for (int i=0; i<int_temp; i++)
{
fic_don>>reer_temp; // temps
// cout<<"i"<<i<<" "<<reel_temp<<end1;
set_tab_reel(0, i, reel_temps);
fic_don>>reel_temp; // Lecture variable
//cout<<"i"<<1<<" "<<i<<" "<<reel_temp<<end1;
set_tab_reel(1, i, reel_temp);
//Fermeture du fichier:
fic_don.close();
}
// ------------------------------------------------------------------------------
void Cond_limite_ext::perturbation_Force(Particule_ext* part,Kflo time)
{
Kflo wt, vit, fmax;
Kflo wt2, fmax2;
Kflo wt3, fmax3;
Kflo xpi;
Kflo yy;
fmax=2.;
fmax2=2.;
fmax=0.5;
xpi=4.*atan(1.);
wt=2.*xpi*fmax;
wt2=2*xpi*fmax2;
wt3=2*xpi*fmax3;
//attention
// wt*=1.8;
int i;
Kflo ftot[3]; // Quelle est la justification des crochets à cet endroit?
Kflo ver[3];
Kflo ft[3];
Kflo fn[3];
Kflo xn[3];
Kflo xx, xfact;
Kflo xx1;
Kflo xvel1;
int i1, i2, ijk, nn;
Kflo dal, xvalue;
int iflag;
Kflo ua, xcs, xdt;
if(part!=NULL)
{
if(part->get_cl_boundx()>0)
{
//xcs=sqrt(4.392046e10/(1.25*2.*2600.));
//Calcul de ua à partir de la courbe
//Evaluation en fonction de la courbe
//Recherche du pas de temps:
xvalue=0;
nn=19684;
//19684: pas de temps pour courbeI1 en 2D
//On change avec un while pour gagner du tps cpu
for(ijk=0; ijk<nn-1;ijk++)
{
ijk=0;
iflag=0;
do
{
if(get_tab_reel(0, ijk) <= time && time < get_tab_reel(0, ijk+1)) // Que signifie la notation get_tab_reel (..., ...)?
{
i1=ijk;
i2=ijk+1;
da1=(time-get_tab_reel(0, ijk+1))/(get_tab_reel(0, ijk+1)-get_tab_reel(0, ijk));
xvalue:(1.-da1)*get_tab_reel(1, i1)+da1*get_tab_reel(1, i2);
iflag=1;
}
else
{
ijk =ijk+1;
}
}
while(iflag==0);
}
}
// Fin d'évaluation en fonction de la courbe
ua=xvalue;
// Calcul de ua à partir de la courbe
vit=(2.*ua)*4.392046e8/(1.25);
if(part->get_c1_boundx()==1)
{
vit *= -1;
}
// Onde S
yy=part->get_pos_init(0);
yy=yy-4500.;
yy=sqrt(yy*yy);
if(yy>3000.)
{
vit=0.;
}
part->set_Ftot(0, part->get_Ftot(0)+vit);
part->set_Mrm(2, 0.);
}
}
};
//-----------------------------------------------------------
void Cond_limite_ext::perturbation_velocity(Particule_ext* part,Kflo time)
{
if(part!=NULL)
{
// Mouvement de translation pour le projectile:
if (part->get_cl_boundx()>0)
{
part->set_velrot(2, 0.);
part->set-e(2, 0.);
}
}
};
// Enregistrement des données:
void Cond_limite_ext::save_cont(double time)
{
int ID, ID_J;
int indice;
int nb;
double hug, sx, sy;
double DIJ, DIJ_init;
double fi;
double f2;
double pression_pmma, pression_cuivre, v_moy_cuivre, v_moy_quartz, v_moy_pmma, v_couple;
int ind_cuivre, ind_quartz, ind_pmma;
iterateur_particule_ext itpart;
Particule_ext* part;
Metre position [3];
// Pointeur sur le gestionnaire de messages
Mka3D_msg* msg=Mka3D_msg::get_ptr();
pression_cuivre=0;
pression_pmma=0;
v_moy_cuivre=0;
v_moy_quartz=0;
v_moy_pmma=0;
ind_cuivre=0;
ind_pmma=0;
ind_quartz=0;
v_couple=0;
nb=0;
hug=0;
sx=0;
sy=0;
fi=0;
f2=0;
indice=1;
}
// Enregistrement des valeurs:
void Cond_limite_ext::oerturbation_Disp(Particule_ext* part, Kflo time)
{
};
END_NAMESPACE_MKA3D |
Comprendre un programme existant
Répondre avec citation
Partager