F/dynamic probing (#14)

* Add support for Dynamic Probing (DP)
* Add alternative codes for penetration rate (B, C), torque (V, AB) and ramming (S, SA).

Author: josteinl

.gitattributes

@@ -0,0 +1,24 @@
+# This .gitattributes file primarily made for the test files. Some test files are deliberatly constructed with wrong
+# line endings for test purposes and should be specified here.
+
+# Don't let git modify these:
+*.[Cc][Pp][Tt] binary
+*.[Dd][Tt][Rr] binary
+*.[Hh][Ff][Aa] binary
+*.[Jj][Bb][123Tt] binary
+*.[Vv][Ii][Mm] binary
+*.[Ss][Tt][Dd] binary
+*.[Tt][Oo][Tt] binary
+
+# std, cpt, tot and dtr files are specified as eol=crlf
+*.[Cc][Pp][Tt] text eol=crlf
+*.[Dd][Tt][Rr] text eol=crlf
+*.[Ss][Tt][Dd] text eol=crlf
+*.[Tt][Oo][Tt] text eol=crlf
+
+# Shell scripts may not contain crlf
+*.sh -crlf
+
+# Yaml file should not contain crlf
+*.yaml -crlf
+*.yml  -crlf

CHANGES.md

@@ -1,5 +1,11 @@
 # NGI Python SGF Parser Package
 
+_2024-08-22_
+
+Version 0.0.1b5
+
+Add support for Dynamic Probing (DP).
+
 _2024-08-08_
 
 Version 0.0.1b4

poetry.lock

@@ -15,7 +15,7 @@ exclude = '''
 
 [tool.poetry]
 name = "sgf-parser"
-version = "0.0.1b4"
+version = "0.0.1b5"
 description = "Parser for the Swedish Geotechnical Society / Svenska Geotekniska Föreningen (SGF) data format"
 license = "MIT"
 authors = ["Jostein Leira <jostein@leira.net>"]

pyproject.toml

@@ -3,6 +3,7 @@
 from sgf_parser.models.types import StopCode, ParseState
 from sgf_parser.models.method import Method, MethodData
 from sgf_parser.models.method_cpt import MethodCPT, MethodCPTData
+from sgf_parser.models.method_dp import MethodDP, MethodDPData
 from sgf_parser.models.method_dt import MethodDT, MethodDTData
 from sgf_parser.models.method_rp import MethodRP, MethodRPData
 from sgf_parser.models.method_srs import MethodSRS, MethodSRSData

src/sgf_parser/models/__init__.py

@@ -14,6 +14,7 @@
 class MethodData(BaseModel, abc.ABC):
     @classmethod
     def _fix_malformed_data(cls, code: str) -> str | None:
+        """Wrong K codes as "4,0" will be converted to "40"."""
         return re.sub("[^0-9]", "", code)
 
     @classmethod
@@ -53,20 +54,19 @@ def comment_code_format(cls, data: Any) -> Any:
         """
         if isinstance(data, dict):
             if "K" in data and data["K"] is not None:
-                
                 # We want to interpret K as a stop code (with integer value)
                 # sometimes K is a string with e.g. "SAND", in that case we move it to T
                 K_is_digit = any(char.isdigit() for char in data["K"])
-                
+
                 if not K_is_digit:
                     # move it to T (remarks column)
                     if "T" not in data:
                         data["T"] = data["K"]
                     else:
                         data["T"] = f"{data['K']}, {data['T']}"
-                    
+
                     del data["K"]
-                
+
                 else:
                     # we identify the most important stop code, and move the rest to T
                     _code, _rest = cls._extract_comment_code(data)
@@ -83,6 +83,52 @@ def comment_code_format(cls, data: Any) -> Any:
     comment_code: int | None = Field(None, alias="K")
     remarks: str | None = Field(None, alias="T")
 
+    @model_validator(mode="before")
+    @classmethod
+    def penetration_rate_validator(cls, data: Any) -> Any:
+        """
+        If the penetration rate (B mm/s) is not set, but C is (s/0.2m) then convert C to B and set B.
+        """
+        if isinstance(data, dict):
+            if ("B" not in data or data["B"] is None) and "C" in data and data["C"] is not None:
+                # B is not set, but C is, convert C to B
+                try:
+                    data["B"] = 200 / float(data["C"])
+                except (ZeroDivisionError, ValueError):
+                    data["B"] = None
+
+        return data
+
+    @model_validator(mode="before")
+    @classmethod
+    def torque_validator(cls, data: Any) -> Any:
+        """
+        If the torque V (kNm) is not set, but AB is (Nm) then convert AB to V and set V.
+        """
+        if isinstance(data, dict):
+            if ("V" not in data or data["V"] is None) and "AB" in data and data["AB"] is not None:
+                try:
+                    data["V"] = float(data["AB"]) / 1000
+                except ValueError:
+                    data["V"] = None
+
+        return data
+
+    @model_validator(mode="before")
+    @classmethod
+    def ramming_validator(cls, data: Any) -> Any:
+        """
+        If the ramming S (blows/0.2m) is not set, but SA is (blows/0.1m) then convert SA to S and set S.
+        """
+        if isinstance(data, dict):
+            if ("S" not in data or data["S"] is None) and "SA" in data and data["SA"] is not None:
+                try:
+                    data["S"] = float(data["SA"]) * 2
+                except ValueError:
+                    data["S"] = None
+
+        return data
+
     def __repr__(self):
         return f"<{self.__class__.__name__} {self.depth}>"
 

src/sgf_parser/models/method.py

@@ -0,0 +1,101 @@
+from decimal import Decimal
+from typing import Literal, Any
+
+from pydantic import Field, model_validator, computed_field, AliasChoices
+
+from sgf_parser.models import MethodData, Method, MethodType
+from sgf_parser.models.types import DPType
+
+
+class MethodDPData(MethodData):
+    """
+    Dynamic Probing Data
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    depth: Decimal = Field(..., alias="D", description="Depth (m)")
+
+    penetration_force: Decimal | None = Field(None, alias="A", description="Penetration force (kN)")
+    penetration_rate: Decimal | None = Field(
+        None,
+        validation_alias=AliasChoices(
+            "B",  # mm/s
+            "C",  # s/0.2m
+        ),
+        description="Penetration rate (mm/s)",
+    )
+    torque: Decimal | None = Field(
+        None,
+        validation_alias=AliasChoices(
+            "V",  # kNm
+            "AB",  # Nm
+        ),
+        description="Torque (kNm)",
+    )
+    ramming: Decimal = Field(None, validation_alias=AliasChoices("S", "SA"), description="Ramming (Blow/0.2 m)")
+    rotation_rate: Decimal | None = Field(None, alias="R", description="Rotation rate (rpm)")
+    increased_rotation_rate: bool | None = Field(None, alias="AQ")
+
+
+class MethodDP(Method):
+    """
+    Dynamic Probing (Swedish Hejarsondering)
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    name: str = "DP"
+    method_type: Literal[MethodType.DP] = MethodType.DP
+    method_data_type: type[MethodDPData] = MethodDPData
+
+    type: DPType
+
+    predrilling_depth: Decimal = Field(Decimal("0"), alias="HO")
+
+    cone_type: str | None = Field(
+        None, validation_alias=AliasChoices("KonTyp", "HN", "HC"), description="Type of cone used."
+    )
+    cushion_type: str | None = Field(None, alias="DynTyp", description="Type of impact cushion used.")
+    use_damper: bool | None = Field(None, alias="Gummi", description="Use of damper.")
+
+    method_data: list[MethodDPData] = []
+
+    @computed_field
+    def depth_top(self) -> Decimal | None:
+        if not self.method_data:
+            return None
+
+        return min(method_data.depth for method_data in self.method_data)
+
+    @computed_field
+    def depth_base(self) -> Decimal | None:
+        if not self.method_data:
+            return None
+
+        return max(method_data.depth for method_data in self.method_data)
+
+    @model_validator(mode="before")
+    @classmethod
+    def set_operation(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            if "HM" in data and data["HM"] is not None:
+                data["type"] = {
+                    "8": DPType.DPSH_A,
+                    "108A": DPType.DPSH_A,
+                    "108B": DPType.DPL,
+                    "108C": DPType.DPM,
+                    "108D": DPType.DPH,
+                    "108E": DPType.DPSH_B,
+                }[data["HM"]]
+
+        return data
+
+    @computed_field
+    def stopcode(self) -> int | None:
+        if not self.method_data:
+            return None
+
+        return self.method_data[-1].comment_code

src/sgf_parser/models/method_dp.py

@@ -7,9 +7,10 @@ class MethodType(enum.StrEnum):
     """
 
     CPT = "CPT"
+    DP = "DP"
+    DT = "DT"
     RP = "RP"
     SRS = "SRS"
     SVT = "SVT"
     TOT = "TOT"
     WST = "WST"
-    DT = "DT"

src/sgf_parser/models/method_type.py

@@ -134,3 +134,16 @@ class Operation(enum.StrEnum):
 
     MANUAL = "MANUAL"
     MECHANICAL = "MECHANICAL"
+
+
+class DPType(enum.StrEnum):
+    """
+    DP Type (Dynamic Probing)
+
+    """
+
+    DPSH_A = "DPSH-A"
+    DPL = "DPL"
+    DPM = "DPM"
+    DPH = "DPH"
+    DPSH_B = "DPSH-B"

src/sgf_parser/models/types.py

@@ -11,7 +11,7 @@
 # to contain only a-z and A-Z. In addition, the Geotech AB extension,
 # have date fields (key "%") with no "=" separating the key from the
 # value...
-_RE_FIELD_SEP = re.compile(r",(?:(?=[a-zA-Z])|(?=%))")
+_RE_FIELD_SEP = re.compile(r",(?=[a-zA-Z%])")
 
 
 class Parser:
@@ -26,6 +26,12 @@ class Parser:
         "102": models.MethodWST,
         "107A": models.MethodCPT,
         "107B": models.MethodCPT,
+        "8": models.MethodDP,
+        "108A": models.MethodDP,
+        "108B": models.MethodDP,
+        "108C": models.MethodDP,
+        "108D": models.MethodDP,
+        "108E": models.MethodDP,
         "23": models.MethodRP,
         "24": models.MethodTOT,
         "12": models.MethodSRS,