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