#!/usr/bin/env python3
"""
概要:
    2次元非調和格子のNVT分子動力学とメトロポリスモンテカルロ法を比較します。

詳細説明:
    L x Lの正方格子の各サイトはスカラー変位 u[i,j] を持ちます。
    周期境界条件を使用し、換算単位系 (m=k_B=1) におけるポテンシャルは
    V = K0/2 sum_i u_i^2 + sum_ij (K2/2 (u_i-u_j)^2 + K4/4 (u_i-u_j)^4)
    で表されます。
    K4=0 の場合は調和格子となり、基準振動モードは散乱しません。
    K4>0 の場合は基準振動モードが結合し、本質的な非調和散乱が生じます。
    弱いオンサイト項 K0 は、並進ゼロモードによる変位MSDの発散を防ぎます。
    MDはLangevin (BAOAB) サーモスタットを使用し、MCは同じカノニカル座標分布から
    サンプリングを行います。MCの運動量が有効な場合、それらは独立したマクスウェル
    分布からの抽出であり、力学的軌道ではありません。
"""

from __future__ import annotations

import argparse
from dataclasses import dataclass

import matplotlib.pyplot as plt
import numpy as np


@dataclass
class Samples:
    """
    概要:
        シミュレーションのサンプリング結果を保持するデータクラスです。

    詳細説明:
        時間やエネルギー、変位の統計量、およびスナップショットを格納します。

    引数:
        :param time: サンプリングされた時間の配列
        :type time: numpy.ndarray
        :param potential: ポテンシャルエネルギーの配列
        :type potential: numpy.ndarray
        :param kinetic: 運動エネルギーの配列
        :type kinetic: numpy.ndarray
        :param msd: 平均二乗変位の配列
        :type msd: numpy.ndarray
        :param v2: 速度の二乗平均の配列
        :type v2: numpy.ndarray
        :param u_snapshots: 変位のスナップショット配列
        :type u_snapshots: numpy.ndarray
    """
    time: np.ndarray
    potential: np.ndarray
    kinetic: np.ndarray
    msd: np.ndarray
    v2: np.ndarray
    u_snapshots: np.ndarray


def bond_energy(delta: np.ndarray | float, k2: float, k4: float) -> np.ndarray | float:
    """
    概要:
        隣接サイト間のボンドエネルギーを計算します。

    引数:
        :param delta: 変位の差
        :type delta: numpy.ndarray | float
        :param k2: 調和ボンド係数
        :type k2: float
        :param k4: 4次の非調和ボンド係数
        :type k4: float

    戻り値:
        :returns: ボンドエネルギーの計算結果
        :rtype: numpy.ndarray | float
    """
    return 0.5 * k2 * delta**2 + 0.25 * k4 * delta**4


def potential_energy(u: np.ndarray, k0: float, k2: float, k4: float) -> float:
    """
    概要:
        格子全体のポテンシャルエネルギーを計算します。

    詳細説明:
        各 +x 方向および +y 方向のボンドについてエネルギーを一度ずつカウントします。

    引数:
        :param u: 格子の変位配列
        :type u: numpy.ndarray
        :param k0: オンサイト調和ポテンシャル係数
        :type k0: float
        :param k2: 調和ボンド係数
        :type k2: float
        :param k4: 4次の非調和ボンド係数
        :type k4: float

    戻り値:
        :returns: 計算された全ポテンシャルエネルギー
        :rtype: float
    """
    dx = np.roll(u, -1, axis=0) - u
    dy = np.roll(u, -1, axis=1) - u
    return float(0.5 * k0 * np.sum(u**2)
                 + np.sum(bond_energy(dx, k2, k4))
                 + np.sum(bond_energy(dy, k2, k4)))


def force(u: np.ndarray, k0: float, k2: float, k4: float) -> np.ndarray:
    """
    概要:
        周期境界条件を持つ格子のポテンシャルの負の勾配を計算して力を返します。

    引数:
        :param u: 格子の変位配列
        :type u: numpy.ndarray
        :param k0: オンサイト調和ポテンシャル係数
        :type k0: float
        :param k2: 調和ボンド係数
        :type k2: float
        :param k4: 4次の非調和ボンド係数
        :type k4: float

    戻り値:
        :returns: 各サイトに働く力の配列
        :rtype: numpy.ndarray
    """
    f = -k0 * u
    for axis in (0, 1):
        forward = np.roll(u, -1, axis=axis) - u
        backward = u - np.roll(u, 1, axis=axis)
        f += k2 * forward + k4 * forward**3
        f -= k2 * backward + k4 * backward**3
    return f


