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)
