jcclass 0.0.1__py3-none-any.whl

jcclass/__init__.py

@@ -0,0 +1,4 @@
+from .compute import compute_cts, eleven_cts
+from .plotting import plot_cts
+
+__all__ = ["compute_cts", "eleven_cts", "plot_cts"]

jcclass/compute/__init__.py

@@ -0,0 +1,3 @@
+from .core import compute_cts, eleven_cts
+
+__all__ = ["compute_cts", "eleven_cts"]

jcclass/compute/core.py

@@ -0,0 +1,74 @@
+import xarray as xr
+from .functions.main import jc_classification
+
+
+def compute_cts(data_mslp: xr.DataArray) -> xr.DataArray:
+    """
+    Computes the Jenkinson and Collison Circulation Types (CTs) based on
+    Mean Sea Level Pressure (MSLP) data.
+
+    Args:
+        data_mslp (xr.DataArray): Input MSLP data as an xarray DataArray.
+            - Dimensions: Typically includes "time", "latitude", and "longitude".
+            - Units: Should be in Pascals (Pa) or Hectopascals (hPa).
+
+    Returns:
+        xr.DataArray: Computed circulation types as an xarray DataArray.
+            - Dimensions: Same as input, with "time", "latitude", and "longitude".
+            - Values: Integer codes representing circulation types.
+                - Codes range from 0 to 28, with -1 indicating unclassified flows.
+            - Attributes: Includes metadata describing the circulation type calculation.
+
+    Notes:
+        - The classification is derived using a gridded version of the Lamb Weather Types.
+        - Ensure the input dataset has global or regional coverage with appropriate
+          spatial and temporal resolution.
+
+    Example:
+        >>> import xarray as xr
+        >>> from jcclass.compute.core import compute_cts
+        >>> data_mslp = xr.open_dataset("mslp_data.nc").msl
+        >>> cts = compute_cts(data_mslp)
+        >>> print(cts)
+    """
+    ds = jc_classification(data_mslp)
+    return ds
+
+
+def eleven_cts(cts: xr.DataArray) -> xr.DataArray:
+    """
+    Reduces the 27 Lamb Weather Types (LWT) circulation types to 11 types
+    based on their advective characteristics.
+
+    Args:
+        cts (xr.DataArray): DataArray containing the 27 circulation types.
+
+    Returns:
+        xr.DataArray: DataArray with reduced 11 circulation types.
+
+    Example:
+        >>> import xarray as xr
+        >>> from jcclass.compute.core import eleven_cts
+        >>> cts = xr.open_dataset("cts_data.nc").lwt
+        >>> cts_11 = eleven_cts(cts)
+        >>> print(cts_11)
+    """
+    mapping = {
+        1: [11, 21, 1],   # NE
+        2: [12, 22, 2],   # E
+        3: [13, 23, 3],   # SE
+        4: [14, 24, 4],   # S
+        5: [15, 25, 5],   # SW
+        6: [16, 26, 6],   # W
+        7: [17, 27, 7],   # NW
+        8: [18, 28, 8],   # N
+        9: [20],          # Cyclonic
+    }
+
+    # Apply the mapping
+    for reduced_type, original_types in mapping.items():
+        cts = xr.where(cts.isin(original_types), reduced_type, cts)
+
+    return cts
+
+

jcclass/compute/functions/__init__.py

@@ -0,0 +1 @@
+

jcclass/compute/functions/computation.py

