def test_filter_type_tests_message_filter_function(): broker = createBroker(2) fFed, fedinfo1 = createMessageFederate(1, "filter") mFed, fedinfo2 = createMessageFederate(1, "message") h.helicsFederateSetFlagOption(mFed, h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS, True) p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "") p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "") f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_DELAY, "filter1") h.helicsFilterAddSourceTarget(f1, "port1") h.helicsFilterSet(f1, "delay", 2.5) h.helicsFederateEnterExecutingModeAsync(fFed) h.helicsFederateEnterExecutingMode(mFed) h.helicsFederateEnterExecutingModeComplete(fFed) state = h.helicsFederateGetState(fFed) assert state == h.HELICS_STATE_EXECUTION data = "".join(["a" for _ in range(0, 500)]).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.helicsFederateRequestTimeAsync(mFed, 2.0) h.helicsFederateRequestTime(fFed, 2.0) h.helicsFederateRequestTimeComplete(mFed) assert h.helicsEndpointHasMessage(p2) is False h.helicsFederateRequestTimeAsync(fFed, 3.0) h.helicsFederateRequestTime(mFed, 3.0) assert h.helicsEndpointHasMessage(p2) is True 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 h.helicsFederateRequestTime(mFed, 3.0) h.helicsFederateRequestTimeComplete(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_bad_input_message_federate_message(): broker = createBroker(1) mFed1, fedinfo = createMessageFederate(1, "test") ept1 = h.helicsFederateRegisterGlobalEndpoint(mFed1, "ept1", "") with pt.raises(h.HelicsException): h.helicsFederateRegisterGlobalEndpoint(mFed1, "ept1", "") h.helicsFederateEnterExecutingMode(mFed1) h.helicsEndpointSetDefaultDestination(ept1, "ept1") mess0 = h.helicsEndpointGetMessage(ept1) mess0 = h.helicsFederateGetMessage(mFed1) with pt.raises(h.HelicsException): h.helicsEndpointSendMessage(ept1, mess0) h.helicsFederateRequestNextStep(mFed1) cnt = h.helicsEndpointPendingMessages(ept1) assert cnt == 0 h.helicsFederateFinalize(mFed1) # @test_throws h.HELICSErrorInvalidFunctionCall with pt.raises(h.HelicsException): h.helicsEndpointSendMessage(ept1, mess0) destroyFederate(mFed1, fedinfo) destroyBroker(broker)
def test_bad_input_filter_test4(): broker = createBroker(1) mFed1, fedinfo = createMessageFederate(1, "test") filt1 = h.helicsFederateRegisterCloningFilter(mFed1, "filt1") # @test_throws h.HELICSErrorRegistrationFailure with pt.raises(h.HelicsException): filt2 = h.helicsFederateRegisterCloningFilter(mFed1, "filt1") # @test_throws h.HELICSErrorInvalidArgument with pt.raises(h.HelicsException): h.helicsFilterSetString(filt1, "unknown", "string") h.helicsFederateRegisterGlobalEndpoint(mFed1, "ept1", "") h.helicsFilterAddDeliveryEndpoint(filt1, "ept1") h.helicsFilterAddSourceTarget(filt1, "ept1") h.helicsFilterAddDestinationTarget(filt1, "ept1") h.helicsFilterRemoveTarget(filt1, "ept1") # @test_throws h.HELICSErrorInvalidArgument with pt.raises(h.HelicsException): h.helicsFilterSet(filt1, "unknown", 10.0) h.helicsFederateFinalize(mFed1) destroyFederate(mFed1, fedinfo) destroyBroker(broker)
def init_logger(config_file_name): fed = h.helicsCreateMessageFederateFromConfig(config_file_name) my_epid = h.helicsFederateGetEndpoint(fed, "logger") fed_name = h.helicsFederateGetName(fed) print(fed_name) pid = os.getpid() print("Logger Pid {}".format(pid)) currenttime = -1 output = "" log.basicConfig(filename='./log/logger.log', filemode='w', format='%(message)s', level=log.INFO) h.helicsFederateEnterExecutingMode(fed) while (currenttime < maxtime): currenttime = h.helicsFederateRequestTime(fed, maxtime) if h.helicsEndpointHasMessage(my_epid): count = h.helicsEndpointPendingMessages(my_epid) for i in range(count): message = h.helicsEndpointGetMessage(my_epid) output = output + str(message.data) + "\n" log.info("Current Time : {}".format(currenttime)) log.info(output) h.helicsFederateFinalize(fed) print(fed_name, " : Federate finalized") h.helicsFederateFree(fed) h.helicsCloseLibrary()
def init_worker(config_file_name, manager_name, individual_simulation_time): print("worker in") fed = h.helicsCreateMessageFederateFromConfig(config_file_name) print("worker passed config") my_epid = h.helicsFederateGetEndpoint(fed, "data") fed_name = h.helicsFederateGetName(fed) dest = manager_name + "/data" pid = os.getpid() print(fed_name, " about to Started") h.helicsFederateEnterExecutingMode(fed) print(fed_name, " Started") current_time = -1 while current_time < maxtime: current_time = h.helicsFederateRequestTime(fed, maxtime) if h.helicsEndpointHasMessage(my_epid): message = h.helicsEndpointGetMessage(my_epid) data = str(fed_name) + "(" + str(pid) + "): " + str(message.data) # time.sleep(random.randrange(4)) time.sleep(individual_simulation_time) h.helicsEndpointSendMessageRaw(my_epid, str(dest), data) h.helicsFederateFinalize(fed) h.helicsFederateFree(fed) h.helicsCloseLibrary()
def test_iteration_execution_iteration_test(): broker = createBroker(1) vFed1, fedinfo = createValueFederate(1, "fed0") # register the publications pubid = h.helicsFederateRegisterGlobalPublication( vFed1, "pub1", h.HELICS_DATA_TYPE_DOUBLE, "") subid = h.helicsFederateRegisterSubscription(vFed1, "pub1", "") h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_DELTA, 1.0) h.helicsFederateEnterInitializingMode(vFed1) h.helicsPublicationPublishDouble(pubid, 27.0) comp = h.helicsFederateEnterExecutingModeIterative( vFed1, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED) assert comp == h.HELICS_ITERATION_RESULT_ITERATING val = h.helicsInputGetDouble(subid) assert val == 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 h.helicsFederateFinalize(vFed1) destroyFederate(vFed1, fedinfo) destroyBroker(broker)
def test_bad_input_tests_raw_tests(): broker = createBroker(1) vFed1, fedinfo = createValueFederate(1, "test") pubid = h.helicsFederateRegisterPublication(vFed1, "pub1", h.HELICS_DATA_TYPE_RAW, "") subid = h.helicsFederateRegisterGlobalInput(vFed1, "inp1", h.HELICS_DATA_TYPE_RAW, "") h.helicsPublicationAddTarget(pubid, "inp1") h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0) h.helicsFederateEnterExecutingMode(vFed1) h.helicsPublicationPublishRaw(pubid, b"hello world") h.helicsFederateRequestNextStep(vFed1) s = h.helicsInputGetRawValue(subid) assert s == b"hello world" h.helicsPublicationPublishDouble(pubid, 27) h.helicsFederateRequestNextStep(vFed1) s = h.helicsInputGetComplex(subid) assert complex(*s) != 27 + 0j h.helicsFederateFinalize(vFed1) t, res = h.helicsFederateRequestTimeIterative( vFed1, 1.0, h.HELICS_ITERATION_REQUEST_NO_ITERATION) assert res == h.HELICS_ITERATION_RESULT_HALTED destroyFederate(vFed1, fedinfo) destroyBroker(broker)
def test_query_broker_tests(): broker = createBroker(2) vFed1, fedinfo1 = createValueFederate(1, "fed0") vFed2, fedinfo2 = createValueFederate(1, "fed1") core = h.helicsFederateGetCoreObject(vFed1) q1 = h.helicsCreateQuery("root", "federates") res = h.helicsQueryCoreExecute(q1, core) name1 = h.helicsFederateGetName(vFed1) name2 = h.helicsFederateGetName(vFed2) try: assert f"[{name1};{name2}]" == res except AssertionError: assert [name1, name2] == res res = h.helicsQueryExecute(q1, vFed1) try: assert f"[{name1};{name2}]" == res except AssertionError: assert [name1, name2] == res h.helicsFederateEnterInitializingModeAsync(vFed1) h.helicsFederateEnterInitializingMode(vFed2) h.helicsFederateEnterInitializingModeComplete(vFed1) h.helicsQueryFree(q1) h.helicsCoreFree(core) h.helicsFederateFinalizeAsync(vFed1) h.helicsFederateFinalize(vFed2) h.helicsFederateFinalizeComplete(vFed1) destroyFederate(vFed1, fedinfo1) destroyFederate(vFed2, fedinfo2) destroyBroker(broker)
def FreeFederate(fed, fedinfo): h.helicsFederateFinalize(fed) state = h.helicsFederateGetState(fed) assert state == 3 # TODO: should this be 3? h.helicsFederateInfoFree(fedinfo) h.helicsFederateFree(fed)
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_valuefederate_test_info_filed(): broker = createBroker() vFed, fedinfo = createValueFederate(1, "fed0") h.helicsFederateSetFlagOption(vFed, h.HELICS_HANDLE_OPTION_CONNECTION_OPTIONAL, True) # register the publications/subscriptions subid1 = h.helicsFederateRegisterSubscription(vFed, "sub1", "") pubid1 = h.helicsFederateRegisterTypePublication(vFed, "pub1", "string", "") pubid2 = h.helicsFederateRegisterGlobalTypePublication(vFed, "pub2", "string", "") # Set info fields h.helicsInputSetInfo(subid1, "sub1_test") h.helicsPublicationSetInfo(pubid1, "pub1_test") h.helicsPublicationSetInfo(pubid2, "pub2_test") h.helicsFederateEnterExecutingMode(vFed) assert h.helicsInputGetInfo(subid1) == "sub1_test" assert h.helicsPublicationGetInfo(pubid1) == "pub1_test" assert h.helicsPublicationGetInfo(pubid2) == "pub2_test" cr = h.helicsFederateGetCoreObject(vFed) h.helicsFederateFinalize(vFed) wait = h.helicsCoreWaitForDisconnect(cr, 70) if wait is False: wait = h.helicsCoreWaitForDisconnect(cr, 500) assert wait is True destroyFederate(vFed, fedinfo) destroyBroker(broker)
def destroy_federate(fed): """ fed: federate to destroy """ h.helicsFederateFinalize(fed) h.helicsFederateFree(fed) h.helicsCloseLibrary()
def init_worker(config_file_name, manager_name): fed = h.helicsCreateMessageFederateFromConfig(config_file_name) my_epid = h.helicsFederateGetEndpoint(fed, "data") fed_name = h.helicsFederateGetName(fed) dest = manager_name + "/data" pid = os.getpid() h.helicsFederateEnterExecutingMode(fed) current_time = h.helicsFederateRequestTime(fed, maxtime) simulation_time_data = h.helicsEndpointGetMessage(my_epid) sleep_time = float(simulation_time_data.data) current_time = -1 while current_time < maxtime: current_time = h.helicsFederateRequestTime(fed, maxtime) if h.helicsEndpointHasMessage(my_epid): message = h.helicsEndpointGetMessage(my_epid) data = str(fed_name) + "(" + str(pid) + "): " + str(message.data) # time.sleep(random.randrange(4)) time.sleep(float(sleep_time)) h.helicsEndpointSendMessageRaw(my_epid, str(dest), data) h.helicsFederateFinalize(fed) h.helicsFederateFree(fed) h.helicsCloseLibrary()
def test_system_tests_federate_logging(): lfile = "log.txt" rm(lfile, force=True) core = h.helicsCreateCore("inproc", "clogf", "--autobroker --log_level=trace") fi = h.helicsCreateFederateInfo() h.helicsFederateInfoSetBrokerKey(fi, "key") h.helicsFederateInfoSetCoreName(fi, "clogf") fed = h.helicsCreateValueFederate("f1", fi) h.helicsFederateSetLogFile(fed, lfile) h.helicsFederateLogLevelMessage(fed, 7, "hello") h.helicsFederateLogErrorMessage(fed, "hello") h.helicsFederateLogDebugMessage(fed, "hello") h.helicsFederateLogWarningMessage(fed, "hello") h.helicsFederateClearMessages(fed) h.helicsCoreSetLogFile(core, lfile) h.helicsCoreDisconnect(core) h.helicsFederateFinalize(fed) h.helicsFederateInfoFree(fi) h.helicsCloseLibrary() assert isfile(lfile) rm(lfile, force=True)
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_value_federate_runFederateTimeoutTest(helicsBroker): fedinitstring = "--broker=mainbroker --federates=1" deltat = 0.01 # Create Federate Info object that describes the federate properties # fedinfo = h.helicsCreateFederateInfo() # Set Federate name # h.helicsFederateInfoSetCoreName(fedinfo, "TestA Core") # Set core type from string # h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string # h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # Set the message interval (timedelta) for federate. Note th# # HELICS minimum message time interval is 1 ns and by default # it uses a time delta of 1 second. What is provided to the # setTimedelta routine is a multiplier for the default timedelta. # Set one second message interval # h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat) h.helicsFederateInfoSetIntegerProperty(fedinfo, h.helics_property_int_log_level, 1) vFed = h.helicsCreateValueFederate("TestA Federate", fedinfo) defaultValue = "String1" testValue = "String2" pubid = h.helicsFederateRegisterGlobalPublication( vFed, "pub1", h.helics_data_type_string, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsInputSetDefaultString(subid, defaultValue) h.helicsFederateEnterExecutingMode(vFed) counter = 60 while counter > 0: counter -= 1 time.sleep(1) # Broker should be connected at this point assert h.helicsBrokerIsConnected( helicsBroker) == 1, "Broker should still be connected" h.helicsFederateFinalize(vFed) state = h.helicsFederateGetState(vFed) assert state == 3 while (h.helicsBrokerIsConnected(helicsBroker)): time.sleep(1) h.helicsFederateInfoFree(fedinfo) h.helicsFederateFree(vFed)
def destroy_value_federate(fed): h.helicsFederateFinalize(fed) state = h.helicsFederateGetState(fed) h.helicsFederateFree(fed) h.helicsCloseLibrary()
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_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 destroyFederate(fed, fedinfo, broker=None): h.helicsFederateFinalize(fed) _ = h.helicsFederateGetState(fed) if broker is not None: while h.helicsBrokerIsConnected(broker): time.sleep(1) h.helicsFederateInfoFree(fedinfo) h.helicsFederateFree(fed) if broker is not None: destroyBroker(broker)
def vFed(): initstring = "-f 1 --name=mainbroker" fedinitstring = "--broker=mainbroker --federates=1" deltat = 0.01 #TODO: should add an assert here about helicsGetVersion h.helicsGetVersion() # Create broker # broker = h.helicsCreateBroker("zmq", "", initstring) isconnected = h.helicsBrokerIsConnected(broker) if isconnected == 1: pass # Create Federate Info object that describes the federate properties # fedinfo = h.helicsCreateFederateInfo() # Set Federate name # h.helicsFederateInfoSetCoreName(fedinfo, "TestA Core") # Set core type from string # h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string # h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # Set the message interval (timedelta) for federate. Note th# # HELICS minimum message time interval is 1 ns and by default # it uses a time delta of 1 second. What is provided to the # setTimedelta routine is a multiplier for the default timedelta. # Set one second message interval # h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat) h.helicsFederateInfoSetIntegerProperty(fedinfo, h.helics_property_int_log_level, 1) vFed = h.helicsCreateValueFederate("TestA Federate", fedinfo) yield vFed h.helicsFederateFinalize(vFed) state = h.helicsFederateGetState(vFed) assert state == 3 while (h.helicsBrokerIsConnected(broker)): time.sleep(1) h.helicsFederateInfoFree(fedinfo) h.helicsFederateFree(vFed) h.helicsCloseLibrary()
def init_manager(config_file_name, worker_name_list): print("manager in") fed = h.helicsCreateMessageFederateFromConfig(config_file_name) print("manager passed config") my_epid = h.helicsFederateGetEndpoint(fed, "data") log_id = h.helicsFederateGetEndpoint(fed, "logger") log_dest = h.helicsEndpointGetDefaultDestination(log_id) currenttime = -1 print("Manager about to Started") h.helicsFederateEnterExecutingMode(fed) print("Manager Started") for t in range(1, 11): h.helicsEndpointSendMessageRaw(log_id, log_dest, "Timestep {}".format(t)) message = "Hello World " + str(t) while currenttime < t: currenttime = h.helicsFederateRequestTime(fed, t) log_msg = "" ################### START TIMING ############### start_time = time.time_ns() / (10**9) ############################################## for worker_name in worker_name_list: h.helicsEndpointSendMessageRaw(my_epid, worker_name + "/data", message) while not (h.helicsEndpointPendingMessages(my_epid) == len(worker_name_list)): currenttime = h.helicsFederateRequestTime(fed, 0) for i in range(len(worker_name_list)): if h.helicsEndpointHasMessage(my_epid): new_message = h.helicsEndpointGetMessage(my_epid) log_msg = log_msg + "From: {} Msg: {} Time: {}\n".format( new_message.source, new_message.data, new_message.time) ################### END TIMING ################## end_time = time.time_ns() / (10**9) ############################################### time_taken = "Time taken for iteration " + str(t) + ": " + str( end_time - start_time) + "\n" h.helicsEndpointSendMessageRaw(log_id, log_dest, log_msg) h.helicsEndpointSendMessageRaw(log_id, log_dest, time_taken) fed_name = h.helicsFederateGetName(fed) h.helicsFederateFinalize(fed) # print("{}: Federate finalized".format(fed_name)) h.helicsFederateFree(fed) h.helicsCloseLibrary()
def destroy_value_federate(fed, broker): h.helicsFederateFinalize(fed) state = h.helicsFederateGetState(fed) while h.helicsBrokerIsConnected(broker): time.sleep(1) h.helicsFederateFree(fed) h.helicsCloseLibrary()
def test_bad_input_init_error(): broker = createBroker(1) vFed1, fedinfo = createValueFederate(1, "fed0") # register the publications # the types here don't match which causes an error when initializing the federation h.helicsFederateRegisterGlobalTypePublication(vFed1, "pub1", "custom1", "") subid = h.helicsFederateRegisterTypeInput(vFed1, "inp1", "custom2", "") k1 = h.helicsInputGetKey(subid) # check some other calls inp2 = h.helicsFederateGetInput(vFed1, "inp1") k2 = h.helicsInputGetKey(inp2) assert k1 == k2 inp3 = h.helicsFederateGetInputByIndex(vFed1, 0) k3 = h.helicsInputGetKey(inp3) assert k1 == k3 h.helicsInputAddTarget(subid, "pub1") h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0) # unknown publication with pt.raises(h.HelicsException): # @test_throws h.HELICSErrorInvalidArgument pub3 = h.helicsFederateGetPublication(vFed1, "unknown") # error in this call from the mismatch with pt.raises(h.HelicsException): # @test_throws h.HELICSErrorConnectionFailure h.helicsFederateEnterInitializingMode(vFed1) with pt.raises(h.HelicsException): # @test_throws h.HELICSErrorInvalidFunctionCall h.helicsFederateRequestTimeAdvance(vFed1, 0.1) # unknown input with pt.raises(h.HelicsException): # @test_throws h.HELICSErrorInvalidArgument inp4 = h.helicsFederateGetInput(vFed1, "unknown") # invalid input index # TODO: does this test segfault some times? with pt.raises(h.HelicsException): # @test_throws h.HELICSErrorInvalidArgument inp5 = h.helicsFederateGetInputByIndex(vFed1, 4) h.helicsFederateFinalize(vFed1) destroyFederate(vFed1, fedinfo) destroyBroker(broker)
def destroy_federate(fed): h.helicsFederateFinalize(fed) # status, state = h.helicsFederateGetState(fed) # assert state == 3 while (h.helicsBrokerIsConnected(broker)): time.sleep(1) h.helicsFederateFree(fed) h.helicsCloseLibrary()
def stop_simulation(self, *args, **kwargs): """ Disconnect the federate from helics core and close the library :return: """ try: h.helicsFederateFinalize(self.fed) h.helicsFederateFree(self.fed) h.helicsCloseLibrary() except h._helics.HelicsException as e: _log.exception("Error stopping HELICS federate {}".format(e))
def test_filter_test_file_load(): filename = os.path.join(CURRENT_DIRECTORY, "filters.json") mFed = h.helicsCreateMessageFederateFromConfig(filename) name = h.helicsFederateGetName(mFed) assert name == "filterFed" assert h.helicsFederateGetEndpointCount(mFed) == 3 h.helicsFederateFinalize(mFed) h.helicsCloseLibrary()
def test_system_test_federate_global_value(): brk = h.helicsCreateBroker("inproc", "gbrokerc", "--root") cr = h.helicsCreateCore("inproc", "gcore", "--broker=gbrokerc") argv = ["", "--corename=gcore"] fi = h.helicsCreateFederateInfo() h.helicsFederateInfoLoadFromArgs(fi, argv) fed = h.helicsCreateValueFederate("fed0", fi) fi2 = h.helicsFederateInfoClone(fi) h.helicsFederateInfoFree(fi2) h.helicsFederateInfoFree(fi) globalVal = "this is a string constant that functions as a global" globalVal2 = "this is a second string constant that functions as a global" h.helicsFederateSetGlobal(fed, "testglobal", globalVal) q = h.helicsCreateQuery("global", "testglobal") res = h.helicsQueryExecute(q, fed) assert res == globalVal h.helicsFederateSetGlobal(fed, "testglobal2", globalVal2) h.helicsQueryFree(q) q = h.helicsCreateQuery("global", "testglobal2") h.helicsQueryExecuteAsync(q, fed) while h.helicsQueryIsCompleted(q) is False: time.sleep(0.20) res = h.helicsQueryExecuteComplete(q) assert res == globalVal2 q2 = h.helicsCreateQuery("", "isinit") h.helicsQueryExecuteAsync(q2, fed) while h.helicsQueryIsCompleted(q2) is False: time.sleep(0.20) res = h.helicsQueryExecuteComplete(q2) assert str(res).lower() == "false" h.helicsFederateFinalize(fed) h.helicsCoreDisconnect(cr) h.helicsBrokerDisconnect(brk) h.helicsQueryFree(q) h.helicsQueryFree(q2) assert h.helicsBrokerIsConnected(brk) is False h.helicsBrokerDisconnect(brk) h.helicsCoreDisconnect(cr) assert h.helicsBrokerIsConnected(brk) is False h.helicsCloseLibrary()
def mFed(): initstring = "-f 1 --name=mainbroker" fedinitstring = "--broker=mainbroker --federates=1" deltat = 0.01 h.helicsGetVersion() # Create broker # broker = h.helicsCreateBroker("zmq", "", initstring) isconnected = h.helicsBrokerIsConnected(broker) if isconnected == 1: pass # Create Federate Info object that describes the federate properties # fedinfo = h.helicsCreateFederateInfo() # Set Federate name # h.helicsFederateInfoSetCoreName(fedinfo, "CoreA Federate") # Set core type from string # h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string # h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # Set the message interval (timedelta) for federate. Note th# # HELICS minimum message time interval is 1 ns and by default # it uses a time delta of 1 second. What is provided to the # setTimedelta routine is a multiplier for the default timedelta. # Set one second message interval # h.helicsFederateInfoSetTimeProperty(fedinfo, h.HELICS_PROPERTY_TIME_DELTA, deltat) h.helicsFederateInfoSetIntegerProperty(fedinfo, h.HELICS_PROPERTY_INT_LOG_LEVEL, 1) mFed = h.helicsCreateMessageFederate("TestA Federate", fedinfo) yield mFed h.helicsFederateFinalize(mFed) state = h.helicsFederateGetState(mFed) assert state == 3 while h.helicsBrokerIsConnected(broker): time.sleep(1) h.helicsFederateInfoFree(fedinfo) h.helicsFederateFree(mFed) h.helicsCloseLibrary()
def test_valuefederate_test_file_load(): filename = os.path.join(CURRENT_DIRECTORY, "valuefederate.json") vFed = h.helicsCreateValueFederateFromConfig(filename) name = h.helicsFederateGetName(vFed) assert name == "valueFed" assert h.helicsFederateGetInputCount(vFed) == 3 assert h.helicsFederateGetPublicationCount(vFed) == 2 h.helicsFederateFinalize(vFed) h.helicsFederateFree(vFed) h.helicsCloseLibrary()
h.helicsFederateEnterExecutingMode(vfed) print("PI SENDER: Entering execution mode") # This federate will be publishing deltat*pi for numsteps steps # this_time = 0.0 value = pi for t in range(5, 10): val = value currenttime = h.helicsFederateRequestTime(vfed, t) h.helicsPublicationPublishDouble(pub, val) print( "PI SENDER: Sending value pi = {} at time {} to PI RECEIVER".format( val, currenttime ) ) time.sleep(1) h.helicsFederateFinalize(vfed) print("PI SENDER: Federate finalized") while h.helicsBrokerIsConnected(broker): time.sleep(1) h.helicsFederateFree(vfed) h.helicsCloseLibrary() print("PI SENDER: Broker disconnected")