Split import validate

main_nathan.py

@@ -15,6 +15,7 @@
 from pv_tool.imports.import_data import Dbase
 from pv_tool.cphi_analysis.c_phi_analysis import CPhiAnalyse
 from pv_tool.imports.import_options import *
+from typing import Literal
 
 
 def get_repo_root(root_search_dir: Optional[str] = None) -> str:
@@ -56,25 +57,42 @@ def get_repo_root(root_search_dir: Optional[str] = None) -> str:
     return repo.working_tree_dir
 
 
-def test_database_import():
+def test_database_import(source: Literal['Stowa', 'PV-tool', 'Dbase'],
+                                 file_name_import: str, file_name_export: str = 'Template_PVtool5_0.xlsx', short=False, validate=False, export=False):
     """Test de database import en validatie functionaliteit."""
     repo_root = Path(get_repo_root())
-    path_to_data = repo_root / "example_files" / "Template_PVtool5_0.xlsx"
+    path_to_data = repo_root / "example_files" / file_name_import
     save_test = Path(r"c:\Users\gebraadn0645\ARCADIS\103076457 - STOWA PV Tool - 05 Project execution\Deliverables\2. validatie\Test output")
 
-    # Database import
-    dbase = Dbase()
-    dbase.import_data(source='Dbase', source_dir=path_to_data)
-
-    # Print unieke verzamelingen
-    print('\nUnieke verzamelingen:')
-    for pvnaam in dbase.dbase_df['PV_NAAM'].unique():
-        print(pvnaam)
-
-    return dbase
-
-
-def test_cphi_analysis_txt(dbase: Dbase):
+    if short and not validate:
+        print("Uitvoeren van korte database import test...")
+        dbase = Dbase()
+        dbase.import_dbase_short(source=source, source_dir=path_to_data)
+        if export:
+            dbase.export_dbase_to_excel(export_dir = save_test, filename=file_name_export)
+        return dbase
+    elif validate and not short:
+        print("Uitvoeren van database import en validatie test...")
+        dbase = Dbase()
+        dbase.import_data(source=source, source_dir=path_to_data)
+        dbase.validate_data(export_path=save_test)
+        if export:
+            dbase.export_dbase_to_excel(export_dir = save_test, filename=file_name_export)
+        return dbase
+    elif short and validate:
+        print("Korte import en validatie kan niet samen worden uitgevoerd. Kies één optie.")
+        return None
+    else:
+        print("Uitvoeren van volledige database import test...")
+        # Database import
+        dbase = Dbase()
+        dbase.import_data(source=source, source_dir=path_to_data)
+        if export:
+            dbase.export_dbase_to_excel(export_dir = save_test, filename=file_name_export)
+        return dbase
+
+
+def test_cphi_analysis_txt(dbase: Dbase, file_name: str = 'Template_PVtool5_0.xlsx'):
     """
     Test een TXT C-phi analyse.
 
@@ -95,12 +113,12 @@ def test_cphi_analysis_txt(dbase: Dbase):
 
     # Pas instellingen toe
     analyse.apply_settings(alpha=0.75)
-    analyse.apply_parameters(cohesie_kar=0)
+    analyse.apply_parameters(cohesie_kar=0.0)
 
     # Print en exporteer resultaten
     print('\nResultaten TXT C-phi analyse:')
     print(analyse.print_short_results())
-    analyse.add_results_to_dbase(path=str(save_test))
+    analyse.add_results_to_dbase(path=str(save_test), file_name=file_name)
 
     # Visualisatie
     analyse.show_figure()
@@ -205,13 +223,19 @@ def test_cphi_analysis_dss_sh(dbase: Dbase):
 
 if __name__ == "__main__":
     # Test database import
-    dbase = test_database_import()
+    source = 'Dbase'  # Opties: 'Stowa', 'PV-tool', 'Dbase'
+    import_name = 'Template_PVtool5_0_SAFE_2022_PV_zonder_resultaten.xlsx'
+    export_name = 'Template_PVtool5_0_SAFE_2022_PV.xlsx'
+    import_name2 = export_name  # TODO eventueel: import naam kan nu niet export naam zijn, dan kan die niet de layout aanpassen. Moet nog worden aangepast in de toekomst.
+    print("Start van de tests...\n")
+    dbase = test_database_import(source=source, file_name_import=import_name, file_name_export=export_name, short=True, validate=False, export=True)
 
     # Test verschillende analyses
     print("\nUitvoeren van verschillende test cases...")
 
     print("\n1. TXT C-phi analyse test")
-    test_cphi_analysis_txt(dbase)
+    file_name = 'Template_PVtool5_0_SAFE_2022_PV.xlsx'
+    test_cphi_analysis_txt(dbase, file_name=file_name)
 
     # print("\n2. DSS C-phi analyse test")
     # test_cphi_analysis_dss(dbase)

pv_tool/cphi_analysis/c_phi_analysis.py

@@ -555,7 +555,7 @@ def print_short_results(self):
             analyse_output_df['cohesie [kPa]'] = [self.c_gem, self.c_kar, self.c_d, self.st_dev_c]
         return analyse_output_df
 
-    def add_results_to_dbase(self, path):
+    def add_results_to_dbase(self, path, file_name: str = 'Template_PVtool5_0.xlsx'):
         """
         Voegt analyseresultaten toe aan de database export.
 