@@ -0,0 +1,192 @@
+import xarray as xr
+import numpy as np
+
+
+def flows(gridpoints, sc, zwa, zsc, zwb, latitude, longitude, time, mslp_data):
+    """
+    Computes indices associated with the direction and vorticity of geostrophic flow
+    given a reanalysis or GCM dataset.
+
+    Args:
+        gridpoints (tuple): A tuple containing the 16 gridded MSLP values (p1 to p16).
+        sc (xr.DataArray): Longitudinal scaling factor.
+        zwa (xr.DataArray): Zonal weighting factor (latitude - 5 degrees).
+        zwb (xr.DataArray): Zonal weighting factor (latitude + 5 degrees).
+        zsc (xr.DataArray): Shear constant.
+        latitude (xr.DataArray): Latitude values of the dataset.
+        longitude (xr.DataArray): Longitude values of the dataset.
+        time (xr.DataArray): Time values of the dataset.
+        mslp_data (xr.DataArray): Mean sea level pressure dataset.
+
+    Returns:
+        tuple: (W, S, F, ZW, ZS, Z)
+            W: Westerly flow
+            S: Southerly flow
+            F: Resultant flow
+            ZW: Westerly shear vorticity
+            ZS: Southerly shear vorticity
+            Z: Total shear vorticity
+    """
+    # Unpack gridpoints
+    (p1, p2, p3, p4, p5, p6, p7, p8,
+     p9, p10, p11, p12, p13, p14, p15, p16) = gridpoints
+
+    # Ensure sc, zwa, zsc, and zwb match the dimensions of MSLP
+    sc = sc.expand_dims(dim={"time": time}, axis=0)
+    zwa = zwa.expand_dims(dim={"time": time}, axis=0)
+    zsc = zsc.expand_dims(dim={"time": time}, axis=0)
+    zwb = zwb.expand_dims(dim={"time": time}, axis=0)
+
+    # Westerly Flow
+    W = (0.5 * (p12 + p13)) - (0.5 * (p4 + p5))
+    if mslp_data.dims[1] == "latitude":
+        W = xr.DataArray(W, coords={"time": time, "latitude": latitude, "longitude": longitude}, dims=["time", "latitude", "longitude"])
+    elif mslp_data.dims[1] == "number":
+        W = xr.DataArray(W, coords={"time": time, "number": mslp_data.number, "latitude": latitude, "longitude": longitude}, dims=["time", "number", "latitude", "longitude"])
+
+    # Southerly Flow
+    S = sc * ((0.25 * (p5 + 2 * p9 + p13)) - (0.25 * (p4 + 2 * p8 + p12)))
+    if mslp_data.dims[1] == "latitude":
+        S = xr.DataArray(S, coords={"time": time, "latitude": latitude, "longitude": longitude}, dims=["time", "latitude", "longitude"])
+    elif mslp_data.dims[1] == "number":
+        S = xr.DataArray(S, coords={"time": time, "number": mslp_data.number, "latitude": latitude, "longitude": longitude}, dims=["time", "number", "latitude", "longitude"])
+
+    # Resultant Flow
+    F = np.sqrt(S**2 + W**2)
+
+    # Westerly Shear Vorticity
+    ZW = (zwa * (0.5 * (p15 + p16) - 0.5 * (p8 + p9))) - (zwb * (0.5 * (p8 + p9) - 0.5 * (p1 + p2)))
+    if mslp_data.dims[1] == "latitude":
+        ZW = xr.DataArray(ZW, coords={"time": time, "latitude": latitude, "longitude": longitude}, dims=["time", "latitude", "longitude"])
+    elif mslp_data.dims[1] == "number":
+        ZW = xr.DataArray(ZW, coords={"time": time, "number": mslp_data.number, "latitude": latitude, "longitude": longitude}, dims=["time", "number", "latitude", "longitude"])
+
+    # Southerly Shear Vorticity
+    ZS = zsc * ((0.25 * (p6 + 2 * p10 + p14)) - (0.25 * (p5 + 2 * p9 + p13)) - (0.25 * (p4 + 2 * p8 + p12)) + (0.25 * (p3 + 2 * p7 + p11)))
+    if mslp_data.dims[1] == "latitude":
+        ZS = xr.DataArray(ZS, coords={"time": time, "latitude": latitude, "longitude": longitude}, dims=["time", "latitude", "longitude"])
+    elif mslp_data.dims[1] == "number":
+        ZS = xr.DataArray(ZS, coords={"time": time, "number": mslp_data.number, "latitude": latitude, "longitude": longitude}, dims=["time", "number", "latitude", "longitude"])
+
+    # Total Shear Vorticity
+    Z = ZW + ZS
+
+    return W, S, F, ZW, ZS, Z
+
+
+def compute_direction(deg, latitude):
+    """
+    Assigns wind direction labels based on wind direction degrees and hemisphere.
+
+    Args:
+        deg (xr.DataArray): Wind direction values in degrees.
+        latitude (xr.DataArray): Latitude values to determine the hemisphere.
+
+    Returns:
+        xr.DataArray: Wind direction labels as strings.
+    """
+    # Define the direction labels for both hemispheres
+    nh_labels = {
+        "W": (247, 292),
+        "NW": (292, 337),
+        "N": (337, 22),
+        "NE": (22, 67),
+        "E": (67, 112),
+        "SE": (112, 157),
+        "S": (157, 202),
+        "SW": (202, 247),
+    }
+
+    sh_labels = {
+        "E": (247, 292),
+        "SE": (292, 337),
+        "S": (337, 22),
+        "SW": (22, 67),
+        "W": (67, 112),
+        "NW": (112, 157),
+        "N": (157, 202),
+        "NE": (202, 247),
+    }
+
+    # Initialize direction as NaN
+    direction = xr.full_like(deg, fill_value=np.nan, dtype=object)
+
+    # Determine Northern Hemisphere directions
+    for label, (lower, upper) in nh_labels.items():
+        if lower <= upper:
+            direction = xr.where((latitude >= 0) & (deg > lower) & (deg <= upper), label, direction)
+        else:  # Handle wrap-around (e.g., N: 337-22)
+            direction = xr.where((latitude >= 0) & ((deg > lower) | (deg <= upper)), label, direction)
+
+    # Determine Southern Hemisphere directions
+    for label, (lower, upper) in sh_labels.items():
+        if lower <= upper:
+            direction = xr.where((latitude < 0) & (deg > lower) & (deg <= upper), label, direction)
+        else:  # Handle wrap-around (e.g., S: 337-22)
+            direction = xr.where((latitude < 0) & ((deg > lower) | (deg <= upper)), label, direction)
+
+    return direction
+
+
+def assign_lwt(F_i, Z_i, direction_i):
+    """
+    Assigns circulation type codes (Lamb Weather Types) based on flow and vorticity.
+
+    Args:
+        F_i (xr.DataArray): Total flow term (F).
+        Z_i (xr.DataArray): Total shear vorticity term (Z).
+        direction_i (xr.DataArray): Flow direction.
+
+    Returns:
+        xr.DataArray: Circulation type classification for each grid point.
+            - Codes range from 0 (purely anticyclonic) to 28 (directional flows).
+            - -1 indicates weak/unclassified flow.
+
+    Example:
+        >>> lwt = assign_lwt(F, Z, direction)
+        >>> print(lwt)
+    """
+    if not isinstance(F_i, xr.DataArray) or not isinstance(Z_i, xr.DataArray) or not isinstance(direction_i, xr.DataArray):
+        raise TypeError("F_i, Z_i, and direction_i must all be xarray.DataArray objects.")
+
+    # Hybrid Anticyclonic flows
+    lwt = xr.where((Z_i < 0) & (direction_i == 'NE'), 1, np.nan)
+    lwt = xr.where((Z_i < 0) & (direction_i == 'E'), 2, lwt)
+    lwt = xr.where((Z_i < 0) & (direction_i == 'SE'), 3, lwt)
+    lwt = xr.where((Z_i < 0) & (direction_i == 'S'), 4, lwt)
+    lwt = xr.where((Z_i < 0) & (direction_i == 'SW'), 5, lwt)
+    lwt = xr.where((Z_i < 0) & (direction_i == 'W'), 6, lwt)
+    lwt = xr.where((Z_i < 0) & (direction_i == 'NW'), 7, lwt)
+    lwt = xr.where((Z_i < 0) & (direction_i == 'N'), 8, lwt)
+
+    # Hybrid Cyclonic flows
+    lwt = xr.where((np.abs(Z_i) < F_i) & (direction_i == 'NE'), 11, lwt)
+    lwt = xr.where((np.abs(Z_i) < F_i) & (direction_i == 'E'), 12, lwt)
+    lwt = xr.where((np.abs(Z_i) < F_i) & (direction_i == 'SE'), 13, lwt)
+    lwt = xr.where((np.abs(Z_i) < F_i) & (direction_i == 'S'), 14, lwt)
+    lwt = xr.where((np.abs(Z_i) < F_i) & (direction_i == 'SW'), 15, lwt)
+    lwt = xr.where((np.abs(Z_i) < F_i) & (direction_i == 'W'), 16, lwt)
+    lwt = xr.where((np.abs(Z_i) < F_i) & (direction_i == 'NW'), 17, lwt)
+    lwt = xr.where((np.abs(Z_i) < F_i) & (direction_i == 'N'), 18, lwt)
+
+    # Purely Cyclonic
+    lwt = xr.where((np.abs(Z_i) > (2 * F_i)) & (Z_i > 0), 20, lwt)
+
+    # Purely Anticyclonic
+    lwt = xr.where((np.abs(Z_i) > (2 * F_i)) & (Z_i < 0), 0, lwt)
+
+    # Directional flows
+    lwt = xr.where((np.abs(Z_i) > F_i) & (np.abs(Z_i) < (2 * F_i)) & (Z_i > 0) & (direction_i == 'NE'), 21, lwt)
+    lwt = xr.where((np.abs(Z_i) > F_i) & (np.abs(Z_i) < (2 * F_i)) & (Z_i > 0) & (direction_i == 'E'), 22, lwt)
+    lwt = xr.where((np.abs(Z_i) > F_i) & (np.abs(Z_i) < (2 * F_i)) & (Z_i > 0) & (direction_i == 'SE'), 23, lwt)
+    lwt = xr.where((np.abs(Z_i) > F_i) & (np.abs(Z_i) < (2 * F_i)) & (Z_i > 0) & (direction_i == 'S'), 24, lwt)
+    lwt = xr.where((np.abs(Z_i) > F_i) & (np.abs(Z_i) < (2 * F_i)) & (Z_i > 0) & (direction_i == 'SW'), 25, lwt)
+    lwt = xr.where((np.abs(Z_i) > F_i) & (np.abs(Z_i) < (2 * F_i)) & (Z_i > 0) & (direction_i == 'W'), 26, lwt)
+    lwt = xr.where((np.abs(Z_i) > F_i) & (np.abs(Z_i) < (2 * F_i)) & (Z_i > 0) & (direction_i == 'NW'), 27, lwt)
+    lwt = xr.where((np.abs(Z_i) > F_i) & (np.abs(Z_i) < (2 * F_i)) & (Z_i > 0) & (direction_i == 'N'), 28, lwt)
+
+    # Low Flow / Unclassified / Weak Flow
+    lwt = xr.where((F_i < 6) & (np.abs(Z_i) < 6), -1, lwt)
+
+    return lwt
+

