def test_bad_input_tests_raw_tests(): broker = createBroker(1) vFed1, fedinfo = createValueFederate(1, "test") pubid = h.helicsFederateRegisterPublication(vFed1, "pub1", h.HELICS_DATA_TYPE_RAW, "") subid = h.helicsFederateRegisterGlobalInput(vFed1, "inp1", h.HELICS_DATA_TYPE_RAW, "") h.helicsPublicationAddTarget(pubid, "inp1") h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0) h.helicsFederateEnterExecutingMode(vFed1) h.helicsPublicationPublishRaw(pubid, b"hello world") h.helicsFederateRequestNextStep(vFed1) s = h.helicsInputGetRawValue(subid) assert s == b"hello world" h.helicsPublicationPublishDouble(pubid, 27) h.helicsFederateRequestNextStep(vFed1) s = h.helicsInputGetComplex(subid) assert complex(*s) != 27 + 0j h.helicsFederateFinalize(vFed1) t, res = h.helicsFederateRequestTimeIterative( vFed1, 1.0, h.HELICS_ITERATION_REQUEST_NO_ITERATION) assert res == h.HELICS_ITERATION_RESULT_HALTED destroyFederate(vFed1, fedinfo) destroyBroker(broker)
def request_time_increment(self): error = sum( [abs(x[0] - x[1]) for k, x in self._subscription_dState.items()]) r_seconds = self._dss_solver.GetTotalSeconds( ) #- self._dss_solver.GetStepResolutionSeconds() if not self._settings.helics.iterative_mode: while self.c_seconds < r_seconds: self.c_seconds = helics.helicsFederateRequestTime( self._PyDSSfederate, r_seconds) self._logger.info('Time requested: {} - time granted: {} '.format( r_seconds, self.c_seconds)) return True, self.c_seconds else: self.c_seconds, iteration_state = helics.helicsFederateRequestTimeIterative( self._PyDSSfederate, r_seconds, helics.helics_iteration_request_iterate_if_needed) self._logger.info( 'Time requested: {} - time granted: {} error: {} it: {}'. format(r_seconds, self.c_seconds, error, self.itr)) if error > -1 and self.itr < self._co_convergance_max_iterations - 1: self.itr += 1 return False, self.c_seconds else: self.itr = 0 return True, self.c_seconds
def request_time_increment(self): error = sum([ abs(y["dStates"][0] - y["dStates"][1]) for k, x in self.Subscriptions.items() for y in x ]) r_seconds = self.Solver.GetTotalSeconds() if not self.settings['helics']['coiter_mode']: while self.c_seconds < r_seconds: self.c_seconds = h.helicsFederateRequestTime( self.cymeFederate, r_seconds) self.__Logger.info('Time requested: {} - time granted: {} '.format( r_seconds, self.c_seconds)) return True, self.c_seconds else: self.c_seconds, iteration_state = h.helicsFederateRequestTimeIterative( self.cymeFederate, r_seconds, h.helics_iteration_request_iterate_if_needed) self.__Logger.info( 'Time requested: {} - time granted: {} error: {} it: {}'. format(r_seconds, self.c_seconds, error, self.itr)) if error > -1 and self.itr < self.settings['helics']["max_coiter"]: self.itr += 1 return False, self.c_seconds else: self.itr = 0 return True, self.c_seconds
basevolt = 2.40 X = 20.0 currenttime = 0 for t in range(0, 25): time_requested = t * 60 * 60 iteration_state = h.helics_iteration_result_iterating for i in range(5): if i == 0: while currenttime < time_requested: currenttime = h.helicsFederateRequestTime(vfed, time_requested) else: currenttime, iteration_state = h.helicsFederateRequestTimeIterative( vfed, time_requested, h.helics_iteration_request_force_iteration #helics_iteration_request_force_iteration, helics_iteration_request_iterate_if_needed ) A = 200 + random.random() * X B = 100 + random.random() * X C = 400 + random.random() * X D = 350 + random.random() * X h.helicsPublicationPublishDouble(pubA, A) h.helicsPublicationPublishDouble(pubB, B) h.helicsPublicationPublishDouble(pubC, C) h.helicsPublicationPublishDouble(pubD, D) print(f"Powers published: {A}, {B}, {C}, {D}") value1 = h.helicsInputGetDouble(sub1) value2 = h.helicsInputGetDouble(sub2) print("PSS/E voltages: bus 153 {} p.u., bus 154 {} p.u.".format(value1, value2)) print(f"Current time: {time_requested}, Granted time: {currenttime}")
def run_p1uhs_federate(fed_name, broker_address=None): fedinitstring = "--federates=1" if broker_address is not None: fedinitstring = f"{fedinitstring} --broker_address=tcp://{broker_address}" deltat = 0.01 print(f"{fed_name}: Helics version = {h.helicsGetVersion()}") # Create Federate Info object that describes the federate properties # fedinfo = h.helicsCreateFederateInfo() # Set Federate name # h.helicsFederateInfoSetCoreName(fedinfo, fed_name) # Set core type from string # h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string # h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # Set the message interval (timedelta) for federate. Note th# # HELICS minimum message time interval is 1 ns and by default # it uses a time delta of 1 second. What is provided to the # setTimedelta routine is a multiplier for the default timedelta. # Set one second message interval # h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat) # Create value federate # vfed = h.helicsCreateValueFederate(fed_name, fedinfo) print("Value federate created") # Register the publications # pub_name = "Circuit.feeder_p1u.{fed_name}.p1ux.TotalPower.E" pub_load = h.helicsFederateRegisterGlobalTypePublication( vfed, pub_name, "double", "kW") print(f"{fed_name}: publication {pub_name} registered") # Register subscriptions # # subscribe to voltage supplied sub_name = f"Circuit.feeder_p1u.{fed_name}.p1ux.voltage" sub_voltage = h.helicsFederateRegisterSubscription(vfed, sub_name, "pu") # subscribe to reiteration flag # sub_flag = h.helicsFederateRegisterSubscription(vfed, "reiterate_flag", None) # h.helicsFederateSetIntegerProperty(vfed, h.helics_property_int_max_iterations, 10) # Enter execution mode # h.helicsFederateEnterExecutingMode(vfed) # fed_iteration_state = h.helicsFederateEnterExecutingModeIterative(vfed, h.helics_iteration_request_iterate_if_needed) print(f"{fed_name}: Entering execution mode") # start execution loop # desiredtime = 0.0 t = 0.0 end_time = 24 * 3600 # 95*15*60 while desiredtime <= end_time: # check time desiredtime = t * 15 * 60 currenttime = h.helicsFederateRequestTime(vfed, desiredtime) if currenttime >= desiredtime: # reiterate until convergence last_voltage = 1.0 iters = 1 iteration_state = h.helics_iteration_result_iterating while iteration_state == h.helics_iteration_result_iterating: supply_voltage, load = pub_and_sub_calc( sub_voltage, pub_load, iters) currenttime, iteration_state = h.helicsFederateRequestTimeIterative( vfed, desiredtime, h.helics_iteration_request_iterate_if_needed) if abs(last_voltage - supply_voltage) < 1e-20: iteration_state = -1 iters += 1 last_voltage = supply_voltage logging.info( "p1uhs0 load {} with voltage {} at time {} after {} iters". format(load, supply_voltage, currenttime, iters)) t += 1 # all other federates should have finished, so now you can close h.helicsFederateFinalize(vfed) print(f"{fed_name}: Test Federate finalized") h.helicsFederateDestroy(vfed) print(f"{fed_name}: test federate destroyed") h.helicsFederateFree(vfed) print(f"{fed_name}: federate freed") h.helicsCloseLibrary() print(f"{fed_name}: library closed")
def run_p1u_federate(fed_name, broker_address, feeders): fedinitstring = "--federates=1" if broker_address is not None: fedinitstring = f"{fedinitstring} --broker_address=tcp://{broker_address}" deltat = 0.01 print(f"{fed_name}: Helics version = {h.helicsGetVersion()}") # Create Federate Info object that describes the federate properties fedinfo = h.helicsCreateFederateInfo() # Set Federate name h.helicsFederateInfoSetCoreName(fedinfo, fed_name) # Set core type from string h.helicsFederateInfoSetCoreTypeFromString(fedinfo, "zmq") # Federate init string h.helicsFederateInfoSetCoreInitString(fedinfo, fedinitstring) # Set one second message interval h.helicsFederateInfoSetTimeProperty(fedinfo, h.helics_property_time_delta, deltat) # Create value federate vfed = h.helicsCreateValueFederate(fed_name, fedinfo) print("Value federate created") # Register the publications pub_load = h.helicsFederateRegisterGlobalTypePublication( vfed, "Circuit.full_network.TotalPower.E", "double", "kW" ) pub_voltages = [] for feeder in feeders: pub_name = f"Circuit.feeder_p1u.{feeder}.p1ux.voltage" pub_voltages.append( h.helicsFederateRegisterGlobalTypePublication( vfed, pub_name, "double", "pu" ) ) print(f"{fed_name}: publication {pub_name} registered") # Register subscriptions # subscribe to voltage supplied sub_voltage = h.helicsFederateRegisterSubscription( vfed, "full_network.voltage", "pu" ) h.helicsInputSetDefaultDouble(sub_voltage, 1.0) # subscribe to loads below sub_loads = [] for feeder in feeders: sub_name = f"Circuit.feeder_p1u.{feeder}.p1ux.TotalPower.E" sub_loads.append(h.helicsFederateRegisterSubscription(vfed, sub_name, "kW")) print(f"{fed_name}: subscription {sub_name} registered") h.helicsFederateSetIntegerProperty(vfed, h.helics_property_int_max_iterations, 10) # Enter execution mode h.helicsFederateEnterExecutingMode(vfed) print(f"{fed_name} Entering executing mode") # start execution loop n_feeders = len(feeders) desiredtime = 0.0 t = 0.0 end_time = 24 * 3600 while desiredtime <= end_time: # check time desiredtime = t * 15 * 60 currenttime = h.helicsFederateRequestTime(vfed, desiredtime) if currenttime >= desiredtime: last_loads = [0 for i in range(0, n_feeders)] # reiterate between supply voltage and loads for up to __ iterations # get supply voltage iters = 1 supply_voltage = h.helicsInputGetDouble(sub_voltage) iteration_state = h.helics_iteration_result_iterating while iteration_state == h.helics_iteration_result_iterating: # if there is an iteration going on, publish and subscribe again new_loads = pub_and_sub_calc( supply_voltage, last_loads, sub_loads, pub_voltages ) currenttime, iteration_state = h.helicsFederateRequestTimeIterative( vfed, desiredtime, h.helics_iteration_request_iterate_if_needed ) # find change in load and determine if you need to continue iterating load_diff = 0 for i in range(n_feeders): load_diff = load_diff + abs(new_loads[i] - last_loads[i]) if load_diff / n_feeders < 1e-3: iteration_state = 0 last_loads = new_loads iters += 1 h.helicsPublicationPublishDouble(pub_load, sum(last_loads)) logger.info( "feeder loads {last_loads} at time {currenttime} after {iters} iters" ) t += 1 # all other federates should have finished, so now you can close h.helicsFederateFinalize(vfed) print(f"{fed_name}: Test Federate finalized") h.helicsFederateDestroy(vfed) print(f"{fed_name}: test federate destroyed") h.helicsFederateFree(vfed) print(f"{fed_name}: federate freed") h.helicsCloseLibrary() print(f"{fed_name}: library closed")
def test_iteration_async_test(): broker = createBroker(1) vFed1, fedinfo1 = createValueFederate(1, "fed0") vFed2, fedinfo2 = createValueFederate(1, "fed1") # register the publications pub1 = h.helicsFederateRegisterGlobalPublication(vFed1, "pub1", h.HELICS_DATA_TYPE_INT) sub1 = h.helicsFederateRegisterSubscription(vFed2, "pub1") pub2 = h.helicsFederateRegisterGlobalPublication(vFed2, "pub2", h.HELICS_DATA_TYPE_INT) sub2 = h.helicsFederateRegisterSubscription(vFed1, "pub2") h.helicsFederateSetTimeProperty(vFed1, h.HELICS_PROPERTY_TIME_PERIOD, 1.0) h.helicsFederateSetTimeProperty(vFed2, h.HELICS_PROPERTY_TIME_PERIOD, 1.0) # vFed1->setLoggingLevel(5) # vFed2->setLoggingLevel(5) h.helicsFederateEnterInitializingModeAsync(vFed1) h.helicsFederateEnterInitializingMode(vFed2) h.helicsFederateEnterInitializingModeComplete(vFed1) c1 = 0 c2 = 0 h.helicsPublicationPublishInteger(pub1, c1) h.helicsPublicationPublishInteger(pub2, c2) h.helicsFederateEnterExecutingModeAsync(vFed1) h.helicsFederateEnterExecutingMode(vFed2) h.helicsFederateEnterExecutingModeComplete(vFed1) while c1 <= 10: h.helicsInputGetInteger(sub1), c1 h.helicsInputGetInteger(sub2), c2 c1 += 1 c2 += 1 if c1 <= 10: h.helicsPublicationPublishInteger(pub1, c1) h.helicsPublicationPublishInteger(pub2, c2) h.helicsFederateRequestTimeIterativeAsync( vFed1, 1.0, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED) grantedTime, state = h.helicsFederateRequestTimeIterative( vFed2, 1.0, h.HELICS_ITERATION_REQUEST_ITERATE_IF_NEEDED) if c1 <= 10: # assert state == h.HELICS_ITERATION_RESULT_ITERATING assert grantedTime == 0.0 else: # assert state == h.HELICS_ITERATION_RESULT_NEXT_STEP assert grantedTime == 1.0 grantedTime, state = h.helicsFederateRequestTimeIterativeComplete( vFed1) if c1 <= 10: # assert state == h.HELICS_ITERATION_RESULT_ITERATING assert grantedTime == 0.0 # assert state == h.HELICS_ITERATION_RESULT_NEXT_STEP # assert grantedTime == 1.0 destroyFederate(vFed1, fedinfo1) destroyFederate(vFed2, fedinfo2) destroyBroker(broker)