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

wrfrun/model/plot.py

@@ -1,5 +1,21 @@
+"""
+wrfrun.model.plot
+#################
+
+This module is used to plot domain area so users can check their domain settings before running simulation.
+
+.. autosummary::
+    :toctree: generated/
+
+    _calculate_x_y_offset
+    create_projection
+    parse_domain_setting
+    plot_domain_area
+    generate_domain_area
+"""
+
 from os.path import abspath, exists
-from typing import Literal, Optional, TypedDict, Union
+from typing import Union
 
 import cartopy.feature as cfeature
 import f90nml
@@ -8,31 +24,14 @@ from cartopy import crs
 from cartopy.mpl.geoaxes import GeoAxes
 from cartopy.mpl.gridliner import LATITUDE_FORMATTER, LONGITUDE_FORMATTER
 from haversine.haversine import Direction, Unit, inverse_haversine
+from matplotlib.figure import Figure
 
-from wrfrun.core import WRFRUNConfig
-from wrfrun.utils import check_path, logger
+from ..core import WRFRUN
+from ..log import logger
+from ..utils import check_path
+from .type import DomainSetting
 
 
-class DomainSetting(TypedDict):
-    """
-    Domain settings which can be used to create a projection.
-    """
-    dx: int
-    dy: int
-    e_sn: Union[list[int], tuple[int]]
-    e_we: Union[list[int], tuple[int]]
-    i_parent_start: Union[list[int], tuple[int]]
-    j_parent_start: Union[list[int], tuple[int]]
-    max_dom: int
-    parent_grid_ratio: Union[list[int], tuple[int]]
-    map_proj: Literal["lambert", "polar", "mercator", "lat-lon"]
-    ref_lat: Union[int, float]
-    ref_lon: Union[int, float]
-    truelat1: Union[int, float]
-    truelat2: Union[int, float]
-    stand_lon: Union[int, float]
-    
-    
 def _calculate_x_y_offset(domain_settings: DomainSetting) -> tuple[float, float]:
     """
     Calculate X and Y offset from planar origin in metres.
@@ -42,12 +41,14 @@ def _calculate_x_y_offset(domain_settings: DomainSetting) -> tuple[float, float]
     :return: (X offset, Y offset)
     :rtype: tuple
     """
-    false_easting = (domain_settings["e_we"][0] - 1) / 2 * domain_settings["dx"]
-    false_northing = (domain_settings["e_sn"][0] - 1) / 2 * domain_settings["dy"]
+    false_easting = (domain_settings["points_x"][0] - 1) / 2 * domain_settings["resolution_x"]
+    false_northing = (domain_settings["points_y"][0] - 1) / 2 * domain_settings["resolution_y"]
     return false_easting, false_northing
 
 
-def create_projection(domain_settings: DomainSetting) -> crs.Projection:
+def create_projection(
+    domain_settings: DomainSetting,
+) -> Union[crs.LambertConformal, crs.NorthPolarStereo, crs.SouthPolarStereo, crs.Mercator, crs.PlateCarree]:
     """
     Create a projection from domain settings which can be used to draw images.
 
@@ -59,26 +60,25 @@ def create_projection(domain_settings: DomainSetting) -> crs.Projection:
     :return: Projection object and the used domain settings.
     :rtype: (Projection, domain settings)
     """
-    match domain_settings["map_proj"]:
+    # declare the proj to pass static type check
+    proj = None
 
+    match domain_settings["projection_type"]:
         case "lat-lon":
-            proj = crs.PlateCarree(central_longitude=domain_settings["ref_lon"])
+            proj = crs.PlateCarree(central_longitude=domain_settings["reference_lon"])
 
         case "lambert":
             false_easting, false_northing = _calculate_x_y_offset(domain_settings)
             proj = crs.LambertConformal(
-                central_longitude=domain_settings["ref_lon"],
-                central_latitude=domain_settings["ref_lat"],
-                standard_parallels=(
-                    domain_settings["truelat1"],
-                    domain_settings["truelat2"]
-                ),
+                central_longitude=domain_settings["reference_lon"],
+                central_latitude=domain_settings["reference_lat"],
+                standard_parallels=(domain_settings["true_lat1"], domain_settings["true_lat2"]),
                 false_easting=false_easting,
-                false_northing=false_northing
+                false_northing=false_northing,
             )
 
         case "polar":
