PyQUDA-Utils 0.9.11.dev0__tar.gz → 0.10.0.dev0__tar.gz

{pyquda_utils-0.9.11.dev0 → pyquda_utils-0.10.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyQUDA-Utils
-Version: 0.9.11.dev0
+Version: 0.10.0.dev0
 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.11.dev0 → pyquda_utils-0.10.0.dev0}/PyQUDA_Utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyQUDA-Utils
-Version: 0.9.11.dev0
+Version: 0.10.0.dev0
 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.11.dev0 → pyquda_utils-0.10.0.dev0}/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.11.dev0 → pyquda_utils-0.10.0.dev0}/PyQUDA_Utils.egg-info/top_level.txt

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

{pyquda_utils-0.9.11.dev0 → pyquda_utils-0.10.0.dev0}/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.10.0.dev0/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.11.dev0/pyquda_utils/io/gauge_utils.py → pyquda_utils-0.10.0.dev0/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,68 @@ 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)
+_FROM_DIRAC_PAULI = numpy.array(
+    [
+        [0, 1, 0, -1],
+        [-1, 0, 1, 0],
+        [0, 1, 0, 1],
+        [-1, 0, -1, 0],
+    ]
+)
+_TO_DIRAC_PAULI = numpy.array(
+    [
+        [0, -1, 0, -1],
+        [1, 0, 1, 0],
+        [0, 1, 0, -1],
+        [-1, 0, 1, 0],
+    ]
+)
+
+
+def propagatorFromDiracPauli(propagator: numpy.ndarray):
+    P = _FROM_DIRAC_PAULI
+    Pinv = _TO_DIRAC_PAULI / 2
+
+    return numpy.ascontiguousarray(numpy.einsum("ij,tzyxjkab,kl->tzyxilab", P, propagator.data, Pinv, optimize=True))
+
+
+def propagatorToDiracPauli(propagator: numpy.ndarray):
+    P = _TO_DIRAC_PAULI
+    Pinv = _FROM_DIRAC_PAULI / 2
+
+    return numpy.ascontiguousarray(numpy.einsum("ij,tzyxjkab,kl->tzyxilab", P, propagator.data, Pinv, optimize=True))
+
+
+def spinMatrixFromDiracPauli(dirac_pauli: numpy.ndarray):
+    P = _FROM_DIRAC_PAULI
+    degrand_rossi = numpy.zeros_like(dirac_pauli)
+    for i in range(4):
+        for j in range(4):
+            for i_ in range((i + 1) % 2, 4, 2):
+                for j_ in range((j + 1) % 2, 4, 2):
+                    if P[i, i_] * P[j, j_] == 1:
+                        degrand_rossi[i, j] += dirac_pauli[i_, j_]
+                    elif P[i, i_] * P[j, j_] == -1:
+                        degrand_rossi[i, j] -= dirac_pauli[i_, j_]
+    return degrand_rossi.transpose(2, 3, 4, 5, 0, 1, 6, 7) / 2
+
+
+def spinMatrixToDiracPauli(degrand_rossi: numpy.ndarray):
+    P = _TO_DIRAC_PAULI
+    degrand_rossi = degrand_rossi.transpose(4, 5, 0, 1, 2, 3, 6, 7) / 2
+    dirac_pauli = numpy.zeros_like(degrand_rossi)
+    for i in range(4):
+        for j in range(4):
+            for i_ in range((i + 1) % 2, 4, 2):
+                for j_ in range((j + 1) % 2, 4, 2):
+                    if P[i, i_] * P[j, j_] == 1:
+                        dirac_pauli[i, j] += degrand_rossi[i_, j_]
+                    elif P[i, i_] * P[j, j_] == -1:
+                        dirac_pauli[i, j] -= degrand_rossi[i_, j_]
+    return dirac_pauli

pyquda_utils-0.10.0.dev0/pyquda_io/_version.py

@@ -0,0 +1 @@
+__version__ = "0.10.0.dev0"

