Python codage difficile

[Inception]

Bonjour,

Je travail grâce à python sur un mini-projet que je souhaiterais terminer.

L'objectif est de simuler un trafic aérien pendant une durée donnée et suivant une flotte de tracteurs d'avions donné. Pourquoi ? Pour savoir combien de tracteurs il est nécessaire de mettre en place pour tracter tous les avions.

Ci-joint, vous allez trouvez mon petit programme : il est fonctionnel mais incomplet. Voici les points que je souhaiterais ajouter absolument pour plus de réalisme, mais dont j'ai été incapable de mettre en œuvre correctement :

# ->Inclure deux zones 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 sur l'aéroport
# -> Ne pas faire décoller un avion en même temps qu'un autre qui 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 (en raison de l'allumage ou de l’extinction des moteurs). Ces deux temps ne sont valables que pour des avions tractés.

Pourriez vous m'aider au codage de ce qui précède à partir du document fournit ?

Merci par avance pour votre aide

Bonne soirée

Bien cordialement
-----

[JPL]

C'est mieux comme cela avec la balise Code, non ?

# -*- 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))<temps_separation_atterrissage: # l'aéroport a un trafic limité : l'écart minimum entre chaque avion dépend du type de l'appareil
        separation_max = temps_separation_atterrissage
    else:
        separation_max = int((temps_simulation_initiale-temps_effectif)/(nb_atterrissage_prevu-nb_atterrissage))
    sequencement_arrivee = random.randint(temps_separation_atterrissage,separation_max) # on séquence de manière aléatoire les arrivées des avions, ne connaissant pas le planning prévisionnel
    duree_stationnement = random.randint(temps_stationnement_min,temps_stationnement_max) # le temps de stationnement d'un avion est aléatoire
    
    
    
    if nb_tracteur > 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<len(temps_attente_avec_tractage): 
        if temps_attente_avec_tractage[i] <= temps_effectif: 
            nb_tracteur +=1
            nb_decollage += 1
            capacite_parking += 1
            del temps_attente_avec_tractage[i]
        i += 1
        
    n=0
    while n<len(temps_attente_sans_tractage):
        if temps_attente_sans_tractage[n] <= temps_effectif: 
            nb_decollage += 1
            capacite_parking += 1
            del temps_attente_sans_tractage[n]
            if choix_avion == 0: # on rajoute la consommation des avions à l'allé
                consommation += consommation_petit_avion*distance_parking_piste/100000
            elif choix_avion == 1:
                consommation += consommation_moyen_avion*distance_parking_piste/100000
            else:
                consommation += consommation_gros_avion*distance_parking_piste/100000
        n += 1

    temps_effectif += sequencement_arrivee
    
avion_en_attente = nb_atterrissage_prevu - nb_atterrissage

    
print("Nb atterrissage {}".format(nb_atterrissage))
print("Nb décollage {}".format(nb_decollage))
print("Rapport tracté/total {}/{}".format(nb_avion_tracte, nb_atterrissage))
print("Consommation {} L".format(consommation))
print("En attente {}".format(avion_en_attente))

[fred1599]

Ce que tu poses se sont les problèmes, mais si tu n'as pas les réponses au moins algorithmique de ce que tu souhaites faire, tu n'auras personne qui te donnera un code tout cuit. Présentes une solution à tes problèmes et on t'aidera à traduire cela en python.

[Inception]

Bonjour,

Voici ci-joint l'algo sur lequel j'ai essayé d'appliquer les solutions au problème posé plus haut, mais qui ne marche pas correctement...

J'attends avec impatience votre aide, car je ne vois absolument pas comment faire quelque chose qui tienne la route ^^

Bien cordialement

#############################################################################
## 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 = 1000 # 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
capacite_aire_stockage_arrivee = 2 # capacité d'avions mis en attente après un atterrissage
capacite_aire_stockage_retour = 2 # lors du décollage
temps_stationnement_min = 5 # temps stationnement minimum pour un avion
temps_stationnement_max = 10 # 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
vitesse_avion_roulage = 25 # en km/h
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))<temps_separation_atterrissage: # l'aéroport a un trafic limité : l'écart minimum entre chaque avion dépend du type de l'appareil
        separation_max = temps_separation_atterrissage
    else:
        separation_max = int((temps_simulation_initiale-temps_effectif)/(nb_atterrissage_prevu-nb_atterrissage))
    sequencement_arrivee = random.randint(temps_separation_atterrissage,separation_max) # on séquence de manière aléatoire les arrivées des avions, ne connaissant pas le planning prévisionnel
    duree_stationnement = random.randint(temps_stationnement_min,temps_stationnement_max) # le temps de stationnement d'un avion est aléatoire
    
    
    if nb_tracteur > 0 and capacite_parking>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
    elif capacite_parking>0: # il n'y a pas de tracteur disponible
        temps_attente_sans_tractage.append(temps_effectif+duree_stationnement) # l'avion non tracté va se stationner
        nb_atterrissage +=1 # on comptabilise l'arrivée de l'avion
        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
    elif capacite_parking <= 0 and capacite_aire_stockage_arrivee > 0: # s'il n'y a plus de place, on stock l'avion sur l'aire de stockage
        capacite_aire_stockage_arrivee -=1 # on enlève 1 place sur l'aire de stockage
