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_value_federate_runFederateTestDouble(vFed): defaultValue = 1.0 testValue = 2.0 pubid = h.helicsFederateRegisterGlobalTypePublication( vFed, "pub1", h.HELICS_DATA_TYPE_DOUBLE, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "double", "") h.helicsSubscriptionSetDefaultDouble(subid, defaultValue) h.helicsFederateEnterExecutionMode(vFed) # publish string1 at time=0.0; h.helicsPublicationPublishDouble(pubid, testValue) status, value = h.helicsSubscriptionGetDouble(subid) assert value == defaultValue status, grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 status, value = h.helicsSubscriptionGetDouble(subid) assert value == testValue # publish string1 at time=0.0; h.helicsPublicationPublishDouble(pubid, testValue + 1) status, grantedtime = h.helicsFederateRequestTime(vFed, 2.0) assert grantedtime == 0.02 status, value = h.helicsSubscriptionGetDouble(subid) assert value == testValue + 1
def test_valuefederate_test_integer(): broker = createBroker() vFed, fedinfo = createValueFederate() defaultValue = 1 testValue = 2 pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.HELICS_DATA_TYPE_INT, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsInputSetDefaultInteger(subid, defaultValue) h.helicsFederateEnterExecutingMode(vFed) h.helicsPublicationPublishInteger(pubid, testValue) value = h.helicsInputGetInteger(subid) assert value == defaultValue grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 value = h.helicsInputGetInteger(subid) assert value == testValue h.helicsPublicationPublishInteger(pubid, testValue + 1) grantedtime = h.helicsFederateRequestTime(vFed, 2.0) assert grantedtime == 0.02 value = h.helicsInputGetInteger(subid) assert value == testValue + 1 destroyFederate(vFed, 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) h.helicsFederateRequestTime(fed, maxtime) ideal_time_data = h.helicsEndpointGetMessage(my_epid) if h.helicsEndpointHasMessage(my_epid): output = output + "ideal simulation time " + ideal_time_data.data + "\n" 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(output) h.helicsFederateFinalize(fed) print(fed_name, " : Federate finalized") h.helicsFederateFree(fed) h.helicsCloseLibrary()
def test_federate_tests_federateGeneratedGlobalError(): brk = h.helicsCreateBroker("inproc", "gbrokerc", "--root") cr = h.helicsCreateCore("inproc", "gcore", "--broker=gbrokerc") argv = ["", "--corename=gcore"] fi = h.helicsCreateFederateInfo() h.helicsFederateInfoLoadFromArgs(fi, argv) fed1 = h.helicsCreateValueFederate("fed0", fi) h.helicsFederateInfoFree(fi) h.helicsFederateEnterExecutingMode(fed1) h.helicsFederateRequestTime(fed1, 2.0) h.helicsFederateGlobalError(fed1, 9827, "user generated global error") with pt.raises(h.HelicsException): h.helicsFederateRequestTime(fed1, 3.0) h.helicsFederateDestroy(fed1) h.helicsCoreDisconnect(cr) h.helicsBrokerDisconnect(brk) h.helicsCloseLibrary()
def test_value_federate_runFederateTestDouble(vFed): defaultValue = 1.0 testValue = 2.0 pubid = h.helicsFederateRegisterGlobalPublication( vFed, "pub1", h.helics_data_type_double, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsInputSetDefaultDouble(subid, defaultValue) h.helicsFederateEnterExecutingMode(vFed) # publish string1 at time=0.0; h.helicsPublicationPublishDouble(pubid, testValue) value = h.helicsInputGetDouble(subid) assert value == defaultValue grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 value = h.helicsInputGetDouble(subid) assert value == testValue # publish string1 at time=0.0; h.helicsPublicationPublishDouble(pubid, testValue + 1) grantedtime = h.helicsFederateRequestTime(vFed, 2.0) assert grantedtime == 0.02 value = h.helicsInputGetDouble(subid) assert value == testValue + 1
def test_value_federate_runFederateTestInteger(vFed): defaultValue = 1 testValue = 2 pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.helics_data_type_int, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsInputSetDefaultInteger(subid, defaultValue) h.helicsFederateEnterExecutingMode(vFed) h.helicsPublicationPublishInteger(pubid, testValue) value = h.helicsInputGetInteger(subid) assert value == defaultValue grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 value = h.helicsInputGetInteger(subid) assert value == testValue h.helicsPublicationPublishInteger(pubid, testValue + 1) grantedtime = h.helicsFederateRequestTime(vFed, 2.0) assert grantedtime == 0.02 value = h.helicsInputGetInteger(subid) assert value == testValue + 1
def test_value_federate_runFederateTestInteger(vFed): defaultValue = 1 testValue = 2 pubid = h.helicsFederateRegisterGlobalTypePublication( vFed, "pub1", h.HELICS_DATA_TYPE_INT, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "int", "") h.helicsSubscriptionSetDefaultInteger(subid, defaultValue) h.helicsFederateEnterExecutionMode(vFed) h.helicsPublicationPublishInteger(pubid, testValue) status, value = h.helicsSubscriptionGetInteger(subid) assert value == defaultValue status, grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 status, value = h.helicsSubscriptionGetInteger(subid) assert value == testValue h.helicsPublicationPublishInteger(pubid, testValue + 1) status, grantedtime = h.helicsFederateRequestTime(vFed, 2.0) assert grantedtime == 0.02 status, value = h.helicsSubscriptionGetInteger(subid) assert value == testValue + 1
def test_value_federate_runFederateTestNamedPoint(vFed): defaultValue = ( "start of a longer string in place of the shorter one and now this should be very long" ) defVal = 5.3 # testValue1 = "inside of the functional relationship of helics" testValue1 = "short string" testVal1 = 45.7823 testValue2 = "I am a string" testVal2 = 0.0 pubid = h.helicsFederateRegisterGlobalPublication( vFed, "pub1", h.helics_data_type_named_point, "" ) subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsInputSetDefaultNamedPoint(subid, defaultValue, defVal) h.helicsFederateEnterExecutingMode(vFed) # publish string1 at time=0.0; h.helicsPublicationPublishNamedPoint(pubid, testValue1, testVal1) # double val; val = h.helicsInputGetNamedPoint(subid) # assert value == defaultValue assert val == [defaultValue, defVal] grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 # get the value val2 = h.helicsInputGetNamedPoint(subid) # make sure the string is what we expect # assert value2 == testValue1 assert val2 == [testValue1, testVal1] # publish a second string h.helicsPublicationPublishNamedPoint(pubid, testValue2, testVal2) # make sure the value is still what we expect val3 = h.helicsInputGetNamedPoint(subid) # make sure the string is what we expect # assert value3 == testValue1 assert val3 == [testValue1, testVal1] # advance time grantedtime = h.helicsFederateRequestTime(vFed, 2.0) assert grantedtime == 0.02 # make sure the value was updated val4 = h.helicsInputGetNamedPoint(subid) # make sure the string is what we expect # assert value4 == testValue2 assert val4 == [testValue2, testVal2]
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 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 request_time_increment(self): error = sum([ abs(y["dStates"][0] - y["dStates"][1]) for k, x in self.Subscriptions.items() for y in x ]) r_seconds = self.Solver.GetTotalSeconds() if not self.settings['helics']['coiter_mode']: while self.c_seconds < r_seconds: self.c_seconds = h.helicsFederateRequestTime( self.cymeFederate, r_seconds) self.__Logger.info('Time requested: {} - time granted: {} '.format( r_seconds, self.c_seconds)) return True, self.c_seconds else: self.c_seconds, iteration_state = h.helicsFederateRequestTimeIterative( self.cymeFederate, r_seconds, h.helics_iteration_request_iterate_if_needed) self.__Logger.info( 'Time requested: {} - time granted: {} error: {} it: {}'. format(r_seconds, self.c_seconds, error, self.itr)) if error > -1 and self.itr < self.settings['helics']["max_coiter"]: self.itr += 1 return False, self.c_seconds else: self.itr = 0 return True, self.c_seconds
def test_valuefederate_test_single_transfer(): broker = createBroker() vFed, fedinfo = createValueFederate() s = "n2" pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.HELICS_DATA_TYPE_STRING, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsFederateEnterExecutingMode(vFed) h.helicsPublicationPublishString(pubid, "string1") grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 s = h.helicsInputGetString(subid) assert s == "string1" t = h.helicsInputLastUpdateTime(subid) assert t == 0.01 h.helicsPublicationPublishString(pubid, "string2") destroyFederate(vFed, fedinfo) destroyBroker(broker)
def test_valuefederate_test_vectord(): broker = createBroker() vFed, fedinfo = createValueFederate() defaultValue = [0.0, 1.0, 2.0] testValue = [3.0, 4.0, 5.0] pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.HELICS_DATA_TYPE_VECTOR, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsInputSetDefaultVector(subid, defaultValue) h.helicsFederateEnterExecutingMode(vFed) h.helicsPublicationPublishVector(pubid, testValue) assert h.helicsInputGetVector(subid) == defaultValue grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 value = h.helicsInputGetVector(subid) assert value == testValue destroyFederate(vFed, fedinfo) destroyBroker(broker)
def test_valuefederate_test_string(): broker = createBroker() vFed, fedinfo = createValueFederate() 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) h.helicsPublicationPublishString(pubid, testValue) value = h.helicsInputGetString(subid) assert value == defaultValue grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 value = h.helicsInputGetString(subid) assert value == testValue destroyFederate(vFed, fedinfo) destroyBroker(broker)
def test_valuefederate_test_complex(): broker = createBroker() vFed, fedinfo = createValueFederate() rDefaultValue = 1.0 iDefaultValue = 1.0 rTestValue = 2.0 iTestValue = 2.0 pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.HELICS_DATA_TYPE_COMPLEX, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsInputSetDefaultComplex(subid, complex(rDefaultValue, iDefaultValue)) h.helicsFederateEnterExecutingMode(vFed) # publish string1 at time=0.0 h.helicsPublicationPublishComplex(pubid, complex(rTestValue, iTestValue)) assert (rDefaultValue, iDefaultValue) == h.helicsInputGetComplex(subid) grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 assert (rTestValue, iTestValue) == h.helicsInputGetComplex(subid) destroyFederate(vFed, fedinfo) destroyBroker(broker)
def test_value_federate_runFederateTestComplex(vFed): rDefaultValue = 1.0 iDefaultValue = 1.0 rTestValue = 2.0 iTestValue = 2.0 pubid = h.helicsFederateRegisterGlobalTypePublication( vFed, "pub1", h.HELICS_DATA_TYPE_COMPLEX, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "double", "") h.helicsSubscriptionSetDefaultComplex(subid, rDefaultValue, iDefaultValue) h.helicsFederateEnterExecutionMode(vFed) # publish string1 at time=0.0; h.helicsPublicationPublishComplex(pubid, rTestValue, iTestValue) status, value1, value2 = h.helicsSubscriptionGetComplex(subid) assert value1 == rDefaultValue assert value2 == iDefaultValue status, grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 status, value1, value2 = h.helicsSubscriptionGetComplex(subid) assert value1 == rTestValue assert value2 == iTestValue
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_value_federate_runFederateTestComplex(vFed): rDefaultValue = 1.0 iDefaultValue = 1.0 rTestValue = 2.0 iTestValue = 2.0 pubid = h.helicsFederateRegisterGlobalPublication( vFed, "pub1", h.helics_data_type_complex, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsInputSetDefaultComplex(subid, rDefaultValue, iDefaultValue) h.helicsFederateEnterExecutingMode(vFed) # publish string1 at time=0.0; h.helicsPublicationPublishComplex(pubid, rTestValue, iTestValue) value1, value2 = h.helicsInputGetComplex(subid) assert value1 == rDefaultValue assert value2 == iDefaultValue grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 value1, value2 = h.helicsInputGetComplex(subid) assert value1 == rTestValue assert value2 == iTestValue
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 request_time_increment(self): error = sum( [abs(x[0] - x[1]) for k, x in self._subscription_dState.items()]) r_seconds = self._dss_solver.GetTotalSeconds( ) #- self._dss_solver.GetStepResolutionSeconds() if not self._settings.helics.iterative_mode: while self.c_seconds < r_seconds: self.c_seconds = helics.helicsFederateRequestTime( self._PyDSSfederate, r_seconds) self._logger.info('Time requested: {} - time granted: {} '.format( r_seconds, self.c_seconds)) return True, self.c_seconds else: self.c_seconds, iteration_state = helics.helicsFederateRequestTimeIterative( self._PyDSSfederate, r_seconds, helics.helics_iteration_request_iterate_if_needed) self._logger.info( 'Time requested: {} - time granted: {} error: {} it: {}'. format(r_seconds, self.c_seconds, error, self.itr)) if error > -1 and self.itr < self._co_convergance_max_iterations - 1: self.itr += 1 return False, self.c_seconds else: self.itr = 0 return True, self.c_seconds
def main(delay=None): broker = create_broker() fed = create_value_federate(broker) pubid = h.helicsFederateRegisterGlobalTypePublication( fed, "federate1-to-federate2", h.HELICS_DATA_TYPE_STRING, "") subid = h.helicsFederateRegisterSubscription(fed, "federate2-to-federate1", "double", "") epid = h.helicsFederateRegisterGlobalEndpoint(fed, "endpoint1", "") if delay is not None: fid = h.helicsFederateRegisterSourceFilter(fed, h.helics_delay_filter, "endpoint2", "filter-name") h.helicsSubscriptionSetDefaultDouble(subid, 0) print("Entering execution mode") h.helicsFederateEnterExecutionMode(fed) if delay is not None: h.helicsFilterSet(fid, "delay", 2.0) grantedtime = -1 while True: try: stop_at_time, value_to_send = get_input(grantedtime) except KeyboardInterrupt: print("") break while grantedtime < stop_at_time: print(">>>>>>>> Requesting time = {}".format(stop_at_time)) status, grantedtime = h.helicsFederateRequestTime( fed, stop_at_time) assert status == 0 if grantedtime != stop_at_time: status, value = h.helicsSubscriptionGetString(subid) assert status == 0 print("Interrupt value '{}' from Federate 2".format(value)) print("<<<<<<<< Granted Time = {}".format(grantedtime)) assert grantedtime == stop_at_time, "stop_at_time = {}, grantedtime = {}".format( stop_at_time, grantedtime) if value_to_send is not None and value_to_send != '': print("Sending '{}' to Federate 2".format(value_to_send)) status = h.helicsPublicationPublishString(pubid, str(value_to_send)) assert status == 0 status = h.helicsEndpointSendMessageRaw(epid, "endpoint2", str(value_to_send)) assert status == 0 status, value = h.helicsSubscriptionGetString(subid) assert status == 0 print("Received value '{}' from Federate 2".format(value)) while h.helicsEndpointHasMessage(epid): value = h.helicsEndpointGetMessage(epid) print("Received message '{}' at time {} from Federate 2".format( value.data, value.time)) print("----------------------------------") destroy_value_federate(fed, broker)
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 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_valuefederate_test_bool(): broker = createBroker() vFed, fedinfo = createValueFederate() defaultValue = True testValue1 = True testValue2 = False # register the publications pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.HELICS_DATA_TYPE_BOOLEAN, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsInputSetDefaultBoolean(subid, defaultValue) h.helicsFederateEnterExecutingMode(vFed) # publish string1 at time=0.0 h.helicsPublicationPublishBoolean(pubid, testValue1) val = h.helicsInputGetBoolean(subid) assert val == defaultValue grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 # get the value val = h.helicsInputGetBoolean(subid) # make sure the string is what we expect assert val == testValue1 # publish a second string h.helicsPublicationPublishBoolean(pubid, testValue2) # make sure the value is still what we expect val = h.helicsInputGetBoolean(subid) assert val == testValue1 # advance time grantedtime = h.helicsFederateRequestTime(vFed, 2.0) # make sure the value was updated assert grantedtime == 0.02 val = h.helicsInputGetBoolean(subid) assert val == testValue2 destroyFederate(vFed, fedinfo) destroyBroker(broker)
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_valuefederate_named_point(): broker = createBroker() vFed, fedinfo = createValueFederate() defaultValue = "start of a longer string in place of the shorter one and now this should be very long" defVal = 5.3 # testValue1 = "inside of the functional relationship of helics" testValue1 = "short string" testVal1 = 45.7823 testValue2 = "I am a string" testVal2 = 0.0 pubid = h.helicsFederateRegisterGlobalPublication(vFed, "pub1", h.HELICS_DATA_TYPE_NAMED_POINT, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsInputSetDefaultNamedPoint(subid, defaultValue, defVal) h.helicsFederateEnterExecutingMode(vFed) # publish string1 at time=0.0 h.helicsPublicationPublishNamedPoint(pubid, testValue1, testVal1) assert h.helicsInputGetNamedPoint(subid) == (defaultValue, defVal) assert h.helicsFederateRequestTime(vFed, 1.0) == 0.01 # # get the value assert h.helicsInputGetNamedPoint(subid) == (testValue1, testVal1) # publish a second string h.helicsPublicationPublishNamedPoint(pubid, testValue2, testVal2) # # make sure the value is still what we expect assert h.helicsInputGetNamedPoint(subid) == (testValue1, testVal1) # # make sure the string is what we expect # # assert value3 == testValue1 # assert val3 == [testValue1, testVal1] # # advance time assert h.helicsFederateRequestTime(vFed, 2.0) == 0.02 # # make sure the value was updated assert h.helicsInputGetNamedPoint(subid) == (testValue2, testVal2) destroyFederate(vFed, fedinfo) destroyBroker(broker)
def test_value_federate_runFederateTestBool(vFed): defaultValue = True testValue1 = True testValue2 = False # register the publications pubid = h.helicsFederateRegisterGlobalPublication( vFed, "pub1", h.helics_data_type_boolean, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsInputSetDefaultBoolean( subid, h.helics_true if defaultValue else h.helics_false) h.helicsFederateEnterExecutingMode(vFed) # publish string1 at time=0.0; h.helicsPublicationPublishBoolean( pubid, h.helics_true if testValue1 else h.helics_false) val = h.helicsInputGetBoolean(subid) assert val == h.helics_true if defaultValue else h.helics_false grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 # get the value val = h.helicsInputGetBoolean(subid) # make sure the string is what we expect assert val == h.helics_true if testValue1 else h.helics_false # publish a second string h.helicsPublicationPublishBoolean( pubid, h.helics_true if testValue2 else h.helics_false) # make sure the value is still what we expect val = h.helicsInputGetBoolean(subid) assert val == h.helics_true if testValue1 else h.helics_false # advance time grantedtime = h.helicsFederateRequestTime(vFed, 2.0) # make sure the value was updated assert grantedtime == 0.02 val = h.helicsInputGetBoolean(subid) assert val == h.helics_false if testValue2 else h.helics_true
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 main(delay=None): broker = create_broker() fed = create_value_federate(broker) pubid = h.helicsFederateRegisterGlobalTypePublication( fed, "federate1-to-federate2", "string", "") subid = h.helicsFederateRegisterSubscription(fed, "federate2-to-federate1", "") epid = h.helicsFederateRegisterGlobalEndpoint(fed, "endpoint1", "") if delay is not None: fid = h.helicsFederateRegisterGlobalFilter(fed, h.helics_filter_type_delay, "filter-name") h.helicsFilterAddSourceTarget(fid, "endpoint1") h.helicsInputSetDefaultNamedPoint(subid, "", 0) print("Entering execution mode") h.helicsFederateEnterExecutingMode(fed) if delay is not None: h.helicsFilterSet(fid, "delay", delay) grantedtime = -1 while True: try: stop_at_time, value_to_send = get_input(grantedtime) print(stop_at_time) except KeyboardInterrupt: print("") break while grantedtime < stop_at_time: print(">>>>>>>> Requesting time = {}".format(stop_at_time)) grantedtime = h.helicsFederateRequestTime(fed, stop_at_time) grantedtime = int(grantedtime) if grantedtime != stop_at_time: value = h.helicsSubscriptionGetKey(subid) print("Interrupt value '{}' from Federate 2".format(value)) print("<<<<<<<< Granted Time = {}".format(grantedtime)) assert (grantedtime == stop_at_time ), "stop_at_time = {}, grantedtime = {}".format( stop_at_time, grantedtime) if value_to_send is not None and value_to_send != "": print("Sending '{}' to Federate 2".format(value_to_send)) h.helicsPublicationPublishString(pubid, str(value_to_send)) h.helicsEndpointSendMessageRaw(epid, "endpoint2", str(value_to_send)) value = h.helicsSubscriptionGetKey(subid) print("Received value '{}' from Federate 2".format(value)) while h.helicsEndpointHasMessage(epid): value = h.helicsEndpointGetMessage(epid) print("Received message '{}' at time {} from Federate 2".format( value.data, value.time)) print("----------------------------------") destroy_value_federate(fed, broker)
# Register the publication # pub = h.helicsFederateRegisterGlobalTypePublication(vfed, "testA", "double", "") print("PI SENDER: Publication registered") # Enter execution mode # 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)