wrfrun 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

wrfrun/model/wrf/core.py

@@ -1,40 +1,67 @@
+"""
+wrfrun.model.wrf.core
+#####################
+
+Core implementation of WRF model. All ``Executable`` of WPS / WRF model are defined here.
+
+If you prefer function interfaces, please see :doc:`function wrapper </api/model.wrf.exec_wrap>` for these ``Executable``.
+
+.. autosummary::
+    :toctree: generated/
+
+    GeoGrid
+    LinkGrib
+    UnGrib
+    MetGrid
+    Real
+    WRF
+    DFI
+    NDown
+"""
+
 from os import listdir
 from os.path import abspath, basename, exists
 from shutil import copyfile, move, rmtree
-from typing import Optional
+from typing import Optional, Union
 
 from wrfrun.core import ExecutableBase, FileConfigDict, InputFileError, NamelistIDError, WRFRUNConfig, WRFRUNExecDB
+from wrfrun.workspace.wrf import WORKSPACE_MODEL_WPS, WORKSPACE_MODEL_WRF
 from wrfrun.utils import logger
-from ._metgrid import reconcile_namelist_metgrid
-from ._ndown import process_after_ndown
-from .namelist import prepare_dfi_namelist, prepare_wps_namelist, prepare_wrf_namelist, prepare_wrfda_namelist
+from .utils import reconcile_namelist_metgrid, process_after_ndown
+from .namelist import (prepare_dfi_namelist, prepare_wps_namelist, prepare_wrf_namelist,
+                       prepare_wrfda_namelist, get_ungrib_out_dir_path, get_ungrib_out_prefix,
+                       set_ungrib_out_prefix, set_metgrid_fg_names)
 from .vtable import VtableFiles
 from ..base import NamelistName
 
 
-def _check_namelist_preparation():
-    if len(WRFRUNConfig.get_namelist("wps")) == 0:
+def _check_and_prepare_namelist():
+    """
+    This function check if namelists needed by WPS/WRF have been loaded,
+    and prepare namelist if check fails.
+    """
+    if not WRFRUNConfig.check_namelist("wps"):
         prepare_wps_namelist()
 
-    if len(WRFRUNConfig.get_namelist("wrf")) == 0:
+    if not WRFRUNConfig.check_namelist("wrf"):
         prepare_wrf_namelist()
 
-    if len(WRFRUNConfig.get_namelist("wrfda")) == 0:
+    if not WRFRUNConfig.check_namelist("wrfda"):
         prepare_wrfda_namelist()
 
 
 class GeoGrid(ExecutableBase):
     """
-    Execute "geogrid.exe".
+    ``Executable`` for "geogrid.exe".
     """
 
     def __init__(self, geogrid_tbl_file: Optional[str] = None, core_num: Optional[int] = None):
         """
-        Execute "geogrid.exe".
+        ``Executable`` for "geogrid.exe".
 
         :param geogrid_tbl_file: Custom GEOGRID.TBL file path. Defaults to None.
         :type geogrid_tbl_file: str
-        :param core_num: An positive integer number of used core numbers. ``mpirun`` will be used to execute geogrid.exe if ``core_num != None``.
+        :param core_num: An positive integer number. ``mpirun`` will be used to execute geogrid.exe if ``core_num != None``.
         :type core_num: int
         """
         if isinstance(core_num, int) and core_num <= 0:
@@ -51,17 +78,18 @@ class GeoGrid(ExecutableBase):
             mpi_cmd = "mpirun"
             mpi_core_num = core_num
 
-        super().__init__(name="geogrid", cmd="./geogrid.exe", work_path=WRFRUNConfig.WPS_WORK_PATH, mpi_use=mpi_use, mpi_cmd=mpi_cmd, mpi_core_num=mpi_core_num)
+        super().__init__(name="geogrid", cmd="./geogrid.exe", work_path=WORKSPACE_MODEL_WPS, mpi_use=mpi_use, mpi_cmd=mpi_cmd, mpi_core_num=mpi_core_num)
 
         self.geogrid_tbl_file = geogrid_tbl_file
 