@@ -566,13 +566,14 @@ def add_results_to_dbase(self, path):
         ----------
         path : str
             Map locatie waar het Excel-bestand staat of moet komen
+        file_name : str, optioneel
+            Naam van het Excel-bestand (standaard 'Template_PVtool5_0.xlsx')
 
         Returns
         -------
         DataFrame
             DataFrame met alle resultaten in het tabblad
         """
-        file_name = 'Template_PVtool5_0.xlsx'
         file_path = f"{path}/{file_name}"
 
         if self.analysis_type in ['TXT_SH', 'DSS_SH']:
@@ -584,7 +585,7 @@ def add_results_to_dbase(self, path):
             with open(file_path, 'r'):
                 pass
         except FileNotFoundError:
-            raise FileNotFoundError("Er is geen dbase aanwezig onder de naam Template_PVtool5_0.xlsx")
+            raise FileNotFoundError(f"Er is geen dbase aanwezig onder de naam {file_name}")
 
         expected_columns = [
             'PV_RESULTAAT_ID', 'PVNAAM', 'PV_REK', 'PV_TYPE_PROEF', 'PV_ANALYSE',

pv_tool/imports/add_ana_columns.py

@@ -15,8 +15,9 @@ def add_columns(self: Dbase):
     analysis_columns = [
         'ANA_TERREINSPANNING', 'ANA_TXT_MAX_VERTICALE_CONSOLIDATIE_SPANNING',
         'ANA_DSS_MAX_CONSOLIDATIE_SPANNING', 'ANA_TXT_CONSOLIDATIE_TYPE_VOORSTEL',
-        'ANA_TXT_CONSOLIDATIE_TYPE_HANDMATIG', 'ANA_DSS_CONSOLIDATIE_TYPE_VOORSTEL',
-        'ANA_DSS_CONSOLIDATIE_TYPE_HANDMATIG', 'ANA_GRENSSPANNING_PROEF', 'ANA_POP_VELD',
+        'ANA_TXT_CONSOLIDATIE_TYPE_HANDMATIG', 'ANA_TXT_CONSOLIDATIE_TYPE_REKEN',
+        'ANA_DSS_CONSOLIDATIE_TYPE_VOORSTEL', 'ANA_DSS_CONSOLIDATIE_TYPE_HANDMATIG',
+        'ANA_DSS_CONSOLIDATIE_TYPE_REKEN', 'ANA_GRENSSPANNING_PROEF', 'ANA_POP_VELD',
         'ANA_POP_VELD_GEMIDDELD', 'ANA_GRENSSPANNING_VOORSTEL', 'ANA_GRENSSPANNING_HANDMATIG',
         'ANA_GRENSSPANNING_REKEN', 'OCR_TXT', 'OCR_DSS'
     ]
@@ -31,30 +32,32 @@ def add_columns(self: Dbase):
     preserved_data = {}
     for col in preserve_cols:
         if col in df.columns:
-            if col.endswith('_HANDMATIG') and 'CONSOLIDATIE_TYPE' in col:
-                # For consolidation type columns, preserve as string
-                preserved_data[col] = df[col].astype(str).where(df[col].notna(), None)
-            elif col == 'ANA_GRENSSPANNING_HANDMATIG':
-                # For numerical columns, convert to float
+            if col == 'ANA_GRENSSPANNING_HANDMATIG':
+                # Ensure numeric type for grensspanning
                 preserved_data[col] = pd.to_numeric(df[col], errors='coerce')
+            elif 'CONSOLIDATIE_TYPE' in col:
+                # Ensure string type for consolidation types
+                preserved_data[col] = df[col].astype(str).where(df[col].notna(), None)
             else:
-                preserved_data[col] = df[col].copy()
+                preserved_data[col] = df[col]
 
     # Get non-analysis columns
     other_columns = [col for col in df.columns if col not in analysis_columns]
 
-    # Create new DataFrame with correct order
+    # Create new DataFrame with non-analysis columns
     new_df = df[other_columns].copy()
 
-    # Add analysis columns with proper types
+    # Add each analysis column in the specified order
     for col in analysis_columns:
-        if col in preserve_cols and col in preserved_data:
+        if col in preserved_data:
+            # If we have preserved data for this column, use it
             new_df[col] = preserved_data[col]
         else:
+            # Otherwise initialize with appropriate type
             if 'CONSOLIDATIE_TYPE' in col:
-                new_df[col] = None  # Will be filled with 'OC' or 'NC' later
+                new_df[col] = pd.Series(dtype='object')
             else:
-                new_df[col] = pd.Series(dtype='float64')  # For numerical columns
+                new_df[col] = pd.Series(dtype='float64')
 
     self.dbase_df = new_df
 
@@ -90,7 +93,6 @@ def add_txt_consol_type(self: Dbase):
             else 'NC', axis=1
         )
 
-
 def add_dss_consol_type(self: Dbase):
     """Geeft een voorstel voor het consolidatietype van de DSS-proef. Indien de maximale consolidatiespanning niet
     meer dan 30% afwijkt van de terreinspanning wordt het consolidatietype OC aangenomen, anders wordt het
