def test_partially_delete_stuff(self):
traj = Trajectory(name='TestDelete',
filename=make_temp_file('testpartiallydel.hdf5'))
res = traj.f_add_result('mytest.test', a='b', c='d')
traj.f_store()
self.assertTrue('a' in res)
traj.f_delete_item(res, delete_only=['a'], remove_from_item=True)
self.assertTrue('c' in res)
self.assertTrue('a' not in res)
res['a'] = 'offf'
self.assertTrue('a' in res)
traj.f_load(load_results=3)
self.assertTrue('a' not in res)
self.assertTrue('c' in res)
traj.f_delete_item(res, remove_from_trajectory=True, remove_empty_groups=True)
self.assertTrue('results' not in traj)
self.assertTrue(res not in traj)
def test_store_and_load_large_dictionary(self):
traj = Trajectory(name='Test', filename=make_temp_file('large_dict.hdf5'))
large_dict = {}
for irun in range(1025):
large_dict['item_%d' % irun] = irun
large_dict2 = {}
for irun in range(33):
large_dict2['item_%d' % irun] = irun
traj.f_add_result('large_dict', large_dict, comment='Huge_dict!')
traj.f_add_result('large_dict2', large_dict2, comment='Not so large dict!')
traj.f_store()
traj_name = traj.v_name
traj2 = Trajectory(filename=make_temp_file('large_dict.hdf5'))
traj2.f_load(name=traj_name, load_all=2)
self.compare_trajectories(traj, traj2)
def test_partial_loading(self):
traj = Trajectory(name='TestPartial', filename=make_temp_file('testpartially.hdf5'))
res = traj.f_add_result('mytest.test', a='b', c='d')
traj.f_store()
traj.f_remove_child('results', recursive=True)
traj.f_update_skeleton()
traj.f_load_item(traj.test, load_only=['a', 'x'])
self.assertTrue('a' in traj.test)
self.assertTrue('c' not in traj.test)
traj.f_remove_child('results', recursive=True)
traj.f_update_skeleton()
load_except= ['c', 'd']
traj.f_load_item(traj.test, load_except=load_except)
self.assertTrue(len(load_except)==2)
self.assertTrue('a' in traj.test)
self.assertTrue('c' not in traj.test)
with self.assertRaises(ValueError):
traj.f_load_item(traj.test, load_except=['x'], load_only=['y'])
def test_storage_service_errors(self):
traj = Trajectory(filename=make_temp_file('testnoservice.hdf5'))
traj_name = traj.v_name
# you cannot store stuff before the trajectory was stored once:
with self.assertRaises(ValueError):
traj.v_storage_service.store('FAKESERVICE', self, trajectory_name = traj.v_name)
traj.f_store()
with self.assertRaises(ValueError):
traj.v_storage_service.store('FAKESERVICE', self, trajectory_name = 'test')
with self.assertRaises(pex.NoSuchServiceError):
traj.v_storage_service.store('FAKESERVICE', self, trajectory_name = traj.v_name)
with self.assertRaises(ValueError):
traj.f_load(name = 'test', index=1)
with self.assertRaises(RuntimeError):
traj.v_storage_service.store('LIST', [('LEAF',None,None,None,None)], trajectory_name = traj.v_name)
with self.assertRaises(ValueError):
traj.f_load(index=9999)
with self.assertRaises(ValueError):
traj.f_load(name='Non-Existising-Traj')
def test_store_items_and_groups(self):
traj = Trajectory(name='testtraj', filename=make_temp_file('teststoreitems.hdf5'))
traj.f_store()
traj.f_add_parameter('group1.test',42, comment= 'TooLong' * pypetconstants.HDF5_STRCOL_MAX_COMMENT_LENGTH)
traj.f_add_result('testres', 42)
traj.group1.f_set_annotations(Test=44)
traj.f_store_items(['test','testres','group1'])
traj2 = Trajectory(name=traj.v_name, add_time=False,
filename=make_temp_file('teststoreitems.hdf5'))
traj2.f_load(load_results=2,load_parameters=2)
traj.f_add_result('Im.stored.along.a.path', 43)
traj.Im.stored.along.v_annotations['wtf'] =4444
traj.res.f_store_child('Im.stored.along.a.path')
traj2.res.f_load_child('Im.stored.along.a.path', load_data=2)
self.compare_trajectories(traj,traj2)
def test_auto_load(self):
traj = Trajectory(name='Test', filename=make_temp_file('autoload.hdf5'))
traj.v_auto_load = True
traj.f_add_result('I.am.$.a.mean.resu', 42, comment='Test')
traj.f_add_derived_parameter('ffa', 42)
traj.f_store()
ffa=traj.f_get('ffa')
ffa.f_unlock()
ffa.f_empty()
self.assertTrue(ffa.f_is_empty())
traj.f_remove_child('results', recursive=True)
# check auto load
val = traj.res.I.am.crun.a.mean.resu
self.assertTrue(val==42)
val = traj.ffa
self.assertTrue(val==42)
with self.assertRaises(Exception):
traj.kdsfdsf
def test_overwrite_stuff(self):
traj = Trajectory(name='Test', filename=make_temp_file('testowrite.hdf5'))
res = traj.f_add_result('mytest.test', a='b', c='d')
traj.f_store()
res['a'] = 333
res['c'] = 123445
traj.f_store_item(res, overwrite='a')
# Should emit a warning
traj.f_store_item(res, overwrite=['a', 'b'])
traj.f_load(load_results=3)
res = traj.test
self.assertTrue(res['a']==333)
self.assertTrue(res['c']=='d')
res['c'] = 123445
traj.f_store_item(res, overwrite=True)
res.f_empty()
traj.f_load(load_results=3)
self.assertTrue(traj.test['c']==123445)
def test_store_load_with_hdf5(self):
traj_name = 'test_%s' % self.__class__.__name__
filename = make_temp_dir(traj_name + '.hdf5')
traj = Trajectory(name=traj_name, dynamic_imports=self.dynamic_imports,
filename = filename, overwrite_file=True)
for res in self.results.values():
traj.f_add_result(res)
traj.f_store()
new_traj = Trajectory(name=traj_name, dynamic_imports=self.dynamic_imports,
filename = filename)
new_traj.f_load(load_data=2)
self.compare_trajectories(traj, new_traj)
def test_store_load_with_hdf5(self):
traj_name = 'test_%s' % self.__class__.__name__
filename = make_temp_dir(traj_name + '.hdf5')
traj = Trajectory(name=traj_name, dynamic_imports=self.dynamic_imports,
filename = filename, overwrite_file=True)
for res in self.results.values():
traj.f_add_result(res)
traj.f_store()
new_traj = Trajectory(name=traj_name, dynamic_imports=self.dynamic_imports,
filename = filename)
new_traj.f_load(load_data=2)
self.compare_trajectories(traj, new_traj)
def test_store_load_with_hdf5_no_data(self):
traj_name = 'test_%s' % self.__class__.__name__
filename = make_temp_dir(traj_name + 'nodata.hdf5')
traj = Trajectory(name=traj_name, dynamic_imports=self.dynamic_imports,
filename = filename, overwrite_file=True)
for param in self.param.values():
param._data = None
traj.f_add_parameter(param)
traj.f_store()
new_traj = Trajectory(name=traj_name, dynamic_imports=self.dynamic_imports,
filename = filename)
new_traj.f_load(load_data=2)
self.compare_trajectories(traj, new_traj)
def test_store_load_with_hdf5_no_data(self):
traj_name = 'test_%s' % self.__class__.__name__
filename = make_temp_dir(traj_name + 'nodata.hdf5')
traj = Trajectory(name=traj_name, dynamic_imports=self.dynamic_imports,
filename = filename, overwrite_file=True)
for param in self.param.values():
param._data = None
traj.f_add_parameter(param)
traj.f_store()
new_traj = Trajectory(name=traj_name, dynamic_imports=self.dynamic_imports,
filename = filename)
new_traj.f_load(load_data=2)
self.compare_trajectories(traj, new_traj)
def test_file_translation(self):
filename = make_temp_dir('to_new_tree.hdf5')
mytraj = Trajectory('SCRATCH', filename=filename)
mytraj.f_add_parameter('Test.Group.Test', 42)
mytraj.f_add_derived_parameter('trajectory.saaaa', 33)
mytraj.f_add_derived_parameter('trajectory.intraj.dpar1', 33)
mytraj.f_add_derived_parameter('run_00000008.inrun.dpar2', 33)
mytraj.f_add_derived_parameter('run_00000001.inrun.dpar3', 35)
mytraj.f_add_result('trajectory.intraj.res1', 33)
mytraj.f_add_result('run_00000008.inrun.res1', 33)
mytraj.f_store()
mytraj.f_migrate(new_name=mytraj.v_name + 'PETER', in_store=True)
mytraj.f_store()
fu = FileUpdater(filename=filename, backup=True)
fu.update_file()
mytraj = Trajectory(name=mytraj.v_name,
add_time=False,
filename=filename)
mytraj.f_load(load_parameters=2,
load_derived_parameters=2,
load_results=2)
for node in mytraj.f_iter_nodes():
self.assertTrue(node.v_name != 'trajectory')
if 'run_' in node.v_full_name:
self.assertTrue('.runs.' in node.v_full_name)
remove_data()
def test_migrations(self):
traj = Trajectory(name='Test', filename=make_temp_file('migrate.hdf5'))
traj.f_add_result('I.am.a.mean.resu', 42, comment='Test')
traj.f_add_derived_parameter('ffa', 42)
traj.f_store()
new_file = make_temp_file('migrate2.hdf5')
traj.f_migrate(new_filename=new_file)
traj.f_store()
new_traj = Trajectory()
new_traj.f_migrate(new_name=traj.v_name, new_filename=new_file, in_store=True)
new_traj.v_auto_load=True
self.assertTrue(new_traj.results.I.am.a.mean.resu == 42)
def test_file_translation(self):
filename = make_temp_dir('to_new_tree.hdf5')
mytraj = Trajectory('SCRATCH', filename=filename)
mytraj.f_add_parameter('Test.Group.Test', 42)
mytraj.f_add_derived_parameter('trajectory.saaaa',33)
mytraj.f_add_derived_parameter('trajectory.intraj.dpar1',33)
mytraj.f_add_derived_parameter('run_00000008.inrun.dpar2',33)
mytraj.f_add_derived_parameter('run_00000001.inrun.dpar3',35)
mytraj.f_add_result('trajectory.intraj.res1',33)
mytraj.f_add_result('run_00000008.inrun.res1',33)
mytraj.f_store()
mytraj.f_migrate(new_name=mytraj.v_name + 'PETER', in_store=True)
mytraj.f_store()
fu=FileUpdater(filename=filename, backup=True)
fu.update_file()
mytraj = Trajectory(name=mytraj.v_name, add_time=False, filename=filename)
mytraj.f_load(load_parameters=2, load_derived_parameters=2, load_results=2)
for node in mytraj.f_iter_nodes():
self.assertTrue(node.v_name != 'trajectory')
if 'run_' in node.v_full_name:
self.assertTrue('.runs.' in node.v_full_name)
remove_data()
def test_wildcard_search(self):
traj = Trajectory(name='Test', filename=make_temp_file('wilcard.hdf5'))
traj.f_add_parameter('expl', 2)
traj.f_explore({'expl':[1,2,3,4]})
traj.f_add_result('wc2test.$.hhh', 333)
traj.f_add_leaf('results.wctest.run_00000000.jjj', 42)
traj.f_add_result('results.wctest.run_00000001.jjj', 43)
traj.v_as_run = 1
self.assertTrue(traj.results.wctest['$'].jjj==43)
self.assertTrue(traj.results.wc2test.crun.hhh==333)
traj.f_store()
traj.f_remove_child('results', recursive=True)
traj.v_auto_load = True
self.assertTrue(traj.results.wctest['$'].jjj==43)
self.assertTrue(traj.results.wc2test.crun.hhh==333)
traj.f_remove_child('results', recursive=True)
traj.v_auto_load = True
self.assertTrue(traj.results.wctest[-2].jjj==43)
self.assertTrue(traj.results.wc2test[-2].hhh==333)
traj.f_remove_child('results', recursive=True)
traj.v_auto_load = True
self.assertTrue(traj.results.wctest[1].jjj==43)
self.assertTrue(traj.results.wc2test[-1].hhh==333)
def test_version_mismatch(self):
traj = Trajectory(name='Test', filename=make_temp_file('testversionmismatch.hdf5'))
traj.f_add_parameter('group1.test',42)
traj.f_add_result('testres', 42)
traj.group1.f_set_annotations(Test=44)
traj._version='0.1a.1'
traj.f_store()
traj2 = Trajectory(name=traj.v_name, add_time=False,
filename=make_temp_file('testversionmismatch.hdf5'))
with self.assertRaises(pex.VersionMismatchError):
traj2.f_load(load_results=2,load_parameters=2)
traj2.f_load(load_results=2,load_parameters=2, force=True)
self.compare_trajectories(traj,traj2)
class AnnotationsTest(unittest.TestCase):
tags = 'unittest', 'annotations'
def setUp(self):
self.filename = make_temp_dir(
os.path.join('experiments', 'tests', 'HDF5', 'annotations.hdf5'))
self.traj = Trajectory(name='Annotations', filename=self.filename)
self.traj.f_add_result('testres', 42)
self.traj.f_add_parameter('testgroup.testparam', 42)
self.make_annotations()
self.add_annotations(self.traj)
pred = lambda x: 'config' not in x.v_full_name
x = len([
node
for node in self.traj.f_iter_nodes(recursive=True, predicate=pred)
])
self.assertTrue(x == 5, '%s != %s' % (str(x), str(5)))
def tearDown(self):
remove_data()
def make_annotations(self):
self.annotations = {}
self.annotations['dict'] = {
'33': 12,
'kkk': [1, 2, 'h'],
3: {
'a': 42.0
}
}
self.annotations['list'] = [self.annotations['dict'], 33]
self.annotations['string'] = 'string'
self.annotations['integer'] = 42
self.annotations['tuple'] = (3, 4, 5)
self.annotations['Numpy_Data'] = np.array(['fff', 'ddd'])
self.annotations[0] = 7777
def add_annotations(self, traj):
funcs = 5
for idx, node in enumerate(
[traj] + [node for node in traj.f_iter_nodes(recursive=True)]):
for name in self.annotations:
anno = self.annotations[name]
if name == 0:
node.f_set_annotations(anno)
node.v_annotations.f_set(anno)
elif idx % funcs == 0:
node.f_set_annotations(**{name: anno})
elif idx % funcs == 1:
node.v_annotations.f_set(**{name: anno})
elif idx % funcs == 2:
node.v_annotations.f_set_single(name, anno)
elif idx % funcs == 3:
setattr(node.v_annotations, name, anno)
elif idx % funcs == 4:
node.v_annotations[name] = anno
def test_annotations_insert(self):
for idx,node in \
enumerate([self.traj] + [node for node in self.traj.f_iter_nodes(recursive=True)]):
for name in self.annotations:
anno = self.annotations[name]
node_anno = node.v_annotations[name]
self.assertTrue(comp.nested_equal(anno, node_anno),
'%s != %s' % (str(anno), str(node_anno)))
def test_pickling(self):
dump = pickle.dumps(self.traj)
del self.traj
self.traj = pickle.loads(dump)
self.test_annotations_insert()
def test_storage_and_loading(self):
self.traj.f_store()
traj_name = self.traj.v_name
del self.traj
self.traj = Trajectory(filename=self.filename)
self.traj.f_load(name=traj_name,
load_parameters=2,
load_derived_parameters=2,
load_results=2,
load_other_data=2)
self.test_annotations_insert()
def test_attribute_deletion(self):
for node in self.traj.f_iter_nodes(recursive=True):
name_list = [name for name in node.v_annotations]
for name in name_list:
delattr(node.v_annotations, name)
self.assertTrue(node.v_annotations.f_is_empty())
def test_item_deletion(self):
for node in self.traj.f_iter_nodes(recursive=True):
name_list = [name for name in node.v_annotations]
for name in name_list:
del node.v_annotations[name]
self.assertTrue(node.v_annotations.f_is_empty())
def test_get_item(self):
for node in self.traj.f_iter_nodes(recursive=True):
for key, val1 in node.v_annotations.f_to_dict().items():
val2 = node.v_annotations[key]
self.assertTrue(comp.nested_equal(val1, val2))
def test_get_item_no_copy(self):
for node in self.traj.f_iter_nodes(recursive=True):
for key, val1 in node.v_annotations.f_to_dict(copy=False).items():
val2 = node.v_annotations[key]
self.assertTrue(comp.nested_equal(val1, val2))
@staticmethod
def dict_to_str(dictionary):
resstr = ''
new_dict = {}
for key, val in dictionary.items():
if key == 0:
key = 'annotation'
new_dict[key] = val
for key in sorted(new_dict.keys()):
resstr += '%s=%s; ' % (key, str(new_dict[key]))
return resstr[:-2]
def test_to_str(self):
dict_str = self.dict_to_str(self.annotations)
for node in self.traj.f_iter_nodes(recursive=True):
ann_str = node.f_ann_to_str()
self.assertTrue(not ann_str.endswith(' ')
or not ann_str.endswith(','))
for name in self.annotations:
if name == 0:
name = 'annotation'
self.assertTrue(name in ann_str)
self.assertEqual(dict_str, ann_str, '%s!=%s' % (dict_str, ann_str))
ann_str = str(node.v_annotations)
self.assertEqual(dict_str, ann_str, '%s!=%s' % (dict_str, ann_str))
def test_single_get_and_getattr_and_setattr(self):
self.traj.f_add_parameter('test2', 42)
self.traj.f_get('test2').v_annotations.test = 4
self.assertTrue(self.traj.f_get('test2').v_annotations.test, 4)
self.assertTrue(self.traj.f_get('test2').v_annotations.f_get(), 4)
def test_get_annotations(self):
key_list = list(self.annotations.keys())
for node in self.traj.f_iter_nodes(recursive=True):
for name in self.annotations:
self.assertTrue(
comp.nested_equal(self.annotations[name],
node.f_get_annotations(name)))
val_list = node.f_get_annotations(*key_list)
for idx, val in enumerate(val_list):
self.assertTrue(
comp.nested_equal(self.annotations[key_list[idx]], val))
def test_f_get_errors(self):
for node in self.traj.f_iter_nodes(recursive=True):
with self.assertRaises(ValueError):
node.v_annotations.f_get()
with self.assertRaises(AttributeError):
node.v_annotations.f_get('gdsdfd')
testparam = self.traj.f_add_parameter('ggg', 343)
with self.assertRaises(AttributeError):
testparam.v_annotations.f_get()
def test_f_set_numbering(self):
int_list = list(range(10))
for node in self.traj.f_iter_nodes(recursive=True):
node.v_annotations.f_set(*int_list)
self.assertEqual(node.v_annotations.f_get(*int_list),
tuple(int_list))
for integer in int_list:
if integer == 0:
name = 'annotation'
else:
name = 'annotation_%d' % integer
self.assertTrue(name in node.v_annotations)
class AnnotationsTest(unittest.TestCase):
def setUp(self):
self.filename = make_temp_file('experiments/tests/HDF5/annotations.hdf5')
self.traj = Trajectory(name='Annotations', filename = self.filename)
self.traj.f_add_result('testres', 42)
self.traj.f_add_parameter('testgroup.testparam', 42)
self.make_annotations()
self.add_annotations(self.traj)
self.assertTrue(len([node for node in self.traj.f_iter_nodes(recursive=True)]) == 5)
def make_annotations(self):
self.annotations={}
self.annotations['dict']={'33':12,'kkk':[1,2,'h'], 3:{'a':42.0}}
self.annotations['list']= [self.annotations['dict'],33]
self.annotations['string'] = 'string'
self.annotations['integer'] = 42
self.annotations['tuple']=(3,4,5)
self.annotations['Numpy_Data'] = np.array(['fff','ddd'])
self.annotations[0] = 7777
def add_annotations(self, traj):
funcs = 5
for idx,node in enumerate(traj.f_iter_nodes(recursive=True)):
for name in self.annotations:
anno = self.annotations[name]
if name == 0:
node.f_set_annotations(anno)
node.v_annotations.f_set(anno)
elif idx % funcs == 0:
node.f_set_annotations(**{name:anno})
elif idx % funcs == 1:
node.v_annotations.f_set(**{name:anno})
elif idx % funcs == 2:
node.v_annotations.f_set_single(name,anno)
elif idx % funcs == 3:
setattr(node.v_annotations,name, anno)
elif idx % funcs == 4:
node.v_annotations[name]=anno
def test_annotations_insert(self):
for node in self.traj.f_iter_nodes(recursive=True):
for name in self.annotations:
anno = self.annotations[name]
node_anno = node.v_annotations[name]
self.assertTrue(comp.nested_equal(anno, node_anno),
'%s != %s' % (str(anno), str(node_anno)))
def test_pickling(self):
dump = pickle.dumps(self.traj)
del self.traj
self.traj = pickle.loads(dump)
self.test_annotations_insert()
def test_storage_and_loading(self):
self.traj.f_store()
traj_name = self.traj.v_name
del self.traj
self.traj = Trajectory(filename=self.filename)
self.traj.f_load(name=traj_name, load_results=2, load_parameters=2, load_derived_parameters=2,
load_other_data=2)
self.test_annotations_insert()
def test_attribute_deletion(self):
for node in self.traj.f_iter_nodes(recursive=True):
name_list=[name for name in node.v_annotations]
for name in name_list:
delattr(node.v_annotations, name)
self.assertTrue(node.v_annotations.f_is_empty())
def test_get_item(self):
for node in self.traj.f_iter_nodes(recursive=True):
for key, val1 in node.v_annotations.f_to_dict().items():
val2 = node.v_annotations[key]
self.assertTrue(comp.nested_equal(val1,val2))
def test_get_item_no_copy(self):
for node in self.traj.f_iter_nodes(recursive=True):
for key, val1 in node.v_annotations.f_to_dict(copy=False).items():
val2 = node.v_annotations[key]
self.assertTrue(comp.nested_equal(val1,val2))
@staticmethod
def dict_to_str(dictionary):
resstr = ''
new_dict={}
for key, val in dictionary.items():
if key == 0:
key = 'annotation'
new_dict[key]=val
for key in sorted(new_dict.keys()):
resstr+='%s=%s; ' % (key,str(new_dict[key]))
return resstr[:-2]
def test_to_str(self):
dict_str = self.dict_to_str(self.annotations)
for node in self.traj.f_iter_nodes(recursive=True):
ann_str = node.f_ann_to_str()
self.assertTrue(not ann_str.endswith(' ') or not ann_str.endswith(','))
for name in self.annotations:
if name==0:
name = 'annotation'
self.assertTrue(name in ann_str)
self.assertEqual(dict_str, ann_str, '%s!=%s' % (dict_str, ann_str))
ann_str = str(node.v_annotations)
self.assertEqual(dict_str, ann_str, '%s!=%s' % (dict_str, ann_str))
def test_single_get_and_getattr_and_setattr(self):
self.traj.f_add_parameter('test2', 42)
self.traj.f_get('test2').v_annotations.test = 4
self.assertTrue(self.traj.f_get('test2').v_annotations.test, 4)
self.assertTrue(self.traj.f_get('test2').v_annotations.f_get(), 4)
def test_get_annotations(self):
key_list = sorted(self.annotations.keys())
for node in self.traj.f_iter_nodes(recursive=True):
for name in self.annotations:
self.assertTrue(comp.nested_equal(self.annotations[name],
node.f_get_annotations(name)))
val_list = node.f_get_annotations(*key_list)
for idx, val in enumerate(val_list):
self.assertTrue(comp.nested_equal(self.annotations[key_list[idx]], val))
def test_f_get_errors(self):
for node in self.traj.f_iter_nodes(recursive=True):
with self.assertRaises(ValueError):
node.v_annotations.f_get()
with self.assertRaises(AttributeError):
node.v_annotations.f_get('gdsdfd')
testparam = self.traj.f_add_parameter('ggg',343)
with self.assertRaises(AttributeError):
testparam.v_annotations.f_get()
def test_f_set_numbering(self):
int_list = range(10)
for node in self.traj.f_iter_nodes(recursive=True):
node.v_annotations.f_set(*int_list)
self.assertEqual(node.v_annotations.f_get(*int_list), tuple(int_list))
for integer in int_list:
if integer == 0:
name = 'annotation'
else:
name = 'annotation_%d' % integer
self.assertTrue(name in node.v_annotations)
def main():
pool = Pool(2)
lock = Manager().Lock()
logging.basicConfig(level=logging.DEBUG)
log_to_stderr()
traj = Trajectory(name='MyTrajectory',filename='../experiments/test.hdf5')
config['multiproc'] = True
#traj.load_trajectory(trajectoryname='MyTrajectory_2013_05_23_14h29m26s')
traj.f_add_parameter('test.testparam', param_type=ParameterSet, **{'Fuechse':1,'Sapiens':1,'Comment':'ladida'})
traj.last.foo = 'bar'
traj.f_add_parameter('Network.Cm')
traj.Parameters.Network.Cm.value= 1.0
traj.Parameters.Network.Cm.unit = 'pF'
print traj.Parameters.Network.Cm()
traj.last.herbert = 4.5
traj.Parameters.test.testparam.Konstantin = 'Konstantin'
traj.f_add_parameter(full_parameter_name='honky', **{'mirta':np.array([[1,2,7],[3,2,17]])})
traj.f_add_parameter('flonky',**{'val' : 10})
param1 = traj.Parameters.test.testparam
param2 = traj.Parameters.honky
param3 = traj.last
print param1()
print param3('val')
exp2_list = range(3)
exp1_list = range(3)
exp3_list = range(3)
explore_dict = { param1.gfn('Sapiens') : exp1_list,
param2.get_fullname('mirta'):exp2_list,
param3.gfn('val') : exp3_list}
cmb_list=[(param3.gfn('val'),param1.gfn('Sapiens'))]
traj.f_add_derived_parameter(full_parameter_name='foo', **{'bar' : -1}).moo = 'zip'
lilma = spsp.lil_matrix((10000,1000))
lilma[0,100] = 555
lilma[9999,999] = 11
traj.f_add_parameter('sparse', mat=lilma, param_type = SparseParameter)
traj.f_explore(ut.cartesian_product,explore_dict,cmb_list)
traj._prepare_experiment()
traj.f_store()
pathname = config['logfolder']
it = ((traj._make_single_run(n),lock, pathname) for n in xrange(len(traj)))
moo = pool.imap(do_stuff, it)
pool.close()
pool.join()
traj.f_add_result('huge_matrices',
mat1 = np.random.rand(100,100,100),
mat2 = np.random.rand(1000,1000))
# Note that the result will not support fast access since it contains more than a single
# data item. Even if there was only `mat1`, because the name is `mat1` instead of `huge_matrices`
# (as the result object itself is called), fast access does not work either.
# Yet, we can access data via natural naming using the names `mat1` and `mat2` e.g.:
val_mat1 = traj.huge_matrices.mat1[10,10,10]
val_mat2 = traj.huge_matrices.mat2[42,13]
print('mat1 contains %f at position [10,10,10]' % val_mat1)
print('mat2 contains %f at position [42,13]' % val_mat2)
# Ok that was enough analysis of the data and should be sufficient for a phd thesis (in economics).
# Let's store our trajectory and subsequently free the space for something completely different.
traj.f_store()
# We free the data:
traj.huge_matrices.f_empty()
# Check if the data was deleted
if traj.huge_matrices.f_is_empty():
print('As promised: Nothing there!')
else:
print('What a disappointing peace of crap this software is!')
# Lucky, it worked.
# Ok we could it add some more stuff to the result object if we want to:
traj.huge_matrices.f_set(monty='Always look on the bright side of life!')
# Next we can store our new string called monty to disk. Since our trajectory was already
traj.f_add_result('huge_matrices',
mat1=np.random.rand(100, 100, 100),
mat2=np.random.rand(1000, 1000))
# Note that the result will not support fast access since it contains more than a single
# data item. Even if there was only `mat1`, because the name is `mat1` instead of `huge_matrices`
# (as the result object itself is called), fast access does not work either.
# Yet, we can access data via natural naming using the names `mat1` and `mat2` e.g.:
val_mat1 = traj.huge_matrices.mat1[10, 10, 10]
val_mat2 = traj.huge_matrices.mat2[42, 13]
print('mat1 contains %f at position [10,10,10]' % val_mat1)
print('mat2 contains %f at position [42,13]' % val_mat2)
# Ok that was enough analysis of the data and should be sufficient for a phd thesis (in economics).
# Let's store our trajectory and subsequently free the space for something completely different.
traj.f_store()
# We free the data:
traj.huge_matrices.f_empty()
# Check if the data was deleted
if traj.huge_matrices.f_is_empty():
print('As promised: Nothing there!')
else:
print('What a disappointing peace of crap this software is!')
# Lucky, it worked.
# Ok we could it add some more stuff to the result object if we want to:
traj.huge_matrices.f_set(monty='Always look on the bright side of life!')
# Next we can store our new string called monty to disk. Since our trajectory was already
