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

wrfrun/model/wrf/namelist.py

@@ -1,13 +1,33 @@
+"""
+wrfrun.model.wrf.namelist
+#########################
+
+Functions to read and change WPS/WRF namelist.
+
+.. autosummary::
+    :toctree: generated/
+
+    prepare_wrf_namelist
+    prepare_wps_namelist
+    prepare_wrfda_namelist
+    prepare_dfi_namelist
+    get_ungrib_out_prefix
+    get_ungrib_out_dir_path
+    set_ungrib_out_prefix
+    get_metgrid_fg_names
+    set_metgrid_fg_names
+"""
+
 from datetime import datetime, timedelta
-from os.path import exists, dirname, basename
+from os.path import basename, dirname, exists
 from typing import Union
 
-from wrfrun.core import WRFRUNConfig
+from wrfrun.log import logger
 from wrfrun.res import NAMELIST_DFI, NAMELIST_WPS, NAMELIST_WRF, NAMELIST_WRFDA
-from wrfrun.utils import logger
-from wrfrun.workspace.wrf import WORKSPACE_MODEL_WPS
-from .scheme import *
+from wrfrun.workspace.wrf import get_wrf_workspace_path
 
+from ...core.core import WRFRUN
+from .scheme import SchemeCumulus, SchemeLandSurfaceModel, SchemeLongWave, SchemePBL, SchemeShortWave, SchemeSurfaceLayer
 
 UNGRIB_OUTPUT_DIR = "./outputs"
 
@@ -19,8 +39,8 @@ def get_ungrib_out_dir_path() -> str:
     :return: URI path.
     :rtype: str
     """
-    wif_prefix = WRFRUNConfig.get_namelist("wps")["ungrib"]["prefix"]
-    wif_path = f"{WORKSPACE_MODEL_WPS}/{dirname(wif_prefix)}"
+    wif_prefix = WRFRUN.config.get_namelist("wps")["ungrib"]["prefix"]
+    wif_path = f"{get_wrf_workspace_path('wps')}/{dirname(wif_prefix)}"
 
     return wif_path
 
@@ -32,7 +52,7 @@ def get_ungrib_out_prefix() -> str:
     :return: Prefix string of ungrib output (WRF intermediate file).
     :rtype: str
     """
-    wif_prefix = WRFRUNConfig.get_namelist("wps")["ungrib"]["prefix"]
+    wif_prefix = WRFRUN.config.get_namelist("wps")["ungrib"]["prefix"]
     wif_prefix = basename(wif_prefix)
     return wif_prefix
 
@@ -44,11 +64,7 @@ def set_ungrib_out_prefix(prefix: str):
     :param prefix: Prefix string of ungrib output (WRF intermediate file).
     :type prefix: str
     """
-    WRFRUNConfig.update_namelist(
-        {
-            "ungrib": {"prefix": f"{UNGRIB_OUTPUT_DIR}/{prefix}"}
-        }, "wps"
-    )
+    WRFRUN.config.update_namelist({"ungrib": {"prefix": f"{UNGRIB_OUTPUT_DIR}/{prefix}"}}, "wps")
 
 
 def get_metgrid_fg_names() -> list[str]:
@@ -58,7 +74,7 @@ def get_metgrid_fg_names() -> list[str]:
     :return: Prefix strings list.
     :rtype: list
     """
-    fg_names = WRFRUNConfig.get_namelist("wps")["metgrid"]["fg_name"]
+    fg_names = WRFRUN.config.get_namelist("wps")["metgrid"]["fg_name"]
     fg_names = [basename(x) for x in fg_names]
     return fg_names
 
@@ -71,16 +87,16 @@ def set_metgrid_fg_names(prefix: Union[str, list[str]]):
     :type prefix: str | list
     """
     if isinstance(prefix, str):
-        prefix = [prefix, ]
+        prefix = [
+            prefix,
+        ]
     fg_names = [f"{UNGRIB_OUTPUT_DIR}/{x}" for x in prefix]
-    WRFRUNConfig.update_namelist(
-        {
-            "metgrid": {"fg_name": fg_names}
-        }, "wps"
-    )
+    WRFRUN.config.update_namelist({"metgrid": {"fg_name": fg_names}}, "wps")
 
 
-def _check_start_end_date(max_dom: int, start_date: Union[datetime, list[datetime]], end_date: Union[datetime, list[datetime]]) -> tuple[list[datetime], list[datetime]]:
+def _check_start_end_date(
+    max_dom: int, start_date: Union[datetime, list[datetime]], end_date: Union[datetime, list[datetime]]
+) -> tuple[list[datetime], list[datetime]]:
     """
     Format start date and end date.
 
