def solve_optimize(conf, options):
opts = conf.options
trunk = io.get_trunk(conf.filename_mesh)
data = {}
dpb = ProblemDefinition.from_conf(conf, init_equations=False)
equations = getattr(conf, '_'.join(('equations_direct', opts.problem)))
dpb.set_equations(equations)
dpb.name = 'direct'
dpb.time_update(None)
apb = dpb.copy('adjoint')
equations = getattr(
conf, '_'.join(
('equations_adjoint', opts.problem, opts.objective_function)))
apb.set_equations(equations)
apb.time_update(None)
apb.ebcs.zero_dofs()
apb.update_equations(None, ebcs=apb.ebcs)
ls_conf = dpb.get_solver_conf(opts.ls)
dnls_conf = dpb.get_solver_conf(opts.nls_direct)
anls_conf = dpb.get_solver_conf(opts.nls_adjoint)
opt_conf = dpb.get_solver_conf(opts.optimizer)
dpb.init_solvers(ls_conf=ls_conf, nls_conf=dnls_conf)
apb.init_solvers(ls_conf=ls_conf, nls_conf=anls_conf)
shape_opt = so.ShapeOptimFlowCase.from_conf(conf, dpb, apb)
design0 = shape_opt.dsg_vars.val
shape_opt.cache = Struct(design=design0 + 100, state=None, i_mesh=-1)
opt_status = IndexedStruct()
optimizer = Solver.any_from_conf(opt_conf,
obj_fun=so.obj_fun,
obj_fun_grad=so.obj_fun_grad,
status=opt_status,
obj_args=(shape_opt, opts))
##
# State problem solution for the initial design.
vec_dp0 = so.solve_problem_for_design(dpb, design0, shape_opt, opts)
dpb.save_state(trunk + '_direct_initial.vtk', vec_dp0)
##
# Optimize.
des = optimizer(design0)
print opt_status
##
# Save final state (for "optimal" design).
dpb.domain.mesh.write(trunk + '_opt.mesh', io='auto')
dpb.save_state(trunk + '_direct_current.vtk', shape_opt.cache.state)
print des
def solve_optimize(conf, options):
opts = conf.options
trunk = io.get_trunk(conf.filename_mesh)
data = {}
dpb = ProblemDefinition.from_conf(conf, init_equations=False)
equations = getattr(conf, "_".join(("equations_direct", opts.problem)))
dpb.set_equations(equations)
dpb.name = "direct"
dpb.time_update(None)
apb = dpb.copy("adjoint")
equations = getattr(conf, "_".join(("equations_adjoint", opts.problem, opts.objective_function)))
apb.set_equations(equations)
apb.time_update(None)
apb.ebcs.zero_dofs()
apb.update_equations(None, ebcs=apb.ebcs)
ls_conf = dpb.get_solver_conf(opts.ls)
dnls_conf = dpb.get_solver_conf(opts.nls_direct)
anls_conf = dpb.get_solver_conf(opts.nls_adjoint)
opt_conf = dpb.get_solver_conf(opts.optimizer)
dpb.init_solvers(ls_conf=ls_conf, nls_conf=dnls_conf)
apb.init_solvers(ls_conf=ls_conf, nls_conf=anls_conf)
shape_opt = so.ShapeOptimFlowCase.from_conf(conf, dpb, apb)
design0 = shape_opt.dsg_vars.val
shape_opt.cache = Struct(design=design0 + 100, state=None, i_mesh=-1)
opt_status = IndexedStruct()
optimizer = Solver.any_from_conf(
opt_conf, obj_fun=so.obj_fun, obj_fun_grad=so.obj_fun_grad, status=opt_status, obj_args=(shape_opt, opts)
)
##
# State problem solution for the initial design.
vec_dp0 = so.solve_problem_for_design(dpb, design0, shape_opt, opts)
dpb.save_state(trunk + "_direct_initial.vtk", vec_dp0)
##
# Optimize.
des = optimizer(design0)
print opt_status
##
# Save final state (for "optimal" design).
dpb.domain.mesh.write(trunk + "_opt.mesh", io="auto")
dpb.save_state(trunk + "_direct_current.vtk", shape_opt.cache.state)
print des
def solve_adjoint(conf, options, dpb, vec_dp, data):
"""
Solve the adjoint (linear) problem.
"""
opts = conf.options
if dpb:
apb = dpb.copy('adjoint')
else:
apb = ProblemDefinition.from_conf(conf)
equations = getattr(conf, '_'.join(('equations_adjoint',
opts.problem,
opts.objective_function)))
apb.set_equations(equations)
apb.time_update(None)
apb.ebcs.zero_dofs()
apb.update_equations(None, ebcs=apb.ebcs)
var_data = dpb.equations.get_state_parts(vec_dp)
var_data = remap_dict(var_data, opts.var_map)
nls_conf = apb.get_solver_conf(opts.nls_adjoint)
vec_ap = apb.solve(nls_conf=nls_conf, var_data=var_data)
trunk = io.get_trunk(conf.filename_mesh)
apb.save_state(trunk + '_adjoint.vtk', vec_ap)
shape_opt = so.ShapeOptimFlowCase.from_conf(conf, dpb, apb)
## print shape_opt
## pause()
if options.test is not None:
##
# Test shape sensitivity.
if shape_opt.test_terms_if_test:
so.test_terms([options.test], opts.term_delta, shape_opt,
var_data, vec_ap)
shape_opt.check_sensitivity([options.test], opts.delta,
var_data, vec_ap)
##
# Compute objective function.
val = shape_opt.obj_fun(vec_dp)
print 'actual obj_fun:', val
## pause()
##
# Compute shape sensitivity.
vec_sa = shape_opt.sensitivity(var_data, vec_ap)
print 'actual sensitivity:', vec_sa
def solve_generic_direct(conf, options):
opts = conf.options
dpb = ProblemDefinition.from_conf(conf, init_equations=False)
equations = getattr(conf, "_".join(("equations_direct", opts.problem)))
dpb.set_equations(equations)
dpb.time_update(None)
nls_conf = dpb.get_solver_conf(opts.nls_direct)
state_dp = dpb.solve(nls_conf=nls_conf)
return dpb, state_dp, {}
def solve_generic_direct(conf, options):
opts = conf.options
dpb = ProblemDefinition.from_conf(conf, init_equations=False)
equations = getattr(conf, '_'.join(('equations_direct', opts.problem)))
dpb.set_equations(equations)
dpb.time_update(None)
nls_conf = dpb.get_solver_conf(opts.nls_direct)
state_dp = dpb.solve(nls_conf=nls_conf)
return dpb, state_dp, {}
def solve_adjoint(conf, options, dpb, state_dp, data):
"""
Solve the adjoint (linear) problem.
"""
opts = conf.options
if dpb:
apb = dpb.copy('adjoint')
else:
apb = ProblemDefinition.from_conf(conf, init_equations=False)
equations = getattr(
conf, '_'.join(
('equations_adjoint', opts.problem, opts.objective_function)))
apb.set_equations(equations)
apb.time_update(None)
apb.ebcs.zero_dofs()
apb.update_equations(None, ebcs=apb.ebcs)
var_data = state_dp.get_parts()
var_data = remap_dict(var_data, opts.var_map)
nls_conf = apb.get_solver_conf(opts.nls_adjoint)
state_ap = apb.solve(nls_conf=nls_conf, var_data=var_data)
trunk = io.get_trunk(conf.filename_mesh)
apb.save_state(trunk + '_adjoint.vtk', state_ap)
shape_opt = so.ShapeOptimFlowCase.from_conf(conf, dpb, apb)
if options.test is not None:
##
# Test shape sensitivity.
if shape_opt.test_terms_if_test:
so.test_terms([options.test], opts.term_delta, shape_opt, var_data,
state_ap)
shape_opt.check_sensitivity([options.test], opts.delta, var_data,
state_ap)
##
# Compute objective function.
val = shape_opt.obj_fun(state_dp)
print 'actual obj_fun:', val
##
# Compute shape sensitivity.
vec_sa = shape_opt.sensitivity(var_data, state_ap)
print 'actual sensitivity:', vec_sa
def solve_navier_stokes(conf, options):
opts = conf.options
dpb = ProblemDefinition.from_conf(conf, init_equations=False)
equations = getattr(conf, "_".join(("equations_direct", opts.problem)))
dpb.set_equations(equations)
ls_conf = dpb.get_solver_conf(opts.ls)
nls_conf = dpb.get_solver_conf(opts.nls_direct)
method = opts.direct_method
if method == "stationary":
data = {}
dpb.time_update(None)
state_dp = dpb.solve(nls_conf=nls_conf)
elif method == "transient":
ls = Solver.any_from_conf(ls_conf)
ts_conf = dpb.get_solver_conf(opts.ts_direct)
data = {"ts": Struct(dt=ts_conf.dt)}
# Plug in mass term.
mequations = {}
for key, eq in equations.iteritems():
if "dw_div_grad" in eq:
eq = "+".join((ts_conf.mass_term, eq)).replace("++", "+")
mequations[key] = eq
if ts_conf.stokes_init:
state_dp0 = solve_stokes(dpb, conf.equations_direct_stokes, nls_conf)
dpb.set_equations(mequations)
else:
dpb.set_equations(mequations)
state_dp0 = dpb.create_state()
dpb.time_update(None)
state_dp0.apply_ebc()
from sfepy.base.log import Log
log = Log.from_conf(Struct(is_plot=True), ([r"$||u||$"], [r"$||p||$"]))
output("Navier-Stokes...")
ev = BasicEvaluator(dpb, ts=Struct(dt=ts_conf.dt))
nls = Solver.any_from_conf(nls_conf, evaluator=ev, lin_solver=ls)
n_step = ts_conf.n_step
step = 0
while 1:
for ii in xrange(n_step):
output(step)
vec_u = state_dp0("w")
vec_p = state_dp0("r")
log(nm.linalg.norm(vec_u), nm.linalg.norm(vec_p))
dpb.variables.set_data_from_state("w_0", state_dp0(), "w")
vec_dp = nls(state_dp0())
step += 1
state_dp = state_dp0.copy()
state_dp.set_reduced(vec_dp)
state_dp0 = state_dp
if ts_conf.interactive:
try:
n_step = int(raw_input("continue: "))
if n_step <= 0:
break
except:
break
vec_u = state_dp("w")
vec_p = state_dp("r")
log(nm.linalg.norm(vec_u), nm.linalg.norm(vec_p), finished=True)
else:
raise "unknown Navier-Stokes solution method (%s)!" % method
return dpb, state_dp, data
def solve_navier_stokes(conf, options):
opts = conf.options
dpb = ProblemDefinition.from_conf(conf, init_equations=False)
equations = getattr(conf, '_'.join(('equations_direct', opts.problem)))
dpb.set_equations(equations)
ls_conf = dpb.get_solver_conf( opts.ls )
nls_conf = dpb.get_solver_conf(opts.nls_direct)
method = opts.direct_method
if method == 'stationary':
data = {}
dpb.time_update(None)
vec_dp = dpb.solve(nls_conf=nls_conf)
elif method == 'transient':
ls = Solver.any_from_conf( ls_conf )
ts_conf = dpb.get_solver_conf( opts.ts_direct )
data = {'ts' : Struct( dt = ts_conf.dt )}
# Plug in mass term.
mequations = {}
for key, eq in equations.iteritems():
if 'dw_div_grad' in eq:
eq = '+'.join( (ts_conf.mass_term, eq) ).replace( '++', '+')
mequations[key] = eq
if ts_conf.stokes_init:
vec_dp0 = solve_stokes( dpb, conf.equations_direct_stokes, nls_conf )
dpb.set_equations( mequations )
else:
dpb.set_equations( mequations )
vec_dp0 = dpb.create_state_vector()
dpb.time_update( None )
dpb.apply_ebc( vec_dp0 )
from sfepy.base.log import Log
log = Log.from_conf( Struct( is_plot = True ),
([r'$||u||$'], [r'$||p||$']) )
output( 'Navier-Stokes...' )
ev = BasicEvaluator( dpb, ts = Struct( dt = ts_conf.dt ) )
nls = Solver.any_from_conf( nls_conf, evaluator = ev, lin_solver = ls )
n_step = ts_conf.n_step
step = 0
while 1:
for ii in xrange( n_step ):
output( step )
vec_u = dpb.variables.get_state_part_view( vec_dp0, 'w' )
vec_p = dpb.variables.get_state_part_view( vec_dp0, 'r' )
log( nm.linalg.norm( vec_u ), nm.linalg.norm( vec_p ) )
dpb.variables.non_state_data_from_state( 'w_0', vec_dp0, 'w' )
vec_dp = nls( vec_dp0 )
step += 1
vec_dp0 = vec_dp.copy()
if ts_conf.interactive:
try:
n_step = int( raw_input( 'continue: ' ) )
if n_step <= 0: break
except:
break
vec_u = dpb.variables.get_state_part_view( vec_dp, 'w' )
vec_p = dpb.variables.get_state_part_view( vec_dp, 'r' )
log( nm.linalg.norm( vec_u ), nm.linalg.norm( vec_p ), finished = True )
else:
raise 'unknown Navier-Stokes solution method (%s)!' % method
return dpb, vec_dp, data
def solve_navier_stokes(conf, options):
opts = conf.options
dpb = ProblemDefinition.from_conf(conf, init_equations=False)
equations = getattr(conf, '_'.join(('equations_direct', opts.problem)))
dpb.set_equations(equations)
ls_conf = dpb.get_solver_conf(opts.ls)
nls_conf = dpb.get_solver_conf(opts.nls_direct)
method = opts.direct_method
if method == 'stationary':
data = {}
dpb.time_update(None)
state_dp = dpb.solve(nls_conf=nls_conf)
elif method == 'transient':
ls = Solver.any_from_conf(ls_conf)
ts_conf = dpb.get_solver_conf(opts.ts_direct)
data = {'ts': Struct(dt=ts_conf.dt)}
# Plug in mass term.
mequations = {}
for key, eq in equations.iteritems():
if 'dw_div_grad' in eq:
eq = '+'.join((ts_conf.mass_term, eq)).replace('++', '+')
mequations[key] = eq
if ts_conf.stokes_init:
state_dp0 = solve_stokes(dpb, conf.equations_direct_stokes,
nls_conf)
dpb.set_equations(mequations)
else:
dpb.set_equations(mequations)
state_dp0 = dpb.create_state()
dpb.time_update(None)
state_dp0.apply_ebc()
from sfepy.base.log import Log
log = Log.from_conf(Struct(is_plot=True), ([r'$||u||$'], [r'$||p||$']))
output('Navier-Stokes...')
ev = BasicEvaluator(dpb, ts=Struct(dt=ts_conf.dt))
nls = Solver.any_from_conf(nls_conf, evaluator=ev, lin_solver=ls)
n_step = ts_conf.n_step
step = 0
while 1:
for ii in xrange(n_step):
output(step)
vec_u = state_dp0('w')
vec_p = state_dp0('r')
log(nm.linalg.norm(vec_u), nm.linalg.norm(vec_p))
dpb.variables.non_state_data_from_state(
'w_0', state_dp0(), 'w')
vec_dp = nls(state_dp0())
step += 1
state_dp = state_dp0.copy()
state_dp.set_reduced(vec_dp)
state_dp0 = state_dp
if ts_conf.interactive:
try:
n_step = int(raw_input('continue: '))
if n_step <= 0: break
except:
break
vec_u = state_dp('w')
vec_p = state_dp('r')
log(nm.linalg.norm(vec_u), nm.linalg.norm(vec_p), finished=True)
else:
raise 'unknown Navier-Stokes solution method (%s)!' % method
return dpb, state_dp, data
