| """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): |
| |
| potential -= kappa * (N**2 - q**2) / 2 / R |
| |
| energy_in_au = ( |
| (kinetic - N / 2 * Q / R**2 + potential) * np.sqrt(2 * Q * nu / N) / N |
| ) |
| |
| 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) |
|
|
