"""G3DRunOptions static class"""
from typing import Any
from g3d.defs import EQNMode
from g3d.defs import DIMMode
[docs]
class G3DRunOptions:
"""G3D run options placeholder"""
__nstep = 0
__nstep_save = -1
__restart = True
__eqn_mode = EQNMode.DNS
__dim_mode = DIMMode.G3D
__use_velocity_gradients = False
__use_irsm = False
__q3d_source_factor = 0.95
__break_residual = 1.e-7
__use_residual_break = False
__attach_profiler = False
__auto_plot_residuals = False
__short_opt = 'hvf'
__long_opt = ['help', 'verbose', 'no-cuda', 'prof', 'g2d', 'g3d', 'cov=', 'local-badge-output-dir=']
# code run options
@property
def short_opt(self) -> str:
"""short option string (one letter options)"""
return type(self).__short_opt
@short_opt.setter
def short_opt(self, s_opt: str) -> None:
type(self).__short_opt = s_opt
@property
def long_opt(self) -> list[str]:
"""long option string (descriptive options)"""
return type(self).__long_opt
@long_opt.setter
def long_opt(self, l_opt: list[str]) -> None:
type(self).__long_opt = l_opt
# code profiler
@property
def attach_profiler(self) -> bool:
"""attach_profiler = True => profiler will be deployed on execution
(default value = False)"""
return type(self).__attach_profiler
@attach_profiler.setter
def attach_profiler(self, b: bool) -> None:
type(self).__attach_profiler = b
# generate plots
@property
def auto_plot_residuals(self) -> bool:
"""auto_plot_residuals = True => residual plots will be generated
automatically (default value = False)"""
return type(self).__auto_plot_residuals
@auto_plot_residuals.setter
def auto_plot_residuals(self, b: bool) -> None:
type(self).__auto_plot_residuals = b
# equations
@property
def eqn_mode(self) -> Any:
"""
solver equation mode (Enum, default value = EQNMode.DNS)
valid options: EULER, NAVIER_STOKES, DNS, RANS, URANS,
LES, DES, DDES
"""
return type(self).__eqn_mode
@eqn_mode.setter
def eqn_mode(self, m: Any) -> None:
if type(m) is EQNMode:
type(self).__eqn_mode = m
# dimensions
@property
def dim_mode(self) -> Any:
"""
solver dimension mode (Enum, default value = DIMMode.G3D)
valid options: Q1D, G2D, G2D_AXISYMM, G3D, Q3D
"""
return type(self).__dim_mode
@dim_mode.setter
def dim_mode(self, m: Any) -> None:
if type(m) is DIMMode:
type(self).__dim_mode = m
if m is DIMMode.G2D_AXISYMM:
type(self).__use_velocity_gradients = True
# iterations
@property
def nstep(self) -> int:
"""number of solver iterations"""
return type(self).__nstep
@nstep.setter
def nstep(self, N: int) -> None:
type(self).__nstep = N
@property
def nstep_save(self) -> int:
"""number of solver iterations between each save of solver state (flow field)"""
return type(self).__nstep_save
@nstep_save.setter
def nstep_save(self, N: int) -> None:
type(self).__nstep_save = N
# restart
@property
def restart(self) -> bool:
"""restart = True => solver will start from previously stored flow state if applicable
(default value = True)"""
return type(self).__restart
@restart.setter
def restart(self, b: bool) -> None:
type(self).__restart = b
# velocity gradients
@property
def use_velocity_gradients(self) -> bool:
"""use_velocity_gradients = True => velocity gradients will be calculated as part of flux evaluation
(default value = False - depending on solver settings)"""
return type(self).__use_velocity_gradients
@use_velocity_gradients.setter
def use_velocity_gradients(self, b: bool) -> None:
type(self).__use_velocity_gradients = b
# implicit residual smoothing (IRSM)
@property
def use_irsm(self) -> bool:
"""use_irsm = True => implicit residual smoothing will be applied
(default value = False, can be triggered by, for example, setting a CFL number
greater than 1.0)"""
return type(self).__use_irsm
@use_irsm.setter
def use_irsm(self, b: bool) -> None:
type(self).__use_irsm = b
# q3d source term
@property
def q3d_source_factor(self) -> float:
"""source term factor used for the quasi-three-dimensional (Q3D) solver
(default value = 0.95)"""
return self.__q3d_source_factor
@q3d_source_factor.setter
def q3d_source_factor(self, f: float) -> None:
type(self).__q3d_source_factor = f
# break residual
@property
def use_residual_break(self) -> bool:
"""use_residual_break = True => solver execution will be stopped if reaching the target residual
(default value = False)"""
return type(self).__use_residual_break
@use_residual_break.setter
def use_residual_break(self, b: bool) -> None:
type(self).__use_residual_break = b
@property
def break_residual(self) -> float:
"""target residual value for which the solver execution will be stopped
(default value = 1.e-7)"""
return type(self).__break_residual
@break_residual.setter
def break_residual(self, r: float) -> None:
type(self).__break_residual = r
type(self).__use_residual_break = True