def test_query_broker_tests(): broker = createBroker(2) vFed1, fedinfo1 = createValueFederate(1, "fed0") vFed2, fedinfo2 = createValueFederate(1, "fed1") core = h.helicsFederateGetCoreObject(vFed1) q1 = h.helicsCreateQuery("root", "federates") res = h.helicsQueryCoreExecute(q1, core) name1 = h.helicsFederateGetName(vFed1) name2 = h.helicsFederateGetName(vFed2) try: assert f"[{name1};{name2}]" == res except AssertionError: assert [name1, name2] == res res = h.helicsQueryExecute(q1, vFed1) try: assert f"[{name1};{name2}]" == res except AssertionError: assert [name1, name2] == res h.helicsFederateEnterInitializingModeAsync(vFed1) h.helicsFederateEnterInitializingMode(vFed2) h.helicsFederateEnterInitializingModeComplete(vFed1) h.helicsQueryFree(q1) h.helicsCoreFree(core) h.helicsFederateFinalizeAsync(vFed1) h.helicsFederateFinalize(vFed2) h.helicsFederateFinalizeComplete(vFed1) destroyFederate(vFed1, fedinfo1) destroyFederate(vFed2, fedinfo2) destroyBroker(broker)
def test_system_test_federate_global_value(): brk = h.helicsCreateBroker("inproc", "gbrokerc", "--root") cr = h.helicsCreateCore("inproc", "gcore", "--broker=gbrokerc") argv = ["", "--corename=gcore"] fi = h.helicsCreateFederateInfo() h.helicsFederateInfoLoadFromArgs(fi, argv) fed = h.helicsCreateValueFederate("fed0", fi) fi2 = h.helicsFederateInfoClone(fi) h.helicsFederateInfoFree(fi2) h.helicsFederateInfoFree(fi) globalVal = "this is a string constant that functions as a global" globalVal2 = "this is a second string constant that functions as a global" h.helicsFederateSetGlobal(fed, "testglobal", globalVal) q = h.helicsCreateQuery("global", "testglobal") res = h.helicsQueryExecute(q, fed) assert res == globalVal h.helicsFederateSetGlobal(fed, "testglobal2", globalVal2) h.helicsQueryFree(q) q = h.helicsCreateQuery("global", "testglobal2") h.helicsQueryExecuteAsync(q, fed) while h.helicsQueryIsCompleted(q) is False: time.sleep(0.20) res = h.helicsQueryExecuteComplete(q) assert res == globalVal2 q2 = h.helicsCreateQuery("", "isinit") h.helicsQueryExecuteAsync(q2, fed) while h.helicsQueryIsCompleted(q2) is False: time.sleep(0.20) res = h.helicsQueryExecuteComplete(q2) assert str(res).lower() == "false" h.helicsFederateFinalize(fed) h.helicsCoreDisconnect(cr) h.helicsBrokerDisconnect(brk) h.helicsQueryFree(q) h.helicsQueryFree(q2) assert h.helicsBrokerIsConnected(brk) is False h.helicsBrokerDisconnect(brk) h.helicsCoreDisconnect(cr) assert h.helicsBrokerIsConnected(brk) is False h.helicsCloseLibrary()
def 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_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)
def eval_data_flow_graph(fed): query = h.helicsCreateQuery("broker", "data_flow_graph") data_flow_graph = h.helicsQueryExecute(query, fed) #logger.debug(f'Data flow graph: {data_flow_graph}') # Processing data flow graph to confirm correct configuration graph = json.loads(data_flow_graph) handle_lut = {} federates_lut = {} for core in graph['cores']: # Build handle and federate look-up table # The data flow graph that is produced identifies input sources # by "handle" an index for all handles in a given federate. For # human comprehension, I'm building a look-up table that matches # handle ID and handle name. Because the handle index is federate # specific I'm going to build a unique key for the look-up table # Formatted <federate Id>-<handle ID> # # I'll build a similar look-up table for federate IDs and names # but the federate IDs are globally unique so it will be simpler # Assume only one federate per core, index "0". Since I built this # federation I know this is true and in most federations it # will also be true. federates_lut[core['federates'][0] ['id']] = core['federates'][0]['name'] # Endpoints, inputs, and publications all are considered handles # BUT only endpoints and publications contain the mapping # between handle ID and handle name if 'endpoints' in core['federates'][0]: for ep in core['federates'][0]['endpoints']: key = f'{ep["federate"]}-{ep["handle"]}' handle_lut[key] = ep['key'] if 'publications' in core['federates'][0]: for pub in core['federates'][0]['publications']: key = f'{pub["federate"]}-{pub["handle"]}' handle_lut[key] = pub['key'] # logger.debug(f'handle_lut: \n{pp.pformat(handle_lut)}') # Now that I've got the look-up tables in place, re-traversing the # graph to log out a simplified human-readable version for core in graph['cores']: if 'inputs' in core['federates'][0]: logger.debug(f'Federate {core["federates"][0]["name"]}' f' (with id {core["federates"][0]["id"]})' f' has the following subscriptions:') for input in core['federates'][0]['inputs']: # Assume only no more than one source per input, index "0" # This is usually true but multi-source inputs are a thing. if "sources" in input: source_key = f'{input["sources"][0]["federate"]}-' \ f'{input["sources"][0]["handle"]}' logger.debug( f'\t{handle_lut[source_key]} from federate' f' {federates_lut[input["sources"][0]["federate"]]}') else: # Input has no defined source logger.warning(f'\tSubscription found with no source ' f'defined') return graph, federates_lut, handle_lut