"""Metrics functions (Metrics class definition)"""
from typing import Any, Union
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 G3DWorld
from g3d.defs import DIMMode
from g3d.defs import G3DEntity
[docs]
class Metrics(G3DEntity):
"""Definition of class Metrics: placeholders and functions for grid metrics data"""
def __init__(self, *args: Any, **kwargs: Any) -> None:
self.__vol = np.zeros(0)
self.__voli = np.zeros(0)
self.__area = np.zeros(0)
self.__streamtube_normal = np.zeros(0)
self.__v_min = 1.e20
self.__v_max = -1.e20
self.allocate()
self.__reset_extreme_values()
super().__init__(*args, **kwargs)
def _set_default(self) -> None:
super()._set_default()
self._tag = 'g3d metrics'
@property
def vol(self) -> ndarray:
"""Cell volumes placeholder
Returns
-------
ndarray
cell volume array
"""
return self.__vol
@property
def voli(self) -> ndarray:
"""Inverse cell volumes placeholder
Returns
-------
ndarray
inverse cell volume array
"""
return self.__voli
@property
def area(self) -> ndarray:
"""Average cell area placeholder
Returns
-------
ndarray
average cell area array
"""
return self.__area
@property
def streamtube_normal(self) -> ndarray:
"""Stream-tube normal placeholder
Returns
-------
ndarray
stream-tube normal array
"""
return self.__streamtube_normal
[docs]
def allocate(self) -> None:
"""Allocates metrics data arrays"""
g3d_world = G3DWorld()
N = g3d_world.sizes.n_cells
if N > 0:
self.__vol = np.zeros(N)
self.__voli = np.zeros(N)
if g3d_world.options.dim_mode is DIMMode.Q1D or g3d_world.options.dim_mode is DIMMode.G2D_AXISYMM:
self.__area = np.zeros(N)
if g3d_world.options.dim_mode is DIMMode.Q3D:
self.__streamtube_normal = np.zeros((N, 3))
def __reset_extreme_values(self) -> None:
self.__v_min = 1.e20
self.__v_max = -1.e20
[docs]
def get_volume(self, idx: int = None) -> Union[float, ndarray]:
"""Gets volume for specific cell if cell index is specified otherwise all cell volumes are returned as an array
Parameters
----------
idx : int :
cell index (Default value = None)
Returns
-------
float or ndarray
cell volume or array of cell volumes
"""
if idx is None:
return self.__vol
else:
return self.__vol[idx]
[docs]
def get_inverse_volume(self, idx: int = None) -> Union[float, ndarray]:
"""Gets inverse volume for specific cell if cell index is specified otherwise all cell inverse volumes are
returned as an array
Parameters
----------
idx : int
cell index (Default value = None)
Returns
-------
float or ndarray
inverse cell volume or array of inverse cell volumes
"""
if idx is None:
return self.__voli
else:
return self.__voli[idx]
[docs]
def get_area(self, idx: int = None) -> Union[float, ndarray]:
"""Gets average area for specific cell if cell index is specified otherwise all average cell areas are
returned as an array
Parameters
----------
idx : int
cell index (Default value = None)
Returns
-------
float or ndarray
average cell area or array of average cell areas
"""
if idx is None:
return self.__area
else:
return self.__area[idx]
[docs]
def get_streamtube_normal(self, idx: int = None) -> Union[float, ndarray]:
"""Gets stream-tube normal for specific cell if cell index is specified otherwise all stream-tube normals are
returned as an array
Parameters
----------
idx : int
cell index (Default value = None)
Returns
-------
float or ndarray
stream-tube normal or array of stream-tube normals
"""
if idx is None:
return self.__streamtube_normal
else:
return self.__streamtube_normal[idx]
[docs]
def set_volume(self, idx: int, val: float) -> None:
"""Sets cell volume array value
Parameters
----------
idx : int
cell index
val : float
cell volume
"""
self.__vol[idx] = val
[docs]
def set_inverse_volume(self, idx: int, val: float) -> None:
"""Sets inverse cell volume array value
Parameters
----------
idx : int
cell index
val : float
inverse cell volume
"""
self.__voli[idx] = val
[docs]
def set_area(self, idx: int, val: float) -> None:
"""Sets average cell area array value
Parameters
----------
idx : int
cell index
val : float
average cell area
"""
self.__area[idx] = val
[docs]
def set_streamtube_normal(self, idx: int, x: float, y: float, z: float) -> None:
"""Sets stream-tube normal array values (x, y, z)
Parameters
----------
idx : int
cell index
x : float
stream-tube normal (x-component)
y : float
stream-tube normal (y-component)
z : float
stream-tube normal (z-component)
"""
self.__streamtube_normal[idx, 0] = x
self.__streamtube_normal[idx, 1] = y
self.__streamtube_normal[idx, 2] = z
[docs]
def nullify_volume(self) -> None:
"""Sets the cell volume to zero for all cells"""
self.__vol[:] = 0.
[docs]
def nullify_inverse_volume(self) -> None:
"""Sets the inverse cell volume to zero for all cells"""
self.__voli[:] = 0.
[docs]
def nullify_area(self) -> None:
"""Sets the average cell area to zero for all cells"""
self.__area[:] = 0.
[docs]
def nullify_streamtube_normal(self) -> None:
"""Sets the stream-tube normal to (0., 0., 0.) for all cells"""
self.__streamtube_normal[:, 0] = 0.
self.__streamtube_normal[:, 1] = 0.
self.__streamtube_normal[:, 2] = 0.
[docs]
def update_extreme_values(self) -> None:
"""Updates min and max values"""
self.__v_min = np.min(self.__vol)
self.__v_max = np.max(self.__vol)
[docs]
def print_extreme_values(self) -> None:
"""Prints min and max values"""
self.update_extreme_values()
print(' cell volume : min=%12.5E, max=%12.5E' % (self.__v_min, self.__v_max))