PyQUDA-Utils 0.9.10.dev1__tar.gz → 0.9.11.dev1__tar.gz

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyQUDA-Utils
-Version: 0.9.10.dev1
+Version: 0.9.11.dev1
 Summary: Utility scripts based on PyQUDA
 Author-email: SaltyChiang <SaltyChiang@users.noreply.github.com>
 Maintainer-email: SaltyChiang <SaltyChiang@users.noreply.github.com>

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/PyQUDA_Utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyQUDA-Utils
-Version: 0.9.10.dev1
+Version: 0.9.11.dev1
 Summary: Utility scripts based on PyQUDA
 Author-email: SaltyChiang <SaltyChiang@users.noreply.github.com>
 Maintainer-email: SaltyChiang <SaltyChiang@users.noreply.github.com>

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/PyQUDA_Utils.egg-info/SOURCES.txt

@@ -8,6 +8,19 @@ PyQUDA_Utils.egg-info/SOURCES.txt
 PyQUDA_Utils.egg-info/dependency_links.txt
 PyQUDA_Utils.egg-info/requires.txt
 PyQUDA_Utils.egg-info/top_level.txt
+pyquda_io/__init__.py
+pyquda_io/_field_utils.py
+pyquda_io/_mpi_file.py
+pyquda_io/_version.py
+pyquda_io/chroma.py
+pyquda_io/io_general.py
+pyquda_io/kyu.py
+pyquda_io/lime.py
+pyquda_io/milc.py
+pyquda_io/nersc.py
+pyquda_io/npy.py
+pyquda_io/openqcd.py
+pyquda_io/xqcd.py
 pyquda_utils/__init__.py
 pyquda_utils/_version.py
 pyquda_utils/convert.py
@@ -20,15 +33,4 @@ pyquda_utils/milc_rhmc_param.py
 pyquda_utils/phase.py
 pyquda_utils/quasi_axial_gauge_fixing.py
 pyquda_utils/source.py
-pyquda_utils/io/__init__.py
-pyquda_utils/io/chroma.py
-pyquda_utils/io/gauge_utils.py
-pyquda_utils/io/io_general.py
-pyquda_utils/io/kyu.py
-pyquda_utils/io/lime.py
-pyquda_utils/io/milc.py
-pyquda_utils/io/mpi_file.py
-pyquda_utils/io/nersc.py
-pyquda_utils/io/npy.py
-pyquda_utils/io/openqcd.py
-pyquda_utils/io/xqcd.py
+pyquda_utils/io/__init__.py

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/PyQUDA_Utils.egg-info/top_level.txt

@@ -1 +1,2 @@
+pyquda_io
 pyquda_utils

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/pyproject.toml

@@ -2,7 +2,7 @@
 requires = ["setuptools", "wheel"]
 
 [tool.setuptools.packages.find]
-include = ["pyquda_utils*"]
+include = ["pyquda_utils*", "pyquda_io*"]
 
 [tool.setuptools.dynamic]
 version = { attr = "pyquda_utils._version.__version__" }

pyquda_utils-0.9.11.dev1/pyquda_io/__init__.py

@@ -0,0 +1,46 @@
+# flake8: noqa
+
+from .io_general import (
+    IOGeneral,
+    read as readIOGeneral,
+    write as writeIOGeneral,
+)
+from .lime import (
+    Lime,
+)
+from .npy import (
+    readGauge as readNPYGauge,
+    writeGauge as writeNPYGauge,
+    readPropagator as readNPYPropagator,
+    writePropagator as writeNPYPropagator,
+)
+from .chroma import (
+    readQIOGauge as readChromaQIOGauge,
+    readQIOPropagator as readChromaQIOPropagator,
+    readILDGBinGauge,
+)
+from .milc import (
+    readGauge as readMILCGauge,
+    writeGauge as writeMILCGauge,
+    readQIOPropagator as readMILCQIOPropagator,
+)
+from .kyu import (
+    readGauge as readKYUGauge,
+    writeGauge as writeKYUGauge,
+    readPropagator as readKYUPropagator,
+    writePropagator as writeKYUPropagator,
+)
+from .xqcd import (
+    readPropagator as readXQCDPropagator,
+    writePropagator as writeXQCDPropagator,
+    readPropagatorFast as readXQCDPropagatorFast,
+    writePropagatorFast as writeXQCDPropagatorFast,
+)
+from .nersc import (
+    readGauge as readNERSCGauge,
+    writeGauge as writeNERSCGauge,
+)
+from .openqcd import (
+    readGauge as readOpenQCDGauge,
+    writeGauge as writeOpenQCDGauge,
+)

pyquda_utils-0.9.10.dev1/pyquda_utils/io/gauge_utils.py → pyquda_utils-0.9.11.dev1/pyquda_io/_field_utils.py

