def imageNameResolver(param, startname):
if param.automatic():
basename = param.group['image'].value
else:
basename = startname
imagename = labeltree.makePath(basename)[-1]
msname = labeltree.makePath(param.group['microstructure'].value)[0]
return whoville.getClass('Image').uniqueName([msname, imagename])
def imageNameResolver(param, startname):
if param.automatic():
basename = param.group['image'].value
else:
basename = startname
imagename = labeltree.makePath(basename)[-1]
msname = labeltree.makePath(param.group['microstructure'].value)[0]
return whoville.getClass('Image').uniqueName([msname, imagename])
def parallel_femesh(menuitem, name, skeleton, D_typename, T_typename,
Q_typename):
# Build edict map. Access masterelement dictionary directly
MEdict = masterelement.getMasterElementDict()
edict = {
MEdict[D_typename].nsides(): MEdict[D_typename],
MEdict[T_typename].nsides(): MEdict[T_typename],
MEdict[Q_typename].nsides(): MEdict[Q_typename]
}
skelpath = labeltree.makePath(skeleton)
skel = skeletoncontext.skeletonContexts[skelpath].getObject()
femesh = skel.femesh_shares(edict,
skeletonelement.SkeletonElement.realmaterial)
if _rank == 0:
femesh.all_meshskeletons = skel.all_skeletons
#collect_pieces(femesh)
if femesh is not None:
meshctxt = ooflib.engine.mesh.meshes.add(
skelpath + [name],
femesh,
parent=skeletoncontext.skeletonContexts[skelpath],
skeleton=skel,
elementdict=edict,
materialfactory=skeletonelement.SkeletonElement.realmaterial)
meshctxt.createDefaultSubProblem()
def set_state(self, subppath):
debug.mainthreadTest()
path = labeltree.makePath(subppath)
self.subpwidget.set_value(path)
# Retrieve the subproblem from the widget, just in case
# subppath wasn't a complete subproblem path.
subpctxt = self.currentSubProblemContext()
if subpctxt: # ie, path was complete
subp = subpctxt.getObject() # CSubProblem object
mesh = self.currentMesh()
for fname,fld in allCompoundFields.items():
fdef = subp.is_defined_field(fld)
self.fieldbuttons[(fname, "defined")].set(fdef)
self.fieldbuttons[(fname, "active")].set_sensitive(fdef)
if config.dimension() == 2:
self.fieldbuttons[(fname, "inplane")].set_sensitive(fdef)
if fdef:
self.fieldbuttons[(fname, "active")].set(
subp.is_active_field(fld))
if config.dimension() == 2:
self.fieldbuttons[(fname, "inplane")].set(
mesh.in_plane(fld))
else: # field not defined
self.fieldbuttons[(fname, "active")].set(0)
if config.dimension() == 2:
self.fieldbuttons[(fname, "inplane")].set(0)
for eqn in equation.allEquations:
active = subp.is_active_equation(eqn)
self.eqnbuttons[(eqn.name(),"active")].set(active)
else: # no current subproblem
for button in self.fieldbuttons.values():
button.set(0)
for button in self.eqnbuttons.values():
button.set(0)
self.sensitize()
def checker(self, x):
# x must be the name of a Who instance of the correct
# WhoClass.
if not (type(x) == StringType
and labeltree.makePath(x) in self.whoclass.keys()):
raise TypeError("Expected the name of a %s instance." %
self.whoclass)
def add(self, name, obj, parent, **kwargs):
assert (self.parentClass is None and parent is None) \
or isinstance(parent, self.parentClass.instanceClass)
path = labeltree.makePath(name)
if len(path) != len(self.hierarchy()):
raise ValueError(
"%s is an invalid name for an object in WhoClass %s" %
(name, self.name()))
# Silently overwrite an old object with the same name. It's
# assumed that if we got this far we know what we're doing.
try:
oldwho = self[path]
except KeyError:
pass
else:
self.remove(path)
whoobj = self.instanceClass(path[-1],
self.name(),
obj,
parent=parent,
**kwargs)
self.members[path] = whoobj
self.nmembers += 1
switchboard.notify('new who', self.name(), path) # generic version
switchboard.notify(('new who', self.name()), path) # specific version
whoobj.parallelize() # does useful work in parallel mode
return whoobj
def remove(self, name):
path = labeltree.makePath(name)
try: ## TODO: This outer try/except/else is meaningless
obj = self[path] # Who instance
except KeyError:
raise #pass # is "pass" necessary?
else:
obj.pause_writing()
try:
switchboard.notify('preremove who', self.name(), path)
switchboard.notify(('preremove who', self.name()), path)
finally:
obj.resume_writing()
# 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 rename_skeleton_CB(self,
gtkobj): # gtk callback for "Rename..." button
menuitem = skeletonmenu.Rename
namearg = menuitem.get_arg('name')
namearg.value = labeltree.makePath(self.skelwidget.get_value())[-1]
if parameterwidgets.getParameters(namearg, title='Rename skeleton'):
menuitem.callWithDefaults(skeleton=self.skelwidget.get_value())
def select(menuitem, source, method):
# source is the name of a Microstructure or Image. Get the object.
whopath = labeltree.makePath(source)
if len(whopath) == 1:
ms = whoville.getClass('Microstructure')[whopath]
source = ms
else:
assert len(whopath) == 2
ms = whoville.getClass('Microstructure')[whopath[0:1]]
source = whoville.getClass('Image')[whopath]
selection = ms.getSelectionContext()
selection.reserve()
selection.begin_writing()
try:
selection.start()
method.select(source, selection)
finally:
selection.end_writing()
selection.cancel_reservation()
# "pixel selection changed" tells UI components that reflect the
# pixel selection status to update themselves.
switchboard.notify('pixel selection changed', selection)
# The notify method for some selection methods sends a switchboard
# message indicating that the method has been used, so that it can
# be recorded in the voxel selection page's historian, for example.
method.notify()
switchboard.notify('redraw')
def checker(self, x):
# x must be the name of a Who instance of the correct
# WhoClass.
if not (type(x) == StringType and
labeltree.makePath(x) in self.whoclass.keys()):
raise TypeError("Expected the name of a %s instance."
% self.whoclass)
def set_state(self, subppath):
debug.mainthreadTest()
path = labeltree.makePath(subppath)
self.subpwidget.set_value(path)
# Retrieve the subproblem from the widget, just in case
# subppath wasn't a complete subproblem path.
subpctxt = self.currentSubProblemContext()
if subpctxt: # ie, path was complete
subp = subpctxt.getObject() # CSubProblem object
mesh = self.currentMesh()
for fname, fld in allCompoundFields.items():
fdef = subp.is_defined_field(fld)
self.fieldbuttons[(fname, "defined")].set(fdef)
self.fieldbuttons[(fname, "active")].set_sensitive(fdef)
if config.dimension() == 2:
self.fieldbuttons[(fname, "inplane")].set_sensitive(fdef)
if fdef:
self.fieldbuttons[(fname, "active")].set(
subp.is_active_field(fld))
if config.dimension() == 2:
self.fieldbuttons[(fname,
"inplane")].set(mesh.in_plane(fld))
else: # field not defined
self.fieldbuttons[(fname, "active")].set(0)
if config.dimension() == 2:
self.fieldbuttons[(fname, "inplane")].set(0)
for eqn in equation.allEquations:
active = subp.is_active_equation(eqn)
self.eqnbuttons[(eqn.name(), "active")].set(active)
else: # no current subproblem
for button in self.fieldbuttons.values():
button.set(0)
for button in self.eqnbuttons.values():
button.set(0)
self.sensitize()
def _skeleton_copy(menuitem, skeleton, name):
if parallel_enable.enabled():
from ooflib.engine.IO import skeletonIPC
skeletonIPC.smenu.Copy(skeleton=skeleton, name=name)
return
# skeleton is a colon separated string
oldskelpath = labeltree.makePath(skeleton)
oldskelcontext = skeletoncontext.skeletonContexts[skeleton]
if name is automatic.automatic:
nm = skeletoncontext.skeletonContexts.uniqueName(skeleton)
else:
nm = name
orig = oldskelcontext.getObject()
newskel = oldskelcontext.resolveCSkeleton(orig.completeCopy())
for e in oldskelcontext.edgeboundaries.values():
newskel.mapBoundary(e, orig, local=None)
for p in oldskelcontext.pointboundaries.values():
newskel.mapBoundary(p, orig, local=None)
for f in oldskelcontext.faceboundaries.values():
newskel.mapBoundary(f, orig, local=None)
msname = oldskelpath[0]
# "add" calls the SkeletonContext constructor, which calls
# "disconnect" on the skeleton, ensuring that the propagation
# we just did doesn't mess up the old skeleton context.
skeletoncontext.skeletonContexts.add(
[msname, nm], newskel, parent=microstructure.microStructures[msname])
newskelcontext = skeletoncontext.skeletonContexts[[msname, nm]]
newskelcontext.groupCopy(oldskelcontext)
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 _skeleton_copy(menuitem, skeleton, name):
if parallel_enable.enabled():
from ooflib.engine.IO import skeletonIPC
skeletonIPC.smenu.Copy(skeleton=skeleton, name=name)
return
# skeleton is a colon separated string
oldskelpath = labeltree.makePath(skeleton)
oldskelcontext = skeletoncontext.skeletonContexts[skeleton]
if name is automatic.automatic:
nm = skeletoncontext.skeletonContexts.uniqueName(skeleton)
else:
nm = name
orig = oldskelcontext.getObject()
newskel = orig.properCopy(fresh=True)
for e in oldskelcontext.edgeboundaries.values():
newskel.mapBoundary(e, orig, local=None)
for p in oldskelcontext.pointboundaries.values():
newskel.mapBoundary(p, orig, local=None)
msname = oldskelpath[0]
# "add" calls the SkeletonContext constructor, which calls
# "disconnect" on the skeleton, ensuring that the propagation
# we just did doesn't mess up the old skeleton context.
skeletoncontext.skeletonContexts.add([msname, nm], newskel, parent=microstructure.microStructures[msname])
newskelcontext = skeletoncontext.skeletonContexts[[msname, nm]]
newskelcontext.groupCopy(oldskelcontext)
def getCurrentSkeleton(self):
name = self.getCurrentSkeletonName()
path = labeltree.makePath(name)
try:
return skeletoncontext.skeletonContexts[name]
except KeyError:
return None
def _skeleton_copy_parallel(menuitem, skeleton, name):
# skeleton is a colon separated string
oldskelpath = labeltree.makePath(skeleton)
oldskelcontext = skeletoncontext.skeletonContexts[skeleton]
if name is automatic.automatic:
nm = skeletoncontext.skeletonContexts.uniqueName(skeleton)
else:
nm = name
orig = oldskelcontext.getObject()
newskel = orig.properCopy(fresh=True)
for e in oldskelcontext.edgeboundaries.values():
newskel.mapBoundary(e, orig, local=None)
for p in oldskelcontext.pointboundaries.values():
newskel.mapBoundary(p, orig, local=None)
msname = oldskelpath[0]
# "add" calls the SkeletonContext constructor, which calls
# "disconnect" on the skeleton, ensuring that the propagation
# we just did doesn't mess up the old skeleton context.
skeletoncontext.skeletonContexts.add(
[msname, nm], newskel,
parent=microstructure.microStructures[msname])
newskelcontext = skeletoncontext.skeletonContexts[ [msname, nm] ]
newskelcontext.groupCopy(oldskelcontext)
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 remove(self, name):
path = labeltree.makePath(name)
try:
obj = self[path] # Who instance
except KeyError:
raise #pass # is "pass" necessary?
else:
obj.pause_writing()
try:
switchboard.notify('preremove who', self.name(), path)
switchboard.notify(('preremove who', self.name()), path)
finally:
obj.resume_writing()
# 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 subprobRenameCB(self, gtkobj):
menuitem = mainmenu.OOF.Subproblem.Rename
namearg = menuitem.get_arg('name')
cursubprob = self.currentFullSubProblemName()
namearg.value = labeltree.makePath(cursubprob)[-1]
if parameterwidgets.getParameters(
namearg, title="Rename subproblem " + namearg.value):
menuitem.callWithDefaults(subproblem=cursubprob)
def renameCB(self, *args): # gtk button callback
menuitem = meshmenu.Rename
namearg = menuitem.get_arg('name')
curmeshpath = self.currentFullMeshName()
namearg.value = labeltree.makePath(curmeshpath)[-1]
if parameterwidgets.getParameters(namearg,
title='Rename mesh '+namearg.value):
menuitem.callWithDefaults(mesh=curmeshpath)
def set_state(self, meshpath): # widget update & information update
debug.mainthreadTest()
path = labeltree.makePath(meshpath)
self.meshwidget.set_value(path)
self.update_info()
self.set_subproblem_state()
self.sensitize()
self.sensitizeHistory()
def msImageNameResolver(param, name):
if param.automatic():
imagename = param.group['image'].value
imagepath = labeltree.makePath(imagename)
basename = imagepath[-1]
else:
basename = name
return ooflib.common.microstructure.microStructures.uniqueName(basename)
def subprobRenameCB(self, gtkobj):
menuitem = mainmenu.OOF.Subproblem.Rename
namearg = menuitem.get_arg('name')
cursubprob = self.currentFullSubProblemName()
namearg.value = labeltree.makePath(cursubprob)[-1]
if parameterwidgets.getParameters(
namearg, title="Rename subproblem " + namearg.value):
menuitem.callWithDefaults(subproblem=cursubprob)
def renameCB(self, *args): # gtk button callback
menuitem = meshmenu.Rename
namearg = menuitem.get_arg('name')
curmeshpath = self.currentFullMeshName()
namearg.value = labeltree.makePath(curmeshpath)[-1]
if parameterwidgets.getParameters(namearg,
title='Rename mesh '+namearg.value):
menuitem.callWithDefaults(mesh=curmeshpath)
def msImageNameResolver(param, name):
if param.automatic():
imagename = param.group['image'].value
imagepath = labeltree.makePath(imagename)
basename = imagepath[-1]
else:
basename = name
return ooflib.common.microstructure.microStructures.uniqueName(basename)
def set_state(self, meshpath): # widget update & information update
debug.mainthreadTest()
path = labeltree.makePath(meshpath)
self.meshwidget.set_value(path)
self.update_info()
self.set_subproblem_state()
self.sensitize()
self.sensitizeHistory()
def subproblemNameResolver(param, startname):
if param.automatic():
basename = 'subproblem'
else:
basename = startname
meshname = param.group['mesh'].value
if meshname is not None:
meshpath = labeltree.makePath(meshname)
return ooflib.engine.subproblemcontext.subproblems.uniqueName(
meshpath + [basename])
def renameMesh_parallel(menuitem, mesh, name):
oldmeshpath = labeltree.makePath(mesh)
themesh = ooflib.engine.mesh.meshes[oldmeshpath]
themesh.reserve()
themesh.begin_writing()
try:
themesh.rename(name, exclude=oldmeshpath[-1])
finally:
themesh.end_writing()
themesh.cancel_reservation()
def bcnameResolver(param, name):
if param.automatic():
basename = 'bc'
else:
basename = name
meshname = param.group['mesh'].value
if meshname is not None:
meshpath = labeltree.makePath(meshname)
meshcontext = ooflib.engine.mesh.meshes[meshpath]
return meshcontext.uniqueBCName(basename)
def subproblemNameResolver(param, startname):
if param.automatic():
basename = 'subproblem'
else:
basename = startname
meshname = param.group['mesh'].value
if meshname is not None:
meshpath = labeltree.makePath(meshname)
return ooflib.engine.subproblemcontext.subproblems.uniqueName(meshpath +
[basename])
def renameMesh_parallel(menuitem, mesh, name):
oldmeshpath = labeltree.makePath(mesh)
themesh = ooflib.engine.mesh.meshes[oldmeshpath]
themesh.reserve()
themesh.begin_writing()
try:
themesh.rename(name, exclude=oldmeshpath[-1])
finally:
themesh.end_writing()
themesh.cancel_reservation()
def bcnameResolver(param, name):
if param.automatic():
basename = 'bc'
else:
basename = name
meshname = param.group['mesh'].value
if meshname is not None:
meshpath = labeltree.makePath(meshname)
meshcontext = ooflib.engine.mesh.meshes[meshpath]
return meshcontext.uniqueBCName(basename)
def _new_subproblem(menuitem, name, mesh, subproblem):
## if parallel_enable.enabled():
## ## TODO MER: very out of date!
## ipcsubpmenu.New(name=name, mesh=mesh, subproblem=subproblem)
## return
meshcontext = ooflib.engine.mesh.meshes[mesh]
# 'subproblem' is a SubProblemType instance
subpobj = subproblem.create()
meshcontext.newSubProblem(subpobj, subproblem,
labeltree.makePath(mesh) + [name])
def getMeshes(self):
from ooflib.engine import mesh # avoid import loop
path = labeltree.makePath(self.path())
if not path:
# path can be None if we're still in the process o
# building a new SkeletonContext. In that case, there are
# no Meshes.
return []
meshnames = mesh.meshes.keys(
path, condition=lambda x: not isinstance(x, whoville.WhoProxy))
return [mesh.meshes[path + name] for name in meshnames]
def _new_subproblem(menuitem, name, mesh, subproblem):
## if parallel_enable.enabled():
## ## TODO: very out of date!
## ipcsubpmenu.New(name=name, mesh=mesh, subproblem=subproblem)
## return
meshcontext = ooflib.engine.mesh.meshes[mesh]
# 'subproblem' is a SubProblemType instance
subpobj = subproblem.create()
meshcontext.newSubProblem(subpobj,
subproblem,
labeltree.makePath(mesh)+[name])
def _skeleton_rename_parallel(menuitem, skeleton, name):
# skeleton is a colon separated string
oldskelpath = labeltree.makePath(skeleton)
skel = skeletoncontext.skeletonContexts[oldskelpath]
skel.reserve()
skel.begin_writing()
try:
skel.rename(name, exclude=oldskelpath[-1])
finally:
skel.end_writing()
skel.cancel_reservation()
def _skeleton_rename_parallel(menuitem, skeleton, name):
# skeleton is a colon separated string
oldskelpath = labeltree.makePath(skeleton)
skel = skeletoncontext.skeletonContexts[oldskelpath]
skel.reserve()
skel.begin_writing()
try:
skel.rename(name, exclude=oldskelpath[-1])
finally:
skel.end_writing()
skel.cancel_reservation()
def _newSubProblem(menuitem, mesh, name, subproblem):
meshcontext = ooflib.engine.mesh.meshes[mesh]
meshcontext.reserve()
meshcontext.begin_writing()
try:
subpobj = subproblem.create()
meshcontext.newSubProblem(subpobj, subproblem,
labeltree.makePath(mesh)+[name])
finally:
meshcontext.end_writing()
meshcontext.cancel_reservation()
def _newSubProblem(menuitem, mesh, name, subproblem):
meshcontext = ooflib.engine.mesh.meshes[mesh]
meshcontext.reserve()
meshcontext.begin_writing()
try:
subpobj = subproblem.create()
meshcontext.newSubProblem(subpobj, subproblem,
labeltree.makePath(mesh) + [name])
finally:
meshcontext.end_writing()
meshcontext.cancel_reservation()
def getMeshes(self):
from ooflib.engine import mesh # avoid import loop
path = labeltree.makePath(self.path())
if not path:
# path can be None if we're still in the process o
# building a new SkeletonContext. In that case, there are
# no Meshes.
return []
meshnames = mesh.meshes.keys(
path, condition=lambda x: not isinstance(x, whoville.WhoProxy))
return [mesh.meshes[path + name] for name in meshnames]
def update(self, skelname, locked):
debug.subthreadTest()
# Most pages are updated when their info changes even if
# they're not currently visible. Because the Skeleton Page
# displays the homogeneity which may be slow to compute, it's
# not updated unless it's currently visible.
if not self.is_current(): # not displayed in the GUI
self.postponed_update = True
return
self.postponed_update = False
skelpath = labeltree.makePath(skelname)
if skelpath:
skelctxt = skeletoncontext.skeletonContexts[skelpath]
skel = skelctxt.getObject()
## Updating the state info is done in two stages, because
## the homogeneity index can take a while to compute. In
## the first stage, the quick stuff is computed, and the
## homogeneity index is displayed as '????'.
if not locked:
skelctxt.begin_reading()
try:
ms_name = skel.MS.name()
nNodes = len(skel.nodes)
nElements = len(skel.elements)
illegalcount = skel.getIllegalCount()
shapecounts = skel.countShapes()
lr_periodicity = skel.left_right_periodicity
tb_periodicity = skel.top_bottom_periodicity
if config.dimension() == 3:
fb_periodicity = skel.front_back_periodicity
else:
fb_periodicity = False
finally:
if not locked:
skelctxt.end_reading()
mainthread.runBlock(self.writeInfoBuffer,
(nNodes, nElements, illegalcount, shapecounts,
None, lr_periodicity, tb_periodicity,
fb_periodicity))
# Homogeneity Index stuff.
if not locked:
skelctxt.begin_writing()
try:
homogIndex = skel.getHomogeneityIndex()
finally:
if not locked:
skelctxt.end_writing()
mainthread.runBlock(self.writeInfoBuffer,
(nNodes, nElements, illegalcount, shapecounts,
homogIndex, lr_periodicity, tb_periodicity,
fb_periodicity))
else:
mainthread.runBlock(self.deleteInfoBuffer)
self.sensitize()
def update(self, skelname, locked):
debug.subthreadTest()
# Most pages are updated when their info changes even if
# they're not currently visible. Because the Skeleton Page
# displays the homogeneity which may be slow to compute, it's
# not updated unless it's currently visible.
if not self.is_current(): # not displayed in the GUI
self.postponed_update = True
return
self.postponed_update = False
skelpath = labeltree.makePath(skelname)
if skelpath:
skelctxt = skeletoncontext.skeletonContexts[skelpath]
skel = skelctxt.getObject()
## Updating the state info is done in two stages, because
## the homogeneity index can take a while to compute. In
## the first stage, the quick stuff is computed, and the
## homogeneity index is displayed as '????'.
if not locked:
skelctxt.begin_reading()
try:
ms_name = skel.MS.name()
nNodes = len(skel.nodes)
nElements = len(skel.elements)
illegalcount = skel.getIllegalCount()
shapecounts = skel.countShapes()
lr_periodicity = skel.left_right_periodicity
tb_periodicity = skel.top_bottom_periodicity
if config.dimension() == 3:
fb_periodicity = skel.front_back_periodicity
else:
fb_periodicity = False
finally:
if not locked:
skelctxt.end_reading()
mainthread.runBlock(self.writeInfoBuffer,
(nNodes, nElements, illegalcount, shapecounts,
None, lr_periodicity, tb_periodicity,
fb_periodicity))
# Homogeneity Index stuff.
if not locked:
skelctxt.begin_writing()
try:
homogIndex = skel.getHomogeneityIndex()
finally:
if not locked:
skelctxt.end_writing()
mainthread.runBlock(self.writeInfoBuffer,
(nNodes, nElements, illegalcount, shapecounts,
homogIndex, lr_periodicity, tb_periodicity,
fb_periodicity))
else:
mainthread.runBlock(self.deleteInfoBuffer)
self.sensitize()
def _imageNameResolver(param, startname):
msname = labeltree.makePath(param.group['microstructure'].value)[0]
if param.automatic():
# The automatic name for an image created from orientation
# data is the filename of the data, minus any directory path
# or suffix that it might have.
msobj = ooflib.common.microstructure.microStructures[msname].getObject()
basename = os.path.splitext(os.path.split(
orientmapdata.getOrientationMapFile(msobj))[1])[0]
else:
basename = startname
return whoville.getClass('Image').uniqueName([msname, basename])
def skeletonNameResolver(param, startname):
if param.automatic():
basename = "skeleton"
else:
basename = startname
msname = param.group["microstructure"].value
mspath = labeltree.makePath(msname)
# In the command-line case, msname may not be set yet -- return
# "None" so the menu system will prompt the user.
if not mspath:
return None
return skeletoncontext.skeletonContexts.uniqueName(mspath + [basename])
def skeletonNameResolver(param, startname):
if param.automatic():
basename = 'skeleton'
else:
basename = startname
msname = param.group['microstructure'].value
mspath = labeltree.makePath(msname)
# In the command-line case, msname may not be set yet -- return
# "None" so the menu system will prompt the user.
if not mspath:
return None
return skeletoncontext.skeletonContexts.uniqueName(mspath + [basename])
def renameWhoCB(self, oldpath, newname): # sb ("rename who", classname)
# The object being renamed might be an internal node, in which
# case the path being passed in will be shorter than required
# for setting the state of this widget.
opath = labeltree.makePath(oldpath) # old path to renamed object
npath = opath[:-1] + [newname] # new path to renamed object
cpath = self.currentPath # current path
if opath == cpath[:len(opath)]: # path to current object is changing
npath += cpath[len(opath):] # new path to current object
self.buildWidgets(npath)
else: # change does not affect current object
self.buildWidgets()
def renameWhoCB(self, oldpath, newname): # sb ("rename who", classname)
# The object being renamed might be an internal node, in which
# case the path being passed in will be shorter than required
# for setting the state of this widget.
opath = labeltree.makePath(oldpath) # old path to renamed object
npath = opath[:-1] + [newname] # new path to renamed object
cpath = self.currentPath # current path
if opath == cpath[:len(opath)]: # path to current object is changing
npath += cpath[len(opath):] # new path to current object
self.buildWidgets(npath)
else: # change does not affect current object
self.buildWidgets()
def _imageNameResolver(param, startname):
msname = labeltree.makePath(param.group['microstructure'].value)[0]
if param.automatic():
# The automatic name for an image created from orientation
# data is the filename of the data, minus any directory path
# or suffix that it might have.
msobj = ooflib.common.microstructure.microStructures[msname].getObject()
basename = os.path.splitext(os.path.split(
orientmapdata.getOrientationMapFile(msobj))[1])[0]
else:
basename = startname
return whoville.getClass('Image').uniqueName([msname, basename])
def _rename_subproblem(menuitem, subproblem, name):
if parallel_enable.enabled():
ipcsubpmenu.Rename(name=name, subproblem=subproblem)
return
oldpath = labeltree.makePath(subproblem)
newpath = labeltree.makePath(subproblem)[:-1] + [name]
subprob = ooflib.engine.subproblemcontext.subproblems[oldpath]
old_dependents = subprob.subptype.get_dependents()
if subprob.name() == ooflib.engine.mesh.defaultSubProblemName:
raise ooferror.ErrUserError("You can't rename the default Subproblem!")
for dependent in old_dependents:
dependentsubp = ooflib.engine.subproblemcontext.subproblems[dependent]
dependentsubp.subptype.sync_dependency(":".join(oldpath),
":".join(newpath))
subprob.reserve()
subprob.begin_writing()
try:
subprob.rename(name, exclude=oldpath[-1])
finally:
subprob.end_writing()
subprob.cancel_reservation()
def parallel_rename_subproblem(menuitem, subproblem, name):
debug.fmsg()
oldpath = labeltree.makePath(subproblem)
subprob = ooflib.engine.subproblemcontext.subproblems[oldpath]
if subprob.name() == ooflib.engine.mesh.defaultSubProblemName:
raise ooferror.ErrUserError("You can't rename the default Subproblem!")
subprob.reserve()
subprob.begin_writing()
try:
subprob.rename(name, exclude=oldpath[-1])
finally:
subprob.end_writing()
subprob.cancel_reservation()
def _newMesh(menuitem, name, masterelems, skeleton):
skel = skeletoncontext.skeletonContexts[skeleton].getObject()
edict = getMyMasterElementDict(masterelems)
# This hard-codes the realmaterial material factory
# function. There's not much chance of ever wanting to store
# Meshes that use other factory functions.
femesh = skel.femesh(edict)
meshctxt = ooflib.engine.mesh.meshes.add(
labeltree.makePath(skeleton)+[name], femesh,
parent=skeletoncontext.skeletonContexts[skeleton],
skeleton=skel, elementdict=edict,
materialfactory=None) #skeletonelement.SkeletonElement.realmaterial)
meshctxt.createDefaultSubProblem()
def parallel_rename_subproblem(menuitem, subproblem, name):
debug.fmsg()
oldpath = labeltree.makePath(subproblem)
subprob = ooflib.engine.subproblemcontext.subproblems[oldpath]
if subprob.name() == ooflib.engine.mesh.defaultSubProblemName:
raise ooferror.ErrUserError("You can't rename the default Subproblem!")
subprob.reserve()
subprob.begin_writing()
try:
subprob.rename(name, exclude=oldpath[-1])
finally:
subprob.end_writing()
subprob.cancel_reservation()
def createMSFromImage_Parallel(menuitem, msname, image):
if _rank==0:
return
#Already done in imagemenu for process 0
imagepath = labeltree.makePath(image)
imagecontext = oofimage.imageContexts[image]
immidge = imagecontext.getObject().clone(imagepath[-1])
ms = ooflib.common.microstructure.Microstructure(msname,
immidge.sizeInPixels(),
immidge.size())
newimagecontext = oofimage.imageContexts.add([msname, immidge.name()],
immidge,
parent=ooflib.common.microstructure.microStructures[msname])
ms.addImage(newimagecontext)
def _newMesh(menuitem, name, masterelems, skeleton):
skel = skeletoncontext.skeletonContexts[skeleton].getObject()
edict = getMyMasterElementDict(masterelems)
# This hard-codes the realmaterial material factory
# function. There's not much chance of ever wanting to store
# Meshes that use other factory functions.
femesh = skel.femesh(edict, skeletonelement.SkeletonElement.realmaterial,
skeleton) #Interface branch, pass skeleton path to femesh
meshctxt = ooflib.engine.mesh.meshes.add(
labeltree.makePath(skeleton)+[name], femesh,
parent=skeletoncontext.skeletonContexts[skeleton],
skeleton=skel, elementdict=edict,
materialfactory=skeletonelement.SkeletonElement.realmaterial)
meshctxt.createDefaultSubProblem()
def rename(self, name, exclude=None):
## TODO LATER: PARALLELIZE THIS FUNCTION
oldpath = self.path() # local copy! path will change
# Make sure the new name is unique. Changing the name
# silently here is probably a bad idea.
newname = self.getClass().uniqueName(
labeltree.makePath(oldpath)[:-1]+[name], exclude=exclude)
self._name = newname
if hasattr(self._obj, "rename"):
self._obj.rename(newname)
self.pause_writing()
switchboard.notify('rename who', self.classname, oldpath, self.name())
switchboard.notify(('rename who', self.classname), oldpath, self.name())
self.resume_writing()
def uniqueName(self, name, exclude=None):
# Given a LabelTree path (list of strings, or colon separated
# substrings), returns a single string that doesn't already
# name a leaf in the same tree. For example, if the WhoClass
# contains a Who called "Hey:Bee:Sea", and you call uniqueName
# with the argument "Hey:Bee:Sea" or ["Hey", "Bee", "Sea"], it
# will return "Sea<2>". If you pass in "Hay:Bea:Sea" it will
# return "Sea".
path = labeltree.makePath(name)
try:
basenode = self.members[path[:-1]]
except KeyError:
return path[-1] # subtree doesn't exist yet
return utils.uniqueName(path[-1], basenode.children(), exclude=exclude)
def _skeleton_rename(menuitem, skeleton, name):
if parallel_enable.enabled():
from ooflib.engine.IO import skeletonIPC
skeletonIPC.smenu.Rename(skeleton=skeleton, name=name)
return
# skeleton is a colon separated string
oldskelpath = labeltree.makePath(skeleton)
skel = skeletoncontext.skeletonContexts[oldskelpath]
skel.reserve()
skel.begin_writing()
try:
skel.rename(name, exclude=oldskelpath[-1])
finally:
skel.end_writing()
skel.cancel_reservation()
def getSourceObject(self, params, gfxwindow):
# We're expecting a MicroStructure or an Image.
# params is a dictionary of parameter values that was passed
# to the menu item that was automatically created from a
# PixelSelectionRegistration by
# GenericSelectToolbox.rebuildMenus(). rebuildMenus() used
# the derived sourceParams function to add the 'source'
# parameter to the parameter list.
# gfxwindow is the GfxWindow or GhostGfxWindow that the
# selection was initiated in. It might not be needed here
# anymore.
whopath = labeltree.makePath(params['source'])
if len(whopath) == 1:
return whoville.getClass('Microstructure')[whopath]
if len(whopath) == 2:
return whoville.getClass('Image')[whopath]
def set_value(self, object):
debug.mainthreadTest()
path = labeltree.makePath(self.tree.objpath(object))
depth = len(path)
for widget in self.widgets:
widget.destroy()
self.widgets = []
tree = self.tree
depth = 0
for name in path:
names = [node.name for node in tree.nodes]
widget = chooser.ChooserWidget(names, callback=self.chooserCB,
callbackargs=(depth,),
name="%s_%d"%(self.name,depth))
depth += 1
widget.set_state(name)
self.widgets.append(widget)
self.gtk.pack_start(widget.gtk, expand=0, fill=0)
tree = tree[name]
self.gtk.show_all()