PyQUDA-Utils 0.9.8.dev1__tar.gz → 0.9.9.dev3__tar.gz

{pyquda_utils-0.9.8.dev1 → pyquda_utils-0.9.9.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyQUDA-Utils
-Version: 0.9.8.dev1
+Version: 0.9.9.dev3
 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.8.dev1 → pyquda_utils-0.9.9.dev3}/PyQUDA_Utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyQUDA-Utils
-Version: 0.9.8.dev1
+Version: 0.9.9.dev3
 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.8.dev1 → pyquda_utils-0.9.9.dev3}/PyQUDA_Utils.egg-info/SOURCES.txt

@@ -24,6 +24,8 @@ pyquda_utils/io/__init__.py
 pyquda_utils/io/chroma.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/npy.py
+pyquda_utils/io/openqcd.py
 pyquda_utils/io/xqcd.py

pyquda_utils-0.9.9.dev3/pyquda_utils/_version.py

@@ -0,0 +1 @@
+__version__ = "0.9.9.dev3"

{pyquda_utils-0.9.8.dev1 → pyquda_utils-0.9.9.dev3}/pyquda_utils/gpt.py

@@ -49,7 +49,7 @@ def LatticeGaugeGPT(lattice: List[g.lattice], gen_simd_width: int, gauge: Lattic
         for index in range(latt_info.Nd):
             gpt_shape = [i for sl in zip(gpt_simd, gpt_latt) for i in sl]
             lattice[index].mview()[0][:] = (
-                gauge.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)

{pyquda_utils-0.9.8.dev1 → pyquda_utils-0.9.9.dev3}/pyquda_utils/io/__init__.py

@@ -1,4 +1,4 @@
-from typing import List, Union
+from typing import List, Literal, Union
 
 import numpy
 
@@ -218,6 +218,22 @@ def writeNPYPropagator(filename: str, propagator: LatticePropagator):
     write(filename, propagator.latt_info.global_size, propagator.lexico())
 
 
+def readOpenQCDGauge(filename: str, endian: Literal["<", ">"] = "<"):
+    from .openqcd import readGauge as read
+
+    latt_size, plaquette, gauge_raw = read(filename, endian)
+    gauge = LatticeGauge(LatticeInfo(latt_size), cb2(gauge_raw, [1, 2, 3, 4]))
+    print(gauge.plaquette()[0], plaquette)
+    return gauge
+
+
+def writeOpenQCDGauge(filename: str, gauge: LatticeGauge):
+    from .openqcd import writeGauge as write
+
+    print(gauge.plaquette())
+    write(filename, gauge.latt_info.global_size, gauge.plaquette()[0] * Nc, gauge.lexico())
+
+
 def readQIOGauge(filename: str):
     return readChromaQIOGauge(filename)
 

{pyquda_utils-0.9.8.dev1 → pyquda_utils-0.9.9.dev3}/pyquda_utils/io/chroma.py

@@ -1,7 +1,5 @@
-import io
 from os import path
-import struct
-from typing import Dict, List, Tuple
+from typing import List
 from xml.etree import ElementTree as ET
 
 from pyquda import getSublatticeSize, getMPIComm, getGridCoord, readMPIFile
@@ -35,31 +33,18 @@ def checksum_qio(latt_size: List[int], data):
 
 
 def readQIOGauge(filename: str, checksum: bool = True):
-    filename = path.expanduser(path.expandvars(filename))
-    with open(filename, "rb") as f:
-        meta: Dict[str, Tuple[int, int]] = {}
-        buffer = f.read(8)
-        while buffer != b"" and buffer != b"\x0A":
-            assert buffer.startswith(b"\x45\x67\x89\xAB\x00\x01")
-            length = (struct.unpack(">Q", f.read(8))[0] + 7) // 8 * 8
-            name = f.read(128).strip(b"\x00").decode("utf-8")
-            meta[name] = (f.tell(), length)
-            f.seek(length, io.SEEK_CUR)
-            buffer = f.read(8)
-
-        f.seek(meta["scidac-private-file-xml"][0])
-        scidac_private_file_xml = ET.ElementTree(
-            ET.fromstring(f.read(meta["scidac-private-file-xml"][1]).strip(b"\x00").decode("utf-8"))
-        )
-        f.seek(meta["scidac-private-record-xml"][0])
-        scidac_private_record_xml = ET.ElementTree(
-            ET.fromstring(f.read(meta["scidac-private-record-xml"][1]).strip(b"\x00").decode("utf-8"))
-        )
-        f.seek(meta["scidac-checksum"][0])
-        scidac_checksum_xml = ET.ElementTree(
-            ET.fromstring(f.read(meta["scidac-checksum"][1]).strip(b"\x00").decode("utf-8"))
-        )
-        offset = meta["ildg-binary-data"][0]
+    from .lime import Lime
+
+    lime = Lime(filename)
+    scidac_private_file_xml = ET.ElementTree(
+        ET.fromstring(lime.read("scidac-private-file-xml").strip(b"\x00").decode("utf-8"))
+    )
+    scidac_private_record_xml = ET.ElementTree(
+        ET.fromstring(lime.read("scidac-private-record-xml").strip(b"\x00").decode("utf-8"))
+    )
+    scidac_checksum_xml = ET.ElementTree(ET.fromstring(lime.read("scidac-checksum").strip(b"\x00").decode("utf-8")))
+    offset = lime.record("ildg-binary-data").offset
+
     precision = _precision_map[scidac_private_record_xml.find("precision").text]
     assert int(scidac_private_record_xml.find("colors").text) == Nc
     assert (
@@ -94,31 +79,18 @@ def readILDGBinGauge(filename: str, dtype: str, latt_size: List[int]):
 
 
 def readQIOPropagator(filename: str, checksum: bool = True):
-    filename = path.expanduser(path.expandvars(filename))
-    with open(filename, "rb") as f:
-        meta: Dict[str, Tuple[int, int]] = {}
-        buffer = f.read(8)
-        while buffer != b"" and buffer != b"\x0A":
-            assert buffer.startswith(b"\x45\x67\x89\xAB\x00\x01")
-            length = (struct.unpack(">Q", f.read(8))[0] + 7) // 8 * 8
-            name = f.read(128).strip(b"\x00").decode("utf-8")
-            meta[name] = (f.tell(), length)
-            f.seek(length, io.SEEK_CUR)
-            buffer = f.read(8)
-
-        f.seek(meta["scidac-private-file-xml"][0])
-        scidac_private_file_xml = ET.ElementTree(
-            ET.fromstring(f.read(meta["scidac-private-file-xml"][1]).strip(b"\x00").decode("utf-8"))
-        )
-        f.seek(meta["scidac-private-record-xml"][0])
-        scidac_private_record_xml = ET.ElementTree(
-            ET.fromstring(f.read(meta["scidac-private-record-xml"][1]).strip(b"\x00").decode("utf-8"))
-        )
-        f.seek(meta["scidac-checksum"][0])
-        scidac_checksum_xml = ET.ElementTree(
-            ET.fromstring(f.read(meta["scidac-checksum"][1]).strip(b"\x00").decode("utf-8"))
-        )
-        offset = meta["scidac-binary-data"][0]
+    from .lime import Lime
+
+    lime = Lime(filename)
+    scidac_private_file_xml = ET.ElementTree(
+        ET.fromstring(lime.read("scidac-private-file-xml").strip(b"\x00").decode("utf-8"))
+    )
+    scidac_private_record_xml = ET.ElementTree(
+        ET.fromstring(lime.read("scidac-private-record-xml").strip(b"\x00").decode("utf-8"))
+    )
+    scidac_checksum_xml = ET.ElementTree(ET.fromstring(lime.read("scidac-checksum").strip(b"\x00").decode("utf-8")))
+    offset = lime.record("scidac-binary-data").offset
+
     precision = _precision_map[scidac_private_record_xml.find("precision").text]
     assert int(scidac_private_record_xml.find("colors").text) == Nc
     assert (

pyquda_utils-0.9.9.dev3/pyquda_utils/io/lime.py

@@ -0,0 +1,38 @@
+import io
+from os import path
+import struct
+from typing import List, NamedTuple
+
+
+class LimeRecord(NamedTuple):
+    name: str
+    offset: int
+    length: int
+
+
+class Lime:
+    def __init__(self, filename: str):
+        self.filename = path.expanduser(path.expandvars(filename))
+        self._records: List[LimeRecord] = []
+        with open(self.filename, "rb") as f:
+            buffer = f.read(8)
+            while buffer != b"" and buffer != b"\x0A":
+                assert buffer.startswith(b"\x45\x67\x89\xAB\x00\x01")
+                length = struct.unpack(">Q", f.read(8))[0]
+                name = f.read(128).strip(b"\x00").decode("utf-8")
+                self._records.append(LimeRecord(name, f.tell(), length))
+                f.seek((length + 7) // 8 * 8, io.SEEK_CUR)
+                buffer = f.read(8)
+
+    def records(self, key: str):
+        return [record for record in self._records if record.name == key]
+
+    def record(self, key: str, index: int = 0):
+        return [record for record in self._records if record.name == key][index]
+
+    def read(self, key: str, index: int = 0):
+        record = self.record(key, index)
+        with open(self.filename, "rb") as f:
+            f.seek(record.offset)
+            buffer = f.read(record.length)
+        return buffer

{pyquda_utils-0.9.8.dev1 → pyquda_utils-0.9.9.dev3}/pyquda_utils/io/milc.py

@@ -1,8 +1,7 @@
 from datetime import datetime
-import io
 from os import path
 import struct
-from typing import Dict, List, Tuple
+from typing import List
 from xml.etree import ElementTree as ET
 
 import numpy
@@ -107,32 +106,17 @@ def writeGauge(filename: str, latt_size: List[int], gauge: numpy.ndarray):
 
 
 def readQIOPropagator(filename: str):
-    filename = path.expanduser(path.expandvars(filename))
-    with open(filename, "rb") as f:
-        meta: Dict[str, List[Tuple[int, int]]] = {}
-        buffer = f.read(8)
-        while buffer != b"" and buffer != b"\x0A":
-            assert buffer.startswith(b"\x45\x67\x89\xAB\x00\x01")
-            length = (struct.unpack(">Q", f.read(8))[0] + 7) // 8 * 8
-            name = f.read(128).strip(b"\x00").decode("utf-8")
-            if name not in meta:
-                meta[name] = [(f.tell(), length)]
-            else:
-                meta[name].append((f.tell(), length))
-            f.seek(length, io.SEEK_CUR)
-            buffer = f.read(8)
-
-        f.seek(meta["scidac-private-file-xml"][0][0])
-        scidac_private_file_xml = ET.ElementTree(
-            ET.fromstring(f.read(meta["scidac-private-file-xml"][0][1]).strip(b"\x00").decode("utf-8"))
-        )
-        f.seek(meta["scidac-private-record-xml"][1][0])
-        scidac_private_record_xml = ET.ElementTree(
-            ET.fromstring(f.read(meta["scidac-private-record-xml"][1][1]).strip(b"\x00").decode("utf-8"))
-        )
-        offset = []
-        for meta_scidac_binary_data in meta["scidac-binary-data"][1::2]:
-            offset.append(meta_scidac_binary_data[0])
+    from .lime import Lime
+
+    lime = Lime(filename)
+    scidac_private_file_xml = ET.ElementTree(
+        ET.fromstring(lime.read("scidac-private-file-xml", 0).strip(b"\x00").decode("utf-8"))
+    )
+    scidac_private_record_xml = ET.ElementTree(
+        ET.fromstring(lime.read("scidac-private-record-xml", 1).strip(b"\x00").decode("utf-8"))
+    )
+    offset = [record.offset for record in lime.records("scidac-binary-data")[1::2]]
+
     precision = _precision_map[scidac_private_record_xml.find("precision").text]
     assert int(scidac_private_record_xml.find("colors").text) == Nc
     if scidac_private_record_xml.find("spins") is not None:

pyquda_utils-0.9.9.dev3/pyquda_utils/io/openqcd.py

@@ -0,0 +1,39 @@
+from os import path
+import struct
+from typing import List, Literal
+
+import numpy
+
+from pyquda import getSublatticeSize, getMPIRank, getMPIComm, readMPIFile, writeMPIFile
+
+Nd, Ns, Nc = 4, 4, 3
+
+
+def readGauge(filename: str, endian: Literal["<", ">"] = "<"):
+    filename = path.expanduser(path.expandvars(filename))
+    with open(filename, "rb") as f:
+        latt_size = struct.unpack(f"{endian}iiii", f.read(16))[::-1]
+        plaquette = struct.unpack(f"{endian}d", f.read(8))[0]
+        offset = f.tell()
+    Lx, Ly, Lz, Lt = getSublatticeSize(latt_size)
+    dtype = f"{endian}c16"
+
+    gauge = readMPIFile(filename, dtype, offset, (Lt, Lz, Ly, Lx, Nd, Nc, Nc), (3, 2, 1, 0))
+    gauge = gauge.transpose(4, 0, 1, 2, 3, 5, 6).astype("<c16")
+    return latt_size, plaquette, gauge
+
+
+def writeGauge(filename: str, latt_size: List[int], plaquette: float, gauge: numpy.ndarray):
+    filename = path.expanduser(path.expandvars(filename))
+    Lx, Ly, Lz, Lt = latt_size
+    dtype, offset = "<c16", None
+
+    gauge = numpy.ascontiguousarray(gauge.transpose(1, 2, 3, 4, 0, 5, 6).astype(dtype))
+    if getMPIRank() == 0:
+        with open(filename, "wb") as f:
+            f.write(struct.pack("<iiii", *latt_size[::-1]))
+            f.write(struct.pack("<d", plaquette))
+            offset = f.tell()
+    offset = getMPIComm().bcast(offset)
+
+    writeMPIFile(filename, dtype, offset, (Lt, Lz, Ly, Lx, Nd, Nc, Nc), (3, 2, 1, 0), gauge)

pyquda_utils-0.9.8.dev1/pyquda_utils/_version.py

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