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 = ODict()
self.step = None
self.inc = None
def readHeader(self):
"""Read the header of a pyFormex geometry file.
"""
sep = ' '
s = self.fil.readline()
if s.startswith('# Formex'):
version = '1.1'
elif s.startswith('# pyFormex Geometry File'):
pos = s.rfind(')')
exec(s[pos + 1:].strip())
else:
version = None
raise RuntimeError, "This does not look like a pyFormex geometry file, or it is a very old version."
self._version_ = version
self.sep = sep
self.objname = utils.NameSequence('%s_000' %
utils.projectName(self.fil.name))
self.results = ODict()
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] = ODict()
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 __init__(self, i, body=False):
self.data = ODict()
while True:
# escape or continue?
while True:
nc = i.char()
if is_whitespace(nc):
#print('waspay', nc)
continue # look for non-whitespace
elif nc == ('}' if not body else '\0'):
#print('bai', nc)
return
else:
###print('kay', nc)
i.rollback()
break
#print("wat")
# key
k = TKey(i).data
#print(k)
if k in self.data:
raise TypeError('{0} already present: keys must be unqiue!')
# eat the '=' sign
while True:
nc = i.char()
if is_whitespace(nc):
continue
elif nc == KVP_SEPR:
break
else:
raise ValueError('expected "=" KVP separator')
self.data[k] = TValue(i).data
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 = ODict()
# 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',
'gts': ('gtsset -h', 'Usage(:) '),
'imagemagick': ('import -version', 'Version: ImageMagick (\S+)'),
'postabq': ('pyformex-postabq -V', 'postabq (\S+).*'),
'python': ('python --version', 'Python (\\S+)'),
'recordmydesktop': ('recordmydesktop --version', 'recordMyDesktop v(\S+)'),
'tetgen': ('tetgen -h |fgrep Version', 'Version (\S+)'),
'units': ('units --version', 'GNU Units version (\S+)'),
'vmtk': ('vmtk --help', 'Usage: vmtk(\S+).*'),
}
# Some regular expressions
digits = re.compile(r'(\d+)')
# versions of detected modules
the_version = ODict({
'pyformex': pf.__version__,
'python': sys.version.split()[0],
})
# versions of detected external commands
the_external = ODict({})
def checkVersion(name, version, external=False):
"""Checks a version of a program/module.
name is either a module or an external program whose availability has
been registered.
Default is to treat name as a module. Add external=True for a program.
Return value is -1, 0 or 1, depending on a version found that is
<, == or > than the requested values.
This should normally understand version numbers in the format 2.10.1
result_types = ODict([
('', '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'),
])
limas = ODict([
('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() ]),
])
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 = ODict()
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
ODict(
cool_dude="wat",
steven="collins",
hello="kitty,\" ?",
puppies='\\n\\n cute',
puppies_2="even more PuPpIeS",
tony_pepperony="522",
bloopers=
"5120\nasdsaf\n\tblah blah. there's quoites, so it doesn't care about \"white\" space???",
query=
"avg # of number of head kicks per karate tournament (this isn't a comment btw)",
things=[
"1", "2", "watlol", "xen_is_best", "no", "kvm", "me", "too",
"thanks", "whatever", "dude"
],
umm=[
"ahem", "excuse me", "thank's", "your welcome",
"beg your pardon"
],
perfect_system=dict(ayy="lmao",
can_hold="0",
why="????",
temperature="100.04",
those_one_guys_ya_know=[
dict(name="doge",
mean="sometimes",
rules="venice",
tryhard="0"),
dict(name="tony",
mean="very",
kicks="frequently",
tryhard="45"),
dict(
name="Unicorn Rodeo",
occupation="JAMES C. UNICORN",
tryhard="999",
mean="never",
)
])))
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 = ODict([
('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 = image2glcolor(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()
################# Add properties ######################
# Plane stress element types for Abaqus
abq_eltype = {
'quad4': 'CPS4',
'quad8': 'CPS8',
'quad9': 'CPS9',
}
def warn():
warning("You should first merge the parts!")
material = ODict([
('name','steel'),
('young_modulus',207000),
('poisson_ratio',0.3),
('density',7.85e-9),
])
section = ODict([
('name','thin steel plate'),
('sectiontype','solid'),
('thickness',1.0),
('material','steel'),
])
def setMaterial():
"""Set the material"""
global section,material
if model is None:
warn()
