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 |
Partager