def main():
args = _parse_args()
with_xhatshuffle = args.with_xhatshuffle
with_lagrangian = args.with_lagrangian
# This is multi-stage, so we need to supply node names
hydro = PySPModel("./PySP/models/", "./PySP/nodedata/")
rho_setter = None
# Things needed for vanilla cylinders
beans = (args, hydro.scenario_creator, hydro.scenario_denouement,
hydro.all_scenario_names)
# Vanilla PH hub
hub_dict = vanilla.ph_hub(*beans,
ph_extensions=None,
rho_setter=rho_setter,
all_nodenames=hydro.all_nodenames)
# Standard Lagrangian bound spoke
if with_lagrangian:
lagrangian_spoke = vanilla.lagrangian_spoke(
*beans, rho_setter=rho_setter, all_nodenames=hydro.all_nodenames)
if with_xhatshuffle:
xhatshuffle_spoke = vanilla.xhatshuffle_spoke(*beans,
hydro.all_nodenames)
list_of_spoke_dict = list()
if with_lagrangian:
list_of_spoke_dict.append(lagrangian_spoke)
if with_xhatshuffle:
list_of_spoke_dict.append(xhatshuffle_spoke)
wheel = WheelSpinner(hub_dict, list_of_spoke_dict)
wheel.spin()
if wheel.global_rank == 0: # we are the reporting hub rank
print(
f"BestInnerBound={wheel.BestInnerBound} and BestOuterBound={wheel.BestOuterBound}"
)
if write_solution:
wheel.write_first_stage_solution('hydro_first_stage.csv')
wheel.write_tree_solution('hydro_full_solution')
hydro.close()
def main():
args = _parse_args()
with_xhatshuffle = args.with_xhatshuffle
with_lagrangian = args.with_lagrangian
# This is multi-stage, so we need to supply node names
hydro = PySPModel("./PySP/models/", "./PySP/nodedata/")
rho_setter = None
# Things needed for vanilla cylinders
beans = (args, hydro.scenario_creator, hydro.scenario_denouement, hydro.all_scenario_names)
# Vanilla PH hub
hub_dict = vanilla.ph_hub(*beans,
ph_extensions=None,
rho_setter = rho_setter,
all_nodenames=hydro.all_nodenames)
# Standard Lagrangian bound spoke
if with_lagrangian:
lagrangian_spoke = vanilla.lagrangian_spoke(*beans,
rho_setter = rho_setter,
all_nodenames=hydro.all_nodenames)
if with_xhatshuffle:
xhatshuffle_spoke = vanilla.xhatshuffle_spoke(*beans,
hydro.all_nodenames)
list_of_spoke_dict = list()
if with_lagrangian:
list_of_spoke_dict.append(lagrangian_spoke)
if with_xhatshuffle:
list_of_spoke_dict.append(xhatshuffle_spoke)
spcomm, opt_dict = sputils.spin_the_wheel(hub_dict, list_of_spoke_dict)
if "hub_class" in opt_dict: # we are a hub rank
if spcomm.opt.cylinder_rank == 0: # we are the reporting hub rank
print("BestInnerBound={} and BestOuterBound={}".\
format(spcomm.BestInnerBound, spcomm.BestOuterBound))
if write_solution:
sputils.write_spin_the_wheel_first_stage_solution(spcomm, opt_dict, 'hydro_first_stage.csv')
sputils.write_spin_the_wheel_tree_solution(spcomm, opt_dict, 'hydro_full_solution')
hydro.close()
def main():
args = _parse_args()
inst = args.instance_name
num_scen = int(inst.split("-")[-3])
if args.num_scens is not None and args.num_scens != num_scen:
raise RuntimeError("Argument num-scens={} does not match the number "
"implied by instance name={} "
"\n(--num-scens is not needed for netdes)")
with_fwph = args.with_fwph
with_xhatlooper = args.with_xhatlooper
with_xhatshuffle = args.with_xhatshuffle
with_lagrangian = args.with_lagrangian
with_slamup = args.with_slamup
with_cross_scenario_cuts = args.with_cross_scenario_cuts
if args.default_rho is None:
raise RuntimeError("The --default-rho option must be specified")
path = f"{netdes.__file__[:-10]}/data/{inst}.dat"
scenario_creator = netdes.scenario_creator
scenario_denouement = netdes.scenario_denouement
all_scenario_names = [f"Scen{i}" for i in range(num_scen)]
scenario_creator_kwargs = {"path": path}
# Things needed for vanilla cylinders
beans = (args, scenario_creator, scenario_denouement, all_scenario_names)
if with_cross_scenario_cuts:
ph_ext = CrossScenarioExtension
else:
ph_ext = None
# Vanilla PH hub
hub_dict = vanilla.ph_hub(*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
ph_extensions=ph_ext,
rho_setter=None)
if with_cross_scenario_cuts:
hub_dict["opt_kwargs"]["PHoptions"]["cross_scen_options"]\
= {"check_bound_improve_iterations" : args.cross_scenario_iter_cnt}
# FWPH spoke
if with_fwph:
fw_spoke = vanilla.fwph_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# Standard Lagrangian bound spoke
if with_lagrangian:
lagrangian_spoke = vanilla.lagrangian_spoke(
*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
rho_setter=None)
# xhat looper bound spoke
if with_xhatlooper:
xhatlooper_spoke = vanilla.xhatlooper_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# xhat shuffle bound spoke
if with_xhatshuffle:
xhatshuffle_spoke = vanilla.xhatshuffle_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# slam up bound spoke
if with_slamup:
slamup_spoke = vanilla.slamup_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# cross scenario cut spoke
if with_cross_scenario_cuts:
cross_scenario_cut_spoke = vanilla.cross_scenario_cut_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
list_of_spoke_dict = list()
if with_fwph:
list_of_spoke_dict.append(fw_spoke)
if with_lagrangian:
list_of_spoke_dict.append(lagrangian_spoke)
if with_xhatlooper:
list_of_spoke_dict.append(xhatlooper_spoke)
if with_xhatshuffle:
list_of_spoke_dict.append(xhatshuffle_spoke)
if with_slamup:
list_of_spoke_dict.append(slamup_spoke)
if with_cross_scenario_cuts:
list_of_spoke_dict.append(cross_scenario_cut_spoke)
spin_the_wheel(hub_dict, list_of_spoke_dict)
def main():
args = _parse_args()
num_scen = args.num_scens
with_fwph = args.with_fwph
with_xhatlooper = args.with_xhatlooper
with_xhatshuffle = args.with_xhatshuffle
with_lagrangian = args.with_lagrangian
with_fixer = args.with_fixer
fixer_tol = args.fixer_tol
if num_scen not in (3, 10):
raise RuntimeError(f"num_scen must the 3 or 10; was {num_scen}")
scenario_creator_kwargs = {"scenario_count": num_scen}
scenario_creator = sizes.scenario_creator
scenario_denouement = sizes.scenario_denouement
all_scenario_names = [f"Scenario{i+1}" for i in range(num_scen)]
rho_setter = sizes._rho_setter
variable_probability = sizes._variable_probability
if with_fixer:
ph_ext = Fixer
else:
ph_ext = None
# Things needed for vanilla cylinders
beans = (args, scenario_creator, scenario_denouement, all_scenario_names)
# Vanilla PH hub
hub_dict = vanilla.ph_hub(*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
ph_extensions=ph_ext,
rho_setter=rho_setter,
variable_probability=variable_probability)
if with_fixer:
hub_dict["opt_kwargs"]["PHoptions"]["fixeroptions"] = {
"verbose": False,
"boundtol": fixer_tol,
"id_fix_list_fct": sizes.id_fix_list_fct,
}
if args.default_rho is None:
# since we are using a rho_setter anyway
hub_dict.opt_kwargs.PHoptions["defaultPHrho"] = 1
# FWPH spoke
if with_fwph:
fw_spoke = vanilla.fwph_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# Standard Lagrangian bound spoke
if with_lagrangian:
lagrangian_spoke = vanilla.lagrangian_spoke(
*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
rho_setter=rho_setter)
# xhat looper bound spoke
if with_xhatlooper:
xhatlooper_spoke = vanilla.xhatlooper_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# xhat shuffle bound spoke
if with_xhatshuffle:
xhatshuffle_spoke = vanilla.xhatshuffle_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
list_of_spoke_dict = list()
if with_fwph:
list_of_spoke_dict.append(fw_spoke)
if with_lagrangian:
list_of_spoke_dict.append(lagrangian_spoke)
if with_xhatlooper:
list_of_spoke_dict.append(xhatlooper_spoke)
if with_xhatshuffle:
list_of_spoke_dict.append(xhatshuffle_spoke)
spin_the_wheel(hub_dict, list_of_spoke_dict)
def main():
args = _parse_args()
num_scen = args.num_scens
with_fwph = args.with_fwph
with_xhatlooper = args.with_xhatlooper
with_xhatshuffle = args.with_xhatshuffle
with_lagrangian = args.with_lagrangian
with_fixer = args.with_fixer
fixer_tol = args.fixer_tol
with_cross_scenario_cuts = args.with_cross_scenario_cuts
scensavail = [3, 5, 10, 25, 50, 100]
if num_scen not in scensavail:
raise RuntimeError("num-scen was {}, but must be in {}".\
format(num_scen, scensavail))
scenario_creator_kwargs = {
"scenario_count": num_scen,
"path": str(num_scen) + "scenarios_r1",
}
scenario_creator = uc.scenario_creator
scenario_denouement = uc.scenario_denouement
all_scenario_names = [f"Scenario{i+1}" for i in range(num_scen)]
rho_setter = uc._rho_setter
# Things needed for vanilla cylinders
beans = (args, scenario_creator, scenario_denouement, all_scenario_names)
### start ph spoke ###
# Start with Vanilla PH hub
hub_dict = vanilla.ph_hub(*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
ph_extensions=MultiPHExtension,
rho_setter=rho_setter)
# Extend and/or correct the vanilla dictionary
ext_classes = [Gapper]
if with_fixer:
ext_classes.append(Fixer)
if with_cross_scenario_cuts:
ext_classes.append(CrossScenarioExtension)
if args.xhat_closest_tree:
ext_classes.append(XhatClosest)
hub_dict["opt_kwargs"]["PH_extension_kwargs"] = {
"ext_classes": ext_classes
}
if with_cross_scenario_cuts:
hub_dict["opt_kwargs"]["PHoptions"]["cross_scen_options"]\
= {"check_bound_improve_iterations" : args.cross_scenario_iter_cnt}
if with_fixer:
hub_dict["opt_kwargs"]["PHoptions"]["fixeroptions"] = {
"verbose": args.with_verbose,
"boundtol": fixer_tol,
"id_fix_list_fct": uc.id_fix_list_fct,
}
if args.xhat_closest_tree:
hub_dict["opt_kwargs"]["PHoptions"]["xhat_closest_options"] = {
"xhat_solver_options": dict(),
"keep_solution": True
}
if args.ph_mipgaps_json is not None:
with open(args.ph_mipgaps_json) as fin:
din = json.load(fin)
mipgapdict = {int(i): din[i] for i in din}
else:
mipgapdict = None
hub_dict["opt_kwargs"]["PHoptions"]["gapperoptions"] = {
"verbose": args.with_verbose,
"mipgapdict": mipgapdict
}
if args.default_rho is None:
# since we are using a rho_setter anyway
hub_dict.opt_kwargs.PHoptions["defaultPHrho"] = 1
### end ph spoke ###
# FWPH spoke
if with_fwph:
fw_spoke = vanilla.fwph_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# Standard Lagrangian bound spoke
if with_lagrangian:
lagrangian_spoke = vanilla.lagrangian_spoke(
*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
rho_setter=rho_setter)
# xhat looper bound spoke
if with_xhatlooper:
xhatlooper_spoke = vanilla.xhatlooper_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# xhat shuffle bound spoke
if with_xhatshuffle:
xhatshuffle_spoke = vanilla.xhatshuffle_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# cross scenario cut spoke
if with_cross_scenario_cuts:
cross_scenario_cut_spoke = vanilla.cross_scenario_cut_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
list_of_spoke_dict = list()
if with_fwph:
list_of_spoke_dict.append(fw_spoke)
if with_lagrangian:
list_of_spoke_dict.append(lagrangian_spoke)
if with_xhatlooper:
list_of_spoke_dict.append(xhatlooper_spoke)
if with_xhatshuffle:
list_of_spoke_dict.append(xhatshuffle_spoke)
if with_cross_scenario_cuts:
list_of_spoke_dict.append(cross_scenario_cut_spoke)
spcomm, opt_dict = spin_the_wheel(hub_dict, list_of_spoke_dict)
if args.solution_dir is not None:
uc.write_solution(spcomm, opt_dict, args.solution_dir)
def main():
args = _parse_args()
BFs = args.branching_factors
xhat_scenario_dict = make_node_scenario_dict_balanced(BFs)
all_nodenames = list(xhat_scenario_dict.keys())
with_xhatspecific = args.with_xhatspecific
with_lagrangian = args.with_lagrangian
with_xhatshuffle = args.with_xhatshuffle
# This is multi-stage, so we need to supply node names
#all_nodenames = ["ROOT"] # all trees must have this node
# The rest is a naming convention invented for this problem.
# Note that mpisppy does not have nodes at the leaves,
# and node names must end in a serial number.
ScenCount = np.prod(BFs)
#ScenCount = _get_num_leaves(BFs)
sc_options = {"args": args}
scenario_creator_kwargs = aircond.kw_creator(sc_options)
all_scenario_names = [f"scen{i}"
for i in range(ScenCount)] #Scens are 0-based
# print(all_scenario_names)
scenario_creator = aircond.scenario_creator
scenario_denouement = aircond.scenario_denouement
primal_rho_setter = aircond.primal_rho_setter
dual_rho_setter = aircond.dual_rho_setter
# Things needed for vanilla cylinders
beans = (args, scenario_creator, scenario_denouement, all_scenario_names)
# Vanilla PH hub
hub_dict = vanilla.ph_hub(*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
ph_extensions=None,
rho_setter=primal_rho_setter,
all_nodenames=all_nodenames)
# Standard Lagrangian bound spoke
if with_lagrangian:
lagrangian_spoke = vanilla.lagrangian_spoke(
*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
rho_setter=primal_rho_setter,
all_nodenames=all_nodenames)
# xhat specific bound spoke
if with_xhatspecific:
xhatspecific_spoke = vanilla.xhatspecific_spoke(
*beans,
xhat_scenario_dict,
all_nodenames=all_nodenames,
scenario_creator_kwargs=scenario_creator_kwargs)
#xhat shuffle looper bound spoke
if with_xhatshuffle:
xhatshuffle_spoke = vanilla.xhatshuffle_spoke(
*beans,
all_nodenames=all_nodenames,
scenario_creator_kwargs=scenario_creator_kwargs)
list_of_spoke_dict = list()
if with_lagrangian:
list_of_spoke_dict.append(lagrangian_spoke)
if with_xhatspecific:
list_of_spoke_dict.append(xhatspecific_spoke)
if with_xhatshuffle:
list_of_spoke_dict.append(xhatshuffle_spoke)
wheel = WheelSpinner(hub_dict, list_of_spoke_dict)
wheel.spin()
fname = 'aircond_cyl_nonants.npy'
if wheel.global_rank == 0:
print("BestInnerBound={} and BestOuterBound={}".\
format(wheel.BestInnerBound, wheel.BestOuterBound))
if write_solution:
print(f"Writing first stage solution to {fname}")
# all ranks need to participate because only the winner will write
if write_solution:
wheel.write_first_stage_solution('aircond_first_stage.csv')
wheel.write_tree_solution('aircond_full_solution')
wheel.write_first_stage_solution(
fname,
first_stage_solution_writer=first_stage_nonant_npy_serializer)
def main():
args = _parse_args()
num_scen = args.num_scens
crops_multiplier = args.crops_mult
rho_setter = farmer._rho_setter if hasattr(farmer, '_rho_setter') else None
if args.default_rho is None and rho_setter is None:
raise RuntimeError(
"No rho_setter so a default must be specified via --default-rho")
if args.use_norm_rho_converger:
if not args.use_norm_rho_updater:
raise RuntimeError(
"--use-norm-rho-converger requires --use-norm-rho-updater")
else:
ph_converger = NormRhoConverger
else:
ph_converger = None
scenario_creator = farmer.scenario_creator
scenario_denouement = farmer.scenario_denouement
all_scenario_names = ['scen{}'.format(sn) for sn in range(num_scen)]
scenario_creator_kwargs = {
'use_integer': False,
"crops_multiplier": crops_multiplier,
}
scenario_names = [f"Scenario{i+1}" for i in range(num_scen)]
# Things needed for vanilla cylinders
beans = (args, scenario_creator, scenario_denouement, all_scenario_names)
if args.run_async:
# Vanilla APH hub
hub_dict = vanilla.aph_hub(
*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
ph_extensions=None,
rho_setter=rho_setter)
else:
# Vanilla PH hub
hub_dict = vanilla.ph_hub(
*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
ph_extensions=None,
ph_converger=ph_converger,
rho_setter=rho_setter)
## hack in adaptive rho
if args.use_norm_rho_updater:
hub_dict['opt_kwargs']['extensions'] = NormRhoUpdater
hub_dict['opt_kwargs']['options']['norm_rho_options'] = {
'verbose': True
}
# FWPH spoke
if args.with_fwph:
fw_spoke = vanilla.fwph_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# Standard Lagrangian bound spoke
if args.with_lagrangian:
lagrangian_spoke = vanilla.lagrangian_spoke(
*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
rho_setter=rho_setter)
# xhat looper bound spoke
if args.with_xhatlooper:
xhatlooper_spoke = vanilla.xhatlooper_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# xhat shuffle bound spoke
if args.with_xhatshuffle:
xhatshuffle_spoke = vanilla.xhatshuffle_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
list_of_spoke_dict = list()
if args.with_fwph:
list_of_spoke_dict.append(fw_spoke)
if args.with_lagrangian:
list_of_spoke_dict.append(lagrangian_spoke)
if args.with_xhatlooper:
list_of_spoke_dict.append(xhatlooper_spoke)
if args.with_xhatshuffle:
list_of_spoke_dict.append(xhatshuffle_spoke)
wheel = WheelSpinner(hub_dict, list_of_spoke_dict)
wheel.spin()
if write_solution:
wheel.write_first_stage_solution('farmer_plant.csv')
wheel.write_first_stage_solution('farmer_cyl_nonants.npy',
first_stage_solution_writer=sputils.
first_stage_nonant_npy_serializer)
wheel.write_tree_solution('farmer_full_solution')
def main():
args = _parse_args()
inst = args.instance_name
num_scen = int(inst.split("_")[-1])
if args.num_scens is not None and args.num_scens != num_scen:
raise RuntimeError("Argument num-scens={} does not match the number "
"implied by instance name={} "
"\n(--num-scens is not needed for sslp)")
with_fwph = args.with_fwph
with_fixer = args.with_fixer
fixer_tol = args.fixer_tol
with_xhatlooper = args.with_xhatlooper
with_xhatshuffle = args.with_xhatshuffle
with_lagrangian = args.with_lagrangian
if args.default_rho is None:
raise RuntimeError("The --default-rho option must be specified")
scenario_creator_kwargs = {
"data_dir": f"{sslp.__file__[:-8]}/data/{inst}/scenariodata"
}
scenario_creator = sslp.scenario_creator
scenario_denouement = sslp.scenario_denouement
all_scenario_names = [f"Scenario{i+1}" for i in range(num_scen)]
if with_fixer:
ph_ext = Fixer
else:
ph_ext = None
# Things needed for vanilla cylinders
beans = (args, scenario_creator, scenario_denouement, all_scenario_names)
# Vanilla PH hub
hub_dict = vanilla.ph_hub(*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
ph_extensions=ph_ext,
rho_setter=None)
if with_fixer:
hub_dict["opt_kwargs"]["PHoptions"]["fixeroptions"] = {
"verbose": False,
"boundtol": fixer_tol,
"id_fix_list_fct": sslp.id_fix_list_fct,
}
# FWPH spoke
if with_fwph:
fw_spoke = vanilla.fwph_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# Standard Lagrangian bound spoke
if with_lagrangian:
lagrangian_spoke = vanilla.lagrangian_spoke(
*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
rho_setter=None)
# xhat looper bound spoke
if with_xhatlooper:
xhatlooper_spoke = vanilla.xhatlooper_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# xhat shuffle bound spoke
if with_xhatshuffle:
xhatshuffle_spoke = vanilla.xhatshuffle_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
list_of_spoke_dict = list()
if with_fwph:
list_of_spoke_dict.append(fw_spoke)
if with_lagrangian:
list_of_spoke_dict.append(lagrangian_spoke)
if with_xhatlooper:
list_of_spoke_dict.append(xhatlooper_spoke)
if with_xhatshuffle:
list_of_spoke_dict.append(xhatshuffle_spoke)
spin_the_wheel(hub_dict, list_of_spoke_dict)
def main():
args = _parse_args()
BFs = args.branching_factors
xhat_scenario_dict = make_node_scenario_dict_balanced(BFs)
all_nodenames = list(xhat_scenario_dict.keys())
with_xhatspecific = args.with_xhatspecific
with_lagrangian = args.with_lagrangian
with_xhatshuffle = args.with_xhatshuffle
# This is multi-stage, so we need to supply node names
#all_nodenames = ["ROOT"] # all trees must have this node
# The rest is a naming convention invented for this problem.
# Note that mpisppy does not have nodes at the leaves,
# and node names must end in a serial number.
ScenCount = np.prod(BFs)
#ScenCount = _get_num_leaves(BFs)
scenario_creator_kwargs = {"BFs": BFs}
all_scenario_names = [f"scen{i}"
for i in range(ScenCount)] #Scens are 0-based
# print(all_scenario_names)
scenario_creator = aircond_submodels.scenario_creator
scenario_denouement = aircond_submodels.scenario_denouement
rho_setter = None
# Things needed for vanilla cylinders
beans = (args, scenario_creator, scenario_denouement, all_scenario_names)
# Vanilla PH hub
hub_dict = vanilla.ph_hub(*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
ph_extensions=None,
rho_setter=rho_setter,
all_nodenames=all_nodenames)
# Standard Lagrangian bound spoke
if with_lagrangian:
lagrangian_spoke = vanilla.lagrangian_spoke(
*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
rho_setter=rho_setter,
all_nodenames=all_nodenames)
# xhat specific bound spoke
if with_xhatspecific:
xhatspecific_spoke = vanilla.xhatspecific_spoke(
*beans,
xhat_scenario_dict,
all_nodenames=all_nodenames,
scenario_creator_kwargs=scenario_creator_kwargs)
#xhat shuffle looper bound spoke
if with_xhatshuffle:
xhatshuffle_spoke = vanilla.xhatshuffle_spoke(
*beans,
all_nodenames=all_nodenames,
scenario_creator_kwargs=scenario_creator_kwargs)
list_of_spoke_dict = list()
if with_lagrangian:
list_of_spoke_dict.append(lagrangian_spoke)
if with_xhatspecific:
list_of_spoke_dict.append(xhatspecific_spoke)
if with_xhatshuffle:
list_of_spoke_dict.append(xhatshuffle_spoke)
spcomm, opt_dict = sputils.spin_the_wheel(hub_dict, list_of_spoke_dict)
if "hub_class" in opt_dict: # we are a hub rank
if spcomm.opt.cylinder_rank == 0: # we are the reporting hub rank
print("BestInnerBound={} and BestOuterBound={}".\
format(spcomm.BestInnerBound, spcomm.BestOuterBound))
if write_solution:
sputils.write_spin_the_wheel_first_stage_solution(
spcomm, opt_dict, 'aircond_first_stage.csv')
sputils.write_spin_the_wheel_tree_solution(spcomm, opt_dict,
'aircond_full_solution')
def main():
args = _parse_args()
num_scen = args.num_scens
crops_multiplier = args.crops_mult
rho_setter = farmer._rho_setter if hasattr(farmer, '_rho_setter') else None
if args.default_rho is None and rho_setter is None:
raise RuntimeError("No rho_setter so there must be --default-rho")
scenario_creator = farmer.scenario_creator
scenario_denouement = farmer.scenario_denouement
all_scenario_names = ['scen{}'.format(sn) for sn in range(num_scen)]
scenario_creator_kwargs = {
'use_integer': False,
"crops_multiplier": crops_multiplier,
}
scenario_names = [f"Scenario{i+1}" for i in range(num_scen)]
# Things needed for vanilla cylinders
beans = (args, scenario_creator, scenario_denouement, all_scenario_names)
# Vanilla PH hub
hub_dict = vanilla.ph_hub(*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
ph_extensions=None,
rho_setter=rho_setter)
## hack in adaptive rho
if args.use_norm_rho_updater:
hub_dict['opt_kwargs']['PH_extensions'] = NormRhoUpdater
hub_dict['opt_kwargs']['PHoptions']['norm_rho_options'] = {
'verbose': True
}
# FWPH spoke
if args.with_fwph:
fw_spoke = vanilla.fwph_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# Standard Lagrangian bound spoke
if args.with_lagrangian:
lagrangian_spoke = vanilla.lagrangian_spoke(
*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
rho_setter=rho_setter)
# xhat looper bound spoke
if args.with_xhatlooper:
xhatlooper_spoke = vanilla.xhatlooper_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
# xhat shuffle bound spoke
if args.with_xhatshuffle:
xhatshuffle_spoke = vanilla.xhatshuffle_spoke(
*beans, scenario_creator_kwargs=scenario_creator_kwargs)
list_of_spoke_dict = list()
if args.with_fwph:
list_of_spoke_dict.append(fw_spoke)
if args.with_lagrangian:
list_of_spoke_dict.append(lagrangian_spoke)
if args.with_xhatlooper:
list_of_spoke_dict.append(xhatlooper_spoke)
if args.with_xhatshuffle:
list_of_spoke_dict.append(xhatshuffle_spoke)
mpisppy.cylinders.SPOKE_SLEEP_TIME = 0.1
spin_the_wheel(hub_dict, list_of_spoke_dict)
def main():
args = _parse_args()
BFs = args.branching_factors
if len(BFs) != 2:
raise RuntimeError("Hydro is a three stage problem, so it needs 2 BFs")
with_xhatshuffle = args.with_xhatshuffle
with_lagrangian = args.with_lagrangian
# This is multi-stage, so we need to supply node names
all_nodenames = sputils.create_nodenames_from_branching_factors(BFs)
ScenCount = BFs[0] * BFs[1]
scenario_creator_kwargs = {"branching_factors": BFs}
all_scenario_names = [f"Scen{i+1}" for i in range(ScenCount)]
scenario_creator = hydro.scenario_creator
scenario_denouement = hydro.scenario_denouement
rho_setter = None
# Things needed for vanilla cylinders
beans = (args, scenario_creator, scenario_denouement, all_scenario_names)
# Vanilla PH hub
hub_dict = vanilla.ph_hub(*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
ph_extensions=None,
rho_setter=rho_setter,
all_nodenames=all_nodenames,
spoke_sleep_time=SPOKE_SLEEP_TIME)
# Standard Lagrangian bound spoke
if with_lagrangian:
lagrangian_spoke = vanilla.lagrangian_spoke(
*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
rho_setter=rho_setter,
all_nodenames=all_nodenames,
spoke_sleep_time=SPOKE_SLEEP_TIME)
# xhat looper bound spoke
if with_xhatshuffle:
xhatshuffle_spoke = vanilla.xhatshuffle_spoke(
*beans,
all_nodenames=all_nodenames,
scenario_creator_kwargs=scenario_creator_kwargs,
spoke_sleep_time=SPOKE_SLEEP_TIME)
list_of_spoke_dict = list()
if with_lagrangian:
list_of_spoke_dict.append(lagrangian_spoke)
if with_xhatshuffle:
list_of_spoke_dict.append(xhatshuffle_spoke)
wheel = WheelSpinner(hub_dict, list_of_spoke_dict)
wheel.spin()
if wheel.global_rank == 0: # we are the reporting hub rank
print(
f"BestInnerBound={wheel.BestInnerBound} and BestOuterBound={wheel.BestOuterBound}"
)
if write_solution:
wheel.write_first_stage_solution('hydro_first_stage.csv')
wheel.write_tree_solution('hydro_full_solution')
def main():
args = _parse_args()
BFs = [int(bf) for bf in args.BFs.split(',')]
if len(BFs) != 2:
raise RuntimeError("Hydro is a three stage problem, so it needs 2 BFs")
with_xhatspecific = args.with_xhatspecific
with_lagrangian = args.with_lagrangian
# This is multi-stage, so we need to supply node names
all_nodenames = ["ROOT"] # all trees must have this node
# The rest is a naming convention invented for this problem.
# Note that mpisppy does not have nodes at the leaves,
# and node names must end in a serial number.
for b in range(BFs[0]):
all_nodenames.append("ROOT_" + str(b))
ScenCount = BFs[0] * BFs[1]
scenario_creator_kwargs = {"branching_factors": BFs}
all_scenario_names = [f"Scen{i+1}" for i in range(ScenCount)]
scenario_creator = hydro.scenario_creator
scenario_denouement = hydro.scenario_denouement
rho_setter = None
# Things needed for vanilla cylinders
beans = (args, scenario_creator, scenario_denouement, all_scenario_names)
# Vanilla PH hub
hub_dict = vanilla.ph_hub(*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
ph_extensions=None,
rho_setter=rho_setter)
hub_dict["opt_kwargs"]["all_nodenames"] = all_nodenames
hub_dict["opt_kwargs"]["PHoptions"]["branching_factors"] = BFs
# Standard Lagrangian bound spoke
if with_lagrangian:
lagrangian_spoke = vanilla.lagrangian_spoke(
*beans,
scenario_creator_kwargs=scenario_creator_kwargs,
rho_setter=rho_setter)
lagrangian_spoke["opt_kwargs"]["all_nodenames"] = all_nodenames
lagrangian_spoke["opt_kwargs"]["PHoptions"]["branching_factors"] = BFs
# xhat looper bound spoke
xhat_scenario_dict = {
"ROOT": "Scen1",
"ROOT_0": "Scen1",
"ROOT_1": "Scen4",
"ROOT_2": "Scen7"
}
if with_xhatspecific:
xhatspecific_spoke = vanilla.xhatspecific_spoke(
*beans,
xhat_scenario_dict,
all_nodenames,
BFs,
scenario_creator_kwargs=scenario_creator_kwargs)
list_of_spoke_dict = list()
if with_lagrangian:
list_of_spoke_dict.append(lagrangian_spoke)
if with_xhatspecific:
list_of_spoke_dict.append(xhatspecific_spoke)
spcomm, opt_dict = spin_the_wheel(hub_dict, list_of_spoke_dict)
if "hub_class" in opt_dict: # we are a hub rank
if spcomm.opt.cylinder_rank == 0: # we are the reporting hub rank
print("BestInnerBound={} and BestOuterBound={}".\
format(spcomm.BestInnerBound, spcomm.BestOuterBound))
