pyuff 2.5.8__tar.gz → 2.6.1__tar.gz

{pyuff-2.5.8 → pyuff-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyuff
-Version: 2.5.8
+Version: 2.6.1
 Summary: UFF (Universal File Format) read/write.
 Project-URL: homepage, https://github.com/ladisk/pyuff
 Project-URL: documentation, https://pyuff.readthedocs.io/en/latest/
@@ -14,12 +14,11 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.11
+Requires-Python: >=3.13
 Requires-Dist: numpy
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'

{pyuff-2.5.8 → pyuff-2.6.1}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyuff"
-version = "2.5.8"
+version = "2.6.1"
 authors = [{name = "Primož Čermelj, Janko Slavič", email = "janko.slavic@fs.uni-lj.si"}]
 maintainers = [{name = "Janko Slavič et al.", email = "janko.slavic@fs.uni-lj.si"}]
 license = "MIT"
 description = "UFF (Universal File Format) read/write."
 readme = "README.rst"
 keywords = ['UFF', 'UNV', 'Universal File Format', 'read/write']
-requires-python = ">=3.11"
+requires-python = ">=3.13"
 dependencies = [
     "numpy",
 ]
@@ -20,10 +20,9 @@ classifiers = [
     'Intended Audience :: Developers',
     'Topic :: Scientific/Engineering',
     'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3.11',
-    'Programming Language :: Python :: 3.12',
     'Programming Language :: Python :: 3.13',
     'Programming Language :: Python :: 3.14',
+    'Programming Language :: Python :: 3.15',
     "License :: OSI Approved :: MIT License",
 ]
 

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/datasets/dataset_151.py

@@ -2,7 +2,7 @@ import numpy as np
 import time
 import os
 
-from ..tools import _opt_fields, _parse_header_line, check_dict_for_none
+from ..tools import _opt_fields, _parse_header_line, check_dict_for_none, _fit_string
 
 def get_structure_151(raw=False):
     """(source: https://www.ceas3.uc.edu/sdrluff/"""
@@ -61,15 +61,18 @@ def _write151(fh, dset):
                                         'time_file_written': ts})
         # write strings to the file
         fh.write('%6i\n%6i%74s\n' % (-1, 151, ' '))
-        fh.write('%-80s\n' % dset['model_name'])
-        fh.write('%-80s\n' % dset['description'])
-        fh.write('%-80s\n' % dset['db_app'])
-        fh.write('%-10s%-10s%10s%10s%10s\n' % (dset['date_db_created'],
-                                                dset['time_db_created'], dset['version_db1'], dset['version_db2'],
+        fh.write('%-80s\n' % _fit_string(dset['model_name'], 80, 'model_name', 151))
+        fh.write('%-80s\n' % _fit_string(dset['description'], 80, 'description', 151))
+        fh.write('%-80s\n' % _fit_string(dset['db_app'], 80, 'db_app', 151))
+        fh.write('%-10s%-10s%10s%10s%10s\n' % (_fit_string(dset['date_db_created'], 10, 'date_db_created', 151),
+                                                _fit_string(dset['time_db_created'], 10, 'time_db_created', 151),
+                                                dset['version_db1'], dset['version_db2'],
                                                 dset['file_type']))
-        fh.write('%-10s%-10s\n' % (dset['date_db_saved'], dset['time_db_saved']))
-        fh.write('%-80s\n' % dset['program'])
-        fh.write('%-10s%-10s\n' % (dset['date_file_written'], dset['time_file_written']))
+        fh.write('%-10s%-10s\n' % (_fit_string(dset['date_db_saved'], 10, 'date_db_saved', 151),
+                                     _fit_string(dset['time_db_saved'], 10, 'time_db_saved', 151)))
+        fh.write('%-80s\n' % _fit_string(dset['program'], 80, 'program', 151))
+        fh.write('%-10s%-10s\n' % (_fit_string(dset['date_file_written'], 10, 'date_file_written', 151),
+                                     _fit_string(dset['time_file_written'], 10, 'time_file_written', 151)))
         fh.write('%6i\n' % -1)
     except KeyError as msg:
         raise Exception('The required key \'' + msg.args[0] + '\' not present when writing data-set #151')

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/datasets/dataset_164.py

@@ -1,7 +1,7 @@
 import numpy as np
 import os
 
-from ..tools import _opt_fields, _parse_header_line, check_dict_for_none
+from ..tools import _opt_fields, _parse_header_line, check_dict_for_none, _fit_string
 
 def get_structure_164(raw=False):
     """(source: https://www.ceas3.uc.edu/sdrluff/"""
@@ -52,7 +52,9 @@ def _write164(fh, dset):
                                         'temp_mode': 1})
         # write strings to the file
         fh.write('%6i\n%6i%74s\n' % (-1, 164, ' '))
