示例#1
0
    def test_rpc_storage_with_simulation(self):
        config = self.createTestPath("local/snake_oil_no_data/snake_oil.ert")

        with RPCServiceContext("ert/server/rpc_storage/simulation_and_storage",
                               config,
                               store_area=True) as server:
            client = ErtRPCClient("localhost", server.port)
            realization_count = 2

            client.prototypeStorage("SNAKEX", {
                "SNAKE_ID": float,
                "SNAKE_RUN": str
            })

            batch_names = ["test_run_0", "test_run_1"]

            for batch_id, batch_name in enumerate(batch_names):
                self.runSimulation(client, realization_count, batch_id,
                                   batch_name)

            for (batch_id,
                 batch_name), iens in product(enumerate(batch_names),
                                              range(realization_count)):
                result = client.getCustomKWResult(batch_name, iens, "SNAKEX")
                self.assertEqual(result["SNAKE_RUN"], "batch_%d" % batch_id)
                snake_id = realization_count * batch_id + iens
                self.assertEqual(result["SNAKE_ID"], snake_id)
示例#2
0
    def test_rpc_storage_with_simulation(self):
        config = self.createTestPath("local/snake_oil_no_data/snake_oil.ert")

        with RPCServiceContext("ert/server/rpc_storage/simulation_and_storage", config, store_area=True) as server:
            client = ErtRPCClient("localhost", server.port)
            realization_count = 2

            client.prototypeStorage("SNAKEX", {"SNAKE_ID": float, "SNAKE_RUN": str})

            batch_names = ["test_run_0", "test_run_1"]

            for batch_id, batch_name in enumerate(batch_names):
                self.runSimulation(client, realization_count, batch_id, batch_name)

            for (batch_id, batch_name), iens in product(enumerate(batch_names), range(realization_count)):
                result = client.getCustomKWResult(batch_name, iens, "SNAKEX")
                self.assertEqual(result["SNAKE_RUN"], "batch_%d" % batch_id)
                snake_id = realization_count * batch_id + iens
                self.assertEqual(result["SNAKE_ID"], snake_id)
示例#3
0
                def clientInteraction():
                    thread_success_state[iens] = False
                    keywords = {"SNAKE_OIL_PARAM": [0.50, iens + 2, 1.750, 0.250, 0.990, 2 + client_count - iens, 1.770, 0.330, 0.550, 0.770]}
                    client = ErtRPCClient("localhost", server.port)
                    client.startSimulationBatch("default", client_count)

                    self.assertTrue(client.isRunning())
                    self.assertTrue(client.isInitializationCaseAvailable())

                    client.addSimulation(target_case_name, 0, 0, iens, keywords)
                    self.assertTrue(realizationIsInitialized(server.ert, target_case_name, iens))

                    while not client.isRealizationFinished(iens):
                        time.sleep(0.5)

                    self.assertTrue(client.didRealizationSucceed(iens))

                    result = client.getCustomKWResult(target_case_name, iens, "SNAKE_OIL_NPV")
                    self.assertTrue("NPV" in result)
                    self.assertTrue("RATING" in result)
                    self.assertEqual(expected_ckw[iens]["RATING"], result["RATING"])
                    self.assertAlmostEqual(expected_ckw[iens]["NPV"], result["NPV"])

                    thread_success_state[iens] = True