@@ -116,8 +132,8 @@ def prepare_wps_namelist():
 
     """
     # prepare namelist
-    WRFRUNConfig.read_namelist(WRFRUNConfig.parse_resource_uri(NAMELIST_WPS), "wps")
-    wrf_config = WRFRUNConfig.get_model_config("wrf")
+    WRFRUN.config.read_namelist(WRFRUN.config.parse_resource_uri(NAMELIST_WPS), "wps")
+    wrf_config = WRFRUN.config.get_model_config("wrf")
 
     # get domain number
     max_dom = wrf_config["domain"]["domain_num"]
@@ -135,12 +151,7 @@ def prepare_wps_namelist():
 
     # generate update settings based on the config file
     update_value = {
-        "share": {
-            "max_dom": max_dom,
-            "start_date": start_date,
-            "end_date": end_date,
-            "interval_seconds": interval_seconds
-        },
+        "share": {"max_dom": max_dom, "start_date": start_date, "end_date": end_date, "interval_seconds": interval_seconds},
         "geogrid": {
             "parent_grid_ratio": wrf_config["domain"]["parent_grid_ratio"],
             "i_parent_start": wrf_config["domain"]["i_parent_start"],
@@ -155,18 +166,18 @@ def prepare_wps_namelist():
             "truelat1": wrf_config["domain"]["truelat1"],
             "truelat2": wrf_config["domain"]["truelat2"],
             "stand_lon": wrf_config["domain"]["stand_lon"],
-            "geog_data_path": wrf_config["geog_data_path"]
+            "geog_data_path": wrf_config["geog_data_path"],
         },
         "ungrib": {"prefix": f"{UNGRIB_OUTPUT_DIR}/FILE"},
-        "metgrid": {"fg_name": f"{UNGRIB_OUTPUT_DIR}/FILE"}
+        "metgrid": {"fg_name": f"{UNGRIB_OUTPUT_DIR}/FILE"},
     }
 
     # # update namelist
-    WRFRUNConfig.update_namelist(update_value, "wps")
+    WRFRUN.config.update_namelist(update_value, "wps")
 
     # # update settings from custom namelist
     if wrf_config["user_wps_namelist"] != "" and exists(wrf_config["user_wps_namelist"]):
-        WRFRUNConfig.update_namelist(wrf_config["user_wps_namelist"], "wps")
+        WRFRUN.config.update_namelist(wrf_config["user_wps_namelist"], "wps")
 
 
 def prepare_wrf_namelist():
@@ -175,10 +186,10 @@ def prepare_wrf_namelist():
 
     """
     # read template namelist
-    WRFRUNConfig.read_namelist(WRFRUNConfig.parse_resource_uri(NAMELIST_WRF), "wrf")
+    WRFRUN.config.read_namelist(WRFRUN.config.parse_resource_uri(NAMELIST_WRF), "wrf")
 
     # wrf config from config
-    wrf_config = WRFRUNConfig.get_model_config("wrf")
+    wrf_config = WRFRUN.config.get_model_config("wrf")
 
     # get debug level
     debug_level = wrf_config["debug_level"]
@@ -187,7 +198,7 @@ def prepare_wrf_namelist():
     max_dom = wrf_config["domain"]["domain_num"]
     start_date = wrf_config["time"]["start_date"]
     end_date = wrf_config["time"]["end_date"]
-    
+
     start_date, end_date = _check_start_end_date(max_dom, start_date, end_date)
 
     # get the time interval of input data and output data
@@ -251,9 +262,8 @@ def prepare_wrf_namelist():
             "e_sn": wrf_config["domain"]["e_sn"],
             "dx": dx,
             "dy": dy,
