def clone(self, newmesh, copy_field, copy_equation, notifications): # Create a copy of this subproblem in the given mesh, which is # either our mesh or a copy of it. 'notifications' is a set # of switchboard messages which will be sent by the calling # function when all the cloning is complete. subp = self.getObject() newsubptype = self.subptype.clone() newsubpobj = newsubptype.create() # create new subproblem context with a temporary name so that # it won't overwrite an old subproblem until we're done with # the old one (in case we're recreating an old subproblem, as # in the Revert mesh modifier). It's up to the caller to # delete the original subproblems and rename the new ones. desiredname = newmesh.path() + ':' + self.name() temppath = newmesh.path() + ":" + subproblems.uniqueName(desiredname) newsubpctxt = newmesh.newSubProblem(newsubpobj, newsubptype, temppath) oldmesh = self.getParent() # CSubProblem.set_mesh() must have been called with the new # meshctxt *before* this point, or new DoFs and NodalEqns # won't be stored in the right object. Mesh.setFEMesh must be # called *before* calling CSubProblem.set_mesh() because it # uses Mesh.getObject() to get the FEMesh. But if we do that, # then the field planarities won't be retrieved correctly from # the Mesh, because it will use the wrong FEMesh. Therefore, # this routine does not set the planarity at all. Planarity # isn't really a subproblem responsibility anyway. if copy_field: for field in self.all_compound_fields(): newsubpobj.define_field(field) notifications.add( ("field defined", desiredname, field.name(), 1)) if subp.is_active_field(field): newsubpobj.activate_field(field) notifications.add(("field activated", desiredname, field.name(), 1)) if copy_equation: for eqn in self.all_equations(): newsubpobj.activate_equation(eqn) notifications.add( ("equation activated", desiredname, eqn.name(), 1)) if self.solver_mode is not None: newsubpctxt.solver_mode = self.solver_mode.clone() # The times and dof values, etc, will be reset when the fields # are initialized, which isn't done here. installedTime, # startValues, and endValues don't have to be set here at all. newsubpctxt.startTime = 0.0 newsubpctxt.endTime = None newsubpctxt.solveFlag = self.solveFlag return newsubpctxt
def _edit_subproblem(menuitem, name, subproblem): ## if parallel_enable.enabled(): ## ## TODO: out of date ## ipcsubpmenu.Edit(name=name, subproblem=subproblem) ## return oldsubp = ooflib.engine.subproblemcontext.subproblems[name] if oldsubp.name() == ooflib.engine.mesh.defaultSubProblemName: raise ooferror.ErrUserError("You can't edit the default Subproblem!") meshctxt = oldsubp.getParent() oldsubp.reserve() oldsubp.begin_writing() try: oldsubpobj = oldsubp.getObject() # Save lists of fields, etc, so that they can be restored in # the new subproblem. oldfields = oldsubp.all_compound_fields() # only CompoundFields oldactivefields = [field for field in oldfields if oldsubpobj.is_active_field(field)] oldeqns = oldsubp.all_equations() oldsubp.destroy() finally: oldsubp.end_writing() oldsubp.cancel_reservation() # Create context for new subproblem. newsubpobj = subproblem.create() newsubp = meshctxt.newSubProblem(newsubpobj, subproblem, name) meshctxt.reserve() meshctxt.begin_writing() # Gather switchboard messages and send them all after the lock has # been released. notifications = [] try: # Restore field and equation state saved from old subproblem. for field in oldfields: newsubpobj.define_field(field) notifications.append(("field defined", name, field.name(), 1)) for field in oldactivefields: newsubpobj.activate_field(field) notifications.append(("field activated", name, field.name(), 1)) for eqn in oldeqns: newsubpobj.activate_equation(eqn) notifications.append(("equation activated", name, eqn.name(), 1)) finally: meshctxt.end_writing() meshctxt.cancel_reservation() newsubp.autoenableBCs() for notice in notifications: switchboard.notify(*notice) newsubp.changed("Subproblem redefined.")
def _deactivateField(menuitem, subproblem, field): deactivation = False if parallel_enable.enabled(): ipcsubpmenu.Field.Deactivate(subproblem=subproblem, field=field) else: subpcontext = ooflib.engine.subproblemcontext.subproblems[subproblem] subpcontext.reserve() subpcontext.begin_writing() try: subp = subpcontext.getObject() if subp.is_active_field(field): subp.deactivate_field(field) deactivation = True else: reporter.report( "You must define and activate a Field before you can deactivate it." ) finally: subpcontext.end_writing() subpcontext.cancel_reservation() if deactivation: subpcontext.autoenableBCs() switchboard.notify("field activated", subproblem, field.name(), 0) subpcontext.changed("Field deactivated.")
def _defineField(menuitem, subproblem, field): if parallel_enable.enabled(): ipcsubpmenu.Field.Define(subproblem=subproblem, field=field) else: # subproblem is a name, not an object subpcontext = ooflib.engine.subproblemcontext.subproblems[subproblem] subpcontext.reserve() subpcontext.begin_writing() didsomething = False try: if not subpcontext.is_defined_field(field): subpcontext.getObject().define_field(field) meshctxt = subpcontext.getParent() initializer = meshctxt.get_initializer(field) if initializer: initializer.apply(subpcontext.getParent().getObject(), field, singleFieldDef=True) meshctxt.update_fields() didsomething = True finally: subpcontext.end_writing() subpcontext.cancel_reservation() if didsomething: subpcontext.autoenableBCs() subpcontext.changed("Field defined.") switchboard.notify("field defined", subproblem, field.name(), 1) switchboard.notify("redraw")
def parallel_copy_subproblem(menuitem, subproblem, mesh, name): debug.fmsg() sourcectxt = ooflib.engine.subproblemcontext.subproblems[subproblem] sourceobj = sourcectxt.getObject() # Make a copy of the CSubProblem object, using the clone function # (added to the class by registerCClass). copyobj = sourceobj.clone() # new CSubProblem sourcectxt.begin_reading() try: fields = sourcectxt.all_compound_fields() activefields = [ field for field in fields if sourcectxt.getObject().is_active_field(field) ] equations = sourceobj.all_equations() finally: sourcectxt.end_reading() meshctxt = ooflib.engine.mesh.meshes[mesh] copyctxt = meshctxt.newSubProblem(copyobj, mesh + ':' + name) # new context copyname = copyctxt.path() # Set Fields and Equations in the copy copyctxt.reserve() copyctxt.begin_writing() notifications = [] try: for field in fields: copyobj.define_field(field) notifications.append(("field defined", copyname, field.name(), 1)) for field in activefields: copyobj.activate_field(field) notifications.append( ("field activated", copyname, field.name(), 1)) for eqn in sourceobj.all_equations(): copyobj.activate_equation(eqn) notifications.append( ("equation activated", copyname, eqn.name(), 1)) finally: copyctxt.end_writing() copyctxt.cancel_reservation() copyctxt.autoenableBCs() for notice in notifications: switchboard.notify(*notice)
def setFieldActiveTip(self, button, field): if button.get_active(): verb = "Deactivate" else: verb = "Activate" tooltips.set_tooltip_text(button, "%s the %s field on the subproblem. The solver finds the values of the active fields by solving the active equations." % (verb, field.name()))
def setFieldDefineTip(self, button, field): if button.get_active(): verb = "Undefine" else: verb = "Define" tooltips.set_tooltip_text(button, "%s the %s field on the mesh. Only defined fields have values." % (verb, field.name()))
def setFieldActiveTip(self, button, field): if button.get_active(): verb = "Deactivate" else: verb = "Activate" tooltips.set_tooltip_text( button, "%s the %s field on the subproblem. The solver finds the values of the active fields by solving the active equations." % (verb, field.name()))
def setFieldInPlaneTip(self, button, field): debug.mainthreadTest() if button.get_active(): verb = "Do not constrain" else: verb = "Constrain" tooltips.set_tooltip_text(button, "%s the derivatives of the %s field to lie in the x-y plane." % (verb, field.name()))
def setFieldDefineTip(self, button, field): if button.get_active(): verb = "Undefine" else: verb = "Define" tooltips.set_tooltip_text( button, "%s the %s field on the mesh. Only defined fields have values." % (verb, field.name()))
def setFieldInPlaneTip(self, button, field): debug.mainthreadTest() if button.get_active(): verb = "Do not constrain" else: verb = "Constrain" tooltips.set_tooltip_text( button, "%s the derivatives of the %s field to lie in the x-y plane." % (verb, field.name()))
def _copy_subproblem(menuitem, subproblem, mesh, name): if parallel_enable.enabled(): ipcsubpmenu.Copy(name=name, mesh=mesh, subproblem=subproblem) return sourcectxt = ooflib.engine.subproblemcontext.subproblems[subproblem] sourceobj = sourcectxt.getObject() copyobj = sourcectxt.subptype.create() # new CSubProblem sourcectxt.begin_reading() try: fields = sourcectxt.all_compound_fields() activefields = [field for field in fields if sourcectxt.getObject().is_active_field(field)] equations = sourceobj.all_equations() finally: sourcectxt.end_reading() meshctxt = ooflib.engine.mesh.meshes[mesh] copyctxt = meshctxt.newSubProblem(copyobj, sourcectxt.subptype, mesh+':'+name) # new context copyname = copyctxt.path() # Set Fields and Equations in the copy copyctxt.reserve() copyctxt.begin_writing() notifications = [] try: for field in fields: copyobj.define_field(field) notifications.append(("field defined", copyname, field.name(), 1)) for field in activefields: copyobj.activate_field(field) notifications.append(("field activated", copyname, field.name(), 1)) for eqn in sourceobj.all_equations(): copyobj.activate_equation(eqn) notifications.append(("equation activated", copyname, eqn.name(), 1)) finally: copyctxt.end_writing() copyctxt.cancel_reservation() copyctxt.autoenableBCs() for notice in notifications: switchboard.notify(*notice)
def parallel_copy_subproblem(menuitem, subproblem, mesh, name): debug.fmsg() sourcectxt = ooflib.engine.subproblemcontext.subproblems[subproblem] sourceobj = sourcectxt.getObject() # Make a copy of the CSubProblem object, using the clone function # (added to the class by registerCClass). copyobj = sourceobj.clone() # new CSubProblem sourcectxt.begin_reading() try: fields = sourcectxt.all_compound_fields() activefields = [field for field in fields if sourcectxt.getObject().is_active_field(field)] equations = sourceobj.all_equations() finally: sourcectxt.end_reading() meshctxt = ooflib.engine.mesh.meshes[mesh] copyctxt = meshctxt.newSubProblem(copyobj, mesh+':'+name) # new context copyname = copyctxt.path() # Set Fields and Equations in the copy copyctxt.reserve() copyctxt.begin_writing() notifications = [] try: for field in fields: copyobj.define_field(field) notifications.append(("field defined", copyname, field.name(), 1)) for field in activefields: copyobj.activate_field(field) notifications.append(("field activated", copyname, field.name(), 1)) for eqn in sourceobj.all_equations(): copyobj.activate_equation(eqn) notifications.append(("equation activated", copyname, eqn.name(), 1)) finally: copyctxt.end_writing() copyctxt.cancel_reservation() copyctxt.autoenableBCs() for notice in notifications: switchboard.notify(*notice)
def _meshFields(menuitem, mesh, defined, active, inplane): meshctxt = ooflib.engine.mesh.meshes[mesh] subpname = meshctxt.get_default_subproblem().path() for fname in defined: field = getFieldObj(fname) meshctxt.get_default_subproblem().getObject().define_field(field) switchboard.notify("field defined", subpname, field.name(), 1) for fname in active: field = getFieldObj(fname) meshctxt.get_default_subproblem().getObject().activate_field(field) switchboard.notify("field activated", subpname, field.name(), 1) for fname in inplane: field = getFieldObj(fname) meshctxt.set_in_plane_field(field, 1) switchboard.notify("field inplane", mesh, field.name(), 1) switchboard.notify("mesh changed", meshctxt)
def _meshFields(menuitem, mesh, defined, active, inplane): meshctxt = ooflib.engine.mesh.meshes[mesh] subpname = meshctxt.get_default_subproblem().path() for fname in defined: field = getFieldObj(fname) meshctxt.get_default_subproblem().getObject().define_field(field) switchboard.notify("field defined", subpname, field.name(), 1) for fname in active: field = getFieldObj(fname) meshctxt.get_default_subproblem().getObject().activate_field(field) switchboard.notify("field activated", subpname, field.name(), 1) ## NO need to check for 2D here. This is old code only for ## loading old OOF2 files. for fname in inplane: field = getFieldObj(fname) meshctxt.set_in_plane_field(field, 1) switchboard.notify("field inplane", mesh, field.name(), 1) switchboard.notify("mesh changed", meshctxt)
def _subpFields(menuitem, subproblem, defined, active, inplane): subpctxt = ooflib.engine.subproblemcontext.subproblems[subproblem] meshctxt = subpctxt.getParent() meshname = meshctxt.path() subpname = subpctxt.path() subp = subpctxt.getObject() for fname in defined: field = getFieldObj(fname) subp.define_field(field) switchboard.notify("field defined", subpname, field.name(), 1) for fname in active: field = getFieldObj(fname) subp.activate_field(field) switchboard.notify("field activated", subpname, field.name(), 1) for fname in inplane: field = getFieldObj(fname) meshctxt.set_in_plane_field(field, 1) switchboard.notify("field inplane", meshname, field.name(), 1) subpctxt.changed("Fields loaded.")
def parallel_undefineField(menuitem, subproblem, field): debug.fmsg() subpcontext = ooflib.engine.subproblemcontext.subproblems[subproblem] subpcontext.reserve() subpcontext.begin_writing() try: subpcontext.getObject().undefine_field(field) subpcontext.getParent().update_fields() finally: subpcontext.end_writing() subpcontext.cancel_reservation() subpcontext.autoenableBCs() subpcontext.changed() switchboard.notify("field defined", subproblem, field.name(), 0) switchboard.notify("redraw")
def parallel_activateField(menuitem, subproblem, field): debug.fmsg() activation = False subpcontext = ooflib.engine.subproblemcontext.subproblems[subproblem] subpcontext.reserve() subpcontext.begin_writing() try: subp = subpcontext.getObject() if subp.is_defined_field(field): subp.activate_field(field) activation = True else: reporter.report( "You must define a Field before you can activate it.") finally: subpcontext.end_writing() subpcontext.cancel_reservation() if activation: subpcontext.autoenableBCs() switchboard.notify("field activated", subproblem, field.name(), 1) subpcontext.changed()
def parallel_deactivateField(menuitem, subproblem, field): debug.fmsg() deactivation = False subpcontext = ooflib.engine.subproblemcontext.subproblems[subproblem] subpcontext.reserve() subpcontext.begin_writing() try: subp = subpcontext.getObject() if subp.is_active_field(field): subp.deactivate_field(field) deactivation = True else: reporter.report( "You must define and activate a Field before you can deactivate it.") finally: subpcontext.end_writing() subpcontext.cancel_reservation() if deactivation: subpcontext.autoenableBCs() switchboard.notify("field activated", subproblem, field.name(), 0) subpcontext.changed()
def _undefineField(menuitem, subproblem, field): if parallel_enable.enabled(): ipcsubpmenu.Field.Undefine(subproblem=subproblem, field=field) else: subpcontext = ooflib.engine.subproblemcontext.subproblems[subproblem] subpcontext.reserve() subpcontext.begin_writing() try: subpcontext.getObject().undefine_field(field) subpcontext.getParent().update_fields() # After undefining a Field, the data cache in the mesh has # the wrong number of dofs in it. We could in principle # delete the correct dofs from each cache entry, but it # might be slow (especially for a disk cache). The # simpler thing to do is to just delete the whole cache. subpcontext.getParent().clearDataCache() finally: subpcontext.end_writing() subpcontext.cancel_reservation() subpcontext.autoenableBCs() subpcontext.changed("Field undefined.") switchboard.notify("field defined", subproblem, field.name(), 0) switchboard.notify("redraw")
def _activateField(menuitem, subproblem, field): activation = False if parallel_enable.enabled(): ipcsubpmenu.Field.Activate(subproblem=subproblem,field=field) else: subpcontext = ooflib.engine.subproblemcontext.subproblems[subproblem] subpcontext.reserve() subpcontext.begin_writing() try: subp = subpcontext.getObject() if subp.is_defined_field(field): subp.activate_field(field) activation = True else: reporter.report( "You must define a Field before you can activate it.") finally: subpcontext.end_writing() subpcontext.cancel_reservation() if activation: subpcontext.autoenableBCs() switchboard.notify("field activated", subproblem, field.name(), 1) subpcontext.changed("Field activated.")
def _undefineField(menuitem, subproblem, field): if parallel_enable.enabled(): ipcsubpmenu.Field.Undefine(subproblem=subproblem,field=field) else: subpcontext = ooflib.engine.subproblemcontext.subproblems[subproblem] subpcontext.reserve() subpcontext.begin_writing() try: subpcontext.getObject().undefine_field(field) subpcontext.getParent().update_fields() # After undefining a Field, the data cache in the mesh has # the wrong number of dofs in it. We could in principle # delete the correct dofs from each cache entry, but it # might be slow (especially for a disk cache). The # simpler thing to do is to just delete the whole cache. subpcontext.getParent().clearDataCache() finally: subpcontext.end_writing() subpcontext.cancel_reservation() subpcontext.autoenableBCs() subpcontext.changed("Field undefined.") switchboard.notify("field defined", subproblem, field.name(), 0) switchboard.notify("redraw")
def _copy_subproblem(menuitem, subproblem, mesh, name): if parallel_enable.enabled(): ipcsubpmenu.Copy(name=name, mesh=mesh, subproblem=subproblem) return meshctxt = ooflib.engine.mesh.meshes[mesh] sourcectxt = ooflib.engine.subproblemcontext.subproblems[subproblem] if not sourcectxt.consistency(): raise ooferror.ErrUserError( 'Subproblem being copied is not consistent!') sourceobj = sourcectxt.getObject() #Retrieving the tree of dependencies order for the less dependent subproblem to the most dependent one links = [] sourcectxt.tree(links) links_update = [] #Looping around the path of each subproblem from the ordered list for link in links: # Retrieve the path, the name and the context of the current subproblem subp_path = labeltree.makePath(link) subp_name = subp_path[-1] subp_ctxt = ooflib.engine.subproblemcontext.subproblems[link] create = False #Should the subproblem be created? if subp_ctxt != sourcectxt: for subp in meshctxt.subproblems(): #Check that the subproblem has the same name and subptype if subp_name == subp.name(): if subp_ctxt.subptype.__class__ == subp.subptype.__class__: create = True links_update.append(subp.path()) #Update with the path break # If the subproblem does not exist in the target mesh subproblem # Copy the subproblem and update its dependencies since they might probably have # different paths if the target mesh is another one. # Create the subproblem copy all the original subproblem content # Finally update the dependencies dependents and propagate the consistency. if create == False: subptype_copy = copy.deepcopy(subp_ctxt.subptype) for dependency in subptype_copy.get_dependencies(): dep_index = links.index(dependency) update_path = links_update[dep_index] subptype_copy.sync_dependency(dependency, update_path) copyobj = subptype_copy.create() # new CSubProblem sourcectxt.begin_reading() try: fields = sourcectxt.all_compound_fields() activefields = [ field for field in fields if sourcectxt.getObject().is_active_field(field) ] equations = sourceobj.all_equations() finally: sourcectxt.end_reading() if subp_ctxt != sourcectxt: copyctxt = meshctxt.newSubProblem(copyobj, subptype_copy, mesh + ':' + subp_name) # new context else: copyctxt = meshctxt.newSubProblem( copyobj, subptype_copy, mesh + ':' + name) # new context copyname = copyctxt.path() links_update.append(copyname) #Update with the new path # Set Fields and Equations in the copy copyctxt.reserve() copyctxt.begin_writing() notifications = [] try: for field in fields: copyobj.define_field(field) notifications.append( ("field defined", copyname, field.name(), 1)) for field in activefields: copyobj.activate_field(field) notifications.append( ("field activated", copyname, field.name(), 1)) for eqn in sourceobj.all_equations(): copyobj.activate_equation(eqn) notifications.append( ("equation activated", copyname, eqn.name(), 1)) finally: copyctxt.end_writing() copyctxt.cancel_reservation() copyctxt.autoenableBCs() for notice in notifications: switchboard.notify(*notice) #Update the dependencies dependents for dependency in copyctxt.subptype.get_dependencies(): dependencysubp = ooflib.engine.subproblemcontext.subproblems[ dependency] dependencysubp.subptype.remove_dependent(link) dependencysubp.subptype.add_dependent(copyname) for dep in copyctxt.subptype.get_dependencies(): ooflib.engine.subproblemcontext.subproblems[ dep].update_consistency() copyctxt.propagate_consistency([copyname])
dfile.endCmd() # Create subproblems anyfields = False # used later to decide if field values must be saved for subpctxt in meshcontext.subproblems(): subp = subpctxt.subptype subpobj = subpctxt.getObject() if subpctxt.name() != ooflib.engine.mesh.defaultSubProblemName: dfile.startCmd(subpmenu.New) dfile.argument('name', subpctxt.name()) dfile.argument('subproblem', subp) dfile.argument('mesh', meshcontext.path()) dfile.endCmd() # Define and activate Fields on subproblems definedfields = [ field.name() for field in subpctxt.all_compound_fields() ] activefields = [ field.name() for field in subpctxt.all_compound_fields() if subpobj.is_active_field(field) ] inplanefields = [ field.name() for field in subpctxt.all_compound_fields() if femesh.in_plane(field) ] if definedfields: anyfields = True dfile.startCmd(subpmenu.Fields) dfile.argument('subproblem', subpctxt.path()) dfile.argument('defined', definedfields) dfile.argument('active', activefields)
def _edit_subproblem(menuitem, name, subproblem): ## if parallel_enable.enabled(): ## ## TODO MER: out of date ## ipcsubpmenu.Edit(name=name, subproblem=subproblem) ## return oldsubp = ooflib.engine.subproblemcontext.subproblems[name] if oldsubp.name() == ooflib.engine.mesh.defaultSubProblemName: raise ooferror.ErrUserError("You can't edit the default Subproblem!") meshctxt = oldsubp.getParent() # Get the old dependents and dependencies for updates old_dependents = oldsubp.subptype.get_dependents() old_dependencies = oldsubp.subptype.get_dependencies() old_path = oldsubp.path() oldsubp.reserve() oldsubp.begin_writing() try: oldsubpobj = oldsubp.getObject() # Save lists of fields, etc, so that they can be restored in # the new subproblem. oldfields = oldsubp.all_compound_fields() # only CompoundFields oldactivefields = [ field for field in oldfields if oldsubpobj.is_active_field(field) ] oldeqns = oldsubp.all_equations() oldsubp.clean() finally: oldsubp.end_writing() oldsubp.cancel_reservation() # Create the new subproblem object newsubpobj = subproblem.create() #Remove the path from the dependencies dependents: for dependency in old_dependencies: if old_path in ooflib.engine.subproblemcontext.subproblems[ dependency].subptype.get_dependents(): ooflib.engine.subproblemcontext.subproblems[ dependency].subptype.remove_dependent(old_path) # Create context for new subproblem. newsubp = meshctxt.newSubProblem(newsubpobj, subproblem, name) meshctxt.reserve() meshctxt.begin_writing() # Gather switchboard messages and send them all after the lock has # been released. notifications = [] try: # Restore field and equation state saved from old subproblem. for field in oldfields: newsubpobj.define_field(field) notifications.append(("field defined", name, field.name(), 1)) for field in oldactivefields: newsubpobj.activate_field(field) notifications.append(("field activated", name, field.name(), 1)) for eqn in oldeqns: newsubpobj.activate_equation(eqn) notifications.append(("equation activated", name, eqn.name(), 1)) finally: meshctxt.end_writing() meshctxt.cancel_reservation() newsubp.autoenableBCs() #Update the dependents with the new object for dependent in old_dependents: dependentsubp = ooflib.engine.subproblemcontext.subproblems[dependent] newsubp.subptype.add_dependent(dependent) dependentsubp.reserve() dependentsubp.begin_writing() try: dependentsubp.subptype.update_dependency(dependentsubp.getObject(), old_path, newsubp.getObject()) finally: dependentsubp.end_writing() dependentsubp.cancel_reservation() for dep in newsubp.subptype.get_dependencies(): ooflib.engine.subproblemcontext.subproblems[dep].update_consistency() newsubp.propagate_consistency([old_path]) for notice in notifications: switchboard.notify(*notice) newsubp.changed("Subproblem redefined.")
dfile.argument('skeleton', skelpath) dfile.endCmd() # Create subproblems anyfields = False # used later to decide if field values must be saved for subpctxt in meshcontext.subproblems(): subp = subpctxt.subptype subpobj = subpctxt.getObject() if subpctxt.name() != ooflib.engine.mesh.defaultSubProblemName: dfile.startCmd(subpmenu.New) dfile.argument('name', subpctxt.name()) dfile.argument('subproblem', subp) dfile.argument('mesh', meshcontext.path()) dfile.endCmd() # Define and activate Fields on subproblems definedfields = [field.name() for field in subpctxt.all_compound_fields()] activefields = [field.name() for field in subpctxt.all_compound_fields() if subpobj.is_active_field(field)] inplanefields = [field.name() for field in subpctxt.all_compound_fields() if femesh.in_plane(field)] if definedfields: anyfields = True dfile.startCmd(subpmenu.Fields) dfile.argument('subproblem', subpctxt.path()) dfile.argument('defined', definedfields) dfile.argument('active', activefields) dfile.argument('inplane', inplanefields) dfile.endCmd()
def writeMesh(dfile, meshcontext, includeFields=True): skelcontext = meshcontext.getParent() skelpath = skelcontext.path() femesh = meshcontext.femesh() # Create mesh. dfile.startCmd(meshmenu.New) dfile.argument('name', meshcontext.name()) masterelems = [el.name() for el in meshcontext.elementdict.values()] dfile.argument('masterelems', masterelems) dfile.argument('skeleton', skelpath) dfile.endCmd() # Create subproblems anyfields = False # used later to decide if field values must be saved for subpctxt in meshcontext.subproblems(): subp = subpctxt.subptype subpobj = subpctxt.getObject() if subpctxt.name() != ooflib.engine.mesh.defaultSubProblemName: dfile.startCmd(subpmenu.New) dfile.argument('name', subpctxt.name()) dfile.argument('subproblem', subp) dfile.argument('mesh', meshcontext.path()) dfile.endCmd() # Define and activate Fields on subproblems definedfields = [field.name() for field in subpctxt.all_compound_fields()] activefields = [field.name() for field in subpctxt.all_compound_fields() if subpobj.is_active_field(field)] if config.dimension == 2: inplanefields = [field.name() for field in subpctxt.all_compound_fields() if femesh.in_plane(field)] if definedfields: anyfields = True dfile.startCmd(subpmenu.Fields) dfile.argument('subproblem', subpctxt.path()) dfile.argument('defined', definedfields) dfile.argument('active', activefields) if config.dimension() == 2: dfile.argument('inplane', inplanefields) dfile.endCmd() # Time derivative fields have a separate menu item to preserve # backwards compatibiltiy from the pre-time-dependence days. timederivfields = [field.name() for field in subpctxt.all_compound_fields() if subpctxt.is_defined_field(field.time_derivative())] if timederivfields: dfile.startCmd(subpmenu.Time_Derivative_Fields) dfile.argument('subproblem', subpctxt.path()) dfile.argument('fields', timederivfields) dfile.endCmd() # Equations equations = [eqn.name() for eqn in subpctxt.all_equations()] if equations: dfile.startCmd(subpmenu.Equations) dfile.argument('subproblem', subpctxt.path()) dfile.argument('equations', equations) dfile.endCmd() # Solver if subpctxt.time_stepper is not None: dfile.startCmd(subpmenu.Solver) dfile.argument('subproblem', subpctxt.path()) dfile.argument('solver_mode', subpctxt.solver_mode) dfile.endCmd() # End loop over subproblems # Field initializers for field in meshcontext.all_subproblem_fields(): init = meshcontext.get_initializer(field) if init: dfile.startCmd(meshmenu.Initialize_Field) dfile.argument('mesh', meshcontext.path()) dfile.argument('field', field) dfile.argument('initializer', init) dfile.endCmd() # Boundary conditions bcnames = meshcontext.allBndyCondNames() bcnames.sort() for bcname in bcnames: bc = meshcontext.getBdyCondition(bcname) # bc's that are invisible in the gui are generally created by # internal processes. Explicity saving and loading them can # lead to conflicts. if bc.isVisible(): dfile.startCmd(meshmenu.Boundary_Condition) dfile.argument('mesh', meshcontext.path()) dfile.argument('bcname', bcname) dfile.argument('bc', bc) dfile.endCmd() # Boundary condition initializers bcnames = [bc.name() for bc in meshcontext.initialized_bcs()] bcnames.sort() for bcname in bcnames: dfile.startCmd(meshmenu.Set_BC_Initializer) dfile.argument('mesh', meshcontext.path()) dfile.argument('bc', bcname) dfile.argument('initializer', meshcontext.get_bc_initializer(bcname)) dfile.endCmd() if anyfields and includeFields: # Cached data. Cached data must be stored before the current # data, so that when it's reloaded, the current data isn't # overwritten. lastcachedtime = None for time in meshcontext.cachedTimes(): meshcontext.restoreCachedData(time) writeAndCacheFields(dfile, meshcontext, time) meshcontext.releaseCachedData() lastcachedtime = time meshcontext.restoreLatestData() if lastcachedtime != meshcontext.getCurrentTime(): writeFields(dfile, meshcontext) meshcontext.releaseLatestData() # allow overwrites later # Time dfile.startCmd(meshmenu.Time) dfile.argument('mesh', meshcontext.path()) dfile.argument('time', meshcontext.getCurrentTime()) dfile.endCmd() # Cross sections: for csname in meshcontext.cross_sections.all_names(): # already ordered cs = meshcontext.cross_sections[csname] dfile.startCmd(meshmenu.CrossSection) dfile.argument('mesh', meshcontext.path()) dfile.argument('name', csname) dfile.argument('cs', cs) dfile.endCmd() # Scheduled outputs meshcontext.outputSchedule.saveAll(dfile, meshcontext) # Status. This should be the last thing written. dfile.startCmd(meshmenu.Status) dfile.argument('mesh', meshcontext.path()) if isinstance(meshcontext.status, (meshstatus.Unsolved, meshstatus.Solving)): # Since the order in which mesh attributes were written to the # data file is somewhat arbitrary, the details of an # "Unsolved" status aren't terribly meaningful. Use generic # details. Also, there's no point in storing a "Solving" # status, because it won't be true when the mesh is loaded. dfile.argument('status', meshstatus.Unsolved("Newly loaded.")) else: dfile.argument('status', meshcontext.status) dfile.endCmd()