"""conservative variable entity (Cons class definition)"""
from typing import Any, Union, Tuple
import os
if os.environ.get('__USE_CUDA', '0') == '1':
import cupy as np
from cupy import ndarray
else:
import numpy as np
from numpy import ndarray
from g3d.defs import G3DEntity
from g3d.defs import FunctionByPass
from g3d.gas import Gas
[docs]
class Cons(G3DEntity):
def __init__(self, *args: Any, **kwargs: Any) -> None:
self._ro = 1.0
self._ru = 0.0
self._rv = 0.0
self._rw = 0.0
self._et = 0.0
super().__init__(*args, **kwargs)
def _set_default(self) -> None:
super()._set_default()
self._tag = 'g3d_cons'
def _set_from_args(self, *args: Any, **kwargs: Any) -> ndarray:
bps = self._get_function_evaluate_status(**kwargs)
if bps is FunctionByPass.SELF:
args_stat = np.ones(len(args))
else:
args_stat = super()._set_from_args(*args)
if bps in [FunctionByPass.EVALUATE, FunctionByPass.SELF]:
if np.sum(args_stat) > 0:
flow_data = []
gas = None
for i in range(len(args)):
if args_stat[i] == 1:
arg = args[i]
if type(arg) is Cons:
args_stat[i] = 0
self.copy(arg)
elif type(arg) is Gas:
args_stat[i] = 0
gas = arg
elif type(arg) is list:
args_stat[i] = 0
if self._list_is_all_floats(arg) and len(arg) == 5:
self._ro, self._ru, self._rv, self._rw, self._et = arg
elif type(arg) in [float, np.float64, np.float32, int, np.int64, np.int32]:
args_stat[i] = 0
flow_data.append(np.float64(arg))
if len(flow_data) == 5:
if gas is None:
self._set_from_args(flow_data, bps=FunctionByPass.SELF)
else:
self.set_from_primitive(flow_data, gas)
return args_stat
[docs]
def set_from_key_value(self, key: str, value: Any) -> bool:
if super().set_from_key_value(key, value):
return True
elif key == 'ro':
self._ro = value
return True
elif key == 'ru':
self._ru = value
return True
elif key == 'rv':
self._rv = value
return True
elif key == 'rw':
self._rw = value
return True
elif key == 'et':
self._et = value
return True
return False
[docs]
def copy(self, cons: 'Cons') -> None:
super().copy(cons)
self._ro = cons.ro
self._ru = cons.ru
self._rv = cons.rv
self._rw = cons.rw
self._et = cons.et
@property
def ro(self) -> float:
"""
:return:
"""
return self._ro
@ro.setter
def ro(self, val: float) -> None:
self._ro = val
@property
def ru(self) -> float:
"""
:return:
"""
return self._ru
@ru.setter
def ru(self, val: float) -> None:
self._ru = val
@property
def rv(self) -> float:
"""
:return:
"""
return self._rv
@rv.setter
def rv(self, val: float) -> None:
self._rv = val
@property
def rw(self) -> float:
"""
:return:
"""
return self._rw
@rw.setter
def rw(self, val: float) -> None:
self._rw = val
@property
def et(self) -> float:
"""
:return:
"""
return self._et
@et.setter
def et(self, val: float) -> None:
self._et = val
[docs]
def get_momentum_vector(self) -> ndarray:
"""
:return:
"""
return np.array([self._ru, self._rv, self._rw])
[docs]
def set_momentum_vector(self, r_vel: Union[Tuple[float, float, float], list[float], ndarray]) -> None:
"""
:param r_vel:
"""
self._ru, self._rv, self._rw = r_vel
[docs]
def ruiui(self) -> float:
"""
:return:
"""
tmp = self.get_momentum_vector()
return sum(tmp * tmp) / self._ro
[docs]
def set_from_primitive(self, *args: Any) -> None:
"""
:param args:
"""
gas = Gas()
flow_data = []
for arg in args:
if type(arg) in [float, np.float64, np.float32, int, np.int64, np.int32] and len(args) >= 5:
flow_data.append(np.float64(arg))
elif type(arg) is list:
if len(arg) == 5:
for i in range(5):
flow_data = arg
elif type(arg) is Gas:
gas = arg
if self._list_is_all_floats(flow_data) and len(flow_data) == 5:
p, u, v, w, t = flow_data
self._ro = gas.get_density(p, t)
self._ru = self._ro * u
self._rv = self._ro * v
self._rw = self._ro * w
self._et = p / gas.gm1 + 0.5 * self.ruiui()
[docs]
def print(self) -> None:
print(' density %11.5E [kg/m^3] ' % self._ro)
print(' x-momentum %11.5E [kg/(m^2 s)]' % self._ru)
print(' y-momentum %11.5E [kg/(m^2 s)]' % self._rv)
print(' z-momentum %11.5E [kg/(m^2 s)]' % self._rw)
print(' total energy %11.5E [m^2/s^2] ' % (self._et / self._ro))