-            ref_lat = domain_settings["ref_lat"]
+            ref_lat = domain_settings["reference_lat"]
             if ref_lat > 0:
                 proj = crs.NorthPolarStereo(central_longitude=domain_settings["stand_lon"])
 
@@ -97,17 +97,18 @@ def create_projection(domain_settings: DomainSetting) -> crs.Projection:
             # ref_lat_distance = ref_lat_distance if central_latitude < 0 else -ref_lat_distance
             # false_northing = ref_lat_distance + false_northing
             proj = crs.Mercator(
-                central_longitude=domain_settings["ref_lon"],
-                latitude_true_scale=domain_settings["truelat1"],
+                central_longitude=domain_settings["reference_lon"],
+                latitude_true_scale=domain_settings["true_lat1"],
                 # false_northing=false_northing,
                 # false_easting=false_easting
             )
 
-        case _:
-            logger.error(f"Unknown projection name: {domain_settings['map_proj']}")
-            raise KeyError(f"Unknown projection name: {domain_settings['map_proj']}")
+    if proj is not None:
+        return proj
 
-    return proj
+    else:
+        logger.error(f"Unknown projection name: {domain_settings['projection_type']}")
+        raise KeyError(f"Unknown projection name: {domain_settings['projection_type']}")
 
 
 def parse_domain_setting(namelist: Union[str, dict]) -> DomainSetting:
@@ -140,30 +141,26 @@ def parse_domain_setting(namelist: Union[str, dict]) -> DomainSetting:
         namelist = f90nml.read(namelist).todict()
 
     domain_setting: DomainSetting = {
-        "dx": namelist["geogrid"]["dx"],
-        "dy": namelist["geogrid"]["dy"],
-        "e_sn": namelist["geogrid"]["e_sn"],
-        "e_we": namelist["geogrid"]["e_we"],
-        "i_parent_start": namelist["geogrid"]["i_parent_start"],
-        "j_parent_start": namelist["geogrid"]["j_parent_start"],
-        "max_dom": namelist["share"]["max_dom"],
-        "parent_grid_ratio": namelist["geogrid"]["parent_grid_ratio"],
-        "ref_lat": namelist["geogrid"]["ref_lat"],
-        "ref_lon": namelist["geogrid"]["ref_lon"],
-        "truelat1": namelist["geogrid"]["truelat1"],
-        "truelat2": namelist["geogrid"]["truelat2"],
+        "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"],
-        "map_proj": namelist["geogrid"]["map_proj"]
+        "projection_type": namelist["geogrid"]["map_proj"],
     }
 
     return domain_setting
 
 
-def plot_domain_area(
-    fig: plt.Figure,
-    domain_settings: Optional[DomainSetting] = None,
-    model_name: Optional[str] = None
-):
+def plot_domain_area(fig: Figure, domain_settings: DomainSetting):
     """
     Plot domain area based on domain settings.
 
@@ -175,74 +172,53 @@ def plot_domain_area(
     :type fig: Figure
     :param domain_settings: Dictionary contains domain settings. If None, read domain settings from ``WRFRUNConfig``.
     :type domain_settings: DomainSetting | None
-    :param model_name: Model's name for reading domain settings.
-    :type model_name: str | None
     """
-    if domain_settings is None:
-        if model_name is None:
-            logger.error("You need to give 'model_name' if `domain_settings == None`")
-            raise ValueError("You need to give 'model_name' if `domain_settings == None`")
-
-        user_settings = WRFRUNConfig.get_model_config(model_name)["domain"]
-        domain_settings: DomainSetting = {
-            "dx": user_settings["dx"],
-            "dy": user_settings["dy"],
-            "e_sn": user_settings["e_sn"],
-            "e_we": user_settings["e_we"],
-            "i_parent_start": user_settings["i_parent_start"],
-            "j_parent_start": user_settings["j_parent_start"],
-            "max_dom": user_settings["domain_num"],
-            "parent_grid_ratio": user_settings["parent_grid_ratio"],
-            "ref_lat": user_settings["ref_lat"],
-            "ref_lon": user_settings["ref_lon"],
-            "truelat1": user_settings["truelat1"],
-            "truelat2": user_settings["truelat2"],
-            "stand_lon": user_settings["stand_lon"],
-            "map_proj": user_settings["map_proj"]
-        }
-
     proj = create_projection(domain_settings)
 
     fig.clear()