-        fh.write('%10i%20s%10i\n' % (dset['units_code'], dset['units_description'], dset['temp_mode']))
+        fh.write('%10i%20s%10i\n' % (dset['units_code'],
+                                       _fit_string(dset['units_description'], 20, 'units_description', 164),
+                                       dset['temp_mode']))
         str = '%25.16e%25.16e%25.16e\n%25.16e\n' % (
             dset['length'], dset['force'], dset['temp'], dset['temp_offset'])
         str = str.replace('e+', 'D+')

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/datasets/dataset_18.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from ..tools import _opt_fields, _parse_header_line, check_dict_for_none
+from ..tools import _opt_fields, _parse_header_line, check_dict_for_none, _fit_string
 
 
 def get_structure_18(raw=False):
@@ -60,7 +60,7 @@ def _write18(fh, dset):
                 int(dset['ref_cs_num'][i]),
                 int(dset['color'][i]),
                 int(dset['method'][i])))
-            fh.write('%-40s\n' % dset['cs_name'][i])
+            fh.write('%-40s\n' % _fit_string(dset['cs_name'][i], 40, 'cs_name', 18))
             fh.write('%13.5e%13.5e%13.5e%13.5e%13.5e%13.5e\n' % (
                 dset['ref_o'][i][0], dset['ref_o'][i][1], dset['ref_o'][i][2],
                 dset['x_point'][i][0], dset['x_point'][i][1], dset['x_point'][i][2]))

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/datasets/dataset_1858.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from ..tools import _opt_fields, _parse_header_line, check_dict_for_none
+from ..tools import _opt_fields, _parse_header_line, check_dict_for_none, _fit_string
 
 def get_structure_1858(raw=False):
     """(source: https://www.ceas3.uc.edu/sdrluff/"""
@@ -155,9 +155,9 @@ def _write1858(fh, dset):
         fh.write('%15.7e%15.7e%15.7e%15.7e%15.7e\n' % (0, 0, 0, 0, 0))
 
         fh.write('%-4s%2s%-4s\n' % (
-            dset['response_direction'],
+            _fit_string(dset['response_direction'], 4, 'response_direction', 1858),
             '',
-            dset['reference_direction'],
+            _fit_string(dset['reference_direction'], 4, 'reference_direction', 1858),
         ))
 
         fh.write('%-80s\n' % 'NONE')

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/datasets/dataset_2400.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from ..tools import _opt_fields, _parse_header_line, check_dict_for_none
+from ..tools import _opt_fields, _parse_header_line, check_dict_for_none, _fit_string
 
 
 def get_structure_2400(raw=False):
@@ -64,10 +64,11 @@ def _write2400(fh, dset):
         fh.write('%6i\n%6i%74s\n' % (-1, 2400, ' '))
         fh.write('%12i%6i%6i%12i\n' % (dset['model_uid'], dset['entity_type'],
                                         dset['entity_subtype'], dset['version_number']))
-        fh.write('%-80s\n' % dset['entity_name'])
-        fh.write('%-80s\n' % dset['part_number'])
+        fh.write('%-80s\n' % _fit_string(dset['entity_name'], 80, 'entity_name', 2400))
+        fh.write('%-80s\n' % _fit_string(dset['part_number'], 80, 'part_number', 2400))
         fh.write('%s\n' % ''.join(['%2i' % v for v in dset['status_mask']]))