-
         },
-        "physics": {}
+        "physics": {},
     }
 
     # and we need to check the physics scheme option
@@ -266,11 +276,12 @@ def prepare_wrf_namelist():
     update_values["physics"].update(long_wave_scheme)
 
     short_wave_scheme = {
-        "ra_sw_physics": [SchemeShortWave.get_scheme_id(wrf_config["scheme"]["short_wave_scheme"]["name"]) for _ in range(max_dom)]
+        "ra_sw_physics": [
+            SchemeShortWave.get_scheme_id(wrf_config["scheme"]["short_wave_scheme"]["name"]) for _ in range(max_dom)
+        ]
     }
     # # and other related options
-    short_wave_scheme.update(
-        wrf_config["scheme"]["short_wave_scheme"]["option"])
+    short_wave_scheme.update(wrf_config["scheme"]["short_wave_scheme"]["option"])
     # update
     update_values["physics"].update(short_wave_scheme)
 
@@ -282,49 +293,47 @@ def prepare_wrf_namelist():
     # update
     update_values["physics"].update(cumulus_scheme)
 
-    pbl_scheme = {
-        "bl_pbl_physics": [SchemePBL.get_scheme_id(wrf_config["scheme"]["pbl_scheme"]["name"]) for _ in range(max_dom)]
-    }
+    pbl_scheme = {"bl_pbl_physics": [SchemePBL.get_scheme_id(wrf_config["scheme"]["pbl_scheme"]["name"]) for _ in range(max_dom)]}
     # # and other related options
     pbl_scheme.update(wrf_config["scheme"]["pbl_scheme"]["option"])
     # update
     update_values["physics"].update(pbl_scheme)
 
     land_surface_scheme = {
-        "sf_surface_physics": [SchemeLandSurfaceModel.get_scheme_id(wrf_config["scheme"]["land_surface_scheme"]["name"]) for _ in range(max_dom)]
+        "sf_surface_physics": [
+            SchemeLandSurfaceModel.get_scheme_id(wrf_config["scheme"]["land_surface_scheme"]["name"]) for _ in range(max_dom)
+        ]
     }
     # # and other related options
-    land_surface_scheme.update(
-        wrf_config["scheme"]["land_surface_scheme"]["option"])
+    land_surface_scheme.update(wrf_config["scheme"]["land_surface_scheme"]["option"])
     # update
     update_values["physics"].update(land_surface_scheme)
 
     surface_layer_scheme = {
-        "sf_sfclay_physics": [SchemeSurfaceLayer.get_scheme_id(wrf_config["scheme"]["surface_layer_scheme"]["name"]) for _ in range(max_dom)]
+        "sf_sfclay_physics": [
+            SchemeSurfaceLayer.get_scheme_id(wrf_config["scheme"]["surface_layer_scheme"]["name"]) for _ in range(max_dom)
+        ]
     }
     # # and other related options
-    surface_layer_scheme.update(
-        wrf_config["scheme"]["surface_layer_scheme"]["option"])
+    surface_layer_scheme.update(wrf_config["scheme"]["surface_layer_scheme"]["option"])
     # update
     update_values["physics"].update(surface_layer_scheme)
 
     # update namelist
-    WRFRUNConfig.update_namelist(update_values, "wrf")
+    WRFRUN.config.update_namelist(update_values, "wrf")
 
     # read user real namelist and update value
     user_namelist_data = wrf_config["user_wrf_namelist"]
     if user_namelist_data != "" and exists(user_namelist_data):
-        WRFRUNConfig.update_namelist(user_namelist_data, "wrf")
+        WRFRUN.config.update_namelist(user_namelist_data, "wrf")
 
 
 def prepare_dfi_namelist():
-    """Generate namelist data for DFI running
-
-    """
+    """Generate namelist data for DFI running"""
     # Read template namelist
-    WRFRUNConfig.read_namelist(WRFRUNConfig.parse_resource_uri(NAMELIST_DFI), "dfi")
+    WRFRUN.config.read_namelist(WRFRUN.config.parse_resource_uri(NAMELIST_DFI), "dfi")
 
