sdfr 1.0.0__py3-none-win_amd64.whl → 1.2.0__py3-none-win_amd64.whl

sdfr/SDF.py

@@ -310,10 +310,8 @@ class BlockList:
         clib = sdf_lib
         self._clib = clib
         clib.sdf_open.restype = ct.POINTER(SdfFile)
-        #clib.sdf_open.restype = ct.c_void_p
         clib.sdf_open.argtypes = [ct.c_char_p, ct.c_int, ct.c_int, ct.c_int]
         clib.sdf_stack_init.argtypes = [ct.c_void_p]
-        #clib.sdf_read_blocklist.argtypes = [ct.POINTER(SdfFile)]
         clib.sdf_read_blocklist.argtypes = [ct.c_void_p]
         clib.sdf_read_blocklist_all.argtypes = [ct.c_void_p]
         clib.sdf_helper_read_data.argtypes = [ct.c_void_p, ct.POINTER(SdfBlock)]
@@ -336,35 +334,71 @@ class BlockList:
 
 
         block = h.contents.blocklist
+        self.Header = get_header(h.contents)
         meshes = []
         mesh_vars = []
+        self._block_ids = {}
+        self._block_names = {}
         for n in range(h.contents.nblocks):
             block = block.contents
             block._handle = h
+            block._blocklist = self
             blocktype = block.blocktype
+            newblock = None
             name = get_member_name(block.name)
-            if blocktype == SdfBlockType.SDF_BLOCKTYPE_RUN_INFO:
-                self.Run_info = get_run_info(block)
+            if blocktype == SdfBlockType.SDF_BLOCKTYPE_ARRAY:
+                newblock = BlockArray(block)
             elif blocktype == SdfBlockType.SDF_BLOCKTYPE_CONSTANT:
-                self.__dict__[name] = BlockConstant(block)
-            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_PLAIN_VARIABLE:
-                self.__dict__[name] = BlockPlainVariable(block)
-                mesh_vars.append(self.__dict__[name])
-            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_POINT_VARIABLE:
-                self.__dict__[name] = BlockPointVariable(block)
-                mesh_vars.append(self.__dict__[name])
+                newblock = BlockConstant(block)
+            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS \
+              or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED:
+                if block.stagger == 10 or block.stagger == 12:
+                    newblock = BlockStitchedPath(block)
+                else:
+                    newblock = BlockStitched(block)
+            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS_MATERIAL \
+              or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED_MATERIAL:
+                newblock = BlockStitchedMaterial(block)
+            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS_MATVAR \
+              or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED_MATVAR:
+                newblock = BlockStitchedMatvar(block)
+            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS_SPECIES \
+              or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED_SPECIES:
+                newblock = BlockStitchedSpecies(block)
+            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS_TENSOR \
+              or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED_TENSOR:
+                newblock = BlockStitchedTensor(block)
+            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_DATABLOCK:
+                newblock = BlockData(block)
+            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_LAGRANGIAN_MESH:
+                newblock = BlockLagrangianMesh(block)
+                meshes.append(newblock)
+            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_NAMEVALUE:
+                newblock = BlockNameValue(block)
+            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_PLAIN_DERIVED \
+              or blocktype == SdfBlockType.SDF_BLOCKTYPE_PLAIN_VARIABLE:
+                newblock = BlockPlainVariable(block)
+                mesh_vars.append(newblock)
             elif blocktype == SdfBlockType.SDF_BLOCKTYPE_PLAIN_MESH:
-                self.__dict__[name] = BlockPlainMesh(block)
-                meshes.append(self.__dict__[name])
+                newblock = BlockPlainMesh(block)
+                meshes.append(newblock)
+            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_POINT_DERIVED \
+              or blocktype == SdfBlockType.SDF_BLOCKTYPE_POINT_VARIABLE:
+                newblock = BlockPointVariable(block)
+                mesh_vars.append(newblock)
             elif blocktype == SdfBlockType.SDF_BLOCKTYPE_POINT_MESH:
-                self.__dict__[name] = BlockPointMesh(block)
-                meshes.append(self.__dict__[name])
-            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_NAMEVALUE:
-                self.__dict__[name] = BlockNameValue(block)
-            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_ARRAY:
-                self.__dict__[name] = BlockArray(block)
-            #else:
-            #    print(name,SdfBlockType(blocktype).name)
+                newblock = BlockPointMesh(block)
+                meshes.append(newblock)
+            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_RUN_INFO:
+                self.Run_info = get_run_info(block)
+            else:
+                # Block not supported
+                # print(name,SdfBlockType(blocktype).name)
+                pass
+            if newblock is not None:
+                self.__dict__[name] = newblock
+                self._block_ids.update({block.id.decode() : newblock})
+                self._block_names.update({block.name.decode() : newblock})
             block = block.next
 
         for var in mesh_vars:
@@ -380,6 +414,16 @@ class BlockList:
         self._clib.sdf_stack_destroy(self._handle)
         self._clib.sdf_close(self._handle)
 