@@ -101,10 +103,29 @@ def add_dss_consol_type(self: Dbase):
             else 'NC', axis=1
         )
 
+def add_txt_consol_type_reken(self: Dbase):
+    """vult de kolom rekenwaarde van consolidatie type: als er een handmatige waarde is ingevuld, wordt deze overgenomen,
+    anders wordt de voorgestelde waarde overgenomen."""
+    def calculate_row(row):
+        if row['ANA_TXT_CONSOLIDATIE_TYPE_HANDMATIG'] and row['ANA_TXT_CONSOLIDATIE_TYPE_HANDMATIG'] is not None and not pd.isna(row['ANA_TXT_CONSOLIDATIE_TYPE_HANDMATIG']):
+            return row['ANA_TXT_CONSOLIDATIE_TYPE_HANDMATIG']
+        else:
+            return row['ANA_TXT_CONSOLIDATIE_TYPE_VOORSTEL']
+    self.dbase_df['ANA_TXT_CONSOLIDATIE_TYPE_REKEN'] = self.dbase_df.apply(calculate_row, axis=1)
+
+def add_dss_consol_type_reken(self: Dbase):
+    """vult de kolom rekenwaarde van consolidatie type: als er een handmatige waarde is ingevuld, wordt deze overgenomen,
+    anders wordt de voorgestelde waarde overgenomen."""
+    def calculate_row(row):
+        if row['ANA_DSS_CONSOLIDATIE_TYPE_HANDMATIG'] and row['ANA_DSS_CONSOLIDATIE_TYPE_HANDMATIG'] is not None and not pd.isna(row['ANA_DSS_CONSOLIDATIE_TYPE_HANDMATIG']):
+            return row['ANA_DSS_CONSOLIDATIE_TYPE_HANDMATIG']
+        else:
+            return row['ANA_DSS_CONSOLIDATIE_TYPE_VOORSTEL']
+    self.dbase_df['ANA_DSS_CONSOLIDATIE_TYPE_REKEN'] = self.dbase_df.apply(calculate_row, axis=1)
 
 def add_grensspanning_proef(self: Dbase):
     """Deze functie bepaalt de grensspanning."""
