def test_value_federate_subscription_and_publication_registration(vFed):
pubid3 = h.helicsFederateRegisterTypePublication(vFed, "pub3", "double",
"V")
subid1 = h.helicsFederateRegisterSubscription(vFed, "sub1", "")
subid2 = h.helicsFederateRegisterSubscription(vFed, "sub2", "")
subid3 = h.helicsFederateRegisterSubscription(vFed, "sub3", "V")
h.helicsFederateEnterExecutingMode(vFed)
publication_type = h.helicsPublicationGetType(pubid3)
assert publication_type == 'double'
sub_key = h.helicsSubscriptionGetKey(subid1)
assert sub_key == 'sub1'
sub_type = h.helicsInputGetType(subid1)
assert sub_type == ''
sub_key = h.helicsSubscriptionGetKey(subid2)
assert sub_key == 'sub2'
sub_key = h.helicsSubscriptionGetKey(subid3)
assert sub_key == 'sub3'
sub_type = h.helicsInputGetType(subid3)
assert sub_type == ''
sub_units = h.helicsInputGetUnits(subid3)
assert sub_units == 'V'
sub_type = h.helicsInputGetType(subid2)
assert sub_type == ''
def main(delay=None):
broker = create_broker()
fed = create_value_federate(broker)
pubid = h.helicsFederateRegisterGlobalTypePublication(
fed, "federate1-to-federate2", "string", "")
subid = h.helicsFederateRegisterSubscription(fed, "federate2-to-federate1",
"")
epid = h.helicsFederateRegisterGlobalEndpoint(fed, "endpoint1", "")
if delay is not None:
fid = h.helicsFederateRegisterGlobalFilter(fed,
h.helics_filter_type_delay,
"filter-name")
h.helicsFilterAddSourceTarget(fid, "endpoint1")
h.helicsInputSetDefaultNamedPoint(subid, "", 0)
print("Entering execution mode")
h.helicsFederateEnterExecutingMode(fed)
if delay is not None:
h.helicsFilterSet(fid, "delay", delay)
grantedtime = -1
while True:
try:
stop_at_time, value_to_send = get_input(grantedtime)
print(stop_at_time)
except KeyboardInterrupt:
print("")
break
while grantedtime < stop_at_time:
print(">>>>>>>> Requesting time = {}".format(stop_at_time))
grantedtime = h.helicsFederateRequestTime(fed, stop_at_time)
grantedtime = int(grantedtime)
if grantedtime != stop_at_time:
value = h.helicsSubscriptionGetKey(subid)
print("Interrupt value '{}' from Federate 2".format(value))
print("<<<<<<<< Granted Time = {}".format(grantedtime))
assert (grantedtime == stop_at_time
), "stop_at_time = {}, grantedtime = {}".format(
stop_at_time, grantedtime)
if value_to_send is not None and value_to_send != "":
print("Sending '{}' to Federate 2".format(value_to_send))
h.helicsPublicationPublishString(pubid, str(value_to_send))
h.helicsEndpointSendMessageRaw(epid, "endpoint2",
str(value_to_send))
value = h.helicsSubscriptionGetKey(subid)
print("Received value '{}' from Federate 2".format(value))
while h.helicsEndpointHasMessage(epid):
value = h.helicsEndpointGetMessage(epid)
print("Received message '{}' at time {} from Federate 2".format(
value.data, value.time))
print("----------------------------------")
destroy_value_federate(fed, broker)
def test_combination_federate():
broker = createBroker()
cfed = h.helicsCreateCombinationFederateFromConfig(
os.path.join(CURRENT_DIRECTORY, "combinationfederate.json"))
assert h.helicsFederateIsValid(cfed)
assert h.helicsFederateGetEndpointCount(cfed) == 2
assert h.helicsFederateGetFilterCount(cfed) == 0
assert h.helicsFederateGetInputCount(cfed) == 2
ept = h.helicsFederateGetEndpointByIndex(cfed, 0)
assert h.helicsEndpointGetName(ept) == "ept1"
ipt = h.helicsFederateGetInputByIndex(cfed, 1)
assert h.helicsInputGetExtractionUnits(ipt) == ""
assert h.helicsSubscriptionGetKey(ipt) == "comboFed/pub2"
h.helicsEndpointClearMessages(ept)
h.helicsFederateDestroy(cfed)
h.helicsFederateFree(cfed)
h.helicsBrokerDestroy(broker)
h.helicsCloseLibrary()
print(f'Created federate {federate_name}')
print(f'\tNumber of endpoints: {end_count}')
print(f'\tNumber of subscriptions: {sub_count}')
print(f'\tNumber of publications: {pub_count}')
# Diagnostics to confirm JSON config correctly added the required
# endpoints, publications, and subscriptions.
endid = {}
for i in range(0, end_count):
endid[i] = h.helicsFederateGetEndpointByIndex(fed, i)
end_name = h.helicsEndpointGetName(endid[i])
logger.debug(f'\tRegistered Endpoint ---> {end_name}')
subid = {}
for i in range(0, sub_count):
subid[i] = h.helicsFederateGetInputByIndex(fed, i)
sub_name = h.helicsSubscriptionGetKey(subid[i])
logger.debug(f'\tRegistered subscription---> {sub_name}')
pubid = {}
for i in range(0, pub_count):
pubid[i] = h.helicsFederateGetPublicationByIndex(fed, i)
pub_name = h.helicsPublicationGetKey(pubid[i])
logger.debug(f'\tRegistered publication---> {pub_name}')
############## Entering Execution Mode ##################################
h.helicsFederateEnterExecutingMode(fed)
logger.info('Entered HELICS execution mode')
# Definition of charging power level (in kW) for level 1, 2, 3 chargers
charge_rate = [1.8, 7.2, 50]
federate_name = h.helicsFederateGetName(fed)[-1]
print(" Federate {} has been registered".format(federate_name))
pubkeys_count = h.helicsFederateGetPublicationCount(fed)
subkeys_count = h.helicsFederateGetInputCount(fed)
print(subkeys_count)
###################### Reference to Publications and Subscription form index #############################
pubid = {}
subid = {}
for i in range(0, pubkeys_count):
pubid["m{}".format(i)] = h.helicsFederateGetPublicationByIndex(fed, i)
pubtype = h.helicsPublicationGetType(pubid["m{}".format(i)])
print(pubtype)
for i in range(0, subkeys_count):
subid["m{}".format(i)] = h.helicsFederateGetInputByIndex(fed, i)
status = h.helicsInputSetDefaultComplex(subid["m{}".format(i)], 0, 0)
sub_key = h.helicsSubscriptionGetKey(subid["m{}".format(i)])
print('Registered Subscription ---> {}'.format(sub_key))
###################### Entereing Execution Mode ##########################################################
status = h.helicsFederateEnterInitializingMode(fed)
status = h.helicsFederateEnterExecutingMode(fed)
#Pypower Processing (inputs)
hours = 24
total_inteval = int(60 * 60 * hours)
grantedtime = -1
pf_interval = 5 * 60 # in seconds (minimim_resolution)
acopf_interval = 15 * 60 # in seconds (minimim_resolution)
random.seed(0)
peak_demand = []
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 test_valuefederate_subscription_and_publication_registration():
broker = createBroker()
vFed, fedinfo = createValueFederate(1, "fed0")
pubid = h.helicsFederateRegisterPublication(vFed, "pub1", h.HELICS_DATA_TYPE_STRING, "")
pubid2 = h.helicsFederateRegisterGlobalPublication(vFed, "pub2", h.HELICS_DATA_TYPE_INT, "volts")
pubid3 = h.helicsFederateRegisterTypePublication(vFed, "pub3", "double", "V")
subid1 = h.helicsFederateRegisterSubscription(vFed, "sub1", "")
subid2 = h.helicsFederateRegisterSubscription(vFed, "sub2", "")
subid3 = h.helicsFederateRegisterSubscription(vFed, "sub3", "V")
h.helicsFederateEnterExecutingMode(vFed)
publication_type = h.helicsPublicationGetType(pubid3)
assert publication_type == "double"
sub_key = h.helicsSubscriptionGetKey(subid1)
assert sub_key == "sub1"
sub_type = h.helicsInputGetType(subid1)
assert sub_type == ""
sub_key = h.helicsSubscriptionGetKey(subid2)
assert sub_key == "sub2"
sub_key = h.helicsSubscriptionGetKey(subid3)
assert sub_key == "sub3"
sub_type = h.helicsInputGetType(subid3)
assert sub_type == ""
sub_units = h.helicsInputGetUnits(subid3)
assert sub_units == "V"
sub_type = h.helicsInputGetType(subid2)
assert sub_type == ""
subid_b = h.helicsFederateGetSubscription(vFed, "sub1")
tmp = h.helicsSubscriptionGetKey(subid_b)
assert tmp == "sub1"
# check the getSubscriptionByIndex function
subid_c = h.helicsFederateGetInputByIndex(vFed, 2)
tmp = h.helicsInputGetUnits(subid_c)
assert tmp == "V"
# check publications
sv = h.helicsPublicationGetKey(pubid)
sv2 = h.helicsPublicationGetKey(pubid2)
assert sv == "Testfed0/pub1"
assert sv2 == "pub2"
pub3name = h.helicsPublicationGetKey(pubid3)
assert pub3name == "Testfed0/pub3"
type = h.helicsPublicationGetType(pubid3)
assert type == "double"
units = h.helicsPublicationGetUnits(pubid3)
assert units == "V"
# check the getSubscription function
pubid_b = h.helicsFederateGetPublication(vFed, "Testfed0/pub1")
tmp = h.helicsPublicationGetType(pubid_b)
assert tmp == "string"
# check the getSubscriptionByIndex function
pubid_c = h.helicsFederateGetPublicationByIndex(vFed, 1)
tmp = h.helicsPublicationGetUnits(pubid_c)
assert tmp == "volts"
# this one should be invalid
# @test_throws h.HELICSErrorInvalidArgument pubid_d = h.helicsFederateGetPublicationByIndex(vFed, 5)
h.helicsFederateFinalize(vFed)
state = h.helicsFederateGetState(vFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(vFed, fedinfo)
destroyBroker(broker)
def federate_example(config_path):
# Registering federate from json
try:
fed = h.helicsCreateCombinationFederateFromConfig(config_path)
except h._helics.HelicsException as exc:
print("Exception occured".format(exc))
exit(-1)
federate_name = h.helicsFederateGetName(fed)
print(federate_name)
endpoint_count = h.helicsFederateGetEndpointCount(fed)
subkeys_count = h.helicsFederateGetInputCount(fed)
pubkeys_count = h.helicsFederateGetPublicationCount(fed)
# Reference to Publications and Subscription form index
endid = {}
subid = {}
pubid = {}
for i in range(0,endpoint_count):
endid["m{}".format(i)] = h.helicsFederateGetEndpointByIndex(fed, i)
end_name = h.helicsEndpointGetName(endid["m{}".format(i)])
logger.info( 'Registered Endpoint ---> {}'.format(end_name))
for i in range(0, subkeys_count):
idx = h.helicsFederateGetInputByIndex(fed, i)
subid["m{}".format(i)] = idx
status = h.helicsInputSetDefaultComplex(subid["m{}".format(i)], 0, 0)
sub_key = h.helicsSubscriptionGetKey(idx)
logger.info( 'Registered Subscription ---> {}'.format(sub_key))
for i in range(0, pubkeys_count):
idx = h.helicsFederateGetPublicationByIndex(fed, i)
pubid["m{}".format(i)] = idx
pub_key = h.helicsPublicationGetKey(idx)
logger.info( 'Registered Publications ---> {}'.format(pub_key))
print('###############################################################################################')
print('######################## Entering Execution Mode ##########################################')
# Entering Execution Mode
h.helicsFederateEnterExecutingMode(fed)
print('###############################################################################################')
hours = 0.1
total_inteval = int(60 * 60 * hours)
grantedtime = -1
update_interval = 1 # 5*60
k = 0
data ={}
time.sleep(5)
time_sim = []
real = 0
for t in range(0, total_inteval, update_interval):
while grantedtime < t:
grantedtime = h.helicsFederateRequestTime (fed, t)
time.sleep(0.1)
print('######################## Time interval {} ##########################################'.format(t))
print('######################## Publishing to topics ######################################')
real = real + 1
for i in range(0, pubkeys_count):
idx = pubid["m{}".format(i)]
h.helicsPublicationPublishComplex(idx, real*i, 78)
print( '######################## Get input from subscribed topics #########################')
for i in range(0, subkeys_count):
idx = subid["m{}".format(i)]
value = h.helicsInputGetDouble(idx)
key = h.helicsSubscriptionGetKey(idx)
print("Value for key: {} is {}".format(key, value))
print('######################## Get from Endpoint #########################################')
idx = endid["m{}".format(0)]
while h.helicsEndpointHasMessage(idx):
msg = h.helicsEndpointGetMessage(idx)
end_name = h.helicsEndpointGetName(idx)
print("Value from endpoint name: {} is {}".format(end_name, msg.data))
print('######################## Send to VOLTTRON Endpoint #################################')
for i in range(0, endpoint_count):
idx = endid["m{}".format(i)]
value = i + random.randint(1, 101) + 89.7
end_name = h.helicsEndpointGetName(idx)
print("Sending Value:{0} for endpoint: {1}".format(value, end_name))
h.helicsEndpointSendEventRaw(idx, '', str(value), t)
end_name = h.helicsEndpointGetName(idx)
logger.info("Destroying federate")
destroy_federate(fed)
def register_inputs(self, config=None, callback=None, **kwargs):
"""
Register configuration parameters with HELICS. The config parameters may include
but not limited to:
1. Name of the federate
2. simulation length
2. Type of core to use (zmq/tcp/udp etc)
3. list (and type) of subscriptions
4. list (and type) of publications
5. broker address (if not default)
:param config: config parameters
:param callback: Register agent callback method
:return:
"""
self._work_callback = callback
# Build HELICS config from agent config
helics_config = deepcopy(config)
properties = helics_config.pop('properties', {})
if not properties:
raise RuntimeError(
"Invalid configuration. Missing properties dictionary")
self._simulation_delta = properties.pop('timeDelta', 1.0) # seconds
self._simulation_length = properties.pop('simulation_length',
3600) # seconds
for key, value in properties.items():
helics_config[key] = value
subscriptions = helics_config.pop('outputs', [])
for sub in subscriptions:
volttron_topic = sub.pop('volttron_topic', None)
if volttron_topic is not None:
self.helics_to_volttron_publish[sub.get(
'key')] = volttron_topic
sub['key'] = sub.pop('sim_topic')
# Replace 'outputs' key with 'subscriptions' key
if subscriptions:
helics_config['subscriptions'] = subscriptions
publications = helics_config.pop('inputs', [])
for pub in publications:
volttron_topic = pub.pop('volttron_topic', None)
pub['key'] = pub.pop('sim_topic')
# Replace 'inputs' key with 'publications' key
if publications:
helics_config['publications'] = publications
_log.debug("new config: {}".format(helics_config))
# Create a temporary json file
tmp_file = os.path.join(os.getcwd(), 'fed_cfg.json')
_log.debug("tmp file: {}".format(tmp_file))
with open(tmp_file, 'w') as fout:
fout.write(jsonapi.dumps(helics_config))
_log.debug("Create Combination Federate")
# Create federate from provided config parameters
try:
self.fed = h.helicsCreateCombinationFederateFromConfig(tmp_file)
except h._helics.HelicsException as e:
_log.exception("Error parsing HELICS config {}".format(e))
# Check if HELICS broker correctly registered inputs
federate_name = h.helicsFederateGetName(self.fed)
_log.debug("Federate name: {}".format(federate_name))
endpoint_count = h.helicsFederateGetEndpointCount(self.fed)
_log.debug("Endpoint count: {}".format(endpoint_count))
subkeys_count = h.helicsFederateGetInputCount(self.fed)
_log.debug("Subscription key count: {}".format(subkeys_count))
pubkeys_count = h.helicsFederateGetPublicationCount(self.fed)
_log.debug("Publication key count: {}".format(endpoint_count))
for i in range(0, endpoint_count):
try:
endpt_idx = h.helicsFederateGetEndpointByIndex(self.fed, i)
endpt_name = h.helicsEndpointGetName(endpt_idx)
self.endpoints[endpt_name] = endpt_idx
except h._helics.HelicsException as e:
_log.exception(
"Error getting helics endpoint index: {}".format(e))
for i in range(0, subkeys_count):
inputs = dict()
try:
idx = h.helicsFederateGetInputByIndex(self.fed, i)
inputs['sub_id'] = idx
inputs['type'] = h.helicsInputGetType(idx)
inputs['key'] = h.helicsSubscriptionGetKey(idx)
self.inputs.append(inputs)
data = dict(type=inputs['type'], value=None)
except h._helics.HelicsException as e:
_log.exception(
"Error getting helics input index: {}".format(e))
for i in range(0, pubkeys_count):
outputs = dict()
try:
idx = h.helicsFederateGetPublicationByIndex(self.fed, i)
outputs['pub_id'] = idx
outputs['type'] = h.helicsPublicationGetType(idx)
pub_key = h.helicsPublicationGetKey(idx)
_log.debug("Publication: {}".format(pub_key))
self.outputs[pub_key] = outputs
data = dict(type=outputs['type'], value=None)
except h._helics.HelicsException as e:
_log.exception(
"Error getting helics publication index: {}".format(e))