-        fh.write('%-10s%-10s%12i%12i%12i\n' % (dset['date'], dset['time'],
+        fh.write('%-10s%-10s%12i%12i%12i\n' % (_fit_string(dset['date'], 10, 'date', 2400),
+                                                 _fit_string(dset['time'], 10, 'time', 2400),
                                                  dset['idm_version_id'], dset['idm_item_id'],
                                                  dset['primary_parent_uid']))
         fh.write('%12i\n' % dset['optimization_switches'])

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/datasets/dataset_2414.py

@@ -1,7 +1,7 @@
 import numpy as np
 import math as math
 
-from ..tools import _opt_fields, _parse_header_line, check_dict_for_none
+from ..tools import _opt_fields, _parse_header_line, check_dict_for_none, _fit_string
 
 def get_structure_2414(raw=False):
     """(source: https://www.ceas3.uc.edu/sdrluff/"""
@@ -564,13 +564,13 @@ def _write2414(fh, dset):
 
         # Write general fields
         fh.write('%10i\n' % (dset['analysis_dataset_label'])) #Loadcase number (DS2414_num)
-        fh.write('%-80s\n' % (dset['analysis_dataset_name'])) #usually with the frequency
+        fh.write('%-80s\n' % (_fit_string(dset['analysis_dataset_name'], 80, 'analysis_dataset_name', 2414))) #usually with the frequency
         fh.write('%10i\n' % (dset['dataset_location']))
-        fh.write('%-80s\n' % dset['id1'])
-        fh.write('%-80s\n' % dset['id2'])
-        fh.write('%-80s\n' % dset['id3']) #usually with the frequency
-        fh.write('%-80s\n' % dset['id4']) #usually with the loadcase
-        fh.write('%-80s\n' % dset['id5'])
+        fh.write('%-80s\n' % _fit_string(dset['id1'], 80, 'id1', 2414))
+        fh.write('%-80s\n' % _fit_string(dset['id2'], 80, 'id2', 2414))
+        fh.write('%-80s\n' % _fit_string(dset['id3'], 80, 'id3', 2414)) #usually with the frequency
+        fh.write('%-80s\n' % _fit_string(dset['id4'], 80, 'id4', 2414)) #usually with the loadcase
+        fh.write('%-80s\n' % _fit_string(dset['id5'], 80, 'id5', 2414))
 
         fh.write('%10i%10i%10i%10i%10i%10i\n' % (
                                         dset['model_type'], 
@@ -668,12 +668,10 @@ def _write2414(fh, dset):
             
             # The data and structure of Record 14 and 15 depend on the 'dataset_location'
             if dset['dataset_location'] == 1:
-                for index in range(dset['node_nums'].shape[0]):
-                    fh.write('%10i\n' % (dset['node_nums'][index]))
-                    for field in dset['data_at_node'][index]:
-                        # number of values unknown, so loop
-                        fh.write('%13.5e' % (field))
-                    fh.write('\n')
+                # the number of values may differ from node to node
+                lines = ['%10i\n' % node + '%13.5e' * len(values) % tuple(values) + '\n'
+                         for node, values in zip(dset['node_nums'], dset['data_at_node'])]
+                fh.write(''.join(lines))
                 fh.write('%6i\n' % (-1))
 
             elif dset['dataset_location'] == 2:
@@ -788,10 +786,9 @@ def _extract2414(block_data):
             split_data = split_data.splitlines()
             if dset['dataset_location'] == 1:
                 # Data at nodes
-                record14 = np.asarray([str.split() for str in split_data[0::2]], 'U')
                 # record 15 not always same number of fields, so a list of ndarray
-                record15 = [np.array([float(elem) for elem in item.split()], float) for item in split_data[1::2]]
-                dset['node_nums'] = np.array(record14[:,0].copy(), dtype=int)
+                record15 = [np.array(line.split(), float) for line in split_data[1::2]]
+                dset['node_nums'] = np.array([line.split()[0] for line in split_data[0::2]], dtype=int)
                 dset['data_at_node'] = record15
 
             elif dset['dataset_location'] == 2:

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/datasets/dataset_2420.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from ..tools import _opt_fields, _parse_header_line, check_dict_for_none
+from ..tools import _opt_fields, _parse_header_line, check_dict_for_none, _fit_string
 
 def get_structure_2420(raw=False):
     """(source: https://www.ceas3.uc.edu/sdrluff/"""
@@ -58,7 +58,7 @@ def _write2420(fh, dset):
         dset = _opt_fields(dset, dict)
         fh.write('%6i\n%6i%74s\n' % (-1, 2420, ' '))
         fh.write('%10i\n' % (dset['Part_UID']))
-        fh.write('%-80s\n' % (dset['Part_Name']))
+        fh.write('%-80s\n' % (_fit_string(dset['Part_Name'], 80, 'Part_Name', 2420)))
 
         # -- Check Dimensions of input arrays
         num_CS = len(dset['CS_sys_labels'])
@@ -66,7 +66,7 @@ def _write2420(fh, dset):
             raise IndexError("Values missing for one or more CS")
         for node in range(num_CS):
             fh.write('%10i%10i%10i\n' % (dset['CS_sys_labels'][node], dset['CS_types'][node], dset['CS_colors'][node]))
-            fh.write('%s\n' % dset['CS_names'][node])
+            fh.write('%s\n' % _fit_string(dset['CS_names'][node], 80, 'CS_names', 2420))
             fh.write('%25.16e%25.16e%25.16e\n' % tuple(dset['CS_matrices'][node][0, :]))
             fh.write('%25.16e%25.16e%25.16e\n' % tuple(dset['CS_matrices'][node][1, :]))
             fh.write('%25.16e%25.16e%25.16e\n' % tuple(dset['CS_matrices'][node][2, :]))

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/datasets/dataset_2429.py

@@ -1,7 +1,7 @@
 import numpy as np
 import math
 
-from ..tools import _opt_fields, _parse_header_line, check_dict_for_none
+from ..tools import _opt_fields, _parse_header_line, check_dict_for_none, _fit_string
 
 def get_structure_2429(raw=False):
     """(source: https://www.ceas3.uc.edu/sdrluff/"""
@@ -125,7 +125,7 @@ def _write2429(fh, dset):
                                                             dset['active_contact_set_no_for_group'],
                                                             len(dset['entity_type_code'])))
         # Record 2
-        fh.write('%-40s\n' % (dset['group_name']))
+        fh.write('%-40s\n' % (_fit_string(dset['group_name'], 40, 'group_name', 2429)))
 
         # Record 3-N
         # Write the full lines (which have 4 pairs)

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/datasets/dataset_2467.py

@@ -1,7 +1,7 @@
 import numpy as np
 import math
 
-from ..tools import _opt_fields, _parse_header_line, check_dict_for_none
+from ..tools import _opt_fields, _parse_header_line, check_dict_for_none, _fit_string
 
 def get_structure_2467(raw=False):
     """(source: https://github.com/victorsndvg/FEconv/blob/master/source/unv/module_dataset_2467.f90)"""
@@ -76,7 +76,7 @@ def _write2467(fh, dset):
                                                              group['active_contact_set_no_for_group'],
                                                              len(group['entity_type_code'])))
             # Record 2
