def from_file(self, filename, file_handle=None):
"""
Either opens a new h5 file for reading or accesses an already opened file via the given h5.Group handle. Reads
all data from the three categories of attributes (incl. lists and dicts), ndarrays, and objects.
Parameters
----------
filename: str
file_handle: h5.Group, optional
Returns
-------
IOData
"""
if file_handle is None:
h5file_group = h5py.File(filename, 'r')
else:
h5file_group = file_handle
attributes = self.read_attributes(h5file_group)
typename = attributes['__type']
del attributes['__type']
ndarrays = self.read_ndarrays(h5file_group)
inner_objects = self.read_objects(h5file_group)
return io.IOData(typename, attributes, ndarrays, inner_objects)
def NoneType_serialize(none_instance: None) -> 'IOData':
"""
Create an IOData instance to write `None` to file.
"""
import scqubits.io_utils.fileio as io
attributes = {'None': 0}
ndarrays: Dict[str, ndarray] = {}
objects: Dict[str, object] = {}
typename = 'NoneType'
return io.IOData(typename, attributes, ndarrays, objects)
def listlike_serialize(listlike_instance: Union[List, Tuple]) -> 'IOData':
"""
Create an IOData instance from list data.
"""
import scqubits.io_utils.fileio as io
attributes: Dict[str, Any] = {}
ndarrays: Dict[str, ndarray] = {}
objects: Dict[str, object] = {}
typename = type(listlike_instance).__name__
for index, item in enumerate(listlike_instance):
update_func = type_dispatch(item)
attributes, ndarrays, objects = update_func(str(index), item,
attributes, ndarrays,
objects)
return io.IOData(typename, attributes, ndarrays, objects)
def range_serialize(range_instance: range) -> "IOData":
"""
Create an IOData instance from range data.
"""
import scqubits.io_utils.fileio as io
attributes = {
"start": range_instance.start,
"stop": range_instance.stop,
"step": range_instance.step,
}
ndarrays: Dict[str, ndarray] = {}
objects: Dict[str, object] = {}
typename = type(range_instance).__name__
return io.IOData(typename, attributes, ndarrays, objects)
def dict_serialize(dict_instance: Dict[str, Any]) -> 'IOData':
"""
Create an IOData instance from dictionary data.
"""
import scqubits.io_utils.fileio as io
dict_instance = utils.remove_nones(dict_instance)
attributes: Dict[str, Any] = {}
ndarrays: Dict[str, ndarray] = {}
objects: Dict[str, object] = {}
typename = 'dict'
for name, content in dict_instance.items():
update_func = type_dispatch(content)
attributes, ndarrays, objects = update_func(name, content, attributes,
ndarrays, objects)
return io.IOData(typename, attributes, ndarrays, objects)
def from_file(self, filename: str, file_handle: Group = None) -> io.IOData:
"""
Either opens a new h5 file for reading or accesses an already opened file via the given h5.Group handle. Reads
all data from the three categories of attributes (incl. lists and dicts), ndarrays, and objects.
"""
if file_handle is None:
h5file_group = h5py.File(filename, 'r')
else:
h5file_group = file_handle
attributes = self.read_attributes(h5file_group)
typename = attributes['__type']
assert isinstance(typename, str)
del attributes['__type']
ndarrays = self.read_ndarrays(h5file_group)
inner_objects = self.read_objects(h5file_group)
return io.IOData(typename, attributes, ndarrays, inner_objects)
def serialize(self):
"""
Convert the content of the current class instance into IOData format.
Returns
-------
IOData
"""
import scqubits.io_utils.fileio as io
typename = type(self).__name__
evec_count = len(self)
qobj_dims = np.asarray(self[0].dims)
qobj_shape = np.asarray(self[0].shape)
io_attributes = {'evec_count': evec_count}
io_ndarrays = {'evecs': np.asarray([utils.qt_ket_to_ndarray(qobj_ket) for qobj_ket in self]),
'qobj_dims': qobj_dims,
'qobj_shape': qobj_shape}
return io.IOData(typename, io_attributes, io_ndarrays, objects=None)
def serialize(self) -> IOData:
"""
Convert the content of the current class instance into IOData format.
"""
import scqubits.io_utils.fileio as io
typename = "NamedSlotsNdarray"
io_attributes = None
if self.dtype in [np.float_, np.complex_, np.int_]:
io_ndarrays = {"input_array": self.view(np.ndarray)}
objects = {"values_by_name": self._parameters.paramvals_by_name}
else:
io_ndarrays = None
objects = {
"values_by_name": self._parameters.paramvals_by_name,
"input_array": self[:].tolist(),
}
return io.IOData(typename, io_attributes, io_ndarrays, objects=objects)
def from_file(self, filename: str, **kwargs) -> io.IOData:
"""
Returns
-------
class instance generated from file data
"""
ext_attributes = self.read_attributes(filename)
typename = ext_attributes['__type']
del ext_attributes['__type']
attributes, data_names, data_slices = self.process_metadict(
ext_attributes)
filename_stub, _ = os.path.splitext(filename)
ndarrays = {}
for index, dataname in enumerate(data_names):
data_filename = filename_stub + '_' + dataname + '.csv'
slices = data_slices[index]
ndarrays[dataname] = self.read_data(data_filename, slices)
return io.IOData(typename, attributes, ndarrays, objects=None)
def csc_matrix_serialize(csc_matrix_instance: csc_matrix) -> 'IOData':
"""
Create an IOData instance from dictionary data.
"""
import scqubits.io_utils.fileio as io
attributes: Dict[str, Any] = {}
ndarrays: Dict[str, ndarray] = {}
objects: Dict[str, object] = {}
typename = 'csc_matrix'
csc_dict = {
"indices": csc_matrix_instance.indices,
"indptr": csc_matrix_instance.indptr,
"shape": csc_matrix_instance.shape,
"data": csc_matrix_instance.data
}
for name, content in csc_dict.items():
update_func = type_dispatch(content)
attributes, ndarrays, objects = update_func(name, content, attributes,
ndarrays, objects)
return io.IOData(typename, attributes, ndarrays, objects)
def listlike_serialize(listlike_instance):
"""
Create an IOData instance from list data.
Parameters
----------
listlike_instance: list or tuple
Returns
-------
IOData
"""
import scqubits.io_utils.fileio as io
attributes = {}
ndarrays = {}
objects = {}
typename = type(listlike_instance).__name__
for index, item in enumerate(listlike_instance):
update_func = type_dispatch(item)
attributes, ndarrays, objects = update_func(str(index), item,
attributes, ndarrays,
objects)
return io.IOData(typename, attributes, ndarrays, objects)
def dict_serialize(dict_instance):
"""
Create an IOData instance from dictionary data.
Parameters
----------
dict_instance: dict
Returns
-------
IOData
"""
import scqubits.io_utils.fileio as io
dict_instance = utils.remove_nones(dict_instance)
attributes = {}
ndarrays = {}
objects = {}
typename = 'dict'
for name, content in dict_instance.items():
update_func = type_dispatch(content)
attributes, ndarrays, objects = update_func(name, content, attributes,
ndarrays, objects)
return io.IOData(typename, attributes, ndarrays, objects)
