Polish text in notebook

JulesBlm · JulesBlm · commit 2cf3c06ddb1f · 2025-05-26T14:15:21.000+02:00
diff --git a/examples/a2-maastricht-gef/a2_maastricht_gef.py b/examples/a2-maastricht-gef/a2_maastricht_gef.py
@@ -18,46 +18,71 @@
 
 import marimo
 
-__generated_with = "0.13.2"
+__generated_with = "0.13.11"
 app = marimo.App(width="medium")
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        # GEF Data for A2 Tunnel Maastricht
+    # GEF Data for A2 Tunnel Maastricht
 
-        This notebook demonstrates how to 
+    This notebook demonstrates how to 
 
-        1. Read in GEF files using [pygef](https://cemsbv.github.io/pygef/)
-        1. Use `bedrock-ge` to load Ground Investigation (GI) data from these GEF files
-        1. Convert that data into a standardized GI database using `bedrock-ge`
-        1. Transform the GI data into 3D GIS features with proper coordinates and geometry ([OGC Simple Feature Access](https://en.wikipedia.org/wiki/Simple_Features))
-        1. Explore and analyze the GI data using:
-          * Interactive filtering with Pandas dataframes
-          * Visualization on interactive maps with GeoPandas
-        1. Export the processed GI database to a GeoPackage file for use in GIS software
+    1. Read in Ground Investigation (GI) data from [GEF files]() using [pygef](https://cemsbv.github.io/pygef/)
+    1. Use `bedrock-ge` to convert that data into a standardized GI database using `bedrock-ge`
+    1. Transform the GI data into 3D spatial features with proper coordinates and geometry ([OGC Simple Feature](https://en.wikipedia.org/wiki/Simple_Features))
+    1. Explore and analyze the GI data using interactive filtering with Pandas DataFrames and interactive visualization on a map with GeoPandas.
+    1. Export the processed GI database to a GeoPackage file for use in other software, like QGIS.
 
-        ## Context
+    <details>
+        <summary>What are GEF files?</summary>
+        <p>
+            <abbr>Geotechnical Exchange Format (GEF)</abbr> is a standardized, text-based format designed to facilitate the reliable exchange and archiving of geotechnical investigation data, particularly CPT results, across different organizations and software platforms. GEF can also be used for other types of soil tests and borehole data. It is widely used in the Netherlands in ground investigration.
+        </p>
+    </details>
 
-        The Koning Willem-Alexander Tunnel is a double-deck tunnel for motorized traffic in the Dutch city of Maastricht. The tunnel has a length of 2.5 kilometers (lower tunnel tubes) and 2.3 kilometers (upper tunnel tubes).
+    <details>
+        <summary>What is a DataFrame?</summary>
+        <p>
+          A DataFrame is like a spreadsheet, it is a two-dimensional data structure that holds data like a table with rows and columns.
+        </p>
+    </details>
 
-        The tunnel has moved the old A2 highway underground. It previously formed a barrier for the city and slowed traffic.
+    ## Context
 
-        ### Geology
+    The Koning Willem-Alexander Tunnel is a double-deck tunnel for motorized traffic in the Dutch city of Maastricht. The tunnel has a length of 2.5 kilometers (lower tunnel tubes) and 2.3 kilometers (upper tunnel tubes).
 
+    The tunnel has moved the old A2 highway underground. This highway previously formed a barrier for the city and slowed traffic.
 
-        The soil here consists of a coarse gravel layer with limestone limestone with karst phenomena underneath. There are also faults.
-        Zwerfkeien
+    ### Geology
 
-        [Geotechniek-en-Risicos bij A2 Maastricht](https://www.cob.nl/magazines-brochures-en-nieuws/verdieping/verdieping-sept2012/geotechniek-en-risicos-bij-a2-maastricht/)
-        [Source](https://archisarchief.cultureelerfgoed.nl/Archis2/Archeorapporten/24/AR26905/RAP%202709_4130060%20Maastricht%20A2-traverse.pdf)
+    The uppermost layer consists of topsoil, clay, and loam, with a thickness of about 2 to 4 meters. These soft Holocene deposits are attributed to the Boxtel Formation, laid down by the Meuse River, as the tunnel is situated in a former river arm.
 
-        ## Ground Investigation Data
+    Beneath the surface layer lies an approximately 8-meter-thick gravel deposit. This gravel acts as a significant aquifer and was a key factor in the groundwater management strategies required for the tunnel construction.
 
-        The GI data was downloaded from [Dinoloket](https://www.dinoloket.nl/ondergrondgegevens), a platform where you can view and request data and models from TNO and BRO about the subsurface of the Netherlands.
-        """
+    Below the gravel lies a fissured limestone layer belonging to the Maastricht Formation (mergel). This layer is a very weak, porous, sandy, shallow marine limestone, often weathered, and includes chalk and calcarenite components.
+
+    The limestone is relatively young and shallow, resulting in low compaction and cementation. Its mechanical strength is highly variable and generally low, especially when saturated with groundwater.
+
+    Extensive geophysical surveys and borehole investigations were conducted to map the subsurface, identify faults, flint layers, and assess the risk of cavities within the limestone. While faults were detected, no significant cavities were found.
+
+    The stability of the excavation pit was monitored in real-time, with groundwater levels and pressures carefully controlled to prevent collapse or excessive deformation of the pit walls.
+
+    Due to the high permeability of the gravel and fissured limestone, groundwater management was a major challenge. Over 500 wells were drilled to depths of up to 32 meters for dewatering, and a reinfiltration system was implemented to return nearly all pumped water to the ground, protecting local buildings and ecosystems.
+
+    #### Sources
+
+    * [Tunnel A2 Maastricht: Groundwater Management with DSI System](https://www.tunnel-online.info/en/artikel/tunnel-a2-maastricht-groundwater-management-with-dsi-system-1564115.html)
+    * [Geotechniek-en-Risicos bij A2 Maastricht](https://www.cob.nl/magazines-brochures-en-nieuws/verdieping/verdieping-sept2012/geotechniek-en-risicos-bij-a2-maastricht/)
+    * [Laboratory Tests on Dutch Limestone (Mergel) ](https://onepetro.org/ISRMEUROCK/proceedings-abstract/EUROCK15/All-EUROCK15/ISRM-EUROCK-2015-072/43534)
+    * [Eduard van Herk en Bjorn Vink](https://a2maastricht.nl/application/files/3315/2060/1222/Interview_Eduard_van_Herk_en_Bjorn_Vink.pdf)
+
+    ## Ground Investigation Data
+
+    The GI data was downloaded from [Dinoloket](https://www.dinoloket.nl/ondergrondgegevens), a platform where you can view and request data and models from TNO and BRO about the subsurface of the Netherlands.
+    """
     )
     return
 
@@ -106,25 +131,35 @@ def _(boreholes, index, pygef):
 def _(mo):
     mo.md(
         r"""
-        ## Converting multiple GEF files to a relational database
+    ## Converting multiple GEF files to a relational database
 
-        First, let's check in which projected coordinate system the provided data was recorded
-        """
+    Rather than dealing with a folder of files, we would like to combine all files into a single database with spatial information. This is where Bedrock comes in.
+
+    ### Relational Databases
+
+    A [relational database](https://observablehq.com/blog/databases-101-basics-data-analysts#what-are-relational-databases) is a database with multiple tables that are linked to each other with relations. This type of database is ideal for storing GI data, given its [hierarchical structure](https://bedrock.engineer/docs/#hierarchical-nature-of-gi-data).
+
+    In Python it's convenient to represent a relational database as a dictionary of DataFrame's.
+
+    ### Coordinated Reference System (CRS)
+
+    First, let's check in which projected coordinate system the provided data was recorded.
+    """
     )
     return
 
 
 @app.cell
 def _(boreholes):
-    boreholes[1].delivered_location.srs_name
+    code = {bore.delivered_location.srs_name for bore in boreholes}.pop()
+    orig_epsg_code = code.split("EPSG::")[-1]
+    orig_crs = f"EPSG:{orig_epsg_code}"
+    orig_crs
     return
 
 
 @app.cell
-def _(boreholes):
-    code = {bore.delivered_location.srs_name for bore in boreholes}.pop()
-    # epsg_code = code.split("EPSG::")[-1]
-    # crs = f"EPSG:{epsg_code}"
+def _():
     crs = "EPSG:7415"
     return (crs,)
 
@@ -133,10 +168,11 @@ def _(boreholes):
 def _(mo):
     mo.md(
         r"""
-        EPSG:28992 is [Rijksdriehoekscoördinaten](https://nl.wikipedia.org/wiki/Rijksdriehoeksco%C3%B6rdinaten), also called Amersfoort / RD New.
+    The data is in EPSG:28992, which is the [Rijksdriehoekscoördinaten (NL)](https://nl.wikipedia.org/wiki/Rijksdriehoeksco%C3%B6rdinaten) system, also called "Amersfoort / RD New". This reference system does not include elevation.
 
-        EPSG:7415 is with Amersfoort / RD New + NAP height. ie with elevation which we need for 3D geometry
-        """
+    To represent GI data spatially in 3D geometry we need a CRS with elevation. That's why we will use
+    EPSG:7415 Amersfoort / RD New + NAP height.
+    """
     )
     return
 
@@ -149,7 +185,7 @@ def _():
 
 @app.cell
 def _():
-    project_uid = "Maastricht A2"
+    project_uid = "Maastricht A2 tunnel"
     return (project_uid,)
 
 
@@ -181,6 +217,18 @@ def process_data(bore):
     return df
 
 
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+    Here, we create a new DataFrame for locations and remap the GEF keys to follow Bedrock's conventions. 
+    We need to map `alias` to `location_source_id` and `delivered_vertical_position_offset` to `ground_level_elevation` for example.
+    We also need to create a **unique identifier** and add `project_uid` as a key to relate it the project.
+    """
+    )
+    return
+
+
 @app.cell
 def _(boreholes, pd, project_uid):
     locations_df = pd.DataFrame([
@@ -208,9 +256,31 @@ def _(calculate_location_gis_geometry, crs, locations_df):
     return (locations,)
 
 
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+    ## Displaying the GI locations on a map
+
+    Rather than multiple tables (DataFrames) and soil profiles, we would like see an overview of what this ground investigation covers. It's **spatial** data after all, let's view it in a spatial context.
+
+    ### Web Mapping Caveats
+
+    Web-mapping tools are rarely capable of handling geometry in non-WGS84 coordinates. Additionally, vertical lines are not visible when looking at a map from straight above. That's why use `create_lon_lat_height_table` to create points in the WGS84 CRS so we can view the locations of the boreholes.
+    """
+    )
+    return
+
+
 @app.cell
 def _(create_lon_lat_height_table, crs, locations):
-    create_lon_lat_height_table(locations, crs).explore()
+    create_lon_lat_height_table(locations, crs).explore(marker_kwds={"radius":5})
+    return
+
+
+@app.cell
+def _(mo):
+    mo.md(r"""Here we create a DataFrame for the In-Situ data of all locations. To relate to locations and the project we add foreign keys.""")
     return
 
 
@@ -236,6 +306,12 @@ def _(insitu):
     return
 
 
+@app.cell
+def _(mo):
+    mo.md(r"""In-situ data is also spatial data. It has a location, a depth and a height. We can also turn it into spatial data using Bedrock's `calculate_in_situ_gis_geometry` """)
+    return
+
+
 @app.cell
 def _(calculate_in_situ_gis_geometry, crs, insitu, locations):
     insitu_geo = calculate_in_situ_gis_geometry(insitu, locations, crs)
@@ -252,12 +328,12 @@ def _(insitu_geo):
 def _(mo):
     mo.md(
         r"""
-        ## Saving the GI geospatial database as a GeoPackage (.gpkg)
+    ## Saving the GI geospatial database as a GeoPackage (.gpkg)
 
-        Finally, lets write it to an actual geospatial database file, so we can share our GI data with others. For example, to reuse it in other notebooks, create dashboards, access the GI data in QGIS or ArcGIS, and more...
+    Finally, we'll write it to an actual geospatial database file, a GeoPackage, so we can share our GI data with others, for example, to reuse it in other computational notebooks, create dashboards, access the GI data in QGIS or ArcGIS, and more...
 
-        A GeoPackage is an <abbr title="Open Geospatial Consortium">OGC-standardized</abbr> extension of SQLite (a relational database in a single file, .sqlite or .db) that allows you to store any type of GIS data (both raster as well as vector data) in a single file that has the .gpkg extension. Therefore, many (open-source) GIS software packages support GeoPackage!
-        """
+    A GeoPackage is an <abbr title="Open Geospatial Consortium">OGC-standardized</abbr> extension of SQLite (a relational database in a single file, .sqlite or .db) that allows you to store any type of GIS data (both raster as well as vector data) in a single file that has the .gpkg extension. Therefore, many (open-source) GIS software packages support GeoPackage!
+    """
     )
     return
 