-    wrf_config = WRFRUNConfig.get_model_config("wrf")
+    wrf_config = WRFRUN.config.get_model_config("wrf")
 
     # Read start date and end date
     start_date = wrf_config["time"]["start_date"]
@@ -366,7 +375,9 @@ def prepare_dfi_namelist():
             "end_minute": [start_date.minute],
             "end_second": [start_date.second],
             "interval_seconds": input_data_interval,
-            "auxinput4_interval_s": [input_data_interval, ]
+            "auxinput4_interval_s": [
+                input_data_interval,
+            ],
         },
         "domains": {
             # make sure max_dom = 1
@@ -395,26 +406,24 @@ def prepare_dfi_namelist():
             "dfi_fwdstop_hour": dfi_end_date.hour,
             "dfi_fwdstop_minute": dfi_end_date.minute,
             "dfi_fwdstop_second": dfi_end_date.second,
-        }
+        },
     }
 
     # update namelist data
-    WRFRUNConfig.update_namelist(update_value, "dfi")
+    WRFRUN.config.update_namelist(update_value, "dfi")
 
     # read user wrf namelist and update value
     user_namelist_data = wrf_config["user_wrf_namelist"]
     if user_namelist_data != "" and exists(user_namelist_data):
-        WRFRUNConfig.update_namelist(user_namelist_data, "dfi")
+        WRFRUN.config.update_namelist(user_namelist_data, "dfi")
 
 
 def prepare_wrfda_namelist():
-    """Generate namelist for da_wrfvar.exe
-
-    """
+    """Generate namelist for da_wrfvar.exe"""
     # read template namelist
-    WRFRUNConfig.read_namelist(WRFRUNConfig.parse_resource_uri(NAMELIST_WRFDA), "wrfda")
+    WRFRUN.config.read_namelist(WRFRUN.config.parse_resource_uri(NAMELIST_WRFDA), "wrfda")
 
-    wrf_config = WRFRUNConfig.get_model_config("wrf")
+    wrf_config = WRFRUN.config.get_model_config("wrf")
 
     # get wrf start date
     start_date = wrf_config["time"]["start_date"]
@@ -422,9 +431,7 @@ def prepare_wrfda_namelist():
 
     # generate update value
     update_value = {
-        "wrfvar18": {
-            "analysis_date": start_date.strftime("%Y-%m-%d_%H:%M:%S.0000")
-        },
+        "wrfvar18": {"analysis_date": start_date.strftime("%Y-%m-%d_%H:%M:%S.0000")},
         "wrfvar21": {
             # one hour before wrf start date
             "time_window_min": (start_date - timedelta(hours=1)).strftime("%Y-%m-%d_%H:%M:%S.0000")
@@ -432,17 +439,26 @@ def prepare_wrfda_namelist():
         "wrfvar22": {
             # one hour after wrf start date
             "time_window_max": (start_date + timedelta(hours=1)).strftime("%Y-%m-%d_%H:%M:%S.0000")
-        }
+        },
     }
 
     # update namelist
-    WRFRUNConfig.update_namelist(update_value, "wrfda")
+    WRFRUN.config.update_namelist(update_value, "wrfda")
 
     # read user wrfda namelist and update value
     user_namelist_data = wrf_config["user_wrfda_namelist"]
     if user_namelist_data != "" and exists(user_namelist_data):
-        WRFRUNConfig.update_namelist(user_namelist_data, "wrfda")
-
-
-__all__ = ["prepare_wrf_namelist", "prepare_wps_namelist", "prepare_wrfda_namelist", "prepare_dfi_namelist", "get_ungrib_out_prefix", "get_ungrib_out_dir_path",
-           "set_ungrib_out_prefix", "get_metgrid_fg_names", "set_metgrid_fg_names"]
+        WRFRUN.config.update_namelist(user_namelist_data, "wrfda")
+
+
+__all__ = [
+    "prepare_wrf_namelist",
+    "prepare_wps_namelist",
+    "prepare_wrfda_namelist",
+    "prepare_dfi_namelist",
+    "get_ungrib_out_prefix",
+    "get_ungrib_out_dir_path",
+    "set_ungrib_out_prefix",
+    "get_metgrid_fg_names",
+    "set_metgrid_fg_names",
+]

