for i in range(0, pub_count):
pubid[i] = h.helicsFederateGetPublicationByIndex(fed, i)
pub_name = h.helicsPublicationGetKey(pubid[i])
logger.debug(f'\tRegistered publication---> {pub_name}')
############## Entering Execution Mode ##################################
h.helicsFederateEnterExecutingMode(fed)
logger.info('Entered HELICS execution mode')
# Definition of charging power level (in kW) for level 1, 2, 3 chargers
charge_rate = [1.8, 7.2, 50]
hours = 24 * 7 # one week
total_interval = int(60 * 60 * hours)
update_interval = int(
h.helicsFederateGetTimeProperty(fed, h.HELICS_PROPERTY_TIME_PERIOD))
grantedtime = 0
# Generate an initial fleet of EVs, one for each previously defined
# endpoint. This gives each EV a unique link to the EV controller
# federate.
numLvl1, numLvl2, numLvl3, EVlist = get_new_EV(end_count)
charging_voltage = calc_charging_voltage(EVlist)
currentsoc = {}
# Data collection lists
time_sim = []
power = []
# Blocking call for a time request at simulation time 0
initial_time = 60
pub_name[i] = h.helicsPublicationGetKey(pubid[i])
logger.debug(f'\tRegistered publication---> {pub_name[i]}')
############## Entering Execution Mode ##################################
h.helicsFederateEnterExecutingMode(fed)
logger.info('Entered HELICS execution mode')
hours = 24*7 # one week
total_interval = int(60 * 60 * hours)
update_interval = int(h.helicsFederateGetTimeProperty(
fed,
h.HELICS_PROPERTY_TIME_PERIOD))
grantedtime = 0
# Define battery physics as empirical values
socs = np.array([0, 1])
effective_R = np.array([8, 150])
batt_list = get_new_battery(pub_count)
current_soc = {}
for i in range (0, pub_count):
current_soc[i] = (np.random.randint(0,60))/100
# Define battery physics as empirical values
socs = np.array([0, 1])
# 8 ohms to 150 ohms
effective_R = np.array([8, 150])
batt_list = get_new_battery(end_count)
current_soc = {}
for i in range (0, end_count):
current_soc[i] = (np.random.randint(0,60))/100
hours = 24 * 7
total_interval = int(60 * 60 * hours)
update_interval = 60*int(h.helicsFederateGetTimeProperty(
fed,
h.helics_property_time_period))
update_offset = int(h.helicsFederateGetTimeProperty(
fed,
h.helics_property_time_offset))
grantedtime = 0
# Data collection lists
time_sim = []
total_current = []
soc = {}
# As long as granted time is in the time range to be simulated...
while grantedtime < total_interval:
# Time request for the next interval to be simulated
# Define battery physics as empirical values
socs = np.array([0, 1])
# 8 ohms to 150 ohms
effective_R = np.array([8, 150])
batt_list = get_new_battery(end_count)
current_soc = {}
for i in range(0, end_count):
current_soc[i] = (np.random.randint(0, 60)) / 100
hours = 24 * 7
total_interval = int(60 * 60 * hours)
update_interval = int(
h.helicsFederateGetTimeProperty(fed, h.helics_property_time_period))
update_offset = int(
h.helicsFederateGetTimeProperty(fed, h.helics_property_time_offset))
grantedtime = 0
# Data collection lists
time_sim = []
total_current = []
soc = {}
# As long as granted time is in the time range to be simulated...
while grantedtime < total_interval:
# Time request for the next interval to be simulated
requested_time = (grantedtime + update_interval + update_offset)
logger.debug(f'Requesting time {requested_time}')
def test_messagefederate_timing_tests():
broker = createBroker(1)
vFed1, fedinfo1 = createMessageFederate(1, "fed0")
vFed2, fedinfo2 = createMessageFederate(1, "fed1")
h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 0.1)
h.helicsFederateSetTimeProperty(vFed2, h.HELICS_PROPERTY_TIME_PERIOD, 0.1)
h.helicsFederateSetTimeProperty(vFed2, h.HELICS_PROPERTY_TIME_INPUT_DELAY,
0.1)
h.helicsFederateSetFlagOption(vFed1,
h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS,
True)
h.helicsFederateSetFlagOption(vFed2,
h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS,
True)
ept1 = h.helicsFederateRegisterGlobalEndpoint(vFed1, "e1", "")
h.helicsFederateRegisterGlobalEndpoint(vFed2, "e2", "")
h.helicsFederateEnterExecutingModeAsync(vFed1)
h.helicsFederateEnterExecutingMode(vFed2)
h.helicsFederateEnterExecutingModeComplete(vFed1)
h.helicsFederateRequestTimeAsync(vFed2, 2.0)
gtime = h.helicsFederateRequestTime(vFed1, 1.0)
# check that the request is only granted at the appropriate period
assert gtime == 1.0
assert h.helicsFederateGetIntegerProperty(
vFed1, h.HELICS_PROPERTY_INT_CONSOLE_LOG_LEVEL) == -1
assert h.helicsFederateGetIntegerProperty(
vFed2, h.HELICS_PROPERTY_INT_CONSOLE_LOG_LEVEL) == -1
assert h.helicsFederateGetFlagOption(
vFed1, h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS) is True
assert h.helicsFederateGetFlagOption(
vFed2, h.HELICS_FLAG_IGNORE_TIME_MISMATCH_WARNINGS) is True
h.helicsEndpointSendMessageRaw(ept1, "e2", "test1".encode())
h.helicsFederateRequestTimeAsync(vFed1, 1.9)
gtime = h.helicsFederateRequestTimeComplete(vFed2)
assert gtime >= 1.1 # the message should show up at the next available time point after the impact window
h.helicsFederateRequestTimeAsync(vFed2, 2.0)
gtime = h.helicsFederateRequestTimeComplete(vFed1)
assert gtime >= 1.9
tres = h.helicsFederateGetTimeProperty(vFed1,
h.HELICS_PROPERTY_TIME_PERIOD)
assert tres == 0.1
# m = h.helicsEndpointGetMessage(ept1)
# @show h.helicsMessageGetRawData(m)
# TODO: null pointer received from C
gtime = h.helicsFederateRequestTimeComplete(vFed2)
assert gtime == 2.0
h.helicsFederateFinalize(vFed1)
h.helicsFederateFinalize(vFed2)
destroyFederate(vFed1, fedinfo1)
destroyFederate(vFed2, fedinfo2)
destroyBroker(broker)