jcclass/compute/functions/constants.py

@@ -0,0 +1,64 @@
+import numpy as np
+import xarray as xr
+
+
+def compute_constants(phi: xr.DataArray, lon: xr.DataArray) -> tuple:
+    """
+    Computes constants dependent on latitude and longitude for grid-point spacing.
+    These constants represent relative differences in the E-W and N-S grid-point spacing.
+
+    Args:
+        phi (xr.DataArray): Central latitude grid points (1D array).
+        lon (xr.DataArray): Longitude values (1D array).
+
+    Returns:
+        tuple:
+            sc (xr.DataArray): Longitudinal scaling factor.
+            zwa (xr.DataArray): Zonal weighting factor (latitude - 5 degrees).
+            zwb (xr.DataArray): Zonal weighting factor (latitude + 5 degrees).
+            zsc (xr.DataArray): Shear constant.
+    """
+    if not isinstance(phi, xr.DataArray) or not isinstance(lon, xr.DataArray):
+        raise TypeError("Both phi (latitude) and lon (longitude) must be xarray.DataArray objects.")
+
+    # Validate dimensions
+    if "latitude" not in phi.dims or len(phi.dims) != 1:
+        raise ValueError("phi must be a 1D xarray.DataArray with 'latitude' as its dimension.")
+    if "longitude" not in lon.dims or len(lon.dims) != 1:
+        raise ValueError("lon must be a 1D xarray.DataArray with 'longitude' as its dimension.")
+
+    # Longitudinal scaling factor
+    sc = 1 / np.cos(np.deg2rad(phi))
+    sc = xr.DataArray(
+        np.repeat(sc.values[:, None], len(lon), axis=1),
+        coords={"latitude": phi, "longitude": lon},
+        dims=["latitude", "longitude"],
+        name="sc"
+    )
+
+    # Zonal weighting factors
+    zwa = np.sin(np.deg2rad(phi)) / np.sin(np.deg2rad(phi - 5))
+    zwb = np.sin(np.deg2rad(phi)) / np.sin(np.deg2rad(phi + 5))
+    zwa = xr.DataArray(
+        np.repeat(zwa.values[:, None], len(lon), axis=1),
+        coords={"latitude": phi, "longitude": lon},
+        dims=["latitude", "longitude"],
+        name="zwa"
+    )
+    zwb = xr.DataArray(
+        np.repeat(zwb.values[:, None], len(lon), axis=1),
+        coords={"latitude": phi, "longitude": lon},
+        dims=["latitude", "longitude"],
+        name="zwb"
+    )
+
+    # Shear constant
+    zsc = 1 / (2 * (np.cos(np.deg2rad(phi)) ** 2))
+    zsc = xr.DataArray(
+        np.repeat(zsc.values[:, None], len(lon), axis=1),
+        coords={"latitude": phi, "longitude": lon},
+        dims=["latitude", "longitude"],
+        name="zsc"
+    )
+
+    return sc, zwa, zwb, zsc

jcclass/compute/functions/data_extraction.py

@@ -0,0 +1,145 @@
+import xarray as xr
+import numpy as np
+
+
+def extract_lat_lon_points(mslp_data: xr.DataArray) -> tuple:
+    """
+    Extracts latitude and longitude points from the MSLP data within the
+    latitude range [-80, 80] degrees.
+    Args:
+        mslp_data (xr.DataArray): Input MSLP data with standardized coordinates
+    Returns:
+        tuple: Latitude and Longitude points within the range [-80, 80] degrees
+
+    """
+    min_lat, max_lat = (-80.0, 80.0)
+    psl_area = mslp_data.where((mslp_data.latitude >= min_lat) & (mslp_data.latitude <= max_lat), drop=True)
+
+    lat = psl_area.latitude
+    lon = psl_area.longitude
+
+    return lat, lon
+
+
+def extracting_gridpoints_area(mslp, latitude, longitude):
+    """
+    Extracts 16 gridded points over a defined area for a Reanalysis or Global Climate Model dataset.
+    These grid points are required for computing terms related to circulation classification.
+
+    The function computes grid points based on predefined latitude and longitude offsets from a central
+    point, ensuring that the dataset is not assumed to cover the entire globe.
+
+    Args:
+        mslp (xr.DataArray): Mean sea level pressure data with latitude and longitude coordinates.
+        latitude (xr.DataArray): Latitude values of the dataset.
+        longitude (xr.DataArray): Longitude values of the dataset.
+
+    Returns:
+        tuple: A tuple of 16 `numpy.ndarray` objects, each corresponding to a grid point value of `mslp`
+               at the calculated latitude and longitude offsets.
+
+    Latitude and Longitude Offsets:
+        Grid Point 1:  (+10, -5)
+        Grid Point 2:  (+10, +5)
+        Grid Point 3:  (+5, -15)
+        Grid Point 4:  (+5, -5)
+        Grid Point 5:  (+5, +5)
+        Grid Point 6:  (+5, +15)
+        Grid Point 7:  (+0, -15)
+        Grid Point 8:  (+0, -5)
+        Grid Point 9:  (+0, +5)
+        Grid Point 10: (+0, +15)
+        Grid Point 11: (-5, -15)
+        Grid Point 12: (-5, -5)
+        Grid Point 13: (-5, +5)
+        Grid Point 14: (-5, +15)
+        Grid Point 15: (-10, -5)
+        Grid Point 16: (-10, +5)
+
+    Example:
+        >>> latitude = xr.DataArray(np.linspace(-90, 90, 181), dims="latitude", name="latitude")
+        >>> longitude = xr.DataArray(np.linspace(-180, 180, 361), dims="longitude", name="longitude")
+        >>> mslp = xr.DataArray(np.random.rand(181, 361), coords={"latitude": latitude, "longitude": longitude}, dims=["latitude", "longitude"])
+        >>> gridpoints = extracting_gridpoints_area(mslp, latitude, longitude)
+        >>> print(gridpoints[0])  # First grid point value
+    """
+    offsets = [
+        (10, -5), (10, 5), (5, -15), (5, -5), (5, 5), (5, 15), (0, -15), (0, -5),
+        (0, 5), (0, 15), (-5, -15), (-5, -5), (-5, 5), (-5, 15), (-10, -5), (-10, 5)
+    ]
+    gridpoints = []
+
+    for lat_offset, lon_offset in offsets:
+        lat_point = latitude + lat_offset
+        lon_point = longitude + lon_offset
+
+        lat_point = latitude.sel(latitude=lat_point, method="nearest")
+        lon_point = longitude.sel(longitude=lon_point, method="nearest")
+
+        gridpoints.append(np.array(mslp.sel(latitude=lat_point, longitude=lon_point)))
+
+    return tuple(gridpoints)
+
+
+def extracting_gridpoints_globe(mslp, latitude, longitude):
+    """
+    Extracts 16 gridded points over the entire globe for a Reanalysis or Global Climate Model dataset.
+    These grid points are required for computing terms related to circulation classification.
+
+    The function dynamically adjusts longitude values to account for the globe's circular nature
+    (longitude wrapping), ensuring that grid points are correctly identified near the 180°E/-180°W boundary.
+
+    Args:
+        mslp (xr.DataArray): Mean sea level pressure data with latitude and longitude coordinates.
+        latitude (xr.DataArray): Latitude values of the dataset.
+        longitude (xr.DataArray): Longitude values of the dataset.
+
+    Returns:
+        tuple: A tuple of 16 `numpy.ndarray` objects, each corresponding to a grid point value of `mslp`
+               at the calculated latitude and longitude offsets.
+
+    Latitude and Longitude Offsets:
+        Grid Point 1:  (+10, -5)
+        Grid Point 2:  (+10, +5)
+        Grid Point 3:  (+5, -15)
+        Grid Point 4:  (+5, -5)
+        Grid Point 5:  (+5, +5)
+        Grid Point 6:  (+5, +15)
+        Grid Point 7:  (+0, -15)
+        Grid Point 8:  (+0, -5)
+        Grid Point 9:  (+0, +5)
+        Grid Point 10: (+0, +15)
+        Grid Point 11: (-5, -15)
+        Grid Point 12: (-5, -5)
+        Grid Point 13: (-5, +5)
+        Grid Point 14: (-5, +15)
+        Grid Point 15: (-10, -5)
+        Grid Point 16: (-10, +5)
+
+    Example:
+        >>> latitude = xr.DataArray(np.linspace(-90, 90, 181), dims="latitude", name="latitude")
+        >>> longitude = xr.DataArray(np.linspace(-180, 180, 361), dims="longitude", name="longitude")
+        >>> mslp = xr.DataArray(np.random.rand(181, 361), coords={"latitude": latitude, "longitude": longitude}, dims=["latitude", "longitude"])
+        >>> gridpoints = extracting_gridpoints_globe(mslp, latitude, longitude)
+        >>> print(gridpoints[0])  # First grid point value
+    """
+    offsets = [
+        (10, -5), (10, 5), (5, -15), (5, -5), (5, 5), (5, 15), (0, -15), (0, -5),
+        (0, 5), (0, 15), (-5, -15), (-5, -5), (-5, 5), (-5, 15), (-10, -5), (-10, 5)
+    ]
+    gridpoints = []
+
+    for lat_offset, lon_offset in offsets:
+        lat_point = latitude + lat_offset
+        lon_point = xr.where(
+            longitude < -175, 360 + longitude + lon_offset,
+            xr.where(longitude > 175, longitude + lon_offset - 360, longitude + lon_offset)
+        )
+        lon_point = xr.where(lon_point == 180, -180, lon_point)
+
+        lat_point = latitude.sel(latitude=lat_point, method="nearest")
+        lon_point = longitude.sel(longitude=lon_point, method="nearest")
+
+        gridpoints.append(np.array(mslp.sel(latitude=lat_point, longitude=lon_point)))
+
+    return tuple(gridpoints)

