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.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 _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 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_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 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 vFed(): 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) vFed = h.helicsCreateValueFederate(fedinfo) yield vFed status = h.helicsFederateFinalize(vFed) status, state = h.helicsFederateGetState(vFed) assert state == 3 while (h.helicsBrokerIsConnected(broker)): time.sleep(1) h.helicsFederateFree(vFed) h.helicsCloseLibrary()
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(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_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_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_federate(deltat=1.0, fedinitstring="--federates=1"): fedinfo = h.helicsFederateInfoCreate() status = h.helicsFederateInfoSetFederateName(fedinfo, "Value 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.helicsCreateValueFederate(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, 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 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()
# 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") # Register the publication # pub = h.helicsFederateRegisterGlobalPublication(vfed, "testA", "double", "") print("PI SENDER: Publication registered") # Enter execution mode # status = h.helicsFederateEnterExecutionMode(vfed) print("PI SENDER: Entering execution mode") # This federate will be publishing deltat*pi for numsteps steps # this_time = 0.0 value = pi for t in range(5, 10):
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")
# 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", "") print("PI SENDER: Publication registered") # Enter execution mode # h.helicsFederateEnterExecutingMode(vfed) print("PI SENDER: Entering execution mode") # This federate will be publishing deltat*pi for numsteps steps # this_time = 0.0 value = pi for t in range(5, 10):
# 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) # Create value federate # vfed = h.helicsCreateValueFederate("TestA Federate", fedinfo) print("PI SENDER: Value federate created") # Register the publication # pub = h.helicsFederateRegisterGlobalTypePublication(vfed, "testA", "double", "") print("PI SENDER: Publication registered") # Enter execution mode # h.helicsFederateEnterExecutingMode(vfed) print("PI SENDER: Entering execution mode") # This federate will be publishing deltat*pi for numsteps steps # this_time = 0.0 value = pi for t in range(5, 10):
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 createValueFederate(federates=1, name="A Federate", deltat=0.01): fedinfo = setupFederateInfo(name, federates, deltat) vFed = h.helicsCreateValueFederate(f"Test{name}", fedinfo) # assert vFed isa h.ValueFederate return vFed, fedinfo