def test_surface_evaluate(self): from sfepy.fem import FieldVariable problem = self.problem us = problem.get_variables()['us'] vec = nm.empty(us.n_dof, dtype=us.dtype) vec[:] = 1.0 us.set_data(vec) expr = 'ev_surface_integrate.isurf.Left( us )' val = problem.evaluate(expr, us=us) ok1 = nm.abs(val - 1.0) < 1e-15 self.report('with unknown: %s, value: %s, ok: %s' % (expr, val, ok1)) ps1 = FieldVariable('ps1', 'parameter', us.get_field(), 1, primary_var_name='(set-to-None)') ps1.set_data(vec) expr = 'ev_surface_integrate.isurf.Left( ps1 )' val = problem.evaluate(expr, ps1=ps1) ok2 = nm.abs(val - 1.0) < 1e-15 self.report('with parameter: %s, value: %s, ok: %s' % (expr, val, ok2)) ok2 = True return ok1 and ok2
def test_surface_evaluate(self): from sfepy.fem import FieldVariable problem = self.problem us = problem.get_variables()['us'] vec = nm.empty(us.n_dof, dtype=us.dtype) vec[:] = 1.0 us.data_from_any(vec) expr = 'di_surface_integrate.isurf.Left( us )' val = problem.evaluate(expr, us=us) ok1 = nm.abs(val - 1.0) < 1e-15 self.report('with unknown: %s, value: %s, ok: %s' % (expr, val, ok1)) ps1 = FieldVariable('ps1', 'parameter', us.get_field(), 1, primary_var_name='(set-to-None)') ps1.data_from_any(vec) expr = 'di_surface_integrate.isurf.Left( ps1 )' val = problem.evaluate(expr, ps1=ps1) ok2 = nm.abs(val - 1.0) < 1e-15 self.report('with parameter: %s, value: %s, ok: %s' % (expr, val, ok2)) ok2 = True return ok1 and ok2
def nodal_stress(out, pb, state, extend=False): ''' Calculate stresses at nodal points. ''' # Point load. mat = pb.get_materials()['Load'] P = 2.0 * mat.get_data('special', None, 'val')[1] # Calculate nodal stress. pb.time_update() stress = pb.evaluate('ev_cauchy_stress.ivn.Omega(Asphalt.D, u)', mode='qp') sfield = H1NodalVolumeField('stress', nm.float64, (3,), pb.domain.regions['Omega']) svar = FieldVariable('sigma', 'parameter', sfield, primary_var_name='(set-to-None)') svar.set_data_from_qp(stress, pb.integrals['ivn']) print '\n==================================================================' print 'Given load = %.2f N' % -P print '\nAnalytical solution' print '===================' print 'Horizontal tensile stress = %.5e MPa/mm' % (-2.*P/(nm.pi*150.)) print 'Vertical compressive stress = %.5e MPa/mm' % (-6.*P/(nm.pi*150.)) print '\nFEM solution' print '============' print 'Horizontal tensile stress = %.5e MPa/mm' % (svar()[0][0]) print 'Vertical compressive stress = %.5e MPa/mm' % (-svar()[0][1]) print '==================================================================' return out
def test_surface_evaluate(self): from sfepy.fem import FieldVariable problem = self.problem p = problem.get_variables()['p'] vec = nm.empty(p.n_dof, dtype=p.dtype) vec[:] = 1.0 p.data_from_any(vec) expr = 'd_surface_integrate.isurf.Left( p )' val = problem.evaluate(expr, p=p) ok1 = nm.abs(val - 1.0) < 1e-15 self.report('with unknown: %s, value: %s, ok: %s' \ % (expr, val, ok1)) r = FieldVariable('r', 'parameter', p.get_field(), 1, primary_var_name='(set-to-None)') r.data_from_any(vec) expr = 'd_surface_integrate.isurf.Left( r )' val = problem.evaluate(expr, r=r) ok2 = nm.abs(val - 1.0) < 1e-15 self.report('with parameter: %s, value: %s, ok: %s' \ % (expr, val, ok2)) ok2 = True return ok1 and ok2
def test_surface_evaluate(self): from sfepy.fem import FieldVariable problem = self.problem us = problem.get_variables()["us"] vec = nm.empty(us.n_dof, dtype=us.dtype) vec[:] = 1.0 us.set_data(vec) expr = "ev_surface_integrate.i.Left( us )" val = problem.evaluate(expr, us=us) ok1 = nm.abs(val - 1.0) < 1e-15 self.report("with unknown: %s, value: %s, ok: %s" % (expr, val, ok1)) ps1 = FieldVariable("ps1", "parameter", us.get_field(), primary_var_name="(set-to-None)") ps1.set_data(vec) expr = "ev_surface_integrate.i.Left( ps1 )" val = problem.evaluate(expr, ps1=ps1) ok2 = nm.abs(val - 1.0) < 1e-15 self.report("with parameter: %s, value: %s, ok: %s" % (expr, val, ok2)) ok2 = True return ok1 and ok2
def test_solving(self): from sfepy.base.base import IndexedStruct from sfepy.fem \ import FieldVariable, Material, ProblemDefinition, \ Function, Equation, Equations, Integral from sfepy.fem.conditions import Conditions, EssentialBC from sfepy.terms import Term from sfepy.solvers.ls import ScipyDirect from sfepy.solvers.nls import Newton u = FieldVariable('u', 'unknown', self.field, self.dim) v = FieldVariable('v', 'test', self.field, self.dim, primary_var_name='u') m = Material('m', lam=1.0, mu=1.0) f = Material('f', val=[[0.02], [0.01]]) bc_fun = Function('fix_u_fun', fix_u_fun, extra_args={'extra_arg' : 'hello'}) fix_u = EssentialBC('fix_u', self.gamma1, {'u.all' : bc_fun}) shift_u = EssentialBC('shift_u', self.gamma2, {'u.0' : 0.1}) integral = Integral('i', order=3) t1 = Term.new('dw_lin_elastic_iso(m.lam, m.mu, v, u)', integral, self.omega, m=m, v=v, u=u) t2 = Term.new('dw_volume_lvf(f.val, v)', integral, self.omega, f=f, v=v) eq = Equation('balance', t1 + t2) eqs = Equations([eq]) ls = ScipyDirect({}) nls_status = IndexedStruct() nls = Newton({}, lin_solver=ls, status=nls_status) pb = ProblemDefinition('elasticity', equations=eqs, nls=nls, ls=ls) ## pb.save_regions_as_groups('regions') pb.time_update(ebcs=Conditions([fix_u, shift_u])) state = pb.solve() name = op.join(self.options.out_dir, 'test_high_level_solving.vtk') pb.save_state(name, state) ok = nls_status.condition == 0 if not ok: self.report('solver did not converge!') _ok = state.has_ebc() if not _ok: self.report('EBCs violated!') ok = ok and _ok return ok
def create_subequations(self, var_names, known_var_names=None): """ Create sub-equations containing only terms with the given virtual variables. Parameters ---------- var_names : list The list of names of virtual variables. known_var_names : list The list of names of (already) known state variables. Returns ------- subequations : Equations instance The sub-equations. """ from sfepy.fem import FieldVariable known_var_names = get_default(known_var_names, []) objs = [] for iv, var_name in enumerate(var_names): terms = [ term.copy(name=term.name) for eq in self for term in eq.terms if term.get_virtual_name() == var_name ] # Make parameter variables from known state variables in terms # arguments. for known_name in known_var_names: for term in terms: if known_name in term.arg_names: ii = term.arg_names.index(known_name) state = self.variables[known_name] par = FieldVariable(known_name, 'parameter', state.field, state.n_components, primary_var_name='(set-to-None)') term.args[ii] = par term._kwargs[known_name] = par par.set_data(state()) new_terms = Terms(terms) objs.append(Equation('eq_%d' % iv, new_terms)) subequations = Equations(objs) return subequations
def test_term_arithmetics(self): from sfepy.fem import FieldVariable, Integral from sfepy.terms.terms import Term integral = Integral('i', order=3) integral_s = Integral('i', kind='s', order=3) u = FieldVariable('u', 'parameter', self.field, self.dim, primary_var_name='(set-to-None)') t1 = Term.new('d_volume(u)', integral, self.omega, u=u) t2 = Term.new('d_surface(u)', integral_s, self.gamma1, u=u) expr = 2.2j * (t1 * 5.5 - 3j * t2) * 0.25 ok = len(expr) == 2 if not ok: self.report('wrong expression length!') _ok = nm.allclose(expr[0].sign, 3.025j, rtol=1e-15, atol=0) if not _ok: self.report('wrong sign of the first term!') ok = ok and _ok _ok = nm.allclose(expr[1].sign, 1.65, rtol=1e-15, atol=0) if not _ok: self.report('wrong sign of the second term!') ok = ok and _ok return ok
def test_term_evaluation(self): from sfepy.fem import Integral, FieldVariable from sfepy.terms.terms import Term integral = Integral('i', order=3) u = FieldVariable('u', 'parameter', self.field, self.dim, primary_var_name='(set-to-None)') term = Term.new('d_volume(u)', integral, self.omega, u=u) term *= 10.0 term.setup() vol = term.evaluate() self.report('volume: %.8f == 2000.0' % vol) ok = nm.allclose(vol, 2000.0, rtol=1e-15, atol=0) ## vec = t1.evaluate() # Returns vector. ## vec = t1.evaluate(u=u_vec) # Returns the same vector. ## mtx = t1.evaluate(diff_var='u') # Returns matrix. ## val = t1.evaluate(v=u_vec, u=u_vec) # Forbidden - virtual variable ## # cannot have value. return ok
def test_volume( self ): from sfepy.fem import FieldVariable ok = True field_map = {'u' : 'vector', 'p' : 'scalar'} volumes = {} avg = 0.0 for key, term in expressions.items(): var_name = key[-1] field = self.problem.fields[field_map[var_name]] var = FieldVariable(var_name, 'parameter', field, 1, primary_var_name='(set-to-None)') val = self.problem.evaluate(term, **{var_name : var}) volumes[key] = val avg += val avg /= len(volumes) for key, val in volumes.items(): err = nm.abs( avg - val ) / nm.abs( avg ) _ok = err < 1e-12 self.report('"'"%s"'" - volume: %e' % (key, val)) self.report('"'"%s"'" - relative volume difference: %e -> %s'\ % (key, err, _ok) ) ok = ok and _ok return ok
def create_subequations(self, var_names, known_var_names=None): """ Create sub-equations containing only terms with the given virtual variables. Parameters ---------- var_names : list The list of names of virtual variables. known_var_names : list The list of names of (already) known state variables. Returns ------- subequations : Equations instance The sub-equations. """ from sfepy.fem import FieldVariable known_var_names = get_default(known_var_names, []) objs = [] for iv, var_name in enumerate(var_names): terms = [term.copy(name=term.name) for eq in self for term in eq.terms if term.get_virtual_name() == var_name] # Make parameter variables from known state variables in terms # arguments. for known_name in known_var_names: for term in terms: if known_name in term.arg_names: ii = term.arg_names.index(known_name) state = self.variables[known_name] par = FieldVariable(known_name, 'parameter', state.field, state.n_components, primary_var_name='(set-to-None)') term.args[ii] = par term._kwargs[known_name] = par par.set_data(state()) new_terms = Terms(terms) objs.append(Equation('eq_%d' % iv, new_terms)) subequations = Equations(objs) return subequations
def test_variables(self): from sfepy.fem import FieldVariable u = FieldVariable('u', 'parameter', self.field, self.dim, primary_var_name='(set-to-None)') u.set_constant(1.0) vec = u() # Nodal values. ok = nm.allclose(vec, 1.0) ## print u() ## print u.get_vector() # Coefficient vector w.r.t. the field space basis. ## print u(gamma1) ## print u.get_vector(gamma2) return ok
def test_variables(self): from sfepy.fem import FieldVariable u = FieldVariable('u', 'parameter', self.field, primary_var_name='(set-to-None)') u.set_constant(1.0) vec = u() # Nodal values. ok = nm.allclose(vec, 1.0) ## print u() ## print u.get_vector() # Coefficient vector w.r.t. the field space basis. ## print u(gamma1) ## print u.get_vector(gamma2) return ok
def test_projection_tri_quad(self): from sfepy.fem.projections import make_l2_projection source = FieldVariable('us', 'unknown', self.field, 1) coors = self.field.get_coor() vals = nm.sin(2.0 * nm.pi * coors[:,0] * coors[:,1]) source.data_from_any(vals) name = op.join(self.options.out_dir, 'test_projection_tri_quad_source.vtk') source.save_as_mesh(name) mesh = Mesh.from_file('meshes/2d/square_quad.mesh', prefix_dir=sfepy.data_dir) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') field = Field('bilinear', nm.float64, 'scalar', omega, space='H1', poly_space_base='lagrange', approx_order=1) target = FieldVariable('ut', 'unknown', field, 1) make_l2_projection(target, source) name = op.join(self.options.out_dir, 'test_projection_tri_quad_target.vtk') target.save_as_mesh(name) bbox = self.field.domain.get_mesh_bounding_box() x = nm.linspace(bbox[0, 0] + 0.001, bbox[1, 0] - 0.001, 20) y = nm.linspace(bbox[0, 1] + 0.001, bbox[1, 1] - 0.001, 20) xx, yy = nm.meshgrid(x, y) test_coors = nm.c_[xx.ravel(), yy.ravel()].copy() vec1 = source.evaluate_at(test_coors) vec2 = target.evaluate_at(test_coors) ok = (nm.abs(vec1 - vec2) < 0.01).all() return ok
def make_h1_projection_data(target, eval_data): """ Project scalar data given by a material-like `eval_data()` function to a scalar `target` field variable using the :math:`H^1` dot product. """ order = target.field.approx_order * 2 integral = Integral('i', order=order) un = target.name v = FieldVariable('v', 'test', target.field, 1, primary_var_name=un) lhs1 = Term.new('dw_volume_dot(v, %s)' % un, integral, target.field.region, v=v, **{un: target}) lhs2 = Term.new('dw_laplace(v, %s)' % un, integral, target.field.region, v=v, **{un: target}) def _eval_data(ts, coors, mode, **kwargs): if mode == 'qp': val = eval_data(ts, coors, mode, 'val', **kwargs) gval = eval_data(ts, coors, mode, 'grad', **kwargs) return {'val': val, 'gval': gval} m = Material('m', function=_eval_data) rhs1 = Term.new('dw_volume_lvf(m.val, v)', integral, target.field.region, m=m, v=v) rhs2 = Term.new('dw_diffusion_r(m.gval, v)', integral, target.field.region, m=m, v=v) eq = Equation('projection', lhs1 + lhs2 - rhs1 - rhs2) eqs = Equations([eq]) ls = ScipyDirect({}) nls_status = IndexedStruct() nls = Newton({}, lin_solver=ls, status=nls_status) pb = ProblemDefinition('aux', equations=eqs, nls=nls, ls=ls) pb.time_update() # This sets the target variable with the projection solution. pb.solve() if nls_status.condition != 0: output('H1 projection: solver did not converge!')
def test_projection_tri_quad(self): from sfepy.fem.projections import make_l2_projection source = FieldVariable("us", "unknown", self.field, 1) coors = self.field.get_coor() vals = nm.sin(2.0 * nm.pi * coors[:, 0] * coors[:, 1]) source.data_from_any(vals) name = op.join(self.options.out_dir, "test_projection_tri_quad_source.vtk") source.save_as_mesh(name) mesh = Mesh.from_file("meshes/2d/square_quad.mesh", prefix_dir=sfepy.data_dir) domain = Domain("domain", mesh) omega = domain.create_region("Omega", "all") field = H1NodalVolumeField("bilinear", nm.float64, "scalar", omega, approx_order=1) target = FieldVariable("ut", "unknown", field, 1) make_l2_projection(target, source) name = op.join(self.options.out_dir, "test_projection_tri_quad_target.vtk") target.save_as_mesh(name) bbox = self.field.domain.get_mesh_bounding_box() x = nm.linspace(bbox[0, 0] + 0.001, bbox[1, 0] - 0.001, 20) y = nm.linspace(bbox[0, 1] + 0.001, bbox[1, 1] - 0.001, 20) xx, yy = nm.meshgrid(x, y) test_coors = nm.c_[xx.ravel(), yy.ravel()].copy() vec1 = source.evaluate_at(test_coors) vec2 = target.evaluate_at(test_coors) ok = (nm.abs(vec1 - vec2) < 0.01).all() return ok
def create_mass_matrix(field): """ Create scalar mass matrix corresponding to the given field. Returns ------- mtx : csr_matrix The mass matrix in CSR format. """ u = FieldVariable('u', 'unknown', field, 1) v = FieldVariable('v', 'test', field, 1, primary_var_name='u') integral = Integral('i', order=field.approx_order * 2) term = Term.new('dw_volume_dot(v, u)', integral, field.region, v=v, u=u) eq = Equation('aux', term) eqs = Equations([eq]) eqs.time_update(None) dummy = eqs.create_state_vector() mtx = eqs.create_matrix_graph() mtx = eqs.eval_tangent_matrices(dummy, mtx) return mtx
def nodal_stress(out, pb, state, extend=False): ''' Calculate stresses at nodal points. ''' # Point load. mat = pb.get_materials()['Load'] P = 2.0 * mat.get_data('special', None, 'val')[1] # Calculate nodal stress. pb.time_update() stress = pb.evaluate('ev_cauchy_stress.ivn.Omega(Asphalt.D, u)', mode='qp') sfield = H1NodalVolumeField('stress', nm.float64, (3, ), pb.domain.regions['Omega']) svar = FieldVariable('sigma', 'parameter', sfield, 3, primary_var_name='(set-to-None)') svar.set_data_from_qp(stress, pb.integrals['ivn']) print '\n==================================================================' print 'Given load = %.2f N' % -P print '\nAnalytical solution' print '===================' print 'Horizontal tensile stress = %.5e MPa/mm' % (-2. * P / (nm.pi * 150.)) print 'Vertical compressive stress = %.5e MPa/mm' % (-6. * P / (nm.pi * 150.)) print '\nFEM solution' print '============' print 'Horizontal tensile stress = %.5e MPa/mm' % (svar()[0][0]) print 'Vertical compressive stress = %.5e MPa/mm' % (-svar()[0][1]) print '==================================================================' return out
def get_volume(problem, field_name, region_name, quad_order=1): """ Get volume of a given region using integration defined by a given field. Both the region and the field have to be defined in `problem`. """ from sfepy.fem import FieldVariable field = problem.fields[field_name] var = FieldVariable('u', 'parameter', field, 1, primary_var_name='(set-to-None)') vol = problem.evaluate('d_volume.%d.%s( u )' % (quad_order, region_name), u=var) return vol
field_u = Field.from_args('displacement', np.float64, 'vector', omega, 1) u = FieldVariable('u', 'unknown', field_u, mesh.dim) v = FieldVariable('v', 'test', field_u, mesh.dim, primary_var_name='u') lam = 10.0 # Lame parameters. mu = 5.0 te = 0.5 # Thermal expansion coefficient. T0 = 20.0 # Background temperature. eye_sym = np.array([[1], [1], [0]], dtype=np.float64) m = Material('m', lam=lam, mu=mu, alpha=te * eye_sym) t2 = FieldVariable('t', 'parameter', field_t, 1, primary_var_name='(set-to-None)') t2.set_data(t() - T0) term1 = Term.new('dw_lin_elastic_iso(m.lam, m.mu, v, u)', integral, omega, m=m, v=v, u=u) term2 = Term.new('dw_biot(m.alpha, v, t)', integral, omega, m=m, v=v, t=t2) eq = Equation('temperature', term1 - term2) eqs = Equations([eq]) u_bottom = EssentialBC('u_bottom', bottom, {'u.all' : 0.0}) u_top = EssentialBC('u_top', top, {'u.[0]' : 0.0}) pb.set_equations_instance(eqs, keep_solvers=True)
def make_term_args(arg_shapes, arg_kinds, arg_types, ats_mode, domain): from sfepy.base.base import basestr from sfepy.fem import Field, FieldVariable, Material, Variables, Materials from sfepy.mechanics.tensors import dim2sym omega = domain.regions['Omega'] dim = domain.shape.dim sym = dim2sym(dim) def _parse_scalar_shape(sh): if isinstance(sh, basestr): if sh == 'D': return dim elif sh == 'S': return sym elif sh == 'N': # General number ;) return 5 else: return int(sh) else: return sh def _parse_tuple_shape(sh): if isinstance(sh, basestr): return [_parse_scalar_shape(ii.strip()) for ii in sh.split(',')] else: return (int(sh), ) args = {} str_args = [] materials = [] variables = [] for ii, arg_kind in enumerate(arg_kinds): if ats_mode is not None: extended_ats = arg_types[ii] + ('/%s' % ats_mode) else: extended_ats = arg_types[ii] try: sh = arg_shapes[arg_types[ii]] except KeyError: sh = arg_shapes[extended_ats] if arg_kind.endswith('variable'): shape = _parse_scalar_shape(sh[0] if isinstance(sh, tuple) else sh) field = Field.from_args('f%d' % ii, nm.float64, shape, omega, approx_order=1) if arg_kind == 'virtual_variable': if sh[1] is not None: istate = arg_types.index(sh[1]) else: # Only virtual variable in arguments. istate = -1 # -> Make fake variable. var = FieldVariable('u-1', 'unknown', field, shape) var.set_constant(0.0) variables.append(var) var = FieldVariable('v', 'test', field, shape, primary_var_name='u%d' % istate) elif arg_kind == 'state_variable': var = FieldVariable('u%d' % ii, 'unknown', field, shape) var.set_constant(0.0) elif arg_kind == 'parameter_variable': var = FieldVariable('p%d' % ii, 'parameter', field, shape, primary_var_name='(set-to-None)') var.set_constant(0.0) variables.append(var) str_args.append(var.name) args[var.name] = var elif arg_kind.endswith('material'): if sh is None: # Switched-off opt_material. continue prefix = '' if isinstance(sh, basestr): aux = sh.split(':') if len(aux) == 2: prefix, sh = aux shape = _parse_tuple_shape(sh) if (len(shape) > 1) or (shape[0] > 1): # Array. values = { '%sc%d' % (prefix, ii): nm.ones(shape, dtype=nm.float64) } elif (len(shape) == 1) and (shape[0] == 1): # Single scalar as a special value. values = {'.c%d' % ii: 1.0} else: raise ValueError('wrong material shape! (%s)' % shape) mat = Material('m%d' % ii, values=values) materials.append(mat) str_args.append(mat.name + '.' + 'c%d' % ii) args[mat.name] = mat else: str_args.append('user%d' % ii) args[str_args[-1]] = None materials = Materials(materials) variables = Variables(variables) return args, str_args, materials, variables
def main(): from sfepy import data_dir parser = OptionParser(usage=usage, version='%prog') parser.add_option('-s', '--show', action="store_true", dest='show', default=False, help=help['show']) options, args = parser.parse_args() mesh = Mesh.from_file(data_dir + '/meshes/2d/rectangle_tri.mesh') domain = Domain('domain', mesh) min_x, max_x = domain.get_mesh_bounding_box()[:, 0] eps = 1e-8 * (max_x - min_x) omega = domain.create_region('Omega', 'all') gamma1 = domain.create_region('Gamma1', 'nodes in x < %.10f' % (min_x + eps)) gamma2 = domain.create_region('Gamma2', 'nodes in x > %.10f' % (max_x - eps)) field = H1NodalVolumeField('fu', nm.float64, 'vector', omega, approx_order=2) u = FieldVariable('u', 'unknown', field, mesh.dim) v = FieldVariable('v', 'test', field, mesh.dim, primary_var_name='u') m = Material('m', lam=1.0, mu=1.0) f = Material('f', val=[[0.02], [0.01]]) integral = Integral('i', order=3) t1 = Term.new('dw_lin_elastic_iso(m.lam, m.mu, v, u)', integral, omega, m=m, v=v, u=u) t2 = Term.new('dw_volume_lvf(f.val, v)', integral, omega, f=f, v=v) eq = Equation('balance', t1 + t2) eqs = Equations([eq]) fix_u = EssentialBC('fix_u', gamma1, {'u.all': 0.0}) bc_fun = Function('shift_u_fun', shift_u_fun, extra_args={'shift': 0.01}) shift_u = EssentialBC('shift_u', gamma2, {'u.0': bc_fun}) ls = ScipyDirect({}) nls_status = IndexedStruct() nls = Newton({}, lin_solver=ls, status=nls_status) pb = ProblemDefinition('elasticity', equations=eqs, nls=nls, ls=ls) pb.save_regions_as_groups('regions') pb.time_update(ebcs=Conditions([fix_u, shift_u])) vec = pb.solve() print nls_status pb.save_state('linear_elasticity.vtk', vec) if options.show: view = Viewer('linear_elasticity.vtk') view(vector_mode='warp_norm', rel_scaling=2, is_scalar_bar=True, is_wireframe=True)
def main(): parser = OptionParser(usage=usage, version='%prog') parser.add_option('-b', '--basis', metavar='name', action='store', dest='basis', default='lagrange', help=help['basis']) parser.add_option('-d', '--derivative', metavar='d', type=int, action='store', dest='derivative', default=0, help=help['derivative']) parser.add_option('-n', '--max-order', metavar='order', type=int, action='store', dest='max_order', default=2, help=help['max_order']) parser.add_option('-g', '--geometry', metavar='name', action='store', dest='geometry', default='2_4', help=help['geometry']) parser.add_option('-m', '--mesh', metavar='mesh', action='store', dest='mesh', default=None, help=help['mesh']) parser.add_option('', '--permutations', metavar='permutations', action='store', dest='permutations', default=None, help=help['permutations']) parser.add_option('', '--dofs', metavar='dofs', action='store', dest='dofs', default=None, help=help['dofs']) parser.add_option('-l', '--lin-options', metavar='options', action='store', dest='lin_options', default='min_level=2,max_level=5,eps=1e-3', help=help['lin_options']) parser.add_option('', '--plot-dofs', action='store_true', dest='plot_dofs', default=False, help=help['plot_dofs']) options, args = parser.parse_args() if len(args) == 1: output_dir = args[0] else: parser.print_help(), return output('polynomial space:', options.basis) output('max. order:', options.max_order) lin = Struct(kind='adaptive', min_level=2, max_level=5, eps=1e-3) for opt in options.lin_options.split(','): key, val = opt.split('=') setattr(lin, key, eval(val)) if options.mesh is None: dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output('reference element geometry:') output(' dimension: %d, vertices: %d' % (dim, n_ep)) gel = GeometryElement(options.geometry) gps = PolySpace.any_from_args(None, gel, 1, base=options.basis) ps = PolySpace.any_from_args(None, gel, options.max_order, base=options.basis) n_digit, _format = get_print_info(ps.n_nod, fill='0') name_template = os.path.join(output_dir, 'bf_%s.vtk' % _format) for ip in get_dofs(options.dofs, ps.n_nod): output('shape function %d...' % ip) def eval_dofs(iels, rx): if options.derivative == 0: bf = ps.eval_base(rx).squeeze() rvals = bf[None, :, ip:ip+1] else: bfg = ps.eval_base(rx, diff=True) rvals = bfg[None, ..., ip] return rvals def eval_coors(iels, rx): bf = gps.eval_base(rx).squeeze() coors = nm.dot(bf, gel.coors)[None, ...] return coors (level, coors, conn, vdofs, mat_ids) = create_output(eval_dofs, eval_coors, 1, ps, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) out = { 'bf' : Struct(name='output_data', mode='vertex', data=vdofs, var_name='bf', dofs=None) } mesh = Mesh.from_data('bf_mesh', coors, None, [conn], [mat_ids], [options.geometry]) name = name_template % ip mesh.write(name, out=out) output('...done (%s)' % name) else: mesh = Mesh.from_file(options.mesh) output('mesh geometry:') output(' dimension: %d, vertices: %d, elements: %d' % (mesh.dim, mesh.n_nod, mesh.n_el)) domain = Domain('domain', mesh) if options.permutations: permutations = [int(ii) for ii in options.permutations.split(',')] output('using connectivity permutations:', permutations) for group in domain.iter_groups(): perms = group.gel.get_conn_permutations()[permutations] offsets = nm.arange(group.shape.n_el) * group.shape.n_ep group.conn[:] = group.conn.take(perms + offsets[:, None]) domain.setup_facets() omega = domain.create_region('Omega', 'all') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=options.max_order, poly_space_base=options.basis) var = FieldVariable('u', 'unknown', field, 1) if options.plot_dofs: import sfepy.postprocess.plot_dofs as pd group = domain.groups[0] ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges) ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn) ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn) pd.plt.show() output('dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) n_digit, _format = get_print_info(var.n_dof, fill='0') name_template = os.path.join(output_dir, 'dof_%s.vtk' % _format) for ip in get_dofs(options.dofs, var.n_dof): output('dof %d...' % ip) vec.fill(0.0) vec[ip] = 1.0 var.data_from_any(vec) if options.derivative == 0: out = var.create_output(vec, linearization=lin) else: out = create_expression_output('ev_grad.ie.Elements(u)', 'u', 'f', {'f' : field}, None, Variables([var]), mode='qp', verbose=False, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) name = name_template % ip out['u'].mesh.write(name, out=out) output('...done (%s)' % name)
def save_basis_on_mesh(mesh, options, output_dir, lin, permutations=None, suffix=''): if permutations is not None: mesh = mesh.copy() for ig, conn in enumerate(mesh.conns): gel = GeometryElement(mesh.descs[ig]) perms = gel.get_conn_permutations()[permutations] n_el, n_ep = conn.shape offsets = nm.arange(n_el) * n_ep conn[:] = conn.take(perms + offsets[:, None]) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=options.max_order, poly_space_base=options.basis) var = FieldVariable('u', 'unknown', field, 1) if options.plot_dofs: import sfepy.postprocess.plot_dofs as pd group = domain.groups[0] ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges) ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn) ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn) if options.dofs is not None: ax = pd.plot_nodes(ax, field.get_coor(), field.aps[0].econn, field.aps[0].interp.poly_spaces['v'].nodes, get_dofs(options.dofs, var.n_dof)) pd.plt.show() output('dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) n_digit, _format = get_print_info(var.n_dof, fill='0') name_template = os.path.join(output_dir, 'dof_%s%s.vtk' % (_format, suffix)) for ip in get_dofs(options.dofs, var.n_dof): output('dof %d...' % ip) vec.fill(0.0) vec[ip] = 1.0 var.set_data(vec) if options.derivative == 0: out = var.create_output(vec, linearization=lin) else: out = create_expression_output('ev_grad.ie.Elements(u)', 'u', 'f', {'f': field}, None, Variables([var]), mode='qp', verbose=False, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) name = name_template % ip ensure_path(name) out['u'].mesh.write(name, out=out) output('...done (%s)' % name)
def make_term_args(arg_shapes, arg_kinds, arg_types, ats_mode, domain): from sfepy.base.base import basestr from sfepy.fem import Field, FieldVariable, Material, Variables, Materials from sfepy.mechanics.tensors import dim2sym omega = domain.regions['Omega'] dim = domain.shape.dim sym = dim2sym(dim) def _parse_scalar_shape(sh): if isinstance(sh, basestr): if sh == 'D': return dim elif sh == 'S': return sym elif sh == 'N': # General number ;) return 5 else: return int(sh) else: return sh def _parse_tuple_shape(sh): if isinstance(sh, basestr): return [_parse_scalar_shape(ii.strip()) for ii in sh.split(',')] else: return (int(sh),) args = {} str_args = [] materials = [] variables = [] for ii, arg_kind in enumerate(arg_kinds): if ats_mode is not None: extended_ats = arg_types[ii] + ('/%s' % ats_mode) else: extended_ats = arg_types[ii] try: sh = arg_shapes[arg_types[ii]] except KeyError: sh = arg_shapes[extended_ats] if arg_kind.endswith('variable'): shape = _parse_scalar_shape(sh[0] if isinstance(sh, tuple) else sh) field = Field.from_args('f%d' % ii, nm.float64, shape, omega, approx_order=1) if arg_kind == 'virtual_variable': if sh[1] is not None: istate = arg_types.index(sh[1]) else: # Only virtual variable in arguments. istate = -1 # -> Make fake variable. var = FieldVariable('u-1', 'unknown', field) var.set_constant(0.0) variables.append(var) var = FieldVariable('v', 'test', field, primary_var_name='u%d' % istate) elif arg_kind == 'state_variable': var = FieldVariable('u%d' % ii, 'unknown', field) var.set_constant(0.0) elif arg_kind == 'parameter_variable': var = FieldVariable('p%d' % ii, 'parameter', field, primary_var_name='(set-to-None)') var.set_constant(0.0) variables.append(var) str_args.append(var.name) args[var.name] = var elif arg_kind.endswith('material'): if sh is None: # Switched-off opt_material. continue prefix = '' if isinstance(sh, basestr): aux = sh.split(':') if len(aux) == 2: prefix, sh = aux shape = _parse_tuple_shape(sh) if (len(shape) > 1) or (shape[0] > 1): # Array. values = {'%sc%d' % (prefix, ii) : nm.ones(shape, dtype=nm.float64)} elif (len(shape) == 1) and (shape[0] == 1): # Single scalar as a special value. values = {'.c%d' % ii : 1.0} else: raise ValueError('wrong material shape! (%s)' % shape) mat = Material('m%d' % ii, values=values) materials.append(mat) str_args.append(mat.name + '.' + 'c%d' % ii) args[mat.name] = mat else: str_args.append('user%d' % ii) args[str_args[-1]] = None materials = Materials(materials) variables = Variables(variables) return args, str_args, materials, variables
def save_basis_on_mesh(mesh, options, output_dir, lin, permutations=None, suffix=''): if permutations is not None: mesh = mesh.copy() for ig, conn in enumerate(mesh.conns): gel = GeometryElement(mesh.descs[ig]) perms = gel.get_conn_permutations()[permutations] n_el, n_ep = conn.shape offsets = nm.arange(n_el) * n_ep conn[:] = conn.take(perms + offsets[:, None]) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=options.max_order, poly_space_base=options.basis) var = FieldVariable('u', 'unknown', field, 1) if options.plot_dofs: import sfepy.postprocess.plot_dofs as pd group = domain.groups[0] ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges) ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn) ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn) if options.dofs is not None: ax = pd.plot_nodes(ax, field.get_coor(), field.aps[0].econn, field.aps[0].interp.poly_spaces['v'].nodes, get_dofs(options.dofs, var.n_dof)) pd.plt.show() output('dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) n_digit, _format = get_print_info(var.n_dof, fill='0') name_template = os.path.join(output_dir, 'dof_%s%s.vtk' % (_format, suffix)) for ip in get_dofs(options.dofs, var.n_dof): output('dof %d...' % ip) vec.fill(0.0) vec[ip] = 1.0 var.set_data(vec) if options.derivative == 0: out = var.create_output(vec, linearization=lin) else: out = create_expression_output('ev_grad.ie.Elements(u)', 'u', 'f', {'f' : field}, None, Variables([var]), mode='qp', verbose=False, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) name = name_template % ip ensure_path(name) out['u'].mesh.write(name, out=out) output('...done (%s)' % name)
def _gen_common_data(orders, gels, report): import sfepy from sfepy.base.base import Struct from sfepy.linalg import combine from sfepy.fem import Mesh, Domain, Field, FieldVariable, Integral from sfepy.fem.global_interp import get_ref_coors bases = ([ii for ii in combine([['2_4', '3_8'], ['lagrange', 'lobatto']])] + [ii for ii in combine([['2_3', '3_4'], ['lagrange']])]) for geom, poly_space_base in bases: report('geometry: %s, base: %s' % (geom, poly_space_base)) order = orders[geom] integral = Integral('i', order=order) aux = '' if geom in ['2_4', '3_8'] else 'z' mesh0 = Mesh.from_file('meshes/elements/%s_2%s.mesh' % (geom, aux), prefix_dir=sfepy.data_dir) gel = gels[geom] perms = gel.get_conn_permutations() qps, qp_weights = integral.get_qp(gel.surface_facet.name) zz = nm.zeros_like(qps[:, :1]) qps = nm.hstack(([qps] + [zz])) shift = shifts[geom] rcoors = nm.ascontiguousarray(qps + shift[:1, :] - shift[1:, :]) ccoors = nm.ascontiguousarray(qps + shift[:1, :] + shift[1:, :]) for ir, pr in enumerate(perms): for ic, pc in enumerate(perms): report('ir: %d, ic: %d' % (ir, ic)) report('pr: %s, pc: %s' % (pr, pc)) mesh = mesh0.copy() conn = mesh.conns[0] conn[0, :] = conn[0, pr] conn[1, :] = conn[1, pc] cache = Struct(mesh=mesh) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') region = domain.create_region('Facet', rsels[geom], 'facet') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=order, poly_space_base=poly_space_base) var = FieldVariable('u', 'unknown', field, 1) report('# dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) ap = field.aps[0] ps = ap.interp.poly_spaces['v'] dofs = field.get_dofs_in_region_group(region, 0, merge=False) edofs, fdofs = nm.unique(dofs[1]), nm.unique(dofs[2]) rrc, rcells, rstatus = get_ref_coors(field, rcoors, cache=cache) crc, ccells, cstatus = get_ref_coors(field, ccoors, cache=cache) assert_((rstatus == 0).all() and (cstatus == 0).all()) yield (geom, poly_space_base, qp_weights, mesh, ir, ic, ap, ps, rrc, rcells[0, 1], crc, ccells[0, 1], vec, edofs, fdofs)
def test_projection_tri_quad(self): from sfepy.fem.projections import make_l2_projection source = FieldVariable('us', 'unknown', self.field, 1) coors = self.field.get_coor() vals = nm.sin(2.0 * nm.pi * coors[:,0] * coors[:,1]) source.set_data(vals) name = op.join(self.options.out_dir, 'test_projection_tri_quad_source.vtk') source.save_as_mesh(name) mesh = Mesh.from_file('meshes/2d/square_quad.mesh', prefix_dir=sfepy.data_dir) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') field = H1NodalVolumeField('bilinear', nm.float64, 'scalar', omega, approx_order=1) target = FieldVariable('ut', 'unknown', field, 1) make_l2_projection(target, source) name = op.join(self.options.out_dir, 'test_projection_tri_quad_target.vtk') target.save_as_mesh(name) bbox = self.field.domain.get_mesh_bounding_box() x = nm.linspace(bbox[0, 0] + 0.001, bbox[1, 0] - 0.001, 20) y = nm.linspace(bbox[0, 1] + 0.001, bbox[1, 1] - 0.001, 20) xx, yy = nm.meshgrid(x, y) test_coors = nm.c_[xx.ravel(), yy.ravel()].copy() vec1 = source.evaluate_at(test_coors) vec2 = target.evaluate_at(test_coors) ok = (nm.abs(vec1 - vec2) < 0.01).all() return ok
def main(): parser = OptionParser(usage=usage, version='%prog') parser.add_option('-b', '--basis', metavar='name', action='store', dest='basis', default='lagrange', help=help['basis']) parser.add_option('-d', '--derivative', metavar='d', type=int, action='store', dest='derivative', default=0, help=help['derivative']) parser.add_option('-n', '--max-order', metavar='order', type=int, action='store', dest='max_order', default=2, help=help['max_order']) parser.add_option('-g', '--geometry', metavar='name', action='store', dest='geometry', default='2_4', help=help['geometry']) parser.add_option('-m', '--mesh', metavar='mesh', action='store', dest='mesh', default=None, help=help['mesh']) parser.add_option('', '--permutations', metavar='permutations', action='store', dest='permutations', default=None, help=help['permutations']) parser.add_option('', '--dofs', metavar='dofs', action='store', dest='dofs', default=None, help=help['dofs']) parser.add_option('-l', '--lin-options', metavar='options', action='store', dest='lin_options', default='min_level=2,max_level=5,eps=1e-3', help=help['lin_options']) parser.add_option('', '--plot-dofs', action='store_true', dest='plot_dofs', default=False, help=help['plot_dofs']) options, args = parser.parse_args() if len(args) == 1: output_dir = args[0] else: parser.print_help(), return output('polynomial space:', options.basis) output('max. order:', options.max_order) lin = Struct(kind='adaptive', min_level=2, max_level=5, eps=1e-3) for opt in options.lin_options.split(','): key, val = opt.split('=') setattr(lin, key, eval(val)) if options.mesh is None: dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output('reference element geometry:') output(' dimension: %d, vertices: %d' % (dim, n_ep)) gel = GeometryElement(options.geometry) gps = PolySpace.any_from_args(None, gel, 1, base=options.basis) ps = PolySpace.any_from_args(None, gel, options.max_order, base=options.basis) n_digit, _format = get_print_info(ps.n_nod, fill='0') name_template = os.path.join(output_dir, 'bf_%s.vtk' % _format) for ip in get_dofs(options.dofs, ps.n_nod): output('shape function %d...' % ip) def eval_dofs(iels, rx): if options.derivative == 0: bf = ps.eval_base(rx).squeeze() rvals = bf[None, :, ip:ip + 1] else: bfg = ps.eval_base(rx, diff=True) rvals = bfg[None, ..., ip] return rvals def eval_coors(iels, rx): bf = gps.eval_base(rx).squeeze() coors = nm.dot(bf, gel.coors)[None, ...] return coors (level, coors, conn, vdofs, mat_ids) = create_output(eval_dofs, eval_coors, 1, ps, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) out = { 'bf': Struct(name='output_data', mode='vertex', data=vdofs, var_name='bf', dofs=None) } mesh = Mesh.from_data('bf_mesh', coors, None, [conn], [mat_ids], [options.geometry]) name = name_template % ip mesh.write(name, out=out) output('...done (%s)' % name) else: mesh = Mesh.from_file(options.mesh) output('mesh geometry:') output(' dimension: %d, vertices: %d, elements: %d' % (mesh.dim, mesh.n_nod, mesh.n_el)) domain = Domain('domain', mesh) if options.permutations: permutations = [int(ii) for ii in options.permutations.split(',')] output('using connectivity permutations:', permutations) for group in domain.iter_groups(): perms = group.gel.get_conn_permutations()[permutations] offsets = nm.arange(group.shape.n_el) * group.shape.n_ep group.conn[:] = group.conn.take(perms + offsets[:, None]) domain.setup_facets() omega = domain.create_region('Omega', 'all') field = Field.from_args('f', nm.float64, shape=1, region=omega, approx_order=options.max_order, poly_space_base=options.basis) var = FieldVariable('u', 'unknown', field, 1) if options.plot_dofs: import sfepy.postprocess.plot_dofs as pd group = domain.groups[0] ax = pd.plot_mesh(None, mesh.coors, mesh.conns[0], group.gel.edges) ax = pd.plot_global_dofs(ax, field.get_coor(), field.aps[0].econn) ax = pd.plot_local_dofs(ax, field.get_coor(), field.aps[0].econn) if options.dofs is not None: ax = pd.plot_nodes(ax, field.get_coor(), field.aps[0].econn, field.aps[0].interp.poly_spaces['v'].nodes, get_dofs(options.dofs, var.n_dof)) pd.plt.show() output('dofs: %d' % var.n_dof) vec = nm.empty(var.n_dof, dtype=var.dtype) n_digit, _format = get_print_info(var.n_dof, fill='0') name_template = os.path.join(output_dir, 'dof_%s.vtk' % _format) for ip in get_dofs(options.dofs, var.n_dof): output('dof %d...' % ip) vec.fill(0.0) vec[ip] = 1.0 var.set_data(vec) if options.derivative == 0: out = var.create_output(vec, linearization=lin) else: out = create_expression_output('ev_grad.ie.Elements(u)', 'u', 'f', {'f': field}, None, Variables([var]), mode='qp', verbose=False, min_level=lin.min_level, max_level=lin.max_level, eps=lin.eps) name = name_template % ip out['u'].mesh.write(name, out=out) output('...done (%s)' % name)
def main(): parser = OptionParser(usage=usage, version='%prog') parser.add_option('-b', '--basis', metavar='name', action='store', dest='basis', default='lagrange', help=help['basis']) parser.add_option('-n', '--max-order', metavar='order', type=int, action='store', dest='max_order', default=10, help=help['max_order']) parser.add_option('-m', '--matrix', metavar='type', action='store', dest='matrix_type', default='laplace', help=help['matrix_type']) parser.add_option('-g', '--geometry', metavar='name', action='store', dest='geometry', default='2_4', help=help['geometry']) options, args = parser.parse_args() dim, n_ep = int(options.geometry[0]), int(options.geometry[2]) output('reference element geometry:') output(' dimension: %d, vertices: %d' % (dim, n_ep)) n_c = {'laplace': 1, 'elasticity': dim}[options.matrix_type] output('matrix type:', options.matrix_type) output('number of variable components:', n_c) output('polynomial space:', options.basis) output('max. order:', options.max_order) mesh = Mesh.from_file(data_dir + '/meshes/elements/%s_1.mesh' % options.geometry) domain = Domain('domain', mesh) omega = domain.create_region('Omega', 'all') orders = nm.arange(1, options.max_order + 1, dtype=nm.int) conds = [] order_fix = 0 if options.geometry in ['2_4', '3_8'] else 1 for order in orders: output('order:', order, '...') field = Field.from_args('fu', nm.float64, n_c, omega, approx_order=order, space='H1', poly_space_base=options.basis) to = field.approx_order quad_order = 2 * (max(to - order_fix, 0)) output('quadrature order:', quad_order) integral = Integral('i', order=quad_order) qp, _ = integral.get_qp(options.geometry) output('number of quadrature points:', qp.shape[0]) u = FieldVariable('u', 'unknown', field, n_c) v = FieldVariable('v', 'test', field, n_c, primary_var_name='u') m = Material('m', lam=1.0, mu=1.0) if options.matrix_type == 'laplace': term = Term.new('dw_laplace(m.mu, v, u)', integral, omega, m=m, v=v, u=u) n_zero = 1 else: assert_(options.matrix_type == 'elasticity') term = Term.new('dw_lin_elastic_iso(m.lam, m.mu, v, u)', integral, omega, m=m, v=v, u=u) n_zero = (dim + 1) * dim / 2 term.setup() output('assembling...') tt = time.clock() mtx, iels = term.evaluate(mode='weak', diff_var='u') output('...done in %.2f s' % (time.clock() - tt)) mtx = mtx[0][0, 0] try: assert_(nm.max(nm.abs(mtx - mtx.T)) < 1e-10) except: from sfepy.base.base import debug debug() output('matrix shape:', mtx.shape) eigs = eig(mtx, method='eig.sgscipy', eigenvectors=False) eigs.sort() # Zero 'true' zeros. eigs[:n_zero] = 0.0 ii = nm.where(eigs < 0.0)[0] if len(ii): output('matrix is not positive semi-definite!') ii = nm.where(eigs[n_zero:] < 1e-12)[0] if len(ii): output('matrix has more than %d zero eigenvalues!' % n_zero) output('smallest eigs:\n', eigs[:10]) ii = nm.where(eigs > 0.0)[0] emin, emax = eigs[ii[[0, -1]]] output('min:', emin, 'max:', emax) cond = emax / emin conds.append(cond) output('condition number:', cond) output('...done') plt.figure(1) plt.semilogy(orders, conds) plt.xticks(orders, orders) plt.xlabel('polynomial order') plt.ylabel('condition number') plt.grid() plt.figure(2) plt.loglog(orders, conds) plt.xticks(orders, orders) plt.xlabel('polynomial order') plt.ylabel('condition number') plt.grid() plt.show()