Liste de petites sphères coupées par grossissement d'une sphere moyenne jusqu'à Rmax

**mecaplus** · 03/03/2011, 18h22

Bonjour,

J'essaie de réaliser un programme C conforme à l'algorithme simplifié dans le fichier pdf ci-joint. L'idée est simple, parcourir un ensemble de petites sphères i de rayon ai contenues dans une grosse sphère A de rayon Rmax en faisant grossir une sphère B de rayon r jusqu'à ce que le rayon de cette sphère soit égal à Rmax.

Au passage, on établie une liste les petites sphères i coupées par la sphère B. (le dessin et l'algorithme dans le fichier ci-joint permet d'illustrer mes propos).

Après réflexion j'ai mis en place l'algorithme simplifié consultable dans le fichier. Le programme écrit en C est donné ci-dessous :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
/* code de calcul simplifie */
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#define nmaxg  10
#define nmaxp  100
 
 
struct vecteur{
	double x;
	double y;
	double z;
};
 
struct sphere{
 
  struct vecteur Pi;
  double rayon;
 
};
 
/* Variables globales */
 
struct sphere grosse[nmaxg];
struct sphere petite[nmaxp];
 
int liste[nmaxg][nmaxp];
 
/* Declaration prototype de la fonction retournant le nombre de spheres coupees */
//int retourne(void);
 
 
 
 
/*===================================================== 			
		Programme retournant le nombre de petites spheres
			coupant une grosse sphere  
 =======================================================*/
 
int retourne(void)
 
{
 
int i,j,l,npcut;
double sij,dij,ai,rp;
double r0,dr,Rmax,r;
double xp,yp,zp,xg,yg,zg;
 
 
			/* Initialisation de la liste des petites spheres i coupant la grosse particule j */
 
			 for (j=0;j<nmaxg;j++){
			   for(i=0;i<nmaxp;i++){
 
			    liste[j][i]=0;
 
			   }
			 }
 
		 /* Initialisation des positions des petites spheres i et de leur rayon ai*/
 
				rp=0.5;
				 for(i=0;i<nmaxp;i++){
					petite[i].Pi.x=0.0;
					petite[i].Pi.y=0.0;
					petite[i].Pi.z=0.0;
					petite[i].rayon=rp;
 
				 }
 
 
 
		/* Initialisation des positions des grosses spheres j et de leur rayon r0*/
				r0=0.5;
				 for(j=0;i<nmaxg;j++){
					grosse[j].Pi.x=68.709244;
					grosse[j].Pi.y=41.190768;
					grosse[j].Pi.z=46.994176;
					grosse[j].rayon=r0;
				 }	 
 
 
		/* Positions de toutes les petites sphères  (a la main pour le moment)*/
 
					petite[0].Pi.x=68.739818;petite[0].Pi.y=36.338619;petite[0].Pi.z=47.033400;
					petite[1].Pi.x=68.751057;petite[1].Pi.y=35.342589;petite[1].Pi.z=47.046098;
					petite[2].Pi.x=68.733077;petite[2].Pi.y=37.336013;petite[2].Pi.z=47.024592;
					petite[3].Pi.x=68.726898;petite[3].Pi.y=38.333393;petite[3].Pi.z= 47.016701;
					petite[4].Pi.x=68.715185;petite[4].Pi.y=40.328183;petite[4].Pi.z=47.001699;
					petite[5].Pi.x=68.721253;petite[5].Pi.y=39.330804;petite[5].Pi.z=47.009528;
					petite[6].Pi.x=68.703453;petite[6].Pi.y=42.322970;petite[6].Pi.z=46.986340;
					petite[7].Pi.x=68.709359;petite[7].Pi.y=41.325591;petite[7].Pi.z=46.994238 ;
					petite[8].Pi.x=68.691409;petite[8].Pi.y=44.317759;petite[8].Pi.z=46.971378;
					petite[9].Pi.x=68.697063;petite[9].Pi.y=43.320374;petite[9].Pi.z=46.978808 ;
					petite[10].Pi.x=68.678527;petite[10].Pi.y=46.312538;petite[10].Pi.z=46.955216 ;
					petite[11].Pi.x=68.685288;petite[11].Pi.y=45.315164;petite[11].Pi.z=46.963515;
					petite[12].Pi.x=68.667791;petite[12].Pi.y=47.308595;petite[12].Pi.z=46.942774;
 
		 /* Position de la grosse sphere */
 
		         xg=grosse[0].Pi.x;
				 yg=grosse[0].Pi.y;
				 zg=grosse[0].Pi.z;
				 r=grosse[0].rayon;
 
		/* Etape 1 de l'algorithme ci-joint : calcul des distances entre i et j */
 
				dij=0.0;
				Rmax=3.733746;
				dr=Rmax/10;
 
				fprintf(stdout,"increment rayon =%lf \n",dr);
 
				for(i=0;i<nmaxp;i++){
					/* recuperation de la position de la sphere i */
				     xp=petite[i].Pi.x;
					 yp=petite[i].Pi.y;
					 zp=petite[i].Pi.z;
					 ai=petite[i].rayon;
 
					 /* Calcul de la distance entre les centres de i et j */
 
				     dij=sqrt((xp-xg)*(xp-xg)+(yp-yg)*(yp-yg)+(zp-zg)*(zp-zg));
 
					 sij=0.0;
					 npcut=0;
					 r=grosse[0].rayon;
					 do{
					 printf("r:%lf, rMax: %lf\n", r, Rmax);
					 /* Calcul de la distance entre les surfaces de i et de j */
 
					 sij=dij-(r+ai);
 
					 /* On identifie les petites spheres qui coupent la grosse sphere 
					 et on incremente le compteur npcut;*/
 
					    if(sij<0.0){
							npcut++;
							liste[0][0]=i; /* On stoke dans les identites des spheres i qui coupent la grosse sphere j=1 */
							l=liste[0][0];
						}
 
						r+=dr; /* On incremente la valeur de r */
 
					}while(r<=Rmax);
 
 
				} /* Fin de la bouche sur les petites particules */
 
 
			return(npcut);
 
}
 
 
/*========================================================================
						MAIN PROGRAM - PROGRAMME PRINCIPAL
======================================================================*/
 
/* Main program */
 
 int main()
 
{
      int nsphere;
 
		nsphere=retourne();
 
		fprintf(stdout," Nsphere =%d \n",nsphere);
 
        return EXIT_SUCCESS;
 
}

Pas de problème à la compilation et pour l'exécution, cependant le résultat renvoyé ne me paraît pas cohérent. Lorsque je raffine dr (incrément du rayon), typiquement dr=Rmax/100., le nombre de petites sphères (renvoyé par le programme) est supérieur au nombre initial de petites sphères et pour dr=Rmax/10. il renvoie 10, inférieur à 13 (nombre initial de petites sphères) mais résultat pas cohérent tout de même.

En effet, en faisant varier le rayon r=r+dr , je m'attends à ce que le nombre de sphères coupées augmente avec le grossissement de la sphère B et à retrouver le nombre initial de petites sphères quand r=Rmax.

Pouvez-vous m'aider à rendre conforme ce code par rapport à l'algorithme ci-joint en corrigeant les éventuelles erreurs de programmation? D'avance merci pour votre aide.