-            fh.write('%-40s\n' % (group['group_name']))
+            fh.write('%-40s\n' % (_fit_string(group['group_name'], 40, 'group_name', 2467)))
 
             # Record 3-N
             # Write the full lines (which have 4 pairs)

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/datasets/dataset_55.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from ..tools import _opt_fields, _parse_header_line, check_dict_for_none
+from ..tools import _opt_fields, _parse_header_line, check_dict_for_none, _fit_string
 
 def get_structure_55(raw=False):
     """(source: https://www.ceas3.uc.edu/sdrluff/"""
@@ -401,11 +401,11 @@ def _write55(fh, dset):
             data_type = 2
         # Write strings to the file
         fh.write('%6i\n%6i%74s\n' % (-1, 55, ' '))
-        fh.write('%-80s\n' % dset['id1'])
-        fh.write('%-80s\n' % dset['id2'])
-        fh.write('%-80s\n' % dset['id3'])
-        fh.write('%-80s\n' % dset['id4'])
-        fh.write('%-80s\n' % dset['id5'])
+        fh.write('%-80s\n' % _fit_string(dset['id1'], 80, 'id1', 55))
+        fh.write('%-80s\n' % _fit_string(dset['id2'], 80, 'id2', 55))
+        fh.write('%-80s\n' % _fit_string(dset['id3'], 80, 'id3', 55))
+        fh.write('%-80s\n' % _fit_string(dset['id4'], 80, 'id4', 55))
+        fh.write('%-80s\n' % _fit_string(dset['id5'], 80, 'id5', 55))
         fh.write('%10i%10i%10i%10i%10i%10i\n' %
                     (dset['model_type'], dset['analysis_type'], dset['data_ch'],
                     dset['spec_data_type'], data_type, n_data_per_node))
@@ -426,26 +426,21 @@ def _write55(fh, dset):
                 dset['modal_b'].real, dset['modal_b'].imag))
         else:
             raise ValueError('Unsupported analysis type')
-        n = len(dset['node_nums'])
+        # Records 14 and 15 of every node: node number, then its values
         if data_type == 2:
             # Real data
             if n_data_per_node == 3:
-                for k in range(0, n):
-                    fh.write('%10i\n' % dset['node_nums'][k])
-                    fh.write('%13.5e%13.5e%13.5e\n' % (dset['r1'][k], dset['r2'][k], dset['r3'][k]))
+                rows = zip(dset['node_nums'], dset['r1'], dset['r2'], dset['r3'])
+                fh.write(''.join('%10i\n%13.5e%13.5e%13.5e\n' % row for row in rows))
             else:
