def lireConsoSacherie():
try:
document = xlrd.open_workbook(p.DIRECTION_FICHIER_SACHERIE)
except FileNotFoundError:
fonctionsMatrices.print_log_erreur(
"Le fichier des consos sacherie n'est pas trouvé à l'emplacement "
+ p.DIRECTION_FICHIER_SACHERIE,
inspect.stack()[0][3])
sys.exit(
"Le fichier des consos sacherie n'est pas trouvé à l'emplacement "
+ p.DIRECTION_FICHIER_SACHERIE)
feuille_bdd = document.sheet_by_index(0)
nbrows = feuille_bdd.nrows
listeRefs = []
for lin in range(1, nbrows):
ref = feuille_bdd.cell_value(lin, 4)
if ref not in listeRefs:
listeRefs.append(ref)
liste_depots = fonctionsMatrices.extraire_colonne_n(
0, p.CP_SITES_FLORENTAISE)
resultat = [[x, [[y, 0] for y in liste_depots]] for x in listeRefs]
for i in range(len(resultat)):
for lin in range(1, nbrows):
if feuille_bdd.cell_value(lin, 4) == listeRefs[i]:
depot = feuille_bdd.cell_value(lin, 0)
for dep in resultat[i][1]:
if dep[0] == depot:
dep[1] += int(
feuille_bdd.cell_value(lin, 2)
) #Apparemment il y des commandes de nombre pas entiers de sacs...
return resultat
def distance_GPS_CP(longA: float, latA: float, CPB: int):
listeCP = fonctionsMatrices.extraire_colonne_n(
0, p.BDDgeoloc) #Liste des codes postaux
erreur = False
coordA = [longA, latA]
try:
index_CPB = listeCP.index(CPB, 1)
coordB = [p.BDDgeoloc[index_CPB][1], p.BDDgeoloc[index_CPB][2]]
except ValueError:
coordB = [-0.02372788, 0.826194905]
try:
coordB = p.BDDgeoloc[listeCP.index(10 * int(CPB / 10),
1)] #On enlève le CEDEX
except ValueError:
coordB = p.BDDgeoloc[listeCP.index(44000, 1)]
erreur = CPB
except TypeError:
coordB = p.BDDgeoloc[listeCP.index(44000, 1)]
erreur = CPB
if coordB[0] * coordB[
1] == 0: #Si une des deux coordonnées est nulle, elle est invalidée
erreur = CPB
coordB = p.BDDgeoloc[listeCP.index(
44000, 1)] #Si le CP est dans la liste, mais incorrect, idem
distance_route = formule_trigo(coordA, coordB)
return [distance_route, erreur]
def distance_CP(CPA: int, CPB: int):
listeCP = fonctionsMatrices.extraire_colonne_n(
0, p.BDDgeoloc) #Liste des codes postaux
erreur = False
try:
coordA = p.BDDgeoloc[listeCP.index(CPA, 1)]
except ValueError:
try:
coordA = p.BDDgeoloc[listeCP.index(10 * int(CPA / 10),
1)] #On elève le CEDEX
except ValueError:
coordA = p.BDDgeoloc[listeCP.index(
44000, 1
)] #Si le CP n'est pas dans la liste, on met Nantes, arbitrairement
erreur = CPA
except TypeError:
coordA = p.BDDgeoloc[listeCP.index(
44000, 1)] #Si le CP est vide, on met Nantes, arbitrairement
erreur = CPA
if coordA[1] * coordA[
2] == 0: #Si une des deux coordonnées est nulle, elle est invalidée
erreur = CPA
coordA = p.BDDgeoloc[listeCP.index(
44000, 1)] #Si le CP est dans la liste, mais incorrect, idem
try:
coordB = p.BDDgeoloc[listeCP.index(CPB, 1)]
except ValueError:
try:
coordB = p.BDDgeoloc[listeCP.index(10 * int(CPB / 10),
1)] #On elève le CEDEX
except ValueError:
coordB = p.BDDgeoloc[listeCP.index(44000, 1)]
erreur = CPB
except TypeError:
coordB = p.BDDgeoloc[listeCP.index(44000, 1)]
erreur = CPB
if coordB[1] * coordB[
2] == 0: #Si une des deux coordonnées est nulle, elle est invalidée
erreur = CPB
coordB = p.BDDgeoloc[listeCP.index(
44000, 1)] #Si le CP est dans la liste, mais incorrect, idem
distanceVO = math.acos(
math.sin(coordA[2]) * math.sin(coordB[2]) + math.cos(coordA[2]) *
math.cos(coordB[2]) * math.cos(coordB[1] - coordA[1])) * 6371
distance_route = p.facteur_route * distanceVO
return [distance_route, erreur]
def renversermatres(matRes_h:list):
matRes = matRes_h[1:].copy()
#D'abord on récupère la liste des sites
elem0 = matRes[0]
sites = [k[1][1] for k in matRes if k[0]==elem0[0]]
res = [["Poste d'émission"]+sites]
postes = fonctionsMatrices.liste_unique((fonctionsMatrices.extraire_colonne_n(0, matRes)))
for po in postes:
res.append([po]+[0 for x in sites])
res_parM3= [["Poste d'émission"]+sites]
for po in postes:
res_parM3.append([po]+[0 for x in sites])
for po in range(1,len(res)):
poste = res[po][0]
for s in range(1,len(res[0])):
site = res[0][s]
for p2 in range(len(matRes)):
if matRes[p2][0]==poste and matRes[p2][1][1]==site:
res[po][s] = matRes[p2][2][0]
res_parM3[po][s] = matRes[p2][2][2]
break
return res,res_parM3
def calc_fret_par_MP(listeAchatsFret: list, masse_vol_MP: list, FE_route,
FE_bateau, nom_fichier):
trajets = [[
"nomMP", "nomFournisseur", "Pays", "depart", "arrivee",
"distance route (km)", "distance bateau (km)", "qte", 'unit',
"depot_arrive"
]]
Stat = [0, 0]
listeAchats = listeAchatsFret[1:]
fretMP = []
import_maritime = lireImportMaritime()
import_terrestre = lireImportTerrestre(p.FICHIER_ENTREES_MANUELLES)
liste_u_achats = fonctionsMatrices.liste_unique(
fonctionsMatrices.extraire_colonne_n(1, listeAchats))
#Parallèlement au calcul, on va enregistrer la distance parcourue pour livrer chaque dépot
usines = [[x[2], x[1]] for x in p.CP_SITES_FLORENTAISE if x[3] <= p.ANNEE]
compte_km_total = 0
#tonnage route bateau BCroute BCbateau
resultat_usine_MP = [[
x, [[y, 0, 0, 0, 0, 0] for y in usines if y[1] != "Support"]
] for x in liste_u_achats]
resultat_usine_MP.insert(0, [
"MP", "id usine (CP/Nom)", "tonnage", "km route", "km bateau",
"BC route (tco2e)", "BC bateau (tco2e)"
])
#La structure est un peu particuliere là. Pour chaque matière premiere, resultat_usine_MP a pour ligne
# [nom MP, [Usine depot,[%de la masse cette MP livree a ce depot, % du volume de...],fret route, fret bateau]
for mp in resultat_usine_MP[1:]:
nombre_livraisons_route_tot = 0 #Pour compter le nombre d'entrées (=livraisons) de cette MP
nombre_livraisons_bateau_tot = 0
sommeRoute_tot = 0.0 #Distance cumulée de camion pour les livraisons de cette MP
sommeBateau_tot = 0.0 #Idem en bateau
nomMP = mp[0]
#Pour compter les quantités
tonnage_tot = 0
idMP = fonctionsMatrices.recherche_elem(nomMP, listeAchats, 1, 0)
#On va chercher la masse volumique pour déterminer le tonnage
masse_volumique = 1
for mv in masse_vol_MP:
if mv[1].lower() in nomMP.lower() or nomMP.lower() in mv[1].lower(
):
try:
masse_volumique = float(mv[2])
except ValueError:
masse_volumique = 1
break
for usine in mp[1]:
nombre_livraisons_route_usine = 0 #Pour compter le nombre d'entrées (=livraisons) de cette MP
nombre_livraisons_bateau_usine = 0
cp_site_depot = usine[0][0]
for j in range(len(listeAchats)): #On parcourt la liste des achats
depot_arrive = listeAchats[j][
7] #Code postal du depot d'arrivee de la matiere premiere pour cette livraison
if cp_site_depot == depot_arrive and listeAchats[j][
1] == nomMP: #Si c'est la MP qui nous intéresse
famille = listeAchats[j][4]
nombre_livraisons_route_tot += 1
nombre_livraisons_route_usine += 1
quantite = listeAchats[j][9]
#On compte la quantité transportée, selon l'unité
if listeAchats[j][10] == "m3":
m3 = quantite
kg = 0
elif listeAchats[j][10] == "kg":
m3 = 0
kg = quantite
else:
fonctionsMatrices.print_log_erreur(
"Unité de l'intrant non reconnue : " +
listeAchats[j][10] + " pour " + nomMP,
inspect.stack()[0][3])
tonnage = (kg / 1000) + (m3 * masse_volumique)
tonnage_tot += tonnage
usine[1] += tonnage
#On récupère le calcul de la distance de fret
distanceRoute, distanceBateau, trajets, nombre_livraisons_bateau_supp = calcul_distance_fret_amont(
listeAchats[j], trajets, import_terrestre,
import_maritime)
compte_km_total += (distanceRoute + distanceBateau)
sommeRoute_tot += distanceRoute
sommeBateau_tot += distanceBateau
nombre_livraisons_bateau_usine += nombre_livraisons_bateau_supp
nombre_livraisons_bateau_tot += nombre_livraisons_bateau_supp
emissionsRoute = (distanceRoute *
FE_route) * tonnage / 1000
emissionsBateau = (distanceBateau *
FE_bateau) * tonnage / 1000
# print(nomMP+" "+str(int(emissionsRoute*1000))+" "+str(int(emissionsBateau*1000)))
usine[2] += distanceRoute
usine[3] += distanceBateau
usine[4] += emissionsRoute
usine[5] += emissionsBateau
if "tourbe" in nomMP.lower():
p.COMPARAISON_TOURBE[0] += (
(distanceRoute * FE_route +
distanceBateau * FE_bateau) * tonnage) / 1000
# print(nomMP+" "+str(cp_site_depot)+" "+str(usine[2])+"km "+str(usine[4])+"tCO2e" )
if nombre_livraisons_route_tot != 0:
moyenneRoute_tot = sommeRoute_tot / nombre_livraisons_route_tot
else:
moyenneRoute_tot = 0
if nombre_livraisons_bateau_tot != 0:
moyenneBateau_tot = sommeBateau_tot / nombre_livraisons_bateau_tot
else:
moyenneBateau_tot = 0
# print("TOT: "+ nomMP+" "+str(masse_volumique)+"t/m3 " )
#Associe un FE de transport en kgCO2e/t
#Le but ici n'est pas d'avoir le BC du fret amont mais seulement un FE par tonne: on ne s'intéresse pas encoe aux quantités.
#On prend juste (distance cumulée ou moyenne)*(FE du moyen de transport)
#Comme ce FE est en kgCO2.t-1.km-1 on a bien à la fin des kgCO2.t-1
fretMP.append([
nomMP, idMP, famille, sommeRoute_tot, sommeBateau_tot,
moyenneRoute_tot, moyenneBateau_tot, tonnage_tot,
FE_route * sommeRoute_tot, FE_bateau * sommeBateau_tot,
FE_route * moyenneRoute_tot, FE_bateau * moyenneBateau_tot,
masse_volumique
])
fretMP.insert(0, [
"nomMP", "ID mp", "Famille BC", "Somme du fret route (km)",
"Somme du fret naval (km)", "Moyenne de fret routier (km)",
"Moyenne de fret naval (km)", "Tonnage", "FE route(kgCO2e/t) cumulé",
"FE bateau(kgCO2e/t) cumulé", "FE route(kgCO2e/t) moyen",
"FE bateau(kgCO2e/t) moyen", "Masse volumique (t/m3)"
])
print("Km amont total : " + str(int(compte_km_total)) + "km")
if p.DISPLAY_GRAPH:
tracer_achats(trajets)
affichageResultats.sauveTrajetsAmont(trajets, nom_fichier)
return fretMP, resultat_usine_MP
def associer_nom_FEfab(listeAchats: list, MP_et_FE: list,
liste_engrais_eol: list):
nomsMP = fonctionsMatrices.liste_unique(
fonctionsMatrices.extraire_colonne_n(1, listeAchats))
MP_et_FEok = [x for x in MP_et_FE if x[0] != ""]
n = len(MP_et_FEok)
compte = 0
c_m1 = 0
c_m2 = 0
c_m3 = 0
c_m4 = 0
liste_introuves = []
for i in range(1, len(nomsMP)):
nom = nomsMP[i]
nomFamille = "A"
#On cherche le facteur d'émission à la FABRICATION de la matière première (en kgCO2e par tonne de MP)
trouve = False
#On parcourt la liste des facteurs d'émission
for k in MP_et_FEok[1:]:
try:
float(k[1])
except ValueError: #L'exception arrive souvent quand on a un caractère vide -> on suppose que c'est 0
k[1] = 0
logging.info(
"Le FE de " + nom +
" est vide. On lui attribue un FE de 0.",
inspect.stack()[0][3])
if nom.lower() == k[0].lower():
trouve = True
compte += 1
c_m1 += 1
FE_MPfab = k[1]
break
if not trouve: #Mais on va essayer de le trouver quand même
#D'abord on vire les caractères qui ne sont pas des lettres
nom_recherche = ""
for c in nom:
if c.isalpha():
nom_recherche += c.lower()
for k in MP_et_FEok[1:]:
nom_k = ""
for c in k[
0]: #On met aussi en minuscule et simplifié cette liste
if c.isalpha():
nom_k += c.lower()
#Là on trouve si la seule différence était un chiffre ou autre symbole
if nom_k != "" and (nom_k == nom_recherche
or nom_k in nom_recherche
or nom_recherche in nom_k):
p.LISTE_ASSIMILATIONS.append(
[nom, k[0], "Comparaison des lettres"])
trouve = True
compte += 1
FE_MPfab = k[1]
c_m2 += 1
MP_et_FEok.append([nom, k[1], k[0]])
break
if not trouve: #Si on a toujours pas trouvé, on récupère la distance de Levenshtein entre les deuxchaines de caractères
#et on prend celle qui ressemble le plus
distance_min = np.inf
temp = []
tolerance = 8 # nombre de caractères d'erreurs acceptés
taux = 0.4
for k in MP_et_FEok[1:]:
distanceL = fonctionsMatrices.levenshtein(
k[0].lower(), nom.lower())
if distanceL < tolerance:
p.LISTE_ASSIMILATIONS.append([
nom, k[0],
"Distance de Levenshtein (" + distanceL + ")"
])
trouve = True
c_m3 += 1
FE_MPfab = k[1]
MP_et_FEok.append([nom, k[1], k[0]])
compte += 1
break
elif distanceL < distance_min:
distance_min = distanceL
temp = [nom, k[1], k[0]]
break
if not trouve and len(temp) > 0 and distance_min < taux * min(
len(k[0]), len(nom)):
p.LISTE_ASSIMILATIONS.append(
[nom, k[0], "Distance de Levenshtein (" + distanceL + ")"])
trouve = True
c_m3 += 1
compte += 1
FE_MPfab = temp[1]
MP_et_FEok.append(temp)
if not trouve: #Si là on a toujours pas trouvé, on tente l'identification des mots
rech = []
mot = ""
for c in nom:
if c.isdigit():
break
elif c != " " and c.isalpha():
mot += c
elif c == " " and mot != "":
if mot not in [
"DE", "TaN", "TN", "TRUFFAUT", "BOTANIC",
"SYSTEME", "U", "DOR", "D", "N", "K"
]:
if mot == "TER":
rech.append("TERREAU")
elif mot == "INT":
rech.append("INTERIEUR")
elif mot == "PTES" or mot == "PLTES":
rech.append("PLANTES")
elif mot == "PAI":
rech.append("PAILLIS")
elif mot in "AROM":
rech.append("AROMATIQUES")
elif mot in "AQUAT":
rech.append("AQUATIQUES")
rech.append(mot)
mot = ""
if len(mot) != 0 and mot.lower() not in [
"l",
"kg",
"mm",
]:
rech.append(mot)
stemp = 0
temp = []
for k in MP_et_FEok[1:n]:
mots_k = []
mot = ""
for c in k[0]:
if c.isdigit():
break
elif c != " " and c.isalpha():
mot += c
elif c == " " and mot != "":
if mot not in [
"DE", "TaN", "TN", "TRUFFAUT", "BOTANIC",
"SYSTEME", "U", "DOR", "D", "N", "K"
]:
if mot == "TER":
mots_k.append("TERREAU")
elif mot == "INT":
mots_k.append("INTERIEUR")
elif mot == "PTES" or mot == "PLTES":
mots_k.append("PLANTES")
elif mot == "PAI":
mots_k.append("PAILLIS")
elif mot == "AROM":
mots_k.append("AROMATIQUES")
elif mot in "AQUAT":
rech.append("AQUATIQUES")
mots_k.append(mot)
mot = ""
if len(mot) != 0 and mot.lower() not in [
"l",
"kg",
"mm",
]:
mots_k.append(mot)
score = 0
stemp = 0
comm = []
comm = []
for v in rech:
for w in mots_k:
if v.lower() == w.lower():
score += 1
comm.append(v)
if score >= 3:
trouve = True
p.LISTE_ASSIMILATIONS.append([
nom, k[0],
str(score) + " mot(s) identique(s): " +
''.join([m + ";" for m in comm])
])
FE_MPfab = k[1]
MP_et_FEok.append([nom, k[1], k[0]])
c_m4 += 1
compte += 1
break
elif score >= 2 and score > stemp:
temp, stemp, elco = [nom, k[1], k[0]], score, comm
elif score == len(mots_k):
p.LISTE_ASSIMILATIONS.append([
nom, k[0],
str(score) + " mot(s) identique(s): " +
''.join([m + ";" for m in comm])
])
trouve = True
FE_MPfab = k[1]
c_m4 += 1
MP_et_FEok.append([nom, k[1], k[0]])
compte += 1
break
if temp != [] and stemp >= 1:
p.LISTE_ASSIMILATIONS.append([
nom, k[0],
str(stemp) + " mot(s) en commun: " +
''.join([m + ";" for m in elco])
])
trouve = True
compte += 1
c_m4 += 1
FE_MPfab = temp[1]
MP_et_FEok.append(temp)
if not trouve:
liste_introuves.append(nom)
for assim in p.LISTE_ASSIMILATIONS:
for engrais in liste_engrais_eol:
if assim[1] == engrais[0]:
liste_engrais_eol.append(
[assim[0], engrais[1], engrais[2], engrais[3], engrais[4]])
break
if len(liste_introuves) > 1:
fonctionsMatrices.print_log_erreur(
str(len(liste_introuves)) +
" facteurs d'émission d'intrants sont à ajouter manuellement:",
inspect.stack()[0][3])
elif len(liste_introuves) == 1:
fonctionsMatrices.print_log_erreur(
"Un facteur d'émission est à ajouter manuellement: " +
liste_introuves[0],
inspect.stack()[0][3])
for introuve in liste_introuves:
fonctionsMatrices.print_log_erreur(
"Ajouter " + introuve +
" à la liste des intrants (FE et masse volumique) dans le fichier des Entrées Manuelles, svp",
inspect.stack()[0][3])
# print(liste_introuves)
if len(MP_et_FEok) - n != 0:
fonctionsMatrices.print_log_info(
"Ajout de " + str(len(MP_et_FEok) - n) +
" entrées de FE dans les intrants par assimilation" +
" (détail des assimilations dans le fichier résultat)",
inspect.stack()[0][3])
return MP_et_FEok, liste_engrais_eol
def qte_materiaux_sacherie(refs_sacherie: list):
#Lecture des dimensions de sacherie
try:
document = xlrd.open_workbook(p.FICHIER_ENTREES_MANUELLES)
except FileNotFoundError:
fonctionsMatrices.print_log_erreur(
"Le fichier des entrées manuelles n'est pas trouvé à l'emplacement "
+ p.FICHIER_ENTREES_MANUELLES,
inspect.stack()[0][3])
sys.exit(
"Le fichier des entrées manuelles n'est pas trouvé à l'emplacement "
+ p.FICHIER_ENTREES_MANUELLES)
feuille_bdd = document.sheet_by_index(5)
nbrows = feuille_bdd.nrows
reference_materiaux = []
#On va lire les caractéristiques de matériau, recyclage et masse de chaque réf
for lin in range(10,
nbrows): #On lit touuuutes les refs, peu importe l'année
ref = feuille_bdd.cell_value(lin, 4)
mat = feuille_bdd.cell_value(lin, 10)
annee = int(feuille_bdd.cell_value(lin, 1))
imprimeur = feuille_bdd.cell_value(lin, 14)
if mat == "PEBD":
masse = feuille_bdd.cell_value(lin, 12)
recy = feuille_bdd.cell_value(lin, 11)
elif mat == "Papier":
masse = feuille_bdd.cell_value(lin, 13)
recy = 0 #Eventuellement à faire évoluer
else:
print("Matériaux du sac pas ok")
mat = "Papier"
masse = 0
recy = 0
reference_materiaux.append([ref, mat, masse, recy, imprimeur, annee])
liste_depots = fonctionsMatrices.extraire_colonne_n(
0, p.CP_SITES_FLORENTAISE)
conso_materiaux_par_site = [[
x, [["PEBD", 0], ["PEBDr", 0], ["Papier", 0]], 0
] for x in liste_depots] #Matrice résultat
#Pour chaque usine on a :
# [Nom , [["PEBD",massePEBD], ..], fret total pour cette usine]
fret_sacherie_par_usine = [
[x, 0, 0] for x in liste_depots
] #Matrice résultat, avec [usine;distance; distance.poids]
#Okay attention là ça devient un peu funky ~~
#Ca c'est la liste des imprimeurs qu'on trouve dans la bdd de sacherie
imprimeurs = fonctionsMatrices.liste_unique(
fonctionsMatrices.extraire_colonne_n(4, reference_materiaux))
#D'abord on va faire les correspondances entre imprimeur et code postal
imprimeries = []
for ligne in range(9, 35):
if feuille_bdd.cell_value(ligne, 18) != "":
nom = feuille_bdd.cell_value(ligne, 16).lower()
long = feuille_bdd.cell_value(ligne, 18)
lat = feuille_bdd.cell_value(ligne, 19)
imprimeries.append([nom, lat, long])
trajet_total = [0,
0] #Contiendra la distance et la masse totale transportée
#Déjà, on inverse la liste des références de sacherie, ça sera utile pour la parcourir dans la deuxième boucle for dans l'ordre de la plus récente à la plus ancienne ref
reference_materiaux = [
reference_materiaux[-(i + 1)] for i in range(len(reference_materiaux))
]
for i in range(
len(refs_sacherie)
): #On parcourt la liste des sacheries avec les quantités achetées par chaque site
trouveref = False
trouveimp = False
longA = -0.0240728298345268
latA = 0.826995076124778
ref = "".join(
[c for c in refs_sacherie[i][0] if c.isalpha() or c.isdigit()])
if "bigba" in ref.lower():
trouveref, mat, masse, recy, imprimeur = gestionBigBag(ref)
else:
for elem in reference_materiaux: #On parcourt la liste des sacheries avec les masses de chaque matériau
#On la parcourt à l'envers, du bas vers le haut par rapport au tableau excel source. Ainsi, grâce au break, on tombera sur la référence la plus récente (sans avoir à comparer les années)
ref_compare = "".join(
[c for c in elem[0] if c.isalpha() or c.isdigit()])
if ref_compare.lower() == ref.lower() and elem[
5] <= p.ANNEE: #Si on a une correspondance entre les références de sacherie
mat = elem[
1] #On enregistre le nom du matériau du sac (PEBD ou Papier)
masse = float(elem[2]) #La masse est en grammes
recy = float(
elem[3]
) #Son taux de recyclage (pour l'instant utile que si mat = PEBD)
imprimeur = elem[4]
trouveref = True
trouveimp = False
nom_imp_simp = []
for c in imprimeur:
if c.isalpha():
nom_imp_simp += c.lower()
if nom_imp_simp == "" or nom_imp_simp == " ":
nom_imp_simp = "placel"
for imp in imprimeries:
autre_nom_imp_simp = []
for c in imp[0]:
if c.isalpha():
autre_nom_imp_simp += c.lower()
if autre_nom_imp_simp == nom_imp_simp:
trouveimp = True
longA = imp[1]
latA = imp[2]
break
if not trouveimp:
fonctionsMatrices.print_log_erreur(
"Il faut renseigner les coordonnes de l'imprimeur "
+ imprimeur + " (réf. " + ref + ")",
inspect.stack()[0][3])
break #Une fois trouvée, on arrete de parcourir la liste
#Selon la matière on donne la masse de chaque composant
if mat == "PEBD":
massePEBD_r = recy * masse
massePEBD = masse - massePEBD_r
massePap = 0
elif mat == "Papier":
massePEBD = 0
massePEBD_r = 0
massePap = masse
if not trouveref:
p.Sacherie_manquante.append(refs_sacherie[i][0])
fonctionsMatrices.print_log_erreur(
"La référence de sacherie " + refs_sacherie[i][0] +
" n'a pas été trouvée",
inspect.stack()[0][3])
#On parcout la liste des usines dans lesquelles cette référence est livrée
for site in refs_sacherie[i][1]:
num_site = site[0]
qte = int(
site[1]) #Quantité de cette référence livrée dans ce dépot
try:
cp_site_liv = fonctionsMatrices.recherche_elem(
num_site, p.CP_SITES_FLORENTAISE, 0, 2)
except ValueError:
cp_site_liv = 44000
fonctionsMatrices.print_log_erreur(
"Code postal du site " + str(num_site) + " introuvable",
inspect.stack()[0][3])
trajet = geolocalisation.distance_GPS_CP(longA, latA, cp_site_liv)
if not trajet[1]: #Pour enregistrer le fret de sacherie par usine
trajet_total[0] += trajet[0]
trajet_total[1] += masse
for usine in fret_sacherie_par_usine:
if usine[0] == num_site:
usine[1] += trajet[0]
usine[2] += trajet[0] * qte * masse / (
1000 * 1000 * 1000
) #de grammes en tonnes et de kgCO2e en tCO2e
break
# print("Masse : "+str(masse)+"g, qté: "+str(qte))
for res in conso_materiaux_par_site: #On parcourt les cases de la matrice résultat
if res[0] == num_site: #Si on a trouvé le site correspondant
res[1][0][
1] += massePEBD * qte / 1000000 #On incrémente la quantité de matière en ajoutant la masse de matière de la réf multipliée par la quantité livrée
res[1][1][
1] += massePEBD_r * qte / 1000000 #On convertit en tonnes au passage
res[1][2][1] += massePap * qte / 1000000
if not trajet[1]:
res[2] += trajet[0]
break #Une fois le site correspondant trouvé on arrête de chercher
return conso_materiaux_par_site, fret_sacherie_par_usine
def getGPSfromCP(CP):
listeCP = fonctionsMatrices.extraire_colonne_n(
0, p.BDDgeoloc) #Liste des codes postaux
#Cette fonction est appelée dans Export ou il risque d'y avoir des CP peu formattés
#Donc d'abord on "nettoie" et on trie le code:
if CP == 0 or CP == " " or CP == "":
CP = 44850
coord = [0, 0]
pays = "FR"
for c in str(CP):
if c.isalpha() or c == '-':
#Alors il s'agit d'un CP étranger
#Donc on pleure un bon coup; on se retrousse les manches, et on y va
pays = "AUTRE"
break
if pays == "FR":
try:
CP_simp = 10 * int(int(CP) / 10) #On enlève le cedex
except ValueError: #En vrai je vois pas dans quel cas de figure mais eh on sait jamais
fonctionsMatrices.print_log_erreur(
"Code postal français invalide en première instance: " +
str(CP),
inspect.stack()[0][3])
CP = 44000 #Au pif
try:
coord = p.BDDgeoloc[listeCP.index(CP)][1:]
except ValueError:
CP_simp = 10 * int(
int(CP) / 10) #On enlève la localité trop précise (cedex)
try: #Et on réessaye !
coord = p.BDDgeoloc[listeCP.index(CP_simp)][1:]
except ValueError: #Bon là on ne peut plus qu'abandonner
#print("Code postal français invalide en seconde instance: "+str(CP))
# corriger_les_erreurs_CP([CP], 'CorrectionsCP.xlsx')
# fonctionsMatrices.print_log_erreur("Code postal français invalide en seconde instance: "+str(CP), inspect.stack()[0][3])
CP_simp2 = 100 * int(
int(CP) / 100) #On enlève la localité trop précise (cedex)
try: #Et on réessaye !
coord = p.BDDgeoloc[listeCP.index(CP_simp2)][1:]
except ValueError:
trouve = False
for x in CODES_POSTAUX_ETRANGERS:
if x[0] == CP:
coord = [x[1], x[2]]
trouve = True
if not trouve:
fonctionsMatrices.print_log_erreur(
"Code postal introuvable en troisième instance: " +
str(CP),
inspect.stack()[0][3])
p.LISTE_CODES_POSTAUX_ERRONES.append([CP, "Ventes"])
CP = 44000
coord = p.BDDgeoloc[listeCP.index(CP)][1:]
else:
trouve = False
for x in CODES_POSTAUX_ETRANGERS:
if x[0] == CP:
coord = [x[1], x[2]]
trouve = True
break
if not trouve:
p.LISTE_CODES_POSTAUX_ERRONES.append([CP, "Ventes (CP étranger)"])
fonctionsMatrices.print_log_erreur(
"Il faut ajouter le CP étranger " + str(CP) +
" à la BDD géoloc secondaire",
inspect.stack()[0][3])
coord = [0, 0]
return coord