jcclass/compute/functions/data_preparation.py

@@ -0,0 +1,114 @@
+import xarray as xr
+import numpy as np
+
+
+def read_mslp_file(mslp_data: xr.DataArray) -> xr.DataArray:
+    """
+    Validates that the input is an xarray.DataArray containing Mean Sea Level Pressure (MSLP) data,
+    and ensures the coordinates are named 'time', 'latitude', and 'longitude'.
+    Args:
+        mslp_data (xr.DataArray): Input MSLP data as an xarray.DataArray
+    Returns:
+        xr.DataArray: Validated and standardized MSLP data with proper coordinate names
+    Raises:
+        TypeError: If the input is not an xarray.DataArray
+        ValueError: If the DataArray does not have valid dimensions
+    """
+    if not isinstance(mslp_data, xr.DataArray):
+        raise TypeError("The input must be an xarray.DataArray containing MSLP data.")
+
+    # Coordinate mapping to enforce naming conventions
+    coord_mapping = {
+        "time": "time",           # Ensure time is named 'time'
+        "valid_time": "time",     # Rename valid_time -> time
+        "lat": "latitude",        # Rename lat -> latitude
+        "latitude": "latitude",   # Ensure latitude stays as latitude
+        "lon": "longitude",       # Rename lon -> longitude
+        "longitude": "longitude", # Ensure longitude stays as longitude
+    }
+
+    # Rename coordinates to enforce naming conventions
+    for old_coord, new_coord in coord_mapping.items():
+        if old_coord in mslp_data.coords and new_coord != old_coord:
+            mslp_data = mslp_data.rename({old_coord: new_coord})
+
+    # Ensure required dimensions
+    required_dims = {"time", "latitude", "longitude"}
+    if not required_dims.issubset(set(coord_mapping.get(dim, dim) for dim in mslp_data.dims)):
+        raise ValueError(
+            f"The DataArray must have dimensions: {', '.join(required_dims)}. "
+            f"Found: {', '.join(mslp_data.dims)}."
+        )
+
+    return mslp_data
+
+
+def checking_lat_coords(mslp_data: xr.DataArray) -> xr.DataArray:
+    """
+    Ensures the latitude coordinate values are in ascending order (e.g., -90 to 90º).
+
+    Args:
+        mslp_data (xr.DataArray): Input MSLP data with standardized coordinates
+    Returns:
+        xr.DataArray: MSLP data with latitude coordinate in ascending order
+    """
+    if mslp_data.latitude[0] > mslp_data.latitude[-1]:
+        mslp_data = mslp_data.reindex(latitude=list(reversed(mslp_data.latitude)))
+    else:
+        pass
+
+    return mslp_data
+
+
+def checking_lon_coords(mslp_data: xr.DataArray) -> xr.DataArray:
+    """
+    Ensures the longitude coordinate values are within the range [-180, 180].
+
+    Args:
+        mslp_data (xr.DataArray): Input MSLP data with standardized coordinates
+    Returns:
+        xr.DataArray: MSLP data with longitude coordinate adjusted to [-180, 180]
+    """
+    if mslp_data.longitude[-1] > 180:
+        # Adjust longitude values
+        mslp_data['_longitude_adjusted'] = xr.where(
+            mslp_data.longitude > 180,
+            mslp_data.longitude - 360,
+            mslp_data.longitude
+        )
+        # Swap dimensions and sort
+        mslp_data = (
+            mslp_data
+            .swap_dims({"longitude": "_longitude_adjusted"})
+            .sel(_longitude_adjusted=sorted(mslp_data._longitude_adjusted))
+            .drop_vars("longitude")
+            .rename({"_longitude_adjusted": "longitude"})
+        )
+    else:
+        pass
+
+    return mslp_data
+
+
+def is_world(mslp_data: xr.DataArray) -> bool:
+    """
+    Checks if the dataset covers the entire globe based on longitude and latitude coverage.
+
+    Args:
+        mslp_data (xr.DataArray or xr.Dataset): Input data with 'longitude' and 'latitude' coordinates.
+    Returns:
+        bool: True if the dataset covers the entire globe, False otherwise.
+    """
+    # Calculate the difference between the first two longitude and latitude values
+    dif_lon = np.abs(mslp_data.longitude[0] - mslp_data.longitude[1])
+    dif_lat = np.abs(mslp_data.latitude[0] - mslp_data.latitude[1])
+
+    # Define conditions for global coverage
+    condition_east = mslp_data.longitude[-1] >= (180 - dif_lon)  # Covers up to 180°E
+    condition_west = mslp_data.longitude[0] <= (-180 + dif_lon)  # Covers up to 180°W
+
+    is_global = condition_west and condition_east
+
+    return bool(is_global)
+
+

jcclass/compute/functions/format_data.py

