prep.py

"""Make CSVs for numerical data.

Some data can be slow to process and it is better to write them into a CSV file before
plotting, so that we don't need to wait for a long time during plotting. Data included:

- Energy result from neural network and ED with different number of electrons in 1/3.
- Ground state energy, quasiparticle/quasihole energy, electron population on the LLL,
  and overlap with the Laughlin wavefunction with different kappa in 1/3 filling.
"""

import os
from pathlib import Path

os.environ["JAX_PLATFORMS"] = "cpu"


import numpy as np
import pandas as pd
from deephall.loss import iqr_clip_real
from puwr import tauint
from uncertainties import ufloat, umath

DATA_PATH = Path(__file__).parent / "data"


def correct_energy(kinetic, potential, N, Q, R, nu, q=0, kappa=1):
    # Remove background contribution
    potential -= kappa * (N**2 - q**2) / 2 / R
    # Density correction for potential energy
    energy_in_au = (
        (kinetic - N / 2 * Q / R**2 + potential) * np.sqrt(2 * Q * nu / N) / N
    )
    # Normalize potential in the unit of 1/ell
    energy_in_ell = energy_in_au * R / np.sqrt(Q) / kappa
    return energy_in_ell


def ed_energy(ed_output, N, Q, R, nu, q=0):
    return correct_energy(N / 2, ed_output / 2, N, Q, R, nu, q)


def energy_vs_n():
    data = {"n": [6, 7, 8, 9, 10, 11, 12], "energy": [], "std": [], "ed": []}
    for n in data["n"]:
        flux = 3 * (n - 1)
        netobs_ckpt = DATA_PATH / f"n{n}l{flux}/k1/energy-100k/netobs_ckpt_001999.npz"
        with netobs_ckpt.open("rb") as f, np.load(f) as npf:
            energy = correct_energy(
                npf["values/kinetic"],
                npf["values/potential"],
                *(n, flux / 2, np.sqrt(flux / 2)),
                nu=1 / 3,
            ).real
        mean, std, *_ = tauint([[iqr_clip_real(energy, scale=3)]], 0)
        data["energy"].append(mean)
        data["std"].append(std)
    ed_n = [6, 7, 8, 9, 10, 11]
    ed_output = [
        7.7432698280425,
        10.121045415564,
        12.725298638045,
        15.542042784237,
        18.559733276244,
        21.768350529899,
    ]
    data["ed"] = [
        ed_energy(e, n, 3 * (n - 1) / 2, np.sqrt(3 * (n - 1) / 2), 1 / 3)
        for n, e in zip(ed_n, ed_output)
    ] + [np.nan]
    return pd.DataFrame(data)


def llm_1_3():
    data = {
        "kappa": [0.5, 1, 3, 10],
        "energy": [],
        "energy_std": [],
        "qp_energy": [],
        "qp_energy_std": [],
        "qh_energy": [],
        "qh_energy_std": [],
        "gap": [],
        "gap_std": [],
        "overlap": [],
        "overlap_std": [],
        "n_LLL": [],
        "n_LLL_std": [],
    }
    for kappa in data["kappa"]:
        netobs_ckpt = DATA_PATH / f"n6l14/k{kappa}/energy/netobs_ckpt_001999.npz"
        with netobs_ckpt.open("rb") as f, np.load(f) as npf:
            qp_energy = correct_energy(
                npf["values/kinetic"],
                npf["values/potential"],
                *(6, 14 / 2, np.sqrt(14 / 2)),
                nu=1 / 3,
                kappa=kappa,
                q=1 / 3,
            ).real
        qp_energy_mean, qp_energy_std, *_ = tauint([[iqr_clip_real(qp_energy)]], 0)
        data["qp_energy"].append(qp_energy_mean)
        data["qp_energy_std"].append(qp_energy_std)
        netobs_ckpt = DATA_PATH / f"n6l15/k{kappa}/energy/netobs_ckpt_001999.npz"
        with netobs_ckpt.open("rb") as f, np.load(f) as npf:
            energy = correct_energy(
                npf["values/kinetic"],
                npf["values/potential"],
                *(6, 15 / 2, np.sqrt(15 / 2)),
                nu=1 / 3,
                kappa=kappa,
            ).real
        energy_mean, energy_std, *_ = tauint([[iqr_clip_real(energy)]], 0)
        data["energy"].append(energy_mean)
        data["energy_std"].append(energy_std)
        netobs_ckpt = DATA_PATH / f"n6l16/k{kappa}/energy/netobs_ckpt_001999.npz"
        with netobs_ckpt.open("rb") as f, np.load(f) as npf:
            qh_energy = correct_energy(
                npf["values/kinetic"],
                npf["values/potential"],
                *(6, 16 / 2, np.sqrt(16 / 2)),
                nu=1 / 3,
                kappa=kappa,
                q=1 / 3,
            ).real
        qh_energy_mean, qh_energy_std, *_ = tauint([[iqr_clip_real(qh_energy)]], 0)
        data["qh_energy"].append(qh_energy_mean)
        data["qh_energy_std"].append(qh_energy_std)

        gap_mean, gap_std, *_ = tauint(
            [[6 * iqr_clip_real(qp_energy + qh_energy - 2 * energy)]], 0
        )
        data["gap"].append(gap_mean)
        data["gap_std"].append(gap_std)

        netobs_ckpt = DATA_PATH / f"n6l15/k{kappa}/overlap/netobs_ckpt_000199.npz"
        with netobs_ckpt.open("rb") as f, np.load(f) as npf:
            overlap_num_real, overlap_num_real_std, *_ = tauint(
                [[npf["values/ratio"].real]], 0
            )
            overlap_num_imag, overlap_num_imag_std, *_ = tauint(
                [[npf["values/ratio"].imag]], 0
            )
            overlap_den, overlap_den_std, *_ = tauint([[npf["values/ratio_square"]]], 0)
            overlap = umath.sqrt(
                (
                    ufloat(overlap_num_real, overlap_num_real_std) ** 2
                    + ufloat(overlap_num_imag, overlap_num_imag_std) ** 2
                )
                / ufloat(overlap_den, overlap_den_std)
            )
            data["overlap"].append(overlap.n)
            data["overlap_std"].append(overlap.s)
        netobs_ckpt = DATA_PATH / f"n6l15/k{kappa}/1rdm/netobs_ckpt_019999.npz"
        with netobs_ckpt.open("rb") as f, np.load(f) as npf:
            trace = np.trace(npf["values/one_rdm"], axis1=1, axis2=2)
            mean, std, *_ = tauint([[trace.real]], 0)
            data["n_LLL"].append(mean)
            data["n_LLL_std"].append(std)
    return pd.DataFrame(data)


if __name__ == "__main__":
    energy_vs_n().to_csv(open(DATA_PATH / "energy_vs_n.csv", "w"), index=False)
    llm_1_3().to_csv(open(DATA_PATH / "llm_1_3.csv", "w"), index=False)