MAIN
unknown
python
3 years ago
27 kB
10
Indexable
import numpy as np
from mpl_toolkits.basemap import Basemap
from netCDF4 import Dataset as NetCDFFile
import matplotlib.pyplot as plt
import skfuzzy as fuzz
from skfuzzy import control as ctrl
import imageio
from fonctions_utiles import *
path = 'C:/Users/Alex/Downloads/KATRINA.nc'
path_ref = 'C:/Users/Alex/Downloads/Charlie.nc'
pression = 'C:/Users/Alex/Downloads/Katrina_pression.nc'
def input_fuzz(variable, input_to_fuzz):
fuzz_input = []
for i in variable.terms.keys():
fuzz_input.append(fuzz.interp_membership(variable.universe, variable.terms[i].mf, input_to_fuzz))
return fuzz_input
def IRR_2var(SF_rules, input_fuzz1, input_fuzz2):
IRR = np.empty([len(SF_rules), 2])
k = -1
for j in range(0, len(SF_rules)):
if (j % len(input_fuzz2)) == 0:
k += 1
IRR[j, 0] = input_fuzz1[k]
IRR[j, 1] = input_fuzz2[j % len(input_fuzz2)]
return IRR
def IRR_3var(SF_rules, input_fuzz1, input_fuzz2, input_fuzz3):
IRR = np.empty([len(SF_rules), 3])
k = -1
m = -1
for j in range(0, len(SF_rules)):
if (j % len(input_fuzz3)) == 0:
k += 1
if (k % len(input_fuzz2)) == 0:
m += 1
IRR[j, 0] = input_fuzz1[m]
IRR[j, 1] = input_fuzz2[j % len(input_fuzz2)]
IRR[j, 2] = input_fuzz3[j % len(input_fuzz3)]
return IRR
def SF1_compute(input_temperature, input_d_speed, input_time):
pas = 0.01
temperature = ctrl.Antecedent(np.arange(263, 323, pas), 'Temperature (K)')
d_speed = ctrl.Antecedent(np.arange(-100, 100, pas), 'Variation of wind speed (m/s)')
time = ctrl.Antecedent(np.arange(0, 15, pas), 'Time since TC formation (days)')
lifespan = ctrl.Consequent(np.arange(0, 15, pas), 'Lifespan')
temperature['Low'] = fuzz.trapmf(temperature.universe, [263, 263, 293, 303])
temperature['Ok'] = fuzz.trapmf(temperature.universe, [293, 303, 323, 323])
d_speed['--'] = fuzz.trapmf(d_speed.universe, [-100, -100, -60, -20])
d_speed['-'] = fuzz.trimf(d_speed.universe, [-60, -30, 0])
d_speed['St'] = fuzz.trimf(d_speed.universe, [-30, 0, 20])
d_speed['+'] = fuzz.trimf(d_speed.universe, [0, 30, 60])
d_speed['++'] = fuzz.trapmf(d_speed.universe, [20, 60, 100, 100])
time['Young'] = fuzz.zmf(time.universe, 3,6)
time['Middle'] = fuzz.gaussmf(time.universe,6,1)
time['Old'] = fuzz.smf(time.universe, 6,9)
lifespan['Dying+'] = fuzz.trapmf(lifespan.universe, [0, 0, 3, 5])
lifespan['Dying'] = fuzz.trimf(lifespan.universe, [3, 5, 7])
lifespan['St'] = fuzz.trimf(lifespan.universe, [5, 7, 10])
lifespan['Living'] = fuzz.trimf(lifespan.universe, [7, 10, 13])
lifespan['Living+'] = fuzz.trapmf(lifespan.universe, [10, 13, 15, 15])
lifespan.view()
temperature.view()
d_speed.view()
time.view()
SF1_rules = [ctrl.Rule(temperature['Low'] & d_speed['--'] & time['Young'], lifespan['Dying+']),
ctrl.Rule(temperature['Low'] & d_speed['--'] & time['Middle'], lifespan['Dying+']),
ctrl.Rule(temperature['Low'] & d_speed['--'] & time['Old'], lifespan['Dying+']),
ctrl.Rule(temperature['Low'] & d_speed['-'] & time['Young'], lifespan['Dying']),
ctrl.Rule(temperature['Low'] & d_speed['-'] & time['Middle'], lifespan['Dying+']),
ctrl.Rule(temperature['Low'] & d_speed['-'] & time['Old'], lifespan['Dying+']),
ctrl.Rule(temperature['Low'] & d_speed['St'] & time['Young'], lifespan['Dying']),
ctrl.Rule(temperature['Low'] & d_speed['St'] & time['Middle'], lifespan['Dying']),
ctrl.Rule(temperature['Low'] & d_speed['St'] & time['Old'], lifespan['Dying']),
ctrl.Rule(temperature['Low'] & d_speed['+'] & time['Young'], lifespan['St']),
ctrl.Rule(temperature['Low'] & d_speed['+'] & time['Middle'], lifespan['St']),
ctrl.Rule(temperature['Low'] & d_speed['+'] & time['Old'], lifespan['St']),
ctrl.Rule(temperature['Low'] & d_speed['++'] & time['Young'], lifespan['Living']),
ctrl.Rule(temperature['Low'] & d_speed['++'] & time['Middle'], lifespan['Living']),
ctrl.Rule(temperature['Low'] & d_speed['++'] & time['Old'], lifespan['Living']),
ctrl.Rule(temperature['Ok'] & d_speed['--'] & time['Young'], lifespan['Dying']),
ctrl.Rule(temperature['Ok'] & d_speed['--'] & time['Middle'], lifespan['Dying']),
ctrl.Rule(temperature['Ok'] & d_speed['--'] & time['Old'], lifespan['Dying']),
ctrl.Rule(temperature['Ok'] & d_speed['-'] & time['Young'], lifespan['Dying']),
ctrl.Rule(temperature['Ok'] & d_speed['-'] & time['Middle'], lifespan['Dying']),
ctrl.Rule(temperature['Ok'] & d_speed['-'] & time['Old'], lifespan['Dying']),
ctrl.Rule(temperature['Ok'] & d_speed['St'] & time['Young'], lifespan['Living']),
ctrl.Rule(temperature['Ok'] & d_speed['St'] & time['Middle'], lifespan['St']),
ctrl.Rule(temperature['Ok'] & d_speed['St'] & time['Old'], lifespan['Dying']),
ctrl.Rule(temperature['Ok'] & d_speed['+'] & time['Young'], lifespan['Living']),
ctrl.Rule(temperature['Ok'] & d_speed['+'] & time['Middle'], lifespan['Living']),
ctrl.Rule(temperature['Ok'] & d_speed['+'] & time['Old'], lifespan['Living']),
ctrl.Rule(temperature['Ok'] & d_speed['++'] & time['Young'], lifespan['Living+']),
ctrl.Rule(temperature['Ok'] & d_speed['++'] & time['Middle'], lifespan['Living+']),
ctrl.Rule(temperature['Ok'] & d_speed['++'] & time['Old'], lifespan['Living+']),
]
SF1_ctrl = ctrl.ControlSystem(SF1_rules)
SF1 = ctrl.ControlSystemSimulation(SF1_ctrl)
input_temperature_fuzz = input_fuzz(temperature, input_temperature)
input_d_speed_fuzz = input_fuzz(d_speed, input_d_speed)
input_time_fuzz = input_fuzz(time, input_time)
print(input_temperature_fuzz)
print(input_d_speed_fuzz)
print(input_time_fuzz)
IRR = IRR_3var(SF1_rules, input_temperature_fuzz, input_d_speed_fuzz, input_time_fuzz)
declenchement = IRR.min(axis=1)
print(IRR)
print(declenchement)
csq_SF1 = {} # variable de type dictionnaire
for i in range(0, len(SF1_rules)): # on initialise à 0 pour chaque règle
csq_SF1[str(SF1_rules[i].consequent)] = 0
for i in range(0, len(SF1_rules)):
csq_i = str(SF1_rules[i].consequent)
csq_SF1[csq_i] = max(csq_SF1[csq_i], declenchement[i]) # Comme dans le TP6
print("Conséquences SF1 :", csq_SF1)
# return SF1
# JUSTE CHANGER REGLES SF1
def SF2_compute(input_humidity, input_TC_size):
pas = 0.01
humidity = ctrl.Antecedent(np.arange(0, 100, pas), 'humidity') # Humidity (%)'
TC_size = ctrl.Antecedent(np.arange(0, 350, pas), 'TC_size') # TC size (km)
TC_size_variation = ctrl.Consequent(np.arange(0, 60, pas), 'TC_var') # Variation of TC size for next day (km)
humidity['--'] = fuzz.trapmf(humidity.universe, [0, 0, 20, 40]) # 20%
humidity['-'] = fuzz.trimf(humidity.universe, [20, 40, 60]) # 40%
humidity['+'] = fuzz.trimf(humidity.universe, [40, 60, 80]) # 60%
humidity['++'] = fuzz.trapmf(humidity.universe, [60, 80, 100, 100]) # 80%
TC_size['Little+'] = fuzz.trapmf(TC_size.universe, [0, 0, 75, 120])
TC_size['Little'] = fuzz.trimf(TC_size.universe, [75, 150, 200])
# TC_size['Normal'] = fuzz.trimf(TC_size.universe, [120, 150, 200])
TC_size['Huge'] = fuzz.trimf(TC_size.universe, [150, 200, 250])
TC_size['Huge+'] = fuzz.trapmf(TC_size.universe, [200, 250, 350, 350])
# 10 13 15 20 25 50
TC_size_variation['Very Low'] = fuzz.trapmf(TC_size_variation.universe, [0, 0, 10, 13]) # 10
TC_size_variation['Low'] = fuzz.trimf(TC_size_variation.universe, [10, 13, 15]) # 13
TC_size_variation['Quite Low'] = fuzz.trimf(TC_size_variation.universe, [13, 15, 20]) # 15
TC_size_variation['Quite High'] = fuzz.trimf(TC_size_variation.universe, [15, 20, 25]) # 20
TC_size_variation['High'] = fuzz.trimf(TC_size_variation.universe, [20, 25, 50]) # 25
TC_size_variation['Very High'] = fuzz.trapmf(TC_size_variation.universe, [25, 50, 50, 50]) # 50
humidity.view()
TC_size.view()
TC_size_variation.view()
SF2_rules = [ctrl.Rule(humidity['--'] & TC_size['Little+'], TC_size_variation['Very Low']),
ctrl.Rule(humidity['--'] & TC_size['Little'], TC_size_variation['Quite Low']),
ctrl.Rule(humidity['--'] & TC_size['Huge'], TC_size_variation['Quite Low']),
ctrl.Rule(humidity['--'] & TC_size['Huge+'], TC_size_variation['Quite Low']),
ctrl.Rule(humidity['-'] & TC_size['Little+'], TC_size_variation['Low']),
ctrl.Rule(humidity['-'] & TC_size['Little'], TC_size_variation['Quite Low']),
ctrl.Rule(humidity['-'] & TC_size['Huge'], TC_size_variation['Quite Low']),
ctrl.Rule(humidity['-'] & TC_size['Huge+'], TC_size_variation['Quite Low']),
ctrl.Rule(humidity['+'] & TC_size['Little+'], TC_size_variation['Quite High']),
ctrl.Rule(humidity['+'] & TC_size['Little'], TC_size_variation['Quite High']),
ctrl.Rule(humidity['+'] & TC_size['Huge'], TC_size_variation['Quite High']),
ctrl.Rule(humidity['+'] & TC_size['Huge+'], TC_size_variation['Quite High']),
ctrl.Rule(humidity['++'] & TC_size['Little+'], TC_size_variation['High']),
ctrl.Rule(humidity['++'] & TC_size['Little'], TC_size_variation['Very High']),
ctrl.Rule(humidity['++'] & TC_size['Huge'], TC_size_variation['Very High']),
ctrl.Rule(humidity['++'] & TC_size['Huge+'], TC_size_variation['Very Low'])]
SF2_ctrl = ctrl.ControlSystem(SF2_rules)
SF2 = ctrl.ControlSystemSimulation(SF2_ctrl)
input_TC_size_fuzz = input_fuzz(TC_size, input_TC_size)
input_humidity_fuzz = input_fuzz(humidity, input_humidity)
IRR = IRR_2var(SF2_rules, input_humidity_fuzz, input_TC_size_fuzz)
print(IRR)
declenchement = IRR.min(axis=1)
print(declenchement)
csq_SF2 = {} # variable de type dictionnaire
for i in range(0, len(SF2_rules)): # on initialise à 0 pour chaque règle
csq_SF2[str(SF2_rules[i].consequent)] = 0
for i in range(0, len(SF2_rules)):
csq_i = str(SF2_rules[i].consequent)
csq_SF2[csq_i] = max(csq_SF2[csq_i], declenchement[i]) # Comme dans le TP6
print("Conséquences SF2 :", csq_SF2)
# SF2.input['humidity'] = input_humidity
# SF2.input['TC_size'] = input_TC_size
# print(SF2.output['TC_var'])
# TC_size_variation.view(sim=SF2)
def SF3_compute(input_TC_velocity,input_surface_pressure,input_dsurface_pressure):
velocity = ctrl.Antecedent(np.arange(0, 100, 0.01), 'Velocity') # Velocity (m/s)
surface_pressure = ctrl.Antecedent(np.arange(92000, 103000, 10), 'Surface_Pressure') # Surface pressure (Pa)
dsurface_pressure = ctrl.Antecedent(np.arange(-2000, 2000, 10), 'Surface_Pressure_Variation') # Surface pressure variation (Pa/h) Surface variation per hour or per day?
velocity_variation = ctrl.Consequent(np.arange(-25, 25, 0.1), 'Velocity_Variation') # Variation of the velocity next hour (m/s). Next hour / next day ?
velocity['Little'] = fuzz.trapmf(velocity.universe, [0,0,20,40])
velocity['Intermediate'] = fuzz.trapmf(velocity.universe, [20,30,50,60])
velocity['High'] = fuzz.trapmf(velocity.universe, [40,60,100,100])
surface_pressure['Little'] = fuzz.trapmf(surface_pressure.universe, [92000,92000, 99000, 101000])
surface_pressure['High'] = fuzz.trapmf(surface_pressure.universe, [99000, 101000, 103000,103000])
dsurface_pressure['--'] = fuzz.trapmf(dsurface_pressure.universe, [-2000, -2000, -1500,-500])
dsurface_pressure['-'] = fuzz.trimf(dsurface_pressure.universe, [-1500, -500, 0])
dsurface_pressure['0'] = fuzz.trimf(dsurface_pressure.universe, [-500, 0, 500])
dsurface_pressure['+'] = fuzz.trimf(dsurface_pressure.universe, [0, 500, 1500])
dsurface_pressure['++'] = fuzz.trapmf(dsurface_pressure.universe, [500,1500, 2000, 2000])
velocity_variation['--'] = fuzz.trimf(velocity_variation.universe, [-25, -25, -10])
velocity_variation['-'] = fuzz.trapmf(velocity_variation.universe, [-25, -10, -5, 0])
velocity_variation['St'] = fuzz.trimf(velocity_variation.universe, [-5, 0, 5])
velocity_variation['+'] = fuzz.trapmf(velocity_variation.universe, [0,5, 10, 25])
velocity_variation['++'] = fuzz.trimf(velocity_variation.universe, [10, 25, 25])
velocity.view()
surface_pressure.view()
dsurface_pressure.view()
velocity_variation.view()
SF3_rules = [ctrl.Rule(surface_pressure['Little'] & velocity['Little'] & dsurface_pressure['--'], velocity_variation['St']),
ctrl.Rule(surface_pressure['Little'] & velocity['Intermediate'] & dsurface_pressure['-'], velocity_variation['+']),
ctrl.Rule(surface_pressure['Little'] & velocity['High'] & dsurface_pressure['0'], velocity_variation['St']),
ctrl.Rule(surface_pressure['Little'] & velocity['Little'] & dsurface_pressure['+'], velocity_variation['St']),
ctrl.Rule(surface_pressure['Little'] & velocity['Intermediate'] & dsurface_pressure['++'], velocity_variation['-']),
ctrl.Rule(surface_pressure['Little'] & velocity['High'] & dsurface_pressure['--'], velocity_variation['++']),
ctrl.Rule(surface_pressure['Little'] & velocity['Little'] & dsurface_pressure['-'], velocity_variation['St']),
ctrl.Rule(surface_pressure['Little'] & velocity['Intermediate'] & dsurface_pressure['0'], velocity_variation['St']),
ctrl.Rule(surface_pressure['Little'] & velocity['High'] & dsurface_pressure['+'], velocity_variation['-']),
ctrl.Rule(surface_pressure['Little'] & velocity['Little'] & dsurface_pressure['++'], velocity_variation['St']),
ctrl.Rule(surface_pressure['Little'] & velocity['Intermediate'] & dsurface_pressure['--'], velocity_variation['+']),
ctrl.Rule(surface_pressure['Little'] & velocity['High'] & dsurface_pressure['-'], velocity_variation['++']),
ctrl.Rule(surface_pressure['Little'] & velocity['Little'] & dsurface_pressure['0'], velocity_variation['St']),
ctrl.Rule(surface_pressure['Little'] & velocity['Intermediate'] & dsurface_pressure['+'], velocity_variation['-']),
ctrl.Rule(surface_pressure['Little'] & velocity['High'] & dsurface_pressure['++'], velocity_variation['--']),
ctrl.Rule(surface_pressure['High'] & velocity['Little'] & dsurface_pressure['--'], velocity_variation['St']),
ctrl.Rule(surface_pressure['High'] & velocity['Intermediate'] & dsurface_pressure['-'], velocity_variation['St']),
ctrl.Rule(surface_pressure['High'] & velocity['High'] & dsurface_pressure['0'], velocity_variation['St']),
ctrl.Rule(surface_pressure['High'] & velocity['Little'] & dsurface_pressure['+'], velocity_variation['St']),
ctrl.Rule(surface_pressure['High'] & velocity['Intermediate'] & dsurface_pressure['++'], velocity_variation['-']),
ctrl.Rule(surface_pressure['High'] & velocity['High'] & dsurface_pressure['--'], velocity_variation['+']),
ctrl.Rule(surface_pressure['High'] & velocity['Little'] & dsurface_pressure['-'], velocity_variation['St']),
ctrl.Rule(surface_pressure['High'] & velocity['Intermediate'] & dsurface_pressure['0'], velocity_variation['St']),
ctrl.Rule(surface_pressure['High'] & velocity['High'] & dsurface_pressure['+'], velocity_variation['-']),
ctrl.Rule(surface_pressure['High'] & velocity['Little'] & dsurface_pressure['++'], velocity_variation['St']),
ctrl.Rule(surface_pressure['High'] & velocity['Intermediate'] & dsurface_pressure['--'], velocity_variation['+']),
ctrl.Rule(surface_pressure['High'] & velocity['High'] & dsurface_pressure['-'], velocity_variation['+']),
ctrl.Rule(surface_pressure['High'] & velocity['Little'] & dsurface_pressure['0'], velocity_variation['St']),
ctrl.Rule(surface_pressure['High'] & velocity['Intermediate'] & dsurface_pressure['+'], velocity_variation['-']),
ctrl.Rule(surface_pressure['High'] & velocity['High'] & dsurface_pressure['++'], velocity_variation['-'])]
SF3_ctrl = ctrl.ControlSystem(SF3_rules)
SF3 = ctrl.ControlSystemSimulation(SF3_ctrl)
input_velocity_fuzz = input_fuzz(velocity, input_TC_velocity)
input_surface_pressure_fuzz = input_fuzz(surface_pressure, input_surface_pressure)
input_dsurface_pressure_fuzz = input_fuzz(dsurface_pressure, input_dsurface_pressure)
print('Velocity fuzz')
print(input_velocity_fuzz)
print('Pressure fuzz')
print(input_surface_pressure_fuzz)
print('dPressure fuzz')
print(input_dsurface_pressure_fuzz)
IRR = IRR_3var(SF3_rules,input_surface_pressure_fuzz, input_velocity_fuzz, input_dsurface_pressure_fuzz)
print(IRR)
declenchement = IRR.min(axis=1)
print(declenchement)
csq_SF3 = {} # variable de type dictionnaire
for i in range(0, len(SF3_rules)): # on initialise à 0 pour chaque règle
csq_SF3[str(SF3_rules[i].consequent)] = 0
for i in range(0, len(SF3_rules)):
csq_i = str(SF3_rules[i].consequent)
csq_SF3[csq_i] = max(csq_SF3[csq_i], declenchement[i]) # Comme dans le TP6
print("Conséquences SF3 :", csq_SF3)
def SF4_compute(input_actu,input_ant):
tendance_actuelle = ctrl.Antecedent(np.arange(-90, 90, 0.1), 'Angle calcul')
tendance_antecedents = ctrl.Antecedent(np.arange(-90, 90, 0.1), 'Angle évalué par la forme')
angle = ctrl.Consequent(np.arange(-90,90,0.1),'Prédiction courbature')
tendance_actuelle['Courbé Gauche Fort'] = fuzz.trapmf(tendance_actuelle.universe, [-90, -90, -60, -45])
tendance_actuelle['Courbé Gauche'] = fuzz.trapmf(tendance_actuelle.universe, [-60, -45, -10, 0])
tendance_actuelle['Linéaire'] = fuzz.trapmf(tendance_actuelle.universe, [-10, 0, 0, 10])
tendance_actuelle['Courbé Droite'] = fuzz.trapmf(tendance_actuelle.universe, [0, 10, 45, 60])
tendance_actuelle['Courbé Droite Fort'] = fuzz.trapmf(tendance_actuelle.universe, [45, 60, 90, 90])
tendance_antecedents['Courbé Gauche Fort'] = fuzz.trapmf(tendance_antecedents.universe, [-90, -90, -60, -40])
tendance_antecedents['Courbé Gauche'] = fuzz.trapmf(tendance_antecedents.universe, [-60, -45, -20, 0])
tendance_antecedents['Linéaire'] = fuzz.trapmf(tendance_antecedents.universe, [-20, -5, 5, 20])
tendance_antecedents['Courbé Droite'] = fuzz.trapmf(tendance_antecedents.universe, [0, 20, 45, 60])
tendance_antecedents['Courbé Droite Fort'] = fuzz.trapmf(tendance_antecedents.universe, [40, 60, 90, 90])
angle['Courbé Gauche Fort'] = fuzz.trapmf(angle.universe, [-90, -90, -60, -40])
angle['Courbé Gauche'] = fuzz.trapmf(angle.universe, [-60, -45, -20, 0])
angle['Linéaire'] = fuzz.trapmf(angle.universe, [-20, -5, 5, 20])
angle['Courbé Droite'] = fuzz.trapmf(angle.universe, [0, 20, 45, 60])
angle['Courbé Droite Fort'] = fuzz.trapmf(angle.universe, [40, 60, 90, 90])
tendance_actuelle.view()
tendance_antecedents.view()
angle.view()
SF4_rules = [ctrl.Rule(tendance_actuelle['Courbé Gauche Fort'] & tendance_antecedents['Courbé Gauche Fort'], angle['Courbé Gauche Fort']),
ctrl.Rule(tendance_actuelle['Courbé Gauche Fort'] & tendance_antecedents['Courbé Gauche'], angle['Courbé Gauche Fort']),
ctrl.Rule(tendance_actuelle['Courbé Gauche Fort'] & tendance_antecedents['Linéaire'], angle['Courbé Gauche']),
ctrl.Rule(tendance_actuelle['Courbé Gauche Fort'] & tendance_antecedents['Courbé Droite'], angle['Courbé Gauche']),
ctrl.Rule(tendance_actuelle['Courbé Gauche Fort'] & tendance_antecedents['Courbé Droite Fort'], angle['Linéaire']),
ctrl.Rule(tendance_actuelle['Courbé Gauche'] & tendance_antecedents['Courbé Gauche Fort'], angle['Courbé Gauche Fort']),
ctrl.Rule(tendance_actuelle['Courbé Gauche'] & tendance_antecedents['Courbé Gauche'], angle['Courbé Gauche']),
ctrl.Rule(tendance_actuelle['Courbé Gauche'] & tendance_antecedents['Linéaire'], angle['Courbé Gauche']),
ctrl.Rule(tendance_actuelle['Courbé Gauche'] & tendance_antecedents['Courbé Droite'], angle['Linéaire']),
ctrl.Rule(tendance_actuelle['Courbé Gauche'] & tendance_antecedents['Courbé Droite Fort'], angle['Courbé Droite']),
ctrl.Rule(tendance_actuelle['Linéaire'] & tendance_antecedents['Courbé Gauche Fort'], angle['Courbé Gauche Fort']),
ctrl.Rule(tendance_actuelle['Linéaire'] & tendance_antecedents['Courbé Gauche'], angle['Courbé Gauche']),
ctrl.Rule(tendance_actuelle['Linéaire'] & tendance_antecedents['Linéaire'], angle['Linéaire']),
ctrl.Rule(tendance_actuelle['Linéaire'] & tendance_antecedents['Courbé Droite'], angle['Courbé Droite']),
ctrl.Rule(tendance_actuelle['Linéaire'] & tendance_antecedents['Courbé Droite Fort'], angle['Courbé Droite Fort']),
ctrl.Rule(tendance_actuelle['Courbé Droite'] & tendance_antecedents['Courbé Gauche Fort'], angle['Courbé Gauche']),
ctrl.Rule(tendance_actuelle['Courbé Droite'] & tendance_antecedents['Courbé Gauche'], angle['Linéaire']),
ctrl.Rule(tendance_actuelle['Courbé Droite'] & tendance_antecedents['Linéaire'], angle['Courbé Droite']),
ctrl.Rule(tendance_actuelle['Courbé Droite'] & tendance_antecedents['Courbé Droite'], angle['Courbé Droite']),
ctrl.Rule(tendance_actuelle['Courbé Droite'] & tendance_antecedents['Courbé Droite Fort'], angle['Courbé Droite Fort']),
ctrl.Rule(tendance_actuelle['Courbé Droite Fort'] & tendance_antecedents['Courbé Gauche Fort'], angle['Linéaire']),
ctrl.Rule(tendance_actuelle['Courbé Droite Fort'] & tendance_antecedents['Courbé Gauche'], angle['Courbé Droite']),
ctrl.Rule(tendance_actuelle['Courbé Droite Fort'] & tendance_antecedents['Linéaire'], angle['Courbé Droite']),
ctrl.Rule(tendance_actuelle['Courbé Droite Fort'] & tendance_antecedents['Courbé Droite'], angle['Courbé Droite Fort']),
ctrl.Rule(tendance_actuelle['Courbé Droite Fort'] & tendance_antecedents['Courbé Droite Fort'], angle['Courbé Droite Fort'])]
SF4_ctrl = ctrl.ControlSystem(SF4_rules)
SF4 = ctrl.ControlSystemSimulation(SF4_ctrl)
input_tendance_actuelle_fuzz = input_fuzz(tendance_actuelle, input_actu)
input_tendance_antecedents_fuzz = input_fuzz(tendance_antecedents, input_ant)
print('Tendance calculée fuzz')
print(input_tendance_actuelle_fuzz)
print('Tendance évaluée fuzz')
print(input_tendance_antecedents_fuzz)
IRR = IRR_2var(SF4_rules,input_tendance_actuelle_fuzz, input_tendance_antecedents_fuzz)
print(IRR)
declenchement = IRR.min(axis=1)
print(declenchement)
csq_SF4 = {} # variable de type dictionnaire
for i in range(0, len(SF4_rules)): # on initialise à 0 pour chaque règle
csq_SF4[str(SF4_rules[i].consequent)] = 0
for i in range(0, len(SF4_rules)):
csq_i = str(SF4_rules[i].consequent)
csq_SF4[csq_i] = max(csq_SF4[csq_i], declenchement[i]) # Comme dans le TP6
# print("Conséquences SF4 :", csq_SF4)
return(output_fuzz(csq_SF4, angle))
def SF4_conclusion(jour,heure,path):
#Prediction pour 12 heures
date_exact = (jour-1)*24 + heure
lat_pos,lon_pos = position_TC(jour,heure,path)
x0 = deg_to_met(lat_pos)
y0 = deg_to_met(lon_pos)
nc = NetCDFFile(path)
u = np.array(nc.variables['u'][:])
lon = np.array(nc.variables['longitude'][:])
lat = np.array(nc.variables['latitude'][:])
prediction = np.zeros(np.shape(u))
sf4_conc = SF4_compute(entree_SF4(29, 12, path), -15)
for lignes in range(np.shape(sf4_conc)[0]):
a = angle(jour, heure, path) + sf4_conc[lignes][0]
for r in np.arange(0,400000,20000):
xo,yo = polar_to_cart(r,a)
x = met_to_deg(xo + x0)
y = met_to_deg(yo + y0)
idx_lon, idx_lat = xy_to_indx_lonlat(y, x, lon, lat)
prediction[date_exact,idx_lat,idx_lon] = sf4_conc[lignes][1]
# plot_array(prediction[date_exact, :, :], lon, lat)
# # plt.plot(posy,posx,ms=5, marker='o', markeredgecolor='red')
# plt.show()
def plotnc():
# Extraction des tableaux de données:
lat = nc.variables['latitude'][:]
lon = nc.variables['longitude'][:]
nc.close()
# Création de la map
map = Basemap(width=5000000, height=3500000,
resolution='l', projection='cyl',
llcrnrlon=lon.min(), llcrnrlat=lat.min(), urcrnrlon=lon.max(), urcrnrlat=lat.max(),
lat_0=lat.mean(),
lon_0=lon.mean())
lons, lats = np.meshgrid(lon, lat)
xi, yi = map(lons, lats)
map.drawmapboundary(fill_color='aqua')
map.fillcontinents(color='coral', lake_color='aqua')
map.drawcoastlines()
parallels = np.arange(lat.min(), lat.max(), 5.) # make latitude lines every 5 degrees from xx to xx
meridians = np.arange(lon.min(), lat.min(), 5.) # make longitude lines every 5 degrees from xx to xx
map.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=5)
map.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=5)
# Création des données en couleur
cs = map.pcolor(xi, yi, np.squeeze(prediction[date_exact, :, :]), vmin=prediction.min(), vmax=prediction.max())
cbar = map.colorbar(cs, location='bottom', pad=0.2, )
plotnc()
plt.show()
SF3_compute(50,99000,-1000)Editor is loading...