-                for k in range(0, n):
-                    fh.write('%10i\n' % dset['node_nums'][k])
-                    fh.write('%13.5e%13.5e%13.5e%13.5e%13.5e%13.5e\n' %
-                                (dset['r1'][k], dset['r2'][k], dset['r3'][k], dset['r4'][k], dset['r5'][k],
-                                dset['r6'][k]))
+                rows = zip(dset['node_nums'], dset['r1'], dset['r2'], dset['r3'], dset['r4'], dset['r5'], dset['r6'])
+                fh.write(''.join('%10i\n%13.5e%13.5e%13.5e%13.5e%13.5e%13.5e\n' % row for row in rows))
         elif data_type == 5:
             # Complex data; n_data_per_node is assumed being 3
-            for k in range(0, n):
-                fh.write('%10i\n' % dset['node_nums'][k])
-                fh.write('%13.5e%13.5e%13.5e%13.5e%13.5e%13.5e\n' %
-                            (dset['r1'][k].real, dset['r1'][k].imag, dset['r2'][k].real, dset['r2'][k].imag,
-                            dset['r3'][k].real, dset['r3'][k].imag))
+            rows = zip(dset['node_nums'], dset['r1'], dset['r2'], dset['r3'])
+            fh.write(''.join('%10i\n%13.5e%13.5e%13.5e%13.5e%13.5e%13.5e\n' %
+                             (node, r1.real, r1.imag, r2.real, r2.imag, r3.real, r3.imag)
+                             for node, r1, r2, r3 in rows))
         else:
             raise ValueError('Unsupported data type')
         fh.write('%6i\n' % -1)
@@ -504,7 +499,9 @@ def _extract55(block_data):
             # Body
         split_data = ''.join(split_data[10:])
         node_nums = np.asarray([int(str) for str in split_data.splitlines(True)[::2]])