# else : plus de place sur la zone de stockage
         
    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
        
        
    temps_effectif += sequencement_arrivee # on incrémente la boucle de manière à faire avancer la simulation en fonction des atterrissages
    
    
    i = 1
    while i<len(temps_attente_sans_tractage): # Boucle qui vérifie si un avion doit partir : pour ceux qui ne sont pas tractés !!
        if temps_attente_sans_tractage[i] <= temps_effectif: 
            
        
            if capacite_aire_stockage_retour > 0:
                capacite_parking += 1 # l'avion part, donc une place ce libère sur le parking
                capacite_aire_stockage_retour -= 1
                
            elif capacite_aire_stockage_retour <= 0:
                capacite_aire_stockage_retour += 1
                nb_decollage += 1
                del temps_attente_sans_tractage[i] # de manière à ne pas recomptabiliser le décollage lors d'une nouvelle boucle de la simulation
                if choix_avion == 0: # on cajoute la consommation des avions à leur retour
                    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 sequencement_arrivee+temps_effectif-temps_separation_atterrissage<temps_attente_sans_tractage[i]<sequencement_arrivee+temps_effectif+temps_separation_atterrissage and capacite_aire_stockage_retour > 0: # si l'avion peut décoller (il n'y a pas d'atterrissage et l'intervalle de temps est respecté) <<<======!!!!!!!
                capacite_aire_stockage_retour += 1
                nb_decollage += 1
                del temps_attente_sans_tractage[i] # de manière à ne pas recomptabiliser le décollage lors d'une nouvelle boucle de la simulation
                if choix_avion == 0: # on cajoute la consommation des avions à leur retour
                    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
        
        i += 1
        
    print("{}".format(temps_attente_sans_tractage))
    p = 0
    while p<len(temps_attente_avec_tractage): # Boucle qui vérifie si un avion doit partir : pour ceux qui sont tractés !!
        if temps_attente_avec_tractage[p] <= temps_effectif:
            if capacite_aire_stockage_retour > 0:
                capacite_parking += 1 # l'avion part, donc une place ce libère sur le parking
                capacite_aire_stockage_retour -= 1
                
            if sequencement_arrivee+temps_effectif-temps_separation_atterrissage<temps_attente_avec_tractage[p]<sequencement_arrivee+temps_effectif+temps_separation_atterrissage and capacite_aire_stockage_retour>0 : # une fois que l'avion a décollé, le tracteur est à nouveau dispo
                nb_tracteur += 1
                capacite_aire_stockage_retour += 1
                del temps_attente_avec_tractage[p]
                
            elif capacite_aire_stockage_retour <= 0:
                capacite_aire_stockage_retour += 1
                nb_decollage += 1
                nb_tracteur += 1
                del temps_attente_avec_tractage[p] # de manière à ne pas recomptabiliser le décollage lors d'une nouvelle boucle de la simulation
             
                
        p += 1
        
        
    avion_precedent = choix_avion
    

    
    
    
    
avion_en_attente = nb_atterrissage_prevu - nb_atterrissage

    
print("Nb atterrissage {}".format(nb_atterrissage))
print("Nb décollage {}".format(nb_decollage))
print("Rapport tracté/total {}/{}".format(nb_avion_tracte, nb_atterrissage))
print("Consommation {} L".format(consommation))
print("En attente {}".format(avion_en_attente))

[A voir en vidéo sur Futura]

[fred1599]

Ok, on s'est pas trop compris en fait, j'y connais rien en aéronef, mais tu peux décrire le problème et ta façon de le résoudre sans passer par python.

On pourrait décrire les objets présents,

• tracteur
• avion
• ...

Comment sont-ils représentés par des types python

• str
• int
• tuple
• list
• ...

leurs actions

• modifier un temps
• modifier une capacité
• modifier une vitesse
• ...

Or cela, tu décris plusieurs étapes, ce qui pour moi en python devrait être représenté d'une façon explicite à l'aide de fonctions. Ces fonctions représentant les différentes actions sur tes objets.

Voilà en espérant avoir été plus clair sur la présentation du problème et les démarches permettant sa résolution.

[Inception]

Bonjour,

Mon code python du message #2 ou #4 est clair normalement : il y a tout un tas d’annotations aidant à la compréhension.

Je ne vois pas comment expliquer plus simplement le code, étant donné que pour moi il est censé marché, mais qu'au final, je n'ai pas le bon résultat. Autant directement s'attaquer à python ^^.

Bien cordialement

[Inception]

Quasiment toutes les lignes sont expliqués, ma démarche se comprend au fur et à mesure de la lecture des annotations. Les variables utilisées sont claires...

[laentheorist]

C'est vrai qu'on peut dire beaucoup de mal de python mais la plupart ne l'utilisent pas pour ce qu'il est : un langage orienté objet.
Cherche de ce côté la.
Décrit les objets et tout marchera probablement mieux.
Bonne chance

[Inception]

C' est bon, je pense avoir trouvé.

Cordialement