import ooflib.common.microstructure
from types import *
if parallel_enable.enabled():
from ooflib.common.IO import microstructureIPC
micromenu = mainmenu.OOF.addItem(oofmenu.OOFMenuItem(
'Microstructure',
help="Create and manipulate µ objects.",
cli_only=1))
#######################
if config.dimension() == 2:
sizeparams = parameter.ParameterGroup(
parameter.FloatParameter('width', 1., tip='Width in physical units.'),
parameter.FloatParameter('height', 1.,tip='Height in physical units.'),
parameter.IntParameter('width_in_pixels', 10, tip='Width in pixels.'),
parameter.IntParameter('height_in_pixels', 10, tip='Height in pixels.'))
def newMicrostructure(menuitem, name,
width, height,
width_in_pixels, height_in_pixels):
if width<=0 or height<=0 or width_in_pixels<=0 or height_in_pixels<=0:
raise ooferror.ErrUserError("Negative size values are not allowed.")
if parallel_enable.enabled():
# For the rear-end guys
microstructureIPC.msmenu.New_Parallel(name=name,
width=width, height=height,
width_in_pixels=width_in_pixels,
skelname = param.group['skeleton'].value
skelcontext = skeletoncontext.skeletonContexts[skelname]
return skelcontext.uniqueBoundaryName(basename)
skeletonparam = whoville.WhoParameter(
'skeleton',
skeletoncontext.skeletonContexts,
tip="The Skeleton containing the boundary.")
nameparam = parameter.AutomaticNameParameter('name',
bdynameresolver,
value=automatic.automatic,
tip="Name for this boundary.")
paramgroup = parameter.ParameterGroup(skeletonparam, nameparam)
# ## ### #### ##### ###### ####### ######## ####### ###### ##### #### ### ## #
class BoundaryConstructor(registeredclass.RegisteredClass):
registry = []
tip = "Tools to build Skeleton boundaries."
discussion = """<para>
<classname>BoundaryConstructor</classname> objects are used by the
<xref linkend='MenuItem-OOF.Skeleton.Boundary.Construct'/> command
to build <link
linkend='Section-Concepts-Skeleton-Boundary'>boundaries</link> in
a &skel;.
</para>"""
help=help,
discussion=registration.discussion))
menuitem.data = registration
switchboard.requestCallback(imagemodifier.ImageModifier, buildImageModMenu)
buildImageModMenu()
###################################
# Size params are reused several times
sizeparams = parameter.ParameterGroup(
parameter.AutoNumericParameter('height',
automatic.automatic,
tip= \
"Physical height of image, or 'automatic'."),
parameter.AutoNumericParameter('width',
automatic.automatic,
tip= \
"Physical width of image, or 'automatic'."))
if config.dimension() == 3:
sizeparams.append(parameter.AutoNumericParameter(
'depth',
automatic.automatic,
tip= \
"Physical depth of image, or 'automatic'."))
###################################
if config.dimension() == 2:
skeleton_geometry)
else:
ms = microStructures[microstructure].getObject()
skel = cskeleton2.initialSkeleton(name, ms, x_elements, y_elements,
skeleton_geometry)
switchboard.notify("redraw")
skelparams = parameter.ParameterGroup(
AutoWhoNameParameter('name',
value=automatic.automatic,
resolver=skeletonNameResolver,
tip="Name of the new skeleton."),
WhoParameter('microstructure',
microStructures,
tip=parameter.emptyTipString),
IntParameter('x_elements',
4,
tip="No. of elements in the x-direction."),
IntParameter('y_elements',
4,
tip="No. of elements in the y-direction."),
RegisteredParameter('skeleton_geometry',
skeleton.SkeletonGeometry,
skeleton.QuadSkeleton(),
tip="The shape of the elements."))
elif config.dimension() == 3:
def _skeleton_from_mstructure(menuitem, name, microstructure, x_elements,
y_elements, z_elements, skeleton_geometry):
if parallel_enable.enabled(): # PARALLEL
skel = cskeleton2.initialSkeletonParallel(name, microstructure,
else:
basename = name
meshname = param.group['mesh'].value
if meshname is not None:
meshpath = labeltree.makePath(meshname)
meshcontext = ooflib.engine.mesh.meshes[meshpath]
return meshcontext.uniqueBCName(basename)
bcmenu.addItem(oofmenu.OOFMenuItem(
'New',
callback=_buildbc,
params=parameter.ParameterGroup(
parameter.AutomaticNameParameter('name',
value=automatic.automatic,
tip="Name of the new boundary condition",
resolver=bcnameResolver),
whoville.WhoParameter('mesh', ooflib.engine.mesh.meshes,
tip='Mesh to which to apply the boundary condition.'),
parameter.RegisteredParameter("condition", bdycondition.BC,
tip="The new boundary condition.")),
help='Create a new boundary condition.',
discussion=xmlmenudump.loadFile('DISCUSSIONS/engine/menu/new_bc.xml')
))
def _bcrename(menuitem, mesh, bc, name):
if parallel_enable.enabled():
boundaryconditionIPC.ipcbcmenu.Rename(mesh=mesh,bc=bc,name=name)
else:
meshcontext = ooflib.engine.mesh.meshes[mesh]
meshcontext.renameBdyCondition(bc, name)
finally:
meshctxt.end_writing()
switchboard.notify("new scheduled output", meshctxt, name)
outputmenu.addItem(
oofmenu.OOFMenuItem(
'New',
callback=_newOutput,
params=parameter.ParameterGroup(
whoville.WhoParameter(
'mesh',
ooflib.engine.mesh.meshes,
tip='Define an output operation on this mesh.'),
parameter.AutomaticNameParameter(
'name',
resolver=outputNameResolver,
value=automatic.automatic,
tip="A name for the new output operation."),
parameter.RegisteredParameter('output',
scheduledoutput.ScheduledOutput,
tip="The output operation.")) +
parameter.ParameterGroup(
parameter.RegisteredParameter(
'scheduletype',
outputschedule.ScheduleType,
tip='How to interpret the schedule.'),
outputschedule.OutputScheduleParameter(
'schedule', tip="When to produce the output.")) +
parameter.ParameterGroup(
outputdestination.OutputDestinationParameter(
if parallel_enable.enabled():
from ooflib.engine.IO import propertymenuIPC
propertymenuIPC.ipcpropmenu.Copy(property=property,new_name=new_name)
else:
try:
AllProperties.new_prop(property, new_name)
except ooferror.ErrUserError, e:
print e
OOF.Property.addItem(oofmenu.OOFMenuItem(
'Copy',
callback=_copywrapper,
params=parameter.ParameterGroup(
parameter.StringParameter('property', tip="Name of the source Property."),
parameter.RestrictedAutomaticNameParameter('new_name',
exclude=':',
resolver=propertyNameResolver,
value=automatic.automatic,
tip="Name for the new Property.")
),
help="Copy a Property.",
discussion="""<para>
Make a copy of an existing &property;, with the same parameters.
The source &property; can be a named &property; or one of the
predefined unnamed &properties;.
</para>"""))
def _deletewrapper(menuitem, property):
if parallel_enable.enabled():
basename = name
# Remove colons from the basename.
return ooflib.common.microstructure.microStructures.uniqueName(
basename.replace(':', '.'))
microstructuremenu.micromenu.addItem(
oofmenu.OOFMenuItem(
'Create_From_OrientationMap_File',
callback=_createMSFromOrientationMapFile,
params=parameter.ParameterGroup(
filenameparam.ReadFileNameParameter(
'filename', tip='Name of the Orientation Map file.'),
enum.EnumParameter('format',
orientmapdata.OrientMapType,
tip='Type of orientation map file.'),
parameter.AutomaticNameParameter(
'microstructure',
msOrientMapFileNameResolver,
automatic.automatic,
tip='Name of the new Microstructure.')),
help=
"Load an Orientation Map file and create a Microstructure from it.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/orientationmap/menu/create.xml')))
################
def _imageNameResolver(param, startname):
msname = labeltree.makePath(param.group['microstructure'].value)[0]
def parallel_buildbc(menuitem, name, mesh, condition):
condition.add_to_mesh(name, mesh)
switchboard.notify("mesh changed", ooflib.engine.mesh.meshes[mesh])
## OOF.LoadData.IPC.Boundary_Conditions.buildbc
ipcbcmenu.addItem(
oofmenu.OOFMenuItem(
'buildbc',
callback=parallel_buildbc,
threadable=oofmenu.PARALLEL_THREADABLE,
params=parameter.ParameterGroup(
parameter.StringParameter('name'),
whoville.WhoParameter(
'mesh',
ooflib.engine.mesh.meshes,
tip='Mesh to which to apply the boundary condition.'),
parameter.RegisteredParameter("condition",
bdycondition.BC,
tip="The new boundary condition."))))
def parallel_bcrename(menuitem, mesh, bc, name):
meshcontext = ooflib.engine.mesh.meshes[mesh]
meshcontext.renameBdyCondition(bc, name)
ipcbcmenu.addItem(
oofmenu.OOFMenuItem(
"Rename",
callback=parallel_bcrename,
else:
basename = 'material'
else:
basename = startname
return utils.uniqueName(basename, materialmanager.getMaterialNames())
#Interface branch
_materialmenu.addItem(
OOFMenuItem('New',
callback=_newmaterial,
params=parameter.ParameterGroup(
parameter.AutomaticNameParameter(
'name',
resolver=materialNameResolver,
value=automatic.automatic,
tip="Name of the material."),
enum.EnumParameter('material_type',
MaterialType,
value=MATERIALTYPE_BULK,
tip="Type of the material.")),
help="Create a new Material.",
discussion="""<para>
Create a new &material; containing no &properties;. If another
&material; with the same <varname>name</varname> already exists,
<userinput><x></userinput> will be appended to the new
<varname>name</varname>, where <userinput>x</userinput> is an
integer chosen to make the new name unique.
</para>"""))
# Rename an existing material.
# 'subproblem' is a SubProblemType instance
subpobj = subproblem.create()
meshcontext.newSubProblem(subpobj, subproblem,
labeltree.makePath(mesh) + [name])
subproblemMenu.addItem(
oofmenu.OOFMenuItem(
'New',
callback=_new_subproblem,
threadable=oofmenu.THREADABLE,
params=parameter.ParameterGroup(
whoville.AutoWhoNameParameter('name',
value=automatic.automatic,
resolver=subproblemNameResolver,
tip="Name of the new SubProblem"),
SyncMeshParameter('mesh', tip=parameter.emptyTipString),
parameter.RegisteredParameter('subproblem',
subproblemtype.SubProblemType,
tip=parameter.emptyTipString)),
help="Define a new subproblem",
discussion="""<para>
Create a new &subproblem; in the given &mesh;. If the given name
is not unique in the &mesh;, <userinput><x></userinput> will
be appended to it, where <userinput>x</userinput> is an integer
chosen to make the name unique. </para>
"""))
#############
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
msobj = ooflib.common.microstructure.microStructures[msname].getObject()
interfacemsplugin = msobj.getPlugIn("Interfaces")
return utils.uniqueName(basename,
interfacemsplugin.getCurrentReservedNames())
_interfacemenu.addItem(
oofmenu.OOFMenuItem(
'New',
callback=_newInterfaceCB,
params=parameter.ParameterGroup(
whoville.WhoParameter('microstructure',
ooflib.common.microstructure.microStructures,
tip=parameter.emptyTipString),
parameter.AutomaticNameParameter('name',
resolver=interfaceNameResolver,
value=automatic.automatic,
tip="Name of the interface."),
parameter.RegisteredParameter('interface_type',
interfaceplugin.InterfaceDef,
tip=parameter.emptyTipString)),
help="Create a named interface in a Microstructure.",
discussion="""<para>
Create an interface definition with the given name in the µs;.
This action should trigger a rebuild of the &mesh;,
if it exists.
</para>"""))
def _renameCB(menuitem, microstructure, interface, name):
msobj = ooflib.common.microstructure.microStructures[
immidge.sizeInPixels(),
immidge.size())
newimagecontext = oofimage.imageContexts.add([msname, immidge.name()],
immidge,
parent=ooflib.common.microstructure.microStructures[msname])
ms.addImage(newimagecontext)
imenu.addItem(oofmenu.OOFMenuItem(
'Create_From_Image_Parallel',
callback = createMSFromImage_Parallel,
secret = 1,
no_log = 1,
threadable = oofmenu.PARALLEL_THREADABLE,
params = parameter.ParameterGroup(
parameter.AutomaticNameParameter('msname', imagemenu.msImageNameResolver,
automatic.automatic,
tip="Name of the new Microstructure."),
parameter.StringParameter('image'))
))
#####################################
def createImage(msname, imagename, origin=0):
if _rank == origin:
image = oofimage.getImage([msname, imagename])
destinations = range(1,_size)
oofimage.Send_Image(image, destinations)
else:
image = oofimage.Recv_Image(origin)
return image
for n in notifications:
switchboard.notify(*n)
ipcmeshmenu.addItem(
oofmenu.OOFMenuItem(
'Copy',
callback=copyMesh_parallel,
threadable=oofmenu.PARALLEL_THREADABLE,
params=parameter.ParameterGroup(
whoville.WhoParameter('mesh',
ooflib.engine.mesh.meshes,
tip=parameter.emptyTipString),
parameter.StringParameter('name'),
parameter.BooleanParameter('copy_field',
value=1,
tip='Copy fields?'),
parameter.BooleanParameter('copy_equation',
value=1,
tip='Copy equation?'),
parameter.BooleanParameter('copy_bc',
value=1,
tip='Copy boundary conditions?'))))
########################################################################
# Field (Define/Undefine, Activate/Deactivate, In_Plane/Out_of_Plane)
########################################################################
## OOF.LoadData.IPC.Field
ipcfieldmenu = parallelmainmenu.ipcmenu.addItem(
oofmenu.OOFMenuItem('Field', secret=1, no_log=1))
finally:
meshctxt.end_writing()
switchboard.notify("new scheduled output", meshctxt, name)
outputmenu.addItem(
oofmenu.OOFMenuItem(
'New',
callback=_newOutput,
params=parameter.ParameterGroup(
whoville.WhoParameter(
'mesh',
ooflib.engine.mesh.meshes,
tip='Define an output operation on this mesh.'),
parameter.AutomaticNameParameter(
'name',
resolver=outputNameResolver,
value=automatic.automatic,
tip="A name for the new output operation."),
parameter.RegisteredParameter('output',
scheduledoutput.ScheduledOutput,
tip="The output operation.")),
help=
"Create an output operation to be performed during a time evolution.",
discussion=xmlmenudump.loadFile(
'DISCUSSIONS/engine/menu/newschedout.xml')))
outputIOmenu.addItem(
outputmenu.New.clone(
discussion="<para>Used internally in data files.</para>"))
else:
basename = startname
msname = param.group['microstructure'].value
ms = ooflib.common.microstructure.getMicrostructure(msname)
return ms.uniqueGroupName(basename)
pixgrpmenu.addItem(
OOFMenuItem(
'New',
callback=newPixelGroup,
params=parameter.ParameterGroup(
AutomaticNameParameter('name',
value=automatic.automatic,
resolver=pixelGroupNameResolver,
tip="Group name."),
whoville.WhoParameter(
'microstructure',
whoville.getClass('Microstructure'),
tip="Microstructure in which to create this PixelGroup.")),
help='Create a new PixelGroup in the given Microstructure.',
discussion="""<para>
Create a new &pixelgroup;. The <varname>name</varname> of the
group must be unique within the µ. If it is not unique, a
suffix of the form <userinput><x></userinput> will be
appended, for some integer <userinput>x</userinput>.
</para>"""))
##########################
if newness:
switchboard.notify("new pixel group", grp)
return grp
reporter.report("Failed to create group", name, "in microstructure",
microstructure)
ipcpixgrpmenu.addItem(
OOFMenuItem(
'New',
callback=newPixelGroup_parallel,
threadable=oofmenu.PARALLEL_THREADABLE,
params=parameter.ParameterGroup(
StringParameter('name', tip="Group name."),
whoville.WhoParameter(
'microstructure',
whoville.getClass('Microstructure'),
tip="Microstructure in which to create this PixelGroup.")),
help='Create a new PixelGroup in the given Microstructure.',
discussion="""<para>
Create a new &pixelgroup;. The <varname>name</varname> of the
group must be unique within the µ. If it is not unique, a
suffix of the form <userinput><x></userinput> will be
appended, for some integer <userinput>x</userinput>.
</para>"""))
##########################
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,
params=[
