def test_create_all_calculations_none(self):
def creator_function(x, y):
if x > 1:
return None
return {"a": 2 * x, "b": y + 1}
all_calculation_kwargs, all_queues, every_parameter_combination = create_all_calculations(
creator_function, x=[1, 2], y=[3, 4]
)
all_calculation_kwargs = list(all_calculation_kwargs)
all_queues = list(all_queues)
every_parameter_combination = list(every_parameter_combination)
self.assertEqual(len(all_calculation_kwargs), 4)
self.assertEqual(len(all_queues), 4)
self.assertEqual(len(every_parameter_combination), 4)
self.assertIn({"a": 2, "b": 4}, all_calculation_kwargs)
self.assertIn({"a": 2, "b": 5}, all_calculation_kwargs)
self.assertNotIn({"a": 4, "b": 4}, all_calculation_kwargs)
self.assertNotIn({"a": 4, "b": 5}, all_calculation_kwargs)
for combination in [{"x": 1, "y": 3}, {"x": 1, "y": 4}, {"x": 2, "y": 3}, {"x": 2, "y": 4}]:
index = every_parameter_combination.index(combination)
x = combination["x"]
y = combination["y"]
if x == 1:
self.assertEqual(all_calculation_kwargs[index], {"a": 2 * x, "b": y + 1})
else:
self.assertEqual(all_calculation_kwargs[index], None)
def test_create_all_calculations_queue(self):
def creator_function(x, y, queue):
return {"a": 2 * x, "b": y + 1, "queue": queue}
all_calculation_kwargs, all_queues, every_parameter_combination = create_all_calculations(
creator_function, x=[1, 2], y=[3, 4]
)
all_calculation_kwargs = list(all_calculation_kwargs)
all_queues = list(all_queues)
every_parameter_combination = list(every_parameter_combination)
self.assertEqual(len(all_calculation_kwargs), 4)
self.assertEqual(len(all_queues), 4)
self.assertEqual(len(every_parameter_combination), 4)
self.assertIn({"x": 1, "y": 3}, every_parameter_combination)
self.assertIn({"x": 1, "y": 4}, every_parameter_combination)
self.assertIn({"x": 2, "y": 3}, every_parameter_combination)
self.assertIn({"x": 2, "y": 4}, every_parameter_combination)
for combination in [{"x": 1, "y": 3}, {"x": 1, "y": 4}, {"x": 2, "y": 3}, {"x": 2, "y": 4}]:
index = every_parameter_combination.index(combination)
x = combination["x"]
y = combination["y"]
self.assertEqual(all_calculation_kwargs[index], {"a": 2 * x, "b": y + 1, "queue": all_queues[index]})
def process_parameter_space(self, kwargs_creator_function, **parameter_lists):
"""
Create a list of calculations by combining all parameters with all parameters you provide and
feeding the tuple into the parameter_creator_function.
If the kwargs_creator_function has a parameter named queue, the function feeds the corresponding
created queue into the parameter_creator_function.
The parameter_creator_function must return a dictionary for every combination of parameters it gets,
which will be used to construct a process out of it.
See ipython_handler_basf2/ipython_handler for an example.
Please note that a list of calculations acts the same as a single calculation you would get from
the process function. You can handle 10 calculations the same way you would handle a single one.
The kwargs_creator_function can transform the incoming parameters into different ones. To make this
more clear, the resulting dictionary created by the kwargs_creator_function is called kwargs.
These are the ones, that will be used to create a calculation process, so they must be compatible to the
calculation you chose (namely compatible with the append function of the _calculation_type).
Arguments
---------
kwargs_creator_function: A function with as many input parameters as parameters you provide.
If the function has an additional queue parameter it is fed with the corresponding queue for this calculation.
parameter_lists: As many lists as you want. Every list is one parameter. If you do not want a
specific parameter constellation to occur, you can return None in your parameter_creator_function for
this combination.
Usage
-----
def kwargs_creator_function(par_1, par_2, par_3, queue):
kwargs = {... f(par_1) ... g(par_2) ... h(par_3)}
queue.put(..., ...)
return kwargs
calculations = handler.process_parameter_space(kwargs_creator_function,
par_1=[1, 2, 3], par_2=["x", "y", "z"], par_3=[3, 4, 5])
The calculations will be created with the kwargs arguments.
"""
all_kwargs, all_queues, all_parameters = calculation_list.create_all_calculations(kwargs_creator_function,
**parameter_lists)
calculations = self._calculation_type()
for kwargs, q, parameters in zip(all_kwargs, all_queues, all_parameters):
calculations.append(result_queue=q, log_file_name=self.next_log_file_name(),
parameters=parameters, **kwargs)
return calculations
def test_create_all_calculations_none(self):
def creator_function(x, y):
if x > 1:
return None
return {"a": 2 * x, "b": y + 1}
all_calculation_kwargs, all_queues, every_parameter_combination = create_all_calculations(
creator_function, x=[1, 2], y=[3, 4])
all_calculation_kwargs = list(all_calculation_kwargs)
all_queues = list(all_queues)
every_parameter_combination = list(every_parameter_combination)
self.assertEqual(len(all_calculation_kwargs), 4)
self.assertEqual(len(all_queues), 4)
self.assertEqual(len(every_parameter_combination), 4)
self.assertIn({"a": 2, "b": 4}, all_calculation_kwargs)
self.assertIn({"a": 2, "b": 5}, all_calculation_kwargs)
self.assertNotIn({"a": 4, "b": 4}, all_calculation_kwargs)
self.assertNotIn({"a": 4, "b": 5}, all_calculation_kwargs)
for combination in [{
"x": 1,
"y": 3
}, {
"x": 1,
"y": 4
}, {
"x": 2,
"y": 3
}, {
"x": 2,
"y": 4
}]:
index = every_parameter_combination.index(combination)
x = combination["x"]
y = combination["y"]
if x == 1:
self.assertEqual(all_calculation_kwargs[index], {
"a": 2 * x,
"b": y + 1
})
else:
self.assertEqual(all_calculation_kwargs[index], None)
def test_create_all_calculations_queue(self):
def creator_function(x, y, queue):
return {"a": 2 * x, "b": y + 1, "queue": queue}
all_calculation_kwargs, all_queues, every_parameter_combination = create_all_calculations(
creator_function, x=[1, 2], y=[3, 4])
all_calculation_kwargs = list(all_calculation_kwargs)
all_queues = list(all_queues)
every_parameter_combination = list(every_parameter_combination)
self.assertEqual(len(all_calculation_kwargs), 4)
self.assertEqual(len(all_queues), 4)
self.assertEqual(len(every_parameter_combination), 4)
self.assertIn({"x": 1, "y": 3}, every_parameter_combination)
self.assertIn({"x": 1, "y": 4}, every_parameter_combination)
self.assertIn({"x": 2, "y": 3}, every_parameter_combination)
self.assertIn({"x": 2, "y": 4}, every_parameter_combination)
for combination in [{
"x": 1,
"y": 3
}, {
"x": 1,
"y": 4
}, {
"x": 2,
"y": 3
}, {
"x": 2,
"y": 4
}]:
index = every_parameter_combination.index(combination)
x = combination["x"]
y = combination["y"]
self.assertEqual(all_calculation_kwargs[index], {
"a": 2 * x,
"b": y + 1,
"queue": all_queues[index]
})
