"""G3D common functions"""
from typing import Tuple
import os
if os.environ.get('__USE_CUDA', '0') == '1':
import cupy as np
else:
import numpy as np
[docs]
def assure_path_exists(path: str) -> None:
"""creates directories of specified path if they do not exist"""
dir_path = os.path.dirname(path)
if len(dir_path):
if not os.path.exists(dir_path):
os.makedirs(dir_path)
[docs]
def clean_path(path: str) -> str:
"""removes double slashes in path"""
return path.replace('//', '/').strip('/')
[docs]
class G3DConvert:
"""collects converters"""
def __init__(self) -> None:
""""initialize converter"""
pass
[docs]
@staticmethod
def dist_to_meter(val: float, it: int = 0) -> float:
"""
converts length given in a specified dimension to meters
input: length, it (default value=0 => meters)
it = 0: meter
it = 1: cm
it = 2: mm
it = 3: in
it = 4: ft
it = 5: m^2
it = 6: cm^2
it = 7: mm^2
it = 8: in^2
it = 9: ft^2
"""
tmp = np.array(10)
tmp[0] = val
# cm
tmp[1] = val / 100.
# mm
tmp[2] = val / 1000.
# in
tmp[3] = 0.0254 * val
# ft
tmp[4] = 0.3048 * val
# cm^2
tmp[5] = np.sqrt(val / np.pi)
tmp[6] = tmp[5] / 100.
# mm^2
tmp[7] = tmp[5] / 1000.
# in^2
tmp[8] = tmp[5] * 0.0254
# ft^2
tmp[9] = tmp[5] * 0.3048
return tmp[it]
[docs]
@staticmethod
def temp_to_Kelvin(val: float, it: int = 0) -> float:
"""
converts temperature given in a specified dimension to Kelvin
input: temperature, it (default value=0 => Kelvin)
it = 0: Kelvin
it = 1: Celsius
it = 2: Fahrenheit
it = 3: Rankine
"""
tmp = np.array(4)
tmp[0] = val
# Celsius
tmp[1] = val + 273.15
# Fahrenheit
tmp[2] = ((val - 32) * (5. / 9.)) + 273.15
# Rankine
tmp[3] = val * (5. / 9.)
return tmp[it]
[docs]
@staticmethod
def pressure_to_Pascal(val: float, it: int = 0) -> float:
"""
converts pressure given in a specified dimension to Pascal
input: pressure, it (default value=0 => Pascal)
it = 0: Pascal
it = 1: bar
it = 2: atm
"""
tmp = np.array(3)
tmp[0] = val
# bar
tmp[1] = val * 1.e5
# atm
tmp[2] = val * 101325.
return tmp[it]
[docs]
class XMLDataItem:
"""XML data placeholder"""
def __init__(self) -> None:
"""initialize XML data placeholder"""
self._ni = 1
self._nj = 1
self._nk = 1
self._n_dim = 3
self._pos = 0
self._NumberType = "Float"
self._precision = "8"
self._format = "Binary"
self._endian = "little"
self._file = "msh.bin"
@property
def ni(self) -> int:
"""number of nodes in i-direction"""
return self._ni
@ni.setter
def ni(self, n: int) -> None:
self._ni = n
@property
def nj(self) -> int:
"""number of nodes in j-direction"""
return self._nj
@nj.setter
def nj(self, n: int) -> None:
self._nj = n
@property
def nk(self) -> int:
"""number of nodes in k-direction"""
return self._nk
@nk.setter
def nk(self, n: int) -> None:
self._nk = n
@property
def n_dim(self) -> int:
"""number of dimensions (default value = 3)"""
return self._n_dim
@n_dim.setter
def n_dim(self, n: int) -> None:
self._n_dim = n
@property
def pos(self) -> int:
"""memory pointer"""
return self._pos
@pos.setter
def pos(self, i: int) -> None:
self._pos = i
@property
def NumberType(self) -> str:
"""number type (default value = 'Float')"""
return self._NumberType
@NumberType.setter
def NumberType(self, s: str) -> None:
self._NumberType = s
@property
def precision(self) -> str:
"""data precision (default value = '8')"""
return self._precision
@precision.setter
def precision(self, s: str) -> None:
self._precision = s
@property
def format(self) -> str:
"""data format (default value = 'little')"""
return self._format
@format.setter
def format(self, s: str) -> None:
self._format = s
@property
def endian(self) -> str:
"""endian format (default value = 'Binary')"""
return self._endian
@endian.setter
def endian(self, s: str) -> None:
self._endian = s
@property
def file(self) -> str:
"""file name (default value = 'msh.bin')"""
return self._file
@file.setter
def file(self, s: str) -> None:
self._file = s
[docs]
def SetDim(self, ni: int, nj: int, nk: int, n_dim: int) -> None:
"""
updates dimension according to specification
:param ni: number of nodes in i-direction
:type ni: int
:param nj: number of nodes in j-direction
:type nj: int
:param nk: number of nodes in k-direction
:type nk: int
:param n_dim: number of dimensions
:type n_dim: int
example: SetDim(ni, nj, nk, n_dim)
"""
self._ni = ni
self._nj = nj
self._nk = nk
self._n_dim = n_dim
[docs]
def GetDim(self) -> Tuple[int, int, int, int]:
"""
gets XML placeholder dimensions
example: ni, nj, nk, n_dim = GetDim()
:return: ni (int), nj (int), nk (int), n_dim (int)
:rtype: tuple
"""
return self._ni, self._nj, self._nk, self._n_dim