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 ##################################