def calc_deplacements(nb_salariees):
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 = document.sheet_by_index(2)
ligne = 12
maximum = feuille.nrows
#Valeurs par défaut
dpt_perso = 5.53
dpt_pro = 43.66
while ligne < maximum:
FE = feuille.cell_value(ligne, 13)
if FE == "Deplacements quotidiens":
dpt_perso = feuille.cell_value(ligne, 14)
elif FE == "Deplacements pro":
dpt_pro = feuille.cell_value(ligne, 14)
ligne += 1
deplacements = []
for k in nb_salariees:
if k[0][2] == "Support":
emissions = k[1] * dpt_pro
else:
emissions = k[1] * dpt_perso
deplacements.append([k[0][2], emissions])
return deplacements
def lire_couts_camion_aval():
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(2)
#En €/km selon le cout
bdd_coutkm_E = []
for i in range(47, 58):
l = []
if feuille_bdd.cell_value(i, 3) != "":
for j in [3, 4, 5, 6]:
l.append(feuille_bdd.cell_value(i, j))
bdd_coutkm_E.append(l)
#En €/km selon la distance
bdd_coutkm_dist = []
for i in range(60, 70):
l = []
if feuille_bdd.cell_value(i, 3) != "":
for j in [3, 4, 5]:
l.append(feuille_bdd.cell_value(i, j))
bdd_coutkm_dist.append(l)
return bdd_coutkm_E, bdd_coutkm_dist
def lire_conversion_sacherie_GCO():
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(0)
nb = feuille_bdd.nrows
p.CONVERSION_SACHERIE_GCO = []
ligne = 12
while ligne < nb:
if feuille_bdd.cell_value(ligne, 29) != "":
p.CONVERSION_SACHERIE_GCO.append([
feuille_bdd.cell_value(ligne, 29),
feuille_bdd.cell_value(ligne, 30),
feuille_bdd.cell_value(ligne, 31)
])
ligne += 1
return None
def lireFE_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 = document.sheet_by_index(0)
liste_mat = ["pebd", "pet"]
carac = ["vierge", "neuf", "recyclé", "recycle"]
for i in range(12, 40):
if feuille.cell_value(i, 13) != "":
for l in liste_mat:
if l in feuille.cell_value(i, 13).lower():
mat = l
break
for c in carac:
if c in feuille.cell_value(i, 13).lower():
car = c
if mat == "pebd" and car in ["neuf", "vierge"]:
p.FE_PEBD_vierge = feuille.cell_value(i, 14)
elif mat == "pebd" and car in ["recyclé", "recycle"]:
p.FE_PEBD_recy = feuille.cell_value(i, 14)
elif mat == "pet" and car in ["neuf", "vierge"]:
p.FE_PET_vierge = feuille.cell_value(i, 14)
elif mat == "pet" and car in ["recyclé", "recycle"]:
p.FE_PET_recy = feuille.cell_value(i, 14)
return None
def sauveFret(sauveFret:list,chemin_ecriture:str, nom:str):
#On enregistre ici l'onglet log fret qui sert à la calculatrice de produits
#On copie la liste de fret sans les entêtes
fret_FE = sauveFret[1:]
#On essaye d'ouvrir le fichier
try:
log_fret = openpyxl.load_workbook( chemin_ecriture+nom)
except FileNotFoundError:
fonctionsMatrices.print_log_erreur("Le document résultat n'est pas trouvé à l'emplacement "+chemin_ecriture+nom, inspect.stack()[0][3])
sys.exit("Le document résultat n'est pas trouvé à l'emplacement "+ chemin_ecriture+nom)
log_fret = openpyxl.load_workbook( chemin_ecriture+nom)
#On crée une nouvelle feuille
feuilleFret = log_fret.create_sheet("log Fret par Matière Première",1)
#On charge les styles précédemment enregistrés comme variables globales
styleFond, styleTeteTab, styleVal, styleTableau, styleEntree, styleTitre = p.STYLES_EXCEL
#On applique un style uniforme sur le fond de la feuille
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for lin in range(1,300):
for col in [x for x in alphabet]:
case = col+str(lin)
feuilleFret[case].style=styleFond
for col in [x+y for x in alphabet for y in alphabet]:
case = col+str(lin)
feuilleFret[case].style=styleFond
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 lire_FEtransport():
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 = document.sheet_by_index(2)
type_camion = feuille.cell_value(7, 4)
type_bateau = feuille.cell_value(8, 4)
FE_transports = []
for ligne in range(12, 31):
if (feuille.cell_value(ligne, 3) !=
""): #On ne prend pas les lignes vides
FE = []
for col in [2, 3, 4, 5]:
FE.append(feuille.cell_value(ligne, col))
FE_transports.append(FE)
FE_route = fonctionsMatrices.recherche_elem(type_camion, FE_transports, 1,
2) #idem
FE_bateau = fonctionsMatrices.recherche_elem(type_bateau, FE_transports, 1,
2) #idem
return FE_route, FE_bateau
def lireDensitesPF():
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 = document.sheet_by_index(7)
nbrows = feuille.nrows
resultat = []
ligne = 2
while ligne < nbrows:
if feuille.cell_value(ligne, 7) != "" and feuille.cell_value(ligne,
8) != -1:
l = []
l.append(feuille.cell_value(ligne, 7))
try:
l.append(abs(float(feuille.cell_value(ligne, 8))))
except ValueError:
l.append(0.387)
resultat.append(l)
ligne += 1
return resultat
def get_cp_sites():
ligne_debut = 12
resultat = []
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 = document.sheet_by_index(0)
i = ligne_debut
while len(feuille.cell_value(i, 24)) > 1 and i < 30:
if feuille.cell_value(i, 25) != "":
a = [
int(feuille.cell_value(i, 23)),
feuille.cell_value(i, 24),
int(feuille.cell_value(i, 25)),
int(feuille.cell_value(i, 27))
]
resultat.append(a)
p.CP_FLORENTAISE.append(int(feuille.cell_value(i, 25)))
i += 1
else:
break
return resultat
def gestionpb_volume_sac(nom: str):
if nom == "TRUFFAUT POUZZOLANE 15L 72 SACS":
return 15 * 72 / 1000, "m3"
elif nom == "COPODECOR ECORCES DE PIN 10/25 60":
return 60 / 1000, "m3"
elif nom == "CERAMIQUE PPC GREEN GRADE":
return 22.7, "kg" #Au pif
elif nom == "COPOCAO COQUES DE CACAO":
return 120 / 1000, "m3" #Au pif aussi
elif nom == "Rajouter ici les noms et quantités manuellement":
return 42, "unite"
#On ne fait pas le cas où la chaine de charactères est nulle
if nom != "":
chiffres = ""
unit = ""
res = 0
identifie = False
i = 0
while i < len(nom):
while i < len(nom) and nom[i].isdigit(
): #important de tester dans cet ordre
chiffres += str(nom[i])
i += 1
if i >= len(nom):
break
if len(chiffres) != 0 and (nom[i] == "L" or nom[i] == "l"):
identifie = True
unit = "m3"
res = int("".join(chiffres))
res /= 1000 #Penser à convertir les L en m3 !
break
elif len(chiffres) != 0 and (
nom[i].lower() == "k" and
(i + 1) < len(nom)) and nom[i + 1].lower() == "g":
identifie = True
unit = "kg"
res = int("".join(chiffres))
break
#S'il y a un espace entre la qté et l'unité
elif (nom[i].lower() == " " and
(i + 1) < len(nom)) and nom[i + 1].isalpha():
#On passe au caractère suivant, ça passe pas par le "else" ni par le second "while" et tout rentre dans l'ordre !c
i += 1
else:
chiffres = ""
i += 1
if identifie:
return res, unit
else:
fonctionsMatrices.print_log_erreur(
"Detection de la quantité par sac indéchiffrable pour: " +
nom +
". A rajouter dans les exception de gestionIntrants.gestionpb_volume_sac() ",
inspect.stack()[0][3])
return 1, "kg" #Par défaut, si on a vraiment rien pu trouver, on donne 1KG
return 0, 'kg'
def lireFE_matprem():
debut = 10 #Ligne de début des tableaux T1 T2 et T3
fin_T1 = 47 #ligne de fin du premier tableau (FE par familles)
debut_T4 = 52 #debut et fin du tableau 4 (engrais)
fin_T4 = 56
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_MP = document.sheet_by_index(1)
FE_familles = []
MP_familles_N = []
masse_vol_MP = []
FE_engrais = []
for i in range(debut - 1, fin_T1):
FE_familles.append([
feuille_MP.cell_value(i, 2),
feuille_MP.cell_value(i, 3),
feuille_MP.cell_value(i, 4)
])
for i in range(debut - 1, feuille_MP.nrows):
ligne = []
for j in range(7, 14):
ligne.append(feuille_MP.cell_value(i, j))
MP_familles_N.append(ligne)
for i in range(debut - 1, feuille_MP.nrows):
if feuille_MP.cell_value(i, 16) != "":
masse_vol_MP.append([
feuille_MP.cell_value(i, 15),
feuille_MP.cell_value(i, 16),
feuille_MP.cell_value(i, 17)
])
for i in range(debut_T4 - 1, fin_T4):
if feuille_MP.cell_value(i, 3) != "":
FE_engrais.append([
feuille_MP.cell_value(i, 2),
feuille_MP.cell_value(i, 3),
feuille_MP.cell_value(i, 4)
])
return FE_familles, MP_familles_N, masse_vol_MP, FE_engrais
def lire_FE_tourbe_eol():
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_MP = document.sheet_by_index(1)
tourbe_blonde = feuille_MP.cell_value(9, 21)
tourbe_brune = feuille_MP.cell_value(10, 21)
tourbe_noire = feuille_MP.cell_value(11, 21)
return [tourbe_blonde, tourbe_brune, tourbe_noire]
def solve_tsp_dynamic(pts, liv): #https://gist.github.com/mlalevic/6222750
#calc all lengths
all_distances = [[
distance(pts[x][0], pts[x][1], pts[y][0], pts[y][1])
for y in range(len(pts))
] for x in range(len(pts))]
#initial value - just distance from 0 to every other point + keep the track of edges
A = {(frozenset([0, idx + 1]), idx + 1): (dist, [0, idx + 1])
for idx, dist in enumerate(all_distances[0][1:])}
cnt = len(pts)
for m in range(2, cnt):
B = {}
for S in [
frozenset(C) | {0}
for C in itertools.combinations(range(1, cnt), m)
]:
for j in S - {0}:
B[(S, j)] = min(
[(A[(S - {j}, k)][0] + all_distances[k][j],
A[(S - {j}, k)][1] + [j]) for k in S
if k != 0 and k != j]
) #this will use 0th index of tuple for ordering, the same as if key=itemgetter(0) used
A = B
try:
res = min([(A[d][0] + all_distances[0][d[1]], A[d][1])
for d in iter(A)])
return res[1]
except ValueError:
fonctionsMatrices.print_log_erreur(
"Optimisation de la sous livraison n°" + str(int(liv[0])) +
" impossible",
inspect.stack()[0][3])
i = 0
plt.title("Problème pour trouver le chemin optimal de BL n°" +
str(int(liv[0])))
for pt in pts[1:]:
i += 1
plt.scatter(pt[0],
pt[1],
s=50 * pt[2] / pts[0][2],
zorder=2,
c="r")
plt.text(pt[0], pt[1], " " + str(i))
plt.scatter(pts[0][0], pts[0][1], s=50, zorder=3, c="g")
plt.show()
return False
def lireExport():
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(4)
nbrows = feuille_bdd.nrows
#TERRESTRE
bdd_exp_terre = []
for i in range(20, min(42, nbrows)):
ligne = []
if feuille_bdd.cell_value(i, 2) != "":
for j in [1, 2, 3, 6, 7]:
ligne.append(feuille_bdd.cell_value(i, j))
bdd_exp_terre.append(ligne)
#MARITIME
bdd_exp_mari = []
liaisons = []
for i in range(3, 11):
if feuille_bdd.cell_value(i, 14) != "":
chaine = []
for j in [14, 15, 16]:
chaine.append(feuille_bdd.cell_value(i, j))
liaisons.append(chaine)
ports = []
for i in range(2, 17):
if feuille_bdd.cell_value(i, 2) != "":
port = []
for j in [1, 2, 3, 6, 7]:
port.append(feuille_bdd.cell_value(i, j))
ports.append(port)
for chaine in liaisons:
port_depart = ports[int(chaine[0] - 1)]
port_arrivee = ports[int(chaine[1] - 1)]
bdd_exp_mari.append([port_depart, port_arrivee, chaine[2]])
return bdd_exp_terre, bdd_exp_mari
def lire_conso_elec():
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 = document.sheet_by_index(0)
conso_par_site = [[[x[0], x[2], x[1]], 0] for x in p.CP_SITES_FLORENTAISE]
nmax = feuille.nrows
i = 3
while i < nmax and feuille.cell_value(i, 0) != "Conso Electrique (kWh)":
i += 1
colonne = 2
ligne = i
while colonne < 40:
if feuille.cell_value(ligne, colonne) == p.ANNEE:
break
colonne += 1
ligne += 1
while ligne <= i + len(p.CP_SITES_FLORENTAISE):
conso = feuille.cell_value(ligne, colonne)
for x in conso_par_site:
if x[0][0] == feuille.cell_value(ligne, 0):
try:
x[1] = float(conso)
except ValueError:
fonctionsMatrices.print_log_erreur(
"Consommation électrique erronée",
inspect.stack()[0][3])
x[1] = 0
break
ligne += 1
total = 0
for x in conso_par_site:
total += x[1]
return conso_par_site, total
def lire_donnees_entreprise():
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 = document.sheet_by_index(0)
employ_par_site = [[[x[0], x[2], x[1]], 0] for x in p.CP_SITES_FLORENTAISE]
production_par_site = [[[x[0], x[2], x[1]], 0]
for x in p.CP_SITES_FLORENTAISE]
ligne = 7
colonne = 2
while colonne < 22:
if p.ANNEE == feuille.cell_value(ligne, colonne):
break
colonne += 1
ligne += 1
CA = feuille.cell_value(ligne, colonne)
ligne = 12
while ligne < 23:
conso = feuille.cell_value(ligne, colonne)
for x in employ_par_site:
if x[0][0] == feuille.cell_value(ligne, 0):
x[1] = conso
break
ligne += 1
ligne = 24
while ligne < 36:
conso = feuille.cell_value(ligne, colonne)
for x in production_par_site:
if x[0][0] == feuille.cell_value(ligne, 0):
x[1] = conso
break
ligne += 1
return CA, employ_par_site, production_par_site
def BC_intrants_par_site(resultat_usine_MP: list, MP_et_FE: list):
BC_MP_site = [[[x[0], x[2], x[1]], 0] for x in p.CP_SITES_FLORENTAISE]
resultat_complet = []
for matprem in resultat_usine_MP[1:]:
nom = matprem[0]
fe = 1
trouve = False
for fact in MP_et_FE:
el = ""
for c in fact[0]:
if c.isalpha():
el += c
if nom.lower() in fact[0].lower() or fact[0].lower() in nom.lower(
):
fe = fact[1]
trouve = True
break
if not trouve:
fonctionsMatrices.print_log_erreur("FE non trouvé pour: " + nom,
inspect.stack()[0][3])
for usine in matprem[1]:
nom_usine = usine[0][1]
tonnage = usine[1]
emissions = tonnage * fe / 1000 #on convertit en tCO2e
if emissions != 0:
resultat_complet.append([
nom, nom_usine, tonnage, fe, "kgCO2e/t", emissions, "tCO2e"
])
# print(nom + " " +nom_usine+" BC mp: "+ str(bc_mp_usine))
for res in BC_MP_site:
if tonnage != 0 and res[0][2] == nom_usine:
res[1] += emissions
# print("Bilan carbone: "+str(emissions) +"tCO2e ("+nom+")")
if "tourbe" in nom.lower():
p.COMPARAISON_TOURBE[1] += emissions
# print("Tourbe : "+str(tonnage*fe/1000)+" teCO2")
break
return BC_MP_site, resultat_complet
def lireFE_emballage():
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(2)
res = []
for ligne in range(12, 40):
if feuille_bdd.cell_value(ligne, 13) != "":
res.append([
feuille_bdd.cell_value(ligne, 13),
feuille_bdd.cell_value(ligne, 14)
])
return res
def liregroupements():
try:
document = xlrd.open_workbook(p.DIRECTION_FICHIER_VENTES1)
except FileNotFoundError:
fonctionsMatrices.print_log_erreur(
"Le fichier des ventes 1 n'est pas trouvé à l'emplacement " +
p.DIRECTION_FICHIER_VENTES1,
inspect.stack()[0][3])
sys.exit("Le fichier des ventes 1 n'est pas trouvé à l'emplacement " +
p.DIRECTION_FICHIER_VENTES1)
document = xlrd.open_workbook(p.DIRECTION_FICHIER_VENTES1)
feuille = document.sheet_by_index(0)
nbrows = feuille.nrows
resultat = [["N° commande", "N° groupement"]]
ligne = 1
while ligne < nbrows:
num_commande = feuille.cell_value(ligne, 10)
num_gpt = feuille.cell_value(ligne, 0)
resultat.append([num_commande, num_gpt])
ligne += 1
return resultat
def lireImportTerrestre(fichier: str):
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_ter = document.sheet_by_index(3)
fournisseurs = []
for lin in range(20, 64):
if feuille_bdd_ter.cell_value(lin, 2) != "":
ligne = []
for col in [2, 3, 6, 7]:
ligne.append(feuille_bdd_ter.cell_value(lin, col))
fournisseurs.append(ligne)
return fournisseurs
def lireBDDgeoloc():
try:
document = xlrd.open_workbook(p.FICHIER_BDD_GEOLOC)
except FileNotFoundError:
fonctionsMatrices.print_log_erreur(
"Le fichier de géolocalisation n'est pas trouvé à l'emplacement " +
p.FICHIER_BDD_GEOLOC,
inspect.stack()[0][3])
sys.exit(
"Le fichier de géolocalisation n'est pas trouvé à l'emplacement " +
p.FICHIER_BDD_GEOLOC)
feuille_bdd = document.sheet_by_index(0)
nbrows = feuille_bdd.nrows
result = []
for i in range(1, nbrows):
result.append([
feuille_bdd.cell_value(i, 1),
feuille_bdd.cell_value(i, 6),
feuille_bdd.cell_value(i, 7)
])
return result
def corriger_noms_massesvol(masses_vol: list, MP_et_FE: list,
listeAchats: list):
n = len(masses_vol)
introuves = []
compteur = 0
ajouts = [x for x in MP_et_FE if len(x) == 3]
to_add = []
for x in ajouts:
ajoute = False
for mv in masses_vol:
if x[2].lower() in mv[1].lower() or mv[1] in x[2].lower():
compteur += 1
ajoute = True
to_add.append([n + compteur, x[0], mv[2]])
break
if not ajoute:
introuves.append(x[0])
for aj in to_add:
masses_vol.append(aj)
if len(introuves) == 1:
pass
fonctionsMatrices.print_log_erreur(
"Une masse volumique est à ajouter manuellement:" + introuves[0],
inspect.stack()[0][3])
elif len(introuves) > 1:
pass
fonctionsMatrices.print_log_erreur(
str(len(introuves)) +
" masses volumiques sont à ajouter manuellement",
inspect.stack()[0][3])
print(introuves)
fonctionsMatrices.print_log_info(
"Ajout de " + str(len(masses_vol) - n) +
" entrées dans les masses volumiques par assimilation",
inspect.stack()[0][3])
return masses_vol
def lire_FE_fuel():
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 = document.sheet_by_index(2)
nlignes = feuille.nrows
type_mixe = feuille.cell_value(8, 9)
ligne = 12
while ligne < nlignes:
if feuille.cell_value(ligne, 8) == type_mixe:
FE = feuille.cell_value(ligne, 9)
break
ligne += 1
return FE
def get_cp_inter():
try:
document = xlrd.open_workbook(p.FICHIER_BDD_GEOLOC)
except FileNotFoundError:
fonctionsMatrices.print_log_erreur(
"Le fichier de géolocalisation n'est pas trouvé à l'emplacement " +
p.FICHIER_BDD_GEOLOC,
inspect.stack()[0][3])
sys.exit(
"Le fichier de géolocalisation n'est pas trouvé à l'emplacement " +
p.FICHIER_BDD_GEOLOC)
feuille_bdd = document.sheet_by_index(0)
ligne = 5
col = 11
res = []
while ligne < 100:
l = []
if feuille_bdd.cell_value(ligne, col) != "":
for c in [col, col + 1, col + 2]:
l.append(feuille_bdd.cell_value(ligne, c))
res.append(l)
ligne += 1
return res
def ajouter_immobilisations():
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 = document.sheet_by_index(6)
maximum = feuille.nrows
immobilisations = []
ligne = 7
while ligne < maximum:
if feuille.cell_value(ligne, 9) == "Total amorti (tCO2e)":
usine = feuille.cell_value(ligne - 5, 0)
ligne += 1
amorti = feuille.cell_value(ligne, 9)
immobilisations.append([usine, amorti])
ligne += 1
return immobilisations
def entetes_resultats_generaux(usines:list, nom_fichier:str):
styleFond, styleTeteTab, styleVal, styleTableau, styleEntree, styleTitre = p.STYLES_EXCEL
ligne_depart = 10
try:
document = openpyxl.load_workbook(p.CHEMIN_ECRITURE_RESULTATS+nom_fichier)
except FileNotFoundError:
fonctionsMatrices.print_log_erreur("Le document résultat n'est pas trouvé à l'emplacement "+p.CHEMIN_ECRITURE_RESULTATS+nom_fichier, inspect.stack()[0][3])
sys.exit("Le document résultat n'est pas trouvé à l'emplacement "+ p.CHEMIN_ECRITURE_RESULTATS+nom_fichier)
feuilleprinc = document.get_sheet_by_name(document.get_sheet_names()[0])
feuilleprinc.column_dimensions['B'].width = 24
feuilleprinc.column_dimensions['C'].width = 0
feuilleprinc.column_dimensions['D'].width = 20
feuilleprinc.column_dimensions['E'].width = 10
FretAmont = ["MP bateau", "MP route"]
FretAval = ["Ventes pro","Ventes Jardineries", "Interdepot"]
Intrants = ["Matières Premières", "CO2 issu de la tourbe"]
HorsEnergie = ["Protoxyde d'azote"]
Energie = ["Electricité", "Fuel"]
Emballages = ["PE neuf", "PE recyclé", "PVC", "Carton"]
entetes = FretAmont+FretAval+Intrants+HorsEnergie+Energie+Emballages
colonnes = ["Poste d'émission", "Site", "Empreinte carbone (tCO2e)","", "Emission par m3 (kgCO2e/m3)", ""]
for i in range(len(colonnes)):
feuilleprinc.cell(row = ligne_depart, column = i+2).value = colonnes[i]
feuilleprinc.cell(row=ligne_depart, column=i+2).style = styleTeteTab
i = 0
for poste in entetes:
for j in range(len(usines)):
feuilleprinc["B"+str(i+ligne_depart+1)] = poste
feuilleprinc["C"+str(i+ligne_depart+1)] = str(usines[j][0]) + " " + usines[j][1]
i+=1
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
tableau = Table(displayName = "Resultats_principaux", ref = "B"+str(ligne_depart)+":"+alphabet[len(entetes)]+str(ligne_depart+i))
tableau.tableStyleInfo = styleTableau
production_totale = sum([x[1]for x in p.PROD_PAR_SITE])
feuilleprinc['C7'] = "Total:"
feuilleprinc['D7'] = "=TEXT(SUM(D11:D"+str(199)+"), \"# ##0\")&+\" tCO2e\""
feuilleprinc['E7'] = "et"
feuilleprinc['F7'] = "=TEXT(1000*SUM(D11:D"+str(199)+")/"+str(production_totale)+", \"# ##0,0\")&+\" kgCO2e/m3\""
# rouge = openpyxl.styles.colors.Color(rgb='00FF0000')
for c in "CDEF":
feuilleprinc[c+"7"].font = Font(size=18, bold=True)
#Si on a la possibilité, on sauvegarde
try:
document.save(p.CHEMIN_ECRITURE_RESULTATS+nom_fichier)
except PermissionError: #Soit à cause du fichier réseau, soit parce que l'excel est ouvert ailleurs
fonctionsMatrices.print_log_erreur("Permissions insuffisantes pour enregistrer le fichier résultat", inspect.stack()[0][3])
except FileNotFoundError: #Emplacement inexistant
fonctionsMatrices.print_log_erreur("Emplacement d'écriture introuvable: "+str(p.CHEMIN_ECRITURE_RESULTATS + nom_fichier), inspect.stack()[0][3])
def associerMPetFE_fab(MP_familles_N: list, FE_engrais: list,
FE_familles: list):
liste_engrais_eol = [[
"Nom engrais", "Taux d'azote (%)", "FE épandage (tCO2e/t_azote)",
"Masse (t)", "FE épandag (kgCO2e/t_engrais)"
]]
MP_et_FE = [["Nom MP", "FE (kgCO2e/t)"]]
for i in range(len(MP_familles_N)):
nom_famille_BC = MP_familles_N[i][5]
if "engrais" in nom_famille_BC.lower(
) or "ammonitrate" in nom_famille_BC.lower(
) or "urée" in nom_famille_BC.lower(
) or "uree" in nom_famille_BC.lower():
tx_N = MP_familles_N[i][6]
try:
tx_N = float(tx_N)
except ValueError:
fonctionsMatrices.print_log_erreur(
"Taux d'azote invalide pour l'engrais " +
str(MP_familles_N[i][2]) +
". On lui attribue un taux de 10%",
inspect.stack()[0][3])
tx_N = 0.1
try:
FE = tx_N * fonctionsMatrices.recherche_elem(
nom_famille_BC, FE_engrais, 1, 2)
except ValueError:
fonctionsMatrices.print_log_erreur(
"La famille de l'engrais " + str(MP_familles_N[i][2]) +
" (" + str(nom_famille_BC) +
") n'a pas été trouvé. On lui attribue un FE de 479.5 kgCO2/t (engrais moyen azoté à 10%)",
inspect.stack()[0][3])
FE = 479.5
liste_engrais_eol.append([
MP_familles_N[i][2], tx_N, p.FE_EMPANDAGE_ENGRAIS * p.PRG_N2O,
0, 1000 * tx_N * p.FE_EMPANDAGE_ENGRAIS * p.PRG_N2O
])
else:
try:
FE = fonctionsMatrices.recherche_elem(nom_famille_BC,
FE_familles, 1, 2)
except ValueError:
fonctionsMatrices.print_log_erreur(
"L'élément " + str(nom_famille_BC) +
" n'a pas été trouvé. On lui attribue un FE de 0",
inspect.stack()[0][3])
FE = 0
MP_et_FE.append([MP_familles_N[i][2], FE])
return MP_et_FE, liste_engrais_eol
def ecrire_messages_derreur(nom:str):
#Tous les messages d'erreur
try:
log_erreurs = openpyxl.load_workbook( p.CHEMIN_ECRITURE_RESULTATS+nom)
except FileNotFoundError:
fonctionsMatrices.print_log_erreur("Le document résultat n'est pas trouvé à l'emplacement "+ p.CHEMIN_ECRITURE_RESULTATS+nom, inspect.stack()[0][3])
sys.exit("Le document résultat n'est pas trouvé à l'emplacement "+ p.CHEMIN_ECRITURE_RESULTATS+nom)
feuilleErreurs = log_erreurs.create_sheet("Erreurs et informations",-1)
styleFond, styleTeteTab, styleVal, styleTableau, styleEntree, styleTitre = p.STYLES_EXCEL
if len(p.MESSAGES_DERREUR)>1:
for message in p.MESSAGES_DERREUR:
feuilleErreurs.append(message)
feuilleErreurs.column_dimensions['A'].width = 9
feuilleErreurs.column_dimensions['B'].width = 160
feuilleErreurs.column_dimensions['C'].width = 28
#Les codes postaux erronés
if p.EMBALLAGES_ET_SACHERIE or p.INTRANTS_ET_FRET or p.FRET_AVAL:
if len(p.LISTE_CODES_POSTAUX_ERRONES)>1:
feuilleErreursCP = log_erreurs.create_sheet("Codes postaux à corriger",-1)
feuilleErreursCP.column_dimensions['A'].width = 14
feuilleErreursCP.column_dimensions['B'].width = 14
for cp in p.LISTE_CODES_POSTAUX_ERRONES:
feuilleErreursCP.append(cp)
#Les assimilations de matières premières
if p.INTRANTS_ET_FRET:
if len(p.LISTE_ASSIMILATIONS)>1:
feuilleAssim = log_erreurs.create_sheet("Assimilations de MP",-1)
feuilleAssim.column_dimensions['A'].width = 40
feuilleAssim.column_dimensions['B'].width = 40
for message in p.LISTE_ASSIMILATIONS:
feuilleAssim.append(message)
#Si on a la possibilité, on sauvegarde
try:
log_erreurs.save(p.CHEMIN_ECRITURE_RESULTATS+nom)
except PermissionError: #Soit à cause du fichier réseau, soit parce que l'excel est ouvert ailleurs
fonctionsMatrices.print_log_erreur("Permissions insuffisantes pour enregistrer le fichier résultat", inspect.stack()[0][3])
except FileNotFoundError: #Emplacement inexistant
fonctionsMatrices.print_log_erreur("Emplacement d'écriture introuvable: "+str(p.CHEMIN_ECRITURE_RESULTATS + nom), inspect.stack()[0][3])
return None
def sauveTrajetsAmont(trajets, nom):
try:
log_fret = openpyxl.load_workbook( p.CHEMIN_ECRITURE_RESULTATS+nom)
except FileNotFoundError:
fonctionsMatrices.print_log_erreur("Le document résultat n'est pas trouvé à l'emplacement "+p.CHEMIN_ECRITURE_RESULTATS+nom, inspect.stack()[0][3])
sys.exit("Le document résultat n'est pas trouvé à l'emplacement "+ p.CHEMIN_ECRITURE_RESULTATS+nom)
feuilleFretAmont = log_fret.create_sheet("Fret Brut MP",1)
#On charge les styles précédemment enregistrés comme variables globales
styleFond, styleTeteTab, styleVal, styleTableau, styleEntree, styleTitre = p.STYLES_EXCEL
for x in trajets:
feuilleFretAmont.append([x[0], x[1], x[2], x[5], x[6], x[7], x[8],x[9]])
#Si on a la possibilité, on sauvegarde
try:
log_fret.save(p.CHEMIN_ECRITURE_RESULTATS+nom)
except PermissionError: #Soit à cause du fichier réseau, soit parce que l'excel est ouvert ailleurs
fonctionsMatrices.print_log_erreur("Permissions insuffisantes pour enregistrer le fichier résultat", inspect.stack()[0][3])
except FileNotFoundError: #Emplacement inexistant
fonctionsMatrices.print_log_erreur("Emplacement d'écriture introuvable: "+str(p.CHEMIN_ECRITURE_RESULTATS + nom), inspect.stack()[0][3])
return None
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