-        node_vals = np.array([[str[i*13:(i+1)*13] for i in range(len(str)//13) ] for str in split_data.splitlines(True)[1::2]], 'd').flatten()
+        # values are in fields of 13 characters, which may touch each other
+        value_lines = split_data.splitlines()[1::2]
+        node_vals = np.array([line[i:i + 13] for line in value_lines for i in range(0, len(line) - 12, 13)], 'd')
         if dset['data_type'] == 2:
             # real data
             if dset['n_data_per_node'] == 3:

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/datasets/dataset_58.py

@@ -3,7 +3,7 @@ import struct
 import sys
 import os
 
-from ..tools import _opt_fields, _parse_header_line, check_dict_for_none
+from ..tools import _opt_fields, _parse_header_line, check_dict_for_none, _fit_string
 
 def get_structure_58(raw=False):
     """(source: https://www.ceas3.uc.edu/sdrluff/"""
@@ -827,7 +827,8 @@ that takes on a binary format in the future.
 def _write58(fh, dset, mode='add', _filename=None, force_double=True):
     """Writes function at nodal DOF - data-set 58 - to an open file fh."""
     try:
-        if not (dset['func_type'] in [0, 1, 2, 3, 4, 6, 9]):
+        # function types 0-27 of the format; the record layout does not depend on the type
+        if not (dset['func_type'] in range(28)):
             raise ValueError('Unsupported function type')
         # handle optional fields - only those that are not calculated
         # automatically
@@ -888,18 +889,26 @@ def _write58(fh, dset, mode='add', _filename=None, force_double=True):
 
         if dset['ord_data_type'] in [4, 6]: # double precision
             is_double = True
-            n_bytes = num_pts * 8
+            n_value_bytes = 8
         elif dset['ord_data_type'] in [2, 5]: # sigle precision
             is_double = False
-            n_bytes = num_pts * 4
-
-        if 'n_bytes' in dset.keys():
-            dset['n_bytes'] = n_bytes
+            n_value_bytes = 4
 
         ord_data_type = dset['ord_data_type']
 
         is_even = bool(dset['abscissa_spacing'])  # handling even/uneven abscissa spacing manually
 
+        # number of bytes of the binary data (58b): every value written, i.e. the
+        # real and imaginary part for complex data and the abscissa for uneven spacing;
+        # the abscissa is always real single precision
+        n_ord_values = 1 if is_r else 2
+        n_bytes = num_pts * n_ord_values * n_value_bytes
+        if not is_even:
+            n_bytes += num_pts * 4
+
+        if 'n_bytes' in dset.keys():
+            dset['n_bytes'] = n_bytes
+
         # handling abscissa spacing automatically
         # is_even = len( set( [ dset['x'][ii]-dset['x'][ii-1] for ii in range(1,len(dset['x'])) ] ) ) == 1
         dset['abscissa_min'] = dset['x'][0]
@@ -913,34 +922,39 @@ def _write58(fh, dset, mode='add', _filename=None, force_double=True):
             fh.write('b%6i%6i%12i%12i%6i%6i%12i%12i\n' % (bo, 2, 11, n_bytes, 0, 0, 0, 0))
         else:
             fh.write('%74s\n' % ' ')
-        fh.write('%-80s\n' % dset['id1'])
-        fh.write('%-80s\n' % dset['id2'])
-        fh.write('%-80s\n' % dset['id3'])
-        fh.write('%-80s\n' % dset['id4'])
-        fh.write('%-80s\n' % dset['id5'])
+        fh.write('%-80s\n' % _fit_string(dset['id1'], 80, 'id1', 58))
+        fh.write('%-80s\n' % _fit_string(dset['id2'], 80, 'id2', 58))
+        fh.write('%-80s\n' % _fit_string(dset['id3'], 80, 'id3', 58))
+        fh.write('%-80s\n' % _fit_string(dset['id4'], 80, 'id4', 58))
+        fh.write('%-80s\n' % _fit_string(dset['id5'], 80, 'id5', 58))
         fh.write('%5i%10i%5i%10i %10s%10i%4i %10s%10i%4i\n' %
                     (dset['func_type'], dset['func_id'], dset['ver_num'], dset['load_case_id'],
-                    dset['rsp_ent_name'], dset['rsp_node'], dset['rsp_dir'], dset['ref_ent_name'],
+                    _fit_string(dset['rsp_ent_name'], 10, 'rsp_ent_name', 58), dset['rsp_node'], dset['rsp_dir'],
+                    _fit_string(dset['ref_ent_name'], 10, 'ref_ent_name', 58),
                     dset['ref_node'], dset['ref_dir']))
         fh.write('%10i%10i%10i%13.5e%13.5e%13.5e\n' % (ord_data_type, num_pts, is_even,
                                                         is_even * dset['abscissa_min'], is_even * dx,
                                                         dset['z_axis_value']))
         fh.write('%10i%5i%5i%5i %-20s %-20s\n' % (dset['abscissa_spec_data_type'],
                                                     dset['abscissa_len_unit_exp'], dset['abscissa_force_unit_exp'],
-                                                    dset['abscissa_temp_unit_exp'], dset['abscissa_axis_lab'],
-                                                    dset['abscissa_axis_units_lab']))
+                                                    dset['abscissa_temp_unit_exp'],
+                                                    _fit_string(dset['abscissa_axis_lab'], 20, 'abscissa_axis_lab', 58),
+                                                    _fit_string(dset['abscissa_axis_units_lab'], 20, 'abscissa_axis_units_lab', 58)))
         fh.write('%10i%5i%5i%5i %-20s %-20s\n' % (dset['ordinate_spec_data_type'],
                                                     dset['ordinate_len_unit_exp'], dset['ordinate_force_unit_exp'],
-                                                    dset['ordinate_temp_unit_exp'], dset['ordinate_axis_lab'],
-                                                    dset['ordinate_axis_units_lab']))
+                                                    dset['ordinate_temp_unit_exp'],
+                                                    _fit_string(dset['ordinate_axis_lab'], 20, 'ordinate_axis_lab', 58),
+                                                    _fit_string(dset['ordinate_axis_units_lab'], 20, 'ordinate_axis_units_lab', 58)))
         fh.write('%10i%5i%5i%5i %-20s %-20s\n' % (dset['orddenom_spec_data_type'],
                                                     dset['orddenom_len_unit_exp'], dset['orddenom_force_unit_exp'],
-                                                    dset['orddenom_temp_unit_exp'], dset['orddenom_axis_lab'],
-                                                    dset['orddenom_axis_units_lab']))
+                                                    dset['orddenom_temp_unit_exp'],
+                                                    _fit_string(dset['orddenom_axis_lab'], 20, 'orddenom_axis_lab', 58),
+                                                    _fit_string(dset['orddenom_axis_units_lab'], 20, 'orddenom_axis_units_lab', 58)))
         fh.write('%10i%5i%5i%5i %-20s %-20s\n' % (dset['z_axis_spec_data_type'],
                                                     dset['z_axis_len_unit_exp'], dset['z_axis_force_unit_exp'],
-                                                    dset['z_axis_temp_unit_exp'], dset['z_axis_axis_lab'],
-                                                    dset['z_axis_axis_units_lab']))
+                                                    dset['z_axis_temp_unit_exp'],
+                                                    _fit_string(dset['z_axis_axis_lab'], 20, 'z_axis_axis_lab', 58),
+                                                    _fit_string(dset['z_axis_axis_units_lab'], 20, 'z_axis_axis_units_lab', 58)))
         if is_r:
             if is_even:
                 data = dset['data'].copy()