+    @property
+    def name_dict(self):
+        """Dictionary of blocks using name field as key"""
+        return self._block_names
+
+    @property
+    def id_dict(self):
+        """Dictionary of blocks using id field as key"""
+        return self._block_ids
+
 
 class Block:
     """SDF block type
@@ -395,6 +439,8 @@ class Block:
         self._dims = tuple(block.dims[:block.ndims])
         self._contents = block
         self._owndata = True
+        self._blocklist = block._blocklist
+        self._data = None
 
     def __del__(self):
         if not self._owndata and self._data is not None:
@@ -413,6 +459,11 @@ class Block:
         self._owndata = False
         return np.frombuffer(buf, dtype)
 
+    @property
+    def blocklist(self):
+        """Blocklist"""
+        return self._blocklist
+
     @property
     def data(self):
         """Block data contents"""
@@ -446,7 +497,7 @@ class Block:
 
 
 class BlockConstant(Block):
-    """Constant block class"""
+    """Constant block"""
     def __init__(self, block):
         super().__init__(block)
         offset = getattr(SdfBlock, 'const_value').offset
@@ -456,10 +507,7 @@ class BlockConstant(Block):
 
 
 class BlockPlainVariable(Block):
-    def __init__(self, block):
-        super().__init__(block)
-        self._data = None
-
+    """Plain variable block"""
     @property
     def data(self):
         """Block data contents"""
@@ -500,6 +548,7 @@ class BlockPlainVariable(Block):
 
 
 class BlockPlainMesh(Block):
+    """Plain mesh block"""
     def __init__(self, block):
         super().__init__(block)
         self._data = None
@@ -508,7 +557,8 @@ class BlockPlainMesh(Block):
         self._mult = None
         if bool(block.dim_mults):
             self._mult = tuple(block.dim_mults[:block.ndims])
-        self._extents = tuple(block.extents[:2*block.ndims])
+        if bool(block.extents):
+            self._extents = tuple(block.extents[:2*block.ndims])
 
     @property
     def data(self):
@@ -550,10 +600,28 @@ class BlockPlainMesh(Block):
         return self._units
 
 
-class BlockPointMesh(BlockPlainMesh):
-    def __init__(self, block):
-        super().__init__(block)
+class BlockLagrangianMesh(BlockPlainMesh):
+    """Lagrangian mesh block"""
+    @property
+    def data(self):
+        """Block data contents"""
+        if self._data is None:
+            clib = self._handle._clib
+            clib.sdf_helper_read_data(self._handle, self._contents)
+            blen = np.dtype(self._datatype).itemsize
+            for d in self.dims:
+                blen *= d
+            grids = []
+            for i, d in enumerate(self.dims):
+                array = self._numpy_from_buffer(self._contents.grids[i], blen)
+                array = array.reshape(self.dims, order='F')
+                grids.append(array)
+            self._data = tuple(grids)
+        return self._data
+
 
+class BlockPointMesh(BlockPlainMesh):
+    """Point mesh block"""
     @property
     def species_id(self):
         """Species ID"""
@@ -561,9 +629,7 @@ class BlockPointMesh(BlockPlainMesh):
 
 
 class BlockPointVariable(BlockPlainVariable):
-    def __init__(self, block):
-        super().__init__(block)
-
+    """Point variable block"""
     @property
     def species_id(self):
         """Species ID"""
@@ -571,6 +637,7 @@ class BlockPointVariable(BlockPlainVariable):
 
 
 class BlockNameValue(Block):
+    """Name/value block"""
     def __init__(self, block):
         super().__init__(block)
         self._dims = (block.ndims,)
@@ -590,10 +657,7 @@ class BlockNameValue(Block):
 
 
 class BlockArray(Block):
-    def __init__(self, block):
-        super().__init__(block)
-        self._data = None
-
+    """Array block"""
     @property
     def data(self):
         """Block data contents"""
@@ -608,19 +672,112 @@ class BlockArray(Block):
         return self._data
 
 
+class BlockData(Block):
+    """Data block"""
+    def __init__(self, block):
+        super().__init__(block)
+        self._checksum = block.checksum.decode()
+        self._checksum_type = block.checksum_type.decode()
+        self._mimetype = block.mimetype.decode()
+
+    @property
+    def data(self):
+        """Block data contents"""
+        if self._data is None:
+            clib = self._handle._clib
+            clib.sdf_helper_read_data(self._handle, self._contents)
+            blen = self._contents.data_length
+            _data = ct.cast(self._contents.data, ct.POINTER(ct.c_char * blen))
+            self._data = _data.contents[:]
+        return self._data
+
+    @property
+    def checksum(self):
+        """Block data checksum"""
+        return self._checksum
+
+    @property
+    def checksum_type(self):
+        """Block data checksum type"""
+        return self._checksum_type
+
+    @property
+    def mimetype(self):
+        """mimetype for Block data contents"""
+        return self._mimetype
+
+
+class BlockStitched(Block):
+    """Stitched block"""
+    @property
+    def data(self):
+        """Block data contents"""
+        if self._data is None:
+            self._data = []
+            for i in range(self._contents.ndims):
+                vid = self._contents.variable_ids[i]
+                if len(vid) > 0:
+                    vid = vid.decode()
+                    self._data.append(self._blocklist._block_ids[vid])
+        return self._data
+
+
+class BlockStitchedPath(BlockStitched):
+    """Stitched path block"""
+    pass
+
+
+class BlockStitchedMaterial(BlockStitched):
+    """Stitched material block"""
+    pass
+
+
+class BlockStitchedMatvar(BlockStitched):
+    """Stitched material variable block"""
+    pass
+
+
+class BlockStitchedSpecies(BlockStitched):
+    """Stitched species block"""
+    pass
+
+
+class BlockStitchedTensor(BlockStitched):
+    """Stitched tensor block"""
+    pass
+
+
+def get_header(h):
+    d = {}
+    d['filename'] = h.filename.decode()
+    d['file_version'] = h.file_version
+    d['file_revision'] = h.file_revision
+    d['code_name'] = h.code_name.decode()
+    d['step'] = h.step
+    d['time'] = h.time
+    d['jobid1'] = h.jobid1
+    d['jobid2'] = h.jobid2
+    d['code_io_version'] = h.code_io_version
+    d['restart_flag'] = h.restart_flag
+    d['other_domains'] = h.other_domains
+    d['station_file'] = h.station_file
+    return d
+
+
 def get_run_info(block):
     from datetime import datetime
-    r = ct.cast(block.data, ct.POINTER(RunInfo)).contents
-    ri = {}
-    ri['version'] = f"{r.version}.{r.revision}.{r.minor_rev}"
-    ri['commit_id'] = r.commit_id.decode()
-    ri['sha1sum'] = r.sha1sum.decode()
-    ri['compile_machine'] = r.compile_machine.decode()
-    ri['compile_flags'] = r.compile_flags.decode()
-    ri['compile_date'] = datetime.utcfromtimestamp(r.compile_date).strftime('%c')
-    ri['run_date'] = datetime.utcfromtimestamp(r.run_date).strftime('%c')
-    ri['io_data'] = datetime.utcfromtimestamp(r.io_date).strftime('%c')
-    return ri
+    h = ct.cast(block.data, ct.POINTER(RunInfo)).contents
+    d = {}
+    d['version'] = f"{h.version}.{h.revision}.{h.minor_rev}"
+    d['commit_id'] = h.commit_id.decode()
+    d['sha1sum'] = h.sha1sum.decode()
+    d['compile_machine'] = h.compile_machine.decode()
+    d['compile_flags'] = h.compile_flags.decode()
+    d['compile_date'] = datetime.utcfromtimestamp(h.compile_date).strftime('%c')
+    d['run_date'] = datetime.utcfromtimestamp(h.run_date).strftime('%c')
+    d['io_data'] = datetime.utcfromtimestamp(h.io_date).strftime('%c')
+    return d
+
 
 def get_member_name(name):
     sname = name.decode()
@@ -628,7 +785,7 @@ def get_member_name(name):
                     or (i >= "0" and i <= "9")) else "_" \
                     for i in sname])
 
-def read(filename, convert=False, derived=True):
+def read(filename, convert=False, mmap=0, dict=False, derived=True):
     """Reads the SDF data and returns a dictionary of NumPy arrays.
 
     Parameters