-    columns = ['CRS_GRENSSPANNING_A', 'SD_ISOTACHE_GRENSSPANNING_A', 'ANA_GRENSSPANNING_HANDMATIG']
+    columns = ['CRS_GRENSSPANNING_A', 'SD_ISOTACHE_GRENSSPANNING_A']
     grens_values = self.dbase_df[columns].max(axis=1)
     self.dbase_df['ANA_GRENSSPANNING_PROEF'] = grens_values
 
@@ -125,32 +146,46 @@ def add_grensspanning_proef(self: Dbase):
 
 
 def calc_pop_veld(self):
-    """Berekend de POP in het veld"""
+    """Berekent de POP in het veld"""
     self.dbase_df['ANA_POP_VELD'] = self.dbase_df['ANA_GRENSSPANNING_PROEF'] - self.dbase_df['ANA_TERREINSPANNING']
 
 
 def calc_pop_average(self):
-    """Berekend de gemiddelde POP van een monster. Aangenomen wordt dat de POP gelijk blijft in de diepte."""
+    """Berekent de gemiddelde POP van een monster. Aangenomen wordt dat de POP gelijk blijft in de diepte."""
     self.dbase_df['ANA_POP_VELD_GEMIDDELD'] = self.dbase_df.groupby('BORING_NUMMER')['ANA_POP_VELD'].transform(
         'mean')
 
 
 def add_grensspanning_voorstel(self: Dbase):
-    self.dbase_df['ANA_GRENSSPANNING_VOORSTEL'] = (self.dbase_df['ANA_TERREINSPANNING'] +
-                                                   self.dbase_df['ANA_POP_VELD_GEMIDDELD'])
+    """Bepaalt de voorgestelde grensspanning alleen wanneer er geen proefwaarde is.
+
+    Als 'ANA_GRENSSPANNING_PROEF' leeg of NaN is, wordt 'ANA_GRENSSPANNING_VOORSTEL'
+    gelijk aan 'ANA_TERREINSPANNING' + 'ANA_POP_VELD_GEMIDDELD'.
+    In alle andere gevallen wordt 'ANA_GRENSSPANNING_VOORSTEL' op None gezet.
+    """
+    mask = self.dbase_df['ANA_GRENSSPANNING_PROEF'].isna()
+    # Standaard None, alleen vullen waar geen proefwaarde is
+    self.dbase_df['ANA_GRENSSPANNING_VOORSTEL'] = None
+    self.dbase_df.loc[mask, 'ANA_GRENSSPANNING_VOORSTEL'] = (
+        self.dbase_df.loc[mask, 'ANA_TERREINSPANNING'] +
+        self.dbase_df.loc[mask, 'ANA_POP_VELD_GEMIDDELD']
+    )
 
 
 def calc_grensspanning_reken(self: Dbase):  # klopt
     """
     Berekent de rekenwaarde van de grensspanning per rij.
     """
     def calculate_row(row):
-        if 'ANA_GRENSSPANNING_HANDMATIG' in row and row['ANA_GRENSSPANNING_HANDMATIG'] is not None:
+        if 'ANA_GRENSSPANNING_HANDMATIG' in row and row['ANA_GRENSSPANNING_HANDMATIG'] is not None and not pd.isna(row['ANA_GRENSSPANNING_HANDMATIG']):
             return row['ANA_GRENSSPANNING_HANDMATIG']
