def __init__(self,
phase=None,
geometry=None,
pores=None,
throats=None,
settings=None,
**kwargs):
self.settings = SettingsAttr(PhysicsSettings, settings)
super().__init__(settings=self.settings, **kwargs)
network = self.project.network
if network:
if phase is not None:
self.set_phase(phase=phase, mode='add')
if geometry is None:
if (pores is None) and (throats is None):
logger.warning(
'No Geometry provided, ' + self.name +
' will not be associated with any locations')
else:
self.set_locations(pores=pores,
throats=throats,
mode='add')
else:
if phase is None:
logger.warning('Cannot associate with a geometry unless ' +
'a phase is also given')
else:
self.set_geometry(geometry=geometry)
def __init__(self, *args, **kwargs):
from openpnm.utils import SettingsAttr
name = kwargs.pop('name', None)
super().__init__(*args, **kwargs)
self.settings = SettingsAttr()
ws[name] = self # Register self with workspace
self.settings['uuid'] = str(uuid.uuid4())
def __init__(self, settings=None, **kwargs):
self.settings = SettingsAttr(GenericAlgorithmSettings, settings)
super().__init__(settings=self.settings, **kwargs)
if self.project:
self['pore.all'] = np.ones(self.project.network.Np, dtype=bool)
self['throat.all'] = np.ones(self.project.network.Nt, dtype=bool)
def __init__(self, phases=[], settings=None, **kwargs):
self.settings = SettingsAttr(MultiPhaseSettings, settings)
super().__init__(settings=self.settings, **kwargs)
self['pore.occupancy.all'] = np.zeros(self.Np, dtype=float)
self['throat.occupancy.all'] = np.zeros(self.Nt, dtype=float)
# Pressure/temperature must come from constituent phases
self.pop('pore.temperature', None)
self.pop('pore.pressure', None)
# Add a dummy model for assembling the global parition
# coefficients array. The dummy model only accepts 'target' and
# kwargs. When a binary partition coefficient is added to the
# MultiPhase, we manually append the binary partition coefficient
# propname as a keyword argument to this dummy model, so that our
# dependency handler is notified of this dependency!
partition_coef_global = self.settings['partition_coef_prefix'] + ".all"
self.add_model(propname=partition_coef_global, model=_dummy)
# Add supplied phases to phases dict and initialize occupancy to 0
self.add_phases(phases)
logger.warning(
'MultiPhase is a beta feature. Functionality may change!')
def _get_settings(self):
"""Dictionary containing object settings."""
if self._settings is None:
self._settings = SettingsAttr()
if self._settings_docs is not None:
self._settings.__dict__['__doc__'] = self._settings_docs
return self._settings
def test_standard_initialization(self):
class S1:
r"""
This is a docstring
"""
a = 1
b = 2
d = TypedList(types=[str])
sets1 = SettingsAttr(S1)
assert "This is a docstring" in sets1.__doc__
def __init__(self, components=[], settings=None, **kwargs):
self.settings = SettingsAttr(GenericMixtureSettings, settings)
super().__init__(settings=self.settings, **kwargs)
# Add any supplied phases to the phases list
for comp in components:
self.set_component(comp)
self.set_mole_fraction(comp, np.nan)
self['pore.mole_fraction.all'] = np.nan
logger.warning('Mixtures are a beta feature and functionality may ' +
'change in future versions')
def test_adding_new_attr_type_is_enforced(self):
class S4:
r"""
This is a docstring
"""
a = 2
b = 3.5
sets4 = SettingsAttr(S4)
sets4.c = 1.5
with pytest.raises(Exception):
sets4.c = "string"
def test_initial_None(self):
class S8:
r"""
This is a docstring
"""
a = 1
b = None
sets8 = SettingsAttr(S8)
sets8.b = 2.2
assert sets8.b == 2.2
with pytest.raises(Exception):
sets8.b = 'str'
def __init__(self, settings=None, **kwargs):
self.settings = SettingsAttr(PhaseSettings, settings)
super().__init__(settings=self.settings, **kwargs)
# If project has a network object, adjust pore and throat array sizes
network = self.project.network
if network:
self['pore.all'] = ones((network.Np, ), dtype=bool)
self['throat.all'] = ones((network.Nt, ), dtype=bool)
# Set standard conditions on the fluid to get started
self['pore.temperature'] = 298.0
self['pore.pressure'] = 101325.0
def __init__(self, pores=[], throats=[], settings=None, **kwargs):
self.settings = SettingsAttr(GeometrySettings, settings)
super().__init__(settings=self.settings, **kwargs)
network = self.project.network
if network:
network[f'pore.{self.name}'] = False
network[f'throat.{self.name}'] = False
try:
self.set_locations(pores=pores, throats=throats, mode='add')
except Exception as e:
logger.error(f'{e}, instantiation cancelled')
network.project.purge_object(self)
raise e
def test_inheritance_and_immutability(self):
class S2:
r"""
This is a docstring
"""
a = 2
b = 3
class S3(S2):
r"""
Different docstring
"""
b = 3
c = 4
sets2 = SettingsAttr(S2)
sets3 = SettingsAttr(S3)
sets3.b = 44
assert sets3._attrs == ['a', 'b', 'c']
assert sets2.b != sets3.b
assert "Different docstring" in sets3.__doc__
with pytest.raises(Exception):
sets3.b = 'nope'
def test_update_from_dataclass(self):
class S7:
r"""
This is a docstring
"""
a = 1
b = 2
class Data:
a = 22
c = 5.5
sets7 = SettingsAttr(S7)
assert sets7.a == 1
sets7._update(Data())
assert sets7.a == 22
def __init__(self, conns=None, coords=None, settings=None, **kwargs):
self.settings = SettingsAttr(NetworkSettings, settings)
super().__init__(settings=self.settings, **kwargs)
self._am = {}
self._im = {}
if coords is not None:
Np = np.shape(coords)[0]
self['pore.all'] = np.ones(Np, dtype=bool)
self['pore.coords'] = np.array(coords)
if conns is not None:
Nt = np.shape(conns)[0]
self['throat.all'] = np.ones(Nt, dtype=bool)
self['throat.conns'] = np.array(conns)
self.add_model(propname='pore.coordination_number',
model=mods.coordination_number,
regen_mode='explicit')
def __init__(self,
Np=0,
Nt=0,
network=None,
name=None,
project=None,
settings=None):
super().__init__()
self.settings = SettingsAttr(BaseSettings, settings)
if project is None:
if network is None:
project = ws.new_project()
else:
project = network.project
if name is None:
name = project._generate_name(self)
project._validate_name(name)
project.extend(self)
self.settings['name'] = name
self.settings.uuid = str(uuid.uuid4())
self.update({'pore.all': np.ones(shape=(Np, ), dtype=bool)})
self.update({'throat.all': np.ones(shape=(Nt, ), dtype=bool)})
def __init__(self, phase, settings=None, **kwargs):
self.settings = SettingsAttr(PorosimetrySettings, settings)
super().__init__(phase=phase, settings=self.settings, **kwargs)
# Use the reset method to initialize all arrays
self.reset()
self.settings['phase'] = phase.name
def __init__(self, phase, settings=None, **kwargs):
self.settings = SettingsAttr(TransientIonicConductionSettings, settings)
super().__init__(settings=self.settings, **kwargs)
self.settings['phase'] = phase.name
def __init__(self, phase, settings=None, **kwargs):
self.settings = SettingsAttr(GenericTransportSettings, settings)
super().__init__(settings=self.settings, **kwargs)
self.settings['phase'] = phase.name
self['pore.bc_rate'] = np.nan
self['pore.bc_value'] = np.nan
def __init__(self, phase, settings=None, **kwargs):
self.settings = SettingsAttr(TransientAdvectionDiffusionSettings,
settings)
super().__init__(phase=phase, settings=self.settings, **kwargs)
def __init__(self, settings=None, **kwargs):
self.settings = SettingsAttr(IonicConductionSettings, settings)
super().__init__(settings=self.settings, **kwargs)
def __init__(self, phase, settings=None, **kwargs):
self.settings = SettingsAttr(OrdinaryPercolationSettings, settings)
super().__init__(settings=self.settings, **kwargs)
# Use the reset method to initialize all arrays
self.reset()
self.settings['phase'] = phase.name
def __init__(self, settings=None, **kwargs):
self.settings = SettingsAttr(AdvectionDiffusionSettings, settings)
super().__init__(settings=self.settings, **kwargs)
def __init__(self, settings=None, **kwargs):
self.settings = SettingsAttr(MixedIPCoopSettings, settings)
super().__init__(settings=self.settings, **kwargs)
def __init__(self, phase, settings=None, **kwargs):
self.settings = SettingsAttr(TransientReactiveTransportSettings, settings)
super().__init__(phase=phase, settings=self.settings, **kwargs)
self.settings['phase'] = phase.name
self["pore.ic"] = np.nan
def __init__(self, settings=None, **kwargs):
self.settings = SettingsAttr(ImportedSettings, settings)
if 'network' in kwargs.keys():
network = kwargs.pop('network')
elif 'project' in kwargs.keys():
project = kwargs.pop('project')
network = project.network
super().__init__(network=network, pores=network.Ps, throats=network.Ts,
settings=self.settings, **kwargs)
# Transfer all geometrical properties off of network
exclude = self.settings['exclude_props']
exclude.extend(['pore.coords', 'throat.conns', 'pore.region_label'])
for item in network.props():
if item not in exclude:
self[item] = network.pop(item)
# If the following 'essential' props are not already defined, then
# they should be added using the specified values or models
if 'pore.diameter' not in self.keys():
pdia = 'pore.'+self.settings['pore_diameter'].split('pore.')[-1]
try:
self['pore.diameter'] = self[pdia]
except KeyError:
logger.error(pdia + " not found, can't assign 'pore.diameter'")
# if 'pore.volume' not in self.keys():
# pore_shape = self.settings['pore_shape']
# m = getattr(mods.geometry.pore_volume, pore_shape)
# self.add_model(propname='pore.volume',
# model=m, pore_diameter='pore.diameter')
# if 'pore.area' not in self.keys():
# pore_shape = self.settings['pore_shape']
# m = getattr(mods.geometry.pore_area, pore_shape)
# self.add_model(propname='pore.area',
# model=m)
if 'throat.diameter' not in self.keys():
tdia = 'throat.'+self.settings['throat_diameter'].split('throat.')[-1]
try:
self['throat.diameter'] = self[tdia]
except KeyError:
logger.error(tdia + " not found, can't assign 'throat.diameter'")
t_shape = self.settings['throat_shape'] + 's'
p_shape = self.settings['pore_shape'] + 's'
if 'throat.length' not in self.keys():
m = getattr(mods.geometry.throat_length, p_shape + '_and_' + t_shape)
self.add_model(propname='throat.length',
model=m,
throat_diameter='throat.diameter',
pore_diameter='pore.diameter')
if 'throat.volume' not in self.keys():
shape = self.settings['throat_shape']
m = getattr(mods.geometry.throat_volume, shape)
self.add_model(propname='throat.volume',
model=m,
throat_length='throat.length',
throat_diameter='throat.diameter')
m = getattr(mods.geometry.diffusive_size_factors, p_shape + '_and_' + t_shape)
self.add_model(propname='throat.diffusive_size_factors', model=m)
m = getattr(mods.geometry.hydraulic_size_factors, p_shape + '_and_' + t_shape)
self.add_model(propname='throat.hydraulic_size_factors', model=m)
def __init__(self, settings=None, **kwargs):
self.settings = SettingsAttr(StokesFlowSettings, settings)
super().__init__(settings=deepcopy(self.settings), **kwargs)
def __init__(self, settings=None, **kwargs):
self.settings = SettingsAttr(EffectiveDiffusivitySettings, settings)
super().__init__(settings=self.settings, **kwargs)
def __init__(self, settings=None, **kwargs):
self.settings = SettingsAttr(AbsolutePermeabilitySettings, settings)
super().__init__(settings=self.settings, **kwargs)
def __init__(self, phase, settings=None, **kwargs):
self.settings = SettingsAttr(ReactiveTransportSettings, settings)
super().__init__(phase=phase, settings=self.settings, **kwargs)
self.settings['phase'] = phase.name
def __init__(self, settings=None, **kwargs):
self.settings = SettingsAttr(FormationFactorSettings, settings)
super().__init__(settings=self.settings, **kwargs)
