Thermal rework

src/JutulDarcy.jl

@@ -152,7 +152,6 @@ module JutulDarcy
     include("porousmedia_grids.jl")
     include("utils.jl")
     include("interpolation.jl")
-    include("flux.jl")
     # Definitions for multiphase flow
     include("multiphase.jl")
     include("variables/variables.jl")
@@ -167,6 +166,7 @@ module JutulDarcy
     # Wells etc.
     include("facility/facility.jl")
 
+    include("flux.jl")
     include("porousmedia.jl")
     # MRST inputs and test cases that use MRST input
     # and .DATA file simulation

src/blackoil/blackoil.jl

@@ -105,7 +105,7 @@ function cnv_mb_errors_bo(r, Φ, b, dt, rhoS, ::Val{N}) where N
     return (Tuple(cnv), Tuple(mb))
 end
 
-function handle_alternate_primary_variable_spec!(init, found, sys::StandardBlackOilSystem)
+function handle_alternate_primary_variable_spec!(init, found, rmodel, sys::StandardBlackOilSystem)
     # Internal utility to handle non-trivial specification of primary variables
     nph = number_of_phases(sys)
     @assert haskey(init, :Pressure)
@@ -137,18 +137,29 @@ function handle_alternate_primary_variable_spec!(init, found, sys::StandardBlack
         F_rv = sys.rv_max
         if has_disgas(sys)
             rs = init[:Rs]
+            rs_var = rmodel[:Rs]
         else
             rs = zeros(nc)
+            rs_var = nothing
         end
         if has_vapoil(sys)
-            rv = init[:Rs]
+            rv = init[:Rv]
+            rv_var = rmodel[:Rv]
         else
             rv = zeros(nc)
+            rv_var = nothing
         end
         so = @. 1.0 - sw - sg
-        bo = map(
-            (w,  o,   g, r,  v, p) -> blackoil_unknown_init(F_rs, F_rv, w, o, g, r, v, p),
-            sw, so, sg, rs, rv, pressure)
+        bo = Vector{BlackOilX{Float64}}()
+        sizehint!(bo, nc)
+        for i in 1:nc
+            reg_rs = region(rs_var, i)
+            reg_rv = region(rv_var, i)
+            F_rs_i = table_by_region(F_rs, reg_rs)
+            F_rv_i = table_by_region(F_rv, reg_rv)
+            v = blackoil_unknown_init(F_rs_i, F_rv_i, sw[i], so[i], sg[i], rs[i], rv[i], pressure[i])
+            push!(bo, v)
+        end
         init[:BlackOilUnknown] = bo
         push!(found, :BlackOilUnknown)
     end

src/blackoil/variables/variables.jl

@@ -24,6 +24,10 @@ struct Rs{F, R} <: ScalarVariable
     regions::R
 end
 
+@inline function region(pv::Rs, cell)
+    return region(pv.regions, cell)
+end
+
 function Rs(rs_max::F; regions::R = nothing) where {F, R}
     return Rs{F, R}(rs_max, regions)
 end
@@ -49,6 +53,10 @@ function Rv(rv_max::F; regions::R = nothing) where {F, R}
     return Rv{F, R}(rv_max, regions)
 end
 
+@inline function region(pv::Rv, cell)
+    return region(pv.regions, cell)
+end
+
 function Jutul.subvariable(v::Rv, map::FiniteVolumeGlobalMap)
     c = map.cells
     regions = Jutul.partition_variable_slice(v.regions, c)

src/deck_support.jl

@@ -1,14 +1,37 @@
 @jutul_secondary function update_deck_viscosity!(mu, μ::DeckPhaseViscosities, model, Pressure, ix)
     pvt, reg = μ.pvt, μ.regions
-    @inbounds for ph in axes(mu, 1)
-        pvt_ph = pvt[ph]
-        for i in ix
-            p = Pressure[i]
+    @inbounds for i in ix
+        p = Pressure[i]
+        for ph in axes(mu, 1)
+            pvt_ph = pvt[ph]
             @inbounds mu[ph, i] = viscosity(pvt_ph, reg, p, i)
         end
     end
 end
 
+@jutul_secondary function update_deck_viscosity!(mu, μ::DeckPhaseViscosities{<:Any, Ttab, <:Any}, model, Pressure, Temperature, ix) where Ttab<:DeckThermalViscosityTable
+    pvt, reg = μ.pvt, μ.regions
+    for i in ix
+        r_i = region(μ, i)
+        p = Pressure[i]
+        T = Temperature[i]
+        for ph in axes(mu, 1)
+            pvt_ph = pvt[ph]
+            pvt_thermal = table_by_region(μ.thermal.visc_tab[ph], r_i)
+            p_ref = table_by_region(μ.thermal.p_ref[ph], r_i)
+            mu_thermal = pvt_thermal(T)
+            if isfinite(p_ref)
+                # We have pressure dependence in addition to temperature
+                # dependence.
+                mu_p = viscosity(pvt_ph, reg, p, i)
+                mu_ref = viscosity(pvt_ph, reg, p_ref, i)
+                mu_thermal *= mu_p/mu_ref
+            end
+            mu[ph, i] = mu_thermal
+        end
+    end
+end
+
 @jutul_secondary function update_deck_density!(rho, ρ::DeckPhaseMassDensities, model, Pressure, ix)
     rhos = reference_densities(model.system)
     pvt, reg = ρ.pvt, ρ.regions
@@ -23,6 +46,33 @@ end
     end
 end
 
+@jutul_secondary function update_deck_density!(rho, ρ::DeckPhaseMassDensities{<:Any, <:WATDENT, <:Any}, model, Pressure, Temperature, ix)
+    rhos = reference_densities(model.system)
+    pvt, reg = ρ.pvt, ρ.regions
+    phases = get_phases(model.system)
+    # Note immiscible assumption
+    for i in ix
+        r_i = region(ρ, i)
+        p = Pressure[i]
+        T = Temperature[i]
+        for ph in axes(rho, 1)
+            rhos_ph = rhos[ph]
+            pvt_ph = pvt[ph]
+            if phases[ph] == AqueousPhase()
+                T_ref, c1, c2 = ρ.watdent.tab[r_i]
+                pvtw = pvt_ph.tab[r_i]
+                p_ref = pvtw.p_ref
+                B_pref = 1.0/shrinkage(pvt_ph, reg, p_ref, i)
+                Δp = pvtw.b_c*(p - p_ref)
+                ΔT = T - T_ref
+                B_w = B_pref*(1.0 - Δp)*(1.0 + c1*ΔT + c2*ΔT^2)
+                rho[ph, i] = rhos_ph/B_w
+            else
+                rho[ph, i] = rhos_ph*shrinkage(pvt_ph, reg, p, i)
+            end
+        end
+    end
+end
 
 @jutul_secondary function update_deck_shrinkage!(b, ρ::DeckShrinkageFactors, model, Pressure, ix)
     pvt, reg = ρ.pvt, ρ.regions

src/deck_types.jl

@@ -8,13 +8,15 @@ abstract type AbstractTablePVT <: AbstractReservoirDeckTable end
 Secondary variable used to evaluate viscosities when a case is generated from a
 input file. Typically not instantiated in user scripts.
 """
-struct DeckPhaseViscosities{T, R} <: DeckPhaseVariables
+struct DeckPhaseViscosities{T, M, R} <: DeckPhaseVariables
     pvt::T
+    thermal::M
     regions::R
-    function DeckPhaseViscosities(pvt; regions = nothing)
+    function DeckPhaseViscosities(pvt; regions = nothing, thermal = nothing)
         check_regions(regions)
         pvt_t = Tuple(pvt)
-        new{typeof(pvt_t), typeof(regions)}(pvt_t, regions)
+        thermal::Union{Nothing, DeckThermalViscosityTable}
+        new{typeof(pvt_t), typeof(thermal), typeof(regions)}(pvt_t, thermal, regions)
     end
 end
 
@@ -24,13 +26,15 @@ end
 Secondary variable used to evaluate densities when a case is generated from a
 input file. Typically not instantiated in user scripts.
 """
-struct DeckPhaseMassDensities{T, R} <: DeckPhaseVariables
+struct DeckPhaseMassDensities{T, W, R} <: DeckPhaseVariables
     pvt::T
+    watdent::W
     regions::R
-    function DeckPhaseMassDensities(pvt; regions = nothing)
+    function DeckPhaseMassDensities(pvt; regions = nothing, watdent = nothing)
         check_regions(regions)
         pvt_t = Tuple(pvt)
-        new{typeof(pvt_t), typeof(regions)}(pvt_t, regions)
+        watdent::Union{Nothing, WATDENT}
+        new{typeof(pvt_t), typeof(watdent), typeof(regions)}(pvt_t, watdent, regions)
     end
 end
 
@@ -40,13 +44,15 @@ DeckShrinkageFactors(pvt, regions = nothing)
 Secondary variable used to evaluate shrinkage factors when a case is generated
 from a input file. Typically not instantiated in user scripts.
 """
-struct DeckShrinkageFactors{T, R} <: DeckPhaseVariables
+struct DeckShrinkageFactors{T, W, R} <: DeckPhaseVariables
     pvt::T
+    watdent::W
     regions::R
-    function DeckShrinkageFactors(pvt; regions = nothing)
+    function DeckShrinkageFactors(pvt; watdent = nothing, regions = nothing)
         check_regions(regions)
         pvt_t = Tuple(pvt)
-        new{typeof(pvt_t), typeof(regions)}(pvt_t, regions)
+        watdent_t = region_wrap(watdent, regions)
+        new{typeof(pvt_t), typeof(watdent_t), typeof(regions)}(pvt_t, watdent, regions)
     end
 end
 
@@ -376,6 +382,52 @@ function PVTW(pvtw::AbstractArray)
     PVTW{N, T}(ct)
 end
 
+struct DeckThermalViscosityTable{T, V}
+    visc_tab::T
+    p_ref::V
+    rs_ref::V
+end
+
+function DeckThermalViscosityTable(props::AbstractDict, pvt, water, oil, gas)
+    visc_tab = []
+    function tab_to_interp(tab)
+        return map(x -> get_1d_interpolator(x[:, 1] .+ 273.15, x[:, 2]), tab)
+    end
+    if water
+        push!(visc_tab, tab_to_interp(props["WATVISCT"]))
+    end
+    if oil
+        push!(visc_tab, tab_to_interp(props["OILVISCT"]))
+    end
+    if gas
+        push!(visc_tab, tab_to_interp(props["GASVISCT"]))
+    end
+    visc_tab = Tuple(visc_tab)
+    if haskey(props, "VISCREF")
+        vref = props["VISCREF"]
+        rs_ref = map(x -> x[2], vref)
+        p_ref = map(x -> x[1], vref)
+    else
+        nreg = length(first(visc_tab))
+        rs_ref = fill(NaN, nreg)
+        p_ref = fill(NaN, nreg)
+    end
+    return DeckThermalViscosityTable(visc_tab, p_ref, rs_ref)
+end
+
+
+struct WATDENT{N, T} <: AbstractTablePVT
+    tab::NTuple{N, T}
+end
+
+function WATDENT(watdent::AbstractArray)
+    c = map(rec ->  (T = rec[1], c1 = rec[2], c2 = rec[3]), watdent)
+    ct = Tuple(c)
+    N = length(ct)
+    T = typeof(ct[1])
+    return WATDENT{N, T}(ct)
+end
+
 struct PVCDO{N, T} <: AbstractTablePVT
     tab::NTuple{N, T}
 end

src/facility/controls.jl

@@ -39,7 +39,11 @@ function Jutul.update_before_step_multimodel!(storage_g, model_g::MultiModel, mo
         pos = get_well_position(model.domain, key)
         q_t[pos] = valid_surface_rate_for_control(q_t[pos], newctrl)
         if changed
-            cfg.limits[key] = merge(cfg.limits[key], as_limit(newctrl.target))
+            if isnothing(cfg.limits[key])
+                cfg.limits[key] = as_limit(newctrl.target)
+            else
+                cfg.limits[key] = merge(cfg.limits[key], as_limit(newctrl.target))
+            end
         end
     end
     cfg.step_index = current_step

src/facility/cross_terms.jl

@@ -284,6 +284,15 @@ function Base.show(io::IO, d::ReservoirFromWellThermalCT)
     n = length(d.CI)
     print(io, "ReservoirFromWellThermalCT ($n connections)")
 end
+
+function Jutul.subcrossterm(ct::ReservoirFromWellThermalCT, ctp, m_t, m_s, map_res::FiniteVolumeGlobalMap, ::TrivialGlobalMap, partition)
+    (; CI, WI, reservoir_cells, well_cells) = ct
+    rc = map(
+        c -> Jutul.local_cell(c, map_res),
+        reservoir_cells)
+    return ReservoirFromWellThermalCT(copy(CI), copy(WI), rc, copy(well_cells))
+end
+
 struct WellFromFacilityThermalCT <: Jutul.AdditiveCrossTerm
     well::Symbol
 end
@@ -305,27 +314,35 @@ function update_cross_term_in_entity!(out, i,
     qT += 0*bottom_hole_pressure(state_well)
 
     cell = well_top_node()
-    H = well_top_node_enthalpy(ctrl, state_well, cell)
+    H = well_top_node_enthalpy(ctrl, well, state_well, cell)
     out[] = -qT*H
 end
 
-function well_top_node_enthalpy(ctrl::InjectorControl, state_well, cell)
-    heat_capacity = state_well.FluidHeatCapacity[cell]
+function well_top_node_enthalpy(ctrl::InjectorControl, model, state_well, cell)
     p = state_well.Pressure[cell]
-    density = ctrl.mixture_density
+    # density = ctrl.mixture_density
     T = ctrl.temperature
-    nph = size(state_well.Saturations, 1)
-    H = 0
-    for ph in 1:nph
-        C = state_well.FluidHeatCapacity[ph, cell]
-        dens = state_well.PhaseMassDensities[ph, cell]
-        S = state_well.Saturations[ph, cell]
-        H += S*(C*T + p/dens)
+    H_w = ctrl.enthalpy
+    if ismissing(H_w)
+        H = 0.0
+        for ph in axes(state_well.Saturations, 1)
+            # Define it via the volume weighted internal energy
+            S = state_well.Saturations[ph, cell]
+            dens = state_well.PhaseMassDensities[ph, cell]
+            C = state_well.ComponentHeatCapacity[ph, cell]
+            H += S*(C*T + p/dens)
+        end
+    elseif H_w isa Real
+        H = H_w
+    elseif H_w isa Function
+        H = H_w(p, T)
+    else
+        error("InjectorControl.enthalpy must be missing, a real or a function (p, T).")
     end
     return H
 end
 
-function well_top_node_enthalpy(ctrl, state_well, cell)
+function well_top_node_enthalpy(ctrl, model, state_well, cell)
     H = state_well.FluidEnthalpy
     S = state_well.Saturations
     H_w = 0.0