Update pyPDAF/mcp_output/mcp_plugin/mcp_service.py

pyPDAF/mcp_output/mcp_plugin/mcp_service.py

@@ -25,6 +25,125 @@ mcp = FastMCP("pyPDAF_service")
 # PDAF Core Module Tools
 # ============================================================================
 
+@mcp.tool(name="pdaf_gather_dim_obs_f", description="Gather global observation dimension across local domains")
+def pdaf_gather_dim_obs_f(dim_obs_p: int) -> dict:
+    """
+    Gather total observation dimension and displacements from local dimensions.
+
+    This allocates the global observation size used by gather_obs_f routines.
+
+    Args:
+        dim_obs_p: Process-local observation dimension.
+
+    Returns:
+        dict: A dictionary containing the full observation dimension.
+    """
+    try:
+        dim_obs_f = PDAF.gather_dim_obs_f(dim_obs_p)
+        return {"success": True, "result": {"dim_obs_f": int(dim_obs_f)}, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_gather_obs_f", description="Gather full observation vector from process-local pieces")
+def pdaf_gather_obs_f(obs_p: List[float], dimobs_f: int) -> dict:
+    """
+    Concatenate process-local observation vectors into a full vector (local-filter use).
+
+    Args:
+        obs_p: Process-local observation vector.
+        dimobs_f: Full observation dimension.
+
+    Returns:
+        dict: A dictionary containing the gathered observation vector and status.
+    """
+    try:
+        obs_p_np = np.array(obs_p, dtype=np.float64)
+        obs_f, status = PDAF.gather_obs_f(obs_p_np, dimobs_f)
+        return {
+            "success": True,
+            "result": {"obs_f": obs_f.tolist(), "status": int(status)},
+            "error": None,
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_gather_obs_f2", description="Gather observation coordinates from local pieces")
+def pdaf_gather_obs_f2(coords_p: List[List[float]], nrows: int, dimobs_f: int) -> dict:
+    """
+    Concatenate process-local observation coordinate arrays into a full coordinate array.
+
+    Args:
+        coords_p: Local coordinate array shaped [nrows, dimobs_p].
+        nrows: Number of coordinate rows (e.g., spatial dimensions).
+        dimobs_f: Full observation dimension.
+
+    Returns:
+        dict: A dictionary containing the gathered coordinates and status.
+    """
+    try:
+        coords_p_np = np.array(coords_p, dtype=np.float64)
+        coords_f, status = PDAF.gather_obs_f2(coords_p_np, nrows, dimobs_f)
+        return {
+            "success": True,
+            "result": {"coords_f": coords_f.tolist(), "status": int(status)},
+            "error": None,
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_gather_obs_f_flex", description="Gather full observation vector without PDAF-internal metadata")
+def pdaf_gather_obs_f_flex(dim_obs_p: int, dim_obs_f: int, obs_p: List[float]) -> dict:
+    """
+    Flexibly gather observation vectors using explicit local/global sizes.
+
+    Args:
+        dim_obs_p: Process-local observation dimension.
+        dim_obs_f: Full observation dimension.
+        obs_p: Local observation vector.
+
+    Returns:
+        dict: A dictionary containing the gathered observation vector and status.
+    """
+    try:
+        obs_p_np = np.array(obs_p, dtype=np.float64)
+        obs_f, status = PDAF.gather_obs_f_flex(dim_obs_p, dim_obs_f, obs_p_np)
+        return {
+            "success": True,
+            "result": {"obs_f": obs_f.tolist(), "status": int(status)},
+            "error": None,
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="pdaf_gather_obs_f2_flex", description="Gather observation coordinates without PDAF-internal metadata")
+def pdaf_gather_obs_f2_flex(dim_obs_p: int, dim_obs_f: int, coords_p: List[List[float]], nrows: int) -> dict:
+    """
+    Flexibly gather 2D observation coordinate arrays using explicit local/global sizes.
+
+    Args:
+        dim_obs_p: Process-local observation dimension.
+        dim_obs_f: Full observation dimension.
+        coords_p: Local coordinate array shaped [nrows, dim_obs_p].
+        nrows: Number of coordinate rows (e.g., spatial dimensions).
+
+    Returns:
+        dict: A dictionary containing the gathered coordinates and status.
+    """
+    try:
+        coords_p_np = np.array(coords_p, dtype=np.float64)
+        coords_f, status = PDAF.gather_obs_f2_flex(dim_obs_p, dim_obs_f, coords_p_np, nrows)
+        return {
+            "success": True,
+            "result": {"coords_f": coords_f.tolist(), "status": int(status)},
+            "error": None,
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
 @mcp.tool(name="pdaf_correlation_function", description="Calculate the value of a correlation function at a given distance")
 def pdaf_correlation_function(ctype: int, length: float, distance: float) -> dict:
     """