Discussion :

[BAmal]

Salut,
je voudrais bien générer des positions aléatoires à l aide d la subroutine Random number ,mais je voudrais aussi imposer une distance minimale qui sépare n importe quels deux points de mon maillage ,quelq'un peut m aider sur ce problème ,voilà ce que j ai bien réussi à faire ,merci

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
30      do   m=1,3
			    call random_number(x)
		        call random_number(y)
          10     do   i=1,n*n
          20     do   j=1,n*n
			    dx=x(j)-x(i)
	            dy=y(j)-y(i)
			    rad=sqrt(dx**2+dy**2)
				write(300,*) i,j,rad
		        enddo
				if(rad<dd) then  ! dd est la distance minimale que j ai imposée 
				!write(*,*) rad
				go to 10
				else
				go to 30
				!write(*,*) x(i),y(j) 
 
				endif
				!write(*,*) rad
			    enddo
		        enddo

[xflr6]

Bonjour,

Même si j'en ai une idée, j'ai un peu de mal à comprendre ce que tu essaies de faire.
1) Essaies-tu de construire un réseau de points répartis aléatoirement (avec des distances inter-points "correctes"), c'est à dire un pb de type sphères dures en 2D ?
2) Ou alors tu as déjà un réseau, et tu désires tirer certains points de ce réseau aléatoirement ?

J'ai l'impression que c'est l'option 1, right ? Pour celle-ci, il faut
- tirer le premier point
- tirer les suivants en vérifiant pour le n-ième qu'il n'overlap pas les n-1 précédents. Si overlap, recommencer jusqu'à ce qu'il n'est ai plus => attention si le rayon est trop grand et le nombre de points trop grands, ça va boucler indéfiniement, il faut donc choisir le rayon en fonction du nombre de points ou inversement pour avoir une densité relativement faible

Pour avoir une idée, jette un coup d'oeil au code ci-dessous, ça fait le job pour des sphères dures sans conditions de bords. Ce n'est pas forcément la ou une bonne solution, mais l'algo est détaillé :

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
program hs
  implicit none
  integer, parameter          :: n     = 10000
  double precision, parameter :: rad   = 0.50d0/sqrt(dble(n))
  integer, parameter          :: nstop = 10000
  integer            :: i, j, nrejet ! iterateurs
  logical            :: accept       ! condition d'acceptance du tirage
  double precision   :: x(n), y(n)   ! les mailles du reseau
  double precision   :: d2, a, b     ! variables intermediaires pour le tirage
  double precision   :: d2min        ! distance min entre 2 points au carre
  !
  d2min = (2.d0*rad)**2 ! rad est le rayon d'une sphère, d2min distance minimale au carré
  ! Le premier point... car il en faut bien un ;-) !
  call random_number(a)
  call random_number(b)
  x(1)=a
  y(1)=b
  ! Les autres points
  do i=2,n
    nrejet = 0               ! On initialise un compteur quelconque ...
                             !    ... pour ne pas boucler indéfiniement
lm: do                       ! On commence un boucle pour tirer un point valide
      call random_number(a)  ! On tire x ...
      call random_number(b)  !           et y ...
      accept = .true.        !                et on suppose que c'est ok
lt:   do j=1,i-1             ! ET ON TESTE SUR TOUS LES POINTS DEJA VALIDES
        d2 = (x(j)-a)**2 + (y(j)-b)**2
        if ( d2 < d2min ) then
          accept = .false.   ! si on a un et un seul overlap, c'est mauvais !
          exit lt            !    => pas la peine de tester les autres points
        endif
      enddo lt
      if ( accept ) exit lm  ! si on a accept qui est encore true ici : YES !
                             !          ... et on peut sortir de la boucle lm
      nrejet = nrejet+1      ! sinon, on a un rejet supplémentaire et on boucle...
                             ! pas trop quand meme...
      if ( nrejet > nstop ) stop 'trop de rejets successifs...'
    enddo lm
    ! si on en est arrive la sans STOP, on a notre point 'i' 
    x(i) = a
    y(i) = b
  enddo
end program hs

Il faut aussi faire attention aux effets de bords s'il y en a.

[BAmal]

SALUT,

Un grand merci pour votre intérêt,j essaie de comprendre votre code ,je vois à peu prés ce que vous voulez faire,je vais regarder encore pour en déduire peut être ce que je veux vraiment obtenir!
en pièce joint les nœuds de maillage que je voulais créer ,des nœuds aléatoires ouiiiiiiii mais un maillage homogène c est ce que j arrive pas a faire!!!!

merci

[xflr6]

Bonsoir,

Il me faut plus d'explications pour comprendre.

Sur la pièce jointe :
Est-ce ce que vous voulez pour les points noirs ?
Il y a me semble-t-il un traitement spécial pour les bords ?
C'est quoi le truc rouge ?

Pour le reste :
N'y a-t-il pas contradiction conceptuelle entre aléatoire et homogène ?
L’homogénéité arriverait avec passage à la limite (rayon -> 0 et N -> \infty).
Ou alors, le rayon, c'est pour "gagner" en "homogénéité" (ou plutot pour éviter la clusterisation) ?

[BAmal]

Je vais faire de mon mieux pour vous expliquer ;