示例#4
0
    def test_client_interaction(self):
        target_case_names = ["batch_1", ".batch_1", "batch_1", ".batch_1"]
        kw = [{
            "SNAKE_OIL_PARAM":
            [0.50, 6, 1.750, 0.250, 0.990, 2, 1.770, 0.330, 0.550, 0.770]
        }, {
            "SNAKE_OIL_PARAM":
            [0.51, 7, 1.751, 0.251, 0.991, 3, 1.771, 0.331, 0.551, 0.771]
        }, {
            "SNAKE_OIL_PARAM":
            [0.52, 8, 1.752, 0.252, 0.992, 4, 1.772, 0.332, 0.552, 0.772]
        }, {
            "SNAKE_OIL_PARAM":
            [0.53, 9, 1.753, 0.253, 0.993, 5, 1.773, 0.333, 0.553, 0.773]
        }]

        expected_state_map = {
            "batch_1": [
                RealizationStateEnum.STATE_HAS_DATA,
                RealizationStateEnum.STATE_UNDEFINED,
                RealizationStateEnum.STATE_HAS_DATA
            ],
            ".batch_1": [
                RealizationStateEnum.STATE_UNDEFINED,
                RealizationStateEnum.STATE_HAS_DATA,
                RealizationStateEnum.STATE_UNDEFINED,
                RealizationStateEnum.STATE_HAS_DATA
            ]
        }

        expected_custom_kw = [{
            'RATING': 'EXCELLENT',
            'NPV': 125692.534209
        }, {
            'RATING': 'AVERAGE',
            'NPV': 87423.5773042
        }, {
            'RATING': 'GOOD',
            'NPV': 113243.319848
        }, {
            'RATING': 'AVERAGE',
            'NPV': 91781.8557083
        }]

        with RPCServiceContext("ert/server/rpc/client", self.config) as server:
            client = ErtRPCClient("localhost", server.port)
            self.assertEqual(Version.currentVersion().versionTuple(),
                             client.ertVersion())
            realization_count = len(target_case_names)

            # with self.assertRaises(UserWarning):
            #     client.startSimulationBatch("default", realization_count)
            #
            # initializeCase(server.ert, "default", 1)

            client.startSimulationBatch("default", realization_count)

            self.assertTrue(server.isInitializationCaseAvailable())
            self.assertTrue(server.isRunning())

            for iens in range(realization_count):
                client.addSimulation(target_case_names[iens],
                                     geo_id=0,
                                     pert_id=0,
                                     sim_id=iens,
                                     keywords=kw[iens])
                self.assertTrue(
                    realizationIsInitialized(server.ert,
                                             target_case_names[iens], iens))

            while client.isRunning():
                time.sleep(1)

            for case in expected_state_map:
                fs = server.ert.getEnkfFsManager().getFileSystem(case)
                state_map = fs.getStateMap()
                states = expected_state_map[case]

                for index, state in enumerate(states):
                    self.assertEqual(state, state_map[index])

            time_map = client.getTimeMap("batch_1")
            self.assertEqual(datetime.datetime(2010, 1, 1), time_map[0])
            self.assertEqual(datetime.datetime(2015, 6, 13), time_map[199])

            with self.assertRaises(KeyError):
                client.getGenDataResult(target_case_names[0], 0, 199,
                                        "UNKNOWN_KEYWORD")

            for iens, case in enumerate(target_case_names):
                self.assertTrue(client.isRealizationFinished(iens))
                self.assertTrue(client.didRealizationSucceed(iens))
                self.assertFalse(client.didRealizationFail(iens))

                self.assertTrue(client.isCustomKWKey("SNAKE_OIL_NPV"))
                self.assertFalse(client.isGenDataKey("SNAKE_OIL_NPV"))
                self.assertTrue(client.isGenDataKey("SNAKE_OIL_OPR_DIFF"))

                result = client.getGenDataResult(case, iens, 199,
                                                 "SNAKE_OIL_OPR_DIFF")
                self.assertEqual(len(result), 2000)

                result = client.getCustomKWResult(case, iens, "SNAKE_OIL_NPV")
                self.assertTrue("NPV" in result)
                self.assertTrue("RATING" in result)
                self.assertEqual(expected_custom_kw[iens]["RATING"],
                                 result["RATING"])
                self.assertAlmostEqual(expected_custom_kw[iens]["NPV"],
                                       result["NPV"])
示例#5
0
                def clientInteraction():
                    thread_success_state[iens] = False
                    keywords = {
                        "SNAKE_OIL_PARAM": [
                            0.50, iens + 2, 1.750, 0.250, 0.990,
                            2 + client_count - iens, 1.770, 0.330, 0.550, 0.770
                        ]
                    }
                    client = ErtRPCClient("localhost", server.port)
                    client.startSimulationBatch("default", client_count)

                    self.assertTrue(client.isRunning())
                    self.assertTrue(client.isInitializationCaseAvailable())

                    client.addSimulation(target_case_name, 0, 0, iens,
                                         keywords)
                    self.assertTrue(
                        realizationIsInitialized(server.ert, target_case_name,
                                                 iens))

                    while not client.isRealizationFinished(iens):
                        time.sleep(0.5)

                    self.assertTrue(client.didRealizationSucceed(iens))

                    result = client.getCustomKWResult(target_case_name, iens,
                                                      "SNAKE_OIL_NPV")
                    self.assertTrue("NPV" in result)
                    self.assertTrue("RATING" in result)
                    self.assertEqual(expected_ckw[iens]["RATING"],
                                     result["RATING"])
                    self.assertAlmostEqual(expected_ckw[iens]["NPV"],
                                           result["NPV"])

                    thread_success_state[iens] = True
