"""velocity gradient variable entity (VGrad class definition)"""
from typing import Any
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
[docs]
class VGrad(G3DEntity):
def __init__(self, *args: Any, **kwargs: Any) -> None:
self._dd = np.zeros((3, 3))
super().__init__(*args, **kwargs)
def _set_default(self) -> None:
super()._set_default()
self._tag = 'g3d_vgrad'
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 = []
for i in range(len(args)):
if args_stat[i] == 1:
arg = args[i]
if type(arg) is VGrad:
args_stat[i] = 0
self.copy(arg)
elif type(arg) is list:
args_stat[i] = 0
if self._list_is_all_floats(arg) and len(arg) == 9:
self._dd[0][0] = arg[0]
self._dd[0][1] = arg[1]
self._dd[0][2] = arg[2]
self._dd[1][0] = arg[3]
self._dd[1][1] = arg[4]
self._dd[1][2] = arg[5]
self._dd[2][0] = arg[6]
self._dd[2][1] = arg[7]
self._dd[2][2] = arg[8]
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) == 9:
self._set_from_args(flow_data, bps=FunctionByPass.SELF)
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 == 'dudx':
self._dd[0][0] = value
return True
elif key == 'dudy':
self._dd[0][1] = value
return True
elif key == 'dudz':
self._dd[0][2] = value
return True
elif key == 'dvdx':
self._dd[1][0] = value
return True
elif key == 'dvdy':
self._dd[1][1] = value
return True
elif key == 'dvdz':
self._dd[1][2] = value
return True
elif key == 'dwdx':
self._dd[2][0] = value
return True
elif key == 'dwdy':
self._dd[2][1] = value
return True
elif key == 'dwdz':
self._dd[2][2] = value
return True
return False
@property
def dd(self) -> ndarray:
"""
:return:
"""
return self._dd
@property
def dudx(self) -> float:
"""
:return:
"""
return self._dd[0][0]
@dudx.setter
def dudx(self, val: float) -> None:
self._dd[0][0] = val
@property
def dudy(self) -> float:
"""
:return:
"""
return self._dd[0][1]
@dudy.setter
def dudy(self, val: float) -> None:
self._dd[0][1] = val
@property
def dudz(self) -> float:
"""
:return:
"""
return self._dd[0][2]
@dudz.setter
def dudz(self, val: float) -> None:
self._dd[0][2] = val
@property
def dvdx(self) -> float:
"""
:return:
"""
return self._dd[1][0]
@dvdx.setter
def dvdx(self, val: float) -> None:
self._dd[1][0] = val
@property
def dvdy(self) -> float:
"""
:return:
"""
return self._dd[1][1]
@dvdy.setter
def dvdy(self, val: float) -> None:
self._dd[1][1] = val
@property
def dvdz(self) -> float:
"""
:return:
"""
return self._dd[1][2]
@dvdz.setter
def dvdz(self, val: float) -> None:
self._dd[1][2] = val
@property
def dwdx(self) -> float:
"""
:return:
"""
return self._dd[2][0]
@dwdx.setter
def dwdx(self, val: float) -> None:
self._dd[2][0] = val
@property
def dwdy(self) -> float:
"""
:return:
"""
return self._dd[2][1]
@dwdy.setter
def dwdy(self, val: float) -> None:
self._dd[2][1] = val
@property
def dwdz(self) -> float:
"""
:return:
"""
return self._dd[2][2]
@dwdz.setter
def dwdz(self, val: float) -> None:
self._dd[2][2] = val
[docs]
def copy(self, vgrad: 'VGrad') -> None:
super().copy(vgrad)
for i in range(3):
for j in range(3):
self._dd[i][j] = vgrad.dd[i][j]
# CALCULATE DIVERGENCE, VORTICITY, STRAIN RATE, AND STRAIN RATE MAGNITUDE HERE
[docs]
def divergence(self) -> float:
"""
:return:
"""
return self._dd[0][0] + self._dd[1][1] + self._dd[2][2]
[docs]
def vorticity(self) -> ndarray:
"""
:return:
"""
v = np.zeros(3)
v[0] = self._dd[2][1] - self._dd[1][2]
v[1] = self._dd[0][2] - self._dd[2][0]
v[2] = self._dd[1][0] - self._dd[0][1]
return v
[docs]
def vorticity_magnitude(self) -> float:
"""
:return:
"""
v = self.vorticity()
return np.sqrt(sum(v * v))
[docs]
def SijSij(self) -> float:
"""
:return:
"""
return (self._dd[0][0] ** 2 + self._dd[1][1] ** 2 + self._dd[2][2] ** 2 +
0.5 * ((self._dd[0][1] + self._dd[1][0]) ** 2
+ (self._dd[0][2] + self._dd[2][0]) ** 2
+ (self._dd[1][2] + self._dd[2][1]) ** 2))
[docs]
def print(self) -> None:
print(' dudx %11.5E [1/s] ' % self._dd[0][0])
print(' dudy %11.5E [1/s] ' % self._dd[0][1])
print(' dudz %11.5E [1/s] ' % self._dd[0][2])
print(' dvdx %11.5E [1/s] ' % self._dd[1][0])
print(' dvdy %11.5E [1/s] ' % self._dd[1][1])
print(' dvdz %11.5E [1/s] ' % self._dd[1][2])
print(' dwdx %11.5E [1/s] ' % self._dd[2][0])
print(' dwdy %11.5E [1/s] ' % self._dd[2][1])
print(' dwdz %11.5E [1/s] ' % self._dd[2][2])