def test_value_federate_runFederateTestComplex(vFed): rDefaultValue = 1.0 iDefaultValue = 1.0 rTestValue = 2.0 iTestValue = 2.0 pubid = h.helicsFederateRegisterGlobalTypePublication( vFed, "pub1", h.HELICS_DATA_TYPE_COMPLEX, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "double", "") h.helicsSubscriptionSetDefaultComplex(subid, rDefaultValue, iDefaultValue) h.helicsFederateEnterExecutionMode(vFed) # publish string1 at time=0.0; h.helicsPublicationPublishComplex(pubid, rTestValue, iTestValue) status, value1, value2 = h.helicsSubscriptionGetComplex(subid) assert value1 == rDefaultValue assert value2 == iDefaultValue status, grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 status, value1, value2 = h.helicsSubscriptionGetComplex(subid) assert value1 == rTestValue assert value2 == iTestValue
def test_value_federate_runFederateTestInteger(vFed): defaultValue = 1 testValue = 2 pubid = h.helicsFederateRegisterGlobalTypePublication( vFed, "pub1", h.HELICS_DATA_TYPE_INT, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "int", "") h.helicsSubscriptionSetDefaultInteger(subid, defaultValue) h.helicsFederateEnterExecutionMode(vFed) h.helicsPublicationPublishInteger(pubid, testValue) status, value = h.helicsSubscriptionGetInteger(subid) assert value == defaultValue status, grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 status, value = h.helicsSubscriptionGetInteger(subid) assert value == testValue h.helicsPublicationPublishInteger(pubid, testValue + 1) status, grantedtime = h.helicsFederateRequestTime(vFed, 2.0) assert grantedtime == 0.02 status, value = h.helicsSubscriptionGetInteger(subid) assert value == testValue + 1
def test_message_federate_endpoint_registration(mFed): epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", None) epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random") h.helicsFederateSetTimeDelta(mFed, 1.0) h.helicsFederateEnterExecutionMode(mFed) data = "random-data" status = h.helicsEndpointSendEventRaw(epid1, "ep2", data, 1.0) status, granted_time = h.helicsFederateRequestTime(mFed, 1.0) assert granted_time == 1.0 res = h.helicsFederateHasMessage(mFed) assert res == 1 res = h.helicsEndpointHasMessage(epid1) # TODO: Figure out why this is returning zero assert res == 0 res = h.helicsEndpointHasMessage (epid2) assert res == 1 # This causes a segfault message = h.helicsEndpointGetMessage(epid2) assert message.data == 'random-data' assert message.length == 11 assert message.original_dest == '' assert message.original_source == 'TestA Federate/ep1' assert message.source == 'TestA Federate/ep1' assert message.time == 1.0
def test_value_federate_runFederateTestDouble(vFed): defaultValue = 1.0 testValue = 2.0 pubid = h.helicsFederateRegisterGlobalTypePublication( vFed, "pub1", h.HELICS_DATA_TYPE_DOUBLE, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "double", "") h.helicsSubscriptionSetDefaultDouble(subid, defaultValue) h.helicsFederateEnterExecutionMode(vFed) # publish string1 at time=0.0; h.helicsPublicationPublishDouble(pubid, testValue) status, value = h.helicsSubscriptionGetDouble(subid) assert value == defaultValue status, grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 status, value = h.helicsSubscriptionGetDouble(subid) assert value == testValue # publish string1 at time=0.0; h.helicsPublicationPublishDouble(pubid, testValue + 1) status, grantedtime = h.helicsFederateRequestTime(vFed, 2.0) assert grantedtime == 0.02 status, value = h.helicsSubscriptionGetDouble(subid) assert value == testValue + 1
def main(delay=None): broker = create_broker() fed = create_value_federate(broker) pubid = h.helicsFederateRegisterGlobalTypePublication( fed, "federate1-to-federate2", h.HELICS_DATA_TYPE_STRING, "") subid = h.helicsFederateRegisterSubscription(fed, "federate2-to-federate1", "double", "") epid = h.helicsFederateRegisterGlobalEndpoint(fed, "endpoint1", "") if delay is not None: fid = h.helicsFederateRegisterSourceFilter(fed, h.helics_delay_filter, "endpoint2", "filter-name") h.helicsSubscriptionSetDefaultDouble(subid, 0) print("Entering execution mode") h.helicsFederateEnterExecutionMode(fed) if delay is not None: h.helicsFilterSet(fid, "delay", 2.0) grantedtime = -1 while True: try: stop_at_time, value_to_send = get_input(grantedtime) except KeyboardInterrupt: print("") break while grantedtime < stop_at_time: print(">>>>>>>> Requesting time = {}".format(stop_at_time)) status, grantedtime = h.helicsFederateRequestTime( fed, stop_at_time) assert status == 0 if grantedtime != stop_at_time: status, value = h.helicsSubscriptionGetString(subid) assert status == 0 print("Interrupt value '{}' from Federate 2".format(value)) print("<<<<<<<< Granted Time = {}".format(grantedtime)) assert grantedtime == stop_at_time, "stop_at_time = {}, grantedtime = {}".format( stop_at_time, grantedtime) if value_to_send is not None and value_to_send != '': print("Sending '{}' to Federate 2".format(value_to_send)) status = h.helicsPublicationPublishString(pubid, str(value_to_send)) assert status == 0 status = h.helicsEndpointSendMessageRaw(epid, "endpoint2", str(value_to_send)) assert status == 0 status, value = h.helicsSubscriptionGetString(subid) assert status == 0 print("Received value '{}' from Federate 2".format(value)) while h.helicsEndpointHasMessage(epid): value = h.helicsEndpointGetMessage(epid) print("Received message '{}' at time {} from Federate 2".format( value.data, value.time)) print("----------------------------------") destroy_value_federate(fed, broker)
def test_value_federate_subscription_registration(vFed): subid1 = h.helicsFederateRegisterSubscription(vFed, "sub1", "double", "V") subid2 = h.helicsFederateRegisterTypeSubscription(vFed, "sub2", h.HELICS_DATA_TYPE_INT, "") subid3 = h.helicsFederateRegisterOptionalSubscription( vFed, "sub3", "double", "V") h.helicsFederateEnterExecutionMode(vFed)
def test_message_federate_initialize(mFed): status, state = h.helicsFederateGetState(mFed) assert state == 0 h.helicsFederateEnterExecutionMode(mFed) status, state = h.helicsFederateGetState(mFed) assert state == 2
def test_value_federate_publisher_registration(vFed): pubid1 = h.helicsFederateRegisterTypePublication(vFed, "pub1", h.HELICS_DATA_TYPE_STRING, "") pubid2 = h.helicsFederateRegisterGlobalTypePublication( vFed, "pub2", h.HELICS_DATA_TYPE_INT, "") pubid3 = h.helicsFederateRegisterTypePublication(vFed, "pub3", h.HELICS_DATA_TYPE_DOUBLE, "V") h.helicsFederateEnterExecutionMode(vFed)
def main(delay=None, verbose=False): if verbose is not False: logger.setLevel(logging.DEBUG) logger.info("Creating MockFederate for FESTIV") fed = create_federate() pubid1 = h.helicsFederateRegisterGlobalTypePublication( fed, "AGCGenDispatch/Alta", h.HELICS_DATA_TYPE_COMPLEX, "") pubid2 = h.helicsFederateRegisterGlobalTypePublication( fed, "AGCGenDispatch/Brighton", h.HELICS_DATA_TYPE_COMPLEX, "") pubid3 = h.helicsFederateRegisterGlobalTypePublication( fed, "AGCGenDispatch/ParkCity", h.HELICS_DATA_TYPE_COMPLEX, "") pubid4 = h.helicsFederateRegisterGlobalTypePublication( fed, "AGCGenDispatch/Solitude", h.HELICS_DATA_TYPE_COMPLEX, "") pubid5 = h.helicsFederateRegisterGlobalTypePublication( fed, "AGCGenDispatch/Sundance", h.HELICS_DATA_TYPE_COMPLEX, "") h.helicsFederateEnterExecutionMode(fed) time_granted = -1 ticker = 0 for day in [ '2020-08-03', '2020-08-04', '2020-08-05', '2020-08-06', '2020-08-07', '2020-08-08', '2020-08-09', ]: for interval in range(0, int(24 * 60 / 5)): for minute in range(0, 5): for second in range(0, 60): ticker = ticker + 1 if int(second % 6) == 0: stop_at_time = ticker while time_granted < stop_at_time: status, time_granted = h.helicsFederateRequestTime( fed, stop_at_time) logger.info( "time granted = {}".format(time_granted)) destroy_federate(fed)
def test_value_federate_single_transfer(vFed): pubid = h.helicsFederateRegisterGlobalTypePublication( vFed, "pub1", h.HELICS_DATA_TYPE_STRING, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "string", "") h.helicsFederateEnterExecutionMode(vFed) h.helicsPublicationPublishString(pubid, "string1") status, grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 status, s = h.helicsSubscriptionGetString(subid) assert status == 0 assert s == "string1"
def test_message_federate_endpoint_registration(mFed): epid1 = h.helicsFederateRegisterEndpoint(mFed, "ep1", None) epid2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "ep2", "random") h.helicsFederateEnterExecutionMode(mFed) status, endpoint_name = h.helicsEndpointGetName(epid1, 100) assert status == 0 assert endpoint_name == "TestA Federate/ep1" status, endpoint_name = h.helicsEndpointGetName(epid2, 100) assert status == 0 assert endpoint_name == "ep2" status, endpoint_name = h.helicsEndpointGetType(epid1, 100) assert status == 0 assert endpoint_name == "" status, endpoint_name = h.helicsEndpointGetType(epid2, 100) assert status == 0 assert endpoint_name == "random"
def test_value_federate_publication_registration(vFed): pubid1 = h.helicsFederateRegisterPublication(vFed, "pub1", "string", "") pubid2 = h.helicsFederateRegisterGlobalPublication(vFed, "pub2", "int", "") pubid3 = h.helicsFederateRegisterPublication(vFed, "pub3", "double", "V") h.helicsFederateEnterExecutionMode(vFed) status, publication_key = h.helicsPublicationGetKey(pubid1) assert status == 0 assert publication_key == 'TestA Federate/pub1' status, publication_key = h.helicsPublicationGetKey(pubid2) assert status == 0 assert publication_key == 'pub2' status, publication_key = h.helicsPublicationGetKey(pubid3) assert status == 0 assert publication_key == 'TestA Federate/pub3' status, publication_type = h.helicsPublicationGetType(pubid3) assert status == 0 assert publication_type == 'double' status, publication_units = h.helicsPublicationGetUnits(pubid3) assert status == 0 assert publication_units == 'V'
def test_value_federate_runFederateTestVectorD(vFed): defaultValue = [0, 1, 2] testValue = [3, 4, 5] pubid = h.helicsFederateRegisterGlobalTypePublication( vFed, "pub1", h.HELICS_DATA_TYPE_VECTOR, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "vector", "") h.helicsSubscriptionSetDefaultVector(subid, defaultValue) h.helicsFederateEnterExecutionMode(vFed) # TODO: Fix error with the following function h.helicsPublicationPublishVector(pubid, testValue) status, value = h.helicsSubscriptionGetVector(subid) assert value == [0, 1, 2] status, grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 status, value = h.helicsSubscriptionGetVector(subid) assert value == [3, 4, 5]
def test_value_federate_runFederateTestString(vFed): defaultValue = "String1" testValue = "String2" pubid = h.helicsFederateRegisterGlobalTypePublication( vFed, "pub1", h.HELICS_DATA_TYPE_STRING, "") subid = h.helicsFederateRegisterSubscription(vFed, "pub1", "string", "") h.helicsSubscriptionSetDefaultString(subid, defaultValue) h.helicsFederateEnterExecutionMode(vFed) # TODO: Fix error with the following function h.helicsPublicationPublishString(pubid, testValue) status, value = h.helicsSubscriptionGetString(subid) assert value == defaultValue status, grantedtime = h.helicsFederateRequestTime(vFed, 1.0) assert grantedtime == 0.01 status, value = h.helicsSubscriptionGetString(subid) assert value == testValue
def main(): # broker = create_broker() fed = create_federate() pubid = h.helicsFederateRegisterGlobalTypePublication( fed, "TransmissionSim/B2Voltage", h.HELICS_DATA_TYPE_COMPLEX, "") subid = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B2_G_1/totalLoad", "complex", "") epid = h.helicsFederateRegisterEndpoint(fed, "ep1", None) h.helicsSubscriptionSetDefaultComplex(subid, 0, 0) h.helicsFederateEnterExecutionMode(fed) hours = 1 seconds = int(60 * 60 * hours) grantedtime = -1 random.seed(0) for t in range(0, seconds, 60 * 5): c = complex(132790.562, 0) * (1 + (random.random() - 0.5) / 2) logger.info("Voltage value = {} kV".format(abs(c) / 1000)) status = h.helicsPublicationPublishComplex(pubid, c.real, c.imag) # status = h.helicsEndpointSendEventRaw(epid, "fixed_price", 10, t) while grantedtime < t: status, grantedtime = h.helicsFederateRequestTime(fed, t) time.sleep(1) status, rValue, iValue = h.helicsSubscriptionGetComplex(subid) logger.info("Python Federate grantedtime = {}".format(grantedtime)) logger.info("Load value = {} MW".format( complex(rValue, iValue) / 1000)) t = 60 * 60 * 24 while grantedtime < t: status, grantedtime = h.helicsFederateRequestTime(fed, t) logger.info("Destroying federate") destroy_federate(fed)
def setup(self, ID): """ID needs to be a list that contains all the T&D interface nodes.""" try: # read solar mapping self.solarData=np.genfromtxt(dirName+'/data/solar_diffusion_map.csv',\ delimiter=',') self.ID = ID # set up comm with helics self.fi = fi = h.helicsFederateInfoCreate() # create info obj status = h.helicsFederateInfoSetFederateName(fi, "pyPflow") status = h.helicsFederateInfoSetCoreTypeFromString(fi, "zmq") status = h.helicsFederateInfoSetCoreInitString(fi, "--federates=1") status = h.helicsFederateInfoSetTimeDelta( fi, 300) # 5 min dispatch interval status = h.helicsFederateInfoSetLoggingLevel(fi, 1) self.vf = vf = h.helicsCreateValueFederate(fi) self.pub = pub = h.helicsFederateRegisterGlobalPublication( vf, "adaptive_volt_var", "string", "") self.sub = sub = {} for entry in ID: # subscribe to all IDs sub['pyGld_' + str(entry)] = h.helicsFederateRegisterSubscription( vf, 'pyGld_' + str(entry), "string", "") status = h.helicsFederateEnterExecutionMode(vf) # Read schema f = open(dirName + '/data/schema_case9.json') self.data = eval(f.read()) f.close() # add V in schema for all subscriptions for entry in ID: self.data['mpc']['get']['V'].append([entry, 0, 0]) # run initial PFLOW (base case condition as read from .m file) self.socket.send_string(json.dumps( self.data)) # send instructions to pflow self.msgFromPflow = eval( self.socket.recv()) # receive data from pflow except: PrintException()
def test_message_filter_function(broker): fFed = AddFederate(broker, "zmq", 1, 1, "filter") mFed = AddFederate(broker, "zmq", 1, 1, "message") p1 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port1", "") p2 = h.helicsFederateRegisterGlobalEndpoint(mFed, "port2", "") f1 = h.helicsFederateRegisterSourceFilter(fFed, h.helics_delay_filter, "port1", "filter1") status = h.helicsFilterSet(f1, "delay", 2.5) assert status == 0 status = h.helicsFederateEnterExecutionModeAsync(fFed) assert status == 0 status = h.helicsFederateEnterExecutionMode(mFed) assert status == 0 status = h.helicsFederateEnterExecutionModeComplete(fFed) assert status == 0 status, state = h.helicsFederateGetState(fFed) assert status == 0 assert state == 2 data = "hello world" h.helicsEndpointSendMessageRaw(p1, "port2", data) grantedtime = h.helicsFederateRequestTimeAsync(mFed, 1.0) assert grantedtime == 0 status, grantedtime = h.helicsFederateRequestTime(fFed, 1.0) assert status == 0 assert grantedtime == 1.0 status, grantedtime = h.helicsFederateRequestTimeComplete(mFed) assert status == 0 assert grantedtime == 1.0 h.helicsFederateFinalize(mFed) h.helicsFederateFinalize(fFed) #f2 = h.helicsFederateRegisterDestinationFilter (fFed, h.helics_custom_filter, "filter2", "port2") #ep1 = h.helicsFederateRegisterEndpoint (fFed, "fout", "") #f3 = h.helicsFederateRegisterSourceFilter (fFed, h.helics_custom_filter, "", "filter0/fout") FreeFederate(fFed) FreeFederate(mFed) time.sleep(1.0)
def setup(self, fedName='pyGld', portNum=12000, ID=5): try: fedName += '_' + str(ID) self.fedName = fedName # setup helics self.fi = fi = h.helicsFederateInfoCreate() # create info obj status = h.helicsFederateInfoSetFederateName(fi, fedName) status = h.helicsFederateInfoSetCoreTypeFromString(fi, "zmq") status = h.helicsFederateInfoSetCoreInitString(fi, "--federates=1") status = h.helicsFederateInfoSetTimeDelta( fi, 300) # 5 min dispatch interval self.vf = vf = h.helicsCreateValueFederate(fi) self.pub = h.helicsFederateRegisterGlobalPublication( vf, fedName, "string", "") self.sub = h.helicsFederateRegisterSubscription( vf, "adaptive_volt_var", "string", "") status = h.helicsFederateEnterExecutionMode(vf) # setup worker self.pyGldWorker.setup(portNum=portNum, ID=ID) except: PrintException()
def main(): fed = create_federate() pubid1 = h.helicsFederateRegisterGlobalTypePublication( fed, "GenOutput/Alta", h.HELICS_DATA_TYPE_COMPLEX, "") pubid2 = h.helicsFederateRegisterGlobalTypePublication( fed, "GenOutput/Brighton", h.HELICS_DATA_TYPE_COMPLEX, "") pubid3 = h.helicsFederateRegisterGlobalTypePublication( fed, "GenOutput/ParkCity", h.HELICS_DATA_TYPE_COMPLEX, "") pubid4 = h.helicsFederateRegisterGlobalTypePublication( fed, "GenOutput/Solitude", h.HELICS_DATA_TYPE_COMPLEX, "") pubid5 = h.helicsFederateRegisterGlobalTypePublication( fed, "GenOutput/Sundance", h.HELICS_DATA_TYPE_COMPLEX, "") subid1 = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B4_G_1/totalLoad", "complex", "") subid2 = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B4_R_1_2/totalLoad", "complex", "") subid3 = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B4_R_1_1/totalLoad", "complex", "") subid4 = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B3_R_3_4/totalLoad", "complex", "") subid5 = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B3_R_3_3/totalLoad", "complex", "") subid6 = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B3_R_3_2/totalLoad", "complex", "") subid7 = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B3_R_3_1/totalLoad", "complex", "") subid8 = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B2_G_1/totalLoad", "complex", "") subid9 = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B2_R_2_3/totalLoad", "complex", "") subid10 = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B2_R_2_2/totalLoad", "complex", "") subid11 = h.helicsFederateRegisterSubscription( fed, "DistributionSim_B2_R_2_1/totalLoad", "complex", "") subid12 = h.helicsFederateRegisterSubscription( fed, "MarketSim/AGCGenDispatch/Alta", "double", "") subid13 = h.helicsFederateRegisterSubscription( fed, "MarketSim/AGCGenDispatch/Brighton", "double", "") subid14 = h.helicsFederateRegisterSubscription( fed, "MarketSim/AGCGenDispatch/ParkCity", "double", "") subid15 = h.helicsFederateRegisterSubscription( fed, "MarketSim/AGCGenDispatch/Solitude", "double", "") subid16 = h.helicsFederateRegisterSubscription( fed, "MarketSim/AGCGenDispatch/Sundance", "double", "") h.helicsFederateEnterExecutionMode(fed) hours = 1 seconds = int(60 * 60 * hours) grantedtime = -1 random.seed(0) for t in range(0, seconds, 60 * 5): status, value = h.helicsSubscriptionGetDouble(subid12) c = complex(value, 0) status = h.helicsPublicationPublishComplex(pubid1, c.real, c.imag) status, value = h.helicsSubscriptionGetDouble(subid13) c = complex(value, 0) status = h.helicsPublicationPublishComplex(pubid2, c.real, c.imag) status, value = h.helicsSubscriptionGetDouble(subid14) c = complex(value, 0) status = h.helicsPublicationPublishComplex(pubid3, c.real, c.imag) status, value = h.helicsSubscriptionGetDouble(subid15) c = complex(value, 0) status = h.helicsPublicationPublishComplex(pubid4, c.real, c.imag) status, value = h.helicsSubscriptionGetDouble(subid16) c = complex(value, 0) status = h.helicsPublicationPublishComplex(pubid5, c.real, c.imag) # status = h.helicsEndpointSendEventRaw(epid, "fixed_price", 10, t) while grantedtime < t: status, grantedtime = h.helicsFederateRequestTime(fed, t) time.sleep(1) logger.info("Python Federate grantedtime = {}".format(grantedtime)) t = 60 * 60 * 24 while grantedtime < t: status, grantedtime = h.helicsFederateRequestTime(fed, t) logger.info("Destroying federate") destroy_federate(fed)
# Set one second message interval # status = h.helicsFederateInfoSetTimeDelta(fedinfo, deltat) status = h.helicsFederateInfoSetLoggingLevel(fedinfo, 1) # Create value federate # vfed = h.helicsCreateValueFederate(fedinfo) print("PI SENDER: Value federate created") # Register the publication # pub = h.helicsFederateRegisterGlobalPublication(vfed, "testA", "double", "") print("PI SENDER: Publication registered") # Enter execution mode # status = h.helicsFederateEnterExecutionMode(vfed) print("PI SENDER: Entering execution mode") # This federate will be publishing deltat*pi for numsteps steps # this_time = 0.0 value = pi for t in range(5, 10): val = value currenttime = h.helicsFederateRequestTime(vfed, t) status = h.helicsPublicationPublishDouble(pub, val) print("PI SENDER: Sending value pi = {} at time {} to PI RECEIVER".format( val, currenttime[-1]))
print ('open case: ' + case) open_case_return_code = pslf.core.load_case(case) print("Open Save Case Code: {}".format(open_case_return_code)) #Register the helics here. This example will publish bus voltage (complex type) at bus 225 in PSLF to gridlabd, #and get the total load from gridlabd, modify the total load (complex value) to the load at bus 225 in PSLF. #NOTE that currently PSLF does not support any optimal power flow staff, so we could not publish the price from PSLF to gridlabd fed_address = "tcp://130.20.153.157" broker_address = "tcp://130.20.24.180" initstring = "--federates=1 --broker_address={broker_address} --interface={fed_address}".format(broker_address=broker_address, fed_address=fed_address) fed = create_federate(deltat=1.0, fedinitstring=initstring) pubid = h.helicsFederateRegisterGlobalTypePublication (fed, "TransmissionSim/B2Voltage", h.HELICS_DATA_TYPE_COMPLEX, "") subid = h.helicsFederateRegisterSubscription (fed, "DistributionSim_B2_G_1/totalLoad", "complex", "") h.helicsSubscriptionSetDefaultComplex(subid, 1.00, 0.0) h.helicsFederateEnterExecutionMode(fed) #NOTE that currently PSLF does not support any optimal power flow staff, so we could not publish the price from PSLF to gridlabd #so we do not need to register the endpoint (epid = h.helicsFederateRegisterEndpoint(fed, "ep1", None)) hours = 1 seconds = int(60 * 60 * hours) grantedtime = -1 print(seconds) for itimestep in range(0, seconds, 60 * 5): #for itimestep in range(0, seconds): #solve power flow in pslf print("\nSolving case!\n") pslf.core.solve_case_default_parameters()
def main(delay=None, verbose=False): if verbose is not False: logger.setLevel(logging.DEBUG) mapping = create_mapping() logger.info("Creating CombinationFederate for FESTIV") fed = create_value_federate() pubid1 = h.helicsFederateRegisterGlobalTypePublication( fed, "AGCGenDispatch/Alta", h.HELICS_DATA_TYPE_COMPLEX, "") pubid2 = h.helicsFederateRegisterGlobalTypePublication( fed, "AGCGenDispatch/Brighton", h.HELICS_DATA_TYPE_COMPLEX, "") pubid3 = h.helicsFederateRegisterGlobalTypePublication( fed, "AGCGenDispatch/ParkCity", h.HELICS_DATA_TYPE_COMPLEX, "") pubid4 = h.helicsFederateRegisterGlobalTypePublication( fed, "AGCGenDispatch/Solitude", h.HELICS_DATA_TYPE_COMPLEX, "") pubid5 = h.helicsFederateRegisterGlobalTypePublication( fed, "AGCGenDispatch/Sundance", h.HELICS_DATA_TYPE_COMPLEX, "") logger.info("Registering endpoint") epid = h.helicsFederateRegisterGlobalEndpoint(fed, "festiv-fixed-price", "") if delay is not None: fedfilter = h.helicsFederateRegisterSourceFilter( fed, 1, "festiv-fixed-price", "delay_filter") status = h.helicsFilterSet(fedfilter, "delay", int(delay)) h.helicsFederateEnterExecutionMode(fed) time_granted = -1 last_second = -1 ticker = 0 for day in [ '2020-08-03', '2020-08-04', '2020-08-05', '2020-08-06', '2020-08-07', '2020-08-08', '2020-08-09', ]: logger.info("Running DAM for day={day}".format(day=day)) df = get_load(day) dam_s = df.loc[day, 'LOAD'].resample('1H').mean() dam_m = build_DAM_model(day, dam_s) dam_m.solve('cbc', verbose=False) rtm_s = df.loc[day, 'LOAD'].resample('5T').mean() for interval in range(0, int(24 * 60 / 5)): hour = int(interval * 5 / 60) logger.info( "Running RTM for day={day} for minute={m} (hour={hour})". format(day=day, m=interval * 5, hour=hour)) commitment = dam_m.results.unit_commitment.loc[hour:hour, :] rtm_m = build_RTM_model(day, rtm_s.iloc[interval], commitment) rtm_m.solve('cbc', verbose=False) logger.debug("LMP = {lmp} \t Power Generated = {pg}".format( lmp=rtm_m.results.lmp, pg=rtm_m.results.power_generated)) for minute in range(0, 5): for second in range(0, 60): ticker = ticker + 1 if int(second % 6) == 0: stop_at_time = ticker while time_granted < stop_at_time: status, time_granted = h.helicsFederateRequestTime( fed, stop_at_time) b2, b3, b4 = rtm_m.results.lmp[['B2', 'B3', 'B4']].values[0] for name in mapping["B2"]: status = h.helicsEndpointSendMessageRaw( epid, "{}/fixed_price".format(name), str(b2)) for name in mapping["B3"]: status = h.helicsEndpointSendMessageRaw( epid, "{}/fixed_price".format(name), str(b3)) for name in mapping["B4"]: status = h.helicsEndpointSendMessageRaw( epid, "{}/fixed_price".format(name), str(b4)) pg = rtm_m.results.power_generated.loc[0].to_dict() status = h.helicsPublicationPublishDouble( pubid1, pg["ALTA"]) status = h.helicsPublicationPublishDouble( pubid2, pg["BRIGHTON"]) status = h.helicsPublicationPublishDouble( pubid3, pg["PARKCITY"]) status = h.helicsPublicationPublishDouble( pubid4, pg["SOLITUDE"]) status = h.helicsPublicationPublishDouble( pubid5, pg["SUNDANCE"]) logger.info("Publishing lmp B2={}".format(b2)) logger.info("Publishing lmp B3={}".format(b2)) logger.info("Publishing lmp B4={}".format(b2)) logger.info("Publishing pg = {}".format(pg)) logger.info("Current time = {minutes} ".format( minutes=ticker / 60))