def langevin_baoab_step(u: np.ndarray, v: np.ndarray, dt: float, gamma: float,
                        temperature: float, k0: float, k2: float, k4: float,
                        rng: np.random.Generator) -> tuple[np.ndarray, np.ndarray]:
    """
    概要:
        単位質量および k_B = 1 の条件でBAOAB法による1ステップの更新を行います。

    引数:
        :param u: 現在の変位配列
        :type u: numpy.ndarray
        :param v: 現在の速度配列
        :type v: numpy.ndarray
        :param dt: タイムステップ
        :type dt: float
        :param gamma: ランジュバン摩擦係数
        :type gamma: float
        :param temperature: 設定温度
        :type temperature: float
        :param k0: オンサイト調和ポテンシャル係数
        :type k0: float
        :param k2: 調和ボンド係数
        :type k2: float
        :param k4: 4次の非調和ボンド係数
        :type k4: float
        :param rng: 乱数生成器
        :type rng: numpy.random.Generator

    戻り値:
        :returns: 更新後の変位配列と速度配列のタプル
        :rtype: tuple[numpy.ndarray, numpy.ndarray]
    """
    v = v + 0.5 * dt * force(u, k0, k2, k4)
    u = u + 0.5 * dt * v
    damping = np.exp(-gamma * dt)
    v = damping * v + np.sqrt((1.0 - damping**2) * temperature) * rng.normal(size=v.shape)
    u = u + 0.5 * dt * v
    v = v + 0.5 * dt * force(u, k0, k2, k4)
    return u, v


def run_md(args: argparse.Namespace, rng: np.random.Generator) -> Samples:
    """
    概要:
        分子動力学法によるシミュレーションを実行します。

    詳細説明:
        バーンイン期間の後に一定の間隔でサンプリングを行い、サンプリング結果を返します。

    引数:
        :param args: コマンドライン引数を格納したオブジェクト
        :type args: argparse.Namespace
        :param rng: 乱数生成器
        :type rng: numpy.random.Generator

    戻り値:
        :returns: サンプリング結果を格納したSamplesオブジェクト
        :rtype: Samples

    例外:
        :raises ValueError: サンプルが生成されなかった場合に送出されます。
    """
    shape = (args.L, args.L)
    u = np.zeros(shape)
    v = rng.normal(scale=np.sqrt(args.temperature), size=shape)
    records: list[tuple[float, float, float, float, float, np.ndarray]] = []

    for step in range(args.md_steps):
        u, v = langevin_baoab_step(u, v, args.dt, args.gamma, args.temperature,
                                    args.k0, args.k2, args.k4, rng)
        if step >= args.md_burn and (step - args.md_burn) % args.sample_stride == 0:
            potential = potential_energy(u, args.k0, args.k2, args.k4)
            kinetic = 0.5 * float(np.sum(v**2))
            records.append((step * args.dt, potential, kinetic, float(np.mean(u**2)),
                            float(np.mean(v**2)), u.copy()))

    if not records:
        raise ValueError("MD produced no samples; reduce --md-burn or increase --md-steps")
    array = np.asarray([(row[0], row[1], row[2], row[3], row[4]) for row in records])
    return Samples(array[:, 0], array[:, 1], array[:, 2], array[:, 3], array[:, 4],
                   np.asarray([row[5] for row in records]))


def metropolis_sweep(u: np.ndarray, temperature: float, proposal: float,
                     k0: float, k2: float, k4: float,
                     rng: np.random.Generator) -> tuple[int, int]:
    """
    概要:
        局所的な変位提案によるメトロポリス更新を1スイープ実行します。

    詳細説明:
        サイトごとにランダムに変位を提案し、エネルギー変化に基づいて受容判定を行います。

    引数:
        :param u: 格子の変位配列
        :type u: numpy.ndarray
        :param temperature: 設定温度
        :type temperature: float
        :param proposal: 一様分布による提案変位の半値幅
        :type proposal: float
        :param k0: オンサイト調和ポテンシャル係数
        :type k0: float
        :param k2: 調和ボンド係数
        :type k2: float
        :param k4: 4次の非調和ボンド係数
        :type k4: float
        :param rng: 乱数生成器
        :type rng: numpy.random.Generator

    戻り値:
        :returns: 受容された提案回数と試行回数のタプル
        :rtype: tuple[int, int]
    """
    L = u.shape[0]
    accepted = 0
    attempted = L * L
    for _ in range(attempted):
        i = int(rng.integers(L))
        j = int(rng.integers(L))
        old = u[i, j]
        new = old + rng.uniform(-proposal, proposal)
        neighbors = (u[(i - 1) % L, j], u[(i + 1) % L, j],
                     u[i, (j - 1) % L], u[i, (j + 1) % L])
        delta_e = 0.5 * k0 * (new**2 - old**2)
        for neighbor in neighbors:
            delta_e += bond_energy(new - neighbor, k2, k4) - bond_energy(old - neighbor, k2, k4)
        if delta_e <= 0.0 or rng.random() < np.exp(-delta_e / temperature):
            u[i, j] = new
            accepted += 1
    return accepted, attempted


