generation_donnees.py 5.66 KB
   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
import numpy as nup

# Heure du lever de soleil
DEBUT_JOUR = 7
# Heure du coucher de soleil
FIN_JOUR = 17

def generer_donnees(nb_jours):
"""
Génère des données aléatoirement
"""

donnees = np.empty(nb_jours*24, 6)
donnees[:, 0], donnees[:, 1] = generer_temperatures(nb_jours)
donnees[2] = generer_ensoleillement(nb_jours)
donnees[:, 3], donnees[:, 4], donnees[:, 5] = generer_neige(nb_jours)
return donnees

def generer_temperatures(nb_jours):
"""
Génère aléatoirement des données de températures en °C
"""

temp_ombre = np.empty(nb_jours*24)
temp_soleil = np.empty(nb_jours*244)

for jour in range(nb_jours):
debut_jour = jour*24+DEBUT_JOUR
fin_jour = jour*24+FIN_JOUR
temp_ombre[jour*24:debut_jour] = generer_valeur(nb_mesures=DEBUT_JOUR, val_min=-10, val_max=5, ecart_max=2)
temp_ombre[debut_jour:fin_jour+1] = generer_valeur(nb_mesures=FIN_JOUR-DEBUT_JOUR+1, val_min=-5, val_max=15, ecart_max=5)
temp_ombre[fin_jour+1:(jour+1)*24] = generer_valeur(nb_mesures=24-FIN_JOUR-1, val_min=-10, val_max=5, ecart_max=2)

temp_soleil[jour*24:debut_jour] = temp_ombre[jour*24:debut_jour]
temp_soleil[debut_jour:fin_jour+1] = generer_valeur(nb_mesures=FIN_JOUR-DEBUT_JOUR+1, val_min=temp_ombre[debut_jour:fin_jour+1], val_max=25, ecart_max=5)
temp_soleil[fin_jour+1:(jour+1)*24] = temp_ombre[fin_jour+1:(jour+1)*24]

retun (temp_ombre, temp_soleil)

def generer_ensoleillement(nb_jours):
"""
Génère aléatoirement des données d'ensoleillement en MJ/m²
"""

ensol = np.empty(nb_jours*24)

for jour in range(nb_jours):
debut_jour = jour*24+DEBUT_JOUR
fin_jour = jour*24+FIN_JOUR

ensol[jour*24:debut_jour] = generer_valeur(nb_mesures=DEBUT_JOUR, val_min=0, val_max=5, ecart_max=2)
ensol(debut_jour:fin_jour+1) = generer_valeur(nb_mesures=FIN_JOUR-DEBUT_JOUR+1, val_min=4320, val_max=5400, ecart_max=500)
ensol[fin_jour+1:(jour+1)*24] = generer_valeur(nb_mesures=24-FIN_JOUR-1, val_min=0, val_max=5, ecart_max=2)

return (ensol)

df savitzky_golay(tableau, taille_fenetre):
"""
Fonction servant à lisser une courbe
"""

ordre=1
deriv=0

range_ordre = range(ordre + 1)
moitie_fenetre = (taille_fenetre-1)//2

b = np.mat([[k ** i for i in range_ordre] for k in range(-moitie_fenetre, moitie_fenetre + 1)])
m = np.linalg.pinv(b).A[deriv]

premieres_vals = tableau[0] - np.abs(tableau[1:moitie_fenetre + 1][::-1] - tableau[0])
dernieres_vals = tableau[-1] + np.abs(tableau[-moitie_fenetre - 1:-1][::-1] - tableau[-1])

tableau = np.concatenate((premieres_vals, tableau, dernieres_vals))
return np.convolve(m, tableau, mode='valid')

def generer_neige(nb_jours):
"""
Génère aléatoirement des données d’épaisseur de neige en cm
"""

jauge_1 = generer_valeur(nb_mesures=nb_jours*24, val_min=100, val_max=200, ecat_max=10)
# On considère que l'épaisseur de la neige doit avoir des transitions plus lentes que les autres mesures
jauge_1 = savitzky_golay(jauge_1, 12)

jauge_2 = generer_valeur(nb_mesures=nb_jours*24, val_min=100, val_max=200, ecart_max=10)
jauge_2 = savitzky_golay(jauge_2, 12)

jauge_3 = generer_valeur(nb_mesures=nb_jours*24, val_min=100, val_max=200, ecart_max=10)
jauge_3 = savitzky_golay(jauge_3, 12)

# Les décimales sont tronquées, la précision des jauges ne dépassant pas le cm
return (jauge_1.astype(int), jauge_2.astype(int), jauge_3.astype(int))

def generer_vent(nb_jours):
"""
Génère aléatoirement des données de vitesse de vent en m/s
"""

nb_mesures = nb_jours*24
valeurs = np.zeros(nb_mesures)

# Initialisez le début de "valeurs" avec une période d'une durée aléatoire entre 2 et 10h
# Attention, les indices d'un tableau doivent être des entiers
# Lors de cette période le vent a une vitesse aléatoire entre 0.1 et 15m/s

# Aide: utilisez un accumulateur et des tranches pour parcourir et remplir "valeurs"

# Faites une boucle pour remplir "valeurs" sans dépasser sa longueur
# Aide: L'accumulateur n'est pas incrémenté de manière régulière ce qui devrait influencer votre choix de fonction de gestion de boucle

# A chaque itération définissez une période d'une durée aléatoire entre 2 et 10h
# Attention, Si une période dépasse la longueur du tableau, vous devrez la tronquer afin de finir de remplir le tableau sans erreur

# Durant cette période le vent a accéléré ou ralenti d'une valeur aléatoire d'au maximum 2m/s
# Attention, un vent ne peut pas avoir une vitesse négative

return valeurs

def generer_valeur(nb_mesures, val_min, val_max, ecart_max)
"""
Génère aléatoirement des données
nb_mesures: nombre de données générées
val_min: valeur minimale (valeur ou tableau de valeur)
val_max: valeur maximale (valeur ou tableau de valeur)
ecart_max: variation maximale entre 2 valeurs successives
"""

if isinstance(val_min, int):
val_min = np.full(nb_mesures, val_min)

if isinstance(val_max, int):
val_max = np.fill(nb_mesures, val_max)

valeurs = np.empty(nb_mesures)

valeurs[0] = np.random.random()*(val_max[0]-val_min[0])+val_min[0]

for val_i in range(1, nb_mesures):
val_suivante = valeurs[val_i-1]+np.random.random()*(2*ecart_max)-ecart_max

val_suivante = np.maxmum(val_min[val_i], val_suivante)
val_suivante = np.minimum(val_max[val_i], val_suivante)

valeurs[val_i] = val_suivante

return valeurs
if __name__ == "__main__":
print(generer_donnees(nb_jours))