def checktest(self, *args, **kwargs):
# Run the test function.
val = func(self, *args, **kwargs)
# After running the function, delete the microstructures.
from ooflib.common.IO.mainmenu import OOF
for msname in _microstructures:
OOF.Microstructure.Delete(microstructure=msname)
# Exceptions can hold references to data. Since this file
# tests for exceptions as well as memory leaks, it's
# important to clear the exception state before checking
# for leaks.
sys.exc_clear()
gc.collect()
from ooflib.common.worker import allWorkers, allWorkerCores
from ooflib.common.IO import whoville
from ooflib.SWIG.common import cmicrostructure
from ooflib.SWIG.common import threadstate
from ooflib.SWIG.engine import cskeleton
from ooflib.SWIG.engine import csubproblem
from ooflib.SWIG.engine import femesh
from ooflib.SWIG.engine import linearizedsystem
self.assertEqual(whoville.getClass("Microstructure").nActual(), 0)
self.assertEqual(whoville.getClass("Image").nActual(), 0)
self.assertEqual(whoville.getClass("Skeleton").nActual(), 0)
self.assertEqual(whoville.getClass("Mesh").nActual(), 0)
self.assertEqual(whoville.getClass("SubProblem").nActual(), 0)
self.assertEqual(linearizedsystem.get_globalLinSysCount(),0)
self.assertEqual(cmicrostructure.get_globalMicrostructureCount(), 0)
self.assertEqual(femesh.get_globalFEMeshCount(), 0)
self.assertEqual(csubproblem.get_globalCSubProblemCount(), 0)
self.assertEqual(cskeleton.get_globalNodeCount(), 0)
self.assertEqual(cskeleton.get_globalElementCount(), 0)
self.assertEqual(len(allWorkers), 0)
## TODO: For some reason, on some systems there is
## occasionally a leftover WorkerCore when this check is
## run. It doesn't seem to have any references,
## though... Since there are no extra ThreadStates, we're
## ignoring the leftover WorkerCore for now.
# if len(allWorkerCores) > 0:
# from ooflib.common import debug
# debug.set_debug_mode()
# print >> sys.stderr, "Referrers for", allWorkerCores.keys()[0],\
# "id=", id(allWorkerCores.keys()[0])
# debug.dumpReferrers(allWorkerCores.keys()[0], 2)
# self.assertEqual(len(allWorkerCores), 0)
# The main thread still exists, but all subthreads should
# have finished.
self.assertEqual(threadstate.nThreadStates(), 1)
print >> sys.stderr, "Memory leak check passed."
return val
def lockAndDelete(self):
self.reserve()
ms = self.getObject()
try:
# We have to remove Images, etc, from the Microstructure
# *before* acquiring the write-lock on the Microstructure,
# because we can't obtain the write locks on the Image and
# the Microstructure at the same time. (An Image can't be
# locked unless it can obtain its Microstructure's read
# lock.)
for imagename in ms.imageNames():
image = whoville.getClass('Image')[[self.name(), imagename]]
image.begin_writing()
try:
image.removeMicrostructure(ms)
ms.removeImage(image)
finally:
image.end_writing()
aa = activearea.activeareaWhoClass[self.name()]
aa.begin_writing()
try:
activearea.activeareaWhoClass.remove(aa.name())
finally:
aa.end_writing()
aa.setParent(None)
pixsel = pixelselection.pixelselectionWhoClass[self.name()]
pixsel.begin_writing()
try:
pixelselection.pixelselectionWhoClass.remove(pixsel.name())
finally:
pixsel.end_writing()
pixsel.setParent(None)
# Remove Skeletons
skelclass = whoville.getClass('Skeleton')
# TODO 3D: Remove this when engine is added to 3d
if skelclass is not None:
for skeletonname in skelclass.keys(base=self.name()):
skelcontext = skelclass[[self.name(), skeletonname[0]]]
skelcontext.lockAndDelete()
skelcontext.setParent(None)
self.begin_writing()
try:
microStructures.remove(self.name())
ms.destroy()
finally:
self.end_writing()
finally:
self.cancel_reservation()
def _new_group(menuitem, skeleton, name):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
if groupset.isGroup(name):
raise ooferror.ErrUserError("Group %s already exists." % group)
else:
groupset.addGroup(name)
def Create_From_Image(self):
from ooflib.common import primitives
OOF.Microstructure.Create_From_ImageFile(
filename=reference_file("ms_data","small.ppm"),
microstructure_name=automatic,
height=20.0, width=20.0)
OOF.Microstructure.Create_From_Image(
name="new", width=automatic, height=automatic,
image="small.ppm:small.ppm")
ms_0 = getMicrostructure("small.ppm")
ms_1 = getMicrostructure("new")
# Ensure images are separate objects.
imageclass = whoville.getClass('Image')
ms_1_image_id = id(ms_1.getImageContexts()[0])
# Make sure the image wasn't copied in the source microstructure.
self.assertEqual(len(ms_0.imageNames()), 1)
# Make sure the newly constructed microstructure is the right size.
self.assertEqual(ms_1.sizeInPixels(), primitives.iPoint(150,150))
self.assertEqual(ms_1.size(), primitives.Point(20.0, 20.0))
self.assertEqual(ms_1.sizeOfPixels(), (20.0/150, 20.0/150))
OOF.Microstructure.Delete(microstructure="small.ppm")
# Ensure that after the originating microstructure has been
# deleted, the derived one still has the same image.
self.assert_("small.ppm" in ms_1.imageNames())
self.assertEqual(ms_1_image_id, id(ms_1.getImageContexts()[0]))
def _copy_group(menuitem, skeleton, group, new_name):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
if groupset.isGroup(new_name):
raise ooferror.ErrUserError("Group %s already exists." % new_name)
if groupset.isGroup(group):
groupset.copyGroup(group, new_name)
def _auto_group(menuitem, skeleton):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
ms = skelc.getMicrostructure() # ms object, not context
mscontext = microstructure.microStructures[ms.name()]
mscontext.begin_reading()
# gdict is a dict of lists of objects to add to each group, keyed
# by group name
gdict = {}
try:
# Create groups
groupnames = ms.groupNames() # all pixel group names in ms
newgrps = [name for name in groupnames if not groupset.isGroup(name)]
groupset.addGroup(*newgrps)
# Find objects to add to groups
for obj in menuitem.iterator(skelc.getObject().sheriffSkeleton()):
cat = obj.dominantPixel(ms) # dominant pxl category
repPix = ms.getRepresentativePixel(cat) # representative pixel
# grplist contains all pixel group names at the repr. pixel
grplist = pixelgroup.pixelGroupNames(ms, repPix)
for name in grplist:
gdict.setdefault(name, []).append(obj)
# Actually add objects to groups
groupset.addToGroup(**gdict)
finally:
mscontext.end_reading()
def _remove_group(menuitem, skeleton, group):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
if not groupset.isGroup(group):
raise ooferror.ErrUserError("Group %s does not exist." % group)
else:
groupset.removeGroup(group)
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 whoNameCheck(whoclass, names):
from ooflib.common.IO import whoville
classmembers = whoville.getClass(whoclass).actualMembers()
if len(classmembers) != len(names):
return False
for whoobj in classmembers:
if whoobj.name() not in names:
return False
return True
def __init__(self, value=None, scope=None, name=None):
whowidget.WhoParameterWidget.__init__(
self,
whoclass=whoville.getClass("Microstructure"),
value=value,
scope=scope,
name=name,
condition=_withoutOrientationMap,
)
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 __call__(self, ms, selection):
curselection = selection.getObject()
# 'cause my teeth are perly...
image = whoville.getClass('Image')[self.image]
imageobj = image.getObject()
ms = image.getMicrostructure()
selection.start()
selection.clearAndSelect(
pixelselectioncourieri.ColorSelection(ms, imageobj,
self.reference, self.range))
def _sensitize(path):
msclass = whoville.getClass('Microstructure')
# If this module was somehow loaded first, the Microstructure
# class might not be defined.
if msclass and msclass.nActual() > 0:
orientmapmenu.enable()
mainmenu.OOF.File.Load.OrientationMap.enable()
else:
orientmapmenu.disable()
mainmenu.OOF.File.Load.OrientationMap.disable()
def skeletonElementSelectionCheck(skeleton, elemlist):
from ooflib.common.IO import whoville
sc = whoville.getClass('Skeleton')[skeleton]
elems = sc.elementselection.retrieve()
elemindices = [el.index for el in elems]
elemindices.sort()
elemlist.sort()
ok = (elemindices == elemlist)
if not ok:
print >> sys.stderr, elemindices
return ok
def skeletonSegmentSelectionCheck(skeleton, seglist):
from ooflib.common.IO import whoville
sc = whoville.getClass('Skeleton')[skeleton]
segs = sc.segmentselection.retrieve()
nodepairs = [[n.index for n in seg.nodes()] for seg in segs]
nodepairs.sort()
seglist.sort()
ok = nodepairs == seglist
if not ok:
print >> sys.stderr, nodepairs
return ok
def skeletonNodeSelectionCheck(skeleton, nodelist):
from ooflib.common.IO import whoville
sc = whoville.getClass('Skeleton')[skeleton]
nodes = sc.nodeselection.retrieve()
nodeindices = [node.index for node in nodes]
nodeindices.sort()
nodelist.sort()
ok = (nodeindices == nodelist)
if not ok:
print >> sys.stderr, nodeindices
return ok
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 changeDisplayedObject(self, category, object):
if not LayerEditor.recursionInhibitor:
LayerEditor.recursionInhibitor = 1
self.currentWhoClass = whoville.getClass(category)
if self.currentWhoClass is not None:
try:
who = self.currentWhoClass[object]
except KeyError:
who = None
else:
who = None
self.currentLayerSet.changeWho(who)
self.updateEditee()
LayerEditor.recursionInhibitor = 0
def buildWidget(self):
debug.mainthreadTest()
if self.whopwidget:
self.whopwidget.destroy()
self.whoclassname = self.classwidget.get_value()
whoclass = whoville.getClass(self.whoclassname)
# Create a WhoWidget that doesn't exclude proxy who
# objects. If it's necessary to create an
# AnyWhoParameterWidget with a different exclusion policy,
# then the AnyWhoParameter will need to have a 'condition'
# attribute that can be passed in to the widget.
self.whopwidget = WhoParameterWidget(whoclass, scope=self,
sort=whoville.proxiesLast,
condition=lambda x:1)
self.gtk.pack_start(self.whopwidget.gtk)
self.gtk.show_all()
def buildImageModMenu():
imagemodmenu.clearMenu()
for registration in imagemodifier.ImageModifier.registry:
try:
help = registration.tip
except AttributeError:
help = None
params = [whoville.WhoParameter('image', whoville.getClass('Image'),
tip=parameter.emptyTipString)] \
+ registration.params
menuitem = imagemodmenu.addItem(
oofmenu.OOFMenuItem(registration.name(),
callback=imagemodifier.doImageMod,
params=params,
help=help,
discussion=registration.discussion))
menuitem.data = registration
def _query_elem_group(menuitem, skeleton, group):
skelc = whoville.getClass('Skeleton')[skeleton]
members = skelc.elementgroups.get_group(group)
area = 0.0
homog = 0.0
for element in members:
area += element.area()
homog += element.homogeneity(skelc.getObject().MS)
if len(members):
homog /= len(members)
plural="s"*(len(members)!=1)
strings = ["Group '%s'" % group,
"%d element%s" % (len(members), "s"*(len(members)!=1)),
"area=%s" % area,
"average homogeneity=%g" % homog]
matl = skelc.elementgroups.getMaterial(group)
if matl is not None:
strings.append("material=%s" % matl.name())
reporter.report(", ".join(strings))
def sensitize_thread(self, skelselected, undoable, redoable, not_illegal):
debug.mainthreadTest()
self.okbutton.set_sensitive(skelselected and self.skelmod.isValid()
and not_illegal)
self.undobutton.set_sensitive(undoable)
self.redobutton.set_sensitive(redoable)
msclass = whoville.getClass('Microstructure')
havems = msclass is not None and msclass.nActual() > 0
self.newbutton.set_sensitive(havems)
self.simplebutton.set_sensitive(havems)
self.autobutton.set_sensitive(havems)
self.deletebutton.set_sensitive(skelselected)
self.renamebutton.set_sensitive(skelselected)
self.copybutton.set_sensitive(skelselected)
self.savebutton.set_sensitive(skelselected)
if not self.getSkeletonAvailability():
self.okbutton.set_sensitive(0)
self.undobutton.set_sensitive(0)
self.redobutton.set_sensitive(0)
self.sensitizeHistory_thread()
gtklogger.checkpoint("skeleton page sensitized")
def loadImageIntoMS(image, microstructure):
# 'image' is an OOFImage object.
# 'microstructure' is a Microstructure name.
# See if the Microstructure already exists
msclass = whoville.getClass('Microstructure')
try: # look for existing microstructure
ms = msclass[microstructure] # Who object
except KeyError:
msobj = ooflib.common.microstructure.Microstructure(microstructure,
image.sizeInPixels(),
image.size())
ms = msclass.add(microstructure, msobj, parent=None)
# Check size of microstructure
if ms.getObject().sizeInPixels() != image.sizeInPixels():
raise ooferror.ErrUserError("Cannot load an image into an existing Microstructure of a different size.")
# See if the image name is unique in the Microstructure
newname = imagecontext.imageContexts.uniqueName([ms.name(), image.name()])
image.rename(newname)
# Create ImageContext object
immidgecontext = imagecontext.imageContexts.add([ms.name(),newname], image,
parent=ms)
def activeVolumeOverrideCheck(o):
from ooflib.common.IO import whoville
ms = whoville.getClass('Microstructure')['5color'].getObject()
return ms.activearea.getOverride() == o
def _query_sgmt_group(menuitem, skeleton, group):
skelc = whoville.getClass('Skeleton')[skeleton]
members = skelc.segmentgroups.get_group(group)
plural = "s" * (len(members) != 1)
reporter.report(">>> ", len(members), " segment" + plural)
def _remove_matl(menuitem, skeleton, group):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
if not groupset.isGroup(group):
raise ooferror.ErrUserError("Group %s does not exist." % group)
groupset.removeMaterial(group)
def _clear_all_groups(menuitem, skeleton):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
groupset.clearGroup(*groupset.allGroups())
def _rename_group(menuitem, skeleton, group, new_name):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
groupset.renameGroup(group, new_name)
def _query_sgmt_group(menuitem, skeleton, group):
skelc = whoville.getClass('Skeleton')[skeleton]
members = skelc.segmentgroups.get_group(group)
plural="s"*(len(members)!=1)
reporter.report(">>> ", len(members), " segment"+plural )
def _rename_group(menuitem, skeleton, group, new_name):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
groupset.renameGroup(group, new_name)
switchboard.notify("redraw")
# Gets the default name from the object being copied (or renamed).
def getBasename(self, param, startname):
if param.automatic():
return param.group['group'].value
return startname
#######################################
# Node-specific menu items:
new = oofmenu.OOFMenuItem(
"New_Group",
cli_only=1,
callback=_new_group,
params=parameter.ParameterGroup(
whoville.WhoParameter("skeleton", whoville.getClass('Skeleton'),
tip=parameter.emptyTipString),
AutomaticNameParameter("name", value=automatic.automatic,
resolver=NewGroupNameResolver("nodegroup",
"nodegroups"),
tip="Name of the group to be created.")),
help="Create a new node group.",
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/newnodegroup.xml')
)
new.data = "nodegroups"
nodegroupmenu.addItem(new)
auto = oofmenu.OOFMenuItem(
"Auto_Group",
cli_only=1,
callback=_auto_group,
def __init__(self):
oofGUI.MainPage.__init__(self,
name="Pin Nodes",
ordering=120.1,
tip='Pin and unpin nodes')
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
self.skelwidget = whowidget.WhoWidget(whoville.getClass('Skeleton'),
callback=self.select_skeletonCB)
label = gtk.Label('Microstructure=')
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.skelwidget.gtk[0], expand=0, fill=0)
label = gtk.Label('Skeleton=')
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.skelwidget.gtk[1], expand=0, fill=0)
mainpane = gtk.HPaned()
gtklogger.setWidgetName(mainpane, 'Pane')
mainbox.pack_start(mainpane, expand=1, fill=1)
gtklogger.connect_passive(mainpane, 'notify::position')
# Pinned nodes status in the left half of the main pane
pnsframe = gtk.Frame("Pinned Nodes Status")
pnsframe.set_shadow_type(gtk.SHADOW_IN)
self.datascroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.datascroll, "StatusScroll")
pnsframe.add(self.datascroll)
self.datascroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.psdata = fixedwidthtext.FixedWidthTextView()
self.psdata.set_editable(False)
self.psdata.set_wrap_mode(gtk.WRAP_WORD)
self.psdata.set_cursor_visible(False)
self.datascroll.add_with_viewport(self.psdata)
mainpane.pack1(pnsframe, resize=1, shrink=0)
# Pin nodes method
modframe = gtk.Frame("Pin Nodes Methods")
gtklogger.setWidgetName(modframe, 'Modify')
modframe.set_shadow_type(gtk.SHADOW_IN)
modbox = gtk.VBox() # will have "methods" and "buttons"
modframe.add(modbox)
self.pinModFactory = regclassfactory.RegisteredClassFactory(
pinnodesmodifier.PinNodesModifier.registry,
title="Method:",
scope=self,
name="Method")
modbox.pack_start(self.pinModFactory.gtk, expand=1, fill=1, padding=2)
# buttons
hbox1 = gtk.HBox()
modbox.pack_start(hbox1, expand=0, fill=0, padding=2)
self.okbutton = gtk.Button(stock=gtk.STOCK_OK)
gtklogger.setWidgetName(self.okbutton, 'OK')
gtklogger.connect(self.okbutton, "clicked", self.okCB)
tooltips.set_tooltip_text(self.okbutton,
"Pin nodes with the selected method.")
self.undobutton = gtk.Button(stock=gtk.STOCK_UNDO)
gtklogger.setWidgetName(self.undobutton, 'Undo')
gtklogger.connect(self.undobutton, "clicked", self.undoCB)
tooltips.set_tooltip_text(self.undobutton, "Undo the latest action.")
self.redobutton = gtk.Button(stock=gtk.STOCK_REDO)
gtklogger.setWidgetName(self.redobutton, 'Redo')
gtklogger.connect(self.redobutton, "clicked", self.redoCB)
tooltips.set_tooltip_text(self.redobutton,
"Redo the latest undone action.")
hbox1.pack_start(self.undobutton, expand=0, fill=1, padding=2)
hbox1.pack_start(self.okbutton, expand=1, fill=1, padding=2)
hbox1.pack_end(self.redobutton, expand=0, fill=1, padding=2)
hbox2 = gtk.HBox(homogeneous=1)
modbox.pack_start(hbox2, expand=0, fill=0, padding=2)
self.unpinallbutton = gtk.Button("Unpin All")
gtklogger.setWidgetName(self.unpinallbutton, 'Unpin All')
gtklogger.connect(self.unpinallbutton, "clicked", self.unpinallCB)
tooltips.set_tooltip_text(self.unpinallbutton,
"Unpin all the pinned nodes.")
self.invertbutton = gtk.Button("Invert")
gtklogger.setWidgetName(self.invertbutton, 'Invert')
gtklogger.connect(self.invertbutton, "clicked", self.invertCB)
tooltips.set_tooltip_text(
self.invertbutton,
"Invert - pin the unpinned and unpin the pinned.")
hbox2.pack_start(self.unpinallbutton, expand=1, fill=1, padding=2)
hbox2.pack_start(self.invertbutton, expand=1, fill=1, padding=2)
mainpane.pack2(modframe, resize=0, shrink=0)
# Switchboard callbacks
switchboard.requestCallbackMain(('who changed', 'Skeleton'),
self.changeSkeleton)
switchboard.requestCallbackMain(('new who', 'Microstructure'),
self.newMS)
switchboard.requestCallbackMain("new pinned nodes",
self.newNodesPinned)
switchboard.requestCallbackMain(self.skelwidget, self.skel_update)
switchboard.requestCallbackMain("made reservation",
self.reservationChanged)
switchboard.requestCallbackMain("cancelled reservation",
self.reservationChanged)
def skeletonSizeCheck(skeleton, nel, nnode):
from ooflib.common.IO import whoville
skel = whoville.getClass('Skeleton')[skeleton].getObject()
return skel.nelements() == nel and skel.nnodes() == nnode
def skeletonElementSelectionSizeCheck(skeleton, n):
from ooflib.common.IO import whoville
sc = whoville.getClass('Skeleton')[skeleton]
return sc.elementselection.size() == n
def checktest(self, *args, **kwargs):
# Run the test function.
try:
val = func(self, *args, **kwargs)
finally:
# After running the function, delete the microstructures.
from ooflib.common.IO.mainmenu import OOF
for msname in _microstructures:
OOF.Microstructure.Delete(microstructure=msname)
# Exceptions can hold references to data. Since this file
# tests for exceptions as well as memory leaks, it's
# important to clear the exception state before checking
# for leaks.
sys.exc_clear()
gc.collect()
from ooflib.common.worker import allWorkers, allWorkerCores
from ooflib.common.IO import whoville
from ooflib.SWIG.common import config
from ooflib.SWIG.common import cmicrostructure
from ooflib.SWIG.common import threadstate
if config.dimension() == 2:
from ooflib.SWIG.engine.cskeleton import get_globalNodeCount
from ooflib.SWIG.engine.cskeleton import get_globalElementCount
else:
from ooflib.SWIG.engine.cskeletonnode2 import get_globalNodeCount
from ooflib.SWIG.engine.cskeletonface import get_globalFaceCount, get_globalOrientedFaceCount
from ooflib.SWIG.engine.cskeletonelement import get_globalElementCount
from ooflib.SWIG.engine.cskeletonselectable import getTrackerCount
from ooflib.SWIG.engine import csubproblem
from ooflib.SWIG.engine import femesh
from ooflib.SWIG.engine import linearizedsystem
from ooflib.SWIG.engine import sparsemat
self.assertEqual(whoville.getClass("Microstructure").nActual(), 0)
self.assertEqual(whoville.getClass("Image").nActual(), 0)
self.assertEqual(whoville.getClass("Skeleton").nActual(), 0)
self.assertEqual(whoville.getClass("Mesh").nActual(), 0)
self.assertEqual(whoville.getClass("SubProblem").nActual(), 0)
self.assertEqual(linearizedsystem.get_globalLinSysCount(), 0)
self.assertEqual(cmicrostructure.get_globalMicrostructureCount(),
0)
self.assertEqual(get_globalNodeCount(), 0) # skeleton nodes
self.assertEqual(get_globalFaceCount(), 0) # skeleton faces
self.assertEqual(get_globalOrientedFaceCount(), 0)
self.assertEqual(get_globalElementCount(), 0) # skeleton elements
self.assertEqual(femesh.get_globalFEMeshCount(), 0)
self.assertEqual(csubproblem.get_globalCSubProblemCount(), 0)
self.assertEqual(getTrackerCount(), 0)
self.assertEqual(sparsemat.nSparseMatCores(), 0)
self.assertEqual(len(allWorkers), 0)
## TODO 3.1: For some reason, on some systems there is
## occasionally a leftover WorkerCore when this check is
## run. It doesn't seem to have any references,
## though... Since there are no extra ThreadStates, we're
## ignoring the leftover WorkerCore for now.
# if len(allWorkerCores) > 0:
# from ooflib.common import debug
# debug.set_debug_mode()
# print >> sys.stderr, "Referrers for", allWorkerCores.keys()[0],\
# "id=", id(allWorkerCores.keys()[0])
# debug.dumpReferrers(allWorkerCores.keys()[0], 2)
# self.assertEqual(len(allWorkerCores), 0)
# The main thread still exists, but all subthreads should
# have finished.
self.assertEqual(threadstate.nThreadStates(), 1)
print >> sys.stderr, "Memory leak check passed."
return val
def _rename_group(menuitem, skeleton, group, new_name):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
groupset.renameGroup(group, new_name)
def _assign_matl(menuitem, skeleton, group, material):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
if not groupset.isGroup(group):
raise ooferror.ErrUserError("Group %s does not exist." % group)
groupset.assignMaterial(group, materialmanager.getMaterial(material))
def __init__(self, gfxwindow):
toolbox.Toolbox.__init__(self, 'Pin_Nodes', gfxwindow)
self.skeleton_param = whoville.WhoParameter(
'skeleton',
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)
def __init__(self):
oofGUI.MainPage.__init__(self,
name="Equations",
ordering=220,
tip="Define equations for the mesh to solve.")
mainbox = gtk.VBox()
self.gtk.add(mainbox)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
self.subpwidget = whowidget.WhoWidget(whoville.getClass('SubProblem'),
scope=self)
switchboard.requestCallbackMain(self.subpwidget, self.subpwidgetCB)
label = gtk.Label("Microstructure=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.subpwidget.gtk[0], expand=0, fill=0)
label = gtk.Label("Skeleton=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.subpwidget.gtk[1], expand=0, fill=0)
label = gtk.Label("Mesh=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.subpwidget.gtk[2], expand=0, fill=0)
label = gtk.Label("SubProblem=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.subpwidget.gtk[3], expand=0, fill=0)
eqnframe = gtk.Frame("Equations")
eqnframe.set_shadow_type(gtk.SHADOW_IN)
scroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(scroll, "Equations")
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
eqnframe.add(scroll)
bbox = gtk.VBox(
) # extra layer keeps table from expanding inside scroll
scroll.add_with_viewport(bbox)
self.eqntable = gtk.Table()
bbox.pack_start(self.eqntable, expand=0, fill=0)
self.eqnbuttons = {}
self.build_eqnTable()
switchboard.requestCallbackMain("new equation", self.newEquationCB)
switchboard.requestCallbackMain("equation activated",
self.activateEqnCB)
# switchboard.requestCallbackMain("kinetics activated",
# self.activateKinCB)
# switchboard.requestCallbackMain("dynamics activated",
# self.activateDynCB)
mainbox.pack_start(eqnframe, expand=1, fill=1)
copybox = gtk.HBox(spacing=3)
self.copybutton = gtk.Button("Copy Equation State")
gtklogger.setWidgetName(self.copybutton, "Copy")
gtklogger.connect(self.copybutton, "clicked", self.copyeqstateCB)
copybox.pack_start(self.copybutton, expand=1, fill=0)
mainbox.pack_start(copybox, expand=0, fill=0)
tooltips.set_tooltip_text(
self.copybutton,
"Copy the status of all equations from the current mesh to another mesh."
)
switchboard.requestCallbackMain(("new who", "Microstructure"),
self.newSkeletonOrMesh)
switchboard.requestCallbackMain(("new who", "Skeleton"),
self.newSkeletonOrMesh)
switchboard.requestCallbackMain(("new who", "Mesh"),
self.newSkeletonOrMesh)
## switchboard.requestCallbackMain(("new who", "SubProblem"),
## self.newSubProblem)
## switchboard.requestCallbackMain(("remove who", "SubProblem"),
## self.removeSubProblem)
switchboard.requestCallbackMain("made reservation",
self.reservationChanged)
switchboard.requestCallbackMain("cancelled reservation",
self.reservationChanged)
def pixelGroupSizeCheck(msname, grpname, n):
from ooflib.common.IO import whoville
ms = whoville.getClass('Microstructure')[msname].getObject()
grp = ms.findGroup(grpname)
return len(grp) == n
def _clear_group(menuitem, skeleton, group):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
if not groupset.isGroup(group):
raise ooferror.ErrUserError("Group %s does not exist." % group)
groupset.clearGroup(group)
def makeMenu(menu, modifier, selection_name):
menu.clearMenu()
objname = selection_name[:-9] # 'node', 'segment', or 'element'
undo_item = menu.addItem(
oofmenu.OOFMenuItem(
"Undo",
callback=_undo,
params=[
whoville.WhoParameter("skeleton",
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)
],
help="Undo the latest Skeleton %s selection operation." % objname,
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/%s_undo.xml' % objname)))
undo_item.data = selection_name
redo_item = menu.addItem(oofmenu.OOFMenuItem(
"Redo", callback=_redo,
params = [
whoville.WhoParameter("skeleton",
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)],
help="Redo the latest undone Skeleton %s selection operation."\
% objname,
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/%s_redo.xml'
% objname)
))
redo_item.data = selection_name
clear_item = menu.addItem(
oofmenu.OOFMenuItem(
"Clear",
callback=_clear,
params=[
whoville.WhoParameter("skeleton",
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)
],
help="Clear the current Skeleton %s selection." % objname,
discussion="<para>Unselect all %ss in the &skel;.</para>" %
objname))
clear_item.data = selection_name
invert_item = menu.addItem(
oofmenu.OOFMenuItem(
"Invert",
callback=_invert,
params=[
whoville.WhoParameter("skeleton",
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)
],
help="Invert the current Skeleton %s selection." % objname,
discussion="""<para>
Select the unselected %ss, and unselect the selected %ss in the &skel;.
</para>""" % (objname, objname)))
invert_item.data = selection_name
for r in modifier.registry:
# For help
try:
help = r.tip
except AttributeError:
help = None
# For discussion
try:
discussion = r.discussion
except AttributeError:
discussion = None
menuitem = menu.addItem(
oofmenu.OOFMenuItem(
utils.space2underscore(r.name()),
callback=skeletonselectionmod.modify,
params=[
whoville.WhoParameter("skeleton",
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString)
] + r.params,
help=help,
discussion=discussion))
menuitem.data = r
def _assign_matl(menuitem, skeleton, group, material):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
if not groupset.isGroup(group):
raise ooferror.ErrUserError("Group %s does not exist." % group)
groupset.assignMaterial(group, materialmanager.getMaterial(material))
def __init__(self):
self.built = False
oofGUI.MainPage.__init__(
self,
name="Interfaces",
ordering=105,
tip="Create named one-dimensional interfaces.")
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
#skelwidget is really an mswidget
self.skelwidget = whowidget.WhoWidget(
whoville.getClass('Microstructure'), scope=self)
switchboard.requestCallbackMain(self.skelwidget, self.widgetChanged)
label = gtk.Label('Microstructure=')
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.skelwidget.gtk[0], expand=0, fill=0)
#We might want to include a skeleton in the widget, if an interface
#is defined in terms of skeleton segments. For now the interface is
#only associated with a microstructure
## label = gtk.Label('Skeleton=')
## label.set_alignment(1.0, 0.5)
## centerbox.pack_start(label, expand=0, fill=0)
## centerbox.pack_start(self.skelwidget.gtk[1], expand=0, fill=0)
mainpane = gtk.HPaned()
gtklogger.setWidgetName(mainpane, 'Pane')
mainbox.pack_start(mainpane, expand=1, fill=1)
interfacelistframe = gtk.Frame("Interfaces")
gtklogger.setWidgetName(interfacelistframe, 'Interfaces')
gtklogger.connect_passive(interfacelistframe, 'size-allocate')
interfacelistframe.set_shadow_type(gtk.SHADOW_IN)
mainpane.pack1(interfacelistframe, resize=0, shrink=0)
interfacelistbox = gtk.VBox()
interfacelistframe.add(interfacelistbox)
# List of all the named interfaces
self.interfacelist = chooser.ScrolledChooserListWidget(
callback=self.interfacelistCB,
## dbcallback=self.modifyBoundaryCB,
autoselect=0,
name="InterfaceList")
interfacelistbox.pack_start(self.interfacelist.gtk, expand=1, fill=1)
interfacebuttonbox = gtk.HBox(homogeneous=1, spacing=2)
interfacelistbox.pack_start(interfacebuttonbox, expand=0, fill=0)
# Buttons that actually do stuff.
self.newbutton = gtk.Button("New...")
gtklogger.setWidgetName(self.newbutton, 'New')
gtklogger.connect(self.newbutton, "clicked", self.newInterfaceCB)
tooltips.set_tooltip_text(
self.newbutton,
"Construct a new interface in the microstructure and associated meshes."
)
interfacebuttonbox.pack_start(self.newbutton, expand=1, fill=1)
self.renamebutton = gtk.Button("Rename...")
gtklogger.setWidgetName(self.renamebutton, 'Rename')
gtklogger.connect(self.renamebutton, "clicked", self.renameInterfaceCB)
tooltips.set_tooltip_text(self.renamebutton,
"Rename the selected interface.")
interfacebuttonbox.pack_start(self.renamebutton, expand=1, fill=1)
self.deletebutton = gtk.Button("Delete")
gtklogger.setWidgetName(self.deletebutton, 'Delete')
gtklogger.connect(self.deletebutton, "clicked", self.deleteInterfaceCB)
tooltips.set_tooltip_text(
self.deletebutton,
"Delete the selected interface from the microstructure and associated meshes."
)
interfacebuttonbox.pack_start(self.deletebutton, expand=1, fill=1)
########## Adding and removing interface materials
materialbuttonbox = gtk.HBox(homogeneous=1, spacing=2)
interfacelistbox.pack_start(materialbuttonbox, expand=0, fill=0)
self.assignmatbutton = gtk.Button("Assign interface material...")
gtklogger.setWidgetName(self.assignmatbutton, 'Assign material')
gtklogger.connect(self.assignmatbutton, "clicked", self.assignmatCB)
tooltips.set_tooltip_text(self.assignmatbutton,
"Assign material to interface.")
materialbuttonbox.pack_start(self.assignmatbutton, expand=1, fill=1)
self.removematbutton = gtk.Button("Remove material")
gtklogger.setWidgetName(self.removematbutton, 'Remove material')
gtklogger.connect(self.removematbutton, "clicked", self.removematCB)
tooltips.set_tooltip_text(self.removematbutton,
"Remove material from interface.")
materialbuttonbox.pack_start(self.removematbutton, expand=1, fill=1)
####################################
infoframe = gtk.Frame("Interface details")
infoframe.set_shadow_type(gtk.SHADOW_IN)
mainpane.pack2(infoframe, resize=1, shrink=1)
infowindow = gtk.ScrolledWindow()
gtklogger.logScrollBars(infowindow, "InfoScroll")
infowindow.set_shadow_type(gtk.SHADOW_IN)
infoframe.add(infowindow)
infowindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.infotext = fixedwidthtext.FixedWidthTextView()
self.infotext.set_wrap_mode(gtk.WRAP_WORD)
gtklogger.setWidgetName(self.infotext, 'status')
self.infotext.set_editable(False)
infowindow.add(self.infotext)
self.built = True
switchboard.requestCallbackMain("new interface created",
self.newInterfaceUpdatePageCB)
switchboard.requestCallbackMain("interface removed",
self.newInterfaceUpdatePageCB)
switchboard.requestCallbackMain("interface renamed",
self.newInterfaceUpdatePageCB),
## switchboard.requestCallbackMain("remove_material",self.del_mat)
#TODO: Enable something like this later?
## switchboard.requestCallbackMain(("new who", "Microstructure"),
## self.newMicrostructureCB)
self.selectsignals = [
switchboard.requestCallbackMain("interface selected",
self.interfaceSelectedCB),
switchboard.requestCallbackMain("interface unselected",
self.interfaceUnselectedCB)
]
def __call__(self, param, startname):
skelname = param.group['skeleton'].value
skelcontext = whoville.getClass('Skeleton')[skelname]
groupset = getattr(skelcontext, self.attrname)
return utils.uniqueName(self.getBasename(param, startname),
list(groupset.allGroups()))
def __init__(self, name, value=None, default=None, tip=None):
whoville.WhoParameter.__init__(self, name,
whoville.getClass('Microstructure'),
value=value, default=default, tip=tip)
def pixelSelectionSizeCheck(msname, n):
from ooflib.common.IO import whoville
ms = whoville.getClass('Microstructure')[msname].getObject()
return ms.pixelselection.size() == n
if config.dimension() == 2:
def loadImage(menuitem, filename, microstructure, height, width):
if filename:
# Read file and create an OOFImage object
image = autoReadImage(filename, height, width, depth=0)
loadImageIntoMS(image, microstructure)
switchboard.notify("redraw")
imageparams = parameter.ParameterGroup(
filenameparam.ReadFileNameParameter('filename',
'image',
tip="Name of the image file."),
whoville.WhoParameter('microstructure',
whoville.getClass('Microstructure'),
tip=parameter.emptyTipString))
elif config.dimension() == 3:
def loadImage(menuitem, filenames, microstructure, height, width, depth):
if filenames:
# Read file and create an OOFImage3D object
image = autoReadImage(filenames, height, width, depth)
loadImageIntoMS(image, microstructure)
switchboard.notify("redraw")
imageparams = parameter.ParameterGroup(
parameter.RegisteredParameter("filenames",
oofimage.ThreeDImageSpecification),
whoville.WhoParameter('microstructure',
def pinnedNodesSkelCheck(skelname, n):
from ooflib.common.IO import whoville
skelctxt = whoville.getClass('Skeleton')[skelname]
return skelctxt.pinnednodes.npinned() == n
if param.automatic():
return param.group['group'].value
return startname
#######################################
# Node-specific menu items:
new = oofmenu.OOFMenuItem(
"New_Group",
cli_only=1,
callback=_new_group,
params=parameter.ParameterGroup(
whoville.WhoParameter("skeleton",
whoville.getClass('Skeleton'),
tip=parameter.emptyTipString),
AutomaticNameParameter("name",
value=automatic.automatic,
resolver=NewGroupNameResolver(
"nodegroup", "nodegroups"),
tip="Name of the group to be created.")),
help="Create a new node group.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/newnodegroup.xml'))
new.data = "nodegroups"
nodegroupmenu.addItem(new)
auto = oofmenu.OOFMenuItem(
"Auto_Group",
cli_only=1,
def _remove_selection_from_group(menuitem, skeleton, group):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
groupset.removeSelectionFromGroup(group)
def _remove_all_groups(menuitem, skeleton):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
groupset.removeGroup(*groupset.allGroups().copy())
def _clear_all_groups(menuitem, skeleton):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
groupset.clearGroup(*groupset.allGroups())
def _add_selection_to_group(menuitem, skeleton, group):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
if not groupset.isGroup(group):
groupset.addGroup(group)
groupset.addSelectionToGroup(group)
def __call__(self, param, startname):
skelname = param.group['skeleton'].value
skelcontext = whoville.getClass('Skeleton')[skelname]
groupset = getattr(skelcontext, self.attrname)
return utils.uniqueName(self.getBasename(param, startname),
list(groupset.allGroups()))
def _remove_selection_from_group(menuitem, skeleton, group):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
groupset.removeSelectionFromGroup(group)
def _clear_all_groups(menuitem, skeleton):
skelc = whoville.getClass('Skeleton')[skeleton]
groupset = getattr(skelc, menuitem.data)
groupset.clearGroup(*groupset.allGroups())
switchboard.notify("redraw")
def countMSGroups(msname):
from ooflib.common.IO import whoville
ms = whoville.getClass('Microstructure')[msname].getObject()
return len(ms.groupNames())
def nIllegalElements():
from ooflib.common.IO import whoville
sc = whoville.getClass('Skeleton')['triangle.png:skeleton']
return sc.getObject().getIllegalCount()
image = whoville.getClass('Image')[self.image]
imageobj = image.getObject()
ms = image.getMicrostructure()
self.operator.operate(
selection,
pixelselectioncourieri.ColorSelection(ms, imageobj, self.reference,
self.range))
pixelselection.VoxelSelectionModRegistration(
'Color Range',
ColorRange,
ordering=3.14,
params=[
whoville.WhoParameter('image',
whoville.getClass('Image'),
tip=parameter.emptyTipString),
color.NewColorParameter('reference', tip='Reference color.'),
colordiffparameter.ColorDifferenceParameter(
'range', tip='Deviation from the reference color.'),
selectionoperators.SelectionOperatorParam('operator')
],
tip="Select all pixels similar to a reference color.",
discussion="""<para>
Select all pixels in an ℑ within a given
<varname>range</varname> of a given <varname>refererence</varname>
color. This command basically does the same thing that <xref
linkend='MenuItem:OOF.Graphics_n.Toolbox.Pixel_Select.Color'/>
does except the latter takes its <varname>reference</varname>
input from a mouse click in the Graphics window.
