class TestRunModel(unittest.TestCase): def setUp(self): self.output_test_dir = ".tests/" if os.path.isdir(self.output_test_dir): shutil.rmtree(self.output_test_dir) os.makedirs(self.output_test_dir) self.features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_invalid", "feature_adaptive" ]) self.parameter_list = [["a", 1, None], ["b", 2, None]] self.parameters = Parameters(self.parameter_list) self.runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, features=self.features) def tearDown(self): if os.path.isdir(self.output_test_dir): shutil.rmtree(self.output_test_dir) def test_init(self): RunModel(model=TestingModel1d(), parameters=self.parameters) def test_set_feature(self): self.runmodel.features = Features() self.assertIsInstance(self.runmodel._features, Features) self.assertIsInstance(self.runmodel._parallel.features, Features) def test_set_model(self): self.runmodel = RunModel(TestingModel2d(), None) self.runmodel.model = TestingModel1d() self.assertIsInstance(self.runmodel._model, TestingModel1d) self.assertIsInstance(self.runmodel._parallel.model, TestingModel1d) def test_set_model_none(self): self.runmodel = RunModel(TestingModel2d(), None) self.runmodel.model = None self.assertIsNone(self.runmodel._model) self.assertIsNone(self.runmodel._parallel.model) def test_set_parameter_list(self): runmodel = RunModel(TestingModel2d(), None) runmodel.parameters = self.parameter_list self.assertIsInstance(runmodel.parameters, Parameters) def test_set_parameter_error(self): runmodel = RunModel(TestingModel2d(), None) with self.assertRaises(TypeError): runmodel.parameters = 2 def test_set_model_function(self): self.runmodel = RunModel(TestingModel2d(), None) self.runmodel.model = model_function self.assertIsInstance(self.runmodel.model, Model) self.assertIsInstance(self.runmodel._parallel.model, Model) def test_init_model_function(self): self.runmodel = RunModel(model_function, None) self.assertIsInstance(self.runmodel.model, Model) self.assertIsInstance(self.runmodel._parallel.model, Model) def test_feature_function(self): def feature_function(time, values): return "time", "values" self.runmodel.features = feature_function self.assertIsInstance(self.runmodel.features, Features) time, values = self.runmodel.features.feature_function(None, None) self.assertEqual(time, "time") self.assertEqual(values, "values") self.assertEqual(self.runmodel.features.features_to_run, ["feature_function"]) def test_feature_functions(self): def feature_function(time, values): return "time", "values" def feature_function2(time, values): return "time2", "values2" self.runmodel.features = [feature_function, feature_function2] self.assertIsInstance(self.runmodel.features, Features) time, values = self.runmodel.features.feature_function(None, None) self.assertEqual(time, "time") self.assertEqual(values, "values") time, values = self.runmodel.features.feature_function(None, None) self.assertEqual(time, "time") self.assertEqual(values, "values") time, values = self.runmodel.features.feature_function2(None, None) self.assertEqual(time, "time2") self.assertEqual(values, "values2") time, values = self.runmodel._parallel.features.feature_function( None, None) self.assertEqual(time, "time") self.assertEqual(values, "values") time, values = self.runmodel._parallel.features.feature_function2( None, None) self.assertEqual(time, "time2") self.assertEqual(values, "values2") self.assertEqual(self.runmodel.features.features_to_run, ["feature_function", "feature_function2"]) def test_feature_functions_base(self): def feature_function(time, values): return "time", "values" def feature_function2(time, values): return "time2", "values2" implemented_features = [ "nr_spikes", "time_before_first_spike", "spike_rate", "average_AP_overshoot", "average_AHP_depth", "average_AP_width", "accommodation_index" ] self.runmodel.features = SpikingFeatures( [feature_function, feature_function2]) self.assertIsInstance(self.runmodel.features, SpikingFeatures) time, values = self.runmodel.features.feature_function(None, None) self.assertEqual(time, "time") self.assertEqual(values, "values") time, values = self.runmodel.features.feature_function2(None, None) self.assertEqual(time, "time2") self.assertEqual(values, "values2") self.assertEqual( set(self.runmodel.features.features_to_run), set(["feature_function", "feature_function2"] + implemented_features)) def test_create_model_parameters(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) uncertain_parameters = ["a", "b"] result = self.runmodel.create_model_parameters(nodes, uncertain_parameters) self.assertEqual(result, [{ "a": 0, "b": 1 }, { "a": 1, "b": 2 }, { "a": 2, "b": 3 }]) def test_create_model_parameters_one(self): nodes = np.array([0, 1, 2]) uncertain_parameters = ["a"] result = self.runmodel.create_model_parameters(nodes, uncertain_parameters) self.assertEqual(result, [{ "a": 0, "b": 2 }, { "a": 1, "b": 2 }, { "a": 2, "b": 2 }]) def test_evaluate_nodes_sequential_model_0d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_invalid" ]) self.runmodel = RunModel(model=TestingModel0d(), parameters=self.parameters, features=features, CPUs=1) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel0d", "feature_invalid" ])) def test_evaluate_nodes_parallel_model_0d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_invalid" ]) self.runmodel = RunModel(model=TestingModel0d(), parameters=self.parameters, features=features, CPUs=3) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel0d", "feature_invalid" ])) def test_evaluate_nodes_sequential_model_1d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) self.runmodel.CPUs = 1 results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel1d", "feature_invalid", "feature_adaptive" ])) def test_evaluate_nodes_parallel_model_1d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) self.runmodel.CPUs = 3 results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel1d", "feature_invalid", "feature_adaptive" ])) def test_evaluate_nodes_sequential_model_2d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_invalid" ]) self.runmodel = RunModel(model=TestingModel2d(), parameters=self.parameters, features=features, CPUs=1) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel2d", "feature_invalid" ])) def test_evaluate_nodes_parallel_model_2d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_invalid" ]) self.runmodel = RunModel(model=TestingModel2d(), parameters=self.parameters, features=features, CPUs=3) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel2d", "feature_invalid" ])) def test_evaluate_nodes_not_supress_graphics(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) self.runmodel.model.suppress_graphics = False self.runmodel.evaluate_nodes(nodes, ["a", "b"]) def test_evaluate_nodes_supress_graphics(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) self.runmodel.model.suppress_graphics = True self.runmodel.evaluate_nodes(nodes, ["a", "b"]) def test_results_to_data_model_1d_all_features(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures( features_to_run=["feature0d", "feature1d", "feature2d"]) self.runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, features=features) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) data = self.runmodel.results_to_data(results) features = data.keys() features.sort() self.assertEqual( features, ["TestingModel1d", "feature0d", "feature1d", "feature2d"]) self.assert_testingmodel1d(data) self.assert_feature_0d(data) self.assert_feature_1d(data) self.assert_feature_2d(data) def test_results_to_data_model_1d_feature_invalid(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures(features_to_run=["feature_invalid"]) self.runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, features=features) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) data = self.runmodel.results_to_data(results) self.assertIn("feature_invalid", data) self.assertTrue(np.isnan(data["feature_invalid"]["time"])) self.assertTrue(np.all(np.isnan(data["feature_invalid"].evaluations))) def test_results_to_data_model_1d_features_all_adaptive(self): features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_adaptive" ], adaptive="feature_adaptive") self.runmodel = RunModel(model=TestingModelAdaptive(), parameters=self.parameters, features=features) nodes = np.array([[0, 1, 2], [1, 2, 3]]) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) data = self.runmodel.results_to_data(results) features = data.keys() features.sort() self.assertEqual(features, [ "TestingModelAdaptive", "feature0d", "feature1d", "feature2d", "feature_adaptive" ]) self.assertIn("TestingModelAdaptive", data) self.assertTrue( np.array_equal(data["TestingModelAdaptive"]["time"], np.arange(0, 15))) self.assertTrue( np.allclose(data["TestingModelAdaptive"].evaluations[0], np.arange(0, 15) + 1)) self.assertTrue( np.allclose(data["TestingModelAdaptive"].evaluations[1], np.arange(0, 15) + 3)) self.assertTrue( np.allclose(data["TestingModelAdaptive"].evaluations[2], np.arange(0, 15) + 5)) self.assertTrue( np.array_equal(data["feature_adaptive"]["time"], np.arange(0, 15))) self.assertTrue( np.allclose(data["feature_adaptive"].evaluations[0], np.arange(0, 15) + 1)) self.assertTrue( np.allclose(data["feature_adaptive"].evaluations[1], np.arange(0, 15) + 3)) self.assertTrue( np.allclose(data["feature_adaptive"].evaluations[2], np.arange(0, 15) + 5)) self.assert_feature_0d(data) self.assert_feature_1d(data) self.assert_feature_2d(data) def test_results_to_data_feature_0d(self): features = TestingFeatures(features_to_run=[ "feature0d", ], adaptive="feature0d") self.runmodel = RunModel(model=TestingModelAdaptive(), parameters=self.parameters, features=features) results = [{ "feature0d": { "values": 1, "time": np.nan } }, { "feature0d": { "values": 1, "time": np.nan } }, { "feature0d": { "values": 1, "time": np.nan } }] data = self.runmodel.results_to_data(results) self.assert_feature_0d(data) def test_results_to_data_no_time(self): features = TestingFeatures(features_to_run=["feature_adaptive"], adaptive="feature_adaptive") self.runmodel = RunModel(model=TestingModelAdaptive(), parameters=self.parameters, features=features) nodes = np.array([[0, 1, 2], [1, 2, 3]]) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) # Remove time from feature_adaptive results for result in results: result["feature_adaptive"]["time"] = np.nan data = self.runmodel.results_to_data(results) features = data.keys() features.sort() self.assertEqual(features, ["TestingModelAdaptive", "feature_adaptive"]) self.assertIn("TestingModelAdaptive", data) self.assertTrue( np.array_equal(data["TestingModelAdaptive"]["time"], np.arange(0, 15))) self.assertTrue( np.allclose(data["TestingModelAdaptive"].evaluations[0], np.arange(0, 15) + 1)) self.assertTrue( np.allclose(data["TestingModelAdaptive"].evaluations[1], np.arange(0, 15) + 3)) self.assertTrue( np.allclose(data["TestingModelAdaptive"].evaluations[2], np.arange(0, 15) + 5)) self.assertTrue( np.array_equal(data["feature_adaptive"]["time"], np.arange(0, 15))) self.assertTrue( np.allclose(data["feature_adaptive"].evaluations[0], np.arange(0, 15) + 1)) self.assertTrue( np.allclose(data["feature_adaptive"].evaluations[1], np.arange(0, 15) + 3)) self.assertTrue( np.allclose(data["feature_adaptive"].evaluations[2], np.arange(0, 15) + 5)) def test_results_to_data_no_time_error(self): features = TestingFeatures(features_to_run=["feature_adaptive"], adaptive="feature_adaptive") self.runmodel = RunModel(model=TestingModelAdaptive(), parameters=self.parameters, features=features) nodes = np.array([[0, 1, 2], [1, 2, 3]]) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) # Remove time from feature_adaptive and model results for result in results: result["feature_adaptive"]["time"] = np.nan result["TestingModelAdaptive"]["time"] = np.nan with self.assertRaises(ValueError): self.runmodel.results_to_data(results) # def test_results_to_dataAdaptiveError(self): # self.runmodel = RunModel(TestingModelAdaptive(adaptive=True), # features=TestingFeatures(), # suppress_model_output=True) # # # nodes = np.array([[0, 1, 2], [1, 2, 3]]) # self.runmodel.data.uncertain_parameters = ["a", "b"] # # # results = self.runmodel.evaluate_nodes(nodes) # self.runmodel.results_to_data(results) # # self.assertEqual(set(self.runmodel.data.U.keys()), # set(["feature0d", "feature1d", "feature2d", # "TestingModelAdaptive", "feature_invalid"])) # # self.assertEqual(set(self.runmodel.data.t.keys()), # set(["feature0d", "feature1d", "feature2d", # "TestingModelAdaptive", "feature_invalid"])) # # self.assertEqual(set(self.runmodel.data.feature_list), # set(["feature0d", "feature1d", "feature2d", # "TestingModelAdaptive", "feature_invalid"])) # # self.assertIn("TestingModelAdaptive", self.runmodel.data.U.keys()) # self.assertTrue(np.array_equal(self.runmodel.data.t["TestingModelAdaptive"], # np.arange(0, 10))) # self.assertTrue(np.allclose(self.runmodel.data.U["TestingModelAdaptive"][0], # np.arange(0, 10) + 1)) # self.assertTrue(np.allclose(self.runmodel.data.U["TestingModelAdaptive"][1], # np.arange(0, 10) + 3)) # self.assertTrue(np.allclose(self.runmodel.data.U["TestingModelAdaptive"][2], # np.arange(0, 10) + 5)) # # self.assert_feature_0d(self.runmodel.data) # self.assert_feature_1d(self.runmodel.data) # self.assert_feature_2d(self.runmodel.data) # self.assert_feature_invalid(self.runmodel.data) def assert_feature_0d(self, data): self.assertIn("feature0d", data) self.assertTrue(np.isnan(data["feature0d"]["time"])) self.assertTrue( np.array_equal(data["feature0d"].evaluations, [1, 1, 1])) self.assertEqual(data["feature0d"]["labels"], ["feature0d"]) def assert_feature_1d(self, data): self.assertIn("feature1d", data) self.assertTrue( np.array_equal(data["feature1d"]["time"], np.arange(0, 10))) self.assertTrue( np.array_equal(data["feature1d"].evaluations[0], np.arange(0, 10))) self.assertTrue( np.array_equal(data["feature1d"].evaluations[1], np.arange(0, 10))) self.assertTrue( np.array_equal(data["feature1d"].evaluations[2], np.arange(0, 10))) self.assertEqual(data["feature1d"]["labels"], ["feature1d x", "feature1d y"]) def assert_feature_2d(self, data): self.assertIn("feature2d", data) self.assertTrue( np.array_equal(data["feature2d"]["time"], np.arange(0, 10))) self.assertTrue( np.array_equal(data["feature2d"].evaluations[0], np.array([np.arange(0, 10), np.arange(0, 10)]))) self.assertTrue( np.array_equal(data["feature2d"].evaluations[1], np.array([np.arange(0, 10), np.arange(0, 10)]))) self.assertTrue( np.array_equal(data["feature2d"].evaluations[2], np.array([np.arange(0, 10), np.arange(0, 10)]))) self.assertEqual(data["feature2d"]["labels"], ["feature2d x", "feature2d y", "feature2d z"]) def assert_testingmodel1d(self, data): self.assertIn("TestingModel1d", data) self.assertTrue( np.array_equal(data["TestingModel1d"]["time"], np.arange(0, 10))) self.assertTrue( np.array_equal(data["TestingModel1d"].evaluations[0], np.arange(0, 10) + 1)) self.assertTrue( np.array_equal(data["TestingModel1d"].evaluations[1], np.arange(0, 10) + 3)) self.assertTrue( np.array_equal(data["TestingModel1d"].evaluations[2], np.arange(0, 10) + 5)) self.assertEqual(data["TestingModel1d"]["labels"], ["x", "y"]) # def assert_feature_invalid(self, data): # self.assertIn("feature_invalid", data.U.keys()) # self.assertTrue(np.isnan(data.t["feature_invalid"])) # self.assertTrue(np.isnan(data.U["feature_invalid"][0])) # self.assertTrue(np.isnan(data.U["feature_invalid"][1])) # self.assertTrue(np.isnan(data.U["feature_invalid"][2])) def test_is_adaptive_false(self): results = [{ "TestingModel1d": { "values": np.arange(0, 10) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 10) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }, { "TestingModel1d": { "values": np.arange(0, 10) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 10) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }, { "TestingModel1d": { "values": np.arange(0, 10) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 10) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }] self.assertFalse(self.runmodel.is_adaptive(results, "feature2d")) self.assertFalse(self.runmodel.is_adaptive(results, "feature1d")) self.assertFalse(self.runmodel.is_adaptive(results, "TestingModel1d")) def test_is_adaptive_true(self): features = TestingFeatures( features_to_run=["feature0d", "feature1d", "feature2d"]) self.runmodel = RunModel(model=TestingModelAdaptive(), parameters=self.parameters, features=features) results = [{ "TestingModelAdaptive": { "values": np.arange(0, 10) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 10) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }, { "TestingModelAdaptive": { "values": np.arange(0, 15) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 10) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }, { "TestingModelAdaptive": { "values": np.arange(0, 10) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 15) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }] self.assertFalse(self.runmodel.is_adaptive(results, "feature2d")) self.assertTrue( self.runmodel.is_adaptive(results, "TestingModelAdaptive")) self.assertTrue(self.runmodel.is_adaptive(results, "feature1d")) def test_apply_interpolation(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) self.runmodel.model.adaptive = True results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) ts = [] interpolation = [] for solved in results: ts.append(solved["TestingModel1d"]["time"]) interpolation.append(solved["TestingModel1d"]["interpolation"]) self.assertTrue(np.array_equal(ts[0], ts[1])) self.assertTrue(np.array_equal(ts[1], ts[2])) self.assertIsInstance(interpolation[0], scipy.interpolate.fitpack2.UnivariateSpline) self.assertIsInstance(interpolation[1], scipy.interpolate.fitpack2.UnivariateSpline) self.assertIsInstance(interpolation[2], scipy.interpolate.fitpack2.UnivariateSpline) time, interpolated_solves = self.runmodel.apply_interpolation( ts, interpolation) self.assertTrue(np.array_equal(time, np.arange(0, 10))) self.assertTrue( np.allclose(interpolated_solves[0], np.arange(0, 10) + 1)) self.assertTrue( np.allclose(interpolated_solves[1], np.arange(0, 10) + 3.)) self.assertTrue( np.allclose(interpolated_solves[2], np.arange(0, 10) + 5.)) ts[1] = np.arange(0, 20) time, interpolated_solves = self.runmodel.apply_interpolation( ts, interpolation) self.assertTrue(np.array_equal(time, np.arange(0, 20))) self.assertTrue( np.allclose(interpolated_solves[0], np.arange(0, 20) + 1)) self.assertTrue( np.allclose(interpolated_solves[1], np.arange(0, 20) + 3.)) self.assertTrue( np.allclose(interpolated_solves[2], np.arange(0, 20) + 5.)) def test_run_two_uncertain_parameters(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures( features_to_run=["feature0d", "feature1d", "feature2d"]) self.runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, features=features, CPUs=1) uncertain_parameters = ["a", "b"] data = self.runmodel.run(nodes, uncertain_parameters) features = data.keys() features.sort() self.assertEqual( features, ["TestingModel1d", "feature0d", "feature1d", "feature2d"]) self.assert_testingmodel1d(data) self.assert_feature_0d(data) self.assert_feature_1d(data) self.assert_feature_2d(data) def test_run_one_uncertain_parameter(self): nodes = np.array([0, 1, 2]) self.runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, features=None, CPUs=1) uncertain_parameters = ["a"] data = self.runmodel.run(nodes, uncertain_parameters) self.assertIn("TestingModel1d", data) self.assertTrue( np.array_equal(data["TestingModel1d"]["time"], np.arange(0, 10))) self.assertTrue( np.array_equal(data["TestingModel1d"].evaluations[0], np.arange(0, 10) + 2)) self.assertTrue( np.array_equal(data["TestingModel1d"].evaluations[1], np.arange(0, 10) + 3)) self.assertTrue( np.array_equal(data["TestingModel1d"].evaluations[2], np.arange(0, 10) + 4)) def test_run_neuron_model(self): path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "models/interneuron_modelDB/") model = NeuronModel(path=path, adaptive=True) self.runmodel = RunModel(model=model, parameters=self.parameters, CPUs=1) uncertain_parameters = ["cap", "Rm"] nodes = np.array([[1.0, 1.1, 1.2], [21900, 22000, 22100]]) self.runmodel.run(nodes, uncertain_parameters) def test_regularize_nan_results(self): results = [{ "a": { "values": np.full(3, np.nan), "time": np.full(3, np.nan) } }, { "a": { "values": np.full((3, 3, 3), 2), "time": np.full((3, 3, 3), 2) } }, { "a": { "values": np.full(3, np.nan), "time": np.full(3, np.nan) } }] new_results = self.runmodel.regularize_nan_results(results) correct_results = [{ "a": { "values": np.full((3, 3, 3), np.nan), "time": np.full((3, 3, 3), np.nan) } }, { "a": { "values": np.full((3, 3, 3), 2), "time": np.full((3, 3, 3), 2) } }, { "a": { "values": np.full((3, 3, 3), np.nan), "time": np.full((3, 3, 3), np.nan) } }] self.assertEqual(correct_results[0]["a"]["values"].shape, new_results[0]["a"]["values"].shape) self.assertEqual(correct_results[1]["a"]["values"].shape, new_results[1]["a"]["values"].shape) self.assertEqual(correct_results[2]["a"]["values"].shape, new_results[2]["a"]["values"].shape) self.assertEqual(correct_results[0]["a"]["time"].shape, new_results[0]["a"]["time"].shape) self.assertEqual(correct_results[1]["a"]["time"].shape, new_results[1]["a"]["time"].shape) self.assertEqual(correct_results[2]["a"]["time"].shape, new_results[2]["a"]["time"].shape) results = [{ "a": { "values": np.full(3, np.nan), "time": np.nan } }, { "a": { "values": np.full((3, 3, 3), 2), "time": np.nan } }, { "a": { "values": np.full(3, np.nan), "time": np.nan } }] new_results = self.runmodel.regularize_nan_results(results) correct_results = [{ "a": { "values": np.full((3, 3, 3), np.nan), "time": np.nan } }, { "a": { "values": np.full((3, 3, 3), 2), "time": np.nan } }, { "a": { "values": np.full((3, 3, 3), np.nan), "time": np.nan } }] self.assertEqual(correct_results[0]["a"]["values"].shape, new_results[0]["a"]["values"].shape) self.assertEqual(correct_results[1]["a"]["values"].shape, new_results[1]["a"]["values"].shape) self.assertEqual(correct_results[2]["a"]["values"].shape, new_results[2]["a"]["values"].shape) self.assertEqual(np.shape(correct_results[0]["a"]["time"]), np.shape(new_results[0]["a"]["time"])) self.assertEqual(np.shape(correct_results[1]["a"]["time"]), np.shape(new_results[1]["a"]["time"])) self.assertEqual(np.shape(correct_results[2]["a"]["time"]), np.shape(new_results[2]["a"]["time"]))
class TestRunModel(unittest.TestCase): def setUp(self): self.output_test_dir = ".tests/" if os.path.isdir(self.output_test_dir): shutil.rmtree(self.output_test_dir) os.makedirs(self.output_test_dir) self.features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_invalid", "feature_interpolate" ]) self.parameter_list = [["a", 1, None], ["b", 2, None]] self.parameters = Parameters(self.parameter_list) self.runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, features=self.features, logger_level="warning") def tearDown(self): if os.path.isdir(self.output_test_dir): shutil.rmtree(self.output_test_dir) def test_init(self): RunModel(model=TestingModel1d(), parameters=self.parameters, logger_level="error") def test_init_cpus_max(self): runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, logger_level="error", CPUs="max") self.assertEqual(runmodel.CPUs, mp.cpu_count()) def test_init_cpus_int(self): runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, logger_level="error", CPUs=34) self.assertEqual(runmodel.CPUs, 34) def test_init_cpus_none(self): runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, logger_level="error", CPUs=None) self.assertIsNone(runmodel.CPUs) def test_set_feature(self): self.runmodel.features = Features(logger_level="error") self.assertIsInstance(self.runmodel._features, Features) self.assertIsInstance(self.runmodel._parallel.features, Features) def test_set_model(self): self.runmodel = RunModel(TestingModel2d(), None, logger_level="error") self.runmodel.model = TestingModel1d() self.assertIsInstance(self.runmodel._model, TestingModel1d) self.assertIsInstance(self.runmodel._parallel.model, TestingModel1d) def test_set_model_none(self): self.runmodel = RunModel(TestingModel2d(), None, logger_level="error") self.runmodel.model = None self.assertIsNone(self.runmodel._model) self.assertIsNone(self.runmodel._parallel.model) def test_set_parameter_list(self): runmodel = RunModel(TestingModel2d(), None, logger_level="error") runmodel.parameters = self.parameter_list self.assertIsInstance(runmodel.parameters, Parameters) def test_set_parameter_error(self): runmodel = RunModel(TestingModel2d(), None, logger_level="error") with self.assertRaises(TypeError): runmodel.parameters = 2 def test_set_model_function(self): self.runmodel = RunModel(TestingModel2d(), None, logger_level="error") self.runmodel.model = model_function self.assertIsInstance(self.runmodel.model, Model) self.assertIsInstance(self.runmodel._parallel.model, Model) def test_init_model_function(self): self.runmodel = RunModel(model_function, None, logger_level="error") self.assertIsInstance(self.runmodel.model, Model) self.assertIsInstance(self.runmodel._parallel.model, Model) def test_feature_function(self): def feature_function(time, values): return "time", "values" self.runmodel.features = feature_function self.assertIsInstance(self.runmodel.features, Features) time, values = self.runmodel.features.feature_function(None, None) self.assertEqual(time, "time") self.assertEqual(values, "values") self.assertEqual(self.runmodel.features.features_to_run, ["feature_function"]) def test_feature_functions(self): def feature_function(time, values): return "time", "values" def feature_function2(time, values): return "time2", "values2" self.runmodel.features = [feature_function, feature_function2] self.assertIsInstance(self.runmodel.features, Features) time, values = self.runmodel.features.feature_function(None, None) self.assertEqual(time, "time") self.assertEqual(values, "values") time, values = self.runmodel.features.feature_function(None, None) self.assertEqual(time, "time") self.assertEqual(values, "values") time, values = self.runmodel.features.feature_function2(None, None) self.assertEqual(time, "time2") self.assertEqual(values, "values2") time, values = self.runmodel._parallel.features.feature_function( None, None) self.assertEqual(time, "time") self.assertEqual(values, "values") time, values = self.runmodel._parallel.features.feature_function2( None, None) self.assertEqual(time, "time2") self.assertEqual(values, "values2") self.assertEqual(self.runmodel.features.features_to_run, ["feature_function", "feature_function2"]) def test_feature_functions_base(self): def feature_function(time, values): return "time", "values" def feature_function2(time, values): return "time2", "values2" implemented_features = [ "nr_spikes", "time_before_first_spike", "spike_rate", "average_AP_overshoot", "average_AHP_depth", "average_AP_width", "accommodation_index", "average_duration" ] self.runmodel.features = SpikingFeatures( [feature_function, feature_function2], logger_level="error") self.assertIsInstance(self.runmodel.features, SpikingFeatures) time, values = self.runmodel.features.feature_function(None, None) self.assertEqual(time, "time") self.assertEqual(values, "values") time, values = self.runmodel.features.feature_function2(None, None) self.assertEqual(time, "time2") self.assertEqual(values, "values2") self.assertEqual( set(self.runmodel.features.features_to_run), set(["feature_function", "feature_function2"] + implemented_features)) def test_create_model_parameters(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) uncertain_parameters = ["a", "b"] result = self.runmodel.create_model_parameters(nodes, uncertain_parameters) self.assertEqual(result, [{ "a": 0, "b": 1 }, { "a": 1, "b": 2 }, { "a": 2, "b": 3 }]) def test_create_model_parameters_one(self): nodes = np.array([0, 1, 2]) uncertain_parameters = ["a"] result = self.runmodel.create_model_parameters(nodes, uncertain_parameters) self.assertEqual(result, [{ "a": 0, "b": 2 }, { "a": 1, "b": 2 }, { "a": 2, "b": 2 }]) def test_evaluate_nodes_sequential_model_0d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_invalid" ]) self.runmodel = RunModel(model=TestingModel0d(), parameters=self.parameters, features=features, CPUs=1, logger_level="error") results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel0d", "feature_invalid" ])) def test_evaluate_nodes_no_multiprocess_model_0d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_invalid" ]) self.runmodel = RunModel(model=TestingModel0d(), parameters=self.parameters, features=features, CPUs=None, logger_level="error") results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel0d", "feature_invalid" ])) def test_evaluate_nodes_parallel_model_0d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_invalid" ]) self.runmodel = RunModel(model=TestingModel0d(), parameters=self.parameters, features=features, CPUs=3, logger_level="error") results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel0d", "feature_invalid" ])) def test_evaluate_nodes_sequential_model_1d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) self.runmodel.CPUs = 1 results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel1d", "feature_invalid", "feature_interpolate" ])) def test_evaluate_nodes_parallel_model_1d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) self.runmodel.CPUs = 3 results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel1d", "feature_invalid", "feature_interpolate" ])) def test_evaluate_nodes_no_multiproccess_model_1d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) self.runmodel.CPUs = None results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel1d", "feature_invalid", "feature_interpolate" ])) def test_evaluate_nodes_sequential_model_2d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_invalid" ]) self.runmodel = RunModel(model=TestingModel2d(), parameters=self.parameters, features=features, CPUs=1, logger_level="error") results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel2d", "feature_invalid" ])) def test_evaluate_nodes_parallel_model_2d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_invalid" ]) self.runmodel = RunModel(model=TestingModel2d(), parameters=self.parameters, features=features, CPUs=3, logger_level="error") results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel2d", "feature_invalid" ])) def test_evaluate_nodes_no_parallel_model_2d(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_invalid" ]) self.runmodel = RunModel(model=TestingModel2d(), parameters=self.parameters, features=features, CPUs=None, logger_level="error") results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertEqual( set(results[0].keys()), set([ "feature0d", "feature1d", "feature2d", "TestingModel2d", "feature_invalid" ])) def test_evaluate_nodes_not_supress_graphics(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) self.runmodel.model.suppress_graphics = False self.runmodel.evaluate_nodes(nodes, ["a", "b"]) def test_evaluate_nodes_supress_graphics(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) self.runmodel.model.suppress_graphics = True self.runmodel.evaluate_nodes(nodes, ["a", "b"]) def test_results_to_data_model_1d_all_features(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures( features_to_run=["feature0d", "feature1d", "feature2d"]) self.runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, features=features, logger_level="error") results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) data = self.runmodel.results_to_data(results) features = list(data.keys()) features.sort() self.assertEqual( features, ["TestingModel1d", "feature0d", "feature1d", "feature2d"]) self.assert_testingmodel1d(data) self.assert_feature_0d(data) self.assert_feature_1d(data) self.assert_feature_2d(data) def test_results_to_data_model_1d_feature_invalid(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures(features_to_run=["feature_invalid"]) self.runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, features=features, logger_level="error") results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) data = self.runmodel.results_to_data(results) self.assertIn("feature_invalid", data) self.assertTrue(np.isnan(data["feature_invalid"]["time"])) self.assertTrue(np.all(np.isnan(data["feature_invalid"].evaluations))) def test_results_to_data_model_1d_features_all_interpolate(self): features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_interpolate" ], interpolate="feature_interpolate") self.runmodel = RunModel(model=TestingModelAdaptive(), parameters=self.parameters, features=features, logger_level="error") nodes = np.array([[0, 1, 2], [1, 2, 3]]) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) data = self.runmodel.results_to_data(results) features = list(data.keys()) features.sort() self.assertEqual(features, [ "TestingModelAdaptive", "feature0d", "feature1d", "feature2d", "feature_interpolate" ]) self.assertIn("TestingModelAdaptive", data) self.assertTrue( np.array_equal(data["TestingModelAdaptive"]["time"], np.arange(0, 15))) self.assertTrue( np.allclose(data["TestingModelAdaptive"].evaluations[0], np.arange(0, 15) + 1)) self.assertTrue( np.allclose(data["TestingModelAdaptive"].evaluations[1], np.arange(0, 15) + 3)) self.assertTrue( np.allclose(data["TestingModelAdaptive"].evaluations[2], np.arange(0, 15) + 5)) self.assertTrue( np.array_equal(data["feature_interpolate"]["time"], np.arange(0, 15))) self.assertTrue( np.allclose(data["feature_interpolate"].evaluations[0], np.arange(0, 15) + 1)) self.assertTrue( np.allclose(data["feature_interpolate"].evaluations[1], np.arange(0, 15) + 3)) self.assertTrue( np.allclose(data["feature_interpolate"].evaluations[2], np.arange(0, 15) + 5)) self.assert_feature_0d(data) self.assert_feature_1d(data) self.assert_feature_2d(data) def test_results_to_data_model_1d_interpolate_ignore(self): self.runmodel = RunModel(model=TestingModelAdaptive(ignore=True), parameters=self.parameters, logger_level="error") self.runmodel.model.interpolate = False nodes = np.array([[0, 1, 2], [1, 2, 3]]) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) data = self.runmodel.results_to_data(results) self.assertEqual(list(data.keys()), ["TestingModelAdaptive"]) self.assertIn("TestingModelAdaptive", data) self.assertTrue( np.array_equal(data["TestingModelAdaptive"]["time"][0], np.arange(0, 11))) self.assertTrue( np.array_equal(data["TestingModelAdaptive"]["time"][1], np.arange(0, 13))) self.assertTrue( np.array_equal(data["TestingModelAdaptive"]["time"][2], np.arange(0, 15))) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].evaluations[0], np.arange(0, 11)) + 1) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].evaluations[1], np.arange(0, 13) + 3)) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].evaluations[2], np.arange(0, 15) + 5)) def test_results_to_data_model_adaptive_no_interpolate_no_ignore(self): features = TestingFeatures(features_to_run=[ "feature0d", "feature1d", "feature2d", "feature_interpolate" ], interpolate="feature_interpolate") self.runmodel = RunModel(model=TestingModelAdaptive(ignore=False), parameters=self.parameters, features=features, logger_level="error") self.runmodel.model.interpolate = False nodes = np.array([[0, 1, 2], [1, 2, 3]]) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) results[0]["TestingModelAdaptive"]["values"] = [[], [1, 2]] data = self.runmodel.results_to_data(results) self.assertEqual(data.error, ["TestingModelAdaptive"]) self.assertIn("TestingModelAdaptive", data) self.assertEqual(data["TestingModelAdaptive"].evaluations[0], [[], [1, 2]]) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].time[0], np.arange(0, 11))) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].time[1], np.arange(0, 13))) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].time[2], np.arange(0, 15))) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].evaluations[0], np.arange(0, 11)) + 1) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].evaluations[1], np.arange(0, 13) + 3)) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].evaluations[2], np.arange(0, 15) + 5)) self.assert_feature_0d(data) self.assert_feature_1d(data) self.assert_feature_2d(data) self.assertIn("feature_interpolate", data) self.assertTrue( np.array_equal(data["feature_interpolate"]["time"], np.arange(0, 15))) self.assertTrue( np.allclose(data["feature_interpolate"].evaluations[0], np.arange(0, 15) + 1)) self.assertTrue( np.allclose(data["feature_interpolate"].evaluations[1], np.arange(0, 15) + 3)) self.assertTrue( np.allclose(data["feature_interpolate"].evaluations[2], np.arange(0, 15) + 5)) def test_results_to_data_model_1d_spiketrain_ignore(self): self.runmodel = RunModel(model=TestingModelAdaptive(ignore=True), parameters=self.parameters, logger_level="error") self.runmodel.model.interpolate = False nodes = np.array([[0, 1, 2], [1, 2, 3]]) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) results[0]["TestingModelAdaptive"]["values"] = [[], [1, 2]] data = self.runmodel.results_to_data(results) self.assertEqual(list(data.keys()), ["TestingModelAdaptive"]) self.assertIn("TestingModelAdaptive", data) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].time[0], np.arange(0, 11))) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].time[1], np.arange(0, 13))) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].time[2], np.arange(0, 15))) self.assertEqual(data["TestingModelAdaptive"].evaluations[0], [[], [1, 2]]) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].evaluations[0], np.arange(0, 11)) + 1) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].evaluations[1], np.arange(0, 13) + 3)) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].evaluations[2], np.arange(0, 15) + 5)) def test_results_to_data_model_1d_interpolate_ignore_and_interpolate(self): self.runmodel = RunModel(model=TestingModelAdaptive(ignore=True), parameters=self.parameters, logger_level="error") self.runmodel.model.interpolate = True nodes = np.array([[0, 1, 2], [1, 2, 3]]) results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) data = self.runmodel.results_to_data(results) self.assertEqual(list(data.keys()), ["TestingModelAdaptive"]) self.assertIn("TestingModelAdaptive", data) self.assertTrue( np.array_equal(data["TestingModelAdaptive"]["time"][0], np.arange(0, 11))) self.assertTrue( np.array_equal(data["TestingModelAdaptive"]["time"][1], np.arange(0, 13))) self.assertTrue( np.array_equal(data["TestingModelAdaptive"]["time"][2], np.arange(0, 15))) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].evaluations[0], np.arange(0, 11)) + 1) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].evaluations[1], np.arange(0, 13) + 3)) self.assertTrue( np.array_equal(data["TestingModelAdaptive"].evaluations[2], np.arange(0, 15) + 5)) def test_results_to_data_feature_0d(self): features = TestingFeatures(features_to_run=[ "feature0d", ], interpolate="feature0d") self.runmodel = RunModel(model=TestingModelAdaptive(), parameters=self.parameters, features=features, logger_level="error") results = [{ "feature0d": { "values": 1, "time": np.nan } }, { "feature0d": { "values": 1, "time": np.nan } }, { "feature0d": { "values": 1, "time": np.nan } }] data = self.runmodel.results_to_data(results) self.assert_feature_0d(data) # def test_results_to_datainterpolateError(self): # self.runmodel = RunModel(TestingModelAdaptive(interpolate=True), # features=TestingFeatures(), # suppress_model_output=True) # # # nodes = np.array([[0, 1, 2], [1, 2, 3]]) # self.runmodel.data.uncertain_parameters = ["a", "b"] # # # results = self.runmodel.evaluate_nodes(nodes) # self.runmodel.results_to_data(results) # # self.assertEqual(set(self.runmodel.data.U.keys()), # set(["feature0d", "feature1d", "feature2d", # "TestingModelAdaptive", "feature_invalid"])) # # self.assertEqual(set(self.runmodel.data.t.keys()), # set(["feature0d", "feature1d", "feature2d", # "TestingModelAdaptive", "feature_invalid"])) # # self.assertEqual(set(self.runmodel.data.feature_list), # set(["feature0d", "feature1d", "feature2d", # "TestingModelAdaptive", "feature_invalid"])) # # self.assertIn("TestingModelAdaptive", self.runmodel.data.U.keys()) # self.assertTrue(np.array_equal(self.runmodel.data.t["TestingModelAdaptive"], # np.arange(0, 10))) # self.assertTrue(np.allclose(self.runmodel.data.U["TestingModelAdaptive"][0], # np.arange(0, 10) + 1)) # self.assertTrue(np.allclose(self.runmodel.data.U["TestingModelAdaptive"][1], # np.arange(0, 10) + 3)) # self.assertTrue(np.allclose(self.runmodel.data.U["TestingModelAdaptive"][2], # np.arange(0, 10) + 5)) # # self.assert_feature_0d(self.runmodel.data) # self.assert_feature_1d(self.runmodel.data) # self.assert_feature_2d(self.runmodel.data) # self.assert_feature_invalid(self.runmodel.data) def assert_feature_0d(self, data): self.assertIn("feature0d", data) self.assertTrue(np.isnan(data["feature0d"]["time"])) self.assertTrue( np.array_equal(data["feature0d"].evaluations, [1, 1, 1])) self.assertEqual(data["feature0d"]["labels"], ["feature0d"]) def assert_feature_1d(self, data): self.assertIn("feature1d", data) self.assertTrue( np.array_equal(data["feature1d"]["time"], np.arange(0, 10))) self.assertTrue( np.array_equal(data["feature1d"].evaluations[0], np.arange(0, 10))) self.assertTrue( np.array_equal(data["feature1d"].evaluations[1], np.arange(0, 10))) self.assertTrue( np.array_equal(data["feature1d"].evaluations[2], np.arange(0, 10))) self.assertEqual(data["feature1d"]["labels"], ["feature1d x", "feature1d y"]) def assert_feature_2d(self, data): self.assertIn("feature2d", data) self.assertTrue( np.array_equal(data["feature2d"]["time"], np.arange(0, 10))) self.assertTrue( np.array_equal(data["feature2d"].evaluations[0], np.array([np.arange(0, 10), np.arange(0, 10)]))) self.assertTrue( np.array_equal(data["feature2d"].evaluations[1], np.array([np.arange(0, 10), np.arange(0, 10)]))) self.assertTrue( np.array_equal(data["feature2d"].evaluations[2], np.array([np.arange(0, 10), np.arange(0, 10)]))) self.assertEqual(data["feature2d"]["labels"], ["feature2d x", "feature2d y", "feature2d z"]) def assert_testingmodel1d(self, data): self.assertIn("TestingModel1d", data) self.assertTrue( np.array_equal(data["TestingModel1d"]["time"], np.arange(0, 10))) self.assertTrue( np.array_equal(data["TestingModel1d"].evaluations[0], np.arange(0, 10) + 1)) self.assertTrue( np.array_equal(data["TestingModel1d"].evaluations[1], np.arange(0, 10) + 3)) self.assertTrue( np.array_equal(data["TestingModel1d"].evaluations[2], np.arange(0, 10) + 5)) self.assertEqual(data["TestingModel1d"]["labels"], ["x", "y"]) # # def assert_feature_invalid(self, data): # # self.assertIn("feature_invalid", data.U.keys()) # # self.assertTrue(np.isnan(data.t["feature_invalid"])) # # self.assertTrue(np.isnan(data.U["feature_invalid"][0])) # # self.assertTrue(np.isnan(data.U["feature_invalid"][1])) # # self.assertTrue(np.isnan(data.U["feature_invalid"][2])) def test_is_regular_true(self): results = [{ "TestingModel1d": { "values": np.arange(0, 10) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 10) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }, { "TestingModel1d": { "values": np.arange(0, 10) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 10) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }, { "TestingModel1d": { "values": np.arange(0, 10) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 10) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }] self.assertTrue(self.runmodel.is_regular(results, "feature2d")) self.assertTrue(self.runmodel.is_regular(results, "feature1d")) self.assertTrue(self.runmodel.is_regular(results, "TestingModel1d")) def test_is_regular_nested_list(self): results = [{ "test": { "values": [[0, 1], [1, 2], [3, 4]] } }, { "test": { "values": [[0, 1], [1, 2], [3, 4]] } }, { "test": { "values": [[0, 1], [1, 2], [3, 4]] } }] self.assertTrue(self.runmodel.is_regular(results, "test")) def test_is_regular_nested_nan(self): results = [{ "test": { "values": [[0, 1], np.nan, [3, 4]] } }, { "test": { "values": [[0, 1], [1, 2], [3, 4]] } }, { "test": { "values": [[0, 1], [1, 2], [3, 4]] } }] self.assertTrue(self.runmodel.is_regular(results, "test")) def test_is_regular_false(self): features = TestingFeatures( features_to_run=["feature0d", "feature1d", "feature2d"]) self.runmodel = RunModel(model=TestingModelAdaptive(), parameters=self.parameters, features=features, logger_level="error") results = [{ "TestingModelAdaptive": { "values": np.arange(0, 10) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 10) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": np.nan } }, { "TestingModelAdaptive": { "values": np.arange(0, 15) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 10) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }, { "TestingModelAdaptive": { "values": np.arange(0, 10) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 15) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }] self.assertTrue(self.runmodel.is_regular(results, "feature2d")) self.assertFalse( self.runmodel.is_regular(results, "TestingModelAdaptive")) self.assertFalse(self.runmodel.is_regular(results, "feature1d")) def test_is_regular_irregular_evaluation(self): features = TestingFeatures( features_to_run=["feature0d", "feature1d", "feature2d"]) self.runmodel = RunModel(model=TestingModelAdaptive(), parameters=self.parameters, features=features, logger_level="error") results = [{ "TestingModelAdaptive": { "values": [1, [1, 2]] }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 10) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }, { "TestingModelAdaptive": { "values": np.arange(0, 15) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 10) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": None } }, { "TestingModelAdaptive": { "values": np.arange(0, 10) }, "feature2d": { "values": np.array([np.arange(0, 10), np.arange(0, 10)]) }, "feature1d": { "values": np.arange(0, 15) }, "feature0d": { "values": 1 }, "feature_invalid": { "values": np.nan } }] self.assertTrue(self.runmodel.is_regular(results, "feature2d")) self.assertFalse( self.runmodel.is_regular(results, "TestingModelAdaptive")) self.assertFalse(self.runmodel.is_regular(results, "feature1d")) def test_is_regular_nan(self): results = [{ "test": { "values": np.nan } }, { "test": { "values": np.arange(0, 15) } }, { "test": { "values": np.arange(0, 10) } }] self.assertFalse(self.runmodel.is_regular(results, "test")) def test_is_regular_list(self): results = [{ "test": { "values": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] } }, { "test": { "values": np.arange(0, 10) } }, { "test": { "values": np.arange(0, 10) } }] self.assertTrue(self.runmodel.is_regular(results, "test")) def test_is_regular_empty_list(self): results = [{ "test": { "values": [0, [], 2, 3, 4, 5, 6, 7, 8, 9] } }, { "test": { "values": np.arange(0, 10) } }, { "test": { "values": np.arange(0, 10) } }] self.assertFalse(self.runmodel.is_regular(results, "test")) def test_apply_interpolation(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) self.runmodel.model.interpolate = True results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertTrue( np.array_equal(results[0]["TestingModel1d"]["time"], results[1]["TestingModel1d"]["time"])) self.assertTrue( np.array_equal(results[1]["TestingModel1d"]["time"], results[2]["TestingModel1d"]["time"])) self.assertIsInstance(results[0]["TestingModel1d"]["interpolation"], scipy.interpolate.fitpack2.UnivariateSpline) self.assertIsInstance(results[1]["TestingModel1d"]["interpolation"], scipy.interpolate.fitpack2.UnivariateSpline) self.assertIsInstance(results[2]["TestingModel1d"]["interpolation"], scipy.interpolate.fitpack2.UnivariateSpline) time, interpolated_solves = self.runmodel.apply_interpolation( results, "TestingModel1d") self.assertTrue(np.array_equal(time, np.arange(0, 10))) self.assertTrue( np.allclose(interpolated_solves[0], np.arange(0, 10) + 1)) self.assertTrue( np.allclose(interpolated_solves[1], np.arange(0, 10) + 3.)) self.assertTrue( np.allclose(interpolated_solves[2], np.arange(0, 10) + 5.)) results[1]["TestingModel1d"]["time"] = np.arange(0, 20) time, interpolated_solves = self.runmodel.apply_interpolation( results, "TestingModel1d") self.assertTrue(np.array_equal(time, np.arange(0, 20))) self.assertTrue( np.allclose(interpolated_solves[0], np.arange(0, 20) + 1)) self.assertTrue( np.allclose(interpolated_solves[1], np.arange(0, 20) + 3.)) self.assertTrue( np.allclose(interpolated_solves[2], np.arange(0, 20) + 5.)) def test_apply_interpolation_none(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) self.runmodel.model.interpolate = True results = self.runmodel.evaluate_nodes(nodes, ["a", "b"]) self.assertTrue( np.array_equal(results[0]["TestingModel1d"]["time"], results[1]["TestingModel1d"]["time"])) self.assertTrue( np.array_equal(results[1]["TestingModel1d"]["time"], results[2]["TestingModel1d"]["time"])) results[1]["TestingModel1d"]["interpolation"] = None time, interpolated_solves = self.runmodel.apply_interpolation( results, "TestingModel1d") self.assertTrue(np.array_equal(time, np.arange(0, 10))) self.assertTrue( np.allclose(interpolated_solves[0], np.arange(0, 10) + 1)) self.assertTrue(np.isnan(interpolated_solves[1])) self.assertTrue( np.allclose(interpolated_solves[2], np.arange(0, 10) + 5.)) def test_run_two_uncertain_parameters(self): nodes = np.array([[0, 1, 2], [1, 2, 3]]) features = TestingFeatures( features_to_run=["feature0d", "feature1d", "feature2d"]) self.runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, features=features, CPUs=1, logger_level="error") uncertain_parameters = ["a", "b"] data = self.runmodel.run(nodes, uncertain_parameters) features = list(data.keys()) features.sort() self.assertEqual( features, ["TestingModel1d", "feature0d", "feature1d", "feature2d"]) self.assert_testingmodel1d(data) self.assert_feature_0d(data) self.assert_feature_1d(data) self.assert_feature_2d(data) def test_run_one_uncertain_parameter(self): nodes = np.array([0, 1, 2]) self.runmodel = RunModel(model=TestingModel1d(), parameters=self.parameters, features=None, CPUs=1, logger_level="error") uncertain_parameters = ["a"] data = self.runmodel.run(nodes, uncertain_parameters) self.assertIn("TestingModel1d", data) self.assertTrue( np.array_equal(data["TestingModel1d"]["time"], np.arange(0, 10))) self.assertTrue( np.array_equal(data["TestingModel1d"].evaluations[0], np.arange(0, 10) + 2)) self.assertTrue( np.array_equal(data["TestingModel1d"].evaluations[1], np.arange(0, 10) + 3)) self.assertTrue( np.array_equal(data["TestingModel1d"].evaluations[2], np.arange(0, 10) + 4)) def test_regularize_nan_results(self): results = [{ "a": { "values": np.full(3, np.nan), "time": np.full(3, np.nan) } }, { "a": { "values": np.full((3, 3, 3), 2), "time": np.full((3, 3, 3), 2) } }, { "a": { "values": np.full(3, np.nan), "time": np.full(3, np.nan) } }] new_results = self.runmodel.regularize_nan_results(results) correct_results = [{ "a": { "values": np.full((3, 3, 3), np.nan), "time": np.full((3, 3, 3), np.nan) } }, { "a": { "values": np.full((3, 3, 3), 2), "time": np.full((3, 3, 3), 2) } }, { "a": { "values": np.full((3, 3, 3), np.nan), "time": np.full((3, 3, 3), np.nan) } }] self.assertEqual(correct_results[0]["a"]["values"].shape, new_results[0]["a"]["values"].shape) self.assertEqual(correct_results[1]["a"]["values"].shape, new_results[1]["a"]["values"].shape) self.assertEqual(correct_results[2]["a"]["values"].shape, new_results[2]["a"]["values"].shape) self.assertEqual(correct_results[0]["a"]["time"].shape, new_results[0]["a"]["time"].shape) self.assertEqual(correct_results[1]["a"]["time"].shape, new_results[1]["a"]["time"].shape) self.assertEqual(correct_results[2]["a"]["time"].shape, new_results[2]["a"]["time"].shape) results = [{ "a": { "values": np.full(3, np.nan), "time": np.nan } }, { "a": { "values": np.full((3, 3, 3), 2), "time": np.nan } }, { "a": { "values": np.full(3, np.nan), "time": np.nan } }] new_results = self.runmodel.regularize_nan_results(results) correct_results = [{ "a": { "values": np.full((3, 3, 3), np.nan), "time": np.nan } }, { "a": { "values": np.full((3, 3, 3), 2), "time": np.nan } }, { "a": { "values": np.full((3, 3, 3), np.nan), "time": np.nan } }] self.assertEqual(correct_results[0]["a"]["values"].shape, new_results[0]["a"]["values"].shape) self.assertEqual(correct_results[1]["a"]["values"].shape, new_results[1]["a"]["values"].shape) self.assertEqual(correct_results[2]["a"]["values"].shape, new_results[2]["a"]["values"].shape) self.assertEqual(np.shape(correct_results[0]["a"]["time"]), np.shape(new_results[0]["a"]["time"])) self.assertEqual(np.shape(correct_results[1]["a"]["time"]), np.shape(new_results[1]["a"]["time"])) self.assertEqual(np.shape(correct_results[2]["a"]["time"]), np.shape(new_results[2]["a"]["time"]))