263 lines
9.9 KiB
Python
263 lines
9.9 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
import sys
|
|
import random
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
import math as m
|
|
from datetime import datetime
|
|
|
|
# précalcul du potentiel qui est linéaire
|
|
RAPINIT = True
|
|
# sous partie à mettre à jour à un nouveau pixel de taille 2S+1x2S+1
|
|
S = 10
|
|
MAJPETITE = False
|
|
# 1% = 0.01, 0.1% = 0.001, convergence optimale à 0.00001 mais compromis vitesse 0.0001
|
|
MAXDELTA = 0.017
|
|
|
|
if len(sys.argv) != 3:
|
|
N = 64
|
|
eta = 6
|
|
else:
|
|
# dimension de la grille NxN
|
|
N=int(sys.argv[1])
|
|
# paramètre de croissance de la structure
|
|
eta=float(sys.argv[2])
|
|
|
|
partMax = 50000
|
|
# la grille est de NxN mais en réalite la mesure d'une unité h est 1/N
|
|
pixelsBitmap = [[0 for j in range(N)] for i in range(N)]
|
|
# que pour le dessin pour éviter la transposition
|
|
dessinBitmap = [[0 for j in range(N)] for i in range(N)]
|
|
# conditions initiales -1 charge négative ou 1 charge positive ou 0 non defini sera mis à jour pendant le programme avec les nouvelles charges
|
|
condInitBitmap = [[0 for j in range(N)] for i in range(N)]
|
|
potentielsBitmap = [[0.0 for j in range(N)] for i in range(N)]
|
|
pixelsCroissance = []
|
|
potentielsCroissance = []
|
|
|
|
def init():
|
|
# ligne du bas en charge positives et trois charges supperposées en haut au milieu
|
|
# ligne du bas en charge positives et ligne du haut en charges négatives (nuage)
|
|
for i in range(N):
|
|
condInitBitmap[i][N-1] = 1
|
|
potentielsBitmap[i][N-1] = 1
|
|
dessinBitmap[N-1][i] = 1
|
|
for i in range(N):
|
|
condInitBitmap[i][0] = -1
|
|
potentielsBitmap[i][0] = 0
|
|
dessinBitmap[0][i] = 0.5
|
|
if RAPINIT:
|
|
# calcul analytique initial du potentiel entre deux plaques: potentiel linéaire en y
|
|
for j in range(1,N-1):
|
|
pot = 0.0+j*1.0/(N-1)
|
|
for i in range(N):
|
|
potentielsBitmap[i][j] = pot
|
|
|
|
# paramètre de relaxation pour accélérer la convergence
|
|
omega = 1.6
|
|
|
|
def majPotentielRapide(i,j):
|
|
delta = 0.0
|
|
nb = 1
|
|
if abs(condInitBitmap[i][j]) != 1:
|
|
if i == 0:
|
|
delta = potentielsBitmap[i+1][j] + potentielsBitmap[i][j-1] + potentielsBitmap[i][j+1] - 3 * potentielsBitmap[i][j]
|
|
nb = 3
|
|
elif i == N-1:
|
|
nb = 3
|
|
delta = potentielsBitmap[i-1][j] + potentielsBitmap[i][j-1] + potentielsBitmap[i][j+1] - 3 * potentielsBitmap[i][j]
|
|
else:
|
|
delta = potentielsBitmap[i-1][j] + potentielsBitmap[i+1][j] + potentielsBitmap[i][j-1] + potentielsBitmap[i][j+1] - 4 * potentielsBitmap[i][j]
|
|
nb = 4
|
|
# on ne met à jour que les points qui ne sont pas des contraintes initiales ou qui ne continnent pas des charges
|
|
potentielsBitmap[i][j] = potentielsBitmap[i][j] + omega * delta / nb
|
|
return abs(delta/potentielsBitmap[i][j]/nb)
|
|
else:
|
|
return 0.0
|
|
|
|
def majPotentielsSousBitmapRapide(x,y,k):
|
|
# mise à jour de la sous partie centrée sur x,y de taille 2k+1 x 2k+1
|
|
maxdelta = 0
|
|
# parcours de bas en haut et de gauche à droite
|
|
# il ne faut pas dépasser le bord: on s'arrête avant
|
|
Ix = max(0,x-k)
|
|
Sx = min(N-1,x+k)
|
|
Iy = max(0,y-k)
|
|
Sy = min(N-1,y+k)
|
|
# N-1 à 0
|
|
for j in range(Sy,Iy-1,-1):
|
|
for i in range(Ix,Sx+1):
|
|
delta = majPotentielRapide(i,j)
|
|
if delta > maxdelta:
|
|
maxdelta = delta
|
|
return maxdelta
|
|
|
|
def majPotentielsBitmapRapide():
|
|
maxdelta = 0.0
|
|
# parcours de bas en haut et de gauche à droite
|
|
# N-1 à 0
|
|
for j in range(N-1,-1,-1):
|
|
# 0 à N-1
|
|
for i in range(N):
|
|
delta = majPotentielRapide(i,j)
|
|
if delta > maxdelta:
|
|
maxdelta = delta
|
|
return maxdelta
|
|
|
|
def estValide(xy, bitmap):
|
|
# valide si qu'un seul voisin dessiné de xy dans bitmap
|
|
if bitmap[xy[0]+1][xy[1]] + bitmap[xy[0]-1][xy[1]] + bitmap[xy[0]][xy[1]+1] + bitmap[xy[0]][xy[1]-1] + bitmap[xy[0]+1][xy[1]+1] + bitmap[xy[0]-1][xy[1]+1] + bitmap[xy[0]+1][xy[1]-1] + bitmap[xy[0]-1][xy[1]-1] == 1:
|
|
return True
|
|
return False
|
|
|
|
def sontAcotes(pt1,pt2):
|
|
if (abs(pt1[0] - pt2[0]) <= 1) and (abs(pt1[1] - pt2[1]) <= 1):
|
|
return True
|
|
return False
|
|
|
|
def pasAcoteCroissance(pt, pixelsCroissance):
|
|
for c in range(len(pixelsCroissance)):
|
|
if sontAcotes(pt, pixelsCroissance[c]):
|
|
return False
|
|
return True
|
|
|
|
def eliminePixelsPres(pt, pixelsCroissance, potentielsCroissance):
|
|
for c in range(len(pixelsCroissance) - 1, -1, -1):
|
|
if sontAcotes(pt, pixelsCroissance[c]):
|
|
pixelsCroissance.pop(c)
|
|
potentielsCroissance.pop(c)
|
|
return None
|
|
|
|
def estDansCroissance(pt, pixelsCroissance):
|
|
for c in range(len(pixelsCroissance)):
|
|
if pixelsCroissance[c] == pt:
|
|
return True
|
|
return False
|
|
|
|
def croissanceRapide(nouv, pixelsBitmap, pixelsCroissance, potantielsCroissance):
|
|
# ajoute les pixels adjacents a nouv qui ne sont pas dans pixelsCroissance
|
|
candidats = [[nouv[0] + 1, nouv[1]], [nouv[0] - 1, nouv[1]], [nouv[0], nouv[1] + 1], [nouv[0], nouv[1] - 1], [nouv[0] + 1, nouv[1] + 1], [nouv[0] + 1, nouv[1] - 1], [nouv[0] - 1, nouv[1] + 1], [nouv[0] - 1, nouv[1] - 1], ]
|
|
for c in range(len(candidats)):
|
|
# si le candidat a qu'un seul voisin et n'est pas déjà un point dessiné et qu'il est pas en bordure supérieure
|
|
if estValide(candidats[c], pixelsBitmap) and (pixelsBitmap[candidats[c][0]][candidats[c][1]] == 0) and (candidats[c][1] > 0):
|
|
|
|
pixelsCroissance.append(candidats[c])
|
|
|
|
potentielsCroissance.append(potentielsBitmap[candidats[c][0]][candidats[c][1]])
|
|
|
|
def choix(pixelsCroissance, potentielsCroissance):
|
|
choixPotentiel = random.uniform(0, 1)
|
|
PotentielTotalEta = 0
|
|
pTotal = []
|
|
sommePTotal = 0
|
|
for i in range(len(potentielsCroissance)):
|
|
PotentielTotalEta += pow(potentielsCroissance[i], eta)
|
|
for i in range(len(pixelsCroissance)):
|
|
pi = pow(potentielsCroissance[i], eta) / PotentielTotalEta
|
|
sommePTotal += pi
|
|
pTotal.append(sommePTotal)
|
|
for i in range(len(pTotal)):
|
|
if pTotal[i] > choixPotentiel:
|
|
choixFinal = pixelsCroissance[i]
|
|
return([choixFinal, i])
|
|
|
|
def majPotentielsCroissance(pixelsCroissance, potentielsCroissance):
|
|
# mise a jour des potentiels de la liste complête
|
|
for c in range(len(pixelsCroissance)):
|
|
potentielsCroissance[c] = potentielsBitmap[pixelsCroissance[c][0]][pixelsCroissance[c][1]]
|
|
|
|
def main(pixelsBitmap, pixelsCroissance, potentielsCroissance):
|
|
run = True
|
|
init()
|
|
# graine: début de décharge en haut au milieu
|
|
graine = [int(N / 2), 1]
|
|
nouv = graine
|
|
pixelsBitmap[nouv[0]][nouv[1]] = 1
|
|
dessinBitmap[nouv[1]][nouv[0]] = 1
|
|
condInitBitmap[nouv[0]][nouv[1]] = -1
|
|
potentielsBitmap[nouv[0]][nouv[1]] = 0
|
|
nbPart = 1
|
|
while run == True:
|
|
# elimine les pixelsCroissance qui sont proche de nouv
|
|
eliminePixelsPres(nouv, pixelsCroissance, potentielsCroissance)
|
|
# mise à jour de la carte des potentiels
|
|
maxdelta = 1
|
|
# condition d'arrêt à MAXDELTA du max des mises à jour des potentiels relatifs
|
|
cf = 0
|
|
if MAJPETITE:
|
|
while maxdelta > MAXDELTA:
|
|
maxdelta = majPotentielsSousBitmapRapide(nouv[0], nouv[1], S)
|
|
cf += 1
|
|
maxdelta = 1
|
|
cs = 0
|
|
while maxdelta > MAXDELTA and cs<200:
|
|
maxdelta = majPotentielsBitmapRapide()
|
|
#print(cs, " : ", maxdelta)
|
|
cs += 1
|
|
# définition des nouveaux sites de croissance potentiels
|
|
croissanceRapide(nouv, pixelsBitmap, pixelsCroissance, potentielsCroissance)
|
|
# mise à jour des potentiels des candidats à la croissance
|
|
majPotentielsCroissance(pixelsCroissance, potentielsCroissance)
|
|
res = choix(pixelsCroissance, potentielsCroissance)
|
|
nouv = res[0]
|
|
# le point choisi est elimine des croissances possibles
|
|
pixelsCroissance.pop(res[1])
|
|
potentielsCroissance.pop(res[1])
|
|
# le point choisi est dessine
|
|
pixelsBitmap[nouv[0]][nouv[1]] = 1
|
|
dessinBitmap[nouv[1]][nouv[0]] = 1
|
|
# le point choisi devient une contrainte à potentiel nul
|
|
condInitBitmap[nouv[0]][nouv[1]] = -1
|
|
potentielsBitmap[nouv[0]][nouv[1]] = 0
|
|
nbPart += 1
|
|
if nouv[0] == 0 or nouv[0] == N-1 or nouv[1] == N-2 or nbPart > partMax :
|
|
run = False
|
|
|
|
print("N=",N,"eta=",eta,"nbpart=",nbPart,"MAXDELTA=",MAXDELTA)
|
|
|
|
main(pixelsBitmap, pixelsCroissance, potentielsCroissance)
|
|
|
|
fichier = "foudre-"+str(N)+"-"+str(eta)+"-"+str(MAXDELTA)+"-"+datetime.now().strftime("%Y%m%d%H%M%S")
|
|
np.save(fichier,np.array(dessinBitmap))
|
|
|
|
|
|
# Partie rajoutée
|
|
|
|
|
|
def Save_txt(y, N, fichier):
|
|
space='' # <--- Pour modifier les espaces
|
|
f=open(fichier + ".txt","a")
|
|
for i in range(N):
|
|
for j in range(N):
|
|
if y[i][j]:
|
|
print('#', end=space, file=f)
|
|
else:
|
|
print(' ', end=space, file=f)
|
|
print("", file=f)
|
|
f.close()
|
|
|
|
def Print_plt(Mat, N, fichier, afficher=False):
|
|
x = []
|
|
y = []
|
|
c="blue" # <--- Couleur des icones
|
|
mk="o" # <--- Motifs des icones ("o", "x", "1")
|
|
size=30 # <--- Taille des icones
|
|
for i in range(1, N-1):
|
|
for j in range(1, N-1):
|
|
if Mat[i][j]:
|
|
x.append(j)
|
|
y.append(N-i)
|
|
plt.scatter(x,y,color=c, label=fichier, s=size, marker=mk)
|
|
plt.title("Simulation de foudre")
|
|
plt.legend(loc='upper left')
|
|
plt.axis([0,N,0,N])
|
|
plt.savefig("..\\Image\\"+fichier+".png")
|
|
if afficher:
|
|
plt.show()
|
|
plt.close()
|
|
|
|
|
|
np.save(fichier,np.array(dessinBitmap))
|
|
Save_txt(np.array(dessinBitmap), N, fichier)
|
|
Print_plt(np.array(dessinBitmap), N, fichier, afficher=True) |