def init_worker(config_file_name, manager_name, individual_simulation_time):
print("worker in")
fed = h.helicsCreateMessageFederateFromConfig(config_file_name)
print("worker passed config")
my_epid = h.helicsFederateGetEndpoint(fed, "data")
fed_name = h.helicsFederateGetName(fed)
dest = manager_name + "/data"
pid = os.getpid()
print(fed_name, " about to Started")
h.helicsFederateEnterExecutingMode(fed)
print(fed_name, " Started")
current_time = -1
while current_time < maxtime:
current_time = h.helicsFederateRequestTime(fed, maxtime)
if h.helicsEndpointHasMessage(my_epid):
message = h.helicsEndpointGetMessage(my_epid)
data = str(fed_name) + "(" + str(pid) + "): " + str(message.data)
# time.sleep(random.randrange(4))
time.sleep(individual_simulation_time)
h.helicsEndpointSendMessageRaw(my_epid, str(dest), data)
h.helicsFederateFinalize(fed)
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
def init_worker(config_file_name, manager_name):
fed = h.helicsCreateMessageFederateFromConfig(config_file_name)
my_epid = h.helicsFederateGetEndpoint(fed, "data")
fed_name = h.helicsFederateGetName(fed)
dest = manager_name + "/data"
pid = os.getpid()
h.helicsFederateEnterExecutingMode(fed)
current_time = h.helicsFederateRequestTime(fed, maxtime)
simulation_time_data = h.helicsEndpointGetMessage(my_epid)
sleep_time = float(simulation_time_data.data)
current_time = -1
while current_time < maxtime:
current_time = h.helicsFederateRequestTime(fed, maxtime)
if h.helicsEndpointHasMessage(my_epid):
message = h.helicsEndpointGetMessage(my_epid)
data = str(fed_name) + "(" + str(pid) + "): " + str(message.data)
# time.sleep(random.randrange(4))
time.sleep(float(sleep_time))
h.helicsEndpointSendMessageRaw(my_epid, str(dest), data)
h.helicsFederateFinalize(fed)
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
def test_filter_type_tests_message_filter_function():
broker = createBroker(2)
fFed, fedinfo1 = createMessageFederate(1, "filter")
mFed, fedinfo2 = createMessageFederate(1, "message")
h.helicsFederateSetFlagOption(mFed,
h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS,
True)
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_DELAY,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
h.helicsFilterSet(f1, "delay", 2.5)
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "port2", data)
h.helicsFederateRequestTimeAsync(mFed, 1.0)
h.helicsFederateRequestTime(fFed, 1.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsFederateHasMessage(mFed) is False
h.helicsFederateRequestTimeAsync(mFed, 2.0)
h.helicsFederateRequestTime(fFed, 2.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2) is False
h.helicsFederateRequestTimeAsync(fFed, 3.0)
h.helicsFederateRequestTime(mFed, 3.0)
assert h.helicsEndpointHasMessage(p2) is True
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "port1"
assert h.helicsMessageGetOriginalSource(m2) == "port1"
assert h.helicsMessageGetDestination(m2) == "port2"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsMessageGetTime(m2) == 2.5
h.helicsFederateRequestTime(mFed, 3.0)
h.helicsFederateRequestTimeComplete(fFed)
h.helicsFederateFinalizeAsync(mFed)
h.helicsFederateFinalize(fFed)
h.helicsFederateFinalizeComplete(mFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(fFed, fedinfo1)
destroyFederate(mFed, fedinfo2)
destroyBroker(broker)
def test_messagefilter_function():
broker = createBroker(2)
fFed, ffedinfo = createMessageFederate(1, "filter")
mFed, mfedinfo = createMessageFederate(1, "message")
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "random")
f1 = h.helicsFederateRegisterGlobalFilter(fFed,
h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
f2 = h.helicsFederateRegisterGlobalFilter(fFed, h.HELICS_FILTER_TYPE_DELAY,
"filter2")
h.helicsFilterAddSourceTarget(f2, "port1")
h.helicsFederateRegisterEndpoint(fFed, "fout", "")
f3 = h.helicsFederateRegisterFilter(fFed,
h.HELICS_FILTER_TYPE_RANDOM_DELAY,
"filter3")
h.helicsFilterAddSourceTarget(f3, "filter/fout")
h.helicsFilterSet(f2, "delay", 2.5)
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
state = h.helicsFederateGetState(fFed)
assert state == 2
data = "hello world"
filt_key = h.helicsFilterGetName(f1)
assert filt_key == "filter1"
filt_key = h.helicsFilterGetName(f2)
assert filt_key == "filter2"
h.helicsEndpointSendMessageRaw(p1, "port2", data.encode())
h.helicsFederateRequestTimeAsync(mFed, 1.0)
grantedtime = h.helicsFederateRequestTime(fFed, 1.0)
assert grantedtime == 1.0
grantedtime = h.helicsFederateRequestTimeComplete(mFed)
assert grantedtime == 1.0
res = h.helicsFederateHasMessage(mFed)
assert res == 0
res = h.helicsEndpointHasMessage(p2)
assert res == 0
# grantedtime = h.helicsFederateRequestTime(fFed, 3.0)
# assert res==h.helics_true
h.helicsFederateFinalize(mFed)
h.helicsFederateFinalize(fFed)
# f2 = h.helicsFederateRegisterDestinationFilter(fFed, h.helics_custom_filter, "filter2", "port2")
# ep1 = h.helicsFederateRegisterEndpoint(fFed, "fout", "")
# f3 = h.helicsFederateRegisterSourceFilter(fFed, h.helics_custom_filter, "", "filter0/fout")
destroyFederate(fFed, ffedinfo)
destroyFederate(mFed, mfedinfo)
time.sleep(1.0)
destroyBroker(broker)
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_message_filter_function(broker):
fFed, ffedinfo = AddFederate(broker, "zmq", 1, 1, "filter")
mFed, mfedinfo = AddFederate(broker, "zmq", 1, 1, "message")
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "random")
f1 = h.helicsFederateRegisterGlobalFilter(fFed,
h.helics_filter_type_custom,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
f2 = h.helicsFederateRegisterGlobalFilter(fFed, h.helics_filter_type_delay,
"filter2")
h.helicsFilterAddSourceTarget(f2, "port1")
h.helicsFederateRegisterEndpoint(fFed, 'fout', '')
f3 = h.helicsFederateRegisterFilter(fFed,
h.helics_filter_type_random_delay,
'filter3')
h.helicsFilterAddSourceTarget(f3, 'filter/fout')
h.helicsFilterSet(f2, "delay", 2.5)
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
state = h.helicsFederateGetState(fFed)
assert state == 2
data = "hello world"
filt_key = h.helicsFilterGetName(f1)
assert filt_key == 'filter1'
filt_key = h.helicsFilterGetName(f2)
assert filt_key == 'filter2'
h.helicsEndpointSendMessageRaw(p1, "port2", data)
h.helicsFederateRequestTimeAsync(mFed, 1.0)
grantedtime = h.helicsFederateRequestTime(fFed, 1.0)
assert grantedtime == 1.0
grantedtime = h.helicsFederateRequestTimeComplete(mFed)
assert grantedtime == 1.0
res = h.helicsFederateHasMessage(mFed)
assert res == 0
res = h.helicsEndpointHasMessage(p2)
assert res == 0
#grantedtime = h.helicsFederateRequestTime(fFed, 3.0)
#assert res==h.helics_true
h.helicsFederateFinalize(mFed)
h.helicsFederateFinalize(fFed)
#f2 = h.helicsFederateRegisterDestinationFilter (fFed, h.helics_custom_filter, "filter2", "port2")
#ep1 = h.helicsFederateRegisterEndpoint (fFed, "fout", "")
#f3 = h.helicsFederateRegisterSourceFilter (fFed, h.helics_custom_filter, "", "filter0/fout")
FreeFederate(fFed, ffedinfo)
FreeFederate(mFed, mfedinfo)
time.sleep(1.0)
def main(delay=None):
broker = create_broker()
fed = create_value_federate(broker)
pubid = h.helicsFederateRegisterGlobalTypePublication(
fed, "federate1-to-federate2", h.HELICS_DATA_TYPE_STRING, "")
subid = h.helicsFederateRegisterSubscription(fed, "federate2-to-federate1",
"double", "")
epid = h.helicsFederateRegisterGlobalEndpoint(fed, "endpoint1", "")
if delay is not None:
fid = h.helicsFederateRegisterSourceFilter(fed, h.helics_delay_filter,
"endpoint2", "filter-name")
h.helicsSubscriptionSetDefaultDouble(subid, 0)
print("Entering execution mode")
h.helicsFederateEnterExecutionMode(fed)
if delay is not None:
h.helicsFilterSet(fid, "delay", 2.0)
grantedtime = -1
while True:
try:
stop_at_time, value_to_send = get_input(grantedtime)
except KeyboardInterrupt:
print("")
break
while grantedtime < stop_at_time:
print(">>>>>>>> Requesting time = {}".format(stop_at_time))
status, grantedtime = h.helicsFederateRequestTime(
fed, stop_at_time)
assert status == 0
if grantedtime != stop_at_time:
status, value = h.helicsSubscriptionGetString(subid)
assert status == 0
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))
status = h.helicsPublicationPublishString(pubid,
str(value_to_send))
assert status == 0
status = h.helicsEndpointSendMessageRaw(epid, "endpoint2",
str(value_to_send))
assert status == 0
status, value = h.helicsSubscriptionGetString(subid)
assert status == 0
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 init_manager(config_file_name, worker_name_list):
print("manager in")
fed = h.helicsCreateMessageFederateFromConfig(config_file_name)
print("manager passed config")
my_epid = h.helicsFederateGetEndpoint(fed, "data")
log_id = h.helicsFederateGetEndpoint(fed, "logger")
log_dest = h.helicsEndpointGetDefaultDestination(log_id)
currenttime = -1
print("Manager about to Started")
h.helicsFederateEnterExecutingMode(fed)
print("Manager Started")
for t in range(1, 11):
h.helicsEndpointSendMessageRaw(log_id, log_dest,
"Timestep {}".format(t))
message = "Hello World " + str(t)
while currenttime < t:
currenttime = h.helicsFederateRequestTime(fed, t)
log_msg = ""
################### START TIMING ###############
start_time = time.time_ns() / (10**9)
##############################################
for worker_name in worker_name_list:
h.helicsEndpointSendMessageRaw(my_epid, worker_name + "/data",
message)
while not (h.helicsEndpointPendingMessages(my_epid)
== len(worker_name_list)):
currenttime = h.helicsFederateRequestTime(fed, 0)
for i in range(len(worker_name_list)):
if h.helicsEndpointHasMessage(my_epid):
new_message = h.helicsEndpointGetMessage(my_epid)
log_msg = log_msg + "From: {} Msg: {} Time: {}\n".format(
new_message.source, new_message.data, new_message.time)
################### END TIMING ##################
end_time = time.time_ns() / (10**9)
###############################################
time_taken = "Time taken for iteration " + str(t) + ": " + str(
end_time - start_time) + "\n"
h.helicsEndpointSendMessageRaw(log_id, log_dest, log_msg)
h.helicsEndpointSendMessageRaw(log_id, log_dest, time_taken)
fed_name = h.helicsFederateGetName(fed)
h.helicsFederateFinalize(fed)
# print("{}: Federate finalized".format(fed_name))
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
def test_message_filter_function(broker):
fFed = AddFederate(broker, "zmq", 1, 1, "filter")
mFed = AddFederate(broker, "zmq", 1, 1, "message")
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
f1 = h.helicsFederateRegisterSourceFilter(fFed, h.helics_delay_filter,
"port1", "filter1")
status = h.helicsFilterSet(f1, "delay", 2.5)
assert status == 0
status = h.helicsFederateEnterExecutionModeAsync(fFed)
assert status == 0
status = h.helicsFederateEnterExecutionMode(mFed)
assert status == 0
status = h.helicsFederateEnterExecutionModeComplete(fFed)
assert status == 0
status, state = h.helicsFederateGetState(fFed)
assert status == 0
assert state == 2
data = "hello world"
h.helicsEndpointSendMessageRaw(p1, "port2", data)
grantedtime = h.helicsFederateRequestTimeAsync(mFed, 1.0)
assert grantedtime == 0
status, grantedtime = h.helicsFederateRequestTime(fFed, 1.0)
assert status == 0
assert grantedtime == 1.0
status, grantedtime = h.helicsFederateRequestTimeComplete(mFed)
assert status == 0
assert grantedtime == 1.0
h.helicsFederateFinalize(mFed)
h.helicsFederateFinalize(fFed)
#f2 = h.helicsFederateRegisterDestinationFilter (fFed, h.helics_custom_filter, "filter2", "port2")
#ep1 = h.helicsFederateRegisterEndpoint (fFed, "fout", "")
#f3 = h.helicsFederateRegisterSourceFilter (fFed, h.helics_custom_filter, "", "filter0/fout")
FreeFederate(fFed)
FreeFederate(mFed)
time.sleep(1.0)
def test_messagefederate_send_receive_2fed_multisend():
broker = createBroker(2)
mFed1, fedinfo1 = createMessageFederate(1, "A Federate")
mFed2, fedinfo2 = createMessageFederate(1, "B Federate")
epid1 = h.helicsFederateRegisterEndpoint(mFed1, "ep1", "")
epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed2, "ep2", "random")
h.helicsEndpointSetOption(epid1, h.HELICS_HANDLE_OPTION_IGNORE_INTERRUPTS,
True)
h.helicsFederateSetTimeProperty(mFed1, h.HELICS_PROPERTY_TIME_DELTA, 1.0)
h.helicsFederateSetTimeProperty(mFed2, h.HELICS_PROPERTY_TIME_DELTA, 1.0)
h.helicsFederateEnterExecutingModeAsync(mFed1)
h.helicsFederateEnterExecutingMode(mFed2)
h.helicsFederateEnterExecutingModeComplete(mFed1)
assert h.HELICS_STATE_EXECUTION == h.helicsFederateGetState(mFed1)
assert h.HELICS_STATE_EXECUTION == h.helicsFederateGetState(mFed2)
h.helicsEndpointSetDefaultDestination(epid1, "ep2")
h.helicsEndpointSendMessageRaw(epid1, "", "a".encode())
h.helicsEndpointSendMessageRaw(epid1, "", "a".encode())
h.helicsEndpointSendMessageRaw(epid1, "", "a".encode())
h.helicsFederateRequestTimeAsync(mFed1, 1.0)
granted_time = h.helicsFederateRequestTime(mFed2, 1.0)
complete_time = h.helicsFederateRequestTimeComplete(mFed1)
assert granted_time == 1.0
assert complete_time == 1.0
res = h.helicsEndpointPendingMessages(epid2)
assert res == 3
res = h.helicsFederatePendingMessages(mFed2)
assert res == 3
assert h.helicsEndpointGetDefaultDestination(epid1) == "ep2"
# FIXME: Someday this will be implemented.
# @test_broken h.helicsEndpointGetOption(epid1, h.HELICS_HANDLE_OPTION_IGNORE_INTERRUPTS) is True
destroyFederate(mFed1, fedinfo1)
destroyFederate(mFed2, fedinfo2)
destroyBroker(broker)
def init_manager(config_file_name, worker_name_list):
fed = h.helicsCreateMessageFederateFromConfig(config_file_name)
my_epid = h.helicsFederateGetEndpoint(fed, "data")
log_id = h.helicsFederateGetEndpoint(fed, "logger")
log_dest = h.helicsEndpointGetDefaultDestination(log_id)
currenttime = -1
h.helicsFederateEnterExecutingMode(fed)
for t in range(1, 11):
h.helicsEndpointSendMessageRaw(log_id, log_dest,
"Timestep {}".format(t))
message = "Hello World " + str(t)
while currenttime < t:
currenttime = h.helicsFederateRequestTime(fed, t)
for worker_name in worker_name_list:
h.helicsEndpointSendMessageRaw(my_epid, worker_name + "/data",
message)
while not (h.helicsEndpointPendingMessages(my_epid)
== len(worker_name_list)):
currenttime = h.helicsFederateRequestTime(fed, 0)
log_msg = ""
for i in range(len(worker_name_list)):
if h.helicsEndpointHasMessage(my_epid):
new_message = h.helicsEndpointGetMessage(my_epid)
log_msg = log_msg + "From: {} Msg: {} Time: {}\n".format(
new_message.source, new_message.data, new_message.time)
h.helicsEndpointSendMessageRaw(log_id, log_dest, log_msg)
fed_name = h.helicsFederateGetName(fed)
h.helicsFederateFinalize(fed)
# print("{}: Federate finalized".format(fed_name))
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
# Data collection lists
time_sim = []
power = []
# Blocking call for a time request at simulation time 0
initial_time = 60
logger.debug(f'Requesting initial time {initial_time}')
t = h.helicsFederateRequestTime(fed, initial_time)
logger.debug(f'Granted time {t}')
# Once granted an initial time, send the initial SOCs to the EV
# Controller
for j in range(0, end_count):
destination_name = str(h.helicsEndpointGetDefaultDestination(endid[j]))
h.helicsEndpointSendMessageRaw(endid[j], "",
str(currentsoc[j]).encode()) #
# As long as granted time is in the time range to be simulated...
while t < total_interval:
# Time request for the next physical interval to be simulated
requested_time = (t + update_interval)
logger.debug(f'Requesting time {requested_time}')
grantedtime = h.helicsFederateRequestTime(fed, requested_time)
logger.debug(f'Granted time {grantedtime}')
t = grantedtime
for j in range(0, end_count):
# Model the physics of the battery charging. This happens
def test_filter_test_types_clone_test_broker_dest_connections():
broker = createBroker(3)
sFed, fedinfo1 = createMessageFederate(1, "source", 1.0)
dFed, fedinfo2 = createMessageFederate(1, "dest", 1.0)
dcFed, fedinfo3 = createMessageFederate(1, "dest_clone", 1.0)
p1 = h.helicsFederateRegisterGlobalEndpoint(sFed, "src", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(dFed, "dest", "")
p3 = h.helicsFederateRegisterGlobalEndpoint(dcFed, "cm", "")
f1 = h.helicsFederateRegisterGlobalCloningFilter(dcFed, "filt1")
h.helicsFilterAddDeliveryEndpoint(f1, "cm")
h.helicsBrokerAddDestinationFilterToEndpoint(broker, "filt1", "dest")
h.helicsBrokerAddDestinationFilterToEndpoint(broker, "", "dest")
h.helicsFederateEnterExecutingModeAsync(sFed)
h.helicsFederateEnterExecutingModeAsync(dcFed)
h.helicsFederateEnterExecutingMode(dFed)
h.helicsFederateEnterExecutingModeComplete(sFed)
h.helicsFederateEnterExecutingModeComplete(dcFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "dest", data)
h.helicsFederateRequestTimeAsync(sFed, 1.0)
h.helicsFederateRequestTimeAsync(dcFed, 1.0)
h.helicsFederateRequestTime(dFed, 1.0)
h.helicsFederateRequestTimeComplete(sFed)
h.helicsFederateRequestTimeComplete(dcFed)
assert h.helicsFederateHasMessage(dFed) is True
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
h.helicsFederateFinalizeAsync(sFed)
h.helicsFederateFinalizeAsync(dFed)
# TODO: figure out why this test fails on CI
# @test_broken False
# assert h.helicsFederateHasMessage(dcFed) is False
# h.helicsFederateRequestTime(dcFed, 2.0)
# assert h.helicsFederateHasMessage(dcFed) is True
# m2 = h.helicsEndpointGetMessage(p3)
# assert h.helicsMessageGetSource(m2) == "src"
# assert h.helicsMessageGetOriginalSource(m2) == "src"
# assert h.helicsMessageGetDestination(m2) == "cm"
# assert h.helicsMessageGetOriginalDestination(m2) == "dest"
# assert h.helicsMessageGetRawDataSize(m2) == len(data)
# _ = h.helicsFederateHasMessage(dcFed)
h.helicsFederateFinalize(dcFed)
h.helicsFederateFinalizeComplete(sFed)
h.helicsFederateFinalizeComplete(dFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(sFed, fedinfo1)
destroyFederate(dFed, fedinfo2)
destroyFederate(dcFed, fedinfo3)
destroyBroker(broker)
def test_filter_callback_test():
broker = createBroker(2)
assert """helics.HelicsBroker(identifier = "mainbroker", address = "tcp://127.0.0.1:23404")""" in repr(
broker)
fFed, fedinfo1 = createMessageFederate(1, "filter", 1.0)
mFed, fedinfo2 = createMessageFederate(1, "message", 1.0)
h.helicsFederateSetFlagOption(mFed,
h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS,
True)
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
assert (
"""helics.HelicsEndpoint(name = "port1", type = "", info = "", is_valid = True, default_destination = "", n_pending_messages = 0)"""
in repr(p1))
assert (
"""helics.HelicsEndpoint(name = "port2", type = "", info = "", is_valid = True, default_destination = "", n_pending_messages = 0)"""
in repr(p2))
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
f2 = h.helicsFederateRegisterFilter(mFed, h.HELICS_FILTER_TYPE_DELAY,
"dfilter")
h.helicsFilterAddSourceTarget(f1, "port1")
assert 'name = "Testfilter/filter1"' in repr(f1)
userdata = UserData(5)
handle = h.ffi.new_handle(userdata)
h.helicsFilterSetCustomCallback(f1, filterFunc1, handle)
with pt.raises(h.HelicsException):
h.helicsFilterSetCustomCallback(f2, filterFunc1, handle)
assert (
"""helics.HelicsMessageFederate(name = "Testfilter", state = HelicsFederateState.STARTUP, current_time = -9223372036.854776, n_publications = 0, n_subscriptions = 0, n_endpoints = 0, n_filters = 1, n_pending_messages = 0)"""
in repr(fFed))
assert (
"""helics.HelicsMessageFederate(name = "Testmessage", state = HelicsFederateState.STARTUP, current_time = -9223372036.854776, n_publications = 0, n_subscriptions = 0, n_endpoints = 2, n_filters = 1, n_pending_messages = 0)"""
in repr(mFed))
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
assert (
"""helics.HelicsMessageFederate(name = "Testfilter", state = HelicsFederateState.EXECUTION, current_time = 0.0, n_publications = 0, n_subscriptions = 0, n_endpoints = 0, n_filters = 1, n_pending_messages = 0)"""
in repr(fFed))
assert (
"""helics.HelicsMessageFederate(name = "Testmessage", state = HelicsFederateState.EXECUTION, current_time = 0.0, n_publications = 0, n_subscriptions = 0, n_endpoints = 2, n_filters = 1, n_pending_messages = 0)"""
in repr(mFed))
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "port2", data)
h.helicsFederateRequestTimeAsync(mFed, 1.0)
h.helicsFederateRequestTime(fFed, 1.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsFederateHasMessage(mFed) is False
h.helicsFederateRequestTimeAsync(mFed, 2.0)
h.helicsFederateRequestTime(fFed, 2.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2) is False
h.helicsFederateRequestTimeAsync(fFed, 3.0)
h.helicsFederateRequestTime(mFed, 3.0)
assert h.helicsEndpointHasMessage(p2)
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "port1"
assert h.helicsMessageGetOriginalSource(m2) == "port1"
assert h.helicsMessageGetDestination(m2) == "port2"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsMessageGetTime(m2) == 2.5
h.helicsFederateRequestTime(mFed, 3.0)
h.helicsFederateRequestTimeComplete(fFed)
h.helicsFederateFinalizeAsync(mFed)
h.helicsFederateFinalize(fFed)
h.helicsFederateFinalizeComplete(mFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(fFed, fedinfo1)
destroyFederate(mFed, fedinfo2)
destroyBroker(broker)
def test_filter_test_types_clone_test_dest_connections():
broker = createBroker(3)
sFed, fedinfo1 = createMessageFederate(1, "source", 1.0)
dFed, fedinfo2 = createMessageFederate(1, "dest", 1.0)
dcFed, fedinfo3 = createMessageFederate(1, "dest_clone", 2.0)
p1 = h.helicsFederateRegisterGlobalEndpoint(sFed, "src", "")
_ = h.helicsFederateRegisterGlobalEndpoint(dFed, "dest", "")
_ = h.helicsFederateRegisterGlobalEndpoint(dcFed, "cm", "")
f1 = h.helicsFederateRegisterGlobalCloningFilter(dcFed, "filt1")
h.helicsFilterAddDeliveryEndpoint(f1, "cm")
cr = h.helicsFederateGetCoreObject(sFed)
h.helicsCoreAddDestinationFilterToEndpoint(cr, "filt1", "dest")
h.helicsCoreAddDestinationFilterToEndpoint(cr, "", "dest")
h.helicsCoreFree(cr)
h.helicsFederateEnterExecutingModeAsync(sFed)
h.helicsFederateEnterExecutingModeAsync(dcFed)
h.helicsFederateEnterExecutingMode(dFed)
h.helicsFederateEnterExecutingModeComplete(sFed)
h.helicsFederateEnterExecutingModeComplete(dcFed)
q = h.helicsCreateQuery("", "filtered_endpoints")
filteredEndpoints = h.helicsQueryExecute(q, dFed)
assert "cloningdestFilter" in str(filteredEndpoints)
h.helicsQueryFree(q)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "dest", data)
h.helicsFederateFinalize(sFed)
# TODO: implement threading
# auto dFedExec = [&]() {
# h.helicsFederateRequestTime(dFed, 1.0)
# m2 = h.helicsEndpointGetMessage(p2)
# h.helicsFederateFinalize(dFed, "")
# }
# h.helics_message m3
# auto dcFedExec = [&]() {
# h.helicsFederateRequestTime(dcFed, 2.0)
# auto res = h.helicsFederateHasMessage(dcFed)
# if (res == h.helics_False) {
# std::this_thread::sleep_for(std::chrono::milliseconds(50))
# h.helicsFederateRequestTime(dcFed, 4.0)
# }
# m3 = h.helicsEndpointGetMessage(p3)
# h.helicsFederateFinalize(dcFed)
# }
# auto threaddFed = std::thread(dFedExec)
# auto threaddcFed = std::thread(dcFedExec)
# threaddFed.join()
# (m2.source, "src")
# (m2.original_source, "src")
# (m2.dest, "dest")
# (m2.length, static_cast<int64_t>(data.size()))
# threaddcFed.join()
# (m3.source, "src")
# (m3.original_source, "src")
# (m3.dest, "cm")
# (m3.original_dest, "dest")
# (m3.length, static_cast<int64_t>(data.size()))
# (state = h.helicsFederateGetState(sFed))
# (state == h.helics_state_finalize)
destroyFederate(sFed, fedinfo1)
destroyFederate(dFed, fedinfo2)
destroyFederate(dcFed, fedinfo3)
destroyBroker(broker)
def test_filter_test_types_clone_test_connections():
broker = createBroker(3)
sFed, fedinfo1 = createMessageFederate(
1,
"source",
1.0,
)
dFed, fedinfo2 = createMessageFederate(1, "dest", 1.0)
dcFed, fedinfo3 = createMessageFederate(1, "dest_clone", 1.0)
p1 = h.helicsFederateRegisterGlobalEndpoint(sFed, "src", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(dFed, "dest", "")
p3 = h.helicsFederateRegisterGlobalEndpoint(dcFed, "cm", "")
f1 = h.helicsFederateRegisterGlobalCloningFilter(dcFed, "filt1")
h.helicsFilterAddDeliveryEndpoint(f1, "cm")
cr = h.helicsFederateGetCoreObject(sFed)
h.helicsCoreAddSourceFilterToEndpoint(cr, "filt1", "src")
h.helicsCoreAddSourceFilterToEndpoint(cr, "", "src")
h.helicsFederateEnterExecutingModeAsync(sFed)
h.helicsFederateEnterExecutingModeAsync(dcFed)
h.helicsFederateEnterExecutingMode(dFed)
h.helicsFederateEnterExecutingModeComplete(sFed)
h.helicsFederateEnterExecutingModeComplete(dcFed)
q = h.helicsCreateQuery("", "filtered_endpoints")
filteredEndpoints = h.helicsQueryExecute(q, sFed)
assert "srcFilters" in str(filteredEndpoints)
assert "(cloning)" in str(filteredEndpoints)
h.helicsQueryFree(q)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "dest", data)
h.helicsFederateRequestTimeAsync(sFed, 1.0)
h.helicsFederateRequestTimeAsync(dcFed, 1.0)
h.helicsFederateRequestTime(dFed, 1.0)
h.helicsFederateRequestTimeComplete(sFed)
h.helicsFederateRequestTimeComplete(dcFed)
assert h.helicsFederateHasMessage(dFed) is True
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsFederateHasMessage(dcFed) is True
m2 = h.helicsEndpointGetMessage(p3)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "cm"
assert h.helicsMessageGetOriginalDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
h.helicsFederateFinalizeAsync(sFed)
h.helicsFederateFinalizeAsync(dFed)
h.helicsFederateFinalize(dcFed)
h.helicsFederateFinalizeComplete(sFed)
h.helicsFederateFinalizeComplete(dFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(sFed, fedinfo1)
destroyFederate(dFed, fedinfo2)
destroyFederate(dcFed, fedinfo3)
destroyBroker(broker)
source = h.helicsMessageGetOriginalSource(msg)
logger.debug(f'Received message from endpoint {source}'
f' at time {t}'
f' with SOC {currentsoc}')
# Send back charging command based on current SOC
# Our very basic protocol:
# If the SOC is less than soc_full keep charging (send "1")
# Otherwise, stop charging (send "0")
soc_full = 0.9
if float(currentsoc) <= soc_full:
instructions = 1
else:
instructions = 0
message = str(instructions)
h.helicsEndpointSendMessageRaw(endid, source, message)
logger.debug(f'Sent message to endpoint {source}'
f' at time {t}'
f' with payload {instructions}')
# Store SOC for later analysis/graphing
if source not in soc:
soc[source] = []
soc[source].append(float(currentsoc))
time_sim.append(t)
# Since we've dealt with all the messages that are queued, there's
# nothing else for the federate to do until/unless another
# message comes in. Request a time very far into the future
# and take a break until/unless a new message arrives.
else:
logger.debug(f'\tNo messages at endpoint {endpoint_name} '
f'recieved at '
f'time {grantedtime}')
# Publish updated charging voltage
h.helicsPublicationPublishDouble(pubid[j], charging_voltage[j])
logger.debug(
f'\tPublishing charging voltage of {charging_voltage[j]} '
f' at time {grantedtime}')
# Send message to Controller with SOC every 15 minutes
if grantedtime % 900 == 0:
destination_name = str(
h.helicsEndpointGetDefaultDestination(endid[j]))
h.helicsEndpointSendMessageRaw(
endid[j], "", f'{currentsoc[j]:4f}'.encode()) #
logger.debug(f'Sent message from endpoint {endpoint_name}'
f' at time {grantedtime}'
f' with payload SOC {currentsoc[j]:4f}')
# Calculate the total power required by all chargers. This is the
# primary metric of interest, to understand the power profile
# and capacity requirements required for this charging garage.
total_power = 0
for j in range(0, end_count):
total_power += charge_rate[(EVlist[j] - 1)]
# Data collection vectors
time_sim.append(grantedtime)
power.append(total_power)
def test_filter_test_types_function2():
broker = createBroker(2)
fFed, fedinfo1 = createMessageFederate(1, "filter")
mFed, fedinfo2 = createMessageFederate(1, "message")
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "")
f1 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_DELAY,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
h.helicsFilterSet(f1, "delay", 2.5)
f2 = h.helicsFederateRegisterFilter(fFed, h.HELICS_FILTER_TYPE_DELAY,
"filter2")
h.helicsFilterAddSourceTarget(f2, "port2")
h.helicsFilterSet(f2, "delay", 2.5)
# this is expected to fail since a regular filter doesn't have a delivery endpoint
# @test_throws h.HELICSErrorInvalidObject h.helicsFilterAddDeliveryEndpoint(f2, "port1")
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "port2", data)
h.helicsFederateRequestTimeAsync(mFed, 1.0)
h.helicsFederateRequestTime(fFed, 1.0)
h.helicsFederateRequestTimeComplete(mFed)
res = h.helicsFederateHasMessage(mFed)
assert res is False
h.helicsEndpointSendMessageRaw(p2, "port1", data)
h.helicsFederateRequestTimeAsync(mFed, 2.0)
h.helicsFederateRequestTime(fFed, 2.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2) is False
# there may be something wrong here yet but this test isn't the one to find it and
# this may prevent spurious errors for now.
# std::this_thread::yield()
h.helicsFederateRequestTime(mFed, 3.0)
assert h.helicsEndpointHasMessage(p2) is True
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "port1"
assert h.helicsMessageGetOriginalSource(m2) == "port1"
assert h.helicsMessageGetDestination(m2) == "port2"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsMessageGetTime(m2) == 2.5
assert h.helicsEndpointHasMessage(p1) is False
h.helicsFederateRequestTime(mFed, 4.0)
assert h.helicsEndpointHasMessage(p1) is True
h.helicsFederateFinalizeAsync(mFed)
h.helicsFederateFinalize(fFed)
h.helicsFederateFinalizeComplete(mFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(fFed, fedinfo1)
destroyFederate(mFed, fedinfo2)
destroyBroker(broker)
logger.info('Total Feeder Load is {} + {} j'.format(
Real_feeder_load, Imag_feeder_load))
if (Real_feeder_load > feeder_limit_upper):
logger.info('Total Feeder Load is over the Feeder Upper Limit')
logger.info('Warning ----> Feeder OverLimit ---> Turn off EV')
if (k < endpoint_count):
end = endid["m{}".format(k)]
end_name = str(h.helicsEndpointGetName(end))
print(end_name)
destination_name = (end_name.replace(federate_name,
distribution_fed_name))
print('Endpoint Destination {}'.format(destination_name))
status = h.helicsEndpointSendMessageRaw(
end, destination_name, str('0 + 0 j'))
#status = h.helicsEndpointSendMessageRaw(end, 'NULL', str('0 + 0 j'))
logger.info('Turning off {}'.format(end_name))
k = k + 1
else:
logger.info('All EVs are Turned off')
if (Real_feeder_load < feeder_limit_lower):
logger.info('Total Feeder Load is under the Feeder Lower Limit')
logger.info('Feeder Can Support EVs ------> Turn on EV')
if (k > 0):
k = k - 1
end = endid["m{}".format(k)]
end_name = h.helicsEndpointGetName(end)
destination_name = (end_name.replace(federate_name,
distribution_fed_name))
print("Broker created and connected")
fed = h.helicsCreateCombinationFederateFromConfig("sender.json")
my_epid = h.helicsFederateGetEndpoint(fed, "data")
h.helicsFederateEnterExecutingMode(fed)
l = []
for i in range(64, 79):
l.append(i)
l.append(255)
message = bytes(l)
print(message)
current_time = 0
for i in range(1, 5):
current_time = h.helicsFederateRequestTime(fed, i)
print("current time : ", current_time)
h.helicsEndpointSendMessageRaw(my_epid, "receiver/data", message)
time.sleep(0.5)
h.helicsFederateFinalize(fed)
while h.helicsBrokerIsConnected(broker):
time.sleep(1)
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
def main(delay=None, verbose=False):
if verbose is not False:
logger.setLevel(logging.DEBUG)
mapping = create_mapping()
logger.info("Creating CombinationFederate for FESTIV")
fed = create_value_federate()
pubid1 = h.helicsFederateRegisterGlobalTypePublication(
fed, "AGCGenDispatch/Alta", h.HELICS_DATA_TYPE_COMPLEX, "")
pubid2 = h.helicsFederateRegisterGlobalTypePublication(
fed, "AGCGenDispatch/Brighton", h.HELICS_DATA_TYPE_COMPLEX, "")
pubid3 = h.helicsFederateRegisterGlobalTypePublication(
fed, "AGCGenDispatch/ParkCity", h.HELICS_DATA_TYPE_COMPLEX, "")
pubid4 = h.helicsFederateRegisterGlobalTypePublication(
fed, "AGCGenDispatch/Solitude", h.HELICS_DATA_TYPE_COMPLEX, "")
pubid5 = h.helicsFederateRegisterGlobalTypePublication(
fed, "AGCGenDispatch/Sundance", h.HELICS_DATA_TYPE_COMPLEX, "")
logger.info("Registering endpoint")
epid = h.helicsFederateRegisterGlobalEndpoint(fed, "festiv-fixed-price",
"")
if delay is not None:
fedfilter = h.helicsFederateRegisterSourceFilter(
fed, 1, "festiv-fixed-price", "delay_filter")
status = h.helicsFilterSet(fedfilter, "delay", int(delay))
h.helicsFederateEnterExecutionMode(fed)
time_granted = -1
last_second = -1
ticker = 0
for day in [
'2020-08-03',
'2020-08-04',
'2020-08-05',
'2020-08-06',
'2020-08-07',
'2020-08-08',
'2020-08-09',
]:
logger.info("Running DAM for day={day}".format(day=day))
df = get_load(day)
dam_s = df.loc[day, 'LOAD'].resample('1H').mean()
dam_m = build_DAM_model(day, dam_s)
dam_m.solve('cbc', verbose=False)
rtm_s = df.loc[day, 'LOAD'].resample('5T').mean()
for interval in range(0, int(24 * 60 / 5)):
hour = int(interval * 5 / 60)
logger.info(
"Running RTM for day={day} for minute={m} (hour={hour})".
format(day=day, m=interval * 5, hour=hour))
commitment = dam_m.results.unit_commitment.loc[hour:hour, :]
rtm_m = build_RTM_model(day, rtm_s.iloc[interval], commitment)
rtm_m.solve('cbc', verbose=False)
logger.debug("LMP = {lmp} \t Power Generated = {pg}".format(
lmp=rtm_m.results.lmp, pg=rtm_m.results.power_generated))
for minute in range(0, 5):
for second in range(0, 60):
ticker = ticker + 1
if int(second % 6) == 0:
stop_at_time = ticker
while time_granted < stop_at_time:
status, time_granted = h.helicsFederateRequestTime(
fed, stop_at_time)
b2, b3, b4 = rtm_m.results.lmp[['B2', 'B3',
'B4']].values[0]
for name in mapping["B2"]:
status = h.helicsEndpointSendMessageRaw(
epid, "{}/fixed_price".format(name), str(b2))
for name in mapping["B3"]:
status = h.helicsEndpointSendMessageRaw(
epid, "{}/fixed_price".format(name), str(b3))
for name in mapping["B4"]:
status = h.helicsEndpointSendMessageRaw(
epid, "{}/fixed_price".format(name), str(b4))
pg = rtm_m.results.power_generated.loc[0].to_dict()
status = h.helicsPublicationPublishDouble(
pubid1, pg["ALTA"])
status = h.helicsPublicationPublishDouble(
pubid2, pg["BRIGHTON"])
status = h.helicsPublicationPublishDouble(
pubid3, pg["PARKCITY"])
status = h.helicsPublicationPublishDouble(
pubid4, pg["SOLITUDE"])
status = h.helicsPublicationPublishDouble(
pubid5, pg["SUNDANCE"])
logger.info("Publishing lmp B2={}".format(b2))
logger.info("Publishing lmp B3={}".format(b2))
logger.info("Publishing lmp B4={}".format(b2))
logger.info("Publishing pg = {}".format(pg))
logger.info("Current time = {minutes} ".format(
minutes=ticker / 60))
while t < total_interval:
for j in range(0, len(enddest_EVsoc)):
# 1. Receive SOC
# print('endpt name: ',h.helicsEndpointGetName(end_EVsoc[j]))
if h.helicsEndpointHasMessage(end_EVsoc[j]):
msg = h.helicsEndpointGetMessageObject(end_EVsoc[j])
currentsoc = h.helicsMessageGetString(msg)
# print('currentsoc: ',currentsoc)
# 2. Send instructions
# destination_name = str(h.helicsEndpointGetDefaultDestination(end_EVsoc[j]))
print(t / 3600, currentsoc)
if float(currentsoc) <= 0.9:
instructions = 1
else:
instructions = 0
message = str(instructions)
h.helicsEndpointSendMessageRaw(end_EVsoc[j], "", message) #
# print('Sent instructions: {}'.format(instructions))
else:
print("NO MESSAGE RECEIVED AT TIME ", t / 3600)
grantedtime = h.helicsFederateRequestTime(fed, (t + update_interval))
# print('EV time: ',grantedtime/3600)
t = grantedtime
# logger.info("Destroying federate")
destroy_federate(fed)
# logger.info("Done!")
logger.info("Total Feeder Load is {} + {} j".format(Real_feeder_load, Imag_feeder_load))
if Real_feeder_load > feeder_limit_upper:
logger.info("Total Feeder Load is over the Feeder Upper Limit")
logger.info("Warning ----> Feeder OverLimit ---> Turn off EV")
if k < endpoint_count:
end = endid["m{}".format(k)]
logger.info("endid: {}".format(endid))
end_name = str(h.helicsEndpointGetName(end))
logger.info("Sending endpoint name: {}".format(end_name))
destination_name = end_name.replace(federate_name, distribution_fed_name)
logger.info(
"Endpoint destination: {}".format(h.helicsEndpointGetDefaultDestination(end))
)
status = h.helicsEndpointSendMessageRaw(end, "", str("0 + 0 j")) #
logger.info("Endpoint sending status: {}".format(status))
logger.info("Turning off {}".format(end_name))
k = k + 1
else:
logger.info("All EVs are Turned off")
if Real_feeder_load < feeder_limit_lower:
logger.info("Total Feeder Load is under the Feeder Lower Limit")
logger.info("Feeder Can Support EVs ------> Turn on EV")
if k > 0:
k = k - 1
end = endid["m{}".format(k)]
end_name = h.helicsEndpointGetName(end)
destination_name = end_name.replace(federate_name, distribution_fed_name)
print("Endpoint Destination {}".format(destination_name))
def run_cosim(fed, endid):
# The event queue ("eq") is the master list of events that the filter
# federates works on. In this simple filter federate, each event
# will be a dictionary with a few parameters:
# 'dest' - destination of message
# 'time' - time when the message should be sent on to its
# intended destination
# 'payload' - content of the message being sent
#
# When eq is empty, there are no messages being
# filtered by the federate. When there are events in the queue it
# indicates the filter federate has messages it is holding onto
# that it needs to forward on (at the indicated time).
#
eq = []
h.helicsFederateEnterExecutingMode(fed)
logger.info('Entered HELICS execution mode')
hours = 24 * 7 # one week
total_interval = int(60 * 60 * hours)
# Blocking call for a time request at max simulation time
fake_max_time = int(h.HELICS_TIME_MAXTIME / 1000)
starttime = fake_max_time
logger.debug(f'Requesting initial time {starttime}')
grantedtime = h.helicsFederateRequestTime(fed, starttime)
logger.debug(f'Granted time {grantedtime}')
while grantedtime < total_interval:
# In HELICS, when multiple messages arrive at an endpoint they
# queue up and are popped off one-by-one with the
# "helicsEndpointHasMessage" API call. When that API doesn't
# return a message, you've processed them all.
while h.helicsEndpointHasMessage(endid):
msg = h.helicsEndpointGetMessage(endid)
msg_str = h.helicsMessageGetString(msg)
source = h.helicsMessageGetOriginalSource(msg)
dest = h.helicsMessageGetOriginalDestination(msg)
time = h.helicsMessageGetTime(msg)
logger.debug(f'Received message from endpoint {source}'
f' to endpoint {dest}'
f' at time {grantedtime}'
f' with message {msg_str}')
event = {
"payload": msg_str,
"source": source,
"dest": dest,
"time": time
}
eq = filter_message(eq, event, 'delay')
if source == 'EVController_federate/endpoint':
eq = filter_message(eq, event, 'hack')
# Sort event queue to get it back in order
eq = sorted(eq, key=itemgetter('time'))
# Acting on any events that need to be dequeued
# Running interference filter. This filter has the ability to
# remove events from eq. We may not have any messages to send
# after interference runs
event = eq[0]
eq = filter_message(eq, event, 'interfere')
# After filtering, send all messages whose time has come (or past;
# in which case something has gone wrong)
while eq and eq[0]['time'] <= grantedtime:
h.helicsEndpointSendMessageRaw(endid, eq[0]['dest'],
eq[0]['payload'].encode())
logger.debug(f'Sent message from endpoint {endid}'
f' to endpoint {eq[0]["dest"]}'
f' at time {grantedtime}'
f' with message {eq[0]["payload"]}')
del eq[0]
if eq:
# Event queue not empty, need to schedule filter federate to
# run again when its time to deliver the next message in the
# queue
requested_time = eq[0]['time']
else:
# If no events in queue, schedule run for end of simulation.
# Filter federate will be granted an earlier time if a
# message is rerouted to the filter federate.
requested_time = fake_max_time
logger.debug(f'Requesting time {requested_time}')
grantedtime = h.helicsFederateRequestTime(fed, requested_time)
logger.debug(f'Granted time {grantedtime}')
source = h.helicsMessageGetOriginalSource(msg)
logger.debug(f'Received message from endpoint {source}'
f' at time {grantedtime}'
f' with SOC {currentsoc}')
# Send back charging command based on current SOC
# Our very basic protocol:
# If the SOC is less than soc_full keep charging (send "1")
# Otherwise, stop charging (send "0")
soc_full = 0.95
if float(currentsoc) <= soc_full:
instructions = 1
else:
instructions = 0
message = str(instructions)
h.helicsEndpointSendMessageRaw(endid, source, message.encode())
logger.debug(f'Sent message to endpoint {source}'
f' at time {grantedtime}'
f' with payload {instructions}')
# Store SOC for later analysis/graphing
if source not in soc:
soc[source] = []
soc[source].append(float(currentsoc))
time_sim.append(grantedtime)
# Since we've dealt with all the messages that are queued, there's
# nothing else for the federate to do until/unless another
# message comes in. Request a time very far into the future
# and take a break until/unless a new message arrives.
import helics as h
from math import pi
print("about to read file")
fed = h.helicsCreateMessageFederateFromConfig("config1.json")
print("read file")
epid = h.helicsFederateGetEndpointByIndex(fed, 0)
ep_name = h.helicsEndpointGetName(epid)
print(ep_name)
h.helicsFederateEnterExecutingMode(fed)
this_time = 0.0
value = pi
for t in range(1, 11):
val = value * t
currenttime = h.helicsFederateRequestTime(fed, t)
h.helicsEndpointSendMessageRaw(epid, "end2", str(val))
print("PI SENDER: Sending value pi = {} at time {} to PI RECEIVER".format(
val, currenttime))
#h.helicsFederateRequestTime(fed, 10000)
h.helicsFederateFinalize(fed)
print("PI SENDER: Federate finalized")
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
def test_filter_test_types_message_filter_function3():
broker = createBroker(2)
fFed, fedinfo1 = createMessageFederate(1, "filter", 1)
mFed, fedinfo2 = createMessageFederate(1, "message", 1)
p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "random")
f1 = h.helicsFederateRegisterGlobalFilter(fFed,
h.HELICS_FILTER_TYPE_CUSTOM,
"filter1")
h.helicsFilterAddSourceTarget(f1, "port1")
f2 = h.helicsFederateRegisterGlobalFilter(fFed, h.HELICS_FILTER_TYPE_DELAY,
"filter2")
h.helicsFilterAddSourceTarget(f2, "port1")
h.helicsFederateRegisterEndpoint(fFed, "fout", "")
f3 = h.helicsFederateRegisterFilter(fFed,
h.HELICS_FILTER_TYPE_RANDOM_DELAY,
"filter3")
h.helicsFilterAddSourceTarget(f3, "filter0/fout")
h.helicsFilterSet(f2, "delay", 2.5)
h.helicsFederateEnterExecutingModeAsync(fFed)
h.helicsFederateEnterExecutingMode(mFed)
h.helicsFederateEnterExecutingModeComplete(fFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_EXECUTION
data = "hello world".encode()
h.helicsEndpointSendMessageRaw(p1, "port2", data)
h.helicsFederateRequestTimeAsync(mFed, 1.0)
h.helicsFederateRequestTime(fFed, 1.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsFederateHasMessage(mFed) is False
h.helicsEndpointSendMessageRaw(p2, "port1", data)
h.helicsFederateRequestTimeAsync(mFed, 2.0)
h.helicsFederateRequestTime(fFed, 2.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2) is False
# there may be something wrong here yet but this test isn't the one to find it and
# this may prevent spurious errors for now.
# std::this_thread::yield()
h.helicsFederateRequestTimeAsync(mFed, 3.0)
h.helicsFederateRequestTime(fFed, 3.0)
h.helicsFederateRequestTimeComplete(mFed)
assert h.helicsEndpointHasMessage(p2)
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "port1"
assert h.helicsMessageGetOriginalSource(m2) == "port1"
assert h.helicsMessageGetDestination(m2) == "port2"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsMessageGetTime(m2) == 2.5
assert h.helicsEndpointHasMessage(p1) is True
h.helicsFederateFinalize(mFed)
h.helicsFederateFinalize(fFed)
state = h.helicsFederateGetState(fFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(mFed, fedinfo1)
destroyFederate(fFed, fedinfo2)
destroyBroker(broker)
logger.info('Total Feeder Load is {} + {} j'.format(
Real_feeder_load, Imag_feeder_load))
if (Real_feeder_load > feeder_limit_upper):
logger.info('Total Feeder Load is over the Feeder Upper Limit')
logger.info('Warning ----> Feeder OverLimit ---> Turn off EV')
if (k < endpoint_count):
end = endid["m{}".format(k)]
end_name = str(h.helicsEndpointGetName(end))
print(end_name)
destination_name = (end_name.replace(federate_name,
distribution_fed_name))
print('Endpoint Destination {}'.format(destination_name))
#status = h.helicsEndpointSendMessageRaw(end, destination_name, str('0 + 0 j'))
status = h.helicsEndpointSendMessageRaw(
end, 'NULL', str('0 + 0 j'))
logger.info('Turning off {}'.format(end_name))
k = k + 1
else:
logger.info('All EVs are Turned off')
if (Real_feeder_load < feeder_limit_lower):
logger.info('Total Feeder Load is under the Feeder Lower Limit')
logger.info('Feeder Can Support EVs ------> Turn on EV')
if (k > 0):
k = k - 1
end = endid["m{}".format(k)]
end_name = h.helicsEndpointGetName(end)
destination_name = (end_name.replace(federate_name,
distribution_fed_name))
print('Endpoint Destination {}'.format(destination_name))
def test_filter_test_types_clone_test():
broker = createBroker(3)
sFed, fedinfo1 = createMessageFederate(1, "source", 1)
dFed, fedinfo2 = createMessageFederate(1, "dest", 1)
dcFed, fedinfo3 = createMessageFederate(1, "dest_clone", 1)
p1 = h.helicsFederateRegisterGlobalEndpoint(sFed, "src", "")
p2 = h.helicsFederateRegisterGlobalEndpoint(dFed, "dest", "")
p3 = h.helicsFederateRegisterGlobalEndpoint(dcFed, "cm", "")
f1 = h.helicsFederateRegisterCloningFilter(dcFed, "")
h.helicsFilterAddDeliveryEndpoint(f1, "cm")
h.helicsFilterAddSourceTarget(f1, "src")
h.helicsFederateEnterExecutingModeAsync(sFed)
h.helicsFederateEnterExecutingModeAsync(dcFed)
h.helicsFederateEnterExecutingMode(dFed)
h.helicsFederateEnterExecutingModeComplete(sFed)
h.helicsFederateEnterExecutingModeComplete(dcFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_EXECUTION
state = h.helicsFederateGetState(dcFed)
assert state == h.HELICS_STATE_EXECUTION
state = h.helicsFederateGetState(dFed)
assert state == h.HELICS_STATE_EXECUTION
data = "".join(["a" for _ in range(0, 500)]).encode()
h.helicsEndpointSendMessageRaw(p1, "dest", data)
h.helicsFederateRequestTimeAsync(sFed, 1.0)
h.helicsFederateRequestTimeAsync(dcFed, 1.0)
h.helicsFederateRequestTime(dFed, 1.0)
h.helicsFederateRequestTimeComplete(sFed)
h.helicsFederateRequestTimeComplete(dcFed)
assert h.helicsFederateHasMessage(dFed)
m2 = h.helicsEndpointGetMessage(p2)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
assert h.helicsFederateHasMessage(dcFed)
m2 = h.helicsEndpointGetMessage(p3)
assert h.helicsMessageGetSource(m2) == "src"
assert h.helicsMessageGetOriginalSource(m2) == "src"
assert h.helicsMessageGetDestination(m2) == "cm"
assert h.helicsMessageGetOriginalDestination(m2) == "dest"
assert h.helicsMessageGetRawDataSize(m2) == len(data)
h.helicsFederateFinalizeAsync(sFed)
h.helicsFederateFinalizeAsync(dFed)
h.helicsFederateFinalize(dcFed)
h.helicsFederateFinalizeComplete(sFed)
h.helicsFederateFinalizeComplete(dFed)
state = h.helicsFederateGetState(sFed)
assert state == h.HELICS_STATE_FINALIZE
destroyFederate(sFed, fedinfo1)
destroyFederate(dFed, fedinfo2)
destroyFederate(dcFed, fedinfo3)
destroyBroker(broker)