Update pyPDAF/mcp_output/mcp_plugin/mcp_service.py

pyPDAF/mcp_output/mcp_plugin/mcp_service.py

@@ -151,36 +151,6 @@ def _read_state_nc(filepath: str) -> Tuple[np.ndarray, np.ndarray, np.ndarray, n
     return lon, lat, depth, temp, salt, u, v, eta_t
 
 
-def _gaspari_cohn(r: float, c: float) -> float:
-    """
-    Gaspari-Cohn correlation function for localization.
-    
-    Args:
-        r: Distance between two points
-        c: Cutoff radius (localization radius)
-    
-    Returns:
-        Correlation value between 0 and 1
-    """
-    z = r / c
-    
-    if z >= 2:
-        return 0.0
-    elif z >= 1:
-        term1 = z**5 / 12.0
-        term2 = z**4 / 2.0
-        term3 = 5.0 * z**3 / 8.0
-        term4 = 5.0 * z**2 / 3.0
-        result = -term1 + term2 + term3 - term4 + 5.0 * z - 4.0 + 2.0 / (3.0 * z)
-        return result
-    else:  # z < 1
-        term1 = z**5 / 4.0
-        term2 = z**4 / 2.0
-        term3 = 5.0 * z**3 / 8.0
-        result = -term1 + term2 + term3 + 1.0
-        return result
-
-
 # ============================================================================
 # MCP Tool 1: Generate Demo Ocean Data
 # ============================================================================
@@ -321,16 +291,16 @@ def run_enoi_pipeline(
     obs_path: str = "obs.nc",
     analysis_path: str = "restart_analysis.nc",
     inflation_factor: float = 1.0,
-    localization_radius: float = 500.0
+    localization_radius: float = 0.0
 ) -> Dict[str, Any]:
     """
     Run Ensemble Optimal Interpolation (EnOI) data assimilation pipeline using pyPDAF.
     
     This implements the EnOI algorithm by:
-    1. Initialize PDAF with EnKF filtertype=200 (EnOI with static ensemble)
+    1. Initialize PDAF with EnKF filtertype=2 (EnKF with static ensemble for EnOI)
     2. Load background state, static ensemble, and observations
     3. Use PDAFomi to handle observation operator
-    4. Apply optional Gaspari-Cohn localization
+    4. Apply optional Gaspari-Cohn localization using omi_init_dim_obs_l_iso
     5. Run offline assimilation
     6. Write analysis state
     
@@ -340,7 +310,7 @@ def run_enoi_pipeline(
         obs_path: Path to observation file
         analysis_path: Output path for analysis state
         inflation_factor: Covariance inflation factor (default 1.0)
-        localization_radius: Localization radius in km (default 500, 0 = no localization)
+        localization_radius: Localization radius in km (default 0 = no localization, global filter)
     
     Returns:
         Status dictionary with analysis statistics
@@ -383,8 +353,7 @@ def run_enoi_pipeline(
     # Step 3: Initialize PDAF for EnOI (offline mode)
     # ========================================================================
     
-    # FilterType: For EnOI, we use filtertype=200 (SEEK with fixed covariance)
-    # or filtertype=2 (EnKF) which works for static ensemble
+    # FilterType: For EnOI, we use filtertype=2 (EnKF with static ensemble)
     filtertype = 2  # EnKF
     subtype = 0      # Standard form
     
@@ -420,17 +389,6 @@ def run_enoi_pipeline(
     # Initialize PDAFomi with 1 observation type
     pyPDAF.PDAFomi.init(1)
     
-    # Setup localization if requested
-    if localization_radius > 0:
-        # Convert radius from km to degrees (approximate)
-        radius_deg = localization_radius / 111.0
-        
-        # Initialize local analysis
-        pyPDAF.PDAFomi.init_local()
-        
-        # Set localization
-        pyPDAF.PDAF.set_localfilter(1)  # Enable local filter
-    
     # Observation class to handle PDAFomi callbacks
     class ObsHandler:
         def __init__(self):
@@ -497,12 +455,23 @@ def run_enoi_pipeline(
     
     collector = StateCollector()
     
-    # Localization handler (if needed)
+    # ========================================================================
+    # Step 5: Run assimilation (global or local)
+    # ========================================================================
+    
     if localization_radius > 0:
-        # Create grid coordinates
+        # Run with localization (domain-localized filter)
+        # Convert radius from km to degrees (approximate)
+        radius_deg = localization_radius / 111.0
+        
+        # Create grid coordinates for domain points
         lon_grid, lat_grid = np.meshgrid(lon, lat, indexing='ij')
         
         class LocalizationHandler:
+            def __init__(self):
+                # Initialize local analysis
+                pyPDAF.PDAFomi.init_local()
+                
             def init_n_domains_pdaf(self, step, n_domains_p):
                 """Number of local analysis domains"""
                 n_domains_p = n_state
@@ -514,21 +483,39 @@ def run_enoi_pipeline(
                 return dim_l
             
             def init_dim_obs_l_pdafomi(self, domain_p, step, dim_obs_f, dim_obs_l):
-                """Local observation dimension"""
-                # For each domain point, find observations within localization radius
-                i_domain = domain_p - 1  # Convert to 0-index
-                
+                """Local observation dimension using PDAFomi localization"""
                 # Get domain coordinates
+                i_domain = domain_p - 1  # Convert to 0-index
                 state_lon = lon_grid.ravel()[i_domain % (nx*ny)]
                 state_lat = lat_grid.ravel()[i_domain % (nx*ny)]
                 
-                # Calculate distances to all observations
-                dx = obs_lon - state_lon
-                dy = obs_lat - state_lat
-                dist = np.sqrt(dx**2 + dy**2)
+                # Create coordinate for this domain
+                coords_l = np.array([state_lon, state_lat], order='F')
+                
+                # Use PDAFomi isotropic localization
+                # Parameters: thisobs_l, thisobs, coords_l, locweight, cradius, sradius, dim_obs_l
+                # locweight: 0=unit weight, 2=Gaspari-Cohn
+                locweight = 2  # Gaspari-Cohn
+                cradius = radius_deg  # Cut-off radius
+                sradius = radius_deg  # Support radius (same as cut-off for Gaspari-Cohn)
+                
+                # Call omi_init_dim_obs_l_iso for isotropic localization
+                try:
+                    dim_obs_l = pyPDAF.PDAF.omi_init_dim_obs_l_iso(
+                        obs_handler.i_obs,  # observation type
+                        coords_l,           # local domain coordinates
+                        locweight,          # localization weight function
+                        cradius,           # cut-off radius
+                        sradius            # support radius
+                    )
+                except Exception as e:
+                    print(f"Warning: omi_init_dim_obs_l_iso failed: {e}")
+                    # Fallback: count observations manually
+                    dx = obs_lon - state_lon
+                    dy = obs_lat - state_lat
+                    dist = np.sqrt(dx**2 + dy**2)
+                    dim_obs_l = np.sum(dist <= radius_deg)
                 
-                # Count observations within localization radius
-                dim_obs_l = np.sum(dist <= radius_deg)
                 return dim_obs_l
         
         loc_handler = LocalizationHandler()
@@ -548,9 +535,9 @@ def run_enoi_pipeline(
                 status
             )
         except Exception as e:
-            return {"status": "error", "message": f"Assimilation failed: {str(e)}"}
+            return {"status": "error", "message": f"Localized assimilation failed: {str(e)}"}
     else:
-        # Run offline assimilation without localization (global)
+        # Run without localization (global filter)
         try:
             status = 0
             pyPDAF.assim_offline_global_nondiagr(
@@ -562,7 +549,7 @@ def run_enoi_pipeline(
                 status
             )
         except Exception as e:
-            return {"status": "error", "message": f"Assimilation failed: {str(e)}"}
+            return {"status": "error", "message": f"Global assimilation failed: {str(e)}"}
     
     # ========================================================================
     # Step 6: Write analysis state
@@ -604,4 +591,4 @@ def run_enoi_pipeline(
 
 def create_app():
     """Create and return the FastMCP application."""
-    return mcp
+    return mcp