def run_mc(args: argparse.Namespace, rng: np.random.Generator) -> tuple[Samples, float]:
    """
    概要:
        モンテカルロ法によるシミュレーションを実行します。

    詳細説明:
        バーンイン期間の後に一定の間隔でサンプリングを行い、サンプリング結果と受容確率を返します。

    引数:
        :param args: コマンドライン引数を格納したオブジェクト
        :type args: argparse.Namespace
        :param rng: 乱数生成器
        :type rng: numpy.random.Generator

    戻り値:
        :returns: サンプリング結果のSamplesオブジェクトと受容確率のタプル
        :rtype: tuple[Samples, float]

    例外:
        :raises ValueError: サンプルが生成されなかった場合に送出されます。
    """
    shape = (args.L, args.L)
    u = np.zeros(shape)
    records: list[tuple[float, float, float, float, float, np.ndarray]] = []
    accepted_total = attempted_total = 0

    for sweep in range(args.mc_sweeps):
        accepted, attempted = metropolis_sweep(u, args.temperature, args.proposal,
                                               args.k0, args.k2, args.k4, rng)
        if sweep >= args.mc_burn:
            accepted_total += accepted
            attempted_total += attempted
        if sweep >= args.mc_burn and (sweep - args.mc_burn) % args.sample_stride == 0:
            potential = potential_energy(u, args.k0, args.k2, args.k4)
            if args.mc_momenta:
                v = rng.normal(scale=np.sqrt(args.temperature), size=shape)
                kinetic = 0.5 * float(np.sum(v**2))
                v2 = float(np.mean(v**2))
            else:
                kinetic = 0.5 * u.size * args.temperature  # equipartition expectation
                v2 = args.temperature
            records.append((float(sweep), potential, kinetic, float(np.mean(u**2)), v2, u.copy()))

    if not records:
        raise ValueError("MC produced no samples; reduce --mc-burn or increase --mc-sweeps")
    array = np.asarray([(row[0], row[1], row[2], row[3], row[4]) for row in records])
    samples = Samples(array[:, 0], array[:, 1], array[:, 2], array[:, 3], array[:, 4],
                      np.asarray([row[5] for row in records]))
    acceptance = accepted_total / max(attempted_total, 1)
    return samples, acceptance


def mean_and_error(values: np.ndarray) -> tuple[float, float]:
    """
    概要:
        配列の平均値と標準誤差を計算します。

    詳細説明:
        時間相関を取り除くような処理は意図的に行っていません。

    引数:
        :param values: 計算対象の数値配列
        :type values: numpy.ndarray

    戻り値:
        :returns: 平均値と標準誤差のタプル
        :rtype: tuple[float, float]
    """
    mean = float(np.mean(values))
    error = float(np.std(values, ddof=1) / np.sqrt(len(values))) if len(values) > 1 else 0.0
    return mean, error


def running_mean(values: np.ndarray) -> np.ndarray:
    """
    概要:
        配列の累積平均を計算します。

    引数:
        :param values: 計算対象の数値配列
        :type values: numpy.ndarray

    戻り値:
        :returns: 累積平均の配列
        :rtype: numpy.ndarray
    """
    return np.cumsum(values) / np.arange(1, len(values) + 1)