@@ -0,0 +1,49 @@
+import xarray as xr
+
+
+def enhance_and_validate_dataarray(lwt: xr.DataArray) -> xr.DataArray:
+    """
+    Enhances metadata and validates coordinates for an atmospheric dataset.
+
+    Args:
+        lwt (xr.DataArray): The circulation type DataArray.
+
+    Returns:
+        xr.DataArray: Enhanced DataArray with added metadata.
+    """
+    # Set a variable name
+    lwt.name = "cts"  # Circulation types (CTS)
+
+    # Add metadata
+    lwt.attrs["description"] = "Jenkinson and Collison / Lamb Weather Types (LWT) Classification"
+    lwt.attrs["units"] = "categorical"
+    lwt.attrs["long_name"] = "Lamb Weather Types"
+
+    # Add metadata to coordinates
+    if "latitude" in lwt.coords:
+        lwt["latitude"].attrs["units"] = "degrees_north"
+        lwt["latitude"].attrs["long_name"] = "Latitude"
+    if "longitude" in lwt.coords:
+        lwt["longitude"].attrs["units"] = "degrees_east"
+        lwt["longitude"].attrs["long_name"] = "Longitude"
+    if "time" in lwt.coords:
+        lwt["time"].attrs["long_name"] = "Time"
+        lwt["time"].attrs["calendar"] = "gregorian"
+
+    # Validate latitude range and order
+    if "latitude" in lwt.coords:
+        latitude = lwt["latitude"]
+        if not (-90 <= latitude.min() <= 90) or not (-90 <= latitude.max() <= 90):
+            raise ValueError("Latitude values must range between -90 and 90 degrees.")
+        if not (latitude.values[1:] >= latitude.values[:-1]).all():
+            raise ValueError("Latitude values must increase monotonically.")
+
+    # Validate longitude range and order
+    if "longitude" in lwt.coords:
+        longitude = lwt["longitude"]
+        if not (-180 <= longitude.min() <= 180) or not (-180 <= longitude.max() <= 180):
+            raise ValueError("Longitude values must range between -180 and 180 degrees.")
+        if not (longitude.values[1:] >= longitude.values[:-1]).all():
+            raise ValueError("Longitude values must increase monotonically.")
+
+    return lwt

jcclass/compute/functions/main.py

@@ -0,0 +1,53 @@
+import gc
+import numpy as np
+import xarray as xr
+from .data_preparation import read_mslp_file, checking_lon_coords, \
+    checking_lat_coords, is_world
+from .data_extraction import extract_lat_lon_points, extracting_gridpoints_area, extracting_gridpoints_globe
+from .constants import compute_constants
+from .computation import flows, compute_direction, assign_lwt
+from .format_data import enhance_and_validate_dataarray
+
+from jcclass.utils.logging_config import setup_logger
+
+logger = setup_logger("jcclass")
+
+def jc_classification(mslp_data: xr.DataArray) -> xr.DataArray:
+    logger.info("Starting the computation of the Jenkinson and Collison Circulation Types.")
+    # Step 1: Data preparation
+    logger.info("Preparing the MSLP data for computation.")
+    mslp_data = read_mslp_file(mslp_data)
+    mslp_data = checking_lat_coords(mslp_data)
+    mslp_data = checking_lon_coords(mslp_data)
+    time_data = mslp_data.time
+    is_global = is_world(mslp_data)
+
+    logger.info("Extracting grid points.")
+    # Step 2: Compute constants
+    latitude, longitude = extract_lat_lon_points(mslp_data)
+    sc, zwa, zwb, zsc = compute_constants(latitude, longitude)
+
+    if is_global:
+        gridpoints = extracting_gridpoints_globe(mslp_data, latitude, longitude)
+    else:
+        gridpoints = extracting_gridpoints_area(mslp_data, latitude, longitude)
+
+    logger.info("Computing equations of flows and vorticity.")
+    # Step 3: Compute equations of flows and vorticity
+    W, S, F, ZW, ZS, Z = flows(gridpoints, sc, zwa, zsc, zwb, latitude, longitude, time_data, mslp_data)
+    deg = np.mod(180 + np.rad2deg(np.arctan2(W, S)), 360)
+
+    logger.info("Computing flow directions.")
+    # Step 4: Compute flow directions
+    direction = compute_direction(deg, latitude)
+
+    logger.info("Assigning Lamb Weather Types.")
+    # Step 5: Assign Lamb Weather Types
+    lwt = assign_lwt(F, Z, direction)
+
+    logger.info("Validating and creating DataArray.")
+    # Step 6: Enhance and validate DataArray
+    lwt = enhance_and_validate_dataarray(lwt)
+    logger.info("Success!")
+
+    return lwt

jcclass/plotting/__init__.py

@@ -0,0 +1,3 @@
+from .core import plot_cts
+
+__all__ = ["plot_cts"]

jcclass/plotting/core.py

@@ -0,0 +1,108 @@
+import xarray as xr
+import numpy as np
+import matplotlib.pyplot as plt
+import cartopy.crs as ccrs
+
+from .functions.tools import ensure_2d, crop_area
+from .functions.plot_utils import get_cmap_and_norm, add_legend, get_fig_size, \
+    configure_gridlines, format_time_string
+from jcclass.compute.core import eleven_cts
+from jcclass.utils.logging_config import setup_logger
+logger = setup_logger("jcclass")
+
+
+def plot_cts(ds: xr.DataArray,
+             lat_south: int = -80,
+             lat_north: int = 80,
+             lon_west: int = -180,
+             lon_east: int = 180,
+             show: bool = True):
+    """
+    Plot the 27 circulation types on a map for a single time step.
+
+    This function visualizes one time slice of circulation types (typically 27 classes)
+    using a predefined colormap, with optional geographic cropping. It also masks out
+    the equatorial region and converts values to the 11 reduced CT categories.
+
+    Parameters
+    ----------
+    ds : xr.DataArray
+        A 2D `xarray.DataArray` with latitude and longitude dimensions.
+        Must represent a single time step of 27 circulation types.
+
+    lat_south : int, optional
+        Southern latitude boundary of the map (default: -80).
+
+    lat_north : int, optional
+        Northern latitude boundary of the map (default: 80).
+
+    lon_west : int, optional
+        Western longitude boundary of the map (default: -180).
+
+    lon_east : int, optional
+        Eastern longitude boundary of the map (default: 180).
+
+    show : bool, optional
+        Whether to display the plot immediately using `plt.show()`.
+        If False, the figure is returned silently (default: True).
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure
+        The generated figure containing the circulation type map.
+
+    Notes
+    -----
+    - The equatorial band between -10 and 10 degrees latitude is masked out.
+    - A legend showing the 11 reduced CTs is included.
+    - The title includes the date (and hour, if available) from the time coordinate.
+
+    Examples
+    --------
+    >>> from jcclass.plotting import plot_cts
+    >>> cts_day = cts_27.sel(time="1979-01-01")
+    >>> fig = plot_cts(cts_day, lat_south=-60, lat_north=60, lon_west=-100, lon_east=20)
+    >>> fig.savefig("my_cts_map.png")
+    """
+    logger.info("Plotting the circulation types to a map.")
+    # Checking the xr.DataArray is 2D
+    ensure_2d(ds)
+    # Cropping the area
+    ds = crop_area(ds, lat_north, lat_south, lon_west, lon_east)
+    # Redefining longitude and latitude limit points
+    lat_north = ds.latitude.max()
+    lat_south = ds.latitude.min()
+    lon_west = ds.longitude.min()
+    lon_east = ds.longitude.max()
+
+    # Mask the data to remove the equatorial region
+    ds = xr.where((ds.latitude < 10) & (ds.latitude > -10), np.nan, ds)
+    # Convert to 11 CTs
+    ds = eleven_cts(ds)
+
+    # Get the colormap and normalization
+    cmap, norm = get_cmap_and_norm()
+    # Compute the size of the figure
+    size_x, size_y = get_fig_size(ds)
+    # Get the x and y coordinate values
+    lons, lats = ds.longitude, ds.latitude
+
+    # Plotting
+    proj = ccrs.PlateCarree()
+    fig, ax = plt.subplots(figsize=(size_x, size_y), subplot_kw={'projection': proj})
+    ax.set_extent([lon_west, lon_east, lat_south, lat_north], crs=proj)
+
+    ax.pcolor(lons, lats, ds, transform=proj, norm=norm, cmap=cmap)
+
+    ax.coastlines('50m')
+    configure_gridlines(ax)
+    add_legend(fig, ax)
+
+    # Add date title if available
+    time_string = format_time_string(ds)
+    ax.set_title(time_string, size=12, loc='left')
+
+    plt.tight_layout()
+    if show:
+        plt.show()
+    return fig