wrfrun/model/wrf/plot.py

@@ -0,0 +1,102 @@
+"""
+wrfrun.model.wrf.plot
+#####################
+
+Functions to generate config to plot domain area.
+
+.. autosummary::
+    :toctree: generated/
+
+    domain_settings_from_config_wrf
+    domain_settings_from_namelist_wrf
+"""
+
+from os.path import exists
+from typing import Union
+
+import f90nml
+
+from wrfrun.core import WRFRUN
+from wrfrun.log import logger
+
+from ..type import DomainSetting
+
+
+def domain_settings_from_config_wrf() -> DomainSetting:
+    """
+    Generate domain settings based on the config from :doc:`WRFRUN </api/core.core>`.
+
+    :return: :class:`DomainSetting <wrfrun.model.type.DomainSetting>` object.
+    :rtype: DomainSetting
+    """
+    user_settings = WRFRUN.config.get_model_config("wrf")["domain"]
+    domain_settings: DomainSetting = {
+        "resolution_x": user_settings["dx"],
+        "resolution_y": user_settings["dy"],
+        "points_y": user_settings["e_sn"],
+        "points_x": user_settings["e_we"],
+        "x_parent_index": user_settings["i_parent_start"],
+        "y_parent_index": user_settings["j_parent_start"],
+        "domain_num": user_settings["domain_num"],
+        "grid_spacing_ratio": user_settings["parent_grid_ratio"],
+        "reference_lat": user_settings["ref_lat"],
+        "reference_lon": user_settings["ref_lon"],
+        "true_lat1": user_settings["truelat1"],
+        "true_lat2": user_settings["truelat2"],
+        "stand_lon": user_settings["stand_lon"],
+        "projection_type": user_settings["map_proj"],
+    }
+
+    return domain_settings
+
+
+def domain_settings_from_namelist_wrf(namelist: Union[str, dict]) -> DomainSetting:
+    """
+    Read values from WPS/WRF namelist and generate domain settings.
+
+    You can give either the path of namelist file or the dict returned by ``f90nml``.
+
+    1. Parse values in a namelist file.
+
+    >>> namelist_file_path = "./namelist.wps"
+    >>> domain_settings = domain_settings_from_namelist_wrf(namelist_file_path)
+
+    2. Parse values from dict.
+
+    >>> namelist_file_path = "./namelist.wps"
+    >>> namelist_data = f90nml.read(namelist_file_path).todict()
+    >>> domain_settings = domain_settings_from_namelist_wrf(namelist_data)
+
+    :param namelist: Path of the namelist file or the dict returned by ``f90nml``.
+    :type namelist: str | dict
+    :return: :class:`DomainSetting <wrfrun.model.type.DomainSetting>`.
+    :rtype: DomainSetting
+    """
+    if isinstance(namelist, str):
+        if not exists(namelist):
+            logger.error(f"Namelist file not found: {namelist}")
+            raise FileNotFoundError(namelist)
+
+        namelist = f90nml.read(namelist).todict()
+
+    domain_setting: DomainSetting = {
+        "resolution_x": namelist["geogrid"]["dx"],
+        "resolution_y": namelist["geogrid"]["dy"],
+        "points_y": namelist["geogrid"]["e_sn"],
+        "points_x": namelist["geogrid"]["e_we"],
+        "x_parent_index": namelist["geogrid"]["i_parent_start"],
+        "y_parent_index": namelist["geogrid"]["j_parent_start"],
+        "domain_num": namelist["share"]["max_dom"],
+        "grid_spacing_ratio": namelist["geogrid"]["parent_grid_ratio"],
+        "reference_lat": namelist["geogrid"]["ref_lat"],
+        "reference_lon": namelist["geogrid"]["ref_lon"],
+        "true_lat1": namelist["geogrid"]["truelat1"],
+        "true_lat2": namelist["geogrid"]["truelat2"],
+        "stand_lon": namelist["geogrid"]["stand_lon"],
+        "projection_type": namelist["geogrid"]["map_proj"],
+    }
+
+    return domain_setting
+
+
+__all__ = ["domain_settings_from_config_wrf", "domain_settings_from_namelist_wrf"]