Spaces:
Sleeping
Sleeping
| import streamlit as st | |
| import pandas as pd | |
| # Initialiser l'état de la session | |
| if 'phases' not in st.session_state: | |
| st.session_state['phases'] = [] | |
| # Titre | |
| st.title('Gestion des erreurs de mélange de béton') | |
| st.header('Entrées les norme de calcul') | |
| g1_norme = st.number_input('G1 norme',value=575.0 ,format="%.2f") | |
| g2_norme= st.number_input('G2 norme',value=1000.0 ,format="%.2f") | |
| sb_norme= st.number_input('SB norme',value=1237.0 ,format="%.2f") | |
| cube_norme= st.number_input('Cube norme',value=1.5 ,format="%.2f") | |
| # Section d'entrée pour la phase | |
| st.header('Entrées pour la phase') | |
| g1_input = st.number_input('G1',format="%.2f") | |
| g2_input = st.number_input('G2',format="%.2f") | |
| sb_input = st.number_input('SB', format="%.2f") | |
| cubes_input = st.number_input('Cubes', value=1.5, format="%.2f") | |
| # Ajouter la phase | |
| if st.button('Ajouter la phase'): | |
| phase_data = { | |
| 'G1': g1_input, | |
| 'G2': g2_input, | |
| 'SB': sb_input, | |
| 'Cubes': cubes_input, | |
| 'G1_Error': g1_input- (g1_norme/cube_norme * cubes_input) , | |
| 'G2_Error': (g2_input - g1_input)-(g2_norme/cube_norme * cubes_input) , | |
| 'SB_Error': (sb_input - g2_input)-(sb_norme /cube_norme* cubes_input) , | |
| } | |
| st.session_state['phases'].append(phase_data) | |
| # Afficher les phases | |
| st.header('Phases') | |
| phases_df = pd.DataFrame(st.session_state['phases']) | |
| st.write(phases_df) | |
| # Calculer les erreurs totales | |
| st.header('Calcul des erreurs') | |
| try: | |
| total_g1_error = phases_df['G1_Error'].sum() | |
| total_g2_error = phases_df['G2_Error'].sum() | |
| total_sb_error = phases_df['SB_Error'].sum() | |
| st.write(f"Erreur totale G1: {total_g1_error}") | |
| st.write(f"Erreur totale G2: {total_g2_error}") | |
| st.write(f"Erreur totale SB: {total_sb_error}") | |
| except KeyError as e: | |
| st.error(f"Erreur dans les données: {e}") | |
| # Correction des erreurs en fonction des cubes restants | |
| st.header('Correction des erreurs') | |
| remaining_cubes = st.number_input('Cubes restants', value=1.0, format="%.2f") | |
| if st.button('Corriger les erreurs'): | |
| try: | |
| correction_g1 = g1_norme/cube_norme *remaining_cubes - total_g1_error | |
| correction_g2 = g2_norme/cube_norme *remaining_cubes - total_g2_error | |
| correction_sb = sb_norme/cube_norme *remaining_cubes - total_sb_error | |
| st.write(f"Correction G1 par cube: {correction_g1}") | |
| st.write(f"Correction G2 par cube: {correction_g2}") | |
| st.write(f"Correction SB par cube: {correction_sb}") | |
| except ZeroDivisionError: | |
| st.error("Le nombre de cubes restants doit être supérieur à zéro pour corriger les erreurs.") | |
| # Générer un rapport détaillé des erreurs | |
| st.header('Rapport détaillé des erreurs') | |
| if st.button('Générer le rapport'): | |
| try: | |
| report = f""" | |
| ## Rapport détaillé des erreurs | |
| ### Erreurs totales | |
| - Erreur G1: {total_g1_error} | |
| - Erreur G2: {total_g2_error} | |
| - Erreur SB: {total_sb_error} | |
| ### Correction nécessaire | |
| - G1 par cube: {correction_g1} | |
| - G2 par cube: {correction_g2} | |
| - SB par cube: {correction_sb} | |
| ### Phases | |
| {phases_df.to_markdown()} | |
| """ | |
| st.markdown(report) | |
| except Exception as e: | |
| st.error(f"Erreur lors de la génération du rapport: {e}") | |
| # Enregistrer le rapport | |
| st.header('Enregistrer le rapport') | |
| if st.button('Enregistrer le rapport'): | |
| try: | |
| with open("rapport_erreurs.txt", "w") as file: | |
| file.write(report) | |
| st.write('Rapport enregistré sous le nom rapport_erreurs.txt') | |
| except Exception as e: | |
| st.error(f"Erreur lors de l'enregistrement du rapport: {e}") | |