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_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()
logger.info(f'\tEV full; removing charging voltage')
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)
currentsoc = np.linspace(0.1, 0.5, num=end_count)
# 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):
logger.info("EV Controller grantedtime = {}".format(grantedtime))
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)
numLvl1, numLvl2, numLvl3, EVlist = get_new_EV(end_count)
##
## Step through each time period starting from t = 0
time_sim = []
currentsoc = np.random.rand(end_count)
#t = 0
# this will be the first message that is "waiting" for the
# EV Controller
t = h.helicsFederateRequestTime(fed, 0)
for j in range(0, len(enddest_EVsoc)):
end_name = str(h.helicsEndpointGetName(end_EVsoc[j]))
destination_name = str(
h.helicsEndpointGetDefaultDestination(end_EVsoc[j]))
h.helicsEndpointSendMessageRaw(end_EVsoc[j], "", str(currentsoc[j])) #
#print('destination: ',destination_name)
#print('message sent: ',str(currentsoc[j]))
#print('at time: ',t/3600)
#print(t/3600,currentsoc[j])
grantedtime = h.helicsFederateRequestTime(fed, (t + update_interval))
t = grantedtime
#logger.info('time: ',t)
time_since_last_msg = np.zeros(end_count)
print('time power')
next_time = []
while t < total_interval:
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)