-        elif 'ANA_GRENSSPANNING_VOORSTEL' in row:
+        elif 'ANA_GRENSSPANNING_VOORSTEL' in row and row['ANA_GRENSSPANNING_VOORSTEL'] is not None and not pd.isna(row['ANA_GRENSSPANNING_VOORSTEL']):
             return row['ANA_GRENSSPANNING_VOORSTEL']
+        elif 'ANA_GRENSSPANNING_PROEF' in row:
+            return row['ANA_GRENSSPANNING_PROEF']
+            # TODO check of dit goed gaat
         return None
-    if 'ANA_GRENSSPANNING_HANDMATIG' in self.dbase_df.columns or 'ANA_GRENSSPANNING_VOORSTEL' in self.dbase_df.columns:
+    if 'ANA_GRENSSPANNING_HANDMATIG' in self.dbase_df.columns or 'ANA_GRENSSPANNING_VOORSTEL' in self.dbase_df.columns or 'ANA_GRENSSPANNING_PROEF' in self.dbase_df.columns:
         self.dbase_df['ANA_GRENSSPANNING_REKEN'] = self.dbase_df.apply(calculate_row, axis=1)
     else:
         self.dbase_df['ANA_GRENSSPANNING_REKEN'] = None
@@ -164,10 +199,10 @@ def calculate_row(row):
             terreinspanning = row['ANA_TERREINSPANNING']
 
             if grensspanning_reken is not None and terreinspanning is not None:
-                if row['ANA_TXT_CONSOLIDATIE_TYPE_HANDMATIG'] == 'OC':
-                    return grensspanning_reken / terreinspanning
-                elif row['ANA_TXT_CONSOLIDATIE_TYPE_VOORSTEL'] == 'OC':
+                if row['ANA_TXT_CONSOLIDATIE_TYPE_REKEN'] == 'OC':
                     return grensspanning_reken / terreinspanning
+                # elif row['ANA_TXT_CONSOLIDATIE_TYPE_VOORSTEL'] == 'OC':
+                #     return grensspanning_reken / terreinspanning
                 else:
                     return 1.0
             return None
@@ -187,10 +222,10 @@ def calculate_row(row):
             terreinspanning = row['ANA_TERREINSPANNING']
 
             if grensspanning_reken is not None and terreinspanning is not None:
-                if row['ANA_DSS_CONSOLIDATIE_TYPE_HANDMATIG'] == 'OC':
-                    return grensspanning_reken / terreinspanning
-                elif row['ANA_DSS_CONSOLIDATIE_TYPE_VOORSTEL'] == 'OC':
+                if row['ANA_DSS_CONSOLIDATIE_TYPE_REKEN'] == 'OC':
                     return grensspanning_reken / terreinspanning
+                # elif row['ANA_DSS_CONSOLIDATIE_TYPE_VOORSTEL'] == 'OC':
+                #     return grensspanning_reken / terreinspanning
                 else:
                     return 1.0
             else:

pv_tool/imports/create_dbase.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 import pandas as pd
 import numpy as np
+
+from imports.add_ana_columns import add_txt_consol_type_reken, add_dss_consol_type_reken
 from pv_tool.imports.globals import (PV_TOOL_DBASE_COLUMNS, CLAS_COLUMNS, CRS_COLUMNS, SD_COLUMNS, DSS_COLUMNS,
                                      TXT_COLUMNS)
 from pv_tool.imports.add_ana_columns import (add_columns, add_terreinspanning, add_txt_max_vert_consol_sp,
@@ -57,8 +59,12 @@ def add_ana_columns(self):
     add_txt_consol_type(self)
     add_dss_consol_type(self)
 
+    # Add rekenwaarde consolidation types
+    add_txt_consol_type_reken(self)
+    add_dss_consol_type_reken(self)
+
     # Now that preserved values are in place from add_columns, calculate dependent values
-    add_grensspanning_proef(self)  # Uses preserved ANA_GRENSSPANNING_HANDMATIG
+    add_grensspanning_proef(self)
     calc_pop_veld(self)  # Depends on grensspanning_proef
     calc_pop_average(self)
     add_grensspanning_voorstel(self)