Update pysph/mcp_output/mcp_plugin/mcp_service.py

pysph/mcp_output/mcp_plugin/mcp_service.py

@@ -1,5 +1,6 @@
 import os
 import sys
+from typing import List, Optional, Dict, Any
 
 # Add the local source directory to sys.path
 source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
@@ -7,69 +8,875 @@ if source_path not in sys.path:
     sys.path.insert(0, source_path)
 
 from fastmcp import FastMCP
+import numpy as np
 
 # Import core modules from the local source
-from pysph.solver.application import Application
-from pysph.sph.scheme import Scheme
+from pysph.tools import geometry
+from pysph.base import kernels
+from pysph.base.utils import get_particle_array
 from pysph.sph.integrator import Integrator
 
 # Create the MCP service application
 mcp = FastMCP("pysph_service")
 
-@mcp.tool(name="run_simulation", description="Run a SPH simulation using the Application class.")
-def run_simulation(config_file: str) -> dict:
+# =====================================================
+# Geometry Tools - 几何工具
+# =====================================================
+
+@mcp.tool(name="create_2d_circle", description="Create a 2D circular particle distribution.")
+def create_2d_circle(dx: float = 0.01, radius: float = 1.0, 
+                     center_x: float = 0.0, center_y: float = 0.0) -> dict:
+    """
+    Create a 2D circular particle distribution.
+    
+    Parameters:
+    - dx (float): Particle spacing (default: 0.01)
+    - radius (float): Radius of the circle (default: 1.0)
+    - center_x (float): X coordinate of center (default: 0.0)
+    - center_y (float): Y coordinate of center (default: 0.0)
+    
+    Returns:
+    - dict: Contains x, y coordinates and particle count.
+    """
+    try:
+        center = np.array([center_x, center_y])
+        x, y = geometry.get_2d_circle(dx=dx, r=radius, center=center)
+        return {
+            "success": True,
+            "num_particles": len(x),
+            "x": x.tolist(),
+            "y": y.tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_2d_block", description="Create a 2D rectangular block of particles.")
+def create_2d_block(dx: float = 0.01, length: float = 1.0, height: float = 1.0,
+                    center_x: float = 0.0, center_y: float = 0.0) -> dict:
+    """
+    Create a 2D rectangular block of particles.
+    
+    Parameters:
+    - dx (float): Particle spacing (default: 0.01)
+    - length (float): Length of the block in x direction (default: 1.0)
+    - height (float): Height of the block in y direction (default: 1.0)
+    - center_x (float): X coordinate of center (default: 0.0)
+    - center_y (float): Y coordinate of center (default: 0.0)
+    
+    Returns:
+    - dict: Contains x, y coordinates and particle count.
+    """
+    try:
+        center = np.array([center_x, center_y])
+        x, y = geometry.get_2d_block(dx=dx, length=length, height=height, center=center)
+        return {
+            "success": True,
+            "num_particles": len(x),
+            "x": x.tolist(),
+            "y": y.tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_3d_sphere", description="Create a 3D spherical particle distribution.")
+def create_3d_sphere(dx: float = 0.05, radius: float = 0.5,
+                     center_x: float = 0.0, center_y: float = 0.0, 
+                     center_z: float = 0.0) -> dict:
+    """
+    Create a 3D spherical particle distribution.
+    
+    Parameters:
+    - dx (float): Particle spacing (default: 0.05)
+    - radius (float): Radius of the sphere (default: 0.5)
+    - center_x, center_y, center_z: Coordinates of center
+    
+    Returns:
+    - dict: Contains x, y, z coordinates and particle count.
+    """
+    try:
+        center = np.array([center_x, center_y, center_z])
+        x, y, z = geometry.get_3d_sphere(dx=dx, r=radius, center=center)
+        return {
+            "success": True,
+            "num_particles": len(x),
+            "x": x.tolist(),
+            "y": y.tolist(),
+            "z": z.tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_3d_block", description="Create a 3D rectangular block of particles.")
+def create_3d_block(dx: float = 0.05, length: float = 1.0, height: float = 1.0, 
+                    depth: float = 1.0, center_x: float = 0.0, 
+                    center_y: float = 0.0, center_z: float = 0.0) -> dict:
+    """
+    Create a 3D rectangular block of particles.
+    
+    Parameters:
+    - dx (float): Particle spacing (default: 0.05)
+    - length (float): Length in x direction (default: 1.0)
+    - height (float): Height in y direction (default: 1.0)
+    - depth (float): Depth in z direction (default: 1.0)
+    - center_x, center_y, center_z: Coordinates of center
+    
+    Returns:
+    - dict: Contains x, y, z coordinates and particle count.
+    """
+    try:
+        center = np.array([center_x, center_y, center_z])
+        x, y, z = geometry.get_3d_block(dx=dx, length=length, height=height, 
+                                        depth=depth, center=center)
+        return {
+            "success": True,
+            "num_particles": len(x),
+            "x": x.tolist(),
+            "y": y.tolist(),
+            "z": z.tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="translate_particles", description="Translate particle positions in 3D space.")
+def translate_particles(x: List[float], y: List[float], z: List[float],
+                        x_translate: float = 0.0, y_translate: float = 0.0, 
+                        z_translate: float = 0.0) -> dict:
+    """
+    Translate particle positions by specified amounts.
+    
+    Parameters:
+    - x, y, z: Lists of particle coordinates
+    - x_translate, y_translate, z_translate: Translation amounts
+    
+    Returns:
+    - dict: Contains translated x, y, z coordinates.
     """
-    Run a SPH simulation using the provided configuration file.
+    try:
+        x_new, y_new, z_new = geometry.translate(
+            np.array(x), np.array(y), np.array(z),
+            x_translate, y_translate, z_translate
+        )
+        return {
+            "success": True,
+            "num_particles": len(x_new),
+            "x": x_new.tolist(),
+            "y": y_new.tolist(),
+            "z": z_new.tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="rotate_particles", description="Rotate particle positions around an axis.")
+def rotate_particles(x: List[float], y: List[float], z: List[float],
+                     axis_x: float = 0.0, axis_y: float = 0.0, axis_z: float = 1.0,
+                     angle: float = 90.0) -> dict:
+    """
+    Rotate particle positions around a specified axis.
+    
+    Parameters:
+    - x, y, z: Lists of particle coordinates
+    - axis_x, axis_y, axis_z: Components of rotation axis (default: z-axis)
+    - angle: Rotation angle in degrees (default: 90.0)
+    
+    Returns:
+    - dict: Contains rotated x, y, z coordinates.
+    """
+    try:
+        axis = np.array([axis_x, axis_y, axis_z])
+        x_new, y_new, z_new = geometry.rotate(
+            np.array(x), np.array(y), np.array(z), axis, angle
+        )
+        return {
+            "success": True,
+            "num_particles": len(x_new),
+            "x": x_new.tolist(),
+            "y": y_new.tolist(),
+            "z": z_new.tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="extrude_2d_to_3d", description="Extrude a 2D geometry into 3D along the z-axis.")
+def extrude_2d_to_3d(x: List[float], y: List[float], dx: float = 0.01,
+                     extrude_dist: float = 1.0, z_center: float = 0.0) -> dict:
+    """
+    Extrude a 2D geometry into 3D along the z-axis.
+    
+    Parameters:
+    - x, y: Lists of 2D particle coordinates
+    - dx (float): Particle spacing for extrusion (default: 0.01)
+    - extrude_dist (float): Total extrusion distance (default: 1.0)
+    - z_center (float): Center z coordinate for extrusion (default: 0.0)
+    
+    Returns:
+    - dict: Contains 3D x, y, z coordinates.
+    """
+    try:
+        x_new, y_new, z_new = geometry.extrude(
+            np.array(x), np.array(y), dx, extrude_dist, z_center
+        )
+        return {
+            "success": True,
+            "num_particles": len(x_new),
+            "x": x_new.tolist(),
+            "y": y_new.tolist(),
+            "z": z_new.tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="create_2d_wall", description="Create a 2D wall (line of particles) parallel to x-axis.")
+def create_2d_wall(dx: float = 0.01, center_x: float = 0.0, center_y: float = 0.0,
+                   length: float = 1.0, num_layers: int = 1, up: bool = True) -> dict:
+    """
+    Create a 2D wall (line of particles) parallel to x-axis.
+    
+    Parameters:
+    - dx (float): Particle spacing (default: 0.01)
+    - center_x, center_y: Center coordinates of the wall
+    - length (float): Length of the wall (default: 1.0)
+    - num_layers (int): Number of particle layers (default: 1)
+    - up (bool): If True, layers extend upward; if False, downward (default: True)
+    
+    Returns:
+    - dict: Contains x, y coordinates and particle count.
+    """
+    try:
+        center = np.array([center_x, center_y])
+        x, y = geometry.get_2d_wall(dx=dx, center=center, length=length, 
+                                     num_layers=num_layers, up=up)
+        return {
+            "success": True,
+            "num_particles": len(x),
+            "x": x.tolist(),
+            "y": y.tolist()
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
 
+
+@mcp.tool(name="create_naca_airfoil", description="Create a NACA 4-digit series airfoil geometry.")
+def create_naca_airfoil(dx: float = 0.01, airfoil: str = "0012", 
+                        chord: float = 1.0) -> dict:
+    """
+    Create a NACA 4-digit series airfoil geometry.
+    
+    The airfoil string format: 'MPXX' where:
+    - M: Maximum camber (% of chord)
+    - P: Position of maximum camber (tenths of chord)
+    - XX: Maximum thickness (% of chord)
+    
     Parameters:
-    - config_file (str): Path to the configuration file for the simulation.
+    - dx (float): Particle spacing (default: 0.01)
+    - airfoil (str): NACA 4-digit designation (default: "0012")
+    - chord (float): Chord length (default: 1.0)
+    
+    Returns:
+    - dict: Contains x, y coordinates and particle count.
+    """
+    try:
+        x, y = geometry.get_4digit_naca_airfoil(dx=dx, airfoil=airfoil, c=chord)
+        return {
+            "success": True,
+            "num_particles": len(x),
+            "x": x.tolist(),
+            "y": y.tolist(),
+            "airfoil_type": f"NACA {airfoil}",
+            "chord": chord
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# =====================================================
+# Kernel Tools - 核函数工具
+# =====================================================
+
+@mcp.tool(name="list_available_kernels", description="List all available SPH kernel functions.")
+def list_available_kernels() -> dict:
+    """
+    List all available SPH kernel functions in PySPH.
+    
+    Returns:
+    - dict: Contains list of kernel names with descriptions.
+    """
+    try:
+        available_kernels = {
+            "CubicSpline": {
+                "dimensions": [1, 2, 3],
+                "radius_scale": 2.0,
+                "description": "Classical cubic spline kernel (Monaghan 1992)"
+            },
+            "WendlandQuintic": {
+                "dimensions": [2, 3],
+                "radius_scale": 2.0,
+                "description": "Wendland quintic C2 kernel, good stability"
+            },
+            "WendlandQuinticC2_1D": {
+                "dimensions": [1],
+                "radius_scale": 2.0,
+                "description": "Wendland quintic C2 kernel for 1D"
+            },
+            "WendlandQuinticC4": {
+                "dimensions": [2, 3],
+                "radius_scale": 2.0,
+                "description": "Wendland quintic C4 kernel"
+            },
+            "WendlandQuinticC4_1D": {
+                "dimensions": [1],
+                "radius_scale": 2.0,
+                "description": "Wendland quintic C4 kernel for 1D"
+            },
+            "WendlandQuinticC6": {
+                "dimensions": [2, 3],
+                "radius_scale": 2.0,
+                "description": "Wendland quintic C6 kernel"
+            },
+            "Gaussian": {
+                "dimensions": [1, 2, 3],
+                "radius_scale": 3.0,
+                "description": "Gaussian kernel with infinite support (truncated)"
+            },
+            "QuinticSpline": {
+                "dimensions": [1, 2, 3],
+                "radius_scale": 3.0,
+                "description": "Quintic spline kernel"
+            },
+            "SuperGaussian": {
+                "dimensions": [1, 2, 3],
+                "radius_scale": 3.0,
+                "description": "Super Gaussian kernel"
+            }
+        }
+        return {
+            "success": True,
+            "kernels": available_kernels,
+            "total_count": len(available_kernels)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
 
+@mcp.tool(name="create_kernel", description="Create an SPH kernel function instance.")
+def create_kernel(kernel_type: str = "CubicSpline", dim: int = 2) -> dict:
+    """
+    Create an SPH kernel function instance.
+    
+    Parameters:
+    - kernel_type (str): Type of kernel (default: "CubicSpline")
+    - dim (int): Dimension of the problem (default: 2)
+    
     Returns:
-    - dict: A dictionary containing success, result, or error information.
+    - dict: Contains kernel information and properties.
     """
     try:
-        app = Application(config_file=config_file)
-        app.run()
-        return {"success": True, "result": "Simulation completed successfully."}
+        kernel_map = {
+            "CubicSpline": kernels.CubicSpline,
+            "WendlandQuintic": kernels.WendlandQuintic,
+            "Gaussian": kernels.Gaussian,
+            "QuinticSpline": kernels.QuinticSpline,
+        }
+        
+        if kernel_type not in kernel_map:
+            return {
+                "success": False,
+                "error": f"Unknown kernel type: {kernel_type}. Available: {list(kernel_map.keys())}"
+            }
+        
+        kernel = kernel_map[kernel_type](dim=dim)
+        
+        return {
+            "success": True,
+            "kernel_type": kernel_type,
+            "dimension": dim,
+            "radius_scale": kernel.radius_scale,
+            "deltap": kernel.get_deltap() if hasattr(kernel, 'get_deltap') else None
+        }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-@mcp.tool(name="create_scheme", description="Create a SPH scheme using the Scheme class.")
-def create_scheme(scheme_name: str, parameters: dict) -> dict:
+
+@mcp.tool(name="evaluate_kernel", description="Evaluate a kernel function at a given distance.")
+def evaluate_kernel(kernel_type: str = "CubicSpline", dim: int = 2,
+                    rij: float = 0.5, h: float = 0.1) -> dict:
     """
-    Create a SPH scheme with the given name and parameters.
+    Evaluate a kernel function at a given distance.
+    
+    Parameters:
+    - kernel_type (str): Type of kernel (default: "CubicSpline")
+    - dim (int): Dimension of the problem (default: 2)
+    - rij (float): Distance between particles (default: 0.5)
+    - h (float): Smoothing length (default: 0.1)
+    
+    Returns:
+    - dict: Contains kernel value and gradient magnitude.
+    """
+    try:
+        kernel_map = {
+            "CubicSpline": kernels.CubicSpline,
+            "WendlandQuintic": kernels.WendlandQuintic,
+            "Gaussian": kernels.Gaussian,
+            "QuinticSpline": kernels.QuinticSpline,
+        }
+        
+        if kernel_type not in kernel_map:
+            return {
+                "success": False,
+                "error": f"Unknown kernel type: {kernel_type}"
+            }
+        
+        kernel = kernel_map[kernel_type](dim=dim)
+        
+        # Evaluate kernel value
+        w = kernel.kernel(rij=rij, h=h)
+        
+        # Evaluate kernel gradient (dwdq)
+        dwdq = kernel.dwdq(rij=rij, h=h)
+        
+        # Calculate q = rij/h
+        q = rij / h
+        
+        return {
+            "success": True,
+            "kernel_type": kernel_type,
+            "dimension": dim,
+            "rij": rij,
+            "h": h,
+            "q": q,
+            "kernel_value": w,
+            "kernel_gradient": dwdq
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# =====================================================
+# Particle Array Tools - 粒子数组工具
+# =====================================================
 
+@mcp.tool(name="create_particle_array", description="Create a PySPH particle array with specified properties.")
+def create_particle_array(name: str = "fluid", x: List[float] = None, 
+                          y: List[float] = None, z: List[float] = None,
+                          h: float = 0.1, rho: float = 1000.0,
+                          m: float = None) -> dict:
+    """
+    Create a PySPH particle array with specified properties.
+    
     Parameters:
-    - scheme_name (str): Name of the scheme to create.
-    - parameters (dict): Parameters for the scheme.
+    - name (str): Name of the particle array (default: "fluid")
+    - x, y, z: Lists of particle coordinates (z optional for 2D)
+    - h (float): Smoothing length (default: 0.1)
+    - rho (float): Density (default: 1000.0)
+    - m (float): Particle mass (if None, calculated from rho and h)
+    
+    Returns:
+    - dict: Contains particle array information.
+    """
+    try:
+        if x is None:
+            x = [0.0]
+        if y is None:
+            y = [0.0]
+        if z is None:
+            z = [0.0] * len(x)
+            
+        x = np.array(x)
+        y = np.array(y)
+        z = np.array(z)
+        
+        # Calculate mass if not provided (2D approximation)
+        if m is None:
+            dx = h / 1.3  # approximate dx from h
+            m = rho * dx * dx  # 2D mass
+        
+        pa = get_particle_array(
+            name=name,
+            x=x, y=y, z=z,
+            h=np.ones_like(x) * h,
+            rho=np.ones_like(x) * rho,
+            m=np.ones_like(x) * m
+        )
+        
+        return {
+            "success": True,
+            "name": name,
+            "num_particles": len(x),
+            "properties": list(pa.properties.keys()),
+            "h": h,
+            "rho": rho,
+            "m": m
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="get_default_properties", description="Get the default properties for SPH particle arrays.")
+def get_default_properties() -> dict:
+    """
+    Get the default properties for SPH particle arrays.
+    
+    Returns:
+    - dict: Contains list of default properties with descriptions.
+    """
+    try:
+        from pysph.base.utils import DEFAULT_PROPS
+        
+        property_descriptions = {
+            'x': 'X-coordinate position',
+            'y': 'Y-coordinate position',
+            'z': 'Z-coordinate position',
+            'u': 'X-component of velocity',
+            'v': 'Y-component of velocity',
+            'w': 'Z-component of velocity',
+            'm': 'Particle mass',
+            'h': 'Smoothing length',
+            'rho': 'Density',
+            'p': 'Pressure',
+            'au': 'X-component of acceleration',
+            'av': 'Y-component of acceleration',
+            'aw': 'Z-component of acceleration',
+            'gid': 'Global particle ID',
+            'pid': 'Processor ID (for parallel)',
+            'tag': 'Particle tag (local/remote/ghost)'
+        }
+        
+        return {
+            "success": True,
+            "default_properties": list(DEFAULT_PROPS),
+            "descriptions": property_descriptions
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# =====================================================
+# SPH Equations Tools - SPH方程工具
+# =====================================================
+
+@mcp.tool(name="list_basic_equations", description="List available basic SPH equations.")
+def list_basic_equations() -> dict:
+    """
+    List available basic SPH equations in PySPH.
+    
+    Returns:
+    - dict: Contains list of equation names with descriptions.
+    """
+    try:
+        equations = {
+            "SummationDensity": {
+                "description": "Compute density using SPH summation: ρ_a = Σ m_b W_ab",
+                "required_properties": ["rho", "m"]
+            },
+            "ContinuityEquation": {
+                "description": "Compute density rate: dρ/dt = Σ m_b v_ab · ∇W_ab",
+                "required_properties": ["arho", "m"]
+            },
+            "BodyForce": {
+                "description": "Add constant body force (e.g., gravity)",
+                "parameters": ["fx", "fy", "fz"],
+                "required_properties": ["au", "av", "aw"]
+            },
+            "IsothermalEOS": {
+                "description": "Isothermal equation of state: p = p0 + c0²(ρ - ρ0)",
+                "parameters": ["rho0", "c0", "p0"],
+                "required_properties": ["p", "rho"]
+            },
+            "MonaghanArtificialViscosity": {
+                "description": "Classical Monaghan artificial viscosity for shock handling",
+                "parameters": ["alpha", "beta"],
+                "required_properties": ["au", "av", "aw", "rho", "cs"]
+            },
+            "VelocityGradient2D": {
+                "description": "Compute velocity gradient tensor in 2D",
+                "required_properties": ["v00", "v01", "v10", "v11"]
+            },
+            "VelocityGradient3D": {
+                "description": "Compute velocity gradient tensor in 3D",
+                "required_properties": ["v00", "v01", "v02", "v10", "v11", "v12", "v20", "v21", "v22"]
+            }
+        }
+        
+        return {
+            "success": True,
+            "equations": equations,
+            "total_count": len(equations)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# =====================================================
+# Integrator Tools - 积分器工具
+# =====================================================
+
+@mcp.tool(name="list_integrators", description="List available integrator types in PySPH.")
+def list_integrators() -> dict:
+    """
+    List available integrator types in PySPH.
+    
+    Returns:
+    - dict: Contains list of integrator types with descriptions.
+    """
+    try:
+        integrators = {
+            "EulerIntegrator": {
+                "description": "Simple first-order Euler integration",
+                "accuracy": "First order",
+                "stages": 1
+            },
+            "PECIntegrator": {
+                "description": "Predict-Evaluate-Correct integrator",
+                "accuracy": "Second order",
+                "stages": 2
+            },
+            "EPECIntegrator": {
+                "description": "Evaluate-Predict-Evaluate-Correct integrator",
+                "accuracy": "Second order",
+                "stages": 3
+            },
+            "TVDRK3Integrator": {
+                "description": "Total Variation Diminishing Runge-Kutta 3rd order",
+                "accuracy": "Third order",
+                "stages": 3
+            },
+            "LeapFrogIntegrator": {
+                "description": "Leap-frog (Verlet) integration scheme",
+                "accuracy": "Second order",
+                "stages": 2
+            }
+        }
+        
+        return {
+            "success": True,
+            "integrators": integrators,
+            "total_count": len(integrators)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
 
+
+# =====================================================
+# Solver Tools - 求解器工具
+# =====================================================
+
+@mcp.tool(name="get_solver_parameters", description="Get description of common solver parameters.")
+def get_solver_parameters() -> dict:
+    """
+    Get description of common solver parameters in PySPH.
+    
     Returns:
-    - dict: A dictionary containing success, result, or error information.
+    - dict: Contains solver parameter descriptions and typical values.
     """
     try:
-        scheme = Scheme(name=scheme_name, **parameters)
-        return {"success": True, "result": f"Scheme '{scheme_name}' created successfully."}
+        parameters = {
+            "dim": {
+                "description": "Dimension of the problem",
+                "type": "int",
+                "values": [1, 2, 3]
+            },
+            "dt": {
+                "description": "Initial/suggested time step",
+                "type": "float",
+                "typical_range": [1e-5, 1e-2]
+            },
+            "tf": {
+                "description": "Final simulation time",
+                "type": "float"
+            },
+            "adaptive_timestep": {
+                "description": "Enable adaptive time stepping",
+                "type": "bool",
+                "default": False
+            },
+            "cfl": {
+                "description": "CFL number for adaptive time stepping",
+                "type": "float",
+                "typical_range": [0.1, 0.5],
+                "default": 0.3
+            },
+            "n_damp": {
+                "description": "Number of initial damping timesteps",
+                "type": "int",
+                "default": 0
+            },
+            "pfreq": {
+                "description": "Output printing frequency (iterations)",
+                "type": "int",
+                "default": 100
+            },
+            "fixed_h": {
+                "description": "Use constant smoothing length",
+                "type": "bool",
+                "default": False
+            }
+        }
+        
+        return {
+            "success": True,
+            "parameters": parameters
+        }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-@mcp.tool(name="initialize_integrator", description="Initialize an integrator using the Integrator class.")
-def initialize_integrator(integrator_type: str, options: dict) -> dict:
+
+# =====================================================
+# Mathematical Utilities - 数学工具
+# =====================================================
+
+@mcp.tool(name="calculate_distance", description="Calculate Euclidean distance between two points.")
+def calculate_distance(point1: List[float], point2: List[float] = None) -> dict:
     """
-    Initialize an integrator with the specified type and options.
+    Calculate Euclidean distance between two points.
+    
+    Parameters:
+    - point1: First point coordinates [x, y] or [x, y, z]
+    - point2: Second point coordinates (default: origin)
+    
+    Returns:
+    - dict: Contains the calculated distance.
+    """
+    try:
+        p1 = np.array(point1)
+        if point2 is None:
+            p2 = np.zeros_like(p1)
+        else:
+            p2 = np.array(point2)
+        
+        dist = geometry.distance(p1, p2) if len(p1) == 3 else geometry.distance_2d(p1[:2], p2[:2])
+        
+        return {
+            "success": True,
+            "point1": point1,
+            "point2": point2 if point2 else [0.0] * len(point1),
+            "distance": float(dist)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
 
+@mcp.tool(name="calculate_triangle_area", description="Calculate area of a triangle given three 3D points.")
+def calculate_triangle_area(point1: List[float], point2: List[float], 
+                            point3: List[float]) -> dict:
+    """
+    Calculate area of a triangle given three 3D points.
+    
     Parameters:
-    - integrator_type (str): Type of the integrator to initialize.
-    - options (dict): Options for the integrator.
+    - point1, point2, point3: Three vertices of the triangle [x, y, z]
+    
+    Returns:
+    - dict: Contains the calculated area.
+    """
+    try:
+        points = np.array([point1, point2, point3])
+        area = geometry.evaluate_area_of_triangle(points)
+        
+        return {
+            "success": True,
+            "vertices": [point1, point2, point3],
+            "area": float(area)
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# =====================================================
+# Information Tools - 信息工具
+# =====================================================
 
+@mcp.tool(name="get_pysph_info", description="Get PySPH library information and capabilities.")
+def get_pysph_info() -> dict:
+    """
+    Get PySPH library information and capabilities.
+    
+    Returns:
+    - dict: Contains library information and main features.
+    """
+    try:
+        return {
+            "success": True,
+            "name": "PySPH",
+            "description": "A framework for Smoothed Particle Hydrodynamics in Python",
+            "main_modules": {
+                "pysph.base": "Core data structures (ParticleArray, NNPS, Kernels)",
+                "pysph.sph": "SPH equations, schemes, and integrators",
+                "pysph.solver": "Solver and application framework",
+                "pysph.tools": "Geometry, interpolation, and post-processing tools",
+                "pysph.parallel": "Parallel computing support with MPI"
+            },
+            "features": [
+                "Multiple SPH formulations (WCSPH, ISPH, IISPH, etc.)",
+                "Flexible equation specification",
+                "Automatic code generation for performance",
+                "GPU acceleration support (OpenCL)",
+                "MPI-based parallel computing",
+                "Various boundary condition implementations"
+            ],
+            "supported_applications": [
+                "Free-surface flows",
+                "Dam break simulations",
+                "Wave dynamics",
+                "Solid mechanics",
+                "Fluid-structure interaction",
+                "Gas dynamics"
+            ]
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+@mcp.tool(name="get_nnps_info", description="Get information about Nearest Neighbor Particle Search (NNPS) methods.")
+def get_nnps_info() -> dict:
+    """
+    Get information about available NNPS (Nearest Neighbor Particle Search) methods.
+    
     Returns:
-    - dict: A dictionary containing success, result, or error information.
+    - dict: Contains NNPS algorithm descriptions.
     """
     try:
-        integrator = Integrator(type=integrator_type, **options)
-        return {"success": True, "result": f"Integrator '{integrator_type}' initialized successfully."}
+        nnps_methods = {
+            "LinkedListNNPS": {
+                "description": "Cell linked list method for neighbor search",
+                "complexity": "O(N)",
+                "best_for": "Uniform particle distributions"
+            },
+            "BoxSortNNPS": {
+                "description": "Box sorting based neighbor search",
+                "complexity": "O(N log N)",
+                "best_for": "General purpose"
+            },
+            "SpatialHashNNPS": {
+                "description": "Spatial hashing based neighbor search",
+                "complexity": "O(N)",
+                "best_for": "Sparse distributions"
+            },
+            "OctreeNNPS": {
+                "description": "Octree-based neighbor search",
+                "complexity": "O(N log N)",
+                "best_for": "Non-uniform distributions"
+            },
+            "StratifiedHashNNPS": {
+                "description": "Stratified hashing for variable-h particles",
+                "complexity": "O(N)",
+                "best_for": "Variable smoothing length"
+            }
+        }
+        
+        return {
+            "success": True,
+            "nnps_methods": nnps_methods,
+            "total_count": len(nnps_methods)
+        }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
+
 def create_app() -> FastMCP:
     """
     Create and return the FastMCP instance for the service.