Petits soucis avec un programme

Bonjour tout le monde :D

Je viens faire un petit tour sur ce forum pour la première fois depuis un bon moment parce que j'ai un petit souci avec un programme en C. En fait, le logiciel que j'utilise accepte de compiler le code, mais une fois que je lance le calcul correspondant, il tourne à vide. J'en ai conclu qu'il devait y avoir une instruction quelque part dans le code dont le calculateur n'arrivait pas à se sortir.

Je vais poster le code. Si quelqu'un peut parvient à trouver le pépin, je lui en serais vraiment reconnaissant parce que ça fait un bon moment que je tourne dessus sans obtenir de résultat.

Code:

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
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
 
#include "cond_limite_ext.h"
//#include "stdio.h"
 
BEGIN_NAMESPACE_MKA3D
 
//		------------------------------------------------------------ 
//		PARTICULE		AUX		LIMITES
//		------------------------------------------------------------
 
void Cond_limite_ext::init_CL()
{
  int    Nxg;
  int    Nxd;
  Index32u ID, ID_J;
  double alpha ;
    double xdist1, xdist2 ;
 
  iterateur_particule_ext itpart;
  Particule_ext* part;
  // Pointeur sur le gestionnaire de messages
  Mka3D_msg* msg=Mka3D_msg::get_ptr();
 
  // 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); 
*/
 
  // Donnees locales
  alpha = 2.;
  Nxg = 0; 
  Nxd = 0; 
  //indentification des DE composant les bords 
  // initialisation des positions
 
  for (itpart  = premiere_particule() ; 
       itpart != derniere_particule() ; itpart++ ) 
    { 
      part = (*itpart);
      ID   = part->get_ID();
 
      part->set_cl_boundx(-1);
      part->set_cl_boundy(-1);
 
//Particules immobiles dans la partie gauche de la zone d' amortissement    
	if ( (part->get_pos(0) >= 0) && (part->get_pos(0) <= 16530) && (part->get_pos(1) >= 0) && (part->get_pos(1) < 2485) ) 
		{ part->set_cl_boundx(1); } 
	if ( (part->get_pos(0) >= 0) && (part->get_pos(0) <= 16530) && (part->get_pos(1) > 2515) && (part->get_pos(1) <= 2830) ) 
		{ part->set_cl_boundx(1); }
	if ( (part->get_pos(0) >= 0) && (part->get_pos(0) < 2390) && (part->get_pos(1) >= 2485) && (part->get_pos(1) <= 2515) ) 
		{ part->set_cl_boundx(1); }
	if ( (part->get_pos(0) > 14335) && (part->get_pos(0) <= 16530) && (part->get_pos(1) >= 2485) && (part->get_pos(1) <= 2515) ) 
		{ part->set_cl_boundx(1); }
 
//Particules immobiles dans la partie droite de la zone d' amortissement:
//        if ( (part->get_pos(0) >= 3600) && (part->get_pos(0) <= 20300) && (part->get_pos(1) >= B) && (part->get_pos(1) <= H - B) ) 
//		{ part->set_cl_boundx(1); } 
 
//Particules en mouvement horizontal vers la gauche: 2 rangées en dessous de la faille      
	if ( (part->get_pos(0) >= 2390) && (part->get_pos(0) <= 14335) && (part->get_pos(1) >= 2485 ) && (part->get_pos(1) <= 2495)) 
		{ part->set_cl_boundx(2); } 
 
//Particules en mouvement oblique vers le bas: une rangée simple à droite de la faille      
	else if ( (part->get_pos(0) >= 2390) && (part->get_pos(0) <= 14335) && (part->get_pos(1) >= 2505) && (part->get_pos(1) <= 2515)) 
		{ part->set_cl_boundx(3); } 
 
 
          part->set_vel(0, 0.);  
          part->set_vel(1, 0.);  
          part->set_vel(2, 0.);  
//           } 
 
    } 
  // Info sur l'essai 
 
} 
 
