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_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_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 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_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 test_filter_type_tests_registration():
broker = createBroker(2)
fFed, fedinfo1 = createMessageFederate(1, "filter")
mFed, fedinfo2 = createMessageFederate(1, "message")
h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter2")
h.helicsFilterAddDestinationTarget(f2, "port2")
assert f1 != f2
_ = h.helicsFederateRegisterEndpoint(fFed, "fout", "")
f3 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"c4")
h.helicsFilterAddSourceTarget(f3, "Testfilter/fout")
f1_b = h.helicsFederateGetFilter(fFed, "filter1")
tmp = h.helicsFilterGetName(f1_b)
assert tmp == "Testfilter/filter1"
f1_c = h.helicsFederateGetFilterByIndex(fFed, 2)
tmp = h.helicsFilterGetName(f1_c)
assert tmp == "Testfilter/c4"
# @test_throws h.HELICSErrorInvalidArgument f1_n = h.helicsFederateGetFilterByIndex(fFed, -2)
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
h.helicsFederateFinalizeAsync(mFed)
h.helicsFederateFinalize(fFed)
h.helicsFederateFinalizeComplete(mFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(fFed, fedinfo1)
destroyFederate(mFed, fedinfo2)
destroyBroker(broker)
def test_filter_type_tests_info():
broker = createBroker(2)
fFed, fedinfo1 = createMessageFederate(1, "filter")
mFed, fedinfo2 = createMessageFederate(1, "message")
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
h.helicsEndpointSetInfo(p1, "p1_test")
h.helicsEndpointSetInfo(p2, "p2_test")
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
h.helicsFilterSetInfo(f1, "f1_test")
f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter2")
h.helicsFilterAddDestinationTarget(f2, "port2")
h.helicsFilterSetInfo(f2, "f2_test")
ep1 = h.helicsFederateRegisterEndpoint(fFed, "fout", "")
h.helicsEndpointSetInfo(ep1, "ep1_test")
f3 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"c4")
h.helicsFilterAddSourceTarget(f3, "filter0/fout")
h.helicsFilterSetInfo(f3, "f3_test")
assert h.helicsEndpointGetInfo(p1) == "p1_test"
assert h.helicsEndpointGetInfo(p2) == "p2_test"
assert h.helicsEndpointGetInfo(ep1) == "ep1_test"
assert h.helicsFilterGetInfo(f1) == "f1_test"
assert h.helicsFilterGetInfo(f2) == "f2_test"
assert h.helicsFilterGetInfo(f3) == "f3_test"
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
h.helicsFederateFinalizeAsync(mFed)
h.helicsFederateFinalize(fFed)
h.helicsFederateFinalizeComplete(mFed)
destroyFederate(fFed, fedinfo1)
destroyFederate(mFed, fedinfo2)
destroyBroker(broker)
def test_messagefederate_test_message_federate_endpoint_registration(mFed):
epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", "")
epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random")
h.helicsFederateEnterExecutingMode(mFed)
assert h.HELICS_STATE_EXECUTION == h.helicsFederateGetState(mFed)
endpoint_name = h.helicsEndpointGetName(epid1)
assert endpoint_name == "TestA Federate/ep1"
endpoint_name = h.helicsEndpointGetName(epid2)
assert endpoint_name == "ep2"
endpoint_name = h.helicsEndpointGetType(epid1)
assert endpoint_name == ""
endpoint_name = h.helicsEndpointGetType(epid2)
assert endpoint_name == "random"
epid_b = h.helicsFederateGetEndpoint(mFed, "ep2")
type = h.helicsEndpointGetType(epid_b)
assert type == "random"
epid_c = h.helicsFederateGetEndpointByIndex(mFed, 0)
name = h.helicsEndpointGetName(epid_c)
assert name == "TestA Federate/ep1"
def test_messagefederate_test_message_federate_send(mFed):
epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", "")
epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random")
h.helicsFederateSetTimeProperty(mFed, h.HELICS_PROPERTY_TIME_DELTA, 1.0)
h.helicsFederateEnterExecutingMode(mFed)
data = "random-data"
h.helicsEndpointSendEventRaw(epid1, "ep2", data, 1.0)
granted_time = h.helicsFederateRequestTime(mFed, 2.0)
assert granted_time == 1.0
res = h.helicsFederateHasMessage(mFed)
assert res is True
res = h.helicsEndpointHasMessage(epid1)
assert res is False
res = h.helicsEndpointHasMessage(epid2)
assert res is True
message = h.helicsEndpointGetMessage(epid2)
assert h.helicsMessageGetMessageID(message) == 55
assert h.helicsMessageIsValid(message) is True
assert h.helicsMessageGetString(message) == "random-data"
assert h.helicsMessageGetRawDataSize(message) == 11
assert h.helicsMessageGetOriginalDestination(message) == ""
assert h.helicsMessageGetOriginalSource(message) == "TestA Federate/ep1"
assert h.helicsMessageGetSource(message) == "TestA Federate/ep1"
assert h.helicsMessageGetTime(message) == 1.0
def test_message_federate_endpoint_registration(mFed):
epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", None)
epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random")
h.helicsFederateSetTimeDelta(mFed, 1.0)
h.helicsFederateEnterExecutionMode(mFed)
data = "random-data"
status = h.helicsEndpointSendEventRaw(epid1, "ep2", data, 1.0)
status, granted_time = h.helicsFederateRequestTime(mFed, 1.0)
assert granted_time == 1.0
res = h.helicsFederateHasMessage(mFed)
assert res == 1
res = h.helicsEndpointHasMessage(epid1)
# TODO: Figure out why this is returning zero
assert res == 0
res = h.helicsEndpointHasMessage (epid2)
assert res == 1
# This causes a segfault
message = h.helicsEndpointGetMessage(epid2)
assert message.data == 'random-data'
assert message.length == 11
assert message.original_dest == ''
assert message.original_source == 'TestA Federate/ep1'
assert message.source == 'TestA Federate/ep1'
assert message.time == 1.0
def test_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 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 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)
def test_message_filter_function(broker):
fFed = AddFederate(broker, "zmq", 1, 1, "filter")
mFed = AddFederate(broker, "zmq", 1, 1, "message")
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
f1 = h.helicsFederateRegisterSourceFilter(fFed, h.helics_delay_filter,
"port1", "filter1")
status = h.helicsFilterSet(f1, "delay", 2.5)
assert status == 0
status = h.helicsFederateEnterExecutionModeAsync(fFed)
assert status == 0
status = h.helicsFederateEnterExecutionMode(mFed)
assert status == 0
status = h.helicsFederateEnterExecutionModeComplete(fFed)
assert status == 0
status, state = h.helicsFederateGetState(fFed)
assert status == 0
assert state == 2
data = "hello world"
h.helicsEndpointSendMessageRaw(p1, "port2", data)
grantedtime = h.helicsFederateRequestTimeAsync(mFed, 1.0)
assert grantedtime == 0
status, grantedtime = h.helicsFederateRequestTime(fFed, 1.0)
assert status == 0
assert grantedtime == 1.0
status, grantedtime = h.helicsFederateRequestTimeComplete(mFed)
assert status == 0
assert grantedtime == 1.0
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)
FreeFederate(mFed)
time.sleep(1.0)
def test_messagefilter_registration():
broker = createBroker(2)
fFed, ffedinfo = createMessageFederate(1, "filter")
mFed, mfedinfo = createMessageFederate(1, "message")
h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter2")
h.helicsFederateRegisterEndpoint(fFed, "fout", "")
h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter0/fout")
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
filter_name = h.helicsFilterGetName(f1)
assert filter_name == "Testfilter/filter1"
filter_name = h.helicsFilterGetName(f2)
assert filter_name == "Testfilter/filter2"
# filter_target = h.helicsFilterGetTarget(f2)
# assert filter_target == "port2"
h.helicsFederateFinalize(mFed)
h.helicsFederateFinalize(fFed)
destroyFederate(fFed, ffedinfo)
destroyFederate(mFed, mfedinfo)
time.sleep(1.0)
destroyBroker(broker)
def test_message_filter_registration(broker):
fFed = AddFederate(broker, "zmq", 1, 1, "filter")
mFed = AddFederate(broker, "zmq", 1, 1, "message")
h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", None)
f1 = h.helicsFederateRegisterSourceFilter(fFed, h.helics_custom_filter,
"filter1", "port1")
f2 = h.helicsFederateRegisterDestinationFilter(fFed,
h.helics_custom_filter,
"filter2", "port2")
ep1 = h.helicsFederateRegisterEndpoint(fFed, "fout", "")
f3 = h.helicsFederateRegisterSourceFilter(fFed, h.helics_custom_filter, "",
"filter0/fout")
h.helicsFederateFinalize(mFed)
h.helicsFederateFinalize(fFed)
FreeFederate(fFed)
FreeFederate(mFed)
time.sleep(1.0)
def test_messagefederate_send_receive_2fed_multisend():
broker = createBroker(2)
mFed1, fedinfo1 = createMessageFederate(1, "A Federate")
mFed2, fedinfo2 = createMessageFederate(1, "B Federate")
epid1 = h.helicsFederateRegisterEndpoint(mFed1, "ep1", "")
epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed2, "ep2", "random")
h.helicsEndpointSetOption(epid1, h.HELICS_HANDLE_OPTION_IGNORE_INTERRUPTS,
True)
h.helicsFederateSetTimeProperty(mFed1, h.HELICS_PROPERTY_TIME_DELTA, 1.0)
h.helicsFederateSetTimeProperty(mFed2, h.HELICS_PROPERTY_TIME_DELTA, 1.0)
h.helicsFederateEnterExecutingModeAsync(mFed1)
h.helicsFederateEnterExecutingMode(mFed2)
h.helicsFederateEnterExecutingModeComplete(mFed1)
assert h.HELICS_STATE_EXECUTION == h.helicsFederateGetState(mFed1)
assert h.HELICS_STATE_EXECUTION == h.helicsFederateGetState(mFed2)
h.helicsEndpointSetDefaultDestination(epid1, "ep2")
h.helicsEndpointSendMessageRaw(epid1, "", "a".encode())
h.helicsEndpointSendMessageRaw(epid1, "", "a".encode())
h.helicsEndpointSendMessageRaw(epid1, "", "a".encode())
h.helicsFederateRequestTimeAsync(mFed1, 1.0)
granted_time = h.helicsFederateRequestTime(mFed2, 1.0)
complete_time = h.helicsFederateRequestTimeComplete(mFed1)
assert granted_time == 1.0
assert complete_time == 1.0
res = h.helicsEndpointPendingMessages(epid2)
assert res == 3
res = h.helicsFederatePendingMessages(mFed2)
assert res == 3
assert h.helicsEndpointGetDefaultDestination(epid1) == "ep2"
# FIXME: Someday this will be implemented.
# @test_broken h.helicsEndpointGetOption(epid1, h.HELICS_HANDLE_OPTION_IGNORE_INTERRUPTS) is True
destroyFederate(mFed1, fedinfo1)
destroyFederate(mFed2, fedinfo2)
destroyBroker(broker)
def test_message_federate_endpoint_registration(mFed):
epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", None)
epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random")
h.helicsFederateEnterExecutingMode(mFed)
endpoint_name = h.helicsEndpointGetName(epid1)
assert endpoint_name == "TestA Federate/ep1"
endpoint_name = h.helicsEndpointGetName(epid2)
assert endpoint_name == "ep2"
endpoint_name = h.helicsEndpointGetType(epid1)
assert endpoint_name == ""
endpoint_name = h.helicsEndpointGetType(epid2)
assert endpoint_name == "random"
def test_messagefederate_message_object_tests(mFed):
epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", "")
epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random")
h.helicsFederateSetTimeProperty(mFed, h.HELICS_PROPERTY_TIME_DELTA, 1.0)
h.helicsFederateEnterExecutingMode(mFed)
assert h.helicsFederateGetState(mFed) == h.HELICS_STATE_EXECUTION
msg = h.helicsFederateCreateMessage(mFed)
h.helicsMessageSetDestination(msg, "ep2")
h.helicsMessageGetDestination(msg) == "ep2"
h.helicsMessageSetData(msg, "".join(["a" for _ in range(0, 500)]).encode())
h.helicsMessageSetTime(msg, 0.0)
h.helicsEndpointSendMessage(epid1, msg)
t = h.helicsFederateRequestTime(mFed, 1.0)
assert t == 1.0
assert h.helicsFederateHasMessage(mFed) is True
assert h.helicsEndpointHasMessage(epid1) is False
assert h.helicsEndpointHasMessage(epid2) is True
msg = h.helicsEndpointGetMessage(epid2)
assert h.helicsMessageGetRawDataSize(msg) == 500
# TODO: segfaults
# print(h.helicsMessageGetRawData(msg))
# @test_broken False
# segfaults
# rawdata = h.helicsMessageGetRawDataPointer(msg)
# assert Char(unsafe_load(Ptr{Cchar}(rdata), 245)) == 'a'
h.helicsFederateFinalize(mFed)
assert h.helicsFederateGetState(mFed) == h.HELICS_STATE_FINALIZE
h.helicsMessageSetFlagOption(msg, 7, True)
assert h.helicsMessageCheckFlag(msg, 7) is True
h.helicsMessageClearFlags(msg)
assert h.helicsMessageCheckFlag(msg, 7) is False
h.helicsEndpointSetDefaultDestination(epid1, "ep2")
def test_message_federate_endpoint_registration(mFed):
epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", None)
epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random")
h.helicsFederateEnterExecutionMode(mFed)
status, endpoint_name = h.helicsEndpointGetName(epid1, 100)
assert status == 0
assert endpoint_name == "TestA Federate/ep1"
status, endpoint_name = h.helicsEndpointGetName(epid2, 100)
assert status == 0
assert endpoint_name == "ep2"
status, endpoint_name = h.helicsEndpointGetType(epid1, 100)
assert status == 0
assert endpoint_name == ""
status, endpoint_name = h.helicsEndpointGetType(epid2, 100)
assert status == 0
assert endpoint_name == "random"
def test_filter_test_types_message_filter_function3():
broker = createBroker(2)
fFed, fedinfo1 = createMessageFederate(1, "filter", 1)
mFed, fedinfo2 = createMessageFederate(1, "message", 1)
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "random")
f1 = h.helicsFederateRegisterGlobalFilter(fFed,
h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
f2 = h.helicsFederateRegisterGlobalFilter(fFed, h.HELICS_FILTER_TYPE_DELAY,
"filter2")
h.helicsFilterAddSourceTarget(f2, "port1")
h.helicsFederateRegisterEndpoint(fFed, "fout", "")
f3 = h.helicsFederateRegisterFilter(fFed,
h.HELICS_FILTER_TYPE_RANDOM_DELAY,
"filter3")
h.helicsFilterAddSourceTarget(f3, "filter0/fout")
h.helicsFilterSet(f2, "delay", 2.5)
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_EXECUTION
data = "hello world".encode()
h.helicsEndpointSendMessageRaw(p1, "port2", data)
h.helicsFederateRequestTimeAsync(mFed, 1.0)
h.helicsFederateRequestTime(fFed, 1.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsFederateHasMessage(mFed) is False
h.helicsEndpointSendMessageRaw(p2, "port1", data)
h.helicsFederateRequestTimeAsync(mFed, 2.0)
h.helicsFederateRequestTime(fFed, 2.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2) is False
# there may be something wrong here yet but this test isn't the one to find it and
# this may prevent spurious errors for now.
# std::this_thread::yield()
h.helicsFederateRequestTimeAsync(mFed, 3.0)
h.helicsFederateRequestTime(fFed, 3.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2)
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "port1"
assert h.helicsMessageGetOriginalSource(m2) == "port1"
assert h.helicsMessageGetDestination(m2) == "port2"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsMessageGetTime(m2) == 2.5
assert h.helicsEndpointHasMessage(p1) is True
h.helicsFederateFinalize(mFed)
h.helicsFederateFinalize(fFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(mFed, fedinfo1)
destroyFederate(fFed, fedinfo2)
destroyBroker(broker)
print("PI RECEIVER: Setting Federate Info Time Delta")
status = h.helicsFederateInfoSetPeriod(fedinfo, timePeriod)
print("PI RECEIVER: Setting Federate Info Logging")
status = h.helicsFederateInfoSetLoggingLevel(fedinfo, 1)
# Create value federate
print("PI RECEIVER: Creating Value Federate")
fed = h.helicsCreateCombinationFederate(fedinfo)
print("PI RECEIVER: Value federate created")
# Subscribe to PI SENDER's publication
sub = h.helicsFederateRegisterSubscription(fed, "testA", "double", "")
print("PI RECEIVER: Subscription registered")
epid = h.helicsFederateRegisterGlobalEndpoint(fed, "endpoint2", "")
status = h.helicsFederateEnterExecutionMode(fed)
print("PI RECEIVER: Entering execution mode")
value = 0.0
prevtime = 0
currenttime = h.helicsFederateRequestTime(fed, 100)[-1]
print("PI RECEIVER: Current time is {} ".format(currenttime))
isupdated = h.helicsSubscriptionIsUpdated(sub)
if isupdated == 1:
result, value = h.helicsSubscriptionGetDouble(sub)
print("PI RECEIVER: Received value = {} at time {} from PI SENDER".format(
def test_filter_test_types_function2():
broker = createBroker(2)
fFed, fedinfo1 = createMessageFederate(1, "filter")
mFed, fedinfo2 = createMessageFederate(1, "message")
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)
f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_DELAY,
"filter2")
h.helicsFilterAddSourceTarget(f2, "port2")
h.helicsFilterSet(f2, "delay", 2.5)
# this is expected to fail since a regular filter doesn't have a delivery endpoint
# @test_throws h.HELICSErrorInvalidObject h.helicsFilterAddDeliveryEndpoint(f2, "port1")
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)
res = h.helicsFederateHasMessage(mFed)
assert res is False
h.helicsEndpointSendMessageRaw(p2, "port1", data)
h.helicsFederateRequestTimeAsync(mFed, 2.0)
h.helicsFederateRequestTime(fFed, 2.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2) is False
# there may be something wrong here yet but this test isn't the one to find it and
# this may prevent spurious errors for now.
# std::this_thread::yield()
h.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
assert h.helicsEndpointHasMessage(p1) is False
h.helicsFederateRequestTime(mFed, 4.0)
assert h.helicsEndpointHasMessage(p1) is True
h.helicsFederateFinalizeAsync(mFed)
h.helicsFederateFinalize(fFed)
h.helicsFederateFinalizeComplete(mFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(fFed, fedinfo1)
destroyFederate(mFed, fedinfo2)
destroyBroker(broker)
def test_filter_test_types_clone_test_broker_dest_connections():
broker = createBroker(3)
sFed, fedinfo1 = createMessageFederate(1, "source", 1.0)
dFed, fedinfo2 = createMessageFederate(1, "dest", 1.0)
dcFed, fedinfo3 = createMessageFederate(1, "dest_clone", 1.0)
p1 = h.helicsFederateRegisterGlobalEndpoint(sFed, "src", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(dFed, "dest", "")
p3 = h.helicsFederateRegisterGlobalEndpoint(dcFed, "cm", "")
f1 = h.helicsFederateRegisterGlobalCloningFilter(dcFed, "filt1")
h.helicsFilterAddDeliveryEndpoint(f1, "cm")
h.helicsBrokerAddDestinationFilterToEndpoint(broker, "filt1", "dest")
h.helicsBrokerAddDestinationFilterToEndpoint(broker, "", "dest")
h.helicsFederateEnterExecutingModeAsync(sFed)
h.helicsFederateEnterExecutingModeAsync(dcFed)
h.helicsFederateEnterExecutingMode(dFed)
h.helicsFederateEnterExecutingModeComplete(sFed)
h.helicsFederateEnterExecutingModeComplete(dcFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "dest", data)
h.helicsFederateRequestTimeAsync(sFed, 1.0)
h.helicsFederateRequestTimeAsync(dcFed, 1.0)
h.helicsFederateRequestTime(dFed, 1.0)
h.helicsFederateRequestTimeComplete(sFed)
h.helicsFederateRequestTimeComplete(dcFed)
assert h.helicsFederateHasMessage(dFed) is True
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
h.helicsFederateFinalizeAsync(sFed)
h.helicsFederateFinalizeAsync(dFed)
# TODO: figure out why this test fails on CI
# @test_broken False
# assert h.helicsFederateHasMessage(dcFed) is False
# h.helicsFederateRequestTime(dcFed, 2.0)
# assert h.helicsFederateHasMessage(dcFed) is True
# m2 = h.helicsEndpointGetMessage(p3)
# assert h.helicsMessageGetSource(m2) == "src"
# assert h.helicsMessageGetOriginalSource(m2) == "src"
# assert h.helicsMessageGetDestination(m2) == "cm"
# assert h.helicsMessageGetOriginalDestination(m2) == "dest"
# assert h.helicsMessageGetRawDataSize(m2) == len(data)
# _ = h.helicsFederateHasMessage(dcFed)
h.helicsFederateFinalize(dcFed)
h.helicsFederateFinalizeComplete(sFed)
h.helicsFederateFinalizeComplete(dFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(sFed, fedinfo1)
destroyFederate(dFed, fedinfo2)
destroyFederate(dcFed, fedinfo3)
destroyBroker(broker)
def test_filter_callback_test():
broker = createBroker(2)
assert """helics.HelicsBroker(identifier = "mainbroker", address = "tcp://127.0.0.1:23404")""" in repr(
broker)
fFed, fedinfo1 = createMessageFederate(1, "filter", 1.0)
mFed, fedinfo2 = createMessageFederate(1, "message", 1.0)
h.helicsFederateSetFlagOption(mFed,
h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS,
True)
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
assert (
"""helics.HelicsEndpoint(name = "port1", type = "", info = "", is_valid = True, default_destination = "", n_pending_messages = 0)"""
in repr(p1))
assert (
"""helics.HelicsEndpoint(name = "port2", type = "", info = "", is_valid = True, default_destination = "", n_pending_messages = 0)"""
in repr(p2))
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
f2 = h.helicsFederateRegisterFilter(mFed, h.HELICS_FILTER_TYPE_DELAY,
"dfilter")
h.helicsFilterAddSourceTarget(f1, "port1")
assert 'name = "Testfilter/filter1"' in repr(f1)
userdata = UserData(5)
handle = h.ffi.new_handle(userdata)
h.helicsFilterSetCustomCallback(f1, filterFunc1, handle)
with pt.raises(h.HelicsException):
h.helicsFilterSetCustomCallback(f2, filterFunc1, handle)
assert (
"""helics.HelicsMessageFederate(name = "Testfilter", state = HelicsFederateState.STARTUP, current_time = -9223372036.854776, n_publications = 0, n_subscriptions = 0, n_endpoints = 0, n_filters = 1, n_pending_messages = 0)"""
in repr(fFed))
assert (
"""helics.HelicsMessageFederate(name = "Testmessage", state = HelicsFederateState.STARTUP, current_time = -9223372036.854776, n_publications = 0, n_subscriptions = 0, n_endpoints = 2, n_filters = 1, n_pending_messages = 0)"""
in repr(mFed))
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
assert (
"""helics.HelicsMessageFederate(name = "Testfilter", state = HelicsFederateState.EXECUTION, current_time = 0.0, n_publications = 0, n_subscriptions = 0, n_endpoints = 0, n_filters = 1, n_pending_messages = 0)"""
in repr(fFed))
assert (
"""helics.HelicsMessageFederate(name = "Testmessage", state = HelicsFederateState.EXECUTION, current_time = 0.0, n_publications = 0, n_subscriptions = 0, n_endpoints = 2, n_filters = 1, n_pending_messages = 0)"""
in repr(mFed))
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)
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_filter_test_types_clone_test_dest_connections():
broker = createBroker(3)
sFed, fedinfo1 = createMessageFederate(1, "source", 1.0)
dFed, fedinfo2 = createMessageFederate(1, "dest", 1.0)
dcFed, fedinfo3 = createMessageFederate(1, "dest_clone", 2.0)
p1 = h.helicsFederateRegisterGlobalEndpoint(sFed, "src", "")
_ = h.helicsFederateRegisterGlobalEndpoint(dFed, "dest", "")
_ = h.helicsFederateRegisterGlobalEndpoint(dcFed, "cm", "")
f1 = h.helicsFederateRegisterGlobalCloningFilter(dcFed, "filt1")
h.helicsFilterAddDeliveryEndpoint(f1, "cm")
cr = h.helicsFederateGetCoreObject(sFed)
h.helicsCoreAddDestinationFilterToEndpoint(cr, "filt1", "dest")
h.helicsCoreAddDestinationFilterToEndpoint(cr, "", "dest")
h.helicsCoreFree(cr)
h.helicsFederateEnterExecutingModeAsync(sFed)
h.helicsFederateEnterExecutingModeAsync(dcFed)
h.helicsFederateEnterExecutingMode(dFed)
h.helicsFederateEnterExecutingModeComplete(sFed)
h.helicsFederateEnterExecutingModeComplete(dcFed)
q = h.helicsCreateQuery("", "filtered_endpoints")
filteredEndpoints = h.helicsQueryExecute(q, dFed)
assert "cloningdestFilter" in str(filteredEndpoints)
h.helicsQueryFree(q)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "dest", data)
h.helicsFederateFinalize(sFed)
# TODO: implement threading
# auto dFedExec = [&]() {
# h.helicsFederateRequestTime(dFed, 1.0)
# m2 = h.helicsEndpointGetMessage(p2)
# h.helicsFederateFinalize(dFed, "")
# }
# h.helics_message m3
# auto dcFedExec = [&]() {
# h.helicsFederateRequestTime(dcFed, 2.0)
# auto res = h.helicsFederateHasMessage(dcFed)
# if (res == h.helics_False) {
# std::this_thread::sleep_for(std::chrono::milliseconds(50))
# h.helicsFederateRequestTime(dcFed, 4.0)
# }
# m3 = h.helicsEndpointGetMessage(p3)
# h.helicsFederateFinalize(dcFed)
# }
# auto threaddFed = std::thread(dFedExec)
# auto threaddcFed = std::thread(dcFedExec)
# threaddFed.join()
# (m2.source, "src")
# (m2.original_source, "src")
# (m2.dest, "dest")
# (m2.length, static_cast<int64_t>(data.size()))
# threaddcFed.join()
# (m3.source, "src")
# (m3.original_source, "src")
# (m3.dest, "cm")
# (m3.original_dest, "dest")
# (m3.length, static_cast<int64_t>(data.size()))
# (state = h.helicsFederateGetState(sFed))
# (state == h.helics_state_finalize)
destroyFederate(sFed, fedinfo1)
destroyFederate(dFed, fedinfo2)
destroyFederate(dcFed, fedinfo3)
destroyBroker(broker)
def test_filter_test_types_clone_test():
broker = createBroker(3)
sFed, fedinfo1 = createMessageFederate(1, "source", 1)
dFed, fedinfo2 = createMessageFederate(1, "dest", 1)
dcFed, fedinfo3 = createMessageFederate(1, "dest_clone", 1)
p1 = h.helicsFederateRegisterGlobalEndpoint(sFed, "src", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(dFed, "dest", "")
p3 = h.helicsFederateRegisterGlobalEndpoint(dcFed, "cm", "")
f1 = h.helicsFederateRegisterCloningFilter(dcFed, "")
h.helicsFilterAddDeliveryEndpoint(f1, "cm")
h.helicsFilterAddSourceTarget(f1, "src")
h.helicsFederateEnterExecutingModeAsync(sFed)
h.helicsFederateEnterExecutingModeAsync(dcFed)
h.helicsFederateEnterExecutingMode(dFed)
h.helicsFederateEnterExecutingModeComplete(sFed)
h.helicsFederateEnterExecutingModeComplete(dcFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_EXECUTION
state = h.helicsFederateGetState(dcFed)
assert state == h.HELICS_STATE_EXECUTION
state = h.helicsFederateGetState(dFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "dest", data)
h.helicsFederateRequestTimeAsync(sFed, 1.0)
h.helicsFederateRequestTimeAsync(dcFed, 1.0)
h.helicsFederateRequestTime(dFed, 1.0)
h.helicsFederateRequestTimeComplete(sFed)
h.helicsFederateRequestTimeComplete(dcFed)
assert h.helicsFederateHasMessage(dFed)
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsFederateHasMessage(dcFed)
m2 = h.helicsEndpointGetMessage(p3)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "cm"
assert h.helicsMessageGetOriginalDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
h.helicsFederateFinalizeAsync(sFed)
h.helicsFederateFinalizeAsync(dFed)
h.helicsFederateFinalize(dcFed)
h.helicsFederateFinalizeComplete(sFed)
h.helicsFederateFinalizeComplete(dFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(sFed, fedinfo1)
destroyFederate(dFed, fedinfo2)
destroyFederate(dcFed, fedinfo3)
destroyBroker(broker)
def test_filter_test_types_clone_test_connections():
broker = createBroker(3)
sFed, fedinfo1 = createMessageFederate(
1,
"source",
1.0,
)
dFed, fedinfo2 = createMessageFederate(1, "dest", 1.0)
dcFed, fedinfo3 = createMessageFederate(1, "dest_clone", 1.0)
p1 = h.helicsFederateRegisterGlobalEndpoint(sFed, "src", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(dFed, "dest", "")
p3 = h.helicsFederateRegisterGlobalEndpoint(dcFed, "cm", "")
f1 = h.helicsFederateRegisterGlobalCloningFilter(dcFed, "filt1")
h.helicsFilterAddDeliveryEndpoint(f1, "cm")
cr = h.helicsFederateGetCoreObject(sFed)
h.helicsCoreAddSourceFilterToEndpoint(cr, "filt1", "src")
h.helicsCoreAddSourceFilterToEndpoint(cr, "", "src")
h.helicsFederateEnterExecutingModeAsync(sFed)
h.helicsFederateEnterExecutingModeAsync(dcFed)
h.helicsFederateEnterExecutingMode(dFed)
h.helicsFederateEnterExecutingModeComplete(sFed)
h.helicsFederateEnterExecutingModeComplete(dcFed)
q = h.helicsCreateQuery("", "filtered_endpoints")
filteredEndpoints = h.helicsQueryExecute(q, sFed)
assert "srcFilters" in str(filteredEndpoints)
assert "(cloning)" in str(filteredEndpoints)
h.helicsQueryFree(q)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "dest", data)
h.helicsFederateRequestTimeAsync(sFed, 1.0)
h.helicsFederateRequestTimeAsync(dcFed, 1.0)
h.helicsFederateRequestTime(dFed, 1.0)
h.helicsFederateRequestTimeComplete(sFed)
h.helicsFederateRequestTimeComplete(dcFed)
assert h.helicsFederateHasMessage(dFed) is True
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsFederateHasMessage(dcFed) is True
m2 = h.helicsEndpointGetMessage(p3)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "cm"
assert h.helicsMessageGetOriginalDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
h.helicsFederateFinalizeAsync(sFed)
h.helicsFederateFinalizeAsync(dFed)
h.helicsFederateFinalize(dcFed)
h.helicsFederateFinalizeComplete(sFed)
h.helicsFederateFinalizeComplete(dFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(sFed, fedinfo1)
destroyFederate(dFed, fedinfo2)
destroyFederate(dcFed, fedinfo3)
destroyBroker(broker)
