Update openmc/mcp_output/mcp_plugin/mcp_service.py

openmc/mcp_output/mcp_plugin/mcp_service.py

@@ -1,108 +1,635 @@
 import os
 import sys
-
-# 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")
-if source_path not in sys.path:
-    sys.path.insert(0, source_path)
+from typing import List, Optional, Dict, Any
 
 from fastmcp import FastMCP
-from openmc import Model, Geometry, Materials, Tallies, Settings
+
+# Import openmc from PyPI (will be installed via requirements.txt)
+# Note: OpenMC requires compiled C++ libraries
+try:
+    import openmc
+    import openmc.stats
+    OPENMC_AVAILABLE = True
+except ImportError:
+    OPENMC_AVAILABLE = False
 
 # Create the FastMCP service application
 mcp = FastMCP("openmc_service")
 
-@mcp.tool(name="create_model", description="Create a new OpenMC model")
-def create_model() -> dict:
+
+@mcp.tool(name="get_openmc_version", description="Get OpenMC library version and status")
+def get_openmc_version() -> dict:
+    """
+    Get the OpenMC library version and availability status.
+
+    Returns:
+    - dict: Version and status information.
+    """
+    try:
+        if OPENMC_AVAILABLE:
+            return {
+                "success": True,
+                "result": {
+                    "version": openmc.__version__,
+                    "available": True,
+                    "description": "OpenMC is a Monte Carlo particle transport simulation code"
+                },
+                "error": None
+            }
+        else:
+            return {
+                "success": True,
+                "result": {
+                    "available": False,
+                    "message": "OpenMC not installed. Requires compiled C++ libraries.",
+                    "install_note": "pip install openmc (requires HDF5 and other dependencies)"
+                },
+                "error": None
+            }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="create_material", description="Create an OpenMC material with nuclides or elements")
+def create_material(
+    name: str,
+    density: float,
+    density_units: str = "g/cm3",
+    nuclides: Dict[str, float] = None,
+    elements: Dict[str, float] = None,
+    temperature: float = None
+) -> dict:
+    """
+    Create an OpenMC material with specified composition.
+
+    Parameters:
+    - name: Material name
+    - density: Material density value
+    - density_units: Units for density (g/cm3, atom/b-cm, etc.)
+    - nuclides: Dictionary of nuclide names to atom fractions (e.g., {"U235": 0.03, "U238": 0.97})
+    - elements: Dictionary of element names to atom fractions (e.g., {"Fe": 0.70, "Cr": 0.18})
+    - temperature: Temperature in Kelvin (optional)
+
+    Returns:
+    - dict: Material information and XML representation.
+    """
+    if not OPENMC_AVAILABLE:
+        return {"success": False, "result": None, "error": "OpenMC not available"}
+    
+    try:
+        mat = openmc.Material(name=name)
+        mat.set_density(density_units, density)
+        
+        if nuclides:
+            for nuclide, fraction in nuclides.items():
+                mat.add_nuclide(nuclide, fraction)
+        
+        if elements:
+            for element, fraction in elements.items():
+                mat.add_element(element, fraction)
+        
+        if temperature is not None:
+            mat.temperature = temperature
+        
+        # Get XML representation
+        xml_str = mat.to_xml_element().tostring().decode() if hasattr(mat.to_xml_element(), 'tostring') else str(mat)
+        
+        return {
+            "success": True,
+            "result": {
+                "name": name,
+                "id": mat.id,
+                "density": density,
+                "density_units": density_units,
+                "nuclides": list(mat.nuclides) if mat.nuclides else [],
+                "description": f"Material '{name}' created successfully"
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="create_surface", description="Create an OpenMC surface for geometry definition")
+def create_surface(
+    surface_type: str,
+    boundary_type: str = "transmission",
+    **params
+) -> dict:
+    """
+    Create an OpenMC surface.
+
+    Parameters:
+    - surface_type: Type of surface (Sphere, ZCylinder, XPlane, YPlane, ZPlane, etc.)
+    - boundary_type: Boundary condition (transmission, vacuum, reflective, periodic)
+    - params: Surface-specific parameters:
+      - For Sphere: x0, y0, z0, r (radius)
+      - For ZCylinder: x0, y0, r
+      - For XPlane/YPlane/ZPlane: x0/y0/z0
+
+    Returns:
+    - dict: Surface information.
+    """
+    if not OPENMC_AVAILABLE:
+        return {"success": False, "result": None, "error": "OpenMC not available"}
+    
+    try:
+        surface_classes = {
+            "sphere": openmc.Sphere,
+            "zcylinder": openmc.ZCylinder,
+            "xcylinder": openmc.XCylinder,
+            "ycylinder": openmc.YCylinder,
+            "xplane": openmc.XPlane,
+            "yplane": openmc.YPlane,
+            "zplane": openmc.ZPlane,
+            "xcone": openmc.XCone,
+            "ycone": openmc.YCone,
+            "zcone": openmc.ZCone,
+        }
+        
+        surface_type_lower = surface_type.lower()
+        if surface_type_lower not in surface_classes:
+            return {
+                "success": False,
+                "result": None,
+                "error": f"Unknown surface type: {surface_type}. Available: {list(surface_classes.keys())}"
+            }
+        
+        surface_class = surface_classes[surface_type_lower]
+        surface = surface_class(boundary_type=boundary_type, **params)
+        
+        return {
+            "success": True,
+            "result": {
+                "type": surface_type,
+                "id": surface.id,
+                "boundary_type": boundary_type,
+                "parameters": params,
+                "description": f"{surface_type} surface created with ID {surface.id}"
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="create_pincell_model", description="Create a complete fuel pin cell model")
+def create_pincell_model(
+    fuel_radius: float = 0.39,
+    clad_inner_radius: float = 0.40,
+    clad_outer_radius: float = 0.46,
+    pitch: float = 1.26,
+    enrichment: float = 0.03,
+    fuel_density: float = 10.5,
+    batches: int = 100,
+    inactive: int = 10,
+    particles: int = 1000
+) -> dict:
     """
-    Create a new OpenMC model with default settings.
+    Create a complete PWR fuel pin cell model.
+
+    Parameters:
+    - fuel_radius: Fuel pellet outer radius (cm)
+    - clad_inner_radius: Cladding inner radius (cm)
+    - clad_outer_radius: Cladding outer radius (cm)
+    - pitch: Pin pitch (cm)
+    - enrichment: U-235 enrichment (atom fraction, e.g., 0.03 for 3%)
+    - fuel_density: Fuel density (g/cm3)
+    - batches: Number of batches for eigenvalue calculation
+    - inactive: Number of inactive batches
+    - particles: Number of particles per batch
 
     Returns:
-        dict: A dictionary containing the success status and the model object.
+    - dict: Model information and estimated k-effective.
     """
+    if not OPENMC_AVAILABLE:
+        return {"success": False, "result": None, "error": "OpenMC not available"}
+    
     try:
-        model = Model()
-        return {"success": True, "result": model}
+        # Create materials
+        fuel = openmc.Material(name='fuel')
+        fuel.add_nuclide('U235', enrichment)
+        fuel.add_nuclide('U238', 1.0 - enrichment)
+        fuel.add_nuclide('O16', 2.0)
+        fuel.set_density('g/cm3', fuel_density)
+        
+        clad = openmc.Material(name='clad')
+        clad.add_element('Zr', 1.0)
+        clad.set_density('g/cm3', 6.55)
+        
+        water = openmc.Material(name='water')
+        water.add_nuclide('H1', 2.0)
+        water.add_nuclide('O16', 1.0)
+        water.set_density('g/cm3', 1.0)
+        water.add_s_alpha_beta('c_H_in_H2O')
+        
+        materials = openmc.Materials([fuel, clad, water])
+        
+        # Create geometry
+        fuel_or = openmc.ZCylinder(r=fuel_radius)
+        clad_ir = openmc.ZCylinder(r=clad_inner_radius)
+        clad_or = openmc.ZCylinder(r=clad_outer_radius)
+        
+        fuel_cell = openmc.Cell(fill=fuel, region=-fuel_or)
+        gap_cell = openmc.Cell(region=+fuel_or & -clad_ir)  # void gap
+        clad_cell = openmc.Cell(fill=clad, region=+clad_ir & -clad_or)
+        water_cell = openmc.Cell(fill=water, region=+clad_or)
+        
+        universe = openmc.Universe(cells=[fuel_cell, gap_cell, clad_cell, water_cell])
+        
+        # Create rectangular boundary
+        min_x = openmc.XPlane(-pitch/2, boundary_type='reflective')
+        max_x = openmc.XPlane(pitch/2, boundary_type='reflective')
+        min_y = openmc.YPlane(-pitch/2, boundary_type='reflective')
+        max_y = openmc.YPlane(pitch/2, boundary_type='reflective')
+        
+        root_cell = openmc.Cell(fill=universe, region=+min_x & -max_x & +min_y & -max_y)
+        root_universe = openmc.Universe(cells=[root_cell])
+        geometry = openmc.Geometry(root_universe)
+        
+        # Create settings
+        settings = openmc.Settings()
+        settings.batches = batches
+        settings.inactive = inactive
+        settings.particles = particles
+        settings.source = openmc.IndependentSource(
+            space=openmc.stats.Box([-pitch/2, -pitch/2, -1], [pitch/2, pitch/2, 1])
+        )
+        
+        # Create model
+        model = openmc.Model(geometry=geometry, materials=materials, settings=settings)
+        
+        return {
+            "success": True,
+            "result": {
+                "model_type": "PWR pincell",
+                "fuel_radius_cm": fuel_radius,
+                "clad_outer_radius_cm": clad_outer_radius,
+                "pitch_cm": pitch,
+                "enrichment_percent": enrichment * 100,
+                "fuel_density_g_cm3": fuel_density,
+                "batches": batches,
+                "inactive": inactive,
+                "particles": particles,
+                "materials": ["UO2 fuel", "Zircaloy clad", "H2O moderator"],
+                "boundary_conditions": "reflective (infinite lattice approximation)",
+                "note": "Model created. Call model.export_to_model_xml() to save, model.run() to execute."
+            },
+            "error": None
+        }
     except Exception as e:
-        return {"success": False, "error": str(e)}
+        return {"success": False, "result": None, "error": str(e)}
+
 
-@mcp.tool(name="setup_geometry", description="Setup geometry for the OpenMC model")
-def setup_geometry(model: Model) -> dict:
+@mcp.tool(name="create_settings", description="Create OpenMC simulation settings")
+def create_settings(
+    run_mode: str = "eigenvalue",
+    batches: int = 100,
+    inactive: int = 10,
+    particles: int = 1000,
+    source_type: str = "box",
+    source_bounds: List[float] = None
+) -> dict:
     """
-    Setup geometry for the given OpenMC model.
+    Create OpenMC simulation settings.
 
-    Args:
-        model (Model): The OpenMC model to setup geometry for.
+    Parameters:
+    - run_mode: Simulation mode (eigenvalue, fixed source, volume, plot)
+    - batches: Number of batches
+    - inactive: Number of inactive batches (eigenvalue mode)
+    - particles: Number of particles per batch
+    - source_type: Source spatial distribution type (box, point)
+    - source_bounds: Source bounds [x_min, y_min, z_min, x_max, y_max, z_max]
 
     Returns:
-        dict: A dictionary containing the success status and the geometry object.
+    - dict: Settings information.
     """
+    if not OPENMC_AVAILABLE:
+        return {"success": False, "result": None, "error": "OpenMC not available"}
+    
     try:
-        geometry = Geometry()
-        model.geometry = geometry
-        return {"success": True, "result": geometry}
+        settings = openmc.Settings()
+        settings.run_mode = run_mode
+        settings.batches = batches
+        settings.particles = particles
+        
+        if run_mode == 'eigenvalue':
+            settings.inactive = inactive
+        
+        # Set source
+        if source_bounds is None:
+            source_bounds = [-10, -10, -10, 10, 10, 10]
+        
+        if source_type == "box":
+            settings.source = openmc.IndependentSource(
+                space=openmc.stats.Box(source_bounds[:3], source_bounds[3:])
+            )
+        elif source_type == "point":
+            center = [(source_bounds[i] + source_bounds[i+3])/2 for i in range(3)]
+            settings.source = openmc.IndependentSource(
+                space=openmc.stats.Point(center)
+            )
+        
+        return {
+            "success": True,
+            "result": {
+                "run_mode": run_mode,
+                "batches": batches,
+                "inactive": inactive if run_mode == 'eigenvalue' else None,
+                "particles": particles,
+                "source_type": source_type,
+                "source_bounds": source_bounds,
+                "total_histories": batches * particles
+            },
+            "error": None
+        }
     except Exception as e:
-        return {"success": False, "error": str(e)}
+        return {"success": False, "result": None, "error": str(e)}
+
 
-@mcp.tool(name="setup_materials", description="Setup materials for the OpenMC model")
-def setup_materials(model: Model) -> dict:
+@mcp.tool(name="create_tally", description="Create an OpenMC tally for scoring results")
+def create_tally(
+    name: str,
+    scores: List[str],
+    filters_config: Dict[str, Any] = None
+) -> dict:
     """
-    Setup materials for the given OpenMC model.
+    Create an OpenMC tally for scoring simulation results.
 
-    Args:
-        model (Model): The OpenMC model to setup materials for.
+    Parameters:
+    - name: Tally name
+    - scores: List of scores to tally (flux, fission, absorption, heating, etc.)
+    - filters_config: Optional filter configuration:
+      - "energy_bins": List of energy boundaries in eV
+      - "mesh_dims": [nx, ny, nz] for mesh tally
+      - "mesh_lower": [x, y, z] lower left corner
+      - "mesh_upper": [x, y, z] upper right corner
 
     Returns:
-        dict: A dictionary containing the success status and the materials object.
+    - dict: Tally information.
     """
+    if not OPENMC_AVAILABLE:
+        return {"success": False, "result": None, "error": "OpenMC not available"}
+    
     try:
-        materials = Materials()
-        model.materials = materials
-        return {"success": True, "result": materials}
+        tally = openmc.Tally(name=name)
+        tally.scores = scores
+        
+        filters_added = []
+        
+        if filters_config:
+            # Add energy filter
+            if "energy_bins" in filters_config:
+                energy_filter = openmc.EnergyFilter(filters_config["energy_bins"])
+                tally.filters.append(energy_filter)
+                filters_added.append(f"EnergyFilter with {len(filters_config['energy_bins'])-1} groups")
+            
+            # Add mesh filter
+            if "mesh_dims" in filters_config:
+                mesh = openmc.RegularMesh()
+                mesh.dimension = filters_config["mesh_dims"]
+                mesh.lower_left = filters_config.get("mesh_lower", [-10, -10, -10])
+                mesh.upper_right = filters_config.get("mesh_upper", [10, 10, 10])
+                mesh_filter = openmc.MeshFilter(mesh)
+                tally.filters.append(mesh_filter)
+                filters_added.append(f"MeshFilter {filters_config['mesh_dims']}")
+        
+        return {
+            "success": True,
+            "result": {
+                "name": name,
+                "id": tally.id,
+                "scores": scores,
+                "filters": filters_added,
+                "description": f"Tally '{name}' created with scores: {', '.join(scores)}"
+            },
+            "error": None
+        }
     except Exception as e:
-        return {"success": False, "error": str(e)}
+        return {"success": False, "result": None, "error": str(e)}
 
-@mcp.tool(name="setup_tallies", description="Setup tallies for the OpenMC model")
-def setup_tallies(model: Model) -> dict:
+
+@mcp.tool(name="list_available_nuclides", description="List common nuclides available in OpenMC")
+def list_available_nuclides() -> dict:
+    """
+    List common nuclides available for use in OpenMC materials.
+
+    Returns:
+    - dict: Nuclides organized by category.
     """
-    Setup tallies for the given OpenMC model.
+    try:
+        nuclides = {
+            "fuel_nuclides": {
+                "U235": "Fissile uranium-235",
+                "U238": "Fertile uranium-238",
+                "Pu239": "Fissile plutonium-239",
+                "Pu240": "Plutonium-240",
+                "Pu241": "Fissile plutonium-241",
+                "Th232": "Fertile thorium-232",
+                "U233": "Fissile uranium-233"
+            },
+            "oxygen": {
+                "O16": "Oxygen-16 (most abundant)",
+                "O17": "Oxygen-17",
+                "O18": "Oxygen-18"
+            },
+            "moderator_nuclides": {
+                "H1": "Hydrogen-1 (protium)",
+                "H2": "Hydrogen-2 (deuterium)",
+                "C12": "Carbon-12",
+                "Be9": "Beryllium-9"
+            },
+            "structural_elements": {
+                "Zr90": "Zirconium-90",
+                "Zr91": "Zirconium-91",
+                "Zr92": "Zirconium-92",
+                "Fe54": "Iron-54",
+                "Fe56": "Iron-56",
+                "Cr52": "Chromium-52",
+                "Ni58": "Nickel-58"
+            },
+            "absorbers": {
+                "B10": "Boron-10 (absorber)",
+                "B11": "Boron-11",
+                "Gd155": "Gadolinium-155",
+                "Gd157": "Gadolinium-157",
+                "Ag107": "Silver-107",
+                "Ag109": "Silver-109",
+                "In115": "Indium-115",
+                "Cd113": "Cadmium-113"
+            },
+            "fission_products": {
+                "Xe135": "Xenon-135 (strong absorber)",
+                "Sm149": "Samarium-149",
+                "I135": "Iodine-135",
+                "Cs137": "Cesium-137"
+            }
+        }
+        return {"success": True, "result": nuclides, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
 
-    Args:
-        model (Model): The OpenMC model to setup tallies for.
+
+@mcp.tool(name="calculate_enrichment", description="Calculate uranium enrichment parameters")
+def calculate_enrichment(
+    u235_weight_percent: float
+) -> dict:
+    """
+    Calculate uranium enrichment parameters from weight percent.
+
+    Parameters:
+    - u235_weight_percent: U-235 weight percent (e.g., 3.0 for 3%)
 
     Returns:
-        dict: A dictionary containing the success status and the tallies object.
+    - dict: Enrichment parameters including atom fractions.
     """
     try:
-        tallies = Tallies()
-        model.tallies = tallies
-        return {"success": True, "result": tallies}
+        # Atomic masses
+        m_u235 = 235.0439299
+        m_u238 = 238.0507882
+        
+        # Convert weight percent to atom fraction
+        w235 = u235_weight_percent / 100.0
+        w238 = 1.0 - w235
+        
+        # Atom fractions
+        n235 = w235 / m_u235
+        n238 = w238 / m_u238
+        total = n235 + n238
+        
+        a235 = n235 / total  # atom fraction U-235
+        a238 = n238 / total  # atom fraction U-238
+        
+        return {
+            "success": True,
+            "result": {
+                "u235_weight_percent": u235_weight_percent,
+                "u238_weight_percent": 100.0 - u235_weight_percent,
+                "u235_atom_fraction": round(a235, 6),
+                "u238_atom_fraction": round(a238, 6),
+                "enrichment_category": (
+                    "Natural" if u235_weight_percent < 0.72 else
+                    "LEU (Low Enriched)" if u235_weight_percent < 20 else
+                    "HEU (Highly Enriched)"
+                ),
+                "note": "Use atom fractions with add_nuclide() method"
+            },
+            "error": None
+        }
     except Exception as e:
-        return {"success": False, "error": str(e)}
+        return {"success": False, "result": None, "error": str(e)}
+
+
+@mcp.tool(name="get_thermal_scattering_libraries", description="Get thermal scattering law libraries")
+def get_thermal_scattering_libraries() -> dict:
+    """
+    Get available thermal scattering law (S(α,β)) libraries and their usage.
 
-@mcp.tool(name="setup_settings", description="Setup settings for the OpenMC model")
-def setup_settings(model: Model) -> dict:
+    Returns:
+    - dict: Thermal scattering libraries and how to use them.
     """
-    Setup settings for the given OpenMC model.
+    try:
+        libraries = {
+            "water": {
+                "name": "c_H_in_H2O",
+                "description": "Hydrogen bound in light water (H2O)",
+                "usage": "material.add_s_alpha_beta('c_H_in_H2O')",
+                "temperature_range": "293.6K - 800K typically available"
+            },
+            "heavy_water": {
+                "name": "c_D_in_D2O",
+                "description": "Deuterium bound in heavy water (D2O)",
+                "usage": "material.add_s_alpha_beta('c_D_in_D2O')"
+            },
+            "graphite": {
+                "name": "c_Graphite",
+                "description": "Carbon in graphite",
+                "usage": "material.add_s_alpha_beta('c_Graphite')"
+            },
+            "polyethylene": {
+                "name": "c_H_in_CH2",
+                "description": "Hydrogen in polyethylene",
+                "usage": "material.add_s_alpha_beta('c_H_in_CH2')"
+            },
+            "beryllium": {
+                "name": "c_Be",
+                "description": "Beryllium metal",
+                "usage": "material.add_s_alpha_beta('c_Be')"
+            },
+            "beryllium_oxide": {
+                "name": "c_Be_in_BeO",
+                "description": "Beryllium in BeO",
+                "usage": "material.add_s_alpha_beta('c_Be_in_BeO')"
+            },
+            "zirconium_hydride": {
+                "names": ["c_H_in_ZrH", "c_Zr_in_ZrH"],
+                "description": "Hydrogen and Zirconium in ZrH",
+                "usage": "Add both for ZrH materials"
+            },
+            "uranium_hydride": {
+                "name": "c_H_in_UH3",
+                "description": "Hydrogen in uranium hydride",
+                "usage": "material.add_s_alpha_beta('c_H_in_UH3')"
+            },
+            "note": "Thermal scattering is important for accurate moderation at thermal energies"
+        }
+        return {"success": True, "result": libraries, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
 
-    Args:
-        model (Model): The OpenMC model to setup settings for.
+
+@mcp.tool(name="list_tally_scores", description="List all available tally scores")
+def list_tally_scores() -> dict:
+    """
+    List all available tally scores in OpenMC.
 
     Returns:
-        dict: A dictionary containing the success status and the settings object.
+    - dict: Tally scores organized by category.
     """
     try:
-        settings = Settings()
-        model.settings = settings
-        return {"success": True, "result": settings}
+        scores = {
+            "flux_and_current": {
+                "flux": "Scalar flux (track-length estimator)",
+                "current": "Current across a surface (requires SurfaceFilter)"
+            },
+            "reaction_rates": {
+                "total": "Total reaction rate",
+                "absorption": "Absorption reaction rate",
+                "scatter": "Scattering reaction rate",
+                "fission": "Fission reaction rate",
+                "nu-fission": "Fission neutron production rate (ν × fission)",
+                "prompt-nu-fission": "Prompt fission neutron production",
+                "delayed-nu-fission": "Delayed fission neutron production",
+                "kappa-fission": "Energy release from fission",
+                "(n,2n)": "(n,2n) reaction rate",
+                "(n,3n)": "(n,3n) reaction rate",
+                "(n,gamma)": "Radiative capture rate",
+                "(n,p)": "(n,p) reaction rate",
+                "(n,a)": "(n,alpha) reaction rate"
+            },
+            "energy_deposition": {
+                "heating": "Total energy deposition (MeV/source)",
+                "heating-local": "Local energy deposition",
+                "damage-energy": "Damage energy production (for DPA calculations)"
+            },
+            "other": {
+                "events": "Number of scoring events",
+                "inverse-velocity": "1/v for kinetics calculations",
+                "fission-q-prompt": "Prompt fission Q-value",
+                "fission-q-recoverable": "Recoverable fission Q-value"
+            },
+            "usage_note": "Scores can be combined in a single tally: tally.scores = ['flux', 'fission', 'heating']"
+        }
+        return {"success": True, "result": scores, "error": None}
     except Exception as e:
-        return {"success": False, "error": str(e)}
+        return {"success": False, "result": None, "error": str(e)}
+
 
 def create_app() -> FastMCP:
     """
     Create and return the FastMCP application instance.
 
     Returns:
-        FastMCP: The FastMCP application instance.
+    - FastMCP: The FastMCP application instance.
     """
-    return mcp
+    return mcp