Discussion :

[fibuleur]

Bonjour à tous !

J'aimerais coder un grillage découpé en zones. Des sites polluants sont répartis aléatoirement dans les zones avec une probabilité de rendre la zone contaminée.
Ce qui donnerait grossièrement le schéma ci-dessous :


J'ai besoin de votre aide afin de savoir comment s'y prendre en terme de programmation car je ne sais pas du tout comment démarrer (Plutôt une programmation orientée objet ou alors un code plus simple est envisageable dans mon cas ?).

Merci d'avance pour vos réponses !

[charliemtx]

Bonjour,

C'est un peu vague comme demande, vous ne précisez aucune condition sur la distribution de probabilité, sur la façon dont vous quadrillez le plan, le seul de contamination, etc...

Voici un code qui génère des points de contaminations aléatoires et qui propage la contamination autour du point d'une distance définie. Chaque point de la carte sera considéré comme contaminé si au moins N points de contaminations se trouvent à moins de la distance définie. Peut-être que vous pouvez partir de là...

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
import numpy as np
import random
import matplotlib
matplotlib.use('tkAgg')
import matplotlib.pyplot as plt
contamination_range = 50
 
# Matrix dimensions
DIM_X = 800
DIM_Y = 800
 
# Generate random contaminated points
contaminated_points = [(int(DIM_X*random.random()),int(DIM_Y*random.random())) for i in range(100)]
 
# Initialize matrix
M = np.zeros((DIM_X,DIM_Y))
 
# Propagate individual contamination
for point in contaminated_points :
    # Determine boundaries to check and avoid examinating the entire matrix
    min_x,max_x = max(point[0]-contamination_range,0), min(point[0]+contamination_range+1,DIM_X)
    min_y,max_y = max(point[1]-contamination_range,0), min(point[1]+contamination_range+1,DIM_Y)
 
    for i in range(min_x, max_x) :
        for j in range(min_y, max_y) :
            # Use circle equation for a surface
            d = (i-point[0])**2 + (j-point[1])**2
            if d <= contamination_range**2 : M[i,j]+=1
 
# Plot results
fig, ax = plt.subplots(1,2)
ax[0].matshow(M)
ax[0].set_title('Individual contamination', pad=20)
# Check if field is contaminated
contamination_threshold=5
M[M<contamination_threshold]=0
M[M>=contamination_threshold]=1
 
ax[1].matshow(M)
ax[1].set_title('Global contamination', pad=20)
plt.show()

[fibuleur]

Bonjour et merci pour votre réponse,

J'ai effectivement oublié de préciser que je souhaitais considérer une centaine de zones (donc un quadrillage de 10x10) et on considère une loi d'activation suivant une loi de Poisson aussi, on considère qu'une zone est contaminée et ce, dès le premier site activé à l'intérieur de celle-ci. La répartition des sites se fait de façon aléatoire et uniforme (j'avais oublié de préciser l'uniformité). Les zones contaminées n'ont pas d'influence sur les zones voisines et les sites activés n'ont pas d'incidence sur les sites actifs.

Voilà pour les précisions .

Je vais déjà essayer de me débrouiller avec ce que vous m'avez fourni.

Encore merci !

[fibuleur]

Bonjour à tous !

J'ai avancé sur mon programme mais il ne me reste plus qu'une seule étape : Compter le nombre de zones qui sont colorées dans la figure ci-dessous :

Si quelqu'un a une idée sur la façon de faire, je suis preneur !

Et le code qui va avec ma simulation :

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
import numpy as np
import matplotlib.pyplot as plt
import random
 
dim = 100
A = np.zeros((100,100)) # Génération des 100 zones
m = 25
sig_inf = 1
sig_0 = 1
Nep = 100
 
nsites = int(np.round(Nep*np.log(2)*(sig_0/sig_inf)**m)) # Nombre de sites actifs moyen dans le volume
 
 
Sites = [[int(dim*random.random()),int(dim*random.random())] for i in range(nsites)] # Distribution aléatoire des points dans la matrice
 
class carre(): # Classe permettant de définir les carrés associées à chaque zone
    def __init__(self,x1,y1,x2,y2):
        self.x1 = x1
        self.x2 = x2
        self.y1 = y1
        self.y2 = y2
 
liste_carres = [] # Liste contenant les zones de chaque éprouvette
 
for j in range(0,91,10): # Remplissage de la liste des zones
    for k in range(0,91,10):
        liste_carres.append(carre(j,k+10,j+10,k))
 
# print(liste_carres[0].x1) # Test du bon fonctionnement de la méthode
 
 
for i in range(len(Sites)):
    for j in range(len(liste_carres)):
        x1 = liste_carres[j].x1
        x2 = liste_carres[j].x2
        y1 = liste_carres[j].y1
        y2 = liste_carres[j].y2
        if ((Sites[i][0] < x2 and Sites[i][0] >= x1) and #test pour savoir si un site est dans une zone
            (Sites[i][1] >= y2 and Sites[i][1] < y1)): 
            A[x1:x2,y2:y1] = 250
 
for i in range (0,100,10): # Création du grillage horizontal
    for j in range (100):
        A[i,j]=800
 
for i in range (0,100,10): # Création du grillage vertical
   for j in range (100):
       A[j,i]=800
 
for i in range(len(Sites)): # Distinction des sites actifs dans la matrice
    A[Sites[i][0],Sites[i][1]] = 1000
 
print("nsites = "+str(nsites))
 
 
plt.matshow(A)

Edit: j'ai trouvé la solution, je passe le sujet en résolu