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 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 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._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 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_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 create_value_federate(deltat=1.0, fedinitstring="--federates=1"): logger.debug("Creating federateinfo") fedinfo = h.helicsFederateInfoCreate() logger.debug("Setting name") status = h.helicsFederateInfoSetFederateName(fedinfo, "MarketSim") assert status == 0 logger.debug("Setting core type") status = h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") assert status == 0 logger.debug("Setting init string") status = h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) assert status == 0 logger.debug("Setting time delta") status = h.helicsFederateInfoSetTimeDelta(fedinfo, deltat) assert status == 0 logger.debug("Setting logging level") status = h.helicsFederateInfoSetLoggingLevel(fedinfo, 1) assert status == 0 logger.debug("Creating CombinationFederate") fed = h.helicsCreateCombinationFederate(fedinfo) return fed
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_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(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_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 mFed(): import helics as h initstring = "1 --name=mainbroker" fedinitstring = "--broker=mainbroker --federates=1" deltat = 0.01 helicsversion = 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.helicsFederateInfoCreate() # Set Federate name # status = h.helicsFederateInfoSetFederateName(fedinfo, "TestA Federate") # Set core type from string # status = h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string # status = 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 # status = h.helicsFederateInfoSetTimeDelta(fedinfo, deltat) status = h.helicsFederateInfoSetLoggingLevel(fedinfo, 1) mFed = h.helicsCreateMessageFederate(fedinfo) yield mFed status = h.helicsFederateFinalize(mFed) status, state = h.helicsFederateGetState(mFed) assert state == 3 while (h.helicsBrokerIsConnected(broker)): time.sleep(1) h.helicsFederateFree(mFed) 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 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_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
def setup(self, ID): """ID needs to be a list that contains all the T&D interface nodes.""" try: # read solar mapping self.solarData=np.genfromtxt(dirName+'/data/solar_diffusion_map.csv',\ delimiter=',') self.ID = ID # set up comm with helics self.fi = fi = h.helicsFederateInfoCreate() # create info obj status = h.helicsFederateInfoSetFederateName(fi, "pyPflow") status = h.helicsFederateInfoSetCoreTypeFromString(fi, "zmq") status = h.helicsFederateInfoSetCoreInitString(fi, "--federates=1") status = h.helicsFederateInfoSetTimeDelta( fi, 300) # 5 min dispatch interval status = h.helicsFederateInfoSetLoggingLevel(fi, 1) self.vf = vf = h.helicsCreateValueFederate(fi) self.pub = pub = h.helicsFederateRegisterGlobalPublication( vf, "adaptive_volt_var", "string", "") self.sub = sub = {} for entry in ID: # subscribe to all IDs sub['pyGld_' + str(entry)] = h.helicsFederateRegisterSubscription( vf, 'pyGld_' + str(entry), "string", "") status = h.helicsFederateEnterExecutionMode(vf) # Read schema f = open(dirName + '/data/schema_case9.json') self.data = eval(f.read()) f.close() # add V in schema for all subscriptions for entry in ID: self.data['mpc']['get']['V'].append([entry, 0, 0]) # run initial PFLOW (base case condition as read from .m file) self.socket.send_string(json.dumps( self.data)) # send instructions to pflow self.msgFromPflow = eval( self.socket.recv()) # receive data from pflow except: PrintException()
def create_value_federate(deltat=1.0, fedinitstring="--federates=1"): fedinfo = h.helicsFederateInfoCreate() status = h.helicsFederateInfoSetFederateName(fedinfo, "TestB Federate") assert status == 0 status = h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") assert status == 0 status = h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) assert status == 0 status = h.helicsFederateInfoSetTimeDelta(fedinfo, deltat) assert status == 0 status = h.helicsFederateInfoSetLoggingLevel(fedinfo, 1) assert status == 0 fed = h.helicsCreateCombinationFederate(fedinfo) return fed
def setup(self, fedName='pyGld', portNum=12000, ID=5): try: fedName += '_' + str(ID) self.fedName = fedName # setup helics self.fi = fi = h.helicsFederateInfoCreate() # create info obj status = h.helicsFederateInfoSetFederateName(fi, fedName) status = h.helicsFederateInfoSetCoreTypeFromString(fi, "zmq") status = h.helicsFederateInfoSetCoreInitString(fi, "--federates=1") status = h.helicsFederateInfoSetTimeDelta( fi, 300) # 5 min dispatch interval self.vf = vf = h.helicsCreateValueFederate(fi) self.pub = h.helicsFederateRegisterGlobalPublication( vf, fedName, "string", "") self.sub = h.helicsFederateRegisterSubscription( vf, "adaptive_volt_var", "string", "") status = h.helicsFederateEnterExecutionMode(vf) # setup worker self.pyGldWorker.setup(portNum=portNum, ID=ID) except: PrintException()
# -*- coding: utf-8 -*- import os import helics as h from math import pi import time initstring = "-f 2 --loglevel=7" broker = h.helicsCreateBroker("zmq", "", initstring) assert h.helicsBrokerIsConnected(broker) is True fedinfo = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreType(fedinfo, h.helics_core_type_zmq) h.helicsFederateInfoSetCoreInitString(fedinfo, "--loglevel=7") h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, 1.0) fed = h.helicsCreateCombinationFederate("sender", fedinfo,) topicA = h.helicsFederateRegisterGlobalPublication( fed, "topicA", h.helics_data_type_double, "" ) h.helicsFederateEnterExecutingMode(fed) currenttime = 0 for t in range(5, 10 + 1): while currenttime < t: currenttime = h.helicsFederateRequestTime(fed, t) print(f"Sending value = {pi} at time = {currenttime}") h.helicsPublicationPublishDouble(topicA, pi) h.helicsFederateFinalize(fed) h.helicsFederateFree(fed)
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.helicsFederateInfoCreate() # Set Federate name # status = h.helicsFederateInfoSetFederateName(fedinfo, "TestA Federate") # Set core type from string # status = h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string # status = 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 # status = h.helicsFederateInfoSetTimeDelta(fedinfo, deltat) status = h.helicsFederateInfoSetLoggingLevel(fedinfo, 1) # Create value federate # vfed = h.helicsCreateValueFederate(fedinfo) print("PI SENDER: Value federate created")
# -*- 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)
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")
# -*- coding: utf-8 -*- import os import helics as h broker_address = "127.0.0.1:12345" interface_address = "127.0.0.1:32432" fedinfo = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreType(fedinfo, h.helics_core_type_zmq) h.helicsFederateInfoSetCoreInitString( fedinfo, f"--federates=1 --broker_address=tcp://{broker_address} --interface=tcp://{interface_address} --loglevel=7", ) h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, 0.5) fed = h.helicsCreateCombinationFederate("receiver", fedinfo,) topicA = h.helicsFederateRegisterSubscription(fed, "topicA", "",) h.helicsFederateEnterExecutingMode(fed) currenttime = 0 for t in range(5, 10 + 1): while currenttime < t: currenttime = h.helicsFederateRequestTime(fed, t) a = h.helicsInputGetDouble(topicA) print(f"Received a = {a} at time = {currenttime}") h.helicsFederateFinalize(fed) h.helicsFederateFree(fed) h.helicsCloseLibrary()
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) # Create value federate # vfed = h.helicsCreateValueFederate("TestA Federate", fedinfo) print("PI SENDER: Value federate created") # Register the publication # pub = h.helicsFederateRegisterGlobalTypePublication(vfed, "testA", "double", "")