@@ -958,23 +972,30 @@ def _write58(fh, dset, mode='add', _filename=None, force_double=True):
                 data[0:-2:3] = dset['x']
                 data[1:-1:3] = dset['data'].real
                 data[2::3] = dset['data'].imag
-        # always write data in double precision
         if dset['binary']:
             fh.close()
-            if mode.lower() == 'overwrite':
-                fh = open(_filename, 'wb')
-            elif mode.lower() == 'add':
-                fh = open(_filename, 'ab')
-            # write data
+            # the header was just written to the file: append in both modes
+            fh = open(_filename, 'ab')
+            # write data in the precision given by the ordinate data type
+            if is_double:
+                value_format = 'd'
+            else:
+                value_format = 'f'
             if bo == 1:
-                [fh.write(struct.pack('<d', datai)) for datai in data]
+                byte_order = '<'
+            else:
+                byte_order = '>'
+            if is_even:
+                fh.write(data.astype(byte_order + value_format).tobytes())
             else:
-                [fh.write(struct.pack('>d', datai)) for datai in data]
+                # uneven spacing: the abscissa is always real single precision
+                rows = np.zeros(num_pts, [('x', byte_order + 'f'),
+                                          ('y', byte_order + value_format, (n_ord_values,))])
+                rows['x'] = dset['x']
+                rows['y'] = data.reshape(num_pts, -1)[:, 1:]
+                fh.write(rows.tobytes())
             fh.close()
-            if mode.lower() == 'overwrite':
-                fh = open(_filename, 'wt', encoding='utf-8')
-            elif mode.lower() == 'add':
-                fh = open(_filename, 'at', encoding='utf-8')
+            fh = open(_filename, 'at', encoding='utf-8')
         else:
             if is_double: # write double precision
                 n4_blocks = len(data) // 4
