def get(self, variable, quantity_name, bf=None, integration=None, step=None, time_derivative=None): """ Get the named quantity related to the variable. Notes ----- This is a convenience wrapper of Variable.evaluate() that initializes the arguments using the term data. """ name = variable.name step = get_default(step, self.arg_steps[name]) time_derivative = get_default(time_derivative, self.arg_derivatives[name]) integration = get_default(integration, self.geometry_types[name]) data = variable.evaluate( mode=quantity_name, region=self.region, integral=self.integral, integration=integration, step=step, time_derivative=time_derivative, is_trace=self.arg_traces[name], bf=bf, ) return data
def _standard_call(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None, i_max=None, mtx=None, status=None, context=None, **kwargs): tt = time.clock() conf = get_default(conf, self.conf) mtx = get_default(mtx, self.mtx) status = get_default(status, self.status) context = get_default(context, self.context) assert_(mtx.shape[0] == mtx.shape[1] == rhs.shape[0]) if x0 is not None: assert_(x0.shape[0] == rhs.shape[0]) result = call(self, rhs, x0, conf, eps_a, eps_r, i_max, mtx, status, context=context, **kwargs) if isinstance(result, tuple): result, n_iter = result else: n_iter = -1 # Number of iterations is undefined/unavailable. ttt = time.clock() - tt if status is not None: status['time'] = ttt status['n_iter'] = n_iter return result
def save_results(self, eigs, mtx_phi, out=None, mesh_results_name=None, eig_results_name=None): mesh_results_name = get_default(mesh_results_name, self.mesh_results_name) eig_results_name = get_default(eig_results_name, self.eig_results_name) pb = self.problem save = self.app_options.save_eig_vectors n_eigs = self.app_options.n_eigs out = get_default(out, {}) state = pb.create_state() aux = {} for ii in range(eigs.shape[0]): if save is not None: if (ii > save[0]) and (ii < (n_eigs - save[1])): continue state.set_full(mtx_phi[:,ii]) aux = state.create_output_dict() key = list(aux.keys())[0] out[key+'%03d' % ii] = aux[key] if aux.get('__mesh__') is not None: out['__mesh__'] = aux['__mesh__'] pb.save_state(mesh_results_name, out=out) fd = open(eig_results_name, 'w') eigs.tofile(fd, ' ') fd.close()
def setup_output( self, output_filename_trunk=None, output_dir=None, output_format=None, float_format=None, file_per_var=None, linearization=None, ): """ Sets output options to given values, or uses the defaults for each argument that is None. """ self.output_modes = {"vtk": "sequence", "h5": "single"} self.ofn_trunk = get_default(output_filename_trunk, io.get_trunk(self.domain.name)) self.set_output_dir(output_dir) self.output_format = get_default(output_format, "vtk") self.float_format = get_default(float_format, None) self.file_per_var = get_default(file_per_var, False) self.linearization = get_default(linearization, Struct(kind="strip")) if (self.output_format == "h5") and (self.linearization.kind == "adaptive"): self.linearization.kind = None
def _petsc_call(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None, i_max=None, mtx=None, status=None, comm=None, context=None, **kwargs): tt = time.clock() conf = get_default(conf, self.conf) mtx = get_default(mtx, self.mtx) status = get_default(status, self.status) context = get_default(context, self.context) comm = get_default(comm, self.comm) mshape = mtx.size if isinstance(mtx, self.petsc.Mat) else mtx.shape rshape = [rhs.size] if isinstance(rhs, self.petsc.Vec) else rhs.shape assert_(mshape[0] == mshape[1] == rshape[0]) if x0 is not None: xshape = [x0.size] if isinstance(x0, self.petsc.Vec) else x0.shape assert_(xshape[0] == rshape[0]) result = call(self, rhs, x0, conf, eps_a, eps_r, i_max, mtx, status, comm, context=context, **kwargs) ttt = time.clock() - tt if status is not None: status['time'] = ttt status['n_iter'] = self.ksp.getIterationNumber() return result
def __call__(self, x0, conf=None, obj_fun=None, obj_fun_grad=None, status=None, obj_args=None): if conf is not None: self.set_method(conf) else: conf = self.conf obj_fun = get_default(obj_fun, self.obj_fun) obj_fun_grad = get_default(obj_fun_grad, self.obj_fun_grad) status = get_default(status, self.status) obj_args = get_default(obj_args, self.obj_args) tt = time.clock() kwargs = {self._i_max_name[conf.method] : conf.i_max, 'disp' : conf.verbose, 'args' : obj_args} if conf.method in self._has_grad: kwargs['fprime'] = obj_fun_grad for key, val in conf.to_dict().iteritems(): if key not in self._omit: kwargs[key] = val out = self.solver(obj_fun, x0, **kwargs) if status is not None: status['time_stats'] = time.clock() - tt return out
def solve_pressure_eigenproblem(self, mtx, eig_problem=None, n_eigs=0, check=False): """G = B*AI*BT or B*AI*BT+D""" def get_slice(n_eigs, nn): if n_eigs > 0: ii = slice(0, n_eigs) elif n_eigs < 0: ii = slice(nn + n_eigs, nn) else: ii = slice(0, 0) return ii eig_problem = get_default(eig_problem, self.eig_problem) n_eigs = get_default(n_eigs, self.n_eigs) check = get_default(check, self.check) mtx_c, mtx_b, action_aibt = mtx['C'], mtx['B'], mtx['action_aibt'] mtx_g = mtx_b * action_aibt.to_array() # mtx_b must be sparse! if eig_problem == 'B*AI*BT+D': mtx_g += mtx['D'].toarray() mtx['G'] = mtx_g output(mtx_c.shape, mtx_g.shape) eigs, mtx_q = eig(mtx_c.toarray(), mtx_g, method='eig.sgscipy') if check: ee = nm.diag(sc.dot(mtx_q.T * mtx_c, mtx_q)).squeeze() oo = nm.diag(sc.dot(sc.dot(mtx_q.T, mtx_g), mtx_q)).squeeze() try: assert_(nm.allclose(ee, eigs)) assert_(nm.allclose(oo, nm.ones_like(eigs))) except ValueError: debug() nn = mtx_c.shape[0] if isinstance(n_eigs, tuple): output('required number of eigenvalues: (%d, %d)' % n_eigs) if sum(n_eigs) < nn: ii0 = get_slice(n_eigs[0], nn) ii1 = get_slice(-n_eigs[1], nn) eigs = nm.concatenate((eigs[ii0], eigs[ii1])) mtx_q = nm.concatenate((mtx_q[:,ii0], mtx_q[:,ii1]), 1) else: output('required number of eigenvalues: %d' % n_eigs) if (n_eigs != 0) and (abs(n_eigs) < nn): ii = get_slice(n_eigs, nn) eigs = eigs[ii] mtx_q = mtx_q[:,ii] ## from sfepy.base.plotutils import pylab, iplot ## pylab.semilogy(eigs) ## pylab.figure(2) ## iplot(eigs) ## pylab.show() ## debug() out = Struct(eigs=eigs, mtx_q=mtx_q) return out
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None, i_max=None, mtx=None, status=None, **kwargs): eps_a = get_default(eps_a, self.conf.eps_a) eps_r = get_default(eps_r, self.conf.eps_r) i_max = get_default(i_max, self.conf.i_max) eps_d = self.conf.eps_d # There is no use in caching matrix in the solver - always set as new. pmtx, psol, prhs = self.set_matrix(mtx) ksp = self.ksp ksp.setOperators(pmtx) ksp.setFromOptions() # PETSc.Options() not used yet... ksp.setTolerances(atol=eps_a, rtol=eps_r, divtol=eps_d, max_it=i_max) # Set PETSc rhs, solve, get solution from PETSc solution. if x0 is not None: psol[...] = x0 ksp.setInitialGuessNonzero(True) prhs[...] = rhs ksp.solve(prhs, psol) sol = psol[...].copy() output('%s(%s) convergence: %s (%s)' % (self.conf.method, self.conf.precond, ksp.reason, self.converged_reasons[ksp.reason])) return sol
def setup_ic( self, conf_ics = None, functions = None ): conf_ics = get_default(conf_ics, self.conf.ics) ics = Conditions.from_conf(conf_ics, self.domain.regions) functions = get_default(functions, self.functions) self.equations.setup_initial_conditions(ics, functions)
def __call__(self, vec_x0, conf=None, fun=None, fun_grad=None, lin_solver=None, iter_hook=None, status=None): if conf is not None: self.set_method( conf ) else: conf = self.conf fun = get_default( fun, self.fun ) status = get_default( status, self.status ) tt = time.clock() kwargs = {'iter' : conf.i_max, 'alpha' : conf.alpha, 'verbose' : conf.verbose} if conf.method == 'broyden_generalized': kwargs.update( {'M' : conf.M} ) elif conf.method in ['anderson', 'anderson2']: kwargs.update( {'M' : conf.M, 'w0' : conf.w0} ) vec_x = self.solver( fun, vec_x0, **kwargs ) vec_x = nm.asarray(vec_x) if status is not None: status['time_stats'] = time.clock() - tt return vec_x
def __call__(self, x0, conf=None, obj_fun=None, obj_fun_grad=None, status=None, obj_args=None): import inspect if conf is not None: self.set_method(conf) else: conf = self.conf obj_fun = get_default(obj_fun, self.obj_fun) obj_fun_grad = get_default(obj_fun_grad, self.obj_fun_grad) status = get_default(status, self.status) obj_args = get_default(obj_args, self.obj_args) tt = time.clock() kwargs = {self._i_max_name[conf.method] : conf.i_max, 'args' : obj_args} if conf.method in self._has_grad: kwargs['fprime'] = obj_fun_grad if 'disp' in inspect.getargspec(self.solver)[0]: kwargs['disp'] = conf.verbose kwargs.update(self.build_solver_kwargs(conf)) out = self.solver(obj_fun, x0, **kwargs) if status is not None: status['time_stats'] = time.clock() - tt return out
def setup_ics(self, ics=None, functions=None): """ Setup the initial conditions for use. """ self.set_ics(get_default(ics, self.ics)) functions = get_default(functions, self.functions) self.equations.setup_initial_conditions(self.ics, functions)
def time_update(self, ts=None, ebcs=None, epbcs=None, lcbcs=None, functions=None, create_matrix=False): self.set_bcs(get_default(ebcs, self.ebcs), get_default(epbcs, self.epbcs), get_default(lcbcs, self.lcbcs)) self.update_equations(ts, self.ebcs, self.epbcs, self.lcbcs, functions, create_matrix)
def get_default_ts(self, t0=None, t1=None, dt=None, n_step=None, step=None): t0 = get_default(t0, 0.0) t1 = get_default(t1, 1.0) dt = get_default(dt, 1.0) n_step = get_default(n_step, 1) ts = TimeStepper(t0, t1, dt, n_step, step=step) return ts
def __init__(self, filename, approx, region_selects, mat_pars, options, evp_options, eigenmomenta_options, band_gaps_options, coefs_save_name='coefs', corrs_save_names=None, incwd=None, output_dir=None, **kwargs): Struct.__init__(self, approx=approx, region_selects=region_selects, mat_pars=mat_pars, options=options, evp_options=evp_options, eigenmomenta_options=eigenmomenta_options, band_gaps_options=band_gaps_options, **kwargs) self.incwd = get_default(incwd, lambda x: x) self.conf = Struct() self.conf.filename_mesh = self.incwd(filename) output_dir = get_default(output_dir, self.incwd('output')) default = {'evp' : 'evp', 'corrs_rs' : 'corrs_rs'} self.corrs_save_names = get_default(corrs_save_names, default) io = MeshIO.any_from_filename(self.conf.filename_mesh) self.bbox, self.dim = io.read_bounding_box(ret_dim=True) rpc_axes = nm.eye(self.dim, dtype=nm.float64) \ * (self.bbox[1] - self.bbox[0]) self.conf.options = options self.conf.options.update({ 'output_dir' : output_dir, 'volume' : { 'value' : get_lattice_volume(rpc_axes), }, 'coefs' : 'coefs', 'requirements' : 'requirements', 'coefs_filename' : coefs_save_name, }) self.conf.mat_pars = mat_pars self.conf.solvers = self.define_solvers() self.conf.regions = self.define_regions() self.conf.materials = self.define_materials() self.conf.fields = self.define_fields() self.conf.variables = self.define_variables() (self.conf.ebcs, self.conf.epbcs, self.conf.lcbcs, self.all_periodic) = self.define_bcs() self.conf.functions = self.define_functions() self.conf.integrals = self.define_integrals() self.equations, self.expr_coefs = self.define_equations() self.conf.coefs = self.define_coefs() self.conf.requirements = self.define_requirements()
def __init__(self, data_names=None, yscales=None, xlabels=None, ylabels=None, is_plot=True, aggregate=200, formats=None, log_filename=None): """`data_names` ... tuple of names grouped by subplots: ([name1, name2, ...], [name3, name4, ...], ...) where name<n> are strings to display in (sub)plot legends.""" try: import matplotlib as mpl except: mpl = None if (mpl is not None) and mpl.rcParams['backend'] == 'GTKAgg': can_live_plot = True else: can_live_plot = False Struct.__init__(self, data_names = {}, n_arg = 0, n_gr = 0, data = {}, x_values = {}, n_calls = 0, yscales = {}, xlabels = {}, ylabels = {}, plot_pipe = None, formats = {}, output = None) if data_names is not None: n_gr = len(data_names) else: n_gr = 0 data_names = [] yscales = get_default(yscales, ['linear'] * n_gr) xlabels = get_default(xlabels, ['iteration'] * n_gr) ylabels = get_default(ylabels, [''] * n_gr ) if formats is None: formats = [None] * n_gr for ig, names in enumerate(data_names): self.add_group(names, yscales[ig], xlabels[ig], ylabels[ig], formats[ig]) self.is_plot = get_default( is_plot, True ) self.aggregate = get_default( aggregate, 100 ) self.can_plot = (can_live_plot and (mpl is not None) and (Process is not None)) if log_filename is not None: self.output = Output('', filename=log_filename) self.output('# started: %s' % time.asctime()) self.output('# groups: %d' % n_gr) for ig, names in enumerate(data_names): self.output('# %d' % ig) self.output('# xlabel: "%s", ylabel: "%s", yscales: "%s"' % (xlabels[ig], ylabels[ig], yscales[ig])) self.output('# names: "%s"' % ', '.join(names)) if self.is_plot and (not self.can_plot): output(_msg_no_live)
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None, i_max=None, mtx=None, status=None, context=None, **kwargs): solver_kwargs = self.build_solver_kwargs(conf) eps_a = get_default(eps_a, self.conf.eps_a) eps_r = get_default(eps_r, self.conf.eps_r) i_max = get_default(i_max, self.conf.i_max) setup_precond = get_default(kwargs.get('setup_precond', None), self.conf.setup_precond) callback = get_default(kwargs.get('callback', lambda sol: None), self.conf.callback) self.iter = 0 def iter_callback(sol): self.iter += 1 msg = '%s: iteration %d' % (self.conf.name, self.iter) if conf.verbose > 2: if conf.method not in self._callbacks_res: res = mtx * sol - rhs else: res = sol rnorm = nm.linalg.norm(res) msg += ': |Ax-b| = %e' % rnorm output(msg, verbose=conf.verbose > 1) # Call an optional user-defined callback. callback(sol) precond = setup_precond(mtx, context) if conf.method == 'qmr': prec_args = {'M1' : precond, 'M2' : precond} else: prec_args = {'M' : precond} solver_kwargs.update(prec_args) try: sol, info = self.solver(mtx, rhs, x0=x0, atol=eps_a, tol=eps_r, maxiter=i_max, callback=iter_callback, **solver_kwargs) except TypeError: sol, info = self.solver(mtx, rhs, x0=x0, tol=eps_r, maxiter=i_max, callback=iter_callback, **solver_kwargs) output('%s: %s convergence: %s (%s, %d iterations)' % (self.conf.name, self.conf.method, info, self.converged_reasons[nm.sign(info)], self.iter), verbose=conf.verbose) return sol, self.iter
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None, i_max=None, mtx=None, status=None, **kwargs): conf = get_default(conf, self.conf) mtx = get_default(mtx, self.mtx) status = get_default(status, self.status) if self.solve is not None: # Matrix is already prefactorized. return self.solve(rhs) else: return self.sls.spsolve(mtx, rhs)
def __call__( self, state0 = None, conf = None, step_fun = None, step_args = None ): step_fun = get_default( step_fun, self.step_fun ) step_args = get_default( step_args, self.step_args ) for step, time in self.ts: output( self.format % (time, step + 1, self.ts.n_step) ) state = step_fun( self.ts, state0, *step_args ) state0 = state.copy(deep=True) yield self.ts, state
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None, i_max=None, mtx=None, status=None, **kwargs): conf = get_default(conf, self.conf) mtx = get_default(mtx, self.mtx) status = get_default(status, self.status) mtxi= self.orig_conf.idxs mtxslc_s = {} mtxslc_f = {} nn = {} for ik, iv in mtxi.iteritems(): ptr = 0 nn[ik] = len(iv) mtxslc_s[ik] = [] mtxslc_f[ik] = [] while ptr < nn[ik]: idx0 = iv[ptr:] idxrange = nm.arange(idx0[0], idx0[0] + len(idx0)) aux = nm.where(idx0 == idxrange)[0] mtxslc_s[ik].append(slice(ptr + aux[0], ptr + aux[-1] + 1)) mtxslc_f[ik].append(slice(idx0[aux][0], idx0[aux][-1] + 1)) ptr += aux[-1] + 1 mtxs = {} rhss = {} ress = {} for ir in mtxi.iterkeys(): rhss[ir] = nm.zeros((nn[ir],), dtype=nm.float64) ress[ir] = nm.zeros((nn[ir],), dtype=nm.float64) for jr, idxr in enumerate(mtxslc_f[ir]): rhss[ir][mtxslc_s[ir][jr]] = rhs[idxr] for ic in mtxi.iterkeys(): mtxid = '%s%s' % (ir, ic) mtxs[mtxid] = nm.zeros((nn[ir], nn[ic]), dtype=nm.float64) for jr, idxr in enumerate(mtxslc_f[ir]): for jc, idxc in enumerate(mtxslc_f[ic]): iir = mtxslc_s[ir][jr] iic = mtxslc_s[ic][jc] mtxs[mtxid][iir, iic] = mtx._get_submatrix(idxr, idxc).todense() self.orig_conf.function(ress, mtxs, rhss, nn) res = nm.zeros_like(rhs) for ir in mtxi.iterkeys(): for jr, idxr in enumerate(mtxslc_f[ir]): res[idxr] = ress[ir][mtxslc_s[ir][jr]] return res
def solve(mtx, rhs, solver_class=None, solver_conf=None): """ Solve the linear system with the matrix `mtx` and the right-hand side `rhs`. Convenience wrapper around the linear solver classes below. """ solver_class = get_default(solver_class, ScipyDirect) solver_conf = get_default(solver_conf, {}) solver = solver_class(solver_conf, mtx=mtx) solution = solver(rhs) return solution
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None, i_max=None, mtx=None, status=None, **kwargs): conf = get_default(conf, self.conf) eps_r = get_default(eps_r, self.eps_r) mtx = get_default(mtx, self.mtx) status = get_default(status, self.status) if (self.mg is None) or (mtx is not self.mtx): self.mg = self.solver(mtx) self.mtx = mtx sol = self.mg.solve(rhs, x0=x0, accel=conf.accel, tol=eps_r) return sol
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None, i_max=None, mtx=None, status=None, **kwargs): eps_r = get_default(eps_r, self.conf.eps_r) i_max = get_default(i_max, self.conf.i_max) if (self.mg is None) or (mtx is not self.mtx): self.mg = self.solver(mtx) self.mtx = mtx sol = self.mg.solve(rhs, x0=x0, accel=conf.accel, tol=eps_r, maxiter=i_max) return sol
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None, i_max=None, mtx=None, status=None, **kwargs): conf = get_default(conf, self.conf) eps_r = get_default(eps_r, self.conf.eps_r) i_max = get_default(i_max, self.conf.i_max) mtx = get_default(mtx, self.mtx) status = get_default(status, self.status) sol, info = self.solver(mtx, rhs, x0=x0, tol=eps_r, maxiter=i_max) output('%s convergence: %s (%s)' % (self.conf.method, info, self.converged_reasons[nm.sign(info)])) return sol
def __call__(self, vec0=None, nls=None, init_fun=None, prestep_fun=None, poststep_fun=None, status=None, **kwargs): """ Solve elastodynamics problems by the generalized :math:`\alpha` method. """ conf = self.conf nls = get_default(nls, self.nls) rho_inf = conf.rho_inf alpha_m = get_default(conf.alpha_m, (2.0 * rho_inf - 1.0) / (rho_inf + 1.0)) alpha_f = get_default(conf.alpha_f, rho_inf / (rho_inf + 1.0)) beta = get_default(conf.beta, 0.25 * (1.0 - alpha_m + alpha_f)**2) gamma = get_default(conf.gamma, 0.5 - alpha_m + alpha_f) output('parameters rho_inf, alpha_m, alpha_f, beta, gamma:', verbose=self.verbose) output(rho_inf, alpha_m, alpha_f, beta, gamma, verbose=self.verbose) vec, unpack, pack = self.get_initial_vec( nls, vec0, init_fun, prestep_fun, poststep_fun) ts = self.ts for step, time in ts.iter_from(ts.step): output(self.format % (time, step + 1, ts.n_step), verbose=self.verbose) dt = ts.dt prestep_fun(ts, vec) ut, vt, at = unpack(vec) nlst = self.create_nlst(nls, dt, alpha_m, alpha_f, gamma, beta, ut, vt, at) ts.set_substep_time((1.0 - alpha_f) * dt) am = nlst(at) ts.restore_step_time() atp = nlst.a1(am) vtp = nlst.v1(atp) utp = nlst.u1(atp) vect = pack(utp, vtp, atp) poststep_fun(ts, vect) vec = vect return vec
def __call__(self, volume, problem=None, data=None): problem = get_default(problem, self.problem) coef = nm.zeros((self.dim, self.dim), dtype=self.dtype) term_mode = self.term_mode equations, variables = problem.create_evaluable(self.expression, term_mode=term_mode) if isinstance(self.set_variables, list): for ir in range(self.dim): self.set_variables_default(variables, ir, None, 'row', self.set_variables, data) for ic in range(self.dim): self.set_variables_default(variables, None, ic, 'col', self.set_variables, data) val = eval_equations(equations, variables, term_mode=term_mode) coef[ir,ic] = val else: for ir in range(self.dim): self.set_variables(variables, ir, None, 'row', **data) for ic in range(self.dim): self.set_variables(variables, None, ic, 'col', **data) val = eval_equations(equations, variables, term_mode=term_mode) coef[ir,ic] = val coef /= self._get_volume(volume) return coef
def set_linear( self, is_linear ): nls_conf = get_default( None, self.nls_conf, 'you must set nonlinear solver!' ) if is_linear: nls_conf.problem = 'linear' else: nls_conf.problem = 'nonlinear'
def _set_data(self, coors, ngroups, conns, mat_ids, descs, nodal_bcs=None): """ Set mesh data. Parameters ---------- coors : array Coordinates of mesh nodes. ngroups : array Node groups. conns : list of arrays The array of mesh elements (connectivities) for each element group. mat_ids : list of arrays The array of material ids for each element group. descs: list of strings The element type for each element group. nodal_bcs : dict of arrays, optional The nodes defining regions for boundary conditions referred to by the dict keys in problem description files. """ self.coors = nm.ascontiguousarray(coors) if ngroups is None: self.ngroups = nm.zeros((self.coors.shape[0],), dtype=nm.int32) else: self.ngroups = nm.ascontiguousarray(ngroups) self.conns = [nm.asarray(conn, dtype=nm.int32) for conn in conns] self.mat_ids = [nm.asarray(mat_id, dtype=nm.int32) for mat_id in mat_ids] self.descs = descs self.nodal_bcs = get_default(nodal_bcs, {})
def set_equations(self, conf_equations=None, user=None, keep_solvers=False, make_virtual=False): """ Set equations of the problem using the `equations` problem description entry. Fields and Regions have to be already set. """ conf_equations = get_default(conf_equations, self.conf.get_default_attr('equations', None)) self.set_variables() variables = Variables.from_conf(self.conf_variables, self.fields) self.set_materials() materials = Materials.from_conf(self.conf_materials, self.functions) self.integrals = self.get_integrals() equations = Equations.from_conf(conf_equations, variables, self.domain.regions, materials, self.integrals, user=user, make_virtual=make_virtual) self.equations = equations if not keep_solvers: self.solvers = None
def setup_default_output(self, conf=None, options=None): """ Provide default values to `ProblemDefinition.setup_output()` from `conf.options` and `options`. """ conf = get_default(conf, self.conf) if options and options.output_filename_trunk: default_output_dir, of = op.split(options.output_filename_trunk) default_trunk = io.get_trunk(of) else: default_trunk = None default_output_dir = get_default_attr(conf.options, 'output_dir', None) if options and options.output_format: default_output_format = options.output_format else: default_output_format = get_default_attr(conf.options, 'output_format', None) default_file_per_var = get_default_attr(conf.options, 'file_per_var', None) default_float_format = get_default_attr(conf.options, 'float_format', None) default_linearization = Struct(kind='strip') self.setup_output(output_filename_trunk=default_trunk, output_dir=default_output_dir, file_per_var=default_file_per_var, output_format=default_output_format, float_format=default_float_format, linearization=default_linearization)
def eval_tangent_matrix( self, vec, mtx = None, is_full = False ): if isinstance(vec, basestr) and vec == 'linear': return get_default(mtx, self.problem.mtx_a) if not is_full: vec = self.make_full_vec( vec ) pb = self.problem if mtx is None: mtx = pb.mtx_a mtx = pb.equations.eval_tangent_matrices(vec, mtx) if self.matrix_hook is not None: mtx = self.matrix_hook(mtx, pb, call_mode='basic') return mtx
def __call__(self, volume, problem=None, data=None): problem = get_default(problem, self.problem) term_mode = self.term_mode equations, variables = problem.create_evaluable(self.expression, term_mode=term_mode) if isinstance(self.set_variables, list): self.set_variables_default(variables, self.set_variables, data) else: self.set_variables(variables, **data) val = eval_equations(equations, variables, term_mode=term_mode) coef = val / self._get_volume(volume) return coef
def __call__(self, volume=None, problem=None, data=None): problem = get_default(problem, self.problem) vf = {} for region_name in self.regions: vkey = 'volume_%s' % region_name key = 'fraction_%s' % region_name equations, variables = problem.create_evaluable(self.expression % region_name) val = eval_equations(equations, variables) vf[vkey] = nm.asarray(val, dtype=nm.float64) vf[key] = vf[vkey] / self._get_volume(volume) return vf
def __call__(self, problem=None, data=None): problem = get_default(problem, self.problem) problem.set_equations(self.equations) problem.select_bcs(ebc_names=self.ebcs, epbc_names=self.epbcs, lcbc_names=self.get('lcbcs', [])) problem.update_materials() mtx = problem.equations.eval_tangent_matrices(problem.create_state()(), problem.mtx_a, by_blocks=True) self.presolve(mtx) evp = self.solve_pressure_eigenproblem(mtx) return Struct(name=self.name, ebcs=self.ebcs, epbcs=self.epbcs, mtx=mtx, evp=evp)
def __call__(self, vec0=None, nls=None, init_fun=None, prestep_fun=None, poststep_fun=None, status=None, **kwargs): """ Solve elastodynamics problems by the Bathe method. """ nls = get_default(nls, self.nls) vec, unpack, pack = self.get_initial_vec(nls, vec0, init_fun, prestep_fun, poststep_fun) ts = self.ts for step, time in ts.iter_from(ts.step): output(self.format % (time, step + 1, ts.n_step), verbose=self.verbose) dt = ts.dt prestep_fun(ts, vec) ut, vt, at = unpack(vec) nlst1 = self.create_nlst1(nls, dt, ut, vt, at) ut1 = nlst1(ut) vt1 = nlst1.v(ut1) at1 = nlst1.a(vt1) ts.set_substep_time(0.5 * dt) vec1 = pack(ut1, vt1, at1) prestep_fun(ts, vec1) nlst2 = self.create_nlst2(nls, dt, ut, ut1, vt, vt1) ut2 = nlst2(ut1) vt2 = nlst2.v(ut2) at2 = nlst2.a(vt2) ts.restore_step_time() vec2 = pack(ut2, vt2, at2) poststep_fun(ts, vec2) vec = vec2 return vec
def __init__(self, name, region, efaces, volume_econn, ig): """nodes[leconn] == econn""" """nodes are sorted by node number -> same order as region.vertices""" self.name = get_default(name, 'surface_data_%s' % region.name) face_indices = region.fis[ig] faces = efaces[face_indices[:,1]] if faces.size == 0: raise ValueError('region with group with no faces! (%s)' % region.name) try: ee = volume_econn[face_indices[:,0]] except: raise ValueError('missing region face indices! (%s)' % region.name) econn = nm.empty(faces.shape, dtype=nm.int32) for ir, face in enumerate( faces ): econn[ir] = ee[ir,face] ef = econn.flat nodes = nm.unique(ef) aux = -nm.ones((nm.max( ef ) + 1,), dtype=nm.int32) aux[nodes] = nm.arange(len(nodes), dtype=nm.int32) leconn = aux[econn].copy() assert_(nm.alltrue(nodes[leconn] == econn)) n_fa, n_fp = face_indices.shape[0], faces.shape[1] face_type = 's%d' % n_fp # Store bkey in SurfaceData, so that base function can be # queried later. bkey = 'b%s' % face_type[1:] self.ig = ig self.econn = econn self.fis = face_indices self.n_fa, self.n_fp = n_fa, n_fp self.nodes = nodes self.leconn = leconn self.face_type = face_type self.bkey = bkey self.meconn = self.mleconn = None
def __call__(self, problem=None, data=None): problem = get_default(problem, self.problem) problem.select_variables(self.variables) problem.set_equations(self.equations) problem.select_bcs(ebc_names=self.ebcs, epbc_names=self.epbcs) state = problem.create_state() state.apply_ebc() vec = eval_term_op(state, self.equations.values()[0], problem, dw_mode='vector') ## print vec.max(), vec.min() return vec
def __call__(self, volume=None, problem=None, data=None): problem = get_default(problem, self.problem) opts = self.app_options evp, dv_info = [data[ii] for ii in self.requires] output('computing eigenmomenta...') if opts.transform is not None: fun = problem.conf.get_function(opts.transform[0]) def wrap_transform(vec, shape): return fun(vec, shape, *opts.eig_vector_transform[1:]) else: wrap_transform = None tt = time.clock() eigenmomenta = compute_eigenmomenta(self.expression, opts.var_name, problem, evp.eig_vectors, wrap_transform) output('...done in %.2f s' % (time.clock() - tt)) n_eigs = evp.eigs.shape[0] mag = norm_l2_along_axis(eigenmomenta) if opts.threshold_is_relative: tol = opts.threshold * mag.max() else: tol = opts.threshold valid = nm.where(mag < tol, False, True) mask = nm.where(valid == False)[0] eigenmomenta[mask, :] = 0.0 n_zeroed = mask.shape[0] output('%d of %d eigenmomenta zeroed (under %.2e)'\ % (n_zeroed, n_eigs, tol)) out = Struct(name='eigenmomenta', n_zeroed=n_zeroed, eigenmomenta=eigenmomenta, valid=valid, to_file_txt=None) return out
def __call__(self, problem=None, data=None): problem = get_default(problem, self.problem) var_name = self.variable clist = ['data'] dn = self.data if type(dn) is list: data = problem for ii in dn: data = data.get(ii, 'None') else: data = problem.get(dn, 'None') ndof, ndim = data.shape state = {var_name: data.reshape((ndof * ndim, ))} corr_sol = CorrSolution(name=self.name, state=state, components=clist) return corr_sol
def __call__(self, volume=None, problem=None, data=None): problem = get_default(problem, self.problem) opts = self.app_options dv_info, cat = [data[ii] for ii in self.requires] output('average density:', dv_info.average_density) dim = problem.get_dim() eye = nm.eye(dim, dim, dtype=nm.float64) mtx_mass = eye * dv_info.average_density meigs, mvecs = eig(mtx_mass, mtx_b=cat, eigenvectors=True, method=opts.eigensolver) phase_velocity = 1.0 / nm.sqrt(meigs) return phase_velocity
def set_field_split(self, field_ranges, comm=None): """ Setup local PETSc ranges for fields to be used with 'fieldsplit' preconditioner. This function must be called before solving the linear system. """ comm = get_default(comm, self.comm) self.fields = [] for key, rng in six.iteritems(field_ranges): size = rng[1] - rng[0] field_is = self.petsc.IS().createStride(size, first=rng[0], step=1, comm=comm) self.fields.append((key, field_is))
def setup(self, define_dict=None, funmod=None, filename=None, required=None, other=None): define_dict = get_default(define_dict, self.__dict__) self._filename = filename self.validate(required=required, other=other) self.transform_input_trivial() self._raw = {} for key, val in define_dict.iteritems(): if isinstance(val, dict): self._raw[key] = copy(val) self.transform_input() self.funmod = funmod
def __init__(self, name, conf=None, functions=None, domain=None, fields=None, equations=None, auto_conf=True, nls=None, ls=None, ts=None, auto_solvers=True): self.name = name self.conf = conf self.functions = functions self.reset() self.ts = get_default(ts, self.get_default_ts()) if auto_conf: if equations is None: raise ValueError('missing equations in auto_conf mode!') if fields is None: variables = equations.variables fields = {} for field in [var.get_field() for var in variables]: fields[field.name] = field if domain is None: domain = fields.values()[0].domain if conf is None: self.conf = Struct(ebcs={}, epbcs={}, lcbcs={}) self.equations = equations self.fields = fields self.domain = domain if auto_solvers: if ls is None: ls = ScipyDirect({}) if nls is None: nls = Newton({}, lin_solver=ls) ev = self.get_evaluator() nls.fun = ev.eval_residual nls.fun_grad = ev.eval_tangent_matrix self.set_solvers_instances(ls=ls, nls=nls) self.setup_output()
def verify_correctors(self, sign, state0, filename, problem=None): problem = get_default(problem, self.problem) io = HDF5MeshIO(filename) ts = TimeStepper(*io.read_time_stepper()) ts.set_step(0) problem.equations.init_time(ts) variables = self.problem.get_variables() vu, vp = self.dump_variables vdp = self.verify_variables[-1] p0 = sign * state0[vp] format = '====== time %%e (step %%%dd of %%%dd) ====='\ % ((ts.n_digit,) * 2) vv = variables ok = True for step, time in ts: output(format % (time, step + 1, ts.n_step)) data = io.read_data(step) if step == 0: assert_(nm.allclose(data[vp].data, p0)) state0 = problem.create_state() state0.set_full(data[vu].data, vu) state0.set_full(data[vp].data, vp) vv[vdp].set_data(data['d' + vp].data) problem.update_time_stepper(ts) state = problem.solve(state0) state, state0 = state(), state0() err = nla.norm(state - state0) / nla.norm(state0) output(state.min(), state.max()) output(state0.min(), state0.max()) output('>>>>>', err) ok = ok and (err < 1e-12) problem.advance(ts) return ok
def get_sorted_dependencies(req_info, coef_info, compute_only): "Make corrs and coefs list sorted according to the dependencies." reqcoef_info = copy(coef_info) reqcoef_info.update(req_info) compute_names = set(get_default(compute_only, coef_info.keys())) compute_names = ['c.' + key for key in compute_names] dep_names = [] for coef_name in compute_names: requires = coef_info[coef_name[2:]].get('requires', []) deps = insert_sub_reqs(copy(requires), [], reqcoef_info)\ + [coef_name] for dep in deps: if dep not in dep_names: dep_names.append(dep) return dep_names
def get_fargs(self, mat, par_r, par_p, par_mv, mode=None, term_mode=None, diff_var=None, **kwargs): vg, _ = self.get_mapping(par_p) grad_r = self.get(par_r, 'grad') grad_p = self.get(par_p, 'grad') div_mv = self.get(par_mv, 'div') grad_mv = self.get(par_mv, 'grad').transpose((0, 1, 3, 2)).copy() return (grad_r, grad_p, div_mv, grad_mv, mat, vg, get_default(term_mode, 1))
def get_fargs(self, par_u, par_w, par_mv, mode=None, term_mode=None, diff_var=None, **kwargs): vg, _ = self.get_mapping(par_u) val_u = self.get(par_u, 'val') grad_u = grad_as_vector(self.get(par_u, 'grad')) val_w = self.get(par_w, 'val') div_mv = self.get(par_mv, 'div') grad_mv = grad_as_vector(self.get(par_mv, 'grad')) return (val_u, grad_u, val_w, div_mv, grad_mv, vg, get_default(term_mode, 1))
def __call__(self, problem=None, data=None): problem = get_default(problem, self.problem) states = nm.zeros((self.dim, ), dtype=nm.object) clist = [] eqns = {} for ir in range(self.dim): for key_eq, val_eq in self.equations.iteritems(): eqns[key_eq] = val_eq % self.eq_pars[ir] problem.set_equations(eqns) problem.select_bcs(ebc_names=self.ebcs, epbc_names=self.epbcs, lcbc_names=self.get('lcbcs', [])) problem.update_materials(problem.ts) self.init_solvers(problem) variables = problem.get_variables() if hasattr(self, 'set_variables'): if isinstance(self.set_variables, list): self.set_variables_default(variables, self.set_variables, data) else: self.set_variables(variables, **data) state = problem.solve() assert_(state.has_ebc()) states[ir] = state.get_parts() clist.append((ir, )) corr_sol = CorrSolution(name=self.name, states=states, components=clist) self.save(corr_sol, problem) return corr_sol
def __call__(self, problem=None, data=None): problem = get_default(problem, self.problem) micro_state, im = problem.micro_state macro_data = problem.homogenization_macro_data pvar = self.variable if micro_state[pvar] is not None: coors = problem.fields['pressure' + pvar[-1]].coors press = nm.dot(coors, macro_data['g' + pvar + '_0'][im])[:, 0] \ + micro_state[pvar][im] - macro_data[pvar + '_0'][im][:, 0] else: ndof = problem.fields['pressure' + pvar[-1]].n_vertex_dof press = nm.zeros((ndof, ), dtype=nm.float64) corr_sol = cb.CorrSolution(name=self.name, state={pvar: press}) return corr_sol
def save_recovery_region(mac_pb, rname, filename=None): filename = get_default(filename, os.path.join(mac_pb.output_dir, 'recovery_region.vtk')) region = mac_pb.domain.regions[rname] # Save recovery region characteristic function. out = {} mask = region.get_charfun(by_cell=False, val_by_id=False) out['vmask'] = Struct(name='output_data', mode='vertex', data=mask[:, nm.newaxis], dofs=None) mask = region.get_charfun(by_cell=True, val_by_id=False) out['cmask'] = Struct(name='output_data', mode='cell', data=mask[:, nm.newaxis, nm.newaxis, nm.newaxis], dofs=None) mac_pb.save_state(filename, out=out)
def __call__(self, problem=None, data=None): problem = get_default(problem, self.problem) problem.select_variables(self.variables) problem.set_equations(self.equations) problem.select_bcs(ebc_names=self.ebcs, epbc_names=self.epbcs, lcbc_names=self.get('lcbcs', [])) state = problem.create_state() state.apply_ebc() eqs = problem.equations eqs.set_variables_from_state(state.vec) vec = eqs.create_stripped_state_vector() eqs.time_update_materials(problem.get_timestepper()) eqs.evaluate(mode='weak', dw_mode='vector', asm_obj=vec) return vec
def solve_eigen_problem(self): opts = self.app_options pb = self.problem pb.set_equations(pb.conf.equations) pb.time_update() output('assembling lhs...') tt = time.clock() mtx_a = pb.evaluate(pb.conf.equations['lhs'], mode='weak', auto_init=True, dw_mode='matrix') output('...done in %.2f s' % (time.clock() - tt)) if 'rhs' in pb.conf.equations: output('assembling rhs...') tt = time.clock() mtx_b = pb.evaluate(pb.conf.equations['rhs'], mode='weak', dw_mode='matrix') output('...done in %.2f s' % (time.clock() - tt)) else: mtx_b = None n_eigs = get_default(opts.n_eigs, mtx_a.shape[0]) output('solving eigenvalue problem for {} values...'.format(n_eigs)) eig = Solver.any_from_conf(pb.get_solver_conf(opts.evps)) if opts.eigs_only: eigs = eig(mtx_a, mtx_b, n_eigs, eigenvectors=False) svecs = None else: eigs, svecs = eig(mtx_a, mtx_b, n_eigs, eigenvectors=True) output('...done') vecs = self.make_full(svecs) self.save_results(eigs, vecs) return Struct(pb=pb, eigs=eigs, vecs=vecs)
def get_fargs(self, mat1, mat2, par_u, par_w, par_mv, mode=None, term_mode=None, diff_var=None, **kwargs): vg, _ = self.get_mapping(par_u) grad_u = grad_as_vector(self.get(par_u, 'grad')) grad_w = grad_as_vector(self.get(par_w, 'grad')) div_mv = self.get(par_mv, 'div') grad_mv = grad_as_vector(self.get(par_mv, 'grad')) return (grad_u, grad_w, div_mv, grad_mv, mat1 * mat2, vg, get_default(term_mode, 1))
def eval_tangent_matrix(self, vec, mtx=None, is_full=False): if isinstance(vec, basestr) and vec == 'linear': return get_default(mtx, self.problem.mtx_a) if not is_full: vec = self.make_full_vec(vec) try: pb = self.problem if mtx is None: mtx = pb.mtx_a mtx = pb.equations.eval_tangent_matrices(vec, mtx) except StopIteration, exc: status = exc.args[0] output( ('error %d in term "%s" of derivative of equation "%s"' + ' with respect to variable "%s"!')\ % (status, exc.args[1].name, exc.args[2].desc, exc.args[3] ) ) raise ValueError
def main(): parser = ArgumentParser(description=__doc__, formatter_class=RawDescriptionHelpFormatter) parser.add_argument('--version', action='version', version='%(prog)s') parser.add_argument('-e', '--examples-dir', metavar='directory', action='store', dest='examples_dir', default='examples', help=help['examples_dir']) parser.add_argument('-i', '--images-dir', metavar='directory', action='store', dest='images_dir', default=None, help=help['images_dir']) parser.add_argument('-n', '--no-images', action='store_true', dest='no_images', default=False, help=help['no_images']) parser.add_argument('-o', '--output', metavar='output_filename', action='store', dest='output_filename', default='gallery/gallery.html', help=help['output_filename']) parser.add_argument('-l', '--link-prefix', metavar='prefix', action='store', dest='link_prefix', default='http://sfepy.org/doc-devel', help=help['link_prefix']) options = parser.parse_args() examples_dir = os.path.realpath(options.examples_dir) output_filename = os.path.realpath(options.output_filename) gallery_dir = os.path.dirname(output_filename) images_dir = get_default(options.images_dir, os.path.join(gallery_dir, 'images')) thumbnails_dir = os.path.join(images_dir, 'thumbnails') rst_dir = os.path.join(gallery_dir, 'examples') if not options.no_images: generate_images(images_dir, examples_dir) generate_thumbnails(thumbnails_dir, images_dir) dir_map = generate_rst_files(rst_dir, examples_dir, images_dir) generate_gallery_html(examples_dir,output_filename, gallery_dir, rst_dir, thumbnails_dir, dir_map, link_prefix=options.link_prefix)
def view_file(filename, filter_names, options, view=None): if view is None: if options.show: offscreen = False else: offscreen = get_default(options.offscreen, True) view = Viewer(filename, watch=options.watch, ffmpeg_options=options.ffmpeg_options, output_dir=options.output_dir, offscreen=offscreen) if options.only_names is not None: options.only_names = options.only_names.split(',') view(show=options.show, is_3d=options.is_3d, view=options.view, roll=options.roll, parallel_projection=options.parallel_projection, fgcolor=options.fgcolor, bgcolor=options.bgcolor, colormap=options.colormap, layout=options.layout, scalar_mode=options.scalar_mode, vector_mode=options.vector_mode, rel_scaling=options.rel_scaling, clamping=options.clamping, ranges=options.ranges, is_scalar_bar=options.is_scalar_bar, is_wireframe=options.is_wireframe, opacity=options.opacity, subdomains_args=options.subdomains_args, rel_text_width=options.rel_text_width, fig_filename=options.filename, resolution=options.resolution, filter_names=filter_names, only_names=options.only_names, group_names=options.group_names, step=options.step, time=options.time, anti_aliasing=options.anti_aliasing, domain_specific=options.domain_specific) else: view.set_source_filename(filename) view.save_image(options.filename) return view
def __call__(self, rhs, x0=None, conf=None, eps_a=None, eps_r=None, i_max=None, mtx=None, status=None, **kwargs): eps_r = get_default(eps_r, self.conf.eps_r) if (self.mg is None) or (mtx is not self.mtx): self.mg = self.solver(mtx) self.mtx = mtx sol = self.mg.solve(rhs, x0=x0, accel=conf.accel, tol=eps_r) return sol
def get_fargs(self, mat, par_b, par_u, par_r, par_mv, mode=None, term_mode=None, diff_var=None, **kwargs): vg, _ = self.get_mapping(par_u) val_b = self.get(par_b, 'val') grad_u = self.get(par_u, 'grad').transpose((0, 1, 3, 2)).copy() grad_r = self.get(par_r, 'grad') div_mv = self.get(par_mv, 'div') grad_mv = self.get(par_mv, 'grad').transpose((0, 1, 3, 2)).copy() return (val_b, grad_u, grad_r, div_mv, grad_mv, mat, vg, get_default(term_mode, 1))
def __call__(self, vec0=None, nls=None, init_fun=None, prestep_fun=None, poststep_fun=None, status=None, **kwargs): ts = self.ts nls = get_default(nls, self.nls) vec0 = init_fun(ts, vec0) prestep_fun(ts, vec0) vec = nls(vec0) poststep_fun(ts, vec) return vec
def __call__(self, problem=None, data=None): problem = get_default(problem, self.problem) var_name = self.variables[0] var = problem.get_variables(auto_create=True)[var_name] dim = problem.domain.mesh.dim nnod = var.n_nod e00 = nm.zeros((nnod, dim), dtype=nm.float64) e1 = nm.ones((nnod, ), dtype=nm.float64) ones = nm.zeros((dim, ), dtype=nm.object) clist = [] for ir in range(dim): aux = e00.copy() aux[:, ir] = e1 ones[ir] = {var_name: nm.ascontiguousarray(aux)} clist.append('pi_%d' % (ir, )) corr_sol = CorrSolution(name=self.name, states=ones, components=clist) return corr_sol