good

app.py

@@ -0,0 +1,108 @@
+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}")