def main(args=None):
"""
:return:
"""
if args is None:
args = sys.argv[1:]
parsed_arguments = parse_arguments(args=args)
db_path = parsed_arguments.database
scenario_id_arg = parsed_arguments.scenario_id
scenario_name_arg = parsed_arguments.scenario
scenario_location = parsed_arguments.scenario_location
conn = connect_to_database(db_path=db_path)
c = conn.cursor()
if not parsed_arguments.quiet:
print("Processing results... (connected to database {})".format(db_path))
scenario_id, scenario_name = get_scenario_id_and_name(
scenario_id_arg=scenario_id_arg,
scenario_name_arg=scenario_name_arg,
c=c,
script="process_results",
)
# Determine scenario directory
scenario_directory = determine_scenario_directory(
scenario_location=scenario_location, scenario_name=scenario_name
)
# Go through modules
modules_to_use = determine_modules(scenario_directory=scenario_directory)
loaded_modules = load_modules(modules_to_use)
# Subscenarios
subscenarios = SubScenarios(conn=conn, scenario_id=scenario_id)
process_results(
loaded_modules=loaded_modules,
db=conn,
cursor=c,
scenario_id=scenario_id,
subscenarios=subscenarios,
quiet=parsed_arguments.quiet,
)
# Close the database connection
conn.close()
def main(args=None):
"""
:return:
"""
# Retrieve DB location and scenario_id and/or name from args
if args is None:
args = sys.argv[1:]
parsed_arguments = parse_arguments(args=args)
db_path = parsed_arguments.database
scenario_id_arg = parsed_arguments.scenario_id
scenario_name_arg = parsed_arguments.scenario
scenario_location = parsed_arguments.scenario_location
conn = connect_to_database(db_path=db_path)
c = conn.cursor()
if not parsed_arguments.quiet:
print("Getting inputs... (connected to database {})".format(db_path))
scenario_id, scenario_name = get_scenario_id_and_name(
scenario_id_arg=scenario_id_arg,
scenario_name_arg=scenario_name_arg,
c=c,
script="get_scenario_inputs",
)
# Determine scenario directory and create it if needed
scenario_directory = determine_scenario_directory(
scenario_location=scenario_location, scenario_name=scenario_name)
create_directory_if_not_exists(directory=scenario_directory)
# Get scenario characteristics (features, scenario_id, subscenarios, subproblems)
# TODO: it seems these fail silently if empty; we may want to implement
# some validation
optional_features = OptionalFeatures(conn=conn, scenario_id=scenario_id)
subscenarios = SubScenarios(conn=conn, scenario_id=scenario_id)
subproblem_structure = get_subproblem_structure_from_db(
conn=conn, scenario_id=scenario_id)
solver_options = SolverOptions(conn=conn, scenario_id=scenario_id)
# Determine requested features and use this to determine what modules to
# load for Gridpath
feature_list = optional_features.get_active_features()
# If any subproblem's stage list is non-empty, we have stages, so set
# the stages_flag to True to pass to determine_modules below
# This tells the determine_modules function to include the
# stages-related modules
stages_flag = any([
len(subproblem_structure.SUBPROBLEM_STAGES[subp]) > 1
for subp in list(subproblem_structure.SUBPROBLEM_STAGES.keys())
])
# Figure out which modules to use and load the modules
modules_to_use = determine_modules(features=feature_list,
multi_stage=stages_flag)
# Get appropriate inputs from database and write the .tab file model inputs
write_model_inputs(
scenario_directory=scenario_directory,
subproblem_structure=subproblem_structure,
modules_to_use=modules_to_use,
scenario_id=scenario_id,
subscenarios=subscenarios,
db_path=db_path,
n_parallel_subproblems=int(parsed_arguments.n_parallel_get_inputs),
)
# Save the list of optional features to a file (will be used to determine
# modules without database connection)
write_features_csv(scenario_directory=scenario_directory,
feature_list=feature_list)
# Write full scenario description
write_scenario_description(
scenario_directory=scenario_directory,
scenario_id=scenario_id,
scenario_name=scenario_name,
optional_features=optional_features,
subscenarios=subscenarios,
)
# Write the units used for all metrics
write_units_csv(scenario_directory, conn)
# Write the solver options file if needed
write_solver_options(scenario_directory=scenario_directory,
solver_options=solver_options)
# Write the subproblem linked timepoints map file if needed
write_linked_subproblems_map(scenario_directory, conn, subscenarios)
# Close the database connection
conn.close()
def main(args=None):
"""
:return:
"""
# Retrieve scenario_id and/or name from args + "quiet" flag
if args is None:
args = sys.argv[1:]
parsed_arguments = parse_arguments(args=args)
if not parsed_arguments.quiet:
print("Validating inputs...")
db_path = parsed_arguments.database
scenario_id_arg = parsed_arguments.scenario_id
scenario_name_arg = parsed_arguments.scenario
conn = connect_to_database(db_path=db_path,
detect_types=sqlite3.PARSE_DECLTYPES)
c = conn.cursor()
scenario_id, scenario_name = get_scenario_id_and_name(
scenario_id_arg=scenario_id_arg,
scenario_name_arg=scenario_name_arg,
c=c,
script="validate_inputs")
# Reset input validation status and results
reset_input_validation(conn, scenario_id)
# TODO: this is very similar to what's in get_scenario_inputs.py,
# so we should consolidate
# Get scenario characteristics (features, scenario_id, subscenarios, subproblems)
optional_features = OptionalFeatures(conn=conn, scenario_id=scenario_id)
subscenarios = SubScenarios(conn=conn, scenario_id=scenario_id)
subproblems = SubProblems(conn=conn, scenario_id=scenario_id)
# Check whether subscenario_ids are valid
is_valid = validate_subscenario_ids(scenario_id, subscenarios,
optional_features, conn)
# Only do the detailed input validation if all required subscenario_ids
# are specified (otherwise will get errors when loading data)
if is_valid:
# Load modules for all requested features
feature_list = optional_features.get_active_features()
# If any subproblem's stage list is non-empty, we have stages, so set
# the stages_flag to True to pass to determine_modules below
# This tells the determine_modules function to include the
# stages-related modules
stages_flag = any([
len(subproblems.SUBPROBLEM_STAGE_DICT[subp]) > 1
for subp in subproblems.SUBPROBLEM_STAGE_DICT.keys()
])
modules_to_use = determine_modules(features=feature_list,
multi_stage=stages_flag)
loaded_modules = load_modules(modules_to_use=modules_to_use)
# Read in inputs from db and validate inputs for loaded modules
validate_inputs(subproblems, loaded_modules, scenario_id, subscenarios,
conn)
else:
if not parsed_arguments.quiet:
print(
"Invalid subscenario ID(s). Skipped detailed input validation."
)
# Update validation status:
update_validation_status(conn, scenario_id)
# Close the database connection explicitly
conn.close()