@@ -637,8 +794,23 @@ def read(filename, convert=False, derived=True):
         The name of the SDF file to open.
     convert : bool, optional
         Convert double precision data to single when reading file.
+    dict : bool, optional
+        Return file contents as a dictionary rather than member names.
     derived : bool, optional
         Include derived variables in the data structure.
     """
 
-    return BlockList(filename, convert, derived)
+    import warnings
+
+    if mmap != 0:
+        warnings.warn("mmap flag ignored")
+
+    blocklist = BlockList(filename, convert, derived)
+
+    if isinstance(dict, str):
+        if dict == "id" or dict == "ids":
+            return blocklist._block_ids
+    elif isinstance(dict, bool) and dict:
+        return blocklist._block_names
+
+    return blocklist

sdfr/__init__.py

@@ -17,8 +17,8 @@
 
 _module_name = "sdfr"
 
-from .SDF import read
-from .sdf_helper import *
+from .SDF import *
+from . import sdf_helper
 from ._commit_info import (
     __commit_date__,
     __commit_id__,

sdfr/_commit_info.py

@@ -1,2 +1,2 @@
-__commit_date__ = "Mon Feb 17 16:26:23 2025 +0000"
-__commit_id__ = "65c7798d61fed5d13311f7484b897d4ad8df4add"
+__commit_date__ = "Thu Mar 6 21:34:01 2025 +0000"
+__commit_id__ = "658f397aca1fa9cfcef3a31d2ea4ba9291c4aa96"