def test_message_filter_registration(broker): fFed, ffedinfo = AddFederate(broker, "zmq", 1, 1, "filter") mFed, mfedinfo = AddFederate(broker, "zmq", 1, 1, "message") h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "") h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", None) f1 = h.helicsFederateRegisterFilter(fFed, h.helics_filter_type_custom, "filter1") f2 = h.helicsFederateRegisterFilter(fFed, h.helics_filter_type_custom, "filter2") h.helicsFederateRegisterEndpoint(fFed, "fout", "") h.helicsFederateRegisterFilter(fFed, h.helics_filter_type_custom, "filter0/fout") h.helicsFederateEnterExecutingModeAsync(fFed) h.helicsFederateEnterExecutingMode(mFed) h.helicsFederateEnterExecutingModeComplete(fFed) filter_name = h.helicsFilterGetName(f1) assert filter_name == "filter/filter1" filter_name = h.helicsFilterGetName(f2) assert filter_name == "filter/filter2" # filter_target = h.helicsFilterGetTarget(f2) # assert filter_target == "port2" h.helicsFederateFinalize(mFed) h.helicsFederateFinalize(fFed) FreeFederate(fFed, ffedinfo) FreeFederate(mFed, mfedinfo) time.sleep(1.0)
def test_messagefilter_function(): broker = createBroker(2) fFed, ffedinfo = createMessageFederate(1, "filter") mFed, mfedinfo = createMessageFederate(1, "message") p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "") p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "random") f1 = h.helicsFederateRegisterGlobalFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "filter1") h.helicsFilterAddSourceTarget(f1, "port1") f2 = h.helicsFederateRegisterGlobalFilter(fFed, h.HELICS_FILTER_TYPE_DELAY, "filter2") h.helicsFilterAddSourceTarget(f2, "port1") h.helicsFederateRegisterEndpoint(fFed, "fout", "") f3 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_RANDOM_DELAY, "filter3") h.helicsFilterAddSourceTarget(f3, "filter/fout") h.helicsFilterSet(f2, "delay", 2.5) h.helicsFederateEnterExecutingModeAsync(fFed) h.helicsFederateEnterExecutingMode(mFed) h.helicsFederateEnterExecutingModeComplete(fFed) state = h.helicsFederateGetState(fFed) assert state == 2 data = "hello world" filt_key = h.helicsFilterGetName(f1) assert filt_key == "filter1" filt_key = h.helicsFilterGetName(f2) assert filt_key == "filter2" h.helicsEndpointSendMessageRaw(p1, "port2", data.encode()) h.helicsFederateRequestTimeAsync(mFed, 1.0) grantedtime = h.helicsFederateRequestTime(fFed, 1.0) assert grantedtime == 1.0 grantedtime = h.helicsFederateRequestTimeComplete(mFed) assert grantedtime == 1.0 res = h.helicsFederateHasMessage(mFed) assert res == 0 res = h.helicsEndpointHasMessage(p2) assert res == 0 # grantedtime = h.helicsFederateRequestTime(fFed, 3.0) # assert res==h.helics_true h.helicsFederateFinalize(mFed) h.helicsFederateFinalize(fFed) # f2 = h.helicsFederateRegisterDestinationFilter(fFed, h.helics_custom_filter, "filter2", "port2") # ep1 = h.helicsFederateRegisterEndpoint(fFed, "fout", "") # f3 = h.helicsFederateRegisterSourceFilter(fFed, h.helics_custom_filter, "", "filter0/fout") destroyFederate(fFed, ffedinfo) destroyFederate(mFed, mfedinfo) time.sleep(1.0) destroyBroker(broker)
def test_message_filter_function(broker): fFed, ffedinfo = AddFederate(broker, "zmq", 1, 1, "filter") mFed, mfedinfo = AddFederate(broker, "zmq", 1, 1, "message") p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "") p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "random") f1 = h.helicsFederateRegisterGlobalFilter(fFed, h.helics_filter_type_custom, "filter1") h.helicsFilterAddSourceTarget(f1, "port1") f2 = h.helicsFederateRegisterGlobalFilter(fFed, h.helics_filter_type_delay, "filter2") h.helicsFilterAddSourceTarget(f2, "port1") h.helicsFederateRegisterEndpoint(fFed, 'fout', '') f3 = h.helicsFederateRegisterFilter(fFed, h.helics_filter_type_random_delay, 'filter3') h.helicsFilterAddSourceTarget(f3, 'filter/fout') h.helicsFilterSet(f2, "delay", 2.5) h.helicsFederateEnterExecutingModeAsync(fFed) h.helicsFederateEnterExecutingMode(mFed) h.helicsFederateEnterExecutingModeComplete(fFed) state = h.helicsFederateGetState(fFed) assert state == 2 data = "hello world" filt_key = h.helicsFilterGetName(f1) assert filt_key == 'filter1' filt_key = h.helicsFilterGetName(f2) assert filt_key == 'filter2' h.helicsEndpointSendMessageRaw(p1, "port2", data) h.helicsFederateRequestTimeAsync(mFed, 1.0) grantedtime = h.helicsFederateRequestTime(fFed, 1.0) assert grantedtime == 1.0 grantedtime = h.helicsFederateRequestTimeComplete(mFed) assert grantedtime == 1.0 res = h.helicsFederateHasMessage(mFed) assert res == 0 res = h.helicsEndpointHasMessage(p2) assert res == 0 #grantedtime = h.helicsFederateRequestTime(fFed, 3.0) #assert res==h.helics_true h.helicsFederateFinalize(mFed) h.helicsFederateFinalize(fFed) #f2 = h.helicsFederateRegisterDestinationFilter (fFed, h.helics_custom_filter, "filter2", "port2") #ep1 = h.helicsFederateRegisterEndpoint (fFed, "fout", "") #f3 = h.helicsFederateRegisterSourceFilter (fFed, h.helics_custom_filter, "", "filter0/fout") FreeFederate(fFed, ffedinfo) FreeFederate(mFed, mfedinfo) time.sleep(1.0)
def test_message_federate_send(mFed): epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", None) epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random") h.helicsFederateSetTimeProperty(mFed, h.helics_property_time_delta, 1.0) h.helicsFederateEnterExecutingMode(mFed) data = "random-data" h.helicsEndpointSendEventRaw(epid1, "ep2", data, 1.0) granted_time = h.helicsFederateRequestTime(mFed, 2.0) assert granted_time == 1.0 res = h.helicsFederateHasMessage(mFed) assert res == 1 res = h.helicsEndpointHasMessage(epid1) assert res == 0 res = h.helicsEndpointHasMessage(epid2) assert res == 1 message = h.helicsEndpointGetMessage(epid2) assert message.data == "random-data" assert message.length == 11 assert message.original_dest == "" assert message.original_source == "TestA Federate/ep1" assert message.source == "TestA Federate/ep1" assert message.time == 1.0
def test_message_federate_endpoint_registration(mFed): epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", None) epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random") h.helicsFederateSetTimeDelta(mFed, 1.0) h.helicsFederateEnterExecutionMode(mFed) data = "random-data" status = h.helicsEndpointSendEventRaw(epid1, "ep2", data, 1.0) status, granted_time = h.helicsFederateRequestTime(mFed, 1.0) assert granted_time == 1.0 res = h.helicsFederateHasMessage(mFed) assert res == 1 res = h.helicsEndpointHasMessage(epid1) # TODO: Figure out why this is returning zero assert res == 0 res = h.helicsEndpointHasMessage (epid2) assert res == 1 # This causes a segfault message = h.helicsEndpointGetMessage(epid2) assert message.data == 'random-data' assert message.length == 11 assert message.original_dest == '' assert message.original_source == 'TestA Federate/ep1' assert message.source == 'TestA Federate/ep1' assert message.time == 1.0
def test_messagefederate_test_message_federate_endpoint_registration(mFed): epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", "") epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random") h.helicsFederateEnterExecutingMode(mFed) assert h.HELICS_STATE_EXECUTION == h.helicsFederateGetState(mFed) endpoint_name = h.helicsEndpointGetName(epid1) assert endpoint_name == "TestA Federate/ep1" endpoint_name = h.helicsEndpointGetName(epid2) assert endpoint_name == "ep2" endpoint_name = h.helicsEndpointGetType(epid1) assert endpoint_name == "" endpoint_name = h.helicsEndpointGetType(epid2) assert endpoint_name == "random" epid_b = h.helicsFederateGetEndpoint(mFed, "ep2") type = h.helicsEndpointGetType(epid_b) assert type == "random" epid_c = h.helicsFederateGetEndpointByIndex(mFed, 0) name = h.helicsEndpointGetName(epid_c) assert name == "TestA Federate/ep1"
def test_messagefederate_test_message_federate_send(mFed): epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", "") epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random") h.helicsFederateSetTimeProperty(mFed, h.HELICS_PROPERTY_TIME_DELTA, 1.0) h.helicsFederateEnterExecutingMode(mFed) data = "random-data" h.helicsEndpointSendEventRaw(epid1, "ep2", data, 1.0) granted_time = h.helicsFederateRequestTime(mFed, 2.0) assert granted_time == 1.0 res = h.helicsFederateHasMessage(mFed) assert res is True res = h.helicsEndpointHasMessage(epid1) assert res is False res = h.helicsEndpointHasMessage(epid2) assert res is True message = h.helicsEndpointGetMessage(epid2) assert h.helicsMessageGetMessageID(message) == 55 assert h.helicsMessageIsValid(message) is True assert h.helicsMessageGetString(message) == "random-data" assert h.helicsMessageGetRawDataSize(message) == 11 assert h.helicsMessageGetOriginalDestination(message) == "" assert h.helicsMessageGetOriginalSource(message) == "TestA Federate/ep1" assert h.helicsMessageGetSource(message) == "TestA Federate/ep1" assert h.helicsMessageGetTime(message) == 1.0
def test_messagefilter_info(): broker = createBroker(2) fFed, ffedinfo = createMessageFederate(1, "filter") mFed, mfedinfo = createMessageFederate(1, "message") p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "") p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "") h.helicsEndpointSetInfo(p1, "p1_test") h.helicsEndpointSetInfo(p2, "p2_test") f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "filter1") h.helicsFilterAddSourceTarget(f1, "port1") h.helicsFilterSetInfo(f1, "f1_test") f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "filter2") h.helicsFilterAddSourceTarget(f2, "port2") h.helicsFilterSetInfo(f2, "f2_test") ep1 = h.helicsFederateRegisterEndpoint(fFed, "fout", "") h.helicsEndpointSetInfo(ep1, "ep1_test") f3 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "c4") h.helicsFilterAddSourceTarget(f3, "filter0/fout") h.helicsFilterSetInfo(f3, "f3_test") h.helicsFederateEnterExecutingModeAsync(fFed) h.helicsFederateEnterExecutingMode(mFed) h.helicsFederateEnterExecutingModeComplete(fFed) filter_name = h.helicsFilterGetName(f1) assert filter_name == "Testfilter/filter1" filter_name = h.helicsFilterGetName(f2) assert filter_name == "Testfilter/filter2" assert h.helicsEndpointGetInfo(p1) == "p1_test" assert h.helicsEndpointGetInfo(p2) == "p2_test" assert h.helicsEndpointGetInfo(ep1) == "ep1_test" assert h.helicsFilterGetInfo(f1) == "f1_test" assert h.helicsFilterGetInfo(f2) == "f2_test" assert h.helicsFilterGetInfo(f3) == "f3_test" h.helicsFederateFinalize(mFed) h.helicsFederateFinalize(fFed) destroyFederate(fFed, ffedinfo) destroyFederate(mFed, mfedinfo) time.sleep(1.0) destroyBroker(broker)
def test_messagefilter_registration(): broker = createBroker(2) fFed, ffedinfo = createMessageFederate(1, "filter") mFed, mfedinfo = createMessageFederate(1, "message") h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "") h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "") f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "filter1") f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "filter2") h.helicsFederateRegisterEndpoint(fFed, "fout", "") h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "filter0/fout") h.helicsFederateEnterExecutingModeAsync(fFed) h.helicsFederateEnterExecutingMode(mFed) h.helicsFederateEnterExecutingModeComplete(fFed) filter_name = h.helicsFilterGetName(f1) assert filter_name == "Testfilter/filter1" filter_name = h.helicsFilterGetName(f2) assert filter_name == "Testfilter/filter2" # filter_target = h.helicsFilterGetTarget(f2) # assert filter_target == "port2" h.helicsFederateFinalize(mFed) h.helicsFederateFinalize(fFed) destroyFederate(fFed, ffedinfo) destroyFederate(mFed, mfedinfo) time.sleep(1.0) destroyBroker(broker)
def test_messagefederate_send_receive_2fed_multisend(): broker = createBroker(2) mFed1, fedinfo1 = createMessageFederate(1, "A Federate") mFed2, fedinfo2 = createMessageFederate(1, "B Federate") epid1 = h.helicsFederateRegisterEndpoint(mFed1, "ep1", "") epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed2, "ep2", "random") h.helicsEndpointSetOption(epid1, h.HELICS_HANDLE_OPTION_IGNORE_INTERRUPTS, True) h.helicsFederateSetTimeProperty(mFed1, h.HELICS_PROPERTY_TIME_DELTA, 1.0) h.helicsFederateSetTimeProperty(mFed2, h.HELICS_PROPERTY_TIME_DELTA, 1.0) h.helicsFederateEnterExecutingModeAsync(mFed1) h.helicsFederateEnterExecutingMode(mFed2) h.helicsFederateEnterExecutingModeComplete(mFed1) assert h.HELICS_STATE_EXECUTION == h.helicsFederateGetState(mFed1) assert h.HELICS_STATE_EXECUTION == h.helicsFederateGetState(mFed2) h.helicsEndpointSetDefaultDestination(epid1, "ep2") h.helicsEndpointSendMessageRaw(epid1, "", "a".encode()) h.helicsEndpointSendMessageRaw(epid1, "", "a".encode()) h.helicsEndpointSendMessageRaw(epid1, "", "a".encode()) h.helicsFederateRequestTimeAsync(mFed1, 1.0) granted_time = h.helicsFederateRequestTime(mFed2, 1.0) complete_time = h.helicsFederateRequestTimeComplete(mFed1) assert granted_time == 1.0 assert complete_time == 1.0 res = h.helicsEndpointPendingMessages(epid2) assert res == 3 res = h.helicsFederatePendingMessages(mFed2) assert res == 3 assert h.helicsEndpointGetDefaultDestination(epid1) == "ep2" # FIXME: Someday this will be implemented. # @test_broken h.helicsEndpointGetOption(epid1, h.HELICS_HANDLE_OPTION_IGNORE_INTERRUPTS) is True destroyFederate(mFed1, fedinfo1) destroyFederate(mFed2, fedinfo2) destroyBroker(broker)
def test_filter_type_tests_registration(): broker = createBroker(2) fFed, fedinfo1 = createMessageFederate(1, "filter") mFed, fedinfo2 = createMessageFederate(1, "message") h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "") h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "") f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "filter1") h.helicsFilterAddSourceTarget(f1, "port1") f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "filter2") h.helicsFilterAddDestinationTarget(f2, "port2") assert f1 != f2 _ = h.helicsFederateRegisterEndpoint(fFed, "fout", "") f3 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "c4") h.helicsFilterAddSourceTarget(f3, "Testfilter/fout") f1_b = h.helicsFederateGetFilter(fFed, "filter1") tmp = h.helicsFilterGetName(f1_b) assert tmp == "Testfilter/filter1" f1_c = h.helicsFederateGetFilterByIndex(fFed, 2) tmp = h.helicsFilterGetName(f1_c) assert tmp == "Testfilter/c4" # @test_throws h.HELICSErrorInvalidArgument f1_n = h.helicsFederateGetFilterByIndex(fFed, -2) h.helicsFederateEnterExecutingModeAsync(fFed) h.helicsFederateEnterExecutingMode(mFed) h.helicsFederateEnterExecutingModeComplete(fFed) h.helicsFederateFinalizeAsync(mFed) h.helicsFederateFinalize(fFed) h.helicsFederateFinalizeComplete(mFed) state = h.helicsFederateGetState(fFed) assert state == h.HELICS_STATE_FINALIZE destroyFederate(fFed, fedinfo1) destroyFederate(mFed, fedinfo2) destroyBroker(broker)
def test_filter_type_tests_info(): broker = createBroker(2) fFed, fedinfo1 = createMessageFederate(1, "filter") mFed, fedinfo2 = createMessageFederate(1, "message") p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "") p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "") h.helicsEndpointSetInfo(p1, "p1_test") h.helicsEndpointSetInfo(p2, "p2_test") f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "filter1") h.helicsFilterAddSourceTarget(f1, "port1") h.helicsFilterSetInfo(f1, "f1_test") f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "filter2") h.helicsFilterAddDestinationTarget(f2, "port2") h.helicsFilterSetInfo(f2, "f2_test") ep1 = h.helicsFederateRegisterEndpoint(fFed, "fout", "") h.helicsEndpointSetInfo(ep1, "ep1_test") f3 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "c4") h.helicsFilterAddSourceTarget(f3, "filter0/fout") h.helicsFilterSetInfo(f3, "f3_test") assert h.helicsEndpointGetInfo(p1) == "p1_test" assert h.helicsEndpointGetInfo(p2) == "p2_test" assert h.helicsEndpointGetInfo(ep1) == "ep1_test" assert h.helicsFilterGetInfo(f1) == "f1_test" assert h.helicsFilterGetInfo(f2) == "f2_test" assert h.helicsFilterGetInfo(f3) == "f3_test" h.helicsFederateEnterExecutingModeAsync(fFed) h.helicsFederateEnterExecutingMode(mFed) h.helicsFederateEnterExecutingModeComplete(fFed) h.helicsFederateFinalizeAsync(mFed) h.helicsFederateFinalize(fFed) h.helicsFederateFinalizeComplete(mFed) destroyFederate(fFed, fedinfo1) destroyFederate(mFed, fedinfo2) destroyBroker(broker)
def test_message_federate_endpoint_registration(mFed): epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", None) epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random") h.helicsFederateEnterExecutingMode(mFed) endpoint_name = h.helicsEndpointGetName(epid1) assert endpoint_name == "TestA Federate/ep1" endpoint_name = h.helicsEndpointGetName(epid2) assert endpoint_name == "ep2" endpoint_name = h.helicsEndpointGetType(epid1) assert endpoint_name == "" endpoint_name = h.helicsEndpointGetType(epid2) assert endpoint_name == "random"
def test_messagefederate_message_object_tests(mFed): epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", "") epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random") h.helicsFederateSetTimeProperty(mFed, h.HELICS_PROPERTY_TIME_DELTA, 1.0) h.helicsFederateEnterExecutingMode(mFed) assert h.helicsFederateGetState(mFed) == h.HELICS_STATE_EXECUTION msg = h.helicsFederateCreateMessage(mFed) h.helicsMessageSetDestination(msg, "ep2") h.helicsMessageGetDestination(msg) == "ep2" h.helicsMessageSetData(msg, "".join(["a" for _ in range(0, 500)]).encode()) h.helicsMessageSetTime(msg, 0.0) h.helicsEndpointSendMessage(epid1, msg) t = h.helicsFederateRequestTime(mFed, 1.0) assert t == 1.0 assert h.helicsFederateHasMessage(mFed) is True assert h.helicsEndpointHasMessage(epid1) is False assert h.helicsEndpointHasMessage(epid2) is True msg = h.helicsEndpointGetMessage(epid2) assert h.helicsMessageGetRawDataSize(msg) == 500 # TODO: segfaults # print(h.helicsMessageGetRawData(msg)) # @test_broken False # segfaults # rawdata = h.helicsMessageGetRawDataPointer(msg) # assert Char(unsafe_load(Ptr{Cchar}(rdata), 245)) == 'a' h.helicsFederateFinalize(mFed) assert h.helicsFederateGetState(mFed) == h.HELICS_STATE_FINALIZE h.helicsMessageSetFlagOption(msg, 7, True) assert h.helicsMessageCheckFlag(msg, 7) is True h.helicsMessageClearFlags(msg) assert h.helicsMessageCheckFlag(msg, 7) is False h.helicsEndpointSetDefaultDestination(epid1, "ep2")
def main(): # broker = create_broker() # Broker already created from 1st terminal fed = create_federate() # Register publication pubid = h.helicsFederateRegisterGlobalPublication( fed, "TransmissionSim/B2Voltage", h.helics_data_type_complex, "") # Register subscription subid = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B2_G_1/totalLoad", "") # Register endpoint epid = h.helicsFederateRegisterEndpoint(fed, "ep1", None) # h.helicsSubscriptionSetDefaultComplex(subid, 0, 0) # Enter execution mode h.helicsFederateEnterExecutingMode(fed) hours = 1 seconds = int(60 * 60 * hours) grantedtime = -1 random.seed(0) for t in range(0, seconds, 60 * 5): c = complex(132790.562, 0) * (1 + (random.random() - 0.5) / 2) logger.info("Voltage value = {} kV".format(abs(c) / 1000)) status = h.helicsPublicationPublishComplex(pubid, c.real, c.imag) # status = h.helicsEndpointSendEventRaw(epid, "fixed_price", 10, t) while grantedtime < t: grantedtime = h.helicsFederateRequestTime(fed, t) time.sleep(1) rValue, iValue = h.helicsInputGetComplex(subid) logger.info("Python Federate grantedtime = {}".format(grantedtime)) logger.info("Load value = {} MVA".format( complex(rValue, iValue) / 1000)) t = 60 * 60 * 24 while grantedtime < t: grantedtime = h.helicsFederateRequestTime(fed, t) logger.info("Destroying federate") destroy_federate(fed)
def test_message_federate_endpoint_registration(mFed): epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", None) epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random") h.helicsFederateEnterExecutionMode(mFed) status, endpoint_name = h.helicsEndpointGetName(epid1, 100) assert status == 0 assert endpoint_name == "TestA Federate/ep1" status, endpoint_name = h.helicsEndpointGetName(epid2, 100) assert status == 0 assert endpoint_name == "ep2" status, endpoint_name = h.helicsEndpointGetType(epid1, 100) assert status == 0 assert endpoint_name == "" status, endpoint_name = h.helicsEndpointGetType(epid2, 100) assert status == 0 assert endpoint_name == "random"
def test_message_filter_registration(broker): fFed = AddFederate(broker, "zmq", 1, 1, "filter") mFed = AddFederate(broker, "zmq", 1, 1, "message") h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "") h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", None) f1 = h.helicsFederateRegisterSourceFilter(fFed, h.helics_custom_filter, "filter1", "port1") f2 = h.helicsFederateRegisterDestinationFilter(fFed, h.helics_custom_filter, "filter2", "port2") ep1 = h.helicsFederateRegisterEndpoint(fFed, "fout", "") f3 = h.helicsFederateRegisterSourceFilter(fFed, h.helics_custom_filter, "", "filter0/fout") h.helicsFederateFinalize(mFed) h.helicsFederateFinalize(fFed) FreeFederate(fFed) FreeFederate(mFed) time.sleep(1.0)
def main(): # broker = create_broker() fed = create_federate() pubid = h.helicsFederateRegisterGlobalTypePublication( fed, "TransmissionSim/B2Voltage", h.HELICS_DATA_TYPE_COMPLEX, "") subid = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B2_G_1/totalLoad", "complex", "") epid = h.helicsFederateRegisterEndpoint(fed, "ep1", None) h.helicsSubscriptionSetDefaultComplex(subid, 0, 0) h.helicsFederateEnterExecutionMode(fed) hours = 1 seconds = int(60 * 60 * hours) grantedtime = -1 random.seed(0) for t in range(0, seconds, 60 * 5): c = complex(132790.562, 0) * (1 + (random.random() - 0.5) / 2) logger.info("Voltage value = {} kV".format(abs(c) / 1000)) status = h.helicsPublicationPublishComplex(pubid, c.real, c.imag) # status = h.helicsEndpointSendEventRaw(epid, "fixed_price", 10, t) while grantedtime < t: status, grantedtime = h.helicsFederateRequestTime(fed, t) time.sleep(1) status, rValue, iValue = h.helicsSubscriptionGetComplex(subid) logger.info("Python Federate grantedtime = {}".format(grantedtime)) logger.info("Load value = {} MW".format( complex(rValue, iValue) / 1000)) t = 60 * 60 * 24 while grantedtime < t: status, grantedtime = h.helicsFederateRequestTime(fed, t) logger.info("Destroying federate") destroy_federate(fed)
def test_misc_api(): fedInfo1 = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreInitString(fedInfo1, "-f 1") h.helicsFederateInfoSetCoreName(fedInfo1, "core3") h.helicsFederateInfoSetCoreType(fedInfo1, 3) h.helicsFederateInfoSetCoreTypeFromString(fedInfo1, "zmq") h.helicsFederateInfoSetFlagOption(fedInfo1, 1, True) h.helicsFederateInfoSetTimeProperty(fedInfo1, h.HELICS_PROPERTY_TIME_INPUT_DELAY, 1.0) h.helicsFederateInfoSetIntegerProperty(fedInfo1, h.HELICS_PROPERTY_INT_LOG_LEVEL, 1) h.helicsFederateInfoSetIntegerProperty( fedInfo1, h.HELICS_PROPERTY_INT_MAX_ITERATIONS, 100) h.helicsFederateInfoSetTimeProperty(fedInfo1, h.HELICS_PROPERTY_TIME_OUTPUT_DELAY, 1.0) h.helicsFederateInfoSetTimeProperty(fedInfo1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0) h.helicsFederateInfoSetTimeProperty(fedInfo1, h.HELICS_PROPERTY_TIME_DELTA, 1.0) h.helicsFederateInfoSetTimeProperty(fedInfo1, h.HELICS_PROPERTY_TIME_OFFSET, 0.1) h.helicsFederateInfoFree(fedInfo1) broker3 = h.helicsCreateBroker("zmq", "broker3", "--federates 1 --loglevel 1") fedInfo2 = h.helicsCreateFederateInfo() coreInitString = "--federates 1" h.helicsFederateInfoSetCoreInitString(fedInfo2, coreInitString) h.helicsFederateInfoSetCoreTypeFromString(fedInfo2, "zmq") h.helicsFederateInfoSetIntegerProperty(fedInfo2, h.HELICS_PROPERTY_INT_LOG_LEVEL, 1) h.helicsFederateInfoSetTimeProperty(fedInfo2, h.HELICS_PROPERTY_TIME_DELTA, 1.0) fed1 = h.helicsCreateCombinationFederate("fed1", fedInfo2) fed2 = h.helicsFederateClone(fed1) _ = h.helicsGetFederateByName("fed1") h.helicsFederateSetFlagOption(fed2, 1, False) h.helicsFederateSetTimeProperty(fed2, h.HELICS_PROPERTY_TIME_INPUT_DELAY, 1.0) h.helicsFederateSetIntegerProperty(fed1, h.HELICS_PROPERTY_INT_LOG_LEVEL, 1) h.helicsFederateSetIntegerProperty(fed2, h.HELICS_PROPERTY_INT_MAX_ITERATIONS, 100) h.helicsFederateSetTimeProperty(fed2, h.HELICS_PROPERTY_TIME_OUTPUT_DELAY, 1.0) h.helicsFederateSetTimeProperty(fed2, h.HELICS_PROPERTY_TIME_PERIOD, 0.0) h.helicsFederateSetTimeProperty(fed2, h.HELICS_PROPERTY_TIME_DELTA, 1.0) _ = h.helicsFederateRegisterCloningFilter(fed1, "fed1/Ep1") fed1DestinationFilter = h.helicsFederateRegisterFilter( fed1, h.HELICS_FILTER_TYPE_DELAY, "fed1DestinationFilter") h.helicsFilterAddDestinationTarget(fed1DestinationFilter, "Ep2") ep1 = h.helicsFederateRegisterEndpoint(fed1, "Ep1", "string") ep2 = h.helicsFederateRegisterGlobalEndpoint(fed1, "Ep2", "string") pub1 = h.helicsFederateRegisterGlobalPublication(fed1, "pub1", h.HELICS_DATA_TYPE_DOUBLE, "") pub2 = h.helicsFederateRegisterGlobalTypePublication( fed1, "pub2", "complex", "") sub1 = h.helicsFederateRegisterSubscription(fed1, "pub1") sub2 = h.helicsFederateRegisterSubscription(fed1, "pub2") h.helicsInputAddTarget(sub2, "Ep2") pub3 = h.helicsFederateRegisterPublication(fed1, "pub3", h.HELICS_DATA_TYPE_STRING, "") pub1KeyString = h.helicsPublicationGetKey(pub1) pub1TypeString = h.helicsPublicationGetType(pub1) pub1UnitsString = h.helicsPublicationGetUnits(pub1) sub1KeyString = h.helicsSubscriptionGetKey(sub1) sub1UnitsString = h.helicsInputGetUnits(sub1) assert "pub1" == pub1KeyString assert "double" == pub1TypeString assert "" == pub1UnitsString assert "pub1" == sub1KeyString assert "" == sub1UnitsString fed1SourceFilter = h.helicsFederateRegisterFilter( fed1, h.HELICS_FILTER_TYPE_DELAY, "fed1SourceFilter") h.helicsFilterAddSourceTarget(fed1SourceFilter, "Ep2") h.helicsFilterAddDestinationTarget(fed1SourceFilter, "fed1/Ep1") h.helicsFilterRemoveTarget(fed1SourceFilter, "fed1/Ep1") h.helicsFilterAddSourceTarget(fed1SourceFilter, "Ep2") h.helicsFilterRemoveTarget(fed1SourceFilter, "Ep2") fed1SourceFilterNameString = h.helicsFilterGetName(fed1SourceFilter) assert fed1SourceFilterNameString == "fed1/fed1SourceFilter" sub3 = h.helicsFederateRegisterSubscription(fed1, "fed1/pub3", "") pub4 = h.helicsFederateRegisterTypePublication(fed1, "pub4", "int", "") sub4 = h.helicsFederateRegisterSubscription(fed1, "fed1/pub4", "") pub5 = h.helicsFederateRegisterGlobalTypePublication( fed1, "pub5", "boolean", "") sub5 = h.helicsFederateRegisterSubscription(fed1, "pub5", "") pub6 = h.helicsFederateRegisterGlobalPublication(fed1, "pub6", h.HELICS_DATA_TYPE_VECTOR, "") sub6 = h.helicsFederateRegisterSubscription(fed1, "pub6", "") pub7 = h.helicsFederateRegisterGlobalPublication( fed1, "pub7", h.HELICS_DATA_TYPE_NAMED_POINT, "") sub7 = h.helicsFederateRegisterSubscription(fed1, "pub7", "") assert """helics.HelicsPublication(name = "pub1", type = "double", units = "", info = "")""" in repr( pub1) assert """helics.HelicsPublication(name = "pub2", type = "complex", units = "", info = "")""" in repr( pub2) assert """helics.HelicsPublication(name = "fed1/pub3", type = "string", units = "", info = "")""" in repr( pub3) assert """helics.HelicsPublication(name = "fed1/pub4", type = "int", units = "", info = "")""" in repr( pub4) assert """helics.HelicsPublication(name = "pub5", type = "boolean", units = "", info = "")""" in repr( pub5) assert """helics.HelicsPublication(name = "pub6", type = "double_vector", units = "", info = "")""" in repr( pub6) assert """helics.HelicsPublication(name = "pub7", type = "named_point", units = "", info = "")""" in repr( pub7) assert ( """helics.HelicsInput(name = "_input_18", units = "", injection_units = "", publication_type = "", type = "", target = "pub7", info = "")""" in repr(sub7)) h.helicsInputSetDefaultBoolean(sub5, False) h.helicsInputSetDefaultComplex(sub2, -9.9 + 2.5j) h.helicsInputSetDefaultDouble(sub1, 3.4) h.helicsInputSetDefaultInteger(sub4, 6) h.helicsInputSetDefaultNamedPoint(sub7, "hollow", 20.0) h.helicsInputSetDefaultString(sub3, "default") sub6Default = [3.4, 90.9, 4.5] h.helicsInputSetDefaultVector(sub6, sub6Default) h.helicsEndpointSubscribe(ep2, "fed1/pub3") h.helicsFederateEnterInitializingModeAsync(fed1) rs = h.helicsFederateIsAsyncOperationCompleted(fed1) if rs == 0: time.sleep(0.500) rs = h.helicsFederateIsAsyncOperationCompleted(fed1) if rs == 0: time.sleep(0.500) rs = h.helicsFederateIsAsyncOperationCompleted(fed1) if rs == 0: assert True is False h.helicsFederateEnterInitializingModeComplete(fed1) h.helicsFederateEnterExecutingModeAsync(fed1) h.helicsFederateEnterExecutingModeComplete(fed1) assert ( """helics.HelicsInput(name = "_input_18", units = "", injection_units = "", publication_type = "named_point", type = "", target = "pub7", info = "")""" in repr(sub7)) mesg1 = h.helicsFederateCreateMessage(fed1) h.helicsMessageSetString(mesg1, "Hello") h.helicsMessageSetSource(mesg1, "fed1/Ep1") h.helicsMessageSetOriginalSource(mesg1, "fed1/Ep1") h.helicsMessageSetDestination(mesg1, "Ep2") h.helicsMessageSetOriginalDestination(mesg1, "Ep2") h.helicsEndpointSendMessage(ep1, mesg1) mesg1 = h.helicsFederateCreateMessage(fed1) h.helicsMessageSetString(mesg1, "There") h.helicsMessageSetSource(mesg1, "fed1/Ep1") h.helicsMessageSetOriginalSource(mesg1, "fed1/Ep1") h.helicsMessageSetDestination(mesg1, "Ep2") h.helicsMessageSetOriginalDestination(mesg1, "Ep2") h.helicsEndpointSendMessage(ep1, mesg1) h.helicsEndpointSetDefaultDestination(ep2, "fed1/Ep1") ep1NameString = h.helicsEndpointGetName(ep1) ep1TypeString = h.helicsEndpointGetType(ep1) assert ep1NameString == "fed1/Ep1" assert ep1TypeString == "string" _ = h.helicsFederateGetCoreObject(fed1) fed1Time = h.helicsFederateGetCurrentTime(fed1) assert fed1Time == 0.0 fed1EndpointCount = h.helicsFederateGetEndpointCount(fed1) assert fed1EndpointCount == 2 fed1NameString = h.helicsFederateGetName(fed1) assert fed1NameString == "fed1" fed1State = h.helicsFederateGetState(fed1) assert fed1State == 2 fed1PubCount = h.helicsFederateGetPublicationCount(fed1) assert fed1PubCount == 7 fed1SubCount = h.helicsFederateGetInputCount(fed1) assert fed1SubCount == 7 h.helicsPublicationPublishBoolean(pub5, True) h.helicsPublicationPublishComplex(pub2, 5.6 + -0.67j) h.helicsPublicationPublishDouble(pub1, 457.234) h.helicsPublicationPublishInteger(pub4, 1) h.helicsPublicationPublishNamedPoint(pub7, "Blah Blah", 20.0) h.helicsPublicationPublishString(pub3, "Mayhem") pub6Vector = [4.5, 56.5] h.helicsPublicationPublishVector(pub6, pub6Vector) time.sleep(0.500) h.helicsFederateRequestTimeAsync(fed1, 1.0) returnTime = h.helicsFederateRequestTimeComplete(fed1) assert returnTime == 1.0 ep2MsgCount = h.helicsEndpointPendingMessages(ep2) assert ep2MsgCount == 2 ep2HasMsg = h.helicsEndpointHasMessage(ep2) assert ep2HasMsg == 1 msg2 = h.helicsEndpointGetMessage(ep2) assert h.helicsMessageGetTime(msg2) == 1.0 assert h.helicsMessageGetString(msg2) == "Hello" assert h.helicsMessageGetOriginalSource(msg2) == "fed1/Ep1" assert h.helicsMessageGetSource(msg2) == "fed1/Ep1" assert h.helicsMessageGetDestination(msg2) == "Ep2" assert h.helicsMessageGetOriginalDestination(msg2) == "Ep2" fed1MsgCount = h.helicsFederatePendingMessages(fed1) assert fed1MsgCount == 1 assert h.helicsFederateHasMessage(fed1) == 1 msg3 = h.helicsFederateGetMessage(fed1) assert h.helicsMessageGetTime(msg3) == 1.0 assert h.helicsMessageGetString(msg3) == "There" assert h.helicsMessageGetOriginalSource(msg3) == "fed1/Ep1" assert h.helicsMessageGetSource(msg3) == "fed1/Ep1" assert h.helicsMessageGetDestination(msg3) == "Ep2" assert h.helicsMessageGetOriginalDestination(msg3) == "Ep2" sub1Updated = h.helicsInputIsUpdated(sub1) # TODO: figure out why this test is broken assert sub1Updated is False # TODO: figure out why this test is broken assert h.helicsInputLastUpdateTime(sub2) == 0.0 # assert h.helicsInputGetComplex(sub2) == 5.6 - 0.67j # assert h.helicsInputGetDouble(sub1) == 457.234 # assert h.helicsInputGetInteger(sub4) == 1 sub7PointString, sub7DoubleValue = h.helicsInputGetNamedPoint(sub7) # assert sub7PointString == "Blah Blah" assert sub7DoubleValue == 20.0 # assert h.helicsInputGetBoolean(sub5) == True # assert h.helicsInputGetString(sub3) == "Mayhem" sub3ValueSize = h.helicsInputGetRawValueSize(sub3) # assert sub3ValueSize == 6 # assert h.helicsInputGetVector(sub6) == [4.5, 56.5] h.helicsFederateFinalize(fed1) h.helicsFederateFinalize(fed2) h.helicsFederateFree(fed1) h.helicsFederateFinalize(fed2) h.helicsFederateFree(fed2) h.helicsFederateInfoFree(fedInfo2) h.helicsBrokerDisconnect(broker3) h.helicsBrokerFree(broker3) h.helicsCleanupLibrary() h.helicsCloseLibrary()
def test_filter_test_types_message_filter_function3(): broker = createBroker(2) fFed, fedinfo1 = createMessageFederate(1, "filter", 1) mFed, fedinfo2 = createMessageFederate(1, "message", 1) p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "") p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "random") f1 = h.helicsFederateRegisterGlobalFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM, "filter1") h.helicsFilterAddSourceTarget(f1, "port1") f2 = h.helicsFederateRegisterGlobalFilter(fFed, h.HELICS_FILTER_TYPE_DELAY, "filter2") h.helicsFilterAddSourceTarget(f2, "port1") h.helicsFederateRegisterEndpoint(fFed, "fout", "") f3 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_RANDOM_DELAY, "filter3") h.helicsFilterAddSourceTarget(f3, "filter0/fout") h.helicsFilterSet(f2, "delay", 2.5) h.helicsFederateEnterExecutingModeAsync(fFed) h.helicsFederateEnterExecutingMode(mFed) h.helicsFederateEnterExecutingModeComplete(fFed) state = h.helicsFederateGetState(fFed) assert state == h.HELICS_STATE_EXECUTION data = "hello world".encode() h.helicsEndpointSendMessageRaw(p1, "port2", data) h.helicsFederateRequestTimeAsync(mFed, 1.0) h.helicsFederateRequestTime(fFed, 1.0) h.helicsFederateRequestTimeComplete(mFed) assert h.helicsFederateHasMessage(mFed) is False h.helicsEndpointSendMessageRaw(p2, "port1", data) h.helicsFederateRequestTimeAsync(mFed, 2.0) h.helicsFederateRequestTime(fFed, 2.0) h.helicsFederateRequestTimeComplete(mFed) assert h.helicsEndpointHasMessage(p2) is False # there may be something wrong here yet but this test isn't the one to find it and # this may prevent spurious errors for now. # std::this_thread::yield() h.helicsFederateRequestTimeAsync(mFed, 3.0) h.helicsFederateRequestTime(fFed, 3.0) h.helicsFederateRequestTimeComplete(mFed) assert h.helicsEndpointHasMessage(p2) m2 = h.helicsEndpointGetMessage(p2) assert h.helicsMessageGetSource(m2) == "port1" assert h.helicsMessageGetOriginalSource(m2) == "port1" assert h.helicsMessageGetDestination(m2) == "port2" assert h.helicsMessageGetRawDataSize(m2) == len(data) assert h.helicsMessageGetTime(m2) == 2.5 assert h.helicsEndpointHasMessage(p1) is True h.helicsFederateFinalize(mFed) h.helicsFederateFinalize(fFed) state = h.helicsFederateGetState(fFed) assert state == h.HELICS_STATE_FINALIZE destroyFederate(mFed, fedinfo1) destroyFederate(fFed, fedinfo2) destroyBroker(broker)
def test_bad_inputs_input_tests(): broker = createBroker(1) vFed1, fedinfo = createValueFederate(1, "fed0") # register the publications pubid = h.helicsFederateRegisterGlobalPublication( vFed1, "pub1", h.HELICS_DATA_TYPE_DOUBLE, "") subid = h.helicsFederateRegisterInput(vFed1, "inp1", h.HELICS_DATA_TYPE_DOUBLE, "") # @test_throws h.HELICSErrorRegistrationFailure with pt.raises(h.HelicsException): subid2 = h.helicsFederateRegisterInput(vFed1, "inp1", h.HELICS_DATA_TYPE_DOUBLE, "") h.helicsInputAddTarget(subid, "pub1") vf2 = h.helicsFederateClone(vFed1) assert h.helicsFederateGetName(vFed1) == h.helicsFederateGetName(vf2) h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0) # @test_throws h.HELICSErrorInvalidObject with pt.raises(h.HelicsException): ept = h.helicsFederateRegisterEndpoint(vFed1, "ept1", "") h.helicsFederateEnterInitializingMode(vFed1) h.helicsPublicationPublishDouble(pubid, 27.0) comp = h.helicsFederateEnterExecutingModeIterative( vFed1, h.HELICS_ITERATION_REQUEST_FORCE_ITERATION) assert comp == h.HELICS_ITERATION_RESULT_ITERATING val = h.helicsInputGetDouble(subid) assert val == 27.0 valt = h.helicsInputGetTime(subid) assert valt == 27.0 comp = h.helicsFederateEnterExecutingModeIterative( vFed1, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED) assert comp == h.HELICS_ITERATION_RESULT_NEXT_STEP val2 = h.helicsInputGetDouble(subid) assert val2 == val # expect error entering initializing Mode again # @test_throws h.HELICSErrorInvalidFunctionCall with pt.raises(h.HelicsException): h.helicsFederateEnterInitializingMode(vFed1) # expect error entering initializing Mode again # @test_throws h.HELICSErrorInvalidFunctionCall with pt.raises(h.HelicsException): h.helicsFederateEnterInitializingModeAsync(vFed1) # expect error entering initializing Mode again # @test_throws h.HELICSErrorInvalidFunctionCall with pt.raises(h.HelicsException): h.helicsFederateEnterInitializingModeComplete(vFed1) h.helicsFederateFinalize(vFed1) destroyFederate(vFed1, fedinfo) destroyBroker(broker)
# assume the EV Controller needs 1 minute to determine whether or not to charge # the vehicles period = 15 * 60 # 15 min fed = create_message_federate(fedinitstring, name, period) #### Register interfaces ##### # Register the endpoints and their destinations # the EVController will subscribe to each EV num_EVs = 100 end_EVsoc = [] enddest_EVsoc = [] EVs = range(1, num_EVs + 1) for EV in EVs: end_name = f"EV{EV}.soc" end_EVsoc.append( h.helicsFederateRegisterEndpoint(fed, end_name, "double")) dest_name = f"EV_federate/EV{EV}.soc" enddest_EVsoc.append( h.helicsEndpointSetDefaultDestination(end_EVsoc[EV - 1], dest_name)) print(f"end point {end_name} registered to {dest_name}") # end_count = h.helicsFederateGetEndpointCount(fed) # print(end_count) fed_name = h.helicsFederateGetName(fed) print(" Federate {} has been registered".format(fed_name)) # test = h.helicsEndpointGetName(end_EVsoc[0]) # print(test) ###################### Entering Execution Mode ########################################################## h.helicsFederateEnterExecutingMode(fed)