Datasets:
Formats:
csv
Languages:
English
Size:
1K - 10K
Tags:
open-science
superconductivity
superconductor-discovery
strongly-correlated
materials-discovery
2d-materials
License:
methods/Yuseon84: ED and Néel-field VMC references behind #56 (δ = 0) — scripts and outputs
#69
by Yuseon84 - opened
- methods/Yuseon84/LICENSE +16 -0
- methods/Yuseon84/README.md +44 -0
- methods/Yuseon84/SHA256SUMS.txt +37 -0
- methods/Yuseon84/code/ed_hubbard.py +154 -0
- methods/Yuseon84/code/ed_ksector.py +257 -0
- methods/Yuseon84/code/ed_ksector_gpu.py +126 -0
- methods/Yuseon84/code/pd_free.py +45 -0
- methods/Yuseon84/code/pd_free66.py +20 -0
- methods/Yuseon84/code/vmc_dwave.py +353 -0
- methods/Yuseon84/code/vmc_gpu.py +324 -0
- methods/Yuseon84/code/vmc_gpu2.py +539 -0
- methods/Yuseon84/code/vmc_gpu3.py +374 -0
- methods/Yuseon84/configs/vmc4x4_Ne10.json +33 -0
- methods/Yuseon84/configs/vmc4x4_Ne12.json +33 -0
- methods/Yuseon84/configs/vmc4x4_Ne14.json +33 -0
- methods/Yuseon84/configs/vmc4x4_Ne16.json +33 -0
- methods/Yuseon84/configs/vmc4x4_Ne8.json +33 -0
- methods/Yuseon84/configs/vmc6x6_Ne20.json +41 -0
- methods/Yuseon84/configs/vmc6x6_Ne22.json +41 -0
- methods/Yuseon84/configs/vmc6x6_Ne24.json +41 -0
- methods/Yuseon84/configs/vmc6x6_Ne26.json +41 -0
- methods/Yuseon84/configs/vmc6x6_Ne28.json +41 -0
- methods/Yuseon84/configs/vmc6x6_Ne30.json +41 -0
- methods/Yuseon84/configs/vmc6x6_Ne32.json +41 -0
- methods/Yuseon84/configs/vmc6x6_Ne34.json +41 -0
- methods/Yuseon84/configs/vmc6x6_Ne36.json +41 -0
- methods/Yuseon84/expected/ed4x4_Ne10_U8.json +25 -0
- methods/Yuseon84/expected/ed4x4_Ne12_U8.json +118 -0
- methods/Yuseon84/expected/ed4x4_Ne14_U8.json +118 -0
- methods/Yuseon84/expected/ed4x4_Ne16_U8.json +110 -0
- methods/Yuseon84/expected/ed4x4_Ne8_U8.json +112 -0
- methods/Yuseon84/expected/vmc4x4_vs_ed.json +52 -0
- methods/Yuseon84/expected/vmc6x6_best_by_energy.json +74 -0
- methods/Yuseon84/run_delta0.sh +14 -0
- methods/Yuseon84/run_ed_4x4.sh +7 -0
- methods/Yuseon84/run_free.sh +4 -0
- methods/Yuseon84/run_vmc_4x4.sh +8 -0
- methods/Yuseon84/run_vmc_6x6_seeds.sh +9 -0
methods/Yuseon84/LICENSE
ADDED
|
@@ -0,0 +1,16 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
MIT License
|
| 2 |
+
|
| 3 |
+
Copyright (c) 2026 Yuseon84
|
| 4 |
+
|
| 5 |
+
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
|
| 6 |
+
documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
|
| 7 |
+
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
|
| 8 |
+
persons to whom the Software is furnished to do so, subject to the following conditions:
|
| 9 |
+
|
| 10 |
+
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
|
| 11 |
+
Software.
|
| 12 |
+
|
| 13 |
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
| 14 |
+
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
| 15 |
+
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
| 16 |
+
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
methods/Yuseon84/README.md
ADDED
|
@@ -0,0 +1,44 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# Yuseon84 — ED and Néel-field VMC references for the OSC d-wave pair correlation
|
| 2 |
+
|
| 3 |
+
Supplementary material for Discussion #56 (A_d at half filling) and #15/#18. Code: MIT (see LICENSE). Numbers and
|
| 4 |
+
reference values from the OSC dataset keep the dataset's CC-BY-NC 4.0.
|
| 5 |
+
|
| 6 |
+
Observable: P_d(R) = ½ · (1/N) Σ_i ⟨Δ†_{i+R} Δ_i⟩, Δ_i = (1/√2) Σ_δ g_δ (c_{i↑} c_{i+δ↓} − c_{i↓} c_{i+δ↑}), g = +1 (x),
|
| 7 |
+
−1 (y): the organizer normalization (½ × the singlet definition; checked against the published 4×4 U = 0 column).
|
| 8 |
+
Hubbard model, periodic boundaries, t = 1, U/t = 8, Sz = 0.
|
| 9 |
+
|
| 10 |
+
## The δ = 0 numbers in #56 — `run_delta0.sh`
|
| 11 |
+
|
| 12 |
+
| quantity | lattice, R | value | file |
|
| 13 |
+
|---|---|---|---|
|
| 14 |
+
| ED, Ne = 16 (n = 1), equal-weight average over the ground manifold | 4×4, (2,2) | 0.006197 | `expected/ed4x4_Ne16_U8.json` |
|
| 15 |
+
| Néel-field VMC, Ne = 36, lowest-energy state, 3 seeds | 6×6, (3,3) | 0.0049 ± 0.0007 | `expected/vmc6x6_best_by_energy.json` |
|
| 16 |
+
|
| 17 |
+
The same VMC ansatz on 4×4 at n = 1 gives 0.0075 with energy within 4.6 % of ED (`expected/vmc4x4_vs_ed.json`).
|
| 18 |
+
|
| 19 |
+
## Everything else in the package
|
| 20 |
+
|
| 21 |
+
| script | what it reproduces |
|
| 22 |
+
|---|---|
|
| 23 |
+
| `run_ed_4x4.sh` | 4×4 ED, Ne = 8–16 (R = (2,2)); all five values equal the published Ku-ku table to 6 digits, with per-momentum-sector values of each degenerate manifold |
|
| 24 |
+
| `run_free.sh` | exact U = 0 pair correlation with degenerate-shell averaging (4×4 normalization check; 6×6 shell decomposition of A_d) |
|
| 25 |
+
| `run_vmc_4x4.sh` | frozen Néel-field VMC states on 4×4 vs ED (energy within 6 % at every filling; P_d 1.7–3.6× above ED at n = 0.75–0.875) |
|
| 26 |
+
| `run_vmc_6x6_seeds.sh` | the 6×6 table below, three measurement seeds |
|
| 27 |
+
|
| 28 |
+
6×6 Néel-field VMC (lowest-energy state per filling, never selected by P_d; energy below the OSC-family ansatz at every
|
| 29 |
+
filling):
|
| 30 |
+
|
| 31 |
+
| Ne | δ | A_d published | P_d (3 seeds) |
|
| 32 |
+
|---|---|---|---|
|
| 33 |
+
| 36 | 0.000 | 0.0384 | 0.0049 ± 0.0007 |
|
| 34 |
+
| 34 | 0.056 | 0.0452 | 0.0309 ± 0.0002 |
|
| 35 |
+
| 32 | 0.111 | 0.0473 | 0.0400 ± 0.0006 |
|
| 36 |
+
| 30 | 0.167 | 0.0557 | 0.0437 ± 0.0001 |
|
| 37 |
+
| 28 | 0.222 | 0.0481 | 0.0464 ± 0.0004 |
|
| 38 |
+
| 26 | 0.278 | 0.0585 | 0.0342 ± 0.0001 |
|
| 39 |
+
| 24 | 0.333 | 0.0430 | 0.0398 ± 0.0004 |
|
| 40 |
+
|
| 41 |
+
Values at δ ≥ 0.389 are omitted: there this ansatz exceeds even the U = 0 result (open-shell bias).
|
| 42 |
+
|
| 43 |
+
Limits: variational, not exact; 4×4 ED is small. Not a request to change any score of our own entries.
|
| 44 |
+
Requirements: Python 3.10, numpy, scipy; PyTorch with CUDA for the GPU scripts. Prepared with AI assistance (Claude Code).
|
methods/Yuseon84/SHA256SUMS.txt
ADDED
|
@@ -0,0 +1,37 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
065e472d891b938564e538453feef3db047cf84b268eecb0f3e1f6163b61ca48 *./LICENSE
|
| 2 |
+
19c64bb8ee160159538763b8d53db3f9243f2026d3e14244f914c3b8556182f5 *./README.md
|
| 3 |
+
3e3ae84d7c73f0ec37bf9d0387f338759cef4f77b092b619acfae38df4f26597 *./code/ed_hubbard.py
|
| 4 |
+
0432c753bad0bc4c4702bcc1293ce38c94fe75018f3ca310211e4ad3285117a0 *./code/ed_ksector.py
|
| 5 |
+
518f46af8cf0294a163b5a1cec8aa37c9661f9844c2085637146d548fc61b388 *./code/ed_ksector_gpu.py
|
| 6 |
+
7041aafec1e9b43bf410aae038124011d999e961babac1e0bd10802a42697790 *./code/pd_free.py
|
| 7 |
+
3ff5ff7d74e6c27efdd22fe8401adea4bd2ae06f8bcade1d8d557a446aa0de24 *./code/pd_free66.py
|
| 8 |
+
11143cc32f69e40e630e12d6028b9ab76216441b6d1b0ffe2642f9c577d60419 *./code/vmc_dwave.py
|
| 9 |
+
aa88304ebc1f67b66c5e7528b0eb9e4ad0b5b1e27ba5c5fc7db5fafd9a48031e *./code/vmc_gpu.py
|
| 10 |
+
03ec08aea607010403df9dbbf432aee070e309f097df7d059af92b720746e65e *./code/vmc_gpu2.py
|
| 11 |
+
d46fcba969cae69bcce38d3bf2c5d9b1c127fda224c9909dd1780a924202d9d7 *./code/vmc_gpu3.py
|
| 12 |
+
9d1f45bd9dcf578e5cc913323bcd4fde8ef5fc877031613c2232e2e65fdcaa6e *./configs/vmc4x4_Ne10.json
|
| 13 |
+
623db3716a5e04e447d10bf3503fa867cab14b28bd73bd3a2dc9890e12375376 *./configs/vmc4x4_Ne12.json
|
| 14 |
+
740487d54a278633759bc83f68a6de7df23ef54258517177f4ff4f0047da52a5 *./configs/vmc4x4_Ne14.json
|
| 15 |
+
2350abb243ffbce4ea23a80de70b9b22c27c7e98200b87baabeec5b4500a12fa *./configs/vmc4x4_Ne16.json
|
| 16 |
+
f74fc3e640d4ff83a154ebed4cc7fec3a579a4f29e5e7a1791aad1e06614cf55 *./configs/vmc4x4_Ne8.json
|
| 17 |
+
7817316d6c7377169a6308c28fb2a01eebd8357ac634e3377221dc3e7dd6a5da *./configs/vmc6x6_Ne20.json
|
| 18 |
+
416fe562b39d121740a84fe971441522563afbb66e88afc3ff4ad0667969a842 *./configs/vmc6x6_Ne22.json
|
| 19 |
+
5b1e75f37a8fba5cd550597837ca6baa10664f87613099bb65056e06f95f0222 *./configs/vmc6x6_Ne24.json
|
| 20 |
+
4a6775b1f37dea0bba87e594d49c205afd80fc28d20635e6e7b5d28a94c04944 *./configs/vmc6x6_Ne26.json
|
| 21 |
+
488216a2924559da872e4748cc6969acafdb34b996f5b9325320dc26acbc7e3c *./configs/vmc6x6_Ne28.json
|
| 22 |
+
3c305ffb1c58463b78c7fb88ce596e7574b2e9c2b6385afd825fc4325c6f0c74 *./configs/vmc6x6_Ne30.json
|
| 23 |
+
d514e03d8cf2f72cfd1731e0cfa74461e508cbb2dfe00ad0c59f1859af4887fb *./configs/vmc6x6_Ne32.json
|
| 24 |
+
d23c0c9331fe5ce60677ffab99504e83132d3a6d3a9194579f87289a9e3b7cb5 *./configs/vmc6x6_Ne34.json
|
| 25 |
+
55d7b00e20a08ff2b0ddf66770b1d2680f6e2cd52561334d813f0240498dfc3d *./configs/vmc6x6_Ne36.json
|
| 26 |
+
a2f07179fe323491a87e1f9c7e6513442ebf5e992ed0d51ddd7ee70cf82cc71f *./expected/ed4x4_Ne10_U8.json
|
| 27 |
+
95aa02d489bd3729170c24214f34c9950a755c7d8061a92a8ddfc01edfb3cd48 *./expected/ed4x4_Ne12_U8.json
|
| 28 |
+
c065119134a5269f76def253de6f57b1d4ad3c6d301163b24efe7b3f41c860b9 *./expected/ed4x4_Ne14_U8.json
|
| 29 |
+
d95338c8d7750cf70f5dfb2bea04e38941ad8fe45aa351dbed833654f0b53ab8 *./expected/ed4x4_Ne16_U8.json
|
| 30 |
+
f25373243445a414624ec30de42d02276746b5fc937add954f39d02d860832f6 *./expected/ed4x4_Ne8_U8.json
|
| 31 |
+
5a4c969718b658a15ae8c8b63de83a36d812de5a61bfade80c5f2f83031c41b5 *./expected/vmc4x4_vs_ed.json
|
| 32 |
+
57d0d21c3e18bd8e20345ffe3cb04e8c0f5bc735115f74ae54e521fbae8eec28 *./expected/vmc6x6_best_by_energy.json
|
| 33 |
+
033e2aad3dc878469b928161a6bbf4b9bab996a9081f2e8ca6e57533c6f4236c *./run_delta0.sh
|
| 34 |
+
3334ddd02a19ca8c0b33d539c2e88be6b80f17e939c1ed4a7519a3cc640117a2 *./run_ed_4x4.sh
|
| 35 |
+
b7425f0baf819fdd89a5815c3539cca3b154e50aa8f906e6c4d6262302db54da *./run_free.sh
|
| 36 |
+
6559d31fc13207fe29cad75162271f6ae7d015189473b6285b65695ca1954c18 *./run_vmc_4x4.sh
|
| 37 |
+
381b40f2801cfc48ee983d42849224996223e7f480d025a90c2c4c4804847308 *./run_vmc_6x6_seeds.sh
|
methods/Yuseon84/code/ed_hubbard.py
ADDED
|
@@ -0,0 +1,154 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# -*- coding: utf-8 -*-
|
| 2 |
+
"""Exact diagonalization of the 2D Hubbard model on an LxL periodic cluster, Sz=0 sector,
|
| 3 |
+
and the OSC d-wave pair correlation P_d(R).
|
| 4 |
+
|
| 5 |
+
Matrix-free product basis: psi is a [dim_up, dim_dn] matrix,
|
| 6 |
+
H psi = T_up @ psi + psi @ T_dn^T + U * D * psi, D[a,b] = popcount(up_a & dn_b)
|
| 7 |
+
Fermion ordering: all up operators left of all down operators, sites ascending.
|
| 8 |
+
|
| 9 |
+
OSC normalization (pinned by the U=0 check in pd_free.py):
|
| 10 |
+
P_org(R) = 1/2 * (1/N) sum_i <D_{i+R}^dag D_i>,
|
| 11 |
+
D_i = 1/sqrt2 sum_d g_d (c_{i,up} c_{i+d,dn} - c_{i,dn} c_{i+d,up}), g = +1 (x), -1 (y)
|
| 12 |
+
Degenerate ground states are averaged with equal weight (as in the Ku-ku ED reference).
|
| 13 |
+
"""
|
| 14 |
+
import argparse, itertools, json, time
|
| 15 |
+
import numpy as np
|
| 16 |
+
import scipy.sparse as sp
|
| 17 |
+
from scipy.sparse.linalg import LinearOperator, eigsh
|
| 18 |
+
|
| 19 |
+
NB = [((1, 0), 1.0), ((-1, 0), 1.0), ((0, 1), -1.0), ((0, -1), -1.0)]
|
| 20 |
+
|
| 21 |
+
|
| 22 |
+
def site(L, x, y):
|
| 23 |
+
return (x % L) * L + (y % L)
|
| 24 |
+
|
| 25 |
+
|
| 26 |
+
def basis(Ns, n):
|
| 27 |
+
st = np.array(sorted(sum(1 << i for i in c) for c in itertools.combinations(range(Ns), n)),
|
| 28 |
+
dtype=np.int64)
|
| 29 |
+
return st
|
| 30 |
+
|
| 31 |
+
|
| 32 |
+
def popcount(a):
|
| 33 |
+
a = a.copy(); c = np.zeros_like(a)
|
| 34 |
+
while a.any():
|
| 35 |
+
c += a & 1; a >>= 1
|
| 36 |
+
return c
|
| 37 |
+
|
| 38 |
+
|
| 39 |
+
def hop_matrix(L, st, t=1.0):
|
| 40 |
+
"""-t sum_<ab> (c_a^dag c_b + h.c.) on one spin species."""
|
| 41 |
+
Ns = L * L
|
| 42 |
+
bonds = set()
|
| 43 |
+
for x in range(L):
|
| 44 |
+
for y in range(L):
|
| 45 |
+
a = site(L, x, y)
|
| 46 |
+
for b in (site(L, x + 1, y), site(L, x, y + 1)):
|
| 47 |
+
bonds.add((min(a, b), max(a, b)))
|
| 48 |
+
rows, cols, vals = [], [], []
|
| 49 |
+
for (a, b) in sorted(bonds):
|
| 50 |
+
mask_between = ((1 << b) - 1) ^ ((1 << (a + 1)) - 1) # sites strictly between a and b
|
| 51 |
+
for src, dst in ((a, b), (b, a)): # c_dst^dag c_src
|
| 52 |
+
has = (st >> src) & 1
|
| 53 |
+
emp = ((st >> dst) & 1) == 0
|
| 54 |
+
ok = np.nonzero(has.astype(bool) & emp)[0]
|
| 55 |
+
new = st[ok] ^ (1 << src) ^ (1 << dst)
|
| 56 |
+
sign = 1 - 2 * (popcount(st[ok] & mask_between) & 1)
|
| 57 |
+
rows.append(np.searchsorted(st, new)); cols.append(ok); vals.append(-t * sign)
|
| 58 |
+
n = len(st)
|
| 59 |
+
return sp.csr_matrix((np.concatenate(vals).astype(float),
|
| 60 |
+
(np.concatenate(rows), np.concatenate(cols))), shape=(n, n))
|
| 61 |
+
|
| 62 |
+
|
| 63 |
+
def annihilator(st_from, st_to, i):
|
| 64 |
+
"""c_i : basis(n) -> basis(n-1), with sign (-1)^{#occupied below i}."""
|
| 65 |
+
ok = np.nonzero((st_from >> i) & 1)[0]
|
| 66 |
+
new = st_from[ok] ^ (1 << i)
|
| 67 |
+
sign = 1 - 2 * (popcount(st_from[ok] & ((1 << i) - 1)) & 1)
|
| 68 |
+
return sp.csr_matrix((sign.astype(float), (np.searchsorted(st_to, new), ok)),
|
| 69 |
+
shape=(len(st_to), len(st_from)))
|
| 70 |
+
|
| 71 |
+
|
| 72 |
+
def ground_states(L, nup, ndn, U, k=6, tol=1e-10, degen_tol=1e-7, ncv=None):
|
| 73 |
+
Ns = L * L
|
| 74 |
+
su, sd = basis(Ns, nup), basis(Ns, ndn)
|
| 75 |
+
Tu, Td = hop_matrix(L, su), hop_matrix(L, sd)
|
| 76 |
+
bu = ((su[:, None] >> np.arange(Ns)) & 1).astype(np.float32)
|
| 77 |
+
bd = ((sd[:, None] >> np.arange(Ns)) & 1).astype(np.float32)
|
| 78 |
+
D = (bu @ bd.T).astype(np.float64)
|
| 79 |
+
du, dd = len(su), len(sd)
|
| 80 |
+
def mv(v):
|
| 81 |
+
P = v.reshape(du, dd)
|
| 82 |
+
out = Tu @ P
|
| 83 |
+
out += (Td @ P.T).T # psi @ T_dn^T (T_dn symmetric)
|
| 84 |
+
out += U * D * P
|
| 85 |
+
return out.ravel()
|
| 86 |
+
|
| 87 |
+
H = LinearOperator((du * dd, du * dd), matvec=mv, dtype=np.float64)
|
| 88 |
+
k = min(k, du * dd - 2)
|
| 89 |
+
w, V = eigsh(H, k=k, which="SA", tol=tol, ncv=ncv)
|
| 90 |
+
o = np.argsort(w); w, V = w[o], V[:, o]
|
| 91 |
+
e0 = w[0]
|
| 92 |
+
deg = int(np.sum(np.abs(w - e0) < degen_tol * max(1.0, abs(e0))))
|
| 93 |
+
if deg == k:
|
| 94 |
+
print(f"[warn] degeneracy may exceed k={k}; rerun with larger --k")
|
| 95 |
+
return dict(su=su, sd=sd, E=w, E0=e0, deg=deg, V=V[:, :deg], du=du, dd=dd)
|
| 96 |
+
|
| 97 |
+
|
| 98 |
+
def pair_corr(L, gs, Rs):
|
| 99 |
+
Ns = L * L
|
| 100 |
+
su, sd, du, dd = gs["su"], gs["sd"], gs["du"], gs["dd"]
|
| 101 |
+
nup, ndn = bin(int(su[0])).count("1"), bin(int(sd[0])).count("1")
|
| 102 |
+
su1, sd1 = basis(Ns, nup - 1), basis(Ns, ndn - 1)
|
| 103 |
+
Au = [annihilator(su, su1, i) for i in range(Ns)]
|
| 104 |
+
Ad = [annihilator(sd, sd1, i) for i in range(Ns)]
|
| 105 |
+
out = {R: 0.0 for R in Rs}
|
| 106 |
+
for s in range(gs["deg"]):
|
| 107 |
+
P = gs["V"][:, s].reshape(du, dd)
|
| 108 |
+
phi = []
|
| 109 |
+
for x in range(L):
|
| 110 |
+
for y in range(L):
|
| 111 |
+
i = site(L, x, y)
|
| 112 |
+
acc = np.zeros((len(su1), len(sd1)))
|
| 113 |
+
for (d, g) in NB:
|
| 114 |
+
j = site(L, x + d[0], y + d[1])
|
| 115 |
+
# c_{i,up} c_{j,dn} - c_{i,dn} c_{j,up} = c_{i,up}c_{j,dn} + c_{j,up}c_{i,dn}
|
| 116 |
+
acc += g * ((Au[i] @ (Ad[j] @ P.T).T) + (Au[j] @ (Ad[i] @ P.T).T))
|
| 117 |
+
phi.append(acc / np.sqrt(2.0))
|
| 118 |
+
for R in Rs:
|
| 119 |
+
tot = 0.0
|
| 120 |
+
for x in range(L):
|
| 121 |
+
for y in range(L):
|
| 122 |
+
i, j = site(L, x, y), site(L, x + R[0], y + R[1])
|
| 123 |
+
tot += np.vdot(phi[j], phi[i]).real
|
| 124 |
+
out[R] += 0.5 * tot / Ns / gs["deg"] # 0.5 = OSC (organizer) normalization
|
| 125 |
+
return out
|
| 126 |
+
|
| 127 |
+
|
| 128 |
+
def main():
|
| 129 |
+
ap = argparse.ArgumentParser()
|
| 130 |
+
ap.add_argument("--L", type=int, default=4)
|
| 131 |
+
ap.add_argument("--Ne", type=int, nargs="+", default=[8, 10])
|
| 132 |
+
ap.add_argument("--U", type=float, default=8.0)
|
| 133 |
+
ap.add_argument("--k", type=int, default=8)
|
| 134 |
+
ap.add_argument("--ncv", type=int, default=None)
|
| 135 |
+
ap.add_argument("--out", default="")
|
| 136 |
+
a = ap.parse_args()
|
| 137 |
+
L = a.L; Rmax = (L // 2, L // 2)
|
| 138 |
+
res = []
|
| 139 |
+
for Ne in a.Ne:
|
| 140 |
+
t0 = time.time()
|
| 141 |
+
gs = ground_states(L, Ne // 2, Ne // 2, a.U, k=a.k, ncv=a.ncv)
|
| 142 |
+
pc = pair_corr(L, gs, [Rmax, (1, 1), (2, 0)] if L >= 4 else [Rmax])
|
| 143 |
+
r = dict(L=L, Ne=Ne, n=Ne / L ** 2, U=a.U, E0=gs["E0"], deg=gs["deg"],
|
| 144 |
+
dim=gs["du"] * gs["dd"], lowest=[round(float(x), 8) for x in gs["E"][:min(6, len(gs["E"]))]],
|
| 145 |
+
Pd={f"{R[0]},{R[1]}": round(v, 6) for R, v in pc.items()},
|
| 146 |
+
sec=round(time.time() - t0, 1))
|
| 147 |
+
print(json.dumps(r), flush=True)
|
| 148 |
+
res.append(r)
|
| 149 |
+
if a.out:
|
| 150 |
+
json.dump(res, open(a.out, "w"), indent=1)
|
| 151 |
+
|
| 152 |
+
|
| 153 |
+
if __name__ == "__main__":
|
| 154 |
+
main()
|
methods/Yuseon84/code/ed_ksector.py
ADDED
|
@@ -0,0 +1,257 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# -*- coding: utf-8 -*-
|
| 2 |
+
"""Momentum-sector ED of the Hubbard model on an LxL periodic cluster (Sz=0), with the OSC
|
| 3 |
+
d-wave pair correlation averaged over the full degenerate ground-state manifold.
|
| 4 |
+
|
| 5 |
+
Basis: "up-representative" coding. A k-state is P_k sum_{r,d} f[r,d] |r,d>, with r running over
|
| 6 |
+
translation-orbit representatives of the up configuration and d over ALL down configurations.
|
| 7 |
+
Rows r with a non-trivial stabilizer S_r are kept symmetrized (Sym), and coordinates are scaled by
|
| 8 |
+
sqrt|S_r| so the induced metric is Euclidean -> the operator is Hermitian on the symmetric subspace
|
| 9 |
+
(it is zero on its complement, which only adds spurious zero eigenvalues; ground energies are < 0).
|
| 10 |
+
|
| 11 |
+
P_k|c'> = sigma * exp(-i k.g) * P_k|a> when T_g c' = sigma * a.
|
| 12 |
+
|
| 13 |
+
Pair correlation: for a momentum eigenstate, (1/N) sum_i <D+_{i+R} D_i> = <D+_R D_0>, evaluated
|
| 14 |
+
as sum of <(c+_{p'up} c_{p up})(c+_{q'dn} c_{q dn})> bilinears on the expanded wavefunction.
|
| 15 |
+
OSC normalization = 1/2 x standard singlet definition (see pd_free.py / ed_hubbard.py).
|
| 16 |
+
"""
|
| 17 |
+
import argparse, json, time, itertools
|
| 18 |
+
import numpy as np
|
| 19 |
+
import scipy.sparse as sp
|
| 20 |
+
from scipy.sparse.linalg import LinearOperator, eigsh
|
| 21 |
+
from ed_hubbard import basis, popcount, hop_matrix, site, NB
|
| 22 |
+
|
| 23 |
+
|
| 24 |
+
def translations(L):
|
| 25 |
+
G = [(gx, gy) for gx in range(L) for gy in range(L)]
|
| 26 |
+
perm = np.array([[site(L, x + gx, y + gy) for x in range(L) for y in range(L)] for gx, gy in G])
|
| 27 |
+
return G, perm
|
| 28 |
+
|
| 29 |
+
|
| 30 |
+
def act(st, perm_g):
|
| 31 |
+
"""Image index and fermion sign of T_g on every basis state of one spin species."""
|
| 32 |
+
Ns = len(perm_g)
|
| 33 |
+
occ = ((st[:, None] >> np.arange(Ns)) & 1).astype(np.int64)
|
| 34 |
+
new = (occ << perm_g[None, :]).sum(1)
|
| 35 |
+
inv = np.zeros(len(st), dtype=np.int64)
|
| 36 |
+
for s1 in range(Ns):
|
| 37 |
+
for s2 in range(s1 + 1, Ns):
|
| 38 |
+
if perm_g[s1] > perm_g[s2]:
|
| 39 |
+
inv += occ[:, s1] & occ[:, s2]
|
| 40 |
+
return np.searchsorted(st, new), 1.0 - 2.0 * (inv & 1)
|
| 41 |
+
|
| 42 |
+
|
| 43 |
+
def bilinear(st, a, b):
|
| 44 |
+
"""Matrix of c+_a c_b on one spin species (a may equal b)."""
|
| 45 |
+
n = len(st)
|
| 46 |
+
if a == b:
|
| 47 |
+
return sp.diags(((st >> a) & 1).astype(float)).tocsr()
|
| 48 |
+
has = ((st >> b) & 1).astype(bool) & (((st >> a) & 1) == 0)
|
| 49 |
+
ok = np.nonzero(has)[0]
|
| 50 |
+
new = st[ok] ^ (1 << a) ^ (1 << b)
|
| 51 |
+
lo, hi = min(a, b), max(a, b)
|
| 52 |
+
between = ((1 << hi) - 1) ^ ((1 << (lo + 1)) - 1)
|
| 53 |
+
sign = 1 - 2 * (popcount(st[ok] & between) & 1)
|
| 54 |
+
return sp.csr_matrix((sign.astype(float), (np.searchsorted(st, new), ok)), shape=(n, n))
|
| 55 |
+
|
| 56 |
+
|
| 57 |
+
class Sector:
|
| 58 |
+
def __init__(self, L, nup, ndn, U, k):
|
| 59 |
+
self.L, self.U, self.k = L, U, k
|
| 60 |
+
Ns = L * L
|
| 61 |
+
self.su, self.sd = basis(Ns, nup), basis(Ns, ndn)
|
| 62 |
+
self.G, permS = translations(L)
|
| 63 |
+
nG = len(self.G)
|
| 64 |
+
self.ph = np.array([np.exp(-2j * np.pi / L * (k[0] * g[0] + k[1] * g[1])) for g in self.G])
|
| 65 |
+
self.img_u, self.sg_u, self.img_d, self.sg_d = [], [], [], []
|
| 66 |
+
for g in range(nG):
|
| 67 |
+
i, s = act(self.su, permS[g]); self.img_u.append(i); self.sg_u.append(s)
|
| 68 |
+
i, s = act(self.sd, permS[g]); self.img_d.append(i); self.sg_d.append(s)
|
| 69 |
+
self.img_u = np.array(self.img_u); self.sg_u = np.array(self.sg_u)
|
| 70 |
+
self.img_d = np.array(self.img_d); self.sg_d = np.array(self.sg_d)
|
| 71 |
+
du, dd = len(self.su), len(self.sd)
|
| 72 |
+
g0 = np.argmin(self.img_u, axis=0) # g0[u]: T_g0 u = rep(u)
|
| 73 |
+
rep_of = self.img_u[g0, np.arange(du)]
|
| 74 |
+
self.reps = np.unique(rep_of)
|
| 75 |
+
pos = -np.ones(du, dtype=np.int64); pos[self.reps] = np.arange(len(self.reps))
|
| 76 |
+
nR = len(self.reps); self.nR, self.dd, self.du = nR, dd, du
|
| 77 |
+
# stabilizers and symmetrizers for rows with non-trivial S_r
|
| 78 |
+
self.S = np.ones(nR)
|
| 79 |
+
self.sym = [] # (row, [(src, coef)])
|
| 80 |
+
for ri, r in enumerate(self.reps):
|
| 81 |
+
stab = [g for g in range(nG) if self.img_u[g, r] == r]
|
| 82 |
+
self.S[ri] = len(stab)
|
| 83 |
+
if len(stab) > 1:
|
| 84 |
+
terms = []
|
| 85 |
+
for h in stab:
|
| 86 |
+
# f_sym[d''] = mean_h sigma_u(h,r) sigma_d(h,src) e^{-ik.h} f[src], src = h^-1 d''
|
| 87 |
+
src = np.empty(dd, dtype=np.int64); src[self.img_d[h]] = np.arange(dd)
|
| 88 |
+
coef = self.sg_u[h, r] * self.sg_d[h][src] * self.ph[h]
|
| 89 |
+
terms.append((src, coef))
|
| 90 |
+
self.sym.append((ri, terms))
|
| 91 |
+
self.sqS = np.sqrt(self.S)
|
| 92 |
+
# interaction
|
| 93 |
+
bu = ((self.su[self.reps][:, None] >> np.arange(Ns)) & 1).astype(np.float32)
|
| 94 |
+
bd = ((self.sd[:, None] >> np.arange(Ns)) & 1).astype(np.float32)
|
| 95 |
+
self.Dm = (bu @ bd.T).astype(np.float64)
|
| 96 |
+
# hopping
|
| 97 |
+
self.Td = hop_matrix(L, self.sd)
|
| 98 |
+
Tu = hop_matrix(L, self.su).tocsc()
|
| 99 |
+
rows = {g: ([], [], []) for g in range(nG)}
|
| 100 |
+
for ri, r in enumerate(self.reps):
|
| 101 |
+
for idx in range(Tu.indptr[r], Tu.indptr[r + 1]):
|
| 102 |
+
u2, amp = Tu.indices[idx], Tu.data[idx]
|
| 103 |
+
g = g0[u2]; rj = pos[rep_of[u2]]
|
| 104 |
+
c = amp * self.sg_u[g, u2] * self.ph[g]
|
| 105 |
+
rows[g][0].append(rj); rows[g][1].append(ri); rows[g][2].append(c)
|
| 106 |
+
self.Up = [(g, sp.csr_matrix((np.array(v[2], dtype=complex), (v[0], v[1])), shape=(nR, nR)))
|
| 107 |
+
for g, v in rows.items() if v[0]]
|
| 108 |
+
self.rep_of, self.g0, self.pos = rep_of, g0, pos
|
| 109 |
+
|
| 110 |
+
def symm(self, F):
|
| 111 |
+
for ri, terms in self.sym:
|
| 112 |
+
acc = np.zeros(self.dd, dtype=complex)
|
| 113 |
+
for src, coef in terms:
|
| 114 |
+
acc += coef * F[ri, src]
|
| 115 |
+
F[ri] = acc / len(terms)
|
| 116 |
+
return F
|
| 117 |
+
|
| 118 |
+
def matvec(self, v):
|
| 119 |
+
F = self.symm(v.reshape(self.nR, self.dd) / self.sqS[:, None])
|
| 120 |
+
out = self.U * self.Dm * F
|
| 121 |
+
out += (self.Td @ F.T).T
|
| 122 |
+
for g, M in self.Up:
|
| 123 |
+
out[:, self.img_d[g]] += M @ (F * self.sg_d[g][None, :])
|
| 124 |
+
out = self.symm(out)
|
| 125 |
+
return (out * self.sqS[:, None]).ravel()
|
| 126 |
+
|
| 127 |
+
def solve(self, k=4, tol=1e-10, ncv=None):
|
| 128 |
+
n = self.nR * self.dd
|
| 129 |
+
H = LinearOperator((n, n), matvec=self.matvec, dtype=complex)
|
| 130 |
+
rng = np.random.default_rng(1)
|
| 131 |
+
v0 = rng.normal(size=n) + 1j * rng.normal(size=n)
|
| 132 |
+
v0 = (self.symm(v0.reshape(self.nR, self.dd) / self.sqS[:, None]) * self.sqS[:, None]).ravel()
|
| 133 |
+
w, V = eigsh(H, k=k, which="SA", tol=tol, v0=v0, ncv=ncv)
|
| 134 |
+
o = np.argsort(w)
|
| 135 |
+
return w[o], V[:, o]
|
| 136 |
+
|
| 137 |
+
def expand(self, v):
|
| 138 |
+
"""Full-product-basis wavefunction Psi[u,d] (normalized) of the k-state with coords v."""
|
| 139 |
+
F = self.symm(v.reshape(self.nR, self.dd) / self.sqS[:, None])
|
| 140 |
+
Psi = np.zeros((self.du, self.dd), dtype=complex)
|
| 141 |
+
for ri, r in enumerate(self.reps):
|
| 142 |
+
for g in range(len(self.G)):
|
| 143 |
+
u = self.img_u[g, r]
|
| 144 |
+
Psi[u, self.img_d[g]] += self.ph[g] * self.sg_u[g, r] * self.sg_d[g] * F[ri]
|
| 145 |
+
Psi /= np.linalg.norm(Psi)
|
| 146 |
+
return Psi
|
| 147 |
+
|
| 148 |
+
|
| 149 |
+
def pair_corr_k(L, su, sd, Psi, R, blk=2048):
|
| 150 |
+
"""<D+_R D_0>, OSC normalization."""
|
| 151 |
+
Rs = site(L, R[0], R[1])
|
| 152 |
+
terms = []
|
| 153 |
+
for (d, g) in NB:
|
| 154 |
+
dj = site(L, d[0], d[1])
|
| 155 |
+
for (dp, gp) in NB:
|
| 156 |
+
Rj = site(L, R[0] + dp[0], R[1] + dp[1])
|
| 157 |
+
for (p, q) in ((0, dj), (dj, 0)):
|
| 158 |
+
for (pp, qp) in ((Rs, Rj), (Rj, Rs)):
|
| 159 |
+
terms.append((g * gp, pp, p, qp, q))
|
| 160 |
+
cache_u, cache_d = {}, {}
|
| 161 |
+
tot = 0.0
|
| 162 |
+
for c, pp, p, qp, q in terms:
|
| 163 |
+
A = cache_u.setdefault((pp, p), bilinear(su, pp, p))
|
| 164 |
+
B = cache_d.setdefault((qp, q), bilinear(sd, qp, q))
|
| 165 |
+
val = 0.0
|
| 166 |
+
for a0 in range(0, Psi.shape[0], blk):
|
| 167 |
+
X = A[a0:a0 + blk] @ Psi
|
| 168 |
+
Y = (B @ X.T).T
|
| 169 |
+
val += np.vdot(Psi[a0:a0 + blk], Y)
|
| 170 |
+
tot += c * val
|
| 171 |
+
return 0.5 * 0.5 * tot.real # 1/2 from sqrt2*sqrt2, 1/2 OSC normalization
|
| 172 |
+
|
| 173 |
+
|
| 174 |
+
def irreducible_k(L):
|
| 175 |
+
"""C4v-irreducible momenta with star multiplicities."""
|
| 176 |
+
seen, out = set(), []
|
| 177 |
+
for kx in range(L):
|
| 178 |
+
for ky in range(L):
|
| 179 |
+
if (kx, ky) in seen:
|
| 180 |
+
continue
|
| 181 |
+
star = set()
|
| 182 |
+
for (a, b) in [(kx, ky), (ky, kx)]:
|
| 183 |
+
for sx in (1, -1):
|
| 184 |
+
for sy in (1, -1):
|
| 185 |
+
star.add(((sx * a) % L, (sy * b) % L))
|
| 186 |
+
seen |= star
|
| 187 |
+
out.append(((kx, ky), len(star)))
|
| 188 |
+
return out
|
| 189 |
+
|
| 190 |
+
|
| 191 |
+
def main():
|
| 192 |
+
ap = argparse.ArgumentParser()
|
| 193 |
+
ap.add_argument("--L", type=int, default=4)
|
| 194 |
+
ap.add_argument("--Ne", type=int, required=True)
|
| 195 |
+
ap.add_argument("--U", type=float, default=8.0)
|
| 196 |
+
ap.add_argument("--k", type=int, default=4, help="eigenpairs per sector")
|
| 197 |
+
ap.add_argument("--degen_tol", type=float, default=1e-7)
|
| 198 |
+
ap.add_argument("--ncv", type=int, default=None)
|
| 199 |
+
ap.add_argument("--out", default="")
|
| 200 |
+
ap.add_argument("--sector", type=int, default=-1, help="solve only this irreducible-k index, save to --save")
|
| 201 |
+
ap.add_argument("--save", default="", help="directory for per-sector npz files")
|
| 202 |
+
ap.add_argument("--combine", action="store_true", help="combine saved sectors from --save")
|
| 203 |
+
a = ap.parse_args()
|
| 204 |
+
L, Ne = a.L, a.Ne
|
| 205 |
+
R = (L // 2, L // 2)
|
| 206 |
+
t0 = time.time()
|
| 207 |
+
ks = irreducible_k(L)
|
| 208 |
+
tag = f"L{L}_Ne{Ne}_U{a.U:g}"
|
| 209 |
+
if a.sector >= 0: # solve one sector, persist low states
|
| 210 |
+
kv, mult = ks[a.sector]
|
| 211 |
+
S = Sector(L, Ne // 2, Ne // 2, a.U, kv)
|
| 212 |
+
w, V = S.solve(k=a.k, ncv=a.ncv)
|
| 213 |
+
low = [i for i, e in enumerate(w) if abs(e - w[0]) < a.degen_tol * abs(w[0])]
|
| 214 |
+
np.savez(f"{a.save}/{tag}_k{kv[0]}{kv[1]}.npz", k=np.array(kv), mult=mult, E=w, V=V[:, low])
|
| 215 |
+
print(f"k={kv} x{mult} dim={S.nR*S.dd} nlow={len(low)} E={np.round(w,8).tolist()} "
|
| 216 |
+
f"({time.time()-t0:.0f}s)", flush=True)
|
| 217 |
+
if len(low) == len(w):
|
| 218 |
+
print(f"[warn] k={kv}: all {len(low)} eigenpairs degenerate; raise --k", flush=True)
|
| 219 |
+
return
|
| 220 |
+
sec = []
|
| 221 |
+
if a.combine:
|
| 222 |
+
for kv, mult in ks:
|
| 223 |
+
z = np.load(f"{a.save}/{tag}_k{kv[0]}{kv[1]}.npz")
|
| 224 |
+
sec.append(dict(k=kv, mult=mult, E=z["E"].tolist(), V=z["V"], nlow=z["V"].shape[1], S=None))
|
| 225 |
+
else:
|
| 226 |
+
for kv, mult in ks:
|
| 227 |
+
S = Sector(L, Ne // 2, Ne // 2, a.U, kv)
|
| 228 |
+
w, V = S.solve(k=a.k, ncv=a.ncv)
|
| 229 |
+
low = [i for i, e in enumerate(w) if abs(e - w[0]) < a.degen_tol * abs(w[0])]
|
| 230 |
+
sec.append(dict(k=kv, mult=mult, E=w.tolist(), S=S, V=V[:, low].copy(), nlow=len(low)))
|
| 231 |
+
del V
|
| 232 |
+
print(f"k={kv} x{mult} dim={S.nR*S.dd} E={np.round(w,8).tolist()} ({time.time()-t0:.0f}s)", flush=True)
|
| 233 |
+
E0 = min(s["E"][0] for s in sec)
|
| 234 |
+
acc, wsum, manifold = 0.0, 0, []
|
| 235 |
+
for s in sec:
|
| 236 |
+
idx = [i for i in range(s["nlow"]) if abs(s["E"][i] - E0) < a.degen_tol * abs(E0)]
|
| 237 |
+
if idx and s["S"] is None:
|
| 238 |
+
s["S"] = Sector(L, Ne // 2, Ne // 2, a.U, s["k"])
|
| 239 |
+
for i in idx:
|
| 240 |
+
Psi = s["S"].expand(s["V"][:, i])
|
| 241 |
+
p = pair_corr_k(L, s["S"].su, s["S"].sd, Psi, R)
|
| 242 |
+
del Psi
|
| 243 |
+
acc += s["mult"] * p; wsum += s["mult"]
|
| 244 |
+
manifold.append(dict(k=s["k"], mult=s["mult"], Pd=round(p, 8)))
|
| 245 |
+
print(f" GS in k={s['k']} x{s['mult']}: Pd={p:.6f}", flush=True)
|
| 246 |
+
s["S"] = None
|
| 247 |
+
res = dict(L=L, Ne=Ne, n=Ne / L ** 2, U=a.U, E0=E0, deg=wsum, R=list(R),
|
| 248 |
+
Pd=round(acc / wsum, 6), manifold=manifold,
|
| 249 |
+
sectors=[dict(k=s["k"], mult=s["mult"], E=[round(e, 8) for e in s["E"]]) for s in sec],
|
| 250 |
+
sec=round(time.time() - t0, 1))
|
| 251 |
+
print(json.dumps(res), flush=True)
|
| 252 |
+
if a.out:
|
| 253 |
+
json.dump(res, open(a.out, "w"), indent=1)
|
| 254 |
+
|
| 255 |
+
|
| 256 |
+
if __name__ == "__main__":
|
| 257 |
+
main()
|
methods/Yuseon84/code/ed_ksector_gpu.py
ADDED
|
@@ -0,0 +1,126 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# -*- coding: utf-8 -*-
|
| 2 |
+
"""GPU (torch/CUDA) matvec for the momentum-sector ED in ed_ksector.py.
|
| 3 |
+
|
| 4 |
+
Same basis, same npz output format (so CPU- and GPU-solved sectors can be combined with
|
| 5 |
+
`ed_ksector.py --combine`). ARPACK (scipy eigsh) stays on the CPU; only H*v runs on the GPU.
|
| 6 |
+
Complex sparse products are split into real ones for portability.
|
| 7 |
+
"""
|
| 8 |
+
import argparse, time
|
| 9 |
+
import numpy as np
|
| 10 |
+
import torch
|
| 11 |
+
from scipy.sparse.linalg import LinearOperator, eigsh
|
| 12 |
+
from ed_ksector import Sector, irreducible_k
|
| 13 |
+
|
| 14 |
+
DEV = torch.device("cuda")
|
| 15 |
+
|
| 16 |
+
|
| 17 |
+
def to_sparse(m):
|
| 18 |
+
m = m.tocsr()
|
| 19 |
+
return torch.sparse_csr_tensor(torch.from_numpy(m.indptr.astype(np.int64)),
|
| 20 |
+
torch.from_numpy(m.indices.astype(np.int64)),
|
| 21 |
+
torch.from_numpy(np.ascontiguousarray(m.data, dtype=np.float64)),
|
| 22 |
+
size=m.shape, device=DEV)
|
| 23 |
+
|
| 24 |
+
|
| 25 |
+
class GPUSector:
|
| 26 |
+
def __init__(self, S):
|
| 27 |
+
self.S = S
|
| 28 |
+
self.nR, self.dd = S.nR, S.dd
|
| 29 |
+
self.U = S.U
|
| 30 |
+
self.Dm = torch.from_numpy(S.Dm).to(DEV)
|
| 31 |
+
self.Td = to_sparse(S.Td)
|
| 32 |
+
self.up = []
|
| 33 |
+
for g, M in S.Up:
|
| 34 |
+
self.up.append((to_sparse(M.real), to_sparse(M.imag) if abs(M.imag).max() > 0 else None,
|
| 35 |
+
torch.from_numpy(S.sg_d[g]).to(DEV),
|
| 36 |
+
torch.from_numpy(S.img_d[g].astype(np.int64)).to(DEV)))
|
| 37 |
+
self.sym = [(ri, [(torch.from_numpy(src).to(DEV), torch.from_numpy(coef).to(DEV)) for src, coef in terms])
|
| 38 |
+
for ri, terms in S.sym]
|
| 39 |
+
self.sqS = torch.from_numpy(S.sqS).to(DEV)
|
| 40 |
+
|
| 41 |
+
def symm(self, F):
|
| 42 |
+
for ri, terms in self.sym:
|
| 43 |
+
acc = torch.zeros(self.dd, dtype=torch.complex128, device=DEV)
|
| 44 |
+
for src, coef in terms:
|
| 45 |
+
acc += coef * F[ri, src]
|
| 46 |
+
F[ri] = acc / len(terms)
|
| 47 |
+
return F
|
| 48 |
+
|
| 49 |
+
@staticmethod
|
| 50 |
+
def spmm(A, X): # real sparse x complex dense
|
| 51 |
+
return torch.complex(A @ X.real.contiguous(), A @ X.imag.contiguous())
|
| 52 |
+
|
| 53 |
+
def matvec_t(self, F):
|
| 54 |
+
F = self.symm(F / self.sqS[:, None])
|
| 55 |
+
out = self.U * self.Dm * F
|
| 56 |
+
out += self.spmm(self.Td, F.T.contiguous()).T
|
| 57 |
+
for Mr, Mi, sg, img in self.up:
|
| 58 |
+
X = F * sg[None, :]
|
| 59 |
+
Y = self.spmm(Mr, X)
|
| 60 |
+
if Mi is not None:
|
| 61 |
+
Y = Y + 1j * self.spmm(Mi, X)
|
| 62 |
+
out.index_add_(1, img, Y)
|
| 63 |
+
out = self.symm(out)
|
| 64 |
+
return out * self.sqS[:, None]
|
| 65 |
+
|
| 66 |
+
def matvec(self, v):
|
| 67 |
+
F = torch.from_numpy(np.ascontiguousarray(v.reshape(self.nR, self.dd))).to(DEV)
|
| 68 |
+
return self.matvec_t(F).cpu().numpy().ravel()
|
| 69 |
+
|
| 70 |
+
def solve(self, k=5, tol=1e-10, ncv=None):
|
| 71 |
+
n = self.nR * self.dd
|
| 72 |
+
H = LinearOperator((n, n), matvec=self.matvec, dtype=complex)
|
| 73 |
+
rng = np.random.default_rng(1)
|
| 74 |
+
v0 = rng.normal(size=n) + 1j * rng.normal(size=n)
|
| 75 |
+
v0 = (self.S.symm(v0.reshape(self.nR, self.dd) / self.S.sqS[:, None]) * self.S.sqS[:, None]).ravel()
|
| 76 |
+
w, V = eigsh(H, k=k, which="SA", tol=tol, v0=v0, ncv=ncv)
|
| 77 |
+
o = np.argsort(w)
|
| 78 |
+
return w[o], V[:, o]
|
| 79 |
+
|
| 80 |
+
|
| 81 |
+
def main():
|
| 82 |
+
ap = argparse.ArgumentParser()
|
| 83 |
+
ap.add_argument("--L", type=int, default=4)
|
| 84 |
+
ap.add_argument("--Ne", type=int, required=True)
|
| 85 |
+
ap.add_argument("--U", type=float, default=8.0)
|
| 86 |
+
ap.add_argument("--k", type=int, default=5)
|
| 87 |
+
ap.add_argument("--ncv", type=int, default=14)
|
| 88 |
+
ap.add_argument("--degen_tol", type=float, default=1e-7)
|
| 89 |
+
ap.add_argument("--sectors", default="all", help="comma list of irreducible-k indices, or 'all'")
|
| 90 |
+
ap.add_argument("--save", default="sectors")
|
| 91 |
+
ap.add_argument("--bench", action="store_true", help="time a few matvecs vs CPU and check agreement")
|
| 92 |
+
a = ap.parse_args()
|
| 93 |
+
ks = irreducible_k(a.L)
|
| 94 |
+
idx = range(len(ks)) if a.sectors == "all" else [int(x) for x in a.sectors.split(",")]
|
| 95 |
+
tag = f"L{a.L}_Ne{a.Ne}_U{a.U:g}"
|
| 96 |
+
for i in idx:
|
| 97 |
+
kv, mult = ks[i]
|
| 98 |
+
t0 = time.time()
|
| 99 |
+
S = Sector(a.L, a.Ne // 2, a.Ne // 2, a.U, kv)
|
| 100 |
+
G = GPUSector(S)
|
| 101 |
+
tb = time.time() - t0
|
| 102 |
+
if a.bench:
|
| 103 |
+
v = np.random.default_rng(0).normal(size=S.nR * S.dd) + 0j
|
| 104 |
+
v = (S.symm(v.reshape(S.nR, S.dd) / S.sqS[:, None]) * S.sqS[:, None]).ravel()
|
| 105 |
+
t1 = time.time(); c = S.matvec(v); tc = time.time() - t1
|
| 106 |
+
G.matvec(v); torch.cuda.synchronize()
|
| 107 |
+
t1 = time.time()
|
| 108 |
+
for _ in range(5):
|
| 109 |
+
g = G.matvec(v)
|
| 110 |
+
torch.cuda.synchronize(); tg = (time.time() - t1) / 5
|
| 111 |
+
print(f"k={kv} dim={S.nR*S.dd} build={tb:.0f}s CPU matvec {tc:.2f}s GPU matvec {tg:.3f}s "
|
| 112 |
+
f"max|diff|={np.abs(c-g).max():.2e}", flush=True)
|
| 113 |
+
continue
|
| 114 |
+
w, V = G.solve(k=a.k, ncv=a.ncv)
|
| 115 |
+
low = [j for j, e in enumerate(w) if abs(e - w[0]) < a.degen_tol * abs(w[0])]
|
| 116 |
+
np.savez(f"{a.save}/{tag}_k{kv[0]}{kv[1]}.npz", k=np.array(kv), mult=mult, E=w, V=V[:, low])
|
| 117 |
+
print(f"k={kv} x{mult} dim={S.nR*S.dd} nlow={len(low)} E={np.round(w,8).tolist()} "
|
| 118 |
+
f"({time.time()-t0:.0f}s, GPU)", flush=True)
|
| 119 |
+
if len(low) == len(w):
|
| 120 |
+
print(f"[warn] k={kv}: all {len(low)} eigenpairs degenerate; raise --k", flush=True)
|
| 121 |
+
del G, S, V
|
| 122 |
+
torch.cuda.empty_cache()
|
| 123 |
+
|
| 124 |
+
|
| 125 |
+
if __name__ == "__main__":
|
| 126 |
+
main()
|
methods/Yuseon84/code/pd_free.py
ADDED
|
@@ -0,0 +1,45 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# Free-fermion d-wave pair correlation on LxL periodic square lattice (Wick), to pin OSC normalization.
|
| 2 |
+
import numpy as np, itertools
|
| 3 |
+
def lattice(L):
|
| 4 |
+
N=L*L; idx=lambda x,y:(x%L)*L+(y%L); return N,idx
|
| 5 |
+
def orbitals(L):
|
| 6 |
+
ks=[(2*np.pi*a/L,2*np.pi*b/L) for a in range(L) for b in range(L)]
|
| 7 |
+
e=np.array([-2*(np.cos(kx)+np.cos(ky)) for kx,ky in ks])
|
| 8 |
+
return ks,e
|
| 9 |
+
def G_from(occ,L):
|
| 10 |
+
N,idx=lattice(L); ks,_=orbitals(L)
|
| 11 |
+
r=np.array([(x,y) for x in range(L) for y in range(L)])
|
| 12 |
+
phi=np.array([[np.exp(1j*(k[0]*x+k[1]*y))/np.sqrt(N) for (x,y) in r] for k in ks]) # [k,site]
|
| 13 |
+
P=phi[list(occ)]
|
| 14 |
+
return (P.conj().T@P) # G[a,b]=<c†_a c_b> = sum_k phi*_k(a) phi_k(b)
|
| 15 |
+
def Pd(Gu,Gd,L,R):
|
| 16 |
+
N,idx=lattice(L)
|
| 17 |
+
nb=[((1,0),1),((-1,0),1),((0,1),-1),((0,-1),-1)]
|
| 18 |
+
tot=0
|
| 19 |
+
for x in range(L):
|
| 20 |
+
for y in range(L):
|
| 21 |
+
i=idx(x,y); j=idx(x+R[0],y+R[1])
|
| 22 |
+
for (d,g) in nb:
|
| 23 |
+
for (dp,gp) in nb:
|
| 24 |
+
a=idx(x+d[0],y+d[1]); b=idx(x+R[0]+dp[0],y+R[1]+dp[1])
|
| 25 |
+
# singlet D_i = (1/sqrt2) sum_d g (c_i↑ c_{i+d}↓ - c_i↓ c_{i+d}↑)
|
| 26 |
+
# <D†_j D_i> = 1/2 sum g g' [Gu(j,i)Gd(b,a)+Gd(j,i)Gu(b,a)+Gu(b,a)Gd(j,i)... cross terms]
|
| 27 |
+
t = (Gu[j,i]*Gd[b,a] + Gu[b,a]*Gd[j,i] + Gu[j,a]*Gd[b,i] + Gu[b,i]*Gd[j,a])
|
| 28 |
+
tot += g*gp*t/2
|
| 29 |
+
return (tot/N).real
|
| 30 |
+
def shells(L):
|
| 31 |
+
ks,e=orbitals(L); order=np.argsort(e,kind='stable'); return e,order
|
| 32 |
+
def avg_Pd(L,Ne,R):
|
| 33 |
+
e,order=shells(L); n=Ne//2
|
| 34 |
+
es=np.round(e,8); levels=sorted(set(es))
|
| 35 |
+
full=[k for k in range(L*L) if es[k]<sorted(es)[n-1]]
|
| 36 |
+
top=[k for k in range(L*L) if es[k]==sorted(es)[n-1]]
|
| 37 |
+
m=n-len(full); combos=list(itertools.combinations(top,m))
|
| 38 |
+
vals=[]
|
| 39 |
+
for cu in combos:
|
| 40 |
+
Gu=G_from(full+list(cu),L)
|
| 41 |
+
for cd in combos:
|
| 42 |
+
Gd=G_from(full+list(cd),L); vals.append(Pd(Gu,Gd,L,R))
|
| 43 |
+
return np.mean(vals),len(combos)**2
|
| 44 |
+
for Ne,ref in [(8,0.046875),(10,0.09375),(12,0.041667),(14,0.010417),(16,0.0)]:
|
| 45 |
+
v,nd=avg_Pd(4,Ne,(2,2)); print(f"4x4 Ne={Ne:2d} n={Ne/16:.3f} P_free={v:.6f} ED_U0(org)={ref} ratio={ref/v if abs(v)>1e-12 else float('nan'):.4f} (#degenerate={nd})")
|
methods/Yuseon84/code/pd_free66.py
ADDED
|
@@ -0,0 +1,20 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import numpy as np, json
|
| 2 |
+
import os, sys
|
| 3 |
+
HERE = os.path.dirname(os.path.abspath(__file__))
|
| 4 |
+
exec(open(os.path.join(HERE, 'pd_free.py'), encoding='utf-8').read().split('for Ne,ref in')[0])
|
| 5 |
+
def avgG(L,n):
|
| 6 |
+
ks,e=orbitals(L); es=np.round(e,8); s=sorted(es); ef=s[n-1]
|
| 7 |
+
full=[k for k in range(L*L) if es[k]<ef]; top=[k for k in range(L*L) if es[k]==ef]
|
| 8 |
+
m=n-len(full)
|
| 9 |
+
return G_from(full,L)+(m/len(top))*G_from(top,L) if top else G_from(full,L), len(top), m
|
| 10 |
+
def Pd_avg(L,Ne,R):
|
| 11 |
+
G,d,m=avgG(L,Ne//2); return 0.5*Pd(G,G,L,R), d, m # 0.5 = OSC convention
|
| 12 |
+
# sanity: 4x4 must reproduce ED U=0
|
| 13 |
+
print("4x4 check:",[round(Pd_avg(4,Ne,(2,2))[0],6) for Ne in (8,10,12,14,16)])
|
| 14 |
+
# usage: python pd_free66.py [path/to/scoring_meta.json] (file from the OSC dataset)
|
| 15 |
+
meta=json.load(open(sys.argv[1] if len(sys.argv) > 1 else 'scoring_meta.json'))['A_by_Ne']
|
| 16 |
+
print(" Ne delta A_d(VMC,U=8) P_free(U=0) ratio shell")
|
| 17 |
+
for Ne in sorted(meta,key=int,reverse=True):
|
| 18 |
+
delta,Ad=meta[Ne]; Ne=int(Ne)
|
| 19 |
+
p,d,m=Pd_avg(6,Ne,(3,3))
|
| 20 |
+
print(f"{Ne:3d} {delta:6.4f} {Ad:9.5f} {p:9.5f} {Ad/p if abs(p)>1e-9 else float('nan'):6.2f} {m}/{d}")
|
methods/Yuseon84/code/vmc_dwave.py
ADDED
|
@@ -0,0 +1,353 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# -*- coding: utf-8 -*-
|
| 2 |
+
"""VMC for the 2D Hubbard model with a Jastrow-Gutzwiller x projected d-wave BCS (AGP) wavefunction.
|
| 3 |
+
|
| 4 |
+
Psi(x) = J(x) det M(x), M[i,j] = phi(r_i^up - r_j^dn)
|
| 5 |
+
phi(r) = (1/N) sum_k a_k cos(k.r), a_k = D_k / (xi_k + E_k)
|
| 6 |
+
D_k = Delta (cos kx - cos ky), xi_k = -2(cos kx + cos ky) - mu, E_k = sqrt(xi^2 + D_k^2)
|
| 7 |
+
log J = -g * D + sum_{i<j} v_c(ij) n_i n_j (D = double occupancy, c = distance class)
|
| 8 |
+
|
| 9 |
+
Labeled-electron first quantization: an in-place hop has matrix element -t with no extra sign.
|
| 10 |
+
P_d uses the OSC normalization (1/2 x standard singlet), see pd_free.py.
|
| 11 |
+
See PHASE2_VMC_DESIGN.md for the validation ladder.
|
| 12 |
+
"""
|
| 13 |
+
import argparse, json, time
|
| 14 |
+
import numpy as np
|
| 15 |
+
|
| 16 |
+
EPS_DK = 1e-6
|
| 17 |
+
|
| 18 |
+
|
| 19 |
+
class Lattice:
|
| 20 |
+
def __init__(self, L):
|
| 21 |
+
self.L, self.N = L, L * L
|
| 22 |
+
self.xy = np.array([(s // L, s % L) for s in range(self.N)])
|
| 23 |
+
self.nb = np.array([[((x + dx) % L) * L + (y + dy) % L for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1))]
|
| 24 |
+
for x, y in self.xy])
|
| 25 |
+
d = (self.xy[:, None, :] - self.xy[None, :, :]) % L # displacement table
|
| 26 |
+
self.dx, self.dy = d[..., 0], d[..., 1]
|
| 27 |
+
m = np.minimum(d, L - d)
|
| 28 |
+
cls = np.sort(m, axis=-1)
|
| 29 |
+
keys = sorted({tuple(c) for c in cls.reshape(-1, 2)} - {(0, 0)})
|
| 30 |
+
self.classes = keys
|
| 31 |
+
self.cls = np.full((self.N, self.N), -1)
|
| 32 |
+
for ci, kk in enumerate(keys):
|
| 33 |
+
self.cls[(cls[..., 0] == kk[0]) & (cls[..., 1] == kk[1])] = ci
|
| 34 |
+
self.site = lambda x, y: (x % L) * L + (y % L)
|
| 35 |
+
|
| 36 |
+
|
| 37 |
+
def phi_table(L, Delta, mu):
|
| 38 |
+
ks = 2 * np.pi * np.arange(L) / L
|
| 39 |
+
KX, KY = np.meshgrid(ks, ks, indexing="ij")
|
| 40 |
+
xi = -2 * (np.cos(KX) + np.cos(KY)) - mu
|
| 41 |
+
f = np.cos(KX) - np.cos(KY)
|
| 42 |
+
if abs(Delta) < 1e-12: # Fermi-sea limit (projected)
|
| 43 |
+
a = np.where(xi < -1e-9, 1.0, np.where(xi > 1e-9, 1e-8, 0.5))
|
| 44 |
+
else:
|
| 45 |
+
# nodal k (f=0): u_k=0 would make a_k infinite and M ill-conditioned; use half of the
|
| 46 |
+
# smallest non-zero lattice gap there instead (the orbital is still effectively filled).
|
| 47 |
+
fmin = np.min(np.abs(f[np.abs(f) > EPS_DK]))
|
| 48 |
+
Dk = Delta * np.where(np.abs(f) > EPS_DK, f, 0.5 * fmin)
|
| 49 |
+
a = Dk / (xi + np.sqrt(xi ** 2 + Dk ** 2))
|
| 50 |
+
a = a / np.max(np.abs(a))
|
| 51 |
+
X = np.arange(L)
|
| 52 |
+
# phi[dx,dy] = (1/N) sum_k a_k cos(kx dx + ky dy)
|
| 53 |
+
ph = np.einsum("ab,xa,yb->xy", a, np.cos(np.outer(X, ks)), np.cos(np.outer(X, ks))) \
|
| 54 |
+
- np.einsum("ab,xa,yb->xy", a, np.sin(np.outer(X, ks)), np.sin(np.outer(X, ks)))
|
| 55 |
+
return ph / (L * L)
|
| 56 |
+
|
| 57 |
+
|
| 58 |
+
class Walker:
|
| 59 |
+
def __init__(self, lat, n, par, rng, U):
|
| 60 |
+
self.lat, self.n, self.rng, self.U = lat, n, rng, U
|
| 61 |
+
self.set_params(par)
|
| 62 |
+
N = lat.N
|
| 63 |
+
while True:
|
| 64 |
+
self.up = rng.choice(N, n, replace=False)
|
| 65 |
+
self.dn = rng.choice(N, n, replace=False)
|
| 66 |
+
self.refresh()
|
| 67 |
+
if np.isfinite(self.Minv).all() and abs(np.linalg.det(self.M)) > 1e-300:
|
| 68 |
+
break
|
| 69 |
+
|
| 70 |
+
def set_params(self, par):
|
| 71 |
+
self.par = dict(par)
|
| 72 |
+
L = self.lat.L
|
| 73 |
+
self.phi = phi_table(L, par["Delta"], par["mu"])
|
| 74 |
+
v = np.asarray(par.get("v", np.zeros(len(self.lat.classes))))
|
| 75 |
+
self.V = np.where(self.lat.cls >= 0, v[np.maximum(self.lat.cls, 0)], 0.0)
|
| 76 |
+
self.g = par.get("g", 0.0)
|
| 77 |
+
|
| 78 |
+
def Mmat(self, up, dn):
|
| 79 |
+
lat = self.lat
|
| 80 |
+
return self.phi[lat.dx[np.ix_(up, dn)], lat.dy[np.ix_(up, dn)]]
|
| 81 |
+
|
| 82 |
+
def refresh(self):
|
| 83 |
+
N = self.lat.N
|
| 84 |
+
self.M = self.Mmat(self.up, self.dn)
|
| 85 |
+
self.Minv = np.linalg.inv(self.M)
|
| 86 |
+
self.nu = np.zeros(N); self.nu[self.up] = 1
|
| 87 |
+
self.nd = np.zeros(N); self.nd[self.dn] = 1
|
| 88 |
+
self.h = self.V @ (self.nu + self.nd)
|
| 89 |
+
|
| 90 |
+
# ---------- single moves ----------
|
| 91 |
+
def jas_ratio_log(self, a, b, spin):
|
| 92 |
+
other = self.nd if spin == 0 else self.nu
|
| 93 |
+
dD = other[b] - other[a]
|
| 94 |
+
return -self.g * dD + (self.h[b] - self.h[a] - self.V[a, b])
|
| 95 |
+
|
| 96 |
+
def step(self):
|
| 97 |
+
lat, n = self.lat, self.n
|
| 98 |
+
spin = self.rng.integers(2)
|
| 99 |
+
e = self.rng.integers(n)
|
| 100 |
+
if spin == 0:
|
| 101 |
+
a = self.up[e]; b = lat.nb[a, self.rng.integers(4)]
|
| 102 |
+
if self.nu[b]:
|
| 103 |
+
return False
|
| 104 |
+
row = self.phi[lat.dx[b, self.dn], lat.dy[b, self.dn]]
|
| 105 |
+
w = row @ self.Minv
|
| 106 |
+
q = w[e]
|
| 107 |
+
else:
|
| 108 |
+
a = self.dn[e]; b = lat.nb[a, self.rng.integers(4)]
|
| 109 |
+
if self.nd[b]:
|
| 110 |
+
return False
|
| 111 |
+
col = self.phi[lat.dx[self.up, b], lat.dy[self.up, b]]
|
| 112 |
+
z = self.Minv @ col
|
| 113 |
+
q = z[e]
|
| 114 |
+
r = q * np.exp(self.jas_ratio_log(a, b, spin))
|
| 115 |
+
if self.rng.random() >= r * r:
|
| 116 |
+
return False
|
| 117 |
+
if spin == 0:
|
| 118 |
+
w[e] -= 1.0
|
| 119 |
+
self.Minv -= np.outer(self.Minv[:, e], w) / q
|
| 120 |
+
self.M[e, :] = row
|
| 121 |
+
self.up[e] = b; self.nu[a] = 0; self.nu[b] = 1
|
| 122 |
+
else:
|
| 123 |
+
z[e] -= 1.0
|
| 124 |
+
self.Minv -= np.outer(z, self.Minv[e, :]) / q
|
| 125 |
+
self.M[:, e] = col
|
| 126 |
+
self.dn[e] = b; self.nd[a] = 0; self.nd[b] = 1
|
| 127 |
+
self.h += self.V[:, b] - self.V[:, a]
|
| 128 |
+
return True
|
| 129 |
+
|
| 130 |
+
def sweep(self, nsteps=None):
|
| 131 |
+
acc = 0
|
| 132 |
+
for _ in range(nsteps or 2 * self.n):
|
| 133 |
+
acc += self.step()
|
| 134 |
+
return acc
|
| 135 |
+
|
| 136 |
+
# ---------- estimators ----------
|
| 137 |
+
def local_energy(self):
|
| 138 |
+
lat = self.lat
|
| 139 |
+
D = float(self.nu @ self.nd)
|
| 140 |
+
kin = 0.0
|
| 141 |
+
# up hops: rows for all (alpha, neighbour)
|
| 142 |
+
tgt = lat.nb[self.up] # (n,4)
|
| 143 |
+
rows = self.phi[lat.dx[tgt[..., None], self.dn[None, None, :]],
|
| 144 |
+
lat.dy[tgt[..., None], self.dn[None, None, :]]] # (n,4,n)
|
| 145 |
+
q = np.einsum("anj,ja->an", rows, self.Minv)
|
| 146 |
+
src = np.repeat(self.up[:, None], 4, 1)
|
| 147 |
+
jl = -self.g * (self.nd[tgt] - self.nd[src]) + (self.h[tgt] - self.h[src] - self.V[src, tgt])
|
| 148 |
+
kin += np.sum(np.where(self.nu[tgt] == 0, q * np.exp(jl), 0.0))
|
| 149 |
+
tgt = lat.nb[self.dn]
|
| 150 |
+
cols = self.phi[lat.dx[self.up[None, None, :], tgt[..., None]],
|
| 151 |
+
lat.dy[self.up[None, None, :], tgt[..., None]]] # (n,4,n) [beta,nb,i]
|
| 152 |
+
q = np.einsum("bi,bni->bn", self.Minv, cols)
|
| 153 |
+
src = np.repeat(self.dn[:, None], 4, 1)
|
| 154 |
+
jl = -self.g * (self.nu[tgt] - self.nu[src]) + (self.h[tgt] - self.h[src] - self.V[src, tgt])
|
| 155 |
+
kin += np.sum(np.where(self.nd[tgt] == 0, q * np.exp(jl), 0.0))
|
| 156 |
+
return self.U * D - kin
|
| 157 |
+
|
| 158 |
+
def pair_terms(self, R):
|
| 159 |
+
"""Precompute (coef, p, p2, q, q2) for (1/N) sum_i <D+_{i+R} D_i>: move up p->p2, down q->q2."""
|
| 160 |
+
lat = self.lat
|
| 161 |
+
NB = [((1, 0), 1.0), ((-1, 0), 1.0), ((0, 1), -1.0), ((0, -1), -1.0)]
|
| 162 |
+
T = []
|
| 163 |
+
for (x, y) in lat.xy:
|
| 164 |
+
i = lat.site(x, y); j = lat.site(x + R[0], y + R[1])
|
| 165 |
+
for d, g in NB:
|
| 166 |
+
di = lat.site(x + d[0], y + d[1])
|
| 167 |
+
for dp, gp in NB:
|
| 168 |
+
dj = lat.site(x + R[0] + dp[0], y + R[1] + dp[1])
|
| 169 |
+
for (p, q) in ((i, di), (di, i)):
|
| 170 |
+
for (p2, q2) in ((j, dj), (dj, j)):
|
| 171 |
+
T.append((g * gp, p, p2, q, q2))
|
| 172 |
+
T = np.array(T)
|
| 173 |
+
return T[:, 0], T[:, 1:].astype(int)
|
| 174 |
+
|
| 175 |
+
def pair_corr(self, coef, idx):
|
| 176 |
+
"""OSC-normalized P_d(R) single-sample estimator (real part)."""
|
| 177 |
+
lat = self.lat
|
| 178 |
+
p, p2, q, q2 = idx.T
|
| 179 |
+
ok = (self.nu[p] == 1) & (self.nd[q] == 1) & (self.nu[p2] == 0) & (self.nd[q2] == 0)
|
| 180 |
+
if not ok.any():
|
| 181 |
+
return 0.0
|
| 182 |
+
c, p, p2, q, q2 = coef[ok], p[ok], p2[ok], q[ok], q2[ok]
|
| 183 |
+
eu = np.full(lat.N, -1); eu[self.up] = np.arange(self.n)
|
| 184 |
+
ed = np.full(lat.N, -1); ed[self.dn] = np.arange(self.n)
|
| 185 |
+
al, be = eu[p], ed[q]
|
| 186 |
+
# new row alpha (with the down electron beta already at q2), new column beta (up alpha at p2)
|
| 187 |
+
dn_new = np.repeat(self.dn[None, :], len(c), 0); dn_new[np.arange(len(c)), be] = q2
|
| 188 |
+
up_new = np.repeat(self.up[None, :], len(c), 0); up_new[np.arange(len(c)), al] = p2
|
| 189 |
+
Rn = self.phi[lat.dx[p2[:, None], dn_new], lat.dy[p2[:, None], dn_new]] # (T,n)
|
| 190 |
+
Cn = self.phi[lat.dx[up_new, q2[:, None]], lat.dy[up_new, q2[:, None]]] # (T,n)
|
| 191 |
+
a = Rn - self.M[al] # row change
|
| 192 |
+
b = Cn - self.M[:, be].T
|
| 193 |
+
b[np.arange(len(c)), al] = 0.0 # (al,be) set by row
|
| 194 |
+
Mi = self.Minv
|
| 195 |
+
x11 = np.einsum("tj,jt->t", a, Mi[:, al])
|
| 196 |
+
x22 = np.einsum("ti,ti->t", Mi[be], b)
|
| 197 |
+
x21 = Mi[be, al]
|
| 198 |
+
x12 = np.einsum("tj,jk,tk->t", a, Mi, b)
|
| 199 |
+
det_r = (1 + x11) * (1 + x22) - x12 * x21
|
| 200 |
+
# Jastrow: up p->p2 then down q->q2
|
| 201 |
+
V, h, g = self.V, self.h, self.g
|
| 202 |
+
j1 = -g * (self.nd[p2] - self.nd[p]) + (h[p2] - h[p] - V[p, p2])
|
| 203 |
+
nu2_q2 = self.nu[q2] - (q2 == p) + (q2 == p2)
|
| 204 |
+
nu2_q = self.nu[q] - (q == p) + (q == p2)
|
| 205 |
+
h2q2 = h[q2] - V[q2, p] + V[q2, p2]
|
| 206 |
+
h2q = h[q] - V[q, p] + V[q, p2]
|
| 207 |
+
j2 = -g * (nu2_q2 - nu2_q) + (h2q2 - h2q - V[q, q2])
|
| 208 |
+
val = np.sum(c * det_r * np.exp(j1 + j2))
|
| 209 |
+
return 0.25 * val / lat.N # 1/2 (sqrt2^2) x 1/2 (OSC normalization)
|
| 210 |
+
|
| 211 |
+
|
| 212 |
+
def unpack(theta, keys, base, nv):
|
| 213 |
+
par = dict(base); par["v"] = np.array(base.get("v", np.zeros(nv)), dtype=float)
|
| 214 |
+
for kname, val in zip(keys, theta):
|
| 215 |
+
if kname.startswith("v"):
|
| 216 |
+
par["v"][int(kname[1:])] = val
|
| 217 |
+
else:
|
| 218 |
+
par[kname] = val
|
| 219 |
+
return par
|
| 220 |
+
|
| 221 |
+
|
| 222 |
+
def log_derivs(w, keys, dphi):
|
| 223 |
+
"""O_k = d log Psi / d theta_k for the current configuration."""
|
| 224 |
+
lat = w.lat
|
| 225 |
+
n = w.nu + w.nd
|
| 226 |
+
out = []
|
| 227 |
+
for kname in keys:
|
| 228 |
+
if kname == "g":
|
| 229 |
+
out.append(-float(w.nu @ w.nd))
|
| 230 |
+
elif kname.startswith("v"):
|
| 231 |
+
c = int(kname[1:])
|
| 232 |
+
out.append(0.5 * float(n @ (lat.cls == c) @ n))
|
| 233 |
+
else:
|
| 234 |
+
dM = dphi[kname][lat.dx[np.ix_(w.up, w.dn)], lat.dy[np.ix_(w.up, w.dn)]]
|
| 235 |
+
out.append(float(np.sum(w.Minv.T * dM)))
|
| 236 |
+
return np.array(out)
|
| 237 |
+
|
| 238 |
+
|
| 239 |
+
def optimize(L, Ne, U, par0, keys, n_iter=150, nsamp=1500, ntherm=150, lr=0.05, seed=0, log=None,
|
| 240 |
+
eps_rel=0.05, eps_abs=1e-3):
|
| 241 |
+
"""Stochastic reconfiguration on the parameters named in `keys` (Delta, mu, g, v0..)."""
|
| 242 |
+
lat = Lattice(L)
|
| 243 |
+
nv = len(lat.classes)
|
| 244 |
+
rng = np.random.default_rng(seed)
|
| 245 |
+
theta = np.array([unpack([], [], par0, nv)[k] if not k.startswith("v")
|
| 246 |
+
else np.asarray(par0.get("v", np.zeros(nv)))[int(k[1:])] for k in keys], float)
|
| 247 |
+
w = Walker(lat, Ne // 2, unpack(theta, keys, par0, nv), rng, U)
|
| 248 |
+
for s in range(ntherm):
|
| 249 |
+
w.sweep()
|
| 250 |
+
hist = []
|
| 251 |
+
for it in range(n_iter):
|
| 252 |
+
par = unpack(theta, keys, par0, nv)
|
| 253 |
+
w.set_params(par); w.refresh()
|
| 254 |
+
h = 1e-5
|
| 255 |
+
dphi = {}
|
| 256 |
+
for kname in keys:
|
| 257 |
+
if kname in ("Delta", "mu"):
|
| 258 |
+
pp, pm = dict(par), dict(par); pp[kname] += h; pm[kname] -= h
|
| 259 |
+
dphi[kname] = (phi_table(L, pp["Delta"], pp["mu"]) - phi_table(L, pm["Delta"], pm["mu"])) / (2 * h)
|
| 260 |
+
for s in range(20):
|
| 261 |
+
w.sweep()
|
| 262 |
+
Es, Os = [], []
|
| 263 |
+
for s in range(nsamp):
|
| 264 |
+
w.sweep()
|
| 265 |
+
if s % 20 == 0:
|
| 266 |
+
w.refresh()
|
| 267 |
+
Es.append(w.local_energy()); Os.append(log_derivs(w, keys, dphi))
|
| 268 |
+
E, O = np.array(Es), np.array(Os)
|
| 269 |
+
Om = O.mean(0)
|
| 270 |
+
S = (O - Om).T @ (O - Om) / len(E)
|
| 271 |
+
F = ((E - E.mean())[:, None] * (O - Om)).mean(0)
|
| 272 |
+
S += np.diag(eps_rel * np.diag(S) + eps_abs)
|
| 273 |
+
dth = -lr * np.linalg.solve(S, F)
|
| 274 |
+
theta = theta + dth
|
| 275 |
+
if "Delta" in keys: # +Delta and -Delta give the same state (global sign)
|
| 276 |
+
i = keys.index("Delta"); theta[i] = abs(theta[i])
|
| 277 |
+
rec = dict(it=it, E=float(E.mean()), dE=float(E.std() / np.sqrt(len(E))),
|
| 278 |
+
theta=[round(float(x), 5) for x in theta])
|
| 279 |
+
hist.append(rec)
|
| 280 |
+
if log:
|
| 281 |
+
print(json.dumps(rec), file=log, flush=True)
|
| 282 |
+
tail = np.array([r["theta"] for r in hist[2 * n_iter // 3:]])
|
| 283 |
+
theta_avg = tail.mean(0)
|
| 284 |
+
return unpack(theta_avg, keys, par0, nv), hist
|
| 285 |
+
|
| 286 |
+
|
| 287 |
+
def run(L, Ne, U, par, nsamp, nthermal, seed, R=None, every=1):
|
| 288 |
+
lat = Lattice(L)
|
| 289 |
+
rng = np.random.default_rng(seed)
|
| 290 |
+
w = Walker(lat, Ne // 2, par, rng, U)
|
| 291 |
+
for s in range(nthermal):
|
| 292 |
+
w.sweep()
|
| 293 |
+
if s % 20 == 0:
|
| 294 |
+
w.refresh()
|
| 295 |
+
R = R or (L // 2, L // 2)
|
| 296 |
+
coef, idx = w.pair_terms(R)
|
| 297 |
+
E, P = [], []
|
| 298 |
+
acc = 0
|
| 299 |
+
for s in range(nsamp):
|
| 300 |
+
acc += w.sweep()
|
| 301 |
+
if s % 20 == 0:
|
| 302 |
+
w.refresh()
|
| 303 |
+
E.append(w.local_energy())
|
| 304 |
+
if s % every == 0:
|
| 305 |
+
P.append(w.pair_corr(coef, idx))
|
| 306 |
+
E, P = np.array(E), np.array(P)
|
| 307 |
+
|
| 308 |
+
def err(x, nb=20):
|
| 309 |
+
b = x[: len(x) // nb * nb].reshape(nb, -1).mean(1)
|
| 310 |
+
return b.std(ddof=1) / np.sqrt(nb)
|
| 311 |
+
return dict(E=E.mean(), dE=err(E), varE=E.var(), Pd=P.mean(), dPd=err(P),
|
| 312 |
+
acc=acc / (nsamp * 2 * (Ne // 2)))
|
| 313 |
+
|
| 314 |
+
|
| 315 |
+
def main():
|
| 316 |
+
ap = argparse.ArgumentParser()
|
| 317 |
+
ap.add_argument("--L", type=int, default=6)
|
| 318 |
+
ap.add_argument("--Ne", type=int, default=26)
|
| 319 |
+
ap.add_argument("--U", type=float, default=8.0)
|
| 320 |
+
ap.add_argument("--Delta", type=float, default=0.15)
|
| 321 |
+
ap.add_argument("--mu", type=float, default=0.0)
|
| 322 |
+
ap.add_argument("--g", type=float, default=0.0)
|
| 323 |
+
ap.add_argument("--nsamp", type=int, default=2000)
|
| 324 |
+
ap.add_argument("--ntherm", type=int, default=200)
|
| 325 |
+
ap.add_argument("--seed", type=int, default=0)
|
| 326 |
+
ap.add_argument("--opt", default="", help="comma list of params to optimize, e.g. Delta,mu,g,jas")
|
| 327 |
+
ap.add_argument("--iters", type=int, default=150)
|
| 328 |
+
ap.add_argument("--nsamp_opt", type=int, default=1500)
|
| 329 |
+
ap.add_argument("--lr", type=float, default=0.1)
|
| 330 |
+
ap.add_argument("--out", default="")
|
| 331 |
+
a = ap.parse_args()
|
| 332 |
+
t0 = time.time()
|
| 333 |
+
par = dict(Delta=a.Delta, mu=a.mu, g=a.g)
|
| 334 |
+
hist = []
|
| 335 |
+
if a.opt:
|
| 336 |
+
nv = len(Lattice(a.L).classes)
|
| 337 |
+
keys = []
|
| 338 |
+
for kname in a.opt.split(","):
|
| 339 |
+
keys += [f"v{c}" for c in range(nv)] if kname == "jas" else [kname]
|
| 340 |
+
log = open(a.out.replace(".json", ".opt.log"), "w") if a.out else None
|
| 341 |
+
par, hist = optimize(a.L, a.Ne, a.U, par, keys, a.iters, a.nsamp_opt, a.ntherm, a.lr, a.seed, log)
|
| 342 |
+
r = run(a.L, a.Ne, a.U, par, a.nsamp, a.ntherm, a.seed + 1000)
|
| 343 |
+
r = {k: float(v) for k, v in r.items()}
|
| 344 |
+
r.update(L=a.L, Ne=a.Ne, U=a.U, opt=a.opt,
|
| 345 |
+
par={k: (np.round(v, 5).tolist() if isinstance(v, np.ndarray) else round(float(v), 5)) for k, v in par.items()},
|
| 346 |
+
sec=round(time.time() - t0, 1))
|
| 347 |
+
print(json.dumps(r))
|
| 348 |
+
if a.out:
|
| 349 |
+
json.dump(dict(result=r, hist=hist), open(a.out, "w"), indent=1)
|
| 350 |
+
|
| 351 |
+
|
| 352 |
+
if __name__ == "__main__":
|
| 353 |
+
main()
|
methods/Yuseon84/code/vmc_gpu.py
ADDED
|
@@ -0,0 +1,324 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# -*- coding: utf-8 -*-
|
| 2 |
+
"""Batched-walker GPU (torch/CUDA) version of vmc_dwave.py — same wavefunction, estimators and
|
| 3 |
+
output format, with B independent Markov chains advanced in lock-step.
|
| 4 |
+
|
| 5 |
+
A sweep = n up-electron moves then n down-electron moves (random electron, random neighbour),
|
| 6 |
+
each a symmetric proposal accepted with |Psi'/Psi|^2. Error bars come from per-walker means
|
| 7 |
+
(walkers are independent), so no blocking is needed.
|
| 8 |
+
"""
|
| 9 |
+
import argparse, json, time
|
| 10 |
+
import numpy as np
|
| 11 |
+
import torch
|
| 12 |
+
from vmc_dwave import Lattice, phi_table
|
| 13 |
+
|
| 14 |
+
DEV = torch.device("cuda")
|
| 15 |
+
DT = torch.float64
|
| 16 |
+
|
| 17 |
+
|
| 18 |
+
class BatchVMC:
|
| 19 |
+
def __init__(self, L, Ne, U, par, B, seed):
|
| 20 |
+
self.lat = Lattice(L)
|
| 21 |
+
self.L, self.N, self.n, self.U, self.B = L, L * L, Ne // 2, U, B
|
| 22 |
+
self.gen = torch.Generator(device=DEV); self.gen.manual_seed(seed)
|
| 23 |
+
lat = self.lat
|
| 24 |
+
self.nb = torch.tensor(lat.nb, device=DEV)
|
| 25 |
+
self.cls = torch.tensor(lat.cls, device=DEV)
|
| 26 |
+
C = len(lat.classes)
|
| 27 |
+
self.Cmat = torch.stack([(self.cls == c).to(DT) for c in range(C)]) # (C,N,N)
|
| 28 |
+
self.ar = torch.arange(B, device=DEV)
|
| 29 |
+
self.set_params(par)
|
| 30 |
+
self.init_walkers()
|
| 31 |
+
|
| 32 |
+
# ---------------- parameters ----------------
|
| 33 |
+
def phi_sites(self, Delta, mu):
|
| 34 |
+
ph = torch.tensor(phi_table(self.L, Delta, mu), dtype=DT, device=DEV)
|
| 35 |
+
dx = torch.tensor(self.lat.dx, device=DEV); dy = torch.tensor(self.lat.dy, device=DEV)
|
| 36 |
+
return ph[dx, dy] # (N,N): phi(r_a - r_b)
|
| 37 |
+
|
| 38 |
+
def set_params(self, par):
|
| 39 |
+
self.par = dict(par)
|
| 40 |
+
self.PHI = self.phi_sites(par["Delta"], par["mu"])
|
| 41 |
+
v = torch.tensor(np.asarray(par.get("v", np.zeros(len(self.lat.classes)))), dtype=DT, device=DEV)
|
| 42 |
+
self.V = torch.where(self.cls >= 0, v[self.cls.clamp(min=0)], torch.zeros((), dtype=DT, device=DEV))
|
| 43 |
+
self.g = float(par.get("g", 0.0))
|
| 44 |
+
|
| 45 |
+
# ---------------- walkers ----------------
|
| 46 |
+
def rand_conf(self, m):
|
| 47 |
+
k = torch.rand(m, self.N, generator=self.gen, device=DEV).argsort(1)[:, : self.n]
|
| 48 |
+
return k
|
| 49 |
+
|
| 50 |
+
def init_walkers(self):
|
| 51 |
+
B = self.B
|
| 52 |
+
self.up = self.rand_conf(B); self.dn = self.rand_conf(B)
|
| 53 |
+
for _ in range(50):
|
| 54 |
+
self.refresh()
|
| 55 |
+
bad = ~torch.isfinite(self.Minv).all(-1).all(-1) | (torch.linalg.det(self.M).abs() < 1e-200)
|
| 56 |
+
if not bad.any():
|
| 57 |
+
break
|
| 58 |
+
nb_ = int(bad.sum())
|
| 59 |
+
self.up[bad] = self.rand_conf(nb_); self.dn[bad] = self.rand_conf(nb_)
|
| 60 |
+
self.refresh()
|
| 61 |
+
|
| 62 |
+
def refresh(self):
|
| 63 |
+
B, N = self.B, self.N
|
| 64 |
+
self.M = self.PHI[self.up[:, :, None], self.dn[:, None, :]]
|
| 65 |
+
self.Minv, info = torch.linalg.inv_ex(self.M)
|
| 66 |
+
bad = (info != 0) | ~torch.isfinite(self.Minv).all(-1).all(-1)
|
| 67 |
+
if bad.any() and not bad.all():
|
| 68 |
+
# walkers sitting on a node of the (new) wavefunction have zero weight: replace each by
|
| 69 |
+
# a copy of a random healthy walker
|
| 70 |
+
good = torch.nonzero(~bad).squeeze(1)
|
| 71 |
+
src = good[torch.randint(0, len(good), (int(bad.sum()),), generator=self.gen, device=DEV)]
|
| 72 |
+
self.up[bad] = self.up[src]; self.dn[bad] = self.dn[src]
|
| 73 |
+
self.M = self.PHI[self.up[:, :, None], self.dn[:, None, :]]
|
| 74 |
+
self.Minv, info = torch.linalg.inv_ex(self.M)
|
| 75 |
+
self.nu = torch.zeros(B, N, dtype=DT, device=DEV); self.nu.scatter_(1, self.up, 1.0)
|
| 76 |
+
self.nd = torch.zeros(B, N, dtype=DT, device=DEV); self.nd.scatter_(1, self.dn, 1.0)
|
| 77 |
+
self.h = (self.nu + self.nd) @ self.V
|
| 78 |
+
|
| 79 |
+
def _rand(self, hi):
|
| 80 |
+
return torch.randint(0, hi, (self.B,), generator=self.gen, device=DEV)
|
| 81 |
+
|
| 82 |
+
def step(self, spin):
|
| 83 |
+
ar, n = self.ar, self.n
|
| 84 |
+
e = self._rand(n); d = self._rand(4)
|
| 85 |
+
pos, same, other = (self.up, self.nu, self.nd) if spin == 0 else (self.dn, self.nd, self.nu)
|
| 86 |
+
a = pos[ar, e]; t = self.nb[a, d]
|
| 87 |
+
blocked = same[ar, t] > 0.5
|
| 88 |
+
if spin == 0:
|
| 89 |
+
vec = self.PHI[t[:, None], self.dn] # new row
|
| 90 |
+
w = torch.einsum("bj,bjk->bk", vec, self.Minv)
|
| 91 |
+
else:
|
| 92 |
+
vec = self.PHI[self.up, t[:, None]] # new column
|
| 93 |
+
w = torch.einsum("bij,bj->bi", self.Minv, vec)
|
| 94 |
+
q = w[ar, e]
|
| 95 |
+
dJ = -self.g * (other[ar, t] - other[ar, a]) + self.h[ar, t] - self.h[ar, a] - self.V[a, t]
|
| 96 |
+
r = q * torch.exp(dJ)
|
| 97 |
+
acc = (torch.rand(self.B, generator=self.gen, device=DEV, dtype=DT) < r * r) & ~blocked
|
| 98 |
+
idx = torch.nonzero(acc).squeeze(1)
|
| 99 |
+
if idx.numel() == 0:
|
| 100 |
+
return 0
|
| 101 |
+
ei, wi, qi = e[idx], w[idx].clone(), q[idx]
|
| 102 |
+
wi[torch.arange(len(idx), device=DEV), ei] -= 1.0
|
| 103 |
+
if spin == 0:
|
| 104 |
+
self.Minv[idx] -= self.Minv[idx, :, ei][:, :, None] * wi[:, None, :] / qi[:, None, None]
|
| 105 |
+
self.M[idx, ei, :] = vec[idx]
|
| 106 |
+
self.up[idx, ei] = t[idx]
|
| 107 |
+
self.nu[idx, a[idx]] = 0.0; self.nu[idx, t[idx]] = 1.0
|
| 108 |
+
else:
|
| 109 |
+
self.Minv[idx] -= wi[:, :, None] * self.Minv[idx, ei, :][:, None, :] / qi[:, None, None]
|
| 110 |
+
self.M[idx, :, ei] = vec[idx]
|
| 111 |
+
self.dn[idx, ei] = t[idx]
|
| 112 |
+
self.nd[idx, a[idx]] = 0.0; self.nd[idx, t[idx]] = 1.0
|
| 113 |
+
self.h[idx] += self.V[t[idx]] - self.V[a[idx]]
|
| 114 |
+
return len(idx)
|
| 115 |
+
|
| 116 |
+
def sweep(self):
|
| 117 |
+
acc = 0
|
| 118 |
+
for spin in (0, 1):
|
| 119 |
+
for _ in range(self.n):
|
| 120 |
+
acc += self.step(spin)
|
| 121 |
+
return acc / (2 * self.n * self.B)
|
| 122 |
+
|
| 123 |
+
# ---------------- estimators ----------------
|
| 124 |
+
def local_energy(self):
|
| 125 |
+
nu, nd, h, V, g, Mi, P = self.nu, self.nd, self.h, self.V, self.g, self.Minv, self.PHI
|
| 126 |
+
bi = self.ar[:, None, None]
|
| 127 |
+
D = (nu * nd).sum(1)
|
| 128 |
+
tgt = self.nb[self.up] # (B,n,4)
|
| 129 |
+
rows = P[tgt[..., None], self.dn[:, None, None, :]] # (B,n,4,n)
|
| 130 |
+
q = torch.einsum("banj,bja->ban", rows, Mi)
|
| 131 |
+
src = self.up[:, :, None].expand_as(tgt)
|
| 132 |
+
jl = -g * (nd[bi, tgt] - nd[bi, src]) + h[bi, tgt] - h[bi, src] - V[src, tgt]
|
| 133 |
+
kin = torch.where(nu[bi, tgt] < 0.5, q * torch.exp(jl), torch.zeros_like(q)).sum((1, 2))
|
| 134 |
+
tgt = self.nb[self.dn]
|
| 135 |
+
cols = P[self.up[:, None, None, :], tgt[..., None]] # (B,n,4,n) [b,beta,k,i]
|
| 136 |
+
q = torch.einsum("bmi,bmki->bmk", Mi, cols)
|
| 137 |
+
src = self.dn[:, :, None].expand_as(tgt)
|
| 138 |
+
jl = -g * (nu[bi, tgt] - nu[bi, src]) + h[bi, tgt] - h[bi, src] - V[src, tgt]
|
| 139 |
+
kin = kin + torch.where(nd[bi, tgt] < 0.5, q * torch.exp(jl), torch.zeros_like(q)).sum((1, 2))
|
| 140 |
+
return self.U * D - kin
|
| 141 |
+
|
| 142 |
+
def pair_terms(self, R):
|
| 143 |
+
lat = self.lat
|
| 144 |
+
NB = [((1, 0), 1.0), ((-1, 0), 1.0), ((0, 1), -1.0), ((0, -1), -1.0)]
|
| 145 |
+
T = []
|
| 146 |
+
for (x, y) in lat.xy:
|
| 147 |
+
i = lat.site(x, y); j = lat.site(x + R[0], y + R[1])
|
| 148 |
+
for d, g in NB:
|
| 149 |
+
di = lat.site(x + d[0], y + d[1])
|
| 150 |
+
for dp, gp in NB:
|
| 151 |
+
dj = lat.site(x + R[0] + dp[0], y + R[1] + dp[1])
|
| 152 |
+
for (p, q) in ((i, di), (di, i)):
|
| 153 |
+
for (p2, q2) in ((j, dj), (dj, j)):
|
| 154 |
+
T.append((g * gp, p, p2, q, q2))
|
| 155 |
+
T = np.array(T)
|
| 156 |
+
self.pc = torch.tensor(T[:, 0], dtype=DT, device=DEV)
|
| 157 |
+
self.pidx = torch.tensor(T[:, 1:].astype(np.int64), device=DEV)
|
| 158 |
+
|
| 159 |
+
def pair_corr(self, chunk=128):
|
| 160 |
+
"""OSC-normalized P_d(R) per walker, shape (B,)."""
|
| 161 |
+
out = torch.zeros(self.B, dtype=DT, device=DEV)
|
| 162 |
+
p, p2, q, q2 = self.pidx.T
|
| 163 |
+
n, T = self.n, len(self.pc)
|
| 164 |
+
ar_n = torch.arange(n, device=DEV)
|
| 165 |
+
for s in range(0, self.B, chunk):
|
| 166 |
+
sl = slice(s, min(s + chunk, self.B)); b = sl.stop - sl.start
|
| 167 |
+
nu, nd, up, dn = self.nu[sl], self.nd[sl], self.up[sl], self.dn[sl]
|
| 168 |
+
M, Mi, h = self.M[sl], self.Minv[sl], self.h[sl]
|
| 169 |
+
ok = (nu[:, p] > 0.5) & (nd[:, q] > 0.5) & (nu[:, p2] < 0.5) & (nd[:, q2] < 0.5) # (b,T)
|
| 170 |
+
eu = torch.full((b, self.N), 0, dtype=torch.long, device=DEV); eu.scatter_(1, up, ar_n.expand(b, n))
|
| 171 |
+
ed = torch.full((b, self.N), 0, dtype=torch.long, device=DEV); ed.scatter_(1, dn, ar_n.expand(b, n))
|
| 172 |
+
al, be = eu[:, p], ed[:, q] # (b,T)
|
| 173 |
+
dn_new = torch.where(ar_n[None, None, :] == be[..., None], q2[None, :, None], dn[:, None, :])
|
| 174 |
+
up_new = torch.where(ar_n[None, None, :] == al[..., None], p2[None, :, None], up[:, None, :])
|
| 175 |
+
Rn = self.PHI[p2[None, :, None], dn_new] # (b,T,n)
|
| 176 |
+
Cn = self.PHI[up_new, q2[None, :, None]]
|
| 177 |
+
a = Rn - torch.gather(M, 1, al[..., None].expand(-1, -1, n))
|
| 178 |
+
bv = Cn - torch.gather(M.transpose(1, 2), 1, be[..., None].expand(-1, -1, n))
|
| 179 |
+
bv = bv.scatter(2, al[..., None], 0.0)
|
| 180 |
+
col_al = torch.gather(Mi.transpose(1, 2), 1, al[..., None].expand(-1, -1, n)) # Minv[:,al]
|
| 181 |
+
row_be = torch.gather(Mi, 1, be[..., None].expand(-1, -1, n)) # Minv[be,:]
|
| 182 |
+
x11 = (a * col_al).sum(-1)
|
| 183 |
+
x22 = (row_be * bv).sum(-1)
|
| 184 |
+
x21 = torch.gather(row_be, 2, al[..., None]).squeeze(-1)
|
| 185 |
+
x12 = (torch.bmm(a, Mi) * bv).sum(-1)
|
| 186 |
+
det_r = (1 + x11) * (1 + x22) - x12 * x21
|
| 187 |
+
V, g = self.V, self.g
|
| 188 |
+
j1 = -g * (nd[:, p2] - nd[:, p]) + h[:, p2] - h[:, p] - V[p, p2]
|
| 189 |
+
nu2_q2 = nu[:, q2] - (q2 == p).to(DT) + (q2 == p2).to(DT)
|
| 190 |
+
nu2_q = nu[:, q] - (q == p).to(DT) + (q == p2).to(DT)
|
| 191 |
+
h2q2 = h[:, q2] - V[q2, p] + V[q2, p2]
|
| 192 |
+
h2q = h[:, q] - V[q, p] + V[q, p2]
|
| 193 |
+
j2 = -g * (nu2_q2 - nu2_q) + (h2q2 - h2q - V[q, q2])
|
| 194 |
+
val = torch.where(ok, self.pc * det_r * torch.exp(j1 + j2), torch.zeros_like(det_r)).sum(1)
|
| 195 |
+
out[sl] = 0.25 * val / self.N
|
| 196 |
+
return out
|
| 197 |
+
|
| 198 |
+
def log_derivs(self, keys, dPHI):
|
| 199 |
+
cols = []
|
| 200 |
+
ntot = self.nu + self.nd
|
| 201 |
+
for k in keys:
|
| 202 |
+
if k == "g":
|
| 203 |
+
cols.append(-(self.nu * self.nd).sum(1))
|
| 204 |
+
elif k.startswith("v"):
|
| 205 |
+
c = int(k[1:])
|
| 206 |
+
cols.append(0.5 * torch.einsum("bi,ij,bj->b", ntot, self.Cmat[c], ntot))
|
| 207 |
+
else:
|
| 208 |
+
dM = dPHI[k][self.up[:, :, None], self.dn[:, None, :]]
|
| 209 |
+
cols.append((self.Minv.transpose(1, 2) * dM).sum((1, 2)))
|
| 210 |
+
return torch.stack(cols, 1)
|
| 211 |
+
|
| 212 |
+
|
| 213 |
+
def unpack(theta, keys, base, nv):
|
| 214 |
+
par = dict(base); par["v"] = np.array(base.get("v", np.zeros(nv)), dtype=float)
|
| 215 |
+
for k, val in zip(keys, theta):
|
| 216 |
+
if k.startswith("v"):
|
| 217 |
+
par["v"][int(k[1:])] = val
|
| 218 |
+
else:
|
| 219 |
+
par[k] = float(val)
|
| 220 |
+
return par
|
| 221 |
+
|
| 222 |
+
|
| 223 |
+
def optimize(vm, par0, keys, n_iter, nmeas, lr, log=None, eps_rel=0.05, eps_abs=1e-3, gap=2):
|
| 224 |
+
nv = len(vm.lat.classes)
|
| 225 |
+
theta = np.array([par0[k] if not k.startswith("v") else np.asarray(par0.get("v", np.zeros(nv)))[int(k[1:])]
|
| 226 |
+
for k in keys], float)
|
| 227 |
+
hist = []
|
| 228 |
+
for it in range(n_iter):
|
| 229 |
+
par = unpack(theta, keys, par0, nv)
|
| 230 |
+
vm.set_params(par); vm.refresh()
|
| 231 |
+
h = 1e-5
|
| 232 |
+
dPHI = {}
|
| 233 |
+
for k in keys:
|
| 234 |
+
if k in ("Delta", "mu"):
|
| 235 |
+
pp, pm = dict(par), dict(par); pp[k] += h; pm[k] -= h
|
| 236 |
+
dPHI[k] = (vm.phi_sites(pp["Delta"], pp["mu"]) - vm.phi_sites(pm["Delta"], pm["mu"])) / (2 * h)
|
| 237 |
+
for _ in range(3):
|
| 238 |
+
vm.sweep()
|
| 239 |
+
Es, Os = [], []
|
| 240 |
+
for m in range(nmeas):
|
| 241 |
+
for _ in range(gap):
|
| 242 |
+
vm.sweep()
|
| 243 |
+
vm.refresh()
|
| 244 |
+
Es.append(vm.local_energy()); Os.append(vm.log_derivs(keys, dPHI))
|
| 245 |
+
E = torch.cat(Es); O = torch.cat(Os)
|
| 246 |
+
Om = O.mean(0)
|
| 247 |
+
S = ((O - Om).T @ (O - Om) / len(E)).cpu().numpy()
|
| 248 |
+
F = (((E - E.mean())[:, None] * (O - Om)).mean(0)).cpu().numpy()
|
| 249 |
+
S += np.diag(eps_rel * np.diag(S) + eps_abs)
|
| 250 |
+
theta = theta - lr * np.linalg.solve(S, F)
|
| 251 |
+
if "Delta" in keys:
|
| 252 |
+
i = keys.index("Delta"); theta[i] = abs(theta[i])
|
| 253 |
+
rec = dict(it=it, E=float(E.mean()), dE=float(E.std() / np.sqrt(len(E))),
|
| 254 |
+
theta=[round(float(x), 5) for x in theta])
|
| 255 |
+
hist.append(rec)
|
| 256 |
+
if log:
|
| 257 |
+
print(json.dumps(rec), file=log, flush=True)
|
| 258 |
+
tail = np.array([r["theta"] for r in hist[2 * n_iter // 3:]])
|
| 259 |
+
return unpack(tail.mean(0), keys, par0, nv), hist
|
| 260 |
+
|
| 261 |
+
|
| 262 |
+
def measure(vm, nmeas, gap=2, R=None):
|
| 263 |
+
R = R or (vm.L // 2, vm.L // 2)
|
| 264 |
+
vm.pair_terms(R)
|
| 265 |
+
Es, Ps, acc = [], [], []
|
| 266 |
+
for m in range(nmeas):
|
| 267 |
+
for _ in range(gap):
|
| 268 |
+
acc.append(vm.sweep())
|
| 269 |
+
vm.refresh()
|
| 270 |
+
Es.append(vm.local_energy()); Ps.append(vm.pair_corr())
|
| 271 |
+
E = torch.stack(Es, 1); P = torch.stack(Ps, 1) # (B, nmeas)
|
| 272 |
+
Ew, Pw = E.mean(1), P.mean(1) # per-walker means (independent)
|
| 273 |
+
sq = np.sqrt(vm.B)
|
| 274 |
+
return dict(E=float(Ew.mean()), dE=float(Ew.std() / sq), varE=float(E.var()),
|
| 275 |
+
Pd=float(Pw.mean()), dPd=float(Pw.std() / sq), acc=float(np.mean(acc)))
|
| 276 |
+
|
| 277 |
+
|
| 278 |
+
def main():
|
| 279 |
+
ap = argparse.ArgumentParser()
|
| 280 |
+
ap.add_argument("--L", type=int, default=6)
|
| 281 |
+
ap.add_argument("--Ne", type=int, default=26)
|
| 282 |
+
ap.add_argument("--U", type=float, default=8.0)
|
| 283 |
+
ap.add_argument("--Delta", type=float, default=0.15)
|
| 284 |
+
ap.add_argument("--mu", type=float, default=0.0)
|
| 285 |
+
ap.add_argument("--g", type=float, default=0.0)
|
| 286 |
+
ap.add_argument("--walkers", type=int, default=2048)
|
| 287 |
+
ap.add_argument("--ntherm", type=int, default=100, help="thermalization sweeps")
|
| 288 |
+
ap.add_argument("--nmeas", type=int, default=20, help="measurement rounds (x walkers = samples)")
|
| 289 |
+
ap.add_argument("--opt", default="")
|
| 290 |
+
ap.add_argument("--iters", type=int, default=150)
|
| 291 |
+
ap.add_argument("--nmeas_opt", type=int, default=2)
|
| 292 |
+
ap.add_argument("--lr", type=float, default=0.05)
|
| 293 |
+
ap.add_argument("--seed", type=int, default=0)
|
| 294 |
+
ap.add_argument("--out", default="")
|
| 295 |
+
a = ap.parse_args()
|
| 296 |
+
t0 = time.time()
|
| 297 |
+
par = dict(Delta=a.Delta, mu=a.mu, g=a.g)
|
| 298 |
+
vm = BatchVMC(a.L, a.Ne, a.U, par, a.walkers, a.seed)
|
| 299 |
+
for s in range(a.ntherm):
|
| 300 |
+
vm.sweep()
|
| 301 |
+
if s % 10 == 0:
|
| 302 |
+
vm.refresh()
|
| 303 |
+
hist = []
|
| 304 |
+
if a.opt:
|
| 305 |
+
nv = len(vm.lat.classes)
|
| 306 |
+
keys = []
|
| 307 |
+
for k in a.opt.split(","):
|
| 308 |
+
keys += [f"v{c}" for c in range(nv)] if k == "jas" else [k]
|
| 309 |
+
log = open(a.out.replace(".json", ".opt.log"), "w") if a.out else None
|
| 310 |
+
par, hist = optimize(vm, par, keys, a.iters, a.nmeas_opt, a.lr, log)
|
| 311 |
+
vm.set_params(par); vm.refresh()
|
| 312 |
+
for _ in range(20):
|
| 313 |
+
vm.sweep()
|
| 314 |
+
r = measure(vm, a.nmeas)
|
| 315 |
+
r.update(L=a.L, Ne=a.Ne, U=a.U, opt=a.opt, walkers=a.walkers,
|
| 316 |
+
par={k: (np.round(v, 5).tolist() if isinstance(v, np.ndarray) else round(float(v), 5)) for k, v in par.items()},
|
| 317 |
+
sec=round(time.time() - t0, 1), engine="gpu")
|
| 318 |
+
print(json.dumps(r))
|
| 319 |
+
if a.out:
|
| 320 |
+
json.dump(dict(result=r, hist=hist), open(a.out, "w"), indent=1)
|
| 321 |
+
|
| 322 |
+
|
| 323 |
+
if __name__ == "__main__":
|
| 324 |
+
main()
|
methods/Yuseon84/code/vmc_gpu2.py
ADDED
|
@@ -0,0 +1,539 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# -*- coding: utf-8 -*-
|
| 2 |
+
"""vmc_gpu.py + (1) doublon-holon Jastrow and (2) a free pairing function a_k.
|
| 3 |
+
|
| 4 |
+
Psi(x) = J(x) det[phi(r_i^up - r_j^dn)]
|
| 5 |
+
log J = -g D + sum_{i<j} v_c n_i n_j - kd * Nd_free - kh * Nh_free
|
| 6 |
+
Nd_free = # doublons with no nearest-neighbour holon, Nh_free = # holons with no NN doublon
|
| 7 |
+
pairing "bcs": a_k = D_k / (xi_k + E_k) (parameters Delta, mu; as in vmc_dwave.py)
|
| 8 |
+
pairing "bdg": F_ij from a real-space BdG mean field with d+s pairing, chemical potential,
|
| 9 |
+
Neel field maf and auxiliary t' (bdg_pair); breaks translation when maf != 0.
|
| 10 |
+
pairing "free": a_k = s(k) * theta_o(k), one free amplitude per C4v orbit o of k, with the
|
| 11 |
+
d-wave sign pattern s(k) = sign(cos kx - cos ky) (+1 on the diagonals).
|
| 12 |
+
BCS is the special case theta_o = |a_k^BCS|. theta of the k=0 orbit is fixed to 1.
|
| 13 |
+
Estimators and output format are those of vmc_gpu.py.
|
| 14 |
+
"""
|
| 15 |
+
import argparse, json, time
|
| 16 |
+
import numpy as np
|
| 17 |
+
import torch
|
| 18 |
+
from vmc_dwave import Lattice, phi_table
|
| 19 |
+
|
| 20 |
+
DEV = torch.device("cuda")
|
| 21 |
+
DT = torch.float64
|
| 22 |
+
|
| 23 |
+
|
| 24 |
+
def k_orbits(L):
|
| 25 |
+
"""C4v orbit index and d-wave sign for every k on the LxL grid."""
|
| 26 |
+
orb, keys = np.zeros((L, L), int), []
|
| 27 |
+
for a in range(L):
|
| 28 |
+
for b in range(L):
|
| 29 |
+
x, y = min(a, L - a), min(b, L - b)
|
| 30 |
+
key = (max(x, y), min(x, y))
|
| 31 |
+
if key not in keys:
|
| 32 |
+
keys.append(key)
|
| 33 |
+
orb[a, b] = keys.index(key)
|
| 34 |
+
ks = 2 * np.pi * np.arange(L) / L
|
| 35 |
+
f = np.cos(ks)[:, None] - np.cos(ks)[None, :]
|
| 36 |
+
s = np.where(np.abs(f) < 1e-9, 1.0, np.sign(f))
|
| 37 |
+
return orb, s, keys
|
| 38 |
+
|
| 39 |
+
|
| 40 |
+
def a_bcs(L, Delta, mu):
|
| 41 |
+
"""|a_k| of the BCS form (same regularization as vmc_dwave.phi_table)."""
|
| 42 |
+
ks = 2 * np.pi * np.arange(L) / L
|
| 43 |
+
KX, KY = np.meshgrid(ks, ks, indexing="ij")
|
| 44 |
+
xi = -2 * (np.cos(KX) + np.cos(KY)) - mu
|
| 45 |
+
f = np.cos(KX) - np.cos(KY)
|
| 46 |
+
fmin = np.min(np.abs(f[np.abs(f) > 1e-6]))
|
| 47 |
+
Dk = Delta * np.where(np.abs(f) > 1e-6, f, 0.5 * fmin)
|
| 48 |
+
a = Dk / (xi + np.sqrt(xi ** 2 + Dk ** 2))
|
| 49 |
+
return a / np.max(np.abs(a))
|
| 50 |
+
|
| 51 |
+
|
| 52 |
+
def phi_from_a(L, a):
|
| 53 |
+
ks = 2 * np.pi * np.arange(L) / L
|
| 54 |
+
X = np.arange(L)
|
| 55 |
+
C, S = np.cos(np.outer(X, ks)), np.sin(np.outer(X, ks))
|
| 56 |
+
ph = np.einsum("ab,xa,yb->xy", a, C, C) - np.einsum("ab,xa,yb->xy", a, S, S)
|
| 57 |
+
return ph / (L * L)
|
| 58 |
+
|
| 59 |
+
|
| 60 |
+
def bdg_pair(lat, Delta, ds, mu, maf, tp=0.0):
|
| 61 |
+
"""Pair function F_ij (up site i, down site j) of the real-space BdG mean field
|
| 62 |
+
h_sigma = -t(nn) - tp(nnn) - mu +/- maf (-1)^(x+y), pairing Delta*g_ij on nn bonds + ds on site.
|
| 63 |
+
F = -U V^{-1} from the negative-energy eigenvectors (equals the BCS phi when maf=tp=0)."""
|
| 64 |
+
N = lat.N
|
| 65 |
+
T = np.zeros((N, N)); Dm = ds * np.eye(N)
|
| 66 |
+
for s in range(N):
|
| 67 |
+
x, y = lat.xy[s]
|
| 68 |
+
for (dx, dy), gd in (((1, 0), 1.0), ((0, 1), -1.0)):
|
| 69 |
+
j = lat.site(x + dx, y + dy)
|
| 70 |
+
T[s, j] -= 1; T[j, s] -= 1
|
| 71 |
+
Dm[s, j] += Delta * gd; Dm[j, s] += Delta * gd
|
| 72 |
+
if tp:
|
| 73 |
+
for dx, dy in ((1, 1), (1, -1)):
|
| 74 |
+
j = lat.site(x + dx, y + dy)
|
| 75 |
+
T[s, j] -= tp; T[j, s] -= tp
|
| 76 |
+
stag = np.diag([(-1.0) ** (x + y) for x, y in lat.xy])
|
| 77 |
+
H = np.block([[T - mu * np.eye(N) + maf * stag, Dm], [Dm.T, -(T - mu * np.eye(N) - maf * stag).T]])
|
| 78 |
+
w, W = np.linalg.eigh(H)
|
| 79 |
+
F = -W[:N, :N] @ np.linalg.inv(W[N:, :N])
|
| 80 |
+
return F / np.max(np.abs(F))
|
| 81 |
+
|
| 82 |
+
|
| 83 |
+
BDG_KEYS = ("Delta", "ds", "mu", "maf", "tp")
|
| 84 |
+
|
| 85 |
+
|
| 86 |
+
class BatchVMC2:
|
| 87 |
+
def __init__(self, L, Ne, U, par, B, seed, pairing="bcs"):
|
| 88 |
+
self.lat = Lattice(L)
|
| 89 |
+
self.L, self.N, self.n, self.U, self.B = L, L * L, Ne // 2, U, B
|
| 90 |
+
self.pairing = pairing
|
| 91 |
+
self.gen = torch.Generator(device=DEV); self.gen.manual_seed(seed)
|
| 92 |
+
lat = self.lat
|
| 93 |
+
self.nb = torch.tensor(lat.nb, device=DEV)
|
| 94 |
+
self.cls = torch.tensor(lat.cls, device=DEV)
|
| 95 |
+
self.Cmat = torch.stack([(self.cls == c).to(DT) for c in range(len(lat.classes))])
|
| 96 |
+
self.dx = torch.tensor(lat.dx, device=DEV); self.dy = torch.tensor(lat.dy, device=DEV)
|
| 97 |
+
self.orb, self.sk, self.okeys = k_orbits(L)
|
| 98 |
+
self.ar = torch.arange(B, device=DEV)
|
| 99 |
+
self.set_params(par)
|
| 100 |
+
self.init_walkers()
|
| 101 |
+
|
| 102 |
+
# ---------------- parameters ----------------
|
| 103 |
+
def a_table(self, par):
|
| 104 |
+
if self.pairing == "bcs":
|
| 105 |
+
return a_bcs(self.L, par["Delta"], par["mu"])
|
| 106 |
+
th = np.asarray(par["a"], float)
|
| 107 |
+
return self.sk * th[self.orb]
|
| 108 |
+
|
| 109 |
+
def phi_sites_from_a(self, a):
|
| 110 |
+
ph = torch.tensor(phi_from_a(self.L, a), dtype=DT, device=DEV)
|
| 111 |
+
return ph[self.dx, self.dy]
|
| 112 |
+
|
| 113 |
+
def pair_matrix(self, par):
|
| 114 |
+
if self.pairing == "bdg":
|
| 115 |
+
return torch.tensor(bdg_pair(self.lat, par["Delta"], par.get("ds", 0.05), par["mu"],
|
| 116 |
+
par.get("maf", 0.0), par.get("tp", 0.0)), dtype=DT, device=DEV)
|
| 117 |
+
return self.phi_sites_from_a(self.a_table(par))
|
| 118 |
+
|
| 119 |
+
def set_params(self, par):
|
| 120 |
+
self.par = dict(par)
|
| 121 |
+
self.PHI = self.pair_matrix(par)
|
| 122 |
+
v = torch.tensor(np.asarray(par.get("v", np.zeros(len(self.lat.classes)))), dtype=DT, device=DEV)
|
| 123 |
+
self.V = torch.where(self.cls >= 0, v[self.cls.clamp(min=0)], torch.zeros((), dtype=DT, device=DEV))
|
| 124 |
+
self.g = float(par.get("g", 0.0))
|
| 125 |
+
self.kd = float(par.get("kd", 0.0)); self.kh = float(par.get("kh", 0.0))
|
| 126 |
+
u = torch.tensor(np.asarray(par.get("u", np.zeros(len(self.lat.classes)))), dtype=DT, device=DEV)
|
| 127 |
+
self.Us = torch.where(self.cls >= 0, u[self.cls.clamp(min=0)], torch.zeros((), dtype=DT, device=DEV))
|
| 128 |
+
self.use_dh = (self.kd != 0.0) or (self.kh != 0.0) or par.get("dh_on", False)
|
| 129 |
+
|
| 130 |
+
# ---------------- doublon-holon ----------------
|
| 131 |
+
def dh_counts(self, nu, nd):
|
| 132 |
+
d = nu * nd
|
| 133 |
+
h = (1 - nu) * (1 - nd)
|
| 134 |
+
h_nb = h[..., self.nb].sum(-1) > 0.5
|
| 135 |
+
d_nb = d[..., self.nb].sum(-1) > 0.5
|
| 136 |
+
return (d * (~h_nb)).sum(-1), (h * (~d_nb)).sum(-1)
|
| 137 |
+
|
| 138 |
+
def dh_log(self, nu, nd):
|
| 139 |
+
if not self.use_dh:
|
| 140 |
+
return torch.zeros(nu.shape[:-1], dtype=DT, device=DEV)
|
| 141 |
+
Nd, Nh = self.dh_counts(nu, nd)
|
| 142 |
+
return -self.kd * Nd - self.kh * Nh
|
| 143 |
+
|
| 144 |
+
# ---------------- walkers ----------------
|
| 145 |
+
def rand_conf(self, m):
|
| 146 |
+
return torch.rand(m, self.N, generator=self.gen, device=DEV).argsort(1)[:, : self.n]
|
| 147 |
+
|
| 148 |
+
def init_walkers(self):
|
| 149 |
+
B = self.B
|
| 150 |
+
self.up = self.rand_conf(B); self.dn = self.rand_conf(B)
|
| 151 |
+
for _ in range(50):
|
| 152 |
+
self.refresh()
|
| 153 |
+
bad = ~torch.isfinite(self.Minv).all(-1).all(-1) | (torch.linalg.det(self.M).abs() < 1e-200)
|
| 154 |
+
if not bad.any():
|
| 155 |
+
break
|
| 156 |
+
k = int(bad.sum())
|
| 157 |
+
self.up[bad] = self.rand_conf(k); self.dn[bad] = self.rand_conf(k)
|
| 158 |
+
self.refresh()
|
| 159 |
+
|
| 160 |
+
def refresh(self):
|
| 161 |
+
B, N = self.B, self.N
|
| 162 |
+
self.M = self.PHI[self.up[:, :, None], self.dn[:, None, :]]
|
| 163 |
+
self.Minv, info = torch.linalg.inv_ex(self.M)
|
| 164 |
+
bad = (info != 0) | ~torch.isfinite(self.Minv).all(-1).all(-1)
|
| 165 |
+
if bad.any() and not bad.all():
|
| 166 |
+
good = torch.nonzero(~bad).squeeze(1)
|
| 167 |
+
src = good[torch.randint(0, len(good), (int(bad.sum()),), generator=self.gen, device=DEV)]
|
| 168 |
+
self.up[bad] = self.up[src]; self.dn[bad] = self.dn[src]
|
| 169 |
+
self.M = self.PHI[self.up[:, :, None], self.dn[:, None, :]]
|
| 170 |
+
self.Minv, info = torch.linalg.inv_ex(self.M)
|
| 171 |
+
self.nu = torch.zeros(B, N, dtype=DT, device=DEV); self.nu.scatter_(1, self.up, 1.0)
|
| 172 |
+
self.nd = torch.zeros(B, N, dtype=DT, device=DEV); self.nd.scatter_(1, self.dn, 1.0)
|
| 173 |
+
self.h = (self.nu + self.nd) @ self.V
|
| 174 |
+
self.hs = (self.nu - self.nd) @ self.Us
|
| 175 |
+
self.dhl = self.dh_log(self.nu, self.nd)
|
| 176 |
+
|
| 177 |
+
def _rand(self, hi):
|
| 178 |
+
return torch.randint(0, hi, (self.B,), generator=self.gen, device=DEV)
|
| 179 |
+
|
| 180 |
+
@staticmethod
|
| 181 |
+
def _moved(occ, src, dst):
|
| 182 |
+
"""Copy of occ (..., N) with one particle moved src->dst; src/dst broadcast over leading dims."""
|
| 183 |
+
o = occ.clone()
|
| 184 |
+
o.scatter_(-1, src[..., None], 0.0)
|
| 185 |
+
o.scatter_(-1, dst[..., None], 1.0)
|
| 186 |
+
return o
|
| 187 |
+
|
| 188 |
+
def step(self, spin):
|
| 189 |
+
ar, n = self.ar, self.n
|
| 190 |
+
e = self._rand(n); d = self._rand(4)
|
| 191 |
+
pos, same, other = (self.up, self.nu, self.nd) if spin == 0 else (self.dn, self.nd, self.nu)
|
| 192 |
+
a = pos[ar, e]; t = self.nb[a, d]
|
| 193 |
+
blocked = same[ar, t] > 0.5
|
| 194 |
+
if spin == 0:
|
| 195 |
+
vec = self.PHI[t[:, None], self.dn]
|
| 196 |
+
w = torch.einsum("bj,bjk->bk", vec, self.Minv)
|
| 197 |
+
else:
|
| 198 |
+
vec = self.PHI[self.up, t[:, None]]
|
| 199 |
+
w = torch.einsum("bij,bj->bi", self.Minv, vec)
|
| 200 |
+
q = w[ar, e]
|
| 201 |
+
dJ = -self.g * (other[ar, t] - other[ar, a]) + self.h[ar, t] - self.h[ar, a] - self.V[a, t]
|
| 202 |
+
sg = 1.0 if spin == 0 else -1.0
|
| 203 |
+
dJ = dJ + sg * (self.hs[ar, t] - self.hs[ar, a]) - self.Us[a, t]
|
| 204 |
+
if self.use_dh:
|
| 205 |
+
new_same = self._moved(same, a, t)
|
| 206 |
+
nl = self.dh_log(new_same, other) if spin == 0 else self.dh_log(other, new_same)
|
| 207 |
+
dJ = dJ + nl - self.dhl
|
| 208 |
+
r = q * torch.exp(dJ)
|
| 209 |
+
acc = (torch.rand(self.B, generator=self.gen, device=DEV, dtype=DT) < r * r) & ~blocked
|
| 210 |
+
idx = torch.nonzero(acc).squeeze(1)
|
| 211 |
+
if idx.numel() == 0:
|
| 212 |
+
return 0
|
| 213 |
+
ei, wi, qi = e[idx], w[idx].clone(), q[idx]
|
| 214 |
+
wi[torch.arange(len(idx), device=DEV), ei] -= 1.0
|
| 215 |
+
if spin == 0:
|
| 216 |
+
self.Minv[idx] -= self.Minv[idx, :, ei][:, :, None] * wi[:, None, :] / qi[:, None, None]
|
| 217 |
+
self.M[idx, ei, :] = vec[idx]
|
| 218 |
+
self.up[idx, ei] = t[idx]
|
| 219 |
+
self.nu[idx, a[idx]] = 0.0; self.nu[idx, t[idx]] = 1.0
|
| 220 |
+
else:
|
| 221 |
+
self.Minv[idx] -= wi[:, :, None] * self.Minv[idx, ei, :][:, None, :] / qi[:, None, None]
|
| 222 |
+
self.M[idx, :, ei] = vec[idx]
|
| 223 |
+
self.dn[idx, ei] = t[idx]
|
| 224 |
+
self.nd[idx, a[idx]] = 0.0; self.nd[idx, t[idx]] = 1.0
|
| 225 |
+
self.h[idx] += self.V[t[idx]] - self.V[a[idx]]
|
| 226 |
+
self.hs[idx] += sg * (self.Us[t[idx]] - self.Us[a[idx]])
|
| 227 |
+
if self.use_dh:
|
| 228 |
+
self.dhl[idx] = self.dh_log(self.nu[idx], self.nd[idx])
|
| 229 |
+
return len(idx)
|
| 230 |
+
|
| 231 |
+
def sweep(self):
|
| 232 |
+
acc = 0
|
| 233 |
+
for spin in (0, 1):
|
| 234 |
+
for _ in range(self.n):
|
| 235 |
+
acc += self.step(spin)
|
| 236 |
+
return acc / (2 * self.n * self.B)
|
| 237 |
+
|
| 238 |
+
# ---------------- estimators ----------------
|
| 239 |
+
def local_energy(self):
|
| 240 |
+
nu, nd, h, V, g, Mi, P = self.nu, self.nd, self.h, self.V, self.g, self.Minv, self.PHI
|
| 241 |
+
bi = self.ar[:, None, None]
|
| 242 |
+
D = (nu * nd).sum(1)
|
| 243 |
+
kin = torch.zeros(self.B, dtype=DT, device=DEV)
|
| 244 |
+
for spin in (0, 1):
|
| 245 |
+
pos, same, other = (self.up, nu, nd) if spin == 0 else (self.dn, nd, nu)
|
| 246 |
+
tgt = self.nb[pos] # (B,n,4)
|
| 247 |
+
src = pos[:, :, None].expand_as(tgt)
|
| 248 |
+
if spin == 0:
|
| 249 |
+
rows = P[tgt[..., None], self.dn[:, None, None, :]]
|
| 250 |
+
q = torch.einsum("banj,bja->ban", rows, Mi)
|
| 251 |
+
else:
|
| 252 |
+
cols = P[self.up[:, None, None, :], tgt[..., None]]
|
| 253 |
+
q = torch.einsum("bmi,bmki->bmk", Mi, cols)
|
| 254 |
+
jl = -g * (other[bi, tgt] - other[bi, src]) + h[bi, tgt] - h[bi, src] - V[src, tgt]
|
| 255 |
+
sg = 1.0 if spin == 0 else -1.0
|
| 256 |
+
jl = jl + sg * (self.hs[bi, tgt] - self.hs[bi, src]) - self.Us[src, tgt]
|
| 257 |
+
if self.use_dh:
|
| 258 |
+
ns = self._moved(same[:, None, None, :].expand(-1, self.n, 4, -1), src, tgt)
|
| 259 |
+
ot = other[:, None, None, :].expand_as(ns)
|
| 260 |
+
nl = self.dh_log(ns, ot) if spin == 0 else self.dh_log(ot, ns)
|
| 261 |
+
jl = jl + nl - self.dhl[:, None, None]
|
| 262 |
+
kin = kin + torch.where(same[bi, tgt] < 0.5, q * torch.exp(jl), torch.zeros_like(q)).sum((1, 2))
|
| 263 |
+
return self.U * D - kin
|
| 264 |
+
|
| 265 |
+
def pair_terms(self, R):
|
| 266 |
+
lat = self.lat
|
| 267 |
+
NB = [((1, 0), 1.0), ((-1, 0), 1.0), ((0, 1), -1.0), ((0, -1), -1.0)]
|
| 268 |
+
T = []
|
| 269 |
+
for (x, y) in lat.xy:
|
| 270 |
+
i = lat.site(x, y); j = lat.site(x + R[0], y + R[1])
|
| 271 |
+
for d, g in NB:
|
| 272 |
+
di = lat.site(x + d[0], y + d[1])
|
| 273 |
+
for dp, gp in NB:
|
| 274 |
+
dj = lat.site(x + R[0] + dp[0], y + R[1] + dp[1])
|
| 275 |
+
for (p, q) in ((i, di), (di, i)):
|
| 276 |
+
for (p2, q2) in ((j, dj), (dj, j)):
|
| 277 |
+
T.append((g * gp, p, p2, q, q2))
|
| 278 |
+
T = np.array(T)
|
| 279 |
+
self.pc = torch.tensor(T[:, 0], dtype=DT, device=DEV)
|
| 280 |
+
self.pidx = torch.tensor(T[:, 1:].astype(np.int64), device=DEV)
|
| 281 |
+
|
| 282 |
+
def pair_corr(self, chunk=64):
|
| 283 |
+
out = torch.zeros(self.B, dtype=DT, device=DEV)
|
| 284 |
+
p, p2, q, q2 = self.pidx.T
|
| 285 |
+
n = self.n
|
| 286 |
+
ar_n = torch.arange(n, device=DEV)
|
| 287 |
+
for s in range(0, self.B, chunk):
|
| 288 |
+
sl = slice(s, min(s + chunk, self.B)); b = sl.stop - sl.start
|
| 289 |
+
nu, nd, up, dn = self.nu[sl], self.nd[sl], self.up[sl], self.dn[sl]
|
| 290 |
+
M, Mi, h = self.M[sl], self.Minv[sl], self.h[sl]
|
| 291 |
+
ok = (nu[:, p] > 0.5) & (nd[:, q] > 0.5) & (nu[:, p2] < 0.5) & (nd[:, q2] < 0.5)
|
| 292 |
+
eu = torch.zeros((b, self.N), dtype=torch.long, device=DEV); eu.scatter_(1, up, ar_n.expand(b, n).contiguous())
|
| 293 |
+
ed = torch.zeros((b, self.N), dtype=torch.long, device=DEV); ed.scatter_(1, dn, ar_n.expand(b, n).contiguous())
|
| 294 |
+
al, be = eu[:, p], ed[:, q]
|
| 295 |
+
dn_new = torch.where(ar_n[None, None, :] == be[..., None], q2[None, :, None], dn[:, None, :])
|
| 296 |
+
up_new = torch.where(ar_n[None, None, :] == al[..., None], p2[None, :, None], up[:, None, :])
|
| 297 |
+
Rn = self.PHI[p2[None, :, None], dn_new]
|
| 298 |
+
Cn = self.PHI[up_new, q2[None, :, None]]
|
| 299 |
+
a = Rn - torch.gather(M, 1, al[..., None].expand(-1, -1, n))
|
| 300 |
+
bv = Cn - torch.gather(M.transpose(1, 2), 1, be[..., None].expand(-1, -1, n))
|
| 301 |
+
bv = bv.scatter(2, al[..., None], 0.0)
|
| 302 |
+
col_al = torch.gather(Mi.transpose(1, 2), 1, al[..., None].expand(-1, -1, n))
|
| 303 |
+
row_be = torch.gather(Mi, 1, be[..., None].expand(-1, -1, n))
|
| 304 |
+
x11 = (a * col_al).sum(-1)
|
| 305 |
+
x22 = (row_be * bv).sum(-1)
|
| 306 |
+
x21 = torch.gather(row_be, 2, al[..., None]).squeeze(-1)
|
| 307 |
+
x12 = (torch.bmm(a, Mi) * bv).sum(-1)
|
| 308 |
+
det_r = (1 + x11) * (1 + x22) - x12 * x21
|
| 309 |
+
V, g = self.V, self.g
|
| 310 |
+
j1 = -g * (nd[:, p2] - nd[:, p]) + h[:, p2] - h[:, p] - V[p, p2]
|
| 311 |
+
nu2_q2 = nu[:, q2] - (q2 == p).to(DT) + (q2 == p2).to(DT)
|
| 312 |
+
nu2_q = nu[:, q] - (q == p).to(DT) + (q == p2).to(DT)
|
| 313 |
+
h2q2 = h[:, q2] - V[q2, p] + V[q2, p2]
|
| 314 |
+
h2q = h[:, q] - V[q, p] + V[q, p2]
|
| 315 |
+
j2 = -g * (nu2_q2 - nu2_q) + (h2q2 - h2q - V[q, q2])
|
| 316 |
+
hs, Us = self.hs[sl], self.Us
|
| 317 |
+
s1 = hs[:, p2] - hs[:, p] - Us[p, p2] # up p->p2
|
| 318 |
+
hs2q2 = hs[:, q2] + Us[q2, p2] - Us[q2, p]
|
| 319 |
+
hs2q = hs[:, q] + Us[q, p2] - Us[q, p]
|
| 320 |
+
s2 = -(hs2q2 - hs2q) - Us[q, q2] # then down q->q2
|
| 321 |
+
jl = j1 + j2 + s1 + s2
|
| 322 |
+
if self.use_dh:
|
| 323 |
+
T = len(p)
|
| 324 |
+
nu_new = self._moved(nu[:, None, :].expand(-1, T, -1), p[None, :].expand(b, -1), p2[None, :].expand(b, -1))
|
| 325 |
+
nd_new = self._moved(nd[:, None, :].expand(-1, T, -1), q[None, :].expand(b, -1), q2[None, :].expand(b, -1))
|
| 326 |
+
jl = jl + self.dh_log(nu_new, nd_new) - self.dhl[sl][:, None]
|
| 327 |
+
val = torch.where(ok, self.pc * det_r * torch.exp(jl), torch.zeros_like(det_r)).sum(1)
|
| 328 |
+
out[sl] = 0.25 * val / self.N
|
| 329 |
+
return out
|
| 330 |
+
|
| 331 |
+
def log_derivs(self, keys, dPHI):
|
| 332 |
+
cols = []
|
| 333 |
+
ntot = self.nu + self.nd
|
| 334 |
+
if any(k in ("kd", "kh") for k in keys):
|
| 335 |
+
Nd, Nh = self.dh_counts(self.nu, self.nd)
|
| 336 |
+
for k in keys:
|
| 337 |
+
if k == "g":
|
| 338 |
+
cols.append(-(self.nu * self.nd).sum(1))
|
| 339 |
+
elif k == "kd":
|
| 340 |
+
cols.append(-Nd)
|
| 341 |
+
elif k == "kh":
|
| 342 |
+
cols.append(-Nh)
|
| 343 |
+
elif k.startswith("v"):
|
| 344 |
+
c = int(k[1:])
|
| 345 |
+
cols.append(0.5 * torch.einsum("bi,ij,bj->b", ntot, self.Cmat[c], ntot))
|
| 346 |
+
elif k.startswith("u"):
|
| 347 |
+
c = int(k[1:]); m = self.nu - self.nd
|
| 348 |
+
cols.append(0.5 * torch.einsum("bi,ij,bj->b", m, self.Cmat[c], m))
|
| 349 |
+
else: # Delta, mu, or a<o>
|
| 350 |
+
dM = dPHI[k][self.up[:, :, None], self.dn[:, None, :]]
|
| 351 |
+
cols.append((self.Minv.transpose(1, 2) * dM).sum((1, 2)))
|
| 352 |
+
return torch.stack(cols, 1)
|
| 353 |
+
|
| 354 |
+
def dphi(self, par, keys):
|
| 355 |
+
out = {}
|
| 356 |
+
for k in keys:
|
| 357 |
+
if k in BDG_KEYS:
|
| 358 |
+
h = 1e-5
|
| 359 |
+
pp, pm = dict(par), dict(par)
|
| 360 |
+
pp[k] = pp.get(k, 0.0) + h; pm[k] = pm.get(k, 0.0) - h
|
| 361 |
+
out[k] = (self.pair_matrix(pp) - self.pair_matrix(pm)) / (2 * h)
|
| 362 |
+
elif k.startswith("a"):
|
| 363 |
+
o = int(k[1:])
|
| 364 |
+
out[k] = self.phi_sites_from_a(np.where(self.orb == o, self.sk, 0.0))
|
| 365 |
+
return out
|
| 366 |
+
|
| 367 |
+
|
| 368 |
+
def unpack(theta, keys, base, nv, na):
|
| 369 |
+
par = dict(base)
|
| 370 |
+
par["v"] = np.array(base.get("v", np.zeros(nv)), dtype=float)
|
| 371 |
+
par["u"] = np.array(base.get("u", np.zeros(nv)), dtype=float)
|
| 372 |
+
if "a" in base:
|
| 373 |
+
par["a"] = np.array(base["a"], dtype=float)
|
| 374 |
+
for k, val in zip(keys, theta):
|
| 375 |
+
if k.startswith("v"):
|
| 376 |
+
par["v"][int(k[1:])] = val
|
| 377 |
+
elif k.startswith("u"):
|
| 378 |
+
par["u"][int(k[1:])] = val
|
| 379 |
+
elif k.startswith("a"):
|
| 380 |
+
par["a"][int(k[1:])] = val
|
| 381 |
+
else:
|
| 382 |
+
par[k] = float(val)
|
| 383 |
+
return par
|
| 384 |
+
|
| 385 |
+
|
| 386 |
+
def get(par, k):
|
| 387 |
+
if k.startswith("v"):
|
| 388 |
+
return float(par["v"][int(k[1:])]) if "v" in par else 0.0
|
| 389 |
+
if k.startswith("u"):
|
| 390 |
+
return float(par["u"][int(k[1:])]) if "u" in par else 0.0
|
| 391 |
+
if k.startswith("a"):
|
| 392 |
+
return float(par["a"][int(k[1:])])
|
| 393 |
+
return float(par.get(k, 0.0))
|
| 394 |
+
|
| 395 |
+
|
| 396 |
+
def optimize(vm, par0, keys, n_iter, nmeas, lr, log=None, eps_rel=0.05, eps_abs=1e-3, gap=2, pre=3):
|
| 397 |
+
nv, na = len(vm.lat.classes), len(vm.okeys)
|
| 398 |
+
theta = np.array([get(par0, k) for k in keys], float)
|
| 399 |
+
hist = []
|
| 400 |
+
good, E_good, lr0 = theta.copy(), None, lr
|
| 401 |
+
for it in range(n_iter):
|
| 402 |
+
par = unpack(theta, keys, par0, nv, na)
|
| 403 |
+
vm.set_params(par); vm.refresh()
|
| 404 |
+
dPHI = vm.dphi(par, keys)
|
| 405 |
+
for _ in range(pre):
|
| 406 |
+
vm.sweep()
|
| 407 |
+
Es, Os = [], []
|
| 408 |
+
for m in range(nmeas):
|
| 409 |
+
for _ in range(gap):
|
| 410 |
+
vm.sweep()
|
| 411 |
+
vm.refresh()
|
| 412 |
+
Es.append(vm.local_energy()); Os.append(vm.log_derivs(keys, dPHI))
|
| 413 |
+
E = torch.cat(Es); O = torch.cat(Os)
|
| 414 |
+
ok = torch.isfinite(E) & torch.isfinite(O).all(1)
|
| 415 |
+
E, O = E[ok], O[ok]
|
| 416 |
+
Em = float(E.mean()) if len(E) else float("nan")
|
| 417 |
+
if (not np.isfinite(Em)) or (E_good is not None and abs(Em) > 10 * abs(E_good)):
|
| 418 |
+
# wavefunction broke down (e.g. near-degenerate mean field): revert and slow down
|
| 419 |
+
theta, lr = good.copy(), lr * 0.5
|
| 420 |
+
hist.append(dict(it=it, E=Em, dE=float("nan"), theta=[round(float(x), 5) for x in theta], reverted=True))
|
| 421 |
+
if log:
|
| 422 |
+
print(json.dumps(hist[-1]), file=log, flush=True)
|
| 423 |
+
continue
|
| 424 |
+
good, E_good = theta.copy(), Em
|
| 425 |
+
lr = min(lr0, lr * 1.1)
|
| 426 |
+
Om = O.mean(0)
|
| 427 |
+
S = ((O - Om).T @ (O - Om) / len(E)).cpu().numpy()
|
| 428 |
+
F = (((E - E.mean())[:, None] * (O - Om)).mean(0)).cpu().numpy()
|
| 429 |
+
S += np.diag(eps_rel * np.diag(S) + eps_abs)
|
| 430 |
+
step = -lr * np.linalg.solve(S, F)
|
| 431 |
+
cap = 0.1 * np.maximum(0.3, np.abs(theta)) # trust region per parameter
|
| 432 |
+
step = step / max(1.0, float(np.max(np.abs(step) / cap)))
|
| 433 |
+
theta = theta + step
|
| 434 |
+
if "Delta" in keys:
|
| 435 |
+
i = keys.index("Delta"); theta[i] = max(abs(theta[i]), getattr(vm, "delta_floor", 0.0))
|
| 436 |
+
for k, fl in getattr(vm, "floors", {}).items(): # keep gaps open (well-conditioned W)
|
| 437 |
+
if k in keys:
|
| 438 |
+
i = keys.index(k); theta[i] = max(theta[i], fl)
|
| 439 |
+
rec = dict(it=it, E=float(E.mean()), dE=float(E.std() / np.sqrt(len(E))),
|
| 440 |
+
theta=[round(float(x), 5) for x in theta])
|
| 441 |
+
hist.append(rec)
|
| 442 |
+
if log:
|
| 443 |
+
print(json.dumps(rec), file=log, flush=True)
|
| 444 |
+
tail = np.array([r["theta"] for r in hist[2 * n_iter // 3:] if not r.get("reverted")] or [good])
|
| 445 |
+
return unpack(tail.mean(0), keys, par0, nv, na), hist
|
| 446 |
+
|
| 447 |
+
|
| 448 |
+
def measure(vm, nmeas, gap=2, R=None):
|
| 449 |
+
R = R or (vm.L // 2, vm.L // 2)
|
| 450 |
+
vm.pair_terms(R)
|
| 451 |
+
Es, Ps, acc = [], [], []
|
| 452 |
+
for m in range(nmeas):
|
| 453 |
+
for _ in range(gap):
|
| 454 |
+
acc.append(vm.sweep())
|
| 455 |
+
vm.refresh()
|
| 456 |
+
Es.append(vm.local_energy()); Ps.append(vm.pair_corr())
|
| 457 |
+
E = torch.stack(Es, 1); P = torch.stack(Ps, 1)
|
| 458 |
+
Ew, Pw = E.mean(1), P.mean(1)
|
| 459 |
+
sq = np.sqrt(vm.B)
|
| 460 |
+
return dict(E=float(Ew.mean()), dE=float(Ew.std() / sq), varE=float(E.var()),
|
| 461 |
+
Pd=float(Pw.mean()), dPd=float(Pw.std() / sq), acc=float(np.mean(acc)))
|
| 462 |
+
|
| 463 |
+
|
| 464 |
+
def main():
|
| 465 |
+
ap = argparse.ArgumentParser()
|
| 466 |
+
ap.add_argument("--L", type=int, default=6)
|
| 467 |
+
ap.add_argument("--Ne", type=int, default=26)
|
| 468 |
+
ap.add_argument("--U", type=float, default=8.0)
|
| 469 |
+
ap.add_argument("--pairing", choices=["bcs", "free", "bdg"], default="bcs")
|
| 470 |
+
ap.add_argument("--ds", type=float, default=0.05, help="bdg: on-site s component (keeps U,V invertible)")
|
| 471 |
+
ap.add_argument("--maf", type=float, default=0.0, help="bdg: staggered (Neel) field")
|
| 472 |
+
ap.add_argument("--tp", type=float, default=0.0, help="bdg: auxiliary next-nearest hopping")
|
| 473 |
+
ap.add_argument("--Delta", type=float, default=0.15)
|
| 474 |
+
ap.add_argument("--mu", type=float, default=0.0)
|
| 475 |
+
ap.add_argument("--g", type=float, default=0.0)
|
| 476 |
+
ap.add_argument("--kd", type=float, default=0.0)
|
| 477 |
+
ap.add_argument("--kh", type=float, default=0.0)
|
| 478 |
+
ap.add_argument("--init", default="", help="json result file to start from (par is reused)")
|
| 479 |
+
ap.add_argument("--walkers", type=int, default=2048)
|
| 480 |
+
ap.add_argument("--ntherm", type=int, default=100)
|
| 481 |
+
ap.add_argument("--nmeas", type=int, default=20)
|
| 482 |
+
ap.add_argument("--opt", default="", help="comma list: Delta,mu,g,jas,dh,afree (afree = all free a_k but k=0)")
|
| 483 |
+
ap.add_argument("--iters", type=int, default=150)
|
| 484 |
+
ap.add_argument("--nmeas_opt", type=int, default=1)
|
| 485 |
+
ap.add_argument("--lr", type=float, default=0.05)
|
| 486 |
+
ap.add_argument("--seed", type=int, default=0)
|
| 487 |
+
ap.add_argument("--out", default="")
|
| 488 |
+
a = ap.parse_args()
|
| 489 |
+
t0 = time.time()
|
| 490 |
+
par = dict(Delta=a.Delta, mu=a.mu, g=a.g, kd=a.kd, kh=a.kh)
|
| 491 |
+
if a.pairing == "bdg":
|
| 492 |
+
par.update(ds=a.ds, maf=a.maf, tp=a.tp)
|
| 493 |
+
if a.init:
|
| 494 |
+
p0 = json.load(open(a.init))["result"]["par"]
|
| 495 |
+
par.update({k: (np.array(v) if isinstance(v, list) else v) for k, v in p0.items()})
|
| 496 |
+
nv = len(Lattice(a.L).classes)
|
| 497 |
+
orb, sk, okeys = k_orbits(a.L)
|
| 498 |
+
if a.pairing == "free" and "a" not in par:
|
| 499 |
+
ab = np.abs(a_bcs(a.L, par["Delta"], par["mu"])) # start from the BCS amplitudes
|
| 500 |
+
par["a"] = np.array([ab[orb == o].mean() for o in range(len(okeys))])
|
| 501 |
+
par["a"] = par["a"] / par["a"][0]
|
| 502 |
+
if "dh" in a.opt:
|
| 503 |
+
par["dh_on"] = True
|
| 504 |
+
vm = BatchVMC2(a.L, a.Ne, a.U, par, a.walkers, a.seed, a.pairing)
|
| 505 |
+
for s in range(a.ntherm):
|
| 506 |
+
vm.sweep()
|
| 507 |
+
if s % 10 == 0:
|
| 508 |
+
vm.refresh()
|
| 509 |
+
hist = []
|
| 510 |
+
if a.opt:
|
| 511 |
+
keys = []
|
| 512 |
+
for k in a.opt.split(","):
|
| 513 |
+
if k == "jas":
|
| 514 |
+
keys += [f"v{c}" for c in range(nv)]
|
| 515 |
+
elif k == "dh":
|
| 516 |
+
keys += ["kd", "kh"]
|
| 517 |
+
elif k == "sjas":
|
| 518 |
+
keys += [f"u{c}" for c in range(nv)]
|
| 519 |
+
elif k == "afree":
|
| 520 |
+
keys += [f"a{o}" for o in range(1, len(okeys))]
|
| 521 |
+
else:
|
| 522 |
+
keys.append(k)
|
| 523 |
+
log = open(a.out.replace(".json", ".opt.log"), "w") if a.out else None
|
| 524 |
+
par, hist = optimize(vm, par, keys, a.iters, a.nmeas_opt, a.lr, log)
|
| 525 |
+
vm.set_params(par); vm.refresh()
|
| 526 |
+
for _ in range(20):
|
| 527 |
+
vm.sweep()
|
| 528 |
+
r = measure(vm, a.nmeas)
|
| 529 |
+
r.update(L=a.L, Ne=a.Ne, U=a.U, opt=a.opt, pairing=a.pairing, walkers=a.walkers,
|
| 530 |
+
par={k: (np.round(v, 5).tolist() if isinstance(v, np.ndarray) else (v if isinstance(v, bool) else round(float(v), 5)))
|
| 531 |
+
for k, v in par.items()},
|
| 532 |
+
sec=round(time.time() - t0, 1), engine="gpu2")
|
| 533 |
+
print(json.dumps(r))
|
| 534 |
+
if a.out:
|
| 535 |
+
json.dump(dict(result=r, hist=hist), open(a.out, "w"), indent=1)
|
| 536 |
+
|
| 537 |
+
|
| 538 |
+
if __name__ == "__main__":
|
| 539 |
+
main()
|
methods/Yuseon84/code/vmc_gpu3.py
ADDED
|
@@ -0,0 +1,374 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# -*- coding: utf-8 -*-
|
| 2 |
+
"""Particle-hole (Yokoyama-Shiba type) determinant VMC: BdG mean field with d+s pairing, chemical
|
| 3 |
+
potential, Neel field and auxiliary t', times the Jastrow factors of vmc_gpu2 (Gutzwiller, density,
|
| 4 |
+
spin, doublon-holon).
|
| 5 |
+
|
| 6 |
+
Down spins are particle-hole transformed: with W the 2N x N negative-energy BdG eigenvectors
|
| 7 |
+
(basis c_up, c+_dn), the amplitude of a configuration is
|
| 8 |
+
Psi(x) = (-1)^(sum of down positions) * det A(x) * J(x),
|
| 9 |
+
A rows = W[up sites] (labeled up electrons) and W[N + hole sites] (labeled down holes).
|
| 10 |
+
This stays well conditioned with a Neel field, unlike the AGP pair function -U V^-1.
|
| 11 |
+
Sign rules (checked against exact H on 4x4): an up hop contributes -t*det-ratio (row of that up
|
| 12 |
+
electron replaced); a down hop a->t contributes +t*det-ratio (row of the hole at t replaced by
|
| 13 |
+
W[N+a]); the pair estimator picks up an overall factor -1 from its down-spin part.
|
| 14 |
+
"""
|
| 15 |
+
import argparse, json, time
|
| 16 |
+
import numpy as np
|
| 17 |
+
import torch
|
| 18 |
+
from vmc_dwave import Lattice
|
| 19 |
+
import vmc_gpu2 as V2
|
| 20 |
+
|
| 21 |
+
DEV, DT = V2.DEV, V2.DT
|
| 22 |
+
KEYS = ("Delta", "ds", "mu", "maf", "tp")
|
| 23 |
+
|
| 24 |
+
|
| 25 |
+
def bdg_W(lat, Delta, ds, mu, maf, tp=0.0):
|
| 26 |
+
N = lat.N
|
| 27 |
+
T = np.zeros((N, N)); Dm = ds * np.eye(N)
|
| 28 |
+
for s in range(N):
|
| 29 |
+
x, y = lat.xy[s]
|
| 30 |
+
for (dx, dy), gd in (((1, 0), 1.0), ((0, 1), -1.0)):
|
| 31 |
+
j = lat.site(x + dx, y + dy)
|
| 32 |
+
T[s, j] -= 1; T[j, s] -= 1
|
| 33 |
+
Dm[s, j] += Delta * gd; Dm[j, s] += Delta * gd
|
| 34 |
+
if tp:
|
| 35 |
+
for dx, dy in ((1, 1), (1, -1)):
|
| 36 |
+
j = lat.site(x + dx, y + dy)
|
| 37 |
+
T[s, j] -= tp; T[j, s] -= tp
|
| 38 |
+
st = np.diag([(-1.0) ** (x + y) for x, y in lat.xy])
|
| 39 |
+
H = np.block([[T - mu * np.eye(N) + maf * st, Dm], [Dm.T, -(T - mu * np.eye(N) - maf * st).T]])
|
| 40 |
+
w, Wv = np.linalg.eigh(H)
|
| 41 |
+
return Wv[:, :N]
|
| 42 |
+
|
| 43 |
+
|
| 44 |
+
class BatchVMC3(V2.BatchVMC2):
|
| 45 |
+
delta_floor = 0.02 # keep the BdG pairing gap open (avoids degenerate, ill-defined W)
|
| 46 |
+
floors = {"ds": 0.02} # on-site s component keeps nodal quasiparticles gapped (U, V invertible)
|
| 47 |
+
|
| 48 |
+
def __init__(self, L, Ne, U, par, B, seed):
|
| 49 |
+
super().__init__(L, Ne, U, par, B, seed, pairing="ph")
|
| 50 |
+
|
| 51 |
+
# ---------------- orbitals ----------------
|
| 52 |
+
def W_of(self, par):
|
| 53 |
+
return bdg_W(self.lat, par["Delta"], par.get("ds", 0.05), par["mu"], par.get("maf", 0.0), par.get("tp", 0.0))
|
| 54 |
+
|
| 55 |
+
def set_params(self, par):
|
| 56 |
+
self.par = dict(par)
|
| 57 |
+
self.W0 = self.W_of(par)
|
| 58 |
+
self.Wt = torch.tensor(self.W0, dtype=DT, device=DEV)
|
| 59 |
+
v = torch.tensor(np.asarray(par.get("v", np.zeros(len(self.lat.classes)))), dtype=DT, device=DEV)
|
| 60 |
+
z = torch.zeros((), dtype=DT, device=DEV)
|
| 61 |
+
self.V = torch.where(self.cls >= 0, v[self.cls.clamp(min=0)], z)
|
| 62 |
+
u = torch.tensor(np.asarray(par.get("u", np.zeros(len(self.lat.classes)))), dtype=DT, device=DEV)
|
| 63 |
+
self.Us = torch.where(self.cls >= 0, u[self.cls.clamp(min=0)], z)
|
| 64 |
+
self.g = float(par.get("g", 0.0))
|
| 65 |
+
self.kd = float(par.get("kd", 0.0)); self.kh = float(par.get("kh", 0.0))
|
| 66 |
+
self.use_dh = (self.kd != 0.0) or (self.kh != 0.0) or par.get("dh_on", False)
|
| 67 |
+
|
| 68 |
+
def dphi(self, par, keys):
|
| 69 |
+
"""dA/dtheta via gauge-aligned finite differences of W (W -> W R leaves log-derivatives
|
| 70 |
+
unchanged up to a constant)."""
|
| 71 |
+
out = {}
|
| 72 |
+
W0 = self.W0
|
| 73 |
+
for k in keys:
|
| 74 |
+
if k in KEYS:
|
| 75 |
+
h = 1e-5
|
| 76 |
+
Ws = []
|
| 77 |
+
for sgn in (1, -1):
|
| 78 |
+
pp = dict(par); pp[k] = pp.get(k, 0.0) + sgn * h
|
| 79 |
+
Wp = self.W_of(pp)
|
| 80 |
+
Ws.append(Wp @ np.linalg.inv(W0.T @ Wp))
|
| 81 |
+
out[k] = torch.tensor((Ws[0] - Ws[1]) / (2 * h), dtype=DT, device=DEV)
|
| 82 |
+
return out
|
| 83 |
+
|
| 84 |
+
# ---------------- walkers ----------------
|
| 85 |
+
def build(self):
|
| 86 |
+
B, N, n = self.B, self.N, self.n
|
| 87 |
+
self.nd = torch.zeros(B, N, dtype=DT, device=DEV); self.nd.scatter_(1, self.dn, 1.0)
|
| 88 |
+
self.holes = torch.argsort(self.nd, dim=1, stable=True)[:, : N - n]
|
| 89 |
+
self.hl = torch.full((B, N), -1, dtype=torch.long, device=DEV)
|
| 90 |
+
self.hl.scatter_(1, self.holes, torch.arange(N - n, device=DEV).expand(B, -1).contiguous())
|
| 91 |
+
self.A = torch.cat([self.Wt[self.up], self.Wt[N + self.holes]], 1)
|
| 92 |
+
self.Ainv, info = torch.linalg.inv_ex(self.A)
|
| 93 |
+
return (info != 0) | ~torch.isfinite(self.Ainv).all(-1).all(-1)
|
| 94 |
+
|
| 95 |
+
def refresh(self):
|
| 96 |
+
B, N = self.B, self.N
|
| 97 |
+
bad = self.build()
|
| 98 |
+
if bad.any() and not bad.all():
|
| 99 |
+
good = torch.nonzero(~bad).squeeze(1)
|
| 100 |
+
src = good[torch.randint(0, len(good), (int(bad.sum()),), generator=self.gen, device=DEV)]
|
| 101 |
+
self.up[bad] = self.up[src]; self.dn[bad] = self.dn[src]
|
| 102 |
+
self.build()
|
| 103 |
+
self.nu = torch.zeros(B, N, dtype=DT, device=DEV); self.nu.scatter_(1, self.up, 1.0)
|
| 104 |
+
self.h = (self.nu + self.nd) @ self.V
|
| 105 |
+
self.hs = (self.nu - self.nd) @ self.Us
|
| 106 |
+
self.dhl = self.dh_log(self.nu, self.nd)
|
| 107 |
+
self.M, self.Minv = self.A, self.Ainv # for code that only checks finiteness
|
| 108 |
+
|
| 109 |
+
def init_walkers(self):
|
| 110 |
+
B = self.B
|
| 111 |
+
self.up = self.rand_conf(B); self.dn = self.rand_conf(B)
|
| 112 |
+
for _ in range(50):
|
| 113 |
+
bad = self.build()
|
| 114 |
+
if not bad.any():
|
| 115 |
+
break
|
| 116 |
+
k = int(bad.sum())
|
| 117 |
+
self.up[bad] = self.rand_conf(k); self.dn[bad] = self.rand_conf(k)
|
| 118 |
+
self.refresh()
|
| 119 |
+
|
| 120 |
+
# ---------------- Jastrow helper ----------------
|
| 121 |
+
def jas_single(self, spin, a, t, bshape_idx):
|
| 122 |
+
"""log J ratio for moving one spin-`spin` electron a->t (a, t broadcast with bshape_idx)."""
|
| 123 |
+
bi = bshape_idx
|
| 124 |
+
same, other = (self.nu, self.nd) if spin == 0 else (self.nd, self.nu)
|
| 125 |
+
V, g = self.V, self.g
|
| 126 |
+
jl = -g * (other[bi, t] - other[bi, a]) + self.h[bi, t] - self.h[bi, a] - V[a, t]
|
| 127 |
+
sg = 1.0 if spin == 0 else -1.0
|
| 128 |
+
jl = jl + sg * (self.hs[bi, t] - self.hs[bi, a]) - self.Us[a, t]
|
| 129 |
+
return jl
|
| 130 |
+
|
| 131 |
+
# ---------------- moves ----------------
|
| 132 |
+
def step(self, spin):
|
| 133 |
+
ar, n, N = self.ar, self.n, self.N
|
| 134 |
+
e = self._rand(n); d = self._rand(4)
|
| 135 |
+
pos, same, other = (self.up, self.nu, self.nd) if spin == 0 else (self.dn, self.nd, self.nu)
|
| 136 |
+
a = pos[ar, e]; t = self.nb[a, d]
|
| 137 |
+
blocked = same[ar, t] > 0.5
|
| 138 |
+
if spin == 0:
|
| 139 |
+
row = e
|
| 140 |
+
vec = self.Wt[t]
|
| 141 |
+
else:
|
| 142 |
+
row = n + self.hl[ar, t].clamp(min=0)
|
| 143 |
+
vec = self.Wt[N + a]
|
| 144 |
+
w = torch.einsum("bk,bkj->bj", vec, self.Ainv)
|
| 145 |
+
q = w[ar, row]
|
| 146 |
+
dJ = self.jas_single(spin, a, t, ar)
|
| 147 |
+
if self.use_dh:
|
| 148 |
+
new_same = self._moved(same, a, t)
|
| 149 |
+
nl = self.dh_log(new_same, other) if spin == 0 else self.dh_log(other, new_same)
|
| 150 |
+
dJ = dJ + nl - self.dhl
|
| 151 |
+
r = q * torch.exp(dJ)
|
| 152 |
+
acc = (torch.rand(self.B, generator=self.gen, device=DEV, dtype=DT) < r * r) & ~blocked
|
| 153 |
+
idx = torch.nonzero(acc).squeeze(1)
|
| 154 |
+
if idx.numel() == 0:
|
| 155 |
+
return 0
|
| 156 |
+
ri, wi, qi = row[idx], w[idx].clone(), q[idx]
|
| 157 |
+
wi[torch.arange(len(idx), device=DEV), ri] -= 1.0
|
| 158 |
+
self.Ainv[idx] -= self.Ainv[idx, :, ri][:, :, None] * wi[:, None, :] / qi[:, None, None]
|
| 159 |
+
self.A[idx, ri, :] = vec[idx]
|
| 160 |
+
# a large or tiny ratio means the old inverse was ill-conditioned (walker near a node):
|
| 161 |
+
# recompute those inverses from scratch instead of trusting the rank-1 update
|
| 162 |
+
big = (qi.abs() > 1e3) | (qi.abs() < 1e-3)
|
| 163 |
+
if big.any():
|
| 164 |
+
jb = idx[big]
|
| 165 |
+
self.Ainv[jb] = torch.linalg.inv_ex(self.A[jb])[0]
|
| 166 |
+
ai, ti = a[idx], t[idx]
|
| 167 |
+
if spin == 0:
|
| 168 |
+
self.up[idx, e[idx]] = ti
|
| 169 |
+
self.nu[idx, ai] = 0.0; self.nu[idx, ti] = 1.0
|
| 170 |
+
else:
|
| 171 |
+
beta = self.hl[idx, ti]
|
| 172 |
+
self.dn[idx, e[idx]] = ti
|
| 173 |
+
self.holes[idx, beta] = ai
|
| 174 |
+
self.hl[idx, ai] = beta; self.hl[idx, ti] = -1
|
| 175 |
+
self.nd[idx, ai] = 0.0; self.nd[idx, ti] = 1.0
|
| 176 |
+
sg = 1.0 if spin == 0 else -1.0
|
| 177 |
+
self.h[idx] += self.V[ti] - self.V[ai]
|
| 178 |
+
self.hs[idx] += sg * (self.Us[ti] - self.Us[ai])
|
| 179 |
+
if self.use_dh:
|
| 180 |
+
self.dhl[idx] = self.dh_log(self.nu[idx], self.nd[idx])
|
| 181 |
+
return len(idx)
|
| 182 |
+
|
| 183 |
+
def step_exchange(self):
|
| 184 |
+
"""Swap a neighbouring (up at i, down at j) pair with i, j singly occupied: up i->j, down j->i.
|
| 185 |
+
D, density and DH counts are unchanged; only the spin Jastrow and the determinant change."""
|
| 186 |
+
ar, n, N = self.ar, self.n, self.N
|
| 187 |
+
e = self._rand(n); d = self._rand(4)
|
| 188 |
+
i = self.up[ar, e]; j = self.nb[i, d]
|
| 189 |
+
ok = (self.nd[ar, j] > 0.5) & (self.nu[ar, j] < 0.5) & (self.nd[ar, i] < 0.5)
|
| 190 |
+
r = n + self.hl[ar, i].clamp(min=0) # hole at i moves to j
|
| 191 |
+
AinvT = self.Ainv.transpose(1, 2)
|
| 192 |
+
ca, cr = AinvT[ar, e], AinvT[ar, r]
|
| 193 |
+
u1, u2 = self.Wt[j], self.Wt[N + j]
|
| 194 |
+
det_r = (u1 * ca).sum(-1) * (u2 * cr).sum(-1) - (u1 * cr).sum(-1) * (u2 * ca).sum(-1)
|
| 195 |
+
jl = 2 * (self.hs[ar, j] - self.hs[ar, i]) - 4 * self.Us[i, j]
|
| 196 |
+
rr = det_r * torch.exp(jl)
|
| 197 |
+
acc = (torch.rand(self.B, generator=self.gen, device=DEV, dtype=DT) < rr * rr) & ok
|
| 198 |
+
idx = torch.nonzero(acc).squeeze(1)
|
| 199 |
+
if idx.numel() == 0:
|
| 200 |
+
return 0
|
| 201 |
+
ii, jj, ei, ri = i[idx], j[idx], e[idx], r[idx]
|
| 202 |
+
beta = self.hl[idx, ii]
|
| 203 |
+
ed = (self.dn[idx] == jj[:, None]).to(torch.long).argmax(1) # label of the down electron at j
|
| 204 |
+
self.up[idx, ei] = jj
|
| 205 |
+
self.dn[idx, ed] = ii
|
| 206 |
+
self.holes[idx, beta] = jj
|
| 207 |
+
self.hl[idx, jj] = beta; self.hl[idx, ii] = -1
|
| 208 |
+
self.nu[idx, ii] = 0.0; self.nu[idx, jj] = 1.0
|
| 209 |
+
self.nd[idx, jj] = 0.0; self.nd[idx, ii] = 1.0
|
| 210 |
+
self.hs[idx] += 2 * (self.Us[jj] - self.Us[ii])
|
| 211 |
+
self.A[idx, ei, :] = self.Wt[jj]
|
| 212 |
+
self.A[idx, ri, :] = self.Wt[N + jj]
|
| 213 |
+
self.Ainv[idx] = torch.linalg.inv_ex(self.A[idx])[0]
|
| 214 |
+
return len(idx)
|
| 215 |
+
|
| 216 |
+
def sweep(self):
|
| 217 |
+
acc = super().sweep()
|
| 218 |
+
for _ in range(self.n):
|
| 219 |
+
self.step_exchange()
|
| 220 |
+
self.refresh() # cheap (batched NxN inverse); keeps Ainv exact each sweep
|
| 221 |
+
return acc
|
| 222 |
+
|
| 223 |
+
# ---------------- estimators ----------------
|
| 224 |
+
def local_energy(self):
|
| 225 |
+
nu, nd, N, n = self.nu, self.nd, self.N, self.n
|
| 226 |
+
bi = self.ar[:, None, None]
|
| 227 |
+
D = (nu * nd).sum(1)
|
| 228 |
+
AinvT = self.Ainv.transpose(1, 2) # [b, col, k]
|
| 229 |
+
E = self.U * D
|
| 230 |
+
for spin in (0, 1):
|
| 231 |
+
pos, same, other = (self.up, nu, nd) if spin == 0 else (self.dn, nd, nu)
|
| 232 |
+
tgt = self.nb[pos]
|
| 233 |
+
src = pos[:, :, None].expand_as(tgt)
|
| 234 |
+
if spin == 0:
|
| 235 |
+
rows = self.Wt[tgt] # (B,n,4,N)
|
| 236 |
+
cols = AinvT[:, :n, :][:, :, None, :] # column alpha = electron label
|
| 237 |
+
q = (rows * cols).sum(-1)
|
| 238 |
+
else:
|
| 239 |
+
vec = self.Wt[N + pos][:, :, None, :] # (B,n,1,N)
|
| 240 |
+
r = n + self.hl[bi, tgt].clamp(min=0) # (B,n,4)
|
| 241 |
+
q = (vec * AinvT[bi, r]).sum(-1)
|
| 242 |
+
jl = self.jas_single(spin, src, tgt, bi)
|
| 243 |
+
if self.use_dh:
|
| 244 |
+
ns = self._moved(same[:, None, None, :].expand(-1, n, 4, -1), src, tgt)
|
| 245 |
+
ot = other[:, None, None, :].expand_as(ns)
|
| 246 |
+
nl = self.dh_log(ns, ot) if spin == 0 else self.dh_log(ot, ns)
|
| 247 |
+
jl = jl + nl - self.dhl[:, None, None]
|
| 248 |
+
term = torch.where(same[bi, tgt] < 0.5, q * torch.exp(jl), torch.zeros_like(q)).sum((1, 2))
|
| 249 |
+
E = E - term if spin == 0 else E + term
|
| 250 |
+
return E
|
| 251 |
+
|
| 252 |
+
def pair_corr(self, chunk=64):
|
| 253 |
+
out = torch.zeros(self.B, dtype=DT, device=DEV)
|
| 254 |
+
p, p2, q, q2 = self.pidx.T
|
| 255 |
+
n, N = self.n, self.N
|
| 256 |
+
ar_n = torch.arange(n, device=DEV)
|
| 257 |
+
for s in range(0, self.B, chunk):
|
| 258 |
+
sl = slice(s, min(s + chunk, self.B)); b = sl.stop - sl.start
|
| 259 |
+
nu, nd, up = self.nu[sl], self.nd[sl], self.up[sl]
|
| 260 |
+
AinvT, h, hs, hl = self.Ainv[sl].transpose(1, 2), self.h[sl], self.hs[sl], self.hl[sl]
|
| 261 |
+
ok = (nu[:, p] > 0.5) & (nd[:, q] > 0.5) & (nu[:, p2] < 0.5) & (nd[:, q2] < 0.5)
|
| 262 |
+
eu = torch.zeros((b, N), dtype=torch.long, device=DEV); eu.scatter_(1, up, ar_n.expand(b, n).contiguous())
|
| 263 |
+
al = eu[:, p] # up electron label at p
|
| 264 |
+
rr = n + hl[:, q2].clamp(min=0) # row of the hole at q2
|
| 265 |
+
bb = torch.arange(b, device=DEV)[:, None]
|
| 266 |
+
ca, cr = AinvT[bb, al], AinvT[bb, rr] # (b,T,N) columns alpha and r of Ainv
|
| 267 |
+
u1 = self.Wt[p2][None] # new row for alpha
|
| 268 |
+
u2 = self.Wt[N + q][None] # hole moves q2 -> q
|
| 269 |
+
det_r = (u1 * ca).sum(-1) * (u2 * cr).sum(-1) - (u1 * cr).sum(-1) * (u2 * ca).sum(-1)
|
| 270 |
+
V, g, Us = self.V, self.g, self.Us
|
| 271 |
+
j1 = -g * (nd[:, p2] - nd[:, p]) + h[:, p2] - h[:, p] - V[p, p2]
|
| 272 |
+
nu2_q2 = nu[:, q2] - (q2 == p).to(DT) + (q2 == p2).to(DT)
|
| 273 |
+
nu2_q = nu[:, q] - (q == p).to(DT) + (q == p2).to(DT)
|
| 274 |
+
j2 = -g * (nu2_q2 - nu2_q) + (h[:, q2] - V[q2, p] + V[q2, p2]) - (h[:, q] - V[q, p] + V[q, p2]) - V[q, q2]
|
| 275 |
+
s1 = hs[:, p2] - hs[:, p] - Us[p, p2]
|
| 276 |
+
s2 = -((hs[:, q2] + Us[q2, p2] - Us[q2, p]) - (hs[:, q] + Us[q, p2] - Us[q, p])) - Us[q, q2]
|
| 277 |
+
jl = j1 + j2 + s1 + s2
|
| 278 |
+
if self.use_dh:
|
| 279 |
+
T = len(p)
|
| 280 |
+
nu_new = self._moved(nu[:, None, :].expand(-1, T, -1), p[None, :].expand(b, -1), p2[None, :].expand(b, -1))
|
| 281 |
+
nd_new = self._moved(nd[:, None, :].expand(-1, T, -1), q[None, :].expand(b, -1), q2[None, :].expand(b, -1))
|
| 282 |
+
jl = jl + self.dh_log(nu_new, nd_new) - self.dhl[sl][:, None]
|
| 283 |
+
val = torch.where(ok, self.pc * det_r * torch.exp(jl), torch.zeros_like(det_r)).sum(1)
|
| 284 |
+
out[sl] = -0.25 * val / N # -1: down-spin part in hole representation
|
| 285 |
+
return out
|
| 286 |
+
|
| 287 |
+
def log_derivs(self, keys, dPHI):
|
| 288 |
+
cols = []
|
| 289 |
+
ntot, m = self.nu + self.nd, self.nu - self.nd
|
| 290 |
+
if any(k in ("kd", "kh") for k in keys):
|
| 291 |
+
Nd, Nh = self.dh_counts(self.nu, self.nd)
|
| 292 |
+
AinvT = self.Ainv.transpose(1, 2)
|
| 293 |
+
for k in keys:
|
| 294 |
+
if k == "g":
|
| 295 |
+
cols.append(-(self.nu * self.nd).sum(1))
|
| 296 |
+
elif k == "kd":
|
| 297 |
+
cols.append(-Nd)
|
| 298 |
+
elif k == "kh":
|
| 299 |
+
cols.append(-Nh)
|
| 300 |
+
elif k.startswith("v"):
|
| 301 |
+
cols.append(0.5 * torch.einsum("bi,ij,bj->b", ntot, self.Cmat[int(k[1:])], ntot))
|
| 302 |
+
elif k.startswith("u"):
|
| 303 |
+
cols.append(0.5 * torch.einsum("bi,ij,bj->b", m, self.Cmat[int(k[1:])], m))
|
| 304 |
+
else:
|
| 305 |
+
dW = dPHI[k]
|
| 306 |
+
dA = torch.cat([dW[self.up], dW[self.N + self.holes]], 1)
|
| 307 |
+
cols.append((AinvT * dA).sum((1, 2)))
|
| 308 |
+
return torch.stack(cols, 1)
|
| 309 |
+
|
| 310 |
+
|
| 311 |
+
def main():
|
| 312 |
+
ap = argparse.ArgumentParser()
|
| 313 |
+
ap.add_argument("--L", type=int, default=6)
|
| 314 |
+
ap.add_argument("--Ne", type=int, default=26)
|
| 315 |
+
ap.add_argument("--U", type=float, default=8.0)
|
| 316 |
+
ap.add_argument("--Delta", type=float, default=0.2)
|
| 317 |
+
ap.add_argument("--ds", type=float, default=0.05)
|
| 318 |
+
ap.add_argument("--mu", type=float, default=0.0)
|
| 319 |
+
ap.add_argument("--maf", type=float, default=0.0)
|
| 320 |
+
ap.add_argument("--tp", type=float, default=0.0)
|
| 321 |
+
ap.add_argument("--g", type=float, default=1.0)
|
| 322 |
+
ap.add_argument("--init", default="")
|
| 323 |
+
ap.add_argument("--walkers", type=int, default=2048)
|
| 324 |
+
ap.add_argument("--ntherm", type=int, default=100)
|
| 325 |
+
ap.add_argument("--nmeas", type=int, default=20)
|
| 326 |
+
ap.add_argument("--opt", default="", help="comma list of Delta,ds,mu,maf,tp,g,jas,sjas,dh")
|
| 327 |
+
ap.add_argument("--iters", type=int, default=300)
|
| 328 |
+
ap.add_argument("--nmeas_opt", type=int, default=1)
|
| 329 |
+
ap.add_argument("--lr", type=float, default=0.05)
|
| 330 |
+
ap.add_argument("--gap", type=int, default=2, help="sweeps between SR measurements")
|
| 331 |
+
ap.add_argument("--pre", type=int, default=3, help="sweeps after each parameter update")
|
| 332 |
+
ap.add_argument("--seed", type=int, default=0)
|
| 333 |
+
ap.add_argument("--out", default="")
|
| 334 |
+
a = ap.parse_args()
|
| 335 |
+
t0 = time.time()
|
| 336 |
+
par = dict(Delta=a.Delta, ds=a.ds, mu=a.mu, maf=a.maf, tp=a.tp, g=a.g)
|
| 337 |
+
if a.init:
|
| 338 |
+
p0 = json.load(open(a.init))["result"]["par"]
|
| 339 |
+
par.update({k: (np.array(v) if isinstance(v, list) else v) for k, v in p0.items() if k != "a"})
|
| 340 |
+
import sys
|
| 341 |
+
for k in ("Delta", "ds", "mu", "maf", "tp", "g"): # explicit command-line values win over --init
|
| 342 |
+
if any(x == f"--{k}" or x.startswith(f"--{k}=") for x in sys.argv):
|
| 343 |
+
par[k] = getattr(a, k)
|
| 344 |
+
if "dh" in a.opt:
|
| 345 |
+
par["dh_on"] = True
|
| 346 |
+
vm = BatchVMC3(a.L, a.Ne, a.U, par, a.walkers, a.seed)
|
| 347 |
+
for s in range(a.ntherm):
|
| 348 |
+
vm.sweep()
|
| 349 |
+
if s % 10 == 0:
|
| 350 |
+
vm.refresh()
|
| 351 |
+
nv = len(vm.lat.classes)
|
| 352 |
+
hist = []
|
| 353 |
+
if a.opt:
|
| 354 |
+
keys = []
|
| 355 |
+
for k in a.opt.split(","):
|
| 356 |
+
keys += ([f"v{c}" for c in range(nv)] if k == "jas" else [f"u{c}" for c in range(nv)] if k == "sjas"
|
| 357 |
+
else ["kd", "kh"] if k == "dh" else [k])
|
| 358 |
+
log = open(a.out.replace(".json", ".opt.log"), "w") if a.out else None
|
| 359 |
+
par, hist = V2.optimize(vm, par, keys, a.iters, a.nmeas_opt, a.lr, log, gap=a.gap, pre=a.pre)
|
| 360 |
+
vm.set_params(par); vm.refresh()
|
| 361 |
+
for _ in range(20):
|
| 362 |
+
vm.sweep()
|
| 363 |
+
r = V2.measure(vm, a.nmeas)
|
| 364 |
+
r.update(L=a.L, Ne=a.Ne, U=a.U, opt=a.opt, pairing="ph", walkers=a.walkers,
|
| 365 |
+
par={k: (np.round(v, 5).tolist() if isinstance(v, np.ndarray) else (v if isinstance(v, bool) else round(float(v), 5)))
|
| 366 |
+
for k, v in par.items()},
|
| 367 |
+
sec=round(time.time() - t0, 1), engine="gpu3")
|
| 368 |
+
print(json.dumps(r))
|
| 369 |
+
if a.out:
|
| 370 |
+
json.dump(dict(result=r, hist=hist), open(a.out, "w"), indent=1)
|
| 371 |
+
|
| 372 |
+
|
| 373 |
+
if __name__ == "__main__":
|
| 374 |
+
main()
|
methods/Yuseon84/configs/vmc4x4_Ne10.json
ADDED
|
@@ -0,0 +1,33 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.0998,
|
| 5 |
+
"ds": 0.00206,
|
| 6 |
+
"mu": -0.41572,
|
| 7 |
+
"maf": 0.00176,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.12306,
|
| 10 |
+
"dh_on": true,
|
| 11 |
+
"v": [
|
| 12 |
+
-0.06788,
|
| 13 |
+
-0.01024,
|
| 14 |
+
-0.0145,
|
| 15 |
+
0.02395,
|
| 16 |
+
0.08593
|
| 17 |
+
],
|
| 18 |
+
"u": [
|
| 19 |
+
0.05008,
|
| 20 |
+
0.00307,
|
| 21 |
+
0.00473,
|
| 22 |
+
-0.02286,
|
| 23 |
+
-0.07523
|
| 24 |
+
],
|
| 25 |
+
"kd": 0.19406,
|
| 26 |
+
"kh": 0.03545
|
| 27 |
+
},
|
| 28 |
+
"L": 4,
|
| 29 |
+
"Ne": 10,
|
| 30 |
+
"U": 8.0,
|
| 31 |
+
"source": "ph_4x4_Ne10.json"
|
| 32 |
+
}
|
| 33 |
+
}
|
methods/Yuseon84/configs/vmc4x4_Ne12.json
ADDED
|
@@ -0,0 +1,33 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.12697,
|
| 5 |
+
"ds": 0.0205,
|
| 6 |
+
"mu": -0.19953,
|
| 7 |
+
"maf": 0.2,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.28783,
|
| 10 |
+
"kd": 0.28079,
|
| 11 |
+
"kh": 0.06687,
|
| 12 |
+
"dh_on": true,
|
| 13 |
+
"v": [
|
| 14 |
+
-0.08859,
|
| 15 |
+
-0.01898,
|
| 16 |
+
-0.02656,
|
| 17 |
+
0.00574,
|
| 18 |
+
0.04997
|
| 19 |
+
],
|
| 20 |
+
"u": [
|
| 21 |
+
0.05543,
|
| 22 |
+
-0.01683,
|
| 23 |
+
0.01772,
|
| 24 |
+
-0.00663,
|
| 25 |
+
-0.02677
|
| 26 |
+
]
|
| 27 |
+
},
|
| 28 |
+
"L": 4,
|
| 29 |
+
"Ne": 12,
|
| 30 |
+
"U": 8.0,
|
| 31 |
+
"source": "ph4_4x4_Ne12_maf0.2.json"
|
| 32 |
+
}
|
| 33 |
+
}
|
methods/Yuseon84/configs/vmc4x4_Ne14.json
ADDED
|
@@ -0,0 +1,33 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.1617,
|
| 5 |
+
"ds": 0.02305,
|
| 6 |
+
"mu": -0.39171,
|
| 7 |
+
"maf": 0.4,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.32995,
|
| 10 |
+
"kd": 0.28119,
|
| 11 |
+
"kh": 0.12059,
|
| 12 |
+
"dh_on": true,
|
| 13 |
+
"v": [
|
| 14 |
+
-0.0965,
|
| 15 |
+
-0.00058,
|
| 16 |
+
-0.04149,
|
| 17 |
+
0.00222,
|
| 18 |
+
0.03332
|
| 19 |
+
],
|
| 20 |
+
"u": [
|
| 21 |
+
0.03165,
|
| 22 |
+
-0.02631,
|
| 23 |
+
-0.00118,
|
| 24 |
+
-0.00086,
|
| 25 |
+
-0.02519
|
| 26 |
+
]
|
| 27 |
+
},
|
| 28 |
+
"L": 4,
|
| 29 |
+
"Ne": 14,
|
| 30 |
+
"U": 8.0,
|
| 31 |
+
"source": "ph4_4x4_Ne14_maf0.4.json"
|
| 32 |
+
}
|
| 33 |
+
}
|
methods/Yuseon84/configs/vmc4x4_Ne16.json
ADDED
|
@@ -0,0 +1,33 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.21793,
|
| 5 |
+
"ds": 0.01463,
|
| 6 |
+
"mu": -0.01813,
|
| 7 |
+
"maf": 1.27417,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.18359,
|
| 10 |
+
"dh_on": true,
|
| 11 |
+
"v": [
|
| 12 |
+
-0.16538,
|
| 13 |
+
-0.14245,
|
| 14 |
+
-0.15601,
|
| 15 |
+
-0.12525,
|
| 16 |
+
-0.08278
|
| 17 |
+
],
|
| 18 |
+
"u": [
|
| 19 |
+
0.04789,
|
| 20 |
+
-0.02247,
|
| 21 |
+
-0.0101,
|
| 22 |
+
-0.01343,
|
| 23 |
+
-0.02826
|
| 24 |
+
],
|
| 25 |
+
"kd": 0.22127,
|
| 26 |
+
"kh": 0.22412
|
| 27 |
+
},
|
| 28 |
+
"L": 4,
|
| 29 |
+
"Ne": 16,
|
| 30 |
+
"U": 8.0,
|
| 31 |
+
"source": "ph_4x4_Ne16.json"
|
| 32 |
+
}
|
| 33 |
+
}
|
methods/Yuseon84/configs/vmc4x4_Ne8.json
ADDED
|
@@ -0,0 +1,33 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.13307,
|
| 5 |
+
"ds": -0.0035,
|
| 6 |
+
"mu": -0.74991,
|
| 7 |
+
"maf": 0.00331,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.03545,
|
| 10 |
+
"dh_on": true,
|
| 11 |
+
"v": [
|
| 12 |
+
-0.05843,
|
| 13 |
+
-0.02974,
|
| 14 |
+
0.0094,
|
| 15 |
+
0.02069,
|
| 16 |
+
0.05466
|
| 17 |
+
],
|
| 18 |
+
"u": [
|
| 19 |
+
0.05041,
|
| 20 |
+
-0.02189,
|
| 21 |
+
0.01166,
|
| 22 |
+
-0.01824,
|
| 23 |
+
-0.04192
|
| 24 |
+
],
|
| 25 |
+
"kd": 0.12758,
|
| 26 |
+
"kh": 0.01025
|
| 27 |
+
},
|
| 28 |
+
"L": 4,
|
| 29 |
+
"Ne": 8,
|
| 30 |
+
"U": 8.0,
|
| 31 |
+
"source": "ph_4x4_Ne8.json"
|
| 32 |
+
}
|
| 33 |
+
}
|
methods/Yuseon84/configs/vmc6x6_Ne20.json
ADDED
|
@@ -0,0 +1,41 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.02563,
|
| 5 |
+
"ds": 0.02137,
|
| 6 |
+
"mu": -0.96859,
|
| 7 |
+
"maf": 0.0,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.10282,
|
| 10 |
+
"dh_on": true,
|
| 11 |
+
"v": [
|
| 12 |
+
-0.07071,
|
| 13 |
+
-0.00896,
|
| 14 |
+
0.01409,
|
| 15 |
+
-0.00941,
|
| 16 |
+
0.0083,
|
| 17 |
+
0.01897,
|
| 18 |
+
0.01944,
|
| 19 |
+
0.02261,
|
| 20 |
+
0.02977
|
| 21 |
+
],
|
| 22 |
+
"u": [
|
| 23 |
+
0.0434,
|
| 24 |
+
0.00699,
|
| 25 |
+
-0.00655,
|
| 26 |
+
0.00034,
|
| 27 |
+
-0.00189,
|
| 28 |
+
-0.01199,
|
| 29 |
+
-0.00537,
|
| 30 |
+
-0.01172,
|
| 31 |
+
-0.01583
|
| 32 |
+
],
|
| 33 |
+
"kd": 0.203,
|
| 34 |
+
"kh": 0.02784
|
| 35 |
+
},
|
| 36 |
+
"L": 6,
|
| 37 |
+
"Ne": 20,
|
| 38 |
+
"U": 8.0,
|
| 39 |
+
"source": "ph66_Ne20_maf0.0.json"
|
| 40 |
+
}
|
| 41 |
+
}
|
methods/Yuseon84/configs/vmc6x6_Ne22.json
ADDED
|
@@ -0,0 +1,41 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.02619,
|
| 5 |
+
"ds": 0.0219,
|
| 6 |
+
"mu": -0.96279,
|
| 7 |
+
"maf": 0.0,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.15585,
|
| 10 |
+
"dh_on": true,
|
| 11 |
+
"v": [
|
| 12 |
+
-0.07419,
|
| 13 |
+
-0.00989,
|
| 14 |
+
0.00981,
|
| 15 |
+
-0.01355,
|
| 16 |
+
0.01077,
|
| 17 |
+
0.01917,
|
| 18 |
+
0.02564,
|
| 19 |
+
0.02822,
|
| 20 |
+
0.04184
|
| 21 |
+
],
|
| 22 |
+
"u": [
|
| 23 |
+
0.04465,
|
| 24 |
+
0.007,
|
| 25 |
+
-0.00128,
|
| 26 |
+
0.00554,
|
| 27 |
+
-0.00164,
|
| 28 |
+
-0.01147,
|
| 29 |
+
-0.00898,
|
| 30 |
+
-0.01758,
|
| 31 |
+
-0.02681
|
| 32 |
+
],
|
| 33 |
+
"kd": 0.21836,
|
| 34 |
+
"kh": 0.03902
|
| 35 |
+
},
|
| 36 |
+
"L": 6,
|
| 37 |
+
"Ne": 22,
|
| 38 |
+
"U": 8.0,
|
| 39 |
+
"source": "ph66_Ne22_maf0.0.json"
|
| 40 |
+
}
|
| 41 |
+
}
|
methods/Yuseon84/configs/vmc6x6_Ne24.json
ADDED
|
@@ -0,0 +1,41 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.03828,
|
| 5 |
+
"ds": 0.02094,
|
| 6 |
+
"mu": -0.90513,
|
| 7 |
+
"maf": 0.0,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.21146,
|
| 10 |
+
"dh_on": true,
|
| 11 |
+
"v": [
|
| 12 |
+
-0.07734,
|
| 13 |
+
-0.00963,
|
| 14 |
+
0.00809,
|
| 15 |
+
-0.02051,
|
| 16 |
+
0.01222,
|
| 17 |
+
0.02135,
|
| 18 |
+
0.03282,
|
| 19 |
+
0.03904,
|
| 20 |
+
0.06109
|
| 21 |
+
],
|
| 22 |
+
"u": [
|
| 23 |
+
0.05032,
|
| 24 |
+
0.00825,
|
| 25 |
+
0.00047,
|
| 26 |
+
0.01237,
|
| 27 |
+
-0.0024,
|
| 28 |
+
-0.01123,
|
| 29 |
+
-0.01479,
|
| 30 |
+
-0.02344,
|
| 31 |
+
-0.04102
|
| 32 |
+
],
|
| 33 |
+
"kd": 0.21347,
|
| 34 |
+
"kh": 0.05345
|
| 35 |
+
},
|
| 36 |
+
"L": 6,
|
| 37 |
+
"Ne": 24,
|
| 38 |
+
"U": 8.0,
|
| 39 |
+
"source": "ph66_Ne24_maf0.0.json"
|
| 40 |
+
}
|
| 41 |
+
}
|
methods/Yuseon84/configs/vmc6x6_Ne26.json
ADDED
|
@@ -0,0 +1,41 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.05392,
|
| 5 |
+
"ds": 0.02047,
|
| 6 |
+
"mu": -0.35407,
|
| 7 |
+
"maf": 0.0,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.26641,
|
| 10 |
+
"dh_on": true,
|
| 11 |
+
"v": [
|
| 12 |
+
-0.07925,
|
| 13 |
+
-0.01033,
|
| 14 |
+
0.00802,
|
| 15 |
+
-0.02867,
|
| 16 |
+
0.01187,
|
| 17 |
+
0.02424,
|
| 18 |
+
0.03973,
|
| 19 |
+
0.05393,
|
| 20 |
+
0.08975
|
| 21 |
+
],
|
| 22 |
+
"u": [
|
| 23 |
+
0.05749,
|
| 24 |
+
0.0119,
|
| 25 |
+
0.00028,
|
| 26 |
+
0.01901,
|
| 27 |
+
-0.00353,
|
| 28 |
+
-0.01091,
|
| 29 |
+
-0.02145,
|
| 30 |
+
-0.02849,
|
| 31 |
+
-0.05651
|
| 32 |
+
],
|
| 33 |
+
"kd": 0.22743,
|
| 34 |
+
"kh": 0.07149
|
| 35 |
+
},
|
| 36 |
+
"L": 6,
|
| 37 |
+
"Ne": 26,
|
| 38 |
+
"U": 8.0,
|
| 39 |
+
"source": "ph66_Ne26_maf0.0.json"
|
| 40 |
+
}
|
| 41 |
+
}
|
methods/Yuseon84/configs/vmc6x6_Ne28.json
ADDED
|
@@ -0,0 +1,41 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.07864,
|
| 5 |
+
"ds": 0.02155,
|
| 6 |
+
"mu": -0.20928,
|
| 7 |
+
"maf": 0.0,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.32143,
|
| 10 |
+
"dh_on": true,
|
| 11 |
+
"v": [
|
| 12 |
+
-0.08788,
|
| 13 |
+
-6e-05,
|
| 14 |
+
0.02011,
|
| 15 |
+
-0.03368,
|
| 16 |
+
0.02117,
|
| 17 |
+
0.03647,
|
| 18 |
+
0.04647,
|
| 19 |
+
0.0579,
|
| 20 |
+
0.08647
|
| 21 |
+
],
|
| 22 |
+
"u": [
|
| 23 |
+
0.05179,
|
| 24 |
+
0.00981,
|
| 25 |
+
-0.00268,
|
| 26 |
+
0.02134,
|
| 27 |
+
-0.00275,
|
| 28 |
+
-0.01113,
|
| 29 |
+
-0.01811,
|
| 30 |
+
-0.02732,
|
| 31 |
+
-0.04784
|
| 32 |
+
],
|
| 33 |
+
"kd": 0.26507,
|
| 34 |
+
"kh": 0.09142
|
| 35 |
+
},
|
| 36 |
+
"L": 6,
|
| 37 |
+
"Ne": 28,
|
| 38 |
+
"U": 8.0,
|
| 39 |
+
"source": "ph66_Ne28_maf0.0.json"
|
| 40 |
+
}
|
| 41 |
+
}
|
methods/Yuseon84/configs/vmc6x6_Ne30.json
ADDED
|
@@ -0,0 +1,41 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.0848,
|
| 5 |
+
"ds": 0.02106,
|
| 6 |
+
"mu": -0.35284,
|
| 7 |
+
"maf": 0.3,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.3178,
|
| 10 |
+
"dh_on": true,
|
| 11 |
+
"v": [
|
| 12 |
+
-0.08106,
|
| 13 |
+
0.00758,
|
| 14 |
+
0.0201,
|
| 15 |
+
-0.02673,
|
| 16 |
+
0.02772,
|
| 17 |
+
0.03987,
|
| 18 |
+
0.04864,
|
| 19 |
+
0.05414,
|
| 20 |
+
0.07247
|
| 21 |
+
],
|
| 22 |
+
"u": [
|
| 23 |
+
0.05138,
|
| 24 |
+
0.00343,
|
| 25 |
+
-0.00425,
|
| 26 |
+
0.01844,
|
| 27 |
+
0.00149,
|
| 28 |
+
-0.01418,
|
| 29 |
+
-0.02106,
|
| 30 |
+
-0.02245,
|
| 31 |
+
-0.04151
|
| 32 |
+
],
|
| 33 |
+
"kd": 0.29551,
|
| 34 |
+
"kh": 0.10045
|
| 35 |
+
},
|
| 36 |
+
"L": 6,
|
| 37 |
+
"Ne": 30,
|
| 38 |
+
"U": 8.0,
|
| 39 |
+
"source": "ph66_Ne30_maf0.3.json"
|
| 40 |
+
}
|
| 41 |
+
}
|
methods/Yuseon84/configs/vmc6x6_Ne32.json
ADDED
|
@@ -0,0 +1,41 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.09129,
|
| 5 |
+
"ds": 0.0218,
|
| 6 |
+
"mu": -0.60162,
|
| 7 |
+
"maf": 0.6,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.25719,
|
| 10 |
+
"dh_on": true,
|
| 11 |
+
"v": [
|
| 12 |
+
-0.0668,
|
| 13 |
+
0.01378,
|
| 14 |
+
0.02051,
|
| 15 |
+
-0.01795,
|
| 16 |
+
0.03128,
|
| 17 |
+
0.0414,
|
| 18 |
+
0.04698,
|
| 19 |
+
0.04866,
|
| 20 |
+
0.05767
|
| 21 |
+
],
|
| 22 |
+
"u": [
|
| 23 |
+
0.04554,
|
| 24 |
+
-0.00241,
|
| 25 |
+
-0.00601,
|
| 26 |
+
0.01561,
|
| 27 |
+
0.0035,
|
| 28 |
+
-0.01424,
|
| 29 |
+
-0.02091,
|
| 30 |
+
-0.01689,
|
| 31 |
+
-0.03178
|
| 32 |
+
],
|
| 33 |
+
"kd": 0.32208,
|
| 34 |
+
"kh": 0.10534
|
| 35 |
+
},
|
| 36 |
+
"L": 6,
|
| 37 |
+
"Ne": 32,
|
| 38 |
+
"U": 8.0,
|
| 39 |
+
"source": "ph66_Ne32_maf0.6.json"
|
| 40 |
+
}
|
| 41 |
+
}
|
methods/Yuseon84/configs/vmc6x6_Ne34.json
ADDED
|
@@ -0,0 +1,41 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.10888,
|
| 5 |
+
"ds": 0.02288,
|
| 6 |
+
"mu": -0.84637,
|
| 7 |
+
"maf": 0.9,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.16985,
|
| 10 |
+
"dh_on": true,
|
| 11 |
+
"v": [
|
| 12 |
+
-0.05133,
|
| 13 |
+
0.01513,
|
| 14 |
+
0.02204,
|
| 15 |
+
-0.01258,
|
| 16 |
+
0.03235,
|
| 17 |
+
0.04347,
|
| 18 |
+
0.04807,
|
| 19 |
+
0.04994,
|
| 20 |
+
0.05347
|
| 21 |
+
],
|
| 22 |
+
"u": [
|
| 23 |
+
0.03781,
|
| 24 |
+
-0.00965,
|
| 25 |
+
-0.01007,
|
| 26 |
+
0.01092,
|
| 27 |
+
0.00386,
|
| 28 |
+
-0.01313,
|
| 29 |
+
-0.01525,
|
| 30 |
+
-0.00916,
|
| 31 |
+
-0.01883
|
| 32 |
+
],
|
| 33 |
+
"kd": 0.33596,
|
| 34 |
+
"kh": 0.11978
|
| 35 |
+
},
|
| 36 |
+
"L": 6,
|
| 37 |
+
"Ne": 34,
|
| 38 |
+
"U": 8.0,
|
| 39 |
+
"source": "ph66_Ne34_maf0.9.json"
|
| 40 |
+
}
|
| 41 |
+
}
|
methods/Yuseon84/configs/vmc6x6_Ne36.json
ADDED
|
@@ -0,0 +1,41 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"result": {
|
| 3 |
+
"par": {
|
| 4 |
+
"Delta": 0.19659,
|
| 5 |
+
"ds": 0.04048,
|
| 6 |
+
"mu": -0.05666,
|
| 7 |
+
"maf": 1.6,
|
| 8 |
+
"tp": 0.0,
|
| 9 |
+
"g": 1.08013,
|
| 10 |
+
"dh_on": true,
|
| 11 |
+
"v": [
|
| 12 |
+
-0.05132,
|
| 13 |
+
-0.00532,
|
| 14 |
+
0.01459,
|
| 15 |
+
-0.03448,
|
| 16 |
+
0.01007,
|
| 17 |
+
0.03116,
|
| 18 |
+
0.0414,
|
| 19 |
+
0.05586,
|
| 20 |
+
0.06954
|
| 21 |
+
],
|
| 22 |
+
"u": [
|
| 23 |
+
0.05813,
|
| 24 |
+
-0.00466,
|
| 25 |
+
-0.00206,
|
| 26 |
+
0.00417,
|
| 27 |
+
-0.00046,
|
| 28 |
+
-0.01494,
|
| 29 |
+
-0.01559,
|
| 30 |
+
-0.00803,
|
| 31 |
+
-0.01631
|
| 32 |
+
],
|
| 33 |
+
"kd": 0.21062,
|
| 34 |
+
"kh": 0.2192
|
| 35 |
+
},
|
| 36 |
+
"L": 6,
|
| 37 |
+
"Ne": 36,
|
| 38 |
+
"U": 8.0,
|
| 39 |
+
"source": "ph66_Ne36_maf1.6.json"
|
| 40 |
+
}
|
| 41 |
+
}
|
methods/Yuseon84/expected/ed4x4_Ne10_U8.json
ADDED
|
@@ -0,0 +1,25 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
[
|
| 2 |
+
{
|
| 3 |
+
"L": 4,
|
| 4 |
+
"Ne": 10,
|
| 5 |
+
"n": 0.625,
|
| 6 |
+
"U": 8.0,
|
| 7 |
+
"E0": -17.51036669487872,
|
| 8 |
+
"deg": 1,
|
| 9 |
+
"dim": 19079424,
|
| 10 |
+
"lowest": [
|
| 11 |
+
-17.51036669,
|
| 12 |
+
-16.41072802,
|
| 13 |
+
-16.41072802,
|
| 14 |
+
-16.40185429,
|
| 15 |
+
-16.40185429,
|
| 16 |
+
-15.94180026
|
| 17 |
+
],
|
| 18 |
+
"Pd": {
|
| 19 |
+
"2,2": 0.060122,
|
| 20 |
+
"1,1": -0.02086,
|
| 21 |
+
"2,0": 0.11386
|
| 22 |
+
},
|
| 23 |
+
"sec": 760.7
|
| 24 |
+
}
|
| 25 |
+
]
|
methods/Yuseon84/expected/ed4x4_Ne12_U8.json
ADDED
|
@@ -0,0 +1,118 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"L": 4,
|
| 3 |
+
"Ne": 12,
|
| 4 |
+
"n": 0.75,
|
| 5 |
+
"U": 8.0,
|
| 6 |
+
"E0": -14.925310215108421,
|
| 7 |
+
"deg": 2,
|
| 8 |
+
"R": [
|
| 9 |
+
2,
|
| 10 |
+
2
|
| 11 |
+
],
|
| 12 |
+
"Pd": 0.009831,
|
| 13 |
+
"manifold": [
|
| 14 |
+
{
|
| 15 |
+
"k": [
|
| 16 |
+
0,
|
| 17 |
+
0
|
| 18 |
+
],
|
| 19 |
+
"mult": 1,
|
| 20 |
+
"Pd": -0.0038063
|
| 21 |
+
},
|
| 22 |
+
{
|
| 23 |
+
"k": [
|
| 24 |
+
2,
|
| 25 |
+
2
|
| 26 |
+
],
|
| 27 |
+
"mult": 1,
|
| 28 |
+
"Pd": 0.02346846
|
| 29 |
+
}
|
| 30 |
+
],
|
| 31 |
+
"sectors": [
|
| 32 |
+
{
|
| 33 |
+
"k": [
|
| 34 |
+
0,
|
| 35 |
+
0
|
| 36 |
+
],
|
| 37 |
+
"mult": 1,
|
| 38 |
+
"E": [
|
| 39 |
+
-14.92531022,
|
| 40 |
+
-14.88407343,
|
| 41 |
+
-14.8628084,
|
| 42 |
+
-14.75289456,
|
| 43 |
+
-14.75289456
|
| 44 |
+
]
|
| 45 |
+
},
|
| 46 |
+
{
|
| 47 |
+
"k": [
|
| 48 |
+
0,
|
| 49 |
+
1
|
| 50 |
+
],
|
| 51 |
+
"mult": 4,
|
| 52 |
+
"E": [
|
| 53 |
+
-14.3356551,
|
| 54 |
+
-14.33138874,
|
| 55 |
+
-14.32786361,
|
| 56 |
+
-14.22099077,
|
| 57 |
+
-14.18839612
|
| 58 |
+
]
|
| 59 |
+
},
|
| 60 |
+
{
|
| 61 |
+
"k": [
|
| 62 |
+
0,
|
| 63 |
+
2
|
| 64 |
+
],
|
| 65 |
+
"mult": 2,
|
| 66 |
+
"E": [
|
| 67 |
+
-14.8628084,
|
| 68 |
+
-14.83539165,
|
| 69 |
+
-14.73233341,
|
| 70 |
+
-14.06807973,
|
| 71 |
+
-13.8609654
|
| 72 |
+
]
|
| 73 |
+
},
|
| 74 |
+
{
|
| 75 |
+
"k": [
|
| 76 |
+
1,
|
| 77 |
+
1
|
| 78 |
+
],
|
| 79 |
+
"mult": 4,
|
| 80 |
+
"E": [
|
| 81 |
+
-14.83855246,
|
| 82 |
+
-14.83539165,
|
| 83 |
+
-14.75289456,
|
| 84 |
+
-14.06807973,
|
| 85 |
+
-13.74777826
|
| 86 |
+
]
|
| 87 |
+
},
|
| 88 |
+
{
|
| 89 |
+
"k": [
|
| 90 |
+
1,
|
| 91 |
+
2
|
| 92 |
+
],
|
| 93 |
+
"mult": 4,
|
| 94 |
+
"E": [
|
| 95 |
+
-14.4413513,
|
| 96 |
+
-14.3356551,
|
| 97 |
+
-14.33138874,
|
| 98 |
+
-14.22099077,
|
| 99 |
+
-14.16796227
|
| 100 |
+
]
|
| 101 |
+
},
|
| 102 |
+
{
|
| 103 |
+
"k": [
|
| 104 |
+
2,
|
| 105 |
+
2
|
| 106 |
+
],
|
| 107 |
+
"mult": 1,
|
| 108 |
+
"E": [
|
| 109 |
+
-14.92531022,
|
| 110 |
+
-14.88407343,
|
| 111 |
+
-14.83855246,
|
| 112 |
+
-14.83855246,
|
| 113 |
+
-14.73233341
|
| 114 |
+
]
|
| 115 |
+
}
|
| 116 |
+
],
|
| 117 |
+
"sec": 294.4
|
| 118 |
+
}
|
methods/Yuseon84/expected/ed4x4_Ne14_U8.json
ADDED
|
@@ -0,0 +1,118 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"L": 4,
|
| 3 |
+
"Ne": 14,
|
| 4 |
+
"n": 0.875,
|
| 5 |
+
"U": 8.0,
|
| 6 |
+
"E0": -11.868835569563847,
|
| 7 |
+
"deg": 3,
|
| 8 |
+
"R": [
|
| 9 |
+
2,
|
| 10 |
+
2
|
| 11 |
+
],
|
| 12 |
+
"Pd": 0.019219,
|
| 13 |
+
"manifold": [
|
| 14 |
+
{
|
| 15 |
+
"k": [
|
| 16 |
+
0,
|
| 17 |
+
0
|
| 18 |
+
],
|
| 19 |
+
"mult": 1,
|
| 20 |
+
"Pd": 0.02313437
|
| 21 |
+
},
|
| 22 |
+
{
|
| 23 |
+
"k": [
|
| 24 |
+
0,
|
| 25 |
+
2
|
| 26 |
+
],
|
| 27 |
+
"mult": 2,
|
| 28 |
+
"Pd": 0.01726132
|
| 29 |
+
}
|
| 30 |
+
],
|
| 31 |
+
"sectors": [
|
| 32 |
+
{
|
| 33 |
+
"k": [
|
| 34 |
+
0,
|
| 35 |
+
0
|
| 36 |
+
],
|
| 37 |
+
"mult": 1,
|
| 38 |
+
"E": [
|
| 39 |
+
-11.86883557,
|
| 40 |
+
-11.67827698,
|
| 41 |
+
-11.67827698,
|
| 42 |
+
-11.57364559,
|
| 43 |
+
-11.47497089
|
| 44 |
+
]
|
| 45 |
+
},
|
| 46 |
+
{
|
| 47 |
+
"k": [
|
| 48 |
+
0,
|
| 49 |
+
1
|
| 50 |
+
],
|
| 51 |
+
"mult": 4,
|
| 52 |
+
"E": [
|
| 53 |
+
-11.35927592,
|
| 54 |
+
-11.33489502,
|
| 55 |
+
-11.29014245,
|
| 56 |
+
-11.24306586,
|
| 57 |
+
-11.21389222
|
| 58 |
+
]
|
| 59 |
+
},
|
| 60 |
+
{
|
| 61 |
+
"k": [
|
| 62 |
+
0,
|
| 63 |
+
2
|
| 64 |
+
],
|
| 65 |
+
"mult": 2,
|
| 66 |
+
"E": [
|
| 67 |
+
-11.86883557,
|
| 68 |
+
-11.77617927,
|
| 69 |
+
-11.71327391,
|
| 70 |
+
-11.56367048,
|
| 71 |
+
-11.49536334
|
| 72 |
+
]
|
| 73 |
+
},
|
| 74 |
+
{
|
| 75 |
+
"k": [
|
| 76 |
+
1,
|
| 77 |
+
1
|
| 78 |
+
],
|
| 79 |
+
"mult": 4,
|
| 80 |
+
"E": [
|
| 81 |
+
-11.82490062,
|
| 82 |
+
-11.77617927,
|
| 83 |
+
-11.67827698,
|
| 84 |
+
-11.56367048,
|
| 85 |
+
-11.49536334
|
| 86 |
+
]
|
| 87 |
+
},
|
| 88 |
+
{
|
| 89 |
+
"k": [
|
| 90 |
+
1,
|
| 91 |
+
2
|
| 92 |
+
],
|
| 93 |
+
"mult": 4,
|
| 94 |
+
"E": [
|
| 95 |
+
-11.35927592,
|
| 96 |
+
-11.33489502,
|
| 97 |
+
-11.29014245,
|
| 98 |
+
-11.24306586,
|
| 99 |
+
-11.21389222
|
| 100 |
+
]
|
| 101 |
+
},
|
| 102 |
+
{
|
| 103 |
+
"k": [
|
| 104 |
+
2,
|
| 105 |
+
2
|
| 106 |
+
],
|
| 107 |
+
"mult": 1,
|
| 108 |
+
"E": [
|
| 109 |
+
-11.82490062,
|
| 110 |
+
-11.82490062,
|
| 111 |
+
-11.71327391,
|
| 112 |
+
-11.47497089,
|
| 113 |
+
-11.40301738
|
| 114 |
+
]
|
| 115 |
+
}
|
| 116 |
+
],
|
| 117 |
+
"sec": 540.6
|
| 118 |
+
}
|
methods/Yuseon84/expected/ed4x4_Ne16_U8.json
ADDED
|
@@ -0,0 +1,110 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"L": 4,
|
| 3 |
+
"Ne": 16,
|
| 4 |
+
"n": 1.0,
|
| 5 |
+
"U": 8.0,
|
| 6 |
+
"E0": -8.468875014196751,
|
| 7 |
+
"deg": 1,
|
| 8 |
+
"R": [
|
| 9 |
+
2,
|
| 10 |
+
2
|
| 11 |
+
],
|
| 12 |
+
"Pd": 0.006197,
|
| 13 |
+
"manifold": [
|
| 14 |
+
{
|
| 15 |
+
"k": [
|
| 16 |
+
0,
|
| 17 |
+
0
|
| 18 |
+
],
|
| 19 |
+
"mult": 1,
|
| 20 |
+
"Pd": 0.00619709
|
| 21 |
+
}
|
| 22 |
+
],
|
| 23 |
+
"sectors": [
|
| 24 |
+
{
|
| 25 |
+
"k": [
|
| 26 |
+
0,
|
| 27 |
+
0
|
| 28 |
+
],
|
| 29 |
+
"mult": 1,
|
| 30 |
+
"E": [
|
| 31 |
+
-8.46887501,
|
| 32 |
+
-7.9075633,
|
| 33 |
+
-7.25888668,
|
| 34 |
+
-7.06223958,
|
| 35 |
+
-6.93742613
|
| 36 |
+
]
|
| 37 |
+
},
|
| 38 |
+
{
|
| 39 |
+
"k": [
|
| 40 |
+
0,
|
| 41 |
+
1
|
| 42 |
+
],
|
| 43 |
+
"mult": 4,
|
| 44 |
+
"E": [
|
| 45 |
+
-7.5392478,
|
| 46 |
+
-7.15783147,
|
| 47 |
+
-7.14422761,
|
| 48 |
+
-6.98852848,
|
| 49 |
+
-6.87194204
|
| 50 |
+
]
|
| 51 |
+
},
|
| 52 |
+
{
|
| 53 |
+
"k": [
|
| 54 |
+
0,
|
| 55 |
+
2
|
| 56 |
+
],
|
| 57 |
+
"mult": 2,
|
| 58 |
+
"E": [
|
| 59 |
+
-7.51900567,
|
| 60 |
+
-7.25888668,
|
| 61 |
+
-7.09123866,
|
| 62 |
+
-7.03622823,
|
| 63 |
+
-6.93742613
|
| 64 |
+
]
|
| 65 |
+
},
|
| 66 |
+
{
|
| 67 |
+
"k": [
|
| 68 |
+
1,
|
| 69 |
+
1
|
| 70 |
+
],
|
| 71 |
+
"mult": 4,
|
| 72 |
+
"E": [
|
| 73 |
+
-7.51900567,
|
| 74 |
+
-7.25007145,
|
| 75 |
+
-7.09123866,
|
| 76 |
+
-7.06223958,
|
| 77 |
+
-6.85660296
|
| 78 |
+
]
|
| 79 |
+
},
|
| 80 |
+
{
|
| 81 |
+
"k": [
|
| 82 |
+
1,
|
| 83 |
+
2
|
| 84 |
+
],
|
| 85 |
+
"mult": 4,
|
| 86 |
+
"E": [
|
| 87 |
+
-7.52722462,
|
| 88 |
+
-7.18256276,
|
| 89 |
+
-7.15783147,
|
| 90 |
+
-6.98852848,
|
| 91 |
+
-6.84011944
|
| 92 |
+
]
|
| 93 |
+
},
|
| 94 |
+
{
|
| 95 |
+
"k": [
|
| 96 |
+
2,
|
| 97 |
+
2
|
| 98 |
+
],
|
| 99 |
+
"mult": 1,
|
| 100 |
+
"E": [
|
| 101 |
+
-8.28491503,
|
| 102 |
+
-7.31024296,
|
| 103 |
+
-7.25007145,
|
| 104 |
+
-7.25007145,
|
| 105 |
+
-7.03622823
|
| 106 |
+
]
|
| 107 |
+
}
|
| 108 |
+
],
|
| 109 |
+
"sec": 327.8
|
| 110 |
+
}
|
methods/Yuseon84/expected/ed4x4_Ne8_U8.json
ADDED
|
@@ -0,0 +1,112 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"L": 4,
|
| 3 |
+
"Ne": 8,
|
| 4 |
+
"n": 0.5,
|
| 5 |
+
"U": 8.0,
|
| 6 |
+
"E0": -16.46062675368178,
|
| 7 |
+
"deg": 3,
|
| 8 |
+
"R": [
|
| 9 |
+
2,
|
| 10 |
+
2
|
| 11 |
+
],
|
| 12 |
+
"Pd": 0.048076,
|
| 13 |
+
"manifold": [
|
| 14 |
+
{
|
| 15 |
+
"k": [
|
| 16 |
+
0,
|
| 17 |
+
0
|
| 18 |
+
],
|
| 19 |
+
"mult": 1,
|
| 20 |
+
"Pd": 0.07258846
|
| 21 |
+
},
|
| 22 |
+
{
|
| 23 |
+
"k": [
|
| 24 |
+
0,
|
| 25 |
+
2
|
| 26 |
+
],
|
| 27 |
+
"mult": 2,
|
| 28 |
+
"Pd": 0.03581966
|
| 29 |
+
}
|
| 30 |
+
],
|
| 31 |
+
"sectors": [
|
| 32 |
+
{
|
| 33 |
+
"k": [
|
| 34 |
+
0,
|
| 35 |
+
0
|
| 36 |
+
],
|
| 37 |
+
"mult": 1,
|
| 38 |
+
"E": [
|
| 39 |
+
-16.46062675,
|
| 40 |
+
-16.33833138,
|
| 41 |
+
-16.33833138,
|
| 42 |
+
-15.68310244
|
| 43 |
+
]
|
| 44 |
+
},
|
| 45 |
+
{
|
| 46 |
+
"k": [
|
| 47 |
+
0,
|
| 48 |
+
1
|
| 49 |
+
],
|
| 50 |
+
"mult": 4,
|
| 51 |
+
"E": [
|
| 52 |
+
-15.44748473,
|
| 53 |
+
-15.29925513,
|
| 54 |
+
-15.29725162,
|
| 55 |
+
-15.18959721
|
| 56 |
+
]
|
| 57 |
+
},
|
| 58 |
+
{
|
| 59 |
+
"k": [
|
| 60 |
+
0,
|
| 61 |
+
2
|
| 62 |
+
],
|
| 63 |
+
"mult": 2,
|
| 64 |
+
"E": [
|
| 65 |
+
-16.46062675,
|
| 66 |
+
-15.8787787,
|
| 67 |
+
-14.42873422,
|
| 68 |
+
-14.26722188
|
| 69 |
+
]
|
| 70 |
+
},
|
| 71 |
+
{
|
| 72 |
+
"k": [
|
| 73 |
+
1,
|
| 74 |
+
1
|
| 75 |
+
],
|
| 76 |
+
"mult": 4,
|
| 77 |
+
"E": [
|
| 78 |
+
-16.33833138,
|
| 79 |
+
-15.8787787,
|
| 80 |
+
-14.26722188,
|
| 81 |
+
-14.21673546
|
| 82 |
+
]
|
| 83 |
+
},
|
| 84 |
+
{
|
| 85 |
+
"k": [
|
| 86 |
+
1,
|
| 87 |
+
2
|
| 88 |
+
],
|
| 89 |
+
"mult": 4,
|
| 90 |
+
"E": [
|
| 91 |
+
-15.29925513,
|
| 92 |
+
-15.29725162,
|
| 93 |
+
-15.18959721,
|
| 94 |
+
-15.18567228
|
| 95 |
+
]
|
| 96 |
+
},
|
| 97 |
+
{
|
| 98 |
+
"k": [
|
| 99 |
+
2,
|
| 100 |
+
2
|
| 101 |
+
],
|
| 102 |
+
"mult": 1,
|
| 103 |
+
"E": [
|
| 104 |
+
-14.22849099,
|
| 105 |
+
-14.21631143,
|
| 106 |
+
-14.09362039,
|
| 107 |
+
-14.09167066
|
| 108 |
+
]
|
| 109 |
+
}
|
| 110 |
+
],
|
| 111 |
+
"sec": 18.9
|
| 112 |
+
}
|
methods/Yuseon84/expected/vmc4x4_vs_ed.json
ADDED
|
@@ -0,0 +1,52 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
[
|
| 2 |
+
{
|
| 3 |
+
"Ne": 8,
|
| 4 |
+
"E_ed": -16.460627,
|
| 5 |
+
"E_vmc": -16.3102,
|
| 6 |
+
"rel_err": 0.0091,
|
| 7 |
+
"Pd_ed_avg": 0.048076,
|
| 8 |
+
"Pd_ed_k00": 0.07259,
|
| 9 |
+
"Pd_vmc": 0.07555,
|
| 10 |
+
"maf": 0.00331
|
| 11 |
+
},
|
| 12 |
+
{
|
| 13 |
+
"Ne": 10,
|
| 14 |
+
"E_ed": -17.510367,
|
| 15 |
+
"E_vmc": -17.3019,
|
| 16 |
+
"rel_err": 0.0119,
|
| 17 |
+
"Pd_ed_avg": 0.060122,
|
| 18 |
+
"Pd_ed_k00": 0.06012,
|
| 19 |
+
"Pd_vmc": 0.06793,
|
| 20 |
+
"maf": 0.00176
|
| 21 |
+
},
|
| 22 |
+
{
|
| 23 |
+
"Ne": 12,
|
| 24 |
+
"E_ed": -14.92531,
|
| 25 |
+
"E_vmc": -14.3907,
|
| 26 |
+
"rel_err": 0.0358,
|
| 27 |
+
"Pd_ed_avg": 0.009831,
|
| 28 |
+
"Pd_ed_k00": -0.00381,
|
| 29 |
+
"Pd_vmc": 0.03555,
|
| 30 |
+
"maf": 0.2
|
| 31 |
+
},
|
| 32 |
+
{
|
| 33 |
+
"Ne": 14,
|
| 34 |
+
"E_ed": -11.868836,
|
| 35 |
+
"E_vmc": -11.183,
|
| 36 |
+
"rel_err": 0.0578,
|
| 37 |
+
"Pd_ed_avg": 0.019219,
|
| 38 |
+
"Pd_ed_k00": 0.02313,
|
| 39 |
+
"Pd_vmc": 0.03911,
|
| 40 |
+
"maf": 0.4
|
| 41 |
+
},
|
| 42 |
+
{
|
| 43 |
+
"Ne": 16,
|
| 44 |
+
"E_ed": -8.468875,
|
| 45 |
+
"E_vmc": -8.083,
|
| 46 |
+
"rel_err": 0.0456,
|
| 47 |
+
"Pd_ed_avg": 0.006197,
|
| 48 |
+
"Pd_ed_k00": 0.0062,
|
| 49 |
+
"Pd_vmc": 0.00752,
|
| 50 |
+
"maf": 1.27417
|
| 51 |
+
}
|
| 52 |
+
]
|
methods/Yuseon84/expected/vmc6x6_best_by_energy.json
ADDED
|
@@ -0,0 +1,74 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"20": {
|
| 3 |
+
"E": -38.3005695842542,
|
| 4 |
+
"dE": 0.006270137991131296,
|
| 5 |
+
"Pd": 0.02008639466157071,
|
| 6 |
+
"dPd": 0.00028052080302624796,
|
| 7 |
+
"maf": 0.0,
|
| 8 |
+
"source": "ph66_Ne20_maf0.0.json"
|
| 9 |
+
},
|
| 10 |
+
"22": {
|
| 11 |
+
"E": -37.68977199064044,
|
| 12 |
+
"dE": 0.007259278422438216,
|
| 13 |
+
"Pd": 0.033899358015224465,
|
| 14 |
+
"dPd": 0.0003107759755719417,
|
| 15 |
+
"maf": 0.0,
|
| 16 |
+
"source": "ph66_Ne22_maf0.0.json"
|
| 17 |
+
},
|
| 18 |
+
"24": {
|
| 19 |
+
"E": -36.561666722737314,
|
| 20 |
+
"dE": 0.008338323087734176,
|
| 21 |
+
"Pd": 0.04018249120571718,
|
| 22 |
+
"dPd": 0.0003484341780663236,
|
| 23 |
+
"maf": 0.0,
|
| 24 |
+
"source": "ph66_Ne24_maf0.0.json"
|
| 25 |
+
},
|
| 26 |
+
"26": {
|
| 27 |
+
"E": -34.97095304685092,
|
| 28 |
+
"dE": 0.009137964514652168,
|
| 29 |
+
"Pd": 0.0342057311776723,
|
| 30 |
+
"dPd": 0.0003375585635617882,
|
| 31 |
+
"maf": 0.0,
|
| 32 |
+
"source": "ph66_Ne26_maf0.0.json"
|
| 33 |
+
},
|
| 34 |
+
"28": {
|
| 35 |
+
"E": -31.61765323295314,
|
| 36 |
+
"dE": 0.01122834776441649,
|
| 37 |
+
"Pd": 0.046465550630268235,
|
| 38 |
+
"dPd": 0.0004690586698101234,
|
| 39 |
+
"maf": 0.0,
|
| 40 |
+
"source": "ph66_Ne28_maf0.0.json"
|
| 41 |
+
},
|
| 42 |
+
"30": {
|
| 43 |
+
"E": -28.141432253114214,
|
| 44 |
+
"dE": 0.01125973117089022,
|
| 45 |
+
"Pd": 0.04373579685905692,
|
| 46 |
+
"dPd": 0.0005372427188067283,
|
| 47 |
+
"maf": 0.3,
|
| 48 |
+
"source": "ph66_Ne30_maf0.3.json"
|
| 49 |
+
},
|
| 50 |
+
"32": {
|
| 51 |
+
"E": -24.748089601854286,
|
| 52 |
+
"dE": 0.01127131858409921,
|
| 53 |
+
"Pd": 0.04058475931382825,
|
| 54 |
+
"dPd": 0.0007236902621490548,
|
| 55 |
+
"maf": 0.6,
|
| 56 |
+
"source": "ph66_Ne32_maf0.6.json"
|
| 57 |
+
},
|
| 58 |
+
"34": {
|
| 59 |
+
"E": -21.487404241108198,
|
| 60 |
+
"dE": 0.010254962615421907,
|
| 61 |
+
"Pd": 0.031059343293219233,
|
| 62 |
+
"dPd": 0.0006024544428974737,
|
| 63 |
+
"maf": 0.9,
|
| 64 |
+
"source": "ph66_Ne34_maf0.9.json"
|
| 65 |
+
},
|
| 66 |
+
"36": {
|
| 67 |
+
"E": -18.398476933684087,
|
| 68 |
+
"dE": 0.0071129092364388274,
|
| 69 |
+
"Pd": 0.0042034371053786546,
|
| 70 |
+
"dPd": 0.0008391372121750209,
|
| 71 |
+
"maf": 1.6,
|
| 72 |
+
"source": "ph66_Ne36_maf1.6.json"
|
| 73 |
+
}
|
| 74 |
+
}
|
methods/Yuseon84/run_delta0.sh
ADDED
|
@@ -0,0 +1,14 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/bin/bash
|
| 2 |
+
# Reproduces the two delta = 0 (half filling, U/t = 8) numbers cited in Discussion #56.
|
| 3 |
+
# (1) 4x4 ED, Ne = 16, R = (2,2): P_d = 0.006197 (manifold average; matches validation/comparison_4x4_ED_vs_VMC.md)
|
| 4 |
+
# -> needs a CUDA GPU for the matvec (about 1 h on an RTX 3060 Ti); expected: expected/ed4x4_Ne16_U8.json
|
| 5 |
+
# (2) 6x6 VMC, Ne = 36, R = (3,3), lowest-energy Neel-field state, three seeds: P_d = 0.0049 +/- 0.0007
|
| 6 |
+
# -> a few minutes per seed on the GPU; expected: expected/vmc6x6_best_by_energy.json (entry "36")
|
| 7 |
+
set -e; cd "$(dirname "$0")/code"; mkdir -p ../out ../sectors
|
| 8 |
+
python ed_ksector_gpu.py --Ne 16 --save ../sectors
|
| 9 |
+
python ed_ksector.py --Ne 16 --combine --save ../sectors --out ../out/ed4x4_Ne16_U8.json
|
| 10 |
+
m=$(python -c "import json;print(json.load(open('../configs/vmc6x6_Ne36.json'))['result']['par']['maf'])")
|
| 11 |
+
for s in 1 2 3; do
|
| 12 |
+
python vmc_gpu3.py --L 6 --Ne 36 --U 8 --init ../configs/vmc6x6_Ne36.json --maf $m \
|
| 13 |
+
--ntherm 1500 --nmeas 40 --walkers 2048 --seed $s --out ../out/vmc6x6_Ne36_seed$s.json
|
| 14 |
+
done
|
methods/Yuseon84/run_ed_4x4.sh
ADDED
|
@@ -0,0 +1,7 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/bin/bash
|
| 2 |
+
# Reproduces the five 4x4 ED reference values (U/t=8, R=(2,2), equal-weight manifold average) -> expected/ed4x4_Ne*_U8.json
|
| 3 |
+
# CPU only is fine for Ne<=12 (minutes); Ne=14,16 use the GPU matvec (about 1 h on an RTX 3060 Ti).
|
| 4 |
+
set -e; cd "$(dirname "$0")/code"; mkdir -p ../out ../sectors
|
| 5 |
+
for Ne in 8 10 12; do python ed_ksector.py --Ne $Ne --out ../out/ed4x4_Ne${Ne}_U8.json; done
|
| 6 |
+
for Ne in 14 16; do python ed_ksector_gpu.py --Ne $Ne --save ../sectors; python ed_ksector.py --Ne $Ne --combine --save ../sectors --out ../out/ed4x4_Ne${Ne}_U8.json; done
|
| 7 |
+
python ed_hubbard.py --help >/dev/null # independent no-symmetry cross-check code (Ne<=10), see README
|
methods/Yuseon84/run_free.sh
ADDED
|
@@ -0,0 +1,4 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/bin/bash
|
| 2 |
+
# Exact U=0 pair correlation with degenerate-shell averaging: 4x4 (normalization check) and 6x6 (shell decomposition of A_d).
|
| 3 |
+
set -e; cd "$(dirname "$0")/code"; mkdir -p ../out
|
| 4 |
+
python pd_free.py > ../out/pd_free_4x4.txt; python pd_free66.py > ../out/pd_free_6x6.txt
|
methods/Yuseon84/run_vmc_4x4.sh
ADDED
|
@@ -0,0 +1,8 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/bin/bash
|
| 2 |
+
# Measures the frozen improved-ansatz states (configs/) on 4x4 and compares with ED (expected/vmc4x4_vs_ed.json).
|
| 3 |
+
# Independent-seed robustness: three seeds per filling.
|
| 4 |
+
set -e; cd "$(dirname "$0")/code"; mkdir -p ../out
|
| 5 |
+
for Ne in 8 10 12 14 16; do for s in 1 2 3; do
|
| 6 |
+
python vmc_gpu3.py --L 4 --Ne $Ne --U 8 --init ../configs/vmc4x4_Ne${Ne}.json --maf $(python -c "import json;print(json.load(open('../configs/vmc4x4_Ne${Ne}.json'))['result']['par']['maf'])") \
|
| 7 |
+
--ntherm 1500 --nmeas 40 --walkers 2048 --seed $s --out ../out/vmc4x4_Ne${Ne}_seed$s.json
|
| 8 |
+
done; done
|
methods/Yuseon84/run_vmc_6x6_seeds.sh
ADDED
|
@@ -0,0 +1,9 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/bin/bash
|
| 2 |
+
# Re-measures the frozen lowest-energy 6x6 states (configs/vmc6x6_Ne*.json) with independent seeds 2 and 3.
|
| 3 |
+
set -e; cd "$(dirname "$0")/code"; mkdir -p ../out
|
| 4 |
+
for Ne in 36 34 32 30 28 26 24 22 20; do for s in 2 3; do
|
| 5 |
+
m=$(python -c "import json;print(json.load(open('../configs/vmc6x6_Ne${Ne}.json'))['result']['par']['maf'])")
|
| 6 |
+
python vmc_gpu3.py --L 6 --Ne $Ne --U 8 --init ../configs/vmc6x6_Ne${Ne}.json --maf $m \
|
| 7 |
+
--ntherm 1500 --nmeas 40 --walkers 2048 --seed $s --out ../out/vmc6x6_Ne${Ne}_seed$s.json
|
| 8 |
+
done; done
|
| 9 |
+
echo SEEDS_DONE
|