-    ax: GeoAxes = fig.add_subplot(1, 1, 1, projection=proj)     # type: ignore
+    ax: GeoAxes = fig.add_subplot(1, 1, 1, projection=proj)  # type: ignore
     ax.coastlines(resolution="50m")
     ax.add_feature(cfeature.OCEAN)
     ax.add_feature(cfeature.LAND)
 
     # set gridline attributes, close the default labels
     grid_line = ax.gridlines(
-        draw_labels=True, dms=True, linestyle=":", linewidth=0.3,
-        x_inline=False, y_inline=False, color='k'
+        draw_labels=True,
+        dms=True,
+        linestyle=":",
+        linewidth=0.3,
+        x_inline=False,
+        y_inline=False,
+        color="k",
+        rotate_labels=None,
+        xformatter=LONGITUDE_FORMATTER,
+        yformatter=LATITUDE_FORMATTER,
     )
 
     # close coordinates labels on the top and right
     grid_line.top_labels = False
     grid_line.right_labels = False
 
-    # align coordinates labels
-    grid_line.rotate_labels = None
-
-    # set label formatter
-    grid_line.xformattter = LONGITUDE_FORMATTER
-    grid_line.yformatter = LATITUDE_FORMATTER
     ax.set_title("Domain Configuration")
 
     # set area range
-    match type(proj):
+    if isinstance(proj, crs.Mercator):
+        # we may need to calculate the range of longitude and latitude
+        ref_lon = domain_settings["reference_lon"]
+        ref_lat = domain_settings["reference_lat"]
+        false_easting, false_northing = _calculate_x_y_offset(domain_settings)
+        _, start_lon = inverse_haversine((ref_lat, ref_lon), false_easting, direction=Direction.WEST, unit=Unit.METERS)
+        _, end_lon = inverse_haversine((ref_lat, ref_lon), false_easting, direction=Direction.EAST, unit=Unit.METERS)
+        start_lat, _ = inverse_haversine((ref_lat, ref_lon), false_northing, direction=Direction.SOUTH, unit=Unit.METERS)
+        end_lat, _ = inverse_haversine((ref_lat, ref_lon), false_northing, direction=Direction.NORTH, unit=Unit.METERS)
+        ax.set_extent([start_lon, end_lon, start_lat, end_lat])
 
-        case crs.Mercator:
-            # we may need to calculate the range of longitude and latitude
-            ref_lon = domain_settings["ref_lon"]
-            ref_lat = domain_settings["ref_lat"]
-            false_easting, false_northing = _calculate_x_y_offset(domain_settings)
-            _, start_lon = inverse_haversine((ref_lat, ref_lon), false_easting, direction=Direction.WEST, unit=Unit.METERS)
-            _, end_lon = inverse_haversine((ref_lat, ref_lon), false_easting, direction=Direction.EAST, unit=Unit.METERS)
-            start_lat, _ = inverse_haversine((ref_lat, ref_lon), false_northing, direction=Direction.SOUTH, unit=Unit.METERS)
-            end_lat, _ = inverse_haversine((ref_lat, ref_lon), false_northing, direction=Direction.NORTH, unit=Unit.METERS)
-            ax.set_extent([start_lon, end_lon, start_lat, end_lat])
+    elif isinstance(proj, crs.LambertConformal):
+        false_easting, false_northing = _calculate_x_y_offset(domain_settings)
+        ax.set_extent([0, false_easting * 2, 0, false_northing * 2], crs=proj)
 
-        case _:
-            logger.error(f"Unsupported project type: {type(proj)}")
+    else:
+        logger.error(f"Unsupported project type: {type(proj)}")
 
 
 def generate_domain_area():
@@ -250,23 +226,32 @@ def generate_domain_area():
     Generate domain area for each model based on user's config.
     Images are saved to the output directory with name: "${model_name}_domain.png".
 