@@ -1088,6 +1109,15 @@ def _extract58(block_data, header_only=False):
                         # single precision - 4 bytes, note: sometimes split_data wrongly contains CR/LF and 
                         # therefore the length of split_data is not divisible by 4
                         values = np.asarray(struct.unpack('%c%sf' % (bo, int(len(split_data) / 4)), split_data[:(len(split_data) // 4)*4]), 'd')
+                    elif (dset['abscissa_spacing'] == 0) and \
+                            (len(split_data) < dset['num_pts'] * (8 + 8 * (1 if dset['ord_data_type'] == 4 else 2))):
+                        # double precision, uneven abscissa: the abscissa is real single precision
+                        # (pyuff 2.5.8 and older wrote it in double precision; those records are
+                        # longer and are read below)
+                        n_ord_values = 1 if dset['ord_data_type'] == 4 else 2
+                        rows = np.frombuffer(split_data[:dset['num_pts'] * (4 + 8 * n_ord_values)],
+                                             [('x', bo + 'f'), ('y', bo + 'd', (n_ord_values,))])
+                        values = np.column_stack((rows['x'], rows['y'])).ravel().astype('d')
                     else:
                         # double precision - 8 bytes, note: sometimes split_data wrongly contains CR/LF and 
                         # therefore the length of split_data is not divisible by 8

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/datasets/dataset_82.py

@@ -1,7 +1,7 @@
 import numpy as np
 import os
 
-from ..tools import _opt_fields, _parse_header_line, check_dict_for_none
+from ..tools import _opt_fields, _parse_header_line, check_dict_for_none, _fit_string
 
 def get_structure_82(raw=False):
     """(source: https://www.ceas3.uc.edu/sdrluff/"""
@@ -57,7 +57,7 @@ def _write82(fh, dset):
         n_nodes = np.sum((dset['nodes'][1:] - dset['nodes'][:-1]) != 0) + 1
         fh.write('%6i\n%6i%74s\n' % (-1, 82, ' '))
         fh.write('%10i%10i%10i\n' % (dset['trace_num'], n_nodes, dset['color']))
-        fh.write('%-80s\n' % dset['id'])
+        fh.write('%-80s\n' % _fit_string(dset['id'], 80, 'id', 82))
         sl = 0
         n8_blocks = n_nodes // 8
         rem_lines = n_nodes % 8

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/pyuff.py

@@ -225,9 +225,11 @@ class UFF:
                     si = self._block_ind[ii, 0]
                     ei = self._block_ind[ii, 1]
                     try:
-                        block_data = data[si:ei + 1].splitlines()
-                        self._set_types[ii] = int(block_data[1][0:6])
-                        if block_data[1][6].lower() == 'b':
+                        # only the second line (data-set type, 'b' for binary) is
+                        # needed; it follows the '    -1' line within 200 bytes
+                        type_line = data[si:min(si + 200, ei + 1)].splitlines()[1]
+                        self._set_types[ii] = int(type_line[0:6])
+                        if type_line[6:7].lower() == b'b':
                             self._set_formats[ii] = 1
                     except:
                         # Some non-valid blocks found; ignore the exception
@@ -257,6 +259,11 @@ class UFF:
                      This usefull for large files.         
         """
         dset = []
+        if not self.file_exists():
+            raise Exception('Cannot read from a non-existing file: ' + self._filename)
+        if not self._refreshed:
+            if not self.refresh():
+                raise Exception('Cannot read from the file: ' + self._filename)
         if setn is None:
             read_range = range(0, self._n_sets)
         else:
@@ -264,11 +271,6 @@ class UFF:
                 read_range = [setn]
             else:
                 read_range = setn
-        if not self.file_exists():
-            raise Exception('Cannot read from a non-existing file: ' + self._filename)
-        if not self._refreshed:
-            if not self.refresh():
-                raise Exception('Cannot read from the file: ' + self._filename)
         try:
             for ii in read_range:
                 dset.append(self._read_set(ii, header_only=header_only))
@@ -297,11 +299,15 @@ class UFF:
         calculated automatically and the dset is updated - as dset is actually
         an alias (aka pointer), this is reflected at the caller too.
 
-        The required fields are:
-            dset - dictionary representing the data-set
-            mode - 'add' or 'overwrite'
-            force_double - True or False (default True). Single precision should be avoided, 
-                           therefore by default data is saved with double precision.
+        NaN and infinite values in ``data`` are written as 0 and as the
+        largest finite float, respectively, with a warning.
+
+        Parameters:
+
+        - ``dsets``: a dictionary, or a list of dictionaries, one per data-set
+        - ``mode``: ``'add'`` (default) or ``'overwrite'``
+        - ``force_double``: ``True`` (default) or ``False``; single precision should be
+          avoided, therefore by default data is saved with double precision.
         """
         if (not type(dsets).__name__ == 'list'):
             dsets = [dsets]
@@ -320,6 +326,7 @@ class UFF:
                 self._write_set(dsets[ii], 'add', force_double=force_double)
         else:
             raise Exception('Unknown mode: ' + mode)
+        self.refresh()
 
     def _read_set(self, n, header_only=False):
         """
@@ -439,6 +446,13 @@ class UFF:
                 raise Exception('Data-set\'s dictionary is missing the required \'type\' key')
             # handle nan or inf
             if 'data' in dset.keys():
+                data = np.asarray(dset['data'])
+                if np.issubdtype(data.dtype, np.inexact):
+                    n_not_finite = np.count_nonzero(~np.isfinite(data))
+                    if n_not_finite:
+                        warnings.warn('Data-set %s: %i of %i data values are NaN or infinite; '
+                                      'NaN is written as 0 and infinity as the largest finite '
+                                      'float.' % (set_type, n_not_finite, data.size), stacklevel=3)
                 dset['data'] = np.nan_to_num(dset['data'])
 
             if set_type == 15:
@@ -479,7 +493,9 @@ class UFF:
             raise  # re-raise the last exception
         else:
             fh.close()
-        self.refresh()
+        # the file has changed: its index of data-sets is rebuilt when it is
+        # needed next, not after every data-set (write_sets writes many)
+        self._refreshed = False
 
 
 if __name__ == '__main__':

{pyuff-2.5.8 → pyuff-2.6.1}/pyuff/tools.py

@@ -1,5 +1,6 @@
 import pyuff
 import numpy as np
+import warnings
 
 def _opt_fields(dict, fields_dict):
     """Sets the optional fields of the dict dictionary. 
@@ -118,6 +119,24 @@ def _write_record(fh, values, formats, multiline=False, fstring=True):
 
     fh.write(to_write)
 
+def _fit_string(value, width, field, set_type):
+    """Returns the value as a string of at most width characters.
+
+    A longer string does not fit the fixed-width field of the record; it is
+    truncated with a warning naming the data-set and the field.
+
+    :param value: value to be written to a text field
+    :param width: width of the field (characters)
+    :param field: name of the field (key of the dataset dictionary)
+    :param set_type: data-set number
+    """
+    value = str(value)
+    if len(value) > width:
+        warnings.warn('Data-set %s: %s is longer than %i characters and is truncated to %r.'
+                      % (set_type, field, width, value[:width]), stacklevel=5)
+        value = value[:width]
+    return value
+
 def check_dict_for_none(dataset):
     dataset1 = {}
     for k, v in dataset.items():