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 _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 _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_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 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 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 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 __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 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 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 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 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 _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 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 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("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. # Set one second message interval # h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat)
print("Creating Broker") broker = h.helicsCreateBroker("zmq", "", brokerinitstring) 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, federateinitstring) # 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)
def run_sub_trans(feeders, broker_address): fedinitstring = "--federates=1" if broker_address is not None: fedinitstring = f"{fedinitstring} --broker_address=tcp://{broker_address}" deltat = 0.01 print(f"{fed_name}: Helics version = {h.helicsGetVersion()}") # Create Federate Info object that describes the federate properties # fedinfo = h.helicsCreateFederateInfo() # Set Federate name # h.helicsFederateInfoSetCoreName(fedinfo, fed_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) # Create value federate # vfed = h.helicsCreateValueFederate(fed_name, fedinfo) print("Value federate created") # Register the publication # print(f"{fed_name}: Publication registered") pubs = [] subs = [] for feeder in feeders: pub_name = f"{feeder}.voltage" pubs.append( h.helicsFederateRegisterGlobalTypePublication( vfed, pub_name, "double", "pu" ) ) print(f"{fed_name}: publication {pub_name} registered") sub_name = "Circuit.{feeder}.TotalPower.E" subs.append(h.helicsFederateRegisterSubscription(vfed, sub_name, "kW")) print(f"{fed_name}: subscription {sub_name} registered") # Enter execution mode h.helicsFederateEnterExecutingMode(vfed) print(f"{fed_name} Entering executing mode") # start execution loop n_feeders = len(feeders) currenttime = 0 desiredtime = 0.0 t = 0.0 end_time = 24 * 3600 while desiredtime <= end_time: # publish desiredtime = t * 15 * 60 currenttime = h.helicsFederateRequestTime(vfed, desiredtime) if currenttime >= desiredtime: for p in pubs: h.helicsPublicationPublishDouble(p, 1.01) for i in range(n_feeders): value = h.helicsInputGetDouble(subs[i]) print( f"Circuit {feeders[i]} active power demand: {value} kW at time: {currenttime}." ) t += 1 # all other federates should have finished, so now you can close the broker h.helicsFederateFinalize(vfed) print(f"{fed_name}: Test Federate finalized") h.helicsFederateDestroy(vfed) print(f"{fed_name}: test federate destroyed") h.helicsFederateFree(vfed) print("federate freed") h.helicsCloseLibrary() print("library closed")
def run_p1uhs_federate(fed_name, broker_address=None): fedinitstring = "--federates=1" if broker_address is not None: fedinitstring = f"{fedinitstring} --broker_address=tcp://{broker_address}" deltat = 0.01 print(f"{fed_name}: Helics version = {h.helicsGetVersion()}") # Create Federate Info object that describes the federate properties # fedinfo = h.helicsCreateFederateInfo() # Set Federate name # h.helicsFederateInfoSetCoreName(fedinfo, fed_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) # Create value federate # vfed = h.helicsCreateValueFederate(fed_name, fedinfo) print("Value federate created") # Register the publications # pub_name = "Circuit.feeder_p1u.{fed_name}.p1ux.TotalPower.E" pub_load = h.helicsFederateRegisterGlobalTypePublication( vfed, pub_name, "double", "kW") print(f"{fed_name}: publication {pub_name} registered") # Register subscriptions # # subscribe to voltage supplied sub_name = f"Circuit.feeder_p1u.{fed_name}.p1ux.voltage" sub_voltage = h.helicsFederateRegisterSubscription(vfed, sub_name, "pu") # subscribe to reiteration flag # sub_flag = h.helicsFederateRegisterSubscription(vfed, "reiterate_flag", None) # h.helicsFederateSetIntegerProperty(vfed, h.helics_property_int_max_iterations, 10) # Enter execution mode # h.helicsFederateEnterExecutingMode(vfed) # fed_iteration_state = h.helicsFederateEnterExecutingModeIterative(vfed, h.helics_iteration_request_iterate_if_needed) print(f"{fed_name}: Entering execution mode") # start execution loop # desiredtime = 0.0 t = 0.0 end_time = 24 * 3600 # 95*15*60 while desiredtime <= end_time: # check time desiredtime = t * 15 * 60 currenttime = h.helicsFederateRequestTime(vfed, desiredtime) if currenttime >= desiredtime: # reiterate until convergence last_voltage = 1.0 iters = 1 iteration_state = h.helics_iteration_result_iterating while iteration_state == h.helics_iteration_result_iterating: supply_voltage, load = pub_and_sub_calc( sub_voltage, pub_load, iters) currenttime, iteration_state = h.helicsFederateRequestTimeIterative( vfed, desiredtime, h.helics_iteration_request_iterate_if_needed) if abs(last_voltage - supply_voltage) < 1e-20: iteration_state = -1 iters += 1 last_voltage = supply_voltage logging.info( "p1uhs0 load {} with voltage {} at time {} after {} iters". format(load, supply_voltage, currenttime, iters)) t += 1 # all other federates should have finished, so now you can close h.helicsFederateFinalize(vfed) print(f"{fed_name}: Test Federate finalized") h.helicsFederateDestroy(vfed) print(f"{fed_name}: test federate destroyed") h.helicsFederateFree(vfed) print(f"{fed_name}: federate freed") h.helicsCloseLibrary() print(f"{fed_name}: library closed")
def test_misc_api(): fedInfo1 = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreInitString(fedInfo1, "-f 1") h.helicsFederateInfoSetCoreName(fedInfo1, "core3") h.helicsFederateInfoSetCoreType(fedInfo1, 3) h.helicsFederateInfoSetCoreTypeFromString(fedInfo1, "zmq") h.helicsFederateInfoSetFlagOption(fedInfo1, 1, True) h.helicsFederateInfoSetTimeProperty(fedInfo1, h.HELICS_PROPERTY_TIME_INPUT_DELAY, 1.0) h.helicsFederateInfoSetIntegerProperty(fedInfo1, h.HELICS_PROPERTY_INT_LOG_LEVEL, 1) h.helicsFederateInfoSetIntegerProperty( fedInfo1, h.HELICS_PROPERTY_INT_MAX_ITERATIONS, 100) h.helicsFederateInfoSetTimeProperty(fedInfo1, h.HELICS_PROPERTY_TIME_OUTPUT_DELAY, 1.0) h.helicsFederateInfoSetTimeProperty(fedInfo1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0) h.helicsFederateInfoSetTimeProperty(fedInfo1, h.HELICS_PROPERTY_TIME_DELTA, 1.0) h.helicsFederateInfoSetTimeProperty(fedInfo1, h.HELICS_PROPERTY_TIME_OFFSET, 0.1) h.helicsFederateInfoFree(fedInfo1) broker3 = h.helicsCreateBroker("zmq", "broker3", "--federates 1 --loglevel 1") fedInfo2 = h.helicsCreateFederateInfo() coreInitString = "--federates 1" h.helicsFederateInfoSetCoreInitString(fedInfo2, coreInitString) h.helicsFederateInfoSetCoreTypeFromString(fedInfo2, "zmq") h.helicsFederateInfoSetIntegerProperty(fedInfo2, h.HELICS_PROPERTY_INT_LOG_LEVEL, 1) h.helicsFederateInfoSetTimeProperty(fedInfo2, h.HELICS_PROPERTY_TIME_DELTA, 1.0) fed1 = h.helicsCreateCombinationFederate("fed1", fedInfo2) fed2 = h.helicsFederateClone(fed1) _ = h.helicsGetFederateByName("fed1") h.helicsFederateSetFlagOption(fed2, 1, False) h.helicsFederateSetTimeProperty(fed2, h.HELICS_PROPERTY_TIME_INPUT_DELAY, 1.0) h.helicsFederateSetIntegerProperty(fed1, h.HELICS_PROPERTY_INT_LOG_LEVEL, 1) h.helicsFederateSetIntegerProperty(fed2, h.HELICS_PROPERTY_INT_MAX_ITERATIONS, 100) h.helicsFederateSetTimeProperty(fed2, h.HELICS_PROPERTY_TIME_OUTPUT_DELAY, 1.0) h.helicsFederateSetTimeProperty(fed2, h.HELICS_PROPERTY_TIME_PERIOD, 0.0) h.helicsFederateSetTimeProperty(fed2, h.HELICS_PROPERTY_TIME_DELTA, 1.0) _ = h.helicsFederateRegisterCloningFilter(fed1, "fed1/Ep1") fed1DestinationFilter = h.helicsFederateRegisterFilter( fed1, h.HELICS_FILTER_TYPE_DELAY, "fed1DestinationFilter") h.helicsFilterAddDestinationTarget(fed1DestinationFilter, "Ep2") ep1 = h.helicsFederateRegisterEndpoint(fed1, "Ep1", "string") ep2 = h.helicsFederateRegisterGlobalEndpoint(fed1, "Ep2", "string") pub1 = h.helicsFederateRegisterGlobalPublication(fed1, "pub1", h.HELICS_DATA_TYPE_DOUBLE, "") pub2 = h.helicsFederateRegisterGlobalTypePublication( fed1, "pub2", "complex", "") sub1 = h.helicsFederateRegisterSubscription(fed1, "pub1") sub2 = h.helicsFederateRegisterSubscription(fed1, "pub2") h.helicsInputAddTarget(sub2, "Ep2") pub3 = h.helicsFederateRegisterPublication(fed1, "pub3", h.HELICS_DATA_TYPE_STRING, "") pub1KeyString = h.helicsPublicationGetKey(pub1) pub1TypeString = h.helicsPublicationGetType(pub1) pub1UnitsString = h.helicsPublicationGetUnits(pub1) sub1KeyString = h.helicsSubscriptionGetKey(sub1) sub1UnitsString = h.helicsInputGetUnits(sub1) assert "pub1" == pub1KeyString assert "double" == pub1TypeString assert "" == pub1UnitsString assert "pub1" == sub1KeyString assert "" == sub1UnitsString fed1SourceFilter = h.helicsFederateRegisterFilter( fed1, h.HELICS_FILTER_TYPE_DELAY, "fed1SourceFilter") h.helicsFilterAddSourceTarget(fed1SourceFilter, "Ep2") h.helicsFilterAddDestinationTarget(fed1SourceFilter, "fed1/Ep1") h.helicsFilterRemoveTarget(fed1SourceFilter, "fed1/Ep1") h.helicsFilterAddSourceTarget(fed1SourceFilter, "Ep2") h.helicsFilterRemoveTarget(fed1SourceFilter, "Ep2") fed1SourceFilterNameString = h.helicsFilterGetName(fed1SourceFilter) assert fed1SourceFilterNameString == "fed1/fed1SourceFilter" sub3 = h.helicsFederateRegisterSubscription(fed1, "fed1/pub3", "") pub4 = h.helicsFederateRegisterTypePublication(fed1, "pub4", "int", "") sub4 = h.helicsFederateRegisterSubscription(fed1, "fed1/pub4", "") pub5 = h.helicsFederateRegisterGlobalTypePublication( fed1, "pub5", "boolean", "") sub5 = h.helicsFederateRegisterSubscription(fed1, "pub5", "") pub6 = h.helicsFederateRegisterGlobalPublication(fed1, "pub6", h.HELICS_DATA_TYPE_VECTOR, "") sub6 = h.helicsFederateRegisterSubscription(fed1, "pub6", "") pub7 = h.helicsFederateRegisterGlobalPublication( fed1, "pub7", h.HELICS_DATA_TYPE_NAMED_POINT, "") sub7 = h.helicsFederateRegisterSubscription(fed1, "pub7", "") assert """helics.HelicsPublication(name = "pub1", type = "double", units = "", info = "")""" in repr( pub1) assert """helics.HelicsPublication(name = "pub2", type = "complex", units = "", info = "")""" in repr( pub2) assert """helics.HelicsPublication(name = "fed1/pub3", type = "string", units = "", info = "")""" in repr( pub3) assert """helics.HelicsPublication(name = "fed1/pub4", type = "int", units = "", info = "")""" in repr( pub4) assert """helics.HelicsPublication(name = "pub5", type = "boolean", units = "", info = "")""" in repr( pub5) assert """helics.HelicsPublication(name = "pub6", type = "double_vector", units = "", info = "")""" in repr( pub6) assert """helics.HelicsPublication(name = "pub7", type = "named_point", units = "", info = "")""" in repr( pub7) assert ( """helics.HelicsInput(name = "_input_18", units = "", injection_units = "", publication_type = "", type = "", target = "pub7", info = "")""" in repr(sub7)) h.helicsInputSetDefaultBoolean(sub5, False) h.helicsInputSetDefaultComplex(sub2, -9.9 + 2.5j) h.helicsInputSetDefaultDouble(sub1, 3.4) h.helicsInputSetDefaultInteger(sub4, 6) h.helicsInputSetDefaultNamedPoint(sub7, "hollow", 20.0) h.helicsInputSetDefaultString(sub3, "default") sub6Default = [3.4, 90.9, 4.5] h.helicsInputSetDefaultVector(sub6, sub6Default) h.helicsEndpointSubscribe(ep2, "fed1/pub3") h.helicsFederateEnterInitializingModeAsync(fed1) rs = h.helicsFederateIsAsyncOperationCompleted(fed1) if rs == 0: time.sleep(0.500) rs = h.helicsFederateIsAsyncOperationCompleted(fed1) if rs == 0: time.sleep(0.500) rs = h.helicsFederateIsAsyncOperationCompleted(fed1) if rs == 0: assert True is False h.helicsFederateEnterInitializingModeComplete(fed1) h.helicsFederateEnterExecutingModeAsync(fed1) h.helicsFederateEnterExecutingModeComplete(fed1) assert ( """helics.HelicsInput(name = "_input_18", units = "", injection_units = "", publication_type = "named_point", type = "", target = "pub7", info = "")""" in repr(sub7)) mesg1 = h.helicsFederateCreateMessage(fed1) h.helicsMessageSetString(mesg1, "Hello") h.helicsMessageSetSource(mesg1, "fed1/Ep1") h.helicsMessageSetOriginalSource(mesg1, "fed1/Ep1") h.helicsMessageSetDestination(mesg1, "Ep2") h.helicsMessageSetOriginalDestination(mesg1, "Ep2") h.helicsEndpointSendMessage(ep1, mesg1) mesg1 = h.helicsFederateCreateMessage(fed1) h.helicsMessageSetString(mesg1, "There") h.helicsMessageSetSource(mesg1, "fed1/Ep1") h.helicsMessageSetOriginalSource(mesg1, "fed1/Ep1") h.helicsMessageSetDestination(mesg1, "Ep2") h.helicsMessageSetOriginalDestination(mesg1, "Ep2") h.helicsEndpointSendMessage(ep1, mesg1) h.helicsEndpointSetDefaultDestination(ep2, "fed1/Ep1") ep1NameString = h.helicsEndpointGetName(ep1) ep1TypeString = h.helicsEndpointGetType(ep1) assert ep1NameString == "fed1/Ep1" assert ep1TypeString == "string" _ = h.helicsFederateGetCoreObject(fed1) fed1Time = h.helicsFederateGetCurrentTime(fed1) assert fed1Time == 0.0 fed1EndpointCount = h.helicsFederateGetEndpointCount(fed1) assert fed1EndpointCount == 2 fed1NameString = h.helicsFederateGetName(fed1) assert fed1NameString == "fed1" fed1State = h.helicsFederateGetState(fed1) assert fed1State == 2 fed1PubCount = h.helicsFederateGetPublicationCount(fed1) assert fed1PubCount == 7 fed1SubCount = h.helicsFederateGetInputCount(fed1) assert fed1SubCount == 7 h.helicsPublicationPublishBoolean(pub5, True) h.helicsPublicationPublishComplex(pub2, 5.6 + -0.67j) h.helicsPublicationPublishDouble(pub1, 457.234) h.helicsPublicationPublishInteger(pub4, 1) h.helicsPublicationPublishNamedPoint(pub7, "Blah Blah", 20.0) h.helicsPublicationPublishString(pub3, "Mayhem") pub6Vector = [4.5, 56.5] h.helicsPublicationPublishVector(pub6, pub6Vector) time.sleep(0.500) h.helicsFederateRequestTimeAsync(fed1, 1.0) returnTime = h.helicsFederateRequestTimeComplete(fed1) assert returnTime == 1.0 ep2MsgCount = h.helicsEndpointPendingMessages(ep2) assert ep2MsgCount == 2 ep2HasMsg = h.helicsEndpointHasMessage(ep2) assert ep2HasMsg == 1 msg2 = h.helicsEndpointGetMessage(ep2) assert h.helicsMessageGetTime(msg2) == 1.0 assert h.helicsMessageGetString(msg2) == "Hello" assert h.helicsMessageGetOriginalSource(msg2) == "fed1/Ep1" assert h.helicsMessageGetSource(msg2) == "fed1/Ep1" assert h.helicsMessageGetDestination(msg2) == "Ep2" assert h.helicsMessageGetOriginalDestination(msg2) == "Ep2" fed1MsgCount = h.helicsFederatePendingMessages(fed1) assert fed1MsgCount == 1 assert h.helicsFederateHasMessage(fed1) == 1 msg3 = h.helicsFederateGetMessage(fed1) assert h.helicsMessageGetTime(msg3) == 1.0 assert h.helicsMessageGetString(msg3) == "There" assert h.helicsMessageGetOriginalSource(msg3) == "fed1/Ep1" assert h.helicsMessageGetSource(msg3) == "fed1/Ep1" assert h.helicsMessageGetDestination(msg3) == "Ep2" assert h.helicsMessageGetOriginalDestination(msg3) == "Ep2" sub1Updated = h.helicsInputIsUpdated(sub1) # TODO: figure out why this test is broken assert sub1Updated is False # TODO: figure out why this test is broken assert h.helicsInputLastUpdateTime(sub2) == 0.0 # assert h.helicsInputGetComplex(sub2) == 5.6 - 0.67j # assert h.helicsInputGetDouble(sub1) == 457.234 # assert h.helicsInputGetInteger(sub4) == 1 sub7PointString, sub7DoubleValue = h.helicsInputGetNamedPoint(sub7) # assert sub7PointString == "Blah Blah" assert sub7DoubleValue == 20.0 # assert h.helicsInputGetBoolean(sub5) == True # assert h.helicsInputGetString(sub3) == "Mayhem" sub3ValueSize = h.helicsInputGetRawValueSize(sub3) # assert sub3ValueSize == 6 # assert h.helicsInputGetVector(sub6) == [4.5, 56.5] h.helicsFederateFinalize(fed1) h.helicsFederateFinalize(fed2) h.helicsFederateFree(fed1) h.helicsFederateFinalize(fed2) h.helicsFederateFree(fed2) h.helicsFederateInfoFree(fedInfo2) h.helicsBrokerDisconnect(broker3) h.helicsBrokerFree(broker3) h.helicsCleanupLibrary() h.helicsCloseLibrary()
def run_p1u_federate(fed_name, broker_address, feeders): fedinitstring = "--federates=1" if broker_address is not None: fedinitstring = f"{fedinitstring} --broker_address=tcp://{broker_address}" deltat = 0.01 print(f"{fed_name}: Helics version = {h.helicsGetVersion()}") # Create Federate Info object that describes the federate properties fedinfo = h.helicsCreateFederateInfo() # Set Federate name h.helicsFederateInfoSetCoreName(fedinfo, fed_name) # Set core type from string h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # Set one second message interval h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat) # Create value federate vfed = h.helicsCreateValueFederate(fed_name, fedinfo) print("Value federate created") # Register the publications pub_load = h.helicsFederateRegisterGlobalTypePublication( vfed, "Circuit.full_network.TotalPower.E", "double", "kW" ) pub_voltages = [] for feeder in feeders: pub_name = f"Circuit.feeder_p1u.{feeder}.p1ux.voltage" pub_voltages.append( h.helicsFederateRegisterGlobalTypePublication( vfed, pub_name, "double", "pu" ) ) print(f"{fed_name}: publication {pub_name} registered") # Register subscriptions # subscribe to voltage supplied sub_voltage = h.helicsFederateRegisterSubscription( vfed, "full_network.voltage", "pu" ) h.helicsInputSetDefaultDouble(sub_voltage, 1.0) # subscribe to loads below sub_loads = [] for feeder in feeders: sub_name = f"Circuit.feeder_p1u.{feeder}.p1ux.TotalPower.E" sub_loads.append(h.helicsFederateRegisterSubscription(vfed, sub_name, "kW")) print(f"{fed_name}: subscription {sub_name} registered") h.helicsFederateSetIntegerProperty(vfed, h.helics_property_int_max_iterations, 10) # Enter execution mode h.helicsFederateEnterExecutingMode(vfed) print(f"{fed_name} Entering executing mode") # start execution loop n_feeders = len(feeders) desiredtime = 0.0 t = 0.0 end_time = 24 * 3600 while desiredtime <= end_time: # check time desiredtime = t * 15 * 60 currenttime = h.helicsFederateRequestTime(vfed, desiredtime) if currenttime >= desiredtime: last_loads = [0 for i in range(0, n_feeders)] # reiterate between supply voltage and loads for up to __ iterations # get supply voltage iters = 1 supply_voltage = h.helicsInputGetDouble(sub_voltage) iteration_state = h.helics_iteration_result_iterating while iteration_state == h.helics_iteration_result_iterating: # if there is an iteration going on, publish and subscribe again new_loads = pub_and_sub_calc( supply_voltage, last_loads, sub_loads, pub_voltages ) currenttime, iteration_state = h.helicsFederateRequestTimeIterative( vfed, desiredtime, h.helics_iteration_request_iterate_if_needed ) # find change in load and determine if you need to continue iterating load_diff = 0 for i in range(n_feeders): load_diff = load_diff + abs(new_loads[i] - last_loads[i]) if load_diff / n_feeders < 1e-3: iteration_state = 0 last_loads = new_loads iters += 1 h.helicsPublicationPublishDouble(pub_load, sum(last_loads)) logger.info( "feeder loads {last_loads} at time {currenttime} after {iters} iters" ) t += 1 # all other federates should have finished, so now you can close h.helicsFederateFinalize(vfed) print(f"{fed_name}: Test Federate finalized") h.helicsFederateDestroy(vfed) print(f"{fed_name}: test federate destroyed") h.helicsFederateFree(vfed) print(f"{fed_name}: federate freed") h.helicsCloseLibrary() print(f"{fed_name}: library closed")
# -*- coding: utf-8 -*- import time import sys from math import pi import helics as h federate_name = f"SenderFederate{sys.argv[1]}" print(f"{federate_name}: Helics version = {h.helicsGetVersion()}") fedinfo = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreName(fedinfo, federate_name + "Core") h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") h.helicsFederateInfoSetCoreInitString(fedinfo, "--federates=1") h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, 0.01) vfed = h.helicsCreateValueFederate(federate_name, fedinfo) print(f"{federate_name}: Value federate created") pub = h.helicsFederateRegisterGlobalTypePublication( vfed, f"globaltopic{sys.argv[1]}", "double", "" ) pub = h.helicsFederateRegisterTypePublication( vfed, f"localtopic{sys.argv[1]}", "double", "" ) print(f"{federate_name}: Publication registered") h.helicsFederateEnterExecutingMode(vfed)
# -*- coding: utf-8 -*- import time import helics as h # Create broker # broker = h.helicsCreateBroker("zmq", "", "-f 2 --name=BeamBroker") isConnected = h.helicsBrokerIsConnected(broker) if isConnected == 1: print("Broker created and connected") fedInfo = h.helicsCreateFederateInfo() fedName = "BeamFederateReader" h.helicsFederateInfoSetCoreName(fedInfo, fedName) h.helicsFederateInfoSetCoreTypeFromString(fedInfo, "zmq") h.helicsFederateInfoSetCoreInitString(fedInfo, "--federates=1") # deltat is multiplied for default timedelta of 1 second h.helicsFederateInfoSetTimeProperty(fedInfo, h.helics_property_time_delta, 1.0) cfed = h.helicsCreateCombinationFederate(fedName, fedInfo) print("Subscribing...") subs_chargingPlugIn = h.helicsFederateRegisterSubscription( cfed, "BeamFederate/chargingPlugIn", "string") subs_chargingPlugOut = h.helicsFederateRegisterSubscription( cfed, "BeamFederate/chargingPlugOut", "string") print("Waiting Execution Mode...") h.helicsFederateEnterInitializingMode(cfed) h.helicsFederateEnterExecutingMode(cfed) # start execution loop # timebin = 300 currenttime = 0