def test_system_tests_federate_logging():
lfile = "log.txt"
rm(lfile, force=True)
core = h.helicsCreateCore("inproc", "clogf",
"--autobroker --log_level=trace")
fi = h.helicsCreateFederateInfo()
h.helicsFederateInfoSetBrokerKey(fi, "key")
h.helicsFederateInfoSetCoreName(fi, "clogf")
fed = h.helicsCreateValueFederate("f1", fi)
h.helicsFederateSetLogFile(fed, lfile)
h.helicsFederateLogLevelMessage(fed, 7, "hello")
h.helicsFederateLogErrorMessage(fed, "hello")
h.helicsFederateLogDebugMessage(fed, "hello")
h.helicsFederateLogWarningMessage(fed, "hello")
h.helicsFederateClearMessages(fed)
h.helicsCoreSetLogFile(core, lfile)
h.helicsCoreDisconnect(core)
h.helicsFederateFinalize(fed)
h.helicsFederateInfoFree(fi)
h.helicsCloseLibrary()
assert isfile(lfile)
rm(lfile, force=True)
def _create_helics_federate(self):
self.fedinfo = helics.helicsCreateFederateInfo()
helics.helicsFederateInfoSetCoreName(self.fedinfo, self._options['Helics']['Federate name'])
helics.helicsFederateInfoSetCoreTypeFromString(self.fedinfo, self._options['Helics']['Core type'])
helics.helicsFederateInfoSetCoreInitString(self.fedinfo, f"--federates=1")
bLoc = self._options['Helics']['Broker']
Port = self._options['Helics']['Broker port']
self._logger.info("Connecting to broker @ {}".format(f"{bLoc}:{Port}" if Port else bLoc))
if self._options['Helics']['Broker']:
helics.helicsFederateInfoSetBroker(self.fedinfo, self._options['Helics']['Broker'])
if self._options['Helics']['Broker port']:
helics.helicsFederateInfoSetBrokerPort(self.fedinfo, self._options['Helics']['Broker port'])
helics.helicsFederateInfoSetTimeProperty(self.fedinfo, helics.helics_property_time_delta,
self._options['Helics']['Time delta'])
helics.helicsFederateInfoSetIntegerProperty(self.fedinfo, helics.helics_property_int_log_level,
self._options['Helics']['Helics logging level'])
helics.helicsFederateInfoSetFlagOption(self.fedinfo, helics.helics_flag_uninterruptible, True)
helics.helicsFederateInfoSetIntegerProperty(self.fedinfo, helics.helics_property_int_max_iterations,
self._options["Helics"]["Max co-iterations"])
self._PyDSSfederate = helics.helicsCreateValueFederate(self._options['Helics']['Federate name'], self.fedinfo)
return
def _create_helics_federate(self):
self.fedinfo = helics.helicsCreateFederateInfo()
helics.helicsFederateInfoSetCoreName(
self.fedinfo, self._settings.helics.federate_name)
helics.helicsFederateInfoSetCoreTypeFromString(
self.fedinfo, self._settings.helics.core_type)
helics.helicsFederateInfoSetCoreInitString(self.fedinfo,
f"--federates=1")
IP = self._settings.helics.broker
Port = self._settings.helics.broker_port
self._logger.info(
"Connecting to broker @ {}".format(f"{IP}:{Port}" if Port else IP))
if self._settings.helics.broker:
helics.helicsFederateInfoSetBroker(self.fedinfo,
self._settings.helics.broker)
if self._settings.helics.broker_port:
helics.helicsFederateInfoSetBrokerPort(
self.fedinfo, self._settings.helics.broker_port)
helics.helicsFederateInfoSetTimeProperty(
self.fedinfo, helics.helics_property_time_delta,
self._settings.helics.time_delta)
helics.helicsFederateInfoSetIntegerProperty(
self.fedinfo, helics.helics_property_int_log_level,
self._settings.helics.logging_level)
helics.helicsFederateInfoSetIntegerProperty(
self.fedinfo, helics.helics_property_int_max_iterations,
self._settings.helics.max_co_iterations)
self._PyDSSfederate = helics.helicsCreateValueFederate(
self._settings.helics.federate_name, self.fedinfo)
return
def create_helics_federate(self):
self.fedName = self.settings['helics']['federate_name']
self.fedinfo = h.helicsCreateFederateInfo()
h.helicsFederateInfoSetCoreName(
self.fedinfo, self.settings['helics']['federate_name'])
h.helicsFederateInfoSetCoreTypeFromString(
self.fedinfo, self.settings['helics']['core_type'])
h.helicsFederateInfoSetCoreInitString(self.fedinfo, f"--federates=1")
h.helicsFederateInfoSetBroker(self.fedinfo,
self.settings['helics']['broker'])
h.helicsFederateInfoSetBrokerPort(
self.fedinfo, self.settings['helics']['broker_port'])
h.helicsFederateInfoSetTimeProperty(
self.fedinfo, h.helics_property_time_delta,
self.settings['helics']['time_delta'])
h.helicsFederateInfoSetIntegerProperty(
self.fedinfo, h.helics_property_int_log_level,
self.settings['helics']['helics_logging_level'])
#h.helicsFederateInfoSetFlagOption(self.fedinfo, h.helics_flag_uninterruptible, True)
h.helicsFederateInfoSetIntegerProperty(
self.fedinfo, h.helics_property_int_max_iterations,
self.settings["helics"]["max_coiter"])
self.cymeFederate = h.helicsCreateValueFederate(
self.settings['helics']['federate_name'], self.fedinfo)
return
def setupFederateInfo(name="A Core", number=1, deltat=0.01):
fedinitstring = f"--broker=mainbroker --federates={number}"
# Create Federate Info object that describes the federate properties
fedinfo = h.helicsCreateFederateInfo()
# assert fedinfo isa h.FederateInfo
# # Set Federate name
h.helicsFederateInfoSetCoreName(fedinfo, f"Test{name}")
# # Set core type from string
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# # Federate init string
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# # Set the message interval (timedelta) for federate. Note th#
# # HELICS minimum message time interval is 1 ns and by default
# # it uses a time delta of 1 second. What is provided to the
# # setTimedelta routine is a multiplier for the default timedelta.
# # Set one second message interval
h.helicsFederateInfoSetTimeProperty(fedinfo, h.HELICS_PROPERTY_TIME_DELTA,
deltat)
h.helicsFederateInfoSetIntegerProperty(fedinfo,
h.HELICS_PROPERTY_INT_LOG_LEVEL, -1)
return fedinfo
def AddFederate(broker,
core_type="zmq",
count=1,
deltat=1.0,
name_prefix="fed"):
# Create Federate Info object that describes the federate properties #
fedinfo = h.helicsCreateFederateInfo()
# Set Federate name #
h.helicsFederateInfoSetCoreName(fedinfo, name_prefix)
# Set core type from string #
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string #
fedinitstring = "--broker=mainbroker --federates={}".format(count)
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# Set the message interval (timedelta) for federate. Note th#
# HELICS minimum message time interval is 1 ns and by default
# it uses a time delta of 1 second. What is provided to the
# setTimedelta routine is a multiplier for the default timedelta.
# Set one second message interval #
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta,
deltat)
h.helicsFederateInfoSetIntegerProperty(fedinfo,
h.helics_property_int_log_level, 1)
mFed = h.helicsCreateMessageFederate(name_prefix, fedinfo)
return mFed, fedinfo
def test_value_federate_runFederateTimeoutTest(helicsBroker):
fedinitstring = "--broker=mainbroker --federates=1"
deltat = 0.01
# Create Federate Info object that describes the federate properties #
fedinfo = h.helicsCreateFederateInfo()
# Set Federate name #
h.helicsFederateInfoSetCoreName(fedinfo, "TestA Core")
# Set core type from string #
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string #
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# Set the message interval (timedelta) for federate. Note th#
# HELICS minimum message time interval is 1 ns and by default
# it uses a time delta of 1 second. What is provided to the
# setTimedelta routine is a multiplier for the default timedelta.
# Set one second message interval #
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta,
deltat)
h.helicsFederateInfoSetIntegerProperty(fedinfo,
h.helics_property_int_log_level, 1)
vFed = h.helicsCreateValueFederate("TestA Federate", fedinfo)
defaultValue = "String1"
testValue = "String2"
pubid = h.helicsFederateRegisterGlobalPublication(
vFed, "pub1", h.helics_data_type_string, "")
subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "")
h.helicsInputSetDefaultString(subid, defaultValue)
h.helicsFederateEnterExecutingMode(vFed)
counter = 60
while counter > 0:
counter -= 1
time.sleep(1)
# Broker should be connected at this point
assert h.helicsBrokerIsConnected(
helicsBroker) == 1, "Broker should still be connected"
h.helicsFederateFinalize(vFed)
state = h.helicsFederateGetState(vFed)
assert state == 3
while (h.helicsBrokerIsConnected(helicsBroker)):
time.sleep(1)
h.helicsFederateInfoFree(fedinfo)
h.helicsFederateFree(vFed)
def __init__(self, core_type = "zmq", time_delta = 1): self.__fedinfo = h.helicsCreateFederateInfo() h.helicsFederateInfoSetCoreName(self.__fedinfo, "") h.helicsFederateInfoSetCoreTypeFromString(self.__fedinfo, core_type) h.helicsFederateInfoSetCoreInitString(self.__fedinfo, "--federates=1") h.helicsFederateInfoSetTimeProperty(self.__fedinfo, h.helics_property_time_delta, time_delta) self.vfed = "" self.pub = [] self.sub = []
def create_federate(deltat=1.0, fedinitstring="--federates=1"):
fedinfo = h.helicsCreateFederateInfo()
h.helicsFederateInfoSetCoreName(fedinfo, "PythonLoadshedFederate")
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta,
deltat)
fed = h.helicsCreateCombinationFederate("PythonLoadshedFederate", fedinfo)
return fed
def vFed():
initstring = "-f 1 --name=mainbroker"
fedinitstring = "--broker=mainbroker --federates=1"
deltat = 0.01
#TODO: should add an assert here about helicsGetVersion
h.helicsGetVersion()
# Create broker #
broker = h.helicsCreateBroker("zmq", "", initstring)
isconnected = h.helicsBrokerIsConnected(broker)
if isconnected == 1:
pass
# Create Federate Info object that describes the federate properties #
fedinfo = h.helicsCreateFederateInfo()
# Set Federate name #
h.helicsFederateInfoSetCoreName(fedinfo, "TestA Core")
# Set core type from string #
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string #
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# Set the message interval (timedelta) for federate. Note th#
# HELICS minimum message time interval is 1 ns and by default
# it uses a time delta of 1 second. What is provided to the
# setTimedelta routine is a multiplier for the default timedelta.
# Set one second message interval #
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta,
deltat)
h.helicsFederateInfoSetIntegerProperty(fedinfo,
h.helics_property_int_log_level, 1)
vFed = h.helicsCreateValueFederate("TestA Federate", fedinfo)
yield vFed
h.helicsFederateFinalize(vFed)
state = h.helicsFederateGetState(vFed)
assert state == 3
while (h.helicsBrokerIsConnected(broker)):
time.sleep(1)
h.helicsFederateInfoFree(fedinfo)
h.helicsFederateFree(vFed)
h.helicsCloseLibrary()
def mFed():
initstring = "-f 1 --name=mainbroker"
fedinitstring = "--broker=mainbroker --federates=1"
deltat = 0.01
h.helicsGetVersion()
# Create broker #
broker = h.helicsCreateBroker("zmq", "", initstring)
isconnected = h.helicsBrokerIsConnected(broker)
if isconnected == 1:
pass
# Create Federate Info object that describes the federate properties #
fedinfo = h.helicsCreateFederateInfo()
# Set Federate name #
h.helicsFederateInfoSetCoreName(fedinfo, "CoreA Federate")
# Set core type from string #
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string #
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# Set the message interval (timedelta) for federate. Note th#
# HELICS minimum message time interval is 1 ns and by default
# it uses a time delta of 1 second. What is provided to the
# setTimedelta routine is a multiplier for the default timedelta.
# Set one second message interval #
h.helicsFederateInfoSetTimeProperty(fedinfo, h.HELICS_PROPERTY_TIME_DELTA,
deltat)
h.helicsFederateInfoSetIntegerProperty(fedinfo,
h.HELICS_PROPERTY_INT_LOG_LEVEL, 1)
mFed = h.helicsCreateMessageFederate("TestA Federate", fedinfo)
yield mFed
h.helicsFederateFinalize(mFed)
state = h.helicsFederateGetState(mFed)
assert state == 3
while h.helicsBrokerIsConnected(broker):
time.sleep(1)
h.helicsFederateInfoFree(fedinfo)
h.helicsFederateFree(mFed)
h.helicsCloseLibrary()
def create_value_federate(self, coreName):
"""This function creates a value federate.
Args:
coreName (str) - The name of the core for creating the
value federate.
Returns:
vFed (helics federate object) - The value federate.
"""
name = "echohub Test--T"
fi = h.helicsCreateFederateInfo()
h.helicsFederateInfoSetCoreName(fi, coreName)
global vFed
vFed = h.helicsCreateValueFederate(name, fi)
logging.info("echo hub - created the value federate")
return vFed
def create_federate(self):
fedinfo = h.helicsCreateFederateInfo()
h.helicsFederateInfoSetCoreName(fedinfo,
self.settings['Federate name'])
h.helicsFederateInfoSetCoreTypeFromString(fedinfo,
self.settings['Core type'])
h.helicsFederateInfoSetCoreInitString(fedinfo, "--federates=1")
h.helicsFederateInfoSetTimeProperty(
fedinfo, h.helics_property_time_delta,
self.settings["Step resolution (sec)"])
h.helicsFederateInfoSetIntegerProperty(
fedinfo, h.helics_property_int_log_level,
self.settings['Helics logging level'])
h.helicsFederateInfoSetFlagOption(fedinfo,
h.helics_flag_uninterruptible, True)
self.PSSEfederate = h.helicsCreateValueFederate(
self.settings['Federate name'], fedinfo)
return
def create_value_federate(deltat=1.0, fedinitstring="--federates=1 --tick=0"):
fedinfo = h.helicsCreateFederateInfo()
h.helicsFederateInfoSetCoreName(fedinfo, "TestB Federate")
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta,
deltat)
h.helicsFederateInfoSetIntegerProperty(fedinfo,
h.helics_property_int_log_level, 1)
fed = h.helicsCreateCombinationFederate("TestB Federate", fedinfo)
return fed
def _create_helics_federate(self):
self.fedinfo = helics.helicsCreateFederateInfo()
helics.helicsFederateInfoSetCoreName(self.fedinfo, self._options['Helics']['Federate name'])
helics.helicsFederateInfoSetCoreTypeFromString(self.fedinfo, self._options['Helics']['Core type'])
helics.helicsFederateInfoSetCoreInitString(self.fedinfo, f"--federates=1")
#helics.helicsFederateInfoSetBroker(self.fedinfo, self._options['Helics']['Broker'])
#helics.helicsFederateInfoSetBrokerPort(self.fedinfo, self._options['Helics']['Broker port'])
helics.helicsFederateInfoSetTimeProperty(self.fedinfo, helics.helics_property_time_delta,
self._options['Helics']['Time delta'])
helics.helicsFederateInfoSetIntegerProperty(self.fedinfo, helics.helics_property_int_log_level,
self._options['Helics']['Helics logging level'])
helics.helicsFederateInfoSetFlagOption(self.fedinfo, helics.helics_flag_uninterruptible, True)
helics.helicsFederateInfoSetIntegerProperty(self.fedinfo, helics.helics_property_int_max_iterations,
self._options["Helics"]["Max co-iterations"])
self._PyDSSfederate = helics.helicsCreateValueFederate(self._options['Helics']['Federate name'], self.fedinfo)
return
def create_value_federate(self, coreName, index):
"""This function creates a value federate.
Args:
coreName (str) - The name of the core for creating the
value federate.
index (int) - The number that indicates which value federate
is created and used during the test.
Returns:
vFed (helics federate object) - The value federate.
"""
name = "echoleaf_{} Test--T".format(index)
fi = h.helicsCreateFederateInfo()
h.helicsFederateInfoSetCoreName(fi, coreName)
global vFed
vFed = h.helicsCreateValueFederate(name, fi)
logging.info("echo leaf - created the value federate")
return vFed
def create_federate(deltat=1.0, fedinitstring="--federates=1"):
fedinfo = h.helicsCreateFederateInfo()
h.helicsFederateInfoSetCoreName(fedinfo, "Combination Federate A")
# assert status == 0
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# assert status == 0
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# assert status == 0
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta,
deltat)
# assert status == 0
# h.helicsFederateInfoSetLoggingLevel(fedinfo, 1)
# assert status == 0
fed = h.helicsCreateCombinationFederate("Combination Federate A", fedinfo)
return fed
print("Creating Broker")
broker = h.helicsCreateBroker("zmq", "", initstring)
print("Created Broker")
print("Checking if Broker is connected")
isconnected = h.helicsBrokerIsConnected(broker)
print("Checked if Broker is connected")
if isconnected == 1:
print("Broker created and connected")
# Create Federate Info object that describes the federate properties #
fedinfo = h.helicsCreateFederateInfo()
# Set Federate name #
h.helicsFederateInfoSetCoreName(fedinfo, "TestA Federate")
# Set core type from string #
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string #
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# Set the message interval (timedelta) for federate. Note th#
# HELICS minimum message time interval is 1 ns and by default
# it uses a time delta of 1 second. What is provided to the
# setTimedelta routine is a multiplier for the default timedelta.
# Set one second message interval #
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat)
print("Creating Broker")
broker = h.helicsCreateBroker("zmq", "", brokerinitstring)
print("Created Broker")
print("Checking if Broker is connected")
isconnected = h.helicsBrokerIsConnected(broker)
print("Checked if Broker is connected")
if isconnected == 1:
print("Broker created and connected")
# Create Federate Info object that describes the federate properties #
fedinfo = h.helicsCreateFederateInfo()
# Set Federate name #
h.helicsFederateInfoSetCoreName(fedinfo, "TestA Federate")
# Set core type from string #
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string #
h.helicsFederateInfoSetCoreInitString(fedinfo, federateinitstring)
# Set the message interval (timedelta) for federate. Note th#
# HELICS minimum message time interval is 1 ns and by default
# it uses a time delta of 1 second. What is provided to the
# setTimedelta routine is a multiplier for the default timedelta.
# Set one second message interval #
h.helicsFederateInfoSetTimeProperty(fedinfo, h.HELICS_PROPERTY_TIME_DELTA, deltat)
def run_sub_trans(feeders, broker_address):
fedinitstring = "--federates=1"
if broker_address is not None:
fedinitstring = f"{fedinitstring} --broker_address=tcp://{broker_address}"
deltat = 0.01
print(f"{fed_name}: Helics version = {h.helicsGetVersion()}")
# Create Federate Info object that describes the federate properties #
fedinfo = h.helicsCreateFederateInfo()
# Set Federate name #
h.helicsFederateInfoSetCoreName(fedinfo, fed_name)
# Set core type from string #
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string #
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# Set the message interval (timedelta) for federate. Note th#
# HELICS minimum message time interval is 1 ns and by default
# it uses a time delta of 1 second. What is provided to the
# setTimedelta routine is a multiplier for the default timedelta.
# Set one second message interval #
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat)
# Create value federate #
vfed = h.helicsCreateValueFederate(fed_name, fedinfo)
print("Value federate created")
# Register the publication #
print(f"{fed_name}: Publication registered")
pubs = []
subs = []
for feeder in feeders:
pub_name = f"{feeder}.voltage"
pubs.append(
h.helicsFederateRegisterGlobalTypePublication(
vfed, pub_name, "double", "pu"
)
)
print(f"{fed_name}: publication {pub_name} registered")
sub_name = "Circuit.{feeder}.TotalPower.E"
subs.append(h.helicsFederateRegisterSubscription(vfed, sub_name, "kW"))
print(f"{fed_name}: subscription {sub_name} registered")
# Enter execution mode
h.helicsFederateEnterExecutingMode(vfed)
print(f"{fed_name} Entering executing mode")
# start execution loop
n_feeders = len(feeders)
currenttime = 0
desiredtime = 0.0
t = 0.0
end_time = 24 * 3600
while desiredtime <= end_time:
# publish
desiredtime = t * 15 * 60
currenttime = h.helicsFederateRequestTime(vfed, desiredtime)
if currenttime >= desiredtime:
for p in pubs:
h.helicsPublicationPublishDouble(p, 1.01)
for i in range(n_feeders):
value = h.helicsInputGetDouble(subs[i])
print(
f"Circuit {feeders[i]} active power demand: {value} kW at time: {currenttime}."
)
t += 1
# all other federates should have finished, so now you can close the broker
h.helicsFederateFinalize(vfed)
print(f"{fed_name}: Test Federate finalized")
h.helicsFederateDestroy(vfed)
print(f"{fed_name}: test federate destroyed")
h.helicsFederateFree(vfed)
print("federate freed")
h.helicsCloseLibrary()
print("library closed")
def run_p1uhs_federate(fed_name, broker_address=None):
fedinitstring = "--federates=1"
if broker_address is not None:
fedinitstring = f"{fedinitstring} --broker_address=tcp://{broker_address}"
deltat = 0.01
print(f"{fed_name}: Helics version = {h.helicsGetVersion()}")
# Create Federate Info object that describes the federate properties #
fedinfo = h.helicsCreateFederateInfo()
# Set Federate name #
h.helicsFederateInfoSetCoreName(fedinfo, fed_name)
# Set core type from string #
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string #
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# Set the message interval (timedelta) for federate. Note th#
# HELICS minimum message time interval is 1 ns and by default
# it uses a time delta of 1 second. What is provided to the
# setTimedelta routine is a multiplier for the default timedelta.
# Set one second message interval #
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta,
deltat)
# Create value federate #
vfed = h.helicsCreateValueFederate(fed_name, fedinfo)
print("Value federate created")
# Register the publications #
pub_name = "Circuit.feeder_p1u.{fed_name}.p1ux.TotalPower.E"
pub_load = h.helicsFederateRegisterGlobalTypePublication(
vfed, pub_name, "double", "kW")
print(f"{fed_name}: publication {pub_name} registered")
# Register subscriptions #
# subscribe to voltage supplied
sub_name = f"Circuit.feeder_p1u.{fed_name}.p1ux.voltage"
sub_voltage = h.helicsFederateRegisterSubscription(vfed, sub_name, "pu")
# subscribe to reiteration flag
# sub_flag = h.helicsFederateRegisterSubscription(vfed, "reiterate_flag", None)
# h.helicsFederateSetIntegerProperty(vfed, h.helics_property_int_max_iterations, 10)
# Enter execution mode #
h.helicsFederateEnterExecutingMode(vfed)
# fed_iteration_state = h.helicsFederateEnterExecutingModeIterative(vfed, h.helics_iteration_request_iterate_if_needed)
print(f"{fed_name}: Entering execution mode")
# start execution loop #
desiredtime = 0.0
t = 0.0
end_time = 24 * 3600 # 95*15*60
while desiredtime <= end_time:
# check time
desiredtime = t * 15 * 60
currenttime = h.helicsFederateRequestTime(vfed, desiredtime)
if currenttime >= desiredtime:
# reiterate until convergence
last_voltage = 1.0
iters = 1
iteration_state = h.helics_iteration_result_iterating
while iteration_state == h.helics_iteration_result_iterating:
supply_voltage, load = pub_and_sub_calc(
sub_voltage, pub_load, iters)
currenttime, iteration_state = h.helicsFederateRequestTimeIterative(
vfed, desiredtime,
h.helics_iteration_request_iterate_if_needed)
if abs(last_voltage - supply_voltage) < 1e-20:
iteration_state = -1
iters += 1
last_voltage = supply_voltage
logging.info(
"p1uhs0 load {} with voltage {} at time {} after {} iters".
format(load, supply_voltage, currenttime, iters))
t += 1
# all other federates should have finished, so now you can close
h.helicsFederateFinalize(vfed)
print(f"{fed_name}: Test Federate finalized")
h.helicsFederateDestroy(vfed)
print(f"{fed_name}: test federate destroyed")
h.helicsFederateFree(vfed)
print(f"{fed_name}: federate freed")
h.helicsCloseLibrary()
print(f"{fed_name}: library closed")
def test_misc_api():
fedInfo1 = h.helicsCreateFederateInfo()
h.helicsFederateInfoSetCoreInitString(fedInfo1, "-f 1")
h.helicsFederateInfoSetCoreName(fedInfo1, "core3")
h.helicsFederateInfoSetCoreType(fedInfo1, 3)
h.helicsFederateInfoSetCoreTypeFromString(fedInfo1, "zmq")
h.helicsFederateInfoSetFlagOption(fedInfo1, 1, True)
h.helicsFederateInfoSetTimeProperty(fedInfo1,
h.HELICS_PROPERTY_TIME_INPUT_DELAY,
1.0)
h.helicsFederateInfoSetIntegerProperty(fedInfo1,
h.HELICS_PROPERTY_INT_LOG_LEVEL, 1)
h.helicsFederateInfoSetIntegerProperty(
fedInfo1, h.HELICS_PROPERTY_INT_MAX_ITERATIONS, 100)
h.helicsFederateInfoSetTimeProperty(fedInfo1,
h.HELICS_PROPERTY_TIME_OUTPUT_DELAY,
1.0)
h.helicsFederateInfoSetTimeProperty(fedInfo1,
h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
h.helicsFederateInfoSetTimeProperty(fedInfo1, h.HELICS_PROPERTY_TIME_DELTA,
1.0)
h.helicsFederateInfoSetTimeProperty(fedInfo1,
h.HELICS_PROPERTY_TIME_OFFSET, 0.1)
h.helicsFederateInfoFree(fedInfo1)
broker3 = h.helicsCreateBroker("zmq", "broker3",
"--federates 1 --loglevel 1")
fedInfo2 = h.helicsCreateFederateInfo()
coreInitString = "--federates 1"
h.helicsFederateInfoSetCoreInitString(fedInfo2, coreInitString)
h.helicsFederateInfoSetCoreTypeFromString(fedInfo2, "zmq")
h.helicsFederateInfoSetIntegerProperty(fedInfo2,
h.HELICS_PROPERTY_INT_LOG_LEVEL, 1)
h.helicsFederateInfoSetTimeProperty(fedInfo2, h.HELICS_PROPERTY_TIME_DELTA,
1.0)
fed1 = h.helicsCreateCombinationFederate("fed1", fedInfo2)
fed2 = h.helicsFederateClone(fed1)
_ = h.helicsGetFederateByName("fed1")
h.helicsFederateSetFlagOption(fed2, 1, False)
h.helicsFederateSetTimeProperty(fed2, h.HELICS_PROPERTY_TIME_INPUT_DELAY,
1.0)
h.helicsFederateSetIntegerProperty(fed1, h.HELICS_PROPERTY_INT_LOG_LEVEL,
1)
h.helicsFederateSetIntegerProperty(fed2,
h.HELICS_PROPERTY_INT_MAX_ITERATIONS,
100)
h.helicsFederateSetTimeProperty(fed2, h.HELICS_PROPERTY_TIME_OUTPUT_DELAY,
1.0)
h.helicsFederateSetTimeProperty(fed2, h.HELICS_PROPERTY_TIME_PERIOD, 0.0)
h.helicsFederateSetTimeProperty(fed2, h.HELICS_PROPERTY_TIME_DELTA, 1.0)
_ = h.helicsFederateRegisterCloningFilter(fed1, "fed1/Ep1")
fed1DestinationFilter = h.helicsFederateRegisterFilter(
fed1, h.HELICS_FILTER_TYPE_DELAY, "fed1DestinationFilter")
h.helicsFilterAddDestinationTarget(fed1DestinationFilter, "Ep2")
ep1 = h.helicsFederateRegisterEndpoint(fed1, "Ep1", "string")
ep2 = h.helicsFederateRegisterGlobalEndpoint(fed1, "Ep2", "string")
pub1 = h.helicsFederateRegisterGlobalPublication(fed1, "pub1",
h.HELICS_DATA_TYPE_DOUBLE,
"")
pub2 = h.helicsFederateRegisterGlobalTypePublication(
fed1, "pub2", "complex", "")
sub1 = h.helicsFederateRegisterSubscription(fed1, "pub1")
sub2 = h.helicsFederateRegisterSubscription(fed1, "pub2")
h.helicsInputAddTarget(sub2, "Ep2")
pub3 = h.helicsFederateRegisterPublication(fed1, "pub3",
h.HELICS_DATA_TYPE_STRING, "")
pub1KeyString = h.helicsPublicationGetKey(pub1)
pub1TypeString = h.helicsPublicationGetType(pub1)
pub1UnitsString = h.helicsPublicationGetUnits(pub1)
sub1KeyString = h.helicsSubscriptionGetKey(sub1)
sub1UnitsString = h.helicsInputGetUnits(sub1)
assert "pub1" == pub1KeyString
assert "double" == pub1TypeString
assert "" == pub1UnitsString
assert "pub1" == sub1KeyString
assert "" == sub1UnitsString
fed1SourceFilter = h.helicsFederateRegisterFilter(
fed1, h.HELICS_FILTER_TYPE_DELAY, "fed1SourceFilter")
h.helicsFilterAddSourceTarget(fed1SourceFilter, "Ep2")
h.helicsFilterAddDestinationTarget(fed1SourceFilter, "fed1/Ep1")
h.helicsFilterRemoveTarget(fed1SourceFilter, "fed1/Ep1")
h.helicsFilterAddSourceTarget(fed1SourceFilter, "Ep2")
h.helicsFilterRemoveTarget(fed1SourceFilter, "Ep2")
fed1SourceFilterNameString = h.helicsFilterGetName(fed1SourceFilter)
assert fed1SourceFilterNameString == "fed1/fed1SourceFilter"
sub3 = h.helicsFederateRegisterSubscription(fed1, "fed1/pub3", "")
pub4 = h.helicsFederateRegisterTypePublication(fed1, "pub4", "int", "")
sub4 = h.helicsFederateRegisterSubscription(fed1, "fed1/pub4", "")
pub5 = h.helicsFederateRegisterGlobalTypePublication(
fed1, "pub5", "boolean", "")
sub5 = h.helicsFederateRegisterSubscription(fed1, "pub5", "")
pub6 = h.helicsFederateRegisterGlobalPublication(fed1, "pub6",
h.HELICS_DATA_TYPE_VECTOR,
"")
sub6 = h.helicsFederateRegisterSubscription(fed1, "pub6", "")
pub7 = h.helicsFederateRegisterGlobalPublication(
fed1, "pub7", h.HELICS_DATA_TYPE_NAMED_POINT, "")
sub7 = h.helicsFederateRegisterSubscription(fed1, "pub7", "")
assert """helics.HelicsPublication(name = "pub1", type = "double", units = "", info = "")""" in repr(
pub1)
assert """helics.HelicsPublication(name = "pub2", type = "complex", units = "", info = "")""" in repr(
pub2)
assert """helics.HelicsPublication(name = "fed1/pub3", type = "string", units = "", info = "")""" in repr(
pub3)
assert """helics.HelicsPublication(name = "fed1/pub4", type = "int", units = "", info = "")""" in repr(
pub4)
assert """helics.HelicsPublication(name = "pub5", type = "boolean", units = "", info = "")""" in repr(
pub5)
assert """helics.HelicsPublication(name = "pub6", type = "double_vector", units = "", info = "")""" in repr(
pub6)
assert """helics.HelicsPublication(name = "pub7", type = "named_point", units = "", info = "")""" in repr(
pub7)
assert (
"""helics.HelicsInput(name = "_input_18", units = "", injection_units = "", publication_type = "", type = "", target = "pub7", info = "")"""
in repr(sub7))
h.helicsInputSetDefaultBoolean(sub5, False)
h.helicsInputSetDefaultComplex(sub2, -9.9 + 2.5j)
h.helicsInputSetDefaultDouble(sub1, 3.4)
h.helicsInputSetDefaultInteger(sub4, 6)
h.helicsInputSetDefaultNamedPoint(sub7, "hollow", 20.0)
h.helicsInputSetDefaultString(sub3, "default")
sub6Default = [3.4, 90.9, 4.5]
h.helicsInputSetDefaultVector(sub6, sub6Default)
h.helicsEndpointSubscribe(ep2, "fed1/pub3")
h.helicsFederateEnterInitializingModeAsync(fed1)
rs = h.helicsFederateIsAsyncOperationCompleted(fed1)
if rs == 0:
time.sleep(0.500)
rs = h.helicsFederateIsAsyncOperationCompleted(fed1)
if rs == 0:
time.sleep(0.500)
rs = h.helicsFederateIsAsyncOperationCompleted(fed1)
if rs == 0:
assert True is False
h.helicsFederateEnterInitializingModeComplete(fed1)
h.helicsFederateEnterExecutingModeAsync(fed1)
h.helicsFederateEnterExecutingModeComplete(fed1)
assert (
"""helics.HelicsInput(name = "_input_18", units = "", injection_units = "", publication_type = "named_point", type = "", target = "pub7", info = "")"""
in repr(sub7))
mesg1 = h.helicsFederateCreateMessage(fed1)
h.helicsMessageSetString(mesg1, "Hello")
h.helicsMessageSetSource(mesg1, "fed1/Ep1")
h.helicsMessageSetOriginalSource(mesg1, "fed1/Ep1")
h.helicsMessageSetDestination(mesg1, "Ep2")
h.helicsMessageSetOriginalDestination(mesg1, "Ep2")
h.helicsEndpointSendMessage(ep1, mesg1)
mesg1 = h.helicsFederateCreateMessage(fed1)
h.helicsMessageSetString(mesg1, "There")
h.helicsMessageSetSource(mesg1, "fed1/Ep1")
h.helicsMessageSetOriginalSource(mesg1, "fed1/Ep1")
h.helicsMessageSetDestination(mesg1, "Ep2")
h.helicsMessageSetOriginalDestination(mesg1, "Ep2")
h.helicsEndpointSendMessage(ep1, mesg1)
h.helicsEndpointSetDefaultDestination(ep2, "fed1/Ep1")
ep1NameString = h.helicsEndpointGetName(ep1)
ep1TypeString = h.helicsEndpointGetType(ep1)
assert ep1NameString == "fed1/Ep1"
assert ep1TypeString == "string"
_ = h.helicsFederateGetCoreObject(fed1)
fed1Time = h.helicsFederateGetCurrentTime(fed1)
assert fed1Time == 0.0
fed1EndpointCount = h.helicsFederateGetEndpointCount(fed1)
assert fed1EndpointCount == 2
fed1NameString = h.helicsFederateGetName(fed1)
assert fed1NameString == "fed1"
fed1State = h.helicsFederateGetState(fed1)
assert fed1State == 2
fed1PubCount = h.helicsFederateGetPublicationCount(fed1)
assert fed1PubCount == 7
fed1SubCount = h.helicsFederateGetInputCount(fed1)
assert fed1SubCount == 7
h.helicsPublicationPublishBoolean(pub5, True)
h.helicsPublicationPublishComplex(pub2, 5.6 + -0.67j)
h.helicsPublicationPublishDouble(pub1, 457.234)
h.helicsPublicationPublishInteger(pub4, 1)
h.helicsPublicationPublishNamedPoint(pub7, "Blah Blah", 20.0)
h.helicsPublicationPublishString(pub3, "Mayhem")
pub6Vector = [4.5, 56.5]
h.helicsPublicationPublishVector(pub6, pub6Vector)
time.sleep(0.500)
h.helicsFederateRequestTimeAsync(fed1, 1.0)
returnTime = h.helicsFederateRequestTimeComplete(fed1)
assert returnTime == 1.0
ep2MsgCount = h.helicsEndpointPendingMessages(ep2)
assert ep2MsgCount == 2
ep2HasMsg = h.helicsEndpointHasMessage(ep2)
assert ep2HasMsg == 1
msg2 = h.helicsEndpointGetMessage(ep2)
assert h.helicsMessageGetTime(msg2) == 1.0
assert h.helicsMessageGetString(msg2) == "Hello"
assert h.helicsMessageGetOriginalSource(msg2) == "fed1/Ep1"
assert h.helicsMessageGetSource(msg2) == "fed1/Ep1"
assert h.helicsMessageGetDestination(msg2) == "Ep2"
assert h.helicsMessageGetOriginalDestination(msg2) == "Ep2"
fed1MsgCount = h.helicsFederatePendingMessages(fed1)
assert fed1MsgCount == 1
assert h.helicsFederateHasMessage(fed1) == 1
msg3 = h.helicsFederateGetMessage(fed1)
assert h.helicsMessageGetTime(msg3) == 1.0
assert h.helicsMessageGetString(msg3) == "There"
assert h.helicsMessageGetOriginalSource(msg3) == "fed1/Ep1"
assert h.helicsMessageGetSource(msg3) == "fed1/Ep1"
assert h.helicsMessageGetDestination(msg3) == "Ep2"
assert h.helicsMessageGetOriginalDestination(msg3) == "Ep2"
sub1Updated = h.helicsInputIsUpdated(sub1)
# TODO: figure out why this test is broken
assert sub1Updated is False
# TODO: figure out why this test is broken
assert h.helicsInputLastUpdateTime(sub2) == 0.0
# assert h.helicsInputGetComplex(sub2) == 5.6 - 0.67j
# assert h.helicsInputGetDouble(sub1) == 457.234
# assert h.helicsInputGetInteger(sub4) == 1
sub7PointString, sub7DoubleValue = h.helicsInputGetNamedPoint(sub7)
# assert sub7PointString == "Blah Blah"
assert sub7DoubleValue == 20.0
# assert h.helicsInputGetBoolean(sub5) == True
# assert h.helicsInputGetString(sub3) == "Mayhem"
sub3ValueSize = h.helicsInputGetRawValueSize(sub3)
# assert sub3ValueSize == 6
# assert h.helicsInputGetVector(sub6) == [4.5, 56.5]
h.helicsFederateFinalize(fed1)
h.helicsFederateFinalize(fed2)
h.helicsFederateFree(fed1)
h.helicsFederateFinalize(fed2)
h.helicsFederateFree(fed2)
h.helicsFederateInfoFree(fedInfo2)
h.helicsBrokerDisconnect(broker3)
h.helicsBrokerFree(broker3)
h.helicsCleanupLibrary()
h.helicsCloseLibrary()
def run_p1u_federate(fed_name, broker_address, feeders):
fedinitstring = "--federates=1"
if broker_address is not None:
fedinitstring = f"{fedinitstring} --broker_address=tcp://{broker_address}"
deltat = 0.01
print(f"{fed_name}: Helics version = {h.helicsGetVersion()}")
# Create Federate Info object that describes the federate properties
fedinfo = h.helicsCreateFederateInfo()
# Set Federate name
h.helicsFederateInfoSetCoreName(fedinfo, fed_name)
# Set core type from string
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
# Federate init string
h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring)
# Set one second message interval
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat)
# Create value federate
vfed = h.helicsCreateValueFederate(fed_name, fedinfo)
print("Value federate created")
# Register the publications
pub_load = h.helicsFederateRegisterGlobalTypePublication(
vfed, "Circuit.full_network.TotalPower.E", "double", "kW"
)
pub_voltages = []
for feeder in feeders:
pub_name = f"Circuit.feeder_p1u.{feeder}.p1ux.voltage"
pub_voltages.append(
h.helicsFederateRegisterGlobalTypePublication(
vfed, pub_name, "double", "pu"
)
)
print(f"{fed_name}: publication {pub_name} registered")
# Register subscriptions
# subscribe to voltage supplied
sub_voltage = h.helicsFederateRegisterSubscription(
vfed, "full_network.voltage", "pu"
)
h.helicsInputSetDefaultDouble(sub_voltage, 1.0)
# subscribe to loads below
sub_loads = []
for feeder in feeders:
sub_name = f"Circuit.feeder_p1u.{feeder}.p1ux.TotalPower.E"
sub_loads.append(h.helicsFederateRegisterSubscription(vfed, sub_name, "kW"))
print(f"{fed_name}: subscription {sub_name} registered")
h.helicsFederateSetIntegerProperty(vfed, h.helics_property_int_max_iterations, 10)
# Enter execution mode
h.helicsFederateEnterExecutingMode(vfed)
print(f"{fed_name} Entering executing mode")
# start execution loop
n_feeders = len(feeders)
desiredtime = 0.0
t = 0.0
end_time = 24 * 3600
while desiredtime <= end_time:
# check time
desiredtime = t * 15 * 60
currenttime = h.helicsFederateRequestTime(vfed, desiredtime)
if currenttime >= desiredtime:
last_loads = [0 for i in range(0, n_feeders)]
# reiterate between supply voltage and loads for up to __ iterations
# get supply voltage
iters = 1
supply_voltage = h.helicsInputGetDouble(sub_voltage)
iteration_state = h.helics_iteration_result_iterating
while iteration_state == h.helics_iteration_result_iterating:
# if there is an iteration going on, publish and subscribe again
new_loads = pub_and_sub_calc(
supply_voltage, last_loads, sub_loads, pub_voltages
)
currenttime, iteration_state = h.helicsFederateRequestTimeIterative(
vfed, desiredtime, h.helics_iteration_request_iterate_if_needed
)
# find change in load and determine if you need to continue iterating
load_diff = 0
for i in range(n_feeders):
load_diff = load_diff + abs(new_loads[i] - last_loads[i])
if load_diff / n_feeders < 1e-3:
iteration_state = 0
last_loads = new_loads
iters += 1
h.helicsPublicationPublishDouble(pub_load, sum(last_loads))
logger.info(
"feeder loads {last_loads} at time {currenttime} after {iters} iters"
)
t += 1
# all other federates should have finished, so now you can close
h.helicsFederateFinalize(vfed)
print(f"{fed_name}: Test Federate finalized")
h.helicsFederateDestroy(vfed)
print(f"{fed_name}: test federate destroyed")
h.helicsFederateFree(vfed)
print(f"{fed_name}: federate freed")
h.helicsCloseLibrary()
print(f"{fed_name}: library closed")
# -*- coding: utf-8 -*-
import time
import sys
from math import pi
import helics as h
federate_name = f"SenderFederate{sys.argv[1]}"
print(f"{federate_name}: Helics version = {h.helicsGetVersion()}")
fedinfo = h.helicsCreateFederateInfo()
h.helicsFederateInfoSetCoreName(fedinfo, federate_name + "Core")
h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq")
h.helicsFederateInfoSetCoreInitString(fedinfo, "--federates=1")
h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, 0.01)
vfed = h.helicsCreateValueFederate(federate_name, fedinfo)
print(f"{federate_name}: Value federate created")
pub = h.helicsFederateRegisterGlobalTypePublication(
vfed, f"globaltopic{sys.argv[1]}", "double", ""
)
pub = h.helicsFederateRegisterTypePublication(
vfed, f"localtopic{sys.argv[1]}", "double", ""
)
print(f"{federate_name}: Publication registered")
h.helicsFederateEnterExecutingMode(vfed)
# -*- coding: utf-8 -*-
import time
import helics as h
# Create broker #
broker = h.helicsCreateBroker("zmq", "", "-f 2 --name=BeamBroker")
isConnected = h.helicsBrokerIsConnected(broker)
if isConnected == 1:
print("Broker created and connected")
fedInfo = h.helicsCreateFederateInfo()
fedName = "BeamFederateReader"
h.helicsFederateInfoSetCoreName(fedInfo, fedName)
h.helicsFederateInfoSetCoreTypeFromString(fedInfo, "zmq")
h.helicsFederateInfoSetCoreInitString(fedInfo, "--federates=1")
# deltat is multiplied for default timedelta of 1 second
h.helicsFederateInfoSetTimeProperty(fedInfo, h.helics_property_time_delta, 1.0)
cfed = h.helicsCreateCombinationFederate(fedName, fedInfo)
print("Subscribing...")
subs_chargingPlugIn = h.helicsFederateRegisterSubscription(
cfed, "BeamFederate/chargingPlugIn", "string")
subs_chargingPlugOut = h.helicsFederateRegisterSubscription(
cfed, "BeamFederate/chargingPlugOut", "string")
print("Waiting Execution Mode...")
h.helicsFederateEnterInitializingMode(cfed)
h.helicsFederateEnterExecutingMode(cfed)
# start execution loop #
timebin = 300
currenttime = 0