-    :return:
-    :rtype:
+    :return: True if domain area is ploted, else False.
+    :rtype: bool
     """
+    WRFRUNConfig = WRFRUN.config
     save_path = WRFRUNConfig.parse_resource_uri(WRFRUNConfig.WRFRUN_OUTPUT_PATH)
     check_path(save_path)
     save_path = abspath(save_path)
 
     fig = plt.figure(figsize=(10.24, 10.24))
 
+    flag = False
+
     model_configs = WRFRUNConfig["model"]
     for model_name in model_configs:
-        plot_domain_area(fig, model_name=model_name)
+        if model_name in ["wrf"] and model_configs[model_name]["use"]:
+            namelist = model_configs[model_name]
+            plot_domain_area(fig, parse_domain_setting(namelist))
+
+            _save_path = f"{save_path}/{model_name}_domain.png"
+            fig.savefig(_save_path)
+
+            logger.info(f"Save domain image for '{model_name}' to '{_save_path}'")
 
-        _save_path = f"{save_path}/{model_name}_domain.png"
-        fig.savefig(_save_path)
+            flag = True
 
-        logger.info(f"Save domain image for '{model_name}' to '{_save_path}'")
+    return flag
 
 
-__all__ = ["plot_domain_area", "DomainSetting", "create_projection", "parse_domain_setting", "generate_domain_area"]
+__all__ = ["plot_domain_area", "create_projection", "generate_domain_area"]

wrfrun/model/type.py

@@ -0,0 +1,116 @@
+"""
+wrfrun.model.type
+#################
+
+Definition of types used in ``wrfrun.model``.
+
+.. autosummary::
+    :toctree: generated/
+
+    DomainSetting
+"""
+
+from typing import Literal, TypedDict, Union
+
+
+class DomainSetting(TypedDict):
+    """
+    Domain settings which can be used to create a projection.
+
+    .. py:attribute:: resolution_x
+        :type: int
+
+        Spacing of the domain 1 grid points along the longitude direction, unit: meter.
+
+    .. py:attribute:: resolution_y
+        :type: int
+
+        Spacing of the domain 1 grid points along the latitude direction, unit: meter.
+
+    .. py:attribute:: points_x
+        :type: Union[list[int], tuple[int]]
+
+        Number of the grid points along the longitude direction of each domain.
+
+    .. py:attribute:: points_y
+        :type: Union[list[int], tuple[int]]
+
+        Number of the grid points along the latitude direction of each domain.
+
+    .. py:attribute:: x_parent_index
+        :type: Union[list[int], tuple[int]]
+
+        Corresponding x index in the parent grid of the first point.
+
+    .. py:attribute:: y_parent_index
+        :type: Union[list[int], tuple[int]]
+
+        Corresponding y index in the parent grid of the first point.
+
+    .. py:attribute:: domain_num
+        :type: int
+
+        Domain number.
+
+    .. py:attribute:: grid_spacing_ratio
+        :type: Union[list[int], tuple[int]]
+
+        Ratio of the grid resolution of each domain compared to the domain 1.
+
+    .. py:attribute:: projection_type
+        :type: Literal["lambert", "polar", "mercator", "lat-lon"]
+
+        Projection type.
+
+    .. py:attribute:: reference_lat
+        :type: Union[int, float]
+
+        Reference latitude.
+
+    .. py:attribute:: reference_lon
+        :type: Union[int, float]
+
+        Reference longitude.
+
+    .. py:attribute:: true_lat1
+        :type: Union[int, float]
+
+        True latitude (1:1 scale).
+
+    .. py:attribute:: true_lat2
+        :type: Union[int, float]
+
+        True latitude (1:1 scale).
+
+    .. py:attribute:: stand_lon
+        :type: Union[int, float]
+
+        Standard longitude.
+    """
+
+    # generally refers to the spacing of the parent grid points along the latitude, unit: meter
+    resolution_x: int
+    # spacing of the parent grid points along the longitude, unit: meter
+    resolution_y: int
+    # generally refers to the number of the grid points along the latitude.
+    points_x: Union[list[int], tuple[int]]
+    # number of the grid points along the longitude.
+    points_y: Union[list[int], tuple[int]]
+    # corresponding index in the parent grid of the first point.
+    x_parent_index: Union[list[int], tuple[int]]
+    y_parent_index: Union[list[int], tuple[int]]
+    # domain number
+    domain_num: int
+    # ratio of the grid point spacing.
+    grid_spacing_ratio: Union[list[int], tuple[int]]
+    # projection type
+    projection_type: Literal["lambert", "polar", "mercator", "lat-lon"]
+    # reference point, true longitude and latitude
+    reference_lat: Union[int, float]
+    reference_lon: Union[int, float]
+    true_lat1: Union[int, float]
+    true_lat2: Union[int, float]
+    stand_lon: Union[int, float]
+
+
+__all__ = ["DomainSetting"]

wrfrun/model/utils.py

@@ -10,12 +10,8 @@ Utility functions used by models.
     clear_model_logs
 """
 
