ps.brine

ps.brine.CapillaryPressureFactor

ps.brine.CapillaryPressureFactor(*, rows) -> None

The factor on the capillary pressure as precipitated salt fills the pores.

ps.brine.CapillaryPressureFactor(rows=[(0.8, 1.2), (1.0, 1.0)]) raises the capillary pressure by a fifth where salt has taken a fifth of the porosity.

Each row is a porosity factor (a fraction) and the positive factor there, two rows at least, the porosity factors strictly rising. It writes PCFACT (PROPS), one table; ps.load refuses a deck that states PCFACT. ps.brine.Package(capillary_pressure_factor=...) holds it, at physics/brine/capillary_pressure_factor, and the model refuses it without the package’s gas_water_vaporization (salt.pcfact.requires_gas_water_vaporization) and a gas that carries water (salt.pcfact.requires_vaporized_water).

Rows: (porosity_factor, capillary_pressure_factor). State each row as a sequence in this order, or as a mapping by column name.

ps.brine.Package

ps.brine.Package(*, pvt: WaterPVT | None = None, initial_salinity=None, solubility: SaltSolubility | None = None, permeability_reduction: PermeabilityReduction | None = None, initial_precipitated_salt=None, gas_water_vaporization: VaporizationBySalt | None = None, capillary_pressure_factor: CapillaryPressureFactor | None = None) -> None

The brine and its salt: salinity-dependent water PVT, initial salt and precipitation.

ps.brine.Package(pvt=ps.brine.WaterPVT(reference_pressure=250.0, rows=[(0.0, 1.02, 4.5e-05, 0.5, 0.0), (4.0, 1.01, 4.0e-05, 0.6, 0.0)])) lets the water’s salt change its PVT; ps.Model(physics=[...]) holds it, at physics/brine.

It switches the brine on (BRINE in RUNSPEC). pvt is the salinity-dependent water PVT (PVTWSALT) and initial_salinity the salt concentration at the start (SALTVD by depth, or SALT cell by cell; a uniform salt content is ps.storage.Package(salinity=)’s). The salt precipitates when any of its tables is stated (PRECSALT): solubility (SALTSOL), the porosity’s permeability_reduction (PERMFACT) and capillary_pressure_factor (PCFACT), initial_precipitated_salt (SALTPVD by depth, or SALTP cell by cell) and the salt-dependent vaporized water gas_water_vaporization (RWGSALT, with VAPWAT). The precipitation tables are written only where the water flows. ps.load reads each card back but RWGSALT and PCFACT, and refuses a deck that states them. A well injects salt with ps.wells.InjectedStream(well=..., salinity=...) (WSALT; beside a polymer, the polymer’s card).

ps.brine.PermeabilityReduction

ps.brine.PermeabilityReduction(*, rows) -> None

The permeability left as precipitated salt fills the pores.

ps.brine.PermeabilityReduction(rows=[(0.8, 0.5), (1.0, 1.0)]) halves the permeability where salt has taken a fifth of the porosity.

Each row is a porosity factor (the porosity the salt leaves over the initial porosity) and the permeability factor there, both fractions, the porosity factors strictly rising. It writes PERMFACT (PROPS), one table, which ps.load reads back. ps.brine.Package(permeability_reduction=...) holds it, at physics/brine/permeability_reduction.

Rows: (porosity_factor, permeability_factor). State each row as a sequence in this order, or as a mapping by column name.

ps.brine.PrecipitatedSaltVsDepth

ps.brine.PrecipitatedSaltVsDepth(*, rows) -> None

The precipitated salt at the start, against depth.

ps.brine.PrecipitatedSaltVsDepth(rows=[(2000.0, 0.0), (2500.0, 0.01)]) starts the region with no salt at 2000 and a volume fraction of 0.01 at 2500.

Each row is a depth in the model’s units and the pore volume fraction the precipitated salt fills there, the depths strictly rising. It writes SALTPVD (SOLUTION), which ps.load reads back. ps.brine.Package(initial_precipitated_salt=...) holds it, at physics/brine/initial_precipitated_salt.

Rows: (depth, precipitated_salt). State each row as a sequence in this order, or as a mapping by column name.

ps.brine.SalinityVsDepth