@@ -3,7 +3,7 @@ from typing import List
 from mpi4py import MPI
 import numpy
 
-from .mpi_file import getSublatticeSize, getNeighbourRank
+from ._mpi_file import getSublatticeSize, getNeighbourRank
 
 Nd, Nc = 4, 3
 
@@ -72,30 +72,12 @@ def gaugeLexicoPlaquette(latt_size: List[int], grid_size: List[int], gauge: nump
         extended[:, -1, :-1, :-1, :-1] = buf
 
     plaq = numpy.zeros((6))
-    plaq[0] = numpy.vdot(
-        numpy.linalg.matmul(gauge[0], extended[1, :-1, :-1, :-1, 1:]),
-        numpy.linalg.matmul(gauge[1], extended[0, :-1, :-1, 1:, :-1]),
-    ).real
-    plaq[1] = numpy.vdot(
-        numpy.linalg.matmul(gauge[0], extended[2, :-1, :-1, :-1, 1:]),
-        numpy.linalg.matmul(gauge[2], extended[0, :-1, 1:, :-1, :-1]),
-    ).real
-    plaq[2] = numpy.vdot(
-        numpy.linalg.matmul(gauge[1], extended[2, :-1, :-1, 1:, :-1]),
-        numpy.linalg.matmul(gauge[2], extended[1, :-1, 1:, :-1, :-1]),
-    ).real
-    plaq[3] = numpy.vdot(
-        numpy.linalg.matmul(gauge[0], extended[3, :-1, :-1, :-1, 1:]),
-        numpy.linalg.matmul(gauge[3], extended[0, 1:, :-1, :-1, :-1]),
-    ).real
-    plaq[4] = numpy.vdot(
-        numpy.linalg.matmul(gauge[1], extended[3, :-1, :-1, 1:, :-1]),
-        numpy.linalg.matmul(gauge[3], extended[1, 1:, :-1, :-1, :-1]),
-    ).real
-    plaq[5] = numpy.vdot(
-        numpy.linalg.matmul(gauge[2], extended[3, :-1, 1:, :-1, :-1]),
-        numpy.linalg.matmul(gauge[3], extended[2, 1:, :-1, :-1, :-1]),
-    ).real
+    plaq[0] = numpy.vdot(gauge[0] @ extended[1, :-1, :-1, :-1, 1:], gauge[1] @ extended[0, :-1, :-1, 1:, :-1]).real
+    plaq[1] = numpy.vdot(gauge[0] @ extended[2, :-1, :-1, :-1, 1:], gauge[2] @ extended[0, :-1, 1:, :-1, :-1]).real
+    plaq[2] = numpy.vdot(gauge[1] @ extended[2, :-1, :-1, 1:, :-1], gauge[2] @ extended[1, :-1, 1:, :-1, :-1]).real
+    plaq[3] = numpy.vdot(gauge[0] @ extended[3, :-1, :-1, :-1, 1:], gauge[3] @ extended[0, 1:, :-1, :-1, :-1]).real
+    plaq[4] = numpy.vdot(gauge[1] @ extended[3, :-1, :-1, 1:, :-1], gauge[3] @ extended[1, 1:, :-1, :-1, :-1]).real
+    plaq[5] = numpy.vdot(gauge[2] @ extended[3, :-1, 1:, :-1, :-1], gauge[3] @ extended[2, 1:, :-1, :-1, :-1]).real
 
     plaq /= int(numpy.prod(latt_size)) * Nc
     plaq = MPI.COMM_WORLD.allreduce(plaq, MPI.SUM)
@@ -186,3 +168,39 @@ def gaugeEvenShiftBackward(latt_size: List[int], grid_size: List[int], gauge: nu
         MPI.COMM_WORLD.Sendrecv_replace(buf, dest=neighbour_rank[3], source=neighbour_rank[7])
         gauge_shift[3, 1, 0, :, :, :] = buf
     return gauge_shift
+
+
+# matrices to convert gamma basis bewteen DeGrand-Rossi and Dirac-Pauli
+# DP for Dirac-Pauli, DR for DeGrand-Rossi
+# \psi(DP) = _DR_TO_DP \psi(DR)
+# \psi(DR) = _DP_TO_DR \psi(DP)
+_DP_TO_DR = numpy.array(
+    [
+        [0, 1, 0, -1],
+        [-1, 0, 1, 0],
+        [0, 1, 0, 1],
+        [-1, 0, -1, 0],
+    ]
+)
+_DR_TO_DP = numpy.array(
+    [
+        [0, -1, 0, -1],
+        [1, 0, 1, 0],
+        [0, 1, 0, -1],
+        [-1, 0, 1, 0],
+    ]
+)
+
+
+def propagatorDeGrandRossiToDiracPauli(propagator: numpy.ndarray):
+    P = _DR_TO_DP
+    Pinv = _DP_TO_DR / 2
+
+    return numpy.ascontiguousarray(numpy.einsum("ij,tzyxjkab,kl->tzyxilab", P, propagator.data, Pinv, optimize=True))
+
+
+def propagatorDiracPauliToDeGrandRossi(propagator: numpy.ndarray):
+    P = _DP_TO_DR
+    Pinv = _DR_TO_DP / 2
+
+    return numpy.ascontiguousarray(numpy.einsum("ij,tzyxjkab,kl->tzyxilab", P, propagator.data, Pinv, optimize=True))

pyquda_utils-0.9.11.dev1/pyquda_io/_version.py

@@ -0,0 +1 @@
+__version__ = "0.9.11.dev1"

{pyquda_utils-0.9.10.dev1/pyquda_utils/io → pyquda_utils-0.9.11.dev1/pyquda_io}/chroma.py

@@ -4,7 +4,7 @@ from xml.etree import ElementTree as ET
 
 from mpi4py import MPI
 
-from .mpi_file import getSublatticeSize, getGridCoord, readMPIFile
+from ._mpi_file import getSublatticeSize, getGridCoord, readMPIFile
 
 Nd, Ns, Nc = 4, 4, 3
 _precision_map = {"D": 8, "F": 4, "S": 4}

{pyquda_utils-0.9.10.dev1/pyquda_utils/io → pyquda_utils-0.9.11.dev1/pyquda_io}/kyu.py

@@ -3,7 +3,8 @@ from typing import List
 
 import numpy
 
-from .mpi_file import getSublatticeSize, readMPIFile, writeMPIFile
+from ._mpi_file import getSublatticeSize, readMPIFile, writeMPIFile
+from ._field_utils import propagatorDiracPauliToDeGrandRossi, propagatorDeGrandRossiToDiracPauli
 
 Nd, Ns, Nc = 4, 4, 3
 
@@ -48,6 +49,7 @@ def readPropagator(filename: str, latt_size: List[int], grid_size: List[int]):
         .reshape(Lt, Lz, Ly, Lx, Ns, Ns, Nc, Nc * 2)
         .view("<c16")
     )
+    propagator = propagatorDiracPauliToDeGrandRossi(propagator)
     return propagator
 
 
@@ -56,6 +58,7 @@ def writePropagator(filename: str, latt_size: List[int], grid_size: List[int], p
     Lx, Ly, Lz, Lt = getSublatticeSize(latt_size, grid_size)
     dtype, offset = ">f8", 0
 
+    propagator = propagatorDeGrandRossiToDiracPauli(propagator)
     propagator = (
         propagator.view("<f8")
         .reshape(Lt, Lz, Ly, Lx, Ns, Ns, Nc, Nc, 2)

{pyquda_utils-0.9.10.dev1/pyquda_utils/io → pyquda_utils-0.9.11.dev1/pyquda_io}/milc.py

@@ -7,7 +7,7 @@ from xml.etree import ElementTree as ET
 import numpy
 from mpi4py import MPI
 
-from .mpi_file import getGridCoord, getSublatticeSize, readMPIFile, writeMPIFile
+from ._mpi_file import getGridCoord, getSublatticeSize, readMPIFile, writeMPIFile
 
 Nd, Ns, Nc = 4, 4, 3
 _precision_map = {"D": 8, "F": 4, "S": 4}

{pyquda_utils-0.9.10.dev1/pyquda_utils/io → pyquda_utils-0.9.11.dev1/pyquda_io}/nersc.py

@@ -5,8 +5,8 @@ from typing import Dict, List
 import numpy
 from mpi4py import MPI
 
-from .mpi_file import getSublatticeSize, readMPIFile, writeMPIFile
-from .gauge_utils import gaugeLexicoPlaquette
+from ._mpi_file import getSublatticeSize, readMPIFile, writeMPIFile
+from ._field_utils import gaugeLexicoPlaquette
 
 Nd, Ns, Nc = 4, 4, 3
 

{pyquda_utils-0.9.10.dev1/pyquda_utils/io → pyquda_utils-0.9.11.dev1/pyquda_io}/npy.py

@@ -5,7 +5,7 @@ import numpy
 from numpy.lib.format import dtype_to_descr, read_magic, read_array_header_1_0, write_array_header_1_0
 from mpi4py import MPI
 
-from .mpi_file import getSublatticeSize, readMPIFile, writeMPIFile
+from ._mpi_file import getSublatticeSize, readMPIFile, writeMPIFile
 
 Nd, Ns, Nc = 4, 4, 3
 

{pyquda_utils-0.9.10.dev1/pyquda_utils/io → pyquda_utils-0.9.11.dev1/pyquda_io}/openqcd.py

@@ -5,8 +5,8 @@ from typing import List
 import numpy
 from mpi4py import MPI
 
-from .mpi_file import getSublatticeSize, readMPIFile, writeMPIFile
-from .gauge_utils import gaugeEvenOdd, gaugeLexico, gaugeLexicoPlaquette, gaugeOddShiftForward, gaugeEvenShiftBackward
+from ._mpi_file import getSublatticeSize, readMPIFile, writeMPIFile
+from ._field_utils import gaugeEvenOdd, gaugeLexico, gaugeLexicoPlaquette, gaugeOddShiftForward, gaugeEvenShiftBackward
 
 Nd, Ns, Nc = 4, 4, 3
 

{pyquda_utils-0.9.10.dev1/pyquda_utils/io → pyquda_utils-0.9.11.dev1/pyquda_io}/xqcd.py

@@ -3,7 +3,8 @@ from typing import List
 
 import numpy
 
-from .mpi_file import getSublatticeSize, readMPIFile, writeMPIFile
+from ._mpi_file import getSublatticeSize, readMPIFile, writeMPIFile
+from ._field_utils import propagatorDiracPauliToDeGrandRossi, propagatorDeGrandRossiToDiracPauli
 
 Ns, Nc = 4, 3
 
@@ -16,6 +17,7 @@ def readPropagator(filename: str, latt_size: List[int], grid_size: List[int], st
     if not staggered:
         propagator = readMPIFile(filename, dtype, offset, (Ns, Nc, Lt, Lz, Ly, Lx, Ns, Nc), (5, 4, 3, 2), grid_size)
         propagator = propagator.transpose(2, 3, 4, 5, 6, 0, 7, 1).astype("<c16")
+        propagator = propagatorDiracPauliToDeGrandRossi(propagator)
     else:
         # QDP_ALIGN16 makes the last Nc to be aligned with 16 Bytes.
         propagator_align16 = readMPIFile(filename, dtype, offset, (Nc, Lt, Lz, Ly, Lx, 4), (4, 3, 2, 1), grid_size)
@@ -32,6 +34,7 @@ def writePropagator(
     dtype, offset = "<c8", 0
 
     if not staggered:
+        propagator = propagatorDeGrandRossiToDiracPauli(propagator)
         propagator = propagator.astype(dtype).transpose(5, 7, 0, 1, 2, 3, 4, 6).copy()
         writeMPIFile(filename, dtype, offset, (Ns, Nc, Lt, Lz, Ly, Lx, Ns, Nc), (5, 4, 3, 2), grid_size, propagator)
     else:

pyquda_utils-0.9.11.dev1/pyquda_utils/_version.py

@@ -0,0 +1 @@
+__version__ = "0.9.11.dev1"

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/pyquda_utils/core.py

@@ -4,6 +4,7 @@ import numpy
 
 from pyquda import (
     initGPU,
+    initGrid,
     initQUDA,
     init,
     getCoordFromRank,
@@ -15,6 +16,7 @@ from pyquda import (
     getGridCoord,
     setDefaultLattice,
     getDefaultLattice,
+    getCUDABackend,
     getLogger,
     setLoggerLevel,
     dirac as fermion,
@@ -41,7 +43,8 @@ from pyquda.field import (
     LatticePropagator,
     LatticeStaggeredPropagator,
     lexico,
-    cb2,
+    evenodd,
+    evenodd as cb2,
 )
 from pyquda.dirac.abstract import Multigrid, FermionDirac, StaggeredFermionDirac
 

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/pyquda_utils/deprecated.py

@@ -1,6 +1,6 @@
 from typing import List
 
-from pyquda import getLogger, getGridSize, quda, enum_quda
+from pyquda import getLogger, getGridSize, pyquda as quda, enum_quda
 from pyquda.field import LatticeFermion, LatticeGauge, LatticeInfo, LatticePropagator, Nc, Ns
 from pyquda.dirac.abstract import FermionDirac
 
@@ -101,11 +101,11 @@ def getDslash(
     latt_info = LatticeInfo([Lx, Ly, Lz, Lt], t_boundary, xi)
 
     if clover_csw != 0.0:
-        from .dirac.clover_wilson import CloverWilsonDirac
+        from pyquda.dirac.clover_wilson import CloverWilsonDirac
 
         return CloverWilsonDirac(latt_info, mass, tol, maxiter, clover_csw, clover_xi, geo_block_size)
     else:
-        from .dirac.wilson import WilsonDirac
+        from pyquda.dirac.wilson import WilsonDirac
 
         return WilsonDirac(latt_info, mass, tol, maxiter, geo_block_size)
 
@@ -131,6 +131,6 @@ def getStaggeredDslash(
         t_boundary = 1
     latt_info = LatticeInfo([Lx, Ly, Lz, Lt], t_boundary, 1.0)
 
-    from .dirac.hisq import HISQDirac
+    from pyquda.dirac.hisq import HISQDirac
 
     return HISQDirac(latt_info, mass, tol, maxiter, naik_epsilon, None)

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/pyquda_utils/gpt.py

@@ -1,15 +1,17 @@
 from typing import List
 import numpy
 
-from pyquda import getSublatticeSize, getGridSize
-from pyquda.field import cb2, LatticeGauge, LatticeInfo, LatticePropagator
+from .core import evenodd, getGridSize, LatticeGauge, LatticeInfo, LatticePropagator
 
 import gpt as g
 
 
 def LatticeInfoGPT(grid: g.grid, gen_simd_width: int):
     assert getGridSize() == grid.mpi
-    sublatt_size = getSublatticeSize(grid.fdimensions, grid.mpi)
+    GLx, GLy, GLz, GLt = grid.fdimensions
+    Gx, Gy, Gz, Gt = grid.mpi
+    Lx, Ly, Lz, Lt = GLx // Gx, GLy // Gy, GLz // Gz, GLt // Gt
+    sublatt_size = [Lx, Ly, Lz, Lt]
     Nd = len(sublatt_size)
     precision = grid.precision.nbytes
     n_simd = gen_simd_width // (2 * precision)
@@ -32,7 +34,7 @@ def LatticeGaugeGPT(lattice: List[g.lattice], gen_simd_width: int, gauge: Lattic
         value = []
         for index in range(latt_info.Nd):
             value.append(
-                cb2(
+                evenodd(
                     numpy.asarray(lattice[index].mview()[0])
                     .view(f"<c{2 * gpt_prec}")
                     .reshape(*gpt_latt[::-1], Nc, Nc, *gpt_simd[::-1])
@@ -47,9 +49,10 @@ def LatticeGaugeGPT(lattice: List[g.lattice], gen_simd_width: int, gauge: Lattic
     else:
         assert latt_info.size == gauge.latt_info.size
         for index in range(latt_info.Nd):
-            gpt_shape = [i for sl in zip(gpt_simd, gpt_latt) for i in sl]
+            gpt_shape = [i for sl in zip(gpt_simd[::-1], gpt_latt[::-1]) for i in sl]
             lattice[index].mview()[0][:] = (
-                gauge[index].lexico()
+                gauge[index]
+                .lexico()
                 .astype(f"<c{2 * gpt_prec}")
                 .reshape(*gpt_shape, Nc, Nc)
                 .transpose(1, 3, 5, 7, 8, 9, 0, 2, 4, 6)
@@ -65,7 +68,7 @@ def LatticePropagatorGPT(lattice: g.lattice, gen_simd_width: int, propagator: La
     Ns, Nc = latt_info.Ns, latt_info.Nc
     assert lattice.describe().startswith(f"ot_matrix_spin_color({Ns},{Nc})")
     if propagator is None:
-        value = cb2(
+        value = evenodd(
             numpy.asarray(lattice.mview()[0])
             .view(f"<c{2 * gpt_prec}")
             .reshape(*gpt_latt[::-1], Ns, Ns, Nc, Nc, *gpt_simd[::-1])

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/pyquda_utils/io/__init__.py

@@ -2,7 +2,7 @@ from typing import List, Union
 
 import numpy
 
-from pyquda.field import Ns, Nc, LatticeInfo, LatticeGauge, LatticePropagator, LatticeStaggeredPropagator, cb2, lexico
+from ..core import Ns, Nc, LatticeInfo, LatticeGauge, LatticePropagator, LatticeStaggeredPropagator, evenodd, lexico
 
 # matrices to convert gamma basis bewteen DeGrand-Rossi and Dirac-Pauli
 # \psi(DP) = _DR_TO_DP \psi(DR)
@@ -71,119 +71,107 @@ def rotateToDeGrandRossi(propagator: LatticePropagator):
 
 def readChromaQIOGauge(filename: str, checksum: bool = True):
     from pyquda import getGridSize
-    from .chroma import readQIOGauge as read
+    from pyquda_io.chroma import readQIOGauge as read
 
     latt_size, gauge_raw = read(filename, getGridSize(), checksum)
-    return LatticeGauge(LatticeInfo(latt_size), cb2(gauge_raw, [1, 2, 3, 4]))
+    return LatticeGauge(LatticeInfo(latt_size), evenodd(gauge_raw, [1, 2, 3, 4]))
 
 
 def readILDGBinGauge(filename: str, dtype: str, latt_size: List[int]):
     from pyquda import getGridSize
-    from .chroma import readILDGBinGauge as read
+    from pyquda_io.chroma import readILDGBinGauge as read
 
     gauge_raw = read(filename, dtype, latt_size, getGridSize())
-    return LatticeGauge(LatticeInfo(latt_size), cb2(gauge_raw, [1, 2, 3, 4]))
+    return LatticeGauge(LatticeInfo(latt_size), evenodd(gauge_raw, [1, 2, 3, 4]))
 
 
 def readChromaQIOPropagator(filename: str, checksum: bool = True):
     from pyquda import getGridSize
-    from .chroma import readQIOPropagator as read
+    from pyquda_io.chroma import readQIOPropagator as read
 
     latt_size, staggered, propagator_raw = read(filename, getGridSize(), checksum)
     if not staggered:
-        return LatticePropagator(LatticeInfo(latt_size), cb2(propagator_raw, [0, 1, 2, 3]))
+        return LatticePropagator(LatticeInfo(latt_size), evenodd(propagator_raw, [0, 1, 2, 3]))
     else:
-        return LatticeStaggeredPropagator(LatticeInfo(latt_size), cb2(propagator_raw, [0, 1, 2, 3]))
+        return LatticeStaggeredPropagator(LatticeInfo(latt_size), evenodd(propagator_raw, [0, 1, 2, 3]))
 
 
 def readMILCGauge(filename: str, checksum: bool = True):
     from pyquda import getGridSize
-    from .milc import readGauge as read
+    from pyquda_io.milc import readGauge as read
 
     latt_size, gauge_raw = read(filename, getGridSize(), checksum)
-    return LatticeGauge(LatticeInfo(latt_size), cb2(gauge_raw, [1, 2, 3, 4]))
+    return LatticeGauge(LatticeInfo(latt_size), evenodd(gauge_raw, [1, 2, 3, 4]))
 
 
 def writeMILCGauge(filename: str, gauge: LatticeGauge):
-    from .milc import writeGauge as write
+    from pyquda_io.milc import writeGauge as write
 
     write(filename, gauge.latt_info.global_size, gauge.latt_info.grid_size, gauge.lexico())
 
 
 def readMILCQIOPropagator(filename: str):
     from pyquda import getGridSize
-    from .milc import readQIOPropagator as read
+    from pyquda_io.milc import readQIOPropagator as read
 
     latt_size, staggered, propagator_raw = read(filename, getGridSize())
     if not staggered:
-        return LatticePropagator(LatticeInfo(latt_size), cb2(propagator_raw, [0, 1, 2, 3]))
+        return LatticePropagator(LatticeInfo(latt_size), evenodd(propagator_raw, [0, 1, 2, 3]))
     else:
-        return LatticeStaggeredPropagator(LatticeInfo(latt_size), cb2(propagator_raw, [0, 1, 2, 3]))
+        return LatticeStaggeredPropagator(LatticeInfo(latt_size), evenodd(propagator_raw, [0, 1, 2, 3]))
 
 
 def readKYUGauge(filename: str, latt_size: List[int]):
     from pyquda import getGridSize
-    from .kyu import readGauge as read
+    from pyquda_io.kyu import readGauge as read
 
     gauge_raw = read(filename, latt_size, getGridSize())
-    return LatticeGauge(LatticeInfo(latt_size), cb2(gauge_raw, [1, 2, 3, 4]))
+    return LatticeGauge(LatticeInfo(latt_size), evenodd(gauge_raw, [1, 2, 3, 4]))
 
 
 def writeKYUGauge(filename: str, gauge: LatticeGauge):
-    from .kyu import writeGauge as write
+    from pyquda_io.kyu import writeGauge as write
 
     write(filename, gauge.latt_info.global_size, gauge.latt_info.grid_size, gauge.lexico())
 
 
 def readKYUPropagator(filename: str, latt_size: List[int]):
     from pyquda import getGridSize
-    from .kyu import readPropagator as read
+    from pyquda_io.kyu import readPropagator as read
 
     propagator_raw = read(filename, latt_size, getGridSize())
-    propagator = LatticePropagator(LatticeInfo(latt_size), cb2(propagator_raw, [0, 1, 2, 3]))
-    propagator = rotateToDeGrandRossi(propagator)
-    return propagator
+    return LatticePropagator(LatticeInfo(latt_size), evenodd(propagator_raw, [0, 1, 2, 3]))
 
 
 def writeKYUPropagator(filename: str, propagator: LatticePropagator):
-    from .kyu import writePropagator as write
+    from pyquda_io.kyu import writePropagator as write
 
-    propagator = rotateToDiracPauli(propagator)
-    propagator_raw = propagator.lexico()
-    write(filename, propagator.latt_info.global_size, propagator.latt_info.grid_size, propagator_raw)
+    write(filename, propagator.latt_info.global_size, propagator.latt_info.grid_size, propagator.lexico())
 
 
 def readXQCDPropagator(filename: str, latt_size: List[int], staggered: bool):
     from pyquda import getGridSize
-    from .xqcd import readPropagator as read
+    from pyquda_io.xqcd import readPropagator as read
 
     propagator_raw = read(filename, latt_size, getGridSize(), staggered)
-    if not staggered:
-        return rotateToDeGrandRossi(LatticePropagator(LatticeInfo(latt_size), cb2(propagator_raw, [0, 1, 2, 3])))
-    else:
-        return LatticeStaggeredPropagator(LatticeInfo(latt_size), cb2(propagator_raw, [0, 1, 2, 3]))
+    return LatticeStaggeredPropagator(LatticeInfo(latt_size), evenodd(propagator_raw, [0, 1, 2, 3]))
 
 
 def writeXQCDPropagator(filename: str, propagator: Union[LatticePropagator, LatticeStaggeredPropagator]):
-    from .xqcd import writePropagator as write
+    from pyquda_io.xqcd import writePropagator as write
 
-    latt_size = propagator.latt_info.global_size
-    grid_size = propagator.latt_info.grid_size
     staggered = isinstance(propagator, LatticeStaggeredPropagator)
-    if not staggered:
-        write(filename, latt_size, grid_size, rotateToDiracPauli(propagator).lexico(), staggered)
-    else:
-        write(filename, latt_size, grid_size, propagator.lexico(), staggered)
+    write(filename, propagator.latt_info.global_size, propagator.latt_info.grid_size, propagator.lexico(), staggered)
 
 
 def readXQCDPropagatorFast(filename: str, latt_size: List[int]):
     from pyquda import getGridSize
-    from .xqcd import readPropagatorFast as read
+    from pyquda_io.xqcd import readPropagatorFast as read
 
     latt_info = LatticeInfo(latt_size)
     Lx, Ly, Lz, Lt = latt_info.size
     propagator_raw = read(filename, getGridSize(), latt_size)
-    propagator = LatticePropagator(latt_info, cb2(propagator_raw, [2, 3, 4, 5]))
+    propagator = LatticePropagator(latt_info, evenodd(propagator_raw, [2, 3, 4, 5]))
     propagator.data = propagator.data.reshape(Ns, Nc, 2, Lt, Lz, Ly, Lx // 2, Ns, Nc)
     propagator.toDevice()
     propagator.data = propagator.data.transpose(2, 3, 4, 5, 6, 7, 0, 8, 1).astype("<c16")
@@ -192,7 +180,7 @@ def readXQCDPropagatorFast(filename: str, latt_size: List[int]):
 
 
 def writeXQCDPropagatorFast(filename: str, propagator: LatticePropagator):
-    from .xqcd import writePropagatorFast as write
+    from pyquda_io.xqcd import writePropagatorFast as write
 
     latt_info = propagator.latt_info
     Lx, Ly, Lz, Lt = latt_info.size
@@ -206,15 +194,15 @@ def writeXQCDPropagatorFast(filename: str, propagator: LatticePropagator):
 
 def readNPYGauge(filename: str):
     from pyquda import getGridSize
-    from .npy import readGauge as read
+    from pyquda_io.npy import readGauge as read
 
     filename = filename if filename.endswith(".npy") else filename + ".npy"
     latt_size, gauge_raw = read(filename, getGridSize())
-    return LatticeGauge(LatticeInfo(latt_size), cb2(gauge_raw, [1, 2, 3, 4]))
+    return LatticeGauge(LatticeInfo(latt_size), evenodd(gauge_raw, [1, 2, 3, 4]))
 
 
 def writeNPYGauge(filename: str, gauge: LatticeGauge):
-    from .npy import writeGauge as write
+    from pyquda_io.npy import writeGauge as write
 
     filename = filename if filename.endswith(".npy") else filename + ".npy"
     write(filename, gauge.latt_info.global_size, gauge.latt_info.grid_size, gauge.lexico())
@@ -222,42 +210,42 @@ def writeNPYGauge(filename: str, gauge: LatticeGauge):
 
 def readNPYPropagator(filename: str):
     from pyquda import getGridSize
-    from .npy import readPropagator as read
+    from pyquda_io.npy import readPropagator as read
 
     latt_size, propagator_raw = read(filename, getGridSize())
-    return LatticePropagator(LatticeInfo(latt_size), cb2(propagator_raw, [0, 1, 2, 3]))
+    return LatticePropagator(LatticeInfo(latt_size), evenodd(propagator_raw, [0, 1, 2, 3]))
 
 
 def writeNPYPropagator(filename: str, propagator: LatticePropagator):
-    from .npy import writePropagator as write
+    from pyquda_io.npy import writePropagator as write
 
     write(filename, propagator.latt_info.global_size, propagator.latt_info.grid_size, propagator.lexico())
 
 
 def readOpenQCDGauge(filename: str, plaquette: bool = True):
     from pyquda import getGridSize
-    from .openqcd import readGauge as read
+    from pyquda_io.openqcd import readGauge as read
 
     latt_size, gauge = read(filename, getGridSize(), plaquette, False)
     return LatticeGauge(LatticeInfo(latt_size), gauge)
 
 
 def writeOpenQCDGauge(filename: str, gauge: LatticeGauge, plaquette: float = None):
-    from .openqcd import writeGauge as write
+    from pyquda_io.openqcd import writeGauge as write
 
     write(filename, gauge.latt_info.global_size, gauge.latt_info.grid_size, gauge.getHost(), plaquette, False)
 
 
 def readNERSCGauge(filename: str, plaquette: bool = True, link_trace: bool = True, checksum: bool = True):
     from pyquda import getGridSize
-    from .nersc import readGauge as read
+    from pyquda_io.nersc import readGauge as read
 
     latt_size, gauge_raw = read(filename, getGridSize(), plaquette, link_trace, checksum)
-    return LatticeGauge(LatticeInfo(latt_size), cb2(gauge_raw, [1, 2, 3, 4]))
+    return LatticeGauge(LatticeInfo(latt_size), evenodd(gauge_raw, [1, 2, 3, 4]))
 
 
 def writeNERSCGauge(filename: str, gauge: LatticeGauge, plaquette: float = None, use_fp32: bool = False):
-    from .nersc import writeGauge as write
+    from pyquda_io.nersc import writeGauge as write
 
     write(filename, gauge.latt_info.global_size, gauge.latt_info.grid_size, gauge.lexico(), plaquette, use_fp32)
 

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/pyquda_utils/phase.py

@@ -3,8 +3,7 @@ from typing import Sequence
 
 import numpy
 
-from pyquda import getCUDABackend, getLogger
-from pyquda.field import LatticeInfo, cb2
+from .core import getLogger, getCUDABackend, evenodd, LatticeInfo
 
 
 def getMomList(mom2_max, mom2_min=0):
@@ -120,7 +119,7 @@ class GridPhase:
         phase = numpy.zeros((Lt, Lz, Ly, Lx), "<i4")
         if sx < Lx and sy < Ly and sz < Lz and st < Lt:
             phase[st::St, sz::Sz, sy::Sy, sx::Sx] = 1
-        phase = cb2(phase, [0, 1, 2, 3])
+        phase = evenodd(phase, [0, 1, 2, 3])
 
         backend = getCUDABackend()
         if backend == "numpy":

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/pyquda_utils/quasi_axial_gauge_fixing.py

@@ -1,7 +1,6 @@
 import numpy as np
 
-from pyquda import getRankFromCoord
-from pyquda.field import cb2, LatticeLink, LatticeGauge, LatticeFermion, X, Y, Z, T
+from .core import getRankFromCoord, evenodd, LatticeLink, LatticeGauge, LatticeFermion, X, Y, Z, T
 
 
 def quasiAxialGaugeFixing(gauge: LatticeGauge, dir: int):
@@ -58,7 +57,7 @@ def quasiAxialGaugeFixing(gauge: LatticeGauge, dir: int):
     rotate[0] = contract("xab,xb->xab", v, cupy.exp(1j * (gi * Li) / GLi * w))
     for i in range(1, Li):
         rotate[i] = contract("xba,xbc,xc->xac", gauge_prod[i - 1].conj(), v, cupy.exp(1j * (i + gi * Li) / GLi * w))
-    rotate = LatticeLink(gauge.latt_info, cb2(rotate.reshape(*axes_shape).transpose(*axes).get(), [0, 1, 2, 3]))
+    rotate = LatticeLink(gauge.latt_info, evenodd(rotate.reshape(*axes_shape).transpose(*axes).get(), [0, 1, 2, 3]))
     rotate.toDevice()
     rotate_ = LatticeFermion(gauge.latt_info)
     rotate.pack(rotate_)

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/pyquda_utils/source.py

@@ -1,6 +1,6 @@
 from typing import List, Literal, Union
 
-from pyquda import quda, getGridSize, getLogger
+from pyquda import pyquda as quda, getGridSize, getLogger
 from pyquda.enum_quda import QudaDslashType, QudaParity
 from pyquda.field import (
     Ns,

{pyquda_utils-0.9.10.dev1 → pyquda_utils-0.9.11.dev1}/setup.py

@@ -11,5 +11,7 @@ if "egg_info" in sys.argv or "dist_info" in sys.argv or "sdist" in sys.argv:
             tag, post = describe, 0
         with open(os.path.join(os.path.dirname(__file__), "pyquda_utils", "_version.py"), "w") as f:
             f.write(f'__version__ = "{tag[1:]}.dev{post}"\n')
+        with open(os.path.join(os.path.dirname(__file__), "pyquda_io", "_version.py"), "w") as f:
+            f.write(f'__version__ = "{tag[1:]}.dev{post}"\n')
 
 setup()

pyquda_utils-0.9.10.dev1/pyquda_utils/_version.py

@@ -1 +0,0 @@
-__version__ = "0.9.10.dev1"