jcclass/plotting/functions/plot_utils.py

@@ -0,0 +1,161 @@
+import numpy as np
+import pandas as pd
+import xarray as xr
+import matplotlib.pyplot as plt
+import cartopy.crs as ccrs
+from matplotlib.colors import ListedColormap, BoundaryNorm
+from matplotlib.lines import Line2D
+from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER
+import matplotlib.ticker as mticker
+
+
+def get_cmap_and_norm():
+    """
+    Returns the colormap and normalization used to plot 11 circulation types.
+
+    Returns:
+        cmap (ListedColormap): Colormap for circulation types.
+        norm (BoundaryNorm): Boundary norm to map values to colors.
+    """
+    cmap = ListedColormap([
+        "#7C7C77", "#17344F", "#0255F4", "#0F78ED", "#9E09EE", "#F6664C",
+        "#F24E64", "#D3C42D", "#2FC698", "#20E1D7", "#BD0000"
+    ])
+    norm = BoundaryNorm(boundaries=np.arange(-1, 11, 1), ncolors=12)
+
+    return cmap, norm
+
+
+def get_fig_size(ds: xr.DataArray) -> tuple:
+    """
+    Calculate the size of the figure based on the area of interest.
+    parameters:
+        ds (xarray.DataArray): DataArray containing latitude and longitude coordinates.
+    returns:
+        tuple: Size of the figure in inches (width, height).
+    """
+    lat_north = ds.latitude.max()
+    lat_south = ds.latitude.min()
+    lon_west = ds.longitude.min()
+    lon_east = ds.longitude.max()
+    # Calculate the size of the figure based on the area of interest
+    dif_x = lon_east - lon_west
+    dif_y = lat_north - lat_south
+    size_x, size_y = 12, 10
+    if dif_x > dif_y:
+        size_y = size_x * (dif_y / dif_x)
+    elif dif_x < dif_y:
+        size_x = size_y * (dif_x / dif_y)
+    return size_x, size_y
+
+
+def configure_gridlines(ax: plt.Axes) -> None:
+    """
+    Adds formatted geographic gridlines to a Cartopy axis.
+
+    Parameters
+    ----------
+    ax : matplotlib.axes._subplots.AxesSubplot
+        The axis (with Cartopy projection) to which the gridlines will be added.
+
+    Notes
+    -----
+    - Latitude labels are shown on the left.
+    - Longitude labels are shown at the bottom.
+    - Gridlines themselves are hidden (no xlines or ylines), only labels are displayed.
+    - Gridline locators and formatters are fixed to common global coordinates.
+    """
+    gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True)
+    gl.top_labels = False
+    gl.bottom_labels = True
+    gl.left_labels = True
+    gl.right_labels = False
+    gl.xlines = False  # disables grid lines
+    gl.ylines = False
+    gl.ylocator = mticker.FixedLocator([-80, -60, -40, -20, 0, 20, 40, 60, 80])
+    gl.xlocator = mticker.FixedLocator([-180, -120, -60, 0, 60, 120, 180])
+    gl.xformatter = LONGITUDE_FORMATTER
+    gl.yformatter = LATITUDE_FORMATTER
+
+
+def add_legend(fig: plt.Figure, ax: plt.Axes) -> None:
+    """
+    Adds a custom legend for 11 circulation types to the plot.
+
+    Parameters
+    ----------
+    fig : matplotlib.figure.Figure
+        The figure object where the legend will be attached.
+
+    ax : matplotlib.axes.Axes
+        The axis object to which the legend belongs.
+
+    Notes
+    -----
+    - The legend includes 11 circulation types labeled:
+      ['LF', 'A', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW', 'N', 'C']
+    - Colors correspond to the colormap used in the circulation plot.
+    - The legend is placed outside the plot at the center right.
+    """
+    legend_labels = ['LF', 'A', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW', 'N', 'C']
+    legend_colors = [
+        "#7c7c77", "#1c2c4b", "#123FDD", "#245cdc", "#802fcd", "#d98b4f",
+        "#D17860", "#d0c742", "#4d9f9e", "#46afd8", "#973000"
+    ]
+    legend_styles = ['None'] * 11  # Only markers, no lines
+
+    legend_elements = [
+        Line2D([0], [0], marker='o', color=color, linestyle=style, markersize=16, label=label)
+        for color, style, label in zip(legend_colors, legend_styles, legend_labels)
+    ]
+
+    ax.legend(
+        handles=legend_elements,
+        loc='center right',
+        bbox_to_anchor=(1.0, 0.5),
+        frameon=False,
+        prop={'size': 14},
+        bbox_transform=fig.transFigure
+    )
+
+
+def format_time_string(ds: xr.DataArray) -> str:
+    """
+    Returns a formatted time string from the 'time' or 'valid_time' coordinate.
+    Includes hours if present (e.g., for hourly data).
+
+    Parameters
+    ----------
+    ds : xr.DataArray
+        DataArray that contains a 'time' or 'valid_time' coordinate.
+
+    Returns
+    -------
+    str
+        A formatted time string, e.g., '2025-04-06' or '2025-04-06 18:00'.
+
+    Raises
+    ------
+    ValueError
+        If neither 'time' nor 'valid_time' coordinate is found.
+    """
+    # Try to find time coordinate
+    for time_coord in ['time', 'valid_time']:
+        if time_coord in ds.coords:
+            time_val = ds[time_coord].values
+            break
+    else:
+        raise ValueError("No 'time' or 'valid_time' coordinate found.")
+
+    # Convert to pandas datetime (supporting scalar or array)
+    time_val = pd.to_datetime(time_val)
+
+    if isinstance(time_val, (np.ndarray, pd.DatetimeIndex)):
+        time_val = time_val[0]
+
+    # Include hour if not 00:00
+    if time_val.hour != 0 or time_val.minute != 0:
+        return time_val.strftime('%Y-%m-%d %H:%M')
+    else:
+        return time_val.strftime('%Y-%m-%d')
+

jcclass/plotting/functions/tools.py

@@ -0,0 +1,88 @@
+import xarray as xr
+import matplotlib.pyplot as plt
+from matplotlib.colors import ListedColormap
+
+import cartopy.crs as ccrs
+from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER
+import matplotlib.ticker as mticker
+from jcclass.utils.logging_config import setup_logger
+logger = setup_logger("jcclass")
+
+
+def ensure_2d(data: xr.DataArray) -> xr.DataArray:
+    """
+    Ensure the DataArray is 2D (after squeezing singleton dims).
+    If not, raise an error and stop plotting.
+
+    Parameters:
+        data (xr.DataArray): The input DataArray.
+
+    Returns:
+        xr.DataArray: A squeezed 2D DataArray ready for plotting.
+
+    Raises:
+        ValueError: If the resulting DataArray is not 2D.
+    """
+    squeezed = data.squeeze()
+
+    if squeezed.ndim != 2:
+        msg = (
+            f"The DataArray has {squeezed.ndim} dimensions after squeezing "
+            f"({list(squeezed.dims)}). Only 2D DataArrays can be plotted."
+        )
+        logger.error(msg)
+        raise ValueError(msg)
+
+    return squeezed
+
+
+def crop_area(data: xr.DataArray,
+              lat_north: float,
+              lat_south: float,
+              lon_west: float,
+              lon_east: float) -> xr.DataArray:
+    """
+    Crop the DataArray to the specified area.
+    Parameters:
+        data (xr.DataArray): The DataArray to crop.
+        lat_north (str): The northern latitude boundary.
+        lat_south (str): The southern latitude boundary.
+        lon_west (str): The western longitude boundary.
+        lon_east (str): The eastern longitude boundary.
+    """
+    lat_north = data.latitude.sel(latitude=lat_north, method='nearest')
+    lat_south = data.latitude.sel(latitude=lat_south, method='nearest')
+    lon_west = data.longitude.sel(longitude=lon_west, method='nearest')
+    lon_east = data.longitude.sel(longitude=lon_east, method='nearest')
+    data = data.sel(latitude=slice(lat_south, lat_north), longitude=slice(lon_west, lon_east))
+    return data
+
+
+def calculate_size(dif_x: float, dif_y: float) -> tuple:
+    size_x, size_y = 12, 10
+    if dif_x > dif_y:
+        size_y = size_x * (dif_y / dif_x)
+    elif dif_x < dif_y:
+        size_x = size_y * (dif_x / dif_y)
+    return size_x, size_y
+
+
+def define_colormap() -> ListedColormap:
+    return ListedColormap([
+        "#7C7C77", "#17344F", "#0255F4", "#0F78ED", "#9E09EE", "#F6664C",
+        "#F24E64", "#D3C42D", "#2FC698", "#20E1D7", "#BD0000"
+    ])
+
+
+def configure_gridlines(ax: plt.Axes) -> None:
+    gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True)
+    gl.top_labels = False
+    gl.bottom_labels = True
+    gl.left_labels = True
+    gl.right_labels = False
+    gl.xlines = False
+    gl.ylines = False
+    gl.ylocator = mticker.FixedLocator([-80, -60, -40, -20, 0, 20, 40, 60, 80])
+    gl.xlocator = mticker.FixedLocator([-180, -120, -60, 0, 60, 120, 180])
+    gl.xformatter = LONGITUDE_FORMATTER
+    gl.yformatter = LATITUDE_FORMATTER

