Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- # -*- coding: utf-8 -*-
- ######################## Importation des bibliothèques ########################
- import sqlite3 as sq # Bibliothèque qui permet de faire des requètes en SQL
- import math # Pour avoir pi
- from sys import exit # On importe la fonction qui va nous permettre de quitter le programme
- from json import dumps # Pour convertir un dictionnaire en chaine de caractères
- from datetime import datetime as dt
- ########################## Définition des fonctions ###########################
- # Si on a trouvé aucun materiaux, on ne peut rien traiter. On sort donc du programme
- def testQuantite(nbMateriauxTrouve):
- if nbMateriauxTrouve == 0:
- print("\nAucune matière ne correspond à votre recherche")
- toLog("Aucune matière/coussinet ne correspond à la recherche")
- quitter()
- # Fonction qui sert principalement au deboggage. Felt it was cute, might delete later.
- def affMatierePossible(nb, critere):
- log.write("[" + str(dt.now()) + "] " + str(nb) + " matériaux correspondent au critère de " + str(critere) + " (")
- for i in range(0, nb):
- log.write(str(Nom[i]) + ", ")
- log.write(")\n")
- # Permet de supprimer une matière qui ne convient pas
- def delMatiere(position):
- toLog("Aucun coussinet en " + str(Nom[position]) + " ne convient")
- del l[position]
- del Id_Mat[position]
- del Nom[position]
- del P_Adm[position]
- del PV_Adm[position]
- toLog("Matière supprimée")
- # Fonction qui gère le choix du coussinet si l'utilisateur décide de ne pas ajouter de critères
- def recherche(longMinCouss):
- # Ok ok, alors....
- # On définie d'abords les variables qui vont nous permettre de stocker ce
- # qu'on extrait de la BDD, c'est à dire les dimension du coussinet, son ID,
- # et sa matière. On extrait aussi le coefficient de prix de la matière pour
- # pouvoir calculer le prix ensuite
- Id_couss = []
- Diam_Int = []
- Diam_Ext = []
- Diam_Col = []
- Epais_Col = []
- Longueur = []
- Mat = []
- Coeff_Prix = []
- # Dans le for en dessous, on va traiter les coussinets matière par matière
- for i in Id_Mat:
- # On fait une requête SQL pr extraire la plus petite valeur de l tel que
- # l > lmin pr les coussinets dans la matière concerné.
- if longMinCouss == 0:
- toLog("Récupération de lmin réel pour " + str(Nom[Id_Mat.index(i)]))
- cursor.execute("SELECT MIN(Longueur) FROM Coussinets WHERE Mat = " + str(i) + " AND Diam_Int = " + str(diametre) + " AND Longueur >= " + str(l[Id_Mat.index(i)]))
- # On sort la valeur minimale et on la met dans une variable
- for j in cursor:
- if not None in j:
- longMinCouss = j["MIN(Longueur)"]
- toLog("Lmin réel récupéré : " + str(longMinCouss))
- # Du coup ici on extrait les coussinets qui correspondent à tous les
- # critères déterminés plus tot, tjrs dans la matières concernées
- toLog("Récupération des coussinets compatibles")
- cursor.execute("SELECT Coussinets.*, Matériaux.Coeff_Prix FROM Coussinets INNER JOIN Matériaux ON Coussinets.Mat = Matériaux.Id_Mat WHERE Longueur = " + str(longMinCouss) + " AND Mat = " + str(i) + " AND Diam_Int = " + str(diametre))
- # On stocke les info dans des listes
- for j in cursor:
- if not None in j:
- Id_couss.append(j["Id_couss"])
- Diam_Int.append(j["Diam_Int"])
- Diam_Ext.append(j["Diam_Ext"])
- Diam_Col.append(j["Diam_Col"])
- Epais_Col.append(j["Epais_Col"])
- Longueur.append(j["Longueur"])
- Mat.append(j["Mat"])
- Coeff_Prix.append(j["Coeff_Prix"])
- toLog("Coussinets compatibles en " + str(Nom[Id_Mat.index(i)]) + " récupérés")
- # Et hop, là on est sortis de la boucle. Ca veut dire qu'on a extrait les
- # informations de tout les coussinets qui conviennent, dans tt les matières
- # adaptés. Maintenant on va calculer leur prix et prendre le moins chère.
- # Le calcul est celui donné dans les document. J'ai séparé le calcul du
- # volume pr plus de clartée.
- toLog("Calcul des prix des coussinets")
- prix = []
- volume = []
- for i in range(0, len(Id_couss)):
- volume.append((math.pi/2)*((Longueur[i]-Epais_Col[i])*(Diam_Ext[i]-Diam_Int[i])+Epais_Col[i]*(Diam_Col[i]-Diam_Int[i])))
- prix.append(volume[i]*Coeff_Prix[i]*10**-3)
- toLog("Prix récupérés")
- # Ici on détermine la position du coussinet le moins chère. Si il y en a
- # plusieurs, python prends le premier qu'il trouve. J'aurais pu faire
- # un générateurde nombre aléatoire, mais non. Et je demande pas à
- # l'utilisateur parce qu'il veut laisser faire l'ordinateur
- pos = prix.index(min(prix))
- # Du coup on stocke les info demandé dans un dictionnaire, parce que
- # pourquoi pas (et ça peut faire des points en plus aussi)
- resultat = {"Diametre interieur":Diam_Int[pos], "Diametre exterieur":Diam_Ext[pos], "Diametre du col":Diam_Col[pos], "Epaisseur du col":Epais_Col[pos], "Longueur":Longueur[pos], "Materiau":Nom[Id_Mat.index(Mat[pos])], "Prix":round(prix[pos], 2)}
- # On affiche les résultats de la recherche à l'utilisateur
- print("\n", resultat)
- # On stocke aussi les résultats dans un fichier, parce que j'ai pas de
- # mémoire
- fichier = open('resultat.txt', 'w')
- string = dumps(resultat) # Celle là elle permet de convertir le contenu du dictionnaire en chaine de caractère (parce qu'on peut pas mettre un dictionnaire dans un fichier txt comme ça)
- fichier.write(string)
- fichier.close()
- quitter()
- #fonction qui permet de filtrer les coussinets sur plus de critères
- def filtrageManuel():
- filtre = 0
- choix = ""
- val = 0
- while True:
- if filtre != 0 and filtre != 3:
- while choix != "oui" and choix != "non" and choix !="exit":
- print("\nVoulez-vous affiner d'avantage la recherche ?")
- choix = str(input("(oui/non) : "))
- choix = choix.casefold()
- if choix == "oui" or filtre == 0:
- print("\nCritères disponibles pour filtration supplémentaire :")
- if filtre == 0:
- print("\n 1) Matière\n 2) Longueur")
- choix = input("1,2 : ")
- elif filtre == 1:
- print("\n 2) Longueur")
- choix = str(input("Appuyez sur entrer pour continuer, entrez exit pour quitter : "))
- elif filtre == 2:
- print("\n 1) Matière")
- choix = str(input("Appuyez sur entrer pour continuer, entrez exit pour quitter : "))
- if choix == "1" or (choix == "" and filtre == 2):
- print("\nMatières disponible pour filtration :")
- for i in Id_Mat:
- print(" " + str(i) + ") " + str(Nom[Id_Mat.index(i)]))
- while True:
- try:
- matiere = int(input("Entrez le numéro de la matière que vous voulez garder : "))
- except ValueError:
- print("Veuillez entrer un nombre")
- else:
- if matiere in Id_Mat:
- break
- print("Entrez un chiffre de la liste")
- matiere = Id_Mat.index(matiere)
- for i in range(0, len(Id_Mat)):
- if i < matiere:
- delMatiere(0)
- elif i > matiere:
- delMatiere(1)
- filtre += 1
- elif choix == "1" and (filtre == 1 or filtre == 3):
- print("Vous avez déja défini la matière")
- elif choix == "2" or (choix == "" and filtre == 1):
- filtreLongueur = []
- for i in Id_Mat:
- cursor.execute("SELECT Longueur FROM Coussinets WHERE Mat = " + str(i) + " AND Diam_Int = " + str(diametre) + " AND Longueur >= " + str(l[Id_Mat.index(i)]))
- for j in cursor:
- if not None in j:
- if not j["longueur"] in filtreLongueur:
- filtreLongueur.append(j["Longueur"])
- print("\nVoici les longueurs disponibles à la filtration :")
- for i in range(0, len(filtreLongueur)):
- print(filtreLongueur[i], "\bmm")
- valType = False
- while not valType:
- try:
- val = int(input("Laquelle voulez-vous choisir ? (entrez la valeur) : "))
- except ValueError:
- print("Veuillez entrer une valeur numérique")
- else:
- valType = True
- if not val in filtreLongueur:
- print("Choisisser une valeur dans la liste de celles données")
- valType = False
- filtre =+2
- elif choix == "1 ou 2":
- print("Bruh")
- elif choix=="exit":
- quitter()
- else:
- print("Veuillez entrer 1 ou 2")
- elif choix == "non":
- toLog("Début récupération coussinet suite à filtration supplémentaire")
- break
- else:
- quitter()
- recherche(val)
- quitter()
- def toLog(msg):
- log.write("[" + str(dt.now()) + "] " + str(msg) + "\n")
- def quitter():
- input("Appuyer sur entrer pour quitter")
- toLog("Fermeture des fichiers et extinction du programme")
- log.close()
- base.close()
- exit(0)
- ###############################################################################
- ###############################################################################
- ################################## Début ######################################
- ###############################################################################
- # On crée un fichier qui permettra de stocker les logs du programme
- log = open('fichiersProjet\log.txt', 'w', encoding = "UTF-8")
- toLog("Début du programme")
- base = sq.connect("fichiersProjet\Coussinets.db") # On se connecte à la base de donnée que l'on va utiliser
- base.row_factory = sq.Row # On met le row factory en sq.row, ce qui nous permet de parcourir les valeurs avec le nom des colonnes (dans le code python)
- # On crée un curseur pour parcourir les bases de données
- cursor = base.cursor()
- # On demande les différentes caractéristiques nécessaire au choix du coussinet.
- # Le try, except permet de gérer l'entrée d'un nombre (En vrai on aurait pu faire ça autrement, mais comme je connais pas les standards j'ai fait comme ça, c'est plus cool :D )
- toLog("Requête critères")
- varType = False # Le variable qui nous permettra de déterminer si le type est bojn ou pas
- while not varType:
- try:
- diametre = float(input("Diamètre de l'arbre (mm) : ")) # On demande le diamètre de l'arbre à l'utilisateur
- except ValueError:
- print("Veuillez entrer un nombre.") # On affiche ce message si l'entrée reçu ne peut pas être convertie en flottant
- toLog("Tentative de passage de valeur non numérique pour diametre")
- else:
- if diametre > 100: # On check si la valeur du diamètre
- print("Le diamètre entré est trop grand")
- toLog("Diamètre entré > valeur max")
- varType = False
- elif diametre < 0:
- print("Diamètre retenu :", diametre, "\bmm")
- varType = True
- toLog("diametre récupéré")
- else:
- varType = True
- toLog("diametre récupéré")
- while varType:
- try:
- frequence = float(input("Fréquence de rotation (tr/min) : ")) # Même chose qu'au dessus
- except ValueError:
- print("Entrez un nombre")
- toLog("Tentative de passage de valeur non numérique pour frequence")
- else:
- varType = False
- toLog("frequence récupéré")
- while not varType:
- try:
- charge = float(input("Charge radiale (N) : ")) # Same
- except ValueError:
- print("Entrez un nombre")
- toLog("Tentative de passage de valeur non numérique pour charge")
- else:
- varType = True
- toLog("charge récupéré")
- toLog("Critères récupérés : diamètre = " + str(diametre) + ", vitesse = " + str(frequence) + ", charge = " + str(charge))
- ##################### Vitesse circonférentielle ###############################
- # On calcule la vitesse radiale / circonférentielle
- toLog("Calcul vitesse radiale")
- vitRad = (math.pi*diametre*frequence)/(60*pow(10,3))
- toLog("Vitesse radiale : " + str(vitRad) + " m/s")
- # On récupère les info des matériaux qui correspondent au critère de vitesse
- toLog("Recherche de materiaux correspondant au critère de vitesse")
- cursor.execute("SELECT Id_Mat, Nom, P_Adm, PV_Adm FROM Matériaux WHERE V_Adm > " + str(vitRad))
- # Définition des listes qui permettront de stocker le contenu extrait de la base de donnée
- Id_Mat = []
- Nom = []
- P_Adm = []
- PV_Adm = []
- # Stockage des données récupérées dans les listes
- for i in cursor:
- if not None in i:
- Id_Mat.append(i["Id_Mat"])
- Nom.append(i["Nom"])
- P_Adm.append(i["P_Adm"])
- PV_Adm.append(i["PV_Adm"])
- # On regarde cb de matière on a trouvé. Si c'est 0, on arrête le programme.
- testQuantite(len(Id_Mat))
- toLog("Matériaux récupérés")
- # Si on peut executer ce qui suit, on a trouve au moins une matière compatible. On les affiche
- affMatierePossible(len(Id_Mat), "vitesse circonférencielle")
- ################## Calcul et comparaison longueur minimale ####################
- l = [] # Liste qui servira a stocker ttes les longueur minimale pr chaque matière
- l1 = [] # Liste qui stockeront les différents résultats des calcul de lmin
- l2 = []
- rejet = 0 # Variable qui servira à compter le nombre de matières rejetés
- toLog("Calcul lmin")
- for i in range(0, len(Id_Mat)):
- l1.append(charge/(P_Adm[i-rejet]*diametre)) # Calcul longueur minimale via pression max admissible
- l2.append((math.pi*charge*frequence)/(60*PV_Adm[i-rejet]*pow(10,3))) # Calcul lmin via produit PV adm
- l.append(max(l1[i-rejet], l2[i-rejet])) #On prend la plus grande valeur des deux qu'on vient de trouver
- toLog("lmin récupéré pour " + str(Nom[i-rejet]) + " : " + str(l[i-rejet]))
- # On rejete tous les materiaux où l min est superieur à la longueur maximale
- # possible d'un coussinet
- if (l[i-rejet] > 100): # 100 = longueur maximale d'un coussinet
- delMatiere(i-rejet)
- rejet += 1
- testQuantite(len(Id_Mat)-rejet)
- testQuantite(len(Id_Mat))
- affMatierePossible(len(Id_Mat), "longueur")
- #### Recherche de coussinet en matière compatible avec diamètre compatible ####
- Mat = [] #Liste qui nous permettra de stocker les matières des coussinets
- matDiff = 0 # Variable qui nous permettra de compter le nombre de matières différentes
- # Ttes les petites commande habituelles pr extraire les différentes matières
- # avec le diamètre et la longueur qui correspondent aux critères
- for i in Id_Mat:
- cursor.execute("SELECT Mat FROM Coussinets WHERE Diam_Int = " + str(diametre) + " AND Longueur >= " + str(l[Id_Mat.index(i)]) + " AND Mat = " + str(i))
- for j in cursor :
- if not None in j :
- Mat.append(j["Mat"])
- matDiff += 1
- # Si on trouve plus de deux coussinets assez long, dans les bonnes
- # matières (très probable), on compare les matières entre elles pr
- # savoir si elles sont différentes
- if len(Mat) > 1:
- if Mat[len(Mat)-1] == Mat[len(Mat)-2]:
- matDiff -=1
- # Si y'a aucune matière qui convient, c'est con
- testQuantite(matDiff)
- toLog(str(matDiff) + " matériaux compatibles avec le critères de diamètre. Comparaison avec les précédents critères")
- # Si les matières des filtres précédants sont pas dans celle qui satisfont le
- # critère de diamètre, on l'enlève.
- for i in Id_Mat:
- if not i in Mat:
- delMatiere(Id_Mat.index(i))
- # On regarde si il nous reste des matières compatibles
- testQuantite(len(Id_Mat))
- affMatierePossible(len(Id_Mat), "diamètre")
- ## Finalement, on affiche toutes les matières qui correspondent aux critères ##
- # C'est pas bien compliqué, normalement y'a pas besoin d'explications. Si y'en
- # a besoin, envoyez-moi un fax (je répondrais par fax aussi)
- print("\nVoici les matériaux qui correspondent aux critères donnés :")
- for i in range(0, len(Id_Mat)):
- print(i, "\b)", Nom[i], "\b, longueur minimale :", l[i], "\bmm")
- print("")
- # On demande à l'utilisateur s'il veut affiner sa recheche, ou laisser
- # l'ordinateur choisir pour lui
- # Simple input dans un while qui tourne tant qu'on a pas une des réponses que
- # l'on veut. Le casefold sert à tt passer en minuscule. (Je sais pas si
- # Exemple == exemple, donc j'ai fait ça). Le exit est uniquement pr moi, ça
- # m'évite de faire tourner tt le programme juste pr vérifier un truc au début
- choix = ""
- while choix != "oui" and choix != "non" and choix !="exit":
- print("Voulez-vous affiner la recherche (Si non, le choix se fera sur le coussinet le moins chère) ?")
- choix = str(input("(oui/non) : "))
- choix = choix.casefold()
- toLog("Choix récupéré : " + str(choix))
- # On fait ce qu'on doit faire en fonction de la décision de l'utilisateur
- if choix == "non":
- toLog("Lancement sélection automatique")
- recherche(0)
- elif choix == "oui":
- toLog("Lancement sélection manuelle")
- filtrageManuel()
- else:
- quitter()
- quitter()
- # Todo :
- # Faire un plus jolie truc pr la recherche parce que c'est nul (mais au moins ça fonctionne)
- # Acquisition critères dans une fonction
- # Passer sur une interface graphique
Add Comment
Please, Sign In to add comment