def detectedSoftware(all=True):
"""Return a dict with all detected helper software"""
if all:
checkAllModules()
checkAllExternals()
system, host, release, version, arch = os.uname()
soft = {
'System':
OrderedDict([
('pyFormex_version', the_version['pyformex']),
('pyFormex_installtype', pf.installtype),
('pyFormex_fullversion', pf.fullVersion()),
('pyFormex_libraries', ', '.join(Libraries())),
('pyFormex_shaders', ', '.join(Shaders())),
('Python_version', the_version['python']),
('Python_fullversion', sys.version.replace('\n', ' ')),
('System', system),
('Host', host),
('Release', release),
('Version', version),
('Arch', arch),
]),
'Modules':
the_version,
'Externals':
the_external,
}
return soft
def odict(self):
"""Return the currently selected items as a dictionary.
Returns an OrderedDict with the currently selected objects in the order
of the selection.names.
"""
return OrderedDict(zip(self.names, self.check(warn=False)))
def Finalize(self):
self.nid = inverseUniqueIndex(self.nodid)
for k in self.elems.iterkeys():
v = asarray(self.elems[k])
self.elems[k] = asarray(self.nid[v])
self.modeldone = True
# we use lists, to keep the cases in order
self.res = OrderedDict()
self.step = None
self.inc = None
def __init__(self, title='AMenu', parent=None, before=None, items=None):
"""Create a menu."""
self._title = title
pf.debug("Creating menu %s" % title, pf.DEBUG.MENU)
self.parent = parent
self.separators = OrderedDict()
self._actions_ = []
self._submenus_ = []
if items:
self.insertItems(items)
if parent and isinstance(parent, BaseMenu):
before = parent.action(before)
parent.insert_menu(self, before)
def Increment(self, step, inc, **kargs):
"""Add a new step/increment to the database.
This method can be used to add a new increment to an existing step,
or to add a new step and set the initial increment, or to just select
an existing step/inc combination.
If the step/inc combination is new, a new empty result record is created.
The result record of the specified step/inc becomes the current result.
"""
if not self.modeldone:
self.Finalize()
if step != self.step:
if step not in self.res.keys():
self.res[step] = OrderedDict()
self.step = step
self.inc = None
res = self.res[self.step]
if inc != self.inc:
if inc not in res.keys():
res[inc] = {}
self.inc = inc
self.R = self.res[self.step][self.inc]
def run():
global image, scaled_image, viewer
flat()
lights(False)
transparent(False)
view('front')
# default image file
filename = getcfg('datadir') + '/butterfly.png'
image = None
scaled_image = None
w, h = 200, 200
# image viewer widget
viewer = ImageView(filename)
transforms = OrderedDict([
('flat', lambda F: F),
('cylindrical', lambda F: F.cylindrical(
[2, 0, 1], [2., 90. / float(nx), 1.]).rollAxes(-1)),
('spherical',
lambda F: F.spherical(scale=[1., 90. / float(nx), 2.]).rollAxes(-1)),
('projected_on_cylinder', lambda F: F.projectOnCylinder(2 * R, 1)),
])
res = askItems([
_I('filename',
filename,
text='Image file',
itemtype='button',
func=selectImage),
viewer, # image previewing widget
_I('nx', w, text='width'),
_I('ny', h, text='height'),
_I('transform', itemtype='vradio', choices=transforms.keys()),
])
if not res:
return
globals().update(res)
if image is None:
print("Loading image")
loadImage(filename)
if image is None:
return
# Create the colors
sz = image.size()
print("Image size is (%s,%s)" % (sz.width(), sz.height()))
color, colortable = qimage2glcolor(image.scaled(nx, ny))
print("Converting image to color array")
# Create a 2D grid of nx*ny elements
print("Creating grid")
R = float(nx) / pi
L = float(ny)
F = Formex('4:0123').replic2(nx, ny).centered()
F = F.translate(2, R)
# Transform grid and draw
def drawTransform(transform):
print("Transforming grid")
trf = transforms[transform]
G = trf(F)
clear()
print("Drawing Colored grid")
draw(G, color=color, colormap=colortable)
drawText('Created with pyFormex', (20, 20), size=24)
drawTransform(transform)
zoomAll()
limas = OrderedDict([
('Dragon Curve', ["F", {
"F": "F+G",
"G": "F-G"
}, 10, turtlecmds()]),
('Koch Line', ["F", {
"F": "F*F//F*F"
}, 6, turtlecmds()]),
('rule2', ["F+F+F+F", {
"F": "FF+FF--FF+F"
}, 4, turtlecmds()]),
('rule3', ["F+F+F+F", {
"F": "FF+F+F-F+FF"
}, 4, turtlecmds()]),
('Koch Snowflake', ["F//F//F", {
"F": "F*F//F*F"
}, 5, turtlecmds()]),
('rule4', ["F+F+F+F", {
"F": "FF+F++F+F"
}, 4, turtlecmds()]),
('rule5', ["F+F+F+F", {
"F": "FF+F+F+F+F+F-F"
}, 4, turtlecmds()]),
('Hilbert Curve',
["X", {
"X": "-YF+XFX+FY-",
"Y": "+XF-YFY-FX+"
}, 5, turtlecmds()]),
('Greek Cross Curve',
["F+XF+F+XF", {
"X": "XF-F+F-XF+F+XF-F+F-X"
}, 4, turtlecmds()]),
('Peano Curve', [
"X", {
"X": "XFYFX+F+YFXFY-F-XFYFX",
"Y": "YFXFY-F-XFYFX+F+YFXFY"
}, 4,
turtlecmds()
]),
('Gosper Curve', [
"XF", {
"X": "X*YF**YF/FX//FXFX/YF*",
"Y": "/FX*YFYF**YF*FX//FX/Y"
}, 4,
turtlecmds()
]),
('Sierpinski Triangle',
["F**F**F", {
"F": "F*J++F**F",
"J": "JJ"
}, 6, turtlecmds()]),
('Sierpinski Triangle1',
["F", {
"F": "*G/F/G*",
"G": "/F*G*F/"
}, 8, turtlecmds()]),
('Sierpinski Carpet',
["F+F+F+F", {
"F": "JF+F+F+F+JF+F+F+F+J",
"J": "JJJ"
}, 3,
turtlecmds()]),
('Gosper Island', [
"F*F*F*F*F*F", {
"F": "+F/F*F-"
}, 5,
turtlecmds({
'+': 'ro(20);',
'-': 'ro(-20);'
})
]),
('Gosper Island Tiling', [
"F*F*F*F*F*F/F/F/F/F/F*F*F*F*F*F", {
"F": "+F/F*F-"
}, 4,
turtlecmds({
'+': 'ro(20);',
'-': 'ro(-20);'
})
]),
('Plant0', [
"+F", {
"F": "F[*F]F[/F]F"
}, 5,
turtlecmds({
'*': 'ro(25);',
'/': 'ro(-25);'
})
]),
('Plant1', [
"+Y", {
"Y": "YFX[*Y][/Y]",
"X": "[/F][*F]FX"
}, 7,
turtlecmds({
'*': 'ro(25);',
'/': 'ro(-25);'
})
]),
('Breezy Bush', [
"+F", {
"F": "FF[//F*F*F][*F/F/F]"
}, 4,
turtlecmds({
'*': 'ro(22.55);',
'/': 'ro(-22.5);'
})
]),
('Islands and Lakes', [
"F-F-F-F", {
"F": "F-J+FF-F-FF-FJ-FF+J-FF+F+FF+FJ+FFF",
"J": "JJJJJJ"
}, 2,
turtlecmds()
]),
('Hexagones', [
"F*F*F*F*F*F", {
"F": "[//J*G*F*G]J",
"G": "[//K*G*F*G]J"
}, 5,
turtlecmds()
]),
('Lace', ["F+F", {
"F": "F*FF**F**FF*F"
}, 4, turtlecmds()]),
('rule19', [
"F++F", {
"F": "*F//F*"
}, 10,
turtlecmds({
'*': 'ro(30);',
'/': 'ro(-30);'
})
]),
('rule20', [
"F+F+F+F", {
"F": "*F//G*",
"G": "/F**G/"
}, 8,
turtlecmds({
'*': 'ro(30);',
'/': 'ro(-30);'
})
]),
('rule21', [
"G+G+G+G", {
"F": "*F//G*",
"G": "/F**G/"
}, 8,
turtlecmds({
'*': 'ro(30);',
'/': 'ro(-30);'
})
]),
('Grass', [
"***X", {
"F": "FF",
"X": "F*[[X]/X]/F[/FX]*X"
}, 6,
turtlecmds({
'*': 'ro(25);',
'/': 'ro(-25);'
})
]),
# (rule22', [ "+F", {"F":"GH", "G":"GG", "H":"G[*F][/F]"}, 12, turtlecmds({'*':'ro(22.5);','/':'ro(-22.5);'}) ]),
# (rule23', [ "F", {"F":"*F-F*"}, 12, turtlecmds({'*':'ro(45);'}) ]),
# (rule24', [ "JF", {"F":"*F-FF+F*","J":"/J"}, 8, turtlecmds({'*':'ro(45);','/':'ro(-45);'}) ]),
# (rule25', [ "F", {"F":"F-F++F-F"}, 4, turtlecmds() ]),
])
result_types = OrderedDict([
('', 'None'),
('U0', 'X-Displacement'),
('U1', 'Y-Displacement'),
('U2', 'Z-Displacement'),
('U', '[Displacement]'),
('S0', 'X-Normal Stress'),
('S1', 'Y-Normal Stress'),
('S2', 'Z-Normal Stress'),
('S3', 'XY-Shear Stress'),
('S4', 'XZ-Shear Stress'),
('S5', 'YZ-Shear Stress'),
('SP0', '1-Principal Stress'),
('SP1', '2-Principal Stress'),
('SP2', '3-Principal Stress'),
('SF0', 'x-Normal Membrane Force'),
('SF1', 'y-Normal Membrane Force'),
('SF2', 'xy-Shear Membrane Force'),
('SF3', 'x-Bending Moment'),
('SF4', 'y-Bending Moment'),
('SF5', 'xy-Twisting Moment'),
('SINV0', 'Mises Stress'),
('SINV1', 'Tresca Stress'),
('SINV2', 'Hydrostatic Pressure'),
('SINV6', 'Third Invariant'),
('COORD0', 'X-Coordinate'),
('COORD1', 'Y-Coordinate'),
('COORD2', 'Z-Coordinate'),
('Computed', 'Distance from a point'),
])
def __str__(self):
return self.__name__
@classmethod
def __repr__(self):
return "elementType(%s)" % self.__name__
@classmethod
def report(self):
return "ElementType %s: ndim=%s, nplex=%s, nedges=%s, nfaces=%s" % (
self.__name__, self.ndim, self.nplex(), self.nedges(),
self.nfaces())
# all registered element types:
_registered_element_types = OrderedDict()
def createElementType(name,
doc,
ndim,
vertices,
edges=('', []),
faces=('', []),
**kargs):
name = name.capitalize()
if name in _registered_element_types:
raise ValueError("Element type %s already exists" % name)
#print "\n CREATING ELEMENT TYPE %s\n" % name
def setPalette(colors):
global palette
palette = OrderedDict([ (k, GLcolor(k)) for k in colors ])
blue = (0.0, 0.0, 1.0)
cyan = (0.0, 1.0, 1.0)
magenta = (1.0, 0.0, 1.0)
yellow = (1.0, 1.0, 0.0)
white = (1.0, 1.0, 1.0)
darkred = (0.5, 0.0, 0.0)
darkgreen = (0.0, 0.5, 0.0)
darkblue = (0.0, 0.0, 0.5)
darkcyan = (0.0, 0.5, 0.5)
darkmagenta = (0.5, 0.0, 0.5)
darkyellow = (0.5, 0.5, 0.0)
pyformex_pink = (1.0, 0.2, 0.4)
lightlightgrey = grey(0.9)
lightgrey = grey(0.8)
mediumgrey = grey(0.6)
darkgrey = grey(0.4)
def setPalette(colors):
global palette
palette = OrderedDict([ (k, GLcolor(k)) for k in colors ])
# Set default palette
# !! THIS IS CURRENTLY NOT USED YET
palette = OrderedDict([ (k, globals()[k]) for k in ['darkgrey', 'red', 'green', 'blue', 'cyan', 'magenta', 'yellow', 'white', 'black', 'darkred', 'darkgreen', 'darkblue', 'darkcyan', 'darkmagenta', 'darkyellow', 'lightgrey'] ])
# End
def add_field(self, field):
"""_Low level function to add a Field"""
if not hasattr(self, '_fields'):
self._fields = OrderedDict()
self._fields[field.fldname] = field
def read(self,count=-1,warn_version=True):
"""Read objects from a pyFormex Geometry File.
This function reads objects from a Geometry File until the file
ends, or until `count` objects have been read.
The File should have been opened for reading.
A count may be specified to limit the number of objects read.
Returns a dict with the objects read. The keys of the dict are the
object names found in the file. If the file does not contain
object names, they will be autogenerated from the file name.
Note that PGF files of version 1.0 are no longer supported.
The use of formats 1.1 to 1.5 is deprecated, and users are
urged to upgrade these files to a newer format. Support for
these formats may be removed in future.
"""
if self.writing:
print("File is opened for writing, not reading.")
return {}
self.results = OrderedDict()
self.geometry = None # used to make sure fields follow geom block
if Version(self.version) < Version('1.6'):
if warn_version:
pf.warning("This is an old PGF format (%s). We recommend you to convert it to a newer format. The geometry import menu contains an item to upgrade a PGF file to the latest format (%s)." % (self.version,GeometryFile._version_))
return self.readLegacy(count)
while True:
s = self.fil.readline()
if len(s) == 0: # end of file
break
if s.startswith('#'):
# Remove the leading '#' and space
s = s[1:].strip()
if s.startswith('objtype'):
if count > 0 and len(self.results) >= count:
break
self.readGeometry(**self.decode(s))
elif s.startswith('field'):
self.readField(**self.decode(s))
elif s.startswith('attrib'):
self.readAttrib(**self.decode(s))
elif s.startswith('pyFormex Geometry File'):
# we have a new header line
self.readHeader(s)
# Unrecognized lines are silently ignored, whether starting
# with a '#' or not.
# We recommend to start all comments lines with a '#' though.
self.file.close()
return self.results
from pyformex import simple
import re
linewidth(2)
clear()
rfuncs = [
'linear (Archimedes)',
'quadratic',
'exponential (equi-angular)',
'constant',
# 'custom',
]
# Define a dictionary of planar cross sections
cross_sections = OrderedDict()
# select the planar patterns from the simple module
for cs in simple.Pattern:
if re.search('[a-zA-Z]', simple.Pattern[cs][2:]) is None:
cross_sections[cs] = simple.Pattern[cs]
# add some more patterns
cross_sections.update({
'channel': 'l:1223',
'H-beam': 'l:11/322/311',
'sigma': 'l:16253',
'Z-beam': 'l:353',
'octagon': 'l:15263748',
'swastika': 'l:12+23+34+41',
'solid_square': '4:0123',
'solid_triangle': '3:012',
'swastika3': '3:012023034041',
ShadesOfGrey,
RunningInCircles,
HowManyColors,
AlignedLines,
ParallelLinesOverWheel,
MotionInducedBlindness,
## FlickerInducedBlindness,
SineWave,
CirclesAndLines,
Crater,
Cussion,
CrazyCircles,
]
headers = [getattr(f, '__doc__').split('\n')[0] for f in illusions]
method = OrderedDict(zip(headers, illusions))
# Dialog Actions
def close():
"""Close the dialog"""
global dialog, explanation
if dialog:
pf.PF[gdname] = dialog.results
dialog.close()
dialog = None
if explanation:
explanation.close()
explanation = None
# Release script lock
deleteAll()
return model is None
################# Add properties ######################
# Plane stress element types for Abaqus
abq_eltype = {
'quad4': 'CPS4',
'quad8': 'CPS8',
'quad9': 'CPS9',
}
material = OrderedDict([
('name', 'steel'),
('young_modulus', 207000),
('poisson_ratio', 0.3),
('density', 7.85e-9),
])
section = OrderedDict([
('name', 'thin steel plate'),
('sectiontype', 'solid'),
('thickness', 1.0),
('material', 'steel'),
])
def setMaterial():
"""Set the material"""
global section, material
if not checkModel():
return