def makeMenu(self, menu): self.menu = menu menu.addItem(oofmenu.OOFMenuItem( 'MoveNode', threadable=oofmenu.THREADABLE, callback = self.moveNode, params=[primitives.PointParameter('origin', tip=parameter.emptyTipString), primitives.PointParameter('destination', tip=parameter.emptyTipString)], help="Move a node to another positon.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/move_node.xml') )) menu.addItem(oofmenu.OOFMenuItem( 'SelectNode', callback = self.selectNode, params=[primitives.PointParameter('position', tip=parameter.emptyTipString)], help="Select a node to move.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/select_move_node.xml') )) menu.addItem(oofmenu.OOFMenuItem( 'AllowIllegal', callback = self.allowIllegal, params=[parameter.BooleanParameter('allowed', 0, tip=parameter.emptyTipString)], help="Are illegal elements allowed?", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/allow_illegal.xml') ))
def buildSelectionModMenu(): selmodmenu.clearMenu() selmodmenu.addItem(oofmenu.OOFMenuItem( 'Undo', params=[whoville.WhoParameter('microstructure', microstructure.microStructures, tip=parameter.emptyTipString)], callback=pixelselectionmod.undo, help="Undo the latest selection.", discussion=xmlmenudump.loadFile('DISCUSSIONS/common/menu/undo_pixsel.xml') )) selmodmenu.addItem(oofmenu.OOFMenuItem( 'Redo', params=[whoville.WhoParameter('microstructure', microstructure.microStructures, tip=parameter.emptyTipString)], callback=pixelselectionmod.redo, help="Redo the latest undone selection.", discussion=xmlmenudump.loadFile('DISCUSSIONS/common/menu/redo_pixsel.xml') )) selmodmenu.addItem(oofmenu.OOFMenuItem( 'Clear', params=[whoville.WhoParameter('microstructure', microstructure.microStructures, tip=parameter.emptyTipString)], callback=pixelselectionmod.clear, help="Clear the current selection.", discussion="<para>Clear the current selection.</para>")) for registration in pixelselectionmod.SelectionModifier.registry: # Help string try: help = registration.tip except AttributeError: help = None # Discussion try: discussion = registration.discussion except AttributeError: discussion = None menuitem = selmodmenu.addItem( oofmenu.OOFMenuItem(utils.space2underscore(registration.name()), callback=pixelselectionmod.doSelectionMod, threadable=oofmenu.THREADABLE, params=[ whoville.WhoParameter('microstructure', microstructure.microStructures, tip=parameter.emptyTipString) ]+registration.params, help=help, discussion=discussion)) menuitem.data = registration
def makeMenu(self, menu): self.menu = menu menu.addItem(oofmenu.OOFMenuItem( 'QueryElement', callback=self.queryElem, params=[primitives.PointParameter('position', tip='Target point.')], help="Query an FE element at a given point.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/query_mesh_elem.xml') )) menu.addItem(oofmenu.OOFMenuItem( 'QueryNode', callback=self.queryNode, params=[primitives.PointParameter('position', tip='Target point.')], help="Query an FE node at a given point.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/query_mesh_node.xml') ))
def addToGfxSettings(gfxwindow): item = gfxwindow.menu.Settings.addItem(oofmenu.CheckOOFMenuItem( 'Hide_Empty_Mesh_Elements', callback=toggleEmptyDrawing, value=gfxwindow.settings.hideEmptyElements, help="Toggle the display of elements with no Material.", discussion=xmlmenudump.loadFile('DISCUSSIONS/common/menu/hideempty.xml'))) item.data = gfxwindow
class RefinementDegree(registeredclass.RegisteredClass): registry = [] def markExtras(self, skeleton, markedEdges): pass tip = "Number of subdivisions per segment." discussion = xmlmenudump.loadFile( 'DISCUSSIONS/engine/reg/refinementdegree.xml')
class ErrorNorm(registeredclass.RegisteredClass): registry = [] #AMR subproblem, pass subproblem def preprocess(self, subproblem, flux): # to be overridden by child class. pass tip = "How to measure error?" discussion = xmlmenudump.loadFile('DISCUSSIONS/engine/reg/errornorm.xml')
class ErrorEstimator(registeredclass.RegisteredClass): registry = [] # If an ErrorEstimator needs a preprocess, it should be added. #AMR subproblem, pass subproblem def preprocess(self, subproblem): pass tip = "Error estimators." discussion = xmlmenudump.loadFile( 'DISCUSSIONS/engine/reg/errorestimator.xml')
class Rationalizer(registeredclass.RegisteredClass): registry = [] def __call__(self, skel, context, targets, criterion, fixer): prog = progress.findProgress("Rationalize") # Copy the element list from skeleton.element before # rationalizing. This is necessary because rationalizing # modifies the Skeleton's element list. elements = targets(skel, context, copy=1) random.shuffle(elements) executed_action = self.getRegistration().gerund processed = {} count = 0 done = 0 # No. of rationalized elements nel = len(elements) # No. of elements in the list for element in elements: count += 1 # The i-th element being processed ... for progress bar if element not in processed and element.active(skel): # fixer is either self.findAndFix or self.fixAll. They # return a list of ProvisionalChanges objects, from # which we pick the best one. changes = fixer(skel, element) bestchange = criterion(changes, skel) if bestchange is not None: done += bestchange.nRemoved() # Accepting the change converts provisional # elements to actual elements. bestchange.accept(skel) for elephant in bestchange.removed: processed[elephant] = 1 for oldel, newel in bestchange.substitutions: # If an unprocessed element has been replaced, # its replacement still has to be processed. # The element being replaced should *not* be # processed, in any case, since it's no longer # in the skeleton. # If the criterion is "Unconditional" or # "Limited Unconditional", it doesn't add subs to # the list. if oldel not in processed: processed[oldel] = 1 if criterion.addSubstitute(elements, newel): nel += 1 if prog.stopped(): break else: prog.setFraction(1.0*count/nel) prog.setMessage(executed_action + " %d/%d" % (count, nel)) skel.cleanUp() reporter.report("%d elements rationalized : %s." % (done, self.getRegistration().name())) tip = "Specific tools to remove badly shaped Elements from Skeletons." discussion = xmlmenudump.loadFile('DISCUSSIONS/engine/reg/rationalizer.xml')
class SubProblemType(registeredclass.RegisteredClass): registry = [] tip = "Different varieties of Subproblems." discussion = xmlmenudump.loadFile( 'DISCUSSIONS/engine/reg/subproblemtype.xml') def get_dependencies(self): # Return the paths (colon separated strings) to the other # subproblems on which this one depends. return []
def addToGfxSettings(gfxwindow): item = gfxwindow.menu.Settings.addItem( oofmenu.CheckOOFMenuItem( 'Hide_Empty_Mesh_Elements', callback=toggleEmptyDrawing, value=gfxwindow.settings.hideEmptyElements, help="Toggle the display of elements with no Material.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/common/menu/hideempty.xml'))) item.data = gfxwindow
def __init__(self, name, methodclass, modifierclass, newselectionsignal, modifierappliedsignal, changedselectionsignal, groupmenu, materialsallowed=None): self.name = name # methodclass is the RegisteredClass of routines for creating # new selections. These appear in the # SkeletonSelectionToolbox. self.methodclass = methodclass # modifierclass is the RegisteredClass of routines for # modifying existing selections. These appear in the # SkeletonSelectionPage. self.modifierclass = modifierclass # newselectionsignal is sent along with a selection method and # pointlist when a new selection is made. # changedselectionsignal is sent when any change is made in # the selection at all. # modifierappliedsignal is sent along with a selection # modifier when the selection is modified. self.modifierappliedsignal = modifierappliedsignal self.newselectionsignal = newselectionsignal self.changedselectionsignal = changedselectionsignal # groupmenu is the menu of commands for manipulating groups of # the object. self.groupmenu = groupmenu # materialsallowed is either None or a MaterialType instance. # If not None, it indicates what kinds of material may be # explicitly assigned to groups of this type of selectable # object. self.materialsallowed = materialsallowed self.stacksize = 50 # Create a menuitem for changing the stack size. The # parameter is shared among the menuitems for all # SkeletonSelectionModes as well as the menuitem that sets all # of the buffer sizes at once. self.stacksize_menuitem = bufsizmenu.addItem(oofmenu.OOFMenuItem( name, callback=self.setUndoBufferSize, params=_stacksize_params, # global, see below help="Set the history buffer size for Skeleton %s selections" % name, discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/skelbufsize.xml', lambda text,obj: text.replace('CLASS', name)) )) SkeletonSelectionMode.modes.append(self) switchboard.notify(SkeletonSelectionMode, self)
class IsotropicRank4Tensor(registeredclass.ConvertibleRegisteredClass): registry = [] tip = "Representations of an isotropic 4th rank tensor." discussion = xmlmenudump.loadFile('DISCUSSIONS/engine/reg/isotropic_rank4.xml') def tensorForm(self): modulus = cijkl.Cijkl() ibase = self.to_base() modulus[0,0] = modulus[1,1] = modulus[2,2] = ibase.c11 modulus[0,1] = modulus[0,2] = modulus[1,2] = ibase.c12 modulus[3,3] = modulus[4,4] = modulus[5,5] = 0.5*(ibase.c11-ibase.c12) return modulus
class MatrixMethod(registeredclass.RegisteredClass): registry = [] def shortrepr(self): return self.__class__.__name__ def solve(self, matrix, rhs, solution): return self.solveMatrix(matrix, rhs, solution) tip = "Ways to solve a matrix equation." discussion = xmlmenudump.loadFile( 'DISCUSSIONS/engine/reg/matrixmethod.xml')
def makeMenu(self, menu): self.menu = menu menu.addItem( oofmenu.OOFMenuItem('MoveNode', callback=self.moveNode, params=[ parameter.IntParameter( 'node', tip='Index of the node to be moved.'), pointparameter.PointParameter( 'destination', tip=parameter.emptyTipString) ], help="Move a node to another positon.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/move_node.xml'))) menu.addItem( oofmenu.OOFMenuItem( 'SelectNode', callback=self.selectNode, params=[ pointparameter.PointParameter( 'position', tip=parameter.emptyTipString), view.ViewParameter('view') ], help="Select a node to move.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/select_move_node.xml'))) menu.addItem( oofmenu.OOFMenuItem( 'AllowIllegal', callback=self.allowIllegal, params=[ parameter.BooleanParameter('allowed', 0, tip=parameter.emptyTipString) ], help="Are illegal elements allowed?", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/allow_illegal.xml')))
def makeMenu(self, menu): self.menu = menu menu.addItem(oofmenu.OOFMenuItem( 'Pin', callback = self.pin, params=[self.skeleton_param, primitives.PointParameter('point', tip='Target point.')], help="Pin the node closest to the given point.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/pin.xml') )) menu.addItem(oofmenu.OOFMenuItem( 'UnPin', callback = self.unpin, params=[self.skeleton_param, primitives.PointParameter('point', tip='Target point.')], help="Unpin the node closest to the given point.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/unpin.xml') )) menu.addItem(oofmenu.OOFMenuItem( 'TogglePin', callback=self.togglepin, params=[self.skeleton_param, primitives.PointParameter('point', tip='Target point.')], help="Toggle the pinnedness of the node closest to the given point.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/toggle_pin.xml') )) menu.addItem(oofmenu.OOFMenuItem( 'UnPinAll', callback = self.unpinall, params=[self.skeleton_param], help="Unpin all nodes.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/unpin_all.xml') )) menu.addItem(oofmenu.OOFMenuItem( 'Invert', callback = self.invert, params=[self.skeleton_param], help="Invert pinned nodes.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/invert_pin.xml') )) menu.addItem(oofmenu.OOFMenuItem( 'Undo', callback=self.undoPin, params=[self.skeleton_param], help="Undo the latest pin.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/undo_pin.xml') )) menu.addItem(oofmenu.OOFMenuItem( 'Redo', callback=self.redoPin, params=[self.skeleton_param], help="Redo the latest undone pin.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/redo_pin.xml') ))
def makeMenu(self, menu): self.menu = menu menu.addItem( oofmenu.OOFMenuItem( 'QueryElement', callback=self.queryElem, params=[ primitives.PointParameter('position', tip='Target point.') ], help="Query an FE element at a given point.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/query_mesh_elem.xml'))) menu.addItem( oofmenu.OOFMenuItem( 'QueryNode', callback=self.queryNode, params=[ primitives.PointParameter('position', tip='Target point.') ], help="Query an FE node at a given point.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/query_mesh_node.xml')))
def makeMenu(self, menu): self.menu = menu menu.addItem( oofmenu.OOFMenuItem( 'QueryElement', callback=self.queryElem, params=[ primitives.PointParameter('position', tip='Target point.') ], help="Query the element closest to the given point.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/query_skel_elem.xml'))) menu.addItem( oofmenu.OOFMenuItem( 'QueryElementByID', callback=self.queryElemByID, params=[parameter.IntParameter('index', tip="Element index.")], help="Query the element with the given index.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/query_skel_elem_id.xml'))) menu.addItem( oofmenu.OOFMenuItem( 'QuerySegment', callback=self.querySgmt, params=[ primitives.PointParameter('position', tip='Target point.') ], help="Query the segment closest to the given point.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/query_skel_sgmt.xml'))) menu.addItem( oofmenu.OOFMenuItem( 'QuerySegmentByID', callback=self.querySgmtByID, params=[parameter.IntParameter('index', tip="Segment index.")], help="Query the segment with the given index.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/query_skel_sgmt_id.xml'))) menu.addItem( oofmenu.OOFMenuItem( 'QueryNode', callback=self.queryNode, params=[ primitives.PointParameter('position', tip='Target point.') ], help="Query the node closest to the given point.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/query_skel_node.xml'))) menu.addItem( oofmenu.OOFMenuItem( 'QueryNodeByID', callback=self.queryNodeByID, params=[parameter.IntParameter( 'index', tip="Node index.", )], help="Query the node with the given index.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/query_skel_node_id.xml')))
def makeMenu(self, menu): self.menu = menu menu.addItem( oofmenu.OOFMenuItem( 'MoveNode', threadable=oofmenu.THREADABLE, callback=self.moveNode, params=[ primitives.PointParameter('origin', tip=parameter.emptyTipString), primitives.PointParameter('destination', tip=parameter.emptyTipString) ], help="Move a node to another positon.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/move_node.xml'))) menu.addItem( oofmenu.OOFMenuItem( 'SelectNode', callback=self.selectNode, params=[ primitives.PointParameter('position', tip=parameter.emptyTipString) ], help="Select a node to move.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/select_move_node.xml'))) menu.addItem( oofmenu.OOFMenuItem( 'AllowIllegal', callback=self.allowIllegal, params=[ parameter.BooleanParameter('allowed', 0, tip=parameter.emptyTipString) ], help="Are illegal elements allowed?", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/allow_illegal.xml')))
class OutputDestination(registeredclass.RegisteredClass): registry = [] tip="What to do with Scheduled Output data." discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/outputdest.xml') def open(self): pass # def open_append(self): # pass def flush(self): pass def rewind(self): pass def close(self): pass
class SampleSet(registeredclass.RegisteredClass): registry = [] def __init__(self): self.sample_list = [] def get_col_names(): return [] def clearSamples(self): self.sample_list = [] tip = "Container for samples. Outputs are evaluated at samples." discussion = xmlmenudump.loadFile('DISCUSSIONS/engine/reg/sampleset.xml')
class SkelModCriterion(registeredclass.RegisteredClass): registry = [] def __call__(self, changes, skel): # Child classes must provide __call__ method with # ProvisionalChanges, Skeleton as arguments pass def hopeless(self): return 0 tip = "Acceptance criteria for skeleton modifications." discussion = xmlmenudump.loadFile( 'DISCUSSIONS/engine/reg/skelmodcriterion.xml')
def makeMenu(self, menu): self.menu = menu menu.addItem( oofmenu.OOFMenuItem( "QueryElement", callback=self.queryElem, params=[primitives.PointParameter("position", tip="Target point.")], help="Query the element closest to the given point.", discussion=xmlmenudump.loadFile("DISCUSSIONS/engine/menu/query_skel_elem.xml"), ) ) menu.addItem( oofmenu.OOFMenuItem( "QueryElementByID", callback=self.queryElemByID, params=[parameter.IntParameter("index", tip="Element index.")], help="Query the element with the given index.", discussion=xmlmenudump.loadFile("DISCUSSIONS/engine/menu/query_skel_elem_id.xml"), ) ) menu.addItem( oofmenu.OOFMenuItem( "QuerySegment", callback=self.querySgmt, params=[primitives.PointParameter("position", tip="Target point.")], help="Query the segment closest to the given point.", discussion=xmlmenudump.loadFile("DISCUSSIONS/engine/menu/query_skel_sgmt.xml"), ) ) menu.addItem( oofmenu.OOFMenuItem( "QuerySegmentByID", callback=self.querySgmtByID, params=[parameter.IntParameter("index", tip="Segment index.")], help="Query the segment with the given index.", discussion=xmlmenudump.loadFile("DISCUSSIONS/engine/menu/query_skel_sgmt_id.xml"), ) ) menu.addItem( oofmenu.OOFMenuItem( "QueryNode", callback=self.queryNode, params=[primitives.PointParameter("position", tip="Target point.")], help="Query the node closest to the given point.", discussion=xmlmenudump.loadFile("DISCUSSIONS/engine/menu/query_skel_node.xml"), ) ) menu.addItem( oofmenu.OOFMenuItem( "QueryNodeByID", callback=self.queryNodeByID, params=[parameter.IntParameter("index", tip="Node index.")], help="Query the node with the given index.", discussion=xmlmenudump.loadFile("DISCUSSIONS/engine/menu/query_skel_node_id.xml"), ) )
def __init__(self, name, ordering, parentClass=None, instanceClass=WhoDoUndo, proxyClasses=[], secret=0): WhoClass.__init__(self, name, ordering, parentClass=parentClass, instanceClass=instanceClass, proxyClasses=proxyClasses, secret=secret) self.historysize = historysize mainmenu.bufsizemenu.addItem(oofmenu.OOFMenuItem( utils.space2underscore(name), callback=self.setUndoBufferSize, # TODO: Disallow size=0. params=[parameter.IntParameter('size', historysize, tip='number of previous versions to preserve')], help="Set the history buffer size for %ss" % name, discussion=xmlmenudump.loadFile( 'DISCUSSIONS/common/menu/bufsize.xml', lambda text,obj: text.replace('CLASS', name)) ))
class Schedule(registeredclass.RegisteredClass): registry = [] tip="Ways to specify when Scheduled Output will be produced." discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/schedule.xml') def __init__(self): self.time0 = 0.0 def reset(self, continuing): pass def singleTime(self): # In subclasses this should return the time if the Schedule # contains only a single time, or None if the Schedule # contains multiple times. If it contains a single unknown # time (which probably doesn't make sense) it should return # None. This is used to distinguish between static and # quasistatic evolutions. return None def setOffset(self, time0): # adjust for relative vs absolute scheduletypes self.time0 = time0
def makemenu(menu_base): menu_base.clearSubMenu() for r in analyze.DataOperation.registry: help = getattr(r, "tip", None) new_item = oofmenu.OOFMenuItem( utils.space2underscore(r.name()), callback = _ops_callback, params = common_analysis_params + r.params, help=help, discussion=r.discussion) new_item.data = r menu_base.addItem(new_item) ops_menu.addItem(oofmenu.OOFMenuItem( 'Rewind', callback=_rewind, params=[filenameparam.FileNameParameter( 'filename', tip='The name of the output file.')], help="Overwrite the data currently in an output file.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/rewind.xml') ))
help="Set default parameters for displaying selected skeleton nodes.", discussion="""<para> Set default parameters for the <xref linkend="RegisteredClass-SkeletonNodeSelectionDisplay"/>, which displays the currently selected &skel; &nodes; in the graphics window. See <xref linkend="RegisteredClass-SkeletonNodeSelectionDisplay"/> for a discussion of the parameters. This command may be put in the &oof2rc; file to set defaults for all &oof2; sessions. </para>""")) nodeSelectDisplay = registeredclass.Registration( 'Selected Nodes', display.DisplayMethod, SkeletonNodeSelectionDisplay, params=nodeselparams, ordering=2.2, layerordering= display.PointLike(3), whoclasses=('Skeleton',), tip="Display the currently selected nodes.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/nodeselectdisplay.xml') ) def defaultNodeSelectDisplay(): return nodeSelectDisplay(color=defaultNodeSelColor, size=defaultNodeSelSize) ghostgfxwindow.PredefinedLayer('Skeleton', '<topmost>', defaultNodeSelectDisplay)
import atexit import os import os.path # Parameter = parameter.Parameter StringParameter = parameter.StringParameter IntParameter = parameter.IntParameter FloatParameter = parameter.FloatParameter OOFMenuItem = oofmenu.OOFMenuItem OOFRootMenu = oofmenu.OOFRootMenu CheckOOFMenuItem = oofmenu.CheckOOFMenuItem OOF = OOFRootMenu( 'OOF', discussion=xmlmenudump.loadFile('DISCUSSIONS/common/menu/oof.xml')) ################ # Automatically log all menu commands to a temp file. The location of # the temp file is taken from the OOFTMP environment variable, if it's # defined. Otherwise it's determined by the tempfile.mkstemp # function, which looks in the environment variables TMPDIR, TEMP, and # TMP, followed by the directories /tmp, /var/tmp, and /usr/tmp. ooftmpdir = os.getenv('OOFTMP') if ooftmpdir is not None: fd, logpath = tempfile.mkstemp(prefix='oof2-', suffix='.py', dir=ooftmpdir) else: fd, logpath = tempfile.mkstemp(prefix='oof2-', suffix='.py') tmplogfile = os.fdopen(fd, 'w')
# be using C. M's symstate will be INCONSISTENT and C21 will be # empty. return (subproblem.matrix_symmetry_M == symstate.ASYMMETRIC or subproblem.matrix_symmetry_C == symstate.ASYMMETRIC or linsys.C21_nonempty()) registeredclass.Registration( 'Forward Euler', timestepper.TimeStepper, ForwardEuler, ordering=0, explicit=True, tip="Fully explicit first order time stepping.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/euler.xml')) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# # Generalized Euler: everything between Forward Euler and Backward # Euler. self.theta is defined in subclasses. class NLDataGE(timestepper.NLData): def __init__(self, subproblem, linsys0, endtime, dt, unknowns, theta): self.dt = dt self.C = linsys0.C_MCKa() # resid0 is the part of the residual that can be computed at # startTime, with the linsys0 that's passed into this function. # resid0 = -C u_n + (1-theta) dt F(u_n, t) self.resid0 = self.C * unknowns
oofmenu.OOFMenuItem( 'Skeleton_Selection', help= "Set the size of history buffers for Skeleton selection operations", ordering=1)) _stacksize = 50 def _allBufSizesCB(menuitem, size): _stacksize = size for mode in SkeletonSelectionMode.modes: mode.setUndoBufferSize(menuitem, size) _stacksize_params = [ parameter.IntParameter('size', _stacksize, tip='number of previous selections to retain') ] _all_stacksize_menuitem = bufsizmenu.addItem( oofmenu.OOFMenuItem( 'All', callback=_allBufSizesCB, ordering=-1, params=_stacksize_params, help="Set the history buffer size for all Skeleton selections", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/skelbufsizes.xml')))
0.0, ## 'c-axis tilt' tip='second rotation, about the y-axis, in degrees.'), FloatRangeParameter( 'beta', (-180., 180., 0.1), 0.0, ## c-axis rot. tip='first rotation, about the z-axis, in degrees.'), FloatRangeParameter( 'gamma', (-180., 180., 0.1), 0.0, ## z-axis rot tip='third rotation, about the z-axis, in degrees.') ], tip= 'Euler angles (alpha, beta, gamma) are applied: first beta about the z axis, then alpha about the y, and finally gamma about z. This operation brings the crystal axes into coincidence with the lab axes.', discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/abg.xml')) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# # Goldstein's "X" convention. This may have some other more # descriptive name, but I don't know what it is. Rotations are z,x,z. class X(Orientation): def __init__(self, phi, theta, psi): self.phi = phi self.theta = theta self.psi = psi self.corient = corientation.COrientX( *map(math.radians, (phi, theta, psi))) @staticmethod
# x and y are the current location and is guaranteed to be # provided. All others are provided if applicable. nx and ny # are the unit-vector components of the boundary normal at # this location. i is the node index, s is the arc length, # alpha is the fractional arc length. strfunction.StrFunction.__init__( self, 'x, y, nx, ny, i, s, alpha', funcstr) def __repr__(self): # ProfileFunctions only have to write their values when they # are used in ProfileFunctionParameters, which can set # themselves from a string. So just write the string. return "'%s'" % self.funcstr xmlmenudump.XMLObjectDoc( 'ProfileFunction', xmlmenudump.loadFile('DISCUSSIONS/engine/object/profilefunction.xml')) # The ProfileFunctionParameter can accept either a string or a # ProfileFunction object, but it only stores a ProfileFunction object. # Like XYStrFunctionParameter, it needs a special "set" function. class ProfileFunctionParameterBase(parameter.Parameter): def __init__(self, name, value=None, default=None, tip=None): parameter.Parameter.__init__(self, name, value=value, default=default, tip=tip) def set(self, value): if type(value) is types.StringType: self._value = self.profileClass(value) elif isinstance(value, self.profileClass): self._value = value
ordering=1, help="Set default parameters for Mesh Info displays.", discussion="""<para> Set default parameters for <link linkend="RegisteredClass-MeshInfoDisplay"><classname>MeshInfoDisplays</classname></link>. See <xref linkend="RegisteredClass-MeshInfoDisplay"/> for the details. This command may be placed in the &oof2rc; file to set a default value for all &oof2; sessions. </para>""")) meshInfoDisplay = registeredclass.Registration( 'Info', display.DisplayMethod, MeshInfoDisplay, params=meshinfoparams, ordering=4.0, layerordering=display.PointLike(100), whoclasses=('Mesh',), tip="Set display parameters for the decorations used by the Mesh Info toolbox.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/meshinfodisplay.xml') ) def defaultMeshInfoDisplay(): return meshInfoDisplay(query_color=defaultQueryColor, peek_color=defaultPeekColor, node_size=defaultNodeSize, element_width=defaultElementWidth) ghostgfxwindow.PredefinedLayer('Mesh', '<topmost>', defaultMeshInfoDisplay)
activearea = microstructure.activearea pixelselection = microstructure.pixelselection activearea.start() activearea.clear() # everything is active activearea.invert() # everything is inactive pixgrp = pixelselection.getSelectionAsGroup() courier = GroupSelection(microstructure, pixgrp) activearea.unselectWithoutCheck(courier) registeredclass.Registration( 'Activate Selection Only', ActiveAreaModifier, ActivateOnlySelection, ordering=0.1, tip="Activate the selected pixels, deactivating everything else.", discussion=xmlmenudump.loadFile('DISCUSSIONS/common/menu/activate_selection_only.xml') ) class ActivateSelection(ActiveAreaModifier): def __call__(self, microstructure): activearea = microstructure.activearea pixelselection = microstructure.pixelselection activearea.start() pixgrp = pixelselection.getSelectionAsGroup() activearea.unselectWithoutCheck(GroupSelection(microstructure, pixgrp)) registeredclass.Registration( 'Activate Selection', ActiveAreaModifier, ActivateSelection, ordering=0.5,
class ContinuumProfile(ProfileX, _ContinuumProfileX): pass registeredclass.Registration( "Continuum Profile", ProfileX, ContinuumProfile, ordering=2, params=[ profilefunction.ProfileFunctionXParameter( "function", value=profilefunction.ProfileFunctionX("0.0"), tip="A function of x, y, nx, ny, i, s, and/or alpha.") ], tip="Boundary condition is an arbitrary function of position.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/reg/continuumprofilex.xml') ) class ContinuumProfileXT(ProfileXT, _ContinuumProfileXT): pass registeredclass.Registration( "Continuum Profile", ProfileXT, ContinuumProfileXT, ordering=2, params=[ profilefunction.ProfileFunctionXTParameter( "function", value=profilefunction.ProfileFunctionXT("0.0"), tip="A function of x, y, nx, ny, i, s, alpha, and/or t.")
details. This command may be put into your &oof2rc; file to set defaults for all &oof2; sessions. </para>""")) meshCrossSectionDisplay = registeredclass.Registration( 'Cross Section', display.DisplayMethod, MeshCrossSectionDisplay, params=[ meshcsparams.MeshCrossSectionSetParameter( 'cross_sections', placeholder.selection, tip="Which cross-section to display?") ] + meshcsdispparams, ordering=5.0, layerordering=display.SemiLinear, whoclasses=('Mesh', ), tip="Determine which cross sections are displayed, and how.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/reg/meshcsdisplay.xml', )) def defaultMeshCrossSectionDisplay(): return meshCrossSectionDisplay(color=defaultMeshCSColor, linewidth=defaultMeshCSLineWidth) ghostgfxwindow.PredefinedLayer('Mesh', '<contourable>', defaultMeshCrossSectionDisplay)
class PinInternalBoundaryNodes(PinNodesModifier): def __call__(self, skelcontext): skel = skelcontext.getObject() skelcontext.pinnednodes.start() skelcontext.pinnednodes.pinInternalBoundaryNodes(skel) registeredclass.Registration( 'Pin Internal Boundary Nodes', PinNodesModifier, PinInternalBoundaryNodes, ordering=2, tip="Pin all internal boundary nodes.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/pininternal.xml')) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class PinSelectedSegments(PinNodesModifier): def __call__(self, skelcontext): skelcontext.pinnednodes.start() skelcontext.pinnednodes.pinSelectedSegments( skelcontext.segmentselection.currentSelectionTracker()) registeredclass.Registration('Pin Selected Segments', PinNodesModifier, PinSelectedSegments, ordering=4,
sister in processed or element.dominantPixel(skel.MS)!=sister.dominantPixel(skel.MS)): continue j = sister.nodes.index(node0) nodeA = sister.nodes[(j+1)%3] nodeB = element.nodes[(i+2)%3] nlist = [node0, nodeA, node1, nodeB] parents = element.getParents() + sister.getParents() change = skeleton.ProvisionalChanges(skel) change.removeElements(element, sister) change.insertElements(ProvisionalQuad(nlist, parents=parents)) changes.append(change) return changes ################################################### registeredclass.Registration( 'Merge Triangles', skeletonmodifier.SkeletonModifier, MergeTriangles, ordering = 5, params=[parameter.RegisteredParameter('targets', skeletonmodifier.SkelModTargets, tip = 'Which elements to modify.'), parameter.RegisteredParameter('criterion', skeletonmodifier.SkelModCriterion, tip='Acceptance criterion.') ], tip="Merge neighboring homogeneous triangles to form quadrilaterals.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/merge.xml') )
SkeletonBoundaryDisplay, params=[SkeletonBoundaryListParameter('boundaries', [], tip="Boundaries to display."), color.ColorParameter('color', value=color.gray50, tip="Color for the displayed boundaries."), parameter.IntRangeParameter('linewidth', widthRange, 4, tip="Line width for edge boundaries."), parameter.IntRangeParameter('dotsize', widthRange, 4, tip="Dot radius for point boundaries."), parameter.IntRangeParameter('arrowsize', (0, 20), 10, tip="Arrow size for edge boundaries.")], ordering=1.0, layerordering=display.SemiLinear(2), whoclasses=('Skeleton',), tip="Display some or all of the boundaries of the Skeleton", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/skeletonbdydisplay.xml') ) # Layer for showing the selected boundary (point and edge) of a skeleton. class SelectedSkeletonBoundaryDisplay(display.DisplayMethod): def __init__(self, color, linewidth, dotsize, arrowsize): self.color = color self.linewidth = linewidth self.dotsize = dotsize self.arrowsize = arrowsize display.DisplayMethod.__init__(self) def draw(self, gfxwindow, device): skel = self.who().resolve(gfxwindow) skelobj = skel.getObject()
self.analysisObj.perform(self, meshcontext, time, self.destination) def finish(self, meshcontext): self.analysisObj.finish(meshcontext) scheduledoutput.ScheduledOutput.finish(self, meshcontext) def defaultName(self): return self.analysis def printHeaders(self, destination): self.analysisObj.printHeaders(destination) def save(self, datafile, meshctxt): # Before saving the ScheduledOutput, make sure the named # analysis is in the data file. from ooflib.engine.IO import analyzemenu analyzemenu.saveAnalysisDef(datafile, self.analysis) scheduledoutput.ScheduledOutput.save(self, datafile, meshctxt) registeredclass.Registration( "Named Analysis", scheduledoutput.ScheduledOutput, NamedAnalysisOutput, ordering=3, destinationClass=outputdestination.TextOutputDestination, params=[ AnalysisNameParameter( "analysis", tip="Name of the analysis operation to perform. Named analyses can be created on the Analysis and Boundary Analysis Pages.") ], tip="Use a predefined bulk or boundary Analysis method.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/namedanalysis.xml') )
registeredclass.Registration( 'Material', display.DisplayMethod, MicrostructureMaterialDisplay, ordering=0, layerordering=display.Planar(0.4), params=[ color.ColorParameter('no_material', color.black, tip="Color to use if no material has been assigned to a pixel"), color.ColorParameter('no_color', color.blue, tip="Color to use if the assigned material has no assigned color") ], whoclasses = ('Microstructure',), tip="Display the color of the Material assigned to each pixel.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/microstructuredisplay.xml') ) ############################ if config.dimension() == 2: class OrientationDisplay(MSMaterialDisplay): def __init__(self, colorscheme, no_material=color.blue, no_orientation=color.black): self.colorscheme = colorscheme self.no_orientation = no_orientation self.no_material = no_material MSMaterialDisplay.__init__(self) def draw(self, gfxwindow, device): msobj = self.who().getObject(gfxwindow)
prog.setMessage("checked %d/%d segments" % (i + 1, n)) registeredclass.Registration( "Heterogeneous Segments", RefinementTarget, CheckHeterogeneousEdges, ordering=3, params=[ parameter.FloatRangeParameter( "threshold", (0.0, 1.0, 0.05), value=0.9, tip="Refine segments whose homogeneity is less than this." ), parameter.RegisteredParameter("choose_from", SegmentChooser, tip="Segments to consider."), ], tip="Divide heterogeneous segments.", discussion=xmlmenudump.loadFile("DISCUSSIONS/engine/reg/check_hetero_segs.xml"), ) class CheckSelectedEdges(RefinementTarget): def __call__(self, skeleton, context, divisions, markedEdges, criterion): prog = progress.findProgress("Refine") segments = context.segmentselection.retrieve() n = len(segments) for i, segment in enumerate(segments): if segment.active(skeleton): self.markSegment(segment, divisions, markedEdges) if prog.stopped(): return prog.setFraction(1.0 * (i + 1) / n) prog.setMessage("checked %d/%d segments" % (i + 1, n))
# 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, params=[whoville.WhoParameter("skeleton", whoville.getClass("Skeleton"), tip=parameter.emptyTipString)], help="Create node groups for each pixel group.", discussion= """<para>Automatically create a &nodegroup; in the &skel; for every &pixelgroup; in the µ. All &skel; &nodes; lying on a pixel in a
from ooflib.engine.IO import microstructuredisplay class OrientationMapDisplay(display.DisplayMethod): def __init__(self, colorscheme): self.colorscheme = colorscheme display.DisplayMethod.__init__(self) def draw(self, gfxwindow, device): msobj = self.who().getObject(gfxwindow) data = orientmapdata.getOrientationMap(msobj) if data is not None: orientimage = orientmapdata.OrientMapImage(data, self.colorscheme) device.draw_image(orientimage, coord.Coord(0,0), msobj.size()) def getTimeStamp(self, gfxwindow): msobj = self.who().getObject(gfxwindow) return max(display.DisplayMethod.getTimeStamp(self, gfxwindow), orientmapdata.getOrientationMapTimestamp(msobj)) registeredclass.Registration( 'Orientation Map', display.DisplayMethod, OrientationMapDisplay, ordering=2, params=[parameter.RegisteredParameter('colorscheme', angle2color.Angle2Color, tip='Method for converting angles to colors.') ], layerordering=display.Planar(0.5), whoclasses = ('Microstructure',), tip="Display a Microstructure's Orientation Map, whether or not it's used by Material Properties.", discussion=xmlmenudump.loadFile('DISCUSSIONS/orientationmap/reg/orientationmapdisplay.xml'))
def __init__(self, name, methodclass, modifierclass, changedselectionsignal, modifierappliedsignal, groupmenu, allCourier, materialsallowed=None): self.name = name # methodclass is the RegisteredClass of routines for creating # new selections. These appear in the # SkeletonSelectionToolbox. self.methodclass = methodclass # modifierclass is the RegisteredClass of routines for # modifying existing selections. These appear in the # SkeletonSelectionPage. self.modifierclass = modifierclass # changedselectionsignal is sent when any change is made in # a selection. It indicates which selection was changed, but # not how. self.changedselectionsignal = changedselectionsignal # modifierappliedsignal is sent when a selection modifier is # uses. The modifier is sent as an argument. self.modifierappliedsignal = modifierappliedsignal # groupmenu is the menu of commands for manipulating groups of # the object. self.groupmenu = groupmenu # allCourier is a SkeletonSelectionCourier class that can be # used to loop over all objects of this category in the # Skeleton. self.allCourier = allCourier # materialsallowed is either None or a MaterialType instance. # If not None, it indicates what kinds of material may be # explicitly assigned to groups of this type of selectable # object. self.materialsallowed = materialsallowed self.stacksize = 50 # Create a menuitem for changing the stack size. The # parameter is shared among the menuitems for all # SkeletonSelectionModes as well as the menuitem that sets all # of the buffer sizes at once. self.stacksize_menuitem = bufsizmenu.addItem( oofmenu.OOFMenuItem( name, callback=self.setUndoBufferSize, params=_stacksize_params, # global, see below help="Set the history buffer size for Skeleton %s selections" % name, discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/skelbufsize.xml', lambda text, obj: text.replace('CLASS', name)))) SkeletonSelectionMode.modes.append(self)
class RGBData8(ImageData): def __init__(self, rgbvalues): self.rgbvalues = rgbvalues def values(self): return self.rgbvalues registeredclass.Registration( 'RGBData8', ImageData, RGBData8, ordering=0, params=[ parameter.ListOfUnsignedShortsParameter('rgbvalues', tip="RGB values.")], tip="RGB image data.", discussion=xmlmenudump.loadFile('DISCUSSIONS/image/reg/rgbdata8.xml')) class GrayData8(ImageData): def __init__(self, grayvalues): self.grayvalues = grayvalues def values(self): return self.grayvalues registeredclass.Registration( 'GrayData8', ImageData, GrayData8, ordering=1, params=[
# use since they don't have any swig overhead. if config.dimension() == 2: if type(ptlist) == types.ListType: return [Point(pt[0], pt[1]) for pt in ptlist] return ptlist.__class__([Point(pt[0], pt[1]) for pt in ptlist]) elif config.dimension() == 3: if type(ptlist) == types.ListType: return [Point(pt[0], pt[1], pt[2]) for pt in ptlist] return ptlist.__class__([Point(pt[0], pt[1], pt[2]) for pt in ptlist]) ## Documentation for Point and iPoint classes from ooflib.common.IO import xmlmenudump xmlmenudump.XMLObjectDoc( 'iPoint', xmlmenudump.loadFile('DISCUSSIONS/common/object/ipoint.xml')) xmlmenudump.XMLObjectDoc( 'Point', xmlmenudump.loadFile('DISCUSSIONS/common/object/point.xml')) #=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=##=--=# class Rectangle(object): # A Rectangle is a pair of points at diagonally opposite corners. def __init__(self, pt0, pt1): # Don't assume that args pt0 and pt1 have .x and .y data self.lowleft = Point(min(pt0[0], pt1[0]), min(pt0[1], pt1[1])) self.upright = Point(max(pt0[0], pt1[0]), max(pt0[1], pt1[1])) def enclosing_rectangle(self):
## TODO: This calculation more logically belongs in ## LinearizedSystem, but it doesn't know the matrix_symmetries. return (subproblem.matrix_symmetry_M == symstate.ASYMMETRIC or subproblem.matrix_symmetry_C == symstate.ASYMMETRIC or linsys.C21_nonempty()) registeredclass.Registration( '4th order Runge-Kutta', timestepper.TimeStepper, RK4, ordering=2.1, explicit=True, tip="Fourth order Runge-Kutta time stepping.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/rk4.xml') ) ## Second order Runge-Kutta ## y_{n+1} = y_n + h k_2 + O(h^3) ## k_1 = g(t_n, y_n) ## k_2 = g(t_n + h/2, y_n + h/2 k_1) ## g(t, u) = C^{-1} (f - K u) class RK2(RKBase): def errorOrder(self): return 3.0 def shortrepr(self):
def compute_jacobian(self, data, nlsolver): return data.linsys.J_MCK() def compute_linear_coef_mtx(self, data, nlsolver): return data.linsys.K_MCK() #################################################################### registeredclass.Registration( 'Static', timestepper.StepDriver, StaticDriver, ordering=0, tip="Solve a subproblem as a static or quasi-static system.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/staticdriver.xml')) # _StaticStepper never appears in the user interface because there's # only one kind of static stepper, so it doesn't really need a # Registration. However, if it doesn't have a Registration its # __repr__ doesn't work, which hinders debugging. So here it has a # Registration, but it's secret. registeredclass.Registration( 'Static', timestepper.TimeStepper, _StaticStepper, tip="Used internally by the Static StepDriver", secret=True, ordering=10000)
from ooflib.SWIG.common import activearea from ooflib.common import debug from ooflib.common import primitives from ooflib.common.IO import mainmenu from ooflib.common.IO import oofmenu from ooflib.common.IO import parameter from ooflib.common.IO import whoville from ooflib.common.IO import xmlmenudump import ooflib.common.microstructure OOF = mainmenu.OOF micromenu = OOF.LoadData.addItem( oofmenu.OOFMenuItem( "Microstructure", help="Commands describing Microstructures in data files.", discussion=xmlmenudump.loadFile("DISCUSSIONS/common/menu/microstructureIO.xml"), ) ) ######### import sys def _newMicrostructure(menuitem, name, isize, size): sys.stdout.flush() try: oldms = ooflib.common.microstructure.microStructures[name] except KeyError: pass else:
from ooflib.SWIG.common import config from ooflib.common import registeredclass ##import weakref class BitmapDisplayMethod(display.DisplayMethod): def __init__(self): self.bitmapobject = None display.DisplayMethod.__init__(self) def draw(self, gfxwindow, device): bitmapobj = self.who().getObject(gfxwindow) if config.dimension() == 2: device.draw_image(bitmapobj, coord.Coord(0, 0), bitmapobj.size()) if config.dimension() == 3: device.draw_image(bitmapobj, coord.Coord(0, 0, 0), bitmapobj.size()) bitmapDisplay = registeredclass.Registration( 'Bitmap', display.DisplayMethod, BitmapDisplayMethod, ordering=-100, layerordering=display.Planar, params=[], whoclasses=('Image', ), tip="Display an Image as a bitmap.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/common/reg/bitmapdisplay.xml'))
C0.axpy(1-theta1, self.a0dot, self.resid0) # ... + (1-theta)*C0*a0dot timestepper.NLData.__init__(self, subproblem, linsys, endtime) def _asymmetric(subproblem): return ((subproblem.second_order_fields() and subproblem.matrix_symmetry_M == symstate.ASYMMETRIC) or subproblem.matrix_symmetry_C == symstate.ASYMMETRIC or subproblem.matrix_symmetry_K == symstate.ASYMMETRIC) registeredclass.Registration( 'SS22', timestepper.TimeStepper, SS22, params=[ parameter.FloatRangeParameter( 'theta1', (0.0, 1.0, 0.1), 0.5, tip='First moment of the weight function for time averages.'), parameter.FloatRangeParameter( 'theta2', (0.0, 1.0, 0.1), 0.5, tip='Second moment of the weight function for time averages.') ], ordering=3.0, require_timederiv = True, tip="Zienkowicz and Taylor's SS22 algorithm for solving equations with second order time derivatives.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/ss22.xml'))
## refactor the classes like that, then the ErrorNorm classes must at ## least be renamed so that it's clear that they are only meant to be ## used with the ZZ estimator. class L2ErrorNorm(ErrorNorm): #AMR subproblem, pass subproblem def __call__(self, element, subproblem, flux): return subproblem.zz_L2_estimate(element, flux) registeredclass.Registration( 'L2 Error Norm', ErrorNorm, L2ErrorNorm, ordering=0, tip="Use the root mean square of the components of the error.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/l2errornorm.xml')) class WeightedL2ErrorNorm(ErrorNorm): def __init__(self): self.weights = None #AMR subproblem, pass subproblem def preprocess(self, subproblem, flux): bottom = 0.0 # [bottom, top] : the range normalized values top = 0.3 # to be weighted. self.weights = subproblem.zz_L2_weights(flux, bottom, top) #AMR subproblem, pass subproblem def __call__(self, element, subproblem, flux): index = element.get_index() return subproblem.zz_L2_estimate(element, flux)*self.weights[index] registeredclass.Registration(
# # # # # # # # # # # # # # # # # Should call the selector with the skeletoncontext and a list of # nodes on which to operate. class SingleNodeSelect(NodeSelectMethod): def select(self, skeletoncontext, pointlist, selector): closest = skeletoncontext.getObject().nearestNode(pointlist[0]) selector([closest]) NodeSelectionRegistration( 'Single_Node', SingleNodeSelect, ordering=0, events=['up'], tip="Select a single node.", discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/reg/single_node.xml')) if config.dimension() == 2: class RectangleNodeSelect(NodeSelectMethod): def select(self, skeletoncontext, pointlist, selector): reslist = [] xmin = min(pointlist[0].x, pointlist[1].x) xmax = max(pointlist[0].x, pointlist[1].x) ymin = min(pointlist[0].y, pointlist[1].y) ymax = max(pointlist[0].y, pointlist[1].y) for n in skeletoncontext.getObject().nodes: if n.position().x < xmax and n.position().x > xmin and \ n.position().y < ymax and n.position().y > ymin: reslist.append(n) selector(reslist)
'Element Edges', display.DisplayMethod, MeshEdgeDisplay, ordering=0.0, layerordering=display.Linear, params=meshdispparams + [ color.ColorParameter( 'color', defaultMeshColor, tip="Color of the displayed edges."), IntRangeParameter('width', widthRange, defaultMeshWidth, tip="Line thickness, in pixels.") ], whoclasses=('Mesh', ), tip="Draw the edges of Mesh Elements.", discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/reg/meshedgedisplay.xml')) registeredclass.Registration( 'Element Edges', display.DisplayMethod, SkeletonEdgeDisplay, ordering=0.0, layerordering=display.Linear, params=[ color.ColorParameter('color', defaultSkeletonColor, tip="Color of the displayed edges."), IntRangeParameter('width', widthRange, defaultSkeletonWidth, tip="Line thickness, in pixels.")
ms.activearea.end_writing() switchboard.notify('active area modified', None) switchboard.notify('redraw') def _delete(menuitem, microstructure, name): ms = ooflib.common.microstructure.getMicrostructure(microstructure) ms.deleteActiveArea(name) switchboard.notify('stored active areas changed', name) # Build menu items for active area modifications aamodmenu = mainmenu.OOF.addItem(oofmenu.OOFMenuItem( 'ActiveArea', cli_only=1, help='Create and manipulate Active Areas.', discussion=xmlmenudump.loadFile('DISCUSSIONS/common/menu/activearea.xml') )) def buildActiveAreaModMenu(): aamodmenu.clearMenu() aamodmenu.addItem(oofmenu.OOFMenuItem( 'Undo', callback=_undo, params=[whoville.WhoParameter('microstructure', ooflib.common.microstructure.microStructures, tip=parameter.emptyTipString) ], help="Undo the latest active area modification.", discussion="""<para> Revert to the previous &active; in the given
def _deleteCB(menuitem, skeleton, boundary): skelctxt = skeletoncontext.skeletonContexts[skeleton] skelctxt.removeBoundary(boundary) boundarymenu.addItem( oofmenu.OOFMenuItem("Delete", callback=_deleteCB, help="Delete a boundary from a Skeleton.", params=[ boundarybuilder.skeletonparam, skeletongroupparams.SkeletonBoundaryParameter( 'boundary', tip="Boundary to be removed.") ], discussion=xmlmenudump.loadFile( 'DISCUSSIONS/engine/menu/boundary_delete.xml'))) ### Boundary renaming def _renameCB(menuitem, skeleton, boundary, name): skelctxt = skeletoncontext.skeletonContexts[skeleton] skelctxt.renameBoundary(boundary, name) boundarymenu.addItem( oofmenu.OOFMenuItem("Rename", callback=_renameCB, help="Rename a Skeleton boundary.", params=[ boundarybuilder.skeletonparam,
def buildActiveAreaModMenu(): aamodmenu.clearMenu() aamodmenu.addItem(oofmenu.OOFMenuItem( 'Undo', callback=_undo, params=[whoville.WhoParameter('microstructure', ooflib.common.microstructure.microStructures, tip=parameter.emptyTipString) ], help="Undo the latest active area modification.", discussion="""<para> Revert to the previous &active; in the given µ.</para>""" )) aamodmenu.addItem(oofmenu.OOFMenuItem( 'Redo', callback=_redo, params=[whoville.WhoParameter('microstructure', ooflib.common.microstructure.microStructures, tip=parameter.emptyTipString) ], help="Redo the latest undone active area modification.", discussion="""<para> Undo the latest <xref linkend='MenuItem-OOF.ActiveArea.Undo'/>. </para>""")) aamodmenu.addItem(oofmenu.OOFMenuItem( 'Override', params=[parameter.BooleanParameter('override', 0, tip="Whether to override or not."), whoville.WhoParameter('microstructure', ooflib.common.microstructure.microStructures, tip=parameter.emptyTipString) ], callback=_override, help="Temporarily activate the entire Microstructure.", discussion=xmlmenudump.loadFile('DISCUSSIONS/common/menu/activearea_override.xml'))) aamodmenu.addItem(oofmenu.OOFMenuItem( 'Store', callback=_store, params=parameter.ParameterGroup( whoville.WhoParameter('microstructure', ooflib.common.microstructure.microStructures, tip=parameter.emptyTipString), parameter.AutomaticNameParameter('name', value=automatic.automatic, resolver=activeAreaNameResolver, tip = "The name of the active are to be stored")), help="Store the current active area.", discussion="""<para> Give the current &active; a <varname>name</varname>, and store it for future use. This makes it easy to switch between different active regions of a µ. If the given <varname>name</varname> is already being used for another &active; in the same µ, then <userinput><x></userinput> will be appended to it, where <userinput>x</userinput> is an integer chosen to make the name unique. </para>""")) aamodmenu.addItem(oofmenu.OOFMenuItem( 'Restore', callback=_restore, params=[whoville.WhoParameter('microstructure', ooflib.common.microstructure.microStructures, tip=parameter.emptyTipString), parameter.StringParameter('name', tip="The name of the active area to be restored.")], help="Restore a named active area.", discussion="""<para> Set the current &active; to the given <link linkend='MenuItem-OOF.ActiveArea.Store'>stored</link> &active;. </para>""")) aamodmenu.addItem(oofmenu.OOFMenuItem( 'Rename', callback=_rename, params=[ whoville.WhoParameter('microstructure', ooflib.common.microstructure.microStructures, tip=parameter.emptyTipString), parameter.StringParameter('oldname', tip="The name of a stored active area."), parameter.StringParameter('newname', '', tip='A new name for the active area.') ], help="Rename the stored active area.", discussion="<para>Assign a new name to a stored active area.</para>")) aamodmenu.addItem(oofmenu.OOFMenuItem( 'Delete', callback=_delete, params=[ whoville.WhoParameter('microstructure', ooflib.common.microstructure.microStructures, tip=parameter.emptyTipString), parameter.StringParameter('name', tip="The name of the active area to be deleted.")], help="Delete a stored active area.", discussion="""<para> Delete a <link linkend='MenuItem-OOF.ActiveArea.Store'>stored</link> active area. This only deletes the stored copy of the active area. It does not affect the activity of any pixels. </para>""")) for registration in activeareamod.ActiveAreaModifier.registry: # registration tip string => menuitem help string try: help = registration.tip except AttributeError: help = None # registration discussion => menuitem discussion try: discussion = registration.discussion except AttributeError: discussion = None menuitem = aamodmenu.addItem( oofmenu.OOFMenuItem(utils.space2underscore(registration.name()), callback=activeareamod.modify, params=[ whoville.WhoParameter('microstructure', ooflib.common.microstructure.microStructures, tip=parameter.emptyTipString) ] + registration.params, help=help, discussion=discussion)) menuitem.data = registration