def print_summary(md: Samples, mc: Samples, acceptance: float, args: argparse.Namespace) -> None:
    """
    概要:
        MDとMCのシミュレーション結果を比較してコンソールに出力します。

    引数:
        :param md: MDシミュレーションのサンプリング結果
        :type md: Samples
        :param mc: MCシミュレーションのサンプリング結果
        :type mc: Samples
        :param acceptance: MCシミュレーションの受容確率
        :type acceptance: float
        :param args: コマンドライン引数を格納したオブジェクト
        :type args: argparse.Namespace

    戻り値:
        :returns: なし
        :rtype: None
    """
    dof = args.L * args.L
    print("\n=== 2D anharmonic lattice: NVT MD versus Metropolis MC ===")
    print(f"L={args.L}, sites={dof}, T={args.temperature:g}, K0={args.k0:g}, "
          f"K2={args.k2:g}, K4={args.k4:g}")
    print("K4=0: harmonic normal modes; K4>0: anharmonic mode coupling.")
    print(f"MC acceptance after burn-in: {acceptance:.3f}")
    print(f"Equipartition reference: <K> = {0.5 * dof * args.temperature:.6g}, "
          f"<v^2> = {args.temperature:.6g}\n")
    print(f"{'observable':<16s} {'MD mean +/- SE':>24s} {'MC mean +/- SE':>24s}")
    print("-" * 68)
    for label, md_values, mc_values in (
            ("potential U", md.potential, mc.potential),
            ("kinetic K", md.kinetic, mc.kinetic),
            ("MSD <u^2>", md.msd, mc.msd),
            ("mean v^2", md.v2, mc.v2)):
        md_mean, md_error = mean_and_error(md_values)
        mc_mean, mc_error = mean_and_error(mc_values)
        print(f"{label:<16s} {md_mean:11.6f} +/- {md_error:9.2e} "
              f"{mc_mean:11.6f} +/- {mc_error:9.2e}")
    print("\nNote: MC velocities are independent Maxwell draws, not MC dynamics.")
    print("      Standard errors are naive; correlated samples need block analysis for precision work.")


def plot_results(md: Samples, mc: Samples, args: argparse.Namespace) -> plt.Figure:
    """
    概要:
        シミュレーション結果の各種グラフを描画します。

    詳細説明:
        エネルギー推移、ポテンシャルエネルギーの収束、平均二乗変位の収束、
        変位分布のヒストグラムをプロットします。

    引数:
        :param md: MDシミュレーションのサンプリング結果
        :type md: Samples
        :param mc: MCシミュレーションのサンプリング結果
        :type mc: Samples
        :param args: コマンドライン引数を格納したオブジェクト
        :type args: argparse.Namespace

    戻り値:
        :returns: 生成されたmatplotlibのFigureオブジェクト
        :rtype: matplotlib.pyplot.Figure
    """
    fig, axes = plt.subplots(2, 2, figsize=(12.5, 8.5))
    ax_energy, ax_potential, ax_msd, ax_hist = axes.flat

    ax_energy.plot(md.time, md.potential, label="MD potential U", lw=1.0)
    ax_energy.plot(md.time, md.kinetic, label="MD kinetic K", lw=1.0)
    ax_energy.plot(md.time, md.potential + md.kinetic, label="MD total E", lw=1.0, alpha=0.8)
    ax_energy.set(xlabel="MD time", ylabel="energy", title="Langevin-MD instantaneous energies")
    ax_energy.legend(fontsize=8)
    ax_energy.grid(alpha=0.25)

    ax_potential.plot(np.arange(1, len(md.potential) + 1), running_mean(md.potential),
                      label="MD", color="tab:blue")
    ax_potential.plot(np.arange(1, len(mc.potential) + 1), running_mean(mc.potential),
                      label="MC", color="tab:orange")
    ax_potential.set(xlabel="stored sample", ylabel="running <U>",
                     title="Potential-energy convergence")
    ax_potential.legend()
    ax_potential.grid(alpha=0.25)

    ax_msd.plot(np.arange(1, len(md.msd) + 1), running_mean(md.msd), label="MD", color="tab:blue")
    ax_msd.plot(np.arange(1, len(mc.msd) + 1), running_mean(mc.msd), label="MC", color="tab:orange")
    ax_msd.set(xlabel="stored sample", ylabel=r"running $\langle u^2\rangle$",
               title="Mean-square displacement from lattice sites")
    ax_msd.legend()
    ax_msd.grid(alpha=0.25)

    bins = np.linspace(min(float(np.min(md.u_snapshots)), float(np.min(mc.u_snapshots))),
                       max(float(np.max(md.u_snapshots)), float(np.max(mc.u_snapshots))), 45)
    ax_hist.hist(md.u_snapshots.ravel(), bins=bins, density=True, histtype="step", lw=1.8,
                 label="MD", color="tab:blue")
    ax_hist.hist(mc.u_snapshots.ravel(), bins=bins, density=True, histtype="step", lw=1.8,
                 label="MC", color="tab:orange")
    ax_hist.set(xlabel="displacement u", ylabel="probability density",
                title="Equilibrium displacement distribution")
    ax_hist.legend()
    ax_hist.grid(alpha=0.25)

    fig.suptitle(f"2D lattice: K0={args.k0:g}, K2={args.k2:g}, K4={args.k4:g}, T={args.temperature:g}",
                 fontsize=14)
    fig.tight_layout(rect=(0, 0, 1, 0.95))
    return fig