{pyquda_utils-0.9.11.dev0/pyquda_utils/io → pyquda_utils-0.10.0.dev0/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.11.dev0/pyquda_utils/io → pyquda_utils-0.10.0.dev0/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 spinMatrixFromDiracPauli, spinMatrixToDiracPauli
 
 Nd, Ns, Nc = 4, 4, 3
 
@@ -42,12 +43,13 @@ def readPropagator(filename: str, latt_size: List[int], grid_size: List[int]):
 
     propagator = readMPIFile(filename, dtype, offset, (Ns, Nc, 2, Ns, Nc, Lt, Lz, Ly, Lx), (8, 7, 6, 5), grid_size)
     propagator = (
-        propagator.transpose(5, 6, 7, 8, 3, 0, 4, 1, 2)
+        propagator.transpose(3, 0, 5, 6, 7, 8, 4, 1, 2)
         .astype("<f8")
         .copy()
-        .reshape(Lt, Lz, Ly, Lx, Ns, Ns, Nc, Nc * 2)
+        .reshape(Ns, Ns, Lt, Lz, Ly, Lx, Nc, Nc * 2)
         .view("<c16")
     )
+    propagator = spinMatrixFromDiracPauli(propagator)
     return propagator
 
 
@@ -56,11 +58,12 @@ 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 = spinMatrixToDiracPauli(propagator)
     propagator = (
         propagator.view("<f8")
-        .reshape(Lt, Lz, Ly, Lx, Ns, Ns, Nc, Nc, 2)
+        .reshape(Ns, Ns, Lt, Lz, Ly, Lx, Nc, Nc, 2)
         .astype(dtype)
-        .transpose(5, 7, 8, 4, 6, 0, 1, 2, 3)
+        .transpose(1, 7, 8, 0, 6, 2, 3, 4, 5)
         .copy()
     )
     writeMPIFile(filename, dtype, offset, (Ns, Nc, 2, Ns, Nc, Lt, Lz, Ly, Lx), (8, 7, 6, 5), grid_size, propagator)

{pyquda_utils-0.9.11.dev0/pyquda_utils/io → pyquda_utils-0.10.0.dev0/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.11.dev0/pyquda_utils/io → pyquda_utils-0.10.0.dev0/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.11.dev0/pyquda_utils/io → pyquda_utils-0.10.0.dev0/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.11.dev0/pyquda_utils/io → pyquda_utils-0.10.0.dev0/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.11.dev0/pyquda_utils/io → pyquda_utils-0.10.0.dev0/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 spinMatrixFromDiracPauli, spinMatrixToDiracPauli
 
 Ns, Nc = 4, 3
 
@@ -15,7 +16,8 @@ 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 = propagator.transpose(6, 0, 2, 3, 4, 5, 7, 1).astype("<c16")
+        propagator = spinMatrixFromDiracPauli(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,7 +34,8 @@ def writePropagator(
     dtype, offset = "<c8", 0
 
     if not staggered:
-        propagator = propagator.astype(dtype).transpose(5, 7, 0, 1, 2, 3, 4, 6).copy()
+        propagator = spinMatrixToDiracPauli(propagator)
+        propagator = propagator.astype(dtype).transpose(1, 7, 2, 3, 4, 5, 0, 6).copy()
         writeMPIFile(filename, dtype, offset, (Ns, Nc, Lt, Lz, Ly, Lx, Ns, Nc), (5, 4, 3, 2), grid_size, propagator)
     else:
         # QDP_ALIGN16 makes the last Nc to be aligned with 16 Bytes.

pyquda_utils-0.10.0.dev0/pyquda_utils/_version.py

@@ -0,0 +1 @@
+__version__ = "0.10.0.dev0"

{pyquda_utils-0.9.11.dev0 → pyquda_utils-0.10.0.dev0}/pyquda_utils/gpt.py

@@ -49,7 +49,7 @@ 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()

{pyquda_utils-0.9.11.dev0 → pyquda_utils-0.10.0.dev0}/pyquda_utils/io/__init__.py

@@ -71,7 +71,7 @@ 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), evenodd(gauge_raw, [1, 2, 3, 4]))
@@ -79,7 +79,7 @@ def readChromaQIOGauge(filename: str, checksum: bool = True):
 
 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), evenodd(gauge_raw, [1, 2, 3, 4]))
@@ -87,7 +87,7 @@ def readILDGBinGauge(filename: str, dtype: str, latt_size: List[int]):
 
 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:
@@ -98,21 +98,21 @@ def readChromaQIOPropagator(filename: str, checksum: bool = True):
 
 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), 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:
@@ -123,66 +123,57 @@ def readMILCQIOPropagator(filename: str):
 
 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), 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), evenodd(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), evenodd(propagator_raw, [0, 1, 2, 3])))
+        return LatticePropagator(LatticeInfo(latt_size), evenodd(propagator_raw, [0, 1, 2, 3]))
     else:
         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_raw = read(filename, latt_size, getGridSize())
     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()
@@ -192,7 +183,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,7 +197,7 @@ 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())
@@ -214,7 +205,7 @@ def readNPYGauge(filename: str):
 
 
 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 +213,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), 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), 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.11.dev0 → pyquda_utils-0.10.0.dev0}/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.11.dev0/pyquda_utils/_version.py

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