jcclass/utils/logging_config.py

@@ -0,0 +1,22 @@
+import logging
+
+
+def setup_logger(name: str, level=logging.INFO) -> logging.Logger:
+    """
+    Sets up a logger with a given name and level.
+
+    Args:
+        name (str): Name of the logger.
+        level (int): Logging level (default: logging.INFO).
+
+    Returns:
+        logging.Logger: Configured logger instance.
+    """
+    logger = logging.getLogger(name)
+    if not logger.hasHandlers():  # Avoid adding duplicate handlers
+        logger.setLevel(level)
+        handler = logging.StreamHandler()  # Output to console
+        formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+    return logger

jcclass-0.0.1.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: jcclass
+Version: 0.0.1
+Summary: Jenkinson and Collison automated gridded classification
+Home-page: https://github.com/PedroLormendez/jcclass
+Author: Pedro Herrera-Lormendez
+Author-email: peth31@gmail.com
+License: MIT
+Keywords: circulations,CTs,WTs,synoptic
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.19.5
+Requires-Dist: xarray>=0.16.2
+Requires-Dist: matplotlib>=3.2.0
+Requires-Dist: pyproj
+Requires-Dist: cartopy>=0.17.0
+Requires-Dist: cftime
+Requires-Dist: netCDF4
+Requires-Dist: pytest
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Jenkinson - Collison automated gridded classification for Python  
+
+[![PyPI version fury.io](https://badge.fury.io/py/jcclass.svg)](https://pypi.python.org/pypi/jcclass/)
+[![DOI](https://zenodo.org/badge/524934105.svg)](https://zenodo.org/badge/latestdoi/524934105)
+[![downloads](https://img.shields.io/pypi/dm/jcclass.svg)](https://pypi.org/project/jcclass/)
+[![PyPI license](https://img.shields.io/pypi/l/jcclass.svg)](https://pypi.python.org/pypi/jcclass/)
+[![Twitter](https://badgen.net/badge/icon/twitter?icon=twitter&label)](https://twitter.com/PedroLormendez)
+
+
+This is an adapted version for python of the __Jenkinson - Collison__ automated classfication based on the original Lamb Weather Types. This gridded version is based on the application made by [Otero](https://link.springer.com/article/10.1007/s00382-017-3705-y) (2018) using a moving central gridded point with  that allows to compute the synoptic circulation types on a gridded Mean Sea Level Pressure (MSLP) domain.
+![](https://github.com/PedroLormendez/jc_module/blob/main/figs/Circulations_quick.gif)
+## How does it work?
+The method uses grid-point MSLP data to obtain numerical values of wind flow and vorticity which can be used to determine Cyclonic and Anticyclonic patterns as well as their dominant advective (direction of wind flow) characteristics. The 16 gridded points are moved along the region in reference to a central point where the dominant circulation type will be designated.   
+![](https://github.com/PedroLormendez/jc_module/blob/main/figs/Gridpoints.gif)
+
+## The Circulation Types (CTs)
+The application of the automated classification allows to derive 27 synoptic circulations. 26 of them based on the dominant pressure pattern and wind direction plus a Low Flow (LF) type which is characterised by days when pressure gradients are to weak and a dominant circulation or advective direction can not be assigned.
+
+|__Name__ | __Abreviation__| __Coding__|__Name__| __Abreviation__| __Coding__|__Name__| __Abreviation__| __Coding__|
+| :-      | :-:            | :-:       | :-     | :-:            | :-:       | :-     | :-:            | :-:    
+|Low Flow                   | LF             | -1        
+|Anticyclonic               | A              | 0         |             |   |   |Cyclonic              | C              | 20
+|Anticyclonic Northeasterly | ANE            | 1         |Northeasterly| NE| 11|Cyclonic Northeasterly| CNE            | 21
+|Anticyclonic Easterly      | AE             | 2         |Easterly     | E | 12|Cyclonic Easterly     | CE             | 22
+|Anticyclonic Southeasterly | ASE            | 3         |Southeasterly| SE| 13|Cyclonic Southeasterly| CSE            | 23
+|Anticyclonic Southerly     | AS             | 4         |Southerly    | S | 14|Cyclonic Southerly    | CS             | 24
+|Anticyclonic Southwesterly | ASW            | 5         |Southwesterly| SW| 15|Cyclonic Southwesterly| CSW            | 25
+|Anticyclonic Westerly      | AW             | 6         |Westerly     | W | 16|Cyclonic Westerly     | CW             | 26
+|Anticyclonic Northwesterly | ANW            | 7         |Northwesterly| NW| 17|Cyclonic Northwesterly| CNW            | 27
+|Anticyclonic Northerly     | AN             | 8         |Northerly    | N | 18|Cyclonic Northerly    | CN             | 28
+
+The original 27 circulations can be reduced to a set of 11 patterns based on their dominant advection.
+
+|Name                   | Abreviation | Coding
+| :-                   | :-:          | :-:    
+|Low Flow               | LF          | -1     
+|Anticyclonic           | A           | 0
+|Northeasterly          | NE          | 1
+|Easterly               | E           | 2
+|Southeasterly          | SE          | 3
+|Southerly              | S           | 4
+|Southwesterly          | SW          | 5
+|Westerly               | W           | 6
+|Northwesterly          | NW          | 7
+|Northerly              | N           | 8
+|Cyclonic               | C           | 9
+
+## Working datasets
+
+The current code has been has been tested for the following datasets:
+- [ERA5](https://www.ecmwf.int/en/forecasts/datasets/reanalysis-datasets/era5) Reanalysis
+-[NOAA](https://psl.noaa.gov/data/gridded/data.20thC_ReanV3.html) 20th Century Reanalysis (V3)
+- Global Climate Models from the Coupled Model Intercomparison Project ([CMIP6](https://esgf-node.llnl.gov/projects/cmip6/))
+
+The method can be applied for any other netcdf files with latitude coordinates names as "latitude" or "lat", or longitudes coordinates as "longitude" or "lon" and MSLP coordinate names as "msl" or "psl".
+
+Sample datasets from ERA5 is provided and available [here](https://github.com/PedroLormendez/jc_module/tree/main/sample_data)
+## Installation
+Simply run in the terminal
+```
+pip install jcclass
+```
+
+## How to use?
+__Importing the module__
+```python
+from jcclass.compute import compute_cts, eleven_cts
+from jcclass.plotting import plot_cts
+```
+
+__Computing the automated circulation types based on gridded MSLP__
+
+Sample datasets available [here](https://github.com/PedroLormendez/jc_module/tree/main/sample_data).
+
+```python
+import xarray as xr
+filename = 'era5_daily_lowres.nc'
+ds_mslp = xr.open_dataset("sample_data/era5_daily_lowres.nc").msl
+cts_27 = compute_cts(ds_mslp)
+```
+__Computing the reduced eleven circulation types__
+```python
+cts_11 = eleven_cts(cts_27)
+```
+__Ploting the circulation types on a map__
+```python
+# Select a single day
+date = "1979-01-03"
+cts_2d = cts_27.sel(time = date) # selecting one time
+fig = plot_cts(cts_2d, *args)
+```
+- *cts   : a 2D  xarray.DataArray of the 27 CTs*
+- **args : 
+
+- float, __optional__ (lat_south, lat_north, lon_west, lon_east)*
+- bool, __optional__ (show = True)* False to not show the figure
+![](https://github.com/PedroLormendez/jc_module/blob/main/figs/plot_cts.png)
+
+__Saving the figures__
+
+You can save anytime any of the figures using ``fig.savefig``.
+
+```py
+fig.savefig('figname.png', dpi = 150)
+```
+
+## Acknowledging this work
+The code can be used and modified freely without any restriction. If you use it for your own research, I would appreciate if you cite this work as follows:
+
+Herrera-Lormendez P., 2022: PedroLormendez/jcclass: version x.y.z [doi:10.5281/zenodo.7025220](https://zenodo.org/record/7025220#.YwjIKexByWg)
+
+Reports on errors are welcomed by [raising an issue](https://github.com/PedroLormendez/JC-Classification/issues)
+
+## Further literature on the method
+- Jenkinson AF, Collison FP. 1977. An Initial Climatology of Gales over the North Sea. Synoptic Climatology Branch Memorandum, No. 62., Meteorological Office, Bracknell.
+- Lamb HH. 1972. British Isles weather types and a register of daily sequence of circulation patterns, 1861-1971: Geophysical Memoir. HMSO.
+- Jones PD, Hulme M, Briffa KR. 1993. A comparison of Lamb circulation types with an objective classification scheme. International Journal of Climatology. John Wiley & Sons, Ltd, 13(6): 655–663. https://doi.org/10.1002/joc.3370130606.
+- Otero N, Sillmann J, Butler T. 2018. Assessment of an extended version of the Jenkinson–Collison classification on CMIP5 models over Europe. Climate Dynamics. Springer Verlag, 50(5–6): 1559–1579. https://doi.org/10.1007/s00382-017-3705-y.

jcclass-0.0.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+jcclass/__init__.py,sha256=00F4MrlU6_vBR02AdrYpqHcWGzrRe2zm5jzO4S5WMYk,129
+jcclass/compute/__init__.py,sha256=xXvi0FMN23bILEynpwQW2jSSHfwSA5FKG9FnipHPlkw,83
+jcclass/compute/core.py,sha256=lU7_sL8uOXX_ysQQOyCJjz_4Y1T9P1kSPf6UISSJ92c,2457
+jcclass/compute/functions/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+jcclass/compute/functions/computation.py,sha256=bWJyp5xKwMPfNvxGaN_tETQAL1K4isjPJBX8uhJmFBs,8649
+jcclass/compute/functions/constants.py,sha256=-QKkxvDt5ImiIr6wbhp8-ljePkfPEd71XrBg69M6mGM,2374
+jcclass/compute/functions/data_extraction.py,sha256=6zhaoIQn01KpeGEgGa5j8QTZsrR0sL5msnJuN_6ugPQ,5957
+jcclass/compute/functions/data_preparation.py,sha256=KziZpEhJ8HGyFntc9RzPWF0-TkdPfvbWSoo3my6Vk1o,4217
+jcclass/compute/functions/format_data.py,sha256=dim7AqPyafxEtQSigQd82AcDp_ptf-0V2vrYs-6uL5s,1952
+jcclass/compute/functions/main.py,sha256=EL4MlENtOZV9AMChTgftFDErLB8vymD907MyDezIiqg,2084
+jcclass/plotting/__init__.py,sha256=tTH6ZQCE2ypbcfzT5-e4aS-N5NJBZLbID3iNHeGOqMg,51
+jcclass/plotting/core.py,sha256=AornbUVDY5prI_8KAA_YL-LP3F59Qh2ZTkKmQzK3J1M,3635
+jcclass/plotting/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jcclass/plotting/functions/plot_utils.py,sha256=XOCwN9-ikAlS2K-rlzb4j5FusdRztf0LrssR9pPMgOg,5183
+jcclass/plotting/functions/tools.py,sha256=Ix7rDbi-D_cBzugKwrQYynsUvIqqbAwfHKmMzsBWqhg,2923
+jcclass/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jcclass/utils/logging_config.py,sha256=QH-a4bZhX_-G9JawGAAfeBSP91Pt7Z8iOHYNTM11FTk,713
+jcclass-0.0.1.dist-info/METADATA,sha256=NBFWU8bC-fICltVG_3mAEN2CvcC0niT0K_JhodHxMtg,7996
+jcclass-0.0.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+jcclass-0.0.1.dist-info/top_level.txt,sha256=-9-rcwn8C0pQ5oeHIYv_V5p9yYhCBkTWgGU7FLZ1HOk,8
+jcclass-0.0.1.dist-info/RECORD,,

jcclass-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jcclass-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+jcclass