pyResToolbox MCP Server

"""Reservoir heterogeneity analysis example.

This example demonstrates Lorenz coefficient calculations and
layer property generation for reservoir simulation.
"""

import asyncio
from fastmcp.client import Client
from pyrestoolbox_mcp import mcp


async def heterogeneity_analysis():
    """Reservoir heterogeneity analysis workflow."""

    # Client context

    async with Client(mcp) as client:
        print("=" * 80)
        print("Reservoir Heterogeneity Analysis")
        print("=" * 80)

        # Example 1: Convert Lorenz to Beta
        print("\nExample 1: Lorenz Coefficient to Beta Conversion")
        print("-" * 80)
        lorenz_values = [0.2, 0.4, 0.6, 0.8]

        print(f"{'Lorenz Coeff':>15} | {'Beta':>10} | {'Interpretation':>20}")
        print("-" * 50)
        for lc in lorenz_values:
            beta_result = await client.call_tool(
                "lorenz_to_beta",
                {"value": lc},
            )
            beta = beta_result["beta"]
            if lc < 0.3:
                interp = "Homogeneous"
            elif lc < 0.6:
                interp = "Moderate"
            else:
                interp = "Heterogeneous"
            print(f"{lc:15.3f} | {beta:10.4f} | {interp:>20}")

        # Example 2: Convert Beta to Lorenz
        print("\nExample 2: Beta to Lorenz Coefficient Conversion")
        print("-" * 80)
        beta_values = [0.3, 0.5, 0.7, 0.9]

        print(f"{'Beta':>10} | {'Lorenz Coeff':>15} | {'Interpretation':>20}")
        print("-" * 50)
        for beta_val in beta_values:
            lorenz_result = await client.call_tool(
                "beta_to_lorenz",
                {"value": beta_val},
            )
            lc = lorenz_result["lorenz_coefficient"]
            if lc < 0.3:
                interp = "Homogeneous"
            elif lc < 0.6:
                interp = "Moderate"
            else:
                interp = "Heterogeneous"
            print(f"{beta_val:10.3f} | {lc:15.4f} | {interp:>20}")

        # Example 3: Calculate Lorenz from flow fractions
        print("\nExample 3: Lorenz from Production Data")
        print("-" * 80)
        # Simulated PLT data: flow fractions and kh fractions for 5 layers
        flow_fracs = [0.45, 0.25, 0.15, 0.10, 0.05]  # Flow allocation
        perm_fracs = [0.30, 0.25, 0.20, 0.15, 0.10]  # kh allocation

        lorenz_from_data = await client.call_tool(
            "lorenz_from_flow_fractions",
            {
                "flow_frac": flow_fracs,
                "perm_frac": perm_fracs,
            },
        )

        print(f"Number of Layers: {lorenz_from_data['number_of_layers']}")
        print(f"Lorenz Coefficient: {lorenz_from_data['lorenz_coefficient']:.4f}")
        print(f"Interpretation: {lorenz_from_data['interpretation']}")

        print("\nLayer-by-Layer Analysis:")
        print(f"{'Layer':>8} | {'Flow %':>10} | {'kh %':>10} | {'Ratio':>10}")
        print("-" * 45)
        for i, (ff, pf) in enumerate(zip(flow_fracs, perm_fracs)):
            ratio = ff / pf if pf > 0 else 0
            print(f"{i+1:8d} | {ff*100:10.2f} | {pf*100:10.2f} | {ratio:10.2f}")

        # Example 4: Generate layer distribution
        print("\nExample 4: Generate Layer Permeability Distribution")
        print("-" * 80)
        lorenz_target = 0.6
        n_layers = 10
        total_h = 100.0  # Total thickness (ft)
        avg_k = 150.0  # Average permeability (mD)

        layer_dist = await client.call_tool(
            "generate_layer_distribution",
            {
                "lorenz": lorenz_target,
                "nlay": n_layers,
                "h": total_h,
                "k_avg": avg_k,
            },
        )

        print(f"Target Lorenz Coefficient: {lorenz_target:.2f}")
        print(f"Number of Layers: {n_layers}")
        print(f"Total Thickness: {total_h:.1f} ft")
        print(f"Average Permeability: {avg_k:.1f} mD")

        print(f"\n{'Layer':>8} | {'h (ft)':>10} | {'k (mD)':>10} | {'h_frac':>10} | {'kh_frac':>10}")
        print("-" * 55)
        for layer in layer_dist["layers"]:
            print(
                f"{layer['layer']:8d} | {layer['thickness_ft']:10.2f} | "
                f"{layer['permeability_md']:10.2f} | {layer['thickness_fraction']:10.4f} | "
                f"{layer['kh_fraction']:10.4f}"
            )

        stats = layer_dist["statistics"]
        print("\nPermeability Statistics:")
        print(f"  Minimum: {stats['k_min_md']:.2f} mD")
        print(f"  Maximum: {stats['k_max_md']:.2f} mD")
        print(f"  Average: {stats['k_avg_md']:.2f} mD")
        print(f"  Median: {stats['k_median_md']:.2f} mD")
        print(f"  Std Dev: {stats['k_std_md']:.2f} mD")
        print(f"  Heterogeneity Ratio: {stats['heterogeneity_ratio']:.2f}")

        # Example 5: Flow fractions from Lorenz
        print("\nExample 5: Flow Fractions from Lorenz Coefficient")
        print("-" * 80)
        flow_profile = await client.call_tool(
            "flow_fractions_from_lorenz",
            {"value": lorenz_target},
        )

        print(f"Lorenz Coefficient: {lorenz_target:.2f}")
        print(f"\nLorenz Curve Data (first 10 points):")
        print(f"{'Cum Flow':>12} | {'Cum Storage':>15}")
        print("-" * 30)
        flow_cap = flow_profile["cumulative_flow_capacity"]
        storage_cap = flow_profile["cumulative_storage_capacity"]
        for i in range(min(10, len(flow_cap))):
            print(f"{flow_cap[i]:12.4f} | {storage_cap[i]:15.4f}")

        # Example 6: Compare different heterogeneity levels
        print("\nExample 6: Compare Different Heterogeneity Levels")
        print("-" * 80)
        lorenz_levels = [0.2, 0.4, 0.6, 0.8]

        print(f"\n{'Lorenz':>10} | {'k_min (mD)':>15} | {'k_max (mD)':>15} | {'Ratio':>10}")
        print("-" * 55)
        for lc in lorenz_levels:
            dist = await client.call_tool(
                "generate_layer_distribution",
                {
                    "lorenz": lc,
                    "nlay": 10,
                    "h": 100.0,
                    "k_avg": 150.0,
                },
            )
            stats = dist["statistics"]
            print(
                f"{lc:10.2f} | {stats['k_min_md']:15.2f} | {stats['k_max_md']:15.2f} | "
                f"{stats['heterogeneity_ratio']:10.2f}"
            )

        print("\n" + "=" * 80)
        print("Reservoir Heterogeneity Analysis completed successfully!")
        print("=" * 80)


if __name__ == "__main__":
    asyncio.run(heterogeneity_analysis())