fmu-pem 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

fmu/pem/pem_utilities/pem_config_validation.py

@@ -1,10 +1,11 @@
 import os
 from datetime import date
 from pathlib import Path
-from typing import Any, Dict, List, Literal, Optional, Self, Union
+from typing import Any, Self
 
 import numpy as np
 from pydantic import (
+    AliasChoices,
     BaseModel,
     ConfigDict,
     DirectoryPath,
@@ -15,54 +16,86 @@ from pydantic import (
 from pydantic.json_schema import SkipJsonSchema
 from pydantic_core.core_schema import ValidationInfo
 
+from fmu.datamodels.fmu_results.global_configuration import GlobalConfiguration
 from fmu.pem import INTERNAL_EQUINOR
 
 from .enum_defs import (
     CO2Models,
+    DifferenceAttribute,
+    DifferenceMethod,
     FluidMixModel,
     GasModels,
     MineralMixModel,
     OverburdenPressureTypes,
+    RPMType,
     TemperatureMethod,
-    VolumeFractions,
 )
-from .rpm_models import MineralProperties, PatchyCementRPM, RegressionRPM, TMatrixRPM
+from .fipnum_pvtnum_utilities import (
+    detect_overlaps,
+    input_num_string_to_list,
+)
+from .rpm_models import (
+    FriableRPM,
+    MineralProperties,
+    OptionalField,
+    PatchyCementRPM,
+    PhysicsModelPressureSensitivity,
+    RegressionPressureSensitivity,
+    RegressionRPM,
+    TMatrixRPM,
+)
 
+REGEX_FIPNUM_PVTNUM = r"^(?:\*|(?:\d+(?:-\d+)?)(?:,(?:\d+(?:-\d+)?))*)$"
 
-class NTGFraction(BaseModel):
-    mode: SkipJsonSchema[Literal[VolumeFractions.NTG_SIM]]
-    from_porosity: bool = Field(
-        default=False,
-        description="If True, net-to-gross is estimated from porosity parameter in "
-        "reservoir simulator INIT file. If False, net-to-gross is read "
-        "from the NTG parameter in the INIT file.",
+
+class EclipseFiles(BaseModel):
+    rel_path_simgrid: DirectoryPath = Field(
+        default=Path("../../sim2seis/input/pem"),
+        description="Relative path of the simulation grid",
+    )
+    egrid_file: Path = Field(
+        default=Path("ECLIPSE.EGRID"),
+        description="Name of Eclipse EGRID file",
+    )
+    init_property_file: Path = Field(
+        default=Path("ECLIPSE.INIT"),
+        description="Name of Eclipse INIT file",
+    )
+    restart_property_file: Path = Field(
+        default=Path("ECLIPSE.UNRST"),
+        description="Name of Eclipse UNRST file",
     )
 
+    @model_validator(mode="after")
+    def check_fractions(self) -> Self:
+        for sim_file in [
+            self.egrid_file,
+            self.init_property_file,
+            self.restart_property_file,
+        ]:
+            full_name = self.rel_path_simgrid / sim_file
+            if not full_name.exists():
+                raise FileNotFoundError(f"fraction prop file is missing: {full_name}")
+        return self
+
 
 class FractionFiles(BaseModel):
-    mode: SkipJsonSchema[Literal[VolumeFractions.VOL_FRAC]]
     rel_path_fractions: DirectoryPath = Field(
         default=Path("../../sim2seis/input/pem"),
         description="Directory for volume fractions",
     )
-    fractions_grid_file_name: Path = Field(
-        description="Grid definition of the volume fractions"
-    )
     fractions_prop_file_names: list[Path] = Field(description="Volume fractions")
-    fraction_is_ntg: bool = Field(
-        default=True,
-        description="In case of a single fraction, it can either be a real volume "
-        "fraction or a net-to-gross parameter. If there is more than one fraction, "
-        "they have to represent real volume fractions, and this will be ignored",
+    fractions_are_mineral_fraction: bool = Field(
+        default=False,
+        description="Fractions can either be mineral fractions or volume fractions."
+        "If they are mineral fractions,the sum of fractions and a"
+        "complement is 1.0. If they are volume fractions, the sum of"
+        "fractions, a complement and porosity is 1.0."
+        "Default value is False.",
     )
 
     @model_validator(mode="after")
     def check_fractions(self) -> Self:
-        full_fraction_grid = self.rel_path_fractions / self.fractions_grid_file_name
-        if not full_fraction_grid.exists():
-            raise FileNotFoundError(
-                f"fraction grid file is missing: {full_fraction_grid}"
-            )
         for frac_prop in self.fractions_prop_file_names:
             full_fraction_prop = self.rel_path_fractions / frac_prop
             if not full_fraction_prop.exists():
@@ -72,6 +105,44 @@ class FractionFiles(BaseModel):
         return self
 
 
+class ZoneRegionMatrixParams(BaseModel):
+    fipnum: str = Field(
+        description="Each grid cell in a reservoir model is assigned a FIPNUM "
+        "integer, where each FIPNUM integer represents a combination of zone and "
+        "segment. `fmu-pem` reuses FIPNUM by letting you define the FIPNUM integers "
+        "where a defined rock matrix should be used. Explicit definitions like "
+        "`1-10,15` matches the FIPNUMs "
+        "`1, 2, ..., 10, 15`. By doing it this way you can have different "
+        "rock physics models for e.g. individual zones and segments. "
+        "Leaving this field empty means that all zones and segments are"
+        "treated as one",
+        pattern=REGEX_FIPNUM_PVTNUM,
+    )
+    model: FriableRPM | PatchyCementRPM | TMatrixRPM | RegressionRPM = Field(
+        description="Selection of rock physics model and parameter set",
+    )
+    pressure_sensitivity: bool = Field(
+        default=True,
+        description="All RPM models can be run with or without pressure sensitivity.",
+    )
+    pressure_sensitivity_model: (
+        RegressionPressureSensitivity | PhysicsModelPressureSensitivity | OptionalField
+    ) = Field(
+        default=OptionalField(),
+        description="For most RPM models, it is possible to choose between a "
+        "regression based pressure sensitivity model from plug measurements "
+        "or a theoretical one. For `T Matrix` model a calibrated model is set "
+        "as default, and any model selection in this interface will be disregarded.",
+    )
+
+    @field_validator("model", mode="before")
+    @classmethod
+    def model_check(cls, v: dict, info: ValidationInfo) -> dict:
+        if v["model_name"] not in list(RPMType):
+            raise ValueError(f"unknown model: {v['model_name']}")
+        return v
+
+
 class RockMatrixProperties(BaseModel):
     """Configuration for rock matrix properties.
 
@@ -82,10 +153,10 @@ class RockMatrixProperties(BaseModel):
 
     model_config = ConfigDict(title="Rock matrix properties:")
 
-    model: Union[PatchyCementRPM, TMatrixRPM, RegressionRPM] = Field(
-        description="Selection of parameter set for rock physics model"
+    zone_regions: list[ZoneRegionMatrixParams] = Field(
+        description="Per-zone or -region parameters"
     )
-    minerals: Dict[str, MineralProperties] = Field(
+    minerals: dict[str, MineralProperties] = Field(
         default={
             "shale": {
                 "bulk_modulus": 25.0e9,
@@ -107,29 +178,31 @@ class RockMatrixProperties(BaseModel):
                 "shear_modulus": 45.0e9,
                 "density": 2870.0,
             },
-            "stevensite": {
-                "bulk_modulus": 32.5e9,
-                "shear_modulus": 45.0e9,
-                "density": 2490.0,
-            },
         },
-        description="Standard values are set for shale, quartz, calcite, dolomite and "
-        "stevensite. All settings can be changed by re-defining them in "
-        "the parameter file",
+        description="Define minerals relevant for the field. Default values are set "
+        "for `shale`, `quartz`, `calcite` and `dolomite` (you can't "
+        "delete these minerals, but you can override their default values and/or "
+        "ignore their definition).",
+    )
+    cement: str = Field(
+        default="quartz",
+        description="For the patchy cement model, the cement mineral must be defined, "
+        "and its properties must be defined in the mineral properties' "
+        "dictionary",
     )
-    volume_fractions: NTGFraction | FractionFiles = Field(
-        default=NTGFraction,
-        description=r"Choice of volume fractions based on NTG from "
-        "simulator INIT file or from grid property file ",
+    volume_fractions: FractionFiles = Field(
+        description="Choice of volume fraction files. Volume fractions are defined"
+        "in the geomodel, but they must be resampled to the simulator grid"
+        "when used in PEM",
     )
-    fraction_names: List[str] = Field(
+    fraction_names: list[str] = Field(
         description="Fraction names must match the names in the volume fractions file",
     )
-    fraction_minerals: List[str] = Field(
+    fraction_minerals: list[str] = Field(
         description="The list of minerals matching the fractions' definition. Each "
         "mineral must be defined in the mineral properties dictionary"
     )
-    shale_fractions: List[str] = Field(
+    shale_fractions: list[str] = Field(
         description="List the fractions that should be regarded as non-net reservoir"
     )
     complement: str = Field(
@@ -137,24 +210,56 @@ class RockMatrixProperties(BaseModel):
         "up to 1.0, the remainder is filled with the complement mineral, "
         "e.g. when using net-to-gross instead of volume fractions"
     )
-    pressure_sensitivity: bool = Field(
-        default=True,
-        description="For the RPM models where pressure sensitivity is not part of "
-        "the model, as for friable and patchy cement models, a separate "
-        "pressure sensitivity model, based on plug measurements is added",
-    )
-    cement: str = Field(
-        default="quartz",
-        description="For the patchy cement model, the cement mineral must be defined, "
-        "and its properties must be defined in the mineral properties' "
-        "dictionary",
-    )
     mineral_mix_model: MineralMixModel = Field(
         default="voigt-reuss-hill",
         description="Effective medium model selection: either "
-        "'hashin-shtrikman-average' or 'voigt-reuss-hill'",
+        "`hashin-shtrikman-average` or `voigt-reuss-hill`",
     )
 
+    @field_validator("zone_regions", mode="before")
+    @classmethod
+    def fipnum_check(cls, v: list[dict]) -> list[dict]:
+        """
+        At this point in time we don't have access to the simulator init file,
+        so we just have to guess that it contains all numbers from 1 to the
+        max number given in the strings. Validate that there are no overlaps.
+
+        Validation must be made here, not under individual ZoneRegion objects
+        to get the combined information in all ZoneRegion groups.
+
+        Earlier wildcard symbol was '*'. Empty string (new wildcard) is
+        changed into '*' for backward compatibility
+        """
+        fipnum_strings = [rock["fipnum"] for rock in v]
+        # Enforce single wildcard usage
+        if any(s is None or not str(s).strip() or s == "*" for s in fipnum_strings):
+            if len(v) > 1:
+                raise ValueError(
+                    "Setting wildcard ('*' or empty string) means that "
+                    "all FIPNUM should be treated as one group, no "
+                    "other groups can be specified"
+                )
+            # Enforce old style wildcard
+            v[0]["fipnum"] = "*"
+            return v
+        # Build temporary range to detect overlaps
+        tmp_max = 1
+        tmp_num_array = [1]
+        for num_string in fipnum_strings:
+            num_array = input_num_string_to_list(num_string, tmp_num_array)
+            if tmp_max < max(num_array):
+                tmp_max = max(num_array)
+                tmp_num_array = list(range(1, tmp_max + 1))
+        if detect_overlaps(fipnum_strings, tmp_num_array):
+            raise ValueError(f"Overlaps in group definitions: {fipnum_strings}")
+        return v
+
+    @field_validator("cement", mode="before")
+    def cement_check(cls, v: str, info: ValidationInfo) -> str:
+        if v not in info.data["minerals"]:
+            raise ValueError(f'{__file__}: cement mineral "{v}" not listed in minerals')
+        return v
+
     @field_validator("shale_fractions", mode="before")
     @classmethod
     def shale_fraction_check(cls, v: list, info: ValidationInfo) -> list:
@@ -168,7 +273,7 @@ class RockMatrixProperties(BaseModel):
 
     @field_validator("complement", mode="before")
     @classmethod
-    def complement_fraction_check(cls, v: list, info: ValidationInfo) -> list:
+    def complement_fraction_check(cls, v: str, info: ValidationInfo) -> str:
         if v not in info.data["minerals"]:
             raise ValueError(
                 f'{__file__}: shale fraction mineral "{v}" not listed in fraction '
@@ -176,31 +281,49 @@ class RockMatrixProperties(BaseModel):
             )
         return v
 
-    @field_validator("cement", mode="before")
-    def cement_check(cls, v: list, info: ValidationInfo) -> list:
-        if v not in info.data["minerals"]:
-            raise ValueError(f'{__file__}: cement mineral "{v}" not listed in minerals')
-        return v
-
     @model_validator(mode="after")
-    def mineral_fraction_check(self):
+    def _validate_rock_matrix_properties(self):
         for frac_min in self.fraction_minerals:
             if frac_min not in self.minerals:
                 raise ValueError(
                     f"{__file__}: volume fraction mineral {frac_min} is not defined"
                 )
+        for fipnum_group in self.zone_regions:
+            if fipnum_group.model.model_name != RPMType.T_MATRIX and (
+                fipnum_group.pressure_sensitivity
+                and not fipnum_group.pressure_sensitivity_model
+            ):
+                raise ValueError("a model is required when pressure sensitivity is set")
         return self
 
 
 # Pressure
 class OverburdenPressureTrend(BaseModel):
     type: SkipJsonSchema[OverburdenPressureTypes] = "trend"
+    fipnum: str = Field(
+        description="Each grid cell in a reservoir model is assigned a FIPNUM "
+        "integer. `fmu-pem` reuses FIPNUM by letting you define the FIPNUM "
+        "integers where a given overburden pressure should be used. Explicit "
+        "definitions like `1-10,15` matches the PVTNUMs `1, 2, ..., 10, 15`. "
+        "Leaving this field empty means that all zones and segments are"
+        "treated as one",
+        pattern=REGEX_FIPNUM_PVTNUM,
+    )
     intercept: float = Field(description="Intercept in pressure depth trend")
     gradient: float = Field(description="Gradient in pressure depth trend")
 
 
 class OverburdenPressureConstant(BaseModel):
     type: SkipJsonSchema[OverburdenPressureTypes] = "constant"
+    fipnum: str = Field(
+        description="Each grid cell in a reservoir model is assigned a FIPNUM "
+        "integer. `fmu-pem` reuses FIPNUM by letting you define the FIPNUM "
+        "integers where a given overburden pressure should be used. Explicit "
+        "definitions like `1-10,15` matches the FIPNUMs `1, 2, ..., 10, 15`. "
+        "Leaving this field empty means that all zones and segments are"
+        "treated as one",
+        pattern=REGEX_FIPNUM_PVTNUM,
+    )
     value: float = Field(description="Constant pressure")
 
 
@@ -209,25 +332,27 @@ class Brine(BaseModel):
     salinity: float = Field(
         default=35000.0,
         gt=0.0,
-        description="Salinity of brine, with unit ppm (parts per million)",
+        description="Salinity of brine, with unit `ppm` (parts per million)."
+        "The composition (NaCl, CaCl2, KCl) is of secondary"
+        " importance, unless the salinity is extremely high.",
     )
     perc_na: float = Field(
         ge=0.0,
         le=100.0,
-        default=0.0,
-        description="Percentage of NaCl in the dissolved salts in brine",
+        default=100.0,
+        description="Percentage of `NaCl` in the dissolved salts in brine",
     )
     perc_ca: float = Field(
         ge=0.0,
         le=100.0,
-        default=100.0,
-        description="Percentage of CaCl in the dissolved salts in brine",
+        default=0.0,
+        description="Percentage of `CaCl2` in the dissolved salts in brine",
     )
     perc_k: float = Field(
         ge=0.0,
         le=100.0,
         default=0.0,
-        description="Percentage of KCl in the dissolved salts in brine",
+        description="Percentage of `KCl` in the dissolved salts in brine",
     )
 
     @model_validator(mode="after")
@@ -262,14 +387,8 @@ class Oil(BaseModel):
         default=865.0,
         ge=700,
         le=950,
-        description="Oil density in kg/m^3 at standard conditions, i.e. 15.6 deg. C "
-        "and 101 kPa",
-    )
-    gor: float = Field(
-        default=123.0,
-        ge=0.0,
-        description="Gas-oil volume ratio in liter/liter when the oil it brought to "
-        "the surface at standard conditions",
+        description="Oil density in `kg/m³` at standard conditions, i.e. `15.6 °C`"
+        "and `101 kPa`",
     )
 
 
@@ -280,22 +399,23 @@ class Gas(BaseModel):
         le=0.87,
         description="Gas gravity is a ratio of gas molecular weight to that air",
     )
-    model: GasModels = Field(
+    model: SkipJsonSchema[GasModels] = Field(
         default="HC2016",
-        description="Gas model is one of 'Global', 'Light', or 'HC2016' (default)",
+        description="Gas model is one of `Global`, `Light`, or `HC2016` (default)",
     )
 
 
 class MixModelWood(BaseModel):
-    method: SkipJsonSchema[FluidMixModel] = "wood"
+    method: FluidMixModel = "wood"
 
 
 class MixModelBrie(BaseModel):
-    method: SkipJsonSchema[FluidMixModel] = "brie"
+    method: FluidMixModel = "brie"
     brie_exponent: float = Field(
         default=3.0,
-        description="Brie exponent selects the mixing curve shape, from linear mix to "
-        "harmonic mean",
+        description="Brie exponent selects the mixing curve shape, from linear mix "
+        "(exponent = 2.0) to approximate harmonic mean for high values "
+        "(exponent > 10.0). Default value is 3.0.",
     )
 
 
@@ -308,57 +428,60 @@ class TemperatureFromSim(BaseModel):
     type: SkipJsonSchema[TemperatureMethod] = "from_sim"
 
 
-# Note that CO2 does not require a separate definition here, as it's properties only
-# depend on temperature and pressure
-class Fluids(BaseModel):
+class SalinityFromSim(BaseModel):
+    enabled: bool = False
+
+    def __bool__(self):
+        return self.enabled
+
+    model_config = ConfigDict(title="Salinity from SIM")
+
+
+class PVTZone(BaseModel):
+    pvtnum: str = Field(
+        description="Each grid cell in a reservoir model is assigned a PVTNUM "
+        "integer. `fmu-pem` reuses PVTNUM by letting you define the PVTNUM "
+        "integers where a given fluid definition should be used. Explicit "
+        "definitions like `1-10,15` matches the PVTNUMs `1, 2, ..., 10, 15`. "
+        "Leaving this field empty means that all PVTNUM zones are treated as one",
+        pattern=REGEX_FIPNUM_PVTNUM,
+    )
     brine: Brine = Field(
-        description="Brine model parameters",
+        description="Brine model parameters.",
     )
-    oil: Oil = Field(description="Oil model parameters")
+    oil: Oil = Field(
+        description="Oil model parameters. Note that GOR (gas-oil ratio) is read from"
+        " eclipse restart file"
+    )
+    # Note that CO2 does not require a separate definition here, as it's properties only
+    # depend on temperature and pressure
     gas: Gas = Field(description="Gas model parameters")
-    condensate: Oil | None = Field(
-        default=None,
+    condensate: OptionalField | Oil = Field(
         title="Condensate properties",
-        description="Condensate is defined by the same set of parameters as oil, "
-        "optional setting for condensate cases",
-    )
-    fluid_mix_method: MixModelBrie | MixModelWood = Field(
-        default=MixModelBrie,
-        description="Selection between Wood's or Brie model. Wood's model gives more "
-        "radical response to adding small amounts of gas in brine or oil",
-    )
-    temperature: ConstantTemperature | TemperatureFromSim = Field(
-        description="In most cases it is sufficient with a constant temperature "
-        "setting for the reservoir. If temperature is modelled in the "
-        "simulation model, it is preferred to use that"
-    )
-    salinity_from_sim: bool = Field(
-        default=False,
-        description="In most cases it is sufficient with a constant salinity "
-        "setting for the reservoir, unless there is large contrast"
-        "between formation water and injected water. If salinity is "
-        "modelled in the simulation model, it is preferred to use that",
+        description="Condensate model requires a similar set of parameters as"
+        "the oil model, this is an optional setting for condensate"
+        " cases",
     )
     gas_saturation_is_co2: bool = Field(
         default=False,
         description="Eclipse model only provides one parameter for gas saturation, "
-        "this flag sets the gas type to be CO2 instead of hydrocarbon gas",
+        "this flag sets the gas type to be CO₂ instead of hydrocarbon gas",
     )
     calculate_condensate: bool = Field(
         default=False,
         description="Flag to control if gas should be modelled with condensate model, "
-        "in which case RV parameter must be present in the Eclipse model",
+        "in which case `RV` parameter must be present in the Eclipse model",
     )
-    gas_z_factor: float = Field(
+    gas_z_factor: SkipJsonSchema[float] = Field(
         default=1.0,
         description="Factor for deviation from an ideal gas in terms of volume change "
         "as a function of temperature and pressure",
     )
-    co2_model: CO2Models = Field(
-        default="span_wagner",
-        description="Selection of model for CO2 properties, 'span_wagner' equation "
-        "of state model or 'flag'. Note that access to flag model depends "
-        "on licence",
+    # Temperature may be set per zone
+    temperature: ConstantTemperature | TemperatureFromSim = Field(
+        description="In most cases it is sufficient with a constant temperature "
+        "setting for the reservoir. If temperature is modelled in the "
+        "simulation model, it is preferred to use that"
     )
 
     @model_validator(mode="after")
@@ -370,53 +493,116 @@ class Fluids(BaseModel):
         return self
 
 
-def possible_date_string(date_strings: List[str]) -> bool:
-    """
-    Validate a list of date strings in YYYYMMDD format.
+class Fluids(BaseModel):
+    pvt_zones: list[PVTZone] = Field(
+        description="Define fluid parameters for each phase in each PVT zone "
+        "or group of PVT zones"
+    )
+    fluid_mix_method: MixModelWood | MixModelBrie = Field(
+        default_factory=MixModelWood,
+        description="Selection between Wood's or Brie model. Wood's model gives more "
+        "radical response to adding small amounts of gas in brine or oil",
+    )
+    # Handling of salinity will be a common factor, not zone-based
+    salinity_from_sim: SalinityFromSim = Field(
+        default_factory=SalinityFromSim,
+        description="In most cases it is sufficient with a constant salinity "
+        "setting for the reservoir, unless there is large contrast"
+        "between formation water and injected water. If salinity is "
+        "modelled in the simulation model, it is preferred to use that",
+    )
+    co2_model: CO2Models = Field(
+        default="span_wagner",
+        description="Selection of model for CO₂ properties, `span_wagner` equation "
+        "of state model or `flag`. Note that access to flag model depends "
+        "on licence",
+    )
 
-    Args:
-        date_strings: List of strings to validate
+    @field_validator("pvt_zones", mode="before")
+    @classmethod
+    def pvtnum_check(cls, v: list[dict]) -> list[dict]:
+        """
+        At this point in time we don't have access to the simulator init file,
+        so we just have to guess that it contains all numbers from 1 to the
+        max number given in the strings. Validate that there are no overlaps.
+
+        Validation must be made here, not under individual PVTZone objects
+        to get the combined information in all PVTZone groups.
+
+        Earlier wildcard symbol was '*'. Empty string (new wildcard) is
+        changed into '*' for backward compatibility
+        """
+        pvtnum_strings = [zone["pvtnum"] for zone in v]
+        # Enforce single wildcard usage
+        if any(s is None or not str(s).strip() or s == "*" for s in pvtnum_strings):
+            if len(v) > 1:
+                raise ValueError(
+                    "Setting wildcard ('*' or empty string) means that "
+                    "all PVTNUM should be treated as one group, no "
+                    "other groups can be specified"
+                )
+            # Enforce old style wildcard
+            v[0]["pvtnum"] = "*"
+            return v
+        # Build temporary range to detect overlaps
+        tmp_max = 1
+        tmp_num_array = [1]
+        for num_string in pvtnum_strings:
+            nums = input_num_string_to_list(num_string, tmp_num_array)
+            m = max(nums)
+            if m > tmp_max:
+                tmp_max = m
+                tmp_num_array = list(range(1, tmp_max + 1))
+        if detect_overlaps(pvtnum_strings, tmp_num_array):
+            raise ValueError(f"Overlaps in PVT zone definitions: {pvtnum_strings}")
+        return v
 
-    Returns:
-        bool: True if all strings are valid dates
 
-    Raises:
-        ValueError: If any string is not a valid date in YYYYMMDD format
-    """
-    for date_string in date_strings:
-        if len(date_string) != 8:
-            raise ValueError(
-                f"Invalid date format: '{date_string}' must be exactly 8 characters"
-            )
-        try:
-            date(
-                year=int(date_string[0:4]),
-                month=int(date_string[4:6]),
-                day=int(date_string[6:]),
-            )
-        except ValueError:
-            raise ValueError(
-                f"Invalid date: '{date_string}' must be a valid date in YYYYMMDD format"
-            )
-    return True
+def date_to_string(date_obj: date) -> str:
+    return date_obj.strftime(format="%Y%m%d")
 
 
-class FromGlobal(BaseModel):
-    grid_model: str
-    seis_dates: List[str]
-    diff_dates: List[List[str]]
-    global_config: Dict[str, Any]
+class SeismicSurvey(BaseModel):
+    ecldate: list[str]
+    time: dict[str, str] | None = None
+    depth: dict[str, str] | None = None
 
-    @field_validator("seis_dates", mode="before")
-    def check_date_string(cls, v: List[str]) -> List[str]:
-        possible_date_string(v)
-        return v
+    @field_validator("ecldate", mode="before")
+    def convert_ecldate_strings(cls, v: list[date]) -> list[str]:
+        return [date_to_string(date) for date in v]
 
-    @field_validator("diff_dates", mode="before")
-    def check_diffdate_string(cls, v: List[List[str]]) -> List[List[str]]:
-        for ll in v:
-            possible_date_string(ll)
-        return v
+
+class SeismicSection(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    templatecube_4d: str = Field(
+        validation_alias=AliasChoices("4d_templatecube", "templatecube_4d"),
+        serialization_alias="4d_templatecube",
+    )
+    real_4d_cropped_path: Path
+    real_4d: dict[str, SeismicSurvey]
+
+
+class FromGlobal(BaseModel):
+    grid_model: str
+    mod_dates: list[str] | None = None
+    mod_diffdates: list[list[str]] | None = None
+    obs_dates: list[str] | None = None
+    obs_diffdates: list[list[str]] | None = None
+    seismic: SeismicSection
+    global_config: GlobalConfiguration
+
+    @field_validator("mod_dates", "obs_dates", mode="before")
+    def make_date_strings(cls, v: list[date]) -> list[str] | None:
+        if v:
+            return [date_to_string(date) for date in v]
+        return None
+
+    @field_validator("mod_diffdates", "obs_diffdates", mode="before")
+    def make_diffdate_strings(cls, v: list[list[str]]) -> list[list[str]] | None:
+        if v:
+            return [[date_to_string(date) for date in diffdate] for diffdate in v]
+        return None
 
 
 class PemPaths(BaseModel):
@@ -443,11 +629,6 @@ class PemPaths(BaseModel):
         "file for the FMU workflow",
         frozen=True,
     )
-    rel_ntg_grid_path: SkipJsonSchema[DirectoryPath] = Field(
-        default=Path("../../sim2seis/input/pem"),
-        description="This is the relative path to the ntg grid file. If the "
-        "ntg_calculation_flag is False, it is disregarded, cfr. fractions",
-    )
     rel_path_simgrid: SkipJsonSchema[DirectoryPath] = Field(
         default=Path("../../sim2seis/input/pem"),
         description="Directory for eclipse simulation grid",
@@ -484,33 +665,43 @@ class PemConfig(BaseModel):
         description="Default path settings exist, it is possible to override them, "
         "mostly relevant for input paths",
     )
+    eclipse_files: EclipseFiles
     rock_matrix: RockMatrixProperties = Field(
         description="Settings related to effective mineral properties and rock "
         "physics model",
     )
+    alternative_fipnum_name: SkipJsonSchema[str] = Field(
+        default="fipnum".upper(),  # Should be upper case
+        description="If it is needed to deviate from Equinor standard to use "
+        "FIPNUM for zone/region class indicator",
+    )
     fluids: Fluids = Field(
-        description="Settings related to fluid composition",
+        description="Values for brine, oil and gas are required, but only the fluid "
+        "phases that are present in the simulation model will in practice be used in "
+        "calculation of effective fluid properties. You can have multiple fluid PVT "
+        "definitions, representing e.g. different regions and/or zones in your model.",
     )
-    pressure: OverburdenPressureTrend | OverburdenPressureConstant = Field(
-        default=OverburdenPressureTrend,
+    pressure: list[OverburdenPressureTrend | OverburdenPressureConstant] = Field(
+        default_factory=OverburdenPressureTrend,
         description="Definition of overburden pressure model - constant or trend",
     )
     results: Results = Field(
         description="Flags for saving results of the PEM",
     )
-    diff_calculation: Dict[str, List[Literal["ratio", "diff", "diffpercent"]]] = Field(
+    diff_calculation: dict[DifferenceAttribute, list[DifferenceMethod]] = Field(
         description="Difference properties of the PEM can be calculated for the dates "
-        "in the Eclipse UNRST file. The settings decide which parameters "
+        "in the Eclipse `.UNRST` file. The settings decide which parameters "
         "difference properties will be generated for, and what kind of "
-        "difference calculation is run - normal difference, percent "
-        "difference or ratio"
+        "difference calculation is run - normal difference (`diff`), percent "
+        "difference (`diffperc`) or ratio (`ratio`). Multiple kinds of differences "
+        "can be estimated for each parameter"
     )
     global_params: SkipJsonSchema[FromGlobal | None] = Field(
         default=None,
     )
 
     @field_validator("paths", mode="before")
-    def check_and_create_directories(cls, v: Dict, info: ValidationInfo):
+    def check_and_create_directories(cls, v: dict, info: ValidationInfo):
         if v is None:
             return PemPaths()
         for key, path in v.items():
@@ -522,14 +713,15 @@ class PemConfig(BaseModel):
         return v
 
     @field_validator("diff_calculation", mode="before")
-    def to_list(cls, v: Dict) -> Dict:
-        v_keys = list(v.keys())
+    def to_list(cls, v: dict) -> dict:
+        v_keys = [key.lower() for key in v]
         v_val = list(v.values())
         for i, val_item in enumerate(v_val):
             if not isinstance(val_item, list):
                 v_val[i] = [
                     val_item,
                 ]
+            v_val[i] = [v.lower() for v in v_val[i]]
         return dict(zip(v_keys, v_val))
 
     # Add global parameters used in the PEM