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", "")