-from os import listdir
-from shutil import move
-
-from ..core import WRFRUNConfig
-from ..utils import check_path, logger
-from ..workspace.wrf import WORKSPACE_MODEL_WRF
+from ..core import WRFRUN
+from .wrf.log import clear_wrf_logs
 
 
 def clear_model_logs():
@@ -23,21 +19,15 @@ def clear_model_logs():
     This function can automatically collect unsaved log files,
     and save them to the corresponding output directory of the ``Executable``.
     """
-    work_status = WRFRUNConfig.WRFRUN_WORK_STATUS
-    work_path = WRFRUNConfig.parse_resource_uri(WORKSPACE_MODEL_WRF)
-
-    log_files = [x for x in listdir(work_path) if x.startswith("rsl.") or x.endswith(".log")]
-
-    if len(log_files) > 0:
-        logger.warning(f"Found unprocessed log files of {work_status}")
-
-        log_save_path = f"{WRFRUNConfig.parse_resource_uri(WRFRUNConfig.WRFRUN_OUTPUT_PATH)}/{work_status}/logs"
-        check_path(log_save_path)
+    WRFRUNConfig = WRFRUN.config
 
-        for _file in log_files:
-            move(f"{work_path}/{_file}", f"{log_save_path}/{_file}")
+    func_map = {
+        "wrf": clear_wrf_logs
+    }
 
-        logger.warning(f"Unprocessed log files of {work_status} has been saved to {log_save_path}, check it")
+    for _model in func_map:
+        if _model in WRFRUNConfig["model"] and WRFRUNConfig["model"][_model]["use"]:
+            func_map[_model]()
 
 
 __all__ = ["clear_model_logs"]

wrfrun/model/wrf/__init__.py

@@ -8,34 +8,29 @@ Submodules
 **********
 
 ============================================ ==================================================================================
-:doc:`_metgrid </api/model.wrf._metgrid>`    Utility functions used by :class:`MetGrid <core.MetGrid>`.
-:doc:`_ndown </api/model.wrf._ndown>`        Utility functions used by :class:`NDown <core.NDown>`.
 :doc:`core </api/model.wrf.core>`            Core implementation of WRF model.
 :doc:`exec_wrap </api/model.wrf.exec_wrap>`  Function wrappers for ``Executable`` defined in :doc:`core </api/model.wrf.core>`.
 :doc:`geodata </api/model.wrf.geodata>`      Utility functions to read / write geographical static datas.
+:doc:`log </api/model.wrf.log>`              Functions to parse and clear WPS/WRF model logs.
 :doc:`namelist </api/model.wrf.namelist>`    Functions to process WPS / WRF namelist files.
 :doc:`plot </api/model.wrf.plot>`            Functions to create projection from namelist settings to plot simulation domain.
 :doc:`scheme </api/model.wrf.scheme>`        Scheme ``dataclass``.
+:doc:`utils </api/model.wrf.utils>`          Utility functions used by wrf model part.
 :doc:`vtable </api/model.wrf.vtable>`        Vtable files ``dataclass``.
 ============================================ ==================================================================================
 
-.. autosummary::
-    :toctree: generated/
-
-    prepare_namelist
-
 .. toctree::
     :maxdepth: 1
     :hidden:
 
-    _metgrid <model.wrf._metgrid>
-    _ndown <model.wrf._ndown>
     core <model.wrf.core>
     exec_wrap <model.wrf.exec_wrap>
     geodata <model.wrf.geodata>
+    log <model.wrf.log>
     namelist <model.wrf.namelist>
     plot <model.wrf.plot>
     scheme <model.wrf.scheme>
+    utils <model.wrf.utils>
     vtable <model.wrf.vtable>
 """