def write_model_inputs(scenario_directory, scenario_id, subscenarios, subproblem, stage, conn):
"""
Get inputs from database and write out the model input .tab files.
:param scenario_directory: string, the scenario directory
:param subscenarios: SubScenarios object with all subscenario info
:param subproblem:
:param stage:
:param conn: database connection
:return:
"""
c = conn.cursor()
# Load in the required prm type modules
required_prm_type_modules = get_required_prm_type_modules(
c=c,
project_portfolio_scenario_id
=subscenarios.PROJECT_PORTFOLIO_SCENARIO_ID,
project_prm_zone_scenario_id=subscenarios.PROJECT_PRM_ZONE_SCENARIO_ID,
project_elcc_chars_scenario_id
=subscenarios.PROJECT_ELCC_CHARS_SCENARIO_ID
)
imported_prm_modules = \
load_prm_type_modules(required_prm_type_modules)
# Write module-specific inputs
for prm_m in required_prm_type_modules:
if hasattr(imported_prm_modules[prm_m],
"write_module_specific_model_inputs"):
imported_prm_modules[prm_m]. \
write_module_specific_model_inputs(
scenario_directory, scenario_id, subscenarios, subproblem, stage, conn)
else:
pass
def load_model_data(m, d, data_portal, scenario_directory, subproblem, stage):
"""
:param m:
:param d:
:param data_portal:
:param scenario_directory:
:param subproblem:
:param stage:
:return:
"""
project_df = pd.read_csv(
os.path.join(scenario_directory, str(subproblem), str(stage),
"inputs", "projects.tab"),
sep="\t",
usecols=["project", "prm_type"]
)
required_prm_modules = [
prm_type for prm_type in project_df.prm_type.unique() if
prm_type != "."
]
imported_prm_modules = load_prm_type_modules(required_prm_modules)
for prm_m in required_prm_modules:
if hasattr(imported_prm_modules[prm_m],
"load_module_specific_data"):
imported_prm_modules[prm_m].load_module_specific_data(
m, data_portal, scenario_directory, subproblem, stage)
else:
pass
def validate_inputs(scenario_id, subscenarios, subproblem, stage, conn):
"""
Get inputs from database and validate the inputs
:param subscenarios: SubScenarios object with all subscenario info
:param subproblem:
:param stage:
:param conn: database connection
:return:
"""
# Load in the required prm type modules
c = conn.cursor()
required_prm_type_modules = get_required_prm_type_modules(
c=c,
project_portfolio_scenario_id
=subscenarios.PROJECT_PORTFOLIO_SCENARIO_ID,
project_prm_zone_scenario_id=subscenarios.PROJECT_PRM_ZONE_SCENARIO_ID,
project_elcc_chars_scenario_id
=subscenarios.PROJECT_ELCC_CHARS_SCENARIO_ID
)
imported_prm_modules = \
load_prm_type_modules(required_prm_type_modules)
# Validate module-specific inputs
for prm_m in required_prm_type_modules:
if hasattr(imported_prm_modules[prm_m],
"validate_module_specific_inputs"):
imported_prm_modules[prm_m]. \
validate_module_specific_inputs(
scenario_id, subscenarios, subproblem, stage, conn)
else:
pass
def add_model_components(m, d, scenario_directory, subproblem, stage):
"""
:param m:
:param d:
:return:
"""
m.PRM_COST_GROUPS = Set(
initialize=lambda mod: join_sets(mod, getattr(d, prm_cost_group_sets)))
def group_prm_type_init(mod, group):
"""
Figure out the PRM type of each group
:param mod:
:param group:
:return:
"""
for group_set in getattr(d, prm_cost_group_sets):
for element in getattr(mod, group_set):
if element == group:
return getattr(d, prm_cost_group_prm_type)[group_set]
m.group_prm_type = Param(
m.PRM_COST_GROUPS,
within=["energy_only_allowed"],
initialize=lambda mod, g: group_prm_type_init(mod, g),
)
# Import all possible PRM modules
project_df = pd.read_csv(
os.path.join(scenario_directory, str(subproblem), str(stage), "inputs",
"projects.tab"),
sep="\t",
usecols=["project", "prm_type"],
)
required_prm_modules = [
prm_type for prm_type in project_df.prm_type.unique()
if prm_type != "."
]
imported_prm_modules = load_prm_type_modules(required_prm_modules)
# For each PRM project type, get the group costs
def group_cost_rule(mod, group, p):
prm_type = mod.group_prm_type[group]
return imported_prm_modules[prm_type].group_cost_rule(mod, group, p)
m.PRM_Group_Costs = Expression(m.PRM_COST_GROUPS,
m.PERIODS,
rule=group_cost_rule)
def import_results_into_database(
scenario_id, subproblem, stage, c, db, results_directory, quiet
):
"""
:param scenario_id:
:param c:
:param db:
:param results_directory:
:param quiet:
:return:
"""
(project_portfolio_scenario_id, project_prm_zone_scenario_id,
project_elcc_chars_scenario_id) = c.execute("""
SELECT project_portfolio_scenario_id, project_prm_zone_scenario_id,
project_elcc_chars_scenario_id
FROM scenarios
WHERE scenario_id = {}
""".format(scenario_id)
).fetchone()
# Required modules are the unique set of generator PRM types in
# the scenario's portfolio
# This list will be used to know which PRM type modules to load
required_prm_type_modules = get_required_prm_type_modules(
c=c,
project_portfolio_scenario_id=project_portfolio_scenario_id,
project_prm_zone_scenario_id=project_prm_zone_scenario_id,
project_elcc_chars_scenario_id=project_elcc_chars_scenario_id
)
# Import module-specific results
# Load in the required operational modules
imported_prm_modules = \
load_prm_type_modules(required_prm_type_modules)
for prm_m in required_prm_type_modules:
if hasattr(imported_prm_modules[prm_m],
"import_module_specific_results_into_database"):
imported_prm_modules[prm_m]. \
import_module_specific_results_into_database(
scenario_id, subproblem, stage, c, db, results_directory, quiet
)
else:
pass
def export_results(scenario_directory, subproblem, stage, m, d):
"""
Export operations results.
:param scenario_directory:
:param subproblem:
:param stage:
:param m:
The Pyomo abstract model
:param d:
Dynamic components
:return:
Nothing
"""
# Export module-specific results
# Operational type modules
project_df = pd.read_csv(
os.path.join(scenario_directory, str(subproblem), str(stage), "inputs",
"projects.tab"),
sep="\t",
usecols=["project", "prm_type"],
)
required_prm_modules = [
prm_type for prm_type in project_df.prm_type.unique()
if prm_type != "."
]
imported_prm_modules = load_prm_type_modules(required_prm_modules)
for prm_m in required_prm_modules:
if hasattr(imported_prm_modules[prm_m], "export_results"):
imported_prm_modules[prm_m].export_results(
m,
d,
scenario_directory,
subproblem,
stage,
)
else:
pass
def add_model_components(m, d, scenario_directory, subproblem, stage):
"""
:param m:
:param d:
:return:
"""
# Import needed PRM modules
project_df = pd.read_csv(
os.path.join(scenario_directory, str(subproblem), str(stage),
"inputs", "projects.tab"),
sep="\t",
usecols=["project", "prm_type"]
)
required_prm_modules = [
prm_type for prm_type in project_df.prm_type.unique() if
prm_type != "."
]
imported_prm_modules = load_prm_type_modules(required_prm_modules)
# Add any components specific to the PRM modules
for prm_m in required_prm_modules:
imp_prm_m = imported_prm_modules[prm_m]
if hasattr(imp_prm_m, "add_model_components"):
imp_prm_m.add_model_components(m, d, scenario_directory, subproblem, stage)
# For each PRM project, get the ELCC-eligible capacity
def elcc_eligible_capacity_rule(mod, g, p):
prm_type = mod.prm_type[g]
return imported_prm_modules[prm_type]. \
elcc_eligible_capacity_rule(mod, g, p)
m.ELCC_Eligible_Capacity_MW = Expression(
m.PRM_PRJ_OPR_PRDS,
rule=elcc_eligible_capacity_rule
)
def process_results(db, c, scenario_id, subscenarios, quiet):
"""
:param db:
:param c:
:param subscenarios:
:param quiet:
:return:
"""
# Required modules are the unique set of generator PRM types in
# the scenario's portfolio
# This list will be used to know which PRM type modules to load
required_prm_type_modules = get_required_prm_type_modules(
c=c,
project_portfolio_scenario_id
=subscenarios.PROJECT_PORTFOLIO_SCENARIO_ID,
project_prm_zone_scenario_id=subscenarios.PROJECT_PRM_ZONE_SCENARIO_ID,
project_elcc_chars_scenario_id
=subscenarios.PROJECT_ELCC_CHARS_SCENARIO_ID
)
# Import module-specific results
# Load in the required operational modules
imported_prm_modules = \
load_prm_type_modules(required_prm_type_modules)
for prm_m in required_prm_type_modules:
if hasattr(imported_prm_modules[prm_m],
"process_module_specific_results"):
imported_prm_modules[prm_m]. \
process_module_specific_results(
db=db, c=c, scenario_id=scenario_id,
subscenarios=subscenarios, quiet=quiet
)
else:
pass
