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_system_tests_federate_logging(): lfile = "log.txt" rm(lfile, force=True) core = h.helicsCreateCore("inproc", "clogf", "--autobroker --log_level=trace") fi = h.helicsCreateFederateInfo() h.helicsFederateInfoSetBrokerKey(fi, "key") h.helicsFederateInfoSetCoreName(fi, "clogf") fed = h.helicsCreateValueFederate("f1", fi) h.helicsFederateSetLogFile(fed, lfile) h.helicsFederateLogLevelMessage(fed, 7, "hello") h.helicsFederateLogErrorMessage(fed, "hello") h.helicsFederateLogDebugMessage(fed, "hello") h.helicsFederateLogWarningMessage(fed, "hello") h.helicsFederateClearMessages(fed) h.helicsCoreSetLogFile(core, lfile) h.helicsCoreDisconnect(core) h.helicsFederateFinalize(fed) h.helicsFederateInfoFree(fi) h.helicsCloseLibrary() assert isfile(lfile) rm(lfile, force=True)
def setupFederateInfo(name="A Core", number=1, deltat=0.01): fedinitstring = f"--broker=mainbroker --federates={number}" # Create Federate Info object that describes the federate properties fedinfo = h.helicsCreateFederateInfo() # assert fedinfo isa h.FederateInfo # # Set Federate name h.helicsFederateInfoSetCoreName(fedinfo, f"Test{name}") # # Set core type from string h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # # Federate init string h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # # Set the message interval (timedelta) for federate. Note th# # # HELICS minimum message time interval is 1 ns and by default # # it uses a time delta of 1 second. What is provided to the # # setTimedelta routine is a multiplier for the default timedelta. # # Set one second message interval h.helicsFederateInfoSetTimeProperty(fedinfo, h.HELICS_PROPERTY_TIME_DELTA, deltat) h.helicsFederateInfoSetIntegerProperty(fedinfo, h.HELICS_PROPERTY_INT_LOG_LEVEL, -1) return fedinfo
def create_helics_federate(self): self.fedName = self.settings['helics']['federate_name'] self.fedinfo = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreName( self.fedinfo, self.settings['helics']['federate_name']) h.helicsFederateInfoSetCoreTypeFromString( self.fedinfo, self.settings['helics']['core_type']) h.helicsFederateInfoSetCoreInitString(self.fedinfo, f"--federates=1") h.helicsFederateInfoSetBroker(self.fedinfo, self.settings['helics']['broker']) h.helicsFederateInfoSetBrokerPort( self.fedinfo, self.settings['helics']['broker_port']) h.helicsFederateInfoSetTimeProperty( self.fedinfo, h.helics_property_time_delta, self.settings['helics']['time_delta']) h.helicsFederateInfoSetIntegerProperty( self.fedinfo, h.helics_property_int_log_level, self.settings['helics']['helics_logging_level']) #h.helicsFederateInfoSetFlagOption(self.fedinfo, h.helics_flag_uninterruptible, True) h.helicsFederateInfoSetIntegerProperty( self.fedinfo, h.helics_property_int_max_iterations, self.settings["helics"]["max_coiter"]) self.cymeFederate = h.helicsCreateValueFederate( self.settings['helics']['federate_name'], self.fedinfo) return
def AddFederate(broker, core_type="zmq", count=1, deltat=1.0, name_prefix="fed"): # Create Federate Info object that describes the federate properties # fedinfo = h.helicsCreateFederateInfo() # Set Federate name # h.helicsFederateInfoSetCoreName(fedinfo, name_prefix) # Set core type from string # h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string # fedinitstring = "--broker=mainbroker --federates={}".format(count) h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # Set the message interval (timedelta) for federate. Note th# # HELICS minimum message time interval is 1 ns and by default # it uses a time delta of 1 second. What is provided to the # setTimedelta routine is a multiplier for the default timedelta. # Set one second message interval # h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat) h.helicsFederateInfoSetIntegerProperty(fedinfo, h.helics_property_int_log_level, 1) mFed = h.helicsCreateMessageFederate(name_prefix, fedinfo) return mFed, fedinfo
def _create_helics_federate(self): self.fedinfo = helics.helicsCreateFederateInfo() helics.helicsFederateInfoSetCoreName( self.fedinfo, self._settings.helics.federate_name) helics.helicsFederateInfoSetCoreTypeFromString( self.fedinfo, self._settings.helics.core_type) helics.helicsFederateInfoSetCoreInitString(self.fedinfo, f"--federates=1") IP = self._settings.helics.broker Port = self._settings.helics.broker_port self._logger.info( "Connecting to broker @ {}".format(f"{IP}:{Port}" if Port else IP)) if self._settings.helics.broker: helics.helicsFederateInfoSetBroker(self.fedinfo, self._settings.helics.broker) if self._settings.helics.broker_port: helics.helicsFederateInfoSetBrokerPort( self.fedinfo, self._settings.helics.broker_port) helics.helicsFederateInfoSetTimeProperty( self.fedinfo, helics.helics_property_time_delta, self._settings.helics.time_delta) helics.helicsFederateInfoSetIntegerProperty( self.fedinfo, helics.helics_property_int_log_level, self._settings.helics.logging_level) helics.helicsFederateInfoSetIntegerProperty( self.fedinfo, helics.helics_property_int_max_iterations, self._settings.helics.max_co_iterations) self._PyDSSfederate = helics.helicsCreateValueFederate( self._settings.helics.federate_name, self.fedinfo) return
def create_message_federate(fedinitstring,name,period): # Create Federate Info object that describes the federate properties fedinfo = h.helicsCreateFederateInfo() # Set core type from string h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "tcpss") #assert status == 0 # Federate init string # you need to tell helics what message bus to use h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) #assert status == 0 # Set one second message interval h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_period, period) #assert status == 0 # set wait for current time update to true h.helicsFederateInfoSetFlagOption(fedinfo, h.helics_flag_uninterruptible, True) # h.helics_flag_uninterruptible should have integer value of 1 #assert status == 0 # see 'helics_federate_flags' in # https://docs.helics.org/en/latest/doxygen/helics__enums_8h_source.html h.helicsFederateInfoSetIntegerProperty(fedinfo, h.helics_property_int_log_level, 1) # more info: # https://docs.helics.org/en/latest/user-guide/logging.html # https://docs.helics.org/en/latest/doxygen/helics__enums_8h_source.html # scroll to section on 'helics_log_levels' #print('status is',status) # make sure these links aren't dead #assert status == 0 # Create combo federate and give it a name fed = h.helicsCreateMessageFederate(name, fedinfo) # should this actually be a message federate? #fed = h.helicsCreateMessageFederate(name, fedinfo) print("Message federate created") return fed
def _create_helics_federate(self): self.fedinfo = helics.helicsCreateFederateInfo() helics.helicsFederateInfoSetCoreName(self.fedinfo, self._options['Helics']['Federate name']) helics.helicsFederateInfoSetCoreTypeFromString(self.fedinfo, self._options['Helics']['Core type']) helics.helicsFederateInfoSetCoreInitString(self.fedinfo, f"--federates=1") bLoc = self._options['Helics']['Broker'] Port = self._options['Helics']['Broker port'] self._logger.info("Connecting to broker @ {}".format(f"{bLoc}:{Port}" if Port else bLoc)) if self._options['Helics']['Broker']: helics.helicsFederateInfoSetBroker(self.fedinfo, self._options['Helics']['Broker']) if self._options['Helics']['Broker port']: helics.helicsFederateInfoSetBrokerPort(self.fedinfo, self._options['Helics']['Broker port']) helics.helicsFederateInfoSetTimeProperty(self.fedinfo, helics.helics_property_time_delta, self._options['Helics']['Time delta']) helics.helicsFederateInfoSetIntegerProperty(self.fedinfo, helics.helics_property_int_log_level, self._options['Helics']['Helics logging level']) helics.helicsFederateInfoSetFlagOption(self.fedinfo, helics.helics_flag_uninterruptible, True) helics.helicsFederateInfoSetIntegerProperty(self.fedinfo, helics.helics_property_int_max_iterations, self._options["Helics"]["Max co-iterations"]) self._PyDSSfederate = helics.helicsCreateValueFederate(self._options['Helics']['Federate name'], self.fedinfo) return
def test_value_federate_runFederateTimeoutTest(helicsBroker): fedinitstring = "--broker=mainbroker --federates=1" deltat = 0.01 # Create Federate Info object that describes the federate properties # fedinfo = h.helicsCreateFederateInfo() # Set Federate name # h.helicsFederateInfoSetCoreName(fedinfo, "TestA Core") # Set core type from string # h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string # h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # Set the message interval (timedelta) for federate. Note th# # HELICS minimum message time interval is 1 ns and by default # it uses a time delta of 1 second. What is provided to the # setTimedelta routine is a multiplier for the default timedelta. # Set one second message interval # h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat) h.helicsFederateInfoSetIntegerProperty(fedinfo, h.helics_property_int_log_level, 1) vFed = h.helicsCreateValueFederate("TestA Federate", fedinfo) defaultValue = "String1" testValue = "String2" pubid = h.helicsFederateRegisterGlobalPublication( vFed, "pub1", h.helics_data_type_string, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "") h.helicsInputSetDefaultString(subid, defaultValue) h.helicsFederateEnterExecutingMode(vFed) counter = 60 while counter > 0: counter -= 1 time.sleep(1) # Broker should be connected at this point assert h.helicsBrokerIsConnected( helicsBroker) == 1, "Broker should still be connected" h.helicsFederateFinalize(vFed) state = h.helicsFederateGetState(vFed) assert state == 3 while (h.helicsBrokerIsConnected(helicsBroker)): time.sleep(1) h.helicsFederateInfoFree(fedinfo) h.helicsFederateFree(vFed)
def create_federate(deltat=1.0, fedinitstring="--federates=1"): fedinfo = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreName(fedinfo, "PythonLoadshedFederate") h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat) fed = h.helicsCreateCombinationFederate("PythonLoadshedFederate", fedinfo) return fed
def __init__(self, core_type = "zmq", time_delta = 1): self.__fedinfo = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreName(self.__fedinfo, "") h.helicsFederateInfoSetCoreTypeFromString(self.__fedinfo, core_type) h.helicsFederateInfoSetCoreInitString(self.__fedinfo, "--federates=1") h.helicsFederateInfoSetTimeProperty(self.__fedinfo, h.helics_property_time_delta, time_delta) self.vfed = "" self.pub = [] self.sub = []
def vFed(): initstring = "-f 1 --name=mainbroker" fedinitstring = "--broker=mainbroker --federates=1" deltat = 0.01 #TODO: should add an assert here about helicsGetVersion h.helicsGetVersion() # Create broker # broker = h.helicsCreateBroker("zmq", "", initstring) isconnected = h.helicsBrokerIsConnected(broker) if isconnected == 1: pass # Create Federate Info object that describes the federate properties # fedinfo = h.helicsCreateFederateInfo() # Set Federate name # h.helicsFederateInfoSetCoreName(fedinfo, "TestA Core") # Set core type from string # h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string # h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # Set the message interval (timedelta) for federate. Note th# # HELICS minimum message time interval is 1 ns and by default # it uses a time delta of 1 second. What is provided to the # setTimedelta routine is a multiplier for the default timedelta. # Set one second message interval # h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat) h.helicsFederateInfoSetIntegerProperty(fedinfo, h.helics_property_int_log_level, 1) vFed = h.helicsCreateValueFederate("TestA Federate", fedinfo) yield vFed h.helicsFederateFinalize(vFed) state = h.helicsFederateGetState(vFed) assert state == 3 while (h.helicsBrokerIsConnected(broker)): time.sleep(1) h.helicsFederateInfoFree(fedinfo) h.helicsFederateFree(vFed) h.helicsCloseLibrary()
def test_system_test_federate_global_value(): brk = h.helicsCreateBroker("inproc", "gbrokerc", "--root") cr = h.helicsCreateCore("inproc", "gcore", "--broker=gbrokerc") argv = ["", "--corename=gcore"] fi = h.helicsCreateFederateInfo() h.helicsFederateInfoLoadFromArgs(fi, argv) fed = h.helicsCreateValueFederate("fed0", fi) fi2 = h.helicsFederateInfoClone(fi) h.helicsFederateInfoFree(fi2) h.helicsFederateInfoFree(fi) globalVal = "this is a string constant that functions as a global" globalVal2 = "this is a second string constant that functions as a global" h.helicsFederateSetGlobal(fed, "testglobal", globalVal) q = h.helicsCreateQuery("global", "testglobal") res = h.helicsQueryExecute(q, fed) assert res == globalVal h.helicsFederateSetGlobal(fed, "testglobal2", globalVal2) h.helicsQueryFree(q) q = h.helicsCreateQuery("global", "testglobal2") h.helicsQueryExecuteAsync(q, fed) while h.helicsQueryIsCompleted(q) is False: time.sleep(0.20) res = h.helicsQueryExecuteComplete(q) assert res == globalVal2 q2 = h.helicsCreateQuery("", "isinit") h.helicsQueryExecuteAsync(q2, fed) while h.helicsQueryIsCompleted(q2) is False: time.sleep(0.20) res = h.helicsQueryExecuteComplete(q2) assert str(res).lower() == "false" h.helicsFederateFinalize(fed) h.helicsCoreDisconnect(cr) h.helicsBrokerDisconnect(brk) h.helicsQueryFree(q) h.helicsQueryFree(q2) assert h.helicsBrokerIsConnected(brk) is False h.helicsBrokerDisconnect(brk) h.helicsCoreDisconnect(cr) assert h.helicsBrokerIsConnected(brk) is False h.helicsCloseLibrary()
def mFed(): initstring = "-f 1 --name=mainbroker" fedinitstring = "--broker=mainbroker --federates=1" deltat = 0.01 h.helicsGetVersion() # Create broker # broker = h.helicsCreateBroker("zmq", "", initstring) isconnected = h.helicsBrokerIsConnected(broker) if isconnected == 1: pass # Create Federate Info object that describes the federate properties # fedinfo = h.helicsCreateFederateInfo() # Set Federate name # h.helicsFederateInfoSetCoreName(fedinfo, "CoreA Federate") # Set core type from string # h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string # h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # Set the message interval (timedelta) for federate. Note th# # HELICS minimum message time interval is 1 ns and by default # it uses a time delta of 1 second. What is provided to the # setTimedelta routine is a multiplier for the default timedelta. # Set one second message interval # h.helicsFederateInfoSetTimeProperty(fedinfo, h.HELICS_PROPERTY_TIME_DELTA, deltat) h.helicsFederateInfoSetIntegerProperty(fedinfo, h.HELICS_PROPERTY_INT_LOG_LEVEL, 1) mFed = h.helicsCreateMessageFederate("TestA Federate", fedinfo) yield mFed h.helicsFederateFinalize(mFed) state = h.helicsFederateGetState(mFed) assert state == 3 while h.helicsBrokerIsConnected(broker): time.sleep(1) h.helicsFederateInfoFree(fedinfo) h.helicsFederateFree(mFed) h.helicsCloseLibrary()
def test_python_api4(): fi = h.helicsCreateFederateInfo() fi.separator = "_" fi.broker = "broker test" fi.broker_key = "hello-world" fi.broker_port = 8929 fi.local_port = 8229 fi.broker_init = "-f 3" fi.flag[h.HelicsFederateFlag.TERMINATE_ON_ERROR] = True fi.property[h.HelicsProperty.TIME_DELTA] = 1.0 fi.property["TIME_DELTA"] = 1.0
def create_message_federate(fedinitstring, name, period): fedinfo = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "tcpss") h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # Set one second message interval h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_period, period) # set wait for current time update to true h.helicsFederateInfoSetFlagOption(fedinfo, h.helics_flag_uninterruptible, True) h.helicsFederateInfoSetIntegerProperty(fedinfo, h.helics_property_int_log_level, 1) fed = h.helicsCreateMessageFederate(name, fedinfo) #print("Message federate created") return fed
def test_python_api0(): broker = h.helicsCreateBroker("zmq", "", "-f 1 --name=mainbroker") fedinfo = h.helicsCreateFederateInfo() assert "HelicsFederateInfo()" in repr(fedinfo) fedinfo.core_name = "TestFederate" fedinfo.core_type = "zmq" fedinfo.core_init = "-f 1 --broker=mainbroker" mFed = h.helicsCreateCombinationFederate("TestFederate", fedinfo) assert ( """HelicsCombinationFederate(name = "TestFederate", state = HelicsFederateState.STARTUP, current_time = -9223372036.854776, n_publications = 0, n_subscriptions = 0, n_endpoints = 0, n_filters = 0, n_pending_messages = 0)""" in repr(mFed)) _ = mFed.register_endpoint("ep1") _ = mFed.register_global_endpoint("ep2") pub = mFed.register_publication("publication", h.HELICS_DATA_TYPE_STRING, "custom-units") assert """HelicsPublication(name = "TestFederate/publication", type = "string", units = "custom-units", info = "")""" in repr( pub) sub = mFed.register_subscription("subscription", "custom-units") assert ( """HelicsInput(name = "_input_3", units = "custom-units", injection_units = "", publication_type = "", type = "", target = "subscription", info = "")""" in repr(sub)) assert ( """{ 'CONNECTION_REQUIRED' = 0, 'CONNECTION_OPTIONAL' = 0, 'SINGLE_CONNECTION_ONLY' = 0, 'MULTIPLE_CONNECTIONS_ALLOWED' = 1, 'BUFFER_DATA' = 0, 'STRICT_TYPE_CHECKING' = 0, 'IGNORE_UNIT_MISMATCH' = 0, 'ONLY_TRANSMIT_ON_CHANGE' = 0, 'ONLY_UPDATE_ON_CHANGE' = 0, 'IGNORE_INTERRUPTS' = 0, 'MULTI_INPUT_HANDLING_METHOD' = 0, 'INPUT_PRIORITY_LOCATION' = -1, 'CLEAR_PRIORITY_LIST' = 1, 'CONNECTIONS' = 0 }""" in repr(sub.option)) sub.option["CONNECTION_REQUIRED"] = 1 sub.option[h.HELICS_HANDLE_OPTION_CONNECTION_REQUIRED] = 1 assert sub.option["CONNECTION_REQUIRED"] == 1 sub.add_target("") mFed.property[h.HELICS_PROPERTY_TIME_DELTA] = 1.0 assert mFed.property[h.HELICS_PROPERTY_TIME_DELTA] == 1.0 mFed.property["TIME_DELTA"] = 1.0 assert mFed.property["TIME_DELTA"] == 1.0 with pt.raises(h.HelicsException): mFed.enter_executing_mode() h.helicsCloseLibrary() del mFed del broker
def create_value_federate(self, coreName): """This function creates a value federate. Args: coreName (str) - The name of the core for creating the value federate. Returns: vFed (helics federate object) - The value federate. """ name = "echohub Test--T" fi = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreName(fi, coreName) global vFed vFed = h.helicsCreateValueFederate(name, fi) logging.info("echo hub - created the value federate") return vFed
def create_federate(self): fedinfo = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreName(fedinfo, self.settings['Federate name']) h.helicsFederateInfoSetCoreTypeFromString(fedinfo, self.settings['Core type']) h.helicsFederateInfoSetCoreInitString(fedinfo, "--federates=1") h.helicsFederateInfoSetTimeProperty( fedinfo, h.helics_property_time_delta, self.settings["Step resolution (sec)"]) h.helicsFederateInfoSetIntegerProperty( fedinfo, h.helics_property_int_log_level, self.settings['Helics logging level']) h.helicsFederateInfoSetFlagOption(fedinfo, h.helics_flag_uninterruptible, True) self.PSSEfederate = h.helicsCreateValueFederate( self.settings['Federate name'], fedinfo) return
def create_value_federate(deltat=1.0, fedinitstring="--federates=1 --tick=0"): fedinfo = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreName(fedinfo, "TestB Federate") h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat) h.helicsFederateInfoSetIntegerProperty(fedinfo, h.helics_property_int_log_level, 1) fed = h.helicsCreateCombinationFederate("TestB Federate", fedinfo) return fed
def test_python_api6(): broker = h.helicsCreateBroker("zmq", "broker", "--federates 1") fi = h.helicsCreateFederateInfo() fed = h.helicsCreateCombinationFederate("test1", fi) fed.enter_initializing_mode() fed.enter_executing_mode() fed.core.disconnect() assert fed.core.wait_for_disconnect() del fed broker.disconnect() assert broker.wait_for_disconnect() del broker h.helicsCleanupLibrary() h.helicsCloseLibrary()
def _create_helics_federate(self): self.fedinfo = helics.helicsCreateFederateInfo() helics.helicsFederateInfoSetCoreName(self.fedinfo, self._options['Helics']['Federate name']) helics.helicsFederateInfoSetCoreTypeFromString(self.fedinfo, self._options['Helics']['Core type']) helics.helicsFederateInfoSetCoreInitString(self.fedinfo, f"--federates=1") #helics.helicsFederateInfoSetBroker(self.fedinfo, self._options['Helics']['Broker']) #helics.helicsFederateInfoSetBrokerPort(self.fedinfo, self._options['Helics']['Broker port']) helics.helicsFederateInfoSetTimeProperty(self.fedinfo, helics.helics_property_time_delta, self._options['Helics']['Time delta']) helics.helicsFederateInfoSetIntegerProperty(self.fedinfo, helics.helics_property_int_log_level, self._options['Helics']['Helics logging level']) helics.helicsFederateInfoSetFlagOption(self.fedinfo, helics.helics_flag_uninterruptible, True) helics.helicsFederateInfoSetIntegerProperty(self.fedinfo, helics.helics_property_int_max_iterations, self._options["Helics"]["Max co-iterations"]) self._PyDSSfederate = helics.helicsCreateValueFederate(self._options['Helics']['Federate name'], self.fedinfo) return
def test_bad_inputs_frees(): broker = createBroker(1) vFed1, fedinfo = createValueFederate(1, "fed0") fi = h.helicsCreateFederateInfo() h.helicsFederateInfoSetBroker(fi, "broker test") h.helicsFederateEnterInitializingMode(vFed1) h.helicsFederateFinalize(vFed1) h.helicsFederateInfoSetBrokerPort(fi, 8929) h.helicsFederateInfoSetLocalPort(fi, "8229") h.helicsFederateInfoFree(fi) h.helicsFederateFree(vFed1) # @test_throws h.HELICSErrorInvalidObject with pt.raises(h.HelicsException): destroyFederate(vFed1, fedinfo) destroyBroker(broker)
def create_message_federate(fedinitstring, name, timedelta): fedinfo = h.helicsCreateFederateInfo() # "coreType": "zmq", h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # "loglevel": 1, h.helicsFederateInfoSetIntegerProperty(fedinfo, h.helics_property_int_log_level, 11) # "timedelta": 1, h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, timedelta) # "uninterruptible": false, h.helicsFederateInfoSetFlagOption(fedinfo, h.helics_flag_uninterruptible, False) # "terminate_on_error": true, h.helicsFederateInfoSetFlagOption(fedinfo, h.HELICS_FLAG_TERMINATE_ON_ERROR, True) # "name": "Controller", fed = h.helicsCreateMessageFederate(name, fedinfo) return fed
def create_value_federate(fedinitstring, name, period): fedinfo = h.helicsCreateFederateInfo() # "coreType": "zmq", h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # "loglevel": 1, h.helicsFederateInfoSetIntegerProperty(fedinfo, h.helics_property_int_log_level, 7) # "period": 60, h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_period, period) # "uninterruptible": false, h.helicsFederateInfoSetFlagOption(fedinfo, h.helics_flag_uninterruptible, False) # "terminate_on_error": true, #h.helicsFederateInfoSetFlagOption(fedinfo, h.HELICS_FLAG_TERMINATE_ON_ERROR, True) h.helicsFederateInfoSetFlagOption(fedinfo, 72, True) # "name": "Charger", fed = h.helicsCreateValueFederate(name, fedinfo) return fed
def create_value_federate(self, coreName, index): """This function creates a value federate. Args: coreName (str) - The name of the core for creating the value federate. index (int) - The number that indicates which value federate is created and used during the test. Returns: vFed (helics federate object) - The value federate. """ name = "echoleaf_{} Test--T".format(index) fi = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreName(fi, coreName) global vFed vFed = h.helicsCreateValueFederate(name, fi) logging.info("echo leaf - created the value federate") return vFed
def test_python_api5(): broker = h.helicsCreateBroker("zmq", "broker", "--federates 1") fi = h.helicsCreateFederateInfo() fed = h.helicsCreateCombinationFederate("test1", fi) with pt.raises(h.HelicsException): fed.register_interfaces("unknownfile.json") fed.core.disconnect() assert fed.core.wait_for_disconnect() del fed broker.disconnect() assert broker.wait_for_disconnect() del broker h.helicsCleanupLibrary() h.helicsCloseLibrary()
def test_logging_api(): fi = h.helicsCreateFederateInfo() broker = h.helicsCreateBroker("zmq", "broker", "--federates 1 --loglevel 1") h.helicsFederateInfoSetCoreInitString(fi, "--federates 1") h.helicsFederateInfoSetIntegerProperty(fi, h.HELICS_PROPERTY_INT_LOG_LEVEL, 5) fed = h.helicsCreateValueFederate("test1", fi) userdata = UserData(5) handle = h.ffi.new_handle(userdata) h.helicsFederateSetLoggingCallback(fed, logger, handle) h.helicsFederateEnterExecutingMode(fed) h.helicsFederateLogInfoMessage(fed, "test MEXAGE") h.helicsFederateRequestNextStep(fed) h.helicsFederateLogInfoMessage(fed, "test MEXAGE") h.helicsFederateRequestNextStep(fed) h.helicsFederateLogInfoMessage(fed, "test MEXAGE") h.helicsFederateRequestNextStep(fed) h.helicsFederateLogInfoMessage(fed, "test MEXAGE") h.helicsFederateRequestNextStep(fed) h.helicsFederateFinalize(fed) assert userdata.x == 9 h.helicsFederateFree(fed) h.helicsFederateInfoFree(fi) h.helicsBrokerDisconnect(broker) h.helicsBrokerFree(broker) h.helicsCleanupLibrary() h.helicsCloseLibrary()
def create_value_federate(fedinitstring, name, period): fedinfo = h.helicsCreateFederateInfo() # "coreType": "zmq", h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # "loglevel": 1, h.helicsFederateInfoSetIntegerProperty(fedinfo, h.helics_property_int_log_level, 1) # "period": 60, h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_period, period) # "uninterruptible": false, h.helicsFederateInfoSetFlagOption(fedinfo, h.helics_flag_uninterruptible, False) # "terminate_on_error": true, h.helicsFederateInfoSetFlagOption(fedinfo, 72, True) # "wait_for_current_time_update": true, h.helicsFederateInfoSetFlagOption( fedinfo, h.helics_flag_wait_for_current_time_update, True) # "name": "Battery", fed = h.helicsCreateValueFederate(name, fedinfo) return fed
def create_federate(deltat=1.0, fedinitstring="--federates=1"): fedinfo = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreName(fedinfo, "Combination Federate A") # assert status == 0 h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # assert status == 0 h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # assert status == 0 h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat) # assert status == 0 # h.helicsFederateInfoSetLoggingLevel(fedinfo, 1) # assert status == 0 fed = h.helicsCreateCombinationFederate("Combination Federate A", fedinfo) return fed
print("PI SENDER: Helics version = {}".format(helicsversion)) # Create broker # print("Creating Broker") broker = h.helicsCreateBroker("zmq", "", initstring) print("Created Broker") print("Checking if Broker is connected") isconnected = h.helicsBrokerIsConnected(broker) print("Checked if Broker is connected") if isconnected == 1: print("Broker created and connected") # Create Federate Info object that describes the federate properties # fedinfo = h.helicsCreateFederateInfo() # Set Federate name # h.helicsFederateInfoSetCoreName(fedinfo, "TestA Federate") # Set core type from string # h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string # h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # Set the message interval (timedelta) for federate. Note th# # HELICS minimum message time interval is 1 ns and by default # it uses a time delta of 1 second. What is provided to the # setTimedelta routine is a multiplier for the default timedelta.