def test_query_broker_tests():
broker = createBroker(2)
vFed1, fedinfo1 = createValueFederate(1, "fed0")
vFed2, fedinfo2 = createValueFederate(1, "fed1")
core = h.helicsFederateGetCoreObject(vFed1)
q1 = h.helicsCreateQuery("root", "federates")
res = h.helicsQueryCoreExecute(q1, core)
name1 = h.helicsFederateGetName(vFed1)
name2 = h.helicsFederateGetName(vFed2)
try:
assert f"[{name1};{name2}]" == res
except AssertionError:
assert [name1, name2] == res
res = h.helicsQueryExecute(q1, vFed1)
try:
assert f"[{name1};{name2}]" == res
except AssertionError:
assert [name1, name2] == res
h.helicsFederateEnterInitializingModeAsync(vFed1)
h.helicsFederateEnterInitializingMode(vFed2)
h.helicsFederateEnterInitializingModeComplete(vFed1)
h.helicsQueryFree(q1)
h.helicsCoreFree(core)
h.helicsFederateFinalizeAsync(vFed1)
h.helicsFederateFinalize(vFed2)
h.helicsFederateFinalizeComplete(vFed1)
destroyFederate(vFed1, fedinfo1)
destroyFederate(vFed2, fedinfo2)
destroyBroker(broker)
def test_iteration_execution_iteration_test():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "fed0")
# register the publications
pubid = h.helicsFederateRegisterGlobalPublication(
vFed1, "pub1", h.HELICS_DATA_TYPE_DOUBLE, "")
subid = h.helicsFederateRegisterSubscription(vFed1, "pub1", "")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_DELTA, 1.0)
h.helicsFederateEnterInitializingMode(vFed1)
h.helicsPublicationPublishDouble(pubid, 27.0)
comp = h.helicsFederateEnterExecutingModeIterative(
vFed1, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED)
assert comp == h.HELICS_ITERATION_RESULT_ITERATING
val = h.helicsInputGetDouble(subid)
assert val == 27.0
comp = h.helicsFederateEnterExecutingModeIterative(
vFed1, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED)
assert comp == h.HELICS_ITERATION_RESULT_NEXT_STEP
val2 = h.helicsInputGetDouble(subid)
assert val2 == val
h.helicsFederateFinalize(vFed1)
destroyFederate(vFed1, fedinfo)
destroyBroker(broker)
def test_bad_input_init_error():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "fed0")
# register the publications
# the types here don't match which causes an error when initializing the federation
h.helicsFederateRegisterGlobalTypePublication(vFed1, "pub1", "custom1", "")
subid = h.helicsFederateRegisterTypeInput(vFed1, "inp1", "custom2", "")
k1 = h.helicsInputGetKey(subid)
# check some other calls
inp2 = h.helicsFederateGetInput(vFed1, "inp1")
k2 = h.helicsInputGetKey(inp2)
assert k1 == k2
inp3 = h.helicsFederateGetInputByIndex(vFed1, 0)
k3 = h.helicsInputGetKey(inp3)
assert k1 == k3
h.helicsInputAddTarget(subid, "pub1")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
# unknown publication
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorInvalidArgument
pub3 = h.helicsFederateGetPublication(vFed1, "unknown")
# error in this call from the mismatch
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorConnectionFailure
h.helicsFederateEnterInitializingMode(vFed1)
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorInvalidFunctionCall
h.helicsFederateRequestTimeAdvance(vFed1, 0.1)
# unknown input
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorInvalidArgument
inp4 = h.helicsFederateGetInput(vFed1, "unknown")
# invalid input index
# TODO: does this test segfault some times?
with pt.raises(h.HelicsException):
# @test_throws h.HELICSErrorInvalidArgument
inp5 = h.helicsFederateGetInputByIndex(vFed1, 4)
h.helicsFederateFinalize(vFed1)
destroyFederate(vFed1, fedinfo)
destroyBroker(broker)
def test_query_federate_tests():
broker = createBroker(2)
vFed1, fedinfo1 = createValueFederate(1, "fed0")
vFed2, fedinfo2 = createValueFederate(1, "fed1")
h.helicsFederateRegisterGlobalTypePublication(vFed1, "pub1", "double", "")
h.helicsFederateRegisterTypePublication(vFed1, "pub2", "double", "")
h.helicsFederateRegisterTypePublication(vFed2, "pub3", "double", "")
h.helicsFederateEnterInitializingModeAsync(vFed1)
h.helicsFederateEnterInitializingMode(vFed2)
h.helicsFederateEnterInitializingModeComplete(vFed1)
core = h.helicsFederateGetCoreObject(vFed1)
q1 = h.helicsCreateQuery("Testfed0", "publications")
res = h.helicsQueryCoreExecute(q1, core)
try:
assert res == "[pub1;Testfed0/pub2]"
except:
assert res == ["pub1", "Testfed0/pub2"]
# res = h.helicsQueryExecute(q1, vFed2)
# assert res == "[pub1;Testfed0/pub2]"
h.helicsQueryFree(q1)
# q1 = h.helicsCreateQuery("Testfed1", "isinit")
# res = h.helicsQueryExecute(q1, vFed1)
# assert res, "True"
# h.helicsQueryFree(q1)
# q1 = h.helicsCreateQuery("Testfed1", "publications")
# res = h.helicsQueryExecute(q1, vFed1)
# assert res == "[Testfed1/pub3]"
# h.helicsQueryFree(q1)
h.helicsCoreFree(core)
h.helicsFederateFinalizeAsync(vFed1)
h.helicsFederateFinalize(vFed2)
h.helicsFederateFinalizeComplete(vFed1)
destroyFederate(vFed1, fedinfo1)
destroyFederate(vFed2, fedinfo2)
destroyBroker(broker)
def test_bad_inputs_frees():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "fed0")
fi = h.helicsCreateFederateInfo()
h.helicsFederateInfoSetBroker(fi, "broker test")
h.helicsFederateEnterInitializingMode(vFed1)
h.helicsFederateFinalize(vFed1)
h.helicsFederateInfoSetBrokerPort(fi, 8929)
h.helicsFederateInfoSetLocalPort(fi, "8229")
h.helicsFederateInfoFree(fi)
h.helicsFederateFree(vFed1)
# @test_throws h.HELICSErrorInvalidObject
with pt.raises(h.HelicsException):
destroyFederate(vFed1, fedinfo)
destroyBroker(broker)
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 = []
ppc = []
case_format = case118()
peak_demand = case_format['bus'][:, 2][:].copy()
ppc = case_format.copy()
def test_bad_inputs_input_tests():
broker = createBroker(1)
vFed1, fedinfo = createValueFederate(1, "fed0")
# register the publications
pubid = h.helicsFederateRegisterGlobalPublication(
vFed1, "pub1", h.HELICS_DATA_TYPE_DOUBLE, "")
subid = h.helicsFederateRegisterInput(vFed1, "inp1",
h.HELICS_DATA_TYPE_DOUBLE, "")
# @test_throws h.HELICSErrorRegistrationFailure
with pt.raises(h.HelicsException):
subid2 = h.helicsFederateRegisterInput(vFed1, "inp1",
h.HELICS_DATA_TYPE_DOUBLE, "")
h.helicsInputAddTarget(subid, "pub1")
vf2 = h.helicsFederateClone(vFed1)
assert h.helicsFederateGetName(vFed1) == h.helicsFederateGetName(vf2)
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0)
# @test_throws h.HELICSErrorInvalidObject
with pt.raises(h.HelicsException):
ept = h.helicsFederateRegisterEndpoint(vFed1, "ept1", "")
h.helicsFederateEnterInitializingMode(vFed1)
h.helicsPublicationPublishDouble(pubid, 27.0)
comp = h.helicsFederateEnterExecutingModeIterative(
vFed1, h.HELICS_ITERATION_REQUEST_FORCE_ITERATION)
assert comp == h.HELICS_ITERATION_RESULT_ITERATING
val = h.helicsInputGetDouble(subid)
assert val == 27.0
valt = h.helicsInputGetTime(subid)
assert valt == 27.0
comp = h.helicsFederateEnterExecutingModeIterative(
vFed1, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED)
assert comp == h.HELICS_ITERATION_RESULT_NEXT_STEP
val2 = h.helicsInputGetDouble(subid)
assert val2 == val
# expect error entering initializing Mode again
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsFederateEnterInitializingMode(vFed1)
# expect error entering initializing Mode again
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsFederateEnterInitializingModeAsync(vFed1)
# expect error entering initializing Mode again
# @test_throws h.HELICSErrorInvalidFunctionCall
with pt.raises(h.HelicsException):
h.helicsFederateEnterInitializingModeComplete(vFed1)
h.helicsFederateFinalize(vFed1)
destroyFederate(vFed1, fedinfo)
destroyBroker(broker)
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
for t in range(timebin, timebin * 360 + 1, timebin):
while currenttime < t:
currenttime = h.helicsFederateRequestTime(cfed, t)
if h.helicsInputIsUpdated(subs_chargingPlugIn) == 1:
chargingPlugIn = h.helicsInputGetString(subs_chargingPlugIn)
arr = chargingPlugIn.split(',')
print("vehId:{}, Joules:{}, lat:{}, lng:{}\n".format(
arr[0], arr[1], arr[2], arr[3]))
if h.helicsInputIsUpdated(subs_chargingPlugOut) == 1:
chargingPlugOut = h.helicsInputGetString(subs_chargingPlugOut)
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)
