def _eff_perm_calc(self, flow_pores):
r"""
Calculates effective permeability of each phase using StokesFlow
algorithm with updated multiphase physics models to account for the
multiphase flow.
The direction of the flow is defined by flow_pores.
All variables except for the rate in darcy's law will be the same in
relative permeability ratio. The effective rate represents the
effective permeability in the nominator of relative permeability
ratio.
Parameters
----------
flow_pores: numpy array
Boundary pores that will have constant value boundary condition in
StokesFlow algorithm. First element is the inlet face (pores) for flow
of invading phase through porous media. Second element is the outlet
face (pores).
Output: array [Kewp, Kenwp]
The value of effective permeability of defending (if there is any) and
invading phase in the direction that is defined by flow_pores.
Note: To account for multiphase flow, multiphase physics model is added
and updated in each saturation (saturation is related to
the presence of another phase). Here, the conduit_hydraulic conductance
is used as the conductance required by stokes flow algorithm.
"""
network = self.project.network
self._regenerate_models()
if self.settings['wp'] is not None:
wp = self.project[self.settings['wp']]
St_mp_wp = StokesFlow(network=network, phase=wp)
St_mp_wp.setup(conductance='throat.conduit_hydraulic_conductance')
St_mp_wp.set_value_BC(pores=flow_pores[0], values=1)
St_mp_wp.set_value_BC(pores=flow_pores[1], values=0)
St_mp_wp.run()
Kewp = np.sum(abs(St_mp_wp.rate(pores=flow_pores[1])))
self.project.purge_object(obj=St_mp_wp)
else:
Kewp = None
pass
nwp = self.project[self.settings['nwp']]
St_mp_nwp = StokesFlow(network=network, phase=nwp)
St_mp_nwp.set_value_BC(pores=flow_pores[0], values=1)
St_mp_nwp.set_value_BC(pores=flow_pores[1], values=0)
St_mp_nwp.setup(conductance='throat.conduit_hydraulic_conductance')
St_mp_nwp.run()
Kenwp = np.sum(abs(St_mp_nwp.rate(pores=flow_pores[1])))
Kenwp = Kenwp
self.project.purge_object(obj=St_mp_nwp)
return [Kewp, Kenwp]
def _abs_perm_calc(self, phase, flow_pores):
r"""
Calculates absolute permeability of the medium using StokesFlow
algorithm. The direction of flow is defined by flow_pores. This
permeability is normalized by variables in darcy's law other than
the rate.
Parameters
----------
phase: phase object
The phase for which the flow rate is calculated.
flow_pores: numpy array
Boundary pores that will have constant value boundary condition to in
StokesFlow algorithm. First element is the inlet face (pores) for flow
of invading phase through porous media. Second element is the outlet
face (pores).
Output: array [Kwp, Knwp]
The value of absolute permeability of defending (if there is any) and
invadin phase in the direction that is defined by flow_pores.
Note: Absolute permeability is not dependent to the phase, but here
we just need to calculate the rate instead of all variables that are
contributing to the darcy's law.
"""
network = self.project.network
St_p = StokesFlow(network=network, phase=phase)
St_p.set_value_BC(pores=flow_pores[0], values=1)
St_p.set_value_BC(pores=flow_pores[1], values=0)
St_p.run()
val = np.sum(abs(St_p.rate(pores=flow_pores[1])))
K_abs = val
self.project.purge_object(obj=St_p)
return K_abs
def run(self):
r"""
Execute the diffusion simulations in the principle directions.
"""
phase = GenericPhase(network=self.network)
phase['pore.viscosity'] = 1.0
phase['throat.viscosity'] = 1.0
mod = models.physics.hydraulic_conductance.hagen_poiseuille
for geom in self.project.geometries().values():
phys = GenericPhysics(network=self.network,
phase=phase, geometry=geom)
phys.add_model(propname='throat.hydraulic_conductance', model=mod)
inlet = self.network.pores(self.settings['inlet'])
outlet = self.network.pores(self.settings['outlet'])
perm = StokesFlow(network=self.project.network, phase=phase)
perm.set_value_BC(pores=inlet, values=1)
perm.set_value_BC(pores=outlet, values=0)
perm.run()
phase.update(perm.results())
K = self._calc_eff_prop(inlets=inlet, outlets=outlet,
domain_area=self.settings['area'],
domain_length=self.settings['length'],
rates=perm.rate(pores=inlet),
prop_diff=1)
return K