def test_bad_input_tests_raw_tests():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "test")
pubid = h.helicsFederateRegisterPublication(vFed1, "pub1",
h.HELICS_DATA_TYPE_RAW, "")
subid = h.helicsFederateRegisterGlobalInput(vFed1, "inp1",
h.HELICS_DATA_TYPE_RAW, "")
h.helicsPublicationAddTarget(pubid, "inp1")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
h.helicsFederateEnterExecutingMode(vFed1)
h.helicsPublicationPublishRaw(pubid, b"hello world")
h.helicsFederateRequestNextStep(vFed1)
s = h.helicsInputGetRawValue(subid)
assert s == b"hello world"
h.helicsPublicationPublishDouble(pubid, 27)
h.helicsFederateRequestNextStep(vFed1)
s = h.helicsInputGetComplex(subid)
assert complex(*s) != 27 + 0j
h.helicsFederateFinalize(vFed1)
t, res = h.helicsFederateRequestTimeIterative(
vFed1, 1.0, h.HELICS_ITERATION_REQUEST_NO_ITERATION)
assert res == h.HELICS_ITERATION_RESULT_HALTED
destroyFederate(vFed1, fedinfo)
destroyBroker(broker)
def request_time_increment(self):
error = sum(
[abs(x[0] - x[1]) for k, x in self._subscription_dState.items()])
r_seconds = self._dss_solver.GetTotalSeconds(
) #- self._dss_solver.GetStepResolutionSeconds()
if not self._settings.helics.iterative_mode:
while self.c_seconds < r_seconds:
self.c_seconds = helics.helicsFederateRequestTime(
self._PyDSSfederate, r_seconds)
self._logger.info('Time requested: {} - time granted: {} '.format(
r_seconds, self.c_seconds))
return True, self.c_seconds
else:
self.c_seconds, iteration_state = helics.helicsFederateRequestTimeIterative(
self._PyDSSfederate, r_seconds,
helics.helics_iteration_request_iterate_if_needed)
self._logger.info(
'Time requested: {} - time granted: {} error: {} it: {}'.
format(r_seconds, self.c_seconds, error, self.itr))
if error > -1 and self.itr < self._co_convergance_max_iterations - 1:
self.itr += 1
return False, self.c_seconds
else:
self.itr = 0
return True, self.c_seconds
def request_time_increment(self):
error = sum([
abs(y["dStates"][0] - y["dStates"][1])
for k, x in self.Subscriptions.items() for y in x
])
r_seconds = self.Solver.GetTotalSeconds()
if not self.settings['helics']['coiter_mode']:
while self.c_seconds < r_seconds:
self.c_seconds = h.helicsFederateRequestTime(
self.cymeFederate, r_seconds)
self.__Logger.info('Time requested: {} - time granted: {} '.format(
r_seconds, self.c_seconds))
return True, self.c_seconds
else:
self.c_seconds, iteration_state = h.helicsFederateRequestTimeIterative(
self.cymeFederate, r_seconds,
h.helics_iteration_request_iterate_if_needed)
self.__Logger.info(
'Time requested: {} - time granted: {} error: {} it: {}'.
format(r_seconds, self.c_seconds, error, self.itr))
if error > -1 and self.itr < self.settings['helics']["max_coiter"]:
self.itr += 1
return False, self.c_seconds
else:
self.itr = 0
return True, self.c_seconds
basevolt = 2.40
X = 20.0
currenttime = 0
for t in range(0, 25):
time_requested = t * 60 * 60
iteration_state = h.helics_iteration_result_iterating
for i in range(5):
if i == 0:
while currenttime < time_requested:
currenttime = h.helicsFederateRequestTime(vfed, time_requested)
else:
currenttime, iteration_state = h.helicsFederateRequestTimeIterative(
vfed,
time_requested,
h.helics_iteration_request_force_iteration #helics_iteration_request_force_iteration, helics_iteration_request_iterate_if_needed
)
A = 200 + random.random() * X
B = 100 + random.random() * X
C = 400 + random.random() * X
D = 350 + random.random() * X
h.helicsPublicationPublishDouble(pubA, A)
h.helicsPublicationPublishDouble(pubB, B)
h.helicsPublicationPublishDouble(pubC, C)
h.helicsPublicationPublishDouble(pubD, D)
print(f"Powers published: {A}, {B}, {C}, {D}")
value1 = h.helicsInputGetDouble(sub1)
value2 = h.helicsInputGetDouble(sub2)
print("PSS/E voltages: bus 153 {} p.u., bus 154 {} p.u.".format(value1, value2))
print(f"Current time: {time_requested}, Granted time: {currenttime}")
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 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")
def test_iteration_async_test():
broker = createBroker(1)
vFed1, fedinfo1 = createValueFederate(1, "fed0")
vFed2, fedinfo2 = createValueFederate(1, "fed1")
# register the publications
pub1 = h.helicsFederateRegisterGlobalPublication(vFed1, "pub1",
h.HELICS_DATA_TYPE_INT)
sub1 = h.helicsFederateRegisterSubscription(vFed2, "pub1")
pub2 = h.helicsFederateRegisterGlobalPublication(vFed2, "pub2",
h.HELICS_DATA_TYPE_INT)
sub2 = h.helicsFederateRegisterSubscription(vFed1, "pub2")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
h.helicsFederateSetTimeProperty(vFed2, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
# vFed1->setLoggingLevel(5)
# vFed2->setLoggingLevel(5)
h.helicsFederateEnterInitializingModeAsync(vFed1)
h.helicsFederateEnterInitializingMode(vFed2)
h.helicsFederateEnterInitializingModeComplete(vFed1)
c1 = 0
c2 = 0
h.helicsPublicationPublishInteger(pub1, c1)
h.helicsPublicationPublishInteger(pub2, c2)
h.helicsFederateEnterExecutingModeAsync(vFed1)
h.helicsFederateEnterExecutingMode(vFed2)
h.helicsFederateEnterExecutingModeComplete(vFed1)
while c1 <= 10:
h.helicsInputGetInteger(sub1), c1
h.helicsInputGetInteger(sub2), c2
c1 += 1
c2 += 1
if c1 <= 10:
h.helicsPublicationPublishInteger(pub1, c1)
h.helicsPublicationPublishInteger(pub2, c2)
h.helicsFederateRequestTimeIterativeAsync(
vFed1, 1.0, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED)
grantedTime, state = h.helicsFederateRequestTimeIterative(
vFed2, 1.0, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED)
if c1 <= 10:
# assert state == h.HELICS_ITERATION_RESULT_ITERATING
assert grantedTime == 0.0
else:
# assert state == h.HELICS_ITERATION_RESULT_NEXT_STEP
assert grantedTime == 1.0
grantedTime, state = h.helicsFederateRequestTimeIterativeComplete(
vFed1)
if c1 <= 10:
# assert state == h.HELICS_ITERATION_RESULT_ITERATING
assert grantedTime == 0.0
# assert state == h.HELICS_ITERATION_RESULT_NEXT_STEP
# assert grantedTime == 1.0
destroyFederate(vFed1, fedinfo1)
destroyFederate(vFed2, fedinfo2)
destroyBroker(broker)