void Cond_limite_ext::init_array_tool()
{
  // Initialisation des donnees utilisateurs (tableaux et scalaires)
  // ces donnees sont utilisables dans l'ensemble des methodes presentes
  // dans ce fichier
  //
  // Procedure appelee en debut de simulation (avant init_CL()) et a 
  // chaque reprise de calcul
 
  string nom_fic;
  ifstream fic_don;
  int int_temp, ndata;
  Kflo reel_temp;
 
  int_temp = 10000;
 
  set_nb_tab_reel(2) ;
  nom_fic="./courbeI1";
  fic_don.open(nom_fic.c_str());
 
  // Lecture du nombre d'éléments et dimensionnement du tableau correspondant
  for (int i=0; i<2; i++)
      {
       set_dim_tab_reel(i, int_temp);
      }
 
  for (int i=0; i<int_temp; i++)
      {
       fic_don>> reel_temp;
       set_tab_reel(0, i, reel_temp);
       fic_don>> reel_temp;
       set_tab_reel(1, i, reel_temp);
      }
 
  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.;
fmax3=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]; 
Kflo vel[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=10000;
      //40000: 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))
	       {
	        i1=ijk;
		i2=ijk+1;
		dal=(time - get_tab_reel(0, ijk))/(get_tab_reel(0, ijk+1) - get_tab_reel(0, ijk));
		xvalue = (1.-dal)*get_tab_reel(1, i1) + dal*get_tab_reel(1, i2);
		iflag=1;
		}
	     else
	       {
	        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);  // vit est un incrément de force. Ca n'a rien à voir avec une vitesse
      if(part->get_cl_boundx()==1)
     {
      vit *= 0;
     }
   if(part->get_cl_boundx()==2)
     {
      vit *= 1;
     }
 
   else if(part->get_cl_boundx()==3)
     {
      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)
{  
 
//      Kflo xt, xx ;
//        xt = 0.4637;
  if ( part != NULL )
    {  
     //Vitesses verticale non nulle pour les particules situées à gauche de la faille
     if (  part->get_cl_boundx()  == 2 )		
        {
            part->set_vel(0, 0.);
	    part->set_vel(1, 1.);
        }
 
     //Vitesse verticale non nulle pour les particules situées à droite de la faille
     if (  part->get_cl_boundx()  == 3 )		
        {
            part->set_vel(0, 0.);
	    part->set_vel(1, -1);
        }     
    }
};
 
//-----------------------------------------------
// ENREGISTREMENT DONNEE
//-------------------------------------------------
 
/*
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 ; 
  double pression_cuivre ; 
  double v_moy_cuivre ;
  double v_moy_quartz ;
  double v_moy_pmma;  
  double v_couple;
  int    ind_cuivre;
  int    ind_quartz;
  int    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::save_cont(double time){}
 
//Fonction de déplacement
float depla(double time) 
{return(0.20*time);}
 
void Cond_limite_ext::perturbation_Disp(Particule_ext* part,Kflo time) 
{ 
 
  if ( part != NULL )
    {
 
     //Déplacement imposé pour les particules situées à gauche de la faille 
     if ( part->get_cl_boundx() == 2 )		
        {
	  part->set_pos(1, part->get_pos_init(1) + depla(time));
	}
 
     //Déplacement imposé pour les particules situées à droite de la faille
     if ( part->get_cl_boundx() == 3 )		
        {
	  part->set_pos(1, part->get_pos_init(1) - depla(time));
	}
     }
 
}
 
//void Cond_limite_ext::perturbation_Disp(double time, int Iteration)
 
 
END_NAMESPACE_MKA3D

A priori, tout ce qui se trouve entre les lignes // Données locales et // Info sur l'essai (en début de code) doivent être bonnes. À mon avis, le "Hic" vient de ce qui est un peu plus bas.
Ce code utilise des notations spécifiques au logiciel que j'utilise. Si il y a besoin de points d'éclaircissement, n'hésitez pas à me demander.

A bientôt et merci d'avance :ccool:

Je précise égalemrnt que je dispose du fichier exécutable intitulé courbeI1, donc le souci ne vient pas de là non plus

Yop,
Pas trop le temps de regarder, mais, déja y a un truc qui me pique les yeux:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 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)) { i1=ijk; i2=ijk+1; dal=(time - get_tab_reel(0, ijk))/(get_tab_reel(0, ijk+1) - get_tab_reel(0, ijk)); xvalue = (1.-dal)*get_tab_reel(1, i1) + dal*get_tab_reel(1, i2); iflag=1; } else { ijk += 1; } } while(iflag==0); }
Je sais pas si tu as vu, mais tu modifies la valeur de ta boucle for, sans la remettre à son état d'origine...

Cordialement,

F-k-z

Euh....

Justement, je ne vois pas... Pourrais tu s' il te plaît être plus spécifique? Cette boucle me paraît fermée.... :roll:

Merci d'avance

yop,
pour simplifier ta boucle, tu as un truc du genre:
Code:

1 2 3 4 for (i=0; i< 10; i++){ /* On fait varier en théorie i de 0 à 10 */ i=0; /* Mais on le remet tout le temps à 0; /* On fait tout pleins de traitement en fonction de notre i, donc on ne connait pas sa valeur, mais elle reste surement inférieur à 10 */ } /* on retourne au début de la boucle for avec notre i d'une valeur inconnue pour nous et on l'incrémente, puis il va revenir à 0, etcetc
Evite de modifier la valeur d'une variable contenue dans une boucle for, sinon tu auras souvent des résultats plus ou moins incohérants par rapport à ta demande ;)

F-k-z

Ben je ne vois toujours pas le problème justement....:?

A l'intérieur de la boucle, on distingue deux étapes avec des instructions différentes. La première est une série d'instructions qui intervient quand la variable ijk vaut 0 et l'autre qui entre en jeu pour toutes les autres valeurs de ijk jusqu'à nn-1....

Quel est le souci là dedans?

Yop

Si on retire les lignes de traitements de ton while, ton code devient:
Code:

1 2 3 4 5 for(ijk=0; ijk<nn-1; ijk++) { ijk=0; }
tu es d'accord ? Et la ne serais-ce pas une boucle infinie (mal formée je suis d'accord, mais infinie quand même).
Donc si tu rajoutes une variable j, afin d'avoir un code similaire à celui-ci:
Code:

1 2 3 4 5 6 7 8 int j=0; for(ijk=0; ijk<nn-1; ijk++) { ijk=0; printf("%d\n",j); j++; }
tu obtiendras en sortie:

Citation:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
...

tu vois le truc ?
Il faut absolument que tu ne change pas la valeur de ton ijk à l'intérieur de ta boucle.
Code:

1 2 3 4 5 for(ijkbouclefor=0; ijkbouclefor<nn-1; ijkbouclefor++) { ijk=0; }
ne s'éxécutera que nn-1 fois ;)

F-k-z

CA MARCHE!!!!!!!!!!!!!!!! YAHOOOOO!!!!! :mrgreen: :mrgreen: :mrgreen:

Merci beaucoup de m'avoir débloqué. Je te dois une fière chandelle!!! :ccool: :ccool:

Yop,
de rien, le meilleur moyen de me remercier c'est surtout d'avoir compris et de faire attention à ce genre de problème ^^

F-k-z

Précisons au passage, que ce code est en C++, pas en C.