-        _check_namelist_preparation()
+        _check_and_prepare_namelist()
 
     def generate_custom_config(self):
         """
-        Get and store namelist.
-        :return:
-        :rtype:
+        Store custom configs, including:
+
+        1. Namelist settings.
+        2. Path of custom TBL file.
         """
         self.custom_config.update(
             {
@@ -71,6 +99,9 @@ class GeoGrid(ExecutableBase):
         )
 
     def load_custom_config(self):
+        """
+        Load custom configs.
+        """
         WRFRUNConfig.update_namelist(self.custom_config["namelist"], "wps")
         self.geogrid_tbl_file = self.custom_config["geogrid_tbl_file"]
 
@@ -81,14 +112,18 @@ class GeoGrid(ExecutableBase):
         if not WRFRUNConfig.IS_IN_REPLAY:
             if self.geogrid_tbl_file is not None:
                 tbl_file: FileConfigDict = {
-                    "file_path": self.geogrid_tbl_file, "save_path": f"{WRFRUNConfig.WPS_WORK_PATH}/geogrid",
+                    "file_path": self.geogrid_tbl_file, "save_path": f"{WORKSPACE_MODEL_WPS}/geogrid",
                     "save_name": "GEOGRID.TBL", "is_data": False, "is_output": False
                 }
                 self.add_input_files(tbl_file)
 
         super().before_exec()
 
-        WRFRUNConfig.write_namelist(f"{WRFRUNConfig.WPS_WORK_PATH}/{NamelistName.WPS}", "wps")
+        WRFRUNConfig.write_namelist(f"{WORKSPACE_MODEL_WPS}/{NamelistName.WPS}", "wps")
+
+        # print debug logs
+        logger.debug("Namelist settings of 'geogrid':")
+        logger.debug(WRFRUNConfig.get_namelist("wps"))
 
     def after_exec(self):
         if not WRFRUNConfig.IS_IN_REPLAY:
@@ -102,26 +137,28 @@ class GeoGrid(ExecutableBase):
 
 class LinkGrib(ExecutableBase):
     """
-    Run command: "./link_grib.csh".
+    ``Executable`` for "./link_grib.csh".
     """
 
     def __init__(self, grib_dir_path: str):
         """
-        Execute "link_grib.csh".
+        ``Executable`` for "link_grib.csh".
 
-        :param grib_dir_path: GRIB data path. Absolute path is recommended.
+        :param grib_dir_path: GRIB data directory path. Absolute path is recommended.
         :type grib_dir_path: str
         """
         self._link_grib_input_path = "./input_grib_data_dir"
 
-        super().__init__(name="link_grib", cmd=["./link_grib.csh", f"{self._link_grib_input_path}/*", "."], work_path=WRFRUNConfig.WPS_WORK_PATH)
+        super().__init__(name="link_grib", cmd=["./link_grib.csh", f"{self._link_grib_input_path}/*", "."], work_path=WORKSPACE_MODEL_WPS)
         self.grib_dir_path = grib_dir_path
 
     def generate_custom_config(self):
-        self.class_config["class_args"] = (self.grib_dir_path,)
+        """
+        Store custom configs, including:
 
-    def replay(self):
-        self()
+        1. Positional arguments of this ``Executable``.
+        """
+        self.class_config["class_args"] = (self.grib_dir_path,)
 
     def before_exec(self):
         if not WRFRUNConfig.IS_IN_REPLAY:
@@ -133,7 +170,7 @@ class LinkGrib(ExecutableBase):
                 logger.error(f"GRIB file directory not found: {_grib_dir_path}")
                 raise FileNotFoundError(f"GRIB file directory not found: {_grib_dir_path}")
 
-            save_path = f"{WRFRUNConfig.WPS_WORK_PATH}/{self._link_grib_input_path}"
+            save_path = f"{WORKSPACE_MODEL_WPS}/{self._link_grib_input_path}"
             save_path = WRFRUNConfig.parse_resource_uri(save_path)
             if exists(save_path):
                 rmtree(save_path)
@@ -141,7 +178,7 @@ class LinkGrib(ExecutableBase):
             for _file in listdir(_grib_dir_path):
                 _file_config: FileConfigDict = {
                     "file_path": f"{_grib_dir_path}/{_file}",
-                    "save_path": f"{WRFRUNConfig.WPS_WORK_PATH}/{self._link_grib_input_path}",
+                    "save_path": f"{WORKSPACE_MODEL_WPS}/{self._link_grib_input_path}",
                     "save_name": _file, "is_data": True, "is_output": False,
                 }
                 self.add_input_files(_file_config)
@@ -151,43 +188,56 @@ class LinkGrib(ExecutableBase):
 
 class UnGrib(ExecutableBase):
     """
-    Execute "ungrib.exe".
+    ``Executable`` for "ungrib.exe".
     """
 
     def __init__(self, vtable_file: Optional[str] = None, input_data_path: Optional[str] = None):
         """
-        Execute "ungrib.exe".
+        ``Executable`` for "ungrib.exe".
 
-        :param vtable_file: Path of the Vtable file "ungrib.exe" used.
+        :param vtable_file: Path of the Vtable file.
+                            Defaults to :attr:`VtableFiles.ERA_PL <vtable.VtableFiles.ERA_PL>`.
         :type vtable_file: str
-        :param input_data_path: Path of the directory stores input GRIB2 files.
+        :param input_data_path: Directory path of input GRIB files.
+                                Defaults to ``input_data_path`` set in user's config file.
         :type input_data_path: str
         """
-        super().__init__(name="ungrib", cmd="./ungrib.exe", work_path=WRFRUNConfig.WPS_WORK_PATH)
+        super().__init__(name="ungrib", cmd="./ungrib.exe", work_path=WORKSPACE_MODEL_WPS)
 
         self.vtable_file = vtable_file
         self.input_data_path = input_data_path
 
-        _check_namelist_preparation()
+        _check_and_prepare_namelist()
 
     def call_link_grib(self):
         """
-        Execute "link_grib.csh" if needed.
-
-        :return:
-        :rtype:
+        Call :class:`LinkGrib` if needed.
         """
         if self.input_data_path is None:
             self.input_data_path = WRFRUNConfig.get_input_data_path()
 
         LinkGrib(self.input_data_path)()
 
+    def set_ungrib_output_prefix(self, prefix="FILE") -> "UnGrib":
+        """
+        This method is the same as :func:`set_ungrib_output_prefix <wrfrun.model.wrf.namelist.set_ungrib_output_prefix>`.
+        ``wrfrun`` provide this method to avoid changing namelist before loading it.
+
+        :param prefix: Prefix of outputs.
+        :type prefix: str
+        :return: This instance itself.
+        :rtype: UnGrib
+        """
+        prefix = basename(prefix)
+        set_ungrib_out_prefix(prefix)
+        return self
+
     def generate_custom_config(self):
         """
-        Get and store namelist.
+        Store custom configs, including:
 
-        :return:
-        :rtype:
+        1. Namelist settings.
+        2. Path of used VTable file.
         """
         self.custom_config.update(
             {
@@ -197,12 +247,12 @@ class UnGrib(ExecutableBase):
         )
 
     def load_custom_config(self):
+        """
+        Load custom configs.
+        """
         self.vtable_file = self.custom_config["vtable_file"]
         WRFRUNConfig.update_namelist(self.custom_config["namelist"], "wps")
 
-    def replay(self):
-        super().__call__()
-
     def before_exec(self):
         WRFRUNConfig.check_wrfrun_context(True)
         WRFRUNConfig.WRFRUN_WORK_STATUS = "ungrib"
@@ -213,7 +263,7 @@ class UnGrib(ExecutableBase):
 
             _file_config: FileConfigDict = {
                 "file_path": self.vtable_file,
-                "save_path": WRFRUNConfig.WPS_WORK_PATH,
+                "save_path": WORKSPACE_MODEL_WPS,
                 "save_name": "Vtable",
                 "is_data": False,
                 "is_output": False
@@ -222,11 +272,15 @@ class UnGrib(ExecutableBase):
 
         super().before_exec()
 
-        WRFRUNConfig.write_namelist(f"{WRFRUNConfig.WPS_WORK_PATH}/{NamelistName.WPS}", "wps")
+        WRFRUNConfig.write_namelist(f"{WORKSPACE_MODEL_WPS}/{NamelistName.WPS}", "wps")
+
+        # print debug logs
+        logger.debug("Namelist settings of 'ungrib':")
+        logger.debug(WRFRUNConfig.get_namelist("wps"))
 
     def after_exec(self):
         if not WRFRUNConfig.IS_IN_REPLAY:
-            self.add_output_files(output_dir=WRFRUNConfig.get_ungrib_out_dir_path(), save_path=self._output_save_path, startswith=WRFRUNConfig.get_ungrib_out_prefix())
+            self.add_output_files(output_dir=get_ungrib_out_dir_path(), save_path=self._output_save_path, startswith=get_ungrib_out_prefix())
             self.add_output_files(save_path=self._log_save_path, outputs=["ungrib.log", "namelist.wps"])
 
         super().after_exec()
@@ -241,18 +295,20 @@ class UnGrib(ExecutableBase):
 
 class MetGrid(ExecutableBase):
     """
-    Execute "metgrid.exe".
+    ``Executable`` of "metgrid.exe".
     """
 
     def __init__(self, geogrid_data_path: Optional[str] = None, ungrib_data_path: Optional[str] = None, core_num: Optional[int] = None):
         """
-        Execute "metgrid.exe".
+        ``Executable`` of "metgrid.exe".
 
-        :param geogrid_data_path: Directory path of outputs from geogrid.exe. If None, tries to use the output path specified by config file.
+        :param geogrid_data_path: Directory path of :class:`GeoGrid` outputs.
+                                  If is ``None``, try to use the output path specified by config file.
         :type geogrid_data_path: str
-        :param ungrib_data_path: Directory path of outputs from ungrib.exe. If None, tries to use the output path specified by config file.
+        :param ungrib_data_path: Directory path of :class:`UnGrib` outputs.
+                                 If is ``None``, try to use the output path specified by config file.
         :type ungrib_data_path: str
-        :param core_num: An positive integer number of used core numbers. ``mpirun`` will be used to execute geogrid.exe if ``core_num != None``.
+        :param core_num: An positive integer number. ``mpirun`` will be used to execute geogrid.exe if ``core_num != None``.
         :type core_num: int
         """
         if isinstance(core_num, int) and core_num <= 0:
@@ -269,18 +325,34 @@ class MetGrid(ExecutableBase):
             mpi_cmd = "mpirun"
             mpi_core_num = core_num
 
-        super().__init__(name="metgrid", cmd="./metgrid.exe", work_path=WRFRUNConfig.WPS_WORK_PATH, mpi_use=mpi_use, mpi_cmd=mpi_cmd, mpi_core_num=mpi_core_num)
+        super().__init__(name="metgrid", cmd="./metgrid.exe", work_path=WORKSPACE_MODEL_WPS, mpi_use=mpi_use, mpi_cmd=mpi_cmd, mpi_core_num=mpi_core_num)
 
         self.geogrid_data_path = geogrid_data_path
         self.ungrib_data_path = ungrib_data_path
 
-        _check_namelist_preparation()
+        _check_and_prepare_namelist()
+
+    def set_metgrid_fg_names(self, fg_names: Union[str, list[str]] = "FILE") -> "MetGrid":
+        """
+        This method
+        :param fg_names: ``fg_name`` of metgrid, a single prefix string or a string list.
+        :type fg_names: str | list
+        :return: This instance itself.
+        :rtype: MetGrid
+        """
+        if isinstance(fg_names, str):
+            fg_names = [fg_names, ]
+        fg_names = [basename(x) for x in fg_names]
+        set_metgrid_fg_names(fg_names)
+        return self
 
     def generate_custom_config(self):
         """
-        Get and store namelist.
-        :return:
-        :rtype:
+        Store custom configs, including:
+
+        1. Directory path of :class:`GeoGrid` outputs.
+        2. Directory path of :class:`UnGrib` outputs.
+        3. Namelist settings.
         """
         self.custom_config.update(
             {
@@ -291,6 +363,9 @@ class MetGrid(ExecutableBase):
         )
 
     def load_custom_config(self):
+        """
+        Load custom configs.
+        """
         self.geogrid_data_path = self.custom_config["geogrid_data_path"]
         self.ungrib_data_path = self.custom_config["ungrib_data_path"]
         WRFRUNConfig.update_namelist(self.custom_config["namelist"], "wps")
@@ -302,7 +377,7 @@ class MetGrid(ExecutableBase):
         if not WRFRUNConfig.IS_IN_REPLAY and not WRFRUNConfig.FAKE_SIMULATION_MODE:
             # check input of metgrid.exe
             # try to search input files in the output path if workspace is clear.
-            file_list = listdir(WRFRUNConfig.parse_resource_uri(WRFRUNConfig.WPS_WORK_PATH))
+            file_list = listdir(WRFRUNConfig.parse_resource_uri(WORKSPACE_MODEL_WPS))
 
             if "geo_em.d01.nc" not in file_list:
 
@@ -319,14 +394,14 @@ class MetGrid(ExecutableBase):
                     for _file in geogrid_file_list:
                         _file_config = {
                             "file_path": f"{self.geogrid_data_path}/{_file}",
-                            "save_path": WRFRUNConfig.WPS_WORK_PATH,
+                            "save_path": WORKSPACE_MODEL_WPS,
                             "save_name": _file,
                             "is_data": True,
                             "is_output": True
                         }
                         self.add_input_files(_file_config)
 
-            ungrib_output_dir = WRFRUNConfig.parse_resource_uri(WRFRUNConfig.get_ungrib_out_dir_path())
+            ungrib_output_dir = WRFRUNConfig.parse_resource_uri(get_ungrib_out_dir_path())
             if basename(ungrib_output_dir) not in file_list or len(listdir(ungrib_output_dir)) == 0:
 
                 if self.ungrib_data_path is None:
@@ -343,7 +418,7 @@ class MetGrid(ExecutableBase):
                     for _file in ungrib_file_list:
                         _file_config: FileConfigDict = {
                             "file_path": f"{self.ungrib_data_path}/{_file}",
-                            "save_path": WRFRUNConfig.get_ungrib_out_dir_path(),
+                            "save_path": get_ungrib_out_dir_path(),
                             "save_name": _file,
                             "is_data": True,
                             "is_output": True
@@ -352,7 +427,7 @@ class MetGrid(ExecutableBase):
 
         super().before_exec()
 
-        WRFRUNConfig.write_namelist(f"{WRFRUNConfig.WPS_WORK_PATH}/{NamelistName.WPS}", "wps")
+        WRFRUNConfig.write_namelist(f"{WORKSPACE_MODEL_WPS}/{NamelistName.WPS}", "wps")
 
     def after_exec(self):
         if not WRFRUNConfig.IS_IN_REPLAY:
@@ -366,16 +441,17 @@ class MetGrid(ExecutableBase):
 
 class Real(ExecutableBase):
     """
-    Execute "real.exe".
+    ``Executable`` of "real.exe".
     """
 
     def __init__(self, metgrid_data_path: Optional[str] = None, core_num: Optional[int] = None):
         """
-        Execute "real.exe".
+        ``Executable`` of "real.exe".
 
-        :param metgrid_data_path: Path of the directory stores outputs from "metgrid.exe".
+        :param metgrid_data_path: Directory path of :class:`MetGrid` outputs.
+                                  If is ``None``, try to use the workspace path or output path in the config file.
         :type metgrid_data_path: str
-        :param core_num: An positive integer number of used core numbers. ``mpirun`` will be used to execute geogrid.exe if ``core_num != None``.
+        :param core_num: An positive integer number. ``mpirun`` will be used to execute geogrid.exe if ``core_num != None``.
         :type core_num: int
         """
         if isinstance(core_num, int) and core_num <= 0:
@@ -392,13 +468,19 @@ class Real(ExecutableBase):
             mpi_cmd = "mpirun"
             mpi_core_num = core_num
 
-        _check_namelist_preparation()
+        _check_and_prepare_namelist()
 
-        super().__init__(name="real", cmd="./real.exe", work_path=WRFRUNConfig.WRF_WORK_PATH, mpi_use=mpi_use, mpi_cmd=mpi_cmd, mpi_core_num=mpi_core_num)
+        super().__init__(name="real", cmd="./real.exe", work_path=WORKSPACE_MODEL_WRF, mpi_use=mpi_use, mpi_cmd=mpi_cmd, mpi_core_num=mpi_core_num)
 
         self.metgrid_data_path = metgrid_data_path
 
     def generate_custom_config(self):
+        """
+        Store custom configs, including:
+
+        1. Namelist settings.
+        2. Directory path of :class:`MetGrid` outputs.
+        """
         self.custom_config["metgrid_data_path"] = self.metgrid_data_path
         self.custom_config.update(
             {
@@ -408,6 +490,9 @@ class Real(ExecutableBase):
         )
 
     def load_custom_config(self):
+        """
+        Load custom configs.
+        """
         self.metgrid_data_path = self.custom_config["metgrid_data_path"]
         WRFRUNConfig.update_namelist(self.custom_config["namelist"], "wrf")
 
@@ -426,7 +511,7 @@ class Real(ExecutableBase):
             for _file in file_list:
                 _file_config: FileConfigDict = {
                     "file_path": f"{self.metgrid_data_path}/{_file}",
-                    "save_path": WRFRUNConfig.WRF_WORK_PATH,
+                    "save_path": WORKSPACE_MODEL_WRF,
                     "save_name": _file,
                     "is_data": True,
                     "is_output": True
@@ -435,7 +520,7 @@ class Real(ExecutableBase):
 
         super().before_exec()
 
-        WRFRUNConfig.write_namelist(f"{WRFRUNConfig.WRF_WORK_PATH}/{NamelistName.WRF}", "wrf")
+        WRFRUNConfig.write_namelist(f"{WORKSPACE_MODEL_WRF}/{NamelistName.WRF}", "wrf")
 
     def after_exec(self):
         if not WRFRUNConfig.IS_IN_REPLAY:
@@ -449,20 +534,20 @@ class Real(ExecutableBase):
 
 class WRF(ExecutableBase):
     """
-    Execute "wrf.exe".
+    ``Executable`` of "wrf.exe".
     """
 
     def __init__(self, input_file_dir_path: Optional[str] = None, restart_file_dir_path: Optional[str] = None, save_restarts=False, core_num: Optional[int] = None):
         """
-        Execute "wrf.exe"
+        ``Executable`` of "wrf.exe"
 
-        :param input_file_dir_path: Path of the directory that stores input data for "wrf.exe".
+        :param input_file_dir_path: Directory path of input data.
         :type input_file_dir_path: str
-        :param restart_file_dir_path: Path of the directory that stores restart files for "wrf.exe".
+        :param restart_file_dir_path: Directory path of restart files.
         :type restart_file_dir_path: str
-        :param save_restarts: If saving restart files from "wrf.exe". Defaults to False.
+        :param save_restarts: If saving restart files. Defaults to False.
         :type save_restarts: bool
-        :param core_num: An positive integer number of used core numbers. ``mpirun`` will be used to execute geogrid.exe if ``core_num != None``.
+        :param core_num: An positive integer number. ``mpirun`` will be used to execute geogrid.exe if ``core_num != None``.
         :type core_num: int
         """
         if isinstance(core_num, int) and core_num <= 0:
@@ -479,15 +564,22 @@ class WRF(ExecutableBase):
             mpi_cmd = "mpirun"
             mpi_core_num = core_num
 
-        _check_namelist_preparation()
+        _check_and_prepare_namelist()
 
-        super().__init__(name="wrf", cmd="./wrf.exe", work_path=WRFRUNConfig.WRF_WORK_PATH, mpi_use=mpi_use, mpi_cmd=mpi_cmd, mpi_core_num=mpi_core_num)
+        super().__init__(name="wrf", cmd="./wrf.exe", work_path=WORKSPACE_MODEL_WRF, mpi_use=mpi_use, mpi_cmd=mpi_cmd, mpi_core_num=mpi_core_num)
 
         self.input_file_dir_path = input_file_dir_path
         self.restart_file_dir_path = restart_file_dir_path
         self.save_restarts = save_restarts
 
     def generate_custom_config(self):
+        """
+        Store custom configs, including:
+
+        1. Directory path of input datas.
+        2. Directory path of restart files.
+        3. Namelist settings.
+        """
         self.custom_config.update(
             {
                 "input_file_dir_path": self.input_file_dir_path,
@@ -497,6 +589,9 @@ class WRF(ExecutableBase):
         )
 
     def load_custom_config(self):
+        """
+        Load custom configs.
+        """
         self.input_file_dir_path = self.custom_config["input_file_dir_path"]
         self.restart_file_dir_path = self.custom_config["restart_file_dir_path"]
         WRFRUNConfig.update_namelist(self.custom_config["namelist"], "wrf")
@@ -530,7 +625,7 @@ class WRF(ExecutableBase):
                 for _file in file_list:
                     _file_config: FileConfigDict = {
                         "file_path": f"{self.input_file_dir_path}/{_file}",
-                        "save_path": WRFRUNConfig.WRF_WORK_PATH,
+                        "save_path": WORKSPACE_MODEL_WRF,
                         "save_name": _file,
                         "is_data": True,
                         "is_output": is_output
@@ -552,7 +647,7 @@ class WRF(ExecutableBase):
                 for _file in file_list:
                     _file_config: FileConfigDict = {
                         "file_path": f"{self.restart_file_dir_path}/{_file}",
-                        "save_path": WRFRUNConfig.WRF_WORK_PATH,
+                        "save_path": WORKSPACE_MODEL_WRF,
                         "save_name": _file,
                         "is_data": True,
                         "is_output": False
@@ -561,7 +656,7 @@ class WRF(ExecutableBase):
 
         super().before_exec()
 
-        WRFRUNConfig.write_namelist(f"{WRFRUNConfig.WRF_WORK_PATH}/{NamelistName.WRF}", "wrf")
+        WRFRUNConfig.write_namelist(f"{WORKSPACE_MODEL_WRF}/{NamelistName.WRF}", "wrf")
 
     def after_exec(self):
         if not WRFRUNConfig.IS_IN_REPLAY:
@@ -578,18 +673,18 @@ class WRF(ExecutableBase):
 
 class DFI(ExecutableBase):
     """
-    Execute "wrf.exe" to run DFI.
+    ``Executable`` to run DFI.
     """
 
     def __init__(self, input_file_dir_path: Optional[str] = None, update_real_output=True, core_num: Optional[int] = None):
         """
-        Execute "wrf.exe" to run DFI.
+        ``Executable`` to run DFI.
 
-        :param input_file_dir_path: Path of the directory that stores input data for "wrf.exe".
+        :param input_file_dir_path: Directory path of input data.
         :type input_file_dir_path: str
-        :param update_real_output: If update the corresponding file in real.exe output directory.
+        :param update_real_output: If update corresponding files in :class:`Real` outputs.
         :type update_real_output: bool
-        :param core_num: An positive integer number of used core numbers. ``mpirun`` will be used to execute geogrid.exe if ``core_num != None``.
+        :param core_num: An positive integer number. ``mpirun`` will be used to execute geogrid.exe if ``core_num != None``.
         :type core_num: int
         """
         if isinstance(core_num, int) and core_num <= 0:
@@ -606,12 +701,19 @@ class DFI(ExecutableBase):
             mpi_cmd = "mpirun"
             mpi_core_num = core_num
 
-        super().__init__(name="dfi", cmd="./wrf.exe", work_path=WRFRUNConfig.WRF_WORK_PATH, mpi_use=mpi_use, mpi_cmd=mpi_cmd, mpi_core_num=mpi_core_num)
+        super().__init__(name="dfi", cmd="./wrf.exe", work_path=WORKSPACE_MODEL_WRF, mpi_use=mpi_use, mpi_cmd=mpi_cmd, mpi_core_num=mpi_core_num)
 
         self.input_file_dir_path = input_file_dir_path
         self.update_real_output = update_real_output
 
     def generate_custom_config(self):
+        """
+        Store custom configs, including:
+
+        1. Directory path of input datas.
+        2. If update corresponding files in :class:`Real` outputs.
+        3. Namelist settings.
+        """
         self.custom_config.update(
             {
                 "input_file_dir_path": self.input_file_dir_path,
@@ -621,6 +723,9 @@ class DFI(ExecutableBase):
         )
 
     def load_custom_config(self):
+        """
+        Load custom configs.
+        """
         self.input_file_dir_path = self.custom_config["input_file_dir_path"]
         self.update_real_output = self.custom_config["update_real_output"]
 
@@ -650,7 +755,7 @@ class DFI(ExecutableBase):
                 for _file in file_list:
                     _file_config: FileConfigDict = {
                         "file_path": f"{self.input_file_dir_path}/{_file}",
-                        "save_path": WRFRUNConfig.WRF_WORK_PATH,
+                        "save_path": WORKSPACE_MODEL_WRF,
                         "save_name": _file,
                         "is_data": True,
                         "is_output": is_output
@@ -664,7 +769,7 @@ class DFI(ExecutableBase):
             prepare_dfi_namelist()
 
         super().before_exec()
-        WRFRUNConfig.write_namelist(f"{WRFRUNConfig.WRF_WORK_PATH}/{NamelistName.WRF}", "dfi")
+        WRFRUNConfig.write_namelist(f"{WORKSPACE_MODEL_WRF}/{NamelistName.WRF}", "dfi")
 
     def after_exec(self):
         if not WRFRUNConfig.IS_IN_REPLAY:
@@ -686,21 +791,21 @@ class DFI(ExecutableBase):
 
 class NDown(ExecutableBase):
     """
-    Execute "ndown.exe".
+    ``Executable`` of "ndown.exe".
     """
 
     def __init__(self, wrfout_file_path: str, real_output_dir_path: Optional[str] = None, update_namelist=True, core_num: Optional[int] = None):
         """
-        Execute "ndown.exe".
+        ``Executable`` of "ndown.exe".
 
         :param wrfout_file_path: wrfout file path.
         :type wrfout_file_path: str
-        :param real_output_dir_path: Path of the directory that contains output of "real.exe".
+        :param real_output_dir_path: Directory path of :class:`Real` outputs.
         :type real_output_dir_path: str
-        :param update_namelist: If update wrf's namelist for the final integral.
+        :param update_namelist: If update namelist settings for the final integral.
         :type update_namelist: bool
-        :param core_num:
-        :type core_num:
+        :param core_num: An positive integer number. ``mpirun`` will be used to execute geogrid.exe if ``core_num != None``.
+        :type core_num: int
         """
         if isinstance(core_num, int) and core_num <= 0:
             logger.warning(f"`core_num` should be greater than 0")
@@ -716,15 +821,23 @@ class NDown(ExecutableBase):
             mpi_cmd = "mpirun"
             mpi_core_num = core_num
 
-        _check_namelist_preparation()
+        _check_and_prepare_namelist()
 
-        super().__init__(name="ndown", cmd="./ndown.exe", work_path=WRFRUNConfig.WRF_WORK_PATH, mpi_use=mpi_use, mpi_cmd=mpi_cmd, mpi_core_num=mpi_core_num)
+        super().__init__(name="ndown", cmd="./ndown.exe", work_path=WORKSPACE_MODEL_WRF, mpi_use=mpi_use, mpi_cmd=mpi_cmd, mpi_core_num=mpi_core_num)
 
         self.wrfout_file_path = wrfout_file_path
         self.real_output_dir_path = real_output_dir_path
         self.update_namelist = update_namelist
 
     def generate_custom_config(self):
+        """
+        Store custom configs, including:
+
+        1. Positional arguments of this ``Executable``.
+        2. Directory path of :class:`Real` outputs.
+        3. If update namelist settings.
+        4. Namelist settings.
+        """
         self.class_config["class_args"] = (self.wrfout_file_path,)
         self.custom_config.update(
             {
@@ -735,6 +848,9 @@ class NDown(ExecutableBase):
         )
 
     def load_custom_config(self):
+        """
+        Load custom configs.
+        """
         self.real_output_dir_path = self.custom_config["real_output_dir_path"]
         self.update_namelist = self.custom_config["update_namelist"]
         WRFRUNConfig.update_namelist(self.custom_config["namelist"])
@@ -756,14 +872,14 @@ class NDown(ExecutableBase):
 
         wrfndi_file_config: FileConfigDict = {
             "file_path": f"{self.real_output_dir_path}/wrfinput_d02",
-            "save_path": WRFRUNConfig.WRF_WORK_PATH,
+            "save_path": WORKSPACE_MODEL_WRF,
             "save_name": "wrfndi_d02",
             "is_data": True,
             "is_output": is_output
         }
         wrfout_file_config: FileConfigDict = {
             "file_path": self.wrfout_file_path,
-            "save_path": WRFRUNConfig.WRF_WORK_PATH,
+            "save_path": WORKSPACE_MODEL_WRF,
             "save_name": "wrfout_d01",
             "is_data": True,
             "is_output": False
@@ -773,7 +889,7 @@ class NDown(ExecutableBase):
 
         super().before_exec()
 
-        WRFRUNConfig.write_namelist(f"{WRFRUNConfig.WRF_WORK_PATH}/{NamelistName.WRF}", "wrf")
+        WRFRUNConfig.write_namelist(f"{WORKSPACE_MODEL_WRF}/{NamelistName.WRF}", "wrf")
 
     def after_exec(self):
         self.add_output_files(save_path=self._log_save_path, startswith="rsl.", outputs="namelist.input")