示例#6
0
    def test_rpc_storage(self):
        config = self.createTestPath("local/snake_oil_no_data/snake_oil.ert")

        with RPCServiceContext("ert/server/rpc_storage/storage", config) as server:
            client = ErtRPCClient("localhost", server.port)

            group_name = "Test"
            storage_definition = {
                "PI": float,
                "DakotaVersion": str,
                "Gradient": float,
                "GradientDirection": str
            }
            client.prototypeStorage(group_name, storage_definition)

            with self.assertRaises(UserWarning):
                client.prototypeStorage(group_name, {"value": float})

            with self.assertRaises(TypeError):
                client.prototypeStorage(group_name, {"value": bool})


            ensemble_config = server.ert.ensembleConfig()

            self.assertIn(group_name, ensemble_config.getKeylistFromImplType(ErtImplType.CUSTOM_KW))

            custom_kw_config = ensemble_config.getNode(group_name).getCustomKeywordModelConfig()

            self.assertIn("PI", custom_kw_config)
            self.assertTrue(custom_kw_config.keyIsDouble("PI"))

            self.assertIn("DakotaVersion", custom_kw_config)
            self.assertFalse(custom_kw_config.keyIsDouble("DakotaVersion"))

            self.assertIn("Gradient", custom_kw_config)
            self.assertTrue(custom_kw_config.keyIsDouble("Gradient"))

            self.assertIn("GradientDirection", custom_kw_config)
            self.assertFalse(custom_kw_config.keyIsDouble("GradientDirection"))


            simulation_count = 10
            initializeCase(server.ert, "default", simulation_count)

            client.storeGlobalData("default", group_name, "PI", 3.1415)
            client.storeGlobalData("default", group_name, "DakotaVersion", "DAKOTA 6.2.0")

            gradients = [random() * 20.0 - 10.0 for _ in range(simulation_count)]
            gradient_directions = [("POSITIVE" if gradient >= 0.0 else "NEGATIVE") for gradient in gradients]
            for sim_id in range(simulation_count):
                gradient = gradients[sim_id]
                gradient_direction = gradient_directions[sim_id]
                client.storeSimulationData("default", group_name, "Gradient", gradient, sim_id)
                client.storeSimulationData("default", group_name, "GradientDirection", gradient_direction, sim_id)


            data = CustomKWCollector.loadAllCustomKWData(server.ert, "default")
            for sim_id in range(simulation_count):
                self.assertEqual(data["Test:PI"][sim_id], 3.1415)
                self.assertEqual(data["Test:DakotaVersion"][sim_id], "DAKOTA 6.2.0")
                self.assertEqual(data["Test:Gradient"][sim_id], gradients[sim_id])
                self.assertEqual(data["Test:GradientDirection"][sim_id], gradient_directions[sim_id])
示例#7
0
    def test_rpc_storage(self):
        config = self.createTestPath("local/snake_oil_no_data/snake_oil.ert")

        with RPCServiceContext("ert/server/rpc_storage/storage",
                               config) as server:
            client = ErtRPCClient("localhost", server.port)

            group_name = "Test"
            storage_definition = {
                "PI": float,
                "DakotaVersion": str,
                "Gradient": float,
                "GradientDirection": str
            }
            client.prototypeStorage(group_name, storage_definition)

            with self.assertRaises(UserWarning):
                client.prototypeStorage(group_name, {"value": float})

            with self.assertRaises(TypeError):
                client.prototypeStorage(group_name, {"value": bool})

            ensemble_config = server.ert.ensembleConfig()

            self.assertIn(
                group_name,
                ensemble_config.getKeylistFromImplType(ErtImplType.CUSTOM_KW))

            custom_kw_config = ensemble_config.getNode(
                group_name).getCustomKeywordModelConfig()

            self.assertIn("PI", custom_kw_config)
            self.assertTrue(custom_kw_config.keyIsDouble("PI"))

            self.assertIn("DakotaVersion", custom_kw_config)
            self.assertFalse(custom_kw_config.keyIsDouble("DakotaVersion"))

            self.assertIn("Gradient", custom_kw_config)
            self.assertTrue(custom_kw_config.keyIsDouble("Gradient"))

            self.assertIn("GradientDirection", custom_kw_config)
            self.assertFalse(custom_kw_config.keyIsDouble("GradientDirection"))

            simulation_count = 10
            initializeCase(server.ert, "default", simulation_count)

            client.storeGlobalData("default", group_name, "PI", 3.1415)
            client.storeGlobalData("default", group_name, "DakotaVersion",
                                   "DAKOTA 6.2.0")

            gradients = [
                random() * 20.0 - 10.0 for _ in range(simulation_count)
            ]
            gradient_directions = [
                ("POSITIVE" if gradient >= 0.0 else "NEGATIVE")
                for gradient in gradients
            ]
            for sim_id in range(simulation_count):
                gradient = gradients[sim_id]
                gradient_direction = gradient_directions[sim_id]
                client.storeSimulationData("default", group_name, "Gradient",
                                           gradient, sim_id)
                client.storeSimulationData("default", group_name,
                                           "GradientDirection",
                                           gradient_direction, sim_id)

            data = CustomKWCollector.loadAllCustomKWData(server.ert, "default")
            for sim_id in range(simulation_count):
                self.assertEqual(data["Test:PI"][sim_id], 3.1415)
                self.assertEqual(data["Test:DakotaVersion"][sim_id],
                                 "DAKOTA 6.2.0")
                self.assertEqual(data["Test:Gradient"][sim_id],
                                 gradients[sim_id])
                self.assertEqual(data["Test:GradientDirection"][sim_id],
                                 gradient_directions[sim_id])
