Update atomman/mcp_output/mcp_plugin/mcp_service.py

atomman/mcp_output/mcp_plugin/mcp_service.py

@@ -1,261 +1,124 @@
 from fastmcp import FastMCP
-import numpy as np
 
 # Create the FastMCP service application
 mcp = FastMCP("atomman_service")
 
-
-@mcp.tool(name="create_atoms", description="Create an Atoms object and return its properties")
-def create_atoms(positions: list, symbols: list) -> dict:
-    """
-    Create an Atoms object.
-
-    Parameters:
-    - positions: List of atomic positions, e.g. [[0,0,0], [0.5,0.5,0.5]].
-    - symbols: List of atomic symbols, e.g. ['Fe', 'Fe'].
-
-    Returns:
-    - Dictionary with success status and atoms information.
-    """
-    try:
-        from atomman.core import Atoms
-        atoms = Atoms(positions=positions, symbols=symbols)
-        return {
-            "success": True,
-            "natoms": atoms.natoms,
-            "symbols": list(atoms.symbols),
-            "positions": atoms.pos.tolist()
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool(name="create_box", description="Create a simulation box")
-def create_box(vects: list) -> dict:
-    """
-    Create a Box object.
-
-    Parameters:
-    - vects: 3x3 list of box vectors, e.g. [[10,0,0], [0,10,0], [0,0,10]].
-
-    Returns:
-    - Dictionary with success status and box information.
+@mcp.tool(name="list_lattice_parameters", description="List lattice parameters of a crystal structure")
+def list_lattice_parameters(lattice: dict) -> dict:
     """
-    try:
-        from atomman.core import Box
-        box = Box(vects=vects)
-        return {
-            "success": True,
-            "vects": box.vects.tolist(),
-            "a": float(box.a),
-            "b": float(box.b),
-            "c": float(box.c),
-            "alpha": float(box.alpha),
-            "beta": float(box.beta),
-            "gamma": float(box.gamma),
-            "volume": float(box.volume)
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool(name="calculate_elastic_constants", description="Calculate elastic constants from Cij matrix")
-def calculate_elastic_constants(Cij: list) -> dict:
-    """
-    Calculate elastic constants.
+    List the lattice parameters of a given crystal structure.
 
     Parameters:
-    - Cij: 6x6 elastic stiffness matrix in Voigt notation (GPa).
+    - lattice: A dictionary containing lattice vectors and angles.
 
     Returns:
-    - Dictionary with success status and elastic properties.
+    - dict: Lattice parameters including a, b, c, alpha, beta, gamma.
     """
     try:
-        from atomman.core import ElasticConstants
-        elastic = ElasticConstants(Cij=np.array(Cij))
-        return {
-            "success": True,
-            "Cij": elastic.Cij.tolist(),
-            "Sij": elastic.Sij.tolist(),
-            "bulk_modulus": float(elastic.bulk()),
-            "shear_modulus": float(elastic.shear())
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool(name="create_system", description="Create an atomic system with atoms and box")
-def create_system(positions: list, symbols: list, box_vects: list) -> dict:
-    """
-    Create a System object combining atoms and box.
-
-    Parameters:
-    - positions: List of atomic positions, e.g. [[0,0,0], [0.5,0.5,0.5]].
-    - symbols: List of atomic symbols, e.g. ['Fe', 'Fe'].
-    - box_vects: 3x3 list of box vectors, e.g. [[10,0,0], [0,10,0], [0,0,10]].
-
-    Returns:
-    - Dictionary with success status and system information.
-    """
-    try:
-        from atomman.core import Atoms, Box, System
-        atoms = Atoms(positions=positions, symbols=symbols)
-        box = Box(vects=box_vects)
-        system = System(atoms=atoms, box=box)
+        from atomman.lattice import Lattice
+        
+        lattice_obj = Lattice(**lattice)
+        params = lattice_obj.parameters()
+        
         return {
             "success": True,
-            "natoms": system.natoms,
-            "symbols": list(system.symbols),
-            "box_volume": float(system.box.volume),
-            "density": float(system.natoms / system.box.volume)
+            "parameters": params
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-
-@mcp.tool(name="calculate_miller_indices", description="Convert vectors to Miller indices")
-def calculate_miller_indices(vectors: list) -> dict:
+@mcp.tool(name="calculate_displacement", description="Calculate atomic displacements in a system")
+def calculate_displacement(system: dict, displacements: list) -> dict:
     """
-    Calculate Miller indices from crystallographic vectors.
+    Calculate atomic displacements in a system.
 
     Parameters:
-    - vectors: List of vectors to convert, e.g. [[1,1,0], [1,1,1]].
+    - system: A dictionary representing the atomic system.
+    - displacements: A list of displacement vectors.
 
     Returns:
-    - Dictionary with success status and Miller indices.
+    - dict: Updated atomic positions after applying displacements.
     """
     try:
-        from atomman.tools import miller
-        indices = miller.vector_crystal_to_cartesian(np.array(vectors))
+        from atomman import System
+        
+        system_obj = System(**system)
+        system_obj.displace(displacements)
+        
         return {
             "success": True,
-            "miller_indices": indices.tolist() if hasattr(indices, 'tolist') else list(indices)
+            "updated_positions": system_obj.atoms.pos
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-
-@mcp.tool(name="calculate_vector_angle", description="Calculate angle between two vectors")
-def calculate_vector_angle(vector1: list, vector2: list) -> dict:
+@mcp.tool(name="compute_elastic_constants", description="Compute elastic constants of a material")
+def compute_elastic_constants(system: dict, strain: dict) -> dict:
     """
-    Calculate angle between two vectors.
+    Compute the elastic constants of a material.
 
     Parameters:
-    - vector1: First vector, e.g. [1, 0, 0].
-    - vector2: Second vector, e.g. [0, 1, 0].
+    - system: A dictionary representing the atomic system.
+    - strain: A dictionary representing the strain tensor.
 
     Returns:
-    - Dictionary with success status and angle in degrees.
+    - dict: Elastic constants of the material.
     """
     try:
-        from atomman.tools import vect_angle
-        angle = vect_angle(vector1, vector2)
+        from atomman import ElasticConstants
+        
+        elastic_constants = ElasticConstants(**strain)
+        
         return {
             "success": True,
-            "angle_degrees": float(angle)
+            "elastic_constants": elastic_constants.C
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-
-@mcp.tool(name="load_lammps_dump", description="Load atomic structure from LAMMPS dump file content")
-def load_lammps_dump(dump_content: str) -> dict:
+@mcp.tool(name="generate_crystal_structure", description="Generate a crystal structure from lattice and basis")
+def generate_crystal_structure(lattice: dict, basis: list) -> dict:
     """
-    Parse LAMMPS dump file content.
+    Generate a crystal structure from lattice parameters and basis atoms.
 
     Parameters:
-    - dump_content: String content of a LAMMPS dump file.
+    - lattice: A dictionary containing lattice vectors and angles.
+    - basis: A list of basis atoms with positions.
 
     Returns:
-    - Dictionary with success status and structure information.
+    - dict: Generated crystal structure.
     """
     try:
-        import atomman as am
-        import tempfile
-        import os
-        
-        # Write content to temp file
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.dump', delete=False) as f:
-            f.write(dump_content)
-            temp_path = f.name
+        from atomman import System
         
-        try:
-            system = am.load('atom_dump', temp_path)
-            result = {
-                "success": True,
-                "natoms": system.natoms,
-                "box_volume": float(system.box.volume)
-            }
-        finally:
-            os.unlink(temp_path)
-        
-        return result
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-@mcp.tool(name="rotate_system", description="Rotate an atomic system")
-def rotate_system(positions: list, symbols: list, box_vects: list, rotation_matrix: list) -> dict:
-    """
-    Rotate an atomic system by a rotation matrix.
-
-    Parameters:
-    - positions: List of atomic positions.
-    - symbols: List of atomic symbols.
-    - box_vects: 3x3 list of box vectors.
-    - rotation_matrix: 3x3 rotation matrix.
-
-    Returns:
-    - Dictionary with rotated system information.
-    """
-    try:
-        from atomman.core import Atoms, Box, System
-        atoms = Atoms(positions=positions, symbols=symbols)
-        box = Box(vects=box_vects)
-        system = System(atoms=atoms, box=box)
+        system = System(lattice=lattice, atoms=basis)
         
-        rotated = system.rotate(np.array(rotation_matrix))
         return {
             "success": True,
-            "natoms": rotated.natoms,
-            "positions": rotated.atoms.pos.tolist(),
-            "box_vects": rotated.box.vects.tolist()
+            "system": system.dump('json')
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
 
-
-@mcp.tool(name="calculate_neighbor_list", description="Calculate neighbor list for atoms")
-def calculate_neighbor_list(positions: list, symbols: list, box_vects: list, cutoff: float) -> dict:
+@mcp.tool(name="analyze_vacancies", description="Analyze vacancies in a crystal structure")
+def analyze_vacancies(system: dict) -> dict:
     """
-    Calculate neighbor list for an atomic system.
+    Analyze vacancies in a crystal structure.
 
     Parameters:
-    - positions: List of atomic positions.
-    - symbols: List of atomic symbols.
-    - box_vects: 3x3 list of box vectors.
-    - cutoff: Cutoff distance for neighbors.
+    - system: A dictionary representing the atomic system.
 
     Returns:
-    - Dictionary with neighbor information.
+    - dict: Information about vacancies in the structure.
     """
     try:
-        from atomman.core import Atoms, Box, System
-        atoms = Atoms(positions=positions, symbols=symbols)
-        box = Box(vects=box_vects)
-        system = System(atoms=atoms, box=box)
-        
-        neighbors = system.neighborlist(cutoff=cutoff)
+        from atomman.defect import Vacancy
         
-        # Get coordination numbers
-        coord_numbers = [len(neighbors[i]) for i in range(system.natoms)]
+        vacancy = Vacancy(system)
         
         return {
             "success": True,
-            "natoms": system.natoms,
-            "cutoff": cutoff,
-            "coordination_numbers": coord_numbers,
-            "average_coordination": float(np.mean(coord_numbers))
+            "vacancies": vacancy.vacancies
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
@@ -265,6 +128,6 @@ def create_app() -> FastMCP:
     Create and return the FastMCP application instance.
 
     Returns:
-    - FastMCP instance.
+    - FastMCP: The FastMCP application instance.
     """
     return mcp