Update atomman/mcp_output/mcp_plugin/mcp_service.py

atomman/mcp_output/mcp_plugin/mcp_service.py

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