示例#8
0
    def test_client_interaction(self):
        target_case_names = ["batch_1", ".batch_1", "batch_1", ".batch_1"]
        kw = [
            {"SNAKE_OIL_PARAM": [0.50, 6, 1.750, 0.250, 0.990, 2, 1.770, 0.330, 0.550, 0.770]},
            {"SNAKE_OIL_PARAM": [0.51, 7, 1.751, 0.251, 0.991, 3, 1.771, 0.331, 0.551, 0.771]},
            {"SNAKE_OIL_PARAM": [0.52, 8, 1.752, 0.252, 0.992, 4, 1.772, 0.332, 0.552, 0.772]},
            {"SNAKE_OIL_PARAM": [0.53, 9, 1.753, 0.253, 0.993, 5, 1.773, 0.333, 0.553, 0.773]}
        ]

        expected_state_map = {
            "batch_1": [RealizationStateEnum.STATE_HAS_DATA,
                        RealizationStateEnum.STATE_UNDEFINED,
                        RealizationStateEnum.STATE_HAS_DATA
                        ],

            ".batch_1": [RealizationStateEnum.STATE_UNDEFINED,
                         RealizationStateEnum.STATE_HAS_DATA,
                         RealizationStateEnum.STATE_UNDEFINED,
                         RealizationStateEnum.STATE_HAS_DATA
                         ]
        }

        expected_custom_kw = [
            {'RATING': 'EXCELLENT', 'NPV': 125692.534209},
            {'RATING': 'AVERAGE', 'NPV': 87423.5773042},
            {'RATING': 'GOOD', 'NPV': 113243.319848},
            {'RATING': 'AVERAGE', 'NPV': 91781.8557083}
        ]

        with RPCServiceContext("ert/server/rpc/client", self.config) as server:
            client = ErtRPCClient("localhost", server.port)
            self.assertEqual(Version.currentVersion().versionTuple(), client.ertVersion())
            realization_count = len(target_case_names)

            # with self.assertRaises(UserWarning):
            #     client.startSimulationBatch("default", realization_count)
            #
            # initializeCase(server.ert, "default", 1)

            client.startSimulationBatch("default", realization_count)

            self.assertTrue(server.isInitializationCaseAvailable())
            self.assertTrue(server.isRunning())


            for iens in range(realization_count):
                client.addSimulation(target_case_names[iens], geo_id=0, pert_id=0, sim_id=iens, keywords=kw[iens])
                self.assertTrue(realizationIsInitialized(server.ert, target_case_names[iens], iens))

            while client.isRunning():
                time.sleep(1)

            for case in expected_state_map:
                fs = server.ert.getEnkfFsManager().getFileSystem(case)
                state_map = fs.getStateMap()
                states = expected_state_map[case]

                for index, state in enumerate(states):
                    self.assertEqual(state, state_map[index])

            time_map = client.getTimeMap("batch_1")
            self.assertEqual(datetime.datetime(2010, 1, 1), time_map[0])
            self.assertEqual(datetime.datetime(2015, 6, 13), time_map[199])

            with self.assertRaises(KeyError):
                client.getGenDataResult(target_case_names[0], 0, 199, "UNKNOWN_KEYWORD")

            for iens, case in enumerate(target_case_names):
                self.assertTrue(client.isRealizationFinished(iens))
                self.assertTrue(client.didRealizationSucceed(iens))
                self.assertFalse(client.didRealizationFail(iens))

                self.assertTrue(client.isCustomKWKey("SNAKE_OIL_NPV"))
                self.assertFalse(client.isGenDataKey("SNAKE_OIL_NPV"))
                self.assertTrue(client.isGenDataKey("SNAKE_OIL_OPR_DIFF"))

                result = client.getGenDataResult(case, iens, 199, "SNAKE_OIL_OPR_DIFF")
                self.assertEqual(len(result), 2000)

                result = client.getCustomKWResult(case, iens, "SNAKE_OIL_NPV")
                self.assertTrue("NPV" in result)
                self.assertTrue("RATING" in result)
                self.assertEqual(expected_custom_kw[iens]["RATING"], result["RATING"])
                self.assertAlmostEqual(expected_custom_kw[iens]["NPV"], result["NPV"])