def from_conf(conf, variables, regions, materials, integrals, user=None, verbose=True): objs = OneTypeList(Equation) conf = copy(conf) ii = 0 for name, desc in conf.iteritems(): if verbose: output('equation "%s":' % name) output(desc) eq = Equation.from_desc(name, desc, variables, regions, materials, integrals, user=user) objs.append(eq) ii += 1 obj = Equations(objs) return obj
def reset_regions(self): """ Reset the list of regions associated with the domain. """ self.regions = OneTypeList(Region) self._region_stack = [] self._bnf = create_bnf(self._region_stack)
def semideep_copy(self): """Copy materials, while external data (e.g. region) remain shared.""" others = copy(self) others.update(OneTypeList(Material)) for mat in self: other = mat.copy(name=mat.name) other.reset() others.append(other) return others
def from_conf(conf): objs = OneTypeList(Function) for key, fc in conf.iteritems(): fun = Function(name = fc.name, function = fc.function, is_constant = False, extra_args = {}) objs.append(fun) obj = Functions(objs) return obj
def from_file_hdf5(filename, var_names): """TODO: do not read entire file, provide data on demand.""" io = HDF5MeshIO(filename) ts = TimeStepper(*io.read_time_stepper()) steps = nm.arange(ts.n_step, dtype=nm.int32) ths = io.read_variables_time_history(var_names, ts) objs = OneTypeList(History) for name, th in ths.iteritems(): hist = History(name, steps=steps, times=ts.times, th=th) objs.append(hist) obj = Histories(objs, dt=ts.dt, name=' '.join(var_names)) return obj
def from_conf(conf, functions, wanted=None): """ Construct Materials instance from configuration. """ if wanted is None: wanted = list(conf.keys()) objs = OneTypeList(Material) for key, mc in six.iteritems(conf): if key not in wanted: continue mat = Material.from_conf(mc, functions) objs.append(mat) obj = Materials(objs) return obj
def from_conf(conf): objs = OneTypeList(Integral) for desc in conf.itervalues(): if hasattr(desc, 'vals'): aux = Integral(desc.name, coors=desc.vals, weights=desc.weights) else: aux = Integral(desc.name, order=desc.order) objs.append(aux) obj = Integrals(objs) return obj
def read_spline_box_hdf5(filename): if not pt.isHDF5File(filename): raise ValueError, 'not a HDF5 file! (%s)' % filename fd = pt.openFile(filename, mode='r') boxes = fd.listNodes('/box') n_box = len(boxes) dim = len(fd.listNodes(boxes[0].ax)) sp_boxes = SplineBoxes(dim=dim, n_box=n_box, n_vertex=0, spbs=OneTypeList(SplineBox)) for box in boxes: spb = SplineBox() sp_boxes.spbs.append(spb) spb.ib = int(box._v_name) spb.cpi = nm.asarray(box.cpi.read()) - 1 spb.gpi = nm.asarray(box.gpi.read()) - 1 spb.cxyz = nm.asarray(box.cxyz.read()).transpose() spb.cxyz0 = spb.cxyz.copy() spb.ax = [] for axi in fd.listNodes(box.ax): spb.ax.append(nm.asarray(axi.bsc.read())) sp_boxes.n_vertex = max(sp_boxes.n_vertex, nm.amax(spb.gpi) + 1) print nm.amin(spb.gpi), nm.amax(spb.gpi) ## # Fix cpi by rebuilding :). off = 0 n0, n1, n2 = spb.cpi.shape aux = nm.arange(n0 * n1).reshape(n1, n0).transpose() for ii in xrange(n2): spb.cpi[:, :, ii] = aux + off off += n0 * n1 fd.close() for perm in cycle([n_box] * 2): if perm[0] == perm[1]: continue gpi1 = sp_boxes.spbs[perm[0]].gpi gpi2 = sp_boxes.spbs[perm[1]].gpi assert_(len(nm.intersect1d(gpi1, gpi2)) == 0) return sp_boxes
def extract_time_history(filename, extract, verbose=True): """Extract time history of a variable from a multi-time-step results file. Parameters ---------- filename : str The name of file to extract from. extract : str The description of what to extract in a string of comma-separated description items. A description item consists of: name of the variable to extract, mode ('e' for elements, 'n' for nodes), ids of the nodes or elements (given by the mode). Example: 'u n 10 15, p e 0' means variable 'u' in nodes 10, 15 and variable 'p' in element 0. verbose : bool Verbosity control. Returns ------- ths : dict The time histories in a dict with variable names as keys. If a nodal variable is requested in elements, its value is a dict of histories in the element nodes. ts : TimeStepper instance The time stepping information. """ output('extracting selected data...', verbose=verbose) output('selection:', extract, verbose=verbose) ## # Parse extractions. pes = OneTypeList(Struct) for chunk in extract.split(','): aux = chunk.strip().split() pes.append(Struct(var = aux[0], mode = aux[1], indx = map(int, aux[2:]), igs = None)) ## # Verify array limits, set igs for element data, shift indx. mesh = Mesh.from_file(filename) n_el, n_els, offs = mesh.n_el, mesh.n_els, mesh.el_offsets for pe in pes: if pe.mode == 'n': for ii in pe.indx: if (ii < 0) or (ii >= mesh.n_nod): raise ValueError('node index 0 <= %d < %d!' % (ii, mesh.n_nod)) if pe.mode == 'e': pe.igs = [] for ii, ie in enumerate(pe.indx[:]): if (ie < 0) or (ie >= n_el): raise ValueError('element index 0 <= %d < %d!' % (ie, n_el)) ig = (ie < n_els).argmax() pe.igs.append(ig) pe.indx[ii] = ie - offs[ig] ## print pes ## # Extract data. # Assumes only one element group (ignores igs)! io = MeshIO.any_from_filename(filename) ths = {} for pe in pes: mode, nname = io.read_data_header(pe.var) output(mode, nname, verbose=verbose) if ((pe.mode == 'n' and mode == 'vertex') or (pe.mode == 'e' and mode == 'cell')): th = io.read_time_history(nname, pe.indx) elif pe.mode == 'e' and mode == 'vertex': conn = mesh.conns[0] th = {} for iel in pe.indx: ips = conn[iel] th[iel] = io.read_time_history(nname, ips) else: raise ValueError('cannot extract cell data %s in nodes!' % pe.var) ths[pe.var] = th output('...done', verbose=verbose) ts = TimeStepper(*io.read_time_stepper()) return ths, ts
def create_evaluable(expression, fields, materials, variables, integrals, regions=None, ebcs=None, epbcs=None, lcbcs=None, ts=None, functions=None, auto_init=False, mode='eval', extra_args=None, verbose=True, kwargs=None): """ Create evaluable object (equations and corresponding variables) from the `expression` string. Parameters ---------- expression : str The expression to evaluate. fields : dict The dictionary of fields used in `variables`. materials : Materials instance The materials used in the expression. variables : Variables instance The variables used in the expression. integrals : Integrals instance The integrals to be used. regions : Region instance or list of Region instances The region(s) to be used. If not given, the regions defined within the fields domain are used. ebcs : Conditions instance, optional The essential (Dirichlet) boundary conditions for 'weak' mode. epbcs : Conditions instance, optional The periodic boundary conditions for 'weak' mode. lcbcs : Conditions instance, optional The linear combination boundary conditions for 'weak' mode. ts : TimeStepper instance, optional The time stepper. functions : Functions instance, optional The user functions for boundary conditions, materials etc. auto_init : bool Set values of all variables to all zeros. mode : one of 'eval', 'el_avg', 'qp', 'weak' The evaluation mode - 'weak' means the finite element assembling, 'qp' requests the values in quadrature points, 'el_avg' element averages and 'eval' means integration over each term region. extra_args : dict, optional Extra arguments to be passed to terms in the expression. verbose : bool If False, reduce verbosity. kwargs : dict, optional The variables (dictionary of (variable name) : (Variable instance)) to be used in the expression. Returns ------- equation : Equation instance The equation that is ready to be evaluated. variables : Variables instance The variables used in the equation. """ if kwargs is None: kwargs = {} if regions is not None: if isinstance(regions, Region): regions = [regions] regions = OneTypeList(Region, regions) else: regions = fields[fields.keys()[0]].domain.regions # Create temporary variables. aux_vars = Variables(variables) if extra_args is None: extra_args = kwargs else: extra_args = copy(extra_args) extra_args.update(kwargs) if ts is not None: extra_args.update({'ts' : ts}) equations = Equations.from_conf({'tmp' : expression}, aux_vars, regions, materials, integrals, user=extra_args, verbose=verbose) equations.collect_conn_info() # The true variables used in the expression. variables = equations.variables if auto_init: for var in variables: var.init_data(step=0) if mode == 'weak': equations.time_update(ts, ebcs, epbcs, lcbcs, functions, verbose=verbose) else: setup_extra_data(equations.conn_info) return equations, variables