def init_logger(config_file_name):
fed = h.helicsCreateMessageFederateFromConfig(config_file_name)
my_epid = h.helicsFederateGetEndpoint(fed, "logger")
fed_name = h.helicsFederateGetName(fed)
print(fed_name)
pid = os.getpid()
print("Logger Pid {}".format(pid))
currenttime = -1
output = ""
log.basicConfig(filename='./log/logger.log',
filemode='w',
format='%(message)s',
level=log.INFO)
h.helicsFederateEnterExecutingMode(fed)
while (currenttime < maxtime):
currenttime = h.helicsFederateRequestTime(fed, maxtime)
if h.helicsEndpointHasMessage(my_epid):
count = h.helicsEndpointPendingMessages(my_epid)
for i in range(count):
message = h.helicsEndpointGetMessage(my_epid)
output = output + str(message.data) + "\n"
log.info("Current Time : {}".format(currenttime))
log.info(output)
h.helicsFederateFinalize(fed)
print(fed_name, " : Federate finalized")
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
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 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_filter_test_file_load():
filename = os.path.join(CURRENT_DIRECTORY, "filters.json")
mFed = h.helicsCreateMessageFederateFromConfig(filename)
name = h.helicsFederateGetName(mFed)
assert name == "filterFed"
assert h.helicsFederateGetEndpointCount(mFed) == 3
h.helicsFederateFinalize(mFed)
h.helicsCloseLibrary()
def configure_federate():
fed = h.helicsCreateMessageFederateFromConfig("FilterConfig.json")
federate_name = h.helicsFederateGetName(fed)
logger.info(f'Created federate {federate_name}')
# Diagnostics to confirm JSON config correctly added the required
# endpoints
end_count = h.helicsFederateGetEndpointCount(fed)
logger.debug(f'\tNumber of endpoints: {end_count}')
endid = h.helicsFederateGetEndpointByIndex(fed, 0)
end_name = h.helicsEndpointGetName(endid)
logger.debug("Registered Endpoint ---> {}".format(end_name))
return fed, endid
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()
def init_logger(config_file_name, log_out_file_name, total_simulation_time,
individual_simulation_time):
print("logger in")
fed = h.helicsCreateMessageFederateFromConfig(config_file_name)
print("logger passed config")
my_epid = h.helicsFederateGetEndpoint(fed, "logger")
fed_name = h.helicsFederateGetName(fed)
# print(fed_name)
pid = os.getpid()
# print("Logger Pid {}".format(pid))
currenttime = -1
output = ""
log.basicConfig(filename="./log/{}".format(log_out_file_name),
filemode='w',
format='%(message)s',
level=log.INFO)
print(fed_name, " about to Started")
h.helicsFederateEnterExecutingMode(fed)
print(fed_name, "Started")
while (currenttime < maxtime):
currenttime = h.helicsFederateRequestTime(fed, maxtime)
if h.helicsEndpointHasMessage(my_epid):
count = h.helicsEndpointPendingMessages(my_epid)
for i in range(count):
message = h.helicsEndpointGetMessage(my_epid)
# log.log(str(message.messageID))
output = output + str(message.data) + "message id: " + "\n"
log.info(output)
h.helicsFederateFinalize(fed)
print(fed_name, " : Federate finalized")
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
import time
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()
should proceed without it (if applicable). Generally this is done
when the co-simulation is complete and all federates end execution
at more or less the same wall-clock time.
:param fed: Federate to be destroyed
:return: (none)
'''
status = h.helicsFederateFinalize(fed)
h.helicsFederateFree(fed)
h.helicsCloseLibrary()
logger.info('Federate finalized')
if __name__ == "__main__":
############## Registering federate from json ##########################
fed = h.helicsCreateMessageFederateFromConfig("ControllerConfig.json")
federate_name = h.helicsFederateGetName(fed)
logger.info(f'Created federate {federate_name}')
#### Register endpoint #####
# Only one endpoint for the controller
endid = h.helicsFederateGetEndpointByIndex(fed, 0)
end_name = h.helicsEndpointGetName(endid)
logger.info("Registered Endpoint ---> {}".format(end_name))
############## Entering Execution Mode ##################################
h.helicsFederateEnterExecutingMode(fed)
logger.info('Entered HELICS execution mode')
hours = 24*7 # one week
med = 0.2
lg = 0.6
# Batteries have different sizes:
# [25,62,100]
listOfBatts = np.random.choice([25,62,100],numBattery,p=[sm,med,
lg]).tolist()
return listOfBatts
if __name__ == "__main__":
np.random.seed(2622)
########## Registering federate and configuring from JSON################
fed = h.helicsCreateMessageFederateFromConfig("BatteryConfig.json")
federate_name = h.helicsFederateGetName(fed)
logger.info(f'Created federate {federate_name}')
print(f'Created federate {federate_name}')
end_count = h.helicsFederateGetEndpointCount(fed)
logging.debug(f'\tNumber of endpoints: {end_count}')
# Diagnostics to confirm JSON config correctly added the required
# endpoints
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}')
lvl2 = 0.6
lvl3 = 0.35
listOfEVs = np.random.choice([1, 2, 3], numEVs, p=[lvl1, lvl2,
lvl3]).tolist()
numLvl1 = listOfEVs.count(1)
numLvl2 = listOfEVs.count(2)
numLvl3 = listOfEVs.count(3)
return numLvl1, numLvl2, numLvl3, listOfEVs
if __name__ == "__main__":
np.random.seed(1490)
############## Registering federate from json ##########################
fed = h.helicsCreateMessageFederateFromConfig("ChargerConfig.json")
federate_name = h.helicsFederateGetName(fed)
logger.info(f'Created federate {federate_name}')
print(f'Created federate {federate_name}')
end_count = h.helicsFederateGetEndpointCount(fed)
logging.debug(f'\tNumber of endpoints: {end_count}')
# Diagnostics to confirm JSON config correctly added the required
# endpoints
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}')
############## Entering Execution Mode ##################################