ps.brine.SalinityVsDepth(*, rows) -> None

The water’s initial salt concentration against depth.

ps.brine.SalinityVsDepth(rows=[(2000.0, 1.0), (2500.0, 1.5)]) starts the water at a salinity of 1 at 2000 and 1.5 at 2500.

Each row is a depth and the salt concentration there, in the model’s units, the depths strictly rising. It writes SALTVD (SOLUTION), which ps.load reads back. ps.brine.Package(initial_salinity=...) holds it, at physics/brine/initial_salinity.

Rows: (depth, salinity). State each row as a sequence in this order, or as a mapping by column name.

ps.brine.SaltSolubility

ps.brine.SaltSolubility(*, rows) -> None

The salt’s solubility limit in the water and the density of the salt that precipitates.

rows hold the salt’s solubility limit in the water (the salinity past which salt precipitates) and the density of the precipitated salt, in the model’s units, the limits strictly rising.

ps.brine.SaltSolubility(rows=[(6.1, 2170.0)]): salt precipitates past a salinity of 6.1 in the one pvt region, at a density of 2170.

It writes the rows as one record of SALTSOL (PROPS), the first PVT region’s, which ps.load reads back as one table; Flow reads only the record’s first row. ps.brine.Package(solubility=...) holds it, at physics/brine/solubility.

Rows: (solubility_limit, salt_density). State each row as a sequence in this order, or as a mapping by column name.

ps.brine.UniformSalinity

ps.brine.UniformSalinity(*, basis: Literal['molality', 'liquid_mole_fraction'], value: ScalarPropertyInput) -> None

One salt content for the whole reservoir’s brine, by molality or by mole fraction.

ps.brine.UniformSalinity(basis="molality", value=1.5) starts every cell’s water at 1.5 mol of salt per kg.

value is non-negative, and a mole fraction is at most 1. It writes SALINITY (molality) or SALTMF (liquid mole fraction) (PROPS), which ps.load reads back. ps.storage.Package(salinity=...) holds it, at physics/storage/salinity: the storage correlations read it. ps.brine.Package(initial_salinity=...) refuses it.

ps.brine.VaporizationBySalt

ps.brine.VaporizationBySalt(*, rows) -> None

The water the gas carries against the gas pressure and the brine’s salinity.

rows hold a gas pressure, a salinity and the vaporized water-gas ratio, the card’s own flat shape with its node column first, as ps.pvt.LiveOil holds its families: each pressure’s rows together and the pressures rising, the salinities rising within one pressure.

ps.brine.VaporizationBySalt(rows=[(100.0, 0.0, 1.0e-4), (100.0, 4.0, 8.0e-5), (200.0, 0.0, 2.0e-4), (200.0, 4.0, 1.6e-4)]) lets the gas carry a fifth less water at a salinity of 4 than in fresh water, at each pressure.

Each number is in the model’s units. It writes RWGSALT (PROPS); ps.load refuses a deck that states RWGSALT. The package switches the gas’s vaporized water on beside it. ps.brine.Package(gas_water_vaporization=...) holds it, at physics/brine/gas_water_vaporization.

Rows: (pressure, salinity, vaporized_water_gas_ratio). State each row as a sequence in this order, or as a mapping by column name.

ps.brine.WaterPVT

ps.brine.WaterPVT(*, reference_pressure: ScalarPropertyInput, surface_reference_salinity: Optional[ScalarPropertyInput] = None, rows) -> None

The water’s PVT against its salt concentration, at a reference pressure.

ps.brine.WaterPVT(reference_pressure=250.0, rows=[(0.0, 1.02, 4.5e-05, 0.5, 0.0), (4.0, 1.01, 4.0e-05, 0.6, 0.0)]) gives fresh and salty water each its formation volume factor, compressibility and viscosity at 250.

Each row is a salt concentration, the water’s formation volume factor, compressibility, viscosity and viscosibility there, in the model’s units, the concentrations strictly rising. It writes PVTWSALT (PROPS), which ps.load reads back, and the fluid’s own water table is then not written. ps.brine.Package(pvt=...) holds it, at physics/brine/pvt.

Rows: (salinity, fvf, compressibility, viscosity, viscosibility). State each row as a sequence in this order, or as a mapping by column name.