def parse_args() -> argparse.Namespace:
    """
    概要:
        コマンドライン引数を解析します。

    戻り値:
        :returns: 解析されたコマンドライン引数を格納したオブジェクト
        :rtype: argparse.Namespace
    """
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--L", type=int, default=8, help="linear lattice size")
    parser.add_argument("--temperature", type=float, default=1.0)
    parser.add_argument("--k0", type=float, default=1.0,
                        help="on-site harmonic pinning; keeps the MSD finite and sampling fast")
    parser.add_argument("--k2", type=float, default=1.0, help="harmonic bond coefficient")
    parser.add_argument("--k4", type=float, default=0.20, help="quartic bond coefficient")
    parser.add_argument("--dt", type=float, default=0.02)
    parser.add_argument("--gamma", type=float, default=1.0, help="Langevin friction")
    parser.add_argument("--md-steps", type=int, default=12000)
    parser.add_argument("--md-burn", type=int, default=4000)
    parser.add_argument("--mc-sweeps", type=int, default=7000)
    parser.add_argument("--mc-burn", type=int, default=2000)
    parser.add_argument("--proposal", type=float, default=0.8,
                        help="uniform MC displacement half-width")
    parser.add_argument("--sample-stride", type=int, default=10)
    parser.add_argument("--seed", type=int, default=12345)
    parser.add_argument("--no-mc-momenta", dest="mc_momenta", action="store_false",
                        help="show equipartition expectation instead of Maxwell samples")
    parser.set_defaults(mc_momenta=True)
    parser.add_argument("--output", type=str, default=None, help="save summary figure")
    parser.add_argument("--dpi", type=int, default=160)
    parser.add_argument("--no-show", action="store_true")
    return parser.parse_args()


def validate_args(args: argparse.Namespace) -> None:
    """
    概要:
        コマンドライン引数の値が妥当かどうかを検証します。

    引数:
        :param args: 検証対象のコマンドライン引数オブジェクト
        :type args: argparse.Namespace

    戻り値:
        :returns: なし
        :rtype: None

    例外:
        :raises ValueError: 引数の値が制約を満たさない場合に送出されます。
    """
    if args.L < 2:
        raise ValueError("L must be at least 2")
    if args.temperature <= 0.0 or args.k0 < 0.0 or args.k2 < 0.0 or args.k4 < 0.0:
        raise ValueError("temperature must be positive and K0, K2, K4 must be non-negative")
    if args.dt <= 0.0 or args.gamma < 0.0 or args.proposal <= 0.0 or args.sample_stride < 1:
        raise ValueError("dt and proposal must be positive; gamma must be non-negative")
    if args.md_burn >= args.md_steps or args.mc_burn >= args.mc_sweeps:
        raise ValueError("burn-in must be shorter than the corresponding run")


def main() -> None:
    """
    概要:
        スクリプトのメインルーチンを実行します。

    詳細説明:
        引数を解析・検証し、MDおよびMCシミュレーションを実行し、結果の出力と描画を行います。

    戻り値:
        :returns: なし
        :rtype: None

    例外:
        :raises SystemExit: 引数エラーが発生した場合に送出されます。
    """
    args = parse_args()
    try:
        validate_args(args)
        seed_sequence = np.random.SeedSequence(args.seed)
        md_rng, mc_rng = [np.random.default_rng(child) for child in seed_sequence.spawn(2)]
        md = run_md(args, md_rng)
        mc, acceptance = run_mc(args, mc_rng)
    except ValueError as exc:
        raise SystemExit(f"Input error: {exc}") from exc

    print_summary(md, mc, acceptance, args)
    fig = plot_results(md, mc, args)
    if args.output:
        fig.savefig(args.output, dpi=args.dpi, bbox_inches="tight")
        print(f"\nSaved figure: {args.output}")
    if args.no_show:
        plt.close(fig)
    else:
        plt.show()


if __name__ == "__main__":
    main()