Alors:
1- Sur la pièce jointe que je vous ai envoyé la dernière fois ---- le truc en rouge n'est pas important dans cette étape ,j'en aurai besoin après ------- ,ce sont plutôt les points noirs ,que je veux créer --------plus précisément ces points noirs sont bien les nœuds de mon maillage ,ils ont été crées de manière aléatoire mais le maillage dans son ensemble est homogène ,sur ce que je viens de vous envoyer maintenant le même maillage c'est à dire des points noirs aléatoires pour le même nombre de nœuds, avant de passer à l'étape homogène c est à dire mes nœuds avant que j'impose une certaine distance minimale) ---------
2-Oui , vous avez raison ,les nœuds aux bords ,je les ai crées séparément ,mais il leurs faut aussi une condition pour qu'ils ne soient pas aussi non homogène c est à dire (en clustérisation si je peux dire ça)
3-Oui, y a une contradiction conceptuelle entre aléatoire et homogène dans le sens propre de mot ,mais ici, ce qu on veux bien c est de ne pas avoir une clusterisation qui génère bien des matrices singulières dans notre calcul parce que par exemple ,en utilisant une maniéré aléatoire on peut facilement générer deux points qui sont trop proches l'une de l'autre ce qui complique nos mesures après.
4-Pourquoi donc ne pas utiliser un maillage régulier? ,oui,le maillage régulier je l'ai fait et j ai validé mes calcul avec,ce que je veux bien c est d avoir plus de précision dans mes calculs et cela est fait par le maillage irrégulier (aléatoire /homogène) ,ce qui a été déjà prouvé par des chercheurs dans le même domaine.

j’espère que je me fais bien comprendre.
Merci encore une fois pour votre intérêt.

[xflr6]

Ok, mais alors, modulo éventuellement les points aux bords, qu'est-ce qui ne va pas et que vous voulez changer dans la figure que vous avez mise en PJ hier ?

[LittleOwl]

Bonjour,

Je ne suis pas sur d'avoir absolument bien saisi ce que vous vouliez faire, mais j'ai l'impression que vous souhaitez générer un maillage cartésien irrégulier de manière aléatoire tel que la distance entre 2 noeuds quelconques soit supérieure à une distance minimale.

Si c'est le cas, l'hypothèse d'un maillage cartésien simplifie considérablement le problème car, pour que la dernière condition soit vérifiée, il faut et il suffit que le pas du réseaux selon les abscisses (resp. les ordonnées) soit supérieur à la distance minimale que l'on souhaite imposer entre les noeuds.

Le code ci-dessous implante cette approche.

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
 
program random_irregular_cartesian_grid
implicit none
real, parameter		::  dmin = 2., &	! Distance minimale entre 2 noeuds (unite arbitraire)
				     dmax = 3.	! Distance maximale entre 2 noeuds (unite arbitraire)
 
integer, parameter	:: n  = 100	! Nbr de points de la grille
 
real, dimension(n)   :: x, &	! grille (abscisses)
			       y	! grille (ordonnees)
real, dimension(2*n-2) :: rnd	! Nombres pseudo-aléatoires 0 <= rnd <= 1
 
integer :: i, j, k, l
real	:: dx, dy, d
real	:: time_begin,time_end
 
!**** Generation de la grille
 
call cpu_time(time_begin)
call random_number(rnd)	
x(1) = 0.; y(1) = 0.	! Le premier point est choisi comme origine
j = 1				! Indice permettant de parcourir le tableau rnd
do i = 2, n
  dx = rnd(j)*dmin   + (1.-rnd(j))*dmax;	x(i) = x(i-1) + dx  ! dmin <= dx <= dmax
  dy = rnd(j+1)*dmin + (1.-rnd(j+1))*dmax;	y(i) = y(i-1) + dy  ! dmin <= dy <= dmax
  j = j + 2
end do
call cpu_time(time_end)
 
print *,"*** Grille (Pt n°|x|y)",n*n," points."
do i = 1, n
	do j = 1, n
	 print *,j+n*(i-1),x(i),y(j)
	end do
end do
print '("Generation",t20,": ",es7.1," s.")',(time_end-time_begin)
 
!*** Verification de la condition ||M_kl.M_ij|| >= 
 
call cpu_time(time_begin)
do i = 1, n
 do j = 1, n
   do k = 1, n
     do l = 1, n
	   dx = x(k) - x(i)
	   dy = y(l) - y(j)
	   d  = sqrt(dx*dx + dy*dy)
	   if ((d < dmin).AND.((k /= i).OR.(l /= j))) then
		print '("Error : Pt N°",i7," - ",i7,"d = ",g9.3)',j+n*(i-1),l+n*(l-1),d
	   end if
	 end do
   end do
 end do
end do 
call cpu_time(time_end)
print '("Verification",t20,": ",es7.1," s.")',(time_end-time_begin)
 
end program random_irregular_cartesian_grid

1. l19 - l26 : Génération du maillage. Le premier point (x(1),y(1)) étant choisi comme origine, il est nécessaire de générer aléatoirement n-1 abscisses et n-1 ordonnées. Pour ce faire, le générateur de nombres peuso-aléatoires est appelé l19 pour générer 2n-2 nombres aléatoires, tous compris entre 0 et 1. Les nombres d'indices pairs (resp. impairs) sont utilisés pour générer un pas aléatoire compris entre dmin et dmax selon l'axe des abscisses (l23) et des ordonnées (l24).

2. l29 - l35 : Affichage de la liste des noeuds. Les noeuds sont numérotés et leurs coordonnées affichées en commençant par l'origine et en suivant l'ordre des lignes.

3. l40 - l53 : Vérification de la condition sur la distance entre les noeuds du réseau. La distance entre 2 noeuds quelconques du réseau est calculée de manière systématique et on vérifie qu'elle est bien supérieure à la distance minimale souhaitée. Le temps de calcul de cette étape peut être réduit lorsque le nombre de noeuds est élevé en se limitant aux premiers voisins.

Ce problème est intermédiaire entre la génération d'un maillage régulier et celui d'un maillage non structuré aléatoire, type sphère dure, tel que le décrit xflr6.

Bonne continuation.