def run():
## Operation process for UEMS
logger = Logger('Universal_ems_main') # The logger system has been started
db_str = db_configuration.universal_database["db_str"] # Database format
engine = create_engine(db_str, echo=False) # Create engine for universal energy management system databases
Session = sessionmaker(bind=engine) # Create engine for target database
session_uems = Session() # Create session for universal energy management system
# IP = "10.25.196.56"
IP = "*"
# Start the information connection
context = zmq.Context()
socket = context.socket(zmq.REP)
socket.bind("tcp://" + IP + ":5555")
socket_upload = context.socket(zmq.REP) # Upload information channel for local EMS
socket_upload.bind("tcp://" + IP + ":5556")
socket_download = context.socket(zmq.REQ) # Download information channel for local EMS
socket_download.bind("tcp://" + IP + ":5557")
initialize = Main(socket)
universal_models = initialize.universal_models
local_models = initialize.local_models
# Start the input information
info_ed = economic_dispatch_info.local_sources() # Dynamic information for economic dispatch
info_uc = economic_dispatch_info.local_sources() # Dynamic information for unit commitment
info_opf = opf_model.informaiton_exchange() # Optimal power flow modelling
# Generate different processes
logger.info("The short term process in UEMS starts!")
sched_short_term = BlockingScheduler() # The schedulor for the optimal power flow
sched_short_term.add_job(short_term_operation.short_term_operation_uems, 'cron',
args=(universal_models, local_models, socket_upload, socket_download, info_opf,
session_uems), minute='0-59',
second='1') # The operation is triggered minutely, this process will start at **:01
sched_short_term.start()
logger.info("The middle term process in UEMS starts!")
sched_middle_term = BlockingScheduler() # The schedulor for the optimal power flow
sched_middle_term.add_job(middle_term_operation.middle_term_operation_uems, 'cron',
args=(universal_models, local_models, socket_upload, socket_download, info_ed,
session_uems), minute='*/5',
second='1') # The operation is triggered every 5 minute
sched_middle_term.start()
short_term_operation.short_term_operation_uems(universal_models, local_models, socket_upload, socket_download, info_opf,
session_uems)
logger.info("The long term process in UEMS starts!")
sched_long_term = BlockingScheduler() # The schedulor for the optimal power flow
sched_long_term.add_job(long_term_operation.long_term_operation_uems, 'cron',
args=(universal_models, local_models, socket_upload, socket_download, info_uc,
session_uems), minute='*/30',
second='1') # The operation is triggered every half an hour
sched_long_term.start()
def run():
# Define the local models
(local_model_short, local_model_middle,
local_model_long) = start_up_lems.start_up_lems.start_up()
# Convert local information to sharable information
static_info = static_information.static_information_generation(
local_model_short)
# Set the database information
db_str = db_configuration.local_database["db_str"]
engine = create_engine(db_str, echo=False)
Session = sessionmaker(bind=engine)
session_lems_short = Session()
session_lems_middle = Session()
session_lems_long = Session()
# Start the information connection
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:5555")
socket_upload = context.socket(zmq.REQ)
socket_upload.connect("tcp://localhost:5556")
socket_upload_ed = context.socket(zmq.REQ)
socket_upload_ed.connect("tcp://localhost:5557")
socket_upload_uc = context.socket(zmq.REQ)
socket_upload_uc.connect("tcp://localhost:5558")
socket_download = context.socket(zmq.REP)
socket_download.connect("tcp://localhost:5559")
while True:
socket.send(b"ConnectionRequest")
message = socket.recv()
if message == b"Start!":
logger.info(
"The connection between the local EMS and universal EMS establishes!"
)
break
else:
logger.error(
"Waiting for the connection between the local EMS and universal EMS!"
)
information_receive_send.information_send(socket, static_info, 2)
info_ed = economic_dispatch_info.local_sources()
info_uc = economic_dispatch_info.local_sources(
) # The information model in the
info_opf = opf_model.informaiton_exchange(
) # The optimal power flow modelling
# By short-term operation process
logger.info("The short-term process in local ems starts!")
sched_lems = BlockingScheduler(
) # The schedulor for the optimal power flow
sched_lems.add_job(lambda: short_term_operation.short_term_operation_lems(
local_model_short, socket_upload, socket_download, info_opf,
session_lems_short),
'cron',
minute='0-59',
second='1') # The operation is triggered minutely
logger.info("The middle-term process in local EMS starts!")
sched_lems.add_job(
lambda: middle_term_operation.middle_term_operation_lems(
local_model_middle, socket_upload_ed, socket_download, info_ed,
session_lems_middle),
'cron',
minute='*/5',
second='5') # The operation is triggered every five minute
logger.info("The long term process in local EMS starts!")
sched_lems.add_job(
lambda: long_term_operation.long_term_operation_lems(
local_model_long, socket_upload_uc, socket_download, info_uc,
session_lems_long),
'cron',
minute='*/30',
second='30') # The operation is triggered every half an hour
sched_lems.start()
def info_formulation(*args):
from configuration.configuration_time_line import default_look_ahead_time_step
from modelling import dynamic_operation_pb2
model = args[0]
Target_time = args[1]
Type = args[2]
dynamic_model = dynamic_operation_pb2.local_sources()
if Type == "UC":
T = default_look_ahead_time_step["Look_ahead_time_uc_time_step"]
else:
T = default_look_ahead_time_step["Look_ahead_time_ed_time_step"]
# 1) Initial dynamic model
dynamic_info = dynamic_model
#################################The information structure
ug_info = dynamic_model.DgType()
dg_info = dynamic_model.DgType()
ess_info = dynamic_model.EssType()
pv_info = dynamic_model.PvType()
wp_info = dynamic_model.WpType()
load_ac_info = dynamic_model.Load_AC_Type()
load_dc_info = dynamic_model.Load_DC_Type()
load_uac_info = dynamic_model.Load_AC_Type()
load_udc_info = dynamic_model.Load_DC_Type()
bic_info = dynamic_model.Convertor_Type()
# Obtain information from the external systems
dynamic_info.AREA = model["UG"]["AREA"]
dynamic_info.TIME_STAMP = Target_time
# Update utility grid information
ug_info.ID = 0
if type(model["UG"]["GEN_STATUS"]) is list:
if len(model["UG"]["GEN_STATUS"]) != T:
ug_info.GEN_STATUS.extend(model["UG"]["GEN_STATUS"] * T)
else:
ug_info.GEN_STATUS.extend(model["UG"]["GEN_STATUS"])
elif type(model["UG"]["GEN_STATUS"]) is int:
ug_info.GEN_STATUS.extend([model["UG"]["GEN_STATUS"]] * T)
if type(model["UG"]["COMMAND_PG"]) is list:
ug_info.PG.extend(model["UG"]["COMMAND_PG"])
else:
ug_info.PG.extend([model["UG"]["COMMAND_PG"]])
if type(model["UG"]["COMMAND_RG"]) is list:
ug_info.RG.extend(model["UG"]["COMMAND_RG"])
else:
ug_info.RG.extend([model["UG"]["COMMAND_RG"]])
if type(model["UG"]["COMMAND_START_UP"]) is list:
ug_info.COMMAND_STATUS.extend(model["UG"]["COMMAND_START_UP"])
else:
ug_info.COMMAND_STATUS.extend([model["UG"]["COMMAND_START_UP"]])
# Update dg part information
dg_info.ID = 1
if type(model["DG"]["GEN_STATUS"]) is list:
if len(model["DG"]["GEN_STATUS"]) != T:
dg_info.GEN_STATUS.extend(model["DG"]["GEN_STATUS"] * T)
else:
dg_info.GEN_STATUS.extend(model["DG"]["GEN_STATUS"])
elif type(model["UG"]["GEN_STATUS"]) is int:
dg_info.GEN_STATUS.extend([model["UG"]["GEN_STATUS"]] * T)
if type(model["DG"]["COMMAND_PG"]) is list:
dg_info.PG.extend(model["DG"]["COMMAND_PG"])
else:
dg_info.PG.extend([model["DG"]["COMMAND_PG"]])
if type(model["DG"]["COMMAND_RG"]) is list:
dg_info.RG.extend(model["DG"]["COMMAND_RG"])
else:
dg_info.RG.extend([model["DG"]["COMMAND_RG"]])
if type(model["DG"]["COMMAND_START_UP"]) is list:
dg_info.COMMAND_STATUS.extend(model["DG"]["COMMAND_START_UP"])
else:
dg_info.COMMAND_STATUS.extend([model["DG"]["COMMAND_START_UP"]])
dynamic_info.dg.extend([ug_info, dg_info])
# Update ess part information
ess_info.ID = 1
ess_info.ESS_STATUS.extend([1]*T)
if type(model["ESS"]["SOC"]) is list:
ess_info.SOC.extend(model["ESS"]["SOC"])
else:
ess_info.SOC.extend([model["ESS"]["SOC"]])
if type(model["ESS"]["COMMAND_PG"]) is list:
ess_info.PG.extend(model["ESS"]["COMMAND_PG"])
else:
ess_info.PG.extend([model["ESS"]["COMMAND_PG"]])
if type(model["ESS"]["COMMAND_RG"]) is list:
ess_info.RG.extend(model["ESS"]["COMMAND_RG"])
else:
ess_info.RG.extend([model["ESS"]["COMMAND_RG"]])
dynamic_info.ess.extend([ess_info])
# Update pv part information
pv_info.PG.extend(model["PV"]["PG"])
if type(model["PV"]["COMMAND_CURT"]) is list:
pv_info.COMMAND_CURT.extend(model["PV"]["COMMAND_CURT"])
else:
pv_info.COMMAND_CURT.extend([model["PV"]["COMMAND_CURT"]])
dynamic_info.pv.extend([pv_info])
# Update wp part information
wp_info.PG.extend(model["WP"]["PG"])
if type(model["WP"]["COMMAND_CURT"]) is list:
wp_info.COMMAND_CURT.extend(model["WP"]["COMMAND_CURT"])
else:
wp_info.COMMAND_CURT.extend([model["WP"]["COMMAND_CURT"]])
dynamic_info.wp.extend([wp_info])
# Update load_ac part information
load_ac_info.PD.extend(model["Load_ac"]["PD"])
if type(model["Load_ac"]["COMMAND_SHED"]) is list:
load_ac_info.COMMAND_SHED.extend(model["Load_ac"]["COMMAND_SHED"])
else:
load_ac_info.COMMAND_SHED.extend([model["Load_ac"]["COMMAND_SHED"]])
load_uac_info.PD.extend(model["Load_uac"]["PD"])
if type(model["Load_uac"]["COMMAND_SHED"]) is list:
load_uac_info.COMMAND_SHED.extend(model["Load_uac"]["COMMAND_SHED"])
else:
load_uac_info.COMMAND_SHED.extend([model["Load_uac"]["COMMAND_SHED"]])
dynamic_info.load_ac.extend([load_ac_info, load_uac_info])
# Update load_dc part information
load_dc_info.PD.extend(model["Load_dc"]["PD"])
if type(model["Load_dc"]["COMMAND_SHED"]) is list:
load_dc_info.COMMAND_SHED.extend(model["Load_dc"]["COMMAND_SHED"])
else:
load_dc_info.COMMAND_SHED.extend([model["Load_dc"]["COMMAND_SHED"]])
load_udc_info.PD.extend(model["Load_udc"]["PD"])
if type(model["Load_udc"]["COMMAND_SHED"]) is list:
load_udc_info.COMMAND_SHED.extend(model["Load_udc"]["COMMAND_SHED"])
else:
load_udc_info.COMMAND_SHED.extend([model["Load_udc"]["COMMAND_SHED"]])
dynamic_info.load_dc.extend([load_dc_info, load_udc_info])
# Update convertor part information
bic_info.STATUS.extend([1]*T)
if type(model["BIC"]["COMMAND_AC2DC"]) is list:
bic_info.PAC2DC.extend(model["BIC"]["COMMAND_AC2DC"])
else:
bic_info.PAC2DC.extend([model["BIC"]["COMMAND_AC2DC"]])
if type(model["BIC"]["COMMAND_DC2AC"]) is list:
bic_info.PDC2AC.extend(model["BIC"]["COMMAND_DC2AC"])
else:
bic_info.PDC2AC.extend([model["BIC"]["COMMAND_DC2AC"]])
dynamic_info.bic.extend([bic_info])
if type(model["PMG"]) is list:
dynamic_info.PMG.extend(model["PMG"])
else:
dynamic_info.PMG.extend([model["PMG"]])
dynamic_info.COMMAND_TYPE = model["COMMAND_TYPE"]
dynamic_info.TIME_STAMP_COMMAND = Target_time
return dynamic_info
def run():
# Define the local models
local_models = {
"DG": generators.Generator_AC.copy(),
"UG": generators.Generator_AC.copy(),
"Load_ac": loads.Load_AC.copy(),
"Load_uac": loads.Load_AC.copy(),
"BIC": convertors.BIC.copy(),
"ESS": energy_storage_systems.BESS.copy(),
"PV": generators.Generator_RES.copy(),
"WP": generators.Generator_RES.copy(),
"Load_dc": loads.Load_DC.copy(),
"Load_udc": loads.Load_DC.copy(),
"PMG": 0,
"VDC": 0
}
# Update the local parameters
local_models["UG"]["GEN_STATUS"] = 0
local_models["WP"]["GEN_STATUS"] = 0
local_models["Load_ac"]["FLEX"] = 0
local_models["Load_uac"]["FLEX"] = 1
local_models["Load_dc"]["FLEX"] = 0
local_models["Load_udc"]["FLEX"] = 1
# Convert local information to sharable information
static_info = static_information.static_information_generation(
local_models)
# Set the database information
db_str = db_configuration.local_database["db_str"]
engine = create_engine(db_str, echo=False)
Session = sessionmaker(bind=engine)
session_lems = Session()
# Start the information connection
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:5555")
socket_upload = context.socket(zmq.REQ)
socket_upload.connect("tcp://localhost:5556")
socket_download = context.socket(zmq.REP)
socket_download.connect("tcp://localhost:5557")
while True:
socket.send(b"ConnectionRequest")
message = socket.recv()
if message == b"Start!":
logger.info(
"The connection between the local EMS and universal EMS establishes!"
)
break
else:
logger.error(
"Waiting for the connection between the local EMS and universal EMS!"
)
information_receive_send.information_send(socket, static_info, 2)
info_ed = economic_dispatch_info.local_sources()
info_uc = economic_dispatch_info.local_sources(
) # The information model in the
info_opf = opf_model.informaiton_exchange(
) # The optimal power flow modelling
# By short-term operation process
logger.info("The short-term process in local ems starts!")
sched_short_term = BlockingScheduler(
) # The schedulor for the optimal power flow
sched_short_term.add_job(
lambda: short_term_operation.short_term_operation_lems(
local_models, socket_upload, socket_download, info_opf,
session_lems),
'cron',
minute='0-59',
second='1') # The operation is triggered minutely
sched_short_term.start()
short_term_operation.short_term_operation_lems(local_models, socket_upload,
socket_download, info_opf,
session_lems)
logger.info("The middle-term process in local EMS starts!")
sched_middle_term = BlockingScheduler(
) # The schedulor for the optimal power flow
sched_middle_term.add_job(
lambda: middle_term_operation.middle_term_operation_lems(
local_models, socket_upload, socket_download, info_ed, session_lems
),
'cron',
minute='*/5',
second='1') # The operation is triggered every five minute
sched_middle_term.start()
logger.info("The long term process in local EMS starts!")
sched_long_term = BlockingScheduler(
) # The schedulor for the optimal power flow
sched_long_term.add_job(
lambda: long_term_operation.long_term_operation_lems(
local_models, socket_upload, socket_download, info_uc, session_lems
),
'cron',
minute='*/30',
second='1') # The operation is triggered every half an hour
sched_long_term.start()