def xyz(snapshot):
"""
Returns
-------
xyz : numpy.ndarray, shape=(atoms, 3), dtype=numpy.float32
atomic coordinates without dimensions. Be careful.
"""
coord = snapshot.coordinates
if is_simtk_quantity(coord):
return coord._value
else:
return coord
def simplify(self, obj, base_type=''):
if obj.__class__.__name__ == 'module':
# store an imported module
if obj.__name__.split('.')[0] in self.safe_modules:
return {'_import': obj.__name__}
else:
raise RuntimeError(
('The module reference "%s" you want to store is '
'not allowed!') % obj.__name__)
elif type(obj) is type or type(obj) is abc.ABCMeta:
# store a storable number type
if obj in self.type_classes:
return {'_type': obj.__name__}
else:
return None
elif type(obj) is float and math.isinf(obj):
return {'_float': str(obj)}
elif type(obj) is int and math.isinf(obj):
return {'_integer': str(obj)}
elif obj.__class__.__module__ != builtin_module:
if is_simtk_quantity(obj):
# This is number with a unit so turn it into a list
if self.unit_system is not None:
return {
'_value':
self.simplify(
obj.value_in_unit_system(self.unit_system)),
'_units':
self.unit_to_dict(
obj.unit.in_unit_system(self.unit_system))
}
else:
return {
'_value': self.simplify(obj / obj.unit, base_type),
'_units': self.unit_to_dict(obj.unit)
}
elif obj.__class__ is np.ndarray:
# this is maybe not the best way to store large numpy arrays!
return {
'_numpy': self.simplify(obj.shape),
'_dtype': str(obj.dtype),
'_data': base64.b64encode(obj.copy(order='C'))
}
elif hasattr(obj, 'to_dict'):
# the object knows how to dismantle itself into a json string
if hasattr(obj, '__uuid__'):
return {
'_cls': obj.__class__.__name__,
'_obj_uuid': str(UUID(int=obj.__uuid__)),
'_dict': self.simplify(obj.to_dict(), base_type)
}
else:
return {
'_cls': obj.__class__.__name__,
'_dict': self.simplify(obj.to_dict(), base_type)
}
elif type(obj) is UUID:
return {'_uuid': str(UUID(int=obj))}
else:
return None
elif type(obj) is list:
return [self.simplify(o, base_type) for o in obj]
elif type(obj) is tuple:
return {'_tuple': [self.simplify(o, base_type) for o in obj]}
elif type(obj) is dict:
# we want to support storable objects as keys so we need to wrap
# dicts with care and store them using tuples
simple = [
key for key in obj.keys()
if type(key) is str or type(key) is int
]
if len(simple) < len(obj):
# other keys than int or str
result = {
'_dict': [
self.simplify(tuple([key, o]))
for key, o in obj.items()
if key not in self.excluded_keys
]
}
else:
# simple enough, do it the old way
# FASTER VERSION NORMALLY
result = {
key: self.simplify(o)
for key, o in obj.items() if key not in self.excluded_keys
}
# SLOWER VERSION FOR DEBUGGING
# result = {}
# for key, o in obj.items():
# logger.debug("Making dict entry of " + str(key) + " : "
# + str(o))
# if key not in self.excluded_keys:
# result[key] = self.simplify(o)
# else:
# logger.debug("EXCLUDED")
return result
elif type(obj) is slice:
return {'_slice': [obj.start, obj.stop, obj.step]}
else:
oo = obj
return oo