# -*- coding: utf-8 -*- ############################################################################# # Programme Python # # auteur : J.B, Bruges, 2015 # # # # Simulation analytique du traitement cyclique des aéronefs sur un aéroport # ############################################################################# ## # Suppositions : # - Le positionnement des tracteurs et leur prise en charge est supposé parfaite, sans perte de temps # Cadre de la simulation : # - les avions considérés sont exclusivement des avions de ligne (représentent plus de 80 % du trafic réel) # - la précision de temps significative et suffisante sera la minute # - la vitesse de roulage de tous les avions sera fixe, qu'ils soient remorqués ou non. # - Les avions à l'atterrissage sont prioritaires # MODIFICATIONS POSANT PROBLEME : # -> Inclure une zone de stockage en entrée et en sortie ayant un nombre limitée de place, entre le chemin piste/parking et parking/piste # -> Inclure une capacité limite des places de stationnement des avions # -> Ne pas faire décoller un avion en même temps qu'il atterrit et respecter les temps de sécurités propre à chaque avion que ce soit à l'atterrissage ou au décollage # -> Mettre en place les 5 min d'attente avant le décollage pour un avion tracté, et les 3 min pour un avion qui va être tracté après son atterrissage # Améliorations futures...: # - Perfectionnner l'utilisation de la méthode aléatoire, en modifiant les probabilités, de manière à être plus significatif et précis # - Ajouter plusieurs pistes d'atterrissage # - Prendre en compte les aléas climatiques (vent, neigne impliquant un dégivrage de l'avion, pluie intense) # - Prendre en compte les aléas techniques ## ############################################################################# ## Importation de fonctions externes : from __future__ import unicode_literals import random import matplotlib.pyplot as plt ############################################################################ ## Programme principal # variables d'entrées temps_simulation_initiale = 2880 # Temps de simulation en minutes nb_tracteur = 5 # Flotte de tracteurs dont dispose l'aéroport nb_atterrissage_prevu = 400 # nombre d'atterrissage prévus durant l'intervalle considéré consommation_petit_avion = 100 # consommation des petits avion en moyenne l/100 (carburant) consommation_moyen_avion = 200 # consommation des avions de catégorie intermédiaire l/100 (carburant) consommation_gros_avion = 400 # consommation des avions lourds l/100 (carburant) capacite_parking = 5 # capacité de stationnement sur l'aéroport temps_stationnement_min = 15 # temps stationnement minimum pour un avion temps_stationnement_max = 45 # temps de stationement maximum possible temps_avion_meme_categorie = 2 # temps séparant 2 avions de même taille temps_avion_gros_moyen = 3 # séparation entre un gros suivi d'un moyen temps_avion_gros_petit = 4 # séparation entre un gros suivi d'un petit temps_avion_moyen_petit = 3 # séparation entre moyen suivi d'un petit temps_avion_plus_gros_minorant = 2 # séparation lorsqu'un plus gros est derrière un plus petit distance_piste_parking = 800 # en mètre distance_parking_piste = 1000 # en mètre temps_eteinte_moteur = 3 # temps d'attente avant un tractage temps_allumage_moteur = 5 # temps d'attente après un tractage # variables/listes entrant dans le programme temps_effectif = 0 choix_avion = 0 temps_separation_atterrissage = 0 avion_precedent = 0 nb_atterrissage = 0 nb_decollage = 0 temps_attente_avec_tractage = [] temps_attente_sans_tractage = [] temps_stationnement = [] consommation = 0 nb_avion_tracte = 0 # boucle de simulation principale while temps_effectif < temps_simulation_initiale: choix_avion = random.randint(0,2) # le type d'avion est choisit de manière aléatoire if (choix_avion == 0 and avion_precedent == 0) or (choix_avion == 1 and avion_precedent == 1) or (choix_avion == 2 and avion_precedent == 2): # si l'avion arrivant est de même taille que le précédent temps_separation_atterrissage = temps_avion_meme_categorie elif choix_avion == 1 and avion_precedent == 2: # si l'avion moyen arrive après un gros temps_separation_atterrissage = temps_avion_gros_moyen elif choix_avion == 0 and avion_precedent == 2: # si l'avion petit arrive après un gros temps_separation_atterrissage = temps_avion_gros_petit elif choix_avion == 0 and avion_precedent == 1: # si l'avion petit arrive après un moyen temps_separation_atterrissage = temps_avion_moyen_petit else: # dans les autres cas, le plus petit est devant, et n'influe pas sur le gros temps_separation_atterrissage = temps_avion_plus_gros_minorant if ((temps_simulation_initiale-temps_effectif)/(nb_atterrissage_prevu-nb_atterrissage)) 0: # on vérifie si un tracteur est disponible nb_tracteur -= 1 nb_avion_tracte +=1 nb_atterrissage +=1 # on comptabilise l'arrivée de l'avion capacite_parking -= 1 # on enlève 1 place de parking dispo temps_attente_avec_tractage.append(temps_eteinte_moteur+temps_effectif+duree_stationnement) # on enregistre le temps de l'avion jusqu'à la fin de son stationnement else: # il n'y a pas de tracteur disponible nb_atterrissage +=1 # on comptabilise l'arrivée de l'avion temps_attente_sans_tractage.append(temps_effectif+duree_stationnement) # l'avion non tracté va se stationner capacite_parking -= 1 # on enlève 1 place de parking dispo if choix_avion == 0: # on rajoute la consommation des avions à l'allé consommation += consommation_petit_avion*distance_piste_parking/100000 elif choix_avion == 1: consommation += consommation_moyen_avion*distance_piste_parking/100000 else: consommation += consommation_gros_avion*distance_piste_parking/100000 if nb_atterrissage == nb_atterrissage_prevu : # une sécurité si la simulation se termine plus tôt que prévue dûe à l'aléatoire du séquencement temps_effectif = temps_simulation_initiale i=0 while i