def __init__(self, name, registeredclass, subclass, ordering, params=[], secret=0, tip=None, discussion=None, **kwargs): self._name = name self.subclass = subclass if type(registeredclass) in (ListType, TupleType): self.registeredclasses = tuple(registeredclass[:]) else: self.registeredclasses = (registeredclass,) self.ordering = ordering self.params = params self.secret = secret self.tip = tip self.discussion = discussion # Registered subclasses must have unique names in the main OOF # namespace: try: scls = utils.OOFeval(subclass.__name__) except NameError: # ok, name isn't already defined. self.exportToOOF() else: raise NameError("RegisteredClass subclass '%s' is already defined." % subclass.__name__) self.__dict__.update(kwargs) # Store the registration. Extract it first, so that it also # works for the RegisteredCClasses. for registeredclass in self.registeredclasses: registeredclass.registry.append(self) # Sorting each time is inefficient, but doesn't happen often. registeredclass.registry.sort() switchboard.notify(registeredclass)
def new_material(self, name, materialtype=material.MATERIALTYPE_BULK, *props): # If a Material already exists with the same name, just # redefine it by deleting its old Properties and adding the # new ones. *Don't* try deleting the Material entirely and # recreating it from scratch, which seems like the easy way to # go. Deleting the Material would delete it from any # Microstructures and Meshes that use it. try: matprop = self.materials[name] except KeyError: matprop = MaterialProps(name, materialtype) self.materials[name] = matprop else: matprop.delete_all_props() mat = matprop.actual for p in props: mat.addProperty(p) reg = p.registration() path = AllProperties.data.reverse_dict[reg].path() matprop.add_prop_ref(path, reg) reg.materials[name]=(matprop, p) switchboard.notify("new_material", name) for ms in microStructures.actualMembers(): if mat in material.getMaterials(ms.getObject()): switchboard.notify("materials changed in microstructure", ms.getObject())
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 bdyPropagate(self, name, contextbdy): # Replace the boundaries up and down the stack with a suitably # mapped version of the modified boundary. Operate only # on sheriffs, and don't re-operate on the original object. # Then, ensure that the modifications get to the meshes -- # in this case, we need to run over the whole stack, because # although deputy skeletons don't have boundaries, their # meshes nevertheless do. start = self.getObject().sheriffSkeleton() # Current sheriff children = self.undobuffer.getToTop() current = start for c in withoutDeputies(children[1:]): if not c is start: contextbdy.remove(c) contextbdy.map(current, c, direction=skeletonboundary.MAP_DOWN) current = c current = start parents = self.undobuffer.getToBottom() for p in withoutDeputies(parents[1:]): if not p is start: contextbdy.remove(p) contextbdy.map(current, p, direction=skeletonboundary.MAP_UP) current = p # Update the boundaries in the Meshes to match the boundaries # in the Skeleton. for mesh in self.getMeshes(): mesh.getObject().skeleton.pushBoundaryToMesh(mesh, name) switchboard.notify("new boundary configuration", self)
def renameBoundary(self, oldname, newname): if oldname==newname: return if newname in self.allBoundaryNames(): raise ooferror.ErrSetupError("Name %s is already in use." % newname) #Interface branch if config.dimension() == 2 and runtimeflags.surface_mode: if newname in self.allInterfaceNames(): raise ooferror.ErrSetupError( "Name %s is already in use as an interface name." % newname) if oldname in self.edgeboundaries: dict = self.edgeboundaries elif oldname in self.pointboundaries: dict = self.pointboundaries else: raise ooferror.ErrPyProgrammingError( "Boundary name %s not found." % oldname) dict[newname]=dict[oldname] del dict[oldname] # SkelContextBoundary.rename calls Skeleton.renameBoundary dict[newname].rename(newname) # Maintain consistency in Meshes for mesh in self.getMeshes(): mesh.renameBoundary(oldname, newname) switchboard.notify("boundary renamed", self) self.bdytimestamp.increment() self.selectBoundary(newname)
def createPointBoundary(self, name, node_set, exterior=None, autoselect=1): bdy = self.getObject().makePointBoundary(name, node_set, exterior) for mesh in self.getMeshes(): mesh.newPointBoundary(name, bdy) context_bdy = bdy.makeContextBoundary(self, name, self.getObject()) self.pointboundaries[name] = context_bdy # Propagation up and down. # See routine above for nomenclature lament. # DeputySkeleton.mapBoundary is a no-op. current = self.getObject() children = self.undobuffer.getToTop() for c in withoutDeputies(children[1:]): c.mapBoundary(context_bdy, current, direction=skeletonboundary.MAP_DOWN) current = c current = self.getObject() parents = self.undobuffer.getToBottom() for p in withoutDeputies(parents[1:]): p.mapBoundary(context_bdy, current, direction=skeletonboundary.MAP_UP) current = p switchboard.notify("new boundary created", self) if autoselect: self.selectBoundary(name) self.bdytimestamp.increment()
def postProcess(self, context): ## global Pcount ## Pcount += 1 ## random.seed(1) skeleton = context.getObject() prog = self.makeProgress() self.count = 0 prog.setMessage(self.header) before = skeleton.energyTotal(self.criterion.alpha) while self.iteration.goodToGo(): self.count += 1 # the context acquires the writing permissions inside # coreProcess. self.coreProcess(context) self.updateIteration(prog) if prog.stopped(): break switchboard.notify("skeleton nodes moved", context) if prog.stopped(): self.targets.cleanUp() return after = skeleton.energyTotal(self.criterion.alpha) if before: rate = 100.0*(before-after)/before else: rate = 0.0 diffE = after - before reporter.report("%s deltaE = %10.4e (%6.3f%%)" % (self.outro, diffE, rate)) self.targets.cleanUp() prog.finish()
def copyMicrostructure(menuitem, microstructure, name): if parallel_enable.enabled(): microstructureIPC.msmenu.Copy(microstructure=microstructure,name=name) return ms = ooflib.common.microstructure.microStructures[microstructure] ms.begin_reading() grouplist = [] try: sourceMS = ms.getObject() newMS = sourceMS.nominalCopy(name) newMScontext = ooflib.common.microstructure.microStructures[name] # First, copy images and load them to copied MS. for imagectxt in sourceMS.getImageContexts(): sourceimage = imagectxt.getObject() immidge = sourceimage.clone(sourceimage.name()) imagecontext.imageContexts.add([newMS.name(),immidge.name()], immidge, parent=newMScontext) # Copy pixel groups for grpname in sourceMS.groupNames(): sourcegrp = sourceMS.findGroup(grpname) # Ignore "newness", all groups will be new. (newgrp, newness) = newMS.getGroup(grpname) newgrp.add(sourcegrp.members()) newgrp.set_meshable(sourcegrp.is_meshable()) grouplist.append(newgrp) finally: ms.end_reading() for g in grouplist: switchboard.notify("new pixel group", g)
def selectNode(self, menuitem, position): context = apply(self.gfxwindow().topwho, self.whoset) if context: skeleton = context.getObject() self.selectednode.set(skeleton.nearestNode(position)) switchboard.notify('redraw') switchboard.notify(("node selected", self))
def createMSFromImageFile(menuitem, filename, microstructure_name, height, width, depth=0): if (height!=automatic and height<=0) or \ (width!=automatic and width<=0) or \ (config.dimension()==3 and depth!=automatic and depth<=0): raise ooferror.ErrUserError( "Negative microstructure sizes are not allowed.") image = autoReadImage(filename, height, width, depth) ms = ooflib.common.microstructure.Microstructure(microstructure_name, image.sizeInPixels(), image.size()) immidgecontext = imagecontext.imageContexts.add( [ms.name(), image.name()], image, parent=ooflib.common.microstructure.microStructures[ms.name()]) if parallel_enable.enabled(): # For the rear-end guys from ooflib.image.IO import oofimageIPC oofimageIPC.imenu.Create_From_Imagefile_Parallel( msname=microstructure_name, imagename=image.name()) switchboard.notify("redraw")
def forgetTextOutputStreams(): _streamsLock.acquire() try: _allStreams.clear() finally: _streamsLock.release() switchboard.notify("output destinations changed")
def createMSFromImage(menuitem, name, width, height, image): if parallel_enable.enabled(): # For the back-end processes from ooflib.image.IO import oofimageIPC oofimageIPC.imenu.Create_From_Image_Parallel( msname=name, image=image) # For serial mode #0 in parallel mode imagepath = labeltree.makePath(image) immidgecontext = imagecontext.imageContexts[image] immidge = immidgecontext.getObject().clone(imagepath[-1]) size = immidge.size() # Point object. if width!=automatic.automatic: size[0]=width if height!=automatic.automatic: size[1]=height ms = ooflib.common.microstructure.Microstructure(name, immidge.sizeInPixels(), size) newimagecontext = imagecontext.imageContexts.add( [name, immidge.name()], immidge, parent=ooflib.common.microstructure.microStructures[name]) switchboard.notify("redraw")
def removeSelectionFromGroup(self, name): if name in self.groups: clist, plist = self.trackerlist() for o in self.get_selection(): o.remove_from_group(name, clist, plist) switchboard.notify("groupset member resized", self.skeletoncontext, self)
def _skeleton_from_mstructure(menuitem, name, microstructure, x_elements, y_elements, skeleton_geometry): if parallel_enable.enabled(): # PARALLEL skeleton.initialSkeletonParallel(name, microstructure, x_elements, y_elements, skeleton_geometry) else: ms = microStructures[microstructure].getObject() skel = skeleton.initialSkeleton(name, ms, x_elements, y_elements, skeleton_geometry) switchboard.notify("redraw")
def creatorcallback(self, menuitem, **kwargs): treepath = string.split(menuitem.path(),".")[3:] reg = self.data[treepath].object name = menuitem.params[0].value # Collision looks for the name under this tree, and if it # finds it, checks if the parameter values are all equal. If # a collision occurs and the parameters conflict, an exception # is raised. If collision returns "true", that means a # collision occurred but the parameters matched. If collision # returns "false", a collision did not occur. namecollision, parametercollision = reg.collision(name, menuitem.params[1:]) if namecollision: # name is a duplicate if parametercollision: # parameters disagree if name != "": raise ooferror.ErrSetupError("Named property in datafile conflicts with existing property '%s'" % name) # reparametrization of unnamed property if reg.materials: raise ooferror.ErrSetupError("Unnamed property in datafile conflicts with existing property '%s'" % name) # Unnamed property is being reparametrized, but it's # not used in any materials, so it's ok. reg.new_params(**kwargs) switchboard.notify("redraw") # A name collision with no parameter collision doesn't # require any action. The data file contained a property # identical to an existing property. else: # No collision, we must create a new NamedRegistration. # We know it's a NamedRegistration because unnamed # property registrations *always* produce a name conflict. fullname = string.join( treepath + [name], ":") newreg = reg.named_copy(fullname, menuitem.params[1:]) switchboard.notify("redraw")
def addSelectionToGroup(self, name): if name in self.groups: clist, plist = self.trackerlist() for o in self.get_selection(): o.add_to_group(name, clist, plist) switchboard.notify("groupset member resized", self.skeletoncontext, self)
def parallel_copyEquationState(menuitem, source, target): notifications = [] source_subp = ooflib.engine.mesh.meshes[source].get_default_subproblem() target_subp = ooflib.engine.mesh.meshes[target].get_default_subproblem() source_subp.begin_reading() target_subp.reserve() target_subp.begin_writing() try: source_obj = source_subp.getObject() target_obj = target_subp.getObject() source_eqns = source_obj.all_equations() target_eqns = target_obj.all_equations() for e in target_eqns: if not source_obj.is_active_equation(e): target_obj.deactivate_equation(e) notifications.append( ("equation activated", target_subp.path(), e.name(), 0)) for e in source_eqns: if not target_obj.is_active_equation(e): target_obj.activate_equation(e) notifications.append( ("equation activated", target_subp.path(), e.name(), 1)) finally: source_subp.end_reading() target_subp.end_writing() target_subp.cancel_reservation() for n in notifications: switchboard.notify(*n) target_subp.autoenableBCs() target_subp.changed()
def _bcremove(self, mesh, name): if parallel_enable.enabled(): boundaryconditionIPC.ipcbcmenu.Delete(mesh=mesh,name=name) else: meshcontext = ooflib.engine.mesh.meshes[mesh] meshcontext.rmBdyConditionByName(name) switchboard.notify("mesh changed", ooflib.engine.mesh.meshes[mesh])
def renamePixelGroup_parallel(menuitem, microstructure, group, new_name): # "group" arg is the old group name. mscontext = ooflib.common.microstructure.microStructures[microstructure] ms = mscontext.getObject() mscontext.begin_writing() renamed = False try: grp = ms.findGroup(group) # Don't just say "if grp" here. PixelGroup has a __len__ # function, so empty groups evaluate to "false". if grp is not None: ms.renameGroup(group, new_name) renamed = True #Interface branch (only implemented for 2D) if config.dimension() == 2: interfacemsplugin=ms.getPlugIn("Interfaces") interfacemsplugin.renameGroup(group, new_name) else: raise ooferror.ErrUserError("There is no pixel group named %s!" % group) finally: mscontext.end_writing() if renamed: switchboard.notify('renamed pixel group', grp, group, new_name)
def clearQuerier(self): self.last_position = None if self.querier: self.querier.set() self.peeker.reset() self.redraw() switchboard.notify((self, "clear"))
def pushModificationSignal(self): self.pause_writing() # Switchboard callbacks usually run on subthreads -- this # pause/resume pair might be useless, but it's harmless. switchboard.notify(('who changed', self.classname), self) ## self.parallelPushModification(self._obj) self.resume_writing()
def redefined(self): # Called when the things affecting the subproblem definition # itself have changed. For example, a MaterialSubProblem is # redefined when its Material is assigned to or removed from # pixels. self.getObject().redefined() switchboard.notify("subproblem redefined", self.path())
def removeInterface(self,name): try: del self.namedinterfaces[name] interfacenames=self.getInterfaceNames() doomedinterfaces=[name] #Because of the possibility of compound interfaces (e.g. union), #we must search the other interfaces for the presence #of the interface corresponding to name. for interfacename in interfacenames: interfaceobj=self.namedinterfaces[interfacename] if interfaceobj.hasInterface(name): del self.namedinterfaces[interfacename] doomedinterfaces.append(interfacename) self.removeMaterialFromInterfaces(doomedinterfaces) self.unselectInterface() #Remove boundary conditions that refer to the doomedinterfaces meshclass=ooflib.engine.mesh.meshes msname=self.microstructure.name() for meshkey in meshclass.keys(base=msname): meshctxt=meshclass[[msname]+meshkey] for doomedinterfacename in doomedinterfaces: meshctxt.removeInterface(doomedinterfacename) self.rebuildMeshes() switchboard.notify("interface removed",self.microstructure) except KeyError: pass
def delete(self, name): path = makePath(name) if len(path) == 1: for i in range(len(self.nodes)): # Use index so "del" works. if self.nodes[i].name==path[0]: # Think of the children. if len(self.nodes[i].nodes)!=0: raise ErrUserError( "Attempt to delete non-leaf from labeltree.") else: # Then do the deletion, in the tree and # in the menus and reverse dictionary. oldnode = self.nodes[i] if self.nodes[i].object is not None: del self.root.reverse_dict[self.nodes[i].object] del self.nodes[i] for menu in self.menus.values(): menu.removeItem(path[0]) # Tell the switchboard... switchboard.notify((self.root, "delete"), oldnode) break # Otherwise, not at bottom. Recurse. else: nodename = path[0] for node in self.nodes: if node.name == nodename: node.delete(path[1:]) break
def moveNode(self, menuitem, origin, destination): skelcontext = self.gfxwindow().topwho('Skeleton') if skelcontext: # if parallel_enable.enabled(): from ooflib.engine.IO import skeletonIPC skeletonIPC.smenu.Move_Node_Helper(origin=origin, destination=destination, allow_illegal=self.allow_illegal, skeletonpath=skelcontext.path()) return # skeleton = skelcontext.getObject().deputyCopy() skeleton.activate() node = skeleton.nearestNode(origin) skelcontext.reserve() skelcontext.begin_writing() try: skeleton.moveNodeTo(node, destination) if node.illegal(): if self.allow_illegal==1: skeleton.setIllegal() else: node.moveBack() elif skeleton.illegal(): # node motion may have rehabilitated skeleton.checkIllegality() skelcontext.pushModification(skeleton) finally: skelcontext.end_writing() skelcontext.cancel_reservation() skeleton.needsHash() switchboard.notify('redraw')
def copyPixelGroup(menuitem, microstructure, group, name): if parallel_enable.enabled(): pixelgroupIPC.ipcpixgrpmenu.Copy(microstructure=microstructure, group=group, name=name) return if group != name: mscontext = ooflib.common.microstructure.microStructures[microstructure] ms = mscontext.getObject() mscontext.begin_writing() newness = False try: oldgroup = ms.findGroup(group) if oldgroup is not None: (newgroup, newness) = ms.getGroup(name) newgroup.addWithoutCheck(oldgroup.members()) else: raise ooferror.ErrUserError("There is no pixel group named %s!" % group) finally: mscontext.end_writing() if newness: switchboard.notify("new pixel group", newgroup) switchboard.notify("changed pixel group", newgroup, microstructure)
def renamePixelGroup(menuitem, microstructure, group, new_name): if parallel_enable.enabled(): pixelgroupIPC.ipcpixgrpmenu.Rename(microstructure=microstructure, group=group, new_name=new_name) return # "group" arg is the old group name. mscontext = ooflib.common.microstructure.microStructures[microstructure] ms = mscontext.getObject() mscontext.begin_writing() renamed = False try: grp = ms.findGroup(group) # Don't just say "if grp" here. PixelGroup has a __len__ # function, so empty groups evaluate to "false". if grp is not None: ms.renameGroup(group, new_name) renamed = True if config.dimension() == 2 and runtimeflags.surface_mode: interfacemsplugin=ms.getPlugIn("Interfaces") interfacemsplugin.renameGroup(group, new_name) else: raise ooferror.ErrUserError("There is no pixel group named %s!" % group) finally: mscontext.end_writing() if renamed: switchboard.notify('renamed pixel group', grp, group, new_name)
def renameInterface(self,oldname,newname): if oldname==newname: return if newname in self.getCurrentReservedNames(): raise ooferror.ErrSetupError("Name %s already in use." % newname) try: obj=self.namedinterfaces[oldname] del self.namedinterfaces[oldname] self.namedinterfaces[newname]=obj interfacenames=self.getInterfaceNames() #Because of the possibility of compound interfaces (e.g. union), #we must search the other interfaces for the presence #of the interface corresponding to oldname. for interfacename in interfacenames: interfaceobj=self.namedinterfaces[interfacename] interfaceobj.renameInterface(oldname,newname) #interface must also be renamed in the list of #material assignments matname=self.getInterfaceMaterialName(oldname) self.removeMaterialFromInterfaces([oldname]) self.assignMaterialToInterfaces(matname,[newname]) #Rename the interface in the boundary conditions #and in the edgements. meshclass=ooflib.engine.mesh.meshes msname=self.microstructure.name() for meshkey in meshclass.keys(base=msname): meshctxt=meshclass[[msname]+meshkey] meshctxt.renameInterface(oldname,newname) self.selectInterface(newname) switchboard.notify("interface renamed",self.microstructure) except KeyError: pass
def clearGroup(self, *names): if names: for name in names: if name in self.groups: for t in self.tracker.values(): t.clear_group(name) switchboard.notify("groupset member resized", self.skeletoncontext, self)
def assignMaterial(self, groupname, material): ts = timestamp.TimeStamp() ts.increment() self.materials[groupname] = (material, ts) switchboard.notify("materials changed in skeleton", self.skeletoncontext) for mesh in self.skeletoncontext.getMeshes(): mesh.refreshMaterials(self.skeletoncontext) switchboard.notify("redraw")
def _copyEquationState(menuitem, source, target): if source == target: raise ooferror.ErrUserError('Source and target must differ!') if parallel_enable.enabled(): ipcsubpmenu.Copy_Equation_State(source=source, target=target) return notifications = [] source_subp = ooflib.engine.subproblemcontext.subproblems[source] target_subp = ooflib.engine.subproblemcontext.subproblems[target] source_subp.begin_reading() target_subp.reserve() target_subp.begin_writing() try: source_obj = source_subp.getObject() target_obj = target_subp.getObject() source_eqns = source_obj.all_equations() target_eqns = target_obj.all_equations() for e in target_eqns: if not source_obj.is_active_equation(e): target_obj.deactivate_equation(e) notifications.append( ("equation activated", target, e.name(), 0)) for e in source_eqns: if not target_obj.is_active_equation(e): target_obj.activate_equation(e) notifications.append( ("equation activated", target, e.name(), 1)) finally: source_subp.end_reading() target_subp.end_writing() target_subp.cancel_reservation() for n in notifications: switchboard.notify(*n) target_subp.autoenableBCs() target_subp.changed("Equations changed.")
def widgetChanged(self, validity, interactive): if self._valid and not validity: self._valid = 0 switchboard.notify(('validity', self), 0) elif not self._valid and validity: self._valid = 1 switchboard.notify(('validity', self), 1) switchboard.notify(self, interactive)
def creatorcallback(self, menuitem, **kwargs): treepath = string.split(menuitem.path(), ".")[3:] reg = self.data[treepath].object name = menuitem.params[0].value # Collision looks for the name under this tree, and if it # finds it, checks if the parameter values are all equal. If # a collision occurs and the parameters conflict, an exception # is raised. If collision returns "true", that means a # collision occurred but the parameters matched. If collision # returns "false", a collision did not occur. namecollision, parametercollision = reg.collision( name, menuitem.params[1:]) if namecollision: # name is a duplicate if parametercollision: # parameters disagree if name != "": raise ooferror.ErrSetupError( "Named property in datafile conflicts with existing property '%s'" % name) # reparametrization of unnamed property if reg.materials: raise ooferror.ErrSetupError( "Unnamed property in datafile conflicts with existing property '%s'" % name) # Unnamed property is being reparametrized, but it's # not used in any materials, so it's ok. reg.new_params(**kwargs) switchboard.notify("redraw") # A name collision with no parameter collision doesn't # require any action. The data file contained a property # identical to an existing property. else: # No collision, we must create a new NamedRegistration. # We know it's a NamedRegistration because unnamed # property registrations *always* produce a name conflict. fullname = string.join(treepath + [name], ":") newreg = reg.named_copy(fullname, menuitem.params[1:]) switchboard.notify("redraw")
def parallel_copyEquationState(menuitem, source, target): debug.fmsg() # Let the front-end/pre-IPC call to check this #if source == target: # raise ooferror.ErrUserError('Source and target must differ!') notifications = [] source_subp = ooflib.engine.subproblemcontext.subproblems[source] target_subp = ooflib.engine.subproblemcontext.subproblems[target] source_subp.begin_reading() target_subp.reserve() target_subp.begin_writing() try: source_obj = source_subp.getObject() target_obj = target_subp.getObject() source_eqns = source_obj.all_equations() target_eqns = target_obj.all_equations() for e in target_eqns: if not source_obj.is_active_equation(e): target_obj.deactivate_equation(e) notifications.append( ("equation activated", target, e.name(), 0)) for e in source_eqns: if not target_obj.is_active_equation(e): target_obj.activate_equation(e) notifications.append( ("equation activated", target, e.name(), 1)) finally: source_subp.end_reading() target_subp.end_writing() target_subp.cancel_reservation() for n in notifications: switchboard.notify(*n) target_subp.autoenableBCs() target_subp.changed()
def createPointBoundary(self, name, node_set, exterior=False, autoselect=1): # TODO OPT: get rid of call to list, needs typemap for sets bdy = self.getObject().makePointBoundary(name, list(node_set), exterior) context_bdy = bdy.makeContextBoundary(self, name, self.getObject()) self.pointboundaries[name] = context_bdy # Propagation up and down. # See routine above for nomenclature lament. # DeputySkeleton.mapBoundary is a no-op. sheriff = self.resolveCSkeleton(self.getObject().sheriffSkeleton()) current = sheriff children = self.undobuffer.getToTop(start=sheriff) for c in withoutDeputies(children[1:]): c.mapBoundary(context_bdy, current, direction=cskeletonselectable.MAP_DOWN) current = c current = sheriff parents = self.undobuffer.getToBottom(start=sheriff) for p in withoutDeputies(parents[1:]): p.mapBoundary(context_bdy, current, direction=cskeletonselectable.MAP_UP) current = p switchboard.notify("new boundary created", self) if autoselect: self.selectBoundary(name) # self.bdytimestamp.increment() switchboard.notify("new boundary configuration", self)
def parallel_activateField(menuitem, mesh, field): activated = False meshcontext = ooflib.engine.mesh.meshes[mesh] subpcontext = meshcontext.get_default_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", subpcontext.path(), field.name(), 1) subpcontext.changed()
def createMSFromImageFile(menuitem, filenames, microstructure_name, height, width, depth=0): if ((height != automatic and height <= 0) or (width != automatic and width <= 0) or (depth != automatic and depth <= 0)): raise ooferror.ErrUserError( "Negative microstructure sizes are not allowed.") image = autoReadImage(filenames, height, width, depth) ms = ooflib.SWIG.common.cmicrostructure.CMicrostructure( microstructure_name, image.sizeInPixels(), image.size()) immidgecontext = imagecontext.imageContexts.add( [ms.name(), image.name()], image, parent=ooflib.common.microstructure.microStructures[ms.name()]) switchboard.notify("redraw")
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 clean(self, name): path = labeltree.makePath(name) try: obj = self[path] # Who instance except KeyError: raise else: # Remove the leaf from the tree. If it's the only leaf on # its branch, remove the branch. self.members.prune(path) obj.remove() self.nmembers -= 1 # The order of these last two signals is important -- the # widgets catch the specific signal, and it's helpful to # the pages (which catch the generic signal) if the widget # is in the new state at page-update-time. obj.pause_writing() try: switchboard.notify(('remove who', self.name()), path) # specific switchboard.notify('remove who', self.name(), path) # generic finally: obj.resume_writing()
def postProcess(self, context): ## global Pcount ## Pcount += 1 ## random.seed(1) skeleton = context.getObject() prog = self.makeProgress() self.count = 0 prog.setMessage(self.header) before = skeleton.energyTotal(self.criterion.alpha) while self.iteration.goodToGo(): self.count += 1 # the context acquires the writing permissions inside # coreProcess. self.coreProcess(context) self.updateIteration(prog) skeleton.updateGeometry() switchboard.notify("skeleton homogeneity changed", context.path()) if prog.stopped(): break switchboard.notify("skeleton nodes moved", context) if prog.stopped(): self.targets.cleanUp() return after = skeleton.energyTotal(self.criterion.alpha) if before: rate = 100.0 * (before - after) / before else: rate = 0.0 diffE = after - before reporter.report("%s deltaE = %10.4e (%6.3f%%)" % (self.outro, diffE, rate)) self.targets.cleanUp() prog.finish()
def parallel_defineField(menuitem, subproblem, field): debug.fmsg() # 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.getObject(), field) meshctxt.update_fields() didsomething = True finally: subpcontext.end_writing() subpcontext.cancel_reservation() if didsomething: subpcontext.autoenableBCs() subpcontext.changed() switchboard.notify("field defined", subproblem, field.name(), 1) switchboard.notify("redraw")
def doSelectionMod(menuitem, microstructure, **params): registration = menuitem.data # create the SelectionModifier selectionModifier = registration(**params) # apply the SelectionModifier ms = ooflib.common.microstructure.microStructures[ microstructure].getObject() selection = ms.pixelselection selection.begin_writing() try: selectionModifier(ms, selection) finally: selection.end_writing() switchboard.notify('pixel selection changed') switchboard.notify('modified pixel selection', selectionModifier) switchboard.notify('new pixel selection', None, None) switchboard.notify('redraw')
def meshablePixelGroup(menuitem, microstructure, group, meshable): if parallel_enable.enabled(): pixelgroupIPC.ipcpixgrpmenu.Meshable(microstructure=microstructure, group=group, meshable=meshable) return mscontext = ooflib.common.microstructure.microStructures[microstructure] ms = mscontext.getObject() mscontext.begin_writing() try: grp = ms.findGroup(group) if grp is not None: grp.set_meshable(meshable) ms.recategorize() else: raise ooferror.ErrUserError("There is no pixel group named %s!" % group) finally: mscontext.end_writing() switchboard.notify('redraw') if grp is not None: switchboard.notify("changed pixel group", grp, microstructure)
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 deleteMaterial(self, matname, material_type): # if material_type==material.MATERIALTYPE_INTERFACE: if material_type == interface_mat_type: try: del self._materialassignments[matname] except KeyError: pass #Unassociate matname from skeleton boundaries msname = self.microstructure.name() skelclass = skeletoncontext.skeletonContexts for skelkey in skelclass.keys(base=msname): skelctxt = skelclass[[msname] + skelkey] for bname in skelctxt.allEdgeBoundaryNames(): bdyctxt = skelctxt.getBoundary(bname) if bdyctxt._interfacematerial == matname: bdyctxt._interfacematerial = None else: if len(self.namedinterfaces) == 0: return interfacenames = self.getInterfaceNames() doomedinterfaces = [] for interfacename in interfacenames: interfaceobj = self.namedinterfaces[interfacename] if interfaceobj.hasBulkMaterial(matname): del self.namedinterfaces[interfacename] doomedinterfaces.append(interfacename) self.removeMaterialFromInterfaces(doomedinterfaces) #Remove boundary conditions that refer to the doomedinterfaces meshclass = ooflib.engine.mesh.meshes msname = self.microstructure.name() for meshkey in meshclass.keys(base=msname): meshctxt = meshclass[[msname] + meshkey] for doomedinterfacename in doomedinterfaces: meshctxt.removeInterface(doomedinterfacename) self.rebuildMeshes() switchboard.notify("interface removed", self.microstructure)
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 coreProcess(self, context): skeleton = context.getObject() prog = self.makeProgress() self.totalEnergy = skeleton.energyTotal(self.criterion.alpha) self.nok = self.nbad = 0 self.deltaE = 0. activenodes = self.targets(context) random.shuffle(activenodes) j = 0 context.begin_writing() try: for node in activenodes: # obtain transition points tps = self.movedPosition(skeleton, node) changes = [] for tp in tps: if tp: change = deputy.DeputyProvisionalChanges() change.moveNode(node, tp, skeleton) changes.append(change) bestchange = self.criterion(changes, skeleton) if bestchange is not None: self.nok += 1 self.deltaE += bestchange.deltaE(skeleton, self.criterion.alpha) bestchange.accept(skeleton) else: self.nbad += 1 if prog.stopped(): return skeleton.timestamp.increment() finally: context.end_writing() switchboard.notify("redraw")
def createMSFromImage(menuitem, name, width, height, image): if parallel_enable.enabled(): # For the back-end processes from ooflib.image.IO import oofimageIPC oofimageIPC.imenu.Create_From_Image_Parallel(msname=name, image=image) # For serial mode #0 in parallel mode imagepath = labeltree.makePath(image) immidgecontext = imagecontext.imageContexts[image] immidge = immidgecontext.getObject().clone(imagepath[-1]) size = immidge.size() # Point object. if width != automatic.automatic: size[0] = width if height != automatic.automatic: size[1] = height ms = ooflib.SWIG.common.cmicrostructure.CMicrostructure( name, immidge.sizeInPixels(), size) newimagecontext = imagecontext.imageContexts.add( [name, immidge.name()], immidge, parent=ooflib.common.microstructure.microStructures[name]) switchboard.notify("redraw")
def renameMaterial(self, oldmatname, newmatname, material_type): # if material_type==material.MATERIALTYPE_INTERFACE: if material_type == interface_mat_type: try: interfacenamelist = self._materialassignments[oldmatname] del self._materialassignments[oldmatname] self._materialassignments[newmatname] = interfacenamelist except KeyError: pass #Rename materials associated with skeleton boundaries msname = self.microstructure.name() skelclass = skeletoncontext.skeletonContexts for skelkey in skelclass.keys(base=msname): skelctxt = skelclass[[msname] + skelkey] for bname in skelctxt.allEdgeBoundaryNames(): bdyctxt = skelctxt.getBoundary(bname) if bdyctxt._interfacematerial == oldmatname: bdyctxt._interfacematerial = newmatname else: for interfaceobj in self.namedinterfaces.values(): interfaceobj.renameBulkMaterial(oldmatname, newmatname) #A material has been renamed, it is possible the details of #one or more interfaces have been changed. switchboard.notify("interface renamed", self.microstructure)
def doImageMod(menuitem, image, **params): if parallel_enable.enabled(): from ooflib.image.IO import oofimageIPC paramenu = oofimageIPC.modmenu.getItem(menuitem.name) paramenu(image=image, **params) # image is the image name, actually imagectxt = imagecontext.imageContexts[image] imagectxt.reserve() try: immidge = imagectxt.getObject() # OOFImage object newimmidge = immidge.clone(immidge.name()) registration = menuitem.data imageModifier = registration(**params) # create ImageModifier obj imagectxt.begin_writing() try: imageModifier(newimmidge) # call its __call__ method on the image oofimage.pushModification(image, newimmidge) finally: imagectxt.end_writing() finally: imagectxt.cancel_reservation() switchboard.notify('modified image', imageModifier, image) switchboard.notify('redraw')
def renameBoundary(self, oldname, newname): if oldname == newname: return if newname in self.allBoundaryNames(): raise ooferror.ErrSetupError("Name %s is already in use." % newname) #Interface branch if config.dimension() == 2 and runtimeflags.surface_mode: if newname in self.allInterfaceNames(): raise ooferror.ErrSetupError( "Name %s is already in use as an interface name." % newname) if oldname in self.edgeboundaries: dict = self.edgeboundaries elif oldname in self.pointboundaries: dict = self.pointboundaries else: raise ooferror.ErrPyProgrammingError( "Boundary name %s not found." % oldname) dict[newname] = dict[oldname] del dict[oldname] # SkelContextBoundary.rename calls Skeleton.renameBoundary dict[newname].rename(newname) # Maintain consistency in Meshes for mesh in self.getMeshes(): mesh.renameBoundary(oldname, newname) switchboard.notify("boundary renamed", self) self.bdytimestamp.increment() self.selectBoundary(newname)
def _modify(menuitem, skeleton, modifier): context = skeletoncontext.skeletonContexts[skeleton] context.reserve() start_nnodes = context.getObject().nnodes() start_nelems = context.getObject().nelements() try: context.begin_writing() cdebug.ProfilerStart("mod.prof") try: skel = modifier.apply(context.getObject()) ## skel is None whenever the modifier fails ## or is interrupted from finishing its task if skel is None: reporter.warn("Modify Process Interrupted") return context.pushModification(skel) skel.needsHash() finally: context.end_writing() ## If the skeleton is modified in postProcess, use ## begin/end_writing inside the function call to guarantee ## that no dead-locking occurs because of possible switchboard ## calls that may make use of begin/end_reading(). See ## cfiddlenodes.spy for an example. modifier.postProcess(context) modifier.cleanUp() cdebug.ProfilerStop() skel.incrementTimestamp() end_nnodes = context.getObject().nnodes() end_nelems = context.getObject().nelements() if end_nnodes > start_nnodes: reporter.report(end_nnodes - start_nnodes, "more nodes.") elif end_nnodes < start_nnodes: reporter.report(start_nnodes - end_nnodes, "fewer nodes.") if end_nelems > start_nelems: reporter.report(end_nelems - start_nelems, "more elements.") elif end_nelems < start_nelems: reporter.report(start_nelems - end_nelems, "fewer elements.") finally: context.cancel_reservation() # "Skeleton modified" indicates that a specific modifier has been # applied. "Skeleton changed" indicates that something has # changed, which might or might not have involved a # SkeletonModifier. "Skeleton changed" is not redundant with "who # changed", because "who changed" is issued by pushModification # before postProcess is called, and postProcess might do most of # the work in a SkeletonModifier. ## TODO OPT: Some modifiers send these notifications in ## postProcess. Don't send them again here. switchboard.notify('Skeleton modified', skeleton, modifier) switchboard.notify('Skeleton changed', skeleton) switchboard.notify('redraw')
def _addprop(menuitem, name, property): matmanager.add_prop(name, property) switchboard.notify("material changed", name) switchboard.notify("prop_added_to_material", name, property) switchboard.notify("redraw") if parallel_enable.enabled() == 1: try: from ooflib.SWIG.common import mpitools if mpitools.Rank() == 0: materialmenuIPC.ipcmaterialmenu.Add_property(name=name, property=property) except ImportError: pass
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 changed(self, message): # Called when fields, equations, or materials have changed. self.defnChanged.increment() # timestamp self.getObject().requirePrecompute() self.findTimeDependent() self.find_second_order_fields() switchboard.notify("subproblem changed", self) ## TODO: Get rid of "mesh changed", and just use ## Mesh.setStatus? There seem to be a lot of nearly redundant ## signals. switchboard.notify("mesh changed", self.parent) fieldsdefined = self.define_timederiv_fields() for fld in fieldsdefined: switchboard.notify("field defined", self.path(), fld.name(), 1) self.getParent().setStatus(meshstatus.Unsolved(message))
def autoPixelGroup(menuitem, grouper, delta, gamma, minsize, contiguous, name_template, clear): ms = grouper.mscontext.getObject() if "%n" not in name_template: name_template = name_template + "%n" prog = progress.getProgress('AutoGroup', progress.DEFINITE) prog.setMessage('Grouping pixels...') grouper.mscontext.begin_writing() newgrpname = None try: newgrpname = statgroups.statgroups(ms, grouper.cobj, delta, gamma, minsize, contiguous, name_template, clear) finally: prog.finish() grouper.mscontext.end_writing() if newgrpname: switchboard.notify("new pixel group", ms.findGroup(newgrpname)) switchboard.notify("changed pixel groups", ms.name()) switchboard.notify("redraw")
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 _modifyCB(self, skeleton, boundary, modifier): skelctxt = skeletoncontext.skeletonContexts[skeleton] modifier(skelctxt, boundary) switchboard.notify("redraw")
def parallel_move_node(menuitem, origin, destination, allow_illegal, skeletonpath): skelcontext = skeletoncontext.skeletonContexts[skeletonpath] #skelcontext = self.gfxwindow().topwho('Skeleton') if skelcontext: skeleton = skelcontext.getObject().deputyCopy() skeleton.activate() #If one looks at moveNodeGUI.py, origin here is already #set to the position of the nearest node. node = skeleton.nearestNode(origin) nodeindex=node.getIndex() distance2=(node.position()-origin)**2 ############################################################### # Get nearest node distances from all processes if _rank==0: #Get list of squares of distance of node to the click point distance2list=[distance2] dmin=-1 dmin_proc_list=[] #Get distances from other processes for proc in range(_size): if proc!=0: distance2list.append(mpitools.Recv_Double(proc)) if distance2list[proc]>=0: dmin=distance2list[proc] #Find closest node among those "nominated" by each process for proc in range(_size): if distance2list[proc]>=0: if distance2list[proc]<dmin: dmin=distance2list[proc] for proc in range(_size): if distance2list[proc]==dmin: dmin_proc_list.append(proc) else: #Backend sends report to front end mpitools.Send_Double(distance2,0) mpitools.Barrier() #Tell the processes in dmin_proc_list to try moving their nodes #and report back the result. Then really move the node if the #move is valid for all of them. if _rank==0: for proc in range(_size): if proc in dmin_proc_list: if proc==0: moveit=1 else: mpitools.Send_Int(1,proc) else: if proc==0: moveit=0 else: mpitools.Send_Int(0,proc) else: moveit=mpitools.Recv_Int(0) mpitools.Barrier() # ############################################################### skelcontext.reserve() skelcontext.begin_writing() try: if moveit: skeleton.moveNodeTo(node, destination) #TODO 3.1: If the node is shared, the move may be valid in one process #but invalid in another. if node.illegal(): if allow_illegal==1: skeleton.setIllegal() else: node.moveBack() elif skeleton.illegal(): # node motion may have rehabilitated skeleton.checkIllegality() skelcontext.pushModification(skeleton) finally: # collect_pieces(skeleton) # skelcontext.end_writing() skelcontext.cancel_reservation() skeleton.needsHash() switchboard.notify('redraw')